tx · 9YvYEjSSYcG86ZBHXpYJgBadGqnr8yDKpAnfd1Ba4mMW

3N9pbsCDHmJAsHgtasRQCrogBueodSvtus3:  -0.03200000 Waves

2023.03.10 12:29 [2483798] smart account 3N9pbsCDHmJAsHgtasRQCrogBueodSvtus3 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "9YvYEjSSYcG86ZBHXpYJgBadGqnr8yDKpAnfd1Ba4mMW",
    "fee": 3200000,
    "feeAssetId": null,
    "timestamp": 1678440651862,
    "version": 2,
    "chainId": 84,
    "sender": "3N9pbsCDHmJAsHgtasRQCrogBueodSvtus3",
    "senderPublicKey": "EQ9pA2xqcqddvVd5UR8qUVnF6wvKyjeJV4KVr3nFvxmq",
    "proofs": [
        "5s3kmoCokuEUUJ9sjgvsCZ8oC8HvqgBWQbgMza24jhxgwfvpBSR5ARSNAdzbvEBoiZpaYU4JmZbKEsQhFYBPUpyc"
    ],
    "script": "base64:BgJHCAISCAoGCAgBAQEIEgUKAwEIAhIDCgEBEgMKAQESBAoCCAgSBAoCCAgSAwoBCBIDCgEIEgMKAQgSBAoCCAESABIDCgEIEgBxAANTRVACAl9fAAZTQ0FMRTgACAAFTVVMVDgAgMLXLwAOUE9PTFdFSUdIVE1VTFQFBU1VTFQ4AQd3cmFwRXJyAQNtc2cJALkJAgkAzAgCAg5ib29zdGluZy5yaWRlOgkAzAgCBQNtc2cFA25pbAIBIAEIdGhyb3dFcnIBA21zZwkAAgEJAQd3cmFwRXJyAQUDbXNnAQRzdHJmAgdhZGRyZXNzA2tleQkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCdCAIFB2FkZHJlc3MFA2tleQkArAICCQCsAgICD21hbmRhdG9yeSB0aGlzLgUDa2V5Ag8gaXMgbm90IGRlZmluZWQBA2lvegIHYWRkcmVzcwNrZXkJAQt2YWx1ZU9yRWxzZQIJAJoIAgUHYWRkcmVzcwUDa2V5AAABA2lvZAMHYWRkcmVzcwNrZXkKZGVmYXVsdFZhbAkBC3ZhbHVlT3JFbHNlAgkAmggCBQdhZGRyZXNzBQNrZXkFCmRlZmF1bHRWYWwBA2lvZgIHYWRkcmVzcwNrZXkJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAmggCBQdhZGRyZXNzBQNrZXkJAKwCAgkArAICAg9tYW5kYXRvcnkgdGhpcy4FA2tleQIPIGlzIG5vdCBkZWZpbmVkAQNhYnMBA3ZhbAMJAGYCAAAFA3ZhbAkBAS0BBQN2YWwFA3ZhbAEDYWFsAQN2YWwEByRtYXRjaDAFA3ZhbAMJAAECBQckbWF0Y2gwAglMaXN0W0FueV0ECnZhbEFueUx5c3QFByRtYXRjaDAFCnZhbEFueUx5c3QJAAIBAhtmYWlsIHRvIGNhc3QgaW50byBMaXN0W0FueV0BAmFpAQN2YWwEByRtYXRjaDAFA3ZhbAMJAAECBQckbWF0Y2gwAgNJbnQEBnZhbEludAUHJG1hdGNoMAUGdmFsSW50CQACAQIVZmFpbCB0byBjYXN0IGludG8gSW50ARtrZXlSZWZlcnJhbHNDb250cmFjdEFkZHJlc3MACQC5CQIJAMwIAgIEJXMlcwkAzAgCAgZjb25maWcJAMwIAgIYcmVmZXJyYWxzQ29udHJhY3RBZGRyZXNzBQNuaWwFA1NFUAAecmVmZXJyYWxzQ29udHJhY3RBZGRyZXNzT3JGYWlsCQERQGV4dHJOYXRpdmUoMTA2MikBCQEEc3RyZgIFBHRoaXMJARtrZXlSZWZlcnJhbHNDb250cmFjdEFkZHJlc3MAABZrZXlSZWZlcnJhbFByb2dyYW1OYW1lCQC5CQIJAMwIAgIEJXMlcwkAzAgCAghyZWZlcnJhbAkAzAgCAgtwcm9ncmFtTmFtZQUDbmlsBQNTRVAAGnJlZmVycmFsUHJvZ3JhbU5hbWVEZWZhdWx0AgZ3eGxvY2sAE3JlZmVycmFsUHJvZ3JhbU5hbWUJAQt2YWx1ZU9yRWxzZQIJAJ0IAgUEdGhpcwUWa2V5UmVmZXJyYWxQcm9ncmFtTmFtZQUacmVmZXJyYWxQcm9ncmFtTmFtZURlZmF1bHQBEWtleUZhY3RvcnlBZGRyZXNzAAIcJXMlc19fY29uZmlnX19mYWN0b3J5QWRkcmVzcwAYSWR4RmFjdG9yeUNmZ1N0YWtpbmdEYXBwAAEAGUlkeEZhY3RvcnlDZmdCb29zdGluZ0RhcHAAAgAUSWR4RmFjdG9yeUNmZ0lkb0RhcHAAAwAVSWR4RmFjdG9yeUNmZ1RlYW1EYXBwAAQAGUlkeEZhY3RvcnlDZmdFbWlzc2lvbkRhcHAABQAVSWR4RmFjdG9yeUNmZ1Jlc3REYXBwAAYAGUlkeEZhY3RvcnlDZmdTbGlwcGFnZURhcHAABwAUSWR4RmFjdG9yeUNmZ0Rhb0RhcHAACAAaSWR4RmFjdG9yeUNmZ01hcmtldGluZ0RhcHAACQAaSWR4RmFjdG9yeUNmZ0d3eFJld2FyZERhcHAACgAWSWR4RmFjdG9yeUNmZ0JpcmRzRGFwcAALAQ1rZXlGYWN0b3J5Q2ZnAAIRJXNfX2ZhY3RvcnlDb25maWcBGmtleUZhY3RvcnlMcDJBc3NldHNNYXBwaW5nAQpscEFzc2V0U3RyCQC5CQIJAMwIAgIGJXMlcyVzCQDMCAIFCmxwQXNzZXRTdHIJAMwIAgIebWFwcGluZ3NfX2xwQXNzZXQyUG9vbENvbnRyYWN0BQNuaWwFA1NFUAEQa2V5RmFjdG9yeUxwTGlzdAACECVzX19scFRva2Vuc0xpc3QBJmtleUZhY3RvcnlMcEFzc2V0VG9Qb29sQ29udHJhY3RBZGRyZXNzAQpscEFzc2V0U3RyCQC5CQIJAMwIAgIGJXMlcyVzCQDMCAIFCmxwQXNzZXRTdHIJAMwIAgIebWFwcGluZ3NfX2xwQXNzZXQyUG9vbENvbnRyYWN0BQNuaWwFA1NFUAEUa2V5RmFjdG9yeVBvb2xXZWlnaHQBD2NvbnRyYWN0QWRkcmVzcwkAuQkCCQDMCAICBCVzJXMJAMwIAgIKcG9vbFdlaWdodAkAzAgCBQ9jb250cmFjdEFkZHJlc3MFA25pbAUDU0VQARtrZXlGYWN0b3J5UG9vbFdlaWdodEhpc3RvcnkCC3Bvb2xBZGRyZXNzA251bQkArAICCQCsAgIJAKwCAgISJXMlc19fcG9vbFdlaWdodF9fBQtwb29sQWRkcmVzcwICX18JAKQDAQUDbnVtARhyZWFkRmFjdG9yeUFkZHJlc3NPckZhaWwACQERQGV4dHJOYXRpdmUoMTA2MikBCQEEc3RyZgIFBHRoaXMJARFrZXlGYWN0b3J5QWRkcmVzcwABCnJlYWRMcExpc3QACQC1CQIJAQt2YWx1ZU9yRWxzZQIJAJ0IAgkBGHJlYWRGYWN0b3J5QWRkcmVzc09yRmFpbAAJARBrZXlGYWN0b3J5THBMaXN0AAIABQNTRVABFHJlYWRGYWN0b3J5Q2ZnT3JGYWlsAQdmYWN0b3J5CQC1CQIJAQRzdHJmAgUHZmFjdG9yeQkBDWtleUZhY3RvcnlDZmcABQNTRVABGGdldEJvb3N0aW5nQWRkcmVzc09yRmFpbAEKZmFjdG9yeUNmZwkBEUBleHRyTmF0aXZlKDEwNjIpAQkAkQMCBQpmYWN0b3J5Q2ZnBRlJZHhGYWN0b3J5Q2ZnQm9vc3RpbmdEYXBwARhnZXRFbWlzc2lvbkFkZHJlc3NPckZhaWwBCmZhY3RvcnlDZmcJARFAZXh0ck5hdGl2ZSgxMDYyKQEJAJEDAgUKZmFjdG9yeUNmZwUZSWR4RmFjdG9yeUNmZ0VtaXNzaW9uRGFwcAEXZ2V0U3Rha2luZ0FkZHJlc3NPckZhaWwBCmZhY3RvcnlDZmcJARFAZXh0ck5hdGl2ZSgxMDYyKQEJAJEDAgUKZmFjdG9yeUNmZwUYSWR4RmFjdG9yeUNmZ1N0YWtpbmdEYXBwARlnZXRHd3hSZXdhcmRBZGRyZXNzT3JGYWlsAQpmYWN0b3J5Q2ZnCQERQGV4dHJOYXRpdmUoMTA2MikBCQCRAwIFCmZhY3RvcnlDZmcFGklkeEZhY3RvcnlDZmdHd3hSZXdhcmREYXBwARNrZXlNYW5hZ2VyUHVibGljS2V5AAIUJXNfX21hbmFnZXJQdWJsaWNLZXkBGmtleVBlbmRpbmdNYW5hZ2VyUHVibGljS2V5AAIbJXNfX3BlbmRpbmdNYW5hZ2VyUHVibGljS2V5AR5rZXlFbWlzc2lvblJhdGVQZXJCbG9ja0N1cnJlbnQAAhslcyVzX19yYXRlUGVyQmxvY2tfX2N1cnJlbnQBIWtleUVtaXNzaW9uUmF0ZVBlckJsb2NrTWF4Q3VycmVudAACHiVzJXNfX3JhdGVQZXJCbG9ja01heF9fY3VycmVudAEVa2V5RW1pc3Npb25TdGFydEJsb2NrAAIaJXMlc19fZW1pc3Npb25fX3N0YXJ0QmxvY2sBG2tleUVtaXNzaW9uRHVyYXRpb25JbkJsb2NrcwACGCVzJXNfX2VtaXNzaW9uX19kdXJhdGlvbgETa2V5RW1pc3Npb25FbmRCbG9jawACGCVzJXNfX2VtaXNzaW9uX19lbmRCbG9jawENa2V5TmV4dFBlcmlvZAACDiVzX19uZXh0UGVyaW9kAR9rZXlHd3hSZXdhcmRFbWlzc2lvblN0YXJ0SGVpZ2h0AAIoJXMlc19fZ3d4UmV3YXJkRW1pc3Npb25QYXJ0X19zdGFydEhlaWdodAANSWR4Q2ZnQXNzZXRJZAABABNJZHhDZmdNaW5Mb2NrQW1vdW50AAIAFUlkeENmZ01pbkxvY2tEdXJhdGlvbgADABVJZHhDZmdNYXhMb2NrRHVyYXRpb24ABAASSWR4Q2ZnTWF0aENvbnRyYWN0AAUBCWtleUNvbmZpZwACCiVzX19jb25maWcBFXJlYWRDb25maWdBcnJheU9yRmFpbAAJALUJAgkBBHN0cmYCBQR0aGlzCQEJa2V5Q29uZmlnAAUDU0VQAAxtYXRoQ29udHJhY3QJARFAZXh0ck5hdGl2ZSgxMDYyKQEJAJEDAgkBFXJlYWRDb25maWdBcnJheU9yRmFpbAAFEklkeENmZ01hdGhDb250cmFjdAENZm9ybWF0Q29uZmlnUwUHYXNzZXRJZA1taW5Mb2NrQW1vdW50D21pbkxvY2tEdXJhdGlvbg9tYXhMb2NrRHVyYXRpb24MbWF0aENvbnRyYWN0CQC5CQIJAMwIAgIIJXMlZCVkJWQJAMwIAgUHYXNzZXRJZAkAzAgCBQ1taW5Mb2NrQW1vdW50CQDMCAIFD21pbkxvY2tEdXJhdGlvbgkAzAgCBQ9tYXhMb2NrRHVyYXRpb24JAMwIAgUMbWF0aENvbnRyYWN0BQNuaWwFA1NFUAEMZm9ybWF0Q29uZmlnBQdhc3NldElkDW1pbkxvY2tBbW91bnQPbWluTG9ja0R1cmF0aW9uD21heExvY2tEdXJhdGlvbgxtYXRoQ29udHJhY3QJAQ1mb3JtYXRDb25maWdTBQUHYXNzZXRJZAkApAMBBQ1taW5Mb2NrQW1vdW50CQCkAwEFD21pbkxvY2tEdXJhdGlvbgkApAMBBQ9tYXhMb2NrRHVyYXRpb24FDG1hdGhDb250cmFjdAEWbWFuYWdlclB1YmxpY0tleU9yVW5pdAAEByRtYXRjaDAJAKIIAQkBE2tleU1hbmFnZXJQdWJsaWNLZXkAAwkAAQIFByRtYXRjaDACBlN0cmluZwQBcwUHJG1hdGNoMAkA2QQBBQFzAwkAAQIFByRtYXRjaDACBFVuaXQFBHVuaXQJAAIBAgtNYXRjaCBlcnJvcgEdcGVuZGluZ01hbmFnZXJQdWJsaWNLZXlPclVuaXQABAckbWF0Y2gwCQCiCAEJARprZXlQZW5kaW5nTWFuYWdlclB1YmxpY0tleQADCQABAgUHJG1hdGNoMAIGU3RyaW5nBAFzBQckbWF0Y2gwCQDZBAEFAXMDCQABAgUHJG1hdGNoMAIEVW5pdAUEdW5pdAkAAgECC01hdGNoIGVycm9yAQttdXN0TWFuYWdlcgEBaQQCcGQJAAIBAhFQZXJtaXNzaW9uIGRlbmllZAQHJG1hdGNoMAkBFm1hbmFnZXJQdWJsaWNLZXlPclVuaXQAAwkAAQIFByRtYXRjaDACCkJ5dGVWZWN0b3IEAnBrBQckbWF0Y2gwAwkAAAIIBQFpD2NhbGxlclB1YmxpY0tleQUCcGsGBQJwZAMJAAECBQckbWF0Y2gwAgRVbml0AwkAAAIIBQFpBmNhbGxlcgUEdGhpcwYFAnBkCQACAQILTWF0Y2ggZXJyb3IADklkeExvY2tVc2VyTnVtAAEADUlkeExvY2tBbW91bnQAAgAMSWR4TG9ja1N0YXJ0AAMAD0lkeExvY2tEdXJhdGlvbgAEAA1JZHhMb2NrUGFyYW1LAAUADUlkeExvY2tQYXJhbUIABgETa2V5TG9ja1BhcmFtc1JlY29yZAELdXNlckFkZHJlc3MJALkJAgkAzAgCAgolcyVzX19sb2NrCQDMCAIFC3VzZXJBZGRyZXNzBQNuaWwFA1NFUAEacmVhZExvY2tQYXJhbXNSZWNvcmRPckZhaWwBC3VzZXJBZGRyZXNzCQC1CQIJAQRzdHJmAgUEdGhpcwkBE2tleUxvY2tQYXJhbXNSZWNvcmQBBQt1c2VyQWRkcmVzcwUDU0VQARdmb3JtYXRMb2NrUGFyYW1zUmVjb3JkUwgHdXNlck51bQZhbW91bnQFc3RhcnQIZHVyYXRpb24GcGFyYW1LBnBhcmFtQhBsYXN0VXBkVGltZXN0YW1wCWd3eEFtb3VudAkAuQkCCQDMCAICECVkJWQlZCVkJWQlZCVkJWQJAMwIAgUHdXNlck51bQkAzAgCBQZhbW91bnQJAMwIAgUFc3RhcnQJAMwIAgUIZHVyYXRpb24JAMwIAgUGcGFyYW1LCQDMCAIFBnBhcmFtQgkAzAgCBRBsYXN0VXBkVGltZXN0YW1wCQDMCAIFCWd3eEFtb3VudAUDbmlsBQNTRVABFmZvcm1hdExvY2tQYXJhbXNSZWNvcmQHB3VzZXJOdW0GYW1vdW50BXN0YXJ0CGR1cmF0aW9uBnBhcmFtSwZwYXJhbUIJZ3d4QW1vdW50CQEXZm9ybWF0TG9ja1BhcmFtc1JlY29yZFMIBQd1c2VyTnVtCQCkAwEFBmFtb3VudAkApAMBBQVzdGFydAkApAMBBQhkdXJhdGlvbgkApAMBBQZwYXJhbUsJAKQDAQUGcGFyYW1CCQCkAwEIBQlsYXN0QmxvY2sJdGltZXN0YW1wCQCkAwEFCWd3eEFtb3VudAEOa2V5TmV4dFVzZXJOdW0AAg8lc19fbmV4dFVzZXJOdW0BEmtleVVzZXIyTnVtTWFwcGluZwELdXNlckFkZHJlc3MJALkJAgkAzAgCAhklcyVzJXNfX21hcHBpbmdfX3VzZXIybnVtCQDMCAIFC3VzZXJBZGRyZXNzBQNuaWwFA1NFUAESa2V5TnVtMlVzZXJNYXBwaW5nAQNudW0JALkJAgkAzAgCAhklcyVzJXNfX21hcHBpbmdfX251bTJ1c2VyCQDMCAIFA251bQUDbmlsBQNTRVABFmtleUxvY2tQYXJhbVVzZXJBbW91bnQBB3VzZXJOdW0JALkJAgkAzAgCAhYlcyVkJXNfX3BhcmFtQnlVc2VyTnVtCQDMCAIFB3VzZXJOdW0JAMwIAgIGYW1vdW50BQNuaWwFA1NFUAEWa2V5TG9ja1BhcmFtU3RhcnRCbG9jawEHdXNlck51bQkAuQkCCQDMCAICFiVzJWQlc19fcGFyYW1CeVVzZXJOdW0JAMwIAgUHdXNlck51bQkAzAgCAgVzdGFydAUDbmlsBQNTRVABFGtleUxvY2tQYXJhbUR1cmF0aW9uAQd1c2VyTnVtCQC5CQIJAMwIAgIWJXMlZCVzX19wYXJhbUJ5VXNlck51bQkAzAgCBQd1c2VyTnVtCQDMCAICCGR1cmF0aW9uBQNuaWwFA1NFUAENa2V5TG9ja1BhcmFtSwEHdXNlck51bQkAuQkCCQDMCAICFiVzJWQlc19fcGFyYW1CeVVzZXJOdW0JAMwIAgUHdXNlck51bQkAzAgCAgFrBQNuaWwFA1NFUAENa2V5TG9ja1BhcmFtQgEHdXNlck51bQkAuQkCCQDMCAICFiVzJWQlc19fcGFyYW1CeVVzZXJOdW0JAMwIAgUHdXNlck51bQkAzAgCAgFiBQNuaWwFA1NFUAEVa2V5TG9ja1BhcmFtQnlQZXJpb2RLAgd1c2VyTnVtBnBlcmlvZAkAuQkCCQDMCAICFyVzJWQlcyVkX19wYXJhbUJ5UGVyaW9kCQDMCAIFB3VzZXJOdW0JAMwIAgIBawkAzAgCBQZwZXJpb2QFA25pbAUDU0VQARVrZXlMb2NrUGFyYW1CeVBlcmlvZEICB3VzZXJOdW0GcGVyaW9kCQC5CQIJAMwIAgIXJXMlZCVzJWRfX3BhcmFtQnlQZXJpb2QJAMwIAgUHdXNlck51bQkAzAgCAgFiCQDMCAIFBnBlcmlvZAUDbmlsBQNTRVABF2tleUxvY2tQYXJhbVRvdGFsQW1vdW50AAIeJXMlc19fc3RhdHNfX2FjdGl2ZVRvdGFsTG9ja2VkASBrZXlTdGF0c0xvY2tzRHVyYXRpb25TdW1JbkJsb2NrcwACJSVzJXNfX3N0YXRzX19sb2Nrc0R1cmF0aW9uU3VtSW5CbG9ja3MBEmtleVN0YXRzTG9ja3NDb3VudAACFyVzJXNfX3N0YXRzX19sb2Nrc0NvdW50ARJrZXlTdGF0c1VzZXJzQ291bnQAAh0lcyVzX19zdGF0c19fYWN0aXZlVXNlcnNDb3VudAEga2V5VXNlckJvb3N0RW1pc3Npb25MYXN0SU5URUdSQUwBB3VzZXJOdW0JALkJAgkAzAgCAh4lcyVkX191c2VyQm9vc3RFbWlzc2lvbkxhc3RJbnQJAMwIAgUHdXNlck51bQUDbmlsBQNTRVABImtleVVzZXJMcEJvb3N0RW1pc3Npb25MYXN0SU5URUdSQUwCB3VzZXJOdW0JbHBBc3NldElkCQC5CQIJAMwIAgIeJXMlZF9fdXNlckJvb3N0RW1pc3Npb25MYXN0SW50CQDMCAIFB3VzZXJOdW0JAMwIAgUJbHBBc3NldElkBQNuaWwFA1NFUAEXa2V5VXNlck1heEJvb3N0SU5URUdSQUwBB3VzZXJOdW0JALkJAgkAzAgCAhElcyVkX19tYXhCb29zdEludAkAzAgCBQd1c2VyTnVtBQNuaWwFA1NFUAEYa2V5VG90YWxNYXhCb29zdElOVEVHUkFMAAIYJXMlc19fbWF4Qm9vc3RJbnRfX3RvdGFsASFrZXlVc2VyQm9vc3RBdmFsYWlibGVUb0NsYWltVG90YWwBB3VzZXJOdW0JALkJAgkAzAgCAiQlcyVkX191c2VyQm9vc3RBdmFsaWFibGVUb0NsYWltVG90YWwJAMwIAgUHdXNlck51bQUDbmlsBQNTRVABE2tleVVzZXJCb29zdENsYWltZWQBB3VzZXJOdW0JALkJAgkAzAgCAhYlcyVkX191c2VyQm9vc3RDbGFpbWVkCQDMCAIFB3VzZXJOdW0FA25pbAUDU0VQARFrZXlUb3RhbENhY2hlZEd3eAACFiVzJXNfX2d3eENhY2hlZF9fdG90YWwBG2tleVRvdGFsQ2FjaGVkR3d4Q29ycmVjdGl2ZQACHCVzX19nd3hDYWNoZWRUb3RhbENvcnJlY3RpdmUAD2ZhY3RvcnlDb250cmFjdAkBGHJlYWRGYWN0b3J5QWRkcmVzc09yRmFpbAAACmZhY3RvcnlDZmcJARRyZWFkRmFjdG9yeUNmZ09yRmFpbAEFD2ZhY3RvcnlDb250cmFjdAAQZW1pc3Npb25Db250cmFjdAkBGGdldEVtaXNzaW9uQWRkcmVzc09yRmFpbAEFCmZhY3RvcnlDZmcAD3N0YWtpbmdDb250cmFjdAkBF2dldFN0YWtpbmdBZGRyZXNzT3JGYWlsAQUKZmFjdG9yeUNmZwARZ3d4UmV3YXJkQ29udHJhY3QJARlnZXRHd3hSZXdhcmRBZGRyZXNzT3JGYWlsAQUKZmFjdG9yeUNmZwAWbHBTdGFraW5nUG9vbHNDb250cmFjdAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCmCAEJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAoggBCQC5CQIJAMwIAgICJXMJAMwIAgIWbHBTdGFraW5nUG9vbHNDb250cmFjdAUDbmlsBQNTRVAJAQd3cmFwRXJyAQIubHBfc3Rha2luZ19wb29scyBjb250cmFjdCBhZGRyZXNzIGlzIHVuZGVmaW5lZAkBB3dyYXBFcnIBAilpbnZhbGlkIGxwX3N0YWtpbmdfcG9vbHMgY29udHJhY3QgYWRkcmVzcwERZ2V0VG90YWxDYWNoZWRHd3gBB2NvcnJlY3QEGWtleVZvdGluZ0VtaXNzaW9uQ29udHJhY3QJALkJAgkAzAgCAgIlcwkAzAgCAhZ2b3RpbmdFbWlzc2lvbkNvbnRyYWN0BQNuaWwFA1NFUAQWdm90aW5nRW1pc3Npb25Db250cmFjdAkBEUBleHRyTmF0aXZlKDEwNjIpAQkBEUBleHRyTmF0aXZlKDEwNTMpAgUPZmFjdG9yeUNvbnRyYWN0BRlrZXlWb3RpbmdFbWlzc2lvbkNvbnRyYWN0BBFrZXlDdXJyZW50RXBvY2hVaQkAuQkCCQDMCAICAiVzCQDMCAICDmN1cnJlbnRFcG9jaFVpBQNuaWwFA1NFUAQOY3VycmVudEVwb2NoVWkJARFAZXh0ck5hdGl2ZSgxMDUwKQIFFnZvdGluZ0VtaXNzaW9uQ29udHJhY3QFEWtleUN1cnJlbnRFcG9jaFVpBA5rZXlUYXJnZXRFcG9jaAkAuQkCCQDMCAICBCVzJXMJAMwIAgIpdG90YWxDYWNoZWRHd3hDb3JyZWN0aW9uX19hY3RpdmF0aW9uRXBvY2gFA25pbAUDU0VQBBF0YXJnZXRFcG9jaE9wdGlvbgkAmggCBQR0aGlzBQ5rZXlUYXJnZXRFcG9jaAQRdG90YWxDYWNoZWRHd3hSYXcJAQt2YWx1ZU9yRWxzZQIJAJoIAgUEdGhpcwkBEWtleVRvdGFsQ2FjaGVkR3d4AAAABBVpc0NvcnJlY3Rpb25BY3RpdmF0ZWQDCQEJaXNEZWZpbmVkAQURdGFyZ2V0RXBvY2hPcHRpb24JAGcCBQ5jdXJyZW50RXBvY2hVaQkBBXZhbHVlAQURdGFyZ2V0RXBvY2hPcHRpb24HBApjb3JyZWN0aXZlAwMFFWlzQ29ycmVjdGlvbkFjdGl2YXRlZAUHY29ycmVjdAcJAQt2YWx1ZU9yRWxzZQIJAJoIAgUEdGhpcwkBG2tleVRvdGFsQ2FjaGVkR3d4Q29ycmVjdGl2ZQAAAAAACQCWAwEJAMwIAgAACQDMCAIJAGQCBRF0b3RhbENhY2hlZEd3eFJhdwUKY29ycmVjdGl2ZQUDbmlsAQxIaXN0b3J5RW50cnkIBHR5cGUEdXNlcgZhbW91bnQJbG9ja1N0YXJ0CGR1cmF0aW9uAWsBYgFpBApoaXN0b3J5S0VZCQC5CQIJAMwIAgIRJXMlcyVzJXNfX2hpc3RvcnkJAMwIAgUEdHlwZQkAzAgCBQR1c2VyCQDMCAIJANgEAQgFAWkNdHJhbnNhY3Rpb25JZAUDbmlsBQNTRVAEC2hpc3RvcnlEQVRBCQC5CQIJAMwIAgIOJWQlZCVkJWQlZCVkJWQJAMwIAgkApAMBCAUJbGFzdEJsb2NrBmhlaWdodAkAzAgCCQCkAwEIBQlsYXN0QmxvY2sJdGltZXN0YW1wCQDMCAIJAKQDAQUGYW1vdW50CQDMCAIJAKQDAQUJbG9ja1N0YXJ0CQDMCAIJAKQDAQUIZHVyYXRpb24JAMwIAgkApAMBBQFrCQDMCAIJAKQDAQUBYgUDbmlsBQNTRVAJAQtTdHJpbmdFbnRyeQIFCmhpc3RvcnlLRVkFC2hpc3RvcnlEQVRBAQpTdGF0c0VudHJ5BA50b3RhbExvY2tlZEluYwtkdXJhdGlvbkluYwxsb2NrQ291bnRJbmMNdXNlcnNDb3VudEluYwQbbG9ja3NEdXJhdGlvblN1bUluQmxvY2tzS0VZCQEga2V5U3RhdHNMb2Nrc0R1cmF0aW9uU3VtSW5CbG9ja3MABA1sb2Nrc0NvdW50S0VZCQESa2V5U3RhdHNMb2Nrc0NvdW50AAQNdXNlcnNDb3VudEtFWQkBEmtleVN0YXRzVXNlcnNDb3VudAAEDnRvdGFsQW1vdW50S0VZCQEXa2V5TG9ja1BhcmFtVG90YWxBbW91bnQABBhsb2Nrc0R1cmF0aW9uU3VtSW5CbG9ja3MJAQNpb3oCBQR0aGlzBRtsb2Nrc0R1cmF0aW9uU3VtSW5CbG9ja3NLRVkECmxvY2tzQ291bnQJAQNpb3oCBQR0aGlzBQ1sb2Nrc0NvdW50S0VZBAp1c2Vyc0NvdW50CQEDaW96AgUEdGhpcwUNdXNlcnNDb3VudEtFWQQLdG90YWxBbW91bnQJAQNpb3oCBQR0aGlzBQ50b3RhbEFtb3VudEtFWQkAzAgCCQEMSW50ZWdlckVudHJ5AgUbbG9ja3NEdXJhdGlvblN1bUluQmxvY2tzS0VZCQBkAgUYbG9ja3NEdXJhdGlvblN1bUluQmxvY2tzBQtkdXJhdGlvbkluYwkAzAgCCQEMSW50ZWdlckVudHJ5AgUNbG9ja3NDb3VudEtFWQkAZAIFCmxvY2tzQ291bnQFDGxvY2tDb3VudEluYwkAzAgCCQEMSW50ZWdlckVudHJ5AgUNdXNlcnNDb3VudEtFWQkAZAIFCnVzZXJzQ291bnQFDXVzZXJzQ291bnRJbmMJAMwIAgkBDEludGVnZXJFbnRyeQIFDnRvdGFsQW1vdW50S0VZCQBkAgULdG90YWxBbW91bnQFDnRvdGFsTG9ja2VkSW5jBQNuaWwBDWNhbGNHd3hBbW91bnQDBGtSYXcEYlJhdwFoBAVTQ0FMRQDoBwkAaQIJAGQCCQBoAgUEa1JhdwUBaAUEYlJhdwUFU0NBTEUBD0xvY2tQYXJhbXNFbnRyeQgLdXNlckFkZHJlc3MHdXNlck51bQZhbW91bnQFc3RhcnQIZHVyYXRpb24BawFiBnBlcmlvZAQNdXNlckFtb3VudEtFWQkBFmtleUxvY2tQYXJhbVVzZXJBbW91bnQBBQd1c2VyTnVtBA1zdGFydEJsb2NrS0VZCQEWa2V5TG9ja1BhcmFtU3RhcnRCbG9jawEFB3VzZXJOdW0EC2R1cmF0aW9uS0VZCQEUa2V5TG9ja1BhcmFtRHVyYXRpb24BBQd1c2VyTnVtBARrS0VZCQENa2V5TG9ja1BhcmFtSwEFB3VzZXJOdW0EBGJLRVkJAQ1rZXlMb2NrUGFyYW1CAQUHdXNlck51bQQMa0J5UGVyaW9kS0VZCQEVa2V5TG9ja1BhcmFtQnlQZXJpb2RLAgUHdXNlck51bQUGcGVyaW9kBAxiQnlQZXJpb2RLRVkJARVrZXlMb2NrUGFyYW1CeVBlcmlvZEICBQd1c2VyTnVtBQZwZXJpb2QECWd3eEFtb3VudAkBDWNhbGNHd3hBbW91bnQDBQFrBQFiBQZoZWlnaHQJAMwIAgkBDEludGVnZXJFbnRyeQIFDXVzZXJBbW91bnRLRVkFBmFtb3VudAkAzAgCCQEMSW50ZWdlckVudHJ5AgUNc3RhcnRCbG9ja0tFWQUFc3RhcnQJAMwIAgkBDEludGVnZXJFbnRyeQIFC2R1cmF0aW9uS0VZBQhkdXJhdGlvbgkAzAgCCQEMSW50ZWdlckVudHJ5AgUEa0tFWQUBawkAzAgCCQEMSW50ZWdlckVudHJ5AgUEYktFWQUBYgkAzAgCCQEMSW50ZWdlckVudHJ5AgUMa0J5UGVyaW9kS0VZBQFrCQDMCAIJAQxJbnRlZ2VyRW50cnkCBQxiQnlQZXJpb2RLRVkFAWIJAMwIAgkBC1N0cmluZ0VudHJ5AgkBE2tleUxvY2tQYXJhbXNSZWNvcmQBBQt1c2VyQWRkcmVzcwkBFmZvcm1hdExvY2tQYXJhbXNSZWNvcmQHBQd1c2VyTnVtBQZhbW91bnQFBXN0YXJ0BQhkdXJhdGlvbgUBawUBYgUJZ3d4QW1vdW50BQNuaWwBImV4dHJhY3RPcHRpb25hbFBheW1lbnRBbW91bnRPckZhaWwCAWkPZXhwZWN0ZWRBc3NldElkAwkAZgIJAJADAQgFAWkIcGF5bWVudHMAAQkAAgECG29ubHkgb25lIHBheW1lbnQgaXMgYWxsb3dlZAMJAAACCQCQAwEIBQFpCHBheW1lbnRzAAAAAAQDcG10CQCRAwIIBQFpCHBheW1lbnRzAAADCQECIT0CCQEFdmFsdWUBCAUDcG10B2Fzc2V0SWQFD2V4cGVjdGVkQXNzZXRJZAkAAgECG2ludmFsaWQgYXNzZXQgaWQgaW4gcGF5bWVudAgFA3BtdAZhbW91bnQBGWNhbGNVc2VyR3d4QW1vdW50QXRIZWlnaHQCC3VzZXJBZGRyZXNzDHRhcmdldEhlaWdodAQFRU1QVFkCBWVtcHR5BBJ1c2VyMk51bU1hcHBpbmdLRVkJARJrZXlVc2VyMk51bU1hcHBpbmcBBQt1c2VyQWRkcmVzcwQHdXNlck51bQkBC3ZhbHVlT3JFbHNlAgkAoggBBRJ1c2VyMk51bU1hcHBpbmdLRVkFBUVNUFRZBAFrCQELdmFsdWVPckVsc2UCCQCfCAEJAQ1rZXlMb2NrUGFyYW1LAQUHdXNlck51bQAABAFiCQELdmFsdWVPckVsc2UCCQCfCAEJAQ1rZXlMb2NrUGFyYW1CAQUHdXNlck51bQAABA1nd3hBbW91bnRDYWxjCQENY2FsY0d3eEFtb3VudAMFAWsFAWIFDHRhcmdldEhlaWdodAQJZ3d4QW1vdW50AwkAZgIAAAUNZ3d4QW1vdW50Q2FsYwAABQ1nd3hBbW91bnRDYWxjBQlnd3hBbW91bnQBFGNhbGNDdXJyZW50R3d4QW1vdW50AQt1c2VyQWRkcmVzcwkBGWNhbGNVc2VyR3d4QW1vdW50QXRIZWlnaHQCBQt1c2VyQWRkcmVzcwUGaGVpZ2h0ARRpbnRlcm5hbENsYWltV3hCb29zdAMMbHBBc3NldElkU3RyDnVzZXJBZGRyZXNzU3RyCHJlYWRPbmx5BAVFTVBUWQIFRU1QVFkEEXVzZXJSZWNvcmRPckVtcHR5CQELdmFsdWVPckVsc2UCCQCdCAIFBHRoaXMJARNrZXlMb2NrUGFyYW1zUmVjb3JkAQUOdXNlckFkZHJlc3NTdHIFBUVNUFRZAwkAAAIFEXVzZXJSZWNvcmRPckVtcHR5BQVFTVBUWQkAlQoDAAAFA25pbAIVdXNlclJlY29yZDo6aXM6OmVtcHR5BA91c2VyUmVjb3JkQXJyYXkJALUJAgURdXNlclJlY29yZE9yRW1wdHkFA1NFUAQKdXNlck51bVN0cgkAkQMCBQ91c2VyUmVjb3JkQXJyYXkFDklkeExvY2tVc2VyTnVtBBxnd3hSZXdhcmRFbWlzc2lvblN0YXJ0SGVpZ2h0CQELdmFsdWVPckVsc2UCCQCaCAIFEWd3eFJld2FyZENvbnRyYWN0CQEfa2V5R3d4UmV3YXJkRW1pc3Npb25TdGFydEhlaWdodAAAAAQIRU1QVFlTVFICBWVtcHR5BA0kdDAxNTc0NTE2MzIzAwkBAiE9AgUMbHBBc3NldElkU3RyBQhFTVBUWVNUUgQOcG9vbEFkZHJlc3NTdHIJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAnQgCBQ9mYWN0b3J5Q29udHJhY3QJARprZXlGYWN0b3J5THAyQXNzZXRzTWFwcGluZwEFDGxwQXNzZXRJZFN0cgkArAICAhV1bnN1cHBvcnRlZCBscCBhc3NldCAFDGxwQXNzZXRJZFN0cgQDcHcxCQERQGV4dHJOYXRpdmUoMTA1MCkCBQ9mYWN0b3J5Q29udHJhY3QJARRrZXlGYWN0b3J5UG9vbFdlaWdodAEFDnBvb2xBZGRyZXNzU3RyBANwdzAJAQt2YWx1ZU9yRWxzZQIJAJoIAgUPZmFjdG9yeUNvbnRyYWN0CQEba2V5RmFjdG9yeVBvb2xXZWlnaHRIaXN0b3J5AgUOcG9vbEFkZHJlc3NTdHIAAAUDcHcxCQCUCgIFA3B3MAUDcHcxAwUIcmVhZE9ubHkJAJQKAgAAAAAJAAIBCQCsAgICKG5vdCByZWFkb25seSBtb2RlOiB1bnN1cHBvcnRlZCBscCBhc3NldCAFDGxwQXNzZXRJZFN0cgQLcG9vbFdlaWdodDAIBQ0kdDAxNTc0NTE2MzIzAl8xBAtwb29sV2VpZ2h0MQgFDSR0MDE1NzQ1MTYzMjMCXzIEEnd4RW1pc3Npb25QZXJCbG9jawkBA2lvZgIFEGVtaXNzaW9uQ29udHJhY3QJAR5rZXlFbWlzc2lvblJhdGVQZXJCbG9ja0N1cnJlbnQABA1lbWlzc2lvblN0YXJ0CQEDaW9mAgUQZW1pc3Npb25Db250cmFjdAkBFWtleUVtaXNzaW9uU3RhcnRCbG9jawAEC2VtaXNzaW9uRW5kCQEDaW9mAgUQZW1pc3Npb25Db250cmFjdAkBE2tleUVtaXNzaW9uRW5kQmxvY2sABAFoAwkAZgIFBmhlaWdodAULZW1pc3Npb25FbmQFC2VtaXNzaW9uRW5kBQZoZWlnaHQEAmRoCQCWAwEJAMwIAgkAZQIFAWgFDWVtaXNzaW9uU3RhcnQJAMwIAgAABQNuaWwEInVzZXJMcEJvb3N0RW1pc3Npb25MYXN0SW50ZWdyYWxLRVkJASJrZXlVc2VyTHBCb29zdEVtaXNzaW9uTGFzdElOVEVHUkFMAgUKdXNlck51bVN0cgUMbHBBc3NldElkU3RyBCB1c2VyQm9vc3RFbWlzc2lvbkxhc3RJbnRlZ3JhbEtFWQkBIGtleVVzZXJCb29zdEVtaXNzaW9uTGFzdElOVEVHUkFMAQUKdXNlck51bVN0cgQddXNlckJvb3N0RW1pc3Npb25MYXN0SW50ZWdyYWwJAQt2YWx1ZU9yRWxzZQIJAJoIAgUEdGhpcwUidXNlckxwQm9vc3RFbWlzc2lvbkxhc3RJbnRlZ3JhbEtFWQkBA2lvegIFBHRoaXMFIHVzZXJCb29zdEVtaXNzaW9uTGFzdEludGVncmFsS0VZBBVib29zdEVtaXNzaW9uSW50ZWdyYWwJAGkCCQBoAgkAaAIFEnd4RW1pc3Npb25QZXJCbG9jawUCZGgAAgADBBl1c2VyQm9vc3RFbWlzc2lvbkludGVncmFsCQBlAgUVYm9vc3RFbWlzc2lvbkludGVncmFsBR11c2VyQm9vc3RFbWlzc2lvbkxhc3RJbnRlZ3JhbAQDdWRoCQBrAwUZdXNlckJvb3N0RW1pc3Npb25JbnRlZ3JhbAADCQBoAgACBRJ3eEVtaXNzaW9uUGVyQmxvY2sEBnVMYXN0SAkAZQIFAWgFA3VkaAQEdWRoMAkAlgMBCQDMCAIJAGUCBRxnd3hSZXdhcmRFbWlzc2lvblN0YXJ0SGVpZ2h0BQZ1TGFzdEgJAMwIAgAABQNuaWwEBHVkaDEJAGUCCQBlAgUBaAUGdUxhc3RIBQR1ZGgwAwMDCQBmAgAABQZ1TGFzdEgGCQBmAgAABQR1ZGgxBgkAZwIJAQNhYnMBCQBlAgkAZAIFBHVkaDAFBHVkaDEFA3VkaAABCQACAQkArAICCQCsAgIJAKwCAgkArAICCQCsAgIJAKwCAgkArAICCQCsAgIJAKwCAgkArAICCQCsAgICFmludmFsaWQgdWRoIGNhbGM6IHVkaD0JAKQDAQUDdWRoAgggdUxhc3RIPQkApAMBBQZ1TGFzdEgCBiB1ZGgwPQkApAMBBQR1ZGgwAgYgdWRoMT0JAKQDAQUEdWRoMQILIGxwQXNzZXRJZD0FDGxwQXNzZXRJZFN0cgINIHVzZXJBZGRyZXNzPQUOdXNlckFkZHJlc3NTdHIDCQBmAgAABRl1c2VyQm9vc3RFbWlzc2lvbkludGVncmFsCQACAQISd3JvbmcgY2FsY3VsYXRpb25zBBd1c2VyTWF4Qm9vc3RJbnRlZ3JhbEtFWQkBF2tleVVzZXJNYXhCb29zdElOVEVHUkFMAQUKdXNlck51bVN0cgQYdG90YWxNYXhCb29zdEludGVncmFsS0VZCQEYa2V5VG90YWxNYXhCb29zdElOVEVHUkFMAAQPdXNlck1heEJvb3N0SW50CQEDaW96AgUEdGhpcwUXdXNlck1heEJvb3N0SW50ZWdyYWxLRVkEEHRvdGFsTWF4Qm9vc3RJbnQJAQNpb3oCBQR0aGlzBRh0b3RhbE1heEJvb3N0SW50ZWdyYWxLRVkEF3RvdGFsQ2FjaGVkR3d4Q29ycmVjdGVkCQERZ2V0VG90YWxDYWNoZWRHd3gBBgQLdXNlckN1cnJHd3gJARRjYWxjQ3VycmVudEd3eEFtb3VudAEFDnVzZXJBZGRyZXNzU3RyBCF1c2VyQm9vc3RBdmFsYWlibGVUb0NsYWltVG90YWxLRVkJASFrZXlVc2VyQm9vc3RBdmFsYWlibGVUb0NsYWltVG90YWwBBQp1c2VyTnVtU3RyBB51c2VyQm9vc3RBdmFsaWFibGVUb0NsYWltVG90YWwJAQNpb3oCBQR0aGlzBSF1c2VyQm9vc3RBdmFsYWlibGVUb0NsYWltVG90YWxLRVkEGnVzZXJCb29zdEVtaXNzaW9uSW50ZWdyYWwwAwkAAAIFA3VkaAAAAAAJAGsDBRl1c2VyQm9vc3RFbWlzc2lvbkludGVncmFsBQR1ZGgwBQN1ZGgEGnVzZXJCb29zdEVtaXNzaW9uSW50ZWdyYWwxAwkAAAIFA3VkaAAAAAAJAGsDBRl1c2VyQm9vc3RFbWlzc2lvbkludGVncmFsBQR1ZGgxBQN1ZGgEHnBvb2xVc2VyQm9vc3RFbWlzc2lvbkludGVncmFsMAkAawMFGnVzZXJCb29zdEVtaXNzaW9uSW50ZWdyYWwwBQtwb29sV2VpZ2h0MAUOUE9PTFdFSUdIVE1VTFQEHnBvb2xVc2VyQm9vc3RFbWlzc2lvbkludGVncmFsMQkAawMFGnVzZXJCb29zdEVtaXNzaW9uSW50ZWdyYWwxBQtwb29sV2VpZ2h0MQUOUE9PTFdFSUdIVE1VTFQEInVzZXJCb29zdEF2YWxpYWJsZVRvQ2xhaW1Ub3RhbE5ldzADCQAAAgUXdG90YWxDYWNoZWRHd3hDb3JyZWN0ZWQAAAAACQBrAwUecG9vbFVzZXJCb29zdEVtaXNzaW9uSW50ZWdyYWwwBQt1c2VyQ3Vyckd3eAUXdG90YWxDYWNoZWRHd3hDb3JyZWN0ZWQEInVzZXJCb29zdEF2YWxpYWJsZVRvQ2xhaW1Ub3RhbE5ldzEDCQAAAgUXdG90YWxDYWNoZWRHd3hDb3JyZWN0ZWQAAAAACQBrAwUecG9vbFVzZXJCb29zdEVtaXNzaW9uSW50ZWdyYWwxBQt1c2VyQ3Vyckd3eAUXdG90YWxDYWNoZWRHd3hDb3JyZWN0ZWQEIXVzZXJCb29zdEF2YWxpYWJsZVRvQ2xhaW1Ub3RhbE5ldwkAZAIFInVzZXJCb29zdEF2YWxpYWJsZVRvQ2xhaW1Ub3RhbE5ldzAFInVzZXJCb29zdEF2YWxpYWJsZVRvQ2xhaW1Ub3RhbE5ldzEEE3VzZXJCb29zdENsYWltZWRLRVkJARNrZXlVc2VyQm9vc3RDbGFpbWVkAQUKdXNlck51bVN0cgQQdXNlckJvb3N0Q2xhaW1lZAkBA2lvegIFBHRoaXMFE3VzZXJCb29zdENsYWltZWRLRVkEEnVzZXJCb29zdEF2YWlsYWJsZQkAZQIFIXVzZXJCb29zdEF2YWxpYWJsZVRvQ2xhaW1Ub3RhbE5ldwUQdXNlckJvb3N0Q2xhaW1lZAQJZGF0YVN0YXRlCQDMCAIJAQxJbnRlZ2VyRW50cnkCBSJ1c2VyTHBCb29zdEVtaXNzaW9uTGFzdEludGVncmFsS0VZBRVib29zdEVtaXNzaW9uSW50ZWdyYWwFA25pbAQFZGVidWcJALkJAgkAzAgCCQCkAwEFHXVzZXJCb29zdEVtaXNzaW9uTGFzdEludGVncmFsCQDMCAIJAKQDAQUZdXNlckJvb3N0RW1pc3Npb25JbnRlZ3JhbAkAzAgCCQCkAwEFEHVzZXJCb29zdENsYWltZWQJAMwIAgkApAMBBRJ1c2VyQm9vc3RBdmFpbGFibGUJAMwIAgkApAMBBQtwb29sV2VpZ2h0MAkAzAgCCQCkAwEFC3Bvb2xXZWlnaHQxCQDMCAIJAKQDAQUBaAkAzAgCCQCkAwEFA3VkaAkAzAgCCQCkAwEFBnVMYXN0SAkAzAgCCQCkAwEFBHVkaDAJAMwIAgkApAMBBQR1ZGgxCQDMCAIJAKQDAQULdXNlckN1cnJHd3gJAMwIAgkApAMBBRd0b3RhbENhY2hlZEd3eENvcnJlY3RlZAUDbmlsAgE6CQCVCgMFIXVzZXJCb29zdEF2YWxpYWJsZVRvQ2xhaW1Ub3RhbE5ldwUJZGF0YVN0YXRlBQVkZWJ1ZwELbG9ja0FjdGlvbnMCAWkIZHVyYXRpb24ECGNmZ0FycmF5CQEVcmVhZENvbmZpZ0FycmF5T3JGYWlsAAQKYXNzZXRJZFN0cgkAkQMCBQhjZmdBcnJheQUNSWR4Q2ZnQXNzZXRJZAQHYXNzZXRJZAkA2QQBBQphc3NldElkU3RyBA1taW5Mb2NrQW1vdW50CQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUIY2ZnQXJyYXkFE0lkeENmZ01pbkxvY2tBbW91bnQED21pbkxvY2tEdXJhdGlvbgkBDXBhcnNlSW50VmFsdWUBCQCRAwIFCGNmZ0FycmF5BRVJZHhDZmdNaW5Mb2NrRHVyYXRpb24ED21heExvY2tEdXJhdGlvbgkBDXBhcnNlSW50VmFsdWUBCQCRAwIFCGNmZ0FycmF5BRVJZHhDZmdNYXhMb2NrRHVyYXRpb24DCQECIT0CCQCQAwEIBQFpCHBheW1lbnRzAAEJAAIBAjRpbnZhbGlkIHBheW1lbnQgLSBleGFjdCBvbmUgcGF5bWVudCBtdXN0IGJlIGF0dGFjaGVkBANwbXQJAJEDAggFAWkIcGF5bWVudHMAAAQJcG10QW1vdW50CAUDcG10BmFtb3VudAMJAQIhPQIFB2Fzc2V0SWQJAQV2YWx1ZQEIBQNwbXQHYXNzZXRJZAkAAgEJAKwCAgkArAICAh5pbnZhbGlkIGFzc2V0IGlzIGluIHBheW1lbnQgLSAFCmFzc2V0SWRTdHICDCBpcyBleHBlY3RlZAQObmV4dFVzZXJOdW1LRVkJAQ5rZXlOZXh0VXNlck51bQAEDnVzZXJBZGRyZXNzU3RyCQClCAEIBQFpBmNhbGxlcgQOdXNlcklzRXhpc3RpbmcJAQlpc0RlZmluZWQBCQCiCAEJARJrZXlVc2VyMk51bU1hcHBpbmcBBQ51c2VyQWRkcmVzc1N0cgQKdXNlck51bVN0cgMFDnVzZXJJc0V4aXN0aW5nCQEFdmFsdWUBCQCiCAEJARJrZXlVc2VyMk51bU1hcHBpbmcBBQ51c2VyQWRkcmVzc1N0cgkApAMBCQEDaW9mAgUEdGhpcwUObmV4dFVzZXJOdW1LRVkEB3VzZXJOdW0JAQ1wYXJzZUludFZhbHVlAQUKdXNlck51bVN0cgQJbG9ja1N0YXJ0BQZoZWlnaHQEDXN0YXJ0QmxvY2tLRVkJARZrZXlMb2NrUGFyYW1TdGFydEJsb2NrAQUKdXNlck51bVN0cgQLZHVyYXRpb25LRVkJARRrZXlMb2NrUGFyYW1EdXJhdGlvbgEFCnVzZXJOdW1TdHIEDXVzZXJBbW91bnRLRVkJARZrZXlMb2NrUGFyYW1Vc2VyQW1vdW50AQUKdXNlck51bVN0cgMDCQBmAgUNbWluTG9ja0Ftb3VudAUJcG10QW1vdW50CQECIT0CCAUBaQZjYWxsZXIFFmxwU3Rha2luZ1Bvb2xzQ29udHJhY3QHCQACAQkArAICAiJhbW91bnQgaXMgbGVzcyB0aGVuIG1pbkxvY2tBbW91bnQ9CQCkAwEFDW1pbkxvY2tBbW91bnQDCQBmAgUPbWluTG9ja0R1cmF0aW9uBQhkdXJhdGlvbgkAAgEJAKwCAgItcGFzc2VkIGR1cmF0aW9uIGlzIGxlc3MgdGhlbiBtaW5Mb2NrRHVyYXRpb249CQCkAwEFD21pbkxvY2tEdXJhdGlvbgMJAGYCBQhkdXJhdGlvbgUPbWF4TG9ja0R1cmF0aW9uCQACAQkArAICAjBwYXNzZWQgZHVyYXRpb24gaXMgZ3JlYXRlciB0aGVuIG1heExvY2tEdXJhdGlvbj0JAKQDAQUPbWF4TG9ja0R1cmF0aW9uAwMFDnVzZXJJc0V4aXN0aW5nCQBnAgkAZAIJAQNpb2YCBQR0aGlzBQ1zdGFydEJsb2NrS0VZCQEDaW9mAgUEdGhpcwULZHVyYXRpb25LRVkFCWxvY2tTdGFydAcJAAIBAjZ0aGVyZSBpcyBhbiBhY3RpdmUgbG9jayAtIGNvbnNpZGVyIHRvIHVzZSBpbmNyZWFzZUxvY2sDCQBmAgkBA2lvegIFBHRoaXMFDXVzZXJBbW91bnRLRVkAAAkAAgEJAKwCAgI0dGhlcmUgYXJlIGxvY2tlZCBXWHMgLSBjb25zaWRlciB0byB1c2UgaW5jcmVhc2VMb2NrIAUNdXNlckFtb3VudEtFWQQHY29lZmZYOAkAawMFCGR1cmF0aW9uBQVNVUxUOAUPbWF4TG9ja0R1cmF0aW9uBA5nV3hBbW91bnRTdGFydAkAawMFCXBtdEFtb3VudAUHY29lZmZYOAUFTVVMVDgEE2dXeFBhcmFtc1Jlc3VsdExpc3QJAQNhYWwBCQD8BwQFDG1hdGhDb250cmFjdAIVY2FsY0d3eFBhcmFtc1JFQURPTkxZCQDMCAIFDmdXeEFtb3VudFN0YXJ0CQDMCAIFCWxvY2tTdGFydAkAzAgCBQhkdXJhdGlvbgUDbmlsBQNuaWwEAWsJAQJhaQEJAJEDAgUTZ1d4UGFyYW1zUmVzdWx0TGlzdAAABAFiCQECYWkBCQCRAwIFE2dXeFBhcmFtc1Jlc3VsdExpc3QAAQQGcGVyaW9kCQCkAwEJAQJhaQEJAJEDAgUTZ1d4UGFyYW1zUmVzdWx0TGlzdAACBBJ3eEVtaXNzaW9uUGVyQmxvY2sJAQNpb2YCBRBlbWlzc2lvbkNvbnRyYWN0CQEea2V5RW1pc3Npb25SYXRlUGVyQmxvY2tDdXJyZW50AAQNZW1pc3Npb25TdGFydAkBA2lvZgIFEGVtaXNzaW9uQ29udHJhY3QJARVrZXlFbWlzc2lvblN0YXJ0QmxvY2sABAtlbWlzc2lvbkVuZAkBA2lvZgIFEGVtaXNzaW9uQ29udHJhY3QJARNrZXlFbWlzc2lvbkVuZEJsb2NrAAQBaAMJAGYCBQZoZWlnaHQFC2VtaXNzaW9uRW5kBQtlbWlzc2lvbkVuZAUGaGVpZ2h0BAJkaAkAlgMBCQDMCAIJAGUCBQFoBQ1lbWlzc2lvblN0YXJ0CQDMCAIAAAUDbmlsBCB1c2VyQm9vc3RFbWlzc2lvbkxhc3RJbnRlZ3JhbEtFWQkBIGtleVVzZXJCb29zdEVtaXNzaW9uTGFzdElOVEVHUkFMAQUKdXNlck51bVN0cgQVYm9vc3RFbWlzc2lvbkludGVncmFsCQBpAgkAaAIJAGgCBRJ3eEVtaXNzaW9uUGVyQmxvY2sFAmRoAAIAAwQXdXNlck1heEJvb3N0SW50ZWdyYWxLRVkJARdrZXlVc2VyTWF4Qm9vc3RJTlRFR1JBTAEFCnVzZXJOdW1TdHIEGHRvdGFsTWF4Qm9vc3RJbnRlZ3JhbEtFWQkBGGtleVRvdGFsTWF4Qm9vc3RJTlRFR1JBTAAED3VzZXJNYXhCb29zdEludAkAaQIJAGgCBQ5nV3hBbW91bnRTdGFydAUIZHVyYXRpb24AAgQQdG90YWxNYXhCb29zdEludAkBA2lvegIFBHRoaXMFGHRvdGFsTWF4Qm9vc3RJbnRlZ3JhbEtFWQQRdG90YWxDYWNoZWRHd3hSYXcJARFnZXRUb3RhbENhY2hlZEd3eAEHBANhcnIDBQ51c2VySXNFeGlzdGluZwUDbmlsCQDMCAIJAQxJbnRlZ2VyRW50cnkCBQ5uZXh0VXNlck51bUtFWQkAZAIFB3VzZXJOdW0AAQkAzAgCCQELU3RyaW5nRW50cnkCCQESa2V5VXNlcjJOdW1NYXBwaW5nAQUOdXNlckFkZHJlc3NTdHIFCnVzZXJOdW1TdHIJAMwIAgkBC1N0cmluZ0VudHJ5AgkBEmtleU51bTJVc2VyTWFwcGluZwEFCnVzZXJOdW1TdHIFDnVzZXJBZGRyZXNzU3RyBQNuaWwJAJQKAgkAzggCCQDNCAIJAM4IAgkAzggCBQNhcnIJAQ9Mb2NrUGFyYW1zRW50cnkIBQ51c2VyQWRkcmVzc1N0cgUKdXNlck51bVN0cgUJcG10QW1vdW50BQlsb2NrU3RhcnQFCGR1cmF0aW9uBQFrBQFiBQZwZXJpb2QJAQpTdGF0c0VudHJ5BAUJcG10QW1vdW50BQhkdXJhdGlvbgABAwUOdXNlcklzRXhpc3RpbmcAAAABCQEMSGlzdG9yeUVudHJ5CAIEbG9jawUOdXNlckFkZHJlc3NTdHIFCXBtdEFtb3VudAUJbG9ja1N0YXJ0BQhkdXJhdGlvbgUBawUBYgUBaQkAzAgCCQEMSW50ZWdlckVudHJ5AgUgdXNlckJvb3N0RW1pc3Npb25MYXN0SW50ZWdyYWxLRVkFFWJvb3N0RW1pc3Npb25JbnRlZ3JhbAkAzAgCCQEMSW50ZWdlckVudHJ5AgkBEWtleVRvdGFsQ2FjaGVkR3d4AAkAZAIFEXRvdGFsQ2FjaGVkR3d4UmF3BQ5nV3hBbW91bnRTdGFydAUDbmlsBQ5nV3hBbW91bnRTdGFydA0BaQELY29uc3RydWN0b3IGEWZhY3RvcnlBZGRyZXNzU3RyDmxvY2tBc3NldElkU3RyDW1pbkxvY2tBbW91bnQLbWluRHVyYXRpb24LbWF4RHVyYXRpb24MbWF0aENvbnRyYWN0BAtjaGVja0NhbGxlcgkBC211c3RNYW5hZ2VyAQUBaQMJAAACBQtjaGVja0NhbGxlcgULY2hlY2tDYWxsZXIJAM4IAgkAzAgCCQEMSW50ZWdlckVudHJ5AgkBDmtleU5leHRVc2VyTnVtAAAACQDMCAIJAQtTdHJpbmdFbnRyeQIJAQlrZXlDb25maWcACQEMZm9ybWF0Q29uZmlnBQUObG9ja0Fzc2V0SWRTdHIFDW1pbkxvY2tBbW91bnQFC21pbkR1cmF0aW9uBQttYXhEdXJhdGlvbgUMbWF0aENvbnRyYWN0CQDMCAIJAQtTdHJpbmdFbnRyeQIJARFrZXlGYWN0b3J5QWRkcmVzcwAFEWZhY3RvcnlBZGRyZXNzU3RyBQNuaWwJAQpTdGF0c0VudHJ5BAAAAAAAAAAACQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAWkBB2xvY2tSZWYDCGR1cmF0aW9uD3JlZmVycmVyQWRkcmVzcwlzaWduYXR1cmUEDSR0MDI0OTU4MjUwMjMJAQtsb2NrQWN0aW9ucwIFAWkFCGR1cmF0aW9uBBFsb2NrQWN0aW9uc1Jlc3VsdAgFDSR0MDI0OTU4MjUwMjMCXzEEDmdXeEFtb3VudFN0YXJ0CAUNJHQwMjQ5NTgyNTAyMwJfMgQPcmVmZXJyYWxBZGRyZXNzCQClCAEIBQFpBmNhbGxlcgQGcmVmSW52AwMJAAACBQ9yZWZlcnJlckFkZHJlc3MCAAYJAAACBQlzaWduYXR1cmUBAAUEdW5pdAkA/AcEBR5yZWZlcnJhbHNDb250cmFjdEFkZHJlc3NPckZhaWwCCmNyZWF0ZVBhaXIJAMwIAgUTcmVmZXJyYWxQcm9ncmFtTmFtZQkAzAgCBQ9yZWZlcnJlckFkZHJlc3MJAMwIAgUPcmVmZXJyYWxBZGRyZXNzCQDMCAIFCXNpZ25hdHVyZQUDbmlsBQNuaWwDCQAAAgUGcmVmSW52BQZyZWZJbnYEEXVwZGF0ZVJlZkFjdGl2aXR5CQD8BwQFDG1hdGhDb250cmFjdAIWdXBkYXRlUmVmZXJyYWxBY3Rpdml0eQkAzAgCCQClCAEIBQFpBmNhbGxlcgkAzAgCBQ5nV3hBbW91bnRTdGFydAUDbmlsBQNuaWwDCQAAAgURdXBkYXRlUmVmQWN0aXZpdHkFEXVwZGF0ZVJlZkFjdGl2aXR5CQCUCgIFEWxvY2tBY3Rpb25zUmVzdWx0BQR1bml0CQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAWkBBGxvY2sBCGR1cmF0aW9uBA0kdDAyNTQ5MzI1NTU4CQELbG9ja0FjdGlvbnMCBQFpBQhkdXJhdGlvbgQRbG9ja0FjdGlvbnNSZXN1bHQIBQ0kdDAyNTQ5MzI1NTU4Al8xBA5nV3hBbW91bnRTdGFydAgFDSR0MDI1NDkzMjU1NTgCXzIEEXVwZGF0ZVJlZkFjdGl2aXR5CQD8BwQFDG1hdGhDb250cmFjdAIWdXBkYXRlUmVmZXJyYWxBY3Rpdml0eQkAzAgCCQClCAEIBQFpBmNhbGxlcgkAzAgCBQ5nV3hBbW91bnRTdGFydAUDbmlsBQNuaWwDCQAAAgURdXBkYXRlUmVmQWN0aXZpdHkFEXVwZGF0ZVJlZkFjdGl2aXR5CQCUCgIFEWxvY2tBY3Rpb25zUmVzdWx0BQR1bml0CQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAWkBDGluY3JlYXNlTG9jawENZGVsdGFEdXJhdGlvbgQIY2ZnQXJyYXkJARVyZWFkQ29uZmlnQXJyYXlPckZhaWwABAphc3NldElkU3RyCQCRAwIFCGNmZ0FycmF5BQ1JZHhDZmdBc3NldElkBAdhc3NldElkCQDZBAEFCmFzc2V0SWRTdHIED21pbkxvY2tEdXJhdGlvbgkBDXBhcnNlSW50VmFsdWUBCQCRAwIFCGNmZ0FycmF5BRVJZHhDZmdNaW5Mb2NrRHVyYXRpb24ED21heExvY2tEdXJhdGlvbgkBDXBhcnNlSW50VmFsdWUBCQCRAwIFCGNmZ0FycmF5BRVJZHhDZmdNYXhMb2NrRHVyYXRpb24ECXBtdEFtb3VudAkBImV4dHJhY3RPcHRpb25hbFBheW1lbnRBbW91bnRPckZhaWwCBQFpBQdhc3NldElkBA51c2VyQWRkcmVzc1N0cgkApQgBCAUBaQZjYWxsZXIED3VzZXJSZWNvcmRBcnJheQkBGnJlYWRMb2NrUGFyYW1zUmVjb3JkT3JGYWlsAQUOdXNlckFkZHJlc3NTdHIECnVzZXJOdW1TdHIJAJEDAgUPdXNlclJlY29yZEFycmF5BQ5JZHhMb2NrVXNlck51bQQKdXNlckFtb3VudAkBDXBhcnNlSW50VmFsdWUBCQCRAwIFD3VzZXJSZWNvcmRBcnJheQUNSWR4TG9ja0Ftb3VudAQJbG9ja1N0YXJ0CQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUPdXNlclJlY29yZEFycmF5BQxJZHhMb2NrU3RhcnQEDGxvY2tEdXJhdGlvbgkBDXBhcnNlSW50VmFsdWUBCQCRAwIFD3VzZXJSZWNvcmRBcnJheQUPSWR4TG9ja0R1cmF0aW9uBAdsb2NrRW5kCQBkAgUJbG9ja1N0YXJ0BQxsb2NrRHVyYXRpb24EEXJlbWFpbmluZ0R1cmF0aW9uCQCWAwEJAMwIAgkAZQIFB2xvY2tFbmQFBmhlaWdodAkAzAgCAAAFA25pbAQNdXNlckFtb3VudE5ldwkAZAIFCnVzZXJBbW91bnQFCXBtdEFtb3VudAQPbG9ja0R1cmF0aW9uTmV3CQBkAgURcmVtYWluaW5nRHVyYXRpb24FDWRlbHRhRHVyYXRpb24DCQBmAgAABQ1kZWx0YUR1cmF0aW9uCQACAQIaZHVyYXRpb24gaXMgbGVzcyB0aGVuIHplcm8DCQBmAgUPbWluTG9ja0R1cmF0aW9uBQ9sb2NrRHVyYXRpb25OZXcJAAIBCQCsAgICLWxvY2tEdXJhdGlvbk5ldyBpcyBsZXNzIHRoZW4gbWluTG9ja0R1cmF0aW9uPQkApAMBBQ9taW5Mb2NrRHVyYXRpb24DCQBmAgUPbG9ja0R1cmF0aW9uTmV3BQ9tYXhMb2NrRHVyYXRpb24JAAIBCQCsAgICRGRlbHRhRHVyYXRpb24gKyBleGlzdGVkTG9ja0R1cmF0aW9uIGlzIGdyZWF0ZXIgdGhlbiBtYXhMb2NrRHVyYXRpb249CQCkAwEFD21heExvY2tEdXJhdGlvbgQHY29lZmZYOAkAawMFD2xvY2tEdXJhdGlvbk5ldwUFTVVMVDgFD21heExvY2tEdXJhdGlvbgQOZ1d4QW1vdW50U3RhcnQJAGsDBQ11c2VyQW1vdW50TmV3BQdjb2VmZlg4BQVNVUxUOAQRdXBkYXRlUmVmQWN0aXZpdHkJAPwHBAUMbWF0aENvbnRyYWN0AhZ1cGRhdGVSZWZlcnJhbEFjdGl2aXR5CQDMCAIJAKUIAQgFAWkGY2FsbGVyCQDMCAIFDmdXeEFtb3VudFN0YXJ0BQNuaWwFA25pbAMJAAACBRF1cGRhdGVSZWZBY3Rpdml0eQURdXBkYXRlUmVmQWN0aXZpdHkEDGxvY2tTdGFydE5ldwUGaGVpZ2h0BBNnV3hQYXJhbXNSZXN1bHRMaXN0CQEDYWFsAQkA/AcEBQxtYXRoQ29udHJhY3QCFWNhbGNHd3hQYXJhbXNSRUFET05MWQkAzAgCBQ5nV3hBbW91bnRTdGFydAkAzAgCBQxsb2NrU3RhcnROZXcJAMwIAgUPbG9ja0R1cmF0aW9uTmV3BQNuaWwFA25pbAQBawkBAmFpAQkAkQMCBRNnV3hQYXJhbXNSZXN1bHRMaXN0AAAEAWIJAQJhaQEJAJEDAgUTZ1d4UGFyYW1zUmVzdWx0TGlzdAABBAZwZXJpb2QJAKQDAQkBAmFpAQkAkQMCBRNnV3hQYXJhbXNSZXN1bHRMaXN0AAIEEnd4RW1pc3Npb25QZXJCbG9jawkBA2lvZgIFEGVtaXNzaW9uQ29udHJhY3QJAR5rZXlFbWlzc2lvblJhdGVQZXJCbG9ja0N1cnJlbnQABA1lbWlzc2lvblN0YXJ0CQEDaW9mAgUQZW1pc3Npb25Db250cmFjdAkBFWtleUVtaXNzaW9uU3RhcnRCbG9jawAEC2VtaXNzaW9uRW5kCQEDaW9mAgUQZW1pc3Npb25Db250cmFjdAkBE2tleUVtaXNzaW9uRW5kQmxvY2sABAFoAwkAZgIFBmhlaWdodAULZW1pc3Npb25FbmQFC2VtaXNzaW9uRW5kBQZoZWlnaHQEAmRoCQCWAwEJAMwIAgkAZQIFAWgFDWVtaXNzaW9uU3RhcnQJAMwIAgAABQNuaWwEIHVzZXJCb29zdEVtaXNzaW9uTGFzdEludGVncmFsS0VZCQEga2V5VXNlckJvb3N0RW1pc3Npb25MYXN0SU5URUdSQUwBBQp1c2VyTnVtU3RyBB11c2VyQm9vc3RFbWlzc2lvbkxhc3RJbnRlZ3JhbAkBA2lvegIFBHRoaXMFIHVzZXJCb29zdEVtaXNzaW9uTGFzdEludGVncmFsS0VZBBVib29zdEVtaXNzaW9uSW50ZWdyYWwJAGkCCQBoAgkAaAIFEnd4RW1pc3Npb25QZXJCbG9jawUCZGgAAgADBBl1c2VyQm9vc3RFbWlzc2lvbkludGVncmFsCQBlAgUVYm9vc3RFbWlzc2lvbkludGVncmFsBR11c2VyQm9vc3RFbWlzc2lvbkxhc3RJbnRlZ3JhbAMJAGYCAAAFGXVzZXJCb29zdEVtaXNzaW9uSW50ZWdyYWwJAAIBAhJ3cm9uZyBjYWxjdWxhdGlvbnMEF3VzZXJNYXhCb29zdEludGVncmFsS0VZCQEXa2V5VXNlck1heEJvb3N0SU5URUdSQUwBBQp1c2VyTnVtU3RyBBh0b3RhbE1heEJvb3N0SW50ZWdyYWxLRVkJARhrZXlUb3RhbE1heEJvb3N0SU5URUdSQUwABA91c2VyTWF4Qm9vc3RJbnQJAQNpb3oCBQR0aGlzBRd1c2VyTWF4Qm9vc3RJbnRlZ3JhbEtFWQQQdG90YWxNYXhCb29zdEludAkBA2lvegIFBHRoaXMFGHRvdGFsTWF4Qm9vc3RJbnRlZ3JhbEtFWQQLY3VyclVzZXJHd3gJARRjYWxjQ3VycmVudEd3eEFtb3VudAEFDnVzZXJBZGRyZXNzU3RyBAdnd3hEaWZmCQBlAgUOZ1d4QW1vdW50U3RhcnQFC2N1cnJVc2VyR3d4AwkAZgIAAAUHZ3d4RGlmZgkAAgEJAKwCAgIYZ3d4RGlmZiBpcyBsZXNzIHRoZW4gMDogCQCkAwEFB2d3eERpZmYEEXRvdGFsQ2FjaGVkR3d4UmF3CQERZ2V0VG90YWxDYWNoZWRHd3gBBwQXdG90YWxDYWNoZWRHd3hDb3JyZWN0ZWQJARFnZXRUb3RhbENhY2hlZEd3eAEGBCF1c2VyQm9vc3RBdmFsYWlibGVUb0NsYWltVG90YWxLRVkJASFrZXlVc2VyQm9vc3RBdmFsYWlibGVUb0NsYWltVG90YWwBBQp1c2VyTnVtU3RyBB51c2VyQm9vc3RBdmFsaWFibGVUb0NsYWltVG90YWwJAQNpb3oCBQR0aGlzBSF1c2VyQm9vc3RBdmFsYWlibGVUb0NsYWltVG90YWxLRVkEIXVzZXJCb29zdEF2YWxpYWJsZVRvQ2xhaW1Ub3RhbE5ldwkAawMFGXVzZXJCb29zdEVtaXNzaW9uSW50ZWdyYWwFC2N1cnJVc2VyR3d4BRd0b3RhbENhY2hlZEd3eENvcnJlY3RlZAQSdXNlck1heEJvb3N0SW50TmV3CQBpAgkAaAIFDmdXeEFtb3VudFN0YXJ0BQ9sb2NrRHVyYXRpb25OZXcAAgQYcmVtYWluaW5nVXNlck1heEJvb3N0SW50CQBpAgkAaAIFC2N1cnJVc2VyR3d4BRFyZW1haW5pbmdEdXJhdGlvbgACBBN1c2VyTWF4Qm9vc3RJbnREaWZmCQBlAgUSdXNlck1heEJvb3N0SW50TmV3BRhyZW1haW5pbmdVc2VyTWF4Qm9vc3RJbnQJAM4IAgkAzQgCCQDOCAIJAQ9Mb2NrUGFyYW1zRW50cnkIBQ51c2VyQWRkcmVzc1N0cgUKdXNlck51bVN0cgUNdXNlckFtb3VudE5ldwUMbG9ja1N0YXJ0TmV3BQ9sb2NrRHVyYXRpb25OZXcFAWsFAWIFBnBlcmlvZAkBClN0YXRzRW50cnkEBQlwbXRBbW91bnQFDWRlbHRhRHVyYXRpb24AAAAACQEMSGlzdG9yeUVudHJ5CAIEbG9jawUOdXNlckFkZHJlc3NTdHIFCXBtdEFtb3VudAUJbG9ja1N0YXJ0BQ9sb2NrRHVyYXRpb25OZXcFAWsFAWIFAWkJAMwIAgkBDEludGVnZXJFbnRyeQIJARFrZXlUb3RhbENhY2hlZEd3eAAJAGQCBRF0b3RhbENhY2hlZEd3eFJhdwUHZ3d4RGlmZgUDbmlsCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAWkBDGNsYWltV3hCb29zdAIMbHBBc3NldElkU3RyDnVzZXJBZGRyZXNzU3RyAwkBAiE9AgUPc3Rha2luZ0NvbnRyYWN0CAUBaQZjYWxsZXIJAAIBAhJwZXJtaXNzaW9ucyBkZW5pZWQEDSR0MDMwNjM0MzA3MzYJARRpbnRlcm5hbENsYWltV3hCb29zdAMFDGxwQXNzZXRJZFN0cgUOdXNlckFkZHJlc3NTdHIHBBJ1c2VyQm9vc3RBdmFpbGFibGUIBQ0kdDAzMDYzNDMwNzM2Al8xBAlkYXRhU3RhdGUIBQ0kdDAzMDYzNDMwNzM2Al8yBAVkZWJ1ZwgFDSR0MDMwNjM0MzA3MzYCXzMJAJQKAgUJZGF0YVN0YXRlCQDMCAIFEnVzZXJCb29zdEF2YWlsYWJsZQUDbmlsAWkBFGNsYWltV3hCb29zdFJFQURPTkxZAgxscEFzc2V0SWRTdHIOdXNlckFkZHJlc3NTdHIEDSR0MDMwODc1MzA5NzYJARRpbnRlcm5hbENsYWltV3hCb29zdAMFDGxwQXNzZXRJZFN0cgUOdXNlckFkZHJlc3NTdHIGBBJ1c2VyQm9vc3RBdmFpbGFibGUIBQ0kdDAzMDg3NTMwOTc2Al8xBAlkYXRhU3RhdGUIBQ0kdDAzMDg3NTMwOTc2Al8yBAVkZWJ1ZwgFDSR0MDMwODc1MzA5NzYCXzMJAJQKAgUDbmlsCQDMCAIFEnVzZXJCb29zdEF2YWlsYWJsZQkAzAgCBQVkZWJ1ZwUDbmlsAWkBBnVubG9jawELdXNlckFkZHJlc3MED3VzZXJSZWNvcmRBcnJheQkBGnJlYWRMb2NrUGFyYW1zUmVjb3JkT3JGYWlsAQULdXNlckFkZHJlc3MECnVzZXJOdW1TdHIJAJEDAgUPdXNlclJlY29yZEFycmF5BQ5JZHhMb2NrVXNlck51bQQKdXNlckFtb3VudAkBDXBhcnNlSW50VmFsdWUBCQCRAwIFD3VzZXJSZWNvcmRBcnJheQUNSWR4TG9ja0Ftb3VudAQJbG9ja1N0YXJ0CQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUPdXNlclJlY29yZEFycmF5BQxJZHhMb2NrU3RhcnQEDGxvY2tEdXJhdGlvbgkBDXBhcnNlSW50VmFsdWUBCQCRAwIFD3VzZXJSZWNvcmRBcnJheQUPSWR4TG9ja0R1cmF0aW9uBAdsb2NrRW5kCQBkAgUJbG9ja1N0YXJ0BQxsb2NrRHVyYXRpb24ECGNmZ0FycmF5CQEVcmVhZENvbmZpZ0FycmF5T3JGYWlsAAQHYXNzZXRJZAkA2QQBCQCRAwIFCGNmZ0FycmF5BQ1JZHhDZmdBc3NldElkAwkAZwIFB2xvY2tFbmQFBmhlaWdodAkAAgEJAKwCAgkArAICAgV3YWl0IAkApAMBBQdsb2NrRW5kAgogdG8gdW5sb2NrAwkAZwIAAAUKdXNlckFtb3VudAkAAgECEW5vdGhpbmcgdG8gdW5sb2NrBAZwZXJpb2QJAQt2YWx1ZU9yRWxzZQIJAJoIAgUMbWF0aENvbnRyYWN0CQENa2V5TmV4dFBlcmlvZAAAAAkAzQgCCQDNCAIJAM4IAgkBD0xvY2tQYXJhbXNFbnRyeQgFC3VzZXJBZGRyZXNzBQp1c2VyTnVtU3RyAAAFCWxvY2tTdGFydAUMbG9ja0R1cmF0aW9uAAAAAAkApAMBBQZwZXJpb2QJAQpTdGF0c0VudHJ5BAkBAS0BBQp1c2VyQW1vdW50AAAAAAD///////////8BCQEMSGlzdG9yeUVudHJ5CAIGdW5sb2NrBQt1c2VyQWRkcmVzcwUKdXNlckFtb3VudAUJbG9ja1N0YXJ0BQxsb2NrRHVyYXRpb24AAAAABQFpCQEOU2NyaXB0VHJhbnNmZXIDCQERQGV4dHJOYXRpdmUoMTA2MikBBQt1c2VyQWRkcmVzcwUKdXNlckFtb3VudAUHYXNzZXRJZAFpARNnd3hVc2VySW5mb1JFQURPTkxZAQt1c2VyQWRkcmVzcwQJZ3d4QW1vdW50CQEUY2FsY0N1cnJlbnRHd3hBbW91bnQBBQt1c2VyQWRkcmVzcwkAlAoCBQNuaWwJAMwIAgUJZ3d4QW1vdW50BQNuaWwBaQEXdXNlck1heER1cmF0aW9uUkVBRE9OTFkBDnVzZXJBZGRyZXNzU3RyBAhjZmdBcnJheQkBFXJlYWRDb25maWdBcnJheU9yRmFpbAAED21heExvY2tEdXJhdGlvbgkBDXBhcnNlSW50VmFsdWUBCQCRAwIFCGNmZ0FycmF5BRVJZHhDZmdNYXhMb2NrRHVyYXRpb24EEHVzZXJSZWNvcmRPcHRpb24JAJ0IAgUEdGhpcwkBE2tleUxvY2tQYXJhbXNSZWNvcmQBBQ51c2VyQWRkcmVzc1N0cgMJAAACBRB1c2VyUmVjb3JkT3B0aW9uBQR1bml0CQCUCgIFA25pbAkAlAoCAgRsb2NrBQ9tYXhMb2NrRHVyYXRpb24ED3VzZXJSZWNvcmRBcnJheQkAtQkCCQEFdmFsdWUBBRB1c2VyUmVjb3JkT3B0aW9uBQNTRVAECWxvY2tTdGFydAkBDXBhcnNlSW50VmFsdWUBCQCRAwIFD3VzZXJSZWNvcmRBcnJheQUMSWR4TG9ja1N0YXJ0BAxsb2NrRHVyYXRpb24JAQ1wYXJzZUludFZhbHVlAQkAkQMCBQ91c2VyUmVjb3JkQXJyYXkFD0lkeExvY2tEdXJhdGlvbgQHbG9ja0VuZAkAZAIFCWxvY2tTdGFydAUMbG9ja0R1cmF0aW9uBBFyZW1haW5pbmdEdXJhdGlvbgkAlgMBCQDMCAIJAGUCBQdsb2NrRW5kBQZoZWlnaHQJAMwIAgAABQNuaWwEEG1heERlbHRhRHVyYXRpb24JAGUCBQ9tYXhMb2NrRHVyYXRpb24FEXJlbWFpbmluZ0R1cmF0aW9uCQCUCgIFA25pbAkAlAoCAgxpbmNyZWFzZUxvY2sFEG1heERlbHRhRHVyYXRpb24BaQEgZ2V0VXNlckd3eEFtb3VudEF0SGVpZ2h0UkVBRE9OTFkCC3VzZXJBZGRyZXNzDHRhcmdldEhlaWdodAQJZ3d4QW1vdW50CQEZY2FsY1VzZXJHd3hBbW91bnRBdEhlaWdodAIFC3VzZXJBZGRyZXNzBQx0YXJnZXRIZWlnaHQJAJQKAgUDbmlsBQlnd3hBbW91bnQBaQEZZ2V0VG90YWxDYWNoZWRHd3hSRUFET05MWQAJAJQKAgUDbmlsCQERZ2V0VG90YWxDYWNoZWRHd3gBBgFpAQpzZXRNYW5hZ2VyARdwZW5kaW5nTWFuYWdlclB1YmxpY0tleQQLY2hlY2tDYWxsZXIJAQttdXN0TWFuYWdlcgEFAWkDCQAAAgULY2hlY2tDYWxsZXIFC2NoZWNrQ2FsbGVyBBVjaGVja01hbmFnZXJQdWJsaWNLZXkJANkEAQUXcGVuZGluZ01hbmFnZXJQdWJsaWNLZXkDCQAAAgUVY2hlY2tNYW5hZ2VyUHVibGljS2V5BRVjaGVja01hbmFnZXJQdWJsaWNLZXkJAMwIAgkBC1N0cmluZ0VudHJ5AgkBGmtleVBlbmRpbmdNYW5hZ2VyUHVibGljS2V5AAUXcGVuZGluZ01hbmFnZXJQdWJsaWNLZXkFA25pbAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgFpAQ5jb25maXJtTWFuYWdlcgAEAnBtCQEdcGVuZGluZ01hbmFnZXJQdWJsaWNLZXlPclVuaXQABAVoYXNQTQMJAQlpc0RlZmluZWQBBQJwbQYJAAIBAhJObyBwZW5kaW5nIG1hbmFnZXIDCQAAAgUFaGFzUE0FBWhhc1BNBAdjaGVja1BNAwkAAAIIBQFpD2NhbGxlclB1YmxpY0tleQkBBXZhbHVlAQUCcG0GCQACAQIbWW91IGFyZSBub3QgcGVuZGluZyBtYW5hZ2VyAwkAAAIFB2NoZWNrUE0FB2NoZWNrUE0JAMwIAgkBC1N0cmluZ0VudHJ5AgkBE2tleU1hbmFnZXJQdWJsaWNLZXkACQDYBAEJAQV2YWx1ZQEFAnBtCQDMCAIJAQtEZWxldGVFbnRyeQEJARprZXlQZW5kaW5nTWFuYWdlclB1YmxpY0tleQAFA25pbAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgECdHgBBnZlcmlmeQAED3RhcmdldFB1YmxpY0tleQQHJG1hdGNoMAkBFm1hbmFnZXJQdWJsaWNLZXlPclVuaXQAAwkAAQIFByRtYXRjaDACCkJ5dGVWZWN0b3IEAnBrBQckbWF0Y2gwBQJwawMJAAECBQckbWF0Y2gwAgRVbml0CAUCdHgPc2VuZGVyUHVibGljS2V5CQACAQILTWF0Y2ggZXJyb3IJAPQDAwgFAnR4CWJvZHlCeXRlcwkAkQMCCAUCdHgGcHJvb2ZzAAAFD3RhcmdldFB1YmxpY0tleXRT82U=",
    "height": 2483798,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: AWFnmYZtC6RyNi6csCyo54SYcLKHoCQ9rvvJmEqE2tBZ

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let SEP = "__"
5+
6+let SCALE8 = 8
7+
8+let MULT8 = 100000000
9+
10+let POOLWEIGHTMULT = MULT8
11+
12+func wrapErr (msg) = makeString(["boosting.ride:", msg], " ")
13+
14+
15+func throwErr (msg) = throw(wrapErr(msg))
16+
17+
18+func strf (address,key) = valueOrErrorMessage(getString(address, key), (("mandatory this." + key) + " is not defined"))
19+
20+
21+func ioz (address,key) = valueOrElse(getInteger(address, key), 0)
22+
23+
24+func iod (address,key,defaultVal) = valueOrElse(getInteger(address, key), defaultVal)
25+
26+
27+func iof (address,key) = valueOrErrorMessage(getInteger(address, key), (("mandatory this." + key) + " is not defined"))
28+
29+
30+func abs (val) = if ((0 > val))
31+    then -(val)
32+    else val
33+
34+
35+func aal (val) = match val {
36+    case valAnyLyst: List[Any] => 
37+        valAnyLyst
38+    case _ => 
39+        throw("fail to cast into List[Any]")
40+}
41+
42+
43+func ai (val) = match val {
44+    case valInt: Int => 
45+        valInt
46+    case _ => 
47+        throw("fail to cast into Int")
48+}
49+
50+
51+func keyReferralsContractAddress () = makeString(["%s%s", "config", "referralsContractAddress"], SEP)
52+
53+
54+let referralsContractAddressOrFail = addressFromStringValue(strf(this, keyReferralsContractAddress()))
55+
56+let keyReferralProgramName = makeString(["%s%s", "referral", "programName"], SEP)
57+
58+let referralProgramNameDefault = "wxlock"
59+
60+let referralProgramName = valueOrElse(getString(this, keyReferralProgramName), referralProgramNameDefault)
61+
62+func keyFactoryAddress () = "%s%s__config__factoryAddress"
63+
64+
65+let IdxFactoryCfgStakingDapp = 1
66+
67+let IdxFactoryCfgBoostingDapp = 2
68+
69+let IdxFactoryCfgIdoDapp = 3
70+
71+let IdxFactoryCfgTeamDapp = 4
72+
73+let IdxFactoryCfgEmissionDapp = 5
74+
75+let IdxFactoryCfgRestDapp = 6
76+
77+let IdxFactoryCfgSlippageDapp = 7
78+
79+let IdxFactoryCfgDaoDapp = 8
80+
81+let IdxFactoryCfgMarketingDapp = 9
82+
83+let IdxFactoryCfgGwxRewardDapp = 10
84+
85+let IdxFactoryCfgBirdsDapp = 11
86+
87+func keyFactoryCfg () = "%s__factoryConfig"
88+
89+
90+func keyFactoryLp2AssetsMapping (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
91+
92+
93+func keyFactoryLpList () = "%s__lpTokensList"
94+
95+
96+func keyFactoryLpAssetToPoolContractAddress (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
97+
98+
99+func keyFactoryPoolWeight (contractAddress) = makeString(["%s%s", "poolWeight", contractAddress], SEP)
100+
101+
102+func keyFactoryPoolWeightHistory (poolAddress,num) = ((("%s%s__poolWeight__" + poolAddress) + "__") + toString(num))
103+
104+
105+func readFactoryAddressOrFail () = addressFromStringValue(strf(this, keyFactoryAddress()))
106+
107+
108+func readLpList () = split(valueOrElse(getString(readFactoryAddressOrFail(), keyFactoryLpList()), ""), SEP)
109+
110+
111+func readFactoryCfgOrFail (factory) = split(strf(factory, keyFactoryCfg()), SEP)
112+
113+
114+func getBoostingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgBoostingDapp])
115+
116+
117+func getEmissionAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgEmissionDapp])
118+
119+
120+func getStakingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgStakingDapp])
121+
122+
123+func getGwxRewardAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgGwxRewardDapp])
124+
125+
126+func keyManagerPublicKey () = "%s__managerPublicKey"
127+
128+
129+func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
130+
131+
132+func keyEmissionRatePerBlockCurrent () = "%s%s__ratePerBlock__current"
133+
134+
135+func keyEmissionRatePerBlockMaxCurrent () = "%s%s__ratePerBlockMax__current"
136+
137+
138+func keyEmissionStartBlock () = "%s%s__emission__startBlock"
139+
140+
141+func keyEmissionDurationInBlocks () = "%s%s__emission__duration"
142+
143+
144+func keyEmissionEndBlock () = "%s%s__emission__endBlock"
145+
146+
147+func keyNextPeriod () = "%s__nextPeriod"
148+
149+
150+func keyGwxRewardEmissionStartHeight () = "%s%s__gwxRewardEmissionPart__startHeight"
151+
152+
153+let IdxCfgAssetId = 1
154+
155+let IdxCfgMinLockAmount = 2
156+
157+let IdxCfgMinLockDuration = 3
158+
159+let IdxCfgMaxLockDuration = 4
160+
161+let IdxCfgMathContract = 5
162+
163+func keyConfig () = "%s__config"
164+
165+
166+func readConfigArrayOrFail () = split(strf(this, keyConfig()), SEP)
167+
168+
169+let mathContract = addressFromStringValue(readConfigArrayOrFail()[IdxCfgMathContract])
170+
171+func formatConfigS (assetId,minLockAmount,minLockDuration,maxLockDuration,mathContract) = makeString(["%s%d%d%d", assetId, minLockAmount, minLockDuration, maxLockDuration, mathContract], SEP)
172+
173+
174+func formatConfig (assetId,minLockAmount,minLockDuration,maxLockDuration,mathContract) = formatConfigS(assetId, toString(minLockAmount), toString(minLockDuration), toString(maxLockDuration), mathContract)
175+
176+
177+func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
178+    case s: String => 
179+        fromBase58String(s)
180+    case _: Unit => 
181+        unit
182+    case _ => 
183+        throw("Match error")
184+}
185+
186+
187+func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
188+    case s: String => 
189+        fromBase58String(s)
190+    case _: Unit => 
191+        unit
192+    case _ => 
193+        throw("Match error")
194+}
195+
196+
197+func mustManager (i) = {
198+    let pd = throw("Permission denied")
199+    match managerPublicKeyOrUnit() {
200+        case pk: ByteVector => 
201+            if ((i.callerPublicKey == pk))
202+                then true
203+                else pd
204+        case _: Unit => 
205+            if ((i.caller == this))
206+                then true
207+                else pd
208+        case _ => 
209+            throw("Match error")
210+    }
211+    }
212+
213+
214+let IdxLockUserNum = 1
215+
216+let IdxLockAmount = 2
217+
218+let IdxLockStart = 3
219+
220+let IdxLockDuration = 4
221+
222+let IdxLockParamK = 5
223+
224+let IdxLockParamB = 6
225+
226+func keyLockParamsRecord (userAddress) = makeString(["%s%s__lock", userAddress], SEP)
227+
228+
229+func readLockParamsRecordOrFail (userAddress) = split(strf(this, keyLockParamsRecord(userAddress)), SEP)
230+
231+
232+func formatLockParamsRecordS (userNum,amount,start,duration,paramK,paramB,lastUpdTimestamp,gwxAmount) = makeString(["%d%d%d%d%d%d%d%d", userNum, amount, start, duration, paramK, paramB, lastUpdTimestamp, gwxAmount], SEP)
233+
234+
235+func formatLockParamsRecord (userNum,amount,start,duration,paramK,paramB,gwxAmount) = formatLockParamsRecordS(userNum, toString(amount), toString(start), toString(duration), toString(paramK), toString(paramB), toString(lastBlock.timestamp), toString(gwxAmount))
236+
237+
238+func keyNextUserNum () = "%s__nextUserNum"
239+
240+
241+func keyUser2NumMapping (userAddress) = makeString(["%s%s%s__mapping__user2num", userAddress], SEP)
242+
243+
244+func keyNum2UserMapping (num) = makeString(["%s%s%s__mapping__num2user", num], SEP)
245+
246+
247+func keyLockParamUserAmount (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "amount"], SEP)
248+
249+
250+func keyLockParamStartBlock (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "start"], SEP)
251+
252+
253+func keyLockParamDuration (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "duration"], SEP)
254+
255+
256+func keyLockParamK (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "k"], SEP)
257+
258+
259+func keyLockParamB (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "b"], SEP)
260+
261+
262+func keyLockParamByPeriodK (userNum,period) = makeString(["%s%d%s%d__paramByPeriod", userNum, "k", period], SEP)
263+
264+
265+func keyLockParamByPeriodB (userNum,period) = makeString(["%s%d%s%d__paramByPeriod", userNum, "b", period], SEP)
266+
267+
268+func keyLockParamTotalAmount () = "%s%s__stats__activeTotalLocked"
269+
270+
271+func keyStatsLocksDurationSumInBlocks () = "%s%s__stats__locksDurationSumInBlocks"
272+
273+
274+func keyStatsLocksCount () = "%s%s__stats__locksCount"
275+
276+
277+func keyStatsUsersCount () = "%s%s__stats__activeUsersCount"
278+
279+
280+func keyUserBoostEmissionLastINTEGRAL (userNum) = makeString(["%s%d__userBoostEmissionLastInt", userNum], SEP)
281+
282+
283+func keyUserLpBoostEmissionLastINTEGRAL (userNum,lpAssetId) = makeString(["%s%d__userBoostEmissionLastInt", userNum, lpAssetId], SEP)
284+
285+
286+func keyUserMaxBoostINTEGRAL (userNum) = makeString(["%s%d__maxBoostInt", userNum], SEP)
287+
288+
289+func keyTotalMaxBoostINTEGRAL () = "%s%s__maxBoostInt__total"
290+
291+
292+func keyUserBoostAvalaibleToClaimTotal (userNum) = makeString(["%s%d__userBoostAvaliableToClaimTotal", userNum], SEP)
293+
294+
295+func keyUserBoostClaimed (userNum) = makeString(["%s%d__userBoostClaimed", userNum], SEP)
296+
297+
298+func keyTotalCachedGwx () = "%s%s__gwxCached__total"
299+
300+
301+func keyTotalCachedGwxCorrective () = "%s__gwxCachedTotalCorrective"
302+
303+
304+let factoryContract = readFactoryAddressOrFail()
305+
306+let factoryCfg = readFactoryCfgOrFail(factoryContract)
307+
308+let emissionContract = getEmissionAddressOrFail(factoryCfg)
309+
310+let stakingContract = getStakingAddressOrFail(factoryCfg)
311+
312+let gwxRewardContract = getGwxRewardAddressOrFail(factoryCfg)
313+
314+let lpStakingPoolsContract = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(makeString(["%s", "lpStakingPoolsContract"], SEP)), wrapErr("lp_staking_pools contract address is undefined"))), wrapErr("invalid lp_staking_pools contract address"))
315+
316+func getTotalCachedGwx (correct) = {
317+    let keyVotingEmissionContract = makeString(["%s", "votingEmissionContract"], SEP)
318+    let votingEmissionContract = addressFromStringValue(getStringValue(factoryContract, keyVotingEmissionContract))
319+    let keyCurrentEpochUi = makeString(["%s", "currentEpochUi"], SEP)
320+    let currentEpochUi = getIntegerValue(votingEmissionContract, keyCurrentEpochUi)
321+    let keyTargetEpoch = makeString(["%s%s", "totalCachedGwxCorrection__activationEpoch"], SEP)
322+    let targetEpochOption = getInteger(this, keyTargetEpoch)
323+    let totalCachedGwxRaw = valueOrElse(getInteger(this, keyTotalCachedGwx()), 0)
324+    let isCorrectionActivated = if (isDefined(targetEpochOption))
325+        then (currentEpochUi >= value(targetEpochOption))
326+        else false
327+    let corrective = if (if (isCorrectionActivated)
328+        then correct
329+        else false)
330+        then valueOrElse(getInteger(this, keyTotalCachedGwxCorrective()), 0)
331+        else 0
332+    max([0, (totalCachedGwxRaw + corrective)])
333+    }
334+
335+
336+func HistoryEntry (type,user,amount,lockStart,duration,k,b,i) = {
337+    let historyKEY = makeString(["%s%s%s%s__history", type, user, toBase58String(i.transactionId)], SEP)
338+    let historyDATA = makeString(["%d%d%d%d%d%d%d", toString(lastBlock.height), toString(lastBlock.timestamp), toString(amount), toString(lockStart), toString(duration), toString(k), toString(b)], SEP)
339+    StringEntry(historyKEY, historyDATA)
340+    }
341+
342+
343+func StatsEntry (totalLockedInc,durationInc,lockCountInc,usersCountInc) = {
344+    let locksDurationSumInBlocksKEY = keyStatsLocksDurationSumInBlocks()
345+    let locksCountKEY = keyStatsLocksCount()
346+    let usersCountKEY = keyStatsUsersCount()
347+    let totalAmountKEY = keyLockParamTotalAmount()
348+    let locksDurationSumInBlocks = ioz(this, locksDurationSumInBlocksKEY)
349+    let locksCount = ioz(this, locksCountKEY)
350+    let usersCount = ioz(this, usersCountKEY)
351+    let totalAmount = ioz(this, totalAmountKEY)
352+[IntegerEntry(locksDurationSumInBlocksKEY, (locksDurationSumInBlocks + durationInc)), IntegerEntry(locksCountKEY, (locksCount + lockCountInc)), IntegerEntry(usersCountKEY, (usersCount + usersCountInc)), IntegerEntry(totalAmountKEY, (totalAmount + totalLockedInc))]
353+    }
354+
355+
356+func calcGwxAmount (kRaw,bRaw,h) = {
357+    let SCALE = 1000
358+    (((kRaw * h) + bRaw) / SCALE)
359+    }
360+
361+
362+func LockParamsEntry (userAddress,userNum,amount,start,duration,k,b,period) = {
363+    let userAmountKEY = keyLockParamUserAmount(userNum)
364+    let startBlockKEY = keyLockParamStartBlock(userNum)
365+    let durationKEY = keyLockParamDuration(userNum)
366+    let kKEY = keyLockParamK(userNum)
367+    let bKEY = keyLockParamB(userNum)
368+    let kByPeriodKEY = keyLockParamByPeriodK(userNum, period)
369+    let bByPeriodKEY = keyLockParamByPeriodB(userNum, period)
370+    let gwxAmount = calcGwxAmount(k, b, height)
371+[IntegerEntry(userAmountKEY, amount), IntegerEntry(startBlockKEY, start), IntegerEntry(durationKEY, duration), IntegerEntry(kKEY, k), IntegerEntry(bKEY, b), IntegerEntry(kByPeriodKEY, k), IntegerEntry(bByPeriodKEY, b), StringEntry(keyLockParamsRecord(userAddress), formatLockParamsRecord(userNum, amount, start, duration, k, b, gwxAmount))]
372+    }
373+
374+
375+func extractOptionalPaymentAmountOrFail (i,expectedAssetId) = if ((size(i.payments) > 1))
376+    then throw("only one payment is allowed")
377+    else if ((size(i.payments) == 0))
378+        then 0
379+        else {
380+            let pmt = i.payments[0]
381+            if ((value(pmt.assetId) != expectedAssetId))
382+                then throw("invalid asset id in payment")
383+                else pmt.amount
384+            }
385+
386+
387+func calcUserGwxAmountAtHeight (userAddress,targetHeight) = {
388+    let EMPTY = "empty"
389+    let user2NumMappingKEY = keyUser2NumMapping(userAddress)
390+    let userNum = valueOrElse(getString(user2NumMappingKEY), EMPTY)
391+    let k = valueOrElse(getInteger(keyLockParamK(userNum)), 0)
392+    let b = valueOrElse(getInteger(keyLockParamB(userNum)), 0)
393+    let gwxAmountCalc = calcGwxAmount(k, b, targetHeight)
394+    let gwxAmount = if ((0 > gwxAmountCalc))
395+        then 0
396+        else gwxAmountCalc
397+    gwxAmount
398+    }
399+
400+
401+func calcCurrentGwxAmount (userAddress) = calcUserGwxAmountAtHeight(userAddress, height)
402+
403+
404+func internalClaimWxBoost (lpAssetIdStr,userAddressStr,readOnly) = {
405+    let EMPTY = "EMPTY"
406+    let userRecordOrEmpty = valueOrElse(getString(this, keyLockParamsRecord(userAddressStr)), EMPTY)
407+    if ((userRecordOrEmpty == EMPTY))
408+        then $Tuple3(0, nil, "userRecord::is::empty")
409+        else {
410+            let userRecordArray = split(userRecordOrEmpty, SEP)
411+            let userNumStr = userRecordArray[IdxLockUserNum]
412+            let gwxRewardEmissionStartHeight = valueOrElse(getInteger(gwxRewardContract, keyGwxRewardEmissionStartHeight()), 0)
413+            let EMPTYSTR = "empty"
414+            let $t01574516323 = if ((lpAssetIdStr != EMPTYSTR))
415+                then {
416+                    let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr))
417+                    let pw1 = getIntegerValue(factoryContract, keyFactoryPoolWeight(poolAddressStr))
418+                    let pw0 = valueOrElse(getInteger(factoryContract, keyFactoryPoolWeightHistory(poolAddressStr, 0)), pw1)
419+                    $Tuple2(pw0, pw1)
420+                    }
421+                else if (readOnly)
422+                    then $Tuple2(0, 0)
423+                    else throw(("not readonly mode: unsupported lp asset " + lpAssetIdStr))
424+            let poolWeight0 = $t01574516323._1
425+            let poolWeight1 = $t01574516323._2
426+            let wxEmissionPerBlock = iof(emissionContract, keyEmissionRatePerBlockCurrent())
427+            let emissionStart = iof(emissionContract, keyEmissionStartBlock())
428+            let emissionEnd = iof(emissionContract, keyEmissionEndBlock())
429+            let h = if ((height > emissionEnd))
430+                then emissionEnd
431+                else height
432+            let dh = max([(h - emissionStart), 0])
433+            let userLpBoostEmissionLastIntegralKEY = keyUserLpBoostEmissionLastINTEGRAL(userNumStr, lpAssetIdStr)
434+            let userBoostEmissionLastIntegralKEY = keyUserBoostEmissionLastINTEGRAL(userNumStr)
435+            let userBoostEmissionLastIntegral = valueOrElse(getInteger(this, userLpBoostEmissionLastIntegralKEY), ioz(this, userBoostEmissionLastIntegralKEY))
436+            let boostEmissionIntegral = (((wxEmissionPerBlock * dh) * 2) / 3)
437+            let userBoostEmissionIntegral = (boostEmissionIntegral - userBoostEmissionLastIntegral)
438+            let udh = fraction(userBoostEmissionIntegral, 3, (2 * wxEmissionPerBlock))
439+            let uLastH = (h - udh)
440+            let udh0 = max([(gwxRewardEmissionStartHeight - uLastH), 0])
441+            let udh1 = ((h - uLastH) - udh0)
442+            if (if (if ((0 > uLastH))
443+                then true
444+                else (0 > udh1))
445+                then true
446+                else (abs(((udh0 + udh1) - udh)) >= 1))
447+                then throw(((((((((((("invalid udh calc: udh=" + toString(udh)) + " uLastH=") + toString(uLastH)) + " udh0=") + toString(udh0)) + " udh1=") + toString(udh1)) + " lpAssetId=") + lpAssetIdStr) + " userAddress=") + userAddressStr))
448+                else if ((0 > userBoostEmissionIntegral))
449+                    then throw("wrong calculations")
450+                    else {
451+                        let userMaxBoostIntegralKEY = keyUserMaxBoostINTEGRAL(userNumStr)
452+                        let totalMaxBoostIntegralKEY = keyTotalMaxBoostINTEGRAL()
453+                        let userMaxBoostInt = ioz(this, userMaxBoostIntegralKEY)
454+                        let totalMaxBoostInt = ioz(this, totalMaxBoostIntegralKEY)
455+                        let totalCachedGwxCorrected = getTotalCachedGwx(true)
456+                        let userCurrGwx = calcCurrentGwxAmount(userAddressStr)
457+                        let userBoostAvalaibleToClaimTotalKEY = keyUserBoostAvalaibleToClaimTotal(userNumStr)
458+                        let userBoostAvaliableToClaimTotal = ioz(this, userBoostAvalaibleToClaimTotalKEY)
459+                        let userBoostEmissionIntegral0 = if ((udh == 0))
460+                            then 0
461+                            else fraction(userBoostEmissionIntegral, udh0, udh)
462+                        let userBoostEmissionIntegral1 = if ((udh == 0))
463+                            then 0
464+                            else fraction(userBoostEmissionIntegral, udh1, udh)
465+                        let poolUserBoostEmissionIntegral0 = fraction(userBoostEmissionIntegral0, poolWeight0, POOLWEIGHTMULT)
466+                        let poolUserBoostEmissionIntegral1 = fraction(userBoostEmissionIntegral1, poolWeight1, POOLWEIGHTMULT)
467+                        let userBoostAvaliableToClaimTotalNew0 = if ((totalCachedGwxCorrected == 0))
468+                            then 0
469+                            else fraction(poolUserBoostEmissionIntegral0, userCurrGwx, totalCachedGwxCorrected)
470+                        let userBoostAvaliableToClaimTotalNew1 = if ((totalCachedGwxCorrected == 0))
471+                            then 0
472+                            else fraction(poolUserBoostEmissionIntegral1, userCurrGwx, totalCachedGwxCorrected)
473+                        let userBoostAvaliableToClaimTotalNew = (userBoostAvaliableToClaimTotalNew0 + userBoostAvaliableToClaimTotalNew1)
474+                        let userBoostClaimedKEY = keyUserBoostClaimed(userNumStr)
475+                        let userBoostClaimed = ioz(this, userBoostClaimedKEY)
476+                        let userBoostAvailable = (userBoostAvaliableToClaimTotalNew - userBoostClaimed)
477+                        let dataState = [IntegerEntry(userLpBoostEmissionLastIntegralKEY, boostEmissionIntegral)]
478+                        let debug = makeString([toString(userBoostEmissionLastIntegral), toString(userBoostEmissionIntegral), toString(userBoostClaimed), toString(userBoostAvailable), toString(poolWeight0), toString(poolWeight1), toString(h), toString(udh), toString(uLastH), toString(udh0), toString(udh1), toString(userCurrGwx), toString(totalCachedGwxCorrected)], ":")
479+                        $Tuple3(userBoostAvaliableToClaimTotalNew, dataState, debug)
480+                        }
481+            }
482+    }
483+
484+
485+func lockActions (i,duration) = {
486+    let cfgArray = readConfigArrayOrFail()
487+    let assetIdStr = cfgArray[IdxCfgAssetId]
488+    let assetId = fromBase58String(assetIdStr)
489+    let minLockAmount = parseIntValue(cfgArray[IdxCfgMinLockAmount])
490+    let minLockDuration = parseIntValue(cfgArray[IdxCfgMinLockDuration])
491+    let maxLockDuration = parseIntValue(cfgArray[IdxCfgMaxLockDuration])
492+    if ((size(i.payments) != 1))
493+        then throw("invalid payment - exact one payment must be attached")
494+        else {
495+            let pmt = i.payments[0]
496+            let pmtAmount = pmt.amount
497+            if ((assetId != value(pmt.assetId)))
498+                then throw((("invalid asset is in payment - " + assetIdStr) + " is expected"))
499+                else {
500+                    let nextUserNumKEY = keyNextUserNum()
501+                    let userAddressStr = toString(i.caller)
502+                    let userIsExisting = isDefined(getString(keyUser2NumMapping(userAddressStr)))
503+                    let userNumStr = if (userIsExisting)
504+                        then value(getString(keyUser2NumMapping(userAddressStr)))
505+                        else toString(iof(this, nextUserNumKEY))
506+                    let userNum = parseIntValue(userNumStr)
507+                    let lockStart = height
508+                    let startBlockKEY = keyLockParamStartBlock(userNumStr)
509+                    let durationKEY = keyLockParamDuration(userNumStr)
510+                    let userAmountKEY = keyLockParamUserAmount(userNumStr)
511+                    if (if ((minLockAmount > pmtAmount))
512+                        then (i.caller != lpStakingPoolsContract)
513+                        else false)
514+                        then throw(("amount is less then minLockAmount=" + toString(minLockAmount)))
515+                        else if ((minLockDuration > duration))
516+                            then throw(("passed duration is less then minLockDuration=" + toString(minLockDuration)))
517+                            else if ((duration > maxLockDuration))
518+                                then throw(("passed duration is greater then maxLockDuration=" + toString(maxLockDuration)))
519+                                else if (if (userIsExisting)
520+                                    then ((iof(this, startBlockKEY) + iof(this, durationKEY)) >= lockStart)
521+                                    else false)
522+                                    then throw("there is an active lock - consider to use increaseLock")
523+                                    else if ((ioz(this, userAmountKEY) > 0))
524+                                        then throw(("there are locked WXs - consider to use increaseLock " + userAmountKEY))
525+                                        else {
526+                                            let coeffX8 = fraction(duration, MULT8, maxLockDuration)
527+                                            let gWxAmountStart = fraction(pmtAmount, coeffX8, MULT8)
528+                                            let gWxParamsResultList = aal(invoke(mathContract, "calcGwxParamsREADONLY", [gWxAmountStart, lockStart, duration], nil))
529+                                            let k = ai(gWxParamsResultList[0])
530+                                            let b = ai(gWxParamsResultList[1])
531+                                            let period = toString(ai(gWxParamsResultList[2]))
532+                                            let wxEmissionPerBlock = iof(emissionContract, keyEmissionRatePerBlockCurrent())
533+                                            let emissionStart = iof(emissionContract, keyEmissionStartBlock())
534+                                            let emissionEnd = iof(emissionContract, keyEmissionEndBlock())
535+                                            let h = if ((height > emissionEnd))
536+                                                then emissionEnd
537+                                                else height
538+                                            let dh = max([(h - emissionStart), 0])
539+                                            let userBoostEmissionLastIntegralKEY = keyUserBoostEmissionLastINTEGRAL(userNumStr)
540+                                            let boostEmissionIntegral = (((wxEmissionPerBlock * dh) * 2) / 3)
541+                                            let userMaxBoostIntegralKEY = keyUserMaxBoostINTEGRAL(userNumStr)
542+                                            let totalMaxBoostIntegralKEY = keyTotalMaxBoostINTEGRAL()
543+                                            let userMaxBoostInt = ((gWxAmountStart * duration) / 2)
544+                                            let totalMaxBoostInt = ioz(this, totalMaxBoostIntegralKEY)
545+                                            let totalCachedGwxRaw = getTotalCachedGwx(false)
546+                                            let arr = if (userIsExisting)
547+                                                then nil
548+                                                else [IntegerEntry(nextUserNumKEY, (userNum + 1)), StringEntry(keyUser2NumMapping(userAddressStr), userNumStr), StringEntry(keyNum2UserMapping(userNumStr), userAddressStr)]
549+                                            $Tuple2(((((arr ++ LockParamsEntry(userAddressStr, userNumStr, pmtAmount, lockStart, duration, k, b, period)) ++ StatsEntry(pmtAmount, duration, 1, if (userIsExisting)
550+                                                then 0
551+                                                else 1)) :+ HistoryEntry("lock", userAddressStr, pmtAmount, lockStart, duration, k, b, i)) ++ [IntegerEntry(userBoostEmissionLastIntegralKEY, boostEmissionIntegral), IntegerEntry(keyTotalCachedGwx(), (totalCachedGwxRaw + gWxAmountStart))]), gWxAmountStart)
552+                                            }
553+                    }
554+            }
555+    }
556+
557+
558+@Callable(i)
559+func constructor (factoryAddressStr,lockAssetIdStr,minLockAmount,minDuration,maxDuration,mathContract) = {
560+    let checkCaller = mustManager(i)
561+    if ((checkCaller == checkCaller))
562+        then ([IntegerEntry(keyNextUserNum(), 0), StringEntry(keyConfig(), formatConfig(lockAssetIdStr, minLockAmount, minDuration, maxDuration, mathContract)), StringEntry(keyFactoryAddress(), factoryAddressStr)] ++ StatsEntry(0, 0, 0, 0))
563+        else throw("Strict value is not equal to itself.")
564+    }
565+
566+
567+
568+@Callable(i)
569+func lockRef (duration,referrerAddress,signature) = {
570+    let $t02495825023 = lockActions(i, duration)
571+    let lockActionsResult = $t02495825023._1
572+    let gWxAmountStart = $t02495825023._2
573+    let referralAddress = toString(i.caller)
574+    let refInv = if (if ((referrerAddress == ""))
575+        then true
576+        else (signature == base58''))
577+        then unit
578+        else invoke(referralsContractAddressOrFail, "createPair", [referralProgramName, referrerAddress, referralAddress, signature], nil)
579+    if ((refInv == refInv))
580+        then {
581+            let updateRefActivity = invoke(mathContract, "updateReferralActivity", [toString(i.caller), gWxAmountStart], nil)
582+            if ((updateRefActivity == updateRefActivity))
583+                then $Tuple2(lockActionsResult, unit)
584+                else throw("Strict value is not equal to itself.")
585+            }
586+        else throw("Strict value is not equal to itself.")
587+    }
588+
589+
590+
591+@Callable(i)
592+func lock (duration) = {
593+    let $t02549325558 = lockActions(i, duration)
594+    let lockActionsResult = $t02549325558._1
595+    let gWxAmountStart = $t02549325558._2
596+    let updateRefActivity = invoke(mathContract, "updateReferralActivity", [toString(i.caller), gWxAmountStart], nil)
597+    if ((updateRefActivity == updateRefActivity))
598+        then $Tuple2(lockActionsResult, unit)
599+        else throw("Strict value is not equal to itself.")
600+    }
601+
602+
603+
604+@Callable(i)
605+func increaseLock (deltaDuration) = {
606+    let cfgArray = readConfigArrayOrFail()
607+    let assetIdStr = cfgArray[IdxCfgAssetId]
608+    let assetId = fromBase58String(assetIdStr)
609+    let minLockDuration = parseIntValue(cfgArray[IdxCfgMinLockDuration])
610+    let maxLockDuration = parseIntValue(cfgArray[IdxCfgMaxLockDuration])
611+    let pmtAmount = extractOptionalPaymentAmountOrFail(i, assetId)
612+    let userAddressStr = toString(i.caller)
613+    let userRecordArray = readLockParamsRecordOrFail(userAddressStr)
614+    let userNumStr = userRecordArray[IdxLockUserNum]
615+    let userAmount = parseIntValue(userRecordArray[IdxLockAmount])
616+    let lockStart = parseIntValue(userRecordArray[IdxLockStart])
617+    let lockDuration = parseIntValue(userRecordArray[IdxLockDuration])
618+    let lockEnd = (lockStart + lockDuration)
619+    let remainingDuration = max([(lockEnd - height), 0])
620+    let userAmountNew = (userAmount + pmtAmount)
621+    let lockDurationNew = (remainingDuration + deltaDuration)
622+    if ((0 > deltaDuration))
623+        then throw("duration is less then zero")
624+        else if ((minLockDuration > lockDurationNew))
625+            then throw(("lockDurationNew is less then minLockDuration=" + toString(minLockDuration)))
626+            else if ((lockDurationNew > maxLockDuration))
627+                then throw(("deltaDuration + existedLockDuration is greater then maxLockDuration=" + toString(maxLockDuration)))
628+                else {
629+                    let coeffX8 = fraction(lockDurationNew, MULT8, maxLockDuration)
630+                    let gWxAmountStart = fraction(userAmountNew, coeffX8, MULT8)
631+                    let updateRefActivity = invoke(mathContract, "updateReferralActivity", [toString(i.caller), gWxAmountStart], nil)
632+                    if ((updateRefActivity == updateRefActivity))
633+                        then {
634+                            let lockStartNew = height
635+                            let gWxParamsResultList = aal(invoke(mathContract, "calcGwxParamsREADONLY", [gWxAmountStart, lockStartNew, lockDurationNew], nil))
636+                            let k = ai(gWxParamsResultList[0])
637+                            let b = ai(gWxParamsResultList[1])
638+                            let period = toString(ai(gWxParamsResultList[2]))
639+                            let wxEmissionPerBlock = iof(emissionContract, keyEmissionRatePerBlockCurrent())
640+                            let emissionStart = iof(emissionContract, keyEmissionStartBlock())
641+                            let emissionEnd = iof(emissionContract, keyEmissionEndBlock())
642+                            let h = if ((height > emissionEnd))
643+                                then emissionEnd
644+                                else height
645+                            let dh = max([(h - emissionStart), 0])
646+                            let userBoostEmissionLastIntegralKEY = keyUserBoostEmissionLastINTEGRAL(userNumStr)
647+                            let userBoostEmissionLastIntegral = ioz(this, userBoostEmissionLastIntegralKEY)
648+                            let boostEmissionIntegral = (((wxEmissionPerBlock * dh) * 2) / 3)
649+                            let userBoostEmissionIntegral = (boostEmissionIntegral - userBoostEmissionLastIntegral)
650+                            if ((0 > userBoostEmissionIntegral))
651+                                then throw("wrong calculations")
652+                                else {
653+                                    let userMaxBoostIntegralKEY = keyUserMaxBoostINTEGRAL(userNumStr)
654+                                    let totalMaxBoostIntegralKEY = keyTotalMaxBoostINTEGRAL()
655+                                    let userMaxBoostInt = ioz(this, userMaxBoostIntegralKEY)
656+                                    let totalMaxBoostInt = ioz(this, totalMaxBoostIntegralKEY)
657+                                    let currUserGwx = calcCurrentGwxAmount(userAddressStr)
658+                                    let gwxDiff = (gWxAmountStart - currUserGwx)
659+                                    if ((0 > gwxDiff))
660+                                        then throw(("gwxDiff is less then 0: " + toString(gwxDiff)))
661+                                        else {
662+                                            let totalCachedGwxRaw = getTotalCachedGwx(false)
663+                                            let totalCachedGwxCorrected = getTotalCachedGwx(true)
664+                                            let userBoostAvalaibleToClaimTotalKEY = keyUserBoostAvalaibleToClaimTotal(userNumStr)
665+                                            let userBoostAvaliableToClaimTotal = ioz(this, userBoostAvalaibleToClaimTotalKEY)
666+                                            let userBoostAvaliableToClaimTotalNew = fraction(userBoostEmissionIntegral, currUserGwx, totalCachedGwxCorrected)
667+                                            let userMaxBoostIntNew = ((gWxAmountStart * lockDurationNew) / 2)
668+                                            let remainingUserMaxBoostInt = ((currUserGwx * remainingDuration) / 2)
669+                                            let userMaxBoostIntDiff = (userMaxBoostIntNew - remainingUserMaxBoostInt)
670+                                            (((LockParamsEntry(userAddressStr, userNumStr, userAmountNew, lockStartNew, lockDurationNew, k, b, period) ++ StatsEntry(pmtAmount, deltaDuration, 0, 0)) :+ HistoryEntry("lock", userAddressStr, pmtAmount, lockStart, lockDurationNew, k, b, i)) ++ [IntegerEntry(keyTotalCachedGwx(), (totalCachedGwxRaw + gwxDiff))])
671+                                            }
672+                                    }
673+                            }
674+                        else throw("Strict value is not equal to itself.")
675+                    }
676+    }
677+
678+
679+
680+@Callable(i)
681+func claimWxBoost (lpAssetIdStr,userAddressStr) = if ((stakingContract != i.caller))
682+    then throw("permissions denied")
683+    else {
684+        let $t03063430736 = internalClaimWxBoost(lpAssetIdStr, userAddressStr, false)
685+        let userBoostAvailable = $t03063430736._1
686+        let dataState = $t03063430736._2
687+        let debug = $t03063430736._3
688+        $Tuple2(dataState, [userBoostAvailable])
689+        }
690+
691+
692+
693+@Callable(i)
694+func claimWxBoostREADONLY (lpAssetIdStr,userAddressStr) = {
695+    let $t03087530976 = internalClaimWxBoost(lpAssetIdStr, userAddressStr, true)
696+    let userBoostAvailable = $t03087530976._1
697+    let dataState = $t03087530976._2
698+    let debug = $t03087530976._3
699+    $Tuple2(nil, [userBoostAvailable, debug])
700+    }
701+
702+
703+
704+@Callable(i)
705+func unlock (userAddress) = {
706+    let userRecordArray = readLockParamsRecordOrFail(userAddress)
707+    let userNumStr = userRecordArray[IdxLockUserNum]
708+    let userAmount = parseIntValue(userRecordArray[IdxLockAmount])
709+    let lockStart = parseIntValue(userRecordArray[IdxLockStart])
710+    let lockDuration = parseIntValue(userRecordArray[IdxLockDuration])
711+    let lockEnd = (lockStart + lockDuration)
712+    let cfgArray = readConfigArrayOrFail()
713+    let assetId = fromBase58String(cfgArray[IdxCfgAssetId])
714+    if ((lockEnd >= height))
715+        then throw((("wait " + toString(lockEnd)) + " to unlock"))
716+        else if ((0 >= userAmount))
717+            then throw("nothing to unlock")
718+            else {
719+                let period = valueOrElse(getInteger(mathContract, keyNextPeriod()), 0)
720+                (((LockParamsEntry(userAddress, userNumStr, 0, lockStart, lockDuration, 0, 0, toString(period)) ++ StatsEntry(-(userAmount), 0, 0, -1)) :+ HistoryEntry("unlock", userAddress, userAmount, lockStart, lockDuration, 0, 0, i)) :+ ScriptTransfer(addressFromStringValue(userAddress), userAmount, assetId))
721+                }
722+    }
723+
724+
725+
726+@Callable(i)
727+func gwxUserInfoREADONLY (userAddress) = {
728+    let gwxAmount = calcCurrentGwxAmount(userAddress)
729+    $Tuple2(nil, [gwxAmount])
730+    }
731+
732+
733+
734+@Callable(i)
735+func userMaxDurationREADONLY (userAddressStr) = {
736+    let cfgArray = readConfigArrayOrFail()
737+    let maxLockDuration = parseIntValue(cfgArray[IdxCfgMaxLockDuration])
738+    let userRecordOption = getString(this, keyLockParamsRecord(userAddressStr))
739+    if ((userRecordOption == unit))
740+        then $Tuple2(nil, $Tuple2("lock", maxLockDuration))
741+        else {
742+            let userRecordArray = split(value(userRecordOption), SEP)
743+            let lockStart = parseIntValue(userRecordArray[IdxLockStart])
744+            let lockDuration = parseIntValue(userRecordArray[IdxLockDuration])
745+            let lockEnd = (lockStart + lockDuration)
746+            let remainingDuration = max([(lockEnd - height), 0])
747+            let maxDeltaDuration = (maxLockDuration - remainingDuration)
748+            $Tuple2(nil, $Tuple2("increaseLock", maxDeltaDuration))
749+            }
750+    }
751+
752+
753+
754+@Callable(i)
755+func getUserGwxAmountAtHeightREADONLY (userAddress,targetHeight) = {
756+    let gwxAmount = calcUserGwxAmountAtHeight(userAddress, targetHeight)
757+    $Tuple2(nil, gwxAmount)
758+    }
759+
760+
761+
762+@Callable(i)
763+func getTotalCachedGwxREADONLY () = $Tuple2(nil, getTotalCachedGwx(true))
764+
765+
766+
767+@Callable(i)
768+func setManager (pendingManagerPublicKey) = {
769+    let checkCaller = mustManager(i)
770+    if ((checkCaller == checkCaller))
771+        then {
772+            let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
773+            if ((checkManagerPublicKey == checkManagerPublicKey))
774+                then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
775+                else throw("Strict value is not equal to itself.")
776+            }
777+        else throw("Strict value is not equal to itself.")
778+    }
779+
780+
781+
782+@Callable(i)
783+func confirmManager () = {
784+    let pm = pendingManagerPublicKeyOrUnit()
785+    let hasPM = if (isDefined(pm))
786+        then true
787+        else throw("No pending manager")
788+    if ((hasPM == hasPM))
789+        then {
790+            let checkPM = if ((i.callerPublicKey == value(pm)))
791+                then true
792+                else throw("You are not pending manager")
793+            if ((checkPM == checkPM))
794+                then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
795+                else throw("Strict value is not equal to itself.")
796+            }
797+        else throw("Strict value is not equal to itself.")
798+    }
799+
800+
801+@Verifier(tx)
802+func verify () = {
803+    let targetPublicKey =     match managerPublicKeyOrUnit() {
804+        case pk: ByteVector => 
805+            pk
806+        case _: Unit => 
807+            tx.senderPublicKey
808+        case _ => 
809+            throw("Match error")
810+    }
811+    sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
812+    }
813+
github/deemru/w8io/873ac7e 
53.68 ms ◑