tx · 7RCbYiWejhAfGZ2VqkycHN2V787wRYo4sLWkyjaoGP6C

3MvfuRGqNjHPZjni3Xf8eZNa8yVSjy1YJwy:  -0.01000000 Waves

2021.11.23 15:26 [1803666] smart account 3MvfuRGqNjHPZjni3Xf8eZNa8yVSjy1YJwy > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "7RCbYiWejhAfGZ2VqkycHN2V787wRYo4sLWkyjaoGP6C",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1637670413123,
    "version": 1,
    "sender": "3MvfuRGqNjHPZjni3Xf8eZNa8yVSjy1YJwy",
    "senderPublicKey": "4G3urRLkmwczZagvu8zbJJSq387b5HcjzxE6KpDHNp5t",
    "proofs": [
        "5DG2q1Yv8bwJLtPUzym7sxBPr5WZhp2HLP376vdkx1EjnxuHeKx2h3bNt3MvAvWxEeiyoAjkqkwwKEHeQBd6mZwN"
    ],
    "script": "base64:AAIFAAAAAAAAAC4IAhIHCgUCAQEBARIAEgASBwoFAgEBAQESABIDCgEIEgUKAwEBARIGCgQICAgBAAAAJQAAAAALcmV2aXNpb25OdW0CAAAAAAAAAAADU0VQAgAAAAJfXwAAAAAITUFYREVQVEgAAAAAAAAAABEAAAAACVVTRVJERVBUSAAAAAAAAAAAGgAAAAAFU0NBTEUAAAAAAAAAA+gBAAAADmdldE51bWJlckJ5S2V5AAAAAQAAAANrZXkJAQAAAAt2YWx1ZU9yRWxzZQAAAAIJAAQaAAAAAgUAAAAEdGhpcwUAAAADa2V5AAAAAAAAAAAAAQAAAA5nZXRTdHJpbmdCeUtleQAAAAEAAAADa2V5CQEAAAALdmFsdWVPckVsc2UAAAACCQAEHQAAAAIFAAAABHRoaXMFAAAAA2tleQIAAAAAAQAAAA9nZXRTdHJpbmdPckZhaWwAAAABAAAAA2tleQkBAAAAE3ZhbHVlT3JFcnJvck1lc3NhZ2UAAAACCQAEIgAAAAEFAAAAA2tleQkAASwAAAACCQABLAAAAAICAAAAD21hbmRhdG9yeSB0aGlzLgUAAAADa2V5AgAAAA8gaXMgbm90IGRlZmluZWQAAAAADUlkeENmZ0Fzc2V0SWQAAAAAAAAAAAEAAAAAFklkeENmZ1BhY2VtYWtlckFkZHJlc3MAAAAAAAAAAAIAAAAAFklkeENmZ0Jvb3N0aW5nQ29udHJhY3QAAAAAAAAAAAMAAAAADklkeENmZ01heERlcHRoAAAAAAAAAAAEAQAAAAlrZXlDb25maWcAAAAAAgAAAAolc19fY29uZmlnAQAAABVyZWFkQ29uZmlnQXJyYXlPckZhaWwAAAAACQAEtQAAAAIJAQAAAA9nZXRTdHJpbmdPckZhaWwAAAABCQEAAAAJa2V5Q29uZmlnAAAAAAUAAAADU0VQAQAAAAxmb3JtYXRDb25maWcAAAAEAAAADHd4QXNzZXRJZFN0cgAAABptYXRjaGVyUGFjZW1ha2VyQWRkcmVzc1N0cgAAABpib29zdGluZ0NvbnRyYWN0QWRkcmVzc1N0cgAAAAhtYXhEZXB0aAkABLkAAAACCQAETAAAAAICAAAACCVzJXMlcyVkCQAETAAAAAIFAAAADHd4QXNzZXRJZFN0cgkABEwAAAACBQAAABptYXRjaGVyUGFjZW1ha2VyQWRkcmVzc1N0cgkABEwAAAACBQAAABpib29zdGluZ0NvbnRyYWN0QWRkcmVzc1N0cgkABEwAAAACCQABpAAAAAEFAAAACG1heERlcHRoBQAAAANuaWwFAAAAA1NFUAEAAAANa2V5VXNlcnNDb3VudAAAAAACAAAADyVzX19uZXh0VXNlck51bQEAAAAUa2V5TmV4dFByb2Nlc3NlZFVzZXIAAAAAAgAAABUlc19fbmV4dFByb2Nlc3NlZFVzZXIBAAAAD2tleUxhdGVzdFBlcmlvZAAAAAACAAAAECVzX19sYXRlc3RQZXJpb2QBAAAADWtleU5leHRQZXJpb2QAAAAAAgAAAA4lc19fbmV4dFBlcmlvZAEAAAAWa2V5TmV4dFByb2Nlc3NlZFBlcmlvZAAAAAACAAAAFyVzX19uZXh0UHJvY2Vzc2VkUGVyaW9kAQAAABtrZXlOZXh0VW5sYWltZWRQZXJpb2RPZlVzZXIAAAABAAAACXVzZXJJbmRleAkABLkAAAACCQAETAAAAAICAAAAFyVzJWRfX25leHRDbGFpbWVkUGVyaW9kCQAETAAAAAIJAAGkAAAAAQUAAAAJdXNlckluZGV4BQAAAANuaWwFAAAAA1NFUAEAAAAca2V5TGFzdFByb2Nlc3NlZFBlcmlvZE9mVXNlcgAAAAEAAAAJdXNlckluZGV4CQAEuQAAAAIJAARMAAAAAgIAAAAZJXMlZF9fbGFzdFByb2Nlc3NlZFBlcmlvZAkABEwAAAACCQABpAAAAAEFAAAACXVzZXJJbmRleAUAAAADbmlsBQAAAANTRVABAAAAEmtleUhlaWdodEZvclBlcmlvZAAAAAEAAAAGcGVyaW9kCQAEuQAAAAIJAARMAAAAAgIAAAAaJXMlZF9fc3RhcnRIZWlnaHRGb3JQZXJpb2QJAARMAAAAAgkAAaQAAAABBQAAAAZwZXJpb2QFAAAAA25pbAUAAAADU0VQAQAAABdrZXlUb3RhbEFtb3VudEZvclBlcmlvZAAAAAEAAAAGcGVyaW9kCQAEuQAAAAIJAARMAAAAAgIAAAAaJXMlZF9fdG90YWxBbW91bnRGb3JQZXJpb2QJAARMAAAAAgkAAaQAAAABBQAAAAZwZXJpb2QFAAAAA25pbAUAAAADU0VQAQAAABdrZXlUb3RhbFdlaWdodEZvclBlcmlvZAAAAAEAAAAGcGVyaW9kCQAEuQAAAAIJAARMAAAAAgIAAAAaJXMlZF9fdG90YWxXZWlnaHRGb3JQZXJpb2QJAARMAAAAAgkAAaQAAAABBQAAAAZwZXJpb2QFAAAAA25pbAUAAAADU0VQAQAAABZrZXlVc2VyS1ZhbHVlRm9yUGVyaW9kAAAAAgAAAAZwZXJpb2QAAAAJdXNlckluZGV4CQAEuQAAAAIJAARMAAAAAgIAAAAXJXMlZCVzJWRfX3BhcmFtQnlQZXJpb2QJAARMAAAAAgkAAaQAAAABBQAAAAl1c2VySW5kZXgJAARMAAAAAgIAAAABawkABEwAAAACCQABpAAAAAEFAAAABnBlcmlvZAUAAAADbmlsBQAAAANTRVABAAAAFmtleVVzZXJCVmFsdWVGb3JQZXJpb2QAAAACAAAABnBlcmlvZAAAAAl1c2VySW5kZXgJAAS5AAAAAgkABEwAAAACAgAAABclcyVkJXMlZF9fcGFyYW1CeVBlcmlvZAkABEwAAAACCQABpAAAAAEFAAAACXVzZXJJbmRleAkABEwAAAACAgAAAAFiCQAETAAAAAIJAAGkAAAAAQUAAAAGcGVyaW9kBQAAAANuaWwFAAAAA1NFUAEAAAAMSGlzdG9yeUVudHJ5AAAABgAAAAR0eXBlAAAABHVzZXIAAAAGYW1vdW50AAAADWN1cnJlbnRQZXJpb2QAAAAMbGF0ZXN0UGVyaW9kAAAAAWkEAAAACmhpc3RvcnlLRVkJAAS5AAAAAgkABEwAAAACAgAAABElcyVzJXMlc19faGlzdG9yeQkABEwAAAACBQAAAAR0eXBlCQAETAAAAAIFAAAABHVzZXIJAARMAAAAAgkAAlgAAAABCAUAAAABaQAAAA10cmFuc2FjdGlvbklkBQAAAANuaWwFAAAAA1NFUAQAAAALaGlzdG9yeURBVEEJAAS5AAAAAgkABEwAAAACAgAAAAolZCVkJWQlZCVkCQAETAAAAAIJAAGkAAAAAQgFAAAACWxhc3RCbG9jawAAAAZoZWlnaHQJAARMAAAAAgkAAaQAAAABCAUAAAAJbGFzdEJsb2NrAAAACXRpbWVzdGFtcAkABEwAAAACCQABpAAAAAEFAAAABmFtb3VudAkABEwAAAACCQABpAAAAAEFAAAADWN1cnJlbnRQZXJpb2QJAARMAAAAAgkAAaQAAAABBQAAAAxsYXRlc3RQZXJpb2QFAAAAA25pbAUAAAADU0VQCQEAAAALU3RyaW5nRW50cnkAAAACBQAAAApoaXN0b3J5S0VZBQAAAAtoaXN0b3J5REFUQQEAAAAOY2FsY1VzZXJXZWlnaHQAAAAEAAAAF2Jvb3N0aW5nQ29udHJhY3RBZGRyZXNzAAAAD2hlaWdodEZvclBlcmlvZAAAAAZwZXJpb2QAAAAJdXNlckluZGV4BAAAAAVrTGFzdAkBAAAAHGtleUxhc3RQcm9jZXNzZWRQZXJpb2RPZlVzZXIAAAABBQAAAAl1c2VySW5kZXgEAAAABGtLZXkJAQAAABZrZXlVc2VyS1ZhbHVlRm9yUGVyaW9kAAAAAgUAAAAGcGVyaW9kBQAAAAl1c2VySW5kZXgEAAAABGtSYXcJAAQaAAAAAgUAAAAXYm9vc3RpbmdDb250cmFjdEFkZHJlc3MFAAAABGtLZXkDCQEAAAAJaXNEZWZpbmVkAAAAAQUAAAAEa1JhdwQAAAABawkBAAAABXZhbHVlAAAAAQUAAAAEa1JhdwQAAAABYgkBAAAABXZhbHVlAAAAAQkABBoAAAACBQAAABdib29zdGluZ0NvbnRyYWN0QWRkcmVzcwkBAAAAFmtleVVzZXJCVmFsdWVGb3JQZXJpb2QAAAACBQAAAAZwZXJpb2QFAAAACXVzZXJJbmRleAQAAAABdwkAAGQAAAACCQAAaAAAAAIFAAAAAWsFAAAAD2hlaWdodEZvclBlcmlvZAUAAAABYgMJAABmAAAAAgUAAAABdwAAAAAAAAAAAAkABRQAAAACCQAAaQAAAAIFAAAAAXcFAAAABVNDQUxFCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACBQAAAAVrTGFzdAUAAAAGcGVyaW9kBQAAAANuaWwJAAUUAAAAAgAAAAAAAAAAAAUAAAADbmlsBAAAAAFwCQAEGgAAAAIFAAAABHRoaXMFAAAABWtMYXN0AwkBAAAACWlzRGVmaW5lZAAAAAEFAAAAAXAEAAAAAnB2CQEAAAAFdmFsdWUAAAABBQAAAAFwBAAAAAFrCQEAAAAFdmFsdWUAAAABCQAEGgAAAAIFAAAAF2Jvb3N0aW5nQ29udHJhY3RBZGRyZXNzCQEAAAAWa2V5VXNlcktWYWx1ZUZvclBlcmlvZAAAAAIFAAAAAnB2BQAAAAl1c2VySW5kZXgEAAAAAWIJAQAAAAV2YWx1ZQAAAAEJAAQaAAAAAgUAAAAXYm9vc3RpbmdDb250cmFjdEFkZHJlc3MJAQAAABZrZXlVc2VyQlZhbHVlRm9yUGVyaW9kAAAAAgUAAAACcHYFAAAACXVzZXJJbmRleAQAAAABdwkAAGQAAAACCQAAaAAAAAIFAAAAAWsFAAAAD2hlaWdodEZvclBlcmlvZAUAAAABYgMJAABmAAAAAgUAAAABdwAAAAAAAAAAAAkABRQAAAACCQAAaQAAAAIFAAAAAXcFAAAABVNDQUxFBQAAAANuaWwJAAUUAAAAAgAAAAAAAAAAAAUAAAADbmlsCQAFFAAAAAIAAAAAAAAAAAAFAAAAA25pbAEAAAAVZ2V0VXNlckluZGV4QnlBZGRyZXNzAAAAAgAAABpib29zdGluZ0NvbnRyYWN0QWRkcmVzc1N0cgAAAAt1c2VyQWRkcmVzcwQAAAADa2V5CQAEuQAAAAIJAARMAAAAAgIAAAAGJXMlcyVzCQAETAAAAAICAAAAB21hcHBpbmcJAARMAAAAAgIAAAAIdXNlcjJudW0JAARMAAAAAgUAAAALdXNlckFkZHJlc3MFAAAAA25pbAUAAAADU0VQCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAQAAABN2YWx1ZU9yRXJyb3JNZXNzYWdlAAAAAgkABB0AAAACCQEAAAAHQWRkcmVzcwAAAAEJAAJZAAAAAQUAAAAaYm9vc3RpbmdDb250cmFjdEFkZHJlc3NTdHIFAAAAA2tleQkAASwAAAACCQABLAAAAAIJAAEsAAAAAgIAAAANVXNlciBhZGRyZXNzIAUAAAALdXNlckFkZHJlc3MCAAAALSBpcyBub3QgZm91bmQgaW4gYm9vc3RpbmcgY29udHJhY3QgZGF0YSwga2V5PQUAAAADa2V5AQAAAApuZXh0UGVyaW9kAAAAAAkBAAAADmdldE51bWJlckJ5S2V5AAAAAQkBAAAADWtleU5leHRQZXJpb2QAAAAAAQAAAA1pbnZva2VQcm9jZXNzAAAABQAAABBib29zdGluZ0NvbnRyYWN0AAAABnBlcmlvZAAAAAR1c2VyAAAABWRlcHRoAAAABndlaWdodAQAAAAGcmVzdWx0CQAD/AAAAAQFAAAABHRoaXMCAAAAEHByb2Nlc3NOZXh0QmF0Y2gJAARMAAAAAgUAAAAQYm9vc3RpbmdDb250cmFjdAkABEwAAAACBQAAAAZwZXJpb2QJAARMAAAAAgUAAAAEdXNlcgkABEwAAAACBQAAAAVkZXB0aAkABEwAAAACBQAAAAZ3ZWlnaHQFAAAAA25pbAUAAAADbmlsAwkAAAAAAAACBQAAAAZyZXN1bHQFAAAABnJlc3VsdAQAAAAHJG1hdGNoMAUAAAAGcmVzdWx0AwkAAAEAAAACBQAAAAckbWF0Y2gwAgAAAA8oSW50LCBJbnQsIEludCkEAAAAAXIFAAAAByRtYXRjaDAFAAAAAXIJAAACAAAAAQIAAAAXSW5jb3JyZWN0IGludm9rZSByZXN1bHQJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAQAAABVjaGVja0xhc3RQYXJ0T2ZQZXJpb2QAAAAGAAAAEGJvb3N0aW5nQ29udHJhY3QAAAANY3VycmVudFBlcmlvZAAAAAxsYXRlc3RQZXJpb2QAAAAFZGVwdGgAAAAOdG90YWxXZWlnaHRLZXkAAAAGd2VpZ2h0AwkAAGcAAAACBQAAAAxsYXRlc3RQZXJpb2QJAABkAAAAAgUAAAANY3VycmVudFBlcmlvZAAAAAAAAAAAAQkBAAAADWludm9rZVByb2Nlc3MAAAAFBQAAABBib29zdGluZ0NvbnRyYWN0CQAAZAAAAAIFAAAADWN1cnJlbnRQZXJpb2QAAAAAAAAAAAEAAAAAAAAAAAAJAABlAAAAAgUAAAAFZGVwdGgAAAAAAAAAAAEAAAAAAAAAAAAJAAUVAAAAAwkAAGQAAAACBQAAAA1jdXJyZW50UGVyaW9kAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAQAAABhwcm9jZXNzTmV4dEJhdGNoSW50ZXJuYWwAAAAFAAAAEGJvb3N0aW5nQ29udHJhY3QAAAANY3VycmVudFBlcmlvZAAAAAtjdXJyZW50VXNlcgAAAAVkZXB0aAAAAAt0b3RhbFdlaWdodAQAAAAXYm9vc3RpbmdDb250cmFjdEFkZHJlc3MJAQAAAAdBZGRyZXNzAAAAAQUAAAAQYm9vc3RpbmdDb250cmFjdAQAAAAMbGF0ZXN0UGVyaW9kCQEAAAAOZ2V0TnVtYmVyQnlLZXkAAAABCQEAAAAPa2V5TGF0ZXN0UGVyaW9kAAAAAAQAAAAKdXNlcnNDb3VudAkBAAAAC3ZhbHVlT3JFbHNlAAAAAgkABBoAAAACBQAAABdib29zdGluZ0NvbnRyYWN0QWRkcmVzcwkBAAAADWtleVVzZXJzQ291bnQAAAAAAAAAAAAAAAAABAAAAA50b3RhbFdlaWdodEtleQkBAAAAF2tleVRvdGFsV2VpZ2h0Rm9yUGVyaW9kAAAAAQUAAAANY3VycmVudFBlcmlvZAQAAAAPaGVpZ2h0Rm9yUGVyaW9kCQEAAAAOZ2V0TnVtYmVyQnlLZXkAAAABCQEAAAASa2V5SGVpZ2h0Rm9yUGVyaW9kAAAAAQUAAAANY3VycmVudFBlcmlvZAMDCQAAZgAAAAIFAAAABWRlcHRoAAAAAAAAAAAACQAAZwAAAAIFAAAADGxhdGVzdFBlcmlvZAUAAAANY3VycmVudFBlcmlvZAcEAAAAAnQwCQEAAAAOY2FsY1VzZXJXZWlnaHQAAAAEBQAAABdib29zdGluZ0NvbnRyYWN0QWRkcmVzcwUAAAAPaGVpZ2h0Rm9yUGVyaW9kBQAAAA1jdXJyZW50UGVyaW9kBQAAAAtjdXJyZW50VXNlcgQAAAAHd2VpZ2h0MAkAAGQAAAACBQAAAAt0b3RhbFdlaWdodAgFAAAAAnQwAAAAAl8xAwkAAGYAAAACBQAAAAp1c2Vyc0NvdW50CQAAZAAAAAIFAAAAC2N1cnJlbnRVc2VyAAAAAAAAAAABBAAAAAJ0MQkBAAAADmNhbGNVc2VyV2VpZ2h0AAAABAUAAAAXYm9vc3RpbmdDb250cmFjdEFkZHJlc3MFAAAAD2hlaWdodEZvclBlcmlvZAUAAAANY3VycmVudFBlcmlvZAkAAGQAAAACBQAAAAtjdXJyZW50VXNlcgAAAAAAAAAAAQQAAAAHd2VpZ2h0MQkAAGQAAAACBQAAAAd3ZWlnaHQwCAUAAAACdDEAAAACXzEDCQAAZgAAAAIFAAAACnVzZXJzQ291bnQJAABkAAAAAgUAAAALY3VycmVudFVzZXIAAAAAAAAAAAIEAAAAAnQyCQEAAAAOY2FsY1VzZXJXZWlnaHQAAAAEBQAAABdib29zdGluZ0NvbnRyYWN0QWRkcmVzcwUAAAAPaGVpZ2h0Rm9yUGVyaW9kBQAAAA1jdXJyZW50UGVyaW9kCQAAZAAAAAIFAAAAC2N1cnJlbnRVc2VyAAAAAAAAAAACBAAAAAd3ZWlnaHQyCQAAZAAAAAIFAAAAB3dlaWdodDEIBQAAAAJ0MgAAAAJfMQMJAABmAAAAAgUAAAAKdXNlcnNDb3VudAkAAGQAAAACBQAAAAtjdXJyZW50VXNlcgAAAAAAAAAAAwQAAAACdDMJAQAAAA5jYWxjVXNlcldlaWdodAAAAAQFAAAAF2Jvb3N0aW5nQ29udHJhY3RBZGRyZXNzBQAAAA9oZWlnaHRGb3JQZXJpb2QFAAAADWN1cnJlbnRQZXJpb2QJAABkAAAAAgUAAAALY3VycmVudFVzZXIAAAAAAAAAAAMEAAAAB3dlaWdodDMJAABkAAAAAgUAAAAHd2VpZ2h0MggFAAAAAnQzAAAAAl8xAwkAAGYAAAACBQAAAAp1c2Vyc0NvdW50CQAAZAAAAAIFAAAAC2N1cnJlbnRVc2VyAAAAAAAAAAAEBAAAAAJ0NAkBAAAADmNhbGNVc2VyV2VpZ2h0AAAABAUAAAAXYm9vc3RpbmdDb250cmFjdEFkZHJlc3MFAAAAD2hlaWdodEZvclBlcmlvZAUAAAANY3VycmVudFBlcmlvZAkAAGQAAAACBQAAAAtjdXJyZW50VXNlcgAAAAAAAAAABAQAAAAHd2VpZ2h0NAkAAGQAAAACBQAAAAd3ZWlnaHQzCAUAAAACdDQAAAACXzEDCQAAZgAAAAIFAAAACnVzZXJzQ291bnQJAABkAAAAAgUAAAALY3VycmVudFVzZXIAAAAAAAAAAAUEAAAAAnQ1CQEAAAAOY2FsY1VzZXJXZWlnaHQAAAAEBQAAABdib29zdGluZ0NvbnRyYWN0QWRkcmVzcwUAAAAPaGVpZ2h0Rm9yUGVyaW9kBQAAAA1jdXJyZW50UGVyaW9kCQAAZAAAAAIFAAAAC2N1cnJlbnRVc2VyAAAAAAAAAAAFBAAAAAd3ZWlnaHQ1CQAAZAAAAAIFAAAAB3dlaWdodDQIBQAAAAJ0NQAAAAJfMQMJAABmAAAAAgUAAAAKdXNlcnNDb3VudAkAAGQAAAACBQAAAAtjdXJyZW50VXNlcgAAAAAAAAAABgQAAAACcjUJAQAAAA1pbnZva2VQcm9jZXNzAAAABQUAAAAQYm9vc3RpbmdDb250cmFjdAUAAAANY3VycmVudFBlcmlvZAkAAGQAAAACBQAAAAtjdXJyZW50VXNlcgAAAAAAAAAABgkAAGUAAAACBQAAAAVkZXB0aAAAAAAAAAAAAQUAAAAHd2VpZ2h0NQkABRYAAAAECQAETgAAAAIJAAROAAAAAgkABE4AAAACCQAETgAAAAIJAAROAAAAAggFAAAAAnQwAAAAAl8yCAUAAAACdDEAAAACXzIIBQAAAAJ0MgAAAAJfMggFAAAAAnQzAAAAAl8yCAUAAAACdDQAAAACXzIIBQAAAAJ0NQAAAAJfMggFAAAAAnI1AAAAAl8xCAUAAAACcjUAAAACXzIIBQAAAAJyNQAAAAJfMwQAAAACcjUJAQAAABVjaGVja0xhc3RQYXJ0T2ZQZXJpb2QAAAAGBQAAABBib29zdGluZ0NvbnRyYWN0BQAAAA1jdXJyZW50UGVyaW9kBQAAAAxsYXRlc3RQZXJpb2QFAAAABWRlcHRoBQAAAA50b3RhbFdlaWdodEtleQUAAAAHd2VpZ2h0NQkABRYAAAAECQAETgAAAAIJAAROAAAAAgkABE4AAAACCQAETgAAAAIJAAROAAAAAgkABE4AAAACCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACBQAAAA50b3RhbFdlaWdodEtleQUAAAAHd2VpZ2h0NQUAAAADbmlsCAUAAAACdDAAAAACXzIIBQAAAAJ0MQAAAAJfMggFAAAAAnQyAAAAAl8yCAUAAAACdDMAAAACXzIIBQAAAAJ0NAAAAAJfMggFAAAAAnQ1AAAAAl8yCAUAAAACcjUAAAACXzEIBQAAAAJyNQAAAAJfMggFAAAAAnI1AAAAAl8zBAAAAAJyNAkBAAAAFWNoZWNrTGFzdFBhcnRPZlBlcmlvZAAAAAYFAAAAEGJvb3N0aW5nQ29udHJhY3QFAAAADWN1cnJlbnRQZXJpb2QFAAAADGxhdGVzdFBlcmlvZAUAAAAFZGVwdGgFAAAADnRvdGFsV2VpZ2h0S2V5BQAAAAd3ZWlnaHQ0CQAFFgAAAAQJAAROAAAAAgkABE4AAAACCQAETgAAAAIJAAROAAAAAgkABE4AAAACCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACBQAAAA50b3RhbFdlaWdodEtleQUAAAAHd2VpZ2h0NAUAAAADbmlsCAUAAAACdDAAAAACXzIIBQAAAAJ0MQAAAAJfMggFAAAAAnQyAAAAAl8yCAUAAAACdDMAAAACXzIIBQAAAAJ0NAAAAAJfMggFAAAAAnI0AAAAAl8xCAUAAAACcjQAAAACXzIIBQAAAAJyNAAAAAJfMwQAAAACcjMJAQAAABVjaGVja0xhc3RQYXJ0T2ZQZXJpb2QAAAAGBQAAABBib29zdGluZ0NvbnRyYWN0BQAAAA1jdXJyZW50UGVyaW9kBQAAAAxsYXRlc3RQZXJpb2QFAAAABWRlcHRoBQAAAA50b3RhbFdlaWdodEtleQUAAAAHd2VpZ2h0MwkABRYAAAAECQAETgAAAAIJAAROAAAAAgkABE4AAAACCQAETgAAAAIJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIFAAAADnRvdGFsV2VpZ2h0S2V5BQAAAAd3ZWlnaHQzBQAAAANuaWwIBQAAAAJ0MAAAAAJfMggFAAAAAnQxAAAAAl8yCAUAAAACdDIAAAACXzIIBQAAAAJ0MwAAAAJfMggFAAAAAnIzAAAAAl8xCAUAAAACcjMAAAACXzIIBQAAAAJyMwAAAAJfMwQAAAACcjIJAQAAABVjaGVja0xhc3RQYXJ0T2ZQZXJpb2QAAAAGBQAAABBib29zdGluZ0NvbnRyYWN0BQAAAA1jdXJyZW50UGVyaW9kBQAAAAxsYXRlc3RQZXJpb2QFAAAABWRlcHRoBQAAAA50b3RhbFdlaWdodEtleQUAAAAHd2VpZ2h0MgkABRYAAAAECQAETgAAAAIJAAROAAAAAgkABE4AAAACCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACBQAAAA50b3RhbFdlaWdodEtleQUAAAAHd2VpZ2h0MgUAAAADbmlsCAUAAAACdDAAAAACXzIIBQAAAAJ0MQAAAAJfMggFAAAAAnQyAAAAAl8yCAUAAAACcjIAAAACXzEIBQAAAAJyMgAAAAJfMggFAAAAAnIyAAAAAl8zBAAAAAJyMQkBAAAAFWNoZWNrTGFzdFBhcnRPZlBlcmlvZAAAAAYFAAAAEGJvb3N0aW5nQ29udHJhY3QFAAAADWN1cnJlbnRQZXJpb2QFAAAADGxhdGVzdFBlcmlvZAUAAAAFZGVwdGgFAAAADnRvdGFsV2VpZ2h0S2V5BQAAAAd3ZWlnaHQxCQAFFgAAAAQJAAROAAAAAgkABE4AAAACCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACBQAAAA50b3RhbFdlaWdodEtleQUAAAAHd2VpZ2h0MQUAAAADbmlsCAUAAAACdDAAAAACXzIIBQAAAAJ0MQAAAAJfMggFAAAAAnIxAAAAAl8xCAUAAAACcjEAAAACXzIIBQAAAAJyMQAAAAJfMwQAAAACcjAJAQAAABVjaGVja0xhc3RQYXJ0T2ZQZXJpb2QAAAAGBQAAABBib29zdGluZ0NvbnRyYWN0BQAAAA1jdXJyZW50UGVyaW9kBQAAAAxsYXRlc3RQZXJpb2QFAAAABWRlcHRoBQAAAA50b3RhbFdlaWdodEtleQUAAAAHd2VpZ2h0MAkABRYAAAAECQAETgAAAAIJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIFAAAADnRvdGFsV2VpZ2h0S2V5BQAAAAd3ZWlnaHQwBQAAAANuaWwIBQAAAAJ0MAAAAAJfMggFAAAAAnIwAAAAAl8xCAUAAAACcjAAAAACXzIIBQAAAAJyMAAAAAJfMwMJAAAAAAAAAgUAAAALY3VycmVudFVzZXIAAAAAAAAAAAAJAAUWAAAABAUAAAADbmlsBQAAAA1jdXJyZW50UGVyaW9kAAAAAAAAAAAAAAAAAAAAAAAACQAFFgAAAAQJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIFAAAADnRvdGFsV2VpZ2h0S2V5BQAAAAt0b3RhbFdlaWdodAUAAAADbmlsBQAAAA1jdXJyZW50UGVyaW9kBQAAAAtjdXJyZW50VXNlcgAAAAAAAAAAAAEAAAALaW52b2tlQ2xhaW0AAAAFAAAAEGJvb3N0aW5nQ29udHJhY3QAAAAGcGVyaW9kAAAABHVzZXIAAAAFZGVwdGgAAAAFdG90YWwEAAAABnJlc3VsdAkAA/wAAAAEBQAAAAR0aGlzAgAAAA5jbGFpbU5leHRCYXRjaAkABEwAAAACBQAAABBib29zdGluZ0NvbnRyYWN0CQAETAAAAAIFAAAABnBlcmlvZAkABEwAAAACBQAAAAR1c2VyCQAETAAAAAIFAAAABWRlcHRoCQAETAAAAAIFAAAABXRvdGFsBQAAAANuaWwFAAAAA25pbAMJAAAAAAAAAgUAAAAGcmVzdWx0BQAAAAZyZXN1bHQEAAAAByRtYXRjaDAFAAAABnJlc3VsdAMJAAABAAAAAgUAAAAHJG1hdGNoMAIAAAAKKEludCwgSW50KQQAAAABcgUAAAAHJG1hdGNoMAUAAAABcgkAAAIAAAABAgAAABdJbmNvcnJlY3QgaW52b2tlIHJlc3VsdAkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BAAAADWNsYWltSW50ZXJuYWwAAAAFAAAAEGJvb3N0aW5nQ29udHJhY3QAAAANY3VycmVudFBlcmlvZAAAAAtjdXJyZW50VXNlcgAAAAVkZXB0aAAAAA91c2VyQWNjdW11bGF0ZWQEAAAAF2Jvb3N0aW5nQ29udHJhY3RBZGRyZXNzCQEAAAAHQWRkcmVzcwAAAAEFAAAAEGJvb3N0aW5nQ29udHJhY3QEAAAADGxhdGVzdFBlcmlvZAkBAAAADmdldE51bWJlckJ5S2V5AAAAAQkBAAAAFmtleU5leHRQcm9jZXNzZWRQZXJpb2QAAAAABAAAAAt0b3RhbFdlaWdodAkBAAAADmdldE51bWJlckJ5S2V5AAAAAQkBAAAAF2tleVRvdGFsV2VpZ2h0Rm9yUGVyaW9kAAAAAQUAAAANY3VycmVudFBlcmlvZAQAAAAPaGVpZ2h0Rm9yUGVyaW9kCQEAAAAOZ2V0TnVtYmVyQnlLZXkAAAABCQEAAAASa2V5SGVpZ2h0Rm9yUGVyaW9kAAAAAQUAAAANY3VycmVudFBlcmlvZAQAAAANJHQwMTA2OTkxMDgxMQkBAAAADmNhbGNVc2VyV2VpZ2h0AAAABAUAAAAXYm9vc3RpbmdDb250cmFjdEFkZHJlc3MFAAAAD2hlaWdodEZvclBlcmlvZAUAAAANY3VycmVudFBlcmlvZAUAAAALY3VycmVudFVzZXIEAAAACnVzZXJXZWlnaHQIBQAAAA0kdDAxMDY5OTEwODExAAAAAl8xBAAAAAdpZ25vcmVkCAUAAAANJHQwMTA2OTkxMDgxMQAAAAJfMgQAAAATdXNlckFtb3VudEZvclBlcmlvZAkAAGsAAAADCQEAAAAOZ2V0TnVtYmVyQnlLZXkAAAABCQEAAAAXa2V5VG90YWxBbW91bnRGb3JQZXJpb2QAAAABBQAAAA1jdXJyZW50UGVyaW9kBQAAAAp1c2VyV2VpZ2h0BQAAAAt0b3RhbFdlaWdodAMDCQAAZwAAAAIAAAAAAAAAAAAFAAAABWRlcHRoBgkAAGcAAAACCQAAZAAAAAIFAAAADWN1cnJlbnRQZXJpb2QAAAAAAAAAAAEFAAAADGxhdGVzdFBlcmlvZAkABRQAAAACCQAAZAAAAAIFAAAADWN1cnJlbnRQZXJpb2QAAAAAAAAAAAEJAABkAAAAAgUAAAAPdXNlckFjY3VtdWxhdGVkBQAAABN1c2VyQW1vdW50Rm9yUGVyaW9kCQEAAAALaW52b2tlQ2xhaW0AAAAFBQAAABBib29zdGluZ0NvbnRyYWN0CQAAZAAAAAIFAAAADWN1cnJlbnRQZXJpb2QAAAAAAAAAAAEFAAAAC2N1cnJlbnRVc2VyCQAAZQAAAAIFAAAABWRlcHRoAAAAAAAAAAABCQAAZAAAAAIFAAAAD3VzZXJBY2N1bXVsYXRlZAUAAAATdXNlckFtb3VudEZvclBlcmlvZAEAAAARY29tbW9uQ2xhaW1SZXdhcmQAAAABAAAAC3VzZXJBZGRyZXNzBAAAAAhjZmdBcnJheQkBAAAAFXJlYWRDb25maWdBcnJheU9yRmFpbAAAAAAEAAAAB3VzZXJJZHgJAQAAABVnZXRVc2VySW5kZXhCeUFkZHJlc3MAAAACCQABkQAAAAIFAAAACGNmZ0FycmF5BQAAABZJZHhDZmdCb29zdGluZ0NvbnRyYWN0BQAAAAt1c2VyQWRkcmVzcwQAAAANY3VycmVudFBlcmlvZAkBAAAADmdldE51bWJlckJ5S2V5AAAAAQkBAAAAG2tleU5leHRVbmxhaW1lZFBlcmlvZE9mVXNlcgAAAAEFAAAAB3VzZXJJZHgEAAAADGxhdGVzdFBlcmlvZAkBAAAADmdldE51bWJlckJ5S2V5AAAAAQkBAAAAFmtleU5leHRQcm9jZXNzZWRQZXJpb2QAAAAAAwkAAGcAAAACBQAAAA1jdXJyZW50UGVyaW9kBQAAAAxsYXRlc3RQZXJpb2QJAAACAAAAAQIAAAAQTm90aGluZyB0byBjbGFpbQQAAAAQYm9vc3RpbmdDb250cmFjdAkAAlkAAAABCQABkQAAAAIFAAAACGNmZ0FycmF5BQAAABZJZHhDZmdCb29zdGluZ0NvbnRyYWN0BAAAAA0kdDAxMTczMjExODI0CQEAAAANY2xhaW1JbnRlcm5hbAAAAAUFAAAAEGJvb3N0aW5nQ29udHJhY3QFAAAADWN1cnJlbnRQZXJpb2QFAAAAB3VzZXJJZHgFAAAACVVTRVJERVBUSAAAAAAAAAAAAAQAAAAGcGVyaW9kCAUAAAANJHQwMTE3MzIxMTgyNAAAAAJfMQQAAAAGYW1vdW50CAUAAAANJHQwMTE3MzIxMTgyNAAAAAJfMgkABRcAAAAFBQAAAAZwZXJpb2QFAAAABmFtb3VudAUAAAAHdXNlcklkeAUAAAAIY2ZnQXJyYXkFAAAADGxhdGVzdFBlcmlvZAAAAAgAAAABaQEAAAAQcHJvY2Vzc05leHRCYXRjaAAAAAUAAAAQYm9vc3RpbmdDb250cmFjdAAAAA1jdXJyZW50UGVyaW9kAAAAC2N1cnJlbnRVc2VyAAAABWRlcHRoAAAAC3RvdGFsV2VpZ2h0AwkBAAAAAiE9AAAAAggFAAAAAWkAAAAGY2FsbGVyBQAAAAR0aGlzCQAAAgAAAAECAAAAJFNob3VsZCBiZSBjYWxsZWQgYnkgdGhpcyBzY3JpcHQgb25seQQAAAADdHBsCQEAAAAYcHJvY2Vzc05leHRCYXRjaEludGVybmFsAAAABQUAAAAQYm9vc3RpbmdDb250cmFjdAUAAAANY3VycmVudFBlcmlvZAUAAAALY3VycmVudFVzZXIFAAAABWRlcHRoBQAAAAt0b3RhbFdlaWdodAkABRQAAAACCAUAAAADdHBsAAAAAl8xCQAFFQAAAAMIBQAAAAN0cGwAAAACXzIIBQAAAAN0cGwAAAACXzMIBQAAAAN0cGwAAAACXzQAAAABaQEAAAAdcHJvY2Vzc1BlbmRpbmdQZXJpb2RzQW5kVXNlcnMAAAAABAAAAA1jdXJyZW50UGVyaW9kCQEAAAAOZ2V0TnVtYmVyQnlLZXkAAAABCQEAAAAWa2V5TmV4dFByb2Nlc3NlZFBlcmlvZAAAAAADCQAAZgAAAAIFAAAADWN1cnJlbnRQZXJpb2QJAQAAAA5nZXROdW1iZXJCeUtleQAAAAEJAQAAAA9rZXlMYXRlc3RQZXJpb2QAAAAACQAAAgAAAAECAAAAEk5vdGhpbmcgdG8gcHJvY2VzcwQAAAAIY2ZnQXJyYXkJAQAAABVyZWFkQ29uZmlnQXJyYXlPckZhaWwAAAAABAAAAAVkZXB0aAkBAAAADXBhcnNlSW50VmFsdWUAAAABCQABkQAAAAIFAAAACGNmZ0FycmF5BQAAAA5JZHhDZmdNYXhEZXB0aAMJAABmAAAAAgUAAAAFZGVwdGgFAAAACE1BWERFUFRICQAAAgAAAAECAAAAFkRlcHRoIGV4Y2VlZHMgTUFYREVQVEgEAAAAEGJvb3N0aW5nQ29udHJhY3QJAAJZAAAAAQkAAZEAAAACBQAAAAhjZmdBcnJheQUAAAAWSWR4Q2ZnQm9vc3RpbmdDb250cmFjdAQAAAALY3VycmVudFVzZXIJAQAAAA5nZXROdW1iZXJCeUtleQAAAAEJAQAAABRrZXlOZXh0UHJvY2Vzc2VkVXNlcgAAAAAEAAAAC3RvdGFsV2VpZ2h0CQEAAAAOZ2V0TnVtYmVyQnlLZXkAAAABCQEAAAAXa2V5VG90YWxXZWlnaHRGb3JQZXJpb2QAAAABBQAAAA1jdXJyZW50UGVyaW9kBAAAAAFyCQEAAAAYcHJvY2Vzc05leHRCYXRjaEludGVybmFsAAAABQUAAAAQYm9vc3RpbmdDb250cmFjdAUAAAANY3VycmVudFBlcmlvZAUAAAALY3VycmVudFVzZXIFAAAABWRlcHRoBQAAAAt0b3RhbFdlaWdodAkABE0AAAACCQAETQAAAAIIBQAAAAFyAAAAAl8xCQEAAAAMSW50ZWdlckVudHJ5AAAAAgkBAAAAFmtleU5leHRQcm9jZXNzZWRQZXJpb2QAAAAACAUAAAABcgAAAAJfMgkBAAAADEludGVnZXJFbnRyeQAAAAIJAQAAABRrZXlOZXh0UHJvY2Vzc2VkVXNlcgAAAAAIBQAAAAFyAAAAAl8zAAAAAWkBAAAAB2RlcG9zaXQAAAAABAAAAAhjZmdBcnJheQkBAAAAFXJlYWRDb25maWdBcnJheU9yRmFpbAAAAAADCQEAAAACIT0AAAACCAUAAAABaQAAAAZjYWxsZXIJAQAAAAdBZGRyZXNzAAAAAQkAAlkAAAABCQABkQAAAAIFAAAACGNmZ0FycmF5BQAAABZJZHhDZmdQYWNlbWFrZXJBZGRyZXNzCQAAAgAAAAECAAAAFFdyb25nIGNhbGxlciBhZGRyZXNzBAAAAAdhc3NldElkCQEAAAAFdmFsdWUAAAABCAkBAAAABXZhbHVlAAAAAQkAAZEAAAACCAUAAAABaQAAAAhwYXltZW50cwAAAAAAAAAAAAAAAAdhc3NldElkAwkBAAAAAiE9AAAAAgUAAAAHYXNzZXRJZAkAAlkAAAABCQABkQAAAAIFAAAACGNmZ0FycmF5BQAAAA1JZHhDZmdBc3NldElkCQAAAgAAAAECAAAAE1dyb25nIHBheW1lbnQgYXNzZXQEAAAABnBlcmlvZAkBAAAACm5leHRQZXJpb2QAAAAACQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACCQEAAAAPa2V5TGF0ZXN0UGVyaW9kAAAAAAUAAAAGcGVyaW9kCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACCQEAAAASa2V5SGVpZ2h0Rm9yUGVyaW9kAAAAAQUAAAAGcGVyaW9kBQAAAAZoZWlnaHQJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIJAQAAABdrZXlUb3RhbEFtb3VudEZvclBlcmlvZAAAAAEFAAAABnBlcmlvZAgJAQAAAAV2YWx1ZQAAAAEJAAGRAAAAAggFAAAAAWkAAAAIcGF5bWVudHMAAAAAAAAAAAAAAAAGYW1vdW50CQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACCQEAAAANa2V5TmV4dFBlcmlvZAAAAAAJAABkAAAAAgUAAAAGcGVyaW9kAAAAAAAAAAABBQAAAANuaWwAAAABaQEAAAAOY2xhaW1OZXh0QmF0Y2gAAAAFAAAAEGJvb3N0aW5nQ29udHJhY3QAAAANY3VycmVudFBlcmlvZAAAAAtjdXJyZW50VXNlcgAAAAVkZXB0aAAAAAt0b3RhbFdlaWdodAMJAQAAAAIhPQAAAAIIBQAAAAFpAAAABmNhbGxlcgUAAAAEdGhpcwkAAAIAAAABAgAAACRTaG91bGQgYmUgY2FsbGVkIGJ5IHRoaXMgc2NyaXB0IG9ubHkEAAAADnBlcmlvZEFuZFRvdGFsCQEAAAANY2xhaW1JbnRlcm5hbAAAAAUFAAAAEGJvb3N0aW5nQ29udHJhY3QFAAAADWN1cnJlbnRQZXJpb2QFAAAAC2N1cnJlbnRVc2VyBQAAAAVkZXB0aAUAAAALdG90YWxXZWlnaHQJAAUUAAAAAgUAAAADbmlsBQAAAA5wZXJpb2RBbmRUb3RhbAAAAAFpAQAAAAtjbGFpbVJld2FyZAAAAAAEAAAAB2FkZHJlc3MJAAQlAAAAAQgFAAAAAWkAAAAGY2FsbGVyBAAAAA0kdDAxNDc2NDE0ODQ2CQEAAAARY29tbW9uQ2xhaW1SZXdhcmQAAAABBQAAAAdhZGRyZXNzBAAAAAZwZXJpb2QIBQAAAA0kdDAxNDc2NDE0ODQ2AAAAAl8xBAAAAAZhbW91bnQIBQAAAA0kdDAxNDc2NDE0ODQ2AAAAAl8yBAAAAAd1c2VySWR4CAUAAAANJHQwMTQ3NjQxNDg0NgAAAAJfMwQAAAAIY2ZnQXJyYXkIBQAAAA0kdDAxNDc2NDE0ODQ2AAAAAl80BAAAAAxsYXRlc3RQZXJpb2QIBQAAAA0kdDAxNDc2NDE0ODQ2AAAAAl81CQAFFAAAAAIJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIJAQAAABtrZXlOZXh0VW5sYWltZWRQZXJpb2RPZlVzZXIAAAABBQAAAAd1c2VySWR4BQAAAAZwZXJpb2QJAARMAAAAAgkBAAAADlNjcmlwdFRyYW5zZmVyAAAAAwgFAAAAAWkAAAAGY2FsbGVyBQAAAAZhbW91bnQJAAJZAAAAAQkAAZEAAAACBQAAAAhjZmdBcnJheQUAAAANSWR4Q2ZnQXNzZXRJZAkABEwAAAACCQEAAAAMSGlzdG9yeUVudHJ5AAAABgIAAAAFY2xhaW0FAAAAB2FkZHJlc3MFAAAABmFtb3VudAUAAAAGcGVyaW9kBQAAAAxsYXRlc3RQZXJpb2QFAAAAAWkFAAAAA25pbAUAAAAGYW1vdW50AAAAAWkBAAAAE2NsYWltUmV3YXJkUkVBRE9OTFkAAAABAAAAB2FkZHJlc3MEAAAADGNsYWltUmVzdWx0cwkBAAAAEWNvbW1vbkNsYWltUmV3YXJkAAAAAQUAAAAHYWRkcmVzcwQAAAAGYW1vdW50CAUAAAAMY2xhaW1SZXN1bHRzAAAAAl8yCQAFFAAAAAIFAAAAA25pbAUAAAAGYW1vdW50AAAAAWkBAAAAFWNhbGNHd3hQYXJhbXNSRUFET05MWQAAAAMAAAAId3hBbW91bnQAAAAPbG9ja1N0YXJ0SGVpZ2h0AAAAEmxvY2tEdXJhdGlvbkJsb2NrcwQAAAANbG9ja0VuZEhlaWdodAkAAGQAAAACBQAAAA9sb2NrU3RhcnRIZWlnaHQFAAAAEmxvY2tEdXJhdGlvbkJsb2NrcwQAAAAMc2NhbGU4UGFyYW1LCQEAAAABLQAAAAEJAABrAAAAAwUAAAAId3hBbW91bnQFAAAABVNDQUxFBQAAABJsb2NrRHVyYXRpb25CbG9ja3MEAAAADHNjYWxlOFBhcmFtQgkAAGgAAAACCQAAawAAAAMFAAAACHd4QW1vdW50BQAAAAVTQ0FMRQUAAAASbG9ja0R1cmF0aW9uQmxvY2tzBQAAAA1sb2NrRW5kSGVpZ2h0CQAFFAAAAAIFAAAAA25pbAkABEwAAAACBQAAAAxzY2FsZThQYXJhbUsJAARMAAAAAgUAAAAMc2NhbGU4UGFyYW1CCQAETAAAAAIJAQAAAApuZXh0UGVyaW9kAAAAAAUAAAADbmlsAAAAAWkBAAAAC2NvbnN0cnVjdG9yAAAABAAAAAx3eEFzc2V0SWRTdHIAAAAabWF0Y2hlclBhY2VtYWtlckFkZHJlc3NTdHIAAAAaYm9vc3RpbmdDb250cmFjdEFkZHJlc3NTdHIAAAAIbWF4RGVwdGgDCQEAAAACIT0AAAACBQAAAAR0aGlzCAUAAAABaQAAAAZjYWxsZXIJAAACAAAAAQIAAAAObm90IGF1dGhvcml6ZWQJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAACWtleUNvbmZpZwAAAAAJAQAAAAxmb3JtYXRDb25maWcAAAAEBQAAAAx3eEFzc2V0SWRTdHIFAAAAGm1hdGNoZXJQYWNlbWFrZXJBZGRyZXNzU3RyBQAAABpib29zdGluZ0NvbnRyYWN0QWRkcmVzc1N0cgUAAAAIbWF4RGVwdGgFAAAAA25pbAAAAACFDJae",
    "chainId": 84,
    "height": 1803666,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: 2uyBuruEcc67qGb4rKZfxxbyy4m8zEPTRJMH19ihgHKM

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 5 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let revisionNum = ""
5+
6+let SEP = "__"
7+
8+let MAXDEPTH = 17
9+
10+let USERDEPTH = 26
11+
12+let SCALE = 1000
13+
14+func getNumberByKey (key) = valueOrElse(getInteger(this, key), 0)
15+
16+
17+func getStringByKey (key) = valueOrElse(getString(this, key), "")
18+
19+
20+func getStringOrFail (key) = valueOrErrorMessage(getString(key), (("mandatory this." + key) + " is not defined"))
21+
22+
23+let IdxCfgAssetId = 1
24+
25+let IdxCfgPacemakerAddress = 2
26+
27+let IdxCfgBoostingContract = 3
28+
29+let IdxCfgMaxDepth = 4
30+
31+func keyConfig () = "%s__config"
32+
33+
34+func readConfigArrayOrFail () = split(getStringOrFail(keyConfig()), SEP)
35+
36+
37+func formatConfig (wxAssetIdStr,matcherPacemakerAddressStr,boostingContractAddressStr,maxDepth) = makeString(["%s%s%s%d", wxAssetIdStr, matcherPacemakerAddressStr, boostingContractAddressStr, toString(maxDepth)], SEP)
38+
39+
40+func keyUsersCount () = "%s__nextUserNum"
41+
42+
43+func keyNextProcessedUser () = "%s__nextProcessedUser"
44+
45+
46+func keyLatestPeriod () = "%s__latestPeriod"
47+
48+
49+func keyNextPeriod () = "%s__nextPeriod"
50+
51+
52+func keyNextProcessedPeriod () = "%s__nextProcessedPeriod"
53+
54+
55+func keyNextUnlaimedPeriodOfUser (userIndex) = makeString(["%s%d__nextClaimedPeriod", toString(userIndex)], SEP)
56+
57+
58+func keyLastProcessedPeriodOfUser (userIndex) = makeString(["%s%d__lastProcessedPeriod", toString(userIndex)], SEP)
59+
60+
61+func keyHeightForPeriod (period) = makeString(["%s%d__startHeightForPeriod", toString(period)], SEP)
62+
63+
64+func keyTotalAmountForPeriod (period) = makeString(["%s%d__totalAmountForPeriod", toString(period)], SEP)
65+
66+
67+func keyTotalWeightForPeriod (period) = makeString(["%s%d__totalWeightForPeriod", toString(period)], SEP)
68+
69+
70+func keyUserKValueForPeriod (period,userIndex) = makeString(["%s%d%s%d__paramByPeriod", toString(userIndex), "k", toString(period)], SEP)
71+
72+
73+func keyUserBValueForPeriod (period,userIndex) = makeString(["%s%d%s%d__paramByPeriod", toString(userIndex), "b", toString(period)], SEP)
74+
75+
76+func HistoryEntry (type,user,amount,currentPeriod,latestPeriod,i) = {
77+    let historyKEY = makeString(["%s%s%s%s__history", type, user, toBase58String(i.transactionId)], SEP)
78+    let historyDATA = makeString(["%d%d%d%d%d", toString(lastBlock.height), toString(lastBlock.timestamp), toString(amount), toString(currentPeriod), toString(latestPeriod)], SEP)
79+    StringEntry(historyKEY, historyDATA)
80+    }
81+
82+
83+func calcUserWeight (boostingContractAddress,heightForPeriod,period,userIndex) = {
84+    let kLast = keyLastProcessedPeriodOfUser(userIndex)
85+    let kKey = keyUserKValueForPeriod(period, userIndex)
86+    let kRaw = getInteger(boostingContractAddress, kKey)
87+    if (isDefined(kRaw))
88+        then {
89+            let k = value(kRaw)
90+            let b = value(getInteger(boostingContractAddress, keyUserBValueForPeriod(period, userIndex)))
91+            let w = ((k * heightForPeriod) + b)
92+            if ((w > 0))
93+                then $Tuple2((w / SCALE), [IntegerEntry(kLast, period)])
94+                else $Tuple2(0, nil)
95+            }
96+        else {
97+            let p = getInteger(this, kLast)
98+            if (isDefined(p))
99+                then {
100+                    let pv = value(p)
101+                    let k = value(getInteger(boostingContractAddress, keyUserKValueForPeriod(pv, userIndex)))
102+                    let b = value(getInteger(boostingContractAddress, keyUserBValueForPeriod(pv, userIndex)))
103+                    let w = ((k * heightForPeriod) + b)
104+                    if ((w > 0))
105+                        then $Tuple2((w / SCALE), nil)
106+                        else $Tuple2(0, nil)
107+                    }
108+                else $Tuple2(0, nil)
109+            }
110+    }
111+
112+
113+func getUserIndexByAddress (boostingContractAddressStr,userAddress) = {
114+    let key = makeString(["%s%s%s", "mapping", "user2num", userAddress], SEP)
115+    parseIntValue(valueOrErrorMessage(getString(Address(fromBase58String(boostingContractAddressStr)), key), ((("User address " + userAddress) + " is not found in boosting contract data, key=") + key)))
116+    }
117+
118+
119+func nextPeriod () = getNumberByKey(keyNextPeriod())
120+
121+
122+func invokeProcess (boostingContract,period,user,depth,weight) = {
123+    let result = invoke(this, "processNextBatch", [boostingContract, period, user, depth, weight], nil)
124+    if ((result == result))
125+        then         match result {
126+            case r: (Int, Int, Int) => 
127+                r
128+            case _ => 
129+                throw("Incorrect invoke result")
130+        }
131+        else throw("Strict value is not equal to itself.")
132+    }
133+
134+
135+func checkLastPartOfPeriod (boostingContract,currentPeriod,latestPeriod,depth,totalWeightKey,weight) = if ((latestPeriod >= (currentPeriod + 1)))
136+    then invokeProcess(boostingContract, (currentPeriod + 1), 0, (depth - 1), 0)
137+    else $Tuple3((currentPeriod + 1), 0, 0)
138+
139+
140+func processNextBatchInternal (boostingContract,currentPeriod,currentUser,depth,totalWeight) = {
141+    let boostingContractAddress = Address(boostingContract)
142+    let latestPeriod = getNumberByKey(keyLatestPeriod())
143+    let usersCount = valueOrElse(getInteger(boostingContractAddress, keyUsersCount()), 0)
144+    let totalWeightKey = keyTotalWeightForPeriod(currentPeriod)
145+    let heightForPeriod = getNumberByKey(keyHeightForPeriod(currentPeriod))
146+    if (if ((depth > 0))
147+        then (latestPeriod >= currentPeriod)
148+        else false)
149+        then {
150+            let t0 = calcUserWeight(boostingContractAddress, heightForPeriod, currentPeriod, currentUser)
151+            let weight0 = (totalWeight + t0._1)
152+            if ((usersCount > (currentUser + 1)))
153+                then {
154+                    let t1 = calcUserWeight(boostingContractAddress, heightForPeriod, currentPeriod, (currentUser + 1))
155+                    let weight1 = (weight0 + t1._1)
156+                    if ((usersCount > (currentUser + 2)))
157+                        then {
158+                            let t2 = calcUserWeight(boostingContractAddress, heightForPeriod, currentPeriod, (currentUser + 2))
159+                            let weight2 = (weight1 + t2._1)
160+                            if ((usersCount > (currentUser + 3)))
161+                                then {
162+                                    let t3 = calcUserWeight(boostingContractAddress, heightForPeriod, currentPeriod, (currentUser + 3))
163+                                    let weight3 = (weight2 + t3._1)
164+                                    if ((usersCount > (currentUser + 4)))
165+                                        then {
166+                                            let t4 = calcUserWeight(boostingContractAddress, heightForPeriod, currentPeriod, (currentUser + 4))
167+                                            let weight4 = (weight3 + t4._1)
168+                                            if ((usersCount > (currentUser + 5)))
169+                                                then {
170+                                                    let t5 = calcUserWeight(boostingContractAddress, heightForPeriod, currentPeriod, (currentUser + 5))
171+                                                    let weight5 = (weight4 + t5._1)
172+                                                    if ((usersCount > (currentUser + 6)))
173+                                                        then {
174+                                                            let r5 = invokeProcess(boostingContract, currentPeriod, (currentUser + 6), (depth - 1), weight5)
175+                                                            $Tuple4((((((t0._2 ++ t1._2) ++ t2._2) ++ t3._2) ++ t4._2) ++ t5._2), r5._1, r5._2, r5._3)
176+                                                            }
177+                                                        else {
178+                                                            let r5 = checkLastPartOfPeriod(boostingContract, currentPeriod, latestPeriod, depth, totalWeightKey, weight5)
179+                                                            $Tuple4((((((([IntegerEntry(totalWeightKey, weight5)] ++ t0._2) ++ t1._2) ++ t2._2) ++ t3._2) ++ t4._2) ++ t5._2), r5._1, r5._2, r5._3)
180+                                                            }
181+                                                    }
182+                                                else {
183+                                                    let r4 = checkLastPartOfPeriod(boostingContract, currentPeriod, latestPeriod, depth, totalWeightKey, weight4)
184+                                                    $Tuple4(((((([IntegerEntry(totalWeightKey, weight4)] ++ t0._2) ++ t1._2) ++ t2._2) ++ t3._2) ++ t4._2), r4._1, r4._2, r4._3)
185+                                                    }
186+                                            }
187+                                        else {
188+                                            let r3 = checkLastPartOfPeriod(boostingContract, currentPeriod, latestPeriod, depth, totalWeightKey, weight3)
189+                                            $Tuple4((((([IntegerEntry(totalWeightKey, weight3)] ++ t0._2) ++ t1._2) ++ t2._2) ++ t3._2), r3._1, r3._2, r3._3)
190+                                            }
191+                                    }
192+                                else {
193+                                    let r2 = checkLastPartOfPeriod(boostingContract, currentPeriod, latestPeriod, depth, totalWeightKey, weight2)
194+                                    $Tuple4(((([IntegerEntry(totalWeightKey, weight2)] ++ t0._2) ++ t1._2) ++ t2._2), r2._1, r2._2, r2._3)
195+                                    }
196+                            }
197+                        else {
198+                            let r1 = checkLastPartOfPeriod(boostingContract, currentPeriod, latestPeriod, depth, totalWeightKey, weight1)
199+                            $Tuple4((([IntegerEntry(totalWeightKey, weight1)] ++ t0._2) ++ t1._2), r1._1, r1._2, r1._3)
200+                            }
201+                    }
202+                else {
203+                    let r0 = checkLastPartOfPeriod(boostingContract, currentPeriod, latestPeriod, depth, totalWeightKey, weight0)
204+                    $Tuple4(([IntegerEntry(totalWeightKey, weight0)] ++ t0._2), r0._1, r0._2, r0._3)
205+                    }
206+            }
207+        else if ((currentUser == 0))
208+            then $Tuple4(nil, currentPeriod, 0, 0)
209+            else $Tuple4([IntegerEntry(totalWeightKey, totalWeight)], currentPeriod, currentUser, 0)
210+    }
211+
212+
213+func invokeClaim (boostingContract,period,user,depth,total) = {
214+    let result = invoke(this, "claimNextBatch", [boostingContract, period, user, depth, total], nil)
215+    if ((result == result))
216+        then         match result {
217+            case r: (Int, Int) => 
218+                r
219+            case _ => 
220+                throw("Incorrect invoke result")
221+        }
222+        else throw("Strict value is not equal to itself.")
223+    }
224+
225+
226+func claimInternal (boostingContract,currentPeriod,currentUser,depth,userAccumulated) = {
227+    let boostingContractAddress = Address(boostingContract)
228+    let latestPeriod = getNumberByKey(keyNextProcessedPeriod())
229+    let totalWeight = getNumberByKey(keyTotalWeightForPeriod(currentPeriod))
230+    let heightForPeriod = getNumberByKey(keyHeightForPeriod(currentPeriod))
231+    let $t01069910811 = calcUserWeight(boostingContractAddress, heightForPeriod, currentPeriod, currentUser)
232+    let userWeight = $t01069910811._1
233+    let ignored = $t01069910811._2
234+    let userAmountForPeriod = fraction(getNumberByKey(keyTotalAmountForPeriod(currentPeriod)), userWeight, totalWeight)
235+    if (if ((0 >= depth))
236+        then true
237+        else ((currentPeriod + 1) >= latestPeriod))
238+        then $Tuple2((currentPeriod + 1), (userAccumulated + userAmountForPeriod))
239+        else invokeClaim(boostingContract, (currentPeriod + 1), currentUser, (depth - 1), (userAccumulated + userAmountForPeriod))
240+    }
241+
242+
243+func commonClaimReward (userAddress) = {
244+    let cfgArray = readConfigArrayOrFail()
245+    let userIdx = getUserIndexByAddress(cfgArray[IdxCfgBoostingContract], userAddress)
246+    let currentPeriod = getNumberByKey(keyNextUnlaimedPeriodOfUser(userIdx))
247+    let latestPeriod = getNumberByKey(keyNextProcessedPeriod())
248+    if ((currentPeriod >= latestPeriod))
249+        then throw("Nothing to claim")
250+        else {
251+            let boostingContract = fromBase58String(cfgArray[IdxCfgBoostingContract])
252+            let $t01173211824 = claimInternal(boostingContract, currentPeriod, userIdx, USERDEPTH, 0)
253+            let period = $t01173211824._1
254+            let amount = $t01173211824._2
255+            $Tuple5(period, amount, userIdx, cfgArray, latestPeriod)
256+            }
257+    }
258+
259+
260+@Callable(i)
261+func processNextBatch (boostingContract,currentPeriod,currentUser,depth,totalWeight) = if ((i.caller != this))
262+    then throw("Should be called by this script only")
263+    else {
264+        let tpl = processNextBatchInternal(boostingContract, currentPeriod, currentUser, depth, totalWeight)
265+        $Tuple2(tpl._1, $Tuple3(tpl._2, tpl._3, tpl._4))
266+        }
267+
268+
269+
270+@Callable(i)
271+func processPendingPeriodsAndUsers () = {
272+    let currentPeriod = getNumberByKey(keyNextProcessedPeriod())
273+    if ((currentPeriod > getNumberByKey(keyLatestPeriod())))
274+        then throw("Nothing to process")
275+        else {
276+            let cfgArray = readConfigArrayOrFail()
277+            let depth = parseIntValue(cfgArray[IdxCfgMaxDepth])
278+            if ((depth > MAXDEPTH))
279+                then throw("Depth exceeds MAXDEPTH")
280+                else {
281+                    let boostingContract = fromBase58String(cfgArray[IdxCfgBoostingContract])
282+                    let currentUser = getNumberByKey(keyNextProcessedUser())
283+                    let totalWeight = getNumberByKey(keyTotalWeightForPeriod(currentPeriod))
284+                    let r = processNextBatchInternal(boostingContract, currentPeriod, currentUser, depth, totalWeight)
285+                    ((r._1 :+ IntegerEntry(keyNextProcessedPeriod(), r._2)) :+ IntegerEntry(keyNextProcessedUser(), r._3))
286+                    }
287+            }
288+    }
289+
290+
291+
292+@Callable(i)
293+func deposit () = {
294+    let cfgArray = readConfigArrayOrFail()
295+    if ((i.caller != Address(fromBase58String(cfgArray[IdxCfgPacemakerAddress]))))
296+        then throw("Wrong caller address")
297+        else {
298+            let assetId = value(value(i.payments[0]).assetId)
299+            if ((assetId != fromBase58String(cfgArray[IdxCfgAssetId])))
300+                then throw("Wrong payment asset")
301+                else {
302+                    let period = nextPeriod()
303+[IntegerEntry(keyLatestPeriod(), period), IntegerEntry(keyHeightForPeriod(period), height), IntegerEntry(keyTotalAmountForPeriod(period), value(i.payments[0]).amount), IntegerEntry(keyNextPeriod(), (period + 1))]
304+                    }
305+            }
306+    }
307+
308+
309+
310+@Callable(i)
311+func claimNextBatch (boostingContract,currentPeriod,currentUser,depth,totalWeight) = if ((i.caller != this))
312+    then throw("Should be called by this script only")
313+    else {
314+        let periodAndTotal = claimInternal(boostingContract, currentPeriod, currentUser, depth, totalWeight)
315+        $Tuple2(nil, periodAndTotal)
316+        }
317+
318+
319+
320+@Callable(i)
321+func claimReward () = {
322+    let address = toString(i.caller)
323+    let $t01476414846 = commonClaimReward(address)
324+    let period = $t01476414846._1
325+    let amount = $t01476414846._2
326+    let userIdx = $t01476414846._3
327+    let cfgArray = $t01476414846._4
328+    let latestPeriod = $t01476414846._5
329+    $Tuple2([IntegerEntry(keyNextUnlaimedPeriodOfUser(userIdx), period), ScriptTransfer(i.caller, amount, fromBase58String(cfgArray[IdxCfgAssetId])), HistoryEntry("claim", address, amount, period, latestPeriod, i)], amount)
330+    }
331+
332+
333+
334+@Callable(i)
335+func claimRewardREADONLY (address) = {
336+    let claimResults = commonClaimReward(address)
337+    let amount = claimResults._2
338+    $Tuple2(nil, amount)
339+    }
340+
341+
342+
343+@Callable(i)
344+func calcGwxParamsREADONLY (wxAmount,lockStartHeight,lockDurationBlocks) = {
345+    let lockEndHeight = (lockStartHeight + lockDurationBlocks)
346+    let scale8ParamK = -(fraction(wxAmount, SCALE, lockDurationBlocks))
347+    let scale8ParamB = (fraction(wxAmount, SCALE, lockDurationBlocks) * lockEndHeight)
348+    $Tuple2(nil, [scale8ParamK, scale8ParamB, nextPeriod()])
349+    }
350+
351+
352+
353+@Callable(i)
354+func constructor (wxAssetIdStr,matcherPacemakerAddressStr,boostingContractAddressStr,maxDepth) = if ((this != i.caller))
355+    then throw("not authorized")
356+    else [StringEntry(keyConfig(), formatConfig(wxAssetIdStr, matcherPacemakerAddressStr, boostingContractAddressStr, maxDepth))]
357+
358+
github/deemru/w8io/169f3d6 
55.95 ms ◑