2022.03.24 18:09 [3043351] smart account 3P8w8NXZUtYdCA13tHbDY5sW4mC27ZFJgG3 > SELF 0.00000000 Waves

{ "type": 13, "id": "SHdwwLzT21iRycAVxXpcdJKg8Z4o7GXr1XRqTEN4irL", "fee": 14000000, "feeAssetId": null, "timestamp": 1648138095851, "version": 1, "sender": "3P8w8NXZUtYdCA13tHbDY5sW4mC27ZFJgG3", "senderPublicKey": "6uKJV5r5qjqG9uVK4Q24W7zG5KZtGtKXz3NWRMwfZbB7", "proofs": [ "3uvstaQzj4HU8qmSeG8qxFGLt5qF8W87nLFWczEBs8YE5NpzjfY5G2qbsGnPbGFsN4M2wgKYfBQFiwmzxYRz9JGn" ], "script": "base64:AAIFAAAAAAAAACAIAhIHCgUICAEBCBIAEgMKAQESABIAEgMKAQgSAwoBCAAAADUAAAAAC3JldmlzaW9uTnVtAgAAACg0NDNjNjRkZDUwNTZiNWJlMjNiNzAwMjI0Njk5Mjk1ZTczM2UwNDUyAAAAAAlzZXBhcmF0b3ICAAAAAl9fAAAAAAVNVUxUNgAAAAAAAA9CQAAAAAAFTVVMVDgAAAAAAAX14QAAAAAABk1VTFRYNgkAATYAAAABBQAAAAVNVUxUNgAAAAAGTVVMVFg4CQABNgAAAAEFAAAABU1VTFQ4AAAAAAdNVUxUWDE4CQABNgAAAAEADeC2s6dkAAAAAAAACldBVkVTSURTVFICAAAABVdBVkVTAAAAAAdXQVZFU0lECQACWQAAAAEFAAAACldBVkVTSURTVFIBAAAADGtleUJvbmRBc3NldAAAAAACAAAADWJvbmRfYXNzZXRfaWQBAAAAGWtleUF1Y3Rpb25Db250cmFjdEFkZHJlc3MAAAAAAgAAABBhdWN0aW9uX2NvbnRyYWN0AQAAABprZXlOZXV0cmlub0NvbnRyYWN0QWRkcmVzcwAAAAACAAAAGyVzX19uZXV0cmlub0NvbnRyYWN0QWRkcmVzcwEAAAAWa2V5TWF0aENvbnRyYWN0QWRkcmVzcwAAAAACAAAAECVzX19tYXRoQ29udHJhY3QBAAAAEGtleU1pbkxvY2tBbW91bnQAAAAAAgAAABElc19fbWluTG9ja0Ftb3VudAEAAAALa2V5SGFsZkxpZmUAAAAAAgAAAAwlc19faGFsZkxpZmUBAAAAFmtleUxvY2tQYXJhbVVzZXJBbW91bnQAAAABAAAAC3VzZXJBZGRyZXNzCQAEuQAAAAIJAARMAAAAAgIAAAAGJXMlcyVzCQAETAAAAAICAAAAC3BhcmFtQnlVc2VyCQAETAAAAAIJAAQlAAAAAQUAAAALdXNlckFkZHJlc3MJAARMAAAAAgIAAAAGYW1vdW50BQAAAANuaWwFAAAACXNlcGFyYXRvcgEAAAAWa2V5TG9ja1BhcmFtU3RhcnRCbG9jawAAAAEAAAALdXNlckFkZHJlc3MJAAS5AAAAAgkABEwAAAACAgAAAAYlcyVzJXMJAARMAAAAAgIAAAALcGFyYW1CeVVzZXIJAARMAAAAAgkABCUAAAABBQAAAAt1c2VyQWRkcmVzcwkABEwAAAACAgAAAAVzdGFydAUAAAADbmlsBQAAAAlzZXBhcmF0b3IBAAAAEGtleUhpc3RvcnlSZWNvcmQAAAADAAAABHR5cGUAAAALdXNlckFkZHJlc3MAAAAEdHhJZAkABLkAAAACCQAETAAAAAICAAAACCVzJXMlcyVzCQAETAAAAAICAAAAB2hpc3RvcnkJAARMAAAAAgUAAAAEdHlwZQkABEwAAAACCQAEJQAAAAEFAAAAC3VzZXJBZGRyZXNzCQAETAAAAAIJAAJYAAAAAQUAAAAEdHhJZAUAAAADbmlsBQAAAAlzZXBhcmF0b3IBAAAAF2tleUxvY2tQYXJhbVRvdGFsQW1vdW50AAAAAAkABLkAAAACCQAETAAAAAICAAAABCVzJXMJAARMAAAAAgIAAAAFc3RhdHMJAARMAAAAAgIAAAARYWN0aXZlVG90YWxMb2NrZWQFAAAAA25pbAUAAAAJc2VwYXJhdG9yAQAAABJrZXlTdGF0c0xvY2tzQ291bnQAAAAACQAEuQAAAAIJAARMAAAAAgIAAAAEJXMlcwkABEwAAAACAgAAAAVzdGF0cwkABEwAAAACAgAAAApsb2Nrc0NvdW50BQAAAANuaWwFAAAACXNlcGFyYXRvcgEAAAASa2V5U3RhdHNVc2Vyc0NvdW50AAAAAAkABLkAAAACCQAETAAAAAICAAAABCVzJXMJAARMAAAAAgIAAAAFc3RhdHMJAARMAAAAAgIAAAAQYWN0aXZlVXNlcnNDb3VudAUAAAADbmlsBQAAAAlzZXBhcmF0b3IBAAAADWtleU5leHRQZXJpb2QAAAAAAgAAAA4lc19fbmV4dFBlcmlvZAEAAAAYa2V5U3VwcG9ydGVkUmV3YXJkQXNzZXRzAAAAAAIAAAAVc3VwcG9ydGVkUmV3YXJkQXNzZXRzAQAAABFrZXlEZXBvc2l0TnVtTGFzdAAAAAAJAAS5AAAAAgkABEwAAAACAgAAAAYlcyVzJXMJAARMAAAAAgIAAAADZGVwCQAETAAAAAICAAAAB2xhc3ROdW0FAAAAA25pbAUAAAAJc2VwYXJhdG9yAQAAABtrZXlVc2VyUmV3YXJkRnJvbURlcG9zaXROdW0AAAABAAAAC3VzZXJBZGRyZXNzCQAEuQAAAAIJAARMAAAAAgIAAAAGJXMlcyVzCQAETAAAAAICAAAAEXVzZXJSd2RGcm9tRGVwTnVtCQAETAAAAAIFAAAAC3VzZXJBZGRyZXNzBQAAAANuaWwFAAAACXNlcGFyYXRvcgEAAAAVa2V5UmV3YXJkUGVyTnNidFN1bUF0AAAAAgAAAApkZXBvc2l0TnVtAAAAA3RrbgkABLkAAAACCQAETAAAAAICAAAABCVzJWQJAARMAAAAAgIAAAAVcndkUGVyTnNidFN1bUJ5RGVwTnVtCQAETAAAAAIJAAGkAAAAAQUAAAAKZGVwb3NpdE51bQkABEwAAAACBQAAAAN0a24FAAAAA25pbAUAAAAJc2VwYXJhdG9yAQAAAAlrZXlSZXdhcmQAAAACAAAAC3VzZXJBZGRyZXNzAAAAA3RrbgkABLkAAAACCQAETAAAAAICAAAABiVzJXMlcwkABEwAAAACAgAAAANyd2QJAARMAAAAAgUAAAALdXNlckFkZHJlc3MJAARMAAAAAgUAAAADdGtuBQAAAANuaWwFAAAACXNlcGFyYXRvcgEAAAAKa2V5Q2xhaW1lZAAAAAIAAAALdXNlckFkZHJlc3MAAAADdGtuCQAEuQAAAAIJAARMAAAAAgIAAAAGJXMlcyVzCQAETAAAAAICAAAAA2NsbQkABEwAAAACBQAAAAt1c2VyQWRkcmVzcwkABEwAAAACBQAAAAN0a24FAAAAA25pbAUAAAAJc2VwYXJhdG9yAQAAABdrZXlOb3REaXN0cmlidXRlZFJld2FyZAAAAAEAAAADdGtuCQAEuQAAAAIJAARMAAAAAgIAAAAEJXMlcwkABEwAAAACAgAAAA5ub3REaXN0cmlidXRlZAkABEwAAAACBQAAAAN0a24FAAAAA25pbAUAAAAJc2VwYXJhdG9yAQAAAAV0b1gxOAAAAAIAAAAHb3JpZ1ZhbAAAAAhvcmlnTXVsdAkAATwAAAADCQABNgAAAAEFAAAAB29yaWdWYWwFAAAAB01VTFRYMTgFAAAACG9yaWdNdWx0AQAAAAxnZXRJbnRPclplcm8AAAABAAAAA2tleQkBAAAAC3ZhbHVlT3JFbHNlAAAAAgkABBoAAAACBQAAAAR0aGlzBQAAAANrZXkAAAAAAAAAAAABAAAADGdldEludE9yRWxzZQAAAAIAAAADa2V5AAAACmRlZmF1bHRWYWwJAQAAAAt2YWx1ZU9yRWxzZQAAAAIJAAQaAAAAAgUAAAAEdGhpcwUAAAADa2V5BQAAAApkZWZhdWx0VmFsAQAAAAxnZXRJbnRPckZhaWwAAAABAAAAA2tleQkBAAAAE3ZhbHVlT3JFcnJvck1lc3NhZ2UAAAACCQAEGgAAAAIFAAAABHRoaXMFAAAAA2tleQkAASwAAAACCQABLAAAAAICAAAAD01hbmRhdG9yeSB0aGlzLgUAAAADa2V5AgAAAA8gaXMgbm90IGRlZmluZWQBAAAADGdldFN0ck9yRWxzZQAAAAIAAAADa2V5AAAACmRlZmF1bHRWYWwJAQAAAAt2YWx1ZU9yRWxzZQAAAAIJAAQdAAAAAgUAAAAEdGhpcwUAAAADa2V5BQAAAApkZWZhdWx0VmFsAQAAAA9nZXRTdHJpbmdPckZhaWwAAAABAAAAA2tleQkBAAAAE3ZhbHVlT3JFcnJvck1lc3NhZ2UAAAACCQAEHQAAAAIFAAAABHRoaXMFAAAAA2tleQkAASwAAAACCQABLAAAAAICAAAAD01hbmRhdG9yeSB0aGlzLgUAAAADa2V5AgAAAA8gaXMgbm90IGRlZmluZWQBAAAAD3RvQWRkcmVzc09yRmFpbAAAAAEAAAAKYWRkcmVzc1N0cgkBAAAAE3ZhbHVlT3JFcnJvck1lc3NhZ2UAAAACCQAEJgAAAAEFAAAACmFkZHJlc3NTdHIJAAEsAAAAAgIAAAAhY291bGRuJ3QgcGFyc2UgcGFzc2VkIGFkZHJlc3NTdHI9BQAAAAphZGRyZXNzU3RyAQAAAAt0b0Fzc2V0VmVjdAAAAAEAAAAIYXNzZXRTdHIDCQAAAAAAAAIFAAAACGFzc2V0U3RyBQAAAApXQVZFU0lEU1RSBQAAAAR1bml0CQACWQAAAAEFAAAACGFzc2V0U3RyAQAAAAVhc0ludAAAAAEAAAADdmFsBAAAAAckbWF0Y2gwBQAAAAN2YWwDCQAAAQAAAAIFAAAAByRtYXRjaDACAAAAA0ludAQAAAAGdmFsSW50BQAAAAckbWF0Y2gwBQAAAAZ2YWxJbnQJAAACAAAAAQIAAAAVZmFpbCB0byBjYXN0IGludG8gSW50AQAAABNmb3JtYXRIaXN0b3J5UmVjb3JkAAAABAAAAAlvbGRBbW91bnQAAAAIb2xkU3RhcnQAAAAJbmV3QW1vdW50AAAACG5ld1N0YXJ0CQAEuQAAAAIJAARMAAAAAgIAAAAMJWQlZCVkJWQlZCVkCQAETAAAAAIJAAGkAAAAAQgFAAAACWxhc3RCbG9jawAAAAZoZWlnaHQJAARMAAAAAgkAAaQAAAABCAUAAAAJbGFzdEJsb2NrAAAACXRpbWVzdGFtcAkABEwAAAACCQABpAAAAAEFAAAACW9sZEFtb3VudAkABEwAAAACCQABpAAAAAEFAAAACG9sZFN0YXJ0CQAETAAAAAIJAAGkAAAAAQUAAAAJbmV3QW1vdW50CQAETAAAAAIJAAGkAAAAAQUAAAAIbmV3U3RhcnQFAAAAA25pbAUAAAAJc2VwYXJhdG9yAQAAABhmb3JtYXRDbGFpbUhpc3RvcnlSZWNvcmQAAAACAAAABHVzZXIAAAAOY2xhaW1lZFJld2FyZHMJAAS5AAAAAgkABEwAAAACAgAAAAglcyVkJWQlcwkABEwAAAACBQAAAAR1c2VyCQAETAAAAAIJAAGkAAAAAQgFAAAACWxhc3RCbG9jawAAAAZoZWlnaHQJAARMAAAAAgkAAaQAAAABCAUAAAAJbGFzdEJsb2NrAAAACXRpbWVzdGFtcAkABEwAAAACBQAAAA5jbGFpbWVkUmV3YXJkcwUAAAADbmlsBQAAAAlzZXBhcmF0b3IBAAAAEkhpc3RvcnlSZWNvcmRFbnRyeQAAAAcAAAAEdHlwZQAAAAt1c2VyQWRkcmVzcwAAAAR0eElkAAAACW9sZEFtb3VudAAAAAhvbGRTdGFydAAAAAluZXdBbW91bnQAAAAIbmV3U3RhcnQJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAABBrZXlIaXN0b3J5UmVjb3JkAAAAAwUAAAAEdHlwZQUAAAALdXNlckFkZHJlc3MFAAAABHR4SWQJAQAAABNmb3JtYXRIaXN0b3J5UmVjb3JkAAAABAUAAAAJb2xkQW1vdW50BQAAAAhvbGRTdGFydAUAAAAJbmV3QW1vdW50BQAAAAhuZXdTdGFydAEAAAARQ2xhaW1IaXN0b3J5RW50cnkAAAADAAAAC3VzZXJBZGRyZXNzAAAABHR4SWQAAAAOY2xhaW1lZFJld2FyZHMJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAABBrZXlIaXN0b3J5UmVjb3JkAAAAAwIAAAAFY2xhaW0FAAAAC3VzZXJBZGRyZXNzBQAAAAR0eElkCQEAAAAYZm9ybWF0Q2xhaW1IaXN0b3J5UmVjb3JkAAAAAgkABCUAAAABBQAAAAt1c2VyQWRkcmVzcwUAAAAOY2xhaW1lZFJld2FyZHMBAAAAC1N0YXRzUmVzdWx0AAAAAwAAAA50b3RhbExvY2tlZEluYwAAAAxsb2NrQ291bnRJbmMAAAANdXNlcnNDb3VudEluYwQAAAAKbG9ja3NDb3VudAkBAAAADGdldEludE9yWmVybwAAAAEJAQAAABJrZXlTdGF0c0xvY2tzQ291bnQAAAAABAAAAAp1c2Vyc0NvdW50CQEAAAAMZ2V0SW50T3JaZXJvAAAAAQkBAAAAEmtleVN0YXRzVXNlcnNDb3VudAAAAAAEAAAAC3RvdGFsQW1vdW50CQEAAAAMZ2V0SW50T3JaZXJvAAAAAQkBAAAAF2tleUxvY2tQYXJhbVRvdGFsQW1vdW50AAAAAAQAAAAOdG90YWxBbW91bnROZXcJAABkAAAAAgUAAAALdG90YWxBbW91bnQFAAAADnRvdGFsTG9ja2VkSW5jCQAFFQAAAAMJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIJAQAAABJrZXlTdGF0c0xvY2tzQ291bnQAAAAACQAAZAAAAAIFAAAACmxvY2tzQ291bnQFAAAADGxvY2tDb3VudEluYwkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgkBAAAAEmtleVN0YXRzVXNlcnNDb3VudAAAAAAJAABkAAAAAgUAAAAKdXNlcnNDb3VudAUAAAANdXNlcnNDb3VudEluYwkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgkBAAAAF2tleUxvY2tQYXJhbVRvdGFsQW1vdW50AAAAAAUAAAAOdG90YWxBbW91bnROZXcFAAAAA25pbAUAAAALdG90YWxBbW91bnQFAAAADnRvdGFsQW1vdW50TmV3AQAAAA9Mb2NrUGFyYW1zRW50cnkAAAADAAAAC3VzZXJBZGRyZXNzAAAABmFtb3VudAAAAAVzdGFydAkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgkBAAAAFmtleUxvY2tQYXJhbVVzZXJBbW91bnQAAAABBQAAAAt1c2VyQWRkcmVzcwUAAAAGYW1vdW50CQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACCQEAAAAWa2V5TG9ja1BhcmFtU3RhcnRCbG9jawAAAAEFAAAAC3VzZXJBZGRyZXNzBQAAAAVzdGFydAUAAAADbmlsAQAAAA9nZXRQYXJhbXNPckZhaWwAAAAABAAAABBuZXV0cmlub0NvbnRyYWN0CQEAAAARQGV4dHJOYXRpdmUoMTA2MikAAAABCQEAAAAPZ2V0U3RyaW5nT3JGYWlsAAAAAQkBAAAAGmtleU5ldXRyaW5vQ29udHJhY3RBZGRyZXNzAAAAAAkABRYAAAAECQACWQAAAAEJAQAAABFAZXh0ck5hdGl2ZSgxMDUzKQAAAAIFAAAAEG5ldXRyaW5vQ29udHJhY3QJAQAAABlrZXlBdWN0aW9uQ29udHJhY3RBZGRyZXNzAAAAAAkAAlkAAAABCQEAAAARQGV4dHJOYXRpdmUoMTA1MykAAAACBQAAABBuZXV0cmlub0NvbnRyYWN0CQEAAAAMa2V5Qm9uZEFzc2V0AAAAAAkBAAAADGdldEludE9yRmFpbAAAAAEJAQAAABBrZXlNaW5Mb2NrQW1vdW50AAAAAAkBAAAADGdldEludE9yRmFpbAAAAAEJAQAAAAtrZXlIYWxmTGlmZQAAAAABAAAADGlzQWN0aXZlVXNlcgAAAAEAAAALdXNlckFkZHJlc3MJAABmAAAAAgkBAAAADGdldEludE9yRWxzZQAAAAIJAQAAABZrZXlMb2NrUGFyYW1Vc2VyQW1vdW50AAAAAQUAAAALdXNlckFkZHJlc3MAAAAAAAAAAAAAAAAAAAAAAAABAAAAE2dldFVzZXJQYXJhbXNPclVuaXQAAAABAAAAC3VzZXJBZGRyZXNzAwkBAAAADGlzQWN0aXZlVXNlcgAAAAEFAAAAC3VzZXJBZGRyZXNzCQAFFQAAAAMHCQEAAAAMZ2V0SW50T3JGYWlsAAAAAQkBAAAAFmtleUxvY2tQYXJhbVVzZXJBbW91bnQAAAABBQAAAAt1c2VyQWRkcmVzcwkBAAAADGdldEludE9yRmFpbAAAAAEJAQAAABZrZXlMb2NrUGFyYW1TdGFydEJsb2NrAAAAAQUAAAALdXNlckFkZHJlc3MFAAAABHVuaXQBAAAAE2dldFVzZXJQYXJhbXNPckZhaWwAAAABAAAAC3VzZXJBZGRyZXNzCQEAAAATdmFsdWVPckVycm9yTWVzc2FnZQAAAAIJAQAAABNnZXRVc2VyUGFyYW1zT3JVbml0AAAAAQUAAAALdXNlckFkZHJlc3MJAAEsAAAAAgkAASwAAAACAgAAAAVVc2VyIAkABCUAAAABBQAAAAt1c2VyQWRkcmVzcwIAAAAPIGlzIG5vdCBkZWZpbmVkAAAAABJzdXBwb3J0ZWRBc3NldHNTdHIJAQAAAAxnZXRTdHJPckVsc2UAAAACCQEAAAAYa2V5U3VwcG9ydGVkUmV3YXJkQXNzZXRzAAAAAAIAAAAAAAAAABNzdXBwb3J0ZWRBc3NldHNMaXN0CQAEtQAAAAIFAAAAEnN1cHBvcnRlZEFzc2V0c1N0cgIAAAABXwEAAAAKY2FsY1Jld2FyZAAAAAUAAAALdXNlckFkZHJlc3MAAAAHYXNzZXRJZAAAAA1zdGFrZWRBbW91bnRYAAAADmRlcG9zaXROdW1Vc2VyAAAADmRlcG9zaXROdW1MYXN0BAAAABdyZXdhcmRQZXJOc2J0U3VtTGFzdEtFWQkBAAAAFWtleVJld2FyZFBlck5zYnRTdW1BdAAAAAIFAAAADmRlcG9zaXROdW1MYXN0BQAAAAdhc3NldElkBAAAAApzdW1MYXN0WDE4CQABpwAAAAEJAQAAAAxnZXRTdHJPckVsc2UAAAACCQEAAAAVa2V5UmV3YXJkUGVyTnNidFN1bUF0AAAAAgUAAAAOZGVwb3NpdE51bUxhc3QFAAAAB2Fzc2V0SWQCAAAAATAEAAAACnN1bVVzZXJYMTgJAAGnAAAAAQkBAAAADGdldFN0ck9yRWxzZQAAAAIJAQAAABVrZXlSZXdhcmRQZXJOc2J0U3VtQXQAAAACBQAAAA5kZXBvc2l0TnVtVXNlcgUAAAAHYXNzZXRJZAIAAAABMAQAAAARcmV3YXJkRHluYW1pY1BhcnQJAAGgAAAAAQkAATwAAAADCQABOAAAAAIFAAAACnN1bUxhc3RYMTgFAAAACnN1bVVzZXJYMTgFAAAADXN0YWtlZEFtb3VudFgFAAAAB01VTFRYMTgEAAAAE3Jld2FyZENhY2hlZFBhcnRLRVkJAQAAAAlrZXlSZXdhcmQAAAACBQAAAAt1c2VyQWRkcmVzcwUAAAAHYXNzZXRJZAQAAAAQcmV3YXJkQ2FjaGVkUGFydAkBAAAADGdldEludE9yRWxzZQAAAAIFAAAAE3Jld2FyZENhY2hlZFBhcnRLRVkAAAAAAAAAAAAJAAUWAAAABAkAAGQAAAACBQAAABByZXdhcmRDYWNoZWRQYXJ0BQAAABFyZXdhcmREeW5hbWljUGFydAUAAAAQcmV3YXJkQ2FjaGVkUGFydAUAAAARcmV3YXJkRHluYW1pY1BhcnQFAAAAE3Jld2FyZENhY2hlZFBhcnRLRVkBAAAADVJld2FyZEVudHJpZXMAAAADAAAACWlzTmV3VXNlcgAAAAt1c2VyQWRkcmVzcwAAAAxzdGFrZWRBbW91bnQEAAAADXN0YWtlZEFtb3VudFgJAAE2AAAAAQUAAAAMc3Rha2VkQW1vdW50BAAAABt1c2VyUmV3YXJkRnJvbURlcG9zaXROdW1LRVkJAQAAABtrZXlVc2VyUmV3YXJkRnJvbURlcG9zaXROdW0AAAABBQAAAAt1c2VyQWRkcmVzcwQAAAAOZGVwb3NpdE51bVVzZXIJAQAAAAxnZXRJbnRPckVsc2UAAAACBQAAABt1c2VyUmV3YXJkRnJvbURlcG9zaXROdW1LRVkA//////////8EAAAADmRlcG9zaXROdW1MYXN0CQEAAAAMZ2V0SW50T3JFbHNlAAAAAgkBAAAAEWtleURlcG9zaXROdW1MYXN0AAAAAAD//////////woBAAAAG2ZvckVhY2hBc3NldENhY2hlVXNlclJld2FyZAAAAAIAAAAFYWNjdW0AAAAFYXNzZXQEAAAACyR0MDc0MDE3NTM2CQEAAAAKY2FsY1Jld2FyZAAAAAUFAAAAC3VzZXJBZGRyZXNzBQAAAAVhc3NldAUAAAANc3Rha2VkQW1vdW50WAUAAAAOZGVwb3NpdE51bVVzZXIFAAAADmRlcG9zaXROdW1MYXN0BAAAAAtyZXdhcmRUb3RhbAgFAAAACyR0MDc0MDE3NTM2AAAAAl8xBAAAAAZjYWNoZWQIBQAAAAskdDA3NDAxNzUzNgAAAAJfMgQAAAAHZHluYW1pYwgFAAAACyR0MDc0MDE3NTM2AAAAAl8zBAAAABNyZXdhcmRDYWNoZWRQYXJ0S0VZCAUAAAALJHQwNzQwMTc1MzYAAAACXzQJAARNAAAAAgUAAAAFYWNjdW0JAQAAAAxJbnRlZ2VyRW50cnkAAAACBQAAABNyZXdhcmRDYWNoZWRQYXJ0S0VZBQAAAAtyZXdhcmRUb3RhbAMDCQAAAAAAAAIFAAAADmRlcG9zaXROdW1MYXN0AP//////////CQAAAAAAAAIFAAAADmRlcG9zaXROdW1Vc2VyAP//////////BwUAAAADbmlsAwMJAAAAAAAAAgUAAAAOZGVwb3NpdE51bUxhc3QA//////////8JAABmAAAAAgUAAAAOZGVwb3NpdE51bVVzZXIA//////////8HCQAAAgAAAAECAAAAL2ludmFsaWQgZGVwb3NpdE51bUxhc3QgYW5kIGRlcG9zaXROdW1Vc2VyIHN0YXRlAwMJAABmAAAAAgUAAAAOZGVwb3NpdE51bUxhc3QA//////////8JAAAAAAAAAgUAAAAOZGVwb3NpdE51bVVzZXIA//////////8HAwUAAAAJaXNOZXdVc2VyCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACBQAAABt1c2VyUmV3YXJkRnJvbURlcG9zaXROdW1LRVkFAAAADmRlcG9zaXROdW1MYXN0BQAAAANuaWwJAARNAAAAAgoAAAAAAiRsBQAAABNzdXBwb3J0ZWRBc3NldHNMaXN0CgAAAAACJHMJAAGQAAAAAQUAAAACJGwKAAAAAAUkYWNjMAUAAAADbmlsCgEAAAAFJGYwXzEAAAACAAAAAiRhAAAAAiRpAwkAAGcAAAACBQAAAAIkaQUAAAACJHMFAAAAAiRhCQEAAAAbZm9yRWFjaEFzc2V0Q2FjaGVVc2VyUmV3YXJkAAAAAgUAAAACJGEJAAGRAAAAAgUAAAACJGwFAAAAAiRpCgEAAAAFJGYwXzIAAAACAAAAAiRhAAAAAiRpAwkAAGcAAAACBQAAAAIkaQUAAAACJHMFAAAAAiRhCQAAAgAAAAECAAAAFExpc3Qgc2l6ZSBleGNlZWRzIDEwCQEAAAAFJGYwXzIAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACBQAAAAUkYWNjMAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAgAAAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABQAAAAAAAAAABgAAAAAAAAAABwAAAAAAAAAACAAAAAAAAAAACQAAAAAAAAAACgkBAAAADEludGVnZXJFbnRyeQAAAAIFAAAAG3VzZXJSZXdhcmRGcm9tRGVwb3NpdE51bUtFWQUAAAAOZGVwb3NpdE51bUxhc3QDAwkAAGYAAAACBQAAAA5kZXBvc2l0TnVtTGFzdAD//////////wkAAGYAAAACBQAAAA5kZXBvc2l0TnVtVXNlcgD//////////wcDBQAAAAlpc05ld1VzZXIJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIFAAAAG3VzZXJSZXdhcmRGcm9tRGVwb3NpdE51bUtFWQUAAAAOZGVwb3NpdE51bUxhc3QFAAAAA25pbAkABE0AAAACCgAAAAACJGwFAAAAE3N1cHBvcnRlZEFzc2V0c0xpc3QKAAAAAAIkcwkAAZAAAAABBQAAAAIkbAoAAAAABSRhY2MwBQAAAANuaWwKAQAAAAUkZjBfMQAAAAIAAAACJGEAAAACJGkDCQAAZwAAAAIFAAAAAiRpBQAAAAIkcwUAAAACJGEJAQAAABtmb3JFYWNoQXNzZXRDYWNoZVVzZXJSZXdhcmQAAAACBQAAAAIkYQkAAZEAAAACBQAAAAIkbAUAAAACJGkKAQAAAAUkZjBfMgAAAAIAAAACJGEAAAACJGkDCQAAZwAAAAIFAAAAAiRpBQAAAAIkcwUAAAACJGEJAAACAAAAAQIAAAAUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQAAAAUkZjBfMgAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIFAAAABSRhY2MwAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAACAAAAAAAAAAADAAAAAAAAAAAEAAAAAAAAAAAFAAAAAAAAAAAGAAAAAAAAAAAHAAAAAAAAAAAIAAAAAAAAAAAJAAAAAAAAAAAKCQEAAAAMSW50ZWdlckVudHJ5AAAAAgUAAAAbdXNlclJld2FyZEZyb21EZXBvc2l0TnVtS0VZBQAAAA5kZXBvc2l0TnVtTGFzdAkAAAIAAAABCQABLAAAAAIJAAEsAAAAAgkAASwAAAACAgAAACR1bmNvdmVyZWQgY29uZGl0aW9uOiBkZXBvc2l0TnVtTGFzdD0JAAGkAAAAAQUAAAAOZGVwb3NpdE51bUxhc3QCAAAAECBkZXBvc2l0TnVtVXNlcj0JAAGkAAAAAQUAAAAOZGVwb3NpdE51bVVzZXIBAAAAIkluY3JlbWVudE5vdERpc3RyaWJ1dGVkUmV3YXJkRW50cnkAAAACAAAAA3RrbgAAAAlhbW91bnRJbmMEAAAAF25vdERpc3RyaWJ1dGVkUmV3YXJkS0VZCQEAAAAXa2V5Tm90RGlzdHJpYnV0ZWRSZXdhcmQAAAABBQAAAAN0a24EAAAAFG5vdERpc3RyaWJ1dGVkUmV3YXJkCQEAAAAMZ2V0SW50T3JFbHNlAAAAAgUAAAAXbm90RGlzdHJpYnV0ZWRSZXdhcmRLRVkAAAAAAAAAAAAJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIFAAAAF25vdERpc3RyaWJ1dGVkUmV3YXJkS0VZCQAAZAAAAAIFAAAAFG5vdERpc3RyaWJ1dGVkUmV3YXJkBQAAAAlhbW91bnRJbmMFAAAAA25pbAAAAAcAAAABaQEAAAALY29uc3RydWN0b3IAAAAFAAAAF25ldXRyaW5vQ29udHJhY3RBZGRyZXNzAAAAE21hdGhDb250cmFjdEFkZHJlc3MAAAANbWluTG9ja0Ftb3VudAAAAAhoYWxmTGlmZQAAABVzdXBwb3J0ZWRSZXdhcmRBc3NldHMDCQEAAAACIT0AAAACCAUAAAABaQAAAAZjYWxsZXIFAAAABHRoaXMJAAACAAAAAQIAAAARUGVybWlzc2lvbiBkZW5pZWQJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAAGmtleU5ldXRyaW5vQ29udHJhY3RBZGRyZXNzAAAAAAUAAAAXbmV1dHJpbm9Db250cmFjdEFkZHJlc3MJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAAFmtleU1hdGhDb250cmFjdEFkZHJlc3MAAAAABQAAABNtYXRoQ29udHJhY3RBZGRyZXNzCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACCQEAAAAQa2V5TWluTG9ja0Ftb3VudAAAAAAFAAAADW1pbkxvY2tBbW91bnQJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIJAQAAAAtrZXlIYWxmTGlmZQAAAAAFAAAACGhhbGZMaWZlCQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAABhrZXlTdXBwb3J0ZWRSZXdhcmRBc3NldHMAAAAABQAAABVzdXBwb3J0ZWRSZXdhcmRBc3NldHMFAAAAA25pbAAAAAFpAQAAAAVzdGFrZQAAAAAEAAAADSR0MDExMTkwMTEyNjkJAQAAAA9nZXRQYXJhbXNPckZhaWwAAAAABAAAAA9hdWN0aW9uQ29udHJhY3QIBQAAAA0kdDAxMTE5MDExMjY5AAAAAl8xBAAAAAtib25kQXNzZXRJZAgFAAAADSR0MDExMTkwMTEyNjkAAAACXzIEAAAADW1pbkxvY2tBbW91bnQIBQAAAA0kdDAxMTE5MDExMjY5AAAAAl8zBAAAAAhoYWxmTGlmZQgFAAAADSR0MDExMTkwMTEyNjkAAAACXzQDCQEAAAACIT0AAAACCQABkAAAAAEIBQAAAAFpAAAACHBheW1lbnRzAAAAAAAAAAABCQAAAgAAAAECAAAAFUludmFsaWQgcGF5bWVudHMgc2l6ZQQAAAAHcGF5bWVudAkAAZEAAAACCAUAAAABaQAAAAhwYXltZW50cwAAAAAAAAAAAAQAAAAGYW1vdW50CAUAAAAHcGF5bWVudAAAAAZhbW91bnQEAAAAE2ludmFsaWRBc3NldE1lc3NhZ2UJAAEsAAAAAgkAASwAAAACAgAAAA9JbnZhbGlkIGFzc2V0LiAJAAJYAAAAAQUAAAALYm9uZEFzc2V0SWQCAAAADCBpcyBleHBlY3RlZAQAAAAHYXNzZXRJZAkBAAAAE3ZhbHVlT3JFcnJvck1lc3NhZ2UAAAACCAUAAAAHcGF5bWVudAAAAAdhc3NldElkBQAAABNpbnZhbGlkQXNzZXRNZXNzYWdlAwkBAAAAAiE9AAAAAgUAAAAHYXNzZXRJZAUAAAALYm9uZEFzc2V0SWQJAAACAAAAAQUAAAATaW52YWxpZEFzc2V0TWVzc2FnZQQAAAALdXNlckFkZHJlc3MIBQAAAAFpAAAABmNhbGxlcgQAAAAOdXNlckFkZHJlc3NTdHIJAAQlAAAAAQgFAAAAAWkAAAAGY2FsbGVyBAAAAA0kdDAxMTgxMTExOTE4CQEAAAALdmFsdWVPckVsc2UAAAACCQEAAAATZ2V0VXNlclBhcmFtc09yVW5pdAAAAAEFAAAAC3VzZXJBZGRyZXNzCQAFFQAAAAMGAAAAAAAAAAAAAP//////////BAAAAAlpc05ld1VzZXIIBQAAAA0kdDAxMTgxMTExOTE4AAAAAl8xBAAAAApsb2NrQW1vdW50CAUAAAANJHQwMTE4MTExMTkxOAAAAAJfMgQAAAAPbG9ja1N0YXJ0SGVpZ2h0CAUAAAANJHQwMTE4MTExMTkxOAAAAAJfMwQAAAAMbWVyZ2VkQW1vdW50AwUAAAAJaXNOZXdVc2VyBQAAAAZhbW91bnQJAABkAAAAAgUAAAAGYW1vdW50BQAAAApsb2NrQW1vdW50BAAAABFtZXJnZWRTdGFydEhlaWdodAMFAAAACWlzTmV3VXNlcgUAAAAGaGVpZ2h0BAAAAAxtYXRoQ29udHJhY3QJAQAAABFAZXh0ck5hdGl2ZSgxMDYyKQAAAAEJAQAAAA9nZXRTdHJpbmdPckZhaWwAAAABCQEAAAAWa2V5TWF0aENvbnRyYWN0QWRkcmVzcwAAAAAJAQAAAAVhc0ludAAAAAEJAAP8AAAABAUAAAAMbWF0aENvbnRyYWN0AgAAABNtZXJnZVN0YWtlc1JFQURPTkxZCQAETAAAAAIFAAAABmFtb3VudAkABEwAAAACBQAAAAZoZWlnaHQJAARMAAAAAgUAAAAKbG9ja0Ftb3VudAkABEwAAAACBQAAAA9sb2NrU3RhcnRIZWlnaHQJAARMAAAAAgUAAAAIaGFsZkxpZmUFAAAAA25pbAUAAAADbmlsAwkAAGYAAAACBQAAAA1taW5Mb2NrQW1vdW50BQAAAAxtZXJnZWRBbW91bnQJAAACAAAAAQkAASwAAAACAgAAABNNaW4gbG9jayBhbW91bnQgaXMgCQABpAAAAAEFAAAADW1pbkxvY2tBbW91bnQEAAAADSR0MDEyMzY4MTI0NzAJAQAAAAtTdGF0c1Jlc3VsdAAAAAMFAAAABmFtb3VudAAAAAAAAAAAAQMFAAAACWlzTmV3VXNlcgAAAAAAAAAAAQAAAAAAAAAAAAQAAAAMc3RhdHNFbnRyaWVzCAUAAAANJHQwMTIzNjgxMjQ3MAAAAAJfMQQAAAALdG90YWxTdGFrZWQIBQAAAA0kdDAxMjM2ODEyNDcwAAAAAl8yBAAAAA50b3RhbFN0YWtlZE5ldwgFAAAADSR0MDEyMzY4MTI0NzAAAAACXzMJAAROAAAAAgkABE4AAAACCQAETgAAAAIJAARMAAAAAgkBAAAAEkhpc3RvcnlSZWNvcmRFbnRyeQAAAAcCAAAABXN0YWtlBQAAAAt1c2VyQWRkcmVzcwgFAAAAAWkAAAANdHJhbnNhY3Rpb25JZAUAAAAKbG9ja0Ftb3VudAUAAAAPbG9ja1N0YXJ0SGVpZ2h0BQAAAAxtZXJnZWRBbW91bnQFAAAAEW1lcmdlZFN0YXJ0SGVpZ2h0BQAAAANuaWwJAQAAAA1SZXdhcmRFbnRyaWVzAAAAAwUAAAAJaXNOZXdVc2VyBQAAAA51c2VyQWRkcmVzc1N0cgUAAAAKbG9ja0Ftb3VudAkBAAAAD0xvY2tQYXJhbXNFbnRyeQAAAAMFAAAAC3VzZXJBZGRyZXNzBQAAAAxtZXJnZWRBbW91bnQFAAAAEW1lcmdlZFN0YXJ0SGVpZ2h0BQAAAAxzdGF0c0VudHJpZXMAAAABaQEAAAAHdW5zdGFrZQAAAAEAAAAGYW1vdW50AwkBAAAAAiE9AAAAAgkAAZAAAAABCAUAAAABaQAAAAhwYXltZW50cwAAAAAAAAAAAAkAAAIAAAABAgAAACN1bnN0YWtlIGRvZXNuJ3QgcmVxdWlyZSBhbnkgcGF5bWVudAQAAAALdXNlckFkZHJlc3MIBQAAAAFpAAAABmNhbGxlcgQAAAAOdXNlckFkZHJlc3NTdHIJAAQlAAAAAQUAAAALdXNlckFkZHJlc3MEAAAADSR0MDEyOTU2MTMwMzQJAQAAAA9nZXRQYXJhbXNPckZhaWwAAAAABAAAAA5hdWN0aW9uQWRkcmVzcwgFAAAADSR0MDEyOTU2MTMwMzQAAAACXzEEAAAAC2JvbmRBc3NldElkCAUAAAANJHQwMTI5NTYxMzAzNAAAAAJfMgQAAAANbWluTG9ja0Ftb3VudAgFAAAADSR0MDEyOTU2MTMwMzQAAAACXzMEAAAACGhhbGZMaWZlCAUAAAANJHQwMTI5NTYxMzAzNAAAAAJfNAQAAAANJHQwMTMwMzcxMzExMQkBAAAAE2dldFVzZXJQYXJhbXNPckZhaWwAAAABBQAAAAt1c2VyQWRkcmVzcwQAAAAJaXNOZXdVc2VyCAUAAAANJHQwMTMwMzcxMzExMQAAAAJfMQQAAAAKbG9ja0Ftb3VudAgFAAAADSR0MDEzMDM3MTMxMTEAAAACXzIEAAAACWxvY2tTdGFydAgFAAAADSR0MDEzMDM3MTMxMTEAAAACXzMDCQAAZwAAAAIAAAAAAAAAAAAFAAAACmxvY2tBbW91bnQJAAACAAAAAQIAAAASTm90aGluZyB0byB1bnN0YWtlAwkAAGYAAAACBQAAAAZhbW91bnQFAAAACmxvY2tBbW91bnQJAAACAAAAAQkAASwAAAACCQABLAAAAAIJAAEsAAAAAgIAAAAKUmVxdWVzdGVkIAkAAaQAAAABBQAAAAZhbW91bnQCAAAAEiwgYnV0IHN0YWtlZCBvbmx5IAkAAaQAAAABBQAAAApsb2NrQW1vdW50BAAAAAxtYXRoQ29udHJhY3QJAQAAABFAZXh0ck5hdGl2ZSgxMDYyKQAAAAEJAQAAAA9nZXRTdHJpbmdPckZhaWwAAAABCQEAAAAWa2V5TWF0aENvbnRyYWN0QWRkcmVzcwAAAAAEAAAAD2NvbWlzc2lvbkFtb3VudAkBAAAABWFzSW50AAAAAQkAA/wAAAAEBQAAAAxtYXRoQ29udHJhY3QCAAAAIWdldFVuc3Rha2VDb21pc3Npb25BbW91bnRSRUFET05MWQkABEwAAAACBQAAAAZhbW91bnQJAARMAAAAAgUAAAAJbG9ja1N0YXJ0CQAETAAAAAIFAAAACGhhbGZMaWZlBQAAAANuaWwFAAAAA25pbAQAAAANJHQwMTM1MTIxMzY2NgkBAAAAC1N0YXRzUmVzdWx0AAAAAwkBAAAAAS0AAAABBQAAAAZhbW91bnQDCQAAAAAAAAIFAAAABmFtb3VudAUAAAAKbG9ja0Ftb3VudAD//////////wAAAAAAAAAAAAMJAAAAAAAAAgUAAAAGYW1vdW50BQAAAApsb2NrQW1vdW50AP//////////AAAAAAAAAAAABAAAAAxzdGF0c0VudHJpZXMIBQAAAA0kdDAxMzUxMjEzNjY2AAAAAl8xBAAAAAt0b3RhbFN0YWtlZAgFAAAADSR0MDEzNTEyMTM2NjYAAAACXzIEAAAADnRvdGFsU3Rha2VkTmV3CAUAAAANJHQwMTM1MTIxMzY2NgAAAAJfMwkABE4AAAACCQAETgAAAAIJAAROAAAAAgkABEwAAAACCQEAAAAOU2NyaXB0VHJhbnNmZXIAAAADBQAAAAt1c2VyQWRkcmVzcwkAAGUAAAACBQAAAAZhbW91bnQFAAAAD2NvbWlzc2lvbkFtb3VudAUAAAALYm9uZEFzc2V0SWQJAARMAAAAAgkBAAAADlNjcmlwdFRyYW5zZmVyAAAAAwkBAAAAB0FkZHJlc3MAAAABBQAAAA5hdWN0aW9uQWRkcmVzcwUAAAAPY29taXNzaW9uQW1vdW50BQAAAAtib25kQXNzZXRJZAkABEwAAAACCQEAAAASSGlzdG9yeVJlY29yZEVudHJ5AAAABwIAAAAHdW5zdGFrZQUAAAALdXNlckFkZHJlc3MIBQAAAAFpAAAADXRyYW5zYWN0aW9uSWQFAAAACmxvY2tBbW91bnQFAAAACWxvY2tTdGFydAkAAGUAAAACBQAAAApsb2NrQW1vdW50BQAAAAZhbW91bnQFAAAACWxvY2tTdGFydAUAAAADbmlsCQEAAAANUmV3YXJkRW50cmllcwAAAAMHBQAAAA51c2VyQWRkcmVzc1N0cgUAAAAKbG9ja0Ftb3VudAkBAAAAD0xvY2tQYXJhbXNFbnRyeQAAAAMFAAAAC3VzZXJBZGRyZXNzCQAAZQAAAAIFAAAACmxvY2tBbW91bnQFAAAABmFtb3VudAUAAAAJbG9ja1N0YXJ0BQAAAAxzdGF0c0VudHJpZXMAAAABaQEAAAAHZGVwb3NpdAAAAAADCQEAAAACIT0AAAACCQABkAAAAAEIBQAAAAFpAAAACHBheW1lbnRzAAAAAAAAAAABCQAAAgAAAAECAAAAH2V4YWN0IDEgcGF5bWVudCBpcyBhbGxvd2VkIG9ubHkEAAAAA3BtdAkAAZEAAAACCAUAAAABaQAAAAhwYXltZW50cwAAAAAAAAAAAAQAAAAGYW1vdW50CAUAAAADcG10AAAABmFtb3VudAQAAAAKcG10QXNzZXRJZAkBAAAAC3ZhbHVlT3JFbHNlAAAAAggFAAAAA3BtdAAAAAdhc3NldElkBQAAAAdXQVZFU0lEBAAAAA1wbXRBc3NldElkU3RyCQACWAAAAAEFAAAACnBtdEFzc2V0SWQEAAAACHBtdE11bHRYAwkAAAAAAAACBQAAAApwbXRBc3NldElkBQAAAAdXQVZFU0lEBQAAAAZNVUxUWDgFAAAABk1VTFRYNgQAAAAHYW1vdW50WAkAATYAAAABBQAAAAZhbW91bnQEAAAAC3RvdGFsU3Rha2VkCQEAAAAMZ2V0SW50T3JFbHNlAAAAAgkBAAAAF2tleUxvY2tQYXJhbVRvdGFsQW1vdW50AAAAAAAAAAAAAAAAAAQAAAAMdG90YWxTdGFrZWRYCQABNgAAAAEFAAAAC3RvdGFsU3Rha2VkAwkAAGYAAAACAAAAAAAAAAAABQAAAAt0b3RhbFN0YWtlZAkAAAIAAAABAgAAABtUT0RPOiBjYXNlIGlzIG5vdCBzdXBwb3J0ZWQDCQAAAAAAAAIFAAAAC3RvdGFsU3Rha2VkAAAAAAAAAAAACQEAAAAiSW5jcmVtZW50Tm90RGlzdHJpYnV0ZWRSZXdhcmRFbnRyeQAAAAIFAAAADXBtdEFzc2V0SWRTdHIFAAAABmFtb3VudAQAAAAQcmV3YXJkUGVyTnNidFgxOAkAATwAAAADBQAAAAdhbW91bnRYBQAAAAdNVUxUWDE4BQAAAAx0b3RhbFN0YWtlZFgEAAAAEWRlcG9zaXROdW1MYXN0S0VZCQEAAAARa2V5RGVwb3NpdE51bUxhc3QAAAAABAAAAA5kZXBvc2l0TnVtTGFzdAkBAAAADGdldEludE9yRWxzZQAAAAIFAAAAEWRlcG9zaXROdW1MYXN0S0VZAP//////////BAAAAA1kZXBvc2l0TnVtTmV3CQAAZAAAAAIFAAAADmRlcG9zaXROdW1MYXN0AAAAAAAAAAABAwkBAAAAASEAAAABCQEAAAAIY29udGFpbnMAAAACBQAAABJzdXBwb3J0ZWRBc3NldHNTdHIFAAAADXBtdEFzc2V0SWRTdHIJAAACAAAAAQkAASwAAAACCQABLAAAAAIFAAAAEnN1cHBvcnRlZEFzc2V0c1N0cgIAAAARIGRvZXNuJ3QgY29udGFpbiAFAAAADXBtdEFzc2V0SWRTdHIKAQAAABdyZWZyZXNoUmV3YXJkUGVyTnNidFNVTQAAAAIAAAAFYWNjdW0AAAAJbmV4dEFzc2V0BAAAABZyZXdhcmRQZXJOc2J0U3VtTmV3S0VZCQEAAAAVa2V5UmV3YXJkUGVyTnNidFN1bUF0AAAAAgUAAAANZGVwb3NpdE51bU5ldwUAAAAJbmV4dEFzc2V0BAAAAApzdW1MYXN0U3RyCQEAAAAMZ2V0U3RyT3JFbHNlAAAAAgkBAAAAFWtleVJld2FyZFBlck5zYnRTdW1BdAAAAAIFAAAADmRlcG9zaXROdW1MYXN0BQAAAAluZXh0QXNzZXQCAAAAATAJAARNAAAAAgUAAAAFYWNjdW0DCQAAAAAAAAIFAAAACW5leHRBc3NldAUAAAANcG10QXNzZXRJZFN0cgkBAAAAC1N0cmluZ0VudHJ5AAAAAgUAAAAWcmV3YXJkUGVyTnNidFN1bU5ld0tFWQkAAaYAAAABCQABNwAAAAIJAAGnAAAAAQUAAAAKc3VtTGFzdFN0cgUAAAAQcmV3YXJkUGVyTnNidFgxOAkBAAAAC1N0cmluZ0VudHJ5AAAAAgUAAAAWcmV3YXJkUGVyTnNidFN1bU5ld0tFWQUAAAAKc3VtTGFzdFN0cgkABE0AAAACCgAAAAACJGwFAAAAE3N1cHBvcnRlZEFzc2V0c0xpc3QKAAAAAAIkcwkAAZAAAAABBQAAAAIkbAoAAAAABSRhY2MwBQAAAANuaWwKAQAAAAUkZjBfMQAAAAIAAAACJGEAAAACJGkDCQAAZwAAAAIFAAAAAiRpBQAAAAIkcwUAAAACJGEJAQAAABdyZWZyZXNoUmV3YXJkUGVyTnNidFNVTQAAAAIFAAAAAiRhCQABkQAAAAIFAAAAAiRsBQAAAAIkaQoBAAAABSRmMF8yAAAAAgAAAAIkYQAAAAIkaQMJAABnAAAAAgUAAAACJGkFAAAAAiRzBQAAAAIkYQkAAAIAAAABAgAAABRMaXN0IHNpemUgZXhjZWVkcyAxMAkBAAAABSRmMF8yAAAAAgkBAAAABSRmMF8xAAAAAgkBAAAABSRmMF8xAAAAAgkBAAAABSRmMF8xAAAAAgkBAAAABSRmMF8xAAAAAgkBAAAABSRmMF8xAAAAAgkBAAAABSRmMF8xAAAAAgkBAAAABSRmMF8xAAAAAgkBAAAABSRmMF8xAAAAAgkBAAAABSRmMF8xAAAAAgkBAAAABSRmMF8xAAAAAgUAAAAFJGFjYzAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAIAAAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAUAAAAAAAAAAAYAAAAAAAAAAAcAAAAAAAAAAAgAAAAAAAAAAAkAAAAAAAAAAAoJAQAAAAxJbnRlZ2VyRW50cnkAAAACBQAAABFkZXBvc2l0TnVtTGFzdEtFWQUAAAANZGVwb3NpdE51bU5ldwAAAAFpAQAAAAxjbGFpbVJld2FyZHMAAAAABAAAAAt1c2VyQWRkcmVzcwgFAAAAAWkAAAAGY2FsbGVyBAAAAA51c2VyQWRkcmVzc1N0cgkABCUAAAABBQAAAAt1c2VyQWRkcmVzcwMJAABmAAAAAgkAAZAAAAABCAUAAAABaQAAAAhwYXltZW50cwAAAAAAAAAAAAkAAAIAAAABAgAAABlwYXltZW50cyBhcmUgbm90IGFjY2VwdGVkBAAAAA0kdDAxNTkyMjE2MDI3CQEAAAALdmFsdWVPckVsc2UAAAACCQEAAAATZ2V0VXNlclBhcmFtc09yVW5pdAAAAAEFAAAAC3VzZXJBZGRyZXNzCQAFFQAAAAMGAAAAAAAAAAAAAAAAAAAAAAAABAAAAAlpc05ld1VzZXIIBQAAAA0kdDAxNTkyMjE2MDI3AAAAAl8xBAAAAAxzdGFrZWRBbW91bnQIBQAAAA0kdDAxNTkyMjE2MDI3AAAAAl8yBAAAAAxzdGFraW5nU3RhcnQIBQAAAA0kdDAxNTkyMjE2MDI3AAAAAl8zBAAAAA1zdGFrZWRBbW91bnRYCQABNgAAAAEFAAAADHN0YWtlZEFtb3VudAQAAAAbdXNlclJld2FyZEZyb21EZXBvc2l0TnVtS0VZCQEAAAAba2V5VXNlclJld2FyZEZyb21EZXBvc2l0TnVtAAAAAQUAAAAOdXNlckFkZHJlc3NTdHIEAAAADmRlcG9zaXROdW1Vc2VyCQEAAAAMZ2V0SW50T3JFbHNlAAAAAgUAAAAbdXNlclJld2FyZEZyb21EZXBvc2l0TnVtS0VZAP//////////BAAAAA5kZXBvc2l0TnVtTGFzdAkBAAAADGdldEludE9yRWxzZQAAAAIJAQAAABFrZXlEZXBvc2l0TnVtTGFzdAAAAAAA//////////8KAQAAAB9mb3JFYWNoQXNzZXRDYWxjVW5jbGFpbWVkUmV3YXJkAAAAAgAAAAVhY2N1bQAAAAVhc3NldAQAAAANJHQwMTYzOTgxNjUzNgkBAAAACmNhbGNSZXdhcmQAAAAFBQAAAA51c2VyQWRkcmVzc1N0cgUAAAAFYXNzZXQFAAAADXN0YWtlZEFtb3VudFgFAAAADmRlcG9zaXROdW1Vc2VyBQAAAA5kZXBvc2l0TnVtTGFzdAQAAAALcmV3YXJkVG90YWwIBQAAAA0kdDAxNjM5ODE2NTM2AAAAAl8xBAAAAAZjYWNoZWQIBQAAAA0kdDAxNjM5ODE2NTM2AAAAAl8yBAAAAAdkeW5hbWljCAUAAAANJHQwMTYzOTgxNjUzNgAAAAJfMwQAAAATcmV3YXJkQ2FjaGVkUGFydEtFWQgFAAAADSR0MDE2Mzk4MTY1MzYAAAACXzQEAAAACmNsYWltZWRLRVkJAQAAAAprZXlDbGFpbWVkAAAAAgUAAAAOdXNlckFkZHJlc3NTdHIFAAAABWFzc2V0BAAAAA0kdDAxNjU5NjE2NjMzBQAAAAVhY2N1bQQAAAAEZGF0YQgFAAAADSR0MDE2NTk2MTY2MzMAAAACXzEEAAAAEWNsYWltZWRBbXRCeUFzc2V0CAUAAAANJHQwMTY1OTYxNjYzMwAAAAJfMgQAAAAHbmV3UGFydAkABLkAAAACCQAETAAAAAIFAAAABWFzc2V0CQAETAAAAAIJAAGkAAAAAQUAAAALcmV3YXJkVG90YWwFAAAAA25pbAIAAAABOgQAAAAUY2xhaW1lZEFtdEJ5QXNzZXROZXcJAAS5AAAAAgkABEwAAAACBQAAABFjbGFpbWVkQW10QnlBc3NldAkABEwAAAACBQAAAAduZXdQYXJ0BQAAAANuaWwCAAAAAV8DCQAAZwAAAAIAAAAAAAAAAAAFAAAAC3Jld2FyZFRvdGFsCQAFFAAAAAIFAAAABGRhdGEFAAAAFGNsYWltZWRBbXRCeUFzc2V0TmV3CQAFFAAAAAIJAARNAAAAAgkABE0AAAACCQAETQAAAAIFAAAABGRhdGEJAQAAAA5TY3JpcHRUcmFuc2ZlcgAAAAMFAAAAC3VzZXJBZGRyZXNzBQAAAAtyZXdhcmRUb3RhbAkBAAAAC3RvQXNzZXRWZWN0AAAAAQUAAAAFYXNzZXQJAQAAAAxJbnRlZ2VyRW50cnkAAAACBQAAAApjbGFpbWVkS0VZCQAAZAAAAAIJAQAAAAt2YWx1ZU9yRWxzZQAAAAIJAAQfAAAAAQUAAAAKY2xhaW1lZEtFWQAAAAAAAAAAAAUAAAALcmV3YXJkVG90YWwJAQAAAAxJbnRlZ2VyRW50cnkAAAACBQAAABNyZXdhcmRDYWNoZWRQYXJ0S0VZAAAAAAAAAAAABQAAABRjbGFpbWVkQW10QnlBc3NldE5ldwQAAAANJHQwMTcwOTMxNzIwNwoAAAAAAiRsBQAAABNzdXBwb3J0ZWRBc3NldHNMaXN0CgAAAAACJHMJAAGQAAAAAQUAAAACJGwKAAAAAAUkYWNjMAkABRQAAAACBQAAAANuaWwCAAAAAAoBAAAABSRmMF8xAAAAAgAAAAIkYQAAAAIkaQMJAABnAAAAAgUAAAACJGkFAAAAAiRzBQAAAAIkYQkBAAAAH2ZvckVhY2hBc3NldENhbGNVbmNsYWltZWRSZXdhcmQAAAACBQAAAAIkYQkAAZEAAAACBQAAAAIkbAUAAAACJGkKAQAAAAUkZjBfMgAAAAIAAAACJGEAAAACJGkDCQAAZwAAAAIFAAAAAiRpBQAAAAIkcwUAAAACJGEJAAACAAAAAQIAAAAUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQAAAAUkZjBfMgAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIFAAAABSRhY2MwAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAACAAAAAAAAAAADAAAAAAAAAAAEAAAAAAAAAAAFAAAAAAAAAAAGAAAAAAAAAAAHAAAAAAAAAAAIAAAAAAAAAAAJAAAAAAAAAAAKBAAAAAl0cmFuc2ZlcnMIBQAAAA0kdDAxNzA5MzE3MjA3AAAAAl8xBAAAABdjbGFpbWVkQW10QnlBc3NldFJlc3VsdAgFAAAADSR0MDE3MDkzMTcyMDcAAAACXzIDCQAAZwAAAAIAAAAAAAAAAAAJAAGQAAAAAQUAAAAJdHJhbnNmZXJzCQAAAgAAAAECAAAAEG5vdGhpbmcgdG8gY2xhaW0JAARNAAAAAgkABE0AAAACBQAAAAl0cmFuc2ZlcnMJAQAAAAxJbnRlZ2VyRW50cnkAAAACBQAAABt1c2VyUmV3YXJkRnJvbURlcG9zaXROdW1LRVkFAAAADmRlcG9zaXROdW1MYXN0CQEAAAARQ2xhaW1IaXN0b3J5RW50cnkAAAADBQAAAAt1c2VyQWRkcmVzcwgFAAAAAWkAAAANdHJhbnNhY3Rpb25JZAkAATAAAAACBQAAABdjbGFpbWVkQW10QnlBc3NldFJlc3VsdAAAAAAAAAAAAQAAAAFpAQAAABh1bmNsYWltZWRSZXdhcmRzUkVBRE9OTFkAAAABAAAADnVzZXJBZGRyZXNzU3RyCgEAAAAWZm9yRWFjaEFzc2V0WmVyb1Jld2FyZAAAAAIAAAAFYWNjdW0AAAAFYXNzZXQJAAEsAAAAAgkAASwAAAACBQAAAAVhY2N1bQkABLkAAAACCQAETAAAAAIFAAAABWFzc2V0CQAETAAAAAICAAAAATAJAARMAAAAAgIAAAABMAUAAAADbmlsAgAAAAE6AgAAAAFfBAAAABJ1bmNsYWltZWRSZXdhcmRTdHIDCQAAAAAAAAIFAAAADnVzZXJBZGRyZXNzU3RyAgAAAAAKAAAAAAIkbAUAAAATc3VwcG9ydGVkQXNzZXRzTGlzdAoAAAAAAiRzCQABkAAAAAEFAAAAAiRsCgAAAAAFJGFjYzACAAAAAAoBAAAABSRmMF8xAAAAAgAAAAIkYQAAAAIkaQMJAABnAAAAAgUAAAACJGkFAAAAAiRzBQAAAAIkYQkBAAAAFmZvckVhY2hBc3NldFplcm9SZXdhcmQAAAACBQAAAAIkYQkAAZEAAAACBQAAAAIkbAUAAAACJGkKAQAAAAUkZjBfMgAAAAIAAAACJGEAAAACJGkDCQAAZwAAAAIFAAAAAiRpBQAAAAIkcwUAAAACJGEJAAACAAAAAQIAAAAUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQAAAAUkZjBfMgAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIJAQAAAAUkZjBfMQAAAAIFAAAABSRhY2MwAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAACAAAAAAAAAAADAAAAAAAAAAAEAAAAAAAAAAAFAAAAAAAAAAAGAAAAAAAAAAAHAAAAAAAAAAAIAAAAAAAAAAAJAAAAAAAAAAAKBAAAAAt1c2VyQWRkcmVzcwkBAAAAEUBleHRyTmF0aXZlKDEwNjIpAAAAAQUAAAAOdXNlckFkZHJlc3NTdHIEAAAADSR0MDE3ODY2MTc5NzEJAQAAAAt2YWx1ZU9yRWxzZQAAAAIJAQAAABNnZXRVc2VyUGFyYW1zT3JVbml0AAAAAQUAAAALdXNlckFkZHJlc3MJAAUVAAAAAwYAAAAAAAAAAAAAAAAAAAAAAAAEAAAACWlzTmV3VXNlcggFAAAADSR0MDE3ODY2MTc5NzEAAAACXzEEAAAADHN0YWtlZEFtb3VudAgFAAAADSR0MDE3ODY2MTc5NzEAAAACXzIEAAAADHN0YWtpbmdTdGFydAgFAAAADSR0MDE3ODY2MTc5NzEAAAACXzMEAAAADXN0YWtlZEFtb3VudFgJAAE2AAAAAQUAAAAMc3Rha2VkQW1vdW50BAAAABt1c2VyUmV3YXJkRnJvbURlcG9zaXROdW1LRVkJAQAAABtrZXlVc2VyUmV3YXJkRnJvbURlcG9zaXROdW0AAAABBQAAAA51c2VyQWRkcmVzc1N0cgQAAAAOZGVwb3NpdE51bVVzZXIJAQAAAAxnZXRJbnRPckVsc2UAAAACBQAAABt1c2VyUmV3YXJkRnJvbURlcG9zaXROdW1LRVkA//////////8EAAAADmRlcG9zaXROdW1MYXN0CQEAAAAMZ2V0SW50T3JFbHNlAAAAAgkBAAAAEWtleURlcG9zaXROdW1MYXN0AAAAAAD//////////woBAAAAH2ZvckVhY2hBc3NldENhbGNVbmNsYWltZWRSZXdhcmQAAAACAAAABWFjY3VtAAAABWFzc2V0BAAAAA0kdDAxODMxNzE4NDU1CQEAAAAKY2FsY1Jld2FyZAAAAAUFAAAADnVzZXJBZGRyZXNzU3RyBQAAAAVhc3NldAUAAAANc3Rha2VkQW1vdW50WAUAAAAOZGVwb3NpdE51bVVzZXIFAAAADmRlcG9zaXROdW1MYXN0BAAAAAtyZXdhcmRUb3RhbAgFAAAADSR0MDE4MzE3MTg0NTUAAAACXzEEAAAABmNhY2hlZAgFAAAADSR0MDE4MzE3MTg0NTUAAAACXzIEAAAAB2R5bmFtaWMIBQAAAA0kdDAxODMxNzE4NDU1AAAAAl8zBAAAABNyZXdhcmRDYWNoZWRQYXJ0S0VZCAUAAAANJHQwMTgzMTcxODQ1NQAAAAJfNAQAAAAHY2xhaW1lZAkBAAAAC3ZhbHVlT3JFbHNlAAAAAgkABB8AAAABCQEAAAAKa2V5Q2xhaW1lZAAAAAIFAAAADnVzZXJBZGRyZXNzU3RyBQAAAAVhc3NldAAAAAAAAAAAAAkAASwAAAACCQABLAAAAAIFAAAABWFjY3VtCQAEuQAAAAIJAARMAAAAAgUAAAAFYXNzZXQJAARMAAAAAgkAAaQAAAABBQAAAAtyZXdhcmRUb3RhbAkABEwAAAACCQABpAAAAAEFAAAAB2NsYWltZWQFAAAAA25pbAIAAAABOgIAAAABXwoAAAAAAiRsBQAAABNzdXBwb3J0ZWRBc3NldHNMaXN0CgAAAAACJHMJAAGQAAAAAQUAAAACJGwKAAAAAAUkYWNjMAIAAAAACgEAAAAFJGYwXzEAAAACAAAAAiRhAAAAAiRpAwkAAGcAAAACBQAAAAIkaQUAAAACJHMFAAAAAiRhCQEAAAAfZm9yRWFjaEFzc2V0Q2FsY1VuY2xhaW1lZFJld2FyZAAAAAIFAAAAAiRhCQABkQAAAAIFAAAAAiRsBQAAAAIkaQoBAAAABSRmMF8yAAAAAgAAAAIkYQAAAAIkaQMJAABnAAAAAgUAAAACJGkFAAAAAiRzBQAAAAIkYQkAAAIAAAABAgAAABRMaXN0IHNpemUgZXhjZWVkcyAxMAkBAAAABSRmMF8yAAAAAgkBAAAABSRmMF8xAAAAAgkBAAAABSRmMF8xAAAAAgkBAAAABSRmMF8xAAAAAgkBAAAABSRmMF8xAAAAAgkBAAAABSRmMF8xAAAAAgkBAAAABSRmMF8xAAAAAgkBAAAABSRmMF8xAAAAAgkBAAAABSRmMF8xAAAAAgkBAAAABSRmMF8xAAAAAgkBAAAABSRmMF8xAAAAAgUAAAAFJGFjYzAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAIAAAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAUAAAAAAAAAAAYAAAAAAAAAAAcAAAAAAAAAAAgAAAAAAAAAAAkAAAAAAAAAAAoJAAUUAAAAAgUAAAADbmlsCQEAAAAJZHJvcFJpZ2h0AAAAAgUAAAASdW5jbGFpbWVkUmV3YXJkU3RyAAAAAAAAAAABAAAAAWkBAAAAFm5zYnRTdGFraW5nU1lTUkVBRE9OTFkAAAABAAAADnVzZXJBZGRyZXNzU3RyBAAAAAx0b3RhbE5zYnRBbXQJAQAAAAxnZXRJbnRPckVsc2UAAAACCQEAAAAXa2V5TG9ja1BhcmFtVG90YWxBbW91bnQAAAAAAAAAAAAAAAAAAwkAAAAAAAACBQAAAA51c2VyQWRkcmVzc1N0cgIAAAAACQAFFAAAAAIFAAAAA25pbAkABEwAAAACAAAAAAAAAAAACQAETAAAAAIFAAAADHRvdGFsTnNidEFtdAkABEwAAAACAAAAAAAAAAAABQAAAANuaWwEAAAAC3VzZXJBZGRyZXNzCQEAAAAPdG9BZGRyZXNzT3JGYWlsAAAAAQUAAAAOdXNlckFkZHJlc3NTdHIEAAAADSR0MDE5MDU5MTkxNjMJAQAAAAt2YWx1ZU9yRWxzZQAAAAIJAQAAABNnZXRVc2VyUGFyYW1zT3JVbml0AAAAAQUAAAALdXNlckFkZHJlc3MJAAUVAAAAAwYAAAAAAAAAAAAAAAAAAAAAAAAEAAAACWlzTmV3VXNlcggFAAAADSR0MDE5MDU5MTkxNjMAAAACXzEEAAAAC3VzZXJOc2J0QW10CAUAAAANJHQwMTkwNTkxOTE2MwAAAAJfMgQAAAAMc3Rha2luZ1N0YXJ0CAUAAAANJHQwMTkwNTkxOTE2MwAAAAJfMwkABRQAAAACBQAAAANuaWwJAARMAAAAAgUAAAALdXNlck5zYnRBbXQJAARMAAAAAgUAAAAMdG90YWxOc2J0QW10CQAETAAAAAIFAAAADHN0YWtpbmdTdGFydAUAAAADbmlsAAAAAQAAAAJ0eAEAAAAGdmVyaWZ5AAAAAAQAAAAQcHViS2V5QWRtaW5zTGlzdAkABEwAAAACAgAAACxHSmRMU2FMaXY1Szd4dWVqYWM4bWNSY0hveW8zZFByRVNydmt0RzNhNk1BUgkABEwAAAACAgAAACxGV1ZmZllyMkFMbUhNZWpabTNXcWVMejZTZHltM2dMRkd0Sm40S1R3eVU1eAkABEwAAAACAgAAACwzV2gyTGFXY2I1Z2c3SzJwUGNXM0VwNkVBdVJCellrQWdyZHB0NDNqVERGYQkABEwAAAACAgAAACw1V1JYRlNqd2NUYk5mS2NKczhacVhtU1NXWXNTVkpVdE12TXFaajVoSDROYwUAAAADbmlsBAAAAAVjb3VudAkAAGQAAAACCQAAZAAAAAIJAABkAAAAAgMJAAH0AAAAAwgFAAAAAnR4AAAACWJvZHlCeXRlcwkAAZEAAAACCAUAAAACdHgAAAAGcHJvb2ZzAAAAAAAAAAAACQACWQAAAAEJAAGRAAAAAgUAAAAQcHViS2V5QWRtaW5zTGlzdAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAMJAAH0AAAAAwgFAAAAAnR4AAAACWJvZHlCeXRlcwkAAZEAAAACCAUAAAACdHgAAAAGcHJvb2ZzAAAAAAAAAAABCQACWQAAAAEJAAGRAAAAAgUAAAAQcHViS2V5QWRtaW5zTGlzdAAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAAAAAMJAAH0AAAAAwgFAAAAAnR4AAAACWJvZHlCeXRlcwkAAZEAAAACCAUAAAACdHgAAAAGcHJvb2ZzAAAAAAAAAAACCQACWQAAAAEJAAGRAAAAAgUAAAAQcHViS2V5QWRtaW5zTGlzdAAAAAAAAAAAAgAAAAAAAAAAAQAAAAAAAAAAAAMJAAH0AAAAAwgFAAAAAnR4AAAACWJvZHlCeXRlcwkAAZEAAAACCAUAAAACdHgAAAAGcHJvb2ZzAAAAAAAAAAADCQACWQAAAAEJAAGRAAAAAgUAAAAQcHViS2V5QWRtaW5zTGlzdAAAAAAAAAAAAwAAAAAAAAAAAgAAAAAAAAAAAAkAAGcAAAACBQAAAAVjb3VudAAAAAAAAAAAA42KypI=", "chainId": 87, "height": 3043351, "applicationStatus": "succeeded", "spentComplexity": 0 } View: original | compacted Prev: none Next: 7NDg2qJaEmtDnrgaqnPDCZd9D97yrsXjbkeT1jhpUbDr Full:
OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 5 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let revisionNum = "443c64dd5056b5be23b700224699295e733e0452"
5+
6+let separator = "__"
7+
8+let MULT6 = 1000000
9+
10+let MULT8 = 100000000
11+
12+let MULTX6 = toBigInt(MULT6)
13+
14+let MULTX8 = toBigInt(MULT8)
15+
16+let MULTX18 = toBigInt(1000000000000000000)
17+
18+let WAVESIDSTR = "WAVES"
19+
20+let WAVESID = fromBase58String(WAVESIDSTR)
21+
22+func keyBondAsset () = "bond_asset_id"
23+
24+
25+func keyAuctionContractAddress () = "auction_contract"
26+
27+
28+func keyNeutrinoContractAddress () = "%s__neutrinoContractAddress"
29+
30+
31+func keyMathContractAddress () = "%s__mathContract"
32+
33+
34+func keyMinLockAmount () = "%s__minLockAmount"
35+
36+
37+func keyHalfLife () = "%s__halfLife"
38+
39+
40+func keyLockParamUserAmount (userAddress) = makeString(["%s%s%s", "paramByUser", toString(userAddress), "amount"], separator)
41+
42+
43+func keyLockParamStartBlock (userAddress) = makeString(["%s%s%s", "paramByUser", toString(userAddress), "start"], separator)
44+
45+
46+func keyHistoryRecord (type,userAddress,txId) = makeString(["%s%s%s%s", "history", type, toString(userAddress), toBase58String(txId)], separator)
47+
48+
49+func keyLockParamTotalAmount () = makeString(["%s%s", "stats", "activeTotalLocked"], separator)
50+
51+
52+func keyStatsLocksCount () = makeString(["%s%s", "stats", "locksCount"], separator)
53+
54+
55+func keyStatsUsersCount () = makeString(["%s%s", "stats", "activeUsersCount"], separator)
56+
57+
58+func keyNextPeriod () = "%s__nextPeriod"
59+
60+
61+func keySupportedRewardAssets () = "supportedRewardAssets"
62+
63+
64+func keyDepositNumLast () = makeString(["%s%s%s", "dep", "lastNum"], separator)
65+
66+
67+func keyUserRewardFromDepositNum (userAddress) = makeString(["%s%s%s", "userRwdFromDepNum", userAddress], separator)
68+
69+
70+func keyRewardPerNsbtSumAt (depositNum,tkn) = makeString(["%s%d", "rwdPerNsbtSumByDepNum", toString(depositNum), tkn], separator)
71+
72+
73+func keyReward (userAddress,tkn) = makeString(["%s%s%s", "rwd", userAddress, tkn], separator)
74+
75+
76+func keyClaimed (userAddress,tkn) = makeString(["%s%s%s", "clm", userAddress, tkn], separator)
77+
78+
79+func keyNotDistributedReward (tkn) = makeString(["%s%s", "notDistributed", tkn], separator)
80+
81+
82+func toX18 (origVal,origMult) = fraction(toBigInt(origVal), MULTX18, origMult)
83+
84+
85+func getIntOrZero (key) = valueOrElse(getInteger(this, key), 0)
86+
87+
88+func getIntOrElse (key,defaultVal) = valueOrElse(getInteger(this, key), defaultVal)
89+
90+
91+func getIntOrFail (key) = valueOrErrorMessage(getInteger(this, key), (("Mandatory this." + key) + " is not defined"))
92+
93+
94+func getStrOrElse (key,defaultVal) = valueOrElse(getString(this, key), defaultVal)
95+
96+
97+func getStringOrFail (key) = valueOrErrorMessage(getString(this, key), (("Mandatory this." + key) + " is not defined"))
98+
99+
100+func toAddressOrFail (addressStr) = valueOrErrorMessage(addressFromString(addressStr), ("couldn't parse passed addressStr=" + addressStr))
101+
102+
103+func toAssetVect (assetStr) = if ((assetStr == WAVESIDSTR))
104+ then unit
105+ else fromBase58String(assetStr)
106+
107+
108+func asInt (val) = match val {
109+ case valInt: Int =>
110+ valInt
111+ case _ =>
112+ throw("fail to cast into Int")
113+}
114+
115+
116+func formatHistoryRecord (oldAmount,oldStart,newAmount,newStart) = makeString(["%d%d%d%d%d%d", toString(lastBlock.height), toString(lastBlock.timestamp), toString(oldAmount), toString(oldStart), toString(newAmount), toString(newStart)], separator)
117+
118+
119+func formatClaimHistoryRecord (user,claimedRewards) = makeString(["%s%d%d%s", user, toString(lastBlock.height), toString(lastBlock.timestamp), claimedRewards], separator)
120+
121+
122+func HistoryRecordEntry (type,userAddress,txId,oldAmount,oldStart,newAmount,newStart) = StringEntry(keyHistoryRecord(type, userAddress, txId), formatHistoryRecord(oldAmount, oldStart, newAmount, newStart))
123+
124+
125+func ClaimHistoryEntry (userAddress,txId,claimedRewards) = StringEntry(keyHistoryRecord("claim", userAddress, txId), formatClaimHistoryRecord(toString(userAddress), claimedRewards))
126+
127+
128+func StatsResult (totalLockedInc,lockCountInc,usersCountInc) = {
129+ let locksCount = getIntOrZero(keyStatsLocksCount())
130+ let usersCount = getIntOrZero(keyStatsUsersCount())
131+ let totalAmount = getIntOrZero(keyLockParamTotalAmount())
132+ let totalAmountNew = (totalAmount + totalLockedInc)
133+ $Tuple3([IntegerEntry(keyStatsLocksCount(), (locksCount + lockCountInc)), IntegerEntry(keyStatsUsersCount(), (usersCount + usersCountInc)), IntegerEntry(keyLockParamTotalAmount(), totalAmountNew)], totalAmount, totalAmountNew)
134+ }
135+
136+
137+func LockParamsEntry (userAddress,amount,start) = [IntegerEntry(keyLockParamUserAmount(userAddress), amount), IntegerEntry(keyLockParamStartBlock(userAddress), start)]
138+
139+
140+func getParamsOrFail () = {
141+ let neutrinoContract = addressFromStringValue(getStringOrFail(keyNeutrinoContractAddress()))
142+ $Tuple4(fromBase58String(getStringValue(neutrinoContract, keyAuctionContractAddress())), fromBase58String(getStringValue(neutrinoContract, keyBondAsset())), getIntOrFail(keyMinLockAmount()), getIntOrFail(keyHalfLife()))
143+ }
144+
145+
146+func isActiveUser (userAddress) = (getIntOrElse(keyLockParamUserAmount(userAddress), 0) > 0)
147+
148+
149+func getUserParamsOrUnit (userAddress) = if (isActiveUser(userAddress))
150+ then $Tuple3(false, getIntOrFail(keyLockParamUserAmount(userAddress)), getIntOrFail(keyLockParamStartBlock(userAddress)))
151+ else unit
152+
153+
154+func getUserParamsOrFail (userAddress) = valueOrErrorMessage(getUserParamsOrUnit(userAddress), (("User " + toString(userAddress)) + " is not defined"))
155+
156+
157+let supportedAssetsStr = getStrOrElse(keySupportedRewardAssets(), "")
158+
159+let supportedAssetsList = split(supportedAssetsStr, "_")
160+
161+func calcReward (userAddress,assetId,stakedAmountX,depositNumUser,depositNumLast) = {
162+ let rewardPerNsbtSumLastKEY = keyRewardPerNsbtSumAt(depositNumLast, assetId)
163+ let sumLastX18 = parseBigIntValue(getStrOrElse(keyRewardPerNsbtSumAt(depositNumLast, assetId), "0"))
164+ let sumUserX18 = parseBigIntValue(getStrOrElse(keyRewardPerNsbtSumAt(depositNumUser, assetId), "0"))
165+ let rewardDynamicPart = toInt(fraction((sumLastX18 - sumUserX18), stakedAmountX, MULTX18))
166+ let rewardCachedPartKEY = keyReward(userAddress, assetId)
167+ let rewardCachedPart = getIntOrElse(rewardCachedPartKEY, 0)
168+ $Tuple4((rewardCachedPart + rewardDynamicPart), rewardCachedPart, rewardDynamicPart, rewardCachedPartKEY)
169+ }
170+
171+
172+func RewardEntries (isNewUser,userAddress,stakedAmount) = {
173+ let stakedAmountX = toBigInt(stakedAmount)
174+ let userRewardFromDepositNumKEY = keyUserRewardFromDepositNum(userAddress)
175+ let depositNumUser = getIntOrElse(userRewardFromDepositNumKEY, -1)
176+ let depositNumLast = getIntOrElse(keyDepositNumLast(), -1)
177+ func forEachAssetCacheUserReward (accum,asset) = {
178+ let $t074017536 = calcReward(userAddress, asset, stakedAmountX, depositNumUser, depositNumLast)
179+ let rewardTotal = $t074017536._1
180+ let cached = $t074017536._2
181+ let dynamic = $t074017536._3
182+ let rewardCachedPartKEY = $t074017536._4
183+ (accum :+ IntegerEntry(rewardCachedPartKEY, rewardTotal))
184+ }
185+
186+ if (if ((depositNumLast == -1))
187+ then (depositNumUser == -1)
188+ else false)
189+ then nil
190+ else if (if ((depositNumLast == -1))
191+ then (depositNumUser > -1)
192+ else false)
193+ then throw("invalid depositNumLast and depositNumUser state")
194+ else if (if ((depositNumLast > -1))
195+ then (depositNumUser == -1)
196+ else false)
197+ then if (isNewUser)
198+ then [IntegerEntry(userRewardFromDepositNumKEY, depositNumLast)]
199+ else ({
200+ let $l = supportedAssetsList
201+ let $s = size($l)
202+ let $acc0 = nil
203+ func $f0_1 ($a,$i) = if (($i >= $s))
204+ then $a
205+ else forEachAssetCacheUserReward($a, $l[$i])
206+
207+ func $f0_2 ($a,$i) = if (($i >= $s))
208+ then $a
209+ else throw("List size exceeds 10")
210+
211+ $f0_2($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)
212+ } :+ IntegerEntry(userRewardFromDepositNumKEY, depositNumLast))
213+ else if (if ((depositNumLast > -1))
214+ then (depositNumUser > -1)
215+ else false)
216+ then if (isNewUser)
217+ then [IntegerEntry(userRewardFromDepositNumKEY, depositNumLast)]
218+ else ({
219+ let $l = supportedAssetsList
220+ let $s = size($l)
221+ let $acc0 = nil
222+ func $f0_1 ($a,$i) = if (($i >= $s))
223+ then $a
224+ else forEachAssetCacheUserReward($a, $l[$i])
225+
226+ func $f0_2 ($a,$i) = if (($i >= $s))
227+ then $a
228+ else throw("List size exceeds 10")
229+
230+ $f0_2($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)
231+ } :+ IntegerEntry(userRewardFromDepositNumKEY, depositNumLast))
232+ else throw(((("uncovered condition: depositNumLast=" + toString(depositNumLast)) + " depositNumUser=") + toString(depositNumUser)))
233+ }
234+
235+
236+func IncrementNotDistributedRewardEntry (tkn,amountInc) = {
237+ let notDistributedRewardKEY = keyNotDistributedReward(tkn)
238+ let notDistributedReward = getIntOrElse(notDistributedRewardKEY, 0)
239+[IntegerEntry(notDistributedRewardKEY, (notDistributedReward + amountInc))]
240+ }
241+
242+
243+@Callable(i)
244+func constructor (neutrinoContractAddress,mathContractAddress,minLockAmount,halfLife,supportedRewardAssets) = if ((i.caller != this))
245+ then throw("Permission denied")
246+ else [StringEntry(keyNeutrinoContractAddress(), neutrinoContractAddress), StringEntry(keyMathContractAddress(), mathContractAddress), IntegerEntry(keyMinLockAmount(), minLockAmount), IntegerEntry(keyHalfLife(), halfLife), StringEntry(keySupportedRewardAssets(), supportedRewardAssets)]
247+
248+
249+
250+@Callable(i)
251+func stake () = {
252+ let $t01119011269 = getParamsOrFail()
253+ let auctionContract = $t01119011269._1
254+ let bondAssetId = $t01119011269._2
255+ let minLockAmount = $t01119011269._3
256+ let halfLife = $t01119011269._4
257+ if ((size(i.payments) != 1))
258+ then throw("Invalid payments size")
259+ else {
260+ let payment = i.payments[0]
261+ let amount = payment.amount
262+ let invalidAssetMessage = (("Invalid asset. " + toBase58String(bondAssetId)) + " is expected")
263+ let assetId = valueOrErrorMessage(payment.assetId, invalidAssetMessage)
264+ if ((assetId != bondAssetId))
265+ then throw(invalidAssetMessage)
266+ else {
267+ let userAddress = i.caller
268+ let userAddressStr = toString(i.caller)
269+ let $t01181111918 = valueOrElse(getUserParamsOrUnit(userAddress), $Tuple3(true, 0, -1))
270+ let isNewUser = $t01181111918._1
271+ let lockAmount = $t01181111918._2
272+ let lockStartHeight = $t01181111918._3
273+ let mergedAmount = if (isNewUser)
274+ then amount
275+ else (amount + lockAmount)
276+ let mergedStartHeight = if (isNewUser)
277+ then height
278+ else {
279+ let mathContract = addressFromStringValue(getStringOrFail(keyMathContractAddress()))
280+ asInt(invoke(mathContract, "mergeStakesREADONLY", [amount, height, lockAmount, lockStartHeight, halfLife], nil))
281+ }
282+ if ((minLockAmount > mergedAmount))
283+ then throw(("Min lock amount is " + toString(minLockAmount)))
284+ else {
285+ let $t01236812470 = StatsResult(amount, 1, if (isNewUser)
286+ then 1
287+ else 0)
288+ let statsEntries = $t01236812470._1
289+ let totalStaked = $t01236812470._2
290+ let totalStakedNew = $t01236812470._3
291+ ((([HistoryRecordEntry("stake", userAddress, i.transactionId, lockAmount, lockStartHeight, mergedAmount, mergedStartHeight)] ++ RewardEntries(isNewUser, userAddressStr, lockAmount)) ++ LockParamsEntry(userAddress, mergedAmount, mergedStartHeight)) ++ statsEntries)
292+ }
293+ }
294+ }
295+ }
296+
297+
298+
299+@Callable(i)
300+func unstake (amount) = if ((size(i.payments) != 0))
301+ then throw("unstake doesn't require any payment")
302+ else {
303+ let userAddress = i.caller
304+ let userAddressStr = toString(userAddress)
305+ let $t01295613034 = getParamsOrFail()
306+ let auctionAddress = $t01295613034._1
307+ let bondAssetId = $t01295613034._2
308+ let minLockAmount = $t01295613034._3
309+ let halfLife = $t01295613034._4
310+ let $t01303713111 = getUserParamsOrFail(userAddress)
311+ let isNewUser = $t01303713111._1
312+ let lockAmount = $t01303713111._2
313+ let lockStart = $t01303713111._3
314+ if ((0 >= lockAmount))
315+ then throw("Nothing to unstake")
316+ else if ((amount > lockAmount))
317+ then throw(((("Requested " + toString(amount)) + ", but staked only ") + toString(lockAmount)))
318+ else {
319+ let mathContract = addressFromStringValue(getStringOrFail(keyMathContractAddress()))
320+ let comissionAmount = asInt(invoke(mathContract, "getUnstakeComissionAmountREADONLY", [amount, lockStart, halfLife], nil))
321+ let $t01351213666 = StatsResult(-(amount), if ((amount == lockAmount))
322+ then -1
323+ else 0, if ((amount == lockAmount))
324+ then -1
325+ else 0)
326+ let statsEntries = $t01351213666._1
327+ let totalStaked = $t01351213666._2
328+ let totalStakedNew = $t01351213666._3
329+ ((([ScriptTransfer(userAddress, (amount - comissionAmount), bondAssetId), ScriptTransfer(Address(auctionAddress), comissionAmount, bondAssetId), HistoryRecordEntry("unstake", userAddress, i.transactionId, lockAmount, lockStart, (lockAmount - amount), lockStart)] ++ RewardEntries(false, userAddressStr, lockAmount)) ++ LockParamsEntry(userAddress, (lockAmount - amount), lockStart)) ++ statsEntries)
330+ }
331+ }
332+
333+
334+
335+@Callable(i)
336+func deposit () = if ((size(i.payments) != 1))
337+ then throw("exact 1 payment is allowed only")
338+ else {
339+ let pmt = i.payments[0]
340+ let amount = pmt.amount
341+ let pmtAssetId = valueOrElse(pmt.assetId, WAVESID)
342+ let pmtAssetIdStr = toBase58String(pmtAssetId)
343+ let pmtMultX = if ((pmtAssetId == WAVESID))
344+ then MULTX8
345+ else MULTX6
346+ let amountX = toBigInt(amount)
347+ let totalStaked = getIntOrElse(keyLockParamTotalAmount(), 0)
348+ let totalStakedX = toBigInt(totalStaked)
349+ if ((0 > totalStaked))
350+ then throw("TODO: case is not supported")
351+ else if ((totalStaked == 0))
352+ then IncrementNotDistributedRewardEntry(pmtAssetIdStr, amount)
353+ else {
354+ let rewardPerNsbtX18 = fraction(amountX, MULTX18, totalStakedX)
355+ let depositNumLastKEY = keyDepositNumLast()
356+ let depositNumLast = getIntOrElse(depositNumLastKEY, -1)
357+ let depositNumNew = (depositNumLast + 1)
358+ if (!(contains(supportedAssetsStr, pmtAssetIdStr)))
359+ then throw(((supportedAssetsStr + " doesn't contain ") + pmtAssetIdStr))
360+ else {
361+ func refreshRewardPerNsbtSUM (accum,nextAsset) = {
362+ let rewardPerNsbtSumNewKEY = keyRewardPerNsbtSumAt(depositNumNew, nextAsset)
363+ let sumLastStr = getStrOrElse(keyRewardPerNsbtSumAt(depositNumLast, nextAsset), "0")
364+ (accum :+ (if ((nextAsset == pmtAssetIdStr))
365+ then StringEntry(rewardPerNsbtSumNewKEY, toString((parseBigIntValue(sumLastStr) + rewardPerNsbtX18)))
366+ else StringEntry(rewardPerNsbtSumNewKEY, sumLastStr)))
367+ }
368+
369+ ({
370+ let $l = supportedAssetsList
371+ let $s = size($l)
372+ let $acc0 = nil
373+ func $f0_1 ($a,$i) = if (($i >= $s))
374+ then $a
375+ else refreshRewardPerNsbtSUM($a, $l[$i])
376+
377+ func $f0_2 ($a,$i) = if (($i >= $s))
378+ then $a
379+ else throw("List size exceeds 10")
380+
381+ $f0_2($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)
382+ } :+ IntegerEntry(depositNumLastKEY, depositNumNew))
383+ }
384+ }
385+ }
386+
387+
388+
389+@Callable(i)
390+func claimRewards () = {
391+ let userAddress = i.caller
392+ let userAddressStr = toString(userAddress)
393+ if ((size(i.payments) > 0))
394+ then throw("payments are not accepted")
395+ else {
396+ let $t01592216027 = valueOrElse(getUserParamsOrUnit(userAddress), $Tuple3(true, 0, 0))
397+ let isNewUser = $t01592216027._1
398+ let stakedAmount = $t01592216027._2
399+ let stakingStart = $t01592216027._3
400+ let stakedAmountX = toBigInt(stakedAmount)
401+ let userRewardFromDepositNumKEY = keyUserRewardFromDepositNum(userAddressStr)
402+ let depositNumUser = getIntOrElse(userRewardFromDepositNumKEY, -1)
403+ let depositNumLast = getIntOrElse(keyDepositNumLast(), -1)
404+ func forEachAssetCalcUnclaimedReward (accum,asset) = {
405+ let $t01639816536 = calcReward(userAddressStr, asset, stakedAmountX, depositNumUser, depositNumLast)
406+ let rewardTotal = $t01639816536._1
407+ let cached = $t01639816536._2
408+ let dynamic = $t01639816536._3
409+ let rewardCachedPartKEY = $t01639816536._4
410+ let claimedKEY = keyClaimed(userAddressStr, asset)
411+ let $t01659616633 = accum
412+ let data = $t01659616633._1
413+ let claimedAmtByAsset = $t01659616633._2
414+ let newPart = makeString([asset, toString(rewardTotal)], ":")
415+ let claimedAmtByAssetNew = makeString([claimedAmtByAsset, newPart], "_")
416+ if ((0 >= rewardTotal))
417+ then $Tuple2(data, claimedAmtByAssetNew)
418+ else $Tuple2((((data :+ ScriptTransfer(userAddress, rewardTotal, toAssetVect(asset))) :+ IntegerEntry(claimedKEY, (valueOrElse(getInteger(claimedKEY), 0) + rewardTotal))) :+ IntegerEntry(rewardCachedPartKEY, 0)), claimedAmtByAssetNew)
419+ }
420+
421+ let $t01709317207 = {
422+ let $l = supportedAssetsList
423+ let $s = size($l)
424+ let $acc0 = $Tuple2(nil, "")
425+ func $f0_1 ($a,$i) = if (($i >= $s))
426+ then $a
427+ else forEachAssetCalcUnclaimedReward($a, $l[$i])
428+
429+ func $f0_2 ($a,$i) = if (($i >= $s))
430+ then $a
431+ else throw("List size exceeds 10")
432+
433+ $f0_2($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)
434+ }
435+ let transfers = $t01709317207._1
436+ let claimedAmtByAssetResult = $t01709317207._2
437+ if ((0 >= size(transfers)))
438+ then throw("nothing to claim")
439+ else ((transfers :+ IntegerEntry(userRewardFromDepositNumKEY, depositNumLast)) :+ ClaimHistoryEntry(userAddress, i.transactionId, drop(claimedAmtByAssetResult, 1)))
440+ }
441+ }
442+
443+
444+
445+@Callable(i)
446+func unclaimedRewardsREADONLY (userAddressStr) = {
447+ func forEachAssetZeroReward (accum,asset) = ((accum + makeString([asset, "0", "0"], ":")) + "_")
448+
449+ let unclaimedRewardStr = if ((userAddressStr == ""))
450+ then {
451+ let $l = supportedAssetsList
452+ let $s = size($l)
453+ let $acc0 = ""
454+ func $f0_1 ($a,$i) = if (($i >= $s))
455+ then $a
456+ else forEachAssetZeroReward($a, $l[$i])
457+
458+ func $f0_2 ($a,$i) = if (($i >= $s))
459+ then $a
460+ else throw("List size exceeds 10")
461+
462+ $f0_2($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)
463+ }
464+ else {
465+ let userAddress = addressFromStringValue(userAddressStr)
466+ let $t01786617971 = valueOrElse(getUserParamsOrUnit(userAddress), $Tuple3(true, 0, 0))
467+ let isNewUser = $t01786617971._1
468+ let stakedAmount = $t01786617971._2
469+ let stakingStart = $t01786617971._3
470+ let stakedAmountX = toBigInt(stakedAmount)
471+ let userRewardFromDepositNumKEY = keyUserRewardFromDepositNum(userAddressStr)
472+ let depositNumUser = getIntOrElse(userRewardFromDepositNumKEY, -1)
473+ let depositNumLast = getIntOrElse(keyDepositNumLast(), -1)
474+ func forEachAssetCalcUnclaimedReward (accum,asset) = {
475+ let $t01831718455 = calcReward(userAddressStr, asset, stakedAmountX, depositNumUser, depositNumLast)
476+ let rewardTotal = $t01831718455._1
477+ let cached = $t01831718455._2
478+ let dynamic = $t01831718455._3
479+ let rewardCachedPartKEY = $t01831718455._4
480+ let claimed = valueOrElse(getInteger(keyClaimed(userAddressStr, asset)), 0)
481+ ((accum + makeString([asset, toString(rewardTotal), toString(claimed)], ":")) + "_")
482+ }
483+
484+ let $l = supportedAssetsList
485+ let $s = size($l)
486+ let $acc0 = ""
487+ func $f0_1 ($a,$i) = if (($i >= $s))
488+ then $a
489+ else forEachAssetCalcUnclaimedReward($a, $l[$i])
490+
491+ func $f0_2 ($a,$i) = if (($i >= $s))
492+ then $a
493+ else throw("List size exceeds 10")
494+
495+ $f0_2($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)
496+ }
497+ $Tuple2(nil, dropRight(unclaimedRewardStr, 1))
498+ }
499+
500+
501+
502+@Callable(i)
503+func nsbtStakingSYSREADONLY (userAddressStr) = {
504+ let totalNsbtAmt = getIntOrElse(keyLockParamTotalAmount(), 0)
505+ if ((userAddressStr == ""))
506+ then $Tuple2(nil, [0, totalNsbtAmt, 0])
507+ else {
508+ let userAddress = toAddressOrFail(userAddressStr)
509+ let $t01905919163 = valueOrElse(getUserParamsOrUnit(userAddress), $Tuple3(true, 0, 0))
510+ let isNewUser = $t01905919163._1
511+ let userNsbtAmt = $t01905919163._2
512+ let stakingStart = $t01905919163._3
513+ $Tuple2(nil, [userNsbtAmt, totalNsbtAmt, stakingStart])
514+ }
515+ }
516+
517+
518+@Verifier(tx)
519+func verify () = {
520+ let pubKeyAdminsList = ["GJdLSaLiv5K7xuejac8mcRcHoyo3dPrESrvktG3a6MAR", "FWVffYr2ALmHMejZm3WqeLz6Sdym3gLFGtJn4KTwyU5x", "3Wh2LaWcb5gg7K2pPcW3Ep6EAuRBzYkAgrdpt43jTDFa", "5WRXFSjwcTbNfKcJs8ZqXmSSWYsSVJUtMvMqZj5hH4Nc"]
521+ let count = ((((if (sigVerify(tx.bodyBytes, tx.proofs[0], fromBase58String(pubKeyAdminsList[0])))
522+ then 1
523+ else 0) + (if (sigVerify(tx.bodyBytes, tx.proofs[1], fromBase58String(pubKeyAdminsList[1])))
524+ then 1
525+ else 0)) + (if (sigVerify(tx.bodyBytes, tx.proofs[2], fromBase58String(pubKeyAdminsList[2])))
526+ then 1
527+ else 0)) + (if (sigVerify(tx.bodyBytes, tx.proofs[3], fromBase58String(pubKeyAdminsList[3])))
528+ then 2
529+ else 0))
530+ (count >= 3)
531+ }
532+

github/deemru/w8io/786bc32 
89.01 ms