tx · 2Qsrt9a5ETVQubeR9qp3F7mWn5gPu26DwEZdaLqFSBLQ

3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm:  -0.10700000 Waves

2023.10.09 18:22 [2791266] smart account 3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "2Qsrt9a5ETVQubeR9qp3F7mWn5gPu26DwEZdaLqFSBLQ",
    "fee": 10700000,
    "feeAssetId": null,
    "timestamp": 1696865017564,
    "version": 2,
    "chainId": 84,
    "sender": "3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm",
    "senderPublicKey": "EVooykMNV691Venwp1dHUTBd7KWequzUcda57Wd3LQEX",
    "proofs": [
        "5QBDo26Eudt6FyeCBMQgbvMxtQfVUsLtKt1ymQZpCgXr7SaepsXbbFKJD8VJ9Cfd3eAJL1yVMmP3pz1794xouEK7"
    ],
    "script": "base64:BgLhAQgCEgMKAQgSBAoCCAESAwoBBBIAEgMKAQgSABIDCgEIEgQKAgEIEgQKAgEIEgQKAgICEgUKAwEBARIAEgQKAggIEgASABIECgICAhIAEgMKAQgSBAoCCAgSAwoBGBIECgIICBIECgIICBIDCgEIEgMKARgSAwoBCBIFCgMICAgSBAoCCAgSBwoFAQEBAQESAwoBARIFCgMBAQgSAwoBCBIDCgEIEgASBAoCCAESBAoCCAESAwoBCBIECgIICBIDCgEIEgASAwoBCBIDCgEIEgMKAQgSBAoCAgISBAoCAgISAJwCAAlEQVlNSUxMSVMAgLiZKQEUa2V5TGFzdEFyYlRpbWVCeVVzZXIBBGFkZHIJAKwCAgIQbGFzdEFyYlRpbWVVc2VyXwUEYWRkcgAGU0NBTEU4AIDC1y8ADHhwTGV2ZWxTY2FsZQCAGQAPeHBMZXZlbFJlY2lwUG93AKAfABJudW1Qb2ludHNPbkxldmVsVXAAAwAOcm9iYmVyeUNvc3RNaW4AgMLXLwAUcm9iYmVyeUNvb2xkb3duQ29lZmYAkAMADHJlcXVpcmVtZW50cwkAzAgCAghTdHJlbmd0aAkAzAgCAghBY2N1cmFjeQkAzAgCAglJbnRlbGxlY3QJAMwIAgIJRW5kdXJhbmNlCQDMCAICCURleHRlcml0eQkAzAgCAgVMZXZlbAkAzAgCAgZIZWFsdGgFA25pbAAMY2hhclN0cmVuZ3RoAAAADGNoYXJBY2N1cmFjeQABAA1jaGFySW50ZWxsZWN0AAIADWNoYXJFbmR1cmFuY2UAAwANY2hhckRleHRlcml0eQAEAAtzZWdCYWNrcGFjawAAAAtOVU1TRUdNRU5UUwAGAApOVU1NQUlOQVVYAAIACE1BWFNMT1RTAAIADU1BWFBST0RJTlNMT1QAHgAQbGFuZFJvYkNvb2xkb3ducwkAzAgCAAAJAMwIAgDAzyQJAMwIAgCg9zYJAMwIAgCA3MwUCQDMCAIAgK6mCgUDbmlsAA5NSU5fUkVTX1RPX1JPQgCA2sQJAAxyb2JJZHhMb2NrZWQAAQALZHVja0lkeEZyZWUAAAAQZHVja0lkeFByZXBhcmluZwABAQ1rZXlEdWNrSGVhbHRoAQtkdWNrQXNzZXRJZAkArAICAgtkdWNrSGVhbHRoXwULZHVja0Fzc2V0SWQBDGtleUR1Y2tDaGFycwELZHVja0Fzc2V0SWQJAKwCAgIKZHVja0NoYXJzXwULZHVja0Fzc2V0SWQBCWtleUR1Y2tYUAELZHVja0Fzc2V0SWQJAKwCAgIHZHVja1hQXwULZHVja0Fzc2V0SWQBDGtleUR1Y2tMZXZlbAELZHVja0Fzc2V0SWQJAKwCAgIKZHVja0xldmVsXwULZHVja0Fzc2V0SWQBEWtleUR1Y2tGcmVlUG9pbnRzAQtkdWNrQXNzZXRJZAkArAICAg9kdWNrRnJlZVBvaW50c18FC2R1Y2tBc3NldElkARBrZXlEdWNrRXF1aXBtZW50AQtkdWNrQXNzZXRJZAkArAICAg5kdWNrRXF1aXBtZW50XwULZHVja0Fzc2V0SWQBCWtleVVzZXJYUAEEYWRkcgkArAICAgd1c2VyWFBfBQRhZGRyAQxrZXlVc2VyTGV2ZWwBBGFkZHIJAKwCAgIKdXNlckxldmVsXwUEYWRkcgERa2V5VXNlckZyZWVQb2ludHMBBGFkZHIJAKwCAgIPdXNlckZyZWVQb2ludHNfBQRhZGRyAQ5rZXlTYXZlZEhlYWx0aAELZHVja0Fzc2V0SWQJAKwCAgIMc2F2ZWRIZWFsdGhfBQtkdWNrQXNzZXRJZAEQa2V5U2F2ZWRMb2NhdGlvbgELZHVja0Fzc2V0SWQJAKwCAgIOc2F2ZWRMb2NhdGlvbl8FC2R1Y2tBc3NldElkAQxrZXlEdWNrQnVmZnMBC2R1Y2tBc3NldElkCQCsAgICCmR1Y2tCdWZmc18FC2R1Y2tBc3NldElkARhrZXlMYXN0Um9iYmVyeVRpbWVCeUR1Y2sBC2R1Y2tBc3NldElkCQCsAgICEGxhc3RSb2JiZXJ5VGltZV8FC2R1Y2tBc3NldElkARhrZXlMYXN0Um9iYmVyeUNvc3RCeUR1Y2sBC2R1Y2tBc3NldElkCQCsAgICEGxhc3RSb2JiZXJ5Q29zdF8FC2R1Y2tBc3NldElkARNrZXlMYW5kUm9iYmVyeVN0YXRlAQtsYW5kQXNzZXRJZAkArAICAhFsYW5kUm9iYmVyeVN0YXRlXwULbGFuZEFzc2V0SWQBEmtleUxhbmRDb29sZG93bkVUQQELbGFuZEFzc2V0SWQJAKwCAgIQbGFuZENvb2xkb3duRVRBXwULbGFuZEFzc2V0SWQBE2tleUR1Y2tSb2JiZXJ5U3RhdGUBC2R1Y2tBc3NldElkCQCsAgICEWR1Y2tSb2JiZXJ5U3RhdGVfBQtkdWNrQXNzZXRJZAETa2V5TG9ja2VkTGFuZEJ5RHVjawELZHVja0Fzc2V0SWQJAKwCAgIRbG9ja2VkTGFuZEJ5RHVja18FC2R1Y2tBc3NldElkARZrZXlEZWxpdmVyeURlbGF5QnlEdWNrAQtkdWNrQXNzZXRJZAkArAICAhRkZWxpdmVyeURlbGF5QnlEdWNrXwULZHVja0Fzc2V0SWQAB3hwQ2xhaW0AkE4AD3hwU3VjY2Vzc0ZsaWdodACQTgAMeHBGYWlsRmxpZ2h0ANAPAAh4cENhbGxFUwCgjQYADHhwQ3VzdG9tTmFtZQDAhD0ACnhwTmV3U0xhbmQAwJaxAgAOeHBVcGdyYWRlSW5mcmEAkE4AB3hwTWVyZ2UAwIQ9AAl4cE9uYm9hcmQAwIQ9AAZ4cEhlYWwAkE4BCWxldmVsQnlYUAECeHAJAGsDBQx4cExldmVsU2NhbGUJAGwGBQJ4cAAEBQ94cExldmVsUmVjaXBQb3cABAAEBQRET1dOBQZTQ0FMRTgBCW1heEhlYWx0aAEFbGV2ZWwJAGQCAGQFBWxldmVsAQdsZXZlbFVwAgljdXJyTGV2ZWwFbmV3WFAECG5ld0xldmVsCQEJbGV2ZWxCeVhQAQUFbmV3WFAJAMwIAgUIbmV3TGV2ZWwJAMwIAgkAaAIFEm51bVBvaW50c09uTGV2ZWxVcAkAZQIFCG5ld0xldmVsBQljdXJyTGV2ZWwFA25pbAEMZ2V0RHVja1N0YXRzBA9zdGFraW5nQ29udHJhY3QLZHVja0Fzc2V0SWQKYnVmZkVmZmVjdApmb3JjZUJ1ZmZzBAVjaGFycwkAtQkCCQELdmFsdWVPckVsc2UCCQCdCAIFD3N0YWtpbmdDb250cmFjdAkBDGtleUR1Y2tDaGFycwEFC2R1Y2tBc3NldElkAgkwXzBfMF8wXzACAV8EA2x2bAkBC3ZhbHVlT3JFbHNlAgkAmggCBQ9zdGFraW5nQ29udHJhY3QJAQxrZXlEdWNrTGV2ZWwBBQtkdWNrQXNzZXRJZAAABAZoZWFsdGgJAQt2YWx1ZU9yRWxzZQIJAJoIAgUPc3Rha2luZ0NvbnRyYWN0CQENa2V5RHVja0hlYWx0aAEFC2R1Y2tBc3NldElkCQEJbWF4SGVhbHRoAQUDbHZsBApzdGF0ZUJ1ZmZzCQC1CQIJAQt2YWx1ZU9yRWxzZQIJAJ0IAgUPc3Rha2luZ0NvbnRyYWN0CQEMa2V5RHVja0J1ZmZzAQULZHVja0Fzc2V0SWQCCTBfMF8wXzBfMAIBXwkAzggCCQDMCAIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQVjaGFycwUMY2hhclN0cmVuZ3RoCQDMCAIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQVjaGFycwUMY2hhckFjY3VyYWN5CQDMCAIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQVjaGFycwUNY2hhckludGVsbGVjdAkAzAgCCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUFY2hhcnMFDWNoYXJFbmR1cmFuY2UJAMwIAgkBDXBhcnNlSW50VmFsdWUBCQCRAwIFBWNoYXJzBQ1jaGFyRGV4dGVyaXR5CQDMCAIFA2x2bAkAzAgCBQZoZWFsdGgFA25pbAMFCmZvcmNlQnVmZnMJAMwIAgUKYnVmZkVmZmVjdAkAzAgCBQpidWZmRWZmZWN0CQDMCAIFCmJ1ZmZFZmZlY3QJAMwIAgUKYnVmZkVmZmVjdAkAzAgCBQpidWZmRWZmZWN0BQNuaWwJAMwIAgkBDXBhcnNlSW50VmFsdWUBCQCRAwIFCnN0YXRlQnVmZnMFDGNoYXJTdHJlbmd0aAkAzAgCCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUKc3RhdGVCdWZmcwUMY2hhckFjY3VyYWN5CQDMCAIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQpzdGF0ZUJ1ZmZzBQ1jaGFySW50ZWxsZWN0CQDMCAIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQpzdGF0ZUJ1ZmZzBQ1jaGFyRW5kdXJhbmNlCQDMCAIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQpzdGF0ZUJ1ZmZzBQ1jaGFyRGV4dGVyaXR5BQNuaWwBDmdldFJvYmJlcnlEYXRhAg9zdGFraW5nQ29udHJhY3QLZHVja0Fzc2V0SWQEC2xhc3RSb2JDb3N0CQELdmFsdWVPckVsc2UCCQCaCAIFD3N0YWtpbmdDb250cmFjdAkBGGtleUxhc3RSb2JiZXJ5Q29zdEJ5RHVjawEFC2R1Y2tBc3NldElkAAAEC2xhc3RSb2JUaW1lCQELdmFsdWVPckVsc2UCCQCaCAIFD3N0YWtpbmdDb250cmFjdAkBGGtleUxhc3RSb2JiZXJ5VGltZUJ5RHVjawEFC2R1Y2tBc3NldElkAAAEA25vdwgFCWxhc3RCbG9jawl0aW1lc3RhbXAEB3JvYkNvc3QJAJYDAQkAzAgCBQ5yb2JiZXJ5Q29zdE1pbgkAzAgCCQBlAgULbGFzdFJvYkNvc3QJAGgCBRRyb2JiZXJ5Q29vbGRvd25Db2VmZgkAZQIFA25vdwULbGFzdFJvYlRpbWUFA25pbAQJZHVja1N0YXRlCQELdmFsdWVPckVsc2UCCQCaCAIFD3N0YWtpbmdDb250cmFjdAkBE2tleUR1Y2tSb2JiZXJ5U3RhdGUBBQtkdWNrQXNzZXRJZAAABApsb2NrZWRMYW5kCQELdmFsdWVPckVsc2UCCQCdCAIFD3N0YWtpbmdDb250cmFjdAkBE2tleUxvY2tlZExhbmRCeUR1Y2sBBQtkdWNrQXNzZXRJZAIABAdsYW5kRVRBCQELdmFsdWVPckVsc2UCCQCaCAIFD3N0YWtpbmdDb250cmFjdAkBEmtleUxhbmRDb29sZG93bkVUQQEFCmxvY2tlZExhbmQAAAkAlwoFBQdyb2JDb3N0BQtsYXN0Um9iVGltZQUJZHVja1N0YXRlBQpsb2NrZWRMYW5kBQdsYW5kRVRBAApMQU5EUFJFRklYAgRMQU5EAApEVUNLUFJFRklYAgREVUNLAApBUlRQUkVTQUxFAgdQUkVTQUxFAAZOVU1SRVMABgAYTUFYX0xBTkRTX1NUQUtFRF9CWV9VU0VSABkAD0RBSUxZUkVTQllQSUVDRQCA+NIBAAxXSE1VTFRJUExJRVIAgMivoCUAD0RFRkFVTFRMT0NBVElPTgIPQWZyaWNhX0ZfQWZyaWNhABBSRVNPVVJDRVBSSUNFTUlOANW1AgAKRVNTRUxMQ09FRgAKABVNSU5fVVNEVF9GRUVfREVMSVZFUlkA0IYDABJURU5fTUlOVVRFU19NSUxMSVMAwM8kAAlwcm9kVHlwZXMJAMwIAgIQRmlyc3QgQWlkIEtpdCBMMQkAzAgCAhBGaXJzdCBBaWQgS2l0IEwyCQDMCAICEEZpcnN0IEFpZCBLaXQgTDMJAMwIAgILQmFja3BhY2sgTDEJAMwIAgILQmFja3BhY2sgTDIJAMwIAgILQmFja3BhY2sgTDMJAMwIAgIORm9vZCBSYXRpb24gTDEJAMwIAgIORm9vZCBSYXRpb24gTDIJAMwIAgIORm9vZCBSYXRpb24gTDMJAMwIAgILSmV0IFBhY2sgTDEJAMwIAgILSmV0IFBhY2sgTDIJAMwIAgILSmV0IFBhY2sgTDMJAMwIAgIJU2hpZWxkIEwxCQDMCAICCVNoaWVsZCBMMgkAzAgCAglTaGllbGQgTDMJAMwIAgIHTWluZSBMMQkAzAgCAgdNaW5lIEwyCQDMCAICB01pbmUgTDMJAMwIAgIHVHJhcCBMMQkAzAgCAgdUcmFwIEwyCQDMCAICB1RyYXAgTDMFA25pbAAKY29udGluZW50cwkAzAgCAghBbWVyaWNhcwkAzAgCAgZFdXJvcGUJAMwIAgIEQXNpYQkAzAgCAgZBZnJpY2EJAMwIAgIHT2NlYW5pYQUDbmlsAAlDT0VGRjJNQVQAgK3iBAAQZm9ydEFsbG93ZWRQcm9kcwkAzAgCAA8JAMwIAgAQCQDMCAIAEQkAzAgCABIJAMwIAgATCQDMCAIAFAUDbmlsABBwcm9kdWN0aW9uTWF0cml4CQDMCAICJThfOF84XzE3XzE3XzQyXzEyXzBfMzBfMCwwLDAsMCwwLDAsMF8JAMwIAgIlOF84XzhfMTdfMTdfNDJfMjRfMF82MF8wLDAsNSwyLDAsMCwwXwkAzAgCAic4XzhfOF8xN18xN180Ml8zNl8wXzEyMF8wLDAsMTAsNCwwLDAsMF8JAMwIAgIpOF8xOV8xOV84XzI3XzE5XzI2XzFfMjBfMCwwLDAsMCwwLDAsMF8wMDEJAMwIAgIpOF8xOV8xOV84XzI3XzE5XzUyXzFfNDBfMCwwLDAsMCwwLDAsMF8wMDEJAMwIAgIpOF8xOV8xOV84XzI3XzE5Xzc4XzFfODBfMCwwLDAsMCwwLDAsMF8wMDEJAMwIAgIlOF84XzhfOF84XzYwXzEzXzJfMl8wLDAsMCwwLDAsMCwwXzAxMQkAzAgCAiU4XzhfOF84XzhfNjBfMjZfMl80XzAsMCwwLDAsMCwwLDBfMDExCQDMCAICJThfOF84XzhfOF82MF8zOV8yXzhfMCwwLDAsMCwwLDAsMF8wMTEJAMwIAgIpMzBfMzBfM18xN18xN18zXzMwXzNfMzBfMCwwLDAsMCwwLDAsMF8xMTEJAMwIAgIpMzBfMzBfM18xN18xN18zXzYwXzNfNTBfMCwwLDAsMCwwLDAsMF8xMTEJAMwIAgIpMzBfMzBfM18xN18xN18zXzkwXzNfNzBfMCwwLDAsMCwwLDAsMF8xMTEJAMwIAgIrMThfMThfMTBfMThfMThfMThfMTFfNF8xMF8wLDAsMCwwLDAsMCwwXzIwMQkAzAgCAisxOF8xOF8xMF8xOF8xOF8xOF8yMl80XzIwXzAsMCwwLDAsMCwwLDBfMjAxCQDMCAICKzE4XzE4XzEwXzE4XzE4XzE4XzMzXzRfMzBfMCwwLDAsMCwwLDAsMF8yMDEJAMwIAgIqNF8xM18yMl80XzM1XzIyXzIzXzBfNTAsMSwwXzAsMCwwLDAsMCwwLDBfCQDMCAICKjRfMTNfMjJfNF8zNV8yMl80Nl8wXzUwLDEsMV8wLDIsNSwwLDAsMCwwXwkAzAgCAis0XzEzXzIyXzRfMzVfMjJfNjlfMF81MCwyLDFfMCw1LDEwLDAsMCwwLDBfCQDMCAICKjVfMjVfNDBfNV8xMF8xNV8yMF8xXzMwLDEsMV8wLDAsMCwwLDAsMCwwXwkAzAgCAio1XzI1XzQwXzVfMTBfMTVfNDBfMV8zMCwxLDJfMiwxLDMsMCwwLDAsMF8JAMwIAgIqNV8yNV80MF81XzEwXzE1XzYwXzFfMzAsMSwzXzUsMiw4LDAsMCwwLDBfBQNuaWwACXJJZHhDb2VmZgAGAApySWR4RWZmZWN0AAgAEHJJZHhSZXF1aXJlbWVudHMACQAJcklkeFNsb3RzAAoADlBST0RVQ1RQS0dTSVpFAAoAC3doSWR4TGV2ZWxzAAAACHdoSWR4UmVzAAEACHdoSWR4TWF0AAIACXdoSWR4UHJvZAADAAl3aElkeExPRlQABAAJdm9sTG9ja2VkAAAAC3ZvbE9jY3VwaWVkAAEAB3ZvbEZyZWUAAgAIdm9sVG90YWwAAwAKYnBJZHhMZXZlbAAAAAhicElkeFJlcwABAAhicElkeE1hdAACAAlicElkeFByb2QAAwAPbG9jSWR4Q29udGluZW50AAAACmxvY0lkeFR5cGUAAQAIbG9jSWR4SWQAAgEVa2V5TGFuZEFzc2V0SWRUb093bmVyAQdhc3NldElkCQCsAgICA25vXwUHYXNzZXRJZAEaa2V5TGFuZEFzc2V0SWRUb0N1c3RvbU5hbWUBB2Fzc2V0SWQJAKwCAgIFbGNuYV8FB2Fzc2V0SWQBFmtleVN0YWtlZFRpbWVCeUFzc2V0SWQBB2Fzc2V0SWQJAKwCAgIDc3RfBQdhc3NldElkASBrZXlMYW5kQXJ0U3RhdHVzQnlUeXBlQW5kQXNzZXRJZAIEdHlwZQdhc3NldElkCQC5CQIJAMwIAgIDbGFzCQDMCAIFBHR5cGUJAMwIAgUHYXNzZXRJZAUDbmlsAgFfASJrZXlTdGFrZWRUaW1lQnlUeXBlQXNzZXRJZEFuZE93bmVyAwduZnRUeXBlB2Fzc2V0SWQJb3duZXJBZGRyCQCsAgIJAKwCAgkArAICCQCsAgIJAKwCAgIGc3R0YW9fBQduZnRUeXBlAgFfBQdhc3NldElkAgFfBQlvd25lckFkZHIBEmtleVdhcmVob3VzZUJ5TGFuZAELbGFuZEFzc2V0SWQJAKwCAgIDd2hfBQtsYW5kQXNzZXRJZAEWa2V5SW5mcmFMZXZlbEJ5QXNzZXRJZAEHYXNzZXRJZAkArAICAgtpbmZyYUxldmVsXwUHYXNzZXRJZAEXa2V5Rm9ydGlmaWNhdGlvbnNCeUxhbmQBC2xhbmRBc3NldElkCQCsAgICD2ZvcnRpZmljYXRpb25zXwULbGFuZEFzc2V0SWQBGmtleUR1Y2tBc3NldElkVG9DdXN0b21OYW1lAQdhc3NldElkCQCsAgICGGR1Y2tDdXN0b21OYW1lQnlBc3NldElkXwUHYXNzZXRJZAEWa2V5QWRkcmVzc1RvQ3VzdG9tTmFtZQEEYWRkcgkArAICAhhhY2NvdW50Q3VzdG9tTmFtZUJ5QWRkcl8FBGFkZHIBD2tleUFkZHJlc3NSZWZCeQEEYWRkcgkArAICAglhY2NSZWZCeV8FBGFkZHIBHGtleU9uYm9hcmRBcnRBY3RpdmF0ZWRPbkR1Y2sBC2R1Y2tBc3NldElkCQCsAgICGm9uYm9hcmRBcnRBY3RpdmF0ZWRPbkR1Y2tfBQtkdWNrQXNzZXRJZAEca2V5T25ib2FyZEFydER1Y2tBY3RpdmF0ZWRCeQEEYWRkcgkArAICAhpvbmJvYXJkQXJ0QWN0aXZhdGVkRHVja0J5XwUEYWRkcgETa2V5QWRkcmVzc1JlZmVycmFscwEEYWRkcgkArAICAg1hY2NSZWZlcnJhbHNfBQRhZGRyARBrZXlEdWNrSWRUb093bmVyAQdhc3NldElkCQCsAgICCmR1Y2tPd25lcl8FB2Fzc2V0SWQBFGtleVN0YWtlZER1Y2tCeU93bmVyAQlvd25lckFkZHIJAKwCAgISc3Rha2VkRHVja0J5T3duZXJfBQlvd25lckFkZHIBEWtleUJhY2twYWNrQnlEdWNrAQtkdWNrQXNzZXRJZAkArAICAgliYWNrUGFja18FC2R1Y2tBc3NldElkAQ9rZXlEdWNrTG9jYXRpb24BC2R1Y2tBc3NldElkCQCsAgICDWR1Y2tMb2NhdGlvbl8FC2R1Y2tBc3NldElkARVrZXlVc2VyR3dsUmVsZWFzZVRpbWUBCHVzZXJBZGRyCQCsAgICGiVzJXNfX3VzZXJHd2xSZWxlYXNlVGltZV9fBQh1c2VyQWRkcgEOa2V5RXNXYXJlaG91c2UAAhplbWVyZ2VuY3lXYXJlaG91c2VQcm9kdWN0cwAPZGVsaXZlcnlGdW5kS2V5AgxkZWxpdmVyeUZ1bmQAEWRlbGl2ZXJ5TG9ja2VkS2V5Ag5kZWxpdmVyeUxvY2tlZAANbGFzdFRvdXJJZEtleQIOJXNfX2xhc3RUb3VySWQBFWtleVRvdXJTdGF0aWNEYXRhQnlJZAEDdElkCQCsAgICFiVzJWRfX3RvdXJTdGF0aWNEYXRhX18JAKQDAQUDdElkARZrZXlUb3VyRHluYW1pY0RhdGFCeUlkAQN0SWQJAKwCAgIXJXMlZF9fdG91ckR5bmFtaWNEYXRhX18JAKQDAQUDdElkARprZXlCZXN0UmVzdWx0QnlUb3VyQW5kRHVjawIDdElkC2R1Y2tBc3NldElkCQC5CQIJAMwIAgIfJXMlZCVzX19iZXN0UmVzdWx0QnlUb3VyQW5kRHVjawkAzAgCCQCkAwEFA3RJZAkAzAgCBQtkdWNrQXNzZXRJZAUDbmlsAgJfXwAJaWR4U3RhdGljAAAACmlkeER5bmFtaWMAAQAKdFN0YXRpY0VuZAAGAA50RHluYW1pY1N0YXR1cwABAQtnZXRUb3VyRGF0YQIMdG91ckNvbnRyYWN0A3RJZAQGc3RhdGljCQC1CQIJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAnQgCBQx0b3VyQ29udHJhY3QJARVrZXlUb3VyU3RhdGljRGF0YUJ5SWQBBQN0SWQJAKwCAgkArAICAhlFcnJvciByZWFkaW5nIHRvdXJuYW1lbnQgCQCkAwEFA3RJZAIFIGRhdGECAl9fBAdkeW5hbWljCQC8CQIJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAnQgCBQx0b3VyQ29udHJhY3QJARZrZXlUb3VyRHluYW1pY0RhdGFCeUlkAQUDdElkCQCsAgIJAKwCAgIZRXJyb3IgcmVhZGluZyB0b3VybmFtZW50IAkApAMBBQN0SWQCBSBkYXRhAgJfXwkAzAgCBQZzdGF0aWMJAMwIAgUHZHluYW1pYwUDbmlsAQ5pc0luVG91cm5hbWVudAIMdG91ckNvbnRyYWN0CGxvY2F0aW9uBAZsYXN0SWQJAQt2YWx1ZU9yRWxzZQIJAJoIAgUMdG91ckNvbnRyYWN0BQ1sYXN0VG91cklkS2V5AAAEA2xvYwkAtQkCBQhsb2NhdGlvbgIBXwQDbm93CAUJbGFzdEJsb2NrCXRpbWVzdGFtcAQFdERhdGEJAQtnZXRUb3VyRGF0YQIFDHRvdXJDb250cmFjdAUGbGFzdElkBAZzdGF0aWMJAJEDAgUFdERhdGEFCWlkeFN0YXRpYwQHZHluYW1pYwkAkQMCBQV0RGF0YQUKaWR4RHluYW1pYwMDAwkAAAIJAJEDAgUDbG9jBQpsb2NJZHhUeXBlAgFUCQAAAgkBDXBhcnNlSW50VmFsdWUBCQCRAwIFA2xvYwUPbG9jSWR4Q29udGluZW50BQZsYXN0SWQHCQAAAgkAkQMCBQdkeW5hbWljBQ50RHluYW1pY1N0YXR1cwIKSU5QUk9HUkVTUwcJAGYCCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUGc3RhdGljBQp0U3RhdGljRW5kBQNub3cHAQxpc0luRGVsaXZlcnkBCGxvY2F0aW9uBANsb2MJALUJAgUIbG9jYXRpb24CAV8EA25vdwgFCWxhc3RCbG9jawl0aW1lc3RhbXAECXN0YXJ0VGltZQkBDXBhcnNlSW50VmFsdWUBCQCRAwIFA2xvYwUPbG9jSWR4Q29udGluZW50BAhkaXN0YW5jZQkBDXBhcnNlSW50VmFsdWUBCQCRAwIFA2xvYwUIbG9jSWR4SWQDAwkAAAIJAJEDAgUDbG9jBQpsb2NJZHhUeXBlAgFECQBmAgUDbm93CQBkAgUJc3RhcnRUaW1lBRJURU5fTUlOVVRFU19NSUxMSVMHCQBnAgADBQhkaXN0YW5jZQcBD2lzVXN1YWxMb2NhdGlvbgEIbG9jYXRpb24EB2xvY1R5cGUJAJEDAgkAtQkCBQhsb2NhdGlvbgIBXwUKbG9jSWR4VHlwZQMJAQIhPQIFB2xvY1R5cGUCAVQJAQIhPQIFB2xvY1R5cGUCAUQHAQlvbk1pc3Npb24CDHRvdXJDb250cmFjdAhsb2NhdGlvbgQGbGFzdElkCQELdmFsdWVPckVsc2UCCQCaCAIFDHRvdXJDb250cmFjdAUNbGFzdFRvdXJJZEtleQAABANsb2MJALUJAgUIbG9jYXRpb24CAV8EA25vdwgFCWxhc3RCbG9jawl0aW1lc3RhbXAEBXREYXRhCQELZ2V0VG91ckRhdGECBQx0b3VyQ29udHJhY3QFBmxhc3RJZAQGc3RhdGljCQCRAwIFBXREYXRhBQlpZHhTdGF0aWMEB2R5bmFtaWMJAJEDAgUFdERhdGEFCmlkeER5bmFtaWMEB2xvY1R5cGUJAJEDAgUDbG9jBQpsb2NJZHhUeXBlAwkAAAIFB2xvY1R5cGUCAUQGAwMDCQAAAgkAkQMCBQNsb2MFCmxvY0lkeFR5cGUCAVQJAAACCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUDbG9jBQ9sb2NJZHhDb250aW5lbnQFBmxhc3RJZAcJAAACCQCRAwIFB2R5bmFtaWMFDnREeW5hbWljU3RhdHVzAgpJTlBST0dSRVNTBwkAZgIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQZzdGF0aWMFCnRTdGF0aWNFbmQFA25vdwcBEmdldFJlY2lwZU1hdGVyaWFscwEGcmVjaXBlCQBoAgkBDXBhcnNlSW50VmFsdWUBCQCRAwIFBnJlY2lwZQUJcklkeENvZWZmBQlDT0VGRjJNQVQBDGNoZWF0QXR0ZW1wdAMGb2xkTG9jBm5ld0xvYwljaGVhdENhc2UJAAIBCQCsAgIJAKwCAgkArAICCQCsAgIJAKwCAgIWQ2hlYXQgYXR0ZW1wdDogb2xkTG9jPQUGb2xkTG9jAgksIG5ld0xvYz0FBm5ld0xvYwIHLCBjYXNlPQkApAMBBQljaGVhdENhc2UAFktTX1NFUEFSQVRFX1BVQkxJQ19LRVkHABhLU19BTExPV19CSUdfSU5GUkFfTUVSR0UHABFLU19BTExPV19ERUxJVkVSWQYABWNoYWluCQDJAQIJAMoBAggFBHRoaXMFYnl0ZXMAAQABAAt1c2R0QXNzZXRJZAQHJG1hdGNoMAUFY2hhaW4DCQAAAgEBVwUHJG1hdGNoMAEghNp6sggDP07Ru8qO7ouTvMmC3Qtd+geWqNQj+agP/7kDCQAAAgEBVAUHJG1hdGNoMAEgVbHYn3KHgu/l41uNrAWrZd6aQ6EvFrsF8xq3h6XxxRgJAAIBAg1Vbmtub3duIGNoYWluABVkZWZhdWx0UmVzdEFkZHJlc3NTdHIEByRtYXRjaDAFBWNoYWluAwkAAAIBAVcFByRtYXRjaDACIzNQUUN1dkZidmg0TGtQVW5yblUxejNqbmJBMXA5bTNXTmh2AwkAAAIBAVQFByRtYXRjaDACIzNNdW1rR0d6dENLQVhwV0RxeGtkZG9mcVhTVWJxUWt2U0p5CQACAQINVW5rbm93biBjaGFpbgARSW5mcmFVcGdyYWRlQ29zdFMEByRtYXRjaDAFBWNoYWluAwkAAAIBAVcFByRtYXRjaDAAgMivoCUDCQAAAgEBVAUHJG1hdGNoMACAwtcvCQACAQINVW5rbm93biBjaGFpbgAOYXJiaXRyYWdlRGVsYXkEByRtYXRjaDAFBWNoYWluAwkAAAIBAVcFByRtYXRjaDAAgLiZKQMJAAACAQFUBQckbWF0Y2gwAODUAwkAAgECDVVua25vd24gY2hhaW4AA1NFUAICX18ABU1VTFQ2AMCEPQAFTVVMVDgAgMLXLwAFU1NJWkUAGQAFTVNJWkUAZAAFTFNJWkUA4QEABlhMU0laRQCQAwAHWFhMU0laRQDxBAAFSVRFUjYJAMwIAgAACQDMCAIAAQkAzAgCAAIJAMwIAgADCQDMCAIABAkAzAgCAAUFA25pbAEPZ2V0U3RyaW5nT3JGYWlsAgdhZGRyZXNzA2tleQkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCdCAIFB2FkZHJlc3MFA2tleQkAuQkCCQDMCAICCm1hbmRhdG9yeSAJAMwIAgkApQgBBQdhZGRyZXNzCQDMCAICAS4JAMwIAgUDa2V5CQDMCAICDyBpcyBub3QgZGVmaW5lZAUDbmlsAgAAEUlkeENmZ1N0YWtpbmdEYXBwAAEAEUlkeENmZ0Vjb25vbXlEYXBwAAIAFElkeENmZ0dvdmVybmFuY2VEYXBwAAMADUlkeENmZ1dsZ0RhcHAABAAUSWR4Q2ZnVG91cm5hbWVudERhcHAABwAPSWR4Q2ZnQWNyZXNEYXBwAAgBCmtleVJlc3RDZmcAAg4lc19fcmVzdENvbmZpZwEOa2V5UmVzdEFkZHJlc3MAAgwlc19fcmVzdEFkZHIBEXJlYWRSZXN0Q2ZnT3JGYWlsAQRyZXN0CQC8CQIJAQ9nZXRTdHJpbmdPckZhaWwCBQRyZXN0CQEKa2V5UmVzdENmZwAFA1NFUAEYZ2V0Q29udHJhY3RBZGRyZXNzT3JGYWlsAgdyZXN0Q2ZnA2lkeAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCmCAEJAJEDAgUHcmVzdENmZwUDaWR4CQCsAgICKlJlc3QgY2ZnIGRvZXNuJ3QgY29udGFpbiBhZGRyZXNzIGF0IGluZGV4IAkApAMBBQNpZHgADHJlc3RDb250cmFjdAkBEUBleHRyTmF0aXZlKDEwNjIpAQkBC3ZhbHVlT3JFbHNlAgkAnQgCBQR0aGlzCQEOa2V5UmVzdEFkZHJlc3MABRVkZWZhdWx0UmVzdEFkZHJlc3NTdHIAB3Jlc3RDZmcJARFyZWFkUmVzdENmZ09yRmFpbAEFDHJlc3RDb250cmFjdAAPc3Rha2luZ0NvbnRyYWN0CQEYZ2V0Q29udHJhY3RBZGRyZXNzT3JGYWlsAgUHcmVzdENmZwURSWR4Q2ZnU3Rha2luZ0RhcHAAD2Vjb25vbXlDb250cmFjdAkBGGdldENvbnRyYWN0QWRkcmVzc09yRmFpbAIFB3Jlc3RDZmcFEUlkeENmZ0Vjb25vbXlEYXBwAAtnb3ZDb250cmFjdAkBGGdldENvbnRyYWN0QWRkcmVzc09yRmFpbAIFB3Jlc3RDZmcFFElkeENmZ0dvdmVybmFuY2VEYXBwAAt3bGdDb250cmFjdAkBGGdldENvbnRyYWN0QWRkcmVzc09yRmFpbAIFB3Jlc3RDZmcFDUlkeENmZ1dsZ0RhcHAAEnRvdXJuYW1lbnRDb250cmFjdAkBGGdldENvbnRyYWN0QWRkcmVzc09yRmFpbAIFB3Jlc3RDZmcFFElkeENmZ1RvdXJuYW1lbnREYXBwAA1hY3Jlc0NvbnRyYWN0CQEYZ2V0Q29udHJhY3RBZGRyZXNzT3JGYWlsAgUHcmVzdENmZwUPSWR4Q2ZnQWNyZXNEYXBwAApyZWNMYW5kTnVtAAAAC3JlY0xhbmRTaXplAAEAC3JlY1RlcnJhaW5zAAIADHJlY0NvbnRpbmVudAADAA13bGdBc3NldElkS2V5Agt3bGdfYXNzZXRJZAAKd2xnQXNzZXRJZAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCcCAIFC3dsZ0NvbnRyYWN0BQ13bGdBc3NldElkS2V5AhhXTEdPTEQgaXMgbm90IGlzc3VlZCB5ZXQAD2FjcmVzQXNzZXRJZEtleQIMYWNyZXNBc3NldElkAAxhY3Jlc0Fzc2V0SWQJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAnAgCBQ1hY3Jlc0NvbnRyYWN0BQ9hY3Jlc0Fzc2V0SWRLZXkCF0FDUkVTIGlzIG5vdCBpc3N1ZWQgeWV0AAtyYW5kb21EZWxheQACAQlrZXlDb21taXQBB2FkZHJlc3MJAKwCAgITZmluaXNoQmxvY2tGb3JBZGRyXwUHYWRkcmVzcwERa2V5UmVzUHJvcG9ydGlvbnMAAhNyZXNUeXBlc1Byb3BvcnRpb25zARZrZXlSZXNUeXBlc0J5Q29udGluZW50AQljb250aW5lbnQJAKwCAgIUcmVzVHlwZXNCeUNvbnRpbmVudF8FCWNvbnRpbmVudAEVa2V5U3Rha2VkTGFuZHNCeU93bmVyAQlvd25lckFkZHIJAKwCAgITc3Rha2VkTGFuZHNCeU93bmVyXwUJb3duZXJBZGRyARZrZXlTdGFrZWRQaWVjZXNCeU93bmVyAQlvd25lckFkZHIJAKwCAgIUc3Rha2VkUGllY2VzQnlPd25lcl8FCW93bmVyQWRkcgEIYXNTdHJpbmcBAXYEByRtYXRjaDAFAXYDCQABAgUHJG1hdGNoMAIGU3RyaW5nBAFzBQckbWF0Y2gwBQFzCQACAQIYZmFpbCB0byBjYXN0IGludG8gU3RyaW5nAQVhc0ludAEBdgQHJG1hdGNoMAUBdgMJAAECBQckbWF0Y2gwAgNJbnQEAW4FByRtYXRjaDAFAW4JAAIBAhVmYWlsIHRvIGNhc3QgaW50byBJbnQBCWFzQW55TGlzdAEBdgQHJG1hdGNoMAUBdgMJAAECBQckbWF0Y2gwAglMaXN0W0FueV0EAWwFByRtYXRjaDAFAWwJAAIBAhtmYWlsIHRvIGNhc3QgaW50byBMaXN0W0FueV0BCWFzQm9vbGVhbgEBdgQHJG1hdGNoMAUBdgMJAAECBQckbWF0Y2gwAgdCb29sZWFuBAFzBQckbWF0Y2gwBQFzCQACAQIZZmFpbCB0byBjYXN0IGludG8gQm9vbGVhbgEQYXNTdHJpbmdJbnRUdXBsZQEDdmFsBAckbWF0Y2gwBQN2YWwDCQABAgUHJG1hdGNoMAINKFN0cmluZywgSW50KQQCdDIFByRtYXRjaDAFAnQyCQACAQIfZmFpbCB0byBjYXN0IGludG8gKFN0cmluZywgSW50KQEPbnVtUGllY2VzQnlTaXplAQhsYW5kU2l6ZQQHJG1hdGNoMAUIbGFuZFNpemUDCQAAAgIBUwUHJG1hdGNoMAUFU1NJWkUDCQAAAgIBTQUHJG1hdGNoMAUFTVNJWkUDCQAAAgIBTAUHJG1hdGNoMAUFTFNJWkUDCQAAAgICWEwFByRtYXRjaDAFBlhMU0laRQMJAAACAgNYWEwFByRtYXRjaDAFB1hYTFNJWkUJAAIBAhFVbmtub3duIGxhbmQgc2l6ZQEHaXNEaWdpdAEBcwkBCWlzRGVmaW5lZAEJALYJAQUBcwEKa2V5QmxvY2tlZAACEGNvbnRyYWN0c0Jsb2NrZWQBEWtleUxhc3RUeElkQnlVc2VyAQRhZGRyCQCsAgICD2xhc3RUeElkQnlVc2VyXwUEYWRkcgEKZml4ZWRQb2ludAIDdmFsCGRlY2ltYWxzBAZ0ZW5Qb3cJAGwGAAoAAAUIZGVjaW1hbHMAAAAABQRET1dOBAdsb3dQYXJ0CQCkAwEJAGoCBQN2YWwFBnRlblBvdwQGemVyb2VzCQCwAgIJAKQDAQUGdGVuUG93CQBkAgABCQCxAgEFB2xvd1BhcnQJAKwCAgkArAICCQCsAgIJAKQDAQkAaQIFA3ZhbAUGdGVuUG93AgEuBQZ6ZXJvZXMFB2xvd1BhcnQBD2dldFJhbmRvbU51bWJlcgMIbWF4VmFsdWUMZmluaXNoSGVpZ2h0CmF1eEVudHJvcHkED3JhbmRvbVNlZWRCbG9jawkBBXZhbHVlAQkA7QcBBQxmaW5pc2hIZWlnaHQECnJhbmRvbUhhc2gJAPcDAQkAywECCQEFdmFsdWUBCAUPcmFuZG9tU2VlZEJsb2NrA3ZyZgUKYXV4RW50cm9weQkAagIJALEJAQUKcmFuZG9tSGFzaAUIbWF4VmFsdWUADWluY3ViYXRvckFkZHIEByRtYXRjaDAFBWNoYWluAwkAAAIBAVcFByRtYXRjaDAJARFAZXh0ck5hdGl2ZSgxMDYyKQECIzNQRWt0VnV4MlJoY2hTTjYzRHNEbzRiNG16NFFxektTZUR2AwkAAAIBAVQFByRtYXRjaDAFBHRoaXMJAAIBAg1Vbmtub3duIGNoYWluAAticmVlZGVyQWRkcgQHJG1hdGNoMAUFY2hhaW4DCQAAAgEBVwUHJG1hdGNoMAkBEUBleHRyTmF0aXZlKDEwNjIpAQIjM1BEVnVVNDVIN0VoNWRtdE5iblJOUlN0R3dVTEE3Tlk2SGIDCQAAAgEBVAUHJG1hdGNoMAUEdGhpcwkAAgECDVVua25vd24gY2hhaW4AA3B1YgQHJG1hdGNoMAUFY2hhaW4DCQAAAgEBVwUHJG1hdGNoMAMFFktTX1NFUEFSQVRFX1BVQkxJQ19LRVkBIKsXV48VZ+NZVEGw1nLrZpvEo9NmXtWZhlDfmDcfsgkIASBPU+IaP1So1p1SThMdRidVvbNT8yx7yVRUsP9DwbQUKAMJAAACAQFUBQckbWF0Y2gwASBPU+IaP1So1p1SThMdRidVvbNT8yx7yVRUsP9DwbQUKAkAAgECDVVua25vd24gY2hhaW4ADEVNUFRZX1BST0Q1MAGQAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEUZJVkVNSU5VVEVTTUlMTElTAOCnEgAMUkVOQU1JTkdDT1NUAMCWsQIACk1BWE5BTUVMRU4AMgAVSW5mcmFVcGdyYWRlQ29zdFNVc2R0AICt4gQADEVYUE1BVEVSSUFMUwQHJG1hdGNoMAUFY2hhaW4DCQAAAgEBVwUHJG1hdGNoMACm3YLtqwcDCQAAAgEBVAUHJG1hdGNoMACqp4GzCQkAAgECDVVua25vd24gY2hhaW4AB0VYUFVTRFQEByRtYXRjaDAFBWNoYWluAwkAAAIBAVcFByRtYXRjaDAAgOWadwMJAAACAQFUBQckbWF0Y2gwAIDlmncJAAIBAg1Vbmtub3duIGNoYWluAAxTX0NPU1RfQUNSRVMAgPKLqAkABUZJVkVYCQC2AgEABQAHVFdFTlRZWAkAtgIBABQACFRXRU5UWTJYCQC2AgEJAGgCABQAFAAIVFdFTlRZM1gJALYCAQkAaAIJAGgCABQAFAAUAAhUV0VOVFk0WAkAtgIBCQBoAgkAaAIJAGgCABQAFAAUABQACFRXRU5UWTVYCQC2AgEJAGgCCQBoAgkAaAIJAGgCABQAFAAUABQAFAAPUFJFU0FMRU5VTUxBTkRTAPQDARJrZXlOZXh0RnJlZUxhbmROdW0AAgtuZXh0TGFuZE51bQEaa2V5TGFuZEN1c3RvbU5hbWVUb0Fzc2V0SWQBBG5hbWUJAKwCAgIEbGNuXwUEbmFtZQEQa2V5TGFuZFRvQXNzZXRJZAEHbGFuZE51bQkArAICAgNsYV8FB2xhbmROdW0BHmtleUluZnJhTGV2ZWxCeUFzc2V0SWRBbmRPd25lcgIHYXNzZXRJZAlvd25lckFkZHIJAKwCAgkArAICCQCsAgICBWlsYW9fBQdhc3NldElkAgFfBQlvd25lckFkZHIBEWtleUxhbmROdW1Ub093bmVyAQdsYW5kTnVtCQCsAgICA2xvXwUHbGFuZE51bQEaa2V5RHVja0N1c3RvbU5hbWVUb0Fzc2V0SWQBBG5hbWUJAKwCAgIRZHVja0J5Q3VzdG9tTmFtZV8FBG5hbWUBFmtleUN1c3RvbU5hbWVUb0FkZHJlc3MBBG5hbWUJAKwCAgIUYWNjb3VudEJ5Q3VzdG9tTmFtZV8FBG5hbWUBCWtleU9sZGllcwACCm9sZGllc0xpc3QAC2NsYWltTW9kZVdoAAAADWNsYWltTW9kZUR1Y2sAAQATY2xhaW1Nb2RlV2hUaGVuRHVjawACAAhmbEhlYWx0aAAAAAtmbFRpbWVzdGFtcAAFAAdmbEJvbnVzAAYAC2ZsUHJvZHNVc2VkAAcBB25mdE5hbWUCB2xhbmROdW0IbGFuZFNpemUJAKwCAgkArAICBQpMQU5EUFJFRklYBQdsYW5kTnVtBQhsYW5kU2l6ZQEIdG9Wb2x1bWUCBmFtb3VudAdwa2dTaXplBARwa2dzAwkAZwIFBmFtb3VudAAACQBpAgkAZQIJAGQCBQZhbW91bnQFB3BrZ1NpemUAAQUHcGtnU2l6ZQkBAS0BCQBpAgkAZQIJAGQCCQEBLQEFBmFtb3VudAUHcGtnU2l6ZQABBQdwa2dTaXplCQBoAgUEcGtncwUFTVVMVDgBE2Rpc3RyaWJ1dGVCeVdlaWdodHMCBXRvdGFsB3dlaWdodHMEA3N1bQkAZAIJAGQCCQBkAgkAZAIJAGQCCQCRAwIFB3dlaWdodHMAAAkAkQMCBQd3ZWlnaHRzAAEJAJEDAgUHd2VpZ2h0cwACCQCRAwIFB3dlaWdodHMAAwkAkQMCBQd3ZWlnaHRzAAQJAJEDAgUHd2VpZ2h0cwAFAwkAZwIAAAUDc3VtCQACAQIQWmVybyB3ZWlnaHRzIHN1bQQFbm9ybTYJAGsDBQV0b3RhbAUFTVVMVDYFA3N1bQoBCm5vcm1hbGl6ZXICA2FjYwRlbGVtCQDNCAIFA2FjYwkAawMFBGVsZW0FBW5vcm02BQVNVUxUNgoAAiRsBQd3ZWlnaHRzCgACJHMJAJADAQUCJGwKAAUkYWNjMAUDbmlsCgEFJGYwXzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQpub3JtYWxpemVyAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGYwXzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhNMaXN0IHNpemUgZXhjZWVkcyA2CQEFJGYwXzICCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECBQUkYWNjMAAAAAEAAgADAAQABQAGARJnZXROZWVkZWRNYXRlcmlhbHMBBXRvdGFsBAVwcm9wcwkAtQkCCQEFdmFsdWUBCQCiCAEJARFrZXlSZXNQcm9wb3J0aW9ucwACAV8DCQECIT0CCQCQAwEFBXByb3BzBQZOVU1SRVMJAAIBAhZXcm9uZyBwcm9wb3J0aW9ucyBkYXRhBAFyCQDMCAIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQVwcm9wcwAACQDMCAIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQVwcm9wcwABCQDMCAIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQVwcm9wcwACCQDMCAIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQVwcm9wcwADCQDMCAIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQVwcm9wcwAECQDMCAIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQVwcm9wcwAFBQNuaWwJARNkaXN0cmlidXRlQnlXZWlnaHRzAgUFdG90YWwFAXIBEXN1YnRyYWN0TWF0ZXJpYWxzAwxzaG91bGRVc2VNYXQDaGFzCXRvdGFsTmVlZAQEbmVlZAkBEmdldE5lZWRlZE1hdGVyaWFscwEFCXRvdGFsTmVlZAoBCnN1YnRyYWN0b3ICA2FjYwNpZHgEBnJlc3VsdAkAZQIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQNoYXMFA2lkeAkAkQMCBQRuZWVkBQNpZHgDCQBmAgAABQZyZXN1bHQJAAIBCQCsAgIJAKwCAgkArAICCQCsAgIJAKwCAgIYTm90IGVub3VnaCBtYXRlcmlhbCBpZHg9CQCkAwEFA2lkeAILLCB5b3UgaGF2ZSAJAJEDAgUDaGFzBQNpZHgCCywgYnV0IG5lZWQgCQCkAwEJAJEDAgUEbmVlZAUDaWR4CQDNCAIFA2FjYwkApAMBBQZyZXN1bHQDBQxzaG91bGRVc2VNYXQKAAIkbAUFSVRFUjYKAAIkcwkAkAMBBQIkbAoABSRhY2MwBQNuaWwKAQUkZjBfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBCnN1YnRyYWN0b3ICBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjBfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECE0xpc3Qgc2l6ZSBleGNlZWRzIDYJAQUkZjBfMgIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYFA2hhcwERc3VidHJhY3RFcXVpcG1lbnQCBW9sZEVxBXBVc2VkAwkAAAIFBXBVc2VkAgAJAJQKAgUFb2xkRXEHCgEHc3ViVXNlZAIDYWNjBmlkeEFtdAQFcGFydHMJALUJAgUGaWR4QW10AgEsAwkBAiE9AgkAkAMBBQVwYXJ0cwACCQACAQIoSW5jb3JyZWN0IGZvcm1hdCwgc2hvdWxkIGJlIGluZGV4LGFtb3VudAQDaWR4CQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUFcGFydHMAAAMDCQBmAgAABQNpZHgGCQBnAgUDaWR4CQCQAwEFEHByb2R1Y3Rpb25NYXRyaXgJAAIBAhNVbmtub3duIHByb2R1Y3QgaWR4BANhbXQJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQVwYXJ0cwABBAdlcVBhcnRzCQC1CQIIBQNhY2MCXzEJAKwCAgkAkQMCBQVwYXJ0cwAAAgE6AwkBAiE9AgkAkAMBBQdlcVBhcnRzAAIJAAIBCQCsAgIJAKwCAgIPWW91IGRvbid0IGhhdmUgCQCRAwIFCXByb2RUeXBlcwUDaWR4AgkgZXF1aXBwZWQEA3RtcAkAkQMCBQdlcVBhcnRzAAEEBm51bUxlbgMJAQdpc0RpZ2l0AQkArwICCQCwAgIFA3RtcAABAAEAAgABBARjdXJyCQENcGFyc2VJbnRWYWx1ZQEJAK8CAgUDdG1wBQZudW1MZW4EBHRhaWwJALACAgUDdG1wBQZudW1MZW4EBm5ld0FtdAMJAGcCBQRjdXJyBQNhbXQJAGUCBQRjdXJyBQNhbXQJAAIBCQCsAgIJAKwCAgkArAICCQCsAgIJAKwCAgINWW91IGVxdWlwcGVkIAkApAMBBQRjdXJyAgQgb2YgCQCRAwIFCXByb2RUeXBlcwUDaWR4AhMsIGJ1dCB0cmllZCB0byB1c2UgCQCkAwEFA2FtdAkAlAoCCQCsAgIJAKwCAgkArAICCQCsAgIJAJEDAgUHZXFQYXJ0cwAACQCRAwIFBXBhcnRzAAACAToJAKQDAQUGbmV3QW10BQR0YWlsAwgFA2FjYwJfMgYDAwkAZwIFA2lkeAAGCQBnAgAIBQNpZHgHCQAAAgUGbmV3QW10AAAHCgACJGwJALUJAgUFcFVzZWQCAV8KAAIkcwkAkAMBBQIkbAoABSRhY2MwCQCUCgIFBW9sZEVxBwoBBSRmMF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEHc3ViVXNlZAIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQUkZjBfMgIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgEOcHJvZFN0clRvQnl0ZXMBB3Byb2RTdHIEBXBMaXN0AwkAAAIFB3Byb2RTdHICAAUDbmlsCQC8CQIFB3Byb2RTdHICAV8KAQR0b0JWAgNhY2MGcmVjaXBlBAFqCQBpAgkAyAEBBQNhY2MACAQEY3VycgMJAGYCCQCQAwEFBXBMaXN0BQFqCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUFcExpc3QFAWoAAAkAywECBQNhY2MJAJoDAQUEY3VycgoAAiRsBRBwcm9kdWN0aW9uTWF0cml4CgACJHMJAJADAQUCJGwKAAUkYWNjMAEACgEFJGYwXzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQR0b0JWAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGYwXzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyA1MAkBBSRmMF8yAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKAAsADAANAA4ADwAQABEAEgATABQAFQAWABcAGAAZABoAGwAcAB0AHgAfACAAIQAiACMAJAAlACYAJwAoACkAKgArACwALQAuAC8AMAAxADIBDmJ5dGVzVG9Qcm9kU3RyAQJidgoBBmZyb21CVgIDYWNjBnJlY2lwZQQBagkAkAMBBQNhY2MEAWIJAMkBAgkAygECBQJidgkAaAIACAUBagAICQDNCAIFA2FjYwkApAMBCQCxCQEFAWIJALoJAgoAAiRsBRBwcm9kdWN0aW9uTWF0cml4CgACJHMJAJADAQUCJGwKAAUkYWNjMAUDbmlsCgEFJGYwXzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQZmcm9tQlYCBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjBfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDUwCQEFJGYwXzICCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoACwAMAA0ADgAPABAAEQASABMAFAAVABYAFwAYABkAGgAbABwAHQAeAB8AIAAhACIAIwAkACUAJgAnACgAKQAqACsALAAtAC4ALwAwADEAMgIBXwEVY2hlY2tTdGF0UmVxdWlyZW1lbnRzAglkdWNrU3RhdHMEcmVxcwoBBWNoZWNrAgNhY2MBagQEYnVmZgMJAGYCCQCQAwEFCWR1Y2tTdGF0cwkAZAIABwUBagkAkQMCBQlkdWNrU3RhdHMJAGQCAAcFAWoAAAMJAGYCCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUEcmVxcwUBagkAZAIJAJEDAgUJZHVja1N0YXRzBQFqBQRidWZmCQACAQkArAICAhtSZXF1aXJlbWVudCBub3Qgc2F0aXNmaWVkOiAJAJEDAgUMcmVxdWlyZW1lbnRzBQFqBgoAAiRsCQDMCAIAAAkAzAgCAAEJAMwIAgACCQDMCAIAAwkAzAgCAAQJAMwIAgAFCQDMCAIABgUDbmlsCgACJHMJAJADAQUCJGwKAAUkYWNjMAcKAQUkZjBfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBBWNoZWNrAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGYwXzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhNMaXN0IHNpemUgZXhjZWVkcyA3CQEFJGYwXzICCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcBCnBsYWNlUHJvZEIGBmlkeENudAVwTGlzdAppc1Bvc2l0aXZlCWR1Y2tTdGF0cwhvY2N1cGllZARmcmVlBAVwYXJ0cwkAtQkCBQZpZHhDbnQCAToDCQECIT0CCQCQAwEFBXBhcnRzAAIJAAIBAihJbmNvcnJlY3QgZm9ybWF0LCBzaG91bGQgYmUgaW5kZXg6YW1vdW50AwMJAQEhAQUKaXNQb3NpdGl2ZQkBAiE9AgkAsQIBCQCRAwIFBXBhcnRzAAAAAgcJAAIBAitQcm9kdWN0IGlkeCBzaG91bGQgYmUgMiBkaWdpdHMsIHplcm8gcGFkZGVkBApwcm9kdWN0SWR4CQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUFcGFydHMAAAQFY291bnQJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQVwYXJ0cwABAwkBASEBCQEPY29udGFpbnNFbGVtZW50AgUQZm9ydEFsbG93ZWRQcm9kcwUKcHJvZHVjdElkeAkAAgEJAKwCAgkArAICAglQcm9kdWN0ICcJAJEDAgUJcHJvZFR5cGVzBQpwcm9kdWN0SWR4AiEnIGNhbm5vdCBiZSB1c2VkIGZvciBsYW5kIGRlZmVuc2UDCQBmAgAABQVjb3VudAkAAgECF0NvdW50IGNhbid0IGJlIG5lZ2F0aXZlAwkAZgIFBWNvdW50BQ1NQVhQUk9ESU5TTE9UCQACAQkArAICCQCsAgIJAKwCAgIUQ2FuJ3QgcHV0IG1vcmUgdGhhbiAJAKQDAQUNTUFYUFJPRElOU0xPVAIEIG9mIAkAkQMCBQlwcm9kVHlwZXMFCnByb2R1Y3RJZHgDCQAAAgUFY291bnQAAAkAlQoDBQVwTGlzdAUIb2NjdXBpZWQFBGZyZWUEBGhlYWQJAMkBAgUFcExpc3QJAGgCAAgFCnByb2R1Y3RJZHgEBGN1cnIJALEJAQkAyQECCQDKAQIFBXBMaXN0CQBoAgAIBQpwcm9kdWN0SWR4AAgEBHRhaWwJAMoBAgUFcExpc3QJAGgCAAgJAGQCBQpwcm9kdWN0SWR4AAEEBnJlY2lwZQkAtQkCCQCRAwIFEHByb2R1Y3Rpb25NYXRyaXgFCnByb2R1Y3RJZHgCAV8DAwkBASEBBQppc1Bvc2l0aXZlCQBmAgUFY291bnQFBGN1cnIHCQACAQkArAICCQCsAgIJAKwCAgkArAICCQCsAgICCVlvdSBoYXZlIAkApAMBBQRjdXJyAgQgb2YgCQCRAwIFCXByb2RUeXBlcwUKcHJvZHVjdElkeAITLCBidXQgdHJpZWQgdG8gdXNlIAkApAMBBQVjb3VudAQGbmV3QW10AwMJAQEhAQUKaXNQb3NpdGl2ZQkBFWNoZWNrU3RhdFJlcXVpcmVtZW50cwIFCWR1Y2tTdGF0cwkAtQkCCQCRAwIFBnJlY2lwZQUQcklkeFJlcXVpcmVtZW50cwIBLAcJAGUCBQRjdXJyBQVjb3VudAkAZAIFBGN1cnIFBWNvdW50BAhkZWx0YVZvbAkAZQIJAQh0b1ZvbHVtZQIFBm5ld0FtdAUOUFJPRFVDVFBLR1NJWkUJAQh0b1ZvbHVtZQIFBGN1cnIFDlBST0RVQ1RQS0dTSVpFCQCVCgMJAMsBAgkAywECBQRoZWFkCQCaAwEFBm5ld0FtdAUEdGFpbAkAZAIFCG9jY3VwaWVkBQhkZWx0YVZvbAkAZQIFBGZyZWUFCGRlbHRhVm9sAQhhZGRQcm9kQgcGaWR4Q250BXBMaXN0CmlzUG9zaXRpdmUHc2VnbWVudAdtYWluQXV4BHNsb3QJZHVja1N0YXRzBAVwYXJ0cwkAtQkCBQZpZHhDbnQCAToDCQECIT0CCQCQAwEFBXBhcnRzAAIJAAIBAihJbmNvcnJlY3QgZm9ybWF0LCBzaG91bGQgYmUgaW5kZXg6YW1vdW50AwMJAQEhAQUKaXNQb3NpdGl2ZQkBAiE9AgkAsQIBCQCRAwIFBXBhcnRzAAAAAgcJAAIBAitQcm9kdWN0IGlkeCBzaG91bGQgYmUgMiBkaWdpdHMsIHplcm8gcGFkZGVkBApwcm9kdWN0SWR4CQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUFcGFydHMAAAQFY291bnQJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQVwYXJ0cwABAwMJAGYCAAAFCnByb2R1Y3RJZHgGCQBnAgUKcHJvZHVjdElkeAkAkAMBBRBwcm9kdWN0aW9uTWF0cml4CQACAQITVW5rbm93biBwcm9kdWN0IGlkeAMJAGYCAAAFBWNvdW50CQACAQIXQ291bnQgY2FuJ3QgYmUgbmVnYXRpdmUDCQBmAgUFY291bnQFDU1BWFBST0RJTlNMT1QJAAIBCQCsAgIJAKwCAgkArAICAhRDYW4ndCBwdXQgbW9yZSB0aGFuIAkApAMBBQ1NQVhQUk9ESU5TTE9UAgQgb2YgCQCRAwIFCXByb2RUeXBlcwUKcHJvZHVjdElkeAMJAAACBQVjb3VudAAACQCUCgIFBXBMaXN0BwQEaGVhZAkAyQECBQVwTGlzdAkAaAIACAUKcHJvZHVjdElkeAQEY3VycgkAsQkBCQDJAQIJAMoBAgUFcExpc3QJAGgCAAgFCnByb2R1Y3RJZHgACAQEdGFpbAkAygECBQVwTGlzdAkAaAIACAkAZAIFCnByb2R1Y3RJZHgAAQQGcmVjaXBlCQC1CQIJAJEDAgUQcHJvZHVjdGlvbk1hdHJpeAUKcHJvZHVjdElkeAIBXwMDCQEBIQEFCmlzUG9zaXRpdmUJAGYCBQVjb3VudAUEY3VycgcJAAIBCQCsAgIJAKwCAgkArAICCQCsAgIJAKwCAgIJWW91IGhhdmUgCQCkAwEFBGN1cnICBCBvZiAJAJEDAgUJcHJvZFR5cGVzBQpwcm9kdWN0SWR4AhMsIGJ1dCB0cmllZCB0byB1c2UgCQCkAwEFBWNvdW50BAlpc0JpZ0l0ZW0DAwkBASEBBQppc1Bvc2l0aXZlCQEVY2hlY2tTdGF0UmVxdWlyZW1lbnRzAgUJZHVja1N0YXRzCQC1CQIJAJEDAgUGcmVjaXBlBRBySWR4UmVxdWlyZW1lbnRzAgEsBwQGY29tcGF0CQCRAwIFBnJlY2lwZQUJcklkeFNsb3RzAwkAAAIFBmNvbXBhdAIACQACAQIXSXRlbSBjYW5ub3QgYmUgZXF1aXBwZWQEAWMJAQ1wYXJzZUludFZhbHVlAQUGY29tcGF0BARjU2VnCQBpAgUBYwBkAwkBAiE9AgUHc2VnbWVudAUEY1NlZwkAAgECFFNlZ21lbnQgaW5jb21wYXRpYmxlBAhjTWFpbkF1eAkAaQIJAGoCBQFjAGQACgMJAQIhPQIFB21haW5BdXgFCGNNYWluQXV4CQACAQIRU2xvdCBpbmNvbXBhdGlibGUECWNOdW1TbG90cwkAagIFAWMACgMDCQECIT0CBQRzbG90AAAJAGYCBQljTnVtU2xvdHMAAQcJAAIBAh5CaWcgaXRlbXMgc2hvdWxkIG9jY3VweSBzbG90IDAJAGYCBQljTnVtU2xvdHMAAQcJAJQKAgkAywECCQDLAQIFBGhlYWQJAJoDAQkAZAIFBGN1cnIDBQppc1Bvc2l0aXZlBQVjb3VudAkBAS0BBQVjb3VudAUEdGFpbAUJaXNCaWdJdGVtAQtzbG90c0dyb3VwQgYBZwRicEluCmlzUG9zaXRpdmUHc2VnbWVudAdtYWluQXV4BXN0YXRzAwkBAiE9AgUBZwIABAVzbG90cwkAtQkCBQFnAgEsAwkAZgIJAJADAQUFc2xvdHMFCE1BWFNMT1RTCQACAQISV3Jvbmcgc2xvdHMgZm9ybWF0BAJzMAkAkQMCBQVzbG90cwAABAJzMQMJAGYCCQCQAwEFBXNsb3RzAAEJAJEDAgUFc2xvdHMAAQIAAwMJAAACBQJzMAIACQAAAgUCczECAAcFBGJwSW4EBXRtcFMwAwkBAiE9AgUCczACAAkBCGFkZFByb2RCBwUCczAFBGJwSW4FCmlzUG9zaXRpdmUFB3NlZ21lbnQFB21haW5BdXgAAAUFc3RhdHMJAJQKAgUEYnBJbgcDCQECIT0CBQJzMQIAAwgFBXRtcFMwAl8yCQACAQIeQmlnIGl0ZW0gYWxyZWFkeSBvY2N1cGllcyBzbG90CAkBCGFkZFByb2RCBwUCczEIBQV0bXBTMAJfMQUKaXNQb3NpdGl2ZQUHc2VnbWVudAUHbWFpbkF1eAABBQVzdGF0cwJfMQgFBXRtcFMwAl8xBQRicEluAQZkcmVzc0IEB3NlZ0xpc3QGcEJ5dGVzCmlzUG9zaXRpdmUFc3RhdHMKAQdzZWdtZW50AgNhY2MDc2VnBAFqCAUDYWNjAl8xBAdtYWluQXV4CQC1CQIFA3NlZwIBOwMJAQIhPQIJAJADAQUHbWFpbkF1eAUKTlVNTUFJTkFVWAkAAgECFFdyb25nIHNlZ21lbnQgZm9ybWF0BAFtCQCRAwIFB21haW5BdXgAAAQBYQkAkQMCBQdtYWluQXV4AAEDAwkAAAIFAW0CAAkAAAIFAWECAAcJAJQKAgkAZAIFAWoAAQgFA2FjYwJfMgQEdG1wTQkBC3Nsb3RzR3JvdXBCBgUBbQgFA2FjYwJfMgUKaXNQb3NpdGl2ZQUBagAABQVzdGF0cwkAlAoCCQBkAgUBagABCQELc2xvdHNHcm91cEIGBQFhBQR0bXBNBQppc1Bvc2l0aXZlBQFqAAEFBXN0YXRzCAoAAiRsBQdzZWdMaXN0CgACJHMJAJADAQUCJGwKAAUkYWNjMAkAlAoCAAAFBnBCeXRlcwoBBSRmMF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEHc2VnbWVudAIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQITTGlzdCBzaXplIGV4Y2VlZHMgNgkBBSRmMF8yAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgJfMgEFZm9ydEIGB3NlZ0xpc3QGcEJ5dGVzCG9jY3VwaWVkBGZyZWUKaXNQb3NpdGl2ZQlkdWNrU3RhdHMDCQBmAgADCQCQAwEFB3NlZ0xpc3QJAAIBAjFBdCBsZWFzdCBkdWNrLCBtaW5lcyBhbmQgdHJhcHMgcGFydHMgYXJlIHJlcXVpcmVkCgEHc2VnbWVudAIDYWNjA3NlZwQBaggFA2FjYwJfMQMJAAACBQFqAAAJAJYKBAkAZAIFAWoAAQgFA2FjYwJfMggFA2FjYwJfMwgFA2FjYwJfNAQBcAkBCnBsYWNlUHJvZEIGBQNzZWcIBQNhY2MCXzIFCmlzUG9zaXRpdmUFCWR1Y2tTdGF0cwgFA2FjYwJfMwgFA2FjYwJfNAkAlgoECQBkAgUBagABCAUBcAJfMQgFAXACXzIIBQFwAl8zBAF0CgACJGwFB3NlZ0xpc3QKAAIkcwkAkAMBBQIkbAoABSRhY2MwCQCWCgQAAAUGcEJ5dGVzBQhvY2N1cGllZAUEZnJlZQoBBSRmMF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEHc2VnbWVudAIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQUkZjBfMgIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgkAlQoDCAUBdAJfMggFAXQCXzMIBQF0Al80ARdjYW5XZWFyQ3VycmVudEVxdWlwbWVudAELZHVja0Fzc2V0SWQEBWVxS2V5CQEQa2V5RHVja0VxdWlwbWVudAEFC2R1Y2tBc3NldElkBAZjdXJyRXEJALUJAgkBC3ZhbHVlT3JFbHNlAgkAoggBBQVlcUtleQIXLDssXyw7LF8sOyxfLDssXyw7LF8sOywCAV8ECXRlbXBQcm9kQgkBBmRyZXNzQgQFBmN1cnJFcQUMRU1QVFlfUFJPRDUwBgUDbmlsBAhzZWdCcEF1eAkAkQMCCQC1CQIJAJEDAgUGY3VyckVxBQtzZWdCYWNrcGFjawIBOwABBApidWZmRWZmZWN0AwkAAAIFCHNlZ0JwQXV4AgAAAAQEYXV4MAkAkQMCCQC1CQIFCHNlZ0JwQXV4AgEsAAADCQAAAgUEYXV4MAIAAAAEBmlkeENudAkAtQkCBQRhdXgwAgE6BANpZHgJAJEDAgUGaWR4Q250AAAEA2NudAkAkQMCBQZpZHhDbnQAAQMDAwMDCQAAAgUDaWR4AgIwNgYJAAACBQNpZHgCAjA3BgkAAAIFA2lkeAICMDgJAQIhPQIFA2NudAIABwkAZgIJAQ1wYXJzZUludFZhbHVlAQUDY250AAAHCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgkAtQkCCQCRAwIFEHByb2R1Y3Rpb25NYXRyaXgJAQ1wYXJzZUludFZhbHVlAQUDaWR4AgFfBQpySWR4RWZmZWN0AAAEBXN0YXRzCQEMZ2V0RHVja1N0YXRzBAUEdGhpcwULZHVja0Fzc2V0SWQFCmJ1ZmZFZmZlY3QGBAhuZXdQcm9kQgkBBmRyZXNzQgQFBmN1cnJFcQUJdGVtcFByb2RCBwUFc3RhdHMJAAACBQhuZXdQcm9kQgUIbmV3UHJvZEIBGXVwZGF0ZVByb3BvcnRpb25zSW50ZXJuYWwECHByb3BMaXN0DXRlcnJhaW5Db3VudHMNbGFuZFNpemVJbmRleARzaWduAwkBAiE9AgkAkAMBBQhwcm9wTGlzdAUGTlVNUkVTCQACAQIWV3JvbmcgcHJvcG9ydGlvbnMgZGF0YQoBB3VwZGF0ZXICA2FjYwFpBAZyZXN1bHQJAGQCCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUIcHJvcExpc3QFAWkJAGgCCQBoAgUEc2lnbgkAkQMCBQ10ZXJyYWluQ291bnRzBQFpBQ1sYW5kU2l6ZUluZGV4AwkAZgIAAAUGcmVzdWx0CQACAQkArAICCQCsAgIJAKwCAgkArAICCQCsAgIJAKwCAgkArAICAhZQYW5pYyEgUGllY2VzIG9mIHR5cGU9CQCkAwEFAWkCBywgc2lnbj0JAKQDAQUEc2lnbgITLCB0ZXJyYWluQ291bnRzW2ldPQkApAMBCQCRAwIFDXRlcnJhaW5Db3VudHMFAWkCECwgbGFuZFNpemVJbmRleD0JAKQDAQUNbGFuZFNpemVJbmRleAkAzQgCBQNhY2MJAKQDAQUGcmVzdWx0CgACJGwFBUlURVI2CgACJHMJAJADAQUCJGwKAAUkYWNjMAUDbmlsCgEFJGYwXzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQd1cGRhdGVyAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGYwXzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhNMaXN0IHNpemUgZXhjZWVkcyA2CQEFJGYwXzICCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECBQUkYWNjMAAAAAEAAgADAAQABQAGARF1cGRhdGVQcm9wb3J0aW9ucwMNdGVycmFpbkNvdW50cw1sYW5kU2l6ZUluZGV4BHNpZ24ECHByb3BMaXN0CQC1CQIJAQt2YWx1ZU9yRWxzZQIJAKIIAQkBEWtleVJlc1Byb3BvcnRpb25zAAILMF8wXzBfMF8wXzACAV8JALkJAgkBGXVwZGF0ZVByb3BvcnRpb25zSW50ZXJuYWwEBQhwcm9wTGlzdAUNdGVycmFpbkNvdW50cwUNbGFuZFNpemVJbmRleAUEc2lnbgIBXwENY291bnRUZXJyYWlucwEIdGVycmFpbnMJAMwIAgkAZQIJAJADAQkAtQkCBQh0ZXJyYWlucwIBQQABCQDMCAIJAGUCCQCQAwEJALUJAgUIdGVycmFpbnMCAUIAAQkAzAgCCQBlAgkAkAMBCQC1CQIFCHRlcnJhaW5zAgFDAAEJAMwIAgkAZQIJAJADAQkAtQkCBQh0ZXJyYWlucwIBRAABCQDMCAIJAGUCCQCQAwEJALUJAgUIdGVycmFpbnMCAUUAAQkAzAgCCQBlAgkAkAMBCQC1CQIFCHRlcnJhaW5zAgFGAAEFA25pbAEGYWRkUmVzBQpjdXJyZW50UmVzDXRlcnJhaW5Db3VudHMJZGVsdGFUaW1lDWxhbmRTaXplSW5kZXgXZGFpbHlCeVBpZWNlV2l0aEJvbnVzZXMKAQVhZGRlcgIDYWNjAWkECXJlc09mVHlwZQkAaAIJAGgCCQBrAwUJZGVsdGFUaW1lBRdkYWlseUJ5UGllY2VXaXRoQm9udXNlcwUJREFZTUlMTElTCQCRAwIFDXRlcnJhaW5Db3VudHMFAWkFDWxhbmRTaXplSW5kZXgJAM0IAgUDYWNjCQCkAwEJAGQCCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUKY3VycmVudFJlcwUBaQUJcmVzT2ZUeXBlBAFyCgACJGwFBUlURVI2CgACJHMJAJADAQUCJGwKAAUkYWNjMAUDbmlsCgEFJGYwXzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQVhZGRlcgIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQITTGlzdCBzaXplIGV4Y2VlZHMgNgkBBSRmMF8yAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgkAuQkCBQFyAgFfAQl2aXJ0Q2xhaW0EDXRlcnJhaW5Db3VudHMJZGVsdGFUaW1lDWxhbmRTaXplSW5kZXgXZGFpbHlCeVBpZWNlV2l0aEJvbnVzZXMKAQVhZGRlcgIDYWNjAWkECXJlc09mVHlwZQkAaAIJAGgCCQBrAwUJZGVsdGFUaW1lBRdkYWlseUJ5UGllY2VXaXRoQm9udXNlcwUJREFZTUlMTElTCQCRAwIFDXRlcnJhaW5Db3VudHMFAWkFDWxhbmRTaXplSW5kZXgJAJQKAgkAzQgCCAUDYWNjAl8xBQlyZXNPZlR5cGUJAGQCCAUDYWNjAl8yBQlyZXNPZlR5cGUKAAIkbAUFSVRFUjYKAAIkcwkAkAMBBQIkbAoABSRhY2MwCQCUCgIFA25pbAAACgEFJGYwXzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQVhZGRlcgIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQITTGlzdCBzaXplIGV4Y2VlZHMgNgkBBSRmMF8yAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgENZGlzdHJpYnV0ZVJlcwQMY3VycmVudFdoUmVzDmN1cnJlbnRQYWNrUmVzCnJlc1RvQ2xhaW0Ld2hTcGFjZUxlZnQEDnJlc0xpc3RUb0NsYWltCAUKcmVzVG9DbGFpbQJfMQQMcmVzQW1Ub0NsYWltCAUKcmVzVG9DbGFpbQJfMgMJAAACBQxyZXNBbVRvQ2xhaW0AAAkAlAoCCQC5CQIFDGN1cnJlbnRXaFJlcwIBXwkAuQkCBQ5jdXJyZW50UGFja1JlcwIBXwMJAGcCBQt3aFNwYWNlTGVmdAUMcmVzQW1Ub0NsYWltCgEIYWRkTGlzdHMCA2FjYwFpCQDNCAIFA2FjYwkApAMBCQBkAgkBDXBhcnNlSW50VmFsdWUBCQCRAwIFDGN1cnJlbnRXaFJlcwUBaQkAkQMCBQ5yZXNMaXN0VG9DbGFpbQUBaQQBcgoAAiRsBQVJVEVSNgoAAiRzCQCQAwEFAiRsCgAFJGFjYzAFA25pbAoBBSRmMF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEIYWRkTGlzdHMCBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjBfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECE0xpc3Qgc2l6ZSBleGNlZWRzIDYJAQUkZjBfMgIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYJAJQKAgkAuQkCBQFyAgFfCQC5CQIFDmN1cnJlbnRQYWNrUmVzAgFfCgEMYWRkUGFydExpc3RzAgNhY2MBaQQGd2hQYXJ0CQBrAwkAkQMCBQ5yZXNMaXN0VG9DbGFpbQUBaQULd2hTcGFjZUxlZnQFDHJlc0FtVG9DbGFpbQkAlAoCCQDNCAIIBQNhY2MCXzEJAKQDAQkAZAIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQxjdXJyZW50V2hSZXMFAWkFBndoUGFydAkAzQgCCAUDYWNjAl8yCQCkAwEJAGUCCQBkAgkBDXBhcnNlSW50VmFsdWUBCQCRAwIFDmN1cnJlbnRQYWNrUmVzBQFpCQCRAwIFDnJlc0xpc3RUb0NsYWltBQFpBQZ3aFBhcnQEAXIKAAIkbAUFSVRFUjYKAAIkcwkAkAMBBQIkbAoABSRhY2MwCQCUCgIFA25pbAUDbmlsCgEFJGYwXzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQxhZGRQYXJ0TGlzdHMCBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjBfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECE0xpc3Qgc2l6ZSBleGNlZWRzIDYJAQUkZjBfMgIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYJAJQKAgkAuQkCCAUBcgJfMQIBXwkAuQkCCAUBcgJfMgIBXwEDYWJzAQF4AwkAwAICBQF4CQC2AgEAAAUBeAkAvgIBBQF4AARmcmVxCQDMCAIJAMwIAgAGCQDMCAIACQkAzAgCAA4JAMwIAgAPCQDMCAIAEAUDbmlsCQDMCAIJAMwIAgAFCQDMCAIACAkAzAgCAA0JAMwIAgAOCQDMCAIADwUDbmlsCQDMCAIJAMwIAgABCQDMCAIABAkAzAgCAAkJAMwIAgAKCQDMCAIADwUDbmlsCQDMCAIJAMwIAgABCQDMCAIABgkAzAgCAAcJAMwIAgAPCQDMCAIAEwUDbmlsCQDMCAIJAMwIAgAECQDMCAIABwkAzAgCAAgJAMwIAgANCQDMCAIAEgUDbmlsBQNuaWwBB2dlbkNoYXICAW4FZnJlcXMEA3JlbQkAoAMBCQC7AgIFAW4FB1RXRU5UWVgEBmxldHRlcgMJAGYCCQCRAwIFBWZyZXFzAAAFA3JlbQIBQQMJAGYCCQCRAwIFBWZyZXFzAAEFA3JlbQIBQgMJAGYCCQCRAwIFBWZyZXFzAAIFA3JlbQIBQwMJAGYCCQCRAwIFBWZyZXFzAAMFA3JlbQIBRAMJAGYCCQCRAwIFBWZyZXFzAAQFA3JlbQIBRQIBRgUGbGV0dGVyAQtnZW5UZXJyYWlucwIEc2VlZAxjb250aW5lbnRJZHgEAWYJAJEDAgUEZnJlcQUMY29udGluZW50SWR4CgEQdGVycmFpbkdlbmVyYXRvcgIDYWNjBGVsZW0JAJQKAgkArAICCQCsAgIJAKwCAgkArAICCQCsAgIIBQNhY2MCXzEJAQdnZW5DaGFyAggFA2FjYwJfMgUBZgkBB2dlbkNoYXICCQC6AgIIBQNhY2MCXzIFB1RXRU5UWVgFAWYJAQdnZW5DaGFyAgkAugICCAUDYWNjAl8yBQhUV0VOVFkyWAUBZgkBB2dlbkNoYXICCQC6AgIIBQNhY2MCXzIFCFRXRU5UWTNYBQFmCQEHZ2VuQ2hhcgIJALoCAggFA2FjYwJfMgUIVFdFTlRZNFgFAWYJALoCAggFA2FjYwJfMgUIVFdFTlRZNVgEAXQKAAIkbAkAzAgCAAEJAMwIAgACCQDMCAIAAwkAzAgCAAQJAMwIAgAFBQNuaWwKAAIkcwkAkAMBBQIkbAoABSRhY2MwCQCUCgICAAkAugICBQRzZWVkBQVGSVZFWAoBBSRmMF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEQdGVycmFpbkdlbmVyYXRvcgIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQITTGlzdCBzaXplIGV4Y2VlZHMgNQkBBSRmMF8yAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgUFJGFjYzAAAAABAAIAAwAEAAUIBQF0Al8xAAZQRVJNMjUJAMwIAgAHCQDMCAIAAgkAzAgCAA8JAMwIAgATCQDMCAIACAkAzAgCABgJAMwIAgABCQDMCAIAFQkAzAgCABAJAMwIAgAFCQDMCAIAAAkAzAgCABYJAMwIAgAUCQDMCAIAFwkAzAgCAAsJAMwIAgAECQDMCAIAEgkAzAgCAAwJAMwIAgAGCQDMCAIACgkAzAgCAAMJAMwIAgARCQDMCAIADQkAzAgCAAkJAMwIAgAOBQNuaWwABlRDSEFSUwkAzAgCAgFBCQDMCAICAUIJAMwIAgIBQwkAzAgCAgFECQDMCAICAUUJAMwIAgIBRgUDbmlsARNnZW5UZXJyYWluc0Zvck1lcmdlAgtzdW1UZXJyYWlucw1sYW5kU2l6ZUluZGV4CgEFc3RlcDECA2FjYwFzBAFqCAUDYWNjAl8yBAJlbAkBDXBhcnNlSW50VmFsdWUBBQFzBAF4AwkAAAIFAmVsAAAAAAMJAGcCBQJlbAkAaAIABAUNbGFuZFNpemVJbmRleAkAaQIFAmVsBQ1sYW5kU2l6ZUluZGV4AwkAZgIFAmVsCQBoAgADBQ1sYW5kU2l6ZUluZGV4AAMJAGQCCQBpAgkAZQIFAmVsAAEFDWxhbmRTaXplSW5kZXgAAQkAlQoDCQDNCAIIBQNhY2MCXzEFAXgJAGQCCAUDYWNjAl8yAAEJAGQCCAUDYWNjAl8zBQF4BAF0CgACJGwFC3N1bVRlcnJhaW5zCgACJHMJAJADAQUCJGwKAAUkYWNjMAkAlQoDBQNuaWwAAAAACgEFJGYwXzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQVzdGVwMQIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQITTGlzdCBzaXplIGV4Y2VlZHMgNgkBBSRmMF8yAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgQDYXJyCAUBdAJfMQQGbWF4SWR4CQEFdmFsdWUBCQDPCAIFA2FycgkAlgMBBQNhcnIEBWRlbHRhCQBlAggFAXQCXzMAGQoBBnN1YmJlcgIDYWNjA2lkeAQDdmFsAwkAAAIFA2lkeAUGbWF4SWR4CQBlAgkAkQMCBQNhcnIFA2lkeAUFZGVsdGEJAJEDAgUDYXJyBQNpZHgEBnplcm9lcwMJAAACBQN2YWwAAAUDbmlsCQC1CQIJALACAgkApAMBCQBsBgAKAAAFA3ZhbAAAAAAFBERPV04AAQIABAFjCQCRAwIFBlRDSEFSUwUDaWR4CgEHbGlzdEdlbgICYWMHaWdub3JlZAkAzQgCBQJhYwUBYwQBegoAAiRsBQZ6ZXJvZXMKAAIkcwkAkAMBBQIkbAoABSRhY2MwBQNuaWwKAQUkZjFfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBB2xpc3RHZW4CBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjFfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDI1CQEFJGYxXzICCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoACwAMAA0ADgAPABAAEQASABMAFAAVABYAFwAYABkJAM4IAgUDYWNjBQF6BAFyCgACJGwFBUlURVI2CgACJHMJAJADAQUCJGwKAAUkYWNjMAUDbmlsCgEFJGYxXzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQZzdWJiZXICBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjFfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECE0xpc3Qgc2l6ZSBleGNlZWRzIDYJAQUkZjFfMgIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYKAQZwZXJtdXQCA2FjYwFqCQCsAgIFA2FjYwkAkQMCBQFyBQFqCgACJGwFBlBFUk0yNQoAAiRzCQCQAwEFAiRsCgAFJGFjYzACAAoBBSRmMl8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEGcGVybXV0AgUCJGEJAJEDAgUCJGwFAiRpCgEFJGYyXzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAyNQkBBSRmMl8yAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKAAsADAANAA4ADwAQABEAEgATABQAFQAWABcAGAAZAQtnZXRCYWNrcGFjawEFYnBLZXkEAXAJALUJAgkBC3ZhbHVlT3JFbHNlAgkAoggBBQVicEtleQIaMDowXzBfMF8wXzBfMDowXzBfMF8wXzBfMDoCAToJAMwIAgkApAMBCQELdmFsdWVPckVsc2UCCQC2CQEJAJEDAgUBcAUKYnBJZHhMZXZlbAAACQDMCAIDCQAAAgkAkAMBCQC1CQIJAJEDAgUBcAUIYnBJZHhSZXMCAV8FBk5VTVJFUwkAkQMCBQFwBQhicElkeFJlcwILMF8wXzBfMF8wXzAJAMwIAgMJAAACCQCQAwEJALUJAgkAkQMCBQFwBQhicElkeE1hdAIBXwUGTlVNUkVTCQCRAwIFAXAFCGJwSWR4TWF0AgswXzBfMF8wXzBfMAkAzAgCCQCRAwIFAXAFCWJwSWR4UHJvZAUDbmlsARdnZXRXYXJlaG91c2VUb3RhbFZvbHVtZQEJdm9sUHJlZml4BAVwYXJ0cwkAtQkCBQl2b2xQcmVmaXgCAV8JAGgCCQBoAgUMV0hNVUxUSVBMSUVSCQBkAgkBDXBhcnNlSW50VmFsdWUBCQCRAwIFBXBhcnRzAAEAAQkBDXBhcnNlSW50VmFsdWUBCQCRAwIFBXBhcnRzAAABF2dldFdhcmVob3VzZU9jY3VwaWVkVm9sAQljdXJyZW50V2gEBWdvb2RzCQCRAwIFCWN1cnJlbnRXaAUJd2hJZHhQcm9kCgEJc3VtUmVzTWF0AgNhY2MEaXRlbQkAZAIFA2FjYwkBDXBhcnNlSW50VmFsdWUBBQRpdGVtCgEHc3VtUHJvZAIDYWNjBGl0ZW0EA2lkeAgFA2FjYwJfMQQEcGtncwkAaQIJAGUCCQBkAgkBDXBhcnNlSW50VmFsdWUBBQRpdGVtBQ5QUk9EVUNUUEtHU0laRQABBQ5QUk9EVUNUUEtHU0laRQkAlAoCCQBkAgUDaWR4AAEJAGQCCAUDYWNjAl8yCQBoAgUEcGtncwUFTVVMVDgECHdoUmVzVm9sCgACJGwJALUJAgkAkQMCBQljdXJyZW50V2gFCHdoSWR4UmVzAgFfCgACJHMJAJADAQUCJGwKAAUkYWNjMAAACgEFJGYwXzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQlzdW1SZXNNYXQCBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjBfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECE0xpc3Qgc2l6ZSBleGNlZWRzIDYJAQUkZjBfMgIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYECHdoTWF0Vm9sCgACJGwJALUJAgkAkQMCBQljdXJyZW50V2gFCHdoSWR4TWF0AgFfCgACJHMJAJADAQUCJGwKAAUkYWNjMAAACgEFJGYxXzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQlzdW1SZXNNYXQCBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjFfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECE0xpc3Qgc2l6ZSBleGNlZWRzIDYJAQUkZjFfMgIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYECndoR29vZHNWb2wDCQAAAgUFZ29vZHMCAAAACAoAAiRsCQC8CQIFBWdvb2RzAgFfCgACJHMJAJADAQUCJGwKAAUkYWNjMAkAlAoCAAAAAAoBBSRmMl8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEHc3VtUHJvZAIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMl8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgNTAJAQUkZjJfMgIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgALAAwADQAOAA8AEAARABIAEwAUABUAFgAXABgAGQAaABsAHAAdAB4AHwAgACEAIgAjACQAJQAmACcAKAApACoAKwAsAC0ALgAvADAAMQAyAl8yCQBkAgkAZAIFCHdoUmVzVm9sBQh3aE1hdFZvbAUKd2hHb29kc1ZvbAEMZ2V0V2FyZWhvdXNlAwV3aEtleQlsYW5kSW5kZXgKaW5mcmFMZXZlbAQJdm9sUHJlZml4CQCsAgIJAKwCAgkApAMBBQlsYW5kSW5kZXgCAV8JAKQDAQUKaW5mcmFMZXZlbAQHd2hUb3RhbAkBF2dldFdhcmVob3VzZVRvdGFsVm9sdW1lAQUJdm9sUHJlZml4BAV3aFN0cgkBC3ZhbHVlT3JFbHNlAgkAoggBBQV3aEtleQkArAICBQl2b2xQcmVmaXgCGzowXzBfMF8wXzBfMDowXzBfMF8wXzBfMDo6MAQCd2gJALwJAgUFd2hTdHICAToECndoT2NjdXBpZWQJARdnZXRXYXJlaG91c2VPY2N1cGllZFZvbAEFAndoBAZ3aExvZnQDCQBmAgAFCQCQAwEFAndoCQC5CQIJAMwIAgIBMAkAzAgCCQCkAwEFCndoT2NjdXBpZWQJAMwIAgkApAMBCQBlAgUHd2hUb3RhbAUKd2hPY2N1cGllZAkAzAgCCQCkAwEFB3doVG90YWwFA25pbAIBXwQEbG9mdAkAtQkCCQCRAwIFAndoBQl3aElkeExPRlQCAV8ECHdoTG9ja2VkCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUEbG9mdAUJdm9sTG9ja2VkBANvY2MDCQBmAgkAkAMBBQRsb2Z0AAEJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQRsb2Z0BQt2b2xPY2N1cGllZAUKd2hPY2N1cGllZAkAuQkCCQDMCAIJAKQDAQUId2hMb2NrZWQJAMwIAgkApAMBBQNvY2MJAMwIAgkApAMBCQBlAgkAZQIFB3doVG90YWwFCHdoTG9ja2VkBQNvY2MJAMwIAgkApAMBBQd3aFRvdGFsBQNuaWwCAV8JAMwIAgkAkQMCBQJ3aAULd2hJZHhMZXZlbHMJAMwIAgMJAAACCQCQAwEJALUJAgkAkQMCBQJ3aAUId2hJZHhSZXMCAV8FBk5VTVJFUwkAkQMCBQJ3aAUId2hJZHhSZXMCCzBfMF8wXzBfMF8wCQDMCAIDCQAAAgkAkAMBCQC1CQIJAJEDAgUCd2gFCHdoSWR4TWF0AgFfBQZOVU1SRVMJAJEDAgUCd2gFCHdoSWR4TWF0AgswXzBfMF8wXzBfMAkAzAgCCQCRAwIFAndoBQl3aElkeFByb2QJAMwIAgUGd2hMb2Z0BQNuaWwBFWdldFdhcmVob3VzZVNwYWNlTGVmdAEJY3VycmVudFdoBAtvY2N1cGllZFZvbAkBF2dldFdhcmVob3VzZU9jY3VwaWVkVm9sAQUJY3VycmVudFdoBA9jdXJyV2hMb2NrZWRWb2wJAQ1wYXJzZUludFZhbHVlAQkAkQMCCQC1CQIJAJEDAgUJY3VycmVudFdoBQl3aElkeExPRlQCAV8FCXZvbExvY2tlZAkAZQIJAGUCCQEXZ2V0V2FyZWhvdXNlVG90YWxWb2x1bWUBCQCRAwIFCWN1cnJlbnRXaAULd2hJZHhMZXZlbHMFC29jY3VwaWVkVm9sBQ9jdXJyV2hMb2NrZWRWb2wBCW1vdmVTdHVmZgMKY2FyZ29QYXJ0cwljdXJyZW50V2gLY3VycmVudFBhY2sDCQECIT0CCQCQAwEFCmNhcmdvUGFydHMAAwkAAgECNGNhcmdvTGlzdFN0ciBzaG91bGQgY29udGFpbiBleGFjdGx5IDIgJzonIHNlcGFyYXRvcnMECHJlc1BhcnRzCQC1CQIJAJEDAgUKY2FyZ29QYXJ0cwAAAgFfBAhtYXRQYXJ0cwkAtQkCCQCRAwIFCmNhcmdvUGFydHMAAQIBXwQJcHJvZFBhcnRzAwkAAAIJAJEDAgUKY2FyZ29QYXJ0cwACAgAFA25pbAkAvAkCCQCRAwIFCmNhcmdvUGFydHMAAgIBXwMJAQIhPQIJAJADAQUIcmVzUGFydHMFBk5VTVJFUwkAAgECIEFsbCA2IHJlc291cmNlcyBzaG91bGQgYmUgcGFzc2VkAwkBAiE9AgkAkAMBBQhtYXRQYXJ0cwUGTlVNUkVTCQACAQIgQWxsIDYgbWF0ZXJpYWxzIHNob3VsZCBiZSBwYXNzZWQEC3doU3BhY2VMZWZ0CQEVZ2V0V2FyZWhvdXNlU3BhY2VMZWZ0AQUJY3VycmVudFdoBAljdXJyV2hSZXMJALUJAgkAkQMCBQljdXJyZW50V2gFCHdoSWR4UmVzAgFfBAljdXJyV2hNYXQJALUJAgkAkQMCBQljdXJyZW50V2gFCHdoSWR4TWF0AgFfBApjdXJyV2hQcm9kAwkAAAIJAJEDAgUJY3VycmVudFdoBQl3aElkeFByb2QCAAUDbmlsCQC8CQIJAJEDAgUJY3VycmVudFdoBQl3aElkeFByb2QCAV8EDmN1cnJlbnRQYWNrUmVzCQC1CQIJAJEDAgULY3VycmVudFBhY2sFCGJwSWR4UmVzAgFfBA5jdXJyZW50UGFja01hdAkAtQkCCQCRAwIFC2N1cnJlbnRQYWNrBQhicElkeE1hdAIBXwQPY3VycmVudFBhY2tQcm9kAwkAAAIJAJEDAgULY3VycmVudFBhY2sFCWJwSWR4UHJvZAIABQNuaWwJALwJAgkAkQMCBQtjdXJyZW50UGFjawUJYnBJZHhQcm9kAgFfCgEDbXZSAgNhY2MEaXRlbQQBaQgFA2FjYwJfMQQCYW0JAQ1wYXJzZUludFZhbHVlAQUEaXRlbQQDd2hyCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUJY3VycldoUmVzBQFpBANicHIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQ5jdXJyZW50UGFja1JlcwUBaQMJAAACBQJhbQAACQCWCgQJAGQCBQFpAAEJAM0IAggFA2FjYwJfMgkAkQMCBQljdXJyV2hSZXMFAWkJAM0IAggFA2FjYwJfMwkAkQMCBQ5jdXJyZW50UGFja1JlcwUBaQgFA2FjYwJfNAMJAGYCBQJhbQAAAwkAZgIFAmFtBQNicHIJAAIBCQCsAgIJAKwCAgkArAICCQCsAgICEEF0dGVtcHQgdG8gdGFrZSAFBGl0ZW0CGSBmcm9tIGJhY2twYWNrLCBidXQgb25seSAJAKQDAQUDYnByAgogYXZhaWxhYmxlCQCWCgQJAGQCBQFpAAEJAM0IAggFA2FjYwJfMgkApAMBCQBkAgUDd2hyBQJhbQkAzQgCCAUDYWNjAl8zCQCkAwEJAGUCBQNicHIFAmFtCQBkAggFA2FjYwJfNAUCYW0DCQBmAgkBAS0BBQJhbQUDd2hyCQACAQkArAICCQCsAgIJAKwCAgkArAICAhBBdHRlbXB0IHRvIHRha2UgCQCkAwEJAQEtAQUCYW0CGiBmcm9tIHdhcmVob3VzZSwgYnV0IG9ubHkgCQCkAwEFA3docgIKIGF2YWlsYWJsZQkAlgoECQBkAgUBaQABCQDNCAIIBQNhY2MCXzIJAKQDAQkAZAIFA3docgUCYW0JAM0IAggFA2FjYwJfMwkApAMBCQBlAgUDYnByBQJhbQkAZAIIBQNhY2MCXzQFAmFtBAFyCgACJGwFCHJlc1BhcnRzCgACJHMJAJADAQUCJGwKAAUkYWNjMAkAlgoEAAAFA25pbAUDbmlsAAAKAQUkZjBfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBA212UgIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQITTGlzdCBzaXplIGV4Y2VlZHMgNgkBBSRmMF8yAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgoBA212TQIDYWNjBGl0ZW0EAWkIBQNhY2MCXzEEAmFtCQENcGFyc2VJbnRWYWx1ZQEFBGl0ZW0EA3dobQkBDXBhcnNlSW50VmFsdWUBCQCRAwIFCWN1cnJXaE1hdAUBaQQDYnBtCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUOY3VycmVudFBhY2tNYXQFAWkDCQAAAgUCYW0AAAkAlgoECQBkAgUBaQABCQDNCAIIBQNhY2MCXzIJAJEDAgUJY3VycldoTWF0BQFpCQDNCAIIBQNhY2MCXzMJAJEDAgUOY3VycmVudFBhY2tNYXQFAWkIBQNhY2MCXzQDCQBmAgUCYW0AAAMJAGYCBQJhbQUDYnBtCQACAQkArAICCQCsAgIJAKwCAgkArAICAhBBdHRlbXB0IHRvIHRha2UgBQRpdGVtAhkgZnJvbSBiYWNrcGFjaywgYnV0IG9ubHkgCQCkAwEFA2JwbQIKIGF2YWlsYWJsZQkAlgoECQBkAgUBaQABCQDNCAIIBQNhY2MCXzIJAKQDAQkAZAIFA3dobQUCYW0JAM0IAggFA2FjYwJfMwkApAMBCQBlAgUDYnBtBQJhbQkAZAIIBQNhY2MCXzQFAmFtAwkAZgIJAQEtAQUCYW0FA3dobQkAAgEJAKwCAgkArAICCQCsAgIJAKwCAgIQQXR0ZW1wdCB0byB0YWtlIAkApAMBCQEBLQEFAmFtAhogZnJvbSB3YXJlaG91c2UsIGJ1dCBvbmx5IAkApAMBBQN3aG0CCiBhdmFpbGFibGUJAJYKBAkAZAIFAWkAAQkAzQgCCAUDYWNjAl8yCQCkAwEJAGQCBQN3aG0FAmFtCQDNCAIIBQNhY2MCXzMJAKQDAQkAZQIFA2JwbQUCYW0JAGQCCAUDYWNjAl80BQJhbQQBbQoAAiRsBQhtYXRQYXJ0cwoAAiRzCQCQAwEFAiRsCgAFJGFjYzAJAJYKBAAABQNuaWwFA25pbAgFAXICXzQKAQUkZjFfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBA212TQIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMV8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQITTGlzdCBzaXplIGV4Y2VlZHMgNgkBBSRmMV8yAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgoBA212UAIDYWNjBGl0ZW0EAWkIBQNhY2MCXzEEAmFtCQENcGFyc2VJbnRWYWx1ZQEFBGl0ZW0EA3docAMJAGYCCQCQAwEFCmN1cnJXaFByb2QFAWkJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQpjdXJyV2hQcm9kBQFpAAAEA2JwcAMJAGYCCQCQAwEFD2N1cnJlbnRQYWNrUHJvZAUBaQkBDXBhcnNlSW50VmFsdWUBCQCRAwIFD2N1cnJlbnRQYWNrUHJvZAUBaQAAAwkAAAIFAmFtAAAJAJYKBAkAZAIFAWkAAQkAzQgCCAUDYWNjAl8yCQCkAwEFA3docAkAzQgCCAUDYWNjAl8zCQCkAwEFA2JwcAgFA2FjYwJfNAMJAGYCBQJhbQAAAwkAZgIFAmFtBQNicHAJAAIBCQCsAgIJAKwCAgkArAICCQCsAgICEEF0dGVtcHQgdG8gdGFrZSAFBGl0ZW0CGSBmcm9tIGJhY2twYWNrLCBidXQgb25seSAJAKQDAQUDYnBwAgogYXZhaWxhYmxlBAhkZWx0YVZvbAkAZQIJAQh0b1ZvbHVtZQIJAGQCBQN3aHAFAmFtBQ5QUk9EVUNUUEtHU0laRQkBCHRvVm9sdW1lAgUDd2hwBQ5QUk9EVUNUUEtHU0laRQkAlgoECQBkAgUBaQABCQDNCAIIBQNhY2MCXzIJAKQDAQkAZAIFA3docAUCYW0JAM0IAggFA2FjYwJfMwkApAMBCQBlAgUDYnBwBQJhbQkAZAIIBQNhY2MCXzQFCGRlbHRhVm9sAwkAZgIJAQEtAQUCYW0FA3docAkAAgEJAKwCAgkArAICCQCsAgIJAKwCAgIQQXR0ZW1wdCB0byB0YWtlIAkApAMBCQEBLQEFAmFtAhogZnJvbSB3YXJlaG91c2UsIGJ1dCBvbmx5IAkApAMBBQN3aHACCiBhdmFpbGFibGUECGRlbHRhVm9sCQBlAgkBCHRvVm9sdW1lAgkAZAIFA3docAUCYW0FDlBST0RVQ1RQS0dTSVpFCQEIdG9Wb2x1bWUCBQN3aHAFDlBST0RVQ1RQS0dTSVpFCQCWCgQJAGQCBQFpAAEJAM0IAggFA2FjYwJfMgkApAMBCQBkAgUDd2hwBQJhbQkAzQgCCAUDYWNjAl8zCQCkAwEJAGUCBQNicHAFAmFtCQBkAggFA2FjYwJfNAUIZGVsdGFWb2wEAXADCQECIT0CCQCQAwEFCXByb2RQYXJ0cwAACgACJGwFCXByb2RQYXJ0cwoAAiRzCQCQAwEFAiRsCgAFJGFjYzAJAJYKBAAABQNuaWwFA25pbAgFAW0CXzQKAQUkZjJfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBA212UAIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMl8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgNTAJAQUkZjJfMgIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgALAAwADQAOAA8AEAARABIAEwAUABUAFgAXABgAGQAaABsAHAAdAB4AHwAgACEAIgAjACQAJQAmACcAKAApACoAKwAsAC0ALgAvADAAMQAyCQCWCgQAAAUKY3VycldoUHJvZAUPY3VycmVudFBhY2tQcm9kCAUBbQJfNAQIdm9sU2FsZG8IBQFwAl80AwkAZgIFCHZvbFNhbGRvBQt3aFNwYWNlTGVmdAkAAgEJAKwCAgkArAICCQCsAgIJAKwCAgIVQXR0ZW1wdCB0byBwdXQgdG90YWwgCQCkAwEFCHZvbFNhbGRvAhEgc3R1ZmYsIGJ1dCBvbmx5IAkApAMBBQt3aFNwYWNlTGVmdAIVIHdhcmVob3VzZSBzcGFjZSBsZWZ0CQCZCgcJALkJAggFAXICXzICAV8JALkJAggFAW0CXzICAV8JALoJAggFAXACXzICAV8JALkJAggFAXICXzMCAV8JALkJAggFAW0CXzMCAV8JALoJAggFAXACXzMCAV8FCHZvbFNhbGRvARJleHBlZGl0aW9uSW50ZXJuYWwCBmNhbGxlcgR0eElkBAh1c2VyQWRkcgkApQgBBQZjYWxsZXIEBmJpZ051bQkBA2FicwEJAJ4DAQUEdHhJZAQHZnJlZU51bQkBC3ZhbHVlT3JFbHNlAgkAnwgBCQESa2V5TmV4dEZyZWVMYW5kTnVtAAkAZAIFD1BSRVNBTEVOVU1MQU5EUwABBAdsYW5kTnVtCQCkAwEFB2ZyZWVOdW0EDGNvbnRpbmVudElkeAkAoAMBCQC7AgIFBmJpZ051bQUFRklWRVgECHRlcnJhaW5zCQELZ2VuVGVycmFpbnMCBQZiaWdOdW0FDGNvbnRpbmVudElkeAQJY29udGluZW50CQCRAwIFCmNvbnRpbmVudHMFDGNvbnRpbmVudElkeAQFaXNzdWUJAMIIBQkBB25mdE5hbWUCBQdsYW5kTnVtAgFTCQC5CQIJAMwIAgUHbGFuZE51bQkAzAgCAgFTCQDMCAIFCHRlcnJhaW5zCQDMCAIFCWNvbnRpbmVudAUDbmlsAgFfAAEAAAcEB2Fzc2V0SWQJALgIAQUFaXNzdWUEAmlkCQDYBAEFB2Fzc2V0SWQJAJQKAgkAzAgCCQEMSW50ZWdlckVudHJ5AgkBEmtleU5leHRGcmVlTGFuZE51bQAJAGQCBQdmcmVlTnVtAAEJAMwIAgUFaXNzdWUJAMwIAgkBC1N0cmluZ0VudHJ5AgkBEGtleUxhbmRUb0Fzc2V0SWQBBQdsYW5kTnVtBQJpZAkAzAgCCQELU3RyaW5nRW50cnkCCQEVa2V5TGFuZEFzc2V0SWRUb093bmVyAQUCaWQFCHVzZXJBZGRyCQDMCAIJAQtTdHJpbmdFbnRyeQIJARFrZXlMYW5kTnVtVG9Pd25lcgEFB2xhbmROdW0FCHVzZXJBZGRyCQDMCAIJAQxJbnRlZ2VyRW50cnkCCQEWa2V5SW5mcmFMZXZlbEJ5QXNzZXRJZAEFAmlkAAAJAMwIAgkBDEludGVnZXJFbnRyeQIJAR5rZXlJbmZyYUxldmVsQnlBc3NldElkQW5kT3duZXICBQJpZAUIdXNlckFkZHIAAAkAzAgCCQEOU2NyaXB0VHJhbnNmZXIDBQZjYWxsZXIAAQUHYXNzZXRJZAUDbmlsCQCUCgIFAmlkBQljb250aW5lbnQBDGZsaWdodENvbW1vbgMIdXNlckFkZHIHbWVzc2FnZQNzaWcDCQEBIQEJAMQTAwUHbWVzc2FnZQUDc2lnBQNwdWIJAAIBAhhzaWduYXR1cmUgZG9lcyBub3QgbWF0Y2gEBXBhcnRzCQC8CQIJALAJAQUHbWVzc2FnZQIBOwQJZmxpZ2h0TG9nCQC8CQIJAJEDAgUFcGFydHMAAAIBfAQCaHAJALUJAgkAkQMCBQlmbGlnaHRMb2cFCGZsSGVhbHRoAgFfBAVjdXJIUAkBDXBhcnNlSW50VmFsdWUBCQCRAwIFAmhwAAAEBW5ld0hQCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUCaHAAAQQLbmV3TG9jVHhWZXIJALUJAgkAkQMCBQVwYXJ0cwABAgE6BAtuZXdMb2NhdGlvbgkAkQMCBQtuZXdMb2NUeFZlcgAABAR0aW1lCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUJZmxpZ2h0TG9nBQtmbFRpbWVzdGFtcAMDCQBmAgUEdGltZQkAZAIIBQlsYXN0QmxvY2sJdGltZXN0YW1wBRFGSVZFTUlOVVRFU01JTExJUwYJAGYCCQBlAggFCWxhc3RCbG9jawl0aW1lc3RhbXAFEUZJVkVNSU5VVEVTTUlMTElTBQR0aW1lCQACAQkArAICCQCsAgIJAKwCAgIcc2lnbmF0dXJlIG91dGRhdGVkOiBsb2dUaW1lPQkApAMBBQR0aW1lAgksIGJjVGltZT0JAKQDAQgFCWxhc3RCbG9jawl0aW1lc3RhbXAECXR4RnJvbU1zZwkAkQMCBQtuZXdMb2NUeFZlcgABBAZsYXN0VHgJAQt2YWx1ZU9yRWxzZQIJAKIIAQkBEWtleUxhc3RUeElkQnlVc2VyAQUIdXNlckFkZHICAAMJAQIhPQIFBmxhc3RUeAUJdHhGcm9tTXNnCQACAQkArAICCQCsAgIJAKwCAgIeVHggaWRzIGRvbid0IG1hdGNoISBJbiBzdGF0ZTogBQZsYXN0VHgCCiwgaW4gbXNnOiAFCXR4RnJvbU1zZwQLZHVja0Fzc2V0SWQJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAoggBCQEUa2V5U3Rha2VkRHVja0J5T3duZXIBBQh1c2VyQWRkcgIcWW91IGRvbid0IGhhdmUgYSBkdWNrIHN0YWtlZAQJa2V5SGVhbHRoCQENa2V5RHVja0hlYWx0aAEFC2R1Y2tBc3NldElkBAVtYXhIUAkBCW1heEhlYWx0aAEJAQt2YWx1ZU9yRWxzZQIJAJ8IAQkBDGtleUR1Y2tMZXZlbAEFC2R1Y2tBc3NldElkAAAEDG9sZEZyb21TdGF0ZQkBC3ZhbHVlT3JFbHNlAgkAnwgBBQlrZXlIZWFsdGgFBW1heEhQAwkBAiE9AgUMb2xkRnJvbVN0YXRlBQVjdXJIUAkAAgEJAKwCAgkArAICCQCsAgICCm9sZEhlYWx0aD0JAKQDAQUMb2xkRnJvbVN0YXRlAi8gZnJvbSBzdGF0ZSBkb2VzIG5vdCBtYXRjaCBvbmUgZnJvbSBmbGlnaHQgbG9nPQkApAMBBQVjdXJIUAMJAGcCAAAFBWN1ckhQCQACAQIeWW91IGNhbid0IGZseSB3aXRoIHplcm8gaGVhbHRoAwkBASEBCQEXY2FuV2VhckN1cnJlbnRFcXVpcG1lbnQBBQtkdWNrQXNzZXRJZAkAAgECFkVxdWlwbWVudCBpbmNvbXBhdGlibGUEBWJvbnVzAwkAZgIJAJADAQUJZmxpZ2h0TG9nBQdmbEJvbnVzCQCRAwIFCWZsaWdodExvZwUHZmxCb251cwIABAhwcm9kVXNlZAMJAGYCCQCQAwEFCWZsaWdodExvZwULZmxQcm9kc1VzZWQJAJEDAgUJZmxpZ2h0TG9nBQtmbFByb2RzVXNlZAIABApzZW50QW1vdW50AwMJAGYCBQVuZXdIUAAACQAAAgUFYm9udXMCASQHCQEFYXNJbnQBCQD8BwQFDHJlc3RDb250cmFjdAINc2VuZFVzZHRQcml6ZQkAzAgCBQh1c2VyQWRkcgUDbmlsBQNuaWwAAAkAlwoFBQVuZXdIUAULZHVja0Fzc2V0SWQFCnNlbnRBbW91bnQFC25ld0xvY2F0aW9uBQhwcm9kVXNlZAEMYXBwbHlCb251c2VzAgtsYW5kQXNzZXRJZAZwaWVjZXMECmluZnJhTGV2ZWwJAQt2YWx1ZU9yRWxzZQIJAJ8IAQkBFmtleUluZnJhTGV2ZWxCeUFzc2V0SWQBBQtsYW5kQXNzZXRJZAAABAlhcnRQaWVjZXMJAQt2YWx1ZU9yRWxzZQIJAJ8IAQkBIGtleUxhbmRBcnRTdGF0dXNCeVR5cGVBbmRBc3NldElkAgUKQVJUUFJFU0FMRQULbGFuZEFzc2V0SWQAAAQEYWRkNgkAaQIFCmluZnJhTGV2ZWwABgQEYWRkNwkAaQIFCmluZnJhTGV2ZWwABwkAZAIJAGQCBQ9EQUlMWVJFU0JZUElFQ0UJAGsDBQ9EQUlMWVJFU0JZUElFQ0UJAGQCCQBkAgUKaW5mcmFMZXZlbAUEYWRkNgkAaAIAAgUEYWRkNwAFCQBrAwUPREFJTFlSRVNCWVBJRUNFBQlhcnRQaWVjZXMJAGgCBQZwaWVjZXMABQEUY2hlY2tDbGFpbUNvbmRpdGlvbnMDBGFkZHIJY2xhaW1Nb2RlDWxhbmRBc3NldElkSW4EDSR0MDMzNzM4MzQyNzcDCQAAAgUJY2xhaW1Nb2RlBQtjbGFpbU1vZGVXaAkAlAoCBQ1sYW5kQXNzZXRJZEluCQELdmFsdWVPckVsc2UCCQCiCAEJARRrZXlTdGFrZWREdWNrQnlPd25lcgEFBGFkZHICAAQLZHVja0Fzc2V0SWQJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAoggBCQEUa2V5U3Rha2VkRHVja0J5T3duZXIBBQRhZGRyAhxZb3UgZG9uJ3QgaGF2ZSBhIGR1Y2sgc3Rha2VkBAtjdXJMb2NhdGlvbgkBC3ZhbHVlT3JFbHNlAgkAoggBCQEPa2V5RHVja0xvY2F0aW9uAQULZHVja0Fzc2V0SWQFD0RFRkFVTFRMT0NBVElPTgQDbG9jCQC1CQIJAQV2YWx1ZQEFC2N1ckxvY2F0aW9uAgFfAwkBAiE9AgkAkQMCBQNsb2MFCmxvY0lkeFR5cGUCAUwJAAIBCQCsAgIJAKwCAgIWRHVjayBsb2NhdGlvbiB0eXBlIGlzIAkAkQMCBQNsb2MFCmxvY0lkeFR5cGUCESwgYnV0IHNob3VsZCBiZSBMCQCUCgIJAJEDAgUDbG9jBQhsb2NJZHhJZAULZHVja0Fzc2V0SWQEC2xhbmRBc3NldElkCAUNJHQwMzM3MzgzNDI3NwJfMQQGZHVja0lkCAUNJHQwMzM3MzgzNDI3NwJfMgQFYXNzZXQJAQV2YWx1ZQEJAOwHAQkA2QQBBQtsYW5kQXNzZXRJZAQHdGltZUtleQkBFmtleVN0YWtlZFRpbWVCeUFzc2V0SWQBBQtsYW5kQXNzZXRJZAQJc2F2ZWRUaW1lCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAJ8IAQUHdGltZUtleQkArAICCQCsAgICBUxhbmQgCAUFYXNzZXQEbmFtZQIOIGlzIG5vdCBzdGFrZWQEBW93bmVyCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAKIIAQkBFWtleUxhbmRBc3NldElkVG9Pd25lcgEFC2xhbmRBc3NldElkCQCsAgIJAKwCAgIETkZUIAgFBWFzc2V0BG5hbWUCDCBpcyBvcnBoYW5lZAMJAQIhPQIFBW93bmVyBQRhZGRyCQACAQkArAICBQpMQU5EUFJFRklYAg0gaXMgbm90IHlvdXJzBAFkCQC1CQIIBQVhc3NldAtkZXNjcmlwdGlvbgIBXwkAlgoEBQZkdWNrSWQFC2xhbmRBc3NldElkBQFkBQlzYXZlZFRpbWUBEGNsYWltUmVzSW50ZXJuYWwEBGFkZHIGYW1vdW50CWNsYWltTW9kZQ1sYW5kQXNzZXRJZEluAwkAZgIAAAUGYW1vdW50CQACAQIPTmVnYXRpdmUgYW1vdW50BAFjCQEUY2hlY2tDbGFpbUNvbmRpdGlvbnMDBQRhZGRyBQljbGFpbU1vZGUFDWxhbmRBc3NldElkSW4ECGxhbmRTaXplCQCRAwIIBQFjAl8zBQtyZWNMYW5kU2l6ZQQNdGVycmFpbkNvdW50cwkBDWNvdW50VGVycmFpbnMBCQCRAwIIBQFjAl8zBQtyZWNUZXJyYWlucwQJZGVsdGFUaW1lCQBlAggFCWxhc3RCbG9jawl0aW1lc3RhbXAIBQFjAl80AwkAZgIAAAUJZGVsdGFUaW1lCQACAQkArAICCQCsAgIJAKwCAgImU2F2ZWQgdGltZXN0YW1wIGlzIGluIGZ1dHVyZSwgc2F2ZWQgPSAJAKQDAQgFAWMCXzQCDCwgY3VycmVudCA9IAkApAMBCAUJbGFzdEJsb2NrCXRpbWVzdGFtcAQGcGllY2VzCQEPbnVtUGllY2VzQnlTaXplAQUIbGFuZFNpemUEFmRhaWx5UHJvZHVjdGlvbkJ5UGllY2UJAQxhcHBseUJvbnVzZXMCCAUBYwJfMgUGcGllY2VzBAhhdmFpbFJlcwkAawMFCWRlbHRhVGltZQkAaAIFFmRhaWx5UHJvZHVjdGlvbkJ5UGllY2UFBnBpZWNlcwUJREFZTUlMTElTAwkAZgIFBmFtb3VudAUIYXZhaWxSZXMJAAIBCQCsAgIJAKwCAgkArAICAiJOb3QgZW5vdWdoIHJlc291cmNlcywgYXZhaWxhYmxlID0gCQCkAwEFCGF2YWlsUmVzAg4sIHJlcXVlc3RlZCA9IAkApAMBBQZhbW91bnQEDG5ld0RlbHRhVGltZQkAawMJAGUCBQhhdmFpbFJlcwUGYW1vdW50BQlEQVlNSUxMSVMJAGgCBRZkYWlseVByb2R1Y3Rpb25CeVBpZWNlBQZwaWVjZXMEDG5ld1RpbWVzdGFtcAkAZQIIBQlsYXN0QmxvY2sJdGltZXN0YW1wBQxuZXdEZWx0YVRpbWUECWxhbmRJbmRleAkAaQIFBnBpZWNlcwUFU1NJWkUECnJlc1RvQ2xhaW0JAQl2aXJ0Q2xhaW0EBQ10ZXJyYWluQ291bnRzCQBlAgUJZGVsdGFUaW1lBQxuZXdEZWx0YVRpbWUFCWxhbmRJbmRleAUWZGFpbHlQcm9kdWN0aW9uQnlQaWVjZQQFd2hLZXkJARJrZXlXYXJlaG91c2VCeUxhbmQBCAUBYwJfMgQKaW5mcmFMZXZlbAkBC3ZhbHVlT3JFbHNlAgkAnwgBCQEWa2V5SW5mcmFMZXZlbEJ5QXNzZXRJZAEIBQFjAl8yAAAECWN1cnJlbnRXaAkBDGdldFdhcmVob3VzZQMFBXdoS2V5BQlsYW5kSW5kZXgFCmluZnJhTGV2ZWwEBGxvZnQJALUJAgkAkQMCBQljdXJyZW50V2gFCXdoSWR4TE9GVAIBXwQLd2hTcGFjZUxlZnQJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQRsb2Z0BQd2b2xGcmVlAwMJAAACBQljbGFpbU1vZGUFC2NsYWltTW9kZVdoCQBmAgUGYW1vdW50BQt3aFNwYWNlTGVmdAcJAAIBCQCsAgIJAKwCAgIFT25seSAJAKQDAQULd2hTcGFjZUxlZnQCGCBzcGFjZSBsZWZ0IGluIHdhcmVob3VzZQQFYnBLZXkJARFrZXlCYWNrcGFja0J5RHVjawEIBQFjAl8xBAtjdXJyZW50UGFjawkBC2dldEJhY2twYWNrAQUFYnBLZXkEDmN1cnJlbnRQYWNrUmVzCQC1CQIJAJEDAgULY3VycmVudFBhY2sFCGJwSWR4UmVzAgFfBAxjdXJyZW50V2hSZXMJALUJAgkAkQMCBQljdXJyZW50V2gFCHdoSWR4UmVzAgFfBA0kdDAzNjY1MTM3NTIyAwkAAAIFCWNsYWltTW9kZQULY2xhaW1Nb2RlV2gJAJYKBAkBBmFkZFJlcwUFDGN1cnJlbnRXaFJlcwUNdGVycmFpbkNvdW50cwkAZQIFCWRlbHRhVGltZQUMbmV3RGVsdGFUaW1lBQlsYW5kSW5kZXgFFmRhaWx5UHJvZHVjdGlvbkJ5UGllY2UJAJEDAgULY3VycmVudFBhY2sFCGJwSWR4UmVzCQBkAgkBDXBhcnNlSW50VmFsdWUBCQCRAwIFBGxvZnQFC3ZvbE9jY3VwaWVkCAUKcmVzVG9DbGFpbQJfMgkAZQIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQRsb2Z0BQd2b2xGcmVlCAUKcmVzVG9DbGFpbQJfMgMJAAACBQljbGFpbU1vZGUFDWNsYWltTW9kZUR1Y2sJAJYKBAkAkQMCBQljdXJyZW50V2gFCHdoSWR4UmVzCQEGYWRkUmVzBQUOY3VycmVudFBhY2tSZXMFDXRlcnJhaW5Db3VudHMJAGUCBQlkZWx0YVRpbWUFDG5ld0RlbHRhVGltZQUJbGFuZEluZGV4BRZkYWlseVByb2R1Y3Rpb25CeVBpZWNlCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUEbG9mdAULdm9sT2NjdXBpZWQJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQRsb2Z0BQd2b2xGcmVlBAVkaXN0cgkBDWRpc3RyaWJ1dGVSZXMEBQxjdXJyZW50V2hSZXMFDmN1cnJlbnRQYWNrUmVzBQpyZXNUb0NsYWltBQt3aFNwYWNlTGVmdAQEd2hBbQkAlwMBCQDMCAIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQRsb2Z0BQd2b2xGcmVlCQDMCAIIBQpyZXNUb0NsYWltAl8yBQNuaWwJAJYKBAgFBWRpc3RyAl8xCAUFZGlzdHICXzIJAGQCCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUEbG9mdAULdm9sT2NjdXBpZWQFBHdoQW0JAGUCCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUEbG9mdAUHdm9sRnJlZQUEd2hBbQQFd2hSZXMIBQ0kdDAzNjY1MTM3NTIyAl8xBAVicFJlcwgFDSR0MDM2NjUxMzc1MjICXzIEBWxvZnRPCAUNJHQwMzY2NTEzNzUyMgJfMwQFbG9mdEYIBQ0kdDAzNjY1MTM3NTIyAl80CQCXCgUJAMwIAgkBDEludGVnZXJFbnRyeQIJARZrZXlTdGFrZWRUaW1lQnlBc3NldElkAQgFAWMCXzIFDG5ld1RpbWVzdGFtcAkAzAgCCQEMSW50ZWdlckVudHJ5AgkBImtleVN0YWtlZFRpbWVCeVR5cGVBc3NldElkQW5kT3duZXIDBQpMQU5EUFJFRklYCAUBYwJfMgUEYWRkcgUMbmV3VGltZXN0YW1wBQNuaWwFBWJwS2V5CQDMCAIJAJEDAgULY3VycmVudFBhY2sFCmJwSWR4TGV2ZWwJAMwIAgUFYnBSZXMJAMwIAgkAkQMCBQtjdXJyZW50UGFjawUIYnBJZHhNYXQJAMwIAgkAkQMCBQtjdXJyZW50UGFjawUJYnBJZHhQcm9kBQNuaWwFBXdoS2V5CQDMCAIJAJEDAgUJY3VycmVudFdoBQt3aElkeExldmVscwkAzAgCBQV3aFJlcwkAzAgCCQCRAwIFCWN1cnJlbnRXaAUId2hJZHhNYXQJAMwIAgkAkQMCBQljdXJyZW50V2gFCXdoSWR4UHJvZAkAzAgCCQC5CQIJAMwIAgkAkQMCBQRsb2Z0BQl2b2xMb2NrZWQJAMwIAgkApAMBBQVsb2Z0TwkAzAgCCQCkAwEFBWxvZnRGCQDMCAIJAJEDAgUEbG9mdAUIdm9sVG90YWwFA25pbAIBXwUDbmlsAQhjbGFpbUFsbAQEYWRkcgtsYW5kQXNzZXRJZAZwaWVjZXMJY2xhaW1Nb2RlBAd0aW1lS2V5CQEWa2V5U3Rha2VkVGltZUJ5QXNzZXRJZAEFC2xhbmRBc3NldElkBAlzYXZlZFRpbWUJAQV2YWx1ZQEJAJ8IAQUHdGltZUtleQQIYXZhaWxSZXMJAGgCCQBrAwkAZQIIBQlsYXN0QmxvY2sJdGltZXN0YW1wBQlzYXZlZFRpbWUJAQxhcHBseUJvbnVzZXMCBQtsYW5kQXNzZXRJZAUGcGllY2VzBQlEQVlNSUxMSVMFBnBpZWNlcwkBEGNsYWltUmVzSW50ZXJuYWwEBQRhZGRyBQhhdmFpbFJlcwUJY2xhaW1Nb2RlBQtsYW5kQXNzZXRJZAENdXBJbmZyYUNvbW1vbgQMc2hvdWxkVXNlTWF0BmNhbGxlcg1wYXltZW50QW1vdW50C2xhbmRBc3NldElkBARhZGRyCQClCAEFBmNhbGxlcgQBYwkBFGNoZWNrQ2xhaW1Db25kaXRpb25zAwUEYWRkcgUTY2xhaW1Nb2RlV2hUaGVuRHVjawULbGFuZEFzc2V0SWQEBnBpZWNlcwkBD251bVBpZWNlc0J5U2l6ZQEJAJEDAggFAWMCXzMFC3JlY0xhbmRTaXplBAhpbmZyYUtleQkBFmtleUluZnJhTGV2ZWxCeUFzc2V0SWQBCAUBYwJfMgQIY3VyTGV2ZWwJAQt2YWx1ZU9yRWxzZQIJAJ8IAQUIaW5mcmFLZXkAAAMDCQEBIQEFGEtTX0FMTE9XX0JJR19JTkZSQV9NRVJHRQkAZwIFCGN1ckxldmVsAAMHCQACAQImQ3VycmVudGx5IG1heCBpbmZyYXN0cnVjdHVyZSBsZXZlbCA9IDMECG1heEluZnJhCQBkAgkAaQIJAQRzcXJ0BAUGcGllY2VzAAAAAAUERE9XTgAFAAIECG5ld0xldmVsCQBkAgUIY3VyTGV2ZWwAAQMDBRhLU19BTExPV19CSUdfSU5GUkFfTUVSR0UJAGYCBQhuZXdMZXZlbAUIbWF4SW5mcmEHCQACAQkArAICAiVDdXJyZW50bHkgbWF4IGluZnJhc3RydWN0dXJlIGxldmVsID0gCQCkAwEFCG1heEluZnJhBARjb3N0CQBrAwUVSW5mcmFVcGdyYWRlQ29zdFNVc2R0CQBoAgUGcGllY2VzBQhuZXdMZXZlbAUFU1NJWkUDAwkBASEBBQxzaG91bGRVc2VNYXQJAQIhPQIFDXBheW1lbnRBbW91bnQFBGNvc3QHCQACAQkArAICAhtQYXltZW50IGF0dGFjaGVkIHNob3VsZCBiZSAJAKQDAQUEY29zdAQFYnBLZXkJARFrZXlCYWNrcGFja0J5RHVjawEIBQFjAl8xBAtjdXJyZW50UGFjawkBC2dldEJhY2twYWNrAQUFYnBLZXkEBW1MaXN0CQC1CQIJAJEDAgULY3VycmVudFBhY2sFCGJwSWR4TWF0AgFfBAdtYXRVc2VkCQBrAwURSW5mcmFVcGdyYWRlQ29zdFMJAGgCBQZwaWVjZXMFCG5ld0xldmVsBQVTU0laRQQGbmV3TWF0CQC5CQIJARFzdWJ0cmFjdE1hdGVyaWFscwMFDHNob3VsZFVzZU1hdAUFbUxpc3QFB21hdFVzZWQCAV8EC2NsYWltUmVzdWx0CQEIY2xhaW1BbGwEBQRhZGRyCAUBYwJfMgUGcGllY2VzBRNjbGFpbU1vZGVXaFRoZW5EdWNrBAZ3aERhdGEIBQtjbGFpbVJlc3VsdAJfNQQGb2xkVm9sCQEXZ2V0V2FyZWhvdXNlVG90YWxWb2x1bWUBCQCRAwIFBndoRGF0YQULd2hJZHhMZXZlbHMECm5ld1ZvbERhdGEJALkJAgkAzAgCCQCRAwIJALUJAgkAkQMCBQZ3aERhdGEFC3doSWR4TGV2ZWxzAgFfAAAJAMwIAgkApAMBBQhuZXdMZXZlbAUDbmlsAgFfBAZuZXdWb2wJARdnZXRXYXJlaG91c2VUb3RhbFZvbHVtZQEFCm5ld1ZvbERhdGEEBGxvZnQJALUJAgkAkQMCBQZ3aERhdGEFCXdoSWR4TE9GVAIBXwQKbmV3TG9mdFN0cgkAuQkCCQDMCAIJAJEDAgUEbG9mdAUJdm9sTG9ja2VkCQDMCAIJAJEDAgUEbG9mdAULdm9sT2NjdXBpZWQJAMwIAgkApAMBCQBlAgkAZAIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQRsb2Z0BQd2b2xGcmVlBQZuZXdWb2wFBm9sZFZvbAkAzAgCCQCkAwEFBm5ld1ZvbAUDbmlsAgFfCQCVCgMJAM4IAgkAzAgCCQEMSW50ZWdlckVudHJ5AgUIaW5mcmFLZXkFCG5ld0xldmVsCQDMCAIJAQxJbnRlZ2VyRW50cnkCCQEea2V5SW5mcmFMZXZlbEJ5QXNzZXRJZEFuZE93bmVyAggFAWMCXzIFBGFkZHIFCG5ld0xldmVsCQDMCAIJAQtTdHJpbmdFbnRyeQIFBWJwS2V5CQC5CQIJAMwIAgkAkQMCBQtjdXJyZW50UGFjawUKYnBJZHhMZXZlbAkAzAgCCQCRAwIIBQtjbGFpbVJlc3VsdAJfMwUIYnBJZHhSZXMJAMwIAgUGbmV3TWF0CQDMCAIJAJEDAgULY3VycmVudFBhY2sFCWJwSWR4UHJvZAUDbmlsAgE6CQDMCAIJAQtTdHJpbmdFbnRyeQIIBQtjbGFpbVJlc3VsdAJfNAkAuQkCCQDMCAIFCm5ld1ZvbERhdGEJAMwIAgkAkQMCBQZ3aERhdGEFCHdoSWR4UmVzCQDMCAIJAJEDAgUGd2hEYXRhBQh3aElkeE1hdAkAzAgCCQCRAwIFBndoRGF0YQUJd2hJZHhQcm9kCQDMCAIFCm5ld0xvZnRTdHIFA25pbAIBOgUDbmlsCAULY2xhaW1SZXN1bHQCXzEFCG5ld0xldmVsBQdtYXRVc2VkARd1cGRhdGVEdWNrU3RhdHNJbnRlcm5hbAILZHVja0Fzc2V0SWQHZGVsdGFYUAQGbHZsS2V5CQEMa2V5RHVja0xldmVsAQULZHVja0Fzc2V0SWQEBXhwS2V5CQEJa2V5RHVja1hQAQULZHVja0Fzc2V0SWQEAnhwCQELdmFsdWVPckVsc2UCCQCfCAEFBXhwS2V5AAAEBW5ld1hQCQBkAgUCeHAFB2RlbHRhWFAECWx2bFBvaW50cwkBB2xldmVsVXACCQELdmFsdWVPckVsc2UCCQCfCAEFBmx2bEtleQAABQVuZXdYUAQJa2V5UG9pbnRzCQERa2V5RHVja0ZyZWVQb2ludHMBBQtkdWNrQXNzZXRJZAkAlAoCCQDMCAIJAQxJbnRlZ2VyRW50cnkCBQZsdmxLZXkJAJEDAgUJbHZsUG9pbnRzAAAJAMwIAgkBDEludGVnZXJFbnRyeQIFBXhwS2V5BQVuZXdYUAkAzAgCCQEMSW50ZWdlckVudHJ5AgUJa2V5UG9pbnRzCQBkAgkBC3ZhbHVlT3JFbHNlAgkAnwgBBQlrZXlQb2ludHMAAAkAkQMCBQlsdmxQb2ludHMAAQUDbmlsBQVuZXdYUAEWdXBkYXRlQWNjU3RhdHNJbnRlcm5hbAIEYWRkcgdkZWx0YVhQBAZsdmxLZXkJAQxrZXlVc2VyTGV2ZWwBBQRhZGRyBAV4cEtleQkBCWtleVVzZXJYUAEFBGFkZHIEAnhwCQELdmFsdWVPckVsc2UCCQCfCAEFBXhwS2V5AAAEBW5ld1hQCQBkAgUCeHAFB2RlbHRhWFAECWx2bFBvaW50cwkBB2xldmVsVXACCQELdmFsdWVPckVsc2UCCQCfCAEFBmx2bEtleQAABQVuZXdYUAQJa2V5UG9pbnRzCQERa2V5VXNlckZyZWVQb2ludHMBBQRhZGRyCQCUCgIJAMwIAgkBDEludGVnZXJFbnRyeQIFBmx2bEtleQkAkQMCBQlsdmxQb2ludHMAAAkAzAgCCQEMSW50ZWdlckVudHJ5AgUFeHBLZXkFBW5ld1hQCQDMCAIJAQxJbnRlZ2VyRW50cnkCBQlrZXlQb2ludHMJAGQCCQELdmFsdWVPckVsc2UCCQCfCAEFCWtleVBvaW50cwAACQCRAwIFCWx2bFBvaW50cwABBQNuaWwFBW5ld1hQARJhY3RpdmF0ZU9uYm9hcmRBcnQBBGFkZHIEC2R1Y2tBc3NldElkCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAKIIAQkBFGtleVN0YWtlZER1Y2tCeU93bmVyAQUEYWRkcgIcWW91IGRvbid0IGhhdmUgYSBkdWNrIHN0YWtlZAQIcmVmQnlLZXkJAQ9rZXlBZGRyZXNzUmVmQnkBBQRhZGRyBAVyZWZCeQkAoggBBQhyZWZCeUtleQMJAQEhAQkBCWlzRGVmaW5lZAEFBXJlZkJ5CQACAQIpWW91IGFyZSBub3QgZWxpZ2libGUgZm9yIE9OQk9BUkQgYXJ0aWZhY3QEBmFydEtleQkBHGtleU9uYm9hcmRBcnREdWNrQWN0aXZhdGVkQnkBBQRhZGRyBAdhcnREdWNrCQCiCAEFBmFydEtleQMJAQlpc0RlZmluZWQBBQdhcnREdWNrCQACAQkArAICAi9Zb3UgYWxyZWFkeSB1c2VkIHlvdXIgT05CT0FSRCBhcnRpZmFjdCBvbiBkdWNrIAkBBXZhbHVlAQUHYXJ0RHVjawQQZHVja0FjdGl2YXRvcktleQkBHGtleU9uYm9hcmRBcnRBY3RpdmF0ZWRPbkR1Y2sBBQtkdWNrQXNzZXRJZAQNZHVja0FjdGl2YXRvcgkAoggBBRBkdWNrQWN0aXZhdG9yS2V5AwkBCWlzRGVmaW5lZAEFDWR1Y2tBY3RpdmF0b3IJAAIBCQCsAgIJAKwCAgkArAICAglUaGUgZHVjayAFC2R1Y2tBc3NldElkAjQgYWxyZWFkeSBnb3QgcG9pbnRzIGZyb20gT05CT0FSRCBhcnRpZmFjdCBmcm9tIHVzZXIgCQEFdmFsdWUBBQ1kdWNrQWN0aXZhdG9yCQDOCAIJAMwIAgkBC1N0cmluZ0VudHJ5AgUGYXJ0S2V5BQtkdWNrQXNzZXRJZAkAzAgCCQELU3RyaW5nRW50cnkCBRBkdWNrQWN0aXZhdG9yS2V5BQRhZGRyBQNuaWwICQEXdXBkYXRlRHVja1N0YXRzSW50ZXJuYWwCBQtkdWNrQXNzZXRJZAUJeHBPbmJvYXJkAl8xARJhY3RpdmF0ZVByZXNhbGVBcnQCBGFkZHINbGFuZEFzc2V0SWRJbgQBYwkBFGNoZWNrQ2xhaW1Db25kaXRpb25zAwUEYWRkcgUTY2xhaW1Nb2RlV2hUaGVuRHVjawUNbGFuZEFzc2V0SWRJbgQLbGFuZEFzc2V0SWQIBQFjAl8yBAZwaWVjZXMJAQ9udW1QaWVjZXNCeVNpemUBCQCRAwIIBQFjAl8zBQtyZWNMYW5kU2l6ZQQNYWN0aXZhdGlvbktleQkBIGtleUxhbmRBcnRTdGF0dXNCeVR5cGVBbmRBc3NldElkAgUKQVJUUFJFU0FMRQULbGFuZEFzc2V0SWQDCQBmAgkBC3ZhbHVlT3JFbHNlAgkAnwgBBQ1hY3RpdmF0aW9uS2V5AAAAAAkAAgECJVByZXNhbGUgYXJ0aWZhY3QgaXMgYWxyZWFkeSBhY3RpdmF0ZWQDCQBmAgkBDXBhcnNlSW50VmFsdWUBCQCRAwIIBQFjAl8zBQpyZWNMYW5kTnVtBQ9QUkVTQUxFTlVNTEFORFMJAAIBCQCsAgIJAKwCAgkArAICBQpMQU5EUFJFRklYAgEgBQtsYW5kQXNzZXRJZAIlIGlzIG5vdCBlbGlnaWJsZSBmb3IgcHJlc2FsZSBhcnRpZmFjdAQLY2xhaW1SZXN1bHQJAQhjbGFpbUFsbAQFBGFkZHIFC2xhbmRBc3NldElkBQZwaWVjZXMFE2NsYWltTW9kZVdoVGhlbkR1Y2sJAM0IAgkAzQgCCQDNCAIIBQtjbGFpbVJlc3VsdAJfMQkBDEludGVnZXJFbnRyeQIFDWFjdGl2YXRpb25LZXkFBnBpZWNlcwkBC1N0cmluZ0VudHJ5AggFC2NsYWltUmVzdWx0Al8yCQC5CQIIBQtjbGFpbVJlc3VsdAJfMwIBOgkBC1N0cmluZ0VudHJ5AggFC2NsYWltUmVzdWx0Al80CQC5CQIIBQtjbGFpbVJlc3VsdAJfNQIBOgEPY2hlY2tUb3VybmFtZW50AQtkdWNrQXNzZXRJZAQGbGFzdElkCQELdmFsdWVPckVsc2UCCQCaCAIFEnRvdXJuYW1lbnRDb250cmFjdAUNbGFzdFRvdXJJZEtleQAABAtjdXJMb2NhdGlvbgkAtQkCCQELdmFsdWVPckVsc2UCCQCiCAEJAQ9rZXlEdWNrTG9jYXRpb24BBQtkdWNrQXNzZXRJZAUPREVGQVVMVExPQ0FUSU9OAgFfBANub3cIBQlsYXN0QmxvY2sJdGltZXN0YW1wBAV0RGF0YQkBC2dldFRvdXJEYXRhAgUSdG91cm5hbWVudENvbnRyYWN0BQZsYXN0SWQEBnN0YXRpYwkAkQMCBQV0RGF0YQUJaWR4U3RhdGljBAdkeW5hbWljCQCRAwIFBXREYXRhBQppZHhEeW5hbWljAwkBAiE9AgkAkQMCBQtjdXJMb2NhdGlvbgUKbG9jSWR4VHlwZQIBVAcDAwMJAAACCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgULY3VyTG9jYXRpb24FD2xvY0lkeENvbnRpbmVudAUGbGFzdElkCQAAAgkAkQMCBQdkeW5hbWljBQ50RHluYW1pY1N0YXR1cwIKSU5QUk9HUkVTUwcJAGYCCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUGc3RhdGljBQp0U3RhdGljRW5kBQNub3cHCQACAQIqWW91ciBkdWNrIGlzIHRha2luZyBwYXJ0IGluIHRoZSB0b3VybmFtZW50CQEJYXNCb29sZWFuAQkA/AcEBQR0aGlzAhZleGl0VG91cm5hbWVudEludGVybmFsCQDMCAIFC2R1Y2tBc3NldElkBQNuaWwFA25pbAENY2hlY2tEZWxpdmVyeQELZHVja0Fzc2V0SWQDCQEBIQEFEUtTX0FMTE9XX0RFTElWRVJZBwQLY3VyTG9jYXRpb24JALUJAgkBC3ZhbHVlT3JFbHNlAgkAoggBCQEPa2V5RHVja0xvY2F0aW9uAQULZHVja0Fzc2V0SWQFD0RFRkFVTFRMT0NBVElPTgIBXwQDbm93CAUJbGFzdEJsb2NrCXRpbWVzdGFtcAMJAQIhPQIJAJEDAgULY3VyTG9jYXRpb24FCmxvY0lkeFR5cGUCAUQHBAlzdGFydFRpbWUJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQtjdXJMb2NhdGlvbgUPbG9jSWR4Q29udGluZW50BAhkaXN0YW5jZQkBDXBhcnNlSW50VmFsdWUBCQCRAwIFC2N1ckxvY2F0aW9uBQhsb2NJZHhJZAMDCQBmAgUDbm93CQBkAgUJc3RhcnRUaW1lBRJURU5fTUlOVVRFU19NSUxMSVMJAGYCAAMFCGRpc3RhbmNlBwkAAgECIFlvdXIgZHVjayBpcyBvbiBkZWxpdmVyeSBtaXNzaW9uCQEJYXNCb29sZWFuAQkA/AcEBQR0aGlzAhRleGl0RGVsaXZlcnlJbnRlcm5hbAkAzAgCBQtkdWNrQXNzZXRJZAUDbmlsBQNuaWwBEmV4aXREZWxpdmVyeUNvbW1vbgELZHVja0Fzc2V0SWQEC2N1ckxvY2F0aW9uCQC1CQIJAQt2YWx1ZU9yRWxzZQIJAKIIAQkBD2tleUR1Y2tMb2NhdGlvbgEFC2R1Y2tBc3NldElkBQ9ERUZBVUxUTE9DQVRJT04CAV8EA25vdwgFCWxhc3RCbG9jawl0aW1lc3RhbXAECXN0YXJ0VGltZQkBDXBhcnNlSW50VmFsdWUBCQCRAwIFC2N1ckxvY2F0aW9uBQ9sb2NJZHhDb250aW5lbnQECGRpc3RhbmNlCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgULY3VyTG9jYXRpb24FCGxvY0lkeElkBAVvd25lcgkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCiCAEJARBrZXlEdWNrSWRUb093bmVyAQULZHVja0Fzc2V0SWQCFE5GVCBkdWNrIGlzIG9ycGhhbmVkBAloZWFsdGhLZXkJAQ1rZXlEdWNrSGVhbHRoAQULZHVja0Fzc2V0SWQECWN1ckhlYWx0aAkBEUBleHRyTmF0aXZlKDEwNTUpAQUJaGVhbHRoS2V5BA5vdXRjb21lQWN0aW9ucwMJAGcCBQhkaXN0YW5jZQADBAZyZXdhcmQJAPwHBAUPZWNvbm9teUNvbnRyYWN0AhJzZW5kRGVsaXZlcnlSZXdhcmQJAMwIAgUFb3duZXIFA25pbAUDbmlsAwkAAAIFBnJld2FyZAUGcmV3YXJkBQNuaWwJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4DCQBmAgUDbm93CQBkAgUJc3RhcnRUaW1lBRJURU5fTUlOVVRFU19NSUxMSVMJAAIBAiZZb3VyIGR1Y2sgaXMgc3RpbGwgb24gZGVsaXZlcnkgbWlzc2lvbgQLbG9ja2VkVG90YWwJAQt2YWx1ZU9yRWxzZQIJAJoIAgUPZWNvbm9teUNvbnRyYWN0BRFkZWxpdmVyeUxvY2tlZEtleQAABAZ1bmxvY2sJAPwHBAUPZWNvbm9teUNvbnRyYWN0AhR1cGRhdGVEZWxpdmVyeUxvY2tlZAkAzAgCCQBlAgULbG9ja2VkVG90YWwFFU1JTl9VU0RUX0ZFRV9ERUxJVkVSWQUDbmlsBQNuaWwDCQAAAgUGdW5sb2NrBQZ1bmxvY2sDCQBnAgAABQljdXJIZWFsdGgFA25pbAkAzAgCCQEMSW50ZWdlckVudHJ5AgkBFmtleURlbGl2ZXJ5RGVsYXlCeUR1Y2sBBQtkdWNrQXNzZXRJZAkAZAIFCXN0YXJ0VGltZQUJREFZTUlMTElTBQNuaWwJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4EC3NhdmVkSGVhbHRoCQERQGV4dHJOYXRpdmUoMTA1NSkBCQEOa2V5U2F2ZWRIZWFsdGgBBQtkdWNrQXNzZXRJZAQNc2F2ZWRMb2NhdGlvbgkBEUBleHRyTmF0aXZlKDEwNTgpAQkBEGtleVNhdmVkTG9jYXRpb24BBQtkdWNrQXNzZXRJZAkAlgoEBQ5vdXRjb21lQWN0aW9ucwkAzAgCCQEMSW50ZWdlckVudHJ5AgUJaGVhbHRoS2V5BQtzYXZlZEhlYWx0aAkAzAgCCQELU3RyaW5nRW50cnkCCQEPa2V5RHVja0xvY2F0aW9uAQULZHVja0Fzc2V0SWQFDXNhdmVkTG9jYXRpb24FA25pbAUNc2F2ZWRMb2NhdGlvbgULc2F2ZWRIZWFsdGgBDW1lcmdlSW50ZXJuYWwGC25ld0xhbmRTaXplCG5ld0xldmVsB2Zvcm11bGEEYWRkcgxsYW5kQXNzZXRJZHMHbmVlZE1hdAQLZHVja0Fzc2V0SWQJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAoggBCQEUa2V5U3Rha2VkRHVja0J5T3duZXIBBQRhZGRyAhxZb3UgZG9uJ3QgaGF2ZSBhIGR1Y2sgc3Rha2VkAwkBD2NoZWNrVG91cm5hbWVudAEFC2R1Y2tBc3NldElkCQACAQIdbWVyZ2VJbnRlcm5hbF9jaGVja1RvdXJuYW1lbnQDCQENY2hlY2tEZWxpdmVyeQEFC2R1Y2tBc3NldElkCQACAQIbbWVyZ2VJbnRlcm5hbF9jaGVja0RlbGl2ZXJ5CgEKY2hlY2tNZXJnZQIDYWNjC2xhbmRBc3NldElkBAVhc3NldAkBBXZhbHVlAQkA7AcBCQDZBAEFC2xhbmRBc3NldElkBAd0aW1lS2V5CQEWa2V5U3Rha2VkVGltZUJ5QXNzZXRJZAEFC2xhbmRBc3NldElkBAlzYXZlZFRpbWUJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAnwgBBQd0aW1lS2V5CQCsAgIJAKwCAgIETkZUIAgFBWFzc2V0BG5hbWUCDiBpcyBub3Qgc3Rha2VkBAVvd25lcgkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCiCAEJARVrZXlMYW5kQXNzZXRJZFRvT3duZXIBBQtsYW5kQXNzZXRJZAkArAICCQCsAgICBE5GVCAIBQVhc3NldARuYW1lAgwgaXMgb3JwaGFuZWQDCQECIT0CBQVvd25lcgUEYWRkcgkAAgEJAKwCAgUKTEFORFBSRUZJWAINIGlzIG5vdCB5b3VycwQBZAkAtQkCCAUFYXNzZXQLZGVzY3JpcHRpb24CAV8ECWNvbnRpbmVudAkAkQMCBQFkBQxyZWNDb250aW5lbnQDAwkBAiE9AggFA2FjYwJfMwIACQECIT0CCAUDYWNjAl8zBQljb250aW5lbnQHCQACAQIuTGFuZHMgc2hvdWxkIGJlIG9uIHRoZSBzYW1lIGNvbnRpbmVudCB0byBtZXJnZQQIbGFuZFNpemUJAJEDAgUBZAULcmVjTGFuZFNpemUEB3NpemVzSW4IBQNhY2MCXzEEAWkJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAswkCBQdzaXplc0luBQhsYW5kU2l6ZQInWW91IGhhdmVuJ3QgcGFzc2VkIGFsbCB0aGUgbGFuZHMgbmVlZGVkBAhzaXplc091dAkArAICCQCvAgIFB3NpemVzSW4FAWkJALACAgUHc2l6ZXNJbgkAZAIFAWkAAQQGcGllY2VzCQEPbnVtUGllY2VzQnlTaXplAQUIbGFuZFNpemUEBGFydHMJAGQCCAUDYWNjAl8yCQELdmFsdWVPckVsc2UCCQCfCAEJASBrZXlMYW5kQXJ0U3RhdHVzQnlUeXBlQW5kQXNzZXRJZAIFCkFSVFBSRVNBTEUFC2xhbmRBc3NldElkAAAECmluZnJhTGV2ZWwJAQt2YWx1ZU9yRWxzZQIJAJ8IAQkBFmtleUluZnJhTGV2ZWxCeUFzc2V0SWQBBQtsYW5kQXNzZXRJZAAABAhyZXFMZXZlbAQHJG1hdGNoMAUIbGFuZFNpemUDCQAAAgIBUwUHJG1hdGNoMAADAwkAAAICAU0FByRtYXRjaDAABAMJAAACAgFMBQckbWF0Y2gwAAUDCQAAAgICWEwFByRtYXRjaDAABgkAAgECGk9ubHkgUywgTSwgTCwgWEwgY2FuIG1lcmdlAwkBAiE9AgUKaW5mcmFMZXZlbAUIcmVxTGV2ZWwJAAIBAiJBbGwgbGFuZHMgc2hvdWxkIGJlIG1heGVkIHRvIG1lcmdlBAdsYW5kTnVtCQCRAwIFAWQFCnJlY0xhbmROdW0EDXRlcnJhaW5Db3VudHMJAQ1jb3VudFRlcnJhaW5zAQkAkQMCBQFkBQtyZWNUZXJyYWlucwQJZGVsdGFUaW1lCQBlAggFCWxhc3RCbG9jawl0aW1lc3RhbXAFCXNhdmVkVGltZQMJAGYCAAAFCWRlbHRhVGltZQkAAgEJAKwCAgkArAICCQCsAgICJlNhdmVkIHRpbWVzdGFtcCBpcyBpbiBmdXR1cmUsIHNhdmVkID0gCQCkAwEFCXNhdmVkVGltZQIMLCBjdXJyZW50ID0gCQCkAwEIBQlsYXN0QmxvY2sJdGltZXN0YW1wBBZkYWlseVByb2R1Y3Rpb25CeVBpZWNlCQEMYXBwbHlCb251c2VzAgULbGFuZEFzc2V0SWQFBnBpZWNlcwQJbGFuZEluZGV4CQBpAgUGcGllY2VzBQVTU0laRQQFYnBSZXMJAQZhZGRSZXMFCQC1CQIIBQNhY2MCXzQCAV8FDXRlcnJhaW5Db3VudHMFCWRlbHRhVGltZQUJbGFuZEluZGV4BRZkYWlseVByb2R1Y3Rpb25CeVBpZWNlBAVwcm9wcwkBGXVwZGF0ZVByb3BvcnRpb25zSW50ZXJuYWwECAUDYWNjAl82BQ10ZXJyYWluQ291bnRzBQlsYW5kSW5kZXgA////////////AQQGY1Byb3BzCQEZdXBkYXRlUHJvcG9ydGlvbnNJbnRlcm5hbAQIBQNhY2MDXzEwBQ10ZXJyYWluQ291bnRzBQlsYW5kSW5kZXgA////////////AQQLc3VtVGVycmFpbnMJARl1cGRhdGVQcm9wb3J0aW9uc0ludGVybmFsBAgFA2FjYwJfOQUNdGVycmFpbkNvdW50cwUJbGFuZEluZGV4AAEEBWxhbmRzCAUDYWNjAl83BANpZHgJAM8IAgUFbGFuZHMFC2xhbmRBc3NldElkAwkBASEBCQEJaXNEZWZpbmVkAQUDaWR4CQACAQkArAICAiBZb3VyIHN0YWtlZCBsYW5kcyBkb24ndCBjb250YWluIAULbGFuZEFzc2V0SWQECWN1c3RvbUtleQkBGmtleUxhbmRBc3NldElkVG9DdXN0b21OYW1lAQULbGFuZEFzc2V0SWQECmN1c3RvbU5hbWUJAQt2YWx1ZU9yRWxzZQIJAKIIAQUJY3VzdG9tS2V5AgAJAJwKCgUIc2l6ZXNPdXQFBGFydHMFCWNvbnRpbmVudAUFYnBSZXMJAM4IAgkAzQgCCQDNCAIJAM0IAgkAzQgCCQDNCAIJAM0IAgkAzQgCCQDNCAIJAM0IAgkAzQgCCQDNCAIIBQNhY2MCXzUJAQtEZWxldGVFbnRyeQEJARZrZXlTdGFrZWRUaW1lQnlBc3NldElkAQULbGFuZEFzc2V0SWQJAQtEZWxldGVFbnRyeQEJASJrZXlTdGFrZWRUaW1lQnlUeXBlQXNzZXRJZEFuZE93bmVyAwUKTEFORFBSRUZJWAULbGFuZEFzc2V0SWQFBGFkZHIJAQtEZWxldGVFbnRyeQEJARBrZXlMYW5kVG9Bc3NldElkAQUHbGFuZE51bQkBC0RlbGV0ZUVudHJ5AQkBFWtleUxhbmRBc3NldElkVG9Pd25lcgEFC2xhbmRBc3NldElkCQELRGVsZXRlRW50cnkBCQEWa2V5SW5mcmFMZXZlbEJ5QXNzZXRJZAEFC2xhbmRBc3NldElkCQELRGVsZXRlRW50cnkBCQEea2V5SW5mcmFMZXZlbEJ5QXNzZXRJZEFuZE93bmVyAgULbGFuZEFzc2V0SWQFBGFkZHIJAQtEZWxldGVFbnRyeQEJASBrZXlMYW5kQXJ0U3RhdHVzQnlUeXBlQW5kQXNzZXRJZAIFCkFSVFBSRVNBTEUFC2xhbmRBc3NldElkCQELRGVsZXRlRW50cnkBCQERa2V5TGFuZE51bVRvT3duZXIBBQdsYW5kTnVtCQELRGVsZXRlRW50cnkBCQESa2V5V2FyZWhvdXNlQnlMYW5kAQULbGFuZEFzc2V0SWQJAQtEZWxldGVFbnRyeQEFCWN1c3RvbUtleQkBBEJ1cm4CCQDZBAEFC2xhbmRBc3NldElkAAEDCQECIT0CBQpjdXN0b21OYW1lAgAJAMwIAgkBC0RlbGV0ZUVudHJ5AQkBGmtleUxhbmRDdXN0b21OYW1lVG9Bc3NldElkAQUKY3VzdG9tTmFtZQUDbmlsBQNuaWwFBXByb3BzCQDRCAIFBWxhbmRzCQEFdmFsdWUBBQNpZHgJAGQCCAUDYWNjAl84BQZwaWVjZXMFC3N1bVRlcnJhaW5zBQZjUHJvcHMEBWJwS2V5CQERa2V5QmFja3BhY2tCeUR1Y2sBBQtkdWNrQXNzZXRJZAQLY3VycmVudFBhY2sJAQtnZXRCYWNrcGFjawEFBWJwS2V5BAhwcm9wTGlzdAkAtQkCCQELdmFsdWVPckVsc2UCCQCiCAEJARFrZXlSZXNQcm9wb3J0aW9ucwACCzBfMF8wXzBfMF8wAgFfBAhsYW5kc0tleQkBFWtleVN0YWtlZExhbmRzQnlPd25lcgEFBGFkZHIECGxhbmRzU3RyCQCiCAEFCGxhbmRzS2V5BAdsYW5kc0luAwkBCWlzRGVmaW5lZAEFCGxhbmRzU3RyCQC9CQIJAQV2YWx1ZQEFCGxhbmRzU3RyAgFfBQNuaWwEBWNvbnQwCQCRAwIJALUJAggJAQV2YWx1ZQEJAOwHAQkA2QQBCQCRAwIFDGxhbmRBc3NldElkcwAAC2Rlc2NyaXB0aW9uAgFfBQxyZWNDb250aW5lbnQECWNvbnRQcm9wcwkAtQkCCQELdmFsdWVPckVsc2UCCQCiCAEJARZrZXlSZXNUeXBlc0J5Q29udGluZW50AQUFY29udDACCzBfMF8wXzBfMF8wAgFfBAFyCgACJGwFDGxhbmRBc3NldElkcwoAAiRzCQCQAwEFAiRsCgAFJGFjYzAJAJwKCgUHZm9ybXVsYQAAAgAJAJEDAgULY3VycmVudFBhY2sFCGJwSWR4UmVzBQNuaWwFCHByb3BMaXN0BQdsYW5kc0luAAAJALUJAgILMF8wXzBfMF8wXzACAV8FCWNvbnRQcm9wcwoBBSRmMF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEKY2hlY2tNZXJnZQIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQITTGlzdCBzaXplIGV4Y2VlZHMgNQkBBSRmMF8yAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgUFJGFjYzAAAAABAAIAAwAEAAUECWNvbnRpbmVudAgFAXICXzMEDGNvbnRpbmVudElkeAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQDPCAIFCmNvbnRpbmVudHMFCWNvbnRpbmVudAkArAICAhNVbmtub3duIGNvbnRpbmVudDogBQljb250aW5lbnQECHRlcnJhaW5zCQETZ2VuVGVycmFpbnNGb3JNZXJnZQIIBQFyAl85CQBpAgkBD251bVBpZWNlc0J5U2l6ZQEFC25ld0xhbmRTaXplBQVTU0laRQQHZnJlZU51bQkBC3ZhbHVlT3JFbHNlAgkAnwgBCQESa2V5TmV4dEZyZWVMYW5kTnVtAAkAZAIFD1BSRVNBTEVOVU1MQU5EUwABBApuZXdMYW5kTnVtCQCkAwEFB2ZyZWVOdW0EBWlzc3VlCQDCCAUJAQduZnROYW1lAgUKbmV3TGFuZE51bQULbmV3TGFuZFNpemUJALkJAgkAzAgCBQpuZXdMYW5kTnVtCQDMCAIFC25ld0xhbmRTaXplCQDMCAIFCHRlcnJhaW5zCQDMCAIFCWNvbnRpbmVudAUDbmlsAgFfAAEAAAcEB2Fzc2V0SWQJALgIAQUFaXNzdWUEDm5ld0xhbmRBc3NldElkCQDYBAEFB2Fzc2V0SWQEBm5ld01hdAkAuQkCCQERc3VidHJhY3RNYXRlcmlhbHMDCQBmAgUHbmVlZE1hdAAACQC1CQIJAJEDAgULY3VycmVudFBhY2sFCGJwSWR4TWF0AgFfBQduZWVkTWF0AgFfBAlwaWVjZXNLZXkJARZrZXlTdGFrZWRQaWVjZXNCeU93bmVyAQUEYWRkcgQMc3Rha2VkUGllY2VzCQELdmFsdWVPckVsc2UCCQCfCAEFCXBpZWNlc0tleQAACQCUCgIJAM0IAgkAzQgCCQDNCAIJAM0IAgkAzQgCCQDNCAIJAM0IAgkAzQgCCQDNCAIJAM0IAgkAzQgCCQDNCAIJAM0IAgkAzQgCCQDNCAIIBQFyAl81AwkAZgIJAJADAQgFAXICXzcAAAkBC1N0cmluZ0VudHJ5AgUIbGFuZHNLZXkJALsJAggFAXICXzcCAV8JAQtEZWxldGVFbnRyeQEFCGxhbmRzS2V5CQEMSW50ZWdlckVudHJ5AgUJcGllY2VzS2V5AwkAZgIIBQFyAl84BQxzdGFrZWRQaWVjZXMAAAkAZQIFDHN0YWtlZFBpZWNlcwgFAXICXzgJAQxJbnRlZ2VyRW50cnkCCQESa2V5TmV4dEZyZWVMYW5kTnVtAAkAZAIFB2ZyZWVOdW0AAQUFaXNzdWUJAQtTdHJpbmdFbnRyeQIJARBrZXlMYW5kVG9Bc3NldElkAQUKbmV3TGFuZE51bQUObmV3TGFuZEFzc2V0SWQJAQtTdHJpbmdFbnRyeQIJARVrZXlMYW5kQXNzZXRJZFRvT3duZXIBBQ5uZXdMYW5kQXNzZXRJZAUEYWRkcgkBC1N0cmluZ0VudHJ5AgkBEWtleUxhbmROdW1Ub093bmVyAQUKbmV3TGFuZE51bQUEYWRkcgkBDEludGVnZXJFbnRyeQIJASBrZXlMYW5kQXJ0U3RhdHVzQnlUeXBlQW5kQXNzZXRJZAIFCkFSVFBSRVNBTEUFDm5ld0xhbmRBc3NldElkCAUBcgJfMgkBDEludGVnZXJFbnRyeQIJARZrZXlJbmZyYUxldmVsQnlBc3NldElkAQUObmV3TGFuZEFzc2V0SWQFCG5ld0xldmVsCQEMSW50ZWdlckVudHJ5AgkBHmtleUluZnJhTGV2ZWxCeUFzc2V0SWRBbmRPd25lcgIFDm5ld0xhbmRBc3NldElkBQRhZGRyBQhuZXdMZXZlbAkBC1N0cmluZ0VudHJ5AgUFYnBLZXkJALkJAgkAzAgCCQCRAwIFC2N1cnJlbnRQYWNrBQpicElkeExldmVsCQDMCAIIBQFyAl80CQDMCAIFBm5ld01hdAkAzAgCCQCRAwIFC2N1cnJlbnRQYWNrBQlicElkeFByb2QFA25pbAIBOgkBC1N0cmluZ0VudHJ5AgkBEWtleVJlc1Byb3BvcnRpb25zAAkAuQkCCAUBcgJfNgIBXwkBC1N0cmluZ0VudHJ5AgkBFmtleVJlc1R5cGVzQnlDb250aW5lbnQBBQljb250aW5lbnQJALkJAggFAXIDXzEwAgFfCQELU3RyaW5nRW50cnkCCQEPa2V5RHVja0xvY2F0aW9uAQULZHVja0Fzc2V0SWQJALkJAgkAzAgCBQljb250aW5lbnQJAMwIAgIBTAkAzAgCBQ5uZXdMYW5kQXNzZXRJZAUDbmlsAgFfCQEOU2NyaXB0VHJhbnNmZXIDCQERQGV4dHJOYXRpdmUoMTA2MikBBQRhZGRyAAEFB2Fzc2V0SWQFDm5ld0xhbmRBc3NldElkAQNzMm0CBGFkZHIMbGFuZEFzc2V0SWRzCQENbWVyZ2VJbnRlcm5hbAYCAU0AAwIEU1NTUwUEYWRkcgUMbGFuZEFzc2V0SWRzAAABA20ybAIEYWRkcgxsYW5kQXNzZXRJZHMJAQ1tZXJnZUludGVybmFsBgIBTAAEAgNTTU0FBGFkZHIFDGxhbmRBc3NldElkcwkAaAIFEUluZnJhVXBncmFkZUNvc3RTAAQBBGwyeGwCBGFkZHIMbGFuZEFzc2V0SWRzCQENbWVyZ2VJbnRlcm5hbAYCAlhMAAUCBVNTU01MBQRhZGRyBQxsYW5kQXNzZXRJZHMJAGgCBRFJbmZyYVVwZ3JhZGVDb3N0UwAvAQZ4bDJ4eGwCBGFkZHIMbGFuZEFzc2V0SWRzCQENbWVyZ2VJbnRlcm5hbAYCA1hYTAAGAgNMWEwFBGFkZHIFDGxhbmRBc3NldElkcwkAaAIFEUluZnJhVXBncmFkZUNvc3RTADYBC21lcmdlQ29tbW9uAgRhZGRyDGxhbmRBc3NldElkcwQHJG1hdGNoMAkAkAMBBQxsYW5kQXNzZXRJZHMDCQAAAgAEBQckbWF0Y2gwCQEDczJtAgUEYWRkcgUMbGFuZEFzc2V0SWRzAwkAAAIAAwUHJG1hdGNoMAkBA20ybAIFBGFkZHIFDGxhbmRBc3NldElkcwMJAAACAAUFByRtYXRjaDAJAQRsMnhsAgUEYWRkcgUMbGFuZEFzc2V0SWRzAwkAAAIAAgUHJG1hdGNoMAkBBnhsMnh4bAIFBGFkZHIFDGxhbmRBc3NldElkcwkAAgECDVVua25vd24gbWVyZ2UBFWNoZWNrT3V0ZGF0ZWREZWxpdmVyeQEIdXNlckFkZHIEBGR1Y2sJAKIIAQkBFGtleVN0YWtlZER1Y2tCeU93bmVyAQUIdXNlckFkZHIDAwURS1NfQUxMT1dfREVMSVZFUlkJAQlpc0RlZmluZWQBBQRkdWNrBwQLZHVja0Fzc2V0SWQJAQV2YWx1ZQEFBGR1Y2sEBmxvY0tleQkBD2tleUR1Y2tMb2NhdGlvbgEFC2R1Y2tBc3NldElkBANsb2MJALUJAgkBC3ZhbHVlT3JFbHNlAgkAoggBBQZsb2NLZXkFD0RFRkFVTFRMT0NBVElPTgIBXwQJc3RhcnRUaW1lCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUDbG9jBQ9sb2NJZHhDb250aW5lbnQDAwkBAiE9AgkAkQMCBQNsb2MFCmxvY0lkeFR5cGUCAUQGCQBmAggFCWxhc3RCbG9jawl0aW1lc3RhbXAJAGQCBQlzdGFydFRpbWUFElRFTl9NSU5VVEVTX01JTExJUwUDbmlsBAloZWFsdGhLZXkJAQ1rZXlEdWNrSGVhbHRoAQULZHVja0Fzc2V0SWQDCQBnAgkBDXBhcnNlSW50VmFsdWUBCQCRAwIFA2xvYwUIbG9jSWR4SWQAAwQGcmV3YXJkCQD8BwQFD2Vjb25vbXlDb250cmFjdAISc2VuZERlbGl2ZXJ5UmV3YXJkCQDMCAIFCHVzZXJBZGRyBQNuaWwFA25pbAMJAAACBQZyZXdhcmQFBnJld2FyZAUDbmlsCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQDNCAIJAM0IAgQLbG9ja2VkVG90YWwJAQt2YWx1ZU9yRWxzZQIJAJoIAgUPZWNvbm9teUNvbnRyYWN0BRFkZWxpdmVyeUxvY2tlZEtleQAABAZ1bmxvY2sJAPwHBAUPZWNvbm9teUNvbnRyYWN0AhR1cGRhdGVEZWxpdmVyeUxvY2tlZAkAzAgCCQBlAgULbG9ja2VkVG90YWwFFU1JTl9VU0RUX0ZFRV9ERUxJVkVSWQUDbmlsBQNuaWwDCQAAAgUGdW5sb2NrBQZ1bmxvY2sDCQBnAgAACQERQGV4dHJOYXRpdmUoMTA1NSkBBQloZWFsdGhLZXkFA25pbAQKcHVuaXNobWVudAkA/AcEBQR0aGlzAgtzYXZlSW50ZWdlcgkAzAgCCQEWa2V5RGVsaXZlcnlEZWxheUJ5RHVjawEFC2R1Y2tBc3NldElkCQDMCAIJAGQCBQlzdGFydFRpbWUFCURBWU1JTExJUwUDbmlsBQNuaWwDCQAAAgUKcHVuaXNobWVudAUKcHVuaXNobWVudAUDbmlsCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQEMSW50ZWdlckVudHJ5AgUJaGVhbHRoS2V5CQERQGV4dHJOYXRpdmUoMTA1NSkBCQEOa2V5U2F2ZWRIZWFsdGgBBQtkdWNrQXNzZXRJZAkBC1N0cmluZ0VudHJ5AgUGbG9jS2V5CQERQGV4dHJOYXRpdmUoMTA1OCkBCQEQa2V5U2F2ZWRMb2NhdGlvbgEFC2R1Y2tBc3NldElkBQNuaWwBBnByb2xvZwEBaQMDCQECIT0CCAUBaQxvcmlnaW5DYWxsZXIFDHJlc3RDb250cmFjdAkBC3ZhbHVlT3JFbHNlAgkAoAgBCQEKa2V5QmxvY2tlZAAHBwkAAgECH0NvbnRyYWN0cyBhcmUgdW5kZXIgbWFpbnRlbmFuY2UECHVzZXJBZGRyCQClCAEIBQFpDG9yaWdpbkNhbGxlcgkAzQgCCQEVY2hlY2tPdXRkYXRlZERlbGl2ZXJ5AQUIdXNlckFkZHIJAQtTdHJpbmdFbnRyeQIJARFrZXlMYXN0VHhJZEJ5VXNlcgEFCHVzZXJBZGRyCQDYBAEIBQFpDXRyYW5zYWN0aW9uSWQBDHByb2xvZ0ZsaWdodAEBaQMDCQECIT0CCAUBaQxvcmlnaW5DYWxsZXIFDHJlc3RDb250cmFjdAkBC3ZhbHVlT3JFbHNlAgkAoAgBCQEKa2V5QmxvY2tlZAAHBwkAAgECH0NvbnRyYWN0cyBhcmUgdW5kZXIgbWFpbnRlbmFuY2UJAMwIAgkBC1N0cmluZ0VudHJ5AgkBEWtleUxhc3RUeElkQnlVc2VyAQkApQgBCAUBaQxvcmlnaW5DYWxsZXIJANgEAQgFAWkNdHJhbnNhY3Rpb25JZAUDbmlsLQFpAQ1jb25zdHJ1Y3RvclYxAQhyZXN0QWRkcgMJAQIhPQIIBQFpBmNhbGxlcgUEdGhpcwkAAgECEVBlcm1pc3Npb24gZGVuaWVkCQDMCAIJAQtTdHJpbmdFbnRyeQIJAQ5rZXlSZXN0QWRkcmVzcwAFCHJlc3RBZGRyBQNuaWwBaQELc2F2ZUludGVnZXICA2tleQZhbW91bnQDCQECIT0CCAUBaQZjYWxsZXIFBHRoaXMJAAIBAiBzYXZlSW50ZWdlciBpcyBub3QgcHVibGljIG1ldGhvZAkAzAgCCQEMSW50ZWdlckVudHJ5AgUDa2V5BQZhbW91bnQFA25pbAFpAQpzZXRCbG9ja2VkAQlpc0Jsb2NrZWQDCQECIT0CCAUBaQZjYWxsZXIFBHRoaXMJAAIBAhFwZXJtaXNzaW9uIGRlbmllZAkAzAgCCQEMQm9vbGVhbkVudHJ5AgkBCmtleUJsb2NrZWQABQlpc0Jsb2NrZWQFA25pbAFpAQlzdGFrZUxhbmQABA1wcm9sb2dBY3Rpb25zCQEGcHJvbG9nAQUBaQMJAQIhPQIJAJADAQgFAWkIcGF5bWVudHMAAQkAAgECHEV4YWN0bHkgb25lIHBheW1lbnQgcmVxdWlyZWQEA3BtdAkBBXZhbHVlAQkAkQMCCAUBaQhwYXltZW50cwAABAdhc3NldElkCQEFdmFsdWUBCAUDcG10B2Fzc2V0SWQEB2FkZHJlc3MJAKUIAQgFAWkGY2FsbGVyAwkBAiE9AggFA3BtdAZhbW91bnQAAQkAAgEJAKwCAgkArAICAgRORlQgBQpMQU5EUFJFRklYAiQgdG9rZW4gc2hvdWxkIGJlIGF0dGFjaGVkIGFzIHBheW1lbnQEBWFzc2V0CQEFdmFsdWUBCQDsBwEFB2Fzc2V0SWQDCQECIT0CCAUFYXNzZXQGaXNzdWVyBQR0aGlzCQACAQIXVW5rbm93biBpc3N1ZXIgb2YgdG9rZW4DCQEBIQEJAQhjb250YWlucwIIBQVhc3NldARuYW1lBQpMQU5EUFJFRklYCQACAQkArAICCQCsAgICCU9ubHkgTkZUIAUKTEFORFBSRUZJWAIUIHRva2VucyBhcmUgYWNjZXB0ZWQEC2xhbmROdW1TaXplCQCwAgIIBQVhc3NldARuYW1lAAQEB2xhbmROdW0DCQEIY29udGFpbnMCBQtsYW5kTnVtU2l6ZQIDWFhMCQCzAgIFC2xhbmROdW1TaXplAAMDCQEIY29udGFpbnMCBQtsYW5kTnVtU2l6ZQICWEwJALMCAgULbGFuZE51bVNpemUAAgkAswICBQtsYW5kTnVtU2l6ZQABAwkBASEBCQEJaXNEZWZpbmVkAQkAtgkBBQdsYW5kTnVtCQACAQkArAICAh5DYW5ub3QgcGFyc2UgbGFuZCBudW1iZXIgZnJvbSAIBQVhc3NldARuYW1lBAtsYW5kQXNzZXRJZAkA2AQBBQdhc3NldElkBAd0aW1lS2V5CQEWa2V5U3Rha2VkVGltZUJ5QXNzZXRJZAEFC2xhbmRBc3NldElkAwkBCWlzRGVmaW5lZAEJAJ8IAQUHdGltZUtleQkAAgEJAKwCAgkArAICAgRORlQgCAUFYXNzZXQEbmFtZQISIGlzIGFscmVhZHkgc3Rha2VkBAFkCQC1CQIIBQVhc3NldAtkZXNjcmlwdGlvbgIBXwQNdGVycmFpbkNvdW50cwkBDWNvdW50VGVycmFpbnMBCQCRAwIFAWQFC3JlY1RlcnJhaW5zBAZwaWVjZXMJAQ9udW1QaWVjZXNCeVNpemUBCQCRAwIFAWQFC3JlY0xhbmRTaXplBAlsYW5kSW5kZXgJAGkCBQZwaWVjZXMFBVNTSVpFBAVwcm9wcwkBEXVwZGF0ZVByb3BvcnRpb25zAwUNdGVycmFpbkNvdW50cwUJbGFuZEluZGV4AAEEDHJlc0J5Q29udEtleQkBFmtleVJlc1R5cGVzQnlDb250aW5lbnQBCQCRAwIFAWQFDHJlY0NvbnRpbmVudAQJY29udFByb3BzCQC1CQIJAQt2YWx1ZU9yRWxzZQIJAKIIAQUMcmVzQnlDb250S2V5AgswXzBfMF8wXzBfMAIBXwQQdXBkYXRlZENvbnRQcm9wcwkAuQkCCQEZdXBkYXRlUHJvcG9ydGlvbnNJbnRlcm5hbAQFCWNvbnRQcm9wcwUNdGVycmFpbkNvdW50cwUJbGFuZEluZGV4AAECAV8ECGxhbmRzS2V5CQEVa2V5U3Rha2VkTGFuZHNCeU93bmVyAQUHYWRkcmVzcwQIbGFuZHNTdHIJAKIIAQUIbGFuZHNLZXkEBWxhbmRzAwkBCWlzRGVmaW5lZAEFCGxhbmRzU3RyCQC9CQIJAQV2YWx1ZQEFCGxhbmRzU3RyAgFfBQNuaWwDCQEPY29udGFpbnNFbGVtZW50AgUFbGFuZHMFC2xhbmRBc3NldElkCQACAQkArAICAiJZb3VyIHN0YWtlZCBsYW5kcyBhbHJlYWR5IGNvbnRhaW4gBQtsYW5kQXNzZXRJZAMJAGcCCQCQAwEFBWxhbmRzBRhNQVhfTEFORFNfU1RBS0VEX0JZX1VTRVIJAAIBCQCsAgIJAKwCAgIZWW91ciBhbHJlYWR5IHN0YWtlZCBtYXggKAkApAMBBRhNQVhfTEFORFNfU1RBS0VEX0JZX1VTRVICBykgbGFuZHMECmluZnJhTGV2ZWwJAQt2YWx1ZU9yRWxzZQIJAJ8IAQkBFmtleUluZnJhTGV2ZWxCeUFzc2V0SWQBBQtsYW5kQXNzZXRJZAAABAlwaWVjZXNLZXkJARZrZXlTdGFrZWRQaWVjZXNCeU93bmVyAQUHYWRkcmVzcwQJb2xkUGllY2VzCQELdmFsdWVPckVsc2UCCQCfCAEFCXBpZWNlc0tleQAABAl3bGdSZXN1bHQJAPwHBAULd2xnQ29udHJhY3QCEm9uU3Rha2VVbnN0YWtlTGFuZAkAzAgCBQdhZGRyZXNzBQNuaWwFA25pbAkAlAoCCQDOCAIJAMwIAgkBDEludGVnZXJFbnRyeQIFB3RpbWVLZXkIBQlsYXN0QmxvY2sJdGltZXN0YW1wCQDMCAIJAQxJbnRlZ2VyRW50cnkCCQEia2V5U3Rha2VkVGltZUJ5VHlwZUFzc2V0SWRBbmRPd25lcgMFCkxBTkRQUkVGSVgFC2xhbmRBc3NldElkBQdhZGRyZXNzCAUJbGFzdEJsb2NrCXRpbWVzdGFtcAkAzAgCCQELU3RyaW5nRW50cnkCBQhsYW5kc0tleQkAuwkCCQDNCAIFBWxhbmRzBQtsYW5kQXNzZXRJZAIBXwkAzAgCCQEMSW50ZWdlckVudHJ5AgUJcGllY2VzS2V5CQBkAgUJb2xkUGllY2VzBQZwaWVjZXMJAMwIAgkBC1N0cmluZ0VudHJ5AgkBFWtleUxhbmRBc3NldElkVG9Pd25lcgEFC2xhbmRBc3NldElkBQdhZGRyZXNzCQDMCAIJAQtTdHJpbmdFbnRyeQIJARFrZXlMYW5kTnVtVG9Pd25lcgEFB2xhbmROdW0FB2FkZHJlc3MJAMwIAgkBDEludGVnZXJFbnRyeQIJAR5rZXlJbmZyYUxldmVsQnlBc3NldElkQW5kT3duZXICBQtsYW5kQXNzZXRJZAUHYWRkcmVzcwUKaW5mcmFMZXZlbAkAzAgCCQELU3RyaW5nRW50cnkCCQERa2V5UmVzUHJvcG9ydGlvbnMABQVwcm9wcwkAzAgCCQELU3RyaW5nRW50cnkCBQxyZXNCeUNvbnRLZXkFEHVwZGF0ZWRDb250UHJvcHMFA25pbAUNcHJvbG9nQWN0aW9ucwUJd2xnUmVzdWx0AWkBC3Vuc3Rha2VMYW5kAQ1sYW5kQXNzZXRJZEluBA1wcm9sb2dBY3Rpb25zCQEGcHJvbG9nAQUBaQMJAQIhPQIJAJADAQgFAWkIcGF5bWVudHMAAAkAAgECFE5vIHBheW1lbnRzIHJlcXVpcmVkBARhZGRyCQClCAEIBQFpBmNhbGxlcgQBYwkBFGNoZWNrQ2xhaW1Db25kaXRpb25zAwUEYWRkcgUNY2xhaW1Nb2RlRHVjawUNbGFuZEFzc2V0SWRJbgQLbGFuZEFzc2V0SWQIBQFjAl8yBAFkCAUBYwJfMwQIbGFuZHNLZXkJARVrZXlTdGFrZWRMYW5kc0J5T3duZXIBBQRhZGRyBA10ZXJyYWluQ291bnRzCQENY291bnRUZXJyYWlucwEJAJEDAgUBZAULcmVjVGVycmFpbnMEBnBpZWNlcwkBD251bVBpZWNlc0J5U2l6ZQEJAJEDAgUBZAULcmVjTGFuZFNpemUECWxhbmRJbmRleAkAaQIFBnBpZWNlcwUFU1NJWkUEBXByb3BzCQERdXBkYXRlUHJvcG9ydGlvbnMDBQ10ZXJyYWluQ291bnRzBQlsYW5kSW5kZXgA////////////AQQMcmVzQnlDb250S2V5CQEWa2V5UmVzVHlwZXNCeUNvbnRpbmVudAEJAJEDAgUBZAUMcmVjQ29udGluZW50BAljb250UHJvcHMJALUJAgkBC3ZhbHVlT3JFbHNlAgkAoggBBQxyZXNCeUNvbnRLZXkCCzBfMF8wXzBfMF8wAgFfBBB1cGRhdGVkQ29udFByb3BzCQC5CQIJARl1cGRhdGVQcm9wb3J0aW9uc0ludGVybmFsBAUJY29udFByb3BzBQ10ZXJyYWluQ291bnRzBQlsYW5kSW5kZXgA////////////AQIBXwQLY2xhaW1SZXN1bHQJAQhjbGFpbUFsbAQFBGFkZHIFC2xhbmRBc3NldElkBQZwaWVjZXMFDWNsYWltTW9kZUR1Y2sEBWxhbmRzCQC9CQIJAQt2YWx1ZU9yRWxzZQIJAKIIAQUIbGFuZHNLZXkCAAIBXwQDaWR4CQDPCAIFBWxhbmRzBQtsYW5kQXNzZXRJZAMJAQEhAQkBCWlzRGVmaW5lZAEFA2lkeAkAAgEJAKwCAgIgWW91ciBzdGFrZWQgbGFuZHMgZG9uJ3QgY29udGFpbiAFC2xhbmRBc3NldElkBANub3cIBQlsYXN0QmxvY2sJdGltZXN0YW1wBA5nb3ZSZWxlYXNlVGltZQkBC3ZhbHVlT3JFbHNlAgkAmggCBQtnb3ZDb250cmFjdAkBFWtleVVzZXJHd2xSZWxlYXNlVGltZQEFBGFkZHIAAAMJAGcCBQ5nb3ZSZWxlYXNlVGltZQUDbm93CQACAQkArAICAjlZb3VyIGdXTCBhcmUgdGFraW5nIHBhcnQgaW4gdm90aW5nLCBjYW5ub3QgdW5zdGFrZSB1bnRpbCAJAKQDAQUOZ292UmVsZWFzZVRpbWUEDmFyYlJlbGVhc2VUaW1lCQBkAgkBC3ZhbHVlT3JFbHNlAgkAmggCBQt3bGdDb250cmFjdAkBFGtleUxhc3RBcmJUaW1lQnlVc2VyAQUEYWRkcgAABQ5hcmJpdHJhZ2VEZWxheQMJAGYCBQ5hcmJSZWxlYXNlVGltZQUDbm93CQACAQkArAICAj9Zb3VyIHN0YWtlZCBsYW5kcyB0b29rIHBhcnQgaW4gYXJiaXRyYWdlLCBjYW5ub3QgdW5zdGFrZSB1bnRpbCAJAKQDAQUOYXJiUmVsZWFzZVRpbWUECXBpZWNlc0tleQkBFmtleVN0YWtlZFBpZWNlc0J5T3duZXIBBQRhZGRyBAxzdGFrZWRQaWVjZXMJAQt2YWx1ZU9yRWxzZQIJAJ8IAQUJcGllY2VzS2V5AAAECW5ld1BpZWNlcwMJAGYCBQZwaWVjZXMFDHN0YWtlZFBpZWNlcwAACQBlAgUMc3Rha2VkUGllY2VzBQZwaWVjZXMECXdsZ1Jlc3VsdAkA/AcEBQt3bGdDb250cmFjdAISb25TdGFrZVVuc3Rha2VMYW5kCQDMCAIFBGFkZHIFA25pbAUDbmlsCQCUCgIJAM4IAgkAzAgCCQEOU2NyaXB0VHJhbnNmZXIDCAUBaQZjYWxsZXIAAQkA2QQBBQtsYW5kQXNzZXRJZAkAzAgCCQELRGVsZXRlRW50cnkBCQEWa2V5U3Rha2VkVGltZUJ5QXNzZXRJZAEFC2xhbmRBc3NldElkCQDMCAIJAQtEZWxldGVFbnRyeQEJASJrZXlTdGFrZWRUaW1lQnlUeXBlQXNzZXRJZEFuZE93bmVyAwUKTEFORFBSRUZJWAULbGFuZEFzc2V0SWQFBGFkZHIJAMwIAgkBC1N0cmluZ0VudHJ5AgkBEWtleVJlc1Byb3BvcnRpb25zAAUFcHJvcHMJAMwIAgkBC1N0cmluZ0VudHJ5AgUMcmVzQnlDb250S2V5BRB1cGRhdGVkQ29udFByb3BzCQDMCAIJAQtTdHJpbmdFbnRyeQIIBQtjbGFpbVJlc3VsdAJfMgkAuQkCCAULY2xhaW1SZXN1bHQCXzMCAToJAMwIAgMJAGYCCQCQAwEFBWxhbmRzAAEJAQtTdHJpbmdFbnRyeQIFCGxhbmRzS2V5CQC7CQIJANEIAgUFbGFuZHMJAQV2YWx1ZQEFA2lkeAIBXwkBC0RlbGV0ZUVudHJ5AQUIbGFuZHNLZXkJAMwIAgkBDEludGVnZXJFbnRyeQIFCXBpZWNlc0tleQUJbmV3UGllY2VzBQNuaWwFDXByb2xvZ0FjdGlvbnMFCXdsZ1Jlc3VsdAFpAQlzdGFrZUR1Y2sABA1wcm9sb2dBY3Rpb25zCQEGcHJvbG9nAQUBaQMJAQIhPQIJAJADAQgFAWkIcGF5bWVudHMAAQkAAgECHEV4YWN0bHkgb25lIHBheW1lbnQgcmVxdWlyZWQEA3BtdAkBBXZhbHVlAQkAkQMCCAUBaQhwYXltZW50cwAABAdhc3NldElkCQEFdmFsdWUBCAUDcG10B2Fzc2V0SWQEB2FkZHJlc3MJAKUIAQgFAWkGY2FsbGVyAwkBAiE9AggFA3BtdAZhbW91bnQAAQkAAgEJAKwCAgkArAICAgRORlQgBQpEVUNLUFJFRklYAiQgdG9rZW4gc2hvdWxkIGJlIGF0dGFjaGVkIGFzIHBheW1lbnQEBWFzc2V0CQEFdmFsdWUBCQDsBwEFB2Fzc2V0SWQDAwkBAiE9AggFBWFzc2V0Bmlzc3VlcgUNaW5jdWJhdG9yQWRkcgkBAiE9AggFBWFzc2V0Bmlzc3VlcgULYnJlZWRlckFkZHIHCQACAQkArAICCQCsAgICElVua25vd24gaXNzdWVyIG9mIAUKRFVDS1BSRUZJWAIGIHRva2VuAwkBASEBCQEIY29udGFpbnMCCAUFYXNzZXQEbmFtZQUKRFVDS1BSRUZJWAkAAgEJAKwCAgkArAICAglPbmx5IE5GVCAFCkRVQ0tQUkVGSVgCFCB0b2tlbnMgYXJlIGFjY2VwdGVkBAphc3NldElkU3RyCQDYBAEFB2Fzc2V0SWQEB3RpbWVLZXkJARZrZXlTdGFrZWRUaW1lQnlBc3NldElkAQUKYXNzZXRJZFN0cgMJAQlpc0RlZmluZWQBCQCfCAEFB3RpbWVLZXkJAAIBCQCsAgIJAKwCAgIETkZUIAgFBWFzc2V0BG5hbWUCEiBpcyBhbHJlYWR5IHN0YWtlZAMJAQlpc0RlZmluZWQBCQCiCAEJARRrZXlTdGFrZWREdWNrQnlPd25lcgEFB2FkZHJlc3MJAAIBCQCsAgICHVlvdSBhbHJlYWR5IHN0YWtlZCBvbmUgZHVjazogCAUFYXNzZXQEbmFtZQQGbG9jS2V5CQEPa2V5RHVja0xvY2F0aW9uAQUKYXNzZXRJZFN0cgQIbG9jYXRpb24JAKIIAQUGbG9jS2V5BAVicEtleQkBEWtleUJhY2twYWNrQnlEdWNrAQUKYXNzZXRJZFN0cgQIYmFja3BhY2sJAKIIAQUFYnBLZXkECWtleUhlYWx0aAkBDWtleUR1Y2tIZWFsdGgBBQphc3NldElkU3RyBAVtYXhIUAkBCW1heEhlYWx0aAEJAQt2YWx1ZU9yRWxzZQIJAJ8IAQkBDGtleUR1Y2tMZXZlbAEFCmFzc2V0SWRTdHIAAAQJY3VySGVhbHRoCQELdmFsdWVPckVsc2UCCQCfCAEFCWtleUhlYWx0aAUFbWF4SFAJAM4IAgkAzAgCCQEMSW50ZWdlckVudHJ5AgUHdGltZUtleQgFCWxhc3RCbG9jawl0aW1lc3RhbXAJAMwIAgkBDEludGVnZXJFbnRyeQIJASJrZXlTdGFrZWRUaW1lQnlUeXBlQXNzZXRJZEFuZE93bmVyAwUKRFVDS1BSRUZJWAkA2AQBBQdhc3NldElkBQdhZGRyZXNzCAUJbGFzdEJsb2NrCXRpbWVzdGFtcAkAzAgCCQELU3RyaW5nRW50cnkCCQEQa2V5RHVja0lkVG9Pd25lcgEFCmFzc2V0SWRTdHIFB2FkZHJlc3MJAMwIAgkBC1N0cmluZ0VudHJ5AgkBFGtleVN0YWtlZER1Y2tCeU93bmVyAQUHYWRkcmVzcwUKYXNzZXRJZFN0cgUDbmlsAwkBCWlzRGVmaW5lZAEFCGxvY2F0aW9uBQNuaWwJAM4IAgkAzAgCCQELU3RyaW5nRW50cnkCBQZsb2NLZXkFD0RFRkFVTFRMT0NBVElPTgUDbmlsAwkBCWlzRGVmaW5lZAEFCGJhY2twYWNrBQNuaWwJAM4IAgkAzQgCCQDMCAIJAQtTdHJpbmdFbnRyeQIFBWJwS2V5AhowOjBfMF8wXzBfMF8wOjBfMF8wXzBfMF8wOgUDbmlsCQEMSW50ZWdlckVudHJ5AgUJa2V5SGVhbHRoBQljdXJIZWFsdGgFDXByb2xvZ0FjdGlvbnMBaQELdW5zdGFrZUR1Y2sBCmFzc2V0SWRTdHIEDXByb2xvZ0FjdGlvbnMJAQZwcm9sb2cBBQFpAwkBAiE9AgkAkAMBCAUBaQhwYXltZW50cwAACQACAQIUTm8gcGF5bWVudHMgcmVxdWlyZWQEB2Fzc2V0SWQJANkEAQUKYXNzZXRJZFN0cgQHYWRkcmVzcwkApQgBCAUBaQZjYWxsZXIEBWFzc2V0CQEFdmFsdWUBCQDsBwEFB2Fzc2V0SWQEB3RpbWVLZXkJARZrZXlTdGFrZWRUaW1lQnlBc3NldElkAQUKYXNzZXRJZFN0cgMJAQEhAQkBCWlzRGVmaW5lZAEJAJ8IAQUHdGltZUtleQkAAgEJAKwCAgkArAICAgRORlQgCAUFYXNzZXQEbmFtZQIOIGlzIG5vdCBzdGFrZWQDCQEBIQEJAQlpc0RlZmluZWQBCQCiCAEJARRrZXlTdGFrZWREdWNrQnlPd25lcgEFB2FkZHJlc3MJAAIBCQCsAgIJAKwCAgIJVGhlIGR1Y2sgCAUFYXNzZXQEbmFtZQIOIGlzIG5vdCBzdGFrZWQEBW93bmVyCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAKIIAQkBEGtleUR1Y2tJZFRvT3duZXIBBQphc3NldElkU3RyCQCsAgIJAKwCAgIETkZUIAgFBWFzc2V0BG5hbWUCDCBpcyBvcnBoYW5lZAMJAQIhPQIFBW93bmVyBQdhZGRyZXNzCQACAQIXU3Rha2VkIE5GVCBpcyBub3QgeW91cnMDCQEPY2hlY2tUb3VybmFtZW50AQUKYXNzZXRJZFN0cgkAAgECG3Vuc3Rha2VEdWNrX2NoZWNrVG91cm5hbWVudAMJAQ1jaGVja0RlbGl2ZXJ5AQUKYXNzZXRJZFN0cgkAAgECGXVuc3Rha2VEdWNrX2NoZWNrRGVsaXZlcnkECWtleUhlYWx0aAkBDWtleUR1Y2tIZWFsdGgBBQphc3NldElkU3RyBAVtYXhIUAkBCW1heEhlYWx0aAEJAQt2YWx1ZU9yRWxzZQIJAJ8IAQkBDGtleUR1Y2tMZXZlbAEFCmFzc2V0SWRTdHIAAAQGaGVhbHRoCQELdmFsdWVPckVsc2UCCQCfCAEFCWtleUhlYWx0aAUFbWF4SFADCQBmAgUFbWF4SFAFBmhlYWx0aAkAAgEJAKwCAgkArAICAhlQbGVhc2UgaGVhbCB5b3VyIGR1Y2sgdG8gCQCkAwEFBW1heEhQAhNocCBiZWZvcmUgdW5zdGFraW5nCQDOCAIJAMwIAgkBDlNjcmlwdFRyYW5zZmVyAwgFAWkGY2FsbGVyAAEFB2Fzc2V0SWQJAMwIAgkBC0RlbGV0ZUVudHJ5AQUHdGltZUtleQkAzAgCCQELRGVsZXRlRW50cnkBBQlrZXlIZWFsdGgJAMwIAgkBC0RlbGV0ZUVudHJ5AQkBD2tleUR1Y2tMb2NhdGlvbgEFCmFzc2V0SWRTdHIJAMwIAgkBC0RlbGV0ZUVudHJ5AQkBEGtleUR1Y2tJZFRvT3duZXIBBQphc3NldElkU3RyCQDMCAIJAQtEZWxldGVFbnRyeQEJASJrZXlTdGFrZWRUaW1lQnlUeXBlQXNzZXRJZEFuZE93bmVyAwUKRFVDS1BSRUZJWAUKYXNzZXRJZFN0cgUHYWRkcmVzcwkAzAgCCQELRGVsZXRlRW50cnkBCQEUa2V5U3Rha2VkRHVja0J5T3duZXIBBQdhZGRyZXNzBQNuaWwFDXByb2xvZ0FjdGlvbnMBaQEIY2xhaW1SZXMCBmFtb3VudA5sYW5kQXNzZXRJZFN0cgQNcHJvbG9nQWN0aW9ucwkBBnByb2xvZwEFAWkDCQECIT0CCQCQAwEIBQFpCHBheW1lbnRzAAAJAAIBAhRObyBwYXltZW50cyByZXF1aXJlZAQEYWRkcgkApQgBCAUBaQxvcmlnaW5DYWxsZXIEBnJlc3VsdAkBEGNsYWltUmVzSW50ZXJuYWwEBQRhZGRyBQZhbW91bnQFDWNsYWltTW9kZUR1Y2sFDmxhbmRBc3NldElkU3RyBAtkdWNrQXNzZXRJZAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCiCAEJARRrZXlTdGFrZWREdWNrQnlPd25lcgEFBGFkZHICHFlvdSBkb24ndCBoYXZlIGEgZHVjayBzdGFrZWQJAJQKAgkAzggCCQDNCAIJAM0IAgkAzggCCAUGcmVzdWx0Al8xCAkBF3VwZGF0ZUR1Y2tTdGF0c0ludGVybmFsAgULZHVja0Fzc2V0SWQJAGsDBQd4cENsYWltBQZhbW91bnQFBU1VTFQ4Al8xCQELU3RyaW5nRW50cnkCCAUGcmVzdWx0Al8yCQC5CQIIBQZyZXN1bHQCXzMCAToJAQtTdHJpbmdFbnRyeQIIBQZyZXN1bHQCXzQJALkJAggFBnJlc3VsdAJfNQIBOgUNcHJvbG9nQWN0aW9ucwkAkQMCCAUGcmVzdWx0Al8zBQhicElkeFJlcwFpAQxjbGFpbVJlc1RvV0gCBmFtb3VudA5sYW5kQXNzZXRJZFN0cgQNcHJvbG9nQWN0aW9ucwkBBnByb2xvZwEFAWkDCQECIT0CCQCQAwEIBQFpCHBheW1lbnRzAAAJAAIBAhRObyBwYXltZW50cyByZXF1aXJlZAQEYWRkcgkApQgBCAUBaQxvcmlnaW5DYWxsZXIEBnJlc3VsdAkBEGNsYWltUmVzSW50ZXJuYWwEBQRhZGRyBQZhbW91bnQFC2NsYWltTW9kZVdoBQ5sYW5kQXNzZXRJZFN0cgkAlAoCCQDOCAIJAM0IAgkAzQgCCQDOCAIIBQZyZXN1bHQCXzEICQEWdXBkYXRlQWNjU3RhdHNJbnRlcm5hbAIFBGFkZHIJAGsDBQd4cENsYWltBQZhbW91bnQFBU1VTFQ4Al8xCQELU3RyaW5nRW50cnkCCAUGcmVzdWx0Al8yCQC5CQIIBQZyZXN1bHQCXzMCAToJAQtTdHJpbmdFbnRyeQIIBQZyZXN1bHQCXzQJALkJAggFBnJlc3VsdAJfNQIBOgUNcHJvbG9nQWN0aW9ucwkAkQMCCAUGcmVzdWx0Al81BQh3aElkeFJlcwFpAQZmbGlnaHQCB21lc3NhZ2UDc2lnBA1wcm9sb2dBY3Rpb25zCQEMcHJvbG9nRmxpZ2h0AQUBaQMJAQIhPQIJAJADAQgFAWkIcGF5bWVudHMAAAkAAgECFE5vIHBheW1lbnRzIHJlcXVpcmVkBAh1c2VyQWRkcgkApQgBCAUBaQZjYWxsZXIEAWYJAQxmbGlnaHRDb21tb24DBQh1c2VyQWRkcgUHbWVzc2FnZQUDc2lnBAVuZXdIUAgFAWYCXzEEC2R1Y2tBc3NldElkCAUBZgJfMgQGbG9jS2V5CQEPa2V5RHVja0xvY2F0aW9uAQULZHVja0Fzc2V0SWQEC2N1ckxvY2F0aW9uCQELdmFsdWVPckVsc2UCCQCiCAEFBmxvY0tleQUPREVGQVVMVExPQ0FUSU9OBAtuZXdMb2NhdGlvbggFAWYCXzQDCQAAAgULbmV3TG9jYXRpb24FC2N1ckxvY2F0aW9uCQACAQIiWW91IGNhbid0IGZseSB0byB0aGUgc2FtZSBsb2NhdGlvbgQGbmV3TG9jCQC1CQIFC25ld0xvY2F0aW9uAgFfBAZpc1RvdXIJAAACCQCRAwIFBm5ld0xvYwUKbG9jSWR4VHlwZQIBVAQHaXNEZWxpdgkAAAIJAJEDAgUGbmV3TG9jBQpsb2NJZHhUeXBlAgFEBAVlcUtleQkBEGtleUR1Y2tFcXVpcG1lbnQBBQtkdWNrQXNzZXRJZAQJY3VycmVudEVxCQELdmFsdWVPckVsc2UCCQCiCAEFBWVxS2V5AhcsOyxfLDssXyw7LF8sOyxfLDssXyw7LAQNJHQwNzAyMDQ3MDMwMQkBEXN1YnRyYWN0RXF1aXBtZW50AgUJY3VycmVudEVxCAUBZgJfNQQFbmV3RXEIBQ0kdDA3MDIwNDcwMzAxAl8xBA9zaG91bGRaZXJvQnVmZnMIBQ0kdDA3MDIwNDcwMzAxAl8yBA0kdDA3MDMwNDczMzU1AwkBASEBCQEJb25NaXNzaW9uAgUSdG91cm5hbWVudENvbnRyYWN0BQtjdXJMb2NhdGlvbgMJAQEhAQkBD2lzVXN1YWxMb2NhdGlvbgEFC25ld0xvY2F0aW9uCQEMY2hlYXRBdHRlbXB0AwULY3VyTG9jYXRpb24FC25ld0xvY2F0aW9uAAUDCQBmAgUFbmV3SFAAAAkAlAoCBQtuZXdMb2NhdGlvbgUFbmV3SFAJAJQKAgULY3VyTG9jYXRpb24AAAMJAQ5pc0luVG91cm5hbWVudAIFEnRvdXJuYW1lbnRDb250cmFjdAULY3VyTG9jYXRpb24DCQEBIQEJAQ5pc0luVG91cm5hbWVudAIFEnRvdXJuYW1lbnRDb250cmFjdAULbmV3TG9jYXRpb24JAAIBAipZb3VyIGR1Y2sgaXMgdGFraW5nIHBhcnQgaW4gdGhlIHRvdXJuYW1lbnQEBXNjb3JlCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUGbmV3TG9jBQhsb2NJZHhJZAQGY3VyTG9jCQC1CQIFC2N1ckxvY2F0aW9uAgFfBAZsYXN0SWQJAQt2YWx1ZU9yRWxzZQIJAJoIAgUSdG91cm5hbWVudENvbnRyYWN0BQ1sYXN0VG91cklkS2V5AAADCQECIT0CBQVzY29yZQkAZAIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQZjdXJMb2MFCGxvY0lkeElkAAEJAQxjaGVhdEF0dGVtcHQDBQtjdXJMb2NhdGlvbgULbmV3TG9jYXRpb24ABwMJAGYCBQVuZXdIUAAABAlsb2NhbEJlc3QJAQt2YWx1ZU9yRWxzZQIJAJoIAgUSdG91cm5hbWVudENvbnRyYWN0CQEaa2V5QmVzdFJlc3VsdEJ5VG91ckFuZER1Y2sCBQZsYXN0SWQFC2R1Y2tBc3NldElkAAAECHVwZExvY2FsAwkAZgIFBXNjb3JlBQlsb2NhbEJlc3QJAPwHBAUSdG91cm5hbWVudENvbnRyYWN0Ag5zYXZlRHVja1Jlc3VsdAkAzAgCBQtkdWNrQXNzZXRJZAkAzAgCBQVzY29yZQUDbmlsBQNuaWwFBHVuaXQDCQAAAgUIdXBkTG9jYWwFCHVwZExvY2FsCQCUCgIFC25ld0xvY2F0aW9uBQVuZXdIUAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAlAoCBQtjdXJMb2NhdGlvbgAAAwkBASEBCQEMaXNJbkRlbGl2ZXJ5AQULY3VyTG9jYXRpb24ECWxvY0hlYWx0aAkBEGFzU3RyaW5nSW50VHVwbGUBCQD8BwQFBHRoaXMCEGF1dG9FeGl0RGVsaXZlcnkJAMwIAgULZHVja0Fzc2V0SWQFA25pbAUDbmlsAwkAAAIFCWxvY0hlYWx0aAUJbG9jSGVhbHRoAwUHaXNEZWxpdgUJbG9jSGVhbHRoAwkAZgIFBW5ld0hQAAAJAJQKAgULbmV3TG9jYXRpb24FBW5ld0hQCQCUCgIIBQlsb2NIZWFsdGgCXzEAAAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgMJAQEhAQUHaXNEZWxpdgkAAgECJFlvdXIgZHVjayBpcyB0YWtpbmcgcGFydCBpbiBkZWxpdmVyeQMJAQEhAQkBDGlzSW5EZWxpdmVyeQEFC25ld0xvY2F0aW9uCQEMY2hlYXRBdHRlbXB0AwULY3VyTG9jYXRpb24FC25ld0xvY2F0aW9uAA0EBXNjb3JlCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUGbmV3TG9jBQhsb2NJZHhJZAQGY3VyTG9jCQC1CQIFC2N1ckxvY2F0aW9uAgFfAwkBAiE9AgUFc2NvcmUJAGQCCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUGY3VyTG9jBQhsb2NJZHhJZAABCQEMY2hlYXRBdHRlbXB0AwULY3VyTG9jYXRpb24FC25ld0xvY2F0aW9uAA4DAwkAZgIFBW5ld0hQAAAJAGYCAAMFBXNjb3JlBwkAlAoCBQtuZXdMb2NhdGlvbgUFbmV3SFAECWxvY0hlYWx0aAkBEGFzU3RyaW5nSW50VHVwbGUBCQD8BwQFBHRoaXMCEGF1dG9FeGl0RGVsaXZlcnkJAMwIAgULZHVja0Fzc2V0SWQFA25pbAUDbmlsAwkAAAIFCWxvY0hlYWx0aAUJbG9jSGVhbHRoBQlsb2NIZWFsdGgJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4ECWxvY1RvU2F2ZQgFDSR0MDcwMzA0NzMzNTUCXzEECGhwVG9TYXZlCAUNJHQwNzAzMDQ3MzM1NQJfMgkAlAoCCQDOCAIJAM4IAgkAzggCCQDMCAIJAQtTdHJpbmdFbnRyeQIFBmxvY0tleQUJbG9jVG9TYXZlCQDMCAIJAQtTdHJpbmdFbnRyeQIFBWVxS2V5BQVuZXdFcQkAzAgCCQEMSW50ZWdlckVudHJ5AgkBDWtleUR1Y2tIZWFsdGgBBQtkdWNrQXNzZXRJZAUFbmV3SFAFA25pbAUNcHJvbG9nQWN0aW9ucwMFD3Nob3VsZFplcm9CdWZmcwkAzAgCCQELU3RyaW5nRW50cnkCCQEMa2V5RHVja0J1ZmZzAQULZHVja0Fzc2V0SWQCCTBfMF8wXzBfMAUDbmlsBQNuaWwICQEXdXBkYXRlRHVja1N0YXRzSW50ZXJuYWwCBQtkdWNrQXNzZXRJZAMJAGYCBQVuZXdIUAAABQ94cFN1Y2Nlc3NGbGlnaHQFDHhwRmFpbEZsaWdodAJfMQgFAWYCXzMBaQEEaGVhbAMKcXVhbnRpdHlMMQpxdWFudGl0eUwyCnF1YW50aXR5TDMEDXByb2xvZ0FjdGlvbnMJAQZwcm9sb2cBBQFpAwMDCQBmAgAABQpxdWFudGl0eUwxBgkAZgIAAAUKcXVhbnRpdHlMMgYJAGYCAAAFCnF1YW50aXR5TDMJAAIBAhtRdWFudGl0eSBjYW5ub3QgYmUgbmVnYXRpdmUEC2R1Y2tBc3NldElkCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAKIIAQkBFGtleVN0YWtlZER1Y2tCeU93bmVyAQkApQgBCAUBaQZjYWxsZXICHFlvdSBkb24ndCBoYXZlIGEgZHVjayBzdGFrZWQDCQEPY2hlY2tUb3VybmFtZW50AQULZHVja0Fzc2V0SWQJAAIBAhRoZWFsX2NoZWNrVG91cm5hbWVudAMJAQ1jaGVja0RlbGl2ZXJ5AQULZHVja0Fzc2V0SWQJAAIBAhJoZWFsX2NoZWNrRGVsaXZlcnkEA3F0cwkAzAgCBQpxdWFudGl0eUwxCQDMCAIFCnF1YW50aXR5TDIJAMwIAgUKcXVhbnRpdHlMMwUDbmlsBAlrZXlIZWFsdGgJAQ1rZXlEdWNrSGVhbHRoAQULZHVja0Fzc2V0SWQEBW1heEhQCQEJbWF4SGVhbHRoAQkBC3ZhbHVlT3JFbHNlAgkAnwgBCQEMa2V5RHVja0xldmVsAQULZHVja0Fzc2V0SWQAAAQJb2xkSGVhbHRoCQELdmFsdWVPckVsc2UCCQCfCAEFCWtleUhlYWx0aAUFbWF4SFADCQBnAgUJb2xkSGVhbHRoBQVtYXhIUAkAAgEJAKwCAgkArAICAg9IUCBzaG91bGQgYmUgPCAJAKQDAQUFbWF4SFACCCB0byBoZWFsBAVicEtleQkBEWtleUJhY2twYWNrQnlEdWNrAQULZHVja0Fzc2V0SWQEC2N1cnJlbnRQYWNrCQELZ2V0QmFja3BhY2sBBQVicEtleQQIcHJvZExpc3QDCQAAAgkAkQMCBQtjdXJyZW50UGFjawUJYnBJZHhQcm9kAgAFA25pbAkAvAkCCQCRAwIFC2N1cnJlbnRQYWNrBQlicElkeFByb2QCAV8KAQtpdGVyYXRlUHJvZAIDYWNjBnJlY2lwZQQBbggFA2FjYwJfMgQBeAMJAGYCCQCQAwEFCHByb2RMaXN0BQFuCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUIcHJvZExpc3QFAW4AAAMJAGYCAAMFAW4EAXEJAJEDAgUDcXRzBQFuAwkAZgIFAXEFAXgJAAIBCQCsAgIJAKwCAgkArAICAg5Zb3UgaGF2ZSBvbmx5IAkApAMBBQF4AgQgb2YgCQCRAwIFCXByb2RUeXBlcwUBbgkAlQoDCQDNCAIIBQNhY2MCXzEJAKQDAQkAZQIFAXgFAXEJAGQCBQFuAAEJAGQCCAUDYWNjAl8zCQBoAgkBDXBhcnNlSW50VmFsdWUBCQCRAwIJALUJAgUGcmVjaXBlAgFfBQpySWR4RWZmZWN0BQFxCQCVCgMJAM0IAggFA2FjYwJfMQkApAMBBQF4CQBkAgUBbgABCAUDYWNjAl8zBAZyZXN1bHQKAAIkbAUQcHJvZHVjdGlvbk1hdHJpeAoAAiRzCQCQAwEFAiRsCgAFJGFjYzAJAJUKAwUDbmlsAAAAAAoBBSRmMF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQELaXRlcmF0ZVByb2QCBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjBfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDUwCQEFJGYwXzICCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoACwAMAA0ADgAPABAAEQASABMAFAAVABYAFwAYABkAGgAbABwAHQAeAB8AIAAhACIAIwAkACUAJgAnACgAKQAqACsALAAtAC4ALwAwADEAMgQJbmV3SGVhbHRoCQCXAwEJAMwIAgUFbWF4SFAJAMwIAgkAZAIFCW9sZEhlYWx0aAgFBnJlc3VsdAJfMwUDbmlsCQCUCgIJAM4IAgkAzggCCQDMCAIJAQxJbnRlZ2VyRW50cnkCBQlrZXlIZWFsdGgFCW5ld0hlYWx0aAkAzAgCCQELU3RyaW5nRW50cnkCBQVicEtleQkAugkCCQDMCAIJAJEDAgULY3VycmVudFBhY2sFCmJwSWR4TGV2ZWwJAMwIAgkAkQMCBQtjdXJyZW50UGFjawUIYnBJZHhSZXMJAMwIAgkAkQMCBQtjdXJyZW50UGFjawUIYnBJZHhNYXQJAMwIAgkAuQkCCAUGcmVzdWx0Al8xAgFfBQNuaWwCAToFA25pbAUNcHJvbG9nQWN0aW9ucwgJARd1cGRhdGVEdWNrU3RhdHNJbnRlcm5hbAIFC2R1Y2tBc3NldElkCQBoAgUGeHBIZWFsCQBkAgkAZAIFCnF1YW50aXR5TDEFCnF1YW50aXR5TDIFCnF1YW50aXR5TDMCXzEFCW5ld0hlYWx0aAFpAQZoZWFsRVMABA1wcm9sb2dBY3Rpb25zCQEGcHJvbG9nAQUBaQMJAQIhPQIJAJADAQgFAWkIcGF5bWVudHMAAQkAAgECHEV4YWN0bHkgb25lIHBheW1lbnQgcmVxdWlyZWQEA3BtdAkBBXZhbHVlAQkAkQMCCAUBaQhwYXltZW50cwAAAwkBAiE9AggFA3BtdAdhc3NldElkBQt1c2R0QXNzZXRJZAkAAgECGkFsbG93ZWQgVVNEVCBwYXltZW50IG9ubHkhBAtkdWNrQXNzZXRJZAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCiCAEJARRrZXlTdGFrZWREdWNrQnlPd25lcgEJAKUIAQgFAWkGY2FsbGVyAhxZb3UgZG9uJ3QgaGF2ZSBhIGR1Y2sgc3Rha2VkAwkBD2NoZWNrVG91cm5hbWVudAEFC2R1Y2tBc3NldElkCQACAQIWaGVhbEVTX2NoZWNrVG91cm5hbWVudAMJAQ1jaGVja0RlbGl2ZXJ5AQULZHVja0Fzc2V0SWQJAAIBAhRoZWFsRVNfY2hlY2tEZWxpdmVyeQQJa2V5SGVhbHRoCQENa2V5RHVja0hlYWx0aAEFC2R1Y2tBc3NldElkBAVtYXhIUAkBCW1heEhlYWx0aAEJAQt2YWx1ZU9yRWxzZQIJAJ8IAQkBDGtleUR1Y2tMZXZlbAEFC2R1Y2tBc3NldElkAAAECW9sZEhlYWx0aAkBC3ZhbHVlT3JFbHNlAgkAnwgBBQlrZXlIZWFsdGgFBW1heEhQAwkAZgIFCW9sZEhlYWx0aAAACQACAQIoSFAgc2hvdWxkIGJlIDAgdG8gY2FsbCBFbWVyZ2VuY3kgU2VydmljZQQFYnBLZXkJARFrZXlCYWNrcGFja0J5RHVjawEFC2R1Y2tBc3NldElkBAtjdXJyZW50UGFjawkBC2dldEJhY2twYWNrAQUFYnBLZXkECHByb2RMaXN0AwkAAAIJAJEDAgULY3VycmVudFBhY2sFCWJwSWR4UHJvZAIABQNuaWwJALwJAgkAkQMCBQtjdXJyZW50UGFjawUJYnBJZHhQcm9kAgFfBA1tZWRLaXRBbW91bnQxAwkAZgIJAJADAQUIcHJvZExpc3QAAAkBDXBhcnNlSW50VmFsdWUBCQCRAwIFCHByb2RMaXN0AAAAAAQNbWVkS2l0QW1vdW50MgMJAGYCCQCQAwEFCHByb2RMaXN0AAEJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQhwcm9kTGlzdAABAAAEDW1lZEtpdEFtb3VudDMDCQBmAgkAkAMBBQhwcm9kTGlzdAACCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUIcHJvZExpc3QAAgAAAwMDCQBmAgUNbWVkS2l0QW1vdW50MQAABgkAZgIFDW1lZEtpdEFtb3VudDIAAAYJAGYCBQ1tZWRLaXRBbW91bnQzAAAJAAIBAh9Zb3UgaGF2ZSB0byB1c2Ugb3duIE1lZGljYWwgS2l0BAhleGlzdFN0cgkAnQgCBQ9lY29ub215Q29udHJhY3QJAQ5rZXlFc1dhcmVob3VzZQAEDGV4aXN0QW1vdW50cwMJAQlpc0RlZmluZWQBBQhleGlzdFN0cgkAvAkCCQEFdmFsdWUBBQhleGlzdFN0cgIBXwUDbmlsBAtleGlzdEFtb3VudAMJAGYCCQCQAwEFDGV4aXN0QW1vdW50cwAACQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUMZXhpc3RBbW91bnRzAAAAAAMJAGcCAAAFC2V4aXN0QW1vdW50CQACAQI5VGhlcmUgYXJlIG5vIE1lZGljYWwgS2l0cyBMMSBhdCBFbWVyZ2VuY3kgU2VydmljZSBzdG9yYWdlBAluZXdIZWFsdGgJAGQCBQlvbGRIZWFsdGgJAQ1wYXJzZUludFZhbHVlAQkAkQMCCQC1CQIJAJEDAgUQcHJvZHVjdGlvbk1hdHJpeAAAAgFfBQpySWR4RWZmZWN0BAVuZXdFUwkAuQkCCQDMCAIJAKQDAQkAZQIFC2V4aXN0QW1vdW50AAEJANEIAgUMZXhpc3RBbW91bnRzAAACAV8EBnJlY2lwZQkAtQkCCQCRAwIFEHByb2R1Y3Rpb25NYXRyaXgAAAIBXwQIdG90YWxNYXQJARJnZXRSZWNpcGVNYXRlcmlhbHMBBQZyZWNpcGUECXNlbGxQcmljZQkAawMJAGgCBQh0b3RhbE1hdAUKRVNTRUxMQ09FRgUQUkVTT1VSQ0VQUklDRU1JTgkAaAIFBU1VTFQ4BQ5QUk9EVUNUUEtHU0laRQMJAQIhPQIIBQNwbXQGYW1vdW50BQlzZWxsUHJpY2UJAAIBCQCsAgICG1BheW1lbnQgYXR0YWNoZWQgc2hvdWxkIGJlIAkApAMBBQlzZWxsUHJpY2UEBnJlc3VsdAkBCGFzU3RyaW5nAQkA/AcEBQ9lY29ub215Q29udHJhY3QCD3VwZGF0ZUVzU3RvcmFnZQkAzAgCBQVuZXdFUwUDbmlsCQDMCAIJAQ9BdHRhY2hlZFBheW1lbnQCBQt1c2R0QXNzZXRJZAUJc2VsbFByaWNlBQNuaWwJAJQKAgkAzggCCQDNCAIFDXByb2xvZ0FjdGlvbnMJAQxJbnRlZ2VyRW50cnkCBQlrZXlIZWFsdGgFCW5ld0hlYWx0aAgJARd1cGRhdGVEdWNrU3RhdHNJbnRlcm5hbAIFC2R1Y2tBc3NldElkBQh4cENhbGxFUwJfMQUGcmVzdWx0AWkBDnVwZGF0ZUJhY2twYWNrAgtkdWNrQXNzZXRJZAduZXdQYWNrAwkBAiE9AggFAWkGY2FsbGVyBQ9lY29ub215Q29udHJhY3QJAAIBAhFwZXJtaXNzaW9uIGRlbmllZAkAlAoCCQDMCAIJAQtTdHJpbmdFbnRyeQIJARFrZXlCYWNrcGFja0J5RHVjawEFC2R1Y2tBc3NldElkBQduZXdQYWNrBQNuaWwFB25ld1BhY2sBaQEPY29tbWl0Rm9yUmFuZG9tAAQNcHJvbG9nQWN0aW9ucwkBBnByb2xvZwEFAWkEC2ZpbmlzaEJsb2NrCQBkAgUGaGVpZ2h0BQtyYW5kb21EZWxheQQEYWRkcgkApQgBCAUBaQZjYWxsZXIJAJQKAgkAzggCCQDMCAIJAQxJbnRlZ2VyRW50cnkCCQEJa2V5Q29tbWl0AQUEYWRkcgULZmluaXNoQmxvY2sFA25pbAUNcHJvbG9nQWN0aW9ucwULZmluaXNoQmxvY2sBaQEIYnV5U0xhbmQABA1wcm9sb2dBY3Rpb25zCQEGcHJvbG9nAQUBaQMJAQIhPQIJAJADAQgFAWkIcGF5bWVudHMAAQkAAgECHEV4YWN0bHkgb25lIHBheW1lbnQgcmVxdWlyZWQEA3BtdAkBBXZhbHVlAQkAkQMCCAUBaQhwYXltZW50cwAAAwkBAiE9AggFA3BtdAdhc3NldElkBQt1c2R0QXNzZXRJZAkAAgECGkFsbG93ZWQgVVNEVCBwYXltZW50IG9ubHkhAwkBAiE9AggFA3BtdAZhbW91bnQFB0VYUFVTRFQJAAIBCQCsAgICG1BheW1lbnQgYXR0YWNoZWQgc2hvdWxkIGJlIAkApAMBBQdFWFBVU0RUBAZyZXN1bHQJARJleHBlZGl0aW9uSW50ZXJuYWwCCAUBaQZjYWxsZXIIBQFpDXRyYW5zYWN0aW9uSWQEC2FjcmVzUmVzdWx0CQEFYXNJbnQBCQD8BwQFDWFjcmVzQ29udHJhY3QCCWJ1cm5BY3JlcwkAzAgCBQxTX0NPU1RfQUNSRVMFA25pbAUDbmlsCQCUCgIJAM4IAgkAzggCCQDNCAIIBQZyZXN1bHQCXzEJAQ5TY3JpcHRUcmFuc2ZlcgMFD2Vjb25vbXlDb250cmFjdAgFA3BtdAZhbW91bnQFC3VzZHRBc3NldElkCAkBFnVwZGF0ZUFjY1N0YXRzSW50ZXJuYWwCCQClCAEIBQFpBmNhbGxlcgUKeHBOZXdTTGFuZAJfMQUNcHJvbG9nQWN0aW9ucwkAlAoCCAgFBnJlc3VsdAJfMgJfMQULYWNyZXNSZXN1bHQBaQEKZXhwZWRpdGlvbgIHbWVzc2FnZQNzaWcEDXByb2xvZ0FjdGlvbnMJAQZwcm9sb2cBBQFpAwkBAiE9AgkAkAMBCAUBaQhwYXltZW50cwAACQACAQIUTm8gcGF5bWVudHMgcmVxdWlyZWQECHVzZXJBZGRyCQClCAEIBQFpBmNhbGxlcgQBZgkBDGZsaWdodENvbW1vbgMFCHVzZXJBZGRyBQdtZXNzYWdlBQNzaWcEC2R1Y2tBc3NldElkCAUBZgJfMgQJa2V5SGVhbHRoCQENa2V5RHVja0hlYWx0aAEFC2R1Y2tBc3NldElkBAVicEtleQkBEWtleUJhY2twYWNrQnlEdWNrAQULZHVja0Fzc2V0SWQEC2N1cnJlbnRQYWNrCQELZ2V0QmFja3BhY2sBBQVicEtleQQFbUxpc3QJALUJAgkAkQMCBQtjdXJyZW50UGFjawUIYnBJZHhNYXQCAV8EBm5ld01hdAkAuQkCCQERc3VidHJhY3RNYXRlcmlhbHMDBgUFbUxpc3QFDEVYUE1BVEVSSUFMUwIBXwQFZXFLZXkJARBrZXlEdWNrRXF1aXBtZW50AQULZHVja0Fzc2V0SWQECWN1cnJlbnRFcQkBC3ZhbHVlT3JFbHNlAgkAoggBBQVlcUtleQIXLDssXyw7LF8sOyxfLDssXyw7LF8sOywEDSR0MDgwNzkyODA4ODkJARFzdWJ0cmFjdEVxdWlwbWVudAIFCWN1cnJlbnRFcQgFAWYCXzUEBW5ld0VxCAUNJHQwODA3OTI4MDg4OQJfMQQPc2hvdWxkWmVyb0J1ZmZzCAUNJHQwODA3OTI4MDg4OQJfMgQBZQkBEmV4cGVkaXRpb25JbnRlcm5hbAIIBQFpBmNhbGxlcggFAWkNdHJhbnNhY3Rpb25JZAQCaWQICAUBZQJfMgJfMQQGcmVzdWx0AwkAZwIAAAgFAWYCXzEJAJUKAwkAzAgCCQEMSW50ZWdlckVudHJ5AgUJa2V5SGVhbHRoAAAJAMwIAgkBC1N0cmluZ0VudHJ5AgUFZXFLZXkFBW5ld0VxBQNuaWwCAAAACQCVCgMJAM4IAggFAWUCXzEDBQ9zaG91bGRaZXJvQnVmZnMJAMwIAgkBC1N0cmluZ0VudHJ5AgkBDGtleUR1Y2tCdWZmcwEFC2R1Y2tBc3NldElkAgkwXzBfMF8wXzAFA25pbAkAzQgCCQDNCAIJAM0IAgkAzQgCBQNuaWwJAQtTdHJpbmdFbnRyeQIJAQ9rZXlEdWNrTG9jYXRpb24BBQtkdWNrQXNzZXRJZAkAuQkCCQDMCAIICAUBZQJfMgJfMgkAzAgCAgFMCQDMCAIFAmlkBQNuaWwCAV8JAQxJbnRlZ2VyRW50cnkCBQlrZXlIZWFsdGgIBQFmAl8xCQELU3RyaW5nRW50cnkCBQVlcUtleQUFbmV3RXEJAQtTdHJpbmdFbnRyeQIFBWJwS2V5CQC5CQIJAMwIAgkAkQMCBQtjdXJyZW50UGFjawUKYnBJZHhMZXZlbAkAzAgCCQCRAwIFC2N1cnJlbnRQYWNrBQhicElkeFJlcwkAzAgCBQZuZXdNYXQJAMwIAgkAkQMCBQtjdXJyZW50UGFjawUJYnBJZHhQcm9kBQNuaWwCAToFAmlkCAUBZgJfMwMJAQ9jaGVja1RvdXJuYW1lbnQBBQtkdWNrQXNzZXRJZAkAAgECGmV4cGVkaXRpb25fY2hlY2tUb3VybmFtZW50AwkBDWNoZWNrRGVsaXZlcnkBBQtkdWNrQXNzZXRJZAkAAgECGGV4cGVkaXRpb25fY2hlY2tEZWxpdmVyeQQLYWNyZXNSZXN1bHQJAQVhc0ludAEJAPwHBAUNYWNyZXNDb250cmFjdAIJYnVybkFjcmVzCQDMCAIFDFNfQ09TVF9BQ1JFUwUDbmlsBQNuaWwJAJQKAgkAzggCCQDOCAIIBQZyZXN1bHQCXzEICQEXdXBkYXRlRHVja1N0YXRzSW50ZXJuYWwCBQtkdWNrQXNzZXRJZAUKeHBOZXdTTGFuZAJfMQUNcHJvbG9nQWN0aW9ucwkAlQoDCAUGcmVzdWx0Al8yCAUGcmVzdWx0Al8zBQthY3Jlc1Jlc3VsdAFpARBidXlTTGFuZEZvckFjcmVzAAQNcHJvbG9nQWN0aW9ucwkBBnByb2xvZwEFAWkDCQECIT0CCQCQAwEIBQFpCHBheW1lbnRzAAEJAAIBAiJleGFjdGx5IDEgcGF5bWVudCBtdXN0IGJlIGF0dGFjaGVkBANwbXQJAJEDAggFAWkIcGF5bWVudHMAAAQDYW10CAUDcG10BmFtb3VudAMDCQEBIQEJAQlpc0RlZmluZWQBCAUDcG10B2Fzc2V0SWQGCQECIT0CCQEFdmFsdWUBCAUDcG10B2Fzc2V0SWQFDGFjcmVzQXNzZXRJZAkAAgECFEFDUkVTIHBheW1lbnRzIG9ubHkhAwkBAiE9AgUDYW10BQxTX0NPU1RfQUNSRVMJAAIBCQCsAgICG1BheW1lbnQgYXR0YWNoZWQgc2hvdWxkIGJlIAkApAMBBQxTX0NPU1RfQUNSRVMEBnJlc3VsdAkBEmV4cGVkaXRpb25JbnRlcm5hbAIIBQFpBmNhbGxlcggFAWkNdHJhbnNhY3Rpb25JZAQLYWNyZXNSZXN1bHQJAQVhc0ludAEJAPwHBAUNYWNyZXNDb250cmFjdAIJYnVybkFjcmVzCQDMCAIFDFNfQ09TVF9BQ1JFUwUDbmlsCQDMCAIJAQ9BdHRhY2hlZFBheW1lbnQCBQxhY3Jlc0Fzc2V0SWQFA2FtdAUDbmlsCQCUCgIJAM4IAgkAzggCCAUGcmVzdWx0Al8xCAkBFnVwZGF0ZUFjY1N0YXRzSW50ZXJuYWwCCQClCAEIBQFpBmNhbGxlcgUKeHBOZXdTTGFuZAJfMQUNcHJvbG9nQWN0aW9ucwkAlAoCCAgFBnJlc3VsdAJfMgJfMQULYWNyZXNSZXN1bHQBaQEMdXBncmFkZUluZnJhAQtsYW5kQXNzZXRJZAQNcHJvbG9nQWN0aW9ucwkBBnByb2xvZwEFAWkDCQECIT0CCQCQAwEIBQFpCHBheW1lbnRzAAAJAAIBAhRObyBwYXltZW50cyByZXF1aXJlZAQGcmVzdWx0CQENdXBJbmZyYUNvbW1vbgQGCAUBaQZjYWxsZXIAAAULbGFuZEFzc2V0SWQEC2R1Y2tBc3NldElkCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAKIIAQkBFGtleVN0YWtlZER1Y2tCeU93bmVyAQkApQgBCAUBaQZjYWxsZXICHFlvdSBkb24ndCBoYXZlIGEgZHVjayBzdGFrZWQJAJQKAgkAzggCCQDOCAIIBQZyZXN1bHQCXzEFDXByb2xvZ0FjdGlvbnMICQEXdXBkYXRlRHVja1N0YXRzSW50ZXJuYWwCBQtkdWNrQXNzZXRJZAkAawMFDnhwVXBncmFkZUluZnJhCAUGcmVzdWx0Al8zBQVNVUxUOAJfMQgFBnJlc3VsdAJfMgFpARBhY3RpdmF0ZUFydGlmYWN0AgdhcnROYW1lDmxhbmRBc3NldElkT3B0BA1wcm9sb2dBY3Rpb25zCQEGcHJvbG9nAQUBaQMJAQIhPQIJAJADAQgFAWkIcGF5bWVudHMAAAkAAgECFE5vIHBheW1lbnRzIHJlcXVpcmVkBARhZGRyCQClCAEIBQFpBmNhbGxlcgQGcmVzdWx0BAckbWF0Y2gwBQdhcnROYW1lAwkAAAICB1BSRVNBTEUFByRtYXRjaDAJARJhY3RpdmF0ZVByZXNhbGVBcnQCBQRhZGRyBQ5sYW5kQXNzZXRJZE9wdAMJAAACAgdPTkJPQVJEBQckbWF0Y2gwCQESYWN0aXZhdGVPbmJvYXJkQXJ0AQUEYWRkcgkAAgECEFVua25vd24gYXJ0aWZhY3QJAM4IAgUGcmVzdWx0BQ1wcm9sb2dBY3Rpb25zAWkBCm1lcmdlTGFuZHMBDGxhbmRBc3NldElkcwQNcHJvbG9nQWN0aW9ucwkBBnByb2xvZwEFAWkDCQECIT0CCQCQAwEIBQFpCHBheW1lbnRzAAAJAAIBAhRObyBwYXltZW50cyByZXF1aXJlZAQGcmVzdWx0CQELbWVyZ2VDb21tb24CCQClCAEIBQFpBmNhbGxlcgUMbGFuZEFzc2V0SWRzCQCUCgIJAM4IAgkAzggCCAUGcmVzdWx0Al8xBQ1wcm9sb2dBY3Rpb25zCAkBFnVwZGF0ZUFjY1N0YXRzSW50ZXJuYWwCCQClCAEIBQFpBmNhbGxlcgUHeHBNZXJnZQJfMQgFBnJlc3VsdAJfMgFpAQ1jYXJnb0V4Y2hhbmdlAgxjYXJnb0xpc3RTdHILbGFuZEFzc2V0SWQEDXByb2xvZ0FjdGlvbnMJAQZwcm9sb2cBBQFpAwkBAiE9AgkAkAMBCAUBaQhwYXltZW50cwAACQACAQIUTm8gcGF5bWVudHMgcmVxdWlyZWQECmNhcmdvUGFydHMJALwJAgUMY2FyZ29MaXN0U3RyAgE6BARhZGRyCQClCAEIBQFpDG9yaWdpbkNhbGxlcgQFYXNzZXQJAQV2YWx1ZQEJAOwHAQkA2QQBBQtsYW5kQXNzZXRJZAQHdGltZUtleQkBFmtleVN0YWtlZFRpbWVCeUFzc2V0SWQBBQtsYW5kQXNzZXRJZAMJAQEhAQkBCWlzRGVmaW5lZAEJAJ8IAQUHdGltZUtleQkAAgEJAKwCAggFBWFzc2V0BG5hbWUCDiBpcyBub3Qgc3Rha2VkBAVvd25lcgkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCiCAEJARVrZXlMYW5kQXNzZXRJZFRvT3duZXIBBQtsYW5kQXNzZXRJZAkArAICCQCsAgICBE5GVCAIBQVhc3NldARuYW1lAgwgaXMgb3JwaGFuZWQDCQECIT0CBQVvd25lcgUEYWRkcgkAAgEJAKwCAgUKTEFORFBSRUZJWAINIGlzIG5vdCB5b3VycwQJbGFuZEluZGV4CQBpAgkBD251bVBpZWNlc0J5U2l6ZQEJAJEDAgkAtQkCCAUFYXNzZXQLZGVzY3JpcHRpb24CAV8FC3JlY0xhbmRTaXplBQVTU0laRQQKaW5mcmFMZXZlbAkBC3ZhbHVlT3JFbHNlAgkAnwgBCQEWa2V5SW5mcmFMZXZlbEJ5QXNzZXRJZAEFC2xhbmRBc3NldElkAAAEC2R1Y2tBc3NldElkCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAKIIAQkBFGtleVN0YWtlZER1Y2tCeU93bmVyAQUEYWRkcgIcWW91IGRvbid0IGhhdmUgYSBkdWNrIHN0YWtlZAQLY3VyTG9jYXRpb24JAQt2YWx1ZU9yRWxzZQIJAKIIAQkBD2tleUR1Y2tMb2NhdGlvbgEFC2R1Y2tBc3NldElkBQ9ERUZBVUxUTE9DQVRJT04EA2xvYwkAtQkCCQEFdmFsdWUBBQtjdXJMb2NhdGlvbgIBXwMJAQIhPQIJAJEDAgUDbG9jBQpsb2NJZHhUeXBlAgFMCQACAQkArAICCQCsAgICFkR1Y2sgbG9jYXRpb24gdHlwZSBpcyAJAJEDAgUDbG9jBQpsb2NJZHhUeXBlAhEsIGJ1dCBzaG91bGQgYmUgTAMJAQIhPQIJAJEDAgUDbG9jBQhsb2NJZHhJZAULbGFuZEFzc2V0SWQJAAIBCQCsAgICG0R1Y2sgc2hvdWxkIGJlIG9uIHRoZSBsYW5kIAULbGFuZEFzc2V0SWQEBXdoS2V5CQESa2V5V2FyZWhvdXNlQnlMYW5kAQULbGFuZEFzc2V0SWQECWN1cnJlbnRXaAkBDGdldFdhcmVob3VzZQMFBXdoS2V5BQlsYW5kSW5kZXgFCmluZnJhTGV2ZWwEBWJwS2V5CQERa2V5QmFja3BhY2tCeUR1Y2sBBQtkdWNrQXNzZXRJZAQLY3VycmVudFBhY2sJAQtnZXRCYWNrcGFjawEFBWJwS2V5BAZyZXN1bHQJAQltb3ZlU3R1ZmYDBQpjYXJnb1BhcnRzBQljdXJyZW50V2gFC2N1cnJlbnRQYWNrBARsb2Z0CQC1CQIJAJEDAgUJY3VycmVudFdoBQl3aElkeExPRlQCAV8EBWxvZnRPCQBkAgkBDXBhcnNlSW50VmFsdWUBCQCRAwIFBGxvZnQFC3ZvbE9jY3VwaWVkCAUGcmVzdWx0Al83BAVsb2Z0RgkAZQIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQRsb2Z0BQd2b2xGcmVlCAUGcmVzdWx0Al83CQDOCAIJAMwIAgkBC1N0cmluZ0VudHJ5AgUFYnBLZXkJALoJAgkAzAgCCQCRAwIFC2N1cnJlbnRQYWNrBQpicElkeExldmVsCQDMCAIIBQZyZXN1bHQCXzQJAMwIAggFBnJlc3VsdAJfNQkAzAgCCAUGcmVzdWx0Al82BQNuaWwCAToJAMwIAgkBC1N0cmluZ0VudHJ5AgUFd2hLZXkJALoJAgkAzAgCCQCRAwIFCWN1cnJlbnRXaAULd2hJZHhMZXZlbHMJAMwIAggFBnJlc3VsdAJfMQkAzAgCCAUGcmVzdWx0Al8yCQDMCAIIBQZyZXN1bHQCXzMJAMwIAgkAuQkCCQDMCAIJAJEDAgUEbG9mdAUJdm9sTG9ja2VkCQDMCAIJAKQDAQUFbG9mdE8JAMwIAgkApAMBBQVsb2Z0RgkAzAgCCQCRAwIFBGxvZnQFCHZvbFRvdGFsBQNuaWwCAV8FA25pbAIBOgUDbmlsBQ1wcm9sb2dBY3Rpb25zAWkBDXNhdmVXYXJlaG91c2UCBXdoU3RyC2xhbmRBc3NldElkAwkBAiE9AggFAWkGY2FsbGVyBQ9lY29ub215Q29udHJhY3QJAAIBAg1BY2Nlc3MgZGVuaWVkBAV3aEtleQkBEmtleVdhcmVob3VzZUJ5TGFuZAEFC2xhbmRBc3NldElkBAJ3aAkAvAkCBQV3aFN0cgIBOgMJAQIhPQIJAJADAQUCd2gABQkAAgECMHdhcmVob3VzZSBzdHJpbmcgc2hvdWxkIGNvbnRhaW4gNCAnOicgc2VwYXJhdG9ycwQFbG9mdEwJAJEDAgkAtQkCCQCRAwIFAndoBQl3aElkeExPRlQCAV8FCXZvbExvY2tlZAQFbG9mdE8JARdnZXRXYXJlaG91c2VPY2N1cGllZFZvbAEFAndoBAVsb2Z0VAkBF2dldFdhcmVob3VzZVRvdGFsVm9sdW1lAQkAkQMCBQJ3aAULd2hJZHhMZXZlbHMEBWxvZnRGCQBlAgkAZQIFBWxvZnRUCQENcGFyc2VJbnRWYWx1ZQEFBWxvZnRMBQVsb2Z0TwQIbmV3V2hTdHIJALoJAgkAzAgCCQCRAwIFAndoBQt3aElkeExldmVscwkAzAgCCQCRAwIFAndoBQh3aElkeFJlcwkAzAgCCQCRAwIFAndoBQh3aElkeE1hdAkAzAgCCQCRAwIFAndoBQl3aElkeFByb2QJAMwIAgkAuQkCCQDMCAIFBWxvZnRMCQDMCAIJAKQDAQUFbG9mdE8JAMwIAgkApAMBBQVsb2Z0RgkAzAgCCQCkAwEFBWxvZnRUBQNuaWwCAV8FA25pbAIBOgkAlAoCCQDMCAIJAQtTdHJpbmdFbnRyeQIFBXdoS2V5BQhuZXdXaFN0cgUDbmlsBQhuZXdXaFN0cgFpARJmaXhXYXJlaG91c2VGb3JtYXQBC2xhbmRBc3NldElkAwkBAiE9AggFAWkGY2FsbGVyBQxyZXN0Q29udHJhY3QJAAIBAg1BY2Nlc3MgZGVuaWVkBAV3aEtleQkBEmtleVdhcmVob3VzZUJ5TGFuZAEFC2xhbmRBc3NldElkBAVhc3NldAkBBXZhbHVlAQkA7AcBCQDZBAEFC2xhbmRBc3NldElkBAlsYW5kSW5kZXgJAGkCCQEPbnVtUGllY2VzQnlTaXplAQkAkQMCCQC1CQIIBQVhc3NldAtkZXNjcmlwdGlvbgIBXwULcmVjTGFuZFNpemUFBVNTSVpFBAppbmZyYUxldmVsCQELdmFsdWVPckVsc2UCCQCfCAEJARZrZXlJbmZyYUxldmVsQnlBc3NldElkAQULbGFuZEFzc2V0SWQAAAQCd2gJAQxnZXRXYXJlaG91c2UDBQV3aEtleQUJbGFuZEluZGV4BQppbmZyYUxldmVsBAVsb2Z0TAkBBWFzSW50AQkA/AcEBQ9lY29ub215Q29udHJhY3QCGnJlY2FsY0xvY2tlZFZvbHVtZVJFQURPTkxZCQDMCAIFC2xhbmRBc3NldElkCQDMCAIFAndoBQNuaWwFA25pbAQFbG9mdE8JARdnZXRXYXJlaG91c2VPY2N1cGllZFZvbAEFAndoBAVsb2Z0VAkBF2dldFdhcmVob3VzZVRvdGFsVm9sdW1lAQkAkQMCBQJ3aAULd2hJZHhMZXZlbHMEBWxvZnRGCQBlAgkAZQIFBWxvZnRUBQVsb2Z0TAUFbG9mdE8ECG5ld1doU3RyCQC6CQIJAMwIAgkAkQMCBQJ3aAULd2hJZHhMZXZlbHMJAMwIAgkAkQMCBQJ3aAUId2hJZHhSZXMJAMwIAgkAkQMCBQJ3aAUId2hJZHhNYXQJAMwIAgkAkQMCBQJ3aAUJd2hJZHhQcm9kCQDMCAIJALkJAgkAzAgCCQCkAwEFBWxvZnRMCQDMCAIJAKQDAQUFbG9mdE8JAMwIAgkApAMBBQVsb2Z0RgkAzAgCCQCkAwEFBWxvZnRUBQNuaWwCAV8FA25pbAIBOgkAlAoCCQDMCAIJAQtTdHJpbmdFbnRyeQIFBXdoS2V5BQhuZXdXaFN0cgUDbmlsBQhuZXdXaFN0cgFpARdmaXhDb250aW5lbnRQcm9wb3J0aW9ucwEMbGFuZEFzc2V0SWRzAwkBAiE9AggFAWkGY2FsbGVyBQxyZXN0Q29udHJhY3QJAAIBAg1BY2Nlc3MgZGVuaWVkCgEIZ2V0UHJvcHMCA2FjYwRjb250CQDNCAIFA2FjYwkBC3ZhbHVlT3JFbHNlAgkAoggBCQEWa2V5UmVzVHlwZXNCeUNvbnRpbmVudAEFBGNvbnQCCzBfMF8wXzBfMF8wBAFwCgACJGwFCmNvbnRpbmVudHMKAAIkcwkAkAMBBQIkbAoABSRhY2MwBQNuaWwKAQUkZjBfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBCGdldFByb3BzAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGYwXzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhNMaXN0IHNpemUgZXhjZWVkcyA1CQEFJGYwXzICCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECBQUkYWNjMAAAAAEAAgADAAQABQoBCXByb2Nlc3NvcgIDYWNjC2xhbmRBc3NldElkBAVhc3NldAkBBXZhbHVlAQkA7AcBCQDZBAEFC2xhbmRBc3NldElkBAFkCQC1CQIIBQVhc3NldAtkZXNjcmlwdGlvbgIBXwQJbGFuZEluZGV4CQBpAgkBD251bVBpZWNlc0J5U2l6ZQEJAJEDAgUBZAULcmVjTGFuZFNpemUFBVNTSVpFBARjb250CQCRAwIFAWQFDHJlY0NvbnRpbmVudAQNdGVycmFpbkNvdW50cwkBDWNvdW50VGVycmFpbnMBCQCRAwIFAWQFC3JlY1RlcnJhaW5zBAxjb250aW5lbnRJZHgJAQV2YWx1ZQEJAM8IAgUKY29udGluZW50cwUEY29udAQJY29udFByb3BzCQC1CQIJAJEDAgUDYWNjBQxjb250aW5lbnRJZHgCAV8EB3VwZGF0ZWQJALkJAgkBGXVwZGF0ZVByb3BvcnRpb25zSW50ZXJuYWwEBQljb250UHJvcHMFDXRlcnJhaW5Db3VudHMFCWxhbmRJbmRleAABAgFfBAckbWF0Y2gwBQRjb250AwkAAAICCEFtZXJpY2FzBQckbWF0Y2gwCQDMCAIFB3VwZGF0ZWQJAMwIAgkAkQMCBQNhY2MAAQkAzAgCCQCRAwIFA2FjYwACCQDMCAIJAJEDAgUDYWNjAAMJAMwIAgkAkQMCBQNhY2MABAUDbmlsAwkAAAICBkV1cm9wZQUHJG1hdGNoMAkAzAgCCQCRAwIFA2FjYwAACQDMCAIFB3VwZGF0ZWQJAMwIAgkAkQMCBQNhY2MAAgkAzAgCCQCRAwIFA2FjYwADCQDMCAIJAJEDAgUDYWNjAAQFA25pbAMJAAACAgRBc2lhBQckbWF0Y2gwCQDMCAIJAJEDAgUDYWNjAAAJAMwIAgkAkQMCBQNhY2MAAQkAzAgCBQd1cGRhdGVkCQDMCAIJAJEDAgUDYWNjAAMJAMwIAgkAkQMCBQNhY2MABAUDbmlsAwkAAAICBkFmcmljYQUHJG1hdGNoMAkAzAgCCQCRAwIFA2FjYwAACQDMCAIJAJEDAgUDYWNjAAEJAMwIAgkAkQMCBQNhY2MAAgkAzAgCBQd1cGRhdGVkCQDMCAIJAJEDAgUDYWNjAAQFA25pbAMJAAACAgdPY2VhbmlhBQckbWF0Y2gwCQDMCAIJAJEDAgUDYWNjAAAJAMwIAgkAkQMCBQNhY2MAAQkAzAgCCQCRAwIFA2FjYwACCQDMCAIJAJEDAgUDYWNjAAMJAMwIAgUHdXBkYXRlZAUDbmlsCQACAQIPd3JvbmcgY29udGluZW50BAFyCgACJGwFDGxhbmRBc3NldElkcwoAAiRzCQCQAwEFAiRsCgAFJGFjYzAFAXAKAQUkZjFfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBCXByb2Nlc3NvcgIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMV8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIVTGlzdCBzaXplIGV4Y2VlZHMgMTAwCQEFJGYxXzICCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoACwAMAA0ADgAPABAAEQASABMAFAAVABYAFwAYABkAGgAbABwAHQAeAB8AIAAhACIAIwAkACUAJgAnACgAKQAqACsALAAtAC4ALwAwADEAMgAzADQANQA2ADcAOAA5ADoAOwA8AD0APgA/AEAAQQBCAEMARABFAEYARwBIAEkASgBLAEwATQBOAE8AUABRAFIAUwBUAFUAVgBXAFgAWQBaAFsAXABdAF4AXwBgAGEAYgBjAGQJAJQKAgkAzAgCCQELU3RyaW5nRW50cnkCCQEWa2V5UmVzVHlwZXNCeUNvbnRpbmVudAECCEFtZXJpY2FzCQCRAwIFAXIAAAkAzAgCCQELU3RyaW5nRW50cnkCCQEWa2V5UmVzVHlwZXNCeUNvbnRpbmVudAECBkV1cm9wZQkAkQMCBQFyAAEJAMwIAgkBC1N0cmluZ0VudHJ5AgkBFmtleVJlc1R5cGVzQnlDb250aW5lbnQBAgRBc2lhCQCRAwIFAXIAAgkAzAgCCQELU3RyaW5nRW50cnkCCQEWa2V5UmVzVHlwZXNCeUNvbnRpbmVudAECBkFmcmljYQkAkQMCBQFyAAMJAMwIAgkBC1N0cmluZ0VudHJ5AgkBFmtleVJlc1R5cGVzQnlDb250aW5lbnQBAgdPY2VhbmlhCQCRAwIFAXIABAUDbmlsAAABaQEPZml4U3Rha2VkUGllY2VzAQdhZGRyZXNzAwkBAiE9AggFAWkGY2FsbGVyBQxyZXN0Q29udHJhY3QJAAIBAg1BY2Nlc3MgZGVuaWVkBAxzdGFrZWRQaWVjZXMDCQAAAgUHYWRkcmVzcwIAAAAECGxhbmRzU3RyCQCdCAIFD3N0YWtpbmdDb250cmFjdAkBFWtleVN0YWtlZExhbmRzQnlPd25lcgEFB2FkZHJlc3MEBWxhbmRzAwkBCWlzRGVmaW5lZAEFCGxhbmRzU3RyCQC9CQIJAQV2YWx1ZQEFCGxhbmRzU3RyAgFfBQNuaWwKAQdvbmVMYW5kAgNhY2MLbGFuZEFzc2V0SWQEBWFzc2V0CQEFdmFsdWUBCQDsBwEJANkEAQULbGFuZEFzc2V0SWQECGxhbmRTaXplCQCRAwIJALUJAggFBWFzc2V0C2Rlc2NyaXB0aW9uAgFfBQtyZWNMYW5kU2l6ZQkAZAIFA2FjYwkBD251bVBpZWNlc0J5U2l6ZQEFCGxhbmRTaXplCgACJGwFBWxhbmRzCgACJHMJAJADAQUCJGwKAAUkYWNjMAAACgEFJGYwXzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQdvbmVMYW5kAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGYwXzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhVMaXN0IHNpemUgZXhjZWVkcyAxMDAJAQUkZjBfMgIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgALAAwADQAOAA8AEAARABIAEwAUABUAFgAXABgAGQAaABsAHAAdAB4AHwAgACEAIgAjACQAJQAmACcAKAApACoAKwAsAC0ALgAvADAAMQAyADMANAA1ADYANwA4ADkAOgA7ADwAPQA+AD8AQABBAEIAQwBEAEUARgBHAEgASQBKAEsATABNAE4ATwBQAFEAUgBTAFQAVQBWAFcAWABZAFoAWwBcAF0AXgBfAGAAYQBiAGMAZAkAlAoCCQDMCAIJAQxJbnRlZ2VyRW50cnkCCQEWa2V5U3Rha2VkUGllY2VzQnlPd25lcgEFB2FkZHJlc3MFDHN0YWtlZFBpZWNlcwUDbmlsBQxzdGFrZWRQaWVjZXMBaQENc2V0Q3VzdG9tTmFtZQMHYXNzZXRJZApjdXN0b21OYW1lBHR5cGUEDXByb2xvZ0FjdGlvbnMJAQZwcm9sb2cBBQFpAwkBAiE9AgkAkAMBCAUBaQhwYXltZW50cwABCQACAQIcRXhhY3RseSBvbmUgcGF5bWVudCByZXF1aXJlZAQDcG10CQEFdmFsdWUBCQCRAwIIBQFpCHBheW1lbnRzAAADCQECIT0CCAUDcG10B2Fzc2V0SWQFC3VzZHRBc3NldElkCQACAQIaQWxsb3dlZCBVU0RUIHBheW1lbnQgb25seSEDCQECIT0CCAUDcG10BmFtb3VudAUMUkVOQU1JTkdDT1NUCQACAQkArAICAhJQYXltZW50IHNob3VsZCBiZSAJAKQDAQUMUkVOQU1JTkdDT1NUAwkBCGNvbnRhaW5zAgUKY3VzdG9tTmFtZQICX18JAAIBCQCsAgICHk5hbWUgc2hvdWxkIG5vdCBjb250YWluICdfXyc6IAUKY3VzdG9tTmFtZQMJAGYCCQCxAgEFCmN1c3RvbU5hbWUFCk1BWE5BTUVMRU4JAAIBCQCsAgICGU5hbWUgdG9vIGxvbmcsIG1heExlbmd0aD0JAKQDAQUKTUFYTkFNRUxFTgQEYWRkcgkApQgBCAUBaQxvcmlnaW5DYWxsZXIEB2FjdGlvbnMEByRtYXRjaDAFBHR5cGUDCQAAAgIHQUNDT1VOVAUHJG1hdGNoMAQKcmV2ZXJzZUtleQkBFmtleUN1c3RvbU5hbWVUb0FkZHJlc3MBBQpjdXN0b21OYW1lBAluYW1lT3duZXIJAKIIAQUKcmV2ZXJzZUtleQMJAQlpc0RlZmluZWQBBQluYW1lT3duZXIJAAIBCQCsAgICGU5hbWUgYWxyZWFkeSByZWdpc3RlcmVkOiAFCmN1c3RvbU5hbWUEDWFkZHJUb05hbWVLZXkJARZrZXlBZGRyZXNzVG9DdXN0b21OYW1lAQUEYWRkcgQHb2xkTmFtZQkAoggBBQ1hZGRyVG9OYW1lS2V5BAdmcmVlT2xkAwkBCWlzRGVmaW5lZAEFB29sZE5hbWUJAMwIAgkBC0RlbGV0ZUVudHJ5AQkBFmtleUN1c3RvbU5hbWVUb0FkZHJlc3MBCQEFdmFsdWUBBQdvbGROYW1lBQNuaWwFA25pbAkAzggCCQDNCAIJAM0IAgUHZnJlZU9sZAkBC1N0cmluZ0VudHJ5AgUNYWRkclRvTmFtZUtleQUKY3VzdG9tTmFtZQkBC1N0cmluZ0VudHJ5AgUKcmV2ZXJzZUtleQUEYWRkcggJARZ1cGRhdGVBY2NTdGF0c0ludGVybmFsAgUEYWRkcgUMeHBDdXN0b21OYW1lAl8xAwkAAAICBExBTkQFByRtYXRjaDAEBWFzc2V0CQEFdmFsdWUBCQDsBwEJANkEAQUHYXNzZXRJZAQHdGltZUtleQkBFmtleVN0YWtlZFRpbWVCeUFzc2V0SWQBBQdhc3NldElkAwkBASEBCQEJaXNEZWZpbmVkAQkAnwgBBQd0aW1lS2V5CQACAQkArAICCAUFYXNzZXQEbmFtZQIOIGlzIG5vdCBzdGFrZWQEBW93bmVyCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAKIIAQkBFWtleUxhbmRBc3NldElkVG9Pd25lcgEFB2Fzc2V0SWQJAKwCAgkArAICAgRORlQgCAUFYXNzZXQEbmFtZQIMIGlzIG9ycGhhbmVkAwkBAiE9AgUFb3duZXIFBGFkZHIJAAIBCQCsAgIFCkxBTkRQUkVGSVgCDSBpcyBub3QgeW91cnMECnJldmVyc2VLZXkJARprZXlMYW5kQ3VzdG9tTmFtZVRvQXNzZXRJZAEFCmN1c3RvbU5hbWUECW5hbWVPd25lcgkAoggBBQpyZXZlcnNlS2V5AwkBCWlzRGVmaW5lZAEFCW5hbWVPd25lcgkAAgEJAKwCAgIZTmFtZSBhbHJlYWR5IHJlZ2lzdGVyZWQ6IAUKY3VzdG9tTmFtZQQOYXNzZXRUb05hbWVLZXkJARprZXlMYW5kQXNzZXRJZFRvQ3VzdG9tTmFtZQEFB2Fzc2V0SWQEB29sZE5hbWUJAKIIAQUOYXNzZXRUb05hbWVLZXkEB2ZyZWVPbGQDCQEJaXNEZWZpbmVkAQUHb2xkTmFtZQkAzAgCCQELRGVsZXRlRW50cnkBCQEaa2V5TGFuZEN1c3RvbU5hbWVUb0Fzc2V0SWQBCQEFdmFsdWUBBQdvbGROYW1lBQNuaWwFA25pbAkAzggCCQDNCAIJAM0IAgUHZnJlZU9sZAkBC1N0cmluZ0VudHJ5AgUOYXNzZXRUb05hbWVLZXkFCmN1c3RvbU5hbWUJAQtTdHJpbmdFbnRyeQIFCnJldmVyc2VLZXkFB2Fzc2V0SWQICQEWdXBkYXRlQWNjU3RhdHNJbnRlcm5hbAIFBGFkZHIFDHhwQ3VzdG9tTmFtZQJfMQMJAAACAgREVUNLBQckbWF0Y2gwBAVhc3NldAkBBXZhbHVlAQkA7AcBCQDZBAEFB2Fzc2V0SWQEB3RpbWVLZXkJARZrZXlTdGFrZWRUaW1lQnlBc3NldElkAQUHYXNzZXRJZAMDCQEBIQEJAQlpc0RlZmluZWQBCQCfCAEFB3RpbWVLZXkGCQEBIQEJAQlpc0RlZmluZWQBCQCiCAEJARRrZXlTdGFrZWREdWNrQnlPd25lcgEFBGFkZHIJAAIBCQCsAgIIBQVhc3NldARuYW1lAg4gaXMgbm90IHN0YWtlZAQFb3duZXIJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAoggBCQEQa2V5RHVja0lkVG9Pd25lcgEFB2Fzc2V0SWQJAKwCAgkArAICAgRORlQgCAUFYXNzZXQEbmFtZQIMIGlzIG9ycGhhbmVkAwkBAiE9AgUFb3duZXIFBGFkZHIJAAIBCQCsAgIFCkRVQ0tQUkVGSVgCDSBpcyBub3QgeW91cnMECnJldmVyc2VLZXkJARprZXlEdWNrQ3VzdG9tTmFtZVRvQXNzZXRJZAEFCmN1c3RvbU5hbWUECW5hbWVPd25lcgkAoggBBQpyZXZlcnNlS2V5AwkBCWlzRGVmaW5lZAEFCW5hbWVPd25lcgkAAgEJAKwCAgIZTmFtZSBhbHJlYWR5IHJlZ2lzdGVyZWQ6IAUKY3VzdG9tTmFtZQQOYXNzZXRUb05hbWVLZXkJARprZXlEdWNrQXNzZXRJZFRvQ3VzdG9tTmFtZQEFB2Fzc2V0SWQEB29sZE5hbWUJAKIIAQUOYXNzZXRUb05hbWVLZXkEB2ZyZWVPbGQDCQEJaXNEZWZpbmVkAQUHb2xkTmFtZQkAzAgCCQELRGVsZXRlRW50cnkBCQEaa2V5RHVja0N1c3RvbU5hbWVUb0Fzc2V0SWQBCQEFdmFsdWUBBQdvbGROYW1lBQNuaWwFA25pbAkAzggCCQDNCAIJAM0IAgUHZnJlZU9sZAkBC1N0cmluZ0VudHJ5AgUOYXNzZXRUb05hbWVLZXkFCmN1c3RvbU5hbWUJAQtTdHJpbmdFbnRyeQIFCnJldmVyc2VLZXkFB2Fzc2V0SWQICQEXdXBkYXRlRHVja1N0YXRzSW50ZXJuYWwCBQdhc3NldElkBQx4cEN1c3RvbU5hbWUCXzEJAAIBAhNVbmtub3duIGVudGl0eSB0eXBlCQCUCgIJAM4IAgkAzQgCBQdhY3Rpb25zCQEOU2NyaXB0VHJhbnNmZXIDBQ9lY29ub215Q29udHJhY3QIBQNwbXQGYW1vdW50BQt1c2R0QXNzZXRJZAUNcHJvbG9nQWN0aW9ucwAAAWkBDHNldFJlZmVycmFscwIJb2xkUGxheWVyCW5ld1BsYXllcgMJAQIhPQIIBQFpD2NhbGxlclB1YmxpY0tleQUDcHViCQACAQIRUGVybWlzc2lvbiBkZW5pZWQEDXByb2xvZ0FjdGlvbnMJAQZwcm9sb2cBBQFpAwkBAiE9AgkAkAMBCAUBaQhwYXltZW50cwAACQACAQIUTm8gcGF5bWVudHMgcmVxdWlyZWQDCQEBIQEJAQlpc0RlZmluZWQBCQCmCAEFCW9sZFBsYXllcgkAAgEJAKwCAgIRSW52YWxpZCBhZGRyZXNzOiAFCW9sZFBsYXllcgMJAQEhAQkBCWlzRGVmaW5lZAEJAKYIAQUJbmV3UGxheWVyCQACAQkArAICAhFJbnZhbGlkIGFkZHJlc3M6IAUJbmV3UGxheWVyBAdvbGRzS2V5CQEJa2V5T2xkaWVzAAQEb2xkcwkAoggBBQdvbGRzS2V5BAZvbGRpZXMDCQEJaXNEZWZpbmVkAQUEb2xkcwkAvAkCCQEFdmFsdWUBBQRvbGRzAgFfBQNuaWwDCQEPY29udGFpbnNFbGVtZW50AgUGb2xkaWVzBQluZXdQbGF5ZXIJAAIBCQCsAgIFCW5ld1BsYXllcgImIGlzIG5vdCBuZXdiaWUgKGFscmVhZHkgaGFzIHJlZmVycmFscykECHJlZkJ5S2V5CQEPa2V5QWRkcmVzc1JlZkJ5AQUJbmV3UGxheWVyBAVyZWZCeQkAoggBBQhyZWZCeUtleQMDCQEJaXNEZWZpbmVkAQUFcmVmQnkJAQlpc0RlZmluZWQBCQCmCAEJAQV2YWx1ZQEFBXJlZkJ5BwkAAgEJAKwCAgkArAICBQluZXdQbGF5ZXICFCBhbHJlYWR5IGhhcyByZWZCeTogCQEFdmFsdWUBBQVyZWZCeQQHcmVmc0tleQkBE2tleUFkZHJlc3NSZWZlcnJhbHMBBQlvbGRQbGF5ZXIEBHJlZnMJAKIIAQUHcmVmc0tleQQJcmVmc0FycmF5AwkBCWlzRGVmaW5lZAEFBHJlZnMJALwJAgkBBXZhbHVlAQUEcmVmcwIBXwUDbmlsAwkBD2NvbnRhaW5zRWxlbWVudAIFCXJlZnNBcnJheQUJbmV3UGxheWVyCQACAQkArAICCQCsAgIJAKwCAgUJb2xkUGxheWVyAhIgYWxyZWFkeSBjb250YWlucyAFCW5ld1BsYXllcgIRIHdpdGhpbiByZWZlcnJhbHMEB25ld1JlZnMJALoJAgkAzQgCBQlyZWZzQXJyYXkFCW5ld1BsYXllcgIBXwQHbmV3T2xkcwMJAQ9jb250YWluc0VsZW1lbnQCBQZvbGRpZXMFCW9sZFBsYXllcgkBBXZhbHVlAQUEb2xkcwkAugkCCQDNCAIFBm9sZGllcwUJb2xkUGxheWVyAgFfCQCUCgIJAM4IAgkAzAgCCQELU3RyaW5nRW50cnkCBQhyZWZCeUtleQUJb2xkUGxheWVyCQDMCAIJAQtTdHJpbmdFbnRyeQIFB3JlZnNLZXkFB25ld1JlZnMJAMwIAgkBC1N0cmluZ0VudHJ5AgUHb2xkc0tleQUHbmV3T2xkcwUDbmlsBQ1wcm9sb2dBY3Rpb25zAAABaQEQZGlzdHJpYnV0ZVBvaW50cwUIc3RyZW5ndGgIYWNjdXJhY3kJaW50ZWxsZWN0CWVuZHVyYW5jZQlkZXh0ZXJpdHkEDXByb2xvZ0FjdGlvbnMJAQZwcm9sb2cBBQFpAwkBAiE9AgkAkAMBCAUBaQhwYXltZW50cwAACQACAQIUTm8gcGF5bWVudHMgcmVxdWlyZWQEBGFkZHIJAKUIAQgFAWkMb3JpZ2luQ2FsbGVyBAt2aXJ0V2xnRGF0YQkBCWFzQW55TGlzdAEJAPwHBAULd2xnQ29udHJhY3QCEmNoZWNrV2xnWHBSRUFET05MWQkAzAgCBQRhZGRyBQNuaWwFA25pbAQNdmlydFdsZ1BvaW50cwkBBWFzSW50AQkAkQMCBQt2aXJ0V2xnRGF0YQABBA0kdDA5NjI3NDk2NjY0AwkAZwIAAAUNdmlydFdsZ1BvaW50cwkAlAoCAAAFA25pbAQHZGVsdGFYUAkBBWFzSW50AQkA/AcEBQt3bGdDb250cmFjdAIJdGFrZVdsZ1hwCQDMCAIFBGFkZHIFA25pbAUDbmlsAwkAAAIFB2RlbHRhWFAFB2RlbHRhWFAJAJQKAgUNdmlydFdsZ1BvaW50cwkAzAgCCQEMSW50ZWdlckVudHJ5AgkBDGtleVVzZXJMZXZlbAEFBGFkZHIJAQVhc0ludAEJAJEDAgULdmlydFdsZ0RhdGEAAAkAzAgCCQEMSW50ZWdlckVudHJ5AgkBCWtleVVzZXJYUAEFBGFkZHIJAQVhc0ludAEJAJEDAgULdmlydFdsZ0RhdGEAAgUDbmlsCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuBAl3bGdQb2ludHMIBQ0kdDA5NjI3NDk2NjY0Al8xBAp3bGdBY3Rpb25zCAUNJHQwOTYyNzQ5NjY2NAJfMgQLZHVja0Fzc2V0SWQJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAoggBCQEUa2V5U3Rha2VkRHVja0J5T3duZXIBBQRhZGRyAhxZb3UgZG9uJ3QgaGF2ZSBhIGR1Y2sgc3Rha2VkBApmcmVlS2V5QWNjCQERa2V5VXNlckZyZWVQb2ludHMBBQRhZGRyBA1mcmVlUG9pbnRzQWNjCQBkAgkBC3ZhbHVlT3JFbHNlAgkAnwgBBQpmcmVlS2V5QWNjAAAFCXdsZ1BvaW50cwQLZnJlZUtleUR1Y2sJARFrZXlEdWNrRnJlZVBvaW50cwEFC2R1Y2tBc3NldElkBA5mcmVlUG9pbnRzRHVjawkBC3ZhbHVlT3JFbHNlAgkAnwgBBQtmcmVlS2V5RHVjawAABAdzdW1GcmVlCQBkAgUNZnJlZVBvaW50c0FjYwUOZnJlZVBvaW50c0R1Y2sED3N1bVRvRGlzdHJpYnV0ZQkAZAIJAGQCCQBkAgkAZAIFCHN0cmVuZ3RoBQhhY2N1cmFjeQUJaW50ZWxsZWN0BQllbmR1cmFuY2UFCWRleHRlcml0eQMJAGYCBQ9zdW1Ub0Rpc3RyaWJ1dGUFB3N1bUZyZWUJAAIBCQCsAgIJAKwCAgIPVGhlcmUgYXJlIG9ubHkgCQCkAwEFB3N1bUZyZWUCGiBmcmVlIHBvaW50cyB0byBkaXN0cmlidXRlBAhjaGFyc0tleQkBDGtleUR1Y2tDaGFycwEFC2R1Y2tBc3NldElkBAVjaGFycwkAtQkCCQELdmFsdWVPckVsc2UCCQCiCAEFCGNoYXJzS2V5AgkwXzBfMF8wXzACAV8EBm5ld0FjYwkAZQIFDWZyZWVQb2ludHNBY2MFD3N1bVRvRGlzdHJpYnV0ZQkAlAoCCQDOCAIJAM4IAgkAzAgCCQEMSW50ZWdlckVudHJ5AgUKZnJlZUtleUFjYwMJAGYCAAAFBm5ld0FjYwAABQZuZXdBY2MJAMwIAgkBDEludGVnZXJFbnRyeQIFC2ZyZWVLZXlEdWNrAwkAZgIAAAUGbmV3QWNjCQBkAgUOZnJlZVBvaW50c0R1Y2sFBm5ld0FjYwUOZnJlZVBvaW50c0R1Y2sJAMwIAgkBC1N0cmluZ0VudHJ5AgUIY2hhcnNLZXkJALkJAgkAzAgCCQCkAwEJAGQCCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUFY2hhcnMFDGNoYXJTdHJlbmd0aAUIc3RyZW5ndGgJAMwIAgkApAMBCQBkAgkBDXBhcnNlSW50VmFsdWUBCQCRAwIFBWNoYXJzBQxjaGFyQWNjdXJhY3kFCGFjY3VyYWN5CQDMCAIJAKQDAQkAZAIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQVjaGFycwUNY2hhckludGVsbGVjdAUJaW50ZWxsZWN0CQDMCAIJAKQDAQkAZAIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQVjaGFycwUNY2hhckVuZHVyYW5jZQUJZW5kdXJhbmNlCQDMCAIJAKQDAQkAZAIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQVjaGFycwUNY2hhckRleHRlcml0eQUJZGV4dGVyaXR5BQNuaWwCAV8FA25pbAUNcHJvbG9nQWN0aW9ucwUKd2xnQWN0aW9ucwAAAWkBHHNwbGl0QnlHbG9iYWxXZWlnaHRzUkVBRE9OTFkBBmFtb3VudAkAlAoCBQNuaWwJARJnZXROZWVkZWRNYXRlcmlhbHMBBQZhbW91bnQBaQEkc3BsaXRCeUdsb2JhbEFuZExvY2FsV2VpZ2h0c1JFQURPTkxZAwltYXRBbW91bnQJcmVzQW1vdW50CHRlcnJhaW5zBA10ZXJyYWluQ291bnRzCQENY291bnRUZXJyYWlucwEFCHRlcnJhaW5zCQCUCgIFA25pbAkAlAoCCQESZ2V0TmVlZGVkTWF0ZXJpYWxzAQUJbWF0QW1vdW50CQETZGlzdHJpYnV0ZUJ5V2VpZ2h0cwIFCXJlc0Ftb3VudAUNdGVycmFpbkNvdW50cwFpARNnZXRCYWNrcGFja1JFQURPTkxZAQtkdWNrQXNzZXRJZAkAlAoCBQNuaWwJALkJAgkBC2dldEJhY2twYWNrAQkBEWtleUJhY2twYWNrQnlEdWNrAQULZHVja0Fzc2V0SWQCAToBaQEUZ2V0V2FyZWhvdXNlUkVBRE9OTFkBC2xhbmRBc3NldElkBAVhc3NldAkBBXZhbHVlAQkA7AcBCQDZBAEFC2xhbmRBc3NldElkBAlsYW5kSW5kZXgJAGkCCQEPbnVtUGllY2VzQnlTaXplAQkAkQMCCQC1CQIIBQVhc3NldAtkZXNjcmlwdGlvbgIBXwULcmVjTGFuZFNpemUFBVNTSVpFBAppbmZyYUxldmVsCQELdmFsdWVPckVsc2UCCQCfCAEJARZrZXlJbmZyYUxldmVsQnlBc3NldElkAQULbGFuZEFzc2V0SWQAAAkAlAoCBQNuaWwJALoJAgkBDGdldFdhcmVob3VzZQMJARJrZXlXYXJlaG91c2VCeUxhbmQBBQtsYW5kQXNzZXRJZAUJbGFuZEluZGV4BQppbmZyYUxldmVsAgE6AWkBCnNhdmVMYXN0VHgAAwkBASEBCQEPY29udGFpbnNFbGVtZW50AgkAzAgCBQt3bGdDb250cmFjdAkAzAgCBQ9lY29ub215Q29udHJhY3QJAMwIAgUSdG91cm5hbWVudENvbnRyYWN0CQDMCAIFDWFjcmVzQ29udHJhY3QFA25pbAgFAWkGY2FsbGVyCQACAQINQWNjZXNzIGRlbmllZAkAlAoCCQEGcHJvbG9nAQUBaQAqAWkBD3VwZGF0ZUR1Y2tTdGF0cwILZHVja0Fzc2V0SWQHZGVsdGFYUAMJAQIhPQIIBQFpBmNhbGxlcgUPZWNvbm9teUNvbnRyYWN0CQACAQINQWNjZXNzIGRlbmllZAkBF3VwZGF0ZUR1Y2tTdGF0c0ludGVybmFsAgULZHVja0Fzc2V0SWQFB2RlbHRhWFABaQEOdXBkYXRlQWNjU3RhdHMCBGFkZHIHZGVsdGFYUAMJAQEhAQkBD2NvbnRhaW5zRWxlbWVudAIJAMwIAgULd2xnQ29udHJhY3QJAMwIAgUPZWNvbm9teUNvbnRyYWN0CQDMCAIFDWFjcmVzQ29udHJhY3QFA25pbAgFAWkGY2FsbGVyCQACAQINQWNjZXNzIGRlbmllZAkBFnVwZGF0ZUFjY1N0YXRzSW50ZXJuYWwCBQRhZGRyBQdkZWx0YVhQAWkBCWVxdWlwRHVjawEJZXF1aXBtZW50BA1wcm9sb2dBY3Rpb25zCQEGcHJvbG9nAQUBaQMJAQIhPQIJAJADAQgFAWkIcGF5bWVudHMAAAkAAgECFE5vIHBheW1lbnRzIHJlcXVpcmVkBARhZGRyCQClCAEIBQFpDG9yaWdpbkNhbGxlcgQLZHVja0Fzc2V0SWQJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAoggBCQEUa2V5U3Rha2VkRHVja0J5T3duZXIBBQRhZGRyAhxZb3UgZG9uJ3QgaGF2ZSBhIGR1Y2sgc3Rha2VkAwkBD2NoZWNrVG91cm5hbWVudAEFC2R1Y2tBc3NldElkCQACAQIZZXF1aXBEdWNrX2NoZWNrVG91cm5hbWVudAMJAQ1jaGVja0RlbGl2ZXJ5AQULZHVja0Fzc2V0SWQJAAIBAhdlcXVpcER1Y2tfY2hlY2tEZWxpdmVyeQQFZXFLZXkJARBrZXlEdWNrRXF1aXBtZW50AQULZHVja0Fzc2V0SWQEC2N1cnJlbnRTZWdzCQC1CQIJAQt2YWx1ZU9yRWxzZQIJAKIIAQUFZXFLZXkCFyw7LF8sOyxfLDssXyw7LF8sOyxfLDssAgFfBAVicEtleQkBEWtleUJhY2twYWNrQnlEdWNrAQULZHVja0Fzc2V0SWQEC2N1cnJlbnRQYWNrCQELZ2V0QmFja3BhY2sBBQVicEtleQQFbmV3RXEJALUJAgUJZXF1aXBtZW50AgFfAwkBAiE9AgkAkAMBBQVuZXdFcQULTlVNU0VHTUVOVFMJAAIBAhZXcm9uZyBlcXVpcG1lbnQgc3RyaW5nBAl0ZW1wUHJvZEIJAQZkcmVzc0IEBQtjdXJyZW50U2VncwkBDnByb2RTdHJUb0J5dGVzAQkAkQMCBQtjdXJyZW50UGFjawUJYnBJZHhQcm9kBgUDbmlsBAhzZWdCcEF1eAkAkQMCCQC1CQIJAJEDAgUFbmV3RXEFC3NlZ0JhY2twYWNrAgE7AAEECmJ1ZmZFZmZlY3QDCQAAAgUIc2VnQnBBdXgCAAAABARhdXgwCQCRAwIJALUJAgUIc2VnQnBBdXgCASwAAAMJAAACBQRhdXgwAgAAAAQGaWR4Q250CQC1CQIFBGF1eDACAToEA2lkeAkAkQMCBQZpZHhDbnQAAAQDY250CQCRAwIFBmlkeENudAABAwMDAwMJAAACBQNpZHgCAjA2BgkAAAIFA2lkeAICMDcGCQAAAgUDaWR4AgIwOAkBAiE9AgUDY250AgAHCQBmAgkBDXBhcnNlSW50VmFsdWUBBQNjbnQAAAcJAQ1wYXJzZUludFZhbHVlAQkAkQMCCQC1CQIJAJEDAgUQcHJvZHVjdGlvbk1hdHJpeAkBDXBhcnNlSW50VmFsdWUBBQNpZHgCAV8FCnJJZHhFZmZlY3QAAAQFc3RhdHMJAQxnZXREdWNrU3RhdHMEBQR0aGlzBQtkdWNrQXNzZXRJZAUKYnVmZkVmZmVjdAYECG5ld1Byb2RCCQEGZHJlc3NCBAUFbmV3RXEFCXRlbXBQcm9kQgcFBXN0YXRzBApuZXdQcm9kU3RyCQEOYnl0ZXNUb1Byb2RTdHIBBQhuZXdQcm9kQgkAlAoCCQDOCAIJAMwIAgkBC1N0cmluZ0VudHJ5AgUFZXFLZXkFCWVxdWlwbWVudAkAzAgCCQELU3RyaW5nRW50cnkCBQVicEtleQkAugkCCQDMCAIJAJEDAgULY3VycmVudFBhY2sFCmJwSWR4TGV2ZWwJAMwIAgkAkQMCBQtjdXJyZW50UGFjawUIYnBJZHhSZXMJAMwIAgkAkQMCBQtjdXJyZW50UGFjawUIYnBJZHhNYXQJAMwIAgUKbmV3UHJvZFN0cgUDbmlsAgE6CQDMCAIJAQtTdHJpbmdFbnRyeQIJAQxrZXlEdWNrQnVmZnMBBQtkdWNrQXNzZXRJZAkAuQkCCQDMCAIJAKQDAQkAkQMCBQVzdGF0cwAHCQDMCAIJAKQDAQkAkQMCBQVzdGF0cwAICQDMCAIJAKQDAQkAkQMCBQVzdGF0cwAJCQDMCAIJAKQDAQkAkQMCBQVzdGF0cwAKCQDMCAIJAKQDAQkAkQMCBQVzdGF0cwALBQNuaWwCAV8FA25pbAUNcHJvbG9nQWN0aW9ucwAAAWkBD2ZvcnRpZmljYXRlTGFuZAILbGFuZEFzc2V0SWQEcGxhbgQNcHJvbG9nQWN0aW9ucwkBBnByb2xvZwEFAWkDCQECIT0CCQCQAwEIBQFpCHBheW1lbnRzAAAJAAIBAhRObyBwYXltZW50cyByZXF1aXJlZAQEYWRkcgkApQgBCAUBaQxvcmlnaW5DYWxsZXIEC2R1Y2tBc3NldElkCQELdmFsdWVPckVsc2UCCQCiCAEJARRrZXlTdGFrZWREdWNrQnlPd25lcgEFBGFkZHICAAQJZHVja1N0YXRzCQEMZ2V0RHVja1N0YXRzBAUEdGhpcwULZHVja0Fzc2V0SWQAAAcEB2ZvcnRLZXkJARdrZXlGb3J0aWZpY2F0aW9uc0J5TGFuZAEFC2xhbmRBc3NldElkBAxjdXJyZW50Rm9ydHMJALUJAgkBC3ZhbHVlT3JFbHNlAgkAoggBBQdmb3J0S2V5Agw6MF8xNTowXzE4OjACAV8EBWFzc2V0CQEFdmFsdWUBCQDsBwEJANkEAQULbGFuZEFzc2V0SWQECWxhbmRJbmRleAkAaQIJAQ9udW1QaWVjZXNCeVNpemUBCQCRAwIJALUJAggFBWFzc2V0C2Rlc2NyaXB0aW9uAgFfBQtyZWNMYW5kU2l6ZQUFU1NJWkUECmluZnJhTGV2ZWwJAQt2YWx1ZU9yRWxzZQIJAJ8IAQkBFmtleUluZnJhTGV2ZWxCeUFzc2V0SWQBBQtsYW5kQXNzZXRJZAAABAV3aEtleQkBEmtleVdhcmVob3VzZUJ5TGFuZAEFC2xhbmRBc3NldElkBAJ3aAkBDGdldFdhcmVob3VzZQMFBXdoS2V5BQlsYW5kSW5kZXgFCmluZnJhTGV2ZWwEB2N1ckxvZnQJALUJAgkAkQMCBQJ3aAUJd2hJZHhMT0ZUAgFfBARjdXJPCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUHY3VyTG9mdAULdm9sT2NjdXBpZWQEBGN1ckYJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQdjdXJMb2Z0BQd2b2xGcmVlBAhuZXdGb3J0cwkAtQkCBQRwbGFuAgFfBA8kdDAxMDM1MDIxMDM2MTcJAQVmb3J0QgYFDGN1cnJlbnRGb3J0cwkBDnByb2RTdHJUb0J5dGVzAQkAkQMCBQJ3aAUJd2hJZHhQcm9kBQRjdXJPBQRjdXJGBgUDbmlsBAl0ZW1wUHJvZEIIBQ8kdDAxMDM1MDIxMDM2MTcCXzEEBXRlbXBPCAUPJHQwMTAzNTAyMTAzNjE3Al8yBAV0ZW1wRggFDyR0MDEwMzUwMjEwMzYxNwJfMwQPJHQwMTAzNjIwMTAzNzE2CQEFZm9ydEIGBQhuZXdGb3J0cwUJdGVtcFByb2RCBQV0ZW1wTwUFdGVtcEYHBQlkdWNrU3RhdHMECG5ld1Byb2RCCAUPJHQwMTAzNjIwMTAzNzE2Al8xBARuZXdPCAUPJHQwMTAzNjIwMTAzNzE2Al8yBARuZXdGCAUPJHQwMTAzNjIwMTAzNzE2Al8zBApuZXdQcm9kU3RyCQEOYnl0ZXNUb1Byb2RTdHIBBQhuZXdQcm9kQgQKbmV3TG9mdFN0cgkAuQkCCQDMCAIJAJEDAgUHY3VyTG9mdAUJdm9sTG9ja2VkCQDMCAIJAKQDAQUEbmV3TwkAzAgCCQCkAwEFBG5ld0YJAMwIAgkAkQMCBQdjdXJMb2Z0BQh2b2xUb3RhbAUDbmlsAgFfCQCUCgIJAM4IAgkAzAgCCQELU3RyaW5nRW50cnkCBQdmb3J0S2V5BQRwbGFuCQDMCAIJAQtTdHJpbmdFbnRyeQIFBXdoS2V5CQC6CQIJAMwIAgkAkQMCBQJ3aAULd2hJZHhMZXZlbHMJAMwIAgkAkQMCBQJ3aAUId2hJZHhSZXMJAMwIAgkAkQMCBQJ3aAUId2hJZHhNYXQJAMwIAgUKbmV3UHJvZFN0cgkAzAgCBQpuZXdMb2Z0U3RyBQNuaWwCAToFA25pbAUNcHJvbG9nQWN0aW9ucwAAAWkBE2luaXREdWNrVG91ckF0dGVtcHQBC2R1Y2tBc3NldElkAwkBAiE9AggFAWkGY2FsbGVyBRJ0b3VybmFtZW50Q29udHJhY3QJAAIBAg1BY2Nlc3MgZGVuaWVkBAlrZXlIZWFsdGgJAQ1rZXlEdWNrSGVhbHRoAQULZHVja0Fzc2V0SWQEBW1heEhQCQEJbWF4SGVhbHRoAQkBC3ZhbHVlT3JFbHNlAgkAnwgBCQEMa2V5RHVja0xldmVsAQULZHVja0Fzc2V0SWQAAAQJY3VySGVhbHRoCQELdmFsdWVPckVsc2UCCQCfCAEFCWtleUhlYWx0aAUFbWF4SFAECWN1ckxvY0tleQkBD2tleUR1Y2tMb2NhdGlvbgEFC2R1Y2tBc3NldElkBAtjdXJMb2NhdGlvbgkBC3ZhbHVlT3JFbHNlAgkAoggBBQljdXJMb2NLZXkFD0RFRkFVTFRMT0NBVElPTgQGbGFzdElkCQELdmFsdWVPckVsc2UCCQCaCAIFEnRvdXJuYW1lbnRDb250cmFjdAUNbGFzdFRvdXJJZEtleQAABAx0b3VyTG9jYXRpb24JAKwCAgkApAMBBQZsYXN0SWQCBF9UXzAJAJQKAgkAzAgCCQEMSW50ZWdlckVudHJ5AgkBDmtleVNhdmVkSGVhbHRoAQULZHVja0Fzc2V0SWQFCWN1ckhlYWx0aAkAzAgCCQEMSW50ZWdlckVudHJ5AgUJa2V5SGVhbHRoBQVtYXhIUAkAzAgCCQELU3RyaW5nRW50cnkCCQEQa2V5U2F2ZWRMb2NhdGlvbgEFC2R1Y2tBc3NldElkBQtjdXJMb2NhdGlvbgkAzAgCCQELU3RyaW5nRW50cnkCBQljdXJMb2NLZXkFDHRvdXJMb2NhdGlvbgUDbmlsBQx0b3VyTG9jYXRpb24BaQEMYnJlYWtBdHRlbXB0AAQNcHJvbG9nQWN0aW9ucwkBBnByb2xvZwEFAWkEC2R1Y2tBc3NldElkCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAKIIAQkBFGtleVN0YWtlZER1Y2tCeU93bmVyAQkApQgBCAUBaQZjYWxsZXICHFlvdSBkb24ndCBoYXZlIGEgZHVjayBzdGFrZWQECWN1ckxvY0tleQkBD2tleUR1Y2tMb2NhdGlvbgEFC2R1Y2tBc3NldElkBAtjdXJMb2NhdGlvbgkBC3ZhbHVlT3JFbHNlAgkAoggBBQljdXJMb2NLZXkFD0RFRkFVTFRMT0NBVElPTgMJAQIhPQIJAJEDAgkAtQkCBQtjdXJMb2NhdGlvbgIBXwUKbG9jSWR4VHlwZQIBVAkAAgECIllvdXIgZHVjayBpcyBub3QgaW4gdGhlIHRvdXJuYW1lbnQEC3NhdmVkSGVhbHRoCQERQGV4dHJOYXRpdmUoMTA1NSkBCQEOa2V5U2F2ZWRIZWFsdGgBBQtkdWNrQXNzZXRJZAQNc2F2ZWRMb2NhdGlvbgkBEUBleHRyTmF0aXZlKDEwNTgpAQkBEGtleVNhdmVkTG9jYXRpb24BBQtkdWNrQXNzZXRJZAkAlAoCCQDNCAIJAM0IAgUNcHJvbG9nQWN0aW9ucwkBDEludGVnZXJFbnRyeQIJAQ1rZXlEdWNrSGVhbHRoAQULZHVja0Fzc2V0SWQFC3NhdmVkSGVhbHRoCQELU3RyaW5nRW50cnkCBQljdXJMb2NLZXkFDXNhdmVkTG9jYXRpb24FC2N1ckxvY2F0aW9uAWkBFmV4aXRUb3VybmFtZW50SW50ZXJuYWwBC2R1Y2tBc3NldElkAwkBAiE9AggFAWkGY2FsbGVyBQR0aGlzCQACAQINQWNjZXNzIGRlbmllZAQLc2F2ZWRIZWFsdGgJARFAZXh0ck5hdGl2ZSgxMDU1KQEJAQ5rZXlTYXZlZEhlYWx0aAEFC2R1Y2tBc3NldElkBA1zYXZlZExvY2F0aW9uCQERQGV4dHJOYXRpdmUoMTA1OCkBCQEQa2V5U2F2ZWRMb2NhdGlvbgEFC2R1Y2tBc3NldElkCQCUCgIJAMwIAgkBDEludGVnZXJFbnRyeQIJAQ1rZXlEdWNrSGVhbHRoAQULZHVja0Fzc2V0SWQFC3NhdmVkSGVhbHRoCQDMCAIJAQtTdHJpbmdFbnRyeQIJAQ9rZXlEdWNrTG9jYXRpb24BBQtkdWNrQXNzZXRJZAUNc2F2ZWRMb2NhdGlvbgUDbmlsBwFpARRleGl0RGVsaXZlcnlJbnRlcm5hbAELZHVja0Fzc2V0SWQDCQECIT0CCAUBaQZjYWxsZXIFBHRoaXMJAAIBAg1BY2Nlc3MgZGVuaWVkBAFlCQESZXhpdERlbGl2ZXJ5Q29tbW9uAQULZHVja0Fzc2V0SWQJAJQKAgkAzggCCAUBZQJfMQgFAWUCXzIHAWkBEGF1dG9FeGl0RGVsaXZlcnkBC2R1Y2tBc3NldElkAwkBAiE9AggFAWkGY2FsbGVyBQR0aGlzCQACAQINQWNjZXNzIGRlbmllZAQBZQkBEmV4aXREZWxpdmVyeUNvbW1vbgEFC2R1Y2tBc3NldElkCQCUCgIIBQFlAl8xCQCUCgIIBQFlAl8zCAUBZQJfNAFpAQ5wcmVwYXJlUm9iYmVyeQIHbWVzc2FnZQNzaWcEDXByb2xvZ0FjdGlvbnMJAQZwcm9sb2cBBQFpAwkBASEBCQDEEwMFB21lc3NhZ2UFA3NpZwUDcHViCQACAQIYc2lnbmF0dXJlIGRvZXMgbm90IG1hdGNoAwkBAiE9AgkAkAMBCAUBaQhwYXltZW50cwABCQACAQIiZXhhY3RseSAxIHBheW1lbnQgbXVzdCBiZSBhdHRhY2hlZAQDcG10CQCRAwIIBQFpCHBheW1lbnRzAAAEBndsZ0FtdAgFA3BtdAZhbW91bnQDAwkBASEBCQEJaXNEZWZpbmVkAQgFA3BtdAdhc3NldElkBgkBAiE9AgkBBXZhbHVlAQgFA3BtdAdhc3NldElkBQp3bGdBc3NldElkCQACAQIVV0xHT0xEIHBheW1lbnRzIG9ubHkhBAVwYXJ0cwkAtQkCCQCwCQEFB21lc3NhZ2UCAXwDCQECIT0CCQCQAwEFBXBhcnRzAAIJAAIBAhRXcm9uZyBtZXNzYWdlIGZvcm1hdAQLZHVja0Fzc2V0SWQJAJEDAgUFcGFydHMAAAMJAQ9jaGVja1RvdXJuYW1lbnQBBQtkdWNrQXNzZXRJZAkAAgECHnByZXBhcmVSb2JiZXJ5X2NoZWNrVG91cm5hbWVudAMJAQ1jaGVja0RlbGl2ZXJ5AQULZHVja0Fzc2V0SWQJAAIBAhxwcmVwYXJlUm9iYmVyeV9jaGVja0RlbGl2ZXJ5BAdyb2JDb3N0CAkBDmdldFJvYmJlcnlEYXRhAgUEdGhpcwULZHVja0Fzc2V0SWQCXzEDCQBmAgUHcm9iQ29zdAUGd2xnQW10CQACAQkArAICCQCsAgIJAKwCAgIIUGF5bWVudCAJAKQDAQUGd2xnQW10AgwgPCByZXF1aXJlZCAJAKQDAQUHcm9iQ29zdAQKY2FuZGlkYXRlcwkAtQkCCQCRAwIFBXBhcnRzAAECAV8EA25vdwgFCWxhc3RCbG9jawl0aW1lc3RhbXAECWR1Y2tTdGF0ZQkBC3ZhbHVlT3JFbHNlAgkAnwgBCQETa2V5RHVja1JvYmJlcnlTdGF0ZQEFC2R1Y2tBc3NldElkAAAECmxvY2tlZExhbmQJAQt2YWx1ZU9yRWxzZQIJAKIIAQkBE2tleUxvY2tlZExhbmRCeUR1Y2sBBQtkdWNrQXNzZXRJZAIABAdsYW5kRVRBCQELdmFsdWVPckVsc2UCCQCfCAEJARJrZXlMYW5kQ29vbGRvd25FVEEBBQpsb2NrZWRMYW5kAAADAwkBAiE9AgUJZHVja1N0YXRlBQtkdWNrSWR4RnJlZQkAZgIFB2xhbmRFVEEFA25vdwcJAAIBCQCsAgICJ1lvdSBhbHJlYWR5IHN0YXJ0ZWQgcm9iYmluZywgd2FpdCB0aWxsIAkApAMBBQdsYW5kRVRBCgEHY2hlY2tlcgIDYWNjC2xhbmRBc3NldElkBAVzdGF0ZQkBC3ZhbHVlT3JFbHNlAgkAnwgBCQETa2V5TGFuZFJvYmJlcnlTdGF0ZQEFC2xhbmRBc3NldElkAAAEC2Nvb2xkb3duRVRBCQELdmFsdWVPckVsc2UCCQCfCAEJARJrZXlMYW5kQ29vbGRvd25FVEEBBQtsYW5kQXNzZXRJZAAAAwkAZgIFBXN0YXRlCQCQAwEFEGxhbmRSb2JDb29sZG93bnMJAAIBAg1JbnZhbGlkIHN0YXRlAwkAZgIFA25vdwULY29vbGRvd25FVEEECnN0YWtlZFRpbWUJAQt2YWx1ZU9yRWxzZQIJAJ8IAQkBFmtleVN0YWtlZFRpbWVCeUFzc2V0SWQBBQtsYW5kQXNzZXRJZAAAAwkAZwIAAAUKc3Rha2VkVGltZQUDYWNjBAFhCQEFdmFsdWUBCQDsBwEJANkEAQULbGFuZEFzc2V0SWQEAWQJALUJAggFAWELZGVzY3JpcHRpb24CAV8EBnBpZWNlcwkBD251bVBpZWNlc0J5U2l6ZQEJAJEDAgUBZAULcmVjTGFuZFNpemUEDHByb2R1Y3Rpdml0eQkBDGFwcGx5Qm9udXNlcwIFC2xhbmRBc3NldElkBQZwaWVjZXMECWRlbHRhVGltZQkAZQIFA25vdwUKc3Rha2VkVGltZQQIYXZhaWxSZXMJAGsDBQlkZWx0YVRpbWUJAGgCBQxwcm9kdWN0aXZpdHkFBnBpZWNlcwUJREFZTUlMTElTAwkAZgIFDk1JTl9SRVNfVE9fUk9CBQhhdmFpbFJlcwUDYWNjCQDNCAIFA2FjYwULbGFuZEFzc2V0SWQFA2FjYwQIZmlsdGVyZWQKAAIkbAUKY2FuZGlkYXRlcwoAAiRzCQCQAwEFAiRsCgAFJGFjYzAFA25pbAoBBSRmMF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEHY2hlY2tlcgIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQUkZjBfMgIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgMJAAACCQCQAwEFCGZpbHRlcmVkAAAJAAIBAhlObyBjYW5kaWRhdGVzIGZvciByb2JiZXJ5BAZybmRJZHgJAQ9nZXRSYW5kb21OdW1iZXIDCQCQAwEFCGZpbHRlcmVkBQZoZWlnaHQJAMsBAgUDc2lnCAUBaQ10cmFuc2FjdGlvbklkBAtsYW5kQXNzZXRJZAkAkQMCBQhmaWx0ZXJlZAUGcm5kSWR4CQCUCgIJAM4IAgkAzAgCCQEMSW50ZWdlckVudHJ5AgkBE2tleUxhbmRSb2JiZXJ5U3RhdGUBBQtsYW5kQXNzZXRJZAUMcm9iSWR4TG9ja2VkCQDMCAIJAQxJbnRlZ2VyRW50cnkCCQESa2V5TGFuZENvb2xkb3duRVRBAQULbGFuZEFzc2V0SWQJAGQCBQNub3cJAJEDAgUQbGFuZFJvYkNvb2xkb3ducwUMcm9iSWR4TG9ja2VkCQDMCAIJAQxJbnRlZ2VyRW50cnkCCQETa2V5RHVja1JvYmJlcnlTdGF0ZQEFC2R1Y2tBc3NldElkBRBkdWNrSWR4UHJlcGFyaW5nCQDMCAIJAQtTdHJpbmdFbnRyeQIJARNrZXlMb2NrZWRMYW5kQnlEdWNrAQULZHVja0Fzc2V0SWQFC2xhbmRBc3NldElkBQNuaWwFDXByb2xvZ0FjdGlvbnMFC2xhbmRBc3NldElkAWkBB3JvYkxhbmQCB21lc3NhZ2UDc2lnBA1wcm9sb2dBY3Rpb25zCQEGcHJvbG9nAQUBaQMJAQEhAQkAxBMDBQdtZXNzYWdlBQNzaWcFA3B1YgkAAgECGHNpZ25hdHVyZSBkb2VzIG5vdCBtYXRjaAQIdXNlckFkZHIJAKUIAQgFAWkGY2FsbGVyBAtkdWNrQXNzZXRJZAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCiCAEJARRrZXlTdGFrZWREdWNrQnlPd25lcgEFCHVzZXJBZGRyAhxZb3UgZG9uJ3QgaGF2ZSBhIGR1Y2sgc3Rha2VkBANub3cIBQlsYXN0QmxvY2sJdGltZXN0YW1wCQCUCgIJAM0IAgUNcHJvbG9nQWN0aW9ucwkBDEludGVnZXJFbnRyeQIJARhrZXlMYXN0Um9iYmVyeVRpbWVCeUR1Y2sBBQtkdWNrQXNzZXRJZAUDbm93AAABaQEOYWNjZXB0RGVsaXZlcnkAAwkBASEBBRFLU19BTExPV19ERUxJVkVSWQkAAgECH0RlbGl2ZXJ5IGZlYXR1cmUgaXMgdHVybmVkIG9mZiEEDXByb2xvZ0FjdGlvbnMJAQZwcm9sb2cBBQFpBAh1c2VyQWRkcgkApQgBCAUBaQZjYWxsZXIEC2R1Y2tBc3NldElkCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAKIIAQkBFGtleVN0YWtlZER1Y2tCeU93bmVyAQUIdXNlckFkZHICHFlvdSBkb24ndCBoYXZlIGEgZHVjayBzdGFrZWQECWZ1bmRUb3RhbAkBC3ZhbHVlT3JFbHNlAgkAmggCBQ9lY29ub215Q29udHJhY3QFD2RlbGl2ZXJ5RnVuZEtleQAABAtsb2NrZWRUb3RhbAkBC3ZhbHVlT3JFbHNlAgkAmggCBQ9lY29ub215Q29udHJhY3QFEWRlbGl2ZXJ5TG9ja2VkS2V5AAADCQBmAgUVTUlOX1VTRFRfRkVFX0RFTElWRVJZCQBlAgUJZnVuZFRvdGFsBQtsb2NrZWRUb3RhbAkAAgEJAKwCAgkArAICCQCsAgICIERlbGl2ZXJ5IGlzIG5vdCBhdmFpbGFibGUsIGZ1bmQ9CQEKZml4ZWRQb2ludAIFCWZ1bmRUb3RhbAAGAgksIGxvY2tlZD0JAQpmaXhlZFBvaW50AgULbG9ja2VkVG90YWwABgQDbm93CAUJbGFzdEJsb2NrCXRpbWVzdGFtcAQIZGVsYXlFVEEJAQt2YWx1ZU9yRWxzZQIJAJ8IAQkBFmtleURlbGl2ZXJ5RGVsYXlCeUR1Y2sBBQtkdWNrQXNzZXRJZAAAAwkAZgIFCGRlbGF5RVRBBQNub3cJAAIBCQCsAgICKkRlbGl2ZXJ5IGlzIGZvcmJpZGRlbiBmb3IgeW91ciBkdWNrIHVudGlsIAkApAMBBQhkZWxheUVUQQMJAQ9jaGVja1RvdXJuYW1lbnQBBQtkdWNrQXNzZXRJZAkAAgECHmFjY2VwdERlbGl2ZXJ5X2NoZWNrVG91cm5hbWVudAMJAQ1jaGVja0RlbGl2ZXJ5AQULZHVja0Fzc2V0SWQJAAIBAhxhY2NlcHREZWxpdmVyeV9jaGVja0RlbGl2ZXJ5BA5uZXdMb2NrZWRUb3RhbAkBBWFzSW50AQkA/AcEBQ9lY29ub215Q29udHJhY3QCFHVwZGF0ZURlbGl2ZXJ5TG9ja2VkCQDMCAIJAGQCBQtsb2NrZWRUb3RhbAUVTUlOX1VTRFRfRkVFX0RFTElWRVJZBQNuaWwFA25pbAQJa2V5SGVhbHRoCQENa2V5RHVja0hlYWx0aAEFC2R1Y2tBc3NldElkBAVtYXhIUAkBCW1heEhlYWx0aAEJAQt2YWx1ZU9yRWxzZQIJAJ8IAQkBDGtleUR1Y2tMZXZlbAEFC2R1Y2tBc3NldElkAAAECWN1ckhlYWx0aAkBC3ZhbHVlT3JFbHNlAgkAnwgBBQlrZXlIZWFsdGgFBW1heEhQBAljdXJMb2NLZXkJAQ9rZXlEdWNrTG9jYXRpb24BBQtkdWNrQXNzZXRJZAQLY3VyTG9jYXRpb24JAQt2YWx1ZU9yRWxzZQIJAKIIAQUJY3VyTG9jS2V5BQ9ERUZBVUxUTE9DQVRJT04EEGRlbGl2ZXJ5TG9jYXRpb24JAKwCAgkApAMBBQNub3cCBF9EXzAJAJQKAgkAzggCCQDMCAIJAQxJbnRlZ2VyRW50cnkCCQEOa2V5U2F2ZWRIZWFsdGgBBQtkdWNrQXNzZXRJZAUJY3VySGVhbHRoCQDMCAIJAQxJbnRlZ2VyRW50cnkCBQlrZXlIZWFsdGgFBW1heEhQCQDMCAIJAQtTdHJpbmdFbnRyeQIJARBrZXlTYXZlZExvY2F0aW9uAQULZHVja0Fzc2V0SWQFC2N1ckxvY2F0aW9uCQDMCAIJAQtTdHJpbmdFbnRyeQIFCWN1ckxvY0tleQUQZGVsaXZlcnlMb2NhdGlvbgUDbmlsBQ1wcm9sb2dBY3Rpb25zCQCUCgIFEGRlbGl2ZXJ5TG9jYXRpb24FDm5ld0xvY2tlZFRvdGFsAFUngqA=",
    "height": 2791266,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 2X3Etifu3P4bLPxK2bKFWqLs1UbDvqyrJGaApqAa1sZU
Next: Dj5wY6S2UuhUK6rrW5AcXiVJHWY368zjfYbhsuQP1VZd

Diff: 
Old
New
Differences
374
374
 
    let ca = cg[bU]
375
375
 
    let cb = cg[bV]
376
376
 
    let cl = cf[bm]
377
-
    if (if ((cl != "T"))
378
-
        then (cl != "D")
379
-
        else false)
377
+
    if ((cl == "D"))
380
378
 
        then true
381
-
        else !(if (if (if ((cf[bm] == "T"))
379
+
        else if (if (if ((cf[bm] == "T"))
382
380
 
            then (parseIntValue(cf[bl]) == ce)
383
381
 
            else false)
384
382
 
            then (cb[bX] == "INPROGRESS")
385
383
 
            else false)
386
384
 
            then (parseIntValue(ca[bW]) > ax)
387
-
            else false)
385
+
            else false
388
386
 
    }
389
387
 
390
388
 
2497
2495
 
                    let lA = fk(lz, hp._5)
2498
2496
 
                    let lB = lA._1
2499
2497
 
                    let lC = lA._2
2500
-
                    let lD = if (cm(df, jq))
2498
+
                    let lD = if (!(cm(df, jq)))
2501
2499
 
                        then if (!(ck(iX)))
2502
2500
 
                            then cp(jq, iX, 5)
2503
2501
 
                            else if ((iV > 0))
Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 6 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
let a = 86400000
5
5
 
6
6
 
func b (c) = ("lastArbTimeUser_" + c)
7
7
 
8
8
 
9
9
 
let d = 100000000
10
10
 
11
11
 
let e = 3200
12
12
 
13
13
 
let f = 4000
14
14
 
15
15
 
let g = 3
16
16
 
17
17
 
let h = 100000000
18
18
 
19
19
 
let i = 400
20
20
 
21
21
 
let j = ["Strength", "Accuracy", "Intellect", "Endurance", "Dexterity", "Level", "Health"]
22
22
 
23
23
 
let k = 0
24
24
 
25
25
 
let l = 1
26
26
 
27
27
 
let m = 2
28
28
 
29
29
 
let n = 3
30
30
 
31
31
 
let o = 4
32
32
 
33
33
 
let p = 0
34
34
 
35
35
 
let q = 6
36
36
 
37
37
 
let r = 2
38
38
 
39
39
 
let s = 2
40
40
 
41
41
 
let t = 30
42
42
 
43
43
 
let u = [0, 600000, 900000, 43200000, 21600000]
44
44
 
45
45
 
let v = 20000000
46
46
 
47
47
 
let w = 1
48
48
 
49
49
 
let x = 0
50
50
 
51
51
 
let y = 1
52
52
 
53
53
 
func z (A) = ("duckHealth_" + A)
54
54
 
55
55
 
56
56
 
func B (A) = ("duckChars_" + A)
57
57
 
58
58
 
59
59
 
func C (A) = ("duckXP_" + A)
60
60
 
61
61
 
62
62
 
func D (A) = ("duckLevel_" + A)
63
63
 
64
64
 
65
65
 
func E (A) = ("duckFreePoints_" + A)
66
66
 
67
67
 
68
68
 
func F (A) = ("duckEquipment_" + A)
69
69
 
70
70
 
71
71
 
func G (c) = ("userXP_" + c)
72
72
 
73
73
 
74
74
 
func H (c) = ("userLevel_" + c)
75
75
 
76
76
 
77
77
 
func I (c) = ("userFreePoints_" + c)
78
78
 
79
79
 
80
80
 
func J (A) = ("savedHealth_" + A)
81
81
 
82
82
 
83
83
 
func K (A) = ("savedLocation_" + A)
84
84
 
85
85
 
86
86
 
func L (A) = ("duckBuffs_" + A)
87
87
 
88
88
 
89
89
 
func M (A) = ("lastRobberyTime_" + A)
90
90
 
91
91
 
92
92
 
func N (A) = ("lastRobberyCost_" + A)
93
93
 
94
94
 
95
95
 
func O (P) = ("landRobberyState_" + P)
96
96
 
97
97
 
98
98
 
func Q (P) = ("landCooldownETA_" + P)
99
99
 
100
100
 
101
101
 
func R (A) = ("duckRobberyState_" + A)
102
102
 
103
103
 
104
104
 
func S (A) = ("lockedLandByDuck_" + A)
105
105
 
106
106
 
107
107
 
func T (A) = ("deliveryDelayByDuck_" + A)
108
108
 
109
109
 
110
110
 
let U = 10000
111
111
 
112
112
 
let V = 10000
113
113
 
114
114
 
let W = 2000
115
115
 
116
116
 
let X = 100000
117
117
 
118
118
 
let Y = 1000000
119
119
 
120
120
 
let Z = 5000000
121
121
 
122
122
 
let aa = 10000
123
123
 
124
124
 
let ab = 1000000
125
125
 
126
126
 
let ac = 1000000
127
127
 
128
128
 
let ad = 10000
129
129
 
130
130
 
func ae (af) = fraction(e, pow(af, 4, f, 4, 4, DOWN), d)
131
131
 
132
132
 
133
133
 
func ag (ah) = (100 + ah)
134
134
 
135
135
 
136
136
 
func ai (aj,ak) = {
137
137
 
    let al = ae(ak)
138
138
 
[al, (g * (al - aj))]
139
139
 
    }
140
140
 
141
141
 
142
142
 
func am (an,A,ao,ap) = {
143
143
 
    let aq = split(valueOrElse(getString(an, B(A)), "0_0_0_0_0"), "_")
144
144
 
    let ar = valueOrElse(getInteger(an, D(A)), 0)
145
145
 
    let as = valueOrElse(getInteger(an, z(A)), ag(ar))
146
146
 
    let at = split(valueOrElse(getString(an, L(A)), "0_0_0_0_0"), "_")
147
147
 
    ([parseIntValue(aq[k]), parseIntValue(aq[l]), parseIntValue(aq[m]), parseIntValue(aq[n]), parseIntValue(aq[o]), ar, as] ++ (if (ap)
148
148
 
        then [ao, ao, ao, ao, ao]
149
149
 
        else [parseIntValue(at[k]), parseIntValue(at[l]), parseIntValue(at[m]), parseIntValue(at[n]), parseIntValue(at[o])]))
150
150
 
    }
151
151
 
152
152
 
153
153
 
func au (an,A) = {
154
154
 
    let av = valueOrElse(getInteger(an, N(A)), 0)
155
155
 
    let aw = valueOrElse(getInteger(an, M(A)), 0)
156
156
 
    let ax = lastBlock.timestamp
157
157
 
    let ay = max([h, (av - (i * (ax - aw)))])
158
158
 
    let az = valueOrElse(getInteger(an, R(A)), 0)
159
159
 
    let aA = valueOrElse(getString(an, S(A)), "")
160
160
 
    let aB = valueOrElse(getInteger(an, Q(aA)), 0)
161
161
 
    $Tuple5(ay, aw, az, aA, aB)
162
162
 
    }
163
163
 
164
164
 
165
165
 
let aC = "LAND"
166
166
 
167
167
 
let aD = "DUCK"
168
168
 
169
169
 
let aE = "PRESALE"
170
170
 
171
171
 
let aF = 6
172
172
 
173
173
 
let aG = 25
174
174
 
175
175
 
let aH = 3456000
176
176
 
177
177
 
let aI = 10000000000
178
178
 
179
179
 
let aJ = "Africa_F_Africa"
180
180
 
181
181
 
let aK = 39637
182
182
 
183
183
 
let aL = 10
184
184
 
185
185
 
let aM = 50000
186
186
 
187
187
 
let aN = 600000
188
188
 
189
189
 
let aO = ["First Aid Kit L1", "First Aid Kit L2", "First Aid Kit L3", "Backpack L1", "Backpack L2", "Backpack L3", "Food Ration L1", "Food Ration L2", "Food Ration L3", "Jet Pack L1", "Jet Pack L2", "Jet Pack L3", "Shield L1", "Shield L2", "Shield L3", "Mine L1", "Mine L2", "Mine L3", "Trap L1", "Trap L2", "Trap L3"]
190
190
 
191
191
 
let aP = ["Americas", "Europe", "Asia", "Africa", "Oceania"]
192
192
 
193
193
 
let aQ = 10000000
194
194
 
195
195
 
let aR = [15, 16, 17, 18, 19, 20]
196
196
 
197
197
 
let aS = ["8_8_8_17_17_42_12_0_30_0,0,0,0,0,0,0_", "8_8_8_17_17_42_24_0_60_0,0,5,2,0,0,0_", "8_8_8_17_17_42_36_0_120_0,0,10,4,0,0,0_", "8_19_19_8_27_19_26_1_20_0,0,0,0,0,0,0_001", "8_19_19_8_27_19_52_1_40_0,0,0,0,0,0,0_001", "8_19_19_8_27_19_78_1_80_0,0,0,0,0,0,0_001", "8_8_8_8_8_60_13_2_2_0,0,0,0,0,0,0_011", "8_8_8_8_8_60_26_2_4_0,0,0,0,0,0,0_011", "8_8_8_8_8_60_39_2_8_0,0,0,0,0,0,0_011", "30_30_3_17_17_3_30_3_30_0,0,0,0,0,0,0_111", "30_30_3_17_17_3_60_3_50_0,0,0,0,0,0,0_111", "30_30_3_17_17_3_90_3_70_0,0,0,0,0,0,0_111", "18_18_10_18_18_18_11_4_10_0,0,0,0,0,0,0_201", "18_18_10_18_18_18_22_4_20_0,0,0,0,0,0,0_201", "18_18_10_18_18_18_33_4_30_0,0,0,0,0,0,0_201", "4_13_22_4_35_22_23_0_50,1,0_0,0,0,0,0,0,0_", "4_13_22_4_35_22_46_0_50,1,1_0,2,5,0,0,0,0_", "4_13_22_4_35_22_69_0_50,2,1_0,5,10,0,0,0,0_", "5_25_40_5_10_15_20_1_30,1,1_0,0,0,0,0,0,0_", "5_25_40_5_10_15_40_1_30,1,2_2,1,3,0,0,0,0_", "5_25_40_5_10_15_60_1_30,1,3_5,2,8,0,0,0,0_"]
198
198
 
199
199
 
let aT = 6
200
200
 
201
201
 
let aU = 8
202
202
 
203
203
 
let aV = 9
204
204
 
205
205
 
let aW = 10
206
206
 
207
207
 
let aX = 10
208
208
 
209
209
 
let aY = 0
210
210
 
211
211
 
let aZ = 1
212
212
 
213
213
 
let ba = 2
214
214
 
215
215
 
let bb = 3
216
216
 
217
217
 
let bc = 4
218
218
 
219
219
 
let bd = 0
220
220
 
221
221
 
let be = 1
222
222
 
223
223
 
let bf = 2
224
224
 
225
225
 
let bg = 3
226
226
 
227
227
 
let bh = 0
228
228
 
229
229
 
let bi = 1
230
230
 
231
231
 
let bj = 2
232
232
 
233
233
 
let bk = 3
234
234
 
235
235
 
let bl = 0
236
236
 
237
237
 
let bm = 1
238
238
 
239
239
 
let bn = 2
240
240
 
241
241
 
func bo (bp) = ("no_" + bp)
242
242
 
243
243
 
244
244
 
func bq (bp) = ("lcna_" + bp)
245
245
 
246
246
 
247
247
 
func br (bp) = ("st_" + bp)
248
248
 
249
249
 
250
250
 
func bs (bt,bp) = makeString(["las", bt, bp], "_")
251
251
 
252
252
 
253
253
 
func bu (bv,bp,bw) = ((((("sttao_" + bv) + "_") + bp) + "_") + bw)
254
254
 
255
255
 
256
256
 
func bx (P) = ("wh_" + P)
257
257
 
258
258
 
259
259
 
func by (bp) = ("infraLevel_" + bp)
260
260
 
261
261
 
262
262
 
func bz (P) = ("fortifications_" + P)
263
263
 
264
264
 
265
265
 
func bA (bp) = ("duckCustomNameByAssetId_" + bp)
266
266
 
267
267
 
268
268
 
func bB (c) = ("accountCustomNameByAddr_" + c)
269
269
 
270
270
 
271
271
 
func bC (c) = ("accRefBy_" + c)
272
272
 
273
273
 
274
274
 
func bD (A) = ("onboardArtActivatedOnDuck_" + A)
275
275
 
276
276
 
277
277
 
func bE (c) = ("onboardArtActivatedDuckBy_" + c)
278
278
 
279
279
 
280
280
 
func bF (c) = ("accReferrals_" + c)
281
281
 
282
282
 
283
283
 
func bG (bp) = ("duckOwner_" + bp)
284
284
 
285
285
 
286
286
 
func bH (bw) = ("stakedDuckByOwner_" + bw)
287
287
 
288
288
 
289
289
 
func bI (A) = ("backPack_" + A)
290
290
 
291
291
 
292
292
 
func bJ (A) = ("duckLocation_" + A)
293
293
 
294
294
 
295
295
 
func bK (bL) = ("%s%s__userGwlReleaseTime__" + bL)
296
296
 
297
297
 
298
298
 
func bM () = "emergencyWarehouseProducts"
299
299
 
300
300
 
301
301
 
let bN = "deliveryFund"
302
302
 
303
303
 
let bO = "deliveryLocked"
304
304
 
305
305
 
let bP = "%s__lastTourId"
306
306
 
307
307
 
func bQ (bR) = ("%s%d__tourStaticData__" + toString(bR))
308
308
 
309
309
 
310
310
 
func bS (bR) = ("%s%d__tourDynamicData__" + toString(bR))
311
311
 
312
312
 
313
313
 
func bT (bR,A) = makeString(["%s%d%s__bestResultByTourAndDuck", toString(bR), A], "__")
314
314
 
315
315
 
316
316
 
let bU = 0
317
317
 
318
318
 
let bV = 1
319
319
 
320
320
 
let bW = 6
321
321
 
322
322
 
let bX = 1
323
323
 
324
324
 
func bY (bZ,bR) = {
325
325
 
    let ca = split(valueOrErrorMessage(getString(bZ, bQ(bR)), (("Error reading tournament " + toString(bR)) + " data")), "__")
326
326
 
    let cb = split_4C(valueOrErrorMessage(getString(bZ, bS(bR)), (("Error reading tournament " + toString(bR)) + " data")), "__")
327
327
 
[ca, cb]
328
328
 
    }
329
329
 
330
330
 
331
331
 
func cc (bZ,cd) = {
332
332
 
    let ce = valueOrElse(getInteger(bZ, bP), 0)
333
333
 
    let cf = split(cd, "_")
334
334
 
    let ax = lastBlock.timestamp
335
335
 
    let cg = bY(bZ, ce)
336
336
 
    let ca = cg[bU]
337
337
 
    let cb = cg[bV]
338
338
 
    if (if (if ((cf[bm] == "T"))
339
339
 
        then (parseIntValue(cf[bl]) == ce)
340
340
 
        else false)
341
341
 
        then (cb[bX] == "INPROGRESS")
342
342
 
        else false)
343
343
 
        then (parseIntValue(ca[bW]) > ax)
344
344
 
        else false
345
345
 
    }
346
346
 
347
347
 
348
348
 
func ch (cd) = {
349
349
 
    let cf = split(cd, "_")
350
350
 
    let ax = lastBlock.timestamp
351
351
 
    let ci = parseIntValue(cf[bl])
352
352
 
    let cj = parseIntValue(cf[bn])
353
353
 
    if (if ((cf[bm] == "D"))
354
354
 
        then (ax > (ci + aN))
355
355
 
        else false)
356
356
 
        then (3 >= cj)
357
357
 
        else false
358
358
 
    }
359
359
 
360
360
 
361
361
 
func ck (cd) = {
362
362
 
    let cl = split(cd, "_")[bm]
363
363
 
    if ((cl != "T"))
364
364
 
        then (cl != "D")
365
365
 
        else false
366
366
 
    }
367
367
 
368
368
 
369
369
 
func cm (bZ,cd) = {
370
370
 
    let ce = valueOrElse(getInteger(bZ, bP), 0)
371
371
 
    let cf = split(cd, "_")
372
372
 
    let ax = lastBlock.timestamp
373
373
 
    let cg = bY(bZ, ce)
374
374
 
    let ca = cg[bU]
375
375
 
    let cb = cg[bV]
376
376
 
    let cl = cf[bm]
377
-
    if (if ((cl != "T"))
378
-
        then (cl != "D")
379
-
        else false)
377
+
    if ((cl == "D"))
380
378
 
        then true
381
-
        else !(if (if (if ((cf[bm] == "T"))
379
+
        else if (if (if ((cf[bm] == "T"))
382
380
 
            then (parseIntValue(cf[bl]) == ce)
383
381
 
            else false)
384
382
 
            then (cb[bX] == "INPROGRESS")
385
383
 
            else false)
386
384
 
            then (parseIntValue(ca[bW]) > ax)
387
-
            else false)
385
+
            else false
388
386
 
    }
389
387
 
390
388
 
391
389
 
func cn (co) = (parseIntValue(co[aT]) * aQ)
392
390
 
393
391
 
394
392
 
func cp (cq,cr,cs) = throw(((((("Cheat attempt: oldLoc=" + cq) + ", newLoc=") + cr) + ", case=") + toString(cs)))
395
393
 
396
394
 
397
395
 
let ct = false
398
396
 
399
397
 
let cu = false
400
398
 
401
399
 
let cv = true
402
400
 
403
401
 
let cw = take(drop(this.bytes, 1), 1)
404
402
 
405
403
 
let cx = {
406
404
 
    let cy = cw
407
405
 
    if ((base58'2W' == cy))
408
406
 
        then base58'9wc3LXNA4TEBsXyKtoLE9mrbDD7WMHXvXrCjZvabLAsi'
409
407
 
        else if ((base58'2T' == cy))
410
408
 
            then base58'6mWwf9mZBjVgkC54idpyaZLQfAosD914wT8fGf2iiY63'
411
409
 
            else throw("Unknown chain")
412
410
 
    }
413
411
 
414
412
 
let cz = {
415
413
 
    let cy = cw
416
414
 
    if ((base58'2W' == cy))
417
415
 
        then "3PQCuvFbvh4LkPUnrnU1z3jnbA1p9m3WNhv"
418
416
 
        else if ((base58'2T' == cy))
419
417
 
            then "3MumkGGztCKAXpWDqxkddofqXSUbqQkvSJy"
420
418
 
            else throw("Unknown chain")
421
419
 
    }
422
420
 
423
421
 
let cA = {
424
422
 
    let cy = cw
425
423
 
    if ((base58'2W' == cy))
426
424
 
        then 10000000000
427
425
 
        else if ((base58'2T' == cy))
428
426
 
            then 100000000
429
427
 
            else throw("Unknown chain")
430
428
 
    }
431
429
 
432
430
 
let cB = {
433
431
 
    let cy = cw
434
432
 
    if ((base58'2W' == cy))
435
433
 
        then 86400000
436
434
 
        else if ((base58'2T' == cy))
437
435
 
            then 60000
438
436
 
            else throw("Unknown chain")
439
437
 
    }
440
438
 
441
439
 
let cC = "__"
442
440
 
443
441
 
let cD = 1000000
444
442
 
445
443
 
let cE = 100000000
446
444
 
447
445
 
let cF = 25
448
446
 
449
447
 
let cG = 100
450
448
 
451
449
 
let cH = 225
452
450
 
453
451
 
let cI = 400
454
452
 
455
453
 
let cJ = 625
456
454
 
457
455
 
let cK = [0, 1, 2, 3, 4, 5]
458
456
 
459
457
 
func cL (cM,cN) = valueOrErrorMessage(getString(cM, cN), makeString(["mandatory ", toString(cM), ".", cN, " is not defined"], ""))
460
458
 
461
459
 
462
460
 
let cO = 1
463
461
 
464
462
 
let cP = 2
465
463
 
466
464
 
let cQ = 3
467
465
 
468
466
 
let cR = 4
469
467
 
470
468
 
let cS = 7
471
469
 
472
470
 
let cT = 8
473
471
 
474
472
 
func cU () = "%s__restConfig"
475
473
 
476
474
 
477
475
 
func cV () = "%s__restAddr"
478
476
 
479
477
 
480
478
 
func cW (cX) = split_4C(cL(cX, cU()), cC)
481
479
 
482
480
 
483
481
 
func cY (cZ,da) = valueOrErrorMessage(addressFromString(cZ[da]), ("Rest cfg doesn't contain address at index " + toString(da)))
484
482
 
485
483
 
486
484
 
let db = addressFromStringValue(valueOrElse(getString(this, cV()), cz))
487
485
 
488
486
 
let cZ = cW(db)
489
487
 
490
488
 
let an = cY(cZ, cO)
491
489
 
492
490
 
let dc = cY(cZ, cP)
493
491
 
494
492
 
let dd = cY(cZ, cQ)
495
493
 
496
494
 
let de = cY(cZ, cR)
497
495
 
498
496
 
let df = cY(cZ, cS)
499
497
 
500
498
 
let dg = cY(cZ, cT)
501
499
 
502
500
 
let dh = 0
503
501
 
504
502
 
let di = 1
505
503
 
506
504
 
let dj = 2
507
505
 
508
506
 
let dk = 3
509
507
 
510
508
 
let dl = "wlg_assetId"
511
509
 
512
510
 
let dm = valueOrErrorMessage(getBinary(de, dl), "WLGOLD is not issued yet")
513
511
 
514
512
 
let dn = "acresAssetId"
515
513
 
516
514
 
let do = valueOrErrorMessage(getBinary(dg, dn), "ACRES is not issued yet")
517
515
 
518
516
 
let dp = 2
519
517
 
520
518
 
func dq (cM) = ("finishBlockForAddr_" + cM)
521
519
 
522
520
 
523
521
 
func dr () = "resTypesProportions"
524
522
 
525
523
 
526
524
 
func ds (dt) = ("resTypesByContinent_" + dt)
527
525
 
528
526
 
529
527
 
func du (bw) = ("stakedLandsByOwner_" + bw)
530
528
 
531
529
 
532
530
 
func dv (bw) = ("stakedPiecesByOwner_" + bw)
533
531
 
534
532
 
535
533
 
func dw (dx) = {
536
534
 
    let cy = dx
537
535
 
    if ($isInstanceOf(cy, "String"))
538
536
 
        then {
539
537
 
            let dy = cy
540
538
 
            dy
541
539
 
            }
542
540
 
        else throw("fail to cast into String")
543
541
 
    }
544
542
 
545
543
 
546
544
 
func dz (dx) = {
547
545
 
    let cy = dx
548
546
 
    if ($isInstanceOf(cy, "Int"))
549
547
 
        then {
550
548
 
            let dA = cy
551
549
 
            dA
552
550
 
            }
553
551
 
        else throw("fail to cast into Int")
554
552
 
    }
555
553
 
556
554
 
557
555
 
func dB (dx) = {
558
556
 
    let cy = dx
559
557
 
    if ($isInstanceOf(cy, "List[Any]"))
560
558
 
        then {
561
559
 
            let dC = cy
562
560
 
            dC
563
561
 
            }
564
562
 
        else throw("fail to cast into List[Any]")
565
563
 
    }
566
564
 
567
565
 
568
566
 
func dD (dx) = {
569
567
 
    let cy = dx
570
568
 
    if ($isInstanceOf(cy, "Boolean"))
571
569
 
        then {
572
570
 
            let dy = cy
573
571
 
            dy
574
572
 
            }
575
573
 
        else throw("fail to cast into Boolean")
576
574
 
    }
577
575
 
578
576
 
579
577
 
func dE (dF) = {
580
578
 
    let cy = dF
581
579
 
    if ($isInstanceOf(cy, "(String, Int)"))
582
580
 
        then {
583
581
 
            let dG = cy
584
582
 
            dG
585
583
 
            }
586
584
 
        else throw("fail to cast into (String, Int)")
587
585
 
    }
588
586
 
589
587
 
590
588
 
func dH (dI) = {
591
589
 
    let cy = dI
592
590
 
    if (("S" == cy))
593
591
 
        then cF
594
592
 
        else if (("M" == cy))
595
593
 
            then cG
596
594
 
            else if (("L" == cy))
597
595
 
                then cH
598
596
 
                else if (("XL" == cy))
599
597
 
                    then cI
600
598
 
                    else if (("XXL" == cy))
601
599
 
                        then cJ
602
600
 
                        else throw("Unknown land size")
603
601
 
    }
604
602
 
605
603
 
606
604
 
func dJ (dy) = isDefined(parseInt(dy))
607
605
 
608
606
 
609
607
 
func dK () = "contractsBlocked"
610
608
 
611
609
 
612
610
 
func dL (c) = ("lastTxIdByUser_" + c)
613
611
 
614
612
 
615
613
 
func dM (dF,dN) = {
616
614
 
    let dO = pow(10, 0, dN, 0, 0, DOWN)
617
615
 
    let dP = toString((dF % dO))
618
616
 
    let dQ = drop(toString(dO), (1 + size(dP)))
619
617
 
    (((toString((dF / dO)) + ".") + dQ) + dP)
620
618
 
    }
621
619
 
622
620
 
623
621
 
func dR (dS,dT,dU) = {
624
622
 
    let dV = value(blockInfoByHeight(dT))
625
623
 
    let dW = sha256((value(dV.vrf) + dU))
626
624
 
    (toInt(dW) % dS)
627
625
 
    }
628
626
 
629
627
 
630
628
 
let dX = {
631
629
 
    let cy = cw
632
630
 
    if ((base58'2W' == cy))
633
631
 
        then addressFromStringValue("3PEktVux2RhchSN63DsDo4b4mz4QqzKSeDv")
634
632
 
        else if ((base58'2T' == cy))
635
633
 
            then this
636
634
 
            else throw("Unknown chain")
637
635
 
    }
638
636
 
639
637
 
let dY = {
640
638
 
    let cy = cw
641
639
 
    if ((base58'2W' == cy))
642
640
 
        then addressFromStringValue("3PDVuU45H7Eh5dmtNbnRNRStGwULA7NY6Hb")
643
641
 
        else if ((base58'2T' == cy))
644
642
 
            then this
645
643
 
            else throw("Unknown chain")
646
644
 
    }
647
645
 
648
646
 
let dZ = {
649
647
 
    let cy = cw
650
648
 
    if ((base58'2W' == cy))
651
649
 
        then if (ct)
652
650
 
            then base58'CWsMtTZC5BjjoL4Q1ayW4Wwb1ehGACQB6DrKyPgotKfm'
653
651
 
            else base58'6LfPuKJjLgekmncBhMg2LZyMTNVzZBccXR28ySXm9uXD'
654
652
 
        else if ((base58'2T' == cy))
655
653
 
            then base58'6LfPuKJjLgekmncBhMg2LZyMTNVzZBccXR28ySXm9uXD'
656
654
 
            else throw("Unknown chain")
657
655
 
    }
658
656
 
659
657
 
let ea = base64'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=='
660
658
 
661
659
 
let eb = 300000
662
660
 
663
661
 
let ec = 5000000
664
662
 
665
663
 
let ed = 50
666
664
 
667
665
 
let ee = 10000000
668
666
 
669
667
 
let ef = {
670
668
 
    let cy = cw
671
669
 
    if ((base58'2W' == cy))
672
670
 
        then 252289527462
673
671
 
        else if ((base58'2T' == cy))
674
672
 
            then 2522895274
675
673
 
            else throw("Unknown chain")
676
674
 
    }
677
675
 
678
676
 
let eg = {
679
677
 
    let cy = cw
680
678
 
    if ((base58'2W' == cy))
681
679
 
        then 250000000
682
680
 
        else if ((base58'2T' == cy))
683
681
 
            then 250000000
684
682
 
            else throw("Unknown chain")
685
683
 
    }
686
684
 
687
685
 
let eh = 2500000000
688
686
 
689
687
 
let ei = toBigInt(5)
690
688
 
691
689
 
let ej = toBigInt(20)
692
690
 
693
691
 
let ek = toBigInt((20 * 20))
694
692
 
695
693
 
let el = toBigInt(((20 * 20) * 20))
696
694
 
697
695
 
let em = toBigInt((((20 * 20) * 20) * 20))
698
696
 
699
697
 
let en = toBigInt(((((20 * 20) * 20) * 20) * 20))
700
698
 
701
699
 
let eo = 500
702
700
 
703
701
 
func ep () = "nextLandNum"
704
702
 
705
703
 
706
704
 
func eq (er) = ("lcn_" + er)
707
705
 
708
706
 
709
707
 
func es (et) = ("la_" + et)
710
708
 
711
709
 
712
710
 
func eu (bp,bw) = ((("ilao_" + bp) + "_") + bw)
713
711
 
714
712
 
715
713
 
func ev (et) = ("lo_" + et)
716
714
 
717
715
 
718
716
 
func ew (er) = ("duckByCustomName_" + er)
719
717
 
720
718
 
721
719
 
func ex (er) = ("accountByCustomName_" + er)
722
720
 
723
721
 
724
722
 
func ey () = "oldiesList"
725
723
 
726
724
 
727
725
 
let ez = 0
728
726
 
729
727
 
let eA = 1
730
728
 
731
729
 
let eB = 2
732
730
 
733
731
 
let eC = 0
734
732
 
735
733
 
let eD = 5
736
734
 
737
735
 
let eE = 6
738
736
 
739
737
 
let eF = 7
740
738
 
741
739
 
func eG (et,dI) = ((aC + et) + dI)
742
740
 
743
741
 
744
742
 
func eH (eI,eJ) = {
745
743
 
    let eK = if ((eI >= 0))
746
744
 
        then (((eI + eJ) - 1) / eJ)
747
745
 
        else -((((-(eI) + eJ) - 1) / eJ))
748
746
 
    (eK * cE)
749
747
 
    }
750
748
 
751
749
 
752
750
 
func eL (eM,eN) = {
753
751
 
    let eO = (((((eN[0] + eN[1]) + eN[2]) + eN[3]) + eN[4]) + eN[5])
754
752
 
    if ((0 >= eO))
755
753
 
        then throw("Zero weights sum")
756
754
 
        else {
757
755
 
            let eP = fraction(eM, cD, eO)
758
756
 
            func eQ (eR,eS) =             (eR :+ fraction(eS, eP, cD))
759
757
 
760
758
 
            let eT = eN
761
759
 
            let eU = size(eT)
762
760
 
            let eV = nil
763
761
 
            func eW (eX,eY) =             if ((eY >= eU))
764
762
 
                then eX
765
763
 
                else eQ(eX, eT[eY])
766
764
 
767
765
 
            func eZ (eX,eY) =             if ((eY >= eU))
768
766
 
                then eX
769
767
 
                else throw("List size exceeds 6")
770
768
 
771
769
 
            eZ(eW(eW(eW(eW(eW(eW(eV, 0), 1), 2), 3), 4), 5), 6)
772
770
 
            }
773
771
 
    }
774
772
 
775
773
 
776
774
 
func fa (eM) = {
777
775
 
    let fb = split(value(getString(dr())), "_")
778
776
 
    if ((size(fb) != aF))
779
777
 
        then throw("Wrong proportions data")
780
778
 
        else {
781
779
 
            let fc = [parseIntValue(fb[0]), parseIntValue(fb[1]), parseIntValue(fb[2]), parseIntValue(fb[3]), parseIntValue(fb[4]), parseIntValue(fb[5])]
782
780
 
            eL(eM, fc)
783
781
 
            }
784
782
 
    }
785
783
 
786
784
 
787
785
 
func fd (fe,ff,fg) = {
788
786
 
    let fh = fa(fg)
789
787
 
    func fi (eR,da) =     {
790
788
 
        let fj = (parseIntValue(ff[da]) - fh[da])
791
789
 
        if ((0 > fj))
792
790
 
            then throw(((((("Not enough material idx=" + toString(da)) + ", you have ") + ff[da]) + ", but need ") + toString(fh[da])))
793
791
 
            else (eR :+ toString(fj))
794
792
 
        }
795
793
 
796
794
 
    if (fe)
797
795
 
        then {
798
796
 
            let eT = cK
799
797
 
            let eU = size(eT)
800
798
 
            let eV = nil
801
799
 
            func eW (eX,eY) =             if ((eY >= eU))
802
800
 
                then eX
803
801
 
                else fi(eX, eT[eY])
804
802
 
805
803
 
            func eZ (eX,eY) =             if ((eY >= eU))
806
804
 
                then eX
807
805
 
                else throw("List size exceeds 6")
808
806
 
809
807
 
            eZ(eW(eW(eW(eW(eW(eW(eV, 0), 1), 2), 3), 4), 5), 6)
810
808
 
            }
811
809
 
        else ff
812
810
 
    }
813
811
 
814
812
 
815
813
 
func fk (fl,fm) = if ((fm == ""))
816
814
 
    then $Tuple2(fl, false)
817
815
 
    else {
818
816
 
        func fn (eR,fo) =         {
819
817
 
            let fp = split(fo, ",")
820
818
 
            if ((size(fp) != 2))
821
819
 
                then throw("Incorrect format, should be index,amount")
822
820
 
                else {
823
821
 
                    let da = parseIntValue(fp[0])
824
822
 
                    if (if ((0 > da))
825
823
 
                        then true
826
824
 
                        else (da >= size(aS)))
827
825
 
                        then throw("Unknown product idx")
828
826
 
                        else {
829
827
 
                            let fq = parseIntValue(fp[1])
830
828
 
                            let fr = split(eR._1, (fp[0] + ":"))
831
829
 
                            if ((size(fr) != 2))
832
830
 
                                then throw((("You don't have " + aO[da]) + " equipped"))
833
831
 
                                else {
834
832
 
                                    let fs = fr[1]
835
833
 
                                    let ft = if (dJ(take(drop(fs, 1), 1)))
836
834
 
                                        then 2
837
835
 
                                        else 1
838
836
 
                                    let fu = parseIntValue(take(fs, ft))
839
837
 
                                    let fv = drop(fs, ft)
840
838
 
                                    let fw = if ((fu >= fq))
841
839
 
                                        then (fu - fq)
842
840
 
                                        else throw(((((("You equipped " + toString(fu)) + " of ") + aO[da]) + ", but tried to use ") + toString(fq)))
843
841
 
                                    $Tuple2(((((fr[0] + fp[0]) + ":") + toString(fw)) + fv), if (eR._2)
844
842
 
                                        then true
845
843
 
                                        else if (if ((da >= 6))
846
844
 
                                            then (8 >= da)
847
845
 
                                            else false)
848
846
 
                                            then (fw == 0)
849
847
 
                                            else false)
850
848
 
                                    }
851
849
 
                            }
852
850
 
                    }
853
851
 
            }
854
852
 
855
853
 
        let eT = split(fm, "_")
856
854
 
        let eU = size(eT)
857
855
 
        let eV = $Tuple2(fl, false)
858
856
 
        func eW (eX,eY) =         if ((eY >= eU))
859
857
 
            then eX
860
858
 
            else fn(eX, eT[eY])
861
859
 
862
860
 
        func eZ (eX,eY) =         if ((eY >= eU))
863
861
 
            then eX
864
862
 
            else throw("List size exceeds 10")
865
863
 
866
864
 
        eZ(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eV, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
867
865
 
        }
868
866
 
869
867
 
870
868
 
func fx (fy) = {
871
869
 
    let fz = if ((fy == ""))
872
870
 
        then nil
873
871
 
        else split_4C(fy, "_")
874
872
 
    func fA (eR,co) =     {
875
873
 
        let fB = (size(eR) / 8)
876
874
 
        let fu = if ((size(fz) > fB))
877
875
 
            then parseIntValue(fz[fB])
878
876
 
            else 0
879
877
 
        (eR + toBytes(fu))
880
878
 
        }
881
879
 
882
880
 
    let eT = aS
883
881
 
    let eU = size(eT)
884
882
 
    let eV = base58''
885
883
 
    func eW (eX,eY) =     if ((eY >= eU))
886
884
 
        then eX
887
885
 
        else fA(eX, eT[eY])
888
886
 
889
887
 
    func eZ (eX,eY) =     if ((eY >= eU))
890
888
 
        then eX
891
889
 
        else throw("List size exceeds 50")
892
890
 
893
891
 
    eZ(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eV, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50)
894
892
 
    }
895
893
 
896
894
 
897
895
 
func fC (fD) = {
898
896
 
    func fE (eR,co) =     {
899
897
 
        let fB = size(eR)
900
898
 
        let fF = take(drop(fD, (8 * fB)), 8)
901
899
 
        (eR :+ toString(toInt(fF)))
902
900
 
        }
903
901
 
904
902
 
    makeString_2C({
905
903
 
        let eT = aS
906
904
 
        let eU = size(eT)
907
905
 
        let eV = nil
908
906
 
        func eW (eX,eY) =         if ((eY >= eU))
909
907
 
            then eX
910
908
 
            else fE(eX, eT[eY])
911
909
 
912
910
 
        func eZ (eX,eY) =         if ((eY >= eU))
913
911
 
            then eX
914
912
 
            else throw("List size exceeds 50")
915
913
 
916
914
 
        eZ(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eV, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50)
917
915
 
        }, "_")
918
916
 
    }
919
917
 
920
918
 
921
919
 
func fG (fH,fI) = {
922
920
 
    func fJ (eR,fB) =     {
923
921
 
        let fK = if ((size(fH) > (7 + fB)))
924
922
 
            then fH[(7 + fB)]
925
923
 
            else 0
926
924
 
        if ((parseIntValue(fI[fB]) > (fH[fB] + fK)))
927
925
 
            then throw(("Requirement not satisfied: " + j[fB]))
928
926
 
            else true
929
927
 
        }
930
928
 
931
929
 
    let eT = [0, 1, 2, 3, 4, 5, 6]
932
930
 
    let eU = size(eT)
933
931
 
    let eV = false
934
932
 
    func eW (eX,eY) =     if ((eY >= eU))
935
933
 
        then eX
936
934
 
        else fJ(eX, eT[eY])
937
935
 
938
936
 
    func eZ (eX,eY) =     if ((eY >= eU))
939
937
 
        then eX
940
938
 
        else throw("List size exceeds 7")
941
939
 
942
940
 
    eZ(eW(eW(eW(eW(eW(eW(eW(eV, 0), 1), 2), 3), 4), 5), 6), 7)
943
941
 
    }
944
942
 
945
943
 
946
944
 
func fL (fM,fz,fN,fH,fO,fP) = {
947
945
 
    let fp = split(fM, ":")
948
946
 
    if ((size(fp) != 2))
949
947
 
        then throw("Incorrect format, should be index:amount")
950
948
 
        else if (if (!(fN))
951
949
 
            then (size(fp[0]) != 2)
952
950
 
            else false)
953
951
 
            then throw("Product idx should be 2 digits, zero padded")
954
952
 
            else {
955
953
 
                let fQ = parseIntValue(fp[0])
956
954
 
                let fR = parseIntValue(fp[1])
957
955
 
                if (!(containsElement(aR, fQ)))
958
956
 
                    then throw((("Product '" + aO[fQ]) + "' cannot be used for land defense"))
959
957
 
                    else if ((0 > fR))
960
958
 
                        then throw("Count can't be negative")
961
959
 
                        else if ((fR > t))
962
960
 
                            then throw(((("Can't put more than " + toString(t)) + " of ") + aO[fQ]))
963
961
 
                            else if ((fR == 0))
964
962
 
                                then $Tuple3(fz, fO, fP)
965
963
 
                                else {
966
964
 
                                    let fS = take(fz, (8 * fQ))
967
965
 
                                    let fu = toInt(take(drop(fz, (8 * fQ)), 8))
968
966
 
                                    let fv = drop(fz, (8 * (fQ + 1)))
969
967
 
                                    let co = split(aS[fQ], "_")
970
968
 
                                    if (if (!(fN))
971
969
 
                                        then (fR > fu)
972
970
 
                                        else false)
973
971
 
                                        then throw(((((("You have " + toString(fu)) + " of ") + aO[fQ]) + ", but tried to use ") + toString(fR)))
974
972
 
                                        else {
975
973
 
                                            let fw = if (if (!(fN))
976
974
 
                                                then fG(fH, split(co[aV], ","))
977
975
 
                                                else false)
978
976
 
                                                then (fu - fR)
979
977
 
                                                else (fu + fR)
980
978
 
                                            let fT = (eH(fw, aX) - eH(fu, aX))
981
979
 
                                            $Tuple3(((fS + toBytes(fw)) + fv), (fO + fT), (fP - fT))
982
980
 
                                            }
983
981
 
                                    }
984
982
 
                }
985
983
 
    }
986
984
 
987
985
 
988
986
 
func fU (fM,fz,fN,fV,fW,fX,fH) = {
989
987
 
    let fp = split(fM, ":")
990
988
 
    if ((size(fp) != 2))
991
989
 
        then throw("Incorrect format, should be index:amount")
992
990
 
        else if (if (!(fN))
993
991
 
            then (size(fp[0]) != 2)
994
992
 
            else false)
995
993
 
            then throw("Product idx should be 2 digits, zero padded")
996
994
 
            else {
997
995
 
                let fQ = parseIntValue(fp[0])
998
996
 
                let fR = parseIntValue(fp[1])
999
997
 
                if (if ((0 > fQ))
1000
998
 
                    then true
1001
999
 
                    else (fQ >= size(aS)))
1002
1000
 
                    then throw("Unknown product idx")
1003
1001
 
                    else if ((0 > fR))
1004
1002
 
                        then throw("Count can't be negative")
1005
1003
 
                        else if ((fR > t))
1006
1004
 
                            then throw(((("Can't put more than " + toString(t)) + " of ") + aO[fQ]))
1007
1005
 
                            else if ((fR == 0))
1008
1006
 
                                then $Tuple2(fz, false)
1009
1007
 
                                else {
1010
1008
 
                                    let fS = take(fz, (8 * fQ))
1011
1009
 
                                    let fu = toInt(take(drop(fz, (8 * fQ)), 8))
1012
1010
 
                                    let fv = drop(fz, (8 * (fQ + 1)))
1013
1011
 
                                    let co = split(aS[fQ], "_")
1014
1012
 
                                    if (if (!(fN))
1015
1013
 
                                        then (fR > fu)
1016
1014
 
                                        else false)
1017
1015
 
                                        then throw(((((("You have " + toString(fu)) + " of ") + aO[fQ]) + ", but tried to use ") + toString(fR)))
1018
1016
 
                                        else {
1019
1017
 
                                            let fY = if (if (!(fN))
1020
1018
 
                                                then fG(fH, split(co[aV], ","))
1021
1019
 
                                                else false)
1022
1020
 
                                                then {
1023
1021
 
                                                    let fZ = co[aW]
1024
1022
 
                                                    if ((fZ == ""))
1025
1023
 
                                                        then throw("Item cannot be equipped")
1026
1024
 
                                                        else {
1027
1025
 
                                                            let ga = parseIntValue(fZ)
1028
1026
 
                                                            let gb = (ga / 100)
1029
1027
 
                                                            if ((fV != gb))
1030
1028
 
                                                                then throw("Segment incompatible")
1031
1029
 
                                                                else {
1032
1030
 
                                                                    let gc = ((ga % 100) / 10)
1033
1031
 
                                                                    if ((fW != gc))
1034
1032
 
                                                                        then throw("Slot incompatible")
1035
1033
 
                                                                        else {
1036
1034
 
                                                                            let gd = (ga % 10)
1037
1035
 
                                                                            if (if ((fX != 0))
1038
1036
 
                                                                                then (gd > 1)
1039
1037
 
                                                                                else false)
1040
1038
 
                                                                                then throw("Big items should occupy slot 0")
1041
1039
 
                                                                                else (gd > 1)
1042
1040
 
                                                                            }
1043
1041
 
                                                                    }
1044
1042
 
                                                            }
1045
1043
 
                                                    }
1046
1044
 
                                                else false
1047
1045
 
                                            $Tuple2(((fS + toBytes((fu + (if (fN)
1048
1046
 
                                                then fR
1049
1047
 
                                                else -(fR))))) + fv), fY)
1050
1048
 
                                            }
1051
1049
 
                                    }
1052
1050
 
                }
1053
1051
 
    }
1054
1052
 
1055
1053
 
1056
1054
 
func ge (gf,gg,fN,fV,fW,gh) = if ((gf != ""))
1057
1055
 
    then {
1058
1056
 
        let gi = split(gf, ",")
1059
1057
 
        if ((size(gi) > s))
1060
1058
 
            then throw("Wrong slots format")
1061
1059
 
            else {
1062
1060
 
                let gj = gi[0]
1063
1061
 
                let gk = if ((size(gi) > 1))
1064
1062
 
                    then gi[1]
1065
1063
 
                    else ""
1066
1064
 
                if (if ((gj == ""))
1067
1065
 
                    then (gk == "")
1068
1066
 
                    else false)
1069
1067
 
                    then gg
1070
1068
 
                    else {
1071
1069
 
                        let gl = if ((gj != ""))
1072
1070
 
                            then fU(gj, gg, fN, fV, fW, 0, gh)
1073
1071
 
                            else $Tuple2(gg, false)
1074
1072
 
                        if ((gk != ""))
1075
1073
 
                            then if (gl._2)
1076
1074
 
                                then throw("Big item already occupies slot")
1077
1075
 
                                else fU(gk, gl._1, fN, fV, fW, 1, gh)._1
1078
1076
 
                            else gl._1
1079
1077
 
                        }
1080
1078
 
                }
1081
1079
 
        }
1082
1080
 
    else gg
1083
1081
 
1084
1082
 
1085
1083
 
func gm (gn,go,fN,gh) = {
1086
1084
 
    func fV (eR,gp) =     {
1087
1085
 
        let fB = eR._1
1088
1086
 
        let fW = split(gp, ";")
1089
1087
 
        if ((size(fW) != r))
1090
1088
 
            then throw("Wrong segment format")
1091
1089
 
            else {
1092
1090
 
                let gq = fW[0]
1093
1091
 
                let gr = fW[1]
1094
1092
 
                if (if ((gq == ""))
1095
1093
 
                    then (gr == "")
1096
1094
 
                    else false)
1097
1095
 
                    then $Tuple2((fB + 1), eR._2)
1098
1096
 
                    else {
1099
1097
 
                        let gs = ge(gq, eR._2, fN, fB, 0, gh)
1100
1098
 
                        $Tuple2((fB + 1), ge(gr, gs, fN, fB, 1, gh))
1101
1099
 
                        }
1102
1100
 
                }
1103
1101
 
        }
1104
1102
 
1105
1103
 
(    let eT = gn
1106
1104
 
    let eU = size(eT)
1107
1105
 
    let eV = $Tuple2(0, go)
1108
1106
 
    func eW (eX,eY) =     if ((eY >= eU))
1109
1107
 
        then eX
1110
1108
 
        else fV(eX, eT[eY])
1111
1109
 
1112
1110
 
    func eZ (eX,eY) =     if ((eY >= eU))
1113
1111
 
        then eX
1114
1112
 
        else throw("List size exceeds 6")
1115
1113
 
1116
1114
 
    eZ(eW(eW(eW(eW(eW(eW(eV, 0), 1), 2), 3), 4), 5), 6))._2
1117
1115
 
    }
1118
1116
 
1119
1117
 
1120
1118
 
func gt (gn,go,fO,fP,fN,fH) = if ((3 > size(gn)))
1121
1119
 
    then throw("At least duck, mines and traps parts are required")
1122
1120
 
    else {
1123
1121
 
        func fV (eR,gp) =         {
1124
1122
 
            let fB = eR._1
1125
1123
 
            if ((fB == 0))
1126
1124
 
                then $Tuple4((fB + 1), eR._2, eR._3, eR._4)
1127
1125
 
                else {
1128
1126
 
                    let gu = fL(gp, eR._2, fN, fH, eR._3, eR._4)
1129
1127
 
                    $Tuple4((fB + 1), gu._1, gu._2, gu._3)
1130
1128
 
                    }
1131
1129
 
            }
1132
1130
 
1133
1131
 
        let gv = {
1134
1132
 
            let eT = gn
1135
1133
 
            let eU = size(eT)
1136
1134
 
            let eV = $Tuple4(0, go, fO, fP)
1137
1135
 
            func eW (eX,eY) =             if ((eY >= eU))
1138
1136
 
                then eX
1139
1137
 
                else fV(eX, eT[eY])
1140
1138
 
1141
1139
 
            func eZ (eX,eY) =             if ((eY >= eU))
1142
1140
 
                then eX
1143
1141
 
                else throw("List size exceeds 10")
1144
1142
 
1145
1143
 
            eZ(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eV, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1146
1144
 
            }
1147
1145
 
        $Tuple3(gv._2, gv._3, gv._4)
1148
1146
 
        }
1149
1147
 
1150
1148
 
1151
1149
 
func gw (A) = {
1152
1150
 
    let gx = F(A)
1153
1151
 
    let gy = split(valueOrElse(getString(gx), ",;,_,;,_,;,_,;,_,;,_,;,"), "_")
1154
1152
 
    let gz = gm(gy, ea, true, nil)
1155
1153
 
    let gA = split(gy[p], ";")[1]
1156
1154
 
    let ao = if ((gA == ""))
1157
1155
 
        then 0
1158
1156
 
        else {
1159
1157
 
            let gB = split(gA, ",")[0]
1160
1158
 
            if ((gB == ""))
1161
1159
 
                then 0
1162
1160
 
                else {
1163
1161
 
                    let fM = split(gB, ":")
1164
1162
 
                    let da = fM[0]
1165
1163
 
                    let gC = fM[1]
1166
1164
 
                    if (if (if (if (if ((da == "06"))
1167
1165
 
                        then true
1168
1166
 
                        else (da == "07"))
1169
1167
 
                        then true
1170
1168
 
                        else (da == "08"))
1171
1169
 
                        then (gC != "")
1172
1170
 
                        else false)
1173
1171
 
                        then (parseIntValue(gC) > 0)
1174
1172
 
                        else false)
1175
1173
 
                        then parseIntValue(split(aS[parseIntValue(da)], "_")[aU])
1176
1174
 
                        else 0
1177
1175
 
                    }
1178
1176
 
            }
1179
1177
 
    let gh = am(this, A, ao, true)
1180
1178
 
    let gD = gm(gy, gz, false, gh)
1181
1179
 
    (gD == gD)
1182
1180
 
    }
1183
1181
 
1184
1182
 
1185
1183
 
func gE (gF,gG,gH,gI) = if ((size(gF) != aF))
1186
1184
 
    then throw("Wrong proportions data")
1187
1185
 
    else {
1188
1186
 
        func gJ (eR,gK) =         {
1189
1187
 
            let fj = (parseIntValue(gF[gK]) + ((gI * gG[gK]) * gH))
1190
1188
 
            if ((0 > fj))
1191
1189
 
                then throw(((((((("Panic! Pieces of type=" + toString(gK)) + ", sign=") + toString(gI)) + ", terrainCounts[i]=") + toString(gG[gK])) + ", landSizeIndex=") + toString(gH)))
1192
1190
 
                else (eR :+ toString(fj))
1193
1191
 
            }
1194
1192
 
1195
1193
 
        let eT = cK
1196
1194
 
        let eU = size(eT)
1197
1195
 
        let eV = nil
1198
1196
 
        func eW (eX,eY) =         if ((eY >= eU))
1199
1197
 
            then eX
1200
1198
 
            else gJ(eX, eT[eY])
1201
1199
 
1202
1200
 
        func eZ (eX,eY) =         if ((eY >= eU))
1203
1201
 
            then eX
1204
1202
 
            else throw("List size exceeds 6")
1205
1203
 
1206
1204
 
        eZ(eW(eW(eW(eW(eW(eW(eV, 0), 1), 2), 3), 4), 5), 6)
1207
1205
 
        }
1208
1206
 
1209
1207
 
1210
1208
 
func gL (gG,gH,gI) = {
1211
1209
 
    let gF = split(valueOrElse(getString(dr()), "0_0_0_0_0_0"), "_")
1212
1210
 
    makeString(gE(gF, gG, gH, gI), "_")
1213
1211
 
    }
1214
1212
 
1215
1213
 
1216
1214
 
func gM (gN) = [(size(split(gN, "A")) - 1), (size(split(gN, "B")) - 1), (size(split(gN, "C")) - 1), (size(split(gN, "D")) - 1), (size(split(gN, "E")) - 1), (size(split(gN, "F")) - 1)]
1217
1215
 
1218
1216
 
1219
1217
 
func gO (gP,gG,gQ,gH,gR) = {
1220
1218
 
    func gS (eR,gK) =     {
1221
1219
 
        let gT = ((fraction(gQ, gR, a) * gG[gK]) * gH)
1222
1220
 
        (eR :+ toString((parseIntValue(gP[gK]) + gT)))
1223
1221
 
        }
1224
1222
 
1225
1223
 
    let fc = {
1226
1224
 
        let eT = cK
1227
1225
 
        let eU = size(eT)
1228
1226
 
        let eV = nil
1229
1227
 
        func eW (eX,eY) =         if ((eY >= eU))
1230
1228
 
            then eX
1231
1229
 
            else gS(eX, eT[eY])
1232
1230
 
1233
1231
 
        func eZ (eX,eY) =         if ((eY >= eU))
1234
1232
 
            then eX
1235
1233
 
            else throw("List size exceeds 6")
1236
1234
 
1237
1235
 
        eZ(eW(eW(eW(eW(eW(eW(eV, 0), 1), 2), 3), 4), 5), 6)
1238
1236
 
        }
1239
1237
 
    makeString(fc, "_")
1240
1238
 
    }
1241
1239
 
1242
1240
 
1243
1241
 
func gU (gG,gQ,gH,gR) = {
1244
1242
 
    func gS (eR,gK) =     {
1245
1243
 
        let gT = ((fraction(gQ, gR, a) * gG[gK]) * gH)
1246
1244
 
        $Tuple2((eR._1 :+ gT), (eR._2 + gT))
1247
1245
 
        }
1248
1246
 
1249
1247
 
    let eT = cK
1250
1248
 
    let eU = size(eT)
1251
1249
 
    let eV = $Tuple2(nil, 0)
1252
1250
 
    func eW (eX,eY) =     if ((eY >= eU))
1253
1251
 
        then eX
1254
1252
 
        else gS(eX, eT[eY])
1255
1253
 
1256
1254
 
    func eZ (eX,eY) =     if ((eY >= eU))
1257
1255
 
        then eX
1258
1256
 
        else throw("List size exceeds 6")
1259
1257
 
1260
1258
 
    eZ(eW(eW(eW(eW(eW(eW(eV, 0), 1), 2), 3), 4), 5), 6)
1261
1259
 
    }
1262
1260
 
1263
1261
 
1264
1262
 
func gV (gW,gX,gY,gZ) = {
1265
1263
 
    let ha = gY._1
1266
1264
 
    let hb = gY._2
1267
1265
 
    if ((hb == 0))
1268
1266
 
        then $Tuple2(makeString(gW, "_"), makeString(gX, "_"))
1269
1267
 
        else if ((gZ >= hb))
1270
1268
 
            then {
1271
1269
 
                func hc (eR,gK) =                 (eR :+ toString((parseIntValue(gW[gK]) + ha[gK])))
1272
1270
 
1273
1271
 
                let fc = {
1274
1272
 
                    let eT = cK
1275
1273
 
                    let eU = size(eT)
1276
1274
 
                    let eV = nil
1277
1275
 
                    func eW (eX,eY) =                     if ((eY >= eU))
1278
1276
 
                        then eX
1279
1277
 
                        else hc(eX, eT[eY])
1280
1278
 
1281
1279
 
                    func eZ (eX,eY) =                     if ((eY >= eU))
1282
1280
 
                        then eX
1283
1281
 
                        else throw("List size exceeds 6")
1284
1282
 
1285
1283
 
                    eZ(eW(eW(eW(eW(eW(eW(eV, 0), 1), 2), 3), 4), 5), 6)
1286
1284
 
                    }
1287
1285
 
                $Tuple2(makeString(fc, "_"), makeString(gX, "_"))
1288
1286
 
                }
1289
1287
 
            else {
1290
1288
 
                func hd (eR,gK) =                 {
1291
1289
 
                    let he = fraction(ha[gK], gZ, hb)
1292
1290
 
                    $Tuple2((eR._1 :+ toString((parseIntValue(gW[gK]) + he))), (eR._2 :+ toString(((parseIntValue(gX[gK]) + ha[gK]) - he))))
1293
1291
 
                    }
1294
1292
 
1295
1293
 
                let fc = {
1296
1294
 
                    let eT = cK
1297
1295
 
                    let eU = size(eT)
1298
1296
 
                    let eV = $Tuple2(nil, nil)
1299
1297
 
                    func eW (eX,eY) =                     if ((eY >= eU))
1300
1298
 
                        then eX
1301
1299
 
                        else hd(eX, eT[eY])
1302
1300
 
1303
1301
 
                    func eZ (eX,eY) =                     if ((eY >= eU))
1304
1302
 
                        then eX
1305
1303
 
                        else throw("List size exceeds 6")
1306
1304
 
1307
1305
 
                    eZ(eW(eW(eW(eW(eW(eW(eV, 0), 1), 2), 3), 4), 5), 6)
1308
1306
 
                    }
1309
1307
 
                $Tuple2(makeString(fc._1, "_"), makeString(fc._2, "_"))
1310
1308
 
                }
1311
1309
 
    }
1312
1310
 
1313
1311
 
1314
1312
 
func hf (hg) = if ((hg >= toBigInt(0)))
1315
1313
 
    then hg
1316
1314
 
    else -(hg)
1317
1315
 
1318
1316
 
1319
1317
 
let hh = [[6, 9, 14, 15, 16], [5, 8, 13, 14, 15], [1, 4, 9, 10, 15], [1, 6, 7, 15, 19], [4, 7, 8, 13, 18]]
1320
1318
 
1321
1319
 
func hi (dA,hj) = {
1322
1320
 
    let hk = toInt((dA % ej))
1323
1321
 
    let hl = if ((hj[0] > hk))
1324
1322
 
        then "A"
1325
1323
 
        else if ((hj[1] > hk))
1326
1324
 
            then "B"
1327
1325
 
            else if ((hj[2] > hk))
1328
1326
 
                then "C"
1329
1327
 
                else if ((hj[3] > hk))
1330
1328
 
                    then "D"
1331
1329
 
                    else if ((hj[4] > hk))
1332
1330
 
                        then "E"
1333
1331
 
                        else "F"
1334
1332
 
    hl
1335
1333
 
    }
1336
1334
 
1337
1335
 
1338
1336
 
func hm (hn,ho) = {
1339
1337
 
    let hp = hh[ho]
1340
1338
 
    func hq (eR,eS) =     $Tuple2((((((eR._1 + hi(eR._2, hp)) + hi((eR._2 / ej), hp)) + hi((eR._2 / ek), hp)) + hi((eR._2 / el), hp)) + hi((eR._2 / em), hp)), (eR._2 / en))
1341
1339
 
1342
1340
 
    let gv = {
1343
1341
 
        let eT = [1, 2, 3, 4, 5]
1344
1342
 
        let eU = size(eT)
1345
1343
 
        let eV = $Tuple2("", (hn / ei))
1346
1344
 
        func eW (eX,eY) =         if ((eY >= eU))
1347
1345
 
            then eX
1348
1346
 
            else hq(eX, eT[eY])
1349
1347
 
1350
1348
 
        func eZ (eX,eY) =         if ((eY >= eU))
1351
1349
 
            then eX
1352
1350
 
            else throw("List size exceeds 5")
1353
1351
 
1354
1352
 
        eZ(eW(eW(eW(eW(eW(eV, 0), 1), 2), 3), 4), 5)
1355
1353
 
        }
1356
1354
 
    gv._1
1357
1355
 
    }
1358
1356
 
1359
1357
 
1360
1358
 
let hr = [7, 2, 15, 19, 8, 24, 1, 21, 16, 5, 0, 22, 20, 23, 11, 4, 18, 12, 6, 10, 3, 17, 13, 9, 14]
1361
1359
 
1362
1360
 
let hs = ["A", "B", "C", "D", "E", "F"]
1363
1361
 
1364
1362
 
func ht (hu,gH) = {
1365
1363
 
    func hv (eR,dy) =     {
1366
1364
 
        let fB = eR._2
1367
1365
 
        let hw = parseIntValue(dy)
1368
1366
 
        let hg = if ((hw == 0))
1369
1367
 
            then 0
1370
1368
 
            else if ((hw >= (4 * gH)))
1371
1369
 
                then (hw / gH)
1372
1370
 
                else if ((hw > (3 * gH)))
1373
1371
 
                    then 3
1374
1372
 
                    else (((hw - 1) / gH) + 1)
1375
1373
 
        $Tuple3((eR._1 :+ hg), (eR._2 + 1), (eR._3 + hg))
1376
1374
 
        }
1377
1375
 
1378
1376
 
    let gv = {
1379
1377
 
        let eT = hu
1380
1378
 
        let eU = size(eT)
1381
1379
 
        let eV = $Tuple3(nil, 0, 0)
1382
1380
 
        func eW (eX,eY) =         if ((eY >= eU))
1383
1381
 
            then eX
1384
1382
 
            else hv(eX, eT[eY])
1385
1383
 
1386
1384
 
        func eZ (eX,eY) =         if ((eY >= eU))
1387
1385
 
            then eX
1388
1386
 
            else throw("List size exceeds 6")
1389
1387
 
1390
1388
 
        eZ(eW(eW(eW(eW(eW(eW(eV, 0), 1), 2), 3), 4), 5), 6)
1391
1389
 
        }
1392
1390
 
    let hx = gv._1
1393
1391
 
    let hy = value(indexOf(hx, max(hx)))
1394
1392
 
    let hz = (gv._3 - 25)
1395
1393
 
    func hA (eR,da) =     {
1396
1394
 
        let dF = if ((da == hy))
1397
1395
 
            then (hx[da] - hz)
1398
1396
 
            else hx[da]
1399
1397
 
        let dQ = if ((dF == 0))
1400
1398
 
            then nil
1401
1399
 
            else split(drop(toString(pow(10, 0, dF, 0, 0, DOWN)), 1), "")
1402
1400
 
        let ga = hs[da]
1403
1401
 
        func hB (hC,hD) =         (hC :+ ga)
1404
1402
 
1405
1403
 
        let hE = {
1406
1404
 
            let eT = dQ
1407
1405
 
            let eU = size(eT)
1408
1406
 
            let eV = nil
1409
1407
 
            func hF (eX,eY) =             if ((eY >= eU))
1410
1408
 
                then eX
1411
1409
 
                else hB(eX, eT[eY])
1412
1410
 
1413
1411
 
            func hG (eX,eY) =             if ((eY >= eU))
1414
1412
 
                then eX
1415
1413
 
                else throw("List size exceeds 25")
1416
1414
 
1417
1415
 
            hG(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(eV, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25)
1418
1416
 
            }
1419
1417
 
        (eR ++ hE)
1420
1418
 
        }
1421
1419
 
1422
1420
 
    let fc = {
1423
1421
 
        let eT = cK
1424
1422
 
        let eU = size(eT)
1425
1423
 
        let eV = nil
1426
1424
 
        func hF (eX,eY) =         if ((eY >= eU))
1427
1425
 
            then eX
1428
1426
 
            else hA(eX, eT[eY])
1429
1427
 
1430
1428
 
        func hG (eX,eY) =         if ((eY >= eU))
1431
1429
 
            then eX
1432
1430
 
            else throw("List size exceeds 6")
1433
1431
 
1434
1432
 
        hG(hF(hF(hF(hF(hF(hF(eV, 0), 1), 2), 3), 4), 5), 6)
1435
1433
 
        }
1436
1434
 
    func hH (eR,fB) =     (eR + fc[fB])
1437
1435
 
1438
1436
 
    let eT = hr
1439
1437
 
    let eU = size(eT)
1440
1438
 
    let eV = ""
1441
1439
 
    func hI (eX,eY) =     if ((eY >= eU))
1442
1440
 
        then eX
1443
1441
 
        else hH(eX, eT[eY])
1444
1442
 
1445
1443
 
    func hJ (eX,eY) =     if ((eY >= eU))
1446
1444
 
        then eX
1447
1445
 
        else throw("List size exceeds 25")
1448
1446
 
1449
1447
 
    hJ(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(eV, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25)
1450
1448
 
    }
1451
1449
 
1452
1450
 
1453
1451
 
func hK (hL) = {
1454
1452
 
    let gu = split(valueOrElse(getString(hL), "0:0_0_0_0_0_0:0_0_0_0_0_0:"), ":")
1455
1453
 
[toString(valueOrElse(parseInt(gu[bh]), 0)), if ((size(split(gu[bi], "_")) == aF))
1456
1454
 
        then gu[bi]
1457
1455
 
        else "0_0_0_0_0_0", if ((size(split(gu[bj], "_")) == aF))
1458
1456
 
        then gu[bj]
1459
1457
 
        else "0_0_0_0_0_0", gu[bk]]
1460
1458
 
    }
1461
1459
 
1462
1460
 
1463
1461
 
func hM (hN) = {
1464
1462
 
    let fp = split(hN, "_")
1465
1463
 
    ((aI * (parseIntValue(fp[1]) + 1)) * parseIntValue(fp[0]))
1466
1464
 
    }
1467
1465
 
1468
1466
 
1469
1467
 
func hO (hP) = {
1470
1468
 
    let hQ = hP[bb]
1471
1469
 
    func hR (eR,hS) =     (eR + parseIntValue(hS))
1472
1470
 
1473
1471
 
    func hT (eR,hS) =     {
1474
1472
 
        let da = eR._1
1475
1473
 
        let eK = (((parseIntValue(hS) + aX) - 1) / aX)
1476
1474
 
        $Tuple2((da + 1), (eR._2 + (eK * cE)))
1477
1475
 
        }
1478
1476
 
1479
1477
 
    let hU = {
1480
1478
 
        let eT = split(hP[aZ], "_")
1481
1479
 
        let eU = size(eT)
1482
1480
 
        let eV = 0
1483
1481
 
        func eW (eX,eY) =         if ((eY >= eU))
1484
1482
 
            then eX
1485
1483
 
            else hR(eX, eT[eY])
1486
1484
 
1487
1485
 
        func eZ (eX,eY) =         if ((eY >= eU))
1488
1486
 
            then eX
1489
1487
 
            else throw("List size exceeds 6")
1490
1488
 
1491
1489
 
        eZ(eW(eW(eW(eW(eW(eW(eV, 0), 1), 2), 3), 4), 5), 6)
1492
1490
 
        }
1493
1491
 
    let hV = {
1494
1492
 
        let eT = split(hP[ba], "_")
1495
1493
 
        let eU = size(eT)
1496
1494
 
        let eV = 0
1497
1495
 
        func hF (eX,eY) =         if ((eY >= eU))
1498
1496
 
            then eX
1499
1497
 
            else hR(eX, eT[eY])
1500
1498
 
1501
1499
 
        func hG (eX,eY) =         if ((eY >= eU))
1502
1500
 
            then eX
1503
1501
 
            else throw("List size exceeds 6")
1504
1502
 
1505
1503
 
        hG(hF(hF(hF(hF(hF(hF(eV, 0), 1), 2), 3), 4), 5), 6)
1506
1504
 
        }
1507
1505
 
    let hW = if ((hQ == ""))
1508
1506
 
        then 0
1509
1507
 
        else (        let eT = split_4C(hQ, "_")
1510
1508
 
        let eU = size(eT)
1511
1509
 
        let eV = $Tuple2(0, 0)
1512
1510
 
        func hI (eX,eY) =         if ((eY >= eU))
1513
1511
 
            then eX
1514
1512
 
            else hT(eX, eT[eY])
1515
1513
 
1516
1514
 
        func hJ (eX,eY) =         if ((eY >= eU))
1517
1515
 
            then eX
1518
1516
 
            else throw("List size exceeds 50")
1519
1517
 
1520
1518
 
        hJ(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(eV, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50))._2
1521
1519
 
    ((hU + hV) + hW)
1522
1520
 
    }
1523
1521
 
1524
1522
 
1525
1523
 
func hX (hY,hZ,ia) = {
1526
1524
 
    let hN = ((toString(hZ) + "_") + toString(ia))
1527
1525
 
    let ib = hM(hN)
1528
1526
 
    let ic = valueOrElse(getString(hY), (hN + ":0_0_0_0_0_0:0_0_0_0_0_0::0"))
1529
1527
 
    let id = split_4C(ic, ":")
1530
1528
 
    let ie = hO(id)
1531
1529
 
    let if = if ((5 > size(id)))
1532
1530
 
        then makeString(["0", toString(ie), toString((ib - ie)), toString(ib)], "_")
1533
1531
 
        else {
1534
1532
 
            let ig = split(id[bc], "_")
1535
1533
 
            let ih = parseIntValue(ig[bd])
1536
1534
 
            let ii = if ((size(ig) > 1))
1537
1535
 
                then parseIntValue(ig[be])
1538
1536
 
                else ie
1539
1537
 
            makeString([toString(ih), toString(ii), toString(((ib - ih) - ii)), toString(ib)], "_")
1540
1538
 
            }
1541
1539
 
[id[aY], if ((size(split(id[aZ], "_")) == aF))
1542
1540
 
        then id[aZ]
1543
1541
 
        else "0_0_0_0_0_0", if ((size(split(id[ba], "_")) == aF))
1544
1542
 
        then id[ba]
1545
1543
 
        else "0_0_0_0_0_0", id[bb], if]
1546
1544
 
    }
1547
1545
 
1548
1546
 
1549
1547
 
func ij (hP) = {
1550
1548
 
    let ik = hO(hP)
1551
1549
 
    let il = parseIntValue(split(hP[bc], "_")[bd])
1552
1550
 
    ((hM(hP[aY]) - ik) - il)
1553
1551
 
    }
1554
1552
 
1555
1553
 
1556
1554
 
func im (in,hP,io) = if ((size(in) != 3))
1557
1555
 
    then throw("cargoListStr should contain exactly 2 ':' separators")
1558
1556
 
    else {
1559
1557
 
        let ip = split(in[0], "_")
1560
1558
 
        let iq = split(in[1], "_")
1561
1559
 
        let ir = if ((in[2] == ""))
1562
1560
 
            then nil
1563
1561
 
            else split_4C(in[2], "_")
1564
1562
 
        if ((size(ip) != aF))
1565
1563
 
            then throw("All 6 resources should be passed")
1566
1564
 
            else if ((size(iq) != aF))
1567
1565
 
                then throw("All 6 materials should be passed")
1568
1566
 
                else {
1569
1567
 
                    let gZ = ij(hP)
1570
1568
 
                    let is = split(hP[aZ], "_")
1571
1569
 
                    let it = split(hP[ba], "_")
1572
1570
 
                    let iu = if ((hP[bb] == ""))
1573
1571
 
                        then nil
1574
1572
 
                        else split_4C(hP[bb], "_")
1575
1573
 
                    let gX = split(io[bi], "_")
1576
1574
 
                    let iv = split(io[bj], "_")
1577
1575
 
                    let iw = if ((io[bk] == ""))
1578
1576
 
                        then nil
1579
1577
 
                        else split_4C(io[bk], "_")
1580
1578
 
                    func ix (eR,hS) =                     {
1581
1579
 
                        let gK = eR._1
1582
1580
 
                        let iy = parseIntValue(hS)
1583
1581
 
                        let iz = parseIntValue(is[gK])
1584
1582
 
                        let iA = parseIntValue(gX[gK])
1585
1583
 
                        if ((iy == 0))
1586
1584
 
                            then $Tuple4((gK + 1), (eR._2 :+ is[gK]), (eR._3 :+ gX[gK]), eR._4)
1587
1585
 
                            else if ((iy > 0))
1588
1586
 
                                then if ((iy > iA))
1589
1587
 
                                    then throw((((("Attempt to take " + hS) + " from backpack, but only ") + toString(iA)) + " available"))
1590
1588
 
                                    else $Tuple4((gK + 1), (eR._2 :+ toString((iz + iy))), (eR._3 :+ toString((iA - iy))), (eR._4 + iy))
1591
1589
 
                                else if ((-(iy) > iz))
1592
1590
 
                                    then throw((((("Attempt to take " + toString(-(iy))) + " from warehouse, but only ") + toString(iz)) + " available"))
1593
1591
 
                                    else $Tuple4((gK + 1), (eR._2 :+ toString((iz + iy))), (eR._3 :+ toString((iA - iy))), (eR._4 + iy))
1594
1592
 
                        }
1595
1593
 
1596
1594
 
                    let fc = {
1597
1595
 
                        let eT = ip
1598
1596
 
                        let eU = size(eT)
1599
1597
 
                        let eV = $Tuple4(0, nil, nil, 0)
1600
1598
 
                        func eW (eX,eY) =                         if ((eY >= eU))
1601
1599
 
                            then eX
1602
1600
 
                            else ix(eX, eT[eY])
1603
1601
 
1604
1602
 
                        func eZ (eX,eY) =                         if ((eY >= eU))
1605
1603
 
                            then eX
1606
1604
 
                            else throw("List size exceeds 6")
1607
1605
 
1608
1606
 
                        eZ(eW(eW(eW(eW(eW(eW(eV, 0), 1), 2), 3), 4), 5), 6)
1609
1607
 
                        }
1610
1608
 
                    func iB (eR,hS) =                     {
1611
1609
 
                        let gK = eR._1
1612
1610
 
                        let iy = parseIntValue(hS)
1613
1611
 
                        let iC = parseIntValue(it[gK])
1614
1612
 
                        let iD = parseIntValue(iv[gK])
1615
1613
 
                        if ((iy == 0))
1616
1614
 
                            then $Tuple4((gK + 1), (eR._2 :+ it[gK]), (eR._3 :+ iv[gK]), eR._4)
1617
1615
 
                            else if ((iy > 0))
1618
1616
 
                                then if ((iy > iD))
1619
1617
 
                                    then throw((((("Attempt to take " + hS) + " from backpack, but only ") + toString(iD)) + " available"))
1620
1618
 
                                    else $Tuple4((gK + 1), (eR._2 :+ toString((iC + iy))), (eR._3 :+ toString((iD - iy))), (eR._4 + iy))
1621
1619
 
                                else if ((-(iy) > iC))
1622
1620
 
                                    then throw((((("Attempt to take " + toString(-(iy))) + " from warehouse, but only ") + toString(iC)) + " available"))
1623
1621
 
                                    else $Tuple4((gK + 1), (eR._2 :+ toString((iC + iy))), (eR._3 :+ toString((iD - iy))), (eR._4 + iy))
1624
1622
 
                        }
1625
1623
 
1626
1624
 
                    let gq = {
1627
1625
 
                        let eT = iq
1628
1626
 
                        let eU = size(eT)
1629
1627
 
                        let eV = $Tuple4(0, nil, nil, fc._4)
1630
1628
 
                        func hF (eX,eY) =                         if ((eY >= eU))
1631
1629
 
                            then eX
1632
1630
 
                            else iB(eX, eT[eY])
1633
1631
 
1634
1632
 
                        func hG (eX,eY) =                         if ((eY >= eU))
1635
1633
 
                            then eX
1636
1634
 
                            else throw("List size exceeds 6")
1637
1635
 
1638
1636
 
                        hG(hF(hF(hF(hF(hF(hF(eV, 0), 1), 2), 3), 4), 5), 6)
1639
1637
 
                        }
1640
1638
 
                    func iE (eR,hS) =                     {
1641
1639
 
                        let gK = eR._1
1642
1640
 
                        let iy = parseIntValue(hS)
1643
1641
 
                        let iF = if ((size(iu) > gK))
1644
1642
 
                            then parseIntValue(iu[gK])
1645
1643
 
                            else 0
1646
1644
 
                        let iG = if ((size(iw) > gK))
1647
1645
 
                            then parseIntValue(iw[gK])
1648
1646
 
                            else 0
1649
1647
 
                        if ((iy == 0))
1650
1648
 
                            then $Tuple4((gK + 1), (eR._2 :+ toString(iF)), (eR._3 :+ toString(iG)), eR._4)
1651
1649
 
                            else if ((iy > 0))
1652
1650
 
                                then if ((iy > iG))
1653
1651
 
                                    then throw((((("Attempt to take " + hS) + " from backpack, but only ") + toString(iG)) + " available"))
1654
1652
 
                                    else {
1655
1653
 
                                        let fT = (eH((iF + iy), aX) - eH(iF, aX))
1656
1654
 
                                        $Tuple4((gK + 1), (eR._2 :+ toString((iF + iy))), (eR._3 :+ toString((iG - iy))), (eR._4 + fT))
1657
1655
 
                                        }
1658
1656
 
                                else if ((-(iy) > iF))
1659
1657
 
                                    then throw((((("Attempt to take " + toString(-(iy))) + " from warehouse, but only ") + toString(iF)) + " available"))
1660
1658
 
                                    else {
1661
1659
 
                                        let fT = (eH((iF + iy), aX) - eH(iF, aX))
1662
1660
 
                                        $Tuple4((gK + 1), (eR._2 :+ toString((iF + iy))), (eR._3 :+ toString((iG - iy))), (eR._4 + fT))
1663
1661
 
                                        }
1664
1662
 
                        }
1665
1663
 
1666
1664
 
                    let gu = if ((size(ir) != 0))
1667
1665
 
                        then {
1668
1666
 
                            let eT = ir
1669
1667
 
                            let eU = size(eT)
1670
1668
 
                            let eV = $Tuple4(0, nil, nil, gq._4)
1671
1669
 
                            func hI (eX,eY) =                             if ((eY >= eU))
1672
1670
 
                                then eX
1673
1671
 
                                else iE(eX, eT[eY])
1674
1672
 
1675
1673
 
                            func hJ (eX,eY) =                             if ((eY >= eU))
1676
1674
 
                                then eX
1677
1675
 
                                else throw("List size exceeds 50")
1678
1676
 
1679
1677
 
                            hJ(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(hI(eV, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50)
1680
1678
 
                            }
1681
1679
 
                        else $Tuple4(0, iu, iw, gq._4)
1682
1680
 
                    let iH = gu._4
1683
1681
 
                    if ((iH > gZ))
1684
1682
 
                        then throw((((("Attempt to put total " + toString(iH)) + " stuff, but only ") + toString(gZ)) + " warehouse space left"))
1685
1683
 
                        else $Tuple7(makeString(fc._2, "_"), makeString(gq._2, "_"), makeString_2C(gu._2, "_"), makeString(fc._3, "_"), makeString(gq._3, "_"), makeString_2C(gu._3, "_"), iH)
1686
1684
 
                    }
1687
1685
 
        }
1688
1686
 
1689
1687
 
1690
1688
 
func iI (iJ,iK) = {
1691
1689
 
    let bL = toString(iJ)
1692
1690
 
    let iL = hf(toBigInt(iK))
1693
1691
 
    let iM = valueOrElse(getInteger(ep()), (eo + 1))
1694
1692
 
    let et = toString(iM)
1695
1693
 
    let ho = toInt((iL % ei))
1696
1694
 
    let gN = hm(iL, ho)
1697
1695
 
    let dt = aP[ho]
1698
1696
 
    let iN = Issue(eG(et, "S"), makeString([et, "S", gN, dt], "_"), 1, 0, false)
1699
1697
 
    let bp = calculateAssetId(iN)
1700
1698
 
    let iO = toBase58String(bp)
1701
1699
 
    $Tuple2([IntegerEntry(ep(), (iM + 1)), iN, StringEntry(es(et), iO), StringEntry(bo(iO), bL), StringEntry(ev(et), bL), IntegerEntry(by(iO), 0), IntegerEntry(eu(iO, bL), 0), ScriptTransfer(iJ, 1, bp)], $Tuple2(iO, dt))
1702
1700
 
    }
1703
1701
 
1704
1702
 
1705
1703
 
func iP (bL,iQ,iR) = if (!(sigVerify_8Kb(iQ, iR, dZ)))
1706
1704
 
    then throw("signature does not match")
1707
1705
 
    else {
1708
1706
 
        let fp = split_4C(toUtf8String(iQ), ";")
1709
1707
 
        let iS = split_4C(fp[0], "|")
1710
1708
 
        let iT = split(iS[eC], "_")
1711
1709
 
        let iU = parseIntValue(iT[0])
1712
1710
 
        let iV = parseIntValue(iT[1])
1713
1711
 
        let iW = split(fp[1], ":")
1714
1712
 
        let iX = iW[0]
1715
1713
 
        let iY = parseIntValue(iS[eD])
1716
1714
 
        if (if ((iY > (lastBlock.timestamp + eb)))
1717
1715
 
            then true
1718
1716
 
            else ((lastBlock.timestamp - eb) > iY))
1719
1717
 
            then throw(((("signature outdated: logTime=" + toString(iY)) + ", bcTime=") + toString(lastBlock.timestamp)))
1720
1718
 
            else {
1721
1719
 
                let iZ = iW[1]
1722
1720
 
                let ja = valueOrElse(getString(dL(bL)), "")
1723
1721
 
                if ((ja != iZ))
1724
1722
 
                    then throw(((("Tx ids don't match! In state: " + ja) + ", in msg: ") + iZ))
1725
1723
 
                    else {
1726
1724
 
                        let A = valueOrErrorMessage(getString(bH(bL)), "You don't have a duck staked")
1727
1725
 
                        let jb = z(A)
1728
1726
 
                        let jc = ag(valueOrElse(getInteger(D(A)), 0))
1729
1727
 
                        let jd = valueOrElse(getInteger(jb), jc)
1730
1728
 
                        if ((jd != iU))
1731
1729
 
                            then throw(((("oldHealth=" + toString(jd)) + " from state does not match one from flight log=") + toString(iU)))
1732
1730
 
                            else if ((0 >= iU))
1733
1731
 
                                then throw("You can't fly with zero health")
1734
1732
 
                                else if (!(gw(A)))
1735
1733
 
                                    then throw("Equipment incompatible")
1736
1734
 
                                    else {
1737
1735
 
                                        let je = if ((size(iS) > eE))
1738
1736
 
                                            then iS[eE]
1739
1737
 
                                            else ""
1740
1738
 
                                        let jf = if ((size(iS) > eF))
1741
1739
 
                                            then iS[eF]
1742
1740
 
                                            else ""
1743
1741
 
                                        let jg = if (if ((iV > 0))
1744
1742
 
                                            then (je == "$")
1745
1743
 
                                            else false)
1746
1744
 
                                            then dz(invoke(db, "sendUsdtPrize", [bL], nil))
1747
1745
 
                                            else 0
1748
1746
 
                                        $Tuple5(iV, A, jg, iX, jf)
1749
1747
 
                                        }
1750
1748
 
                        }
1751
1749
 
                }
1752
1750
 
        }
1753
1751
 
1754
1752
 
1755
1753
 
func jh (P,ji) = {
1756
1754
 
    let ia = valueOrElse(getInteger(by(P)), 0)
1757
1755
 
    let jj = valueOrElse(getInteger(bs(aE, P)), 0)
1758
1756
 
    let jk = (ia / 6)
1759
1757
 
    let jl = (ia / 7)
1760
1758
 
    ((aH + fraction(aH, ((ia + jk) + (2 * jl)), 5)) + fraction(aH, jj, (ji * 5)))
1761
1759
 
    }
1762
1760
 
1763
1761
 
1764
1762
 
func jm (c,jn,jo) = {
1765
1763
 
    let jp = if ((jn == ez))
1766
1764
 
        then $Tuple2(jo, valueOrElse(getString(bH(c)), ""))
1767
1765
 
        else {
1768
1766
 
            let A = valueOrErrorMessage(getString(bH(c)), "You don't have a duck staked")
1769
1767
 
            let jq = valueOrElse(getString(bJ(A)), aJ)
1770
1768
 
            let cf = split(value(jq), "_")
1771
1769
 
            if ((cf[bm] != "L"))
1772
1770
 
                then throw((("Duck location type is " + cf[bm]) + ", but should be L"))
1773
1771
 
                else $Tuple2(cf[bn], A)
1774
1772
 
            }
1775
1773
 
    let P = jp._1
1776
1774
 
    let jr = jp._2
1777
1775
 
    let js = value(assetInfo(fromBase58String(P)))
1778
1776
 
    let jt = br(P)
1779
1777
 
    let ju = valueOrErrorMessage(getInteger(jt), (("Land " + js.name) + " is not staked"))
1780
1778
 
    let jv = valueOrErrorMessage(getString(bo(P)), (("NFT " + js.name) + " is orphaned"))
1781
1779
 
    if ((jv != c))
1782
1780
 
        then throw((aC + " is not yours"))
1783
1781
 
        else {
1784
1782
 
            let jw = split(js.description, "_")
1785
1783
 
            $Tuple4(jr, P, jw, ju)
1786
1784
 
            }
1787
1785
 
    }
1788
1786
 
1789
1787
 
1790
1788
 
func jx (c,eI,jn,jo) = if ((0 > eI))
1791
1789
 
    then throw("Negative amount")
1792
1790
 
    else {
1793
1791
 
        let ga = jm(c, jn, jo)
1794
1792
 
        let dI = ga._3[di]
1795
1793
 
        let gG = gM(ga._3[dj])
1796
1794
 
        let gQ = (lastBlock.timestamp - ga._4)
1797
1795
 
        if ((0 > gQ))
1798
1796
 
            then throw(((("Saved timestamp is in future, saved = " + toString(ga._4)) + ", current = ") + toString(lastBlock.timestamp)))
1799
1797
 
            else {
1800
1798
 
                let ji = dH(dI)
1801
1799
 
                let jy = jh(ga._2, ji)
1802
1800
 
                let jz = fraction(gQ, (jy * ji), a)
1803
1801
 
                if ((eI > jz))
1804
1802
 
                    then throw(((("Not enough resources, available = " + toString(jz)) + ", requested = ") + toString(eI)))
1805
1803
 
                    else {
1806
1804
 
                        let jA = fraction((jz - eI), a, (jy * ji))
1807
1805
 
                        let jB = (lastBlock.timestamp - jA)
1808
1806
 
                        let hZ = (ji / cF)
1809
1807
 
                        let gY = gU(gG, (gQ - jA), hZ, jy)
1810
1808
 
                        let hY = bx(ga._2)
1811
1809
 
                        let ia = valueOrElse(getInteger(by(ga._2)), 0)
1812
1810
 
                        let hP = hX(hY, hZ, ia)
1813
1811
 
                        let ig = split(hP[bc], "_")
1814
1812
 
                        let gZ = parseIntValue(ig[bf])
1815
1813
 
                        if (if ((jn == ez))
1816
1814
 
                            then (eI > gZ)
1817
1815
 
                            else false)
1818
1816
 
                            then throw((("Only " + toString(gZ)) + " space left in warehouse"))
1819
1817
 
                            else {
1820
1818
 
                                let hL = bI(ga._1)
1821
1819
 
                                let io = hK(hL)
1822
1820
 
                                let gX = split(io[bi], "_")
1823
1821
 
                                let gW = split(hP[aZ], "_")
1824
1822
 
                                let jC = if ((jn == ez))
1825
1823
 
                                    then $Tuple4(gO(gW, gG, (gQ - jA), hZ, jy), io[bi], (parseIntValue(ig[be]) + gY._2), (parseIntValue(ig[bf]) - gY._2))
1826
1824
 
                                    else if ((jn == eA))
1827
1825
 
                                        then $Tuple4(hP[aZ], gO(gX, gG, (gQ - jA), hZ, jy), parseIntValue(ig[be]), parseIntValue(ig[bf]))
1828
1826
 
                                        else {
1829
1827
 
                                            let jD = gV(gW, gX, gY, gZ)
1830
1828
 
                                            let jE = min([parseIntValue(ig[bf]), gY._2])
1831
1829
 
                                            $Tuple4(jD._1, jD._2, (parseIntValue(ig[be]) + jE), (parseIntValue(ig[bf]) - jE))
1832
1830
 
                                            }
1833
1831
 
                                let jF = jC._1
1834
1832
 
                                let jG = jC._2
1835
1833
 
                                let jH = jC._3
1836
1834
 
                                let jI = jC._4
1837
1835
 
                                $Tuple5([IntegerEntry(br(ga._2), jB), IntegerEntry(bu(aC, ga._2, c), jB)], hL, [io[bh], jG, io[bj], io[bk]], hY, [hP[aY], jF, hP[ba], hP[bb], makeString([ig[bd], toString(jH), toString(jI), ig[bg]], "_")])
1838
1836
 
                                }
1839
1837
 
                        }
1840
1838
 
                }
1841
1839
 
        }
1842
1840
 
1843
1841
 
1844
1842
 
func jJ (c,P,ji,jn) = {
1845
1843
 
    let jt = br(P)
1846
1844
 
    let ju = value(getInteger(jt))
1847
1845
 
    let jz = (fraction((lastBlock.timestamp - ju), jh(P, ji), a) * ji)
1848
1846
 
    jx(c, jz, jn, P)
1849
1847
 
    }
1850
1848
 
1851
1849
 
1852
1850
 
func jK (fe,iJ,jL,P) = {
1853
1851
 
    let c = toString(iJ)
1854
1852
 
    let ga = jm(c, eB, P)
1855
1853
 
    let ji = dH(ga._3[di])
1856
1854
 
    let jM = by(ga._2)
1857
1855
 
    let jN = valueOrElse(getInteger(jM), 0)
1858
1856
 
    if (if (!(cu))
1859
1857
 
        then (jN >= 3)
1860
1858
 
        else false)
1861
1859
 
        then throw("Currently max infrastructure level = 3")
1862
1860
 
        else {
1863
1861
 
            let jO = ((sqrt(ji, 0, 0, DOWN) / 5) + 2)
1864
1862
 
            let al = (jN + 1)
1865
1863
 
            if (if (cu)
1866
1864
 
                then (al > jO)
1867
1865
 
                else false)
1868
1866
 
                then throw(("Currently max infrastructure level = " + toString(jO)))
1869
1867
 
                else {
1870
1868
 
                    let jP = fraction(ee, (ji * al), cF)
1871
1869
 
                    if (if (!(fe))
1872
1870
 
                        then (jL != jP)
1873
1871
 
                        else false)
1874
1872
 
                        then throw(("Payment attached should be " + toString(jP)))
1875
1873
 
                        else {
1876
1874
 
                            let hL = bI(ga._1)
1877
1875
 
                            let io = hK(hL)
1878
1876
 
                            let jQ = split(io[bj], "_")
1879
1877
 
                            let jR = fraction(cA, (ji * al), cF)
1880
1878
 
                            let jS = makeString(fd(fe, jQ, jR), "_")
1881
1879
 
                            let jT = jJ(c, ga._2, ji, eB)
1882
1880
 
                            let jU = jT._5
1883
1881
 
                            let jV = hM(jU[aY])
1884
1882
 
                            let jW = makeString([split(jU[aY], "_")[0], toString(al)], "_")
1885
1883
 
                            let jX = hM(jW)
1886
1884
 
                            let ig = split(jU[bc], "_")
1887
1885
 
                            let jY = makeString([ig[bd], ig[be], toString(((parseIntValue(ig[bf]) + jX) - jV)), toString(jX)], "_")
1888
1886
 
                            $Tuple3(([IntegerEntry(jM, al), IntegerEntry(eu(ga._2, c), al), StringEntry(hL, makeString([io[bh], jT._3[bi], jS, io[bk]], ":")), StringEntry(jT._4, makeString([jW, jU[aZ], jU[ba], jU[bb], jY], ":"))] ++ jT._1), al, jR)
1889
1887
 
                            }
1890
1888
 
                    }
1891
1889
 
            }
1892
1890
 
    }
1893
1891
 
1894
1892
 
1895
1893
 
func jZ (A,ka) = {
1896
1894
 
    let kb = D(A)
1897
1895
 
    let kc = C(A)
1898
1896
 
    let af = valueOrElse(getInteger(kc), 0)
1899
1897
 
    let ak = (af + ka)
1900
1898
 
    let kd = ai(valueOrElse(getInteger(kb), 0), ak)
1901
1899
 
    let ke = E(A)
1902
1900
 
    $Tuple2([IntegerEntry(kb, kd[0]), IntegerEntry(kc, ak), IntegerEntry(ke, (valueOrElse(getInteger(ke), 0) + kd[1]))], ak)
1903
1901
 
    }
1904
1902
 
1905
1903
 
1906
1904
 
func kf (c,ka) = {
1907
1905
 
    let kb = H(c)
1908
1906
 
    let kc = G(c)
1909
1907
 
    let af = valueOrElse(getInteger(kc), 0)
1910
1908
 
    let ak = (af + ka)
1911
1909
 
    let kd = ai(valueOrElse(getInteger(kb), 0), ak)
1912
1910
 
    let ke = I(c)
1913
1911
 
    $Tuple2([IntegerEntry(kb, kd[0]), IntegerEntry(kc, ak), IntegerEntry(ke, (valueOrElse(getInteger(ke), 0) + kd[1]))], ak)
1914
1912
 
    }
1915
1913
 
1916
1914
 
1917
1915
 
func kg (c) = {
1918
1916
 
    let A = valueOrErrorMessage(getString(bH(c)), "You don't have a duck staked")
1919
1917
 
    let kh = bC(c)
1920
1918
 
    let ki = getString(kh)
1921
1919
 
    if (!(isDefined(ki)))
1922
1920
 
        then throw("You are not eligible for ONBOARD artifact")
1923
1921
 
        else {
1924
1922
 
            let kj = bE(c)
1925
1923
 
            let kk = getString(kj)
1926
1924
 
            if (isDefined(kk))
1927
1925
 
                then throw(("You already used your ONBOARD artifact on duck " + value(kk)))
1928
1926
 
                else {
1929
1927
 
                    let kl = bD(A)
1930
1928
 
                    let km = getString(kl)
1931
1929
 
                    if (isDefined(km))
1932
1930
 
                        then throw(((("The duck " + A) + " already got points from ONBOARD artifact from user ") + value(km)))
1933
1931
 
                        else ([StringEntry(kj, A), StringEntry(kl, c)] ++ jZ(A, ac)._1)
1934
1932
 
                    }
1935
1933
 
            }
1936
1934
 
    }
1937
1935
 
1938
1936
 
1939
1937
 
func kn (c,jo) = {
1940
1938
 
    let ga = jm(c, eB, jo)
1941
1939
 
    let P = ga._2
1942
1940
 
    let ji = dH(ga._3[di])
1943
1941
 
    let ko = bs(aE, P)
1944
1942
 
    if ((valueOrElse(getInteger(ko), 0) > 0))
1945
1943
 
        then throw("Presale artifact is already activated")
1946
1944
 
        else if ((parseIntValue(ga._3[dh]) > eo))
1947
1945
 
            then throw((((aC + " ") + P) + " is not eligible for presale artifact"))
1948
1946
 
            else {
1949
1947
 
                let jT = jJ(c, P, ji, eB)
1950
1948
 
                (((jT._1 :+ IntegerEntry(ko, ji)) :+ StringEntry(jT._2, makeString(jT._3, ":"))) :+ StringEntry(jT._4, makeString(jT._5, ":")))
1951
1949
 
                }
1952
1950
 
    }
1953
1951
 
1954
1952
 
1955
1953
 
func kp (A) = {
1956
1954
 
    let ce = valueOrElse(getInteger(df, bP), 0)
1957
1955
 
    let jq = split(valueOrElse(getString(bJ(A)), aJ), "_")
1958
1956
 
    let ax = lastBlock.timestamp
1959
1957
 
    let cg = bY(df, ce)
1960
1958
 
    let ca = cg[bU]
1961
1959
 
    let cb = cg[bV]
1962
1960
 
    if ((jq[bm] != "T"))
1963
1961
 
        then false
1964
1962
 
        else if (if (if ((parseIntValue(jq[bl]) == ce))
1965
1963
 
            then (cb[bX] == "INPROGRESS")
1966
1964
 
            else false)
1967
1965
 
            then (parseIntValue(ca[bW]) > ax)
1968
1966
 
            else false)
1969
1967
 
            then throw("Your duck is taking part in the tournament")
1970
1968
 
            else dD(invoke(this, "exitTournamentInternal", [A], nil))
1971
1969
 
    }
1972
1970
 
1973
1971
 
1974
1972
 
func kq (A) = if (!(cv))
1975
1973
 
    then false
1976
1974
 
    else {
1977
1975
 
        let jq = split(valueOrElse(getString(bJ(A)), aJ), "_")
1978
1976
 
        let ax = lastBlock.timestamp
1979
1977
 
        if ((jq[bm] != "D"))
1980
1978
 
            then false
1981
1979
 
            else {
1982
1980
 
                let ci = parseIntValue(jq[bl])
1983
1981
 
                let cj = parseIntValue(jq[bn])
1984
1982
 
                if (if ((ax > (ci + aN)))
1985
1983
 
                    then (3 > cj)
1986
1984
 
                    else false)
1987
1985
 
                    then throw("Your duck is on delivery mission")
1988
1986
 
                    else dD(invoke(this, "exitDeliveryInternal", [A], nil))
1989
1987
 
                }
1990
1988
 
        }
1991
1989
 
1992
1990
 
1993
1991
 
func kr (A) = {
1994
1992
 
    let jq = split(valueOrElse(getString(bJ(A)), aJ), "_")
1995
1993
 
    let ax = lastBlock.timestamp
1996
1994
 
    let ci = parseIntValue(jq[bl])
1997
1995
 
    let cj = parseIntValue(jq[bn])
1998
1996
 
    let jv = valueOrErrorMessage(getString(bG(A)), "NFT duck is orphaned")
1999
1997
 
    let ks = z(A)
2000
1998
 
    let kt = getIntegerValue(ks)
2001
1999
 
    let ku = if ((cj >= 3))
2002
2000
 
        then {
2003
2001
 
            let kv = invoke(dc, "sendDeliveryReward", [jv], nil)
2004
2002
 
            if ((kv == kv))
2005
2003
 
                then nil
2006
2004
 
                else throw("Strict value is not equal to itself.")
2007
2005
 
            }
2008
2006
 
        else if ((ax > (ci + aN)))
2009
2007
 
            then throw("Your duck is still on delivery mission")
2010
2008
 
            else {
2011
2009
 
                let kw = valueOrElse(getInteger(dc, bO), 0)
2012
2010
 
                let kx = invoke(dc, "updateDeliveryLocked", [(kw - aM)], nil)
2013
2011
 
                if ((kx == kx))
2014
2012
 
                    then if ((0 >= kt))
2015
2013
 
                        then nil
2016
2014
 
                        else [IntegerEntry(T(A), (ci + a))]
2017
2015
 
                    else throw("Strict value is not equal to itself.")
2018
2016
 
                }
2019
2017
 
    let ky = getIntegerValue(J(A))
2020
2018
 
    let kz = getStringValue(K(A))
2021
2019
 
    $Tuple4(ku, [IntegerEntry(ks, ky), StringEntry(bJ(A), kz)], kz, ky)
2022
2020
 
    }
2023
2021
 
2024
2022
 
2025
2023
 
func kA (kB,al,kC,c,kD,kE) = {
2026
2024
 
    let A = valueOrErrorMessage(getString(bH(c)), "You don't have a duck staked")
2027
2025
 
    if (kp(A))
2028
2026
 
        then throw("mergeInternal_checkTournament")
2029
2027
 
        else if (kq(A))
2030
2028
 
            then throw("mergeInternal_checkDelivery")
2031
2029
 
            else {
2032
2030
 
                func kF (eR,P) =                 {
2033
2031
 
                    let js = value(assetInfo(fromBase58String(P)))
2034
2032
 
                    let jt = br(P)
2035
2033
 
                    let ju = valueOrErrorMessage(getInteger(jt), (("NFT " + js.name) + " is not staked"))
2036
2034
 
                    let jv = valueOrErrorMessage(getString(bo(P)), (("NFT " + js.name) + " is orphaned"))
2037
2035
 
                    if ((jv != c))
2038
2036
 
                        then throw((aC + " is not yours"))
2039
2037
 
                        else {
2040
2038
 
                            let jw = split(js.description, "_")
2041
2039
 
                            let dt = jw[dk]
2042
2040
 
                            if (if ((eR._3 != ""))
2043
2041
 
                                then (eR._3 != dt)
2044
2042
 
                                else false)
2045
2043
 
                                then throw("Lands should be on the same continent to merge")
2046
2044
 
                                else {
2047
2045
 
                                    let dI = jw[di]
2048
2046
 
                                    let kG = eR._1
2049
2047
 
                                    let gK = valueOrErrorMessage(indexOf(kG, dI), "You haven't passed all the lands needed")
2050
2048
 
                                    let kH = (take(kG, gK) + drop(kG, (gK + 1)))
2051
2049
 
                                    let ji = dH(dI)
2052
2050
 
                                    let kI = (eR._2 + valueOrElse(getInteger(bs(aE, P)), 0))
2053
2051
 
                                    let ia = valueOrElse(getInteger(by(P)), 0)
2054
2052
 
                                    let kJ = {
2055
2053
 
                                        let cy = dI
2056
2054
 
                                        if (("S" == cy))
2057
2055
 
                                            then 3
2058
2056
 
                                            else if (("M" == cy))
2059
2057
 
                                                then 4
2060
2058
 
                                                else if (("L" == cy))
2061
2059
 
                                                    then 5
2062
2060
 
                                                    else if (("XL" == cy))
2063
2061
 
                                                        then 6
2064
2062
 
                                                        else throw("Only S, M, L, XL can merge")
2065
2063
 
                                        }
2066
2064
 
                                    if ((ia != kJ))
2067
2065
 
                                        then throw("All lands should be maxed to merge")
2068
2066
 
                                        else {
2069
2067
 
                                            let et = jw[dh]
2070
2068
 
                                            let gG = gM(jw[dj])
2071
2069
 
                                            let gQ = (lastBlock.timestamp - ju)
2072
2070
 
                                            if ((0 > gQ))
2073
2071
 
                                                then throw(((("Saved timestamp is in future, saved = " + toString(ju)) + ", current = ") + toString(lastBlock.timestamp)))
2074
2072
 
                                                else {
2075
2073
 
                                                    let jy = jh(P, ji)
2076
2074
 
                                                    let hZ = (ji / cF)
2077
2075
 
                                                    let jG = gO(split(eR._4, "_"), gG, gQ, hZ, jy)
2078
2076
 
                                                    let fb = gE(eR._6, gG, hZ, -1)
2079
2077
 
                                                    let kK = gE(eR._10, gG, hZ, -1)
2080
2078
 
                                                    let hu = gE(eR._9, gG, hZ, 1)
2081
2079
 
                                                    let kL = eR._7
2082
2080
 
                                                    let da = indexOf(kL, P)
2083
2081
 
                                                    if (!(isDefined(da)))
2084
2082
 
                                                        then throw(("Your staked lands don't contain " + P))
2085
2083
 
                                                        else {
2086
2084
 
                                                            let kM = bq(P)
2087
2085
 
                                                            let kN = valueOrElse(getString(kM), "")
2088
2086
 
                                                            $Tuple10(kH, kI, dt, jG, ((((((((((((eR._5 :+ DeleteEntry(br(P))) :+ DeleteEntry(bu(aC, P, c))) :+ DeleteEntry(es(et))) :+ DeleteEntry(bo(P))) :+ DeleteEntry(by(P))) :+ DeleteEntry(eu(P, c))) :+ DeleteEntry(bs(aE, P))) :+ DeleteEntry(ev(et))) :+ DeleteEntry(bx(P))) :+ DeleteEntry(kM)) :+ Burn(fromBase58String(P), 1)) ++ (if ((kN != ""))
2089
2087
 
                                                                then [DeleteEntry(eq(kN))]
2090
2088
 
                                                                else nil)), fb, removeByIndex(kL, value(da)), (eR._8 + ji), hu, kK)
2091
2089
 
                                                            }
2092
2090
 
                                                    }
2093
2091
 
                                            }
2094
2092
 
                                    }
2095
2093
 
                            }
2096
2094
 
                    }
2097
2095
 
2098
2096
 
                let hL = bI(A)
2099
2097
 
                let io = hK(hL)
2100
2098
 
                let gF = split(valueOrElse(getString(dr()), "0_0_0_0_0_0"), "_")
2101
2099
 
                let kO = du(c)
2102
2100
 
                let kP = getString(kO)
2103
2101
 
                let kQ = if (isDefined(kP))
2104
2102
 
                    then split_51C(value(kP), "_")
2105
2103
 
                    else nil
2106
2104
 
                let kR = split(value(assetInfo(fromBase58String(kD[0]))).description, "_")[dk]
2107
2105
 
                let kS = split(valueOrElse(getString(ds(kR)), "0_0_0_0_0_0"), "_")
2108
2106
 
                let fc = {
2109
2107
 
                    let eT = kD
2110
2108
 
                    let eU = size(eT)
2111
2109
 
                    let eV = $Tuple10(kC, 0, "", io[bi], nil, gF, kQ, 0, split("0_0_0_0_0_0", "_"), kS)
2112
2110
 
                    func eW (eX,eY) =                     if ((eY >= eU))
2113
2111
 
                        then eX
2114
2112
 
                        else kF(eX, eT[eY])
2115
2113
 
2116
2114
 
                    func eZ (eX,eY) =                     if ((eY >= eU))
2117
2115
 
                        then eX
2118
2116
 
                        else throw("List size exceeds 5")
2119
2117
 
2120
2118
 
                    eZ(eW(eW(eW(eW(eW(eV, 0), 1), 2), 3), 4), 5)
2121
2119
 
                    }
2122
2120
 
                let dt = fc._3
2123
2121
 
                let ho = valueOrErrorMessage(indexOf(aP, dt), ("Unknown continent: " + dt))
2124
2122
 
                let gN = ht(fc._9, (dH(kB) / cF))
2125
2123
 
                let iM = valueOrElse(getInteger(ep()), (eo + 1))
2126
2124
 
                let kT = toString(iM)
2127
2125
 
                let iN = Issue(eG(kT, kB), makeString([kT, kB, gN, dt], "_"), 1, 0, false)
2128
2126
 
                let bp = calculateAssetId(iN)
2129
2127
 
                let kU = toBase58String(bp)
2130
2128
 
                let jS = makeString(fd((kE > 0), split(io[bj], "_"), kE), "_")
2131
2129
 
                let kV = dv(c)
2132
2130
 
                let kW = valueOrElse(getInteger(kV), 0)
2133
2131
 
                $Tuple2((((((((((((((((fc._5 :+ (if ((size(fc._7) > 0))
2134
2132
 
                    then StringEntry(kO, makeString_11C(fc._7, "_"))
2135
2133
 
                    else DeleteEntry(kO))) :+ IntegerEntry(kV, if ((fc._8 > kW))
2136
2134
 
                    then 0
2137
2135
 
                    else (kW - fc._8))) :+ IntegerEntry(ep(), (iM + 1))) :+ iN) :+ StringEntry(es(kT), kU)) :+ StringEntry(bo(kU), c)) :+ StringEntry(ev(kT), c)) :+ IntegerEntry(bs(aE, kU), fc._2)) :+ IntegerEntry(by(kU), al)) :+ IntegerEntry(eu(kU, c), al)) :+ StringEntry(hL, makeString([io[bh], fc._4, jS, io[bk]], ":"))) :+ StringEntry(dr(), makeString(fc._6, "_"))) :+ StringEntry(ds(dt), makeString(fc._10, "_"))) :+ StringEntry(bJ(A), makeString([dt, "L", kU], "_"))) :+ ScriptTransfer(addressFromStringValue(c), 1, bp)), kU)
2138
2136
 
                }
2139
2137
 
    }
2140
2138
 
2141
2139
 
2142
2140
 
func kX (c,kD) = kA("M", 3, "SSSS", c, kD, 0)
2143
2141
 
2144
2142
 
2145
2143
 
func kY (c,kD) = kA("L", 4, "SMM", c, kD, (cA * 4))
2146
2144
 
2147
2145
 
2148
2146
 
func kZ (c,kD) = kA("XL", 5, "SSSML", c, kD, (cA * 47))
2149
2147
 
2150
2148
 
2151
2149
 
func la (c,kD) = kA("XXL", 6, "LXL", c, kD, (cA * 54))
2152
2150
 
2153
2151
 
2154
2152
 
func lb (c,kD) = {
2155
2153
 
    let cy = size(kD)
2156
2154
 
    if ((4 == cy))
2157
2155
 
        then kX(c, kD)
2158
2156
 
        else if ((3 == cy))
2159
2157
 
            then kY(c, kD)
2160
2158
 
            else if ((5 == cy))
2161
2159
 
                then kZ(c, kD)
2162
2160
 
                else if ((2 == cy))
2163
2161
 
                    then la(c, kD)
2164
2162
 
                    else throw("Unknown merge")
2165
2163
 
    }
2166
2164
 
2167
2165
 
2168
2166
 
func lc (bL) = {
2169
2167
 
    let ld = getString(bH(bL))
2170
2168
 
    if (if (cv)
2171
2169
 
        then isDefined(ld)
2172
2170
 
        else false)
2173
2171
 
        then {
2174
2172
 
            let A = value(ld)
2175
2173
 
            let le = bJ(A)
2176
2174
 
            let cf = split(valueOrElse(getString(le), aJ), "_")
2177
2175
 
            let ci = parseIntValue(cf[bl])
2178
2176
 
            if (if ((cf[bm] != "D"))
2179
2177
 
                then true
2180
2178
 
                else (lastBlock.timestamp > (ci + aN)))
2181
2179
 
                then nil
2182
2180
 
                else {
2183
2181
 
                    let ks = z(A)
2184
2182
 
                    if ((parseIntValue(cf[bn]) >= 3))
2185
2183
 
                        then {
2186
2184
 
                            let kv = invoke(dc, "sendDeliveryReward", [bL], nil)
2187
2185
 
                            if ((kv == kv))
2188
2186
 
                                then nil
2189
2187
 
                                else throw("Strict value is not equal to itself.")
2190
2188
 
                            }
2191
2189
 
                        else (({
2192
2190
 
                            let kw = valueOrElse(getInteger(dc, bO), 0)
2193
2191
 
                            let kx = invoke(dc, "updateDeliveryLocked", [(kw - aM)], nil)
2194
2192
 
                            if ((kx == kx))
2195
2193
 
                                then if ((0 >= getIntegerValue(ks)))
2196
2194
 
                                    then nil
2197
2195
 
                                    else {
2198
2196
 
                                        let lf = invoke(this, "saveInteger", [T(A), (ci + a)], nil)
2199
2197
 
                                        if ((lf == lf))
2200
2198
 
                                            then nil
2201
2199
 
                                            else throw("Strict value is not equal to itself.")
2202
2200
 
                                        }
2203
2201
 
                                else throw("Strict value is not equal to itself.")
2204
2202
 
                            } :+ IntegerEntry(ks, getIntegerValue(J(A)))) :+ StringEntry(le, getStringValue(K(A))))
2205
2203
 
                    }
2206
2204
 
            }
2207
2205
 
        else nil
2208
2206
 
    }
2209
2207
 
2210
2208
 
2211
2209
 
func lg (gK) = if (if ((gK.originCaller != db))
2212
2210
 
    then valueOrElse(getBoolean(dK()), false)
2213
2211
 
    else false)
2214
2212
 
    then throw("Contracts are under maintenance")
2215
2213
 
    else {
2216
2214
 
        let bL = toString(gK.originCaller)
2217
2215
 
        (lc(bL) :+ StringEntry(dL(bL), toBase58String(gK.transactionId)))
2218
2216
 
        }
2219
2217
 
2220
2218
 
2221
2219
 
func lh (gK) = if (if ((gK.originCaller != db))
2222
2220
 
    then valueOrElse(getBoolean(dK()), false)
2223
2221
 
    else false)
2224
2222
 
    then throw("Contracts are under maintenance")
2225
2223
 
    else [StringEntry(dL(toString(gK.originCaller)), toBase58String(gK.transactionId))]
2226
2224
 
2227
2225
 
2228
2226
 
@Callable(gK)
2229
2227
 
func constructorV1 (li) = if ((gK.caller != this))
2230
2228
 
    then throw("Permission denied")
2231
2229
 
    else [StringEntry(cV(), li)]
2232
2230
 
2233
2231
 
2234
2232
 
2235
2233
 
@Callable(gK)
2236
2234
 
func saveInteger (cN,eI) = if ((gK.caller != this))
2237
2235
 
    then throw("saveInteger is not public method")
2238
2236
 
    else [IntegerEntry(cN, eI)]
2239
2237
 
2240
2238
 
2241
2239
 
2242
2240
 
@Callable(gK)
2243
2241
 
func setBlocked (lj) = if ((gK.caller != this))
2244
2242
 
    then throw("permission denied")
2245
2243
 
    else [BooleanEntry(dK(), lj)]
2246
2244
 
2247
2245
 
2248
2246
 
2249
2247
 
@Callable(gK)
2250
2248
 
func stakeLand () = {
2251
2249
 
    let lk = lg(gK)
2252
2250
 
    if ((size(gK.payments) != 1))
2253
2251
 
        then throw("Exactly one payment required")
2254
2252
 
        else {
2255
2253
 
            let ll = value(gK.payments[0])
2256
2254
 
            let bp = value(ll.assetId)
2257
2255
 
            let cM = toString(gK.caller)
2258
2256
 
            if ((ll.amount != 1))
2259
2257
 
                then throw((("NFT " + aC) + " token should be attached as payment"))
2260
2258
 
                else {
2261
2259
 
                    let js = value(assetInfo(bp))
2262
2260
 
                    if ((js.issuer != this))
2263
2261
 
                        then throw("Unknown issuer of token")
2264
2262
 
                        else if (!(contains(js.name, aC)))
2265
2263
 
                            then throw((("Only NFT " + aC) + " tokens are accepted"))
2266
2264
 
                            else {
2267
2265
 
                                let lm = drop(js.name, 4)
2268
2266
 
                                let et = if (contains(lm, "XXL"))
2269
2267
 
                                    then dropRight(lm, 3)
2270
2268
 
                                    else if (contains(lm, "XL"))
2271
2269
 
                                        then dropRight(lm, 2)
2272
2270
 
                                        else dropRight(lm, 1)
2273
2271
 
                                if (!(isDefined(parseInt(et))))
2274
2272
 
                                    then throw(("Cannot parse land number from " + js.name))
2275
2273
 
                                    else {
2276
2274
 
                                        let P = toBase58String(bp)
2277
2275
 
                                        let jt = br(P)
2278
2276
 
                                        if (isDefined(getInteger(jt)))
2279
2277
 
                                            then throw((("NFT " + js.name) + " is already staked"))
2280
2278
 
                                            else {
2281
2279
 
                                                let jw = split(js.description, "_")
2282
2280
 
                                                let gG = gM(jw[dj])
2283
2281
 
                                                let ji = dH(jw[di])
2284
2282
 
                                                let hZ = (ji / cF)
2285
2283
 
                                                let fb = gL(gG, hZ, 1)
2286
2284
 
                                                let ln = ds(jw[dk])
2287
2285
 
                                                let kS = split(valueOrElse(getString(ln), "0_0_0_0_0_0"), "_")
2288
2286
 
                                                let lo = makeString(gE(kS, gG, hZ, 1), "_")
2289
2287
 
                                                let kO = du(cM)
2290
2288
 
                                                let kP = getString(kO)
2291
2289
 
                                                let kL = if (isDefined(kP))
2292
2290
 
                                                    then split_51C(value(kP), "_")
2293
2291
 
                                                    else nil
2294
2292
 
                                                if (containsElement(kL, P))
2295
2293
 
                                                    then throw(("Your staked lands already contain " + P))
2296
2294
 
                                                    else if ((size(kL) >= aG))
2297
2295
 
                                                        then throw((("Your already staked max (" + toString(aG)) + ") lands"))
2298
2296
 
                                                        else {
2299
2297
 
                                                            let ia = valueOrElse(getInteger(by(P)), 0)
2300
2298
 
                                                            let kV = dv(cM)
2301
2299
 
                                                            let lp = valueOrElse(getInteger(kV), 0)
2302
2300
 
                                                            let lq = invoke(de, "onStakeUnstakeLand", [cM], nil)
2303
2301
 
                                                            $Tuple2(([IntegerEntry(jt, lastBlock.timestamp), IntegerEntry(bu(aC, P, cM), lastBlock.timestamp), StringEntry(kO, makeString_11C((kL :+ P), "_")), IntegerEntry(kV, (lp + ji)), StringEntry(bo(P), cM), StringEntry(ev(et), cM), IntegerEntry(eu(P, cM), ia), StringEntry(dr(), fb), StringEntry(ln, lo)] ++ lk), lq)
2304
2302
 
                                                            }
2305
2303
 
                                                }
2306
2304
 
                                        }
2307
2305
 
                                }
2308
2306
 
                    }
2309
2307
 
            }
2310
2308
 
    }
2311
2309
 
2312
2310
 
2313
2311
 
2314
2312
 
@Callable(gK)
2315
2313
 
func unstakeLand (jo) = {
2316
2314
 
    let lk = lg(gK)
2317
2315
 
    if ((size(gK.payments) != 0))
2318
2316
 
        then throw("No payments required")
2319
2317
 
        else {
2320
2318
 
            let c = toString(gK.caller)
2321
2319
 
            let ga = jm(c, eA, jo)
2322
2320
 
            let P = ga._2
2323
2321
 
            let jw = ga._3
2324
2322
 
            let kO = du(c)
2325
2323
 
            let gG = gM(jw[dj])
2326
2324
 
            let ji = dH(jw[di])
2327
2325
 
            let hZ = (ji / cF)
2328
2326
 
            let fb = gL(gG, hZ, -1)
2329
2327
 
            let ln = ds(jw[dk])
2330
2328
 
            let kS = split(valueOrElse(getString(ln), "0_0_0_0_0_0"), "_")
2331
2329
 
            let lo = makeString(gE(kS, gG, hZ, -1), "_")
2332
2330
 
            let jT = jJ(c, P, ji, eA)
2333
2331
 
            let kL = split_51C(valueOrElse(getString(kO), ""), "_")
2334
2332
 
            let da = indexOf(kL, P)
2335
2333
 
            if (!(isDefined(da)))
2336
2334
 
                then throw(("Your staked lands don't contain " + P))
2337
2335
 
                else {
2338
2336
 
                    let ax = lastBlock.timestamp
2339
2337
 
                    let lr = valueOrElse(getInteger(dd, bK(c)), 0)
2340
2338
 
                    if ((lr >= ax))
2341
2339
 
                        then throw(("Your gWL are taking part in voting, cannot unstake until " + toString(lr)))
2342
2340
 
                        else {
2343
2341
 
                            let ls = (valueOrElse(getInteger(de, b(c)), 0) + cB)
2344
2342
 
                            if ((ls > ax))
2345
2343
 
                                then throw(("Your staked lands took part in arbitrage, cannot unstake until " + toString(ls)))
2346
2344
 
                                else {
2347
2345
 
                                    let kV = dv(c)
2348
2346
 
                                    let kW = valueOrElse(getInteger(kV), 0)
2349
2347
 
                                    let lt = if ((ji > kW))
2350
2348
 
                                        then 0
2351
2349
 
                                        else (kW - ji)
2352
2350
 
                                    let lq = invoke(de, "onStakeUnstakeLand", [c], nil)
2353
2351
 
                                    $Tuple2(([ScriptTransfer(gK.caller, 1, fromBase58String(P)), DeleteEntry(br(P)), DeleteEntry(bu(aC, P, c)), StringEntry(dr(), fb), StringEntry(ln, lo), StringEntry(jT._2, makeString(jT._3, ":")), if ((size(kL) > 1))
2354
2352
 
                                        then StringEntry(kO, makeString_11C(removeByIndex(kL, value(da)), "_"))
2355
2353
 
                                        else DeleteEntry(kO), IntegerEntry(kV, lt)] ++ lk), lq)
2356
2354
 
                                    }
2357
2355
 
                            }
2358
2356
 
                    }
2359
2357
 
            }
2360
2358
 
    }
2361
2359
 
2362
2360
 
2363
2361
 
2364
2362
 
@Callable(gK)
2365
2363
 
func stakeDuck () = {
2366
2364
 
    let lk = lg(gK)
2367
2365
 
    if ((size(gK.payments) != 1))
2368
2366
 
        then throw("Exactly one payment required")
2369
2367
 
        else {
2370
2368
 
            let ll = value(gK.payments[0])
2371
2369
 
            let bp = value(ll.assetId)
2372
2370
 
            let cM = toString(gK.caller)
2373
2371
 
            if ((ll.amount != 1))
2374
2372
 
                then throw((("NFT " + aD) + " token should be attached as payment"))
2375
2373
 
                else {
2376
2374
 
                    let js = value(assetInfo(bp))
2377
2375
 
                    if (if ((js.issuer != dX))
2378
2376
 
                        then (js.issuer != dY)
2379
2377
 
                        else false)
2380
2378
 
                        then throw((("Unknown issuer of " + aD) + " token"))
2381
2379
 
                        else if (!(contains(js.name, aD)))
2382
2380
 
                            then throw((("Only NFT " + aD) + " tokens are accepted"))
2383
2381
 
                            else {
2384
2382
 
                                let lu = toBase58String(bp)
2385
2383
 
                                let jt = br(lu)
2386
2384
 
                                if (isDefined(getInteger(jt)))
2387
2385
 
                                    then throw((("NFT " + js.name) + " is already staked"))
2388
2386
 
                                    else if (isDefined(getString(bH(cM))))
2389
2387
 
                                        then throw(("You already staked one duck: " + js.name))
2390
2388
 
                                        else {
2391
2389
 
                                            let le = bJ(lu)
2392
2390
 
                                            let cd = getString(le)
2393
2391
 
                                            let hL = bI(lu)
2394
2392
 
                                            let lv = getString(hL)
2395
2393
 
                                            let jb = z(lu)
2396
2394
 
                                            let jc = ag(valueOrElse(getInteger(D(lu)), 0))
2397
2395
 
                                            let kt = valueOrElse(getInteger(jb), jc)
2398
2396
 
                                            ([IntegerEntry(jt, lastBlock.timestamp), IntegerEntry(bu(aD, toBase58String(bp), cM), lastBlock.timestamp), StringEntry(bG(lu), cM), StringEntry(bH(cM), lu)] ++ (if (isDefined(cd))
2399
2397
 
                                                then nil
2400
2398
 
                                                else ([StringEntry(le, aJ)] ++ (if (isDefined(lv))
2401
2399
 
                                                    then nil
2402
2400
 
                                                    else (([StringEntry(hL, "0:0_0_0_0_0_0:0_0_0_0_0_0:")] :+ IntegerEntry(jb, kt)) ++ lk)))))
2403
2401
 
                                            }
2404
2402
 
                                }
2405
2403
 
                    }
2406
2404
 
            }
2407
2405
 
    }
2408
2406
 
2409
2407
 
2410
2408
 
2411
2409
 
@Callable(gK)
2412
2410
 
func unstakeDuck (lu) = {
2413
2411
 
    let lk = lg(gK)
2414
2412
 
    if ((size(gK.payments) != 0))
2415
2413
 
        then throw("No payments required")
2416
2414
 
        else {
2417
2415
 
            let bp = fromBase58String(lu)
2418
2416
 
            let cM = toString(gK.caller)
2419
2417
 
            let js = value(assetInfo(bp))
2420
2418
 
            let jt = br(lu)
2421
2419
 
            if (!(isDefined(getInteger(jt))))
2422
2420
 
                then throw((("NFT " + js.name) + " is not staked"))
2423
2421
 
                else if (!(isDefined(getString(bH(cM)))))
2424
2422
 
                    then throw((("The duck " + js.name) + " is not staked"))
2425
2423
 
                    else {
2426
2424
 
                        let jv = valueOrErrorMessage(getString(bG(lu)), (("NFT " + js.name) + " is orphaned"))
2427
2425
 
                        if ((jv != cM))
2428
2426
 
                            then throw("Staked NFT is not yours")
2429
2427
 
                            else if (kp(lu))
2430
2428
 
                                then throw("unstakeDuck_checkTournament")
2431
2429
 
                                else if (kq(lu))
2432
2430
 
                                    then throw("unstakeDuck_checkDelivery")
2433
2431
 
                                    else {
2434
2432
 
                                        let jb = z(lu)
2435
2433
 
                                        let jc = ag(valueOrElse(getInteger(D(lu)), 0))
2436
2434
 
                                        let as = valueOrElse(getInteger(jb), jc)
2437
2435
 
                                        if ((jc > as))
2438
2436
 
                                            then throw((("Please heal your duck to " + toString(jc)) + "hp before unstaking"))
2439
2437
 
                                            else ([ScriptTransfer(gK.caller, 1, bp), DeleteEntry(jt), DeleteEntry(jb), DeleteEntry(bJ(lu)), DeleteEntry(bG(lu)), DeleteEntry(bu(aD, lu, cM)), DeleteEntry(bH(cM))] ++ lk)
2440
2438
 
                                        }
2441
2439
 
                        }
2442
2440
 
            }
2443
2441
 
    }
2444
2442
 
2445
2443
 
2446
2444
 
2447
2445
 
@Callable(gK)
2448
2446
 
func claimRes (eI,lw) = {
2449
2447
 
    let lk = lg(gK)
2450
2448
 
    if ((size(gK.payments) != 0))
2451
2449
 
        then throw("No payments required")
2452
2450
 
        else {
2453
2451
 
            let c = toString(gK.originCaller)
2454
2452
 
            let fj = jx(c, eI, eA, lw)
2455
2453
 
            let A = valueOrErrorMessage(getString(bH(c)), "You don't have a duck staked")
2456
2454
 
            $Tuple2(((((fj._1 ++ jZ(A, fraction(U, eI, cE))._1) :+ StringEntry(fj._2, makeString(fj._3, ":"))) :+ StringEntry(fj._4, makeString(fj._5, ":"))) ++ lk), fj._3[bi])
2457
2455
 
            }
2458
2456
 
    }
2459
2457
 
2460
2458
 
2461
2459
 
2462
2460
 
@Callable(gK)
2463
2461
 
func claimResToWH (eI,lw) = {
2464
2462
 
    let lk = lg(gK)
2465
2463
 
    if ((size(gK.payments) != 0))
2466
2464
 
        then throw("No payments required")
2467
2465
 
        else {
2468
2466
 
            let c = toString(gK.originCaller)
2469
2467
 
            let fj = jx(c, eI, ez, lw)
2470
2468
 
            $Tuple2(((((fj._1 ++ kf(c, fraction(U, eI, cE))._1) :+ StringEntry(fj._2, makeString(fj._3, ":"))) :+ StringEntry(fj._4, makeString(fj._5, ":"))) ++ lk), fj._5[aZ])
2471
2469
 
            }
2472
2470
 
    }
2473
2471
 
2474
2472
 
2475
2473
 
2476
2474
 
@Callable(gK)
2477
2475
 
func flight (iQ,iR) = {
2478
2476
 
    let lk = lh(gK)
2479
2477
 
    if ((size(gK.payments) != 0))
2480
2478
 
        then throw("No payments required")
2481
2479
 
        else {
2482
2480
 
            let bL = toString(gK.caller)
2483
2481
 
            let hp = iP(bL, iQ, iR)
2484
2482
 
            let iV = hp._1
2485
2483
 
            let A = hp._2
2486
2484
 
            let le = bJ(A)
2487
2485
 
            let jq = valueOrElse(getString(le), aJ)
2488
2486
 
            let iX = hp._4
2489
2487
 
            if ((iX == jq))
2490
2488
 
                then throw("You can't fly to the same location")
2491
2489
 
                else {
2492
2490
 
                    let cr = split(iX, "_")
2493
2491
 
                    let lx = (cr[bm] == "T")
2494
2492
 
                    let ly = (cr[bm] == "D")
2495
2493
 
                    let gx = F(A)
2496
2494
 
                    let lz = valueOrElse(getString(gx), ",;,_,;,_,;,_,;,_,;,_,;,")
2497
2495
 
                    let lA = fk(lz, hp._5)
2498
2496
 
                    let lB = lA._1
2499
2497
 
                    let lC = lA._2
2500
-
                    let lD = if (cm(df, jq))
2498
+
                    let lD = if (!(cm(df, jq)))
2501
2499
 
                        then if (!(ck(iX)))
2502
2500
 
                            then cp(jq, iX, 5)
2503
2501
 
                            else if ((iV > 0))
2504
2502
 
                                then $Tuple2(iX, iV)
2505
2503
 
                                else $Tuple2(jq, 0)
2506
2504
 
                        else if (cc(df, jq))
2507
2505
 
                            then if (!(cc(df, iX)))
2508
2506
 
                                then throw("Your duck is taking part in the tournament")
2509
2507
 
                                else {
2510
2508
 
                                    let lE = parseIntValue(cr[bn])
2511
2509
 
                                    let lF = split(jq, "_")
2512
2510
 
                                    let ce = valueOrElse(getInteger(df, bP), 0)
2513
2511
 
                                    if ((lE != (parseIntValue(lF[bn]) + 1)))
2514
2512
 
                                        then cp(jq, iX, 7)
2515
2513
 
                                        else if ((iV > 0))
2516
2514
 
                                            then {
2517
2515
 
                                                let lG = valueOrElse(getInteger(df, bT(ce, A)), 0)
2518
2516
 
                                                let lH = if ((lE > lG))
2519
2517
 
                                                    then invoke(df, "saveDuckResult", [A, lE], nil)
2520
2518
 
                                                    else unit
2521
2519
 
                                                if ((lH == lH))
2522
2520
 
                                                    then $Tuple2(iX, iV)
2523
2521
 
                                                    else throw("Strict value is not equal to itself.")
2524
2522
 
                                                }
2525
2523
 
                                            else $Tuple2(jq, 0)
2526
2524
 
                                    }
2527
2525
 
                            else if (!(ch(jq)))
2528
2526
 
                                then {
2529
2527
 
                                    let lI = dE(invoke(this, "autoExitDelivery", [A], nil))
2530
2528
 
                                    if ((lI == lI))
2531
2529
 
                                        then if (ly)
2532
2530
 
                                            then lI
2533
2531
 
                                            else if ((iV > 0))
2534
2532
 
                                                then $Tuple2(iX, iV)
2535
2533
 
                                                else $Tuple2(lI._1, 0)
2536
2534
 
                                        else throw("Strict value is not equal to itself.")
2537
2535
 
                                    }
2538
2536
 
                                else if (!(ly))
2539
2537
 
                                    then throw("Your duck is taking part in delivery")
2540
2538
 
                                    else if (!(ch(iX)))
2541
2539
 
                                        then cp(jq, iX, 13)
2542
2540
 
                                        else {
2543
2541
 
                                            let lE = parseIntValue(cr[bn])
2544
2542
 
                                            let lF = split(jq, "_")
2545
2543
 
                                            if ((lE != (parseIntValue(lF[bn]) + 1)))
2546
2544
 
                                                then cp(jq, iX, 14)
2547
2545
 
                                                else if (if ((iV > 0))
2548
2546
 
                                                    then (3 > lE)
2549
2547
 
                                                    else false)
2550
2548
 
                                                    then $Tuple2(iX, iV)
2551
2549
 
                                                    else {
2552
2550
 
                                                        let lI = dE(invoke(this, "autoExitDelivery", [A], nil))
2553
2551
 
                                                        if ((lI == lI))
2554
2552
 
                                                            then lI
2555
2553
 
                                                            else throw("Strict value is not equal to itself.")
2556
2554
 
                                                        }
2557
2555
 
                                            }
2558
2556
 
                    let lJ = lD._1
2559
2557
 
                    let lK = lD._2
2560
2558
 
                    $Tuple2(((([StringEntry(le, lJ), StringEntry(gx, lB), IntegerEntry(z(A), iV)] ++ lk) ++ (if (lC)
2561
2559
 
                        then [StringEntry(L(A), "0_0_0_0_0")]
2562
2560
 
                        else nil)) ++ jZ(A, if ((iV > 0))
2563
2561
 
                        then V
2564
2562
 
                        else W)._1), hp._3)
2565
2563
 
                    }
2566
2564
 
            }
2567
2565
 
    }
2568
2566
 
2569
2567
 
2570
2568
 
2571
2569
 
@Callable(gK)
2572
2570
 
func heal (lL,lM,lN) = {
2573
2571
 
    let lk = lg(gK)
2574
2572
 
    if (if (if ((0 > lL))
2575
2573
 
        then true
2576
2574
 
        else (0 > lM))
2577
2575
 
        then true
2578
2576
 
        else (0 > lN))
2579
2577
 
        then throw("Quantity cannot be negative")
2580
2578
 
        else {
2581
2579
 
            let A = valueOrErrorMessage(getString(bH(toString(gK.caller))), "You don't have a duck staked")
2582
2580
 
            if (kp(A))
2583
2581
 
                then throw("heal_checkTournament")
2584
2582
 
                else if (kq(A))
2585
2583
 
                    then throw("heal_checkDelivery")
2586
2584
 
                    else {
2587
2585
 
                        let lO = [lL, lM, lN]
2588
2586
 
                        let jb = z(A)
2589
2587
 
                        let jc = ag(valueOrElse(getInteger(D(A)), 0))
2590
2588
 
                        let lP = valueOrElse(getInteger(jb), jc)
2591
2589
 
                        if ((lP >= jc))
2592
2590
 
                            then throw((("HP should be < " + toString(jc)) + " to heal"))
2593
2591
 
                            else {
2594
2592
 
                                let hL = bI(A)
2595
2593
 
                                let io = hK(hL)
2596
2594
 
                                let lQ = if ((io[bk] == ""))
2597
2595
 
                                    then nil
2598
2596
 
                                    else split_4C(io[bk], "_")
2599
2597
 
                                func lR (eR,co) =                                 {
2600
2598
 
                                    let dA = eR._2
2601
2599
 
                                    let hg = if ((size(lQ) > dA))
2602
2600
 
                                        then parseIntValue(lQ[dA])
2603
2601
 
                                        else 0
2604
2602
 
                                    if ((3 > dA))
2605
2603
 
                                        then {
2606
2604
 
                                            let lS = lO[dA]
2607
2605
 
                                            if ((lS > hg))
2608
2606
 
                                                then throw(((("You have only " + toString(hg)) + " of ") + aO[dA]))
2609
2607
 
                                                else $Tuple3((eR._1 :+ toString((hg - lS))), (dA + 1), (eR._3 + (parseIntValue(split(co, "_")[aU]) * lS)))
2610
2608
 
                                            }
2611
2609
 
                                        else $Tuple3((eR._1 :+ toString(hg)), (dA + 1), eR._3)
2612
2610
 
                                    }
2613
2611
 
2614
2612
 
                                let fj = {
2615
2613
 
                                    let eT = aS
2616
2614
 
                                    let eU = size(eT)
2617
2615
 
                                    let eV = $Tuple3(nil, 0, 0)
2618
2616
 
                                    func eW (eX,eY) =                                     if ((eY >= eU))
2619
2617
 
                                        then eX
2620
2618
 
                                        else lR(eX, eT[eY])
2621
2619
 
2622
2620
 
                                    func eZ (eX,eY) =                                     if ((eY >= eU))
2623
2621
 
                                        then eX
2624
2622
 
                                        else throw("List size exceeds 50")
2625
2623
 
2626
2624
 
                                    eZ(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eV, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50)
2627
2625
 
                                    }
2628
2626
 
                                let lT = min([jc, (lP + fj._3)])
2629
2627
 
                                $Tuple2((([IntegerEntry(jb, lT), StringEntry(hL, makeString_2C([io[bh], io[bi], io[bj], makeString(fj._1, "_")], ":"))] ++ lk) ++ jZ(A, (ad * ((lL + lM) + lN)))._1), lT)
2630
2628
 
                                }
2631
2629
 
                        }
2632
2630
 
            }
2633
2631
 
    }
2634
2632
 
2635
2633
 
2636
2634
 
2637
2635
 
@Callable(gK)
2638
2636
 
func healES () = {
2639
2637
 
    let lk = lg(gK)
2640
2638
 
    if ((size(gK.payments) != 1))
2641
2639
 
        then throw("Exactly one payment required")
2642
2640
 
        else {
2643
2641
 
            let ll = value(gK.payments[0])
2644
2642
 
            if ((ll.assetId != cx))
2645
2643
 
                then throw("Allowed USDT payment only!")
2646
2644
 
                else {
2647
2645
 
                    let A = valueOrErrorMessage(getString(bH(toString(gK.caller))), "You don't have a duck staked")
2648
2646
 
                    if (kp(A))
2649
2647
 
                        then throw("healES_checkTournament")
2650
2648
 
                        else if (kq(A))
2651
2649
 
                            then throw("healES_checkDelivery")
2652
2650
 
                            else {
2653
2651
 
                                let jb = z(A)
2654
2652
 
                                let jc = ag(valueOrElse(getInteger(D(A)), 0))
2655
2653
 
                                let lP = valueOrElse(getInteger(jb), jc)
2656
2654
 
                                if ((lP > 0))
2657
2655
 
                                    then throw("HP should be 0 to call Emergency Service")
2658
2656
 
                                    else {
2659
2657
 
                                        let hL = bI(A)
2660
2658
 
                                        let io = hK(hL)
2661
2659
 
                                        let lQ = if ((io[bk] == ""))
2662
2660
 
                                            then nil
2663
2661
 
                                            else split_4C(io[bk], "_")
2664
2662
 
                                        let lU = if ((size(lQ) > 0))
2665
2663
 
                                            then parseIntValue(lQ[0])
2666
2664
 
                                            else 0
2667
2665
 
                                        let lV = if ((size(lQ) > 1))
2668
2666
 
                                            then parseIntValue(lQ[1])
2669
2667
 
                                            else 0
2670
2668
 
                                        let lW = if ((size(lQ) > 2))
2671
2669
 
                                            then parseIntValue(lQ[2])
2672
2670
 
                                            else 0
2673
2671
 
                                        if (if (if ((lU > 0))
2674
2672
 
                                            then true
2675
2673
 
                                            else (lV > 0))
2676
2674
 
                                            then true
2677
2675
 
                                            else (lW > 0))
2678
2676
 
                                            then throw("You have to use own Medical Kit")
2679
2677
 
                                            else {
2680
2678
 
                                                let lX = getString(dc, bM())
2681
2679
 
                                                let lY = if (isDefined(lX))
2682
2680
 
                                                    then split_4C(value(lX), "_")
2683
2681
 
                                                    else nil
2684
2682
 
                                                let lZ = if ((size(lY) > 0))
2685
2683
 
                                                    then parseIntValue(lY[0])
2686
2684
 
                                                    else 0
2687
2685
 
                                                if ((0 >= lZ))
2688
2686
 
                                                    then throw("There are no Medical Kits L1 at Emergency Service storage")
2689
2687
 
                                                    else {
2690
2688
 
                                                        let lT = (lP + parseIntValue(split(aS[0], "_")[aU]))
2691
2689
 
                                                        let ma = makeString([toString((lZ - 1)), removeByIndex(lY, 0)], "_")
2692
2690
 
                                                        let co = split(aS[0], "_")
2693
2691
 
                                                        let mb = cn(co)
2694
2692
 
                                                        let mc = fraction((mb * aL), aK, (cE * aX))
2695
2693
 
                                                        if ((ll.amount != mc))
2696
2694
 
                                                            then throw(("Payment attached should be " + toString(mc)))
2697
2695
 
                                                            else {
2698
2696
 
                                                                let fj = dw(invoke(dc, "updateEsStorage", [ma], [AttachedPayment(cx, mc)]))
2699
2697
 
                                                                $Tuple2(((lk :+ IntegerEntry(jb, lT)) ++ jZ(A, X)._1), fj)
2700
2698
 
                                                                }
2701
2699
 
                                                        }
2702
2700
 
                                                }
2703
2701
 
                                        }
2704
2702
 
                                }
2705
2703
 
                    }
2706
2704
 
            }
2707
2705
 
    }
2708
2706
 
2709
2707
 
2710
2708
 
2711
2709
 
@Callable(gK)
2712
2710
 
func updateBackpack (A,md) = if ((gK.caller != dc))
2713
2711
 
    then throw("permission denied")
2714
2712
 
    else $Tuple2([StringEntry(bI(A), md)], md)
2715
2713
 
2716
2714
 
2717
2715
 
2718
2716
 
@Callable(gK)
2719
2717
 
func commitForRandom () = {
2720
2718
 
    let lk = lg(gK)
2721
2719
 
    let me = (height + dp)
2722
2720
 
    let c = toString(gK.caller)
2723
2721
 
    $Tuple2(([IntegerEntry(dq(c), me)] ++ lk), me)
2724
2722
 
    }
2725
2723
 
2726
2724
 
2727
2725
 
2728
2726
 
@Callable(gK)
2729
2727
 
func buySLand () = {
2730
2728
 
    let lk = lg(gK)
2731
2729
 
    if ((size(gK.payments) != 1))
2732
2730
 
        then throw("Exactly one payment required")
2733
2731
 
        else {
2734
2732
 
            let ll = value(gK.payments[0])
2735
2733
 
            if ((ll.assetId != cx))
2736
2734
 
                then throw("Allowed USDT payment only!")
2737
2735
 
                else if ((ll.amount != eg))
2738
2736
 
                    then throw(("Payment attached should be " + toString(eg)))
2739
2737
 
                    else {
2740
2738
 
                        let fj = iI(gK.caller, gK.transactionId)
2741
2739
 
                        let mf = dz(invoke(dg, "burnAcres", [eh], nil))
2742
2740
 
                        $Tuple2((((fj._1 :+ ScriptTransfer(dc, ll.amount, cx)) ++ kf(toString(gK.caller), Z)._1) ++ lk), $Tuple2(fj._2._1, mf))
2743
2741
 
                        }
2744
2742
 
            }
2745
2743
 
    }
2746
2744
 
2747
2745
 
2748
2746
 
2749
2747
 
@Callable(gK)
2750
2748
 
func expedition (iQ,iR) = {
2751
2749
 
    let lk = lg(gK)
2752
2750
 
    if ((size(gK.payments) != 0))
2753
2751
 
        then throw("No payments required")
2754
2752
 
        else {
2755
2753
 
            let bL = toString(gK.caller)
2756
2754
 
            let hp = iP(bL, iQ, iR)
2757
2755
 
            let A = hp._2
2758
2756
 
            let jb = z(A)
2759
2757
 
            let hL = bI(A)
2760
2758
 
            let io = hK(hL)
2761
2759
 
            let jQ = split(io[bj], "_")
2762
2760
 
            let jS = makeString(fd(true, jQ, ef), "_")
2763
2761
 
            let gx = F(A)
2764
2762
 
            let lz = valueOrElse(getString(gx), ",;,_,;,_,;,_,;,_,;,_,;,")
2765
2763
 
            let mg = fk(lz, hp._5)
2766
2764
 
            let lB = mg._1
2767
2765
 
            let lC = mg._2
2768
2766
 
            let mh = iI(gK.caller, gK.transactionId)
2769
2767
 
            let iO = mh._2._1
2770
2768
 
            let fj = if ((0 >= hp._1))
2771
2769
 
                then $Tuple3([IntegerEntry(jb, 0), StringEntry(gx, lB)], "", 0)
2772
2770
 
                else $Tuple3((mh._1 ++ (if (lC)
2773
2771
 
                    then [StringEntry(L(A), "0_0_0_0_0")]
2774
2772
 
                    else ((((nil :+ StringEntry(bJ(A), makeString([mh._2._2, "L", iO], "_"))) :+ IntegerEntry(jb, hp._1)) :+ StringEntry(gx, lB)) :+ StringEntry(hL, makeString([io[bh], io[bi], jS, io[bk]], ":"))))), iO, hp._3)
2775
2773
 
            if (kp(A))
2776
2774
 
                then throw("expedition_checkTournament")
2777
2775
 
                else if (kq(A))
2778
2776
 
                    then throw("expedition_checkDelivery")
2779
2777
 
                    else {
2780
2778
 
                        let mf = dz(invoke(dg, "burnAcres", [eh], nil))
2781
2779
 
                        $Tuple2(((fj._1 ++ jZ(A, Z)._1) ++ lk), $Tuple3(fj._2, fj._3, mf))
2782
2780
 
                        }
2783
2781
 
            }
2784
2782
 
    }
2785
2783
 
2786
2784
 
2787
2785
 
2788
2786
 
@Callable(gK)
2789
2787
 
func buySLandForAcres () = {
2790
2788
 
    let lk = lg(gK)
2791
2789
 
    if ((size(gK.payments) != 1))
2792
2790
 
        then throw("exactly 1 payment must be attached")
2793
2791
 
        else {
2794
2792
 
            let ll = gK.payments[0]
2795
2793
 
            let fq = ll.amount
2796
2794
 
            if (if (!(isDefined(ll.assetId)))
2797
2795
 
                then true
2798
2796
 
                else (value(ll.assetId) != do))
2799
2797
 
                then throw("ACRES payments only!")
2800
2798
 
                else if ((fq != eh))
2801
2799
 
                    then throw(("Payment attached should be " + toString(eh)))
2802
2800
 
                    else {
2803
2801
 
                        let fj = iI(gK.caller, gK.transactionId)
2804
2802
 
                        let mf = dz(invoke(dg, "burnAcres", [eh], [AttachedPayment(do, fq)]))
2805
2803
 
                        $Tuple2(((fj._1 ++ kf(toString(gK.caller), Z)._1) ++ lk), $Tuple2(fj._2._1, mf))
2806
2804
 
                        }
2807
2805
 
            }
2808
2806
 
    }
2809
2807
 
2810
2808
 
2811
2809
 
2812
2810
 
@Callable(gK)
2813
2811
 
func upgradeInfra (P) = {
2814
2812
 
    let lk = lg(gK)
2815
2813
 
    if ((size(gK.payments) != 0))
2816
2814
 
        then throw("No payments required")
2817
2815
 
        else {
2818
2816
 
            let fj = jK(true, gK.caller, 0, P)
2819
2817
 
            let A = valueOrErrorMessage(getString(bH(toString(gK.caller))), "You don't have a duck staked")
2820
2818
 
            $Tuple2(((fj._1 ++ lk) ++ jZ(A, fraction(aa, fj._3, cE))._1), fj._2)
2821
2819
 
            }
2822
2820
 
    }
2823
2821
 
2824
2822
 
2825
2823
 
2826
2824
 
@Callable(gK)
2827
2825
 
func activateArtifact (mi,mj) = {
2828
2826
 
    let lk = lg(gK)
2829
2827
 
    if ((size(gK.payments) != 0))
2830
2828
 
        then throw("No payments required")
2831
2829
 
        else {
2832
2830
 
            let c = toString(gK.caller)
2833
2831
 
            let fj = {
2834
2832
 
                let cy = mi
2835
2833
 
                if (("PRESALE" == cy))
2836
2834
 
                    then kn(c, mj)
2837
2835
 
                    else if (("ONBOARD" == cy))
2838
2836
 
                        then kg(c)
2839
2837
 
                        else throw("Unknown artifact")
2840
2838
 
                }
2841
2839
 
            (fj ++ lk)
2842
2840
 
            }
2843
2841
 
    }
2844
2842
 
2845
2843
 
2846
2844
 
2847
2845
 
@Callable(gK)
2848
2846
 
func mergeLands (kD) = {
2849
2847
 
    let lk = lg(gK)
2850
2848
 
    if ((size(gK.payments) != 0))
2851
2849
 
        then throw("No payments required")
2852
2850
 
        else {
2853
2851
 
            let fj = lb(toString(gK.caller), kD)
2854
2852
 
            $Tuple2(((fj._1 ++ lk) ++ kf(toString(gK.caller), ab)._1), fj._2)
2855
2853
 
            }
2856
2854
 
    }
2857
2855
 
2858
2856
 
2859
2857
 
2860
2858
 
@Callable(gK)
2861
2859
 
func cargoExchange (mk,P) = {
2862
2860
 
    let lk = lg(gK)
2863
2861
 
    if ((size(gK.payments) != 0))
2864
2862
 
        then throw("No payments required")
2865
2863
 
        else {
2866
2864
 
            let in = split_4C(mk, ":")
2867
2865
 
            let c = toString(gK.originCaller)
2868
2866
 
            let js = value(assetInfo(fromBase58String(P)))
2869
2867
 
            let jt = br(P)
2870
2868
 
            if (!(isDefined(getInteger(jt))))
2871
2869
 
                then throw((js.name + " is not staked"))
2872
2870
 
                else {
2873
2871
 
                    let jv = valueOrErrorMessage(getString(bo(P)), (("NFT " + js.name) + " is orphaned"))
2874
2872
 
                    if ((jv != c))
2875
2873
 
                        then throw((aC + " is not yours"))
2876
2874
 
                        else {
2877
2875
 
                            let hZ = (dH(split(js.description, "_")[di]) / cF)
2878
2876
 
                            let ia = valueOrElse(getInteger(by(P)), 0)
2879
2877
 
                            let A = valueOrErrorMessage(getString(bH(c)), "You don't have a duck staked")
2880
2878
 
                            let jq = valueOrElse(getString(bJ(A)), aJ)
2881
2879
 
                            let cf = split(value(jq), "_")
2882
2880
 
                            if ((cf[bm] != "L"))
2883
2881
 
                                then throw((("Duck location type is " + cf[bm]) + ", but should be L"))
2884
2882
 
                                else if ((cf[bn] != P))
2885
2883
 
                                    then throw(("Duck should be on the land " + P))
2886
2884
 
                                    else {
2887
2885
 
                                        let hY = bx(P)
2888
2886
 
                                        let hP = hX(hY, hZ, ia)
2889
2887
 
                                        let hL = bI(A)
2890
2888
 
                                        let io = hK(hL)
2891
2889
 
                                        let fj = im(in, hP, io)
2892
2890
 
                                        let ig = split(hP[bc], "_")
2893
2891
 
                                        let jH = (parseIntValue(ig[be]) + fj._7)
2894
2892
 
                                        let jI = (parseIntValue(ig[bf]) - fj._7)
2895
2893
 
                                        ([StringEntry(hL, makeString_2C([io[bh], fj._4, fj._5, fj._6], ":")), StringEntry(hY, makeString_2C([hP[aY], fj._1, fj._2, fj._3, makeString([ig[bd], toString(jH), toString(jI), ig[bg]], "_")], ":"))] ++ lk)
2896
2894
 
                                        }
2897
2895
 
                            }
2898
2896
 
                    }
2899
2897
 
            }
2900
2898
 
    }
2901
2899
 
2902
2900
 
2903
2901
 
2904
2902
 
@Callable(gK)
2905
2903
 
func saveWarehouse (ic,P) = if ((gK.caller != dc))
2906
2904
 
    then throw("Access denied")
2907
2905
 
    else {
2908
2906
 
        let hY = bx(P)
2909
2907
 
        let id = split_4C(ic, ":")
2910
2908
 
        if ((size(id) != 5))
2911
2909
 
            then throw("warehouse string should contain 4 ':' separators")
2912
2910
 
            else {
2913
2911
 
                let ml = split(id[bc], "_")[bd]
2914
2912
 
                let jH = hO(id)
2915
2913
 
                let mm = hM(id[aY])
2916
2914
 
                let jI = ((mm - parseIntValue(ml)) - jH)
2917
2915
 
                let mn = makeString_2C([id[aY], id[aZ], id[ba], id[bb], makeString([ml, toString(jH), toString(jI), toString(mm)], "_")], ":")
2918
2916
 
                $Tuple2([StringEntry(hY, mn)], mn)
2919
2917
 
                }
2920
2918
 
        }
2921
2919
 
2922
2920
 
2923
2921
 
2924
2922
 
@Callable(gK)
2925
2923
 
func fixWarehouseFormat (P) = if ((gK.caller != db))
2926
2924
 
    then throw("Access denied")
2927
2925
 
    else {
2928
2926
 
        let hY = bx(P)
2929
2927
 
        let js = value(assetInfo(fromBase58String(P)))
2930
2928
 
        let hZ = (dH(split(js.description, "_")[di]) / cF)
2931
2929
 
        let ia = valueOrElse(getInteger(by(P)), 0)
2932
2930
 
        let id = hX(hY, hZ, ia)
2933
2931
 
        let ml = dz(invoke(dc, "recalcLockedVolumeREADONLY", [P, id], nil))
2934
2932
 
        let jH = hO(id)
2935
2933
 
        let mm = hM(id[aY])
2936
2934
 
        let jI = ((mm - ml) - jH)
2937
2935
 
        let mn = makeString_2C([id[aY], id[aZ], id[ba], id[bb], makeString([toString(ml), toString(jH), toString(jI), toString(mm)], "_")], ":")
2938
2936
 
        $Tuple2([StringEntry(hY, mn)], mn)
2939
2937
 
        }
2940
2938
 
2941
2939
 
2942
2940
 
2943
2941
 
@Callable(gK)
2944
2942
 
func fixContinentProportions (kD) = if ((gK.caller != db))
2945
2943
 
    then throw("Access denied")
2946
2944
 
    else {
2947
2945
 
        func mo (eR,mp) =         (eR :+ valueOrElse(getString(ds(mp)), "0_0_0_0_0_0"))
2948
2946
 
2949
2947
 
        let gu = {
2950
2948
 
            let eT = aP
2951
2949
 
            let eU = size(eT)
2952
2950
 
            let eV = nil
2953
2951
 
            func eW (eX,eY) =             if ((eY >= eU))
2954
2952
 
                then eX
2955
2953
 
                else mo(eX, eT[eY])
2956
2954
 
2957
2955
 
            func eZ (eX,eY) =             if ((eY >= eU))
2958
2956
 
                then eX
2959
2957
 
                else throw("List size exceeds 5")
2960
2958
 
2961
2959
 
            eZ(eW(eW(eW(eW(eW(eV, 0), 1), 2), 3), 4), 5)
2962
2960
 
            }
2963
2961
 
        func mq (eR,P) =         {
2964
2962
 
            let js = value(assetInfo(fromBase58String(P)))
2965
2963
 
            let jw = split(js.description, "_")
2966
2964
 
            let hZ = (dH(jw[di]) / cF)
2967
2965
 
            let mp = jw[dk]
2968
2966
 
            let gG = gM(jw[dj])
2969
2967
 
            let ho = value(indexOf(aP, mp))
2970
2968
 
            let kS = split(eR[ho], "_")
2971
2969
 
            let mr = makeString(gE(kS, gG, hZ, 1), "_")
2972
2970
 
            let cy = mp
2973
2971
 
            if (("Americas" == cy))
2974
2972
 
                then [mr, eR[1], eR[2], eR[3], eR[4]]
2975
2973
 
                else if (("Europe" == cy))
2976
2974
 
                    then [eR[0], mr, eR[2], eR[3], eR[4]]
2977
2975
 
                    else if (("Asia" == cy))
2978
2976
 
                        then [eR[0], eR[1], mr, eR[3], eR[4]]
2979
2977
 
                        else if (("Africa" == cy))
2980
2978
 
                            then [eR[0], eR[1], eR[2], mr, eR[4]]
2981
2979
 
                            else if (("Oceania" == cy))
2982
2980
 
                                then [eR[0], eR[1], eR[2], eR[3], mr]
2983
2981
 
                                else throw("wrong continent")
2984
2982
 
            }
2985
2983
 
2986
2984
 
        let fc = {
2987
2985
 
            let eT = kD
2988
2986
 
            let eU = size(eT)
2989
2987
 
            let eV = gu
2990
2988
 
            func hF (eX,eY) =             if ((eY >= eU))
2991
2989
 
                then eX
2992
2990
 
                else mq(eX, eT[eY])
2993
2991
 
2994
2992
 
            func hG (eX,eY) =             if ((eY >= eU))
2995
2993
 
                then eX
2996
2994
 
                else throw("List size exceeds 100")
2997
2995
 
2998
2996
 
            hG(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(hF(eV, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50), 51), 52), 53), 54), 55), 56), 57), 58), 59), 60), 61), 62), 63), 64), 65), 66), 67), 68), 69), 70), 71), 72), 73), 74), 75), 76), 77), 78), 79), 80), 81), 82), 83), 84), 85), 86), 87), 88), 89), 90), 91), 92), 93), 94), 95), 96), 97), 98), 99), 100)
2999
2997
 
            }
3000
2998
 
        $Tuple2([StringEntry(ds("Americas"), fc[0]), StringEntry(ds("Europe"), fc[1]), StringEntry(ds("Asia"), fc[2]), StringEntry(ds("Africa"), fc[3]), StringEntry(ds("Oceania"), fc[4])], 0)
3001
2999
 
        }
3002
3000
 
3003
3001
 
3004
3002
 
3005
3003
 
@Callable(gK)
3006
3004
 
func fixStakedPieces (cM) = if ((gK.caller != db))
3007
3005
 
    then throw("Access denied")
3008
3006
 
    else {
3009
3007
 
        let kW = if ((cM == ""))
3010
3008
 
            then 0
3011
3009
 
            else {
3012
3010
 
                let kP = getString(an, du(cM))
3013
3011
 
                let kL = if (isDefined(kP))
3014
3012
 
                    then split_51C(value(kP), "_")
3015
3013
 
                    else nil
3016
3014
 
                func ms (eR,P) =                 {
3017
3015
 
                    let js = value(assetInfo(fromBase58String(P)))
3018
3016
 
                    let dI = split(js.description, "_")[di]
3019
3017
 
                    (eR + dH(dI))
3020
3018
 
                    }
3021
3019
 
3022
3020
 
                let eT = kL
3023
3021
 
                let eU = size(eT)
3024
3022
 
                let eV = 0
3025
3023
 
                func eW (eX,eY) =                 if ((eY >= eU))
3026
3024
 
                    then eX
3027
3025
 
                    else ms(eX, eT[eY])
3028
3026
 
3029
3027
 
                func eZ (eX,eY) =                 if ((eY >= eU))
3030
3028
 
                    then eX
3031
3029
 
                    else throw("List size exceeds 100")
3032
3030
 
3033
3031
 
                eZ(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eV, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50), 51), 52), 53), 54), 55), 56), 57), 58), 59), 60), 61), 62), 63), 64), 65), 66), 67), 68), 69), 70), 71), 72), 73), 74), 75), 76), 77), 78), 79), 80), 81), 82), 83), 84), 85), 86), 87), 88), 89), 90), 91), 92), 93), 94), 95), 96), 97), 98), 99), 100)
3034
3032
 
                }
3035
3033
 
        $Tuple2([IntegerEntry(dv(cM), kW)], kW)
3036
3034
 
        }
3037
3035
 
3038
3036
 
3039
3037
 
3040
3038
 
@Callable(gK)
3041
3039
 
func setCustomName (bp,kN,bt) = {
3042
3040
 
    let lk = lg(gK)
3043
3041
 
    if ((size(gK.payments) != 1))
3044
3042
 
        then throw("Exactly one payment required")
3045
3043
 
        else {
3046
3044
 
            let ll = value(gK.payments[0])
3047
3045
 
            if ((ll.assetId != cx))
3048
3046
 
                then throw("Allowed USDT payment only!")
3049
3047
 
                else if ((ll.amount != ec))
3050
3048
 
                    then throw(("Payment should be " + toString(ec)))
3051
3049
 
                    else if (contains(kN, "__"))
3052
3050
 
                        then throw(("Name should not contain '__': " + kN))
3053
3051
 
                        else if ((size(kN) > ed))
3054
3052
 
                            then throw(("Name too long, maxLength=" + toString(ed)))
3055
3053
 
                            else {
3056
3054
 
                                let c = toString(gK.originCaller)
3057
3055
 
                                let mt = {
3058
3056
 
                                    let cy = bt
3059
3057
 
                                    if (("ACCOUNT" == cy))
3060
3058
 
                                        then {
3061
3059
 
                                            let mu = ex(kN)
3062
3060
 
                                            let mv = getString(mu)
3063
3061
 
                                            if (isDefined(mv))
3064
3062
 
                                                then throw(("Name already registered: " + kN))
3065
3063
 
                                                else {
3066
3064
 
                                                    let mw = bB(c)
3067
3065
 
                                                    let mx = getString(mw)
3068
3066
 
                                                    let my = if (isDefined(mx))
3069
3067
 
                                                        then [DeleteEntry(ex(value(mx)))]
3070
3068
 
                                                        else nil
3071
3069
 
                                                    (((my :+ StringEntry(mw, kN)) :+ StringEntry(mu, c)) ++ kf(c, Y)._1)
3072
3070
 
                                                    }
3073
3071
 
                                            }
3074
3072
 
                                        else if (("LAND" == cy))
3075
3073
 
                                            then {
3076
3074
 
                                                let js = value(assetInfo(fromBase58String(bp)))
3077
3075
 
                                                let jt = br(bp)
3078
3076
 
                                                if (!(isDefined(getInteger(jt))))
3079
3077
 
                                                    then throw((js.name + " is not staked"))
3080
3078
 
                                                    else {
3081
3079
 
                                                        let jv = valueOrErrorMessage(getString(bo(bp)), (("NFT " + js.name) + " is orphaned"))
3082
3080
 
                                                        if ((jv != c))
3083
3081
 
                                                            then throw((aC + " is not yours"))
3084
3082
 
                                                            else {
3085
3083
 
                                                                let mu = eq(kN)
3086
3084
 
                                                                let mv = getString(mu)
3087
3085
 
                                                                if (isDefined(mv))
3088
3086
 
                                                                    then throw(("Name already registered: " + kN))
3089
3087
 
                                                                    else {
3090
3088
 
                                                                        let mz = bq(bp)
3091
3089
 
                                                                        let mx = getString(mz)
3092
3090
 
                                                                        let my = if (isDefined(mx))
3093
3091
 
                                                                            then [DeleteEntry(eq(value(mx)))]
3094
3092
 
                                                                            else nil
3095
3093
 
                                                                        (((my :+ StringEntry(mz, kN)) :+ StringEntry(mu, bp)) ++ kf(c, Y)._1)
3096
3094
 
                                                                        }
3097
3095
 
                                                                }
3098
3096
 
                                                        }
3099
3097
 
                                                }
3100
3098
 
                                            else if (("DUCK" == cy))
3101
3099
 
                                                then {
3102
3100
 
                                                    let js = value(assetInfo(fromBase58String(bp)))
3103
3101
 
                                                    let jt = br(bp)
3104
3102
 
                                                    if (if (!(isDefined(getInteger(jt))))
3105
3103
 
                                                        then true
3106
3104
 
                                                        else !(isDefined(getString(bH(c)))))
3107
3105
 
                                                        then throw((js.name + " is not staked"))
3108
3106
 
                                                        else {
3109
3107
 
                                                            let jv = valueOrErrorMessage(getString(bG(bp)), (("NFT " + js.name) + " is orphaned"))
3110
3108
 
                                                            if ((jv != c))
3111
3109
 
                                                                then throw((aD + " is not yours"))
3112
3110
 
                                                                else {
3113
3111
 
                                                                    let mu = ew(kN)
3114
3112
 
                                                                    let mv = getString(mu)
3115
3113
 
                                                                    if (isDefined(mv))
3116
3114
 
                                                                        then throw(("Name already registered: " + kN))
3117
3115
 
                                                                        else {
3118
3116
 
                                                                            let mz = bA(bp)
3119
3117
 
                                                                            let mx = getString(mz)
3120
3118
 
                                                                            let my = if (isDefined(mx))
3121
3119
 
                                                                                then [DeleteEntry(ew(value(mx)))]
3122
3120
 
                                                                                else nil
3123
3121
 
                                                                            (((my :+ StringEntry(mz, kN)) :+ StringEntry(mu, bp)) ++ jZ(bp, Y)._1)
3124
3122
 
                                                                            }
3125
3123
 
                                                                    }
3126
3124
 
                                                            }
3127
3125
 
                                                    }
3128
3126
 
                                                else throw("Unknown entity type")
3129
3127
 
                                    }
3130
3128
 
                                $Tuple2(((mt :+ ScriptTransfer(dc, ll.amount, cx)) ++ lk), 0)
3131
3129
 
                                }
3132
3130
 
            }
3133
3131
 
    }
3134
3132
 
3135
3133
 
3136
3134
 
3137
3135
 
@Callable(gK)
3138
3136
 
func setReferrals (mA,mB) = if ((gK.callerPublicKey != dZ))
3139
3137
 
    then throw("Permission denied")
3140
3138
 
    else {
3141
3139
 
        let lk = lg(gK)
3142
3140
 
        if ((size(gK.payments) != 0))
3143
3141
 
            then throw("No payments required")
3144
3142
 
            else if (!(isDefined(addressFromString(mA))))
3145
3143
 
                then throw(("Invalid address: " + mA))
3146
3144
 
                else if (!(isDefined(addressFromString(mB))))
3147
3145
 
                    then throw(("Invalid address: " + mB))
3148
3146
 
                    else {
3149
3147
 
                        let mC = ey()
3150
3148
 
                        let mD = getString(mC)
3151
3149
 
                        let mE = if (isDefined(mD))
3152
3150
 
                            then split_4C(value(mD), "_")
3153
3151
 
                            else nil
3154
3152
 
                        if (containsElement(mE, mB))
3155
3153
 
                            then throw((mB + " is not newbie (already has referrals)"))
3156
3154
 
                            else {
3157
3155
 
                                let kh = bC(mB)
3158
3156
 
                                let ki = getString(kh)
3159
3157
 
                                if (if (isDefined(ki))
3160
3158
 
                                    then isDefined(addressFromString(value(ki)))
3161
3159
 
                                    else false)
3162
3160
 
                                    then throw(((mB + " already has refBy: ") + value(ki)))
3163
3161
 
                                    else {
3164
3162
 
                                        let mF = bF(mA)
3165
3163
 
                                        let mG = getString(mF)
3166
3164
 
                                        let mH = if (isDefined(mG))
3167
3165
 
                                            then split_4C(value(mG), "_")
3168
3166
 
                                            else nil
3169
3167
 
                                        if (containsElement(mH, mB))
3170
3168
 
                                            then throw((((mA + " already contains ") + mB) + " within referrals"))
3171
3169
 
                                            else {
3172
3170
 
                                                let mI = makeString_2C((mH :+ mB), "_")
3173
3171
 
                                                let mJ = if (containsElement(mE, mA))
3174
3172
 
                                                    then value(mD)
3175
3173
 
                                                    else makeString_2C((mE :+ mA), "_")
3176
3174
 
                                                $Tuple2(([StringEntry(kh, mA), StringEntry(mF, mI), StringEntry(mC, mJ)] ++ lk), 0)
3177
3175
 
                                                }
3178
3176
 
                                        }
3179
3177
 
                                }
3180
3178
 
                        }
3181
3179
 
        }
3182
3180
 
3183
3181
 
3184
3182
 
3185
3183
 
@Callable(gK)
3186
3184
 
func distributePoints (mK,mL,mM,mN,mO) = {
3187
3185
 
    let lk = lg(gK)
3188
3186
 
    if ((size(gK.payments) != 0))
3189
3187
 
        then throw("No payments required")
3190
3188
 
        else {
3191
3189
 
            let c = toString(gK.originCaller)
3192
3190
 
            let mP = dB(invoke(de, "checkWlgXpREADONLY", [c], nil))
3193
3191
 
            let mQ = dz(mP[1])
3194
3192
 
            let mR = if ((0 >= mQ))
3195
3193
 
                then $Tuple2(0, nil)
3196
3194
 
                else {
3197
3195
 
                    let ka = dz(invoke(de, "takeWlgXp", [c], nil))
3198
3196
 
                    if ((ka == ka))
3199
3197
 
                        then $Tuple2(mQ, [IntegerEntry(H(c), dz(mP[0])), IntegerEntry(G(c), dz(mP[2]))])
3200
3198
 
                        else throw("Strict value is not equal to itself.")
3201
3199
 
                    }
3202
3200
 
            let mS = mR._1
3203
3201
 
            let mT = mR._2
3204
3202
 
            let A = valueOrErrorMessage(getString(bH(c)), "You don't have a duck staked")
3205
3203
 
            let mU = I(c)
3206
3204
 
            let mV = (valueOrElse(getInteger(mU), 0) + mS)
3207
3205
 
            let mW = E(A)
3208
3206
 
            let mX = valueOrElse(getInteger(mW), 0)
3209
3207
 
            let mY = (mV + mX)
3210
3208
 
            let mZ = ((((mK + mL) + mM) + mN) + mO)
3211
3209
 
            if ((mZ > mY))
3212
3210
 
                then throw((("There are only " + toString(mY)) + " free points to distribute"))
3213
3211
 
                else {
3214
3212
 
                    let na = B(A)
3215
3213
 
                    let aq = split(valueOrElse(getString(na), "0_0_0_0_0"), "_")
3216
3214
 
                    let nb = (mV - mZ)
3217
3215
 
                    $Tuple2((([IntegerEntry(mU, if ((0 > nb))
3218
3216
 
                        then 0
3219
3217
 
                        else nb), IntegerEntry(mW, if ((0 > nb))
3220
3218
 
                        then (mX + nb)
3221
3219
 
                        else mX), StringEntry(na, makeString([toString((parseIntValue(aq[k]) + mK)), toString((parseIntValue(aq[l]) + mL)), toString((parseIntValue(aq[m]) + mM)), toString((parseIntValue(aq[n]) + mN)), toString((parseIntValue(aq[o]) + mO))], "_"))] ++ lk) ++ mT), 0)
3222
3220
 
                    }
3223
3221
 
            }
3224
3222
 
    }
3225
3223
 
3226
3224
 
3227
3225
 
3228
3226
 
@Callable(gK)
3229
3227
 
func splitByGlobalWeightsREADONLY (eI) = $Tuple2(nil, fa(eI))
3230
3228
 
3231
3229
 
3232
3230
 
3233
3231
 
@Callable(gK)
3234
3232
 
func splitByGlobalAndLocalWeightsREADONLY (nc,nd,gN) = {
3235
3233
 
    let gG = gM(gN)
3236
3234
 
    $Tuple2(nil, $Tuple2(fa(nc), eL(nd, gG)))
3237
3235
 
    }
3238
3236
 
3239
3237
 
3240
3238
 
3241
3239
 
@Callable(gK)
3242
3240
 
func getBackpackREADONLY (A) = $Tuple2(nil, makeString(hK(bI(A)), ":"))
3243
3241
 
3244
3242
 
3245
3243
 
3246
3244
 
@Callable(gK)
3247
3245
 
func getWarehouseREADONLY (P) = {
3248
3246
 
    let js = value(assetInfo(fromBase58String(P)))
3249
3247
 
    let hZ = (dH(split(js.description, "_")[di]) / cF)
3250
3248
 
    let ia = valueOrElse(getInteger(by(P)), 0)
3251
3249
 
    $Tuple2(nil, makeString_2C(hX(bx(P), hZ, ia), ":"))
3252
3250
 
    }
3253
3251
 
3254
3252
 
3255
3253
 
3256
3254
 
@Callable(gK)
3257
3255
 
func saveLastTx () = if (!(containsElement([de, dc, df, dg], gK.caller)))
3258
3256
 
    then throw("Access denied")
3259
3257
 
    else $Tuple2(lg(gK), 42)
3260
3258
 
3261
3259
 
3262
3260
 
3263
3261
 
@Callable(gK)
3264
3262
 
func updateDuckStats (A,ka) = if ((gK.caller != dc))
3265
3263
 
    then throw("Access denied")
3266
3264
 
    else jZ(A, ka)
3267
3265
 
3268
3266
 
3269
3267
 
3270
3268
 
@Callable(gK)
3271
3269
 
func updateAccStats (c,ka) = if (!(containsElement([de, dc, dg], gK.caller)))
3272
3270
 
    then throw("Access denied")
3273
3271
 
    else kf(c, ka)
3274
3272
 
3275
3273
 
3276
3274
 
3277
3275
 
@Callable(gK)
3278
3276
 
func equipDuck (ne) = {
3279
3277
 
    let lk = lg(gK)
3280
3278
 
    if ((size(gK.payments) != 0))
3281
3279
 
        then throw("No payments required")
3282
3280
 
        else {
3283
3281
 
            let c = toString(gK.originCaller)
3284
3282
 
            let A = valueOrErrorMessage(getString(bH(c)), "You don't have a duck staked")
3285
3283
 
            if (kp(A))
3286
3284
 
                then throw("equipDuck_checkTournament")
3287
3285
 
                else if (kq(A))
3288
3286
 
                    then throw("equipDuck_checkDelivery")
3289
3287
 
                    else {
3290
3288
 
                        let gx = F(A)
3291
3289
 
                        let nf = split(valueOrElse(getString(gx), ",;,_,;,_,;,_,;,_,;,_,;,"), "_")
3292
3290
 
                        let hL = bI(A)
3293
3291
 
                        let io = hK(hL)
3294
3292
 
                        let lB = split(ne, "_")
3295
3293
 
                        if ((size(lB) != q))
3296
3294
 
                            then throw("Wrong equipment string")
3297
3295
 
                            else {
3298
3296
 
                                let gz = gm(nf, fx(io[bk]), true, nil)
3299
3297
 
                                let gA = split(lB[p], ";")[1]
3300
3298
 
                                let ao = if ((gA == ""))
3301
3299
 
                                    then 0
3302
3300
 
                                    else {
3303
3301
 
                                        let gB = split(gA, ",")[0]
3304
3302
 
                                        if ((gB == ""))
3305
3303
 
                                            then 0
3306
3304
 
                                            else {
3307
3305
 
                                                let fM = split(gB, ":")
3308
3306
 
                                                let da = fM[0]
3309
3307
 
                                                let gC = fM[1]
3310
3308
 
                                                if (if (if (if (if ((da == "06"))
3311
3309
 
                                                    then true
3312
3310
 
                                                    else (da == "07"))
3313
3311
 
                                                    then true
3314
3312
 
                                                    else (da == "08"))
3315
3313
 
                                                    then (gC != "")
3316
3314
 
                                                    else false)
3317
3315
 
                                                    then (parseIntValue(gC) > 0)
3318
3316
 
                                                    else false)
3319
3317
 
                                                    then parseIntValue(split(aS[parseIntValue(da)], "_")[aU])
3320
3318
 
                                                    else 0
3321
3319
 
                                                }
3322
3320
 
                                        }
3323
3321
 
                                let gh = am(this, A, ao, true)
3324
3322
 
                                let gD = gm(lB, gz, false, gh)
3325
3323
 
                                let ng = fC(gD)
3326
3324
 
                                $Tuple2(([StringEntry(gx, ne), StringEntry(hL, makeString_2C([io[bh], io[bi], io[bj], ng], ":")), StringEntry(L(A), makeString([toString(gh[7]), toString(gh[8]), toString(gh[9]), toString(gh[10]), toString(gh[11])], "_"))] ++ lk), 0)
3327
3325
 
                                }
3328
3326
 
                        }
3329
3327
 
            }
3330
3328
 
    }
3331
3329
 
3332
3330
 
3333
3331
 
3334
3332
 
@Callable(gK)
3335
3333
 
func fortificateLand (P,nh) = {
3336
3334
 
    let lk = lg(gK)
3337
3335
 
    if ((size(gK.payments) != 0))
3338
3336
 
        then throw("No payments required")
3339
3337
 
        else {
3340
3338
 
            let c = toString(gK.originCaller)
3341
3339
 
            let A = valueOrElse(getString(bH(c)), "")
3342
3340
 
            let fH = am(this, A, 0, false)
3343
3341
 
            let ni = bz(P)
3344
3342
 
            let nj = split(valueOrElse(getString(ni), ":0_15:0_18:0"), "_")
3345
3343
 
            let js = value(assetInfo(fromBase58String(P)))
3346
3344
 
            let hZ = (dH(split(js.description, "_")[di]) / cF)
3347
3345
 
            let ia = valueOrElse(getInteger(by(P)), 0)
3348
3346
 
            let hY = bx(P)
3349
3347
 
            let id = hX(hY, hZ, ia)
3350
3348
 
            let nk = split(id[bc], "_")
3351
3349
 
            let nl = parseIntValue(nk[be])
3352
3350
 
            let nm = parseIntValue(nk[bf])
3353
3351
 
            let nn = split(nh, "_")
3354
3352
 
            let no = gt(nj, fx(id[bb]), nl, nm, true, nil)
3355
3353
 
            let gz = no._1
3356
3354
 
            let np = no._2
3357
3355
 
            let nq = no._3
3358
3356
 
            let nr = gt(nn, gz, np, nq, false, fH)
3359
3357
 
            let gD = nr._1
3360
3358
 
            let ns = nr._2
3361
3359
 
            let nt = nr._3
3362
3360
 
            let ng = fC(gD)
3363
3361
 
            let jY = makeString([nk[bd], toString(ns), toString(nt), nk[bg]], "_")
3364
3362
 
            $Tuple2(([StringEntry(ni, nh), StringEntry(hY, makeString_2C([id[aY], id[aZ], id[ba], ng, jY], ":"))] ++ lk), 0)
3365
3363
 
            }
3366
3364
 
    }
3367
3365
 
3368
3366
 
3369
3367
 
3370
3368
 
@Callable(gK)
3371
3369
 
func initDuckTourAttempt (A) = if ((gK.caller != df))
3372
3370
 
    then throw("Access denied")
3373
3371
 
    else {
3374
3372
 
        let jb = z(A)
3375
3373
 
        let jc = ag(valueOrElse(getInteger(D(A)), 0))
3376
3374
 
        let kt = valueOrElse(getInteger(jb), jc)
3377
3375
 
        let nu = bJ(A)
3378
3376
 
        let jq = valueOrElse(getString(nu), aJ)
3379
3377
 
        let ce = valueOrElse(getInteger(df, bP), 0)
3380
3378
 
        let nv = (toString(ce) + "_T_0")
3381
3379
 
        $Tuple2([IntegerEntry(J(A), kt), IntegerEntry(jb, jc), StringEntry(K(A), jq), StringEntry(nu, nv)], nv)
3382
3380
 
        }
3383
3381
 
3384
3382
 
3385
3383
 
3386
3384
 
@Callable(gK)
3387
3385
 
func breakAttempt () = {
3388
3386
 
    let lk = lg(gK)
3389
3387
 
    let A = valueOrErrorMessage(getString(bH(toString(gK.caller))), "You don't have a duck staked")
3390
3388
 
    let nu = bJ(A)
3391
3389
 
    let jq = valueOrElse(getString(nu), aJ)
3392
3390
 
    if ((split(jq, "_")[bm] != "T"))
3393
3391
 
        then throw("Your duck is not in the tournament")
3394
3392
 
        else {
3395
3393
 
            let ky = getIntegerValue(J(A))
3396
3394
 
            let kz = getStringValue(K(A))
3397
3395
 
            $Tuple2(((lk :+ IntegerEntry(z(A), ky)) :+ StringEntry(nu, kz)), jq)
3398
3396
 
            }
3399
3397
 
    }
3400
3398
 
3401
3399
 
3402
3400
 
3403
3401
 
@Callable(gK)
3404
3402
 
func exitTournamentInternal (A) = if ((gK.caller != this))
3405
3403
 
    then throw("Access denied")
3406
3404
 
    else {
3407
3405
 
        let ky = getIntegerValue(J(A))
3408
3406
 
        let kz = getStringValue(K(A))
3409
3407
 
        $Tuple2([IntegerEntry(z(A), ky), StringEntry(bJ(A), kz)], false)
3410
3408
 
        }
3411
3409
 
3412
3410
 
3413
3411
 
3414
3412
 
@Callable(gK)
3415
3413
 
func exitDeliveryInternal (A) = if ((gK.caller != this))
3416
3414
 
    then throw("Access denied")
3417
3415
 
    else {
3418
3416
 
        let mh = kr(A)
3419
3417
 
        $Tuple2((mh._1 ++ mh._2), false)
3420
3418
 
        }
3421
3419
 
3422
3420
 
3423
3421
 
3424
3422
 
@Callable(gK)
3425
3423
 
func autoExitDelivery (A) = if ((gK.caller != this))
3426
3424
 
    then throw("Access denied")
3427
3425
 
    else {
3428
3426
 
        let mh = kr(A)
3429
3427
 
        $Tuple2(mh._1, $Tuple2(mh._3, mh._4))
3430
3428
 
        }
3431
3429
 
3432
3430
 
3433
3431
 
3434
3432
 
@Callable(gK)
3435
3433
 
func prepareRobbery (iQ,iR) = {
3436
3434
 
    let lk = lg(gK)
3437
3435
 
    if (!(sigVerify_8Kb(iQ, iR, dZ)))
3438
3436
 
        then throw("signature does not match")
3439
3437
 
        else if ((size(gK.payments) != 1))
3440
3438
 
            then throw("exactly 1 payment must be attached")
3441
3439
 
            else {
3442
3440
 
                let ll = gK.payments[0]
3443
3441
 
                let nw = ll.amount
3444
3442
 
                if (if (!(isDefined(ll.assetId)))
3445
3443
 
                    then true
3446
3444
 
                    else (value(ll.assetId) != dm))
3447
3445
 
                    then throw("WLGOLD payments only!")
3448
3446
 
                    else {
3449
3447
 
                        let fp = split(toUtf8String(iQ), "|")
3450
3448
 
                        if ((size(fp) != 2))
3451
3449
 
                            then throw("Wrong message format")
3452
3450
 
                            else {
3453
3451
 
                                let A = fp[0]
3454
3452
 
                                if (kp(A))
3455
3453
 
                                    then throw("prepareRobbery_checkTournament")
3456
3454
 
                                    else if (kq(A))
3457
3455
 
                                        then throw("prepareRobbery_checkDelivery")
3458
3456
 
                                        else {
3459
3457
 
                                            let ay = au(this, A)._1
3460
3458
 
                                            if ((ay > nw))
3461
3459
 
                                                then throw(((("Payment " + toString(nw)) + " < required ") + toString(ay)))
3462
3460
 
                                                else {
3463
3461
 
                                                    let nx = split(fp[1], "_")
3464
3462
 
                                                    let ax = lastBlock.timestamp
3465
3463
 
                                                    let az = valueOrElse(getInteger(R(A)), 0)
3466
3464
 
                                                    let aA = valueOrElse(getString(S(A)), "")
3467
3465
 
                                                    let aB = valueOrElse(getInteger(Q(aA)), 0)
3468
3466
 
                                                    if (if ((az != x))
3469
3467
 
                                                        then (aB > ax)
3470
3468
 
                                                        else false)
3471
3469
 
                                                        then throw(("You already started robbing, wait till " + toString(aB)))
3472
3470
 
                                                        else {
3473
3471
 
                                                            func ny (eR,P) =                                                             {
3474
3472
 
                                                                let nz = valueOrElse(getInteger(O(P)), 0)
3475
3473
 
                                                                let nA = valueOrElse(getInteger(Q(P)), 0)
3476
3474
 
                                                                if ((nz > size(u)))
3477
3475
 
                                                                    then throw("Invalid state")
3478
3476
 
                                                                    else if ((ax > nA))
3479
3477
 
                                                                        then {
3480
3478
 
                                                                            let nB = valueOrElse(getInteger(br(P)), 0)
3481
3479
 
                                                                            if ((0 >= nB))
3482
3480
 
                                                                                then eR
3483
3481
 
                                                                                else {
3484
3482
 
                                                                                    let gr = value(assetInfo(fromBase58String(P)))
3485
3483
 
                                                                                    let jw = split(gr.description, "_")
3486
3484
 
                                                                                    let ji = dH(jw[di])
3487
3485
 
                                                                                    let nC = jh(P, ji)
3488
3486
 
                                                                                    let gQ = (ax - nB)
3489
3487
 
                                                                                    let jz = fraction(gQ, (nC * ji), a)
3490
3488
 
                                                                                    if ((v > jz))
3491
3489
 
                                                                                        then eR
3492
3490
 
                                                                                        else (eR :+ P)
3493
3491
 
                                                                                    }
3494
3492
 
                                                                            }
3495
3493
 
                                                                        else eR
3496
3494
 
                                                                }
3497
3495
 
3498
3496
 
                                                            let nD = {
3499
3497
 
                                                                let eT = nx
3500
3498
 
                                                                let eU = size(eT)
3501
3499
 
                                                                let eV = nil
3502
3500
 
                                                                func eW (eX,eY) =                                                                 if ((eY >= eU))
3503
3501
 
                                                                    then eX
3504
3502
 
                                                                    else ny(eX, eT[eY])
3505
3503
 
3506
3504
 
                                                                func eZ (eX,eY) =                                                                 if ((eY >= eU))
3507
3505
 
                                                                    then eX
3508
3506
 
                                                                    else throw("List size exceeds 10")
3509
3507
 
3510
3508
 
                                                                eZ(eW(eW(eW(eW(eW(eW(eW(eW(eW(eW(eV, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
3511
3509
 
                                                                }
3512
3510
 
                                                            if ((size(nD) == 0))
3513
3511
 
                                                                then throw("No candidates for robbery")
3514
3512
 
                                                                else {
3515
3513
 
                                                                    let nE = dR(size(nD), height, (iR + gK.transactionId))
3516
3514
 
                                                                    let P = nD[nE]
3517
3515
 
                                                                    $Tuple2(([IntegerEntry(O(P), w), IntegerEntry(Q(P), (ax + u[w])), IntegerEntry(R(A), y), StringEntry(S(A), P)] ++ lk), P)
3518
3516
 
                                                                    }
3519
3517
 
                                                            }
3520
3518
 
                                                    }
3521
3519
 
                                            }
3522
3520
 
                                }
3523
3521
 
                        }
3524
3522
 
                }
3525
3523
 
    }
3526
3524
 
3527
3525
 
3528
3526
 
3529
3527
 
@Callable(gK)
3530
3528
 
func robLand (iQ,iR) = {
3531
3529
 
    let lk = lg(gK)
3532
3530
 
    if (!(sigVerify_8Kb(iQ, iR, dZ)))
3533
3531
 
        then throw("signature does not match")
3534
3532
 
        else {
3535
3533
 
            let bL = toString(gK.caller)
3536
3534
 
            let A = valueOrErrorMessage(getString(bH(bL)), "You don't have a duck staked")
3537
3535
 
            let ax = lastBlock.timestamp
3538
3536
 
            $Tuple2((lk :+ IntegerEntry(M(A), ax)), 0)
3539
3537
 
            }
3540
3538
 
    }
3541
3539
 
3542
3540
 
3543
3541
 
3544
3542
 
@Callable(gK)
3545
3543
 
func acceptDelivery () = if (!(cv))
3546
3544
 
    then throw("Delivery feature is turned off!")
3547
3545
 
    else {
3548
3546
 
        let lk = lg(gK)
3549
3547
 
        let bL = toString(gK.caller)
3550
3548
 
        let A = valueOrErrorMessage(getString(bH(bL)), "You don't have a duck staked")
3551
3549
 
        let nF = valueOrElse(getInteger(dc, bN), 0)
3552
3550
 
        let kw = valueOrElse(getInteger(dc, bO), 0)
3553
3551
 
        if ((aM > (nF - kw)))
3554
3552
 
            then throw(((("Delivery is not available, fund=" + dM(nF, 6)) + ", locked=") + dM(kw, 6)))
3555
3553
 
            else {
3556
3554
 
                let ax = lastBlock.timestamp
3557
3555
 
                let nG = valueOrElse(getInteger(T(A)), 0)
3558
3556
 
                if ((nG > ax))
3559
3557
 
                    then throw(("Delivery is forbidden for your duck until " + toString(nG)))
3560
3558
 
                    else if (kp(A))
3561
3559
 
                        then throw("acceptDelivery_checkTournament")
3562
3560
 
                        else if (kq(A))
3563
3561
 
                            then throw("acceptDelivery_checkDelivery")
3564
3562
 
                            else {
3565
3563
 
                                let nH = dz(invoke(dc, "updateDeliveryLocked", [(kw + aM)], nil))
3566
3564
 
                                let jb = z(A)
3567
3565
 
                                let jc = ag(valueOrElse(getInteger(D(A)), 0))
3568
3566
 
                                let kt = valueOrElse(getInteger(jb), jc)
3569
3567
 
                                let nu = bJ(A)
3570
3568
 
                                let jq = valueOrElse(getString(nu), aJ)
3571
3569
 
                                let nI = (toString(ax) + "_D_0")
3572
3570
 
                                $Tuple2(([IntegerEntry(J(A), kt), IntegerEntry(jb, jc), StringEntry(K(A), jq), StringEntry(nu, nI)] ++ lk), $Tuple2(nI, nH))
3573
3571
 
                                }
3574
3572
 
                }
3575
3573
 
        }
3576
3574
 
3577
3575