tx · 8BENUk94WpFzrQhVYuLUhbpv5h6H2QbyVHyZJ5ksweqH

3Mp3nG9T5fKGziHW8mcCqx3jMFx3towh3WA:  -0.02400000 Waves

2022.06.30 11:28 [2118929] smart account 3Mp3nG9T5fKGziHW8mcCqx3jMFx3towh3WA > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "8BENUk94WpFzrQhVYuLUhbpv5h6H2QbyVHyZJ5ksweqH",
    "fee": 2400000,
    "feeAssetId": null,
    "timestamp": 1656577772920,
    "version": 2,
    "chainId": 84,
    "sender": "3Mp3nG9T5fKGziHW8mcCqx3jMFx3towh3WA",
    "senderPublicKey": "D46gQxzmdzdCTYRg6dMcwFoUrc6ZmxF6GKd5ZoTkvzp1",
    "proofs": [
        "3HqEtAynZZtTXimHqfe5VUgPMgbfdvBsShCPSh1gmSFSCRUz3fecoFqm4eTqTTEfZLFNAaxQANc1VCjvHBmndZ5r"
    ],
    "script": "base64:BgJbCAISAwoBCBIAEgQKAggBEgcKBQgICAgBEgQKAggIEgUKAwgIARIECgIICBIDCgEBEgMKAQESBAoCCAgSAwoBCBIAEgMKAQESABIECgIICBIECgIICBIECgIICDEACXNlcGFyYXRvcgICX18ADnBvb2xXZWlnaHRNdWx0AIDC1y8AD21heERlcHRoRGVmYXVsdAAKABZmaW5hbGl6YXRpb25TdGFnZVRvdGFsAAAAF2ZpbmFsaXphdGlvblN0YWdlU2hhcmVzAAEADmtleUVwb2NoTGVuZ3RoCQC5CQIJAMwIAgICJXMJAMwIAgILZXBvY2hMZW5ndGgFA25pbAUJc2VwYXJhdG9yAA9rZXlDdXJyZW50RXBvY2gJALkJAgkAzAgCAgIlcwkAzAgCAgxjdXJyZW50RXBvY2gFA25pbAUJc2VwYXJhdG9yAAtrZXlNYXhEZXB0aAkAuQkCCQDMCAICAiVzCQDMCAICCG1heERlcHRoBQNuaWwFCXNlcGFyYXRvcgAia2V5Vm90aW5nRW1pc3Npb25DYW5kaWRhdGVDb250cmFjdAkAuQkCCQDMCAICAiVzCQDMCAICH3ZvdGluZ0VtaXNzaW9uQ2FuZGlkYXRlQ29udHJhY3QFA25pbAUJc2VwYXJhdG9yABJrZXlGYWN0b3J5Q29udHJhY3QJALkJAgkAzAgCAgIlcwkAzAgCAg9mYWN0b3J5Q29udHJhY3QFA25pbAUJc2VwYXJhdG9yABNrZXlCb29zdGluZ0NvbnRyYWN0CQC5CQIJAMwIAgICJXMJAMwIAgIQYm9vc3RpbmdDb250cmFjdAUDbmlsBQlzZXBhcmF0b3IAEmtleVN0YWtpbmdDb250cmFjdAkAuQkCCQDMCAICAiVzCQDMCAICD3N0YWtpbmdDb250cmFjdAUDbmlsBQlzZXBhcmF0b3IAFGtleUZpbmFsaXphdGlvblN0YWdlCQC5CQIJAMwIAgICJXMJAMwIAgIRZmluYWxpemF0aW9uU3RhZ2UFA25pbAUJc2VwYXJhdG9yAAtrZXlOZXh0UG9vbAkAuQkCCQDMCAICAiVzCQDMCAICCG5leHRQb29sBQNuaWwFCXNlcGFyYXRvcgALa2V5TmV4dFVzZXIJALkJAgkAzAgCAgIlcwkAzAgCAghuZXh0VXNlcgUDbmlsBQlzZXBhcmF0b3IADmtleVN0YXJ0SGVpZ2h0CQC5CQIJAMwIAgICJXMJAMwIAgILc3RhcnRIZWlnaHQFA25pbAUJc2VwYXJhdG9yABFrZXlDdXJyZW50RXBvY2hVaQkAuQkCCQDMCAICAiVzCQDMCAICDmN1cnJlbnRFcG9jaFVpBQNuaWwFCXNlcGFyYXRvcgAQa2V5U3RhcnRIZWlnaHRVaQkAuQkCCQDMCAICAiVzCQDMCAICDXN0YXJ0SGVpZ2h0VWkFA25pbAUJc2VwYXJhdG9yARVrZXlTdGFydEhlaWdodEJ5RXBvY2gBBWVwb2NoCQC5CQIJAMwIAgIEJXMlZAkAzAgCAgtzdGFydEhlaWdodAkAzAgCCQCkAwEFBWVwb2NoBQNuaWwFCXNlcGFyYXRvcgEMa2V5RmluYWxpemVkAQVlcG9jaAkAuQkCCQDMCAICBCVzJWQJAMwIAgIJZmluYWxpemVkCQDMCAIJAKQDAQUFZXBvY2gFA25pbAUJc2VwYXJhdG9yAQlrZXlJbkxpc3QBBHBvb2wECyR0MDE0MzYxNDc2BQRwb29sBA1hbW91bnRBc3NldElkCAULJHQwMTQzNjE0NzYCXzEEDHByaWNlQXNzZXRJZAgFCyR0MDE0MzYxNDc2Al8yCQC5CQIJAMwIAgIGJXMlcyVzCQDMCAICBmluTGlzdAkAzAgCBQ1hbW91bnRBc3NldElkCQDMCAIFDHByaWNlQXNzZXRJZAUDbmlsBQlzZXBhcmF0b3IBB2tleVVzZWQCB2FkZHJlc3MFZXBvY2gJALkJAgkAzAgCAgYlcyVzJWQJAMwIAgIEdXNlZAkAzAgCCQClCAEFB2FkZHJlc3MJAMwIAgkApAMBBQVlcG9jaAUDbmlsBQlzZXBhcmF0b3IBB2tleVZvdGUDBHBvb2wHYWRkcmVzcwVlcG9jaAQLJHQwMTc1MDE3OTAFBHBvb2wEDWFtb3VudEFzc2V0SWQIBQskdDAxNzUwMTc5MAJfMQQMcHJpY2VBc3NldElkCAULJHQwMTc1MDE3OTACXzIJALkJAgkAzAgCAgolcyVzJXMlcyVkCQDMCAICBHZvdGUJAMwIAgUNYW1vdW50QXNzZXRJZAkAzAgCBQxwcmljZUFzc2V0SWQJAMwIAgkApQgBBQdhZGRyZXNzCQDMCAIJAKQDAQUFZXBvY2gFA25pbAUJc2VwYXJhdG9yAQ9rZXlWb3RpbmdSZXN1bHQCBHBvb2wFZXBvY2gECyR0MDE5NzIyMDEyBQRwb29sBA1hbW91bnRBc3NldElkCAULJHQwMTk3MjIwMTICXzEEDHByaWNlQXNzZXRJZAgFCyR0MDE5NzIyMDEyAl8yCQC5CQIJAMwIAgIIJXMlcyVzJWQJAMwIAgIMdm90aW5nUmVzdWx0CQDMCAIFDWFtb3VudEFzc2V0SWQJAMwIAgUMcHJpY2VBc3NldElkCQDMCAIJAKQDAQUFZXBvY2gFA25pbAUJc2VwYXJhdG9yAQxrZXlQb29sU2hhcmUCBHBvb2wFZXBvY2gECyR0MDIxNzcyMjE3BQRwb29sBA1hbW91bnRBc3NldElkCAULJHQwMjE3NzIyMTcCXzEEDHByaWNlQXNzZXRJZAgFCyR0MDIxNzcyMjE3Al8yCQC5CQIJAMwIAgIIJXMlcyVzJWQJAMwIAgIJcG9vbFNoYXJlCQDMCAIFDWFtb3VudEFzc2V0SWQJAMwIAgUMcHJpY2VBc3NldElkCQDMCAIJAKQDAQUFZXBvY2gFA25pbAUJc2VwYXJhdG9yAQ1rZXlUb3RhbFZvdGVzAQVlcG9jaAkAuQkCCQDMCAICBCVzJWQJAMwIAgIKdG90YWxWb3RlcwkAzAgCCQCkAwEFBWVwb2NoBQNuaWwFCXNlcGFyYXRvcgEOZ2V0VmFsdWVPckZhaWwDB2FkZHJlc3MDa2V5BHR5cGUEBWVycm9yCQC5CQIJAMwIAgIKbWFuZGF0b3J5IAkAzAgCCQClCAEFB2FkZHJlc3MJAMwIAgIBLgkAzAgCBQNrZXkJAMwIAgIPIGlzIG5vdCBkZWZpbmVkBQNuaWwCAAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCBAckbWF0Y2gwBQR0eXBlAwkAAQIFByRtYXRjaDACBlN0cmluZwQDc3RyBQckbWF0Y2gwCQCdCAIFB2FkZHJlc3MFA2tleQMJAAECBQckbWF0Y2gwAgNJbnQEA2ludAUHJG1hdGNoMAkAmggCBQdhZGRyZXNzBQNrZXkJAAIBAhJpbnZhbGlkIGVudHJ5IHR5cGUFBWVycm9yAQxnZXRTdHJPckZhaWwCB2FkZHJlc3MDa2V5CgABQAkBDmdldFZhbHVlT3JGYWlsAwUHYWRkcmVzcwUDa2V5AgADCQABAgUBQAIGU3RyaW5nBQFACQACAQkArAICCQADAQkBDmdldFZhbHVlT3JGYWlsAwUHYWRkcmVzcwUDa2V5AgACGyBjb3VsZG4ndCBiZSBjYXN0IHRvIFN0cmluZwEMZ2V0SW50T3JGYWlsAgdhZGRyZXNzA2tleQoAAUAJAQ5nZXRWYWx1ZU9yRmFpbAMFB2FkZHJlc3MFA2tleQAAAwkAAQIFAUACA0ludAUBQAkAAgEJAKwCAgkAAwEJAQ5nZXRWYWx1ZU9yRmFpbAMFB2FkZHJlc3MFA2tleQAAAhggY291bGRuJ3QgYmUgY2FzdCB0byBJbnQBDHBvb2xUb1N0cmluZwEEcG9vbAkArAICCQCsAgIIBQRwb29sAl8xBQlzZXBhcmF0b3IIBQRwb29sAl8yAQxzdHJpbmdUb1Bvb2wBA3N0cgQFcGFydHMJALUJAgUDc3RyBQlzZXBhcmF0b3IDCQAAAgkAkAMBBQVwYXJ0cwACCQCUCgIJAJEDAgUFcGFydHMAAAkAkQMCBQVwYXJ0cwABCQACAQITaW52YWxpZCBwb29sIHN0cmluZwEWZ2V0THBBc3NldEJ5UG9vbEFzc2V0cwINYW1vdW50QXNzZXRJZAxwcmljZUFzc2V0SWQKAR9rZXlNYXBwaW5nc0Jhc2VBc3NldDJpbnRlcm5hbElkAQxiYXNlQXNzZXRTdHIJAKwCAgIoJXMlcyVzX19tYXBwaW5nc19fYmFzZUFzc2V0MmludGVybmFsSWRfXwUMYmFzZUFzc2V0U3RyCgEpa2V5TWFwcGluZ1Bvb2xBc3NldHNUb1Bvb2xDb250cmFjdEFkZHJlc3MCGGludGVybmFsQW1vdW50QXNzZXRJZFN0chdpbnRlcm5hbFByaWNlQXNzZXRJZFN0cgkArAICCQCsAgIJAKwCAgkArAICAgolZCVkJXMlc19fCQCkAwEFGGludGVybmFsQW1vdW50QXNzZXRJZFN0cgICX18JAKQDAQUXaW50ZXJuYWxQcmljZUFzc2V0SWRTdHICI19fbWFwcGluZ3NfX3Bvb2xBc3NldHMyUG9vbENvbnRyYWN0CgEfa2V5TWFwcGluZ1Bvb2xDb250cmFjdFRvTFBBc3NldAETcG9vbENvbnRyYWN0QWRkcmVzcwkArAICCQCsAgICCCVzJXMlc19fBRNwb29sQ29udHJhY3RBZGRyZXNzAiBfX21hcHBpbmdzX19wb29sQ29udHJhY3QyTHBBc3NldAQPZmFjdG9yeUNvbnRyYWN0CQERQGV4dHJOYXRpdmUoMTA2MikBCQEMZ2V0U3RyT3JGYWlsAgUEdGhpcwUSa2V5RmFjdG9yeUNvbnRyYWN0BBVhbW91bnRBc3NldEludGVybmFsSWQJAQxnZXRJbnRPckZhaWwCBQ9mYWN0b3J5Q29udHJhY3QJAR9rZXlNYXBwaW5nc0Jhc2VBc3NldDJpbnRlcm5hbElkAQUNYW1vdW50QXNzZXRJZAQUcHJpY2VBc3NldEludGVybmFsSWQJAQxnZXRJbnRPckZhaWwCBQ9mYWN0b3J5Q29udHJhY3QJAR9rZXlNYXBwaW5nc0Jhc2VBc3NldDJpbnRlcm5hbElkAQUMcHJpY2VBc3NldElkBBNwb29sQ29udHJhY3RBZGRyZXNzCQEMZ2V0U3RyT3JGYWlsAgUPZmFjdG9yeUNvbnRyYWN0CQEpa2V5TWFwcGluZ1Bvb2xBc3NldHNUb1Bvb2xDb250cmFjdEFkZHJlc3MCBRVhbW91bnRBc3NldEludGVybmFsSWQFFHByaWNlQXNzZXRJbnRlcm5hbElkBAlscEFzc2V0SWQJAQxnZXRTdHJPckZhaWwCBQ9mYWN0b3J5Q29udHJhY3QJAR9rZXlNYXBwaW5nUG9vbENvbnRyYWN0VG9MUEFzc2V0AQUTcG9vbENvbnRyYWN0QWRkcmVzcwUJbHBBc3NldElkARhjaGVja1d4RW1pc3Npb25Qb29sTGFiZWwBBHBvb2wECyR0MDQ0NTk0NDk5BQRwb29sBA1hbW91bnRBc3NldElkCAULJHQwNDQ1OTQ0OTkCXzEEDHByaWNlQXNzZXRJZAgFCyR0MDQ0NTk0NDk5Al8yBA9mYWN0b3J5Q29udHJhY3QJARFAZXh0ck5hdGl2ZSgxMDYyKQEJAQxnZXRTdHJPckZhaWwCBQR0aGlzBRJrZXlGYWN0b3J5Q29udHJhY3QKAAFACQD8BwQFD2ZhY3RvcnlDb250cmFjdAIYY2hlY2tXeEVtaXNzaW9uUG9vbExhYmVsCQDMCAIFDWFtb3VudEFzc2V0SWQJAMwIAgUMcHJpY2VBc3NldElkBQNuaWwFA25pbAMJAAECBQFAAgdCb29sZWFuBQFACQACAQkArAICCQADAQkA/AcEBQ9mYWN0b3J5Q29udHJhY3QCGGNoZWNrV3hFbWlzc2lvblBvb2xMYWJlbAkAzAgCBQ1hbW91bnRBc3NldElkCQDMCAIFDHByaWNlQXNzZXRJZAUDbmlsBQNuaWwCHCBjb3VsZG4ndCBiZSBjYXN0IHRvIEJvb2xlYW4ADXBvb2xzTGlzdE5hbWUCBXBvb2xzARBnZXRWb3Rlc0xpc3ROYW1lAQRwb29sBAskdDA0ODAwNDg0MAUEcG9vbAQNYW1vdW50QXNzZXRJZAgFCyR0MDQ4MDA0ODQwAl8xBAxwcmljZUFzc2V0SWQIBQskdDA0ODAwNDg0MAJfMgkAuQkCCQDMCAICBXZvdGVzCQDMCAIFDWFtb3VudEFzc2V0SWQJAMwIAgUMcHJpY2VBc3NldElkBQNuaWwFCXNlcGFyYXRvcgELa2V5TGlzdEhlYWQBCGxpc3ROYW1lBARtZXRhAwkAAAIFCGxpc3ROYW1lBQ1wb29sc0xpc3ROYW1lAgQlcyVzAgglcyVzJXMlcwkAuQkCCQDMCAIFBG1ldGEJAMwIAgUIbGlzdE5hbWUJAMwIAgIEaGVhZAUDbmlsBQlzZXBhcmF0b3IBC2tleUxpc3RTaXplAQhsaXN0TmFtZQQEbWV0YQMJAAACBQhsaXN0TmFtZQUNcG9vbHNMaXN0TmFtZQIEJXMlcwIIJXMlcyVzJXMJALkJAgkAzAgCBQRtZXRhCQDMCAIFCGxpc3ROYW1lCQDMCAICBHNpemUFA25pbAUJc2VwYXJhdG9yAQtrZXlMaXN0UHJldgIIbGlzdE5hbWUCaWQEBG1ldGEDCQAAAgUIbGlzdE5hbWUFDXBvb2xzTGlzdE5hbWUCCCVzJXMlcyVzAgolcyVzJXMlcyVzCQC5CQIJAMwIAgUEbWV0YQkAzAgCBQhsaXN0TmFtZQkAzAgCBQJpZAkAzAgCAgRwcmV2BQNuaWwFCXNlcGFyYXRvcgELa2V5TGlzdE5leHQCCGxpc3ROYW1lAmlkBARtZXRhAwkAAAIFCGxpc3ROYW1lBQ1wb29sc0xpc3ROYW1lAgglcyVzJXMlcwIKJXMlcyVzJXMlcwkAuQkCCQDMCAIFBG1ldGEJAMwIAgUIbGlzdE5hbWUJAMwIAgUCaWQJAMwIAgIEbmV4dAUDbmlsBQlzZXBhcmF0b3IBDGNvbnRhaW5zTm9kZQIIbGlzdE5hbWUCaWQECmhlYWRPclVuaXQJAJ0IAgUEdGhpcwkBC2tleUxpc3RIZWFkAQUIbGlzdE5hbWUECnByZXZPclVuaXQJAJ0IAgUEdGhpcwkBC2tleUxpc3RQcmV2AgUIbGlzdE5hbWUFAmlkBApuZXh0T3JVbml0CQCdCAIFBHRoaXMJAQtrZXlMaXN0TmV4dAIFCGxpc3ROYW1lBQJpZAMDCQAAAgUCaWQJAQt2YWx1ZU9yRWxzZQIFCmhlYWRPclVuaXQCAAYJAQIhPQIFCnByZXZPclVuaXQFBHVuaXQGCQECIT0CBQpuZXh0T3JVbml0BQR1bml0ARFpbnNlcnROb2RlQWN0aW9ucwIIbGlzdE5hbWUCaWQECmhlYWRPclVuaXQJAJ0IAgUEdGhpcwkBC2tleUxpc3RIZWFkAQUIbGlzdE5hbWUECGxpc3RTaXplCQELdmFsdWVPckVsc2UCCQCaCAIFBHRoaXMJAQtrZXlMaXN0U2l6ZQEFCGxpc3ROYW1lAAAECWNoZWNrTm9kZQMJAQEhAQkBDGNvbnRhaW5zTm9kZQIFCGxpc3ROYW1lBQJpZAYJAAIBAgtOb2RlIGV4aXN0cwMJAAACBQljaGVja05vZGUFCWNoZWNrTm9kZQkAzggCCQDOCAIJAMwIAgkBDEludGVnZXJFbnRyeQIJAQtrZXlMaXN0U2l6ZQEFCGxpc3ROYW1lCQBkAgUIbGlzdFNpemUAAQUDbmlsAwkBAiE9AgUKaGVhZE9yVW5pdAUEdW5pdAkAzAgCCQELU3RyaW5nRW50cnkCCQELa2V5TGlzdE5leHQCBQhsaXN0TmFtZQUCaWQJAQV2YWx1ZQEFCmhlYWRPclVuaXQJAMwIAgkBC1N0cmluZ0VudHJ5AgkBC2tleUxpc3RQcmV2AgUIbGlzdE5hbWUJAQV2YWx1ZQEFCmhlYWRPclVuaXQFAmlkBQNuaWwFA25pbAkAzAgCCQELU3RyaW5nRW50cnkCCQELa2V5TGlzdEhlYWQBBQhsaXN0TmFtZQUCaWQFA25pbAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgERZGVsZXRlTm9kZUFjdGlvbnMCCGxpc3ROYW1lAmlkBApoZWFkT3JVbml0CQCdCAIFBHRoaXMJAQtrZXlMaXN0SGVhZAEFCGxpc3ROYW1lBAhsaXN0U2l6ZQkBC3ZhbHVlT3JFbHNlAgkAmggCBQR0aGlzCQELa2V5TGlzdFNpemUBBQhsaXN0TmFtZQAABApwcmV2T3JVbml0CQCdCAIFBHRoaXMJAQtrZXlMaXN0UHJldgIFCGxpc3ROYW1lBQJpZAQKbmV4dE9yVW5pdAkAnQgCBQR0aGlzCQELa2V5TGlzdE5leHQCBQhsaXN0TmFtZQUCaWQJAM4IAgkAzAgCCQEMSW50ZWdlckVudHJ5AgkBC2tleUxpc3RTaXplAQUIbGlzdE5hbWUJAGUCBQhsaXN0U2l6ZQABBQNuaWwDAwkBAiE9AgUKcHJldk9yVW5pdAUEdW5pdAkBAiE9AgUKbmV4dE9yVW5pdAUEdW5pdAcJAMwIAgkBC1N0cmluZ0VudHJ5AgkBC2tleUxpc3ROZXh0AgUIbGlzdE5hbWUJAQV2YWx1ZQEFCnByZXZPclVuaXQJAQV2YWx1ZQEFCm5leHRPclVuaXQJAMwIAgkBC1N0cmluZ0VudHJ5AgkBC2tleUxpc3RQcmV2AgUIbGlzdE5hbWUJAQV2YWx1ZQEFCm5leHRPclVuaXQJAQV2YWx1ZQEFCnByZXZPclVuaXQJAMwIAgkBC0RlbGV0ZUVudHJ5AQkBC2tleUxpc3RQcmV2AgUIbGlzdE5hbWUFAmlkCQDMCAIJAQtEZWxldGVFbnRyeQEJAQtrZXlMaXN0TmV4dAIFCGxpc3ROYW1lBQJpZAUDbmlsAwkBAiE9AgUKbmV4dE9yVW5pdAUEdW5pdAkAzAgCCQELU3RyaW5nRW50cnkCCQELa2V5TGlzdEhlYWQBBQhsaXN0TmFtZQkBBXZhbHVlAQUKbmV4dE9yVW5pdAkAzAgCCQELRGVsZXRlRW50cnkBCQELa2V5TGlzdE5leHQCBQhsaXN0TmFtZQUCaWQJAMwIAgkBC0RlbGV0ZUVudHJ5AQkBC2tleUxpc3RQcmV2AgUIbGlzdE5hbWUJAQV2YWx1ZQEFCm5leHRPclVuaXQFA25pbAMJAQIhPQIFCnByZXZPclVuaXQFBHVuaXQJAMwIAgkBC0RlbGV0ZUVudHJ5AQkBC2tleUxpc3RQcmV2AgUIbGlzdE5hbWUFAmlkCQDMCAIJAQtEZWxldGVFbnRyeQEJAQtrZXlMaXN0TmV4dAIFCGxpc3ROYW1lCQEFdmFsdWUBBQpwcmV2T3JVbml0BQNuaWwDCQAAAgUCaWQJAQt2YWx1ZU9yRWxzZQIFCmhlYWRPclVuaXQCAAkAzAgCCQELRGVsZXRlRW50cnkBCQELa2V5TGlzdEhlYWQBBQhsaXN0TmFtZQUDbmlsCQACAQkArAICCQCsAgIJAKwCAgIOaW52YWxpZCBub2RlOiAFCGxpc3ROYW1lAgEuBQJpZAETa2V5TWFuYWdlclB1YmxpY0tleQACFCVzX19tYW5hZ2VyUHVibGljS2V5ARprZXlQZW5kaW5nTWFuYWdlclB1YmxpY0tleQACGyVzX19wZW5kaW5nTWFuYWdlclB1YmxpY0tleQEWbWFuYWdlclB1YmxpY0tleU9yVW5pdAAEByRtYXRjaDAJAKIIAQkBE2tleU1hbmFnZXJQdWJsaWNLZXkAAwkAAQIFByRtYXRjaDACBlN0cmluZwQBcwUHJG1hdGNoMAkA2QQBBQFzAwkAAQIFByRtYXRjaDACBFVuaXQFBHVuaXQJAAIBAgtNYXRjaCBlcnJvcgEdcGVuZGluZ01hbmFnZXJQdWJsaWNLZXlPclVuaXQABAckbWF0Y2gwCQCiCAEJARprZXlQZW5kaW5nTWFuYWdlclB1YmxpY0tleQADCQABAgUHJG1hdGNoMAIGU3RyaW5nBAFzBQckbWF0Y2gwCQDZBAEFAXMDCQABAgUHJG1hdGNoMAIEVW5pdAUEdW5pdAkAAgECC01hdGNoIGVycm9yABVwZXJtaXNzaW9uRGVuaWVkRXJyb3IJAAIBAhFQZXJtaXNzaW9uIGRlbmllZAEIbXVzdFRoaXMBAWkDCQAAAggFAWkGY2FsbGVyBQR0aGlzBgUVcGVybWlzc2lvbkRlbmllZEVycm9yAQttdXN0TWFuYWdlcgEBaQQHJG1hdGNoMAkBFm1hbmFnZXJQdWJsaWNLZXlPclVuaXQAAwkAAQIFByRtYXRjaDACCkJ5dGVWZWN0b3IEAnBrBQckbWF0Y2gwAwkAAAIIBQFpD2NhbGxlclB1YmxpY0tleQUCcGsGBRVwZXJtaXNzaW9uRGVuaWVkRXJyb3IDCQABAgUHJG1hdGNoMAIEVW5pdAkBCG11c3RUaGlzAQUBaQkAAgECC01hdGNoIGVycm9yEQFpAQpzZXRNYW5hZ2VyARdwZW5kaW5nTWFuYWdlclB1YmxpY0tleQQLY2hlY2tDYWxsZXIJAQttdXN0TWFuYWdlcgEFAWkDCQAAAgULY2hlY2tDYWxsZXIFC2NoZWNrQ2FsbGVyBBVjaGVja01hbmFnZXJQdWJsaWNLZXkJANkEAQUXcGVuZGluZ01hbmFnZXJQdWJsaWNLZXkDCQAAAgUVY2hlY2tNYW5hZ2VyUHVibGljS2V5BRVjaGVja01hbmFnZXJQdWJsaWNLZXkJAMwIAgkBC1N0cmluZ0VudHJ5AgkBGmtleVBlbmRpbmdNYW5hZ2VyUHVibGljS2V5AAUXcGVuZGluZ01hbmFnZXJQdWJsaWNLZXkFA25pbAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgFpAQ5jb25maXJtTWFuYWdlcgAEAnBtCQEdcGVuZGluZ01hbmFnZXJQdWJsaWNLZXlPclVuaXQABAVoYXNQTQMJAQlpc0RlZmluZWQBBQJwbQYJAAIBAhJObyBwZW5kaW5nIG1hbmFnZXIDCQAAAgUFaGFzUE0FBWhhc1BNBAdjaGVja1BNAwkAAAIIBQFpD2NhbGxlclB1YmxpY0tleQkBBXZhbHVlAQUCcG0GCQACAQIbWW91IGFyZSBub3QgcGVuZGluZyBtYW5hZ2VyAwkAAAIFB2NoZWNrUE0FB2NoZWNrUE0JAMwIAgkBC1N0cmluZ0VudHJ5AgkBE2tleU1hbmFnZXJQdWJsaWNLZXkACQDYBAEJAQV2YWx1ZQEFAnBtCQDMCAIJAQtEZWxldGVFbnRyeQEJARprZXlQZW5kaW5nTWFuYWdlclB1YmxpY0tleQAFA25pbAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgFpARhnZXRVc2VyR3d4QW1vdW50QXRIZWlnaHQCC3VzZXJBZGRyZXNzDHRhcmdldEhlaWdodAQXYm9vc3RpbmdDb250cmFjdEFkZHJlc3MJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkApggBCQEMZ2V0U3RyT3JGYWlsAgUEdGhpcwUTa2V5Qm9vc3RpbmdDb250cmFjdAIhaW52YWxpZCBib29zdGluZyBjb250cmFjdCBhZGRyZXNzCQCUCgIFA25pbAoAAUAJAPwHBAUXYm9vc3RpbmdDb250cmFjdEFkZHJlc3MCIGdldFVzZXJHd3hBbW91bnRBdEhlaWdodFJFQURPTkxZCQDMCAIFC3VzZXJBZGRyZXNzCQDMCAIFDHRhcmdldEhlaWdodAUDbmlsBQNuaWwDCQABAgUBQAIDSW50BQFACQACAQkArAICCQADAQkA/AcEBRdib29zdGluZ0NvbnRyYWN0QWRkcmVzcwIgZ2V0VXNlckd3eEFtb3VudEF0SGVpZ2h0UkVBRE9OTFkJAMwIAgULdXNlckFkZHJlc3MJAMwIAgUMdGFyZ2V0SGVpZ2h0BQNuaWwFA25pbAIYIGNvdWxkbid0IGJlIGNhc3QgdG8gSW50AWkBC2NvbnN0cnVjdG9yBQ9mYWN0b3J5Q29udHJhY3Qfdm90aW5nRW1pc3Npb25DYW5kaWRhdGVDb250cmFjdBBib29zdGluZ0NvbnRyYWN0D3N0YWtpbmdDb250cmFjdAtlcG9jaExlbmd0aAQFY2hla3MJAMwIAgkBC211c3RNYW5hZ2VyAQUBaQkAzAgCAwkBAiE9AgkApggBBQ9mYWN0b3J5Q29udHJhY3QFBHVuaXQGAiBpbnZhbGlkIGZhY3RvcnkgY29udHJhY3QgYWRkcmVzcwkAzAgCAwkBAiE9AgkApggBBR92b3RpbmdFbWlzc2lvbkNhbmRpZGF0ZUNvbnRyYWN0BQR1bml0BgIyaW52YWxpZCB2b3RpbmcgZW1pc3Npb24gY2FuZGlkYXRlIGNvbnRyYWN0IGFkZHJlc3MJAMwIAgMJAQIhPQIJAKYIAQUQYm9vc3RpbmdDb250cmFjdAUEdW5pdAYCIWludmFsaWQgYm9vc3RpbmcgY29udHJhY3QgYWRkcmVzcwkAzAgCAwkBAiE9AgkApggBBQ9zdGFraW5nQ29udHJhY3QFBHVuaXQGAiBpbnZhbGlkIHN0YWtpbmcgY29udHJhY3QgYWRkcmVzcwkAzAgCAwkAZgIFC2Vwb2NoTGVuZ3RoAAAGCQACAQIUaW52YWxpZCBlcG9jaCBsZW5ndGgFA25pbAMJAAACBQVjaGVrcwUFY2hla3MJAJQKAgkAzAgCCQELU3RyaW5nRW50cnkCBRJrZXlGYWN0b3J5Q29udHJhY3QFD2ZhY3RvcnlDb250cmFjdAkAzAgCCQELU3RyaW5nRW50cnkCBSJrZXlWb3RpbmdFbWlzc2lvbkNhbmRpZGF0ZUNvbnRyYWN0BR92b3RpbmdFbWlzc2lvbkNhbmRpZGF0ZUNvbnRyYWN0CQDMCAIJAQtTdHJpbmdFbnRyeQIFE2tleUJvb3N0aW5nQ29udHJhY3QFEGJvb3N0aW5nQ29udHJhY3QJAMwIAgkBC1N0cmluZ0VudHJ5AgUSa2V5U3Rha2luZ0NvbnRyYWN0BQ9zdGFraW5nQ29udHJhY3QJAMwIAgkBDEludGVnZXJFbnRyeQIFDmtleUVwb2NoTGVuZ3RoBQtlcG9jaExlbmd0aAUDbmlsBQR1bml0CQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAWkBBmNyZWF0ZQINYW1vdW50QXNzZXRJZAxwcmljZUFzc2V0SWQEBmNoZWNrcwkAzAgCAwkAAAIJANgEAQgIBQFpBmNhbGxlcgVieXRlcwkBC3ZhbHVlT3JFbHNlAgkAnQgCBQR0aGlzBSJrZXlWb3RpbmdFbWlzc2lvbkNhbmRpZGF0ZUNvbnRyYWN0AgAGCQELbXVzdE1hbmFnZXIBBQFpBQNuaWwDCQAAAgUGY2hlY2tzBQZjaGVja3MEBHBvb2wJAJQKAgUNYW1vdW50QXNzZXRJZAUMcHJpY2VBc3NldElkBA1pbkxpc3RBY3Rpb25zCQDOCAIJAMwIAgkBDEJvb2xlYW5FbnRyeQIJAQlrZXlJbkxpc3QBBQRwb29sBgUDbmlsCQERaW5zZXJ0Tm9kZUFjdGlvbnMCBQ1wb29sc0xpc3ROYW1lCQEMcG9vbFRvU3RyaW5nAQUEcG9vbAQYY3VycmVudEVwb2NoSXNOb3REZWZpbmVkCQAAAgkAmggCBQR0aGlzBQ9rZXlDdXJyZW50RXBvY2gFBHVuaXQEEnN0YXJ0SGVpZ2h0QWN0aW9ucwMFGGN1cnJlbnRFcG9jaElzTm90RGVmaW5lZAQFZXBvY2gAAAkAzAgCCQEMSW50ZWdlckVudHJ5AgUPa2V5Q3VycmVudEVwb2NoBQVlcG9jaAkAzAgCCQEMSW50ZWdlckVudHJ5AgkBFWtleVN0YXJ0SGVpZ2h0QnlFcG9jaAEFBWVwb2NoBQZoZWlnaHQJAMwIAgkBDEludGVnZXJFbnRyeQIFDmtleVN0YXJ0SGVpZ2h0BQZoZWlnaHQJAMwIAgkBDEludGVnZXJFbnRyeQIFEWtleUN1cnJlbnRFcG9jaFVpBQVlcG9jaAkAzAgCCQEMSW50ZWdlckVudHJ5AgUQa2V5U3RhcnRIZWlnaHRVaQUGaGVpZ2h0BQNuaWwFA25pbAkAlAoCCQDOCAIFDWluTGlzdEFjdGlvbnMFEnN0YXJ0SGVpZ2h0QWN0aW9ucwUEdW5pdAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgFpAQR2b3RlAw1hbW91bnRBc3NldElkDHByaWNlQXNzZXRJZAZhbW91bnQEBHBvb2wJAJQKAgUNYW1vdW50QXNzZXRJZAUMcHJpY2VBc3NldElkBAVlcG9jaAkBC3ZhbHVlT3JFbHNlAgkAmggCBQR0aGlzBQ9rZXlDdXJyZW50RXBvY2gAAAQLc3RhcnRIZWlnaHQJAQxnZXRJbnRPckZhaWwCBQR0aGlzCQEVa2V5U3RhcnRIZWlnaHRCeUVwb2NoAQUFZXBvY2gEC2Vwb2NoTGVuZ3RoCQEMZ2V0SW50T3JGYWlsAgUEdGhpcwUOa2V5RXBvY2hMZW5ndGgECWVuZEhlaWdodAkAZAIFC3N0YXJ0SGVpZ2h0BQtlcG9jaExlbmd0aAQXZmluYWxpemF0aW9uU3RhZ2VPclVuaXQJAJoIAgUEdGhpcwUUa2V5RmluYWxpemF0aW9uU3RhZ2UEBHVzZWQJAQt2YWx1ZU9yRWxzZQIJAJoIAgUEdGhpcwkBB2tleVVzZWQCCAUBaQZjYWxsZXIFBWVwb2NoAAAEBHZvdGUJAQt2YWx1ZU9yRWxzZQIJAJoIAgUEdGhpcwkBB2tleVZvdGUDBQRwb29sCAUBaQZjYWxsZXIFBWVwb2NoAAAECnBvb2xSZXN1bHQJAQt2YWx1ZU9yRWxzZQIJAJoIAgUEdGhpcwkBD2tleVZvdGluZ1Jlc3VsdAIFBHBvb2wFBWVwb2NoAAAECnRvdGFsVm90ZXMJAQt2YWx1ZU9yRWxzZQIJAJoIAgUEdGhpcwkBDWtleVRvdGFsVm90ZXMBBQVlcG9jaAAABBNnd3hBbW91bnRBdEVuZFRvdGFsCgABQAkA/AcEBQR0aGlzAhhnZXRVc2VyR3d4QW1vdW50QXRIZWlnaHQJAMwIAgkA2AQBCAgFAWkGY2FsbGVyBWJ5dGVzCQDMCAIFCWVuZEhlaWdodAUDbmlsBQNuaWwDCQABAgUBQAIDSW50BQFACQACAQkArAICCQADAQkA/AcEBQR0aGlzAhhnZXRVc2VyR3d4QW1vdW50QXRIZWlnaHQJAMwIAgkA2AQBCAgFAWkGY2FsbGVyBWJ5dGVzCQDMCAIFCWVuZEhlaWdodAUDbmlsBQNuaWwCGCBjb3VsZG4ndCBiZSBjYXN0IHRvIEludAQJYXZhaWxhYmxlCQBlAgUTZ3d4QW1vdW50QXRFbmRUb3RhbAUEdXNlZAQHbmV3Vm90ZQkAZAIFBHZvdGUFBmFtb3VudAQKd3hFbWlzc2lvbgkBGGNoZWNrV3hFbWlzc2lvblBvb2xMYWJlbAEFBHBvb2wEBmNoZWNrcwkAzAgCAwkBAiE9AgkAoAgBCQEJa2V5SW5MaXN0AQUEcG9vbAUEdW5pdAYJAAIBAg5pbnZhbGlkIGFzc2V0cwkAzAgCAwkAZgIFCWVuZEhlaWdodAUGaGVpZ2h0BgkAAgECDmludmFsaWQgaGVpZ2h0CQDMCAIDCQAAAgUXZmluYWxpemF0aW9uU3RhZ2VPclVuaXQFBHVuaXQGCQACAQIYZmluYWxpemF0aW9uIGluIHByb2dyZXNzCQDMCAIDCQBmAgUTZ3d4QW1vdW50QXRFbmRUb3RhbAAABgkAAgECE3lvdSBkbyBub3QgaGF2ZSBnV1gJAMwIAgMDCQBmAgUGYW1vdW50AAAJAGcCBQlhdmFpbGFibGUFBmFtb3VudAcGCQACAQIOaW52YWxpZCBhbW91bnQJAMwIAgMFCnd4RW1pc3Npb24GCQACAQIdcG9vbCBoYXNuJ3QgV1hfRU1JU1NJT04gbGFiZWwFA25pbAMJAAACBQZjaGVja3MFBmNoZWNrcwQNdm90ZXNMaXN0TmFtZQkBEGdldFZvdGVzTGlzdE5hbWUBBQRwb29sBA51c2VyQWRkcmVzc1N0cgkApQgBCAUBaQZjYWxsZXIEEHZvdGVzTGlzdEFjdGlvbnMDCQEMY29udGFpbnNOb2RlAgUNdm90ZXNMaXN0TmFtZQUOdXNlckFkZHJlc3NTdHIFA25pbAkBEWluc2VydE5vZGVBY3Rpb25zAgUNdm90ZXNMaXN0TmFtZQUOdXNlckFkZHJlc3NTdHIJAJQKAgkAzggCCQDMCAIJAQxJbnRlZ2VyRW50cnkCCQEHa2V5VXNlZAIIBQFpBmNhbGxlcgUFZXBvY2gJAGQCBQR1c2VkBQZhbW91bnQJAMwIAgkBDEludGVnZXJFbnRyeQIJAQdrZXlWb3RlAwUEcG9vbAgFAWkGY2FsbGVyBQVlcG9jaAUHbmV3Vm90ZQkAzAgCCQEMSW50ZWdlckVudHJ5AgkBD2tleVZvdGluZ1Jlc3VsdAIFBHBvb2wFBWVwb2NoCQBkAgUKcG9vbFJlc3VsdAUGYW1vdW50CQDMCAIJAQxJbnRlZ2VyRW50cnkCCQENa2V5VG90YWxWb3RlcwEFBWVwb2NoCQBkAgUKdG90YWxWb3RlcwUGYW1vdW50BQNuaWwFEHZvdGVzTGlzdEFjdGlvbnMFBHVuaXQJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BaQEKY2FuY2VsVm90ZQINYW1vdW50QXNzZXRJZAxwcmljZUFzc2V0SWQEBHBvb2wJAJQKAgUNYW1vdW50QXNzZXRJZAUMcHJpY2VBc3NldElkBAVlcG9jaAkBC3ZhbHVlT3JFbHNlAgkAmggCBQR0aGlzBQ9rZXlDdXJyZW50RXBvY2gAAAQLc3RhcnRIZWlnaHQJAQxnZXRJbnRPckZhaWwCBQR0aGlzCQEVa2V5U3RhcnRIZWlnaHRCeUVwb2NoAQUFZXBvY2gEC2Vwb2NoTGVuZ3RoCQEMZ2V0SW50T3JGYWlsAgUEdGhpcwUOa2V5RXBvY2hMZW5ndGgECWVuZEhlaWdodAkAZAIFC3N0YXJ0SGVpZ2h0BQtlcG9jaExlbmd0aAQXZmluYWxpemF0aW9uU3RhZ2VPclVuaXQJAJoIAgUEdGhpcwUUa2V5RmluYWxpemF0aW9uU3RhZ2UEBHVzZWQJAQt2YWx1ZU9yRWxzZQIJAJoIAgUEdGhpcwkBB2tleVVzZWQCCAUBaQZjYWxsZXIFBWVwb2NoAAAEBHZvdGUJAQt2YWx1ZU9yRWxzZQIJAJoIAgUEdGhpcwkBB2tleVZvdGUDBQRwb29sCAUBaQZjYWxsZXIFBWVwb2NoAAAECnBvb2xSZXN1bHQJAQt2YWx1ZU9yRWxzZQIJAJoIAgUEdGhpcwkBD2tleVZvdGluZ1Jlc3VsdAIFBHBvb2wFBWVwb2NoAAAECnRvdGFsVm90ZXMJAQt2YWx1ZU9yRWxzZQIJAJoIAgUEdGhpcwkBDWtleVRvdGFsVm90ZXMBBQVlcG9jaAAABAZjaGVja3MJAMwIAgMJAQIhPQIJAKAIAQkBCWtleUluTGlzdAEFBHBvb2wFBHVuaXQGCQACAQIOaW52YWxpZCBhc3NldHMJAMwIAgMJAGYCBQllbmRIZWlnaHQFBmhlaWdodAYJAAIBAg5pbnZhbGlkIGhlaWdodAkAzAgCAwkAAAIFF2ZpbmFsaXphdGlvblN0YWdlT3JVbml0BQR1bml0BgkAAgECGGZpbmFsaXphdGlvbiBpbiBwcm9ncmVzcwkAzAgCAwkAZgIFBHZvdGUAAAYJAAIBAgdubyB2b3RlBQNuaWwDCQAAAgUGY2hlY2tzBQZjaGVja3MEDXZvdGVzTGlzdE5hbWUJARBnZXRWb3Rlc0xpc3ROYW1lAQUEcG9vbAQOdXNlckFkZHJlc3NTdHIJAKUIAQgFAWkGY2FsbGVyCQCUCgIJAM4IAgkAzAgCCQEMSW50ZWdlckVudHJ5AgkBB2tleVVzZWQCCAUBaQZjYWxsZXIFBWVwb2NoCQCWAwEJAMwIAgkAZQIFBHVzZWQFBHZvdGUJAMwIAgAABQNuaWwJAMwIAgkBC0RlbGV0ZUVudHJ5AQkBB2tleVZvdGUDBQRwb29sCAUBaQZjYWxsZXIFBWVwb2NoCQDMCAIJAQxJbnRlZ2VyRW50cnkCCQEPa2V5Vm90aW5nUmVzdWx0AgUEcG9vbAUFZXBvY2gJAGUCBQpwb29sUmVzdWx0BQR2b3RlCQDMCAIJAQxJbnRlZ2VyRW50cnkCCQENa2V5VG90YWxWb3RlcwEFBWVwb2NoCQBlAgUKdG90YWxWb3RlcwUEdm90ZQUDbmlsCQERZGVsZXRlTm9kZUFjdGlvbnMCBQ12b3Rlc0xpc3ROYW1lBQ51c2VyQWRkcmVzc1N0cgUEdW5pdAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgFpAQ5zZXRFcG9jaExlbmd0aAEObmV3RXBvY2hMZW5ndGgEBWNoZWtzCQDMCAIJAQttdXN0TWFuYWdlcgEFAWkJAMwIAgMJAGYCBQ5uZXdFcG9jaExlbmd0aAAABgkAAgECFGludmFsaWQgZXBvY2ggbGVuZ3RoBQNuaWwDCQAAAgUFY2hla3MFBWNoZWtzCQCUCgIJAMwIAgkBDEludGVnZXJFbnRyeQIFDmtleUVwb2NoTGVuZ3RoBQ5uZXdFcG9jaExlbmd0aAUDbmlsBQR1bml0CQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAWkBC3NldE1heERlcHRoAQtuZXdNYXhEZXB0aAQFY2hla3MJAMwIAgkBC211c3RNYW5hZ2VyAQUBaQkAzAgCAwkAZgIFC25ld01heERlcHRoAAAGCQACAQIRaW52YWxpZCBtYXggZGVwdGgFA25pbAMJAAACBQVjaGVrcwUFY2hla3MJAJQKAgkAzAgCCQEMSW50ZWdlckVudHJ5AgULa2V5TWF4RGVwdGgFC25ld01heERlcHRoBQNuaWwFBHVuaXQJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BaQETcHJvY2Vzc1ZvdGVJTlRFUk5BTAIHcG9vbFN0cg51c2VyQWRkcmVzc1N0cgQLY2hlY2tDYWxsZXIJAQhtdXN0VGhpcwEFAWkDCQAAAgULY2hlY2tDYWxsZXIFC2NoZWNrQ2FsbGVyBAt1c2VyQWRkcmVzcwkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCmCAEFDnVzZXJBZGRyZXNzU3RyCQCsAgICKnByb2Nlc3NWb3RlSU5URVJOQUw6IGludmFsaWQgdXNlciBhZGRyZXNzIAUOdXNlckFkZHJlc3NTdHIEBWVwb2NoCQEMZ2V0SW50T3JGYWlsAgUEdGhpcwUPa2V5Q3VycmVudEVwb2NoBA1lcG9jaFByZXZpb3VzCQBlAgUFZXBvY2gAAQQLZXBvY2hMZW5ndGgJAQxnZXRJbnRPckZhaWwCBQR0aGlzBQ5rZXlFcG9jaExlbmd0aAQLc3RhcnRIZWlnaHQJAQxnZXRJbnRPckZhaWwCBQR0aGlzCQEVa2V5U3RhcnRIZWlnaHRCeUVwb2NoAQUFZXBvY2gECWVuZEhlaWdodAkAZAIFC3N0YXJ0SGVpZ2h0BQtlcG9jaExlbmd0aAQTc3RhcnRIZWlnaHRQcmV2aW91cwkBDGdldEludE9yRmFpbAIFBHRoaXMJARVrZXlTdGFydEhlaWdodEJ5RXBvY2gBBQ1lcG9jaFByZXZpb3VzBBFlbmRIZWlnaHRQcmV2aW91cwkAZAIFE3N0YXJ0SGVpZ2h0UHJldmlvdXMFC2Vwb2NoTGVuZ3RoBBBjaGVja1RhcmdldEVwb2NoAwkAZwIFDWVwb2NoUHJldmlvdXMAAAYJAAIBAitwcm9jZXNzVm90ZUlOVEVSTkFMOiBpbnZhbGlkIHByZXZpb3VzIGVwb2NoAwkAAAIFEGNoZWNrVGFyZ2V0RXBvY2gFEGNoZWNrVGFyZ2V0RXBvY2gEBHBvb2wJAQxzdHJpbmdUb1Bvb2wBBQdwb29sU3RyBA0kdDAxNzEyNjE3MTY2BQRwb29sBA1hbW91bnRBc3NldElkCAUNJHQwMTcxMjYxNzE2NgJfMQQMcHJpY2VBc3NldElkCAUNJHQwMTcxMjYxNzE2NgJfMgQKd3hFbWlzc2lvbgkBGGNoZWNrV3hFbWlzc2lvblBvb2xMYWJlbAEFBHBvb2wEE2d3eEFtb3VudEF0RW5kVG90YWwKAAFACQD8BwQFBHRoaXMCGGdldFVzZXJHd3hBbW91bnRBdEhlaWdodAkAzAgCBQ51c2VyQWRkcmVzc1N0cgkAzAgCBQllbmRIZWlnaHQFA25pbAUDbmlsAwkAAQIFAUACA0ludAUBQAkAAgEJAKwCAgkAAwEJAPwHBAUEdGhpcwIYZ2V0VXNlckd3eEFtb3VudEF0SGVpZ2h0CQDMCAIFDnVzZXJBZGRyZXNzU3RyCQDMCAIFCWVuZEhlaWdodAUDbmlsBQNuaWwCGCBjb3VsZG4ndCBiZSBjYXN0IHRvIEludAQbZ3d4QW1vdW50QXRFbmRUb3RhbFByZXZpb3VzCgABQAkA/AcEBQR0aGlzAhhnZXRVc2VyR3d4QW1vdW50QXRIZWlnaHQJAMwIAgUOdXNlckFkZHJlc3NTdHIJAMwIAgURZW5kSGVpZ2h0UHJldmlvdXMFA25pbAUDbmlsAwkAAQIFAUACA0ludAUBQAkAAgEJAKwCAgkAAwEJAPwHBAUEdGhpcwIYZ2V0VXNlckd3eEFtb3VudEF0SGVpZ2h0CQDMCAIFDnVzZXJBZGRyZXNzU3RyCQDMCAIFEWVuZEhlaWdodFByZXZpb3VzBQNuaWwFA25pbAIYIGNvdWxkbid0IGJlIGNhc3QgdG8gSW50BAp0b3RhbFZvdGVzCQELdmFsdWVPckVsc2UCCQCfCAEJAQ1rZXlUb3RhbFZvdGVzAQUFZXBvY2gAAAQMdm90aW5nUmVzdWx0CQELdmFsdWVPckVsc2UCCQCfCAEJAQ9rZXlWb3RpbmdSZXN1bHQCBQRwb29sBQVlcG9jaAAABAx2b3RlUHJldmlvdXMJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAnwgBCQEHa2V5Vm90ZQMFBHBvb2wFC3VzZXJBZGRyZXNzBQ1lcG9jaFByZXZpb3VzCQCsAgIJAKwCAgkArAICCQCsAgICFHByb2Nlc3NWb3RlSU5URVJOQUwgBQdwb29sU3RyAgEgBQ51c2VyQWRkcmVzc1N0cgISOiBubyBwcmV2aW91cyB2b3RlBAR1c2VkCQELdmFsdWVPckVsc2UCCQCaCAIFBHRoaXMJAQdrZXlVc2VkAgULdXNlckFkZHJlc3MFBWVwb2NoAAAEB25ld1ZvdGUJAGsDBQx2b3RlUHJldmlvdXMFE2d3eEFtb3VudEF0RW5kVG90YWwFG2d3eEFtb3VudEF0RW5kVG90YWxQcmV2aW91cwQHYWN0aW9ucwMDCQBmAgUHbmV3Vm90ZQAABQp3eEVtaXNzaW9uBwkAzAgCCQEMSW50ZWdlckVudHJ5AgkBB2tleVZvdGUDBQRwb29sBQt1c2VyQWRkcmVzcwUFZXBvY2gFB25ld1ZvdGUJAMwIAgkBDEludGVnZXJFbnRyeQIJAQ1rZXlUb3RhbFZvdGVzAQUFZXBvY2gJAGQCBQp0b3RhbFZvdGVzBQduZXdWb3RlCQDMCAIJAQxJbnRlZ2VyRW50cnkCCQEPa2V5Vm90aW5nUmVzdWx0AgUEcG9vbAUFZXBvY2gJAGQCBQx2b3RpbmdSZXN1bHQFB25ld1ZvdGUJAMwIAgkBDEludGVnZXJFbnRyeQIJAQdrZXlVc2VkAgULdXNlckFkZHJlc3MFBWVwb2NoCQBkAgUEdXNlZAUHbmV3Vm90ZQUDbmlsCQERZGVsZXRlTm9kZUFjdGlvbnMCCQEQZ2V0Vm90ZXNMaXN0TmFtZQEFBHBvb2wFDnVzZXJBZGRyZXNzU3RyCQCUCgIFB2FjdGlvbnMFBHVuaXQJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BaQETcHJvY2Vzc1Bvb2xJTlRFUk5BTAEHcG9vbFN0cgQLY2hlY2tDYWxsZXIJAQhtdXN0VGhpcwEFAWkDCQAAAgULY2hlY2tDYWxsZXIFC2NoZWNrQ2FsbGVyBAt0YXJnZXRFcG9jaAkAZQIJAQxnZXRJbnRPckZhaWwCBQR0aGlzBQ9rZXlDdXJyZW50RXBvY2gAAQQQY2hlY2tUYXJnZXRFcG9jaAMJAGcCBQt0YXJnZXRFcG9jaAAABgkAAgECKXByb2Nlc3NQb29sSU5URVJOQUw6IGludmFsaWQgdGFyZ2V0IGVwb2NoAwkAAAIFEGNoZWNrVGFyZ2V0RXBvY2gFEGNoZWNrVGFyZ2V0RXBvY2gEBHBvb2wJAQxzdHJpbmdUb1Bvb2wBBQdwb29sU3RyBA0kdDAxODY4MzE4NzIzBQRwb29sBA1hbW91bnRBc3NldElkCAUNJHQwMTg2ODMxODcyMwJfMQQMcHJpY2VBc3NldElkCAUNJHQwMTg2ODMxODcyMwJfMgQPc3Rha2luZ0NvbnRyYWN0CQERQGV4dHJOYXRpdmUoMTA2MikBCQEMZ2V0U3RyT3JGYWlsAgUEdGhpcwUSa2V5U3Rha2luZ0NvbnRyYWN0BA9mYWN0b3J5Q29udHJhY3QJARFAZXh0ck5hdGl2ZSgxMDYyKQEJAQxnZXRTdHJPckZhaWwCBQR0aGlzBRJrZXlGYWN0b3J5Q29udHJhY3QECWxwQXNzZXRJZAkBFmdldExwQXNzZXRCeVBvb2xBc3NldHMCBQ1hbW91bnRBc3NldElkBQxwcmljZUFzc2V0SWQEAXIKAAFACQD8BwQFD3N0YWtpbmdDb250cmFjdAISdXNlcnNMaXN0VHJhdmVyc2FsCQDMCAIFCWxwQXNzZXRJZAUDbmlsBQNuaWwDCQABAgUBQAIHQm9vbGVhbgUBQAkAAgEJAKwCAgkAAwEJAPwHBAUPc3Rha2luZ0NvbnRyYWN0AhJ1c2Vyc0xpc3RUcmF2ZXJzYWwJAMwIAgUJbHBBc3NldElkBQNuaWwFA25pbAIcIGNvdWxkbid0IGJlIGNhc3QgdG8gQm9vbGVhbgMJAAACBQFyBQFyAwUBcgkAlAoCBQNuaWwGBAp3eEVtaXNzaW9uCQEYY2hlY2tXeEVtaXNzaW9uUG9vbExhYmVsAQUEcG9vbAQKdG90YWxWb3RlcwkBC3ZhbHVlT3JFbHNlAgkAmggCBQR0aGlzCQENa2V5VG90YWxWb3RlcwEFC3RhcmdldEVwb2NoAAAEDHZvdGluZ1Jlc3VsdAkBC3ZhbHVlT3JFbHNlAgkAmggCBQR0aGlzCQEPa2V5Vm90aW5nUmVzdWx0AgUEcG9vbAULdGFyZ2V0RXBvY2gAAAQFc2hhcmUDAwkAAAIFCnRvdGFsVm90ZXMAAAYJAQEhAQUKd3hFbWlzc2lvbgAACQBrAwUMdm90aW5nUmVzdWx0BQ5wb29sV2VpZ2h0TXVsdAUKdG90YWxWb3RlcwQPbW9kaWZ5V2VpZ2h0SW52CQD8BwQFD2ZhY3RvcnlDb250cmFjdAIMbW9kaWZ5V2VpZ2h0CQDMCAIFCWxwQXNzZXRJZAkAzAgCBQVzaGFyZQUDbmlsBQNuaWwDCQAAAgUPbW9kaWZ5V2VpZ2h0SW52BQ9tb2RpZnlXZWlnaHRJbnYEEHBvb2xzTGlzdEFjdGlvbnMDBQp3eEVtaXNzaW9uBQNuaWwJAM4IAgkAzAgCCQELRGVsZXRlRW50cnkBCQEJa2V5SW5MaXN0AQUEcG9vbAUDbmlsCQERZGVsZXRlTm9kZUFjdGlvbnMCBQ1wb29sc0xpc3ROYW1lBQdwb29sU3RyCQCUCgIJAM4IAgkAzAgCCQEMSW50ZWdlckVudHJ5AgkBDGtleVBvb2xTaGFyZQIFBHBvb2wFC3RhcmdldEVwb2NoBQVzaGFyZQUDbmlsBRBwb29sc0xpc3RBY3Rpb25zBwkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgFpAQ5maW5hbGl6ZUhlbHBlcgAEBWVwb2NoCQELdmFsdWVPckVsc2UCCQCaCAIFBHRoaXMFD2tleUN1cnJlbnRFcG9jaAAABA1wcmV2aW91c0Vwb2NoCQBlAgUFZXBvY2gAAQQLc3RhcnRIZWlnaHQJAQxnZXRJbnRPckZhaWwCBQR0aGlzCQEVa2V5U3RhcnRIZWlnaHRCeUVwb2NoAQUFZXBvY2gEC2Vwb2NoTGVuZ3RoCQEMZ2V0SW50T3JGYWlsAgUEdGhpcwUOa2V5RXBvY2hMZW5ndGgECWVuZEhlaWdodAkAZAIFC3N0YXJ0SGVpZ2h0BQtlcG9jaExlbmd0aAQXZmluYWxpemF0aW9uU3RhZ2VPclVuaXQJAJoIAgUEdGhpcwUUa2V5RmluYWxpemF0aW9uU3RhZ2UDAwkAZwIFBmhlaWdodAUJZW5kSGVpZ2h0CQAAAgUXZmluYWxpemF0aW9uU3RhZ2VPclVuaXQFBHVuaXQHBAhuZXdFcG9jaAkAZAIFBWVwb2NoAAEJAJQKAgkAzAgCCQEMSW50ZWdlckVudHJ5AgkBFWtleVN0YXJ0SGVpZ2h0QnlFcG9jaAEFCG5ld0Vwb2NoBQZoZWlnaHQJAMwIAgkBDEludGVnZXJFbnRyeQIFDmtleVN0YXJ0SGVpZ2h0BQZoZWlnaHQJAMwIAgkBDEludGVnZXJFbnRyeQIFD2tleUN1cnJlbnRFcG9jaAUIbmV3RXBvY2gJAMwIAgkBDEludGVnZXJFbnRyeQIFFGtleUZpbmFsaXphdGlvblN0YWdlBRZmaW5hbGl6YXRpb25TdGFnZVRvdGFsBQNuaWwGAwkAAAIFF2ZpbmFsaXphdGlvblN0YWdlT3JVbml0BQR1bml0CQCUCgIFA25pbAcDCQAAAgUXZmluYWxpemF0aW9uU3RhZ2VPclVuaXQFFmZpbmFsaXphdGlvblN0YWdlVG90YWwECnBvb2xPclVuaXQJAKIIAQULa2V5TmV4dFBvb2wECnVzZXJPclVuaXQJAKIIAQULa2V5TmV4dFVzZXIEByRtYXRjaDAFCnBvb2xPclVuaXQDCQABAgUHJG1hdGNoMAIEVW5pdAQHJG1hdGNoMQkAoggBCQELa2V5TGlzdEhlYWQBBQ1wb29sc0xpc3ROYW1lAwkAAQIFByRtYXRjaDECBFVuaXQJAJQKAgkAzAgCCQEMSW50ZWdlckVudHJ5AgUUa2V5RmluYWxpemF0aW9uU3RhZ2UFF2ZpbmFsaXphdGlvblN0YWdlU2hhcmVzCQDMCAIJAQtEZWxldGVFbnRyeQEFC2tleU5leHRQb29sCQDMCAIJAQtEZWxldGVFbnRyeQEFC2tleU5leHRVc2VyBQNuaWwGAwkAAQIFByRtYXRjaDECBlN0cmluZwQMcG9vbHNIZWFkU3RyBQckbWF0Y2gxCQCUCgIJAMwIAgkBC1N0cmluZ0VudHJ5AgULa2V5TmV4dFBvb2wFDHBvb2xzSGVhZFN0cgUDbmlsBgkAAgECC01hdGNoIGVycm9yAwkAAQIFByRtYXRjaDACBlN0cmluZwQHcG9vbFN0cgUHJG1hdGNoMAQEcG9vbAkBDHN0cmluZ1RvUG9vbAEFB3Bvb2xTdHIEDm5leHRVc2VyT3JVbml0BAckbWF0Y2gxBQp1c2VyT3JVbml0AwkAAQIFByRtYXRjaDECBFVuaXQJAKIIAQkBC2tleUxpc3RIZWFkAQkBEGdldFZvdGVzTGlzdE5hbWUBBQRwb29sAwkAAQIFByRtYXRjaDECBlN0cmluZwQEdXNlcgUHJG1hdGNoMQQOcHJvY2Vzc1ZvdGVJbnYJAPwHBAUEdGhpcwITcHJvY2Vzc1ZvdGVJTlRFUk5BTAkAzAgCBQdwb29sU3RyCQDMCAIFBHVzZXIFA25pbAUDbmlsAwkAAAIFDnByb2Nlc3NWb3RlSW52BQ5wcm9jZXNzVm90ZUludgkAoggBCQELa2V5TGlzdE5leHQCCQEQZ2V0Vm90ZXNMaXN0TmFtZQEFBHBvb2wFBHVzZXIJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAgtNYXRjaCBlcnJvcgQHJG1hdGNoMQUObmV4dFVzZXJPclVuaXQDCQABAgUHJG1hdGNoMQIEVW5pdAQObmV4dFBvb2xPclVuaXQJAKIIAQkBC2tleUxpc3ROZXh0AgUNcG9vbHNMaXN0TmFtZQUHcG9vbFN0cgQHJG1hdGNoMgUObmV4dFBvb2xPclVuaXQDCQABAgUHJG1hdGNoMgIEVW5pdAkAlAoCCQDMCAIJAQxJbnRlZ2VyRW50cnkCBRRrZXlGaW5hbGl6YXRpb25TdGFnZQUXZmluYWxpemF0aW9uU3RhZ2VTaGFyZXMJAMwIAgkBC0RlbGV0ZUVudHJ5AQULa2V5TmV4dFBvb2wJAMwIAgkBC0RlbGV0ZUVudHJ5AQULa2V5TmV4dFVzZXIFA25pbAYDCQABAgUHJG1hdGNoMgIGU3RyaW5nBAFzBQckbWF0Y2gyCQCUCgIJAMwIAgkBC1N0cmluZ0VudHJ5AgULa2V5TmV4dFBvb2wFAXMJAMwIAgkBC0RlbGV0ZUVudHJ5AQULa2V5TmV4dFVzZXIFA25pbAYJAAIBAgtNYXRjaCBlcnJvcgMJAAECBQckbWF0Y2gxAgZTdHJpbmcECG5leHRVc2VyBQckbWF0Y2gxCQCUCgIJAMwIAgkBC1N0cmluZ0VudHJ5AgULa2V5TmV4dFVzZXIFCG5leHRVc2VyBQNuaWwGCQACAQILTWF0Y2ggZXJyb3IJAAIBAgtNYXRjaCBlcnJvcgMJAAACBRdmaW5hbGl6YXRpb25TdGFnZU9yVW5pdAUXZmluYWxpemF0aW9uU3RhZ2VTaGFyZXMECnBvb2xPclVuaXQJAKIIAQULa2V5TmV4dFBvb2wEByRtYXRjaDAFCnBvb2xPclVuaXQDCQABAgUHJG1hdGNoMAIEVW5pdAQHJG1hdGNoMQkAoggBCQELa2V5TGlzdEhlYWQBBQ1wb29sc0xpc3ROYW1lAwkAAQIFByRtYXRjaDECBFVuaXQJAJQKAgkAzAgCCQELRGVsZXRlRW50cnkBBRRrZXlGaW5hbGl6YXRpb25TdGFnZQkAzAgCCQEMQm9vbGVhbkVudHJ5AgkBDGtleUZpbmFsaXplZAEFDXByZXZpb3VzRXBvY2gGCQDMCAIJAQxJbnRlZ2VyRW50cnkCBRFrZXlDdXJyZW50RXBvY2hVaQUFZXBvY2gJAMwIAgkBDEludGVnZXJFbnRyeQIFEGtleVN0YXJ0SGVpZ2h0VWkFC3N0YXJ0SGVpZ2h0BQNuaWwGAwkAAQIFByRtYXRjaDECBlN0cmluZwQLbmV4dFBvb2xTdHIFByRtYXRjaDEJAJQKAgkAzAgCCQELU3RyaW5nRW50cnkCBQtrZXlOZXh0UG9vbAULbmV4dFBvb2xTdHIFA25pbAYJAAIBAgtNYXRjaCBlcnJvcgMJAAECBQckbWF0Y2gwAgZTdHJpbmcEB3Bvb2xTdHIFByRtYXRjaDAEAXIKAAFACQD8BwQFBHRoaXMCE3Byb2Nlc3NQb29sSU5URVJOQUwJAMwIAgUHcG9vbFN0cgUDbmlsBQNuaWwDCQABAgUBQAIHQm9vbGVhbgUBQAkAAgEJAKwCAgkAAwEJAPwHBAUEdGhpcwITcHJvY2Vzc1Bvb2xJTlRFUk5BTAkAzAgCBQdwb29sU3RyBQNuaWwFA25pbAIcIGNvdWxkbid0IGJlIGNhc3QgdG8gQm9vbGVhbgMJAAACBQFyBQFyAwUBcgkAlAoCBQNuaWwGBA5uZXh0UG9vbE9yVW5pdAkAoggBCQELa2V5TGlzdE5leHQCBQ1wb29sc0xpc3ROYW1lBQdwb29sU3RyBAckbWF0Y2gxBQ5uZXh0UG9vbE9yVW5pdAMJAAECBQckbWF0Y2gxAgRVbml0CQCUCgIJAMwIAgkBC0RlbGV0ZUVudHJ5AQUUa2V5RmluYWxpemF0aW9uU3RhZ2UJAMwIAgkBDEJvb2xlYW5FbnRyeQIJAQxrZXlGaW5hbGl6ZWQBBQ1wcmV2aW91c0Vwb2NoBgkAzAgCCQEMSW50ZWdlckVudHJ5AgURa2V5Q3VycmVudEVwb2NoVWkFBWVwb2NoCQDMCAIJAQxJbnRlZ2VyRW50cnkCBRBrZXlTdGFydEhlaWdodFVpBQtzdGFydEhlaWdodAkAzAgCCQELRGVsZXRlRW50cnkBBQtrZXlOZXh0UG9vbAUDbmlsBgMJAAECBQckbWF0Y2gxAgZTdHJpbmcEC25leHRQb29sU3RyBQckbWF0Y2gxCQCUCgIJAMwIAgkBC1N0cmluZ0VudHJ5AgULa2V5TmV4dFBvb2wFC25leHRQb29sU3RyBQNuaWwGCQACAQILTWF0Y2ggZXJyb3IJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAgtNYXRjaCBlcnJvcgkAAgECFmZpbmFsaXphdGlvbiBpcyBicm9rZW4BaQEPZmluYWxpemVXcmFwcGVyAQdjb3VudGVyBAZyZXN1bHQKAAFACQD8BwQFBHRoaXMCDmZpbmFsaXplSGVscGVyBQNuaWwFA25pbAMJAAECBQFAAgdCb29sZWFuBQFACQACAQkArAICCQADAQkA/AcEBQR0aGlzAg5maW5hbGl6ZUhlbHBlcgUDbmlsBQNuaWwCHCBjb3VsZG4ndCBiZSBjYXN0IHRvIEJvb2xlYW4DCQAAAgUGcmVzdWx0BQZyZXN1bHQDCQEBIQEFBnJlc3VsdAMJAAACBQdjb3VudGVyAAAJAAIBAh5DdXJyZW50IHZvdGluZyBpcyBub3Qgb3ZlciB5ZXQJAJQKAgUDbmlsBQR1bml0BAhtYXhEZXB0aAkBC3ZhbHVlT3JFbHNlAgkAmggCBQR0aGlzBQtrZXlNYXhEZXB0aAUPbWF4RGVwdGhEZWZhdWx0AwkAZgIFCG1heERlcHRoBQdjb3VudGVyBANpbnYJAPwHBAUEdGhpcwIPZmluYWxpemVXcmFwcGVyCQDMCAIJAGQCBQdjb3VudGVyAAEFA25pbAUDbmlsAwkAAAIFA2ludgUDaW52CQCUCgIFA25pbAUEdW5pdAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAlAoCBQNuaWwFBHVuaXQJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BaQEIZmluYWxpemUABANpbnYJAPwHBAUEdGhpcwIPZmluYWxpemVXcmFwcGVyCQDMCAIAAAUDbmlsBQNuaWwDCQAAAgUDaW52BQNpbnYJAJQKAgUDbmlsBQR1bml0CQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAWkBFGNvbnRhaW5zTm9kZVJFQURPTkxZAghsaXN0TmFtZQJpZAkAlAoCBQNuaWwJAQxjb250YWluc05vZGUCBQhsaXN0TmFtZQUCaWQBaQEKaW5zZXJ0Tm9kZQIIbGlzdE5hbWUCaWQEC2NoZWNrQ2FsbGVyCQELbXVzdE1hbmFnZXIBBQFpAwkAAAIFC2NoZWNrQ2FsbGVyBQtjaGVja0NhbGxlcgkAlAoCCQERaW5zZXJ0Tm9kZUFjdGlvbnMCBQhsaXN0TmFtZQUCaWQFBHVuaXQJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BaQEKZGVsZXRlTm9kZQIIbGlzdE5hbWUCaWQEC2NoZWNrQ2FsbGVyCQELbXVzdE1hbmFnZXIBBQFpAwkAAAIFC2NoZWNrQ2FsbGVyBQtjaGVja0NhbGxlcgkAlAoCCQERZGVsZXRlTm9kZUFjdGlvbnMCBQhsaXN0TmFtZQUCaWQFBHVuaXQJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BAnR4AQZ2ZXJpZnkABA90YXJnZXRQdWJsaWNLZXkEByRtYXRjaDAJARZtYW5hZ2VyUHVibGljS2V5T3JVbml0AAMJAAECBQckbWF0Y2gwAgpCeXRlVmVjdG9yBAJwawUHJG1hdGNoMAUCcGsDCQABAgUHJG1hdGNoMAIEVW5pdAgFAnR4D3NlbmRlclB1YmxpY0tleQkAAgECC01hdGNoIGVycm9yCQD0AwMIBQJ0eAlib2R5Qnl0ZXMJAJEDAggFAnR4BnByb29mcwAABQ90YXJnZXRQdWJsaWNLZXmdfGgm",
    "height": 2118929,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: CxzAAN3JwF1JdVC2iMNLuNVTF1rmqKMFbNXqWttDp2f3

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let separator = "__"
5+
6+let poolWeightMult = 100000000
7+
8+let maxDepthDefault = 10
9+
10+let finalizationStageTotal = 0
11+
12+let finalizationStageShares = 1
13+
14+let keyEpochLength = makeString(["%s", "epochLength"], separator)
15+
16+let keyCurrentEpoch = makeString(["%s", "currentEpoch"], separator)
17+
18+let keyMaxDepth = makeString(["%s", "maxDepth"], separator)
19+
20+let keyVotingEmissionCandidateContract = makeString(["%s", "votingEmissionCandidateContract"], separator)
21+
22+let keyFactoryContract = makeString(["%s", "factoryContract"], separator)
23+
24+let keyBoostingContract = makeString(["%s", "boostingContract"], separator)
25+
26+let keyStakingContract = makeString(["%s", "stakingContract"], separator)
27+
28+let keyFinalizationStage = makeString(["%s", "finalizationStage"], separator)
29+
30+let keyNextPool = makeString(["%s", "nextPool"], separator)
31+
32+let keyNextUser = makeString(["%s", "nextUser"], separator)
33+
34+let keyStartHeight = makeString(["%s", "startHeight"], separator)
35+
36+let keyCurrentEpochUi = makeString(["%s", "currentEpochUi"], separator)
37+
38+let keyStartHeightUi = makeString(["%s", "startHeightUi"], separator)
39+
40+func keyStartHeightByEpoch (epoch) = makeString(["%s%d", "startHeight", toString(epoch)], separator)
41+
42+
43+func keyFinalized (epoch) = makeString(["%s%d", "finalized", toString(epoch)], separator)
44+
45+
46+func keyInList (pool) = {
47+    let $t014361476 = pool
48+    let amountAssetId = $t014361476._1
49+    let priceAssetId = $t014361476._2
50+    makeString(["%s%s%s", "inList", amountAssetId, priceAssetId], separator)
51+    }
52+
53+
54+func keyUsed (address,epoch) = makeString(["%s%s%d", "used", toString(address), toString(epoch)], separator)
55+
56+
57+func keyVote (pool,address,epoch) = {
58+    let $t017501790 = pool
59+    let amountAssetId = $t017501790._1
60+    let priceAssetId = $t017501790._2
61+    makeString(["%s%s%s%s%d", "vote", amountAssetId, priceAssetId, toString(address), toString(epoch)], separator)
62+    }
63+
64+
65+func keyVotingResult (pool,epoch) = {
66+    let $t019722012 = pool
67+    let amountAssetId = $t019722012._1
68+    let priceAssetId = $t019722012._2
69+    makeString(["%s%s%s%d", "votingResult", amountAssetId, priceAssetId, toString(epoch)], separator)
70+    }
71+
72+
73+func keyPoolShare (pool,epoch) = {
74+    let $t021772217 = pool
75+    let amountAssetId = $t021772217._1
76+    let priceAssetId = $t021772217._2
77+    makeString(["%s%s%s%d", "poolShare", amountAssetId, priceAssetId, toString(epoch)], separator)
78+    }
79+
80+
81+func keyTotalVotes (epoch) = makeString(["%s%d", "totalVotes", toString(epoch)], separator)
82+
83+
84+func getValueOrFail (address,key,type) = {
85+    let error = makeString(["mandatory ", toString(address), ".", key, " is not defined"], "")
86+    valueOrErrorMessage(    match type {
87+        case str: String => 
88+            getString(address, key)
89+        case int: Int => 
90+            getInteger(address, key)
91+        case _ => 
92+            throw("invalid entry type")
93+    }, error)
94+    }
95+
96+
97+func getStrOrFail (address,key) = {
98+    let @ = getValueOrFail(address, key, "")
99+    if ($isInstanceOf(@, "String"))
100+        then @
101+        else throw(($getType(getValueOrFail(address, key, "")) + " couldn't be cast to String"))
102+    }
103+
104+
105+func getIntOrFail (address,key) = {
106+    let @ = getValueOrFail(address, key, 0)
107+    if ($isInstanceOf(@, "Int"))
108+        then @
109+        else throw(($getType(getValueOrFail(address, key, 0)) + " couldn't be cast to Int"))
110+    }
111+
112+
113+func poolToString (pool) = ((pool._1 + separator) + pool._2)
114+
115+
116+func stringToPool (str) = {
117+    let parts = split(str, separator)
118+    if ((size(parts) == 2))
119+        then $Tuple2(parts[0], parts[1])
120+        else throw("invalid pool string")
121+    }
122+
123+
124+func getLpAssetByPoolAssets (amountAssetId,priceAssetId) = {
125+    func keyMappingsBaseAsset2internalId (baseAssetStr) =     ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
126+
127+    func keyMappingPoolAssetsToPoolContractAddress (internalAmountAssetIdStr,internalPriceAssetIdStr) =     (((("%d%d%s%s__" + toString(internalAmountAssetIdStr)) + "__") + toString(internalPriceAssetIdStr)) + "__mappings__poolAssets2PoolContract")
128+
129+    func keyMappingPoolContractToLPAsset (poolContractAddress) =     (("%s%s%s__" + poolContractAddress) + "__mappings__poolContract2LpAsset")
130+
131+    let factoryContract = addressFromStringValue(getStrOrFail(this, keyFactoryContract))
132+    let amountAssetInternalId = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(amountAssetId))
133+    let priceAssetInternalId = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(priceAssetId))
134+    let poolContractAddress = getStrOrFail(factoryContract, keyMappingPoolAssetsToPoolContractAddress(amountAssetInternalId, priceAssetInternalId))
135+    let lpAssetId = getStrOrFail(factoryContract, keyMappingPoolContractToLPAsset(poolContractAddress))
136+    lpAssetId
137+    }
138+
139+
140+func checkWxEmissionPoolLabel (pool) = {
141+    let $t044594499 = pool
142+    let amountAssetId = $t044594499._1
143+    let priceAssetId = $t044594499._2
144+    let factoryContract = addressFromStringValue(getStrOrFail(this, keyFactoryContract))
145+    let @ = invoke(factoryContract, "checkWxEmissionPoolLabel", [amountAssetId, priceAssetId], nil)
146+    if ($isInstanceOf(@, "Boolean"))
147+        then @
148+        else throw(($getType(invoke(factoryContract, "checkWxEmissionPoolLabel", [amountAssetId, priceAssetId], nil)) + " couldn't be cast to Boolean"))
149+    }
150+
151+
152+let poolsListName = "pools"
153+
154+func getVotesListName (pool) = {
155+    let $t048004840 = pool
156+    let amountAssetId = $t048004840._1
157+    let priceAssetId = $t048004840._2
158+    makeString(["votes", amountAssetId, priceAssetId], separator)
159+    }
160+
161+
162+func keyListHead (listName) = {
163+    let meta = if ((listName == poolsListName))
164+        then "%s%s"
165+        else "%s%s%s%s"
166+    makeString([meta, listName, "head"], separator)
167+    }
168+
169+
170+func keyListSize (listName) = {
171+    let meta = if ((listName == poolsListName))
172+        then "%s%s"
173+        else "%s%s%s%s"
174+    makeString([meta, listName, "size"], separator)
175+    }
176+
177+
178+func keyListPrev (listName,id) = {
179+    let meta = if ((listName == poolsListName))
180+        then "%s%s%s%s"
181+        else "%s%s%s%s%s"
182+    makeString([meta, listName, id, "prev"], separator)
183+    }
184+
185+
186+func keyListNext (listName,id) = {
187+    let meta = if ((listName == poolsListName))
188+        then "%s%s%s%s"
189+        else "%s%s%s%s%s"
190+    makeString([meta, listName, id, "next"], separator)
191+    }
192+
193+
194+func containsNode (listName,id) = {
195+    let headOrUnit = getString(this, keyListHead(listName))
196+    let prevOrUnit = getString(this, keyListPrev(listName, id))
197+    let nextOrUnit = getString(this, keyListNext(listName, id))
198+    if (if ((id == valueOrElse(headOrUnit, "")))
199+        then true
200+        else (prevOrUnit != unit))
201+        then true
202+        else (nextOrUnit != unit)
203+    }
204+
205+
206+func insertNodeActions (listName,id) = {
207+    let headOrUnit = getString(this, keyListHead(listName))
208+    let listSize = valueOrElse(getInteger(this, keyListSize(listName)), 0)
209+    let checkNode = if (!(containsNode(listName, id)))
210+        then true
211+        else throw("Node exists")
212+    if ((checkNode == checkNode))
213+        then (([IntegerEntry(keyListSize(listName), (listSize + 1))] ++ (if ((headOrUnit != unit))
214+            then [StringEntry(keyListNext(listName, id), value(headOrUnit)), StringEntry(keyListPrev(listName, value(headOrUnit)), id)]
215+            else nil)) ++ [StringEntry(keyListHead(listName), id)])
216+        else throw("Strict value is not equal to itself.")
217+    }
218+
219+
220+func deleteNodeActions (listName,id) = {
221+    let headOrUnit = getString(this, keyListHead(listName))
222+    let listSize = valueOrElse(getInteger(this, keyListSize(listName)), 0)
223+    let prevOrUnit = getString(this, keyListPrev(listName, id))
224+    let nextOrUnit = getString(this, keyListNext(listName, id))
225+    ([IntegerEntry(keyListSize(listName), (listSize - 1))] ++ (if (if ((prevOrUnit != unit))
226+        then (nextOrUnit != unit)
227+        else false)
228+        then [StringEntry(keyListNext(listName, value(prevOrUnit)), value(nextOrUnit)), StringEntry(keyListPrev(listName, value(nextOrUnit)), value(prevOrUnit)), DeleteEntry(keyListPrev(listName, id)), DeleteEntry(keyListNext(listName, id))]
229+        else if ((nextOrUnit != unit))
230+            then [StringEntry(keyListHead(listName), value(nextOrUnit)), DeleteEntry(keyListNext(listName, id)), DeleteEntry(keyListPrev(listName, value(nextOrUnit)))]
231+            else if ((prevOrUnit != unit))
232+                then [DeleteEntry(keyListPrev(listName, id)), DeleteEntry(keyListNext(listName, value(prevOrUnit)))]
233+                else if ((id == valueOrElse(headOrUnit, "")))
234+                    then [DeleteEntry(keyListHead(listName))]
235+                    else throw(((("invalid node: " + listName) + ".") + id))))
236+    }
237+
238+
239+func keyManagerPublicKey () = "%s__managerPublicKey"
240+
241+
242+func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
243+
244+
245+func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
246+    case s: String => 
247+        fromBase58String(s)
248+    case _: Unit => 
249+        unit
250+    case _ => 
251+        throw("Match error")
252+}
253+
254+
255+func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
256+    case s: String => 
257+        fromBase58String(s)
258+    case _: Unit => 
259+        unit
260+    case _ => 
261+        throw("Match error")
262+}
263+
264+
265+let permissionDeniedError = throw("Permission denied")
266+
267+func mustThis (i) = if ((i.caller == this))
268+    then true
269+    else permissionDeniedError
270+
271+
272+func mustManager (i) = match managerPublicKeyOrUnit() {
273+    case pk: ByteVector => 
274+        if ((i.callerPublicKey == pk))
275+            then true
276+            else permissionDeniedError
277+    case _: Unit => 
278+        mustThis(i)
279+    case _ => 
280+        throw("Match error")
281+}
282+
283+
284+@Callable(i)
285+func setManager (pendingManagerPublicKey) = {
286+    let checkCaller = mustManager(i)
287+    if ((checkCaller == checkCaller))
288+        then {
289+            let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
290+            if ((checkManagerPublicKey == checkManagerPublicKey))
291+                then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
292+                else throw("Strict value is not equal to itself.")
293+            }
294+        else throw("Strict value is not equal to itself.")
295+    }
296+
297+
298+
299+@Callable(i)
300+func confirmManager () = {
301+    let pm = pendingManagerPublicKeyOrUnit()
302+    let hasPM = if (isDefined(pm))
303+        then true
304+        else throw("No pending manager")
305+    if ((hasPM == hasPM))
306+        then {
307+            let checkPM = if ((i.callerPublicKey == value(pm)))
308+                then true
309+                else throw("You are not pending manager")
310+            if ((checkPM == checkPM))
311+                then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
312+                else throw("Strict value is not equal to itself.")
313+            }
314+        else throw("Strict value is not equal to itself.")
315+    }
316+
317+
318+
319+@Callable(i)
320+func getUserGwxAmountAtHeight (userAddress,targetHeight) = {
321+    let boostingContractAddress = valueOrErrorMessage(addressFromString(getStrOrFail(this, keyBoostingContract)), "invalid boosting contract address")
322+    $Tuple2(nil, {
323+        let @ = invoke(boostingContractAddress, "getUserGwxAmountAtHeightREADONLY", [userAddress, targetHeight], nil)
324+        if ($isInstanceOf(@, "Int"))
325+            then @
326+            else throw(($getType(invoke(boostingContractAddress, "getUserGwxAmountAtHeightREADONLY", [userAddress, targetHeight], nil)) + " couldn't be cast to Int"))
327+        })
328+    }
329+
330+
331+
332+@Callable(i)
333+func constructor (factoryContract,votingEmissionCandidateContract,boostingContract,stakingContract,epochLength) = {
334+    let cheks = [mustManager(i), if ((addressFromString(factoryContract) != unit))
335+        then true
336+        else "invalid factory contract address", if ((addressFromString(votingEmissionCandidateContract) != unit))
337+        then true
338+        else "invalid voting emission candidate contract address", if ((addressFromString(boostingContract) != unit))
339+        then true
340+        else "invalid boosting contract address", if ((addressFromString(stakingContract) != unit))
341+        then true
342+        else "invalid staking contract address", if ((epochLength > 0))
343+        then true
344+        else throw("invalid epoch length")]
345+    if ((cheks == cheks))
346+        then $Tuple2([StringEntry(keyFactoryContract, factoryContract), StringEntry(keyVotingEmissionCandidateContract, votingEmissionCandidateContract), StringEntry(keyBoostingContract, boostingContract), StringEntry(keyStakingContract, stakingContract), IntegerEntry(keyEpochLength, epochLength)], unit)
347+        else throw("Strict value is not equal to itself.")
348+    }
349+
350+
351+
352+@Callable(i)
353+func create (amountAssetId,priceAssetId) = {
354+    let checks = [if ((toBase58String(i.caller.bytes) == valueOrElse(getString(this, keyVotingEmissionCandidateContract), "")))
355+        then true
356+        else mustManager(i)]
357+    if ((checks == checks))
358+        then {
359+            let pool = $Tuple2(amountAssetId, priceAssetId)
360+            let inListActions = ([BooleanEntry(keyInList(pool), true)] ++ insertNodeActions(poolsListName, poolToString(pool)))
361+            let currentEpochIsNotDefined = (getInteger(this, keyCurrentEpoch) == unit)
362+            let startHeightActions = if (currentEpochIsNotDefined)
363+                then {
364+                    let epoch = 0
365+[IntegerEntry(keyCurrentEpoch, epoch), IntegerEntry(keyStartHeightByEpoch(epoch), height), IntegerEntry(keyStartHeight, height), IntegerEntry(keyCurrentEpochUi, epoch), IntegerEntry(keyStartHeightUi, height)]
366+                    }
367+                else nil
368+            $Tuple2((inListActions ++ startHeightActions), unit)
369+            }
370+        else throw("Strict value is not equal to itself.")
371+    }
372+
373+
374+
375+@Callable(i)
376+func vote (amountAssetId,priceAssetId,amount) = {
377+    let pool = $Tuple2(amountAssetId, priceAssetId)
378+    let epoch = valueOrElse(getInteger(this, keyCurrentEpoch), 0)
379+    let startHeight = getIntOrFail(this, keyStartHeightByEpoch(epoch))
380+    let epochLength = getIntOrFail(this, keyEpochLength)
381+    let endHeight = (startHeight + epochLength)
382+    let finalizationStageOrUnit = getInteger(this, keyFinalizationStage)
383+    let used = valueOrElse(getInteger(this, keyUsed(i.caller, epoch)), 0)
384+    let vote = valueOrElse(getInteger(this, keyVote(pool, i.caller, epoch)), 0)
385+    let poolResult = valueOrElse(getInteger(this, keyVotingResult(pool, epoch)), 0)
386+    let totalVotes = valueOrElse(getInteger(this, keyTotalVotes(epoch)), 0)
387+    let gwxAmountAtEndTotal = {
388+        let @ = invoke(this, "getUserGwxAmountAtHeight", [toBase58String(i.caller.bytes), endHeight], nil)
389+        if ($isInstanceOf(@, "Int"))
390+            then @
391+            else throw(($getType(invoke(this, "getUserGwxAmountAtHeight", [toBase58String(i.caller.bytes), endHeight], nil)) + " couldn't be cast to Int"))
392+        }
393+    let available = (gwxAmountAtEndTotal - used)
394+    let newVote = (vote + amount)
395+    let wxEmission = checkWxEmissionPoolLabel(pool)
396+    let checks = [if ((getBoolean(keyInList(pool)) != unit))
397+        then true
398+        else throw("invalid assets"), if ((endHeight > height))
399+        then true
400+        else throw("invalid height"), if ((finalizationStageOrUnit == unit))
401+        then true
402+        else throw("finalization in progress"), if ((gwxAmountAtEndTotal > 0))
403+        then true
404+        else throw("you do not have gWX"), if (if ((amount > 0))
405+        then (available >= amount)
406+        else false)
407+        then true
408+        else throw("invalid amount"), if (wxEmission)
409+        then true
410+        else throw("pool hasn't WX_EMISSION label")]
411+    if ((checks == checks))
412+        then {
413+            let votesListName = getVotesListName(pool)
414+            let userAddressStr = toString(i.caller)
415+            let votesListActions = if (containsNode(votesListName, userAddressStr))
416+                then nil
417+                else insertNodeActions(votesListName, userAddressStr)
418+            $Tuple2(([IntegerEntry(keyUsed(i.caller, epoch), (used + amount)), IntegerEntry(keyVote(pool, i.caller, epoch), newVote), IntegerEntry(keyVotingResult(pool, epoch), (poolResult + amount)), IntegerEntry(keyTotalVotes(epoch), (totalVotes + amount))] ++ votesListActions), unit)
419+            }
420+        else throw("Strict value is not equal to itself.")
421+    }
422+
423+
424+
425+@Callable(i)
426+func cancelVote (amountAssetId,priceAssetId) = {
427+    let pool = $Tuple2(amountAssetId, priceAssetId)
428+    let epoch = valueOrElse(getInteger(this, keyCurrentEpoch), 0)
429+    let startHeight = getIntOrFail(this, keyStartHeightByEpoch(epoch))
430+    let epochLength = getIntOrFail(this, keyEpochLength)
431+    let endHeight = (startHeight + epochLength)
432+    let finalizationStageOrUnit = getInteger(this, keyFinalizationStage)
433+    let used = valueOrElse(getInteger(this, keyUsed(i.caller, epoch)), 0)
434+    let vote = valueOrElse(getInteger(this, keyVote(pool, i.caller, epoch)), 0)
435+    let poolResult = valueOrElse(getInteger(this, keyVotingResult(pool, epoch)), 0)
436+    let totalVotes = valueOrElse(getInteger(this, keyTotalVotes(epoch)), 0)
437+    let checks = [if ((getBoolean(keyInList(pool)) != unit))
438+        then true
439+        else throw("invalid assets"), if ((endHeight > height))
440+        then true
441+        else throw("invalid height"), if ((finalizationStageOrUnit == unit))
442+        then true
443+        else throw("finalization in progress"), if ((vote > 0))
444+        then true
445+        else throw("no vote")]
446+    if ((checks == checks))
447+        then {
448+            let votesListName = getVotesListName(pool)
449+            let userAddressStr = toString(i.caller)
450+            $Tuple2(([IntegerEntry(keyUsed(i.caller, epoch), max([(used - vote), 0])), DeleteEntry(keyVote(pool, i.caller, epoch)), IntegerEntry(keyVotingResult(pool, epoch), (poolResult - vote)), IntegerEntry(keyTotalVotes(epoch), (totalVotes - vote))] ++ deleteNodeActions(votesListName, userAddressStr)), unit)
451+            }
452+        else throw("Strict value is not equal to itself.")
453+    }
454+
455+
456+
457+@Callable(i)
458+func setEpochLength (newEpochLength) = {
459+    let cheks = [mustManager(i), if ((newEpochLength > 0))
460+        then true
461+        else throw("invalid epoch length")]
462+    if ((cheks == cheks))
463+        then $Tuple2([IntegerEntry(keyEpochLength, newEpochLength)], unit)
464+        else throw("Strict value is not equal to itself.")
465+    }
466+
467+
468+
469+@Callable(i)
470+func setMaxDepth (newMaxDepth) = {
471+    let cheks = [mustManager(i), if ((newMaxDepth > 0))
472+        then true
473+        else throw("invalid max depth")]
474+    if ((cheks == cheks))
475+        then $Tuple2([IntegerEntry(keyMaxDepth, newMaxDepth)], unit)
476+        else throw("Strict value is not equal to itself.")
477+    }
478+
479+
480+
481+@Callable(i)
482+func processVoteINTERNAL (poolStr,userAddressStr) = {
483+    let checkCaller = mustThis(i)
484+    if ((checkCaller == checkCaller))
485+        then {
486+            let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), ("processVoteINTERNAL: invalid user address " + userAddressStr))
487+            let epoch = getIntOrFail(this, keyCurrentEpoch)
488+            let epochPrevious = (epoch - 1)
489+            let epochLength = getIntOrFail(this, keyEpochLength)
490+            let startHeight = getIntOrFail(this, keyStartHeightByEpoch(epoch))
491+            let endHeight = (startHeight + epochLength)
492+            let startHeightPrevious = getIntOrFail(this, keyStartHeightByEpoch(epochPrevious))
493+            let endHeightPrevious = (startHeightPrevious + epochLength)
494+            let checkTargetEpoch = if ((epochPrevious >= 0))
495+                then true
496+                else throw("processVoteINTERNAL: invalid previous epoch")
497+            if ((checkTargetEpoch == checkTargetEpoch))
498+                then {
499+                    let pool = stringToPool(poolStr)
500+                    let $t01712617166 = pool
501+                    let amountAssetId = $t01712617166._1
502+                    let priceAssetId = $t01712617166._2
503+                    let wxEmission = checkWxEmissionPoolLabel(pool)
504+                    let gwxAmountAtEndTotal = {
505+                        let @ = invoke(this, "getUserGwxAmountAtHeight", [userAddressStr, endHeight], nil)
506+                        if ($isInstanceOf(@, "Int"))
507+                            then @
508+                            else throw(($getType(invoke(this, "getUserGwxAmountAtHeight", [userAddressStr, endHeight], nil)) + " couldn't be cast to Int"))
509+                        }
510+                    let gwxAmountAtEndTotalPrevious = {
511+                        let @ = invoke(this, "getUserGwxAmountAtHeight", [userAddressStr, endHeightPrevious], nil)
512+                        if ($isInstanceOf(@, "Int"))
513+                            then @
514+                            else throw(($getType(invoke(this, "getUserGwxAmountAtHeight", [userAddressStr, endHeightPrevious], nil)) + " couldn't be cast to Int"))
515+                        }
516+                    let totalVotes = valueOrElse(getInteger(keyTotalVotes(epoch)), 0)
517+                    let votingResult = valueOrElse(getInteger(keyVotingResult(pool, epoch)), 0)
518+                    let votePrevious = valueOrErrorMessage(getInteger(keyVote(pool, userAddress, epochPrevious)), (((("processVoteINTERNAL " + poolStr) + " ") + userAddressStr) + ": no previous vote"))
519+                    let used = valueOrElse(getInteger(this, keyUsed(userAddress, epoch)), 0)
520+                    let newVote = fraction(votePrevious, gwxAmountAtEndTotal, gwxAmountAtEndTotalPrevious)
521+                    let actions = if (if ((newVote > 0))
522+                        then wxEmission
523+                        else false)
524+                        then [IntegerEntry(keyVote(pool, userAddress, epoch), newVote), IntegerEntry(keyTotalVotes(epoch), (totalVotes + newVote)), IntegerEntry(keyVotingResult(pool, epoch), (votingResult + newVote)), IntegerEntry(keyUsed(userAddress, epoch), (used + newVote))]
525+                        else deleteNodeActions(getVotesListName(pool), userAddressStr)
526+                    $Tuple2(actions, unit)
527+                    }
528+                else throw("Strict value is not equal to itself.")
529+            }
530+        else throw("Strict value is not equal to itself.")
531+    }
532+
533+
534+
535+@Callable(i)
536+func processPoolINTERNAL (poolStr) = {
537+    let checkCaller = mustThis(i)
538+    if ((checkCaller == checkCaller))
539+        then {
540+            let targetEpoch = (getIntOrFail(this, keyCurrentEpoch) - 1)
541+            let checkTargetEpoch = if ((targetEpoch >= 0))
542+                then true
543+                else throw("processPoolINTERNAL: invalid target epoch")
544+            if ((checkTargetEpoch == checkTargetEpoch))
545+                then {
546+                    let pool = stringToPool(poolStr)
547+                    let $t01868318723 = pool
548+                    let amountAssetId = $t01868318723._1
549+                    let priceAssetId = $t01868318723._2
550+                    let stakingContract = addressFromStringValue(getStrOrFail(this, keyStakingContract))
551+                    let factoryContract = addressFromStringValue(getStrOrFail(this, keyFactoryContract))
552+                    let lpAssetId = getLpAssetByPoolAssets(amountAssetId, priceAssetId)
553+                    let r = {
554+                        let @ = invoke(stakingContract, "usersListTraversal", [lpAssetId], nil)
555+                        if ($isInstanceOf(@, "Boolean"))
556+                            then @
557+                            else throw(($getType(invoke(stakingContract, "usersListTraversal", [lpAssetId], nil)) + " couldn't be cast to Boolean"))
558+                        }
559+                    if ((r == r))
560+                        then if (r)
561+                            then $Tuple2(nil, true)
562+                            else {
563+                                let wxEmission = checkWxEmissionPoolLabel(pool)
564+                                let totalVotes = valueOrElse(getInteger(this, keyTotalVotes(targetEpoch)), 0)
565+                                let votingResult = valueOrElse(getInteger(this, keyVotingResult(pool, targetEpoch)), 0)
566+                                let share = if (if ((totalVotes == 0))
567+                                    then true
568+                                    else !(wxEmission))
569+                                    then 0
570+                                    else fraction(votingResult, poolWeightMult, totalVotes)
571+                                let modifyWeightInv = invoke(factoryContract, "modifyWeight", [lpAssetId, share], nil)
572+                                if ((modifyWeightInv == modifyWeightInv))
573+                                    then {
574+                                        let poolsListActions = if (wxEmission)
575+                                            then nil
576+                                            else ([DeleteEntry(keyInList(pool))] ++ deleteNodeActions(poolsListName, poolStr))
577+                                        $Tuple2(([IntegerEntry(keyPoolShare(pool, targetEpoch), share)] ++ poolsListActions), false)
578+                                        }
579+                                    else throw("Strict value is not equal to itself.")
580+                                }
581+                        else throw("Strict value is not equal to itself.")
582+                    }
583+                else throw("Strict value is not equal to itself.")
584+            }
585+        else throw("Strict value is not equal to itself.")
586+    }
587+
588+
589+
590+@Callable(i)
591+func finalizeHelper () = {
592+    let epoch = valueOrElse(getInteger(this, keyCurrentEpoch), 0)
593+    let previousEpoch = (epoch - 1)
594+    let startHeight = getIntOrFail(this, keyStartHeightByEpoch(epoch))
595+    let epochLength = getIntOrFail(this, keyEpochLength)
596+    let endHeight = (startHeight + epochLength)
597+    let finalizationStageOrUnit = getInteger(this, keyFinalizationStage)
598+    if (if ((height >= endHeight))
599+        then (finalizationStageOrUnit == unit)
600+        else false)
601+        then {
602+            let newEpoch = (epoch + 1)
603+            $Tuple2([IntegerEntry(keyStartHeightByEpoch(newEpoch), height), IntegerEntry(keyStartHeight, height), IntegerEntry(keyCurrentEpoch, newEpoch), IntegerEntry(keyFinalizationStage, finalizationStageTotal)], true)
604+            }
605+        else if ((finalizationStageOrUnit == unit))
606+            then $Tuple2(nil, false)
607+            else if ((finalizationStageOrUnit == finalizationStageTotal))
608+                then {
609+                    let poolOrUnit = getString(keyNextPool)
610+                    let userOrUnit = getString(keyNextUser)
611+                    match poolOrUnit {
612+                        case _: Unit => 
613+                            match getString(keyListHead(poolsListName)) {
614+                                case _: Unit => 
615+                                    $Tuple2([IntegerEntry(keyFinalizationStage, finalizationStageShares), DeleteEntry(keyNextPool), DeleteEntry(keyNextUser)], true)
616+                                case poolsHeadStr: String => 
617+                                    $Tuple2([StringEntry(keyNextPool, poolsHeadStr)], true)
618+                                case _ => 
619+                                    throw("Match error")
620+                            }
621+                        case poolStr: String => 
622+                            let pool = stringToPool(poolStr)
623+                            let nextUserOrUnit =                             match userOrUnit {
624+                                case _: Unit => 
625+                                    getString(keyListHead(getVotesListName(pool)))
626+                                case user: String => 
627+                                    let processVoteInv = invoke(this, "processVoteINTERNAL", [poolStr, user], nil)
628+                                    if ((processVoteInv == processVoteInv))
629+                                        then getString(keyListNext(getVotesListName(pool), user))
630+                                        else throw("Strict value is not equal to itself.")
631+                                case _ => 
632+                                    throw("Match error")
633+                            }
634+                            match nextUserOrUnit {
635+                                case _: Unit => 
636+                                    let nextPoolOrUnit = getString(keyListNext(poolsListName, poolStr))
637+                                    match nextPoolOrUnit {
638+                                        case _: Unit => 
639+                                            $Tuple2([IntegerEntry(keyFinalizationStage, finalizationStageShares), DeleteEntry(keyNextPool), DeleteEntry(keyNextUser)], true)
640+                                        case s: String => 
641+                                            $Tuple2([StringEntry(keyNextPool, s), DeleteEntry(keyNextUser)], true)
642+                                        case _ => 
643+                                            throw("Match error")
644+                                    }
645+                                case nextUser: String => 
646+                                    $Tuple2([StringEntry(keyNextUser, nextUser)], true)
647+                                case _ => 
648+                                    throw("Match error")
649+                            }
650+                        case _ => 
651+                            throw("Match error")
652+                    }
653+                    }
654+                else if ((finalizationStageOrUnit == finalizationStageShares))
655+                    then {
656+                        let poolOrUnit = getString(keyNextPool)
657+                        match poolOrUnit {
658+                            case _: Unit => 
659+                                match getString(keyListHead(poolsListName)) {
660+                                    case _: Unit => 
661+                                        $Tuple2([DeleteEntry(keyFinalizationStage), BooleanEntry(keyFinalized(previousEpoch), true), IntegerEntry(keyCurrentEpochUi, epoch), IntegerEntry(keyStartHeightUi, startHeight)], true)
662+                                    case nextPoolStr: String => 
663+                                        $Tuple2([StringEntry(keyNextPool, nextPoolStr)], true)
664+                                    case _ => 
665+                                        throw("Match error")
666+                                }
667+                            case poolStr: String => 
668+                                let r = {
669+                                    let @ = invoke(this, "processPoolINTERNAL", [poolStr], nil)
670+                                    if ($isInstanceOf(@, "Boolean"))
671+                                        then @
672+                                        else throw(($getType(invoke(this, "processPoolINTERNAL", [poolStr], nil)) + " couldn't be cast to Boolean"))
673+                                    }
674+                                if ((r == r))
675+                                    then if (r)
676+                                        then $Tuple2(nil, true)
677+                                        else {
678+                                            let nextPoolOrUnit = getString(keyListNext(poolsListName, poolStr))
679+                                            match nextPoolOrUnit {
680+                                                case _: Unit => 
681+                                                    $Tuple2([DeleteEntry(keyFinalizationStage), BooleanEntry(keyFinalized(previousEpoch), true), IntegerEntry(keyCurrentEpochUi, epoch), IntegerEntry(keyStartHeightUi, startHeight), DeleteEntry(keyNextPool)], true)
682+                                                case nextPoolStr: String => 
683+                                                    $Tuple2([StringEntry(keyNextPool, nextPoolStr)], true)
684+                                                case _ => 
685+                                                    throw("Match error")
686+                                            }
687+                                            }
688+                                    else throw("Strict value is not equal to itself.")
689+                            case _ => 
690+                                throw("Match error")
691+                        }
692+                        }
693+                    else throw("finalization is broken")
694+    }
695+
696+
697+
698+@Callable(i)
699+func finalizeWrapper (counter) = {
700+    let result = {
701+        let @ = invoke(this, "finalizeHelper", nil, nil)
702+        if ($isInstanceOf(@, "Boolean"))
703+            then @
704+            else throw(($getType(invoke(this, "finalizeHelper", nil, nil)) + " couldn't be cast to Boolean"))
705+        }
706+    if ((result == result))
707+        then if (!(result))
708+            then if ((counter == 0))
709+                then throw("Current voting is not over yet")
710+                else $Tuple2(nil, unit)
711+            else {
712+                let maxDepth = valueOrElse(getInteger(this, keyMaxDepth), maxDepthDefault)
713+                if ((maxDepth > counter))
714+                    then {
715+                        let inv = invoke(this, "finalizeWrapper", [(counter + 1)], nil)
716+                        if ((inv == inv))
717+                            then $Tuple2(nil, unit)
718+                            else throw("Strict value is not equal to itself.")
719+                        }
720+                    else $Tuple2(nil, unit)
721+                }
722+        else throw("Strict value is not equal to itself.")
723+    }
724+
725+
726+
727+@Callable(i)
728+func finalize () = {
729+    let inv = invoke(this, "finalizeWrapper", [0], nil)
730+    if ((inv == inv))
731+        then $Tuple2(nil, unit)
732+        else throw("Strict value is not equal to itself.")
733+    }
734+
735+
736+
737+@Callable(i)
738+func containsNodeREADONLY (listName,id) = $Tuple2(nil, containsNode(listName, id))
739+
740+
741+
742+@Callable(i)
743+func insertNode (listName,id) = {
744+    let checkCaller = mustManager(i)
745+    if ((checkCaller == checkCaller))
746+        then $Tuple2(insertNodeActions(listName, id), unit)
747+        else throw("Strict value is not equal to itself.")
748+    }
749+
750+
751+
752+@Callable(i)
753+func deleteNode (listName,id) = {
754+    let checkCaller = mustManager(i)
755+    if ((checkCaller == checkCaller))
756+        then $Tuple2(deleteNodeActions(listName, id), unit)
757+        else throw("Strict value is not equal to itself.")
758+    }
759+
760+
761+@Verifier(tx)
762+func verify () = {
763+    let targetPublicKey =     match managerPublicKeyOrUnit() {
764+        case pk: ByteVector => 
765+            pk
766+        case _: Unit => 
767+            tx.senderPublicKey
768+        case _ => 
769+            throw("Match error")
770+    }
771+    sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
772+    }
773+
github/deemru/w8io/169f3d6 
66.56 ms ◑