tx · D9hSjsYxjrYbE63CLrsb5BK6bRW4tbiZvxLaMuY1NhAU

3N8WDKbqGox5Eky326PHHT7rUyrby5MXdmb:  -0.03200000 Waves

2022.07.07 13:00 [2129125] smart account 3N8WDKbqGox5Eky326PHHT7rUyrby5MXdmb > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "D9hSjsYxjrYbE63CLrsb5BK6bRW4tbiZvxLaMuY1NhAU",
    "fee": 3200000,
    "feeAssetId": null,
    "timestamp": 1657188015115,
    "version": 2,
    "chainId": 84,
    "sender": "3N8WDKbqGox5Eky326PHHT7rUyrby5MXdmb",
    "senderPublicKey": "FWSsBbeCwLVkekWhvNKtX6JkrZiruRybKKVuiS3F4bqN",
    "proofs": [
        "3gtRhKSXwWPoK9GC2cECeDeaF1eF7exDzwo2twgB4nw7YquqX1DMxceTAQbawiJe6PryUWfZNCEmLhSUwYYYT6rW"
    ],
    "script": "base64:AAIFAAAAAAAAAEoIAhIGCgQIAQgIEgYKBAgIAQgSBQoDCAgBEgUKAwgBCBIECgIIARIECgIICBIECgIICBIFCgMICAESBAoCCAESAwoBCBIECgIICAAAACkAAAAACnNoaW55d2dnaWQBAAAAIIlpzwL/trq51HGW13m4mXYmsHTQd3n0c26G8PRznwYmAAAAAA90cmVhc3VyeUFkZHJlc3MBAAAAGgFUZfjwFgsEwFlCcBqeSIyX/37cHGLy3bv9AAAAAA1hc3NldHNBZGRyZXNzAQAAABoBVMvmtMF31x0nLWsWEEvKkUjrKYsKGpWnmgAAAAASbWFya2V0cGxhY2VBZGRyZXNzAQAAABoBVB0huZPx/BjDpxtJcRZDllF066xULiW87wAAAAAUY29uZmlndXJhdGlvbkFkZHJlc3MBAAAAGgFU2yDLl5FWP0IObKdlNYKLYb+1dHI4tNAuAAAAAA5uYXRpb25zQWRkcmVzcwEAAAAaAVRNheje9PhEa1kQO3Bfw7e5ZQ5R9URGbaAAAAAAC2FkbWluV2FsbGV0CQEAAAARQGV4dHJOYXRpdmUoMTA2MikAAAABAgAAACMzTXBOdGlQU1JTcTZObmFRWWszOEJmV1N6WmNnQVlUeXJROQAAAAAWZGFpbHlHYW1lUmV3YXJkc1dhbGxldAkBAAAAEUBleHRyTmF0aXZlKDEwNjIpAAAAAQIAAAAjM011U3JYVFRpd285YmRvRDZGZWFCcE1VWU1pVTVzYUR2MlUAAAAAGWRhaWx5U3Rha2luZ1Jld2FyZHNXYWxsZXQJAQAAABFAZXh0ck5hdGl2ZSgxMDYyKQAAAAECAAAAIzNNdjNtcjN1TlhkcGdrVlBBcGJHRUpqTVFYcWF1MzdEWTVpAQAAAApjaGVja0FkbWluAAAAAQAAAAZjYWxsZXIDAwMDAwkAAAAAAAACBQAAAAZjYWxsZXIFAAAAC2FkbWluV2FsbGV0BgkAAAAAAAACBQAAAAZjYWxsZXIFAAAABHRoaXMGCQAAAAAAAAIIBQAAAAZjYWxsZXIAAAAFYnl0ZXMFAAAADWFzc2V0c0FkZHJlc3MGCQAAAAAAAAIIBQAAAAZjYWxsZXIAAAAFYnl0ZXMFAAAAD3RyZWFzdXJ5QWRkcmVzcwYJAAAAAAAAAggFAAAABmNhbGxlcgAAAAVieXRlcwUAAAASbWFya2V0cGxhY2VBZGRyZXNzBgkAAAAAAAACCAUAAAAGY2FsbGVyAAAABWJ5dGVzBQAAAA5uYXRpb25zQWRkcmVzcwEAAAANdHJ5R2V0SW50ZWdlcgAAAAEAAAADa2V5BAAAAAckbWF0Y2gwCQAEGgAAAAIFAAAABHRoaXMFAAAAA2tleQMJAAABAAAAAgUAAAAHJG1hdGNoMAIAAAADSW50BAAAAAFiBQAAAAckbWF0Y2gwBQAAAAFiAAAAAAAAAAAAAQAAAA10cnlHZXRCb29sZWFuAAAAAQAAAANrZXkEAAAAByRtYXRjaDAJAAQbAAAAAgUAAAAEdGhpcwUAAAADa2V5AwkAAAEAAAACBQAAAAckbWF0Y2gwAgAAAAdCb29sZWFuBAAAAAFiBQAAAAckbWF0Y2gwBQAAAAFiBwEAAAAMdHJ5R2V0U3RyaW5nAAAAAQAAAANrZXkEAAAAByRtYXRjaDAJAAQdAAAAAgUAAAAEdGhpcwUAAAADa2V5AwkAAAEAAAACBQAAAAckbWF0Y2gwAgAAAAZTdHJpbmcEAAAAAWIFAAAAByRtYXRjaDAFAAAAAWICAAAAAAEAAAAIZ2V0QUxLZXkAAAACAAAABE5hbWUAAAAFTGV2ZWwJAAEsAAAAAgkAASwAAAACBQAAAAROYW1lAgAAAARfbHZsCQABpAAAAAEFAAAABUxldmVsAQAAABFjb25mVHJ5R2V0SW50ZWdlcgAAAAEAAAADa2V5BAAAAAckbWF0Y2gwCQAEGgAAAAIJAQAAAAdBZGRyZXNzAAAAAQUAAAAUY29uZmlndXJhdGlvbkFkZHJlc3MFAAAAA2tleQMJAAABAAAAAgUAAAAHJG1hdGNoMAIAAAADSW50BAAAAAFiBQAAAAckbWF0Y2gwBQAAAAFiAAAAAAAAAAAAAQAAABBjb25mVHJ5R2V0U3RyaW5nAAAAAQAAAANrZXkEAAAAByRtYXRjaDAJAAQdAAAAAgkBAAAAB0FkZHJlc3MAAAABBQAAABRjb25maWd1cmF0aW9uQWRkcmVzcwUAAAADa2V5AwkAAAEAAAACBQAAAAckbWF0Y2gwAgAAAAZTdHJpbmcEAAAAAWIFAAAAByRtYXRjaDAFAAAAAWICAAAAAAEAAAARY29uZlRyeUdldEJvb2xlYW4AAAABAAAAA2tleQQAAAAHJG1hdGNoMAkABBsAAAACCQEAAAAHQWRkcmVzcwAAAAEFAAAAFGNvbmZpZ3VyYXRpb25BZGRyZXNzBQAAAANrZXkDCQAAAQAAAAIFAAAAByRtYXRjaDACAAAAB0Jvb2xlYW4EAAAAAWIFAAAAByRtYXRjaDAFAAAAAWIHAQAAAA5nZXRUcmVhc3VyeUtleQAAAAEAAAAIbmF0aW9uaWQJAAEsAAAAAgUAAAAIbmF0aW9uaWQCAAAACV9UcmVhc3VyeQEAAAAVdHJlYXN1cnlUcnlHZXRJbnRlZ2VyAAAAAQAAAANrZXkEAAAAByRtYXRjaDAJAAQaAAAAAgkBAAAAB0FkZHJlc3MAAAABBQAAAA90cmVhc3VyeUFkZHJlc3MFAAAAA2tleQMJAAABAAAAAgUAAAAHJG1hdGNoMAIAAAADSW50BAAAAAFiBQAAAAckbWF0Y2gwBQAAAAFiAAAAAAAAAAAAAQAAABRuYXRpb25zVHJ5R2V0SW50ZWdlcgAAAAEAAAADa2V5BAAAAAckbWF0Y2gwCQAEGgAAAAIJAQAAAAdBZGRyZXNzAAAAAQUAAAAObmF0aW9uc0FkZHJlc3MFAAAAA2tleQMJAAABAAAAAgUAAAAHJG1hdGNoMAIAAAADSW50BAAAAAFiBQAAAAckbWF0Y2gwBQAAAAFiAAAAAAAAAAAAAQAAABRuYXRpb25zVHJ5R2V0Qm9vbGVhbgAAAAEAAAADa2V5BAAAAAckbWF0Y2gwCQAEGwAAAAIJAQAAAAdBZGRyZXNzAAAAAQUAAAAObmF0aW9uc0FkZHJlc3MFAAAAA2tleQMJAAABAAAAAgUAAAAHJG1hdGNoMAIAAAAHQm9vbGVhbgQAAAABYgUAAAAHJG1hdGNoMAUAAAABYgcBAAAAE25hdGlvbnNUcnlHZXRTdHJpbmcAAAABAAAAA2tleQQAAAAHJG1hdGNoMAkABB0AAAACCQEAAAAHQWRkcmVzcwAAAAEFAAAADm5hdGlvbnNBZGRyZXNzBQAAAANrZXkDCQAAAQAAAAIFAAAAByRtYXRjaDACAAAABlN0cmluZwQAAAABYgUAAAAHJG1hdGNoMAUAAAABYgIAAAAAAQAAABZnZXRBc3NldE93bmVyS2V5U3RyaW5nAAAAAQAAAAdhc3NldElkCQABLAAAAAIFAAAAB2Fzc2V0SWQCAAAABl9Pd25lcgAAAAAMQnVpbGRTdGFydGVkAgAAAA1CVUlMRF9TVEFSVEVEAAAAAA1CdWlsZEZpbmlzaGVkAgAAAA5CVUlMRF9GSU5JU0hFRAEAAAANZ2V0QXNzZXRJZEtleQAAAAIAAAAEdHhJZAAAAAlhc3NldFR5cGUJAAEsAAAAAgkAASwAAAACBQAAAAlhc3NldFR5cGUCAAAAAV8JAAJYAAAAAQUAAAAEdHhJZAEAAAAQZ2V0QXNzZXRPd25lcktleQAAAAIAAAAEdHhJZAAAAAlhc3NldFR5cGUJAAEsAAAAAgkBAAAADWdldEFzc2V0SWRLZXkAAAACBQAAAAR0eElkBQAAAAlhc3NldFR5cGUCAAAABl9Pd25lcgEAAAAaZ2V0QnVpbGRpbmdGaW5pc2hIZWlnaHRLZXkAAAADAAAAB2FkZHJlc3MAAAAEdHhJZAAAAAlhc3NldFR5cGUJAAEsAAAAAgkAASwAAAACCQABLAAAAAIFAAAAB2FkZHJlc3MCAAAAAV8JAQAAAA1nZXRBc3NldElkS2V5AAAAAgUAAAAEdHhJZAUAAAAJYXNzZXRUeXBlAgAAAANfZmgBAAAAFGdldEJ1aWxkaW5nU3RhdHVzS2V5AAAAAwAAAAdhZGRyZXNzAAAABHR4SWQAAAAJYXNzZXRUeXBlCQABLAAAAAIJAAEsAAAAAgkAASwAAAACBQAAAAdhZGRyZXNzAgAAAAFfCQEAAAANZ2V0QXNzZXRJZEtleQAAAAIFAAAABHR4SWQFAAAACWFzc2V0VHlwZQIAAAAHX3N0YXR1cwEAAAARZ2V0QXNzZXRUeXBlTGV2ZWwAAAABAAAACGFzc2V0U3RyBAAAAAZjaHVua3MJAAS1AAAAAgUAAAAIYXNzZXRTdHICAAAAAV8EAAAADHN0ckFzc2V0VHlwZQkAAZEAAAACBQAAAAZjaHVua3MAAAAAAAAAAAAEAAAABWxldmVsCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAEwAAAAAgkAAZEAAAACBQAAAAZjaHVua3MAAAAAAAAAAAEAAAAAAAAAAAMJAAUUAAAAAgUAAAAMc3RyQXNzZXRUeXBlBQAAAAVsZXZlbAEAAAAPaW50ZXJuYWxEaXN0cmliAAAAAgAAAAphZGRyZXNzU3RyAAAABmFtb3VudAQAAAACdHIJAAP8AAAABAkBAAAAB0FkZHJlc3MAAAABBQAAAA90cmVhc3VyeUFkZHJlc3MCAAAACWFkZFJld2FyZAkABEwAAAACCQEAAAARQGV4dHJOYXRpdmUoMTA2MikAAAABBQAAAAphZGRyZXNzU3RyCQAETAAAAAIFAAAABmFtb3VudAUAAAADbmlsBQAAAANuaWwDCQAAAAAAAAIFAAAAAnRyBQAAAAJ0cgQAAAAHJG1hdGNoMAUAAAACdHIDCQAAAQAAAAIFAAAAByRtYXRjaDACAAAAA0ludAQAAAABdAUAAAAHJG1hdGNoMAUAAAAGYW1vdW50AAAAAAAAAAAACQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgEAAAAVZGlzdHJpYkRlc3Ryb3lSZXdhcmRzAAAAAgAAAAVhY2N1bQAAAAluZXh0VmFsdWUEAAAAA3ZhbAkABLUAAAACBQAAAAluZXh0VmFsdWUCAAAAAV8EAAAABGFkZHIJAAGRAAAAAgUAAAADdmFsAAAAAAAAAAAABAAAAARhbW50CQABkQAAAAIFAAAAA3ZhbAAAAAAAAAAAAQkABE0AAAACBQAAAAVhY2N1bQkBAAAAD2ludGVybmFsRGlzdHJpYgAAAAIFAAAABGFkZHIJAQAAAA1wYXJzZUludFZhbHVlAAAAAQUAAAAEYW1udAEAAAAcaW50ZXJuYWxTYWNyaWZpY2VGaW5pc2hCdWlsZAAAAAcAAAAGY2FsbGVyAAAACGFzc2V0U3RyAAAACGFzc2V0S2V5AAAAEUJ1aWxkaW5nU3RhdHVzS2V5AAAAD2ZpbmlzaEhlaWdodEtleQAAAA10cmFuc2FjdGlvbklkAAAADHNhY3JpZmljZWtleQQAAAAGY2h1bmtzCQEAAAARZ2V0QXNzZXRUeXBlTGV2ZWwAAAABBQAAAAhhc3NldFN0cgQAAAAMc3RyQXNzZXRUeXBlCAUAAAAGY2h1bmtzAAAAAl8xBAAAAAVsZXZlbAgFAAAABmNodW5rcwAAAAJfMgQAAAAUYnVpbGRpbmdGaW5pc2hIZWlnaHQJAQAAABFAZXh0ck5hdGl2ZSgxMDUwKQAAAAIFAAAABHRoaXMFAAAAD2ZpbmlzaEhlaWdodEtleQMJAABmAAAAAgUAAAAUYnVpbGRpbmdGaW5pc2hIZWlnaHQFAAAABmhlaWdodAkAAAIAAAABCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAICAAAAHUJ1aWxkaW5nIGlzIG5vdCBmaW5pc2hlZCB5ZXQgCQABpAAAAAEJAABlAAAAAgUAAAAUYnVpbGRpbmdGaW5pc2hIZWlnaHQFAAAABmhlaWdodAIAAAAnIGJsb2NrcyByZW1haW5pbmcsIGl0IHdpbGwgdGFrZSBhcm91bmQgCQABpAAAAAEJAABlAAAAAgUAAAAUYnVpbGRpbmdGaW5pc2hIZWlnaHQFAAAABmhlaWdodAIAAAAIIG1pbnV0ZXMDCQAAAAAAAAIJAAEvAAAAAgUAAAAMc3RyQXNzZXRUeXBlAAAAAAAAAAAEAgAAAARURUNIBAAAAApkaXNjb3ZlcmVkCQAD/AAAAAQJAQAAAAdBZGRyZXNzAAAAAQUAAAAObmF0aW9uc0FkZHJlc3MCAAAAGHNldFRlY25obm9sb2d5RGlzY292ZXJlZAkABEwAAAACBQAAAAZjYWxsZXIJAARMAAAAAgUAAAAIYXNzZXRTdHIFAAAAA25pbAUAAAADbmlsAwkAAAAAAAACBQAAAApkaXNjb3ZlcmVkBgkABEwAAAACCQEAAAALRGVsZXRlRW50cnkAAAABBQAAABFCdWlsZGluZ1N0YXR1c0tleQkABEwAAAACCQEAAAALRGVsZXRlRW50cnkAAAABBQAAAA9maW5pc2hIZWlnaHRLZXkJAARMAAAAAgkBAAAAC0RlbGV0ZUVudHJ5AAAAAQkBAAAAEGdldEFzc2V0T3duZXJLZXkAAAACBQAAAA10cmFuc2FjdGlvbklkBQAAAAhhc3NldFN0cgUAAAADbmlsCQAAAgAAAAECAAAAHGVycm9yIGRpc2NvdmVyaW5nIHRlY2hub2xvZ3kEAAAACmFzc2V0UG93ZXIJAQAAABFjb25mVHJ5R2V0SW50ZWdlcgAAAAEJAAEsAAAAAgUAAAAIYXNzZXRTdHICAAAABl9Qb3dlcgQAAAAKYXNzZXRDb2lucwkAAGkAAAACCQAAaAAAAAIJAQAAABFjb25mVHJ5R2V0SW50ZWdlcgAAAAEJAAEsAAAAAgUAAAAMc2FjcmlmaWNla2V5AgAAAAVfQ29zdAAAAAAAAAAAFAAAAAAAAAAAZAMJAABmAAAAAgUAAAAKYXNzZXRQb3dlcgAAAAAAAAAAAAQAAAAMY3VycmVudFBvd2VyCQEAAAAUbmF0aW9uc1RyeUdldEludGVnZXIAAAABCQABLAAAAAIFAAAABmNhbGxlcgIAAAAGX1Bvd2VyBAAAAAJwdwkAA/wAAAAECQEAAAAHQWRkcmVzcwAAAAEFAAAADm5hdGlvbnNBZGRyZXNzAgAAAAxzZXRVc2VyUG93ZXIJAARMAAAAAgUAAAAGY2FsbGVyCQAETAAAAAIJAABkAAAAAgUAAAAMY3VycmVudFBvd2VyBQAAAAphc3NldFBvd2VyBQAAAANuaWwFAAAAA25pbAMJAAAAAAAAAgUAAAACcHcFAAAAAnB3CQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACBQAAAAhhc3NldEtleQUAAAAKYXNzZXRDb2lucwkABEwAAAACCQEAAAALRGVsZXRlRW50cnkAAAABBQAAABFCdWlsZGluZ1N0YXR1c0tleQkABEwAAAACCQEAAAALRGVsZXRlRW50cnkAAAABBQAAAA9maW5pc2hIZWlnaHRLZXkFAAAAA25pbAkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIFAAAACGFzc2V0S2V5BQAAAAphc3NldENvaW5zCQAETAAAAAIJAQAAAAtEZWxldGVFbnRyeQAAAAEFAAAAEUJ1aWxkaW5nU3RhdHVzS2V5CQAETAAAAAIJAQAAAAtEZWxldGVFbnRyeQAAAAEFAAAAD2ZpbmlzaEhlaWdodEtleQUAAAADbmlsAQAAABNpbnRlcm5hbEZpbmlzaEJ1aWxkAAAABgAAAAZjYWxsZXIAAAAIYXNzZXRTdHIAAAAIYXNzZXRLZXkAAAARQnVpbGRpbmdTdGF0dXNLZXkAAAAPZmluaXNoSGVpZ2h0S2V5AAAADXRyYW5zYWN0aW9uSWQEAAAABmNodW5rcwkBAAAAEWdldEFzc2V0VHlwZUxldmVsAAAAAQUAAAAIYXNzZXRTdHIEAAAADHN0ckFzc2V0VHlwZQgFAAAABmNodW5rcwAAAAJfMQQAAAAFbGV2ZWwIBQAAAAZjaHVua3MAAAACXzIEAAAAFGJ1aWxkaW5nRmluaXNoSGVpZ2h0CQEAAAARQGV4dHJOYXRpdmUoMTA1MCkAAAACBQAAAAR0aGlzBQAAAA9maW5pc2hIZWlnaHRLZXkDCQAAZgAAAAIFAAAAFGJ1aWxkaW5nRmluaXNoSGVpZ2h0BQAAAAZoZWlnaHQJAAACAAAAAQkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACAgAAAB1CdWlsZGluZyBpcyBub3QgZmluaXNoZWQgeWV0IAkAAaQAAAABCQAAZQAAAAIFAAAAFGJ1aWxkaW5nRmluaXNoSGVpZ2h0BQAAAAZoZWlnaHQCAAAAJyBibG9ja3MgcmVtYWluaW5nLCBpdCB3aWxsIHRha2UgYXJvdW5kIAkAAaQAAAABCQAAZQAAAAIFAAAAFGJ1aWxkaW5nRmluaXNoSGVpZ2h0BQAAAAZoZWlnaHQCAAAACCBtaW51dGVzAwkAAAAAAAACCQABLwAAAAIFAAAADHN0ckFzc2V0VHlwZQAAAAAAAAAABAIAAAAEVEVDSAQAAAAKZGlzY292ZXJlZAkAA/wAAAAECQEAAAAHQWRkcmVzcwAAAAEFAAAADm5hdGlvbnNBZGRyZXNzAgAAABhzZXRUZWNuaG5vbG9neURpc2NvdmVyZWQJAARMAAAAAgUAAAAGY2FsbGVyCQAETAAAAAIFAAAACGFzc2V0U3RyBQAAAANuaWwFAAAAA25pbAMJAAAAAAAAAgUAAAAKZGlzY292ZXJlZAYJAARMAAAAAgkBAAAAC0RlbGV0ZUVudHJ5AAAAAQUAAAARQnVpbGRpbmdTdGF0dXNLZXkJAARMAAAAAgkBAAAAC0RlbGV0ZUVudHJ5AAAAAQUAAAAPZmluaXNoSGVpZ2h0S2V5CQAETAAAAAIJAQAAAAtEZWxldGVFbnRyeQAAAAEJAQAAABBnZXRBc3NldE93bmVyS2V5AAAAAgUAAAANdHJhbnNhY3Rpb25JZAUAAAAIYXNzZXRTdHIFAAAAA25pbAkAAAIAAAABAgAAABxlcnJvciBkaXNjb3ZlcmluZyB0ZWNobm9sb2d5BAAAAAphc3NldFBvd2VyCQEAAAARY29uZlRyeUdldEludGVnZXIAAAABCQABLAAAAAIFAAAACGFzc2V0U3RyAgAAAAZfUG93ZXIEAAAACmFzc2V0Q29pbnMJAABpAAAAAgkAAGgAAAACCQEAAAARY29uZlRyeUdldEludGVnZXIAAAABCQABLAAAAAIFAAAACGFzc2V0U3RyAgAAAAVfQ29zdAAAAAAAAAAAFAAAAAAAAAAAZAQAAAAHcmVmQ2FsbAkAA/wAAAAECQEAAAAHQWRkcmVzcwAAAAEFAAAAD3RyZWFzdXJ5QWRkcmVzcwIAAAADUGF5CQAETAAAAAIFAAAABmNhbGxlcgkABEwAAAACBQAAAAphc3NldENvaW5zBQAAAANuaWwFAAAAA25pbAMJAAAAAAAAAgUAAAAHcmVmQ2FsbAUAAAAHcmVmQ2FsbAMJAABmAAAAAgUAAAAKYXNzZXRQb3dlcgAAAAAAAAAAAAQAAAAMY3VycmVudFBvd2VyCQEAAAAUbmF0aW9uc1RyeUdldEludGVnZXIAAAABCQABLAAAAAIFAAAABmNhbGxlcgIAAAAGX1Bvd2VyBAAAAAJwdwkAA/wAAAAECQEAAAAHQWRkcmVzcwAAAAEFAAAADm5hdGlvbnNBZGRyZXNzAgAAAAxzZXRVc2VyUG93ZXIJAARMAAAAAgUAAAAGY2FsbGVyCQAETAAAAAIJAABkAAAAAgUAAAAMY3VycmVudFBvd2VyBQAAAAphc3NldFBvd2VyBQAAAANuaWwFAAAAA25pbAMJAAAAAAAAAgUAAAACcHcFAAAAAnB3AwkBAAAAEWNvbmZUcnlHZXRCb29sZWFuAAAAAQkAASwAAAACBQAAAAhhc3NldFN0cgIAAAALX0FnZ3JlZ2F0ZWQEAAAADGFnZ3JBc3NldGtleQkAASwAAAACCQABLAAAAAIFAAAACGFzc2V0U3RyAgAAAAFfBQAAAAZjYWxsZXIEAAAABWNvaW5zCQEAAAANdHJ5R2V0SW50ZWdlcgAAAAEFAAAADGFnZ3JBc3NldGtleQQAAAADcXR5CQEAAAANdHJ5R2V0SW50ZWdlcgAAAAEJAAEsAAAAAgUAAAAMYWdnckFzc2V0a2V5AgAAAARfUXR5CQAETAAAAAIJAQAAAAtEZWxldGVFbnRyeQAAAAEJAQAAABBnZXRBc3NldE93bmVyS2V5AAAAAgUAAAANdHJhbnNhY3Rpb25JZAUAAAAIYXNzZXRTdHIJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkAASwAAAACBQAAAAxhZ2dyQXNzZXRrZXkCAAAABl9Pd25lcgUAAAAGY2FsbGVyCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACBQAAAAxhZ2dyQXNzZXRrZXkJAABkAAAAAgUAAAAFY29pbnMFAAAACmFzc2V0Q29pbnMJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIJAAEsAAAAAgUAAAAMYWdnckFzc2V0a2V5AgAAAARfUXR5CQAAZAAAAAIFAAAAA3F0eQAAAAAAAAAAAQkABEwAAAACCQEAAAALRGVsZXRlRW50cnkAAAABBQAAABFCdWlsZGluZ1N0YXR1c0tleQkABEwAAAACCQEAAAALRGVsZXRlRW50cnkAAAABBQAAAA9maW5pc2hIZWlnaHRLZXkFAAAAA25pbAkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgUAAAAIYXNzZXRLZXkFAAAACmFzc2V0Q29pbnMJAARMAAAAAgkBAAAAC0RlbGV0ZUVudHJ5AAAAAQUAAAARQnVpbGRpbmdTdGF0dXNLZXkJAARMAAAAAgkBAAAAC0RlbGV0ZUVudHJ5AAAAAQUAAAAPZmluaXNoSGVpZ2h0S2V5BQAAAANuaWwJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAwkBAAAAEWNvbmZUcnlHZXRCb29sZWFuAAAAAQkAASwAAAACBQAAAAhhc3NldFN0cgIAAAALX0FnZ3JlZ2F0ZWQEAAAADGFnZ3JBc3NldGtleQkAASwAAAACCQABLAAAAAIFAAAACGFzc2V0U3RyAgAAAAFfBQAAAAZjYWxsZXIEAAAABWNvaW5zCQEAAAANdHJ5R2V0SW50ZWdlcgAAAAEFAAAADGFnZ3JBc3NldGtleQQAAAADcXR5CQEAAAANdHJ5R2V0SW50ZWdlcgAAAAEJAAEsAAAAAgUAAAAMYWdnckFzc2V0a2V5AgAAAARfUXR5CQAETAAAAAIJAQAAAAtEZWxldGVFbnRyeQAAAAEJAQAAABBnZXRBc3NldE93bmVyS2V5AAAAAgUAAAANdHJhbnNhY3Rpb25JZAUAAAAIYXNzZXRTdHIJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkAASwAAAACBQAAAAxhZ2dyQXNzZXRrZXkCAAAABl9Pd25lcgUAAAAGY2FsbGVyCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACBQAAAAxhZ2dyQXNzZXRrZXkJAABkAAAAAgUAAAAFY29pbnMFAAAACmFzc2V0Q29pbnMJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIJAAEsAAAAAgUAAAAMYWdnckFzc2V0a2V5AgAAAARfUXR5CQAAZAAAAAIFAAAAA3F0eQAAAAAAAAAAAQkABEwAAAACCQEAAAALRGVsZXRlRW50cnkAAAABBQAAABFCdWlsZGluZ1N0YXR1c0tleQkABEwAAAACCQEAAAALRGVsZXRlRW50cnkAAAABBQAAAA9maW5pc2hIZWlnaHRLZXkFAAAAA25pbAkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgUAAAAIYXNzZXRLZXkFAAAACmFzc2V0Q29pbnMJAARMAAAAAgkBAAAAC0RlbGV0ZUVudHJ5AAAAAQUAAAARQnVpbGRpbmdTdGF0dXNLZXkJAARMAAAAAgkBAAAAC0RlbGV0ZUVudHJ5AAAAAQUAAAAPZmluaXNoSGVpZ2h0S2V5BQAAAANuaWwJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAQAAAA9jaGVja0Fzc2V0T3duZXIAAAACAAAABmNhbGxlcgAAAAhhc3NldEtleQQAAAAKYXNzZXRPd25lcgkBAAAADHRyeUdldFN0cmluZwAAAAEJAQAAABZnZXRBc3NldE93bmVyS2V5U3RyaW5nAAAAAQUAAAAIYXNzZXRLZXkJAAAAAAAAAgUAAAAKYXNzZXRPd25lcgUAAAAGY2FsbGVyAQAAABVpc05hdGlvblJlc2VydmVkQXNzZXQAAAACAAAABE5hbWUAAAAFTGV2ZWwEAAAAAWsJAQAAAAhnZXRBTEtleQAAAAIFAAAABE5hbWUFAAAABUxldmVsCQEAAAARY29uZlRyeUdldEJvb2xlYW4AAAABCQABLAAAAAIFAAAAAWsCAAAAD19OYXRpb25SZXNlcnZlZAEAAAAZaW50ZXJuYWxUcmFzbmZlck93bmVyc2hpcAAAAAMAAAAHYXNzZXRJZAAAAAhuZXdPd25lcgAAAANxdHkEAAAABmNodW5rcwkBAAAAEWdldEFzc2V0VHlwZUxldmVsAAAAAQUAAAAHYXNzZXRJZAQAAAAMc3RyQXNzZXRUeXBlCAUAAAAGY2h1bmtzAAAAAl8xBAAAAAVsZXZlbAgFAAAABmNodW5rcwAAAAJfMgQAAAABawkBAAAACGdldEFMS2V5AAAAAgUAAAAMc3RyQXNzZXRUeXBlBQAAAAVsZXZlbAQAAAAIb2xkT3duZXIJAQAAAAx0cnlHZXRTdHJpbmcAAAABCQEAAAAWZ2V0QXNzZXRPd25lcktleVN0cmluZwAAAAEFAAAAB2Fzc2V0SWQDCQEAAAARY29uZlRyeUdldEJvb2xlYW4AAAABCQABLAAAAAIFAAAAAWsCAAAAC19BZ2dyZWdhdGVkBAAAAAphc3NldFBvd2VyCQEAAAARY29uZlRyeUdldEludGVnZXIAAAABCQABLAAAAAIFAAAAAWsCAAAABl9Qb3dlcgQAAAAIcXR5UG93ZXIJAABoAAAAAgUAAAAKYXNzZXRQb3dlcgUAAAADcXR5BAAAAAxhZ2dyQXNzZXRrZXkJAAEsAAAAAgkAASwAAAACBQAAAAFrAgAAAAFfBQAAAAhvbGRPd25lcgQAAAAIb2xkUG93ZXIJAQAAABRuYXRpb25zVHJ5R2V0SW50ZWdlcgAAAAEJAAEsAAAAAgUAAAAIb2xkT3duZXICAAAABl9Qb3dlcgQAAAAIb2xkQ29pbnMJAQAAAA10cnlHZXRJbnRlZ2VyAAAAAQUAAAAMYWdnckFzc2V0a2V5BAAAAApzaW5nbGVDb2luCQAAawAAAAMFAAAACG9sZENvaW5zAAAAAAAAAAABBQAAAANxdHkEAAAACm9sZEl0ZW1xdHkJAQAAAA10cnlHZXRJbnRlZ2VyAAAAAQkAASwAAAACBQAAAAxhZ2dyQXNzZXRrZXkCAAAABF9RdHkEAAAAD25ld0FnZ3JBc3NldEtleQkAASwAAAACCQABLAAAAAIFAAAAAWsCAAAAAV8FAAAACG5ld093bmVyBAAAAAhuZXdDb2lucwkBAAAADXRyeUdldEludGVnZXIAAAABBQAAAA9uZXdBZ2dyQXNzZXRLZXkEAAAACm5ld0l0ZW1xdHkJAQAAAA10cnlHZXRJbnRlZ2VyAAAAAQkAASwAAAACBQAAAA9uZXdBZ2dyQXNzZXRLZXkCAAAABF9RdHkEAAAACG5ld1Bvd2VyCQEAAAAUbmF0aW9uc1RyeUdldEludGVnZXIAAAABCQABLAAAAAIFAAAACG5ld093bmVyAgAAAAZfUG93ZXIEAAAABXB3T2xkCQAD/AAAAAQJAQAAAAdBZGRyZXNzAAAAAQUAAAAObmF0aW9uc0FkZHJlc3MCAAAADHNldFVzZXJQb3dlcgkABEwAAAACBQAAAAhvbGRPd25lcgkABEwAAAACCQAAZQAAAAIFAAAACG9sZFBvd2VyBQAAAAhxdHlQb3dlcgUAAAADbmlsBQAAAANuaWwDCQAAAAAAAAIFAAAABXB3T2xkBQAAAAVwd09sZAQAAAAFcHdOZXcJAAP8AAAABAkBAAAAB0FkZHJlc3MAAAABBQAAAA5uYXRpb25zQWRkcmVzcwIAAAAMc2V0VXNlclBvd2VyCQAETAAAAAIFAAAACG5ld093bmVyCQAETAAAAAIJAABkAAAAAgUAAAAIbmV3UG93ZXIFAAAACHF0eVBvd2VyBQAAAANuaWwFAAAAA25pbAMJAAAAAAAAAgUAAAAFcHdOZXcFAAAABXB3TmV3CQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACCQABLAAAAAIFAAAADGFnZ3JBc3NldGtleQIAAAAEX1F0eQkAAGUAAAACBQAAAApvbGRJdGVtcXR5BQAAAANxdHkJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIJAAEsAAAAAgUAAAAPbmV3QWdnckFzc2V0S2V5AgAAAARfUXR5CQAAZAAAAAIFAAAACm5ld0l0ZW1xdHkFAAAAA3F0eQkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgUAAAAMYWdnckFzc2V0a2V5CQAAZQAAAAIFAAAACG9sZENvaW5zCQAAaAAAAAIFAAAAA3F0eQUAAAAKc2luZ2xlQ29pbgkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgUAAAAPbmV3QWdnckFzc2V0S2V5CQAAZAAAAAIFAAAACG5ld0NvaW5zCQAAaAAAAAIFAAAAA3F0eQUAAAAKc2luZ2xlQ29pbgUAAAADbmlsCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4EAAAACmFzc2V0UG93ZXIJAQAAABFjb25mVHJ5R2V0SW50ZWdlcgAAAAEJAAEsAAAAAgUAAAABawIAAAAGX1Bvd2VyAwkAAGYAAAACBQAAAAphc3NldFBvd2VyAAAAAAAAAAAABAAAAAxjdXJyZW50UG93ZXIJAQAAABRuYXRpb25zVHJ5R2V0SW50ZWdlcgAAAAEJAAEsAAAAAgUAAAAIb2xkT3duZXICAAAABl9Qb3dlcgQAAAACcHcJAAP8AAAABAkBAAAAB0FkZHJlc3MAAAABBQAAAA5uYXRpb25zQWRkcmVzcwIAAAAMc2V0VXNlclBvd2VyCQAETAAAAAIFAAAACG9sZE93bmVyCQAETAAAAAIJAABlAAAAAgUAAAAMY3VycmVudFBvd2VyBQAAAAphc3NldFBvd2VyBQAAAANuaWwFAAAAA25pbAMJAAAAAAAAAgUAAAACcHcFAAAAAnB3AwkBAAAAAiE9AAAAAgUAAAACcHcJAABlAAAAAgUAAAAMY3VycmVudFBvd2VyBQAAAAphc3NldFBvd2VyCQAAAgAAAAECAAAAF0luY29ycmVjdCBpbnZva2UgcmVzdWx0BAAAAA9uZXdjdXJyZW50UG93ZXIJAQAAABRuYXRpb25zVHJ5R2V0SW50ZWdlcgAAAAEJAAEsAAAAAgUAAAAIbmV3T3duZXICAAAABl9Qb3dlcgQAAAADcHcyCQAD/AAAAAQJAQAAAAdBZGRyZXNzAAAAAQUAAAAObmF0aW9uc0FkZHJlc3MCAAAADHNldFVzZXJQb3dlcgkABEwAAAACBQAAAAhuZXdPd25lcgkABEwAAAACCQAAZAAAAAIFAAAAD25ld2N1cnJlbnRQb3dlcgUAAAAKYXNzZXRQb3dlcgUAAAADbmlsBQAAAANuaWwDCQAAAAAAAAIFAAAAA3B3MgUAAAADcHcyBAAAAAckbWF0Y2gwBQAAAANwdzIDCQAAAQAAAAIFAAAAByRtYXRjaDACAAAAA0ludAQAAAABcgUAAAAHJG1hdGNoMAkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAAWZ2V0QXNzZXRPd25lcktleVN0cmluZwAAAAEFAAAAB2Fzc2V0SWQFAAAACG5ld093bmVyBQAAAANuaWwJAAACAAAAAQIAAAAXSW5jb3JyZWN0IGludm9rZSByZXN1bHQJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAAWZ2V0QXNzZXRPd25lcktleVN0cmluZwAAAAEFAAAAB2Fzc2V0SWQFAAAACG5ld093bmVyBQAAAANuaWwBAAAAHENoZWNrQXNzZXRCdWlsZGFibGVTYWNyaWZpY2UAAAADAAAABUFMS2V5AAAABmNhbGxlcgAAAAxTYWNyaWZpY2VLZXkEAAAACGFzc2V0U2FjCQEAAAAQY29uZlRyeUdldFN0cmluZwAAAAEJAAEsAAAAAgUAAAAFQUxLZXkCAAAAD19TYWNyaWZpY2VBc3NldAQAAAALYXNzZXRTYWNsdmwJAQAAABFjb25mVHJ5R2V0SW50ZWdlcgAAAAEJAAEsAAAAAgUAAAAFQUxLZXkCAAAAFF9TYWNyaWZpY2VBc3NldExldmVsAwkAAAAAAAACBQAAAAhhc3NldFNhYwIAAAAABgMJAQAAAAEhAAAAAQkBAAAAD2NoZWNrQXNzZXRPd25lcgAAAAIFAAAABmNhbGxlcgUAAAAMU2FjcmlmaWNlS2V5CQAAAgAAAAECAAAALHlvdSBhcmUgbm90IHRoZSBvd25lciBvZiB0aGUgU2FjcmlmaWNlIGFzc2V0BAAAAAZjaHVua3MJAQAAABFnZXRBc3NldFR5cGVMZXZlbAAAAAEFAAAADFNhY3JpZmljZUtleQMDCQEAAAACIT0AAAACBQAAAAhhc3NldFNhYwgFAAAABmNodW5rcwAAAAJfMQYJAQAAAAIhPQAAAAIFAAAAC2Fzc2V0U2FjbHZsCAUAAAAGY2h1bmtzAAAAAl8yCQAAAgAAAAECAAAALnRoZSBzYWNyaWZpY2VBc3NldCBoYXMgdGhlIHdyb25nIHR5cGUgb3IgbGV2ZWwGAQAAABlDaGVja0Fzc2V0QnVpbGRhYmxlTmF0aW9uAAAABAAAAAROYW1lAAAABUxldmVsAAAACU5hdGlvbktleQAAAAxTYWNyaWZpY2VLZXkEAAAAB2NuZmdLZXkJAQAAAAhnZXRBTEtleQAAAAIFAAAABE5hbWUFAAAABUxldmVsBAAAAAN0ZWMJAQAAABBjb25mVHJ5R2V0U3RyaW5nAAAAAQkAASwAAAACBQAAAAdjbmZnS2V5AgAAABZfVGVjbmhvbG9neV9kaXNjb3ZlcmVkAwkBAAAAAiE9AAAAAgUAAAADdGVjAgAAAAADCQEAAAAUbmF0aW9uc1RyeUdldEJvb2xlYW4AAAABCQABLAAAAAIJAAEsAAAAAgUAAAAJTmF0aW9uS2V5AgAAAAFfBQAAAAN0ZWMJAQAAABxDaGVja0Fzc2V0QnVpbGRhYmxlU2FjcmlmaWNlAAAAAwUAAAAHY25mZ0tleQUAAAAJTmF0aW9uS2V5BQAAAAxTYWNyaWZpY2VLZXkHCQEAAAAcQ2hlY2tBc3NldEJ1aWxkYWJsZVNhY3JpZmljZQAAAAMFAAAAB2NuZmdLZXkFAAAACU5hdGlvbktleQUAAAAMU2FjcmlmaWNlS2V5AQAAABdDaGVja0Fzc2V0QnVpbGRhYmxlVXNlcgAAAAQAAAAETmFtZQAAAAVMZXZlbAAAAAZjYWxsZXIAAAAMU2FjcmlmaWNlS2V5BAAAAAZjbmZLZXkJAQAAAAhnZXRBTEtleQAAAAIFAAAABE5hbWUFAAAABUxldmVsBAAAAAhuYXRpb25JZAkBAAAAFG5hdGlvbnNUcnlHZXRJbnRlZ2VyAAAAAQUAAAAGY2FsbGVyAwkAAAAAAAACBQAAAAhuYXRpb25JZAAAAAAAAAAAAAcEAAAAA3RlYwkBAAAAEGNvbmZUcnlHZXRTdHJpbmcAAAABCQABLAAAAAIFAAAABmNuZktleQIAAAAWX1RlY25ob2xvZ3lfZGlzY292ZXJlZAMJAQAAAAIhPQAAAAIFAAAAA3RlYwIAAAAABAAAAAlOYXRpb25LZXkJAQAAABNuYXRpb25zVHJ5R2V0U3RyaW5nAAAAAQkAAaQAAAABBQAAAAhuYXRpb25JZAMJAQAAABRuYXRpb25zVHJ5R2V0Qm9vbGVhbgAAAAEJAAEsAAAAAgkAASwAAAACBQAAAAlOYXRpb25LZXkCAAAAAV8FAAAAA3RlYwkBAAAAHENoZWNrQXNzZXRCdWlsZGFibGVTYWNyaWZpY2UAAAADBQAAAAZjbmZLZXkFAAAABmNhbGxlcgUAAAAMU2FjcmlmaWNlS2V5BwkBAAAAHENoZWNrQXNzZXRCdWlsZGFibGVTYWNyaWZpY2UAAAADBQAAAAZjbmZLZXkFAAAABmNhbGxlcgUAAAAMU2FjcmlmaWNlS2V5AQAAABNDaGVja0Fzc2V0QnVpbGRhYmxlAAAABQAAAAROYW1lAAAABUxldmVsAAAABkNhbGxlcgAAAAlOYXRpb25LZXkAAAAMU2FjcmlmaWNlS2V5AwkBAAAAAiE9AAAAAgUAAAAJTmF0aW9uS2V5AgAAAAAJAQAAABlDaGVja0Fzc2V0QnVpbGRhYmxlTmF0aW9uAAAABAUAAAAETmFtZQUAAAAFTGV2ZWwFAAAACU5hdGlvbktleQUAAAAMU2FjcmlmaWNlS2V5CQEAAAAXQ2hlY2tBc3NldEJ1aWxkYWJsZVVzZXIAAAAEBQAAAAROYW1lBQAAAAVMZXZlbAUAAAAGQ2FsbGVyBQAAAAxTYWNyaWZpY2VLZXkAAAALAAAAAWkBAAAAClN0YXJ0QnVpbGQAAAAEAAAADHN0ckFzc2V0VHlwZQAAAAVMZXZlbAAAAAlOYXRpb25LZXkAAAAMU2FjcmlmaWNlS2V5AwkBAAAAASEAAAABCQEAAAATQ2hlY2tBc3NldEJ1aWxkYWJsZQAAAAUFAAAADHN0ckFzc2V0VHlwZQUAAAAFTGV2ZWwJAAQlAAAAAQgFAAAAAWkAAAAGY2FsbGVyBQAAAAlOYXRpb25LZXkFAAAADFNhY3JpZmljZUtleQkAAAIAAAABAgAAABpZb3UgY2Fubm90IGJ1aWxkIHRoaXMgSXRlbQQAAAAHY25mZ0tleQkBAAAACGdldEFMS2V5AAAAAgUAAAAMc3RyQXNzZXRUeXBlBQAAAAVMZXZlbAQAAAAQZGVsYXlGb3JCdWlsZGluZwkBAAAAEWNvbmZUcnlHZXRJbnRlZ2VyAAAAAQkAASwAAAACBQAAAAdjbmZnS2V5AgAAAApfQnVpbGRUaW1lBAAAAA5hc3NldEJ1aWxkQ29zdAkBAAAAEWNvbmZUcnlHZXRJbnRlZ2VyAAAAAQkAASwAAAACBQAAAAdjbmZnS2V5AgAAAAVfQ29zdAQAAAANVG9BZG1pbldhbGxldAkAAGkAAAACCQAAaAAAAAIFAAAADmFzc2V0QnVpbGRDb3N0AAAAAAAAAAAFAAAAAAAAAABkBAAAABNUb0dhbWVSZXdhcmRzV2FsbGV0CQAAaQAAAAIJAABoAAAAAgUAAAAOYXNzZXRCdWlsZENvc3QAAAAAAAAAAAoAAAAAAAAAAGQEAAAAFlRvU3Rha2luZ1Jld2FyZHNXYWxsZXQJAABpAAAAAgkAAGgAAAACBQAAAA5hc3NldEJ1aWxkQ29zdAAAAAAAAAAAQQAAAAAAAAAAZAQAAAANVW5pdFN0YWtlU2hlZwkAAGUAAAACCQAAZQAAAAIJAABlAAAAAgUAAAAOYXNzZXRCdWlsZENvc3QFAAAADVRvQWRtaW5XYWxsZXQFAAAAE1RvR2FtZVJld2FyZHNXYWxsZXQFAAAAFlRvU3Rha2luZ1Jld2FyZHNXYWxsZXQDCQEAAAAVaXNOYXRpb25SZXNlcnZlZEFzc2V0AAAAAgUAAAAMc3RyQXNzZXRUeXBlBQAAAAVMZXZlbAMDCQEAAAABIQAAAAEJAQAAAA9jaGVja0Fzc2V0T3duZXIAAAACCQAEJQAAAAEIBQAAAAFpAAAABmNhbGxlcgUAAAAJTmF0aW9uS2V5CQEAAAABIQAAAAEJAQAAAApjaGVja0FkbWluAAAAAQgFAAAAAWkAAAAGY2FsbGVyBwkAAAIAAAABAgAAACNZb3UgYXJlIG5vdCB0aGUgb3duZXIgb2YgdGhlIG5hdGlvbgQAAAAKbmF0aW9uc2hlZwkBAAAAFXRyZWFzdXJ5VHJ5R2V0SW50ZWdlcgAAAAEJAQAAAA5nZXRUcmVhc3VyeUtleQAAAAEFAAAACU5hdGlvbktleQMJAABmAAAAAgUAAAAOYXNzZXRCdWlsZENvc3QFAAAACm5hdGlvbnNoZWcJAAACAAAAAQIAAAAeVGhlIG5hdGlvbiBoYXNuJ3QgZW5vdWdoIGZ1bmRzBAAAAAFkCQAD/AAAAAQJAQAAAAdBZGRyZXNzAAAAAQUAAAAPdHJlYXN1cnlBZGRyZXNzAgAAABRkZWNyZWFzZU5hdGlvbldhbGxldAkABEwAAAACBQAAAAlOYXRpb25LZXkJAARMAAAAAgUAAAAOYXNzZXRCdWlsZENvc3QFAAAAA25pbAUAAAADbmlsBAAAAAckbWF0Y2gwBQAAAAFkAwkAAAEAAAACBQAAAAckbWF0Y2gwAgAAAANJbnQEAAAAAXIFAAAAByRtYXRjaDAEAAAAAnB3CQAD/AAAAAQJAQAAAAdBZGRyZXNzAAAAAQUAAAAPdHJlYXN1cnlBZGRyZXNzAgAAABFhcmJpdHJhcnlBZGRDb2lucwkABEwAAAACBQAAAAlOYXRpb25LZXkJAARMAAAAAgUAAAANVW5pdFN0YWtlU2hlZwUAAAADbmlsBQAAAANuaWwEAAAAByRtYXRjaDEFAAAAAnB3AwkAAAEAAAACBQAAAAckbWF0Y2gxAgAAAANJbnQEAAAAAWIFAAAAByRtYXRjaDEEAAAACHRyYW5zZmVyCQAD/AAAAAQJAQAAAAdBZGRyZXNzAAAAAQUAAAAPdHJlYXN1cnlBZGRyZXNzAgAAABpkaXN0cmlidXRlTmF0aW9uUGF5UmV3YXJkcwkABEwAAAACBQAAAA5hc3NldEJ1aWxkQ29zdAUAAAADbmlsBQAAAANuaWwEAAAAByRtYXRjaDIFAAAACHRyYW5zZmVyAwkAAAEAAAACBQAAAAckbWF0Y2gyAgAAAANJbnQEAAAAAXQFAAAAByRtYXRjaDIJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAAFGdldEJ1aWxkaW5nU3RhdHVzS2V5AAAAAwkABCUAAAABCAUAAAABaQAAAAxvcmlnaW5DYWxsZXIIBQAAAAFpAAAADXRyYW5zYWN0aW9uSWQFAAAAB2NuZmdLZXkFAAAADEJ1aWxkU3RhcnRlZAkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAAQZ2V0QXNzZXRPd25lcktleQAAAAIIBQAAAAFpAAAADXRyYW5zYWN0aW9uSWQFAAAAB2NuZmdLZXkFAAAACU5hdGlvbktleQkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgkBAAAAGmdldEJ1aWxkaW5nRmluaXNoSGVpZ2h0S2V5AAAAAwkABCUAAAABCAUAAAABaQAAAAxvcmlnaW5DYWxsZXIIBQAAAAFpAAAADXRyYW5zYWN0aW9uSWQFAAAAB2NuZmdLZXkJAABkAAAAAgUAAAAGaGVpZ2h0BQAAABBkZWxheUZvckJ1aWxkaW5nBQAAAANuaWwJAAACAAAAAQIAAAAgRXJyb3IgRGlzdHJpYnV0aW5nIGFzc2V0IHJld2FyZHMJAAACAAAAAQIAAAAdRXJyb3IgRGVwb3NpdGluZyBuYXRpb24gZnVuZHMJAAACAAAAAQIAAAAdRXJyb3IgRGVwb3NpdGluZyBuYXRpb24gZnVuZHMEAAAACGFzc2V0U2FjCQEAAAAQY29uZlRyeUdldFN0cmluZwAAAAEJAAEsAAAAAgUAAAAHY25mZ0tleQIAAAAPX1NhY3JpZmljZUFzc2V0AwkBAAAAAiE9AAAAAgUAAAAIYXNzZXRTYWMCAAAAAAkABEwAAAACCQEAAAALRGVsZXRlRW50cnkAAAABBQAAAAxTYWNyaWZpY2VLZXkJAARMAAAAAgkBAAAAC0RlbGV0ZUVudHJ5AAAAAQkAASwAAAACBQAAAAxTYWNyaWZpY2VLZXkCAAAABl9Pd25lcgkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAAUZ2V0QnVpbGRpbmdTdGF0dXNLZXkAAAADCQAEJQAAAAEIBQAAAAFpAAAADG9yaWdpbkNhbGxlcggFAAAAAWkAAAANdHJhbnNhY3Rpb25JZAUAAAAHY25mZ0tleQUAAAAMQnVpbGRTdGFydGVkCQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAABBnZXRBc3NldE93bmVyS2V5AAAAAggFAAAAAWkAAAANdHJhbnNhY3Rpb25JZAUAAAAHY25mZ0tleQkABCUAAAABCAUAAAABaQAAAAxvcmlnaW5DYWxsZXIJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIJAQAAABpnZXRCdWlsZGluZ0ZpbmlzaEhlaWdodEtleQAAAAMJAAQlAAAAAQgFAAAAAWkAAAAMb3JpZ2luQ2FsbGVyCAUAAAABaQAAAA10cmFuc2FjdGlvbklkBQAAAAdjbmZnS2V5CQAAZAAAAAIFAAAABmhlaWdodAUAAAAQZGVsYXlGb3JCdWlsZGluZwUAAAADbmlsBAAAAAhhbW91bnRJbgkBAAAABXZhbHVlAAAAAQgJAAGRAAAAAggFAAAAAWkAAAAIcGF5bWVudHMAAAAAAAAAAAAAAAAGYW1vdW50AwkAAGYAAAACBQAAAA5hc3NldEJ1aWxkQ29zdAUAAAAIYW1vdW50SW4JAAACAAAAAQkAASwAAAACAgAAAD5Zb3UgcHJvdmlkZWQgbGVzcyAkaGVnIHRoYW4gdGhlIG5lZWRlZCBjb3N0IGZvciBidWlsZGluZyB0aGlzIAUAAAAMc3RyQXNzZXRUeXBlAwkBAAAAAiE9AAAAAggJAAGRAAAAAggFAAAAAWkAAAAIcGF5bWVudHMAAAAAAAAAAAAAAAAHYXNzZXRJZAUAAAAKc2hpbnl3Z2dpZAkAAAIAAAABAgAAABpPbmx5ICRIRUcgcGF5bWVudHMgYWxsb3dlZAQAAAACcHcJAAP8AAAABAkBAAAAB0FkZHJlc3MAAAABBQAAAA90cmVhc3VyeUFkZHJlc3MCAAAAB0RlcG9zaXQFAAAAA25pbAkABEwAAAACCQEAAAAPQXR0YWNoZWRQYXltZW50AAAAAgUAAAAKc2hpbnl3Z2dpZAUAAAANVW5pdFN0YWtlU2hlZwUAAAADbmlsBAAAAAckbWF0Y2gwBQAAAAJwdwMJAAABAAAAAgUAAAAHJG1hdGNoMAIAAAADSW50BAAAAAFyBQAAAAckbWF0Y2gwCQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAABRnZXRCdWlsZGluZ1N0YXR1c0tleQAAAAMJAAQlAAAAAQgFAAAAAWkAAAAMb3JpZ2luQ2FsbGVyCAUAAAABaQAAAA10cmFuc2FjdGlvbklkBQAAAAdjbmZnS2V5BQAAAAxCdWlsZFN0YXJ0ZWQJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAAEGdldEFzc2V0T3duZXJLZXkAAAACCAUAAAABaQAAAA10cmFuc2FjdGlvbklkBQAAAAdjbmZnS2V5CQAEJQAAAAEIBQAAAAFpAAAADG9yaWdpbkNhbGxlcgkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgkBAAAAGmdldEJ1aWxkaW5nRmluaXNoSGVpZ2h0S2V5AAAAAwkABCUAAAABCAUAAAABaQAAAAxvcmlnaW5DYWxsZXIIBQAAAAFpAAAADXRyYW5zYWN0aW9uSWQFAAAAB2NuZmdLZXkJAABkAAAAAgUAAAAGaGVpZ2h0BQAAABBkZWxheUZvckJ1aWxkaW5nCQAETAAAAAIJAQAAAA5TY3JpcHRUcmFuc2ZlcgAAAAMFAAAAC2FkbWluV2FsbGV0BQAAAA1Ub0FkbWluV2FsbGV0BQAAAApzaGlueXdnZ2lkCQAETAAAAAIJAQAAAA5TY3JpcHRUcmFuc2ZlcgAAAAMFAAAAFmRhaWx5R2FtZVJld2FyZHNXYWxsZXQFAAAAE1RvR2FtZVJld2FyZHNXYWxsZXQFAAAACnNoaW55d2dnaWQJAARMAAAAAgkBAAAADlNjcmlwdFRyYW5zZmVyAAAAAwUAAAAZZGFpbHlTdGFraW5nUmV3YXJkc1dhbGxldAUAAAAWVG9TdGFraW5nUmV3YXJkc1dhbGxldAUAAAAKc2hpbnl3Z2dpZAUAAAADbmlsCQAAAgAAAAECAAAAF0luY29ycmVjdCBpbnZva2UgcmVzdWx0AAAAAWkBAAAAC0ZpbmlzaEJ1aWxkAAAABAAAAAd0eElkU3RyAAAACGFzc2V0U3RyAAAABUxldmVsAAAACU5hdGlvbktleQQAAAAEdHhJZAkAAlkAAAABBQAAAAd0eElkU3RyBAAAAAVBTEtleQkBAAAACGdldEFMS2V5AAAAAgUAAAAIYXNzZXRTdHIFAAAABUxldmVsBAAAABFCdWlsZGluZ1N0YXR1c0tleQkBAAAAFGdldEJ1aWxkaW5nU3RhdHVzS2V5AAAAAwkABCUAAAABCAUAAAABaQAAAAZjYWxsZXIFAAAABHR4SWQFAAAABUFMS2V5BAAAAA9maW5pc2hIZWlnaHRLZXkJAQAAABpnZXRCdWlsZGluZ0ZpbmlzaEhlaWdodEtleQAAAAMJAAQlAAAAAQgFAAAAAWkAAAAGY2FsbGVyBQAAAAR0eElkBQAAAAVBTEtleQQAAAAIYXNzZXRLZXkJAQAAAA1nZXRBc3NldElkS2V5AAAAAgUAAAAEdHhJZAUAAAAFQUxLZXkEAAAACmFzc2V0T3duZXIJAQAAAAx0cnlHZXRTdHJpbmcAAAABCQEAAAAQZ2V0QXNzZXRPd25lcktleQAAAAIFAAAABHR4SWQFAAAABUFMS2V5AwkBAAAAFWlzTmF0aW9uUmVzZXJ2ZWRBc3NldAAAAAIFAAAACGFzc2V0U3RyBQAAAAVMZXZlbAMDCQEAAAABIQAAAAEJAQAAAA9jaGVja0Fzc2V0T3duZXIAAAACCQAEJQAAAAEIBQAAAAFpAAAABmNhbGxlcgUAAAAJTmF0aW9uS2V5CQEAAAABIQAAAAEJAQAAAApjaGVja0FkbWluAAAAAQgFAAAAAWkAAAAGY2FsbGVyBwkAAAIAAAABAgAAADBZb3UgYXJlIG5vdCBhdXRob3JpemVkIHRvIHBlcmZvcm0gdGhpcyBvcGVyYXRpb24JAQAAABNpbnRlcm5hbEZpbmlzaEJ1aWxkAAAABgUAAAAJTmF0aW9uS2V5BQAAAAVBTEtleQUAAAAIYXNzZXRLZXkFAAAAEUJ1aWxkaW5nU3RhdHVzS2V5BQAAAA9maW5pc2hIZWlnaHRLZXkFAAAABHR4SWQDCQEAAAACIT0AAAACBQAAAAphc3NldE93bmVyCQAEJQAAAAEIBQAAAAFpAAAABmNhbGxlcgkAAAIAAAABCQABLAAAAAICAAAAIVlvdSBjYW5ub3QgY2xhaW0gb3RoZXIncyBwbGF5ZXJzIAUAAAAIYXNzZXRTdHIEAAAAEGJ1aWxkaW5nVHhTdGF0dXMJAQAAAAx0cnlHZXRTdHJpbmcAAAABBQAAABFCdWlsZGluZ1N0YXR1c0tleQMJAAAAAAAAAgUAAAAQYnVpbGRpbmdUeFN0YXR1cwIAAAAACQAAAgAAAAECAAAAJE5vIHBlbmRpbmcgb3BlcmF0aW9ucyBmb3IgdGhpcyBhc3NldAQAAAAIYXNzZXRTYWMJAQAAABBjb25mVHJ5R2V0U3RyaW5nAAAAAQkAASwAAAACBQAAAAVBTEtleQIAAAAPX1NhY3JpZmljZUFzc2V0BAAAAA1hc3NldFNhY0xldmVsCQEAAAARY29uZlRyeUdldEludGVnZXIAAAABCQABLAAAAAIFAAAABUFMS2V5AgAAABRfU2FjcmlmaWNlQXNzZXRMZXZlbAMJAQAAAAIhPQAAAAIFAAAACGFzc2V0U2FjAgAAAAAJAQAAABxpbnRlcm5hbFNhY3JpZmljZUZpbmlzaEJ1aWxkAAAABwkABCUAAAABCAUAAAABaQAAAAZjYWxsZXIFAAAABUFMS2V5BQAAAAhhc3NldEtleQUAAAARQnVpbGRpbmdTdGF0dXNLZXkFAAAAD2ZpbmlzaEhlaWdodEtleQUAAAAEdHhJZAkBAAAACGdldEFMS2V5AAAAAgUAAAAIYXNzZXRTYWMFAAAADWFzc2V0U2FjTGV2ZWwJAQAAABNpbnRlcm5hbEZpbmlzaEJ1aWxkAAAABgkABCUAAAABCAUAAAABaQAAAAZjYWxsZXIFAAAABUFMS2V5BQAAAAhhc3NldEtleQUAAAARQnVpbGRpbmdTdGF0dXNLZXkFAAAAD2ZpbmlzaEhlaWdodEtleQUAAAAEdHhJZAAAAAFpAQAAABF0cmFuc2Zlck93bmVyc2hpcAAAAAMAAAAHYXNzZXRJZAAAAAhuZXdPd25lcgAAAANxdHkDCQEAAAABIQAAAAEJAQAAAApjaGVja0FkbWluAAAAAQgFAAAAAWkAAAAGY2FsbGVyCQAAAgAAAAECAAAAKU9ubHkgdGhlIGFkbWluIGNhbiBwZXJmb3JtIHRoaXMgb3BlcmF0aW9uCQAFFAAAAAIJAQAAABlpbnRlcm5hbFRyYXNuZmVyT3duZXJzaGlwAAAAAwUAAAAHYXNzZXRJZAUAAAAIbmV3T3duZXIFAAAAA3F0eQUAAAAIbmV3T3duZXIAAAABaQEAAAAXZGVzdHJveUFzc2V0QW5kVHJhbnNmZXIAAAADAAAAB2Fzc2V0SWQAAAADcXR5AAAACXRvQWRkcmVzcwQAAAAGY2h1bmtzCQEAAAARZ2V0QXNzZXRUeXBlTGV2ZWwAAAABBQAAAAdhc3NldElkBAAAAAxzdHJBc3NldFR5cGUIBQAAAAZjaHVua3MAAAACXzEEAAAABWxldmVsCAUAAAAGY2h1bmtzAAAAAl8yBAAAAAFrCQEAAAAIZ2V0QUxLZXkAAAACBQAAAAxzdHJBc3NldFR5cGUFAAAABWxldmVsAwkBAAAAASEAAAABCQEAAAAKY2hlY2tBZG1pbgAAAAEIBQAAAAFpAAAABmNhbGxlcgkAAAIAAAABAgAAAClPbmx5IHRoZSBhZG1pbiBjYW4gcGVyZm9ybSB0aGlzIG9wZXJhdGlvbgQAAAAIb2xkT3duZXIJAQAAAAx0cnlHZXRTdHJpbmcAAAABCQEAAAAWZ2V0QXNzZXRPd25lcktleVN0cmluZwAAAAEFAAAAB2Fzc2V0SWQEAAAACmFzc2V0Q29pbnMJAQAAAA10cnlHZXRJbnRlZ2VyAAAAAQUAAAAHYXNzZXRJZAQAAAAMY3VycmVudFBvd2VyCQEAAAAUbmF0aW9uc1RyeUdldEludGVnZXIAAAABCQABLAAAAAIFAAAACG9sZE93bmVyAgAAAAZfUG93ZXIEAAAACmFzc2V0UG93ZXIJAQAAABFjb25mVHJ5R2V0SW50ZWdlcgAAAAEJAAEsAAAAAgUAAAABawIAAAAGX1Bvd2VyAwkBAAAAEWNvbmZUcnlHZXRCb29sZWFuAAAAAQkAASwAAAACBQAAAAFrAgAAAAtfQWdncmVnYXRlZAQAAAAOdW5pdEFzc2V0Q29pbnMJAABpAAAAAgkAAGgAAAACCQEAAAARY29uZlRyeUdldEludGVnZXIAAAABCQABLAAAAAIFAAAAAWsCAAAABV9Db3N0AAAAAAAAAAAUAAAAAAAAAABkBAAAAAhxdHlBc3NldAkBAAAADXRyeUdldEludGVnZXIAAAABCQABLAAAAAIFAAAAAWsCAAAABF9RdHkDCQAAZgAAAAIAAAAAAAAAAAAJAABlAAAAAgUAAAAIcXR5QXNzZXQFAAAAA3F0eQkAAAIAAAABCQABLAAAAAICAAAAFnlvdSBkb24ndCBoYXZlIGVub3VnaCAFAAAADHN0ckFzc2V0VHlwZQQAAAACcHcJAAP8AAAABAkBAAAAB0FkZHJlc3MAAAABBQAAAA5uYXRpb25zQWRkcmVzcwIAAAAMc2V0VXNlclBvd2VyCQAETAAAAAIFAAAACG9sZE93bmVyCQAETAAAAAIJAABlAAAAAgUAAAAMY3VycmVudFBvd2VyCQAAaAAAAAIFAAAACmFzc2V0UG93ZXIFAAAAA3F0eQUAAAADbmlsBQAAAANuaWwEAAAAByRtYXRjaDAFAAAAAnB3AwkAAAEAAAACBQAAAAckbWF0Y2gwAgAAAANJbnQEAAAAAXIFAAAAByRtYXRjaDAEAAAACWF0dGFja2VycwkABLUAAAACBQAAAAl0b0FkZHJlc3MCAAAAASMEAAAABGRpc3QKAAAAAAIkbAUAAAAJYXR0YWNrZXJzCgAAAAACJHMJAAGQAAAAAQUAAAACJGwKAAAAAAUkYWNjMAUAAAADbmlsCgEAAAAFJGYwXzEAAAACAAAAAiRhAAAAAiRpAwkAAGcAAAACBQAAAAIkaQUAAAACJHMFAAAAAiRhCQEAAAAVZGlzdHJpYkRlc3Ryb3lSZXdhcmRzAAAAAgUAAAACJGEJAAGRAAAAAgUAAAACJGwFAAAAAiRpCgEAAAAFJGYwXzIAAAACAAAAAiRhAAAAAiRpAwkAAGcAAAACBQAAAAIkaQUAAAACJHMFAAAAAiRhCQAAAgAAAAECAAAAFExpc3Qgc2l6ZSBleGNlZWRzIDUwCQEAAAAFJGYwXzIAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACBQAAAAUkYWNjMAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAgAAAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABQAAAAAAAAAABgAAAAAAAAAABwAAAAAAAAAACAAAAAAAAAAACQAAAAAAAAAACgAAAAAAAAAACwAAAAAAAAAADAAAAAAAAAAADQAAAAAAAAAADgAAAAAAAAAADwAAAAAAAAAAEAAAAAAAAAAAEQAAAAAAAAAAEgAAAAAAAAAAEwAAAAAAAAAAFAAAAAAAAAAAFQAAAAAAAAAAFgAAAAAAAAAAFwAAAAAAAAAAGAAAAAAAAAAAGQAAAAAAAAAAGgAAAAAAAAAAGwAAAAAAAAAAHAAAAAAAAAAAHQAAAAAAAAAAHgAAAAAAAAAAHwAAAAAAAAAAIAAAAAAAAAAAIQAAAAAAAAAAIgAAAAAAAAAAIwAAAAAAAAAAJAAAAAAAAAAAJQAAAAAAAAAAJgAAAAAAAAAAJwAAAAAAAAAAKAAAAAAAAAAAKQAAAAAAAAAAKgAAAAAAAAAAKwAAAAAAAAAALAAAAAAAAAAALQAAAAAAAAAALgAAAAAAAAAALwAAAAAAAAAAMAAAAAAAAAAAMQAAAAAAAAAAMgMJAAAAAAAAAgUAAAAEZGlzdAUAAAAEZGlzdAMJAABmAAAAAgkAAGUAAAACBQAAAAhxdHlBc3NldAUAAAADcXR5AAAAAAAAAAAACQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACCQABLAAAAAIFAAAAAWsCAAAABF9RdHkJAABlAAAAAgUAAAAIcXR5QXNzZXQFAAAAA3F0eQUAAAADbmlsCQAETAAAAAIJAQAAAAtEZWxldGVFbnRyeQAAAAEFAAAAB2Fzc2V0SWQJAARMAAAAAgkBAAAAC0RlbGV0ZUVudHJ5AAAAAQkBAAAAFmdldEFzc2V0T3duZXJLZXlTdHJpbmcAAAABBQAAAAdhc3NldElkBQAAAANuaWwJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQAAAgAAAAECAAAAGEVycm9yIHNldHRpbmcgdXNlciBwb3dlcgQAAAAJYXR0YWNrZXJzCQAEtQAAAAIFAAAACXRvQWRkcmVzcwIAAAABIwQAAAAEZGlzdAoAAAAAAiRsBQAAAAlhdHRhY2tlcnMKAAAAAAIkcwkAAZAAAAABBQAAAAIkbAoAAAAABSRhY2MwBQAAAANuaWwKAQAAAAUkZjBfMQAAAAIAAAACJGEAAAACJGkDCQAAZwAAAAIFAAAAAiRpBQAAAAIkcwUAAAACJGEJAQAAABVkaXN0cmliRGVzdHJveVJld2FyZHMAAAACBQAAAAIkYQkAAZEAAAACBQAAAAIkbAUAAAACJGkKAQAAAAUkZjBfMgAAAAIAAAACJGEAAAACJGkDCQAAZwAAAAIFAAAAAiRpBQAAAAIkcwUAAAACJGEJAAACAAAAAQIAAAAUTGlzdCBzaXplIGV4Y2VlZHMgNTAJAQAAAAUkZjBfMgAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIFAAAABSRhY2MwAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAACAAAAAAAAAAADAAAAAAAAAAAEAAAAAAAAAAAFAAAAAAAAAAAGAAAAAAAAAAAHAAAAAAAAAAAIAAAAAAAAAAAJAAAAAAAAAAAKAAAAAAAAAAALAAAAAAAAAAAMAAAAAAAAAAANAAAAAAAAAAAOAAAAAAAAAAAPAAAAAAAAAAAQAAAAAAAAAAARAAAAAAAAAAASAAAAAAAAAAATAAAAAAAAAAAUAAAAAAAAAAAVAAAAAAAAAAAWAAAAAAAAAAAXAAAAAAAAAAAYAAAAAAAAAAAZAAAAAAAAAAAaAAAAAAAAAAAbAAAAAAAAAAAcAAAAAAAAAAAdAAAAAAAAAAAeAAAAAAAAAAAfAAAAAAAAAAAgAAAAAAAAAAAhAAAAAAAAAAAiAAAAAAAAAAAjAAAAAAAAAAAkAAAAAAAAAAAlAAAAAAAAAAAmAAAAAAAAAAAnAAAAAAAAAAAoAAAAAAAAAAApAAAAAAAAAAAqAAAAAAAAAAArAAAAAAAAAAAsAAAAAAAAAAAtAAAAAAAAAAAuAAAAAAAAAAAvAAAAAAAAAAAwAAAAAAAAAAAxAAAAAAAAAAAyAwkAAAAAAAACBQAAAARkaXN0BQAAAARkaXN0BAAAAAJwdwkAA/wAAAAECQEAAAAHQWRkcmVzcwAAAAEFAAAADm5hdGlvbnNBZGRyZXNzAgAAAAxzZXRVc2VyUG93ZXIJAARMAAAAAgUAAAAIb2xkT3duZXIJAARMAAAAAgkAAGUAAAACBQAAAAxjdXJyZW50UG93ZXIFAAAACmFzc2V0UG93ZXIFAAAAA25pbAUAAAADbmlsAwkAAAAAAAACBQAAAAJwdwUAAAACcHcEAAAAByRtYXRjaDAFAAAAAnB3AwkAAAEAAAACBQAAAAckbWF0Y2gwAgAAAANJbnQEAAAAAXIFAAAAByRtYXRjaDAJAARMAAAAAgkBAAAAC0RlbGV0ZUVudHJ5AAAAAQUAAAAHYXNzZXRJZAkABEwAAAACCQEAAAALRGVsZXRlRW50cnkAAAABCQEAAAAWZ2V0QXNzZXRPd25lcktleVN0cmluZwAAAAEFAAAAB2Fzc2V0SWQFAAAAA25pbAkAAAIAAAABAgAAABhFcnJvciBzZXR0aW5nIHVzZXIgcG93ZXIJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgAAAAFpAQAAABRkZXN0cm95QXNzZXRGcm9tVXNlcgAAAAIAAAAHYXNzZXRJZAAAAANxdHkEAAAABmNodW5rcwkBAAAAEWdldEFzc2V0VHlwZUxldmVsAAAAAQUAAAAHYXNzZXRJZAQAAAAMc3RyQXNzZXRUeXBlCAUAAAAGY2h1bmtzAAAAAl8xBAAAAAVsZXZlbAgFAAAABmNodW5rcwAAAAJfMgQAAAABawkBAAAACGdldEFMS2V5AAAAAgUAAAAMc3RyQXNzZXRUeXBlBQAAAAVsZXZlbAMJAQAAAAEhAAAAAQkBAAAAD2NoZWNrQXNzZXRPd25lcgAAAAIJAAQlAAAAAQgFAAAAAWkAAAAGY2FsbGVyBQAAAAdhc3NldElkCQAAAgAAAAECAAAAGFlvdSBkb24ndCBvd24gdGhpcyBhc3NldAQAAAAKYXNzZXRDb2lucwkBAAAADXRyeUdldEludGVnZXIAAAABBQAAAAdhc3NldElkBAAAAAxjdXJyZW50UG93ZXIJAQAAABRuYXRpb25zVHJ5R2V0SW50ZWdlcgAAAAEJAAEsAAAAAgkABCUAAAABCAUAAAABaQAAAAZjYWxsZXICAAAABl9Qb3dlcgQAAAAKYXNzZXRQb3dlcgkBAAAAEWNvbmZUcnlHZXRJbnRlZ2VyAAAAAQkAASwAAAACBQAAAAFrAgAAAAZfUG93ZXIDCQEAAAARY29uZlRyeUdldEJvb2xlYW4AAAABCQABLAAAAAIFAAAAAWsCAAAAC19BZ2dyZWdhdGVkBAAAAA51bml0QXNzZXRDb2lucwkAAGkAAAACCQAAaAAAAAIJAQAAABFjb25mVHJ5R2V0SW50ZWdlcgAAAAEJAAEsAAAAAgUAAAABawIAAAAFX0Nvc3QAAAAAAAAAABQAAAAAAAAAAGQEAAAACHF0eUFzc2V0CQEAAAANdHJ5R2V0SW50ZWdlcgAAAAEJAAEsAAAAAgUAAAABawIAAAAEX1F0eQMJAABmAAAAAgAAAAAAAAAAAAkAAGUAAAACBQAAAAhxdHlBc3NldAUAAAADcXR5CQAAAgAAAAEJAAEsAAAAAgIAAAAWeW91IGRvbid0IGhhdmUgZW5vdWdoIAUAAAAMc3RyQXNzZXRUeXBlBAAAAAJwdwkAA/wAAAAECQEAAAAHQWRkcmVzcwAAAAEFAAAADm5hdGlvbnNBZGRyZXNzAgAAAAxzZXRVc2VyUG93ZXIJAARMAAAAAgkABCUAAAABCAUAAAABaQAAAAZjYWxsZXIJAARMAAAAAgkAAGUAAAACBQAAAAxjdXJyZW50UG93ZXIJAABoAAAAAgUAAAAKYXNzZXRQb3dlcgUAAAADcXR5BQAAAANuaWwFAAAAA25pbAQAAAAHJG1hdGNoMAUAAAACcHcDCQAAAQAAAAIFAAAAByRtYXRjaDACAAAAA0ludAQAAAABcgUAAAAHJG1hdGNoMAQAAAACdHIJAAP8AAAABAkBAAAAB0FkZHJlc3MAAAABBQAAAA90cmVhc3VyeUFkZHJlc3MCAAAADWFkbWluVHJhbnNmZXIJAARMAAAAAgkABCUAAAABCAUAAAABaQAAAAZjYWxsZXIJAARMAAAAAgkAAGgAAAACBQAAAA51bml0QXNzZXRDb2lucwUAAAADcXR5BQAAAANuaWwFAAAAA25pbAQAAAAHJG1hdGNoMQUAAAACdHIDCQAAAQAAAAIFAAAAByRtYXRjaDECAAAAA0ludAQAAAABdAUAAAAHJG1hdGNoMQMJAABmAAAAAgkAAGUAAAACBQAAAAhxdHlBc3NldAUAAAADcXR5AAAAAAAAAAAACQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACCQABLAAAAAIFAAAAAWsCAAAABF9RdHkJAABlAAAAAgUAAAAIcXR5QXNzZXQFAAAAA3F0eQUAAAADbmlsCQAETAAAAAIJAQAAAAtEZWxldGVFbnRyeQAAAAEFAAAAB2Fzc2V0SWQJAARMAAAAAgkBAAAAC0RlbGV0ZUVudHJ5AAAAAQkBAAAAFmdldEFzc2V0T3duZXJLZXlTdHJpbmcAAAABBQAAAAdhc3NldElkBQAAAANuaWwJAAACAAAAAQIAAAAYRXJyb3IgdHJhbnNmZXJyaW5nIGNvaW5zCQAAAgAAAAECAAAAGEVycm9yIHNldHRpbmcgdXNlciBwb3dlcgQAAAACcHcJAAP8AAAABAkBAAAAB0FkZHJlc3MAAAABBQAAAA5uYXRpb25zQWRkcmVzcwIAAAAMc2V0VXNlclBvd2VyCQAETAAAAAIJAAQlAAAAAQgFAAAAAWkAAAAGY2FsbGVyCQAETAAAAAIJAABlAAAAAgUAAAAMY3VycmVudFBvd2VyBQAAAAphc3NldFBvd2VyBQAAAANuaWwFAAAAA25pbAQAAAAHJG1hdGNoMAUAAAACcHcDCQAAAQAAAAIFAAAAByRtYXRjaDACAAAAA0ludAQAAAABcgUAAAAHJG1hdGNoMAQAAAACdHIJAAP8AAAABAkBAAAAB0FkZHJlc3MAAAABBQAAAA90cmVhc3VyeUFkZHJlc3MCAAAADWFkbWluVHJhbnNmZXIJAARMAAAAAgkABCUAAAABCAUAAAABaQAAAAZjYWxsZXIJAARMAAAAAgUAAAAKYXNzZXRDb2lucwUAAAADbmlsBQAAAANuaWwEAAAAByRtYXRjaDEFAAAAAnRyAwkAAAEAAAACBQAAAAckbWF0Y2gxAgAAAANJbnQEAAAAAXQFAAAAByRtYXRjaDEJAARMAAAAAgkBAAAAC0RlbGV0ZUVudHJ5AAAAAQUAAAAHYXNzZXRJZAkABEwAAAACCQEAAAALRGVsZXRlRW50cnkAAAABCQEAAAAWZ2V0QXNzZXRPd25lcktleVN0cmluZwAAAAEFAAAAB2Fzc2V0SWQFAAAAA25pbAkAAAIAAAABAgAAABhFcnJvciB0cmFuc2ZlcnJpbmcgY29pbnMJAAACAAAAAQIAAAAYRXJyb3Igc2V0dGluZyB1c2VyIHBvd2VyAAAAAWkBAAAADnNldE5hdGlvbk93bmVyAAAAAgAAAAluYXRpb25LZXkAAAAIbmV3T3duZXIDCQEAAAAKY2hlY2tBZG1pbgAAAAEIBQAAAAFpAAAABmNhbGxlcgkABRQAAAACCQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAAEsAAAAAgUAAAAJbmF0aW9uS2V5AgAAAAZfT3duZXIFAAAACG5ld093bmVyBQAAAANuaWwGBAAAAAxjdXJyZW50T3duZXIJAQAAAAx0cnlHZXRTdHJpbmcAAAABCQABLAAAAAIFAAAACW5hdGlvbktleQIAAAAGX093bmVyAwkBAAAAAiE9AAAAAgUAAAAMY3VycmVudE93bmVyCQAEJQAAAAEIBQAAAAFpAAAABmNhbGxlcgkAAAIAAAABAgAAABxZb3UgYXJlIG5vdCB0aGUgbmF0aW9uIG93bmVyCQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAAEsAAAAAgUAAAAJbmF0aW9uS2V5AgAAAAZfT3duZXIFAAAACG5ld093bmVyBQAAAANuaWwAAAABaQEAAAANYnV5TmF0aW9uSXRlbQAAAAIAAAAHYXNzZXRJZAAAAAlOYXRpb25LZXkEAAAABmNodW5rcwkBAAAAEWdldEFzc2V0VHlwZUxldmVsAAAAAQUAAAAHYXNzZXRJZAQAAAAMc3RyQXNzZXRUeXBlCAUAAAAGY2h1bmtzAAAAAl8xBAAAAAVsZXZlbAgFAAAABmNodW5rcwAAAAJfMgQAAAABawkBAAAACGdldEFMS2V5AAAAAgUAAAAMc3RyQXNzZXRUeXBlBQAAAAVsZXZlbAQAAAABbgkBAAAAFG5hdGlvbnNUcnlHZXRJbnRlZ2VyAAAAAQkABCUAAAABCAUAAAABaQAAAAZjYWxsZXIEAAAAA25pZAkBAAAAFG5hdGlvbnNUcnlHZXRJbnRlZ2VyAAAAAQUAAAAJTmF0aW9uS2V5AwkBAAAAAiE9AAAAAgUAAAABbgUAAAADbmlkCQAAAgAAAAECAAAAKHlvdSBjYW4gYnV5IGFzc2V0cyBvbmx5IGZyb20geW91ciBuYXRpb24DCQEAAAABIQAAAAEJAQAAAA9jaGVja0Fzc2V0T3duZXIAAAACBQAAAAlOYXRpb25LZXkFAAAAB2Fzc2V0SWQJAAACAAAAAQIAAAAnVGhlIGFzc2V0IGRvZXMgbm90IGJlbG9uZyB0byB0aGUgbmF0aW9uAwkBAAAAASEAAAABCQEAAAAVaXNOYXRpb25SZXNlcnZlZEFzc2V0AAAAAgUAAAAMc3RyQXNzZXRUeXBlBQAAAAVsZXZlbAkAAAIAAAABAgAAACd0aGlzIGFzc2V0IGNhbm5vdCBiZSBzb2xkIGJ5IHRoZSBuYXRpb24EAAAACmFzc2V0UHJpY2UJAQAAABFjb25mVHJ5R2V0SW50ZWdlcgAAAAEJAAEsAAAAAgkBAAAACGdldEFMS2V5AAAAAgUAAAAMc3RyQXNzZXRUeXBlBQAAAAVsZXZlbAIAAAAKX1NlbGxQcmljZQQAAAAIYW1vdW50SW4JAQAAAAV2YWx1ZQAAAAEICQABkQAAAAIIBQAAAAFpAAAACHBheW1lbnRzAAAAAAAAAAAAAAAABmFtb3VudAMJAABmAAAAAgUAAAAKYXNzZXRQcmljZQUAAAAIYW1vdW50SW4JAAACAAAAAQkAASwAAAACAgAAADxZb3UgcHJvdmlkZWQgbGVzcyAkaGVnIHRoYW4gdGhlIG5lZWRlZCBjb3N0IGZvciBidXlpbmcgdGhpcyAFAAAADHN0ckFzc2V0VHlwZQMJAQAAAAIhPQAAAAIICQABkQAAAAIIBQAAAAFpAAAACHBheW1lbnRzAAAAAAAAAAAAAAAAB2Fzc2V0SWQFAAAACnNoaW55d2dnaWQJAAACAAAAAQIAAAAaT25seSAkSEVHIHBheW1lbnRzIGFsbG93ZWQEAAAAAWEJAAP8AAAABAkBAAAAB0FkZHJlc3MAAAABBQAAAA90cmVhc3VyeUFkZHJlc3MCAAAAFGluY3JlYXNlTmF0aW9uV2FsbGV0CQAETAAAAAIFAAAACU5hdGlvbktleQkABEwAAAACBQAAAAhhbW91bnRJbgUAAAADbmlsBQAAAANuaWwEAAAAByRtYXRjaDAFAAAAAWEDCQAAAQAAAAIFAAAAByRtYXRjaDACAAAAA0ludAQAAAABYgUAAAAHJG1hdGNoMAkABE0AAAACCQEAAAAZaW50ZXJuYWxUcmFzbmZlck93bmVyc2hpcAAAAAMFAAAAB2Fzc2V0SWQJAAQlAAAAAQgFAAAAAWkAAAAGY2FsbGVyAAAAAAAAAAABCQEAAAAOU2NyaXB0VHJhbnNmZXIAAAADCQEAAAAHQWRkcmVzcwAAAAEFAAAAD3RyZWFzdXJ5QWRkcmVzcwUAAAAIYW1vdW50SW4FAAAACnNoaW55d2dnaWQJAAACAAAAAQIAAAApRXJyb3IgdHJhbnNmZXJyaW5nIFNIRUcgdG8gbmF0aW9ucyB3YWxsZXQAAAABaQEAAAAWQWRkQXNzZXRGcm9tTWFya2VwbGFjZQAAAAMAAAAHYXNzZXRJZAAAAAhvbGRPd25lcgAAAAlhc3NldFNoZWcDCQEAAAABIQAAAAEJAQAAAApjaGVja0FkbWluAAAAAQgFAAAAAWkAAAAGY2FsbGVyCQAAAgAAAAECAAAALVlvdSBhcmUgbm90IGFsbG93ZWQgdG8gcGVyZm9ybSB0aGlzIG9wZXJhdGlvbgkABRQAAAACCQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAABZnZXRBc3NldE93bmVyS2V5U3RyaW5nAAAAAQUAAAAHYXNzZXRJZAUAAAAIb2xkT3duZXIJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIFAAAAB2Fzc2V0SWQFAAAACWFzc2V0U2hlZwUAAAADbmlsBQAAAAhvbGRPd25lcgAAAAFpAQAAABpUcmFuc2ZlckFzc2V0VG9NYXJrZXRwbGFjZQAAAAIAAAAHYXNzZXRJZAAAAAlzZWxscHJpY2UDCQEAAAABIQAAAAEJAQAAAA9jaGVja0Fzc2V0T3duZXIAAAACCQAEJQAAAAEIBQAAAAFpAAAABmNhbGxlcgUAAAAHYXNzZXRJZAkAAAIAAAABAgAAACNZb3UgYXJlIG5vdCB0aGUgb3duZXIgb2YgdGhpcyBhc3NldAQAAAAJYXNzZXRTaGVnCQEAAAANdHJ5R2V0SW50ZWdlcgAAAAEFAAAAB2Fzc2V0SWQEAAAAAnRyCQAD/AAAAAQJAQAAAAdBZGRyZXNzAAAAAQUAAAASbWFya2V0cGxhY2VBZGRyZXNzAgAAAAlwdXRPblNhbGUJAARMAAAAAgUAAAAHYXNzZXRJZAkABEwAAAACBQAAAAlhc3NldFNoZWcJAARMAAAAAgUAAAAJc2VsbHByaWNlBQAAAANuaWwFAAAAA25pbAQAAAAHJG1hdGNoMAUAAAACdHIDCQAAAQAAAAIFAAAAByRtYXRjaDACAAAAA0ludAQAAAABdAUAAAAHJG1hdGNoMAkABEwAAAACCQEAAAALRGVsZXRlRW50cnkAAAABCQEAAAAWZ2V0QXNzZXRPd25lcktleVN0cmluZwAAAAEFAAAAB2Fzc2V0SWQJAARMAAAAAgkBAAAAC0RlbGV0ZUVudHJ5AAAAAQUAAAAHYXNzZXRJZAUAAAADbmlsCQAAAgAAAAECAAAAKUVycm9yIHB1dHRpbmcgdGhlIGl0ZW0gb24gdGhlIG1hcmtldHBsYWNlAAAAAWkBAAAABkRlbEtleQAAAAEAAAADa2V5AwkBAAAAASEAAAABCQEAAAAKY2hlY2tBZG1pbgAAAAEIBQAAAAFpAAAABmNhbGxlcgkAAAIAAAABAgAAAAAJAARMAAAAAgkBAAAAC0RlbGV0ZUVudHJ5AAAAAQUAAAADa2V5BQAAAANuaWwAAAABaQEAAAAGVXBkS2V5AAAAAgAAAANrZXkAAAADdmFsAwkBAAAAASEAAAABCQEAAAAKY2hlY2tBZG1pbgAAAAEIBQAAAAFpAAAABmNhbGxlcgkAAAIAAAABAgAAAAAJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgUAAAADa2V5BQAAAAN2YWwFAAAAA25pbAAAAACKl8lW",
    "height": 2129125,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: GRDVgQ8tYUURwJgCs1YvNujrPQLFoB6ANhQvvSZPYPeJ
Next: Hdr93jgyU83ubtkarjBnNLPPg835LkU1CY1m58bdD9B4

Diff: 

OldNewDifferences
255255     }
256256 
257257 
258-func internalTrasnferOwnership (assetId,newOwner) = {
258+func internalTrasnferOwnership (assetId,newOwner,qty) = {
259259     let chunks = getAssetTypeLevel(assetId)
260260     let strAssetType = chunks._1
261261     let level = chunks._2
262262     let k = getALKey(strAssetType, level)
263263     let oldOwner = tryGetString(getAssetOwnerKeyString(assetId))
264-    let assetPower = confTryGetInteger((k + "_Power"))
265-    if ((assetPower > 0))
264+    if (confTryGetBoolean((k + "_Aggregated")))
266265         then {
267-            let currentPower = nationsTryGetInteger((oldOwner + "_Power"))
268-            let pw = invoke(Address(nationsAddress), "setUserPower", [oldOwner, (currentPower - assetPower)], nil)
269-            if ((pw == pw))
270-                then if ((pw != (currentPower - assetPower)))
271-                    then throw("Incorrect invoke result")
272-                    else {
273-                        let newcurrentPower = nationsTryGetInteger((newOwner + "_Power"))
274-                        let pw2 = invoke(Address(nationsAddress), "setUserPower", [newOwner, (newcurrentPower + assetPower)], nil)
275-                        if ((pw2 == pw2))
276-                            then                             match pw2 {
277-                                case r: Int => 
278-[StringEntry(getAssetOwnerKeyString(assetId), newOwner)]
279-                                case _ => 
280-                                    throw("Incorrect invoke result")
281-                            }
282-                            else throw("Strict value is not equal to itself.")
283-                        }
266+            let assetPower = confTryGetInteger((k + "_Power"))
267+            let qtyPower = (assetPower * qty)
268+            let aggrAssetkey = ((k + "_") + oldOwner)
269+            let oldPower = nationsTryGetInteger((oldOwner + "_Power"))
270+            let oldCoins = tryGetInteger(aggrAssetkey)
271+            let singleCoin = fraction(oldCoins, 1, qty)
272+            let oldItemqty = tryGetInteger((aggrAssetkey + "_Qty"))
273+            let newAggrAssetKey = ((k + "_") + newOwner)
274+            let newCoins = tryGetInteger(newAggrAssetKey)
275+            let newItemqty = tryGetInteger((newAggrAssetKey + "_Qty"))
276+            let newPower = nationsTryGetInteger((newOwner + "_Power"))
277+            let pwOld = invoke(Address(nationsAddress), "setUserPower", [oldOwner, (oldPower - qtyPower)], nil)
278+            if ((pwOld == pwOld))
279+                then {
280+                    let pwNew = invoke(Address(nationsAddress), "setUserPower", [newOwner, (newPower + qtyPower)], nil)
281+                    if ((pwNew == pwNew))
282+                        then [IntegerEntry((aggrAssetkey + "_Qty"), (oldItemqty - qty)), IntegerEntry((newAggrAssetKey + "_Qty"), (newItemqty + qty)), IntegerEntry(aggrAssetkey, (oldCoins - (qty * singleCoin))), IntegerEntry(newAggrAssetKey, (newCoins + (qty * singleCoin)))]
283+                        else throw("Strict value is not equal to itself.")
284+                    }
284285                 else throw("Strict value is not equal to itself.")
285286             }
286-        else [StringEntry(getAssetOwnerKeyString(assetId), newOwner)]
287+        else {
288+            let assetPower = confTryGetInteger((k + "_Power"))
289+            if ((assetPower > 0))
290+                then {
291+                    let currentPower = nationsTryGetInteger((oldOwner + "_Power"))
292+                    let pw = invoke(Address(nationsAddress), "setUserPower", [oldOwner, (currentPower - assetPower)], nil)
293+                    if ((pw == pw))
294+                        then if ((pw != (currentPower - assetPower)))
295+                            then throw("Incorrect invoke result")
296+                            else {
297+                                let newcurrentPower = nationsTryGetInteger((newOwner + "_Power"))
298+                                let pw2 = invoke(Address(nationsAddress), "setUserPower", [newOwner, (newcurrentPower + assetPower)], nil)
299+                                if ((pw2 == pw2))
300+                                    then                                     match pw2 {
301+                                        case r: Int => 
302+[StringEntry(getAssetOwnerKeyString(assetId), newOwner)]
303+                                        case _ => 
304+                                            throw("Incorrect invoke result")
305+                                    }
306+                                    else throw("Strict value is not equal to itself.")
307+                                }
308+                        else throw("Strict value is not equal to itself.")
309+                    }
310+                else [StringEntry(getAssetOwnerKeyString(assetId), newOwner)]
311+            }
287312     }
288313 
289314 
440465 
441466 
442467 @Callable(i)
443-func transferOwnership (assetId,newOwner) = if (!(checkAdmin(i.caller)))
468+func transferOwnership (assetId,newOwner,qty) = if (!(checkAdmin(i.caller)))
444469     then throw("Only the admin can perform this operation")
445-    else $Tuple2(internalTrasnferOwnership(assetId, newOwner), newOwner)
470+    else $Tuple2(internalTrasnferOwnership(assetId, newOwner, qty), newOwner)
446471 
447472 
448473 
622647                                 let a = invoke(Address(treasuryAddress), "increaseNationWallet", [NationKey, amountIn], nil)
623648                                 match a {
624649                                     case b: Int => 
625-                                        (internalTrasnferOwnership(assetId, toString(i.caller)) :+ ScriptTransfer(Address(treasuryAddress), amountIn, shinywggid))
650+                                        (internalTrasnferOwnership(assetId, toString(i.caller), 1) :+ ScriptTransfer(Address(treasuryAddress), amountIn, shinywggid))
626651                                     case _ => 
627652                                         throw("Error transferring SHEG to nations wallet")
628653                                 }

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 5 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let shinywggid = base58'AFQS5E4ELtxex3iANtWtUU2V2oWJZSo8VVnK8z3VFmqf'
55 
66 let treasuryAddress = base58'3MyDGEoKp1gF4LSRknk9vSuDEyrwuYXcQEQ'
77 
88 let assetsAddress = base58'3N8WDKbqGox5Eky326PHHT7rUyrby5MXdmb'
99 
1010 let marketplaceAddress = base58'3Mra7mjPipcQd5sJaRmXK8xgS4scb8gPF4A'
1111 
1212 let configurationAddress = base58'3N9tj3b2djcaZozn97VkYchL9S1i6cdEbC1'
1313 
1414 let nationsAddress = base58'3MvyzDtzWWV5MZ1GP8JfQhhQqiGU4Nbifdy'
1515 
1616 let adminWallet = addressFromStringValue("3MpNtiPSRSq6NnaQYk38BfWSzZcgAYTyrQ9")
1717 
1818 let dailyGameRewardsWallet = addressFromStringValue("3MuSrXTTiwo9bdoD6FeaBpMUYMiU5saDv2U")
1919 
2020 let dailyStakingRewardsWallet = addressFromStringValue("3Mv3mr3uNXdpgkVPApbGEJjMQXqau37DY5i")
2121 
2222 func checkAdmin (caller) = if (if (if (if (if ((caller == adminWallet))
2323     then true
2424     else (caller == this))
2525     then true
2626     else (caller.bytes == assetsAddress))
2727     then true
2828     else (caller.bytes == treasuryAddress))
2929     then true
3030     else (caller.bytes == marketplaceAddress))
3131     then true
3232     else (caller.bytes == nationsAddress)
3333 
3434 
3535 func tryGetInteger (key) = match getInteger(this, key) {
3636     case b: Int => 
3737         b
3838     case _ => 
3939         0
4040 }
4141 
4242 
4343 func tryGetBoolean (key) = match getBoolean(this, key) {
4444     case b: Boolean => 
4545         b
4646     case _ => 
4747         false
4848 }
4949 
5050 
5151 func tryGetString (key) = match getString(this, key) {
5252     case b: String => 
5353         b
5454     case _ => 
5555         ""
5656 }
5757 
5858 
5959 func getALKey (Name,Level) = ((Name + "_lvl") + toString(Level))
6060 
6161 
6262 func confTryGetInteger (key) = match getInteger(Address(configurationAddress), key) {
6363     case b: Int => 
6464         b
6565     case _ => 
6666         0
6767 }
6868 
6969 
7070 func confTryGetString (key) = match getString(Address(configurationAddress), key) {
7171     case b: String => 
7272         b
7373     case _ => 
7474         ""
7575 }
7676 
7777 
7878 func confTryGetBoolean (key) = match getBoolean(Address(configurationAddress), key) {
7979     case b: Boolean => 
8080         b
8181     case _ => 
8282         false
8383 }
8484 
8585 
8686 func getTreasuryKey (nationid) = (nationid + "_Treasury")
8787 
8888 
8989 func treasuryTryGetInteger (key) = match getInteger(Address(treasuryAddress), key) {
9090     case b: Int => 
9191         b
9292     case _ => 
9393         0
9494 }
9595 
9696 
9797 func nationsTryGetInteger (key) = match getInteger(Address(nationsAddress), key) {
9898     case b: Int => 
9999         b
100100     case _ => 
101101         0
102102 }
103103 
104104 
105105 func nationsTryGetBoolean (key) = match getBoolean(Address(nationsAddress), key) {
106106     case b: Boolean => 
107107         b
108108     case _ => 
109109         false
110110 }
111111 
112112 
113113 func nationsTryGetString (key) = match getString(Address(nationsAddress), key) {
114114     case b: String => 
115115         b
116116     case _ => 
117117         ""
118118 }
119119 
120120 
121121 func getAssetOwnerKeyString (assetId) = (assetId + "_Owner")
122122 
123123 
124124 let BuildStarted = "BUILD_STARTED"
125125 
126126 let BuildFinished = "BUILD_FINISHED"
127127 
128128 func getAssetIdKey (txId,assetType) = ((assetType + "_") + toBase58String(txId))
129129 
130130 
131131 func getAssetOwnerKey (txId,assetType) = (getAssetIdKey(txId, assetType) + "_Owner")
132132 
133133 
134134 func getBuildingFinishHeightKey (address,txId,assetType) = (((address + "_") + getAssetIdKey(txId, assetType)) + "_fh")
135135 
136136 
137137 func getBuildingStatusKey (address,txId,assetType) = (((address + "_") + getAssetIdKey(txId, assetType)) + "_status")
138138 
139139 
140140 func getAssetTypeLevel (assetStr) = {
141141     let chunks = split(assetStr, "_")
142142     let strAssetType = chunks[0]
143143     let level = parseIntValue(drop(chunks[1], 3))
144144     $Tuple2(strAssetType, level)
145145     }
146146 
147147 
148148 func internalDistrib (addressStr,amount) = {
149149     let tr = invoke(Address(treasuryAddress), "addReward", [addressFromStringValue(addressStr), amount], nil)
150150     if ((tr == tr))
151151         then         match tr {
152152             case t: Int => 
153153                 amount
154154             case _ => 
155155                 0
156156         }
157157         else throw("Strict value is not equal to itself.")
158158     }
159159 
160160 
161161 func distribDestroyRewards (accum,nextValue) = {
162162     let val = split(nextValue, "_")
163163     let addr = val[0]
164164     let amnt = val[1]
165165     (accum :+ internalDistrib(addr, parseIntValue(amnt)))
166166     }
167167 
168168 
169169 func internalSacrificeFinishBuild (caller,assetStr,assetKey,BuildingStatusKey,finishHeightKey,transactionId,sacrificekey) = {
170170     let chunks = getAssetTypeLevel(assetStr)
171171     let strAssetType = chunks._1
172172     let level = chunks._2
173173     let buildingFinishHeight = getIntegerValue(this, finishHeightKey)
174174     if ((buildingFinishHeight > height))
175175         then throw((((("Building is not finished yet " + toString((buildingFinishHeight - height))) + " blocks remaining, it will take around ") + toString((buildingFinishHeight - height))) + " minutes"))
176176         else if ((take(strAssetType, 4) == "TECH"))
177177             then {
178178                 let discovered = invoke(Address(nationsAddress), "setTecnhnologyDiscovered", [caller, assetStr], nil)
179179                 if ((discovered == true))
180180                     then [DeleteEntry(BuildingStatusKey), DeleteEntry(finishHeightKey), DeleteEntry(getAssetOwnerKey(transactionId, assetStr))]
181181                     else throw("error discovering technology")
182182                 }
183183             else {
184184                 let assetPower = confTryGetInteger((assetStr + "_Power"))
185185                 let assetCoins = ((confTryGetInteger((sacrificekey + "_Cost")) * 20) / 100)
186186                 if ((assetPower > 0))
187187                     then {
188188                         let currentPower = nationsTryGetInteger((caller + "_Power"))
189189                         let pw = invoke(Address(nationsAddress), "setUserPower", [caller, (currentPower + assetPower)], nil)
190190                         if ((pw == pw))
191191                             then [IntegerEntry(assetKey, assetCoins), DeleteEntry(BuildingStatusKey), DeleteEntry(finishHeightKey)]
192192                             else throw("Strict value is not equal to itself.")
193193                         }
194194                     else [IntegerEntry(assetKey, assetCoins), DeleteEntry(BuildingStatusKey), DeleteEntry(finishHeightKey)]
195195                 }
196196     }
197197 
198198 
199199 func internalFinishBuild (caller,assetStr,assetKey,BuildingStatusKey,finishHeightKey,transactionId) = {
200200     let chunks = getAssetTypeLevel(assetStr)
201201     let strAssetType = chunks._1
202202     let level = chunks._2
203203     let buildingFinishHeight = getIntegerValue(this, finishHeightKey)
204204     if ((buildingFinishHeight > height))
205205         then throw((((("Building is not finished yet " + toString((buildingFinishHeight - height))) + " blocks remaining, it will take around ") + toString((buildingFinishHeight - height))) + " minutes"))
206206         else if ((take(strAssetType, 4) == "TECH"))
207207             then {
208208                 let discovered = invoke(Address(nationsAddress), "setTecnhnologyDiscovered", [caller, assetStr], nil)
209209                 if ((discovered == true))
210210                     then [DeleteEntry(BuildingStatusKey), DeleteEntry(finishHeightKey), DeleteEntry(getAssetOwnerKey(transactionId, assetStr))]
211211                     else throw("error discovering technology")
212212                 }
213213             else {
214214                 let assetPower = confTryGetInteger((assetStr + "_Power"))
215215                 let assetCoins = ((confTryGetInteger((assetStr + "_Cost")) * 20) / 100)
216216                 let refCall = invoke(Address(treasuryAddress), "Pay", [caller, assetCoins], nil)
217217                 if ((refCall == refCall))
218218                     then if ((assetPower > 0))
219219                         then {
220220                             let currentPower = nationsTryGetInteger((caller + "_Power"))
221221                             let pw = invoke(Address(nationsAddress), "setUserPower", [caller, (currentPower + assetPower)], nil)
222222                             if ((pw == pw))
223223                                 then if (confTryGetBoolean((assetStr + "_Aggregated")))
224224                                     then {
225225                                         let aggrAssetkey = ((assetStr + "_") + caller)
226226                                         let coins = tryGetInteger(aggrAssetkey)
227227                                         let qty = tryGetInteger((aggrAssetkey + "_Qty"))
228228 [DeleteEntry(getAssetOwnerKey(transactionId, assetStr)), StringEntry((aggrAssetkey + "_Owner"), caller), IntegerEntry(aggrAssetkey, (coins + assetCoins)), IntegerEntry((aggrAssetkey + "_Qty"), (qty + 1)), DeleteEntry(BuildingStatusKey), DeleteEntry(finishHeightKey)]
229229                                         }
230230                                     else [IntegerEntry(assetKey, assetCoins), DeleteEntry(BuildingStatusKey), DeleteEntry(finishHeightKey)]
231231                                 else throw("Strict value is not equal to itself.")
232232                             }
233233                         else if (confTryGetBoolean((assetStr + "_Aggregated")))
234234                             then {
235235                                 let aggrAssetkey = ((assetStr + "_") + caller)
236236                                 let coins = tryGetInteger(aggrAssetkey)
237237                                 let qty = tryGetInteger((aggrAssetkey + "_Qty"))
238238 [DeleteEntry(getAssetOwnerKey(transactionId, assetStr)), StringEntry((aggrAssetkey + "_Owner"), caller), IntegerEntry(aggrAssetkey, (coins + assetCoins)), IntegerEntry((aggrAssetkey + "_Qty"), (qty + 1)), DeleteEntry(BuildingStatusKey), DeleteEntry(finishHeightKey)]
239239                                 }
240240                             else [IntegerEntry(assetKey, assetCoins), DeleteEntry(BuildingStatusKey), DeleteEntry(finishHeightKey)]
241241                     else throw("Strict value is not equal to itself.")
242242                 }
243243     }
244244 
245245 
246246 func checkAssetOwner (caller,assetKey) = {
247247     let assetOwner = tryGetString(getAssetOwnerKeyString(assetKey))
248248     (assetOwner == caller)
249249     }
250250 
251251 
252252 func isNationReservedAsset (Name,Level) = {
253253     let k = getALKey(Name, Level)
254254     confTryGetBoolean((k + "_NationReserved"))
255255     }
256256 
257257 
258-func internalTrasnferOwnership (assetId,newOwner) = {
258+func internalTrasnferOwnership (assetId,newOwner,qty) = {
259259     let chunks = getAssetTypeLevel(assetId)
260260     let strAssetType = chunks._1
261261     let level = chunks._2
262262     let k = getALKey(strAssetType, level)
263263     let oldOwner = tryGetString(getAssetOwnerKeyString(assetId))
264-    let assetPower = confTryGetInteger((k + "_Power"))
265-    if ((assetPower > 0))
264+    if (confTryGetBoolean((k + "_Aggregated")))
266265         then {
267-            let currentPower = nationsTryGetInteger((oldOwner + "_Power"))
268-            let pw = invoke(Address(nationsAddress), "setUserPower", [oldOwner, (currentPower - assetPower)], nil)
269-            if ((pw == pw))
270-                then if ((pw != (currentPower - assetPower)))
271-                    then throw("Incorrect invoke result")
272-                    else {
273-                        let newcurrentPower = nationsTryGetInteger((newOwner + "_Power"))
274-                        let pw2 = invoke(Address(nationsAddress), "setUserPower", [newOwner, (newcurrentPower + assetPower)], nil)
275-                        if ((pw2 == pw2))
276-                            then                             match pw2 {
277-                                case r: Int => 
278-[StringEntry(getAssetOwnerKeyString(assetId), newOwner)]
279-                                case _ => 
280-                                    throw("Incorrect invoke result")
281-                            }
282-                            else throw("Strict value is not equal to itself.")
283-                        }
266+            let assetPower = confTryGetInteger((k + "_Power"))
267+            let qtyPower = (assetPower * qty)
268+            let aggrAssetkey = ((k + "_") + oldOwner)
269+            let oldPower = nationsTryGetInteger((oldOwner + "_Power"))
270+            let oldCoins = tryGetInteger(aggrAssetkey)
271+            let singleCoin = fraction(oldCoins, 1, qty)
272+            let oldItemqty = tryGetInteger((aggrAssetkey + "_Qty"))
273+            let newAggrAssetKey = ((k + "_") + newOwner)
274+            let newCoins = tryGetInteger(newAggrAssetKey)
275+            let newItemqty = tryGetInteger((newAggrAssetKey + "_Qty"))
276+            let newPower = nationsTryGetInteger((newOwner + "_Power"))
277+            let pwOld = invoke(Address(nationsAddress), "setUserPower", [oldOwner, (oldPower - qtyPower)], nil)
278+            if ((pwOld == pwOld))
279+                then {
280+                    let pwNew = invoke(Address(nationsAddress), "setUserPower", [newOwner, (newPower + qtyPower)], nil)
281+                    if ((pwNew == pwNew))
282+                        then [IntegerEntry((aggrAssetkey + "_Qty"), (oldItemqty - qty)), IntegerEntry((newAggrAssetKey + "_Qty"), (newItemqty + qty)), IntegerEntry(aggrAssetkey, (oldCoins - (qty * singleCoin))), IntegerEntry(newAggrAssetKey, (newCoins + (qty * singleCoin)))]
283+                        else throw("Strict value is not equal to itself.")
284+                    }
284285                 else throw("Strict value is not equal to itself.")
285286             }
286-        else [StringEntry(getAssetOwnerKeyString(assetId), newOwner)]
287+        else {
288+            let assetPower = confTryGetInteger((k + "_Power"))
289+            if ((assetPower > 0))
290+                then {
291+                    let currentPower = nationsTryGetInteger((oldOwner + "_Power"))
292+                    let pw = invoke(Address(nationsAddress), "setUserPower", [oldOwner, (currentPower - assetPower)], nil)
293+                    if ((pw == pw))
294+                        then if ((pw != (currentPower - assetPower)))
295+                            then throw("Incorrect invoke result")
296+                            else {
297+                                let newcurrentPower = nationsTryGetInteger((newOwner + "_Power"))
298+                                let pw2 = invoke(Address(nationsAddress), "setUserPower", [newOwner, (newcurrentPower + assetPower)], nil)
299+                                if ((pw2 == pw2))
300+                                    then                                     match pw2 {
301+                                        case r: Int => 
302+[StringEntry(getAssetOwnerKeyString(assetId), newOwner)]
303+                                        case _ => 
304+                                            throw("Incorrect invoke result")
305+                                    }
306+                                    else throw("Strict value is not equal to itself.")
307+                                }
308+                        else throw("Strict value is not equal to itself.")
309+                    }
310+                else [StringEntry(getAssetOwnerKeyString(assetId), newOwner)]
311+            }
287312     }
288313 
289314 
290315 func CheckAssetBuildableSacrifice (ALKey,caller,SacrificeKey) = {
291316     let assetSac = confTryGetString((ALKey + "_SacrificeAsset"))
292317     let assetSaclvl = confTryGetInteger((ALKey + "_SacrificeAssetLevel"))
293318     if ((assetSac == ""))
294319         then true
295320         else if (!(checkAssetOwner(caller, SacrificeKey)))
296321             then throw("you are not the owner of the Sacrifice asset")
297322             else {
298323                 let chunks = getAssetTypeLevel(SacrificeKey)
299324                 if (if ((assetSac != chunks._1))
300325                     then true
301326                     else (assetSaclvl != chunks._2))
302327                     then throw("the sacrificeAsset has the wrong type or level")
303328                     else true
304329                 }
305330     }
306331 
307332 
308333 func CheckAssetBuildableNation (Name,Level,NationKey,SacrificeKey) = {
309334     let cnfgKey = getALKey(Name, Level)
310335     let tec = confTryGetString((cnfgKey + "_Tecnhology_discovered"))
311336     if ((tec != ""))
312337         then if (nationsTryGetBoolean(((NationKey + "_") + tec)))
313338             then CheckAssetBuildableSacrifice(cnfgKey, NationKey, SacrificeKey)
314339             else false
315340         else CheckAssetBuildableSacrifice(cnfgKey, NationKey, SacrificeKey)
316341     }
317342 
318343 
319344 func CheckAssetBuildableUser (Name,Level,caller,SacrificeKey) = {
320345     let cnfKey = getALKey(Name, Level)
321346     let nationId = nationsTryGetInteger(caller)
322347     if ((nationId == 0))
323348         then false
324349         else {
325350             let tec = confTryGetString((cnfKey + "_Tecnhology_discovered"))
326351             if ((tec != ""))
327352                 then {
328353                     let NationKey = nationsTryGetString(toString(nationId))
329354                     if (nationsTryGetBoolean(((NationKey + "_") + tec)))
330355                         then CheckAssetBuildableSacrifice(cnfKey, caller, SacrificeKey)
331356                         else false
332357                     }
333358                 else CheckAssetBuildableSacrifice(cnfKey, caller, SacrificeKey)
334359             }
335360     }
336361 
337362 
338363 func CheckAssetBuildable (Name,Level,Caller,NationKey,SacrificeKey) = if ((NationKey != ""))
339364     then CheckAssetBuildableNation(Name, Level, NationKey, SacrificeKey)
340365     else CheckAssetBuildableUser(Name, Level, Caller, SacrificeKey)
341366 
342367 
343368 @Callable(i)
344369 func StartBuild (strAssetType,Level,NationKey,SacrificeKey) = if (!(CheckAssetBuildable(strAssetType, Level, toString(i.caller), NationKey, SacrificeKey)))
345370     then throw("You cannot build this Item")
346371     else {
347372         let cnfgKey = getALKey(strAssetType, Level)
348373         let delayForBuilding = confTryGetInteger((cnfgKey + "_BuildTime"))
349374         let assetBuildCost = confTryGetInteger((cnfgKey + "_Cost"))
350375         let ToAdminWallet = ((assetBuildCost * 5) / 100)
351376         let ToGameRewardsWallet = ((assetBuildCost * 10) / 100)
352377         let ToStakingRewardsWallet = ((assetBuildCost * 65) / 100)
353378         let UnitStakeSheg = (((assetBuildCost - ToAdminWallet) - ToGameRewardsWallet) - ToStakingRewardsWallet)
354379         if (isNationReservedAsset(strAssetType, Level))
355380             then if (if (!(checkAssetOwner(toString(i.caller), NationKey)))
356381                 then !(checkAdmin(i.caller))
357382                 else false)
358383                 then throw("You are not the owner of the nation")
359384                 else {
360385                     let nationsheg = treasuryTryGetInteger(getTreasuryKey(NationKey))
361386                     if ((assetBuildCost > nationsheg))
362387                         then throw("The nation hasn't enough funds")
363388                         else {
364389                             let d = invoke(Address(treasuryAddress), "decreaseNationWallet", [NationKey, assetBuildCost], nil)
365390                             match d {
366391                                 case r: Int => 
367392                                     let pw = invoke(Address(treasuryAddress), "arbitraryAddCoins", [NationKey, UnitStakeSheg], nil)
368393                                     match pw {
369394                                         case b: Int => 
370395                                             let transfer = invoke(Address(treasuryAddress), "distributeNationPayRewards", [assetBuildCost], nil)
371396                                             match transfer {
372397                                                 case t: Int => 
373398 [StringEntry(getBuildingStatusKey(toString(i.originCaller), i.transactionId, cnfgKey), BuildStarted), StringEntry(getAssetOwnerKey(i.transactionId, cnfgKey), NationKey), IntegerEntry(getBuildingFinishHeightKey(toString(i.originCaller), i.transactionId, cnfgKey), (height + delayForBuilding))]
374399                                                 case _ => 
375400                                                     throw("Error Distributing asset rewards")
376401                                             }
377402                                         case _ => 
378403                                             throw("Error Depositing nation funds")
379404                                     }
380405                                 case _ => 
381406                                     throw("Error Depositing nation funds")
382407                             }
383408                             }
384409                     }
385410             else {
386411                 let assetSac = confTryGetString((cnfgKey + "_SacrificeAsset"))
387412                 if ((assetSac != ""))
388413                     then [DeleteEntry(SacrificeKey), DeleteEntry((SacrificeKey + "_Owner")), StringEntry(getBuildingStatusKey(toString(i.originCaller), i.transactionId, cnfgKey), BuildStarted), StringEntry(getAssetOwnerKey(i.transactionId, cnfgKey), toString(i.originCaller)), IntegerEntry(getBuildingFinishHeightKey(toString(i.originCaller), i.transactionId, cnfgKey), (height + delayForBuilding))]
389414                     else {
390415                         let amountIn = value(i.payments[0].amount)
391416                         if ((assetBuildCost > amountIn))
392417                             then throw(("You provided less $heg than the needed cost for building this " + strAssetType))
393418                             else if ((i.payments[0].assetId != shinywggid))
394419                                 then throw("Only $HEG payments allowed")
395420                                 else {
396421                                     let pw = invoke(Address(treasuryAddress), "Deposit", nil, [AttachedPayment(shinywggid, UnitStakeSheg)])
397422                                     match pw {
398423                                         case r: Int => 
399424 [StringEntry(getBuildingStatusKey(toString(i.originCaller), i.transactionId, cnfgKey), BuildStarted), StringEntry(getAssetOwnerKey(i.transactionId, cnfgKey), toString(i.originCaller)), IntegerEntry(getBuildingFinishHeightKey(toString(i.originCaller), i.transactionId, cnfgKey), (height + delayForBuilding)), ScriptTransfer(adminWallet, ToAdminWallet, shinywggid), ScriptTransfer(dailyGameRewardsWallet, ToGameRewardsWallet, shinywggid), ScriptTransfer(dailyStakingRewardsWallet, ToStakingRewardsWallet, shinywggid)]
400425                                         case _ => 
401426                                             throw("Incorrect invoke result")
402427                                     }
403428                                     }
404429                         }
405430                 }
406431         }
407432 
408433 
409434 
410435 @Callable(i)
411436 func FinishBuild (txIdStr,assetStr,Level,NationKey) = {
412437     let txId = fromBase58String(txIdStr)
413438     let ALKey = getALKey(assetStr, Level)
414439     let BuildingStatusKey = getBuildingStatusKey(toString(i.caller), txId, ALKey)
415440     let finishHeightKey = getBuildingFinishHeightKey(toString(i.caller), txId, ALKey)
416441     let assetKey = getAssetIdKey(txId, ALKey)
417442     let assetOwner = tryGetString(getAssetOwnerKey(txId, ALKey))
418443     if (isNationReservedAsset(assetStr, Level))
419444         then if (if (!(checkAssetOwner(toString(i.caller), NationKey)))
420445             then !(checkAdmin(i.caller))
421446             else false)
422447             then throw("You are not authorized to perform this operation")
423448             else internalFinishBuild(NationKey, ALKey, assetKey, BuildingStatusKey, finishHeightKey, txId)
424449         else if ((assetOwner != toString(i.caller)))
425450             then throw(("You cannot claim other's players " + assetStr))
426451             else {
427452                 let buildingTxStatus = tryGetString(BuildingStatusKey)
428453                 if ((buildingTxStatus == ""))
429454                     then throw("No pending operations for this asset")
430455                     else {
431456                         let assetSac = confTryGetString((ALKey + "_SacrificeAsset"))
432457                         let assetSacLevel = confTryGetInteger((ALKey + "_SacrificeAssetLevel"))
433458                         if ((assetSac != ""))
434459                             then internalSacrificeFinishBuild(toString(i.caller), ALKey, assetKey, BuildingStatusKey, finishHeightKey, txId, getALKey(assetSac, assetSacLevel))
435460                             else internalFinishBuild(toString(i.caller), ALKey, assetKey, BuildingStatusKey, finishHeightKey, txId)
436461                         }
437462                 }
438463     }
439464 
440465 
441466 
442467 @Callable(i)
443-func transferOwnership (assetId,newOwner) = if (!(checkAdmin(i.caller)))
468+func transferOwnership (assetId,newOwner,qty) = if (!(checkAdmin(i.caller)))
444469     then throw("Only the admin can perform this operation")
445-    else $Tuple2(internalTrasnferOwnership(assetId, newOwner), newOwner)
470+    else $Tuple2(internalTrasnferOwnership(assetId, newOwner, qty), newOwner)
446471 
447472 
448473 
449474 @Callable(i)
450475 func destroyAssetAndTransfer (assetId,qty,toAddress) = {
451476     let chunks = getAssetTypeLevel(assetId)
452477     let strAssetType = chunks._1
453478     let level = chunks._2
454479     let k = getALKey(strAssetType, level)
455480     if (!(checkAdmin(i.caller)))
456481         then throw("Only the admin can perform this operation")
457482         else {
458483             let oldOwner = tryGetString(getAssetOwnerKeyString(assetId))
459484             let assetCoins = tryGetInteger(assetId)
460485             let currentPower = nationsTryGetInteger((oldOwner + "_Power"))
461486             let assetPower = confTryGetInteger((k + "_Power"))
462487             if (confTryGetBoolean((k + "_Aggregated")))
463488                 then {
464489                     let unitAssetCoins = ((confTryGetInteger((k + "_Cost")) * 20) / 100)
465490                     let qtyAsset = tryGetInteger((k + "_Qty"))
466491                     if ((0 > (qtyAsset - qty)))
467492                         then throw(("you don't have enough " + strAssetType))
468493                         else {
469494                             let pw = invoke(Address(nationsAddress), "setUserPower", [oldOwner, (currentPower - (assetPower * qty))], nil)
470495                             match pw {
471496                                 case r: Int => 
472497                                     let attackers = split(toAddress, "#")
473498                                     let dist = {
474499                                         let $l = attackers
475500                                         let $s = size($l)
476501                                         let $acc0 = nil
477502                                         func $f0_1 ($a,$i) =                                         if (($i >= $s))
478503                                             then $a
479504                                             else distribDestroyRewards($a, $l[$i])
480505 
481506                                         func $f0_2 ($a,$i) =                                         if (($i >= $s))
482507                                             then $a
483508                                             else throw("List size exceeds 50")
484509 
485510                                         $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50)
486511                                         }
487512                                     if ((dist == dist))
488513                                         then if (((qtyAsset - qty) > 0))
489514                                             then [IntegerEntry((k + "_Qty"), (qtyAsset - qty))]
490515                                             else [DeleteEntry(assetId), DeleteEntry(getAssetOwnerKeyString(assetId))]
491516                                         else throw("Strict value is not equal to itself.")
492517                                 case _ => 
493518                                     throw("Error setting user power")
494519                             }
495520                             }
496521                     }
497522                 else {
498523                     let attackers = split(toAddress, "#")
499524                     let dist = {
500525                         let $l = attackers
501526                         let $s = size($l)
502527                         let $acc0 = nil
503528                         func $f0_1 ($a,$i) =                         if (($i >= $s))
504529                             then $a
505530                             else distribDestroyRewards($a, $l[$i])
506531 
507532                         func $f0_2 ($a,$i) =                         if (($i >= $s))
508533                             then $a
509534                             else throw("List size exceeds 50")
510535 
511536                         $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50)
512537                         }
513538                     if ((dist == dist))
514539                         then {
515540                             let pw = invoke(Address(nationsAddress), "setUserPower", [oldOwner, (currentPower - assetPower)], nil)
516541                             if ((pw == pw))
517542                                 then                                 match pw {
518543                                     case r: Int => 
519544 [DeleteEntry(assetId), DeleteEntry(getAssetOwnerKeyString(assetId))]
520545                                     case _ => 
521546                                         throw("Error setting user power")
522547                                 }
523548                                 else throw("Strict value is not equal to itself.")
524549                             }
525550                         else throw("Strict value is not equal to itself.")
526551                     }
527552             }
528553     }
529554 
530555 
531556 
532557 @Callable(i)
533558 func destroyAssetFromUser (assetId,qty) = {
534559     let chunks = getAssetTypeLevel(assetId)
535560     let strAssetType = chunks._1
536561     let level = chunks._2
537562     let k = getALKey(strAssetType, level)
538563     if (!(checkAssetOwner(toString(i.caller), assetId)))
539564         then throw("You don't own this asset")
540565         else {
541566             let assetCoins = tryGetInteger(assetId)
542567             let currentPower = nationsTryGetInteger((toString(i.caller) + "_Power"))
543568             let assetPower = confTryGetInteger((k + "_Power"))
544569             if (confTryGetBoolean((k + "_Aggregated")))
545570                 then {
546571                     let unitAssetCoins = ((confTryGetInteger((k + "_Cost")) * 20) / 100)
547572                     let qtyAsset = tryGetInteger((k + "_Qty"))
548573                     if ((0 > (qtyAsset - qty)))
549574                         then throw(("you don't have enough " + strAssetType))
550575                         else {
551576                             let pw = invoke(Address(nationsAddress), "setUserPower", [toString(i.caller), (currentPower - (assetPower * qty))], nil)
552577                             match pw {
553578                                 case r: Int => 
554579                                     let tr = invoke(Address(treasuryAddress), "adminTransfer", [toString(i.caller), (unitAssetCoins * qty)], nil)
555580                                     match tr {
556581                                         case t: Int => 
557582                                             if (((qtyAsset - qty) > 0))
558583                                                 then [IntegerEntry((k + "_Qty"), (qtyAsset - qty))]
559584                                                 else [DeleteEntry(assetId), DeleteEntry(getAssetOwnerKeyString(assetId))]
560585                                         case _ => 
561586                                             throw("Error transferring coins")
562587                                     }
563588                                 case _ => 
564589                                     throw("Error setting user power")
565590                             }
566591                             }
567592                     }
568593                 else {
569594                     let pw = invoke(Address(nationsAddress), "setUserPower", [toString(i.caller), (currentPower - assetPower)], nil)
570595                     match pw {
571596                         case r: Int => 
572597                             let tr = invoke(Address(treasuryAddress), "adminTransfer", [toString(i.caller), assetCoins], nil)
573598                             match tr {
574599                                 case t: Int => 
575600 [DeleteEntry(assetId), DeleteEntry(getAssetOwnerKeyString(assetId))]
576601                                 case _ => 
577602                                     throw("Error transferring coins")
578603                             }
579604                         case _ => 
580605                             throw("Error setting user power")
581606                     }
582607                     }
583608             }
584609     }
585610 
586611 
587612 
588613 @Callable(i)
589614 func setNationOwner (nationKey,newOwner) = if (checkAdmin(i.caller))
590615     then $Tuple2([StringEntry((nationKey + "_Owner"), newOwner)], true)
591616     else {
592617         let currentOwner = tryGetString((nationKey + "_Owner"))
593618         if ((currentOwner != toString(i.caller)))
594619             then throw("You are not the nation owner")
595620             else [StringEntry((nationKey + "_Owner"), newOwner)]
596621         }
597622 
598623 
599624 
600625 @Callable(i)
601626 func buyNationItem (assetId,NationKey) = {
602627     let chunks = getAssetTypeLevel(assetId)
603628     let strAssetType = chunks._1
604629     let level = chunks._2
605630     let k = getALKey(strAssetType, level)
606631     let n = nationsTryGetInteger(toString(i.caller))
607632     let nid = nationsTryGetInteger(NationKey)
608633     if ((n != nid))
609634         then throw("you can buy assets only from your nation")
610635         else if (!(checkAssetOwner(NationKey, assetId)))
611636             then throw("The asset does not belong to the nation")
612637             else if (!(isNationReservedAsset(strAssetType, level)))
613638                 then throw("this asset cannot be sold by the nation")
614639                 else {
615640                     let assetPrice = confTryGetInteger((getALKey(strAssetType, level) + "_SellPrice"))
616641                     let amountIn = value(i.payments[0].amount)
617642                     if ((assetPrice > amountIn))
618643                         then throw(("You provided less $heg than the needed cost for buying this " + strAssetType))
619644                         else if ((i.payments[0].assetId != shinywggid))
620645                             then throw("Only $HEG payments allowed")
621646                             else {
622647                                 let a = invoke(Address(treasuryAddress), "increaseNationWallet", [NationKey, amountIn], nil)
623648                                 match a {
624649                                     case b: Int => 
625-                                        (internalTrasnferOwnership(assetId, toString(i.caller)) :+ ScriptTransfer(Address(treasuryAddress), amountIn, shinywggid))
650+                                        (internalTrasnferOwnership(assetId, toString(i.caller), 1) :+ ScriptTransfer(Address(treasuryAddress), amountIn, shinywggid))
626651                                     case _ => 
627652                                         throw("Error transferring SHEG to nations wallet")
628653                                 }
629654                                 }
630655                     }
631656     }
632657 
633658 
634659 
635660 @Callable(i)
636661 func AddAssetFromMarkeplace (assetId,oldOwner,assetSheg) = if (!(checkAdmin(i.caller)))
637662     then throw("You are not allowed to perform this operation")
638663     else $Tuple2([StringEntry(getAssetOwnerKeyString(assetId), oldOwner), IntegerEntry(assetId, assetSheg)], oldOwner)
639664 
640665 
641666 
642667 @Callable(i)
643668 func TransferAssetToMarketplace (assetId,sellprice) = if (!(checkAssetOwner(toString(i.caller), assetId)))
644669     then throw("You are not the owner of this asset")
645670     else {
646671         let assetSheg = tryGetInteger(assetId)
647672         let tr = invoke(Address(marketplaceAddress), "putOnSale", [assetId, assetSheg, sellprice], nil)
648673         match tr {
649674             case t: Int => 
650675 [DeleteEntry(getAssetOwnerKeyString(assetId)), DeleteEntry(assetId)]
651676             case _ => 
652677                 throw("Error putting the item on the marketplace")
653678         }
654679         }
655680 
656681 
657682 
658683 @Callable(i)
659684 func DelKey (key) = if (!(checkAdmin(i.caller)))
660685     then throw("")
661686     else [DeleteEntry(key)]
662687 
663688 
664689 
665690 @Callable(i)
666691 func UpdKey (key,val) = if (!(checkAdmin(i.caller)))
667692     then throw("")
668693     else [StringEntry(key, val)]
669694 
670695 
github/deemru/w8io/169f3d6 
75.95 ms ◑