2021.12.28 17:39 [2919277] smart account 3PGCkrHBxFMi7tz1xqnxgBpeNvn5E4M4g8S > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "123HQBFq8ShAv3kWgRXndhiuW2nqYFs9HfSirRhprGQV",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1640702289447,
    "version": 1,
    "sender": "3PGCkrHBxFMi7tz1xqnxgBpeNvn5E4M4g8S",
    "senderPublicKey": "CRRN9T4LWdYfw63q5x9XxR8P93XshdCac31Z65PbE6zv",
    "proofs": [
        "5PchZas5LtYiyckYGW6tbj5J4gNZCRnnDofVHKsmUmSmZ6h7xZaPqxzpQPByEAYyRg3iCv8t4Za7fBnMvupJyiqt"
    ],
    "script": "base64:AAIFAAAAAAAAAIsIAhIAEgMKAQgSBAoCCAgSABIDCgEIEgASABIDCgEBEgASCAoGCAgICAgBEgMKAQgSAwoBCBIDCgEIEgMKAQgSAwoBARIDCgEIEgQKAggEEgQKAggBEgMKAQgSBAoCCAESBAoCCAESAwoBCBIFCgMICAESBQoDCAgBEgMKAQgSABIDCgEIEgQKAggBAAAAWQEAAAAEZ2V0SQAAAAEAAAADa2V5CQAEGgAAAAIFAAAABHRoaXMFAAAAA2tleQEAAAAEZ2V0UwAAAAEAAAADa2V5CQAEHQAAAAIFAAAABHRoaXMFAAAAA2tleQEAAAAFZ2V0U1YAAAABAAAAA2tleQkBAAAABXZhbHVlAAAAAQkABB0AAAACBQAAAAR0aGlzBQAAAANrZXkBAAAAB3Rocm93SWYAAAACAAAACWNvbmRpdGlvbgAAAAVlcnJvcgMFAAAACWNvbmRpdGlvbgkAAAIAAAABBQAAAAVlcnJvcgYBAAAACHdyaXRlSW50AAAAAgAAAANrZXkAAAAFdmFsdWUDCQAAZgAAAAIAAAAAAAAAAAAFAAAABXZhbHVlCQAAAgAAAAEJAAEsAAAAAgkAASwAAAACCQABLAAAAAICAAAAF3dyaXRpbmcgbmVnYXRpdmUgdmFsdWUgCQABpAAAAAEFAAAABXZhbHVlAgAAAAkgZm9yIGtleSAFAAAAA2tleQkBAAAADEludGVnZXJFbnRyeQAAAAIFAAAAA2tleQUAAAAFdmFsdWUBAAAACGNoYW5nZUJ5AAAAAgAAAANrZXkAAAAFdmFsdWUJAQAAAAh3cml0ZUludAAAAAIFAAAAA2tleQkAAGQAAAACCQEAAAALdmFsdWVPckVsc2UAAAACCQEAAAAEZ2V0SQAAAAEFAAAAA2tleQAAAAAAAAAAAAUAAAAFdmFsdWUBAAAAC3dyaXRlU3RyaW5nAAAAAgAAAANrZXkAAAAFdmFsdWUJAQAAAAtTdHJpbmdFbnRyeQAAAAIFAAAAA2tleQUAAAAFdmFsdWUBAAAADGZyYWN0aW9uQ2VpbAAAAAMAAAAFdmFsdWUAAAAJbnVtZXJhdG9yAAAAC2Rlbm9taW5hdG9yBAAAAARjYW5kCQAAawAAAAMFAAAABXZhbHVlBQAAAAludW1lcmF0b3IFAAAAC2Rlbm9taW5hdG9yBAAAAAFEAAAAAAC1BPMzBAAAAAVleGFjdAkAAAAAAAACCQAAagAAAAIJAABoAAAAAgkAAGoAAAACBQAAAARjYW5kBQAAAAFECQAAagAAAAIFAAAAC2Rlbm9taW5hdG9yBQAAAAFEBQAAAAFECQAAagAAAAIJAABoAAAAAgkAAGoAAAACBQAAAAV2YWx1ZQUAAAABRAkAAGoAAAACBQAAAAludW1lcmF0b3IFAAAAAUQFAAAAAUQDBQAAAAVleGFjdAUAAAAEY2FuZAkAAGQAAAACBQAAAARjYW5kAAAAAAAAAAABAAAAAA1CbG9ja3NQZXJZZWFyAAAAAAAACAUgAAAAAAVSQmFzZQAAI4byb8EAAAAAAAALZmFjdG9yc0Jhc2UAAAAAAAAAA+gAAAAADGFzc2V0SWRTdG9yZQIAAAAHYXNzZXRJZAAAAAAJbWFpblN0b3JlAgAAAARtYWluAAAAABJyZXNlcnZlRmFjdG9yU3RvcmUJAAEsAAAAAgkBAAAABWdldFNWAAAAAQUAAAAMYXNzZXRJZFN0b3JlAgAAAA5fUmVzZXJ2ZUZhY3RvcgAAAAAVY29sbGF0ZXJhbEZhY3RvclN0b3JlCQABLAAAAAIJAQAAAAVnZXRTVgAAAAEFAAAADGFzc2V0SWRTdG9yZQIAAAARX0NvbGxhdGVyYWxGYWN0b3IAAAAAGWxpcXVpZGF0aW9uVGhyZXNob2xkU3RvcmUJAAEsAAAAAgkBAAAAEUBleHRyTmF0aXZlKDEwNTgpAAAAAQUAAAAMYXNzZXRJZFN0b3JlAgAAABVfTGlxdWlkYXRpb25UaHJlc2hvbGQAAAAAEm92ZXJsYXBDaGFyZ2VTdG9yZQIAAAAWYWNjb3VudF9oZWFsdGhfb3ZlcmxhcAAAAAAXbGlxdWlkYXRpb25QZW5hbHR5U3RvcmUJAAEsAAAAAgkBAAAAEUBleHRyTmF0aXZlKDEwNTgpAAAAAQUAAAAMYXNzZXRJZFN0b3JlAgAAABNfTGlxdWlkYXRpb25QZW5hbHR5AAAAABJjb25maWdBZGRyZXNzU3RvcmUCAAAADWNvbmZpZ0FkZHJlc3MAAAAAC29yYWNsZVN0b3JlAgAAAA1vcmFjbGVBZGRyZXNzAAAAAA1hVG9rZW5JZFN0b3JlAgAAAAhhVG9rZW5JZAAAAAAPYVRva2VuTmFtZVN0b3JlAgAAAAphVG9rZW5OYW1lAAAAABZhVG9rZW5DaXJjdWxhdGlvblN0b3JlAgAAABFhVG9rZW5DaXJjdWxhdGlvbgAAAAAVbGFzdFVwZGF0ZUhlaWdodFN0b3JlAgAAABBsYXN0VXBkYXRlSGVpZ2h0AAAAAA50b3RhbERlYnRTdG9yZQIAAAALdG90YWxCb3Jyb3cAAAAAEXRvdGFsRGVwb3NpdFN0b3JlAgAAAAx0b3RhbERlcG9zaXQAAAAAEXRvdGFsUmVzZXJ2ZVN0b3JlAgAAAAx0b3RhbFJlc2VydmUAAAAACmluZGV4U3RvcmUCAAAAC3N0b3JlZEluZGV4AAAAABNhVG9rZW5EZWNpbWFsc1N0b3JlAgAAAA5hVG9rZW5EZWNpbWFscwEAAAASYVRva2VuQmFsYW5jZVN0b3JlAAAAAQAAAAt1c2VyQWRkcmVzcwkAASwAAAACBQAAAAt1c2VyQWRkcmVzcwIAAAAOX2FUb2tlbkJhbGFuY2UBAAAACWRlYnRTdG9yZQAAAAEAAAALdXNlckFkZHJlc3MJAAEsAAAAAgUAAAALdXNlckFkZHJlc3MCAAAABV9kZWJ0AQAAAA5kZWJ0SW5kZXhTdG9yZQAAAAEAAAALdXNlckFkZHJlc3MJAAEsAAAAAgUAAAALdXNlckFkZHJlc3MCAAAABl9pbmRleAEAAAAUdXNlQXNDb2xsYXRlcmFsU3RvcmUAAAABAAAAC3VzZXJBZGRyZXNzCQABLAAAAAIFAAAAC3VzZXJBZGRyZXNzAgAAABBfdXNlQXNDb2xsYXRlcmFsAAAAAAdhc3NldElkBAAAAAJpZAkBAAAAE3ZhbHVlT3JFcnJvck1lc3NhZ2UAAAACCQEAAAAEZ2V0UwAAAAEFAAAADGFzc2V0SWRTdG9yZQIAAAAKbm8gYXNzZXRJZAMJAAAAAAAAAgUAAAACaWQCAAAABVdBVkVTBQAAAAR1bml0CQACWQAAAAEFAAAAAmlkAAAAAAphc3NldElkU3RyBAAAAAckbWF0Y2gwBQAAAAdhc3NldElkAwkAAAEAAAACBQAAAAckbWF0Y2gwAgAAAApCeXRlVmVjdG9yBAAAAAJidgUAAAAHJG1hdGNoMAkAAlgAAAABBQAAAAJidgMJAAABAAAAAgUAAAAHJG1hdGNoMAIAAAAEVW5pdAQAAAABdQUAAAAHJG1hdGNoMAIAAAAFV0FWRVMJAAACAAAAAQIAAAALTWF0Y2ggZXJyb3IBAAAACmdldEJhbGFuY2UAAAACAAAADmFkZHJlc3NPckFsaWFzAAAAB2Fzc2V0SWQEAAAAByRtYXRjaDAFAAAAB2Fzc2V0SWQDCQAAAQAAAAIFAAAAByRtYXRjaDACAAAACkJ5dGVWZWN0b3IEAAAAAmJ2BQAAAAckbWF0Y2gwCQAD8AAAAAIFAAAADmFkZHJlc3NPckFsaWFzBQAAAAJidgMJAAABAAAAAgUAAAAHJG1hdGNoMAIAAAAEVW5pdAQAAAABdQUAAAAHJG1hdGNoMAgJAAPvAAAAAQUAAAAOYWRkcmVzc09yQWxpYXMAAAAJYXZhaWxhYmxlCQAAAgAAAAECAAAAC01hdGNoIGVycm9yAAAAAA1hc3NldERlY2ltYWxzCQEAAAATdmFsdWVPckVycm9yTWVzc2FnZQAAAAIJAQAAAARnZXRJAAAAAQUAAAATYVRva2VuRGVjaW1hbHNTdG9yZQIAAAAQbm8gYXNzZXREZWNpbWFscwAAAAANY29uZmlnQWRkcmVzcwkBAAAAE3ZhbHVlT3JFcnJvck1lc3NhZ2UAAAACCQAEJgAAAAEJAQAAABN2YWx1ZU9yRXJyb3JNZXNzYWdlAAAAAgkBAAAABGdldFMAAAABBQAAABJjb25maWdBZGRyZXNzU3RvcmUCAAAAEG5vIGNvbmZpZ0FkZHJlc3MCAAAAFmludmFsaWQgY29uZmlnIGFkZHJlc3MBAAAACW9wQWxsb3dlZAAAAAEAAAACb3AEAAAAA2FpZAkBAAAAE3ZhbHVlT3JFcnJvck1lc3NhZ2UAAAACCQEAAAAEZ2V0UwAAAAEFAAAADGFzc2V0SWRTdG9yZQIAAAAKbm8gYXNzZXRJZAQAAAAHJG1hdGNoMAkAA/wAAAAEBQAAAA1jb25maWdBZGRyZXNzAgAAAAlvcEFsbG93ZWQJAARMAAAAAgUAAAADYWlkCQAETAAAAAIFAAAAAm9wBQAAAANuaWwFAAAAA25pbAMJAAABAAAAAgUAAAAHJG1hdGNoMAIAAAAHQm9vbGVhbgQAAAABYgUAAAAHJG1hdGNoMAMFAAAAAWIGCQAAAgAAAAECAAAAC25vdCBhbGxvd2VkCQAAAgAAAAECAAAAIW9wQWxsb3dlZDogdW5leHBlY3RlZCByZXN1bHQgdHlwZQEAAAAIbWFpbk9ubHkAAAABAAAAAWkDCQEAAAACIT0AAAACCAUAAAABaQAAAAZjYWxsZXIJAQAAABN2YWx1ZU9yRXJyb3JNZXNzYWdlAAAAAgkABCYAAAABCQEAAAATdmFsdWVPckVycm9yTWVzc2FnZQAAAAIJAAQdAAAAAgUAAAANY29uZmlnQWRkcmVzcwUAAAAJbWFpblN0b3JlAgAAABFubyBtYWluIGluIGNvbmZpZwIAAAAUaW52YWxpZCBtYWluIGFkZHJlc3MJAAACAAAAAQIAAAAQb25seSBtYWluIGNhbiBkbwYBAAAADGRpdkFkbWluT25seQAAAAEAAAABaQQAAAAJZGl2QWRtaW5zCQEAAAATdmFsdWVPckVycm9yTWVzc2FnZQAAAAIJAAQdAAAAAgUAAAANY29uZmlnQWRkcmVzcwIAAAAJZGl2QWRtaW5zAgAAAA1ubyBkaXYgYWRtaW5zAwkBAAAAASEAAAABCQEAAAAIY29udGFpbnMAAAACBQAAAAlkaXZBZG1pbnMJAAQlAAAAAQgFAAAAAWkAAAAGY2FsbGVyCQAAAgAAAAECAAAAFW9ubHkgZGl2IGFkbWluIGNhbiBkbwYBAAAAEGlzQXNzZXRJZE9yV2F2ZXMAAAABAAAABXZhbHVlAwMJAQAAAAIhPQAAAAIFAAAABXZhbHVlAgAAAAVXQVZFUwkAAAAAAAACCQACWQAAAAEFAAAABXZhbHVlCQACWQAAAAECAAAAAAcJAAACAAAAAQIAAAAPaW52YWxpZCBhc3NldElkBgAAAAAObm90SW5pdGlhbGl6ZWQJAQAAAAd0aHJvd0lmAAAAAgkBAAAACWlzRGVmaW5lZAAAAAEJAQAAAARnZXRTAAAAAQUAAAAMYXNzZXRJZFN0b3JlAgAAABNhbHJlYWR5IGluaXRpYWxpemVkAAAAABJtYXliZU9yYWNsZUFkZHJlc3MEAAAAByRtYXRjaDAJAQAAAARnZXRTAAAAAQUAAAALb3JhY2xlU3RvcmUDCQAAAQAAAAIFAAAAByRtYXRjaDACAAAABlN0cmluZwQAAAABcwUAAAAHJG1hdGNoMAkABCYAAAABBQAAAAFzBQAAAAR1bml0AAAAAAtvcmFjbGVQcmljZQQAAAAHJG1hdGNoMAkAA/wAAAAECQEAAAATdmFsdWVPckVycm9yTWVzc2FnZQAAAAIFAAAAEm1heWJlT3JhY2xlQWRkcmVzcwIAAAAJbm8gb3JhY2xlAgAAAAVwcmljZQkABEwAAAACCQEAAAAFZ2V0U1YAAAABBQAAAAxhc3NldElkU3RvcmUFAAAAA25pbAUAAAADbmlsAwkAAAEAAAACBQAAAAckbWF0Y2gwAgAAAANJbnQEAAAAAWkFAAAAByRtYXRjaDAFAAAAAWkJAAACAAAAAQIAAAAPYmFkIG9yYWNsZSBkYXRhAAAAAAZIRUlHSFQFAAAABmhlaWdodAAAAAAQbGFzdFVwZGF0ZUhlaWdodAkBAAAAE3ZhbHVlT3JFcnJvck1lc3NhZ2UAAAACCQEAAAAEZ2V0SQAAAAEFAAAAFWxhc3RVcGRhdGVIZWlnaHRTdG9yZQIAAAATbm8gbGFzdFVwZGF0ZUhlaWdodAAAAAAIYVRva2VuSWQJAAJZAAAAAQkBAAAAE3ZhbHVlT3JFcnJvck1lc3NhZ2UAAAACCQEAAAAEZ2V0UwAAAAEFAAAADWFUb2tlbklkU3RvcmUCAAAAC25vIGFUb2tlbklkAAAAABFhVG9rZW5DaXJjdWxhdGlvbgkBAAAAC3ZhbHVlT3JFbHNlAAAAAgkBAAAABGdldEkAAAABBQAAABZhVG9rZW5DaXJjdWxhdGlvblN0b3JlAAAAAAAAAAAAAAAAAARBQkNEBAAAAAJpZAkBAAAABWdldFNWAAAAAQUAAAAMYXNzZXRJZFN0b3JlCQAFFgAAAAQJAQAAABFAZXh0ck5hdGl2ZSgxMDUwKQAAAAIFAAAADWNvbmZpZ0FkZHJlc3MJAAEsAAAAAgUAAAACaWQCAAAAB19BUG9pbnQJAQAAABFAZXh0ck5hdGl2ZSgxMDUwKQAAAAIFAAAADWNvbmZpZ0FkZHJlc3MJAAEsAAAAAgUAAAACaWQCAAAAB19CUG9pbnQJAQAAABFAZXh0ck5hdGl2ZSgxMDUwKQAAAAIFAAAADWNvbmZpZ0FkZHJlc3MJAAEsAAAAAgUAAAACaWQCAAAAB19DUG9pbnQJAQAAABFAZXh0ck5hdGl2ZSgxMDUwKQAAAAIFAAAADWNvbmZpZ0FkZHJlc3MJAAEsAAAAAgUAAAACaWQCAAAAB19EUG9pbnQAAAAADXJlc2VydmVGYWN0b3IJAQAAABN2YWx1ZU9yRXJyb3JNZXNzYWdlAAAAAgkABBoAAAACBQAAAA1jb25maWdBZGRyZXNzBQAAABJyZXNlcnZlRmFjdG9yU3RvcmUCAAAAEG5vIHJlc2VydmVGYWN0b3IAAAAAEGNvbGxhdGVyYWxGYWN0b3IJAQAAABN2YWx1ZU9yRXJyb3JNZXNzYWdlAAAAAgkABBoAAAACBQAAAA1jb25maWdBZGRyZXNzBQAAABVjb2xsYXRlcmFsRmFjdG9yU3RvcmUCAAAAE25vIGNvbGxhdGVyYWxGYWN0b3IAAAAAFGxpcXVpZGF0aW9uVGhyZXNob2xkCQEAAAATdmFsdWVPckVycm9yTWVzc2FnZQAAAAIJAAQaAAAAAgUAAAANY29uZmlnQWRkcmVzcwUAAAAZbGlxdWlkYXRpb25UaHJlc2hvbGRTdG9yZQIAAAAXbm8gbGlxdWlkYXRpb25UaHJlc2hvbGQAAAAAFGFjY291bnRIZWFsdGhPdmVybGFwCQEAAAATdmFsdWVPckVycm9yTWVzc2FnZQAAAAIJAAQaAAAAAgUAAAANY29uZmlnQWRkcmVzcwUAAAASb3ZlcmxhcENoYXJnZVN0b3JlAgAAABBubyBvdmVybGFwQ2hhcmdlAAAAABJsaXF1aWRhdGlvblBlbmFsdHkJAQAAABN2YWx1ZU9yRXJyb3JNZXNzYWdlAAAAAgkABBoAAAACBQAAAA1jb25maWdBZGRyZXNzBQAAABdsaXF1aWRhdGlvblBlbmFsdHlTdG9yZQIAAAAVbm8gbGlxdWlkYXRpb25QZW5hbHR5AAAAABJzdG9yZWRUb3RhbERlcG9zaXQJAQAAAAt2YWx1ZU9yRWxzZQAAAAIJAQAAAARnZXRJAAAAAQUAAAARdG90YWxEZXBvc2l0U3RvcmUAAAAAAAAAAAAAAAAAEnN0b3JlZFRvdGFsUmVzZXJ2ZQkBAAAAC3ZhbHVlT3JFbHNlAAAAAgkBAAAABGdldEkAAAABBQAAABF0b3RhbFJlc2VydmVTdG9yZQAAAAAAAAAAAAAAAAAPc3RvcmVkVG90YWxEZWJ0CQEAAAALdmFsdWVPckVsc2UAAAACCQEAAAAEZ2V0SQAAAAEFAAAADnRvdGFsRGVidFN0b3JlAAAAAAAAAAAAAAAAAAtzdG9yZWRJbmRleAkBAAAAC3ZhbHVlT3JFbHNlAAAAAgkBAAAABGdldEkAAAABBQAAAAppbmRleFN0b3JlBQAAAAVSQmFzZQAAAAALdXRpbGl6YXRpb24DCQAAZgAAAAIFAAAAEnN0b3JlZFRvdGFsRGVwb3NpdAAAAAAAAAAAAAkAAGsAAAADBQAAAA9zdG9yZWRUb3RhbERlYnQFAAAAC2ZhY3RvcnNCYXNlBQAAABJzdG9yZWRUb3RhbERlcG9zaXQAAAAAAAAAAAAAAAAAA2FwcgQAAAALJHQwNTc1ODU3NzgFAAAABEFCQ0QEAAAAAWEIBQAAAAskdDA1NzU4NTc3OAAAAAJfMQQAAAABYggFAAAACyR0MDU3NTg1Nzc4AAAAAl8yBAAAAAFjCAUAAAALJHQwNTc1ODU3NzgAAAACXzMEAAAAAWQIBQAAAAskdDA1NzU4NTc3OAAAAAJfNAQAAAAGbGluZUFDCQAAZAAAAAIJAABrAAAAAwkAAGUAAAACBQAAAAFhBQAAAAFjBQAAAAt1dGlsaXphdGlvbgkBAAAAAS0AAAABBQAAAAFiBQAAAAFhBAAAAAZsaW5lQ0QJAABkAAAAAgkAAGsAAAADCQAAZQAAAAIFAAAAAWMFAAAAAWQJAABlAAAAAgUAAAALdXRpbGl6YXRpb24FAAAAAWIJAABlAAAAAgUAAAABYgUAAAALZmFjdG9yc0Jhc2UFAAAAAWMDCQAAAAAAAAIFAAAAC3V0aWxpemF0aW9uAAAAAAAAAAAABQAAAAFhAwkAAAAAAAACBQAAAAt1dGlsaXphdGlvbgUAAAABYgUAAAABYwMDCQAAZgAAAAIFAAAAAWIFAAAAC3V0aWxpemF0aW9uBgkAAAAAAAACBQAAAAFiBQAAAAtmYWN0b3JzQmFzZQUAAAAGbGluZUFDBQAAAAZsaW5lQ0QAAAAAA2FweQMJAAAAAAAAAgUAAAASc3RvcmVkVG90YWxEZXBvc2l0AAAAAAAAAAAAAAAAAAAAAAAACQAAawAAAAMJAABrAAAAAwUAAAAPc3RvcmVkVG90YWxEZWJ0BQAAAANhcHIFAAAAEnN0b3JlZFRvdGFsRGVwb3NpdAkAAGUAAAACBQAAAAtmYWN0b3JzQmFzZQUAAAANcmVzZXJ2ZUZhY3RvcgUAAAALZmFjdG9yc0Jhc2UAAAAADGN1cnJlbnRJbmRleAMJAAAAAAAAAgUAAAAGSEVJR0hUBQAAABBsYXN0VXBkYXRlSGVpZ2h0BQAAAAtzdG9yZWRJbmRleAQAAAADYnByCQEAAAAMZnJhY3Rpb25DZWlsAAAAAwUAAAADYXByBQAAAAVSQmFzZQkAAGgAAAACBQAAAA1CbG9ja3NQZXJZZWFyBQAAAAtmYWN0b3JzQmFzZQkBAAAADGZyYWN0aW9uQ2VpbAAAAAMFAAAAC3N0b3JlZEluZGV4CQAAZAAAAAIFAAAABVJCYXNlCQAAaAAAAAIFAAAAA2JwcgkAAGUAAAACBQAAAAZIRUlHSFQFAAAAEGxhc3RVcGRhdGVIZWlnaHQFAAAABVJCYXNlAQAAAA5saXF1aWRpdHlDaGVjawAAAAMAAAAGYW1vdW50AAAAA21heAAAAANlcnIDCQAAZgAAAAIFAAAABmFtb3VudAUAAAADbWF4CQAAAgAAAAEJAAEsAAAAAgIAAAAWbm90IGVub3VnaCBsaXF1aWRpdHk6IAUAAAADZXJyBgEAAAAOc3RvcmVkVXNlckRlYnQAAAABAAAAC3VzZXJBZGRyZXNzCQEAAAALdmFsdWVPckVsc2UAAAACCQEAAAAEZ2V0SQAAAAEJAQAAAAlkZWJ0U3RvcmUAAAABBQAAAAt1c2VyQWRkcmVzcwAAAAAAAAAAAAEAAAAPY3VycmVudFVzZXJEZWJ0AAAAAQAAAAt1c2VyQWRkcmVzcwQAAAABdgkBAAAADnN0b3JlZFVzZXJEZWJ0AAAAAQUAAAALdXNlckFkZHJlc3MDCQAAAAAAAAIFAAAAAXYAAAAAAAAAAAAAAAAAAAAAAAAEAAAAD3N0b3JlZFVzZXJJbmRleAkBAAAAE3ZhbHVlT3JFcnJvck1lc3NhZ2UAAAACCQEAAAAEZ2V0SQAAAAEJAQAAAA5kZWJ0SW5kZXhTdG9yZQAAAAEFAAAAC3VzZXJBZGRyZXNzAgAAACBoYXMgZGVidCBidXQgZG9lcyBub3QgaGF2ZSBpbmRleAkAAGsAAAADBQAAAAF2BQAAAAxjdXJyZW50SW5kZXgFAAAAD3N0b3JlZFVzZXJJbmRleAAAAAAQY3VycmVudFRvdGFsRGVidAkAAGsAAAADBQAAAA9zdG9yZWRUb3RhbERlYnQFAAAADGN1cnJlbnRJbmRleAUAAAALc3RvcmVkSW5kZXgAAAAACWFkZGVkRGVidAkAAGUAAAACBQAAABBjdXJyZW50VG90YWxEZWJ0BQAAAA9zdG9yZWRUb3RhbERlYnQAAAAADGFkZGVkRGVwb3NpdAkAAGsAAAADBQAAAAlhZGRlZERlYnQJAABlAAAAAgUAAAALZmFjdG9yc0Jhc2UFAAAADXJlc2VydmVGYWN0b3IFAAAAC2ZhY3RvcnNCYXNlAAAAABNjdXJyZW50VG90YWxEZXBvc2l0CQAAZAAAAAIFAAAAEnN0b3JlZFRvdGFsRGVwb3NpdAUAAAAMYWRkZWREZXBvc2l0AAAAABNjdXJyZW50VG90YWxSZXNlcnZlCQAAZQAAAAIJAABkAAAAAgUAAAASc3RvcmVkVG90YWxSZXNlcnZlBQAAAAlhZGRlZERlYnQFAAAADGFkZGVkRGVwb3NpdAEAAAANcGF5bWVudEFtb3VudAAAAAIAAAABaQAAAAdhc3NldElkBAAAAAFwCAkAAZEAAAACCAUAAAABaQAAAAhwYXltZW50cwAAAAAAAAAAAAAAAAZhbW91bnQDCQAAZwAAAAIAAAAAAAAAAAAFAAAAAXAJAAACAAAAAQIAAAAnUGF5bWVudCBpcyBsZXNzIHRoYW4gbWluIGFsbG93ZWQgYW1vdW50AwkBAAAAAiE9AAAAAggJAAGRAAAAAggFAAAAAWkAAAAIcGF5bWVudHMAAAAAAAAAAAAAAAAHYXNzZXRJZAUAAAAHYXNzZXRJZAkAAAIAAAABCQABLAAAAAICAAAAHWJhZCBhc3NldCBhdHRhY2hlZDogcmVxdWlyZWQgBQAAAAphc3NldElkU3RyBQAAAAFwAQAAAApzeW5jVG90YWxzAAAABAAAABFhZGRpdGlvbmFsRGVwb3NpdAAAAA5hZGRpdGlvbmFsRGVidAAAABFhZGRpdGlvbmFsUmVzZXJ2ZQAAAA1rZWVwQXRCYWxhbmNlBAAAAA1hY3R1YWxCYWxhbmNlBAAAAAckbWF0Y2gwBQAAAAdhc3NldElkAwkAAAEAAAACBQAAAAckbWF0Y2gwAgAAAApCeXRlVmVjdG9yBAAAAANhaWQFAAAAByRtYXRjaDAJAAPwAAAAAgUAAAAEdGhpcwUAAAADYWlkCAkAA+8AAAABBQAAAAR0aGlzAAAACWF2YWlsYWJsZQQAAAANc3Rha2luZ0FjdGlvbgMJAAAAAAAAAgUAAAANYWN0dWFsQmFsYW5jZQUAAAANa2VlcEF0QmFsYW5jZQUAAAAEdW5pdAQAAAAOc3Rha2luZ0VuYWJsZWQJAQAAAAt2YWx1ZU9yRWxzZQAAAAIJAAQbAAAAAgUAAAANY29uZmlnQWRkcmVzcwkAASwAAAACAgAAABBzdGFraW5nX2VuYWJsZWRfBQAAAAphc3NldElkU3RyBwMJAQAAAAEhAAAAAQUAAAAOc3Rha2luZ0VuYWJsZWQFAAAABHVuaXQEAAAADnN0YWtpbmdBZGRyZXNzCQEAAAATdmFsdWVPckVycm9yTWVzc2FnZQAAAAIJAAQmAAAAAQkBAAAAE3ZhbHVlT3JFcnJvck1lc3NhZ2UAAAACCQAEHQAAAAIFAAAADWNvbmZpZ0FkZHJlc3MJAAEsAAAAAgIAAAAPc3Rha2luZ19jb25maWdfBQAAAAphc3NldElkU3RyCQABLAAAAAICAAAAF25vIHN0YWtpbmcgYWRkcmVzcyBmb3IgBQAAAAphc3NldElkU3RyCQABLAAAAAICAAAAGGJhZCBzdGFraW5nIGFkZHJlc3MgZm9yIAUAAAAKYXNzZXRJZFN0cgMJAABmAAAAAgUAAAANYWN0dWFsQmFsYW5jZQUAAAANa2VlcEF0QmFsYW5jZQkAA/wAAAAEBQAAAA5zdGFraW5nQWRkcmVzcwIAAAADcHV0BQAAAANuaWwJAARMAAAAAgkBAAAAD0F0dGFjaGVkUGF5bWVudAAAAAIFAAAAB2Fzc2V0SWQJAABlAAAAAgUAAAANYWN0dWFsQmFsYW5jZQUAAAANa2VlcEF0QmFsYW5jZQUAAAADbmlsCQAD/AAAAAQFAAAADnN0YWtpbmdBZGRyZXNzAgAAAANnZXQJAARMAAAAAgkAAGUAAAACBQAAAA1rZWVwQXRCYWxhbmNlBQAAAA1hY3R1YWxCYWxhbmNlBQAAAANuaWwFAAAAA25pbAMJAAAAAAAAAgUAAAANc3Rha2luZ0FjdGlvbgUAAAANc3Rha2luZ0FjdGlvbgkABEwAAAACCQEAAAAId3JpdGVJbnQAAAACBQAAAAppbmRleFN0b3JlBQAAAAxjdXJyZW50SW5kZXgJAARMAAAAAgkBAAAACHdyaXRlSW50AAAAAgUAAAAVbGFzdFVwZGF0ZUhlaWdodFN0b3JlBQAAAAZIRUlHSFQJAARMAAAAAgkBAAAACHdyaXRlSW50AAAAAgUAAAARdG90YWxEZXBvc2l0U3RvcmUJAABkAAAAAgUAAAATY3VycmVudFRvdGFsRGVwb3NpdAUAAAARYWRkaXRpb25hbERlcG9zaXQJAARMAAAAAgkBAAAACHdyaXRlSW50AAAAAgUAAAAOdG90YWxEZWJ0U3RvcmUJAABkAAAAAgUAAAAQY3VycmVudFRvdGFsRGVidAUAAAAOYWRkaXRpb25hbERlYnQJAARMAAAAAgkBAAAACHdyaXRlSW50AAAAAgUAAAARdG90YWxSZXNlcnZlU3RvcmUJAABkAAAAAgUAAAATY3VycmVudFRvdGFsUmVzZXJ2ZQUAAAARYWRkaXRpb25hbFJlc2VydmUFAAAAA25pbAkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BAAAABXBvdzEwAAAAAQAAAAFuAwkAAAAAAAACBQAAAAFuAAAAAAAAAAAGAAAAAAAAD0JAAwkAAAAAAAACBQAAAAFuAAAAAAAAAAAIAAAAAAAF9eEACQAAAgAAAAEJAAEsAAAAAgIAAAAOYmFkIGRlY2ltYWxzOiAJAAGkAAAAAQUAAAABbgEAAAAKYXNzZXRUb1VzZAAAAAEAAAAGYW1vdW50CQAAawAAAAMFAAAABmFtb3VudAUAAAALb3JhY2xlUHJpY2UJAQAAAAVwb3cxMAAAAAEFAAAADWFzc2V0RGVjaW1hbHMBAAAACnVzZFRvQXNzZXQAAAABAAAABmFtb3VudAkAAGsAAAADBQAAAAZhbW91bnQJAQAAAAVwb3cxMAAAAAEFAAAADWFzc2V0RGVjaW1hbHMFAAAAC29yYWNsZVByaWNlAQAAAA1hVG9rZW5Ub0Fzc2V0AAAAAQAAAAxhVG9rZW5BbW91bnQDCQAAAAAAAAIFAAAADGFUb2tlbkFtb3VudAAAAAAAAAAAAAAAAAAAAAAAAAMJAABmAAAAAgUAAAARYVRva2VuQ2lyY3VsYXRpb24AAAAAAAAAAAAJAABrAAAAAwUAAAAMYVRva2VuQW1vdW50BQAAABNjdXJyZW50VG90YWxEZXBvc2l0BQAAABFhVG9rZW5DaXJjdWxhdGlvbgUAAAAMYVRva2VuQW1vdW50AQAAAA1hc3NldFRvQVRva2VuAAAAAQAAAAthc3NldEFtb3VudAMJAAAAAAAAAgUAAAALYXNzZXRBbW91bnQAAAAAAAAAAAAAAAAAAAAAAAADCQAAZgAAAAIFAAAAEWFUb2tlbkNpcmN1bGF0aW9uAAAAAAAAAAAACQAAawAAAAMFAAAAC2Fzc2V0QW1vdW50BQAAABFhVG9rZW5DaXJjdWxhdGlvbgUAAAATY3VycmVudFRvdGFsRGVwb3NpdAUAAAALYXNzZXRBbW91bnQBAAAAEWFzc2V0VG9BVG9rZW5DZWlsAAAAAQAAAAthc3NldEFtb3VudAMJAAAAAAAAAgUAAAALYXNzZXRBbW91bnQAAAAAAAAAAAAAAAAAAAAAAAADCQAAZgAAAAIFAAAAEWFUb2tlbkNpcmN1bGF0aW9uAAAAAAAAAAAACQEAAAAMZnJhY3Rpb25DZWlsAAAAAwUAAAALYXNzZXRBbW91bnQFAAAAEWFUb2tlbkNpcmN1bGF0aW9uBQAAABNjdXJyZW50VG90YWxEZXBvc2l0BQAAAAthc3NldEFtb3VudAEAAAANYVRva2VuQmFsYW5jZQAAAAEAAAAHYWRkcmVzcwkBAAAAC3ZhbHVlT3JFbHNlAAAAAgkBAAAABGdldEkAAAABCQEAAAASYVRva2VuQmFsYW5jZVN0b3JlAAAAAQUAAAAHYWRkcmVzcwAAAAAAAAAAAAEAAAAJZW5hYmxlQ29sAAAAAQAAAAR1c2VyCQEAAAAMQm9vbGVhbkVudHJ5AAAAAgkBAAAAFHVzZUFzQ29sbGF0ZXJhbFN0b3JlAAAAAQUAAAAEdXNlcgYBAAAAEWVuYWJsZUNvbElmTmVlZGVkAAAAAQAAAAR1c2VyAwkAAGYAAAACCQEAAAAPY3VycmVudFVzZXJEZWJ0AAAAAQUAAAAEdXNlcgAAAAAAAAAAAAkABEwAAAACCQEAAAAJZW5hYmxlQ29sAAAAAQUAAAAEdXNlcgUAAAADbmlsBQAAAANuaWwBAAAADGNvbGxhcHNlVXNlcgAAAAIAAAAHYWRkcmVzcwAAAAZhbW91bnQEAAAABGRlYnQJAQAAAA9jdXJyZW50VXNlckRlYnQAAAABBQAAAAdhZGRyZXNzBAAAAAdkZXBvc2l0CQEAAAANYVRva2VuVG9Bc3NldAAAAAEJAQAAAA1hVG9rZW5CYWxhbmNlAAAAAQUAAAAHYWRkcmVzcwQAAAALbWF4UG9zc2libGUJAAGXAAAAAQkABEwAAAACBQAAAARkZWJ0CQAETAAAAAIFAAAAB2RlcG9zaXQFAAAAA25pbAQAAAADYW10AwkAAGYAAAACAP//////////BQAAAAZhbW91bnQJAAACAAAAAQIAAAAXaW52YWxpZCBjb2xsYXBzZSBhbW91bnQDAwkAAAAAAAACBQAAAAttYXhQb3NzaWJsZQAAAAAAAAAAAAYJAAAAAAAAAgUAAAAGYW1vdW50AAAAAAAAAAAACQAAAgAAAAECAAAAE25vdGhpbmcgdG8gY29sbGFwc2UDAwkAAAAAAAACBQAAAAZhbW91bnQA//////////8GCQAAZgAAAAIFAAAABmFtb3VudAUAAAALbWF4UG9zc2libGUFAAAAC21heFBvc3NpYmxlBQAAAAZhbW91bnQEAAAADnJlbW92ZWRBdG9rZW5zCQEAAAARYXNzZXRUb0FUb2tlbkNlaWwAAAABBQAAAANhbXQJAAUUAAAAAgkABE4AAAACCQEAAAAKc3luY1RvdGFscwAAAAQJAQAAAAEtAAAAAQUAAAADYW10CQEAAAABLQAAAAEFAAAAA2FtdAAAAAAAAAAAAAAAAAAAAAAAAAkABEwAAAACCQEAAAAIY2hhbmdlQnkAAAACCQEAAAASYVRva2VuQmFsYW5jZVN0b3JlAAAAAQUAAAAHYWRkcmVzcwkBAAAAAS0AAAABBQAAAA5yZW1vdmVkQXRva2VucwkABEwAAAACCQEAAAAIY2hhbmdlQnkAAAACBQAAABZhVG9rZW5DaXJjdWxhdGlvblN0b3JlCQEAAAABLQAAAAEFAAAADnJlbW92ZWRBdG9rZW5zCQAETAAAAAIJAQAAAAh3cml0ZUludAAAAAIJAQAAAAlkZWJ0U3RvcmUAAAABBQAAAAdhZGRyZXNzCQAAZQAAAAIFAAAABGRlYnQFAAAAA2FtdAkABEwAAAACCQEAAAAId3JpdGVJbnQAAAACCQEAAAAOZGVidEluZGV4U3RvcmUAAAABBQAAAAdhZGRyZXNzBQAAAAxjdXJyZW50SW5kZXgFAAAAA25pbAUAAAADYW10AQAAAAlyZXBheVVzZXIAAAACAAAAC3VzZXJBZGRyZXNzAAAABmFtb3VudAQAAAAGY2hlY2tzCQEAAAAJb3BBbGxvd2VkAAAAAQIAAAAFcmVwYXkDCQAAAAAAAAIFAAAABmNoZWNrcwUAAAAGY2hlY2tzBAAAAAtjdXJyZW50RGVidAkBAAAAD2N1cnJlbnRVc2VyRGVidAAAAAEFAAAAC3VzZXJBZGRyZXNzAwkAAAAAAAACBQAAAAtjdXJyZW50RGVidAUAAAALY3VycmVudERlYnQEAAAADSR0MDExMDk1MTEzOTgDCQAAZgAAAAIFAAAABmFtb3VudAUAAAALY3VycmVudERlYnQJAAUWAAAABAAAAAAAAAAAAAkBAAAAAS0AAAABBQAAAAtjdXJyZW50RGVidAkAAGUAAAACBQAAAAZhbW91bnQFAAAAC2N1cnJlbnREZWJ0CQAETAAAAAIJAQAAAA5TY3JpcHRUcmFuc2ZlcgAAAAMJAQAAABFAZXh0ck5hdGl2ZSgxMDYyKQAAAAEFAAAAC3VzZXJBZGRyZXNzCQAAZQAAAAIFAAAABmFtb3VudAUAAAALY3VycmVudERlYnQFAAAAB2Fzc2V0SWQFAAAAA25pbAkABRYAAAAECQAAZQAAAAIFAAAAC2N1cnJlbnREZWJ0BQAAAAZhbW91bnQJAQAAAAEtAAAAAQUAAAAGYW1vdW50AAAAAAAAAAAABQAAAANuaWwEAAAAB25ld0RlYnQIBQAAAA0kdDAxMTA5NTExMzk4AAAAAl8xBAAAAA90b3RhbERlYnRVcGRhdGUIBQAAAA0kdDAxMTA5NTExMzk4AAAAAl8yBAAAAAZwYXlvdXQIBQAAAA0kdDAxMTA5NTExMzk4AAAAAl8zBAAAAAdhY3Rpb25zCAUAAAANJHQwMTEwOTUxMTM5OAAAAAJfNAQAAAAGcmVwYWlkCQAAZQAAAAIFAAAABmFtb3VudAUAAAAGcGF5b3V0CQAFFAAAAAIJAAROAAAAAgkABE4AAAACCQEAAAAKc3luY1RvdGFscwAAAAQAAAAAAAAAAAAFAAAAD3RvdGFsRGVidFVwZGF0ZQAAAAAAAAAAAAUAAAAGcGF5b3V0BQAAAAdhY3Rpb25zCQAETAAAAAIJAQAAAAh3cml0ZUludAAAAAIJAQAAAAlkZWJ0U3RvcmUAAAABBQAAAAt1c2VyQWRkcmVzcwUAAAAHbmV3RGVidAkABEwAAAACCQEAAAAId3JpdGVJbnQAAAACCQEAAAAOZGVidEluZGV4U3RvcmUAAAABBQAAAAt1c2VyQWRkcmVzcwUAAAAMY3VycmVudEluZGV4BQAAAANuaWwFAAAABnJlcGFpZAkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAQAAAAlnZXRDb25maWcAAAAABAAAAA0kdDAxMTYzMTExNjUxBQAAAARBQkNEBAAAAAFhCAUAAAANJHQwMTE2MzExMTY1MQAAAAJfMQQAAAABYggFAAAADSR0MDExNjMxMTE2NTEAAAACXzIEAAAAAWMIBQAAAA0kdDAxMTYzMTExNjUxAAAAAl8zBAAAAAFkCAUAAAANJHQwMTE2MzExMTY1MQAAAAJfNAkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgIAAAAGQUJDRDogCQABpAAAAAEFAAAAAWECAAAAATsJAAGkAAAAAQUAAAABYgIAAAABOwkAAaQAAAABBQAAAAFjAgAAAAE7CQABpAAAAAEFAAAAAWQCAAAAESwgcmVzZXJ2ZUZhY3RvcjogCQABpAAAAAEFAAAADXJlc2VydmVGYWN0b3ICAAAAFCwgY29sbGF0ZXJhbEZhY3RvcjogCQABpAAAAAEFAAAAEGNvbGxhdGVyYWxGYWN0b3ICAAAAGCwgbGlxdWlkYXRpb25UaHJlc2hvbGQ6IAkAAaQAAAABBQAAABRsaXF1aWRhdGlvblRocmVzaG9sZAIAAAAWLCBsaXF1aWRhdGlvblBlbmFsdHk6IAkAAaQAAAABBQAAABJsaXF1aWRhdGlvblBlbmFsdHkBAAAACGdldFN0YXRlAAAAAAkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgIAAAAVY3VycmVudFRvdGFsRGVwb3NpdDogCQABpAAAAAEFAAAAE2N1cnJlbnRUb3RhbERlcG9zaXQCAAAAFiwgc3RvcmVkVG90YWxEZXBvc2l0OiAJAAGkAAAAAQUAAAASc3RvcmVkVG90YWxEZXBvc2l0AgAAABQsIGN1cnJlbnRUb3RhbERlYnQ6IAkAAaQAAAABBQAAABBjdXJyZW50VG90YWxEZWJ0AgAAABMsIHN0b3JlZFRvdGFsRGVidDogCQABpAAAAAEFAAAAD3N0b3JlZFRvdGFsRGVidAIAAAAXLCBjdXJyZW50VG90YWxSZXNlcnZlOiAJAAGkAAAAAQUAAAATY3VycmVudFRvdGFsUmVzZXJ2ZQIAAAAWLCBzdG9yZWRUb3RhbFJlc2VydmU6IAkAAaQAAAABBQAAABJzdG9yZWRUb3RhbFJlc2VydmUCAAAADywgY3VycmVudEluZGV4OgkAAaQAAAABBQAAAAxjdXJyZW50SW5kZXgCAAAADywgc3RvcmVkSW5kZXg6IAkAAaQAAAABBQAAAAtzdG9yZWRJbmRleAIAAAAULCBsYXN0VXBkYXRlSGVpZ2h0OiAJAAGkAAAAAQUAAAAQbGFzdFVwZGF0ZUhlaWdodAIAAAAPLCB1dGlsaXphdGlvbjogCQABpAAAAAEFAAAAC3V0aWxpemF0aW9uAgAAABUsIGFUb2tlbkNpcmN1bGF0aW9uOiAJAAGkAAAAAQUAAAARYVRva2VuQ2lyY3VsYXRpb24CAAAADywgYVRva2VuUHJpY2U6IAkAAaQAAAABCQEAAAANYVRva2VuVG9Bc3NldAAAAAEJAABsAAAABgAAAAAAAAAACgAAAAAAAAAAAAUAAAANYXNzZXREZWNpbWFscwAAAAAAAAAAAAAAAAAAAAAAAAUAAAAFRkxPT1ICAAAABywgQVBSOiAJAAGkAAAAAQUAAAADYXByAgAAAAcsIEFQWTogCQABpAAAAAEFAAAAA2FweQEAAAAMZ2V0VXNlclN0YXRlAAAAAQAAAAR1c2VyBAAAAAhhQmFsYW5jZQkBAAAADWFUb2tlbkJhbGFuY2UAAAABBQAAAAR1c2VyBAAAAA5hQmFsYW5jZVdhbGxldAkBAAAACmdldEJhbGFuY2UAAAACCQEAAAARQGV4dHJOYXRpdmUoMTA2MikAAAABBQAAAAR1c2VyBQAAAAhhVG9rZW5JZAkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAICAAAADWN1cnJlbnREZWJ0OiAJAAGkAAAAAQkBAAAAD2N1cnJlbnRVc2VyRGVidAAAAAEFAAAABHVzZXICAAAADiwgc3RvcmVkRGVidDogCQABpAAAAAEJAQAAAAt2YWx1ZU9yRWxzZQAAAAIJAQAAAARnZXRJAAAAAQkBAAAACWRlYnRTdG9yZQAAAAEFAAAABHVzZXIAAAAAAAAAAAACAAAAEiwgY3VycmVudERlcG9zaXQ6IAkAAaQAAAABCQEAAAANYVRva2VuVG9Bc3NldAAAAAEFAAAACGFCYWxhbmNlAgAAABksIGFUb2tlbkNvbnRyYWN0QmFsYW5jZTogCQABpAAAAAEFAAAACGFCYWxhbmNlAgAAABcsIGFUb2tlbldhbGxldEJhbGFuY2U6IAkAAaQAAAABBQAAAA5hQmFsYW5jZVdhbGxldAIAAAAPLCB3YWxsZXRTdGFrZTogCQABpAAAAAEJAQAAAA1hVG9rZW5Ub0Fzc2V0AAAAAQUAAAAOYUJhbGFuY2VXYWxsZXQCAAAAFiwgYXNzZXRXYWxsZXRCYWxhbmNlOiAJAAGkAAAAAQkBAAAACmdldEJhbGFuY2UAAAACCQEAAAARQGV4dHJOYXRpdmUoMTA2MikAAAABBQAAAAR1c2VyBQAAAAdhc3NldElkAgAAABMsIHVzZUFzQ29sbGF0ZXJhbDogCQABpQAAAAEJAQAAAAt2YWx1ZU9yRWxzZQAAAAIJAAQbAAAAAgUAAAAEdGhpcwkBAAAAFHVzZUFzQ29sbGF0ZXJhbFN0b3JlAAAAAQUAAAAEdXNlcgYCAAAADywgc3RvcmVkSW5kZXg6IAkAAaQAAAABCQEAAAALdmFsdWVPckVsc2UAAAACCQEAAAAEZ2V0SQAAAAEJAQAAAA5kZWJ0SW5kZXhTdG9yZQAAAAEFAAAABHVzZXIAAAAAAAAAAAABAAAAC2RlYnVnVG90YWxzAAAAAAkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAICAAAAFHN0b3JlZFRvdGFsRGVwb3NpdDogCQABpAAAAAEFAAAAEnN0b3JlZFRvdGFsRGVwb3NpdAIAAAATLCBzdG9yZWRUb3RhbERlYnQ6IAkAAaQAAAABBQAAAA9zdG9yZWRUb3RhbERlYnQCAAAAFiwgc3RvcmVkVG90YWxSZXNlcnZlOiAJAAGkAAAAAQUAAAASc3RvcmVkVG90YWxSZXNlcnZlAgAAAA8sIHN0b3JlZEluZGV4OiAJAAGkAAAAAQUAAAALc3RvcmVkSW5kZXgCAAAAFCwgbGFzdFVwZGF0ZUhlaWdodDogCQABpAAAAAEFAAAAEGxhc3RVcGRhdGVIZWlnaHQCAAAAFywgY3VycmVudFRvdGFsRGVwb3NpdDogCQABpAAAAAEFAAAAE2N1cnJlbnRUb3RhbERlcG9zaXQCAAAAFCwgY3VycmVudFRvdGFsRGVidDogCQABpAAAAAEFAAAAEGN1cnJlbnRUb3RhbERlYnQCAAAAFywgY3VycmVudFRvdGFsUmVzZXJ2ZTogCQABpAAAAAEFAAAAE2N1cnJlbnRUb3RhbFJlc2VydmUCAAAAECwgY3VycmVudEluZGV4OiAJAAGkAAAAAQUAAAAMY3VycmVudEluZGV4AgAAABEsIGN1cnJlbnRIZWlnaHQ6IAkAAaQAAAABBQAAAAZIRUlHSFQCAAAAFSwgYVRva2VuQ2lyY3VsYXRpb246IAkAAaQAAAABBQAAABFhVG9rZW5DaXJjdWxhdGlvbgIAAAAPLCBhVG9rZW5QcmljZTogCQABpAAAAAEJAQAAAA1hVG9rZW5Ub0Fzc2V0AAAAAQkAAGwAAAAGAAAAAAAAAAAKAAAAAAAAAAAABQAAAA1hc3NldERlY2ltYWxzAAAAAAAAAAAAAAAAAAAAAAAABQAAAAVGTE9PUgEAAAAKdXNlclRvdGFscwAAAAEAAAAEdXNlcgQAAAAHYXRva2VucwkBAAAADWFUb2tlbkJhbGFuY2UAAAABBQAAAAR1c2VyBAAAAAVhc3NldAkBAAAADWFUb2tlblRvQXNzZXQAAAABBQAAAAdhdG9rZW5zBAAAAARkZWJ0CQEAAAAPY3VycmVudFVzZXJEZWJ0AAAAAQUAAAAEdXNlcgMJAAAAAAAAAgUAAAAGSEVJR0hUBQAAABBsYXN0VXBkYXRlSGVpZ2h0CQAFFgAAAAQFAAAAEnN0b3JlZFRvdGFsRGVwb3NpdAUAAAAPc3RvcmVkVG90YWxEZWJ0BQAAAAVhc3NldAUAAAAEZGVidAkABRYAAAAEBQAAABNjdXJyZW50VG90YWxEZXBvc2l0BQAAABBjdXJyZW50VG90YWxEZWJ0BQAAAAVhc3NldAUAAAAEZGVidAAAABwAAAABaQEAAAASZ2V0UmVzZXJ2ZURpdnNJbmZvAAAAAAkABRQAAAACBQAAAANuaWwJAAUUAAAAAgUAAAATY3VycmVudFRvdGFsUmVzZXJ2ZQUAAAAKYXNzZXRJZFN0cgAAAAFpAQAAABBnZXRDdXJyZW50VG90YWxzAAAAAQAAAAR1c2VyCQAFFAAAAAIFAAAAA25pbAkBAAAACnVzZXJUb3RhbHMAAAABBQAAAAR1c2VyAAAAAWkBAAAAEWdldEN1cnJlbnRUb3RhbHMyAAAAAgAAAAV1c2VyMQAAAAV1c2VyMgQAAAANJHQwMTQ4NjIxNDg5OQkBAAAACnVzZXJUb3RhbHMAAAABBQAAAAV1c2VyMQQAAAACZDEIBQAAAA0kdDAxNDg2MjE0ODk5AAAAAl8xBAAAAAJkMggFAAAADSR0MDE0ODYyMTQ4OTkAAAACXzIEAAAAAmQzCAUAAAANJHQwMTQ4NjIxNDg5OQAAAAJfMwQAAAACZDQIBQAAAA0kdDAxNDg2MjE0ODk5AAAAAl80BAAAAA0kdDAxNDkwNDE0OTQxCQEAAAAKdXNlclRvdGFscwAAAAEFAAAABXVzZXIyBAAAAAJlMQgFAAAADSR0MDE0OTA0MTQ5NDEAAAACXzEEAAAAAmUyCAUAAAANJHQwMTQ5MDQxNDk0MQAAAAJfMgQAAAACZTMIBQAAAA0kdDAxNDkwNDE0OTQxAAAAAl8zBAAAAAJlNAgFAAAADSR0MDE0OTA0MTQ5NDEAAAACXzQJAAUUAAAAAgUAAAADbmlsCQAFGAAAAAYFAAAAAmQxBQAAAAJkMgUAAAACZDMFAAAAAmQ0BQAAAAJlMwUAAAACZTQAAAABaQEAAAAGYWR2aXNlAAAAAAkABRQAAAACBQAAAANuaWwJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACAgAAABByZXNlcnZlQWRkcmVzczogCQAEJQAAAAEFAAAABHRoaXMCAAAAAiwgCQEAAAAJZ2V0Q29uZmlnAAAAAAIAAAACLCAJAQAAAAhnZXRTdGF0ZQAAAAAAAAABaQEAAAAKYWR2aXNlVXNlcgAAAAEAAAAEdXNlcgQAAAAOY3VycmVudERlYnRVc2QJAQAAAAphc3NldFRvVXNkAAAAAQUAAAAQY3VycmVudFRvdGFsRGVidAQAAAARY3VycmVudERlcG9zaXRVc2QJAQAAAAphc3NldFRvVXNkAAAAAQUAAAATY3VycmVudFRvdGFsRGVwb3NpdAQAAAAMYXNDb2xsYXRlcmFsCQEAAAALdmFsdWVPckVsc2UAAAACCQAEGwAAAAIFAAAABHRoaXMJAQAAABR1c2VBc0NvbGxhdGVyYWxTdG9yZQAAAAEFAAAABHVzZXIGBAAAABNlZmZlY3RpdmVEZXBvc2l0VXNkAwUAAAAMYXNDb2xsYXRlcmFsBQAAABFjdXJyZW50RGVwb3NpdFVzZAAAAAAAAAAAAAQAAAAKb3ZlcmxhcFVzZAkAAZcAAAABCQAETAAAAAIFAAAADmN1cnJlbnREZWJ0VXNkCQAETAAAAAIFAAAAE2VmZmVjdGl2ZURlcG9zaXRVc2QFAAAAA25pbAQAAAANb3ZlcmxhcENoYXJnZQkBAAAADGZyYWN0aW9uQ2VpbAAAAAMFAAAACm92ZXJsYXBVc2QFAAAAFGFjY291bnRIZWFsdGhPdmVybGFwBQAAAAtmYWN0b3JzQmFzZQQAAAACYnADCQAAZgAAAAIFAAAADmN1cnJlbnREZWJ0VXNkBQAAABNlZmZlY3RpdmVEZXBvc2l0VXNkAAAAAAAAAAAACQAAawAAAAMJAABlAAAAAgUAAAATZWZmZWN0aXZlRGVwb3NpdFVzZAUAAAAOY3VycmVudERlYnRVc2QFAAAAEGNvbGxhdGVyYWxGYWN0b3IFAAAAC2ZhY3RvcnNCYXNlBAAAAANicHUDCQAAZgAAAAIFAAAADmN1cnJlbnREZWJ0VXNkBQAAABNlZmZlY3RpdmVEZXBvc2l0VXNkCQAAZAAAAAIJAABrAAAAAwkAAGUAAAACBQAAAA5jdXJyZW50RGVidFVzZAUAAAATZWZmZWN0aXZlRGVwb3NpdFVzZAUAAAALZmFjdG9yc0Jhc2UFAAAAFGxpcXVpZGF0aW9uVGhyZXNob2xkBQAAAA1vdmVybGFwQ2hhcmdlBQAAAA1vdmVybGFwQ2hhcmdlBAAAAAhlbnJpY2hlZAkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgIAAAAQcmVzZXJ2ZUFkZHJlc3M6IAkABCUAAAABBQAAAAR0aGlzAgAAABIsIGN1cnJlbnREZWJ0VXNkOiAJAAGkAAAAAQUAAAAOY3VycmVudERlYnRVc2QCAAAAFSwgY3VycmVudERlcG9zaXRVc2Q6IAkAAaQAAAABBQAAABFjdXJyZW50RGVwb3NpdFVzZAIAAAAGLCBicDogCQABpAAAAAEFAAAAAmJwAgAAAAcsIGJwdTogCQABpAAAAAEFAAAAA2JwdQkABRQAAAACBQAAAANuaWwJAAEsAAAAAgkAASwAAAACBQAAAAhlbnJpY2hlZAIAAAACLCAJAQAAAAxnZXRVc2VyU3RhdGUAAAABBQAAAAR1c2VyAAAAAWkBAAAAC2FkZEludGVyZXN0AAAAAAMJAQAAAAIhPQAAAAIICQABkQAAAAIIBQAAAAFpAAAACHBheW1lbnRzAAAAAAAAAAAAAAAAB2Fzc2V0SWQFAAAAB2Fzc2V0SWQJAAACAAAAAQIAAAAnY2FuJ3QgYWRkIGludGVyZXN0IHdpdGggdW5yZWxhdGVkIHRva2VuCQEAAAAKc3luY1RvdGFscwAAAAQICQABkQAAAAIIBQAAAAFpAAAACHBheW1lbnRzAAAAAAAAAAAAAAAABmFtb3VudAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFpAQAAAAxhZGRUb1Jlc2VydmUAAAAAAwkBAAAAAiE9AAAAAggJAAGRAAAAAggFAAAAAWkAAAAIcGF5bWVudHMAAAAAAAAAAAAAAAAHYXNzZXRJZAUAAAAHYXNzZXRJZAkAAAIAAAABAgAAACdjYW4ndCBhZGQgaW50ZXJlc3Qgd2l0aCB1bnJlbGF0ZWQgdG9rZW4JAQAAAApzeW5jVG90YWxzAAAABAAAAAAAAAAAAAAAAAAAAAAAAAgJAAGRAAAAAggFAAAAAWkAAAAIcGF5bWVudHMAAAAAAAAAAAAAAAAGYW1vdW50AAAAAAAAAAAAAAAAAWkBAAAAE3dpdGhkcmF3RnJvbVJlc2VydmUAAAABAAAAA2FtdAQAAAAGY2hlY2tzCQEAAAAMZGl2QWRtaW5Pbmx5AAAAAQUAAAABaQMJAAAAAAAAAgUAAAAGY2hlY2tzBQAAAAZjaGVja3MEAAAABGRpZmYDCQAAAAAAAAIFAAAAA2FtdAD//////////wUAAAATY3VycmVudFRvdGFsUmVzZXJ2ZQUAAAADYW10CQAFFAAAAAIJAAROAAAAAgkBAAAACnN5bmNUb3RhbHMAAAAEAAAAAAAAAAAAAAAAAAAAAAAACQEAAAABLQAAAAEFAAAABGRpZmYFAAAABGRpZmYJAARMAAAAAgkBAAAADlNjcmlwdFRyYW5zZmVyAAAAAwgFAAAAAWkAAAAGY2FsbGVyBQAAAARkaWZmBQAAAAdhc3NldElkBQAAAANuaWwFAAAABGRpZmYJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAAAAAWkBAAAAC2ZvcmNlVXBkYXRlAAAAAAQAAAAFYWRtaW4JAQAAABFAZXh0ck5hdGl2ZSgxMDUzKQAAAAIFAAAADWNvbmZpZ0FkZHJlc3MCAAAABWFkbWluAwkBAAAAAiE9AAAAAgkABCUAAAABCAUAAAABaQAAAAZjYWxsZXIFAAAABWFkbWluCQAAAgAAAAECAAAAEW9ubHkgYWRtaW4gY2FuIGRvCQEAAAAKc3luY1RvdGFscwAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABaQEAAAAKaW5pdGlhbGl6ZQAAAAYAAAAKY2ZnQWRkcmVzcwAAAApvcmFjbGVBZGRyAAAADmFzc2V0SWRPcldhdmVzAAAACmFUb2tlbk5hbWUAAAARYVRva2VuRGVzY3JpcHRpb24AAAAOYVRva2VuRGVjaW1hbHMEAAAABmNoZWNrcwMFAAAADm5vdEluaXRpYWxpemVkCQEAAAAQaXNBc3NldElkT3JXYXZlcwAAAAEFAAAADmFzc2V0SWRPcldhdmVzBwMJAAAAAAAAAgUAAAAGY2hlY2tzBQAAAAZjaGVja3MEAAAABmFUb2tlbgkABEIAAAAFBQAAAAphVG9rZW5OYW1lBQAAABFhVG9rZW5EZXNjcmlwdGlvbgAAAAAAAAAAAAUAAAAOYVRva2VuRGVjaW1hbHMGCQAETAAAAAIFAAAABmFUb2tlbgkABEwAAAACCQEAAAALd3JpdGVTdHJpbmcAAAACBQAAAAtvcmFjbGVTdG9yZQUAAAAKb3JhY2xlQWRkcgkABEwAAAACCQEAAAAId3JpdGVJbnQAAAACBQAAABNhVG9rZW5EZWNpbWFsc1N0b3JlBQAAAA5hVG9rZW5EZWNpbWFscwkABEwAAAACCQEAAAALd3JpdGVTdHJpbmcAAAACBQAAAA9hVG9rZW5OYW1lU3RvcmUFAAAACmFUb2tlbk5hbWUJAARMAAAAAgkBAAAAC3dyaXRlU3RyaW5nAAAAAgUAAAAMYXNzZXRJZFN0b3JlBQAAAA5hc3NldElkT3JXYXZlcwkABEwAAAACCQEAAAALd3JpdGVTdHJpbmcAAAACBQAAABJjb25maWdBZGRyZXNzU3RvcmUFAAAACmNmZ0FkZHJlc3MJAARMAAAAAgkBAAAAC3dyaXRlU3RyaW5nAAAAAgUAAAANYVRva2VuSWRTdG9yZQkAAlgAAAABCQAEOAAAAAEFAAAABmFUb2tlbgkABEwAAAACCQEAAAAId3JpdGVJbnQAAAACBQAAABVsYXN0VXBkYXRlSGVpZ2h0U3RvcmUFAAAABkhFSUdIVAUAAAADbmlsCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgAAAAFpAQAAAA51c2VyRGVwb3NpdFVTRAAAAAEAAAAHYWRkcmVzcwkABRQAAAACBQAAAANuaWwJAQAAAAphc3NldFRvVXNkAAAAAQkBAAAADWFUb2tlblRvQXNzZXQAAAABCQEAAAANYVRva2VuQmFsYW5jZQAAAAEFAAAAB2FkZHJlc3MAAAABaQEAAAALdXNlckRlYnRVU0QAAAABAAAAB2FkZHJlc3MJAAUUAAAAAgUAAAADbmlsCQEAAAAKYXNzZXRUb1VzZAAAAAEJAQAAAA9jdXJyZW50VXNlckRlYnQAAAABBQAAAAdhZGRyZXNzAAAAAWkBAAAAC3VzZXJCYWxhbmNlAAAAAQAAAAdhZGRyZXNzBAAAAAdhdG9rZW5zCQEAAAANYVRva2VuQmFsYW5jZQAAAAEFAAAAB2FkZHJlc3MEAAAABWFzc2V0CQEAAAANYVRva2VuVG9Bc3NldAAAAAEFAAAAB2F0b2tlbnMEAAAABGRlYnQJAQAAAA9jdXJyZW50VXNlckRlYnQAAAABBQAAAAdhZGRyZXNzCQAFFAAAAAIFAAAAA25pbAkABRgAAAAGBQAAAAdhdG9rZW5zBQAAAAVhc3NldAkBAAAACmFzc2V0VG9Vc2QAAAABBQAAAAVhc3NldAUAAAAEZGVidAkBAAAACmFzc2V0VG9Vc2QAAAABBQAAAARkZWJ0CQEAAAALdmFsdWVPckVsc2UAAAACCQAEGwAAAAIFAAAABHRoaXMJAQAAABR1c2VBc0NvbGxhdGVyYWxTdG9yZQAAAAEFAAAAB2FkZHJlc3MGAAAAAWkBAAAACHVzZXJEZWJ0AAAAAQAAAAdhZGRyZXNzBAAAAARkZWJ0CQEAAAAPY3VycmVudFVzZXJEZWJ0AAAAAQUAAAAHYWRkcmVzcwQAAAAHZGVidFVzZAkBAAAACmFzc2V0VG9Vc2QAAAABBQAAAARkZWJ0CQAFFAAAAAIFAAAAA25pbAkABRQAAAACBQAAAARkZWJ0BQAAAAdkZWJ0VXNkAAAAAWkBAAAADWFzc2V0VXNkVmFsdWUAAAABAAAAC2Fzc2V0QW1vdW50CQAFFAAAAAIFAAAAA25pbAkBAAAACmFzc2V0VG9Vc2QAAAABBQAAAAthc3NldEFtb3VudAAAAAFpAQAAAAhyZXBheUZvcgAAAAEAAAALdXNlckFkZHJlc3MEAAAABmNoZWNrcwkBAAAACG1haW5Pbmx5AAAAAQUAAAABaQMJAAAAAAAAAgUAAAAGY2hlY2tzBQAAAAZjaGVja3MJAQAAAAlyZXBheVVzZXIAAAACBQAAAAt1c2VyQWRkcmVzcwkBAAAADXBheW1lbnRBbW91bnQAAAACBQAAAAFpBQAAAAdhc3NldElkCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgAAAAFpAQAAAApkZXBvc2l0Rm9yAAAAAgAAAAlkZXBvc2l0b3IAAAAPdXNlQXNDb2xsYXRlcmFsBAAAAAZjaGVja3MDCQEAAAAIbWFpbk9ubHkAAAABBQAAAAFpCQEAAAAJb3BBbGxvd2VkAAAAAQIAAAAHZGVwb3NpdAcDCQAAAAAAAAIFAAAABmNoZWNrcwUAAAAGY2hlY2tzAwMJAABmAAAAAgkBAAAAD2N1cnJlbnRVc2VyRGVidAAAAAEFAAAACWRlcG9zaXRvcgAAAAAAAAAAAAkBAAAAASEAAAABBQAAAA91c2VBc0NvbGxhdGVyYWwHCQAAAgAAAAECAAAAOGNhbid0IGRpc2FibGUgdXNlIGFzIGNvbGxhdGVyYWwgZm9yIGFzc2V0IHdpdGggb3BlbiBkZWJ0BAAAAAZhbW91bnQJAQAAAA1wYXltZW50QW1vdW50AAAAAgUAAAABaQUAAAAHYXNzZXRJZAQAAAAMYVRva2VuQW1vdW50CQEAAAANYXNzZXRUb0FUb2tlbgAAAAEFAAAABmFtb3VudAkABE4AAAACCQEAAAAKc3luY1RvdGFscwAAAAQFAAAABmFtb3VudAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkABEwAAAACCQEAAAAIY2hhbmdlQnkAAAACBQAAABZhVG9rZW5DaXJjdWxhdGlvblN0b3JlBQAAAAxhVG9rZW5BbW91bnQJAARMAAAAAgkBAAAACGNoYW5nZUJ5AAAAAgkBAAAAEmFUb2tlbkJhbGFuY2VTdG9yZQAAAAEFAAAACWRlcG9zaXRvcgUAAAAMYVRva2VuQW1vdW50CQAETAAAAAIJAQAAAAxCb29sZWFuRW50cnkAAAACCQEAAAAUdXNlQXNDb2xsYXRlcmFsU3RvcmUAAAABBQAAAAlkZXBvc2l0b3IFAAAAD3VzZUFzQ29sbGF0ZXJhbAUAAAADbmlsCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgAAAAFpAQAAAAt3aXRoZHJhd0ZvcgAAAAIAAAAHYWRkcmVzcwAAAAZhbW91bnQEAAAAC21heFdpdGhkcmF3CQAAZQAAAAIJAABkAAAAAgUAAAASc3RvcmVkVG90YWxEZXBvc2l0BQAAABJzdG9yZWRUb3RhbFJlc2VydmUFAAAAD3N0b3JlZFRvdGFsRGVidAQAAAAGY2hlY2tzAwMDCQEAAAAIbWFpbk9ubHkAAAABBQAAAAFpCQEAAAAObGlxdWlkaXR5Q2hlY2sAAAADBQAAAAZhbW91bnQFAAAAC21heFdpdGhkcmF3AgAAAAxmdW5kcyBpbiB1c2UHCQEAAAAHdGhyb3dJZgAAAAIJAABmAAAAAgD//////////wUAAAAGYW1vdW50AgAAAA5pbnZhbGlkIGFtb3VudAcJAQAAAAlvcEFsbG93ZWQAAAABAgAAAAh3aXRoZHJhdwcDCQAAAAAAAAIFAAAABmNoZWNrcwUAAAAGY2hlY2tzBAAAAA0kdDAxOTU3NjE5NzcwAwkAAAAAAAACBQAAAAZhbW91bnQA//////////8EAAAAB2F0b2tlbnMJAQAAAA1hVG9rZW5CYWxhbmNlAAAAAQUAAAAHYWRkcmVzcwkABRQAAAACBQAAAAdhdG9rZW5zCQEAAAANYVRva2VuVG9Bc3NldAAAAAEFAAAAB2F0b2tlbnMJAAUUAAAAAgkBAAAAEWFzc2V0VG9BVG9rZW5DZWlsAAAAAQUAAAAGYW1vdW50BQAAAAZhbW91bnQEAAAADnJlbW92ZWRBdG9rZW5zCAUAAAANJHQwMTk1NzYxOTc3MAAAAAJfMQQAAAAOd2l0aGRyYXdBbW91bnQIBQAAAA0kdDAxOTU3NjE5NzcwAAAAAl8yCQAFFAAAAAIJAAROAAAAAgkBAAAACnN5bmNUb3RhbHMAAAAECQEAAAABLQAAAAEFAAAADndpdGhkcmF3QW1vdW50AAAAAAAAAAAAAAAAAAAAAAAABQAAAA53aXRoZHJhd0Ftb3VudAkABEwAAAACCQEAAAAOU2NyaXB0VHJhbnNmZXIAAAADCQEAAAARQGV4dHJOYXRpdmUoMTA2MikAAAABBQAAAAdhZGRyZXNzBQAAAA53aXRoZHJhd0Ftb3VudAUAAAAHYXNzZXRJZAkABEwAAAACCQEAAAAIY2hhbmdlQnkAAAACCQEAAAASYVRva2VuQmFsYW5jZVN0b3JlAAAAAQUAAAAHYWRkcmVzcwkBAAAAAS0AAAABBQAAAA5yZW1vdmVkQXRva2VucwkABEwAAAACCQEAAAAIY2hhbmdlQnkAAAACBQAAABZhVG9rZW5DaXJjdWxhdGlvblN0b3JlCQEAAAABLQAAAAEFAAAADnJlbW92ZWRBdG9rZW5zBQAAAANuaWwFAAAADndpdGhkcmF3QW1vdW50CQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgAAAAFpAQAAABZyZXBsZW5pc2hXaXRoQXRva2VuRm9yAAAAAQAAAAR1c2VyBAAAAAZjaGVja3MDCQEAAAAIbWFpbk9ubHkAAAABBQAAAAFpCQEAAAAJb3BBbGxvd2VkAAAAAQIAAAAHYXRva2VucwcDCQAAAAAAAAIFAAAABmNoZWNrcwUAAAAGY2hlY2tzBAAAAAxhVG9rZW5BbW91bnQJAQAAAA1wYXltZW50QW1vdW50AAAAAgUAAAABaQUAAAAIYVRva2VuSWQJAAUUAAAAAgkABE4AAAACCQAETgAAAAIJAQAAAApzeW5jVG90YWxzAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkABEwAAAACCQEAAAAIY2hhbmdlQnkAAAACCQEAAAASYVRva2VuQmFsYW5jZVN0b3JlAAAAAQUAAAAEdXNlcgUAAAAMYVRva2VuQW1vdW50CQAETAAAAAIJAQAAAARCdXJuAAAAAgUAAAAIYVRva2VuSWQFAAAADGFUb2tlbkFtb3VudAUAAAADbmlsCQEAAAARZW5hYmxlQ29sSWZOZWVkZWQAAAABBQAAAAR1c2VyCQEAAAANYVRva2VuVG9Bc3NldAAAAAEFAAAADGFUb2tlbkFtb3VudAkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4AAAABaQEAAAAJYm9ycm93Rm9yAAAAAgAAAAdhZGRyZXNzAAAADmFtb3VudFRvQm9ycm93BAAAAAZjaGVja3MDAwkBAAAACG1haW5Pbmx5AAAAAQUAAAABaQkBAAAADmxpcXVpZGl0eUNoZWNrAAAAAwUAAAAOYW1vdW50VG9Cb3Jyb3cJAABlAAAAAgUAAAASc3RvcmVkVG90YWxEZXBvc2l0BQAAAA9zdG9yZWRUb3RhbERlYnQCAAAAGXRvbyBtdWNoIGJvcnJvdyByZXF1ZXN0ZWQHCQEAAAAJb3BBbGxvd2VkAAAAAQIAAAAGYm9ycm93BwMJAAAAAAAAAgUAAAAGY2hlY2tzBQAAAAZjaGVja3MEAAAAC2N1cnJlbnREZWJ0CQEAAAAPY3VycmVudFVzZXJEZWJ0AAAAAQUAAAAHYWRkcmVzcwQAAAAHbmV3RGVidAkAAGQAAAACBQAAAAtjdXJyZW50RGVidAUAAAAOYW1vdW50VG9Cb3Jyb3cJAAROAAAAAgkBAAAACnN5bmNUb3RhbHMAAAAEAAAAAAAAAAAABQAAAA5hbW91bnRUb0JvcnJvdwAAAAAAAAAAAAUAAAAOYW1vdW50VG9Cb3Jyb3cJAARMAAAAAgkBAAAACHdyaXRlSW50AAAAAgkBAAAACWRlYnRTdG9yZQAAAAEFAAAAB2FkZHJlc3MFAAAAB25ld0RlYnQJAARMAAAAAgkBAAAACWVuYWJsZUNvbAAAAAEFAAAAB2FkZHJlc3MJAARMAAAAAgkBAAAACHdyaXRlSW50AAAAAgkBAAAADmRlYnRJbmRleFN0b3JlAAAAAQUAAAAHYWRkcmVzcwUAAAAMY3VycmVudEluZGV4CQAETAAAAAIJAQAAAA5TY3JpcHRUcmFuc2ZlcgAAAAMJAQAAABFAZXh0ck5hdGl2ZSgxMDYyKQAAAAEFAAAAB2FkZHJlc3MFAAAADmFtb3VudFRvQm9ycm93BQAAAAdhc3NldElkBQAAAANuaWwJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAAAAAWkBAAAADW1pbnRBdG9rZW5Gb3IAAAACAAAAB2FkZHJlc3MAAAAMYW1vdW50VG9NaW50BAAAABF1c2VyQVRva2VuQmFsYW5jZQkBAAAADWFUb2tlbkJhbGFuY2UAAAABBQAAAAdhZGRyZXNzBAAAAAZhbW91bnQDCQAAAAAAAAIFAAAADGFtb3VudFRvTWludAD//////////wUAAAARdXNlckFUb2tlbkJhbGFuY2UFAAAADGFtb3VudFRvTWludAQAAAAGY2hlY2tzAwMDCQEAAAAIbWFpbk9ubHkAAAABBQAAAAFpCQEAAAAJb3BBbGxvd2VkAAAAAQIAAAAHYXRva2VucwcJAQAAAAd0aHJvd0lmAAAAAgkAAGYAAAACAP//////////BQAAAAxhbW91bnRUb01pbnQCAAAAFGludmFsaWQgYW1vdW50VG9NaW50BwkBAAAAB3Rocm93SWYAAAACCQAAZgAAAAIFAAAABmFtb3VudAUAAAARdXNlckFUb2tlbkJhbGFuY2UJAAEsAAAAAgIAAAApVHJ5aW5nIHRvIG1pbnQgbW9yZSB0aGFuIGF2YWlsYWJsZSwgbWF4OiAJAAGkAAAAAQUAAAARdXNlckFUb2tlbkJhbGFuY2UHAwkAAAAAAAACBQAAAAZjaGVja3MFAAAABmNoZWNrcwkABRQAAAACCQAETgAAAAIJAQAAAApzeW5jVG90YWxzAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkABEwAAAACCQEAAAAIY2hhbmdlQnkAAAACCQEAAAASYVRva2VuQmFsYW5jZVN0b3JlAAAAAQUAAAAHYWRkcmVzcwkBAAAAAS0AAAABBQAAAAZhbW91bnQJAARMAAAAAgkBAAAAB1JlaXNzdWUAAAADBQAAAAhhVG9rZW5JZAUAAAAGYW1vdW50BgkABEwAAAACCQEAAAAOU2NyaXB0VHJhbnNmZXIAAAADCQEAAAARQGV4dHJOYXRpdmUoMTA2MikAAAABBQAAAAdhZGRyZXNzBQAAAAZhbW91bnQFAAAACGFUb2tlbklkBQAAAANuaWwJAQAAAA1hVG9rZW5Ub0Fzc2V0AAAAAQUAAAAGYW1vdW50CQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgAAAAFpAQAAABByZWRlZW1BdG9rZW5zRm9yAAAAAQAAAAR1c2VyBAAAAAZjaGVja3MDCQEAAAAIbWFpbk9ubHkAAAABBQAAAAFpCQEAAAAJb3BBbGxvd2VkAAAAAQIAAAAHYXRva2VucwcDCQAAAAAAAAIFAAAABmNoZWNrcwUAAAAGY2hlY2tzBAAAAAxhVG9rZW5BbW91bnQJAQAAAA1wYXltZW50QW1vdW50AAAAAgUAAAABaQUAAAAIYVRva2VuSWQEAAAACW91dEFtb3VudAkBAAAADWFUb2tlblRvQXNzZXQAAAABBQAAAAxhVG9rZW5BbW91bnQJAAUUAAAAAgkABE4AAAACCQEAAAAKc3luY1RvdGFscwAAAAQJAQAAAAEtAAAAAQUAAAAJb3V0QW1vdW50AAAAAAAAAAAAAAAAAAAAAAAABQAAAAlvdXRBbW91bnQJAARMAAAAAgkBAAAADlNjcmlwdFRyYW5zZmVyAAAAAwkBAAAAEUBleHRyTmF0aXZlKDEwNjIpAAAAAQUAAAAEdXNlcgUAAAAJb3V0QW1vdW50BQAAAAdhc3NldElkCQAETAAAAAIJAQAAAAhjaGFuZ2VCeQAAAAIFAAAAFmFUb2tlbkNpcmN1bGF0aW9uU3RvcmUJAQAAAAEtAAAAAQUAAAAMYVRva2VuQW1vdW50CQAETAAAAAIJAQAAAARCdXJuAAAAAgUAAAAIYVRva2VuSWQFAAAADGFUb2tlbkFtb3VudAUAAAADbmlsBQAAAAlvdXRBbW91bnQJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAAAAAWkBAAAAEnRyYW5zZmVyQVRva2Vuc0ZvcgAAAAMAAAAEZnJvbQAAAAJ0bwAAAAh2YWx1ZVVzZAQAAAAGY2hlY2tzAwkBAAAACG1haW5Pbmx5AAAAAQUAAAABaQkBAAAACW9wQWxsb3dlZAAAAAECAAAADXRyYW5zZmVyX2RlYnQHAwkAAAAAAAACBQAAAAZjaGVja3MFAAAABmNoZWNrcwQAAAAGYXNzZXRzCQEAAAAKdXNkVG9Bc3NldAAAAAEFAAAACHZhbHVlVXNkBAAAAAdhdG9rZW5zCQEAAAANYXNzZXRUb0FUb2tlbgAAAAEFAAAABmFzc2V0cwQAAAALYVRva2Vuc0Zyb20JAQAAAA1hVG9rZW5CYWxhbmNlAAAAAQUAAAAEZnJvbQMJAABmAAAAAgUAAAAHYXRva2VucwUAAAALYVRva2Vuc0Zyb20JAAACAAAAAQkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACAgAAABl0cmFuc2ZlckF0b2tlbnNGb3IgZXJyb3I6AgAAABQgdHJhbnNmZXIudmFsdWVVc2Q6IAkAAaQAAAABBQAAAAh2YWx1ZVVzZAIAAAASIHRyYW5zZmVyLmFzc2V0czogCQABpAAAAAEFAAAABmFzc2V0cwIAAAATIHRyYW5zZmVyLmF0b2tlbnM6IAkAAaQAAAABBQAAAAdhdG9rZW5zAgAAAA8gZnJvbS5hdG9rZW5zOiAJAAGkAAAAAQUAAAALYVRva2Vuc0Zyb20CAAAABCBhdCAJAAQlAAAAAQUAAAAEdGhpcwkABRQAAAACCQAETgAAAAIJAAROAAAAAgkBAAAACnN5bmNUb3RhbHMAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQAETAAAAAIJAQAAAAhjaGFuZ2VCeQAAAAIJAQAAABJhVG9rZW5CYWxhbmNlU3RvcmUAAAABBQAAAARmcm9tCQEAAAABLQAAAAEFAAAAB2F0b2tlbnMJAARMAAAAAgkBAAAACGNoYW5nZUJ5AAAAAgkBAAAAEmFUb2tlbkJhbGFuY2VTdG9yZQAAAAEFAAAAAnRvBQAAAAdhdG9rZW5zBQAAAANuaWwJAQAAABFlbmFibGVDb2xJZk5lZWRlZAAAAAEFAAAAAnRvCQEAAAANYVRva2VuVG9Bc3NldAAAAAEFAAAAB2F0b2tlbnMJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAAAAAWkBAAAAD3RyYW5zZmVyRGVidEZvcgAAAAMAAAAEZnJvbQAAAAJ0bwAAAAZhbW91bnQEAAAABmNoZWNrcwMJAQAAAAhtYWluT25seQAAAAEFAAAAAWkJAQAAAAlvcEFsbG93ZWQAAAABAgAAAA10cmFuc2Zlcl9kZWJ0BwMJAAAAAAAAAgUAAAAGY2hlY2tzBQAAAAZjaGVja3MJAAUUAAAAAgkABE4AAAACCQEAAAAKc3luY1RvdGFscwAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJAARMAAAAAgkBAAAACHdyaXRlSW50AAAAAgkBAAAACWRlYnRTdG9yZQAAAAEFAAAABGZyb20JAABlAAAAAgkBAAAAD2N1cnJlbnRVc2VyRGVidAAAAAEFAAAABGZyb20FAAAABmFtb3VudAkABEwAAAACCQEAAAAId3JpdGVJbnQAAAACCQEAAAAJZGVidFN0b3JlAAAAAQUAAAACdG8JAABkAAAAAgkBAAAAD2N1cnJlbnRVc2VyRGVidAAAAAEFAAAAAnRvBQAAAAZhbW91bnQJAARMAAAAAgkBAAAACHdyaXRlSW50AAAAAgkBAAAADmRlYnRJbmRleFN0b3JlAAAAAQUAAAAEZnJvbQUAAAAMY3VycmVudEluZGV4CQAETAAAAAIJAQAAAAh3cml0ZUludAAAAAIJAQAAAA5kZWJ0SW5kZXhTdG9yZQAAAAEFAAAAAnRvBQAAAAxjdXJyZW50SW5kZXgJAARMAAAAAgkBAAAACWVuYWJsZUNvbAAAAAEFAAAAAnRvBQAAAANuaWwFAAAABmFtb3VudAkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4AAAABaQEAAAAZZGlzYWJsZVVzZUFzQ29sbGF0ZXJhbEZvcgAAAAEAAAAHYWRkcmVzcwQAAAAGY2hlY2tzAwkBAAAACG1haW5Pbmx5AAAAAQUAAAABaQkBAAAACW9wQWxsb3dlZAAAAAECAAAACnVzZV9hc19jb2wHAwkAAAAAAAACBQAAAAZjaGVja3MFAAAABmNoZWNrcwMJAABmAAAAAgkBAAAAD2N1cnJlbnRVc2VyRGVidAAAAAEFAAAAB2FkZHJlc3MAAAAAAAAAAAAJAAACAAAAAQIAAAAxY2FuJ3QgZGlzYWJsZSBjb2xsYXRlcmFsIGZvciBhc3NldCB3aXRoIG9wZW4gZGVidAkABE4AAAACCQEAAAAKc3luY1RvdGFscwAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJAARMAAAAAgkBAAAADEJvb2xlYW5FbnRyeQAAAAIJAQAAABR1c2VBc0NvbGxhdGVyYWxTdG9yZQAAAAEFAAAAB2FkZHJlc3MHBQAAAANuaWwJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAAAAAWkBAAAAFWVuYWJsZVVzZUFzQ29sbGF0ZXJhbAAAAAAEAAAABmNoZWNrcwkBAAAACW9wQWxsb3dlZAAAAAECAAAACnVzZV9hc19jb2wDCQAAAAAAAAIFAAAABmNoZWNrcwUAAAAGY2hlY2tzCQAETgAAAAIJAQAAAApzeW5jVG90YWxzAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkABEwAAAACCQEAAAAJZW5hYmxlQ29sAAAAAQkABCUAAAABCAUAAAABaQAAAAZjYWxsZXIFAAAAA25pbAkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4AAAABaQEAAAALY29sbGFwc2VGb3IAAAABAAAABHVzZXIEAAAABmNoZWNrcwMJAQAAAAhtYWluT25seQAAAAEFAAAAAWkJAQAAAAlvcEFsbG93ZWQAAAABAgAAAA5mb3JjZV9jb2xsYXBzZQcDCQAAAAAAAAIFAAAABmNoZWNrcwUAAAAGY2hlY2tzCQEAAAAMY29sbGFwc2VVc2VyAAAAAgUAAAAEdXNlcgD//////////wkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4AAAABaQEAAAARY29sbGFwc2VGb3JBbW91bnQAAAACAAAABHVzZXIAAAAGYW1vdW50BAAAAAZjaGVja3MDCQEAAAAIbWFpbk9ubHkAAAABBQAAAAFpCQEAAAAJb3BBbGxvd2VkAAAAAQIAAAAIY29sbGFwc2UHAwkAAAAAAAACBQAAAAZjaGVja3MFAAAABmNoZWNrcwkBAAAADGNvbGxhcHNlVXNlcgAAAAIFAAAABHVzZXIFAAAABmFtb3VudAkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4AAAAAM7FSLg==",
    "chainId": 87,
    "height": 2919277,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: AHpGvd5jPFnPnk9vV8UpEgJjjm7mYw3mCGWKJCjnwzhg
Next: 6c4uHNmJiwdfnHYKna5bHUi8wa3WEGePcbSFz5EKZoTu

Diff: 

OldNewDifferences
138138     else true
139139 
140140 
141+func divAdminOnly (i) = {
142+    let divAdmins = valueOrErrorMessage(getString(configAddress, "divAdmins"), "no div admins")
143+    if (!(contains(divAdmins, toString(i.caller))))
144+        then throw("only div admin can do")
145+        else true
146+    }
147+
148+
141149 func isAssetIdOrWaves (value) = if (if ((value != "WAVES"))
142150     then (fromBase58String(value) == fromBase58String(""))
143151     else false)
197205     else 0
198206 
199207 let apr = {
200-    let $t055325552 = ABCD
201-    let a = $t055325552._1
202-    let b = $t055325552._2
203-    let c = $t055325552._3
204-    let d = $t055325552._4
208+    let $t057585778 = ABCD
209+    let a = $t057585778._1
210+    let b = $t057585778._2
211+    let c = $t057585778._3
212+    let d = $t057585778._4
205213     let lineAC = (fraction((a - c), utilization, -(b)) + a)
206214     let lineCD = (fraction((c - d), (utilization - b), (b - factorsBase)) + c)
207215     if ((utilization == 0))
363371             let currentDebt = currentUserDebt(userAddress)
364372             if ((currentDebt == currentDebt))
365373                 then {
366-                    let $t01086911172 = if ((amount > currentDebt))
374+                    let $t01109511398 = if ((amount > currentDebt))
367375                         then $Tuple4(0, -(currentDebt), (amount - currentDebt), [ScriptTransfer(addressFromStringValue(userAddress), (amount - currentDebt), assetId)])
368376                         else $Tuple4((currentDebt - amount), -(amount), 0, nil)
369-                    let newDebt = $t01086911172._1
370-                    let totalDebtUpdate = $t01086911172._2
371-                    let payout = $t01086911172._3
372-                    let actions = $t01086911172._4
377+                    let newDebt = $t01109511398._1
378+                    let totalDebtUpdate = $t01109511398._2
379+                    let payout = $t01109511398._3
380+                    let actions = $t01109511398._4
373381                     let repaid = (amount - payout)
374382                     $Tuple2(((syncTotals(0, totalDebtUpdate, 0, payout) ++ actions) ++ [writeInt(debtStore(userAddress), newDebt), writeInt(debtIndexStore(userAddress), currentIndex)]), repaid)
375383                     }
380388 
381389 
382390 func getConfig () = {
383-    let $t01140511425 = ABCD
384-    let a = $t01140511425._1
385-    let b = $t01140511425._2
386-    let c = $t01140511425._3
387-    let d = $t01140511425._4
391+    let $t01163111651 = ABCD
392+    let a = $t01163111651._1
393+    let b = $t01163111651._2
394+    let c = $t01163111651._3
395+    let d = $t01163111651._4
388396     ((((((((((((((("ABCD: " + toString(a)) + ";") + toString(b)) + ";") + toString(c)) + ";") + toString(d)) + ", reserveFactor: ") + toString(reserveFactor)) + ", collateralFactor: ") + toString(collateralFactor)) + ", liquidationThreshold: ") + toString(liquidationThreshold)) + ", liquidationPenalty: ") + toString(liquidationPenalty))
389397     }
390398 
413421 
414422 
415423 @Callable(i)
424+func getReserveDivsInfo () = $Tuple2(nil, $Tuple2(currentTotalReserve, assetIdStr))
425+
426+
427+
428+@Callable(i)
416429 func getCurrentTotals (user) = $Tuple2(nil, userTotals(user))
417430 
418431 
419432 
420433 @Callable(i)
421434 func getCurrentTotals2 (user1,user2) = {
422-    let $t01455314590 = userTotals(user1)
423-    let d1 = $t01455314590._1
424-    let d2 = $t01455314590._2
425-    let d3 = $t01455314590._3
426-    let d4 = $t01455314590._4
427-    let $t01459514632 = userTotals(user2)
428-    let e1 = $t01459514632._1
429-    let e2 = $t01459514632._2
430-    let e3 = $t01459514632._3
431-    let e4 = $t01459514632._4
435+    let $t01486214899 = userTotals(user1)
436+    let d1 = $t01486214899._1
437+    let d2 = $t01486214899._2
438+    let d3 = $t01486214899._3
439+    let d4 = $t01486214899._4
440+    let $t01490414941 = userTotals(user2)
441+    let e1 = $t01490414941._1
442+    let e2 = $t01490414941._2
443+    let e3 = $t01490414941._3
444+    let e4 = $t01490414941._4
432445     $Tuple2(nil, $Tuple6(d1, d2, d3, d4, e3, e4))
433446     }
434447 
477490 
478491 @Callable(i)
479492 func withdrawFromReserve (amt) = {
480-    let admin = getStringValue(configAddress, "admin")
481-    if ((toString(i.caller) != admin))
482-        then throw("only admin can do")
483-        else (syncTotals(0, 0, -(amt), amt) ++ [ScriptTransfer(addressFromStringValue(admin), amt, assetId)])
493+    let checks = divAdminOnly(i)
494+    if ((checks == checks))
495+        then {
496+            let diff = if ((amt == -1))
497+                then currentTotalReserve
498+                else amt
499+            $Tuple2((syncTotals(0, 0, -(diff), diff) ++ [ScriptTransfer(i.caller, diff, assetId)]), diff)
500+            }
501+        else throw("Strict value is not equal to itself.")
484502     }
485503 
486504 
586604         else false
587605     if ((checks == checks))
588606         then {
589-            let $t01932119515 = if ((amount == -1))
607+            let $t01957619770 = if ((amount == -1))
590608                 then {
591609                     let atokens = aTokenBalance(address)
592610                     $Tuple2(atokens, aTokenToAsset(atokens))
593611                     }
594612                 else $Tuple2(assetToATokenCeil(amount), amount)
595-            let removedAtokens = $t01932119515._1
596-            let withdrawAmount = $t01932119515._2
613+            let removedAtokens = $t01957619770._1
614+            let withdrawAmount = $t01957619770._2
597615             $Tuple2((syncTotals(-(withdrawAmount), 0, 0, withdrawAmount) ++ [ScriptTransfer(addressFromStringValue(address), withdrawAmount, assetId), changeBy(aTokenBalanceStore(address), -(removedAtokens)), changeBy(aTokenCirculationStore, -(removedAtokens))]), withdrawAmount)
598616             }
599617         else throw("Strict value is not equal to itself.")
655673 
656674 
657675 @Callable(i)
658-func redeemAtokens () = {
659-    let checks = opAllowed("atokens")
676+func redeemAtokensFor (user) = {
677+    let checks = if (mainOnly(i))
678+        then opAllowed("atokens")
679+        else false
660680     if ((checks == checks))
661681         then {
662682             let aTokenAmount = paymentAmount(i, aTokenId)
663683             let outAmount = aTokenToAsset(aTokenAmount)
664-            (syncTotals(-(outAmount), 0, 0, outAmount) ++ [ScriptTransfer(i.caller, outAmount, assetId), changeBy(aTokenCirculationStore, -(aTokenAmount)), Burn(aTokenId, aTokenAmount)])
684+            $Tuple2((syncTotals(-(outAmount), 0, 0, outAmount) ++ [ScriptTransfer(addressFromStringValue(user), outAmount, assetId), changeBy(aTokenCirculationStore, -(aTokenAmount)), Burn(aTokenId, aTokenAmount)]), outAmount)
665685             }
666686         else throw("Strict value is not equal to itself.")
667687     }

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 5 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 func getI (key) = getInteger(this, key)
55 
66 
77 func getS (key) = getString(this, key)
88 
99 
1010 func getSV (key) = value(getString(this, key))
1111 
1212 
1313 func throwIf (condition,error) = if (condition)
1414     then throw(error)
1515     else true
1616 
1717 
1818 func writeInt (key,value) = if ((0 > value))
1919     then throw(((("writing negative value " + toString(value)) + " for key ") + key))
2020     else IntegerEntry(key, value)
2121 
2222 
2323 func changeBy (key,value) = writeInt(key, (valueOrElse(getI(key), 0) + value))
2424 
2525 
2626 func writeString (key,value) = StringEntry(key, value)
2727 
2828 
2929 func fractionCeil (value,numerator,denominator) = {
3030     let cand = fraction(value, numerator, denominator)
3131     let D = 3037000499
3232     let exact = ((((cand % D) * (denominator % D)) % D) == (((value % D) * (numerator % D)) % D))
3333     if (exact)
3434         then cand
3535         else (cand + 1)
3636     }
3737 
3838 
3939 let BlocksPerYear = 525600
4040 
4141 let RBase = 10000000000000000
4242 
4343 let factorsBase = 1000
4444 
4545 let assetIdStore = "assetId"
4646 
4747 let mainStore = "main"
4848 
4949 let reserveFactorStore = (getSV(assetIdStore) + "_ReserveFactor")
5050 
5151 let collateralFactorStore = (getSV(assetIdStore) + "_CollateralFactor")
5252 
5353 let liquidationThresholdStore = (getStringValue(assetIdStore) + "_LiquidationThreshold")
5454 
5555 let overlapChargeStore = "account_health_overlap"
5656 
5757 let liquidationPenaltyStore = (getStringValue(assetIdStore) + "_LiquidationPenalty")
5858 
5959 let configAddressStore = "configAddress"
6060 
6161 let oracleStore = "oracleAddress"
6262 
6363 let aTokenIdStore = "aTokenId"
6464 
6565 let aTokenNameStore = "aTokenName"
6666 
6767 let aTokenCirculationStore = "aTokenCirculation"
6868 
6969 let lastUpdateHeightStore = "lastUpdateHeight"
7070 
7171 let totalDebtStore = "totalBorrow"
7272 
7373 let totalDepositStore = "totalDeposit"
7474 
7575 let totalReserveStore = "totalReserve"
7676 
7777 let indexStore = "storedIndex"
7878 
7979 let aTokenDecimalsStore = "aTokenDecimals"
8080 
8181 func aTokenBalanceStore (userAddress) = (userAddress + "_aTokenBalance")
8282 
8383 
8484 func debtStore (userAddress) = (userAddress + "_debt")
8585 
8686 
8787 func debtIndexStore (userAddress) = (userAddress + "_index")
8888 
8989 
9090 func useAsCollateralStore (userAddress) = (userAddress + "_useAsCollateral")
9191 
9292 
9393 let assetId = {
9494     let id = valueOrErrorMessage(getS(assetIdStore), "no assetId")
9595     if ((id == "WAVES"))
9696         then unit
9797         else fromBase58String(id)
9898     }
9999 
100100 let assetIdStr = match assetId {
101101     case bv: ByteVector => 
102102         toBase58String(bv)
103103     case u: Unit => 
104104         "WAVES"
105105     case _ => 
106106         throw("Match error")
107107 }
108108 
109109 func getBalance (addressOrAlias,assetId) = match assetId {
110110     case bv: ByteVector => 
111111         assetBalance(addressOrAlias, bv)
112112     case u: Unit => 
113113         wavesBalance(addressOrAlias).available
114114     case _ => 
115115         throw("Match error")
116116 }
117117 
118118 
119119 let assetDecimals = valueOrErrorMessage(getI(aTokenDecimalsStore), "no assetDecimals")
120120 
121121 let configAddress = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getS(configAddressStore), "no configAddress")), "invalid config address")
122122 
123123 func opAllowed (op) = {
124124     let aid = valueOrErrorMessage(getS(assetIdStore), "no assetId")
125125     match invoke(configAddress, "opAllowed", [aid, op], nil) {
126126         case b: Boolean => 
127127             if (b)
128128                 then true
129129                 else throw("not allowed")
130130         case _ => 
131131             throw("opAllowed: unexpected result type")
132132     }
133133     }
134134 
135135 
136136 func mainOnly (i) = if ((i.caller != valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(configAddress, mainStore), "no main in config")), "invalid main address")))
137137     then throw("only main can do")
138138     else true
139139 
140140 
141+func divAdminOnly (i) = {
142+    let divAdmins = valueOrErrorMessage(getString(configAddress, "divAdmins"), "no div admins")
143+    if (!(contains(divAdmins, toString(i.caller))))
144+        then throw("only div admin can do")
145+        else true
146+    }
147+
148+
141149 func isAssetIdOrWaves (value) = if (if ((value != "WAVES"))
142150     then (fromBase58String(value) == fromBase58String(""))
143151     else false)
144152     then throw("invalid assetId")
145153     else true
146154 
147155 
148156 let notInitialized = throwIf(isDefined(getS(assetIdStore)), "already initialized")
149157 
150158 let maybeOracleAddress = match getS(oracleStore) {
151159     case s: String => 
152160         addressFromString(s)
153161     case _ => 
154162         unit
155163 }
156164 
157165 let oraclePrice = match invoke(valueOrErrorMessage(maybeOracleAddress, "no oracle"), "price", [getSV(assetIdStore)], nil) {
158166     case i: Int => 
159167         i
160168     case _ => 
161169         throw("bad oracle data")
162170 }
163171 
164172 let HEIGHT = height
165173 
166174 let lastUpdateHeight = valueOrErrorMessage(getI(lastUpdateHeightStore), "no lastUpdateHeight")
167175 
168176 let aTokenId = fromBase58String(valueOrErrorMessage(getS(aTokenIdStore), "no aTokenId"))
169177 
170178 let aTokenCirculation = valueOrElse(getI(aTokenCirculationStore), 0)
171179 
172180 let ABCD = {
173181     let id = getSV(assetIdStore)
174182     $Tuple4(getIntegerValue(configAddress, (id + "_APoint")), getIntegerValue(configAddress, (id + "_BPoint")), getIntegerValue(configAddress, (id + "_CPoint")), getIntegerValue(configAddress, (id + "_DPoint")))
175183     }
176184 
177185 let reserveFactor = valueOrErrorMessage(getInteger(configAddress, reserveFactorStore), "no reserveFactor")
178186 
179187 let collateralFactor = valueOrErrorMessage(getInteger(configAddress, collateralFactorStore), "no collateralFactor")
180188 
181189 let liquidationThreshold = valueOrErrorMessage(getInteger(configAddress, liquidationThresholdStore), "no liquidationThreshold")
182190 
183191 let accountHealthOverlap = valueOrErrorMessage(getInteger(configAddress, overlapChargeStore), "no overlapCharge")
184192 
185193 let liquidationPenalty = valueOrErrorMessage(getInteger(configAddress, liquidationPenaltyStore), "no liquidationPenalty")
186194 
187195 let storedTotalDeposit = valueOrElse(getI(totalDepositStore), 0)
188196 
189197 let storedTotalReserve = valueOrElse(getI(totalReserveStore), 0)
190198 
191199 let storedTotalDebt = valueOrElse(getI(totalDebtStore), 0)
192200 
193201 let storedIndex = valueOrElse(getI(indexStore), RBase)
194202 
195203 let utilization = if ((storedTotalDeposit > 0))
196204     then fraction(storedTotalDebt, factorsBase, storedTotalDeposit)
197205     else 0
198206 
199207 let apr = {
200-    let $t055325552 = ABCD
201-    let a = $t055325552._1
202-    let b = $t055325552._2
203-    let c = $t055325552._3
204-    let d = $t055325552._4
208+    let $t057585778 = ABCD
209+    let a = $t057585778._1
210+    let b = $t057585778._2
211+    let c = $t057585778._3
212+    let d = $t057585778._4
205213     let lineAC = (fraction((a - c), utilization, -(b)) + a)
206214     let lineCD = (fraction((c - d), (utilization - b), (b - factorsBase)) + c)
207215     if ((utilization == 0))
208216         then a
209217         else if ((utilization == b))
210218             then c
211219             else if (if ((b > utilization))
212220                 then true
213221                 else (b == factorsBase))
214222                 then lineAC
215223                 else lineCD
216224     }
217225 
218226 let apy = if ((storedTotalDeposit == 0))
219227     then 0
220228     else fraction(fraction(storedTotalDebt, apr, storedTotalDeposit), (factorsBase - reserveFactor), factorsBase)
221229 
222230 let currentIndex = if ((HEIGHT == lastUpdateHeight))
223231     then storedIndex
224232     else {
225233         let bpr = fractionCeil(apr, RBase, (BlocksPerYear * factorsBase))
226234         fractionCeil(storedIndex, (RBase + (bpr * (HEIGHT - lastUpdateHeight))), RBase)
227235         }
228236 
229237 func liquidityCheck (amount,max,err) = if ((amount > max))
230238     then throw(("not enough liquidity: " + err))
231239     else true
232240 
233241 
234242 func storedUserDebt (userAddress) = valueOrElse(getI(debtStore(userAddress)), 0)
235243 
236244 
237245 func currentUserDebt (userAddress) = {
238246     let v = storedUserDebt(userAddress)
239247     if ((v == 0))
240248         then 0
241249         else {
242250             let storedUserIndex = valueOrErrorMessage(getI(debtIndexStore(userAddress)), "has debt but does not have index")
243251             fraction(v, currentIndex, storedUserIndex)
244252             }
245253     }
246254 
247255 
248256 let currentTotalDebt = fraction(storedTotalDebt, currentIndex, storedIndex)
249257 
250258 let addedDebt = (currentTotalDebt - storedTotalDebt)
251259 
252260 let addedDeposit = fraction(addedDebt, (factorsBase - reserveFactor), factorsBase)
253261 
254262 let currentTotalDeposit = (storedTotalDeposit + addedDeposit)
255263 
256264 let currentTotalReserve = ((storedTotalReserve + addedDebt) - addedDeposit)
257265 
258266 func paymentAmount (i,assetId) = {
259267     let p = i.payments[0].amount
260268     if ((0 >= p))
261269         then throw("Payment is less than min allowed amount")
262270         else if ((i.payments[0].assetId != assetId))
263271             then throw(("bad asset attached: required " + assetIdStr))
264272             else p
265273     }
266274 
267275 
268276 func syncTotals (additionalDeposit,additionalDebt,additionalReserve,keepAtBalance) = {
269277     let actualBalance =     match assetId {
270278         case aid: ByteVector => 
271279             assetBalance(this, aid)
272280         case _ => 
273281             wavesBalance(this).available
274282     }
275283     let stakingAction = if ((actualBalance == keepAtBalance))
276284         then unit
277285         else {
278286             let stakingEnabled = valueOrElse(getBoolean(configAddress, ("staking_enabled_" + assetIdStr)), false)
279287             if (!(stakingEnabled))
280288                 then unit
281289                 else {
282290                     let stakingAddress = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(configAddress, ("staking_config_" + assetIdStr)), ("no staking address for " + assetIdStr))), ("bad staking address for " + assetIdStr))
283291                     if ((actualBalance > keepAtBalance))
284292                         then invoke(stakingAddress, "put", nil, [AttachedPayment(assetId, (actualBalance - keepAtBalance))])
285293                         else invoke(stakingAddress, "get", [(keepAtBalance - actualBalance)], nil)
286294                     }
287295             }
288296     if ((stakingAction == stakingAction))
289297         then [writeInt(indexStore, currentIndex), writeInt(lastUpdateHeightStore, HEIGHT), writeInt(totalDepositStore, (currentTotalDeposit + additionalDeposit)), writeInt(totalDebtStore, (currentTotalDebt + additionalDebt)), writeInt(totalReserveStore, (currentTotalReserve + additionalReserve))]
290298         else throw("Strict value is not equal to itself.")
291299     }
292300 
293301 
294302 func pow10 (n) = if ((n == 6))
295303     then 1000000
296304     else if ((n == 8))
297305         then 100000000
298306         else throw(("bad decimals: " + toString(n)))
299307 
300308 
301309 func assetToUsd (amount) = fraction(amount, oraclePrice, pow10(assetDecimals))
302310 
303311 
304312 func usdToAsset (amount) = fraction(amount, pow10(assetDecimals), oraclePrice)
305313 
306314 
307315 func aTokenToAsset (aTokenAmount) = if ((aTokenAmount == 0))
308316     then 0
309317     else if ((aTokenCirculation > 0))
310318         then fraction(aTokenAmount, currentTotalDeposit, aTokenCirculation)
311319         else aTokenAmount
312320 
313321 
314322 func assetToAToken (assetAmount) = if ((assetAmount == 0))
315323     then 0
316324     else if ((aTokenCirculation > 0))
317325         then fraction(assetAmount, aTokenCirculation, currentTotalDeposit)
318326         else assetAmount
319327 
320328 
321329 func assetToATokenCeil (assetAmount) = if ((assetAmount == 0))
322330     then 0
323331     else if ((aTokenCirculation > 0))
324332         then fractionCeil(assetAmount, aTokenCirculation, currentTotalDeposit)
325333         else assetAmount
326334 
327335 
328336 func aTokenBalance (address) = valueOrElse(getI(aTokenBalanceStore(address)), 0)
329337 
330338 
331339 func enableCol (user) = BooleanEntry(useAsCollateralStore(user), true)
332340 
333341 
334342 func enableColIfNeeded (user) = if ((currentUserDebt(user) > 0))
335343     then [enableCol(user)]
336344     else nil
337345 
338346 
339347 func collapseUser (address,amount) = {
340348     let debt = currentUserDebt(address)
341349     let deposit = aTokenToAsset(aTokenBalance(address))
342350     let maxPossible = min([debt, deposit])
343351     let amt = if ((-1 > amount))
344352         then throw("invalid collapse amount")
345353         else if (if ((maxPossible == 0))
346354             then true
347355             else (amount == 0))
348356             then throw("nothing to collapse")
349357             else if (if ((amount == -1))
350358                 then true
351359                 else (amount > maxPossible))
352360                 then maxPossible
353361                 else amount
354362     let removedAtokens = assetToATokenCeil(amt)
355363     $Tuple2((syncTotals(-(amt), -(amt), 0, 0) ++ [changeBy(aTokenBalanceStore(address), -(removedAtokens)), changeBy(aTokenCirculationStore, -(removedAtokens)), writeInt(debtStore(address), (debt - amt)), writeInt(debtIndexStore(address), currentIndex)]), amt)
356364     }
357365 
358366 
359367 func repayUser (userAddress,amount) = {
360368     let checks = opAllowed("repay")
361369     if ((checks == checks))
362370         then {
363371             let currentDebt = currentUserDebt(userAddress)
364372             if ((currentDebt == currentDebt))
365373                 then {
366-                    let $t01086911172 = if ((amount > currentDebt))
374+                    let $t01109511398 = if ((amount > currentDebt))
367375                         then $Tuple4(0, -(currentDebt), (amount - currentDebt), [ScriptTransfer(addressFromStringValue(userAddress), (amount - currentDebt), assetId)])
368376                         else $Tuple4((currentDebt - amount), -(amount), 0, nil)
369-                    let newDebt = $t01086911172._1
370-                    let totalDebtUpdate = $t01086911172._2
371-                    let payout = $t01086911172._3
372-                    let actions = $t01086911172._4
377+                    let newDebt = $t01109511398._1
378+                    let totalDebtUpdate = $t01109511398._2
379+                    let payout = $t01109511398._3
380+                    let actions = $t01109511398._4
373381                     let repaid = (amount - payout)
374382                     $Tuple2(((syncTotals(0, totalDebtUpdate, 0, payout) ++ actions) ++ [writeInt(debtStore(userAddress), newDebt), writeInt(debtIndexStore(userAddress), currentIndex)]), repaid)
375383                     }
376384                 else throw("Strict value is not equal to itself.")
377385             }
378386         else throw("Strict value is not equal to itself.")
379387     }
380388 
381389 
382390 func getConfig () = {
383-    let $t01140511425 = ABCD
384-    let a = $t01140511425._1
385-    let b = $t01140511425._2
386-    let c = $t01140511425._3
387-    let d = $t01140511425._4
391+    let $t01163111651 = ABCD
392+    let a = $t01163111651._1
393+    let b = $t01163111651._2
394+    let c = $t01163111651._3
395+    let d = $t01163111651._4
388396     ((((((((((((((("ABCD: " + toString(a)) + ";") + toString(b)) + ";") + toString(c)) + ";") + toString(d)) + ", reserveFactor: ") + toString(reserveFactor)) + ", collateralFactor: ") + toString(collateralFactor)) + ", liquidationThreshold: ") + toString(liquidationThreshold)) + ", liquidationPenalty: ") + toString(liquidationPenalty))
389397     }
390398 
391399 
392400 func getState () = ((((((((((((((((((((((((((("currentTotalDeposit: " + toString(currentTotalDeposit)) + ", storedTotalDeposit: ") + toString(storedTotalDeposit)) + ", currentTotalDebt: ") + toString(currentTotalDebt)) + ", storedTotalDebt: ") + toString(storedTotalDebt)) + ", currentTotalReserve: ") + toString(currentTotalReserve)) + ", storedTotalReserve: ") + toString(storedTotalReserve)) + ", currentIndex:") + toString(currentIndex)) + ", storedIndex: ") + toString(storedIndex)) + ", lastUpdateHeight: ") + toString(lastUpdateHeight)) + ", utilization: ") + toString(utilization)) + ", aTokenCirculation: ") + toString(aTokenCirculation)) + ", aTokenPrice: ") + toString(aTokenToAsset(pow(10, 0, assetDecimals, 0, 0, FLOOR)))) + ", APR: ") + toString(apr)) + ", APY: ") + toString(apy))
393401 
394402 
395403 func getUserState (user) = {
396404     let aBalance = aTokenBalance(user)
397405     let aBalanceWallet = getBalance(addressFromStringValue(user), aTokenId)
398406     ((((((((((((((((("currentDebt: " + toString(currentUserDebt(user))) + ", storedDebt: ") + toString(valueOrElse(getI(debtStore(user)), 0))) + ", currentDeposit: ") + toString(aTokenToAsset(aBalance))) + ", aTokenContractBalance: ") + toString(aBalance)) + ", aTokenWalletBalance: ") + toString(aBalanceWallet)) + ", walletStake: ") + toString(aTokenToAsset(aBalanceWallet))) + ", assetWalletBalance: ") + toString(getBalance(addressFromStringValue(user), assetId))) + ", useAsCollateral: ") + toString(valueOrElse(getBoolean(this, useAsCollateralStore(user)), true))) + ", storedIndex: ") + toString(valueOrElse(getI(debtIndexStore(user)), 0)))
399407     }
400408 
401409 
402410 func debugTotals () = ((((((((((((((((((((((("storedTotalDeposit: " + toString(storedTotalDeposit)) + ", storedTotalDebt: ") + toString(storedTotalDebt)) + ", storedTotalReserve: ") + toString(storedTotalReserve)) + ", storedIndex: ") + toString(storedIndex)) + ", lastUpdateHeight: ") + toString(lastUpdateHeight)) + ", currentTotalDeposit: ") + toString(currentTotalDeposit)) + ", currentTotalDebt: ") + toString(currentTotalDebt)) + ", currentTotalReserve: ") + toString(currentTotalReserve)) + ", currentIndex: ") + toString(currentIndex)) + ", currentHeight: ") + toString(HEIGHT)) + ", aTokenCirculation: ") + toString(aTokenCirculation)) + ", aTokenPrice: ") + toString(aTokenToAsset(pow(10, 0, assetDecimals, 0, 0, FLOOR))))
403411 
404412 
405413 func userTotals (user) = {
406414     let atokens = aTokenBalance(user)
407415     let asset = aTokenToAsset(atokens)
408416     let debt = currentUserDebt(user)
409417     if ((HEIGHT == lastUpdateHeight))
410418         then $Tuple4(storedTotalDeposit, storedTotalDebt, asset, debt)
411419         else $Tuple4(currentTotalDeposit, currentTotalDebt, asset, debt)
412420     }
413421 
414422 
415423 @Callable(i)
424+func getReserveDivsInfo () = $Tuple2(nil, $Tuple2(currentTotalReserve, assetIdStr))
425+
426+
427+
428+@Callable(i)
416429 func getCurrentTotals (user) = $Tuple2(nil, userTotals(user))
417430 
418431 
419432 
420433 @Callable(i)
421434 func getCurrentTotals2 (user1,user2) = {
422-    let $t01455314590 = userTotals(user1)
423-    let d1 = $t01455314590._1
424-    let d2 = $t01455314590._2
425-    let d3 = $t01455314590._3
426-    let d4 = $t01455314590._4
427-    let $t01459514632 = userTotals(user2)
428-    let e1 = $t01459514632._1
429-    let e2 = $t01459514632._2
430-    let e3 = $t01459514632._3
431-    let e4 = $t01459514632._4
435+    let $t01486214899 = userTotals(user1)
436+    let d1 = $t01486214899._1
437+    let d2 = $t01486214899._2
438+    let d3 = $t01486214899._3
439+    let d4 = $t01486214899._4
440+    let $t01490414941 = userTotals(user2)
441+    let e1 = $t01490414941._1
442+    let e2 = $t01490414941._2
443+    let e3 = $t01490414941._3
444+    let e4 = $t01490414941._4
432445     $Tuple2(nil, $Tuple6(d1, d2, d3, d4, e3, e4))
433446     }
434447 
435448 
436449 
437450 @Callable(i)
438451 func advise () = $Tuple2(nil, ((((("reserveAddress: " + toString(this)) + ", ") + getConfig()) + ", ") + getState()))
439452 
440453 
441454 
442455 @Callable(i)
443456 func adviseUser (user) = {
444457     let currentDebtUsd = assetToUsd(currentTotalDebt)
445458     let currentDepositUsd = assetToUsd(currentTotalDeposit)
446459     let asCollateral = valueOrElse(getBoolean(this, useAsCollateralStore(user)), true)
447460     let effectiveDepositUsd = if (asCollateral)
448461         then currentDepositUsd
449462         else 0
450463     let overlapUsd = min([currentDebtUsd, effectiveDepositUsd])
451464     let overlapCharge = fractionCeil(overlapUsd, accountHealthOverlap, factorsBase)
452465     let bp = if ((currentDebtUsd > effectiveDepositUsd))
453466         then 0
454467         else fraction((effectiveDepositUsd - currentDebtUsd), collateralFactor, factorsBase)
455468     let bpu = if ((currentDebtUsd > effectiveDepositUsd))
456469         then (fraction((currentDebtUsd - effectiveDepositUsd), factorsBase, liquidationThreshold) + overlapCharge)
457470         else overlapCharge
458471     let enriched = ((((((((("reserveAddress: " + toString(this)) + ", currentDebtUsd: ") + toString(currentDebtUsd)) + ", currentDepositUsd: ") + toString(currentDepositUsd)) + ", bp: ") + toString(bp)) + ", bpu: ") + toString(bpu))
459472     $Tuple2(nil, ((enriched + ", ") + getUserState(user)))
460473     }
461474 
462475 
463476 
464477 @Callable(i)
465478 func addInterest () = if ((i.payments[0].assetId != assetId))
466479     then throw("can't add interest with unrelated token")
467480     else syncTotals(i.payments[0].amount, 0, 0, 0)
468481 
469482 
470483 
471484 @Callable(i)
472485 func addToReserve () = if ((i.payments[0].assetId != assetId))
473486     then throw("can't add interest with unrelated token")
474487     else syncTotals(0, 0, i.payments[0].amount, 0)
475488 
476489 
477490 
478491 @Callable(i)
479492 func withdrawFromReserve (amt) = {
480-    let admin = getStringValue(configAddress, "admin")
481-    if ((toString(i.caller) != admin))
482-        then throw("only admin can do")
483-        else (syncTotals(0, 0, -(amt), amt) ++ [ScriptTransfer(addressFromStringValue(admin), amt, assetId)])
493+    let checks = divAdminOnly(i)
494+    if ((checks == checks))
495+        then {
496+            let diff = if ((amt == -1))
497+                then currentTotalReserve
498+                else amt
499+            $Tuple2((syncTotals(0, 0, -(diff), diff) ++ [ScriptTransfer(i.caller, diff, assetId)]), diff)
500+            }
501+        else throw("Strict value is not equal to itself.")
484502     }
485503 
486504 
487505 
488506 @Callable(i)
489507 func forceUpdate () = {
490508     let admin = getStringValue(configAddress, "admin")
491509     if ((toString(i.caller) != admin))
492510         then throw("only admin can do")
493511         else syncTotals(0, 0, 0, 0)
494512     }
495513 
496514 
497515 
498516 @Callable(i)
499517 func initialize (cfgAddress,oracleAddr,assetIdOrWaves,aTokenName,aTokenDescription,aTokenDecimals) = {
500518     let checks = if (notInitialized)
501519         then isAssetIdOrWaves(assetIdOrWaves)
502520         else false
503521     if ((checks == checks))
504522         then {
505523             let aToken = Issue(aTokenName, aTokenDescription, 0, aTokenDecimals, true)
506524 [aToken, writeString(oracleStore, oracleAddr), writeInt(aTokenDecimalsStore, aTokenDecimals), writeString(aTokenNameStore, aTokenName), writeString(assetIdStore, assetIdOrWaves), writeString(configAddressStore, cfgAddress), writeString(aTokenIdStore, toBase58String(calculateAssetId(aToken))), writeInt(lastUpdateHeightStore, HEIGHT)]
507525             }
508526         else throw("Strict value is not equal to itself.")
509527     }
510528 
511529 
512530 
513531 @Callable(i)
514532 func userDepositUSD (address) = $Tuple2(nil, assetToUsd(aTokenToAsset(aTokenBalance(address))))
515533 
516534 
517535 
518536 @Callable(i)
519537 func userDebtUSD (address) = $Tuple2(nil, assetToUsd(currentUserDebt(address)))
520538 
521539 
522540 
523541 @Callable(i)
524542 func userBalance (address) = {
525543     let atokens = aTokenBalance(address)
526544     let asset = aTokenToAsset(atokens)
527545     let debt = currentUserDebt(address)
528546     $Tuple2(nil, $Tuple6(atokens, asset, assetToUsd(asset), debt, assetToUsd(debt), valueOrElse(getBoolean(this, useAsCollateralStore(address)), true)))
529547     }
530548 
531549 
532550 
533551 @Callable(i)
534552 func userDebt (address) = {
535553     let debt = currentUserDebt(address)
536554     let debtUsd = assetToUsd(debt)
537555     $Tuple2(nil, $Tuple2(debt, debtUsd))
538556     }
539557 
540558 
541559 
542560 @Callable(i)
543561 func assetUsdValue (assetAmount) = $Tuple2(nil, assetToUsd(assetAmount))
544562 
545563 
546564 
547565 @Callable(i)
548566 func repayFor (userAddress) = {
549567     let checks = mainOnly(i)
550568     if ((checks == checks))
551569         then repayUser(userAddress, paymentAmount(i, assetId))
552570         else throw("Strict value is not equal to itself.")
553571     }
554572 
555573 
556574 
557575 @Callable(i)
558576 func depositFor (depositor,useAsCollateral) = {
559577     let checks = if (mainOnly(i))
560578         then opAllowed("deposit")
561579         else false
562580     if ((checks == checks))
563581         then if (if ((currentUserDebt(depositor) > 0))
564582             then !(useAsCollateral)
565583             else false)
566584             then throw("can't disable use as collateral for asset with open debt")
567585             else {
568586                 let amount = paymentAmount(i, assetId)
569587                 let aTokenAmount = assetToAToken(amount)
570588                 (syncTotals(amount, 0, 0, 0) ++ [changeBy(aTokenCirculationStore, aTokenAmount), changeBy(aTokenBalanceStore(depositor), aTokenAmount), BooleanEntry(useAsCollateralStore(depositor), useAsCollateral)])
571589                 }
572590         else throw("Strict value is not equal to itself.")
573591     }
574592 
575593 
576594 
577595 @Callable(i)
578596 func withdrawFor (address,amount) = {
579597     let maxWithdraw = ((storedTotalDeposit + storedTotalReserve) - storedTotalDebt)
580598     let checks = if (if (if (mainOnly(i))
581599         then liquidityCheck(amount, maxWithdraw, "funds in use")
582600         else false)
583601         then throwIf((-1 > amount), "invalid amount")
584602         else false)
585603         then opAllowed("withdraw")
586604         else false
587605     if ((checks == checks))
588606         then {
589-            let $t01932119515 = if ((amount == -1))
607+            let $t01957619770 = if ((amount == -1))
590608                 then {
591609                     let atokens = aTokenBalance(address)
592610                     $Tuple2(atokens, aTokenToAsset(atokens))
593611                     }
594612                 else $Tuple2(assetToATokenCeil(amount), amount)
595-            let removedAtokens = $t01932119515._1
596-            let withdrawAmount = $t01932119515._2
613+            let removedAtokens = $t01957619770._1
614+            let withdrawAmount = $t01957619770._2
597615             $Tuple2((syncTotals(-(withdrawAmount), 0, 0, withdrawAmount) ++ [ScriptTransfer(addressFromStringValue(address), withdrawAmount, assetId), changeBy(aTokenBalanceStore(address), -(removedAtokens)), changeBy(aTokenCirculationStore, -(removedAtokens))]), withdrawAmount)
598616             }
599617         else throw("Strict value is not equal to itself.")
600618     }
601619 
602620 
603621 
604622 @Callable(i)
605623 func replenishWithAtokenFor (user) = {
606624     let checks = if (mainOnly(i))
607625         then opAllowed("atokens")
608626         else false
609627     if ((checks == checks))
610628         then {
611629             let aTokenAmount = paymentAmount(i, aTokenId)
612630             $Tuple2(((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(user), aTokenAmount), Burn(aTokenId, aTokenAmount)]) ++ enableColIfNeeded(user)), aTokenToAsset(aTokenAmount))
613631             }
614632         else throw("Strict value is not equal to itself.")
615633     }
616634 
617635 
618636 
619637 @Callable(i)
620638 func borrowFor (address,amountToBorrow) = {
621639     let checks = if (if (mainOnly(i))
622640         then liquidityCheck(amountToBorrow, (storedTotalDeposit - storedTotalDebt), "too much borrow requested")
623641         else false)
624642         then opAllowed("borrow")
625643         else false
626644     if ((checks == checks))
627645         then {
628646             let currentDebt = currentUserDebt(address)
629647             let newDebt = (currentDebt + amountToBorrow)
630648             (syncTotals(0, amountToBorrow, 0, amountToBorrow) ++ [writeInt(debtStore(address), newDebt), enableCol(address), writeInt(debtIndexStore(address), currentIndex), ScriptTransfer(addressFromStringValue(address), amountToBorrow, assetId)])
631649             }
632650         else throw("Strict value is not equal to itself.")
633651     }
634652 
635653 
636654 
637655 @Callable(i)
638656 func mintAtokenFor (address,amountToMint) = {
639657     let userATokenBalance = aTokenBalance(address)
640658     let amount = if ((amountToMint == -1))
641659         then userATokenBalance
642660         else amountToMint
643661     let checks = if (if (if (mainOnly(i))
644662         then opAllowed("atokens")
645663         else false)
646664         then throwIf((-1 > amountToMint), "invalid amountToMint")
647665         else false)
648666         then throwIf((amount > userATokenBalance), ("Trying to mint more than available, max: " + toString(userATokenBalance)))
649667         else false
650668     if ((checks == checks))
651669         then $Tuple2((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(address), -(amount)), Reissue(aTokenId, amount, true), ScriptTransfer(addressFromStringValue(address), amount, aTokenId)]), aTokenToAsset(amount))
652670         else throw("Strict value is not equal to itself.")
653671     }
654672 
655673 
656674 
657675 @Callable(i)
658-func redeemAtokens () = {
659-    let checks = opAllowed("atokens")
676+func redeemAtokensFor (user) = {
677+    let checks = if (mainOnly(i))
678+        then opAllowed("atokens")
679+        else false
660680     if ((checks == checks))
661681         then {
662682             let aTokenAmount = paymentAmount(i, aTokenId)
663683             let outAmount = aTokenToAsset(aTokenAmount)
664-            (syncTotals(-(outAmount), 0, 0, outAmount) ++ [ScriptTransfer(i.caller, outAmount, assetId), changeBy(aTokenCirculationStore, -(aTokenAmount)), Burn(aTokenId, aTokenAmount)])
684+            $Tuple2((syncTotals(-(outAmount), 0, 0, outAmount) ++ [ScriptTransfer(addressFromStringValue(user), outAmount, assetId), changeBy(aTokenCirculationStore, -(aTokenAmount)), Burn(aTokenId, aTokenAmount)]), outAmount)
665685             }
666686         else throw("Strict value is not equal to itself.")
667687     }
668688 
669689 
670690 
671691 @Callable(i)
672692 func transferATokensFor (from,to,valueUsd) = {
673693     let checks = if (mainOnly(i))
674694         then opAllowed("transfer_debt")
675695         else false
676696     if ((checks == checks))
677697         then {
678698             let assets = usdToAsset(valueUsd)
679699             let atokens = assetToAToken(assets)
680700             let aTokensFrom = aTokenBalance(from)
681701             if ((atokens > aTokensFrom))
682702                 then throw((((((((((("transferAtokensFor error:" + " transfer.valueUsd: ") + toString(valueUsd)) + " transfer.assets: ") + toString(assets)) + " transfer.atokens: ") + toString(atokens)) + " from.atokens: ") + toString(aTokensFrom)) + " at ") + toString(this)))
683703                 else $Tuple2(((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(from), -(atokens)), changeBy(aTokenBalanceStore(to), atokens)]) ++ enableColIfNeeded(to)), aTokenToAsset(atokens))
684704             }
685705         else throw("Strict value is not equal to itself.")
686706     }
687707 
688708 
689709 
690710 @Callable(i)
691711 func transferDebtFor (from,to,amount) = {
692712     let checks = if (mainOnly(i))
693713         then opAllowed("transfer_debt")
694714         else false
695715     if ((checks == checks))
696716         then $Tuple2((syncTotals(0, 0, 0, 0) ++ [writeInt(debtStore(from), (currentUserDebt(from) - amount)), writeInt(debtStore(to), (currentUserDebt(to) + amount)), writeInt(debtIndexStore(from), currentIndex), writeInt(debtIndexStore(to), currentIndex), enableCol(to)]), amount)
697717         else throw("Strict value is not equal to itself.")
698718     }
699719 
700720 
701721 
702722 @Callable(i)
703723 func disableUseAsCollateralFor (address) = {
704724     let checks = if (mainOnly(i))
705725         then opAllowed("use_as_col")
706726         else false
707727     if ((checks == checks))
708728         then if ((currentUserDebt(address) > 0))
709729             then throw("can't disable collateral for asset with open debt")
710730             else (syncTotals(0, 0, 0, 0) ++ [BooleanEntry(useAsCollateralStore(address), false)])
711731         else throw("Strict value is not equal to itself.")
712732     }
713733 
714734 
715735 
716736 @Callable(i)
717737 func enableUseAsCollateral () = {
718738     let checks = opAllowed("use_as_col")
719739     if ((checks == checks))
720740         then (syncTotals(0, 0, 0, 0) ++ [enableCol(toString(i.caller))])
721741         else throw("Strict value is not equal to itself.")
722742     }
723743 
724744 
725745 
726746 @Callable(i)
727747 func collapseFor (user) = {
728748     let checks = if (mainOnly(i))
729749         then opAllowed("force_collapse")
730750         else false
731751     if ((checks == checks))
732752         then collapseUser(user, -1)
733753         else throw("Strict value is not equal to itself.")
734754     }
735755 
736756 
737757 
738758 @Callable(i)
739759 func collapseForAmount (user,amount) = {
740760     let checks = if (mainOnly(i))
741761         then opAllowed("collapse")
742762         else false
743763     if ((checks == checks))
744764         then collapseUser(user, amount)
745765         else throw("Strict value is not equal to itself.")
746766     }
747767 
748768 
github/deemru/w8io/786bc32 
83.94 ms ◑