tx · AmkwiMwGk537QJXeqwLRYHMS59Y6nM6nsfnoYV8Zxcou

3N8p4dscxCN8XkfWopQP55a2AyvFD9cJx8a:  -0.10000000 Waves

2022.10.30 15:43 [2295152] smart account 3N8p4dscxCN8XkfWopQP55a2AyvFD9cJx8a > SELF 0.00000000 Waves

{ "type": 13, "id": "AmkwiMwGk537QJXeqwLRYHMS59Y6nM6nsfnoYV8Zxcou", "fee": 10000000, "feeAssetId": null, "timestamp": 1667133807004, "version": 1, "sender": "3N8p4dscxCN8XkfWopQP55a2AyvFD9cJx8a", "senderPublicKey": "3JAonT9h65iAMaQegaHVE8pCbEPHPXoARiimB7edrrTb", "proofs": [ "4Fd5xvioDCbJSVVJLfMbogtYQU69xWRtuFSp1KLTCedfn6uWDBGG8DqzCeCX1w4Yo4XoMFXgnxatFafMsZV9wYCx" ], "script": "base64:BgJwCAISCAoGCAgIAQEBEgMKAQESBQoDAQEBEgQKAgEBEgMKAQgSBAoCAQESBAoCAQESABIAEgQKAggEEgQKAgEBEgASBAoCAQESABIAEgMKAQgSABIAEgMKAQESABIAEgMKAQQSABIAEgMKAQgSAwoBCEQAB05fQ09JTlMJARFAZXh0ck5hdGl2ZSgxMDUwKQIFBHRoaXMCB05fQ09JTlMAC05fQ09JTlNfYmlnCQC2AgEFB05fQ09JTlMAC05fQ09JTlNfTUFYAAoADlRPS0VOX0RFQ0lNQUxTAAYAClRPS0VOX1JBVEUAwIQ9AA9GRUVfREVOT01JTkFUT1IAgMivoCUACVBSRUNJU0lPTgDAhD0ACERFQ0lNQUxTAAYADU1BWF9BRE1JTl9GRUUAgMivoCUAB01BWF9GRUUAgOSX0BIABU1BWF9BAMCEPQAMTUFYX0FfQ0hBTkdFAAoAE0FETUlOX0FDVElPTlNfREVMQVkJAGkCCQBoAgADAICjBQA8AA1NSU5fUkFNUF9USU1FCQBpAgCAowUAPAANVlBfTE9HX1BFUklPRACAuJkpAAxWUF9QUkVDSVNJT04AgKCUpY0dAAVjb2lucwkAtQkCCQERQGV4dHJOYXRpdmUoMTA1MykCBQR0aGlzAgVjb2lucwIBLAADZmVlCQERQGV4dHJOYXRpdmUoMTA1MCkCBQR0aGlzAgNmZWUACWFkbWluX2ZlZQkBEUBleHRyTmF0aXZlKDEwNTApAgUEdGhpcwIJYWRtaW5fZmVlAAxpc19hdXRvX2ZlZXMJARFAZXh0ck5hdGl2ZSgxMDUxKQIFBHRoaXMCDGlzX2F1dG9fZmVlcwAFb3duZXIJARFAZXh0ck5hdGl2ZSgxMDYyKQEJARFAZXh0ck5hdGl2ZSgxMDUzKQIFBHRoaXMCBW93bmVyAAV0b2tlbgkA2QQBCQERQGV4dHJOYXRpdmUoMTA1MykCBQR0aGlzAgV0b2tlbgAOdG9rZW5fcXVhbnRpdHkICQEFdmFsdWUBCQDsBwEFBXRva2VuCHF1YW50aXR5AAlpbml0aWFsX0EJARFAZXh0ck5hdGl2ZSgxMDUwKQIFBHRoaXMCCWluaXRpYWxfQQAIZnV0dXJlX0EJARFAZXh0ck5hdGl2ZSgxMDUwKQIFBHRoaXMCCGZ1dHVyZV9BAA5pbml0aWFsX0FfdGltZQkBC3ZhbHVlT3JFbHNlAgkAmggCBQR0aGlzAg5pbml0aWFsX0FfdGltZQAAAA1mdXR1cmVfQV90aW1lCQELdmFsdWVPckVsc2UCCQCaCAIFBHRoaXMCDWZ1dHVyZV9BX3RpbWUAAAAWYWRtaW5fYWN0aW9uc19kZWFkbGluZQkBC3ZhbHVlT3JFbHNlAgkAmggCBQR0aGlzAhZhZG1pbl9hY3Rpb25zX2RlYWRsaW5lAAAAG3RyYW5zZmVyX293bmVyc2hpcF9kZWFkbGluZQkBC3ZhbHVlT3JFbHNlAgkAmggCBQR0aGlzAht0cmFuc2Zlcl9vd25lcnNoaXBfZGVhZGxpbmUAAAAKZnV0dXJlX2ZlZQkBEUBleHRyTmF0aXZlKDEwNTApAgUEdGhpcwIKZnV0dXJlX2ZlZQAQZnV0dXJlX2FkbWluX2ZlZQkBEUBleHRyTmF0aXZlKDEwNTApAgUEdGhpcwIQZnV0dXJlX2FkbWluX2ZlZQAMZnV0dXJlX293bmVyCQERQGV4dHJOYXRpdmUoMTA1MykCBQR0aGlzAgxmdXR1cmVfb3duZXIACWlzX2tpbGxlZAkBEUBleHRyTmF0aXZlKDEwNTEpAgUEdGhpcwIJaXNfa2lsbGVkAA1raWxsX2RlYWRsaW5lCQERQGV4dHJOYXRpdmUoMTA1MCkCBQR0aGlzAg1raWxsX2RlYWRsaW5lABBLSUxMX0RFQURMSU5FX0RUCQBpAgkAaAIJAGgCAAIAHgCAowUAPAAEYmlnMAkAtgIBAAAABGJpZzEJALYCAQABAARiaWcyCQC2AgEAAgANaGVpZ2h0QWRkcmVzcwkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCmCAEJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAnQgCBQR0aGlzAg1oZWlnaHRBZGRyZXNzAhNubyBzZXR0aW5ncyBkZWZpbmVkAhRiYWQgc2V0dGluZ3MgYWRkcmVzcwAGSEVJR0hUBQZoZWlnaHQAD2Jsb2NrX3RpbWVzdGFtcAUGSEVJR0hUAQZhc3NlcnQBAWEDBQFhBwYBCWxpc3RfaXRvcwEEbGlzdAMJAGYCCQCQAwEFBGxpc3QFC05fQ09JTlNfTUFYCQACAQIkbGlzdF9pdG9zOiBsaXN0LnNpemUoKSA+IE5fQ09JTlNfTUFYCgEEZm9sZAIDYWNjA3ZhbAkAzQgCBQNhY2MJAKQDAQUDdmFsCgACJGwFBGxpc3QKAAIkcwkAkAMBBQIkbAoABSRhY2MwBQNuaWwKAQUkZjBfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBBGZvbGQCBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjBfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDEwCQEFJGYwXzICCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoBCWxpc3Rfc3RvaQEEbGlzdAMJAGYCCQCQAwEFBGxpc3QFC05fQ09JTlNfTUFYCQACAQIkbGlzdF9zdG9pOiBsaXN0LnNpemUoKSA+IE5fQ09JTlNfTUFYCgEEZm9sZAIDYWNjA3ZhbAkAzQgCBQNhY2MJAQ1wYXJzZUludFZhbHVlAQUDdmFsCgACJGwFBGxpc3QKAAIkcwkAkAMBBQIkbAoABSRhY2MwBQNuaWwKAQUkZjBfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBBGZvbGQCBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjBfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDEwCQEFJGYwXzICCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoACGJhbGFuY2VzCQEJbGlzdF9zdG9pAQkAtQkCCQERQGV4dHJOYXRpdmUoMTA1MykCBQR0aGlzAghiYWxhbmNlcwIBLAAFcmF0ZXMJAQlsaXN0X3N0b2kBCQC1CQIJARFAZXh0ck5hdGl2ZSgxMDUzKQIFBHRoaXMCBXJhdGVzAgEsAApyYXRlc19zaXplCQCQAwEFBXJhdGVzABFpbmRleF9OX0NPSU5TX01BWAkAzAgCAAAJAMwIAgABCQDMCAIAAgkAzAgCAAMJAMwIAgAECQDMCAIABQkAzAgCAAYJAMwIAgAHCQDMCAIACAkAzAgCAAkFA25pbAEHaW5kZXhfbgEBbgMJAGYCBQFuBQtOX0NPSU5TX01BWAkAAgECGGluZGV4X246IG4gPiBOX0NPSU5TX01BWAoBBGZvbGQCA2FjYwVpbmRleAMJAGYCBQFuBQVpbmRleAkAzQgCBQNhY2MFBWluZGV4BQNhY2MKAAIkbAURaW5kZXhfTl9DT0lOU19NQVgKAAIkcwkAkAMBBQIkbAoABSRhY2MwBQNuaWwKAQUkZjBfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBBGZvbGQCBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjBfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDEwCQEFJGYwXzICCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoADWluZGV4X05fQ09JTlMJAQdpbmRleF9uAQUHTl9DT0lOUwAPaW5kZXhfTl9DT0lOU18xCQDNCAIFDWluZGV4X05fQ09JTlMFB05fQ09JTlMBCGJpZ19saXN0AQRsaXN0AwkBAiE9AgkAkAMBBQRsaXN0BQdOX0NPSU5TCQACAQIgYmlnX2xpc3Q6IGxpc3Quc2l6ZSgpICE9IE5fQ09JTlMKAQRmb2xkAgNhY2MFaW5kZXgJAM0IAgUDYWNjCQC2AgEJAGsDCQCRAwIFBGxpc3QFBWluZGV4BQpUT0tFTl9SQVRFCQCRAwIFBXJhdGVzBQVpbmRleAoAAiRsBQ1pbmRleF9OX0NPSU5TCgACJHMJAJADAQUCJGwKAAUkYWNjMAUDbmlsCgEFJGYwXzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQRmb2xkAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGYwXzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxMAkBBSRmMF8yAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKAQpjb2luX2luZGV4AQdwYXltZW50BAckbWF0Y2gwCAUHcGF5bWVudAdhc3NldElkAwkAAQIFByRtYXRjaDACCkJ5dGVWZWN0b3IEB2Fzc2V0SWQFByRtYXRjaDAJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAzwgCBQVjb2lucwkA2AQBBQdhc3NldElkCQCsAgIJANgEAQUHYXNzZXRJZAIMIG91dCBvZiBwb29sCQACAQITdW5zdXBwb3J0ZWQgYXNzZXRJZAENYWRtaW5fYmFsYW5jZQEBaQMDCQBmAgAABQFpBgkAZgIFAWkFB05fQ09JTlMJAAIBAg5pIG91dCBvZiBpbmRleAkAZQIJAPAHAgUEdGhpcwkA2QQBCQCRAwIFBWNvaW5zBQFpCQCRAwIFCGJhbGFuY2VzBQFpAQxjaGVja0FkZHJlc3MBA2E1OAQBYQkBEUBleHRyTmF0aXZlKDEwNjIpAQUDYTU4CQClCAEFAWEBAl9BAAQCdDEFDWZ1dHVyZV9BX3RpbWUEAkExBQhmdXR1cmVfQQMJAGYCBQJ0MQUPYmxvY2tfdGltZXN0YW1wBAJBMAUJaW5pdGlhbF9BBAJ0MAUOaW5pdGlhbF9BX3RpbWUDCQBmAgUCQTEFAkEwCQBkAgUCQTAJAGkCCQBoAgkAZQIFAkExBQJBMAkAZQIFD2Jsb2NrX3RpbWVzdGFtcAUCdDAJAGUCBQJ0MQUCdDAJAGUCBQJBMAkAaQIJAGgCCQBlAgUCQTAFAkExCQBlAgUPYmxvY2tfdGltZXN0YW1wBQJ0MAkAZQIFAnQxBQJ0MAUCQTEBCGxpc3Rfc3VtAQRsaXN0CgEEZm9sZAIDYWNjA3ZhbAkAtwICBQNhY2MFA3ZhbAoAAiRsBQRsaXN0CgACJHMJAJADAQUCJGwKAAUkYWNjMAUEYmlnMAoBBSRmMF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEEZm9sZAIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQUkZjBfMgIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgEJbGlzdF9tdWx0AQRsaXN0CgEEZm9sZAIDYWNjA3ZhbAkAvAIDCQC8AgMFA2FjYwUDdmFsBQRiaWcxBQtOX0NPSU5TX2JpZwUEYmlnMQoAAiRsBQRsaXN0CgACJHMJAJADAQUCJGwKAAUkYWNjMAUEYmlnMQoBBSRmMF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEEZm9sZAIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQUkZjBfMgIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgAGbGlzdDE2CQDMCAIAAQkAzAgCAAIJAMwIAgADCQDMCAIABAkAzAgCAAUJAMwIAgAGCQDMCAIABwkAzAgCAAgJAMwIAgAJCQDMCAIACgkAzAgCAAsJAMwIAgAMCQDMCAIADQkAzAgCAA4JAMwIAgAPCQDMCAIAEAUDbmlsAQVnZXRfRAICeHADYW1wBAFTCQEIbGlzdF9zdW0BBQJ4cAMJAAACCQCgAwEFAVMAAAAABANBbm4JAGgCBQNhbXAFB05fQ09JTlMEBEFublMJALwCAwkAtgIBBQNBbm4FAVMFBGJpZzEEBEFubjEJALYCAQkAZQIFA0FubgABBAJ4ZAkBCWxpc3RfbXVsdAEFAnhwBAlOX0NPSU5TXzEJAGQCBQdOX0NPSU5TAAEEDU5fQ09JTlNfMV9iaWcJALYCAQUJTl9DT0lOU18xCgEGRF9tdWx0AQN2YWwKAQRmb2xkAgNhY2MFaW5kZXgJALwCAwUDYWNjBQN2YWwFBGJpZzEKAAIkbAUPaW5kZXhfTl9DT0lOU18xCgACJHMJAJADAQUCJGwKAAUkYWNjMAUEYmlnMQoBBSRmMF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEEZm9sZAIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQUkZjBfMgIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgoBBkRfcHJvYwIDYWNjBnVudXNlZAMJAAACCAUDYWNjAl8yBgUDYWNjBAVEcHJldggFA2FjYwJfMQQDRF9QCQC8AgMJAQZEX211bHQBBQVEcHJldgUEYmlnMQUCeGQEAUQJALwCAwkAtwICBQRBbm5TCQC8AgMFC05fQ09JTlNfYmlnBQNEX1AFBGJpZzEFBURwcmV2CQC3AgIJALwCAwUEQW5uMQUFRHByZXYFBGJpZzEJALwCAwUNTl9DT0lOU18xX2JpZwUDRF9QBQRiaWcxAwkAvwICBQFEBQVEcHJldgMJAGcCAAEJAKADAQkAuAICBQFEBQVEcHJldgkAlAoCBQFEBgkAlAoCBQFEBwMJAGcCAAEJAKADAQkAuAICBQVEcHJldgUBRAkAlAoCBQFEBgkAlAoCBQFEBwQLJHQwNjA0NDYxMDYKAAIkbAUGbGlzdDE2CgACJHMJAJADAQUCJGwKAAUkYWNjMAkAlAoCBQFTBwoBBSRmMF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEGRF9wcm9jAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGYwXzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxNgkBBSRmMF8yAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKAAsADAANAA4ADwAQBAFECAULJHQwNjA0NDYxMDYCXzEECGZpbmlzaGVkCAULJHQwNjA0NDYxMDYCXzIDCQAAAgUIZmluaXNoZWQHCQACAQkArAICAhtEX3Byb2MoKSBub3QgZmluaXNoZWQgd2l0aCAJAKYDAQUBRAkAoAMBBQFEAQVnZXRfeQQBaQFqAXgCeHADCQEGYXNzZXJ0AQkBAiE9AgUBaQUBagkAAgECCXNhbWUgY29pbgMJAQZhc3NlcnQBAwkAZwIFAWoAAAkAZwIFAWkAAAcJAAIBAgpiZWxvdyB6ZXJvAwkBBmFzc2VydAEDCQBmAgUHTl9DT0lOUwUBagkAZgIFB05fQ09JTlMFAWkHCQACAQINYWJvdmUgTl9DT0lOUwQDYW1wCQECX0EABAFECQEFZ2V0X0QCBQJ4cAUDYW1wBAVEX2JpZwkAtgIBBQFEBAdBbm5fYmlnCQC2AgEJAGgCBQNhbXAFB05fQ09JTlMKAQNTX2MCA2FjYwVpbmRleAQLJHQwNjcxODY3MzcFA2FjYwQCU18IBQskdDA2NzE4NjczNwJfMQQBYwgFCyR0MDY3MTg2NzM3Al8yBAJ4XwMJAAACBQVpbmRleAUBaQkAtgIBCQBrAwUBeAUKVE9LRU5fUkFURQkAkQMCBQVyYXRlcwUFaW5kZXgJAJEDAgUCeHAFBWluZGV4AwkBAiE9AgUFaW5kZXgFAWoJAJQKAgkAtwICBQJTXwUCeF8JALwCAwUBYwUFRF9iaWcJALwCAwUCeF8FC05fQ09JTlNfYmlnBQRiaWcxCQCUCgIFAlNfBQFjBAskdDA3MDEzNzA3NwoAAiRsBQ1pbmRleF9OX0NPSU5TCgACJHMJAJADAQUCJGwKAAUkYWNjMAkAlAoCBQRiaWcwBQVEX2JpZwoBBSRmMF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEDU19jAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGYwXzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxMAkBBSRmMF8yAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKBAJTXwgFCyR0MDcwMTM3MDc3Al8xBAJjXwgFCyR0MDcwMTM3MDc3Al8yBAFjCQC8AgMFAmNfBQVEX2JpZwkAvAIDBQdBbm5fYmlnBQtOX0NPSU5TX2JpZwUEYmlnMQQCYkQJALgCAgkAtwICBQJTXwkAvAIDBQVEX2JpZwUEYmlnMQUHQW5uX2JpZwUFRF9iaWcKAQZ5X3Byb2MCA2FjYwZ1bnVzZWQDCQAAAggFA2FjYwJfMgYFA2FjYwQGeV9wcmV2CAUDYWNjAl8xBAF5CQC8AgMJALcCAgkAvAIDBQZ5X3ByZXYFBnlfcHJldgUEYmlnMQUBYwUEYmlnMQkAtwICCQC8AgMFBGJpZzIFBnlfcHJldgUEYmlnMQUCYkQDCQC/AgIFAXkFBnlfcHJldgMJAGcCAAEJAKADAQkAuAICBQF5BQZ5X3ByZXYJAJQKAgUBeQYJAJQKAgUBeQcDCQBnAgABCQCgAwEJALgCAgUGeV9wcmV2BQF5CQCUCgIFAXkGCQCUCgIFAXkHBAskdDA3NjU3NzcyMwoAAiRsBQZsaXN0MTYKAAIkcwkAkAMBBQIkbAoABSRhY2MwCQCUCgIFBURfYmlnBwoBBSRmMV8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEGeV9wcm9jAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGYxXzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxNgkBBSRmMV8yAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgkBBSRmMV8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKAAsADAANAA4ADwAQBAF5CAULJHQwNzY1Nzc3MjMCXzEECGZpbmlzaGVkCAULJHQwNzY1Nzc3MjMCXzIDCQAAAgUIZmluaXNoZWQHCQACAQkArAICAht5X3Byb2MoKSBub3QgZmluaXNoZWQgd2l0aCAJAKYDAQUBeQkAlAoCCQBrAwkAoAMBBQF5CQCRAwIFBXJhdGVzBQFqBQpUT0tFTl9SQVRFBQFEAQdnZXRfeV9EBANhbXABaQJ4cAFEAwkBBmFzc2VydAEJAGcCBQFpAAAJAAIBAgxpIGJlbG93IHplcm8DCQEGYXNzZXJ0AQkAZgIFB05fQ09JTlMFAWkJAAIBAg9pIGFib3ZlIE5fQ09JTlMEBURfYmlnCQC2AgEFAUQEB0Fubl9iaWcJALYCAQkAaAIFA2FtcAUHTl9DT0lOUwoBA1NfYwIDYWNjBWluZGV4BAskdDA4MjI4ODI0NwUDYWNjBAJTXwgFCyR0MDgyMjg4MjQ3Al8xBAFjCAULJHQwODIyODgyNDcCXzIEAnhfAwkAAAIFBWluZGV4BQFpBQRiaWcwCQCRAwIFAnhwBQVpbmRleAMJAQIhPQIFBWluZGV4BQFpCQCUCgIJALcCAgUCU18FAnhfCQC8AgMFAWMFBURfYmlnCQC8AgMFAnhfBQtOX0NPSU5TX2JpZwUEYmlnMQkAlAoCBQJTXwUBYwQLJHQwODQ3Nzg1NDEKAAIkbAUNaW5kZXhfTl9DT0lOUwoAAiRzCQCQAwEFAiRsCgAFJGFjYzAJAJQKAgUEYmlnMAUFRF9iaWcKAQUkZjBfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBA1NfYwIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQUkZjBfMgIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgQCU18IBQskdDA4NDc3ODU0MQJfMQQCY18IBQskdDA4NDc3ODU0MQJfMgQBYwkAvAIDBQJjXwUFRF9iaWcJALwCAwUHQW5uX2JpZwULTl9DT0lOU19iaWcFBGJpZzEEAmJECQC4AgIJALcCAgUCU18JALwCAwUFRF9iaWcFBGJpZzEFB0Fubl9iaWcFBURfYmlnCgEGeV9wcm9jAgNhY2MGdW51c2VkAwkAAAIIBQNhY2MCXzIGBQNhY2MEBnlfcHJldggFA2FjYwJfMQQBeQkAvAIDCQC3AgIJALwCAwUGeV9wcmV2BQZ5X3ByZXYFBGJpZzEFAWMFBGJpZzEJALcCAgkAvAIDBQRiaWcyBQZ5X3ByZXYFBGJpZzEFAmJEAwkAvwICBQF5BQZ5X3ByZXYDCQBnAgABCQCgAwEJALgCAgUBeQUGeV9wcmV2CQCUCgIFAXkGCQCUCgIFAXkHAwkAZwIAAQkAoAMBCQC4AgIFBnlfcHJldgUBeQkAlAoCBQF5BgkAlAoCBQF5BwQLJHQwOTEyMTkxODcKAAIkbAUGbGlzdDE2CgACJHMJAJADAQUCJGwKAAUkYWNjMAkAlAoCBQVEX2JpZwcKAQUkZjFfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBBnlfcHJvYwIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMV8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTYJAQUkZjFfMgIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgALAAwADQAOAA8AEAQBeQgFCyR0MDkxMjE5MTg3Al8xBAhmaW5pc2hlZAgFCyR0MDkxMjE5MTg3Al8yAwkAAAIFCGZpbmlzaGVkBwkAAgEJAKwCAgIbeV9wcm9jKCkgbm90IGZpbmlzaGVkIHdpdGggCQCmAwEFAXkJAGsDCQCgAwEFAXkJAJEDAgUFcmF0ZXMFAWkFClRPS0VOX1JBVEUBF19jYWxjX3dpdGhkcmF3X29uZV9jb2luAg1fdG9rZW5fYW1vdW50AWkEA2FtcAkBAl9BAAQEX2ZlZQkAaQIJAGgCBQNmZWUFB05fQ09JTlMJAGgCAAQJAGUCBQdOX0NPSU5TAAEEAnhwCQEIYmlnX2xpc3QBBQhiYWxhbmNlcwQCRDAJAQVnZXRfRAIFAnhwBQNhbXAEAkQxCQBlAgUCRDAJAGsDBQ1fdG9rZW5fYW1vdW50BQJEMAUOdG9rZW5fcXVhbnRpdHkEBW5ld195CQEHZ2V0X3lfRAQFA2FtcAUBaQUCeHAFAkQxBARkeV8wCQBlAgkAkQMCBQhiYWxhbmNlcwUBaQUFbmV3X3kKAQRmb2xkAgNhY2MFaW5kZXgEBHhwX2oJAJEDAgUIYmFsYW5jZXMFBWluZGV4BAtkeF9leHBlY3RlZAMJAAACBQVpbmRleAUBaQkAZQIJAGsDBQR4cF9qBQJEMQUCRDAFBW5ld195CQBlAgUEeHBfagkAawMFBHhwX2oFAkQxBQJEMAkAzQgCBQNhY2MJAGUCBQR4cF9qCQBrAwUEX2ZlZQULZHhfZXhwZWN0ZWQFD0ZFRV9ERU5PTUlOQVRPUgQKeHBfcmVkdWNlZAoAAiRsBQ1pbmRleF9OX0NPSU5TCgACJHMJAJADAQUCJGwKAAUkYWNjMAUDbmlsCgEFJGYwXzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQRmb2xkAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGYwXzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxMAkBBSRmMF8yAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKBAx4cF9yZWR1Y2VkX2kJAJEDAgUKeHBfcmVkdWNlZAUBaQQCZHkJAGUCCQBlAgUMeHBfcmVkdWNlZF9pCQEHZ2V0X3lfRAQFA2FtcAUBaQkBCGJpZ19saXN0AQUKeHBfcmVkdWNlZAUCRDEAAQkAlQoDBQJkeQkAZQIFBGR5XzAFAmR5BQJEMAENdmlydHVhbF9wcmljZQEBRAkAawMFAUQFDFZQX1BSRUNJU0lPTgUOdG9rZW5fcXVhbnRpdHkBCGxvZ19kYXRhAgFEA2FkZAQJdG90YWxfdm9sCQC3AgIJAKcDAQkBC3ZhbHVlT3JFbHNlAgkAoggBAgN2b2wCATAJALYCAQUDYWRkBBB0b3RhbF92b2xfc3RyaW5nCQCmAwEFCXRvdGFsX3ZvbAkAzggCCQDMCAIJAQtTdHJpbmdFbnRyeQICA3ZvbAUQdG90YWxfdm9sX3N0cmluZwUDbmlsBApsb2dfcGVyaW9kCQCkAwEJAGkCCAUJbGFzdEJsb2NrCXRpbWVzdGFtcAUNVlBfTE9HX1BFUklPRAQHbG9nX2tleQkArAICAgRsb2dfBQpsb2dfcGVyaW9kAwkBCWlzRGVmaW5lZAEJAKIIAQUHbG9nX2tleQUDbmlsCQDMCAIJAQtTdHJpbmdFbnRyeQIFB2xvZ19rZXkJAKwCAgkArAICCQCsAgIJAKwCAgkApAMBCQENdmlydHVhbF9wcmljZQEFAUQCAV8FEHRvdGFsX3ZvbF9zdHJpbmcCAV8JAKQDAQgFCWxhc3RCbG9jawl0aW1lc3RhbXAFA25pbAEPZ2V0X25lYXJlc3RfbG9nAQZwZXJpb2QKAQRmb2xkAglsb2dfdmFsdWUEc3RlcAMJAQIhPQIFCWxvZ192YWx1ZQIABQlsb2dfdmFsdWUEB2xvZ19rZXkJAKwCAgIEbG9nXwkApAMBCQBlAgUGcGVyaW9kBQRzdGVwCQELdmFsdWVPckVsc2UCCQCiCAEFB2xvZ19rZXkCAAQHbGlzdDMwcAkAzAgCAAAJAMwIAgABCQDMCAIAAgkAzAgCAAMJAMwIAgAECQDMCAIABQkAzAgCAAYJAMwIAgAHCQDMCAIACAkAzAgCAAkJAMwIAgAKCQDMCAIACwkAzAgCAAwJAMwIAgANCQDMCAIADgkAzAgCAA8JAMwIAgAQCQDMCAIAEQkAzAgCABIJAMwIAgATCQDMCAIAFAkAzAgCABUJAMwIAgAWCQDMCAIAFwkAzAgCABgJAMwIAgAZCQDMCAIAGgkAzAgCABsJAMwIAgAcCQDMCAIAHQUDbmlsBAdsaXN0MzBtCQDMCAIA////////////AQkAzAgCAP7//////////wEJAMwIAgD9//////////8BCQDMCAIA/P//////////AQkAzAgCAPv//////////wEJAMwIAgD6//////////8BCQDMCAIA+f//////////AQkAzAgCAPj//////////wEJAMwIAgD3//////////8BCQDMCAIA9v//////////AQkAzAgCAPX//////////wEJAMwIAgD0//////////8BCQDMCAIA8///////////AQkAzAgCAPL//////////wEJAMwIAgDx//////////8BCQDMCAIA8P//////////AQkAzAgCAO///////////wEJAMwIAgDu//////////8BCQDMCAIA7f//////////AQkAzAgCAOz//////////wEJAMwIAgDr//////////8BCQDMCAIA6v//////////AQkAzAgCAOn//////////wEJAMwIAgDo//////////8BCQDMCAIA5///////////AQkAzAgCAOb//////////wEJAMwIAgDl//////////8BCQDMCAIA5P//////////AQkAzAgCAOP//////////wEJAMwIAgDi//////////8BBQNuaWwECHZhbHVlMzBwCgACJGwFB2xpc3QzMHAKAAIkcwkAkAMBBQIkbAoABSRhY2MwAgAKAQUkZjBfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBBGZvbGQCBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjBfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDMwCQEFJGYwXzICCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoACwAMAA0ADgAPABAAEQASABMAFAAVABYAFwAYABkAGgAbABwAHQAeAwkBAiE9AgUIdmFsdWUzMHACAAUIdmFsdWUzMHAKAAIkbAUHbGlzdDMwbQoAAiRzCQCQAwEFAiRsCgAFJGFjYzACAAoBBSRmMV8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEEZm9sZAIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMV8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMzAJAQUkZjFfMgIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIJAQUkZjFfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgALAAwADQAOAA8AEAARABIAEwAUABUAFgAXABgAGQAaABsAHAAdAB4BFmdldF92aXJ0dWFsX3ByaWNlX2RpZmYBA190MAQDdnAxCQENdmlydHVhbF9wcmljZQEJAQVnZXRfRAIJAQhiaWdfbGlzdAEFCGJhbGFuY2VzCQECX0EABA12cDFfdGltZXN0YW1wCAUJbGFzdEJsb2NrCXRpbWVzdGFtcAQCdDADCQBnAgAABQNfdDAJAGQCBQ12cDFfdGltZXN0YW1wBQNfdDAFA190MAQJdDBfcGVyaW9kCQBpAgUCdDAFDVZQX0xPR19QRVJJT0QECWxvZ192YWx1ZQkBD2dldF9uZWFyZXN0X2xvZwEFCXQwX3BlcmlvZAMJAAACBQlsb2dfdmFsdWUCAAkAlQoDBQN2cDEFA3ZwMQAABAhsb2dfbGlzdAkAtQkCBQlsb2dfdmFsdWUCAV8EA3ZwMAkBDXBhcnNlSW50VmFsdWUBCQCRAwIFCGxvZ19saXN0AAAEDXZwMF90aW1lc3RhbXAJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQhsb2dfbGlzdAACCQCVCgMFA3ZwMQUDdnAwCQBlAgUNdnAxX3RpbWVzdGFtcAUNdnAwX3RpbWVzdGFtcAEPZ2V0X3ZvbHVtZV9kaWZmAQNfdDAEBHZvbDEJAKcDAQkBC3ZhbHVlT3JFbHNlAgkAoggBAgN2b2wCATAEDnZvbDFfdGltZXN0YW1wCAUJbGFzdEJsb2NrCXRpbWVzdGFtcAQCdDADCQBnAgAABQNfdDAJAGQCBQ52b2wxX3RpbWVzdGFtcAUDX3QwBQNfdDAECXQwX3BlcmlvZAkAaQIFAnQwBQ1WUF9MT0dfUEVSSU9EBAlsb2dfdmFsdWUJAQ9nZXRfbmVhcmVzdF9sb2cBBQl0MF9wZXJpb2QDCQAAAgUJbG9nX3ZhbHVlAgAJAJUKAwUEdm9sMQUEdm9sMQAABAhsb2dfbGlzdAkAtQkCBQlsb2dfdmFsdWUCAV8EBHZvbDAJAKcDAQkAkQMCBQhsb2dfbGlzdAABBA52b2wwX3RpbWVzdGFtcAkBDXBhcnNlSW50VmFsdWUBCQCRAwIFCGxvZ19saXN0AAIJAJUKAwUEdm9sMQUEdm9sMAkAZQIFDnZvbDFfdGltZXN0YW1wBQ52b2wwX3RpbWVzdGFtcBoDbXNnAQRpbml0BgZfb3duZXIGX2NvaW5zC19wb29sX3Rva2VuAl9BBF9mZWUKX2FkbWluX2ZlZQMJAQEhAQkAnggBBQR0aGlzCQACAQITYWxyZWFkeSBpbml0aWFsaXplZAMJAQIhPQIIBQNtc2cGY2FsbGVyBQR0aGlzCQACAQIYc2VsZiBpbml0aWFsaXphdGlvbiBvbmx5BApjb2luc19saXN0CQC1CQIFBl9jb2lucwIBLAQBbgkAkAMBBQpjb2luc19saXN0AwkAZgIAAgUBbgkAAgECD3RvbyBzbWFsbCBjb2lucwMJAGYCBQFuBQtOX0NPSU5TX01BWAkAAgECDnRvbyBtYW55IGNvaW5zCgEKZHVwbGljYXRlcwIDYWNjBWluZGV4AwMJAGcCBQVpbmRleAUBbgYJAAACBQNhY2MHBQNhY2MJAAACCQDPCAIFCmNvaW5zX2xpc3QJAJEDAgUKY29pbnNfbGlzdAUFaW5kZXgFBWluZGV4AwkAAAIHCgACJGwFEWluZGV4X05fQ09JTlNfTUFYCgACJHMJAJADAQUCJGwKAAUkYWNjMAYKAQUkZjBfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBCmR1cGxpY2F0ZXMCBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjBfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDEwCQEFJGYwXzICCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoJAAIBAhdkdXBsaWNhdGUgY29pbiBkZXRlY3RlZAoBCGRlY2ltYWxzAQRjb2luCAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQDsBwEJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkA2QQBBQRjb2luCQCsAgICEmZyb21CYXNlNThTdHJpbmc6IAUEY29pbgkArAICAgthc3NldEluZm86IAUEY29pbghkZWNpbWFscwoBBGZvbGQCA2FjYwRjb2luCQCVCgMJAGQCCAUDYWNjAl8xAAEJAM0IAggFA2FjYwJfMgAACQDNCAIIBQNhY2MCXzMJAGwGAAoAAAkBCGRlY2ltYWxzAQUEY29pbgAAAAAFBERPV04EDSR0MDEzNzYyMTM4NTcKAAIkbAUKY29pbnNfbGlzdAoAAiRzCQCQAwEFAiRsCgAFJGFjYzAJAJUKAwAABQNuaWwFA25pbAoBBSRmMF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEEZm9sZAIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQUkZjBfMgIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgQIX05fQ09JTlMIBQ0kdDAxMzc2MjEzODU3Al8xBAV6ZXJvcwgFDSR0MDEzNzYyMTM4NTcCXzIEBl9yYXRlcwgFDSR0MDEzNzYyMTM4NTcCXzMECmlzc3VlVG9rZW4JAMIIBQULX3Bvb2xfdG9rZW4JAKwCAgINTFAgdG9rZW4gZm9yIAUGX2NvaW5zAAAFDlRPS0VOX0RFQ0lNQUxTBgQHdG9rZW5JZAkA2AQBCQC4CAEFCmlzc3VlVG9rZW4JAMwIAgkBC1N0cmluZ0VudHJ5AgIFY29pbnMFBl9jb2lucwkAzAgCCQELU3RyaW5nRW50cnkCAgVyYXRlcwkAuQkCCQEJbGlzdF9pdG9zAQUGX3JhdGVzAgEsCQDMCAIJAQtTdHJpbmdFbnRyeQICCGJhbGFuY2VzCQC5CQIJAQlsaXN0X2l0b3MBBQV6ZXJvcwIBLAkAzAgCCQEMSW50ZWdlckVudHJ5AgIHTl9DT0lOUwUIX05fQ09JTlMJAMwIAgkBDEludGVnZXJFbnRyeQICCWluaXRpYWxfQQUCX0EJAMwIAgkBDEludGVnZXJFbnRyeQICCGZ1dHVyZV9BBQJfQQkAzAgCCQEMSW50ZWdlckVudHJ5AgIDZmVlBQRfZmVlCQDMCAIJAQxJbnRlZ2VyRW50cnkCAglhZG1pbl9mZWUFCl9hZG1pbl9mZWUJAMwIAgkBC1N0cmluZ0VudHJ5AgIFb3duZXIJAQxjaGVja0FkZHJlc3MBBQZfb3duZXIJAMwIAgkBDEludGVnZXJFbnRyeQICDWtpbGxfZGVhZGxpbmUJAGQCBQZoZWlnaHQFEEtJTExfREVBRExJTkVfRFQJAMwIAgkBC1N0cmluZ0VudHJ5AgIFdG9rZW4FB3Rva2VuSWQJAMwIAgkBDEJvb2xlYW5FbnRyeQICCWlzX2tpbGxlZAcJAMwIAgkBDEJvb2xlYW5FbnRyeQICDGlzX2F1dG9fZmVlcwYJAMwIAgUKaXNzdWVUb2tlbgUDbmlsA21zZwENYWRkX2xpcXVpZGl0eQEPbWluX21pbnRfYW1vdW50AwkBBmFzc2VydAEJAQEhAQUJaXNfa2lsbGVkCQACAQIJaXMga2lsbGVkBANhbXAJAQJfQQAEDHRva2VuX3N1cHBseQUOdG9rZW5fcXVhbnRpdHkEAkQwAwkAAAIFDHRva2VuX3N1cHBseQAAAAAJAQVnZXRfRAIJAQhiaWdfbGlzdAEFCGJhbGFuY2VzBQNhbXAKARB1cGRhdGVfMV9iYWxhbmNlAwRiYXNlBnRhcmdldAZhbW91bnQKAQRmb2xkAgNhY2MFaW5kZXgJAM0IAgUDYWNjCQBkAgkAkQMCBQRiYXNlBQVpbmRleAMJAAACBQVpbmRleAUGdGFyZ2V0BQZhbW91bnQAAAoAAiRsBQ1pbmRleF9OX0NPSU5TCgACJHMJAJADAQUCJGwKAAUkYWNjMAUDbmlsCgEFJGYwXzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQRmb2xkAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGYwXzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxMAkBBSRmMF8yAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKCgELdXBfYmFsYW5jZXMCBGJhc2UIcGF5bWVudHMEAW4JAJADAQUIcGF5bWVudHMDCQBmAgABBQFuCQACAQIRcGF5bWVudHMgc2l6ZSA8IDEDCQBmAgUBbgULTl9DT0lOU19NQVgJAAIBAhtwYXltZW50cyBzaXplID4gTl9DT0lOU19NQVgKAQRmb2xkAgNhY2MHcGF5bWVudAkBEHVwZGF0ZV8xX2JhbGFuY2UDBQNhY2MJAQpjb2luX2luZGV4AQUHcGF5bWVudAgFB3BheW1lbnQGYW1vdW50CgACJGwFCHBheW1lbnRzCgACJHMJAJADAQUCJGwKAAUkYWNjMAUEYmFzZQoBBSRmMF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEEZm9sZAIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQUkZjBfMgIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgQMbmV3X2JhbGFuY2VzCQELdXBfYmFsYW5jZXMCBQhiYWxhbmNlcwgFA21zZwhwYXltZW50cwMDCQAAAgUMdG9rZW5fc3VwcGx5AAAJAAACCQCXAwEFDG5ld19iYWxhbmNlcwAABwkAAgECImluaXRpYWwgZGVwb3NpdCByZXF1aXJlcyBhbGwgY29pbnMEAkQxCQEFZ2V0X0QCCQEIYmlnX2xpc3QBBQxuZXdfYmFsYW5jZXMFA2FtcAMJAQZhc3NlcnQBCQBmAgUCRDEFAkQwCQACAQIHRDEgPiBEMAQNJHQwMTYwMDkxODAxMAMJAGYCBQx0b2tlbl9zdXBwbHkAAAoBDGZlZV9iYWxhbmNlcwIDb2xkA25ldwQEX2ZlZQkAaQIJAGgCBQNmZWUFB05fQ09JTlMJAGgCAAQJAGUCBQdOX0NPSU5TAAEEAW4JAJADAQUDb2xkCgEEZm9sZAIDYWNjBWluZGV4BAtvbGRfYmFsYW5jZQkAkQMCBQNvbGQFBWluZGV4BAtuZXdfYmFsYW5jZQkAkQMCBQNuZXcFBWluZGV4BA1pZGVhbF9iYWxhbmNlCQBrAwUCRDEFC29sZF9iYWxhbmNlBQJEMAQKZGlmZmVyZW5jZQMJAGYCBQ1pZGVhbF9iYWxhbmNlBQtuZXdfYmFsYW5jZQkAZQIFDWlkZWFsX2JhbGFuY2UFC25ld19iYWxhbmNlCQBlAgULbmV3X2JhbGFuY2UFDWlkZWFsX2JhbGFuY2UECmFtb3VudF9mZWUJAGsDBQRfZmVlBQpkaWZmZXJlbmNlBQ9GRUVfREVOT01JTkFUT1IEEGFtb3VudF9hZG1pbl9mZWUJAGsDBQphbW91bnRfZmVlBQlhZG1pbl9mZWUFD0ZFRV9ERU5PTUlOQVRPUgkAlgoECQDNCAIIBQNhY2MCXzEJAGUCBQtuZXdfYmFsYW5jZQUQYW1vdW50X2FkbWluX2ZlZQkAzQgCCAUDYWNjAl8yCQBlAgULbmV3X2JhbGFuY2UFCmFtb3VudF9mZWUDAwUMaXNfYXV0b19mZWVzCQBmAgUQYW1vdW50X2FkbWluX2ZlZQAABwkAzQgCCAUDYWNjAl8zCQEOU2NyaXB0VHJhbnNmZXIDBQVvd25lcgUQYW1vdW50X2FkbWluX2ZlZQkA2QQBCQCRAwIFBWNvaW5zBQVpbmRleAgFA2FjYwJfMwkAZAIIBQNhY2MCXzQJAGsDBQphbW91bnRfZmVlBQpUT0tFTl9SQVRFCQCRAwIFBXJhdGVzBQVpbmRleAoAAiRsBQ1pbmRleF9OX0NPSU5TCgACJHMJAJADAQUCJGwKAAUkYWNjMAkAlgoEBQNuaWwFA25pbAUDbmlsAAAKAQUkZjBfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBBGZvbGQCBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjBfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDEwCQEFJGYwXzICCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoEDSR0MDE3NTgxMTc2NjMJAQxmZWVfYmFsYW5jZXMCBQhiYWxhbmNlcwUMbmV3X2JhbGFuY2VzBAZmaW5hbHMIBQ0kdDAxNzU4MTE3NjYzAl8xBAdub19mZWVzCAUNJHQwMTc1ODExNzY2MwJfMgQHYWN0aW9ucwgFDSR0MDE3NTgxMTc2NjMCXzMEB2ZlZV9zdW0IBQ0kdDAxNzU4MTE3NjYzAl80CQCVCgMFBmZpbmFscwkBBWdldF9EAgkBCGJpZ19saXN0AQUHbm9fZmVlcwUDYW1wCQDOCAIFB2FjdGlvbnMJAQhsb2dfZGF0YQIFAkQwCQBrAwUHZmVlX3N1bQUPRkVFX0RFTk9NSU5BVE9SBQNmZWUJAJUKAwUMbmV3X2JhbGFuY2VzBQJEMQUDbmlsBA5maW5hbF9iYWxhbmNlcwgFDSR0MDE2MDA5MTgwMTACXzEEAkQyCAUNJHQwMTYwMDkxODAxMAJfMgQMZmVlc19hY3Rpb25zCAUNJHQwMTYwMDkxODAxMAJfMwQLbWludF9hbW91bnQDCQAAAgUMdG9rZW5fc3VwcGx5AAAFAkQxCQBrAwUMdG9rZW5fc3VwcGx5CQBlAgUCRDIFAkQwBQJEMAMJAQZhc3NlcnQBCQBnAgULbWludF9hbW91bnQFD21pbl9taW50X2Ftb3VudAkAAgECFHNsaXBwYWdlIHNjcmV3ZWQgeW91CQDOCAIJAMwIAgkBC1N0cmluZ0VudHJ5AgIIYmFsYW5jZXMJALkJAgkBCWxpc3RfaXRvcwEFDmZpbmFsX2JhbGFuY2VzAgEsCQDMCAIJAQdSZWlzc3VlAwUFdG9rZW4FC21pbnRfYW1vdW50BgkAzAgCCQEOU2NyaXB0VHJhbnNmZXIDCAUDbXNnBmNhbGxlcgULbWludF9hbW91bnQFBXRva2VuBQNuaWwFDGZlZXNfYWN0aW9ucwNtc2cBBmdldF9keQMBaQFqAmR4BAR4cF9pCQCRAwIFCGJhbGFuY2VzBQFpBAR4cF9qCQCRAwIFCGJhbGFuY2VzBQFqBAF4CQBkAgUEeHBfaQUCZHgEDSR0MDE4NjAzMTg2NTYJAQVnZXRfeQQFAWkFAWoFAXgJAQhiaWdfbGlzdAEFCGJhbGFuY2VzBAF5CAUNJHQwMTg2MDMxODY1NgJfMQQBRAgFDSR0MDE4NjAzMTg2NTYCXzIEA19keQkAZQIJAGUCBQR4cF9qBQF5AAEEBmR5X2ZlZQkAawMFA19keQUDZmVlBQ9GRUVfREVOT01JTkFUT1IEAmR5CQBlAgUDX2R5BQZkeV9mZWUJAJQKAgUDbmlsBQJkeQNtc2cBCGV4Y2hhbmdlAgFqBm1pbl9keQMJAQZhc3NlcnQBCQEBIQEFCWlzX2tpbGxlZAkAAgECCWlzIGtpbGxlZAMJAQIhPQIJAJADAQgFA21zZwhwYXltZW50cwABCQACAQIVc2l6ZSggcGF5bWVudHMgKSAhPSAxBAdwYXltZW50CQCRAwIIBQNtc2cIcGF5bWVudHMAAAQCZHgIBQdwYXltZW50BmFtb3VudAQBaQkBCmNvaW5faW5kZXgBBQdwYXltZW50BAR4cF9pCQCRAwIFCGJhbGFuY2VzBQFpBAR4cF9qCQCRAwIFCGJhbGFuY2VzBQFqBAF4CQBkAgUEeHBfaQUCZHgEDSR0MDE5MTYyMTkyMTUJAQVnZXRfeQQFAWkFAWoFAXgJAQhiaWdfbGlzdAEFCGJhbGFuY2VzBAF5CAUNJHQwMTkxNjIxOTIxNQJfMQQBRAgFDSR0MDE5MTYyMTkyMTUCXzIEA19keQkAZQIJAGUCBQR4cF9qBQF5AAEEBmR5X2ZlZQkAawMFA19keQUDZmVlBQ9GRUVfREVOT01JTkFUT1IEAmR5CQBlAgUDX2R5BQZkeV9mZWUDCQEGYXNzZXJ0AQkAZwIFAmR5BQZtaW5fZHkJAAIBAi5leGNoYW5nZSByZXN1bHRlZCBpbiBmZXdlciBjb2lucyB0aGFuIGV4cGVjdGVkBAxkeV9hZG1pbl9mZWUJAGsDBQZkeV9mZWUFCWFkbWluX2ZlZQUPRkVFX0RFTk9NSU5BVE9SCgEEZm9sZAIDYWNjBWluZGV4CQDNCAIFA2FjYwMJAAACBQVpbmRleAUBaQkAZAIJAJEDAgUIYmFsYW5jZXMFBWluZGV4BQJkeAMJAAACBQVpbmRleAUBagkAZQIJAGUCCQCRAwIFCGJhbGFuY2VzBQVpbmRleAUCZHkFDGR5X2FkbWluX2ZlZQkAkQMCBQhiYWxhbmNlcwUFaW5kZXgEDmZpbmFsX2JhbGFuY2VzCgACJGwFDWluZGV4X05fQ09JTlMKAAIkcwkAkAMBBQIkbAoABSRhY2MwBQNuaWwKAQUkZjBfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBBGZvbGQCBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjBfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDEwCQEFJGYwXzICCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoECHRva2VuT3V0CQDZBAEJAJEDAgUFY29pbnMFAWoJAJQKAgkAzggCCQDOCAIJAMwIAgkBC1N0cmluZ0VudHJ5AgIIYmFsYW5jZXMJALkJAgkBCWxpc3RfaXRvcwEFDmZpbmFsX2JhbGFuY2VzAgEsCQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMIBQNtc2cGY2FsbGVyBQJkeQUIdG9rZW5PdXQFA25pbAMDBQxpc19hdXRvX2ZlZXMJAGYCBQxkeV9hZG1pbl9mZWUAAAcJAMwIAgkBDlNjcmlwdFRyYW5zZmVyAwUFb3duZXIFDGR5X2FkbWluX2ZlZQUIdG9rZW5PdXQFA25pbAUDbmlsCQEIbG9nX2RhdGECBQFECQBrAwUCZHgFClRPS0VOX1JBVEUJAJEDAgUFcmF0ZXMFAWkFAmR5A21zZwEQcmVtb3ZlX2xpcXVpZGl0eQEMX21pbl9hbW91bnRzAwkBAiE9AgkAkAMBCAUDbXNnCHBheW1lbnRzAAEJAAIBAhVzaXplKCBwYXltZW50cyApICE9IDEEB3BheW1lbnQJAJEDAggFA21zZwhwYXltZW50cwAAAwkBAiE9AggFB3BheW1lbnQHYXNzZXRJZAUFdG9rZW4JAAIBAg11bmtub3duIHRva2VuBAttaW5fYW1vdW50cwMJAAACBQxfbWluX2Ftb3VudHMCATAFA25pbAkBCWxpc3Rfc3RvaQEJALUJAgUMX21pbl9hbW91bnRzAgEsAwMJAQIhPQIFDF9taW5fYW1vdW50cwIBMAkBAiE9AgkAkAMBBQttaW5fYW1vdW50cwUHTl9DT0lOUwcJAAIBAh1taW5fYW1vdW50cy5zaXplKCkgIT0gTl9DT0lOUwQGYW1vdW50CAUHcGF5bWVudAZhbW91bnQEBmNhbGxlcggFA21zZwZjYWxsZXIKAQRmb2xkAgNhY2MFaW5kZXgEB2JhbGFuY2UJAJEDAgUIYmFsYW5jZXMFBWluZGV4BAphbW91bnRfb3V0CQBrAwUHYmFsYW5jZQUGYW1vdW50BQ50b2tlbl9xdWFudGl0eQMDCQECIT0CBQxfbWluX2Ftb3VudHMCATAJAGYCCQCRAwIFC21pbl9hbW91bnRzBQVpbmRleAUKYW1vdW50X291dAcJAAIBAjB3aXRoZHJhd2FsIHJlc3VsdGVkIGluIGZld2VyIGNvaW5zIHRoYW4gZXhwZWN0ZWQJAJQKAgkAzQgCCAUDYWNjAl8xCQEOU2NyaXB0VHJhbnNmZXIDBQZjYWxsZXIFCmFtb3VudF9vdXQJANkEAQkAkQMCBQVjb2lucwUFaW5kZXgJAM0IAggFA2FjYwJfMgkAZQIFB2JhbGFuY2UFCmFtb3VudF9vdXQEDSR0MDIxMzMxMjE0MTAKAAIkbAUNaW5kZXhfTl9DT0lOUwoAAiRzCQCQAwEFAiRsCgAFJGFjYzAJAJQKAgUDbmlsBQNuaWwKAQUkZjBfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBBGZvbGQCBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjBfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDEwCQEFJGYwXzICCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoECXRyYW5zZmVycwgFDSR0MDIxMzMxMjE0MTACXzEEDmZpbmFsX2JhbGFuY2VzCAUNJHQwMjEzMzEyMTQxMAJfMgkAzggCBQl0cmFuc2ZlcnMJAMwIAgkBC1N0cmluZ0VudHJ5AgIIYmFsYW5jZXMJALkJAgkBCWxpc3RfaXRvcwEFDmZpbmFsX2JhbGFuY2VzAgEsCQDMCAIJAQRCdXJuAgUFdG9rZW4FBmFtb3VudAUDbmlsA21zZwEWY2FsY193aXRoZHJhd19vbmVfY29pbgINX3Rva2VuX2Ftb3VudAFpCQCUCgIFA25pbAgJARdfY2FsY193aXRoZHJhd19vbmVfY29pbgIFDV90b2tlbl9hbW91bnQFAWkCXzEDbXNnARlyZW1vdmVfbGlxdWlkaXR5X29uZV9jb2luAgFpCm1pbl9hbW91bnQDCQEGYXNzZXJ0AQkBASEBBQlpc19raWxsZWQJAAIBAglpcyBraWxsZWQDCQECIT0CCQCQAwEIBQNtc2cIcGF5bWVudHMAAQkAAgECFXNpemUoIHBheW1lbnRzICkgIT0gMQQHcGF5bWVudAkAkQMCCAUDbXNnCHBheW1lbnRzAAADCQECIT0CCAUHcGF5bWVudAdhc3NldElkBQV0b2tlbgkAAgECDXVua25vd24gdG9rZW4EDV90b2tlbl9hbW91bnQIBQdwYXltZW50BmFtb3VudAQNJHQwMjIwNzEyMjEzOAkBF19jYWxjX3dpdGhkcmF3X29uZV9jb2luAgUNX3Rva2VuX2Ftb3VudAUBaQQCZHkIBQ0kdDAyMjA3MTIyMTM4Al8xBAZkeV9mZWUIBQ0kdDAyMjA3MTIyMTM4Al8yBAFECAUNJHQwMjIwNzEyMjEzOAJfMwMJAQZhc3NlcnQBCQBnAgUCZHkFCm1pbl9hbW91bnQJAAIBAhhub3QgZW5vdWdoIGNvaW5zIHJlbW92ZWQEDGR5X2FkbWluX2ZlZQkAawMFBmR5X2ZlZQUJYWRtaW5fZmVlBQ9GRUVfREVOT01JTkFUT1IECmR5X2FuZF9mZWUJAGQCBQJkeQUMZHlfYWRtaW5fZmVlCgEEZm9sZAIDYWNjBWluZGV4CQDNCAIFA2FjYwkAZQIJAJEDAgUIYmFsYW5jZXMFBWluZGV4AwkAAAIFBWluZGV4BQFpBQpkeV9hbmRfZmVlAAAEDmZpbmFsX2JhbGFuY2VzCgACJGwFDWluZGV4X05fQ09JTlMKAAIkcwkAkAMBBQIkbAoABSRhY2MwBQNuaWwKAQUkZjBfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBBGZvbGQCBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjBfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDEwCQEFJGYwXzICCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoECHRva2VuT3V0CQDZBAEJAJEDAgUFY29pbnMFAWkJAJQKAgkAzggCCQDOCAIJAMwIAgkBC1N0cmluZ0VudHJ5AgIIYmFsYW5jZXMJALkJAgkBCWxpc3RfaXRvcwEFDmZpbmFsX2JhbGFuY2VzAgEsCQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMIBQNtc2cGY2FsbGVyBQJkeQUIdG9rZW5PdXQJAMwIAgkBBEJ1cm4CBQV0b2tlbgUNX3Rva2VuX2Ftb3VudAUDbmlsAwMFDGlzX2F1dG9fZmVlcwkAZgIFDGR5X2FkbWluX2ZlZQAABwkAzAgCCQEOU2NyaXB0VHJhbnNmZXIDBQVvd25lcgUMZHlfYWRtaW5fZmVlBQh0b2tlbk91dAUDbmlsBQNuaWwJAQhsb2dfZGF0YQIFAUQJAGsDCQBrAwUGZHlfZmVlBQpUT0tFTl9SQVRFCQCRAwIFBXJhdGVzBQFpBQ9GRUVfREVOT01JTkFUT1IFA2ZlZQUCZHkDbXNnAQFBAAkAlAoCBQNuaWwJAQJfQQADbXNnARFnZXRfdmlydHVhbF9wcmljZQAEAUQJAQVnZXRfRAIJAQhiaWdfbGlzdAEFCGJhbGFuY2VzCQECX0EACQCUCgIFA25pbAkBDXZpcnR1YWxfcHJpY2UBBQFEA21zZwERY2FsY190b2tlbl9hbW91bnQCCF9hbW91bnRzB2RlcG9zaXQEB2Ftb3VudHMJAQlsaXN0X3N0b2kBCQC1CQIFCF9hbW91bnRzAgEsAwkBAiE9AgkAkAMBBQdhbW91bnRzBQdOX0NPSU5TCQACAQITbm90IGVub3VnaHQgYW1vdW50cwQDYW1wCQECX0EABAJEMAkBBWdldF9EAgkBCGJpZ19saXN0AQUHYW1vdW50cwUDYW1wCgEEZm9sZAIDYWNjBWluZGV4CQDNCAIFA2FjYwkAZAIJAJEDAgUIYmFsYW5jZXMFBWluZGV4AwUHZGVwb3NpdAkAkQMCBQdhbW91bnRzBQVpbmRleAkBAS0BCQCRAwIFB2Ftb3VudHMFBWluZGV4BAxuZXdfYmFsYW5jZXMKAAIkbAUNaW5kZXhfTl9DT0lOUwoAAiRzCQCQAwEFAiRsCgAFJGFjYzAFA25pbAoBBSRmMF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEEZm9sZAIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQUkZjBfMgIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgQCRDEJAQVnZXRfRAIJAQhiaWdfbGlzdAEFDG5ld19iYWxhbmNlcwUDYW1wBAx0b2tlbl9hbW91bnQFDnRva2VuX3F1YW50aXR5BARkaWZmAwUHZGVwb3NpdAkAZQIFAkQxBQJEMAkAZQIFAkQwBQJEMQkAlAoCBQNuaWwJAGsDBQRkaWZmBQx0b2tlbl9hbW91bnQFAkQwA21zZwEGcmFtcF9BAglfZnV0dXJlX0EMX2Z1dHVyZV90aW1lAwkBBmFzc2VydAEJAAACCAUDbXNnBmNhbGxlcgUFb3duZXIJAAIBAgpvbmx5IG93bmVyAwkBBmFzc2VydAEJAGcCBQ9ibG9ja190aW1lc3RhbXAJAGQCBQ5pbml0aWFsX0FfdGltZQUNTUlOX1JBTVBfVElNRQkAAgECCXRvbyBvZnRlbgMJAQZhc3NlcnQBCQBnAgUMX2Z1dHVyZV90aW1lCQBkAgUPYmxvY2tfdGltZXN0YW1wBQ1NSU5fUkFNUF9USU1FCQACAQIRaW5zdWZmaWNpZW50IHRpbWUECl9pbml0aWFsX0EJAQJfQQADCQEGYXNzZXJ0AQMJAGYCBQlfZnV0dXJlX0EAAAkAZgIFBU1BWF9BBQlfZnV0dXJlX0EHCQACAQIRb3V0IG9mIGJhc2UgcmFuZ2UDCQEGYXNzZXJ0AQMDCQBnAgUJX2Z1dHVyZV9BBQpfaW5pdGlhbF9BCQBnAgkAaAIFCl9pbml0aWFsX0EFDE1BWF9BX0NIQU5HRQUJX2Z1dHVyZV9BBwYDCQBmAgUKX2luaXRpYWxfQQUJX2Z1dHVyZV9BCQBnAgkAaAIFCV9mdXR1cmVfQQUMTUFYX0FfQ0hBTkdFBQpfaW5pdGlhbF9BBwkAAgECDG91dCBvZiByYW5nZQkAzAgCCQEMSW50ZWdlckVudHJ5AgIJaW5pdGlhbF9BBQpfaW5pdGlhbF9BCQDMCAIJAQxJbnRlZ2VyRW50cnkCAghmdXR1cmVfQQUJX2Z1dHVyZV9BCQDMCAIJAQxJbnRlZ2VyRW50cnkCAg5pbml0aWFsX0FfdGltZQUPYmxvY2tfdGltZXN0YW1wCQDMCAIJAQxJbnRlZ2VyRW50cnkCAg1mdXR1cmVfQV90aW1lBQxfZnV0dXJlX3RpbWUFA25pbANtc2cBC3N0b3BfcmFtcF9BAAMJAQZhc3NlcnQBCQAAAggFA21zZwZjYWxsZXIFBW93bmVyCQACAQIKb25seSBvd25lcgQJY3VycmVudF9BCQECX0EACQDMCAIJAQxJbnRlZ2VyRW50cnkCAglpbml0aWFsX0EFCWN1cnJlbnRfQQkAzAgCCQEMSW50ZWdlckVudHJ5AgIIZnV0dXJlX0EFCWN1cnJlbnRfQQkAzAgCCQEMSW50ZWdlckVudHJ5AgIOaW5pdGlhbF9BX3RpbWUFD2Jsb2NrX3RpbWVzdGFtcAkAzAgCCQEMSW50ZWdlckVudHJ5AgINZnV0dXJlX0FfdGltZQUPYmxvY2tfdGltZXN0YW1wBQNuaWwDbXNnAQ5jb21taXRfbmV3X2ZlZQIHbmV3X2ZlZQ1uZXdfYWRtaW5fZmVlAwkBBmFzc2VydAEJAAACCAUDbXNnBmNhbGxlcgUFb3duZXIJAAIBAgpvbmx5IG93bmVyAwkBBmFzc2VydAEJAAACBRZhZG1pbl9hY3Rpb25zX2RlYWRsaW5lAAAJAAIBAg1hY3RpdmUgYWN0aW9uAwkBBmFzc2VydAEJAGcCBQdNQVhfRkVFBQduZXdfZmVlCQACAQITZmVlIGV4Y2VlZHMgbWF4aW11bQMJAQZhc3NlcnQBCQBnAgUNTUFYX0FETUlOX0ZFRQUNbmV3X2FkbWluX2ZlZQkAAgECGWFkbWluIGZlZSBleGNlZWRzIG1heGltdW0ECV9kZWFkbGluZQkAZAIFD2Jsb2NrX3RpbWVzdGFtcAUTQURNSU5fQUNUSU9OU19ERUxBWQkAzAgCCQEMSW50ZWdlckVudHJ5AgIWYWRtaW5fYWN0aW9uc19kZWFkbGluZQUJX2RlYWRsaW5lCQDMCAIJAQxJbnRlZ2VyRW50cnkCAgpmdXR1cmVfZmVlBQduZXdfZmVlCQDMCAIJAQxJbnRlZ2VyRW50cnkCAhBmdXR1cmVfYWRtaW5fZmVlBQ1uZXdfYWRtaW5fZmVlBQNuaWwDbXNnAQ1hcHBseV9uZXdfZmVlAAMJAQZhc3NlcnQBCQAAAggFA21zZwZjYWxsZXIFBW93bmVyCQACAQIKb25seSBvd25lcgMJAQZhc3NlcnQBCQBnAgUPYmxvY2tfdGltZXN0YW1wBRZhZG1pbl9hY3Rpb25zX2RlYWRsaW5lCQACAQIRaW5zdWZmaWNpZW50IHRpbWUDCQEGYXNzZXJ0AQkBAiE9AgUWYWRtaW5fYWN0aW9uc19kZWFkbGluZQAACQACAQIQbm8gYWN0aXZlIGFjdGlvbgkAzAgCCQEMSW50ZWdlckVudHJ5AgIWYWRtaW5fYWN0aW9uc19kZWFkbGluZQAACQDMCAIJAQxJbnRlZ2VyRW50cnkCAgNmZWUFCmZ1dHVyZV9mZWUJAMwIAgkBDEludGVnZXJFbnRyeQICCWFkbWluX2ZlZQUQZnV0dXJlX2FkbWluX2ZlZQUDbmlsA21zZwEVcmV2ZXJ0X25ld19wYXJhbWV0ZXJzAAMJAQZhc3NlcnQBCQAAAggFA21zZwZjYWxsZXIFBW93bmVyCQACAQIKb25seSBvd25lcgkAzAgCCQEMSW50ZWdlckVudHJ5AgIWYWRtaW5fYWN0aW9uc19kZWFkbGluZQAABQNuaWwDbXNnARljb21taXRfdHJhbnNmZXJfb3duZXJzaGlwAQZfb3duZXIDCQEGYXNzZXJ0AQkAAAIIBQNtc2cGY2FsbGVyBQVvd25lcgkAAgECCm9ubHkgb3duZXIDCQEGYXNzZXJ0AQkAAAIFG3RyYW5zZmVyX293bmVyc2hpcF9kZWFkbGluZQAACQACAQIPYWN0aXZlIHRyYW5zZmVyBAlfZGVhZGxpbmUJAGQCBQ9ibG9ja190aW1lc3RhbXAFE0FETUlOX0FDVElPTlNfREVMQVkJAMwIAgkBDEludGVnZXJFbnRyeQICG3RyYW5zZmVyX293bmVyc2hpcF9kZWFkbGluZQUJX2RlYWRsaW5lCQDMCAIJAQtTdHJpbmdFbnRyeQICDGZ1dHVyZV9vd25lcgkBDGNoZWNrQWRkcmVzcwEFBl9vd25lcgUDbmlsA21zZwEYYXBwbHlfdHJhbnNmZXJfb3duZXJzaGlwAAMJAQZhc3NlcnQBCQAAAggFA21zZwZjYWxsZXIFBW93bmVyCQACAQIKb25seSBvd25lcgMJAQZhc3NlcnQBCQBnAgUPYmxvY2tfdGltZXN0YW1wBRt0cmFuc2Zlcl9vd25lcnNoaXBfZGVhZGxpbmUJAAIBAhFpbnN1ZmZpY2llbnQgdGltZQMJAQZhc3NlcnQBCQECIT0CBRt0cmFuc2Zlcl9vd25lcnNoaXBfZGVhZGxpbmUAAAkAAgECEm5vIGFjdGl2ZSB0cmFuc2ZlcgkAzAgCCQEMSW50ZWdlckVudHJ5AgIbdHJhbnNmZXJfb3duZXJzaGlwX2RlYWRsaW5lAAAJAMwIAgkBC1N0cmluZ0VudHJ5AgIFb3duZXIFDGZ1dHVyZV9vd25lcgUDbmlsA21zZwEZcmV2ZXJ0X3RyYW5zZmVyX293bmVyc2hpcAADCQEGYXNzZXJ0AQkAAAIIBQNtc2cGY2FsbGVyBQVvd25lcgkAAgECCm9ubHkgb3duZXIJAMwIAgkBDEludGVnZXJFbnRyeQICG3RyYW5zZmVyX293bmVyc2hpcF9kZWFkbGluZQAABQNuaWwDbXNnAQ5hZG1pbl9iYWxhbmNlcwEBaQkAlAoCBQNuaWwJAQ1hZG1pbl9iYWxhbmNlAQUBaQNtc2cBE3dpdGhkcmF3X2FkbWluX2ZlZXMAAwkBBmFzc2VydAEJAAACCAUDbXNnBmNhbGxlcgUFb3duZXIJAAIBAgpvbmx5IG93bmVyCgEEZm9sZAIDYWNjBWluZGV4CQDNCAIFA2FjYwkBDlNjcmlwdFRyYW5zZmVyAwUFb3duZXIJAQ1hZG1pbl9iYWxhbmNlAQUFaW5kZXgJANkEAQkAkQMCBQVjb2lucwUFaW5kZXgKAAIkbAUNaW5kZXhfTl9DT0lOUwoAAiRzCQCQAwEFAiRsCgAFJGFjYzAFA25pbAoBBSRmMF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEEZm9sZAIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQUkZjBfMgIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgNtc2cBEWRvbmF0ZV9hZG1pbl9mZWVzAAMJAQZhc3NlcnQBCQAAAggFA21zZwZjYWxsZXIFBW93bmVyCQACAQIKb25seSBvd25lcgoBBGZvbGQCA2FjYwVpbmRleAkAzQgCBQNhY2MJAGQCCQCRAwIFCGJhbGFuY2VzBQVpbmRleAkBDWFkbWluX2JhbGFuY2UBBQVpbmRleAQMbmV3X2JhbGFuY2VzCgACJGwFDWluZGV4X05fQ09JTlMKAAIkcwkAkAMBBQIkbAoABSRhY2MwBQNuaWwKAQUkZjBfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBBGZvbGQCBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjBfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDEwCQEFJGYwXzICCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECCQEFJGYwXzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoJAMwIAgkBC1N0cmluZ0VudHJ5AgIIYmFsYW5jZXMJALkJAgkBCWxpc3RfaXRvcwEFDG5ld19iYWxhbmNlcwIBLAUDbmlsA21zZwENc2V0X2F1dG9fZmVlcwENX2lzX2F1dG9fZmVlcwMJAQZhc3NlcnQBCQAAAggFA21zZwZjYWxsZXIFBW93bmVyCQACAQIKb25seSBvd25lcgkAzAgCCQEMQm9vbGVhbkVudHJ5AgIMaXNfYXV0b19mZWVzBQ1faXNfYXV0b19mZWVzBQNuaWwDbXNnAQdraWxsX21lAAMJAQZhc3NlcnQBCQAAAggFA21zZwZjYWxsZXIFBW93bmVyCQACAQIKb25seSBvd25lcgMJAQZhc3NlcnQBCQBmAgUNa2lsbF9kZWFkbGluZQUPYmxvY2tfdGltZXN0YW1wCQACAQITZGVhZGxpbmUgaGFzIHBhc3NlZAkAzAgCCQEMQm9vbGVhbkVudHJ5AgIJaXNfa2lsbGVkBgUDbmlsA21zZwEJdW5raWxsX21lAAMJAQZhc3NlcnQBCQAAAggFA21zZwZjYWxsZXIFBW93bmVyCQACAQIKb25seSBvd25lcgkAzAgCCQEMQm9vbGVhbkVudHJ5AgIJaXNfa2lsbGVkBwUDbmlsA21zZwESc2V0X2hlaWdodF9hZGRyZXNzAQ5faGVpZ2h0QWRkcmVzcwMJAQIhPQIIBQNtc2cGY2FsbGVyBQVvd25lcgkAAgECCm9ubHkgb3duZXIJAMwIAgkBC1N0cmluZ0VudHJ5AgINaGVpZ2h0QWRkcmVzcwkBDGNoZWNrQWRkcmVzcwEFDl9oZWlnaHRBZGRyZXNzBQNuaWwBaQEMc2V0X3ZlcmlmaWVyAQh2ZXJpZmllcgMJAQIhPQIIBQFpBmNhbGxlcgUEdGhpcwkAAgECDnNlbGYgY2FsbCBvbmx5BAlhZGRyZXNzT0sEByRtYXRjaDAJAKYIAQUIdmVyaWZpZXIDCQABAgUHJG1hdGNoMAIHQWRkcmVzcwQBYQUHJG1hdGNoMAYHAwkBASEBBQlhZGRyZXNzT0sJAAIBCQCsAgICF3ZlcmlmaWVyIHdyb25nIGFkZHJlc3MgBQh2ZXJpZmllcgMJAQlpc0RlZmluZWQBCQCdCAIFBHRoaXMCCHZlcmlmaWVyCQACAQIYdmVyaWZpZXIgYWxyZWFkeSBkZWZpbmVkCQDMCAIJAQtTdHJpbmdFbnRyeQICCHZlcmlmaWVyBQh2ZXJpZmllcgUDbmlsAQJ0eAEGdmVyaWZ5AAQHJG1hdGNoMAkAnQgCBQR0aGlzAgh2ZXJpZmllcgMJAAECBQckbWF0Y2gwAgZTdHJpbmcECHZlcmlmaWVyBQckbWF0Y2gwCQELdmFsdWVPckVsc2UCCQCbCAIJARFAZXh0ck5hdGl2ZSgxMDYyKQEFCHZlcmlmaWVyCQCsAgIJAKwCAgkArAICAgdzdGF0dXNfCQClCAEFBHRoaXMCAV8JANgEAQgFAnR4AmlkBwkA9AMDCAUCdHgJYm9keUJ5dGVzCQCRAwIIBQJ0eAZwcm9vZnMAAAgFAnR4D3NlbmRlclB1YmxpY0tleWg0zEM=", "chainId": 84, "height": 2295152, "applicationStatus": "succeeded", "spentComplexity": 0 } View: original | compacted Prev: none Next: wQqeHB3jR8k1L9HLbaQWGpm6CkrrV4fJb6SUmmx3Qco Full:
OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let a = getIntegerValue(this, "N_COINS")
5+
6+let b = toBigInt(a)
7+
8+let c = 10
9+
10+let d = 6
11+
12+let e = 1000000
13+
14+let f = 10000000000
15+
16+let g = 1000000
17+
18+let h = 6
19+
20+let i = 10000000000
21+
22+let j = 5000000000
23+
24+let k = 1000000
25+
26+let l = 10
27+
28+let m = ((3 * 86400) / 60)
29+
30+let n = (86400 / 60)
31+
32+let o = 86400000
33+
34+let p = 1000000000000
35+
36+let q = split(getStringValue(this, "coins"), ",")
37+
38+let r = getIntegerValue(this, "fee")
39+
40+let s = getIntegerValue(this, "admin_fee")
41+
42+let t = getBooleanValue(this, "is_auto_fees")
43+
44+let u = addressFromStringValue(getStringValue(this, "owner"))
45+
46+let v = fromBase58String(getStringValue(this, "token"))
47+
48+let w = value(assetInfo(v)).quantity
49+
50+let x = getIntegerValue(this, "initial_A")
51+
52+let y = getIntegerValue(this, "future_A")
53+
54+let z = valueOrElse(getInteger(this, "initial_A_time"), 0)
55+
56+let B = valueOrElse(getInteger(this, "future_A_time"), 0)
57+
58+let C = valueOrElse(getInteger(this, "admin_actions_deadline"), 0)
59+
60+let D = valueOrElse(getInteger(this, "transfer_ownership_deadline"), 0)
61+
62+let E = getIntegerValue(this, "future_fee")
63+
64+let F = getIntegerValue(this, "future_admin_fee")
65+
66+let G = getStringValue(this, "future_owner")
67+
68+let H = getBooleanValue(this, "is_killed")
69+
70+let I = getIntegerValue(this, "kill_deadline")
71+
72+let J = (((2 * 30) * 86400) / 60)
73+
74+let K = toBigInt(0)
75+
76+let L = toBigInt(1)
77+
78+let M = toBigInt(2)
79+
80+let N = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(this, "heightAddress"), "no settings defined")), "bad settings address")
81+
82+let O = height
83+
84+let P = O
85+
86+func Q (R) = if (R)
87+ then false
88+ else true
89+
90+
91+func S (T) = if ((size(T) > c))
92+ then throw("list_itos: list.size() > N_COINS_MAX")
93+ else {
94+ func U (V,W) = (V :+ toString(W))
95+
96+ let X = T
97+ let Y = size(X)
98+ let Z = nil
99+ func aa (ab,ac) = if ((ac >= Y))
100+ then ab
101+ else U(ab, X[ac])
102+
103+ func ad (ab,ac) = if ((ac >= Y))
104+ then ab
105+ else throw("List size exceeds 10")
106+
107+ ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
108+ }
109+
110+
111+func ae (T) = if ((size(T) > c))
112+ then throw("list_stoi: list.size() > N_COINS_MAX")
113+ else {
114+ func U (V,W) = (V :+ parseIntValue(W))
115+
116+ let X = T
117+ let Y = size(X)
118+ let Z = nil
119+ func aa (ab,ac) = if ((ac >= Y))
120+ then ab
121+ else U(ab, X[ac])
122+
123+ func ad (ab,ac) = if ((ac >= Y))
124+ then ab
125+ else throw("List size exceeds 10")
126+
127+ ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
128+ }
129+
130+
131+let af = ae(split(getStringValue(this, "balances"), ","))
132+
133+let ag = ae(split(getStringValue(this, "rates"), ","))
134+
135+let ah = size(ag)
136+
137+let ai = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
138+
139+func aj (ak) = if ((ak > c))
140+ then throw("index_n: n > N_COINS_MAX")
141+ else {
142+ func U (V,al) = if ((ak > al))
143+ then (V :+ al)
144+ else V
145+
146+ let X = ai
147+ let Y = size(X)
148+ let Z = nil
149+ func aa (ab,ac) = if ((ac >= Y))
150+ then ab
151+ else U(ab, X[ac])
152+
153+ func ad (ab,ac) = if ((ac >= Y))
154+ then ab
155+ else throw("List size exceeds 10")
156+
157+ ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
158+ }
159+
160+
161+let am = aj(a)
162+
163+let an = (am :+ a)
164+
165+func ao (T) = if ((size(T) != a))
166+ then throw("big_list: list.size() != N_COINS")
167+ else {
168+ func U (V,al) = (V :+ toBigInt(fraction(T[al], e, ag[al])))
169+
170+ let X = am
171+ let Y = size(X)
172+ let Z = nil
173+ func aa (ab,ac) = if ((ac >= Y))
174+ then ab
175+ else U(ab, X[ac])
176+
177+ func ad (ab,ac) = if ((ac >= Y))
178+ then ab
179+ else throw("List size exceeds 10")
180+
181+ ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
182+ }
183+
184+
185+func ap (aq) = {
186+ let ar = aq.assetId
187+ if ($isInstanceOf(ar, "ByteVector"))
188+ then {
189+ let as = ar
190+ valueOrErrorMessage(indexOf(q, toBase58String(as)), (toBase58String(as) + " out of pool"))
191+ }
192+ else throw("unsupported assetId")
193+ }
194+
195+
196+func at (au) = if (if ((0 > au))
197+ then true
198+ else (au > a))
199+ then throw("i out of index")
200+ else (assetBalance(this, fromBase58String(q[au])) - af[au])
201+
202+
203+func av (aw) = {
204+ let R = addressFromStringValue(aw)
205+ toString(R)
206+ }
207+
208+
209+func ax () = {
210+ let ay = B
211+ let az = y
212+ if ((ay > P))
213+ then {
214+ let aA = x
215+ let aB = z
216+ if ((az > aA))
217+ then (aA + (((az - aA) * (P - aB)) / (ay - aB)))
218+ else (aA - (((aA - az) * (P - aB)) / (ay - aB)))
219+ }
220+ else az
221+ }
222+
223+
224+func aC (T) = {
225+ func U (V,W) = (V + W)
226+
227+ let X = T
228+ let Y = size(X)
229+ let Z = K
230+ func aa (ab,ac) = if ((ac >= Y))
231+ then ab
232+ else U(ab, X[ac])
233+
234+ func ad (ab,ac) = if ((ac >= Y))
235+ then ab
236+ else throw("List size exceeds 10")
237+
238+ ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
239+ }
240+
241+
242+func aD (T) = {
243+ func U (V,W) = fraction(fraction(V, W, L), b, L)
244+
245+ let X = T
246+ let Y = size(X)
247+ let Z = L
248+ func aa (ab,ac) = if ((ac >= Y))
249+ then ab
250+ else U(ab, X[ac])
251+
252+ func ad (ab,ac) = if ((ac >= Y))
253+ then ab
254+ else throw("List size exceeds 10")
255+
256+ ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
257+ }
258+
259+
260+let aE = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
261+
262+func aF (aG,aH) = {
263+ let aI = aC(aG)
264+ if ((toInt(aI) == 0))
265+ then 0
266+ else {
267+ let aJ = (aH * a)
268+ let aK = fraction(toBigInt(aJ), aI, L)
269+ let aL = toBigInt((aJ - 1))
270+ let aM = aD(aG)
271+ let aN = (a + 1)
272+ let aO = toBigInt(aN)
273+ func aP (W) = {
274+ func U (V,al) = fraction(V, W, L)
275+
276+ let X = an
277+ let Y = size(X)
278+ let Z = L
279+ func aa (ab,ac) = if ((ac >= Y))
280+ then ab
281+ else U(ab, X[ac])
282+
283+ func ad (ab,ac) = if ((ac >= Y))
284+ then ab
285+ else throw("List size exceeds 10")
286+
287+ ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
288+ }
289+
290+ func aQ (V,aR) = if ((V._2 == true))
291+ then V
292+ else {
293+ let aS = V._1
294+ let aT = fraction(aP(aS), L, aM)
295+ let aU = fraction((aK + fraction(b, aT, L)), aS, (fraction(aL, aS, L) + fraction(aO, aT, L)))
296+ if ((aU > aS))
297+ then if ((1 >= toInt((aU - aS))))
298+ then $Tuple2(aU, true)
299+ else $Tuple2(aU, false)
300+ else if ((1 >= toInt((aS - aU))))
301+ then $Tuple2(aU, true)
302+ else $Tuple2(aU, false)
303+ }
304+
305+ let aV = {
306+ let X = aE
307+ let Y = size(X)
308+ let Z = $Tuple2(aI, false)
309+ func aa (ab,ac) = if ((ac >= Y))
310+ then ab
311+ else aQ(ab, X[ac])
312+
313+ func ad (ab,ac) = if ((ac >= Y))
314+ then ab
315+ else throw("List size exceeds 16")
316+
317+ ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16)
318+ }
319+ let aU = aV._1
320+ let aW = aV._2
321+ if ((aW == false))
322+ then throw(("D_proc() not finished with " + toString(aU)))
323+ else toInt(aU)
324+ }
325+ }
326+
327+
328+func aX (au,aY,aZ,aG) = if (Q((au != aY)))
329+ then throw("same coin")
330+ else if (Q(if ((aY >= 0))
331+ then (au >= 0)
332+ else false))
333+ then throw("below zero")
334+ else if (Q(if ((a > aY))
335+ then (a > au)
336+ else false))
337+ then throw("above N_COINS")
338+ else {
339+ let aH = ax()
340+ let aU = aF(aG, aH)
341+ let ba = toBigInt(aU)
342+ let bb = toBigInt((aH * a))
343+ func bc (V,al) = {
344+ let bd = V
345+ let be = bd._1
346+ let bf = bd._2
347+ let bg = if ((al == au))
348+ then toBigInt(fraction(aZ, e, ag[al]))
349+ else aG[al]
350+ if ((al != aY))
351+ then $Tuple2((be + bg), fraction(bf, ba, fraction(bg, b, L)))
352+ else $Tuple2(be, bf)
353+ }
354+
355+ let bh = {
356+ let X = am
357+ let Y = size(X)
358+ let Z = $Tuple2(K, ba)
359+ func aa (ab,ac) = if ((ac >= Y))
360+ then ab
361+ else bc(ab, X[ac])
362+
363+ func ad (ab,ac) = if ((ac >= Y))
364+ then ab
365+ else throw("List size exceeds 10")
366+
367+ ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
368+ }
369+ let be = bh._1
370+ let bi = bh._2
371+ let bf = fraction(bi, ba, fraction(bb, b, L))
372+ let bj = ((be + fraction(ba, L, bb)) - ba)
373+ func bk (V,aR) = if ((V._2 == true))
374+ then V
375+ else {
376+ let bl = V._1
377+ let bm = fraction((fraction(bl, bl, L) + bf), L, (fraction(M, bl, L) + bj))
378+ if ((bm > bl))
379+ then if ((1 >= toInt((bm - bl))))
380+ then $Tuple2(bm, true)
381+ else $Tuple2(bm, false)
382+ else if ((1 >= toInt((bl - bm))))
383+ then $Tuple2(bm, true)
384+ else $Tuple2(bm, false)
385+ }
386+
387+ let bn = {
388+ let X = aE
389+ let Y = size(X)
390+ let Z = $Tuple2(ba, false)
391+ func bo (ab,ac) = if ((ac >= Y))
392+ then ab
393+ else bk(ab, X[ac])
394+
395+ func bp (ab,ac) = if ((ac >= Y))
396+ then ab
397+ else throw("List size exceeds 16")
398+
399+ bp(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16)
400+ }
401+ let bm = bn._1
402+ let aW = bn._2
403+ if ((aW == false))
404+ then throw(("y_proc() not finished with " + toString(bm)))
405+ else $Tuple2(fraction(toInt(bm), ag[aY], e), aU)
406+ }
407+
408+
409+func bq (aH,au,aG,aU) = if (Q((au >= 0)))
410+ then throw("i below zero")
411+ else if (Q((a > au)))
412+ then throw("i above N_COINS")
413+ else {
414+ let ba = toBigInt(aU)
415+ let bb = toBigInt((aH * a))
416+ func bc (V,al) = {
417+ let br = V
418+ let be = br._1
419+ let bf = br._2
420+ let bg = if ((al == au))
421+ then K
422+ else aG[al]
423+ if ((al != au))
424+ then $Tuple2((be + bg), fraction(bf, ba, fraction(bg, b, L)))
425+ else $Tuple2(be, bf)
426+ }
427+
428+ let bs = {
429+ let X = am
430+ let Y = size(X)
431+ let Z = $Tuple2(K, ba)
432+ func aa (ab,ac) = if ((ac >= Y))
433+ then ab
434+ else bc(ab, X[ac])
435+
436+ func ad (ab,ac) = if ((ac >= Y))
437+ then ab
438+ else throw("List size exceeds 10")
439+
440+ ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
441+ }
442+ let be = bs._1
443+ let bi = bs._2
444+ let bf = fraction(bi, ba, fraction(bb, b, L))
445+ let bj = ((be + fraction(ba, L, bb)) - ba)
446+ func bk (V,aR) = if ((V._2 == true))
447+ then V
448+ else {
449+ let bl = V._1
450+ let bm = fraction((fraction(bl, bl, L) + bf), L, (fraction(M, bl, L) + bj))
451+ if ((bm > bl))
452+ then if ((1 >= toInt((bm - bl))))
453+ then $Tuple2(bm, true)
454+ else $Tuple2(bm, false)
455+ else if ((1 >= toInt((bl - bm))))
456+ then $Tuple2(bm, true)
457+ else $Tuple2(bm, false)
458+ }
459+
460+ let bt = {
461+ let X = aE
462+ let Y = size(X)
463+ let Z = $Tuple2(ba, false)
464+ func bo (ab,ac) = if ((ac >= Y))
465+ then ab
466+ else bk(ab, X[ac])
467+
468+ func bp (ab,ac) = if ((ac >= Y))
469+ then ab
470+ else throw("List size exceeds 16")
471+
472+ bp(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16)
473+ }
474+ let bm = bt._1
475+ let aW = bt._2
476+ if ((aW == false))
477+ then throw(("y_proc() not finished with " + toString(bm)))
478+ else fraction(toInt(bm), ag[au], e)
479+ }
480+
481+
482+func bu (bv,au) = {
483+ let aH = ax()
484+ let bw = ((r * a) / (4 * (a - 1)))
485+ let aG = ao(af)
486+ let bx = aF(aG, aH)
487+ let by = (bx - fraction(bv, bx, w))
488+ let bz = bq(aH, au, aG, by)
489+ let bA = (af[au] - bz)
490+ func U (V,al) = {
491+ let bB = af[al]
492+ let bC = if ((al == au))
493+ then (fraction(bB, by, bx) - bz)
494+ else (bB - fraction(bB, by, bx))
495+ (V :+ (bB - fraction(bw, bC, f)))
496+ }
497+
498+ let bD = {
499+ let X = am
500+ let Y = size(X)
501+ let Z = nil
502+ func aa (ab,ac) = if ((ac >= Y))
503+ then ab
504+ else U(ab, X[ac])
505+
506+ func ad (ab,ac) = if ((ac >= Y))
507+ then ab
508+ else throw("List size exceeds 10")
509+
510+ ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
511+ }
512+ let bE = bD[au]
513+ let bF = ((bE - bq(aH, au, ao(bD), by)) - 1)
514+ $Tuple3(bF, (bA - bF), bx)
515+ }
516+
517+
518+func bG (aU) = fraction(aU, p, w)
519+
520+
521+func bH (aU,bI) = {
522+ let bJ = (parseBigIntValue(valueOrElse(getString("vol"), "0")) + toBigInt(bI))
523+ let bK = toString(bJ)
524+ ([StringEntry("vol", bK)] ++ {
525+ let bL = toString((lastBlock.timestamp / o))
526+ let bM = ("log_" + bL)
527+ if (isDefined(getString(bM)))
528+ then nil
529+ else [StringEntry(bM, ((((toString(bG(aU)) + "_") + bK) + "_") + toString(lastBlock.timestamp)))]
530+ })
531+ }
532+
533+
534+func bN (bO) = {
535+ func U (bP,bQ) = if ((bP != ""))
536+ then bP
537+ else {
538+ let bM = ("log_" + toString((bO - bQ)))
539+ valueOrElse(getString(bM), "")
540+ }
541+
542+ let bR = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
543+ let bS = [-1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16, -17, -18, -19, -20, -21, -22, -23, -24, -25, -26, -27, -28, -29, -30]
544+ let bT = {
545+ let X = bR
546+ let Y = size(X)
547+ let Z = ""
548+ func aa (ab,ac) = if ((ac >= Y))
549+ then ab
550+ else U(ab, X[ac])
551+
552+ func ad (ab,ac) = if ((ac >= Y))
553+ then ab
554+ else throw("List size exceeds 30")
555+
556+ ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30)
557+ }
558+ if ((bT != ""))
559+ then bT
560+ else {
561+ let X = bS
562+ let Y = size(X)
563+ let Z = ""
564+ func bo (ab,ac) = if ((ac >= Y))
565+ then ab
566+ else U(ab, X[ac])
567+
568+ func bp (ab,ac) = if ((ac >= Y))
569+ then ab
570+ else throw("List size exceeds 30")
571+
572+ bp(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30)
573+ }
574+ }
575+
576+
577+func bU (bV) = {
578+ let bW = bG(aF(ao(af), ax()))
579+ let bX = lastBlock.timestamp
580+ let aB = if ((0 >= bV))
581+ then (bX + bV)
582+ else bV
583+ let bY = (aB / o)
584+ let bP = bN(bY)
585+ if ((bP == ""))
586+ then $Tuple3(bW, bW, 0)
587+ else {
588+ let bZ = split(bP, "_")
589+ let ca = parseIntValue(bZ[0])
590+ let cb = parseIntValue(bZ[2])
591+ $Tuple3(bW, ca, (bX - cb))
592+ }
593+ }
594+
595+
596+func cc (bV) = {
597+ let cd = parseBigIntValue(valueOrElse(getString("vol"), "0"))
598+ let ce = lastBlock.timestamp
599+ let aB = if ((0 >= bV))
600+ then (ce + bV)
601+ else bV
602+ let bY = (aB / o)
603+ let bP = bN(bY)
604+ if ((bP == ""))
605+ then $Tuple3(cd, cd, 0)
606+ else {
607+ let bZ = split(bP, "_")
608+ let cf = parseBigIntValue(bZ[1])
609+ let cg = parseIntValue(bZ[2])
610+ $Tuple3(cd, cf, (ce - cg))
611+ }
612+ }
613+
614+
615+@Callable(ch)
616+func init (ci,cj,ck,ax,bw,cl) = if (!(isDataStorageUntouched(this)))
617+ then throw("already initialized")
618+ else if ((ch.caller != this))
619+ then throw("self initialization only")
620+ else {
621+ let cm = split(cj, ",")
622+ let ak = size(cm)
623+ if ((2 > ak))
624+ then throw("too small coins")
625+ else if ((ak > c))
626+ then throw("too many coins")
627+ else {
628+ func cn (V,al) = if (if ((al >= ak))
629+ then true
630+ else (V == false))
631+ then V
632+ else (indexOf(cm, cm[al]) == al)
633+
634+ if ((false == {
635+ let X = ai
636+ let Y = size(X)
637+ let Z = true
638+ func aa (ab,ac) = if ((ac >= Y))
639+ then ab
640+ else cn(ab, X[ac])
641+
642+ func ad (ab,ac) = if ((ac >= Y))
643+ then ab
644+ else throw("List size exceeds 10")
645+
646+ ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
647+ }))
648+ then throw("duplicate coin detected")
649+ else {
650+ func co (cp) = valueOrErrorMessage(assetInfo(valueOrErrorMessage(fromBase58String(cp), ("fromBase58String: " + cp))), ("assetInfo: " + cp)).decimals
651+
652+ func U (V,cp) = $Tuple3((V._1 + 1), (V._2 :+ 0), (V._3 :+ pow(10, 0, co(cp), 0, 0, DOWN)))
653+
654+ let cq = {
655+ let X = cm
656+ let Y = size(X)
657+ let Z = $Tuple3(0, nil, nil)
658+ func aa (ab,ac) = if ((ac >= Y))
659+ then ab
660+ else U(ab, X[ac])
661+
662+ func ad (ab,ac) = if ((ac >= Y))
663+ then ab
664+ else throw("List size exceeds 10")
665+
666+ ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
667+ }
668+ let cr = cq._1
669+ let cs = cq._2
670+ let ct = cq._3
671+ let cu = Issue(ck, ("LP token for " + cj), 0, d, true)
672+ let cv = toBase58String(calculateAssetId(cu))
673+[StringEntry("coins", cj), StringEntry("rates", makeString(S(ct), ",")), StringEntry("balances", makeString(S(cs), ",")), IntegerEntry("N_COINS", cr), IntegerEntry("initial_A", ax), IntegerEntry("future_A", ax), IntegerEntry("fee", bw), IntegerEntry("admin_fee", cl), StringEntry("owner", av(ci)), IntegerEntry("kill_deadline", (height + J)), StringEntry("token", cv), BooleanEntry("is_killed", false), BooleanEntry("is_auto_fees", true), cu]
674+ }
675+ }
676+ }
677+
678+
679+
680+@Callable(ch)
681+func add_liquidity (cw) = if (Q(!(H)))
682+ then throw("is killed")
683+ else {
684+ let aH = ax()
685+ let cx = w
686+ let bx = if ((cx == 0))
687+ then 0
688+ else aF(ao(af), aH)
689+ func cy (cz,cA,cB) = {
690+ func U (V,al) = (V :+ (cz[al] + (if ((al == cA))
691+ then cB
692+ else 0)))
693+
694+ let X = am
695+ let Y = size(X)
696+ let Z = nil
697+ func aa (ab,ac) = if ((ac >= Y))
698+ then ab
699+ else U(ab, X[ac])
700+
701+ func ad (ab,ac) = if ((ac >= Y))
702+ then ab
703+ else throw("List size exceeds 10")
704+
705+ ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
706+ }
707+
708+ func cC (cz,cD) = {
709+ let ak = size(cD)
710+ if ((1 > ak))
711+ then throw("payments size < 1")
712+ else if ((ak > c))
713+ then throw("payments size > N_COINS_MAX")
714+ else {
715+ func U (V,aq) = cy(V, ap(aq), aq.amount)
716+
717+ let X = cD
718+ let Y = size(X)
719+ let Z = cz
720+ func aa (ab,ac) = if ((ac >= Y))
721+ then ab
722+ else U(ab, X[ac])
723+
724+ func ad (ab,ac) = if ((ac >= Y))
725+ then ab
726+ else throw("List size exceeds 10")
727+
728+ ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
729+ }
730+ }
731+
732+ let cE = cC(af, ch.payments)
733+ if (if ((cx == 0))
734+ then (min(cE) == 0)
735+ else false)
736+ then throw("initial deposit requires all coins")
737+ else {
738+ let by = aF(ao(cE), aH)
739+ if (Q((by > bx)))
740+ then throw("D1 > D0")
741+ else {
742+ let cF = if ((cx > 0))
743+ then {
744+ func cG (cH,cI) = {
745+ let bw = ((r * a) / (4 * (a - 1)))
746+ let ak = size(cH)
747+ func U (V,al) = {
748+ let cJ = cH[al]
749+ let cK = cI[al]
750+ let cL = fraction(by, cJ, bx)
751+ let cM = if ((cL > cK))
752+ then (cL - cK)
753+ else (cK - cL)
754+ let cN = fraction(bw, cM, f)
755+ let cO = fraction(cN, s, f)
756+ $Tuple4((V._1 :+ (cK - cO)), (V._2 :+ (cK - cN)), if (if (t)
757+ then (cO > 0)
758+ else false)
759+ then (V._3 :+ ScriptTransfer(u, cO, fromBase58String(q[al])))
760+ else V._3, (V._4 + fraction(cN, e, ag[al])))
761+ }
762+
763+ let X = am
764+ let Y = size(X)
765+ let Z = $Tuple4(nil, nil, nil, 0)
766+ func aa (ab,ac) = if ((ac >= Y))
767+ then ab
768+ else U(ab, X[ac])
769+
770+ func ad (ab,ac) = if ((ac >= Y))
771+ then ab
772+ else throw("List size exceeds 10")
773+
774+ ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
775+ }
776+
777+ let cP = cG(af, cE)
778+ let cQ = cP._1
779+ let cR = cP._2
780+ let cS = cP._3
781+ let cT = cP._4
782+ $Tuple3(cQ, aF(ao(cR), aH), (cS ++ bH(bx, fraction(cT, f, r))))
783+ }
784+ else $Tuple3(cE, by, nil)
785+ let cU = cF._1
786+ let cV = cF._2
787+ let cW = cF._3
788+ let cX = if ((cx == 0))
789+ then by
790+ else fraction(cx, (cV - bx), bx)
791+ if (Q((cX >= cw)))
792+ then throw("slippage screwed you")
793+ else ([StringEntry("balances", makeString(S(cU), ",")), Reissue(v, cX, true), ScriptTransfer(ch.caller, cX, v)] ++ cW)
794+ }
795+ }
796+ }
797+
798+
799+
800+@Callable(ch)
801+func get_dy (au,aY,cY) = {
802+ let cZ = af[au]
803+ let bB = af[aY]
804+ let aZ = (cZ + cY)
805+ let da = aX(au, aY, aZ, ao(af))
806+ let bm = da._1
807+ let aU = da._2
808+ let db = ((bB - bm) - 1)
809+ let dc = fraction(db, r, f)
810+ let bF = (db - dc)
811+ $Tuple2(nil, bF)
812+ }
813+
814+
815+
816+@Callable(ch)
817+func exchange (aY,dd) = if (Q(!(H)))
818+ then throw("is killed")
819+ else if ((size(ch.payments) != 1))
820+ then throw("size( payments ) != 1")
821+ else {
822+ let aq = ch.payments[0]
823+ let cY = aq.amount
824+ let au = ap(aq)
825+ let cZ = af[au]
826+ let bB = af[aY]
827+ let aZ = (cZ + cY)
828+ let de = aX(au, aY, aZ, ao(af))
829+ let bm = de._1
830+ let aU = de._2
831+ let db = ((bB - bm) - 1)
832+ let dc = fraction(db, r, f)
833+ let bF = (db - dc)
834+ if (Q((bF >= dd)))
835+ then throw("exchange resulted in fewer coins than expected")
836+ else {
837+ let df = fraction(dc, s, f)
838+ func U (V,al) = (V :+ (if ((al == au))
839+ then (af[al] + cY)
840+ else if ((al == aY))
841+ then ((af[al] - bF) - df)
842+ else af[al]))
843+
844+ let cU = {
845+ let X = am
846+ let Y = size(X)
847+ let Z = nil
848+ func aa (ab,ac) = if ((ac >= Y))
849+ then ab
850+ else U(ab, X[ac])
851+
852+ func ad (ab,ac) = if ((ac >= Y))
853+ then ab
854+ else throw("List size exceeds 10")
855+
856+ ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
857+ }
858+ let dg = fromBase58String(q[aY])
859+ $Tuple2((([StringEntry("balances", makeString(S(cU), ",")), ScriptTransfer(ch.caller, bF, dg)] ++ (if (if (t)
860+ then (df > 0)
861+ else false)
862+ then [ScriptTransfer(u, df, dg)]
863+ else nil)) ++ bH(aU, fraction(cY, e, ag[au]))), bF)
864+ }
865+ }
866+
867+
868+
869+@Callable(ch)
870+func remove_liquidity (dh) = if ((size(ch.payments) != 1))
871+ then throw("size( payments ) != 1")
872+ else {
873+ let aq = ch.payments[0]
874+ if ((aq.assetId != v))
875+ then throw("unknown token")
876+ else {
877+ let di = if ((dh == "0"))
878+ then nil
879+ else ae(split(dh, ","))
880+ if (if ((dh != "0"))
881+ then (size(di) != a)
882+ else false)
883+ then throw("min_amounts.size() != N_COINS")
884+ else {
885+ let cB = aq.amount
886+ let dj = ch.caller
887+ func U (V,al) = {
888+ let dk = af[al]
889+ let dl = fraction(dk, cB, w)
890+ if (if ((dh != "0"))
891+ then (di[al] > dl)
892+ else false)
893+ then throw("withdrawal resulted in fewer coins than expected")
894+ else $Tuple2((V._1 :+ ScriptTransfer(dj, dl, fromBase58String(q[al]))), (V._2 :+ (dk - dl)))
895+ }
896+
897+ let dm = {
898+ let X = am
899+ let Y = size(X)
900+ let Z = $Tuple2(nil, nil)
901+ func aa (ab,ac) = if ((ac >= Y))
902+ then ab
903+ else U(ab, X[ac])
904+
905+ func ad (ab,ac) = if ((ac >= Y))
906+ then ab
907+ else throw("List size exceeds 10")
908+
909+ ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
910+ }
911+ let dn = dm._1
912+ let cU = dm._2
913+ (dn ++ [StringEntry("balances", makeString(S(cU), ",")), Burn(v, cB)])
914+ }
915+ }
916+ }
917+
918+
919+
920+@Callable(ch)
921+func calc_withdraw_one_coin (bv,au) = $Tuple2(nil, bu(bv, au)._1)
922+
923+
924+
925+@Callable(ch)
926+func remove_liquidity_one_coin (au,do) = if (Q(!(H)))
927+ then throw("is killed")
928+ else if ((size(ch.payments) != 1))
929+ then throw("size( payments ) != 1")
930+ else {
931+ let aq = ch.payments[0]
932+ if ((aq.assetId != v))
933+ then throw("unknown token")
934+ else {
935+ let bv = aq.amount
936+ let dp = bu(bv, au)
937+ let bF = dp._1
938+ let dc = dp._2
939+ let aU = dp._3
940+ if (Q((bF >= do)))
941+ then throw("not enough coins removed")
942+ else {
943+ let df = fraction(dc, s, f)
944+ let dq = (bF + df)
945+ func U (V,al) = (V :+ (af[al] - (if ((al == au))
946+ then dq
947+ else 0)))
948+
949+ let cU = {
950+ let X = am
951+ let Y = size(X)
952+ let Z = nil
953+ func aa (ab,ac) = if ((ac >= Y))
954+ then ab
955+ else U(ab, X[ac])
956+
957+ func ad (ab,ac) = if ((ac >= Y))
958+ then ab
959+ else throw("List size exceeds 10")
960+
961+ ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
962+ }
963+ let dg = fromBase58String(q[au])
964+ $Tuple2((([StringEntry("balances", makeString(S(cU), ",")), ScriptTransfer(ch.caller, bF, dg), Burn(v, bv)] ++ (if (if (t)
965+ then (df > 0)
966+ else false)
967+ then [ScriptTransfer(u, df, dg)]
968+ else nil)) ++ bH(aU, fraction(fraction(dc, e, ag[au]), f, r))), bF)
969+ }
970+ }
971+ }
972+
973+
974+
975+@Callable(ch)
976+func A () = $Tuple2(nil, ax())
977+
978+
979+
980+@Callable(ch)
981+func get_virtual_price () = {
982+ let aU = aF(ao(af), ax())
983+ $Tuple2(nil, bG(aU))
984+ }
985+
986+
987+
988+@Callable(ch)
989+func calc_token_amount (dr,ds) = {
990+ let dt = ae(split(dr, ","))
991+ if ((size(dt) != a))
992+ then throw("not enought amounts")
993+ else {
994+ let aH = ax()
995+ let bx = aF(ao(dt), aH)
996+ func U (V,al) = (V :+ (af[al] + (if (ds)
997+ then dt[al]
998+ else -(dt[al]))))
999+
1000+ let cE = {
1001+ let X = am
1002+ let Y = size(X)
1003+ let Z = nil
1004+ func aa (ab,ac) = if ((ac >= Y))
1005+ then ab
1006+ else U(ab, X[ac])
1007+
1008+ func ad (ab,ac) = if ((ac >= Y))
1009+ then ab
1010+ else throw("List size exceeds 10")
1011+
1012+ ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1013+ }
1014+ let by = aF(ao(cE), aH)
1015+ let du = w
1016+ let dv = if (ds)
1017+ then (by - bx)
1018+ else (bx - by)
1019+ $Tuple2(nil, fraction(dv, du, bx))
1020+ }
1021+ }
1022+
1023+
1024+
1025+@Callable(ch)
1026+func ramp_A (dw,dx) = if (Q((ch.caller == u)))
1027+ then throw("only owner")
1028+ else if (Q((P >= (z + n))))
1029+ then throw("too often")
1030+ else if (Q((dx >= (P + n))))
1031+ then throw("insufficient time")
1032+ else {
1033+ let dy = ax()
1034+ if (Q(if ((dw > 0))
1035+ then (k > dw)
1036+ else false))
1037+ then throw("out of base range")
1038+ else if (Q(if (if ((dw >= dy))
1039+ then ((dy * l) >= dw)
1040+ else false)
1041+ then true
1042+ else if ((dy > dw))
1043+ then ((dw * l) >= dy)
1044+ else false))
1045+ then throw("out of range")
1046+ else [IntegerEntry("initial_A", dy), IntegerEntry("future_A", dw), IntegerEntry("initial_A_time", P), IntegerEntry("future_A_time", dx)]
1047+ }
1048+
1049+
1050+
1051+@Callable(ch)
1052+func stop_ramp_A () = if (Q((ch.caller == u)))
1053+ then throw("only owner")
1054+ else {
1055+ let dz = ax()
1056+[IntegerEntry("initial_A", dz), IntegerEntry("future_A", dz), IntegerEntry("initial_A_time", P), IntegerEntry("future_A_time", P)]
1057+ }
1058+
1059+
1060+
1061+@Callable(ch)
1062+func commit_new_fee (dA,dB) = if (Q((ch.caller == u)))
1063+ then throw("only owner")
1064+ else if (Q((C == 0)))
1065+ then throw("active action")
1066+ else if (Q((j >= dA)))
1067+ then throw("fee exceeds maximum")
1068+ else if (Q((i >= dB)))
1069+ then throw("admin fee exceeds maximum")
1070+ else {
1071+ let dC = (P + m)
1072+[IntegerEntry("admin_actions_deadline", dC), IntegerEntry("future_fee", dA), IntegerEntry("future_admin_fee", dB)]
1073+ }
1074+
1075+
1076+
1077+@Callable(ch)
1078+func apply_new_fee () = if (Q((ch.caller == u)))
1079+ then throw("only owner")
1080+ else if (Q((P >= C)))
1081+ then throw("insufficient time")
1082+ else if (Q((C != 0)))
1083+ then throw("no active action")
1084+ else [IntegerEntry("admin_actions_deadline", 0), IntegerEntry("fee", E), IntegerEntry("admin_fee", F)]
1085+
1086+
1087+
1088+@Callable(ch)
1089+func revert_new_parameters () = if (Q((ch.caller == u)))
1090+ then throw("only owner")
1091+ else [IntegerEntry("admin_actions_deadline", 0)]
1092+
1093+
1094+
1095+@Callable(ch)
1096+func commit_transfer_ownership (ci) = if (Q((ch.caller == u)))
1097+ then throw("only owner")
1098+ else if (Q((D == 0)))
1099+ then throw("active transfer")
1100+ else {
1101+ let dC = (P + m)
1102+[IntegerEntry("transfer_ownership_deadline", dC), StringEntry("future_owner", av(ci))]
1103+ }
1104+
1105+
1106+
1107+@Callable(ch)
1108+func apply_transfer_ownership () = if (Q((ch.caller == u)))
1109+ then throw("only owner")
1110+ else if (Q((P >= D)))
1111+ then throw("insufficient time")
1112+ else if (Q((D != 0)))
1113+ then throw("no active transfer")
1114+ else [IntegerEntry("transfer_ownership_deadline", 0), StringEntry("owner", G)]
1115+
1116+
1117+
1118+@Callable(ch)
1119+func revert_transfer_ownership () = if (Q((ch.caller == u)))
1120+ then throw("only owner")
1121+ else [IntegerEntry("transfer_ownership_deadline", 0)]
1122+
1123+
1124+
1125+@Callable(ch)
1126+func admin_balances (au) = $Tuple2(nil, at(au))
1127+
1128+
1129+
1130+@Callable(ch)
1131+func withdraw_admin_fees () = if (Q((ch.caller == u)))
1132+ then throw("only owner")
1133+ else {
1134+ func U (V,al) = (V :+ ScriptTransfer(u, at(al), fromBase58String(q[al])))
1135+
1136+ let X = am
1137+ let Y = size(X)
1138+ let Z = nil
1139+ func aa (ab,ac) = if ((ac >= Y))
1140+ then ab
1141+ else U(ab, X[ac])
1142+
1143+ func ad (ab,ac) = if ((ac >= Y))
1144+ then ab
1145+ else throw("List size exceeds 10")
1146+
1147+ ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1148+ }
1149+
1150+
1151+
1152+@Callable(ch)
1153+func donate_admin_fees () = if (Q((ch.caller == u)))
1154+ then throw("only owner")
1155+ else {
1156+ func U (V,al) = (V :+ (af[al] + at(al)))
1157+
1158+ let cE = {
1159+ let X = am
1160+ let Y = size(X)
1161+ let Z = nil
1162+ func aa (ab,ac) = if ((ac >= Y))
1163+ then ab
1164+ else U(ab, X[ac])
1165+
1166+ func ad (ab,ac) = if ((ac >= Y))
1167+ then ab
1168+ else throw("List size exceeds 10")
1169+
1170+ ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1171+ }
1172+[StringEntry("balances", makeString(S(cE), ","))]
1173+ }
1174+
1175+
1176+
1177+@Callable(ch)
1178+func set_auto_fees (dD) = if (Q((ch.caller == u)))
1179+ then throw("only owner")
1180+ else [BooleanEntry("is_auto_fees", dD)]
1181+
1182+
1183+
1184+@Callable(ch)
1185+func kill_me () = if (Q((ch.caller == u)))
1186+ then throw("only owner")
1187+ else if (Q((I > P)))
1188+ then throw("deadline has passed")
1189+ else [BooleanEntry("is_killed", true)]
1190+
1191+
1192+
1193+@Callable(ch)
1194+func unkill_me () = if (Q((ch.caller == u)))
1195+ then throw("only owner")
1196+ else [BooleanEntry("is_killed", false)]
1197+
1198+
1199+
1200+@Callable(ch)
1201+func set_height_address (dE) = if ((ch.caller != u))
1202+ then throw("only owner")
1203+ else [StringEntry("heightAddress", av(dE))]
1204+
1205+
1206+
1207+@Callable(au)
1208+func set_verifier (dF) = if ((au.caller != this))
1209+ then throw("self call only")
1210+ else {
1211+ let dG = {
1212+ let ar = addressFromString(dF)
1213+ if ($isInstanceOf(ar, "Address"))
1214+ then {
1215+ let R = ar
1216+ true
1217+ }
1218+ else false
1219+ }
1220+ if (!(dG))
1221+ then throw(("verifier wrong address " + dF))
1222+ else if (isDefined(getString(this, "verifier")))
1223+ then throw("verifier already defined")
1224+ else [StringEntry("verifier", dF)]
1225+ }
1226+
1227+
1228+@Verifier(dH)
1229+func dI () = {
1230+ let ar = getString(this, "verifier")
1231+ if ($isInstanceOf(ar, "String"))
1232+ then {
1233+ let dF = ar
1234+ valueOrElse(getBoolean(addressFromStringValue(dF), ((("status_" + toString(this)) + "_") + toBase58String(dH.id))), false)
1235+ }
1236+ else sigVerify(dH.bodyBytes, dH.proofs[0], dH.senderPublicKey)
1237+ }
1238+

github/deemru/w8io/169f3d6 
77.56 ms