tx · vS3hxKT3r5Besttpz4Ayv3UebLpyiWyApJHt6jJ7CVX

3MrLv9SyejKpyQmQtxofNjJRbP7ofVzusrT:  -0.01000000 Waves

2022.03.15 11:49 [1964833] smart account 3MrLv9SyejKpyQmQtxofNjJRbP7ofVzusrT > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "vS3hxKT3r5Besttpz4Ayv3UebLpyiWyApJHt6jJ7CVX",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1647334170881,
    "version": 2,
    "chainId": 84,
    "sender": "3MrLv9SyejKpyQmQtxofNjJRbP7ofVzusrT",
    "senderPublicKey": "AksmzbhS8VH8fPkDs7eyh735mMBBgSqDpkumTQua7jqS",
    "proofs": [
        "4LhdWNid5ByLbRFFuS8H4ta9HgujD2JhZzcQL75HWnGENAeGzkn3SqUcKmyyXJPuoymxd9WyThPYy1wmzGx9AoCA"
    ],
    "script": "base64:AAIFAAAAAAAAAHMIAhIDCgEIEgMKAQgSABIECgIBBBIHCgUBAQEBBBIDCgEBEgASBwoFAQEBCAESBAoCAQESAwoBARIECgIICBIAEgMKAQgSBQoDAQEBEgQKAggBEgQKAgEBEgQKAggIEgsKCQgBAQIBAggEBBIGCgQICAEIAAAASQAAAAAGc2NhbGU4AAAAAAAF9eEAAAAAAAxzY2FsZThCaWdJbnQJAAE2AAAAAQAAAAAABfXhAAAAAAAHc2NhbGUxOAkAATYAAAABAA3gtrOnZAAAAAAAAAp6ZXJvQmlnSW50CQABNgAAAAEAAAAAAAAAAAAAAAAACW9uZUJpZ0ludAkAATYAAAABAAAAAAAAAAABAAAAAApzbGlwcGFnZTRECQABNgAAAAEJAABlAAAAAgUAAAAGc2NhbGU4CQAAaQAAAAIJAABoAAAAAgUAAAAGc2NhbGU4AAAAAAAAAAABBQAAAAZzY2FsZTgAAAAABUFtdWx0AgAAAAMxMDAAAAAABURjb252AgAAAAExAAAAAANTRVACAAAAAl9fAAAAAAVFTVBUWQIAAAAAAAAAAApQb29sQWN0aXZlAAAAAAAAAAABAAAAAApQb29sUHV0RGlzAAAAAAAAAAACAAAAAA5Qb29sTWF0Y2hlckRpcwAAAAAAAAAAAwAAAAAMUG9vbFNodXRkb3duAAAAAAAAAAAEAAAAAA5pZHhQb29sQWRkcmVzcwAAAAAAAAAAAQAAAAAJaWR4UG9vbFN0AAAAAAAAAAACAAAAAAlpZHhMUEFzSWQAAAAAAAAAAAMAAAAACWlkeEFtQXNJZAAAAAAAAAAABAAAAAAJaWR4UHJBc0lkAAAAAAAAAAAFAAAAAAtpZHhBbXRBc0RjbQAAAAAAAAAABgAAAAANaWR4UHJpY2VBc0RjbQAAAAAAAAAABwAAAAALaWR4SUFtdEFzSWQAAAAAAAAAAAgAAAAADWlkeElQcmljZUFzSWQAAAAAAAAAAAkAAAAAD2lkeEZhY3RTdGFrQ250cgAAAAAAAAAAAQAAAAAQaWR4RmFjdFNsaXBwQ250cgAAAAAAAAAABwAAAAARaWR4RmFjdEd3eFJld0NudHIAAAAAAAAAAAoBAAAAAnQxAAAAAgAAAAdvcmlnVmFsAAAADW9yaWdTY2FsZU11bHQJAAE8AAAAAwkAATYAAAABBQAAAAdvcmlnVmFsBQAAAAdzY2FsZTE4CQABNgAAAAEFAAAADW9yaWdTY2FsZU11bHQBAAAAAmYxAAAAAgAAAAN2YWwAAAAPcmVzdWx0U2NhbGVNdWx0CQABoAAAAAEJAAE8AAAAAwUAAAADdmFsCQABNgAAAAEFAAAAD3Jlc3VsdFNjYWxlTXVsdAUAAAAHc2NhbGUxOAEAAAACdHMAAAADAAAAA2FtdAAAAAhyZXNTY2FsZQAAAAhjdXJTY2FsZQkAAGsAAAADBQAAAANhbXQFAAAACHJlc1NjYWxlBQAAAAhjdXJTY2FsZQEAAAADYWJzAAAAAQAAAAN2YWwDCQABPwAAAAIFAAAACnplcm9CaWdJbnQFAAAAA3ZhbAkAAT4AAAABBQAAAAN2YWwFAAAAA3ZhbAEAAAACZmMAAAAAAgAAABMlc19fZmFjdG9yeUNvbnRyYWN0AQAAAANtcGsAAAAAAgAAABQlc19fbWFuYWdlclB1YmxpY0tleQEAAAAEcG1wawAAAAACAAAAGyVzX19wZW5kaW5nTWFuYWdlclB1YmxpY0tleQEAAAACcGwAAAAAAgAAABElcyVzX19wcmljZV9fbGFzdAEAAAACcGgAAAACAAAAAWgAAAABdAkABLkAAAACCQAETAAAAAICAAAAGCVzJXMlZCVkX19wcmljZV9faGlzdG9yeQkABEwAAAACCQABpAAAAAEFAAAAAWgJAARMAAAAAgkAAaQAAAABBQAAAAF0BQAAAANuaWwFAAAAA1NFUAEAAAADcGF1AAAAAgAAAAJ1YQAAAAR0eElkCQABLAAAAAIJAAEsAAAAAgkAASwAAAACAgAAAAslcyVzJXNfX1BfXwUAAAACdWECAAAAAl9fBQAAAAR0eElkAQAAAANnYXUAAAACAAAAAnVhAAAABHR4SWQJAAEsAAAAAgkAASwAAAACCQABLAAAAAICAAAACyVzJXMlc19fR19fBQAAAAJ1YQIAAAACX18FAAAABHR4SWQBAAAAAmFhAAAAAAIAAAAPJXNfX2Ftb3VudEFzc2V0AQAAAAJwYQAAAAACAAAADiVzX19wcmljZUFzc2V0AQAAAANhbXAAAAAAAgAAAAclc19fYW1wAQAAAANhZGEAAAAAAgAAAA0lc19fYWRkb25BZGRyAQAAAARmY2ZnAAAAAAIAAAARJXNfX2ZhY3RvcnlDb25maWcBAAAABG10cGsAAAAAAgAAABglcyVzX19tYXRjaGVyX19wdWJsaWNLZXkBAAAAAnBjAAAAAgAAAAZpQW10QXMAAAAFaVByQXMJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgIAAAAIJWQlZCVzX18FAAAABmlBbXRBcwIAAAACX18FAAAABWlQckFzAgAAAAhfX2NvbmZpZwEAAAADbWJhAAAAAQAAAAViQVN0cgkAASwAAAACAgAAACglcyVzJXNfX21hcHBpbmdzX19iYXNlQXNzZXQyaW50ZXJuYWxJZF9fBQAAAAViQVN0cgEAAAADYXBzAAAAAAIAAAAMJXNfX3NodXRkb3duAQAAAAN0b2UAAAADAAAAA29yVgAAAAZzZW5kclYAAAAGbWF0Y2hWCQAAAgAAAAEJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACAgAAABFGYWlsZWQ6IG9yZFZhbGlkPQkAAaUAAAABBQAAAANvclYCAAAACyBzbmRyVmFsaWQ9CQABpQAAAAEFAAAABnNlbmRyVgIAAAAMIG10Y2hyVmFsaWQ9CQABpQAAAAEFAAAABm1hdGNoVgEAAAADc3RyAAAAAQAAAAN2YWwEAAAAByRtYXRjaDAFAAAAA3ZhbAMJAAABAAAAAgUAAAAHJG1hdGNoMAIAAAAGU3RyaW5nBAAAAAZ2YWxTdHIFAAAAByRtYXRjaDAFAAAABnZhbFN0cgkAAAIAAAABAgAAABNmYWlsIGNhc3QgdG8gU3RyaW5nAQAAAARzdHJmAAAAAgAAAARhZGRyAAAAA2tleQkBAAAAE3ZhbHVlT3JFcnJvck1lc3NhZ2UAAAACCQAEHQAAAAIFAAAABGFkZHIFAAAAA2tleQkABLkAAAACCQAETAAAAAICAAAACm1hbmRhdG9yeSAJAARMAAAAAgkABCUAAAABBQAAAARhZGRyCQAETAAAAAICAAAAAS4JAARMAAAAAgUAAAADa2V5CQAETAAAAAICAAAADCBub3QgZGVmaW5lZAUAAAADbmlsAgAAAAABAAAABGludGYAAAACAAAABGFkZHIAAAADa2V5CQEAAAATdmFsdWVPckVycm9yTWVzc2FnZQAAAAIJAAQaAAAAAgUAAAAEYWRkcgUAAAADa2V5CQAEuQAAAAIJAARMAAAAAgIAAAAKbWFuZGF0b3J5IAkABEwAAAACCQAEJQAAAAEFAAAABGFkZHIJAARMAAAAAgIAAAABLgkABEwAAAACBQAAAANrZXkJAARMAAAAAgIAAAAMIG5vdCBkZWZpbmVkBQAAAANuaWwCAAAAAAAAAAADZmNhCQEAAAARQGV4dHJOYXRpdmUoMTA2MikAAAABCQEAAAAEc3RyZgAAAAIFAAAABHRoaXMJAQAAAAJmYwAAAAAAAAAAAUEJAQAAAARzdHJmAAAAAgUAAAAEdGhpcwkBAAAAA2FtcAAAAAABAAAAA2lncwAAAAAJAQAAAAt2YWx1ZU9yRWxzZQAAAAIJAAQbAAAAAgUAAAADZmNhCQEAAAADYXBzAAAAAAcBAAAAAm1wAAAAAAkAAlkAAAABCQEAAAAEc3RyZgAAAAIFAAAAA2ZjYQkBAAAABG10cGsAAAAAAQAAAANncGMAAAAABAAAAAVhbXRBcwkBAAAABHN0cmYAAAACBQAAAAR0aGlzCQEAAAACYWEAAAAABAAAAAdwcmljZUFzCQEAAAAEc3RyZgAAAAIFAAAABHRoaXMJAQAAAAJwYQAAAAAEAAAACGlQcmljZUFzCQEAAAAEaW50ZgAAAAIFAAAAA2ZjYQkBAAAAA21iYQAAAAEFAAAAB3ByaWNlQXMEAAAABmlBbXRBcwkBAAAABGludGYAAAACBQAAAANmY2EJAQAAAANtYmEAAAABBQAAAAVhbXRBcwkABLUAAAACCQEAAAAEc3RyZgAAAAIFAAAAA2ZjYQkBAAAAAnBjAAAAAgkAAaQAAAABBQAAAAZpQW10QXMJAAGkAAAAAQUAAAAIaVByaWNlQXMFAAAAA1NFUAEAAAADZ2ZjAAAAAAkABLUAAAACCQEAAAAEc3RyZgAAAAIFAAAAA2ZjYQkBAAAABGZjZmcAAAAABQAAAANTRVABAAAAEWRhdGFQdXRBY3Rpb25JbmZvAAAACgAAAA1pbkFtdEFzc2V0QW10AAAAD2luUHJpY2VBc3NldEFtdAAAAAhvdXRMcEFtdAAAAAVwcmljZQAAAApzbGlwQnlVc2VyAAAADHNsaXBwYWdlUmVhbAAAAAh0eEhlaWdodAAAAAt0eFRpbWVzdGFtcAAAAAxzbGlwYWdlQW1BbXQAAAAMc2xpcGFnZVByQW10CQAEuQAAAAIJAARMAAAAAgIAAAAUJWQlZCVkJWQlZCVkJWQlZCVkJWQJAARMAAAAAgkAAaQAAAABBQAAAA1pbkFtdEFzc2V0QW10CQAETAAAAAIJAAGkAAAAAQUAAAAPaW5QcmljZUFzc2V0QW10CQAETAAAAAIJAAGkAAAAAQUAAAAIb3V0THBBbXQJAARMAAAAAgkAAaQAAAABBQAAAAVwcmljZQkABEwAAAACCQABpAAAAAEFAAAACnNsaXBCeVVzZXIJAARMAAAAAgkAAaQAAAABBQAAAAxzbGlwcGFnZVJlYWwJAARMAAAAAgkAAaQAAAABBQAAAAh0eEhlaWdodAkABEwAAAACCQABpAAAAAEFAAAAC3R4VGltZXN0YW1wCQAETAAAAAIJAAGkAAAAAQUAAAAMc2xpcGFnZUFtQW10CQAETAAAAAIJAAGkAAAAAQUAAAAMc2xpcGFnZVByQW10BQAAAANuaWwFAAAAA1NFUAEAAAARZGF0YUdldEFjdGlvbkluZm8AAAAGAAAADm91dEFtdEFzc2V0QW10AAAAEG91dFByaWNlQXNzZXRBbXQAAAAHaW5McEFtdAAAAAVwcmljZQAAAAh0eEhlaWdodAAAAAt0eFRpbWVzdGFtcAkABLkAAAACCQAETAAAAAICAAAADCVkJWQlZCVkJWQlZAkABEwAAAACCQABpAAAAAEFAAAADm91dEFtdEFzc2V0QW10CQAETAAAAAIJAAGkAAAAAQUAAAAQb3V0UHJpY2VBc3NldEFtdAkABEwAAAACCQABpAAAAAEFAAAAB2luTHBBbXQJAARMAAAAAgkAAaQAAAABBQAAAAVwcmljZQkABEwAAAACCQABpAAAAAEFAAAACHR4SGVpZ2h0CQAETAAAAAIJAAGkAAAAAQUAAAALdHhUaW1lc3RhbXAFAAAAA25pbAUAAAADU0VQAQAAAA1nZXRBY2NCYWxhbmNlAAAAAQAAAAdhc3NldElkAwkAAAAAAAACBQAAAAdhc3NldElkAgAAAAVXQVZFUwgJAAPvAAAAAQUAAAAEdGhpcwAAAAlhdmFpbGFibGUJAAPwAAAAAgUAAAAEdGhpcwkAAlkAAAABBQAAAAdhc3NldElkAQAAAARjcGJpAAAAAgAAAAhwckFtdFgxOAAAAAhhbUFtdFgxOAkAATwAAAADBQAAAAhwckFtdFgxOAUAAAAHc2NhbGUxOAUAAAAIYW1BbXRYMTgBAAAAA3ZhZAAAAAMAAAACQTEAAAACQTIAAAAIc2xpcHBhZ2UEAAAABGRpZmYJAAE8AAAAAwkAATgAAAACBQAAAAJBMQUAAAACQTIFAAAADHNjYWxlOEJpZ0ludAUAAAACQTIEAAAABHBhc3MJAAE/AAAAAgkAATgAAAACBQAAAAhzbGlwcGFnZQkBAAAAA2FicwAAAAEFAAAABGRpZmYFAAAACnplcm9CaWdJbnQDCQEAAAABIQAAAAEFAAAABHBhc3MJAAACAAAAAQkAASwAAAACAgAAAApCaWcgc2xwZzogCQABpgAAAAEFAAAABGRpZmYJAAUUAAAAAgUAAAAEcGFzcwkAAZkAAAABCQAETAAAAAIFAAAAAkExCQAETAAAAAIFAAAAAkEyBQAAAANuaWwBAAAAAnZkAAAAAwAAAAJEMQAAAAJEMAAAAARzbHBnBAAAAARkaWZmCQABPAAAAAMFAAAAAkQwBQAAAAxzY2FsZThCaWdJbnQFAAAAAkQxBAAAAARmYWlsCQABPwAAAAIFAAAABHNscGcFAAAABGRpZmYDAwUAAAAEZmFpbAYJAAE/AAAAAgUAAAACRDAFAAAAAkQxCQAAAgAAAAEJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAGmAAAAAQUAAAACRDACAAAAASAJAAGmAAAAAQUAAAACRDECAAAAASAJAAGmAAAAAQUAAAAEZGlmZgIAAAABIAkAAaYAAAABBQAAAARzbHBnBQAAAARmYWlsAQAAAANwY3AAAAAEAAAACmFtQXNzZXREY20AAAAKcHJBc3NldERjbQAAAAVhbUFtdAAAAAVwckFtdAQAAAALYW10QXNBbXRYMTgJAQAAAAJ0MQAAAAIFAAAABWFtQW10BQAAAAphbUFzc2V0RGNtBAAAAApwckFzQW10WDE4CQEAAAACdDEAAAACBQAAAAVwckFtdAUAAAAKcHJBc3NldERjbQkBAAAABGNwYmkAAAACBQAAAApwckFzQW10WDE4BQAAAAthbXRBc0FtdFgxOAEAAAAKY2FsY1ByaWNlcwAAAAMAAAAFYW1BbXQAAAAFcHJBbXQAAAAFbHBBbXQEAAAAA2NmZwkBAAAAA2dwYwAAAAAEAAAACGFtdEFzRGNtCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAADY2ZnBQAAAAtpZHhBbXRBc0RjbQQAAAAHcHJBc0RjbQkBAAAADXBhcnNlSW50VmFsdWUAAAABCQABkQAAAAIFAAAAA2NmZwUAAAANaWR4UHJpY2VBc0RjbQQAAAAIcHJpY2VYMTgJAQAAAANwY3AAAAAEBQAAAAhhbXRBc0RjbQUAAAAHcHJBc0RjbQUAAAAFYW1BbXQFAAAABXByQW10BAAAAAhhbUFtdFgxOAkBAAAAAnQxAAAAAgUAAAAFYW1BbXQFAAAACGFtdEFzRGNtBAAAAAhwckFtdFgxOAkBAAAAAnQxAAAAAgUAAAAFcHJBbXQFAAAAB3ByQXNEY20EAAAACGxwQW10WDE4CQEAAAACdDEAAAACBQAAAAVscEFtdAUAAAAGc2NhbGU4BAAAAA1scFBySW5BbUFzWDE4CQEAAAAEY3BiaQAAAAIFAAAACGFtQW10WDE4BQAAAAhscEFtdFgxOAQAAAANbHBQckluUHJBc1gxOAkBAAAABGNwYmkAAAACBQAAAAhwckFtdFgxOAUAAAAIbHBBbXRYMTgJAARMAAAAAgUAAAAIcHJpY2VYMTgJAARMAAAAAgUAAAANbHBQckluQW1Bc1gxOAkABEwAAAACBQAAAA1scFBySW5QckFzWDE4BQAAAANuaWwBAAAAD2NhbGN1bGF0ZVByaWNlcwAAAAMAAAAFYW1BbXQAAAAFcHJBbXQAAAAFbHBBbXQEAAAAAXAJAQAAAApjYWxjUHJpY2VzAAAAAwUAAAAFYW1BbXQFAAAABXByQW10BQAAAAVscEFtdAkABEwAAAACCQEAAAACZjEAAAACCQABkQAAAAIFAAAAAXAAAAAAAAAAAAAFAAAABnNjYWxlOAkABEwAAAACCQEAAAACZjEAAAACCQABkQAAAAIFAAAAAXAAAAAAAAAAAAEFAAAABnNjYWxlOAkABEwAAAACCQEAAAACZjEAAAACCQABkQAAAAIFAAAAAXAAAAAAAAAAAAIFAAAABnNjYWxlOAUAAAADbmlsAQAAAANlZ28AAAAEAAAABnR4SWQ1OAAAAApwbXRBc3NldElkAAAACHBtdExwQW10AAAAC3VzZXJBZGRyZXNzBAAAAANjZmcJAQAAAANncGMAAAAABAAAAARscElkCQABkQAAAAIFAAAAA2NmZwUAAAAJaWR4TFBBc0lkBAAAAARhbUlkCQABkQAAAAIFAAAAA2NmZwUAAAAJaWR4QW1Bc0lkBAAAAARwcklkCQABkQAAAAIFAAAAA2NmZwUAAAAJaWR4UHJBc0lkBAAAAAVhbURjbQkBAAAADXBhcnNlSW50VmFsdWUAAAABCQABkQAAAAIFAAAAA2NmZwUAAAALaWR4QW10QXNEY20EAAAABXByRGNtCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAADY2ZnBQAAAA1pZHhQcmljZUFzRGNtBAAAAANzdHMJAAGRAAAAAgUAAAADY2ZnBQAAAAlpZHhQb29sU3QEAAAAB2xwRW1pc3MICQEAAAATdmFsdWVPckVycm9yTWVzc2FnZQAAAAIJAAPsAAAAAQkAAlkAAAABBQAAAARscElkAgAAAAtXcm9uZyBMUCBpZAAAAAhxdWFudGl0eQMJAQAAAAIhPQAAAAIFAAAABGxwSWQFAAAACnBtdEFzc2V0SWQJAAACAAAAAQIAAAAPV3JvbmcgcG10IGFzc2V0BAAAAAlhbUJhbGFuY2UJAQAAAA1nZXRBY2NCYWxhbmNlAAAAAQUAAAAEYW1JZAQAAAAMYW1CYWxhbmNlWDE4CQEAAAACdDEAAAACBQAAAAlhbUJhbGFuY2UFAAAABWFtRGNtBAAAAAlwckJhbGFuY2UJAQAAAA1nZXRBY2NCYWxhbmNlAAAAAQUAAAAEcHJJZAQAAAAMcHJCYWxhbmNlWDE4CQEAAAACdDEAAAACBQAAAAlwckJhbGFuY2UFAAAABXByRGNtBAAAAAtjdXJQcmljZVgxOAkBAAAABGNwYmkAAAACBQAAAAxwckJhbGFuY2VYMTgFAAAADGFtQmFsYW5jZVgxOAQAAAAIY3VyUHJpY2UJAQAAAAJmMQAAAAIFAAAAC2N1clByaWNlWDE4BQAAAAZzY2FsZTgEAAAAC3BtdExwQW10WDE4CQEAAAACdDEAAAACBQAAAAhwbXRMcEFtdAUAAAAGc2NhbGU4BAAAAApscEVtaXNzWDE4CQEAAAACdDEAAAACBQAAAAdscEVtaXNzBQAAAAZzY2FsZTgEAAAAC291dEFtQW10WDE4CQABPAAAAAMFAAAADGFtQmFsYW5jZVgxOAUAAAALcG10THBBbXRYMTgFAAAACmxwRW1pc3NYMTgEAAAAC291dFByQW10WDE4CQABPAAAAAMFAAAADHByQmFsYW5jZVgxOAUAAAALcG10THBBbXRYMTgFAAAACmxwRW1pc3NYMTgEAAAACG91dEFtQW10CQEAAAACZjEAAAACBQAAAAtvdXRBbUFtdFgxOAUAAAAFYW1EY20EAAAACG91dFByQW10CQEAAAACZjEAAAACBQAAAAtvdXRQckFtdFgxOAUAAAAFcHJEY20EAAAABXN0YXRlAwkAAAAAAAACBQAAAAZ0eElkNTgCAAAAAAUAAAADbmlsCQAETAAAAAIJAQAAAA5TY3JpcHRUcmFuc2ZlcgAAAAMFAAAAC3VzZXJBZGRyZXNzBQAAAAhvdXRBbUFtdAMJAAAAAAAAAgUAAAAEYW1JZAIAAAAFV0FWRVMFAAAABHVuaXQJAAJZAAAAAQUAAAAEYW1JZAkABEwAAAACCQEAAAAOU2NyaXB0VHJhbnNmZXIAAAADBQAAAAt1c2VyQWRkcmVzcwUAAAAIb3V0UHJBbXQDCQAAAAAAAAIFAAAABHBySWQCAAAABVdBVkVTBQAAAAR1bml0CQACWQAAAAEFAAAABHBySWQJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAAA2dhdQAAAAIJAAQlAAAAAQUAAAALdXNlckFkZHJlc3MFAAAABnR4SWQ1OAkBAAAAEWRhdGFHZXRBY3Rpb25JbmZvAAAABgUAAAAIb3V0QW1BbXQFAAAACG91dFByQW10BQAAAAhwbXRMcEFtdAUAAAAIY3VyUHJpY2UFAAAABmhlaWdodAgFAAAACWxhc3RCbG9jawAAAAl0aW1lc3RhbXAJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIJAQAAAAJwbAAAAAAFAAAACGN1clByaWNlCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACCQEAAAACcGgAAAACBQAAAAZoZWlnaHQIBQAAAAlsYXN0QmxvY2sAAAAJdGltZXN0YW1wBQAAAAhjdXJQcmljZQUAAAADbmlsCQAFHAAAAAoFAAAACG91dEFtQW10BQAAAAhvdXRQckFtdAUAAAAEYW1JZAUAAAAEcHJJZAUAAAAJYW1CYWxhbmNlBQAAAAlwckJhbGFuY2UFAAAAB2xwRW1pc3MFAAAAC2N1clByaWNlWDE4BQAAAANzdHMFAAAABXN0YXRlAQAAAANlcG8AAAAMAAAABnR4SWQ1OAAAAAhzbGlwcGFnZQAAAAdpbkFtQW10AAAABmluQW1JZAAAAAdpblByQW10AAAABmluUHJJZAAAAAt1c2VyQWRkcmVzcwAAAAZpc0V2YWwAAAAGZW1pdExwAAAACmlzT25lQXNzZXQAAAAGcG10QW10AAAABXBtdElkBAAAAANjZmcJAQAAAANncGMAAAAABAAAAARscElkCQACWQAAAAEJAAGRAAAAAgUAAAADY2ZnBQAAAAlpZHhMUEFzSWQEAAAAB2FtSWRTdHIJAAGRAAAAAgUAAAADY2ZnBQAAAAlpZHhBbUFzSWQEAAAAB3BySWRTdHIJAAGRAAAAAgUAAAADY2ZnBQAAAAlpZHhQckFzSWQEAAAACWluQW1JZFN0cgkAAZEAAAACBQAAAANjZmcFAAAAC2lkeElBbXRBc0lkBAAAAAlpblBySWRTdHIJAAGRAAAAAgUAAAADY2ZnBQAAAA1pZHhJUHJpY2VBc0lkBAAAAAZhbXREY20JAQAAAA1wYXJzZUludFZhbHVlAAAAAQkAAZEAAAACBQAAAANjZmcFAAAAC2lkeEFtdEFzRGNtBAAAAAhwcmljZURjbQkBAAAADXBhcnNlSW50VmFsdWUAAAABCQABkQAAAAIFAAAAA2NmZwUAAAANaWR4UHJpY2VBc0RjbQQAAAADc3RzCQABkQAAAAIFAAAAA2NmZwUAAAAJaWR4UG9vbFN0BAAAAARscEVtCAkBAAAAE3ZhbHVlT3JFcnJvck1lc3NhZ2UAAAACCQAD7AAAAAEFAAAABGxwSWQCAAAACFdyIGxwIGFzAAAACHF1YW50aXR5BAAAAAlhbUJhbGFuY2UDBQAAAAZpc0V2YWwJAQAAAA1nZXRBY2NCYWxhbmNlAAAAAQUAAAAHYW1JZFN0cgMDBQAAAAppc09uZUFzc2V0CQAAAAAAAAIFAAAABXBtdElkBQAAAAdhbUlkU3RyBwkAAGUAAAACCQEAAAANZ2V0QWNjQmFsYW5jZQAAAAEFAAAAB2FtSWRTdHIFAAAABnBtdEFtdAMFAAAACmlzT25lQXNzZXQJAQAAAA1nZXRBY2NCYWxhbmNlAAAAAQUAAAAHYW1JZFN0cgkAAGUAAAACCQEAAAANZ2V0QWNjQmFsYW5jZQAAAAEFAAAAB2FtSWRTdHIFAAAAB2luQW1BbXQEAAAACXByQmFsYW5jZQMFAAAABmlzRXZhbAkBAAAADWdldEFjY0JhbGFuY2UAAAABBQAAAAdwcklkU3RyAwMFAAAACmlzT25lQXNzZXQJAAAAAAAAAgUAAAAFcG10SWQFAAAAB3BySWRTdHIHCQAAZQAAAAIJAQAAAA1nZXRBY2NCYWxhbmNlAAAAAQUAAAAHcHJJZFN0cgUAAAAGcG10QW10AwUAAAAKaXNPbmVBc3NldAkBAAAADWdldEFjY0JhbGFuY2UAAAABBQAAAAdwcklkU3RyCQAAZQAAAAIJAQAAAA1nZXRBY2NCYWxhbmNlAAAAAQUAAAAHcHJJZFN0cgUAAAAHaW5QckFtdAQAAAAPaW5BbUFzc2V0QW10WDE4CQEAAAACdDEAAAACBQAAAAdpbkFtQW10BQAAAAZhbXREY20EAAAAD2luUHJBc3NldEFtdFgxOAkBAAAAAnQxAAAAAgUAAAAHaW5QckFtdAUAAAAIcHJpY2VEY20EAAAADHVzZXJQcmljZVgxOAkBAAAABGNwYmkAAAACBQAAAA9pblByQXNzZXRBbXRYMTgFAAAAD2luQW1Bc3NldEFtdFgxOAQAAAAMYW1CYWxhbmNlWDE4CQEAAAACdDEAAAACBQAAAAlhbUJhbGFuY2UFAAAABmFtdERjbQQAAAAMcHJCYWxhbmNlWDE4CQEAAAACdDEAAAACBQAAAAlwckJhbGFuY2UFAAAACHByaWNlRGNtBAAAAAFyAwkAAAAAAAACBQAAAARscEVtAAAAAAAAAAAABAAAAAtjdXJQcmljZVgxOAUAAAAKemVyb0JpZ0ludAQAAAALc2xpcHBhZ2VYMTgFAAAACnplcm9CaWdJbnQEAAAACGxwQW10WDE4CQAAdgAAAAYJAAE5AAAAAgUAAAAPaW5BbUFzc2V0QW10WDE4BQAAAA9pblByQXNzZXRBbXRYMTgAAAAAAAAAAAAJAAE2AAAAAQAAAAAAAAAABQAAAAAAAAAAAQAAAAAAAAAAAAUAAAAERE9XTgkABRcAAAAFCQEAAAACZjEAAAACBQAAAAhscEFtdFgxOAUAAAAGc2NhbGU4CQEAAAACZjEAAAACBQAAAA9pbkFtQXNzZXRBbXRYMTgFAAAABmFtdERjbQkBAAAAAmYxAAAAAgUAAAAPaW5QckFzc2V0QW10WDE4BQAAAAhwcmljZURjbQkBAAAABGNwYmkAAAACCQABNwAAAAIFAAAADHByQmFsYW5jZVgxOAUAAAAPaW5QckFzc2V0QW10WDE4CQABNwAAAAIFAAAADGFtQmFsYW5jZVgxOAUAAAAPaW5BbUFzc2V0QW10WDE4BQAAAAtzbGlwcGFnZVgxOAQAAAALY3VyUHJpY2VYMTgJAQAAAARjcGJpAAAAAgUAAAAMcHJCYWxhbmNlWDE4BQAAAAxhbUJhbGFuY2VYMTgEAAAAD3NsaXBwYWdlUmVhbFgxOAkAATwAAAADCQEAAAADYWJzAAAAAQkAATgAAAACBQAAAAtjdXJQcmljZVgxOAUAAAAMdXNlclByaWNlWDE4BQAAAAdzY2FsZTE4BQAAAAtjdXJQcmljZVgxOAQAAAALc2xpcHBhZ2VYMTgJAQAAAAJ0MQAAAAIFAAAACHNsaXBwYWdlBQAAAAZzY2FsZTgDAwkBAAAAAiE9AAAAAgUAAAALY3VyUHJpY2VYMTgFAAAACnplcm9CaWdJbnQJAAE/AAAAAgUAAAAPc2xpcHBhZ2VSZWFsWDE4BQAAAAtzbGlwcGFnZVgxOAcJAAACAAAAAQkAASwAAAACCQABLAAAAAIJAAEsAAAAAgIAAAAPUHJpY2Ugc2xpcHBhZ2UgCQABpgAAAAEFAAAAD3NsaXBwYWdlUmVhbFgxOAIAAAADID4gCQABpgAAAAEFAAAAC3NsaXBwYWdlWDE4BAAAAA1scEVtaXNzaW9uWDE4CQEAAAACdDEAAAACBQAAAARscEVtBQAAAAZzY2FsZTgEAAAACnByVmlhQW1YMTgJAAE8AAAAAwUAAAAPaW5BbUFzc2V0QW10WDE4BQAAAAtjdXJQcmljZVgxOAUAAAAHc2NhbGUxOAQAAAAKYW1WaWFQclgxOAkAATwAAAADBQAAAA9pblByQXNzZXRBbXRYMTgFAAAAB3NjYWxlMTgFAAAAC2N1clByaWNlWDE4BAAAAAxleHBlY3RlZEFtdHMDCQABPwAAAAIFAAAACnByVmlhQW1YMTgFAAAAD2luUHJBc3NldEFtdFgxOAkABRQAAAACBQAAAAphbVZpYVByWDE4BQAAAA9pblByQXNzZXRBbXRYMTgJAAUUAAAAAgUAAAAPaW5BbUFzc2V0QW10WDE4BQAAAApwclZpYUFtWDE4BAAAABFleHBBbXRBc3NldEFtdFgxOAgFAAAADGV4cGVjdGVkQW10cwAAAAJfMQQAAAATZXhwUHJpY2VBc3NldEFtdFgxOAgFAAAADGV4cGVjdGVkQW10cwAAAAJfMgQAAAAIbHBBbXRYMTgJAAE8AAAAAwUAAAANbHBFbWlzc2lvblgxOAUAAAATZXhwUHJpY2VBc3NldEFtdFgxOAUAAAAMcHJCYWxhbmNlWDE4CQAFFwAAAAUJAQAAAAJmMQAAAAIFAAAACGxwQW10WDE4BQAAAAZzY2FsZTgJAQAAAAJmMQAAAAIFAAAAEWV4cEFtdEFzc2V0QW10WDE4BQAAAAZhbXREY20JAQAAAAJmMQAAAAIFAAAAE2V4cFByaWNlQXNzZXRBbXRYMTgFAAAACHByaWNlRGNtBQAAAAtjdXJQcmljZVgxOAUAAAALc2xpcHBhZ2VYMTgEAAAACWNhbGNMcEFtdAgFAAAAAXIAAAACXzEEAAAADmNhbGNBbUFzc2V0UG10CAUAAAABcgAAAAJfMgQAAAAOY2FsY1ByQXNzZXRQbXQIBQAAAAFyAAAAAl8zBAAAAAhjdXJQcmljZQkBAAAAAmYxAAAAAggFAAAAAXIAAAACXzQFAAAABnNjYWxlOAQAAAAMc2xpcHBhZ2VDYWxjCQEAAAACZjEAAAACCAUAAAABcgAAAAJfNQUAAAAGc2NhbGU4AwkAAGcAAAACAAAAAAAAAAAABQAAAAljYWxjTHBBbXQJAAACAAAAAQIAAAAHTFAgPD0gMAQAAAAJZW1pdExwQW10AwkBAAAAASEAAAABBQAAAAZlbWl0THAAAAAAAAAAAAAFAAAACWNhbGNMcEFtdAQAAAAGYW1EaWZmCQAAZQAAAAIFAAAAB2luQW1BbXQFAAAADmNhbGNBbUFzc2V0UG10BAAAAAZwckRpZmYJAABlAAAAAgUAAAAHaW5QckFtdAUAAAAOY2FsY1ByQXNzZXRQbXQEAAAADSR0MDE1Mjk2MTU2NDEDAwUAAAAKaXNPbmVBc3NldAkAAAAAAAACBQAAAAVwbXRJZAUAAAAHYW1JZFN0cgcJAAUUAAAAAgUAAAAGcG10QW10AAAAAAAAAAAAAwMFAAAACmlzT25lQXNzZXQJAAAAAAAAAgUAAAAFcG10SWQFAAAAB3BySWRTdHIHCQAFFAAAAAIAAAAAAAAAAAAFAAAABnBtdEFtdAkABRQAAAACBQAAAA5jYWxjQW1Bc3NldFBtdAUAAAAOY2FsY1ByQXNzZXRQbXQEAAAACndyaXRlQW1BbXQIBQAAAA0kdDAxNTI5NjE1NjQxAAAAAl8xBAAAAAp3cml0ZVByQW10CAUAAAANJHQwMTUyOTYxNTY0MQAAAAJfMgQAAAALY29tbW9uU3RhdGUJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIJAQAAAAJwbAAAAAAFAAAACGN1clByaWNlCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACCQEAAAACcGgAAAACBQAAAAZoZWlnaHQIBQAAAAlsYXN0QmxvY2sAAAAJdGltZXN0YW1wBQAAAAhjdXJQcmljZQkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAADcGF1AAAAAgUAAAALdXNlckFkZHJlc3MFAAAABnR4SWQ1OAkBAAAAEWRhdGFQdXRBY3Rpb25JbmZvAAAACgUAAAAKd3JpdGVBbUFtdAUAAAAKd3JpdGVQckFtdAUAAAAJZW1pdExwQW10BQAAAAhjdXJQcmljZQUAAAAIc2xpcHBhZ2UFAAAADHNsaXBwYWdlQ2FsYwUAAAAGaGVpZ2h0CAUAAAAJbGFzdEJsb2NrAAAACXRpbWVzdGFtcAUAAAAGYW1EaWZmBQAAAAZwckRpZmYFAAAAA25pbAkABR8AAAANBQAAAAljYWxjTHBBbXQFAAAACWVtaXRMcEFtdAUAAAAIY3VyUHJpY2UFAAAACWFtQmFsYW5jZQUAAAAJcHJCYWxhbmNlBQAAAARscEVtBQAAAARscElkBQAAAANzdHMFAAAAC2NvbW1vblN0YXRlBQAAAAZhbURpZmYFAAAABnByRGlmZgUAAAAGaW5BbUlkBQAAAAZpblBySWQBAAAAA21vYQAAAAEAAAAFb3JkZXIEAAAAA2NmZwkBAAAAA2dwYwAAAAAEAAAAB2FtdEFzSWQJAAGRAAAAAgUAAAADY2ZnBQAAAAlpZHhBbUFzSWQEAAAABnByQXNJZAkAAZEAAAACBQAAAANjZmcFAAAACWlkeFByQXNJZAQAAAADc3RzCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAADY2ZnBQAAAAlpZHhQb29sU3QEAAAACGFtdEFzRGNtCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAADY2ZnBQAAAAtpZHhBbXRBc0RjbQQAAAAHcHJBc0RjbQkBAAAADXBhcnNlSW50VmFsdWUAAAABCQABkQAAAAIFAAAAA2NmZwUAAAANaWR4UHJpY2VBc0RjbQQAAAAPYWNjQW10QXNCYWxhbmNlCQEAAAANZ2V0QWNjQmFsYW5jZQAAAAEFAAAAB2FtdEFzSWQEAAAADmFjY1ByQXNCYWxhbmNlCQEAAAANZ2V0QWNjQmFsYW5jZQAAAAEFAAAABnByQXNJZAQAAAALY3VyUHJpY2VYMTgDCQAAAAAAAAIIBQAAAAVvcmRlcgAAAAlvcmRlclR5cGUFAAAAA0J1eQkBAAAAA3BjcAAAAAQFAAAACGFtdEFzRGNtBQAAAAdwckFzRGNtCQAAZAAAAAIFAAAAD2FjY0FtdEFzQmFsYW5jZQgFAAAABW9yZGVyAAAABmFtb3VudAUAAAAOYWNjUHJBc0JhbGFuY2UJAQAAAANwY3AAAAAEBQAAAAhhbXRBc0RjbQUAAAAHcHJBc0RjbQkAAGUAAAACBQAAAA9hY2NBbXRBc0JhbGFuY2UIBQAAAAVvcmRlcgAAAAZhbW91bnQFAAAADmFjY1ByQXNCYWxhbmNlBAAAAAhjdXJQcmljZQkBAAAAAmYxAAAAAgUAAAALY3VyUHJpY2VYMTgFAAAABnNjYWxlOAMDAwkBAAAAA2lncwAAAAAGCQAAAAAAAAIFAAAAA3N0cwUAAAAOUG9vbE1hdGNoZXJEaXMGCQAAAAAAAAIFAAAAA3N0cwUAAAAMUG9vbFNodXRkb3duCQAAAgAAAAECAAAADUFkbWluIGJsb2NrZWQEAAAACm9yQW10QXNzZXQICAUAAAAFb3JkZXIAAAAJYXNzZXRQYWlyAAAAC2Ftb3VudEFzc2V0BAAAAApvckFtdEFzU3RyAwkAAAAAAAACBQAAAApvckFtdEFzc2V0BQAAAAR1bml0AgAAAAVXQVZFUwkAAlgAAAABCQEAAAAFdmFsdWUAAAABBQAAAApvckFtdEFzc2V0BAAAAAlvclByQXNzZXQICAUAAAAFb3JkZXIAAAAJYXNzZXRQYWlyAAAACnByaWNlQXNzZXQEAAAACW9yUHJBc1N0cgMJAAAAAAAAAgUAAAAJb3JQckFzc2V0BQAAAAR1bml0AgAAAAVXQVZFUwkAAlgAAAABCQEAAAAFdmFsdWUAAAABBQAAAAlvclByQXNzZXQDAwkBAAAAAiE9AAAAAgUAAAAKb3JBbXRBc1N0cgUAAAAHYW10QXNJZAYJAQAAAAIhPQAAAAIFAAAACW9yUHJBc1N0cgUAAAAGcHJBc0lkCQAAAgAAAAECAAAACVdyIGFzc2V0cwQAAAAKb3JkZXJQcmljZQgFAAAABW9yZGVyAAAABXByaWNlBAAAAAhwcmljZURjbQkAAGsAAAADBQAAAAZzY2FsZTgFAAAAB3ByQXNEY20FAAAACGFtdEFzRGNtBAAAAA5jYXN0T3JkZXJQcmljZQkBAAAAAnRzAAAAAwUAAAAKb3JkZXJQcmljZQUAAAAGc2NhbGU4BQAAAAhwcmljZURjbQQAAAARaXNPcmRlclByaWNlVmFsaWQDCQAAAAAAAAIIBQAAAAVvcmRlcgAAAAlvcmRlclR5cGUFAAAAA0J1eQkAAGcAAAACBQAAAAhjdXJQcmljZQUAAAAOY2FzdE9yZGVyUHJpY2UJAABnAAAAAgUAAAAOY2FzdE9yZGVyUHJpY2UFAAAACGN1clByaWNlBgEAAAACY2cAAAABAAAAAWkDCQEAAAACIT0AAAACCQABkAAAAAEIBQAAAAFpAAAACHBheW1lbnRzAAAAAAAAAAABCQAAAgAAAAECAAAACjEgcG1udCBleHAEAAAAA3BtdAkBAAAABXZhbHVlAAAAAQkAAZEAAAACCAUAAAABaQAAAAhwYXltZW50cwAAAAAAAAAAAAQAAAAKcG10QXNzZXRJZAkBAAAABXZhbHVlAAAAAQgFAAAAA3BtdAAAAAdhc3NldElkBAAAAAZwbXRBbXQIBQAAAANwbXQAAAAGYW1vdW50BAAAAAFyCQEAAAADZWdvAAAABAkAAlgAAAABCAUAAAABaQAAAA10cmFuc2FjdGlvbklkCQACWAAAAAEFAAAACnBtdEFzc2V0SWQFAAAABnBtdEFtdAgFAAAAAWkAAAAGY2FsbGVyBAAAAAhvdXRBbUFtdAgFAAAAAXIAAAACXzEEAAAACG91dFByQW10CAUAAAABcgAAAAJfMgQAAAADc3RzCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEIBQAAAAFyAAAAAl85BAAAAAVzdGF0ZQgFAAAAAXIAAAADXzEwAwMJAQAAAANpZ3MAAAAABgkAAAAAAAACBQAAAANzdHMFAAAADFBvb2xTaHV0ZG93bgkAAAIAAAABCQABLAAAAAICAAAAD0FkbWluIGJsb2NrZWQ6IAkAAaQAAAABBQAAAANzdHMJAAUXAAAABQUAAAAIb3V0QW1BbXQFAAAACG91dFByQW10BQAAAAZwbXRBbXQFAAAACnBtdEFzc2V0SWQFAAAABXN0YXRlAQAAAAJjcAAAAAkAAAAGY2FsbGVyAAAABHR4SWQAAAAHYW1Bc1BtdAAAAAdwckFzUG10AAAACHNsaXBwYWdlAAAABmVtaXRMcAAAAAppc09uZUFzc2V0AAAABnBtdEFtdAAAAAVwbXRJZAQAAAABcgkBAAAAA2VwbwAAAAwFAAAABHR4SWQFAAAACHNsaXBwYWdlCAkBAAAABXZhbHVlAAAAAQUAAAAHYW1Bc1BtdAAAAAZhbW91bnQICQEAAAAFdmFsdWUAAAABBQAAAAdhbUFzUG10AAAAB2Fzc2V0SWQICQEAAAAFdmFsdWUAAAABBQAAAAdwckFzUG10AAAABmFtb3VudAgJAQAAAAV2YWx1ZQAAAAEFAAAAB3ByQXNQbXQAAAAHYXNzZXRJZAUAAAAGY2FsbGVyBwUAAAAGZW1pdExwBQAAAAppc09uZUFzc2V0BQAAAAZwbXRBbXQFAAAABXBtdElkBAAAAANzdHMJAQAAAA1wYXJzZUludFZhbHVlAAAAAQgFAAAAAXIAAAACXzgDAwMJAQAAAANpZ3MAAAAABgkAAAAAAAACBQAAAANzdHMFAAAAClBvb2xQdXREaXMGCQAAAAAAAAIFAAAAA3N0cwUAAAAMUG9vbFNodXRkb3duCQAAAgAAAAEJAAEsAAAAAgIAAAAIQmxvY2tlZDoJAAGkAAAAAQUAAAADc3RzBQAAAAFyAQAAAAFtAAAAAAQAAAAHJG1hdGNoMAkABCIAAAABCQEAAAADbXBrAAAAAAMJAAABAAAAAgUAAAAHJG1hdGNoMAIAAAAGU3RyaW5nBAAAAAFzBQAAAAckbWF0Y2gwCQACWQAAAAEFAAAAAXMDCQAAAQAAAAIFAAAAByRtYXRjaDACAAAABFVuaXQFAAAABHVuaXQJAAACAAAAAQIAAAALTWF0Y2ggZXJyb3IBAAAAAnBtAAAAAAQAAAAHJG1hdGNoMAkABCIAAAABCQEAAAAEcG1wawAAAAADCQAAAQAAAAIFAAAAByRtYXRjaDACAAAABlN0cmluZwQAAAABcwUAAAAHJG1hdGNoMAkAAlkAAAABBQAAAAFzAwkAAAEAAAACBQAAAAckbWF0Y2gwAgAAAARVbml0BQAAAAR1bml0CQAAAgAAAAECAAAAC01hdGNoIGVycm9yAQAAAAJtbQAAAAEAAAABaQQAAAACcGQJAAACAAAAAQIAAAARUGVybWlzc2lvbiBkZW5pZWQEAAAAByRtYXRjaDAJAQAAAAFtAAAAAAMJAAABAAAAAgUAAAAHJG1hdGNoMAIAAAAKQnl0ZVZlY3RvcgQAAAACcGsFAAAAByRtYXRjaDADCQAAAAAAAAIIBQAAAAFpAAAAD2NhbGxlclB1YmxpY0tleQUAAAACcGsGBQAAAAJwZAMJAAABAAAAAgUAAAAHJG1hdGNoMAIAAAAEVW5pdAMJAAAAAAAAAggFAAAAAWkAAAAGY2FsbGVyBQAAAAR0aGlzBgUAAAACcGQJAAACAAAAAQIAAAALTWF0Y2ggZXJyb3IAAAATAAAAAWkBAAAAC2NvbnN0cnVjdG9yAAAAAQAAAAJmYwQAAAABYwkBAAAAAm1tAAAAAQUAAAABaQMJAAAAAAAAAgUAAAABYwUAAAABYwkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAACZmMAAAAABQAAAAJmYwUAAAADbmlsCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgAAAAFpAQAAAApzZXRNYW5hZ2VyAAAAAQAAABdwZW5kaW5nTWFuYWdlclB1YmxpY0tleQQAAAABYwkBAAAAAm1tAAAAAQUAAAABaQMJAAAAAAAAAgUAAAABYwUAAAABYwQAAAACY20JAAJZAAAAAQUAAAAXcGVuZGluZ01hbmFnZXJQdWJsaWNLZXkDCQAAAAAAAAIFAAAAAmNtBQAAAAJjbQkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAAEcG1wawAAAAAFAAAAF3BlbmRpbmdNYW5hZ2VyUHVibGljS2V5BQAAAANuaWwJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgAAAAFpAQAAAA5jb25maXJtTWFuYWdlcgAAAAAEAAAAAXAJAQAAAAJwbQAAAAAEAAAAA2hwbQMJAQAAAAlpc0RlZmluZWQAAAABBQAAAAFwBgkAAAIAAAABAgAAABJObyBwZW5kaW5nIG1hbmFnZXIDCQAAAAAAAAIFAAAAA2hwbQUAAAADaHBtBAAAAANjcG0DCQAAAAAAAAIIBQAAAAFpAAAAD2NhbGxlclB1YmxpY0tleQkBAAAABXZhbHVlAAAAAQUAAAABcAYJAAACAAAAAQIAAAAbWW91IGFyZSBub3QgcGVuZGluZyBtYW5hZ2VyAwkAAAAAAAACBQAAAANjcG0FAAAAA2NwbQkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAADbXBrAAAAAAkAAlgAAAABCQEAAAAFdmFsdWUAAAABBQAAAAFwCQAETAAAAAIJAQAAAAtEZWxldGVFbnRyeQAAAAEJAQAAAARwbXBrAAAAAAUAAAADbmlsCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4AAAABaQEAAAADcHV0AAAAAgAAAARzbGlwAAAACWF1dG9TdGFrZQQAAAAHZmFjdENmZwkBAAAAA2dmYwAAAAAEAAAAC3N0YWtpbmdDbnRyCQEAAAATdmFsdWVPckVycm9yTWVzc2FnZQAAAAIJAAQmAAAAAQkAAZEAAAACBQAAAAdmYWN0Q2ZnBQAAAA9pZHhGYWN0U3Rha0NudHICAAAACldyIHN0IGFkZHIEAAAACHNsaXBDbnRyCQEAAAATdmFsdWVPckVycm9yTWVzc2FnZQAAAAIJAAQmAAAAAQkAAZEAAAACBQAAAAdmYWN0Q2ZnBQAAABBpZHhGYWN0U2xpcHBDbnRyAgAAAApXciBzbCBhZGRyAwkAAGYAAAACAAAAAAAAAAAABQAAAARzbGlwCQAAAgAAAAECAAAADldyb25nIHNsaXBwYWdlAwkBAAAAAiE9AAAAAgkAAZAAAAABCAUAAAABaQAAAAhwYXltZW50cwAAAAAAAAAAAgkAAAIAAAABAgAAAAwyIHBtbnRzIGV4cGQEAAAAAWUJAQAAAAJjcAAAAAkJAAQlAAAAAQgFAAAAAWkAAAAGY2FsbGVyCQACWAAAAAEIBQAAAAFpAAAADXRyYW5zYWN0aW9uSWQJAQAAAA9BdHRhY2hlZFBheW1lbnQAAAACCAkBAAAABXZhbHVlAAAAAQkAAZEAAAACCAUAAAABaQAAAAhwYXltZW50cwAAAAAAAAAAAAAAAAdhc3NldElkCAkBAAAABXZhbHVlAAAAAQkAAZEAAAACCAUAAAABaQAAAAhwYXltZW50cwAAAAAAAAAAAAAAAAZhbW91bnQJAAGRAAAAAggFAAAAAWkAAAAIcGF5bWVudHMAAAAAAAAAAAEFAAAABHNsaXAGBwAAAAAAAAAAAAIAAAAABAAAAAllbWl0THBBbXQIBQAAAAFlAAAAAl8yBAAAAAlscEFzc2V0SWQIBQAAAAFlAAAAAl83BAAAAAVzdGF0ZQgFAAAAAWUAAAACXzkEAAAABmFtRGlmZggFAAAAAWUAAAADXzEwBAAAAAZwckRpZmYIBQAAAAFlAAAAA18xMQQAAAAEYW1JZAgFAAAAAWUAAAADXzEyBAAAAARwcklkCAUAAAABZQAAAANfMTMEAAAAAXIJAAP8AAAABAUAAAADZmNhAgAAAARlbWl0CQAETAAAAAIFAAAACWVtaXRMcEFtdAUAAAADbmlsBQAAAANuaWwDCQAAAAAAAAIFAAAAAXIFAAAAAXIEAAAAAmVsBAAAAAckbWF0Y2gwBQAAAAFyAwkAAAEAAAACBQAAAAckbWF0Y2gwAgAAAAdBZGRyZXNzBAAAAAZsZWdhY3kFAAAAByRtYXRjaDAJAAP8AAAABAUAAAAGbGVnYWN5AgAAAARlbWl0CQAETAAAAAIFAAAACWVtaXRMcEFtdAUAAAADbmlsBQAAAANuaWwFAAAABHVuaXQDCQAAAAAAAAIFAAAAAmVsBQAAAAJlbAQAAAACc2EDCQAAZgAAAAIFAAAABmFtRGlmZgAAAAAAAAAAAAkAA/wAAAAEBQAAAAhzbGlwQ250cgIAAAADcHV0BQAAAANuaWwJAARMAAAAAgkBAAAAD0F0dGFjaGVkUGF5bWVudAAAAAIFAAAABGFtSWQFAAAABmFtRGlmZgUAAAADbmlsBQAAAANuaWwDCQAAAAAAAAIFAAAAAnNhBQAAAAJzYQQAAAACc3ADCQAAZgAAAAIFAAAABnByRGlmZgAAAAAAAAAAAAkAA/wAAAAEBQAAAAhzbGlwQ250cgIAAAADcHV0BQAAAANuaWwJAARMAAAAAgkBAAAAD0F0dGFjaGVkUGF5bWVudAAAAAIFAAAABHBySWQFAAAABnByRGlmZgUAAAADbmlsBQAAAANuaWwDCQAAAAAAAAIFAAAAAnNwBQAAAAJzcAQAAAAIbHBUcm5zZnIDBQAAAAlhdXRvU3Rha2UEAAAAAnNzCQAD/AAAAAQFAAAAC3N0YWtpbmdDbnRyAgAAAAVzdGFrZQUAAAADbmlsCQAETAAAAAIJAQAAAA9BdHRhY2hlZFBheW1lbnQAAAACBQAAAAlscEFzc2V0SWQFAAAACWVtaXRMcEFtdAUAAAADbmlsAwkAAAAAAAACBQAAAAJzcwUAAAACc3MFAAAAA25pbAkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAARMAAAAAgkBAAAADlNjcmlwdFRyYW5zZmVyAAAAAwgFAAAAAWkAAAAGY2FsbGVyBQAAAAllbWl0THBBbXQFAAAACWxwQXNzZXRJZAUAAAADbmlsCQAETgAAAAIFAAAABXN0YXRlBQAAAAhscFRybnNmcgkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4AAAABaQEAAAAJcHV0T25lVGtuAAAABQAAAAthbUFzc2V0UGFydAAAAAtwckFzc2V0UGFydAAAAAVvdXRMcAAAAAhzbGlwcGFnZQAAAAlhdXRvU3Rha2UEAAAAA2NmZwkBAAAAA2dmYwAAAAAEAAAAC3N0YWtpbmdDbnRyCQEAAAATdmFsdWVPckVycm9yTWVzc2FnZQAAAAIJAAQmAAAAAQkAAZEAAAACBQAAAANjZmcFAAAAD2lkeEZhY3RTdGFrQ250cgIAAAAKV3Igc3QgYWRkcgQAAAAIc2xpcENudHIJAQAAABN2YWx1ZU9yRXJyb3JNZXNzYWdlAAAAAgkABCYAAAABCQABkQAAAAIFAAAAA2NmZwUAAAAQaWR4RmFjdFNsaXBwQ250cgIAAAAKV3Igc2wgYWRkcgQAAAAHZ3d4Q250cgkBAAAAE3ZhbHVlT3JFcnJvck1lc3NhZ2UAAAACCQAEJgAAAAEJAAGRAAAAAgUAAAADY2ZnBQAAABFpZHhGYWN0R3d4UmV3Q250cgIAAAALV3IgZ3d4IGFkZHIEAAAAB3Bvb2xDZmcJAQAAAANncGMAAAAABAAAAARhbUlkCQABkQAAAAIFAAAAB3Bvb2xDZmcFAAAACWlkeEFtQXNJZAQAAAAEcHJJZAkAAZEAAAACBQAAAAdwb29sQ2ZnBQAAAAlpZHhQckFzSWQEAAAABWFtRGNtCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAAHcG9vbENmZwUAAAALaWR4QW10QXNEY20EAAAABXByRGNtCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAAHcG9vbENmZwUAAAANaWR4UHJpY2VBc0RjbQMDAwMJAABnAAAAAgAAAAAAAAAAAAUAAAAIc2xpcHBhZ2UGCQAAZwAAAAIAAAAAAAAAAAAFAAAAC2FtQXNzZXRQYXJ0BgkAAGcAAAACAAAAAAAAAAAABQAAAAtwckFzc2V0UGFydAYJAABnAAAAAgAAAAAAAAAAAAUAAAAFb3V0THAJAAACAAAAAQIAAAAMV3JvbmcgcGFyYW1zAwkBAAAAAiE9AAAAAgkAAZAAAAABCAUAAAABaQAAAAhwYXltZW50cwAAAAAAAAAAAQkAAAIAAAABAgAAAAsxIHBtbnQgZXhwZAQAAAADcG10CQEAAAAFdmFsdWUAAAABCQABkQAAAAIIBQAAAAFpAAAACHBheW1lbnRzAAAAAAAAAAAABAAAAApwbXRBc3NldElkCQACWAAAAAEJAQAAAAV2YWx1ZQAAAAEIBQAAAANwbXQAAAAHYXNzZXRJZAQAAAAGcG10QW10CAUAAAADcG10AAAABmFtb3VudAMDAwkAAGYAAAACBQAAAAthbUFzc2V0UGFydAUAAAAGcG10QW10BgkAAGYAAAACBQAAAAtwckFzc2V0UGFydAUAAAAGcG10QW10BgkAAGYAAAACAAAAAAAAmJaABQAAAAZwbXRBbXQJAAACAAAAAQIAAAANV3JvbmcgcG10IGFtdAQAAAAJYW1CYWxhbmNlCQEAAAANZ2V0QWNjQmFsYW5jZQAAAAEFAAAABGFtSWQEAAAACXByQmFsYW5jZQkBAAAADWdldEFjY0JhbGFuY2UAAAABBQAAAARwcklkBAAAAA0kdDAyNDE4OTI0NTY5AwkAAAAAAAACBQAAAApwbXRBc3NldElkBQAAAARhbUlkCQAFGAAAAAYJAABlAAAAAgUAAAAJYW1CYWxhbmNlBQAAAAZwbXRBbXQFAAAACXByQmFsYW5jZQkAAGUAAAACBQAAAAZwbXRBbXQFAAAAC2FtQXNzZXRQYXJ0BQAAAAtwckFzc2V0UGFydAAAAAAAAAAAAAAAAAAAAAAAAAMJAAAAAAAAAgUAAAAKcG10QXNzZXRJZAUAAAAEcHJJZAkABRgAAAAGBQAAAAlhbUJhbGFuY2UJAABlAAAAAgUAAAAJcHJCYWxhbmNlBQAAAAZwbXRBbXQAAAAAAAAAAAAAAAAAAAAAAAAJAABlAAAAAgUAAAAGcG10QW10BQAAAAtwckFzc2V0UGFydAUAAAALYW1Bc3NldFBhcnQJAAACAAAAAQIAAAAQd3JvbmcgcG10QXNzZXRJZAQAAAAMYW1CYWxhbmNlTm93CAUAAAANJHQwMjQxODkyNDU2OQAAAAJfMQQAAAAMcHJCYWxhbmNlTm93CAUAAAANJHQwMjQxODkyNDU2OQAAAAJfMgQAAAAMdmlydFN3YXBJbkFtCAUAAAANJHQwMjQxODkyNDU2OQAAAAJfMwQAAAANdmlydFN3YXBPdXRQcggFAAAADSR0MDI0MTg5MjQ1NjkAAAACXzQEAAAADHZpcnRTd2FwSW5QcggFAAAADSR0MDI0MTg5MjQ1NjkAAAACXzUEAAAADXZpcnRTd2FwT3V0QW0IBQAAAA0kdDAyNDE4OTI0NTY5AAAAAl82BAAAAAJEMAkAA/wAAAAEBQAAAAdnd3hDbnRyAgAAAAVjYWxjRAkABEwAAAACCQABpAAAAAEFAAAADGFtQmFsYW5jZU5vdwkABEwAAAACCQABpAAAAAEFAAAADHByQmFsYW5jZU5vdwkABEwAAAACBQAAAAFBCQAETAAAAAIFAAAABUFtdWx0CQAETAAAAAIFAAAABURjb252BQAAAANuaWwFAAAAA25pbAQAAAACRDEJAAP8AAAABAUAAAAHZ3d4Q250cgIAAAAFY2FsY0QJAARMAAAAAgkAAaYAAAABCQABNgAAAAEJAABlAAAAAgkAAGQAAAACBQAAAAxhbUJhbGFuY2VOb3cFAAAADHZpcnRTd2FwSW5BbQUAAAANdmlydFN3YXBPdXRBbQkABEwAAAACCQABpgAAAAEJAAE2AAAAAQkAAGUAAAACCQAAZAAAAAIFAAAADHByQmFsYW5jZU5vdwUAAAAMdmlydFN3YXBJblByBQAAAA12aXJ0U3dhcE91dFByCQAETAAAAAIFAAAAAUEJAARMAAAAAgUAAAAFQW11bHQJAARMAAAAAgUAAAAFRGNvbnYFAAAAA25pbAUAAAADbmlsBAAAAAZEMHZzRDEJAQAAAAJ2ZAAAAAMJAAGnAAAAAQkBAAAAA3N0cgAAAAEFAAAAAkQxCQABpwAAAAEJAQAAAANzdHIAAAABBQAAAAJEMAUAAAAKc2xpcHBhZ2U0RAMJAAAAAAAAAgUAAAAGRDB2c0QxBQAAAAZEMHZzRDEEAAAABmVzdFB1dAkBAAAAAmNwAAAACQkABCUAAAABCAUAAAABaQAAAAZjYWxsZXIJAAJYAAAAAQgFAAAAAWkAAAANdHJhbnNhY3Rpb25JZAkBAAAAD0F0dGFjaGVkUGF5bWVudAAAAAIJAAJZAAAAAQUAAAAEYW1JZAUAAAALYW1Bc3NldFBhcnQJAQAAAA9BdHRhY2hlZFBheW1lbnQAAAACCQACWQAAAAEFAAAABHBySWQFAAAAC3ByQXNzZXRQYXJ0BQAAAAhzbGlwcGFnZQYGBQAAAAZwbXRBbXQFAAAACnBtdEFzc2V0SWQEAAAAB2VzdGltTFAIBQAAAAZlc3RQdXQAAAACXzIEAAAACWxwQXNzZXRJZAgFAAAABmVzdFB1dAAAAAJfNwQAAAAFc3RhdGUIBQAAAAZlc3RQdXQAAAACXzkEAAAABmFtRGlmZggFAAAABmVzdFB1dAAAAANfMTAEAAAABnByRGlmZggFAAAABmVzdFB1dAAAAANfMTEEAAAACWxwQ2FsY1JlcwkBAAAAA3ZhZAAAAAMJAAE2AAAAAQUAAAAHZXN0aW1MUAkAATYAAAABBQAAAAVvdXRMcAkAATYAAAABBQAAAAhzbGlwcGFnZQQAAAAJZW1pdExwQW10CQABoAAAAAEIBQAAAAlscENhbGNSZXMAAAACXzIEAAAAAWUJAAP8AAAABAUAAAADZmNhAgAAAARlbWl0CQAETAAAAAIFAAAACWVtaXRMcEFtdAUAAAADbmlsBQAAAANuaWwDCQAAAAAAAAIFAAAAAWUFAAAAAWUEAAAAAmVsBAAAAAckbWF0Y2gwBQAAAAFlAwkAAAEAAAACBQAAAAckbWF0Y2gwAgAAAAdBZGRyZXNzBAAAAAZsZWdhY3kFAAAAByRtYXRjaDAJAAP8AAAABAUAAAAGbGVnYWN5AgAAAARlbWl0CQAETAAAAAIFAAAACWVtaXRMcEFtdAUAAAADbmlsBQAAAANuaWwFAAAABHVuaXQDCQAAAAAAAAIFAAAAAmVsBQAAAAJlbAQAAAACc2EDCQAAZgAAAAIFAAAABmFtRGlmZgAAAAAAAAAAAAkAA/wAAAAEBQAAAAhzbGlwQ250cgIAAAADcHV0BQAAAANuaWwJAARMAAAAAgkBAAAAD0F0dGFjaGVkUGF5bWVudAAAAAIJAAJZAAAAAQUAAAAEYW1JZAUAAAAGYW1EaWZmBQAAAANuaWwFAAAAA25pbAMJAAAAAAAAAgUAAAACc2EFAAAAAnNhBAAAAAJzcAMJAABmAAAAAgUAAAAGcHJEaWZmAAAAAAAAAAAACQAD/AAAAAQFAAAACHNsaXBDbnRyAgAAAANwdXQFAAAAA25pbAkABEwAAAACCQEAAAAPQXR0YWNoZWRQYXltZW50AAAAAgkAAlkAAAABBQAAAARwcklkBQAAAAZwckRpZmYFAAAAA25pbAUAAAADbmlsAwkAAAAAAAACBQAAAAJzcAUAAAACc3AEAAAACGxwVHJuc2ZyAwUAAAAJYXV0b1N0YWtlBAAAAAJzcwkAA/wAAAAEBQAAAAtzdGFraW5nQ250cgIAAAAFc3Rha2UFAAAAA25pbAkABEwAAAACCQEAAAAPQXR0YWNoZWRQYXltZW50AAAAAgUAAAAJbHBBc3NldElkBQAAAAllbWl0THBBbXQFAAAAA25pbAMJAAAAAAAAAgUAAAACc3MFAAAAAnNzBQAAAANuaWwJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQAETAAAAAIJAQAAAA5TY3JpcHRUcmFuc2ZlcgAAAAMIBQAAAAFpAAAABmNhbGxlcgUAAAAJZW1pdExwQW10BQAAAAlscEFzc2V0SWQFAAAAA25pbAkABE4AAAACBQAAAAVzdGF0ZQUAAAAIbHBUcm5zZnIJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgAAAAFpAQAAAApwdXRGb3JGcmVlAAAAAQAAAAdtYXhTbHBnAwkAAGYAAAACAAAAAAAAAAAABQAAAAdtYXhTbHBnCQAAAgAAAAECAAAACldyb25nIHNscGcDCQEAAAACIT0AAAACCQABkAAAAAEIBQAAAAFpAAAACHBheW1lbnRzAAAAAAAAAAACCQAAAgAAAAECAAAADDIgcG1udHMgZXhwZAQAAAAGZXN0UHV0CQEAAAACY3AAAAAJCQAEJQAAAAEIBQAAAAFpAAAABmNhbGxlcgkAAlgAAAABCAUAAAABaQAAAA10cmFuc2FjdGlvbklkCQEAAAAPQXR0YWNoZWRQYXltZW50AAAAAggJAQAAAAV2YWx1ZQAAAAEJAAGRAAAAAggFAAAAAWkAAAAIcGF5bWVudHMAAAAAAAAAAAAAAAAHYXNzZXRJZAgJAQAAAAV2YWx1ZQAAAAEJAAGRAAAAAggFAAAAAWkAAAAIcGF5bWVudHMAAAAAAAAAAAAAAAAGYW1vdW50CQABkQAAAAIIBQAAAAFpAAAACHBheW1lbnRzAAAAAAAAAAABBQAAAAdtYXhTbHBnBwcAAAAAAAAAAAACAAAAAAgFAAAABmVzdFB1dAAAAAJfOQAAAAFpAQAAAANnZXQAAAAABAAAAAFyCQEAAAACY2cAAAABBQAAAAFpBAAAAAlvdXRBbXRBbXQIBQAAAAFyAAAAAl8xBAAAAAhvdXRQckFtdAgFAAAAAXIAAAACXzIEAAAABnBtdEFtdAgFAAAAAXIAAAACXzMEAAAACnBtdEFzc2V0SWQIBQAAAAFyAAAAAl80BAAAAAVzdGF0ZQgFAAAAAXIAAAACXzUEAAAAAWIJAAP8AAAABAUAAAADZmNhAgAAAARidXJuCQAETAAAAAIFAAAABnBtdEFtdAUAAAADbmlsCQAETAAAAAIJAQAAAA9BdHRhY2hlZFBheW1lbnQAAAACBQAAAApwbXRBc3NldElkBQAAAAZwbXRBbXQFAAAAA25pbAMJAAAAAAAAAgUAAAABYgUAAAABYgUAAAAFc3RhdGUJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAAAAAWkBAAAACWdldE9uZVRrbgAAAAUAAAAKZXhjaFJlc3VsdAAAAAdub3RVc2VkAAAACW91dEFtb3VudAAAAApvdXRBc3NldElkAAAACHNsaXBwYWdlAwkBAAAAAiE9AAAAAgkAAZAAAAABCAUAAAABaQAAAAhwYXltZW50cwAAAAAAAAAAAQkAAAIAAAABAgAAAAsxIHBtbnQgZXhwZAQAAAADY2ZnCQEAAAADZ3BjAAAAAAQAAAAEbHBJZAkAAZEAAAACBQAAAANjZmcFAAAACWlkeExQQXNJZAQAAAAEYW1JZAkAAZEAAAACBQAAAANjZmcFAAAACWlkeEFtQXNJZAQAAAAEcHJJZAkAAZEAAAACBQAAAANjZmcFAAAACWlkeFByQXNJZAQAAAAFYW1EY20JAQAAAA1wYXJzZUludFZhbHVlAAAAAQkAAZEAAAACBQAAAANjZmcFAAAAC2lkeEFtdEFzRGNtBAAAAAVwckRjbQkBAAAADXBhcnNlSW50VmFsdWUAAAABCQABkQAAAAIFAAAAA2NmZwUAAAANaWR4UHJpY2VBc0RjbQQAAAADc3RzCQABkQAAAAIFAAAAA2NmZwUAAAAJaWR4UG9vbFN0BAAAAAdmYWN0Q2ZnCQEAAAADZ2ZjAAAAAAQAAAAHZ3d4Q250cgkBAAAAE3ZhbHVlT3JFcnJvck1lc3NhZ2UAAAACCQAEJgAAAAEJAAGRAAAAAgUAAAAHZmFjdENmZwUAAAARaWR4RmFjdEd3eFJld0NudHICAAAACldyIHNsIGFkZHIEAAAAA3BtdAkBAAAABXZhbHVlAAAAAQkAAZEAAAACCAUAAAABaQAAAAhwYXltZW50cwAAAAAAAAAAAAQAAAAFYWRkb24JAQAAAAt2YWx1ZU9yRWxzZQAAAAIJAAQdAAAAAgUAAAAEdGhpcwkBAAAAA2FkYQAAAAACAAAAAAQAAAALdXNlckFkZHJlc3MDCQAAAAAAAAIFAAAABWFkZG9uCQAEJQAAAAEIBQAAAAFpAAAABmNhbGxlcggFAAAAAWkAAAAMb3JpZ2luQ2FsbGVyCAUAAAABaQAAAAZjYWxsZXIEAAAABnR4SWQ1OAkAAlgAAAABCAUAAAABaQAAAA10cmFuc2FjdGlvbklkBAAAAApwbXRBc3NldElkCQEAAAAFdmFsdWUAAAABCAUAAAADcG10AAAAB2Fzc2V0SWQEAAAABnBtdEFtdAgFAAAAA3BtdAAAAAZhbW91bnQDCQAAZgAAAAIAAAAAADuaygAFAAAABnBtdEFtdAkAAAIAAAABAgAAAA1NaW4gcG10IDEwIExQAwMDCQAAZgAAAAIAAAAAAAAAAAAFAAAACHNsaXBwYWdlBgkAAGYAAAACAAAAAAAAAAAABQAAAApleGNoUmVzdWx0BgkAAGYAAAACAAAAAAAAAAAABQAAAAlvdXRBbW91bnQJAAACAAAAAQIAAAAMV3JvbmcgcGFyYW1zAwkBAAAAAiE9AAAAAgUAAAAEbHBJZAkAAlgAAAABBQAAAApwbXRBc3NldElkCQAAAgAAAAECAAAACFdyb25nIExQBAAAAAFyCQEAAAADZWdvAAAABAkAAlgAAAABCAUAAAABaQAAAA10cmFuc2FjdGlvbklkCQACWAAAAAEFAAAACnBtdEFzc2V0SWQFAAAABnBtdEFtdAgFAAAAAWkAAAAGY2FsbGVyBAAAAAplc3RpbUFtQW10CAUAAAABcgAAAAJfMQQAAAAKZXN0aW1QckFtdAgFAAAAAXIAAAACXzIEAAAACWFtQmFsYW5jZQkBAAAADWdldEFjY0JhbGFuY2UAAAABBQAAAARhbUlkBAAAAAlwckJhbGFuY2UJAQAAAA1nZXRBY2NCYWxhbmNlAAAAAQUAAAAEcHJJZAQAAAANJHQwMjkzNDgyOTgwNQMJAAAAAAAAAgUAAAAKb3V0QXNzZXRJZAUAAAAEYW1JZAkABRkAAAAHCQAAZQAAAAIFAAAACWFtQmFsYW5jZQUAAAAKZXN0aW1BbUFtdAkAAGUAAAACBQAAAAlwckJhbGFuY2UFAAAACmVzdGltUHJBbXQFAAAACmV4Y2hSZXN1bHQFAAAACmVzdGltUHJBbXQAAAAAAAAAAAAAAAAAAAAAAAAJAABkAAAAAgUAAAAKZXN0aW1BbUFtdAUAAAAKZXhjaFJlc3VsdAMJAAAAAAAAAgUAAAAKb3V0QXNzZXRJZAUAAAAEcHJJZAkABRkAAAAHCQAAZQAAAAIFAAAACWFtQmFsYW5jZQUAAAAKZXN0aW1BbUFtdAkAAGUAAAACBQAAAAlwckJhbGFuY2UFAAAACmVzdGltUHJBbXQAAAAAAAAAAAAAAAAAAAAAAAAFAAAACmV4Y2hSZXN1bHQFAAAACmVzdGltQW1BbXQJAABkAAAAAgUAAAAKZXN0aW1QckFtdAUAAAAKZXhjaFJlc3VsdAkAAAIAAAABAgAAABB3cm9uZyBvdXRBc3NldElkBAAAAAxhbUJhbGFuY2VOb3cIBQAAAA0kdDAyOTM0ODI5ODA1AAAAAl8xBAAAAAxwckJhbGFuY2VOb3cIBQAAAA0kdDAyOTM0ODI5ODA1AAAAAl8yBAAAAAx2aXJ0U3dhcEluQW0IBQAAAA0kdDAyOTM0ODI5ODA1AAAAAl8zBAAAAA12aXJ0U3dhcE91dFByCAUAAAANJHQwMjkzNDgyOTgwNQAAAAJfNAQAAAAMdmlydFN3YXBJblByCAUAAAANJHQwMjkzNDgyOTgwNQAAAAJfNQQAAAANdmlydFN3YXBPdXRBbQgFAAAADSR0MDI5MzQ4Mjk4MDUAAAACXzYEAAAACHRvdGFsR2V0CAUAAAANJHQwMjkzNDgyOTgwNQAAAAJfNwMDCQAAZgAAAAIAAAAAAAAAAAAFAAAADHZpcnRTd2FwSW5BbQYJAABmAAAAAgAAAAAAAAAAAAUAAAAMdmlydFN3YXBJblByCQAAAgAAAAECAAAACldyb25nIGNhbGMEAAAAAkQwCQAD/AAAAAQFAAAAB2d3eENudHICAAAABWNhbGNECQAETAAAAAIJAAGkAAAAAQUAAAAMYW1CYWxhbmNlTm93CQAETAAAAAIJAAGkAAAAAQUAAAAMcHJCYWxhbmNlTm93CQAETAAAAAIFAAAAAUEJAARMAAAAAgUAAAAFQW11bHQJAARMAAAAAgUAAAAFRGNvbnYFAAAAA25pbAUAAAADbmlsBAAAAAJEMQkAA/wAAAAEBQAAAAdnd3hDbnRyAgAAAAVjYWxjRAkABEwAAAACCQABpAAAAAEJAABkAAAAAgkAAGUAAAACBQAAAAxhbUJhbGFuY2VOb3cFAAAADHZpcnRTd2FwSW5BbQUAAAANdmlydFN3YXBPdXRBbQkABEwAAAACCQABpAAAAAEJAABlAAAAAgkAAGQAAAACBQAAAAxwckJhbGFuY2VOb3cFAAAADXZpcnRTd2FwT3V0UHIFAAAADHZpcnRTd2FwSW5QcgkABEwAAAACBQAAAAFBCQAETAAAAAIFAAAABUFtdWx0CQAETAAAAAIFAAAABURjb252BQAAAANuaWwFAAAAA25pbAQAAAAGRDB2c0QxCQEAAAACdmQAAAADCQABpwAAAAEJAQAAAANzdHIAAAABBQAAAAJEMQkAAacAAAABCQEAAAADc3RyAAAAAQUAAAACRDAFAAAACnNsaXBwYWdlNEQDCQAAAAAAAAIFAAAABkQwdnNEMQUAAAAGRDB2c0QxBAAAAAhmaW5hbFJlcwkBAAAAA3ZhZAAAAAMJAAE2AAAAAQUAAAAIdG90YWxHZXQJAAE2AAAAAQUAAAAJb3V0QW1vdW50CQABNgAAAAEFAAAACHNsaXBwYWdlAwkAAAAAAAACBQAAAAhmaW5hbFJlcwUAAAAIZmluYWxSZXMEAAAADSR0MDMwNTEwMzA2MTQDCQAAAAAAAAIFAAAACm91dEFzc2V0SWQFAAAABGFtSWQJAAUUAAAAAgkAAaAAAAABCAUAAAAIZmluYWxSZXMAAAACXzIAAAAAAAAAAAAJAAUUAAAAAgAAAAAAAAAAAAkAAaAAAAABCAUAAAAIZmluYWxSZXMAAAACXzIEAAAABW91dEFtCAUAAAANJHQwMzA1MTAzMDYxNAAAAAJfMQQAAAAFb3V0UHIIBQAAAA0kdDAzMDUxMDMwNjE0AAAAAl8yBAAAAAhjdXJQclgxOAkBAAAABGNwYmkAAAACCQEAAAACdDEAAAACBQAAAAlwckJhbGFuY2UFAAAABXByRGNtCQEAAAACdDEAAAACBQAAAAlhbUJhbGFuY2UFAAAABWFtRGNtBAAAAAVjdXJQcgkBAAAAAmYxAAAAAgUAAAAIY3VyUHJYMTgFAAAABnNjYWxlOAQAAAAFc3RhdGUJAARMAAAAAgkBAAAADlNjcmlwdFRyYW5zZmVyAAAAAwUAAAALdXNlckFkZHJlc3MJAABkAAAAAgUAAAAFb3V0QW0FAAAABW91dFByAwkAAAAAAAACBQAAAApvdXRBc3NldElkAgAAAAVXQVZFUwUAAAAEdW5pdAkAAlkAAAABBQAAAApvdXRBc3NldElkCQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAAANnYXUAAAACCQAEJQAAAAEFAAAAC3VzZXJBZGRyZXNzBQAAAAZ0eElkNTgJAQAAABFkYXRhR2V0QWN0aW9uSW5mbwAAAAYFAAAABW91dEFtBQAAAAVvdXRQcgUAAAAGcG10QW10BQAAAAVjdXJQcgUAAAAGaGVpZ2h0CAUAAAAJbGFzdEJsb2NrAAAACXRpbWVzdGFtcAkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgkBAAAAAnBsAAAAAAUAAAAFY3VyUHIJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIJAQAAAAJwaAAAAAIFAAAABmhlaWdodAgFAAAACWxhc3RCbG9jawAAAAl0aW1lc3RhbXAFAAAABWN1clByBQAAAANuaWwDCQAAAAAAAAIFAAAABXN0YXRlBQAAAAVzdGF0ZQQAAAAEYnVybgkAA/wAAAAEBQAAAANmY2ECAAAABGJ1cm4JAARMAAAAAgUAAAAGcG10QW10BQAAAANuaWwJAARMAAAAAgkBAAAAD0F0dGFjaGVkUGF5bWVudAAAAAIFAAAACnBtdEFzc2V0SWQFAAAABnBtdEFtdAUAAAADbmlsAwkAAAAAAAACBQAAAARidXJuBQAAAARidXJuBQAAAAVzdGF0ZQkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4AAAABaQEAAAAJZ2V0Tm9MZXNzAAAAAgAAABJub0xlc3NUaGVuQW10QXNzZXQAAAAUbm9MZXNzVGhlblByaWNlQXNzZXQEAAAAAXIJAQAAAAJjZwAAAAEFAAAAAWkEAAAACG91dEFtQW10CAUAAAABcgAAAAJfMQQAAAAIb3V0UHJBbXQIBQAAAAFyAAAAAl8yBAAAAAZwbXRBbXQIBQAAAAFyAAAAAl8zBAAAAApwbXRBc3NldElkCAUAAAABcgAAAAJfNAQAAAAFc3RhdGUIBQAAAAFyAAAAAl81AwkAAGYAAAACBQAAABJub0xlc3NUaGVuQW10QXNzZXQFAAAACG91dEFtQW10CQAAAgAAAAEJAAEsAAAAAgkAASwAAAACCQABLAAAAAICAAAACUZhaWxlZDogIAkAAaQAAAABBQAAAAhvdXRBbUFtdAIAAAADIDwgCQABpAAAAAEFAAAAEm5vTGVzc1RoZW5BbXRBc3NldAMJAABmAAAAAgUAAAAUbm9MZXNzVGhlblByaWNlQXNzZXQFAAAACG91dFByQW10CQAAAgAAAAEJAAEsAAAAAgkAASwAAAACCQABLAAAAAICAAAACEZhaWxlZDogCQABpAAAAAEFAAAACG91dFByQW10AgAAAAMgPCAJAAGkAAAAAQUAAAAUbm9MZXNzVGhlblByaWNlQXNzZXQEAAAAFGJ1cm5MUEFzc2V0T25GYWN0b3J5CQAD/AAAAAQFAAAAA2ZjYQIAAAAEYnVybgkABEwAAAACBQAAAAZwbXRBbXQFAAAAA25pbAkABEwAAAACCQEAAAAPQXR0YWNoZWRQYXltZW50AAAAAgUAAAAKcG10QXNzZXRJZAUAAAAGcG10QW10BQAAAANuaWwDCQAAAAAAAAIFAAAAFGJ1cm5MUEFzc2V0T25GYWN0b3J5BQAAABRidXJuTFBBc3NldE9uRmFjdG9yeQUAAAAFc3RhdGUJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAAAAAWkBAAAADXVuc3Rha2VBbmRHZXQAAAABAAAABmFtb3VudAQAAAANY2hlY2tQYXltZW50cwMJAQAAAAIhPQAAAAIJAAGQAAAAAQgFAAAAAWkAAAAIcGF5bWVudHMAAAAAAAAAAAAJAAACAAAAAQIAAAANTm8gcG1udHMgZXhwZAYDCQAAAAAAAAIFAAAADWNoZWNrUGF5bWVudHMFAAAADWNoZWNrUGF5bWVudHMEAAAAA2NmZwkBAAAAA2dwYwAAAAAEAAAACmZhY3RvcnlDZmcJAQAAAANnZmMAAAAABAAAAAlscEFzc2V0SWQJAAJZAAAAAQkAAZEAAAACBQAAAANjZmcFAAAACWlkeExQQXNJZAQAAAAHc3Rha2luZwkBAAAAE3ZhbHVlT3JFcnJvck1lc3NhZ2UAAAACCQAEJgAAAAEJAAGRAAAAAgUAAAAKZmFjdG9yeUNmZwUAAAAPaWR4RmFjdFN0YWtDbnRyAgAAAApXciBzdCBhZGRyBAAAAAp1bnN0YWtlSW52CQAD/AAAAAQFAAAAB3N0YWtpbmcCAAAAB3Vuc3Rha2UJAARMAAAAAgkAAlgAAAABBQAAAAlscEFzc2V0SWQJAARMAAAAAgUAAAAGYW1vdW50BQAAAANuaWwFAAAAA25pbAMJAAAAAAAAAgUAAAAKdW5zdGFrZUludgUAAAAKdW5zdGFrZUludgQAAAABcgkBAAAAA2VnbwAAAAQJAAJYAAAAAQgFAAAAAWkAAAANdHJhbnNhY3Rpb25JZAkAAlgAAAABBQAAAAlscEFzc2V0SWQFAAAABmFtb3VudAgFAAAAAWkAAAAGY2FsbGVyBAAAAANzdHMJAQAAAA1wYXJzZUludFZhbHVlAAAAAQgFAAAAAXIAAAACXzkEAAAABXN0YXRlCAUAAAABcgAAAANfMTAEAAAAAXYDAwkBAAAAA2lncwAAAAAGCQAAAAAAAAIFAAAAA3N0cwUAAAAMUG9vbFNodXRkb3duCQAAAgAAAAEJAAEsAAAAAgIAAAAJQmxvY2tlZDogCQABpAAAAAEFAAAAA3N0cwYDCQAAAAAAAAIFAAAAAXYFAAAAAXYEAAAABWJ1cm5BCQAD/AAAAAQFAAAAA2ZjYQIAAAAEYnVybgkABEwAAAACBQAAAAZhbW91bnQFAAAAA25pbAkABEwAAAACCQEAAAAPQXR0YWNoZWRQYXltZW50AAAAAgUAAAAJbHBBc3NldElkBQAAAAZhbW91bnQFAAAAA25pbAMJAAAAAAAAAgUAAAAFYnVybkEFAAAABWJ1cm5BBQAAAAVzdGF0ZQkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4AAAABaQEAAAAIYWN0aXZhdGUAAAACAAAACGFtdEFzU3RyAAAAB3ByQXNTdHIDCQEAAAACIT0AAAACCQAEJQAAAAEIBQAAAAFpAAAABmNhbGxlcgkABCUAAAABBQAAAANmY2EJAAACAAAAAQIAAAAGZGVuaWVkCQAFFAAAAAIJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAAAmFhAAAAAAUAAAAIYW10QXNTdHIJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAAAnBhAAAAAAUAAAAHcHJBc1N0cgUAAAADbmlsAgAAAAdzdWNjZXNzAAAAAWkBAAAAHGdldFBvb2xDb25maWdXcmFwcGVyUkVBRE9OTFkAAAAACQAFFAAAAAIFAAAAA25pbAkBAAAAA2dwYwAAAAAAAAABaQEAAAAcZ2V0QWNjQmFsYW5jZVdyYXBwZXJSRUFET05MWQAAAAEAAAAHYXNzZXRJZAkABRQAAAACBQAAAANuaWwJAQAAAA1nZXRBY2NCYWxhbmNlAAAAAQUAAAAHYXNzZXRJZAAAAAFpAQAAABljYWxjUHJpY2VzV3JhcHBlclJFQURPTkxZAAAAAwAAAAVhbUFtdAAAAAVwckFtdAAAAAVscEFtdAQAAAACcHIJAQAAAApjYWxjUHJpY2VzAAAAAwUAAAAFYW1BbXQFAAAABXByQW10BQAAAAVscEFtdAkABRQAAAACBQAAAANuaWwJAARMAAAAAgkAAaYAAAABCQABkQAAAAIFAAAAAnByAAAAAAAAAAAACQAETAAAAAIJAAGmAAAAAQkAAZEAAAACBQAAAAJwcgAAAAAAAAAAAQkABEwAAAACCQABpgAAAAEJAAGRAAAAAgUAAAACcHIAAAAAAAAAAAIFAAAAA25pbAAAAAFpAQAAABZmcm9tWDE4V3JhcHBlclJFQURPTkxZAAAAAgAAAAN2YWwAAAAMcmVzU2NhbGVNdWx0CQAFFAAAAAIFAAAAA25pbAkBAAAAAmYxAAAAAgkAAacAAAABBQAAAAN2YWwFAAAADHJlc1NjYWxlTXVsdAAAAAFpAQAAABR0b1gxOFdyYXBwZXJSRUFET05MWQAAAAIAAAAHb3JpZ1ZhbAAAAA1vcmlnU2NhbGVNdWx0CQAFFAAAAAIFAAAAA25pbAkAAaYAAAABCQEAAAACdDEAAAACBQAAAAdvcmlnVmFsBQAAAA1vcmlnU2NhbGVNdWx0AAAAAWkBAAAAHmNhbGNQcmljZUJpZ0ludFdyYXBwZXJSRUFET05MWQAAAAIAAAAIcHJBbXRYMTgAAAAIYW1BbXRYMTgJAAUUAAAAAgUAAAADbmlsCQABpgAAAAEJAQAAAARjcGJpAAAAAgkAAacAAAABBQAAAAhwckFtdFgxOAkAAacAAAABBQAAAAhhbUFtdFgxOAAAAAFpAQAAACNlc3RpbWF0ZVB1dE9wZXJhdGlvbldyYXBwZXJSRUFET05MWQAAAAkAAAAGdHhJZDU4AAAACHNsaXBwYWdlAAAAB2luQW1BbXQAAAAGaW5BbUlkAAAAB2luUHJBbXQAAAAGaW5QcklkAAAAB3VzckFkZHIAAAAGaXNFdmFsAAAABmVtaXRMcAkABRQAAAACBQAAAANuaWwJAQAAAANlcG8AAAAMBQAAAAZ0eElkNTgFAAAACHNsaXBwYWdlBQAAAAdpbkFtQW10BQAAAAZpbkFtSWQFAAAAB2luUHJBbXQFAAAABmluUHJJZAUAAAAHdXNyQWRkcgUAAAAGaXNFdmFsBQAAAAZlbWl0THAHAAAAAAAAAAAAAgAAAAAAAAABaQEAAAAjZXN0aW1hdGVHZXRPcGVyYXRpb25XcmFwcGVyUkVBRE9OTFkAAAAEAAAABnR4SWQ1OAAAAAdwbXRBc0lkAAAACHBtdExwQW10AAAAB3VzckFkZHIEAAAAAXIJAQAAAANlZ28AAAAEBQAAAAZ0eElkNTgFAAAAB3BtdEFzSWQFAAAACHBtdExwQW10CQEAAAARQGV4dHJOYXRpdmUoMTA2MikAAAABBQAAAAd1c3JBZGRyCQAFFAAAAAIFAAAAA25pbAkABRwAAAAKCAUAAAABcgAAAAJfMQgFAAAAAXIAAAACXzIIBQAAAAFyAAAAAl8zCAUAAAABcgAAAAJfNAgFAAAAAXIAAAACXzUIBQAAAAFyAAAAAl82CAUAAAABcgAAAAJfNwkAAaYAAAABCAUAAAABcgAAAAJfOAgFAAAAAXIAAAACXzkIBQAAAAFyAAAAA18xMAAAAAEAAAACdHgBAAAABnZlcmlmeQAAAAAEAAAAByRtYXRjaDAFAAAAAnR4AwkAAAEAAAACBQAAAAckbWF0Y2gwAgAAAAVPcmRlcgQAAAAFb3JkZXIFAAAAByRtYXRjaDAEAAAAB210Y2hQdWIJAQAAAAJtcAAAAAAEAAAAA29yVgkBAAAAA21vYQAAAAEFAAAABW9yZGVyBAAAAAVzbmRyVgkAAfQAAAADCAUAAAAFb3JkZXIAAAAJYm9keUJ5dGVzCQABkQAAAAIIBQAAAAVvcmRlcgAAAAZwcm9vZnMAAAAAAAAAAAAIBQAAAAVvcmRlcgAAAA9zZW5kZXJQdWJsaWNLZXkEAAAABW10Y2hWCQAB9AAAAAMIBQAAAAVvcmRlcgAAAAlib2R5Qnl0ZXMJAAGRAAAAAggFAAAABW9yZGVyAAAABnByb29mcwAAAAAAAAAAAQUAAAAHbXRjaFB1YgMDAwUAAAADb3JWBQAAAAVzbmRyVgcFAAAABW10Y2hWBwYJAQAAAAN0b2UAAAADBQAAAANvclYFAAAABXNuZHJWBQAAAAVtdGNoVgQAAAAPdGFyZ2V0UHVibGljS2V5BAAAAAckbWF0Y2gxCQEAAAABbQAAAAADCQAAAQAAAAIFAAAAByRtYXRjaDECAAAACkJ5dGVWZWN0b3IEAAAAAnBrBQAAAAckbWF0Y2gxBQAAAAJwawMJAAABAAAAAgUAAAAHJG1hdGNoMQIAAAAEVW5pdAgFAAAAAnR4AAAAD3NlbmRlclB1YmxpY0tleQkAAAIAAAABAgAAAAtNYXRjaCBlcnJvcgkAAfQAAAADCAUAAAACdHgAAAAJYm9keUJ5dGVzCQABkQAAAAIIBQAAAAJ0eAAAAAZwcm9vZnMAAAAAAAAAAAAFAAAAD3RhcmdldFB1YmxpY0tleVF8+x8=",
    "height": 1964833,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 5 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let a = 100000000
5+
6+let b = toBigInt(100000000)
7+
8+let c = toBigInt(1000000000000000000)
9+
10+let d = toBigInt(0)
11+
12+let e = toBigInt(1)
13+
14+let f = toBigInt((a - ((a * 1) / a)))
15+
16+let g = "100"
17+
18+let h = "1"
19+
20+let i = "__"
21+
22+let j = ""
23+
24+let k = 1
25+
26+let l = 2
27+
28+let m = 3
29+
30+let n = 4
31+
32+let o = 1
33+
34+let p = 2
35+
36+let q = 3
37+
38+let r = 4
39+
40+let s = 5
41+
42+let t = 6
43+
44+let u = 7
45+
46+let v = 8
47+
48+let w = 9
49+
50+let x = 1
51+
52+let y = 7
53+
54+let z = 10
55+
56+func A (B,C) = fraction(toBigInt(B), c, toBigInt(C))
57+
58+
59+func D (E,F) = toInt(fraction(E, toBigInt(F), c))
60+
61+
62+func G (H,I,J) = fraction(H, I, J)
63+
64+
65+func K (E) = if ((d > E))
66+    then -(E)
67+    else E
68+
69+
70+func L () = "%s__factoryContract"
71+
72+
73+func M () = "%s__managerPublicKey"
74+
75+
76+func N () = "%s__pendingManagerPublicKey"
77+
78+
79+func O () = "%s%s__price__last"
80+
81+
82+func P (Q,R) = makeString(["%s%s%d%d__price__history", toString(Q), toString(R)], i)
83+
84+
85+func S (T,U) = ((("%s%s%s__P__" + T) + "__") + U)
86+
87+
88+func V (T,U) = ((("%s%s%s__G__" + T) + "__") + U)
89+
90+
91+func W () = "%s__amountAsset"
92+
93+
94+func X () = "%s__priceAsset"
95+
96+
97+func Y () = "%s__amp"
98+
99+
100+func Z () = "%s__addonAddr"
101+
102+
103+func aa () = "%s__factoryConfig"
104+
105+
106+func ab () = "%s%s__matcher__publicKey"
107+
108+
109+func ac (ad,ae) = (((("%d%d%s__" + ad) + "__") + ae) + "__config")
110+
111+
112+func af (ag) = ("%s%s%s__mappings__baseAsset2internalId__" + ag)
113+
114+
115+func ah () = "%s__shutdown"
116+
117+
118+func ai (aj,ak,al) = throw(((((("Failed: ordValid=" + toString(aj)) + " sndrValid=") + toString(ak)) + " mtchrValid=") + toString(al)))
119+
120+
121+func am (E) = {
122+    let an = E
123+    if ($isInstanceOf(an, "String"))
124+        then {
125+            let ao = an
126+            ao
127+            }
128+        else throw("fail cast to String")
129+    }
130+
131+
132+func ap (aq,ar) = valueOrErrorMessage(getString(aq, ar), makeString(["mandatory ", toString(aq), ".", ar, " not defined"], ""))
133+
134+
135+func as (aq,ar) = valueOrErrorMessage(getInteger(aq, ar), makeString(["mandatory ", toString(aq), ".", ar, " not defined"], ""))
136+
137+
138+let at = addressFromStringValue(ap(this, L()))
139+
140+let au = ap(this, Y())
141+
142+func av () = valueOrElse(getBoolean(at, ah()), false)
143+
144+
145+func aw () = fromBase58String(ap(at, ab()))
146+
147+
148+func ax () = {
149+    let ay = ap(this, W())
150+    let az = ap(this, X())
151+    let aA = as(at, af(az))
152+    let ad = as(at, af(ay))
153+    split(ap(at, ac(toString(ad), toString(aA))), i)
154+    }
155+
156+
157+func aB () = split(ap(at, aa()), i)
158+
159+
160+func aC (aD,aE,aF,aG,aH,aI,aJ,aK,aL,aM) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(aD), toString(aE), toString(aF), toString(aG), toString(aH), toString(aI), toString(aJ), toString(aK), toString(aL), toString(aM)], i)
161+
162+
163+func aN (aO,aP,aQ,aG,aJ,aK) = makeString(["%d%d%d%d%d%d", toString(aO), toString(aP), toString(aQ), toString(aG), toString(aJ), toString(aK)], i)
164+
165+
166+func aR (aS) = if ((aS == "WAVES"))
167+    then wavesBalance(this).available
168+    else assetBalance(this, fromBase58String(aS))
169+
170+
171+func aT (aU,aV) = fraction(aU, c, aV)
172+
173+
174+func aW (aX,aY,aZ) = {
175+    let ba = fraction((aX - aY), b, aY)
176+    let bb = ((aZ - K(ba)) > d)
177+    if (!(bb))
178+        then throw(("Big slpg: " + toString(ba)))
179+        else $Tuple2(bb, min([aX, aY]))
180+    }
181+
182+
183+func bc (bd,be,bf) = {
184+    let ba = fraction(be, b, bd)
185+    let bg = (bf > ba)
186+    if (if (bg)
187+        then true
188+        else (be > bd))
189+        then throw(((((((toString(be) + " ") + toString(bd)) + " ") + toString(ba)) + " ") + toString(bf)))
190+        else bg
191+    }
192+
193+
194+func bh (bi,bj,bk,bl) = {
195+    let bm = A(bk, bi)
196+    let bn = A(bl, bj)
197+    aT(bn, bm)
198+    }
199+
200+
201+func bo (bk,bl,bp) = {
202+    let bq = ax()
203+    let br = parseIntValue(bq[t])
204+    let bs = parseIntValue(bq[u])
205+    let bt = bh(br, bs, bk, bl)
206+    let aV = A(bk, br)
207+    let aU = A(bl, bs)
208+    let bu = A(bp, a)
209+    let bv = aT(aV, bu)
210+    let bw = aT(aU, bu)
211+[bt, bv, bw]
212+    }
213+
214+
215+func bx (bk,bl,bp) = {
216+    let by = bo(bk, bl, bp)
217+[D(by[0], a), D(by[1], a), D(by[2], a)]
218+    }
219+
220+
221+func bz (bA,bB,bC,bD) = {
222+    let bq = ax()
223+    let bE = bq[q]
224+    let bF = bq[r]
225+    let bG = bq[s]
226+    let bH = parseIntValue(bq[t])
227+    let bI = parseIntValue(bq[u])
228+    let bJ = bq[p]
229+    let bK = valueOrErrorMessage(assetInfo(fromBase58String(bE)), "Wrong LP id").quantity
230+    if ((bE != bB))
231+        then throw("Wrong pmt asset")
232+        else {
233+            let bL = aR(bF)
234+            let bM = A(bL, bH)
235+            let bN = aR(bG)
236+            let bO = A(bN, bI)
237+            let bP = aT(bO, bM)
238+            let bQ = D(bP, a)
239+            let bR = A(bC, a)
240+            let bS = A(bK, a)
241+            let bT = fraction(bM, bR, bS)
242+            let bU = fraction(bO, bR, bS)
243+            let bV = D(bT, bH)
244+            let bW = D(bU, bI)
245+            let bX = if ((bA == ""))
246+                then nil
247+                else [ScriptTransfer(bD, bV, if ((bF == "WAVES"))
248+                    then unit
249+                    else fromBase58String(bF)), ScriptTransfer(bD, bW, if ((bG == "WAVES"))
250+                    then unit
251+                    else fromBase58String(bG)), StringEntry(V(toString(bD), bA), aN(bV, bW, bC, bQ, height, lastBlock.timestamp)), IntegerEntry(O(), bQ), IntegerEntry(P(height, lastBlock.timestamp), bQ)]
252+            $Tuple10(bV, bW, bF, bG, bL, bN, bK, bP, bJ, bX)
253+            }
254+    }
255+
256+
257+func bY (bA,aZ,bZ,ca,cb,cc,bD,cd,ce,cf,cg,ch) = {
258+    let bq = ax()
259+    let bE = fromBase58String(bq[q])
260+    let ci = bq[r]
261+    let cj = bq[s]
262+    let ck = bq[v]
263+    let cl = bq[w]
264+    let cm = parseIntValue(bq[t])
265+    let cn = parseIntValue(bq[u])
266+    let bJ = bq[p]
267+    let co = valueOrErrorMessage(assetInfo(bE), "Wr lp as").quantity
268+    let bL = if (cd)
269+        then aR(ci)
270+        else if (if (cf)
271+            then (ch == ci)
272+            else false)
273+            then (aR(ci) - cg)
274+            else if (cf)
275+                then aR(ci)
276+                else (aR(ci) - bZ)
277+    let bN = if (cd)
278+        then aR(cj)
279+        else if (if (cf)
280+            then (ch == cj)
281+            else false)
282+            then (aR(cj) - cg)
283+            else if (cf)
284+                then aR(cj)
285+                else (aR(cj) - cb)
286+    let cp = A(bZ, cm)
287+    let cq = A(cb, cn)
288+    let cr = aT(cq, cp)
289+    let bM = A(bL, cm)
290+    let bO = A(bN, cn)
291+    let cs = if ((co == 0))
292+        then {
293+            let bP = d
294+            let ct = d
295+            let bu = pow((cp * cq), 0, toBigInt(5), 1, 0, DOWN)
296+            $Tuple5(D(bu, a), D(cp, cm), D(cq, cn), aT((bO + cq), (bM + cp)), ct)
297+            }
298+        else {
299+            let bP = aT(bO, bM)
300+            let cu = fraction(K((bP - cr)), c, bP)
301+            let ct = A(aZ, a)
302+            if (if ((bP != d))
303+                then (cu > ct)
304+                else false)
305+                then throw(((("Price slippage " + toString(cu)) + " > ") + toString(ct)))
306+                else {
307+                    let cv = A(co, a)
308+                    let cw = fraction(cp, bP, c)
309+                    let cx = fraction(cq, c, bP)
310+                    let cy = if ((cw > cq))
311+                        then $Tuple2(cx, cq)
312+                        else $Tuple2(cp, cw)
313+                    let cz = cy._1
314+                    let cA = cy._2
315+                    let bu = fraction(cv, cA, bO)
316+                    $Tuple5(D(bu, a), D(cz, cm), D(cA, cn), bP, ct)
317+                    }
318+            }
319+    let cB = cs._1
320+    let cC = cs._2
321+    let cD = cs._3
322+    let bQ = D(cs._4, a)
323+    let cE = D(cs._5, a)
324+    if ((0 >= cB))
325+        then throw("LP <= 0")
326+        else {
327+            let cF = if (!(ce))
328+                then 0
329+                else cB
330+            let cG = (bZ - cC)
331+            let cH = (cb - cD)
332+            let cI = if (if (cf)
333+                then (ch == ci)
334+                else false)
335+                then $Tuple2(cg, 0)
336+                else if (if (cf)
337+                    then (ch == cj)
338+                    else false)
339+                    then $Tuple2(0, cg)
340+                    else $Tuple2(cC, cD)
341+            let cJ = cI._1
342+            let cK = cI._2
343+            let cL = [IntegerEntry(O(), bQ), IntegerEntry(P(height, lastBlock.timestamp), bQ), StringEntry(S(bD, bA), aC(cJ, cK, cF, bQ, aZ, cE, height, lastBlock.timestamp, cG, cH))]
344+            $Tuple13(cB, cF, bQ, bL, bN, co, bE, bJ, cL, cG, cH, ca, cc)
345+            }
346+    }
347+
348+
349+func cM (cN) = {
350+    let bq = ax()
351+    let cO = bq[r]
352+    let cP = bq[s]
353+    let bJ = parseIntValue(bq[p])
354+    let br = parseIntValue(bq[t])
355+    let bs = parseIntValue(bq[u])
356+    let cQ = aR(cO)
357+    let cR = aR(cP)
358+    let bP = if ((cN.orderType == Buy))
359+        then bh(br, bs, (cQ + cN.amount), cR)
360+        else bh(br, bs, (cQ - cN.amount), cR)
361+    let bQ = D(bP, a)
362+    if (if (if (av())
363+        then true
364+        else (bJ == m))
365+        then true
366+        else (bJ == n))
367+        then throw("Admin blocked")
368+        else {
369+            let cS = cN.assetPair.amountAsset
370+            let cT = if ((cS == unit))
371+                then "WAVES"
372+                else toBase58String(value(cS))
373+            let cU = cN.assetPair.priceAsset
374+            let cV = if ((cU == unit))
375+                then "WAVES"
376+                else toBase58String(value(cU))
377+            if (if ((cT != cO))
378+                then true
379+                else (cV != cP))
380+                then throw("Wr assets")
381+                else {
382+                    let cW = cN.price
383+                    let cn = fraction(a, bs, br)
384+                    let cX = G(cW, a, cn)
385+                    let cY = if ((cN.orderType == Buy))
386+                        then (bQ >= cX)
387+                        else (cX >= bQ)
388+                    true
389+                    }
390+            }
391+    }
392+
393+
394+func cZ (da) = if ((size(da.payments) != 1))
395+    then throw("1 pmnt exp")
396+    else {
397+        let db = value(da.payments[0])
398+        let bB = value(db.assetId)
399+        let cg = db.amount
400+        let cs = bz(toBase58String(da.transactionId), toBase58String(bB), cg, da.caller)
401+        let bV = cs._1
402+        let bW = cs._2
403+        let bJ = parseIntValue(cs._9)
404+        let bX = cs._10
405+        if (if (av())
406+            then true
407+            else (bJ == n))
408+            then throw(("Admin blocked: " + toString(bJ)))
409+            else $Tuple5(bV, bW, cg, bB, bX)
410+        }
411+
412+
413+func dc (dd,U,de,df,aZ,ce,cf,cg,ch) = {
414+    let cs = bY(U, aZ, value(de).amount, value(de).assetId, value(df).amount, value(df).assetId, dd, false, ce, cf, cg, ch)
415+    let bJ = parseIntValue(cs._8)
416+    if (if (if (av())
417+        then true
418+        else (bJ == l))
419+        then true
420+        else (bJ == n))
421+        then throw(("Blocked:" + toString(bJ)))
422+        else cs
423+    }
424+
425+
426+func dg () = {
427+    let an = getString(M())
428+    if ($isInstanceOf(an, "String"))
429+        then {
430+            let dh = an
431+            fromBase58String(dh)
432+            }
433+        else if ($isInstanceOf(an, "Unit"))
434+            then unit
435+            else throw("Match error")
436+    }
437+
438+
439+func di () = {
440+    let an = getString(N())
441+    if ($isInstanceOf(an, "String"))
442+        then {
443+            let dh = an
444+            fromBase58String(dh)
445+            }
446+        else if ($isInstanceOf(an, "Unit"))
447+            then unit
448+            else throw("Match error")
449+    }
450+
451+
452+func dj (da) = {
453+    let dk = throw("Permission denied")
454+    let an = dg()
455+    if ($isInstanceOf(an, "ByteVector"))
456+        then {
457+            let dl = an
458+            if ((da.callerPublicKey == dl))
459+                then true
460+                else dk
461+            }
462+        else if ($isInstanceOf(an, "Unit"))
463+            then if ((da.caller == this))
464+                then true
465+                else dk
466+            else throw("Match error")
467+    }
468+
469+
470+@Callable(da)
471+func constructor (L) = {
472+    let dm = dj(da)
473+    if ((dm == dm))
474+        then [StringEntry(L(), L)]
475+        else throw("Strict value is not equal to itself.")
476+    }
477+
478+
479+
480+@Callable(da)
481+func setManager (dn) = {
482+    let dm = dj(da)
483+    if ((dm == dm))
484+        then {
485+            let do = fromBase58String(dn)
486+            if ((do == do))
487+                then [StringEntry(N(), dn)]
488+                else throw("Strict value is not equal to itself.")
489+            }
490+        else throw("Strict value is not equal to itself.")
491+    }
492+
493+
494+
495+@Callable(da)
496+func confirmManager () = {
497+    let by = di()
498+    let dp = if (isDefined(by))
499+        then true
500+        else throw("No pending manager")
501+    if ((dp == dp))
502+        then {
503+            let dq = if ((da.callerPublicKey == value(by)))
504+                then true
505+                else throw("You are not pending manager")
506+            if ((dq == dq))
507+                then [StringEntry(M(), toBase58String(value(by))), DeleteEntry(N())]
508+                else throw("Strict value is not equal to itself.")
509+            }
510+        else throw("Strict value is not equal to itself.")
511+    }
512+
513+
514+
515+@Callable(da)
516+func put (dr,ds) = {
517+    let dt = aB()
518+    let du = valueOrErrorMessage(addressFromString(dt[x]), "Wr st addr")
519+    let dv = valueOrErrorMessage(addressFromString(dt[y]), "Wr sl addr")
520+    if ((0 > dr))
521+        then throw("Wrong slippage")
522+        else if ((size(da.payments) != 2))
523+            then throw("2 pmnts expd")
524+            else {
525+                let dw = dc(toString(da.caller), toBase58String(da.transactionId), AttachedPayment(value(da.payments[0]).assetId, value(da.payments[0]).amount), da.payments[1], dr, true, false, 0, "")
526+                let cF = dw._2
527+                let dx = dw._7
528+                let bX = dw._9
529+                let cG = dw._10
530+                let cH = dw._11
531+                let bF = dw._12
532+                let bG = dw._13
533+                let cs = invoke(at, "emit", [cF], nil)
534+                if ((cs == cs))
535+                    then {
536+                        let dy = {
537+                            let an = cs
538+                            if ($isInstanceOf(an, "Address"))
539+                                then {
540+                                    let dz = an
541+                                    invoke(dz, "emit", [cF], nil)
542+                                    }
543+                                else unit
544+                            }
545+                        if ((dy == dy))
546+                            then {
547+                                let dA = if ((cG > 0))
548+                                    then invoke(dv, "put", nil, [AttachedPayment(bF, cG)])
549+                                    else nil
550+                                if ((dA == dA))
551+                                    then {
552+                                        let dB = if ((cH > 0))
553+                                            then invoke(dv, "put", nil, [AttachedPayment(bG, cH)])
554+                                            else nil
555+                                        if ((dB == dB))
556+                                            then {
557+                                                let dC = if (ds)
558+                                                    then {
559+                                                        let dD = invoke(du, "stake", nil, [AttachedPayment(dx, cF)])
560+                                                        if ((dD == dD))
561+                                                            then nil
562+                                                            else throw("Strict value is not equal to itself.")
563+                                                        }
564+                                                    else [ScriptTransfer(da.caller, cF, dx)]
565+                                                (bX ++ dC)
566+                                                }
567+                                            else throw("Strict value is not equal to itself.")
568+                                        }
569+                                    else throw("Strict value is not equal to itself.")
570+                                }
571+                            else throw("Strict value is not equal to itself.")
572+                        }
573+                    else throw("Strict value is not equal to itself.")
574+                }
575+    }
576+
577+
578+
579+@Callable(da)
580+func putOneTkn (dE,dF,dG,aZ,ds) = {
581+    let bq = aB()
582+    let du = valueOrErrorMessage(addressFromString(bq[x]), "Wr st addr")
583+    let dv = valueOrErrorMessage(addressFromString(bq[y]), "Wr sl addr")
584+    let dH = valueOrErrorMessage(addressFromString(bq[z]), "Wr gwx addr")
585+    let dI = ax()
586+    let bF = dI[r]
587+    let bG = dI[s]
588+    let bH = parseIntValue(dI[t])
589+    let bI = parseIntValue(dI[u])
590+    if (if (if (if ((0 >= aZ))
591+        then true
592+        else (0 >= dE))
593+        then true
594+        else (0 >= dF))
595+        then true
596+        else (0 >= dG))
597+        then throw("Wrong params")
598+        else if ((size(da.payments) != 1))
599+            then throw("1 pmnt expd")
600+            else {
601+                let db = value(da.payments[0])
602+                let bB = toBase58String(value(db.assetId))
603+                let cg = db.amount
604+                if (if (if ((dE > cg))
605+                    then true
606+                    else (dF > cg))
607+                    then true
608+                    else (10000000 > cg))
609+                    then throw("Wrong pmt amt")
610+                    else {
611+                        let bL = aR(bF)
612+                        let bN = aR(bG)
613+                        let dJ = if ((bB == bF))
614+                            then $Tuple6((bL - cg), bN, (cg - dE), dF, 0, 0)
615+                            else if ((bB == bG))
616+                                then $Tuple6(bL, (bN - cg), 0, 0, (cg - dF), dE)
617+                                else throw("wrong pmtAssetId")
618+                        let dK = dJ._1
619+                        let dL = dJ._2
620+                        let dM = dJ._3
621+                        let dN = dJ._4
622+                        let dO = dJ._5
623+                        let dP = dJ._6
624+                        let be = invoke(dH, "calcD", [toString(dK), toString(dL), au, g, h], nil)
625+                        let bd = invoke(dH, "calcD", [toString(toBigInt(((dK + dM) - dP))), toString(toBigInt(((dL + dO) - dN))), au, g, h], nil)
626+                        let dQ = bc(parseBigIntValue(am(bd)), parseBigIntValue(am(be)), f)
627+                        if ((dQ == dQ))
628+                            then {
629+                                let dR = dc(toString(da.caller), toBase58String(da.transactionId), AttachedPayment(fromBase58String(bF), dE), AttachedPayment(fromBase58String(bG), dF), aZ, true, true, cg, bB)
630+                                let dS = dR._2
631+                                let dx = dR._7
632+                                let bX = dR._9
633+                                let cG = dR._10
634+                                let cH = dR._11
635+                                let dT = aW(toBigInt(dS), toBigInt(dG), toBigInt(aZ))
636+                                let cF = toInt(dT._2)
637+                                let dw = invoke(at, "emit", [cF], nil)
638+                                if ((dw == dw))
639+                                    then {
640+                                        let dy = {
641+                                            let an = dw
642+                                            if ($isInstanceOf(an, "Address"))
643+                                                then {
644+                                                    let dz = an
645+                                                    invoke(dz, "emit", [cF], nil)
646+                                                    }
647+                                                else unit
648+                                            }
649+                                        if ((dy == dy))
650+                                            then {
651+                                                let dA = if ((cG > 0))
652+                                                    then invoke(dv, "put", nil, [AttachedPayment(fromBase58String(bF), cG)])
653+                                                    else nil
654+                                                if ((dA == dA))
655+                                                    then {
656+                                                        let dB = if ((cH > 0))
657+                                                            then invoke(dv, "put", nil, [AttachedPayment(fromBase58String(bG), cH)])
658+                                                            else nil
659+                                                        if ((dB == dB))
660+                                                            then {
661+                                                                let dC = if (ds)
662+                                                                    then {
663+                                                                        let dD = invoke(du, "stake", nil, [AttachedPayment(dx, cF)])
664+                                                                        if ((dD == dD))
665+                                                                            then nil
666+                                                                            else throw("Strict value is not equal to itself.")
667+                                                                        }
668+                                                                    else [ScriptTransfer(da.caller, cF, dx)]
669+                                                                (bX ++ dC)
670+                                                                }
671+                                                            else throw("Strict value is not equal to itself.")
672+                                                        }
673+                                                    else throw("Strict value is not equal to itself.")
674+                                                }
675+                                            else throw("Strict value is not equal to itself.")
676+                                        }
677+                                    else throw("Strict value is not equal to itself.")
678+                                }
679+                            else throw("Strict value is not equal to itself.")
680+                        }
681+                }
682+    }
683+
684+
685+
686+@Callable(da)
687+func putForFree (dU) = if ((0 > dU))
688+    then throw("Wrong slpg")
689+    else if ((size(da.payments) != 2))
690+        then throw("2 pmnts expd")
691+        else {
692+            let dR = dc(toString(da.caller), toBase58String(da.transactionId), AttachedPayment(value(da.payments[0]).assetId, value(da.payments[0]).amount), da.payments[1], dU, false, false, 0, "")
693+            dR._9
694+            }
695+
696+
697+
698+@Callable(da)
699+func get () = {
700+    let cs = cZ(da)
701+    let dV = cs._1
702+    let bW = cs._2
703+    let cg = cs._3
704+    let bB = cs._4
705+    let bX = cs._5
706+    let dW = invoke(at, "burn", [cg], [AttachedPayment(bB, cg)])
707+    if ((dW == dW))
708+        then bX
709+        else throw("Strict value is not equal to itself.")
710+    }
711+
712+
713+
714+@Callable(da)
715+func getOneTkn (dX,dY,dZ,ea,aZ) = if ((size(da.payments) != 1))
716+    then throw("1 pmnt expd")
717+    else {
718+        let bq = ax()
719+        let bE = bq[q]
720+        let bF = bq[r]
721+        let bG = bq[s]
722+        let bH = parseIntValue(bq[t])
723+        let bI = parseIntValue(bq[u])
724+        let bJ = bq[p]
725+        let dt = aB()
726+        let dH = valueOrErrorMessage(addressFromString(dt[z]), "Wr sl addr")
727+        let db = value(da.payments[0])
728+        let eb = valueOrElse(getString(this, Z()), "")
729+        let bD = if ((eb == toString(da.caller)))
730+            then da.originCaller
731+            else da.caller
732+        let bA = toBase58String(da.transactionId)
733+        let bB = value(db.assetId)
734+        let cg = db.amount
735+        if ((1000000000 > cg))
736+            then throw("Min pmt 10 LP")
737+            else if (if (if ((0 > aZ))
738+                then true
739+                else (0 > dX))
740+                then true
741+                else (0 > dZ))
742+                then throw("Wrong params")
743+                else if ((bE != toBase58String(bB)))
744+                    then throw("Wrong LP")
745+                    else {
746+                        let cs = bz(toBase58String(da.transactionId), toBase58String(bB), cg, da.caller)
747+                        let ec = cs._1
748+                        let ed = cs._2
749+                        let bL = aR(bF)
750+                        let bN = aR(bG)
751+                        let ee = if ((ea == bF))
752+                            then $Tuple7((bL - ec), (bN - ed), dX, ed, 0, 0, (ec + dX))
753+                            else if ((ea == bG))
754+                                then $Tuple7((bL - ec), (bN - ed), 0, 0, dX, ec, (ed + dX))
755+                                else throw("wrong outAssetId")
756+                        let dK = ee._1
757+                        let dL = ee._2
758+                        let dM = ee._3
759+                        let dN = ee._4
760+                        let dO = ee._5
761+                        let dP = ee._6
762+                        let ef = ee._7
763+                        if (if ((0 > dM))
764+                            then true
765+                            else (0 > dO))
766+                            then throw("Wrong calc")
767+                            else {
768+                                let be = invoke(dH, "calcD", [toString(dK), toString(dL), au, g, h], nil)
769+                                let bd = invoke(dH, "calcD", [toString(((dK - dM) + dP)), toString(((dL + dN) - dO)), au, g, h], nil)
770+                                let dQ = bc(parseBigIntValue(am(bd)), parseBigIntValue(am(be)), f)
771+                                if ((dQ == dQ))
772+                                    then {
773+                                        let eg = aW(toBigInt(ef), toBigInt(dZ), toBigInt(aZ))
774+                                        if ((eg == eg))
775+                                            then {
776+                                                let eh = if ((ea == bF))
777+                                                    then $Tuple2(toInt(eg._2), 0)
778+                                                    else $Tuple2(0, toInt(eg._2))
779+                                                let ei = eh._1
780+                                                let ej = eh._2
781+                                                let ek = aT(A(bN, bI), A(bL, bH))
782+                                                let el = D(ek, a)
783+                                                let bX = [ScriptTransfer(bD, (ei + ej), if ((ea == "WAVES"))
784+                                                    then unit
785+                                                    else fromBase58String(ea)), StringEntry(V(toString(bD), bA), aN(ei, ej, cg, el, height, lastBlock.timestamp)), IntegerEntry(O(), el), IntegerEntry(P(height, lastBlock.timestamp), el)]
786+                                                if ((bX == bX))
787+                                                    then {
788+                                                        let em = invoke(at, "burn", [cg], [AttachedPayment(bB, cg)])
789+                                                        if ((em == em))
790+                                                            then bX
791+                                                            else throw("Strict value is not equal to itself.")
792+                                                        }
793+                                                    else throw("Strict value is not equal to itself.")
794+                                                }
795+                                            else throw("Strict value is not equal to itself.")
796+                                        }
797+                                    else throw("Strict value is not equal to itself.")
798+                                }
799+                        }
800+        }
801+
802+
803+
804+@Callable(da)
805+func getNoLess (en,eo) = {
806+    let cs = cZ(da)
807+    let bV = cs._1
808+    let bW = cs._2
809+    let cg = cs._3
810+    let bB = cs._4
811+    let bX = cs._5
812+    if ((en > bV))
813+        then throw(((("Failed:  " + toString(bV)) + " < ") + toString(en)))
814+        else if ((eo > bW))
815+            then throw(((("Failed: " + toString(bW)) + " < ") + toString(eo)))
816+            else {
817+                let ep = invoke(at, "burn", [cg], [AttachedPayment(bB, cg)])
818+                if ((ep == ep))
819+                    then bX
820+                    else throw("Strict value is not equal to itself.")
821+                }
822+    }
823+
824+
825+
826+@Callable(da)
827+func unstakeAndGet (eq) = {
828+    let er = if ((size(da.payments) != 0))
829+        then throw("No pmnts expd")
830+        else true
831+    if ((er == er))
832+        then {
833+            let bq = ax()
834+            let es = aB()
835+            let dx = fromBase58String(bq[q])
836+            let et = valueOrErrorMessage(addressFromString(es[x]), "Wr st addr")
837+            let eu = invoke(et, "unstake", [toBase58String(dx), eq], nil)
838+            if ((eu == eu))
839+                then {
840+                    let cs = bz(toBase58String(da.transactionId), toBase58String(dx), eq, da.caller)
841+                    let bJ = parseIntValue(cs._9)
842+                    let bX = cs._10
843+                    let ev = if (if (av())
844+                        then true
845+                        else (bJ == n))
846+                        then throw(("Blocked: " + toString(bJ)))
847+                        else true
848+                    if ((ev == ev))
849+                        then {
850+                            let ew = invoke(at, "burn", [eq], [AttachedPayment(dx, eq)])
851+                            if ((ew == ew))
852+                                then bX
853+                                else throw("Strict value is not equal to itself.")
854+                            }
855+                        else throw("Strict value is not equal to itself.")
856+                    }
857+                else throw("Strict value is not equal to itself.")
858+            }
859+        else throw("Strict value is not equal to itself.")
860+    }
861+
862+
863+
864+@Callable(da)
865+func activate (ex,ey) = if ((toString(da.caller) != toString(at)))
866+    then throw("denied")
867+    else $Tuple2([StringEntry(W(), ex), StringEntry(X(), ey)], "success")
868+
869+
870+
871+@Callable(da)
872+func getPoolConfigWrapperREADONLY () = $Tuple2(nil, ax())
873+
874+
875+
876+@Callable(da)
877+func getAccBalanceWrapperREADONLY (aS) = $Tuple2(nil, aR(aS))
878+
879+
880+
881+@Callable(da)
882+func calcPricesWrapperREADONLY (bk,bl,bp) = {
883+    let ez = bo(bk, bl, bp)
884+    $Tuple2(nil, [toString(ez[0]), toString(ez[1]), toString(ez[2])])
885+    }
886+
887+
888+
889+@Callable(da)
890+func fromX18WrapperREADONLY (E,eA) = $Tuple2(nil, D(parseBigIntValue(E), eA))
891+
892+
893+
894+@Callable(da)
895+func toX18WrapperREADONLY (B,C) = $Tuple2(nil, toString(A(B, C)))
896+
897+
898+
899+@Callable(da)
900+func calcPriceBigIntWrapperREADONLY (aU,aV) = $Tuple2(nil, toString(aT(parseBigIntValue(aU), parseBigIntValue(aV))))
901+
902+
903+
904+@Callable(da)
905+func estimatePutOperationWrapperREADONLY (bA,aZ,bZ,ca,cb,cc,eB,cd,ce) = $Tuple2(nil, bY(bA, aZ, bZ, ca, cb, cc, eB, cd, ce, false, 0, ""))
906+
907+
908+
909+@Callable(da)
910+func estimateGetOperationWrapperREADONLY (bA,eC,bC,eB) = {
911+    let cs = bz(bA, eC, bC, addressFromStringValue(eB))
912+    $Tuple2(nil, $Tuple10(cs._1, cs._2, cs._3, cs._4, cs._5, cs._6, cs._7, toString(cs._8), cs._9, cs._10))
913+    }
914+
915+
916+@Verifier(eD)
917+func eE () = {
918+    let an = eD
919+    if ($isInstanceOf(an, "Order"))
920+        then {
921+            let cN = an
922+            let eF = aw()
923+            let aj = cM(cN)
924+            let eG = sigVerify(cN.bodyBytes, cN.proofs[0], cN.senderPublicKey)
925+            let eH = sigVerify(cN.bodyBytes, cN.proofs[1], eF)
926+            if (if (if (aj)
927+                then eG
928+                else false)
929+                then eH
930+                else false)
931+                then true
932+                else ai(aj, eG, eH)
933+            }
934+        else {
935+            let eI = {
936+                let eJ = dg()
937+                if ($isInstanceOf(eJ, "ByteVector"))
938+                    then {
939+                        let dl = eJ
940+                        dl
941+                        }
942+                    else if ($isInstanceOf(eJ, "Unit"))
943+                        then eD.senderPublicKey
944+                        else throw("Match error")
945+                }
946+            sigVerify(eD.bodyBytes, eD.proofs[0], eI)
947+            }
948+    }
949+
github/deemru/w8io/026f985 
44.71 ms ◑