tx · FMS6w7BGyn5VFdu3yVE6gM682UXaoiJv9wY2FB3oNUPp

3MxWgDbE9EmjQj8b3LfFwa91FZizptyeQXS:  -0.10000000 Waves

2022.10.11 15:24 [2267668] smart account 3MxWgDbE9EmjQj8b3LfFwa91FZizptyeQXS > SELF 0.00000000 Waves

{ "type": 13, "id": "FMS6w7BGyn5VFdu3yVE6gM682UXaoiJv9wY2FB3oNUPp", "fee": 10000000, "feeAssetId": null, "timestamp": 1665491100127, "version": 2, "chainId": 84, "sender": "3MxWgDbE9EmjQj8b3LfFwa91FZizptyeQXS", "senderPublicKey": "C7xgcYqQ8qV8rmvzAjhQWq4cz82F6VJfXMNygvrTXsfW", "proofs": [ "3vEuraXjqNr9e1yTCqAGSKMccXQxzNknUSehzN6kt9UnbD4U1F6rgrRufTfvj6W1rLQ7GKPnYZoSy6DMqTRVcoSk" ], "script": "base64:BgJlCAISBAoCEQESBQoDCAEBEgQKAgEEEgQKAhEIEgMKAQESBgoECAgBCBIECgIIARIDCgEREgQKAhEBEgUKAwEICBIECgIIARIFCgMIAQESABIAEgQKAhEEEgQKAgEBEgASABIAEgBXAAlQUkVDSVNJT04AwIQ9AAVNQVhfQQDAhD0ADE1BWF9BX0NIQU5HRQAKAAhERUNJTUFMUwAGAA1NSU5fUkFNUF9USU1FCQBpAgCAowUAPAAHdmVyc2lvbgIFMy4wLjAACGtWZXJzaW9uAgd2ZXJzaW9uAAdrQXNzZXRzAglhc3NldF9pZHMADWtBc3NldEJhbGFuY2UCCF9iYWxhbmNlAAdrQWN0aXZlAgZhY3RpdmUABmtDYXVzZQIOc2h1dGRvd25fY2F1c2UADWtTaGFyZUFzc2V0SWQCDnNoYXJlX2Fzc2V0X2lkABFrU2hhcmVBc3NldFN1cHBseQISc2hhcmVfYXNzZXRfc3VwcGx5AARrRmVlAgpjb21taXNzaW9uABJrREFwcFRocmVzaG9sZENvZWYCEWRBcHBUaHJlc2hvbGRDb2VmAAxrVVNETkFkZHJlc3MCGHN0YWtpbmdfdXNkbm5zYnRfYWRkcmVzcwAKa0Rpc2NvdW50cwIJZGlzY291bnRzAA9rRGlzY291bnRWYWx1ZXMCD2Rpc2NvdW50X3ZhbHVlcwAOa1VzZXJTd29wSW5Hb3YCDF9TV09QX2Ftb3VudAANa0FkbWluUHViS2V5MQILYWRtaW5fcHViXzEADWtBZG1pblB1YktleTICC2FkbWluX3B1Yl8yAA1rQWRtaW5QdWJLZXkzAgthZG1pbl9wdWJfMwASa0FkbWluSW52b2tlUHViS2V5AhBhZG1pbl9pbnZva2VfcHViABBrTW9uZXlCb3hBZGRyZXNzAhFtb25leV9ib3hfYWRkcmVzcwALa0dvdkFkZHJlc3MCEmdvdmVybmFuY2VfYWRkcmVzcwAOa1ZvdGluZ0FkZHJlc3MCDnZvdGluZ19hZGRyZXNzAA9rRmFybWluZ0FkZHJlc3MCD2Zhcm1pbmdfYWRkcmVzcwARa0xQRmFybWluZ0FkZHJlc3MCCmxwX2Zhcm1pbmcABm9yYWNsZQkBB0FkZHJlc3MBARoBVEgTlwzA0zPMJTKAtin3p2RogKvjzHtLmQETZ2V0QmFzZTU4RnJvbU9yYWNsZQEDa2V5BAckbWF0Y2gwCQCdCAIFBm9yYWNsZQUDa2V5AwkAAQIFByRtYXRjaDACBlN0cmluZwQGc3RyaW5nBQckbWF0Y2gwCQDZBAEFBnN0cmluZwQHbm90aGluZwUHJG1hdGNoMAkAAgEJAKwCAgUDa2V5AghpcyBlbXB0eQAMYWRtaW5QdWJLZXkxCQETZ2V0QmFzZTU4RnJvbU9yYWNsZQEFDWtBZG1pblB1YktleTEADGFkbWluUHViS2V5MgkBE2dldEJhc2U1OEZyb21PcmFjbGUBBQ1rQWRtaW5QdWJLZXkyAAxhZG1pblB1YktleTMJARNnZXRCYXNlNThGcm9tT3JhY2xlAQUNa0FkbWluUHViS2V5MwARYWRtaW5QdWJLZXlJbnZva2UJARNnZXRCYXNlNThGcm9tT3JhY2xlAQUSa0FkbWluSW52b2tlUHViS2V5AA9tb25leUJveEFkZHJlc3MJAQdBZGRyZXNzAQkBE2dldEJhc2U1OEZyb21PcmFjbGUBBRBrTW9uZXlCb3hBZGRyZXNzAApnb3ZBZGRyZXNzCQEHQWRkcmVzcwEJARNnZXRCYXNlNThGcm9tT3JhY2xlAQULa0dvdkFkZHJlc3MAEnN0YWtpbmdVU0ROQWRkcmVzcwkBB0FkZHJlc3MBCQETZ2V0QmFzZTU4RnJvbU9yYWNsZQEFDGtVU0ROQWRkcmVzcwANdm90aW5nQWRkcmVzcwkBB0FkZHJlc3MBCQETZ2V0QmFzZTU4RnJvbU9yYWNsZQEFDmtWb3RpbmdBZGRyZXNzAA5mYXJtaW5nQWRkcmVzcwkBB0FkZHJlc3MBCQETZ2V0QmFzZTU4RnJvbU9yYWNsZQEFD2tGYXJtaW5nQWRkcmVzcwAQbHBGYXJtaW5nQWRkcmVzcwkBB0FkZHJlc3MBCQETZ2V0QmFzZTU4RnJvbU9yYWNsZQEFEWtMUEZhcm1pbmdBZGRyZXNzAARVU0ROASBvJKPKqzDcUimY6CxhWu5afyNNwi11u+mdqlTg0tAHwQANc3Rha2luZ0Fzc2V0cwkAzAgCCQDYBAEFBFVTRE4FA25pbAAGYWN0aXZlCQERQGV4dHJOYXRpdmUoMTA1MSkCBQR0aGlzBQdrQWN0aXZlAAxzaGFyZUFzc2V0SWQJANkEAQkBEUBleHRyTmF0aXZlKDEwNTMpAgUEdGhpcwUNa1NoYXJlQXNzZXRJZAALc2hhcmVTdXBwbHkJARFAZXh0ck5hdGl2ZSgxMDUwKQIFBHRoaXMFEWtTaGFyZUFzc2V0U3VwcGx5AAlmZWVTY2FsZTYAwIQ9AANmZWUJARFAZXh0ck5hdGl2ZSgxMDUwKQIFBHRoaXMFBGtGZWUADWZlZUdvdmVybmFuY2UJAGsDACgFCWZlZVNjYWxlNgBkAAlpbml0aWFsX0EJARFAZXh0ck5hdGl2ZSgxMDUwKQIFBHRoaXMCCWluaXRpYWxfQQAIZnV0dXJlX0EJARFAZXh0ck5hdGl2ZSgxMDUwKQIFBHRoaXMCCGZ1dHVyZV9BAA5pbml0aWFsX0FfdGltZQkBC3ZhbHVlT3JFbHNlAgkAmggCBQR0aGlzAg5pbml0aWFsX0FfdGltZQAAAA1mdXR1cmVfQV90aW1lCQELdmFsdWVPckVsc2UCCQCaCAIFBHRoaXMCDWZ1dHVyZV9BX3RpbWUAAAAIYXNzZXRJZHMJALUJAgkBEUBleHRyTmF0aXZlKDEwNTMpAgUEdGhpcwUHa0Fzc2V0cwIBLAAGbkNvaW5zCQCQAwEFCGFzc2V0SWRzAQdzdXNwZW5kAQVjYXVzZQkAzAgCCQEMQm9vbGVhbkVudHJ5AgUHa0FjdGl2ZQcJAMwIAgkBC1N0cmluZ0VudHJ5AgUGa0NhdXNlBQVjYXVzZQUDbmlsAQ10aHJvd0lzQWN0aXZlAAkAAgECFkRBcHAgaXMgYWxyZWFkeSBhY3RpdmUBCGlzQWN0aXZlAAMFBmFjdGl2ZQUEdW5pdAkAAgECH0RBcHAgaXMgaW5hY3RpdmUgYXQgdGhpcyBtb21lbnQBC2lzQWRtaW5DYWxsAQFpAwkBD2NvbnRhaW5zRWxlbWVudAIJAMwIAgUMYWRtaW5QdWJLZXkxCQDMCAIFDGFkbWluUHViS2V5MgkAzAgCBQxhZG1pblB1YktleTMFA25pbAgFAWkPY2FsbGVyUHVibGljS2V5BQR1bml0CQACAQIhT25seSBhZG1pbiBjYW4gY2FsbCB0aGlzIGZ1bmN0aW9uAQppc1NlbGZDYWxsAQFpAwkAAAIFBHRoaXMIBQFpBmNhbGxlcgUEdW5pdAkAAgECK09ubHkgY29udHJhY3QgaXRzZWxmIGNhbiBjYWxsIHRoaXMgZnVuY3Rpb24ABGJpZzIJALYCAQACAAZpdGVyMTAJAMwIAgAACQDMCAIAAQkAzAgCAAIJAMwIAgADCQDMCAIABAkAzAgCAAUJAMwIAgAGCQDMCAIABwkAzAgCAAgJAMwIAgAJBQNuaWwABml0ZXIxNQkAzAgCAAAJAMwIAgABCQDMCAIAAgkAzAgCAAMJAMwIAgAECQDMCAIABQkAzAgCAAYJAMwIAgAHCQDMCAIACAkAzAgCAAkJAMwIAgAKCQDMCAIACwkAzAgCAAwJAMwIAgANCQDMCAIADgUDbmlsAAZpdGVyMTYJAMwIAgAACQDMCAIAAQkAzAgCAAIJAMwIAgADCQDMCAIABAkAzAgCAAUJAMwIAgAGCQDMCAIABwkAzAgCAAgJAMwIAgAJCQDMCAIACgkAzAgCAAsJAMwIAgAMCQDMCAIADQkAzAgCAA4JAMwIAgAPBQNuaWwADmJsb2NrVGltZXN0YW1wBQZoZWlnaHQBBmFzc2VydAEBYQMFAWEHBgEUY2FsY3VsYXRlRmVlRGlzY291bnQBCHVzZXJBZGRyBAR1c2VyBAckbWF0Y2gwBQh1c2VyQWRkcgMJAAECBQckbWF0Y2gwAgdBZGRyZXNzBAF1BQckbWF0Y2gwCQClCAEFAXUDCQABAgUHJG1hdGNoMAIGU3RyaW5nBAF1BQckbWF0Y2gwBQF1CQACAQIYVW5rbm93IHR5cGUgb2YgdXNlciBBZGRyBApzd29wQW1vdW50CQELdmFsdWVPckVsc2UCCQCaCAIFCmdvdkFkZHJlc3MJAKwCAgUEdXNlcgUOa1VzZXJTd29wSW5Hb3YAAAQOZGlzY291bnRWYWx1ZXMJALUJAgkBEUBleHRyTmF0aXZlKDEwNTMpAgUGb3JhY2xlBQ9rRGlzY291bnRWYWx1ZXMCASwECWRpc2NvdW50cwkAtQkCCQERQGV4dHJOYXRpdmUoMTA1MykCBQZvcmFjbGUFCmtEaXNjb3VudHMCASwDAwkAZwIFCnN3b3BBbW91bnQJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQ5kaXNjb3VudFZhbHVlcwAACQBmAgkBDXBhcnNlSW50VmFsdWUBCQCRAwIFDmRpc2NvdW50VmFsdWVzAAEFCnN3b3BBbW91bnQHCQBlAgUJZmVlU2NhbGU2CQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUJZGlzY291bnRzAAADAwkAZwIFCnN3b3BBbW91bnQJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQ5kaXNjb3VudFZhbHVlcwABCQBmAgkBDXBhcnNlSW50VmFsdWUBCQCRAwIFDmRpc2NvdW50VmFsdWVzAAIFCnN3b3BBbW91bnQHCQBlAgUJZmVlU2NhbGU2CQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUJZGlzY291bnRzAAEDAwkAZwIFCnN3b3BBbW91bnQJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQ5kaXNjb3VudFZhbHVlcwACCQBmAgkBDXBhcnNlSW50VmFsdWUBCQCRAwIFDmRpc2NvdW50VmFsdWVzAAMFCnN3b3BBbW91bnQHCQBlAgUJZmVlU2NhbGU2CQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUJZGlzY291bnRzAAIDAwkAZwIFCnN3b3BBbW91bnQJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQ5kaXNjb3VudFZhbHVlcwADCQBmAgkBDXBhcnNlSW50VmFsdWUBCQCRAwIFDmRpc2NvdW50VmFsdWVzAAQFCnN3b3BBbW91bnQHCQBlAgUJZmVlU2NhbGU2CQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUJZGlzY291bnRzAAMDCQBnAgUKc3dvcEFtb3VudAkBDXBhcnNlSW50VmFsdWUBCQCRAwIFDmRpc2NvdW50VmFsdWVzAAQJAGUCBQlmZWVTY2FsZTYJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQlkaXNjb3VudHMABAUJZmVlU2NhbGU2AQJfQQAEAnQxBQ1mdXR1cmVfQV90aW1lBAJBMQUIZnV0dXJlX0EDCQBmAgUCdDEFDmJsb2NrVGltZXN0YW1wBAJBMAUJaW5pdGlhbF9BBAJ0MAUOaW5pdGlhbF9BX3RpbWUDCQBmAgUCQTEFAkEwCQBkAgUCQTAJAGkCCQBoAgkAZQIFAkExBQJBMAkAZQIFDmJsb2NrVGltZXN0YW1wBQJ0MAkAZQIFAnQxBQJ0MAkAZQIFAkEwCQBpAgkAaAIJAGUCBQJBMAUCQTEJAGUCBQ5ibG9ja1RpbWVzdGFtcAUCdDAJAGUCBQJ0MQUCdDAFAkExAQNfeHAACgENYXNzZXRCYWxhbmNlcwIDYWNjB2Fzc2V0SWQJAM0IAgUDYWNjCQELdmFsdWVPckVsc2UCCQCaCAIFBHRoaXMJAKwCAgUHYXNzZXRJZAUNa0Fzc2V0QmFsYW5jZQAACgACJGwFCGFzc2V0SWRzCgACJHMJAJADAQUCJGwKAAUkYWNjMAUDbmlsCgEFJGYwXzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQ1hc3NldEJhbGFuY2VzAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGYwXzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxMAkBBSRmMF8yAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKAQdfeHBfbWVtAQJ4cAUCeHABB3N1bUxpc3QCA2FjYwdlbGVtZW50CQBkAgUDYWNjBQdlbGVtZW50AQVnZXRfRAICeHADYW1wCgABQAkA/AcEBQR0aGlzAgFECQDMCAIFAnhwCQDMCAIFA2FtcAUDbmlsBQNuaWwDCQABAgUBQAIDSW50BQFACQACAQkArAICCQADAQUBQAIYIGNvdWxkbid0IGJlIGNhc3QgdG8gSW50AQ5nZXRfRF9pbnRlcm5hbAICeHADYW1wBAFTCgACJGwFAnhwCgACJHMJAJADAQUCJGwKAAUkYWNjMAAACgEFJGYwXzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQdzdW1MaXN0AgUCJGEJAJEDAgUCJGwFAiRpCgEFJGYwXzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxMAkBBSRmMF8yAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKAwkAAAIFAVMAAAAABANBbm4JAGgCBQNhbXAFBm5Db2lucwQEQW5uUwkAuQICCQC2AgEFA0FubgkAtgIBBQFTBARBbm4xCQC2AgEJAGUCBQNBbm4AAQoBBURwcm9jAgNhY2MBaQMJAAACCAUDYWNjAl8yBgUDYWNjBAVEcHJldggFA2FjYwJfMQoBB0RfUFByb2MCA0RfUAFpAwkAZgIFBm5Db2lucwUBaQkAugICCQC5AgIFA0RfUAUFRHByZXYJALkCAgkAtgIBCQCRAwIFAnhwBQFpCQC2AgEFBm5Db2lucwUDRF9QBANEX1AKAAIkbAUGaXRlcjEwCgACJHMJAJADAQUCJGwKAAUkYWNjMAUFRHByZXYKAQUkZjFfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBB0RfUFByb2MCBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjFfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDEwCQEFJGYxXzICCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoEAUQJALwCAwkAtwICBQRBbm5TCQC5AgIJALYCAQUGbkNvaW5zBQNEX1AFBURwcmV2CQC3AgIJALkCAgUEQW5uMQUFRHByZXYJALkCAgkAtgIBCQBkAgUGbkNvaW5zAAEFA0RfUAMJAL8CAgUBRAUFRHByZXYDCQBnAgABCQCgAwEJALgCAgUBRAUFRHByZXYJAJQKAgUBRAYJAJQKAgUBRAcDCQBnAgABCQCgAwEJALgCAgUFRHByZXYFAUQJAJQKAgUBRAYJAJQKAgUBRAcECyR0MDYzMjE2Mzg3CgACJGwFBml0ZXIxNQoAAiRzCQCQAwEFAiRsCgAFJGFjYzAJAJQKAgkAtgIBBQFTBwoBBSRmMV8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEFRHByb2MCBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjFfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDE1CQEFJGYxXzICCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoACwAMAA0ADgAPBAFECAULJHQwNjMyMTYzODcCXzEECGZpbmlzaGVkCAULJHQwNjMyMTYzODcCXzIDCQAAAgUIZmluaXNoZWQHCQACAQkArAICAhpnZXRfRCgpIG5vdCBmaW5pc2hlZCB3aXRoIAkApgMBBQFECQCgAwEFAUQBB2dldERNZW0CAnhwA2FtcAkBBWdldF9EAgkBB194cF9tZW0BBQJ4cAUDYW1wAQRnZXRZBAJpbgNvdXQBeAN4cF8DCQEGYXNzZXJ0AQkBAiE9AgUCaW4FA291dAkAAgECCXNhbWUgY29pbgMJAQZhc3NlcnQBAwkAZwIFA291dAAACQBnAgUCaW4AAAcJAAIBAgpiZWxvdyB6ZXJvAwkBBmFzc2VydAEDCQBmAgUGbkNvaW5zBQNvdXQJAGYCBQZuQ29pbnMFAmluBwkAAgECDWFib3ZlIE5fQ09JTlMEA2FtcAkBAl9BAAQBRAkBBWdldF9EAgUDeHBfBQNhbXAEA0FubgkAaAIFA2FtcAUGbkNvaW5zCgEDU19jAgNhY2MBaQQLJHQwNjk1ODY5NzUFA2FjYwQCU18IBQskdDA2OTU4Njk3NQJfMQQBYwgFCyR0MDY5NTg2OTc1Al8yBAJ4XwMJAAACBQJpbgUBaQUBeAkAkQMCBQN4cF8FAWkDAwkBAiE9AgUBaQUDb3V0CQBmAgUGbkNvaW5zBQFpBwkAlAoCCQBkAgUCU18FAnhfCQC8AgMFAWMJALYCAQUBRAkAtgIBCQBoAgUCeF8FBm5Db2lucwkAlAoCBQJTXwUBYwQLJHQwNzE4MzcyMzgKAAIkbAUGaXRlcjEwCgACJHMJAJADAQUCJGwKAAUkYWNjMAkAlAoCAAAJALYCAQUBRAoBBSRmMF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEDU19jAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGYwXzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxMAkBBSRmMF8yAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKBAJTXwgFCyR0MDcxODM3MjM4Al8xBAJjXwgFCyR0MDcxODM3MjM4Al8yBAFjCQC8AgMFAmNfCQC2AgEFAUQJALYCAQkAaAIFA0FubgUGbkNvaW5zBAJiRAkAtgIBCQBlAgkAZAIFAlNfCQBpAgUBRAUDQW5uBQFECgEGeV9wcm9jAgNhY2MCX2kDCQAAAggFA2FjYwJfMgYFA2FjYwQGeV9wcmV2CAUDYWNjAl8xBAF5CQC6AgIJALcCAgkAuQICBQZ5X3ByZXYFBnlfcHJldgUBYwkAtwICCQC5AgIFBGJpZzIFBnlfcHJldgUCYkQDCQC/AgIFAXkFBnlfcHJldgMJAGcCAAEJAKADAQkAuAICBQF5BQZ5X3ByZXYJAJQKAgUBeQYJAJQKAgUBeQcDCQBnAgABCQCgAwEJALgCAgUGeV9wcmV2BQF5CQCUCgIFAXkGCQCUCgIFAXkHBAskdDA3NzIwNzc4NwoAAiRsBQZpdGVyMTYKAAIkcwkAkAMBBQIkbAoABSRhY2MwCQCUCgIJALYCAQUBRAcKAQUkZjFfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBBnlfcHJvYwIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMV8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTYJAQUkZjFfMgIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgALAAwADQAOAA8AEAQBeQgFCyR0MDc3MjA3Nzg3Al8xBAhmaW5pc2hlZAgFCyR0MDc3MjA3Nzg3Al8yAwkAAAIFCGZpbmlzaGVkBwkAAgEJAKwCAgIZZ2V0WSgpIG5vdCBmaW5pc2hlZCB3aXRoIAkApgMBBQF5CQCgAwEFAXkBB2dldF95X0QEAkFfAmluAnhwAUQDCQEGYXNzZXJ0AQkAZwIFAmluAAAJAAIBAgxpIGJlbG93IHplcm8DCQEGYXNzZXJ0AQkAZgIFBm5Db2lucwUCaW4JAAIBAg9pIGFib3ZlIE5fQ09JTlMEA0FubgkAaAIFAkFfBQZuQ29pbnMKAQNTX2MCA2FjYwFpBAskdDA4MTY2ODE4MwUDYWNjBAJTXwgFCyR0MDgxNjY4MTgzAl8xBAFjCAULJHQwODE2NjgxODMCXzIEAnhfAwMJAQIhPQIFAmluBQFpCQBmAgUGbkNvaW5zBQFpBwkAkQMCBQJ4cAUBaQAAAwMJAGYCBQZuQ29pbnMFAWkJAQIhPQIFAmluBQFpBwkAlAoCCQBkAgUCU18FAnhfCQC8AgMFAWMJALYCAQUBRAkAtgIBCQBoAgUCeF8FBm5Db2lucwkAlAoCBQJTXwUBYwQLJHQwODQwMzg0NTgKAAIkbAUGaXRlcjEwCgACJHMJAJADAQUCJGwKAAUkYWNjMAkAlAoCAAAJALYCAQUBRAoBBSRmMF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEDU19jAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGYwXzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxMAkBBSRmMF8yAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKBAJTXwgFCyR0MDg0MDM4NDU4Al8xBAJjXwgFCyR0MDg0MDM4NDU4Al8yBAFjCQC8AgMFAmNfCQC2AgEFAUQJALYCAQkAaAIFA0FubgUGbkNvaW5zBAJiRAkAtgIBCQBlAgkAZAIFAlNfCQBpAgUBRAUDQW5uBQFECgEIeV9EX3Byb2MCA2FjYwFpAwkAAAIIBQNhY2MCXzIGBQNhY2MEBnlfcHJldggFA2FjYwJfMQQBeQkAugICCQC3AgIJALkCAgUGeV9wcmV2BQZ5X3ByZXYFAWMJALcCAgkAuQICBQRiaWcyBQZ5X3ByZXYFAmJEAwkAvwICBQF5BQZ5X3ByZXYDCQBnAgABCQCgAwEJALgCAgUBeQUGeV9wcmV2CQCUCgIFAXkGCQCUCgIFAXkHAwkAZwIAAQkAoAMBCQC4AgIFBnlfcHJldgUBeQkAlAoCBQF5BgkAlAoCBQF5BwQLJHQwODk0MTkwMTAKAAIkbAUGaXRlcjE2CgACJHMJAJADAQUCJGwKAAUkYWNjMAkAlAoCCQC2AgEFAUQHCgEFJGYxXzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQh5X0RfcHJvYwIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMV8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTYJAQUkZjFfMgIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgALAAwADQAOAA8AEAQBeQgFCyR0MDg5NDE5MDEwAl8xBAhmaW5pc2hlZAgFCyR0MDg5NDE5MDEwAl8yAwkAAAIFCGZpbmlzaGVkBwkAAgEJAKwCAgIcZ2V0X3lfRCgpIG5vdCBmaW5pc2hlZCB3aXRoIAkApgMBBQF5CQCgAwEFAXkBFF9jYWxjV2l0aGRyYXdPbmVDb2luBAJ4cA1fdG9rZW5fYW1vdW50AWkGY2FsbGVyBAtmZWVEaXNjb3VudAkBFGNhbGN1bGF0ZUZlZURpc2NvdW50AQUGY2FsbGVyBANhbXAJAQJfQQAEBF9mZWUJAGkCCQBoAgkAbgQFA2ZlZQULZmVlRGlzY291bnQFCWZlZVNjYWxlNgUHQ0VJTElORwUGbkNvaW5zCQBoAgAECQBlAgUGbkNvaW5zAAEEDHRvdGFsX3N1cHBseQULc2hhcmVTdXBwbHkEAkQwCQEFZ2V0X0QCBQJ4cAUDYW1wBAJEMQkAZQIFAkQwCQBrAwUNX3Rva2VuX2Ftb3VudAUCRDAFDHRvdGFsX3N1cHBseQQFbmV3X3kJAQdnZXRfeV9EBAUDYW1wBQFpBQJ4cAUCRDEEBGR5XzAJAGUCCQCRAwIFAnhwBQFpBQVuZXdfeQoBD3hwX3JlZHVjZWRfcHJvYwIDYWNjBHhwX2oECyR0MDk2NTE5NjgwBQNhY2MECnhwX3JlZHVjZWQIBQskdDA5NjUxOTY4MAJfMQQFaW5kZXgIBQskdDA5NjUxOTY4MAJfMgQLZHhfZXhwZWN0ZWQDCQAAAgUFaW5kZXgFAWkJAGUCCQBrAwUEeHBfagUCRDEFAkQwBQVuZXdfeQkAZQIFBHhwX2oJAGsDBQR4cF9qBQJEMQUCRDAJAJQKAgkAzQgCBQp4cF9yZWR1Y2VkCQBlAgUEeHBfagkAawMFBF9mZWUFC2R4X2V4cGVjdGVkBQlmZWVTY2FsZTYJAGQCBQVpbmRleAABBAwkdDA5OTQyMTAwMDYKAAIkbAUCeHAKAAIkcwkAkAMBBQIkbAoABSRhY2MwCQCUCgIFA25pbAAACgEFJGYwXzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQ94cF9yZWR1Y2VkX3Byb2MCBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjBfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDEwCQEFJGYwXzICCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoECnhwX3JlZHVjZWQIBQwkdDA5OTQyMTAwMDYCXzEEBWluZGV4CAUMJHQwOTk0MjEwMDA2Al8yBAx4cF9yZWR1Y2VkX2kJAJEDAgUKeHBfcmVkdWNlZAUBaQQCZHkJAGUCCQBlAgUMeHBfcmVkdWNlZF9pCQEHZ2V0X3lfRAQFA2FtcAUBaQUKeHBfcmVkdWNlZAUCRDEAAQkAlAoCBQJkeQkAZQIFBGR5XzAFAmR5AQ1nZXRTdHJBc3NldElkAQdhc3NldElkBAckbWF0Y2gwBQdhc3NldElkAwkAAQIFByRtYXRjaDACCkJ5dGVWZWN0b3IEAmlkBQckbWF0Y2gwCQDYBAEFAmlkAwkAAQIFByRtYXRjaDACBFVuaXQEBXdhdmVzBQckbWF0Y2gwAgVXQVZFUwkAAgECC01hdGNoIGVycm9yARhjYWxjU3Rha2luZ0Z1bmNBbmRBZGRyZXMCBXN0YWtlB2Fzc2V0SWQDBQVzdGFrZQkAlAoCAgxsb2NrTmV1dHJpbm8FEnN0YWtpbmdVU0ROQWRkcmVzcwkAlAoCAg51bmxvY2tOZXV0cmlubwUSc3Rha2luZ1VTRE5BZGRyZXNzARFjYWxjU3Rha2luZ1BhcmFtcwMFc3Rha2UGYW1vdW50B2Fzc2V0SWQDBQVzdGFrZQQNJHQwMTA1NzAxMDYzNgkBGGNhbGNTdGFraW5nRnVuY0FuZEFkZHJlcwIFBXN0YWtlBQdhc3NldElkBARjYWxsCAUNJHQwMTA1NzAxMDYzNgJfMQQLc3Rha2luZ0FkZHIIBQ0kdDAxMDU3MDEwNjM2Al8yCQCWCgQFBGNhbGwFC3N0YWtpbmdBZGRyBQNuaWwJAMwIAgkBD0F0dGFjaGVkUGF5bWVudAIFB2Fzc2V0SWQFBmFtb3VudAUDbmlsBA0kdDAxMDcyMjEwNzg4CQEYY2FsY1N0YWtpbmdGdW5jQW5kQWRkcmVzAgUFc3Rha2UFB2Fzc2V0SWQEBGNhbGwIBQ0kdDAxMDcyMjEwNzg4Al8xBAtzdGFraW5nQWRkcggFDSR0MDEwNzIyMTA3ODgCXzIJAJYKBAUEY2FsbAULc3Rha2luZ0FkZHIJAMwIAgUGYW1vdW50CQDMCAIJANgEAQUHYXNzZXRJZAUDbmlsBQNuaWwBBXN0YWtlAgZhbW91bnQNYXNzZXRJZFN0cmluZwMJAQ9jb250YWluc0VsZW1lbnQCBQ1zdGFraW5nQXNzZXRzBQ1hc3NldElkU3RyaW5nBA0kdDAxMDk3NTExMDc3CQERY2FsY1N0YWtpbmdQYXJhbXMDBgUGYW1vdW50CQDZBAEFDWFzc2V0SWRTdHJpbmcEBGNhbGwIBQ0kdDAxMDk3NTExMDc3Al8xBARhZGRyCAUNJHQwMTA5NzUxMTA3NwJfMgQGcGFyYW1zCAUNJHQwMTA5NzUxMTA3NwJfMwQIcGF5bWVudHMIBQ0kdDAxMDk3NTExMDc3Al80CQD8BwQFBGFkZHIFBGNhbGwFBnBhcmFtcwUIcGF5bWVudHMAAAEHdW5zdGFrZQIGYW1vdW50DWFzc2V0SWRTdHJpbmcDCQEPY29udGFpbnNFbGVtZW50AgUNc3Rha2luZ0Fzc2V0cwUNYXNzZXRJZFN0cmluZwQNJHQwMTEyNjIxMTM2NQkBEWNhbGNTdGFraW5nUGFyYW1zAwcFBmFtb3VudAkA2QQBBQ1hc3NldElkU3RyaW5nBARjYWxsCAUNJHQwMTEyNjIxMTM2NQJfMQQEYWRkcggFDSR0MDExMjYyMTEzNjUCXzIEBnBhcmFtcwgFDSR0MDExMjYyMTEzNjUCXzMECHBheW1lbnRzCAUNJHQwMTEyNjIxMTM2NQJfNAkA/AcEBQRhZGRyBQRjYWxsBQZwYXJhbXMFCHBheW1lbnRzAAABDHN0YWtlZEFtb3VudAEHYXNzZXRJZAQWc3Rha2VkQW1vdW50Q2FsY3VsYXRlZAQHJG1hdGNoMAUHYXNzZXRJZAMJAAECBQckbWF0Y2gwAgpCeXRlVmVjdG9yBANhSWQFByRtYXRjaDADCQAAAgUDYUlkBQRVU0ROCQCaCAIFEnN0YWtpbmdVU0ROQWRkcmVzcwkArAICCQCsAgIJAKwCAgIMcnBkX2JhbGFuY2VfCQDYBAEFA2FJZAIBXwkApQgBBQR0aGlzAAADCQABAgUHJG1hdGNoMAIEVW5pdAAACQACAQILTWF0Y2ggZXJyb3IEByRtYXRjaDAFFnN0YWtlZEFtb3VudENhbGN1bGF0ZWQDCQABAgUHJG1hdGNoMAIDSW50BAFpBQckbWF0Y2gwBQFpAAABD2NoZWNrU3VzcGljaW91cwAEEGNvbnRyYWN0QmFsYW5jZXMJAQNfeHAACgEMY2hlY2tCYWxhbmNlAgNhY2MHYXNzZXRJZAQNJHQwMTE5NzYxMjAwMQUDYWNjBApzdXNwaWNpb3VzCAUNJHQwMTE5NzYxMjAwMQJfMQQBaQgFDSR0MDExOTc2MTIwMDECXzIDBQpzdXNwaWNpb3VzCQCUCgIFCnN1c3BpY2lvdXMFAWkECGFCYWxhbmNlCQBkAgkA8AcCBQR0aGlzCQDZBAEFB2Fzc2V0SWQJAQxzdGFrZWRBbW91bnQBCQDZBAEFB2Fzc2V0SWQDCQBmAgkAkQMCBRBjb250cmFjdEJhbGFuY2VzBQFpBQhhQmFsYW5jZQkAlAoCBgUBaQkAlAoCBwkAZAIFAWkAAQoAAiRsBQhhc3NldElkcwoAAiRzCQCQAwEFAiRsCgAFJGFjYzAJAJQKAgcAAAoBBSRmMF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEMY2hlY2tCYWxhbmNlAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGYwXzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxMAkBBSRmMF8yAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKARFzdXNwZW5kU3VzcGljaW91cwEBaQkBB3N1c3BlbmQBCQCsAgICHVN1c3BpY2lvdXMgc3RhdGUgd2l0aCBhc3NldDogCQCRAwIFCGFzc2V0SWRzBQFpAQ5yZXR1cm5QYXltZW50cwIGY2FsbGVyCHBheW1lbnRzCgENcGFyc2VQYXltZW50cwIDYWNjB3BheW1lbnQJAM0IAgUDYWNjCQEOU2NyaXB0VHJhbnNmZXIDBQZjYWxsZXIIBQdwYXltZW50BmFtb3VudAgFB3BheW1lbnQHYXNzZXRJZAoAAiRsBQhwYXltZW50cwoAAiRzCQCQAwEFAiRsCgAFJGFjYzAFA25pbAoBBSRmMF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQENcGFyc2VQYXltZW50cwIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQUkZjBfMgIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgESY2hlY2tEQXBwVGhyZXNob2xkAQtuZXdCYWxhbmNlcwQRZEFwcFRocmVzaG9sZENvZWYJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAmggCBQR0aGlzBRJrREFwcFRocmVzaG9sZENvZWYCGE5vIGRBcHBUaHJlc2hvbGRDb2VmIGtleQQOdGhyZXNob2xkU2NhbGUAkE4ECm1heEJhbGFuY2UJAJYDAQULbmV3QmFsYW5jZXMECm1pbkJhbGFuY2UJAJcDAQULbmV3QmFsYW5jZXMEBXJhdGlvCQBrAwUKbWF4QmFsYW5jZQUOdGhyZXNob2xkU2NhbGUFCm1pbkJhbGFuY2UDCQBmAgUFcmF0aW8JAGgCBRFkQXBwVGhyZXNob2xkQ29lZgUOdGhyZXNob2xkU2NhbGUJAAIBAjhOZXcgYmFsYW5jZSBpbiBhc3NldHMgb2YgdGhlIERBcHAgaXMgbGVzcyB0aGFuIHRocmVzaG9sZAcBCmNoZWNrQ29pbnMBCGFzc2V0SWRzBAVjb2lucwkAtQkCBQhhc3NldElkcwIBLAMJAGYCCQCQAwEFBWNvaW5zAAoJAAIBAiBUbyBtYW55IGNvaW5zLCBtYXggY29pbnMgc2l6ZSAxMAoBCWNoZWNrQ29pbgIFZXJyb3IHYXNzZXRJZAQFYXNzZXQJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkA2QQBBQdhc3NldElkCQCsAgICEmZyb21CYXNlNThTdHJpbmc6IAUHYXNzZXRJZAQIZGVjaW1hbHMICQETdmFsdWVPckVycm9yTWVzc2FnZQIJAOwHAQUFYXNzZXQJAKwCAgILYXNzZXRJbmZvOiAFB2Fzc2V0SWQIZGVjaW1hbHMDCQECIT0CBQhkZWNpbWFscwUIREVDSU1BTFMJAAIBAg53cm9uZyBkZWNpbWFscwcKAAIkbAUFY29pbnMKAAIkcwkAkAMBBQIkbAoABSRhY2MwBwoBBSRmMF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEJY2hlY2tDb2luAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGYwXzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxMAkBBSRmMF8yAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKFANtc2cBAUQCAnhwA2FtcAQBRAkBDmdldF9EX2ludGVybmFsAgUCeHAFA2FtcAkAlAoCCQDMCAIJAQxJbnRlZ2VyRW50cnkCAgFEBQFEBQNuaWwFAUQDbXNnAQRpbml0Awhhc3NldElkcwJfQRJfZEFwcFRocmVzaG9sZENvZWYDCQEBIQEJAJ4IAQUEdGhpcwkAAgECE0FscmVhZHkgaW5pdGlhbGl6ZWQDCQBnAgAABQJfQQkAAgECFEFtcCBtdXN0IGJlIG11c3QgPiAwAwkAZwIAAAUSX2RBcHBUaHJlc2hvbGRDb2VmCQACAQIfZEFwcCBUaHJlc2hvbGQgQ29lZiBtdXN0IGJlID4gMAQJc2hhcmVOYW1lAgtzX011bHRpX1VTRAQQc2hhcmVEZXNjcmlwdGlvbgkArAICAkJTaGFyZVRva2VuIG9mIFN3b3BGaSBwcm90b2NvbCBmb3IgTXVsdGlTdGFibGUgVVNEIHBvb2wgYXQgYWRkcmVzcyAJAKUIAQUEdGhpcwQKaXNzdWVUb2tlbgkAwggFBQlzaGFyZU5hbWUFEHNoYXJlRGVzY3JpcHRpb24AAAAGBgQHdG9rZW5JZAkAuAgBBQppc3N1ZVRva2VuAwkBCmNoZWNrQ29pbnMBBQhhc3NldElkcwkBBXRocm93AAkAzAgCCQELU3RyaW5nRW50cnkCBQhrVmVyc2lvbgUHdmVyc2lvbgkAzAgCCQELU3RyaW5nRW50cnkCBQdrQXNzZXRzBQhhc3NldElkcwkAzAgCCQEMSW50ZWdlckVudHJ5AgIJaW5pdGlhbF9BBQJfQQkAzAgCCQEMSW50ZWdlckVudHJ5AgIIZnV0dXJlX0EFAl9BCQDMCAIJAQxJbnRlZ2VyRW50cnkCBQRrRmVlCQERQGV4dHJOYXRpdmUoMTA1MCkCBQZvcmFjbGUCDWJhc2VfZmVlX2ZsYXQJAMwIAgkBC1N0cmluZ0VudHJ5AgUNa1NoYXJlQXNzZXRJZAkA2AQBBQd0b2tlbklkCQDMCAIJAQxJbnRlZ2VyRW50cnkCBRFrU2hhcmVBc3NldFN1cHBseQAACQDMCAIJAQxJbnRlZ2VyRW50cnkCBRJrREFwcFRocmVzaG9sZENvZWYFEl9kQXBwVGhyZXNob2xkQ29lZgkAzAgCCQEMQm9vbGVhbkVudHJ5AgUHa0FjdGl2ZQYJAMwIAgUKaXNzdWVUb2tlbgUDbmlsA21zZwEMYWRkTGlxdWlkaXR5Ag1taW5NaW50QW1vdW50DHN0YWtlRmFybWluZwkBC3ZhbHVlT3JFbHNlAgkBCGlzQWN0aXZlAAQDYW1wCQECX0EABAJ4cAkBA194cAAEAkQwAwkAAAIFC3NoYXJlU3VwcGx5AAAAAAkBB2dldERNZW0CBQJ4cAUDYW1wBAhwYXltZW50cwgFA21zZwhwYXltZW50cwQMcGF5bWVudHNTaXplCQCQAwEFCHBheW1lbnRzCgENdmFsaWRQYXltZW50cwEBbgMJAGYCBQxwYXltZW50c1NpemUFBm5Db2lucwkAAgEJAKwCAgIQcGF5bWVudHMgc2l6ZSA+IAkApAMBBQZuQ29pbnMDCQBmAgABBQxwYXltZW50c1NpemUJAAIBAhFwYXltZW50cyBzaXplIDwgMQMDCQAAAgULc2hhcmVTdXBwbHkAAAkBAiE9AgUGbkNvaW5zBQxwYXltZW50c1NpemUHCQACAQIiaW5pdGlhbCBkZXBvc2l0IHJlcXVpcmVzIGFsbCBjb2lucwoBDHBheW1hbnRWYWxpZAIDYWNjB3BheW1lbnQDCQEPY29udGFpbnNFbGVtZW50AgUIYXNzZXRJZHMJAQ1nZXRTdHJBc3NldElkAQgFB3BheW1lbnQHYXNzZXRJZAYJAAIBAhhJbnZhbGlkIGFzc2V0IGluIHBheW1lbnQKAAIkbAUIcGF5bWVudHMKAAIkcwkAkAMBBQIkbAoABSRhY2MwBwoBBSRmMF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEMcGF5bWFudFZhbGlkAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGYwXzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxMAkBBSRmMF8yAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKAwkBASEBCQENdmFsaWRQYXltZW50cwEFDHBheW1lbnRzU2l6ZQkBBXRocm93AAQKc3VzcGljaW91cwkBD2NoZWNrU3VzcGljaW91cwADCAUKc3VzcGljaW91cwJfMQkAzggCCQERc3VzcGVuZFN1c3BpY2lvdXMBCAUKc3VzcGljaW91cwJfMgkBDnJldHVyblBheW1lbnRzAggFA21zZwZjYWxsZXIFCHBheW1lbnRzCgENcGFyc2VQYXltZW50cwIDYWNjB2Fzc2V0SWQEDSR0MDE2MDkyMTYxMTgFA2FjYwQLbmV3QmFsYW5jZXMIBQ0kdDAxNjA5MjE2MTE4Al8xBAFpCAUNJHQwMTYwOTIxNjExOAJfMgoBDHBhcnNlUGF5bWVudAIKbmV3QmFsYW5jZQdwYXltZW50AwkAAAIJAQ1nZXRTdHJBc3NldElkAQgFB3BheW1lbnQHYXNzZXRJZAUHYXNzZXRJZAkAZAIFCm5ld0JhbGFuY2UIBQdwYXltZW50BmFtb3VudAUKbmV3QmFsYW5jZQQJbmV3QmFsYWNlCgACJGwFCHBheW1lbnRzCgACJHMJAJADAQUCJGwKAAUkYWNjMAkAkQMCBQJ4cAUBaQoBBSRmMF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEMcGFyc2VQYXltZW50AgUCJGEJAJEDAgUCJGwFAiRpCgEFJGYwXzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxMAkBBSRmMF8yAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKCQCUCgIJAM0IAgULbmV3QmFsYW5jZXMFCW5ld0JhbGFjZQkAZAIFAWkAAQQNJHQwMTY0NjgxNjUzNQoAAiRsBQhhc3NldElkcwoAAiRzCQCQAwEFAiRsCgAFJGFjYzAJAJQKAgUDbmlsAAAKAQUkZjBfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBDXBhcnNlUGF5bWVudHMCBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjBfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDEwCQEFJGYwXzICCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoEC25ld0JhbGFuY2VzCAUNJHQwMTY0NjgxNjUzNQJfMQQBawgFDSR0MDE2NDY4MTY1MzUCXzIDCQESY2hlY2tEQXBwVGhyZXNob2xkAQULbmV3QmFsYW5jZXMJAQV0aHJvdwAEAkQxCQEHZ2V0RE1lbQIFC25ld0JhbGFuY2VzBQNhbXADCQEGYXNzZXJ0AQkAZgIFAkQxBQJEMAkAAgECB0QxID4gRDAEC2ZlZURpc2NvdW50CQEUY2FsY3VsYXRlRmVlRGlzY291bnQBCAUDbXNnBmNhbGxlcgoBEWNhbGNTY3JpcHRBY3Rpb25zAgNhY2MKbmV3QmFsYW5jZQQNJHQwMTY4NTUxNjg5NgUDYWNjBAtpbnZCYWxhbmNlcwgFDSR0MDE2ODU1MTY4OTYCXzEEDXNjcmlwdEFjdGlvbnMIBQ0kdDAxNjg1NTE2ODk2Al8yBAFpCAUNJHQwMTY4NTUxNjg5NgJfMwMJAGYCBQtzaGFyZVN1cHBseQAABARfZmVlCQBpAgkAaAIJAG4EBQNmZWUFC2ZlZURpc2NvdW50BQlmZWVTY2FsZTYFB0NFSUxJTkcFBm5Db2lucwkAaAIABAkAZQIFBm5Db2lucwABBARmZWVzBAxpZGVhbEJhbGFuY2UJAGsDBQJEMQkAkQMCBQJ4cAUBaQUCRDAECmRpZmZlcmVuY2UDCQBmAgUMaWRlYWxCYWxhbmNlBQpuZXdCYWxhbmNlCQBlAgUMaWRlYWxCYWxhbmNlBQpuZXdCYWxhbmNlCQBlAgUKbmV3QmFsYW5jZQUMaWRlYWxCYWxhbmNlCQBrAwUEX2ZlZQUKZGlmZmVyZW5jZQUJZmVlU2NhbGU2BA5nb3Zlcm5hbmNlRmVlcwkAawMFBGZlZXMFDWZlZUdvdmVybmFuY2UFCWZlZVNjYWxlNgQMZmluYWxCYWxhbmNlCQBlAgUKbmV3QmFsYW5jZQUEZmVlcwQQaW52YXJpYW50QmFsYW5jZQkAZQIFCm5ld0JhbGFuY2UFBGZlZXMEA3BtdAkAZQIFCm5ld0JhbGFuY2UJAJEDAgUCeHAFAWkEBmxwRmVlcwkAZQIFBGZlZXMFDmdvdmVybmFuY2VGZWVzBANpbnYDCQBmAgUDcG10AAAJAQVzdGFrZQIJAGUCBQNwbXQFBGZlZXMJAJEDAgUIYXNzZXRJZHMFAWkJAQd1bnN0YWtlAgUEZmVlcwkAkQMCBQhhc3NldElkcwUBaQMJAAACBQNpbnYFA2ludgQHYWlyZHJvcAMJAGYCBQZscEZlZXMAAAkA/AcEBRBscEZhcm1pbmdBZGRyZXNzAgdhaXJEcm9wBQNuaWwJAMwIAgkBD0F0dGFjaGVkUGF5bWVudAIJANkEAQkAkQMCBQhhc3NldElkcwUBaQUGbHBGZWVzBQNuaWwAAAMJAAACBQdhaXJkcm9wBQdhaXJkcm9wCQCVCgMJAM0IAgULaW52QmFsYW5jZXMFEGludmFyaWFudEJhbGFuY2UJAM4IAgUNc2NyaXB0QWN0aW9ucwkAzAgCCQEOU2NyaXB0VHJhbnNmZXIDBQ9tb25leUJveEFkZHJlc3MFDmdvdmVybmFuY2VGZWVzCQDZBAEJAJEDAgUIYXNzZXRJZHMFAWkJAMwIAgkBDEludGVnZXJFbnRyeQIJAKwCAgkAkQMCBQhhc3NldElkcwUBaQUNa0Fzc2V0QmFsYW5jZQUMZmluYWxCYWxhbmNlBQNuaWwJAGQCBQFpAAEJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4EA2ludgkBBXN0YWtlAgUKbmV3QmFsYW5jZQkAkQMCBQhhc3NldElkcwUBaQMJAAACBQNpbnYFA2ludgkAlQoDCQDNCAIFC2ludkJhbGFuY2VzBQpuZXdCYWxhbmNlCQDNCAIFDXNjcmlwdEFjdGlvbnMJAQxJbnRlZ2VyRW50cnkCCQCsAgIJAJEDAgUIYXNzZXRJZHMFAWkFDWtBc3NldEJhbGFuY2UFCm5ld0JhbGFuY2UJAGQCBQFpAAEJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4EDSR0MDE4NjAxMTg2ODkKAAIkbAULbmV3QmFsYW5jZXMKAAIkcwkAkAMBBQIkbAoABSRhY2MwCQCVCgMFA25pbAUDbmlsAAAKAQUkZjFfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBEWNhbGNTY3JpcHRBY3Rpb25zAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGYxXzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxMAkBBSRmMV8yAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKBAtpbnZCYWxhbmNlcwgFDSR0MDE4NjAxMTg2ODkCXzEEDXNjcmlwdEFjdGlvbnMIBQ0kdDAxODYwMTE4Njg5Al8yBAJEMgkBB2dldERNZW0CBQtpbnZCYWxhbmNlcwUDYW1wBAttaW50X2Ftb3VudAMJAAACBQtzaGFyZVN1cHBseQAABQJEMQkAawMFC3NoYXJlU3VwcGx5CQBlAgUCRDIFAkQwBQJEMAMJAQZhc3NlcnQBCQBnAgULbWludF9hbW91bnQFDW1pbk1pbnRBbW91bnQJAAIBAhRTbGlwcGFnZSBzY3Jld2VkIHlvdQMFDHN0YWtlRmFybWluZwQCcmUJAPwHBAUEdGhpcwIMcmVpc3N1ZVNoYXJlCQDMCAIFC21pbnRfYW1vdW50BQNuaWwFA25pbAMJAAACBQJyZQUCcmUEAXMJAPwHBAUOZmFybWluZ0FkZHJlc3MCD2xvY2tTaGFyZVRva2VucwkAzAgCCQClCAEFBHRoaXMFA25pbAkAzAgCCQEPQXR0YWNoZWRQYXltZW50AgUMc2hhcmVBc3NldElkBQttaW50X2Ftb3VudAUDbmlsAwkAAAIFAXMFAXMJAM0IAgUNc2NyaXB0QWN0aW9ucwkBDEludGVnZXJFbnRyeQIFEWtTaGFyZUFzc2V0U3VwcGx5CQBkAgULc2hhcmVTdXBwbHkFC21pbnRfYW1vdW50CQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQDOCAIFDXNjcmlwdEFjdGlvbnMJAMwIAgkBB1JlaXNzdWUDBQxzaGFyZUFzc2V0SWQFC21pbnRfYW1vdW50BgkAzAgCCQEOU2NyaXB0VHJhbnNmZXIDCAUDbXNnBmNhbGxlcgULbWludF9hbW91bnQFDHNoYXJlQXNzZXRJZAkAzAgCCQEMSW50ZWdlckVudHJ5AgURa1NoYXJlQXNzZXRTdXBwbHkJAGQCBQtzaGFyZVN1cHBseQULbWludF9hbW91bnQFA25pbANtc2cBDmNhbGNNaW50QW1vdW50AgtuZXdCYWxhbmNlcwR1c2VyBANhbXAJAQJfQQAEAnhwCQEDX3hwAAQCRDEJAQdnZXRETWVtAgULbmV3QmFsYW5jZXMFA2FtcAMJAAACBQtzaGFyZVN1cHBseQAACQCUCgIFA25pbAUCRDEEAkQwCQEHZ2V0RE1lbQIFAnhwBQNhbXAEC2ZlZURpc2NvdW50CQEUY2FsY3VsYXRlRmVlRGlzY291bnQBBQR1c2VyCgEPY2FsY0ludkJhbGFuY2VzAgNhY2MKbmV3QmFsYW5jZQQNJHQwMTk4NzgxOTkwNAUDYWNjBAtpbnZCYWxhbmNlcwgFDSR0MDE5ODc4MTk5MDQCXzEEAWkIBQ0kdDAxOTg3ODE5OTA0Al8yBARfZmVlCQBpAgkAaAIJAG4EBQNmZWUFC2ZlZURpc2NvdW50BQlmZWVTY2FsZTYFB0NFSUxJTkcFBm5Db2lucwkAaAIABAkAZQIFBm5Db2lucwABBARmZWVzBAxpZGVhbEJhbGFuY2UJAGsDBQJEMQkAkQMCBQJ4cAUBaQUCRDAECmRpZmZlcmVuY2UDCQBmAgUMaWRlYWxCYWxhbmNlBQpuZXdCYWxhbmNlCQBlAgUMaWRlYWxCYWxhbmNlBQpuZXdCYWxhbmNlCQBlAgUKbmV3QmFsYW5jZQUMaWRlYWxCYWxhbmNlCQBrAwUEX2ZlZQUKZGlmZmVyZW5jZQUJZmVlU2NhbGU2BBBpbnZhcmlhbnRCYWxhbmNlCQBlAgUKbmV3QmFsYW5jZQUEZmVlcwkAlAoCCQDNCAIFC2ludkJhbGFuY2VzBRBpbnZhcmlhbnRCYWxhbmNlCQBkAgUBaQABBA0kdDAyMDUwNjIwNTc2CgACJGwFC25ld0JhbGFuY2VzCgACJHMJAJADAQUCJGwKAAUkYWNjMAkAlAoCBQNuaWwAAAoBBSRmMF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEPY2FsY0ludkJhbGFuY2VzAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGYwXzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxMAkBBSRmMF8yAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKBAtpbnZCYWxhbmNlcwgFDSR0MDIwNTA2MjA1NzYCXzEEAWsIBQ0kdDAyMDUwNjIwNTc2Al8yBAJEMgkBB2dldERNZW0CBQtpbnZCYWxhbmNlcwUDYW1wBAptaW50QW1vdW50CQBrAwULc2hhcmVTdXBwbHkJAGUCBQJEMgUCRDAFAkQwCQCUCgIFA25pbAUKbWludEFtb3VudANtc2cBDHJlaXNzdWVTaGFyZQEGYW1vdW50CQELdmFsdWVPckVsc2UCCQEKaXNTZWxmQ2FsbAEFA21zZwkAzAgCCQEHUmVpc3N1ZQMFDHNoYXJlQXNzZXRJZAUGYW1vdW50BgUDbmlsA21zZwEFZ2V0RHkECWFzc2V0RnJvbQdhc3NldFRvAmR4C3VzZXJBZGRyZXNzBAJ4cAkBA194cAAECWZyb21JbmRleAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQDPCAIFCGFzc2V0SWRzBQlhc3NldEZyb20CEHVua25vd24gdG9rZW4gaW4EB3RvSW5kZXgJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAzwgCBQhhc3NldElkcwUHYXNzZXRUbwIRdW5rbm93biB0b2tlbiBvdXQEAXgJAGQCCQCRAwIFAnhwBQlmcm9tSW5kZXgFAmR4BAF5CQEEZ2V0WQQFCWZyb21JbmRleAUHdG9JbmRleAUBeAUCeHAEAmR5CQBlAgkAZQIJAJEDAgUCeHAFB3RvSW5kZXgFAXkAAQQLZmVlRGlzY291bnQJARRjYWxjdWxhdGVGZWVEaXNjb3VudAEJAQdBZGRyZXNzAQkA2QQBBQt1c2VyQWRkcmVzcwQEX2ZlZQkAawMJAG4EBQNmZWUFC2ZlZURpc2NvdW50BQlmZWVTY2FsZTYFB0NFSUxJTkcFAmR5BQlmZWVTY2FsZTYJAJQKAgUDbmlsCQCUCgIJAGUCBQJkeQUEX2ZlZQUEX2ZlZQNtc2cBCGV4Y2hhbmdlAgh0b2tlbk91dAZtaW5fZHkJAQt2YWx1ZU9yRWxzZQIJAQhpc0FjdGl2ZQADCQECIT0CCQCQAwEIBQNtc2cIcGF5bWVudHMAAQkAAgECE3NpemUocGF5bWVudHMpICE9IDEECnN1c3BpY2lvdXMJAQ9jaGVja1N1c3BpY2lvdXMAAwgFCnN1c3BpY2lvdXMCXzEJAM4IAgkBEXN1c3BlbmRTdXNwaWNpb3VzAQgFCnN1c3BpY2lvdXMCXzIJAQ5yZXR1cm5QYXltZW50cwIIBQNtc2cGY2FsbGVyCAUDbXNnCHBheW1lbnRzBAdwYXltZW50CQCRAwIIBQNtc2cIcGF5bWVudHMAAAQHdG9rZW5JbgkBDWdldFN0ckFzc2V0SWQBCAUHcGF5bWVudAdhc3NldElkBAt0b2tlbk91dEI1OAkA2QQBBQh0b2tlbk91dAQCZHgIBQdwYXltZW50BmFtb3VudAQJZnJvbUluZGV4CQETdmFsdWVPckVycm9yTWVzc2FnZQIJAM8IAgUIYXNzZXRJZHMFB3Rva2VuSW4CEHVua25vd24gdG9rZW4gaW4EB3RvSW5kZXgJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAzwgCBQhhc3NldElkcwUIdG9rZW5PdXQCEXVua25vd24gdG9rZW4gb3V0BAJ4cAkBA194cAAEAXgJAGQCCQCRAwIFAnhwBQlmcm9tSW5kZXgFAmR4BAF5CQEEZ2V0WQQFCWZyb21JbmRleAUHdG9JbmRleAUBeAUCeHAEA19keQkAZQIJAGUCCQCRAwIFAnhwBQd0b0luZGV4BQF5AAEEC2ZlZURpc2NvdW50CQEUY2FsY3VsYXRlRmVlRGlzY291bnQBCAUDbXNnDG9yaWdpbkNhbGxlcgQEX2ZlZQkAawMFA19keQkAbgQFA2ZlZQULZmVlRGlzY291bnQFCWZlZVNjYWxlNgUHQ0VJTElORwUJZmVlU2NhbGU2BAJkeQkAZQIFA19keQUEX2ZlZQQOZ292ZXJuYW5jZUZlZXMJAGsDBQRfZmVlBQ1mZWVHb3Zlcm5hbmNlBQlmZWVTY2FsZTYDCQEGYXNzZXJ0AQkAZwIFAmR5BQZtaW5fZHkJAAIBAi5FeGNoYW5nZSByZXN1bHRlZCBpbiBmZXdlciBjb2lucyB0aGFuIGV4cGVjdGVkCgEPbWFrZU5ld0JhbGFuY2VzAgNhY2MMdG9rZW5CYWxhbmNlBA0kdDAyMjYxNzIyNjQzBQNhY2MEC25ld0JhbGFuY2VzCAUNJHQwMjI2MTcyMjY0MwJfMQQBaQgFDSR0MDIyNjE3MjI2NDMCXzIDCQAAAgUBaQUJZnJvbUluZGV4CQCUCgIJAM0IAgULbmV3QmFsYW5jZXMJAGQCBQx0b2tlbkJhbGFuY2UFAmR4CQBkAgUBaQABAwkAAAIFAWkFB3RvSW5kZXgJAJQKAgkAzQgCBQtuZXdCYWxhbmNlcwkAZQIFDHRva2VuQmFsYW5jZQUDX2R5CQBkAgUBaQABCQCUCgIJAM0IAgULbmV3QmFsYW5jZXMFDHRva2VuQmFsYW5jZQkAZAIFAWkAAQQNJHQwMjI4OTQyMjk1NQoAAiRsBQJ4cAoAAiRzCQCQAwEFAiRsCgAFJGFjYzAJAJQKAgUDbmlsAAAKAQUkZjBfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBD21ha2VOZXdCYWxhbmNlcwIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQUkZjBfMgIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgQLbmV3QmFsYW5jZXMIBQ0kdDAyMjg5NDIyOTU1Al8xBAFpCAUNJHQwMjI4OTQyMjk1NQJfMgMJARJjaGVja0RBcHBUaHJlc2hvbGQBBQtuZXdCYWxhbmNlcwkBBXRocm93AAQBcwkBBXN0YWtlAggFB3BheW1lbnQGYW1vdW50CQENZ2V0U3RyQXNzZXRJZAEIBQdwYXltZW50B2Fzc2V0SWQDCQAAAgUBcwUBcwQCdXMJAQd1bnN0YWtlAgUDX2R5BQh0b2tlbk91dAMJAAACBQJ1cwUCdXMEBmxwRmVlcwkAZQIFBF9mZWUFDmdvdmVybmFuY2VGZWVzBAdhaXJkcm9wAwkAZgIFBmxwRmVlcwAACQD8BwQFEGxwRmFybWluZ0FkZHJlc3MCB2FpckRyb3AFA25pbAkAzAgCCQEPQXR0YWNoZWRQYXltZW50AgULdG9rZW5PdXRCNTgFBmxwRmVlcwUDbmlsAAADCQAAAgUHYWlyZHJvcAUHYWlyZHJvcAkAlAoCCQDMCAIJAQxJbnRlZ2VyRW50cnkCCQCsAgIFB3Rva2VuSW4FDWtBc3NldEJhbGFuY2UFAXgJAMwIAgkBDEludGVnZXJFbnRyeQIJAKwCAgUIdG9rZW5PdXQFDWtBc3NldEJhbGFuY2UJAGUCCQCRAwIFAnhwBQd0b0luZGV4BQNfZHkJAMwIAgkBDlNjcmlwdFRyYW5zZmVyAwgFA21zZwZjYWxsZXIFAmR5BQt0b2tlbk91dEI1OAkAzAgCCQEOU2NyaXB0VHJhbnNmZXIDBQ9tb25leUJveEFkZHJlc3MFDmdvdmVybmFuY2VGZWVzBQt0b2tlbk91dEI1OAUDbmlsCQDMCAIFAmR5CQDMCAIFC3Rva2VuT3V0QjU4BQNuaWwJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4DbXNnAQh3aXRoZHJhdwEKbWluQW1vdW50cwkBC3ZhbHVlT3JFbHNlAgkBCGlzQWN0aXZlAAMJAQIhPQIJAJADAQgFA21zZwhwYXltZW50cwABCQACAQITc2l6ZShwYXltZW50cykgIT0gMQQJcG10QW1vdW50CAkAkQMCCAUDbXNnCHBheW1lbnRzAAAGYW1vdW50BApwbXRBc3NldElkCAkAkQMCCAUDbXNnCHBheW1lbnRzAAAHYXNzZXRJZAMJAQIhPQIFDHNoYXJlQXNzZXRJZAUKcG10QXNzZXRJZAkAAgECFXVua25vd24gcGF5bWVudCB0b2tlbgQKc3VzcGljaW91cwkBD2NoZWNrU3VzcGljaW91cwADCAUKc3VzcGljaW91cwJfMQkAzggCCQERc3VzcGVuZFN1c3BpY2lvdXMBCAUKc3VzcGljaW91cwJfMgkBDnJldHVyblBheW1lbnRzAggFA21zZwxvcmlnaW5DYWxsZXIIBQNtc2cIcGF5bWVudHMKARFjYWxjU2NyaXB0QWN0aW9ucwIDYWNjB2JhbGFuY2UEDSR0MDI0MjQ2MjQyNzQFA2FjYwQNc2NyaXB0QWN0aW9ucwgFDSR0MDI0MjQ2MjQyNzQCXzEEAWkIBQ0kdDAyNDI0NjI0Mjc0Al8yBAd3QW1vdW50CQBrAwUHYmFsYW5jZQUJcG10QW1vdW50BQtzaGFyZVN1cHBseQMJAQZhc3NlcnQBCQBnAgUHd0Ftb3VudAkAkQMCBQptaW5BbW91bnRzBQFpCQACAQIwV2l0aGRyYXdhbCByZXN1bHRlZCBpbiBmZXdlciBjb2lucyB0aGFuIGV4cGVjdGVkBAJ1cwkBB3Vuc3Rha2UCBQd3QW1vdW50CQCRAwIFCGFzc2V0SWRzBQFpAwkAAAIFAnVzBQJ1cwkAlAoCCQDOCAIFDXNjcmlwdEFjdGlvbnMJAMwIAgkBDEludGVnZXJFbnRyeQIJAKwCAgkAkQMCBQhhc3NldElkcwUBaQUNa0Fzc2V0QmFsYW5jZQkAZQIFB2JhbGFuY2UFB3dBbW91bnQJAMwIAgkBDlNjcmlwdFRyYW5zZmVyAwgFA21zZwxvcmlnaW5DYWxsZXIFB3dBbW91bnQJANkEAQkAkQMCBQhhc3NldElkcwUBaQUDbmlsCQBkAgUBaQABCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuBA0kdDAyNDc2NDI0ODMyCgACJGwJAQNfeHAACgACJHMJAJADAQUCJGwKAAUkYWNjMAkAlAoCBQNuaWwAAAoBBSRmMF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQERY2FsY1NjcmlwdEFjdGlvbnMCBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjBfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDEwCQEFJGYwXzICCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoEDXNjcmlwdEFjdGlvbnMIBQ0kdDAyNDc2NDI0ODMyAl8xBAFpCAUNJHQwMjQ3NjQyNDgzMgJfMgkAzggCBQ1zY3JpcHRBY3Rpb25zCQDMCAIJAQRCdXJuAgUMc2hhcmVBc3NldElkBQlwbXRBbW91bnQJAMwIAgkBDEludGVnZXJFbnRyeQIFEWtTaGFyZUFzc2V0U3VwcGx5CQBlAgULc2hhcmVTdXBwbHkFCXBtdEFtb3VudAUDbmlsA21zZwESd2l0aGRyYXdXaXRoVW5sb2NrAgptaW5BbW91bnRzDHVubG9ja0Ftb3VudAkBC3ZhbHVlT3JFbHNlAgkBCGlzQWN0aXZlAAMJAGcCAAAFDHVubG9ja0Ftb3VudAkAAgECHlVubG9jayBhbW91bnQgbXVzdCBiZSBwb3NpdGl2ZQQKc3VzcGljaW91cwkBD2NoZWNrU3VzcGljaW91cwADCAUKc3VzcGljaW91cwJfMQkAzggCCQERc3VzcGVuZFN1c3BpY2lvdXMBCAUKc3VzcGljaW91cwJfMgkBDnJldHVyblBheW1lbnRzAggFA21zZwZjYWxsZXIIBQNtc2cIcGF5bWVudHMECXBtdEFtb3VudAMJAGYCCQCQAwEIBQNtc2cIcGF5bWVudHMAAAMJAQIhPQIJAJADAQgFA21zZwhwYXltZW50cwABCQACAQITc2l6ZShwYXltZW50cykgIT0gMQQKcG10QXNzZXRJZAgJAJEDAggFA21zZwhwYXltZW50cwAAB2Fzc2V0SWQDCQECIT0CBQxzaGFyZUFzc2V0SWQFCnBtdEFzc2V0SWQJAAIBAhV1bmtub3duIHBheW1lbnQgdG9rZW4ICQCRAwIIBQNtc2cIcGF5bWVudHMAAAZhbW91bnQAAAQGdW5sb2NrCQD8BwQFDmZhcm1pbmdBZGRyZXNzAhN3aXRoZHJhd1NoYXJlVG9rZW5zCQDMCAIJAKUIAQUEdGhpcwkAzAgCBQx1bmxvY2tBbW91bnQFA25pbAUDbmlsAwkAAAIFBnVubG9jawUGdW5sb2NrBA53aXRoZHJhd0Ftb3VudAkAZAIFCXBtdEFtb3VudAUMdW5sb2NrQW1vdW50BANpbnYJAPwHBAUEdGhpcwIId2l0aGRyYXcJAMwIAgUKbWluQW1vdW50cwUDbmlsCQDMCAIJAQ9BdHRhY2hlZFBheW1lbnQCBQxzaGFyZUFzc2V0SWQFDndpdGhkcmF3QW1vdW50BQNuaWwDCQAAAgUDaW52BQNpbnYFA25pbAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgNtc2cBE2NhbGNXaXRoZHJhd09uZUNvaW4DC3Rva2VuQW1vdW50CHRva2VuT3V0BHVzZXIDCQBnAgAABQt0b2tlbkFtb3VudAkAAgECF0Ftb3VudCBtdXN0IGJlIHBvc2l0aXZlBAFpCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAM8IAgUIYXNzZXRJZHMFCHRva2VuT3V0AhF1bmtub3duIHRva2VuIG91dAkAlAoCBQNuaWwICQEUX2NhbGNXaXRoZHJhd09uZUNvaW4ECQEDX3hwAAULdG9rZW5BbW91bnQFAWkJAQdBZGRyZXNzAQkA2QQBBQR1c2VyAl8xA21zZwEPd2l0aGRyYXdPbmVDb2luAgh0b2tlbk91dAltaW5BbW91bnQJAQt2YWx1ZU9yRWxzZQIJAQhpc0FjdGl2ZQADCQECIT0CCQCQAwEIBQNtc2cIcGF5bWVudHMAAQkAAgECE3NpemUocGF5bWVudHMpICE9IDEECnN1c3BpY2lvdXMJAQ9jaGVja1N1c3BpY2lvdXMAAwgFCnN1c3BpY2lvdXMCXzEJAM4IAgkBEXN1c3BlbmRTdXNwaWNpb3VzAQgFCnN1c3BpY2lvdXMCXzIJAQ5yZXR1cm5QYXltZW50cwIIBQNtc2cMb3JpZ2luQ2FsbGVyCAUDbXNnCHBheW1lbnRzBAlwbXRBbW91bnQICQCRAwIIBQNtc2cIcGF5bWVudHMAAAZhbW91bnQECnBtdEFzc2V0SWQICQCRAwIIBQNtc2cIcGF5bWVudHMAAAdhc3NldElkAwkBAiE9AgUKcG10QXNzZXRJZAUMc2hhcmVBc3NldElkCQACAQINdW5rbm93biB0b2tlbgQIb3V0SW5kZXgJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAzwgCBQhhc3NldElkcwUIdG9rZW5PdXQCEXVua25vd24gdG9rZW4gb3V0BAt0b2tlbk91dEI1OAkA2QQBBQh0b2tlbk91dAQCeHAJAQNfeHAABA0kdDAyNjg2NDI2OTQ2CQEUX2NhbGNXaXRoZHJhd09uZUNvaW4EBQJ4cAUJcG10QW1vdW50BQhvdXRJbmRleAgFA21zZwxvcmlnaW5DYWxsZXIEAmR5CAUNJHQwMjY4NjQyNjk0NgJfMQQGZHlfZmVlCAUNJHQwMjY4NjQyNjk0NgJfMgMJAQZhc3NlcnQBCQBnAgUCZHkFCW1pbkFtb3VudAkAAgECGE5vdCBlbm91Z2ggY29pbnMgcmVtb3ZlZAQOZ292ZXJuYW5jZUZlZXMJAGsDBQZkeV9mZWUFDWZlZUdvdmVybmFuY2UFCWZlZVNjYWxlNgQKZHlfYW5kX2ZlZQkAZAIFAmR5BQZkeV9mZWUKAQ9tYWtlTmV3QmFsYW5jZXMCA2FjYwx0b2tlbkJhbGFuY2UEDSR0MDI3MjA0MjcyMzAFA2FjYwQLbmV3QmFsYW5jZXMIBQ0kdDAyNzIwNDI3MjMwAl8xBAFpCAUNJHQwMjcyMDQyNzIzMAJfMgMJAAACBQFpBQhvdXRJbmRleAkAlAoCCQDNCAIFC25ld0JhbGFuY2VzCQBlAgUMdG9rZW5CYWxhbmNlBQpkeV9hbmRfZmVlCQBkAgUBaQABCQCUCgIJAM0IAgULbmV3QmFsYW5jZXMFDHRva2VuQmFsYW5jZQkAZAIFAWkAAQQNJHQwMjczOTcyNzQ1OAoAAiRsBQJ4cAoAAiRzCQCQAwEFAiRsCgAFJGFjYzAJAJQKAgUDbmlsAAAKAQUkZjBfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBD21ha2VOZXdCYWxhbmNlcwIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQUkZjBfMgIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgQLbmV3QmFsYW5jZXMIBQ0kdDAyNzM5NzI3NDU4Al8xBAF2CAUNJHQwMjczOTcyNzQ1OAJfMgMJARJjaGVja0RBcHBUaHJlc2hvbGQBBQtuZXdCYWxhbmNlcwkBBXRocm93AAQCdXMJAQd1bnN0YWtlAgUKZHlfYW5kX2ZlZQUIdG9rZW5PdXQDCQAAAgUCdXMFAnVzBAZscEZlZXMJAGUCBQZkeV9mZWUFDmdvdmVybmFuY2VGZWVzBAdhaXJkcm9wAwkAZgIFBmxwRmVlcwAACQD8BwQFEGxwRmFybWluZ0FkZHJlc3MCB2FpckRyb3AFA25pbAkAzAgCCQEPQXR0YWNoZWRQYXltZW50AgULdG9rZW5PdXRCNTgFBmxwRmVlcwUDbmlsAAADCQAAAgUHYWlyZHJvcAUHYWlyZHJvcAkAzAgCCQEOU2NyaXB0VHJhbnNmZXIDCAUDbXNnDG9yaWdpbkNhbGxlcgUCZHkFC3Rva2VuT3V0QjU4CQDMCAIJAQxJbnRlZ2VyRW50cnkCCQCsAgIJAJEDAgUIYXNzZXRJZHMFCG91dEluZGV4BQ1rQXNzZXRCYWxhbmNlCQBlAgkAkQMCBQJ4cAUIb3V0SW5kZXgFCmR5X2FuZF9mZWUJAMwIAgkBBEJ1cm4CBQxzaGFyZUFzc2V0SWQFCXBtdEFtb3VudAkAzAgCCQEOU2NyaXB0VHJhbnNmZXIDBQ9tb25leUJveEFkZHJlc3MFDmdvdmVybmFuY2VGZWVzBQt0b2tlbk91dEI1OAkAzAgCCQEMSW50ZWdlckVudHJ5AgURa1NoYXJlQXNzZXRTdXBwbHkJAGUCBQtzaGFyZVN1cHBseQUJcG10QW1vdW50BQNuaWwJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4DbXNnARl3aXRoZHJhd09uZUNvaW5XaXRoVW5sb2NrAwh0b2tlbk91dAltaW5BbW91bnQMdW5sb2NrQW1vdW50CQELdmFsdWVPckVsc2UCCQEIaXNBY3RpdmUAAwkAZwIAAAUMdW5sb2NrQW1vdW50CQACAQIeVW5sb2NrIGFtb3VudCBtdXN0IGJlIHBvc2l0aXZlBApzdXNwaWNpb3VzCQEPY2hlY2tTdXNwaWNpb3VzAAMIBQpzdXNwaWNpb3VzAl8xCQDOCAIJARFzdXNwZW5kU3VzcGljaW91cwEIBQpzdXNwaWNpb3VzAl8yCQEOcmV0dXJuUGF5bWVudHMCCAUDbXNnBmNhbGxlcggFA21zZwhwYXltZW50cwQJcG10QW1vdW50AwkAZgIJAJADAQgFA21zZwhwYXltZW50cwAAAwkBAiE9AgkAkAMBCAUDbXNnCHBheW1lbnRzAAEJAAIBAhNzaXplKHBheW1lbnRzKSAhPSAxBApwbXRBc3NldElkCAkAkQMCCAUDbXNnCHBheW1lbnRzAAAHYXNzZXRJZAMJAQIhPQIFDHNoYXJlQXNzZXRJZAUKcG10QXNzZXRJZAkAAgECFXVua25vd24gcGF5bWVudCB0b2tlbggJAJEDAggFA21zZwhwYXltZW50cwAABmFtb3VudAAABAZ1bmxvY2sJAPwHBAUOZmFybWluZ0FkZHJlc3MCE3dpdGhkcmF3U2hhcmVUb2tlbnMJAMwIAgkApQgBBQR0aGlzCQDMCAIFDHVubG9ja0Ftb3VudAUDbmlsBQNuaWwDCQAAAgUGdW5sb2NrBQZ1bmxvY2sEDndpdGhkcmF3QW1vdW50CQBkAgUJcG10QW1vdW50BQx1bmxvY2tBbW91bnQEA2ludgkA/AcEBQR0aGlzAg93aXRoZHJhd09uZUNvaW4JAMwIAgUIdG9rZW5PdXQJAMwIAgUJbWluQW1vdW50BQNuaWwJAMwIAgkBD0F0dGFjaGVkUGF5bWVudAIFDHNoYXJlQXNzZXRJZAUOd2l0aGRyYXdBbW91bnQFA25pbAMJAAACBQNpbnYFA2ludgUDbmlsCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuA21zZwEBQQAJAJQKAgUDbmlsCQECX0EAA21zZwEPZ2V0VmlydHVhbFByaWNlAAQBRAkBBWdldF9EAgkBA194cAAJAQJfQQAJAJQKAgUDbmlsCQBrAwUBRAUJUFJFQ0lTSU9OBQtzaGFyZVN1cHBseQNtc2cBD2NhbGNUb2tlbkFtb3VudAIHYW1vdW50cwdkZXBvc2l0BANhbXAJAQJfQQAECGJhbGFuY2VzCQEDX3hwAAQCRDAJAQdnZXRETWVtAgUIYmFsYW5jZXMFA2FtcAoBD2NhbGNOZXdCYWxhbmNlcwIDYWNjB2JhbGFuY2UEDSR0MDI5NDc1Mjk1MDEFA2FjYwQLbmV3QmFsYW5jZXMIBQ0kdDAyOTQ3NTI5NTAxAl8xBAFpCAUNJHQwMjk0NzUyOTUwMQJfMgQKbmV3QmFsYW5jZQkAZAIFB2JhbGFuY2UDBQdkZXBvc2l0CQCRAwIFB2Ftb3VudHMFAWkJAQEtAQkAkQMCBQdhbW91bnRzBQFpCQCUCgIJAM0IAgULbmV3QmFsYW5jZXMFCm5ld0JhbGFuY2UJAGQCBQFpAAEEC25ld0JhbGFuY2VzCAoAAiRsBQhiYWxhbmNlcwoAAiRzCQCQAwEFAiRsCgAFJGFjYzAJAJQKAgUDbmlsAAAKAQUkZjBfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBD2NhbGNOZXdCYWxhbmNlcwIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQUkZjBfMgIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgJfMQQCRDEJAQdnZXRETWVtAgULbmV3QmFsYW5jZXMFA2FtcAQEZGlmZgMFB2RlcG9zaXQJAGUCBQJEMQUCRDAJAGUCBQJEMAUCRDEJAJQKAgUDbmlsCQBrAwUEZGlmZgULc2hhcmVTdXBwbHkFAkQwA21zZwEFcmFtcEECCF9mdXR1cmVBC19mdXR1cmVUaW1lCQELdmFsdWVPckVsc2UCCQEIaXNBY3RpdmUACQELdmFsdWVPckVsc2UCCQELaXNBZG1pbkNhbGwBBQNtc2cDCQEGYXNzZXJ0AQkAZwIFDmJsb2NrVGltZXN0YW1wCQBkAgUOaW5pdGlhbF9BX3RpbWUFDU1JTl9SQU1QX1RJTUUJAAIBAgl0b28gb2Z0ZW4DCQEGYXNzZXJ0AQkAZwIFC19mdXR1cmVUaW1lCQBkAgUOYmxvY2tUaW1lc3RhbXAFDU1JTl9SQU1QX1RJTUUJAAIBAhFpbnN1ZmZpY2llbnQgdGltZQQKX2luaXRpYWxfQQkBAl9BAAMJAQZhc3NlcnQBAwkAZgIFCF9mdXR1cmVBAAAJAGYCBQVNQVhfQQUIX2Z1dHVyZUEHCQACAQIRb3V0IG9mIGJhc2UgcmFuZ2UDCQEGYXNzZXJ0AQMDCQBnAgUIX2Z1dHVyZUEFCl9pbml0aWFsX0EJAGcCCQBoAgUKX2luaXRpYWxfQQUMTUFYX0FfQ0hBTkdFBQhfZnV0dXJlQQcGAwkAZgIFCl9pbml0aWFsX0EFCF9mdXR1cmVBCQBnAgkAaAIFCF9mdXR1cmVBBQxNQVhfQV9DSEFOR0UFCl9pbml0aWFsX0EHCQACAQIMb3V0IG9mIHJhbmdlCQDMCAIJAQxJbnRlZ2VyRW50cnkCAglpbml0aWFsX0EFCl9pbml0aWFsX0EJAMwIAgkBDEludGVnZXJFbnRyeQICCGZ1dHVyZV9BBQhfZnV0dXJlQQkAzAgCCQEMSW50ZWdlckVudHJ5AgIOaW5pdGlhbF9BX3RpbWUFDmJsb2NrVGltZXN0YW1wCQDMCAIJAQxJbnRlZ2VyRW50cnkCAg1mdXR1cmVfQV90aW1lBQtfZnV0dXJlVGltZQUDbmlsA21zZwEJc3RvcFJhbXBBAAkBC3ZhbHVlT3JFbHNlAgkBCGlzQWN0aXZlAAkBC3ZhbHVlT3JFbHNlAgkBC2lzQWRtaW5DYWxsAQUDbXNnBAhjdXJyZW50QQkBAl9BAAkAzAgCCQEMSW50ZWdlckVudHJ5AgIJaW5pdGlhbF9BBQhjdXJyZW50QQkAzAgCCQEMSW50ZWdlckVudHJ5AgIIZnV0dXJlX0EFCGN1cnJlbnRBCQDMCAIJAQxJbnRlZ2VyRW50cnkCAg5pbml0aWFsX0FfdGltZQUOYmxvY2tUaW1lc3RhbXAJAMwIAgkBDEludGVnZXJFbnRyeQICDWZ1dHVyZV9BX3RpbWUFDmJsb2NrVGltZXN0YW1wBQNuaWwDbXNnAQhzaHV0ZG93bgAJAQt2YWx1ZU9yRWxzZQIJAQtpc0FkbWluQ2FsbAEFA21zZwMJAQEhAQUGYWN0aXZlCQACAQkArAICAiJEQXBwIGlzIGFscmVhZHkgc3VzcGVuZGVkLiBDYXVzZTogCQELdmFsdWVPckVsc2UCCQCdCAIFBHRoaXMFBmtDYXVzZQIadGhlIGNhdXNlIHdhc24ndCBzcGVjaWZpZWQJAQdzdXNwZW5kAQIPUGF1c2VkIGJ5IGFkbWluA21zZwEIYWN0aXZhdGUACQELdmFsdWVPckVsc2UCCQELaXNBZG1pbkNhbGwBBQNtc2cDBQZhY3RpdmUJAQ10aHJvd0lzQWN0aXZlAAkAzAgCCQEMQm9vbGVhbkVudHJ5AgUHa0FjdGl2ZQYJAMwIAgkBC0RlbGV0ZUVudHJ5AQUGa0NhdXNlBQNuaWwDbXNnARl0YWtlSW50b0FjY291bnRFeHRyYUZ1bmRzAAkBC3ZhbHVlT3JFbHNlAgkBCGlzQWN0aXZlAAMJAQIhPQIIBQNtc2cGY2FsbGVyBQ9tb25leUJveEFkZHJlc3MJAAIBAiZPbmx5IHRoZSB3YWxsZXQgY2FuIGNhbGwgdGhpcyBmdW5jdGlvbgQIYmFsYW5jZXMJAQNfeHAACgEOdGFrZUV4dHJhRnVuZHMCA2FjYwdhc3NldElkBA0kdDAzMTg0MzMxODYxBQNhY2MEA3N1bQgFDSR0MDMxODQzMzE4NjECXzEEAWkIBQ0kdDAzMTg0MzMxODYxAl8yBAh0b2tlbkI1OAkA2QQBBQdhc3NldElkBAhyQmFsYW5jZQkAZAIJAPAHAgUEdGhpcwUIdG9rZW5CNTgJAQxzdGFrZWRBbW91bnQBBQh0b2tlbkI1OAQMZW5yb2xsQW1vdW50CQBlAgUIckJhbGFuY2UJAJEDAgUIYmFsYW5jZXMFAWkDCQBmAgAABQxlbnJvbGxBbW91bnQJAQdzdXNwZW5kAQkArAICAiBFbnJvbGwgYW1vdW50IG5lZ2F0aXZlIGZvciBhc3NldAUHYXNzZXRJZAQHYWlyZHJvcAMJAGYCBQxlbnJvbGxBbW91bnQAAAkA/AcEBRBscEZhcm1pbmdBZGRyZXNzAgdhaXJEcm9wBQNuaWwJAMwIAgkBD0F0dGFjaGVkUGF5bWVudAIFCHRva2VuQjU4BQxlbnJvbGxBbW91bnQFA25pbAAAAwkAAAIFB2FpcmRyb3AFB2FpcmRyb3AJAJQKAgkAZAIFA3N1bQUMZW5yb2xsQW1vdW50CQBkAgUBaQABCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuBAFrCgACJGwFCGFzc2V0SWRzCgACJHMJAJADAQUCJGwKAAUkYWNjMAkAlAoCAAAAAAoBBSRmMF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEOdGFrZUV4dHJhRnVuZHMCBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjBfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDEwCQEFJGYwXzICCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoDCQAAAggFAWsCXzEAAAkAAgECEE5vIG1vbmV5IHRvIHRha2UFA25pbAECdHgBBnZlcmlmeQAEE211bHRpU2lnbmVkQnlBZG1pbnMEEmFkbWluUHViS2V5MVNpZ25lZAMJAPQDAwgFAnR4CWJvZHlCeXRlcwkAkQMCCAUCdHgGcHJvb2ZzAAAFDGFkbWluUHViS2V5MQABAAAEEmFkbWluUHViS2V5MlNpZ25lZAMJAPQDAwgFAnR4CWJvZHlCeXRlcwkAkQMCCAUCdHgGcHJvb2ZzAAEFDGFkbWluUHViS2V5MgABAAAEEmFkbWluUHViS2V5M1NpZ25lZAMJAPQDAwgFAnR4CWJvZHlCeXRlcwkAkQMCCAUCdHgGcHJvb2ZzAAIFDGFkbWluUHViS2V5MwABAAAJAGcCCQBkAgkAZAIFEmFkbWluUHViS2V5MVNpZ25lZAUSYWRtaW5QdWJLZXkyU2lnbmVkBRJhZG1pblB1YktleTNTaWduZWQAAgQHJG1hdGNoMAUCdHgDCQABAgUHJG1hdGNoMAIXSW52b2tlU2NyaXB0VHJhbnNhY3Rpb24EA2ludgUHJG1hdGNoMAQTY2FsbFRha2VJbnRvQWNjb3VudAMJAAACCAUDaW52BGRBcHAFBHRoaXMJAAACCAUDaW52CGZ1bmN0aW9uAhl0YWtlSW50b0FjY291bnRFeHRyYUZ1bmRzBwQNc2lnbmVkQnlBZG1pbgMDAwkA9AMDCAUCdHgJYm9keUJ5dGVzCQCRAwIIBQJ0eAZwcm9vZnMAAAUMYWRtaW5QdWJLZXkxBgkA9AMDCAUCdHgJYm9keUJ5dGVzCQCRAwIIBQJ0eAZwcm9vZnMAAAUMYWRtaW5QdWJLZXkyBgkA9AMDCAUCdHgJYm9keUJ5dGVzCQCRAwIIBQJ0eAZwcm9vZnMAAAUMYWRtaW5QdWJLZXkzBgkA9AMDCAUCdHgJYm9keUJ5dGVzCQCRAwIIBQJ0eAZwcm9vZnMAAAURYWRtaW5QdWJLZXlJbnZva2UDAwUTY2FsbFRha2VJbnRvQWNjb3VudAUNc2lnbmVkQnlBZG1pbgcGBRNtdWx0aVNpZ25lZEJ5QWRtaW5zBRNtdWx0aVNpZ25lZEJ5QWRtaW5zz3XOLA==", "height": 2267668, "applicationStatus": "succeeded", "spentComplexity": 0 } View: original | compacted Prev: none Next: 9GDJqh7tMaqmqFFHYGC89reXt68bGsNyNuufFpxj1mEp Full:
OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let a = 1000000
5+
6+let b = 1000000
7+
8+let c = 10
9+
10+let d = 6
11+
12+let e = (86400 / 60)
13+
14+let f = "3.0.0"
15+
16+let g = "version"
17+
18+let h = "asset_ids"
19+
20+let i = "_balance"
21+
22+let j = "active"
23+
24+let k = "shutdown_cause"
25+
26+let l = "share_asset_id"
27+
28+let m = "share_asset_supply"
29+
30+let n = "commission"
31+
32+let o = "dAppThresholdCoef"
33+
34+let p = "staking_usdnnsbt_address"
35+
36+let q = "discounts"
37+
38+let r = "discount_values"
39+
40+let s = "_SWOP_amount"
41+
42+let t = "admin_pub_1"
43+
44+let u = "admin_pub_2"
45+
46+let v = "admin_pub_3"
47+
48+let w = "admin_invoke_pub"
49+
50+let x = "money_box_address"
51+
52+let y = "governance_address"
53+
54+let z = "voting_address"
55+
56+let B = "farming_address"
57+
58+let C = "lp_farming"
59+
60+let E = Address(base58'3MvVBtsXroQpy1tsPw21TU2ET9A8WfmrNjz')
61+
62+func F (G) = {
63+ let H = getString(E, G)
64+ if ($isInstanceOf(H, "String"))
65+ then {
66+ let I = H
67+ fromBase58String(I)
68+ }
69+ else {
70+ let J = H
71+ throw((G + "is empty"))
72+ }
73+ }
74+
75+
76+let K = F(t)
77+
78+let L = F(u)
79+
80+let M = F(v)
81+
82+let N = F(w)
83+
84+let O = Address(F(x))
85+
86+let P = Address(F(y))
87+
88+let Q = Address(F(p))
89+
90+let R = Address(F(z))
91+
92+let S = Address(F(B))
93+
94+let T = Address(F(C))
95+
96+let U = base58'8UrfDVd5GreeUwm7uPk7eYz1eMv376kzR52C6sANPkwS'
97+
98+let V = [toBase58String(U)]
99+
100+let W = getBooleanValue(this, j)
101+
102+let X = fromBase58String(getStringValue(this, l))
103+
104+let Y = getIntegerValue(this, m)
105+
106+let Z = 1000000
107+
108+let aa = getIntegerValue(this, n)
109+
110+let ab = fraction(40, Z, 100)
111+
112+let ac = getIntegerValue(this, "initial_A")
113+
114+let ad = getIntegerValue(this, "future_A")
115+
116+let ae = valueOrElse(getInteger(this, "initial_A_time"), 0)
117+
118+let af = valueOrElse(getInteger(this, "future_A_time"), 0)
119+
120+let ag = split(getStringValue(this, h), ",")
121+
122+let ah = size(ag)
123+
124+func ai (aj) = [BooleanEntry(j, false), StringEntry(k, aj)]
125+
126+
127+func ak () = throw("DApp is already active")
128+
129+
130+func al () = if (W)
131+ then unit
132+ else throw("DApp is inactive at this moment")
133+
134+
135+func am (an) = if (containsElement([K, L, M], an.callerPublicKey))
136+ then unit
137+ else throw("Only admin can call this function")
138+
139+
140+func ao (an) = if ((this == an.caller))
141+ then unit
142+ else throw("Only contract itself can call this function")
143+
144+
145+let ap = toBigInt(2)
146+
147+let aq = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
148+
149+let ar = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
150+
151+let as = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
152+
153+let at = height
154+
155+func au (av) = if (av)
156+ then false
157+ else true
158+
159+
160+func aw (ax) = {
161+ let ay = {
162+ let H = ax
163+ if ($isInstanceOf(H, "Address"))
164+ then {
165+ let az = H
166+ toString(az)
167+ }
168+ else if ($isInstanceOf(H, "String"))
169+ then {
170+ let az = H
171+ az
172+ }
173+ else throw("Unknow type of user Addr")
174+ }
175+ let aA = valueOrElse(getInteger(P, (ay + s)), 0)
176+ let aB = split(getStringValue(E, r), ",")
177+ let aC = split(getStringValue(E, q), ",")
178+ if (if ((aA >= parseIntValue(aB[0])))
179+ then (parseIntValue(aB[1]) > aA)
180+ else false)
181+ then (Z - parseIntValue(aC[0]))
182+ else if (if ((aA >= parseIntValue(aB[1])))
183+ then (parseIntValue(aB[2]) > aA)
184+ else false)
185+ then (Z - parseIntValue(aC[1]))
186+ else if (if ((aA >= parseIntValue(aB[2])))
187+ then (parseIntValue(aB[3]) > aA)
188+ else false)
189+ then (Z - parseIntValue(aC[2]))
190+ else if (if ((aA >= parseIntValue(aB[3])))
191+ then (parseIntValue(aB[4]) > aA)
192+ else false)
193+ then (Z - parseIntValue(aC[3]))
194+ else if ((aA >= parseIntValue(aB[4])))
195+ then (Z - parseIntValue(aC[4]))
196+ else Z
197+ }
198+
199+
200+func aD () = {
201+ let aE = af
202+ let aF = ad
203+ if ((aE > at))
204+ then {
205+ let aG = ac
206+ let aH = ae
207+ if ((aF > aG))
208+ then (aG + (((aF - aG) * (at - aH)) / (aE - aH)))
209+ else (aG - (((aG - aF) * (at - aH)) / (aE - aH)))
210+ }
211+ else aF
212+ }
213+
214+
215+func aI () = {
216+ func aJ (aK,aL) = (aK :+ valueOrElse(getInteger(this, (aL + i)), 0))
217+
218+ let aM = ag
219+ let aN = size(aM)
220+ let aO = nil
221+ func aP (aQ,aR) = if ((aR >= aN))
222+ then aQ
223+ else aJ(aQ, aM[aR])
224+
225+ func aS (aQ,aR) = if ((aR >= aN))
226+ then aQ
227+ else throw("List size exceeds 10")
228+
229+ aS(aP(aP(aP(aP(aP(aP(aP(aP(aP(aP(aO, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
230+ }
231+
232+
233+func aT (aU) = aU
234+
235+
236+func aV (aK,aW) = (aK + aW)
237+
238+
239+func aX (aU,aY) = {
240+ let aZ = invoke(this, "D", [aU, aY], nil)
241+ if ($isInstanceOf(aZ, "Int"))
242+ then aZ
243+ else throw(($getType(aZ) + " couldn't be cast to Int"))
244+ }
245+
246+
247+func ba (aU,aY) = {
248+ let bb = {
249+ let aM = aU
250+ let aN = size(aM)
251+ let aO = 0
252+ func aP (aQ,aR) = if ((aR >= aN))
253+ then aQ
254+ else aV(aQ, aM[aR])
255+
256+ func aS (aQ,aR) = if ((aR >= aN))
257+ then aQ
258+ else throw("List size exceeds 10")
259+
260+ aS(aP(aP(aP(aP(aP(aP(aP(aP(aP(aP(aO, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
261+ }
262+ if ((bb == 0))
263+ then 0
264+ else {
265+ let bc = (aY * ah)
266+ let bd = (toBigInt(bc) * toBigInt(bb))
267+ let be = toBigInt((bc - 1))
268+ func bf (aK,an) = if ((aK._2 == true))
269+ then aK
270+ else {
271+ let bg = aK._1
272+ func bh (bi,an) = if ((ah > an))
273+ then ((bi * bg) / (toBigInt(aU[an]) * toBigInt(ah)))
274+ else bi
275+
276+ let bi = {
277+ let aM = aq
278+ let aN = size(aM)
279+ let aO = bg
280+ func bj (aQ,aR) = if ((aR >= aN))
281+ then aQ
282+ else bh(aQ, aM[aR])
283+
284+ func bk (aQ,aR) = if ((aR >= aN))
285+ then aQ
286+ else throw("List size exceeds 10")
287+
288+ bk(bj(bj(bj(bj(bj(bj(bj(bj(bj(bj(aO, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
289+ }
290+ let bl = fraction((bd + (toBigInt(ah) * bi)), bg, ((be * bg) + (toBigInt((ah + 1)) * bi)))
291+ if ((bl > bg))
292+ then if ((1 >= toInt((bl - bg))))
293+ then $Tuple2(bl, true)
294+ else $Tuple2(bl, false)
295+ else if ((1 >= toInt((bg - bl))))
296+ then $Tuple2(bl, true)
297+ else $Tuple2(bl, false)
298+ }
299+
300+ let bm = {
301+ let aM = ar
302+ let aN = size(aM)
303+ let aO = $Tuple2(toBigInt(bb), false)
304+ func bj (aQ,aR) = if ((aR >= aN))
305+ then aQ
306+ else bf(aQ, aM[aR])
307+
308+ func bk (aQ,aR) = if ((aR >= aN))
309+ then aQ
310+ else throw("List size exceeds 15")
311+
312+ bk(bj(bj(bj(bj(bj(bj(bj(bj(bj(bj(bj(bj(bj(bj(bj(aO, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
313+ }
314+ let bl = bm._1
315+ let bn = bm._2
316+ if ((bn == false))
317+ then throw(("get_D() not finished with " + toString(bl)))
318+ else toInt(bl)
319+ }
320+ }
321+
322+
323+func bo (aU,aY) = aX(aT(aU), aY)
324+
325+
326+func bp (bq,br,bs,bt) = if (au((bq != br)))
327+ then throw("same coin")
328+ else if (au(if ((br >= 0))
329+ then (bq >= 0)
330+ else false))
331+ then throw("below zero")
332+ else if (au(if ((ah > br))
333+ then (ah > bq)
334+ else false))
335+ then throw("above N_COINS")
336+ else {
337+ let aY = aD()
338+ let bl = aX(bt, aY)
339+ let bc = (aY * ah)
340+ func bu (aK,an) = {
341+ let bv = aK
342+ let bw = bv._1
343+ let bx = bv._2
344+ let by = if ((bq == an))
345+ then bs
346+ else bt[an]
347+ if (if ((an != br))
348+ then (ah > an)
349+ else false)
350+ then $Tuple2((bw + by), fraction(bx, toBigInt(bl), toBigInt((by * ah))))
351+ else $Tuple2(bw, bx)
352+ }
353+
354+ let bz = {
355+ let aM = aq
356+ let aN = size(aM)
357+ let aO = $Tuple2(0, toBigInt(bl))
358+ func aP (aQ,aR) = if ((aR >= aN))
359+ then aQ
360+ else bu(aQ, aM[aR])
361+
362+ func aS (aQ,aR) = if ((aR >= aN))
363+ then aQ
364+ else throw("List size exceeds 10")
365+
366+ aS(aP(aP(aP(aP(aP(aP(aP(aP(aP(aP(aO, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
367+ }
368+ let bw = bz._1
369+ let bA = bz._2
370+ let bx = fraction(bA, toBigInt(bl), toBigInt((bc * ah)))
371+ let bB = toBigInt(((bw + (bl / bc)) - bl))
372+ func bC (aK,bD) = if ((aK._2 == true))
373+ then aK
374+ else {
375+ let bE = aK._1
376+ let bF = (((bE * bE) + bx) / ((ap * bE) + bB))
377+ if ((bF > bE))
378+ then if ((1 >= toInt((bF - bE))))
379+ then $Tuple2(bF, true)
380+ else $Tuple2(bF, false)
381+ else if ((1 >= toInt((bE - bF))))
382+ then $Tuple2(bF, true)
383+ else $Tuple2(bF, false)
384+ }
385+
386+ let bG = {
387+ let aM = as
388+ let aN = size(aM)
389+ let aO = $Tuple2(toBigInt(bl), false)
390+ func bj (aQ,aR) = if ((aR >= aN))
391+ then aQ
392+ else bC(aQ, aM[aR])
393+
394+ func bk (aQ,aR) = if ((aR >= aN))
395+ then aQ
396+ else throw("List size exceeds 16")
397+
398+ bk(bj(bj(bj(bj(bj(bj(bj(bj(bj(bj(bj(bj(bj(bj(bj(bj(aO, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16)
399+ }
400+ let bF = bG._1
401+ let bn = bG._2
402+ if ((bn == false))
403+ then throw(("getY() not finished with " + toString(bF)))
404+ else toInt(bF)
405+ }
406+
407+
408+func bH (bI,bq,aU,bl) = if (au((bq >= 0)))
409+ then throw("i below zero")
410+ else if (au((ah > bq)))
411+ then throw("i above N_COINS")
412+ else {
413+ let bc = (bI * ah)
414+ func bu (aK,an) = {
415+ let bJ = aK
416+ let bw = bJ._1
417+ let bx = bJ._2
418+ let by = if (if ((bq != an))
419+ then (ah > an)
420+ else false)
421+ then aU[an]
422+ else 0
423+ if (if ((ah > an))
424+ then (bq != an)
425+ else false)
426+ then $Tuple2((bw + by), fraction(bx, toBigInt(bl), toBigInt((by * ah))))
427+ else $Tuple2(bw, bx)
428+ }
429+
430+ let bK = {
431+ let aM = aq
432+ let aN = size(aM)
433+ let aO = $Tuple2(0, toBigInt(bl))
434+ func aP (aQ,aR) = if ((aR >= aN))
435+ then aQ
436+ else bu(aQ, aM[aR])
437+
438+ func aS (aQ,aR) = if ((aR >= aN))
439+ then aQ
440+ else throw("List size exceeds 10")
441+
442+ aS(aP(aP(aP(aP(aP(aP(aP(aP(aP(aP(aO, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
443+ }
444+ let bw = bK._1
445+ let bA = bK._2
446+ let bx = fraction(bA, toBigInt(bl), toBigInt((bc * ah)))
447+ let bB = toBigInt(((bw + (bl / bc)) - bl))
448+ func bL (aK,an) = if ((aK._2 == true))
449+ then aK
450+ else {
451+ let bE = aK._1
452+ let bF = (((bE * bE) + bx) / ((ap * bE) + bB))
453+ if ((bF > bE))
454+ then if ((1 >= toInt((bF - bE))))
455+ then $Tuple2(bF, true)
456+ else $Tuple2(bF, false)
457+ else if ((1 >= toInt((bE - bF))))
458+ then $Tuple2(bF, true)
459+ else $Tuple2(bF, false)
460+ }
461+
462+ let bM = {
463+ let aM = as
464+ let aN = size(aM)
465+ let aO = $Tuple2(toBigInt(bl), false)
466+ func bj (aQ,aR) = if ((aR >= aN))
467+ then aQ
468+ else bL(aQ, aM[aR])
469+
470+ func bk (aQ,aR) = if ((aR >= aN))
471+ then aQ
472+ else throw("List size exceeds 16")
473+
474+ bk(bj(bj(bj(bj(bj(bj(bj(bj(bj(bj(bj(bj(bj(bj(bj(bj(aO, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16)
475+ }
476+ let bF = bM._1
477+ let bn = bM._2
478+ if ((bn == false))
479+ then throw(("get_y_D() not finished with " + toString(bF)))
480+ else toInt(bF)
481+ }
482+
483+
484+func bN (aU,bO,an,bP) = {
485+ let bQ = aw(bP)
486+ let aY = aD()
487+ let bR = ((fraction(aa, bQ, Z, CEILING) * ah) / (4 * (ah - 1)))
488+ let bS = Y
489+ let bT = aX(aU, aY)
490+ let bU = (bT - fraction(bO, bT, bS))
491+ let bV = bH(aY, an, aU, bU)
492+ let bW = (aU[an] - bV)
493+ func bX (aK,bY) = {
494+ let bZ = aK
495+ let ca = bZ._1
496+ let cb = bZ._2
497+ let cc = if ((cb == an))
498+ then (fraction(bY, bU, bT) - bV)
499+ else (bY - fraction(bY, bU, bT))
500+ $Tuple2((ca :+ (bY - fraction(bR, cc, Z))), (cb + 1))
501+ }
502+
503+ let cd = {
504+ let aM = aU
505+ let aN = size(aM)
506+ let aO = $Tuple2(nil, 0)
507+ func aP (aQ,aR) = if ((aR >= aN))
508+ then aQ
509+ else bX(aQ, aM[aR])
510+
511+ func aS (aQ,aR) = if ((aR >= aN))
512+ then aQ
513+ else throw("List size exceeds 10")
514+
515+ aS(aP(aP(aP(aP(aP(aP(aP(aP(aP(aP(aO, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
516+ }
517+ let ca = cd._1
518+ let cb = cd._2
519+ let ce = ca[an]
520+ let cf = ((ce - bH(aY, an, ca, bU)) - 1)
521+ $Tuple2(cf, (bW - cf))
522+ }
523+
524+
525+func cg (aL) = {
526+ let H = aL
527+ if ($isInstanceOf(H, "ByteVector"))
528+ then {
529+ let ch = H
530+ toBase58String(ch)
531+ }
532+ else if ($isInstanceOf(H, "Unit"))
533+ then {
534+ let ci = H
535+ "WAVES"
536+ }
537+ else throw("Match error")
538+ }
539+
540+
541+func cj (ck,aL) = if (ck)
542+ then $Tuple2("lockNeutrino", Q)
543+ else $Tuple2("unlockNeutrino", Q)
544+
545+
546+func cl (ck,cm,aL) = if (ck)
547+ then {
548+ let cn = cj(ck, aL)
549+ let co = cn._1
550+ let cp = cn._2
551+ $Tuple4(co, cp, nil, [AttachedPayment(aL, cm)])
552+ }
553+ else {
554+ let cq = cj(ck, aL)
555+ let co = cq._1
556+ let cp = cq._2
557+ $Tuple4(co, cp, [cm, toBase58String(aL)], nil)
558+ }
559+
560+
561+func ck (cm,cr) = if (containsElement(V, cr))
562+ then {
563+ let cs = cl(true, cm, fromBase58String(cr))
564+ let co = cs._1
565+ let ct = cs._2
566+ let cu = cs._3
567+ let cv = cs._4
568+ invoke(ct, co, cu, cv)
569+ }
570+ else 0
571+
572+
573+func cw (cm,cr) = if (containsElement(V, cr))
574+ then {
575+ let cx = cl(false, cm, fromBase58String(cr))
576+ let co = cx._1
577+ let ct = cx._2
578+ let cu = cx._3
579+ let cv = cx._4
580+ invoke(ct, co, cu, cv)
581+ }
582+ else 0
583+
584+
585+func cy (aL) = {
586+ let cz = {
587+ let H = aL
588+ if ($isInstanceOf(H, "ByteVector"))
589+ then {
590+ let cA = H
591+ if ((cA == U))
592+ then getInteger(Q, ((("rpd_balance_" + toBase58String(cA)) + "_") + toString(this)))
593+ else 0
594+ }
595+ else if ($isInstanceOf(H, "Unit"))
596+ then 0
597+ else throw("Match error")
598+ }
599+ let H = cz
600+ if ($isInstanceOf(H, "Int"))
601+ then {
602+ let an = H
603+ an
604+ }
605+ else 0
606+ }
607+
608+
609+func cB () = {
610+ let cC = aI()
611+ func cD (aK,aL) = {
612+ let cE = aK
613+ let cF = cE._1
614+ let an = cE._2
615+ if (cF)
616+ then $Tuple2(cF, an)
617+ else {
618+ let cG = (assetBalance(this, fromBase58String(aL)) + cy(fromBase58String(aL)))
619+ if ((cC[an] > cG))
620+ then $Tuple2(true, an)
621+ else $Tuple2(false, (an + 1))
622+ }
623+ }
624+
625+ let aM = ag
626+ let aN = size(aM)
627+ let aO = $Tuple2(false, 0)
628+ func aP (aQ,aR) = if ((aR >= aN))
629+ then aQ
630+ else cD(aQ, aM[aR])
631+
632+ func aS (aQ,aR) = if ((aR >= aN))
633+ then aQ
634+ else throw("List size exceeds 10")
635+
636+ aS(aP(aP(aP(aP(aP(aP(aP(aP(aP(aP(aO, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
637+ }
638+
639+
640+func cH (an) = ai(("Suspicious state with asset: " + ag[an]))
641+
642+
643+func cI (bP,cv) = {
644+ func cJ (aK,cK) = (aK :+ ScriptTransfer(bP, cK.amount, cK.assetId))
645+
646+ let aM = cv
647+ let aN = size(aM)
648+ let aO = nil
649+ func aP (aQ,aR) = if ((aR >= aN))
650+ then aQ
651+ else cJ(aQ, aM[aR])
652+
653+ func aS (aQ,aR) = if ((aR >= aN))
654+ then aQ
655+ else throw("List size exceeds 10")
656+
657+ aS(aP(aP(aP(aP(aP(aP(aP(aP(aP(aP(aO, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
658+ }
659+
660+
661+func cL (cM) = {
662+ let cN = valueOrErrorMessage(getInteger(this, o), "No dAppThresholdCoef key")
663+ let cO = 10000
664+ let cP = max(cM)
665+ let cQ = min(cM)
666+ let cR = fraction(cP, cO, cQ)
667+ if ((cR > (cN * cO)))
668+ then throw("New balance in assets of the DApp is less than threshold")
669+ else false
670+ }
671+
672+
673+func cS (ag) = {
674+ let cT = split(ag, ",")
675+ if ((size(cT) > 10))
676+ then throw("To many coins, max coins size 10")
677+ else {
678+ func cU (cV,aL) = {
679+ let cW = valueOrErrorMessage(fromBase58String(aL), ("fromBase58String: " + aL))
680+ let cX = valueOrErrorMessage(assetInfo(cW), ("assetInfo: " + aL)).decimals
681+ if ((cX != d))
682+ then throw("wrong decimals")
683+ else false
684+ }
685+
686+ let aM = cT
687+ let aN = size(aM)
688+ let aO = false
689+ func aP (aQ,aR) = if ((aR >= aN))
690+ then aQ
691+ else cU(aQ, aM[aR])
692+
693+ func aS (aQ,aR) = if ((aR >= aN))
694+ then aQ
695+ else throw("List size exceeds 10")
696+
697+ aS(aP(aP(aP(aP(aP(aP(aP(aP(aP(aP(aO, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
698+ }
699+ }
700+
701+
702+@Callable(cY)
703+func D (aU,aY) = {
704+ let bl = ba(aU, aY)
705+ $Tuple2([IntegerEntry("D", bl)], bl)
706+ }
707+
708+
709+
710+@Callable(cY)
711+func init (ag,aD,cZ) = if (!(isDataStorageUntouched(this)))
712+ then throw("Already initialized")
713+ else if ((0 >= aD))
714+ then throw("Amp must be must > 0")
715+ else if ((0 >= cZ))
716+ then throw("dApp Threshold Coef must be > 0")
717+ else {
718+ let da = "s_Multi_USD"
719+ let db = ("ShareToken of SwopFi protocol for MultiStable USD pool at address " + toString(this))
720+ let dc = Issue(da, db, 0, 6, true)
721+ let dd = calculateAssetId(dc)
722+ if (cS(ag))
723+ then throw()
724+ else [StringEntry(g, f), StringEntry(h, ag), IntegerEntry("initial_A", aD), IntegerEntry("future_A", aD), IntegerEntry(n, getIntegerValue(E, "base_fee_flat")), StringEntry(l, toBase58String(dd)), IntegerEntry(m, 0), IntegerEntry(o, cZ), BooleanEntry(j, true), dc]
725+ }
726+
727+
728+
729+@Callable(cY)
730+func addLiquidity (de,df) = valueOrElse(al(), {
731+ let aY = aD()
732+ let aU = aI()
733+ let bT = if ((Y == 0))
734+ then 0
735+ else bo(aU, aY)
736+ let cv = cY.payments
737+ let dg = size(cv)
738+ func dh (di) = if ((dg > ah))
739+ then throw(("payments size > " + toString(ah)))
740+ else if ((1 > dg))
741+ then throw("payments size < 1")
742+ else if (if ((Y == 0))
743+ then (ah != dg)
744+ else false)
745+ then throw("initial deposit requires all coins")
746+ else {
747+ func dj (aK,cK) = if (containsElement(ag, cg(cK.assetId)))
748+ then true
749+ else throw("Invalid asset in payment")
750+
751+ let aM = cv
752+ let aN = size(aM)
753+ let aO = false
754+ func aP (aQ,aR) = if ((aR >= aN))
755+ then aQ
756+ else dj(aQ, aM[aR])
757+
758+ func aS (aQ,aR) = if ((aR >= aN))
759+ then aQ
760+ else throw("List size exceeds 10")
761+
762+ aS(aP(aP(aP(aP(aP(aP(aP(aP(aP(aP(aO, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
763+ }
764+
765+ if (!(dh(dg)))
766+ then throw()
767+ else {
768+ let cF = cB()
769+ if (cF._1)
770+ then (cH(cF._2) ++ cI(cY.caller, cv))
771+ else {
772+ func cJ (aK,aL) = {
773+ let dk = aK
774+ let cM = dk._1
775+ let an = dk._2
776+ func dl (dm,cK) = if ((cg(cK.assetId) == aL))
777+ then (dm + cK.amount)
778+ else dm
779+
780+ let dn = {
781+ let aM = cv
782+ let aN = size(aM)
783+ let aO = aU[an]
784+ func aP (aQ,aR) = if ((aR >= aN))
785+ then aQ
786+ else dl(aQ, aM[aR])
787+
788+ func aS (aQ,aR) = if ((aR >= aN))
789+ then aQ
790+ else throw("List size exceeds 10")
791+
792+ aS(aP(aP(aP(aP(aP(aP(aP(aP(aP(aP(aO, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
793+ }
794+ $Tuple2((cM :+ dn), (an + 1))
795+ }
796+
797+ let do = {
798+ let aM = ag
799+ let aN = size(aM)
800+ let aO = $Tuple2(nil, 0)
801+ func aP (aQ,aR) = if ((aR >= aN))
802+ then aQ
803+ else cJ(aQ, aM[aR])
804+
805+ func aS (aQ,aR) = if ((aR >= aN))
806+ then aQ
807+ else throw("List size exceeds 10")
808+
809+ aS(aP(aP(aP(aP(aP(aP(aP(aP(aP(aP(aO, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
810+ }
811+ let cM = do._1
812+ let dp = do._2
813+ if (cL(cM))
814+ then throw()
815+ else {
816+ let bU = bo(cM, aY)
817+ if (au((bU > bT)))
818+ then throw("D1 > D0")
819+ else {
820+ let bQ = aw(cY.caller)
821+ func dq (aK,dm) = {
822+ let dr = aK
823+ let ds = dr._1
824+ let dt = dr._2
825+ let an = dr._3
826+ if ((Y > 0))
827+ then {
828+ let bR = ((fraction(aa, bQ, Z, CEILING) * ah) / (4 * (ah - 1)))
829+ let du = {
830+ let dv = fraction(bU, aU[an], bT)
831+ let dw = if ((dv > dm))
832+ then (dv - dm)
833+ else (dm - dv)
834+ fraction(bR, dw, Z)
835+ }
836+ let dx = fraction(du, ab, Z)
837+ let dy = (dm - du)
838+ let dz = (dm - du)
839+ let dA = (dm - aU[an])
840+ let dB = (du - dx)
841+ let dC = if ((dA > 0))
842+ then ck((dA - du), ag[an])
843+ else cw(du, ag[an])
844+ if ((dC == dC))
845+ then {
846+ let dD = if ((dB > 0))
847+ then invoke(T, "airDrop", nil, [AttachedPayment(fromBase58String(ag[an]), dB)])
848+ else 0
849+ if ((dD == dD))
850+ then $Tuple3((ds :+ dz), (dt ++ [ScriptTransfer(O, dx, fromBase58String(ag[an])), IntegerEntry((ag[an] + i), dy)]), (an + 1))
851+ else throw("Strict value is not equal to itself.")
852+ }
853+ else throw("Strict value is not equal to itself.")
854+ }
855+ else {
856+ let dC = ck(dm, ag[an])
857+ if ((dC == dC))
858+ then $Tuple3((ds :+ dm), (dt :+ IntegerEntry((ag[an] + i), dm)), (an + 1))
859+ else throw("Strict value is not equal to itself.")
860+ }
861+ }
862+
863+ let dE = {
864+ let aM = cM
865+ let aN = size(aM)
866+ let aO = $Tuple3(nil, nil, 0)
867+ func bj (aQ,aR) = if ((aR >= aN))
868+ then aQ
869+ else dq(aQ, aM[aR])
870+
871+ func bk (aQ,aR) = if ((aR >= aN))
872+ then aQ
873+ else throw("List size exceeds 10")
874+
875+ bk(bj(bj(bj(bj(bj(bj(bj(bj(bj(bj(aO, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
876+ }
877+ let ds = dE._1
878+ let dt = dE._2
879+ let dF = bo(ds, aY)
880+ let dG = if ((Y == 0))
881+ then bU
882+ else fraction(Y, (dF - bT), bT)
883+ if (au((dG >= de)))
884+ then throw("Slippage screwed you")
885+ else if (df)
886+ then {
887+ let dH = invoke(this, "reissueShare", [dG], nil)
888+ if ((dH == dH))
889+ then {
890+ let dI = invoke(S, "lockShareTokens", [toString(this)], [AttachedPayment(X, dG)])
891+ if ((dI == dI))
892+ then (dt :+ IntegerEntry(m, (Y + dG)))
893+ else throw("Strict value is not equal to itself.")
894+ }
895+ else throw("Strict value is not equal to itself.")
896+ }
897+ else (dt ++ [Reissue(X, dG, true), ScriptTransfer(cY.caller, dG, X), IntegerEntry(m, (Y + dG))])
898+ }
899+ }
900+ }
901+ }
902+ })
903+
904+
905+
906+@Callable(cY)
907+func calcMintAmount (cM,ay) = {
908+ let aY = aD()
909+ let aU = aI()
910+ let bU = bo(cM, aY)
911+ if ((Y == 0))
912+ then $Tuple2(nil, bU)
913+ else {
914+ let bT = bo(aU, aY)
915+ let bQ = aw(ay)
916+ func dJ (aK,dm) = {
917+ let dK = aK
918+ let ds = dK._1
919+ let an = dK._2
920+ let bR = ((fraction(aa, bQ, Z, CEILING) * ah) / (4 * (ah - 1)))
921+ let du = {
922+ let dv = fraction(bU, aU[an], bT)
923+ let dw = if ((dv > dm))
924+ then (dv - dm)
925+ else (dm - dv)
926+ fraction(bR, dw, Z)
927+ }
928+ let dz = (dm - du)
929+ $Tuple2((ds :+ dz), (an + 1))
930+ }
931+
932+ let dL = {
933+ let aM = cM
934+ let aN = size(aM)
935+ let aO = $Tuple2(nil, 0)
936+ func aP (aQ,aR) = if ((aR >= aN))
937+ then aQ
938+ else dJ(aQ, aM[aR])
939+
940+ func aS (aQ,aR) = if ((aR >= aN))
941+ then aQ
942+ else throw("List size exceeds 10")
943+
944+ aS(aP(aP(aP(aP(aP(aP(aP(aP(aP(aP(aO, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
945+ }
946+ let ds = dL._1
947+ let dp = dL._2
948+ let dF = bo(ds, aY)
949+ let dM = fraction(Y, (dF - bT), bT)
950+ $Tuple2(nil, dM)
951+ }
952+ }
953+
954+
955+
956+@Callable(cY)
957+func reissueShare (cm) = valueOrElse(ao(cY), [Reissue(X, cm, true)])
958+
959+
960+
961+@Callable(cY)
962+func getDy (dN,dO,dP,dQ) = {
963+ let aU = aI()
964+ let dR = valueOrErrorMessage(indexOf(ag, dN), "unknown token in")
965+ let dS = valueOrErrorMessage(indexOf(ag, dO), "unknown token out")
966+ let bs = (aU[dR] + dP)
967+ let bF = bp(dR, dS, bs, aU)
968+ let cf = ((aU[dS] - bF) - 1)
969+ let bQ = aw(Address(fromBase58String(dQ)))
970+ let bR = fraction(fraction(aa, bQ, Z, CEILING), cf, Z)
971+ $Tuple2(nil, $Tuple2((cf - bR), bR))
972+ }
973+
974+
975+
976+@Callable(cY)
977+func exchange (dT,dU) = valueOrElse(al(), if ((size(cY.payments) != 1))
978+ then throw("size(payments) != 1")
979+ else {
980+ let cF = cB()
981+ if (cF._1)
982+ then (cH(cF._2) ++ cI(cY.caller, cY.payments))
983+ else {
984+ let cK = cY.payments[0]
985+ let dV = cg(cK.assetId)
986+ let dW = fromBase58String(dT)
987+ let dP = cK.amount
988+ let dR = valueOrErrorMessage(indexOf(ag, dV), "unknown token in")
989+ let dS = valueOrErrorMessage(indexOf(ag, dT), "unknown token out")
990+ let aU = aI()
991+ let bs = (aU[dR] + dP)
992+ let bF = bp(dR, dS, bs, aU)
993+ let dX = ((aU[dS] - bF) - 1)
994+ let bQ = aw(cY.originCaller)
995+ let bR = fraction(dX, fraction(aa, bQ, Z, CEILING), Z)
996+ let cf = (dX - bR)
997+ let dx = fraction(bR, ab, Z)
998+ if (au((cf >= dU)))
999+ then throw("Exchange resulted in fewer coins than expected")
1000+ else {
1001+ func dY (aK,dZ) = {
1002+ let ea = aK
1003+ let cM = ea._1
1004+ let an = ea._2
1005+ if ((an == dR))
1006+ then $Tuple2((cM :+ (dZ + dP)), (an + 1))
1007+ else if ((an == dS))
1008+ then $Tuple2((cM :+ (dZ - dX)), (an + 1))
1009+ else $Tuple2((cM :+ dZ), (an + 1))
1010+ }
1011+
1012+ let eb = {
1013+ let aM = aU
1014+ let aN = size(aM)
1015+ let aO = $Tuple2(nil, 0)
1016+ func aP (aQ,aR) = if ((aR >= aN))
1017+ then aQ
1018+ else dY(aQ, aM[aR])
1019+
1020+ func aS (aQ,aR) = if ((aR >= aN))
1021+ then aQ
1022+ else throw("List size exceeds 10")
1023+
1024+ aS(aP(aP(aP(aP(aP(aP(aP(aP(aP(aP(aO, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1025+ }
1026+ let cM = eb._1
1027+ let an = eb._2
1028+ if (cL(cM))
1029+ then throw()
1030+ else {
1031+ let dI = ck(cK.amount, cg(cK.assetId))
1032+ if ((dI == dI))
1033+ then {
1034+ let ec = cw(dX, dT)
1035+ if ((ec == ec))
1036+ then {
1037+ let dB = (bR - dx)
1038+ let dD = if ((dB > 0))
1039+ then invoke(T, "airDrop", nil, [AttachedPayment(dW, dB)])
1040+ else 0
1041+ if ((dD == dD))
1042+ then $Tuple2([IntegerEntry((dV + i), bs), IntegerEntry((dT + i), (aU[dS] - dX)), ScriptTransfer(cY.caller, cf, dW), ScriptTransfer(O, dx, dW)], [cf, dW])
1043+ else throw("Strict value is not equal to itself.")
1044+ }
1045+ else throw("Strict value is not equal to itself.")
1046+ }
1047+ else throw("Strict value is not equal to itself.")
1048+ }
1049+ }
1050+ }
1051+ })
1052+
1053+
1054+
1055+@Callable(cY)
1056+func withdraw (ed) = valueOrElse(al(), if ((size(cY.payments) != 1))
1057+ then throw("size(payments) != 1")
1058+ else {
1059+ let ee = cY.payments[0].amount
1060+ let ef = cY.payments[0].assetId
1061+ if ((X != ef))
1062+ then throw("unknown payment token")
1063+ else {
1064+ let cF = cB()
1065+ if (cF._1)
1066+ then (cH(cF._2) ++ cI(cY.originCaller, cY.payments))
1067+ else {
1068+ func dq (aK,eg) = {
1069+ let eh = aK
1070+ let dt = eh._1
1071+ let an = eh._2
1072+ let ei = fraction(eg, ee, Y)
1073+ if (au((ei >= ed[an])))
1074+ then throw("Withdrawal resulted in fewer coins than expected")
1075+ else {
1076+ let ec = cw(ei, ag[an])
1077+ if ((ec == ec))
1078+ then $Tuple2((dt ++ [IntegerEntry((ag[an] + i), (eg - ei)), ScriptTransfer(cY.originCaller, ei, fromBase58String(ag[an]))]), (an + 1))
1079+ else throw("Strict value is not equal to itself.")
1080+ }
1081+ }
1082+
1083+ let ej = {
1084+ let aM = aI()
1085+ let aN = size(aM)
1086+ let aO = $Tuple2(nil, 0)
1087+ func aP (aQ,aR) = if ((aR >= aN))
1088+ then aQ
1089+ else dq(aQ, aM[aR])
1090+
1091+ func aS (aQ,aR) = if ((aR >= aN))
1092+ then aQ
1093+ else throw("List size exceeds 10")
1094+
1095+ aS(aP(aP(aP(aP(aP(aP(aP(aP(aP(aP(aO, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1096+ }
1097+ let dt = ej._1
1098+ let an = ej._2
1099+ (dt ++ [Burn(X, ee), IntegerEntry(m, (Y - ee))])
1100+ }
1101+ }
1102+ })
1103+
1104+
1105+
1106+@Callable(cY)
1107+func withdrawWithUnlock (ed,ek) = valueOrElse(al(), if ((0 >= ek))
1108+ then throw("Unlock amount must be positive")
1109+ else {
1110+ let cF = cB()
1111+ if (cF._1)
1112+ then (cH(cF._2) ++ cI(cY.caller, cY.payments))
1113+ else {
1114+ let ee = if ((size(cY.payments) > 0))
1115+ then if ((size(cY.payments) != 1))
1116+ then throw("size(payments) != 1")
1117+ else {
1118+ let ef = cY.payments[0].assetId
1119+ if ((X != ef))
1120+ then throw("unknown payment token")
1121+ else cY.payments[0].amount
1122+ }
1123+ else 0
1124+ let el = invoke(S, "withdrawShareTokens", [toString(this), ek], nil)
1125+ if ((el == el))
1126+ then {
1127+ let em = (ee + ek)
1128+ let dC = invoke(this, "withdraw", [ed], [AttachedPayment(X, em)])
1129+ if ((dC == dC))
1130+ then nil
1131+ else throw("Strict value is not equal to itself.")
1132+ }
1133+ else throw("Strict value is not equal to itself.")
1134+ }
1135+ })
1136+
1137+
1138+
1139+@Callable(cY)
1140+func calcWithdrawOneCoin (en,dT,ay) = if ((0 >= en))
1141+ then throw("Amount must be positive")
1142+ else {
1143+ let an = valueOrErrorMessage(indexOf(ag, dT), "unknown token out")
1144+ $Tuple2(nil, bN(aI(), en, an, Address(fromBase58String(ay)))._1)
1145+ }
1146+
1147+
1148+
1149+@Callable(cY)
1150+func withdrawOneCoin (dT,eo) = valueOrElse(al(), if ((size(cY.payments) != 1))
1151+ then throw("size(payments) != 1")
1152+ else {
1153+ let cF = cB()
1154+ if (cF._1)
1155+ then (cH(cF._2) ++ cI(cY.originCaller, cY.payments))
1156+ else {
1157+ let ee = cY.payments[0].amount
1158+ let ef = cY.payments[0].assetId
1159+ if ((ef != X))
1160+ then throw("unknown token")
1161+ else {
1162+ let ep = valueOrErrorMessage(indexOf(ag, dT), "unknown token out")
1163+ let dW = fromBase58String(dT)
1164+ let aU = aI()
1165+ let eq = bN(aU, ee, ep, cY.originCaller)
1166+ let cf = eq._1
1167+ let er = eq._2
1168+ if (au((cf >= eo)))
1169+ then throw("Not enough coins removed")
1170+ else {
1171+ let dx = fraction(er, ab, Z)
1172+ let es = (cf + er)
1173+ func dY (aK,dZ) = {
1174+ let et = aK
1175+ let cM = et._1
1176+ let an = et._2
1177+ if ((an == ep))
1178+ then $Tuple2((cM :+ (dZ - es)), (an + 1))
1179+ else $Tuple2((cM :+ dZ), (an + 1))
1180+ }
1181+
1182+ let eu = {
1183+ let aM = aU
1184+ let aN = size(aM)
1185+ let aO = $Tuple2(nil, 0)
1186+ func aP (aQ,aR) = if ((aR >= aN))
1187+ then aQ
1188+ else dY(aQ, aM[aR])
1189+
1190+ func aS (aQ,aR) = if ((aR >= aN))
1191+ then aQ
1192+ else throw("List size exceeds 10")
1193+
1194+ aS(aP(aP(aP(aP(aP(aP(aP(aP(aP(aP(aO, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1195+ }
1196+ let cM = eu._1
1197+ let ev = eu._2
1198+ if (cL(cM))
1199+ then throw()
1200+ else {
1201+ let ec = cw(es, dT)
1202+ if ((ec == ec))
1203+ then {
1204+ let dB = (er - dx)
1205+ let dD = if ((dB > 0))
1206+ then invoke(T, "airDrop", nil, [AttachedPayment(dW, dB)])
1207+ else 0
1208+ if ((dD == dD))
1209+ then [ScriptTransfer(cY.originCaller, cf, dW), IntegerEntry((ag[ep] + i), (aU[ep] - es)), Burn(X, ee), ScriptTransfer(O, dx, dW), IntegerEntry(m, (Y - ee))]
1210+ else throw("Strict value is not equal to itself.")
1211+ }
1212+ else throw("Strict value is not equal to itself.")
1213+ }
1214+ }
1215+ }
1216+ }
1217+ })
1218+
1219+
1220+
1221+@Callable(cY)
1222+func withdrawOneCoinWithUnlock (dT,eo,ek) = valueOrElse(al(), if ((0 >= ek))
1223+ then throw("Unlock amount must be positive")
1224+ else {
1225+ let cF = cB()
1226+ if (cF._1)
1227+ then (cH(cF._2) ++ cI(cY.caller, cY.payments))
1228+ else {
1229+ let ee = if ((size(cY.payments) > 0))
1230+ then if ((size(cY.payments) != 1))
1231+ then throw("size(payments) != 1")
1232+ else {
1233+ let ef = cY.payments[0].assetId
1234+ if ((X != ef))
1235+ then throw("unknown payment token")
1236+ else cY.payments[0].amount
1237+ }
1238+ else 0
1239+ let el = invoke(S, "withdrawShareTokens", [toString(this), ek], nil)
1240+ if ((el == el))
1241+ then {
1242+ let em = (ee + ek)
1243+ let dC = invoke(this, "withdrawOneCoin", [dT, eo], [AttachedPayment(X, em)])
1244+ if ((dC == dC))
1245+ then nil
1246+ else throw("Strict value is not equal to itself.")
1247+ }
1248+ else throw("Strict value is not equal to itself.")
1249+ }
1250+ })
1251+
1252+
1253+
1254+@Callable(cY)
1255+func A () = $Tuple2(nil, aD())
1256+
1257+
1258+
1259+@Callable(cY)
1260+func getVirtualPrice () = {
1261+ let bl = aX(aI(), aD())
1262+ $Tuple2(nil, fraction(bl, a, Y))
1263+ }
1264+
1265+
1266+
1267+@Callable(cY)
1268+func calcTokenAmount (ew,ex) = {
1269+ let aY = aD()
1270+ let ey = aI()
1271+ let bT = bo(ey, aY)
1272+ func ez (aK,eg) = {
1273+ let eA = aK
1274+ let cM = eA._1
1275+ let an = eA._2
1276+ let dm = (eg + (if (ex)
1277+ then ew[an]
1278+ else -(ew[an])))
1279+ $Tuple2((cM :+ dm), (an + 1))
1280+ }
1281+
1282+ let cM = ( let aM = ey
1283+ let aN = size(aM)
1284+ let aO = $Tuple2(nil, 0)
1285+ func aP (aQ,aR) = if ((aR >= aN))
1286+ then aQ
1287+ else ez(aQ, aM[aR])
1288+
1289+ func aS (aQ,aR) = if ((aR >= aN))
1290+ then aQ
1291+ else throw("List size exceeds 10")
1292+
1293+ aS(aP(aP(aP(aP(aP(aP(aP(aP(aP(aP(aO, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10))._1
1294+ let bU = bo(cM, aY)
1295+ let eB = if (ex)
1296+ then (bU - bT)
1297+ else (bT - bU)
1298+ $Tuple2(nil, fraction(eB, Y, bT))
1299+ }
1300+
1301+
1302+
1303+@Callable(cY)
1304+func rampA (eC,eD) = valueOrElse(al(), valueOrElse(am(cY), if (au((at >= (ae + e))))
1305+ then throw("too often")
1306+ else if (au((eD >= (at + e))))
1307+ then throw("insufficient time")
1308+ else {
1309+ let eE = aD()
1310+ if (au(if ((eC > 0))
1311+ then (b > eC)
1312+ else false))
1313+ then throw("out of base range")
1314+ else if (au(if (if ((eC >= eE))
1315+ then ((eE * c) >= eC)
1316+ else false)
1317+ then true
1318+ else if ((eE > eC))
1319+ then ((eC * c) >= eE)
1320+ else false))
1321+ then throw("out of range")
1322+ else [IntegerEntry("initial_A", eE), IntegerEntry("future_A", eC), IntegerEntry("initial_A_time", at), IntegerEntry("future_A_time", eD)]
1323+ }))
1324+
1325+
1326+
1327+@Callable(cY)
1328+func stopRampA () = valueOrElse(al(), valueOrElse(am(cY), {
1329+ let eF = aD()
1330+[IntegerEntry("initial_A", eF), IntegerEntry("future_A", eF), IntegerEntry("initial_A_time", at), IntegerEntry("future_A_time", at)]
1331+ }))
1332+
1333+
1334+
1335+@Callable(cY)
1336+func shutdown () = valueOrElse(am(cY), if (!(W))
1337+ then throw(("DApp is already suspended. Cause: " + valueOrElse(getString(this, k), "the cause wasn't specified")))
1338+ else ai("Paused by admin"))
1339+
1340+
1341+
1342+@Callable(cY)
1343+func activate () = valueOrElse(am(cY), if (W)
1344+ then ak()
1345+ else [BooleanEntry(j, true), DeleteEntry(k)])
1346+
1347+
1348+
1349+@Callable(cY)
1350+func takeIntoAccountExtraFunds () = valueOrElse(al(), if ((cY.caller != O))
1351+ then throw("Only the wallet can call this function")
1352+ else {
1353+ let ey = aI()
1354+ func eG (aK,aL) = {
1355+ let eH = aK
1356+ let eI = eH._1
1357+ let an = eH._2
1358+ let eJ = fromBase58String(aL)
1359+ let eK = (assetBalance(this, eJ) + cy(eJ))
1360+ let eL = (eK - ey[an])
1361+ if ((0 > eL))
1362+ then ai(("Enroll amount negative for asset" + aL))
1363+ else {
1364+ let dD = if ((eL > 0))
1365+ then invoke(T, "airDrop", nil, [AttachedPayment(eJ, eL)])
1366+ else 0
1367+ if ((dD == dD))
1368+ then $Tuple2((eI + eL), (an + 1))
1369+ else throw("Strict value is not equal to itself.")
1370+ }
1371+ }
1372+
1373+ let dp = {
1374+ let aM = ag
1375+ let aN = size(aM)
1376+ let aO = $Tuple2(0, 0)
1377+ func aP (aQ,aR) = if ((aR >= aN))
1378+ then aQ
1379+ else eG(aQ, aM[aR])
1380+
1381+ func aS (aQ,aR) = if ((aR >= aN))
1382+ then aQ
1383+ else throw("List size exceeds 10")
1384+
1385+ aS(aP(aP(aP(aP(aP(aP(aP(aP(aP(aP(aO, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1386+ }
1387+ if ((dp._1 == 0))
1388+ then throw("No money to take")
1389+ else nil
1390+ })
1391+
1392+
1393+@Verifier(eM)
1394+func eN () = {
1395+ let eO = {
1396+ let eP = if (sigVerify(eM.bodyBytes, eM.proofs[0], K))
1397+ then 1
1398+ else 0
1399+ let eQ = if (sigVerify(eM.bodyBytes, eM.proofs[1], L))
1400+ then 1
1401+ else 0
1402+ let eR = if (sigVerify(eM.bodyBytes, eM.proofs[2], M))
1403+ then 1
1404+ else 0
1405+ (((eP + eQ) + eR) >= 2)
1406+ }
1407+ let H = eM
1408+ if ($isInstanceOf(H, "InvokeScriptTransaction"))
1409+ then {
1410+ let dC = H
1411+ let eS = if ((dC.dApp == this))
1412+ then (dC.function == "takeIntoAccountExtraFunds")
1413+ else false
1414+ let eT = if (if (if (sigVerify(eM.bodyBytes, eM.proofs[0], K))
1415+ then true
1416+ else sigVerify(eM.bodyBytes, eM.proofs[0], L))
1417+ then true
1418+ else sigVerify(eM.bodyBytes, eM.proofs[0], M))
1419+ then true
1420+ else sigVerify(eM.bodyBytes, eM.proofs[0], N)
1421+ if (if (eS)
1422+ then eT
1423+ else false)
1424+ then true
1425+ else eO
1426+ }
1427+ else eO
1428+ }
1429+

github/deemru/w8io/c3f4982 
63.80 ms