tx · BUxSUsbptrTHZL3yqV6sJ8hNLZ67wcDXoTCtHthELV6A

3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm:  -0.07000000 Waves

2023.07.12 16:54 [2662772] smart account 3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "BUxSUsbptrTHZL3yqV6sJ8hNLZ67wcDXoTCtHthELV6A",
    "fee": 7000000,
    "feeAssetId": null,
    "timestamp": 1689170118996,
    "version": 2,
    "chainId": 84,
    "sender": "3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm",
    "senderPublicKey": "EVooykMNV691Venwp1dHUTBd7KWequzUcda57Wd3LQEX",
    "proofs": [
        "Cr1jynwNrK6QAhW2AupYKbMzyEn6AcYfN8F7W1PPYwngS7vjCY74FCPSuF4MbpGahUBU9zZjduEmSQXqDP85rnW"
    ],
    "script": "base64:BgKtAQgCEgMKAQgSAwoBBBIAEgMKAQgSABIDCgEIEgQKAgEIEgQKAgEIEgQKAgICEgUKAwEBARIAEgQKAggIEgASBAoCAgISAwoBCBIDCgEIEgQKAggIEgMKARgSAwoBGBIECgIICBIECgIICBIDCgEIEgMKAQgSBQoDCAgIEgQKAggIEgcKBQEBAQEBEgMKAQESBQoDAQEIEgMKAQgSAwoBCBIAEgQKAggBEgQKAggBwgEABlNDQUxFOACAwtcvAAx4cExldmVsU2NhbGUAgBkAD3hwTGV2ZWxSZWNpcFBvdwCgHwASbnVtUG9pbnRzT25MZXZlbFVwAAMADGNoYXJTdHJlbmd0aAAAAAxjaGFyQWNjdXJhY3kAAQANY2hhckludGVsbGVjdAACAA1jaGFyRW5kdXJhbmNlAAMADWNoYXJEZXh0ZXJpdHkABAEMa2V5RHVja0NoYXJzAQtkdWNrQXNzZXRJZAkArAICAgpkdWNrQ2hhcnNfBQtkdWNrQXNzZXRJZAEJa2V5RHVja1hQAQtkdWNrQXNzZXRJZAkArAICAgdkdWNrWFBfBQtkdWNrQXNzZXRJZAEMa2V5RHVja0xldmVsAQtkdWNrQXNzZXRJZAkArAICAgpkdWNrTGV2ZWxfBQtkdWNrQXNzZXRJZAERa2V5RHVja0ZyZWVQb2ludHMBC2R1Y2tBc3NldElkCQCsAgICD2R1Y2tGcmVlUG9pbnRzXwULZHVja0Fzc2V0SWQBCWtleVVzZXJYUAEEYWRkcgkArAICAgd1c2VyWFBfBQRhZGRyAQxrZXlVc2VyTGV2ZWwBBGFkZHIJAKwCAgIKdXNlckxldmVsXwUEYWRkcgERa2V5VXNlckZyZWVQb2ludHMBBGFkZHIJAKwCAgIPdXNlckZyZWVQb2ludHNfBQRhZGRyAAd4cENsYWltAKCNBgAPeHBTdWNjZXNzRmxpZ2h0ANCGAwAMeHBGYWlsRmxpZ2h0AJBOAAh4cENhbGxFUwCgjQYADHhwQ3VzdG9tTmFtZQDAlrECAAp4cE5ld1NMYW5kAIDh6xcADnhwVXBncmFkZUluZnJhAKCNBgAHeHBNZXJnZQCAreIEAAl4cE9uYm9hcmQAgK3iBAAGeHBIZWFsAJBOAQlsZXZlbEJ5WFABAnhwCQBrAwUMeHBMZXZlbFNjYWxlCQBsBgUCeHAABAUPeHBMZXZlbFJlY2lwUG93AAQABAUERE9XTgUGU0NBTEU4AQltYXhIZWFsdGgBBWxldmVsCQBkAgBkBQVsZXZlbAEHbGV2ZWxVcAIJY3VyckxldmVsBW5ld1hQBAhuZXdMZXZlbAkBCWxldmVsQnlYUAEFBW5ld1hQCQDMCAIFCG5ld0xldmVsCQDMCAIJAGgCBRJudW1Qb2ludHNPbkxldmVsVXAJAGUCBQhuZXdMZXZlbAUJY3VyckxldmVsBQNuaWwACkxBTkRQUkVGSVgCBExBTkQACkRVQ0tQUkVGSVgCBERVQ0sACkFSVFBSRVNBTEUCB1BSRVNBTEUABk5VTVJFUwAGAA9EQUlMWVJFU0JZUElFQ0UAgPjSAQAJREFZTUlMTElTAIC4mSkADFdITVVMVElQTElFUgCAyK+gJQAPREVGQVVMVExPQ0FUSU9OAg9BZnJpY2FfRl9BZnJpY2EAEFJFU09VUkNFUFJJQ0VNSU4A1bUCAApFU1NFTExDT0VGAAoACXByb2RUeXBlcwkAzAgCAhBGaXJzdCBBaWQgS2l0IEwxCQDMCAICEEZpcnN0IEFpZCBLaXQgTDIJAMwIAgIQRmlyc3QgQWlkIEtpdCBMMwkAzAgCAgtCYWNrcGFjayBMMQkAzAgCAgtCYWNrcGFjayBMMgkAzAgCAgtCYWNrcGFjayBMMwkAzAgCAg5Gb29kIFJhdGlvbiBMMQkAzAgCAg5Gb29kIFJhdGlvbiBMMgkAzAgCAg5Gb29kIFJhdGlvbiBMMwkAzAgCAgtKZXQgUGFjayBMMQkAzAgCAgtKZXQgUGFjayBMMgkAzAgCAgtKZXQgUGFjayBMMwkAzAgCAglTaGllbGQgTDEJAMwIAgIJU2hpZWxkIEwyCQDMCAICCVNoaWVsZCBMMwUDbmlsAApjb250aW5lbnRzCQDMCAICCEFtZXJpY2FzCQDMCAICBkV1cm9wZQkAzAgCAgRBc2lhCQDMCAICBkFmcmljYQkAzAgCAgdPY2VhbmlhBQNuaWwAEHByb2R1Y3Rpb25NYXRyaXgJAMwIAgITOF84XzhfMTdfMTdfNDJfMTJfMAkAzAgCAhM4XzhfOF8xN18xN180Ml8yNF8wCQDMCAICEzhfOF84XzE3XzE3XzQyXzM2XzAJAMwIAgIUOF8xOV8xOV84XzI3XzE5XzI2XzEJAMwIAgIUOF8xOV8xOV84XzI3XzE5XzUyXzEJAMwIAgIUOF8xOV8xOV84XzI3XzE5Xzc4XzEJAMwIAgIROF84XzhfOF84XzYwXzEzXzIJAMwIAgIROF84XzhfOF84XzYwXzI2XzIJAMwIAgIROF84XzhfOF84XzYwXzM5XzIJAMwIAgIUMzBfMzBfM18xN18xN18zXzMwXzMJAMwIAgIUMzBfMzBfM18xN18xN18zXzYwXzMJAMwIAgIUMzBfMzBfM18xN18xN18zXzkwXzMJAMwIAgIWMThfMThfMTBfMThfMThfMThfMTFfNAkAzAgCAhYxOF8xOF8xMF8xOF8xOF8xOF8yMl80CQDMCAICFjE4XzE4XzEwXzE4XzE4XzE4XzMzXzQFA25pbAAJcklkeENvZWZmAAYADnByb2R1Y3RQa2dTaXplAAoAC3doSWR4TGV2ZWxzAAAACHdoSWR4UmVzAAEACHdoSWR4TWF0AAIACXdoSWR4UHJvZAADAAl3aElkeExPRlQABAAJdm9sTG9ja2VkAAAAC3ZvbE9jY3VwaWVkAAEAB3ZvbEZyZWUAAgAIdm9sVG90YWwAAwAKYnBJZHhMZXZlbAAAAAhicElkeFJlcwABAAhicElkeE1hdAACAAlicElkeFByb2QAAwERa2V5TGFzdFR4SWRCeVVzZXIBBGFkZHIJAKwCAgIPbGFzdFR4SWRCeVVzZXJfBQRhZGRyARVrZXlMYW5kQXNzZXRJZFRvT3duZXIBB2Fzc2V0SWQJAKwCAgIJbmZ0T3duZXJfBQdhc3NldElkARprZXlMYW5kQXNzZXRJZFRvQ3VzdG9tTmFtZQEHYXNzZXRJZAkArAICAhhsYW5kQ3VzdG9tTmFtZUJ5QXNzZXRJZF8FB2Fzc2V0SWQBFmtleVN0YWtlZFRpbWVCeUFzc2V0SWQBB2Fzc2V0SWQJAKwCAgILc3Rha2VkVGltZV8FB2Fzc2V0SWQBFmtleUluZnJhTGV2ZWxCeUFzc2V0SWQBB2Fzc2V0SWQJAKwCAgILaW5mcmFMZXZlbF8FB2Fzc2V0SWQBIGtleUxhbmRBcnRTdGF0dXNCeVR5cGVBbmRBc3NldElkAgR0eXBlB2Fzc2V0SWQJALkJAgkAzAgCAg1sYW5kQXJ0U3RhdHVzCQDMCAIFBHR5cGUJAMwIAgUHYXNzZXRJZAUDbmlsAgFfASJrZXlTdGFrZWRUaW1lQnlUeXBlQXNzZXRJZEFuZE93bmVyAwduZnRUeXBlB2Fzc2V0SWQJb3duZXJBZGRyCQCsAgIJAKwCAgkArAICCQCsAgIJAKwCAgIgc3Rha2VkVGltZUJ5VHlwZUFzc2V0SWRBbmRPd25lcl8FB25mdFR5cGUCAV8FB2Fzc2V0SWQCAV8FCW93bmVyQWRkcgESa2V5V2FyZWhvdXNlQnlMYW5kAQtsYW5kQXNzZXRJZAkArAICAgp3YXJlSG91c2VfBQtsYW5kQXNzZXRJZAEaa2V5RHVja0Fzc2V0SWRUb0N1c3RvbU5hbWUBB2Fzc2V0SWQJAKwCAgIYZHVja0N1c3RvbU5hbWVCeUFzc2V0SWRfBQdhc3NldElkARZrZXlBZGRyZXNzVG9DdXN0b21OYW1lAQRhZGRyCQCsAgICGGFjY291bnRDdXN0b21OYW1lQnlBZGRyXwUEYWRkcgEPa2V5QWRkcmVzc1JlZkJ5AQRhZGRyCQCsAgICCWFjY1JlZkJ5XwUEYWRkcgEca2V5T25ib2FyZEFydEFjdGl2YXRlZE9uRHVjawELZHVja0Fzc2V0SWQJAKwCAgIab25ib2FyZEFydEFjdGl2YXRlZE9uRHVja18FC2R1Y2tBc3NldElkARxrZXlPbmJvYXJkQXJ0RHVja0FjdGl2YXRlZEJ5AQRhZGRyCQCsAgICGm9uYm9hcmRBcnRBY3RpdmF0ZWREdWNrQnlfBQRhZGRyARNrZXlBZGRyZXNzUmVmZXJyYWxzAQRhZGRyCQCsAgICDWFjY1JlZmVycmFsc18FBGFkZHIBEGtleUR1Y2tJZFRvT3duZXIBB2Fzc2V0SWQJAKwCAgIKZHVja093bmVyXwUHYXNzZXRJZAEUa2V5U3Rha2VkRHVja0J5T3duZXIBCW93bmVyQWRkcgkArAICAhJzdGFrZWREdWNrQnlPd25lcl8FCW93bmVyQWRkcgERa2V5QmFja3BhY2tCeUR1Y2sBC2R1Y2tBc3NldElkCQCsAgICCWJhY2tQYWNrXwULZHVja0Fzc2V0SWQBD2tleUR1Y2tMb2NhdGlvbgELZHVja0Fzc2V0SWQJAKwCAgINZHVja0xvY2F0aW9uXwULZHVja0Fzc2V0SWQBDWtleUR1Y2tIZWFsdGgBC2R1Y2tBc3NldElkCQCsAgICC2R1Y2tIZWFsdGhfBQtkdWNrQXNzZXRJZAEKa2V5QmxvY2tlZAACEGNvbnRyYWN0c0Jsb2NrZWQBFWtleVVzZXJHd2xSZWxlYXNlVGltZQEIdXNlckFkZHIJAKwCAgIaJXMlc19fdXNlckd3bFJlbGVhc2VUaW1lX18FCHVzZXJBZGRyAQ5rZXlFc1dhcmVob3VzZQACGmVtZXJnZW5jeVdhcmVob3VzZVByb2R1Y3RzAApsb2NJZHhUeXBlAAEACGxvY0lkeElkAAIBEmdldFJlY2lwZU1hdGVyaWFscwEGcmVjaXBlCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUGcmVjaXBlBQlySWR4Q29lZmYAD0tTQUxMT1dYUExFVkVMUwYABWNoYWluCQDJAQIJAMoBAggFBHRoaXMFYnl0ZXMAAQABAAt1c2R0QXNzZXRJZAQHJG1hdGNoMAUFY2hhaW4DCQAAAgEBVwUHJG1hdGNoMAEghNp6sggDP07Ru8qO7ouTvMmC3Qtd+geWqNQj+agP/7kDCQAAAgEBVAUHJG1hdGNoMAEgVbHYn3KHgu/l41uNrAWrZd6aQ6EvFrsF8xq3h6XxxRgJAAIBAg1Vbmtub3duIGNoYWluABVkZWZhdWx0UmVzdEFkZHJlc3NTdHIEByRtYXRjaDAFBWNoYWluAwkAAAIBAVcFByRtYXRjaDACIzNQUUN1dkZidmg0TGtQVW5yblUxejNqbmJBMXA5bTNXTmh2AwkAAAIBAVQFByRtYXRjaDACIzNNdW1rR0d6dENLQVhwV0RxeGtkZG9mcVhTVWJxUWt2U0p5CQACAQINVW5rbm93biBjaGFpbgARSW5mcmFVcGdyYWRlQ29zdFMEByRtYXRjaDAFBWNoYWluAwkAAAIBAVcFByRtYXRjaDAAgMivoCUDCQAAAgEBVAUHJG1hdGNoMACAwtcvCQACAQINVW5rbm93biBjaGFpbgADU0VQAgJfXwAFTVVMVDYAwIQ9AAVNVUxUOACAwtcvAAVTU0laRQAZAAVNU0laRQBkAAVMU0laRQDhAQAGWExTSVpFAJADAAdYWExTSVpFAPEEAQ9nZXRTdHJpbmdPckZhaWwCB2FkZHJlc3MDa2V5CQETdmFsdWVPckVycm9yTWVzc2FnZQIJAJ0IAgUHYWRkcmVzcwUDa2V5CQC5CQIJAMwIAgIKbWFuZGF0b3J5IAkAzAgCCQClCAEFB2FkZHJlc3MJAMwIAgIBLgkAzAgCBQNrZXkJAMwIAgIPIGlzIG5vdCBkZWZpbmVkBQNuaWwCAAARSWR4Q2ZnU3Rha2luZ0RhcHAAAQARSWR4Q2ZnRWNvbm9teURhcHAAAgAUSWR4Q2ZnR292ZXJuYW5jZURhcHAAAwANSWR4Q2ZnV2xnRGFwcAAEAQprZXlSZXN0Q2ZnAAIOJXNfX3Jlc3RDb25maWcBDmtleVJlc3RBZGRyZXNzAAIMJXNfX3Jlc3RBZGRyARFyZWFkUmVzdENmZ09yRmFpbAEEcmVzdAkAvAkCCQEPZ2V0U3RyaW5nT3JGYWlsAgUEcmVzdAkBCmtleVJlc3RDZmcABQNTRVABGGdldENvbnRyYWN0QWRkcmVzc09yRmFpbAIHcmVzdENmZwNpZHgJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkApggBCQCRAwIFB3Jlc3RDZmcFA2lkeAkArAICAipSZXN0IGNmZyBkb2Vzbid0IGNvbnRhaW4gYWRkcmVzcyBhdCBpbmRleCAJAKQDAQUDaWR4AAxyZXN0Q29udHJhY3QJARFAZXh0ck5hdGl2ZSgxMDYyKQEJAQt2YWx1ZU9yRWxzZQIJAJ0IAgUEdGhpcwkBDmtleVJlc3RBZGRyZXNzAAUVZGVmYXVsdFJlc3RBZGRyZXNzU3RyAAdyZXN0Q2ZnCQERcmVhZFJlc3RDZmdPckZhaWwBBQxyZXN0Q29udHJhY3QAD3N0YWtpbmdDb250cmFjdAkBGGdldENvbnRyYWN0QWRkcmVzc09yRmFpbAIFB3Jlc3RDZmcFEUlkeENmZ1N0YWtpbmdEYXBwAA9lY29ub215Q29udHJhY3QJARhnZXRDb250cmFjdEFkZHJlc3NPckZhaWwCBQdyZXN0Q2ZnBRFJZHhDZmdFY29ub215RGFwcAALZ292Q29udHJhY3QJARhnZXRDb250cmFjdEFkZHJlc3NPckZhaWwCBQdyZXN0Q2ZnBRRJZHhDZmdHb3Zlcm5hbmNlRGFwcAALd2xnQ29udHJhY3QJARhnZXRDb250cmFjdEFkZHJlc3NPckZhaWwCBQdyZXN0Q2ZnBQ1JZHhDZmdXbGdEYXBwAApyZWNMYW5kTnVtAAAAC3JlY0xhbmRTaXplAAEAC3JlY1RlcnJhaW5zAAIADHJlY0NvbnRpbmVudAADARFrZXlSZXNQcm9wb3J0aW9ucwACE3Jlc1R5cGVzUHJvcG9ydGlvbnMBFWtleVN0YWtlZExhbmRzQnlPd25lcgEJb3duZXJBZGRyCQCsAgICE3N0YWtlZExhbmRzQnlPd25lcl8FCW93bmVyQWRkcgEWa2V5U3Rha2VkUGllY2VzQnlPd25lcgEJb3duZXJBZGRyCQCsAgICFHN0YWtlZFBpZWNlc0J5T3duZXJfBQlvd25lckFkZHIBCGFzU3RyaW5nAQF2BAckbWF0Y2gwBQF2AwkAAQIFByRtYXRjaDACBlN0cmluZwQBcwUHJG1hdGNoMAUBcwkAAgECGGZhaWwgdG8gY2FzdCBpbnRvIFN0cmluZwEFYXNJbnQBAXYEByRtYXRjaDAFAXYDCQABAgUHJG1hdGNoMAIDSW50BAFuBQckbWF0Y2gwBQFuCQACAQIVZmFpbCB0byBjYXN0IGludG8gSW50AQ9udW1QaWVjZXNCeVNpemUBCGxhbmRTaXplBAckbWF0Y2gwBQhsYW5kU2l6ZQMJAAACAgFTBQckbWF0Y2gwBQVTU0laRQMJAAACAgFNBQckbWF0Y2gwBQVNU0laRQMJAAACAgFMBQckbWF0Y2gwBQVMU0laRQMJAAACAgJYTAUHJG1hdGNoMAUGWExTSVpFAwkAAAICA1hYTAUHJG1hdGNoMAUHWFhMU0laRQkAAgECEVVua25vd24gbGFuZCBzaXplAA1pbmN1YmF0b3JBZGRyBAckbWF0Y2gwBQVjaGFpbgMJAAACAQFXBQckbWF0Y2gwCQERQGV4dHJOYXRpdmUoMTA2MikBAiMzUEVrdFZ1eDJSaGNoU042M0RzRG80YjRtejRRcXpLU2VEdgMJAAACAQFUBQckbWF0Y2gwBQR0aGlzCQACAQINVW5rbm93biBjaGFpbgALYnJlZWRlckFkZHIEByRtYXRjaDAFBWNoYWluAwkAAAIBAVcFByRtYXRjaDAJARFAZXh0ck5hdGl2ZSgxMDYyKQECIzNQRFZ1VTQ1SDdFaDVkbXROYm5STlJTdEd3VUxBN05ZNkhiAwkAAAIBAVQFByRtYXRjaDAFBHRoaXMJAAIBAg1Vbmtub3duIGNoYWluAANwdWIBIE9T4ho/VKjWnVJOEx1GJ1W9s1PzLHvJVFSw/0PBtBQoAAhtZWRLaXRIcAkAzAgCAB4JAMwIAgA8CQDMCAIAeAUDbmlsABFGSVZFTUlOVVRFU01JTExJUwDgpxIADFJFTkFNSU5HQ09TVADAlrECAApNQVhOQU1FTEVOADIAFUluZnJhVXBncmFkZUNvc3RTVXNkdACAreIEAAxFWFBNQVRFUklBTFMEByRtYXRjaDAFBWNoYWluAwkAAAIBAVcFByRtYXRjaDAApt2C7asHAwkAAAIBAVQFByRtYXRjaDAAqqeBswkJAAIBAg1Vbmtub3duIGNoYWluAAdFWFBVU0RUBAckbWF0Y2gwBQVjaGFpbgMJAAACAQFXBQckbWF0Y2gwAIDlmncDCQAAAgEBVAUHJG1hdGNoMACA5Zp3CQACAQINVW5rbm93biBjaGFpbgAFRklWRVgJALYCAQAFAAdUV0VOVFlYCQC2AgEAFAAIVFdFTlRZMlgJALYCAQkAaAIAFAAUAAhUV0VOVFkzWAkAtgIBCQBoAgkAaAIAFAAUABQACFRXRU5UWTRYCQC2AgEJAGgCCQBoAgkAaAIAFAAUABQAFAAIVFdFTlRZNVgJALYCAQkAaAIJAGgCCQBoAgkAaAIAFAAUABQAFAAUAA9QUkVTQUxFTlVNTEFORFMA9AMBEmtleU5leHRGcmVlTGFuZE51bQACC25leHRMYW5kTnVtARBrZXlMYW5kVG9Bc3NldElkAQdsYW5kTnVtCQCsAgICDGxhbmRUb0Fzc2V0XwUHbGFuZE51bQEaa2V5TGFuZEN1c3RvbU5hbWVUb0Fzc2V0SWQBBG5hbWUJAKwCAgIRbGFuZEJ5Q3VzdG9tTmFtZV8FBG5hbWUBHmtleUluZnJhTGV2ZWxCeUFzc2V0SWRBbmRPd25lcgIHYXNzZXRJZAlvd25lckFkZHIJAKwCAgkArAICCQCsAgICHGluZnJhTGV2ZWxCeUFzc2V0SWRBbmRPd25lcl8FB2Fzc2V0SWQCAV8FCW93bmVyQWRkcgEla2V5TGFuZEFydFN0YXR1c0J5VHlwZUFzc2V0SWRBbmRPd25lcgMEdHlwZQdhc3NldElkCW93bmVyQWRkcgkAuQkCCQDMCAICImxhbmRBcnRTdGF0dXNCeVR5cGVBc3NldElkQW5kT3duZXIJAMwIAgUEdHlwZQkAzAgCBQdhc3NldElkCQDMCAIFCW93bmVyQWRkcgUDbmlsAgFfARFrZXlMYW5kTnVtVG9Pd25lcgEHbGFuZE51bQkArAICAgpsYW5kT3duZXJfBQdsYW5kTnVtARprZXlEdWNrQ3VzdG9tTmFtZVRvQXNzZXRJZAEEbmFtZQkArAICAhFkdWNrQnlDdXN0b21OYW1lXwUEbmFtZQEWa2V5Q3VzdG9tTmFtZVRvQWRkcmVzcwEEbmFtZQkArAICAhRhY2NvdW50QnlDdXN0b21OYW1lXwUEbmFtZQEJa2V5T2xkaWVzAAIKb2xkaWVzTGlzdAALY2xhaW1Nb2RlV2gAAAANY2xhaW1Nb2RlRHVjawABABNjbGFpbU1vZGVXaFRoZW5EdWNrAAIACGZsSGVhbHRoAAAAC2ZsVGltZXN0YW1wAAUAB2ZsQm9udXMABgALZmxQcm9kc1VzZWQABwEHbmZ0TmFtZQIHbGFuZE51bQhsYW5kU2l6ZQkArAICCQCsAgIFCkxBTkRQUkVGSVgFB2xhbmROdW0FCGxhbmRTaXplARNkaXN0cmlidXRlQnlXZWlnaHRzAgV0b3RhbAd3ZWlnaHRzBANzdW0JAGQCCQBkAgkAZAIJAGQCCQBkAgkAkQMCBQd3ZWlnaHRzAAAJAJEDAgUHd2VpZ2h0cwABCQCRAwIFB3dlaWdodHMAAgkAkQMCBQd3ZWlnaHRzAAMJAJEDAgUHd2VpZ2h0cwAECQCRAwIFB3dlaWdodHMABQMJAGcCAAAFA3N1bQkAAgECEFplcm8gd2VpZ2h0cyBzdW0EBW5vcm02CQBrAwUFdG90YWwFBU1VTFQ2BQNzdW0KAQpub3JtYWxpemVyAgNhY2MEZWxlbQkAzQgCBQNhY2MJAGsDBQRlbGVtBQVub3JtNgUFTVVMVDYKAAIkbAUHd2VpZ2h0cwoAAiRzCQCQAwEFAiRsCgAFJGFjYzAFA25pbAoBBSRmMF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEKbm9ybWFsaXplcgIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQITTGlzdCBzaXplIGV4Y2VlZHMgNgkBBSRmMF8yAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgESZ2V0TmVlZGVkTWF0ZXJpYWxzAQV0b3RhbAQFcHJvcHMJALUJAgkBBXZhbHVlAQkAoggBCQERa2V5UmVzUHJvcG9ydGlvbnMAAgFfAwkBAiE9AgkAkAMBBQVwcm9wcwUGTlVNUkVTCQACAQIWV3JvbmcgcHJvcG9ydGlvbnMgZGF0YQQBcgkAzAgCCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUFcHJvcHMAAAkAzAgCCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUFcHJvcHMAAQkAzAgCCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUFcHJvcHMAAgkAzAgCCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUFcHJvcHMAAwkAzAgCCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUFcHJvcHMABAkAzAgCCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUFcHJvcHMABQUDbmlsCQETZGlzdHJpYnV0ZUJ5V2VpZ2h0cwIFBXRvdGFsBQFyARFzdWJ0cmFjdE1hdGVyaWFscwMMc2hvdWxkVXNlTWF0A2hhcwl0b3RhbE5lZWQEBG5lZWQJARJnZXROZWVkZWRNYXRlcmlhbHMBBQl0b3RhbE5lZWQKAQpzdWJ0cmFjdG9yAgNhY2MDaWR4BAZyZXN1bHQJAGUCCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUDaGFzBQNpZHgJAJEDAgUEbmVlZAUDaWR4AwkAZgIAAAUGcmVzdWx0CQACAQkArAICCQCsAgIJAKwCAgkArAICCQCsAgICGE5vdCBlbm91Z2ggbWF0ZXJpYWwgaWR4PQkApAMBBQNpZHgCCywgeW91IGhhdmUgCQCRAwIFA2hhcwUDaWR4AgssIGJ1dCBuZWVkIAkApAMBCQCRAwIFBG5lZWQFA2lkeAkAzQgCBQNhY2MJAKQDAQUGcmVzdWx0AwUMc2hvdWxkVXNlTWF0CgACJGwJAMwIAgAACQDMCAIAAQkAzAgCAAIJAMwIAgADCQDMCAIABAkAzAgCAAUFA25pbAoAAiRzCQCQAwEFAiRsCgAFJGFjYzAFA25pbAoBBSRmMF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEKc3VidHJhY3RvcgIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQITTGlzdCBzaXplIGV4Y2VlZHMgNgkBBSRmMF8yAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgUDaGFzARBzdWJ0cmFjdFByb2R1Y3RzAgRwSGFzBXBVc2VkAwkAAAIFBXBVc2VkAgAFBHBIYXMEBXBMaXN0AwkAAAIFBHBIYXMCAAUDbmlsCQC1CQIFBHBIYXMCAV8KAQRzdWJQAgNhY2MEaXRlbQQBaggFA2FjYwJfMQoBCWNoZWNrVXNlZAICYWMGaWR4QW10BAVwYXJ0cwkAtQkCBQZpZHhBbXQCASwDCQECIT0CCQCQAwEFBXBhcnRzAAIJAAIBAihJbmNvcnJlY3QgZm9ybWF0LCBzaG91bGQgYmUgaW5kZXgsYW1vdW50BANpZHgJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQVwYXJ0cwAAAwMJAGYCAAAFA2lkeAYJAGcCBQNpZHgJAJADAQUQcHJvZHVjdGlvbk1hdHJpeAkAAgECE1Vua25vd24gcHJvZHVjdCBpZHgDCQECIT0CBQNpZHgFAWoFAmFjBANhbXQJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQVwYXJ0cwABAwkAZwIAAAUDYW10CQACAQIaUGFzcyBvbmx5IHBvc2l0aXZlIGFtb3VudHMJAGQCBQJhYwUDYW10BAFhCgACJGwJALUJAgUFcFVzZWQCAV8KAAIkcwkAkAMBBQIkbAoABSRhY2MwAAAKAQUkZjBfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBCWNoZWNrVXNlZAIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQUkZjBfMgIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgQEY3VycgMJAGYCCQCQAwEFBXBMaXN0BQFqCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUFcExpc3QFAWoAAAQGbmV3QW10AwkAZwIFBGN1cnIFAWEJAGUCBQRjdXJyBQFhCQACAQkArAICCQCsAgIJAKwCAgkArAICCQCsAgICCVlvdSBoYXZlIAkApAMBBQRjdXJyAgQgb2YgCQCRAwIFCXByb2RUeXBlcwUBagITLCBidXQgdHJpZWQgdG8gdXNlIAkApAMBBQFhCQCUCgIJAGQCBQFqAAEJAM0IAggFA2FjYwJfMgkApAMBBQZuZXdBbXQEB25ld1Byb2QKAAIkbAUQcHJvZHVjdGlvbk1hdHJpeAoAAiRzCQCQAwEFAiRsCgAFJGFjYzAJAJQKAgAABQNuaWwKAQUkZjBfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBBHN1YlACBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjBfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDUwCQEFJGYwXzICCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoACwAMAA0ADgAPABAAEQASABMAFAAVABYAFwAYABkAGgAbABwAHQAeAB8AIAAhACIAIwAkACUAJgAnACgAKQAqACsALAAtAC4ALwAwADEAMgkAuQkCCAUHbmV3UHJvZAJfMgIBXwEZdXBkYXRlUHJvcG9ydGlvbnNJbnRlcm5hbAQIcHJvcExpc3QNdGVycmFpbkNvdW50cw1sYW5kU2l6ZUluZGV4BHNpZ24DCQECIT0CCQCQAwEFCHByb3BMaXN0BQZOVU1SRVMJAAIBAhZXcm9uZyBwcm9wb3J0aW9ucyBkYXRhCgEHdXBkYXRlcgIDYWNjAWkEBnJlc3VsdAkAZAIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQhwcm9wTGlzdAUBaQkAaAIJAGgCBQRzaWduCQCRAwIFDXRlcnJhaW5Db3VudHMFAWkFDWxhbmRTaXplSW5kZXgDCQBmAgAABQZyZXN1bHQJAAIBCQCsAgIJAKwCAgkArAICCQCsAgIJAKwCAgkArAICCQCsAgICFlBhbmljISBQaWVjZXMgb2YgdHlwZT0JAKQDAQUBaQIHLCBzaWduPQkApAMBBQRzaWduAhQsICB0ZXJyYWluQ291bnRzW2ldPQkApAMBCQCRAwIFDXRlcnJhaW5Db3VudHMFAWkCECwgbGFuZFNpemVJbmRleD0JAKQDAQUNbGFuZFNpemVJbmRleAkAzQgCBQNhY2MJAKQDAQUGcmVzdWx0BAFyCgACJGwJAMwIAgAACQDMCAIAAQkAzAgCAAIJAMwIAgADCQDMCAIABAkAzAgCAAUFA25pbAoAAiRzCQCQAwEFAiRsCgAFJGFjYzAFA25pbAoBBSRmMF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEHdXBkYXRlcgIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQITTGlzdCBzaXplIGV4Y2VlZHMgNgkBBSRmMF8yAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgkAuQkCBQFyAgFfARF1cGRhdGVQcm9wb3J0aW9ucwMNdGVycmFpbkNvdW50cw1sYW5kU2l6ZUluZGV4BHNpZ24ECHByb3BMaXN0CQC1CQIJAQt2YWx1ZU9yRWxzZQIJAKIIAQkBEWtleVJlc1Byb3BvcnRpb25zAAILMF8wXzBfMF8wXzACAV8JARl1cGRhdGVQcm9wb3J0aW9uc0ludGVybmFsBAUIcHJvcExpc3QFDXRlcnJhaW5Db3VudHMFDWxhbmRTaXplSW5kZXgFBHNpZ24BDWNvdW50VGVycmFpbnMBCHRlcnJhaW5zCQDMCAIJAGUCCQCQAwEJALUJAgUIdGVycmFpbnMCAUEAAQkAzAgCCQBlAgkAkAMBCQC1CQIFCHRlcnJhaW5zAgFCAAEJAMwIAgkAZQIJAJADAQkAtQkCBQh0ZXJyYWlucwIBQwABCQDMCAIJAGUCCQCQAwEJALUJAgUIdGVycmFpbnMCAUQAAQkAzAgCCQBlAgkAkAMBCQC1CQIFCHRlcnJhaW5zAgFFAAEJAMwIAgkAZQIJAJADAQkAtQkCBQh0ZXJyYWlucwIBRgABBQNuaWwBBmFkZFJlcwUKY3VycmVudFJlcw10ZXJyYWluQ291bnRzCWRlbHRhVGltZQ1sYW5kU2l6ZUluZGV4F2RhaWx5QnlQaWVjZVdpdGhCb251c2VzCgEFYWRkZXICA2FjYwFpBAlyZXNPZlR5cGUJAGgCCQBoAgkAawMFCWRlbHRhVGltZQUXZGFpbHlCeVBpZWNlV2l0aEJvbnVzZXMFCURBWU1JTExJUwkAkQMCBQ10ZXJyYWluQ291bnRzBQFpBQ1sYW5kU2l6ZUluZGV4CQDNCAIFA2FjYwkApAMBCQBkAgkBDXBhcnNlSW50VmFsdWUBCQCRAwIFCmN1cnJlbnRSZXMFAWkFCXJlc09mVHlwZQQBcgoAAiRsCQDMCAIAAAkAzAgCAAEJAMwIAgACCQDMCAIAAwkAzAgCAAQJAMwIAgAFBQNuaWwKAAIkcwkAkAMBBQIkbAoABSRhY2MwBQNuaWwKAQUkZjBfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBBWFkZGVyAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGYwXzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhNMaXN0IHNpemUgZXhjZWVkcyA2CQEFJGYwXzICCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECBQUkYWNjMAAAAAEAAgADAAQABQAGCQC5CQIFAXICAV8BCXZpcnRDbGFpbQQNdGVycmFpbkNvdW50cwlkZWx0YVRpbWUNbGFuZFNpemVJbmRleBdkYWlseUJ5UGllY2VXaXRoQm9udXNlcwoBBWFkZGVyAgNhY2MBaQQJcmVzT2ZUeXBlCQBoAgkAaAIJAGsDBQlkZWx0YVRpbWUFF2RhaWx5QnlQaWVjZVdpdGhCb251c2VzBQlEQVlNSUxMSVMJAJEDAgUNdGVycmFpbkNvdW50cwUBaQUNbGFuZFNpemVJbmRleAkAlAoCCQDNCAIIBQNhY2MCXzEFCXJlc09mVHlwZQkAZAIIBQNhY2MCXzIFCXJlc09mVHlwZQoAAiRsCQDMCAIAAAkAzAgCAAEJAMwIAgACCQDMCAIAAwkAzAgCAAQJAMwIAgAFBQNuaWwKAAIkcwkAkAMBBQIkbAoABSRhY2MwCQCUCgIFA25pbAAACgEFJGYwXzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQVhZGRlcgIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQITTGlzdCBzaXplIGV4Y2VlZHMgNgkBBSRmMF8yAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgENZGlzdHJpYnV0ZVJlcwQMY3VycmVudFdoUmVzDmN1cnJlbnRQYWNrUmVzCnJlc1RvQ2xhaW0Ld2hTcGFjZUxlZnQEDnJlc0xpc3RUb0NsYWltCAUKcmVzVG9DbGFpbQJfMQQMcmVzQW1Ub0NsYWltCAUKcmVzVG9DbGFpbQJfMgMJAAACBQxyZXNBbVRvQ2xhaW0AAAkAlAoCCQC5CQIFDGN1cnJlbnRXaFJlcwIBXwkAuQkCBQ5jdXJyZW50UGFja1JlcwIBXwMJAGcCBQt3aFNwYWNlTGVmdAUMcmVzQW1Ub0NsYWltCgEIYWRkTGlzdHMCA2FjYwFpCQDNCAIFA2FjYwkApAMBCQBkAgkBDXBhcnNlSW50VmFsdWUBCQCRAwIFDGN1cnJlbnRXaFJlcwUBaQkAkQMCBQ5yZXNMaXN0VG9DbGFpbQUBaQQBcgoAAiRsCQDMCAIAAAkAzAgCAAEJAMwIAgACCQDMCAIAAwkAzAgCAAQJAMwIAgAFBQNuaWwKAAIkcwkAkAMBBQIkbAoABSRhY2MwBQNuaWwKAQUkZjBfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBCGFkZExpc3RzAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGYwXzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhNMaXN0IHNpemUgZXhjZWVkcyA2CQEFJGYwXzICCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECBQUkYWNjMAAAAAEAAgADAAQABQAGCQCUCgIJALkJAgUBcgIBXwkAuQkCBQ5jdXJyZW50UGFja1JlcwIBXwoBDGFkZFBhcnRMaXN0cwIDYWNjAWkEBndoUGFydAkAawMJAJEDAgUOcmVzTGlzdFRvQ2xhaW0FAWkFC3doU3BhY2VMZWZ0BQxyZXNBbVRvQ2xhaW0JAJQKAgkAzQgCCAUDYWNjAl8xCQCkAwEJAGQCCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUMY3VycmVudFdoUmVzBQFpBQZ3aFBhcnQJAM0IAggFA2FjYwJfMgkApAMBCQBlAgkAZAIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQ5jdXJyZW50UGFja1JlcwUBaQkAkQMCBQ5yZXNMaXN0VG9DbGFpbQUBaQUGd2hQYXJ0BAFyCgACJGwJAMwIAgAACQDMCAIAAQkAzAgCAAIJAMwIAgADCQDMCAIABAkAzAgCAAUFA25pbAoAAiRzCQCQAwEFAiRsCgAFJGFjYzAJAJQKAgUDbmlsBQNuaWwKAQUkZjBfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBDGFkZFBhcnRMaXN0cwIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQITTGlzdCBzaXplIGV4Y2VlZHMgNgkBBSRmMF8yAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgkAlAoCCQC5CQIIBQFyAl8xAgFfCQC5CQIIBQFyAl8yAgFfAQNhYnMBAXgDCQDAAgIFAXgJALYCAQAABQF4CQC+AgEFAXgABGZyZXEJAMwIAgkAzAgCAAYJAMwIAgAJCQDMCAIADgkAzAgCAA8JAMwIAgAQBQNuaWwJAMwIAgkAzAgCAAUJAMwIAgAICQDMCAIADQkAzAgCAA4JAMwIAgAPBQNuaWwJAMwIAgkAzAgCAAEJAMwIAgAECQDMCAIACQkAzAgCAAoJAMwIAgAPBQNuaWwJAMwIAgkAzAgCAAEJAMwIAgAGCQDMCAIABwkAzAgCAA8JAMwIAgATBQNuaWwJAMwIAgkAzAgCAAQJAMwIAgAHCQDMCAIACAkAzAgCAA0JAMwIAgASBQNuaWwFA25pbAEHZ2VuQ2hhcgIBbgVmcmVxcwQDcmVtCQCgAwEJALsCAgUBbgUHVFdFTlRZWAQGbGV0dGVyAwkAZgIJAJEDAgUFZnJlcXMAAAUDcmVtAgFBAwkAZgIJAJEDAgUFZnJlcXMAAQUDcmVtAgFCAwkAZgIJAJEDAgUFZnJlcXMAAgUDcmVtAgFDAwkAZgIJAJEDAgUFZnJlcXMAAwUDcmVtAgFEAwkAZgIJAJEDAgUFZnJlcXMABAUDcmVtAgFFAgFGBQZsZXR0ZXIBC2dlblRlcnJhaW5zAgRzZWVkDGNvbnRpbmVudElkeAQBZgkAkQMCBQRmcmVxBQxjb250aW5lbnRJZHgKARB0ZXJyYWluR2VuZXJhdG9yAgNhY2MEZWxlbQkAlAoCCQCsAgIJAKwCAgkArAICCQCsAgIJAKwCAggFA2FjYwJfMQkBB2dlbkNoYXICCAUDYWNjAl8yBQFmCQEHZ2VuQ2hhcgIJALoCAggFA2FjYwJfMgUHVFdFTlRZWAUBZgkBB2dlbkNoYXICCQC6AgIIBQNhY2MCXzIFCFRXRU5UWTJYBQFmCQEHZ2VuQ2hhcgIJALoCAggFA2FjYwJfMgUIVFdFTlRZM1gFAWYJAQdnZW5DaGFyAgkAugICCAUDYWNjAl8yBQhUV0VOVFk0WAUBZgkAugICCAUDYWNjAl8yBQhUV0VOVFk1WAQBdAoAAiRsCQDMCAIAAQkAzAgCAAIJAMwIAgADCQDMCAIABAkAzAgCAAUFA25pbAoAAiRzCQCQAwEFAiRsCgAFJGFjYzAJAJQKAgIACQC6AgIFBHNlZWQFBUZJVkVYCgEFJGYwXzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJARB0ZXJyYWluR2VuZXJhdG9yAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGYwXzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhNMaXN0IHNpemUgZXhjZWVkcyA1CQEFJGYwXzICCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECBQUkYWNjMAAAAAEAAgADAAQABQgFAXQCXzEBC2dldEJhY2twYWNrAQVicEtleQQBcAkAtQkCCQELdmFsdWVPckVsc2UCCQCiCAEFBWJwS2V5AhowOjBfMF8wXzBfMF8wOjBfMF8wXzBfMF8wOgIBOgkAzAgCCQCkAwEJAQt2YWx1ZU9yRWxzZQIJALYJAQkAkQMCBQFwBQpicElkeExldmVsAAAJAMwIAgMJAAACCQCQAwEJALUJAgkAkQMCBQFwBQhicElkeFJlcwIBXwUGTlVNUkVTCQCRAwIFAXAFCGJwSWR4UmVzAgswXzBfMF8wXzBfMAkAzAgCAwkAAAIJAJADAQkAtQkCCQCRAwIFAXAFCGJwSWR4TWF0AgFfBQZOVU1SRVMJAJEDAgUBcAUIYnBJZHhNYXQCCzBfMF8wXzBfMF8wCQDMCAIJAJEDAgUBcAUJYnBJZHhQcm9kBQNuaWwBF2dldFdhcmVob3VzZVRvdGFsVm9sdW1lAQl2b2xQcmVmaXgEBXBhcnRzCQC1CQIFCXZvbFByZWZpeAIBXwkAaAIJAGgCBQxXSE1VTFRJUExJRVIJAGQCCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUFcGFydHMAAQABCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUFcGFydHMAAAEXZ2V0V2FyZWhvdXNlT2NjdXBpZWRWb2wBCWN1cnJlbnRXaAQFZ29vZHMJAJEDAgUJY3VycmVudFdoBQl3aElkeFByb2QKAQlzdW1SZXNNYXQCA2FjYwRpdGVtCQBkAgUDYWNjCQENcGFyc2VJbnRWYWx1ZQEFBGl0ZW0KAQdzdW1Qcm9kAgNhY2MEaXRlbQQDaWR4CAUDYWNjAl8xBARwa2dzCQBpAgkAZQIJAGQCCQENcGFyc2VJbnRWYWx1ZQEFBGl0ZW0FDnByb2R1Y3RQa2dTaXplAAEFDnByb2R1Y3RQa2dTaXplCQCUCgIJAGQCBQNpZHgAAQkAZAIIBQNhY2MCXzIJAGgCBQRwa2dzBQVNVUxUOAQId2hSZXNWb2wKAAIkbAkAtQkCCQCRAwIFCWN1cnJlbnRXaAUId2hJZHhSZXMCAV8KAAIkcwkAkAMBBQIkbAoABSRhY2MwAAAKAQUkZjBfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBCXN1bVJlc01hdAIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQITTGlzdCBzaXplIGV4Y2VlZHMgNgkBBSRmMF8yAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgQId2hNYXRWb2wKAAIkbAkAtQkCCQCRAwIFCWN1cnJlbnRXaAUId2hJZHhNYXQCAV8KAAIkcwkAkAMBBQIkbAoABSRhY2MwAAAKAQUkZjFfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBCXN1bVJlc01hdAIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMV8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQITTGlzdCBzaXplIGV4Y2VlZHMgNgkBBSRmMV8yAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgQKd2hHb29kc1ZvbAMJAAACBQVnb29kcwIAAAAICgACJGwJALwJAgUFZ29vZHMCAV8KAAIkcwkAkAMBBQIkbAoABSRhY2MwCQCUCgIAAAAACgEFJGYyXzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQdzdW1Qcm9kAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGYyXzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyA1MAkBBSRmMl8yAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKAAsADAANAA4ADwAQABEAEgATABQAFQAWABcAGAAZABoAGwAcAB0AHgAfACAAIQAiACMAJAAlACYAJwAoACkAKgArACwALQAuAC8AMAAxADICXzIJAGQCCQBkAgUId2hSZXNWb2wFCHdoTWF0Vm9sBQp3aEdvb2RzVm9sAQxnZXRXYXJlaG91c2UDBXdoS2V5CWxhbmRJbmRleAppbmZyYUxldmVsBAl2b2xQcmVmaXgJAKwCAgkArAICCQCkAwEFCWxhbmRJbmRleAIBXwkApAMBBQppbmZyYUxldmVsBAd3aFRvdGFsCQEXZ2V0V2FyZWhvdXNlVG90YWxWb2x1bWUBBQl2b2xQcmVmaXgEBXdoU3RyCQELdmFsdWVPckVsc2UCCQCiCAEFBXdoS2V5CQCsAgIFCXZvbFByZWZpeAIbOjBfMF8wXzBfMF8wOjBfMF8wXzBfMF8wOjowBAJ3aAkAvAkCBQV3aFN0cgIBOgQKd2hPY2N1cGllZAkBF2dldFdhcmVob3VzZU9jY3VwaWVkVm9sAQUCd2gEBndoTG9mdAMJAGYCAAUJAJADAQUCd2gJALkJAgkAzAgCAgEwCQDMCAIJAKQDAQUKd2hPY2N1cGllZAkAzAgCCQCkAwEJAGUCBQd3aFRvdGFsBQp3aE9jY3VwaWVkCQDMCAIJAKQDAQUHd2hUb3RhbAUDbmlsAgFfBARsb2Z0CQC1CQIJAJEDAgUCd2gFCXdoSWR4TE9GVAIBXwQId2hMb2NrZWQJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQRsb2Z0BQl2b2xMb2NrZWQEA29jYwMJAGYCCQCQAwEFBGxvZnQAAQkBDXBhcnNlSW50VmFsdWUBCQCRAwIFBGxvZnQFC3ZvbE9jY3VwaWVkBQp3aE9jY3VwaWVkCQC5CQIJAMwIAgkApAMBBQh3aExvY2tlZAkAzAgCCQCkAwEFA29jYwkAzAgCCQCkAwEJAGUCCQBlAgUHd2hUb3RhbAUId2hMb2NrZWQFA29jYwkAzAgCCQCkAwEFB3doVG90YWwFA25pbAIBXwkAzAgCCQCRAwIFAndoBQt3aElkeExldmVscwkAzAgCAwkAAAIJAJADAQkAtQkCCQCRAwIFAndoBQh3aElkeFJlcwIBXwUGTlVNUkVTCQCRAwIFAndoBQh3aElkeFJlcwILMF8wXzBfMF8wXzAJAMwIAgMJAAACCQCQAwEJALUJAgkAkQMCBQJ3aAUId2hJZHhNYXQCAV8FBk5VTVJFUwkAkQMCBQJ3aAUId2hJZHhNYXQCCzBfMF8wXzBfMF8wCQDMCAIJAJEDAgUCd2gFCXdoSWR4UHJvZAkAzAgCBQZ3aExvZnQFA25pbAEVZ2V0V2FyZWhvdXNlU3BhY2VMZWZ0AQljdXJyZW50V2gEC29jY3VwaWVkVm9sCQEXZ2V0V2FyZWhvdXNlT2NjdXBpZWRWb2wBBQljdXJyZW50V2gED2N1cnJXaExvY2tlZFZvbAkBDXBhcnNlSW50VmFsdWUBCQCRAwIJALUJAgkAkQMCBQljdXJyZW50V2gFCXdoSWR4TE9GVAIBXwUJdm9sTG9ja2VkCQBlAgkAZQIJARdnZXRXYXJlaG91c2VUb3RhbFZvbHVtZQEJAJEDAgUJY3VycmVudFdoBQt3aElkeExldmVscwULb2NjdXBpZWRWb2wFD2N1cnJXaExvY2tlZFZvbAEIdG9Wb2x1bWUCBmFtb3VudAdwa2dTaXplBARwa2dzAwkAZwIFBmFtb3VudAAACQBpAgkAZQIJAGQCBQZhbW91bnQFB3BrZ1NpemUAAQUHcGtnU2l6ZQkBAS0BCQBpAgkAZQIJAGQCCQEBLQEFBmFtb3VudAUHcGtnU2l6ZQABBQdwa2dTaXplCQBoAgUEcGtncwUFTVVMVDgBCW1vdmVTdHVmZgMKY2FyZ29QYXJ0cwljdXJyZW50V2gLY3VycmVudFBhY2sDCQECIT0CCQCQAwEFCmNhcmdvUGFydHMAAwkAAgECNGNhcmdvTGlzdFN0ciBzaG91bGQgY29udGFpbiBleGFjdGx5IDIgJzonIHNlcGFyYXRvcnMECHJlc1BhcnRzCQC1CQIJAJEDAgUKY2FyZ29QYXJ0cwAAAgFfBAhtYXRQYXJ0cwkAtQkCCQCRAwIFCmNhcmdvUGFydHMAAQIBXwQJcHJvZFBhcnRzAwkAAAIJAJEDAgUKY2FyZ29QYXJ0cwACAgAFA25pbAkAtQkCCQCRAwIFCmNhcmdvUGFydHMAAgIBXwMJAQIhPQIJAJADAQUIcmVzUGFydHMFBk5VTVJFUwkAAgECIEFsbCA2IHJlc291cmNlcyBzaG91bGQgYmUgcGFzc2VkAwkBAiE9AgkAkAMBBQhtYXRQYXJ0cwUGTlVNUkVTCQACAQIgQWxsIDYgbWF0ZXJpYWxzIHNob3VsZCBiZSBwYXNzZWQEC3doU3BhY2VMZWZ0CQEVZ2V0V2FyZWhvdXNlU3BhY2VMZWZ0AQUJY3VycmVudFdoBAljdXJyV2hSZXMJALUJAgkAkQMCBQljdXJyZW50V2gFCHdoSWR4UmVzAgFfBAljdXJyV2hNYXQJALUJAgkAkQMCBQljdXJyZW50V2gFCHdoSWR4TWF0AgFfBApjdXJyV2hQcm9kAwkAAAIJAJEDAgUJY3VycmVudFdoBQl3aElkeFByb2QCAAUDbmlsCQC1CQIJAJEDAgUJY3VycmVudFdoBQl3aElkeFByb2QCAV8EDmN1cnJlbnRQYWNrUmVzCQC1CQIJAJEDAgULY3VycmVudFBhY2sFCGJwSWR4UmVzAgFfBA5jdXJyZW50UGFja01hdAkAtQkCCQCRAwIFC2N1cnJlbnRQYWNrBQhicElkeE1hdAIBXwQPY3VycmVudFBhY2tQcm9kAwkAAAIJAJEDAgULY3VycmVudFBhY2sFCWJwSWR4UHJvZAIABQNuaWwJALUJAgkAkQMCBQtjdXJyZW50UGFjawUJYnBJZHhQcm9kAgFfCgEDbXZSAgNhY2MEaXRlbQQBaQgFA2FjYwJfMQQCYW0JAQ1wYXJzZUludFZhbHVlAQUEaXRlbQQDd2hyCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUJY3VycldoUmVzBQFpBANicHIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQ5jdXJyZW50UGFja1JlcwUBaQMJAAACBQJhbQAACQCWCgQJAGQCBQFpAAEJAM0IAggFA2FjYwJfMgkAkQMCBQljdXJyV2hSZXMFAWkJAM0IAggFA2FjYwJfMwkAkQMCBQ5jdXJyZW50UGFja1JlcwUBaQgFA2FjYwJfNAMJAGYCBQJhbQAAAwkAZgIFAmFtBQNicHIJAAIBCQCsAgIJAKwCAgkArAICCQCsAgICEEF0dGVtcHQgdG8gdGFrZSAFBGl0ZW0CGSBmcm9tIGJhY2twYWNrLCBidXQgb25seSAJAKQDAQUDYnByAgogYXZhaWxhYmxlCQCWCgQJAGQCBQFpAAEJAM0IAggFA2FjYwJfMgkApAMBCQBkAgUDd2hyBQJhbQkAzQgCCAUDYWNjAl8zCQCkAwEJAGUCBQNicHIFAmFtCQBkAggFA2FjYwJfNAUCYW0DCQBmAgkBAS0BBQJhbQUDd2hyCQACAQkArAICCQCsAgIJAKwCAgkArAICAhBBdHRlbXB0IHRvIHRha2UgCQCkAwEJAQEtAQUCYW0CGiBmcm9tIHdhcmVob3VzZSwgYnV0IG9ubHkgCQCkAwEFA3docgIKIGF2YWlsYWJsZQkAlgoECQBkAgUBaQABCQDNCAIIBQNhY2MCXzIJAKQDAQkAZAIFA3docgUCYW0JAM0IAggFA2FjYwJfMwkApAMBCQBlAgUDYnByBQJhbQkAZAIIBQNhY2MCXzQFAmFtBAFyCgACJGwFCHJlc1BhcnRzCgACJHMJAJADAQUCJGwKAAUkYWNjMAkAlgoEAAAFA25pbAUDbmlsAAAKAQUkZjBfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBA212UgIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQITTGlzdCBzaXplIGV4Y2VlZHMgNgkBBSRmMF8yAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgoBA212TQIDYWNjBGl0ZW0EAWkIBQNhY2MCXzEEAmFtCQENcGFyc2VJbnRWYWx1ZQEFBGl0ZW0EA3dobQkBDXBhcnNlSW50VmFsdWUBCQCRAwIFCWN1cnJXaE1hdAUBaQQDYnBtCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUOY3VycmVudFBhY2tNYXQFAWkDCQAAAgUCYW0AAAkAlgoECQBkAgUBaQABCQDNCAIIBQNhY2MCXzIJAJEDAgUJY3VycldoTWF0BQFpCQDNCAIIBQNhY2MCXzMJAJEDAgUOY3VycmVudFBhY2tNYXQFAWkIBQNhY2MCXzQDCQBmAgUCYW0AAAMJAGYCBQJhbQUDYnBtCQACAQkArAICCQCsAgIJAKwCAgkArAICAhBBdHRlbXB0IHRvIHRha2UgBQRpdGVtAhkgZnJvbSBiYWNrcGFjaywgYnV0IG9ubHkgCQCkAwEFA2JwbQIKIGF2YWlsYWJsZQkAlgoECQBkAgUBaQABCQDNCAIIBQNhY2MCXzIJAKQDAQkAZAIFA3dobQUCYW0JAM0IAggFA2FjYwJfMwkApAMBCQBlAgUDYnBtBQJhbQkAZAIIBQNhY2MCXzQFAmFtAwkAZgIJAQEtAQUCYW0FA3dobQkAAgEJAKwCAgkArAICCQCsAgIJAKwCAgIQQXR0ZW1wdCB0byB0YWtlIAkApAMBCQEBLQEFAmFtAhogZnJvbSB3YXJlaG91c2UsIGJ1dCBvbmx5IAkApAMBBQN3aG0CCiBhdmFpbGFibGUJAJYKBAkAZAIFAWkAAQkAzQgCCAUDYWNjAl8yCQCkAwEJAGQCBQN3aG0FAmFtCQDNCAIIBQNhY2MCXzMJAKQDAQkAZQIFA2JwbQUCYW0JAGQCCAUDYWNjAl80BQJhbQQBbQoAAiRsBQhtYXRQYXJ0cwoAAiRzCQCQAwEFAiRsCgAFJGFjYzAJAJYKBAAABQNuaWwFA25pbAgFAXICXzQKAQUkZjFfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBA212TQIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMV8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQITTGlzdCBzaXplIGV4Y2VlZHMgNgkBBSRmMV8yAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgoBA212UAIDYWNjBGl0ZW0EAWkIBQNhY2MCXzEEAmFtCQENcGFyc2VJbnRWYWx1ZQEFBGl0ZW0EA3docAMJAGYCCQCQAwEFCmN1cnJXaFByb2QFAWkJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQpjdXJyV2hQcm9kBQFpAAAEA2JwcAMJAGYCCQCQAwEFD2N1cnJlbnRQYWNrUHJvZAUBaQkBDXBhcnNlSW50VmFsdWUBCQCRAwIFD2N1cnJlbnRQYWNrUHJvZAUBaQAAAwkAAAIFAmFtAAAJAJYKBAkAZAIFAWkAAQkAzQgCCAUDYWNjAl8yCQCkAwEFA3docAkAzQgCCAUDYWNjAl8zCQCkAwEFA2JwcAgFA2FjYwJfNAMJAGYCBQJhbQAAAwkAZgIFAmFtBQNicHAJAAIBCQCsAgIJAKwCAgkArAICCQCsAgICEEF0dGVtcHQgdG8gdGFrZSAFBGl0ZW0CGSBmcm9tIGJhY2twYWNrLCBidXQgb25seSAJAKQDAQUDYnBwAgogYXZhaWxhYmxlBAhkZWx0YVZvbAkAZQIJAQh0b1ZvbHVtZQIJAGQCBQN3aHAFAmFtBQ5wcm9kdWN0UGtnU2l6ZQkBCHRvVm9sdW1lAgUDd2hwBQ5wcm9kdWN0UGtnU2l6ZQkAlgoECQBkAgUBaQABCQDNCAIIBQNhY2MCXzIJAKQDAQkAZAIFA3docAUCYW0JAM0IAggFA2FjYwJfMwkApAMBCQBlAgUDYnBwBQJhbQkAZAIIBQNhY2MCXzQFCGRlbHRhVm9sAwkAZgIJAQEtAQUCYW0FA3docAkAAgEJAKwCAgkArAICCQCsAgIJAKwCAgIQQXR0ZW1wdCB0byB0YWtlIAkApAMBCQEBLQEFAmFtAhogZnJvbSB3YXJlaG91c2UsIGJ1dCBvbmx5IAkApAMBBQN3aHACCiBhdmFpbGFibGUECGRlbHRhVm9sCQBlAgkBCHRvVm9sdW1lAgkAZAIFA3docAUCYW0FDnByb2R1Y3RQa2dTaXplCQEIdG9Wb2x1bWUCBQN3aHAFDnByb2R1Y3RQa2dTaXplCQCWCgQJAGQCBQFpAAEJAM0IAggFA2FjYwJfMgkApAMBCQBkAgUDd2hwBQJhbQkAzQgCCAUDYWNjAl8zCQCkAwEJAGUCBQNicHAFAmFtCQBkAggFA2FjYwJfNAUIZGVsdGFWb2wEAXADCQECIT0CCQCQAwEFCXByb2RQYXJ0cwAACgACJGwFCXByb2RQYXJ0cwoAAiRzCQCQAwEFAiRsCgAFJGFjYzAJAJYKBAAABQNuaWwFA25pbAgFAW0CXzQKAQUkZjJfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBA212UAIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMl8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgNTAJAQUkZjJfMgIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIJAQUkZjJfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgALAAwADQAOAA8AEAARABIAEwAUABUAFgAXABgAGQAaABsAHAAdAB4AHwAgACEAIgAjACQAJQAmACcAKAApACoAKwAsAC0ALgAvADAAMQAyCQCWCgQAAAUKY3VycldoUHJvZAUPY3VycmVudFBhY2tQcm9kCAUBbQJfNAQIdm9sU2FsZG8IBQFwAl80AwkAZgIFCHZvbFNhbGRvBQt3aFNwYWNlTGVmdAkAAgEJAKwCAgkArAICCQCsAgIJAKwCAgIVQXR0ZW1wdCB0byBwdXQgdG90YWwgCQCkAwEFCHZvbFNhbGRvAhEgc3R1ZmYsIGJ1dCBvbmx5IAkApAMBBQt3aFNwYWNlTGVmdAIVIHdhcmVob3VzZSBzcGFjZSBsZWZ0CQCZCgcJALkJAggFAXICXzICAV8JALkJAggFAW0CXzICAV8JALkJAggFAXACXzICAV8JALkJAggFAXICXzMCAV8JALkJAggFAW0CXzMCAV8JALkJAggFAXACXzMCAV8FCHZvbFNhbGRvARJleHBlZGl0aW9uSW50ZXJuYWwCBmNhbGxlcgR0eElkBAh1c2VyQWRkcgkApQgBBQZjYWxsZXIEBmJpZ051bQkBA2FicwEJAJ4DAQUEdHhJZAQHZnJlZU51bQkBC3ZhbHVlT3JFbHNlAgkAnwgBCQESa2V5TmV4dEZyZWVMYW5kTnVtAAkAZAIFD1BSRVNBTEVOVU1MQU5EUwABBAdsYW5kTnVtCQCkAwEFB2ZyZWVOdW0EDGNvbnRpbmVudElkeAkAoAMBCQC7AgIFBmJpZ051bQUFRklWRVgECHRlcnJhaW5zCQELZ2VuVGVycmFpbnMCBQZiaWdOdW0FDGNvbnRpbmVudElkeAQJY29udGluZW50CQCRAwIFCmNvbnRpbmVudHMFDGNvbnRpbmVudElkeAQFaXNzdWUJAMIIBQkBB25mdE5hbWUCBQdsYW5kTnVtAgFTCQC5CQIJAMwIAgUHbGFuZE51bQkAzAgCAgFTCQDMCAIFCHRlcnJhaW5zCQDMCAIFCWNvbnRpbmVudAUDbmlsAgFfAAEAAAcEB2Fzc2V0SWQJALgIAQUFaXNzdWUEAmlkCQDYBAEFB2Fzc2V0SWQJAJQKAgkAzAgCCQEMSW50ZWdlckVudHJ5AgkBEmtleU5leHRGcmVlTGFuZE51bQAJAGQCBQdmcmVlTnVtAAEJAMwIAgUFaXNzdWUJAMwIAgkBC1N0cmluZ0VudHJ5AgkBEGtleUxhbmRUb0Fzc2V0SWQBBQdsYW5kTnVtBQJpZAkAzAgCCQELU3RyaW5nRW50cnkCCQEVa2V5TGFuZEFzc2V0SWRUb093bmVyAQUCaWQFCHVzZXJBZGRyCQDMCAIJAQtTdHJpbmdFbnRyeQIJARFrZXlMYW5kTnVtVG9Pd25lcgEFB2xhbmROdW0FCHVzZXJBZGRyCQDMCAIJAQxJbnRlZ2VyRW50cnkCCQEWa2V5SW5mcmFMZXZlbEJ5QXNzZXRJZAEFAmlkAAAJAMwIAgkBDEludGVnZXJFbnRyeQIJAR5rZXlJbmZyYUxldmVsQnlBc3NldElkQW5kT3duZXICBQJpZAUIdXNlckFkZHIAAAkAzAgCCQEOU2NyaXB0VHJhbnNmZXIDBQZjYWxsZXIAAQUHYXNzZXRJZAUDbmlsCQCUCgIFAmlkBQljb250aW5lbnQBDGZsaWdodENvbW1vbgMIdXNlckFkZHIHbWVzc2FnZQNzaWcDCQEBIQEJAMQTAwUHbWVzc2FnZQUDc2lnBQNwdWIJAAIBAhhzaWduYXR1cmUgZG9lcyBub3QgbWF0Y2gEBXBhcnRzCQC1CQIJALAJAQUHbWVzc2FnZQIBOwQJZmxpZ2h0TG9nCQC1CQIJAJEDAgUFcGFydHMAAAIBfAQCaHAJALUJAgkAkQMCBQlmbGlnaHRMb2cFCGZsSGVhbHRoAgFfBAVjdXJIUAkBDXBhcnNlSW50VmFsdWUBCQCRAwIFAmhwAAAEBW5ld0hQCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUCaHAAAQQLbmV3TG9jVHhWZXIJALUJAgkAkQMCBQVwYXJ0cwABAgE6BAtuZXdMb2NhdGlvbgkAkQMCBQtuZXdMb2NUeFZlcgAABAR0aW1lCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUJZmxpZ2h0TG9nBQtmbFRpbWVzdGFtcAMDCQBmAgUEdGltZQkAZAIIBQlsYXN0QmxvY2sJdGltZXN0YW1wBRFGSVZFTUlOVVRFU01JTExJUwYJAGYCCQBlAggFCWxhc3RCbG9jawl0aW1lc3RhbXAFEUZJVkVNSU5VVEVTTUlMTElTBQR0aW1lCQACAQkArAICCQCsAgIJAKwCAgIcc2lnbmF0dXJlIG91dGRhdGVkOiBsb2dUaW1lPQkApAMBBQR0aW1lAgksIGJjVGltZT0JAKQDAQgFCWxhc3RCbG9jawl0aW1lc3RhbXAECXR4RnJvbU1zZwkAkQMCBQtuZXdMb2NUeFZlcgABBAZsYXN0VHgJAQt2YWx1ZU9yRWxzZQIJAKIIAQkBEWtleUxhc3RUeElkQnlVc2VyAQUIdXNlckFkZHICAAMJAQIhPQIFBmxhc3RUeAUJdHhGcm9tTXNnCQACAQkArAICCQCsAgIJAKwCAgIeVHggaWRzIGRvbid0IG1hdGNoISBJbiBzdGF0ZTogBQZsYXN0VHgCCiwgaW4gbXNnOiAFCXR4RnJvbU1zZwQLZHVja0Fzc2V0SWQJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAoggBCQEUa2V5U3Rha2VkRHVja0J5T3duZXIBBQh1c2VyQWRkcgIcWW91IGRvbid0IGhhdmUgYSBkdWNrIHN0YWtlZAQJa2V5SGVhbHRoCQENa2V5RHVja0hlYWx0aAEFC2R1Y2tBc3NldElkBAVtYXhIUAkBCW1heEhlYWx0aAEJAQt2YWx1ZU9yRWxzZQIJAJ8IAQkBDGtleUR1Y2tMZXZlbAEFC2R1Y2tBc3NldElkAAAEDG9sZEZyb21TdGF0ZQkBC3ZhbHVlT3JFbHNlAgkAnwgBBQlrZXlIZWFsdGgFBW1heEhQAwkBAiE9AgUMb2xkRnJvbVN0YXRlBQVjdXJIUAkAAgEJAKwCAgkArAICCQCsAgICCm9sZEhlYWx0aD0JAKQDAQUMb2xkRnJvbVN0YXRlAi8gZnJvbSBzdGF0ZSBkb2VzIG5vdCBtYXRjaCBvbmUgZnJvbSBmbGlnaHQgbG9nPQkApAMBBQVjdXJIUAMJAGcCAAAFBWN1ckhQCQACAQIeWW91IGNhbid0IGZseSB3aXRoIHplcm8gaGVhbHRoBAVib251cwMJAGYCCQCQAwEFCWZsaWdodExvZwUHZmxCb251cwkAkQMCBQlmbGlnaHRMb2cFB2ZsQm9udXMCAAQIcHJvZFVzZWQDCQBmAgkAkAMBBQlmbGlnaHRMb2cFC2ZsUHJvZHNVc2VkCQCRAwIFCWZsaWdodExvZwULZmxQcm9kc1VzZWQCAAQKc2VudEFtb3VudAMDCQBmAgUFbmV3SFAAAAkAAAIFBWJvbnVzAgEkBwkBBWFzSW50AQkA/AcEBQxyZXN0Q29udHJhY3QCDXNlbmRVc2R0UHJpemUJAMwIAgUIdXNlckFkZHIFA25pbAUDbmlsAAAJAJcKBQUFbmV3SFAFC2R1Y2tBc3NldElkBQpzZW50QW1vdW50BQtuZXdMb2NhdGlvbgUIcHJvZFVzZWQBEGV4cGVkaXRpb25Db21tb24EBmNhbGxlcgR0eElkB21lc3NhZ2UDc2lnBAh1c2VyQWRkcgkApQgBBQZjYWxsZXIEAWYJAQxmbGlnaHRDb21tb24DBQh1c2VyQWRkcgUHbWVzc2FnZQUDc2lnBAlrZXlIZWFsdGgJAQ1rZXlEdWNrSGVhbHRoAQgFAWYCXzIEBWJwS2V5CQERa2V5QmFja3BhY2tCeUR1Y2sBCAUBZgJfMgQLY3VycmVudFBhY2sJAQtnZXRCYWNrcGFjawEFBWJwS2V5BAVtTGlzdAkAtQkCCQCRAwIFC2N1cnJlbnRQYWNrBQhicElkeE1hdAIBXwQGbmV3TWF0CQC5CQIJARFzdWJ0cmFjdE1hdGVyaWFscwMGBQVtTGlzdAUMRVhQTUFURVJJQUxTAgFfBAduZXdQcm9kCQEQc3VidHJhY3RQcm9kdWN0cwIJAJEDAgULY3VycmVudFBhY2sFCWJwSWR4UHJvZAgFAWYCXzUDCQBnAgAACAUBZgJfMQkAlQoDCQDMCAIJAQxJbnRlZ2VyRW50cnkCBQlrZXlIZWFsdGgAAAkAzAgCCQELU3RyaW5nRW50cnkCBQVicEtleQkAuQkCCQDMCAIJAJEDAgULY3VycmVudFBhY2sFCmJwSWR4TGV2ZWwJAMwIAgkAkQMCBQtjdXJyZW50UGFjawUIYnBJZHhSZXMJAMwIAgkAkQMCBQtjdXJyZW50UGFjawUIYnBJZHhNYXQJAMwIAgUHbmV3UHJvZAUDbmlsAgE6BQNuaWwCAAAABAFlCQESZXhwZWRpdGlvbkludGVybmFsAgUGY2FsbGVyBQR0eElkBAJpZAgIBQFlAl8yAl8xCQCVCgMJAM0IAgkAzQgCCQDNCAIIBQFlAl8xCQELU3RyaW5nRW50cnkCCQEPa2V5RHVja0xvY2F0aW9uAQgFAWYCXzIJALkJAgkAzAgCCAgFAWUCXzICXzIJAMwIAgIBTAkAzAgCBQJpZAUDbmlsAgFfCQEMSW50ZWdlckVudHJ5AgUJa2V5SGVhbHRoCAUBZgJfMQkBC1N0cmluZ0VudHJ5AgUFYnBLZXkJALkJAgkAzAgCCQCRAwIFC2N1cnJlbnRQYWNrBQpicElkeExldmVsCQDMCAIJAJEDAgULY3VycmVudFBhY2sFCGJwSWR4UmVzCQDMCAIFBm5ld01hdAkAzAgCBQduZXdQcm9kBQNuaWwCAToFAmlkCAUBZgJfMwEMYXBwbHlCb251c2VzAgtsYW5kQXNzZXRJZAZwaWVjZXMECmluZnJhTGV2ZWwJAQt2YWx1ZU9yRWxzZQIJAJ8IAQkBFmtleUluZnJhTGV2ZWxCeUFzc2V0SWQBBQtsYW5kQXNzZXRJZAAABAlhcnRQaWVjZXMJAQt2YWx1ZU9yRWxzZQIJAJ8IAQkBIGtleUxhbmRBcnRTdGF0dXNCeVR5cGVBbmRBc3NldElkAgUKQVJUUFJFU0FMRQULbGFuZEFzc2V0SWQAAAQEYWRkNgkAaQIFCmluZnJhTGV2ZWwABgQEYWRkNwkAaQIFCmluZnJhTGV2ZWwABwkAZAIJAGQCBQ9EQUlMWVJFU0JZUElFQ0UJAGsDBQ9EQUlMWVJFU0JZUElFQ0UJAGQCCQBkAgUKaW5mcmFMZXZlbAUEYWRkNgkAaAIAAgUEYWRkNwAFCQBrAwUPREFJTFlSRVNCWVBJRUNFBQlhcnRQaWVjZXMJAGgCBQZwaWVjZXMABQEUY2hlY2tDbGFpbUNvbmRpdGlvbnMDBGFkZHIJY2xhaW1Nb2RlDWxhbmRBc3NldElkSW4EDSR0MDI0ODQ2MjUzODUDCQAAAgUJY2xhaW1Nb2RlBQtjbGFpbU1vZGVXaAkAlAoCBQ1sYW5kQXNzZXRJZEluCQELdmFsdWVPckVsc2UCCQCiCAEJARRrZXlTdGFrZWREdWNrQnlPd25lcgEFBGFkZHICAAQLZHVja0Fzc2V0SWQJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAoggBCQEUa2V5U3Rha2VkRHVja0J5T3duZXIBBQRhZGRyAhxZb3UgZG9uJ3QgaGF2ZSBhIGR1Y2sgc3Rha2VkBAtjdXJMb2NhdGlvbgkBC3ZhbHVlT3JFbHNlAgkAoggBCQEPa2V5RHVja0xvY2F0aW9uAQULZHVja0Fzc2V0SWQFD0RFRkFVTFRMT0NBVElPTgQDbG9jCQC1CQIJAQV2YWx1ZQEFC2N1ckxvY2F0aW9uAgFfAwkBAiE9AgkAkQMCBQNsb2MFCmxvY0lkeFR5cGUCAUwJAAIBCQCsAgIJAKwCAgIWRHVjayBsb2NhdGlvbiB0eXBlIGlzIAkAkQMCBQNsb2MFCmxvY0lkeFR5cGUCESwgYnV0IHNob3VsZCBiZSBMCQCUCgIJAJEDAgUDbG9jBQhsb2NJZHhJZAULZHVja0Fzc2V0SWQEC2xhbmRBc3NldElkCAUNJHQwMjQ4NDYyNTM4NQJfMQQGZHVja0lkCAUNJHQwMjQ4NDYyNTM4NQJfMgQFYXNzZXQJAQV2YWx1ZQEJAOwHAQkA2QQBBQtsYW5kQXNzZXRJZAQHdGltZUtleQkBFmtleVN0YWtlZFRpbWVCeUFzc2V0SWQBBQtsYW5kQXNzZXRJZAQJc2F2ZWRUaW1lCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAJ8IAQUHdGltZUtleQkArAICCQCsAgICBUxhbmQgCAUFYXNzZXQEbmFtZQIOIGlzIG5vdCBzdGFrZWQEBW93bmVyCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAKIIAQkBFWtleUxhbmRBc3NldElkVG9Pd25lcgEFC2xhbmRBc3NldElkCQCsAgIJAKwCAgIETkZUIAgFBWFzc2V0BG5hbWUCDCBpcyBvcnBoYW5lZAMJAQIhPQIFBW93bmVyBQRhZGRyCQACAQkArAICBQpMQU5EUFJFRklYAg0gaXMgbm90IHlvdXJzBAFkCQC1CQIIBQVhc3NldAtkZXNjcmlwdGlvbgIBXwkAlgoEBQZkdWNrSWQFC2xhbmRBc3NldElkBQFkBQlzYXZlZFRpbWUBEGNsYWltUmVzSW50ZXJuYWwEBGFkZHIGYW1vdW50CWNsYWltTW9kZQ1sYW5kQXNzZXRJZEluAwkAZgIAAAUGYW1vdW50CQACAQIPTmVnYXRpdmUgYW1vdW50BAFjCQEUY2hlY2tDbGFpbUNvbmRpdGlvbnMDBQRhZGRyBQljbGFpbU1vZGUFDWxhbmRBc3NldElkSW4ECGxhbmRTaXplCQCRAwIIBQFjAl8zBQtyZWNMYW5kU2l6ZQQNdGVycmFpbkNvdW50cwkBDWNvdW50VGVycmFpbnMBCQCRAwIIBQFjAl8zBQtyZWNUZXJyYWlucwQJZGVsdGFUaW1lCQBlAggFCWxhc3RCbG9jawl0aW1lc3RhbXAIBQFjAl80AwkAZgIAAAUJZGVsdGFUaW1lCQACAQkArAICCQCsAgIJAKwCAgImU2F2ZWQgdGltZXN0YW1wIGlzIGluIGZ1dHVyZSwgc2F2ZWQgPSAJAKQDAQgFAWMCXzQCDCwgY3VycmVudCA9IAkApAMBCAUJbGFzdEJsb2NrCXRpbWVzdGFtcAQGcGllY2VzCQEPbnVtUGllY2VzQnlTaXplAQUIbGFuZFNpemUEFmRhaWx5UHJvZHVjdGlvbkJ5UGllY2UJAQxhcHBseUJvbnVzZXMCCAUBYwJfMgUGcGllY2VzBAhhdmFpbFJlcwkAawMFCWRlbHRhVGltZQkAaAIFFmRhaWx5UHJvZHVjdGlvbkJ5UGllY2UFBnBpZWNlcwUJREFZTUlMTElTAwkAZgIFBmFtb3VudAUIYXZhaWxSZXMJAAIBCQCsAgIJAKwCAgkArAICAiJOb3QgZW5vdWdoIHJlc291cmNlcywgYXZhaWxhYmxlID0gCQCkAwEFCGF2YWlsUmVzAg4sIHJlcXVlc3RlZCA9IAkApAMBBQZhbW91bnQEDG5ld0RlbHRhVGltZQkAawMJAGUCBQhhdmFpbFJlcwUGYW1vdW50BQlEQVlNSUxMSVMJAGgCBRZkYWlseVByb2R1Y3Rpb25CeVBpZWNlBQZwaWVjZXMEDG5ld1RpbWVzdGFtcAkAZQIIBQlsYXN0QmxvY2sJdGltZXN0YW1wBQxuZXdEZWx0YVRpbWUECWxhbmRJbmRleAkAaQIFBnBpZWNlcwUFU1NJWkUECnJlc1RvQ2xhaW0JAQl2aXJ0Q2xhaW0EBQ10ZXJyYWluQ291bnRzCQBlAgUJZGVsdGFUaW1lBQxuZXdEZWx0YVRpbWUFCWxhbmRJbmRleAUWZGFpbHlQcm9kdWN0aW9uQnlQaWVjZQQFd2hLZXkJARJrZXlXYXJlaG91c2VCeUxhbmQBCAUBYwJfMgQKaW5mcmFMZXZlbAkBC3ZhbHVlT3JFbHNlAgkAnwgBCQEWa2V5SW5mcmFMZXZlbEJ5QXNzZXRJZAEIBQFjAl8yAAAECWN1cnJlbnRXaAkBDGdldFdhcmVob3VzZQMFBXdoS2V5BQlsYW5kSW5kZXgFCmluZnJhTGV2ZWwEBGxvZnQJALUJAgkAkQMCBQljdXJyZW50V2gFCXdoSWR4TE9GVAIBXwQLd2hTcGFjZUxlZnQJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQRsb2Z0BQd2b2xGcmVlAwMJAAACBQljbGFpbU1vZGUFC2NsYWltTW9kZVdoCQBmAgUGYW1vdW50BQt3aFNwYWNlTGVmdAcJAAIBCQCsAgIJAKwCAgIFT25seSAJAKQDAQULd2hTcGFjZUxlZnQCGCBzcGFjZSBsZWZ0IGluIHdhcmVob3VzZQQFYnBLZXkJARFrZXlCYWNrcGFja0J5RHVjawEIBQFjAl8xBAtjdXJyZW50UGFjawkBC2dldEJhY2twYWNrAQUFYnBLZXkEDmN1cnJlbnRQYWNrUmVzCQC1CQIJAJEDAgULY3VycmVudFBhY2sFCGJwSWR4UmVzAgFfBAxjdXJyZW50V2hSZXMJALUJAgkAkQMCBQljdXJyZW50V2gFCHdoSWR4UmVzAgFfBA0kdDAyNzc1OTI4NjMwAwkAAAIFCWNsYWltTW9kZQULY2xhaW1Nb2RlV2gJAJYKBAkBBmFkZFJlcwUFDGN1cnJlbnRXaFJlcwUNdGVycmFpbkNvdW50cwkAZQIFCWRlbHRhVGltZQUMbmV3RGVsdGFUaW1lBQlsYW5kSW5kZXgFFmRhaWx5UHJvZHVjdGlvbkJ5UGllY2UJAJEDAgULY3VycmVudFBhY2sFCGJwSWR4UmVzCQBkAgkBDXBhcnNlSW50VmFsdWUBCQCRAwIFBGxvZnQFC3ZvbE9jY3VwaWVkCAUKcmVzVG9DbGFpbQJfMgkAZQIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQRsb2Z0BQd2b2xGcmVlCAUKcmVzVG9DbGFpbQJfMgMJAAACBQljbGFpbU1vZGUFDWNsYWltTW9kZUR1Y2sJAJYKBAkAkQMCBQljdXJyZW50V2gFCHdoSWR4UmVzCQEGYWRkUmVzBQUOY3VycmVudFBhY2tSZXMFDXRlcnJhaW5Db3VudHMJAGUCBQlkZWx0YVRpbWUFDG5ld0RlbHRhVGltZQUJbGFuZEluZGV4BRZkYWlseVByb2R1Y3Rpb25CeVBpZWNlCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUEbG9mdAULdm9sT2NjdXBpZWQJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQRsb2Z0BQd2b2xGcmVlBAVkaXN0cgkBDWRpc3RyaWJ1dGVSZXMEBQxjdXJyZW50V2hSZXMFDmN1cnJlbnRQYWNrUmVzBQpyZXNUb0NsYWltBQt3aFNwYWNlTGVmdAQEd2hBbQkAlwMBCQDMCAIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQRsb2Z0BQd2b2xGcmVlCQDMCAIIBQpyZXNUb0NsYWltAl8yBQNuaWwJAJYKBAgFBWRpc3RyAl8xCAUFZGlzdHICXzIJAGQCCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUEbG9mdAULdm9sT2NjdXBpZWQFBHdoQW0JAGUCCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUEbG9mdAUHdm9sRnJlZQUEd2hBbQQFd2hSZXMIBQ0kdDAyNzc1OTI4NjMwAl8xBAVicFJlcwgFDSR0MDI3NzU5Mjg2MzACXzIEBWxvZnRPCAUNJHQwMjc3NTkyODYzMAJfMwQFbG9mdEYIBQ0kdDAyNzc1OTI4NjMwAl80CQCXCgUJAMwIAgkBDEludGVnZXJFbnRyeQIJARZrZXlTdGFrZWRUaW1lQnlBc3NldElkAQgFAWMCXzIFDG5ld1RpbWVzdGFtcAkAzAgCCQEMSW50ZWdlckVudHJ5AgkBImtleVN0YWtlZFRpbWVCeVR5cGVBc3NldElkQW5kT3duZXIDBQpMQU5EUFJFRklYCAUBYwJfMgUEYWRkcgUMbmV3VGltZXN0YW1wBQNuaWwFBWJwS2V5CQDMCAIJAJEDAgULY3VycmVudFBhY2sFCmJwSWR4TGV2ZWwJAMwIAgUFYnBSZXMJAMwIAgkAkQMCBQtjdXJyZW50UGFjawUIYnBJZHhNYXQJAMwIAgkAkQMCBQtjdXJyZW50UGFjawUJYnBJZHhQcm9kBQNuaWwFBXdoS2V5CQDMCAIJAJEDAgUJY3VycmVudFdoBQt3aElkeExldmVscwkAzAgCBQV3aFJlcwkAzAgCCQCRAwIFCWN1cnJlbnRXaAUId2hJZHhNYXQJAMwIAgkAkQMCBQljdXJyZW50V2gFCXdoSWR4UHJvZAkAzAgCCQC5CQIJAMwIAgkAkQMCBQRsb2Z0BQl2b2xMb2NrZWQJAMwIAgkApAMBBQVsb2Z0TwkAzAgCCQCkAwEFBWxvZnRGCQDMCAIJAJEDAgUEbG9mdAUIdm9sVG90YWwFA25pbAIBXwUDbmlsAQhjbGFpbUFsbAQEYWRkcgtsYW5kQXNzZXRJZAZwaWVjZXMJY2xhaW1Nb2RlBAd0aW1lS2V5CQEWa2V5U3Rha2VkVGltZUJ5QXNzZXRJZAEFC2xhbmRBc3NldElkBAlzYXZlZFRpbWUJAQV2YWx1ZQEJAJ8IAQUHdGltZUtleQQIYXZhaWxSZXMJAGgCCQBrAwkAZQIIBQlsYXN0QmxvY2sJdGltZXN0YW1wBQlzYXZlZFRpbWUJAQxhcHBseUJvbnVzZXMCBQtsYW5kQXNzZXRJZAUGcGllY2VzBQlEQVlNSUxMSVMFBnBpZWNlcwkBEGNsYWltUmVzSW50ZXJuYWwEBQRhZGRyBQhhdmFpbFJlcwUJY2xhaW1Nb2RlBQtsYW5kQXNzZXRJZAENdXBJbmZyYUNvbW1vbgQMc2hvdWxkVXNlTWF0BmNhbGxlcg1wYXltZW50QW1vdW50C2xhbmRBc3NldElkBARhZGRyCQClCAEFBmNhbGxlcgQBYwkBFGNoZWNrQ2xhaW1Db25kaXRpb25zAwUEYWRkcgUTY2xhaW1Nb2RlV2hUaGVuRHVjawULbGFuZEFzc2V0SWQEBnBpZWNlcwkBD251bVBpZWNlc0J5U2l6ZQEJAJEDAggFAWMCXzMFC3JlY0xhbmRTaXplBAhpbmZyYUtleQkBFmtleUluZnJhTGV2ZWxCeUFzc2V0SWQBCAUBYwJfMgQIY3VyTGV2ZWwJAQt2YWx1ZU9yRWxzZQIJAJ8IAQUIaW5mcmFLZXkAAAMJAGcCBQhjdXJMZXZlbAADCQACAQImQ3VycmVudGx5IG1heCBpbmZyYXN0cnVjdHVyZSBsZXZlbCA9IDMECG5ld0xldmVsCQBkAgUIY3VyTGV2ZWwAAQQEY29zdAkAawMFFUluZnJhVXBncmFkZUNvc3RTVXNkdAkAaAIFBnBpZWNlcwUIbmV3TGV2ZWwFBVNTSVpFAwMJAQEhAQUMc2hvdWxkVXNlTWF0CQECIT0CBQ1wYXltZW50QW1vdW50BQRjb3N0BwkAAgEJAKwCAgIbUGF5bWVudCBhdHRhY2hlZCBzaG91bGQgYmUgCQCkAwEFBGNvc3QEBWJwS2V5CQERa2V5QmFja3BhY2tCeUR1Y2sBCAUBYwJfMQQLY3VycmVudFBhY2sJAQtnZXRCYWNrcGFjawEFBWJwS2V5BAVtTGlzdAkAtQkCCQCRAwIFC2N1cnJlbnRQYWNrBQhicElkeE1hdAIBXwQHbWF0VXNlZAkAawMFEUluZnJhVXBncmFkZUNvc3RTCQBoAgUGcGllY2VzBQhuZXdMZXZlbAUFU1NJWkUEBm5ld01hdAkAuQkCCQERc3VidHJhY3RNYXRlcmlhbHMDBQxzaG91bGRVc2VNYXQFBW1MaXN0BQdtYXRVc2VkAgFfBAtjbGFpbVJlc3VsdAkBCGNsYWltQWxsBAUEYWRkcggFAWMCXzIFBnBpZWNlcwUTY2xhaW1Nb2RlV2hUaGVuRHVjawQGd2hEYXRhCAULY2xhaW1SZXN1bHQCXzUEBm9sZFZvbAkBF2dldFdhcmVob3VzZVRvdGFsVm9sdW1lAQkAkQMCBQZ3aERhdGEFC3doSWR4TGV2ZWxzBApuZXdWb2xEYXRhCQC5CQIJAMwIAgkAkQMCCQC1CQIJAJEDAgUGd2hEYXRhBQt3aElkeExldmVscwIBXwAACQDMCAIJAKQDAQUIbmV3TGV2ZWwFA25pbAIBXwQGbmV3Vm9sCQEXZ2V0V2FyZWhvdXNlVG90YWxWb2x1bWUBBQpuZXdWb2xEYXRhBARsb2Z0CQC1CQIJAJEDAgUGd2hEYXRhBQl3aElkeExPRlQCAV8ECm5ld0xvZnRTdHIJALkJAgkAzAgCCQCRAwIFBGxvZnQFCXZvbExvY2tlZAkAzAgCCQCRAwIFBGxvZnQFC3ZvbE9jY3VwaWVkCQDMCAIJAKQDAQkAZQIJAGQCCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUEbG9mdAUHdm9sRnJlZQUGbmV3Vm9sBQZvbGRWb2wJAMwIAgkApAMBBQZuZXdWb2wFA25pbAIBXwkAlQoDCQDOCAIJAMwIAgkBDEludGVnZXJFbnRyeQIFCGluZnJhS2V5BQhuZXdMZXZlbAkAzAgCCQEMSW50ZWdlckVudHJ5AgkBHmtleUluZnJhTGV2ZWxCeUFzc2V0SWRBbmRPd25lcgIIBQFjAl8yBQRhZGRyBQhuZXdMZXZlbAkAzAgCCQELU3RyaW5nRW50cnkCBQVicEtleQkAuQkCCQDMCAIJAJEDAgULY3VycmVudFBhY2sFCmJwSWR4TGV2ZWwJAMwIAgkAkQMCCAULY2xhaW1SZXN1bHQCXzMFCGJwSWR4UmVzCQDMCAIFBm5ld01hdAkAzAgCCQCRAwIFC2N1cnJlbnRQYWNrBQlicElkeFByb2QFA25pbAIBOgkAzAgCCQELU3RyaW5nRW50cnkCCAULY2xhaW1SZXN1bHQCXzQJALkJAgkAzAgCBQpuZXdWb2xEYXRhCQDMCAIJAJEDAgUGd2hEYXRhBQh3aElkeFJlcwkAzAgCCQCRAwIFBndoRGF0YQUId2hJZHhNYXQJAMwIAgkAkQMCBQZ3aERhdGEFCXdoSWR4UHJvZAkAzAgCBQpuZXdMb2Z0U3RyBQNuaWwCAToFA25pbAgFC2NsYWltUmVzdWx0Al8xBQhuZXdMZXZlbAUHbWF0VXNlZAEXdXBkYXRlRHVja1N0YXRzSW50ZXJuYWwCC2R1Y2tBc3NldElkB2RlbHRhWFADCQEBIQEFD0tTQUxMT1dYUExFVkVMUwkAlAoCBQNuaWwAAAQGbHZsS2V5CQEMa2V5RHVja0xldmVsAQULZHVja0Fzc2V0SWQEBXhwS2V5CQEJa2V5RHVja1hQAQULZHVja0Fzc2V0SWQEAnhwCQELdmFsdWVPckVsc2UCCQCaCAIFD3N0YWtpbmdDb250cmFjdAUFeHBLZXkAAAQFbmV3WFAJAGQCBQJ4cAUHZGVsdGFYUAQJbHZsUG9pbnRzCQEHbGV2ZWxVcAIJAQt2YWx1ZU9yRWxzZQIJAJoIAgUPc3Rha2luZ0NvbnRyYWN0BQZsdmxLZXkAAAUFbmV3WFAECWtleVBvaW50cwkBEWtleUR1Y2tGcmVlUG9pbnRzAQULZHVja0Fzc2V0SWQJAJQKAgkAzAgCCQEMSW50ZWdlckVudHJ5AgUGbHZsS2V5CQCRAwIFCWx2bFBvaW50cwAACQDMCAIJAQxJbnRlZ2VyRW50cnkCBQV4cEtleQUFbmV3WFAJAMwIAgkBDEludGVnZXJFbnRyeQIFCWtleVBvaW50cwkAZAIJAQt2YWx1ZU9yRWxzZQIJAJ8IAQUJa2V5UG9pbnRzAAAJAJEDAgUJbHZsUG9pbnRzAAEFA25pbAUFbmV3WFABFnVwZGF0ZUFjY1N0YXRzSW50ZXJuYWwCBGFkZHIHZGVsdGFYUAMJAQEhAQUPS1NBTExPV1hQTEVWRUxTCQCUCgIFA25pbAAABAZsdmxLZXkJAQxrZXlVc2VyTGV2ZWwBBQRhZGRyBAV4cEtleQkBCWtleVVzZXJYUAEFBGFkZHIEAnhwCQELdmFsdWVPckVsc2UCCQCaCAIFD3N0YWtpbmdDb250cmFjdAUFeHBLZXkAAAQFbmV3WFAJAGQCBQJ4cAUHZGVsdGFYUAQJbHZsUG9pbnRzCQEHbGV2ZWxVcAIJAQt2YWx1ZU9yRWxzZQIJAJoIAgUPc3Rha2luZ0NvbnRyYWN0BQZsdmxLZXkAAAUFbmV3WFAECWtleVBvaW50cwkBEWtleVVzZXJGcmVlUG9pbnRzAQUEYWRkcgkAlAoCCQDMCAIJAQxJbnRlZ2VyRW50cnkCBQZsdmxLZXkJAJEDAgUJbHZsUG9pbnRzAAAJAMwIAgkBDEludGVnZXJFbnRyeQIFBXhwS2V5BQVuZXdYUAkAzAgCCQEMSW50ZWdlckVudHJ5AgUJa2V5UG9pbnRzCQBkAgkBC3ZhbHVlT3JFbHNlAgkAnwgBBQlrZXlQb2ludHMAAAkAkQMCBQlsdmxQb2ludHMAAQUDbmlsBQVuZXdYUAESYWN0aXZhdGVPbmJvYXJkQXJ0AQRhZGRyBAtkdWNrQXNzZXRJZAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCiCAEJARRrZXlTdGFrZWREdWNrQnlPd25lcgEFBGFkZHICHFlvdSBkb24ndCBoYXZlIGEgZHVjayBzdGFrZWQECHJlZkJ5S2V5CQEPa2V5QWRkcmVzc1JlZkJ5AQUEYWRkcgQFcmVmQnkJAKIIAQUIcmVmQnlLZXkDCQEBIQEJAQlpc0RlZmluZWQBBQVyZWZCeQkAAgECKVlvdSBhcmUgbm90IGVsaWdpYmxlIGZvciBPTkJPQVJEIGFydGlmYWN0BAZhcnRLZXkJARxrZXlPbmJvYXJkQXJ0RHVja0FjdGl2YXRlZEJ5AQUEYWRkcgQHYXJ0RHVjawkAoggBBQZhcnRLZXkDCQEJaXNEZWZpbmVkAQUHYXJ0RHVjawkAAgEJAKwCAgIvWW91IGFscmVhZHkgdXNlZCB5b3VyIE9OQk9BUkQgYXJ0aWZhY3Qgb24gZHVjayAJAQV2YWx1ZQEFB2FydER1Y2sEEGR1Y2tBY3RpdmF0b3JLZXkJARxrZXlPbmJvYXJkQXJ0QWN0aXZhdGVkT25EdWNrAQULZHVja0Fzc2V0SWQEDWR1Y2tBY3RpdmF0b3IJAKIIAQUQZHVja0FjdGl2YXRvcktleQMJAQlpc0RlZmluZWQBBQ1kdWNrQWN0aXZhdG9yCQACAQkArAICCQCsAgIJAKwCAgIJVGhlIGR1Y2sgBQtkdWNrQXNzZXRJZAI0IGFscmVhZHkgZ290IHBvaW50cyBmcm9tIE9OQk9BUkQgYXJ0aWZhY3QgZnJvbSB1c2VyIAkBBXZhbHVlAQUNZHVja0FjdGl2YXRvcgkAzggCCQDMCAIJAQtTdHJpbmdFbnRyeQIFBmFydEtleQULZHVja0Fzc2V0SWQJAMwIAgkBC1N0cmluZ0VudHJ5AgUQZHVja0FjdGl2YXRvcktleQUEYWRkcgUDbmlsCAkBF3VwZGF0ZUR1Y2tTdGF0c0ludGVybmFsAgULZHVja0Fzc2V0SWQFCXhwT25ib2FyZAJfMQESYWN0aXZhdGVQcmVzYWxlQXJ0AgRhZGRyDWxhbmRBc3NldElkSW4EAWMJARRjaGVja0NsYWltQ29uZGl0aW9ucwMFBGFkZHIFE2NsYWltTW9kZVdoVGhlbkR1Y2sFDWxhbmRBc3NldElkSW4EC2xhbmRBc3NldElkCAUBYwJfMgQGcGllY2VzCQEPbnVtUGllY2VzQnlTaXplAQkAkQMCCAUBYwJfMwULcmVjTGFuZFNpemUEDWFjdGl2YXRpb25LZXkJASBrZXlMYW5kQXJ0U3RhdHVzQnlUeXBlQW5kQXNzZXRJZAIFCkFSVFBSRVNBTEUFC2xhbmRBc3NldElkAwkAZgIJAQt2YWx1ZU9yRWxzZQIJAJ8IAQUNYWN0aXZhdGlvbktleQAAAAAJAAIBAiVQcmVzYWxlIGFydGlmYWN0IGlzIGFscmVhZHkgYWN0aXZhdGVkAwkAZgIJAQ1wYXJzZUludFZhbHVlAQkAkQMCCAUBYwJfMwUKcmVjTGFuZE51bQUPUFJFU0FMRU5VTUxBTkRTCQACAQkArAICCQCsAgIJAKwCAgUKTEFORFBSRUZJWAIBIAULbGFuZEFzc2V0SWQCJSBpcyBub3QgZWxpZ2libGUgZm9yIHByZXNhbGUgYXJ0aWZhY3QEC2NsYWltUmVzdWx0CQEIY2xhaW1BbGwEBQRhZGRyBQtsYW5kQXNzZXRJZAUGcGllY2VzBRNjbGFpbU1vZGVXaFRoZW5EdWNrCQDNCAIJAM0IAgkAzQgCCQDNCAIIBQtjbGFpbVJlc3VsdAJfMQkBDEludGVnZXJFbnRyeQIFDWFjdGl2YXRpb25LZXkFBnBpZWNlcwkBDEludGVnZXJFbnRyeQIJASVrZXlMYW5kQXJ0U3RhdHVzQnlUeXBlQXNzZXRJZEFuZE93bmVyAwUKQVJUUFJFU0FMRQULbGFuZEFzc2V0SWQFBGFkZHIFBnBpZWNlcwkBC1N0cmluZ0VudHJ5AggFC2NsYWltUmVzdWx0Al8yCQC5CQIIBQtjbGFpbVJlc3VsdAJfMwIBOgkBC1N0cmluZ0VudHJ5AggFC2NsYWltUmVzdWx0Al80CQC5CQIIBQtjbGFpbVJlc3VsdAJfNQIBOgENbWVyZ2VJbnRlcm5hbAcLbmV3TGFuZFNpemUIbmV3TGV2ZWwHZm9ybXVsYQRhZGRyDGxhbmRBc3NldElkcwR0eElkB25lZWRNYXQEC2R1Y2tBc3NldElkCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAKIIAQkBFGtleVN0YWtlZER1Y2tCeU93bmVyAQUEYWRkcgIcWW91IGRvbid0IGhhdmUgYSBkdWNrIHN0YWtlZAoBCmNoZWNrTWVyZ2UCA2FjYwtsYW5kQXNzZXRJZAQFYXNzZXQJAQV2YWx1ZQEJAOwHAQkA2QQBBQtsYW5kQXNzZXRJZAQHdGltZUtleQkBFmtleVN0YWtlZFRpbWVCeUFzc2V0SWQBBQtsYW5kQXNzZXRJZAQJc2F2ZWRUaW1lCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAJ8IAQUHdGltZUtleQkArAICCQCsAgICBE5GVCAIBQVhc3NldARuYW1lAg4gaXMgbm90IHN0YWtlZAQFb3duZXIJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAoggBCQEVa2V5TGFuZEFzc2V0SWRUb093bmVyAQULbGFuZEFzc2V0SWQJAKwCAgkArAICAgRORlQgCAUFYXNzZXQEbmFtZQIMIGlzIG9ycGhhbmVkAwkBAiE9AgUFb3duZXIFBGFkZHIJAAIBCQCsAgIFCkxBTkRQUkVGSVgCDSBpcyBub3QgeW91cnMEAWQJALUJAggFBWFzc2V0C2Rlc2NyaXB0aW9uAgFfBAljb250aW5lbnQJAJEDAgUBZAUMcmVjQ29udGluZW50AwMJAQIhPQIIBQNhY2MCXzMCAAkBAiE9AggFA2FjYwJfMwUJY29udGluZW50BwkAAgECLkxhbmRzIHNob3VsZCBiZSBvbiB0aGUgc2FtZSBjb250aW5lbnQgdG8gbWVyZ2UECGxhbmRTaXplCQCRAwIFAWQFC3JlY0xhbmRTaXplBAdzaXplc0luCAUDYWNjAl8xBAFpCQETdmFsdWVPckVycm9yTWVzc2FnZQIJALMJAgUHc2l6ZXNJbgUIbGFuZFNpemUCJ1lvdSBoYXZlbid0IHBhc3NlZCBhbGwgdGhlIGxhbmRzIG5lZWRlZAQIc2l6ZXNPdXQJAKwCAgkArwICBQdzaXplc0luBQFpCQCwAgIFB3NpemVzSW4JAGQCBQFpAAEEBnBpZWNlcwkBD251bVBpZWNlc0J5U2l6ZQEFCGxhbmRTaXplBARhcnRzCQBkAggFA2FjYwJfMgkBC3ZhbHVlT3JFbHNlAgkAnwgBCQEga2V5TGFuZEFydFN0YXR1c0J5VHlwZUFuZEFzc2V0SWQCBQpBUlRQUkVTQUxFBQtsYW5kQXNzZXRJZAAABAppbmZyYUxldmVsCQELdmFsdWVPckVsc2UCCQCfCAEJARZrZXlJbmZyYUxldmVsQnlBc3NldElkAQULbGFuZEFzc2V0SWQAAAQIcmVxTGV2ZWwEByRtYXRjaDAFCGxhbmRTaXplAwkAAAICAVMFByRtYXRjaDAAAwMJAAACAgFNBQckbWF0Y2gwAAQDCQAAAgIBTAUHJG1hdGNoMAAFAwkAAAICAlhMBQckbWF0Y2gwAAYJAAIBAhpPbmx5IFMsIE0sIEwsIFhMIGNhbiBtZXJnZQMJAQIhPQIFCmluZnJhTGV2ZWwFCHJlcUxldmVsCQACAQIiQWxsIGxhbmRzIHNob3VsZCBiZSBtYXhlZCB0byBtZXJnZQQHbGFuZE51bQkAkQMCBQFkBQpyZWNMYW5kTnVtBA10ZXJyYWluQ291bnRzCQENY291bnRUZXJyYWlucwEJAJEDAgUBZAULcmVjVGVycmFpbnMECWRlbHRhVGltZQkAZQIIBQlsYXN0QmxvY2sJdGltZXN0YW1wBQlzYXZlZFRpbWUDCQBmAgAABQlkZWx0YVRpbWUJAAIBCQCsAgIJAKwCAgkArAICAiZTYXZlZCB0aW1lc3RhbXAgaXMgaW4gZnV0dXJlLCBzYXZlZCA9IAkApAMBBQlzYXZlZFRpbWUCDCwgY3VycmVudCA9IAkApAMBCAUJbGFzdEJsb2NrCXRpbWVzdGFtcAQWZGFpbHlQcm9kdWN0aW9uQnlQaWVjZQkBDGFwcGx5Qm9udXNlcwIFC2xhbmRBc3NldElkBQZwaWVjZXMECWxhbmRJbmRleAkAaQIFBnBpZWNlcwUFU1NJWkUEBWJwUmVzCQEGYWRkUmVzBQkAtQkCCAUDYWNjAl80AgFfBQ10ZXJyYWluQ291bnRzBQlkZWx0YVRpbWUFCWxhbmRJbmRleAUWZGFpbHlQcm9kdWN0aW9uQnlQaWVjZQQFcHJvcHMJARl1cGRhdGVQcm9wb3J0aW9uc0ludGVybmFsBAkAtQkCCAUDYWNjAl82AgFfBQ10ZXJyYWluQ291bnRzBQlsYW5kSW5kZXgA////////////AQQFbGFuZHMIBQNhY2MCXzcEA2lkeAkAzwgCBQVsYW5kcwULbGFuZEFzc2V0SWQDCQEBIQEJAQlpc0RlZmluZWQBBQNpZHgJAAIBCQCsAgICIFlvdXIgc3Rha2VkIGxhbmRzIGRvbid0IGNvbnRhaW4gBQtsYW5kQXNzZXRJZAQJY3VzdG9tS2V5CQEaa2V5TGFuZEFzc2V0SWRUb0N1c3RvbU5hbWUBBQtsYW5kQXNzZXRJZAQKY3VzdG9tTmFtZQkBC3ZhbHVlT3JFbHNlAgkAoggBBQljdXN0b21LZXkCAAkAmgoIBQhzaXplc091dAUEYXJ0cwUJY29udGluZW50BQVicFJlcwkAzQgCCQDNCAIJAM0IAgkAzQgCCQDNCAIJAM0IAgkAzQgCCQDNCAIJAM0IAgkAzQgCCQDNCAIJAM0IAgkAzQgCCAUDYWNjAl81CQELRGVsZXRlRW50cnkBCQEWa2V5U3Rha2VkVGltZUJ5QXNzZXRJZAEFC2xhbmRBc3NldElkCQELRGVsZXRlRW50cnkBCQEia2V5U3Rha2VkVGltZUJ5VHlwZUFzc2V0SWRBbmRPd25lcgMFCkxBTkRQUkVGSVgFC2xhbmRBc3NldElkBQRhZGRyCQELRGVsZXRlRW50cnkBCQEQa2V5TGFuZFRvQXNzZXRJZAEFB2xhbmROdW0JAQtEZWxldGVFbnRyeQEJARVrZXlMYW5kQXNzZXRJZFRvT3duZXIBBQtsYW5kQXNzZXRJZAkBC0RlbGV0ZUVudHJ5AQkBFmtleUluZnJhTGV2ZWxCeUFzc2V0SWQBBQtsYW5kQXNzZXRJZAkBC0RlbGV0ZUVudHJ5AQkBHmtleUluZnJhTGV2ZWxCeUFzc2V0SWRBbmRPd25lcgIFC2xhbmRBc3NldElkBQRhZGRyCQELRGVsZXRlRW50cnkBCQEga2V5TGFuZEFydFN0YXR1c0J5VHlwZUFuZEFzc2V0SWQCBQpBUlRQUkVTQUxFBQtsYW5kQXNzZXRJZAkBC0RlbGV0ZUVudHJ5AQkBJWtleUxhbmRBcnRTdGF0dXNCeVR5cGVBc3NldElkQW5kT3duZXIDBQpBUlRQUkVTQUxFBQtsYW5kQXNzZXRJZAUEYWRkcgkBC0RlbGV0ZUVudHJ5AQkBEWtleUxhbmROdW1Ub093bmVyAQUHbGFuZE51bQkBC0RlbGV0ZUVudHJ5AQkBEmtleVdhcmVob3VzZUJ5TGFuZAEFC2xhbmRBc3NldElkCQELRGVsZXRlRW50cnkBBQljdXN0b21LZXkJAQtEZWxldGVFbnRyeQEJARprZXlMYW5kQ3VzdG9tTmFtZVRvQXNzZXRJZAEFCmN1c3RvbU5hbWUJAQRCdXJuAgkA2QQBBQtsYW5kQXNzZXRJZAABBQVwcm9wcwkA0QgCBQVsYW5kcwkBBXZhbHVlAQUDaWR4CQBkAggFA2FjYwJfOAUGcGllY2VzBAVicEtleQkBEWtleUJhY2twYWNrQnlEdWNrAQULZHVja0Fzc2V0SWQEC2N1cnJlbnRQYWNrCQELZ2V0QmFja3BhY2sBBQVicEtleQQHcHJvcFN0cgkBC3ZhbHVlT3JFbHNlAgkAoggBCQERa2V5UmVzUHJvcG9ydGlvbnMAAgswXzBfMF8wXzBfMAQIbGFuZHNLZXkJARVrZXlTdGFrZWRMYW5kc0J5T3duZXIBBQRhZGRyBAhsYW5kc1N0cgkAoggBBQhsYW5kc0tleQQHbGFuZHNJbgMJAQlpc0RlZmluZWQBBQhsYW5kc1N0cgkAvQkCCQEFdmFsdWUBBQhsYW5kc1N0cgIBXwUDbmlsBAFyCgACJGwFDGxhbmRBc3NldElkcwoAAiRzCQCQAwEFAiRsCgAFJGFjYzAJAJoKCAUHZm9ybXVsYQAAAgAJAJEDAgULY3VycmVudFBhY2sFCGJwSWR4UmVzBQNuaWwFB3Byb3BTdHIFB2xhbmRzSW4AAAoBBSRmMF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEKY2hlY2tNZXJnZQIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQITTGlzdCBzaXplIGV4Y2VlZHMgNQkBBSRmMF8yAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgUFJGFjYzAAAAABAAIAAwAEAAUECWNvbnRpbmVudAgFAXICXzMEDGNvbnRpbmVudElkeAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQDPCAIFCmNvbnRpbmVudHMFCWNvbnRpbmVudAkArAICAhNVbmtub3duIGNvbnRpbmVudDogBQljb250aW5lbnQECHRlcnJhaW5zCQELZ2VuVGVycmFpbnMCCQEDYWJzAQkAngMBBQR0eElkBQxjb250aW5lbnRJZHgEB2ZyZWVOdW0JAQt2YWx1ZU9yRWxzZQIJAJ8IAQkBEmtleU5leHRGcmVlTGFuZE51bQAJAGQCBQ9QUkVTQUxFTlVNTEFORFMAAQQKbmV3TGFuZE51bQkApAMBBQdmcmVlTnVtBAVpc3N1ZQkAwggFCQEHbmZ0TmFtZQIFCm5ld0xhbmROdW0FC25ld0xhbmRTaXplCQC5CQIJAMwIAgUKbmV3TGFuZE51bQkAzAgCBQtuZXdMYW5kU2l6ZQkAzAgCBQh0ZXJyYWlucwkAzAgCBQljb250aW5lbnQFA25pbAIBXwABAAAHBAdhc3NldElkCQC4CAEFBWlzc3VlBA5uZXdMYW5kQXNzZXRJZAkA2AQBBQdhc3NldElkBAZuZXdNYXQJALkJAgkBEXN1YnRyYWN0TWF0ZXJpYWxzAwkAZgIFB25lZWRNYXQAAAkAtQkCCQCRAwIFC2N1cnJlbnRQYWNrBQhicElkeE1hdAIBXwUHbmVlZE1hdAIBXwQJcGllY2VzS2V5CQEWa2V5U3Rha2VkUGllY2VzQnlPd25lcgEFBGFkZHIEDHN0YWtlZFBpZWNlcwkBC3ZhbHVlT3JFbHNlAgkAnwgBBQlwaWVjZXNLZXkAAAkAlAoCCQDNCAIJAM0IAgkAzQgCCQDNCAIJAM0IAgkAzQgCCQDNCAIJAM0IAgkAzQgCCQDNCAIJAM0IAgkAzQgCCQDNCAIJAM0IAgkAzQgCCAUBcgJfNQMJAGYCCQCQAwEIBQFyAl83AAAJAQtTdHJpbmdFbnRyeQIFCGxhbmRzS2V5CQC7CQIIBQFyAl83AgFfCQELRGVsZXRlRW50cnkBBQhsYW5kc0tleQkBDEludGVnZXJFbnRyeQIFCXBpZWNlc0tleQMJAGYCCAUBcgJfOAUMc3Rha2VkUGllY2VzAAAJAGUCBQxzdGFrZWRQaWVjZXMIBQFyAl84CQEMSW50ZWdlckVudHJ5AgkBEmtleU5leHRGcmVlTGFuZE51bQAJAGQCBQdmcmVlTnVtAAEFBWlzc3VlCQELU3RyaW5nRW50cnkCCQEQa2V5TGFuZFRvQXNzZXRJZAEFCm5ld0xhbmROdW0FDm5ld0xhbmRBc3NldElkCQELU3RyaW5nRW50cnkCCQEVa2V5TGFuZEFzc2V0SWRUb093bmVyAQUObmV3TGFuZEFzc2V0SWQFBGFkZHIJAQtTdHJpbmdFbnRyeQIJARFrZXlMYW5kTnVtVG9Pd25lcgEFCm5ld0xhbmROdW0FBGFkZHIJAQxJbnRlZ2VyRW50cnkCCQEga2V5TGFuZEFydFN0YXR1c0J5VHlwZUFuZEFzc2V0SWQCBQpBUlRQUkVTQUxFBQ5uZXdMYW5kQXNzZXRJZAgFAXICXzIJAQxJbnRlZ2VyRW50cnkCCQEla2V5TGFuZEFydFN0YXR1c0J5VHlwZUFzc2V0SWRBbmRPd25lcgMFCkFSVFBSRVNBTEUFDm5ld0xhbmRBc3NldElkBQRhZGRyCAUBcgJfMgkBDEludGVnZXJFbnRyeQIJARZrZXlJbmZyYUxldmVsQnlBc3NldElkAQUObmV3TGFuZEFzc2V0SWQFCG5ld0xldmVsCQEMSW50ZWdlckVudHJ5AgkBHmtleUluZnJhTGV2ZWxCeUFzc2V0SWRBbmRPd25lcgIFDm5ld0xhbmRBc3NldElkBQRhZGRyBQhuZXdMZXZlbAkBC1N0cmluZ0VudHJ5AgUFYnBLZXkJALkJAgkAzAgCCQCRAwIFC2N1cnJlbnRQYWNrBQpicElkeExldmVsCQDMCAIIBQFyAl80CQDMCAIFBm5ld01hdAkAzAgCCQCRAwIFC2N1cnJlbnRQYWNrBQlicElkeFByb2QFA25pbAIBOgkBC1N0cmluZ0VudHJ5AgkBEWtleVJlc1Byb3BvcnRpb25zAAgFAXICXzYJAQtTdHJpbmdFbnRyeQIJAQ9rZXlEdWNrTG9jYXRpb24BBQtkdWNrQXNzZXRJZAkAuQkCCQDMCAIFCWNvbnRpbmVudAkAzAgCAgFMCQDMCAIFDm5ld0xhbmRBc3NldElkBQNuaWwCAV8JAQ5TY3JpcHRUcmFuc2ZlcgMJARFAZXh0ck5hdGl2ZSgxMDYyKQEFBGFkZHIAAQUHYXNzZXRJZAUObmV3TGFuZEFzc2V0SWQBA3MybQMEYWRkcgxsYW5kQXNzZXRJZHMEdHhJZAkBDW1lcmdlSW50ZXJuYWwHAgFNAAMCBFNTU1MFBGFkZHIFDGxhbmRBc3NldElkcwUEdHhJZAAAAQNtMmwFBGFkZHIMbGFuZEFzc2V0SWRzBHR4SWQMc2hvdWxkVXNlTWF0DXBheW1lbnRBbW91bnQEBGNvc3QJAGgCBRVJbmZyYVVwZ3JhZGVDb3N0U1VzZHQABAMDCQEBIQEFDHNob3VsZFVzZU1hdAkBAiE9AgUNcGF5bWVudEFtb3VudAUEY29zdAcJAAIBCQCsAgICG1BheW1lbnQgYXR0YWNoZWQgc2hvdWxkIGJlIAkApAMBBQRjb3N0CQENbWVyZ2VJbnRlcm5hbAcCAUwABAIDU01NBQRhZGRyBQxsYW5kQXNzZXRJZHMFBHR4SWQJAGgCBRFJbmZyYVVwZ3JhZGVDb3N0UwAEAQRsMnhsBQRhZGRyDGxhbmRBc3NldElkcwR0eElkDHNob3VsZFVzZU1hdA1wYXltZW50QW1vdW50BARjb3N0CQBoAgUVSW5mcmFVcGdyYWRlQ29zdFNVc2R0AC8DAwkBASEBBQxzaG91bGRVc2VNYXQJAQIhPQIFDXBheW1lbnRBbW91bnQFBGNvc3QHCQACAQkArAICAhtQYXltZW50IGF0dGFjaGVkIHNob3VsZCBiZSAJAKQDAQUEY29zdAkBDW1lcmdlSW50ZXJuYWwHAgJYTAAFAgVTU1NNTAUEYWRkcgUMbGFuZEFzc2V0SWRzBQR0eElkCQBoAgURSW5mcmFVcGdyYWRlQ29zdFMALwEGeGwyeHhsBQRhZGRyDGxhbmRBc3NldElkcwR0eElkDHNob3VsZFVzZU1hdA1wYXltZW50QW1vdW50BARjb3N0CQBoAgUVSW5mcmFVcGdyYWRlQ29zdFNVc2R0ADYDAwkBASEBBQxzaG91bGRVc2VNYXQJAQIhPQIFDXBheW1lbnRBbW91bnQFBGNvc3QHCQACAQkArAICAhtQYXltZW50IGF0dGFjaGVkIHNob3VsZCBiZSAJAKQDAQUEY29zdAkBDW1lcmdlSW50ZXJuYWwHAgNYWEwABgIDTFhMBQRhZGRyBQxsYW5kQXNzZXRJZHMFBHR4SWQJAGgCBRFJbmZyYVVwZ3JhZGVDb3N0UwA2AQttZXJnZUNvbW1vbgUMc2hvdWxkVXNlTWF0BGFkZHINcGF5bWVudEFtb3VudAxsYW5kQXNzZXRJZHMEdHhJZAQLbWVyZ2VSZXN1bHQEByRtYXRjaDAJAJADAQUMbGFuZEFzc2V0SWRzAwkAAAIABAUHJG1hdGNoMAkBA3MybQMFBGFkZHIFDGxhbmRBc3NldElkcwUEdHhJZAMJAAACAAMFByRtYXRjaDAJAQNtMmwFBQRhZGRyBQxsYW5kQXNzZXRJZHMFBHR4SWQFDHNob3VsZFVzZU1hdAUNcGF5bWVudEFtb3VudAMJAAACAAUFByRtYXRjaDAJAQRsMnhsBQUEYWRkcgUMbGFuZEFzc2V0SWRzBQR0eElkBQxzaG91bGRVc2VNYXQFDXBheW1lbnRBbW91bnQDCQAAAgACBQckbWF0Y2gwCQEGeGwyeHhsBQUEYWRkcgUMbGFuZEFzc2V0SWRzBQR0eElkBQxzaG91bGRVc2VNYXQFDXBheW1lbnRBbW91bnQJAAIBAg1Vbmtub3duIG1lcmdlBQttZXJnZVJlc3VsdAEGcHJvbG9nAQFpAwMJAQIhPQIIBQFpDG9yaWdpbkNhbGxlcgUMcmVzdENvbnRyYWN0CQELdmFsdWVPckVsc2UCCQCgCAEJAQprZXlCbG9ja2VkAAcHCQACAQIfQ29udHJhY3RzIGFyZSB1bmRlciBtYWludGVuYW5jZQkBC1N0cmluZ0VudHJ5AgkBEWtleUxhc3RUeElkQnlVc2VyAQkApQgBCAUBaQxvcmlnaW5DYWxsZXIJANgEAQgFAWkNdHJhbnNhY3Rpb25JZCEBaQENY29uc3RydWN0b3JWMQEIcmVzdEFkZHIDCQECIT0CCAUBaQZjYWxsZXIFBHRoaXMJAAIBAhFQZXJtaXNzaW9uIGRlbmllZAkAzAgCCQELU3RyaW5nRW50cnkCCQEOa2V5UmVzdEFkZHJlc3MABQhyZXN0QWRkcgUDbmlsAWkBCnNldEJsb2NrZWQBCWlzQmxvY2tlZAMJAQIhPQIIBQFpBmNhbGxlcgUEdGhpcwkAAgECEXBlcm1pc3Npb24gZGVuaWVkCQDMCAIJAQxCb29sZWFuRW50cnkCCQEKa2V5QmxvY2tlZAAFCWlzQmxvY2tlZAUDbmlsAWkBCXN0YWtlTGFuZAAEDHByb2xvZ0FjdGlvbgkBBnByb2xvZwEFAWkDCQECIT0CCQCQAwEIBQFpCHBheW1lbnRzAAEJAAIBAhxFeGFjdGx5IG9uZSBwYXltZW50IHJlcXVpcmVkBANwbXQJAQV2YWx1ZQEJAJEDAggFAWkIcGF5bWVudHMAAAQHYXNzZXRJZAkBBXZhbHVlAQgFA3BtdAdhc3NldElkBAdhZGRyZXNzCQClCAEIBQFpBmNhbGxlcgMJAQIhPQIIBQNwbXQGYW1vdW50AAEJAAIBCQCsAgIJAKwCAgIETkZUIAUKTEFORFBSRUZJWAIkIHRva2VuIHNob3VsZCBiZSBhdHRhY2hlZCBhcyBwYXltZW50BAVhc3NldAkBBXZhbHVlAQkA7AcBBQdhc3NldElkAwkBAiE9AggFBWFzc2V0Bmlzc3VlcgUEdGhpcwkAAgECF1Vua25vd24gaXNzdWVyIG9mIHRva2VuAwkBASEBCQEIY29udGFpbnMCCAUFYXNzZXQEbmFtZQUKTEFORFBSRUZJWAkAAgEJAKwCAgkArAICAglPbmx5IE5GVCAFCkxBTkRQUkVGSVgCFCB0b2tlbnMgYXJlIGFjY2VwdGVkBAtsYW5kTnVtU2l6ZQkAsAICCAUFYXNzZXQEbmFtZQAEBAdsYW5kTnVtAwkBCGNvbnRhaW5zAgULbGFuZE51bVNpemUCA1hYTAkAswICBQtsYW5kTnVtU2l6ZQADAwkBCGNvbnRhaW5zAgULbGFuZE51bVNpemUCAlhMCQCzAgIFC2xhbmROdW1TaXplAAIJALMCAgULbGFuZE51bVNpemUAAQMJAQEhAQkBCWlzRGVmaW5lZAEJALYJAQUHbGFuZE51bQkAAgEJAKwCAgIeQ2Fubm90IHBhcnNlIGxhbmQgbnVtYmVyIGZyb20gCAUFYXNzZXQEbmFtZQQLbGFuZEFzc2V0SWQJANgEAQUHYXNzZXRJZAQHdGltZUtleQkBFmtleVN0YWtlZFRpbWVCeUFzc2V0SWQBBQtsYW5kQXNzZXRJZAMJAQlpc0RlZmluZWQBCQCfCAEFB3RpbWVLZXkJAAIBCQCsAgIJAKwCAgIETkZUIAgFBWFzc2V0BG5hbWUCEiBpcyBhbHJlYWR5IHN0YWtlZAQBZAkAtQkCCAUFYXNzZXQLZGVzY3JpcHRpb24CAV8EDXRlcnJhaW5Db3VudHMJAQ1jb3VudFRlcnJhaW5zAQkAkQMCBQFkBQtyZWNUZXJyYWlucwQGcGllY2VzCQEPbnVtUGllY2VzQnlTaXplAQkAkQMCBQFkBQtyZWNMYW5kU2l6ZQQFcHJvcHMJARF1cGRhdGVQcm9wb3J0aW9ucwMFDXRlcnJhaW5Db3VudHMJAGkCBQZwaWVjZXMFBVNTSVpFAAEECWFydFBpZWNlcwkBC3ZhbHVlT3JFbHNlAgkAnwgBCQEga2V5TGFuZEFydFN0YXR1c0J5VHlwZUFuZEFzc2V0SWQCBQpBUlRQUkVTQUxFBQtsYW5kQXNzZXRJZAAABAhsYW5kc0tleQkBFWtleVN0YWtlZExhbmRzQnlPd25lcgEFB2FkZHJlc3MECGxhbmRzU3RyCQCiCAEFCGxhbmRzS2V5BAVsYW5kcwMJAQlpc0RlZmluZWQBBQhsYW5kc1N0cgkAvQkCCQEFdmFsdWUBBQhsYW5kc1N0cgIBXwUDbmlsAwkBD2NvbnRhaW5zRWxlbWVudAIFBWxhbmRzBQtsYW5kQXNzZXRJZAkAAgEJAKwCAgIiWW91ciBzdGFrZWQgbGFuZHMgYWxyZWFkeSBjb250YWluIAULbGFuZEFzc2V0SWQECmluZnJhTGV2ZWwJAQt2YWx1ZU9yRWxzZQIJAJ8IAQkBFmtleUluZnJhTGV2ZWxCeUFzc2V0SWQBBQtsYW5kQXNzZXRJZAAABAlwaWVjZXNLZXkJARZrZXlTdGFrZWRQaWVjZXNCeU93bmVyAQUHYWRkcmVzcwQJb2xkUGllY2VzCQELdmFsdWVPckVsc2UCCQCfCAEFCXBpZWNlc0tleQAABAl3bGdSZXN1bHQJAQVhc0ludAEJAPwHBAULd2xnQ29udHJhY3QCC29uU3Rha2VMYW5kCQDMCAIFB2FkZHJlc3MFA25pbAUDbmlsCQCUCgIJAMwIAgkBDEludGVnZXJFbnRyeQIFB3RpbWVLZXkIBQlsYXN0QmxvY2sJdGltZXN0YW1wCQDMCAIJAQxJbnRlZ2VyRW50cnkCCQEia2V5U3Rha2VkVGltZUJ5VHlwZUFzc2V0SWRBbmRPd25lcgMFCkxBTkRQUkVGSVgFC2xhbmRBc3NldElkBQdhZGRyZXNzCAUJbGFzdEJsb2NrCXRpbWVzdGFtcAkAzAgCCQELU3RyaW5nRW50cnkCBQhsYW5kc0tleQkAuwkCCQDNCAIFBWxhbmRzBQtsYW5kQXNzZXRJZAIBXwkAzAgCCQEMSW50ZWdlckVudHJ5AgUJcGllY2VzS2V5CQBkAgUJb2xkUGllY2VzBQZwaWVjZXMJAMwIAgkBC1N0cmluZ0VudHJ5AgkBFWtleUxhbmRBc3NldElkVG9Pd25lcgEFC2xhbmRBc3NldElkBQdhZGRyZXNzCQDMCAIJAQtTdHJpbmdFbnRyeQIJARFrZXlMYW5kTnVtVG9Pd25lcgEFB2xhbmROdW0FB2FkZHJlc3MJAMwIAgkBDEludGVnZXJFbnRyeQIJASVrZXlMYW5kQXJ0U3RhdHVzQnlUeXBlQXNzZXRJZEFuZE93bmVyAwUKQVJUUFJFU0FMRQULbGFuZEFzc2V0SWQFB2FkZHJlc3MFCWFydFBpZWNlcwkAzAgCCQEMSW50ZWdlckVudHJ5AgkBHmtleUluZnJhTGV2ZWxCeUFzc2V0SWRBbmRPd25lcgIFC2xhbmRBc3NldElkBQdhZGRyZXNzBQppbmZyYUxldmVsCQDMCAIJAQtTdHJpbmdFbnRyeQIJARFrZXlSZXNQcm9wb3J0aW9ucwAFBXByb3BzCQDMCAIFDHByb2xvZ0FjdGlvbgUDbmlsBQl3bGdSZXN1bHQBaQELdW5zdGFrZUxhbmQBDWxhbmRBc3NldElkSW4EDHByb2xvZ0FjdGlvbgkBBnByb2xvZwEFAWkDCQECIT0CCQCQAwEIBQFpCHBheW1lbnRzAAAJAAIBAhRObyBwYXltZW50cyByZXF1aXJlZAQEYWRkcgkApQgBCAUBaQZjYWxsZXIEAWMJARRjaGVja0NsYWltQ29uZGl0aW9ucwMFBGFkZHIFDWNsYWltTW9kZUR1Y2sFDWxhbmRBc3NldElkSW4EC2xhbmRBc3NldElkCAUBYwJfMgQIbGFuZHNLZXkJARVrZXlTdGFrZWRMYW5kc0J5T3duZXIBBQRhZGRyBA10ZXJyYWluQ291bnRzCQENY291bnRUZXJyYWlucwEJAJEDAggFAWMCXzMFC3JlY1RlcnJhaW5zBAZwaWVjZXMJAQ9udW1QaWVjZXNCeVNpemUBCQCRAwIIBQFjAl8zBQtyZWNMYW5kU2l6ZQQFcHJvcHMJARF1cGRhdGVQcm9wb3J0aW9ucwMFDXRlcnJhaW5Db3VudHMJAGkCBQZwaWVjZXMFBVNTSVpFAP///////////wEEC2NsYWltUmVzdWx0CQEIY2xhaW1BbGwEBQRhZGRyBQtsYW5kQXNzZXRJZAUGcGllY2VzBQ1jbGFpbU1vZGVEdWNrBAVsYW5kcwkAvQkCCQELdmFsdWVPckVsc2UCCQCiCAEFCGxhbmRzS2V5AgACAV8EA2lkeAkAzwgCBQVsYW5kcwULbGFuZEFzc2V0SWQDCQEBIQEJAQlpc0RlZmluZWQBBQNpZHgJAAIBCQCsAgICIFlvdXIgc3Rha2VkIGxhbmRzIGRvbid0IGNvbnRhaW4gBQtsYW5kQXNzZXRJZAQBdAgJAQV2YWx1ZQEJAO0HAQUGaGVpZ2h0CXRpbWVzdGFtcAQLcmVsZWFzZVRpbWUJAQt2YWx1ZU9yRWxzZQIJAJoIAgULZ292Q29udHJhY3QJARVrZXlVc2VyR3dsUmVsZWFzZVRpbWUBBQRhZGRyAAADCQBnAgULcmVsZWFzZVRpbWUFAXQJAAIBCQCsAgICOVlvdXIgZ1dMIGFyZSB0YWtpbmcgcGFydCBpbiB2b3RpbmcsIGNhbm5vdCB1bnN0YWtlIHVudGlsIAkApAMBBQtyZWxlYXNlVGltZQQJcGllY2VzS2V5CQEWa2V5U3Rha2VkUGllY2VzQnlPd25lcgEFBGFkZHIEDHN0YWtlZFBpZWNlcwkBC3ZhbHVlT3JFbHNlAgkAnwgBBQlwaWVjZXNLZXkAAAQJbmV3UGllY2VzAwkAZgIFBnBpZWNlcwUMc3Rha2VkUGllY2VzAAAJAGUCBQxzdGFrZWRQaWVjZXMFBnBpZWNlcwQJd2xnUmVzdWx0CQEFYXNJbnQBCQD8BwQFC3dsZ0NvbnRyYWN0Ag1vblVuc3Rha2VMYW5kCQDMCAIFBGFkZHIFA25pbAUDbmlsCQCUCgIJAMwIAgkBDlNjcmlwdFRyYW5zZmVyAwgFAWkGY2FsbGVyAAEJANkEAQULbGFuZEFzc2V0SWQJAMwIAgkBC0RlbGV0ZUVudHJ5AQkBFmtleVN0YWtlZFRpbWVCeUFzc2V0SWQBBQtsYW5kQXNzZXRJZAkAzAgCCQELRGVsZXRlRW50cnkBCQEia2V5U3Rha2VkVGltZUJ5VHlwZUFzc2V0SWRBbmRPd25lcgMFCkxBTkRQUkVGSVgFC2xhbmRBc3NldElkBQRhZGRyCQDMCAIJAQtTdHJpbmdFbnRyeQIJARFrZXlSZXNQcm9wb3J0aW9ucwAFBXByb3BzCQDMCAIJAQtTdHJpbmdFbnRyeQIIBQtjbGFpbVJlc3VsdAJfMgkAuQkCCAULY2xhaW1SZXN1bHQCXzMCAToJAMwIAgMJAGYCCQCQAwEFBWxhbmRzAAEJAQtTdHJpbmdFbnRyeQIFCGxhbmRzS2V5CQC7CQIJANEIAgUFbGFuZHMJAQV2YWx1ZQEFA2lkeAIBXwkBC0RlbGV0ZUVudHJ5AQUIbGFuZHNLZXkJAMwIAgkBDEludGVnZXJFbnRyeQIFCXBpZWNlc0tleQUJbmV3UGllY2VzCQDMCAIFDHByb2xvZ0FjdGlvbgUDbmlsBQl3bGdSZXN1bHQBaQEJc3Rha2VEdWNrAAQMcHJvbG9nQWN0aW9uCQEGcHJvbG9nAQUBaQMJAQIhPQIJAJADAQgFAWkIcGF5bWVudHMAAQkAAgECHEV4YWN0bHkgb25lIHBheW1lbnQgcmVxdWlyZWQEA3BtdAkBBXZhbHVlAQkAkQMCCAUBaQhwYXltZW50cwAABAdhc3NldElkCQEFdmFsdWUBCAUDcG10B2Fzc2V0SWQEB2FkZHJlc3MJAKUIAQgFAWkGY2FsbGVyAwkBAiE9AggFA3BtdAZhbW91bnQAAQkAAgEJAKwCAgkArAICAgRORlQgBQpEVUNLUFJFRklYAiQgdG9rZW4gc2hvdWxkIGJlIGF0dGFjaGVkIGFzIHBheW1lbnQEBWFzc2V0CQEFdmFsdWUBCQDsBwEFB2Fzc2V0SWQDAwkBAiE9AggFBWFzc2V0Bmlzc3VlcgUNaW5jdWJhdG9yQWRkcgkBAiE9AggFBWFzc2V0Bmlzc3VlcgULYnJlZWRlckFkZHIHCQACAQkArAICCQCsAgICElVua25vd24gaXNzdWVyIG9mIAUKRFVDS1BSRUZJWAIGIHRva2VuAwkBASEBCQEIY29udGFpbnMCCAUFYXNzZXQEbmFtZQUKRFVDS1BSRUZJWAkAAgEJAKwCAgkArAICAglPbmx5IE5GVCAFCkRVQ0tQUkVGSVgCFCB0b2tlbnMgYXJlIGFjY2VwdGVkBAphc3NldElkU3RyCQDYBAEFB2Fzc2V0SWQEB3RpbWVLZXkJARZrZXlTdGFrZWRUaW1lQnlBc3NldElkAQUKYXNzZXRJZFN0cgMJAQlpc0RlZmluZWQBCQCfCAEFB3RpbWVLZXkJAAIBCQCsAgIJAKwCAgIETkZUIAgFBWFzc2V0BG5hbWUCEiBpcyBhbHJlYWR5IHN0YWtlZAMJAQlpc0RlZmluZWQBCQCiCAEJARRrZXlTdGFrZWREdWNrQnlPd25lcgEFB2FkZHJlc3MJAAIBCQCsAgICHVlvdSBhbHJlYWR5IHN0YWtlZCBvbmUgZHVjazogCAUFYXNzZXQEbmFtZQQGbG9jS2V5CQEPa2V5RHVja0xvY2F0aW9uAQUKYXNzZXRJZFN0cgQIbG9jYXRpb24JAKIIAQUGbG9jS2V5BAVicEtleQkBEWtleUJhY2twYWNrQnlEdWNrAQUKYXNzZXRJZFN0cgQIYmFja3BhY2sJAKIIAQUFYnBLZXkECWtleUhlYWx0aAkBDWtleUR1Y2tIZWFsdGgBBQphc3NldElkU3RyBAVtYXhIUAkBCW1heEhlYWx0aAEJAQt2YWx1ZU9yRWxzZQIJAJ8IAQkBDGtleUR1Y2tMZXZlbAEFCmFzc2V0SWRTdHIAAAQJY3VySGVhbHRoCQELdmFsdWVPckVsc2UCCQCfCAEFCWtleUhlYWx0aAUFbWF4SFAJAM4IAgkAzAgCCQEMSW50ZWdlckVudHJ5AgUHdGltZUtleQgFCWxhc3RCbG9jawl0aW1lc3RhbXAJAMwIAgkBDEludGVnZXJFbnRyeQIJASJrZXlTdGFrZWRUaW1lQnlUeXBlQXNzZXRJZEFuZE93bmVyAwUKRFVDS1BSRUZJWAkA2AQBBQdhc3NldElkBQdhZGRyZXNzCAUJbGFzdEJsb2NrCXRpbWVzdGFtcAkAzAgCCQELU3RyaW5nRW50cnkCCQEQa2V5RHVja0lkVG9Pd25lcgEFCmFzc2V0SWRTdHIFB2FkZHJlc3MJAMwIAgkBC1N0cmluZ0VudHJ5AgkBFGtleVN0YWtlZER1Y2tCeU93bmVyAQUHYWRkcmVzcwUKYXNzZXRJZFN0cgUDbmlsAwkBCWlzRGVmaW5lZAEFCGxvY2F0aW9uBQNuaWwJAM4IAgkAzAgCCQELU3RyaW5nRW50cnkCBQZsb2NLZXkFD0RFRkFVTFRMT0NBVElPTgUDbmlsAwkBCWlzRGVmaW5lZAEFCGJhY2twYWNrBQNuaWwJAM0IAgkAzQgCCQDMCAIJAQtTdHJpbmdFbnRyeQIFBWJwS2V5AhowOjBfMF8wXzBfMF8wOjBfMF8wXzBfMF8wOgUDbmlsCQEMSW50ZWdlckVudHJ5AgUJa2V5SGVhbHRoBQljdXJIZWFsdGgFDHByb2xvZ0FjdGlvbgFpAQt1bnN0YWtlRHVjawEKYXNzZXRJZFN0cgQMcHJvbG9nQWN0aW9uCQEGcHJvbG9nAQUBaQMJAQIhPQIJAJADAQgFAWkIcGF5bWVudHMAAAkAAgECFE5vIHBheW1lbnRzIHJlcXVpcmVkBAdhc3NldElkCQDZBAEFCmFzc2V0SWRTdHIEB2FkZHJlc3MJAKUIAQgFAWkGY2FsbGVyBAVhc3NldAkBBXZhbHVlAQkA7AcBBQdhc3NldElkBAd0aW1lS2V5CQEWa2V5U3Rha2VkVGltZUJ5QXNzZXRJZAEJANgEAQUHYXNzZXRJZAMJAQEhAQkBCWlzRGVmaW5lZAEJAJ8IAQUHdGltZUtleQkAAgEJAKwCAgkArAICAgRORlQgCAUFYXNzZXQEbmFtZQIOIGlzIG5vdCBzdGFrZWQDCQEBIQEJAQlpc0RlZmluZWQBCQCiCAEJARRrZXlTdGFrZWREdWNrQnlPd25lcgEFB2FkZHJlc3MJAAIBCQCsAgIJAKwCAgIJVGhlIGR1Y2sgCAUFYXNzZXQEbmFtZQIOIGlzIG5vdCBzdGFrZWQEBW93bmVyCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAKIIAQkBEGtleUR1Y2tJZFRvT3duZXIBCQDYBAEFB2Fzc2V0SWQJAKwCAgkArAICAgRORlQgCAUFYXNzZXQEbmFtZQIMIGlzIG9ycGhhbmVkAwkBAiE9AgUFb3duZXIFB2FkZHJlc3MJAAIBAhdTdGFrZWQgTkZUIGlzIG5vdCB5b3VycwQJa2V5SGVhbHRoCQENa2V5RHVja0hlYWx0aAEFCmFzc2V0SWRTdHIEBW1heEhQCQEJbWF4SGVhbHRoAQkBC3ZhbHVlT3JFbHNlAgkAnwgBCQEMa2V5RHVja0xldmVsAQUKYXNzZXRJZFN0cgAABAZoZWFsdGgJAQt2YWx1ZU9yRWxzZQIJAJ8IAQUJa2V5SGVhbHRoBQVtYXhIUAMJAGYCBQVtYXhIUAUGaGVhbHRoCQACAQkArAICCQCsAgICGVBsZWFzZSBoZWFsIHlvdXIgZHVjayB0byAJAKQDAQUFbWF4SFACE2hwIGJlZm9yZSB1bnN0YWtpbmcJAMwIAgkBDlNjcmlwdFRyYW5zZmVyAwgFAWkGY2FsbGVyAAEFB2Fzc2V0SWQJAMwIAgkBC0RlbGV0ZUVudHJ5AQUHdGltZUtleQkAzAgCCQELRGVsZXRlRW50cnkBBQlrZXlIZWFsdGgJAMwIAgkBC0RlbGV0ZUVudHJ5AQkBD2tleUR1Y2tMb2NhdGlvbgEFCmFzc2V0SWRTdHIJAMwIAgkBC0RlbGV0ZUVudHJ5AQkBEGtleUR1Y2tJZFRvT3duZXIBBQphc3NldElkU3RyCQDMCAIJAQtEZWxldGVFbnRyeQEJASJrZXlTdGFrZWRUaW1lQnlUeXBlQXNzZXRJZEFuZE93bmVyAwUKRFVDS1BSRUZJWAUKYXNzZXRJZFN0cgUHYWRkcmVzcwkAzAgCCQELRGVsZXRlRW50cnkBCQEUa2V5U3Rha2VkRHVja0J5T3duZXIBBQdhZGRyZXNzCQDMCAIFDHByb2xvZ0FjdGlvbgUDbmlsAWkBCGNsYWltUmVzAgZhbW91bnQObGFuZEFzc2V0SWRTdHIEDHByb2xvZ0FjdGlvbgkBBnByb2xvZwEFAWkDCQECIT0CCQCQAwEIBQFpCHBheW1lbnRzAAAJAAIBAhRObyBwYXltZW50cyByZXF1aXJlZAQEYWRkcgkApQgBCAUBaQxvcmlnaW5DYWxsZXIEBnJlc3VsdAkBEGNsYWltUmVzSW50ZXJuYWwEBQRhZGRyBQZhbW91bnQFDWNsYWltTW9kZUR1Y2sFDmxhbmRBc3NldElkU3RyBAtkdWNrQXNzZXRJZAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCiCAEJARRrZXlTdGFrZWREdWNrQnlPd25lcgEFBGFkZHICHFlvdSBkb24ndCBoYXZlIGEgZHVjayBzdGFrZWQJAJQKAgkAzQgCCQDNCAIJAM0IAgkAzggCCAUGcmVzdWx0Al8xCAkBF3VwZGF0ZUR1Y2tTdGF0c0ludGVybmFsAgULZHVja0Fzc2V0SWQJAGsDBQd4cENsYWltBQZhbW91bnQFBU1VTFQ4Al8xCQELU3RyaW5nRW50cnkCCAUGcmVzdWx0Al8yCQC5CQIIBQZyZXN1bHQCXzMCAToJAQtTdHJpbmdFbnRyeQIIBQZyZXN1bHQCXzQJALkJAggFBnJlc3VsdAJfNQIBOgUMcHJvbG9nQWN0aW9uCQCRAwIIBQZyZXN1bHQCXzMFCGJwSWR4UmVzAWkBDGNsYWltUmVzVG9XSAIGYW1vdW50DmxhbmRBc3NldElkU3RyBAxwcm9sb2dBY3Rpb24JAQZwcm9sb2cBBQFpAwkBAiE9AgkAkAMBCAUBaQhwYXltZW50cwAACQACAQIUTm8gcGF5bWVudHMgcmVxdWlyZWQEBGFkZHIJAKUIAQgFAWkMb3JpZ2luQ2FsbGVyBAZyZXN1bHQJARBjbGFpbVJlc0ludGVybmFsBAUEYWRkcgUGYW1vdW50BQtjbGFpbU1vZGVXaAUObGFuZEFzc2V0SWRTdHIJAJQKAgkAzQgCCQDNCAIJAM0IAgkAzggCCAUGcmVzdWx0Al8xCAkBFnVwZGF0ZUFjY1N0YXRzSW50ZXJuYWwCBQRhZGRyCQBrAwUHeHBDbGFpbQUGYW1vdW50BQVNVUxUOAJfMQkBC1N0cmluZ0VudHJ5AggFBnJlc3VsdAJfMgkAuQkCCAUGcmVzdWx0Al8zAgE6CQELU3RyaW5nRW50cnkCCAUGcmVzdWx0Al80CQC5CQIIBQZyZXN1bHQCXzUCAToFDHByb2xvZ0FjdGlvbgkAkQMCCAUGcmVzdWx0Al81BQh3aElkeFJlcwFpAQZmbGlnaHQCB21lc3NhZ2UDc2lnBAxwcm9sb2dBY3Rpb24JAQZwcm9sb2cBBQFpAwkBAiE9AgkAkAMBCAUBaQhwYXltZW50cwAACQACAQIUTm8gcGF5bWVudHMgcmVxdWlyZWQECHVzZXJBZGRyCQClCAEIBQFpBmNhbGxlcgQBZgkBDGZsaWdodENvbW1vbgMFCHVzZXJBZGRyBQdtZXNzYWdlBQNzaWcEC2R1Y2tBc3NldElkCAUBZgJfMgQGbG9jS2V5CQEPa2V5RHVja0xvY2F0aW9uAQULZHVja0Fzc2V0SWQEC2N1ckxvY2F0aW9uCQELdmFsdWVPckVsc2UCCQCiCAEFBmxvY0tleQUPREVGQVVMVExPQ0FUSU9OAwkAAAIIBQFmAl80BQtjdXJMb2NhdGlvbgkAAgECIllvdSBjYW4ndCBmbHkgdG8gdGhlIHNhbWUgbG9jYXRpb24EBWJwS2V5CQERa2V5QmFja3BhY2tCeUR1Y2sBBQtkdWNrQXNzZXRJZAQLY3VycmVudFBhY2sJAQtnZXRCYWNrcGFjawEFBWJwS2V5BAduZXdQcm9kCQEQc3VidHJhY3RQcm9kdWN0cwIJAJEDAgULY3VycmVudFBhY2sFCWJwSWR4UHJvZAgFAWYCXzUJAJQKAgkAzggCCQDMCAIJAQtTdHJpbmdFbnRyeQIFBmxvY0tleQMJAGYCCAUBZgJfMQAACAUBZgJfNAULY3VyTG9jYXRpb24JAMwIAgkBC1N0cmluZ0VudHJ5AgUFYnBLZXkJALkJAgkAzAgCCQCRAwIFC2N1cnJlbnRQYWNrBQpicElkeExldmVsCQDMCAIJAJEDAgULY3VycmVudFBhY2sFCGJwSWR4UmVzCQDMCAIJAJEDAgULY3VycmVudFBhY2sFCGJwSWR4TWF0CQDMCAIFB25ld1Byb2QFA25pbAIBOgkAzAgCCQEMSW50ZWdlckVudHJ5AgkBDWtleUR1Y2tIZWFsdGgBBQtkdWNrQXNzZXRJZAgFAWYCXzEJAMwIAgUMcHJvbG9nQWN0aW9uBQNuaWwICQEXdXBkYXRlRHVja1N0YXRzSW50ZXJuYWwCBQtkdWNrQXNzZXRJZAMJAGYCCAUBZgJfMQAABQ94cFN1Y2Nlc3NGbGlnaHQFDHhwRmFpbEZsaWdodAJfMQgFAWYCXzMBaQEEaGVhbAMKcXVhbnRpdHlMMQpxdWFudGl0eUwyCnF1YW50aXR5TDMEDHByb2xvZ0FjdGlvbgkBBnByb2xvZwEFAWkDAwMJAGYCAAAFCnF1YW50aXR5TDEGCQBmAgAABQpxdWFudGl0eUwyBgkAZgIAAAUKcXVhbnRpdHlMMwkAAgECG1F1YW50aXR5IGNhbm5vdCBiZSBuZWdhdGl2ZQQLZHVja0Fzc2V0SWQJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAoggBCQEUa2V5U3Rha2VkRHVja0J5T3duZXIBCQClCAEIBQFpBmNhbGxlcgIcWW91IGRvbid0IGhhdmUgYSBkdWNrIHN0YWtlZAQDcXRzCQDMCAIFCnF1YW50aXR5TDEJAMwIAgUKcXVhbnRpdHlMMgkAzAgCBQpxdWFudGl0eUwzBQNuaWwECWtleUhlYWx0aAkBDWtleUR1Y2tIZWFsdGgBBQtkdWNrQXNzZXRJZAQFbWF4SFAJAQltYXhIZWFsdGgBCQELdmFsdWVPckVsc2UCCQCfCAEJAQxrZXlEdWNrTGV2ZWwBBQtkdWNrQXNzZXRJZAAABAlvbGRIZWFsdGgJAQt2YWx1ZU9yRWxzZQIJAJ8IAQUJa2V5SGVhbHRoBQVtYXhIUAMJAGcCBQlvbGRIZWFsdGgFBW1heEhQCQACAQkArAICCQCsAgICD0hQIHNob3VsZCBiZSA8IAkApAMBBQVtYXhIUAIIIHRvIGhlYWwEBWJwS2V5CQERa2V5QmFja3BhY2tCeUR1Y2sBBQtkdWNrQXNzZXRJZAQLY3VycmVudFBhY2sJAQtnZXRCYWNrcGFjawEFBWJwS2V5BAhwcm9kTGlzdAMJAAACCQCRAwIFC2N1cnJlbnRQYWNrBQlicElkeFByb2QCAAUDbmlsCQC1CQIJAJEDAgULY3VycmVudFBhY2sFCWJwSWR4UHJvZAIBXwoBC2l0ZXJhdGVQcm9kAgNhY2MLaWdub3JlZEl0ZW0EAW4IBQNhY2MCXzIEAXgDCQBmAgkAkAMBBQhwcm9kTGlzdAUBbgkBDXBhcnNlSW50VmFsdWUBCQCRAwIFCHByb2RMaXN0BQFuAAADCQBmAgADBQFuBAFxCQCRAwIFA3F0cwUBbgMJAGYCBQFxBQF4CQACAQkArAICCQCsAgIJAKwCAgIOWW91IGhhdmUgb25seSAJAKQDAQUBeAIEIG9mIAkAkQMCBQlwcm9kVHlwZXMFAW4JAJUKAwkAzQgCCAUDYWNjAl8xCQCkAwEJAGUCBQF4BQFxCQBkAgUBbgABCQBkAggFA2FjYwJfMwkAaAIJAJEDAgUIbWVkS2l0SHAFAW4FAXEJAJUKAwkAzQgCCAUDYWNjAl8xCQCkAwEFAXgJAGQCBQFuAAEIBQNhY2MCXzMEBnJlc3VsdAoAAiRsBRBwcm9kdWN0aW9uTWF0cml4CgACJHMJAJADAQUCJGwKAAUkYWNjMAkAlQoDBQNuaWwAAAAACgEFJGYwXzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQtpdGVyYXRlUHJvZAIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgNTAJAQUkZjBfMgIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgALAAwADQAOAA8AEAARABIAEwAUABUAFgAXABgAGQAaABsAHAAdAB4AHwAgACEAIgAjACQAJQAmACcAKAApACoAKwAsAC0ALgAvADAAMQAyBAluZXdIZWFsdGgJAJcDAQkAzAgCBQVtYXhIUAkAzAgCCQBkAgUJb2xkSGVhbHRoCAUGcmVzdWx0Al8zBQNuaWwJAJQKAgkAzggCCQDMCAIJAQxJbnRlZ2VyRW50cnkCBQlrZXlIZWFsdGgFCW5ld0hlYWx0aAkAzAgCCQELU3RyaW5nRW50cnkCBQVicEtleQkAugkCCQDMCAIJAJEDAgULY3VycmVudFBhY2sFCmJwSWR4TGV2ZWwJAMwIAgkAkQMCBQtjdXJyZW50UGFjawUIYnBJZHhSZXMJAMwIAgkAkQMCBQtjdXJyZW50UGFjawUIYnBJZHhNYXQJAMwIAgkAuQkCCAUGcmVzdWx0Al8xAgFfBQNuaWwCAToJAMwIAgUMcHJvbG9nQWN0aW9uBQNuaWwICQEXdXBkYXRlRHVja1N0YXRzSW50ZXJuYWwCBQtkdWNrQXNzZXRJZAkAaAIFBnhwSGVhbAkAZAIJAGQCBQpxdWFudGl0eUwxBQpxdWFudGl0eUwyBQpxdWFudGl0eUwzAl8xBQluZXdIZWFsdGgBaQEGaGVhbEVTAAQMcHJvbG9nQWN0aW9uCQEGcHJvbG9nAQUBaQMJAQIhPQIJAJADAQgFAWkIcGF5bWVudHMAAQkAAgECHEV4YWN0bHkgb25lIHBheW1lbnQgcmVxdWlyZWQEA3BtdAkBBXZhbHVlAQkAkQMCCAUBaQhwYXltZW50cwAAAwkBAiE9AggFA3BtdAdhc3NldElkBQt1c2R0QXNzZXRJZAkAAgECGkFsbG93ZWQgVVNEVCBwYXltZW50IG9ubHkhBAtkdWNrQXNzZXRJZAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCiCAEJARRrZXlTdGFrZWREdWNrQnlPd25lcgEJAKUIAQgFAWkGY2FsbGVyAhxZb3UgZG9uJ3QgaGF2ZSBhIGR1Y2sgc3Rha2VkBAlrZXlIZWFsdGgJAQ1rZXlEdWNrSGVhbHRoAQULZHVja0Fzc2V0SWQEBW1heEhQCQEJbWF4SGVhbHRoAQkBC3ZhbHVlT3JFbHNlAgkAnwgBCQEMa2V5RHVja0xldmVsAQULZHVja0Fzc2V0SWQAAAQJb2xkSGVhbHRoCQELdmFsdWVPckVsc2UCCQCfCAEFCWtleUhlYWx0aAUFbWF4SFADCQBmAgUJb2xkSGVhbHRoAAAJAAIBAihIUCBzaG91bGQgYmUgMCB0byBjYWxsIEVtZXJnZW5jeSBTZXJ2aWNlBAVicEtleQkBEWtleUJhY2twYWNrQnlEdWNrAQULZHVja0Fzc2V0SWQEC2N1cnJlbnRQYWNrCQELZ2V0QmFja3BhY2sBBQVicEtleQQIcHJvZExpc3QDCQAAAgkAkQMCBQtjdXJyZW50UGFjawUJYnBJZHhQcm9kAgAFA25pbAkAtQkCCQCRAwIFC2N1cnJlbnRQYWNrBQlicElkeFByb2QCAV8EDW1lZEtpdEFtb3VudDEDCQBmAgkAkAMBBQhwcm9kTGlzdAAACQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUIcHJvZExpc3QAAAAABA1tZWRLaXRBbW91bnQyAwkAZgIJAJADAQUIcHJvZExpc3QAAQkBDXBhcnNlSW50VmFsdWUBCQCRAwIFCHByb2RMaXN0AAEAAAQNbWVkS2l0QW1vdW50MwMJAGYCCQCQAwEFCHByb2RMaXN0AAIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQhwcm9kTGlzdAACAAADAwMJAGYCBQ1tZWRLaXRBbW91bnQxAAAGCQBmAgUNbWVkS2l0QW1vdW50MgAABgkAZgIFDW1lZEtpdEFtb3VudDMAAAkAAgECH1lvdSBoYXZlIHRvIHVzZSBvd24gTWVkaWNhbCBLaXQECGV4aXN0U3RyCQCdCAIFD2Vjb25vbXlDb250cmFjdAkBDmtleUVzV2FyZWhvdXNlAAQMZXhpc3RBbW91bnRzAwkBCWlzRGVmaW5lZAEFCGV4aXN0U3RyCQC1CQIJAQV2YWx1ZQEFCGV4aXN0U3RyAgFfBQNuaWwEC2V4aXN0QW1vdW50AwkAZgIJAJADAQUMZXhpc3RBbW91bnRzAAAJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQxleGlzdEFtb3VudHMAAAAAAwkAZwIAAAULZXhpc3RBbW91bnQJAAIBAjlUaGVyZSBhcmUgbm8gTWVkaWNhbCBLaXRzIEwxIGF0IEVtZXJnZW5jeSBTZXJ2aWNlIHN0b3JhZ2UECW5ld0hlYWx0aAkAZAIFCW9sZEhlYWx0aAkAkQMCBQhtZWRLaXRIcAAABAVuZXdFUwkAuQkCCQDMCAIJAKQDAQkAZQIFC2V4aXN0QW1vdW50AAEJANEIAgUMZXhpc3RBbW91bnRzAAACAV8EBnJlY2lwZQkAtQkCCQCRAwIFEHByb2R1Y3Rpb25NYXRyaXgAAAIBXwQIdG90YWxNYXQJARJnZXRSZWNpcGVNYXRlcmlhbHMBBQZyZWNpcGUECXNlbGxQcmljZQkAawMJAGgCBQh0b3RhbE1hdAUKRVNTRUxMQ09FRgUQUkVTT1VSQ0VQUklDRU1JTgkAaAIACgUOcHJvZHVjdFBrZ1NpemUDCQECIT0CCAUDcG10BmFtb3VudAUJc2VsbFByaWNlCQACAQkArAICAhtQYXltZW50IGF0dGFjaGVkIHNob3VsZCBiZSAJAKQDAQUJc2VsbFByaWNlBAZyZXN1bHQJAQhhc1N0cmluZwEJAPwHBAUPZWNvbm9teUNvbnRyYWN0Ag91cGRhdGVFc1N0b3JhZ2UJAMwIAgUFbmV3RVMFA25pbAkAzAgCCQEPQXR0YWNoZWRQYXltZW50AgULdXNkdEFzc2V0SWQFCXNlbGxQcmljZQUDbmlsCQCUCgIJAM4IAgkAzAgCCQEMSW50ZWdlckVudHJ5AgUJa2V5SGVhbHRoBQluZXdIZWFsdGgJAMwIAgUMcHJvbG9nQWN0aW9uBQNuaWwICQEXdXBkYXRlRHVja1N0YXRzSW50ZXJuYWwCBQtkdWNrQXNzZXRJZAUIeHBDYWxsRVMCXzEFBnJlc3VsdAFpAQ51cGRhdGVCYWNrcGFjawILZHVja0Fzc2V0SWQHbmV3UGFjawMJAQIhPQIIBQFpBmNhbGxlcgUPZWNvbm9teUNvbnRyYWN0CQACAQIRcGVybWlzc2lvbiBkZW5pZWQJAJQKAgkAzAgCCQELU3RyaW5nRW50cnkCCQERa2V5QmFja3BhY2tCeUR1Y2sBBQtkdWNrQXNzZXRJZAUHbmV3UGFjawUDbmlsBQduZXdQYWNrAWkBCGJ1eVNMYW5kAAQMcHJvbG9nQWN0aW9uCQEGcHJvbG9nAQUBaQMJAQIhPQIJAJADAQgFAWkIcGF5bWVudHMAAQkAAgECHEV4YWN0bHkgb25lIHBheW1lbnQgcmVxdWlyZWQEA3BtdAkBBXZhbHVlAQkAkQMCCAUBaQhwYXltZW50cwAAAwkBAiE9AggFA3BtdAdhc3NldElkBQt1c2R0QXNzZXRJZAkAAgECGkFsbG93ZWQgVVNEVCBwYXltZW50IG9ubHkhAwkBAiE9AggFA3BtdAZhbW91bnQFB0VYUFVTRFQJAAIBCQCsAgICG1BheW1lbnQgYXR0YWNoZWQgc2hvdWxkIGJlIAkApAMBBQdFWFBVU0RUBAZyZXN1bHQJARJleHBlZGl0aW9uSW50ZXJuYWwCCAUBaQZjYWxsZXIIBQFpDXRyYW5zYWN0aW9uSWQJAJQKAgkAzQgCCQDOCAIJAM0IAggFBnJlc3VsdAJfMQkBDlNjcmlwdFRyYW5zZmVyAwUPZWNvbm9teUNvbnRyYWN0CAUDcG10BmFtb3VudAULdXNkdEFzc2V0SWQICQEWdXBkYXRlQWNjU3RhdHNJbnRlcm5hbAIJAKUIAQgFAWkGY2FsbGVyBQp4cE5ld1NMYW5kAl8xBQxwcm9sb2dBY3Rpb24ICAUGcmVzdWx0Al8yAl8xAWkBCmV4cGVkaXRpb24CB21lc3NhZ2UDc2lnBAxwcm9sb2dBY3Rpb24JAQZwcm9sb2cBBQFpAwkBAiE9AgkAkAMBCAUBaQhwYXltZW50cwAACQACAQIUTm8gcGF5bWVudHMgcmVxdWlyZWQEBnJlc3VsdAkBEGV4cGVkaXRpb25Db21tb24ECAUBaQZjYWxsZXIIBQFpDXRyYW5zYWN0aW9uSWQFB21lc3NhZ2UFA3NpZwQLZHVja0Fzc2V0SWQJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAoggBCQEUa2V5U3Rha2VkRHVja0J5T3duZXIBCQClCAEIBQFpBmNhbGxlcgIcWW91IGRvbid0IGhhdmUgYSBkdWNrIHN0YWtlZAkAlAoCCQDNCAIJAM4IAggFBnJlc3VsdAJfMQgJARd1cGRhdGVEdWNrU3RhdHNJbnRlcm5hbAIFC2R1Y2tBc3NldElkBQp4cE5ld1NMYW5kAl8xBQxwcm9sb2dBY3Rpb24JAJQKAggFBnJlc3VsdAJfMggFBnJlc3VsdAJfMwFpAQx1cGdyYWRlSW5mcmEBC2xhbmRBc3NldElkBAxwcm9sb2dBY3Rpb24JAQZwcm9sb2cBBQFpAwkBAiE9AgkAkAMBCAUBaQhwYXltZW50cwAACQACAQIUTm8gcGF5bWVudHMgcmVxdWlyZWQEBnJlc3VsdAkBDXVwSW5mcmFDb21tb24EBggFAWkGY2FsbGVyAAAFC2xhbmRBc3NldElkBAtkdWNrQXNzZXRJZAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCiCAEJARRrZXlTdGFrZWREdWNrQnlPd25lcgEJAKUIAQgFAWkGY2FsbGVyAhxZb3UgZG9uJ3QgaGF2ZSBhIGR1Y2sgc3Rha2VkCQCUCgIJAM4IAgkAzQgCCAUGcmVzdWx0Al8xBQxwcm9sb2dBY3Rpb24ICQEXdXBkYXRlRHVja1N0YXRzSW50ZXJuYWwCBQtkdWNrQXNzZXRJZAkAawMFDnhwVXBncmFkZUluZnJhCAUGcmVzdWx0Al8zBQVNVUxUOAJfMQgFBnJlc3VsdAJfMgFpARB1cGdyYWRlSW5mcmFVc2R0AQtsYW5kQXNzZXRJZAMJAQIhPQIIBQFpBmNhbGxlcgUEdGhpcwkAAgECEVBlcm1pc3Npb24gZGVuaWVkBAxwcm9sb2dBY3Rpb24JAQZwcm9sb2cBBQFpAwkBAiE9AgkAkAMBCAUBaQhwYXltZW50cwABCQACAQIcRXhhY3RseSBvbmUgcGF5bWVudCByZXF1aXJlZAQDcG10CQEFdmFsdWUBCQCRAwIIBQFpCHBheW1lbnRzAAADCQECIT0CCAUDcG10B2Fzc2V0SWQFC3VzZHRBc3NldElkCQACAQIaQWxsb3dlZCBVU0RUIHBheW1lbnQgb25seSEEBnJlc3VsdAkBDXVwSW5mcmFDb21tb24EBwgFAWkGY2FsbGVyCAUDcG10BmFtb3VudAULbGFuZEFzc2V0SWQJAJQKAgkAzQgCCQDNCAIIBQZyZXN1bHQCXzEJAQ5TY3JpcHRUcmFuc2ZlcgMFD2Vjb25vbXlDb250cmFjdAgFA3BtdAZhbW91bnQFC3VzZHRBc3NldElkBQxwcm9sb2dBY3Rpb24IBQZyZXN1bHQCXzIBaQEQYWN0aXZhdGVBcnRpZmFjdAIHYXJ0TmFtZQ5sYW5kQXNzZXRJZE9wdAQMcHJvbG9nQWN0aW9uCQEGcHJvbG9nAQUBaQMJAQIhPQIJAJADAQgFAWkIcGF5bWVudHMAAAkAAgECFE5vIHBheW1lbnRzIHJlcXVpcmVkBARhZGRyCQClCAEIBQFpBmNhbGxlcgQGcmVzdWx0BAckbWF0Y2gwBQdhcnROYW1lAwkAAAICB1BSRVNBTEUFByRtYXRjaDAJARJhY3RpdmF0ZVByZXNhbGVBcnQCBQRhZGRyBQ5sYW5kQXNzZXRJZE9wdAMJAAACAgdPTkJPQVJEBQckbWF0Y2gwCQESYWN0aXZhdGVPbmJvYXJkQXJ0AQUEYWRkcgkAAgECEFVua25vd24gYXJ0aWZhY3QJAM0IAgUGcmVzdWx0BQxwcm9sb2dBY3Rpb24BaQEKbWVyZ2VMYW5kcwEMbGFuZEFzc2V0SWRzBAxwcm9sb2dBY3Rpb24JAQZwcm9sb2cBBQFpAwkBAiE9AgkAkAMBCAUBaQhwYXltZW50cwAACQACAQIUTm8gcGF5bWVudHMgcmVxdWlyZWQEBnJlc3VsdAkBC21lcmdlQ29tbW9uBQYJAKUIAQgFAWkGY2FsbGVyAAAFDGxhbmRBc3NldElkcwgFAWkNdHJhbnNhY3Rpb25JZAkAlAoCCQDOCAIJAM0IAggFBnJlc3VsdAJfMQUMcHJvbG9nQWN0aW9uCAkBFnVwZGF0ZUFjY1N0YXRzSW50ZXJuYWwCCQClCAEIBQFpBmNhbGxlcgUHeHBNZXJnZQJfMQgFBnJlc3VsdAJfMgFpAQ5tZXJnZUxhbmRzVXNkdAEMbGFuZEFzc2V0SWRzBAxwcm9sb2dBY3Rpb24JAQZwcm9sb2cBBQFpAwkBAiE9AgkAkAMBCAUBaQhwYXltZW50cwABCQACAQIcRXhhY3RseSBvbmUgcGF5bWVudCByZXF1aXJlZAQDcG10CQEFdmFsdWUBCQCRAwIIBQFpCHBheW1lbnRzAAADCQECIT0CCAUDcG10B2Fzc2V0SWQFC3VzZHRBc3NldElkCQACAQIaQWxsb3dlZCBVU0RUIHBheW1lbnQgb25seSEEBnJlc3VsdAkBC21lcmdlQ29tbW9uBQcJAKUIAQgFAWkGY2FsbGVyCAUDcG10BmFtb3VudAUMbGFuZEFzc2V0SWRzCAUBaQ10cmFuc2FjdGlvbklkCQCUCgIJAM0IAgkAzQgCCAUGcmVzdWx0Al8xCQEOU2NyaXB0VHJhbnNmZXIDBQ9lY29ub215Q29udHJhY3QIBQNwbXQGYW1vdW50BQt1c2R0QXNzZXRJZAUMcHJvbG9nQWN0aW9uCAUGcmVzdWx0Al8yAWkBDWNhcmdvRXhjaGFuZ2UCDGNhcmdvTGlzdFN0cgtsYW5kQXNzZXRJZAQMcHJvbG9nQWN0aW9uCQEGcHJvbG9nAQUBaQMJAQIhPQIJAJADAQgFAWkIcGF5bWVudHMAAAkAAgECFE5vIHBheW1lbnRzIHJlcXVpcmVkBApjYXJnb1BhcnRzCQC8CQIFDGNhcmdvTGlzdFN0cgIBOgQEYWRkcgkApQgBCAUBaQxvcmlnaW5DYWxsZXIEBWFzc2V0CQEFdmFsdWUBCQDsBwEJANkEAQULbGFuZEFzc2V0SWQEB3RpbWVLZXkJARZrZXlTdGFrZWRUaW1lQnlBc3NldElkAQULbGFuZEFzc2V0SWQDCQEBIQEJAQlpc0RlZmluZWQBCQCfCAEFB3RpbWVLZXkJAAIBCQCsAgIIBQVhc3NldARuYW1lAg4gaXMgbm90IHN0YWtlZAQFb3duZXIJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAoggBCQEVa2V5TGFuZEFzc2V0SWRUb093bmVyAQULbGFuZEFzc2V0SWQJAKwCAgkArAICAgRORlQgCAUFYXNzZXQEbmFtZQIMIGlzIG9ycGhhbmVkAwkBAiE9AgUFb3duZXIFBGFkZHIJAAIBCQCsAgIFCkxBTkRQUkVGSVgCDSBpcyBub3QgeW91cnMECWxhbmRJbmRleAkAaQIJAQ9udW1QaWVjZXNCeVNpemUBCQCRAwIJALUJAggFBWFzc2V0C2Rlc2NyaXB0aW9uAgFfBQtyZWNMYW5kU2l6ZQUFU1NJWkUECmluZnJhTGV2ZWwJAQt2YWx1ZU9yRWxzZQIJAJ8IAQkBFmtleUluZnJhTGV2ZWxCeUFzc2V0SWQBBQtsYW5kQXNzZXRJZAAABAtkdWNrQXNzZXRJZAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCiCAEJARRrZXlTdGFrZWREdWNrQnlPd25lcgEFBGFkZHICHFlvdSBkb24ndCBoYXZlIGEgZHVjayBzdGFrZWQEC2N1ckxvY2F0aW9uCQELdmFsdWVPckVsc2UCCQCiCAEJAQ9rZXlEdWNrTG9jYXRpb24BBQtkdWNrQXNzZXRJZAUPREVGQVVMVExPQ0FUSU9OBANsb2MJALUJAgkBBXZhbHVlAQULY3VyTG9jYXRpb24CAV8DCQECIT0CCQCRAwIFA2xvYwUKbG9jSWR4VHlwZQIBTAkAAgEJAKwCAgkArAICAhZEdWNrIGxvY2F0aW9uIHR5cGUgaXMgCQCRAwIFA2xvYwUKbG9jSWR4VHlwZQIRLCBidXQgc2hvdWxkIGJlIEwDCQECIT0CCQCRAwIFA2xvYwUIbG9jSWR4SWQFC2xhbmRBc3NldElkCQACAQkArAICAhtEdWNrIHNob3VsZCBiZSBvbiB0aGUgbGFuZCAFC2xhbmRBc3NldElkBAV3aEtleQkBEmtleVdhcmVob3VzZUJ5TGFuZAEFC2xhbmRBc3NldElkBAljdXJyZW50V2gJAQxnZXRXYXJlaG91c2UDBQV3aEtleQUJbGFuZEluZGV4BQppbmZyYUxldmVsBAVicEtleQkBEWtleUJhY2twYWNrQnlEdWNrAQULZHVja0Fzc2V0SWQEC2N1cnJlbnRQYWNrCQELZ2V0QmFja3BhY2sBBQVicEtleQQGcmVzdWx0CQEJbW92ZVN0dWZmAwUKY2FyZ29QYXJ0cwUJY3VycmVudFdoBQtjdXJyZW50UGFjawQEbG9mdAkAtQkCCQCRAwIFCWN1cnJlbnRXaAUJd2hJZHhMT0ZUAgFfBAVsb2Z0TwkAZAIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQRsb2Z0BQt2b2xPY2N1cGllZAgFBnJlc3VsdAJfNwQFbG9mdEYJAGUCCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUEbG9mdAUHdm9sRnJlZQgFBnJlc3VsdAJfNwkAzAgCCQELU3RyaW5nRW50cnkCBQVicEtleQkAugkCCQDMCAIJAJEDAgULY3VycmVudFBhY2sFCmJwSWR4TGV2ZWwJAMwIAggFBnJlc3VsdAJfNAkAzAgCCAUGcmVzdWx0Al81CQDMCAIIBQZyZXN1bHQCXzYFA25pbAIBOgkAzAgCCQELU3RyaW5nRW50cnkCBQV3aEtleQkAugkCCQDMCAIJAJEDAgUJY3VycmVudFdoBQt3aElkeExldmVscwkAzAgCCAUGcmVzdWx0Al8xCQDMCAIIBQZyZXN1bHQCXzIJAMwIAggFBnJlc3VsdAJfMwkAzAgCCQC5CQIJAMwIAgkAkQMCBQRsb2Z0BQl2b2xMb2NrZWQJAMwIAgkApAMBBQVsb2Z0TwkAzAgCCQCkAwEFBWxvZnRGCQDMCAIJAJEDAgUEbG9mdAUIdm9sVG90YWwFA25pbAIBXwUDbmlsAgE6CQDMCAIFDHByb2xvZ0FjdGlvbgUDbmlsAWkBDXNhdmVXYXJlaG91c2UCBXdoU3RyC2xhbmRBc3NldElkAwkBAiE9AggFAWkGY2FsbGVyBQ9lY29ub215Q29udHJhY3QJAAIBAg1BY2Nlc3MgZGVuaWVkBAV3aEtleQkBEmtleVdhcmVob3VzZUJ5TGFuZAEFC2xhbmRBc3NldElkBAJ3aAkAvAkCBQV3aFN0cgIBOgMJAQIhPQIJAJADAQUCd2gABQkAAgECMHdhcmVob3VzZSBzdHJpbmcgc2hvdWxkIGNvbnRhaW4gNCAnOicgc2VwYXJhdG9ycwQFbG9mdEwJAJEDAgkAtQkCCQCRAwIFAndoBQl3aElkeExPRlQCAV8FCXZvbExvY2tlZAQFbG9mdE8JARdnZXRXYXJlaG91c2VPY2N1cGllZFZvbAEFAndoBAVsb2Z0VAkBF2dldFdhcmVob3VzZVRvdGFsVm9sdW1lAQkAkQMCBQJ3aAULd2hJZHhMZXZlbHMEBWxvZnRGCQBlAgkAZQIFBWxvZnRUCQENcGFyc2VJbnRWYWx1ZQEFBWxvZnRMBQVsb2Z0TwQIbmV3V2hTdHIJALoJAgkAzAgCCQCRAwIFAndoBQt3aElkeExldmVscwkAzAgCCQCRAwIFAndoBQh3aElkeFJlcwkAzAgCCQCRAwIFAndoBQh3aElkeE1hdAkAzAgCCQCRAwIFAndoBQl3aElkeFByb2QJAMwIAgkAuQkCCQDMCAIFBWxvZnRMCQDMCAIJAKQDAQUFbG9mdE8JAMwIAgkApAMBBQVsb2Z0RgkAzAgCCQCkAwEFBWxvZnRUBQNuaWwCAV8FA25pbAIBOgkAlAoCCQDMCAIJAQtTdHJpbmdFbnRyeQIFBXdoS2V5BQhuZXdXaFN0cgUDbmlsBQhuZXdXaFN0cgFpARJmaXhXYXJlaG91c2VGb3JtYXQBC2xhbmRBc3NldElkAwkBAiE9AggFAWkGY2FsbGVyBQxyZXN0Q29udHJhY3QJAAIBAg1BY2Nlc3MgZGVuaWVkBAV3aEtleQkBEmtleVdhcmVob3VzZUJ5TGFuZAEFC2xhbmRBc3NldElkBAVhc3NldAkBBXZhbHVlAQkA7AcBCQDZBAEFC2xhbmRBc3NldElkBAlsYW5kSW5kZXgJAGkCCQEPbnVtUGllY2VzQnlTaXplAQkAkQMCCQC1CQIIBQVhc3NldAtkZXNjcmlwdGlvbgIBXwULcmVjTGFuZFNpemUFBVNTSVpFBAppbmZyYUxldmVsCQELdmFsdWVPckVsc2UCCQCfCAEJARZrZXlJbmZyYUxldmVsQnlBc3NldElkAQULbGFuZEFzc2V0SWQAAAQCd2gJAQxnZXRXYXJlaG91c2UDBQV3aEtleQUJbGFuZEluZGV4BQppbmZyYUxldmVsBAVsb2Z0TAkBBWFzSW50AQkA/AcEBQ9lY29ub215Q29udHJhY3QCGnJlY2FsY0xvY2tlZFZvbHVtZVJFQURPTkxZCQDMCAIFC2xhbmRBc3NldElkCQDMCAIFAndoBQNuaWwFA25pbAQFbG9mdE8JARdnZXRXYXJlaG91c2VPY2N1cGllZFZvbAEFAndoBAVsb2Z0VAkBF2dldFdhcmVob3VzZVRvdGFsVm9sdW1lAQkAkQMCBQJ3aAULd2hJZHhMZXZlbHMEBWxvZnRGCQBlAgkAZQIFBWxvZnRUBQVsb2Z0TAUFbG9mdE8ECG5ld1doU3RyCQC6CQIJAMwIAgkAkQMCBQJ3aAULd2hJZHhMZXZlbHMJAMwIAgkAkQMCBQJ3aAUId2hJZHhSZXMJAMwIAgkAkQMCBQJ3aAUId2hJZHhNYXQJAMwIAgkAkQMCBQJ3aAUJd2hJZHhQcm9kCQDMCAIJALkJAgkAzAgCCQCkAwEFBWxvZnRMCQDMCAIJAKQDAQUFbG9mdE8JAMwIAgkApAMBBQVsb2Z0RgkAzAgCCQCkAwEFBWxvZnRUBQNuaWwCAV8FA25pbAIBOgkAlAoCCQDMCAIJAQtTdHJpbmdFbnRyeQIFBXdoS2V5BQhuZXdXaFN0cgUDbmlsBQhuZXdXaFN0cgFpAQ9maXhTdGFrZWRQaWVjZXMBB2FkZHJlc3MDCQECIT0CCAUBaQZjYWxsZXIFDHJlc3RDb250cmFjdAkAAgECDUFjY2VzcyBkZW5pZWQEDHN0YWtlZFBpZWNlcwMJAAACBQdhZGRyZXNzAgAAAAQIbGFuZHNTdHIJAJ0IAgUPc3Rha2luZ0NvbnRyYWN0CQEVa2V5U3Rha2VkTGFuZHNCeU93bmVyAQUHYWRkcmVzcwQFbGFuZHMDCQEJaXNEZWZpbmVkAQUIbGFuZHNTdHIJAL0JAgkBBXZhbHVlAQUIbGFuZHNTdHICAV8FA25pbAoBB29uZUxhbmQCA2FjYwtsYW5kQXNzZXRJZAQFYXNzZXQJAQV2YWx1ZQEJAOwHAQkA2QQBBQtsYW5kQXNzZXRJZAQIbGFuZFNpemUJAJEDAgkAtQkCCAUFYXNzZXQLZGVzY3JpcHRpb24CAV8FC3JlY0xhbmRTaXplCQBkAgUDYWNjCQEPbnVtUGllY2VzQnlTaXplAQUIbGFuZFNpemUKAAIkbAUFbGFuZHMKAAIkcwkAkAMBBQIkbAoABSRhY2MwAAAKAQUkZjBfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBB29uZUxhbmQCBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjBfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFUxpc3Qgc2l6ZSBleGNlZWRzIDEwMAkBBSRmMF8yAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKAAsADAANAA4ADwAQABEAEgATABQAFQAWABcAGAAZABoAGwAcAB0AHgAfACAAIQAiACMAJAAlACYAJwAoACkAKgArACwALQAuAC8AMAAxADIAMwA0ADUANgA3ADgAOQA6ADsAPAA9AD4APwBAAEEAQgBDAEQARQBGAEcASABJAEoASwBMAE0ATgBPAFAAUQBSAFMAVABVAFYAVwBYAFkAWgBbAFwAXQBeAF8AYABhAGIAYwBkCQCUCgIJAMwIAgkBDEludGVnZXJFbnRyeQIJARZrZXlTdGFrZWRQaWVjZXNCeU93bmVyAQUHYWRkcmVzcwUMc3Rha2VkUGllY2VzBQNuaWwFDHN0YWtlZFBpZWNlcwFpAQ1zZXRDdXN0b21OYW1lAwdhc3NldElkCmN1c3RvbU5hbWUEdHlwZQQMcHJvbG9nQWN0aW9uCQEGcHJvbG9nAQUBaQMJAQIhPQIJAJADAQgFAWkIcGF5bWVudHMAAQkAAgECHEV4YWN0bHkgb25lIHBheW1lbnQgcmVxdWlyZWQEA3BtdAkBBXZhbHVlAQkAkQMCCAUBaQhwYXltZW50cwAAAwkBAiE9AggFA3BtdAdhc3NldElkBQt1c2R0QXNzZXRJZAkAAgECGkFsbG93ZWQgVVNEVCBwYXltZW50IG9ubHkhAwkBAiE9AggFA3BtdAZhbW91bnQFDFJFTkFNSU5HQ09TVAkAAgEJAKwCAgISUGF5bWVudCBzaG91bGQgYmUgCQCkAwEFDFJFTkFNSU5HQ09TVAMJAQhjb250YWlucwIFCmN1c3RvbU5hbWUCAl9fCQACAQkArAICAh5OYW1lIHNob3VsZCBub3QgY29udGFpbiAnX18nOiAFCmN1c3RvbU5hbWUDCQBmAgkAsQIBBQpjdXN0b21OYW1lBQpNQVhOQU1FTEVOCQACAQkArAICAhlOYW1lIHRvbyBsb25nLCBtYXhMZW5ndGg9CQCkAwEFCk1BWE5BTUVMRU4EBGFkZHIJAKUIAQgFAWkMb3JpZ2luQ2FsbGVyBAdhY3Rpb25zBAckbWF0Y2gwBQR0eXBlAwkAAAICB0FDQ09VTlQFByRtYXRjaDAECnJldmVyc2VLZXkJARZrZXlDdXN0b21OYW1lVG9BZGRyZXNzAQUKY3VzdG9tTmFtZQQJbmFtZU93bmVyCQCiCAEFCnJldmVyc2VLZXkDCQEJaXNEZWZpbmVkAQUJbmFtZU93bmVyCQACAQkArAICAhlOYW1lIGFscmVhZHkgcmVnaXN0ZXJlZDogBQpjdXN0b21OYW1lBA1hZGRyVG9OYW1lS2V5CQEWa2V5QWRkcmVzc1RvQ3VzdG9tTmFtZQEFBGFkZHIEB29sZE5hbWUJAKIIAQUNYWRkclRvTmFtZUtleQQHZnJlZU9sZAMJAQlpc0RlZmluZWQBBQdvbGROYW1lCQDMCAIJAQtEZWxldGVFbnRyeQEJARZrZXlDdXN0b21OYW1lVG9BZGRyZXNzAQkBBXZhbHVlAQUHb2xkTmFtZQUDbmlsBQNuaWwJAM4IAgkAzQgCCQDNCAIFB2ZyZWVPbGQJAQtTdHJpbmdFbnRyeQIFDWFkZHJUb05hbWVLZXkFCmN1c3RvbU5hbWUJAQtTdHJpbmdFbnRyeQIFCnJldmVyc2VLZXkFBGFkZHIICQEWdXBkYXRlQWNjU3RhdHNJbnRlcm5hbAIFBGFkZHIFDHhwQ3VzdG9tTmFtZQJfMQMJAAACAgRMQU5EBQckbWF0Y2gwBAVhc3NldAkBBXZhbHVlAQkA7AcBCQDZBAEFB2Fzc2V0SWQEB3RpbWVLZXkJARZrZXlTdGFrZWRUaW1lQnlBc3NldElkAQUHYXNzZXRJZAMJAQEhAQkBCWlzRGVmaW5lZAEJAJ8IAQUHdGltZUtleQkAAgEJAKwCAggFBWFzc2V0BG5hbWUCDiBpcyBub3Qgc3Rha2VkBAVvd25lcgkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCiCAEJARVrZXlMYW5kQXNzZXRJZFRvT3duZXIBBQdhc3NldElkCQCsAgIJAKwCAgIETkZUIAgFBWFzc2V0BG5hbWUCDCBpcyBvcnBoYW5lZAMJAQIhPQIFBW93bmVyBQRhZGRyCQACAQkArAICBQpMQU5EUFJFRklYAg0gaXMgbm90IHlvdXJzBApyZXZlcnNlS2V5CQEaa2V5TGFuZEN1c3RvbU5hbWVUb0Fzc2V0SWQBBQpjdXN0b21OYW1lBAluYW1lT3duZXIJAKIIAQUKcmV2ZXJzZUtleQMJAQlpc0RlZmluZWQBBQluYW1lT3duZXIJAAIBCQCsAgICGU5hbWUgYWxyZWFkeSByZWdpc3RlcmVkOiAFCmN1c3RvbU5hbWUEDmFzc2V0VG9OYW1lS2V5CQEaa2V5TGFuZEFzc2V0SWRUb0N1c3RvbU5hbWUBBQdhc3NldElkBAdvbGROYW1lCQCiCAEFDmFzc2V0VG9OYW1lS2V5BAdmcmVlT2xkAwkBCWlzRGVmaW5lZAEFB29sZE5hbWUJAMwIAgkBC0RlbGV0ZUVudHJ5AQkBGmtleUxhbmRDdXN0b21OYW1lVG9Bc3NldElkAQkBBXZhbHVlAQUHb2xkTmFtZQUDbmlsBQNuaWwJAM4IAgkAzQgCCQDNCAIFB2ZyZWVPbGQJAQtTdHJpbmdFbnRyeQIFDmFzc2V0VG9OYW1lS2V5BQpjdXN0b21OYW1lCQELU3RyaW5nRW50cnkCBQpyZXZlcnNlS2V5BQdhc3NldElkCAkBFnVwZGF0ZUFjY1N0YXRzSW50ZXJuYWwCBQRhZGRyBQx4cEN1c3RvbU5hbWUCXzEDCQAAAgIERFVDSwUHJG1hdGNoMAQFYXNzZXQJAQV2YWx1ZQEJAOwHAQkA2QQBBQdhc3NldElkBAd0aW1lS2V5CQEWa2V5U3Rha2VkVGltZUJ5QXNzZXRJZAEFB2Fzc2V0SWQDAwkBASEBCQEJaXNEZWZpbmVkAQkAnwgBBQd0aW1lS2V5BgkBASEBCQEJaXNEZWZpbmVkAQkAoggBCQEUa2V5U3Rha2VkRHVja0J5T3duZXIBBQRhZGRyCQACAQkArAICCAUFYXNzZXQEbmFtZQIOIGlzIG5vdCBzdGFrZWQEBW93bmVyCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAKIIAQkBEGtleUR1Y2tJZFRvT3duZXIBBQdhc3NldElkCQCsAgIJAKwCAgIETkZUIAgFBWFzc2V0BG5hbWUCDCBpcyBvcnBoYW5lZAMJAQIhPQIFBW93bmVyBQRhZGRyCQACAQkArAICBQpEVUNLUFJFRklYAg0gaXMgbm90IHlvdXJzBApyZXZlcnNlS2V5CQEaa2V5RHVja0N1c3RvbU5hbWVUb0Fzc2V0SWQBBQpjdXN0b21OYW1lBAluYW1lT3duZXIJAKIIAQUKcmV2ZXJzZUtleQMJAQlpc0RlZmluZWQBBQluYW1lT3duZXIJAAIBCQCsAgICGU5hbWUgYWxyZWFkeSByZWdpc3RlcmVkOiAFCmN1c3RvbU5hbWUEDmFzc2V0VG9OYW1lS2V5CQEaa2V5RHVja0Fzc2V0SWRUb0N1c3RvbU5hbWUBBQdhc3NldElkBAdvbGROYW1lCQCiCAEFDmFzc2V0VG9OYW1lS2V5BAdmcmVlT2xkAwkBCWlzRGVmaW5lZAEFB29sZE5hbWUJAMwIAgkBC0RlbGV0ZUVudHJ5AQkBGmtleUR1Y2tDdXN0b21OYW1lVG9Bc3NldElkAQkBBXZhbHVlAQUHb2xkTmFtZQUDbmlsBQNuaWwJAM4IAgkAzQgCCQDNCAIFB2ZyZWVPbGQJAQtTdHJpbmdFbnRyeQIFDmFzc2V0VG9OYW1lS2V5BQpjdXN0b21OYW1lCQELU3RyaW5nRW50cnkCBQpyZXZlcnNlS2V5BQdhc3NldElkCAkBF3VwZGF0ZUR1Y2tTdGF0c0ludGVybmFsAgUHYXNzZXRJZAUMeHBDdXN0b21OYW1lAl8xCQACAQITVW5rbm93biBlbnRpdHkgdHlwZQkAlAoCCQDNCAIJAM0IAgUHYWN0aW9ucwkBDlNjcmlwdFRyYW5zZmVyAwUPZWNvbm9teUNvbnRyYWN0CAUDcG10BmFtb3VudAULdXNkdEFzc2V0SWQFDHByb2xvZ0FjdGlvbgAAAWkBDHNldFJlZmVycmFscwIJb2xkUGxheWVyCW5ld1BsYXllcgMJAQIhPQIIBQFpD2NhbGxlclB1YmxpY0tleQUDcHViCQACAQIRUGVybWlzc2lvbiBkZW5pZWQEDHByb2xvZ0FjdGlvbgkBBnByb2xvZwEFAWkDCQECIT0CCQCQAwEIBQFpCHBheW1lbnRzAAAJAAIBAhRObyBwYXltZW50cyByZXF1aXJlZAMJAQEhAQkBCWlzRGVmaW5lZAEJAKYIAQUJb2xkUGxheWVyCQACAQkArAICAhFJbnZhbGlkIGFkZHJlc3M6IAUJb2xkUGxheWVyAwkBASEBCQEJaXNEZWZpbmVkAQkApggBBQluZXdQbGF5ZXIJAAIBCQCsAgICEUludmFsaWQgYWRkcmVzczogBQluZXdQbGF5ZXIEB29sZHNLZXkJAQlrZXlPbGRpZXMABARvbGRzCQCiCAEFB29sZHNLZXkEBm9sZGllcwMJAQlpc0RlZmluZWQBBQRvbGRzCQC8CQIJAQV2YWx1ZQEFBG9sZHMCAV8FA25pbAMJAQ9jb250YWluc0VsZW1lbnQCBQZvbGRpZXMFCW5ld1BsYXllcgkAAgEJAKwCAgUJbmV3UGxheWVyAiYgaXMgbm90IG5ld2JpZSAoYWxyZWFkeSBoYXMgcmVmZXJyYWxzKQQIcmVmQnlLZXkJAQ9rZXlBZGRyZXNzUmVmQnkBBQluZXdQbGF5ZXIEBXJlZkJ5CQCiCAEFCHJlZkJ5S2V5AwMJAQlpc0RlZmluZWQBBQVyZWZCeQkBCWlzRGVmaW5lZAEJAKYIAQkBBXZhbHVlAQUFcmVmQnkHCQACAQkArAICCQCsAgIFCW5ld1BsYXllcgIUIGFscmVhZHkgaGFzIHJlZkJ5OiAJAQV2YWx1ZQEFBXJlZkJ5BAdyZWZzS2V5CQETa2V5QWRkcmVzc1JlZmVycmFscwEFCW9sZFBsYXllcgQEcmVmcwkAoggBBQdyZWZzS2V5BAlyZWZzQXJyYXkDCQEJaXNEZWZpbmVkAQUEcmVmcwkAvAkCCQEFdmFsdWUBBQRyZWZzAgFfBQNuaWwDCQEPY29udGFpbnNFbGVtZW50AgUJcmVmc0FycmF5BQluZXdQbGF5ZXIJAAIBCQCsAgIJAKwCAgkArAICBQlvbGRQbGF5ZXICEiBhbHJlYWR5IGNvbnRhaW5zIAUJbmV3UGxheWVyAhEgd2l0aGluIHJlZmVycmFscwQHbmV3UmVmcwkAugkCCQDNCAIFCXJlZnNBcnJheQUJbmV3UGxheWVyAgFfBAduZXdPbGRzAwkBD2NvbnRhaW5zRWxlbWVudAIFBm9sZGllcwUJb2xkUGxheWVyCQEFdmFsdWUBBQRvbGRzCQC6CQIJAM0IAgUGb2xkaWVzBQlvbGRQbGF5ZXICAV8JAJQKAgkAzAgCCQELU3RyaW5nRW50cnkCBQhyZWZCeUtleQUJb2xkUGxheWVyCQDMCAIJAQtTdHJpbmdFbnRyeQIFB3JlZnNLZXkFB25ld1JlZnMJAMwIAgkBC1N0cmluZ0VudHJ5AgUHb2xkc0tleQUHbmV3T2xkcwkAzAgCBQxwcm9sb2dBY3Rpb24FA25pbAAAAWkBEGRpc3RyaWJ1dGVQb2ludHMFCHN0cmVuZ3RoCGFjY3VyYWN5CWludGVsbGVjdAllbmR1cmFuY2UJZGV4dGVyaXR5BAxwcm9sb2dBY3Rpb24JAQZwcm9sb2cBBQFpAwkBAiE9AgkAkAMBCAUBaQhwYXltZW50cwAACQACAQIUTm8gcGF5bWVudHMgcmVxdWlyZWQEBGFkZHIJAKUIAQgFAWkMb3JpZ2luQ2FsbGVyBAtkdWNrQXNzZXRJZAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCiCAEJARRrZXlTdGFrZWREdWNrQnlPd25lcgEFBGFkZHICHFlvdSBkb24ndCBoYXZlIGEgZHVjayBzdGFrZWQECmZyZWVLZXlBY2MJARFrZXlVc2VyRnJlZVBvaW50cwEFBGFkZHIEDWZyZWVQb2ludHNBY2MJAQt2YWx1ZU9yRWxzZQIJAJoIAgUPc3Rha2luZ0NvbnRyYWN0BQpmcmVlS2V5QWNjAAAEC2ZyZWVLZXlEdWNrCQERa2V5RHVja0ZyZWVQb2ludHMBBQtkdWNrQXNzZXRJZAQOZnJlZVBvaW50c0R1Y2sJAQt2YWx1ZU9yRWxzZQIJAJoIAgUPc3Rha2luZ0NvbnRyYWN0BQtmcmVlS2V5RHVjawAABAdzdW1GcmVlCQBkAgUNZnJlZVBvaW50c0FjYwUOZnJlZVBvaW50c0R1Y2sED3N1bVRvRGlzdHJpYnV0ZQkAZAIJAGQCCQBkAgkAZAIFCHN0cmVuZ3RoBQhhY2N1cmFjeQUJaW50ZWxsZWN0BQllbmR1cmFuY2UFCWRleHRlcml0eQMJAGYCBQ9zdW1Ub0Rpc3RyaWJ1dGUFB3N1bUZyZWUJAAIBCQCsAgIJAKwCAgIPVGhlcmUgYXJlIG9ubHkgCQCkAwEFB3N1bUZyZWUCGiBmcmVlIHBvaW50cyB0byBkaXN0cmlidXRlBAhjaGFyc0tleQkBDGtleUR1Y2tDaGFycwEFC2R1Y2tBc3NldElkBAVjaGFycwkAtQkCCQELdmFsdWVPckVsc2UCCQCdCAIFD3N0YWtpbmdDb250cmFjdAUIY2hhcnNLZXkCCTBfMF8wXzBfMAIBXwQGbmV3QWNjCQBlAgUNZnJlZVBvaW50c0FjYwUPc3VtVG9EaXN0cmlidXRlCQCUCgIJAMwIAgkBDEludGVnZXJFbnRyeQIFCmZyZWVLZXlBY2MDCQBmAgAABQZuZXdBY2MAAAUGbmV3QWNjCQDMCAIJAQxJbnRlZ2VyRW50cnkCBQtmcmVlS2V5RHVjawMJAGYCAAAFBm5ld0FjYwkAZAIFDmZyZWVQb2ludHNEdWNrBQZuZXdBY2MFDmZyZWVQb2ludHNEdWNrCQDMCAIJAQtTdHJpbmdFbnRyeQIFCGNoYXJzS2V5CQC5CQIJAMwIAgkApAMBCQBkAgkBDXBhcnNlSW50VmFsdWUBCQCRAwIFBWNoYXJzBQxjaGFyU3RyZW5ndGgFCHN0cmVuZ3RoCQDMCAIJAKQDAQkAZAIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQVjaGFycwUMY2hhckFjY3VyYWN5BQhhY2N1cmFjeQkAzAgCCQCkAwEJAGQCCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUFY2hhcnMFDWNoYXJJbnRlbGxlY3QFCWludGVsbGVjdAkAzAgCCQCkAwEJAGQCCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUFY2hhcnMFDWNoYXJFbmR1cmFuY2UFCWVuZHVyYW5jZQkAzAgCCQCkAwEJAGQCCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUFY2hhcnMFDWNoYXJEZXh0ZXJpdHkFCWRleHRlcml0eQUDbmlsAgFfCQDMCAIFDHByb2xvZ0FjdGlvbgUDbmlsAAABaQEcc3BsaXRCeUdsb2JhbFdlaWdodHNSRUFET05MWQEGYW1vdW50CQCUCgIFA25pbAkBEmdldE5lZWRlZE1hdGVyaWFscwEFBmFtb3VudAFpASRzcGxpdEJ5R2xvYmFsQW5kTG9jYWxXZWlnaHRzUkVBRE9OTFkDCW1hdEFtb3VudAlyZXNBbW91bnQIdGVycmFpbnMEDXRlcnJhaW5Db3VudHMJAQ1jb3VudFRlcnJhaW5zAQUIdGVycmFpbnMJAJQKAgUDbmlsCQCUCgIJARJnZXROZWVkZWRNYXRlcmlhbHMBBQltYXRBbW91bnQJARNkaXN0cmlidXRlQnlXZWlnaHRzAgUJcmVzQW1vdW50BQ10ZXJyYWluQ291bnRzAWkBE2dldEJhY2twYWNrUkVBRE9OTFkBC2R1Y2tBc3NldElkCQCUCgIFA25pbAkAuQkCCQELZ2V0QmFja3BhY2sBCQERa2V5QmFja3BhY2tCeUR1Y2sBBQtkdWNrQXNzZXRJZAIBOgFpARRnZXRXYXJlaG91c2VSRUFET05MWQELbGFuZEFzc2V0SWQEBWFzc2V0CQEFdmFsdWUBCQDsBwEJANkEAQULbGFuZEFzc2V0SWQECWxhbmRJbmRleAkAaQIJAQ9udW1QaWVjZXNCeVNpemUBCQCRAwIJALUJAggFBWFzc2V0C2Rlc2NyaXB0aW9uAgFfBQtyZWNMYW5kU2l6ZQUFU1NJWkUECmluZnJhTGV2ZWwJAQt2YWx1ZU9yRWxzZQIJAJ8IAQkBFmtleUluZnJhTGV2ZWxCeUFzc2V0SWQBBQtsYW5kQXNzZXRJZAAACQCUCgIFA25pbAkAugkCCQEMZ2V0V2FyZWhvdXNlAwkBEmtleVdhcmVob3VzZUJ5TGFuZAEFC2xhbmRBc3NldElkBQlsYW5kSW5kZXgFCmluZnJhTGV2ZWwCAToBaQEKc2F2ZUxhc3RUeAADAwkBAiE9AggFAWkGY2FsbGVyBQt3bGdDb250cmFjdAkBAiE9AggFAWkGY2FsbGVyBQ9lY29ub215Q29udHJhY3QHCQACAQINQWNjZXNzIGRlbmllZAkAlAoCCQDMCAIJAQZwcm9sb2cBBQFpBQNuaWwAKgFpAQ91cGRhdGVEdWNrU3RhdHMCC2R1Y2tBc3NldElkB2RlbHRhWFADCQECIT0CCAUBaQZjYWxsZXIFD2Vjb25vbXlDb250cmFjdAkAAgECDUFjY2VzcyBkZW5pZWQJARd1cGRhdGVEdWNrU3RhdHNJbnRlcm5hbAIFC2R1Y2tBc3NldElkBQdkZWx0YVhQAWkBDnVwZGF0ZUFjY1N0YXRzAgRhZGRyB2RlbHRhWFADCQECIT0CCAUBaQZjYWxsZXIFD2Vjb25vbXlDb250cmFjdAkAAgECDUFjY2VzcyBkZW5pZWQJARZ1cGRhdGVBY2NTdGF0c0ludGVybmFsAgUEYWRkcgUHZGVsdGFYUABlUX96",
    "height": 2662772,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 4eRjkh2Nm7d2njTXmhbT9TWycuBhb8mWqAJrYiZqqnCN
Next: AKrYaZYNJbYnuPbEEjVYPpgbZRhyA2ZSsLRF8qfVQqVJ

Diff: 
Old
New
Differences
96
96
 
97
97
 
let V = ["Americas", "Europe", "Asia", "Africa", "Oceania"]
98
98
 
99
-
let W = ["1_1_1_2_2_5_1_10_0", "2_2_2_4_4_10_1_10_0", "3_3_3_6_6_15_1_10_0", "2_5_5_2_7_5_2_25_1", "4_10_10_4_14_10_2_25_1", "6_15_15_6_21_15_2_25_1", "1_1_1_1_1_8_1_10_2", "2_2_2_2_2_16_1_10_2", "3_3_3_3_3_24_1_10_2", "9_9_1_5_5_1_5_30_3", "18_18_2_10_10_2_5_30_3", "27_27_3_15_15_3_5_30_3", "2_2_1_2_2_2_1_10_4", "4_4_2_4_4_4_1_10_4", "6_6_3_6_6_6_1_10_4"]
100
-
101
-
let X = 7
102
-
103
-
let Y = 0
104
-
105
-
let Z = 1
106
-
107
-
let aa = 2
108
-
109
-
let ab = 3
110
-
111
-
let ac = 4
112
-
113
-
let ad = 0
114
-
115
-
let ae = 1
116
-
117
-
let af = 2
118
-
119
-
let ag = 3
120
-
121
-
let ah = 0
122
-
123
-
let ai = 1
124
-
125
-
let aj = 2
126
-
127
-
let ak = 3
128
-
129
-
func al (am) = parseIntValue(split(W[am], "_")[X])
130
-
131
-
132
-
func an (p) = ("lastTxIdByUser_" + p)
133
-
134
-
135
-
func ao (ap) = ("nftOwner_" + ap)
136
-
137
-
138
-
func aq (ap) = ("landCustomNameByAssetId_" + ap)
139
-
140
-
141
-
func ar (ap) = ("stakedTime_" + ap)
142
-
143
-
144
-
func as (ap) = ("infraLevel_" + ap)
145
-
146
-
147
-
func at (au,ap) = makeString(["landArtStatus", au, ap], "_")
148
-
149
-
150
-
func av (aw,ap,ax) = ((((("stakedTimeByTypeAssetIdAndOwner_" + aw) + "_") + ap) + "_") + ax)
151
-
152
-
153
-
func ay (az) = ("wareHouse_" + az)
154
-
155
-
156
-
func aA (ap) = ("duckCustomNameByAssetId_" + ap)
157
-
158
-
159
-
func aB (p) = ("accountCustomNameByAddr_" + p)
160
-
161
-
162
-
func aC (p) = ("accRefBy_" + p)
163
-
164
-
165
-
func aD (k) = ("onboardArtActivatedOnDuck_" + k)
166
-
167
-
168
-
func aE (p) = ("onboardArtActivatedDuckBy_" + p)
169
-
170
-
171
-
func aF (p) = ("accReferrals_" + p)
172
-
173
-
174
-
func aG (ap) = ("duckOwner_" + ap)
175
-
176
-
177
-
func aH (ax) = ("stakedDuckByOwner_" + ax)
178
-
179
-
180
-
func aI (k) = ("backPack_" + k)
181
-
182
-
183
-
func aJ (k) = ("duckLocation_" + k)
184
-
185
-
186
-
func aK (k) = ("duckHealth_" + k)
187
-
188
-
189
-
func aL () = "contractsBlocked"
190
-
191
-
192
-
func aM (aN) = ("%s%s__userGwlReleaseTime__" + aN)
193
-
194
-
195
-
func aO () = "emergencyWarehouseProducts"
196
-
197
-
198
-
let aP = 1
199
-
200
-
let aQ = 2
201
-
202
-
func aR (aS) = {
203
-
    func aT (aU,aV) =     (aU + parseIntValue(aS[aV]))
204
-
205
-
    let aW = [0, 1, 2, 3, 4, 5]
206
-
    let aX = size(aW)
207
-
    let aY = 0
208
-
    func aZ (ba,bb) =     if ((bb >= aX))
209
-
        then ba
210
-
        else aT(ba, aW[bb])
211
-
212
-
    func bc (ba,bb) =     if ((bb >= aX))
213
-
        then ba
214
-
        else throw("List size exceeds 6")
215
-
216
-
    bc(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6)
217
-
    }
218
-
219
-
220
-
let bd = true
221
-
222
-
let be = take(drop(this.bytes, 1), 1)
223
-
224
-
let bf = {
225
-
    let bg = be
226
-
    if ((base58'2W' == bg))
99
+
let W = ["8_8_8_17_17_42_12_0", "8_8_8_17_17_42_24_0", "8_8_8_17_17_42_36_0", "8_19_19_8_27_19_26_1", "8_19_19_8_27_19_52_1", "8_19_19_8_27_19_78_1", "8_8_8_8_8_60_13_2", "8_8_8_8_8_60_26_2", "8_8_8_8_8_60_39_2", "30_30_3_17_17_3_30_3", "30_30_3_17_17_3_60_3", "30_30_3_17_17_3_90_3", "18_18_10_18_18_18_11_4", "18_18_10_18_18_18_22_4", "18_18_10_18_18_18_33_4"]
100
+
101
+
let X = 6
102
+
103
+
let Y = 10
104
+
105
+
let Z = 0
106
+
107
+
let aa = 1
108
+
109
+
let ab = 2
110
+
111
+
let ac = 3
112
+
113
+
let ad = 4
114
+
115
+
let ae = 0
116
+
117
+
let af = 1
118
+
119
+
let ag = 2
120
+
121
+
let ah = 3
122
+
123
+
let ai = 0
124
+
125
+
let aj = 1
126
+
127
+
let ak = 2
128
+
129
+
let al = 3
130
+
131
+
func am (p) = ("lastTxIdByUser_" + p)
132
+
133
+
134
+
func an (ao) = ("nftOwner_" + ao)
135
+
136
+
137
+
func ap (ao) = ("landCustomNameByAssetId_" + ao)
138
+
139
+
140
+
func aq (ao) = ("stakedTime_" + ao)
141
+
142
+
143
+
func ar (ao) = ("infraLevel_" + ao)
144
+
145
+
146
+
func as (at,ao) = makeString(["landArtStatus", at, ao], "_")
147
+
148
+
149
+
func au (av,ao,aw) = ((((("stakedTimeByTypeAssetIdAndOwner_" + av) + "_") + ao) + "_") + aw)
150
+
151
+
152
+
func ax (ay) = ("wareHouse_" + ay)
153
+
154
+
155
+
func az (ao) = ("duckCustomNameByAssetId_" + ao)
156
+
157
+
158
+
func aA (p) = ("accountCustomNameByAddr_" + p)
159
+
160
+
161
+
func aB (p) = ("accRefBy_" + p)
162
+
163
+
164
+
func aC (k) = ("onboardArtActivatedOnDuck_" + k)
165
+
166
+
167
+
func aD (p) = ("onboardArtActivatedDuckBy_" + p)
168
+
169
+
170
+
func aE (p) = ("accReferrals_" + p)
171
+
172
+
173
+
func aF (ao) = ("duckOwner_" + ao)
174
+
175
+
176
+
func aG (aw) = ("stakedDuckByOwner_" + aw)
177
+
178
+
179
+
func aH (k) = ("backPack_" + k)
180
+
181
+
182
+
func aI (k) = ("duckLocation_" + k)
183
+
184
+
185
+
func aJ (k) = ("duckHealth_" + k)
186
+
187
+
188
+
func aK () = "contractsBlocked"
189
+
190
+
191
+
func aL (aM) = ("%s%s__userGwlReleaseTime__" + aM)
192
+
193
+
194
+
func aN () = "emergencyWarehouseProducts"
195
+
196
+
197
+
let aO = 1
198
+
199
+
let aP = 2
200
+
201
+
func aQ (aR) = parseIntValue(aR[X])
202
+
203
+
204
+
let aS = true
205
+
206
+
let aT = take(drop(this.bytes, 1), 1)
207
+
208
+
let aU = {
209
+
    let aV = aT
210
+
    if ((base58'2W' == aV))
227
211
 
        then base58'9wc3LXNA4TEBsXyKtoLE9mrbDD7WMHXvXrCjZvabLAsi'
228
-
        else if ((base58'2T' == bg))
212
+
        else if ((base58'2T' == aV))
229
213
 
            then base58'6mWwf9mZBjVgkC54idpyaZLQfAosD914wT8fGf2iiY63'
230
214
 
            else throw("Unknown chain")
231
215
 
    }
232
216
 
233
-
let bh = {
234
-
    let bg = be
235
-
    if ((base58'2W' == bg))
217
+
let aW = {
218
+
    let aV = aT
219
+
    if ((base58'2W' == aV))
236
220
 
        then "3PQCuvFbvh4LkPUnrnU1z3jnbA1p9m3WNhv"
237
-
        else if ((base58'2T' == bg))
221
+
        else if ((base58'2T' == aV))
238
222
 
            then "3MumkGGztCKAXpWDqxkddofqXSUbqQkvSJy"
239
223
 
            else throw("Unknown chain")
240
224
 
    }
241
225
 
242
-
let bi = {
243
-
    let bg = be
244
-
    if ((base58'2W' == bg))
226
+
let aX = {
227
+
    let aV = aT
228
+
    if ((base58'2W' == aV))
245
229
 
        then 10000000000
246
-
        else if ((base58'2T' == bg))
230
+
        else if ((base58'2T' == aV))
247
231
 
            then 100000000
248
232
 
            else throw("Unknown chain")
249
233
 
    }
250
234
 
251
-
let bj = "__"
252
-
253
-
let bk = 1000000
254
-
255
-
let bl = 100000000
256
-
257
-
let bm = 25
258
-
259
-
let bn = 100
260
-
261
-
let bo = 225
262
-
263
-
let bp = 400
264
-
265
-
let bq = 625
266
-
267
-
func br (bs,bt) = valueOrErrorMessage(getString(bs, bt), makeString(["mandatory ", toString(bs), ".", bt, " is not defined"], ""))
268
-
269
-
270
-
let bu = 1
271
-
272
-
let bv = 2
273
-
274
-
let bw = 3
275
-
276
-
let bx = 4
277
-
278
-
func by () = "%s__restConfig"
279
-
280
-
281
-
func bz () = "%s__restAddr"
282
-
283
-
284
-
func bA (bB) = split_4C(br(bB, by()), bj)
285
-
286
-
287
-
func bC (bD,bE) = valueOrErrorMessage(addressFromString(bD[bE]), ("Rest cfg doesn't contain address at index " + toString(bE)))
288
-
289
-
290
-
let bF = addressFromStringValue(valueOrElse(getString(this, bz()), bh))
291
-
292
-
let bD = bA(bF)
293
-
294
-
let bG = bC(bD, bu)
295
-
296
-
let bH = bC(bD, bv)
297
-
298
-
let bI = bC(bD, bw)
299
-
300
-
let bJ = bC(bD, bx)
301
-
302
-
let bK = 0
303
-
304
-
let bL = 1
305
-
306
-
let bM = 2
307
-
308
-
let bN = 3
309
-
310
-
func bO () = "resTypesProportions"
311
-
312
-
313
-
func bP (ax) = ("stakedLandsByOwner_" + ax)
314
-
315
-
316
-
func bQ (ax) = ("stakedPiecesByOwner_" + ax)
317
-
318
-
319
-
func bR (bS) = {
320
-
    let bg = bS
321
-
    if ($isInstanceOf(bg, "String"))
235
+
let aY = "__"
236
+
237
+
let aZ = 1000000
238
+
239
+
let ba = 100000000
240
+
241
+
let bb = 25
242
+
243
+
let bc = 100
244
+
245
+
let bd = 225
246
+
247
+
let be = 400
248
+
249
+
let bf = 625
250
+
251
+
func bg (bh,bi) = valueOrErrorMessage(getString(bh, bi), makeString(["mandatory ", toString(bh), ".", bi, " is not defined"], ""))
252
+
253
+
254
+
let bj = 1
255
+
256
+
let bk = 2
257
+
258
+
let bl = 3
259
+
260
+
let bm = 4
261
+
262
+
func bn () = "%s__restConfig"
263
+
264
+
265
+
func bo () = "%s__restAddr"
266
+
267
+
268
+
func bp (bq) = split_4C(bg(bq, bn()), aY)
269
+
270
+
271
+
func br (bs,bt) = valueOrErrorMessage(addressFromString(bs[bt]), ("Rest cfg doesn't contain address at index " + toString(bt)))
272
+
273
+
274
+
let bu = addressFromStringValue(valueOrElse(getString(this, bo()), aW))
275
+
276
+
let bs = bp(bu)
277
+
278
+
let bv = br(bs, bj)
279
+
280
+
let bw = br(bs, bk)
281
+
282
+
let bx = br(bs, bl)
283
+
284
+
let by = br(bs, bm)
285
+
286
+
let bz = 0
287
+
288
+
let bA = 1
289
+
290
+
let bB = 2
291
+
292
+
let bC = 3
293
+
294
+
func bD () = "resTypesProportions"
295
+
296
+
297
+
func bE (aw) = ("stakedLandsByOwner_" + aw)
298
+
299
+
300
+
func bF (aw) = ("stakedPiecesByOwner_" + aw)
301
+
302
+
303
+
func bG (bH) = {
304
+
    let aV = bH
305
+
    if ($isInstanceOf(aV, "String"))
322
306
 
        then {
323
-
            let bT = bg
324
-
            bT
307
+
            let bI = aV
308
+
            bI
325
309
 
            }
326
310
 
        else throw("fail to cast into String")
327
311
 
    }
328
312
 
329
313
 
330
-
func bU (bS) = {
331
-
    let bg = bS
332
-
    if ($isInstanceOf(bg, "Int"))
314
+
func bJ (bH) = {
315
+
    let aV = bH
316
+
    if ($isInstanceOf(aV, "Int"))
333
317
 
        then {
334
-
            let bV = bg
335
-
            bV
318
+
            let bK = aV
319
+
            bK
336
320
 
            }
337
321
 
        else throw("fail to cast into Int")
338
322
 
    }
339
323
 
340
324
 
341
-
func bW (bX) = {
342
-
    let bg = bX
343
-
    if (("S" == bg))
344
-
        then bm
345
-
        else if (("M" == bg))
346
-
            then bn
347
-
            else if (("L" == bg))
348
-
                then bo
349
-
                else if (("XL" == bg))
350
-
                    then bp
351
-
                    else if (("XXL" == bg))
352
-
                        then bq
325
+
func bL (bM) = {
326
+
    let aV = bM
327
+
    if (("S" == aV))
328
+
        then bb
329
+
        else if (("M" == aV))
330
+
            then bc
331
+
            else if (("L" == aV))
332
+
                then bd
333
+
                else if (("XL" == aV))
334
+
                    then be
335
+
                    else if (("XXL" == aV))
336
+
                        then bf
353
337
 
                        else throw("Unknown land size")
354
338
 
    }
355
339
 
356
340
 
357
-
let bY = {
358
-
    let bg = be
359
-
    if ((base58'2W' == bg))
341
+
let bN = {
342
+
    let aV = aT
343
+
    if ((base58'2W' == aV))
360
344
 
        then addressFromStringValue("3PEktVux2RhchSN63DsDo4b4mz4QqzKSeDv")
361
-
        else if ((base58'2T' == bg))
345
+
        else if ((base58'2T' == aV))
362
346
 
            then this
363
347
 
            else throw("Unknown chain")
364
348
 
    }
365
349
 
366
-
let bZ = {
367
-
    let bg = be
368
-
    if ((base58'2W' == bg))
350
+
let bO = {
351
+
    let aV = aT
352
+
    if ((base58'2W' == aV))
369
353
 
        then addressFromStringValue("3PDVuU45H7Eh5dmtNbnRNRStGwULA7NY6Hb")
370
-
        else if ((base58'2T' == bg))
354
+
        else if ((base58'2T' == aV))
371
355
 
            then this
372
356
 
            else throw("Unknown chain")
373
357
 
    }
374
358
 
375
-
let ca = base58'6LfPuKJjLgekmncBhMg2LZyMTNVzZBccXR28ySXm9uXD'
376
-
377
-
let cb = [30, 60, 120]
378
-
379
-
let cc = 300000
380
-
381
-
let cd = 5000000
382
-
383
-
let ce = 50
384
-
385
-
let cf = 10000000
386
-
387
-
let cg = {
388
-
    let bg = be
389
-
    if ((base58'2W' == bg))
359
+
let bP = base58'6LfPuKJjLgekmncBhMg2LZyMTNVzZBccXR28ySXm9uXD'
360
+
361
+
let bQ = [30, 60, 120]
362
+
363
+
let bR = 300000
364
+
365
+
let bS = 5000000
366
+
367
+
let bT = 50
368
+
369
+
let bU = 10000000
370
+
371
+
let bV = {
372
+
    let aV = aT
373
+
    if ((base58'2W' == aV))
390
374
 
        then 252289527462
391
-
        else if ((base58'2T' == bg))
375
+
        else if ((base58'2T' == aV))
392
376
 
            then 2522895274
393
377
 
            else throw("Unknown chain")
394
378
 
    }
395
379
 
396
-
let ch = {
397
-
    let bg = be
398
-
    if ((base58'2W' == bg))
380
+
let bW = {
381
+
    let aV = aT
382
+
    if ((base58'2W' == aV))
399
383
 
        then 250000000
400
-
        else if ((base58'2T' == bg))
384
+
        else if ((base58'2T' == aV))
401
385
 
            then 250000000
402
386
 
            else throw("Unknown chain")
403
387
 
    }
404
388
 
405
-
let ci = toBigInt(5)
406
-
407
-
let cj = toBigInt(20)
408
-
409
-
let ck = toBigInt((20 * 20))
410
-
411
-
let cl = toBigInt(((20 * 20) * 20))
412
-
413
-
let cm = toBigInt((((20 * 20) * 20) * 20))
414
-
415
-
let cn = toBigInt(((((20 * 20) * 20) * 20) * 20))
416
-
417
-
let co = 500
418
-
419
-
func cp () = "nextLandNum"
420
-
421
-
422
-
func cq (cr) = ("landToAsset_" + cr)
423
-
424
-
425
-
func cs (ct) = ("landByCustomName_" + ct)
426
-
427
-
428
-
func cu (ap,ax) = ((("infraLevelByAssetIdAndOwner_" + ap) + "_") + ax)
429
-
430
-
431
-
func cv (au,ap,ax) = makeString(["landArtStatusByTypeAssetIdAndOwner", au, ap, ax], "_")
432
-
433
-
434
-
func cw (cr) = ("landOwner_" + cr)
435
-
436
-
437
-
func cx (ct) = ("duckByCustomName_" + ct)
438
-
439
-
440
-
func cy (ct) = ("accountByCustomName_" + ct)
441
-
442
-
443
-
func cz () = "oldiesList"
444
-
445
-
446
-
let cA = 0
447
-
448
-
let cB = 1
449
-
450
-
let cC = 2
451
-
452
-
let cD = 0
453
-
454
-
let cE = 5
455
-
456
-
let cF = 6
457
-
458
-
let cG = 7
459
-
460
-
func cH (cr,bX) = ((K + cr) + bX)
461
-
462
-
463
-
func cI (cJ,cK) = {
464
-
    let cL = (((((cK[0] + cK[1]) + cK[2]) + cK[3]) + cK[4]) + cK[5])
465
-
    if ((0 >= cL))
389
+
let bX = toBigInt(5)
390
+
391
+
let bY = toBigInt(20)
392
+
393
+
let bZ = toBigInt((20 * 20))
394
+
395
+
let ca = toBigInt(((20 * 20) * 20))
396
+
397
+
let cb = toBigInt((((20 * 20) * 20) * 20))
398
+
399
+
let cc = toBigInt(((((20 * 20) * 20) * 20) * 20))
400
+
401
+
let cd = 500
402
+
403
+
func ce () = "nextLandNum"
404
+
405
+
406
+
func cf (cg) = ("landToAsset_" + cg)
407
+
408
+
409
+
func ch (ci) = ("landByCustomName_" + ci)
410
+
411
+
412
+
func cj (ao,aw) = ((("infraLevelByAssetIdAndOwner_" + ao) + "_") + aw)
413
+
414
+
415
+
func ck (at,ao,aw) = makeString(["landArtStatusByTypeAssetIdAndOwner", at, ao, aw], "_")
416
+
417
+
418
+
func cl (cg) = ("landOwner_" + cg)
419
+
420
+
421
+
func cm (ci) = ("duckByCustomName_" + ci)
422
+
423
+
424
+
func cn (ci) = ("accountByCustomName_" + ci)
425
+
426
+
427
+
func co () = "oldiesList"
428
+
429
+
430
+
let cp = 0
431
+
432
+
let cq = 1
433
+
434
+
let cr = 2
435
+
436
+
let cs = 0
437
+
438
+
let ct = 5
439
+
440
+
let cu = 6
441
+
442
+
let cv = 7
443
+
444
+
func cw (cg,bM) = ((K + cg) + bM)
445
+
446
+
447
+
func cx (cy,cz) = {
448
+
    let cA = (((((cz[0] + cz[1]) + cz[2]) + cz[3]) + cz[4]) + cz[5])
449
+
    if ((0 >= cA))
466
450
 
        then throw("Zero weights sum")
467
451
 
        else {
468
-
            let cM = fraction(cJ, bk, cL)
469
-
            func cN (cO,cP) =             (cO :+ fraction(cP, cM, bk))
470
-
471
-
            let aW = cK
472
-
            let aX = size(aW)
473
-
            let aY = nil
474
-
            func aZ (ba,bb) =             if ((bb >= aX))
475
-
                then ba
476
-
                else cN(ba, aW[bb])
477
-
478
-
            func bc (ba,bb) =             if ((bb >= aX))
479
-
                then ba
452
+
            let cB = fraction(cy, aZ, cA)
453
+
            func cC (cD,cE) =             (cD :+ fraction(cE, cB, aZ))
454
+
455
+
            let cF = cz
456
+
            let cG = size(cF)
457
+
            let cH = nil
458
+
            func cI (cJ,cK) =             if ((cK >= cG))
459
+
                then cJ
460
+
                else cC(cJ, cF[cK])
461
+
462
+
            func cL (cJ,cK) =             if ((cK >= cG))
463
+
                then cJ
480
464
 
                else throw("List size exceeds 6")
481
465
 
482
-
            bc(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6)
483
-
            }
484
-
    }
485
-
486
-
487
-
func cQ (cJ) = {
488
-
    let cR = split(value(getString(bO())), "_")
489
-
    if ((size(cR) != N))
466
+
            cL(cI(cI(cI(cI(cI(cI(cH, 0), 1), 2), 3), 4), 5), 6)
467
+
            }
468
+
    }
469
+
470
+
471
+
func cM (cy) = {
472
+
    let cN = split(value(getString(bD())), "_")
473
+
    if ((size(cN) != N))
490
474
 
        then throw("Wrong proportions data")
491
475
 
        else {
492
-
            let cS = [parseIntValue(cR[0]), parseIntValue(cR[1]), parseIntValue(cR[2]), parseIntValue(cR[3]), parseIntValue(cR[4]), parseIntValue(cR[5])]
493
-
            cI(cJ, cS)
494
-
            }
495
-
    }
496
-
497
-
498
-
func cT (cU,cV,cW) = {
499
-
    let cX = cQ(cW)
500
-
    func cY (cO,bE) =     {
501
-
        let cZ = (parseIntValue(cV[bE]) - cX[bE])
502
-
        if ((0 > cZ))
503
-
            then throw(((((("Not enough material idx=" + toString(bE)) + ", you have ") + cV[bE]) + ", but need ") + toString(cX[bE])))
504
-
            else (cO :+ toString(cZ))
476
+
            let cO = [parseIntValue(cN[0]), parseIntValue(cN[1]), parseIntValue(cN[2]), parseIntValue(cN[3]), parseIntValue(cN[4]), parseIntValue(cN[5])]
477
+
            cx(cy, cO)
478
+
            }
479
+
    }
480
+
481
+
482
+
func cP (cQ,cR,cS) = {
483
+
    let cT = cM(cS)
484
+
    func cU (cD,bt) =     {
485
+
        let cV = (parseIntValue(cR[bt]) - cT[bt])
486
+
        if ((0 > cV))
487
+
            then throw(((((("Not enough material idx=" + toString(bt)) + ", you have ") + cR[bt]) + ", but need ") + toString(cT[bt])))
488
+
            else (cD :+ toString(cV))
505
489
 
        }
506
490
 
507
-
    if (cU)
491
+
    if (cQ)
508
492
 
        then {
509
-
            let aW = [0, 1, 2, 3, 4, 5]
510
-
            let aX = size(aW)
511
-
            let aY = nil
512
-
            func aZ (ba,bb) =             if ((bb >= aX))
513
-
                then ba
514
-
                else cY(ba, aW[bb])
515
-
516
-
            func bc (ba,bb) =             if ((bb >= aX))
517
-
                then ba
493
+
            let cF = [0, 1, 2, 3, 4, 5]
494
+
            let cG = size(cF)
495
+
            let cH = nil
496
+
            func cI (cJ,cK) =             if ((cK >= cG))
497
+
                then cJ
498
+
                else cU(cJ, cF[cK])
499
+
500
+
            func cL (cJ,cK) =             if ((cK >= cG))
501
+
                then cJ
518
502
 
                else throw("List size exceeds 6")
519
503
 
520
-
            bc(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6)
521
-
            }
522
-
        else cV
523
-
    }
524
-
525
-
526
-
func da (db,dc) = if ((dc == ""))
527
-
    then db
504
+
            cL(cI(cI(cI(cI(cI(cI(cH, 0), 1), 2), 3), 4), 5), 6)
505
+
            }
506
+
        else cR
507
+
    }
508
+
509
+
510
+
func cW (cX,cY) = if ((cY == ""))
511
+
    then cX
528
512
 
    else {
529
-
        let dd = if ((db == ""))
513
+
        let cZ = if ((cX == ""))
530
514
 
            then nil
531
-
            else split(db, "_")
532
-
        func de (cO,df) =         {
533
-
            let aV = cO._1
534
-
            func dg (aU,dh) =             {
535
-
                let di = split(dh, ",")
536
-
                if ((size(di) != 2))
515
+
            else split(cX, "_")
516
+
        func da (cD,db) =         {
517
+
            let dc = cD._1
518
+
            func dd (de,df) =             {
519
+
                let dg = split(df, ",")
520
+
                if ((size(dg) != 2))
537
521
 
                    then throw("Incorrect format, should be index,amount")
538
522
 
                    else {
539
-
                        let bE = parseIntValue(di[0])
540
-
                        if (if ((0 > bE))
523
+
                        let bt = parseIntValue(dg[0])
524
+
                        if (if ((0 > bt))
541
525
 
                            then true
542
-
                            else (bE >= size(W)))
526
+
                            else (bt >= size(W)))
543
527
 
                            then throw("Unknown product idx")
544
-
                            else if ((bE != aV))
545
-
                                then aU
528
+
                            else if ((bt != dc))
529
+
                                then de
546
530
 
                                else {
547
-
                                    let dj = parseIntValue(di[1])
548
-
                                    if ((0 >= dj))
531
+
                                    let dh = parseIntValue(dg[1])
532
+
                                    if ((0 >= dh))
549
533
 
                                        then throw("Pass only positive amounts")
550
-
                                        else (aU + dj)
534
+
                                        else (de + dh)
551
535
 
                                    }
552
536
 
                        }
553
537
 
                }
554
538
 
555
-
            let dk = {
556
-
                let aW = split(dc, "_")
557
-
                let aX = size(aW)
558
-
                let aY = 0
559
-
                func aZ (ba,bb) =                 if ((bb >= aX))
560
-
                    then ba
561
-
                    else dg(ba, aW[bb])
562
-
563
-
                func bc (ba,bb) =                 if ((bb >= aX))
564
-
                    then ba
539
+
            let di = {
540
+
                let cF = split(cY, "_")
541
+
                let cG = size(cF)
542
+
                let cH = 0
543
+
                func cI (cJ,cK) =                 if ((cK >= cG))
544
+
                    then cJ
545
+
                    else dd(cJ, cF[cK])
546
+
547
+
                func cL (cJ,cK) =                 if ((cK >= cG))
548
+
                    then cJ
565
549
 
                    else throw("List size exceeds 10")
566
550
 
567
-
                bc(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
551
+
                cL(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cH, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
568
552
 
                }
569
-
            let dl = if ((size(dd) > aV))
570
-
                then parseIntValue(dd[aV])
553
+
            let dj = if ((size(cZ) > dc))
554
+
                then parseIntValue(cZ[dc])
571
555
 
                else 0
572
-
            let dm = if ((dk > dl))
573
-
                then throw(((((("You have " + toString(dl)) + " of ") + U[aV]) + ", but tried to use ") + toString(dk)))
574
-
                else (dl - dk)
575
-
            $Tuple2((aV + 1), (cO._2 :+ toString(dm)))
576
-
            }
577
-
578
-
        let dn = {
579
-
            let aW = W
580
-
            let aX = size(aW)
581
-
            let aY = $Tuple2(0, nil)
582
-
            func aZ (ba,bb) =             if ((bb >= aX))
583
-
                then ba
584
-
                else de(ba, aW[bb])
585
-
586
-
            func bc (ba,bb) =             if ((bb >= aX))
587
-
                then ba
556
+
            let dk = if ((dj >= di))
557
+
                then (dj - di)
558
+
                else throw(((((("You have " + toString(dj)) + " of ") + U[dc]) + ", but tried to use ") + toString(di)))
559
+
            $Tuple2((dc + 1), (cD._2 :+ toString(dk)))
560
+
            }
561
+
562
+
        let dl = {
563
+
            let cF = W
564
+
            let cG = size(cF)
565
+
            let cH = $Tuple2(0, nil)
566
+
            func cI (cJ,cK) =             if ((cK >= cG))
567
+
                then cJ
568
+
                else da(cJ, cF[cK])
569
+
570
+
            func cL (cJ,cK) =             if ((cK >= cG))
571
+
                then cJ
588
572
 
                else throw("List size exceeds 50")
589
573
 
590
-
            bc(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aY, 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)
591
-
            }
592
-
        makeString(dn._2, "_")
574
+
            cL(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cH, 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)
575
+
            }
576
+
        makeString(dl._2, "_")
593
577
 
        }
594
578
 
595
579
 
596
-
func do (dp,dq,dr,ds) = if ((size(dp) != N))
580
+
func dm (dn,do,dp,dq) = if ((size(dn) != N))
597
581
 
    then throw("Wrong proportions data")
598
582
 
    else {
599
-
        func dt (cO,du) =         {
600
-
            let cZ = (parseIntValue(dp[du]) + ((ds * dq[du]) * dr))
601
-
            if ((0 > cZ))
602
-
                then throw(((((((("Panic! Pieces of type=" + toString(du)) + ", sign=") + toString(ds)) + ",  terrainCounts[i]=") + toString(dq[du])) + ", landSizeIndex=") + toString(dr)))
603
-
                else (cO :+ toString(cZ))
604
-
            }
605
-
606
-
        let cS = {
607
-
            let aW = [0, 1, 2, 3, 4, 5]
608
-
            let aX = size(aW)
609
-
            let aY = nil
610
-
            func aZ (ba,bb) =             if ((bb >= aX))
611
-
                then ba
612
-
                else dt(ba, aW[bb])
613
-
614
-
            func bc (ba,bb) =             if ((bb >= aX))
615
-
                then ba
583
+
        func dr (cD,ds) =         {
584
+
            let cV = (parseIntValue(dn[ds]) + ((dq * do[ds]) * dp))
585
+
            if ((0 > cV))
586
+
                then throw(((((((("Panic! Pieces of type=" + toString(ds)) + ", sign=") + toString(dq)) + ",  terrainCounts[i]=") + toString(do[ds])) + ", landSizeIndex=") + toString(dp)))
587
+
                else (cD :+ toString(cV))
588
+
            }
589
+
590
+
        let cO = {
591
+
            let cF = [0, 1, 2, 3, 4, 5]
592
+
            let cG = size(cF)
593
+
            let cH = nil
594
+
            func cI (cJ,cK) =             if ((cK >= cG))
595
+
                then cJ
596
+
                else dr(cJ, cF[cK])
597
+
598
+
            func cL (cJ,cK) =             if ((cK >= cG))
599
+
                then cJ
616
600
 
                else throw("List size exceeds 6")
617
601
 
618
-
            bc(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6)
619
-
            }
620
-
        makeString(cS, "_")
602
+
            cL(cI(cI(cI(cI(cI(cI(cH, 0), 1), 2), 3), 4), 5), 6)
603
+
            }
604
+
        makeString(cO, "_")
621
605
 
        }
622
606
 
623
607
 
624
-
func dv (dq,dr,ds) = {
625
-
    let dp = split(valueOrElse(getString(bO()), "0_0_0_0_0_0"), "_")
626
-
    do(dp, dq, dr, ds)
627
-
    }
628
-
629
-
630
-
func dw (dx) = [(size(split(dx, "A")) - 1), (size(split(dx, "B")) - 1), (size(split(dx, "C")) - 1), (size(split(dx, "D")) - 1), (size(split(dx, "E")) - 1), (size(split(dx, "F")) - 1)]
631
-
632
-
633
-
func dy (dz,dq,dA,dr,dB) = {
634
-
    func dC (cO,du) =     {
635
-
        let dD = ((fraction(dA, dB, P) * dq[du]) * dr)
636
-
        (cO :+ toString((parseIntValue(dz[du]) + dD)))
608
+
func dt (do,dp,dq) = {
609
+
    let dn = split(valueOrElse(getString(bD()), "0_0_0_0_0_0"), "_")
610
+
    dm(dn, do, dp, dq)
611
+
    }
612
+
613
+
614
+
func du (dv) = [(size(split(dv, "A")) - 1), (size(split(dv, "B")) - 1), (size(split(dv, "C")) - 1), (size(split(dv, "D")) - 1), (size(split(dv, "E")) - 1), (size(split(dv, "F")) - 1)]
615
+
616
+
617
+
func dw (dx,do,dy,dp,dz) = {
618
+
    func dA (cD,ds) =     {
619
+
        let dB = ((fraction(dy, dz, P) * do[ds]) * dp)
620
+
        (cD :+ toString((parseIntValue(dx[ds]) + dB)))
637
621
 
        }
638
622
 
639
-
    let cS = {
640
-
        let aW = [0, 1, 2, 3, 4, 5]
641
-
        let aX = size(aW)
642
-
        let aY = nil
643
-
        func aZ (ba,bb) =         if ((bb >= aX))
644
-
            then ba
645
-
            else dC(ba, aW[bb])
646
-
647
-
        func bc (ba,bb) =         if ((bb >= aX))
648
-
            then ba
623
+
    let cO = {
624
+
        let cF = [0, 1, 2, 3, 4, 5]
625
+
        let cG = size(cF)
626
+
        let cH = nil
627
+
        func cI (cJ,cK) =         if ((cK >= cG))
628
+
            then cJ
629
+
            else dA(cJ, cF[cK])
630
+
631
+
        func cL (cJ,cK) =         if ((cK >= cG))
632
+
            then cJ
649
633
 
            else throw("List size exceeds 6")
650
634
 
651
-
        bc(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6)
635
+
        cL(cI(cI(cI(cI(cI(cI(cH, 0), 1), 2), 3), 4), 5), 6)
652
636
 
        }
653
-
    makeString(cS, "_")
654
-
    }
655
-
656
-
657
-
func dE (dq,dA,dr,dB) = {
658
-
    func dC (cO,du) =     {
659
-
        let dD = ((fraction(dA, dB, P) * dq[du]) * dr)
660
-
        $Tuple2((cO._1 :+ dD), (cO._2 + dD))
637
+
    makeString(cO, "_")
638
+
    }
639
+
640
+
641
+
func dC (do,dy,dp,dz) = {
642
+
    func dA (cD,ds) =     {
643
+
        let dB = ((fraction(dy, dz, P) * do[ds]) * dp)
644
+
        $Tuple2((cD._1 :+ dB), (cD._2 + dB))
661
645
 
        }
662
646
 
663
-
    let aW = [0, 1, 2, 3, 4, 5]
664
-
    let aX = size(aW)
665
-
    let aY = $Tuple2(nil, 0)
666
-
    func aZ (ba,bb) =     if ((bb >= aX))
667
-
        then ba
668
-
        else dC(ba, aW[bb])
669
-
670
-
    func bc (ba,bb) =     if ((bb >= aX))
671
-
        then ba
647
+
    let cF = [0, 1, 2, 3, 4, 5]
648
+
    let cG = size(cF)
649
+
    let cH = $Tuple2(nil, 0)
650
+
    func cI (cJ,cK) =     if ((cK >= cG))
651
+
        then cJ
652
+
        else dA(cJ, cF[cK])
653
+
654
+
    func cL (cJ,cK) =     if ((cK >= cG))
655
+
        then cJ
672
656
 
        else throw("List size exceeds 6")
673
657
 
674
-
    bc(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6)
675
-
    }
676
-
677
-
678
-
func dF (dG,dH,dI,dJ) = {
679
-
    let dK = dI._1
680
-
    let dL = dI._2
681
-
    if ((dL == 0))
682
-
        then $Tuple2(makeString(dG, "_"), makeString(dH, "_"))
683
-
        else if ((dJ >= dL))
658
+
    cL(cI(cI(cI(cI(cI(cI(cH, 0), 1), 2), 3), 4), 5), 6)
659
+
    }
660
+
661
+
662
+
func dD (dE,dF,dG,dH) = {
663
+
    let dI = dG._1
664
+
    let dJ = dG._2
665
+
    if ((dJ == 0))
666
+
        then $Tuple2(makeString(dE, "_"), makeString(dF, "_"))
667
+
        else if ((dH >= dJ))
684
668
 
            then {
685
-
                func dM (cO,du) =                 (cO :+ toString((parseIntValue(dG[du]) + dK[du])))
686
-
687
-
                let cS = {
688
-
                    let aW = [0, 1, 2, 3, 4, 5]
689
-
                    let aX = size(aW)
690
-
                    let aY = nil
691
-
                    func aZ (ba,bb) =                     if ((bb >= aX))
692
-
                        then ba
693
-
                        else dM(ba, aW[bb])
694
-
695
-
                    func bc (ba,bb) =                     if ((bb >= aX))
696
-
                        then ba
669
+
                func dK (cD,ds) =                 (cD :+ toString((parseIntValue(dE[ds]) + dI[ds])))
670
+
671
+
                let cO = {
672
+
                    let cF = [0, 1, 2, 3, 4, 5]
673
+
                    let cG = size(cF)
674
+
                    let cH = nil
675
+
                    func cI (cJ,cK) =                     if ((cK >= cG))
676
+
                        then cJ
677
+
                        else dK(cJ, cF[cK])
678
+
679
+
                    func cL (cJ,cK) =                     if ((cK >= cG))
680
+
                        then cJ
697
681
 
                        else throw("List size exceeds 6")
698
682
 
699
-
                    bc(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6)
683
+
                    cL(cI(cI(cI(cI(cI(cI(cH, 0), 1), 2), 3), 4), 5), 6)
700
684
 
                    }
701
-
                $Tuple2(makeString(cS, "_"), makeString(dH, "_"))
685
+
                $Tuple2(makeString(cO, "_"), makeString(dF, "_"))
702
686
 
                }
703
687
 
            else {
704
-
                func dN (cO,du) =                 {
705
-
                    let dO = fraction(dK[du], dJ, dL)
706
-
                    $Tuple2((cO._1 :+ toString((parseIntValue(dG[du]) + dO))), (cO._2 :+ toString(((parseIntValue(dH[du]) + dK[du]) - dO))))
688
+
                func dL (cD,ds) =                 {
689
+
                    let dM = fraction(dI[ds], dH, dJ)
690
+
                    $Tuple2((cD._1 :+ toString((parseIntValue(dE[ds]) + dM))), (cD._2 :+ toString(((parseIntValue(dF[ds]) + dI[ds]) - dM))))
707
691
 
                    }
708
692
 
709
-
                let cS = {
710
-
                    let aW = [0, 1, 2, 3, 4, 5]
711
-
                    let aX = size(aW)
712
-
                    let aY = $Tuple2(nil, nil)
713
-
                    func aZ (ba,bb) =                     if ((bb >= aX))
714
-
                        then ba
715
-
                        else dN(ba, aW[bb])
716
-
717
-
                    func bc (ba,bb) =                     if ((bb >= aX))
718
-
                        then ba
693
+
                let cO = {
694
+
                    let cF = [0, 1, 2, 3, 4, 5]
695
+
                    let cG = size(cF)
696
+
                    let cH = $Tuple2(nil, nil)
697
+
                    func cI (cJ,cK) =                     if ((cK >= cG))
698
+
                        then cJ
699
+
                        else dL(cJ, cF[cK])
700
+
701
+
                    func cL (cJ,cK) =                     if ((cK >= cG))
702
+
                        then cJ
719
703
 
                        else throw("List size exceeds 6")
720
704
 
721
-
                    bc(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6)
705
+
                    cL(cI(cI(cI(cI(cI(cI(cH, 0), 1), 2), 3), 4), 5), 6)
722
706
 
                    }
723
-
                $Tuple2(makeString(cS._1, "_"), makeString(cS._2, "_"))
707
+
                $Tuple2(makeString(cO._1, "_"), makeString(cO._2, "_"))
724
708
 
                }
725
709
 
    }
726
710
 
727
711
 
728
-
func dP (dQ) = if ((dQ >= toBigInt(0)))
729
-
    then dQ
730
-
    else -(dQ)
731
-
732
-
733
-
let dR = [[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]]
734
-
735
-
func dS (bV,dT) = {
736
-
    let dU = toInt((bV % cj))
737
-
    let dV = if ((dT[0] > dU))
712
+
func dN (dO) = if ((dO >= toBigInt(0)))
713
+
    then dO
714
+
    else -(dO)
715
+
716
+
717
+
let dP = [[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]]
718
+
719
+
func dQ (bK,dR) = {
720
+
    let dS = toInt((bK % bY))
721
+
    let dT = if ((dR[0] > dS))
738
722
 
        then "A"
739
-
        else if ((dT[1] > dU))
723
+
        else if ((dR[1] > dS))
740
724
 
            then "B"
741
-
            else if ((dT[2] > dU))
725
+
            else if ((dR[2] > dS))
742
726
 
                then "C"
743
-
                else if ((dT[3] > dU))
727
+
                else if ((dR[3] > dS))
744
728
 
                    then "D"
745
-
                    else if ((dT[4] > dU))
729
+
                    else if ((dR[4] > dS))
746
730
 
                        then "E"
747
731
 
                        else "F"
748
-
    dV
749
-
    }
750
-
751
-
752
-
func dW (dX,dY) = {
753
-
    let dZ = dR[dY]
754
-
    func ea (cO,cP) =     $Tuple2((((((cO._1 + dS(cO._2, dZ)) + dS((cO._2 / cj), dZ)) + dS((cO._2 / ck), dZ)) + dS((cO._2 / cl), dZ)) + dS((cO._2 / cm), dZ)), (cO._2 / cn))
755
-
756
-
    let eb = {
757
-
        let aW = [1, 2, 3, 4, 5]
758
-
        let aX = size(aW)
759
-
        let aY = $Tuple2("", (dX / ci))
760
-
        func aZ (ba,bb) =         if ((bb >= aX))
761
-
            then ba
762
-
            else ea(ba, aW[bb])
763
-
764
-
        func bc (ba,bb) =         if ((bb >= aX))
765
-
            then ba
732
+
    dT
733
+
    }
734
+
735
+
736
+
func dU (dV,dW) = {
737
+
    let dX = dP[dW]
738
+
    func dY (cD,cE) =     $Tuple2((((((cD._1 + dQ(cD._2, dX)) + dQ((cD._2 / bY), dX)) + dQ((cD._2 / bZ), dX)) + dQ((cD._2 / ca), dX)) + dQ((cD._2 / cb), dX)), (cD._2 / cc))
739
+
740
+
    let dZ = {
741
+
        let cF = [1, 2, 3, 4, 5]
742
+
        let cG = size(cF)
743
+
        let cH = $Tuple2("", (dV / bX))
744
+
        func cI (cJ,cK) =         if ((cK >= cG))
745
+
            then cJ
746
+
            else dY(cJ, cF[cK])
747
+
748
+
        func cL (cJ,cK) =         if ((cK >= cG))
749
+
            then cJ
766
750
 
            else throw("List size exceeds 5")
767
751
 
768
-
        bc(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5)
752
+
        cL(cI(cI(cI(cI(cI(cH, 0), 1), 2), 3), 4), 5)
769
753
 
        }
770
-
    eb._1
771
-
    }
772
-
773
-
774
-
func ec (ed) = {
775
-
    let ee = split(valueOrElse(getString(ed), "0:0_0_0_0_0_0:0_0_0_0_0_0:"), ":")
776
-
[toString(valueOrElse(parseInt(ee[ah]), 0)), if ((size(split(ee[ai], "_")) == N))
777
-
        then ee[ai]
778
-
        else "0_0_0_0_0_0", if ((size(split(ee[aj], "_")) == N))
779
-
        then ee[aj]
780
-
        else "0_0_0_0_0_0", ee[ak]]
754
+
    dZ._1
755
+
    }
756
+
757
+
758
+
func ea (eb) = {
759
+
    let ec = split(valueOrElse(getString(eb), "0:0_0_0_0_0_0:0_0_0_0_0_0:"), ":")
760
+
[toString(valueOrElse(parseInt(ec[ai]), 0)), if ((size(split(ec[aj], "_")) == N))
761
+
        then ec[aj]
762
+
        else "0_0_0_0_0_0", if ((size(split(ec[ak], "_")) == N))
763
+
        then ec[ak]
764
+
        else "0_0_0_0_0_0", ec[al]]
765
+
    }
766
+
767
+
768
+
func ed (ee) = {
769
+
    let dg = split(ee, "_")
770
+
    ((Q * (parseIntValue(dg[1]) + 1)) * parseIntValue(dg[0]))
781
771
 
    }
782
772
 
783
773
 
784
774
 
func ef (eg) = {
785
-
    let di = split(eg, "_")
786
-
    ((Q * (parseIntValue(di[1]) + 1)) * parseIntValue(di[0]))
787
-
    }
788
-
789
-
790
-
func eh (ei) = {
791
-
    let ej = ei[ab]
792
-
    func ek (cO,df) =     (cO + parseIntValue(df))
793
-
794
-
    func el (cO,df) =     {
795
-
        let bE = cO._1
796
-
        let em = al(bE)
797
-
        let en = (((parseIntValue(df) + em) - 1) / em)
798
-
        $Tuple2((bE + 1), (cO._2 + (en * bl)))
775
+
    let eh = eg[ac]
776
+
    func ei (cD,db) =     (cD + parseIntValue(db))
777
+
778
+
    func ej (cD,db) =     {
779
+
        let bt = cD._1
780
+
        let ek = (((parseIntValue(db) + Y) - 1) / Y)
781
+
        $Tuple2((bt + 1), (cD._2 + (ek * ba)))
799
782
 
        }
800
783
 
801
-
    let eo = {
802
-
        let aW = split(ei[Z], "_")
803
-
        let aX = size(aW)
804
-
        let aY = 0
805
-
        func aZ (ba,bb) =         if ((bb >= aX))
806
-
            then ba
807
-
            else ek(ba, aW[bb])
808
-
809
-
        func bc (ba,bb) =         if ((bb >= aX))
810
-
            then ba
784
+
    let el = {
785
+
        let cF = split(eg[aa], "_")
786
+
        let cG = size(cF)
787
+
        let cH = 0
788
+
        func cI (cJ,cK) =         if ((cK >= cG))
789
+
            then cJ
790
+
            else ei(cJ, cF[cK])
791
+
792
+
        func cL (cJ,cK) =         if ((cK >= cG))
793
+
            then cJ
811
794
 
            else throw("List size exceeds 6")
812
795
 
813
-
        bc(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6)
796
+
        cL(cI(cI(cI(cI(cI(cI(cH, 0), 1), 2), 3), 4), 5), 6)
814
797
 
        }
815
-
    let ep = {
816
-
        let aW = split(ei[aa], "_")
817
-
        let aX = size(aW)
818
-
        let aY = 0
819
-
        func eq (ba,bb) =         if ((bb >= aX))
820
-
            then ba
821
-
            else ek(ba, aW[bb])
822
-
823
-
        func er (ba,bb) =         if ((bb >= aX))
824
-
            then ba
798
+
    let em = {
799
+
        let cF = split(eg[ab], "_")
800
+
        let cG = size(cF)
801
+
        let cH = 0
802
+
        func en (cJ,cK) =         if ((cK >= cG))
803
+
            then cJ
804
+
            else ei(cJ, cF[cK])
805
+
806
+
        func eo (cJ,cK) =         if ((cK >= cG))
807
+
            then cJ
825
808
 
            else throw("List size exceeds 6")
826
809
 
827
-
        er(eq(eq(eq(eq(eq(eq(aY, 0), 1), 2), 3), 4), 5), 6)
810
+
        eo(en(en(en(en(en(en(cH, 0), 1), 2), 3), 4), 5), 6)
828
811
 
        }
829
-
    let es = if ((ej == ""))
812
+
    let ep = if ((eh == ""))
830
813
 
        then 0
831
-
        else (        let aW = split_4C(ej, "_")
832
-
        let aX = size(aW)
833
-
        let aY = $Tuple2(0, 0)
834
-
        func et (ba,bb) =         if ((bb >= aX))
835
-
            then ba
836
-
            else el(ba, aW[bb])
837
-
838
-
        func eu (ba,bb) =         if ((bb >= aX))
839
-
            then ba
814
+
        else (        let cF = split_4C(eh, "_")
815
+
        let cG = size(cF)
816
+
        let cH = $Tuple2(0, 0)
817
+
        func eq (cJ,cK) =         if ((cK >= cG))
818
+
            then cJ
819
+
            else ej(cJ, cF[cK])
820
+
821
+
        func er (cJ,cK) =         if ((cK >= cG))
822
+
            then cJ
840
823
 
            else throw("List size exceeds 50")
841
824
 
842
-
        eu(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(aY, 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
843
-
    ((eo + ep) + es)
844
-
    }
845
-
846
-
847
-
func ev (ew,ex,ey) = {
848
-
    let eg = ((toString(ex) + "_") + toString(ey))
849
-
    let ez = ef(eg)
850
-
    let eA = valueOrElse(getString(ew), (eg + ":0_0_0_0_0_0:0_0_0_0_0_0::0"))
851
-
    let eB = split_4C(eA, ":")
852
-
    let eC = eh(eB)
853
-
    let eD = if ((5 > size(eB)))
854
-
        then makeString(["0", toString(eC), toString((ez - eC)), toString(ez)], "_")
855
-
        else {
856
-
            let eE = split(eB[ac], "_")
857
-
            let eF = parseIntValue(eE[ad])
858
-
            let eG = if ((size(eE) > 1))
859
-
                then parseIntValue(eE[ae])
860
-
                else eC
861
-
            makeString([toString(eF), toString(eG), toString(((ez - eF) - eG)), toString(ez)], "_")
862
-
            }
863
-
[eB[Y], if ((size(split(eB[Z], "_")) == N))
864
-
        then eB[Z]
865
-
        else "0_0_0_0_0_0", if ((size(split(eB[aa], "_")) == N))
866
-
        then eB[aa]
867
-
        else "0_0_0_0_0_0", eB[ab], eD]
868
-
    }
869
-
870
-
871
-
func eH (ei) = {
872
-
    let eI = eh(ei)
873
-
    let eJ = parseIntValue(split(ei[ac], "_")[ad])
874
-
    ((ef(ei[Y]) - eI) - eJ)
875
-
    }
876
-
877
-
878
-
func eK (eL,em) = {
879
-
    let en = if ((eL >= 0))
880
-
        then (((eL + em) - 1) / em)
881
-
        else -((((-(eL) + em) - 1) / em))
882
-
    (en * bl)
883
-
    }
884
-
885
-
886
-
func eM (eN,ei,eO) = if ((size(eN) != 3))
825
+
        er(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(cH, 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
826
+
    ((el + em) + ep)
827
+
    }
828
+
829
+
830
+
func es (et,eu,ev) = {
831
+
    let ee = ((toString(eu) + "_") + toString(ev))
832
+
    let ew = ed(ee)
833
+
    let ex = valueOrElse(getString(et), (ee + ":0_0_0_0_0_0:0_0_0_0_0_0::0"))
834
+
    let ey = split_4C(ex, ":")
835
+
    let ez = ef(ey)
836
+
    let eA = if ((5 > size(ey)))
837
+
        then makeString(["0", toString(ez), toString((ew - ez)), toString(ew)], "_")
838
+
        else {
839
+
            let eB = split(ey[ad], "_")
840
+
            let eC = parseIntValue(eB[ae])
841
+
            let eD = if ((size(eB) > 1))
842
+
                then parseIntValue(eB[af])
843
+
                else ez
844
+
            makeString([toString(eC), toString(eD), toString(((ew - eC) - eD)), toString(ew)], "_")
845
+
            }
846
+
[ey[Z], if ((size(split(ey[aa], "_")) == N))
847
+
        then ey[aa]
848
+
        else "0_0_0_0_0_0", if ((size(split(ey[ab], "_")) == N))
849
+
        then ey[ab]
850
+
        else "0_0_0_0_0_0", ey[ac], eA]
851
+
    }
852
+
853
+
854
+
func eE (eg) = {
855
+
    let eF = ef(eg)
856
+
    let eG = parseIntValue(split(eg[ad], "_")[ae])
857
+
    ((ed(eg[Z]) - eF) - eG)
858
+
    }
859
+
860
+
861
+
func eH (eI,eJ) = {
862
+
    let ek = if ((eI >= 0))
863
+
        then (((eI + eJ) - 1) / eJ)
864
+
        else -((((-(eI) + eJ) - 1) / eJ))
865
+
    (ek * ba)
866
+
    }
867
+
868
+
869
+
func eK (eL,eg,eM) = if ((size(eL) != 3))
887
870
 
    then throw("cargoListStr should contain exactly 2 ':' separators")
888
871
 
    else {
889
-
        let eP = split(eN[0], "_")
890
-
        let eQ = split(eN[1], "_")
891
-
        let eR = if ((eN[2] == ""))
872
+
        let eN = split(eL[0], "_")
873
+
        let eO = split(eL[1], "_")
874
+
        let eP = if ((eL[2] == ""))
892
875
 
            then nil
893
-
            else split(eN[2], "_")
894
-
        if ((size(eP) != N))
876
+
            else split(eL[2], "_")
877
+
        if ((size(eN) != N))
895
878
 
            then throw("All 6 resources should be passed")
896
-
            else if ((size(eQ) != N))
879
+
            else if ((size(eO) != N))
897
880
 
                then throw("All 6 materials should be passed")
898
881
 
                else {
899
-
                    let dJ = eH(ei)
900
-
                    let eS = split(ei[Z], "_")
901
-
                    let eT = split(ei[aa], "_")
902
-
                    let eU = if ((ei[ab] == ""))
882
+
                    let dH = eE(eg)
883
+
                    let eQ = split(eg[aa], "_")
884
+
                    let eR = split(eg[ab], "_")
885
+
                    let eS = if ((eg[ac] == ""))
903
886
 
                        then nil
904
-
                        else split(ei[ab], "_")
905
-
                    let dH = split(eO[ai], "_")
906
-
                    let eV = split(eO[aj], "_")
907
-
                    let eW = if ((eO[ak] == ""))
887
+
                        else split(eg[ac], "_")
888
+
                    let dF = split(eM[aj], "_")
889
+
                    let eT = split(eM[ak], "_")
890
+
                    let eU = if ((eM[al] == ""))
908
891
 
                        then nil
909
-
                        else split(eO[ak], "_")
910
-
                    func eX (cO,df) =                     {
911
-
                        let du = cO._1
912
-
                        let eY = parseIntValue(df)
913
-
                        let eZ = parseIntValue(eS[du])
914
-
                        let fa = parseIntValue(dH[du])
915
-
                        if ((eY == 0))
916
-
                            then $Tuple4((du + 1), (cO._2 :+ eS[du]), (cO._3 :+ dH[du]), cO._4)
917
-
                            else if ((eY > 0))
918
-
                                then if ((eY > fa))
919
-
                                    then throw((((("Attempt to take " + df) + " from backpack, but only ") + toString(fa)) + " available"))
920
-
                                    else $Tuple4((du + 1), (cO._2 :+ toString((eZ + eY))), (cO._3 :+ toString((fa - eY))), (cO._4 + eY))
921
-
                                else if ((-(eY) > eZ))
922
-
                                    then throw((((("Attempt to take " + toString(-(eY))) + " from warehouse, but only ") + toString(eZ)) + " available"))
923
-
                                    else $Tuple4((du + 1), (cO._2 :+ toString((eZ + eY))), (cO._3 :+ toString((fa - eY))), (cO._4 + eY))
892
+
                        else split(eM[al], "_")
893
+
                    func eV (cD,db) =                     {
894
+
                        let ds = cD._1
895
+
                        let eW = parseIntValue(db)
896
+
                        let eX = parseIntValue(eQ[ds])
897
+
                        let eY = parseIntValue(dF[ds])
898
+
                        if ((eW == 0))
899
+
                            then $Tuple4((ds + 1), (cD._2 :+ eQ[ds]), (cD._3 :+ dF[ds]), cD._4)
900
+
                            else if ((eW > 0))
901
+
                                then if ((eW > eY))
902
+
                                    then throw((((("Attempt to take " + db) + " from backpack, but only ") + toString(eY)) + " available"))
903
+
                                    else $Tuple4((ds + 1), (cD._2 :+ toString((eX + eW))), (cD._3 :+ toString((eY - eW))), (cD._4 + eW))
904
+
                                else if ((-(eW) > eX))
905
+
                                    then throw((((("Attempt to take " + toString(-(eW))) + " from warehouse, but only ") + toString(eX)) + " available"))
906
+
                                    else $Tuple4((ds + 1), (cD._2 :+ toString((eX + eW))), (cD._3 :+ toString((eY - eW))), (cD._4 + eW))
924
907
 
                        }
925
908
 
926
-
                    let cS = {
927
-
                        let aW = eP
928
-
                        let aX = size(aW)
929
-
                        let aY = $Tuple4(0, nil, nil, 0)
930
-
                        func aZ (ba,bb) =                         if ((bb >= aX))
931
-
                            then ba
932
-
                            else eX(ba, aW[bb])
933
-
934
-
                        func bc (ba,bb) =                         if ((bb >= aX))
935
-
                            then ba
909
+
                    let cO = {
910
+
                        let cF = eN
911
+
                        let cG = size(cF)
912
+
                        let cH = $Tuple4(0, nil, nil, 0)
913
+
                        func cI (cJ,cK) =                         if ((cK >= cG))
914
+
                            then cJ
915
+
                            else eV(cJ, cF[cK])
916
+
917
+
                        func cL (cJ,cK) =                         if ((cK >= cG))
918
+
                            then cJ
936
919
 
                            else throw("List size exceeds 6")
937
920
 
938
-
                        bc(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6)
921
+
                        cL(cI(cI(cI(cI(cI(cI(cH, 0), 1), 2), 3), 4), 5), 6)
939
922
 
                        }
940
-
                    func fb (cO,df) =                     {
941
-
                        let du = cO._1
942
-
                        let eY = parseIntValue(df)
943
-
                        let fc = parseIntValue(eT[du])
944
-
                        let fd = parseIntValue(eV[du])
945
-
                        if ((eY == 0))
946
-
                            then $Tuple4((du + 1), (cO._2 :+ eT[du]), (cO._3 :+ eV[du]), cO._4)
947
-
                            else if ((eY > 0))
948
-
                                then if ((eY > fd))
949
-
                                    then throw((((("Attempt to take " + df) + " from backpack, but only ") + toString(fd)) + " available"))
950
-
                                    else $Tuple4((du + 1), (cO._2 :+ toString((fc + eY))), (cO._3 :+ toString((fd - eY))), (cO._4 + eY))
951
-
                                else if ((-(eY) > fc))
952
-
                                    then throw((((("Attempt to take " + toString(-(eY))) + " from warehouse, but only ") + toString(fc)) + " available"))
953
-
                                    else $Tuple4((du + 1), (cO._2 :+ toString((fc + eY))), (cO._3 :+ toString((fd - eY))), (cO._4 + eY))
923
+
                    func eZ (cD,db) =                     {
924
+
                        let ds = cD._1
925
+
                        let eW = parseIntValue(db)
926
+
                        let fa = parseIntValue(eR[ds])
927
+
                        let fb = parseIntValue(eT[ds])
928
+
                        if ((eW == 0))
929
+
                            then $Tuple4((ds + 1), (cD._2 :+ eR[ds]), (cD._3 :+ eT[ds]), cD._4)
930
+
                            else if ((eW > 0))
931
+
                                then if ((eW > fb))
932
+
                                    then throw((((("Attempt to take " + db) + " from backpack, but only ") + toString(fb)) + " available"))
933
+
                                    else $Tuple4((ds + 1), (cD._2 :+ toString((fa + eW))), (cD._3 :+ toString((fb - eW))), (cD._4 + eW))
934
+
                                else if ((-(eW) > fa))
935
+
                                    then throw((((("Attempt to take " + toString(-(eW))) + " from warehouse, but only ") + toString(fa)) + " available"))
936
+
                                    else $Tuple4((ds + 1), (cD._2 :+ toString((fa + eW))), (cD._3 :+ toString((fb - eW))), (cD._4 + eW))
954
937
 
                        }
955
938
 
956
-
                    let fe = {
957
-
                        let aW = eQ
958
-
                        let aX = size(aW)
959
-
                        let aY = $Tuple4(0, nil, nil, cS._4)
960
-
                        func eq (ba,bb) =                         if ((bb >= aX))
961
-
                            then ba
962
-
                            else fb(ba, aW[bb])
963
-
964
-
                        func er (ba,bb) =                         if ((bb >= aX))
965
-
                            then ba
939
+
                    let fc = {
940
+
                        let cF = eO
941
+
                        let cG = size(cF)
942
+
                        let cH = $Tuple4(0, nil, nil, cO._4)
943
+
                        func en (cJ,cK) =                         if ((cK >= cG))
944
+
                            then cJ
945
+
                            else eZ(cJ, cF[cK])
946
+
947
+
                        func eo (cJ,cK) =                         if ((cK >= cG))
948
+
                            then cJ
966
949
 
                            else throw("List size exceeds 6")
967
950
 
968
-
                        er(eq(eq(eq(eq(eq(eq(aY, 0), 1), 2), 3), 4), 5), 6)
951
+
                        eo(en(en(en(en(en(en(cH, 0), 1), 2), 3), 4), 5), 6)
969
952
 
                        }
970
-
                    func ff (cO,df) =                     {
971
-
                        let du = cO._1
972
-
                        let em = al(du)
973
-
                        let eY = parseIntValue(df)
974
-
                        let fg = if ((size(eU) > du))
975
-
                            then parseIntValue(eU[du])
953
+
                    func fd (cD,db) =                     {
954
+
                        let ds = cD._1
955
+
                        let eW = parseIntValue(db)
956
+
                        let fe = if ((size(eS) > ds))
957
+
                            then parseIntValue(eS[ds])
976
958
 
                            else 0
977
-
                        let fh = if ((size(eW) > du))
978
-
                            then parseIntValue(eW[du])
959
+
                        let ff = if ((size(eU) > ds))
960
+
                            then parseIntValue(eU[ds])
979
961
 
                            else 0
980
-
                        if ((eY == 0))
981
-
                            then $Tuple4((du + 1), (cO._2 :+ toString(fg)), (cO._3 :+ toString(fh)), cO._4)
982
-
                            else if ((eY > 0))
983
-
                                then if ((eY > fh))
984
-
                                    then throw((((("Attempt to take " + df) + " from backpack, but only ") + toString(fh)) + " available"))
962
+
                        if ((eW == 0))
963
+
                            then $Tuple4((ds + 1), (cD._2 :+ toString(fe)), (cD._3 :+ toString(ff)), cD._4)
964
+
                            else if ((eW > 0))
965
+
                                then if ((eW > ff))
966
+
                                    then throw((((("Attempt to take " + db) + " from backpack, but only ") + toString(ff)) + " available"))
985
967
 
                                    else {
986
-
                                        let fi = (eK((fg + eY), em) - eK(fg, em))
987
-
                                        $Tuple4((du + 1), (cO._2 :+ toString((fg + eY))), (cO._3 :+ toString((fh - eY))), (cO._4 + fi))
968
+
                                        let fg = (eH((fe + eW), Y) - eH(fe, Y))
969
+
                                        $Tuple4((ds + 1), (cD._2 :+ toString((fe + eW))), (cD._3 :+ toString((ff - eW))), (cD._4 + fg))
988
970
 
                                        }
989
-
                                else if ((-(eY) > fg))
990
-
                                    then throw((((("Attempt to take " + toString(-(eY))) + " from warehouse, but only ") + toString(fg)) + " available"))
971
+
                                else if ((-(eW) > fe))
972
+
                                    then throw((((("Attempt to take " + toString(-(eW))) + " from warehouse, but only ") + toString(fe)) + " available"))
991
973
 
                                    else {
992
-
                                        let fi = (eK((fg + eY), em) - eK(fg, em))
993
-
                                        $Tuple4((du + 1), (cO._2 :+ toString((fg + eY))), (cO._3 :+ toString((fh - eY))), (cO._4 + fi))
974
+
                                        let fg = (eH((fe + eW), Y) - eH(fe, Y))
975
+
                                        $Tuple4((ds + 1), (cD._2 :+ toString((fe + eW))), (cD._3 :+ toString((ff - eW))), (cD._4 + fg))
994
976
 
                                        }
995
977
 
                        }
996
978
 
997
-
                    let ee = if ((size(eR) != 0))
979
+
                    let ec = if ((size(eP) != 0))
998
980
 
                        then {
999
-
                            let aW = eR
1000
-
                            let aX = size(aW)
1001
-
                            let aY = $Tuple4(0, nil, nil, fe._4)
1002
-
                            func et (ba,bb) =                             if ((bb >= aX))
1003
-
                                then ba
1004
-
                                else ff(ba, aW[bb])
1005
-
1006
-
                            func eu (ba,bb) =                             if ((bb >= aX))
1007
-
                                then ba
981
+
                            let cF = eP
982
+
                            let cG = size(cF)
983
+
                            let cH = $Tuple4(0, nil, nil, fc._4)
984
+
                            func eq (cJ,cK) =                             if ((cK >= cG))
985
+
                                then cJ
986
+
                                else fd(cJ, cF[cK])
987
+
988
+
                            func er (cJ,cK) =                             if ((cK >= cG))
989
+
                                then cJ
1008
990
 
                                else throw("List size exceeds 50")
1009
991
 
1010
-
                            eu(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(aY, 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)
992
+
                            er(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(cH, 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)
1011
993
 
                            }
1012
-
                        else $Tuple4(0, eU, eW, fe._4)
1013
-
                    let fj = ee._4
1014
-
                    if ((fj > dJ))
1015
-
                        then throw((((("Attempt to put total " + toString(fj)) + " stuff, but only ") + toString(dJ)) + " warehouse space left"))
1016
-
                        else $Tuple7(makeString(cS._2, "_"), makeString(fe._2, "_"), makeString(ee._2, "_"), makeString(cS._3, "_"), makeString(fe._3, "_"), makeString(ee._3, "_"), fj)
994
+
                        else $Tuple4(0, eS, eU, fc._4)
995
+
                    let fh = ec._4
996
+
                    if ((fh > dH))
997
+
                        then throw((((("Attempt to put total " + toString(fh)) + " stuff, but only ") + toString(dH)) + " warehouse space left"))
998
+
                        else $Tuple7(makeString(cO._2, "_"), makeString(fc._2, "_"), makeString(ec._2, "_"), makeString(cO._3, "_"), makeString(fc._3, "_"), makeString(ec._3, "_"), fh)
1017
999
 
                    }
1018
1000
 
        }
1019
1001
 
1020
1002
 
1021
-
func fk (fl,fm) = {
1022
-
    let aN = toString(fl)
1023
-
    let fn = dP(toBigInt(fm))
1024
-
    let fo = valueOrElse(getInteger(cp()), (co + 1))
1025
-
    let cr = toString(fo)
1026
-
    let dY = toInt((fn % ci))
1027
-
    let dx = dW(fn, dY)
1028
-
    let fp = V[dY]
1029
-
    let fq = Issue(cH(cr, "S"), makeString([cr, "S", dx, fp], "_"), 1, 0, false)
1030
-
    let ap = calculateAssetId(fq)
1031
-
    let fr = toBase58String(ap)
1032
-
    $Tuple2([IntegerEntry(cp(), (fo + 1)), fq, StringEntry(cq(cr), fr), StringEntry(ao(fr), aN), StringEntry(cw(cr), aN), IntegerEntry(as(fr), 0), IntegerEntry(cu(fr, aN), 0), ScriptTransfer(fl, 1, ap)], $Tuple2(fr, fp))
1033
-
    }
1034
-
1035
-
1036
-
func fs (aN,ft,fu) = if (!(sigVerify_8Kb(ft, fu, ca)))
1003
+
func fi (fj,fk) = {
1004
+
    let aM = toString(fj)
1005
+
    let fl = dN(toBigInt(fk))
1006
+
    let fm = valueOrElse(getInteger(ce()), (cd + 1))
1007
+
    let cg = toString(fm)
1008
+
    let dW = toInt((fl % bX))
1009
+
    let dv = dU(fl, dW)
1010
+
    let fn = V[dW]
1011
+
    let fo = Issue(cw(cg, "S"), makeString([cg, "S", dv, fn], "_"), 1, 0, false)
1012
+
    let ao = calculateAssetId(fo)
1013
+
    let fp = toBase58String(ao)
1014
+
    $Tuple2([IntegerEntry(ce(), (fm + 1)), fo, StringEntry(cf(cg), fp), StringEntry(an(fp), aM), StringEntry(cl(cg), aM), IntegerEntry(ar(fp), 0), IntegerEntry(cj(fp, aM), 0), ScriptTransfer(fj, 1, ao)], $Tuple2(fp, fn))
1015
+
    }
1016
+
1017
+
1018
+
func fq (aM,fr,fs) = if (!(sigVerify_8Kb(fr, fs, bP)))
1037
1019
 
    then throw("signature does not match")
1038
1020
 
    else {
1039
-
        let di = split(toUtf8String(ft), ";")
1040
-
        let fv = split(di[0], "|")
1041
-
        let fw = split(fv[cD], "_")
1042
-
        let fx = parseIntValue(fw[0])
1043
-
        let fy = parseIntValue(fw[1])
1044
-
        let fz = split(di[1], ":")
1045
-
        let fA = fz[0]
1046
-
        let fB = parseIntValue(fv[cE])
1047
-
        if (if ((fB > (lastBlock.timestamp + cc)))
1021
+
        let dg = split(toUtf8String(fr), ";")
1022
+
        let ft = split(dg[0], "|")
1023
+
        let fu = split(ft[cs], "_")
1024
+
        let fv = parseIntValue(fu[0])
1025
+
        let fw = parseIntValue(fu[1])
1026
+
        let fx = split(dg[1], ":")
1027
+
        let fy = fx[0]
1028
+
        let fz = parseIntValue(ft[ct])
1029
+
        if (if ((fz > (lastBlock.timestamp + bR)))
1048
1030
 
            then true
1049
-
            else ((lastBlock.timestamp - cc) > fB))
1050
-
            then throw(((("signature outdated: logTime=" + toString(fB)) + ", bcTime=") + toString(lastBlock.timestamp)))
1031
+
            else ((lastBlock.timestamp - bR) > fz))
1032
+
            then throw(((("signature outdated: logTime=" + toString(fz)) + ", bcTime=") + toString(lastBlock.timestamp)))
1051
1033
 
            else {
1052
-
                let fC = fz[1]
1053
-
                let fD = valueOrElse(getString(an(aN)), "")
1054
-
                if ((fD != fC))
1055
-
                    then throw(((("Tx ids don't match! In state: " + fD) + ", in msg: ") + fC))
1034
+
                let fA = fx[1]
1035
+
                let fB = valueOrElse(getString(am(aM)), "")
1036
+
                if ((fB != fA))
1037
+
                    then throw(((("Tx ids don't match! In state: " + fB) + ", in msg: ") + fA))
1056
1038
 
                    else {
1057
-
                        let k = valueOrErrorMessage(getString(aH(aN)), "You don't have a duck staked")
1058
-
                        let fE = aK(k)
1059
-
                        let fF = E(valueOrElse(getInteger(m(k)), 0))
1060
-
                        let fG = valueOrElse(getInteger(fE), fF)
1061
-
                        if ((fG != fx))
1062
-
                            then throw(((("oldHealth=" + toString(fG)) + " from state does not match one from flight log=") + toString(fx)))
1063
-
                            else if ((0 >= fx))
1039
+
                        let k = valueOrErrorMessage(getString(aG(aM)), "You don't have a duck staked")
1040
+
                        let fC = aJ(k)
1041
+
                        let fD = E(valueOrElse(getInteger(m(k)), 0))
1042
+
                        let fE = valueOrElse(getInteger(fC), fD)
1043
+
                        if ((fE != fv))
1044
+
                            then throw(((("oldHealth=" + toString(fE)) + " from state does not match one from flight log=") + toString(fv)))
1045
+
                            else if ((0 >= fv))
1064
1046
 
                                then throw("You can't fly with zero health")
1065
1047
 
                                else {
1066
-
                                    let fH = if ((size(fv) > cF))
1067
-
                                        then fv[cF]
1048
+
                                    let fF = if ((size(ft) > cu))
1049
+
                                        then ft[cu]
1068
1050
 
                                        else ""
1069
-
                                    let fI = if ((size(fv) > cG))
1070
-
                                        then fv[cG]
1051
+
                                    let fG = if ((size(ft) > cv))
1052
+
                                        then ft[cv]
1071
1053
 
                                        else ""
1072
-
                                    let fJ = if (if ((fy > 0))
1073
-
                                        then (fH == "$")
1054
+
                                    let fH = if (if ((fw > 0))
1055
+
                                        then (fF == "$")
1074
1056
 
                                        else false)
1075
-
                                        then bU(invoke(bF, "sendUsdtPrize", [aN], nil))
1057
+
                                        then bJ(invoke(bu, "sendUsdtPrize", [aM], nil))
1076
1058
 
                                        else 0
1077
-
                                    $Tuple5(fy, k, fJ, fA, fI)
1059
+
                                    $Tuple5(fw, k, fH, fy, fG)
1078
1060
 
                                    }
1079
1061
 
                        }
1080
1062
 
                }
1081
1063
 
        }
1082
1064
 
1083
1065
 
1084
-
func fK (fl,fm,ft,fu) = {
1085
-
    let aN = toString(fl)
1086
-
    let dZ = fs(aN, ft, fu)
1087
-
    let fE = aK(dZ._2)
1088
-
    let ed = aI(dZ._2)
1089
-
    let eO = ec(ed)
1090
-
    let fL = split(eO[aj], "_")
1091
-
    let fM = makeString(cT(true, fL, cg), "_")
1092
-
    let dn = da(eO[ak], dZ._5)
1093
-
    if ((0 >= dZ._1))
1094
-
        then $Tuple3([IntegerEntry(fE, 0), StringEntry(ed, makeString([eO[ah], eO[ai], eO[aj], dn], ":"))], "", 0)
1095
-
        else {
1096
-
            let fN = fk(fl, fm)
1097
-
            let fr = fN._2._1
1098
-
            $Tuple3((((fN._1 :+ StringEntry(aJ(dZ._2), makeString([fN._2._2, "L", fr], "_"))) :+ IntegerEntry(fE, dZ._1)) :+ StringEntry(ed, makeString([eO[ah], eO[ai], fM, dn], ":"))), fr, dZ._3)
1099
-
            }
1100
-
    }
1101
-
1102
-
1103
-
func fO (az,fP) = {
1104
-
    let ey = valueOrElse(getInteger(as(az)), 0)
1105
-
    let fQ = valueOrElse(getInteger(at(M, az)), 0)
1106
-
    let fR = (ey / 6)
1107
-
    let fS = (ey / 7)
1108
-
    ((O + fraction(O, ((ey + fR) + (2 * fS)), 5)) + fraction(O, fQ, (fP * 5)))
1109
-
    }
1110
-
1111
-
1112
-
func fT (p,fU,fV) = {
1113
-
    let fW = if ((fU == cA))
1114
-
        then $Tuple2(fV, valueOrElse(getString(aH(p)), ""))
1115
-
        else {
1116
-
            let k = valueOrErrorMessage(getString(aH(p)), "You don't have a duck staked")
1117
-
            let fX = valueOrElse(getString(aJ(k)), R)
1118
-
            let fY = split(value(fX), "_")
1119
-
            if ((fY[aP] != "L"))
1120
-
                then throw((("Duck location type is " + fY[aP]) + ", but should be L"))
1121
-
                else $Tuple2(fY[aQ], k)
1122
-
            }
1123
-
    let az = fW._1
1124
-
    let fZ = fW._2
1125
-
    let ga = value(assetInfo(fromBase58String(az)))
1126
-
    let gb = ar(az)
1127
-
    let gc = valueOrErrorMessage(getInteger(gb), (("Land " + ga.name) + " is not staked"))
1128
-
    let gd = valueOrErrorMessage(getString(ao(az)), (("NFT " + ga.name) + " is orphaned"))
1129
-
    if ((gd != p))
1066
+
func fI (fj,fk,fr,fs) = {
1067
+
    let aM = toString(fj)
1068
+
    let dX = fq(aM, fr, fs)
1069
+
    let fC = aJ(dX._2)
1070
+
    let eb = aH(dX._2)
1071
+
    let eM = ea(eb)
1072
+
    let fJ = split(eM[ak], "_")
1073
+
    let fK = makeString(cP(true, fJ, bV), "_")
1074
+
    let dl = cW(eM[al], dX._5)
1075
+
    if ((0 >= dX._1))
1076
+
        then $Tuple3([IntegerEntry(fC, 0), StringEntry(eb, makeString([eM[ai], eM[aj], eM[ak], dl], ":"))], "", 0)
1077
+
        else {
1078
+
            let fL = fi(fj, fk)
1079
+
            let fp = fL._2._1
1080
+
            $Tuple3((((fL._1 :+ StringEntry(aI(dX._2), makeString([fL._2._2, "L", fp], "_"))) :+ IntegerEntry(fC, dX._1)) :+ StringEntry(eb, makeString([eM[ai], eM[aj], fK, dl], ":"))), fp, dX._3)
1081
+
            }
1082
+
    }
1083
+
1084
+
1085
+
func fM (ay,fN) = {
1086
+
    let ev = valueOrElse(getInteger(ar(ay)), 0)
1087
+
    let fO = valueOrElse(getInteger(as(M, ay)), 0)
1088
+
    let fP = (ev / 6)
1089
+
    let fQ = (ev / 7)
1090
+
    ((O + fraction(O, ((ev + fP) + (2 * fQ)), 5)) + fraction(O, fO, (fN * 5)))
1091
+
    }
1092
+
1093
+
1094
+
func fR (p,fS,fT) = {
1095
+
    let fU = if ((fS == cp))
1096
+
        then $Tuple2(fT, valueOrElse(getString(aG(p)), ""))
1097
+
        else {
1098
+
            let k = valueOrErrorMessage(getString(aG(p)), "You don't have a duck staked")
1099
+
            let fV = valueOrElse(getString(aI(k)), R)
1100
+
            let fW = split(value(fV), "_")
1101
+
            if ((fW[aO] != "L"))
1102
+
                then throw((("Duck location type is " + fW[aO]) + ", but should be L"))
1103
+
                else $Tuple2(fW[aP], k)
1104
+
            }
1105
+
    let ay = fU._1
1106
+
    let fX = fU._2
1107
+
    let fY = value(assetInfo(fromBase58String(ay)))
1108
+
    let fZ = aq(ay)
1109
+
    let ga = valueOrErrorMessage(getInteger(fZ), (("Land " + fY.name) + " is not staked"))
1110
+
    let gb = valueOrErrorMessage(getString(an(ay)), (("NFT " + fY.name) + " is orphaned"))
1111
+
    if ((gb != p))
1130
1112
 
        then throw((K + " is not yours"))
1131
1113
 
        else {
1132
-
            let ge = split(ga.description, "_")
1133
-
            $Tuple4(fZ, az, ge, gc)
1134
-
            }
1135
-
    }
1136
-
1137
-
1138
-
func gf (p,eL,fU,fV) = if ((0 > eL))
1114
+
            let gc = split(fY.description, "_")
1115
+
            $Tuple4(fX, ay, gc, ga)
1116
+
            }
1117
+
    }
1118
+
1119
+
1120
+
func gd (p,eI,fS,fT) = if ((0 > eI))
1139
1121
 
    then throw("Negative amount")
1140
1122
 
    else {
1141
-
        let gg = fT(p, fU, fV)
1142
-
        let bX = gg._3[bL]
1143
-
        let dq = dw(gg._3[bM])
1144
-
        let dA = (lastBlock.timestamp - gg._4)
1145
-
        if ((0 > dA))
1146
-
            then throw(((("Saved timestamp is in future, saved = " + toString(gg._4)) + ", current = ") + toString(lastBlock.timestamp)))
1123
+
        let ge = fR(p, fS, fT)
1124
+
        let bM = ge._3[bA]
1125
+
        let do = du(ge._3[bB])
1126
+
        let dy = (lastBlock.timestamp - ge._4)
1127
+
        if ((0 > dy))
1128
+
            then throw(((("Saved timestamp is in future, saved = " + toString(ge._4)) + ", current = ") + toString(lastBlock.timestamp)))
1147
1129
 
            else {
1148
-
                let fP = bW(bX)
1149
-
                let gh = fO(gg._2, fP)
1150
-
                let gi = fraction(dA, (gh * fP), P)
1151
-
                if ((eL > gi))
1152
-
                    then throw(((("Not enough resources, available = " + toString(gi)) + ", requested = ") + toString(eL)))
1130
+
                let fN = bL(bM)
1131
+
                let gf = fM(ge._2, fN)
1132
+
                let gg = fraction(dy, (gf * fN), P)
1133
+
                if ((eI > gg))
1134
+
                    then throw(((("Not enough resources, available = " + toString(gg)) + ", requested = ") + toString(eI)))
1153
1135
 
                    else {
1154
-
                        let gj = fraction((gi - eL), P, (gh * fP))
1155
-
                        let gk = (lastBlock.timestamp - gj)
1156
-
                        let ex = (fP / bm)
1157
-
                        let dI = dE(dq, (dA - gj), ex, gh)
1158
-
                        let ew = ay(gg._2)
1159
-
                        let ey = valueOrElse(getInteger(as(gg._2)), 0)
1160
-
                        let ei = ev(ew, ex, ey)
1161
-
                        let eE = split(ei[ac], "_")
1162
-
                        let dJ = parseIntValue(eE[af])
1163
-
                        if (if ((fU == cA))
1164
-
                            then (eL > dJ)
1136
+
                        let gh = fraction((gg - eI), P, (gf * fN))
1137
+
                        let gi = (lastBlock.timestamp - gh)
1138
+
                        let eu = (fN / bb)
1139
+
                        let dG = dC(do, (dy - gh), eu, gf)
1140
+
                        let et = ax(ge._2)
1141
+
                        let ev = valueOrElse(getInteger(ar(ge._2)), 0)
1142
+
                        let eg = es(et, eu, ev)
1143
+
                        let eB = split(eg[ad], "_")
1144
+
                        let dH = parseIntValue(eB[ag])
1145
+
                        if (if ((fS == cp))
1146
+
                            then (eI > dH)
1165
1147
 
                            else false)
1166
-
                            then throw((("Only " + toString(dJ)) + " space left in warehouse"))
1148
+
                            then throw((("Only " + toString(dH)) + " space left in warehouse"))
1167
1149
 
                            else {
1168
-
                                let ed = aI(gg._1)
1169
-
                                let eO = ec(ed)
1170
-
                                let dH = split(eO[ai], "_")
1171
-
                                let dG = split(ei[Z], "_")
1172
-
                                let gl = if ((fU == cA))
1173
-
                                    then $Tuple4(dy(dG, dq, (dA - gj), ex, gh), eO[ai], (parseIntValue(eE[ae]) + dI._2), (parseIntValue(eE[af]) - dI._2))
1174
-
                                    else if ((fU == cB))
1175
-
                                        then $Tuple4(ei[Z], dy(dH, dq, (dA - gj), ex, gh), parseIntValue(eE[ae]), parseIntValue(eE[af]))
1150
+
                                let eb = aH(ge._1)
1151
+
                                let eM = ea(eb)
1152
+
                                let dF = split(eM[aj], "_")
1153
+
                                let dE = split(eg[aa], "_")
1154
+
                                let gj = if ((fS == cp))
1155
+
                                    then $Tuple4(dw(dE, do, (dy - gh), eu, gf), eM[aj], (parseIntValue(eB[af]) + dG._2), (parseIntValue(eB[ag]) - dG._2))
1156
+
                                    else if ((fS == cq))
1157
+
                                        then $Tuple4(eg[aa], dw(dF, do, (dy - gh), eu, gf), parseIntValue(eB[af]), parseIntValue(eB[ag]))
1176
1158
 
                                        else {
1177
-
                                            let gm = dF(dG, dH, dI, dJ)
1178
-
                                            let gn = min([parseIntValue(eE[af]), dI._2])
1179
-
                                            $Tuple4(gm._1, gm._2, (parseIntValue(eE[ae]) + gn), (parseIntValue(eE[af]) - gn))
1159
+
                                            let gk = dD(dE, dF, dG, dH)
1160
+
                                            let gl = min([parseIntValue(eB[ag]), dG._2])
1161
+
                                            $Tuple4(gk._1, gk._2, (parseIntValue(eB[af]) + gl), (parseIntValue(eB[ag]) - gl))
1180
1162
 
                                            }
1181
-
                                let go = gl._1
1182
-
                                let gp = gl._2
1183
-
                                let gq = gl._3
1184
-
                                let gr = gl._4
1185
-
                                $Tuple5([IntegerEntry(ar(gg._2), gk), IntegerEntry(av(K, gg._2, p), gk)], ed, [eO[ah], gp, eO[aj], eO[ak]], ew, [ei[Y], go, ei[aa], ei[ab], makeString([eE[ad], toString(gq), toString(gr), eE[ag]], "_")])
1163
+
                                let gm = gj._1
1164
+
                                let gn = gj._2
1165
+
                                let go = gj._3
1166
+
                                let gp = gj._4
1167
+
                                $Tuple5([IntegerEntry(aq(ge._2), gi), IntegerEntry(au(K, ge._2, p), gi)], eb, [eM[ai], gn, eM[ak], eM[al]], et, [eg[Z], gm, eg[ab], eg[ac], makeString([eB[ae], toString(go), toString(gp), eB[ah]], "_")])
1186
1168
 
                                }
1187
1169
 
                        }
1188
1170
 
                }
1189
1171
 
        }
1190
1172
 
1191
1173
 
1192
-
func gs (p,az,fP,fU) = {
1193
-
    let gb = ar(az)
1194
-
    let gc = value(getInteger(gb))
1195
-
    let gi = (fraction((lastBlock.timestamp - gc), fO(az, fP), P) * fP)
1196
-
    gf(p, gi, fU, az)
1197
-
    }
1198
-
1199
-
1200
-
func gt (cU,fl,gu,az) = {
1201
-
    let p = toString(fl)
1202
-
    let gg = fT(p, cC, az)
1203
-
    let fP = bW(gg._3[bL])
1204
-
    let gv = as(gg._2)
1205
-
    let gw = valueOrElse(getInteger(gv), 0)
1206
-
    if ((gw >= 3))
1174
+
func gq (p,ay,fN,fS) = {
1175
+
    let fZ = aq(ay)
1176
+
    let ga = value(getInteger(fZ))
1177
+
    let gg = (fraction((lastBlock.timestamp - ga), fM(ay, fN), P) * fN)
1178
+
    gd(p, gg, fS, ay)
1179
+
    }
1180
+
1181
+
1182
+
func gr (cQ,fj,gs,ay) = {
1183
+
    let p = toString(fj)
1184
+
    let ge = fR(p, cr, ay)
1185
+
    let fN = bL(ge._3[bA])
1186
+
    let gt = ar(ge._2)
1187
+
    let gu = valueOrElse(getInteger(gt), 0)
1188
+
    if ((gu >= 3))
1207
1189
 
        then throw("Currently max infrastructure level = 3")
1208
1190
 
        else {
1209
-
            let J = (gw + 1)
1210
-
            let gx = fraction(cf, (fP * J), bm)
1211
-
            if (if (!(cU))
1212
-
                then (gu != gx)
1191
+
            let J = (gu + 1)
1192
+
            let gv = fraction(bU, (fN * J), bb)
1193
+
            if (if (!(cQ))
1194
+
                then (gs != gv)
1213
1195
 
                else false)
1214
-
                then throw(("Payment attached should be " + toString(gx)))
1196
+
                then throw(("Payment attached should be " + toString(gv)))
1215
1197
 
                else {
1216
-
                    let ed = aI(gg._1)
1217
-
                    let eO = ec(ed)
1218
-
                    let fL = split(eO[aj], "_")
1219
-
                    let gy = fraction(bi, (fP * J), bm)
1220
-
                    let fM = makeString(cT(cU, fL, gy), "_")
1221
-
                    let gz = gs(p, gg._2, fP, cC)
1222
-
                    let gA = gz._5
1223
-
                    let gB = ef(gA[Y])
1224
-
                    let gC = makeString([split(gA[Y], "_")[0], toString(J)], "_")
1225
-
                    let gD = ef(gC)
1226
-
                    let eE = split(gA[ac], "_")
1227
-
                    let gE = makeString([eE[ad], eE[ae], toString(((parseIntValue(eE[af]) + gD) - gB)), toString(gD)], "_")
1228
-
                    $Tuple3(([IntegerEntry(gv, J), IntegerEntry(cu(gg._2, p), J), StringEntry(ed, makeString([eO[ah], gz._3[ai], fM, eO[ak]], ":")), StringEntry(gz._4, makeString([gC, gA[Z], gA[aa], gA[ab], gE], ":"))] ++ gz._1), J, gy)
1198
+
                    let eb = aH(ge._1)
1199
+
                    let eM = ea(eb)
1200
+
                    let fJ = split(eM[ak], "_")
1201
+
                    let gw = fraction(aX, (fN * J), bb)
1202
+
                    let fK = makeString(cP(cQ, fJ, gw), "_")
1203
+
                    let gx = gq(p, ge._2, fN, cr)
1204
+
                    let gy = gx._5
1205
+
                    let gz = ed(gy[Z])
1206
+
                    let gA = makeString([split(gy[Z], "_")[0], toString(J)], "_")
1207
+
                    let gB = ed(gA)
1208
+
                    let eB = split(gy[ad], "_")
1209
+
                    let gC = makeString([eB[ae], eB[af], toString(((parseIntValue(eB[ag]) + gB) - gz)), toString(gB)], "_")
1210
+
                    $Tuple3(([IntegerEntry(gt, J), IntegerEntry(cj(ge._2, p), J), StringEntry(eb, makeString([eM[ai], gx._3[aj], fK, eM[al]], ":")), StringEntry(gx._4, makeString([gA, gy[aa], gy[ab], gy[ac], gC], ":"))] ++ gx._1), J, gw)
1229
1211
 
                    }
1230
1212
 
            }
1231
1213
 
    }
1232
1214
 
1233
1215
 
1234
-
func gF (k,gG) = if (!(bd))
1216
+
func gD (k,gE) = if (!(aS))
1235
1217
 
    then $Tuple2(nil, 0)
1236
1218
 
    else {
1237
-
        let gH = m(k)
1238
-
        let gI = l(k)
1239
-
        let D = valueOrElse(getInteger(bG, gI), 0)
1240
-
        let I = (D + gG)
1241
-
        let gJ = G(valueOrElse(getInteger(bG, gH), 0), I)
1242
-
        let gK = n(k)
1243
-
        $Tuple2([IntegerEntry(gH, gJ[0]), IntegerEntry(gI, I), IntegerEntry(gK, (valueOrElse(getInteger(gK), 0) + gJ[1]))], I)
1219
+
        let gF = m(k)
1220
+
        let gG = l(k)
1221
+
        let D = valueOrElse(getInteger(bv, gG), 0)
1222
+
        let I = (D + gE)
1223
+
        let gH = G(valueOrElse(getInteger(bv, gF), 0), I)
1224
+
        let gI = n(k)
1225
+
        $Tuple2([IntegerEntry(gF, gH[0]), IntegerEntry(gG, I), IntegerEntry(gI, (valueOrElse(getInteger(gI), 0) + gH[1]))], I)
1244
1226
 
        }
1245
1227
 
1246
1228
 
1247
-
func gL (p,gG) = if (!(bd))
1229
+
func gJ (p,gE) = if (!(aS))
1248
1230
 
    then $Tuple2(nil, 0)
1249
1231
 
    else {
1250
-
        let gH = q(p)
1251
-
        let gI = o(p)
1252
-
        let D = valueOrElse(getInteger(bG, gI), 0)
1253
-
        let I = (D + gG)
1254
-
        let gJ = G(valueOrElse(getInteger(bG, gH), 0), I)
1255
-
        let gK = r(p)
1256
-
        $Tuple2([IntegerEntry(gH, gJ[0]), IntegerEntry(gI, I), IntegerEntry(gK, (valueOrElse(getInteger(gK), 0) + gJ[1]))], I)
1232
+
        let gF = q(p)
1233
+
        let gG = o(p)
1234
+
        let D = valueOrElse(getInteger(bv, gG), 0)
1235
+
        let I = (D + gE)
1236
+
        let gH = G(valueOrElse(getInteger(bv, gF), 0), I)
1237
+
        let gI = r(p)
1238
+
        $Tuple2([IntegerEntry(gF, gH[0]), IntegerEntry(gG, I), IntegerEntry(gI, (valueOrElse(getInteger(gI), 0) + gH[1]))], I)
1257
1239
 
        }
1258
1240
 
1259
1241
 
1260
-
func gM (p) = {
1261
-
    let k = valueOrErrorMessage(getString(aH(p)), "You don't have a duck staked")
1262
-
    let gN = aC(p)
1263
-
    let gO = getString(gN)
1264
-
    if (!(isDefined(gO)))
1242
+
func gK (p) = {
1243
+
    let k = valueOrErrorMessage(getString(aG(p)), "You don't have a duck staked")
1244
+
    let gL = aB(p)
1245
+
    let gM = getString(gL)
1246
+
    if (!(isDefined(gM)))
1265
1247
 
        then throw("You are not eligible for ONBOARD artifact")
1266
1248
 
        else {
1267
-
            let gP = aE(p)
1268
-
            let gQ = getString(gP)
1269
-
            if (isDefined(gQ))
1270
-
                then throw(("You already used your ONBOARD artifact on duck " + value(gQ)))
1249
+
            let gN = aD(p)
1250
+
            let gO = getString(gN)
1251
+
            if (isDefined(gO))
1252
+
                then throw(("You already used your ONBOARD artifact on duck " + value(gO)))
1271
1253
 
                else {
1272
-
                    let gR = aD(k)
1273
-
                    let gS = getString(gR)
1274
-
                    if (isDefined(gS))
1275
-
                        then throw(((("The duck " + k) + " already got points from ONBOARD artifact from user ") + value(gS)))
1276
-
                        else ([StringEntry(gP, k), StringEntry(gR, p)] ++ gF(k, A)._1)
1254
+
                    let gP = aC(k)
1255
+
                    let gQ = getString(gP)
1256
+
                    if (isDefined(gQ))
1257
+
                        then throw(((("The duck " + k) + " already got points from ONBOARD artifact from user ") + value(gQ)))
1258
+
                        else ([StringEntry(gN, k), StringEntry(gP, p)] ++ gD(k, A)._1)
1277
1259
 
                    }
1278
1260
 
            }
1279
1261
 
    }
1280
1262
 
1281
1263
 
1282
-
func gT (p,fV) = {
1283
-
    let gg = fT(p, cC, fV)
1284
-
    let az = gg._2
1285
-
    let fP = bW(gg._3[bL])
1286
-
    let gU = at(M, az)
1287
-
    if ((valueOrElse(getInteger(gU), 0) > 0))
1264
+
func gR (p,fT) = {
1265
+
    let ge = fR(p, cr, fT)
1266
+
    let ay = ge._2
1267
+
    let fN = bL(ge._3[bA])
1268
+
    let gS = as(M, ay)
1269
+
    if ((valueOrElse(getInteger(gS), 0) > 0))
1288
1270
 
        then throw("Presale artifact is already activated")
1289
-
        else if ((parseIntValue(gg._3[bK]) > co))
1290
-
            then throw((((K + " ") + az) + " is not eligible for presale artifact"))
1271
+
        else if ((parseIntValue(ge._3[bz]) > cd))
1272
+
            then throw((((K + " ") + ay) + " is not eligible for presale artifact"))
1291
1273
 
            else {
1292
-
                let gz = gs(p, az, fP, cC)
1293
-
                ((((gz._1 :+ IntegerEntry(gU, fP)) :+ IntegerEntry(cv(M, az, p), fP)) :+ StringEntry(gz._2, makeString(gz._3, ":"))) :+ StringEntry(gz._4, makeString(gz._5, ":")))
1274
+
                let gx = gq(p, ay, fN, cr)
1275
+
                ((((gx._1 :+ IntegerEntry(gS, fN)) :+ IntegerEntry(ck(M, ay, p), fN)) :+ StringEntry(gx._2, makeString(gx._3, ":"))) :+ StringEntry(gx._4, makeString(gx._5, ":")))
1294
1276
 
                }
1295
1277
 
    }
1296
1278
 
1297
1279
 
1298
-
func gV (gW,J,gX,p,gY,fm,gZ) = {
1299
-
    let k = valueOrErrorMessage(getString(aH(p)), "You don't have a duck staked")
1300
-
    func ha (cO,az) =     {
1301
-
        let ga = value(assetInfo(fromBase58String(az)))
1302
-
        let gb = ar(az)
1303
-
        let gc = valueOrErrorMessage(getInteger(gb), (("NFT " + ga.name) + " is not staked"))
1304
-
        let gd = valueOrErrorMessage(getString(ao(az)), (("NFT " + ga.name) + " is orphaned"))
1305
-
        if ((gd != p))
1280
+
func gT (gU,J,gV,p,gW,fk,gX) = {
1281
+
    let k = valueOrErrorMessage(getString(aG(p)), "You don't have a duck staked")
1282
+
    func gY (cD,ay) =     {
1283
+
        let fY = value(assetInfo(fromBase58String(ay)))
1284
+
        let fZ = aq(ay)
1285
+
        let ga = valueOrErrorMessage(getInteger(fZ), (("NFT " + fY.name) + " is not staked"))
1286
+
        let gb = valueOrErrorMessage(getString(an(ay)), (("NFT " + fY.name) + " is orphaned"))
1287
+
        if ((gb != p))
1306
1288
 
            then throw((K + " is not yours"))
1307
1289
 
            else {
1308
-
                let ge = split(ga.description, "_")
1309
-
                let fp = ge[bN]
1310
-
                if (if ((cO._3 != ""))
1311
-
                    then (cO._3 != fp)
1290
+
                let gc = split(fY.description, "_")
1291
+
                let fn = gc[bC]
1292
+
                if (if ((cD._3 != ""))
1293
+
                    then (cD._3 != fn)
1312
1294
 
                    else false)
1313
1295
 
                    then throw("Lands should be on the same continent to merge")
1314
1296
 
                    else {
1315
-
                        let bX = ge[bL]
1316
-
                        let hb = cO._1
1317
-
                        let du = valueOrErrorMessage(indexOf(hb, bX), "You haven't passed all the lands needed")
1318
-
                        let hc = (take(hb, du) + drop(hb, (du + 1)))
1319
-
                        let fP = bW(bX)
1320
-
                        let hd = (cO._2 + valueOrElse(getInteger(at(M, az)), 0))
1321
-
                        let ey = valueOrElse(getInteger(as(az)), 0)
1322
-
                        let he = {
1323
-
                            let bg = bX
1324
-
                            if (("S" == bg))
1297
+
                        let bM = gc[bA]
1298
+
                        let gZ = cD._1
1299
+
                        let ds = valueOrErrorMessage(indexOf(gZ, bM), "You haven't passed all the lands needed")
1300
+
                        let ha = (take(gZ, ds) + drop(gZ, (ds + 1)))
1301
+
                        let fN = bL(bM)
1302
+
                        let hb = (cD._2 + valueOrElse(getInteger(as(M, ay)), 0))
1303
+
                        let ev = valueOrElse(getInteger(ar(ay)), 0)
1304
+
                        let hc = {
1305
+
                            let aV = bM
1306
+
                            if (("S" == aV))
1325
1307
 
                                then 3
1326
-
                                else if (("M" == bg))
1308
+
                                else if (("M" == aV))
1327
1309
 
                                    then 4
1328
-
                                    else if (("L" == bg))
1310
+
                                    else if (("L" == aV))
1329
1311
 
                                        then 5
1330
-
                                        else if (("XL" == bg))
1312
+
                                        else if (("XL" == aV))
1331
1313
 
                                            then 6
1332
1314
 
                                            else throw("Only S, M, L, XL can merge")
1333
1315
 
                            }
1334
-
                        if ((ey != he))
1316
+
                        if ((ev != hc))
1335
1317
 
                            then throw("All lands should be maxed to merge")
1336
1318
 
                            else {
1337
-
                                let cr = ge[bK]
1338
-
                                let dq = dw(ge[bM])
1339
-
                                let dA = (lastBlock.timestamp - gc)
1340
-
                                if ((0 > dA))
1341
-
                                    then throw(((("Saved timestamp is in future, saved = " + toString(gc)) + ", current = ") + toString(lastBlock.timestamp)))
1319
+
                                let cg = gc[bz]
1320
+
                                let do = du(gc[bB])
1321
+
                                let dy = (lastBlock.timestamp - ga)
1322
+
                                if ((0 > dy))
1323
+
                                    then throw(((("Saved timestamp is in future, saved = " + toString(ga)) + ", current = ") + toString(lastBlock.timestamp)))
1342
1324
 
                                    else {
1343
-
                                        let gh = fO(az, fP)
1344
-
                                        let ex = (fP / bm)
1345
-
                                        let gp = dy(split(cO._4, "_"), dq, dA, ex, gh)
1346
-
                                        let cR = do(split(cO._6, "_"), dq, ex, -1)
1347
-
                                        let hf = cO._7
1348
-
                                        let bE = indexOf(hf, az)
1349
-
                                        if (!(isDefined(bE)))
1350
-
                                            then throw(("Your staked lands don't contain " + az))
1325
+
                                        let gf = fM(ay, fN)
1326
+
                                        let eu = (fN / bb)
1327
+
                                        let gn = dw(split(cD._4, "_"), do, dy, eu, gf)
1328
+
                                        let cN = dm(split(cD._6, "_"), do, eu, -1)
1329
+
                                        let hd = cD._7
1330
+
                                        let bt = indexOf(hd, ay)
1331
+
                                        if (!(isDefined(bt)))
1332
+
                                            then throw(("Your staked lands don't contain " + ay))
1351
1333
 
                                            else {
1352
-
                                                let hg = aq(az)
1353
-
                                                let hh = valueOrElse(getString(hg), "")
1354
-
                                                $Tuple8(hc, hd, fp, gp, (((((((((((((cO._5 :+ DeleteEntry(ar(az))) :+ DeleteEntry(av(K, az, p))) :+ DeleteEntry(cq(cr))) :+ DeleteEntry(ao(az))) :+ DeleteEntry(as(az))) :+ DeleteEntry(cu(az, p))) :+ DeleteEntry(at(M, az))) :+ DeleteEntry(cv(M, az, p))) :+ DeleteEntry(cw(cr))) :+ DeleteEntry(ay(az))) :+ DeleteEntry(hg)) :+ DeleteEntry(cs(hh))) :+ Burn(fromBase58String(az), 1)), cR, removeByIndex(hf, value(bE)), (cO._8 + fP))
1334
+
                                                let he = ap(ay)
1335
+
                                                let hf = valueOrElse(getString(he), "")
1336
+
                                                $Tuple8(ha, hb, fn, gn, (((((((((((((cD._5 :+ DeleteEntry(aq(ay))) :+ DeleteEntry(au(K, ay, p))) :+ DeleteEntry(cf(cg))) :+ DeleteEntry(an(ay))) :+ DeleteEntry(ar(ay))) :+ DeleteEntry(cj(ay, p))) :+ DeleteEntry(as(M, ay))) :+ DeleteEntry(ck(M, ay, p))) :+ DeleteEntry(cl(cg))) :+ DeleteEntry(ax(ay))) :+ DeleteEntry(he)) :+ DeleteEntry(ch(hf))) :+ Burn(fromBase58String(ay), 1)), cN, removeByIndex(hd, value(bt)), (cD._8 + fN))
1355
1337
 
                                                }
1356
1338
 
                                        }
1357
1339
 
                                }
1359
1341
 
                }
1360
1342
 
        }
1361
1343
 
1362
-
    let ed = aI(k)
1363
-
    let eO = ec(ed)
1364
-
    let hi = valueOrElse(getString(bO()), "0_0_0_0_0_0")
1365
-
    let hj = bP(p)
1366
-
    let hk = getString(hj)
1367
-
    let hl = if (isDefined(hk))
1368
-
        then split_51C(value(hk), "_")
1344
+
    let eb = aH(k)
1345
+
    let eM = ea(eb)
1346
+
    let hg = valueOrElse(getString(bD()), "0_0_0_0_0_0")
1347
+
    let hh = bE(p)
1348
+
    let hi = getString(hh)
1349
+
    let hj = if (isDefined(hi))
1350
+
        then split_51C(value(hi), "_")
1369
1351
 
        else nil
1370
-
    let cS = {
1371
-
        let aW = gY
1372
-
        let aX = size(aW)
1373
-
        let aY = $Tuple8(gX, 0, "", eO[ai], nil, hi, hl, 0)
1374
-
        func aZ (ba,bb) =         if ((bb >= aX))
1375
-
            then ba
1376
-
            else ha(ba, aW[bb])
1377
-
1378
-
        func bc (ba,bb) =         if ((bb >= aX))
1379
-
            then ba
1352
+
    let cO = {
1353
+
        let cF = gW
1354
+
        let cG = size(cF)
1355
+
        let cH = $Tuple8(gV, 0, "", eM[aj], nil, hg, hj, 0)
1356
+
        func cI (cJ,cK) =         if ((cK >= cG))
1357
+
            then cJ
1358
+
            else gY(cJ, cF[cK])
1359
+
1360
+
        func cL (cJ,cK) =         if ((cK >= cG))
1361
+
            then cJ
1380
1362
 
            else throw("List size exceeds 5")
1381
1363
 
1382
-
        bc(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5)
1364
+
        cL(cI(cI(cI(cI(cI(cH, 0), 1), 2), 3), 4), 5)
1383
1365
 
        }
1384
-
    let fp = cS._3
1385
-
    let dY = valueOrErrorMessage(indexOf(V, fp), ("Unknown continent: " + fp))
1386
-
    let dx = dW(dP(toBigInt(fm)), dY)
1387
-
    let fo = valueOrElse(getInteger(cp()), (co + 1))
1388
-
    let hm = toString(fo)
1389
-
    let fq = Issue(cH(hm, gW), makeString([hm, gW, dx, fp], "_"), 1, 0, false)
1390
-
    let ap = calculateAssetId(fq)
1391
-
    let hn = toBase58String(ap)
1392
-
    let fM = makeString(cT((gZ > 0), split(eO[aj], "_"), gZ), "_")
1393
-
    let ho = bQ(p)
1394
-
    let hp = valueOrElse(getInteger(ho), 0)
1395
-
    $Tuple2((((((((((((((((cS._5 :+ (if ((size(cS._7) > 0))
1396
-
        then StringEntry(hj, makeString_11C(cS._7, "_"))
1397
-
        else DeleteEntry(hj))) :+ IntegerEntry(ho, if ((cS._8 > hp))
1366
+
    let fn = cO._3
1367
+
    let dW = valueOrErrorMessage(indexOf(V, fn), ("Unknown continent: " + fn))
1368
+
    let dv = dU(dN(toBigInt(fk)), dW)
1369
+
    let fm = valueOrElse(getInteger(ce()), (cd + 1))
1370
+
    let hk = toString(fm)
1371
+
    let fo = Issue(cw(hk, gU), makeString([hk, gU, dv, fn], "_"), 1, 0, false)
1372
+
    let ao = calculateAssetId(fo)
1373
+
    let hl = toBase58String(ao)
1374
+
    let fK = makeString(cP((gX > 0), split(eM[ak], "_"), gX), "_")
1375
+
    let hm = bF(p)
1376
+
    let hn = valueOrElse(getInteger(hm), 0)
1377
+
    $Tuple2((((((((((((((((cO._5 :+ (if ((size(cO._7) > 0))
1378
+
        then StringEntry(hh, makeString_11C(cO._7, "_"))
1379
+
        else DeleteEntry(hh))) :+ IntegerEntry(hm, if ((cO._8 > hn))
1398
1380
 
        then 0
1399
-
        else (hp - cS._8))) :+ IntegerEntry(cp(), (fo + 1))) :+ fq) :+ StringEntry(cq(hm), hn)) :+ StringEntry(ao(hn), p)) :+ StringEntry(cw(hm), p)) :+ IntegerEntry(at(M, hn), cS._2)) :+ IntegerEntry(cv(M, hn, p), cS._2)) :+ IntegerEntry(as(hn), J)) :+ IntegerEntry(cu(hn, p), J)) :+ StringEntry(ed, makeString([eO[ah], cS._4, fM, eO[ak]], ":"))) :+ StringEntry(bO(), cS._6)) :+ StringEntry(aJ(k), makeString([fp, "L", hn], "_"))) :+ ScriptTransfer(addressFromStringValue(p), 1, ap)), hn)
1400
-
    }
1401
-
1402
-
1403
-
func hq (p,gY,fm) = gV("M", 3, "SSSS", p, gY, fm, 0)
1404
-
1405
-
1406
-
func hr (p,gY,fm,cU,gu) = {
1407
-
    let gx = (cf * 4)
1408
-
    if (if (!(cU))
1409
-
        then (gu != gx)
1381
+
        else (hn - cO._8))) :+ IntegerEntry(ce(), (fm + 1))) :+ fo) :+ StringEntry(cf(hk), hl)) :+ StringEntry(an(hl), p)) :+ StringEntry(cl(hk), p)) :+ IntegerEntry(as(M, hl), cO._2)) :+ IntegerEntry(ck(M, hl, p), cO._2)) :+ IntegerEntry(ar(hl), J)) :+ IntegerEntry(cj(hl, p), J)) :+ StringEntry(eb, makeString([eM[ai], cO._4, fK, eM[al]], ":"))) :+ StringEntry(bD(), cO._6)) :+ StringEntry(aI(k), makeString([fn, "L", hl], "_"))) :+ ScriptTransfer(addressFromStringValue(p), 1, ao)), hl)
1382
+
    }
1383
+
1384
+
1385
+
func ho (p,gW,fk) = gT("M", 3, "SSSS", p, gW, fk, 0)
1386
+
1387
+
1388
+
func hp (p,gW,fk,cQ,gs) = {
1389
+
    let gv = (bU * 4)
1390
+
    if (if (!(cQ))
1391
+
        then (gs != gv)
1410
1392
 
        else false)
1411
-
        then throw(("Payment attached should be " + toString(gx)))
1412
-
        else gV("L", 4, "SMM", p, gY, fm, (bi * 4))
1413
-
    }
1414
-
1415
-
1416
-
func hs (p,gY,fm,cU,gu) = {
1417
-
    let gx = (cf * 47)
1418
-
    if (if (!(cU))
1419
-
        then (gu != gx)
1393
+
        then throw(("Payment attached should be " + toString(gv)))
1394
+
        else gT("L", 4, "SMM", p, gW, fk, (aX * 4))
1395
+
    }
1396
+
1397
+
1398
+
func hq (p,gW,fk,cQ,gs) = {
1399
+
    let gv = (bU * 47)
1400
+
    if (if (!(cQ))
1401
+
        then (gs != gv)
1420
1402
 
        else false)
1421
-
        then throw(("Payment attached should be " + toString(gx)))
1422
-
        else gV("XL", 5, "SSSML", p, gY, fm, (bi * 47))
1423
-
    }
1424
-
1425
-
1426
-
func ht (p,gY,fm,cU,gu) = {
1427
-
    let gx = (cf * 54)
1428
-
    if (if (!(cU))
1429
-
        then (gu != gx)
1403
+
        then throw(("Payment attached should be " + toString(gv)))
1404
+
        else gT("XL", 5, "SSSML", p, gW, fk, (aX * 47))
1405
+
    }
1406
+
1407
+
1408
+
func hr (p,gW,fk,cQ,gs) = {
1409
+
    let gv = (bU * 54)
1410
+
    if (if (!(cQ))
1411
+
        then (gs != gv)
1430
1412
 
        else false)
1431
-
        then throw(("Payment attached should be " + toString(gx)))
1432
-
        else gV("XXL", 6, "LXL", p, gY, fm, (bi * 54))
1433
-
    }
1434
-
1435
-
1436
-
func hu (cU,p,gu,gY,fm) = {
1437
-
    let hv = {
1438
-
        let bg = size(gY)
1439
-
        if ((4 == bg))
1440
-
            then hq(p, gY, fm)
1441
-
            else if ((3 == bg))
1442
-
                then hr(p, gY, fm, cU, gu)
1443
-
                else if ((5 == bg))
1444
-
                    then hs(p, gY, fm, cU, gu)
1445
-
                    else if ((2 == bg))
1446
-
                        then ht(p, gY, fm, cU, gu)
1413
+
        then throw(("Payment attached should be " + toString(gv)))
1414
+
        else gT("XXL", 6, "LXL", p, gW, fk, (aX * 54))
1415
+
    }
1416
+
1417
+
1418
+
func hs (cQ,p,gs,gW,fk) = {
1419
+
    let ht = {
1420
+
        let aV = size(gW)
1421
+
        if ((4 == aV))
1422
+
            then ho(p, gW, fk)
1423
+
            else if ((3 == aV))
1424
+
                then hp(p, gW, fk, cQ, gs)
1425
+
                else if ((5 == aV))
1426
+
                    then hq(p, gW, fk, cQ, gs)
1427
+
                    else if ((2 == aV))
1428
+
                        then hr(p, gW, fk, cQ, gs)
1447
1429
 
                        else throw("Unknown merge")
1448
1430
 
        }
1449
-
    hv
1450
-
    }
1451
-
1452
-
1453
-
func hw (du) = if (if ((du.originCaller != bF))
1454
-
    then valueOrElse(getBoolean(aL()), false)
1431
+
    ht
1432
+
    }
1433
+
1434
+
1435
+
func hu (ds) = if (if ((ds.originCaller != bu))
1436
+
    then valueOrElse(getBoolean(aK()), false)
1455
1437
 
    else false)
1456
1438
 
    then throw("Contracts are under maintenance")
1457
-
    else StringEntry(an(toString(du.originCaller)), toBase58String(du.transactionId))
1458
-
1459
-
1460
-
@Callable(du)
1461
-
func constructorV1 (hx) = if ((du.caller != this))
1439
+
    else StringEntry(am(toString(ds.originCaller)), toBase58String(ds.transactionId))
1440
+
1441
+
1442
+
@Callable(ds)
1443
+
func constructorV1 (hv) = if ((ds.caller != this))
1462
1444
 
    then throw("Permission denied")
1463
-
    else [StringEntry(bz(), hx)]
1464
-
1465
-
1466
-
1467
-
@Callable(du)
1468
-
func setBlocked (hy) = if ((du.caller != this))
1445
+
    else [StringEntry(bo(), hv)]
1446
+
1447
+
1448
+
1449
+
@Callable(ds)
1450
+
func setBlocked (hw) = if ((ds.caller != this))
1469
1451
 
    then throw("permission denied")
1470
-
    else [BooleanEntry(aL(), hy)]
1471
-
1472
-
1473
-
1474
-
@Callable(du)
1452
+
    else [BooleanEntry(aK(), hw)]
1453
+
1454
+
1455
+
1456
+
@Callable(ds)
1475
1457
 
func stakeLand () = {
1476
-
    let hz = hw(du)
1477
-
    if ((size(du.payments) != 1))
1458
+
    let hx = hu(ds)
1459
+
    if ((size(ds.payments) != 1))
1478
1460
 
        then throw("Exactly one payment required")
1479
1461
 
        else {
1480
-
            let hA = value(du.payments[0])
1481
-
            let ap = value(hA.assetId)
1482
-
            let bs = toString(du.caller)
1483
-
            if ((hA.amount != 1))
1462
+
            let hy = value(ds.payments[0])
1463
+
            let ao = value(hy.assetId)
1464
+
            let bh = toString(ds.caller)
1465
+
            if ((hy.amount != 1))
1484
1466
 
                then throw((("NFT " + K) + " token should be attached as payment"))
1485
1467
 
                else {
1486
-
                    let ga = value(assetInfo(ap))
1487
-
                    if ((ga.issuer != this))
1468
+
                    let fY = value(assetInfo(ao))
1469
+
                    if ((fY.issuer != this))
1488
1470
 
                        then throw("Unknown issuer of token")
1489
-
                        else if (!(contains(ga.name, K)))
1471
+
                        else if (!(contains(fY.name, K)))
1490
1472
 
                            then throw((("Only NFT " + K) + " tokens are accepted"))
1491
1473
 
                            else {
1492
-
                                let hB = drop(ga.name, 4)
1493
-
                                let cr = if (contains(hB, "XXL"))
1494
-
                                    then dropRight(hB, 3)
1495
-
                                    else if (contains(hB, "XL"))
1496
-
                                        then dropRight(hB, 2)
1497
-
                                        else dropRight(hB, 1)
1498
-
                                if (!(isDefined(parseInt(cr))))
1499
-
                                    then throw(("Cannot parse land number from " + ga.name))
1474
+
                                let hz = drop(fY.name, 4)
1475
+
                                let cg = if (contains(hz, "XXL"))
1476
+
                                    then dropRight(hz, 3)
1477
+
                                    else if (contains(hz, "XL"))
1478
+
                                        then dropRight(hz, 2)
1479
+
                                        else dropRight(hz, 1)
1480
+
                                if (!(isDefined(parseInt(cg))))
1481
+
                                    then throw(("Cannot parse land number from " + fY.name))
1500
1482
 
                                    else {
1501
-
                                        let az = toBase58String(ap)
1502
-
                                        let gb = ar(az)
1503
-
                                        if (isDefined(getInteger(gb)))
1504
-
                                            then throw((("NFT " + ga.name) + " is already staked"))
1483
+
                                        let ay = toBase58String(ao)
1484
+
                                        let fZ = aq(ay)
1485
+
                                        if (isDefined(getInteger(fZ)))
1486
+
                                            then throw((("NFT " + fY.name) + " is already staked"))
1505
1487
 
                                            else {
1506
-
                                                let ge = split(ga.description, "_")
1507
-
                                                let dq = dw(ge[bM])
1508
-
                                                let fP = bW(ge[bL])
1509
-
                                                let cR = dv(dq, (fP / bm), 1)
1510
-
                                                let fQ = valueOrElse(getInteger(at(M, az)), 0)
1511
-
                                                let hj = bP(bs)
1512
-
                                                let hk = getString(hj)
1513
-
                                                let hf = if (isDefined(hk))
1514
-
                                                    then split_51C(value(hk), "_")
1488
+
                                                let gc = split(fY.description, "_")
1489
+
                                                let do = du(gc[bB])
1490
+
                                                let fN = bL(gc[bA])
1491
+
                                                let cN = dt(do, (fN / bb), 1)
1492
+
                                                let fO = valueOrElse(getInteger(as(M, ay)), 0)
1493
+
                                                let hh = bE(bh)
1494
+
                                                let hi = getString(hh)
1495
+
                                                let hd = if (isDefined(hi))
1496
+
                                                    then split_51C(value(hi), "_")
1515
1497
 
                                                    else nil
1516
-
                                                if (containsElement(hf, az))
1517
-
                                                    then throw(("Your staked lands already contain " + az))
1498
+
                                                if (containsElement(hd, ay))
1499
+
                                                    then throw(("Your staked lands already contain " + ay))
1518
1500
 
                                                    else {
1519
-
                                                        let ey = valueOrElse(getInteger(as(az)), 0)
1520
-
                                                        let ho = bQ(bs)
1521
-
                                                        let hC = valueOrElse(getInteger(ho), 0)
1522
-
                                                        let hD = bU(invoke(bJ, "onStakeLand", [bs], nil))
1523
-
                                                        $Tuple2([IntegerEntry(gb, lastBlock.timestamp), IntegerEntry(av(K, az, bs), lastBlock.timestamp), StringEntry(hj, makeString_11C((hf :+ az), "_")), IntegerEntry(ho, (hC + fP)), StringEntry(ao(az), bs), StringEntry(cw(cr), bs), IntegerEntry(cv(M, az, bs), fQ), IntegerEntry(cu(az, bs), ey), StringEntry(bO(), cR), hz], hD)
1501
+
                                                        let ev = valueOrElse(getInteger(ar(ay)), 0)
1502
+
                                                        let hm = bF(bh)
1503
+
                                                        let hA = valueOrElse(getInteger(hm), 0)
1504
+
                                                        let hB = bJ(invoke(by, "onStakeLand", [bh], nil))
1505
+
                                                        $Tuple2([IntegerEntry(fZ, lastBlock.timestamp), IntegerEntry(au(K, ay, bh), lastBlock.timestamp), StringEntry(hh, makeString_11C((hd :+ ay), "_")), IntegerEntry(hm, (hA + fN)), StringEntry(an(ay), bh), StringEntry(cl(cg), bh), IntegerEntry(ck(M, ay, bh), fO), IntegerEntry(cj(ay, bh), ev), StringEntry(bD(), cN), hx], hB)
1524
1506
 
                                                        }
1525
1507
 
                                                }
1526
1508
 
                                        }
1531
1513
 
1532
1514
 
1533
1515
 
1534
-
@Callable(du)
1535
-
func unstakeLand (fV) = {
1536
-
    let hz = hw(du)
1537
-
    if ((size(du.payments) != 0))
1516
+
@Callable(ds)
1517
+
func unstakeLand (fT) = {
1518
+
    let hx = hu(ds)
1519
+
    if ((size(ds.payments) != 0))
1538
1520
 
        then throw("No payments required")
1539
1521
 
        else {
1540
-
            let p = toString(du.caller)
1541
-
            let gg = fT(p, cB, fV)
1542
-
            let az = gg._2
1543
-
            let hj = bP(p)
1544
-
            let dq = dw(gg._3[bM])
1545
-
            let fP = bW(gg._3[bL])
1546
-
            let cR = dv(dq, (fP / bm), -1)
1547
-
            let gz = gs(p, az, fP, cB)
1548
-
            let hf = split_51C(valueOrElse(getString(hj), ""), "_")
1549
-
            let bE = indexOf(hf, az)
1550
-
            if (!(isDefined(bE)))
1551
-
                then throw(("Your staked lands don't contain " + az))
1522
+
            let p = toString(ds.caller)
1523
+
            let ge = fR(p, cq, fT)
1524
+
            let ay = ge._2
1525
+
            let hh = bE(p)
1526
+
            let do = du(ge._3[bB])
1527
+
            let fN = bL(ge._3[bA])
1528
+
            let cN = dt(do, (fN / bb), -1)
1529
+
            let gx = gq(p, ay, fN, cq)
1530
+
            let hd = split_51C(valueOrElse(getString(hh), ""), "_")
1531
+
            let bt = indexOf(hd, ay)
1532
+
            if (!(isDefined(bt)))
1533
+
                then throw(("Your staked lands don't contain " + ay))
1552
1534
 
                else {
1553
-
                    let eb = value(blockInfoByHeight(height)).timestamp
1554
-
                    let hE = valueOrElse(getInteger(bI, aM(p)), 0)
1555
-
                    if ((hE >= eb))
1556
-
                        then throw(("Your gWL are taking part in voting, cannot unstake until " + toString(hE)))
1535
+
                    let dZ = value(blockInfoByHeight(height)).timestamp
1536
+
                    let hC = valueOrElse(getInteger(bx, aL(p)), 0)
1537
+
                    if ((hC >= dZ))
1538
+
                        then throw(("Your gWL are taking part in voting, cannot unstake until " + toString(hC)))
1557
1539
 
                        else {
1558
-
                            let ho = bQ(p)
1559
-
                            let hp = valueOrElse(getInteger(ho), 0)
1560
-
                            let hF = if ((fP > hp))
1540
+
                            let hm = bF(p)
1541
+
                            let hn = valueOrElse(getInteger(hm), 0)
1542
+
                            let hD = if ((fN > hn))
1561
1543
 
                                then 0
1562
-
                                else (hp - fP)
1563
-
                            let hD = bU(invoke(bJ, "onUnstakeLand", [p], nil))
1564
-
                            $Tuple2([ScriptTransfer(du.caller, 1, fromBase58String(az)), DeleteEntry(ar(az)), DeleteEntry(av(K, az, p)), StringEntry(bO(), cR), StringEntry(gz._2, makeString(gz._3, ":")), if ((size(hf) > 1))
1565
-
                                then StringEntry(hj, makeString_11C(removeByIndex(hf, value(bE)), "_"))
1566
-
                                else DeleteEntry(hj), IntegerEntry(ho, hF), hz], hD)
1544
+
                                else (hn - fN)
1545
+
                            let hB = bJ(invoke(by, "onUnstakeLand", [p], nil))
1546
+
                            $Tuple2([ScriptTransfer(ds.caller, 1, fromBase58String(ay)), DeleteEntry(aq(ay)), DeleteEntry(au(K, ay, p)), StringEntry(bD(), cN), StringEntry(gx._2, makeString(gx._3, ":")), if ((size(hd) > 1))
1547
+
                                then StringEntry(hh, makeString_11C(removeByIndex(hd, value(bt)), "_"))
1548
+
                                else DeleteEntry(hh), IntegerEntry(hm, hD), hx], hB)
1567
1549
 
                            }
1568
1550
 
                    }
1569
1551
 
            }
1571
1553
 
1572
1554
 
1573
1555
 
1574
-
@Callable(du)
1556
+
@Callable(ds)
1575
1557
 
func stakeDuck () = {
1576
-
    let hz = hw(du)
1577
-
    if ((size(du.payments) != 1))
1558
+
    let hx = hu(ds)
1559
+
    if ((size(ds.payments) != 1))
1578
1560
 
        then throw("Exactly one payment required")
1579
1561
 
        else {
1580
-
            let hA = value(du.payments[0])
1581
-
            let ap = value(hA.assetId)
1582
-
            let bs = toString(du.caller)
1583
-
            if ((hA.amount != 1))
1562
+
            let hy = value(ds.payments[0])
1563
+
            let ao = value(hy.assetId)
1564
+
            let bh = toString(ds.caller)
1565
+
            if ((hy.amount != 1))
1584
1566
 
                then throw((("NFT " + L) + " token should be attached as payment"))
1585
1567
 
                else {
1586
-
                    let ga = value(assetInfo(ap))
1587
-
                    if (if ((ga.issuer != bY))
1588
-
                        then (ga.issuer != bZ)
1568
+
                    let fY = value(assetInfo(ao))
1569
+
                    if (if ((fY.issuer != bN))
1570
+
                        then (fY.issuer != bO)
1589
1571
 
                        else false)
1590
1572
 
                        then throw((("Unknown issuer of " + L) + " token"))
1591
-
                        else if (!(contains(ga.name, L)))
1573
+
                        else if (!(contains(fY.name, L)))
1592
1574
 
                            then throw((("Only NFT " + L) + " tokens are accepted"))
1593
1575
 
                            else {
1594
-
                                let hG = toBase58String(ap)
1595
-
                                let gb = ar(hG)
1596
-
                                if (isDefined(getInteger(gb)))
1597
-
                                    then throw((("NFT " + ga.name) + " is already staked"))
1598
-
                                    else if (isDefined(getString(aH(bs))))
1599
-
                                        then throw(("You already staked one duck: " + ga.name))
1576
+
                                let hE = toBase58String(ao)
1577
+
                                let fZ = aq(hE)
1578
+
                                if (isDefined(getInteger(fZ)))
1579
+
                                    then throw((("NFT " + fY.name) + " is already staked"))
1580
+
                                    else if (isDefined(getString(aG(bh))))
1581
+
                                        then throw(("You already staked one duck: " + fY.name))
1600
1582
 
                                        else {
1601
-
                                            let hH = aJ(hG)
1602
-
                                            let hI = getString(hH)
1603
-
                                            let ed = aI(hG)
1604
-
                                            let hJ = getString(ed)
1605
-
                                            let fE = aK(hG)
1606
-
                                            let fF = E(valueOrElse(getInteger(m(hG)), 0))
1607
-
                                            let hK = valueOrElse(getInteger(fE), fF)
1608
-
                                            ([IntegerEntry(gb, lastBlock.timestamp), IntegerEntry(av(L, toBase58String(ap), bs), lastBlock.timestamp), StringEntry(aG(hG), bs), StringEntry(aH(bs), hG)] ++ (if (isDefined(hI))
1583
+
                                            let hF = aI(hE)
1584
+
                                            let hG = getString(hF)
1585
+
                                            let eb = aH(hE)
1586
+
                                            let hH = getString(eb)
1587
+
                                            let fC = aJ(hE)
1588
+
                                            let fD = E(valueOrElse(getInteger(m(hE)), 0))
1589
+
                                            let hI = valueOrElse(getInteger(fC), fD)
1590
+
                                            ([IntegerEntry(fZ, lastBlock.timestamp), IntegerEntry(au(L, toBase58String(ao), bh), lastBlock.timestamp), StringEntry(aF(hE), bh), StringEntry(aG(bh), hE)] ++ (if (isDefined(hG))
1609
1591
 
                                                then nil
1610
-
                                                else ([StringEntry(hH, R)] ++ (if (isDefined(hJ))
1592
+
                                                else ([StringEntry(hF, R)] ++ (if (isDefined(hH))
1611
1593
 
                                                    then nil
1612
-
                                                    else (([StringEntry(ed, "0:0_0_0_0_0_0:0_0_0_0_0_0:")] :+ IntegerEntry(fE, hK)) :+ hz)))))
1594
+
                                                    else (([StringEntry(eb, "0:0_0_0_0_0_0:0_0_0_0_0_0:")] :+ IntegerEntry(fC, hI)) :+ hx)))))
1613
1595
 
                                            }
1614
1596
 
                                }
1615
1597
 
                    }
1618
1600
 
1619
1601
 
1620
1602
 
1621
-
@Callable(du)
1622
-
func unstakeDuck (hG) = {
1623
-
    let hz = hw(du)
1624
-
    if ((size(du.payments) != 0))
1603
+
@Callable(ds)
1604
+
func unstakeDuck (hE) = {
1605
+
    let hx = hu(ds)
1606
+
    if ((size(ds.payments) != 0))
1625
1607
 
        then throw("No payments required")
1626
1608
 
        else {
1627
-
            let ap = fromBase58String(hG)
1628
-
            let bs = toString(du.caller)
1629
-
            let ga = value(assetInfo(ap))
1630
-
            let gb = ar(toBase58String(ap))
1631
-
            if (!(isDefined(getInteger(gb))))
1632
-
                then throw((("NFT " + ga.name) + " is not staked"))
1633
-
                else if (!(isDefined(getString(aH(bs)))))
1634
-
                    then throw((("The duck " + ga.name) + " is not staked"))
1609
+
            let ao = fromBase58String(hE)
1610
+
            let bh = toString(ds.caller)
1611
+
            let fY = value(assetInfo(ao))
1612
+
            let fZ = aq(toBase58String(ao))
1613
+
            if (!(isDefined(getInteger(fZ))))
1614
+
                then throw((("NFT " + fY.name) + " is not staked"))
1615
+
                else if (!(isDefined(getString(aG(bh)))))
1616
+
                    then throw((("The duck " + fY.name) + " is not staked"))
1635
1617
 
                    else {
1636
-
                        let gd = valueOrErrorMessage(getString(aG(toBase58String(ap))), (("NFT " + ga.name) + " is orphaned"))
1637
-
                        if ((gd != bs))
1618
+
                        let gb = valueOrErrorMessage(getString(aF(toBase58String(ao))), (("NFT " + fY.name) + " is orphaned"))
1619
+
                        if ((gb != bh))
1638
1620
 
                            then throw("Staked NFT is not yours")
1639
1621
 
                            else {
1640
-
                                let fE = aK(hG)
1641
-
                                let fF = E(valueOrElse(getInteger(m(hG)), 0))
1642
-
                                let hL = valueOrElse(getInteger(fE), fF)
1643
-
                                if ((fF > hL))
1644
-
                                    then throw((("Please heal your duck to " + toString(fF)) + "hp before unstaking"))
1645
-
                                    else [ScriptTransfer(du.caller, 1, ap), DeleteEntry(gb), DeleteEntry(fE), DeleteEntry(aJ(hG)), DeleteEntry(aG(hG)), DeleteEntry(av(L, hG, bs)), DeleteEntry(aH(bs)), hz]
1622
+
                                let fC = aJ(hE)
1623
+
                                let fD = E(valueOrElse(getInteger(m(hE)), 0))
1624
+
                                let hJ = valueOrElse(getInteger(fC), fD)
1625
+
                                if ((fD > hJ))
1626
+
                                    then throw((("Please heal your duck to " + toString(fD)) + "hp before unstaking"))
1627
+
                                    else [ScriptTransfer(ds.caller, 1, ao), DeleteEntry(fZ), DeleteEntry(fC), DeleteEntry(aI(hE)), DeleteEntry(aF(hE)), DeleteEntry(au(L, hE, bh)), DeleteEntry(aG(bh)), hx]
1646
1628
 
                                }
1647
1629
 
                        }
1648
1630
 
            }
1650
1632
 
1651
1633
 
1652
1634
 
1653
-
@Callable(du)
1654
-
func claimRes (eL,hM) = {
1655
-
    let hz = hw(du)
1656
-
    if ((size(du.payments) != 0))
1635
+
@Callable(ds)
1636
+
func claimRes (eI,hK) = {
1637
+
    let hx = hu(ds)
1638
+
    if ((size(ds.payments) != 0))
1657
1639
 
        then throw("No payments required")
1658
1640
 
        else {
1659
-
            let p = toString(du.originCaller)
1660
-
            let cZ = gf(p, eL, cB, hM)
1661
-
            let k = valueOrErrorMessage(getString(aH(p)), "You don't have a duck staked")
1662
-
            $Tuple2(((((cZ._1 ++ gF(k, fraction(s, eL, bl))._1) :+ StringEntry(cZ._2, makeString(cZ._3, ":"))) :+ StringEntry(cZ._4, makeString(cZ._5, ":"))) :+ hz), cZ._3[ai])
1663
-
            }
1664
-
    }
1665
-
1666
-
1667
-
1668
-
@Callable(du)
1669
-
func claimResToWH (eL,hM) = {
1670
-
    let hz = hw(du)
1671
-
    if ((size(du.payments) != 0))
1641
+
            let p = toString(ds.originCaller)
1642
+
            let cV = gd(p, eI, cq, hK)
1643
+
            let k = valueOrErrorMessage(getString(aG(p)), "You don't have a duck staked")
1644
+
            $Tuple2(((((cV._1 ++ gD(k, fraction(s, eI, ba))._1) :+ StringEntry(cV._2, makeString(cV._3, ":"))) :+ StringEntry(cV._4, makeString(cV._5, ":"))) :+ hx), cV._3[aj])
1645
+
            }
1646
+
    }
1647
+
1648
+
1649
+
1650
+
@Callable(ds)
1651
+
func claimResToWH (eI,hK) = {
1652
+
    let hx = hu(ds)
1653
+
    if ((size(ds.payments) != 0))
1672
1654
 
        then throw("No payments required")
1673
1655
 
        else {
1674
-
            let p = toString(du.originCaller)
1675
-
            let cZ = gf(p, eL, cA, hM)
1676
-
            $Tuple2(((((cZ._1 ++ gL(p, fraction(s, eL, bl))._1) :+ StringEntry(cZ._2, makeString(cZ._3, ":"))) :+ StringEntry(cZ._4, makeString(cZ._5, ":"))) :+ hz), cZ._5[Z])
1677
-
            }
1678
-
    }
1679
-
1680
-
1681
-
1682
-
@Callable(du)
1683
-
func flight (ft,fu) = {
1684
-
    let hz = hw(du)
1685
-
    if ((size(du.payments) != 0))
1656
+
            let p = toString(ds.originCaller)
1657
+
            let cV = gd(p, eI, cp, hK)
1658
+
            $Tuple2(((((cV._1 ++ gJ(p, fraction(s, eI, ba))._1) :+ StringEntry(cV._2, makeString(cV._3, ":"))) :+ StringEntry(cV._4, makeString(cV._5, ":"))) :+ hx), cV._5[aa])
1659
+
            }
1660
+
    }
1661
+
1662
+
1663
+
1664
+
@Callable(ds)
1665
+
func flight (fr,fs) = {
1666
+
    let hx = hu(ds)
1667
+
    if ((size(ds.payments) != 0))
1686
1668
 
        then throw("No payments required")
1687
1669
 
        else {
1688
-
            let aN = toString(du.caller)
1689
-
            let dZ = fs(aN, ft, fu)
1690
-
            let k = dZ._2
1691
-
            let hH = aJ(k)
1692
-
            let fX = valueOrElse(getString(hH), R)
1693
-
            if ((dZ._4 == fX))
1670
+
            let aM = toString(ds.caller)
1671
+
            let dX = fq(aM, fr, fs)
1672
+
            let k = dX._2
1673
+
            let hF = aI(k)
1674
+
            let fV = valueOrElse(getString(hF), R)
1675
+
            if ((dX._4 == fV))
1694
1676
 
                then throw("You can't fly to the same location")
1695
1677
 
                else {
1696
-
                    let ed = aI(k)
1697
-
                    let eO = ec(ed)
1698
-
                    let dn = da(eO[ak], dZ._5)
1699
-
                    $Tuple2(([StringEntry(hH, if ((dZ._1 > 0))
1700
-
                        then dZ._4
1701
-
                        else fX), StringEntry(ed, makeString([eO[ah], eO[ai], eO[aj], dn], ":")), IntegerEntry(aK(k), dZ._1), hz] ++ gF(k, if ((dZ._1 > 0))
1678
+
                    let eb = aH(k)
1679
+
                    let eM = ea(eb)
1680
+
                    let dl = cW(eM[al], dX._5)
1681
+
                    $Tuple2(([StringEntry(hF, if ((dX._1 > 0))
1682
+
                        then dX._4
1683
+
                        else fV), StringEntry(eb, makeString([eM[ai], eM[aj], eM[ak], dl], ":")), IntegerEntry(aJ(k), dX._1), hx] ++ gD(k, if ((dX._1 > 0))
1702
1684
 
                        then t
1703
-
                        else u)._1), dZ._3)
1685
+
                        else u)._1), dX._3)
1704
1686
 
                    }
1705
1687
 
            }
1706
1688
 
    }
1707
1689
 
1708
1690
 
1709
1691
 
1710
-
@Callable(du)
1711
-
func heal (hN,hO,hP) = {
1712
-
    let hz = hw(du)
1713
-
    if (if (if ((0 > hN))
1692
+
@Callable(ds)
1693
+
func heal (hL,hM,hN) = {
1694
+
    let hx = hu(ds)
1695
+
    if (if (if ((0 > hL))
1714
1696
 
        then true
1715
-
        else (0 > hO))
1697
+
        else (0 > hM))
1716
1698
 
        then true
1717
-
        else (0 > hP))
1699
+
        else (0 > hN))
1718
1700
 
        then throw("Quantity cannot be negative")
1719
1701
 
        else {
1720
-
            let k = valueOrErrorMessage(getString(aH(toString(du.caller))), "You don't have a duck staked")
1721
-
            let hQ = [hN, hO, hP]
1722
-
            let fE = aK(k)
1723
-
            let fF = E(valueOrElse(getInteger(m(k)), 0))
1724
-
            let hR = valueOrElse(getInteger(fE), fF)
1725
-
            if ((hR >= fF))
1726
-
                then throw((("HP should be < " + toString(fF)) + " to heal"))
1702
+
            let k = valueOrErrorMessage(getString(aG(toString(ds.caller))), "You don't have a duck staked")
1703
+
            let hO = [hL, hM, hN]
1704
+
            let fC = aJ(k)
1705
+
            let fD = E(valueOrElse(getInteger(m(k)), 0))
1706
+
            let hP = valueOrElse(getInteger(fC), fD)
1707
+
            if ((hP >= fD))
1708
+
                then throw((("HP should be < " + toString(fD)) + " to heal"))
1727
1709
 
                else {
1728
-
                    let ed = aI(k)
1729
-
                    let eO = ec(ed)
1730
-
                    let hS = if ((eO[ak] == ""))
1710
+
                    let eb = aH(k)
1711
+
                    let eM = ea(eb)
1712
+
                    let hQ = if ((eM[al] == ""))
1731
1713
 
                        then nil
1732
-
                        else split(eO[ak], "_")
1733
-
                    func hT (cO,hU) =                     {
1734
-
                        let bV = cO._2
1735
-
                        let dQ = if ((size(hS) > bV))
1736
-
                            then parseIntValue(hS[bV])
1714
+
                        else split(eM[al], "_")
1715
+
                    func hR (cD,hS) =                     {
1716
+
                        let bK = cD._2
1717
+
                        let dO = if ((size(hQ) > bK))
1718
+
                            then parseIntValue(hQ[bK])
1737
1719
 
                            else 0
1738
-
                        if ((3 > bV))
1720
+
                        if ((3 > bK))
1739
1721
 
                            then {
1740
-
                                let hV = hQ[bV]
1741
-
                                if ((hV > dQ))
1742
-
                                    then throw(((("You have only " + toString(dQ)) + " of ") + U[bV]))
1743
-
                                    else $Tuple3((cO._1 :+ toString((dQ - hV))), (bV + 1), (cO._3 + (cb[bV] * hV)))
1722
+
                                let hT = hO[bK]
1723
+
                                if ((hT > dO))
1724
+
                                    then throw(((("You have only " + toString(dO)) + " of ") + U[bK]))
1725
+
                                    else $Tuple3((cD._1 :+ toString((dO - hT))), (bK + 1), (cD._3 + (bQ[bK] * hT)))
1744
1726
 
                                }
1745
-
                            else $Tuple3((cO._1 :+ toString(dQ)), (bV + 1), cO._3)
1727
+
                            else $Tuple3((cD._1 :+ toString(dO)), (bK + 1), cD._3)
1746
1728
 
                        }
1747
1729
 
1748
-
                    let cZ = {
1749
-
                        let aW = W
1750
-
                        let aX = size(aW)
1751
-
                        let aY = $Tuple3(nil, 0, 0)
1752
-
                        func aZ (ba,bb) =                         if ((bb >= aX))
1753
-
                            then ba
1754
-
                            else hT(ba, aW[bb])
1755
-
1756
-
                        func bc (ba,bb) =                         if ((bb >= aX))
1757
-
                            then ba
1730
+
                    let cV = {
1731
+
                        let cF = W
1732
+
                        let cG = size(cF)
1733
+
                        let cH = $Tuple3(nil, 0, 0)
1734
+
                        func cI (cJ,cK) =                         if ((cK >= cG))
1735
+
                            then cJ
1736
+
                            else hR(cJ, cF[cK])
1737
+
1738
+
                        func cL (cJ,cK) =                         if ((cK >= cG))
1739
+
                            then cJ
1758
1740
 
                            else throw("List size exceeds 50")
1759
1741
 
1760
-
                        bc(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aY, 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)
1742
+
                        cL(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cH, 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)
1761
1743
 
                        }
1762
-
                    let hW = min([fF, (hR + cZ._3)])
1763
-
                    $Tuple2(([IntegerEntry(fE, hW), StringEntry(ed, makeString_2C([eO[ah], eO[ai], eO[aj], makeString(cZ._1, "_")], ":")), hz] ++ gF(k, (B * ((hN + hO) + hP)))._1), hW)
1744
+
                    let hU = min([fD, (hP + cV._3)])
1745
+
                    $Tuple2(([IntegerEntry(fC, hU), StringEntry(eb, makeString_2C([eM[ai], eM[aj], eM[ak], makeString(cV._1, "_")], ":")), hx] ++ gD(k, (B * ((hL + hM) + hN)))._1), hU)
1764
1746
 
                    }
1765
1747
 
            }
1766
1748
 
    }
1767
1749
 
1768
1750
 
1769
1751
 
1770
-
@Callable(du)
1752
+
@Callable(ds)
1771
1753
 
func healES () = {
1772
-
    let hz = hw(du)
1773
-
    if ((size(du.payments) != 1))
1754
+
    let hx = hu(ds)
1755
+
    if ((size(ds.payments) != 1))
1774
1756
 
        then throw("Exactly one payment required")
1775
1757
 
        else {
1776
-
            let hA = value(du.payments[0])
1777
-
            if ((hA.assetId != bf))
1758
+
            let hy = value(ds.payments[0])
1759
+
            if ((hy.assetId != aU))
1778
1760
 
                then throw("Allowed USDT payment only!")
1779
1761
 
                else {
1780
-
                    let k = valueOrErrorMessage(getString(aH(toString(du.caller))), "You don't have a duck staked")
1781
-
                    let fE = aK(k)
1782
-
                    let fF = E(valueOrElse(getInteger(m(k)), 0))
1783
-
                    let hR = valueOrElse(getInteger(fE), fF)
1784
-
                    if ((hR > 0))
1762
+
                    let k = valueOrErrorMessage(getString(aG(toString(ds.caller))), "You don't have a duck staked")
1763
+
                    let fC = aJ(k)
1764
+
                    let fD = E(valueOrElse(getInteger(m(k)), 0))
1765
+
                    let hP = valueOrElse(getInteger(fC), fD)
1766
+
                    if ((hP > 0))
1785
1767
 
                        then throw("HP should be 0 to call Emergency Service")
1786
1768
 
                        else {
1787
-
                            let ed = aI(k)
1788
-
                            let eO = ec(ed)
1789
-
                            let hS = if ((eO[ak] == ""))
1769
+
                            let eb = aH(k)
1770
+
                            let eM = ea(eb)
1771
+
                            let hQ = if ((eM[al] == ""))
1790
1772
 
                                then nil
1791
-
                                else split(eO[ak], "_")
1792
-
                            let hX = if ((size(hS) > 0))
1793
-
                                then parseIntValue(hS[0])
1773
+
                                else split(eM[al], "_")
1774
+
                            let hV = if ((size(hQ) > 0))
1775
+
                                then parseIntValue(hQ[0])
1794
1776
 
                                else 0
1795
-
                            let hY = if ((size(hS) > 1))
1796
-
                                then parseIntValue(hS[1])
1777
+
                            let hW = if ((size(hQ) > 1))
1778
+
                                then parseIntValue(hQ[1])
1797
1779
 
                                else 0
1798
-
                            let hZ = if ((size(hS) > 2))
1799
-
                                then parseIntValue(hS[2])
1780
+
                            let hX = if ((size(hQ) > 2))
1781
+
                                then parseIntValue(hQ[2])
1800
1782
 
                                else 0
1801
-
                            if (if (if ((hX > 0))
1783
+
                            if (if (if ((hV > 0))
1802
1784
 
                                then true
1803
-
                                else (hY > 0))
1785
+
                                else (hW > 0))
1804
1786
 
                                then true
1805
-
                                else (hZ > 0))
1787
+
                                else (hX > 0))
1806
1788
 
                                then throw("You have to use own Medical Kit")
1807
1789
 
                                else {
1808
-
                                    let ia = getString(bH, aO())
1809
-
                                    let ib = if (isDefined(ia))
1810
-
                                        then split(value(ia), "_")
1790
+
                                    let hY = getString(bw, aN())
1791
+
                                    let hZ = if (isDefined(hY))
1792
+
                                        then split(value(hY), "_")
1811
1793
 
                                        else nil
1812
-
                                    let ic = if ((size(ib) > 0))
1813
-
                                        then parseIntValue(ib[0])
1794
+
                                    let ia = if ((size(hZ) > 0))
1795
+
                                        then parseIntValue(hZ[0])
1814
1796
 
                                        else 0
1815
-
                                    if ((0 >= ic))
1797
+
                                    if ((0 >= ia))
1816
1798
 
                                        then throw("There are no Medical Kits L1 at Emergency Service storage")
1817
1799
 
                                        else {
1818
-
                                            let hW = (hR + cb[0])
1819
-
                                            let id = makeString([toString((ic - 1)), removeByIndex(ib, 0)], "_")
1820
-
                                            let aS = split(W[0], "_")
1821
-
                                            let ie = aR(aS)
1822
-
                                            let if = parseIntValue(aS[X])
1823
-
                                            let ig = fraction((ie * T), S, (10 * if))
1824
-
                                            if ((hA.amount != ig))
1825
-
                                                then throw(("Payment attached should be " + toString(ig)))
1800
+
                                            let hU = (hP + bQ[0])
1801
+
                                            let ib = makeString([toString((ia - 1)), removeByIndex(hZ, 0)], "_")
1802
+
                                            let aR = split(W[0], "_")
1803
+
                                            let ic = aQ(aR)
1804
+
                                            let id = fraction((ic * T), S, (10 * Y))
1805
+
                                            if ((hy.amount != id))
1806
+
                                                then throw(("Payment attached should be " + toString(id)))
1826
1807
 
                                                else {
1827
-
                                                    let cZ = bR(invoke(bH, "updateEsStorage", [id], [AttachedPayment(bf, ig)]))
1828
-
                                                    $Tuple2(([IntegerEntry(fE, hW), hz] ++ gF(k, v)._1), cZ)
1808
+
                                                    let cV = bG(invoke(bw, "updateEsStorage", [ib], [AttachedPayment(aU, id)]))
1809
+
                                                    $Tuple2(([IntegerEntry(fC, hU), hx] ++ gD(k, v)._1), cV)
1829
1810
 
                                                    }
1830
1811
 
                                            }
1831
1812
 
                                    }
1836
1817
 
1837
1818
 
1838
1819
 
1839
-
@Callable(du)
1840
-
func updateBackpack (k,ih) = if ((du.caller != bH))
1820
+
@Callable(ds)
1821
+
func updateBackpack (k,ie) = if ((ds.caller != bw))
1841
1822
 
    then throw("permission denied")
1842
-
    else $Tuple2([StringEntry(aI(k), ih)], ih)
1843
-
1844
-
1845
-
1846
-
@Callable(du)
1823
+
    else $Tuple2([StringEntry(aH(k), ie)], ie)
1824
+
1825
+
1826
+
1827
+
@Callable(ds)
1847
1828
 
func buySLand () = {
1848
-
    let hz = hw(du)
1849
-
    if ((size(du.payments) != 1))
1829
+
    let hx = hu(ds)
1830
+
    if ((size(ds.payments) != 1))
1850
1831
 
        then throw("Exactly one payment required")
1851
1832
 
        else {
1852
-
            let hA = value(du.payments[0])
1853
-
            if ((hA.assetId != bf))
1833
+
            let hy = value(ds.payments[0])
1834
+
            if ((hy.assetId != aU))
1854
1835
 
                then throw("Allowed USDT payment only!")
1855
-
                else if ((hA.amount != ch))
1856
-
                    then throw(("Payment attached should be " + toString(ch)))
1836
+
                else if ((hy.amount != bW))
1837
+
                    then throw(("Payment attached should be " + toString(bW)))
1857
1838
 
                    else {
1858
-
                        let cZ = fk(du.caller, du.transactionId)
1859
-
                        $Tuple2((((cZ._1 :+ ScriptTransfer(bH, hA.amount, bf)) ++ gL(toString(du.caller), x)._1) :+ hz), cZ._2._1)
1839
+
                        let cV = fi(ds.caller, ds.transactionId)
1840
+
                        $Tuple2((((cV._1 :+ ScriptTransfer(bw, hy.amount, aU)) ++ gJ(toString(ds.caller), x)._1) :+ hx), cV._2._1)
1860
1841
 
                        }
1861
1842
 
            }
1862
1843
 
    }
1863
1844
 
1864
1845
 
1865
1846
 
1866
-
@Callable(du)
1867
-
func expedition (ft,fu) = {
1868
-
    let hz = hw(du)
1869
-
    if ((size(du.payments) != 0))
1847
+
@Callable(ds)
1848
+
func expedition (fr,fs) = {
1849
+
    let hx = hu(ds)
1850
+
    if ((size(ds.payments) != 0))
1870
1851
 
        then throw("No payments required")
1871
1852
 
        else {
1872
-
            let cZ = fK(du.caller, du.transactionId, ft, fu)
1873
-
            let k = valueOrErrorMessage(getString(aH(toString(du.caller))), "You don't have a duck staked")
1874
-
            $Tuple2(((cZ._1 ++ gF(k, x)._1) :+ hz), $Tuple2(cZ._2, cZ._3))
1875
-
            }
1876
-
    }
1877
-
1878
-
1879
-
1880
-
@Callable(du)
1881
-
func upgradeInfra (az) = {
1882
-
    let hz = hw(du)
1883
-
    if ((size(du.payments) != 0))
1853
+
            let cV = fI(ds.caller, ds.transactionId, fr, fs)
1854
+
            let k = valueOrErrorMessage(getString(aG(toString(ds.caller))), "You don't have a duck staked")
1855
+
            $Tuple2(((cV._1 ++ gD(k, x)._1) :+ hx), $Tuple2(cV._2, cV._3))
1856
+
            }
1857
+
    }
1858
+
1859
+
1860
+
1861
+
@Callable(ds)
1862
+
func upgradeInfra (ay) = {
1863
+
    let hx = hu(ds)
1864
+
    if ((size(ds.payments) != 0))
1884
1865
 
        then throw("No payments required")
1885
1866
 
        else {
1886
-
            let cZ = gt(true, du.caller, 0, az)
1887
-
            let k = valueOrErrorMessage(getString(aH(toString(du.caller))), "You don't have a duck staked")
1888
-
            $Tuple2(((cZ._1 :+ hz) ++ gF(k, fraction(y, cZ._3, bl))._1), cZ._2)
1889
-
            }
1890
-
    }
1891
-
1892
-
1893
-
1894
-
@Callable(du)
1895
-
func upgradeInfraUsdt (az) = if ((du.caller != this))
1867
+
            let cV = gr(true, ds.caller, 0, ay)
1868
+
            let k = valueOrErrorMessage(getString(aG(toString(ds.caller))), "You don't have a duck staked")
1869
+
            $Tuple2(((cV._1 :+ hx) ++ gD(k, fraction(y, cV._3, ba))._1), cV._2)
1870
+
            }
1871
+
    }
1872
+
1873
+
1874
+
1875
+
@Callable(ds)
1876
+
func upgradeInfraUsdt (ay) = if ((ds.caller != this))
1896
1877
 
    then throw("Permission denied")
1897
1878
 
    else {
1898
-
        let hz = hw(du)
1899
-
        if ((size(du.payments) != 1))
1879
+
        let hx = hu(ds)
1880
+
        if ((size(ds.payments) != 1))
1900
1881
 
            then throw("Exactly one payment required")
1901
1882
 
            else {
1902
-
                let hA = value(du.payments[0])
1903
-
                if ((hA.assetId != bf))
1883
+
                let hy = value(ds.payments[0])
1884
+
                if ((hy.assetId != aU))
1904
1885
 
                    then throw("Allowed USDT payment only!")
1905
1886
 
                    else {
1906
-
                        let cZ = gt(false, du.caller, hA.amount, az)
1907
-
                        $Tuple2(((cZ._1 :+ ScriptTransfer(bH, hA.amount, bf)) :+ hz), cZ._2)
1887
+
                        let cV = gr(false, ds.caller, hy.amount, ay)
1888
+
                        $Tuple2(((cV._1 :+ ScriptTransfer(bw, hy.amount, aU)) :+ hx), cV._2)
1908
1889
 
                        }
1909
1890
 
                }
1910
1891
 
        }
1911
1892
 
1912
1893
 
1913
1894
 
1914
-
@Callable(du)
1915
-
func activateArtifact (ii,ij) = {
1916
-
    let hz = hw(du)
1917
-
    if ((size(du.payments) != 0))
1895
+
@Callable(ds)
1896
+
func activateArtifact (if,ig) = {
1897
+
    let hx = hu(ds)
1898
+
    if ((size(ds.payments) != 0))
1918
1899
 
        then throw("No payments required")
1919
1900
 
        else {
1920
-
            let p = toString(du.caller)
1921
-
            let cZ = {
1922
-
                let bg = ii
1923
-
                if (("PRESALE" == bg))
1924
-
                    then gT(p, ij)
1925
-
                    else if (("ONBOARD" == bg))
1926
-
                        then gM(p)
1901
+
            let p = toString(ds.caller)
1902
+
            let cV = {
1903
+
                let aV = if
1904
+
                if (("PRESALE" == aV))
1905
+
                    then gR(p, ig)
1906
+
                    else if (("ONBOARD" == aV))
1907
+
                        then gK(p)
1927
1908
 
                        else throw("Unknown artifact")
1928
1909
 
                }
1929
-
            (cZ :+ hz)
1930
-
            }
1931
-
    }
1932
-
1933
-
1934
-
1935
-
@Callable(du)
1936
-
func mergeLands (gY) = {
1937
-
    let hz = hw(du)
1938
-
    if ((size(du.payments) != 0))
1910
+
            (cV :+ hx)
1911
+
            }
1912
+
    }
1913
+
1914
+
1915
+
1916
+
@Callable(ds)
1917
+
func mergeLands (gW) = {
1918
+
    let hx = hu(ds)
1919
+
    if ((size(ds.payments) != 0))
1939
1920
 
        then throw("No payments required")
1940
1921
 
        else {
1941
-
            let cZ = hu(true, toString(du.caller), 0, gY, du.transactionId)
1942
-
            $Tuple2(((cZ._1 :+ hz) ++ gL(toString(du.caller), z)._1), cZ._2)
1943
-
            }
1944
-
    }
1945
-
1946
-
1947
-
1948
-
@Callable(du)
1949
-
func mergeLandsUsdt (gY) = {
1950
-
    let hz = hw(du)
1951
-
    if ((size(du.payments) != 1))
1922
+
            let cV = hs(true, toString(ds.caller), 0, gW, ds.transactionId)
1923
+
            $Tuple2(((cV._1 :+ hx) ++ gJ(toString(ds.caller), z)._1), cV._2)
1924
+
            }
1925
+
    }
1926
+
1927
+
1928
+
1929
+
@Callable(ds)
1930
+
func mergeLandsUsdt (gW) = {
1931
+
    let hx = hu(ds)
1932
+
    if ((size(ds.payments) != 1))
1952
1933
 
        then throw("Exactly one payment required")
1953
1934
 
        else {
1954
-
            let hA = value(du.payments[0])
1955
-
            if ((hA.assetId != bf))
1935
+
            let hy = value(ds.payments[0])
1936
+
            if ((hy.assetId != aU))
1956
1937
 
                then throw("Allowed USDT payment only!")
1957
1938
 
                else {
1958
-
                    let cZ = hu(false, toString(du.caller), hA.amount, gY, du.transactionId)
1959
-
                    $Tuple2(((cZ._1 :+ ScriptTransfer(bH, hA.amount, bf)) :+ hz), cZ._2)
1939
+
                    let cV = hs(false, toString(ds.caller), hy.amount, gW, ds.transactionId)
1940
+
                    $Tuple2(((cV._1 :+ ScriptTransfer(bw, hy.amount, aU)) :+ hx), cV._2)
1960
1941
 
                    }
1961
1942
 
            }
1962
1943
 
    }
1963
1944
 
1964
1945
 
1965
1946
 
1966
-
@Callable(du)
1967
-
func cargoExchange (ik,az) = {
1968
-
    let hz = hw(du)
1969
-
    if ((size(du.payments) != 0))
1947
+
@Callable(ds)
1948
+
func cargoExchange (ih,ay) = {
1949
+
    let hx = hu(ds)
1950
+
    if ((size(ds.payments) != 0))
1970
1951
 
        then throw("No payments required")
1971
1952
 
        else {
1972
-
            let eN = split_4C(ik, ":")
1973
-
            let p = toString(du.originCaller)
1974
-
            let ga = value(assetInfo(fromBase58String(az)))
1975
-
            let gb = ar(az)
1976
-
            if (!(isDefined(getInteger(gb))))
1977
-
                then throw((ga.name + " is not staked"))
1953
+
            let eL = split_4C(ih, ":")
1954
+
            let p = toString(ds.originCaller)
1955
+
            let fY = value(assetInfo(fromBase58String(ay)))
1956
+
            let fZ = aq(ay)
1957
+
            if (!(isDefined(getInteger(fZ))))
1958
+
                then throw((fY.name + " is not staked"))
1978
1959
 
                else {
1979
-
                    let gd = valueOrErrorMessage(getString(ao(az)), (("NFT " + ga.name) + " is orphaned"))
1980
-
                    if ((gd != p))
1960
+
                    let gb = valueOrErrorMessage(getString(an(ay)), (("NFT " + fY.name) + " is orphaned"))
1961
+
                    if ((gb != p))
1981
1962
 
                        then throw((K + " is not yours"))
1982
1963
 
                        else {
1983
-
                            let ex = (bW(split(ga.description, "_")[bL]) / bm)
1984
-
                            let ey = valueOrElse(getInteger(as(az)), 0)
1985
-
                            let k = valueOrErrorMessage(getString(aH(p)), "You don't have a duck staked")
1986
-
                            let fX = valueOrElse(getString(aJ(k)), R)
1987
-
                            let fY = split(value(fX), "_")
1988
-
                            if ((fY[aP] != "L"))
1989
-
                                then throw((("Duck location type is " + fY[aP]) + ", but should be L"))
1990
-
                                else if ((fY[aQ] != az))
1991
-
                                    then throw(("Duck should be on the land " + az))
1964
+
                            let eu = (bL(split(fY.description, "_")[bA]) / bb)
1965
+
                            let ev = valueOrElse(getInteger(ar(ay)), 0)
1966
+
                            let k = valueOrErrorMessage(getString(aG(p)), "You don't have a duck staked")
1967
+
                            let fV = valueOrElse(getString(aI(k)), R)
1968
+
                            let fW = split(value(fV), "_")
1969
+
                            if ((fW[aO] != "L"))
1970
+
                                then throw((("Duck location type is " + fW[aO]) + ", but should be L"))
1971
+
                                else if ((fW[aP] != ay))
1972
+
                                    then throw(("Duck should be on the land " + ay))
1992
1973
 
                                    else {
1993
-
                                        let ew = ay(az)
1994
-
                                        let ei = ev(ew, ex, ey)
1995
-
                                        let ed = aI(k)
1996
-
                                        let eO = ec(ed)
1997
-
                                        let cZ = eM(eN, ei, eO)
1998
-
                                        let eE = split(ei[ac], "_")
1999
-
                                        let gq = (parseIntValue(eE[ae]) + cZ._7)
2000
-
                                        let gr = (parseIntValue(eE[af]) - cZ._7)
2001
-
[StringEntry(ed, makeString_2C([eO[ah], cZ._4, cZ._5, cZ._6], ":")), StringEntry(ew, makeString_2C([ei[Y], cZ._1, cZ._2, cZ._3, makeString([eE[ad], toString(gq), toString(gr), eE[ag]], "_")], ":")), hz]
1974
+
                                        let et = ax(ay)
1975
+
                                        let eg = es(et, eu, ev)
1976
+
                                        let eb = aH(k)
1977
+
                                        let eM = ea(eb)
1978
+
                                        let cV = eK(eL, eg, eM)
1979
+
                                        let eB = split(eg[ad], "_")
1980
+
                                        let go = (parseIntValue(eB[af]) + cV._7)
1981
+
                                        let gp = (parseIntValue(eB[ag]) - cV._7)
1982
+
[StringEntry(eb, makeString_2C([eM[ai], cV._4, cV._5, cV._6], ":")), StringEntry(et, makeString_2C([eg[Z], cV._1, cV._2, cV._3, makeString([eB[ae], toString(go), toString(gp), eB[ah]], "_")], ":")), hx]
2002
1983
 
                                        }
2003
1984
 
                            }
2004
1985
 
                    }
2007
1988
 
2008
1989
 
2009
1990
 
2010
-
@Callable(du)
2011
-
func saveWarehouse (eA,az) = if ((du.caller != bH))
1991
+
@Callable(ds)
1992
+
func saveWarehouse (ex,ay) = if ((ds.caller != bw))
2012
1993
 
    then throw("Access denied")
2013
1994
 
    else {
2014
-
        let ew = ay(az)
2015
-
        let eB = split_4C(eA, ":")
2016
-
        if ((size(eB) != 5))
1995
+
        let et = ax(ay)
1996
+
        let ey = split_4C(ex, ":")
1997
+
        if ((size(ey) != 5))
2017
1998
 
            then throw("warehouse string should contain 4 ':' separators")
2018
1999
 
            else {
2019
-
                let il = split(eB[ac], "_")[ad]
2020
-
                let gq = eh(eB)
2021
-
                let im = ef(eB[Y])
2022
-
                let gr = ((im - parseIntValue(il)) - gq)
2023
-
                let in = makeString_2C([eB[Y], eB[Z], eB[aa], eB[ab], makeString([il, toString(gq), toString(gr), toString(im)], "_")], ":")
2024
-
                $Tuple2([StringEntry(ew, in)], in)
2000
+
                let ii = split(ey[ad], "_")[ae]
2001
+
                let go = ef(ey)
2002
+
                let ij = ed(ey[Z])
2003
+
                let gp = ((ij - parseIntValue(ii)) - go)
2004
+
                let ik = makeString_2C([ey[Z], ey[aa], ey[ab], ey[ac], makeString([ii, toString(go), toString(gp), toString(ij)], "_")], ":")
2005
+
                $Tuple2([StringEntry(et, ik)], ik)
2025
2006
 
                }
2026
2007
 
        }
2027
2008
 
2028
2009
 
2029
2010
 
2030
-
@Callable(du)
2031
-
func fixWarehouseFormat (az) = if ((du.caller != bF))
2011
+
@Callable(ds)
2012
+
func fixWarehouseFormat (ay) = if ((ds.caller != bu))
2032
2013
 
    then throw("Access denied")
2033
2014
 
    else {
2034
-
        let ew = ay(az)
2035
-
        let ga = value(assetInfo(fromBase58String(az)))
2036
-
        let ex = (bW(split(ga.description, "_")[bL]) / bm)
2037
-
        let ey = valueOrElse(getInteger(as(az)), 0)
2038
-
        let eB = ev(ew, ex, ey)
2039
-
        let il = bU(invoke(bH, "recalcLockedVolumeREADONLY", [az, eB], nil))
2040
-
        let gq = eh(eB)
2041
-
        let im = ef(eB[Y])
2042
-
        let gr = ((im - il) - gq)
2043
-
        let in = makeString_2C([eB[Y], eB[Z], eB[aa], eB[ab], makeString([toString(il), toString(gq), toString(gr), toString(im)], "_")], ":")
2044
-
        $Tuple2([StringEntry(ew, in)], in)
2015
+
        let et = ax(ay)
2016
+
        let fY = value(assetInfo(fromBase58String(ay)))
2017
+
        let eu = (bL(split(fY.description, "_")[bA]) / bb)
2018
+
        let ev = valueOrElse(getInteger(ar(ay)), 0)
2019
+
        let ey = es(et, eu, ev)
2020
+
        let ii = bJ(invoke(bw, "recalcLockedVolumeREADONLY", [ay, ey], nil))
2021
+
        let go = ef(ey)
2022
+
        let ij = ed(ey[Z])
2023
+
        let gp = ((ij - ii) - go)
2024
+
        let ik = makeString_2C([ey[Z], ey[aa], ey[ab], ey[ac], makeString([toString(ii), toString(go), toString(gp), toString(ij)], "_")], ":")
2025
+
        $Tuple2([StringEntry(et, ik)], ik)
2045
2026
 
        }
2046
2027
 
2047
2028
 
2048
2029
 
2049
-
@Callable(du)
2050
-
func fixStakedPieces (bs) = if ((du.caller != bF))
2030
+
@Callable(ds)
2031
+
func fixStakedPieces (bh) = if ((ds.caller != bu))
2051
2032
 
    then throw("Access denied")
2052
2033
 
    else {
2053
-
        let hp = if ((bs == ""))
2034
+
        let hn = if ((bh == ""))
2054
2035
 
            then 0
2055
2036
 
            else {
2056
-
                let hk = getString(bG, bP(bs))
2057
-
                let hf = if (isDefined(hk))
2058
-
                    then split_51C(value(hk), "_")
2037
+
                let hi = getString(bv, bE(bh))
2038
+
                let hd = if (isDefined(hi))
2039
+
                    then split_51C(value(hi), "_")
2059
2040
 
                    else nil
2060
-
                func io (cO,az) =                 {
2061
-
                    let ga = value(assetInfo(fromBase58String(az)))
2062
-
                    let bX = split(ga.description, "_")[bL]
2063
-
                    (cO + bW(bX))
2041
+
                func il (cD,ay) =                 {
2042
+
                    let fY = value(assetInfo(fromBase58String(ay)))
2043
+
                    let bM = split(fY.description, "_")[bA]
2044
+
                    (cD + bL(bM))
2064
2045
 
                    }
2065
2046
 
2066
-
                let aW = hf
2067
-
                let aX = size(aW)
2068
-
                let aY = 0
2069
-
                func aZ (ba,bb) =                 if ((bb >= aX))
2070
-
                    then ba
2071
-
                    else io(ba, aW[bb])
2072
-
2073
-
                func bc (ba,bb) =                 if ((bb >= aX))
2074
-
                    then ba
2047
+
                let cF = hd
2048
+
                let cG = size(cF)
2049
+
                let cH = 0
2050
+
                func cI (cJ,cK) =                 if ((cK >= cG))
2051
+
                    then cJ
2052
+
                    else il(cJ, cF[cK])
2053
+
2054
+
                func cL (cJ,cK) =                 if ((cK >= cG))
2055
+
                    then cJ
2075
2056
 
                    else throw("List size exceeds 100")
2076
2057
 
2077
-
                bc(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aY, 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)
2058
+
                cL(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cH, 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)
2078
2059
 
                }
2079
-
        $Tuple2([IntegerEntry(bQ(bs), hp)], hp)
2060
+
        $Tuple2([IntegerEntry(bF(bh), hn)], hn)
2080
2061
 
        }
2081
2062
 
2082
2063
 
2083
2064
 
2084
-
@Callable(du)
2085
-
func setCustomName (ap,hh,au) = {
2086
-
    let hz = hw(du)
2087
-
    if ((size(du.payments) != 1))
2065
+
@Callable(ds)
2066
+
func setCustomName (ao,hf,at) = {
2067
+
    let hx = hu(ds)
2068
+
    if ((size(ds.payments) != 1))
2088
2069
 
        then throw("Exactly one payment required")
2089
2070
 
        else {
2090
-
            let hA = value(du.payments[0])
2091
-
            if ((hA.assetId != bf))
2071
+
            let hy = value(ds.payments[0])
2072
+
            if ((hy.assetId != aU))
2092
2073
 
                then throw("Allowed USDT payment only!")
2093
-
                else if ((hA.amount != cd))
2094
-
                    then throw(("Payment should be " + toString(cd)))
2095
-
                    else if (contains(hh, "__"))
2096
-
                        then throw(("Name should not contain '__': " + hh))
2097
-
                        else if ((size(hh) > ce))
2098
-
                            then throw(("Name too long, maxLength=" + toString(ce)))
2074
+
                else if ((hy.amount != bS))
2075
+
                    then throw(("Payment should be " + toString(bS)))
2076
+
                    else if (contains(hf, "__"))
2077
+
                        then throw(("Name should not contain '__': " + hf))
2078
+
                        else if ((size(hf) > bT))
2079
+
                            then throw(("Name too long, maxLength=" + toString(bT)))
2099
2080
 
                            else {
2100
-
                                let p = toString(du.originCaller)
2101
-
                                let ip = {
2102
-
                                    let bg = au
2103
-
                                    if (("ACCOUNT" == bg))
2081
+
                                let p = toString(ds.originCaller)
2082
+
                                let im = {
2083
+
                                    let aV = at
2084
+
                                    if (("ACCOUNT" == aV))
2104
2085
 
                                        then {
2105
-
                                            let iq = cy(hh)
2106
-
                                            let ir = getString(iq)
2107
-
                                            if (isDefined(ir))
2108
-
                                                then throw(("Name already registered: " + hh))
2086
+
                                            let in = cn(hf)
2087
+
                                            let io = getString(in)
2088
+
                                            if (isDefined(io))
2089
+
                                                then throw(("Name already registered: " + hf))
2109
2090
 
                                                else {
2110
-
                                                    let is = aB(p)
2111
-
                                                    let it = getString(is)
2112
-
                                                    let iu = if (isDefined(it))
2113
-
                                                        then [DeleteEntry(cy(value(it)))]
2091
+
                                                    let ip = aA(p)
2092
+
                                                    let iq = getString(ip)
2093
+
                                                    let ir = if (isDefined(iq))
2094
+
                                                        then [DeleteEntry(cn(value(iq)))]
2114
2095
 
                                                        else nil
2115
-
                                                    (((iu :+ StringEntry(is, hh)) :+ StringEntry(iq, p)) ++ gL(p, w)._1)
2096
+
                                                    (((ir :+ StringEntry(ip, hf)) :+ StringEntry(in, p)) ++ gJ(p, w)._1)
2116
2097
 
                                                    }
2117
2098
 
                                            }
2118
-
                                        else if (("LAND" == bg))
2099
+
                                        else if (("LAND" == aV))
2119
2100
 
                                            then {
2120
-
                                                let ga = value(assetInfo(fromBase58String(ap)))
2121
-
                                                let gb = ar(ap)
2122
-
                                                if (!(isDefined(getInteger(gb))))
2123
-
                                                    then throw((ga.name + " is not staked"))
2101
+
                                                let fY = value(assetInfo(fromBase58String(ao)))
2102
+
                                                let fZ = aq(ao)
2103
+
                                                if (!(isDefined(getInteger(fZ))))
2104
+
                                                    then throw((fY.name + " is not staked"))
2124
2105
 
                                                    else {
2125
-
                                                        let gd = valueOrErrorMessage(getString(ao(ap)), (("NFT " + ga.name) + " is orphaned"))
2126
-
                                                        if ((gd != p))
2106
+
                                                        let gb = valueOrErrorMessage(getString(an(ao)), (("NFT " + fY.name) + " is orphaned"))
2107
+
                                                        if ((gb != p))
2127
2108
 
                                                            then throw((K + " is not yours"))
2128
2109
 
                                                            else {
2129
-
                                                                let iq = cs(hh)
2130
-
                                                                let ir = getString(iq)
2131
-
                                                                if (isDefined(ir))
2132
-
                                                                    then throw(("Name already registered: " + hh))
2110
+
                                                                let in = ch(hf)
2111
+
                                                                let io = getString(in)
2112
+
                                                                if (isDefined(io))
2113
+
                                                                    then throw(("Name already registered: " + hf))
2133
2114
 
                                                                    else {
2134
-
                                                                        let iv = aq(ap)
2135
-
                                                                        let it = getString(iv)
2136
-
                                                                        let iu = if (isDefined(it))
2137
-
                                                                            then [DeleteEntry(cs(value(it)))]
2115
+
                                                                        let is = ap(ao)
2116
+
                                                                        let iq = getString(is)
2117
+
                                                                        let ir = if (isDefined(iq))
2118
+
                                                                            then [DeleteEntry(ch(value(iq)))]
2138
2119
 
                                                                            else nil
2139
-
                                                                        (((iu :+ StringEntry(iv, hh)) :+ StringEntry(iq, ap)) ++ gL(p, w)._1)
2120
+
                                                                        (((ir :+ StringEntry(is, hf)) :+ StringEntry(in, ao)) ++ gJ(p, w)._1)
2140
2121
 
                                                                        }
2141
2122
 
                                                                }
2142
2123
 
                                                        }
2143
2124
 
                                                }
2144
-
                                            else if (("DUCK" == bg))
2125
+
                                            else if (("DUCK" == aV))
2145
2126
 
                                                then {
2146
-
                                                    let ga = value(assetInfo(fromBase58String(ap)))
2147
-
                                                    let gb = ar(ap)
2148
-
                                                    if (if (!(isDefined(getInteger(gb))))
2127
+
                                                    let fY = value(assetInfo(fromBase58String(ao)))
2128
+
                                                    let fZ = aq(ao)
2129
+
                                                    if (if (!(isDefined(getInteger(fZ))))
2149
2130
 
                                                        then true
2150
-
                                                        else !(isDefined(getString(aH(p)))))
2151
-
                                                        then throw((ga.name + " is not staked"))
2131
+
                                                        else !(isDefined(getString(aG(p)))))
2132
+
                                                        then throw((fY.name + " is not staked"))
2152
2133
 
                                                        else {
2153
-
                                                            let gd = valueOrErrorMessage(getString(aG(ap)), (("NFT " + ga.name) + " is orphaned"))
2154
-
                                                            if ((gd != p))
2134
+
                                                            let gb = valueOrErrorMessage(getString(aF(ao)), (("NFT " + fY.name) + " is orphaned"))
2135
+
                                                            if ((gb != p))
2155
2136
 
                                                                then throw((L + " is not yours"))
2156
2137
 
                                                                else {
2157
-
                                                                    let iq = cx(hh)
2158
-
                                                                    let ir = getString(iq)
2159
-
                                                                    if (isDefined(ir))
2160
-
                                                                        then throw(("Name already registered: " + hh))
2138
+
                                                                    let in = cm(hf)
2139
+
                                                                    let io = getString(in)
2140
+
                                                                    if (isDefined(io))
2141
+
                                                                        then throw(("Name already registered: " + hf))
2161
2142
 
                                                                        else {
2162
-
                                                                            let iv = aA(ap)
2163
-
                                                                            let it = getString(iv)
2164
-
                                                                            let iu = if (isDefined(it))
2165
-
                                                                                then [DeleteEntry(cx(value(it)))]
2143
+
                                                                            let is = az(ao)
2144
+
                                                                            let iq = getString(is)
2145
+
                                                                            let ir = if (isDefined(iq))
2146
+
                                                                                then [DeleteEntry(cm(value(iq)))]
2166
2147
 
                                                                                else nil
2167
-
                                                                            (((iu :+ StringEntry(iv, hh)) :+ StringEntry(iq, ap)) ++ gF(ap, w)._1)
2148
+
                                                                            (((ir :+ StringEntry(is, hf)) :+ StringEntry(in, ao)) ++ gD(ao, w)._1)
2168
2149
 
                                                                            }
2169
2150
 
                                                                    }
2170
2151
 
                                                            }
2171
2152
 
                                                    }
2172
2153
 
                                                else throw("Unknown entity type")
2173
2154
 
                                    }
2174
-
                                $Tuple2(((ip :+ ScriptTransfer(bH, hA.amount, bf)) :+ hz), 0)
2155
+
                                $Tuple2(((im :+ ScriptTransfer(bw, hy.amount, aU)) :+ hx), 0)
2175
2156
 
                                }
2176
2157
 
            }
2177
2158
 
    }
2178
2159
 
2179
2160
 
2180
2161
 
2181
-
@Callable(du)
2182
-
func setReferrals (iw,ix) = if ((du.callerPublicKey != ca))
2162
+
@Callable(ds)
2163
+
func setReferrals (it,iu) = if ((ds.callerPublicKey != bP))
2183
2164
 
    then throw("Permission denied")
2184
2165
 
    else {
2185
-
        let hz = hw(du)
2186
-
        if ((size(du.payments) != 0))
2166
+
        let hx = hu(ds)
2167
+
        if ((size(ds.payments) != 0))
2187
2168
 
            then throw("No payments required")
2188
-
            else if (!(isDefined(addressFromString(iw))))
2189
-
                then throw(("Invalid address: " + iw))
2190
-
                else if (!(isDefined(addressFromString(ix))))
2191
-
                    then throw(("Invalid address: " + ix))
2169
+
            else if (!(isDefined(addressFromString(it))))
2170
+
                then throw(("Invalid address: " + it))
2171
+
                else if (!(isDefined(addressFromString(iu))))
2172
+
                    then throw(("Invalid address: " + iu))
2192
2173
 
                    else {
2193
-
                        let iy = cz()
2194
-
                        let iz = getString(iy)
2195
-
                        let iA = if (isDefined(iz))
2196
-
                            then split_4C(value(iz), "_")
2174
+
                        let iv = co()
2175
+
                        let iw = getString(iv)
2176
+
                        let ix = if (isDefined(iw))
2177
+
                            then split_4C(value(iw), "_")
2197
2178
 
                            else nil
2198
-
                        if (containsElement(iA, ix))
2199
-
                            then throw((ix + " is not newbie (already has referrals)"))
2179
+
                        if (containsElement(ix, iu))
2180
+
                            then throw((iu + " is not newbie (already has referrals)"))
2200
2181
 
                            else {
2201
-
                                let gN = aC(ix)
2202
-
                                let gO = getString(gN)
2203
-
                                if (if (isDefined(gO))
2204
-
                                    then isDefined(addressFromString(value(gO)))
2182
+
                                let gL = aB(iu)
2183
+
                                let gM = getString(gL)
2184
+
                                if (if (isDefined(gM))
2185
+
                                    then isDefined(addressFromString(value(gM)))
2205
2186
 
                                    else false)
2206
-
                                    then throw(((ix + " already has refBy: ") + value(gO)))
2187
+
                                    then throw(((iu + " already has refBy: ") + value(gM)))
2207
2188
 
                                    else {
2208
-
                                        let iB = aF(iw)
2209
-
                                        let iC = getString(iB)
2210
-
                                        let iD = if (isDefined(iC))
2211
-
                                            then split_4C(value(iC), "_")
2189
+
                                        let iy = aE(it)
2190
+
                                        let iz = getString(iy)
2191
+
                                        let iA = if (isDefined(iz))
2192
+
                                            then split_4C(value(iz), "_")
2212
2193
 
                                            else nil
2213
-
                                        if (containsElement(iD, ix))
2214
-
                                            then throw((((iw + " already contains ") + ix) + " within referrals"))
2194
+
                                        if (containsElement(iA, iu))
2195
+
                                            then throw((((it + " already contains ") + iu) + " within referrals"))
2215
2196
 
                                            else {
2216
-
                                                let iE = makeString_2C((iD :+ ix), "_")
2217
-
                                                let iF = if (containsElement(iA, iw))
2218
-
                                                    then value(iz)
2219
-
                                                    else makeString_2C((iA :+ iw), "_")
2220
-
                                                $Tuple2([StringEntry(gN, iw), StringEntry(iB, iE), StringEntry(iy, iF), hz], 0)
2197
+
                                                let iB = makeString_2C((iA :+ iu), "_")
2198
+
                                                let iC = if (containsElement(ix, it))
2199
+
                                                    then value(iw)
2200
+
                                                    else makeString_2C((ix :+ it), "_")
2201
+
                                                $Tuple2([StringEntry(gL, it), StringEntry(iy, iB), StringEntry(iv, iC), hx], 0)
2221
2202
 
                                                }
2222
2203
 
                                        }
2223
2204
 
                                }
2226
2207
 
2227
2208
 
2228
2209
 
2229
-
@Callable(du)
2230
-
func distributePoints (iG,iH,iI,iJ,iK) = {
2231
-
    let hz = hw(du)
2232
-
    if ((size(du.payments) != 0))
2210
+
@Callable(ds)
2211
+
func distributePoints (iD,iE,iF,iG,iH) = {
2212
+
    let hx = hu(ds)
2213
+
    if ((size(ds.payments) != 0))
2233
2214
 
        then throw("No payments required")
2234
2215
 
        else {
2235
-
            let p = toString(du.originCaller)
2236
-
            let k = valueOrErrorMessage(getString(aH(p)), "You don't have a duck staked")
2237
-
            let iL = r(p)
2238
-
            let iM = valueOrElse(getInteger(bG, iL), 0)
2239
-
            let iN = n(k)
2240
-
            let iO = valueOrElse(getInteger(bG, iN), 0)
2241
-
            let iP = (iM + iO)
2242
-
            let iQ = ((((iG + iH) + iI) + iJ) + iK)
2243
-
            if ((iQ > iP))
2244
-
                then throw((("There are only " + toString(iP)) + " free points to distribute"))
2216
+
            let p = toString(ds.originCaller)
2217
+
            let k = valueOrErrorMessage(getString(aG(p)), "You don't have a duck staked")
2218
+
            let iI = r(p)
2219
+
            let iJ = valueOrElse(getInteger(bv, iI), 0)
2220
+
            let iK = n(k)
2221
+
            let iL = valueOrElse(getInteger(bv, iK), 0)
2222
+
            let iM = (iJ + iL)
2223
+
            let iN = ((((iD + iE) + iF) + iG) + iH)
2224
+
            if ((iN > iM))
2225
+
                then throw((("There are only " + toString(iM)) + " free points to distribute"))
2245
2226
 
                else {
2246
-
                    let iR = j(k)
2247
-
                    let iS = split(valueOrElse(getString(bG, iR), "0_0_0_0_0"), "_")
2248
-
                    let iT = (iM - iQ)
2249
-
                    $Tuple2([IntegerEntry(iL, if ((0 > iT))
2227
+
                    let iO = j(k)
2228
+
                    let iP = split(valueOrElse(getString(bv, iO), "0_0_0_0_0"), "_")
2229
+
                    let iQ = (iJ - iN)
2230
+
                    $Tuple2([IntegerEntry(iI, if ((0 > iQ))
2250
2231
 
                        then 0
2251
-
                        else iT), IntegerEntry(iN, if ((0 > iT))
2252
-
                        then (iO + iT)
2253
-
                        else iO), StringEntry(iR, makeString([toString((parseIntValue(iS[e]) + iG)), toString((parseIntValue(iS[f]) + iH)), toString((parseIntValue(iS[g]) + iI)), toString((parseIntValue(iS[h]) + iJ)), toString((parseIntValue(iS[i]) + iK))], "_")), hz], 0)
2232
+
                        else iQ), IntegerEntry(iK, if ((0 > iQ))
2233
+
                        then (iL + iQ)
2234
+
                        else iL), StringEntry(iO, makeString([toString((parseIntValue(iP[e]) + iD)), toString((parseIntValue(iP[f]) + iE)), toString((parseIntValue(iP[g]) + iF)), toString((parseIntValue(iP[h]) + iG)), toString((parseIntValue(iP[i]) + iH))], "_")), hx], 0)
2254
2235
 
                    }
2255
2236
 
            }
2256
2237
 
    }
2257
2238
 
2258
2239
 
2259
2240
 
2260
-
@Callable(du)
2261
-
func splitByGlobalWeightsREADONLY (eL) = $Tuple2(nil, cQ(eL))
2262
-
2263
-
2264
-
2265
-
@Callable(du)
2266
-
func splitByGlobalAndLocalWeightsREADONLY (iU,iV,dx) = {
2267
-
    let dq = dw(dx)
2268
-
    $Tuple2(nil, $Tuple2(cQ(iU), cI(iV, dq)))
2269
-
    }
2270
-
2271
-
2272
-
2273
-
@Callable(du)
2274
-
func getBackpackREADONLY (k) = $Tuple2(nil, makeString(ec(aI(k)), ":"))
2275
-
2276
-
2277
-
2278
-
@Callable(du)
2279
-
func getWarehouseREADONLY (az) = {
2280
-
    let ga = value(assetInfo(fromBase58String(az)))
2281
-
    let ex = (bW(split(ga.description, "_")[bL]) / bm)
2282
-
    let ey = valueOrElse(getInteger(as(az)), 0)
2283
-
    $Tuple2(nil, makeString_2C(ev(ay(az), ex, ey), ":"))
2284
-
    }
2285
-
2286
-
2287
-
2288
-
@Callable(du)
2289
-
func saveLastTx () = if (if ((du.caller != bJ))
2290
-
    then (du.caller != bH)
2241
+
@Callable(ds)
2242
+
func splitByGlobalWeightsREADONLY (eI) = $Tuple2(nil, cM(eI))
2243
+
2244
+
2245
+
2246
+
@Callable(ds)
2247
+
func splitByGlobalAndLocalWeightsREADONLY (iR,iS,dv) = {
2248
+
    let do = du(dv)
2249
+
    $Tuple2(nil, $Tuple2(cM(iR), cx(iS, do)))
2250
+
    }
2251
+
2252
+
2253
+
2254
+
@Callable(ds)
2255
+
func getBackpackREADONLY (k) = $Tuple2(nil, makeString(ea(aH(k)), ":"))
2256
+
2257
+
2258
+
2259
+
@Callable(ds)
2260
+
func getWarehouseREADONLY (ay) = {
2261
+
    let fY = value(assetInfo(fromBase58String(ay)))
2262
+
    let eu = (bL(split(fY.description, "_")[bA]) / bb)
2263
+
    let ev = valueOrElse(getInteger(ar(ay)), 0)
2264
+
    $Tuple2(nil, makeString_2C(es(ax(ay), eu, ev), ":"))
2265
+
    }
2266
+
2267
+
2268
+
2269
+
@Callable(ds)
2270
+
func saveLastTx () = if (if ((ds.caller != by))
2271
+
    then (ds.caller != bw)
2291
2272
 
    else false)
2292
2273
 
    then throw("Access denied")
2293
-
    else $Tuple2([hw(du)], 42)
2294
-
2295
-
2296
-
2297
-
@Callable(du)
2298
-
func updateDuckStats (k,gG) = if ((du.caller != bH))
2274
+
    else $Tuple2([hu(ds)], 42)
2275
+
2276
+
2277
+
2278
+
@Callable(ds)
2279
+
func updateDuckStats (k,gE) = if ((ds.caller != bw))
2299
2280
 
    then throw("Access denied")
2300
-
    else gF(k, gG)
2301
-
2302
-
2303
-
2304
-
@Callable(du)
2305
-
func updateAccStats (p,gG) = if ((du.caller != bH))
2281
+
    else gD(k, gE)
2282
+
2283
+
2284
+
2285
+
@Callable(ds)
2286
+
func updateAccStats (p,gE) = if ((ds.caller != bw))
2306
2287
 
    then throw("Access denied")
2307
-
    else gL(p, gG)
2288
+
    else gJ(p, gE)
2308
2289
 
2309
2290
 

Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 6 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
let a = 100000000
5
5
 
6
6
 
let b = 3200
7
7
 
8
8
 
let c = 4000
9
9
 
10
10
 
let d = 3
11
11
 
12
12
 
let e = 0
13
13
 
14
14
 
let f = 1
15
15
 
16
16
 
let g = 2
17
17
 
18
18
 
let h = 3
19
19
 
20
20
 
let i = 4
21
21
 
22
22
 
func j (k) = ("duckChars_" + k)
23
23
 
24
24
 
25
25
 
func l (k) = ("duckXP_" + k)
26
26
 
27
27
 
28
28
 
func m (k) = ("duckLevel_" + k)
29
29
 
30
30
 
31
31
 
func n (k) = ("duckFreePoints_" + k)
32
32
 
33
33
 
34
34
 
func o (p) = ("userXP_" + p)
35
35
 
36
36
 
37
37
 
func q (p) = ("userLevel_" + p)
38
38
 
39
39
 
40
40
 
func r (p) = ("userFreePoints_" + p)
41
41
 
42
42
 
43
43
 
let s = 100000
44
44
 
45
45
 
let t = 50000
46
46
 
47
47
 
let u = 10000
48
48
 
49
49
 
let v = 100000
50
50
 
51
51
 
let w = 5000000
52
52
 
53
53
 
let x = 50000000
54
54
 
55
55
 
let y = 100000
56
56
 
57
57
 
let z = 10000000
58
58
 
59
59
 
let A = 10000000
60
60
 
61
61
 
let B = 10000
62
62
 
63
63
 
func C (D) = fraction(b, pow(D, 4, c, 4, 4, DOWN), a)
64
64
 
65
65
 
66
66
 
func E (F) = (100 + F)
67
67
 
68
68
 
69
69
 
func G (H,I) = {
70
70
 
    let J = C(I)
71
71
 
[J, (d * (J - H))]
72
72
 
    }
73
73
 
74
74
 
75
75
 
let K = "LAND"
76
76
 
77
77
 
let L = "DUCK"
78
78
 
79
79
 
let M = "PRESALE"
80
80
 
81
81
 
let N = 6
82
82
 
83
83
 
let O = 3456000
84
84
 
85
85
 
let P = 86400000
86
86
 
87
87
 
let Q = 10000000000
88
88
 
89
89
 
let R = "Africa_F_Africa"
90
90
 
91
91
 
let S = 39637
92
92
 
93
93
 
let T = 10
94
94
 
95
95
 
let U = ["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"]
96
96
 
97
97
 
let V = ["Americas", "Europe", "Asia", "Africa", "Oceania"]
98
98
 
99
-
let W = ["1_1_1_2_2_5_1_10_0", "2_2_2_4_4_10_1_10_0", "3_3_3_6_6_15_1_10_0", "2_5_5_2_7_5_2_25_1", "4_10_10_4_14_10_2_25_1", "6_15_15_6_21_15_2_25_1", "1_1_1_1_1_8_1_10_2", "2_2_2_2_2_16_1_10_2", "3_3_3_3_3_24_1_10_2", "9_9_1_5_5_1_5_30_3", "18_18_2_10_10_2_5_30_3", "27_27_3_15_15_3_5_30_3", "2_2_1_2_2_2_1_10_4", "4_4_2_4_4_4_1_10_4", "6_6_3_6_6_6_1_10_4"]
100
-
101
-
let X = 7
102
-
103
-
let Y = 0
104
-
105
-
let Z = 1
106
-
107
-
let aa = 2
108
-
109
-
let ab = 3
110
-
111
-
let ac = 4
112
-
113
-
let ad = 0
114
-
115
-
let ae = 1
116
-
117
-
let af = 2
118
-
119
-
let ag = 3
120
-
121
-
let ah = 0
122
-
123
-
let ai = 1
124
-
125
-
let aj = 2
126
-
127
-
let ak = 3
128
-
129
-
func al (am) = parseIntValue(split(W[am], "_")[X])
130
-
131
-
132
-
func an (p) = ("lastTxIdByUser_" + p)
133
-
134
-
135
-
func ao (ap) = ("nftOwner_" + ap)
136
-
137
-
138
-
func aq (ap) = ("landCustomNameByAssetId_" + ap)
139
-
140
-
141
-
func ar (ap) = ("stakedTime_" + ap)
142
-
143
-
144
-
func as (ap) = ("infraLevel_" + ap)
145
-
146
-
147
-
func at (au,ap) = makeString(["landArtStatus", au, ap], "_")
148
-
149
-
150
-
func av (aw,ap,ax) = ((((("stakedTimeByTypeAssetIdAndOwner_" + aw) + "_") + ap) + "_") + ax)
151
-
152
-
153
-
func ay (az) = ("wareHouse_" + az)
154
-
155
-
156
-
func aA (ap) = ("duckCustomNameByAssetId_" + ap)
157
-
158
-
159
-
func aB (p) = ("accountCustomNameByAddr_" + p)
160
-
161
-
162
-
func aC (p) = ("accRefBy_" + p)
163
-
164
-
165
-
func aD (k) = ("onboardArtActivatedOnDuck_" + k)
166
-
167
-
168
-
func aE (p) = ("onboardArtActivatedDuckBy_" + p)
169
-
170
-
171
-
func aF (p) = ("accReferrals_" + p)
172
-
173
-
174
-
func aG (ap) = ("duckOwner_" + ap)
175
-
176
-
177
-
func aH (ax) = ("stakedDuckByOwner_" + ax)
178
-
179
-
180
-
func aI (k) = ("backPack_" + k)
181
-
182
-
183
-
func aJ (k) = ("duckLocation_" + k)
184
-
185
-
186
-
func aK (k) = ("duckHealth_" + k)
187
-
188
-
189
-
func aL () = "contractsBlocked"
190
-
191
-
192
-
func aM (aN) = ("%s%s__userGwlReleaseTime__" + aN)
193
-
194
-
195
-
func aO () = "emergencyWarehouseProducts"
196
-
197
-
198
-
let aP = 1
199
-
200
-
let aQ = 2
201
-
202
-
func aR (aS) = {
203
-
    func aT (aU,aV) =     (aU + parseIntValue(aS[aV]))
204
-
205
-
    let aW = [0, 1, 2, 3, 4, 5]
206
-
    let aX = size(aW)
207
-
    let aY = 0
208
-
    func aZ (ba,bb) =     if ((bb >= aX))
209
-
        then ba
210
-
        else aT(ba, aW[bb])
211
-
212
-
    func bc (ba,bb) =     if ((bb >= aX))
213
-
        then ba
214
-
        else throw("List size exceeds 6")
215
-
216
-
    bc(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6)
217
-
    }
218
-
219
-
220
-
let bd = true
221
-
222
-
let be = take(drop(this.bytes, 1), 1)
223
-
224
-
let bf = {
225
-
    let bg = be
226
-
    if ((base58'2W' == bg))
99
+
let W = ["8_8_8_17_17_42_12_0", "8_8_8_17_17_42_24_0", "8_8_8_17_17_42_36_0", "8_19_19_8_27_19_26_1", "8_19_19_8_27_19_52_1", "8_19_19_8_27_19_78_1", "8_8_8_8_8_60_13_2", "8_8_8_8_8_60_26_2", "8_8_8_8_8_60_39_2", "30_30_3_17_17_3_30_3", "30_30_3_17_17_3_60_3", "30_30_3_17_17_3_90_3", "18_18_10_18_18_18_11_4", "18_18_10_18_18_18_22_4", "18_18_10_18_18_18_33_4"]
100
+
101
+
let X = 6
102
+
103
+
let Y = 10
104
+
105
+
let Z = 0
106
+
107
+
let aa = 1
108
+
109
+
let ab = 2
110
+
111
+
let ac = 3
112
+
113
+
let ad = 4
114
+
115
+
let ae = 0
116
+
117
+
let af = 1
118
+
119
+
let ag = 2
120
+
121
+
let ah = 3
122
+
123
+
let ai = 0
124
+
125
+
let aj = 1
126
+
127
+
let ak = 2
128
+
129
+
let al = 3
130
+
131
+
func am (p) = ("lastTxIdByUser_" + p)
132
+
133
+
134
+
func an (ao) = ("nftOwner_" + ao)
135
+
136
+
137
+
func ap (ao) = ("landCustomNameByAssetId_" + ao)
138
+
139
+
140
+
func aq (ao) = ("stakedTime_" + ao)
141
+
142
+
143
+
func ar (ao) = ("infraLevel_" + ao)
144
+
145
+
146
+
func as (at,ao) = makeString(["landArtStatus", at, ao], "_")
147
+
148
+
149
+
func au (av,ao,aw) = ((((("stakedTimeByTypeAssetIdAndOwner_" + av) + "_") + ao) + "_") + aw)
150
+
151
+
152
+
func ax (ay) = ("wareHouse_" + ay)
153
+
154
+
155
+
func az (ao) = ("duckCustomNameByAssetId_" + ao)
156
+
157
+
158
+
func aA (p) = ("accountCustomNameByAddr_" + p)
159
+
160
+
161
+
func aB (p) = ("accRefBy_" + p)
162
+
163
+
164
+
func aC (k) = ("onboardArtActivatedOnDuck_" + k)
165
+
166
+
167
+
func aD (p) = ("onboardArtActivatedDuckBy_" + p)
168
+
169
+
170
+
func aE (p) = ("accReferrals_" + p)
171
+
172
+
173
+
func aF (ao) = ("duckOwner_" + ao)
174
+
175
+
176
+
func aG (aw) = ("stakedDuckByOwner_" + aw)
177
+
178
+
179
+
func aH (k) = ("backPack_" + k)
180
+
181
+
182
+
func aI (k) = ("duckLocation_" + k)
183
+
184
+
185
+
func aJ (k) = ("duckHealth_" + k)
186
+
187
+
188
+
func aK () = "contractsBlocked"
189
+
190
+
191
+
func aL (aM) = ("%s%s__userGwlReleaseTime__" + aM)
192
+
193
+
194
+
func aN () = "emergencyWarehouseProducts"
195
+
196
+
197
+
let aO = 1
198
+
199
+
let aP = 2
200
+
201
+
func aQ (aR) = parseIntValue(aR[X])
202
+
203
+
204
+
let aS = true
205
+
206
+
let aT = take(drop(this.bytes, 1), 1)
207
+
208
+
let aU = {
209
+
    let aV = aT
210
+
    if ((base58'2W' == aV))
227
211
 
        then base58'9wc3LXNA4TEBsXyKtoLE9mrbDD7WMHXvXrCjZvabLAsi'
228
-
        else if ((base58'2T' == bg))
212
+
        else if ((base58'2T' == aV))
229
213
 
            then base58'6mWwf9mZBjVgkC54idpyaZLQfAosD914wT8fGf2iiY63'
230
214
 
            else throw("Unknown chain")
231
215
 
    }
232
216
 
233
-
let bh = {
234
-
    let bg = be
235
-
    if ((base58'2W' == bg))
217
+
let aW = {
218
+
    let aV = aT
219
+
    if ((base58'2W' == aV))
236
220
 
        then "3PQCuvFbvh4LkPUnrnU1z3jnbA1p9m3WNhv"
237
-
        else if ((base58'2T' == bg))
221
+
        else if ((base58'2T' == aV))
238
222
 
            then "3MumkGGztCKAXpWDqxkddofqXSUbqQkvSJy"
239
223
 
            else throw("Unknown chain")
240
224
 
    }
241
225
 
242
-
let bi = {
243
-
    let bg = be
244
-
    if ((base58'2W' == bg))
226
+
let aX = {
227
+
    let aV = aT
228
+
    if ((base58'2W' == aV))
245
229
 
        then 10000000000
246
-
        else if ((base58'2T' == bg))
230
+
        else if ((base58'2T' == aV))
247
231
 
            then 100000000
248
232
 
            else throw("Unknown chain")
249
233
 
    }
250
234
 
251
-
let bj = "__"
252
-
253
-
let bk = 1000000
254
-
255
-
let bl = 100000000
256
-
257
-
let bm = 25
258
-
259
-
let bn = 100
260
-
261
-
let bo = 225
262
-
263
-
let bp = 400
264
-
265
-
let bq = 625
266
-
267
-
func br (bs,bt) = valueOrErrorMessage(getString(bs, bt), makeString(["mandatory ", toString(bs), ".", bt, " is not defined"], ""))
268
-
269
-
270
-
let bu = 1
271
-
272
-
let bv = 2
273
-
274
-
let bw = 3
275
-
276
-
let bx = 4
277
-
278
-
func by () = "%s__restConfig"
279
-
280
-
281
-
func bz () = "%s__restAddr"
282
-
283
-
284
-
func bA (bB) = split_4C(br(bB, by()), bj)
285
-
286
-
287
-
func bC (bD,bE) = valueOrErrorMessage(addressFromString(bD[bE]), ("Rest cfg doesn't contain address at index " + toString(bE)))
288
-
289
-
290
-
let bF = addressFromStringValue(valueOrElse(getString(this, bz()), bh))
291
-
292
-
let bD = bA(bF)
293
-
294
-
let bG = bC(bD, bu)
295
-
296
-
let bH = bC(bD, bv)
297
-
298
-
let bI = bC(bD, bw)
299
-
300
-
let bJ = bC(bD, bx)
301
-
302
-
let bK = 0
303
-
304
-
let bL = 1
305
-
306
-
let bM = 2
307
-
308
-
let bN = 3
309
-
310
-
func bO () = "resTypesProportions"
311
-
312
-
313
-
func bP (ax) = ("stakedLandsByOwner_" + ax)
314
-
315
-
316
-
func bQ (ax) = ("stakedPiecesByOwner_" + ax)
317
-
318
-
319
-
func bR (bS) = {
320
-
    let bg = bS
321
-
    if ($isInstanceOf(bg, "String"))
235
+
let aY = "__"
236
+
237
+
let aZ = 1000000
238
+
239
+
let ba = 100000000
240
+
241
+
let bb = 25
242
+
243
+
let bc = 100
244
+
245
+
let bd = 225
246
+
247
+
let be = 400
248
+
249
+
let bf = 625
250
+
251
+
func bg (bh,bi) = valueOrErrorMessage(getString(bh, bi), makeString(["mandatory ", toString(bh), ".", bi, " is not defined"], ""))
252
+
253
+
254
+
let bj = 1
255
+
256
+
let bk = 2
257
+
258
+
let bl = 3
259
+
260
+
let bm = 4
261
+
262
+
func bn () = "%s__restConfig"
263
+
264
+
265
+
func bo () = "%s__restAddr"
266
+
267
+
268
+
func bp (bq) = split_4C(bg(bq, bn()), aY)
269
+
270
+
271
+
func br (bs,bt) = valueOrErrorMessage(addressFromString(bs[bt]), ("Rest cfg doesn't contain address at index " + toString(bt)))
272
+
273
+
274
+
let bu = addressFromStringValue(valueOrElse(getString(this, bo()), aW))
275
+
276
+
let bs = bp(bu)
277
+
278
+
let bv = br(bs, bj)
279
+
280
+
let bw = br(bs, bk)
281
+
282
+
let bx = br(bs, bl)
283
+
284
+
let by = br(bs, bm)
285
+
286
+
let bz = 0
287
+
288
+
let bA = 1
289
+
290
+
let bB = 2
291
+
292
+
let bC = 3
293
+
294
+
func bD () = "resTypesProportions"
295
+
296
+
297
+
func bE (aw) = ("stakedLandsByOwner_" + aw)
298
+
299
+
300
+
func bF (aw) = ("stakedPiecesByOwner_" + aw)
301
+
302
+
303
+
func bG (bH) = {
304
+
    let aV = bH
305
+
    if ($isInstanceOf(aV, "String"))
322
306
 
        then {
323
-
            let bT = bg
324
-
            bT
307
+
            let bI = aV
308
+
            bI
325
309
 
            }
326
310
 
        else throw("fail to cast into String")
327
311
 
    }
328
312
 
329
313
 
330
-
func bU (bS) = {
331
-
    let bg = bS
332
-
    if ($isInstanceOf(bg, "Int"))
314
+
func bJ (bH) = {
315
+
    let aV = bH
316
+
    if ($isInstanceOf(aV, "Int"))
333
317
 
        then {
334
-
            let bV = bg
335
-
            bV
318
+
            let bK = aV
319
+
            bK
336
320
 
            }
337
321
 
        else throw("fail to cast into Int")
338
322
 
    }
339
323
 
340
324
 
341
-
func bW (bX) = {
342
-
    let bg = bX
343
-
    if (("S" == bg))
344
-
        then bm
345
-
        else if (("M" == bg))
346
-
            then bn
347
-
            else if (("L" == bg))
348
-
                then bo
349
-
                else if (("XL" == bg))
350
-
                    then bp
351
-
                    else if (("XXL" == bg))
352
-
                        then bq
325
+
func bL (bM) = {
326
+
    let aV = bM
327
+
    if (("S" == aV))
328
+
        then bb
329
+
        else if (("M" == aV))
330
+
            then bc
331
+
            else if (("L" == aV))
332
+
                then bd
333
+
                else if (("XL" == aV))
334
+
                    then be
335
+
                    else if (("XXL" == aV))
336
+
                        then bf
353
337
 
                        else throw("Unknown land size")
354
338
 
    }
355
339
 
356
340
 
357
-
let bY = {
358
-
    let bg = be
359
-
    if ((base58'2W' == bg))
341
+
let bN = {
342
+
    let aV = aT
343
+
    if ((base58'2W' == aV))
360
344
 
        then addressFromStringValue("3PEktVux2RhchSN63DsDo4b4mz4QqzKSeDv")
361
-
        else if ((base58'2T' == bg))
345
+
        else if ((base58'2T' == aV))
362
346
 
            then this
363
347
 
            else throw("Unknown chain")
364
348
 
    }
365
349
 
366
-
let bZ = {
367
-
    let bg = be
368
-
    if ((base58'2W' == bg))
350
+
let bO = {
351
+
    let aV = aT
352
+
    if ((base58'2W' == aV))
369
353
 
        then addressFromStringValue("3PDVuU45H7Eh5dmtNbnRNRStGwULA7NY6Hb")
370
-
        else if ((base58'2T' == bg))
354
+
        else if ((base58'2T' == aV))
371
355
 
            then this
372
356
 
            else throw("Unknown chain")
373
357
 
    }
374
358
 
375
-
let ca = base58'6LfPuKJjLgekmncBhMg2LZyMTNVzZBccXR28ySXm9uXD'
376
-
377
-
let cb = [30, 60, 120]
378
-
379
-
let cc = 300000
380
-
381
-
let cd = 5000000
382
-
383
-
let ce = 50
384
-
385
-
let cf = 10000000
386
-
387
-
let cg = {
388
-
    let bg = be
389
-
    if ((base58'2W' == bg))
359
+
let bP = base58'6LfPuKJjLgekmncBhMg2LZyMTNVzZBccXR28ySXm9uXD'
360
+
361
+
let bQ = [30, 60, 120]
362
+
363
+
let bR = 300000
364
+
365
+
let bS = 5000000
366
+
367
+
let bT = 50
368
+
369
+
let bU = 10000000
370
+
371
+
let bV = {
372
+
    let aV = aT
373
+
    if ((base58'2W' == aV))
390
374
 
        then 252289527462
391
-
        else if ((base58'2T' == bg))
375
+
        else if ((base58'2T' == aV))
392
376
 
            then 2522895274
393
377
 
            else throw("Unknown chain")
394
378
 
    }
395
379
 
396
-
let ch = {
397
-
    let bg = be
398
-
    if ((base58'2W' == bg))
380
+
let bW = {
381
+
    let aV = aT
382
+
    if ((base58'2W' == aV))
399
383
 
        then 250000000
400
-
        else if ((base58'2T' == bg))
384
+
        else if ((base58'2T' == aV))
401
385
 
            then 250000000
402
386
 
            else throw("Unknown chain")
403
387
 
    }
404
388
 
405
-
let ci = toBigInt(5)
406
-
407
-
let cj = toBigInt(20)
408
-
409
-
let ck = toBigInt((20 * 20))
410
-
411
-
let cl = toBigInt(((20 * 20) * 20))
412
-
413
-
let cm = toBigInt((((20 * 20) * 20) * 20))
414
-
415
-
let cn = toBigInt(((((20 * 20) * 20) * 20) * 20))
416
-
417
-
let co = 500
418
-
419
-
func cp () = "nextLandNum"
420
-
421
-
422
-
func cq (cr) = ("landToAsset_" + cr)
423
-
424
-
425
-
func cs (ct) = ("landByCustomName_" + ct)
426
-
427
-
428
-
func cu (ap,ax) = ((("infraLevelByAssetIdAndOwner_" + ap) + "_") + ax)
429
-
430
-
431
-
func cv (au,ap,ax) = makeString(["landArtStatusByTypeAssetIdAndOwner", au, ap, ax], "_")
432
-
433
-
434
-
func cw (cr) = ("landOwner_" + cr)
435
-
436
-
437
-
func cx (ct) = ("duckByCustomName_" + ct)
438
-
439
-
440
-
func cy (ct) = ("accountByCustomName_" + ct)
441
-
442
-
443
-
func cz () = "oldiesList"
444
-
445
-
446
-
let cA = 0
447
-
448
-
let cB = 1
449
-
450
-
let cC = 2
451
-
452
-
let cD = 0
453
-
454
-
let cE = 5
455
-
456
-
let cF = 6
457
-
458
-
let cG = 7
459
-
460
-
func cH (cr,bX) = ((K + cr) + bX)
461
-
462
-
463
-
func cI (cJ,cK) = {
464
-
    let cL = (((((cK[0] + cK[1]) + cK[2]) + cK[3]) + cK[4]) + cK[5])
465
-
    if ((0 >= cL))
389
+
let bX = toBigInt(5)
390
+
391
+
let bY = toBigInt(20)
392
+
393
+
let bZ = toBigInt((20 * 20))
394
+
395
+
let ca = toBigInt(((20 * 20) * 20))
396
+
397
+
let cb = toBigInt((((20 * 20) * 20) * 20))
398
+
399
+
let cc = toBigInt(((((20 * 20) * 20) * 20) * 20))
400
+
401
+
let cd = 500
402
+
403
+
func ce () = "nextLandNum"
404
+
405
+
406
+
func cf (cg) = ("landToAsset_" + cg)
407
+
408
+
409
+
func ch (ci) = ("landByCustomName_" + ci)
410
+
411
+
412
+
func cj (ao,aw) = ((("infraLevelByAssetIdAndOwner_" + ao) + "_") + aw)
413
+
414
+
415
+
func ck (at,ao,aw) = makeString(["landArtStatusByTypeAssetIdAndOwner", at, ao, aw], "_")
416
+
417
+
418
+
func cl (cg) = ("landOwner_" + cg)
419
+
420
+
421
+
func cm (ci) = ("duckByCustomName_" + ci)
422
+
423
+
424
+
func cn (ci) = ("accountByCustomName_" + ci)
425
+
426
+
427
+
func co () = "oldiesList"
428
+
429
+
430
+
let cp = 0
431
+
432
+
let cq = 1
433
+
434
+
let cr = 2
435
+
436
+
let cs = 0
437
+
438
+
let ct = 5
439
+
440
+
let cu = 6
441
+
442
+
let cv = 7
443
+
444
+
func cw (cg,bM) = ((K + cg) + bM)
445
+
446
+
447
+
func cx (cy,cz) = {
448
+
    let cA = (((((cz[0] + cz[1]) + cz[2]) + cz[3]) + cz[4]) + cz[5])
449
+
    if ((0 >= cA))
466
450
 
        then throw("Zero weights sum")
467
451
 
        else {
468
-
            let cM = fraction(cJ, bk, cL)
469
-
            func cN (cO,cP) =             (cO :+ fraction(cP, cM, bk))
470
-
471
-
            let aW = cK
472
-
            let aX = size(aW)
473
-
            let aY = nil
474
-
            func aZ (ba,bb) =             if ((bb >= aX))
475
-
                then ba
476
-
                else cN(ba, aW[bb])
477
-
478
-
            func bc (ba,bb) =             if ((bb >= aX))
479
-
                then ba
452
+
            let cB = fraction(cy, aZ, cA)
453
+
            func cC (cD,cE) =             (cD :+ fraction(cE, cB, aZ))
454
+
455
+
            let cF = cz
456
+
            let cG = size(cF)
457
+
            let cH = nil
458
+
            func cI (cJ,cK) =             if ((cK >= cG))
459
+
                then cJ
460
+
                else cC(cJ, cF[cK])
461
+
462
+
            func cL (cJ,cK) =             if ((cK >= cG))
463
+
                then cJ
480
464
 
                else throw("List size exceeds 6")
481
465
 
482
-
            bc(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6)
483
-
            }
484
-
    }
485
-
486
-
487
-
func cQ (cJ) = {
488
-
    let cR = split(value(getString(bO())), "_")
489
-
    if ((size(cR) != N))
466
+
            cL(cI(cI(cI(cI(cI(cI(cH, 0), 1), 2), 3), 4), 5), 6)
467
+
            }
468
+
    }
469
+
470
+
471
+
func cM (cy) = {
472
+
    let cN = split(value(getString(bD())), "_")
473
+
    if ((size(cN) != N))
490
474
 
        then throw("Wrong proportions data")
491
475
 
        else {
492
-
            let cS = [parseIntValue(cR[0]), parseIntValue(cR[1]), parseIntValue(cR[2]), parseIntValue(cR[3]), parseIntValue(cR[4]), parseIntValue(cR[5])]
493
-
            cI(cJ, cS)
494
-
            }
495
-
    }
496
-
497
-
498
-
func cT (cU,cV,cW) = {
499
-
    let cX = cQ(cW)
500
-
    func cY (cO,bE) =     {
501
-
        let cZ = (parseIntValue(cV[bE]) - cX[bE])
502
-
        if ((0 > cZ))
503
-
            then throw(((((("Not enough material idx=" + toString(bE)) + ", you have ") + cV[bE]) + ", but need ") + toString(cX[bE])))
504
-
            else (cO :+ toString(cZ))
476
+
            let cO = [parseIntValue(cN[0]), parseIntValue(cN[1]), parseIntValue(cN[2]), parseIntValue(cN[3]), parseIntValue(cN[4]), parseIntValue(cN[5])]
477
+
            cx(cy, cO)
478
+
            }
479
+
    }
480
+
481
+
482
+
func cP (cQ,cR,cS) = {
483
+
    let cT = cM(cS)
484
+
    func cU (cD,bt) =     {
485
+
        let cV = (parseIntValue(cR[bt]) - cT[bt])
486
+
        if ((0 > cV))
487
+
            then throw(((((("Not enough material idx=" + toString(bt)) + ", you have ") + cR[bt]) + ", but need ") + toString(cT[bt])))
488
+
            else (cD :+ toString(cV))
505
489
 
        }
506
490
 
507
-
    if (cU)
491
+
    if (cQ)
508
492
 
        then {
509
-
            let aW = [0, 1, 2, 3, 4, 5]
510
-
            let aX = size(aW)
511
-
            let aY = nil
512
-
            func aZ (ba,bb) =             if ((bb >= aX))
513
-
                then ba
514
-
                else cY(ba, aW[bb])
515
-
516
-
            func bc (ba,bb) =             if ((bb >= aX))
517
-
                then ba
493
+
            let cF = [0, 1, 2, 3, 4, 5]
494
+
            let cG = size(cF)
495
+
            let cH = nil
496
+
            func cI (cJ,cK) =             if ((cK >= cG))
497
+
                then cJ
498
+
                else cU(cJ, cF[cK])
499
+
500
+
            func cL (cJ,cK) =             if ((cK >= cG))
501
+
                then cJ
518
502
 
                else throw("List size exceeds 6")
519
503
 
520
-
            bc(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6)
521
-
            }
522
-
        else cV
523
-
    }
524
-
525
-
526
-
func da (db,dc) = if ((dc == ""))
527
-
    then db
504
+
            cL(cI(cI(cI(cI(cI(cI(cH, 0), 1), 2), 3), 4), 5), 6)
505
+
            }
506
+
        else cR
507
+
    }
508
+
509
+
510
+
func cW (cX,cY) = if ((cY == ""))
511
+
    then cX
528
512
 
    else {
529
-
        let dd = if ((db == ""))
513
+
        let cZ = if ((cX == ""))
530
514
 
            then nil
531
-
            else split(db, "_")
532
-
        func de (cO,df) =         {
533
-
            let aV = cO._1
534
-
            func dg (aU,dh) =             {
535
-
                let di = split(dh, ",")
536
-
                if ((size(di) != 2))
515
+
            else split(cX, "_")
516
+
        func da (cD,db) =         {
517
+
            let dc = cD._1
518
+
            func dd (de,df) =             {
519
+
                let dg = split(df, ",")
520
+
                if ((size(dg) != 2))
537
521
 
                    then throw("Incorrect format, should be index,amount")
538
522
 
                    else {
539
-
                        let bE = parseIntValue(di[0])
540
-
                        if (if ((0 > bE))
523
+
                        let bt = parseIntValue(dg[0])
524
+
                        if (if ((0 > bt))
541
525
 
                            then true
542
-
                            else (bE >= size(W)))
526
+
                            else (bt >= size(W)))
543
527
 
                            then throw("Unknown product idx")
544
-
                            else if ((bE != aV))
545
-
                                then aU
528
+
                            else if ((bt != dc))
529
+
                                then de
546
530
 
                                else {
547
-
                                    let dj = parseIntValue(di[1])
548
-
                                    if ((0 >= dj))
531
+
                                    let dh = parseIntValue(dg[1])
532
+
                                    if ((0 >= dh))
549
533
 
                                        then throw("Pass only positive amounts")
550
-
                                        else (aU + dj)
534
+
                                        else (de + dh)
551
535
 
                                    }
552
536
 
                        }
553
537
 
                }
554
538
 
555
-
            let dk = {
556
-
                let aW = split(dc, "_")
557
-
                let aX = size(aW)
558
-
                let aY = 0
559
-
                func aZ (ba,bb) =                 if ((bb >= aX))
560
-
                    then ba
561
-
                    else dg(ba, aW[bb])
562
-
563
-
                func bc (ba,bb) =                 if ((bb >= aX))
564
-
                    then ba
539
+
            let di = {
540
+
                let cF = split(cY, "_")
541
+
                let cG = size(cF)
542
+
                let cH = 0
543
+
                func cI (cJ,cK) =                 if ((cK >= cG))
544
+
                    then cJ
545
+
                    else dd(cJ, cF[cK])
546
+
547
+
                func cL (cJ,cK) =                 if ((cK >= cG))
548
+
                    then cJ
565
549
 
                    else throw("List size exceeds 10")
566
550
 
567
-
                bc(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
551
+
                cL(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cH, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
568
552
 
                }
569
-
            let dl = if ((size(dd) > aV))
570
-
                then parseIntValue(dd[aV])
553
+
            let dj = if ((size(cZ) > dc))
554
+
                then parseIntValue(cZ[dc])
571
555
 
                else 0
572
-
            let dm = if ((dk > dl))
573
-
                then throw(((((("You have " + toString(dl)) + " of ") + U[aV]) + ", but tried to use ") + toString(dk)))
574
-
                else (dl - dk)
575
-
            $Tuple2((aV + 1), (cO._2 :+ toString(dm)))
576
-
            }
577
-
578
-
        let dn = {
579
-
            let aW = W
580
-
            let aX = size(aW)
581
-
            let aY = $Tuple2(0, nil)
582
-
            func aZ (ba,bb) =             if ((bb >= aX))
583
-
                then ba
584
-
                else de(ba, aW[bb])
585
-
586
-
            func bc (ba,bb) =             if ((bb >= aX))
587
-
                then ba
556
+
            let dk = if ((dj >= di))
557
+
                then (dj - di)
558
+
                else throw(((((("You have " + toString(dj)) + " of ") + U[dc]) + ", but tried to use ") + toString(di)))
559
+
            $Tuple2((dc + 1), (cD._2 :+ toString(dk)))
560
+
            }
561
+
562
+
        let dl = {
563
+
            let cF = W
564
+
            let cG = size(cF)
565
+
            let cH = $Tuple2(0, nil)
566
+
            func cI (cJ,cK) =             if ((cK >= cG))
567
+
                then cJ
568
+
                else da(cJ, cF[cK])
569
+
570
+
            func cL (cJ,cK) =             if ((cK >= cG))
571
+
                then cJ
588
572
 
                else throw("List size exceeds 50")
589
573
 
590
-
            bc(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aY, 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)
591
-
            }
592
-
        makeString(dn._2, "_")
574
+
            cL(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cH, 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)
575
+
            }
576
+
        makeString(dl._2, "_")
593
577
 
        }
594
578
 
595
579
 
596
-
func do (dp,dq,dr,ds) = if ((size(dp) != N))
580
+
func dm (dn,do,dp,dq) = if ((size(dn) != N))
597
581
 
    then throw("Wrong proportions data")
598
582
 
    else {
599
-
        func dt (cO,du) =         {
600
-
            let cZ = (parseIntValue(dp[du]) + ((ds * dq[du]) * dr))
601
-
            if ((0 > cZ))
602
-
                then throw(((((((("Panic! Pieces of type=" + toString(du)) + ", sign=") + toString(ds)) + ",  terrainCounts[i]=") + toString(dq[du])) + ", landSizeIndex=") + toString(dr)))
603
-
                else (cO :+ toString(cZ))
604
-
            }
605
-
606
-
        let cS = {
607
-
            let aW = [0, 1, 2, 3, 4, 5]
608
-
            let aX = size(aW)
609
-
            let aY = nil
610
-
            func aZ (ba,bb) =             if ((bb >= aX))
611
-
                then ba
612
-
                else dt(ba, aW[bb])
613
-
614
-
            func bc (ba,bb) =             if ((bb >= aX))
615
-
                then ba
583
+
        func dr (cD,ds) =         {
584
+
            let cV = (parseIntValue(dn[ds]) + ((dq * do[ds]) * dp))
585
+
            if ((0 > cV))
586
+
                then throw(((((((("Panic! Pieces of type=" + toString(ds)) + ", sign=") + toString(dq)) + ",  terrainCounts[i]=") + toString(do[ds])) + ", landSizeIndex=") + toString(dp)))
587
+
                else (cD :+ toString(cV))
588
+
            }
589
+
590
+
        let cO = {
591
+
            let cF = [0, 1, 2, 3, 4, 5]
592
+
            let cG = size(cF)
593
+
            let cH = nil
594
+
            func cI (cJ,cK) =             if ((cK >= cG))
595
+
                then cJ
596
+
                else dr(cJ, cF[cK])
597
+
598
+
            func cL (cJ,cK) =             if ((cK >= cG))
599
+
                then cJ
616
600
 
                else throw("List size exceeds 6")
617
601
 
618
-
            bc(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6)
619
-
            }
620
-
        makeString(cS, "_")
602
+
            cL(cI(cI(cI(cI(cI(cI(cH, 0), 1), 2), 3), 4), 5), 6)
603
+
            }
604
+
        makeString(cO, "_")
621
605
 
        }
622
606
 
623
607
 
624
-
func dv (dq,dr,ds) = {
625
-
    let dp = split(valueOrElse(getString(bO()), "0_0_0_0_0_0"), "_")
626
-
    do(dp, dq, dr, ds)
627
-
    }
628
-
629
-
630
-
func dw (dx) = [(size(split(dx, "A")) - 1), (size(split(dx, "B")) - 1), (size(split(dx, "C")) - 1), (size(split(dx, "D")) - 1), (size(split(dx, "E")) - 1), (size(split(dx, "F")) - 1)]
631
-
632
-
633
-
func dy (dz,dq,dA,dr,dB) = {
634
-
    func dC (cO,du) =     {
635
-
        let dD = ((fraction(dA, dB, P) * dq[du]) * dr)
636
-
        (cO :+ toString((parseIntValue(dz[du]) + dD)))
608
+
func dt (do,dp,dq) = {
609
+
    let dn = split(valueOrElse(getString(bD()), "0_0_0_0_0_0"), "_")
610
+
    dm(dn, do, dp, dq)
611
+
    }
612
+
613
+
614
+
func du (dv) = [(size(split(dv, "A")) - 1), (size(split(dv, "B")) - 1), (size(split(dv, "C")) - 1), (size(split(dv, "D")) - 1), (size(split(dv, "E")) - 1), (size(split(dv, "F")) - 1)]
615
+
616
+
617
+
func dw (dx,do,dy,dp,dz) = {
618
+
    func dA (cD,ds) =     {
619
+
        let dB = ((fraction(dy, dz, P) * do[ds]) * dp)
620
+
        (cD :+ toString((parseIntValue(dx[ds]) + dB)))
637
621
 
        }
638
622
 
639
-
    let cS = {
640
-
        let aW = [0, 1, 2, 3, 4, 5]
641
-
        let aX = size(aW)
642
-
        let aY = nil
643
-
        func aZ (ba,bb) =         if ((bb >= aX))
644
-
            then ba
645
-
            else dC(ba, aW[bb])
646
-
647
-
        func bc (ba,bb) =         if ((bb >= aX))
648
-
            then ba
623
+
    let cO = {
624
+
        let cF = [0, 1, 2, 3, 4, 5]
625
+
        let cG = size(cF)
626
+
        let cH = nil
627
+
        func cI (cJ,cK) =         if ((cK >= cG))
628
+
            then cJ
629
+
            else dA(cJ, cF[cK])
630
+
631
+
        func cL (cJ,cK) =         if ((cK >= cG))
632
+
            then cJ
649
633
 
            else throw("List size exceeds 6")
650
634
 
651
-
        bc(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6)
635
+
        cL(cI(cI(cI(cI(cI(cI(cH, 0), 1), 2), 3), 4), 5), 6)
652
636
 
        }
653
-
    makeString(cS, "_")
654
-
    }
655
-
656
-
657
-
func dE (dq,dA,dr,dB) = {
658
-
    func dC (cO,du) =     {
659
-
        let dD = ((fraction(dA, dB, P) * dq[du]) * dr)
660
-
        $Tuple2((cO._1 :+ dD), (cO._2 + dD))
637
+
    makeString(cO, "_")
638
+
    }
639
+
640
+
641
+
func dC (do,dy,dp,dz) = {
642
+
    func dA (cD,ds) =     {
643
+
        let dB = ((fraction(dy, dz, P) * do[ds]) * dp)
644
+
        $Tuple2((cD._1 :+ dB), (cD._2 + dB))
661
645
 
        }
662
646
 
663
-
    let aW = [0, 1, 2, 3, 4, 5]
664
-
    let aX = size(aW)
665
-
    let aY = $Tuple2(nil, 0)
666
-
    func aZ (ba,bb) =     if ((bb >= aX))
667
-
        then ba
668
-
        else dC(ba, aW[bb])
669
-
670
-
    func bc (ba,bb) =     if ((bb >= aX))
671
-
        then ba
647
+
    let cF = [0, 1, 2, 3, 4, 5]
648
+
    let cG = size(cF)
649
+
    let cH = $Tuple2(nil, 0)
650
+
    func cI (cJ,cK) =     if ((cK >= cG))
651
+
        then cJ
652
+
        else dA(cJ, cF[cK])
653
+
654
+
    func cL (cJ,cK) =     if ((cK >= cG))
655
+
        then cJ
672
656
 
        else throw("List size exceeds 6")
673
657
 
674
-
    bc(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6)
675
-
    }
676
-
677
-
678
-
func dF (dG,dH,dI,dJ) = {
679
-
    let dK = dI._1
680
-
    let dL = dI._2
681
-
    if ((dL == 0))
682
-
        then $Tuple2(makeString(dG, "_"), makeString(dH, "_"))
683
-
        else if ((dJ >= dL))
658
+
    cL(cI(cI(cI(cI(cI(cI(cH, 0), 1), 2), 3), 4), 5), 6)
659
+
    }
660
+
661
+
662
+
func dD (dE,dF,dG,dH) = {
663
+
    let dI = dG._1
664
+
    let dJ = dG._2
665
+
    if ((dJ == 0))
666
+
        then $Tuple2(makeString(dE, "_"), makeString(dF, "_"))
667
+
        else if ((dH >= dJ))
684
668
 
            then {
685
-
                func dM (cO,du) =                 (cO :+ toString((parseIntValue(dG[du]) + dK[du])))
686
-
687
-
                let cS = {
688
-
                    let aW = [0, 1, 2, 3, 4, 5]
689
-
                    let aX = size(aW)
690
-
                    let aY = nil
691
-
                    func aZ (ba,bb) =                     if ((bb >= aX))
692
-
                        then ba
693
-
                        else dM(ba, aW[bb])
694
-
695
-
                    func bc (ba,bb) =                     if ((bb >= aX))
696
-
                        then ba
669
+
                func dK (cD,ds) =                 (cD :+ toString((parseIntValue(dE[ds]) + dI[ds])))
670
+
671
+
                let cO = {
672
+
                    let cF = [0, 1, 2, 3, 4, 5]
673
+
                    let cG = size(cF)
674
+
                    let cH = nil
675
+
                    func cI (cJ,cK) =                     if ((cK >= cG))
676
+
                        then cJ
677
+
                        else dK(cJ, cF[cK])
678
+
679
+
                    func cL (cJ,cK) =                     if ((cK >= cG))
680
+
                        then cJ
697
681
 
                        else throw("List size exceeds 6")
698
682
 
699
-
                    bc(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6)
683
+
                    cL(cI(cI(cI(cI(cI(cI(cH, 0), 1), 2), 3), 4), 5), 6)
700
684
 
                    }
701
-
                $Tuple2(makeString(cS, "_"), makeString(dH, "_"))
685
+
                $Tuple2(makeString(cO, "_"), makeString(dF, "_"))
702
686
 
                }
703
687
 
            else {
704
-
                func dN (cO,du) =                 {
705
-
                    let dO = fraction(dK[du], dJ, dL)
706
-
                    $Tuple2((cO._1 :+ toString((parseIntValue(dG[du]) + dO))), (cO._2 :+ toString(((parseIntValue(dH[du]) + dK[du]) - dO))))
688
+
                func dL (cD,ds) =                 {
689
+
                    let dM = fraction(dI[ds], dH, dJ)
690
+
                    $Tuple2((cD._1 :+ toString((parseIntValue(dE[ds]) + dM))), (cD._2 :+ toString(((parseIntValue(dF[ds]) + dI[ds]) - dM))))
707
691
 
                    }
708
692
 
709
-
                let cS = {
710
-
                    let aW = [0, 1, 2, 3, 4, 5]
711
-
                    let aX = size(aW)
712
-
                    let aY = $Tuple2(nil, nil)
713
-
                    func aZ (ba,bb) =                     if ((bb >= aX))
714
-
                        then ba
715
-
                        else dN(ba, aW[bb])
716
-
717
-
                    func bc (ba,bb) =                     if ((bb >= aX))
718
-
                        then ba
693
+
                let cO = {
694
+
                    let cF = [0, 1, 2, 3, 4, 5]
695
+
                    let cG = size(cF)
696
+
                    let cH = $Tuple2(nil, nil)
697
+
                    func cI (cJ,cK) =                     if ((cK >= cG))
698
+
                        then cJ
699
+
                        else dL(cJ, cF[cK])
700
+
701
+
                    func cL (cJ,cK) =                     if ((cK >= cG))
702
+
                        then cJ
719
703
 
                        else throw("List size exceeds 6")
720
704
 
721
-
                    bc(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6)
705
+
                    cL(cI(cI(cI(cI(cI(cI(cH, 0), 1), 2), 3), 4), 5), 6)
722
706
 
                    }
723
-
                $Tuple2(makeString(cS._1, "_"), makeString(cS._2, "_"))
707
+
                $Tuple2(makeString(cO._1, "_"), makeString(cO._2, "_"))
724
708
 
                }
725
709
 
    }
726
710
 
727
711
 
728
-
func dP (dQ) = if ((dQ >= toBigInt(0)))
729
-
    then dQ
730
-
    else -(dQ)
731
-
732
-
733
-
let dR = [[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]]
734
-
735
-
func dS (bV,dT) = {
736
-
    let dU = toInt((bV % cj))
737
-
    let dV = if ((dT[0] > dU))
712
+
func dN (dO) = if ((dO >= toBigInt(0)))
713
+
    then dO
714
+
    else -(dO)
715
+
716
+
717
+
let dP = [[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]]
718
+
719
+
func dQ (bK,dR) = {
720
+
    let dS = toInt((bK % bY))
721
+
    let dT = if ((dR[0] > dS))
738
722
 
        then "A"
739
-
        else if ((dT[1] > dU))
723
+
        else if ((dR[1] > dS))
740
724
 
            then "B"
741
-
            else if ((dT[2] > dU))
725
+
            else if ((dR[2] > dS))
742
726
 
                then "C"
743
-
                else if ((dT[3] > dU))
727
+
                else if ((dR[3] > dS))
744
728
 
                    then "D"
745
-
                    else if ((dT[4] > dU))
729
+
                    else if ((dR[4] > dS))
746
730
 
                        then "E"
747
731
 
                        else "F"
748
-
    dV
749
-
    }
750
-
751
-
752
-
func dW (dX,dY) = {
753
-
    let dZ = dR[dY]
754
-
    func ea (cO,cP) =     $Tuple2((((((cO._1 + dS(cO._2, dZ)) + dS((cO._2 / cj), dZ)) + dS((cO._2 / ck), dZ)) + dS((cO._2 / cl), dZ)) + dS((cO._2 / cm), dZ)), (cO._2 / cn))
755
-
756
-
    let eb = {
757
-
        let aW = [1, 2, 3, 4, 5]
758
-
        let aX = size(aW)
759
-
        let aY = $Tuple2("", (dX / ci))
760
-
        func aZ (ba,bb) =         if ((bb >= aX))
761
-
            then ba
762
-
            else ea(ba, aW[bb])
763
-
764
-
        func bc (ba,bb) =         if ((bb >= aX))
765
-
            then ba
732
+
    dT
733
+
    }
734
+
735
+
736
+
func dU (dV,dW) = {
737
+
    let dX = dP[dW]
738
+
    func dY (cD,cE) =     $Tuple2((((((cD._1 + dQ(cD._2, dX)) + dQ((cD._2 / bY), dX)) + dQ((cD._2 / bZ), dX)) + dQ((cD._2 / ca), dX)) + dQ((cD._2 / cb), dX)), (cD._2 / cc))
739
+
740
+
    let dZ = {
741
+
        let cF = [1, 2, 3, 4, 5]
742
+
        let cG = size(cF)
743
+
        let cH = $Tuple2("", (dV / bX))
744
+
        func cI (cJ,cK) =         if ((cK >= cG))
745
+
            then cJ
746
+
            else dY(cJ, cF[cK])
747
+
748
+
        func cL (cJ,cK) =         if ((cK >= cG))
749
+
            then cJ
766
750
 
            else throw("List size exceeds 5")
767
751
 
768
-
        bc(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5)
752
+
        cL(cI(cI(cI(cI(cI(cH, 0), 1), 2), 3), 4), 5)
769
753
 
        }
770
-
    eb._1
771
-
    }
772
-
773
-
774
-
func ec (ed) = {
775
-
    let ee = split(valueOrElse(getString(ed), "0:0_0_0_0_0_0:0_0_0_0_0_0:"), ":")
776
-
[toString(valueOrElse(parseInt(ee[ah]), 0)), if ((size(split(ee[ai], "_")) == N))
777
-
        then ee[ai]
778
-
        else "0_0_0_0_0_0", if ((size(split(ee[aj], "_")) == N))
779
-
        then ee[aj]
780
-
        else "0_0_0_0_0_0", ee[ak]]
754
+
    dZ._1
755
+
    }
756
+
757
+
758
+
func ea (eb) = {
759
+
    let ec = split(valueOrElse(getString(eb), "0:0_0_0_0_0_0:0_0_0_0_0_0:"), ":")
760
+
[toString(valueOrElse(parseInt(ec[ai]), 0)), if ((size(split(ec[aj], "_")) == N))
761
+
        then ec[aj]
762
+
        else "0_0_0_0_0_0", if ((size(split(ec[ak], "_")) == N))
763
+
        then ec[ak]
764
+
        else "0_0_0_0_0_0", ec[al]]
765
+
    }
766
+
767
+
768
+
func ed (ee) = {
769
+
    let dg = split(ee, "_")
770
+
    ((Q * (parseIntValue(dg[1]) + 1)) * parseIntValue(dg[0]))
781
771
 
    }
782
772
 
783
773
 
784
774
 
func ef (eg) = {
785
-
    let di = split(eg, "_")
786
-
    ((Q * (parseIntValue(di[1]) + 1)) * parseIntValue(di[0]))
787
-
    }
788
-
789
-
790
-
func eh (ei) = {
791
-
    let ej = ei[ab]
792
-
    func ek (cO,df) =     (cO + parseIntValue(df))
793
-
794
-
    func el (cO,df) =     {
795
-
        let bE = cO._1
796
-
        let em = al(bE)
797
-
        let en = (((parseIntValue(df) + em) - 1) / em)
798
-
        $Tuple2((bE + 1), (cO._2 + (en * bl)))
775
+
    let eh = eg[ac]
776
+
    func ei (cD,db) =     (cD + parseIntValue(db))
777
+
778
+
    func ej (cD,db) =     {
779
+
        let bt = cD._1
780
+
        let ek = (((parseIntValue(db) + Y) - 1) / Y)
781
+
        $Tuple2((bt + 1), (cD._2 + (ek * ba)))
799
782
 
        }
800
783
 
801
-
    let eo = {
802
-
        let aW = split(ei[Z], "_")
803
-
        let aX = size(aW)
804
-
        let aY = 0
805
-
        func aZ (ba,bb) =         if ((bb >= aX))
806
-
            then ba
807
-
            else ek(ba, aW[bb])
808
-
809
-
        func bc (ba,bb) =         if ((bb >= aX))
810
-
            then ba
784
+
    let el = {
785
+
        let cF = split(eg[aa], "_")
786
+
        let cG = size(cF)
787
+
        let cH = 0
788
+
        func cI (cJ,cK) =         if ((cK >= cG))
789
+
            then cJ
790
+
            else ei(cJ, cF[cK])
791
+
792
+
        func cL (cJ,cK) =         if ((cK >= cG))
793
+
            then cJ
811
794
 
            else throw("List size exceeds 6")
812
795
 
813
-
        bc(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6)
796
+
        cL(cI(cI(cI(cI(cI(cI(cH, 0), 1), 2), 3), 4), 5), 6)
814
797
 
        }
815
-
    let ep = {
816
-
        let aW = split(ei[aa], "_")
817
-
        let aX = size(aW)
818
-
        let aY = 0
819
-
        func eq (ba,bb) =         if ((bb >= aX))
820
-
            then ba
821
-
            else ek(ba, aW[bb])
822
-
823
-
        func er (ba,bb) =         if ((bb >= aX))
824
-
            then ba
798
+
    let em = {
799
+
        let cF = split(eg[ab], "_")
800
+
        let cG = size(cF)
801
+
        let cH = 0
802
+
        func en (cJ,cK) =         if ((cK >= cG))
803
+
            then cJ
804
+
            else ei(cJ, cF[cK])
805
+
806
+
        func eo (cJ,cK) =         if ((cK >= cG))
807
+
            then cJ
825
808
 
            else throw("List size exceeds 6")
826
809
 
827
-
        er(eq(eq(eq(eq(eq(eq(aY, 0), 1), 2), 3), 4), 5), 6)
810
+
        eo(en(en(en(en(en(en(cH, 0), 1), 2), 3), 4), 5), 6)
828
811
 
        }
829
-
    let es = if ((ej == ""))
812
+
    let ep = if ((eh == ""))
830
813
 
        then 0
831
-
        else (        let aW = split_4C(ej, "_")
832
-
        let aX = size(aW)
833
-
        let aY = $Tuple2(0, 0)
834
-
        func et (ba,bb) =         if ((bb >= aX))
835
-
            then ba
836
-
            else el(ba, aW[bb])
837
-
838
-
        func eu (ba,bb) =         if ((bb >= aX))
839
-
            then ba
814
+
        else (        let cF = split_4C(eh, "_")
815
+
        let cG = size(cF)
816
+
        let cH = $Tuple2(0, 0)
817
+
        func eq (cJ,cK) =         if ((cK >= cG))
818
+
            then cJ
819
+
            else ej(cJ, cF[cK])
820
+
821
+
        func er (cJ,cK) =         if ((cK >= cG))
822
+
            then cJ
840
823
 
            else throw("List size exceeds 50")
841
824
 
842
-
        eu(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(aY, 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
843
-
    ((eo + ep) + es)
844
-
    }
845
-
846
-
847
-
func ev (ew,ex,ey) = {
848
-
    let eg = ((toString(ex) + "_") + toString(ey))
849
-
    let ez = ef(eg)
850
-
    let eA = valueOrElse(getString(ew), (eg + ":0_0_0_0_0_0:0_0_0_0_0_0::0"))
851
-
    let eB = split_4C(eA, ":")
852
-
    let eC = eh(eB)
853
-
    let eD = if ((5 > size(eB)))
854
-
        then makeString(["0", toString(eC), toString((ez - eC)), toString(ez)], "_")
855
-
        else {
856
-
            let eE = split(eB[ac], "_")
857
-
            let eF = parseIntValue(eE[ad])
858
-
            let eG = if ((size(eE) > 1))
859
-
                then parseIntValue(eE[ae])
860
-
                else eC
861
-
            makeString([toString(eF), toString(eG), toString(((ez - eF) - eG)), toString(ez)], "_")
862
-
            }
863
-
[eB[Y], if ((size(split(eB[Z], "_")) == N))
864
-
        then eB[Z]
865
-
        else "0_0_0_0_0_0", if ((size(split(eB[aa], "_")) == N))
866
-
        then eB[aa]
867
-
        else "0_0_0_0_0_0", eB[ab], eD]
868
-
    }
869
-
870
-
871
-
func eH (ei) = {
872
-
    let eI = eh(ei)
873
-
    let eJ = parseIntValue(split(ei[ac], "_")[ad])
874
-
    ((ef(ei[Y]) - eI) - eJ)
875
-
    }
876
-
877
-
878
-
func eK (eL,em) = {
879
-
    let en = if ((eL >= 0))
880
-
        then (((eL + em) - 1) / em)
881
-
        else -((((-(eL) + em) - 1) / em))
882
-
    (en * bl)
883
-
    }
884
-
885
-
886
-
func eM (eN,ei,eO) = if ((size(eN) != 3))
825
+
        er(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(cH, 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
826
+
    ((el + em) + ep)
827
+
    }
828
+
829
+
830
+
func es (et,eu,ev) = {
831
+
    let ee = ((toString(eu) + "_") + toString(ev))
832
+
    let ew = ed(ee)
833
+
    let ex = valueOrElse(getString(et), (ee + ":0_0_0_0_0_0:0_0_0_0_0_0::0"))
834
+
    let ey = split_4C(ex, ":")
835
+
    let ez = ef(ey)
836
+
    let eA = if ((5 > size(ey)))
837
+
        then makeString(["0", toString(ez), toString((ew - ez)), toString(ew)], "_")
838
+
        else {
839
+
            let eB = split(ey[ad], "_")
840
+
            let eC = parseIntValue(eB[ae])
841
+
            let eD = if ((size(eB) > 1))
842
+
                then parseIntValue(eB[af])
843
+
                else ez
844
+
            makeString([toString(eC), toString(eD), toString(((ew - eC) - eD)), toString(ew)], "_")
845
+
            }
846
+
[ey[Z], if ((size(split(ey[aa], "_")) == N))
847
+
        then ey[aa]
848
+
        else "0_0_0_0_0_0", if ((size(split(ey[ab], "_")) == N))
849
+
        then ey[ab]
850
+
        else "0_0_0_0_0_0", ey[ac], eA]
851
+
    }
852
+
853
+
854
+
func eE (eg) = {
855
+
    let eF = ef(eg)
856
+
    let eG = parseIntValue(split(eg[ad], "_")[ae])
857
+
    ((ed(eg[Z]) - eF) - eG)
858
+
    }
859
+
860
+
861
+
func eH (eI,eJ) = {
862
+
    let ek = if ((eI >= 0))
863
+
        then (((eI + eJ) - 1) / eJ)
864
+
        else -((((-(eI) + eJ) - 1) / eJ))
865
+
    (ek * ba)
866
+
    }
867
+
868
+
869
+
func eK (eL,eg,eM) = if ((size(eL) != 3))
887
870
 
    then throw("cargoListStr should contain exactly 2 ':' separators")
888
871
 
    else {
889
-
        let eP = split(eN[0], "_")
890
-
        let eQ = split(eN[1], "_")
891
-
        let eR = if ((eN[2] == ""))
872
+
        let eN = split(eL[0], "_")
873
+
        let eO = split(eL[1], "_")
874
+
        let eP = if ((eL[2] == ""))
892
875
 
            then nil
893
-
            else split(eN[2], "_")
894
-
        if ((size(eP) != N))
876
+
            else split(eL[2], "_")
877
+
        if ((size(eN) != N))
895
878
 
            then throw("All 6 resources should be passed")
896
-
            else if ((size(eQ) != N))
879
+
            else if ((size(eO) != N))
897
880
 
                then throw("All 6 materials should be passed")
898
881
 
                else {
899
-
                    let dJ = eH(ei)
900
-
                    let eS = split(ei[Z], "_")
901
-
                    let eT = split(ei[aa], "_")
902
-
                    let eU = if ((ei[ab] == ""))
882
+
                    let dH = eE(eg)
883
+
                    let eQ = split(eg[aa], "_")
884
+
                    let eR = split(eg[ab], "_")
885
+
                    let eS = if ((eg[ac] == ""))
903
886
 
                        then nil
904
-
                        else split(ei[ab], "_")
905
-
                    let dH = split(eO[ai], "_")
906
-
                    let eV = split(eO[aj], "_")
907
-
                    let eW = if ((eO[ak] == ""))
887
+
                        else split(eg[ac], "_")
888
+
                    let dF = split(eM[aj], "_")
889
+
                    let eT = split(eM[ak], "_")
890
+
                    let eU = if ((eM[al] == ""))
908
891
 
                        then nil
909
-
                        else split(eO[ak], "_")
910
-
                    func eX (cO,df) =                     {
911
-
                        let du = cO._1
912
-
                        let eY = parseIntValue(df)
913
-
                        let eZ = parseIntValue(eS[du])
914
-
                        let fa = parseIntValue(dH[du])
915
-
                        if ((eY == 0))
916
-
                            then $Tuple4((du + 1), (cO._2 :+ eS[du]), (cO._3 :+ dH[du]), cO._4)
917
-
                            else if ((eY > 0))
918
-
                                then if ((eY > fa))
919
-
                                    then throw((((("Attempt to take " + df) + " from backpack, but only ") + toString(fa)) + " available"))
920
-
                                    else $Tuple4((du + 1), (cO._2 :+ toString((eZ + eY))), (cO._3 :+ toString((fa - eY))), (cO._4 + eY))
921
-
                                else if ((-(eY) > eZ))
922
-
                                    then throw((((("Attempt to take " + toString(-(eY))) + " from warehouse, but only ") + toString(eZ)) + " available"))
923
-
                                    else $Tuple4((du + 1), (cO._2 :+ toString((eZ + eY))), (cO._3 :+ toString((fa - eY))), (cO._4 + eY))
892
+
                        else split(eM[al], "_")
893
+
                    func eV (cD,db) =                     {
894
+
                        let ds = cD._1
895
+
                        let eW = parseIntValue(db)
896
+
                        let eX = parseIntValue(eQ[ds])
897
+
                        let eY = parseIntValue(dF[ds])
898
+
                        if ((eW == 0))
899
+
                            then $Tuple4((ds + 1), (cD._2 :+ eQ[ds]), (cD._3 :+ dF[ds]), cD._4)
900
+
                            else if ((eW > 0))
901
+
                                then if ((eW > eY))
902
+
                                    then throw((((("Attempt to take " + db) + " from backpack, but only ") + toString(eY)) + " available"))
903
+
                                    else $Tuple4((ds + 1), (cD._2 :+ toString((eX + eW))), (cD._3 :+ toString((eY - eW))), (cD._4 + eW))
904
+
                                else if ((-(eW) > eX))
905
+
                                    then throw((((("Attempt to take " + toString(-(eW))) + " from warehouse, but only ") + toString(eX)) + " available"))
906
+
                                    else $Tuple4((ds + 1), (cD._2 :+ toString((eX + eW))), (cD._3 :+ toString((eY - eW))), (cD._4 + eW))
924
907
 
                        }
925
908
 
926
-
                    let cS = {
927
-
                        let aW = eP
928
-
                        let aX = size(aW)
929
-
                        let aY = $Tuple4(0, nil, nil, 0)
930
-
                        func aZ (ba,bb) =                         if ((bb >= aX))
931
-
                            then ba
932
-
                            else eX(ba, aW[bb])
933
-
934
-
                        func bc (ba,bb) =                         if ((bb >= aX))
935
-
                            then ba
909
+
                    let cO = {
910
+
                        let cF = eN
911
+
                        let cG = size(cF)
912
+
                        let cH = $Tuple4(0, nil, nil, 0)
913
+
                        func cI (cJ,cK) =                         if ((cK >= cG))
914
+
                            then cJ
915
+
                            else eV(cJ, cF[cK])
916
+
917
+
                        func cL (cJ,cK) =                         if ((cK >= cG))
918
+
                            then cJ
936
919
 
                            else throw("List size exceeds 6")
937
920
 
938
-
                        bc(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6)
921
+
                        cL(cI(cI(cI(cI(cI(cI(cH, 0), 1), 2), 3), 4), 5), 6)
939
922
 
                        }
940
-
                    func fb (cO,df) =                     {
941
-
                        let du = cO._1
942
-
                        let eY = parseIntValue(df)
943
-
                        let fc = parseIntValue(eT[du])
944
-
                        let fd = parseIntValue(eV[du])
945
-
                        if ((eY == 0))
946
-
                            then $Tuple4((du + 1), (cO._2 :+ eT[du]), (cO._3 :+ eV[du]), cO._4)
947
-
                            else if ((eY > 0))
948
-
                                then if ((eY > fd))
949
-
                                    then throw((((("Attempt to take " + df) + " from backpack, but only ") + toString(fd)) + " available"))
950
-
                                    else $Tuple4((du + 1), (cO._2 :+ toString((fc + eY))), (cO._3 :+ toString((fd - eY))), (cO._4 + eY))
951
-
                                else if ((-(eY) > fc))
952
-
                                    then throw((((("Attempt to take " + toString(-(eY))) + " from warehouse, but only ") + toString(fc)) + " available"))
953
-
                                    else $Tuple4((du + 1), (cO._2 :+ toString((fc + eY))), (cO._3 :+ toString((fd - eY))), (cO._4 + eY))
923
+
                    func eZ (cD,db) =                     {
924
+
                        let ds = cD._1
925
+
                        let eW = parseIntValue(db)
926
+
                        let fa = parseIntValue(eR[ds])
927
+
                        let fb = parseIntValue(eT[ds])
928
+
                        if ((eW == 0))
929
+
                            then $Tuple4((ds + 1), (cD._2 :+ eR[ds]), (cD._3 :+ eT[ds]), cD._4)
930
+
                            else if ((eW > 0))
931
+
                                then if ((eW > fb))
932
+
                                    then throw((((("Attempt to take " + db) + " from backpack, but only ") + toString(fb)) + " available"))
933
+
                                    else $Tuple4((ds + 1), (cD._2 :+ toString((fa + eW))), (cD._3 :+ toString((fb - eW))), (cD._4 + eW))
934
+
                                else if ((-(eW) > fa))
935
+
                                    then throw((((("Attempt to take " + toString(-(eW))) + " from warehouse, but only ") + toString(fa)) + " available"))
936
+
                                    else $Tuple4((ds + 1), (cD._2 :+ toString((fa + eW))), (cD._3 :+ toString((fb - eW))), (cD._4 + eW))
954
937
 
                        }
955
938
 
956
-
                    let fe = {
957
-
                        let aW = eQ
958
-
                        let aX = size(aW)
959
-
                        let aY = $Tuple4(0, nil, nil, cS._4)
960
-
                        func eq (ba,bb) =                         if ((bb >= aX))
961
-
                            then ba
962
-
                            else fb(ba, aW[bb])
963
-
964
-
                        func er (ba,bb) =                         if ((bb >= aX))
965
-
                            then ba
939
+
                    let fc = {
940
+
                        let cF = eO
941
+
                        let cG = size(cF)
942
+
                        let cH = $Tuple4(0, nil, nil, cO._4)
943
+
                        func en (cJ,cK) =                         if ((cK >= cG))
944
+
                            then cJ
945
+
                            else eZ(cJ, cF[cK])
946
+
947
+
                        func eo (cJ,cK) =                         if ((cK >= cG))
948
+
                            then cJ
966
949
 
                            else throw("List size exceeds 6")
967
950
 
968
-
                        er(eq(eq(eq(eq(eq(eq(aY, 0), 1), 2), 3), 4), 5), 6)
951
+
                        eo(en(en(en(en(en(en(cH, 0), 1), 2), 3), 4), 5), 6)
969
952
 
                        }
970
-
                    func ff (cO,df) =                     {
971
-
                        let du = cO._1
972
-
                        let em = al(du)
973
-
                        let eY = parseIntValue(df)
974
-
                        let fg = if ((size(eU) > du))
975
-
                            then parseIntValue(eU[du])
953
+
                    func fd (cD,db) =                     {
954
+
                        let ds = cD._1
955
+
                        let eW = parseIntValue(db)
956
+
                        let fe = if ((size(eS) > ds))
957
+
                            then parseIntValue(eS[ds])
976
958
 
                            else 0
977
-
                        let fh = if ((size(eW) > du))
978
-
                            then parseIntValue(eW[du])
959
+
                        let ff = if ((size(eU) > ds))
960
+
                            then parseIntValue(eU[ds])
979
961
 
                            else 0
980
-
                        if ((eY == 0))
981
-
                            then $Tuple4((du + 1), (cO._2 :+ toString(fg)), (cO._3 :+ toString(fh)), cO._4)
982
-
                            else if ((eY > 0))
983
-
                                then if ((eY > fh))
984
-
                                    then throw((((("Attempt to take " + df) + " from backpack, but only ") + toString(fh)) + " available"))
962
+
                        if ((eW == 0))
963
+
                            then $Tuple4((ds + 1), (cD._2 :+ toString(fe)), (cD._3 :+ toString(ff)), cD._4)
964
+
                            else if ((eW > 0))
965
+
                                then if ((eW > ff))
966
+
                                    then throw((((("Attempt to take " + db) + " from backpack, but only ") + toString(ff)) + " available"))
985
967
 
                                    else {
986
-
                                        let fi = (eK((fg + eY), em) - eK(fg, em))
987
-
                                        $Tuple4((du + 1), (cO._2 :+ toString((fg + eY))), (cO._3 :+ toString((fh - eY))), (cO._4 + fi))
968
+
                                        let fg = (eH((fe + eW), Y) - eH(fe, Y))
969
+
                                        $Tuple4((ds + 1), (cD._2 :+ toString((fe + eW))), (cD._3 :+ toString((ff - eW))), (cD._4 + fg))
988
970
 
                                        }
989
-
                                else if ((-(eY) > fg))
990
-
                                    then throw((((("Attempt to take " + toString(-(eY))) + " from warehouse, but only ") + toString(fg)) + " available"))
971
+
                                else if ((-(eW) > fe))
972
+
                                    then throw((((("Attempt to take " + toString(-(eW))) + " from warehouse, but only ") + toString(fe)) + " available"))
991
973
 
                                    else {
992
-
                                        let fi = (eK((fg + eY), em) - eK(fg, em))
993
-
                                        $Tuple4((du + 1), (cO._2 :+ toString((fg + eY))), (cO._3 :+ toString((fh - eY))), (cO._4 + fi))
974
+
                                        let fg = (eH((fe + eW), Y) - eH(fe, Y))
975
+
                                        $Tuple4((ds + 1), (cD._2 :+ toString((fe + eW))), (cD._3 :+ toString((ff - eW))), (cD._4 + fg))
994
976
 
                                        }
995
977
 
                        }
996
978
 
997
-
                    let ee = if ((size(eR) != 0))
979
+
                    let ec = if ((size(eP) != 0))
998
980
 
                        then {
999
-
                            let aW = eR
1000
-
                            let aX = size(aW)
1001
-
                            let aY = $Tuple4(0, nil, nil, fe._4)
1002
-
                            func et (ba,bb) =                             if ((bb >= aX))
1003
-
                                then ba
1004
-
                                else ff(ba, aW[bb])
1005
-
1006
-
                            func eu (ba,bb) =                             if ((bb >= aX))
1007
-
                                then ba
981
+
                            let cF = eP
982
+
                            let cG = size(cF)
983
+
                            let cH = $Tuple4(0, nil, nil, fc._4)
984
+
                            func eq (cJ,cK) =                             if ((cK >= cG))
985
+
                                then cJ
986
+
                                else fd(cJ, cF[cK])
987
+
988
+
                            func er (cJ,cK) =                             if ((cK >= cG))
989
+
                                then cJ
1008
990
 
                                else throw("List size exceeds 50")
1009
991
 
1010
-
                            eu(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(et(aY, 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)
992
+
                            er(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(eq(cH, 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)
1011
993
 
                            }
1012
-
                        else $Tuple4(0, eU, eW, fe._4)
1013
-
                    let fj = ee._4
1014
-
                    if ((fj > dJ))
1015
-
                        then throw((((("Attempt to put total " + toString(fj)) + " stuff, but only ") + toString(dJ)) + " warehouse space left"))
1016
-
                        else $Tuple7(makeString(cS._2, "_"), makeString(fe._2, "_"), makeString(ee._2, "_"), makeString(cS._3, "_"), makeString(fe._3, "_"), makeString(ee._3, "_"), fj)
994
+
                        else $Tuple4(0, eS, eU, fc._4)
995
+
                    let fh = ec._4
996
+
                    if ((fh > dH))
997
+
                        then throw((((("Attempt to put total " + toString(fh)) + " stuff, but only ") + toString(dH)) + " warehouse space left"))
998
+
                        else $Tuple7(makeString(cO._2, "_"), makeString(fc._2, "_"), makeString(ec._2, "_"), makeString(cO._3, "_"), makeString(fc._3, "_"), makeString(ec._3, "_"), fh)
1017
999
 
                    }
1018
1000
 
        }
1019
1001
 
1020
1002
 
1021
-
func fk (fl,fm) = {
1022
-
    let aN = toString(fl)
1023
-
    let fn = dP(toBigInt(fm))
1024
-
    let fo = valueOrElse(getInteger(cp()), (co + 1))
1025
-
    let cr = toString(fo)
1026
-
    let dY = toInt((fn % ci))
1027
-
    let dx = dW(fn, dY)
1028
-
    let fp = V[dY]
1029
-
    let fq = Issue(cH(cr, "S"), makeString([cr, "S", dx, fp], "_"), 1, 0, false)
1030
-
    let ap = calculateAssetId(fq)
1031
-
    let fr = toBase58String(ap)
1032
-
    $Tuple2([IntegerEntry(cp(), (fo + 1)), fq, StringEntry(cq(cr), fr), StringEntry(ao(fr), aN), StringEntry(cw(cr), aN), IntegerEntry(as(fr), 0), IntegerEntry(cu(fr, aN), 0), ScriptTransfer(fl, 1, ap)], $Tuple2(fr, fp))
1033
-
    }
1034
-
1035
-
1036
-
func fs (aN,ft,fu) = if (!(sigVerify_8Kb(ft, fu, ca)))
1003
+
func fi (fj,fk) = {
1004
+
    let aM = toString(fj)
1005
+
    let fl = dN(toBigInt(fk))
1006
+
    let fm = valueOrElse(getInteger(ce()), (cd + 1))
1007
+
    let cg = toString(fm)
1008
+
    let dW = toInt((fl % bX))
1009
+
    let dv = dU(fl, dW)
1010
+
    let fn = V[dW]
1011
+
    let fo = Issue(cw(cg, "S"), makeString([cg, "S", dv, fn], "_"), 1, 0, false)
1012
+
    let ao = calculateAssetId(fo)
1013
+
    let fp = toBase58String(ao)
1014
+
    $Tuple2([IntegerEntry(ce(), (fm + 1)), fo, StringEntry(cf(cg), fp), StringEntry(an(fp), aM), StringEntry(cl(cg), aM), IntegerEntry(ar(fp), 0), IntegerEntry(cj(fp, aM), 0), ScriptTransfer(fj, 1, ao)], $Tuple2(fp, fn))
1015
+
    }
1016
+
1017
+
1018
+
func fq (aM,fr,fs) = if (!(sigVerify_8Kb(fr, fs, bP)))
1037
1019
 
    then throw("signature does not match")
1038
1020
 
    else {
1039
-
        let di = split(toUtf8String(ft), ";")
1040
-
        let fv = split(di[0], "|")
1041
-
        let fw = split(fv[cD], "_")
1042
-
        let fx = parseIntValue(fw[0])
1043
-
        let fy = parseIntValue(fw[1])
1044
-
        let fz = split(di[1], ":")
1045
-
        let fA = fz[0]
1046
-
        let fB = parseIntValue(fv[cE])
1047
-
        if (if ((fB > (lastBlock.timestamp + cc)))
1021
+
        let dg = split(toUtf8String(fr), ";")
1022
+
        let ft = split(dg[0], "|")
1023
+
        let fu = split(ft[cs], "_")
1024
+
        let fv = parseIntValue(fu[0])
1025
+
        let fw = parseIntValue(fu[1])
1026
+
        let fx = split(dg[1], ":")
1027
+
        let fy = fx[0]
1028
+
        let fz = parseIntValue(ft[ct])
1029
+
        if (if ((fz > (lastBlock.timestamp + bR)))
1048
1030
 
            then true
1049
-
            else ((lastBlock.timestamp - cc) > fB))
1050
-
            then throw(((("signature outdated: logTime=" + toString(fB)) + ", bcTime=") + toString(lastBlock.timestamp)))
1031
+
            else ((lastBlock.timestamp - bR) > fz))
1032
+
            then throw(((("signature outdated: logTime=" + toString(fz)) + ", bcTime=") + toString(lastBlock.timestamp)))
1051
1033
 
            else {
1052
-
                let fC = fz[1]
1053
-
                let fD = valueOrElse(getString(an(aN)), "")
1054
-
                if ((fD != fC))
1055
-
                    then throw(((("Tx ids don't match! In state: " + fD) + ", in msg: ") + fC))
1034
+
                let fA = fx[1]
1035
+
                let fB = valueOrElse(getString(am(aM)), "")
1036
+
                if ((fB != fA))
1037
+
                    then throw(((("Tx ids don't match! In state: " + fB) + ", in msg: ") + fA))
1056
1038
 
                    else {
1057
-
                        let k = valueOrErrorMessage(getString(aH(aN)), "You don't have a duck staked")
1058
-
                        let fE = aK(k)
1059
-
                        let fF = E(valueOrElse(getInteger(m(k)), 0))
1060
-
                        let fG = valueOrElse(getInteger(fE), fF)
1061
-
                        if ((fG != fx))
1062
-
                            then throw(((("oldHealth=" + toString(fG)) + " from state does not match one from flight log=") + toString(fx)))
1063
-
                            else if ((0 >= fx))
1039
+
                        let k = valueOrErrorMessage(getString(aG(aM)), "You don't have a duck staked")
1040
+
                        let fC = aJ(k)
1041
+
                        let fD = E(valueOrElse(getInteger(m(k)), 0))
1042
+
                        let fE = valueOrElse(getInteger(fC), fD)
1043
+
                        if ((fE != fv))
1044
+
                            then throw(((("oldHealth=" + toString(fE)) + " from state does not match one from flight log=") + toString(fv)))
1045
+
                            else if ((0 >= fv))
1064
1046
 
                                then throw("You can't fly with zero health")
1065
1047
 
                                else {
1066
-
                                    let fH = if ((size(fv) > cF))
1067
-
                                        then fv[cF]
1048
+
                                    let fF = if ((size(ft) > cu))
1049
+
                                        then ft[cu]
1068
1050
 
                                        else ""
1069
-
                                    let fI = if ((size(fv) > cG))
1070
-
                                        then fv[cG]
1051
+
                                    let fG = if ((size(ft) > cv))
1052
+
                                        then ft[cv]
1071
1053
 
                                        else ""
1072
-
                                    let fJ = if (if ((fy > 0))
1073
-
                                        then (fH == "$")
1054
+
                                    let fH = if (if ((fw > 0))
1055
+
                                        then (fF == "$")
1074
1056
 
                                        else false)
1075
-
                                        then bU(invoke(bF, "sendUsdtPrize", [aN], nil))
1057
+
                                        then bJ(invoke(bu, "sendUsdtPrize", [aM], nil))
1076
1058
 
                                        else 0
1077
-
                                    $Tuple5(fy, k, fJ, fA, fI)
1059
+
                                    $Tuple5(fw, k, fH, fy, fG)
1078
1060
 
                                    }
1079
1061
 
                        }
1080
1062
 
                }
1081
1063
 
        }
1082
1064
 
1083
1065
 
1084
-
func fK (fl,fm,ft,fu) = {
1085
-
    let aN = toString(fl)
1086
-
    let dZ = fs(aN, ft, fu)
1087
-
    let fE = aK(dZ._2)
1088
-
    let ed = aI(dZ._2)
1089
-
    let eO = ec(ed)
1090
-
    let fL = split(eO[aj], "_")
1091
-
    let fM = makeString(cT(true, fL, cg), "_")
1092
-
    let dn = da(eO[ak], dZ._5)
1093
-
    if ((0 >= dZ._1))
1094
-
        then $Tuple3([IntegerEntry(fE, 0), StringEntry(ed, makeString([eO[ah], eO[ai], eO[aj], dn], ":"))], "", 0)
1095
-
        else {
1096
-
            let fN = fk(fl, fm)
1097
-
            let fr = fN._2._1
1098
-
            $Tuple3((((fN._1 :+ StringEntry(aJ(dZ._2), makeString([fN._2._2, "L", fr], "_"))) :+ IntegerEntry(fE, dZ._1)) :+ StringEntry(ed, makeString([eO[ah], eO[ai], fM, dn], ":"))), fr, dZ._3)
1099
-
            }
1100
-
    }
1101
-
1102
-
1103
-
func fO (az,fP) = {
1104
-
    let ey = valueOrElse(getInteger(as(az)), 0)
1105
-
    let fQ = valueOrElse(getInteger(at(M, az)), 0)
1106
-
    let fR = (ey / 6)
1107
-
    let fS = (ey / 7)
1108
-
    ((O + fraction(O, ((ey + fR) + (2 * fS)), 5)) + fraction(O, fQ, (fP * 5)))
1109
-
    }
1110
-
1111
-
1112
-
func fT (p,fU,fV) = {
1113
-
    let fW = if ((fU == cA))
1114
-
        then $Tuple2(fV, valueOrElse(getString(aH(p)), ""))
1115
-
        else {
1116
-
            let k = valueOrErrorMessage(getString(aH(p)), "You don't have a duck staked")
1117
-
            let fX = valueOrElse(getString(aJ(k)), R)
1118
-
            let fY = split(value(fX), "_")
1119
-
            if ((fY[aP] != "L"))
1120
-
                then throw((("Duck location type is " + fY[aP]) + ", but should be L"))
1121
-
                else $Tuple2(fY[aQ], k)
1122
-
            }
1123
-
    let az = fW._1
1124
-
    let fZ = fW._2
1125
-
    let ga = value(assetInfo(fromBase58String(az)))
1126
-
    let gb = ar(az)
1127
-
    let gc = valueOrErrorMessage(getInteger(gb), (("Land " + ga.name) + " is not staked"))
1128
-
    let gd = valueOrErrorMessage(getString(ao(az)), (("NFT " + ga.name) + " is orphaned"))
1129
-
    if ((gd != p))
1066
+
func fI (fj,fk,fr,fs) = {
1067
+
    let aM = toString(fj)
1068
+
    let dX = fq(aM, fr, fs)
1069
+
    let fC = aJ(dX._2)
1070
+
    let eb = aH(dX._2)
1071
+
    let eM = ea(eb)
1072
+
    let fJ = split(eM[ak], "_")
1073
+
    let fK = makeString(cP(true, fJ, bV), "_")
1074
+
    let dl = cW(eM[al], dX._5)
1075
+
    if ((0 >= dX._1))
1076
+
        then $Tuple3([IntegerEntry(fC, 0), StringEntry(eb, makeString([eM[ai], eM[aj], eM[ak], dl], ":"))], "", 0)
1077
+
        else {
1078
+
            let fL = fi(fj, fk)
1079
+
            let fp = fL._2._1
1080
+
            $Tuple3((((fL._1 :+ StringEntry(aI(dX._2), makeString([fL._2._2, "L", fp], "_"))) :+ IntegerEntry(fC, dX._1)) :+ StringEntry(eb, makeString([eM[ai], eM[aj], fK, dl], ":"))), fp, dX._3)
1081
+
            }
1082
+
    }
1083
+
1084
+
1085
+
func fM (ay,fN) = {
1086
+
    let ev = valueOrElse(getInteger(ar(ay)), 0)
1087
+
    let fO = valueOrElse(getInteger(as(M, ay)), 0)
1088
+
    let fP = (ev / 6)
1089
+
    let fQ = (ev / 7)
1090
+
    ((O + fraction(O, ((ev + fP) + (2 * fQ)), 5)) + fraction(O, fO, (fN * 5)))
1091
+
    }
1092
+
1093
+
1094
+
func fR (p,fS,fT) = {
1095
+
    let fU = if ((fS == cp))
1096
+
        then $Tuple2(fT, valueOrElse(getString(aG(p)), ""))
1097
+
        else {
1098
+
            let k = valueOrErrorMessage(getString(aG(p)), "You don't have a duck staked")
1099
+
            let fV = valueOrElse(getString(aI(k)), R)
1100
+
            let fW = split(value(fV), "_")
1101
+
            if ((fW[aO] != "L"))
1102
+
                then throw((("Duck location type is " + fW[aO]) + ", but should be L"))
1103
+
                else $Tuple2(fW[aP], k)
1104
+
            }
1105
+
    let ay = fU._1
1106
+
    let fX = fU._2
1107
+
    let fY = value(assetInfo(fromBase58String(ay)))
1108
+
    let fZ = aq(ay)
1109
+
    let ga = valueOrErrorMessage(getInteger(fZ), (("Land " + fY.name) + " is not staked"))
1110
+
    let gb = valueOrErrorMessage(getString(an(ay)), (("NFT " + fY.name) + " is orphaned"))
1111
+
    if ((gb != p))
1130
1112
 
        then throw((K + " is not yours"))
1131
1113
 
        else {
1132
-
            let ge = split(ga.description, "_")
1133
-
            $Tuple4(fZ, az, ge, gc)
1134
-
            }
1135
-
    }
1136
-
1137
-
1138
-
func gf (p,eL,fU,fV) = if ((0 > eL))
1114
+
            let gc = split(fY.description, "_")
1115
+
            $Tuple4(fX, ay, gc, ga)
1116
+
            }
1117
+
    }
1118
+
1119
+
1120
+
func gd (p,eI,fS,fT) = if ((0 > eI))
1139
1121
 
    then throw("Negative amount")
1140
1122
 
    else {
1141
-
        let gg = fT(p, fU, fV)
1142
-
        let bX = gg._3[bL]
1143
-
        let dq = dw(gg._3[bM])
1144
-
        let dA = (lastBlock.timestamp - gg._4)
1145
-
        if ((0 > dA))
1146
-
            then throw(((("Saved timestamp is in future, saved = " + toString(gg._4)) + ", current = ") + toString(lastBlock.timestamp)))
1123
+
        let ge = fR(p, fS, fT)
1124
+
        let bM = ge._3[bA]
1125
+
        let do = du(ge._3[bB])
1126
+
        let dy = (lastBlock.timestamp - ge._4)
1127
+
        if ((0 > dy))
1128
+
            then throw(((("Saved timestamp is in future, saved = " + toString(ge._4)) + ", current = ") + toString(lastBlock.timestamp)))
1147
1129
 
            else {
1148
-
                let fP = bW(bX)
1149
-
                let gh = fO(gg._2, fP)
1150
-
                let gi = fraction(dA, (gh * fP), P)
1151
-
                if ((eL > gi))
1152
-
                    then throw(((("Not enough resources, available = " + toString(gi)) + ", requested = ") + toString(eL)))
1130
+
                let fN = bL(bM)
1131
+
                let gf = fM(ge._2, fN)
1132
+
                let gg = fraction(dy, (gf * fN), P)
1133
+
                if ((eI > gg))
1134
+
                    then throw(((("Not enough resources, available = " + toString(gg)) + ", requested = ") + toString(eI)))
1153
1135
 
                    else {
1154
-
                        let gj = fraction((gi - eL), P, (gh * fP))
1155
-
                        let gk = (lastBlock.timestamp - gj)
1156
-
                        let ex = (fP / bm)
1157
-
                        let dI = dE(dq, (dA - gj), ex, gh)
1158
-
                        let ew = ay(gg._2)
1159
-
                        let ey = valueOrElse(getInteger(as(gg._2)), 0)
1160
-
                        let ei = ev(ew, ex, ey)
1161
-
                        let eE = split(ei[ac], "_")
1162
-
                        let dJ = parseIntValue(eE[af])
1163
-
                        if (if ((fU == cA))
1164
-
                            then (eL > dJ)
1136
+
                        let gh = fraction((gg - eI), P, (gf * fN))
1137
+
                        let gi = (lastBlock.timestamp - gh)
1138
+
                        let eu = (fN / bb)
1139
+
                        let dG = dC(do, (dy - gh), eu, gf)
1140
+
                        let et = ax(ge._2)
1141
+
                        let ev = valueOrElse(getInteger(ar(ge._2)), 0)
1142
+
                        let eg = es(et, eu, ev)
1143
+
                        let eB = split(eg[ad], "_")
1144
+
                        let dH = parseIntValue(eB[ag])
1145
+
                        if (if ((fS == cp))
1146
+
                            then (eI > dH)
1165
1147
 
                            else false)
1166
-
                            then throw((("Only " + toString(dJ)) + " space left in warehouse"))
1148
+
                            then throw((("Only " + toString(dH)) + " space left in warehouse"))
1167
1149
 
                            else {
1168
-
                                let ed = aI(gg._1)
1169
-
                                let eO = ec(ed)
1170
-
                                let dH = split(eO[ai], "_")
1171
-
                                let dG = split(ei[Z], "_")
1172
-
                                let gl = if ((fU == cA))
1173
-
                                    then $Tuple4(dy(dG, dq, (dA - gj), ex, gh), eO[ai], (parseIntValue(eE[ae]) + dI._2), (parseIntValue(eE[af]) - dI._2))
1174
-
                                    else if ((fU == cB))
1175
-
                                        then $Tuple4(ei[Z], dy(dH, dq, (dA - gj), ex, gh), parseIntValue(eE[ae]), parseIntValue(eE[af]))
1150
+
                                let eb = aH(ge._1)
1151
+
                                let eM = ea(eb)
1152
+
                                let dF = split(eM[aj], "_")
1153
+
                                let dE = split(eg[aa], "_")
1154
+
                                let gj = if ((fS == cp))
1155
+
                                    then $Tuple4(dw(dE, do, (dy - gh), eu, gf), eM[aj], (parseIntValue(eB[af]) + dG._2), (parseIntValue(eB[ag]) - dG._2))
1156
+
                                    else if ((fS == cq))
1157
+
                                        then $Tuple4(eg[aa], dw(dF, do, (dy - gh), eu, gf), parseIntValue(eB[af]), parseIntValue(eB[ag]))
1176
1158
 
                                        else {
1177
-
                                            let gm = dF(dG, dH, dI, dJ)
1178
-
                                            let gn = min([parseIntValue(eE[af]), dI._2])
1179
-
                                            $Tuple4(gm._1, gm._2, (parseIntValue(eE[ae]) + gn), (parseIntValue(eE[af]) - gn))
1159
+
                                            let gk = dD(dE, dF, dG, dH)
1160
+
                                            let gl = min([parseIntValue(eB[ag]), dG._2])
1161
+
                                            $Tuple4(gk._1, gk._2, (parseIntValue(eB[af]) + gl), (parseIntValue(eB[ag]) - gl))
1180
1162
 
                                            }
1181
-
                                let go = gl._1
1182
-
                                let gp = gl._2
1183
-
                                let gq = gl._3
1184
-
                                let gr = gl._4
1185
-
                                $Tuple5([IntegerEntry(ar(gg._2), gk), IntegerEntry(av(K, gg._2, p), gk)], ed, [eO[ah], gp, eO[aj], eO[ak]], ew, [ei[Y], go, ei[aa], ei[ab], makeString([eE[ad], toString(gq), toString(gr), eE[ag]], "_")])
1163
+
                                let gm = gj._1
1164
+
                                let gn = gj._2
1165
+
                                let go = gj._3
1166
+
                                let gp = gj._4
1167
+
                                $Tuple5([IntegerEntry(aq(ge._2), gi), IntegerEntry(au(K, ge._2, p), gi)], eb, [eM[ai], gn, eM[ak], eM[al]], et, [eg[Z], gm, eg[ab], eg[ac], makeString([eB[ae], toString(go), toString(gp), eB[ah]], "_")])
1186
1168
 
                                }
1187
1169
 
                        }
1188
1170
 
                }
1189
1171
 
        }
1190
1172
 
1191
1173
 
1192
-
func gs (p,az,fP,fU) = {
1193
-
    let gb = ar(az)
1194
-
    let gc = value(getInteger(gb))
1195
-
    let gi = (fraction((lastBlock.timestamp - gc), fO(az, fP), P) * fP)
1196
-
    gf(p, gi, fU, az)
1197
-
    }
1198
-
1199
-
1200
-
func gt (cU,fl,gu,az) = {
1201
-
    let p = toString(fl)
1202
-
    let gg = fT(p, cC, az)
1203
-
    let fP = bW(gg._3[bL])
1204
-
    let gv = as(gg._2)
1205
-
    let gw = valueOrElse(getInteger(gv), 0)
1206
-
    if ((gw >= 3))
1174
+
func gq (p,ay,fN,fS) = {
1175
+
    let fZ = aq(ay)
1176
+
    let ga = value(getInteger(fZ))
1177
+
    let gg = (fraction((lastBlock.timestamp - ga), fM(ay, fN), P) * fN)
1178
+
    gd(p, gg, fS, ay)
1179
+
    }
1180
+
1181
+
1182
+
func gr (cQ,fj,gs,ay) = {
1183
+
    let p = toString(fj)
1184
+
    let ge = fR(p, cr, ay)
1185
+
    let fN = bL(ge._3[bA])
1186
+
    let gt = ar(ge._2)
1187
+
    let gu = valueOrElse(getInteger(gt), 0)
1188
+
    if ((gu >= 3))
1207
1189
 
        then throw("Currently max infrastructure level = 3")
1208
1190
 
        else {
1209
-
            let J = (gw + 1)
1210
-
            let gx = fraction(cf, (fP * J), bm)
1211
-
            if (if (!(cU))
1212
-
                then (gu != gx)
1191
+
            let J = (gu + 1)
1192
+
            let gv = fraction(bU, (fN * J), bb)
1193
+
            if (if (!(cQ))
1194
+
                then (gs != gv)
1213
1195
 
                else false)
1214
-
                then throw(("Payment attached should be " + toString(gx)))
1196
+
                then throw(("Payment attached should be " + toString(gv)))
1215
1197
 
                else {
1216
-
                    let ed = aI(gg._1)
1217
-
                    let eO = ec(ed)
1218
-
                    let fL = split(eO[aj], "_")
1219
-
                    let gy = fraction(bi, (fP * J), bm)
1220
-
                    let fM = makeString(cT(cU, fL, gy), "_")
1221
-
                    let gz = gs(p, gg._2, fP, cC)
1222
-
                    let gA = gz._5
1223
-
                    let gB = ef(gA[Y])
1224
-
                    let gC = makeString([split(gA[Y], "_")[0], toString(J)], "_")
1225
-
                    let gD = ef(gC)
1226
-
                    let eE = split(gA[ac], "_")
1227
-
                    let gE = makeString([eE[ad], eE[ae], toString(((parseIntValue(eE[af]) + gD) - gB)), toString(gD)], "_")
1228
-
                    $Tuple3(([IntegerEntry(gv, J), IntegerEntry(cu(gg._2, p), J), StringEntry(ed, makeString([eO[ah], gz._3[ai], fM, eO[ak]], ":")), StringEntry(gz._4, makeString([gC, gA[Z], gA[aa], gA[ab], gE], ":"))] ++ gz._1), J, gy)
1198
+
                    let eb = aH(ge._1)
1199
+
                    let eM = ea(eb)
1200
+
                    let fJ = split(eM[ak], "_")
1201
+
                    let gw = fraction(aX, (fN * J), bb)
1202
+
                    let fK = makeString(cP(cQ, fJ, gw), "_")
1203
+
                    let gx = gq(p, ge._2, fN, cr)
1204
+
                    let gy = gx._5
1205
+
                    let gz = ed(gy[Z])
1206
+
                    let gA = makeString([split(gy[Z], "_")[0], toString(J)], "_")
1207
+
                    let gB = ed(gA)
1208
+
                    let eB = split(gy[ad], "_")
1209
+
                    let gC = makeString([eB[ae], eB[af], toString(((parseIntValue(eB[ag]) + gB) - gz)), toString(gB)], "_")
1210
+
                    $Tuple3(([IntegerEntry(gt, J), IntegerEntry(cj(ge._2, p), J), StringEntry(eb, makeString([eM[ai], gx._3[aj], fK, eM[al]], ":")), StringEntry(gx._4, makeString([gA, gy[aa], gy[ab], gy[ac], gC], ":"))] ++ gx._1), J, gw)
1229
1211
 
                    }
1230
1212
 
            }
1231
1213
 
    }
1232
1214
 
1233
1215
 
1234
-
func gF (k,gG) = if (!(bd))
1216
+
func gD (k,gE) = if (!(aS))
1235
1217
 
    then $Tuple2(nil, 0)
1236
1218
 
    else {
1237
-
        let gH = m(k)
1238
-
        let gI = l(k)
1239
-
        let D = valueOrElse(getInteger(bG, gI), 0)
1240
-
        let I = (D + gG)
1241
-
        let gJ = G(valueOrElse(getInteger(bG, gH), 0), I)
1242
-
        let gK = n(k)
1243
-
        $Tuple2([IntegerEntry(gH, gJ[0]), IntegerEntry(gI, I), IntegerEntry(gK, (valueOrElse(getInteger(gK), 0) + gJ[1]))], I)
1219
+
        let gF = m(k)
1220
+
        let gG = l(k)
1221
+
        let D = valueOrElse(getInteger(bv, gG), 0)
1222
+
        let I = (D + gE)
1223
+
        let gH = G(valueOrElse(getInteger(bv, gF), 0), I)
1224
+
        let gI = n(k)
1225
+
        $Tuple2([IntegerEntry(gF, gH[0]), IntegerEntry(gG, I), IntegerEntry(gI, (valueOrElse(getInteger(gI), 0) + gH[1]))], I)
1244
1226
 
        }
1245
1227
 
1246
1228
 
1247
-
func gL (p,gG) = if (!(bd))
1229
+
func gJ (p,gE) = if (!(aS))
1248
1230
 
    then $Tuple2(nil, 0)
1249
1231
 
    else {
1250
-
        let gH = q(p)
1251
-
        let gI = o(p)
1252
-
        let D = valueOrElse(getInteger(bG, gI), 0)
1253
-
        let I = (D + gG)
1254
-
        let gJ = G(valueOrElse(getInteger(bG, gH), 0), I)
1255
-
        let gK = r(p)
1256
-
        $Tuple2([IntegerEntry(gH, gJ[0]), IntegerEntry(gI, I), IntegerEntry(gK, (valueOrElse(getInteger(gK), 0) + gJ[1]))], I)
1232
+
        let gF = q(p)
1233
+
        let gG = o(p)
1234
+
        let D = valueOrElse(getInteger(bv, gG), 0)
1235
+
        let I = (D + gE)
1236
+
        let gH = G(valueOrElse(getInteger(bv, gF), 0), I)
1237
+
        let gI = r(p)
1238
+
        $Tuple2([IntegerEntry(gF, gH[0]), IntegerEntry(gG, I), IntegerEntry(gI, (valueOrElse(getInteger(gI), 0) + gH[1]))], I)
1257
1239
 
        }
1258
1240
 
1259
1241
 
1260
-
func gM (p) = {
1261
-
    let k = valueOrErrorMessage(getString(aH(p)), "You don't have a duck staked")
1262
-
    let gN = aC(p)
1263
-
    let gO = getString(gN)
1264
-
    if (!(isDefined(gO)))
1242
+
func gK (p) = {
1243
+
    let k = valueOrErrorMessage(getString(aG(p)), "You don't have a duck staked")
1244
+
    let gL = aB(p)
1245
+
    let gM = getString(gL)
1246
+
    if (!(isDefined(gM)))
1265
1247
 
        then throw("You are not eligible for ONBOARD artifact")
1266
1248
 
        else {
1267
-
            let gP = aE(p)
1268
-
            let gQ = getString(gP)
1269
-
            if (isDefined(gQ))
1270
-
                then throw(("You already used your ONBOARD artifact on duck " + value(gQ)))
1249
+
            let gN = aD(p)
1250
+
            let gO = getString(gN)
1251
+
            if (isDefined(gO))
1252
+
                then throw(("You already used your ONBOARD artifact on duck " + value(gO)))
1271
1253
 
                else {
1272
-
                    let gR = aD(k)
1273
-
                    let gS = getString(gR)
1274
-
                    if (isDefined(gS))
1275
-
                        then throw(((("The duck " + k) + " already got points from ONBOARD artifact from user ") + value(gS)))
1276
-
                        else ([StringEntry(gP, k), StringEntry(gR, p)] ++ gF(k, A)._1)
1254
+
                    let gP = aC(k)
1255
+
                    let gQ = getString(gP)
1256
+
                    if (isDefined(gQ))
1257
+
                        then throw(((("The duck " + k) + " already got points from ONBOARD artifact from user ") + value(gQ)))
1258
+
                        else ([StringEntry(gN, k), StringEntry(gP, p)] ++ gD(k, A)._1)
1277
1259
 
                    }
1278
1260
 
            }
1279
1261
 
    }
1280
1262
 
1281
1263
 
1282
-
func gT (p,fV) = {
1283
-
    let gg = fT(p, cC, fV)
1284
-
    let az = gg._2
1285
-
    let fP = bW(gg._3[bL])
1286
-
    let gU = at(M, az)
1287
-
    if ((valueOrElse(getInteger(gU), 0) > 0))
1264
+
func gR (p,fT) = {
1265
+
    let ge = fR(p, cr, fT)
1266
+
    let ay = ge._2
1267
+
    let fN = bL(ge._3[bA])
1268
+
    let gS = as(M, ay)
1269
+
    if ((valueOrElse(getInteger(gS), 0) > 0))
1288
1270
 
        then throw("Presale artifact is already activated")
1289
-
        else if ((parseIntValue(gg._3[bK]) > co))
1290
-
            then throw((((K + " ") + az) + " is not eligible for presale artifact"))
1271
+
        else if ((parseIntValue(ge._3[bz]) > cd))
1272
+
            then throw((((K + " ") + ay) + " is not eligible for presale artifact"))
1291
1273
 
            else {
1292
-
                let gz = gs(p, az, fP, cC)
1293
-
                ((((gz._1 :+ IntegerEntry(gU, fP)) :+ IntegerEntry(cv(M, az, p), fP)) :+ StringEntry(gz._2, makeString(gz._3, ":"))) :+ StringEntry(gz._4, makeString(gz._5, ":")))
1274
+
                let gx = gq(p, ay, fN, cr)
1275
+
                ((((gx._1 :+ IntegerEntry(gS, fN)) :+ IntegerEntry(ck(M, ay, p), fN)) :+ StringEntry(gx._2, makeString(gx._3, ":"))) :+ StringEntry(gx._4, makeString(gx._5, ":")))
1294
1276
 
                }
1295
1277
 
    }
1296
1278
 
1297
1279
 
1298
-
func gV (gW,J,gX,p,gY,fm,gZ) = {
1299
-
    let k = valueOrErrorMessage(getString(aH(p)), "You don't have a duck staked")
1300
-
    func ha (cO,az) =     {
1301
-
        let ga = value(assetInfo(fromBase58String(az)))
1302
-
        let gb = ar(az)
1303
-
        let gc = valueOrErrorMessage(getInteger(gb), (("NFT " + ga.name) + " is not staked"))
1304
-
        let gd = valueOrErrorMessage(getString(ao(az)), (("NFT " + ga.name) + " is orphaned"))
1305
-
        if ((gd != p))
1280
+
func gT (gU,J,gV,p,gW,fk,gX) = {
1281
+
    let k = valueOrErrorMessage(getString(aG(p)), "You don't have a duck staked")
1282
+
    func gY (cD,ay) =     {
1283
+
        let fY = value(assetInfo(fromBase58String(ay)))
1284
+
        let fZ = aq(ay)
1285
+
        let ga = valueOrErrorMessage(getInteger(fZ), (("NFT " + fY.name) + " is not staked"))
1286
+
        let gb = valueOrErrorMessage(getString(an(ay)), (("NFT " + fY.name) + " is orphaned"))
1287
+
        if ((gb != p))
1306
1288
 
            then throw((K + " is not yours"))
1307
1289
 
            else {
1308
-
                let ge = split(ga.description, "_")
1309
-
                let fp = ge[bN]
1310
-
                if (if ((cO._3 != ""))
1311
-
                    then (cO._3 != fp)
1290
+
                let gc = split(fY.description, "_")
1291
+
                let fn = gc[bC]
1292
+
                if (if ((cD._3 != ""))
1293
+
                    then (cD._3 != fn)
1312
1294
 
                    else false)
1313
1295
 
                    then throw("Lands should be on the same continent to merge")
1314
1296
 
                    else {
1315
-
                        let bX = ge[bL]
1316
-
                        let hb = cO._1
1317
-
                        let du = valueOrErrorMessage(indexOf(hb, bX), "You haven't passed all the lands needed")
1318
-
                        let hc = (take(hb, du) + drop(hb, (du + 1)))
1319
-
                        let fP = bW(bX)
1320
-
                        let hd = (cO._2 + valueOrElse(getInteger(at(M, az)), 0))
1321
-
                        let ey = valueOrElse(getInteger(as(az)), 0)
1322
-
                        let he = {
1323
-
                            let bg = bX
1324
-
                            if (("S" == bg))
1297
+
                        let bM = gc[bA]
1298
+
                        let gZ = cD._1
1299
+
                        let ds = valueOrErrorMessage(indexOf(gZ, bM), "You haven't passed all the lands needed")
1300
+
                        let ha = (take(gZ, ds) + drop(gZ, (ds + 1)))
1301
+
                        let fN = bL(bM)
1302
+
                        let hb = (cD._2 + valueOrElse(getInteger(as(M, ay)), 0))
1303
+
                        let ev = valueOrElse(getInteger(ar(ay)), 0)
1304
+
                        let hc = {
1305
+
                            let aV = bM
1306
+
                            if (("S" == aV))
1325
1307
 
                                then 3
1326
-
                                else if (("M" == bg))
1308
+
                                else if (("M" == aV))
1327
1309
 
                                    then 4
1328
-
                                    else if (("L" == bg))
1310
+
                                    else if (("L" == aV))
1329
1311
 
                                        then 5
1330
-
                                        else if (("XL" == bg))
1312
+
                                        else if (("XL" == aV))
1331
1313
 
                                            then 6
1332
1314
 
                                            else throw("Only S, M, L, XL can merge")
1333
1315
 
                            }
1334
-
                        if ((ey != he))
1316
+
                        if ((ev != hc))
1335
1317
 
                            then throw("All lands should be maxed to merge")
1336
1318
 
                            else {
1337
-
                                let cr = ge[bK]
1338
-
                                let dq = dw(ge[bM])
1339
-
                                let dA = (lastBlock.timestamp - gc)
1340
-
                                if ((0 > dA))
1341
-
                                    then throw(((("Saved timestamp is in future, saved = " + toString(gc)) + ", current = ") + toString(lastBlock.timestamp)))
1319
+
                                let cg = gc[bz]
1320
+
                                let do = du(gc[bB])
1321
+
                                let dy = (lastBlock.timestamp - ga)
1322
+
                                if ((0 > dy))
1323
+
                                    then throw(((("Saved timestamp is in future, saved = " + toString(ga)) + ", current = ") + toString(lastBlock.timestamp)))
1342
1324
 
                                    else {
1343
-
                                        let gh = fO(az, fP)
1344
-
                                        let ex = (fP / bm)
1345
-
                                        let gp = dy(split(cO._4, "_"), dq, dA, ex, gh)
1346
-
                                        let cR = do(split(cO._6, "_"), dq, ex, -1)
1347
-
                                        let hf = cO._7
1348
-
                                        let bE = indexOf(hf, az)
1349
-
                                        if (!(isDefined(bE)))
1350
-
                                            then throw(("Your staked lands don't contain " + az))
1325
+
                                        let gf = fM(ay, fN)
1326
+
                                        let eu = (fN / bb)
1327
+
                                        let gn = dw(split(cD._4, "_"), do, dy, eu, gf)
1328
+
                                        let cN = dm(split(cD._6, "_"), do, eu, -1)
1329
+
                                        let hd = cD._7
1330
+
                                        let bt = indexOf(hd, ay)
1331
+
                                        if (!(isDefined(bt)))
1332
+
                                            then throw(("Your staked lands don't contain " + ay))
1351
1333
 
                                            else {
1352
-
                                                let hg = aq(az)
1353
-
                                                let hh = valueOrElse(getString(hg), "")
1354
-
                                                $Tuple8(hc, hd, fp, gp, (((((((((((((cO._5 :+ DeleteEntry(ar(az))) :+ DeleteEntry(av(K, az, p))) :+ DeleteEntry(cq(cr))) :+ DeleteEntry(ao(az))) :+ DeleteEntry(as(az))) :+ DeleteEntry(cu(az, p))) :+ DeleteEntry(at(M, az))) :+ DeleteEntry(cv(M, az, p))) :+ DeleteEntry(cw(cr))) :+ DeleteEntry(ay(az))) :+ DeleteEntry(hg)) :+ DeleteEntry(cs(hh))) :+ Burn(fromBase58String(az), 1)), cR, removeByIndex(hf, value(bE)), (cO._8 + fP))
1334
+
                                                let he = ap(ay)
1335
+
                                                let hf = valueOrElse(getString(he), "")
1336
+
                                                $Tuple8(ha, hb, fn, gn, (((((((((((((cD._5 :+ DeleteEntry(aq(ay))) :+ DeleteEntry(au(K, ay, p))) :+ DeleteEntry(cf(cg))) :+ DeleteEntry(an(ay))) :+ DeleteEntry(ar(ay))) :+ DeleteEntry(cj(ay, p))) :+ DeleteEntry(as(M, ay))) :+ DeleteEntry(ck(M, ay, p))) :+ DeleteEntry(cl(cg))) :+ DeleteEntry(ax(ay))) :+ DeleteEntry(he)) :+ DeleteEntry(ch(hf))) :+ Burn(fromBase58String(ay), 1)), cN, removeByIndex(hd, value(bt)), (cD._8 + fN))
1355
1337
 
                                                }
1356
1338
 
                                        }
1357
1339
 
                                }
1358
1340
 
                        }
1359
1341
 
                }
1360
1342
 
        }
1361
1343
 
1362
-
    let ed = aI(k)
1363
-
    let eO = ec(ed)
1364
-
    let hi = valueOrElse(getString(bO()), "0_0_0_0_0_0")
1365
-
    let hj = bP(p)
1366
-
    let hk = getString(hj)
1367
-
    let hl = if (isDefined(hk))
1368
-
        then split_51C(value(hk), "_")
1344
+
    let eb = aH(k)
1345
+
    let eM = ea(eb)
1346
+
    let hg = valueOrElse(getString(bD()), "0_0_0_0_0_0")
1347
+
    let hh = bE(p)
1348
+
    let hi = getString(hh)
1349
+
    let hj = if (isDefined(hi))
1350
+
        then split_51C(value(hi), "_")
1369
1351
 
        else nil
1370
-
    let cS = {
1371
-
        let aW = gY
1372
-
        let aX = size(aW)
1373
-
        let aY = $Tuple8(gX, 0, "", eO[ai], nil, hi, hl, 0)
1374
-
        func aZ (ba,bb) =         if ((bb >= aX))
1375
-
            then ba
1376
-
            else ha(ba, aW[bb])
1377
-
1378
-
        func bc (ba,bb) =         if ((bb >= aX))
1379
-
            then ba
1352
+
    let cO = {
1353
+
        let cF = gW
1354
+
        let cG = size(cF)
1355
+
        let cH = $Tuple8(gV, 0, "", eM[aj], nil, hg, hj, 0)
1356
+
        func cI (cJ,cK) =         if ((cK >= cG))
1357
+
            then cJ
1358
+
            else gY(cJ, cF[cK])
1359
+
1360
+
        func cL (cJ,cK) =         if ((cK >= cG))
1361
+
            then cJ
1380
1362
 
            else throw("List size exceeds 5")
1381
1363
 
1382
-
        bc(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5)
1364
+
        cL(cI(cI(cI(cI(cI(cH, 0), 1), 2), 3), 4), 5)
1383
1365
 
        }
1384
-
    let fp = cS._3
1385
-
    let dY = valueOrErrorMessage(indexOf(V, fp), ("Unknown continent: " + fp))
1386
-
    let dx = dW(dP(toBigInt(fm)), dY)
1387
-
    let fo = valueOrElse(getInteger(cp()), (co + 1))
1388
-
    let hm = toString(fo)
1389
-
    let fq = Issue(cH(hm, gW), makeString([hm, gW, dx, fp], "_"), 1, 0, false)
1390
-
    let ap = calculateAssetId(fq)
1391
-
    let hn = toBase58String(ap)
1392
-
    let fM = makeString(cT((gZ > 0), split(eO[aj], "_"), gZ), "_")
1393
-
    let ho = bQ(p)
1394
-
    let hp = valueOrElse(getInteger(ho), 0)
1395
-
    $Tuple2((((((((((((((((cS._5 :+ (if ((size(cS._7) > 0))
1396
-
        then StringEntry(hj, makeString_11C(cS._7, "_"))
1397
-
        else DeleteEntry(hj))) :+ IntegerEntry(ho, if ((cS._8 > hp))
1366
+
    let fn = cO._3
1367
+
    let dW = valueOrErrorMessage(indexOf(V, fn), ("Unknown continent: " + fn))
1368
+
    let dv = dU(dN(toBigInt(fk)), dW)
1369
+
    let fm = valueOrElse(getInteger(ce()), (cd + 1))
1370
+
    let hk = toString(fm)
1371
+
    let fo = Issue(cw(hk, gU), makeString([hk, gU, dv, fn], "_"), 1, 0, false)
1372
+
    let ao = calculateAssetId(fo)
1373
+
    let hl = toBase58String(ao)
1374
+
    let fK = makeString(cP((gX > 0), split(eM[ak], "_"), gX), "_")
1375
+
    let hm = bF(p)
1376
+
    let hn = valueOrElse(getInteger(hm), 0)
1377
+
    $Tuple2((((((((((((((((cO._5 :+ (if ((size(cO._7) > 0))
1378
+
        then StringEntry(hh, makeString_11C(cO._7, "_"))
1379
+
        else DeleteEntry(hh))) :+ IntegerEntry(hm, if ((cO._8 > hn))
1398
1380
 
        then 0
1399
-
        else (hp - cS._8))) :+ IntegerEntry(cp(), (fo + 1))) :+ fq) :+ StringEntry(cq(hm), hn)) :+ StringEntry(ao(hn), p)) :+ StringEntry(cw(hm), p)) :+ IntegerEntry(at(M, hn), cS._2)) :+ IntegerEntry(cv(M, hn, p), cS._2)) :+ IntegerEntry(as(hn), J)) :+ IntegerEntry(cu(hn, p), J)) :+ StringEntry(ed, makeString([eO[ah], cS._4, fM, eO[ak]], ":"))) :+ StringEntry(bO(), cS._6)) :+ StringEntry(aJ(k), makeString([fp, "L", hn], "_"))) :+ ScriptTransfer(addressFromStringValue(p), 1, ap)), hn)
1400
-
    }
1401
-
1402
-
1403
-
func hq (p,gY,fm) = gV("M", 3, "SSSS", p, gY, fm, 0)
1404
-
1405
-
1406
-
func hr (p,gY,fm,cU,gu) = {
1407
-
    let gx = (cf * 4)
1408
-
    if (if (!(cU))
1409
-
        then (gu != gx)
1381
+
        else (hn - cO._8))) :+ IntegerEntry(ce(), (fm + 1))) :+ fo) :+ StringEntry(cf(hk), hl)) :+ StringEntry(an(hl), p)) :+ StringEntry(cl(hk), p)) :+ IntegerEntry(as(M, hl), cO._2)) :+ IntegerEntry(ck(M, hl, p), cO._2)) :+ IntegerEntry(ar(hl), J)) :+ IntegerEntry(cj(hl, p), J)) :+ StringEntry(eb, makeString([eM[ai], cO._4, fK, eM[al]], ":"))) :+ StringEntry(bD(), cO._6)) :+ StringEntry(aI(k), makeString([fn, "L", hl], "_"))) :+ ScriptTransfer(addressFromStringValue(p), 1, ao)), hl)
1382
+
    }
1383
+
1384
+
1385
+
func ho (p,gW,fk) = gT("M", 3, "SSSS", p, gW, fk, 0)
1386
+
1387
+
1388
+
func hp (p,gW,fk,cQ,gs) = {
1389
+
    let gv = (bU * 4)
1390
+
    if (if (!(cQ))
1391
+
        then (gs != gv)
1410
1392
 
        else false)
1411
-
        then throw(("Payment attached should be " + toString(gx)))
1412
-
        else gV("L", 4, "SMM", p, gY, fm, (bi * 4))
1413
-
    }
1414
-
1415
-
1416
-
func hs (p,gY,fm,cU,gu) = {
1417
-
    let gx = (cf * 47)
1418
-
    if (if (!(cU))
1419
-
        then (gu != gx)
1393
+
        then throw(("Payment attached should be " + toString(gv)))
1394
+
        else gT("L", 4, "SMM", p, gW, fk, (aX * 4))
1395
+
    }
1396
+
1397
+
1398
+
func hq (p,gW,fk,cQ,gs) = {
1399
+
    let gv = (bU * 47)
1400
+
    if (if (!(cQ))
1401
+
        then (gs != gv)
1420
1402
 
        else false)
1421
-
        then throw(("Payment attached should be " + toString(gx)))
1422
-
        else gV("XL", 5, "SSSML", p, gY, fm, (bi * 47))
1423
-
    }
1424
-
1425
-
1426
-
func ht (p,gY,fm,cU,gu) = {
1427
-
    let gx = (cf * 54)
1428
-
    if (if (!(cU))
1429
-
        then (gu != gx)
1403
+
        then throw(("Payment attached should be " + toString(gv)))
1404
+
        else gT("XL", 5, "SSSML", p, gW, fk, (aX * 47))
1405
+
    }
1406
+
1407
+
1408
+
func hr (p,gW,fk,cQ,gs) = {
1409
+
    let gv = (bU * 54)
1410
+
    if (if (!(cQ))
1411
+
        then (gs != gv)
1430
1412
 
        else false)
1431
-
        then throw(("Payment attached should be " + toString(gx)))
1432
-
        else gV("XXL", 6, "LXL", p, gY, fm, (bi * 54))
1433
-
    }
1434
-
1435
-
1436
-
func hu (cU,p,gu,gY,fm) = {
1437
-
    let hv = {
1438
-
        let bg = size(gY)
1439
-
        if ((4 == bg))
1440
-
            then hq(p, gY, fm)
1441
-
            else if ((3 == bg))
1442
-
                then hr(p, gY, fm, cU, gu)
1443
-
                else if ((5 == bg))
1444
-
                    then hs(p, gY, fm, cU, gu)
1445
-
                    else if ((2 == bg))
1446
-
                        then ht(p, gY, fm, cU, gu)
1413
+
        then throw(("Payment attached should be " + toString(gv)))
1414
+
        else gT("XXL", 6, "LXL", p, gW, fk, (aX * 54))
1415
+
    }
1416
+
1417
+
1418
+
func hs (cQ,p,gs,gW,fk) = {
1419
+
    let ht = {
1420
+
        let aV = size(gW)
1421
+
        if ((4 == aV))
1422
+
            then ho(p, gW, fk)
1423
+
            else if ((3 == aV))
1424
+
                then hp(p, gW, fk, cQ, gs)
1425
+
                else if ((5 == aV))
1426
+
                    then hq(p, gW, fk, cQ, gs)
1427
+
                    else if ((2 == aV))
1428
+
                        then hr(p, gW, fk, cQ, gs)
1447
1429
 
                        else throw("Unknown merge")
1448
1430
 
        }
1449
-
    hv
1450
-
    }
1451
-
1452
-
1453
-
func hw (du) = if (if ((du.originCaller != bF))
1454
-
    then valueOrElse(getBoolean(aL()), false)
1431
+
    ht
1432
+
    }
1433
+
1434
+
1435
+
func hu (ds) = if (if ((ds.originCaller != bu))
1436
+
    then valueOrElse(getBoolean(aK()), false)
1455
1437
 
    else false)
1456
1438
 
    then throw("Contracts are under maintenance")
1457
-
    else StringEntry(an(toString(du.originCaller)), toBase58String(du.transactionId))
1458
-
1459
-
1460
-
@Callable(du)
1461
-
func constructorV1 (hx) = if ((du.caller != this))
1439
+
    else StringEntry(am(toString(ds.originCaller)), toBase58String(ds.transactionId))
1440
+
1441
+
1442
+
@Callable(ds)
1443
+
func constructorV1 (hv) = if ((ds.caller != this))
1462
1444
 
    then throw("Permission denied")
1463
-
    else [StringEntry(bz(), hx)]
1464
-
1465
-
1466
-
1467
-
@Callable(du)
1468
-
func setBlocked (hy) = if ((du.caller != this))
1445
+
    else [StringEntry(bo(), hv)]
1446
+
1447
+
1448
+
1449
+
@Callable(ds)
1450
+
func setBlocked (hw) = if ((ds.caller != this))
1469
1451
 
    then throw("permission denied")
1470
-
    else [BooleanEntry(aL(), hy)]
1471
-
1472
-
1473
-
1474
-
@Callable(du)
1452
+
    else [BooleanEntry(aK(), hw)]
1453
+
1454
+
1455
+
1456
+
@Callable(ds)
1475
1457
 
func stakeLand () = {
1476
-
    let hz = hw(du)
1477
-
    if ((size(du.payments) != 1))
1458
+
    let hx = hu(ds)
1459
+
    if ((size(ds.payments) != 1))
1478
1460
 
        then throw("Exactly one payment required")
1479
1461
 
        else {
1480
-
            let hA = value(du.payments[0])
1481
-
            let ap = value(hA.assetId)
1482
-
            let bs = toString(du.caller)
1483
-
            if ((hA.amount != 1))
1462
+
            let hy = value(ds.payments[0])
1463
+
            let ao = value(hy.assetId)
1464
+
            let bh = toString(ds.caller)
1465
+
            if ((hy.amount != 1))
1484
1466
 
                then throw((("NFT " + K) + " token should be attached as payment"))
1485
1467
 
                else {
1486
-
                    let ga = value(assetInfo(ap))
1487
-
                    if ((ga.issuer != this))
1468
+
                    let fY = value(assetInfo(ao))
1469
+
                    if ((fY.issuer != this))
1488
1470
 
                        then throw("Unknown issuer of token")
1489
-
                        else if (!(contains(ga.name, K)))
1471
+
                        else if (!(contains(fY.name, K)))
1490
1472
 
                            then throw((("Only NFT " + K) + " tokens are accepted"))
1491
1473
 
                            else {
1492
-
                                let hB = drop(ga.name, 4)
1493
-
                                let cr = if (contains(hB, "XXL"))
1494
-
                                    then dropRight(hB, 3)
1495
-
                                    else if (contains(hB, "XL"))
1496
-
                                        then dropRight(hB, 2)
1497
-
                                        else dropRight(hB, 1)
1498
-
                                if (!(isDefined(parseInt(cr))))
1499
-
                                    then throw(("Cannot parse land number from " + ga.name))
1474
+
                                let hz = drop(fY.name, 4)
1475
+
                                let cg = if (contains(hz, "XXL"))
1476
+
                                    then dropRight(hz, 3)
1477
+
                                    else if (contains(hz, "XL"))
1478
+
                                        then dropRight(hz, 2)
1479
+
                                        else dropRight(hz, 1)
1480
+
                                if (!(isDefined(parseInt(cg))))
1481
+
                                    then throw(("Cannot parse land number from " + fY.name))
1500
1482
 
                                    else {
1501
-
                                        let az = toBase58String(ap)
1502
-
                                        let gb = ar(az)
1503
-
                                        if (isDefined(getInteger(gb)))
1504
-
                                            then throw((("NFT " + ga.name) + " is already staked"))
1483
+
                                        let ay = toBase58String(ao)
1484
+
                                        let fZ = aq(ay)
1485
+
                                        if (isDefined(getInteger(fZ)))
1486
+
                                            then throw((("NFT " + fY.name) + " is already staked"))
1505
1487
 
                                            else {
1506
-
                                                let ge = split(ga.description, "_")
1507
-
                                                let dq = dw(ge[bM])
1508
-
                                                let fP = bW(ge[bL])
1509
-
                                                let cR = dv(dq, (fP / bm), 1)
1510
-
                                                let fQ = valueOrElse(getInteger(at(M, az)), 0)
1511
-
                                                let hj = bP(bs)
1512
-
                                                let hk = getString(hj)
1513
-
                                                let hf = if (isDefined(hk))
1514
-
                                                    then split_51C(value(hk), "_")
1488
+
                                                let gc = split(fY.description, "_")
1489
+
                                                let do = du(gc[bB])
1490
+
                                                let fN = bL(gc[bA])
1491
+
                                                let cN = dt(do, (fN / bb), 1)
1492
+
                                                let fO = valueOrElse(getInteger(as(M, ay)), 0)
1493
+
                                                let hh = bE(bh)
1494
+
                                                let hi = getString(hh)
1495
+
                                                let hd = if (isDefined(hi))
1496
+
                                                    then split_51C(value(hi), "_")
1515
1497
 
                                                    else nil
1516
-
                                                if (containsElement(hf, az))
1517
-
                                                    then throw(("Your staked lands already contain " + az))
1498
+
                                                if (containsElement(hd, ay))
1499
+
                                                    then throw(("Your staked lands already contain " + ay))
1518
1500
 
                                                    else {
1519
-
                                                        let ey = valueOrElse(getInteger(as(az)), 0)
1520
-
                                                        let ho = bQ(bs)
1521
-
                                                        let hC = valueOrElse(getInteger(ho), 0)
1522
-
                                                        let hD = bU(invoke(bJ, "onStakeLand", [bs], nil))
1523
-
                                                        $Tuple2([IntegerEntry(gb, lastBlock.timestamp), IntegerEntry(av(K, az, bs), lastBlock.timestamp), StringEntry(hj, makeString_11C((hf :+ az), "_")), IntegerEntry(ho, (hC + fP)), StringEntry(ao(az), bs), StringEntry(cw(cr), bs), IntegerEntry(cv(M, az, bs), fQ), IntegerEntry(cu(az, bs), ey), StringEntry(bO(), cR), hz], hD)
1501
+
                                                        let ev = valueOrElse(getInteger(ar(ay)), 0)
1502
+
                                                        let hm = bF(bh)
1503
+
                                                        let hA = valueOrElse(getInteger(hm), 0)
1504
+
                                                        let hB = bJ(invoke(by, "onStakeLand", [bh], nil))
1505
+
                                                        $Tuple2([IntegerEntry(fZ, lastBlock.timestamp), IntegerEntry(au(K, ay, bh), lastBlock.timestamp), StringEntry(hh, makeString_11C((hd :+ ay), "_")), IntegerEntry(hm, (hA + fN)), StringEntry(an(ay), bh), StringEntry(cl(cg), bh), IntegerEntry(ck(M, ay, bh), fO), IntegerEntry(cj(ay, bh), ev), StringEntry(bD(), cN), hx], hB)
1524
1506
 
                                                        }
1525
1507
 
                                                }
1526
1508
 
                                        }
1527
1509
 
                                }
1528
1510
 
                    }
1529
1511
 
            }
1530
1512
 
    }
1531
1513
 
1532
1514
 
1533
1515
 
1534
-
@Callable(du)
1535
-
func unstakeLand (fV) = {
1536
-
    let hz = hw(du)
1537
-
    if ((size(du.payments) != 0))
1516
+
@Callable(ds)
1517
+
func unstakeLand (fT) = {
1518
+
    let hx = hu(ds)
1519
+
    if ((size(ds.payments) != 0))
1538
1520
 
        then throw("No payments required")
1539
1521
 
        else {
1540
-
            let p = toString(du.caller)
1541
-
            let gg = fT(p, cB, fV)
1542
-
            let az = gg._2
1543
-
            let hj = bP(p)
1544
-
            let dq = dw(gg._3[bM])
1545
-
            let fP = bW(gg._3[bL])
1546
-
            let cR = dv(dq, (fP / bm), -1)
1547
-
            let gz = gs(p, az, fP, cB)
1548
-
            let hf = split_51C(valueOrElse(getString(hj), ""), "_")
1549
-
            let bE = indexOf(hf, az)
1550
-
            if (!(isDefined(bE)))
1551
-
                then throw(("Your staked lands don't contain " + az))
1522
+
            let p = toString(ds.caller)
1523
+
            let ge = fR(p, cq, fT)
1524
+
            let ay = ge._2
1525
+
            let hh = bE(p)
1526
+
            let do = du(ge._3[bB])
1527
+
            let fN = bL(ge._3[bA])
1528
+
            let cN = dt(do, (fN / bb), -1)
1529
+
            let gx = gq(p, ay, fN, cq)
1530
+
            let hd = split_51C(valueOrElse(getString(hh), ""), "_")
1531
+
            let bt = indexOf(hd, ay)
1532
+
            if (!(isDefined(bt)))
1533
+
                then throw(("Your staked lands don't contain " + ay))
1552
1534
 
                else {
1553
-
                    let eb = value(blockInfoByHeight(height)).timestamp
1554
-
                    let hE = valueOrElse(getInteger(bI, aM(p)), 0)
1555
-
                    if ((hE >= eb))
1556
-
                        then throw(("Your gWL are taking part in voting, cannot unstake until " + toString(hE)))
1535
+
                    let dZ = value(blockInfoByHeight(height)).timestamp
1536
+
                    let hC = valueOrElse(getInteger(bx, aL(p)), 0)
1537
+
                    if ((hC >= dZ))
1538
+
                        then throw(("Your gWL are taking part in voting, cannot unstake until " + toString(hC)))
1557
1539
 
                        else {
1558
-
                            let ho = bQ(p)
1559
-
                            let hp = valueOrElse(getInteger(ho), 0)
1560
-
                            let hF = if ((fP > hp))
1540
+
                            let hm = bF(p)
1541
+
                            let hn = valueOrElse(getInteger(hm), 0)
1542
+
                            let hD = if ((fN > hn))
1561
1543
 
                                then 0
1562
-
                                else (hp - fP)
1563
-
                            let hD = bU(invoke(bJ, "onUnstakeLand", [p], nil))
1564
-
                            $Tuple2([ScriptTransfer(du.caller, 1, fromBase58String(az)), DeleteEntry(ar(az)), DeleteEntry(av(K, az, p)), StringEntry(bO(), cR), StringEntry(gz._2, makeString(gz._3, ":")), if ((size(hf) > 1))
1565
-
                                then StringEntry(hj, makeString_11C(removeByIndex(hf, value(bE)), "_"))
1566
-
                                else DeleteEntry(hj), IntegerEntry(ho, hF), hz], hD)
1544
+
                                else (hn - fN)
1545
+
                            let hB = bJ(invoke(by, "onUnstakeLand", [p], nil))
1546
+
                            $Tuple2([ScriptTransfer(ds.caller, 1, fromBase58String(ay)), DeleteEntry(aq(ay)), DeleteEntry(au(K, ay, p)), StringEntry(bD(), cN), StringEntry(gx._2, makeString(gx._3, ":")), if ((size(hd) > 1))
1547
+
                                then StringEntry(hh, makeString_11C(removeByIndex(hd, value(bt)), "_"))
1548
+
                                else DeleteEntry(hh), IntegerEntry(hm, hD), hx], hB)
1567
1549
 
                            }
1568
1550
 
                    }
1569
1551
 
            }
1570
1552
 
    }
1571
1553
 
1572
1554
 
1573
1555
 
1574
-
@Callable(du)
1556
+
@Callable(ds)
1575
1557
 
func stakeDuck () = {
1576
-
    let hz = hw(du)
1577
-
    if ((size(du.payments) != 1))
1558
+
    let hx = hu(ds)
1559
+
    if ((size(ds.payments) != 1))
1578
1560
 
        then throw("Exactly one payment required")
1579
1561
 
        else {
1580
-
            let hA = value(du.payments[0])
1581
-
            let ap = value(hA.assetId)
1582
-
            let bs = toString(du.caller)
1583
-
            if ((hA.amount != 1))
1562
+
            let hy = value(ds.payments[0])
1563
+
            let ao = value(hy.assetId)
1564
+
            let bh = toString(ds.caller)
1565
+
            if ((hy.amount != 1))
1584
1566
 
                then throw((("NFT " + L) + " token should be attached as payment"))
1585
1567
 
                else {
1586
-
                    let ga = value(assetInfo(ap))
1587
-
                    if (if ((ga.issuer != bY))
1588
-
                        then (ga.issuer != bZ)
1568
+
                    let fY = value(assetInfo(ao))
1569
+
                    if (if ((fY.issuer != bN))
1570
+
                        then (fY.issuer != bO)
1589
1571
 
                        else false)
1590
1572
 
                        then throw((("Unknown issuer of " + L) + " token"))
1591
-
                        else if (!(contains(ga.name, L)))
1573
+
                        else if (!(contains(fY.name, L)))
1592
1574
 
                            then throw((("Only NFT " + L) + " tokens are accepted"))
1593
1575
 
                            else {
1594
-
                                let hG = toBase58String(ap)
1595
-
                                let gb = ar(hG)
1596
-
                                if (isDefined(getInteger(gb)))
1597
-
                                    then throw((("NFT " + ga.name) + " is already staked"))
1598
-
                                    else if (isDefined(getString(aH(bs))))
1599
-
                                        then throw(("You already staked one duck: " + ga.name))
1576
+
                                let hE = toBase58String(ao)
1577
+
                                let fZ = aq(hE)
1578
+
                                if (isDefined(getInteger(fZ)))
1579
+
                                    then throw((("NFT " + fY.name) + " is already staked"))
1580
+
                                    else if (isDefined(getString(aG(bh))))
1581
+
                                        then throw(("You already staked one duck: " + fY.name))
1600
1582
 
                                        else {
1601
-
                                            let hH = aJ(hG)
1602
-
                                            let hI = getString(hH)
1603
-
                                            let ed = aI(hG)
1604
-
                                            let hJ = getString(ed)
1605
-
                                            let fE = aK(hG)
1606
-
                                            let fF = E(valueOrElse(getInteger(m(hG)), 0))
1607
-
                                            let hK = valueOrElse(getInteger(fE), fF)
1608
-
                                            ([IntegerEntry(gb, lastBlock.timestamp), IntegerEntry(av(L, toBase58String(ap), bs), lastBlock.timestamp), StringEntry(aG(hG), bs), StringEntry(aH(bs), hG)] ++ (if (isDefined(hI))
1583
+
                                            let hF = aI(hE)
1584
+
                                            let hG = getString(hF)
1585
+
                                            let eb = aH(hE)
1586
+
                                            let hH = getString(eb)
1587
+
                                            let fC = aJ(hE)
1588
+
                                            let fD = E(valueOrElse(getInteger(m(hE)), 0))
1589
+
                                            let hI = valueOrElse(getInteger(fC), fD)
1590
+
                                            ([IntegerEntry(fZ, lastBlock.timestamp), IntegerEntry(au(L, toBase58String(ao), bh), lastBlock.timestamp), StringEntry(aF(hE), bh), StringEntry(aG(bh), hE)] ++ (if (isDefined(hG))
1609
1591
 
                                                then nil
1610
-
                                                else ([StringEntry(hH, R)] ++ (if (isDefined(hJ))
1592
+
                                                else ([StringEntry(hF, R)] ++ (if (isDefined(hH))
1611
1593
 
                                                    then nil
1612
-
                                                    else (([StringEntry(ed, "0:0_0_0_0_0_0:0_0_0_0_0_0:")] :+ IntegerEntry(fE, hK)) :+ hz)))))
1594
+
                                                    else (([StringEntry(eb, "0:0_0_0_0_0_0:0_0_0_0_0_0:")] :+ IntegerEntry(fC, hI)) :+ hx)))))
1613
1595
 
                                            }
1614
1596
 
                                }
1615
1597
 
                    }
1616
1598
 
            }
1617
1599
 
    }
1618
1600
 
1619
1601
 
1620
1602
 
1621
-
@Callable(du)
1622
-
func unstakeDuck (hG) = {
1623
-
    let hz = hw(du)
1624
-
    if ((size(du.payments) != 0))
1603
+
@Callable(ds)
1604
+
func unstakeDuck (hE) = {
1605
+
    let hx = hu(ds)
1606
+
    if ((size(ds.payments) != 0))
1625
1607
 
        then throw("No payments required")
1626
1608
 
        else {
1627
-
            let ap = fromBase58String(hG)
1628
-
            let bs = toString(du.caller)
1629
-
            let ga = value(assetInfo(ap))
1630
-
            let gb = ar(toBase58String(ap))
1631
-
            if (!(isDefined(getInteger(gb))))
1632
-
                then throw((("NFT " + ga.name) + " is not staked"))
1633
-
                else if (!(isDefined(getString(aH(bs)))))
1634
-
                    then throw((("The duck " + ga.name) + " is not staked"))
1609
+
            let ao = fromBase58String(hE)
1610
+
            let bh = toString(ds.caller)
1611
+
            let fY = value(assetInfo(ao))
1612
+
            let fZ = aq(toBase58String(ao))
1613
+
            if (!(isDefined(getInteger(fZ))))
1614
+
                then throw((("NFT " + fY.name) + " is not staked"))
1615
+
                else if (!(isDefined(getString(aG(bh)))))
1616
+
                    then throw((("The duck " + fY.name) + " is not staked"))
1635
1617
 
                    else {
1636
-
                        let gd = valueOrErrorMessage(getString(aG(toBase58String(ap))), (("NFT " + ga.name) + " is orphaned"))
1637
-
                        if ((gd != bs))
1618
+
                        let gb = valueOrErrorMessage(getString(aF(toBase58String(ao))), (("NFT " + fY.name) + " is orphaned"))
1619
+
                        if ((gb != bh))
1638
1620
 
                            then throw("Staked NFT is not yours")
1639
1621
 
                            else {
1640
-
                                let fE = aK(hG)
1641
-
                                let fF = E(valueOrElse(getInteger(m(hG)), 0))
1642
-
                                let hL = valueOrElse(getInteger(fE), fF)
1643
-
                                if ((fF > hL))
1644
-
                                    then throw((("Please heal your duck to " + toString(fF)) + "hp before unstaking"))
1645
-
                                    else [ScriptTransfer(du.caller, 1, ap), DeleteEntry(gb), DeleteEntry(fE), DeleteEntry(aJ(hG)), DeleteEntry(aG(hG)), DeleteEntry(av(L, hG, bs)), DeleteEntry(aH(bs)), hz]
1622
+
                                let fC = aJ(hE)
1623
+
                                let fD = E(valueOrElse(getInteger(m(hE)), 0))
1624
+
                                let hJ = valueOrElse(getInteger(fC), fD)
1625
+
                                if ((fD > hJ))
1626
+
                                    then throw((("Please heal your duck to " + toString(fD)) + "hp before unstaking"))
1627
+
                                    else [ScriptTransfer(ds.caller, 1, ao), DeleteEntry(fZ), DeleteEntry(fC), DeleteEntry(aI(hE)), DeleteEntry(aF(hE)), DeleteEntry(au(L, hE, bh)), DeleteEntry(aG(bh)), hx]
1646
1628
 
                                }
1647
1629
 
                        }
1648
1630
 
            }
1649
1631
 
    }
1650
1632
 
1651
1633
 
1652
1634
 
1653
-
@Callable(du)
1654
-
func claimRes (eL,hM) = {
1655
-
    let hz = hw(du)
1656
-
    if ((size(du.payments) != 0))
1635
+
@Callable(ds)
1636
+
func claimRes (eI,hK) = {
1637
+
    let hx = hu(ds)
1638
+
    if ((size(ds.payments) != 0))
1657
1639
 
        then throw("No payments required")
1658
1640
 
        else {
1659
-
            let p = toString(du.originCaller)
1660
-
            let cZ = gf(p, eL, cB, hM)
1661
-
            let k = valueOrErrorMessage(getString(aH(p)), "You don't have a duck staked")
1662
-
            $Tuple2(((((cZ._1 ++ gF(k, fraction(s, eL, bl))._1) :+ StringEntry(cZ._2, makeString(cZ._3, ":"))) :+ StringEntry(cZ._4, makeString(cZ._5, ":"))) :+ hz), cZ._3[ai])
1663
-
            }
1664
-
    }
1665
-
1666
-
1667
-
1668
-
@Callable(du)
1669
-
func claimResToWH (eL,hM) = {
1670
-
    let hz = hw(du)
1671
-
    if ((size(du.payments) != 0))
1641
+
            let p = toString(ds.originCaller)
1642
+
            let cV = gd(p, eI, cq, hK)
1643
+
            let k = valueOrErrorMessage(getString(aG(p)), "You don't have a duck staked")
1644
+
            $Tuple2(((((cV._1 ++ gD(k, fraction(s, eI, ba))._1) :+ StringEntry(cV._2, makeString(cV._3, ":"))) :+ StringEntry(cV._4, makeString(cV._5, ":"))) :+ hx), cV._3[aj])
1645
+
            }
1646
+
    }
1647
+
1648
+
1649
+
1650
+
@Callable(ds)
1651
+
func claimResToWH (eI,hK) = {
1652
+
    let hx = hu(ds)
1653
+
    if ((size(ds.payments) != 0))
1672
1654
 
        then throw("No payments required")
1673
1655
 
        else {
1674
-
            let p = toString(du.originCaller)
1675
-
            let cZ = gf(p, eL, cA, hM)
1676
-
            $Tuple2(((((cZ._1 ++ gL(p, fraction(s, eL, bl))._1) :+ StringEntry(cZ._2, makeString(cZ._3, ":"))) :+ StringEntry(cZ._4, makeString(cZ._5, ":"))) :+ hz), cZ._5[Z])
1677
-
            }
1678
-
    }
1679
-
1680
-
1681
-
1682
-
@Callable(du)
1683
-
func flight (ft,fu) = {
1684
-
    let hz = hw(du)
1685
-
    if ((size(du.payments) != 0))
1656
+
            let p = toString(ds.originCaller)
1657
+
            let cV = gd(p, eI, cp, hK)
1658
+
            $Tuple2(((((cV._1 ++ gJ(p, fraction(s, eI, ba))._1) :+ StringEntry(cV._2, makeString(cV._3, ":"))) :+ StringEntry(cV._4, makeString(cV._5, ":"))) :+ hx), cV._5[aa])
1659
+
            }
1660
+
    }
1661
+
1662
+
1663
+
1664
+
@Callable(ds)
1665
+
func flight (fr,fs) = {
1666
+
    let hx = hu(ds)
1667
+
    if ((size(ds.payments) != 0))
1686
1668
 
        then throw("No payments required")
1687
1669
 
        else {
1688
-
            let aN = toString(du.caller)
1689
-
            let dZ = fs(aN, ft, fu)
1690
-
            let k = dZ._2
1691
-
            let hH = aJ(k)
1692
-
            let fX = valueOrElse(getString(hH), R)
1693
-
            if ((dZ._4 == fX))
1670
+
            let aM = toString(ds.caller)
1671
+
            let dX = fq(aM, fr, fs)
1672
+
            let k = dX._2
1673
+
            let hF = aI(k)
1674
+
            let fV = valueOrElse(getString(hF), R)
1675
+
            if ((dX._4 == fV))
1694
1676
 
                then throw("You can't fly to the same location")
1695
1677
 
                else {
1696
-
                    let ed = aI(k)
1697
-
                    let eO = ec(ed)
1698
-
                    let dn = da(eO[ak], dZ._5)
1699
-
                    $Tuple2(([StringEntry(hH, if ((dZ._1 > 0))
1700
-
                        then dZ._4
1701
-
                        else fX), StringEntry(ed, makeString([eO[ah], eO[ai], eO[aj], dn], ":")), IntegerEntry(aK(k), dZ._1), hz] ++ gF(k, if ((dZ._1 > 0))
1678
+
                    let eb = aH(k)
1679
+
                    let eM = ea(eb)
1680
+
                    let dl = cW(eM[al], dX._5)
1681
+
                    $Tuple2(([StringEntry(hF, if ((dX._1 > 0))
1682
+
                        then dX._4
1683
+
                        else fV), StringEntry(eb, makeString([eM[ai], eM[aj], eM[ak], dl], ":")), IntegerEntry(aJ(k), dX._1), hx] ++ gD(k, if ((dX._1 > 0))
1702
1684
 
                        then t
1703
-
                        else u)._1), dZ._3)
1685
+
                        else u)._1), dX._3)
1704
1686
 
                    }
1705
1687
 
            }
1706
1688
 
    }
1707
1689
 
1708
1690
 
1709
1691
 
1710
-
@Callable(du)
1711
-
func heal (hN,hO,hP) = {
1712
-
    let hz = hw(du)
1713
-
    if (if (if ((0 > hN))
1692
+
@Callable(ds)
1693
+
func heal (hL,hM,hN) = {
1694
+
    let hx = hu(ds)
1695
+
    if (if (if ((0 > hL))
1714
1696
 
        then true
1715
-
        else (0 > hO))
1697
+
        else (0 > hM))
1716
1698
 
        then true
1717
-
        else (0 > hP))
1699
+
        else (0 > hN))
1718
1700
 
        then throw("Quantity cannot be negative")
1719
1701
 
        else {
1720
-
            let k = valueOrErrorMessage(getString(aH(toString(du.caller))), "You don't have a duck staked")
1721
-
            let hQ = [hN, hO, hP]
1722
-
            let fE = aK(k)
1723
-
            let fF = E(valueOrElse(getInteger(m(k)), 0))
1724
-
            let hR = valueOrElse(getInteger(fE), fF)
1725
-
            if ((hR >= fF))
1726
-
                then throw((("HP should be < " + toString(fF)) + " to heal"))
1702
+
            let k = valueOrErrorMessage(getString(aG(toString(ds.caller))), "You don't have a duck staked")
1703
+
            let hO = [hL, hM, hN]
1704
+
            let fC = aJ(k)
1705
+
            let fD = E(valueOrElse(getInteger(m(k)), 0))
1706
+
            let hP = valueOrElse(getInteger(fC), fD)
1707
+
            if ((hP >= fD))
1708
+
                then throw((("HP should be < " + toString(fD)) + " to heal"))
1727
1709
 
                else {
1728
-
                    let ed = aI(k)
1729
-
                    let eO = ec(ed)
1730
-
                    let hS = if ((eO[ak] == ""))
1710
+
                    let eb = aH(k)
1711
+
                    let eM = ea(eb)
1712
+
                    let hQ = if ((eM[al] == ""))
1731
1713
 
                        then nil
1732
-
                        else split(eO[ak], "_")
1733
-
                    func hT (cO,hU) =                     {
1734
-
                        let bV = cO._2
1735
-
                        let dQ = if ((size(hS) > bV))
1736
-
                            then parseIntValue(hS[bV])
1714
+
                        else split(eM[al], "_")
1715
+
                    func hR (cD,hS) =                     {
1716
+
                        let bK = cD._2
1717
+
                        let dO = if ((size(hQ) > bK))
1718
+
                            then parseIntValue(hQ[bK])
1737
1719
 
                            else 0
1738
-
                        if ((3 > bV))
1720
+
                        if ((3 > bK))
1739
1721
 
                            then {
1740
-
                                let hV = hQ[bV]
1741
-
                                if ((hV > dQ))
1742
-
                                    then throw(((("You have only " + toString(dQ)) + " of ") + U[bV]))
1743
-
                                    else $Tuple3((cO._1 :+ toString((dQ - hV))), (bV + 1), (cO._3 + (cb[bV] * hV)))
1722
+
                                let hT = hO[bK]
1723
+
                                if ((hT > dO))
1724
+
                                    then throw(((("You have only " + toString(dO)) + " of ") + U[bK]))
1725
+
                                    else $Tuple3((cD._1 :+ toString((dO - hT))), (bK + 1), (cD._3 + (bQ[bK] * hT)))
1744
1726
 
                                }
1745
-
                            else $Tuple3((cO._1 :+ toString(dQ)), (bV + 1), cO._3)
1727
+
                            else $Tuple3((cD._1 :+ toString(dO)), (bK + 1), cD._3)
1746
1728
 
                        }
1747
1729
 
1748
-
                    let cZ = {
1749
-
                        let aW = W
1750
-
                        let aX = size(aW)
1751
-
                        let aY = $Tuple3(nil, 0, 0)
1752
-
                        func aZ (ba,bb) =                         if ((bb >= aX))
1753
-
                            then ba
1754
-
                            else hT(ba, aW[bb])
1755
-
1756
-
                        func bc (ba,bb) =                         if ((bb >= aX))
1757
-
                            then ba
1730
+
                    let cV = {
1731
+
                        let cF = W
1732
+
                        let cG = size(cF)
1733
+
                        let cH = $Tuple3(nil, 0, 0)
1734
+
                        func cI (cJ,cK) =                         if ((cK >= cG))
1735
+
                            then cJ
1736
+
                            else hR(cJ, cF[cK])
1737
+
1738
+
                        func cL (cJ,cK) =                         if ((cK >= cG))
1739
+
                            then cJ
1758
1740
 
                            else throw("List size exceeds 50")
1759
1741
 
1760
-
                        bc(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aY, 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)
1742
+
                        cL(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cH, 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)
1761
1743
 
                        }
1762
-
                    let hW = min([fF, (hR + cZ._3)])
1763
-
                    $Tuple2(([IntegerEntry(fE, hW), StringEntry(ed, makeString_2C([eO[ah], eO[ai], eO[aj], makeString(cZ._1, "_")], ":")), hz] ++ gF(k, (B * ((hN + hO) + hP)))._1), hW)
1744
+
                    let hU = min([fD, (hP + cV._3)])
1745
+
                    $Tuple2(([IntegerEntry(fC, hU), StringEntry(eb, makeString_2C([eM[ai], eM[aj], eM[ak], makeString(cV._1, "_")], ":")), hx] ++ gD(k, (B * ((hL + hM) + hN)))._1), hU)
1764
1746
 
                    }
1765
1747
 
            }
1766
1748
 
    }
1767
1749
 
1768
1750
 
1769
1751
 
1770
-
@Callable(du)
1752
+
@Callable(ds)
1771
1753
 
func healES () = {
1772
-
    let hz = hw(du)
1773
-
    if ((size(du.payments) != 1))
1754
+
    let hx = hu(ds)
1755
+
    if ((size(ds.payments) != 1))
1774
1756
 
        then throw("Exactly one payment required")
1775
1757
 
        else {
1776
-
            let hA = value(du.payments[0])
1777
-
            if ((hA.assetId != bf))
1758
+
            let hy = value(ds.payments[0])
1759
+
            if ((hy.assetId != aU))
1778
1760
 
                then throw("Allowed USDT payment only!")
1779
1761
 
                else {
1780
-
                    let k = valueOrErrorMessage(getString(aH(toString(du.caller))), "You don't have a duck staked")
1781
-
                    let fE = aK(k)
1782
-
                    let fF = E(valueOrElse(getInteger(m(k)), 0))
1783
-
                    let hR = valueOrElse(getInteger(fE), fF)
1784
-
                    if ((hR > 0))
1762
+
                    let k = valueOrErrorMessage(getString(aG(toString(ds.caller))), "You don't have a duck staked")
1763
+
                    let fC = aJ(k)
1764
+
                    let fD = E(valueOrElse(getInteger(m(k)), 0))
1765
+
                    let hP = valueOrElse(getInteger(fC), fD)
1766
+
                    if ((hP > 0))
1785
1767
 
                        then throw("HP should be 0 to call Emergency Service")
1786
1768
 
                        else {
1787
-
                            let ed = aI(k)
1788
-
                            let eO = ec(ed)
1789
-
                            let hS = if ((eO[ak] == ""))
1769
+
                            let eb = aH(k)
1770
+
                            let eM = ea(eb)
1771
+
                            let hQ = if ((eM[al] == ""))
1790
1772
 
                                then nil
1791
-
                                else split(eO[ak], "_")
1792
-
                            let hX = if ((size(hS) > 0))
1793
-
                                then parseIntValue(hS[0])
1773
+
                                else split(eM[al], "_")
1774
+
                            let hV = if ((size(hQ) > 0))
1775
+
                                then parseIntValue(hQ[0])
1794
1776
 
                                else 0
1795
-
                            let hY = if ((size(hS) > 1))
1796
-
                                then parseIntValue(hS[1])
1777
+
                            let hW = if ((size(hQ) > 1))
1778
+
                                then parseIntValue(hQ[1])
1797
1779
 
                                else 0
1798
-
                            let hZ = if ((size(hS) > 2))
1799
-
                                then parseIntValue(hS[2])
1780
+
                            let hX = if ((size(hQ) > 2))
1781
+
                                then parseIntValue(hQ[2])
1800
1782
 
                                else 0
1801
-
                            if (if (if ((hX > 0))
1783
+
                            if (if (if ((hV > 0))
1802
1784
 
                                then true
1803
-
                                else (hY > 0))
1785
+
                                else (hW > 0))
1804
1786
 
                                then true
1805
-
                                else (hZ > 0))
1787
+
                                else (hX > 0))
1806
1788
 
                                then throw("You have to use own Medical Kit")
1807
1789
 
                                else {
1808
-
                                    let ia = getString(bH, aO())
1809
-
                                    let ib = if (isDefined(ia))
1810
-
                                        then split(value(ia), "_")
1790
+
                                    let hY = getString(bw, aN())
1791
+
                                    let hZ = if (isDefined(hY))
1792
+
                                        then split(value(hY), "_")
1811
1793
 
                                        else nil
1812
-
                                    let ic = if ((size(ib) > 0))
1813
-
                                        then parseIntValue(ib[0])
1794
+
                                    let ia = if ((size(hZ) > 0))
1795
+
                                        then parseIntValue(hZ[0])
1814
1796
 
                                        else 0
1815
-
                                    if ((0 >= ic))
1797
+
                                    if ((0 >= ia))
1816
1798
 
                                        then throw("There are no Medical Kits L1 at Emergency Service storage")
1817
1799
 
                                        else {
1818
-
                                            let hW = (hR + cb[0])
1819
-
                                            let id = makeString([toString((ic - 1)), removeByIndex(ib, 0)], "_")
1820
-
                                            let aS = split(W[0], "_")
1821
-
                                            let ie = aR(aS)
1822
-
                                            let if = parseIntValue(aS[X])
1823
-
                                            let ig = fraction((ie * T), S, (10 * if))
1824
-
                                            if ((hA.amount != ig))
1825
-
                                                then throw(("Payment attached should be " + toString(ig)))
1800
+
                                            let hU = (hP + bQ[0])
1801
+
                                            let ib = makeString([toString((ia - 1)), removeByIndex(hZ, 0)], "_")
1802
+
                                            let aR = split(W[0], "_")
1803
+
                                            let ic = aQ(aR)
1804
+
                                            let id = fraction((ic * T), S, (10 * Y))
1805
+
                                            if ((hy.amount != id))
1806
+
                                                then throw(("Payment attached should be " + toString(id)))
1826
1807
 
                                                else {
1827
-
                                                    let cZ = bR(invoke(bH, "updateEsStorage", [id], [AttachedPayment(bf, ig)]))
1828
-
                                                    $Tuple2(([IntegerEntry(fE, hW), hz] ++ gF(k, v)._1), cZ)
1808
+
                                                    let cV = bG(invoke(bw, "updateEsStorage", [ib], [AttachedPayment(aU, id)]))
1809
+
                                                    $Tuple2(([IntegerEntry(fC, hU), hx] ++ gD(k, v)._1), cV)
1829
1810
 
                                                    }
1830
1811
 
                                            }
1831
1812
 
                                    }
1832
1813
 
                            }
1833
1814
 
                    }
1834
1815
 
            }
1835
1816
 
    }
1836
1817
 
1837
1818
 
1838
1819
 
1839
-
@Callable(du)
1840
-
func updateBackpack (k,ih) = if ((du.caller != bH))
1820
+
@Callable(ds)
1821
+
func updateBackpack (k,ie) = if ((ds.caller != bw))
1841
1822
 
    then throw("permission denied")
1842
-
    else $Tuple2([StringEntry(aI(k), ih)], ih)
1843
-
1844
-
1845
-
1846
-
@Callable(du)
1823
+
    else $Tuple2([StringEntry(aH(k), ie)], ie)
1824
+
1825
+
1826
+
1827
+
@Callable(ds)
1847
1828
 
func buySLand () = {
1848
-
    let hz = hw(du)
1849
-
    if ((size(du.payments) != 1))
1829
+
    let hx = hu(ds)
1830
+
    if ((size(ds.payments) != 1))
1850
1831
 
        then throw("Exactly one payment required")
1851
1832
 
        else {
1852
-
            let hA = value(du.payments[0])
1853
-
            if ((hA.assetId != bf))
1833
+
            let hy = value(ds.payments[0])
1834
+
            if ((hy.assetId != aU))
1854
1835
 
                then throw("Allowed USDT payment only!")
1855
-
                else if ((hA.amount != ch))
1856
-
                    then throw(("Payment attached should be " + toString(ch)))
1836
+
                else if ((hy.amount != bW))
1837
+
                    then throw(("Payment attached should be " + toString(bW)))
1857
1838
 
                    else {
1858
-
                        let cZ = fk(du.caller, du.transactionId)
1859
-
                        $Tuple2((((cZ._1 :+ ScriptTransfer(bH, hA.amount, bf)) ++ gL(toString(du.caller), x)._1) :+ hz), cZ._2._1)
1839
+
                        let cV = fi(ds.caller, ds.transactionId)
1840
+
                        $Tuple2((((cV._1 :+ ScriptTransfer(bw, hy.amount, aU)) ++ gJ(toString(ds.caller), x)._1) :+ hx), cV._2._1)
1860
1841
 
                        }
1861
1842
 
            }
1862
1843
 
    }
1863
1844
 
1864
1845
 
1865
1846
 
1866
-
@Callable(du)
1867
-
func expedition (ft,fu) = {
1868
-
    let hz = hw(du)
1869
-
    if ((size(du.payments) != 0))
1847
+
@Callable(ds)
1848
+
func expedition (fr,fs) = {
1849
+
    let hx = hu(ds)
1850
+
    if ((size(ds.payments) != 0))
1870
1851
 
        then throw("No payments required")
1871
1852
 
        else {
1872
-
            let cZ = fK(du.caller, du.transactionId, ft, fu)
1873
-
            let k = valueOrErrorMessage(getString(aH(toString(du.caller))), "You don't have a duck staked")
1874
-
            $Tuple2(((cZ._1 ++ gF(k, x)._1) :+ hz), $Tuple2(cZ._2, cZ._3))
1875
-
            }
1876
-
    }
1877
-
1878
-
1879
-
1880
-
@Callable(du)
1881
-
func upgradeInfra (az) = {
1882
-
    let hz = hw(du)
1883
-
    if ((size(du.payments) != 0))
1853
+
            let cV = fI(ds.caller, ds.transactionId, fr, fs)
1854
+
            let k = valueOrErrorMessage(getString(aG(toString(ds.caller))), "You don't have a duck staked")
1855
+
            $Tuple2(((cV._1 ++ gD(k, x)._1) :+ hx), $Tuple2(cV._2, cV._3))
1856
+
            }
1857
+
    }
1858
+
1859
+
1860
+
1861
+
@Callable(ds)
1862
+
func upgradeInfra (ay) = {
1863
+
    let hx = hu(ds)
1864
+
    if ((size(ds.payments) != 0))
1884
1865
 
        then throw("No payments required")
1885
1866
 
        else {
1886
-
            let cZ = gt(true, du.caller, 0, az)
1887
-
            let k = valueOrErrorMessage(getString(aH(toString(du.caller))), "You don't have a duck staked")
1888
-
            $Tuple2(((cZ._1 :+ hz) ++ gF(k, fraction(y, cZ._3, bl))._1), cZ._2)
1889
-
            }
1890
-
    }
1891
-
1892
-
1893
-
1894
-
@Callable(du)
1895
-
func upgradeInfraUsdt (az) = if ((du.caller != this))
1867
+
            let cV = gr(true, ds.caller, 0, ay)
1868
+
            let k = valueOrErrorMessage(getString(aG(toString(ds.caller))), "You don't have a duck staked")
1869
+
            $Tuple2(((cV._1 :+ hx) ++ gD(k, fraction(y, cV._3, ba))._1), cV._2)
1870
+
            }
1871
+
    }
1872
+
1873
+
1874
+
1875
+
@Callable(ds)
1876
+
func upgradeInfraUsdt (ay) = if ((ds.caller != this))
1896
1877
 
    then throw("Permission denied")
1897
1878
 
    else {
1898
-
        let hz = hw(du)
1899
-
        if ((size(du.payments) != 1))
1879
+
        let hx = hu(ds)
1880
+
        if ((size(ds.payments) != 1))
1900
1881
 
            then throw("Exactly one payment required")
1901
1882
 
            else {
1902
-
                let hA = value(du.payments[0])
1903
-
                if ((hA.assetId != bf))
1883
+
                let hy = value(ds.payments[0])
1884
+
                if ((hy.assetId != aU))
1904
1885
 
                    then throw("Allowed USDT payment only!")
1905
1886
 
                    else {
1906
-
                        let cZ = gt(false, du.caller, hA.amount, az)
1907
-
                        $Tuple2(((cZ._1 :+ ScriptTransfer(bH, hA.amount, bf)) :+ hz), cZ._2)
1887
+
                        let cV = gr(false, ds.caller, hy.amount, ay)
1888
+
                        $Tuple2(((cV._1 :+ ScriptTransfer(bw, hy.amount, aU)) :+ hx), cV._2)
1908
1889
 
                        }
1909
1890
 
                }
1910
1891
 
        }
1911
1892
 
1912
1893
 
1913
1894
 
1914
-
@Callable(du)
1915
-
func activateArtifact (ii,ij) = {
1916
-
    let hz = hw(du)
1917
-
    if ((size(du.payments) != 0))
1895
+
@Callable(ds)
1896
+
func activateArtifact (if,ig) = {
1897
+
    let hx = hu(ds)
1898
+
    if ((size(ds.payments) != 0))
1918
1899
 
        then throw("No payments required")
1919
1900
 
        else {
1920
-
            let p = toString(du.caller)
1921
-
            let cZ = {
1922
-
                let bg = ii
1923
-
                if (("PRESALE" == bg))
1924
-
                    then gT(p, ij)
1925
-
                    else if (("ONBOARD" == bg))
1926
-
                        then gM(p)
1901
+
            let p = toString(ds.caller)
1902
+
            let cV = {
1903
+
                let aV = if
1904
+
                if (("PRESALE" == aV))
1905
+
                    then gR(p, ig)
1906
+
                    else if (("ONBOARD" == aV))
1907
+
                        then gK(p)
1927
1908
 
                        else throw("Unknown artifact")
1928
1909
 
                }
1929
-
            (cZ :+ hz)
1930
-
            }
1931
-
    }
1932
-
1933
-
1934
-
1935
-
@Callable(du)
1936
-
func mergeLands (gY) = {
1937
-
    let hz = hw(du)
1938
-
    if ((size(du.payments) != 0))
1910
+
            (cV :+ hx)
1911
+
            }
1912
+
    }
1913
+
1914
+
1915
+
1916
+
@Callable(ds)
1917
+
func mergeLands (gW) = {
1918
+
    let hx = hu(ds)
1919
+
    if ((size(ds.payments) != 0))
1939
1920
 
        then throw("No payments required")
1940
1921
 
        else {
1941
-
            let cZ = hu(true, toString(du.caller), 0, gY, du.transactionId)
1942
-
            $Tuple2(((cZ._1 :+ hz) ++ gL(toString(du.caller), z)._1), cZ._2)
1943
-
            }
1944
-
    }
1945
-
1946
-
1947
-
1948
-
@Callable(du)
1949
-
func mergeLandsUsdt (gY) = {
1950
-
    let hz = hw(du)
1951
-
    if ((size(du.payments) != 1))
1922
+
            let cV = hs(true, toString(ds.caller), 0, gW, ds.transactionId)
1923
+
            $Tuple2(((cV._1 :+ hx) ++ gJ(toString(ds.caller), z)._1), cV._2)
1924
+
            }
1925
+
    }
1926
+
1927
+
1928
+
1929
+
@Callable(ds)
1930
+
func mergeLandsUsdt (gW) = {
1931
+
    let hx = hu(ds)
1932
+
    if ((size(ds.payments) != 1))
1952
1933
 
        then throw("Exactly one payment required")
1953
1934
 
        else {
1954
-
            let hA = value(du.payments[0])
1955
-
            if ((hA.assetId != bf))
1935
+
            let hy = value(ds.payments[0])
1936
+
            if ((hy.assetId != aU))
1956
1937
 
                then throw("Allowed USDT payment only!")
1957
1938
 
                else {
1958
-
                    let cZ = hu(false, toString(du.caller), hA.amount, gY, du.transactionId)
1959
-
                    $Tuple2(((cZ._1 :+ ScriptTransfer(bH, hA.amount, bf)) :+ hz), cZ._2)
1939
+
                    let cV = hs(false, toString(ds.caller), hy.amount, gW, ds.transactionId)
1940
+
                    $Tuple2(((cV._1 :+ ScriptTransfer(bw, hy.amount, aU)) :+ hx), cV._2)
1960
1941
 
                    }
1961
1942
 
            }
1962
1943
 
    }
1963
1944
 
1964
1945
 
1965
1946
 
1966
-
@Callable(du)
1967
-
func cargoExchange (ik,az) = {
1968
-
    let hz = hw(du)
1969
-
    if ((size(du.payments) != 0))
1947
+
@Callable(ds)
1948
+
func cargoExchange (ih,ay) = {
1949
+
    let hx = hu(ds)
1950
+
    if ((size(ds.payments) != 0))
1970
1951
 
        then throw("No payments required")
1971
1952
 
        else {
1972
-
            let eN = split_4C(ik, ":")
1973
-
            let p = toString(du.originCaller)
1974
-
            let ga = value(assetInfo(fromBase58String(az)))
1975
-
            let gb = ar(az)
1976
-
            if (!(isDefined(getInteger(gb))))
1977
-
                then throw((ga.name + " is not staked"))
1953
+
            let eL = split_4C(ih, ":")
1954
+
            let p = toString(ds.originCaller)
1955
+
            let fY = value(assetInfo(fromBase58String(ay)))
1956
+
            let fZ = aq(ay)
1957
+
            if (!(isDefined(getInteger(fZ))))
1958
+
                then throw((fY.name + " is not staked"))
1978
1959
 
                else {
1979
-
                    let gd = valueOrErrorMessage(getString(ao(az)), (("NFT " + ga.name) + " is orphaned"))
1980
-
                    if ((gd != p))
1960
+
                    let gb = valueOrErrorMessage(getString(an(ay)), (("NFT " + fY.name) + " is orphaned"))
1961
+
                    if ((gb != p))
1981
1962
 
                        then throw((K + " is not yours"))
1982
1963
 
                        else {
1983
-
                            let ex = (bW(split(ga.description, "_")[bL]) / bm)
1984
-
                            let ey = valueOrElse(getInteger(as(az)), 0)
1985
-
                            let k = valueOrErrorMessage(getString(aH(p)), "You don't have a duck staked")
1986
-
                            let fX = valueOrElse(getString(aJ(k)), R)
1987
-
                            let fY = split(value(fX), "_")
1988
-
                            if ((fY[aP] != "L"))
1989
-
                                then throw((("Duck location type is " + fY[aP]) + ", but should be L"))
1990
-
                                else if ((fY[aQ] != az))
1991
-
                                    then throw(("Duck should be on the land " + az))
1964
+
                            let eu = (bL(split(fY.description, "_")[bA]) / bb)
1965
+
                            let ev = valueOrElse(getInteger(ar(ay)), 0)
1966
+
                            let k = valueOrErrorMessage(getString(aG(p)), "You don't have a duck staked")
1967
+
                            let fV = valueOrElse(getString(aI(k)), R)
1968
+
                            let fW = split(value(fV), "_")
1969
+
                            if ((fW[aO] != "L"))
1970
+
                                then throw((("Duck location type is " + fW[aO]) + ", but should be L"))
1971
+
                                else if ((fW[aP] != ay))
1972
+
                                    then throw(("Duck should be on the land " + ay))
1992
1973
 
                                    else {
1993
-
                                        let ew = ay(az)
1994
-
                                        let ei = ev(ew, ex, ey)
1995
-
                                        let ed = aI(k)
1996
-
                                        let eO = ec(ed)
1997
-
                                        let cZ = eM(eN, ei, eO)
1998
-
                                        let eE = split(ei[ac], "_")
1999
-
                                        let gq = (parseIntValue(eE[ae]) + cZ._7)
2000
-
                                        let gr = (parseIntValue(eE[af]) - cZ._7)
2001
-
[StringEntry(ed, makeString_2C([eO[ah], cZ._4, cZ._5, cZ._6], ":")), StringEntry(ew, makeString_2C([ei[Y], cZ._1, cZ._2, cZ._3, makeString([eE[ad], toString(gq), toString(gr), eE[ag]], "_")], ":")), hz]
1974
+
                                        let et = ax(ay)
1975
+
                                        let eg = es(et, eu, ev)
1976
+
                                        let eb = aH(k)
1977
+
                                        let eM = ea(eb)
1978
+
                                        let cV = eK(eL, eg, eM)
1979
+
                                        let eB = split(eg[ad], "_")
1980
+
                                        let go = (parseIntValue(eB[af]) + cV._7)
1981
+
                                        let gp = (parseIntValue(eB[ag]) - cV._7)
1982
+
[StringEntry(eb, makeString_2C([eM[ai], cV._4, cV._5, cV._6], ":")), StringEntry(et, makeString_2C([eg[Z], cV._1, cV._2, cV._3, makeString([eB[ae], toString(go), toString(gp), eB[ah]], "_")], ":")), hx]
2002
1983
 
                                        }
2003
1984
 
                            }
2004
1985
 
                    }
2005
1986
 
            }
2006
1987
 
    }
2007
1988
 
2008
1989
 
2009
1990
 
2010
-
@Callable(du)
2011
-
func saveWarehouse (eA,az) = if ((du.caller != bH))
1991
+
@Callable(ds)
1992
+
func saveWarehouse (ex,ay) = if ((ds.caller != bw))
2012
1993
 
    then throw("Access denied")
2013
1994
 
    else {
2014
-
        let ew = ay(az)
2015
-
        let eB = split_4C(eA, ":")
2016
-
        if ((size(eB) != 5))
1995
+
        let et = ax(ay)
1996
+
        let ey = split_4C(ex, ":")
1997
+
        if ((size(ey) != 5))
2017
1998
 
            then throw("warehouse string should contain 4 ':' separators")
2018
1999
 
            else {
2019
-
                let il = split(eB[ac], "_")[ad]
2020
-
                let gq = eh(eB)
2021
-
                let im = ef(eB[Y])
2022
-
                let gr = ((im - parseIntValue(il)) - gq)
2023
-
                let in = makeString_2C([eB[Y], eB[Z], eB[aa], eB[ab], makeString([il, toString(gq), toString(gr), toString(im)], "_")], ":")
2024
-
                $Tuple2([StringEntry(ew, in)], in)
2000
+
                let ii = split(ey[ad], "_")[ae]
2001
+
                let go = ef(ey)
2002
+
                let ij = ed(ey[Z])
2003
+
                let gp = ((ij - parseIntValue(ii)) - go)
2004
+
                let ik = makeString_2C([ey[Z], ey[aa], ey[ab], ey[ac], makeString([ii, toString(go), toString(gp), toString(ij)], "_")], ":")
2005
+
                $Tuple2([StringEntry(et, ik)], ik)
2025
2006
 
                }
2026
2007
 
        }
2027
2008
 
2028
2009
 
2029
2010
 
2030
-
@Callable(du)
2031
-
func fixWarehouseFormat (az) = if ((du.caller != bF))
2011
+
@Callable(ds)
2012
+
func fixWarehouseFormat (ay) = if ((ds.caller != bu))
2032
2013
 
    then throw("Access denied")
2033
2014
 
    else {
2034
-
        let ew = ay(az)
2035
-
        let ga = value(assetInfo(fromBase58String(az)))
2036
-
        let ex = (bW(split(ga.description, "_")[bL]) / bm)
2037
-
        let ey = valueOrElse(getInteger(as(az)), 0)
2038
-
        let eB = ev(ew, ex, ey)
2039
-
        let il = bU(invoke(bH, "recalcLockedVolumeREADONLY", [az, eB], nil))
2040
-
        let gq = eh(eB)
2041
-
        let im = ef(eB[Y])
2042
-
        let gr = ((im - il) - gq)
2043
-
        let in = makeString_2C([eB[Y], eB[Z], eB[aa], eB[ab], makeString([toString(il), toString(gq), toString(gr), toString(im)], "_")], ":")
2044
-
        $Tuple2([StringEntry(ew, in)], in)
2015
+
        let et = ax(ay)
2016
+
        let fY = value(assetInfo(fromBase58String(ay)))
2017
+
        let eu = (bL(split(fY.description, "_")[bA]) / bb)
2018
+
        let ev = valueOrElse(getInteger(ar(ay)), 0)
2019
+
        let ey = es(et, eu, ev)
2020
+
        let ii = bJ(invoke(bw, "recalcLockedVolumeREADONLY", [ay, ey], nil))
2021
+
        let go = ef(ey)
2022
+
        let ij = ed(ey[Z])
2023
+
        let gp = ((ij - ii) - go)
2024
+
        let ik = makeString_2C([ey[Z], ey[aa], ey[ab], ey[ac], makeString([toString(ii), toString(go), toString(gp), toString(ij)], "_")], ":")
2025
+
        $Tuple2([StringEntry(et, ik)], ik)
2045
2026
 
        }
2046
2027
 
2047
2028
 
2048
2029
 
2049
-
@Callable(du)
2050
-
func fixStakedPieces (bs) = if ((du.caller != bF))
2030
+
@Callable(ds)
2031
+
func fixStakedPieces (bh) = if ((ds.caller != bu))
2051
2032
 
    then throw("Access denied")
2052
2033
 
    else {
2053
-
        let hp = if ((bs == ""))
2034
+
        let hn = if ((bh == ""))
2054
2035
 
            then 0
2055
2036
 
            else {
2056
-
                let hk = getString(bG, bP(bs))
2057
-
                let hf = if (isDefined(hk))
2058
-
                    then split_51C(value(hk), "_")
2037
+
                let hi = getString(bv, bE(bh))
2038
+
                let hd = if (isDefined(hi))
2039
+
                    then split_51C(value(hi), "_")
2059
2040
 
                    else nil
2060
-
                func io (cO,az) =                 {
2061
-
                    let ga = value(assetInfo(fromBase58String(az)))
2062
-
                    let bX = split(ga.description, "_")[bL]
2063
-
                    (cO + bW(bX))
2041
+
                func il (cD,ay) =                 {
2042
+
                    let fY = value(assetInfo(fromBase58String(ay)))
2043
+
                    let bM = split(fY.description, "_")[bA]
2044
+
                    (cD + bL(bM))
2064
2045
 
                    }
2065
2046
 
2066
-
                let aW = hf
2067
-
                let aX = size(aW)
2068
-
                let aY = 0
2069
-
                func aZ (ba,bb) =                 if ((bb >= aX))
2070
-
                    then ba
2071
-
                    else io(ba, aW[bb])
2072
-
2073
-
                func bc (ba,bb) =                 if ((bb >= aX))
2074
-
                    then ba
2047
+
                let cF = hd
2048
+
                let cG = size(cF)
2049
+
                let cH = 0
2050
+
                func cI (cJ,cK) =                 if ((cK >= cG))
2051
+
                    then cJ
2052
+
                    else il(cJ, cF[cK])
2053
+
2054
+
                func cL (cJ,cK) =                 if ((cK >= cG))
2055
+
                    then cJ
2075
2056
 
                    else throw("List size exceeds 100")
2076
2057
 
2077
-
                bc(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aY, 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)
2058
+
                cL(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cI(cH, 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)
2078
2059
 
                }
2079
-
        $Tuple2([IntegerEntry(bQ(bs), hp)], hp)
2060
+
        $Tuple2([IntegerEntry(bF(bh), hn)], hn)
2080
2061
 
        }
2081
2062
 
2082
2063
 
2083
2064
 
2084
-
@Callable(du)
2085
-
func setCustomName (ap,hh,au) = {
2086
-
    let hz = hw(du)
2087
-
    if ((size(du.payments) != 1))
2065
+
@Callable(ds)
2066
+
func setCustomName (ao,hf,at) = {
2067
+
    let hx = hu(ds)
2068
+
    if ((size(ds.payments) != 1))
2088
2069
 
        then throw("Exactly one payment required")
2089
2070
 
        else {
2090
-
            let hA = value(du.payments[0])
2091
-
            if ((hA.assetId != bf))
2071
+
            let hy = value(ds.payments[0])
2072
+
            if ((hy.assetId != aU))
2092
2073
 
                then throw("Allowed USDT payment only!")
2093
-
                else if ((hA.amount != cd))
2094
-
                    then throw(("Payment should be " + toString(cd)))
2095
-
                    else if (contains(hh, "__"))
2096
-
                        then throw(("Name should not contain '__': " + hh))
2097
-
                        else if ((size(hh) > ce))
2098
-
                            then throw(("Name too long, maxLength=" + toString(ce)))
2074
+
                else if ((hy.amount != bS))
2075
+
                    then throw(("Payment should be " + toString(bS)))
2076
+
                    else if (contains(hf, "__"))
2077
+
                        then throw(("Name should not contain '__': " + hf))
2078
+
                        else if ((size(hf) > bT))
2079
+
                            then throw(("Name too long, maxLength=" + toString(bT)))
2099
2080
 
                            else {
2100
-
                                let p = toString(du.originCaller)
2101
-
                                let ip = {
2102
-
                                    let bg = au
2103
-
                                    if (("ACCOUNT" == bg))
2081
+
                                let p = toString(ds.originCaller)
2082
+
                                let im = {
2083
+
                                    let aV = at
2084
+
                                    if (("ACCOUNT" == aV))
2104
2085
 
                                        then {
2105
-
                                            let iq = cy(hh)
2106
-
                                            let ir = getString(iq)
2107
-
                                            if (isDefined(ir))
2108
-
                                                then throw(("Name already registered: " + hh))
2086
+
                                            let in = cn(hf)
2087
+
                                            let io = getString(in)
2088
+
                                            if (isDefined(io))
2089
+
                                                then throw(("Name already registered: " + hf))
2109
2090
 
                                                else {
2110
-
                                                    let is = aB(p)
2111
-
                                                    let it = getString(is)
2112
-
                                                    let iu = if (isDefined(it))
2113
-
                                                        then [DeleteEntry(cy(value(it)))]
2091
+
                                                    let ip = aA(p)
2092
+
                                                    let iq = getString(ip)
2093
+
                                                    let ir = if (isDefined(iq))
2094
+
                                                        then [DeleteEntry(cn(value(iq)))]
2114
2095
 
                                                        else nil
2115
-
                                                    (((iu :+ StringEntry(is, hh)) :+ StringEntry(iq, p)) ++ gL(p, w)._1)
2096
+
                                                    (((ir :+ StringEntry(ip, hf)) :+ StringEntry(in, p)) ++ gJ(p, w)._1)
2116
2097
 
                                                    }
2117
2098
 
                                            }
2118
-
                                        else if (("LAND" == bg))
2099
+
                                        else if (("LAND" == aV))
2119
2100
 
                                            then {
2120
-
                                                let ga = value(assetInfo(fromBase58String(ap)))
2121
-
                                                let gb = ar(ap)
2122
-
                                                if (!(isDefined(getInteger(gb))))
2123
-
                                                    then throw((ga.name + " is not staked"))
2101
+
                                                let fY = value(assetInfo(fromBase58String(ao)))
2102
+
                                                let fZ = aq(ao)
2103
+
                                                if (!(isDefined(getInteger(fZ))))
2104
+
                                                    then throw((fY.name + " is not staked"))
2124
2105
 
                                                    else {
2125
-
                                                        let gd = valueOrErrorMessage(getString(ao(ap)), (("NFT " + ga.name) + " is orphaned"))
2126
-
                                                        if ((gd != p))
2106
+
                                                        let gb = valueOrErrorMessage(getString(an(ao)), (("NFT " + fY.name) + " is orphaned"))
2107
+
                                                        if ((gb != p))
2127
2108
 
                                                            then throw((K + " is not yours"))
2128
2109
 
                                                            else {
2129
-
                                                                let iq = cs(hh)
2130
-
                                                                let ir = getString(iq)
2131
-
                                                                if (isDefined(ir))
2132
-
                                                                    then throw(("Name already registered: " + hh))
2110
+
                                                                let in = ch(hf)
2111
+
                                                                let io = getString(in)
2112
+
                                                                if (isDefined(io))
2113
+
                                                                    then throw(("Name already registered: " + hf))
2133
2114
 
                                                                    else {
2134
-
                                                                        let iv = aq(ap)
2135
-
                                                                        let it = getString(iv)
2136
-
                                                                        let iu = if (isDefined(it))
2137
-
                                                                            then [DeleteEntry(cs(value(it)))]
2115
+
                                                                        let is = ap(ao)
2116
+
                                                                        let iq = getString(is)
2117
+
                                                                        let ir = if (isDefined(iq))
2118
+
                                                                            then [DeleteEntry(ch(value(iq)))]
2138
2119
 
                                                                            else nil
2139
-
                                                                        (((iu :+ StringEntry(iv, hh)) :+ StringEntry(iq, ap)) ++ gL(p, w)._1)
2120
+
                                                                        (((ir :+ StringEntry(is, hf)) :+ StringEntry(in, ao)) ++ gJ(p, w)._1)
2140
2121
 
                                                                        }
2141
2122
 
                                                                }
2142
2123
 
                                                        }
2143
2124
 
                                                }
2144
-
                                            else if (("DUCK" == bg))
2125
+
                                            else if (("DUCK" == aV))
2145
2126
 
                                                then {
2146
-
                                                    let ga = value(assetInfo(fromBase58String(ap)))
2147
-
                                                    let gb = ar(ap)
2148
-
                                                    if (if (!(isDefined(getInteger(gb))))
2127
+
                                                    let fY = value(assetInfo(fromBase58String(ao)))
2128
+
                                                    let fZ = aq(ao)
2129
+
                                                    if (if (!(isDefined(getInteger(fZ))))
2149
2130
 
                                                        then true
2150
-
                                                        else !(isDefined(getString(aH(p)))))
2151
-
                                                        then throw((ga.name + " is not staked"))
2131
+
                                                        else !(isDefined(getString(aG(p)))))
2132
+
                                                        then throw((fY.name + " is not staked"))
2152
2133
 
                                                        else {
2153
-
                                                            let gd = valueOrErrorMessage(getString(aG(ap)), (("NFT " + ga.name) + " is orphaned"))
2154
-
                                                            if ((gd != p))
2134
+
                                                            let gb = valueOrErrorMessage(getString(aF(ao)), (("NFT " + fY.name) + " is orphaned"))
2135
+
                                                            if ((gb != p))
2155
2136
 
                                                                then throw((L + " is not yours"))
2156
2137
 
                                                                else {
2157
-
                                                                    let iq = cx(hh)
2158
-
                                                                    let ir = getString(iq)
2159
-
                                                                    if (isDefined(ir))
2160
-
                                                                        then throw(("Name already registered: " + hh))
2138
+
                                                                    let in = cm(hf)
2139
+
                                                                    let io = getString(in)
2140
+
                                                                    if (isDefined(io))
2141
+
                                                                        then throw(("Name already registered: " + hf))
2161
2142
 
                                                                        else {
2162
-
                                                                            let iv = aA(ap)
2163
-
                                                                            let it = getString(iv)
2164
-
                                                                            let iu = if (isDefined(it))
2165
-
                                                                                then [DeleteEntry(cx(value(it)))]
2143
+
                                                                            let is = az(ao)
2144
+
                                                                            let iq = getString(is)
2145
+
                                                                            let ir = if (isDefined(iq))
2146
+
                                                                                then [DeleteEntry(cm(value(iq)))]
2166
2147
 
                                                                                else nil
2167
-
                                                                            (((iu :+ StringEntry(iv, hh)) :+ StringEntry(iq, ap)) ++ gF(ap, w)._1)
2148
+
                                                                            (((ir :+ StringEntry(is, hf)) :+ StringEntry(in, ao)) ++ gD(ao, w)._1)
2168
2149
 
                                                                            }
2169
2150
 
                                                                    }
2170
2151
 
                                                            }
2171
2152
 
                                                    }
2172
2153
 
                                                else throw("Unknown entity type")
2173
2154
 
                                    }
2174
-
                                $Tuple2(((ip :+ ScriptTransfer(bH, hA.amount, bf)) :+ hz), 0)
2155
+
                                $Tuple2(((im :+ ScriptTransfer(bw, hy.amount, aU)) :+ hx), 0)
2175
2156
 
                                }
2176
2157
 
            }
2177
2158
 
    }
2178
2159
 
2179
2160
 
2180
2161
 
2181
-
@Callable(du)
2182
-
func setReferrals (iw,ix) = if ((du.callerPublicKey != ca))
2162
+
@Callable(ds)
2163
+
func setReferrals (it,iu) = if ((ds.callerPublicKey != bP))
2183
2164
 
    then throw("Permission denied")
2184
2165
 
    else {
2185
-
        let hz = hw(du)
2186
-
        if ((size(du.payments) != 0))
2166
+
        let hx = hu(ds)
2167
+
        if ((size(ds.payments) != 0))
2187
2168
 
            then throw("No payments required")
2188
-
            else if (!(isDefined(addressFromString(iw))))
2189
-
                then throw(("Invalid address: " + iw))
2190
-
                else if (!(isDefined(addressFromString(ix))))
2191
-
                    then throw(("Invalid address: " + ix))
2169
+
            else if (!(isDefined(addressFromString(it))))
2170
+
                then throw(("Invalid address: " + it))
2171
+
                else if (!(isDefined(addressFromString(iu))))
2172
+
                    then throw(("Invalid address: " + iu))
2192
2173
 
                    else {
2193
-
                        let iy = cz()
2194
-
                        let iz = getString(iy)
2195
-
                        let iA = if (isDefined(iz))
2196
-
                            then split_4C(value(iz), "_")
2174
+
                        let iv = co()
2175
+
                        let iw = getString(iv)
2176
+
                        let ix = if (isDefined(iw))
2177
+
                            then split_4C(value(iw), "_")
2197
2178
 
                            else nil
2198
-
                        if (containsElement(iA, ix))
2199
-
                            then throw((ix + " is not newbie (already has referrals)"))
2179
+
                        if (containsElement(ix, iu))
2180
+
                            then throw((iu + " is not newbie (already has referrals)"))
2200
2181
 
                            else {
2201
-
                                let gN = aC(ix)
2202
-
                                let gO = getString(gN)
2203
-
                                if (if (isDefined(gO))
2204
-
                                    then isDefined(addressFromString(value(gO)))
2182
+
                                let gL = aB(iu)
2183
+
                                let gM = getString(gL)
2184
+
                                if (if (isDefined(gM))
2185
+
                                    then isDefined(addressFromString(value(gM)))
2205
2186
 
                                    else false)
2206
-
                                    then throw(((ix + " already has refBy: ") + value(gO)))
2187
+
                                    then throw(((iu + " already has refBy: ") + value(gM)))
2207
2188
 
                                    else {
2208
-
                                        let iB = aF(iw)
2209
-
                                        let iC = getString(iB)
2210
-
                                        let iD = if (isDefined(iC))
2211
-
                                            then split_4C(value(iC), "_")
2189
+
                                        let iy = aE(it)
2190
+
                                        let iz = getString(iy)
2191
+
                                        let iA = if (isDefined(iz))
2192
+
                                            then split_4C(value(iz), "_")
2212
2193
 
                                            else nil
2213
-
                                        if (containsElement(iD, ix))
2214
-
                                            then throw((((iw + " already contains ") + ix) + " within referrals"))
2194
+
                                        if (containsElement(iA, iu))
2195
+
                                            then throw((((it + " already contains ") + iu) + " within referrals"))
2215
2196
 
                                            else {
2216
-
                                                let iE = makeString_2C((iD :+ ix), "_")
2217
-
                                                let iF = if (containsElement(iA, iw))
2218
-
                                                    then value(iz)
2219
-
                                                    else makeString_2C((iA :+ iw), "_")
2220
-
                                                $Tuple2([StringEntry(gN, iw), StringEntry(iB, iE), StringEntry(iy, iF), hz], 0)
2197
+
                                                let iB = makeString_2C((iA :+ iu), "_")
2198
+
                                                let iC = if (containsElement(ix, it))
2199
+
                                                    then value(iw)
2200
+
                                                    else makeString_2C((ix :+ it), "_")
2201
+
                                                $Tuple2([StringEntry(gL, it), StringEntry(iy, iB), StringEntry(iv, iC), hx], 0)
2221
2202
 
                                                }
2222
2203
 
                                        }
2223
2204
 
                                }
2224
2205
 
                        }
2225
2206
 
        }
2226
2207
 
2227
2208
 
2228
2209
 
2229
-
@Callable(du)
2230
-
func distributePoints (iG,iH,iI,iJ,iK) = {
2231
-
    let hz = hw(du)
2232
-
    if ((size(du.payments) != 0))
2210
+
@Callable(ds)
2211
+
func distributePoints (iD,iE,iF,iG,iH) = {
2212
+
    let hx = hu(ds)
2213
+
    if ((size(ds.payments) != 0))
2233
2214
 
        then throw("No payments required")
2234
2215
 
        else {
2235
-
            let p = toString(du.originCaller)
2236
-
            let k = valueOrErrorMessage(getString(aH(p)), "You don't have a duck staked")
2237
-
            let iL = r(p)
2238
-
            let iM = valueOrElse(getInteger(bG, iL), 0)
2239
-
            let iN = n(k)
2240
-
            let iO = valueOrElse(getInteger(bG, iN), 0)
2241
-
            let iP = (iM + iO)
2242
-
            let iQ = ((((iG + iH) + iI) + iJ) + iK)
2243
-
            if ((iQ > iP))
2244
-
                then throw((("There are only " + toString(iP)) + " free points to distribute"))
2216
+
            let p = toString(ds.originCaller)
2217
+
            let k = valueOrErrorMessage(getString(aG(p)), "You don't have a duck staked")
2218
+
            let iI = r(p)
2219
+
            let iJ = valueOrElse(getInteger(bv, iI), 0)
2220
+
            let iK = n(k)
2221
+
            let iL = valueOrElse(getInteger(bv, iK), 0)
2222
+
            let iM = (iJ + iL)
2223
+
            let iN = ((((iD + iE) + iF) + iG) + iH)
2224
+
            if ((iN > iM))
2225
+
                then throw((("There are only " + toString(iM)) + " free points to distribute"))
2245
2226
 
                else {
2246
-
                    let iR = j(k)
2247
-
                    let iS = split(valueOrElse(getString(bG, iR), "0_0_0_0_0"), "_")
2248
-
                    let iT = (iM - iQ)
2249
-
                    $Tuple2([IntegerEntry(iL, if ((0 > iT))
2227
+
                    let iO = j(k)
2228
+
                    let iP = split(valueOrElse(getString(bv, iO), "0_0_0_0_0"), "_")
2229
+
                    let iQ = (iJ - iN)
2230
+
                    $Tuple2([IntegerEntry(iI, if ((0 > iQ))
2250
2231
 
                        then 0
2251
-
                        else iT), IntegerEntry(iN, if ((0 > iT))
2252
-
                        then (iO + iT)
2253
-
                        else iO), StringEntry(iR, makeString([toString((parseIntValue(iS[e]) + iG)), toString((parseIntValue(iS[f]) + iH)), toString((parseIntValue(iS[g]) + iI)), toString((parseIntValue(iS[h]) + iJ)), toString((parseIntValue(iS[i]) + iK))], "_")), hz], 0)
2232
+
                        else iQ), IntegerEntry(iK, if ((0 > iQ))
2233
+
                        then (iL + iQ)
2234
+
                        else iL), StringEntry(iO, makeString([toString((parseIntValue(iP[e]) + iD)), toString((parseIntValue(iP[f]) + iE)), toString((parseIntValue(iP[g]) + iF)), toString((parseIntValue(iP[h]) + iG)), toString((parseIntValue(iP[i]) + iH))], "_")), hx], 0)
2254
2235
 
                    }
2255
2236
 
            }
2256
2237
 
    }
2257
2238
 
2258
2239
 
2259
2240
 
2260
-
@Callable(du)
2261
-
func splitByGlobalWeightsREADONLY (eL) = $Tuple2(nil, cQ(eL))
2262
-
2263
-
2264
-
2265
-
@Callable(du)
2266
-
func splitByGlobalAndLocalWeightsREADONLY (iU,iV,dx) = {
2267
-
    let dq = dw(dx)
2268
-
    $Tuple2(nil, $Tuple2(cQ(iU), cI(iV, dq)))
2269
-
    }
2270
-
2271
-
2272
-
2273
-
@Callable(du)
2274
-
func getBackpackREADONLY (k) = $Tuple2(nil, makeString(ec(aI(k)), ":"))
2275
-
2276
-
2277
-
2278
-
@Callable(du)
2279
-
func getWarehouseREADONLY (az) = {
2280
-
    let ga = value(assetInfo(fromBase58String(az)))
2281
-
    let ex = (bW(split(ga.description, "_")[bL]) / bm)
2282
-
    let ey = valueOrElse(getInteger(as(az)), 0)
2283
-
    $Tuple2(nil, makeString_2C(ev(ay(az), ex, ey), ":"))
2284
-
    }
2285
-
2286
-
2287
-
2288
-
@Callable(du)
2289
-
func saveLastTx () = if (if ((du.caller != bJ))
2290
-
    then (du.caller != bH)
2241
+
@Callable(ds)
2242
+
func splitByGlobalWeightsREADONLY (eI) = $Tuple2(nil, cM(eI))
2243
+
2244
+
2245
+
2246
+
@Callable(ds)
2247
+
func splitByGlobalAndLocalWeightsREADONLY (iR,iS,dv) = {
2248
+
    let do = du(dv)
2249
+
    $Tuple2(nil, $Tuple2(cM(iR), cx(iS, do)))
2250
+
    }
2251
+
2252
+
2253
+
2254
+
@Callable(ds)
2255
+
func getBackpackREADONLY (k) = $Tuple2(nil, makeString(ea(aH(k)), ":"))
2256
+
2257
+
2258
+
2259
+
@Callable(ds)
2260
+
func getWarehouseREADONLY (ay) = {
2261
+
    let fY = value(assetInfo(fromBase58String(ay)))
2262
+
    let eu = (bL(split(fY.description, "_")[bA]) / bb)
2263
+
    let ev = valueOrElse(getInteger(ar(ay)), 0)
2264
+
    $Tuple2(nil, makeString_2C(es(ax(ay), eu, ev), ":"))
2265
+
    }
2266
+
2267
+
2268
+
2269
+
@Callable(ds)
2270
+
func saveLastTx () = if (if ((ds.caller != by))
2271
+
    then (ds.caller != bw)
2291
2272
 
    else false)
2292
2273
 
    then throw("Access denied")
2293
-
    else $Tuple2([hw(du)], 42)
2294
-
2295
-
2296
-
2297
-
@Callable(du)
2298
-
func updateDuckStats (k,gG) = if ((du.caller != bH))
2274
+
    else $Tuple2([hu(ds)], 42)
2275
+
2276
+
2277
+
2278
+
@Callable(ds)
2279
+
func updateDuckStats (k,gE) = if ((ds.caller != bw))
2299
2280
 
    then throw("Access denied")
2300
-
    else gF(k, gG)
2301
-
2302
-
2303
-
2304
-
@Callable(du)
2305
-
func updateAccStats (p,gG) = if ((du.caller != bH))
2281
+
    else gD(k, gE)
2282
+
2283
+
2284
+
2285
+
@Callable(ds)
2286
+
func updateAccStats (p,gE) = if ((ds.caller != bw))
2306
2287
 
    then throw("Access denied")
2307
-
    else gL(p, gG)
2288
+
    else gJ(p, gE)
2308
2289
 
2309
2290