w8 · tx · 8iz···ZUM

tx · 8izLCTE3yVT8ynDQSJ812eRMzX6mRA5en3n7nGg9PZUM

3MzKSdTH2jFbypLsoNfrH7QgkzSbx3EYwCA:  -0.04100000 Waves

2023.06.01 15:34 [2603600] smart account 3MzKSdTH2jFbypLsoNfrH7QgkzSbx3EYwCA > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "8izLCTE3yVT8ynDQSJ812eRMzX6mRA5en3n7nGg9PZUM",
    "fee": 4100000,
    "feeAssetId": null,
    "timestamp": 1685622914690,
    "version": 2,
    "chainId": 84,
    "sender": "3MzKSdTH2jFbypLsoNfrH7QgkzSbx3EYwCA",
    "senderPublicKey": "35yd3qw1gxKDxKwGAykHN9fANbXNWwseaUwbWDj24o3x",
    "proofs": [
        "2ovHsYn37BWkaKG4W3diNfoaRzCTeJAhLh2GxUnrP4Aq97VttwPqx6AtebFESEpEXikDw2ZhuytDcPMSzTz5bt8J"
    ],
    "script": "base64:BgKALQgCEgUKAwEEARIHCgUBBAEIARIDCgEIEgQKAgEEEgQKAgEEEgMKAQESABIECgIIARIAEgQKAggBEgQKAggBEgQKAgEBEgMKAQESBQoDAQEBEgUKAwEIARIECgIBCBIECgIBCBIECgIICBIAEgMKAQgSBQoDAQEBEgQKAggBEgQKAgEBEgQKAggIEgsKCQgBAQIBAggEBBIGCgQICAEIEgAiBnNjYWxlOCIMc2NhbGU4QmlnSW50IgdzY2FsZTE4Igp6ZXJvQmlnSW50IgRiaWcwIgRiaWcxIgRiaWcyIgRiaWczIgRiaWc0IgpzbGlwcGFnZTREIgt3YXZlc1N0cmluZyIKYW1wSW5pdGlhbCIFQW11bHQiBURjb252IgNTRVAiBUVNUFRZIgpQb29sQWN0aXZlIgpQb29sUHV0RGlzIg5Qb29sTWF0Y2hlckRpcyIMUG9vbFNodXRkb3duIg5pZHhQb29sQWRkcmVzcyIJaWR4UG9vbFN0IglpZHhMUEFzSWQiCWlkeEFtQXNJZCIJaWR4UHJBc0lkIgtpZHhBbXRBc0RjbSINaWR4UHJpY2VBc0RjbSILaWR4SUFtdEFzSWQiDWlkeElQcmljZUFzSWQiD2lkeEZhY3RTdGFrQ250ciISaWR4RmFjdG9yeVJlc3RDbnRyIhBpZHhGYWN0U2xpcHBDbnRyIhFpZHhGYWN0R3d4UmV3Q250ciIKZmVlRGVmYXVsdCICdDEiB29yaWdWYWwiDW9yaWdTY2FsZU11bHQiCHQxQmlnSW50IgJmMSIDdmFsIg9yZXN1bHRTY2FsZU11bHQiDGZyb21YMThSb3VuZCIFcm91bmQiAnQyIgJmMiICdHMiA2FtdCIIcmVzU2NhbGUiCGN1clNjYWxlIgNhYnMiCWFic0JpZ0ludCICZmMiE2tleU1hbmFnZXJQdWJsaWNLZXkiFmtleU1hbmFnZXJWYXVsdEFkZHJlc3MiAnBsIgJwaCIBaCIBdCIDcGF1IgJ1YSIEdHhJZCIDZ2F1IgJhYSICcGEiA2FtcCINa2V5QW1wSGlzdG9yeSIMaGVpZ2h0QmxvY2tzIhRrZXlDaGFuZ2VBbXBMYXN0Q2FsbCIGa2V5RmVlIgNmZWUiBmtleURMcCIVa2V5RExwUmVmcmVzaGVkSGVpZ2h0IhJrZXlETHBSZWZyZXNoRGVsYXkiFmRMcFJlZnJlc2hEZWxheURlZmF1bHQiD2RMcFJlZnJlc2hEZWxheSIEZmNmZyIEbXRwayICcGMiBmlBbXRBcyIFaVByQXMiA21iYSIFYkFTdHIiA2FwcyIca2V5QWxsb3dlZExwU3RhYmxlU2NyaXB0SGFzaCIWa2V5RmVlQ29sbGVjdG9yQWRkcmVzcyIWa2V5U2tpcE9yZGVyVmFsaWRhdGlvbiILcG9vbEFkZHJlc3MiD3Rocm93T3JkZXJFcnJvciIKb3JkZXJWYWxpZCIOb3JkZXJWYWxpZEluZm8iC3NlbmRlclZhbGlkIgxtYXRjaGVyVmFsaWQiF2FkZHJlc3NGcm9tU3RyaW5nT3JUaGlzIg1hZGRyZXNzU3RyaW5nIgckbWF0Y2gwIgFhIhxnZXRNYW5hZ2VyVmF1bHRBZGRyZXNzT3JUaGlzIg5mYWN0b3J5QWRkcmVzcyIDZmNhIgFzIgRzdHJmIgRhZGRyIgNrZXkiBGludGYiCHRocm93RXJyIgNtc2ciBmZtdEVyciIFaW5GZWUiAUAiBm91dEZlZSIBQSIDaWdzIgJtcCITZmVlQ29sbGVjdG9yQWRkcmVzcyIDZ3BjIgVhbXRBcyIHcHJpY2VBcyIIaVByaWNlQXMiDHBhcnNlQXNzZXRJZCIFaW5wdXQiD2Fzc2V0SWRUb1N0cmluZyIPcGFyc2VQb29sQ29uZmlnIgpwb29sQ29uZmlnIhBwb29sQ29uZmlnUGFyc2VkIgskdDA4NjA4ODc5NCIOY2ZnUG9vbEFkZHJlc3MiDWNmZ1Bvb2xTdGF0dXMiDGNmZ0xwQXNzZXRJZCIQY2ZnQW1vdW50QXNzZXRJZCIPY2ZnUHJpY2VBc3NldElkIhZjZmdBbW91bnRBc3NldERlY2ltYWxzIhVjZmdQcmljZUFzc2V0RGVjaW1hbHMiA2dmYyINZmFjdG9yeUNvbmZpZyIPc3Rha2luZ0NvbnRyYWN0Ig9zbGlwYWdlQ29udHJhY3QiC2d3eENvbnRyYWN0IgxyZXN0Q29udHJhY3QiEWRhdGFQdXRBY3Rpb25JbmZvIg1pbkFtdEFzc2V0QW10Ig9pblByaWNlQXNzZXRBbXQiCG91dExwQW10IgVwcmljZSIKc2xpcEJ5VXNlciIMc2xpcHBhZ2VSZWFsIgh0eEhlaWdodCILdHhUaW1lc3RhbXAiDHNsaXBhZ2VBbUFtdCIMc2xpcGFnZVByQW10IhFkYXRhR2V0QWN0aW9uSW5mbyIOb3V0QW10QXNzZXRBbXQiEG91dFByaWNlQXNzZXRBbXQiB2luTHBBbXQiDWdldEFjY0JhbGFuY2UiB2Fzc2V0SWQiBGNwYmkiCHByQW10WDE4IghhbUFtdFgxOCIFY3BiaXIiA3ZhZCICQTEiAkEyIghzbGlwcGFnZSIEZGlmZiIEcGFzcyICdmQiAkQxIgJEMCIEc2xwZyIEZmFpbCIDcGNwIgphbUFzc2V0RGNtIgpwckFzc2V0RGNtIgVhbUFtdCIFcHJBbXQiC2FtdEFzQW10WDE4IgpwckFzQW10WDE4IgpjYWxjUHJpY2VzIgVscEFtdCIIYW10QXNEY20iB3ByQXNEY20iCHByaWNlWDE4IghscEFtdFgxOCINbHBQckluQW1Bc1gxOCINbHBQckluUHJBc1gxOCIPY2FsY3VsYXRlUHJpY2VzIgFwIgd0YWtlRmVlIgZhbW91bnQiCWZlZUFtb3VudCIEZ2V0RCICeHAiA3hwMCIDeHAxIgNhbm4iC3hwMF94cDFfbl9uIgVhbm5fcyIFYW5uXzEiCWNhbGNETmV4dCIBZCICZGQiA2RkZCICZHAiBGNhbGMiA2FjYyIBaSIFZE5leHQiCGREaWZmUmF3IgVkRGlmZiIDYXJyIg0kdDAxMzI5OTEzMzQ3IgIkbCICJHMiBSRhY2MwIgUkZjBfMSICJGEiAiRpIgUkZjBfMiIFZm91bmQiA2VnbyIGdHhJZDU4IgpwbXRBc3NldElkIghwbXRMcEFtdCILdXNlckFkZHJlc3MiBGxwSWQiBGFtSWQiBHBySWQiBWFtRGNtIgVwckRjbSIDc3RzIgdscEVtaXNzIglhbUJhbGFuY2UiDGFtQmFsYW5jZVgxOCIJcHJCYWxhbmNlIgxwckJhbGFuY2VYMTgiC2N1clByaWNlWDE4IghjdXJQcmljZSILcG10THBBbXRYMTgiCmxwRW1pc3NYMTgiC291dEFtQW10WDE4IgtvdXRQckFtdFgxOCIIb3V0QW1BbXQiCG91dFByQW10IgVzdGF0ZSIDZXBvIgdpbkFtQW10IgZpbkFtSWQiB2luUHJBbXQiBmluUHJJZCIGaXNFdmFsIgZlbWl0THAiCmlzT25lQXNzZXQiEHZhbGlkYXRlU2xpcHBhZ2UiBnBtdEFtdCIFcG10SWQiB2FtSWRTdHIiB3BySWRTdHIiBmFtdERjbSIIcHJpY2VEY20iBGxwRW0iD2luQW1Bc3NldEFtdFgxOCIPaW5QckFzc2V0QW10WDE4Igx1c2VyUHJpY2VYMTgiAXIiBmNoZWNrRCILc2xpcHBhZ2VYMTgiD3NsaXBwYWdlUmVhbFgxOCINbHBFbWlzc2lvblgxOCIKcHJWaWFBbVgxOCIKYW1WaWFQclgxOCIMZXhwZWN0ZWRBbXRzIhFleHBBbXRBc3NldEFtdFgxOCITZXhwUHJpY2VBc3NldEFtdFgxOCIJY2FsY0xwQW10Ig5jYWxjQW1Bc3NldFBtdCIOY2FsY1ByQXNzZXRQbXQiDHNsaXBwYWdlQ2FsYyIJZW1pdExwQW10IgZhbURpZmYiBnByRGlmZiINJHQwMjExMDkyMTQ1NCIKd3JpdGVBbUFtdCIKd3JpdGVQckFtdCILY29tbW9uU3RhdGUiBWdldFlEIgFEIgFuIgF4IgphUHJlY2lzaW9uIgFjIgFiIgNjdXIiDSR0MDIyNjQ5MjI2NjkiAXkiBXlOZXh0IgV5RGlmZiINJHQwMjI5NzYyMzAyMyIHY2FsY0RMcCINYW1vdW50QmFsYW5jZSIMcHJpY2VCYWxhbmNlIgpscEVtaXNzaW9uIgp1cGRhdGVkRExwIg5jYWxjQ3VycmVudERMcCIQYW1vdW50QXNzZXREZWx0YSIPcHJpY2VBc3NldERlbHRhIhRscEFzc2V0RW1pc3Npb25EZWx0YSISYW1vdW50QXNzZXRCYWxhbmNlIhFwcmljZUFzc2V0QmFsYW5jZSIPbHBBc3NldEVtaXNzaW9uIgpjdXJyZW50RExwIhJyZWZyZXNoRExwSW50ZXJuYWwiF2Ftb3VudEFzc2V0QmFsYW5jZURlbHRhIhZwcmljZUFzc2V0QmFsYW5jZURlbHRhIgdhY3Rpb25zIhJ2YWxpZGF0ZVVwZGF0ZWRETHAiBm9sZERMcCIbdmFsaWRhdGVNYXRjaGVyT3JkZXJBbGxvd2VkIgVvcmRlciIRYW1vdW50QXNzZXRBbW91bnQiEHByaWNlQXNzZXRBbW91bnQiDSR0MDI1MjIxMjU0MzMiA2RMcCINJHQwMjU3NzUyNTg3NSINdW51c2VkQWN0aW9ucyIGZExwTmV3Igxpc09yZGVyVmFsaWQiBGluZm8iAmNnIgNwbXQiAmNwIgZjYWxsZXIiB2FtQXNQbXQiB3ByQXNQbXQiDWNhbGNQdXRPbmVUa24iCXBtdEFtdFJhdyILd2l0aFRha2VGZWUiDWNoZWNoRW1pc3Npb24iDSR0MDI4NTMxMjg5OTMiDGFtQmFsYW5jZU9sZCIMcHJCYWxhbmNlT2xkIg0kdDAyODk5OTI5MTc1IgthbUFtb3VudFJhdyILcHJBbW91bnRSYXciDSR0MDI5MTc5Mjk0MzMiCGFtQW1vdW50IghwckFtb3VudCIMYW1CYWxhbmNlTmV3IgxwckJhbGFuY2VOZXciCGxwQW1vdW50Ig5wb29sUHJvcG9ydGlvbiIPYW1vdW50QXNzZXRQYXJ0Ig5wcmljZUFzc2V0UGFydCIJbHBBbXRCb3RoIgVib251cyITZ2V0T25lVGtuVjJJbnRlcm5hbCIKb3V0QXNzZXRJZCIMbWluT3V0QW1vdW50IghwYXltZW50cyIMb3JpZ2luQ2FsbGVyIg10cmFuc2FjdGlvbklkIgphbURlY2ltYWxzIgpwckRlY2ltYWxzIgpwb29sU3RhdHVzIg0kdDAzMTU0NTMxNjU2Igh0b3RhbEdldCILdG90YWxBbW91bnQiDSR0MDMxODQ2MzIxNTMiBW91dEFtIgVvdXRQciIIY3VyUHJYMTgiBWN1clByIhFvdXRBc3NldElkT3JXYXZlcyIQc2VuZEZlZVRvTWF0Y2hlciIEYnVybiINJHQwMzI5MzgzMzI4OCIQZmVlQW1vdW50Rm9yQ2FsYyIQb3V0SW5BbW91bnRBc3NldCINJHQwMzMyOTEzMzM5OSIRcmVmcmVzaERMcEFjdGlvbnMiEWlzVXBkYXRlZERMcFZhbGlkIhZtYW5hZ2VyUHVibGljS2V5T3JVbml0IhNtYW5hZ2VyVmF1bHRBZGRyZXNzIgJwZCIJaXNNYW5hZ2VyIgJwayILbXVzdE1hbmFnZXIiBGdldFkiCWlzUmV2ZXJzZSITcG9vbEFtb3VudEluQmFsYW5jZSINJHQwMzQ4ODYzNDkwNiINJHQwMzUyMzczNTI4NCITc2tpcE9yZGVyVmFsaWRhdGlvbiINY2xlYW5BbW91bnRJbiINZmVlUG9vbEFtb3VudCINJHQwMzU2MzYzNjA2MCIIYXNzZXRPdXQiAmR5Igt0b3RhbEdldFJhdyIFbmV3WHAiBG5ld0QiDGFtb3VudE91dE1pbiIJYWRkcmVzc1RvIgtzd2FwQ29udGFjdCIGY2hlY2tzIgdhc3NldEluIg0kdDAzNzQ5NjM3ODkwIghjaGVja01pbiIEc2xpcCIJYXV0b1N0YWtlIgdmYWN0Q2ZnIgtzdGFraW5nQ250ciIIc2xpcENudHIiCmFtQXNzZXRQbXQiCnByQXNzZXRQbXQiAWUiCWxwQXNzZXRJZCICZWwiBmxlZ2FjeSICc2EiAnNwIghscFRybnNmciICc3MiDSR0MDQyMDM0NDIxNzYiBWNoZWNrIhRscEFzc2V0RW1pc3Npb25BZnRlciIgaXNQb29sT25lVG9rZW5PcGVyYXRpb25zRGlzYWJsZWQiDWlzUHV0RGlzYWJsZWQiDSR0MDQzODE3NDM5NzUiB2VzdGltTFAiDSR0MDQ0ODYwNDUyMDkiFHBheW1lbnRJbkFtb3VudEFzc2V0Ig0kdDA0NTIxMjQ1MzIwIgdtYXhTbHBnIgZlc3RQdXQiDSR0MDQ2MzUwNDY0MTUiCW91dEFtdEFtdCINJHQwNDc1ODg0NzY3MCINaXNHZXREaXNhYmxlZCINJHQwNDgyODg0ODQ0MyIYbGFzdFJlZnJlc2hlZEJsb2NrSGVpZ2h0Ih1jaGVja0xhc3RSZWZyZXNoZWRCbG9ja0hlaWdodCINJHQwNDg5Njc0OTAzMSIQZExwVXBkYXRlQWN0aW9ucyINbHBBc3NldEFtb3VudCIFaW5kZXgiBG5ld1kiDSR0MDUwMDQxNTAwOTYiDSR0MDUwNDcxNTA1ODYiDnN1bU9mR2V0QXNzZXRzIhJub0xlc3NUaGVuQW10QXNzZXQiFG5vTGVzc1RoZW5QcmljZUFzc2V0IhRidXJuTFBBc3NldE9uRmFjdG9yeSINJHQwNTE3NTI1MTgzMyINY2hlY2tQYXltZW50cyIKZmFjdG9yeUNmZyIHc3Rha2luZyIKdW5zdGFrZUludiIBdiIFYnVybkEiDSR0MDUyODYwNTI5NDEiDXVuc3Rha2VBbW91bnQiFW5vTGVzc1RoZW5BbW91bnRBc3NldCIDcmVzIgxjaGVja0Ftb3VudHMiDSR0MDU0MTkyNTQyNzMiF2xwQXNzZXRSZWNpcGllbnRBZGRyZXNzIg0kdDA1NTI5NTU1NDgzIhBwYXltZW50QW1vdW50UmF3Ig5wYXltZW50QXNzZXRJZCINJHQwNTU2MTE1NTcxNCINJHQwNTU4NjI1NTk2NiIIYW10QXNTdHIiB3ByQXNTdHIiAnByIgxyZXNTY2FsZU11bHQiB3VzckFkZHIiB3BtdEFzSWQiA2NmZyINJHQwNTgzNzU1ODU3NCIEbGlzdCIFZGVsYXkiBWRlbHRhIgZ0YXJnZXQiBmN1ckFtcCIJbmV3QW1wUmF3IgZuZXdBbXAiCGxhc3RDYWxsIgR3YWl0IgJ0eCIGdmVyaWZ5Ig90YXJnZXRQdWJsaWNLZXkiCm1hdGNoZXJQdWIiDSR0MDU5NTA3NTk2MjQiB25ld0hhc2giC2FsbG93ZWRIYXNoIgtjdXJyZW50SGFzaIUBAAFhAIDC1y8AAWIJALYCAQCAwtcvAAFjCQC2AgEAgICQu7rWrfANAAFkCQC2AgEAAAABZQkAtgIBAAAAAWYJALYCAQABAAFnCQC2AgEAAgABaAkAtgIBAAMAAWkJALYCAQAEAAFqCQC2AgEJAGUCBQFhCQBpAgkAaAIFAWEAAQUBYQABawIFV0FWRVMAAWwAMgABbQIDMTAwAAFuAgExAAFvAgJfXwABcAIAAAFxAAEAAXIAAgABcwADAAF0AAQAAXUAAQABdgACAAF3AAMAAXgABAABeQAFAAF6AAYAAUEABwABQgAIAAFDAAkAAUQAAQABRQAGAAFGAAcAAUcACgABSAkAawMACgUBYQCQTgEBSQIBSgFLCQC8AgMJALYCAQUBSgUBYwkAtgIBBQFLAQFMAgFKAUsJALwCAwUBSgUBYwUBSwEBTQIBTgFPCQCgAwEJALwCAwUBTgkAtgIBBQFPBQFjAQFQAwFOAU8BUQkAoAMBCQC9AgQFAU4JALYCAQUBTwUBYwUBUQEBUgIBSgFLCQC8AgMFAUoFAWMJALYCAQUBSwEBUwIBTgFPCQC8AgMFAU4JALYCAQUBTwUBYwEBVAMBVQFWAVcJAGsDBQFVBQFWBQFXAQFYAQFOAwkAvwICBQFkBQFOCQC+AgEFAU4FAU4BAVkBAU4DCQC/AgIFAWQFAU4JAL4CAQUBTgUBTgEBWgACEyVzX19mYWN0b3J5Q29udHJhY3QBAmFhAAIUJXNfX21hbmFnZXJQdWJsaWNLZXkBAmFiAAIXJXNfX21hbmFnZXJWYXVsdEFkZHJlc3MBAmFjAAIRJXMlc19fcHJpY2VfX2xhc3QBAmFkAgJhZQJhZgkAuQkCCQDMCAICGCVzJXMlZCVkX19wcmljZV9faGlzdG9yeQkAzAgCCQCkAwEFAmFlCQDMCAIJAKQDAQUCYWYFA25pbAUBbwECYWcCAmFoAmFpCQCsAgIJAKwCAgkArAICAgslcyVzJXNfX1BfXwUCYWgCAl9fBQJhaQECYWoCAmFoAmFpCQCsAgIJAKwCAgkArAICAgslcyVzJXNfX0dfXwUCYWgCAl9fBQJhaQECYWsAAg8lc19fYW1vdW50QXNzZXQBAmFsAAIOJXNfX3ByaWNlQXNzZXQBAmFtAAIHJXNfX2FtcAECYW4BAmFvCQCsAgICCyVzJWRfX2FtcF9fCQCkAwEFAmFvAQJhcAACFSVzX19jaGFuZ2VBbXBMYXN0Q2FsbAACYXECByVzX19mZWUAAmFyCQELdmFsdWVPckVsc2UCCQCaCAIFBHRoaXMFAmFxBQFIAAJhcwkAuQkCCQDMCAICAiVzCQDMCAICA2RMcAUDbmlsBQFvAAJhdAkAuQkCCQDMCAICAiVzCQDMCAICEmRMcFJlZnJlc2hlZEhlaWdodAUDbmlsBQFvAAJhdQkAuQkCCQDMCAICAiVzCQDMCAICD3JlZnJlc2hETHBEZWxheQUDbmlsBQFvAAJhdgAeAAJhdwkBC3ZhbHVlT3JFbHNlAgkAmggCBQR0aGlzBQJhdQUCYXYBAmF4AAIRJXNfX2ZhY3RvcnlDb25maWcBAmF5AAIYJXMlc19fbWF0Y2hlcl9fcHVibGljS2V5AQJhegICYUECYUIJAKwCAgkArAICCQCsAgIJAKwCAgIIJWQlZCVzX18FAmFBAgJfXwUCYUICCF9fY29uZmlnAQJhQwECYUQJAKwCAgIoJXMlcyVzX19tYXBwaW5nc19fYmFzZUFzc2V0MmludGVybmFsSWRfXwUCYUQBAmFFAAIMJXNfX3NodXRkb3duAQJhRgACHSVzX19hbGxvd2VkTHBTdGFibGVTY3JpcHRIYXNoAQJhRwACFyVzX19mZWVDb2xsZWN0b3JBZGRyZXNzAQJhSAECYUkJAKwCAgIbJXMlc19fc2tpcE9yZGVyVmFsaWRhdGlvbl9fBQJhSQECYUoEAmFLAmFMAmFNAmFOCQACAQkArAICCQCsAgIJAKwCAgkArAICCQCsAgIJAKwCAgkArAICCQCsAgICJG9yZGVyIHZhbGlkYXRpb24gZmFpbGVkOiBvcmRlclZhbGlkPQkApQMBBQJhSwICICgFAmFMAgEpAg0gc2VuZGVyVmFsaWQ9CQClAwEFAmFNAg4gbWF0Y2hlclZhbGlkPQkApQMBBQJhTgECYU8BAmFQBAJhUQkApggBBQJhUAMJAAECBQJhUQIHQWRkcmVzcwQCYVIFAmFRBQJhUgUEdGhpcwECYVMABAJhVAQCYVEJAKIIAQkBAVoAAwkAAQIFAmFRAgZTdHJpbmcEAmFVBQJhUQkBAmFPAQUCYVUFBHRoaXMEAmFRCQCdCAIFAmFUCQECYWIAAwkAAQIFAmFRAgZTdHJpbmcEAmFWBQJhUQkBAmFPAQUCYVYFBHRoaXMBAmFXAgJhWAJhWQkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCdCAIFAmFYBQJhWQkAuQkCCQDMCAICCm1hbmRhdG9yeSAJAMwIAgkApQgBBQJhWAkAzAgCAgEuCQDMCAIFAmFZCQDMCAICDCBub3QgZGVmaW5lZAUDbmlsAgABAmFaAgJhWAJhWQkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCaCAIFAmFYBQJhWQkAuQkCCQDMCAICCm1hbmRhdG9yeSAJAMwIAgkApQgBBQJhWAkAzAgCAgEuCQDMCAIFAmFZCQDMCAICDCBub3QgZGVmaW5lZAUDbmlsAgABAmJhAQJiYgkAAgEJALkJAgkAzAgCAg9scF9zdGFibGUucmlkZToJAMwIAgUCYmIFA25pbAIBIAECYmMBAmJiCQC5CQIJAMwIAgIPbHBfc3RhYmxlLnJpZGU6CQDMCAIFAmJiBQNuaWwCASAAAmFVCQERQGV4dHJOYXRpdmUoMTA2MikBCQECYVcCBQR0aGlzCQEBWgAAAmJkCgACYmUJAPwHBAUCYVUCEGdldEluRmVlUkVBRE9OTFkJAMwIAgkApQgBBQR0aGlzBQNuaWwFA25pbAMJAAECBQJiZQIDSW50BQJiZQkAAgEJAKwCAgkAAwEFAmJlAhggY291bGRuJ3QgYmUgY2FzdCB0byBJbnQAAmJmCgACYmUJAPwHBAUCYVUCEWdldE91dEZlZVJFQURPTkxZCQDMCAIJAKUIAQUEdGhpcwUDbmlsBQNuaWwDCQABAgUCYmUCA0ludAUCYmUJAAIBCQCsAgIJAAMBBQJiZQIYIGNvdWxkbid0IGJlIGNhc3QgdG8gSW50AAJiZwkBAmFXAgUEdGhpcwkBAmFtAAECYmgACQELdmFsdWVPckVsc2UCCQCbCAIFAmFVCQECYUUABwECYmkACQDZBAEJAQJhVwIFAmFVCQECYXkAAAJiagkBEUBleHRyTmF0aXZlKDEwNjIpAQkBAmFXAgUCYVUJAQJhRwABAmJrAAQCYmwJAQJhVwIFBHRoaXMJAQJhawAEAmJtCQECYVcCBQR0aGlzCQECYWwABAJibgkBAmFaAgUCYVUJAQJhQwEFAmJtBAJhQQkBAmFaAgUCYVUJAQJhQwEFAmJsCQC1CQIJAQJhVwIFAmFVCQECYXoCCQCkAwEFAmFBCQCkAwEFAmJuBQFvAQJibwECYnADCQAAAgUCYnAFAWsFBHVuaXQJANkEAQUCYnABAmJxAQJicAMJAAACBQJicAUEdW5pdAUBawkA2AQBCQEFdmFsdWUBBQJicAECYnIBAmJzCQCZCgcJARFAZXh0ck5hdGl2ZSgxMDYyKQEJAJEDAgUCYnMFAXUJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQJicwUBdgkA2QQBCQCRAwIFAmJzBQF3CQECYm8BCQCRAwIFAmJzBQF4CQECYm8BCQCRAwIFAmJzBQF5CQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUCYnMFAXoJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQJicwUBQQACYnQJAQJicgEJAQJiawAAAmJ1BQJidAACYnYIBQJidQJfMQACYncIBQJidQJfMgACYngIBQJidQJfMwACYnkIBQJidQJfNAACYnoIBQJidQJfNQACYkEIBQJidQJfNgACYkIIBQJidQJfNwECYkMACQC1CQIJAQJhVwIFAmFVCQECYXgABQFvAAJiRAkBAmJDAAACYkUJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkApggBCQCRAwIFAmJEBQFEAiBJbnZhbGlkIHN0YWtpbmcgY29udHJhY3QgYWRkcmVzcwACYkYJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkApggBCQCRAwIFAmJEBQFGAiBJbnZhbGlkIHNsaXBhZ2UgY29udHJhY3QgYWRkcmVzcwACYkcJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkApggBCQCRAwIFAmJEBQFHAhxJbnZhbGlkIGd3eCBjb250cmFjdCBhZGRyZXNzAAJiSAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCmCAEJAJEDAgUCYkQFAUUCHEludmFsaWQgZ3d4IGNvbnRyYWN0IGFkZHJlc3MBAmJJCgJiSgJiSwJiTAJiTQJiTgJiTwJiUAJiUQJiUgJiUwkAuQkCCQDMCAICFCVkJWQlZCVkJWQlZCVkJWQlZCVkCQDMCAIJAKQDAQUCYkoJAMwIAgkApAMBBQJiSwkAzAgCCQCkAwEFAmJMCQDMCAIJAKQDAQUCYk0JAMwIAgkApAMBBQJiTgkAzAgCCQCkAwEFAmJPCQDMCAIJAKQDAQUCYlAJAMwIAgkApAMBBQJiUQkAzAgCCQCkAwEFAmJSCQDMCAIJAKQDAQUCYlMFA25pbAUBbwECYlQGAmJVAmJWAmJXAmJNAmJQAmJRCQC5CQIJAMwIAgIMJWQlZCVkJWQlZCVkCQDMCAIJAKQDAQUCYlUJAMwIAgkApAMBBQJiVgkAzAgCCQCkAwEFAmJXCQDMCAIJAKQDAQUCYk0JAMwIAgkApAMBBQJiUAkAzAgCCQCkAwEFAmJRBQNuaWwFAW8BAmJYAQJiWQMJAAACBQJiWQIFV0FWRVMICQDvBwEFBHRoaXMJYXZhaWxhYmxlCQDwBwIFBHRoaXMJANkEAQUCYlkBAmJaAgJjYQJjYgkAvAIDBQJjYQUBYwUCY2IBAmNjAwJjYQJjYgFRCQC9AgQFAmNhBQFjBQJjYgUBUQECY2QDAmNlAmNmAmNnBAJjaAkAvAIDCQC4AgIFAmNlBQJjZgUBYgUCY2YEAmNpCQC/AgIJALgCAgUCY2cJAQFYAQUCY2gFAWQDCQEBIQEFAmNpCQACAQkArAICAgpCaWcgc2xwZzogCQCmAwEFAmNoCQCUCgIFAmNpCQCZAwEJAMwIAgUCY2UJAMwIAgUCY2YFA25pbAECY2oDAmNrAmNsAmNtBAJjaAkAvAIDBQJjbAUBYgUCY2sEAmNuCQC/AgIFAmNtBQJjaAMDBQJjbgYJAL8CAgUCY2wFAmNrCQACAQkArAICCQCsAgIJAKwCAgkArAICCQCsAgIJAKwCAgkApgMBBQJjbAIBIAkApgMBBQJjawIBIAkApgMBBQJjaAIBIAkApgMBBQJjbQUCY24BAmNvBAJjcAJjcQJjcgJjcwQCY3QJAQFJAgUCY3IFAmNwBAJjdQkBAUkCBQJjcwUCY3EJAQJiWgIFAmN1BQJjdAECY3YDAmNyAmNzAmN3BAJjeAUCYkEEAmN5BQJiQgQCY3oJAQJjbwQFAmN4BQJjeQUCY3IFAmNzBAJjYgkBAUkCBQJjcgUCY3gEAmNhCQEBSQIFAmNzBQJjeQQCY0EJAQFJAgUCY3cFAWEEAmNCCQECYloCBQJjYgUCY0EEAmNDCQECYloCBQJjYQUCY0EJAMwIAgUCY3oJAMwIAgUCY0IJAMwIAgUCY0MFA25pbAECY0QDAmNyAmNzAmN3BAJjRQkBAmN2AwUCY3IFAmNzBQJjdwkAzAgCCQEBTQIJAJEDAgUCY0UAAAUBYQkAzAgCCQEBTQIJAJEDAgUCY0UAAQUBYQkAzAgCCQEBTQIJAJEDAgUCY0UAAgUBYQUDbmlsAQJjRgICY0cCYXIEAmNIAwkAAAIFAmFyAAAAAAkAawMFAmNHBQJhcgUBYQkAlAoCCQBlAgUCY0cFAmNIBQJjSAECY0kBAmNKBAJjSwkAkQMCBQJjSgAABAJjTAkAkQMCBQJjSgABBAJhVgkAtwICBQJjSwUCY0wDCQAAAgUCYVYFAWUFAWUEAmFSCQENcGFyc2VJbnRWYWx1ZQEFAmJnBAJjTQkAaAIFAmFSAAIEAmNFCQC8AgMFAmNLBQJjTAUBZgQCY04JALwCAwUCY0UFAWkFAWYEAmNPCQC8AgMJALYCAQUCY00FAmFWBQFmBAJjUAkAtgIBCQBlAgUCY00AAQoBAmNRAQJjUgQCY1MJALwCAwUCY1IFAmNSBQFmBAJjVAkAvAIDBQJjUwUCY1IFAWYEAmNVCQC8AgMFAmNUBQFmBQJjTgkAvAIDCQC3AgIFAmNPCQC8AgMFAmNVBQFnBQFmBQJjUgkAtwICCQC8AgMFAmNQBQJjUgUBZgkAvAIDBQFoBQJjVQUBZgoBAmNWAgJjVwJjWAMIBQJjVwJfMgUCY1cEAmNSCAUCY1cCXzEEAmNZCQECY1EBBQJjUgQCY1oJALgCAgUCY1kJAQV2YWx1ZQEFAmNSBAJkYQMJAL8CAgUBZQUCY1oJAL4CAQUCY1oFAmNaAwkAwAICBQFmBQJkYQkAlAoCBQJjWQYJAJQKAgUCY1kHBAJkYgkAzAgCAAAJAMwIAgABCQDMCAIAAgkAzAgCAAMJAMwIAgAECQDMCAIABQkAzAgCAAYJAMwIAgAHCQDMCAIACAkAzAgCAAkJAMwIAgAKCQDMCAIACwkAzAgCAAwJAMwIAgANCQDMCAIADgkAzAgCAA8JAMwIAgAQBQNuaWwEAmRjCgACZGQFAmRiCgACZGUJAJADAQUCZGQKAAJkZgkAlAoCBQJhVgcKAQJkZwICZGgCZGkDCQBnAgUCZGkFAmRlBQJkaAkBAmNWAgUCZGgJAJEDAgUCZGQFAmRpCgECZGoCAmRoAmRpAwkAZwIFAmRpBQJkZQUCZGgJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxNwkBAmRqAgkBAmRnAgkBAmRnAgkBAmRnAgkBAmRnAgkBAmRnAgkBAmRnAgkBAmRnAgkBAmRnAgkBAmRnAgkBAmRnAgkBAmRnAgkBAmRnAgkBAmRnAgkBAmRnAgkBAmRnAgkBAmRnAgkBAmRnAgUCZGYAAAABAAIAAwAEAAUABgAHAAgACQAKAAsADAANAA4ADwAQABEEAmNSCAUCZGMCXzEEAmRrCAUCZGMCXzIDBQJkawUCY1IJAAIBCQCsAgICGUQgY2FsY3VsYXRpb24gZXJyb3IsIEQgPSAJAKYDAQUCY1IBAmRsBAJkbQJkbgJkbwJkcAQCZHEFAmJ4BAJkcgkA2AQBCQEFdmFsdWUBBQJieQQCZHMJANgEAQkBBXZhbHVlAQUCYnoEAmR0BQJiQQQCZHUFAmJCBAJkdgkApAMBBQJidwQCZHcICQETdmFsdWVPckVycm9yTWVzc2FnZQIJAOwHAQUCZHECC1dyb25nIExQIGlkCHF1YW50aXR5AwkBAiE9AgkA2AQBBQJkcQUCZG4JAAIBAg9Xcm9uZyBwbXQgYXNzZXQEAmR4CQECYlgBBQJkcgQCZHkJAQFJAgUCZHgFAmR0BAJkegkBAmJYAQUCZHMEAmRBCQEBSQIFAmR6BQJkdQQCZEIJAQJiWgIFAmRBBQJkeQQCZEMJAQFNAgUCZEIFAWEEAmRECQEBSQIFAmRvBQFhBAJkRQkBAUkCBQJkdwUBYQQCZEYJALwCAwUCZHkFAmREBQJkRQQCZEcJALwCAwUCZEEFAmREBQJkRQQCZEgJAQFQAwUCZEYFAmR0BQVGTE9PUgQCZEkJAQFQAwUCZEcFAmR1BQVGTE9PUgQCZEoDCQAAAgUCZG0CAAUDbmlsCQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMFAmRwBQJkSAMJAAACBQJkcgIFV0FWRVMFBHVuaXQJANkEAQUCZHIJAMwIAgkBDlNjcmlwdFRyYW5zZmVyAwUCZHAFAmRJAwkAAAIFAmRzAgVXQVZFUwUEdW5pdAkA2QQBBQJkcwkAzAgCCQELU3RyaW5nRW50cnkCCQECYWoCCQClCAEFAmRwBQJkbQkBAmJUBgUCZEgFAmRJBQJkbwUCZEMFBmhlaWdodAgFCWxhc3RCbG9jawl0aW1lc3RhbXAJAMwIAgkBDEludGVnZXJFbnRyeQIJAQJhYwAFAmRDCQDMCAIJAQxJbnRlZ2VyRW50cnkCCQECYWQCBQZoZWlnaHQIBQlsYXN0QmxvY2sJdGltZXN0YW1wBQJkQwUDbmlsCQCcCgoFAmRIBQJkSQUCZHIFAmRzBQJkeAUCZHoFAmR3BQJkQgUCZHYFAmRKAQJkSw0CZG0CY2cCZEwCZE0CZE4CZE8CZHACZFACZFECZFICZFMCZFQCZFUEAmRxBQJieAQCZFYJANgEAQkBBXZhbHVlAQUCYnkEAmRXCQDYBAEJAQV2YWx1ZQEFAmJ6BAJkWAUCYkEEAmRZBQJiQgQCZHYJAKQDAQUCYncEAmRaCAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQDsBwEFAmRxAghXciBscCBhcwhxdWFudGl0eQQCZHgDBQJkUAkBAmJYAQUCZFYDAwUCZFIJAAACBQJkVQUCZFYHCQBlAgkBAmJYAQUCZFYFAmRUAwUCZFIJAQJiWAEFAmRWCQBlAgkBAmJYAQUCZFYFAmRMBAJkegMFAmRQCQECYlgBBQJkVwMDBQJkUgkAAAIFAmRVBQJkVwcJAGUCCQECYlgBBQJkVwUCZFQDBQJkUgkBAmJYAQUCZFcJAGUCCQECYlgBBQJkVwUCZE4EAmVhCQEBSQIFAmRMBQJkWAQCZWIJAQFJAgUCZE4FAmRZBAJlYwkBAmJaAgUCZWIFAmVhBAJkeQkBAUkCBQJkeAUCZFgEAmRBCQEBSQIFAmR6BQJkWQQCY2wJAQJjSQEJAMwIAgUCZHkJAMwIAgUCZEEFA25pbAQCZWQDCQAAAgUCZFoAAAQCY2sJAQJjSQEJAMwIAgkAtwICBQJkeQUCZWEJAMwIAgkAtwICBQJkQQUCZWIFA25pbAQCZWUDCQC/AgIFAmNrBQJjbAYJAAIBAhxEMSBzaG91bGQgYmUgZ3JlYXRlciB0aGFuIEQwAwkAAAIFAmVlBQJlZQQCZEIFAWQEAmVmBQFkBAJjQQUCY2sJAJcKBQkBAU0CBQJjQQUBYQkBAU0CBQJlYQUCZFgJAQFNAgUCZWIFAmRZCQECYloCCQC3AgIFAmRBBQJlYgkAtwICBQJkeQUCZWEFAmVmCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuBAJkQgkBAmJaAgUCZEEFAmR5BAJlZwkAvAIDCQEBWAEJALgCAgUCZEIFAmVjBQFjBQJkQgQCZWYJAQFJAgUCY2cFAWEDAwMFAmRTCQECIT0CBQJkQgUBZAcJAL8CAgUCZWcFAmVmBwkAAgEJAKwCAgkArAICCQCsAgICD1ByaWNlIHNsaXBwYWdlIAkApgMBBQJlZwIDID4gCQCmAwEFAmVmBAJlaAkBAUkCBQJkWgUBYQQCZWkJAL0CBAUCZWEJAQJjYwMFAmRBBQJkeQUHQ0VJTElORwUBYwUHQ0VJTElORwQCZWoJAL0CBAUCZWIFAWMJAQJjYwMFAmRBBQJkeQUFRkxPT1IFB0NFSUxJTkcEAmVrAwkAvwICBQJlaQUCZWIJAJQKAgUCZWoFAmViCQCUCgIFAmVhBQJlaQQCZWwIBQJlawJfMQQCZW0IBQJlawJfMgQCY2sJAQJjSQEJAMwIAgkAtwICBQJkeQUCZWwJAMwIAgkAtwICBQJkQQUCZW0FA25pbAQCZWUDCQC/AgIFAmNrBQJjbAYJAAIBAhxEMSBzaG91bGQgYmUgZ3JlYXRlciB0aGFuIEQwAwkAAAIFAmVlBQJlZQQCY0EJALwCAwUCZWgJALgCAgUCY2sFAmNsBQJjbAkAlwoFCQEBUAMFAmNBBQFhBQVGTE9PUgkBAVADBQJlbAUCZFgFB0NFSUxJTkcJAQFQAwUCZW0FAmRZBQdDRUlMSU5HBQJkQgUCZWYJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4EAmVuCAUCZWQCXzEEAmVvCAUCZWQCXzIEAmVwCAUCZWQCXzMEAmRDCQEBTQIIBQJlZAJfNAUBYQQCZXEJAQFNAggFAmVkAl81BQFhAwkAZwIAAAUCZW4JAAIBAgdMUCA8PSAwBAJlcgMJAQEhAQUCZFEAAAUCZW4EAmVzCQBlAgUCZEwFAmVvBAJldAkAZQIFAmROBQJlcAQCZXUDAwUCZFIJAAACBQJkVQUCZFYHCQCUCgIFAmRUAAADAwUCZFIJAAACBQJkVQUCZFcHCQCUCgIAAAUCZFQJAJQKAgUCZW8FAmVwBAJldggFAmV1Al8xBAJldwgFAmV1Al8yBAJleAkAzAgCCQEMSW50ZWdlckVudHJ5AgkBAmFjAAUCZEMJAMwIAgkBDEludGVnZXJFbnRyeQIJAQJhZAIFBmhlaWdodAgFCWxhc3RCbG9jawl0aW1lc3RhbXAFAmRDCQDMCAIJAQtTdHJpbmdFbnRyeQIJAQJhZwIFAmRwBQJkbQkBAmJJCgUCZXYFAmV3BQJlcgUCZEMFAmNnBQJlcQUGaGVpZ2h0CAUJbGFzdEJsb2NrCXRpbWVzdGFtcAUCZXMFAmV0BQNuaWwJAJ8KDQUCZW4FAmVyBQJkQwUCZHgFAmR6BQJkWgUCZHEFAmR2BQJleAUCZXMFAmV0BQJkTQUCZE8BAmV5AwJjSgJjWAJlegQCZUEFAWcEAmVCCQCRAwIFAmNKAwkAAAIFAmNYAAAAAQAABAJlQwkApwMBBQFtBAJhUgkAuQICCQCnAwEFAmJnBQJlQwQCYVYFAmVCBAJjTQkAuQICBQJhUgUCZUEEAmVECQC6AgIJALkCAgkAuQICCQC6AgIJALkCAgUCZXoFAmV6CQC5AgIFAmVCBQJlQQUCZXoFAmVDCQC5AgIFAmNNBQJlQQQCZUUJALgCAgkAtwICBQJhVgkAugICCQC5AgIFAmV6BQJlQwUCY00FAmV6CgECY1YCAmNXAmVGBAJlRwUCY1cEAmVICAUCZUcCXzEEAmRrCAUCZUcCXzIDCQECIT0CBQJkawUEdW5pdAUCY1cEAmVJCQC6AgIJALcCAgkAuQICBQJlSAUCZUgFAmVECQC3AgIJALkCAgUBZwUCZUgFAmVFBAJlSgkBAVkBCQC4AgIFAmVJCQEFdmFsdWUBBQJlSAMJAMACAgUBZgUCZUoJAJQKAgUCZUkFAmVGCQCUCgIFAmVJBQR1bml0BAJkYgkAzAgCAAAJAMwIAgABCQDMCAIAAgkAzAgCAAMJAMwIAgAECQDMCAIABQkAzAgCAAYJAMwIAgAHCQDMCAIACAkAzAgCAAkJAMwIAgAKCQDMCAIACwkAzAgCAAwJAMwIAgANCQDMCAIADgUDbmlsBAJlSwoAAmRkBQJkYgoAAmRlCQCQAwEFAmRkCgACZGYJAJQKAgUCZXoFBHVuaXQKAQJkZwICZGgCZGkDCQBnAgUCZGkFAmRlBQJkaAkBAmNWAgUCZGgJAJEDAgUCZGQFAmRpCgECZGoCAmRoAmRpAwkAZwIFAmRpBQJkZQUCZGgJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxNQkBAmRqAgkBAmRnAgkBAmRnAgkBAmRnAgkBAmRnAgkBAmRnAgkBAmRnAgkBAmRnAgkBAmRnAgkBAmRnAgkBAmRnAgkBAmRnAgkBAmRnAgkBAmRnAgkBAmRnAgkBAmRnAgUCZGYAAAABAAIAAwAEAAUABgAHAAgACQAKAAsADAANAA4ADwQCZUgIBQJlSwJfMQQCZGsIBQJlSwJfMgMJAQIhPQIFAmRrBQR1bml0BQJlSAkAAgEJAKwCAgIZWSBjYWxjdWxhdGlvbiBlcnJvciwgWSA9IAkApgMBBQJlSAECZUwDAmVNAmVOAmVPBAJlUAkAvAIDCQECY0kBCQDMCAIJAQFMAgUCZU0JALYCAQUCYkEJAMwIAgkBAUwCBQJlTgkAtgIBBQJiQgUDbmlsBQFjBQJlTwMJAAACBQJlTwUBZQUBZQUCZVABAmVRAwJlUgJlUwJlVAQCZVUJALgCAgkAtgIBCQECYlgBCQECYnEBBQJieQUCZVIEAmVWCQC4AgIJALYCAQkBAmJYAQkBAmJxAQUCYnoFAmVTBAJlVwkAuAICCQC2AgEICQEFdmFsdWUBCQDsBwEFAmJ4CHF1YW50aXR5BQJlVAQCZVgJAQJlTAMFAmVVBQJlVgUCZVcFAmVYAQJlWQMCZVoCZmECZVQEAmVVCQBkAgkBAmJYAQkBAmJxAQUCYnkFAmVaBAJlVgkAZAIJAQJiWAEJAQJicQEFAmJ6BQJmYQQCZVcJAGQCCAkBBXZhbHVlAQkA7AcBBQJieAhxdWFudGl0eQUCZVQEAmVQCQECZUwDCQC2AgEFAmVVCQC2AgEFAmVWCQC2AgEFAmVXBAJmYgkAzAgCCQEMSW50ZWdlckVudHJ5AgUCYXQFBmhlaWdodAkAzAgCCQELU3RyaW5nRW50cnkCBQJhcwkApgMBBQJlUAUDbmlsCQCUCgIFAmZiBQJlUAECZmMCAmZkAmVQAwkAwAICBQJlUAUCZmQGCQECYmEBAiJ1cGRhdGVkIERMcCBsb3dlciB0aGFuIGN1cnJlbnQgRExwAQJmZQECZmYEAmVVCQECYlgBCQECYnEBBQJieQQCZVYJAQJiWAEJAQJicQEFAmJ6BAJmZwgFAmZmBmFtb3VudAQCZmgJAG4ECAUCZmYGYW1vdW50CAUCZmYFcHJpY2UFAWEFBUZMT09SBAJmaQMJAAACCAUCZmYJb3JkZXJUeXBlBQNCdXkJAJQKAgUCZmcJAQEtAQUCZmgJAJQKAgkBAS0BBQJmZwUCZmgEAmVaCAUCZmkCXzEEAmZhCAUCZmkCXzIDAwMJAQJiaAAGCQAAAgUCYncFAXMGCQAAAgUCYncFAXQJAAIBAg1BZG1pbiBibG9ja2VkAwMJAQIhPQIICAUCZmYJYXNzZXRQYWlyC2Ftb3VudEFzc2V0BQJieQYJAQIhPQIICAUCZmYJYXNzZXRQYWlyCnByaWNlQXNzZXQFAmJ6CQACAQIJV3IgYXNzZXRzBAJmagkApwMBCQELdmFsdWVPckVsc2UCCQCdCAIFBHRoaXMFAmFzAgEwBAJmawkBAmVZAwUCZVoFAmZhAAAEAmZsCAUCZmsCXzEEAmZtCAUCZmsCXzIEAmZuCQDAAgIFAmZtBQJmagQCZm8JALkJAgkAzAgCAgRkTHA9CQDMCAIJAKYDAQUCZmoJAMwIAgIIIGRMcE5ldz0JAMwIAgkApgMBBQJmbQkAzAgCAhQgYW1vdW50QXNzZXRCYWxhbmNlPQkAzAgCCQCkAwEFAmVVCQDMCAICEyBwcmljZUFzc2V0QmFsYW5jZT0JAMwIAgkApAMBBQJlVgkAzAgCAhkgYW1vdW50QXNzZXRCYWxhbmNlRGVsdGE9CQDMCAIJAKQDAQUCZVoJAMwIAgIYIHByaWNlQXNzZXRCYWxhbmNlRGVsdGE9CQDMCAIJAKQDAQUCZmEJAMwIAgIIIGhlaWdodD0JAMwIAgkApAMBBQZoZWlnaHQFA25pbAIACQCUCgIFAmZuBQJmbwECZnABAmNYAwkBAiE9AgkAkAMBCAUCY1gIcGF5bWVudHMAAQkAAgECCjEgcG1udCBleHAEAmZxCQEFdmFsdWUBCQCRAwIIBQJjWAhwYXltZW50cwAABAJkbgkBBXZhbHVlAQgFAmZxB2Fzc2V0SWQEAmRUCAUCZnEGYW1vdW50BAJlZAkBAmRsBAkA2AQBCAUCY1gNdHJhbnNhY3Rpb25JZAkA2AQBBQJkbgUCZFQIBQJjWAZjYWxsZXIEAmRICAUCZWQCXzEEAmRJCAUCZWQCXzIEAmR2CQENcGFyc2VJbnRWYWx1ZQEIBQJlZAJfOQQCZEoIBQJlZANfMTADAwkBAmJoAAYJAAACBQJkdgUBdAkAAgEJAKwCAgIPQWRtaW4gYmxvY2tlZDogCQCkAwEFAmR2CQCXCgUFAmRIBQJkSQUCZFQFAmRuBQJkSgECZnIKAmZzAmFpAmZ0AmZ1AmNnAmRRAmRSAmRTAmRUAmRVBAJlZAkBAmRLDQUCYWkFAmNnCAkBBXZhbHVlAQUCZnQGYW1vdW50CAkBBXZhbHVlAQUCZnQHYXNzZXRJZAgJAQV2YWx1ZQEFAmZ1BmFtb3VudAgJAQV2YWx1ZQEFAmZ1B2Fzc2V0SWQFAmZzCQAAAgUCYWkCAAUCZFEFAmRSBQJkUwUCZFQFAmRVBAJkdgkBDXBhcnNlSW50VmFsdWUBCAUCZWQCXzgDAwMJAQJiaAAGCQAAAgUCZHYFAXIGCQAAAgUCZHYFAXQJAAIBCQCsAgICCEJsb2NrZWQ6CQCkAwEFAmR2BQJlZAECZnYFAmZ3AmRuAmRwAmFpAmZ4BAJkcgkA2AQBCQEFdmFsdWUBBQJieQQCZHMJANgEAQkBBXZhbHVlAQUCYnoEAmRxBQJieAQCZFgFAmJBBAJkWQUCYkIEAmVXCQC2AgEICQETdmFsdWVPckVycm9yTWVzc2FnZQIJAOwHAQUCZHECEGludmFsaWQgbHAgYXNzZXQIcXVhbnRpdHkEAmZ5AwkAvwICBQJlVwUBZQYJAAIBAiJpbml0aWFsIGRlcG9zaXQgcmVxdWlyZXMgYWxsIGNvaW5zAwkAAAIFAmZ5BQJmeQQCZHgJAQJiWAEFAmRyBAJkegkBAmJYAQUCZHMEAmZ6AwkAAAIFAmFpAgAJAJQKAgUCZHgFAmR6AwkAAAIFAmRuBQJkcgMJAGYCBQJmdwUCZHgJAAIBAhZpbnZhbGlkIHBheW1lbnQgYW1vdW50CQCUCgIJAGUCBQJkeAUCZncFAmR6AwkAAAIFAmRuBQJkcwMJAGYCBQJmdwUCZHoJAAIBAhZpbnZhbGlkIHBheW1lbnQgYW1vdW50CQCUCgIFAmR4CQBlAgUCZHoFAmZ3CQACAQIQd3JvbmcgcG10QXNzZXRJZAQCZkEIBQJmegJfMQQCZkIIBQJmegJfMgQCZkMDCQAAAgUCZG4FAmRyCQCUCgIFAmZ3AAADCQAAAgUCZG4FAmRzCQCUCgIAAAUCZncJAAIBAg9pbnZhbGlkIHBheW1lbnQEAmZECAUCZkMCXzEEAmZFCAUCZkMCXzIEAmZGAwUCZngJAJUKAwgJAQJjRgIFAmZEBQJiZAJfMQgJAQJjRgIFAmZFBQJiZAJfMQgJAQJjRgIFAmZ3BQJiZAJfMgkAlQoDBQJmRAUCZkUAAAQCZkcIBQJmRgJfMQQCZkgIBQJmRgJfMgQCY0gIBQJmRgJfMwQCZkkJAGQCBQJmQQUCZkcEAmZKCQBkAgUCZkIFAmZIBAJjbAkBAmNJAQkAzAgCCQEBSQIFAmZBBQJiQQkAzAgCCQEBSQIFAmZCBQJiQgUDbmlsBAJjawkBAmNJAQkAzAgCCQEBSQIFAmZJBQJiQQkAzAgCCQEBSQIFAmZKBQJiQgUDbmlsBAJlZQMJAL8CAgUCY2sFAmNsBgkBBXRocm93AAMJAAACBQJlZQUCZWUEAmZLCQC9AgQFAmVXCQC4AgIFAmNrBQJjbAUCY2wFBUZMT09SBAJkQwkBAU0CCQECYloCCQEBSQIFAmZKBQJkWQkBAUkCBQJmSQUCZFgFAWEEAmV4CQDMCAIJAQxJbnRlZ2VyRW50cnkCCQECYWMABQJkQwkAzAgCCQEMSW50ZWdlckVudHJ5AgkBAmFkAgUGaGVpZ2h0CAUJbGFzdEJsb2NrCXRpbWVzdGFtcAUCZEMJAMwIAgkBC1N0cmluZ0VudHJ5AgkBAmFnAgUCZHAFAmFpCQECYkkKBQJmRAUCZkUJAKADAQUCZksFAmRDAAAAAAUGaGVpZ2h0CAUJbGFzdEJsb2NrCXRpbWVzdGFtcAAAAAAFA25pbAQCZkwJAGsDBQJmQgUBYQUCZkEEAmZNCQBrAwUCZncFAWEJAGQCBQJmTAUBYQQCZk4JAGUCBQJmdwUCZk0EAmZPCQC8AgMFAmVXCQC2AgEFAmZOCQC2AgEFAmZCBAJmUAkAoAMBCQC8AgMJALgCAgUCZksFAmZPBQFiBQJmTwkAlgoECQCgAwEFAmZLBQJleAUCY0gFAmZQCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAQJmUQYCZlICZlMCZlQCZnMCZlUCZlYEAmRxCQDYBAEJAQV2YWx1ZQEFAmJ4BAJkcgkA2AQBCQEFdmFsdWUBBQJieQQCZHMJANgEAQkBBXZhbHVlAQUCYnoEAmZXBQJiQQQCZlgFAmJCBAJmWQUCYncEAmRwAwkAAAIFAmZzBQJiSAUCZlUFAmZzBAJmcQkBBXZhbHVlAQkAkQMCBQJmVAAABAJkbgkBBXZhbHVlAQgFAmZxB2Fzc2V0SWQEAmRUCAUCZnEGYW1vdW50BAJlWAkBAmVRAwUBZQUBZQUBZQMJAAACBQJlWAUCZVgEAmRtCQDYBAEFAmZWAwkBAiE9AgUCZHEJANgEAQUCZG4JAAIBAghXcm9uZyBMUAQCZHgJAQJiWAEFAmRyBAJkegkBAmJYAQUCZHMEAmZaCgACYmUJAPwHBAUEdGhpcwITZ2V0T25lVGtuVjJSRUFET05MWQkAzAgCBQJmUgkAzAgCBQJkVAUDbmlsBQNuaWwDCQABAgUCYmUCCihJbnQsIEludCkFAmJlCQACAQkArAICCQADAQUCYmUCHyBjb3VsZG4ndCBiZSBjYXN0IHRvIChJbnQsIEludCkDCQAAAgUCZloFAmZaBAJjSAgFAmZaAl8yBAJnYQgFAmZaAl8xBAJnYgMDCQBmAgUCZlMAAAkAZgIFAmZTBQJnYQcJAQJiYQEJALkJAgkAzAgCAh9hbW91bnQgdG8gcmVjZWl2ZSBpcyBsZXNzIHRoYW4gCQDMCAIJAKQDAQUCZlMFA25pbAIABQJnYQQCZ2MDCQAAAgUCZlIFAmRyCQCWCgQFAmdiAAAJAGUCCQBlAgUCZHgFAmdiBQJjSAUCZHoDCQAAAgUCZlIFAmRzCQCWCgQAAAUCZ2IFAmR4CQBlAgkAZQIFAmR6BQJnYgUCY0gJAAIBAhRpbnZhbGlkIG91dCBhc3NldCBpZAQCZ2QIBQJnYwJfMQQCZ2UIBQJnYwJfMgQCZkkIBQJnYwJfMwQCZkoIBQJnYwJfNAQCZ2YJAQJiWgIJAQFJAgUCZkoFAmZYCQEBSQIFAmZJBQJmVwQCZ2cJAQFNAgUCZ2YFAWEEAmdoAwkAAAIFAmZSAgVXQVZFUwUEdW5pdAkA2QQBBQJmUgQCZ2kDCQBmAgUCY0gAAAkAzAgCCQEOU2NyaXB0VHJhbnNmZXIDBQJiagUCY0gFAmdoBQNuaWwFA25pbAQCZEoJAM4IAgkAzAgCCQEOU2NyaXB0VHJhbnNmZXIDBQJkcAUCZ2IFAmdoCQDMCAIJAQtTdHJpbmdFbnRyeQIJAQJhagIJAKUIAQUCZHAFAmRtCQECYlQGBQJnZAUCZ2UFAmRUBQJnZwUGaGVpZ2h0CAUJbGFzdEJsb2NrCXRpbWVzdGFtcAkAzAgCCQEMSW50ZWdlckVudHJ5AgkBAmFjAAUCZ2cJAMwIAgkBDEludGVnZXJFbnRyeQIJAQJhZAIFBmhlaWdodAgFCWxhc3RCbG9jawl0aW1lc3RhbXAFAmdnBQNuaWwFAmdpAwkAAAIFAmRKBQJkSgQCZ2oJAPwHBAUCYVUCBGJ1cm4JAMwIAgUCZFQFA25pbAkAzAgCCQEPQXR0YWNoZWRQYXltZW50AgUCZG4FAmRUBQNuaWwDCQAAAgUCZ2oFAmdqBAJnawQCZ2wDCQAAAgUEdGhpcwUCYmoAAAUCY0gEAmdtAwkAAAIJAQJibwEFAmZSBQJieQYHAwUCZ20JAJQKAgkBAS0BCQBkAgUCZ2EFAmdsAAAJAJQKAgAACQEBLQEJAGQCBQJnYQUCZ2wEAmVaCAUCZ2sCXzEEAmZhCAUCZ2sCXzIEAmduCQECZVkDBQJlWgUCZmEAAAQCZ28IBQJnbgJfMQQCZVAIBQJnbgJfMgQCZ3AJAQJmYwIFAmVYBQJlUAMJAAACBQJncAUCZ3AJAJQKAgkAzggCBQJkSgUCZ28FAmdiCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAQJncQAEAmdyCQECYVMABAJhUQkAnQgCBQJncgkBAmFhAAMJAAECBQJhUQIGU3RyaW5nBAJhVgUCYVEJANkEAQUCYVYDCQABAgUCYVECBFVuaXQFBHVuaXQJAAIBAgtNYXRjaCBlcnJvcgACZ3MJAAIBAhFQZXJtaXNzaW9uIGRlbmllZAECZ3QBAmNYBAJhUQkBAmdxAAMJAAECBQJhUQIKQnl0ZVZlY3RvcgQCZ3UFAmFRCQAAAggFAmNYD2NhbGxlclB1YmxpY0tleQUCZ3UDCQABAgUCYVECBFVuaXQJAAACCAUCY1gGY2FsbGVyBQR0aGlzCQACAQILTWF0Y2ggZXJyb3IBAmd2AQJjWAQCYVEJAQJncQADCQABAgUCYVECCkJ5dGVWZWN0b3IEAmd1BQJhUQMJAAACCAUCY1gPY2FsbGVyUHVibGljS2V5BQJndQYFAmdzAwkAAQIFAmFRAgRVbml0AwkAAAIIBQJjWAZjYWxsZXIFBHRoaXMGBQJncwkAAgECC01hdGNoIGVycm9yAQJndwMCZ3gCZXoCZ3kEAmJzCQECYmsABAJkcgkAkQMCBQJicwUBeAQCZHMJAJEDAgUCYnMFAXkEAmVBBQFnBAJlQwkApwMBBQFtBAJhUgkAuQICCQCnAwEFAmJnBQJlQwQCY0oDCQAAAgUCZ3gHCQDMCAIJALcCAgkAtgIBCQECYlgBBQJkcgUCZ3kJAMwIAgkAtgIBCQECYlgBBQJkcwUDbmlsCQDMCAIJALcCAgkAtgIBCQECYlgBBQJkcwUCZ3kJAMwIAgkAtgIBCQECYlgBBQJkcgUDbmlsBAJlQgkAkQMCBQJjSgAABAJhVgUCZUIEAmNNCQC5AgIFAmFSBQJlQQQCZUQJALoCAgkAuQICCQC5AgIJALoCAgkAuQICBQJlegUCZXoJALkCAgUCZUIFAmVBBQJlegUCZUMJALkCAgUCY00FAmVBBAJlRQkAuAICCQC3AgIFAmFWCQC6AgIJALkCAgUCZXoFAmVDBQJjTQUCZXoKAQJjVgICY1cCZUYEAmd6BQJjVwQCZUgIBQJnegJfMQQCZGsIBQJnegJfMgMJAQIhPQIFAmRrBQR1bml0BQJjVwQCZUkJALoCAgkAtwICCQC5AgIFAmVIBQJlSAUCZUQJALcCAgkAuQICBQFnBQJlSAUCZUUEAmVKCQEBWQEJALgCAgUCZUkJAQV2YWx1ZQEFAmVIAwkAwAICBQFmBQJlSgkAlAoCBQJlSQUCZUYJAJQKAgUCZUkFBHVuaXQEAmRiCQDMCAIAAAkAzAgCAAEJAMwIAgACCQDMCAIAAwkAzAgCAAQJAMwIAgAFCQDMCAIABgkAzAgCAAcJAMwIAgAICQDMCAIACQkAzAgCAAoJAMwIAgALCQDMCAIADAkAzAgCAA0JAMwIAgAOBQNuaWwEAmdBCgACZGQFAmRiCgACZGUJAJADAQUCZGQKAAJkZgkAlAoCBQJlegUEdW5pdAoBAmRnAgJkaAJkaQMJAGcCBQJkaQUCZGUFAmRoCQECY1YCBQJkaAkAkQMCBQJkZAUCZGkKAQJkagICZGgCZGkDCQBnAgUCZGkFAmRlBQJkaAkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDE1CQECZGoCCQECZGcCCQECZGcCCQECZGcCCQECZGcCCQECZGcCCQECZGcCCQECZGcCCQECZGcCCQECZGcCCQECZGcCCQECZGcCCQECZGcCCQECZGcCCQECZGcCCQECZGcCBQJkZgAAAAEAAgADAAQABQAGAAcACAAJAAoACwAMAA0ADgAPBAJlSAgFAmdBAl8xBAJkawgFAmdBAl8yAwkBAiE9AgUCZGsFBHVuaXQFAmVICQACAQkArAICAhlZIGNhbGN1bGF0aW9uIGVycm9yLCBZID0gCQCmAwEFAmVIAQJnQgAJAQt2YWx1ZU9yRWxzZQIJAJsIAgUCYVUJAQJhSAEJAKUIAQUEdGhpcwcbAmNYASFjYWxjdWxhdGVBbW91bnRPdXRGb3JTd2FwUkVBRE9OTFkDAmdDAmd4AmdEBAJnRQMJAAACBQJneAcEAmdGCQECYVcCBQR0aGlzCQECYWwABAJneQkAtwICCQC2AgEJAQJiWAEJAQJhVwIFBHRoaXMJAQJhawAJALYCAQUCZ0MJAJQKAgUCZ0YFAmd5BAJnRgkBAmFXAgUEdGhpcwkBAmFrAAQCZ3kJALcCAgkAtgIBCQECYlgBCQECYVcCBQR0aGlzCQECYWwACQC2AgEFAmdDCQCUCgIFAmdGBQJneQQCZ0YIBQJnRQJfMQQCZ3kIBQJnRQJfMgQCYnMJAQJiawAEAmRyCQCRAwIFAmJzBQF4BAJkcwkAkQMCBQJicwUBeQQCY0oJAMwIAgkAtgIBCQECYlgBBQJkcgkAzAgCCQC2AgEJAQJiWAEFAmRzBQNuaWwEAmV6CQECY0kBBQJjSgQCZUgJAQJndwMFAmd4BQJlegkAtgIBBQJnQwQCZ0cJALgCAgkAuAICCQC2AgEJAQJiWAEFAmdGBQJlSAkAtgIBAAEEAmdICQCWAwEJAMwIAgAACQDMCAIJAKADAQUCZ0cFA25pbAQCZ0kDCQAAAgUCZ3gHCQDMCAIJALcCAgkAtwICCQC2AgEJAQJiWAEFAmRyCQC2AgEFAmdDCQC2AgEFAmdECQDMCAIJALgCAgkAtgIBCQECYlgBBQJkcwUCZ0cFA25pbAkAzAgCCQC4AgIJALYCAQkBAmJYAQUCZHIFAmdHCQDMCAIJALcCAgkAtwICCQC2AgEJAQJiWAEFAmRzCQC2AgEFAmdDCQC2AgEFAmdEBQNuaWwEAmdKCQECY0kBBQJnSQQCZWUDCQDAAgIFAmdKBQJlegYJAAIBCQC5CQIJAMwIAgIUbmV3IEQgaXMgZmV3ZXIgZXJyb3IJAMwIAgkApgMBBQJlegkAzAgCCQCmAwEFAmdKBQNuaWwCAl9fAwkAAAIFAmVlBQJlZQkAlAoCBQNuaWwFAmdICQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAmNYASZjYWxjdWxhdGVBbW91bnRPdXRGb3JTd2FwQW5kU2VuZFRva2VucwUCZ0MCZ3gCZ0sCZ0wCZ0QEAmdNCgACYmUJAPwHBAUCYVUCF2dldFN3YXBDb250cmFjdFJFQURPTkxZBQNuaWwFA25pbAMJAAECBQJiZQIGU3RyaW5nBQJiZQkAAgEJAKwCAgkAAwEFAmJlAhsgY291bGRuJ3QgYmUgY2FzdCB0byBTdHJpbmcEAmdOCQDMCAIDCQBnAggJAQV2YWx1ZQEJAJEDAggFAmNYCHBheW1lbnRzAAAGYW1vdW50BQJnQwYJAQJiYQECDFdyb25nIGFtb3VudAkAzAgCAwkAAAIIBQJjWAZjYWxsZXIJARFAZXh0ck5hdGl2ZSgxMDYyKQEFAmdNBgkBAmJhAQIRUGVybWlzc2lvbiBkZW5pZWQFA25pbAMJAAACBQJnTgUCZ04EAmZxCQEFdmFsdWUBCQCRAwIIBQJjWAhwYXltZW50cwAABAJnTwkBAmJxAQgFAmZxB2Fzc2V0SWQEAmdQAwkAAAIFAmd4BwQCZ0YJAQJhVwIFBHRoaXMJAQJhbAAEAmd5CQBlAgkBAmJYAQUCZ08ICQEFdmFsdWUBCQCRAwIIBQJjWAhwYXltZW50cwAABmFtb3VudAkAlAoCBQJnRgUCZ3kEAmdGCQECYVcCBQR0aGlzCQECYWsABAJneQkAZQIJAQJiWAEFAmdPCAkBBXZhbHVlAQkAkQMCCAUCY1gIcGF5bWVudHMAAAZhbW91bnQJAJQKAgUCZ0YFAmd5BAJnRggFAmdQAl8xBAJneQgFAmdQAl8yBAJicwkBAmJrAAQCZHIJAJEDAgUCYnMFAXgEAmRzCQCRAwIFAmJzBQF5BAJjSgMJAAACBQJneAcJAMwIAgkAuAICCQC2AgEJAQJiWAEFAmRyCQC2AgEICQEFdmFsdWUBCQCRAwIIBQJjWAhwYXltZW50cwAABmFtb3VudAkAzAgCCQC2AgEJAQJiWAEFAmRzBQNuaWwJAMwIAgkAtgIBCQECYlgBBQJkcgkAzAgCCQC4AgIJALYCAQkBAmJYAQUCZHMJALYCAQgJAQV2YWx1ZQEJAJEDAggFAmNYCHBheW1lbnRzAAAGYW1vdW50BQNuaWwEAmV6CQECY0kBBQJjSgQCZUgJAQJndwMFAmd4BQJlegkAtgIBAAAEAmdHCQC4AgIJALgCAgkAtgIBCQECYlgBBQJnRgUCZUgJALYCAQABBAJnSAkAlgMBCQDMCAIAAAkAzAgCCQCgAwEFAmdHBQNuaWwEAmdRAwkAZwIFAmdIBQJnSwYJAAIBAixFeGNoYW5nZSByZXN1bHQgaXMgZmV3ZXIgY29pbnMgdGhhbiBleHBlY3RlZAMJAAACBQJnUQUCZ1EEAmdJAwkAAAIFAmd4BwkAzAgCCQC3AgIJALYCAQkBAmJYAQUCZHIJALYCAQUCZ0QJAMwIAgkAuAICCQC2AgEJAQJiWAEFAmRzBQJnRwUDbmlsCQDMCAIJALgCAgkAtgIBCQECYlgBBQJkcgUCZ0cJAMwIAgkAtwICCQC2AgEJAQJiWAEFAmRzCQC2AgEFAmdEBQNuaWwEAmdKCQECY0kBBQJnSQQCZWUDCQDAAgIFAmdKBQJlegYJAAIBAhRuZXcgRCBpcyBmZXdlciBlcnJvcgMJAAACBQJlZQUCZWUJAJQKAgkAzAgCCQEOU2NyaXB0VHJhbnNmZXIDCQERQGV4dHJOYXRpdmUoMTA2MikBBQJnTAUCZ0gJAQJibwEFAmdGBQNuaWwFAmdICQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAmNYAQtjb25zdHJ1Y3RvcgEBWgQCZUQJAQJndgEFAmNYAwkAAAIFAmVEBQJlRAkAzAgCCQELU3RyaW5nRW50cnkCCQEBWgAFAVoFA25pbAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgJjWAEDcHV0AgJnUgJnUwQCZ1QJAQJiQwAEAmdVCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAKYIAQkAkQMCBQJnVAUBRAIKV3Igc3QgYWRkcgQCZ1YJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkApggBCQCRAwIFAmdUBQFGAgpXciBzbCBhZGRyAwkAZgIAAAUCZ1IJAAIBAg5Xcm9uZyBzbGlwcGFnZQMJAQIhPQIJAJADAQgFAmNYCHBheW1lbnRzAAIJAAIBAgwyIHBtbnRzIGV4cGQEAmdXCQC2AgEICQEFdmFsdWUBCQCRAwIIBQJjWAhwYXltZW50cwAABmFtb3VudAQCZ1gJALYCAQgJAQV2YWx1ZQEJAJEDAggFAmNYCHBheW1lbnRzAAEGYW1vdW50BAJlVQkAuAICCQC2AgEJAQJiWAEJAQJicQEFAmJ5BQJnVwMJAAACBQJlVQUCZVUEAmVWCQC4AgIJALYCAQkBAmJYAQkBAmJxAQUCYnoFAmdYAwkAAAIFAmVWBQJlVgQCZVcJALYCAQgJAQV2YWx1ZQEJAOwHAQUCYngIcXVhbnRpdHkDCQAAAgUCZVcFAmVXBAJlWAkBAmVRAwUCZ1cFAmdYCQC2AgEAAAMJAAACBQJlWAUCZVgEAmdZCQECZnIKCQClCAEIBQJjWAZjYWxsZXIJANgEAQgFAmNYDXRyYW5zYWN0aW9uSWQJAQ9BdHRhY2hlZFBheW1lbnQCCAkBBXZhbHVlAQkAkQMCCAUCY1gIcGF5bWVudHMAAAdhc3NldElkCAkBBXZhbHVlAQkAkQMCCAUCY1gIcGF5bWVudHMAAAZhbW91bnQJAJEDAggFAmNYCHBheW1lbnRzAAEFAmdSBgcGAAACAAQCZXIIBQJnWQJfMgQCZ1oIBQJnWQJfNwQCZEoIBQJnWQJfOQQCZXMIBQJnWQNfMTAEAmV0CAUCZ1kDXzExBAJkcggFAmdZA18xMgQCZHMIBQJnWQNfMTMEAmVkCQD8BwQFAmFVAgRlbWl0CQDMCAIFAmVyBQNuaWwFA25pbAMJAAACBQJlZAUCZWQEAmhhBAJhUQUCZWQDCQABAgUCYVECB0FkZHJlc3MEAmhiBQJhUQkA/AcEBQJoYgIEZW1pdAkAzAgCBQJlcgUDbmlsBQNuaWwFBHVuaXQDCQAAAgUCaGEFAmhhBAJoYwMJAGYCBQJlcwAACQD8BwQFAmdWAgNwdXQFA25pbAkAzAgCCQEPQXR0YWNoZWRQYXltZW50AgUCZHIFAmVzBQNuaWwFA25pbAMJAAACBQJoYwUCaGMEAmhkAwkAZgIFAmV0AAAJAPwHBAUCZ1YCA3B1dAUDbmlsCQDMCAIJAQ9BdHRhY2hlZFBheW1lbnQCBQJkcwUCZXQFA25pbAUDbmlsAwkAAAIFAmhkBQJoZAQCaGUDBQJnUwQCaGYJAPwHBAUCZ1UCBXN0YWtlBQNuaWwJAMwIAgkBD0F0dGFjaGVkUGF5bWVudAIFAmdaBQJlcgUDbmlsAwkAAAIFAmhmBQJoZgUDbmlsCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMIBQJjWAZjYWxsZXIFAmVyBQJnWgUDbmlsBAJoZwkBAmVZAwAAAAAAAAQCZ28IBQJoZwJfMQQCZVAIBQJoZwJfMgQCaGgDCQDAAgIFAmVQBQJlWAYJAQJiYQEJALkJAgkAzAgCAiJ1cGRhdGVkIERMcCBsb3dlciB0aGFuIGN1cnJlbnQgRExwCQDMCAIJAKYDAQUCZVUJAMwIAgkApgMBBQJlVgkAzAgCCQCmAwEFAmVXCQDMCAIJAKYDAQUCZVgJAMwIAgkApgMBBQJlUAkAzAgCCQCkAwEFAmVzCQDMCAIJAKQDAQUCZXQFA25pbAIBIAMJAAACBQJoaAUCaGgEAmhpCAkBBXZhbHVlAQkA7AcBBQJieAhxdWFudGl0eQMJAAACBQJoaQUCaGkJAM4IAgkAzggCBQJkSgUCaGUFAmdvCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAmNYAQtwdXRPbmVUa25WMgICZlMCZ1MEAmhqCgACYmUJAPwHBAUCYVUCKGlzUG9vbE9uZVRva2VuT3BlcmF0aW9uc0Rpc2FibGVkUkVBRE9OTFkJAMwIAgkApQgBBQR0aGlzBQNuaWwFA25pbAMJAAECBQJiZQIHQm9vbGVhbgUCYmUJAAIBCQCsAgIJAAMBBQJiZQIcIGNvdWxkbid0IGJlIGNhc3QgdG8gQm9vbGVhbgQCaGsDAwMJAQJiaAAGCQAAAgUCYncFAXIGCQAAAgUCYncFAXQGBQJoagQCZ04JAMwIAgMDCQEBIQEFAmhrBgkBAmd0AQUCY1gGCQECYmEBAiFwdXQgb3BlcmF0aW9uIGlzIGJsb2NrZWQgYnkgYWRtaW4JAMwIAgMJAAACCQCQAwEIBQJjWAhwYXltZW50cwABBgkBAmJhAQIeZXhhY3RseSAxIHBheW1lbnQgYXJlIGV4cGVjdGVkBQNuaWwDCQAAAgUCZ04FAmdOBAJkcgkA2AQBCQEFdmFsdWUBBQJieQQCZHMJANgEAQkBBXZhbHVlAQUCYnoEAmRxBQJieAQCZlcFAmJBBAJmWAUCYkIEAmRwAwkAAAIIBQJjWAZjYWxsZXIFBHRoaXMIBQJjWAxvcmlnaW5DYWxsZXIIBQJjWAZjYWxsZXIEAmZxCQEFdmFsdWUBCQCRAwIIBQJjWAhwYXltZW50cwAABAJkbgkA2AQBCQEFdmFsdWUBCAUCZnEHYXNzZXRJZAQCZFQIBQJmcQZhbW91bnQEAmVYAwkAAAIIBQJmcQdhc3NldElkBQJieQkBAmVRAwkAtgIBBQJkVAkAtgIBAAAJALYCAQAACQECZVEDCQC2AgEAAAkAtgIBBQJkVAkAtgIBAAADCQAAAgUCZVgFAmVYBAJobAkBAmZ2BQUCZFQFAmRuCQClCAEFAmRwCQDYBAEIBQJjWA10cmFuc2FjdGlvbklkBgMJAAACBQJobAUCaGwEAmNICAUCaGwCXzMEAmRKCAUCaGwCXzIEAmhtCAUCaGwCXzEEAmVyAwMJAGYCBQJmUwAACQBmAgUCZlMFAmhtBwkBAmJhAQkAuQkCCQDMCAICH2Ftb3VudCB0byByZWNlaXZlIGlzIGxlc3MgdGhhbiAJAMwIAgkApAMBBQJmUwUDbmlsAgAFAmhtBAJnWQkA/AcEBQJhVQIEZW1pdAkAzAgCBQJlcgUDbmlsBQNuaWwDCQAAAgUCZ1kFAmdZBAJoYQQCYVEFAmdZAwkAAQIFAmFRAgdBZGRyZXNzBAJoYgUCYVEJAPwHBAUCaGICBGVtaXQJAMwIAgUCZXIFA25pbAUDbmlsBQR1bml0AwkAAAIFAmhhBQJoYQQCaGUDBQJnUwQCaGYJAPwHBAUCYkUCCHN0YWtlRm9yCQDMCAIJAKUIAQgFAmNYBmNhbGxlcgUDbmlsCQDMCAIJAQ9BdHRhY2hlZFBheW1lbnQCBQJkcQUCZXIFA25pbAMJAAACBQJoZgUCaGYFA25pbAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAzAgCCQEOU2NyaXB0VHJhbnNmZXIDCAUCY1gGY2FsbGVyBQJlcgUCZHEFA25pbAQCZ2kDCQBmAgUCY0gAAAkAzAgCCQEOU2NyaXB0VHJhbnNmZXIDBQJiagUCY0gJANkEAQUCZG4FA25pbAUDbmlsBAJobgMJAAACBQR0aGlzBQJiagkAlAoCAAAAAAQCaG8DCQAAAggFAmZxB2Fzc2V0SWQFAmJ5BgcDBQJobwkAlAoCCQEBLQEFAmNIAAAJAJQKAgAACQEBLQEFAmNIBAJlWggFAmhuAl8xBAJmYQgFAmhuAl8yBAJocAkBAmVZAwUCZVoFAmZhAAAEAmdvCAUCaHACXzEEAmVQCAUCaHACXzIEAmdwCQECZmMCBQJlWAUCZVADCQAAAgUCZ3AFAmdwCQCUCgIJAM4IAgkAzggCCQDOCAIFAmRKBQJoZQUCZ2kFAmdvBQJlcgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgJjWAEKcHV0Rm9yRnJlZQECaHEDCQBmAgAABQJocQkAAgECCldyb25nIHNscGcDCQECIT0CCQCQAwEIBQJjWAhwYXltZW50cwACCQACAQIMMiBwbW50cyBleHBkBAJocgkBAmZyCgkApQgBCAUCY1gGY2FsbGVyCQDYBAEIBQJjWA10cmFuc2FjdGlvbklkCQEPQXR0YWNoZWRQYXltZW50AggJAQV2YWx1ZQEJAJEDAggFAmNYCHBheW1lbnRzAAAHYXNzZXRJZAgJAQV2YWx1ZQEJAJEDAggFAmNYCHBheW1lbnRzAAAGYW1vdW50CQCRAwIIBQJjWAhwYXltZW50cwABBQJocQcHBgAAAgAEAmRKCAUCaHICXzkEAmdXCQC2AgEICQEFdmFsdWUBCQCRAwIIBQJjWAhwYXltZW50cwAABmFtb3VudAQCZ1gJALYCAQgJAQV2YWx1ZQEJAJEDAggFAmNYCHBheW1lbnRzAAEGYW1vdW50BAJlWAkBAmVRAwUCZ1cFAmdYCQC2AgEAAAMJAAACBQJlWAUCZVgEAmhzCQECZVkDAAAAAAAABAJnbwgFAmhzAl8xBAJlUAgFAmhzAl8yBAJncAkBAmZjAgUCZVgFAmVQAwkAAAIFAmdwBQJncAkAzggCBQJkSgUCZ28JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4CY1gBA2dldAAEAmVYCQECZVEDCQC2AgEAAAkAtgIBAAAJALYCAQAAAwkAAAIFAmVYBQJlWAQCZWQJAQJmcAEFAmNYBAJodAgFAmVkAl8xBAJkSQgFAmVkAl8yBAJkVAgFAmVkAl8zBAJkbggFAmVkAl80BAJkSggFAmVkAl81BAJlRQkA/AcEBQJhVQIEYnVybgkAzAgCBQJkVAUDbmlsCQDMCAIJAQ9BdHRhY2hlZFBheW1lbnQCBQJkbgUCZFQFA25pbAMJAAACBQJlRQUCZUUEAmh1CQECZVkDCQEBLQEFAmh0CQEBLQEFAmRJAAAEAmdvCAUCaHUCXzEEAmVQCAUCaHUCXzIEAmdwCQECZmMCBQJlWAUCZVADCQAAAgUCZ3AFAmdwCQDOCAIFAmRKBQJnbwkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgJjWAELZ2V0T25lVGtuVjICAmZSAmZTBAJoagoAAmJlCQD8BwQFAmFVAihpc1Bvb2xPbmVUb2tlbk9wZXJhdGlvbnNEaXNhYmxlZFJFQURPTkxZCQDMCAIJAKUIAQUEdGhpcwUDbmlsBQNuaWwDCQABAgUCYmUCB0Jvb2xlYW4FAmJlCQACAQkArAICCQADAQUCYmUCHCBjb3VsZG4ndCBiZSBjYXN0IHRvIEJvb2xlYW4EAmh2AwMJAQJiaAAGCQAAAgUCYncFAXQGBQJoagQCZ04JAMwIAgMDCQEBIQEFAmh2BgkBAmd0AQUCY1gGCQECYmEBAiFnZXQgb3BlcmF0aW9uIGlzIGJsb2NrZWQgYnkgYWRtaW4JAMwIAgMJAAACCQCQAwEIBQJjWAhwYXltZW50cwABBgkBAmJhAQIeZXhhY3RseSAxIHBheW1lbnQgYXJlIGV4cGVjdGVkBQNuaWwDCQAAAgUCZ04FAmdOBAJodwkBAmZRBgUCZlIFAmZTCAUCY1gIcGF5bWVudHMIBQJjWAZjYWxsZXIIBQJjWAxvcmlnaW5DYWxsZXIIBQJjWA10cmFuc2FjdGlvbklkBAJkSggFAmh3Al8xBAJnYggFAmh3Al8yCQCUCgIFAmRKBQJnYgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgJjWAEKcmVmcmVzaERMcAAEAmh4CQELdmFsdWVPckVsc2UCCQCfCAEFAmF0AAAEAmh5AwkAZwIJAGUCBQZoZWlnaHQFAmh4BQJhdwUEdW5pdAkBAmJhAQkAuQkCCQDMCAIJAKQDAQUCYXcJAMwIAgIvIGJsb2NrcyBoYXZlIG5vdCBwYXNzZWQgc2luY2UgdGhlIHByZXZpb3VzIGNhbGwFA25pbAIAAwkAAAIFAmh5BQJoeQQCZmoJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAqAMBCQELdmFsdWVPckVsc2UCCQCdCAIFBHRoaXMFAmFzAgEwCQECYmMBAgtpbnZhbGlkIGRMcAQCaHoJAQJlWQMAAAAAAAAEAmhBCAUCaHoCXzEEAmVQCAUCaHoCXzIEAmZiAwkBAiE9AgUCZmoFAmVQBQJoQQkBAmJhAQISbm90aGluZyB0byByZWZyZXNoCQCUCgIFAmZiCQCmAwEFAmVQCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAmNYARNnZXRPbmVUa25WMlJFQURPTkxZAgJmUgJoQgQCZHIJANgEAQkBBXZhbHVlAQUCYnkEAmRzCQDYBAEJAQV2YWx1ZQEFAmJ6BAJkcQkA2AQBCQEFdmFsdWUBBQJieAQCY0oJAMwIAgkAtgIBCQECYlgBBQJkcgkAzAgCCQC2AgEJAQJiWAEFAmRzBQNuaWwEAmVPCQC2AgEICQETdmFsdWVPckVycm9yTWVzc2FnZQIJAOwHAQkA2QQBBQJkcQIQaW52YWxpZCBscCBhc3NldAhxdWFudGl0eQQCY2wJAQJjSQEFAmNKBAJjawkAuAICBQJjbAkAvAIDCQC2AgEFAmhCBQJjbAUCZU8EAmhDAwkAAAIFAmZSBQJkcgAAAwkAAAIFAmZSBQJkcwABCQACAQIUaW52YWxpZCBvdXQgYXNzZXQgaWQEAmhECQECZXkDBQJjSgUCaEMFAmNrBAJnRwkAuAICCQCRAwIFAmNKBQJoQwUCaEQEAmdICQCWAwEJAMwIAgAACQDMCAIJAKADAQkAuAICBQJnRwUBZgUDbmlsBAJoRQkBAmNGAgUCZ0gFAmJmBAJnYQgFAmhFAl8xBAJjSAgFAmhFAl8yCQCUCgIFA25pbAkAlAoCBQJnYQUCY0gCY1gBHGdldE9uZVRrblYyV2l0aEJvbnVzUkVBRE9OTFkCAmZSAmhCBAJkcgkA2AQBCQEFdmFsdWUBBQJieQQCZHMJANgEAQkBBXZhbHVlAQUCYnoEAmRxCQDYBAEJAQV2YWx1ZQEFAmJ4BAJkeAkBAmJYAQUCZHIEAmR6CQECYlgBBQJkcwQCaEYKAAJiZQkA/AcEBQR0aGlzAhNnZXRPbmVUa25WMlJFQURPTkxZCQDMCAIFAmZSCQDMCAIFAmhCBQNuaWwFA25pbAMJAAECBQJiZQIKKEludCwgSW50KQUCYmUJAAIBCQCsAgIJAAMBBQJiZQIfIGNvdWxkbid0IGJlIGNhc3QgdG8gKEludCwgSW50KQQCZ2EIBQJoRgJfMQQCY0gIBQJoRgJfMgQCZWQJAQJkbAQCAAUCZHEFAmhCBQR0aGlzBAJkSAgFAmVkAl8xBAJkSQgFAmVkAl8yBAJoRwkAZAIFAmRIBQJkSQQCZlADCQAAAgUCaEcAAAMJAAACBQJnYQAAAAAJAAIBAhdib251cyBjYWxjdWxhdGlvbiBlcnJvcgkAawMJAGUCBQJnYQUCaEcFAWEFAmhHCQCUCgIFA25pbAkAlQoDBQJnYQUCY0gFAmZQAmNYAQlnZXROb0xlc3MCAmhIAmhJBAJlZAkBAmZwAQUCY1gEAmRICAUCZWQCXzEEAmRJCAUCZWQCXzIEAmRUCAUCZWQCXzMEAmRuCAUCZWQCXzQEAmRKCAUCZWQCXzUDCQBmAgUCaEgFAmRICQACAQkArAICCQCsAgIJAKwCAgIJRmFpbGVkOiAgCQCkAwEFAmRIAgMgPCAJAKQDAQUCaEgDCQBmAgUCaEkFAmRJCQACAQkArAICCQCsAgIJAKwCAgIIRmFpbGVkOiAJAKQDAQUCZEkCAyA8IAkApAMBBQJoSQQCZVgJAQJlUQMJALYCAQAACQC2AgEAAAkAtgIBAAADCQAAAgUCZVgFAmVYBAJoSgkA/AcEBQJhVQIEYnVybgkAzAgCBQJkVAUDbmlsCQDMCAIJAQ9BdHRhY2hlZFBheW1lbnQCBQJkbgUCZFQFA25pbAMJAAACBQJoSgUCaEoEAmhLCQECZVkDCQEBLQEFAmRICQEBLQEFAmRJAAAEAmdvCAUCaEsCXzEEAmVQCAUCaEsCXzIEAmdwCQECZmMCBQJlWAUCZVADCQAAAgUCZ3AFAmdwCQDOCAIFAmRKBQJnbwkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgJjWAENdW5zdGFrZUFuZEdldAECY0cEAmhMAwkBAiE9AgkAkAMBCAUCY1gIcGF5bWVudHMAAAkAAgECDU5vIHBtbnRzIGV4cGQGAwkAAAIFAmhMBQJoTAQCaE0JAQJiQwAEAmdaBQJieAQCaE4JARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkApggBCQCRAwIFAmhNBQFEAgpXciBzdCBhZGRyBAJlWAkBAmVRAwkAtgIBAAAJALYCAQAACQC2AgEAAAMJAAACBQJlWAUCZVgEAmhPCQD8BwQFAmhOAgd1bnN0YWtlCQDMCAIJANgEAQUCZ1oJAMwIAgUCY0cFA25pbAUDbmlsAwkAAAIFAmhPBQJoTwQCZWQJAQJkbAQJANgEAQgFAmNYDXRyYW5zYWN0aW9uSWQJANgEAQUCZ1oFAmNHCAUCY1gGY2FsbGVyBAJkSAgFAmVkAl8xBAJkSQgFAmVkAl8yBAJkdgkBDXBhcnNlSW50VmFsdWUBCAUCZWQCXzkEAmRKCAUCZWQDXzEwBAJoUAMDCQECYmgABgkAAAIFAmR2BQF0CQACAQkArAICAglCbG9ja2VkOiAJAKQDAQUCZHYGAwkAAAIFAmhQBQJoUAQCaFEJAPwHBAUCYVUCBGJ1cm4JAMwIAgUCY0cFA25pbAkAzAgCCQEPQXR0YWNoZWRQYXltZW50AgUCZ1oFAmNHBQNuaWwDCQAAAgUCaFEFAmhRBAJoUgkBAmVZAwkBAS0BBQJkSAkBAS0BBQJkSQAABAJnbwgFAmhSAl8xBAJlUAgFAmhSAl8yBAJncAkBAmZjAgUCZVgFAmVQAwkAAAIFAmdwBQJncAkAzggCBQJkSgUCZ28JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4CY1gBE3Vuc3Rha2VBbmRHZXROb0xlc3MDAmhTAmhUAmhJBAJodgMJAQJiaAAGCQAAAgUCYncFAXQEAmdOCQDMCAIDCQEBIQEFAmh2BgkAAgECIWdldCBvcGVyYXRpb24gaXMgYmxvY2tlZCBieSBhZG1pbgkAzAgCAwkAAAIJAJADAQgFAmNYCHBheW1lbnRzAAAGCQACAQIYbm8gcGF5bWVudHMgYXJlIGV4cGVjdGVkBQNuaWwDCQAAAgUCZ04FAmdOBAJlWAkBAmVRAwkAtgIBAAAJALYCAQAACQC2AgEAAAMJAAACBQJlWAUCZVgEAmhPCQD8BwQFAmJFAgd1bnN0YWtlCQDMCAIJANgEAQUCYngJAMwIAgUCaFMFA25pbAUDbmlsAwkAAAIFAmhPBQJoTwQCaFUJAQJkbAQJANgEAQgFAmNYDXRyYW5zYWN0aW9uSWQJANgEAQUCYngFAmhTCAUCY1gGY2FsbGVyBAJkSAgFAmhVAl8xBAJkSQgFAmhVAl8yBAJkSggFAmhVA18xMAQCaFYJAMwIAgMJAGcCBQJkSAUCaFQGCQACAQkAuQkCCQDMCAICLGFtb3VudCBhc3NldCBhbW91bnQgdG8gcmVjZWl2ZSBpcyBsZXNzIHRoYW4gCQDMCAIJAKQDAQUCaFQFA25pbAIACQDMCAIDCQBnAgUCZEkFAmhJBgkAAgEJALkJAgkAzAgCAitwcmljZSBhc3NldCBhbW91bnQgdG8gcmVjZWl2ZSBpcyBsZXNzIHRoYW4gCQDMCAIJAKQDAQUCaEkFA25pbAIABQNuaWwDCQAAAgUCaFYFAmhWBAJoSgkA/AcEBQJhVQIEYnVybgkAzAgCBQJoUwUDbmlsCQDMCAIJAQ9BdHRhY2hlZFBheW1lbnQCBQJieAUCaFMFA25pbAMJAAACBQJoSgUCaEoEAmhXCQECZVkDCQEBLQEFAmRICQEBLQEFAmRJAAAEAmdvCAUCaFcCXzEEAmVQCAUCaFcCXzIEAmdwCQECZmMCBQJlWAUCZVADCQAAAgUCZ3AFAmdwCQDOCAIFAmRKBQJnbwkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgJjWAEVdW5zdGFrZUFuZEdldE9uZVRrblYyAwJoUwJmUgJmUwQCaGoKAAJiZQkA/AcEBQJhVQIoaXNQb29sT25lVG9rZW5PcGVyYXRpb25zRGlzYWJsZWRSRUFET05MWQkAzAgCCQClCAEFBHRoaXMFA25pbAUDbmlsAwkAAQIFAmJlAgdCb29sZWFuBQJiZQkAAgEJAKwCAgkAAwEFAmJlAhwgY291bGRuJ3QgYmUgY2FzdCB0byBCb29sZWFuBAJodgMDCQECYmgABgkAAAIFAmJ3BQF0BgUCaGoEAmdOCQDMCAIDAwkBASEBBQJodgYJAQJndAEFAmNYBgkBAmJhAQIhZ2V0IG9wZXJhdGlvbiBpcyBibG9ja2VkIGJ5IGFkbWluCQDMCAIDCQAAAgkAkAMBCAUCY1gIcGF5bWVudHMAAAYJAQJiYQECGG5vIHBheW1lbnRzIGFyZSBleHBlY3RlZAUDbmlsAwkAAAIFAmdOBQJnTgQCaE0JAQJiQwAEAmdaBQJieAQCaE4JARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkApggBCQCRAwIFAmhNBQFEAgpXciBzdCBhZGRyBAJkcAgFAmNYBmNhbGxlcgQCaFgFBHRoaXMEAmhPCQD8BwQFAmhOAg91bnN0YWtlSU5URVJOQUwJAMwIAgUCZ1oJAMwIAgUCaFMJAMwIAggFAmRwBWJ5dGVzCQDMCAIIBQJoWAVieXRlcwUDbmlsBQNuaWwDCQAAAgUCaE8FAmhPBAJoWQkBAmZRBgUCZlIFAmZTCQDMCAIJAQ9BdHRhY2hlZFBheW1lbnQCBQJnWgUCaFMFA25pbAgFAmNYBmNhbGxlcggFAmNYDG9yaWdpbkNhbGxlcggFAmNYDXRyYW5zYWN0aW9uSWQEAmRKCAUCaFkCXzEEAmdiCAUCaFkCXzIJAJQKAgUCZEoFAmdiCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAmNYARxwdXRPbmVUa25WMldpdGhCb251c1JFQURPTkxZAgJoWgJpYQQCaWIJAQJmdgUFAmhaBQJpYQIAAgAGBAJmSwgFAmliAl8xBAJkSggFAmliAl8yBAJjSAgFAmliAl8zBAJmUAgFAmliAl80CQCUCgIFA25pbAkAlQoDBQJmSwUCY0gFAmZQAmNYASFwdXRPbmVUa25WMldpdGhvdXRUYWtlRmVlUkVBRE9OTFkCAmhaAmlhBAJpYwkBAmZ2BQUCaFoFAmlhAgACAAcEAmZLCAUCaWMCXzEEAmRKCAUCaWMCXzIEAmNICAUCaWMCXzMEAmZQCAUCaWMCXzQJAJQKAgUDbmlsCQCVCgMFAmZLBQJjSAUCZlACY1gBCGFjdGl2YXRlAgJpZAJpZQMJAQIhPQIJAKUIAQgFAmNYBmNhbGxlcgkApQgBBQJhVQkAAgECBmRlbmllZAkAlAoCCQDMCAIJAQtTdHJpbmdFbnRyeQIJAQJhawAFAmlkCQDMCAIJAQtTdHJpbmdFbnRyeQIJAQJhbAAFAmllCQDMCAIJAQtTdHJpbmdFbnRyeQIJAQJhbQAJAKQDAQUBbAUDbmlsAgdzdWNjZXNzAmNYARxnZXRQb29sQ29uZmlnV3JhcHBlclJFQURPTkxZAAkAlAoCBQNuaWwJAQJiawACY1gBHGdldEFjY0JhbGFuY2VXcmFwcGVyUkVBRE9OTFkBAmJZCQCUCgIFA25pbAkBAmJYAQUCYlkCY1gBGWNhbGNQcmljZXNXcmFwcGVyUkVBRE9OTFkDAmNyAmNzAmN3BAJpZgkBAmN2AwUCY3IFAmNzBQJjdwkAlAoCBQNuaWwJAMwIAgkApgMBCQCRAwIFAmlmAAAJAMwIAgkApgMBCQCRAwIFAmlmAAEJAMwIAgkApgMBCQCRAwIFAmlmAAIFA25pbAJjWAEWZnJvbVgxOFdyYXBwZXJSRUFET05MWQIBTgJpZwkAlAoCBQNuaWwJAQFNAgkApwMBBQFOBQJpZwJjWAEUdG9YMThXcmFwcGVyUkVBRE9OTFkCAUoBSwkAlAoCBQNuaWwJAKYDAQkBAUkCBQFKBQFLAmNYAR5jYWxjUHJpY2VCaWdJbnRXcmFwcGVyUkVBRE9OTFkCAmNhAmNiCQCUCgIFA25pbAkApgMBCQECYloCCQCnAwEFAmNhCQCnAwEFAmNiAmNYASNlc3RpbWF0ZVB1dE9wZXJhdGlvbldyYXBwZXJSRUFET05MWQkCZG0CY2cCZEwCZE0CZE4CZE8CaWgCZFACZFEJAJQKAgUDbmlsCQECZEsNBQJkbQUCY2cFAmRMBQJkTQUCZE4FAmRPBQJpaAUCZFAFAmRRBgcAAAIAAmNYASNlc3RpbWF0ZUdldE9wZXJhdGlvbldyYXBwZXJSRUFET05MWQQCZG0CaWkCZG8CaWgEAmVkCQECZGwEBQJkbQUCaWkFAmRvCQERQGV4dHJOYXRpdmUoMTA2MikBBQJpaAkAlAoCBQNuaWwJAJwKCggFAmVkAl8xCAUCZWQCXzIIBQJlZAJfMwgFAmVkAl80CAUCZWQCXzUIBQJlZAJfNggFAmVkAl83CQCmAwEIBQJlZAJfOAgFAmVkAl85CAUCZWQDXzEwAmNYAQljaGFuZ2VBbXAABAJpagkA/AcEBQJhVQIaZ2V0Q2hhbmdlQW1wQ29uZmlnUkVBRE9OTFkJAMwIAgkApQgBBQR0aGlzBQNuaWwFA25pbAQCaWsEAmFRBQJpagMJAAECBQJhUQIJTGlzdFtBbnldBAJpbAUCYVEJAJUKAwoAAmJlCQCRAwIFAmlsAAADCQABAgUCYmUCA0ludAUCYmUJAAIBCQCsAgIJAAMBBQJiZQIYIGNvdWxkbid0IGJlIGNhc3QgdG8gSW50CgACYmUJAJEDAgUCaWwAAQMJAAECBQJiZQIDSW50BQJiZQkAAgEJAKwCAgkAAwEFAmJlAhggY291bGRuJ3QgYmUgY2FzdCB0byBJbnQKAAJiZQkAkQMCBQJpbAACAwkAAQIFAmJlAgNJbnQFAmJlCQACAQkArAICCQADAQUCYmUCGCBjb3VsZG4ndCBiZSBjYXN0IHRvIEludAkBAmJhAQISaW52YWxpZCBlbnRyeSB0eXBlBAJpbQgFAmlrAl8xBAJpbggFAmlrAl8yBAJpbwgFAmlrAl8zBAJpcAkBDXBhcnNlSW50VmFsdWUBCQERQGV4dHJOYXRpdmUoMTA1OCkBCQECYW0ABAJpcQkAZAIFAmlwBQJpbgQCaXIDCQBmAgAABQJpbgMJAGYCBQJpbwUCaXEFAmlvBQJpcQMJAGYCBQJpcQUCaW8FAmlvBQJpcQQCaXMJAQt2YWx1ZU9yRWxzZQIJAJ8IAQkBAmFwAAAABAJpdAkAZAIFAmlzBQJpbQQCZ04JAMwIAgMJAGYCBQZoZWlnaHQFAml0BgkBAmJhAQIXdHJ5IGFnYWluIGluIGZldyBibG9ja3MJAMwIAgMJAQIhPQIFAmlwBQJpcgYJAQJiYQECFmFscmVhZHkgcmVhY2hlZCB0YXJnZXQFA25pbAMJAAACBQJnTgUCZ04JAMwIAgkBDEludGVnZXJFbnRyeQIJAQJhcAAFBmhlaWdodAkAzAgCCQELU3RyaW5nRW50cnkCCQECYW0ACQCkAwEFAmlyCQDMCAIJAQtTdHJpbmdFbnRyeQIJAQJhbgEFBmhlaWdodAkApAMBBQJpcgUDbmlsCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAQJpdQECaXYABAJpdwQCYVEJAQJncQADCQABAgUCYVECCkJ5dGVWZWN0b3IEAmd1BQJhUQUCZ3UDCQABAgUCYVECBFVuaXQIBQJpdQ9zZW5kZXJQdWJsaWNLZXkJAAIBAgtNYXRjaCBlcnJvcgQCYVEFAml1AwkAAQIFAmFRAgVPcmRlcgQCZmYFAmFRBAJpeAkBAmJpAAQCaXkDCQECZ0IACQCUCgIGAgAJAQJmZQEFAmZmBAJhSwgFAml5Al8xBAJhTAgFAml5Al8yBAJhTQkA9AMDCAUCZmYJYm9keUJ5dGVzCQCRAwIIBQJmZgZwcm9vZnMAAAgFAmZmD3NlbmRlclB1YmxpY0tleQQCYU4JAPQDAwgFAmZmCWJvZHlCeXRlcwkAkQMCCAUCZmYGcHJvb2ZzAAEFAml4AwMDBQJhSwUCYU0HBQJhTgcGCQECYUoEBQJhSwUCYUwFAmFNBQJhTgMJAAECBQJhUQIUU2V0U2NyaXB0VHJhbnNhY3Rpb24EAmFWBQJhUQMJAPQDAwgFAml1CWJvZHlCeXRlcwkAkQMCCAUCaXUGcHJvb2ZzAAAFAml3BgQCaXoJAPYDAQkBBXZhbHVlAQgFAmFWBnNjcmlwdAQCaUEJANsEAQkBBXZhbHVlAQkAnQgCBQJhVQkBAmFGAAQCaUIJAPEHAQUEdGhpcwMJAAACBQJpQQUCaXoJAQIhPQIFAmlCBQJpegcJAPQDAwgFAml1CWJvZHlCeXRlcwkAkQMCCAUCaXUGcHJvb2ZzAAAFAml3HRMn8g==",
    "height": 2603600,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 588uvrDNcdPngaEhLh3jM28edjA1n14UNE7ndBUQpB5h
Next: FScn96AwLBy9S2vmMXsNbH85BaCQgmUyFnU5YN7THGmp

Diff: 
Old New Differences
22 22  let slippage4D = toBigInt((scale8 - ((scale8 * 1) / scale8)))
23 23  
24 24  let wavesString = "WAVES"
25 + 
26 + let ampInitial = 50
25 27  
26 28  let Amult = "100"
27 29  
256 258      else toBase58String(value(input))
257 259  
258 260  
259 - func parsePoolConfig (poolConfig) = $Tuple9(addressFromStringValue(poolConfig[idxPoolAddress]), parseIntValue(poolConfig[idxPoolSt]), fromBase58String(poolConfig[idxLPAsId]), parseAssetId(poolConfig[idxAmAsId]), parseAssetId(poolConfig[idxPrAsId]), parseIntValue(poolConfig[idxAmtAsDcm]), parseIntValue(poolConfig[idxPriceAsDcm]), fromBase58String(poolConfig[idxIAmtAsId]), fromBase58String(poolConfig[idxIPriceAsId]))
261 + func parsePoolConfig (poolConfig) = $Tuple7(addressFromStringValue(poolConfig[idxPoolAddress]), parseIntValue(poolConfig[idxPoolSt]), fromBase58String(poolConfig[idxLPAsId]), parseAssetId(poolConfig[idxAmAsId]), parseAssetId(poolConfig[idxPrAsId]), parseIntValue(poolConfig[idxAmtAsDcm]), parseIntValue(poolConfig[idxPriceAsDcm]))
260 262  
261 263  
262 264  let poolConfigParsed = parsePoolConfig(gpc())
263 265  
264 - let $t086868915 = poolConfigParsed
266 + let $t086088794 = poolConfigParsed
265 267  
266 - let cfgPoolAddress = $t086868915._1
268 + let cfgPoolAddress = $t086088794._1
267 269  
268 - let cfgPoolStatus = $t086868915._2
270 + let cfgPoolStatus = $t086088794._2
269 271  
270 - let cfgLpAssetId = $t086868915._3
272 + let cfgLpAssetId = $t086088794._3
271 273  
272 - let cfgAmountAssetId = $t086868915._4
274 + let cfgAmountAssetId = $t086088794._4
273 275  
274 - let cfgPriceAssetId = $t086868915._5
276 + let cfgPriceAssetId = $t086088794._5
275 277  
276 - let cfgAmountAssetDecimals = $t086868915._6
278 + let cfgAmountAssetDecimals = $t086088794._6
277 279  
278 - let cfgPriceAssetDecimals = $t086868915._7
279 - 
280 - let cfgInAmountAssedId = $t086868915._8
281 - 
282 - let cfgInPriceAssetId = $t086868915._9
280 + let cfgPriceAssetDecimals = $t086088794._7
283 281  
284 282  func gfc () = split(strf(fca, fcfg()), SEP)
285 283  
400 398                      }
401 399  
402 400              let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
403 -             let $t01342013468 = {
401 +             let $t01329913347 = {
404 402                  let $l = arr
405 403                  let $s = size($l)
406 404                  let $acc0 = $Tuple2(s, false)
414 412  
415 413                  $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17)
416 414                  }
417 -             let d = $t01342013468._1
418 -             let found = $t01342013468._2
415 +             let d = $t01329913347._1
416 +             let found = $t01329913347._2
419 417              if (found)
420 418                  then d
421 419                  else throw(("D calculation error, D = " + toString(d)))
462 460      let lpId = cfgLpAssetId
463 461      let amIdStr = toBase58String(value(cfgAmountAssetId))
464 462      let prIdStr = toBase58String(value(cfgPriceAssetId))
465 -     let inAmIdStr = cfgInAmountAssedId
466 -     let inPrIdStr = cfgInPriceAssetId
467 463      let amtDcm = cfgAmountAssetDecimals
468 464      let priceDcm = cfgPriceAssetDecimals
469 465      let sts = toString(cfgPoolStatus)
551 547                  else calcLpAmt
552 548              let amDiff = (inAmAmt - calcAmAssetPmt)
553 549              let prDiff = (inPrAmt - calcPrAssetPmt)
554 -             let $t02130721652 = if (if (isOneAsset)
550 +             let $t02110921454 = if (if (isOneAsset)
555 551                  then (pmtId == amIdStr)
556 552                  else false)
557 553                  then $Tuple2(pmtAmt, 0)
560 556                      else false)
561 557                      then $Tuple2(0, pmtAmt)
562 558                      else $Tuple2(calcAmAssetPmt, calcPrAssetPmt)
563 -             let writeAmAmt = $t02130721652._1
564 -             let writePrAmt = $t02130721652._2
559 +             let writeAmAmt = $t02110921454._1
560 +             let writePrAmt = $t02110921454._2
565 561              let commonState = [IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice), StringEntry(pau(userAddress, txId58), dataPutActionInfo(writeAmAmt, writePrAmt, emitLpAmt, curPrice, slippage, slippageCalc, height, lastBlock.timestamp, amDiff, prDiff))]
566 562              $Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEm, lpId, sts, commonState, amDiff, prDiff, inAmId, inPrId)
567 563              }
580 576      let c = (((((D * D) / (x * n)) * D) * aPrecision) / (ann * n))
581 577      let b = ((s + ((D * aPrecision) / ann)) - D)
582 578      func calc (acc,cur) =     {
583 -         let $t02284722867 = acc
584 -         let y = $t02284722867._1
585 -         let found = $t02284722867._2
579 +         let $t02264922669 = acc
580 +         let y = $t02264922669._1
581 +         let found = $t02264922669._2
586 582          if ((found != unit))
587 583              then acc
588 584              else {
595 591          }
596 592  
597 593      let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
598 -     let $t02317423221 = {
594 +     let $t02297623023 = {
599 595          let $l = arr
600 596          let $s = size($l)
601 597          let $acc0 = $Tuple2(D, unit)
609 605  
610 606          $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
611 607          }
612 -     let y = $t02317423221._1
613 -     let found = $t02317423221._2
608 +     let y = $t02297623023._1
609 +     let found = $t02297623023._2
614 610      if ((found != unit))
615 611          then y
616 612          else throw(("Y calculation error, Y = " + toString(y)))
654 650      let priceAssetBalance = getAccBalance(assetIdToString(cfgPriceAssetId))
655 651      let amountAssetAmount = order.amount
656 652      let priceAssetAmount = fraction(order.amount, order.price, scale8, FLOOR)
657 -     let $t02541925631 = if ((order.orderType == Buy))
653 +     let $t02522125433 = if ((order.orderType == Buy))
658 654          then $Tuple2(amountAssetAmount, -(priceAssetAmount))
659 655          else $Tuple2(-(amountAssetAmount), priceAssetAmount)
660 -     let amountAssetBalanceDelta = $t02541925631._1
661 -     let priceAssetBalanceDelta = $t02541925631._2
656 +     let amountAssetBalanceDelta = $t02522125433._1
657 +     let priceAssetBalanceDelta = $t02522125433._2
662 658      if (if (if (igs())
663 659          then true
664 660          else (cfgPoolStatus == PoolMatcherDis))
671 667              then throw("Wr assets")
672 668              else {
673 669                  let dLp = parseBigIntValue(valueOrElse(getString(this, keyDLp), "0"))
674 -                 let $t02597326073 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
675 -                 let unusedActions = $t02597326073._1
676 -                 let dLpNew = $t02597326073._2
670 +                 let $t02577525875 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
671 +                 let unusedActions = $t02577525875._1
672 +                 let dLpNew = $t02577525875._2
677 673                  let isOrderValid = (dLpNew >= dLp)
678 674                  let info = makeString(["dLp=", toString(dLp), " dLpNew=", toString(dLpNew), " amountAssetBalance=", toString(amountAssetBalance), " priceAssetBalance=", toString(priceAssetBalance), " amountAssetBalanceDelta=", toString(amountAssetBalanceDelta), " priceAssetBalanceDelta=", toString(priceAssetBalanceDelta), " height=", toString(height)], "")
679 675                  $Tuple2(isOrderValid, info)
727 723          then {
728 724              let amBalance = getAccBalance(amId)
729 725              let prBalance = getAccBalance(prId)
730 -             let $t02872929191 = if ((txId == ""))
726 +             let $t02853128993 = if ((txId == ""))
731 727                  then $Tuple2(amBalance, prBalance)
732 728                  else if ((pmtAssetId == amId))
733 729                      then if ((pmtAmtRaw > amBalance))
738 734                              then throw("invalid payment amount")
739 735                              else $Tuple2(amBalance, (prBalance - pmtAmtRaw))
740 736                          else throw("wrong pmtAssetId")
741 -             let amBalanceOld = $t02872929191._1
742 -             let prBalanceOld = $t02872929191._2
743 -             let $t02919729373 = if ((pmtAssetId == amId))
737 +             let amBalanceOld = $t02853128993._1
738 +             let prBalanceOld = $t02853128993._2
739 +             let $t02899929175 = if ((pmtAssetId == amId))
744 740                  then $Tuple2(pmtAmtRaw, 0)
745 741                  else if ((pmtAssetId == prId))
746 742                      then $Tuple2(0, pmtAmtRaw)
747 743                      else throw("invalid payment")
748 -             let amAmountRaw = $t02919729373._1
749 -             let prAmountRaw = $t02919729373._2
750 -             let $t02937729631 = if (withTakeFee)
744 +             let amAmountRaw = $t02899929175._1
745 +             let prAmountRaw = $t02899929175._2
746 +             let $t02917929433 = if (withTakeFee)
751 747                  then $Tuple3(takeFee(amAmountRaw, inFee)._1, takeFee(prAmountRaw, inFee)._1, takeFee(pmtAmtRaw, inFee)._2)
752 748                  else $Tuple3(amAmountRaw, prAmountRaw, 0)
753 -             let amAmount = $t02937729631._1
754 -             let prAmount = $t02937729631._2
755 -             let feeAmount = $t02937729631._3
749 +             let amAmount = $t02917929433._1
750 +             let prAmount = $t02917929433._2
751 +             let feeAmount = $t02917929433._3
756 752              let amBalanceNew = (amBalanceOld + amAmount)
757 753              let prBalanceNew = (prBalanceOld + prAmount)
758 754              let D0 = getD([t1(amBalanceOld, cfgAmountAssetDecimals), t1(prBalanceOld, cfgPriceAssetDecimals)])
800 796                  else {
801 797                      let amBalance = getAccBalance(amId)
802 798                      let prBalance = getAccBalance(prId)
803 -                     let $t03174331854 = {
799 +                     let $t03154531656 = {
804 800                          let @ = invoke(this, "getOneTknV2READONLY", [outAssetId, pmtAmt], nil)
805 801                          if ($isInstanceOf(@, "(Int, Int)"))
806 802                              then @
807 803                              else throw(($getType(@) + " couldn't be cast to (Int, Int)"))
808 804                          }
809 -                     if (($t03174331854 == $t03174331854))
805 +                     if (($t03154531656 == $t03154531656))
810 806                          then {
811 -                             let feeAmount = $t03174331854._2
812 -                             let totalGet = $t03174331854._1
807 +                             let feeAmount = $t03154531656._2
808 +                             let totalGet = $t03154531656._1
813 809                              let totalAmount = if (if ((minOutAmount > 0))
814 810                                  then (minOutAmount > totalGet)
815 811                                  else false)
816 812                                  then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
817 813                                  else totalGet
818 -                             let $t03204432351 = if ((outAssetId == amId))
814 +                             let $t03184632153 = if ((outAssetId == amId))
819 815                                  then $Tuple4(totalAmount, 0, ((amBalance - totalAmount) - feeAmount), prBalance)
820 816                                  else if ((outAssetId == prId))
821 817                                      then $Tuple4(0, totalAmount, amBalance, ((prBalance - totalAmount) - feeAmount))
822 818                                      else throw("invalid out asset id")
823 -                             let outAm = $t03204432351._1
824 -                             let outPr = $t03204432351._2
825 -                             let amBalanceNew = $t03204432351._3
826 -                             let prBalanceNew = $t03204432351._4
819 +                             let outAm = $t03184632153._1
820 +                             let outPr = $t03184632153._2
821 +                             let amBalanceNew = $t03184632153._3
822 +                             let prBalanceNew = $t03184632153._4
827 823                              let curPrX18 = cpbi(t1(prBalanceNew, prDecimals), t1(amBalanceNew, amDecimals))
828 824                              let curPr = f1(curPrX18, scale8)
829 825                              let outAssetIdOrWaves = if ((outAssetId == "WAVES"))
838 834                                      let burn = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
839 835                                      if ((burn == burn))
840 836                                          then {
841 -                                             let $t03313633486 = {
837 +                                             let $t03293833288 = {
842 838                                                  let feeAmountForCalc = if ((this == feeCollectorAddress))
843 839                                                      then 0
844 840                                                      else feeAmount
849 845                                                      then $Tuple2(-((totalGet + feeAmountForCalc)), 0)
850 846                                                      else $Tuple2(0, -((totalGet + feeAmountForCalc)))
851 847                                                  }
852 -                                             let amountAssetBalanceDelta = $t03313633486._1
853 -                                             let priceAssetBalanceDelta = $t03313633486._2
854 -                                             let $t03348933597 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
855 -                                             let refreshDLpActions = $t03348933597._1
856 -                                             let updatedDLp = $t03348933597._2
848 +                                             let amountAssetBalanceDelta = $t03293833288._1
849 +                                             let priceAssetBalanceDelta = $t03293833288._2
850 +                                             let $t03329133399 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
851 +                                             let refreshDLpActions = $t03329133399._1
852 +                                             let updatedDLp = $t03329133399._2
857 853                                              let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
858 854                                              if ((isUpdatedDLpValid == isUpdatedDLpValid))
859 855                                                  then $Tuple2((state ++ refreshDLpActions), totalAmount)
925 921      let c = (((((D * D) / (x * n)) * D) * aPrecision) / (ann * n))
926 922      let b = ((s + ((D * aPrecision) / ann)) - D)
927 923      func calc (acc,cur) =     {
928 -         let $t03508435104 = acc
929 -         let y = $t03508435104._1
930 -         let found = $t03508435104._2
924 +         let $t03488634906 = acc
925 +         let y = $t03488634906._1
926 +         let found = $t03488634906._2
931 927          if ((found != unit))
932 928              then acc
933 929              else {
940 936          }
941 937  
942 938      let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
943 -     let $t03543535482 = {
939 +     let $t03523735284 = {
944 940          let $l = arr
945 941          let $s = size($l)
946 942          let $acc0 = $Tuple2(D, unit)
954 950  
955 951          $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
956 952          }
957 -     let y = $t03543535482._1
958 -     let found = $t03543535482._2
953 +     let y = $t03523735284._1
954 +     let found = $t03523735284._2
959 955      if ((found != unit))
960 956          then y
961 957          else throw(("Y calculation error, Y = " + toString(y)))
967 963  
968 964  @Callable(i)
969 965  func calculateAmountOutForSwapREADONLY (cleanAmountIn,isReverse,feePoolAmount) = {
970 -     let $t03583436258 = if ((isReverse == false))
966 +     let $t03563636060 = if ((isReverse == false))
971 967          then {
972 968              let assetOut = strf(this, pa())
973 969              let poolAmountInBalance = (toBigInt(getAccBalance(strf(this, aa()))) + toBigInt(cleanAmountIn))
978 974              let poolAmountInBalance = (toBigInt(getAccBalance(strf(this, pa()))) + toBigInt(cleanAmountIn))
979 975              $Tuple2(assetOut, poolAmountInBalance)
980 976              }
981 -     let assetOut = $t03583436258._1
982 -     let poolAmountInBalance = $t03583436258._2
977 +     let assetOut = $t03563636060._1
978 +     let poolAmountInBalance = $t03563636060._2
983 979      let poolConfig = gpc()
984 980      let amId = poolConfig[idxAmAsId]
985 981      let prId = poolConfig[idxPrAsId]
1019 1015          then {
1020 1016              let pmt = value(i.payments[0])
1021 1017              let assetIn = assetIdToString(pmt.assetId)
1022 -             let $t03769438088 = if ((isReverse == false))
1018 +             let $t03749637890 = if ((isReverse == false))
1023 1019                  then {
1024 1020                      let assetOut = strf(this, pa())
1025 1021                      let poolAmountInBalance = (getAccBalance(assetIn) - value(i.payments[0]).amount)
1030 1026                      let poolAmountInBalance = (getAccBalance(assetIn) - value(i.payments[0]).amount)
1031 1027                      $Tuple2(assetOut, poolAmountInBalance)
1032 1028                      }
1033 -             let assetOut = $t03769438088._1
1034 -             let poolAmountInBalance = $t03769438088._2
1029 +             let assetOut = $t03749637890._1
1030 +             let poolAmountInBalance = $t03749637890._2
1035 1031              let poolConfig = gpc()
1036 1032              let amId = poolConfig[idxAmAsId]
1037 1033              let prId = poolConfig[idxPrAsId]
1136 1132                                                                                              else throw("Strict value is not equal to itself.")
1137 1133                                                                                          }
1138 1134                                                                                      else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
1139 -                                                                                 let $t04223242374 = refreshDLpInternal(0, 0, 0)
1140 -                                                                                 let refreshDLpActions = $t04223242374._1
1141 -                                                                                 let updatedDLp = $t04223242374._2
1135 +                                                                                 let $t04203442176 = refreshDLpInternal(0, 0, 0)
1136 +                                                                                 let refreshDLpActions = $t04203442176._1
1137 +                                                                                 let updatedDLp = $t04203442176._2
1142 1138                                                                                  let check = if ((updatedDLp >= currentDLp))
1143 1139                                                                                      then true
1144 1140                                                                                      else throwErr(makeString(["updated DLp lower than current DLp", toString(amountAssetBalance), toString(priceAssetBalance), toString(lpAssetEmission), toString(currentDLp), toString(updatedDLp), toString(amDiff), toString(prDiff)], " "))
1211 1207                  else calcCurrentDLp(toBigInt(0), toBigInt(pmtAmt), toBigInt(0))
1212 1208              if ((currentDLp == currentDLp))
1213 1209                  then {
1214 -                     let $t04401544173 = calcPutOneTkn(pmtAmt, pmtAssetId, toString(userAddress), toBase58String(i.transactionId), true)
1215 -                     if (($t04401544173 == $t04401544173))
1210 +                     let $t04381743975 = calcPutOneTkn(pmtAmt, pmtAssetId, toString(userAddress), toBase58String(i.transactionId), true)
1211 +                     if (($t04381743975 == $t04381743975))
1216 1212                          then {
1217 -                             let feeAmount = $t04401544173._3
1218 -                             let state = $t04401544173._2
1219 -                             let estimLP = $t04401544173._1
1213 +                             let feeAmount = $t04381743975._3
1214 +                             let state = $t04381743975._2
1215 +                             let estimLP = $t04381743975._1
1220 1216                              let emitLpAmt = if (if ((minOutAmount > 0))
1221 1217                                  then (minOutAmount > estimLP)
1222 1218                                  else false)
1244 1240                                              let sendFeeToMatcher = if ((feeAmount > 0))
1245 1241                                                  then [ScriptTransfer(feeCollectorAddress, feeAmount, fromBase58String(pmtAssetId))]
1246 1242                                                  else nil
1247 -                                             let $t04505845407 = if ((this == feeCollectorAddress))
1243 +                                             let $t04486045209 = if ((this == feeCollectorAddress))
1248 1244                                                  then $Tuple2(0, 0)
1249 1245                                                  else {
1250 1246                                                      let paymentInAmountAsset = if ((pmt.assetId == cfgAmountAssetId))
1254 1250                                                          then $Tuple2(-(feeAmount), 0)
1255 1251                                                          else $Tuple2(0, -(feeAmount))
1256 1252                                                      }
1257 -                                             let amountAssetBalanceDelta = $t04505845407._1
1258 -                                             let priceAssetBalanceDelta = $t04505845407._2
1259 -                                             let $t04541045518 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
1260 -                                             let refreshDLpActions = $t04541045518._1
1261 -                                             let updatedDLp = $t04541045518._2
1253 +                                             let amountAssetBalanceDelta = $t04486045209._1
1254 +                                             let priceAssetBalanceDelta = $t04486045209._2
1255 +                                             let $t04521245320 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
1256 +                                             let refreshDLpActions = $t04521245320._1
1257 +                                             let updatedDLp = $t04521245320._2
1262 1258                                              let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1263 1259                                              if ((isUpdatedDLpValid == isUpdatedDLpValid))
1264 1260                                                  then $Tuple2((((state ++ lpTrnsfr) ++ sendFeeToMatcher) ++ refreshDLpActions), emitLpAmt)
1290 1286              let currentDLp = calcCurrentDLp(amAssetPmt, prAssetPmt, toBigInt(0))
1291 1287              if ((currentDLp == currentDLp))
1292 1288                  then {
1293 -                     let $t04654846613 = refreshDLpInternal(0, 0, 0)
1294 -                     let refreshDLpActions = $t04654846613._1
1295 -                     let updatedDLp = $t04654846613._2
1289 +                     let $t04635046415 = refreshDLpInternal(0, 0, 0)
1290 +                     let refreshDLpActions = $t04635046415._1
1291 +                     let updatedDLp = $t04635046415._2
1296 1292                      let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1297 1293                      if ((isUpdatedDLpValid == isUpdatedDLpValid))
1298 1294                          then (state ++ refreshDLpActions)
1317 1313              let b = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
1318 1314              if ((b == b))
1319 1315                  then {
1320 -                     let $t04778647868 = refreshDLpInternal(-(outAmtAmt), -(outPrAmt), 0)
1321 -                     let refreshDLpActions = $t04778647868._1
1322 -                     let updatedDLp = $t04778647868._2
1316 +                     let $t04758847670 = refreshDLpInternal(-(outAmtAmt), -(outPrAmt), 0)
1317 +                     let refreshDLpActions = $t04758847670._1
1318 +                     let updatedDLp = $t04758847670._2
1323 1319                      let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1324 1320                      if ((isUpdatedDLpValid == isUpdatedDLpValid))
1325 1321                          then (state ++ refreshDLpActions)
1354 1350          else throwErr("exactly 1 payment are expected")]
1355 1351      if ((checks == checks))
1356 1352          then {
1357 -             let $t04848648641 = getOneTknV2Internal(outAssetId, minOutAmount, i.payments, i.caller, i.originCaller, i.transactionId)
1358 -             let state = $t04848648641._1
1359 -             let totalAmount = $t04848648641._2
1353 +             let $t04828848443 = getOneTknV2Internal(outAssetId, minOutAmount, i.payments, i.caller, i.originCaller, i.transactionId)
1354 +             let state = $t04828848443._1
1355 +             let totalAmount = $t04828848443._2
1360 1356              $Tuple2(state, totalAmount)
1361 1357              }
1362 1358          else throw("Strict value is not equal to itself.")
1373 1369      if ((checkLastRefreshedBlockHeight == checkLastRefreshedBlockHeight))
1374 1370          then {
1375 1371              let dLp = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, keyDLp), "0")), fmtErr("invalid dLp"))
1376 -             let $t04916549229 = refreshDLpInternal(0, 0, 0)
1377 -             let dLpUpdateActions = $t04916549229._1
1378 -             let updatedDLp = $t04916549229._2
1372 +             let $t04896749031 = refreshDLpInternal(0, 0, 0)
1373 +             let dLpUpdateActions = $t04896749031._1
1374 +             let updatedDLp = $t04896749031._2
1379 1375              let actions = if ((dLp != updatedDLp))
1380 1376                  then dLpUpdateActions
1381 1377                  else throwErr("nothing to refresh")
1403 1399      let newY = getYD(xp, index, D1)
1404 1400      let dy = (xp[index] - newY)
1405 1401      let totalGetRaw = max([0, toInt((dy - big1))])
1406 -     let $t05023950294 = takeFee(totalGetRaw, outFee)
1407 -     let totalGet = $t05023950294._1
1408 -     let feeAmount = $t05023950294._2
1402 +     let $t05004150096 = takeFee(totalGetRaw, outFee)
1403 +     let totalGet = $t05004150096._1
1404 +     let feeAmount = $t05004150096._2
1409 1405      $Tuple2(nil, $Tuple2(totalGet, feeAmount))
1410 1406      }
1411 1407  
1418 1414      let lpId = toBase58String(value(cfgLpAssetId))
1419 1415      let amBalance = getAccBalance(amId)
1420 1416      let prBalance = getAccBalance(prId)
1421 -     let $t05066950784 = {
1417 +     let $t05047150586 = {
1422 1418          let @ = invoke(this, "getOneTknV2READONLY", [outAssetId, lpAssetAmount], nil)
1423 1419          if ($isInstanceOf(@, "(Int, Int)"))
1424 1420              then @
1425 1421              else throw(($getType(@) + " couldn't be cast to (Int, Int)"))
1426 1422          }
1427 -     let totalGet = $t05066950784._1
1428 -     let feeAmount = $t05066950784._2
1423 +     let totalGet = $t05047150586._1
1424 +     let feeAmount = $t05047150586._2
1429 1425      let r = ego("", lpId, lpAssetAmount, this)
1430 1426      let outAmAmt = r._1
1431 1427      let outPrAmt = r._2
1459 1455                          let burnLPAssetOnFactory = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
1460 1456                          if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
1461 1457                              then {
1462 -                                 let $t05195052031 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1463 -                                 let refreshDLpActions = $t05195052031._1
1464 -                                 let updatedDLp = $t05195052031._2
1458 +                                 let $t05175251833 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1459 +                                 let refreshDLpActions = $t05175251833._1
1460 +                                 let updatedDLp = $t05175251833._2
1465 1461                                  let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1466 1462                                  if ((isUpdatedDLpValid == isUpdatedDLpValid))
1467 1463                                      then (state ++ refreshDLpActions)
1506 1502                                      let burnA = invoke(fca, "burn", [amount], [AttachedPayment(lpAssetId, amount)])
1507 1503                                      if ((burnA == burnA))
1508 1504                                          then {
1509 -                                             let $t05305853139 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1510 -                                             let refreshDLpActions = $t05305853139._1
1511 -                                             let updatedDLp = $t05305853139._2
1505 +                                             let $t05286052941 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1506 +                                             let refreshDLpActions = $t05286052941._1
1507 +                                             let updatedDLp = $t05286052941._2
1512 1508                                              let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1513 1509                                              if ((isUpdatedDLpValid == isUpdatedDLpValid))
1514 1510                                                  then (state ++ refreshDLpActions)
1559 1555                                      let burnLPAssetOnFactory = invoke(fca, "burn", [unstakeAmount], [AttachedPayment(cfgLpAssetId, unstakeAmount)])
1560 1556                                      if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
1561 1557                                          then {
1562 -                                             let $t05439054471 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1563 -                                             let refreshDLpActions = $t05439054471._1
1564 -                                             let updatedDLp = $t05439054471._2
1558 +                                             let $t05419254273 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1559 +                                             let refreshDLpActions = $t05419254273._1
1560 +                                             let updatedDLp = $t05419254273._2
1565 1561                                              let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1566 1562                                              if ((isUpdatedDLpValid == isUpdatedDLpValid))
1567 1563                                                  then (state ++ refreshDLpActions)
1610 1606              let unstakeInv = invoke(staking, "unstakeINTERNAL", [lpAssetId, unstakeAmount, userAddress.bytes, lpAssetRecipientAddress.bytes], nil)
1611 1607              if ((unstakeInv == unstakeInv))
1612 1608                  then {
1613 -                     let $t05549355681 = getOneTknV2Internal(outAssetId, minOutAmount, [AttachedPayment(lpAssetId, unstakeAmount)], i.caller, i.originCaller, i.transactionId)
1614 -                     let state = $t05549355681._1
1615 -                     let totalAmount = $t05549355681._2
1609 +                     let $t05529555483 = getOneTknV2Internal(outAssetId, minOutAmount, [AttachedPayment(lpAssetId, unstakeAmount)], i.caller, i.originCaller, i.transactionId)
1610 +                     let state = $t05529555483._1
1611 +                     let totalAmount = $t05529555483._2
1616 1612                      $Tuple2(state, totalAmount)
1617 1613                      }
1618 1614                  else throw("Strict value is not equal to itself.")
1624 1620  
1625 1621  @Callable(i)
1626 1622  func putOneTknV2WithBonusREADONLY (paymentAmountRaw,paymentAssetId) = {
1627 -     let $t05580955912 = calcPutOneTkn(paymentAmountRaw, paymentAssetId, "", "", true)
1628 -     let lpAmount = $t05580955912._1
1629 -     let state = $t05580955912._2
1630 -     let feeAmount = $t05580955912._3
1631 -     let bonus = $t05580955912._4
1623 +     let $t05561155714 = calcPutOneTkn(paymentAmountRaw, paymentAssetId, "", "", true)
1624 +     let lpAmount = $t05561155714._1
1625 +     let state = $t05561155714._2
1626 +     let feeAmount = $t05561155714._3
1627 +     let bonus = $t05561155714._4
1632 1628      $Tuple2(nil, $Tuple3(lpAmount, feeAmount, bonus))
1633 1629      }
1634 1630  
1636 1632  
1637 1633  @Callable(i)
1638 1634  func putOneTknV2WithoutTakeFeeREADONLY (paymentAmountRaw,paymentAssetId) = {
1639 -     let $t05606056164 = calcPutOneTkn(paymentAmountRaw, paymentAssetId, "", "", false)
1640 -     let lpAmount = $t05606056164._1
1641 -     let state = $t05606056164._2
1642 -     let feeAmount = $t05606056164._3
1643 -     let bonus = $t05606056164._4
1635 +     let $t05586255966 = calcPutOneTkn(paymentAmountRaw, paymentAssetId, "", "", false)
1636 +     let lpAmount = $t05586255966._1
1637 +     let state = $t05586255966._2
1638 +     let feeAmount = $t05586255966._3
1639 +     let bonus = $t05586255966._4
1644 1640      $Tuple2(nil, $Tuple3(lpAmount, feeAmount, bonus))
1645 1641      }
1646 1642  
1649 1645  @Callable(i)
1650 1646  func activate (amtAsStr,prAsStr) = if ((toString(i.caller) != toString(fca)))
1651 1647      then throw("denied")
1652 -     else $Tuple2([StringEntry(aa(), amtAsStr), StringEntry(pa(), prAsStr)], "success")
1648 +     else $Tuple2([StringEntry(aa(), amtAsStr), StringEntry(pa(), prAsStr), StringEntry(amp(), toString(ampInitial))], "success")
1653 1649  
1654 1650  
1655 1651  
1702 1698  @Callable(i)
1703 1699  func changeAmp () = {
1704 1700      let cfg = invoke(fca, "getChangeAmpConfigREADONLY", [toString(this)], nil)
1705 -     let $t05851858717 =     match cfg {
1701 +     let $t05837558574 =     match cfg {
1706 1702          case list: List[Any] => 
1707 1703              $Tuple3({
1708 1704                  let @ = list[0]
1723 1719          case _ => 
1724 1720              throwErr("invalid entry type")
1725 1721      }
1726 -     let delay = $t05851858717._1
1727 -     let delta = $t05851858717._2
1728 -     let target = $t05851858717._3
1722 +     let delay = $t05837558574._1
1723 +     let delta = $t05837558574._2
1724 +     let target = $t05837558574._3
1729 1725      let curAmp = parseIntValue(getStringValue(amp()))
1730 1726      let newAmpRaw = (curAmp + delta)
1731 1727      let newAmp = if ((0 > delta))
1761 1757      match tx {
1762 1758          case order: Order => 
1763 1759              let matcherPub = mp()
1764 -             let $t05965059767 = if (skipOrderValidation())
1760 +             let $t05950759624 = if (skipOrderValidation())
1765 1761                  then $Tuple2(true, "")
1766 1762                  else validateMatcherOrderAllowed(order)
1767 -             let orderValid = $t05965059767._1
1768 -             let orderValidInfo = $t05965059767._2
1763 +             let orderValid = $t05950759624._1
1764 +             let orderValidInfo = $t05950759624._2
1769 1765              let senderValid = sigVerify(order.bodyBytes, order.proofs[0], order.senderPublicKey)
1770 1766              let matcherValid = sigVerify(order.bodyBytes, order.proofs[1], matcherPub)
1771 1767              if (if (if (orderValid)
Full: 
Old New Differences
1 1  {-# STDLIB_VERSION 6 #-}
2 2  {-# SCRIPT_TYPE ACCOUNT #-}
3 3  {-# CONTENT_TYPE DAPP #-}
4 4  let scale8 = 100000000
5 5  
6 6  let scale8BigInt = toBigInt(100000000)
7 7  
8 8  let scale18 = toBigInt(1000000000000000000)
9 9  
10 10  let zeroBigInt = toBigInt(0)
11 11  
12 12  let big0 = toBigInt(0)
13 13  
14 14  let big1 = toBigInt(1)
15 15  
16 16  let big2 = toBigInt(2)
17 17  
18 18  let big3 = toBigInt(3)
19 19  
20 20  let big4 = toBigInt(4)
21 21  
22 22  let slippage4D = toBigInt((scale8 - ((scale8 * 1) / scale8)))
23 23  
24 24  let wavesString = "WAVES"
25 + 
26 + let ampInitial = 50
25 27  
26 28  let Amult = "100"
27 29  
28 30  let Dconv = "1"
29 31  
30 32  let SEP = "__"
31 33  
32 34  let EMPTY = ""
33 35  
34 36  let PoolActive = 1
35 37  
36 38  let PoolPutDis = 2
37 39  
38 40  let PoolMatcherDis = 3
39 41  
40 42  let PoolShutdown = 4
41 43  
42 44  let idxPoolAddress = 1
43 45  
44 46  let idxPoolSt = 2
45 47  
46 48  let idxLPAsId = 3
47 49  
48 50  let idxAmAsId = 4
49 51  
50 52  let idxPrAsId = 5
51 53  
52 54  let idxAmtAsDcm = 6
53 55  
54 56  let idxPriceAsDcm = 7
55 57  
56 58  let idxIAmtAsId = 8
57 59  
58 60  let idxIPriceAsId = 9
59 61  
60 62  let idxFactStakCntr = 1
61 63  
62 64  let idxFactoryRestCntr = 6
63 65  
64 66  let idxFactSlippCntr = 7
65 67  
66 68  let idxFactGwxRewCntr = 10
67 69  
68 70  let feeDefault = fraction(10, scale8, 10000)
69 71  
70 72  func t1 (origVal,origScaleMult) = fraction(toBigInt(origVal), scale18, toBigInt(origScaleMult))
71 73  
72 74  
73 75  func t1BigInt (origVal,origScaleMult) = fraction(origVal, scale18, origScaleMult)
74 76  
75 77  
76 78  func f1 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), scale18))
77 79  
78 80  
79 81  func fromX18Round (val,resultScaleMult,round) = toInt(fraction(val, toBigInt(resultScaleMult), scale18, round))
80 82  
81 83  
82 84  func t2 (origVal,origScaleMult) = fraction(origVal, scale18, toBigInt(origScaleMult))
83 85  
84 86  
85 87  func f2 (val,resultScaleMult) = fraction(val, toBigInt(resultScaleMult), scale18)
86 88  
87 89  
88 90  func ts (amt,resScale,curScale) = fraction(amt, resScale, curScale)
89 91  
90 92  
91 93  func abs (val) = if ((zeroBigInt > val))
92 94      then -(val)
93 95      else val
94 96  
95 97  
96 98  func absBigInt (val) = if ((zeroBigInt > val))
97 99      then -(val)
98 100      else val
99 101  
100 102  
101 103  func fc () = "%s__factoryContract"
102 104  
103 105  
104 106  func keyManagerPublicKey () = "%s__managerPublicKey"
105 107  
106 108  
107 109  func keyManagerVaultAddress () = "%s__managerVaultAddress"
108 110  
109 111  
110 112  func pl () = "%s%s__price__last"
111 113  
112 114  
113 115  func ph (h,t) = makeString(["%s%s%d%d__price__history", toString(h), toString(t)], SEP)
114 116  
115 117  
116 118  func pau (ua,txId) = ((("%s%s%s__P__" + ua) + "__") + txId)
117 119  
118 120  
119 121  func gau (ua,txId) = ((("%s%s%s__G__" + ua) + "__") + txId)
120 122  
121 123  
122 124  func aa () = "%s__amountAsset"
123 125  
124 126  
125 127  func pa () = "%s__priceAsset"
126 128  
127 129  
128 130  func amp () = "%s__amp"
129 131  
130 132  
131 133  func keyAmpHistory (heightBlocks) = ("%s%d__amp__" + toString(heightBlocks))
132 134  
133 135  
134 136  func keyChangeAmpLastCall () = "%s__changeAmpLastCall"
135 137  
136 138  
137 139  let keyFee = "%s__fee"
138 140  
139 141  let fee = valueOrElse(getInteger(this, keyFee), feeDefault)
140 142  
141 143  let keyDLp = makeString(["%s", "dLp"], SEP)
142 144  
143 145  let keyDLpRefreshedHeight = makeString(["%s", "dLpRefreshedHeight"], SEP)
144 146  
145 147  let keyDLpRefreshDelay = makeString(["%s", "refreshDLpDelay"], SEP)
146 148  
147 149  let dLpRefreshDelayDefault = 30
148 150  
149 151  let dLpRefreshDelay = valueOrElse(getInteger(this, keyDLpRefreshDelay), dLpRefreshDelayDefault)
150 152  
151 153  func fcfg () = "%s__factoryConfig"
152 154  
153 155  
154 156  func mtpk () = "%s%s__matcher__publicKey"
155 157  
156 158  
157 159  func pc (iAmtAs,iPrAs) = (((("%d%d%s__" + iAmtAs) + "__") + iPrAs) + "__config")
158 160  
159 161  
160 162  func mba (bAStr) = ("%s%s%s__mappings__baseAsset2internalId__" + bAStr)
161 163  
162 164  
163 165  func aps () = "%s__shutdown"
164 166  
165 167  
166 168  func keyAllowedLpStableScriptHash () = "%s__allowedLpStableScriptHash"
167 169  
168 170  
169 171  func keyFeeCollectorAddress () = "%s__feeCollectorAddress"
170 172  
171 173  
172 174  func keySkipOrderValidation (poolAddress) = ("%s%s__skipOrderValidation__" + poolAddress)
173 175  
174 176  
175 177  func throwOrderError (orderValid,orderValidInfo,senderValid,matcherValid) = throw((((((((("order validation failed: orderValid=" + toString(orderValid)) + " (") + orderValidInfo) + ")") + " senderValid=") + toString(senderValid)) + " matcherValid=") + toString(matcherValid)))
176 178  
177 179  
178 180  func addressFromStringOrThis (addressString) = match addressFromString(addressString) {
179 181      case a: Address => 
180 182          a
181 183      case _ => 
182 184          this
183 185  }
184 186  
185 187  
186 188  func getManagerVaultAddressOrThis () = {
187 189      let factoryAddress =     match getString(fc()) {
188 190          case fca: String => 
189 191              addressFromStringOrThis(fca)
190 192          case _ => 
191 193              this
192 194      }
193 195      match getString(factoryAddress, keyManagerVaultAddress()) {
194 196          case s: String => 
195 197              addressFromStringOrThis(s)
196 198          case _ => 
197 199              this
198 200      }
199 201      }
200 202  
201 203  
202 204  func strf (addr,key) = valueOrErrorMessage(getString(addr, key), makeString(["mandatory ", toString(addr), ".", key, " not defined"], ""))
203 205  
204 206  
205 207  func intf (addr,key) = valueOrErrorMessage(getInteger(addr, key), makeString(["mandatory ", toString(addr), ".", key, " not defined"], ""))
206 208  
207 209  
208 210  func throwErr (msg) = throw(makeString(["lp_stable.ride:", msg], " "))
209 211  
210 212  
211 213  func fmtErr (msg) = makeString(["lp_stable.ride:", msg], " ")
212 214  
213 215  
214 216  let fca = addressFromStringValue(strf(this, fc()))
215 217  
216 218  let inFee = {
217 219      let @ = invoke(fca, "getInFeeREADONLY", [toString(this)], nil)
218 220      if ($isInstanceOf(@, "Int"))
219 221          then @
220 222          else throw(($getType(@) + " couldn't be cast to Int"))
221 223      }
222 224  
223 225  let outFee = {
224 226      let @ = invoke(fca, "getOutFeeREADONLY", [toString(this)], nil)
225 227      if ($isInstanceOf(@, "Int"))
226 228          then @
227 229          else throw(($getType(@) + " couldn't be cast to Int"))
228 230      }
229 231  
230 232  let A = strf(this, amp())
231 233  
232 234  func igs () = valueOrElse(getBoolean(fca, aps()), false)
233 235  
234 236  
235 237  func mp () = fromBase58String(strf(fca, mtpk()))
236 238  
237 239  
238 240  let feeCollectorAddress = addressFromStringValue(strf(fca, keyFeeCollectorAddress()))
239 241  
240 242  func gpc () = {
241 243      let amtAs = strf(this, aa())
242 244      let priceAs = strf(this, pa())
243 245      let iPriceAs = intf(fca, mba(priceAs))
244 246      let iAmtAs = intf(fca, mba(amtAs))
245 247      split(strf(fca, pc(toString(iAmtAs), toString(iPriceAs))), SEP)
246 248      }
247 249  
248 250  
249 251  func parseAssetId (input) = if ((input == wavesString))
250 252      then unit
251 253      else fromBase58String(input)
252 254  
253 255  
254 256  func assetIdToString (input) = if ((input == unit))
255 257      then wavesString
256 258      else toBase58String(value(input))
257 259  
258 260  
259 - func parsePoolConfig (poolConfig) = $Tuple9(addressFromStringValue(poolConfig[idxPoolAddress]), parseIntValue(poolConfig[idxPoolSt]), fromBase58String(poolConfig[idxLPAsId]), parseAssetId(poolConfig[idxAmAsId]), parseAssetId(poolConfig[idxPrAsId]), parseIntValue(poolConfig[idxAmtAsDcm]), parseIntValue(poolConfig[idxPriceAsDcm]), fromBase58String(poolConfig[idxIAmtAsId]), fromBase58String(poolConfig[idxIPriceAsId]))
261 + func parsePoolConfig (poolConfig) = $Tuple7(addressFromStringValue(poolConfig[idxPoolAddress]), parseIntValue(poolConfig[idxPoolSt]), fromBase58String(poolConfig[idxLPAsId]), parseAssetId(poolConfig[idxAmAsId]), parseAssetId(poolConfig[idxPrAsId]), parseIntValue(poolConfig[idxAmtAsDcm]), parseIntValue(poolConfig[idxPriceAsDcm]))
260 262  
261 263  
262 264  let poolConfigParsed = parsePoolConfig(gpc())
263 265  
264 - let $t086868915 = poolConfigParsed
266 + let $t086088794 = poolConfigParsed
265 267  
266 - let cfgPoolAddress = $t086868915._1
268 + let cfgPoolAddress = $t086088794._1
267 269  
268 - let cfgPoolStatus = $t086868915._2
270 + let cfgPoolStatus = $t086088794._2
269 271  
270 - let cfgLpAssetId = $t086868915._3
272 + let cfgLpAssetId = $t086088794._3
271 273  
272 - let cfgAmountAssetId = $t086868915._4
274 + let cfgAmountAssetId = $t086088794._4
273 275  
274 - let cfgPriceAssetId = $t086868915._5
276 + let cfgPriceAssetId = $t086088794._5
275 277  
276 - let cfgAmountAssetDecimals = $t086868915._6
278 + let cfgAmountAssetDecimals = $t086088794._6
277 279  
278 - let cfgPriceAssetDecimals = $t086868915._7
279 - 
280 - let cfgInAmountAssedId = $t086868915._8
281 - 
282 - let cfgInPriceAssetId = $t086868915._9
280 + let cfgPriceAssetDecimals = $t086088794._7
283 281  
284 282  func gfc () = split(strf(fca, fcfg()), SEP)
285 283  
286 284  
287 285  let factoryConfig = gfc()
288 286  
289 287  let stakingContract = valueOrErrorMessage(addressFromString(factoryConfig[idxFactStakCntr]), "Invalid staking contract address")
290 288  
291 289  let slipageContract = valueOrErrorMessage(addressFromString(factoryConfig[idxFactSlippCntr]), "Invalid slipage contract address")
292 290  
293 291  let gwxContract = valueOrErrorMessage(addressFromString(factoryConfig[idxFactGwxRewCntr]), "Invalid gwx contract address")
294 292  
295 293  let restContract = valueOrErrorMessage(addressFromString(factoryConfig[idxFactoryRestCntr]), "Invalid gwx contract address")
296 294  
297 295  func dataPutActionInfo (inAmtAssetAmt,inPriceAssetAmt,outLpAmt,price,slipByUser,slippageReal,txHeight,txTimestamp,slipageAmAmt,slipagePrAmt) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(inAmtAssetAmt), toString(inPriceAssetAmt), toString(outLpAmt), toString(price), toString(slipByUser), toString(slippageReal), toString(txHeight), toString(txTimestamp), toString(slipageAmAmt), toString(slipagePrAmt)], SEP)
298 296  
299 297  
300 298  func dataGetActionInfo (outAmtAssetAmt,outPriceAssetAmt,inLpAmt,price,txHeight,txTimestamp) = makeString(["%d%d%d%d%d%d", toString(outAmtAssetAmt), toString(outPriceAssetAmt), toString(inLpAmt), toString(price), toString(txHeight), toString(txTimestamp)], SEP)
301 299  
302 300  
303 301  func getAccBalance (assetId) = if ((assetId == "WAVES"))
304 302      then wavesBalance(this).available
305 303      else assetBalance(this, fromBase58String(assetId))
306 304  
307 305  
308 306  func cpbi (prAmtX18,amAmtX18) = fraction(prAmtX18, scale18, amAmtX18)
309 307  
310 308  
311 309  func cpbir (prAmtX18,amAmtX18,round) = fraction(prAmtX18, scale18, amAmtX18, round)
312 310  
313 311  
314 312  func vad (A1,A2,slippage) = {
315 313      let diff = fraction((A1 - A2), scale8BigInt, A2)
316 314      let pass = ((slippage - abs(diff)) > zeroBigInt)
317 315      if (!(pass))
318 316          then throw(("Big slpg: " + toString(diff)))
319 317          else $Tuple2(pass, min([A1, A2]))
320 318      }
321 319  
322 320  
323 321  func vd (D1,D0,slpg) = {
324 322      let diff = fraction(D0, scale8BigInt, D1)
325 323      let fail = (slpg > diff)
326 324      if (if (fail)
327 325          then true
328 326          else (D0 > D1))
329 327          then throw(((((((toString(D0) + " ") + toString(D1)) + " ") + toString(diff)) + " ") + toString(slpg)))
330 328          else fail
331 329      }
332 330  
333 331  
334 332  func pcp (amAssetDcm,prAssetDcm,amAmt,prAmt) = {
335 333      let amtAsAmtX18 = t1(amAmt, amAssetDcm)
336 334      let prAsAmtX18 = t1(prAmt, prAssetDcm)
337 335      cpbi(prAsAmtX18, amtAsAmtX18)
338 336      }
339 337  
340 338  
341 339  func calcPrices (amAmt,prAmt,lpAmt) = {
342 340      let amtAsDcm = cfgAmountAssetDecimals
343 341      let prAsDcm = cfgPriceAssetDecimals
344 342      let priceX18 = pcp(amtAsDcm, prAsDcm, amAmt, prAmt)
345 343      let amAmtX18 = t1(amAmt, amtAsDcm)
346 344      let prAmtX18 = t1(prAmt, prAsDcm)
347 345      let lpAmtX18 = t1(lpAmt, scale8)
348 346      let lpPrInAmAsX18 = cpbi(amAmtX18, lpAmtX18)
349 347      let lpPrInPrAsX18 = cpbi(prAmtX18, lpAmtX18)
350 348  [priceX18, lpPrInAmAsX18, lpPrInPrAsX18]
351 349      }
352 350  
353 351  
354 352  func calculatePrices (amAmt,prAmt,lpAmt) = {
355 353      let p = calcPrices(amAmt, prAmt, lpAmt)
356 354  [f1(p[0], scale8), f1(p[1], scale8), f1(p[2], scale8)]
357 355      }
358 356  
359 357  
360 358  func takeFee (amount,fee) = {
361 359      let feeAmount = if ((fee == 0))
362 360          then 0
363 361          else fraction(amount, fee, scale8)
364 362      $Tuple2((amount - feeAmount), feeAmount)
365 363      }
366 364  
367 365  
368 366  func getD (xp) = {
369 367      let xp0 = xp[0]
370 368      let xp1 = xp[1]
371 369      let s = (xp0 + xp1)
372 370      if ((s == big0))
373 371          then big0
374 372          else {
375 373              let a = parseIntValue(A)
376 374              let ann = (a * 2)
377 375              let p = fraction(xp0, xp1, big1)
378 376              let xp0_xp1_n_n = fraction(p, big4, big1)
379 377              let ann_s = fraction(toBigInt(ann), s, big1)
380 378              let ann_1 = toBigInt((ann - 1))
381 379              func calcDNext (d) =             {
382 380                  let dd = fraction(d, d, big1)
383 381                  let ddd = fraction(dd, d, big1)
384 382                  let dp = fraction(ddd, big1, xp0_xp1_n_n)
385 383                  fraction((ann_s + fraction(dp, big2, big1)), d, (fraction(ann_1, d, big1) + fraction(big3, dp, big1)))
386 384                  }
387 385  
388 386              func calc (acc,i) =             if (acc._2)
389 387                  then acc
390 388                  else {
391 389                      let d = acc._1
392 390                      let dNext = calcDNext(d)
393 391                      let dDiffRaw = (dNext - value(d))
394 392                      let dDiff = if ((big0 > dDiffRaw))
395 393                          then -(dDiffRaw)
396 394                          else dDiffRaw
397 395                      if ((big1 >= dDiff))
398 396                          then $Tuple2(dNext, true)
399 397                          else $Tuple2(dNext, false)
400 398                      }
401 399  
402 400              let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
403 -             let $t01342013468 = {
401 +             let $t01329913347 = {
404 402                  let $l = arr
405 403                  let $s = size($l)
406 404                  let $acc0 = $Tuple2(s, false)
407 405                  func $f0_1 ($a,$i) =                 if (($i >= $s))
408 406                      then $a
409 407                      else calc($a, $l[$i])
410 408  
411 409                  func $f0_2 ($a,$i) =                 if (($i >= $s))
412 410                      then $a
413 411                      else throw("List size exceeds 17")
414 412  
415 413                  $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17)
416 414                  }
417 -             let d = $t01342013468._1
418 -             let found = $t01342013468._2
415 +             let d = $t01329913347._1
416 +             let found = $t01329913347._2
419 417              if (found)
420 418                  then d
421 419                  else throw(("D calculation error, D = " + toString(d)))
422 420              }
423 421      }
424 422  
425 423  
426 424  func ego (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
427 425      let lpId = cfgLpAssetId
428 426      let amId = toBase58String(value(cfgAmountAssetId))
429 427      let prId = toBase58String(value(cfgPriceAssetId))
430 428      let amDcm = cfgAmountAssetDecimals
431 429      let prDcm = cfgPriceAssetDecimals
432 430      let sts = toString(cfgPoolStatus)
433 431      let lpEmiss = valueOrErrorMessage(assetInfo(lpId), "Wrong LP id").quantity
434 432      if ((toBase58String(lpId) != pmtAssetId))
435 433          then throw("Wrong pmt asset")
436 434          else {
437 435              let amBalance = getAccBalance(amId)
438 436              let amBalanceX18 = t1(amBalance, amDcm)
439 437              let prBalance = getAccBalance(prId)
440 438              let prBalanceX18 = t1(prBalance, prDcm)
441 439              let curPriceX18 = cpbi(prBalanceX18, amBalanceX18)
442 440              let curPrice = f1(curPriceX18, scale8)
443 441              let pmtLpAmtX18 = t1(pmtLpAmt, scale8)
444 442              let lpEmissX18 = t1(lpEmiss, scale8)
445 443              let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissX18)
446 444              let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissX18)
447 445              let outAmAmt = fromX18Round(outAmAmtX18, amDcm, FLOOR)
448 446              let outPrAmt = fromX18Round(outPrAmtX18, prDcm, FLOOR)
449 447              let state = if ((txId58 == ""))
450 448                  then nil
451 449                  else [ScriptTransfer(userAddress, outAmAmt, if ((amId == "WAVES"))
452 450                      then unit
453 451                      else fromBase58String(amId)), ScriptTransfer(userAddress, outPrAmt, if ((prId == "WAVES"))
454 452                      then unit
455 453                      else fromBase58String(prId)), StringEntry(gau(toString(userAddress), txId58), dataGetActionInfo(outAmAmt, outPrAmt, pmtLpAmt, curPrice, height, lastBlock.timestamp)), IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice)]
456 454              $Tuple10(outAmAmt, outPrAmt, amId, prId, amBalance, prBalance, lpEmiss, curPriceX18, sts, state)
457 455              }
458 456      }
459 457  
460 458  
461 459  func epo (txId58,slippage,inAmAmt,inAmId,inPrAmt,inPrId,userAddress,isEval,emitLp,isOneAsset,validateSlippage,pmtAmt,pmtId) = {
462 460      let lpId = cfgLpAssetId
463 461      let amIdStr = toBase58String(value(cfgAmountAssetId))
464 462      let prIdStr = toBase58String(value(cfgPriceAssetId))
465 -     let inAmIdStr = cfgInAmountAssedId
466 -     let inPrIdStr = cfgInPriceAssetId
467 463      let amtDcm = cfgAmountAssetDecimals
468 464      let priceDcm = cfgPriceAssetDecimals
469 465      let sts = toString(cfgPoolStatus)
470 466      let lpEm = valueOrErrorMessage(assetInfo(lpId), "Wr lp as").quantity
471 467      let amBalance = if (isEval)
472 468          then getAccBalance(amIdStr)
473 469          else if (if (isOneAsset)
474 470              then (pmtId == amIdStr)
475 471              else false)
476 472              then (getAccBalance(amIdStr) - pmtAmt)
477 473              else if (isOneAsset)
478 474                  then getAccBalance(amIdStr)
479 475                  else (getAccBalance(amIdStr) - inAmAmt)
480 476      let prBalance = if (isEval)
481 477          then getAccBalance(prIdStr)
482 478          else if (if (isOneAsset)
483 479              then (pmtId == prIdStr)
484 480              else false)
485 481              then (getAccBalance(prIdStr) - pmtAmt)
486 482              else if (isOneAsset)
487 483                  then getAccBalance(prIdStr)
488 484                  else (getAccBalance(prIdStr) - inPrAmt)
489 485      let inAmAssetAmtX18 = t1(inAmAmt, amtDcm)
490 486      let inPrAssetAmtX18 = t1(inPrAmt, priceDcm)
491 487      let userPriceX18 = cpbi(inPrAssetAmtX18, inAmAssetAmtX18)
492 488      let amBalanceX18 = t1(amBalance, amtDcm)
493 489      let prBalanceX18 = t1(prBalance, priceDcm)
494 490      let D0 = getD([amBalanceX18, prBalanceX18])
495 491      let r = if ((lpEm == 0))
496 492          then {
497 493              let D1 = getD([(amBalanceX18 + inAmAssetAmtX18), (prBalanceX18 + inPrAssetAmtX18)])
498 494              let checkD = if ((D1 > D0))
499 495                  then true
500 496                  else throw("D1 should be greater than D0")
501 497              if ((checkD == checkD))
502 498                  then {
503 499                      let curPriceX18 = zeroBigInt
504 500                      let slippageX18 = zeroBigInt
505 501                      let lpAmtX18 = D1
506 502                      $Tuple5(f1(lpAmtX18, scale8), f1(inAmAssetAmtX18, amtDcm), f1(inPrAssetAmtX18, priceDcm), cpbi((prBalanceX18 + inPrAssetAmtX18), (amBalanceX18 + inAmAssetAmtX18)), slippageX18)
507 503                      }
508 504                  else throw("Strict value is not equal to itself.")
509 505              }
510 506          else {
511 507              let curPriceX18 = cpbi(prBalanceX18, amBalanceX18)
512 508              let slippageRealX18 = fraction(abs((curPriceX18 - userPriceX18)), scale18, curPriceX18)
513 509              let slippageX18 = t1(slippage, scale8)
514 510              if (if (if (validateSlippage)
515 511                  then (curPriceX18 != zeroBigInt)
516 512                  else false)
517 513                  then (slippageRealX18 > slippageX18)
518 514                  else false)
519 515                  then throw(((("Price slippage " + toString(slippageRealX18)) + " > ") + toString(slippageX18)))
520 516                  else {
521 517                      let lpEmissionX18 = t1(lpEm, scale8)
522 518                      let prViaAmX18 = fraction(inAmAssetAmtX18, cpbir(prBalanceX18, amBalanceX18, CEILING), scale18, CEILING)
523 519                      let amViaPrX18 = fraction(inPrAssetAmtX18, scale18, cpbir(prBalanceX18, amBalanceX18, FLOOR), CEILING)
524 520                      let expectedAmts = if ((prViaAmX18 > inPrAssetAmtX18))
525 521                          then $Tuple2(amViaPrX18, inPrAssetAmtX18)
526 522                          else $Tuple2(inAmAssetAmtX18, prViaAmX18)
527 523                      let expAmtAssetAmtX18 = expectedAmts._1
528 524                      let expPriceAssetAmtX18 = expectedAmts._2
529 525                      let D1 = getD([(amBalanceX18 + expAmtAssetAmtX18), (prBalanceX18 + expPriceAssetAmtX18)])
530 526                      let checkD = if ((D1 > D0))
531 527                          then true
532 528                          else throw("D1 should be greater than D0")
533 529                      if ((checkD == checkD))
534 530                          then {
535 531                              let lpAmtX18 = fraction(lpEmissionX18, (D1 - D0), D0)
536 532                              $Tuple5(fromX18Round(lpAmtX18, scale8, FLOOR), fromX18Round(expAmtAssetAmtX18, amtDcm, CEILING), fromX18Round(expPriceAssetAmtX18, priceDcm, CEILING), curPriceX18, slippageX18)
537 533                              }
538 534                          else throw("Strict value is not equal to itself.")
539 535                      }
540 536              }
541 537      let calcLpAmt = r._1
542 538      let calcAmAssetPmt = r._2
543 539      let calcPrAssetPmt = r._3
544 540      let curPrice = f1(r._4, scale8)
545 541      let slippageCalc = f1(r._5, scale8)
546 542      if ((0 >= calcLpAmt))
547 543          then throw("LP <= 0")
548 544          else {
549 545              let emitLpAmt = if (!(emitLp))
550 546                  then 0
551 547                  else calcLpAmt
552 548              let amDiff = (inAmAmt - calcAmAssetPmt)
553 549              let prDiff = (inPrAmt - calcPrAssetPmt)
554 -             let $t02130721652 = if (if (isOneAsset)
550 +             let $t02110921454 = if (if (isOneAsset)
555 551                  then (pmtId == amIdStr)
556 552                  else false)
557 553                  then $Tuple2(pmtAmt, 0)
558 554                  else if (if (isOneAsset)
559 555                      then (pmtId == prIdStr)
560 556                      else false)
561 557                      then $Tuple2(0, pmtAmt)
562 558                      else $Tuple2(calcAmAssetPmt, calcPrAssetPmt)
563 -             let writeAmAmt = $t02130721652._1
564 -             let writePrAmt = $t02130721652._2
559 +             let writeAmAmt = $t02110921454._1
560 +             let writePrAmt = $t02110921454._2
565 561              let commonState = [IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice), StringEntry(pau(userAddress, txId58), dataPutActionInfo(writeAmAmt, writePrAmt, emitLpAmt, curPrice, slippage, slippageCalc, height, lastBlock.timestamp, amDiff, prDiff))]
566 562              $Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEm, lpId, sts, commonState, amDiff, prDiff, inAmId, inPrId)
567 563              }
568 564      }
569 565  
570 566  
571 567  func getYD (xp,i,D) = {
572 568      let n = big2
573 569      let x = xp[if ((i == 0))
574 570          then 1
575 571          else 0]
576 572      let aPrecision = parseBigIntValue(Amult)
577 573      let a = (parseBigIntValue(A) * aPrecision)
578 574      let s = x
579 575      let ann = (a * n)
580 576      let c = (((((D * D) / (x * n)) * D) * aPrecision) / (ann * n))
581 577      let b = ((s + ((D * aPrecision) / ann)) - D)
582 578      func calc (acc,cur) =     {
583 -         let $t02284722867 = acc
584 -         let y = $t02284722867._1
585 -         let found = $t02284722867._2
579 +         let $t02264922669 = acc
580 +         let y = $t02264922669._1
581 +         let found = $t02264922669._2
586 582          if ((found != unit))
587 583              then acc
588 584              else {
589 585                  let yNext = (((y * y) + c) / ((big2 * y) + b))
590 586                  let yDiff = absBigInt((yNext - value(y)))
591 587                  if ((big1 >= yDiff))
592 588                      then $Tuple2(yNext, cur)
593 589                      else $Tuple2(yNext, unit)
594 590                  }
595 591          }
596 592  
597 593      let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
598 -     let $t02317423221 = {
594 +     let $t02297623023 = {
599 595          let $l = arr
600 596          let $s = size($l)
601 597          let $acc0 = $Tuple2(D, unit)
602 598          func $f0_1 ($a,$i) =         if (($i >= $s))
603 599              then $a
604 600              else calc($a, $l[$i])
605 601  
606 602          func $f0_2 ($a,$i) =         if (($i >= $s))
607 603              then $a
608 604              else throw("List size exceeds 15")
609 605  
610 606          $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
611 607          }
612 -     let y = $t02317423221._1
613 -     let found = $t02317423221._2
608 +     let y = $t02297623023._1
609 +     let found = $t02297623023._2
614 610      if ((found != unit))
615 611          then y
616 612          else throw(("Y calculation error, Y = " + toString(y)))
617 613      }
618 614  
619 615  
620 616  func calcDLp (amountBalance,priceBalance,lpEmission) = {
621 617      let updatedDLp = fraction(getD([t1BigInt(amountBalance, toBigInt(cfgAmountAssetDecimals)), t1BigInt(priceBalance, toBigInt(cfgPriceAssetDecimals))]), scale18, lpEmission)
622 618      if ((lpEmission == big0))
623 619          then big0
624 620          else updatedDLp
625 621      }
626 622  
627 623  
628 624  func calcCurrentDLp (amountAssetDelta,priceAssetDelta,lpAssetEmissionDelta) = {
629 625      let amountAssetBalance = (toBigInt(getAccBalance(assetIdToString(cfgAmountAssetId))) - amountAssetDelta)
630 626      let priceAssetBalance = (toBigInt(getAccBalance(assetIdToString(cfgPriceAssetId))) - priceAssetDelta)
631 627      let lpAssetEmission = (toBigInt(value(assetInfo(cfgLpAssetId)).quantity) - lpAssetEmissionDelta)
632 628      let currentDLp = calcDLp(amountAssetBalance, priceAssetBalance, lpAssetEmission)
633 629      currentDLp
634 630      }
635 631  
636 632  
637 633  func refreshDLpInternal (amountAssetBalanceDelta,priceAssetBalanceDelta,lpAssetEmissionDelta) = {
638 634      let amountAssetBalance = (getAccBalance(assetIdToString(cfgAmountAssetId)) + amountAssetBalanceDelta)
639 635      let priceAssetBalance = (getAccBalance(assetIdToString(cfgPriceAssetId)) + priceAssetBalanceDelta)
640 636      let lpAssetEmission = (value(assetInfo(cfgLpAssetId)).quantity + lpAssetEmissionDelta)
641 637      let updatedDLp = calcDLp(toBigInt(amountAssetBalance), toBigInt(priceAssetBalance), toBigInt(lpAssetEmission))
642 638      let actions = [IntegerEntry(keyDLpRefreshedHeight, height), StringEntry(keyDLp, toString(updatedDLp))]
643 639      $Tuple2(actions, updatedDLp)
644 640      }
645 641  
646 642  
647 643  func validateUpdatedDLp (oldDLp,updatedDLp) = if ((updatedDLp >= oldDLp))
648 644      then true
649 645      else throwErr("updated DLp lower than current DLp")
650 646  
651 647  
652 648  func validateMatcherOrderAllowed (order) = {
653 649      let amountAssetBalance = getAccBalance(assetIdToString(cfgAmountAssetId))
654 650      let priceAssetBalance = getAccBalance(assetIdToString(cfgPriceAssetId))
655 651      let amountAssetAmount = order.amount
656 652      let priceAssetAmount = fraction(order.amount, order.price, scale8, FLOOR)
657 -     let $t02541925631 = if ((order.orderType == Buy))
653 +     let $t02522125433 = if ((order.orderType == Buy))
658 654          then $Tuple2(amountAssetAmount, -(priceAssetAmount))
659 655          else $Tuple2(-(amountAssetAmount), priceAssetAmount)
660 -     let amountAssetBalanceDelta = $t02541925631._1
661 -     let priceAssetBalanceDelta = $t02541925631._2
656 +     let amountAssetBalanceDelta = $t02522125433._1
657 +     let priceAssetBalanceDelta = $t02522125433._2
662 658      if (if (if (igs())
663 659          then true
664 660          else (cfgPoolStatus == PoolMatcherDis))
665 661          then true
666 662          else (cfgPoolStatus == PoolShutdown))
667 663          then throw("Admin blocked")
668 664          else if (if ((order.assetPair.amountAsset != cfgAmountAssetId))
669 665              then true
670 666              else (order.assetPair.priceAsset != cfgPriceAssetId))
671 667              then throw("Wr assets")
672 668              else {
673 669                  let dLp = parseBigIntValue(valueOrElse(getString(this, keyDLp), "0"))
674 -                 let $t02597326073 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
675 -                 let unusedActions = $t02597326073._1
676 -                 let dLpNew = $t02597326073._2
670 +                 let $t02577525875 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
671 +                 let unusedActions = $t02577525875._1
672 +                 let dLpNew = $t02577525875._2
677 673                  let isOrderValid = (dLpNew >= dLp)
678 674                  let info = makeString(["dLp=", toString(dLp), " dLpNew=", toString(dLpNew), " amountAssetBalance=", toString(amountAssetBalance), " priceAssetBalance=", toString(priceAssetBalance), " amountAssetBalanceDelta=", toString(amountAssetBalanceDelta), " priceAssetBalanceDelta=", toString(priceAssetBalanceDelta), " height=", toString(height)], "")
679 675                  $Tuple2(isOrderValid, info)
680 676                  }
681 677      }
682 678  
683 679  
684 680  func cg (i) = if ((size(i.payments) != 1))
685 681      then throw("1 pmnt exp")
686 682      else {
687 683          let pmt = value(i.payments[0])
688 684          let pmtAssetId = value(pmt.assetId)
689 685          let pmtAmt = pmt.amount
690 686          let r = ego(toBase58String(i.transactionId), toBase58String(pmtAssetId), pmtAmt, i.caller)
691 687          let outAmAmt = r._1
692 688          let outPrAmt = r._2
693 689          let sts = parseIntValue(r._9)
694 690          let state = r._10
695 691          if (if (igs())
696 692              then true
697 693              else (sts == PoolShutdown))
698 694              then throw(("Admin blocked: " + toString(sts)))
699 695              else $Tuple5(outAmAmt, outPrAmt, pmtAmt, pmtAssetId, state)
700 696          }
701 697  
702 698  
703 699  func cp (caller,txId,amAsPmt,prAsPmt,slippage,emitLp,isOneAsset,validateSlippage,pmtAmt,pmtId) = {
704 700      let r = epo(txId, slippage, value(amAsPmt).amount, value(amAsPmt).assetId, value(prAsPmt).amount, value(prAsPmt).assetId, caller, (txId == ""), emitLp, isOneAsset, validateSlippage, pmtAmt, pmtId)
705 701      let sts = parseIntValue(r._8)
706 702      if (if (if (igs())
707 703          then true
708 704          else (sts == PoolPutDis))
709 705          then true
710 706          else (sts == PoolShutdown))
711 707          then throw(("Blocked:" + toString(sts)))
712 708          else r
713 709      }
714 710  
715 711  
716 712  func calcPutOneTkn (pmtAmtRaw,pmtAssetId,userAddress,txId,withTakeFee) = {
717 713      let amId = toBase58String(value(cfgAmountAssetId))
718 714      let prId = toBase58String(value(cfgPriceAssetId))
719 715      let lpId = cfgLpAssetId
720 716      let amtDcm = cfgAmountAssetDecimals
721 717      let priceDcm = cfgPriceAssetDecimals
722 718      let lpAssetEmission = toBigInt(valueOrErrorMessage(assetInfo(lpId), "invalid lp asset").quantity)
723 719      let chechEmission = if ((lpAssetEmission > big0))
724 720          then true
725 721          else throw("initial deposit requires all coins")
726 722      if ((chechEmission == chechEmission))
727 723          then {
728 724              let amBalance = getAccBalance(amId)
729 725              let prBalance = getAccBalance(prId)
730 -             let $t02872929191 = if ((txId == ""))
726 +             let $t02853128993 = if ((txId == ""))
731 727                  then $Tuple2(amBalance, prBalance)
732 728                  else if ((pmtAssetId == amId))
733 729                      then if ((pmtAmtRaw > amBalance))
734 730                          then throw("invalid payment amount")
735 731                          else $Tuple2((amBalance - pmtAmtRaw), prBalance)
736 732                      else if ((pmtAssetId == prId))
737 733                          then if ((pmtAmtRaw > prBalance))
738 734                              then throw("invalid payment amount")
739 735                              else $Tuple2(amBalance, (prBalance - pmtAmtRaw))
740 736                          else throw("wrong pmtAssetId")
741 -             let amBalanceOld = $t02872929191._1
742 -             let prBalanceOld = $t02872929191._2
743 -             let $t02919729373 = if ((pmtAssetId == amId))
737 +             let amBalanceOld = $t02853128993._1
738 +             let prBalanceOld = $t02853128993._2
739 +             let $t02899929175 = if ((pmtAssetId == amId))
744 740                  then $Tuple2(pmtAmtRaw, 0)
745 741                  else if ((pmtAssetId == prId))
746 742                      then $Tuple2(0, pmtAmtRaw)
747 743                      else throw("invalid payment")
748 -             let amAmountRaw = $t02919729373._1
749 -             let prAmountRaw = $t02919729373._2
750 -             let $t02937729631 = if (withTakeFee)
744 +             let amAmountRaw = $t02899929175._1
745 +             let prAmountRaw = $t02899929175._2
746 +             let $t02917929433 = if (withTakeFee)
751 747                  then $Tuple3(takeFee(amAmountRaw, inFee)._1, takeFee(prAmountRaw, inFee)._1, takeFee(pmtAmtRaw, inFee)._2)
752 748                  else $Tuple3(amAmountRaw, prAmountRaw, 0)
753 -             let amAmount = $t02937729631._1
754 -             let prAmount = $t02937729631._2
755 -             let feeAmount = $t02937729631._3
749 +             let amAmount = $t02917929433._1
750 +             let prAmount = $t02917929433._2
751 +             let feeAmount = $t02917929433._3
756 752              let amBalanceNew = (amBalanceOld + amAmount)
757 753              let prBalanceNew = (prBalanceOld + prAmount)
758 754              let D0 = getD([t1(amBalanceOld, cfgAmountAssetDecimals), t1(prBalanceOld, cfgPriceAssetDecimals)])
759 755              let D1 = getD([t1(amBalanceNew, cfgAmountAssetDecimals), t1(prBalanceNew, cfgPriceAssetDecimals)])
760 756              let checkD = if ((D1 > D0))
761 757                  then true
762 758                  else throw()
763 759              if ((checkD == checkD))
764 760                  then {
765 761                      let lpAmount = fraction(lpAssetEmission, (D1 - D0), D0, FLOOR)
766 762                      let curPrice = f1(cpbi(t1(prBalanceNew, priceDcm), t1(amBalanceNew, amtDcm)), scale8)
767 763                      let commonState = [IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice), StringEntry(pau(userAddress, txId), dataPutActionInfo(amAmountRaw, prAmountRaw, toInt(lpAmount), curPrice, 0, 0, height, lastBlock.timestamp, 0, 0))]
768 764                      let poolProportion = fraction(prBalanceOld, scale8, amBalanceOld)
769 765                      let amountAssetPart = fraction(pmtAmtRaw, scale8, (poolProportion + scale8))
770 766                      let priceAssetPart = (pmtAmtRaw - amountAssetPart)
771 767                      let lpAmtBoth = fraction(lpAssetEmission, toBigInt(priceAssetPart), toBigInt(prBalanceOld))
772 768                      let bonus = toInt(fraction((lpAmount - lpAmtBoth), scale8BigInt, lpAmtBoth))
773 769                      $Tuple4(toInt(lpAmount), commonState, feeAmount, bonus)
774 770                      }
775 771                  else throw("Strict value is not equal to itself.")
776 772              }
777 773          else throw("Strict value is not equal to itself.")
778 774      }
779 775  
780 776  
781 777  func getOneTknV2Internal (outAssetId,minOutAmount,payments,caller,originCaller,transactionId) = {
782 778      let lpId = toBase58String(value(cfgLpAssetId))
783 779      let amId = toBase58String(value(cfgAmountAssetId))
784 780      let prId = toBase58String(value(cfgPriceAssetId))
785 781      let amDecimals = cfgAmountAssetDecimals
786 782      let prDecimals = cfgPriceAssetDecimals
787 783      let poolStatus = cfgPoolStatus
788 784      let userAddress = if ((caller == restContract))
789 785          then originCaller
790 786          else caller
791 787      let pmt = value(payments[0])
792 788      let pmtAssetId = value(pmt.assetId)
793 789      let pmtAmt = pmt.amount
794 790      let currentDLp = calcCurrentDLp(big0, big0, big0)
795 791      if ((currentDLp == currentDLp))
796 792          then {
797 793              let txId58 = toBase58String(transactionId)
798 794              if ((lpId != toBase58String(pmtAssetId)))
799 795                  then throw("Wrong LP")
800 796                  else {
801 797                      let amBalance = getAccBalance(amId)
802 798                      let prBalance = getAccBalance(prId)
803 -                     let $t03174331854 = {
799 +                     let $t03154531656 = {
804 800                          let @ = invoke(this, "getOneTknV2READONLY", [outAssetId, pmtAmt], nil)
805 801                          if ($isInstanceOf(@, "(Int, Int)"))
806 802                              then @
807 803                              else throw(($getType(@) + " couldn't be cast to (Int, Int)"))
808 804                          }
809 -                     if (($t03174331854 == $t03174331854))
805 +                     if (($t03154531656 == $t03154531656))
810 806                          then {
811 -                             let feeAmount = $t03174331854._2
812 -                             let totalGet = $t03174331854._1
807 +                             let feeAmount = $t03154531656._2
808 +                             let totalGet = $t03154531656._1
813 809                              let totalAmount = if (if ((minOutAmount > 0))
814 810                                  then (minOutAmount > totalGet)
815 811                                  else false)
816 812                                  then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
817 813                                  else totalGet
818 -                             let $t03204432351 = if ((outAssetId == amId))
814 +                             let $t03184632153 = if ((outAssetId == amId))
819 815                                  then $Tuple4(totalAmount, 0, ((amBalance - totalAmount) - feeAmount), prBalance)
820 816                                  else if ((outAssetId == prId))
821 817                                      then $Tuple4(0, totalAmount, amBalance, ((prBalance - totalAmount) - feeAmount))
822 818                                      else throw("invalid out asset id")
823 -                             let outAm = $t03204432351._1
824 -                             let outPr = $t03204432351._2
825 -                             let amBalanceNew = $t03204432351._3
826 -                             let prBalanceNew = $t03204432351._4
819 +                             let outAm = $t03184632153._1
820 +                             let outPr = $t03184632153._2
821 +                             let amBalanceNew = $t03184632153._3
822 +                             let prBalanceNew = $t03184632153._4
827 823                              let curPrX18 = cpbi(t1(prBalanceNew, prDecimals), t1(amBalanceNew, amDecimals))
828 824                              let curPr = f1(curPrX18, scale8)
829 825                              let outAssetIdOrWaves = if ((outAssetId == "WAVES"))
830 826                                  then unit
831 827                                  else fromBase58String(outAssetId)
832 828                              let sendFeeToMatcher = if ((feeAmount > 0))
833 829                                  then [ScriptTransfer(feeCollectorAddress, feeAmount, outAssetIdOrWaves)]
834 830                                  else nil
835 831                              let state = ([ScriptTransfer(userAddress, totalAmount, outAssetIdOrWaves), StringEntry(gau(toString(userAddress), txId58), dataGetActionInfo(outAm, outPr, pmtAmt, curPr, height, lastBlock.timestamp)), IntegerEntry(pl(), curPr), IntegerEntry(ph(height, lastBlock.timestamp), curPr)] ++ sendFeeToMatcher)
836 832                              if ((state == state))
837 833                                  then {
838 834                                      let burn = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
839 835                                      if ((burn == burn))
840 836                                          then {
841 -                                             let $t03313633486 = {
837 +                                             let $t03293833288 = {
842 838                                                  let feeAmountForCalc = if ((this == feeCollectorAddress))
843 839                                                      then 0
844 840                                                      else feeAmount
845 841                                                  let outInAmountAsset = if ((parseAssetId(outAssetId) == cfgAmountAssetId))
846 842                                                      then true
847 843                                                      else false
848 844                                                  if (outInAmountAsset)
849 845                                                      then $Tuple2(-((totalGet + feeAmountForCalc)), 0)
850 846                                                      else $Tuple2(0, -((totalGet + feeAmountForCalc)))
851 847                                                  }
852 -                                             let amountAssetBalanceDelta = $t03313633486._1
853 -                                             let priceAssetBalanceDelta = $t03313633486._2
854 -                                             let $t03348933597 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
855 -                                             let refreshDLpActions = $t03348933597._1
856 -                                             let updatedDLp = $t03348933597._2
848 +                                             let amountAssetBalanceDelta = $t03293833288._1
849 +                                             let priceAssetBalanceDelta = $t03293833288._2
850 +                                             let $t03329133399 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
851 +                                             let refreshDLpActions = $t03329133399._1
852 +                                             let updatedDLp = $t03329133399._2
857 853                                              let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
858 854                                              if ((isUpdatedDLpValid == isUpdatedDLpValid))
859 855                                                  then $Tuple2((state ++ refreshDLpActions), totalAmount)
860 856                                                  else throw("Strict value is not equal to itself.")
861 857                                              }
862 858                                          else throw("Strict value is not equal to itself.")
863 859                                      }
864 860                                  else throw("Strict value is not equal to itself.")
865 861                              }
866 862                          else throw("Strict value is not equal to itself.")
867 863                      }
868 864              }
869 865          else throw("Strict value is not equal to itself.")
870 866      }
871 867  
872 868  
873 869  func managerPublicKeyOrUnit () = {
874 870      let managerVaultAddress = getManagerVaultAddressOrThis()
875 871      match getString(managerVaultAddress, keyManagerPublicKey()) {
876 872          case s: String => 
877 873              fromBase58String(s)
878 874          case _: Unit => 
879 875              unit
880 876          case _ => 
881 877              throw("Match error")
882 878      }
883 879      }
884 880  
885 881  
886 882  let pd = throw("Permission denied")
887 883  
888 884  func isManager (i) = match managerPublicKeyOrUnit() {
889 885      case pk: ByteVector => 
890 886          (i.callerPublicKey == pk)
891 887      case _: Unit => 
892 888          (i.caller == this)
893 889      case _ => 
894 890          throw("Match error")
895 891  }
896 892  
897 893  
898 894  func mustManager (i) = match managerPublicKeyOrUnit() {
899 895      case pk: ByteVector => 
900 896          if ((i.callerPublicKey == pk))
901 897              then true
902 898              else pd
903 899      case _: Unit => 
904 900          if ((i.caller == this))
905 901              then true
906 902              else pd
907 903      case _ => 
908 904          throw("Match error")
909 905  }
910 906  
911 907  
912 908  func getY (isReverse,D,poolAmountInBalance) = {
913 909      let poolConfig = gpc()
914 910      let amId = poolConfig[idxAmAsId]
915 911      let prId = poolConfig[idxPrAsId]
916 912      let n = big2
917 913      let aPrecision = parseBigIntValue(Amult)
918 914      let a = (parseBigIntValue(A) * aPrecision)
919 915      let xp = if ((isReverse == false))
920 916          then [(toBigInt(getAccBalance(amId)) + poolAmountInBalance), toBigInt(getAccBalance(prId))]
921 917          else [(toBigInt(getAccBalance(prId)) + poolAmountInBalance), toBigInt(getAccBalance(amId))]
922 918      let x = xp[0]
923 919      let s = x
924 920      let ann = (a * n)
925 921      let c = (((((D * D) / (x * n)) * D) * aPrecision) / (ann * n))
926 922      let b = ((s + ((D * aPrecision) / ann)) - D)
927 923      func calc (acc,cur) =     {
928 -         let $t03508435104 = acc
929 -         let y = $t03508435104._1
930 -         let found = $t03508435104._2
924 +         let $t03488634906 = acc
925 +         let y = $t03488634906._1
926 +         let found = $t03488634906._2
931 927          if ((found != unit))
932 928              then acc
933 929              else {
934 930                  let yNext = (((y * y) + c) / ((big2 * y) + b))
935 931                  let yDiff = absBigInt((yNext - value(y)))
936 932                  if ((big1 >= yDiff))
937 933                      then $Tuple2(yNext, cur)
938 934                      else $Tuple2(yNext, unit)
939 935                  }
940 936          }
941 937  
942 938      let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
943 -     let $t03543535482 = {
939 +     let $t03523735284 = {
944 940          let $l = arr
945 941          let $s = size($l)
946 942          let $acc0 = $Tuple2(D, unit)
947 943          func $f0_1 ($a,$i) =         if (($i >= $s))
948 944              then $a
949 945              else calc($a, $l[$i])
950 946  
951 947          func $f0_2 ($a,$i) =         if (($i >= $s))
952 948              then $a
953 949              else throw("List size exceeds 15")
954 950  
955 951          $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
956 952          }
957 -     let y = $t03543535482._1
958 -     let found = $t03543535482._2
953 +     let y = $t03523735284._1
954 +     let found = $t03523735284._2
959 955      if ((found != unit))
960 956          then y
961 957          else throw(("Y calculation error, Y = " + toString(y)))
962 958      }
963 959  
964 960  
965 961  func skipOrderValidation () = valueOrElse(getBoolean(fca, keySkipOrderValidation(toString(this))), false)
966 962  
967 963  
968 964  @Callable(i)
969 965  func calculateAmountOutForSwapREADONLY (cleanAmountIn,isReverse,feePoolAmount) = {
970 -     let $t03583436258 = if ((isReverse == false))
966 +     let $t03563636060 = if ((isReverse == false))
971 967          then {
972 968              let assetOut = strf(this, pa())
973 969              let poolAmountInBalance = (toBigInt(getAccBalance(strf(this, aa()))) + toBigInt(cleanAmountIn))
974 970              $Tuple2(assetOut, poolAmountInBalance)
975 971              }
976 972          else {
977 973              let assetOut = strf(this, aa())
978 974              let poolAmountInBalance = (toBigInt(getAccBalance(strf(this, pa()))) + toBigInt(cleanAmountIn))
979 975              $Tuple2(assetOut, poolAmountInBalance)
980 976              }
981 -     let assetOut = $t03583436258._1
982 -     let poolAmountInBalance = $t03583436258._2
977 +     let assetOut = $t03563636060._1
978 +     let poolAmountInBalance = $t03563636060._2
983 979      let poolConfig = gpc()
984 980      let amId = poolConfig[idxAmAsId]
985 981      let prId = poolConfig[idxPrAsId]
986 982      let xp = [toBigInt(getAccBalance(amId)), toBigInt(getAccBalance(prId))]
987 983      let D = getD(xp)
988 984      let y = getY(isReverse, D, toBigInt(cleanAmountIn))
989 985      let dy = ((toBigInt(getAccBalance(assetOut)) - y) - toBigInt(1))
990 986      let totalGetRaw = max([0, toInt(dy)])
991 987      let newXp = if ((isReverse == false))
992 988          then [((toBigInt(getAccBalance(amId)) + toBigInt(cleanAmountIn)) + toBigInt(feePoolAmount)), (toBigInt(getAccBalance(prId)) - dy)]
993 989          else [(toBigInt(getAccBalance(amId)) - dy), ((toBigInt(getAccBalance(prId)) + toBigInt(cleanAmountIn)) + toBigInt(feePoolAmount))]
994 990      let newD = getD(newXp)
995 991      let checkD = if ((newD >= D))
996 992          then true
997 993          else throw(makeString(["new D is fewer error", toString(D), toString(newD)], "__"))
998 994      if ((checkD == checkD))
999 995          then $Tuple2(nil, totalGetRaw)
1000 996          else throw("Strict value is not equal to itself.")
1001 997      }
1002 998  
1003 999  
1004 1000  
1005 1001  @Callable(i)
1006 1002  func calculateAmountOutForSwapAndSendTokens (cleanAmountIn,isReverse,amountOutMin,addressTo,feePoolAmount) = {
1007 1003      let swapContact = {
1008 1004          let @ = invoke(fca, "getSwapContractREADONLY", nil, nil)
1009 1005          if ($isInstanceOf(@, "String"))
1010 1006              then @
1011 1007              else throw(($getType(@) + " couldn't be cast to String"))
1012 1008          }
1013 1009      let checks = [if ((value(i.payments[0]).amount >= cleanAmountIn))
1014 1010          then true
1015 1011          else throwErr("Wrong amount"), if ((i.caller == addressFromStringValue(swapContact)))
1016 1012          then true
1017 1013          else throwErr("Permission denied")]
1018 1014      if ((checks == checks))
1019 1015          then {
1020 1016              let pmt = value(i.payments[0])
1021 1017              let assetIn = assetIdToString(pmt.assetId)
1022 -             let $t03769438088 = if ((isReverse == false))
1018 +             let $t03749637890 = if ((isReverse == false))
1023 1019                  then {
1024 1020                      let assetOut = strf(this, pa())
1025 1021                      let poolAmountInBalance = (getAccBalance(assetIn) - value(i.payments[0]).amount)
1026 1022                      $Tuple2(assetOut, poolAmountInBalance)
1027 1023                      }
1028 1024                  else {
1029 1025                      let assetOut = strf(this, aa())
1030 1026                      let poolAmountInBalance = (getAccBalance(assetIn) - value(i.payments[0]).amount)
1031 1027                      $Tuple2(assetOut, poolAmountInBalance)
1032 1028                      }
1033 -             let assetOut = $t03769438088._1
1034 -             let poolAmountInBalance = $t03769438088._2
1029 +             let assetOut = $t03749637890._1
1030 +             let poolAmountInBalance = $t03749637890._2
1035 1031              let poolConfig = gpc()
1036 1032              let amId = poolConfig[idxAmAsId]
1037 1033              let prId = poolConfig[idxPrAsId]
1038 1034              let xp = if ((isReverse == false))
1039 1035                  then [(toBigInt(getAccBalance(amId)) - toBigInt(value(i.payments[0]).amount)), toBigInt(getAccBalance(prId))]
1040 1036                  else [toBigInt(getAccBalance(amId)), (toBigInt(getAccBalance(prId)) - toBigInt(value(i.payments[0]).amount))]
1041 1037              let D = getD(xp)
1042 1038              let y = getY(isReverse, D, toBigInt(0))
1043 1039              let dy = ((toBigInt(getAccBalance(assetOut)) - y) - toBigInt(1))
1044 1040              let totalGetRaw = max([0, toInt(dy)])
1045 1041              let checkMin = if ((totalGetRaw >= amountOutMin))
1046 1042                  then true
1047 1043                  else throw("Exchange result is fewer coins than expected")
1048 1044              if ((checkMin == checkMin))
1049 1045                  then {
1050 1046                      let newXp = if ((isReverse == false))
1051 1047                          then [(toBigInt(getAccBalance(amId)) + toBigInt(feePoolAmount)), (toBigInt(getAccBalance(prId)) - dy)]
1052 1048                          else [(toBigInt(getAccBalance(amId)) - dy), (toBigInt(getAccBalance(prId)) + toBigInt(feePoolAmount))]
1053 1049                      let newD = getD(newXp)
1054 1050                      let checkD = if ((newD >= D))
1055 1051                          then true
1056 1052                          else throw("new D is fewer error")
1057 1053                      if ((checkD == checkD))
1058 1054                          then $Tuple2([ScriptTransfer(addressFromStringValue(addressTo), totalGetRaw, parseAssetId(assetOut))], totalGetRaw)
1059 1055                          else throw("Strict value is not equal to itself.")
1060 1056                      }
1061 1057                  else throw("Strict value is not equal to itself.")
1062 1058              }
1063 1059          else throw("Strict value is not equal to itself.")
1064 1060      }
1065 1061  
1066 1062  
1067 1063  
1068 1064  @Callable(i)
1069 1065  func constructor (fc) = {
1070 1066      let c = mustManager(i)
1071 1067      if ((c == c))
1072 1068          then [StringEntry(fc(), fc)]
1073 1069          else throw("Strict value is not equal to itself.")
1074 1070      }
1075 1071  
1076 1072  
1077 1073  
1078 1074  @Callable(i)
1079 1075  func put (slip,autoStake) = {
1080 1076      let factCfg = gfc()
1081 1077      let stakingCntr = valueOrErrorMessage(addressFromString(factCfg[idxFactStakCntr]), "Wr st addr")
1082 1078      let slipCntr = valueOrErrorMessage(addressFromString(factCfg[idxFactSlippCntr]), "Wr sl addr")
1083 1079      if ((0 > slip))
1084 1080          then throw("Wrong slippage")
1085 1081          else if ((size(i.payments) != 2))
1086 1082              then throw("2 pmnts expd")
1087 1083              else {
1088 1084                  let amAssetPmt = toBigInt(value(i.payments[0]).amount)
1089 1085                  let prAssetPmt = toBigInt(value(i.payments[1]).amount)
1090 1086                  let amountAssetBalance = (toBigInt(getAccBalance(assetIdToString(cfgAmountAssetId))) - amAssetPmt)
1091 1087                  if ((amountAssetBalance == amountAssetBalance))
1092 1088                      then {
1093 1089                          let priceAssetBalance = (toBigInt(getAccBalance(assetIdToString(cfgPriceAssetId))) - prAssetPmt)
1094 1090                          if ((priceAssetBalance == priceAssetBalance))
1095 1091                              then {
1096 1092                                  let lpAssetEmission = toBigInt(value(assetInfo(cfgLpAssetId)).quantity)
1097 1093                                  if ((lpAssetEmission == lpAssetEmission))
1098 1094                                      then {
1099 1095                                          let currentDLp = calcCurrentDLp(amAssetPmt, prAssetPmt, toBigInt(0))
1100 1096                                          if ((currentDLp == currentDLp))
1101 1097                                              then {
1102 1098                                                  let e = cp(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(value(i.payments[0]).assetId, value(i.payments[0]).amount), i.payments[1], slip, true, false, true, 0, "")
1103 1099                                                  let emitLpAmt = e._2
1104 1100                                                  let lpAssetId = e._7
1105 1101                                                  let state = e._9
1106 1102                                                  let amDiff = e._10
1107 1103                                                  let prDiff = e._11
1108 1104                                                  let amId = e._12
1109 1105                                                  let prId = e._13
1110 1106                                                  let r = invoke(fca, "emit", [emitLpAmt], nil)
1111 1107                                                  if ((r == r))
1112 1108                                                      then {
1113 1109                                                          let el =                                                         match r {
1114 1110                                                              case legacy: Address => 
1115 1111                                                                  invoke(legacy, "emit", [emitLpAmt], nil)
1116 1112                                                              case _ => 
1117 1113                                                                  unit
1118 1114                                                          }
1119 1115                                                          if ((el == el))
1120 1116                                                              then {
1121 1117                                                                  let sa = if ((amDiff > 0))
1122 1118                                                                      then invoke(slipCntr, "put", nil, [AttachedPayment(amId, amDiff)])
1123 1119                                                                      else nil
1124 1120                                                                  if ((sa == sa))
1125 1121                                                                      then {
1126 1122                                                                          let sp = if ((prDiff > 0))
1127 1123                                                                              then invoke(slipCntr, "put", nil, [AttachedPayment(prId, prDiff)])
1128 1124                                                                              else nil
1129 1125                                                                          if ((sp == sp))
1130 1126                                                                              then {
1131 1127                                                                                  let lpTrnsfr = if (autoStake)
1132 1128                                                                                      then {
1133 1129                                                                                          let ss = invoke(stakingCntr, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
1134 1130                                                                                          if ((ss == ss))
1135 1131                                                                                              then nil
1136 1132                                                                                              else throw("Strict value is not equal to itself.")
1137 1133                                                                                          }
1138 1134                                                                                      else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
1139 -                                                                                 let $t04223242374 = refreshDLpInternal(0, 0, 0)
1140 -                                                                                 let refreshDLpActions = $t04223242374._1
1141 -                                                                                 let updatedDLp = $t04223242374._2
1135 +                                                                                 let $t04203442176 = refreshDLpInternal(0, 0, 0)
1136 +                                                                                 let refreshDLpActions = $t04203442176._1
1137 +                                                                                 let updatedDLp = $t04203442176._2
1142 1138                                                                                  let check = if ((updatedDLp >= currentDLp))
1143 1139                                                                                      then true
1144 1140                                                                                      else throwErr(makeString(["updated DLp lower than current DLp", toString(amountAssetBalance), toString(priceAssetBalance), toString(lpAssetEmission), toString(currentDLp), toString(updatedDLp), toString(amDiff), toString(prDiff)], " "))
1145 1141                                                                                  if ((check == check))
1146 1142                                                                                      then {
1147 1143                                                                                          let lpAssetEmissionAfter = value(assetInfo(cfgLpAssetId)).quantity
1148 1144                                                                                          if ((lpAssetEmissionAfter == lpAssetEmissionAfter))
1149 1145                                                                                              then ((state ++ lpTrnsfr) ++ refreshDLpActions)
1150 1146                                                                                              else throw("Strict value is not equal to itself.")
1151 1147                                                                                          }
1152 1148                                                                                      else throw("Strict value is not equal to itself.")
1153 1149                                                                                  }
1154 1150                                                                              else throw("Strict value is not equal to itself.")
1155 1151                                                                          }
1156 1152                                                                      else throw("Strict value is not equal to itself.")
1157 1153                                                                  }
1158 1154                                                              else throw("Strict value is not equal to itself.")
1159 1155                                                          }
1160 1156                                                      else throw("Strict value is not equal to itself.")
1161 1157                                                  }
1162 1158                                              else throw("Strict value is not equal to itself.")
1163 1159                                          }
1164 1160                                      else throw("Strict value is not equal to itself.")
1165 1161                                  }
1166 1162                              else throw("Strict value is not equal to itself.")
1167 1163                          }
1168 1164                      else throw("Strict value is not equal to itself.")
1169 1165                  }
1170 1166      }
1171 1167  
1172 1168  
1173 1169  
1174 1170  @Callable(i)
1175 1171  func putOneTknV2 (minOutAmount,autoStake) = {
1176 1172      let isPoolOneTokenOperationsDisabled = {
1177 1173          let @ = invoke(fca, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1178 1174          if ($isInstanceOf(@, "Boolean"))
1179 1175              then @
1180 1176              else throw(($getType(@) + " couldn't be cast to Boolean"))
1181 1177          }
1182 1178      let isPutDisabled = if (if (if (igs())
1183 1179          then true
1184 1180          else (cfgPoolStatus == PoolPutDis))
1185 1181          then true
1186 1182          else (cfgPoolStatus == PoolShutdown))
1187 1183          then true
1188 1184          else isPoolOneTokenOperationsDisabled
1189 1185      let checks = [if (if (!(isPutDisabled))
1190 1186          then true
1191 1187          else isManager(i))
1192 1188          then true
1193 1189          else throwErr("put operation is blocked by admin"), if ((size(i.payments) == 1))
1194 1190          then true
1195 1191          else throwErr("exactly 1 payment are expected")]
1196 1192      if ((checks == checks))
1197 1193          then {
1198 1194              let amId = toBase58String(value(cfgAmountAssetId))
1199 1195              let prId = toBase58String(value(cfgPriceAssetId))
1200 1196              let lpId = cfgLpAssetId
1201 1197              let amDecimals = cfgAmountAssetDecimals
1202 1198              let prDecimals = cfgPriceAssetDecimals
1203 1199              let userAddress = if ((i.caller == this))
1204 1200                  then i.originCaller
1205 1201                  else i.caller
1206 1202              let pmt = value(i.payments[0])
1207 1203              let pmtAssetId = toBase58String(value(pmt.assetId))
1208 1204              let pmtAmt = pmt.amount
1209 1205              let currentDLp = if ((pmt.assetId == cfgAmountAssetId))
1210 1206                  then calcCurrentDLp(toBigInt(pmtAmt), toBigInt(0), toBigInt(0))
1211 1207                  else calcCurrentDLp(toBigInt(0), toBigInt(pmtAmt), toBigInt(0))
1212 1208              if ((currentDLp == currentDLp))
1213 1209                  then {
1214 -                     let $t04401544173 = calcPutOneTkn(pmtAmt, pmtAssetId, toString(userAddress), toBase58String(i.transactionId), true)
1215 -                     if (($t04401544173 == $t04401544173))
1210 +                     let $t04381743975 = calcPutOneTkn(pmtAmt, pmtAssetId, toString(userAddress), toBase58String(i.transactionId), true)
1211 +                     if (($t04381743975 == $t04381743975))
1216 1212                          then {
1217 -                             let feeAmount = $t04401544173._3
1218 -                             let state = $t04401544173._2
1219 -                             let estimLP = $t04401544173._1
1213 +                             let feeAmount = $t04381743975._3
1214 +                             let state = $t04381743975._2
1215 +                             let estimLP = $t04381743975._1
1220 1216                              let emitLpAmt = if (if ((minOutAmount > 0))
1221 1217                                  then (minOutAmount > estimLP)
1222 1218                                  else false)
1223 1219                                  then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
1224 1220                                  else estimLP
1225 1221                              let e = invoke(fca, "emit", [emitLpAmt], nil)
1226 1222                              if ((e == e))
1227 1223                                  then {
1228 1224                                      let el =                                     match e {
1229 1225                                          case legacy: Address => 
1230 1226                                              invoke(legacy, "emit", [emitLpAmt], nil)
1231 1227                                          case _ => 
1232 1228                                              unit
1233 1229                                      }
1234 1230                                      if ((el == el))
1235 1231                                          then {
1236 1232                                              let lpTrnsfr = if (autoStake)
1237 1233                                                  then {
1238 1234                                                      let ss = invoke(stakingContract, "stakeFor", [toString(i.caller)], [AttachedPayment(lpId, emitLpAmt)])
1239 1235                                                      if ((ss == ss))
1240 1236                                                          then nil
1241 1237                                                          else throw("Strict value is not equal to itself.")
1242 1238                                                      }
1243 1239                                                  else [ScriptTransfer(i.caller, emitLpAmt, lpId)]
1244 1240                                              let sendFeeToMatcher = if ((feeAmount > 0))
1245 1241                                                  then [ScriptTransfer(feeCollectorAddress, feeAmount, fromBase58String(pmtAssetId))]
1246 1242                                                  else nil
1247 -                                             let $t04505845407 = if ((this == feeCollectorAddress))
1243 +                                             let $t04486045209 = if ((this == feeCollectorAddress))
1248 1244                                                  then $Tuple2(0, 0)
1249 1245                                                  else {
1250 1246                                                      let paymentInAmountAsset = if ((pmt.assetId == cfgAmountAssetId))
1251 1247                                                          then true
1252 1248                                                          else false
1253 1249                                                      if (paymentInAmountAsset)
1254 1250                                                          then $Tuple2(-(feeAmount), 0)
1255 1251                                                          else $Tuple2(0, -(feeAmount))
1256 1252                                                      }
1257 -                                             let amountAssetBalanceDelta = $t04505845407._1
1258 -                                             let priceAssetBalanceDelta = $t04505845407._2
1259 -                                             let $t04541045518 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
1260 -                                             let refreshDLpActions = $t04541045518._1
1261 -                                             let updatedDLp = $t04541045518._2
1253 +                                             let amountAssetBalanceDelta = $t04486045209._1
1254 +                                             let priceAssetBalanceDelta = $t04486045209._2
1255 +                                             let $t04521245320 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
1256 +                                             let refreshDLpActions = $t04521245320._1
1257 +                                             let updatedDLp = $t04521245320._2
1262 1258                                              let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1263 1259                                              if ((isUpdatedDLpValid == isUpdatedDLpValid))
1264 1260                                                  then $Tuple2((((state ++ lpTrnsfr) ++ sendFeeToMatcher) ++ refreshDLpActions), emitLpAmt)
1265 1261                                                  else throw("Strict value is not equal to itself.")
1266 1262                                              }
1267 1263                                          else throw("Strict value is not equal to itself.")
1268 1264                                      }
1269 1265                                  else throw("Strict value is not equal to itself.")
1270 1266                              }
1271 1267                          else throw("Strict value is not equal to itself.")
1272 1268                      }
1273 1269                  else throw("Strict value is not equal to itself.")
1274 1270              }
1275 1271          else throw("Strict value is not equal to itself.")
1276 1272      }
1277 1273  
1278 1274  
1279 1275  
1280 1276  @Callable(i)
1281 1277  func putForFree (maxSlpg) = if ((0 > maxSlpg))
1282 1278      then throw("Wrong slpg")
1283 1279      else if ((size(i.payments) != 2))
1284 1280          then throw("2 pmnts expd")
1285 1281          else {
1286 1282              let estPut = cp(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(value(i.payments[0]).assetId, value(i.payments[0]).amount), i.payments[1], maxSlpg, false, false, true, 0, "")
1287 1283              let state = estPut._9
1288 1284              let amAssetPmt = toBigInt(value(i.payments[0]).amount)
1289 1285              let prAssetPmt = toBigInt(value(i.payments[1]).amount)
1290 1286              let currentDLp = calcCurrentDLp(amAssetPmt, prAssetPmt, toBigInt(0))
1291 1287              if ((currentDLp == currentDLp))
1292 1288                  then {
1293 -                     let $t04654846613 = refreshDLpInternal(0, 0, 0)
1294 -                     let refreshDLpActions = $t04654846613._1
1295 -                     let updatedDLp = $t04654846613._2
1289 +                     let $t04635046415 = refreshDLpInternal(0, 0, 0)
1290 +                     let refreshDLpActions = $t04635046415._1
1291 +                     let updatedDLp = $t04635046415._2
1296 1292                      let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1297 1293                      if ((isUpdatedDLpValid == isUpdatedDLpValid))
1298 1294                          then (state ++ refreshDLpActions)
1299 1295                          else throw("Strict value is not equal to itself.")
1300 1296                      }
1301 1297                  else throw("Strict value is not equal to itself.")
1302 1298              }
1303 1299  
1304 1300  
1305 1301  
1306 1302  @Callable(i)
1307 1303  func get () = {
1308 1304      let currentDLp = calcCurrentDLp(toBigInt(0), toBigInt(0), toBigInt(0))
1309 1305      if ((currentDLp == currentDLp))
1310 1306          then {
1311 1307              let r = cg(i)
1312 1308              let outAmtAmt = r._1
1313 1309              let outPrAmt = r._2
1314 1310              let pmtAmt = r._3
1315 1311              let pmtAssetId = r._4
1316 1312              let state = r._5
1317 1313              let b = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
1318 1314              if ((b == b))
1319 1315                  then {
1320 -                     let $t04778647868 = refreshDLpInternal(-(outAmtAmt), -(outPrAmt), 0)
1321 -                     let refreshDLpActions = $t04778647868._1
1322 -                     let updatedDLp = $t04778647868._2
1316 +                     let $t04758847670 = refreshDLpInternal(-(outAmtAmt), -(outPrAmt), 0)
1317 +                     let refreshDLpActions = $t04758847670._1
1318 +                     let updatedDLp = $t04758847670._2
1323 1319                      let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1324 1320                      if ((isUpdatedDLpValid == isUpdatedDLpValid))
1325 1321                          then (state ++ refreshDLpActions)
1326 1322                          else throw("Strict value is not equal to itself.")
1327 1323                      }
1328 1324                  else throw("Strict value is not equal to itself.")
1329 1325              }
1330 1326          else throw("Strict value is not equal to itself.")
1331 1327      }
1332 1328  
1333 1329  
1334 1330  
1335 1331  @Callable(i)
1336 1332  func getOneTknV2 (outAssetId,minOutAmount) = {
1337 1333      let isPoolOneTokenOperationsDisabled = {
1338 1334          let @ = invoke(fca, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1339 1335          if ($isInstanceOf(@, "Boolean"))
1340 1336              then @
1341 1337              else throw(($getType(@) + " couldn't be cast to Boolean"))
1342 1338          }
1343 1339      let isGetDisabled = if (if (igs())
1344 1340          then true
1345 1341          else (cfgPoolStatus == PoolShutdown))
1346 1342          then true
1347 1343          else isPoolOneTokenOperationsDisabled
1348 1344      let checks = [if (if (!(isGetDisabled))
1349 1345          then true
1350 1346          else isManager(i))
1351 1347          then true
1352 1348          else throwErr("get operation is blocked by admin"), if ((size(i.payments) == 1))
1353 1349          then true
1354 1350          else throwErr("exactly 1 payment are expected")]
1355 1351      if ((checks == checks))
1356 1352          then {
1357 -             let $t04848648641 = getOneTknV2Internal(outAssetId, minOutAmount, i.payments, i.caller, i.originCaller, i.transactionId)
1358 -             let state = $t04848648641._1
1359 -             let totalAmount = $t04848648641._2
1353 +             let $t04828848443 = getOneTknV2Internal(outAssetId, minOutAmount, i.payments, i.caller, i.originCaller, i.transactionId)
1354 +             let state = $t04828848443._1
1355 +             let totalAmount = $t04828848443._2
1360 1356              $Tuple2(state, totalAmount)
1361 1357              }
1362 1358          else throw("Strict value is not equal to itself.")
1363 1359      }
1364 1360  
1365 1361  
1366 1362  
1367 1363  @Callable(i)
1368 1364  func refreshDLp () = {
1369 1365      let lastRefreshedBlockHeight = valueOrElse(getInteger(keyDLpRefreshedHeight), 0)
1370 1366      let checkLastRefreshedBlockHeight = if (((height - lastRefreshedBlockHeight) >= dLpRefreshDelay))
1371 1367          then unit
1372 1368          else throwErr(makeString([toString(dLpRefreshDelay), " blocks have not passed since the previous call"], ""))
1373 1369      if ((checkLastRefreshedBlockHeight == checkLastRefreshedBlockHeight))
1374 1370          then {
1375 1371              let dLp = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, keyDLp), "0")), fmtErr("invalid dLp"))
1376 -             let $t04916549229 = refreshDLpInternal(0, 0, 0)
1377 -             let dLpUpdateActions = $t04916549229._1
1378 -             let updatedDLp = $t04916549229._2
1372 +             let $t04896749031 = refreshDLpInternal(0, 0, 0)
1373 +             let dLpUpdateActions = $t04896749031._1
1374 +             let updatedDLp = $t04896749031._2
1379 1375              let actions = if ((dLp != updatedDLp))
1380 1376                  then dLpUpdateActions
1381 1377                  else throwErr("nothing to refresh")
1382 1378              $Tuple2(actions, toString(updatedDLp))
1383 1379              }
1384 1380          else throw("Strict value is not equal to itself.")
1385 1381      }
1386 1382  
1387 1383  
1388 1384  
1389 1385  @Callable(i)
1390 1386  func getOneTknV2READONLY (outAssetId,lpAssetAmount) = {
1391 1387      let amId = toBase58String(value(cfgAmountAssetId))
1392 1388      let prId = toBase58String(value(cfgPriceAssetId))
1393 1389      let lpId = toBase58String(value(cfgLpAssetId))
1394 1390      let xp = [toBigInt(getAccBalance(amId)), toBigInt(getAccBalance(prId))]
1395 1391      let lpEmission = toBigInt(valueOrErrorMessage(assetInfo(fromBase58String(lpId)), "invalid lp asset").quantity)
1396 1392      let D0 = getD(xp)
1397 1393      let D1 = (D0 - fraction(toBigInt(lpAssetAmount), D0, lpEmission))
1398 1394      let index = if ((outAssetId == amId))
1399 1395          then 0
1400 1396          else if ((outAssetId == prId))
1401 1397              then 1
1402 1398              else throw("invalid out asset id")
1403 1399      let newY = getYD(xp, index, D1)
1404 1400      let dy = (xp[index] - newY)
1405 1401      let totalGetRaw = max([0, toInt((dy - big1))])
1406 -     let $t05023950294 = takeFee(totalGetRaw, outFee)
1407 -     let totalGet = $t05023950294._1
1408 -     let feeAmount = $t05023950294._2
1402 +     let $t05004150096 = takeFee(totalGetRaw, outFee)
1403 +     let totalGet = $t05004150096._1
1404 +     let feeAmount = $t05004150096._2
1409 1405      $Tuple2(nil, $Tuple2(totalGet, feeAmount))
1410 1406      }
1411 1407  
1412 1408  
1413 1409  
1414 1410  @Callable(i)
1415 1411  func getOneTknV2WithBonusREADONLY (outAssetId,lpAssetAmount) = {
1416 1412      let amId = toBase58String(value(cfgAmountAssetId))
1417 1413      let prId = toBase58String(value(cfgPriceAssetId))
1418 1414      let lpId = toBase58String(value(cfgLpAssetId))
1419 1415      let amBalance = getAccBalance(amId)
1420 1416      let prBalance = getAccBalance(prId)
1421 -     let $t05066950784 = {
1417 +     let $t05047150586 = {
1422 1418          let @ = invoke(this, "getOneTknV2READONLY", [outAssetId, lpAssetAmount], nil)
1423 1419          if ($isInstanceOf(@, "(Int, Int)"))
1424 1420              then @
1425 1421              else throw(($getType(@) + " couldn't be cast to (Int, Int)"))
1426 1422          }
1427 -     let totalGet = $t05066950784._1
1428 -     let feeAmount = $t05066950784._2
1423 +     let totalGet = $t05047150586._1
1424 +     let feeAmount = $t05047150586._2
1429 1425      let r = ego("", lpId, lpAssetAmount, this)
1430 1426      let outAmAmt = r._1
1431 1427      let outPrAmt = r._2
1432 1428      let sumOfGetAssets = (outAmAmt + outPrAmt)
1433 1429      let bonus = if ((sumOfGetAssets == 0))
1434 1430          then if ((totalGet == 0))
1435 1431              then 0
1436 1432              else throw("bonus calculation error")
1437 1433          else fraction((totalGet - sumOfGetAssets), scale8, sumOfGetAssets)
1438 1434      $Tuple2(nil, $Tuple3(totalGet, feeAmount, bonus))
1439 1435      }
1440 1436  
1441 1437  
1442 1438  
1443 1439  @Callable(i)
1444 1440  func getNoLess (noLessThenAmtAsset,noLessThenPriceAsset) = {
1445 1441      let r = cg(i)
1446 1442      let outAmAmt = r._1
1447 1443      let outPrAmt = r._2
1448 1444      let pmtAmt = r._3
1449 1445      let pmtAssetId = r._4
1450 1446      let state = r._5
1451 1447      if ((noLessThenAmtAsset > outAmAmt))
1452 1448          then throw(((("Failed:  " + toString(outAmAmt)) + " < ") + toString(noLessThenAmtAsset)))
1453 1449          else if ((noLessThenPriceAsset > outPrAmt))
1454 1450              then throw(((("Failed: " + toString(outPrAmt)) + " < ") + toString(noLessThenPriceAsset)))
1455 1451              else {
1456 1452                  let currentDLp = calcCurrentDLp(toBigInt(0), toBigInt(0), toBigInt(0))
1457 1453                  if ((currentDLp == currentDLp))
1458 1454                      then {
1459 1455                          let burnLPAssetOnFactory = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
1460 1456                          if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
1461 1457                              then {
1462 -                                 let $t05195052031 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1463 -                                 let refreshDLpActions = $t05195052031._1
1464 -                                 let updatedDLp = $t05195052031._2
1458 +                                 let $t05175251833 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1459 +                                 let refreshDLpActions = $t05175251833._1
1460 +                                 let updatedDLp = $t05175251833._2
1465 1461                                  let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1466 1462                                  if ((isUpdatedDLpValid == isUpdatedDLpValid))
1467 1463                                      then (state ++ refreshDLpActions)
1468 1464                                      else throw("Strict value is not equal to itself.")
1469 1465                                  }
1470 1466                              else throw("Strict value is not equal to itself.")
1471 1467                          }
1472 1468                      else throw("Strict value is not equal to itself.")
1473 1469                  }
1474 1470      }
1475 1471  
1476 1472  
1477 1473  
1478 1474  @Callable(i)
1479 1475  func unstakeAndGet (amount) = {
1480 1476      let checkPayments = if ((size(i.payments) != 0))
1481 1477          then throw("No pmnts expd")
1482 1478          else true
1483 1479      if ((checkPayments == checkPayments))
1484 1480          then {
1485 1481              let factoryCfg = gfc()
1486 1482              let lpAssetId = cfgLpAssetId
1487 1483              let staking = valueOrErrorMessage(addressFromString(factoryCfg[idxFactStakCntr]), "Wr st addr")
1488 1484              let currentDLp = calcCurrentDLp(toBigInt(0), toBigInt(0), toBigInt(0))
1489 1485              if ((currentDLp == currentDLp))
1490 1486                  then {
1491 1487                      let unstakeInv = invoke(staking, "unstake", [toBase58String(lpAssetId), amount], nil)
1492 1488                      if ((unstakeInv == unstakeInv))
1493 1489                          then {
1494 1490                              let r = ego(toBase58String(i.transactionId), toBase58String(lpAssetId), amount, i.caller)
1495 1491                              let outAmAmt = r._1
1496 1492                              let outPrAmt = r._2
1497 1493                              let sts = parseIntValue(r._9)
1498 1494                              let state = r._10
1499 1495                              let v = if (if (igs())
1500 1496                                  then true
1501 1497                                  else (sts == PoolShutdown))
1502 1498                                  then throw(("Blocked: " + toString(sts)))
1503 1499                                  else true
1504 1500                              if ((v == v))
1505 1501                                  then {
1506 1502                                      let burnA = invoke(fca, "burn", [amount], [AttachedPayment(lpAssetId, amount)])
1507 1503                                      if ((burnA == burnA))
1508 1504                                          then {
1509 -                                             let $t05305853139 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1510 -                                             let refreshDLpActions = $t05305853139._1
1511 -                                             let updatedDLp = $t05305853139._2
1505 +                                             let $t05286052941 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1506 +                                             let refreshDLpActions = $t05286052941._1
1507 +                                             let updatedDLp = $t05286052941._2
1512 1508                                              let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1513 1509                                              if ((isUpdatedDLpValid == isUpdatedDLpValid))
1514 1510                                                  then (state ++ refreshDLpActions)
1515 1511                                                  else throw("Strict value is not equal to itself.")
1516 1512                                              }
1517 1513                                          else throw("Strict value is not equal to itself.")
1518 1514                                      }
1519 1515                                  else throw("Strict value is not equal to itself.")
1520 1516                              }
1521 1517                          else throw("Strict value is not equal to itself.")
1522 1518                      }
1523 1519                  else throw("Strict value is not equal to itself.")
1524 1520              }
1525 1521          else throw("Strict value is not equal to itself.")
1526 1522      }
1527 1523  
1528 1524  
1529 1525  
1530 1526  @Callable(i)
1531 1527  func unstakeAndGetNoLess (unstakeAmount,noLessThenAmountAsset,noLessThenPriceAsset) = {
1532 1528      let isGetDisabled = if (igs())
1533 1529          then true
1534 1530          else (cfgPoolStatus == PoolShutdown)
1535 1531      let checks = [if (!(isGetDisabled))
1536 1532          then true
1537 1533          else throw("get operation is blocked by admin"), if ((size(i.payments) == 0))
1538 1534          then true
1539 1535          else throw("no payments are expected")]
1540 1536      if ((checks == checks))
1541 1537          then {
1542 1538              let currentDLp = calcCurrentDLp(toBigInt(0), toBigInt(0), toBigInt(0))
1543 1539              if ((currentDLp == currentDLp))
1544 1540                  then {
1545 1541                      let unstakeInv = invoke(stakingContract, "unstake", [toBase58String(cfgLpAssetId), unstakeAmount], nil)
1546 1542                      if ((unstakeInv == unstakeInv))
1547 1543                          then {
1548 1544                              let res = ego(toBase58String(i.transactionId), toBase58String(cfgLpAssetId), unstakeAmount, i.caller)
1549 1545                              let outAmAmt = res._1
1550 1546                              let outPrAmt = res._2
1551 1547                              let state = res._10
1552 1548                              let checkAmounts = [if ((outAmAmt >= noLessThenAmountAsset))
1553 1549                                  then true
1554 1550                                  else throw(makeString(["amount asset amount to receive is less than ", toString(noLessThenAmountAsset)], "")), if ((outPrAmt >= noLessThenPriceAsset))
1555 1551                                  then true
1556 1552                                  else throw(makeString(["price asset amount to receive is less than ", toString(noLessThenPriceAsset)], ""))]
1557 1553                              if ((checkAmounts == checkAmounts))
1558 1554                                  then {
1559 1555                                      let burnLPAssetOnFactory = invoke(fca, "burn", [unstakeAmount], [AttachedPayment(cfgLpAssetId, unstakeAmount)])
1560 1556                                      if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
1561 1557                                          then {
1562 -                                             let $t05439054471 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1563 -                                             let refreshDLpActions = $t05439054471._1
1564 -                                             let updatedDLp = $t05439054471._2
1558 +                                             let $t05419254273 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1559 +                                             let refreshDLpActions = $t05419254273._1
1560 +                                             let updatedDLp = $t05419254273._2
1565 1561                                              let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1566 1562                                              if ((isUpdatedDLpValid == isUpdatedDLpValid))
1567 1563                                                  then (state ++ refreshDLpActions)
1568 1564                                                  else throw("Strict value is not equal to itself.")
1569 1565                                              }
1570 1566                                          else throw("Strict value is not equal to itself.")
1571 1567                                      }
1572 1568                                  else throw("Strict value is not equal to itself.")
1573 1569                              }
1574 1570                          else throw("Strict value is not equal to itself.")
1575 1571                      }
1576 1572                  else throw("Strict value is not equal to itself.")
1577 1573              }
1578 1574          else throw("Strict value is not equal to itself.")
1579 1575      }
1580 1576  
1581 1577  
1582 1578  
1583 1579  @Callable(i)
1584 1580  func unstakeAndGetOneTknV2 (unstakeAmount,outAssetId,minOutAmount) = {
1585 1581      let isPoolOneTokenOperationsDisabled = {
1586 1582          let @ = invoke(fca, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1587 1583          if ($isInstanceOf(@, "Boolean"))
1588 1584              then @
1589 1585              else throw(($getType(@) + " couldn't be cast to Boolean"))
1590 1586          }
1591 1587      let isGetDisabled = if (if (igs())
1592 1588          then true
1593 1589          else (cfgPoolStatus == PoolShutdown))
1594 1590          then true
1595 1591          else isPoolOneTokenOperationsDisabled
1596 1592      let checks = [if (if (!(isGetDisabled))
1597 1593          then true
1598 1594          else isManager(i))
1599 1595          then true
1600 1596          else throwErr("get operation is blocked by admin"), if ((size(i.payments) == 0))
1601 1597          then true
1602 1598          else throwErr("no payments are expected")]
1603 1599      if ((checks == checks))
1604 1600          then {
1605 1601              let factoryCfg = gfc()
1606 1602              let lpAssetId = cfgLpAssetId
1607 1603              let staking = valueOrErrorMessage(addressFromString(factoryCfg[idxFactStakCntr]), "Wr st addr")
1608 1604              let userAddress = i.caller
1609 1605              let lpAssetRecipientAddress = this
1610 1606              let unstakeInv = invoke(staking, "unstakeINTERNAL", [lpAssetId, unstakeAmount, userAddress.bytes, lpAssetRecipientAddress.bytes], nil)
1611 1607              if ((unstakeInv == unstakeInv))
1612 1608                  then {
1613 -                     let $t05549355681 = getOneTknV2Internal(outAssetId, minOutAmount, [AttachedPayment(lpAssetId, unstakeAmount)], i.caller, i.originCaller, i.transactionId)
1614 -                     let state = $t05549355681._1
1615 -                     let totalAmount = $t05549355681._2
1609 +                     let $t05529555483 = getOneTknV2Internal(outAssetId, minOutAmount, [AttachedPayment(lpAssetId, unstakeAmount)], i.caller, i.originCaller, i.transactionId)
1610 +                     let state = $t05529555483._1
1611 +                     let totalAmount = $t05529555483._2
1616 1612                      $Tuple2(state, totalAmount)
1617 1613                      }
1618 1614                  else throw("Strict value is not equal to itself.")
1619 1615              }
1620 1616          else throw("Strict value is not equal to itself.")
1621 1617      }
1622 1618  
1623 1619  
1624 1620  
1625 1621  @Callable(i)
1626 1622  func putOneTknV2WithBonusREADONLY (paymentAmountRaw,paymentAssetId) = {
1627 -     let $t05580955912 = calcPutOneTkn(paymentAmountRaw, paymentAssetId, "", "", true)
1628 -     let lpAmount = $t05580955912._1
1629 -     let state = $t05580955912._2
1630 -     let feeAmount = $t05580955912._3
1631 -     let bonus = $t05580955912._4
1623 +     let $t05561155714 = calcPutOneTkn(paymentAmountRaw, paymentAssetId, "", "", true)
1624 +     let lpAmount = $t05561155714._1
1625 +     let state = $t05561155714._2
1626 +     let feeAmount = $t05561155714._3
1627 +     let bonus = $t05561155714._4
1632 1628      $Tuple2(nil, $Tuple3(lpAmount, feeAmount, bonus))
1633 1629      }
1634 1630  
1635 1631  
1636 1632  
1637 1633  @Callable(i)
1638 1634  func putOneTknV2WithoutTakeFeeREADONLY (paymentAmountRaw,paymentAssetId) = {
1639 -     let $t05606056164 = calcPutOneTkn(paymentAmountRaw, paymentAssetId, "", "", false)
1640 -     let lpAmount = $t05606056164._1
1641 -     let state = $t05606056164._2
1642 -     let feeAmount = $t05606056164._3
1643 -     let bonus = $t05606056164._4
1635 +     let $t05586255966 = calcPutOneTkn(paymentAmountRaw, paymentAssetId, "", "", false)
1636 +     let lpAmount = $t05586255966._1
1637 +     let state = $t05586255966._2
1638 +     let feeAmount = $t05586255966._3
1639 +     let bonus = $t05586255966._4
1644 1640      $Tuple2(nil, $Tuple3(lpAmount, feeAmount, bonus))
1645 1641      }
1646 1642  
1647 1643  
1648 1644  
1649 1645  @Callable(i)
1650 1646  func activate (amtAsStr,prAsStr) = if ((toString(i.caller) != toString(fca)))
1651 1647      then throw("denied")
1652 -     else $Tuple2([StringEntry(aa(), amtAsStr), StringEntry(pa(), prAsStr)], "success")
1648 +     else $Tuple2([StringEntry(aa(), amtAsStr), StringEntry(pa(), prAsStr), StringEntry(amp(), toString(ampInitial))], "success")
1653 1649  
1654 1650  
1655 1651  
1656 1652  @Callable(i)
1657 1653  func getPoolConfigWrapperREADONLY () = $Tuple2(nil, gpc())
1658 1654  
1659 1655  
1660 1656  
1661 1657  @Callable(i)
1662 1658  func getAccBalanceWrapperREADONLY (assetId) = $Tuple2(nil, getAccBalance(assetId))
1663 1659  
1664 1660  
1665 1661  
1666 1662  @Callable(i)
1667 1663  func calcPricesWrapperREADONLY (amAmt,prAmt,lpAmt) = {
1668 1664      let pr = calcPrices(amAmt, prAmt, lpAmt)
1669 1665      $Tuple2(nil, [toString(pr[0]), toString(pr[1]), toString(pr[2])])
1670 1666      }
1671 1667  
1672 1668  
1673 1669  
1674 1670  @Callable(i)
1675 1671  func fromX18WrapperREADONLY (val,resScaleMult) = $Tuple2(nil, f1(parseBigIntValue(val), resScaleMult))
1676 1672  
1677 1673  
1678 1674  
1679 1675  @Callable(i)
1680 1676  func toX18WrapperREADONLY (origVal,origScaleMult) = $Tuple2(nil, toString(t1(origVal, origScaleMult)))
1681 1677  
1682 1678  
1683 1679  
1684 1680  @Callable(i)
1685 1681  func calcPriceBigIntWrapperREADONLY (prAmtX18,amAmtX18) = $Tuple2(nil, toString(cpbi(parseBigIntValue(prAmtX18), parseBigIntValue(amAmtX18))))
1686 1682  
1687 1683  
1688 1684  
1689 1685  @Callable(i)
1690 1686  func estimatePutOperationWrapperREADONLY (txId58,slippage,inAmAmt,inAmId,inPrAmt,inPrId,usrAddr,isEval,emitLp) = $Tuple2(nil, epo(txId58, slippage, inAmAmt, inAmId, inPrAmt, inPrId, usrAddr, isEval, emitLp, true, false, 0, ""))
1691 1687  
1692 1688  
1693 1689  
1694 1690  @Callable(i)
1695 1691  func estimateGetOperationWrapperREADONLY (txId58,pmtAsId,pmtLpAmt,usrAddr) = {
1696 1692      let r = ego(txId58, pmtAsId, pmtLpAmt, addressFromStringValue(usrAddr))
1697 1693      $Tuple2(nil, $Tuple10(r._1, r._2, r._3, r._4, r._5, r._6, r._7, toString(r._8), r._9, r._10))
1698 1694      }
1699 1695  
1700 1696  
1701 1697  
1702 1698  @Callable(i)
1703 1699  func changeAmp () = {
1704 1700      let cfg = invoke(fca, "getChangeAmpConfigREADONLY", [toString(this)], nil)
1705 -     let $t05851858717 =     match cfg {
1701 +     let $t05837558574 =     match cfg {
1706 1702          case list: List[Any] => 
1707 1703              $Tuple3({
1708 1704                  let @ = list[0]
1709 1705                  if ($isInstanceOf(@, "Int"))
1710 1706                      then @
1711 1707                      else throw(($getType(@) + " couldn't be cast to Int"))
1712 1708                  }, {
1713 1709                  let @ = list[1]
1714 1710                  if ($isInstanceOf(@, "Int"))
1715 1711                      then @
1716 1712                      else throw(($getType(@) + " couldn't be cast to Int"))
1717 1713                  }, {
1718 1714                  let @ = list[2]
1719 1715                  if ($isInstanceOf(@, "Int"))
1720 1716                      then @
1721 1717                      else throw(($getType(@) + " couldn't be cast to Int"))
1722 1718                  })
1723 1719          case _ => 
1724 1720              throwErr("invalid entry type")
1725 1721      }
1726 -     let delay = $t05851858717._1
1727 -     let delta = $t05851858717._2
1728 -     let target = $t05851858717._3
1722 +     let delay = $t05837558574._1
1723 +     let delta = $t05837558574._2
1724 +     let target = $t05837558574._3
1729 1725      let curAmp = parseIntValue(getStringValue(amp()))
1730 1726      let newAmpRaw = (curAmp + delta)
1731 1727      let newAmp = if ((0 > delta))
1732 1728          then if ((target > newAmpRaw))
1733 1729              then target
1734 1730              else newAmpRaw
1735 1731          else if ((newAmpRaw > target))
1736 1732              then target
1737 1733              else newAmpRaw
1738 1734      let lastCall = valueOrElse(getInteger(keyChangeAmpLastCall()), 0)
1739 1735      let wait = (lastCall + delay)
1740 1736      let checks = [if ((height > wait))
1741 1737          then true
1742 1738          else throwErr("try again in few blocks"), if ((curAmp != newAmp))
1743 1739          then true
1744 1740          else throwErr("already reached target")]
1745 1741      if ((checks == checks))
1746 1742          then [IntegerEntry(keyChangeAmpLastCall(), height), StringEntry(amp(), toString(newAmp)), StringEntry(keyAmpHistory(height), toString(newAmp))]
1747 1743          else throw("Strict value is not equal to itself.")
1748 1744      }
1749 1745  
1750 1746  
1751 1747  @Verifier(tx)
1752 1748  func verify () = {
1753 1749      let targetPublicKey =     match managerPublicKeyOrUnit() {
1754 1750          case pk: ByteVector => 
1755 1751              pk
1756 1752          case _: Unit => 
1757 1753              tx.senderPublicKey
1758 1754          case _ => 
1759 1755              throw("Match error")
1760 1756      }
1761 1757      match tx {
1762 1758          case order: Order => 
1763 1759              let matcherPub = mp()
1764 -             let $t05965059767 = if (skipOrderValidation())
1760 +             let $t05950759624 = if (skipOrderValidation())
1765 1761                  then $Tuple2(true, "")
1766 1762                  else validateMatcherOrderAllowed(order)
1767 -             let orderValid = $t05965059767._1
1768 -             let orderValidInfo = $t05965059767._2
1763 +             let orderValid = $t05950759624._1
1764 +             let orderValidInfo = $t05950759624._2
1769 1765              let senderValid = sigVerify(order.bodyBytes, order.proofs[0], order.senderPublicKey)
1770 1766              let matcherValid = sigVerify(order.bodyBytes, order.proofs[1], matcherPub)
1771 1767              if (if (if (orderValid)
1772 1768                  then senderValid
1773 1769                  else false)
1774 1770                  then matcherValid
1775 1771                  else false)
1776 1772                  then true
1777 1773                  else throwOrderError(orderValid, orderValidInfo, senderValid, matcherValid)
1778 1774          case s: SetScriptTransaction => 
1779 1775              if (sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey))
1780 1776                  then true
1781 1777                  else {
1782 1778                      let newHash = blake2b256(value(s.script))
1783 1779                      let allowedHash = fromBase64String(value(getString(fca, keyAllowedLpStableScriptHash())))
1784 1780                      let currentHash = scriptHash(this)
1785 1781                      if ((allowedHash == newHash))
1786 1782                          then (currentHash != newHash)
1787 1783                          else false
1788 1784                      }
1789 1785          case _ => 
1790 1786              sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
1791 1787      }
1792 1788      }
1793 1789

Old	New		Differences
22	22		let slippage4D = toBigInt((scale8 - ((scale8 * 1) / scale8)))
23	23
24	24		let wavesString = "WAVES"
	25	+
	26	+	let ampInitial = 50
25	27
26	28		let Amult = "100"
27	29

256	258		else toBase58String(value(input))
257	259
258	260
259		-	func parsePoolConfig (poolConfig) = $~~Tuple9~~(addressFromStringValue(poolConfig[idxPoolAddress]), parseIntValue(poolConfig[idxPoolSt]), fromBase58String(poolConfig[idxLPAsId]), parseAssetId(poolConfig[idxAmAsId]), parseAssetId(poolConfig[idxPrAsId]), parseIntValue(poolConfig[idxAmtAsDcm]), parseIntValue(poolConfig[idxPriceAsDcm])~~, fromBase58String(poolConfig[idxIAmtAsId]~~)~~, fromBase58String(poolConfig[idxIPriceAsId]))~~
	261	+	func parsePoolConfig (poolConfig) = $Tuple7(addressFromStringValue(poolConfig[idxPoolAddress]), parseIntValue(poolConfig[idxPoolSt]), fromBase58String(poolConfig[idxLPAsId]), parseAssetId(poolConfig[idxAmAsId]), parseAssetId(poolConfig[idxPrAsId]), parseIntValue(poolConfig[idxAmtAsDcm]), parseIntValue(poolConfig[idxPriceAsDcm]))
260	262
261	263
262	264		let poolConfigParsed = parsePoolConfig(gpc())
263	265
264		-	let $~~t086868915~~ = poolConfigParsed
	266	+	let $t086088794 = poolConfigParsed
265	267
266		-	let cfgPoolAddress = $~~t086868915~~._1
	268	+	let cfgPoolAddress = $t086088794._1
267	269
268		-	let cfgPoolStatus = $~~t086868915~~._2
	270	+	let cfgPoolStatus = $t086088794._2
269	271
270		-	let cfgLpAssetId = $~~t086868915~~._3
	272	+	let cfgLpAssetId = $t086088794._3
271	273
272		-	let cfgAmountAssetId = $~~t086868915~~._4
	274	+	let cfgAmountAssetId = $t086088794._4
273	275
274		-	let cfgPriceAssetId = $~~t086868915~~._5
	276	+	let cfgPriceAssetId = $t086088794._5
275	277
276		-	let cfgAmountAssetDecimals = $~~t086868915~~._6
	278	+	let cfgAmountAssetDecimals = $t086088794._6
277	279
278		-	let cfgPriceAssetDecimals = $t086868915._7
279		-
280		-	let cfgInAmountAssedId = $t086868915._8
281		-
282		-	let cfgInPriceAssetId = $t086868915._9
	280	+	let cfgPriceAssetDecimals = $t086088794._7
283	281
284	282		func gfc () = split(strf(fca, fcfg()), SEP)
285	283

400	398		}
401	399
402	400		let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
403		-	let $~~t01342013468~~ = {
	401	+	let $t01329913347 = {
404	402		let $l = arr
405	403		let $s = size($l)
406	404		let $acc0 = $Tuple2(s, false)

414	412
415	413		$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17)
416	414		}
417		-	let d = $~~t01342013468~~._1
418		-	let found = $~~t01342013468~~._2
	415	+	let d = $t01329913347._1
	416	+	let found = $t01329913347._2
419	417		if (found)
420	418		then d
421	419		else throw(("D calculation error, D = " + toString(d)))

462	460		let lpId = cfgLpAssetId
463	461		let amIdStr = toBase58String(value(cfgAmountAssetId))
464	462		let prIdStr = toBase58String(value(cfgPriceAssetId))
465		-	let inAmIdStr = cfgInAmountAssedId
466		-	let inPrIdStr = cfgInPriceAssetId
467	463		let amtDcm = cfgAmountAssetDecimals
468	464		let priceDcm = cfgPriceAssetDecimals
469	465		let sts = toString(cfgPoolStatus)

551	547		else calcLpAmt
552	548		let amDiff = (inAmAmt - calcAmAssetPmt)
553	549		let prDiff = (inPrAmt - calcPrAssetPmt)
554		-	let $~~t02130721652~~ = if (if (isOneAsset)
	550	+	let $t02110921454 = if (if (isOneAsset)
555	551		then (pmtId == amIdStr)
556	552		else false)
557	553		then $Tuple2(pmtAmt, 0)

560	556		else false)
561	557		then $Tuple2(0, pmtAmt)
562	558		else $Tuple2(calcAmAssetPmt, calcPrAssetPmt)
563		-	let writeAmAmt = $~~t02130721652~~._1
564		-	let writePrAmt = $~~t02130721652~~._2
	559	+	let writeAmAmt = $t02110921454._1
	560	+	let writePrAmt = $t02110921454._2
565	561		let commonState = [IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice), StringEntry(pau(userAddress, txId58), dataPutActionInfo(writeAmAmt, writePrAmt, emitLpAmt, curPrice, slippage, slippageCalc, height, lastBlock.timestamp, amDiff, prDiff))]
566	562		$Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEm, lpId, sts, commonState, amDiff, prDiff, inAmId, inPrId)
567	563		}

580	576		let c = (((((D * D) / (x * n)) * D) * aPrecision) / (ann * n))
581	577		let b = ((s + ((D * aPrecision) / ann)) - D)
582	578		func calc (acc,cur) = {
583		-	let $~~t02284722867~~ = acc
584		-	let y = $~~t02284722867~~._1
585		-	let found = $~~t02284722867~~._2
	579	+	let $t02264922669 = acc
	580	+	let y = $t02264922669._1
	581	+	let found = $t02264922669._2
586	582		if ((found != unit))
587	583		then acc
588	584		else {

595	591		}
596	592
597	593		let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
598		-	let $~~t02317423221~~ = {
	594	+	let $t02297623023 = {
599	595		let $l = arr
600	596		let $s = size($l)
601	597		let $acc0 = $Tuple2(D, unit)

609	605
610	606		$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
611	607		}
612		-	let y = $~~t02317423221~~._1
613		-	let found = $~~t02317423221~~._2
	608	+	let y = $t02297623023._1
	609	+	let found = $t02297623023._2
614	610		if ((found != unit))
615	611		then y
616	612		else throw(("Y calculation error, Y = " + toString(y)))

654	650		let priceAssetBalance = getAccBalance(assetIdToString(cfgPriceAssetId))
655	651		let amountAssetAmount = order.amount
656	652		let priceAssetAmount = fraction(order.amount, order.price, scale8, FLOOR)
657		-	let $~~t02541925631~~ = if ((order.orderType == Buy))
	653	+	let $t02522125433 = if ((order.orderType == Buy))
658	654		then $Tuple2(amountAssetAmount, -(priceAssetAmount))
659	655		else $Tuple2(-(amountAssetAmount), priceAssetAmount)
660		-	let amountAssetBalanceDelta = $~~t02541925631~~._1
661		-	let priceAssetBalanceDelta = $~~t02541925631~~._2
	656	+	let amountAssetBalanceDelta = $t02522125433._1
	657	+	let priceAssetBalanceDelta = $t02522125433._2
662	658		if (if (if (igs())
663	659		then true
664	660		else (cfgPoolStatus == PoolMatcherDis))

671	667		then throw("Wr assets")
672	668		else {
673	669		let dLp = parseBigIntValue(valueOrElse(getString(this, keyDLp), "0"))
674		-	let $~~t02597326073~~ = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
675		-	let unusedActions = $~~t02597326073~~._1
676		-	let dLpNew = $~~t02597326073~~._2
	670	+	let $t02577525875 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
	671	+	let unusedActions = $t02577525875._1
	672	+	let dLpNew = $t02577525875._2
677	673		let isOrderValid = (dLpNew >= dLp)
678	674		let info = makeString(["dLp=", toString(dLp), " dLpNew=", toString(dLpNew), " amountAssetBalance=", toString(amountAssetBalance), " priceAssetBalance=", toString(priceAssetBalance), " amountAssetBalanceDelta=", toString(amountAssetBalanceDelta), " priceAssetBalanceDelta=", toString(priceAssetBalanceDelta), " height=", toString(height)], "")
679	675		$Tuple2(isOrderValid, info)

727	723		then {
728	724		let amBalance = getAccBalance(amId)
729	725		let prBalance = getAccBalance(prId)
730		-	let $~~t02872929191~~ = if ((txId == ""))
	726	+	let $t02853128993 = if ((txId == ""))
731	727		then $Tuple2(amBalance, prBalance)
732	728		else if ((pmtAssetId == amId))
733	729		then if ((pmtAmtRaw > amBalance))

738	734		then throw("invalid payment amount")
739	735		else $Tuple2(amBalance, (prBalance - pmtAmtRaw))
740	736		else throw("wrong pmtAssetId")
741		-	let amBalanceOld = $~~t02872929191~~._1
742		-	let prBalanceOld = $~~t02872929191~~._2
743		-	let $~~t02919729373~~ = if ((pmtAssetId == amId))
	737	+	let amBalanceOld = $t02853128993._1
	738	+	let prBalanceOld = $t02853128993._2
	739	+	let $t02899929175 = if ((pmtAssetId == amId))
744	740		then $Tuple2(pmtAmtRaw, 0)
745	741		else if ((pmtAssetId == prId))
746	742		then $Tuple2(0, pmtAmtRaw)
747	743		else throw("invalid payment")
748		-	let amAmountRaw = $~~t02919729373~~._1
749		-	let prAmountRaw = $~~t02919729373~~._2
750		-	let $~~t02937729631~~ = if (withTakeFee)
	744	+	let amAmountRaw = $t02899929175._1
	745	+	let prAmountRaw = $t02899929175._2
	746	+	let $t02917929433 = if (withTakeFee)
751	747		then $Tuple3(takeFee(amAmountRaw, inFee)._1, takeFee(prAmountRaw, inFee)._1, takeFee(pmtAmtRaw, inFee)._2)
752	748		else $Tuple3(amAmountRaw, prAmountRaw, 0)
753		-	let amAmount = $~~t02937729631~~._1
754		-	let prAmount = $~~t02937729631~~._2
755		-	let feeAmount = $~~t02937729631~~._3
	749	+	let amAmount = $t02917929433._1
	750	+	let prAmount = $t02917929433._2
	751	+	let feeAmount = $t02917929433._3
756	752		let amBalanceNew = (amBalanceOld + amAmount)
757	753		let prBalanceNew = (prBalanceOld + prAmount)
758	754		let D0 = getD([t1(amBalanceOld, cfgAmountAssetDecimals), t1(prBalanceOld, cfgPriceAssetDecimals)])

800	796		else {
801	797		let amBalance = getAccBalance(amId)
802	798		let prBalance = getAccBalance(prId)
803		-	let $~~t03174331854~~ = {
	799	+	let $t03154531656 = {
804	800		let @ = invoke(this, "getOneTknV2READONLY", [outAssetId, pmtAmt], nil)
805	801		if ($isInstanceOf(@, "(Int, Int)"))
806	802		then @
807	803		else throw(($getType(@) + " couldn't be cast to (Int, Int)"))
808	804		}
809		-	if (($~~t03174331854~~ == $~~t03174331854~~))
	805	+	if (($t03154531656 == $t03154531656))
810	806		then {
811		-	let feeAmount = $~~t03174331854~~._2
812		-	let totalGet = $~~t03174331854~~._1
	807	+	let feeAmount = $t03154531656._2
	808	+	let totalGet = $t03154531656._1
813	809		let totalAmount = if (if ((minOutAmount > 0))
814	810		then (minOutAmount > totalGet)
815	811		else false)
816	812		then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
817	813		else totalGet
818		-	let $~~t03204432351~~ = if ((outAssetId == amId))
	814	+	let $t03184632153 = if ((outAssetId == amId))
819	815		then $Tuple4(totalAmount, 0, ((amBalance - totalAmount) - feeAmount), prBalance)
820	816		else if ((outAssetId == prId))
821	817		then $Tuple4(0, totalAmount, amBalance, ((prBalance - totalAmount) - feeAmount))
822	818		else throw("invalid out asset id")
823		-	let outAm = $~~t03204432351~~._1
824		-	let outPr = $~~t03204432351~~._2
825		-	let amBalanceNew = $~~t03204432351~~._3
826		-	let prBalanceNew = $~~t03204432351~~._4
	819	+	let outAm = $t03184632153._1
	820	+	let outPr = $t03184632153._2
	821	+	let amBalanceNew = $t03184632153._3
	822	+	let prBalanceNew = $t03184632153._4
827	823		let curPrX18 = cpbi(t1(prBalanceNew, prDecimals), t1(amBalanceNew, amDecimals))
828	824		let curPr = f1(curPrX18, scale8)
829	825		let outAssetIdOrWaves = if ((outAssetId == "WAVES"))

838	834		let burn = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
839	835		if ((burn == burn))
840	836		then {
841		-	let $~~t03313633486~~ = {
	837	+	let $t03293833288 = {
842	838		let feeAmountForCalc = if ((this == feeCollectorAddress))
843	839		then 0
844	840		else feeAmount

849	845		then $Tuple2(-((totalGet + feeAmountForCalc)), 0)
850	846		else $Tuple2(0, -((totalGet + feeAmountForCalc)))
851	847		}
852		-	let amountAssetBalanceDelta = $~~t03313633486~~._1
853		-	let priceAssetBalanceDelta = $~~t03313633486~~._2
854		-	let $~~t03348933597~~ = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
855		-	let refreshDLpActions = $~~t03348933597~~._1
856		-	let updatedDLp = $~~t03348933597~~._2
	848	+	let amountAssetBalanceDelta = $t03293833288._1
	849	+	let priceAssetBalanceDelta = $t03293833288._2
	850	+	let $t03329133399 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
	851	+	let refreshDLpActions = $t03329133399._1
	852	+	let updatedDLp = $t03329133399._2
857	853		let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
858	854		if ((isUpdatedDLpValid == isUpdatedDLpValid))
859	855		then $Tuple2((state ++ refreshDLpActions), totalAmount)

925	921		let c = (((((D * D) / (x * n)) * D) * aPrecision) / (ann * n))
926	922		let b = ((s + ((D * aPrecision) / ann)) - D)
927	923		func calc (acc,cur) = {
928		-	let $~~t03508435104~~ = acc
929		-	let y = $~~t03508435104~~._1
930		-	let found = $~~t03508435104~~._2
	924	+	let $t03488634906 = acc
	925	+	let y = $t03488634906._1
	926	+	let found = $t03488634906._2
931	927		if ((found != unit))
932	928		then acc
933	929		else {

940	936		}
941	937
942	938		let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
943		-	let $~~t03543535482~~ = {
	939	+	let $t03523735284 = {
944	940		let $l = arr
945	941		let $s = size($l)
946	942		let $acc0 = $Tuple2(D, unit)

954	950
955	951		$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
956	952		}
957		-	let y = $~~t03543535482~~._1
958		-	let found = $~~t03543535482~~._2
	953	+	let y = $t03523735284._1
	954	+	let found = $t03523735284._2
959	955		if ((found != unit))
960	956		then y
961	957		else throw(("Y calculation error, Y = " + toString(y)))

967	963
968	964		@Callable(i)
969	965		func calculateAmountOutForSwapREADONLY (cleanAmountIn,isReverse,feePoolAmount) = {
970		-	let $~~t03583436258~~ = if ((isReverse == false))
	966	+	let $t03563636060 = if ((isReverse == false))
971	967		then {
972	968		let assetOut = strf(this, pa())
973	969		let poolAmountInBalance = (toBigInt(getAccBalance(strf(this, aa()))) + toBigInt(cleanAmountIn))

978	974		let poolAmountInBalance = (toBigInt(getAccBalance(strf(this, pa()))) + toBigInt(cleanAmountIn))
979	975		$Tuple2(assetOut, poolAmountInBalance)
980	976		}
981		-	let assetOut = $~~t03583436258~~._1
982		-	let poolAmountInBalance = $~~t03583436258~~._2
	977	+	let assetOut = $t03563636060._1
	978	+	let poolAmountInBalance = $t03563636060._2
983	979		let poolConfig = gpc()
984	980		let amId = poolConfig[idxAmAsId]
985	981		let prId = poolConfig[idxPrAsId]

1019	1015		then {
1020	1016		let pmt = value(i.payments[0])
1021	1017		let assetIn = assetIdToString(pmt.assetId)
1022		-	let $~~t03769438088~~ = if ((isReverse == false))
	1018	+	let $t03749637890 = if ((isReverse == false))
1023	1019		then {
1024	1020		let assetOut = strf(this, pa())
1025	1021		let poolAmountInBalance = (getAccBalance(assetIn) - value(i.payments[0]).amount)

1030	1026		let poolAmountInBalance = (getAccBalance(assetIn) - value(i.payments[0]).amount)
1031	1027		$Tuple2(assetOut, poolAmountInBalance)
1032	1028		}
1033		-	let assetOut = $~~t03769438088~~._1
1034		-	let poolAmountInBalance = $~~t03769438088~~._2
	1029	+	let assetOut = $t03749637890._1
	1030	+	let poolAmountInBalance = $t03749637890._2
1035	1031		let poolConfig = gpc()
1036	1032		let amId = poolConfig[idxAmAsId]
1037	1033		let prId = poolConfig[idxPrAsId]

1136	1132		else throw("Strict value is not equal to itself.")
1137	1133		}
1138	1134		else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
1139		-	let $~~t04223242374~~ = refreshDLpInternal(0, 0, 0)
1140		-	let refreshDLpActions = $~~t04223242374~~._1
1141		-	let updatedDLp = $~~t04223242374~~._2
	1135	+	let $t04203442176 = refreshDLpInternal(0, 0, 0)
	1136	+	let refreshDLpActions = $t04203442176._1
	1137	+	let updatedDLp = $t04203442176._2
1142	1138		let check = if ((updatedDLp >= currentDLp))
1143	1139		then true
1144	1140		else throwErr(makeString(["updated DLp lower than current DLp", toString(amountAssetBalance), toString(priceAssetBalance), toString(lpAssetEmission), toString(currentDLp), toString(updatedDLp), toString(amDiff), toString(prDiff)], " "))

1211	1207		else calcCurrentDLp(toBigInt(0), toBigInt(pmtAmt), toBigInt(0))
1212	1208		if ((currentDLp == currentDLp))
1213	1209		then {
1214		-	let $~~t04401544173~~ = calcPutOneTkn(pmtAmt, pmtAssetId, toString(userAddress), toBase58String(i.transactionId), true)
1215		-	if (($~~t04401544173~~ == $~~t04401544173~~))
	1210	+	let $t04381743975 = calcPutOneTkn(pmtAmt, pmtAssetId, toString(userAddress), toBase58String(i.transactionId), true)
	1211	+	if (($t04381743975 == $t04381743975))
1216	1212		then {
1217		-	let feeAmount = $~~t04401544173~~._3
1218		-	let state = $~~t04401544173~~._2
1219		-	let estimLP = $~~t04401544173~~._1
	1213	+	let feeAmount = $t04381743975._3
	1214	+	let state = $t04381743975._2
	1215	+	let estimLP = $t04381743975._1
1220	1216		let emitLpAmt = if (if ((minOutAmount > 0))
1221	1217		then (minOutAmount > estimLP)
1222	1218		else false)

1244	1240		let sendFeeToMatcher = if ((feeAmount > 0))
1245	1241		then [ScriptTransfer(feeCollectorAddress, feeAmount, fromBase58String(pmtAssetId))]
1246	1242		else nil
1247		-	let $~~t04505845407~~ = if ((this == feeCollectorAddress))
	1243	+	let $t04486045209 = if ((this == feeCollectorAddress))
1248	1244		then $Tuple2(0, 0)
1249	1245		else {
1250	1246		let paymentInAmountAsset = if ((pmt.assetId == cfgAmountAssetId))

1254	1250		then $Tuple2(-(feeAmount), 0)
1255	1251		else $Tuple2(0, -(feeAmount))
1256	1252		}
1257		-	let amountAssetBalanceDelta = $~~t04505845407~~._1
1258		-	let priceAssetBalanceDelta = $~~t04505845407~~._2
1259		-	let $~~t04541045518~~ = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
1260		-	let refreshDLpActions = $~~t04541045518~~._1
1261		-	let updatedDLp = $~~t04541045518~~._2
	1253	+	let amountAssetBalanceDelta = $t04486045209._1
	1254	+	let priceAssetBalanceDelta = $t04486045209._2
	1255	+	let $t04521245320 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
	1256	+	let refreshDLpActions = $t04521245320._1
	1257	+	let updatedDLp = $t04521245320._2
1262	1258		let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1263	1259		if ((isUpdatedDLpValid == isUpdatedDLpValid))
1264	1260		then $Tuple2((((state ++ lpTrnsfr) ++ sendFeeToMatcher) ++ refreshDLpActions), emitLpAmt)

1290	1286		let currentDLp = calcCurrentDLp(amAssetPmt, prAssetPmt, toBigInt(0))
1291	1287		if ((currentDLp == currentDLp))
1292	1288		then {
1293		-	let $~~t04654846613~~ = refreshDLpInternal(0, 0, 0)
1294		-	let refreshDLpActions = $~~t04654846613~~._1
1295		-	let updatedDLp = $~~t04654846613~~._2
	1289	+	let $t04635046415 = refreshDLpInternal(0, 0, 0)
	1290	+	let refreshDLpActions = $t04635046415._1
	1291	+	let updatedDLp = $t04635046415._2
1296	1292		let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1297	1293		if ((isUpdatedDLpValid == isUpdatedDLpValid))
1298	1294		then (state ++ refreshDLpActions)

1317	1313		let b = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
1318	1314		if ((b == b))
1319	1315		then {
1320		-	let $~~t04778647868~~ = refreshDLpInternal(-(outAmtAmt), -(outPrAmt), 0)
1321		-	let refreshDLpActions = $~~t04778647868~~._1
1322		-	let updatedDLp = $~~t04778647868~~._2
	1316	+	let $t04758847670 = refreshDLpInternal(-(outAmtAmt), -(outPrAmt), 0)
	1317	+	let refreshDLpActions = $t04758847670._1
	1318	+	let updatedDLp = $t04758847670._2
1323	1319		let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1324	1320		if ((isUpdatedDLpValid == isUpdatedDLpValid))
1325	1321		then (state ++ refreshDLpActions)

1354	1350		else throwErr("exactly 1 payment are expected")]
1355	1351		if ((checks == checks))
1356	1352		then {
1357		-	let $~~t04848648641~~ = getOneTknV2Internal(outAssetId, minOutAmount, i.payments, i.caller, i.originCaller, i.transactionId)
1358		-	let state = $~~t04848648641~~._1
1359		-	let totalAmount = $~~t04848648641~~._2
	1353	+	let $t04828848443 = getOneTknV2Internal(outAssetId, minOutAmount, i.payments, i.caller, i.originCaller, i.transactionId)
	1354	+	let state = $t04828848443._1
	1355	+	let totalAmount = $t04828848443._2
1360	1356		$Tuple2(state, totalAmount)
1361	1357		}
1362	1358		else throw("Strict value is not equal to itself.")

1373	1369		if ((checkLastRefreshedBlockHeight == checkLastRefreshedBlockHeight))
1374	1370		then {
1375	1371		let dLp = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, keyDLp), "0")), fmtErr("invalid dLp"))
1376		-	let $~~t04916549229~~ = refreshDLpInternal(0, 0, 0)
1377		-	let dLpUpdateActions = $~~t04916549229~~._1
1378		-	let updatedDLp = $~~t04916549229~~._2
	1372	+	let $t04896749031 = refreshDLpInternal(0, 0, 0)
	1373	+	let dLpUpdateActions = $t04896749031._1
	1374	+	let updatedDLp = $t04896749031._2
1379	1375		let actions = if ((dLp != updatedDLp))
1380	1376		then dLpUpdateActions
1381	1377		else throwErr("nothing to refresh")

1403	1399		let newY = getYD(xp, index, D1)
1404	1400		let dy = (xp[index] - newY)
1405	1401		let totalGetRaw = max([0, toInt((dy - big1))])
1406		-	let $~~t05023950294~~ = takeFee(totalGetRaw, outFee)
1407		-	let totalGet = $~~t05023950294~~._1
1408		-	let feeAmount = $~~t05023950294~~._2
	1402	+	let $t05004150096 = takeFee(totalGetRaw, outFee)
	1403	+	let totalGet = $t05004150096._1
	1404	+	let feeAmount = $t05004150096._2
1409	1405		$Tuple2(nil, $Tuple2(totalGet, feeAmount))
1410	1406		}
1411	1407

1418	1414		let lpId = toBase58String(value(cfgLpAssetId))
1419	1415		let amBalance = getAccBalance(amId)
1420	1416		let prBalance = getAccBalance(prId)
1421		-	let $~~t05066950784~~ = {
	1417	+	let $t05047150586 = {
1422	1418		let @ = invoke(this, "getOneTknV2READONLY", [outAssetId, lpAssetAmount], nil)
1423	1419		if ($isInstanceOf(@, "(Int, Int)"))
1424	1420		then @
1425	1421		else throw(($getType(@) + " couldn't be cast to (Int, Int)"))
1426	1422		}
1427		-	let totalGet = $~~t05066950784~~._1
1428		-	let feeAmount = $~~t05066950784~~._2
	1423	+	let totalGet = $t05047150586._1
	1424	+	let feeAmount = $t05047150586._2
1429	1425		let r = ego("", lpId, lpAssetAmount, this)
1430	1426		let outAmAmt = r._1
1431	1427		let outPrAmt = r._2

1459	1455		let burnLPAssetOnFactory = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
1460	1456		if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
1461	1457		then {
1462		-	let $~~t05195052031~~ = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1463		-	let refreshDLpActions = $~~t05195052031~~._1
1464		-	let updatedDLp = $~~t05195052031~~._2
	1458	+	let $t05175251833 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
	1459	+	let refreshDLpActions = $t05175251833._1
	1460	+	let updatedDLp = $t05175251833._2
1465	1461		let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1466	1462		if ((isUpdatedDLpValid == isUpdatedDLpValid))
1467	1463		then (state ++ refreshDLpActions)

1506	1502		let burnA = invoke(fca, "burn", [amount], [AttachedPayment(lpAssetId, amount)])
1507	1503		if ((burnA == burnA))
1508	1504		then {
1509		-	let $~~t05305853139~~ = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1510		-	let refreshDLpActions = $~~t05305853139~~._1
1511		-	let updatedDLp = $~~t05305853139~~._2
	1505	+	let $t05286052941 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
	1506	+	let refreshDLpActions = $t05286052941._1
	1507	+	let updatedDLp = $t05286052941._2

Old	New		Differences
1	1		{-# STDLIB_VERSION 6 #-}
2	2		{-# SCRIPT_TYPE ACCOUNT #-}
3	3		{-# CONTENT_TYPE DAPP #-}
4	4		let scale8 = 100000000
5	5
6	6		let scale8BigInt = toBigInt(100000000)
7	7
8	8		let scale18 = toBigInt(1000000000000000000)
9	9
10	10		let zeroBigInt = toBigInt(0)
11	11
12	12		let big0 = toBigInt(0)
13	13
14	14		let big1 = toBigInt(1)
15	15
16	16		let big2 = toBigInt(2)
17	17
18	18		let big3 = toBigInt(3)
19	19
20	20		let big4 = toBigInt(4)
21	21
22	22		let slippage4D = toBigInt((scale8 - ((scale8 * 1) / scale8)))
23	23
24	24		let wavesString = "WAVES"
	25	+
	26	+	let ampInitial = 50
25	27
26	28		let Amult = "100"
27	29
28	30		let Dconv = "1"
29	31
30	32		let SEP = "__"
31	33
32	34		let EMPTY = ""
33	35
34	36		let PoolActive = 1
35	37
36	38		let PoolPutDis = 2
37	39
38	40		let PoolMatcherDis = 3
39	41
40	42		let PoolShutdown = 4
41	43
42	44		let idxPoolAddress = 1
43	45
44	46		let idxPoolSt = 2
45	47
46	48		let idxLPAsId = 3
47	49
48	50		let idxAmAsId = 4
49	51
50	52		let idxPrAsId = 5
51	53
52	54		let idxAmtAsDcm = 6
53	55
54	56		let idxPriceAsDcm = 7
55	57
56	58		let idxIAmtAsId = 8
57	59
58	60		let idxIPriceAsId = 9
59	61
60	62		let idxFactStakCntr = 1
61	63
62	64		let idxFactoryRestCntr = 6
63	65
64	66		let idxFactSlippCntr = 7
65	67
66	68		let idxFactGwxRewCntr = 10
67	69
68	70		let feeDefault = fraction(10, scale8, 10000)
69	71
70	72		func t1 (origVal,origScaleMult) = fraction(toBigInt(origVal), scale18, toBigInt(origScaleMult))
71	73
72	74
73	75		func t1BigInt (origVal,origScaleMult) = fraction(origVal, scale18, origScaleMult)
74	76
75	77
76	78		func f1 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), scale18))
77	79
78	80
79	81		func fromX18Round (val,resultScaleMult,round) = toInt(fraction(val, toBigInt(resultScaleMult), scale18, round))
80	82
81	83
82	84		func t2 (origVal,origScaleMult) = fraction(origVal, scale18, toBigInt(origScaleMult))
83	85
84	86
85	87		func f2 (val,resultScaleMult) = fraction(val, toBigInt(resultScaleMult), scale18)
86	88
87	89
88	90		func ts (amt,resScale,curScale) = fraction(amt, resScale, curScale)
89	91
90	92
91	93		func abs (val) = if ((zeroBigInt > val))
92	94		then -(val)
93	95		else val
94	96
95	97
96	98		func absBigInt (val) = if ((zeroBigInt > val))
97	99		then -(val)
98	100		else val
99	101
100	102
101	103		func fc () = "%s__factoryContract"
102	104
103	105
104	106		func keyManagerPublicKey () = "%s__managerPublicKey"
105	107
106	108
107	109		func keyManagerVaultAddress () = "%s__managerVaultAddress"
108	110
109	111
110	112		func pl () = "%s%s__price__last"
111	113
112	114
113	115		func ph (h,t) = makeString(["%s%s%d%d__price__history", toString(h), toString(t)], SEP)
114	116
115	117
116	118		func pau (ua,txId) = ((("%s%s%s__P__" + ua) + "__") + txId)
117	119
118	120
119	121		func gau (ua,txId) = ((("%s%s%s__G__" + ua) + "__") + txId)
120	122
121	123
122	124		func aa () = "%s__amountAsset"
123	125
124	126
125	127		func pa () = "%s__priceAsset"
126	128
127	129
128	130		func amp () = "%s__amp"
129	131
130	132
131	133		func keyAmpHistory (heightBlocks) = ("%s%d__amp__" + toString(heightBlocks))
132	134
133	135
134	136		func keyChangeAmpLastCall () = "%s__changeAmpLastCall"
135	137
136	138
137	139		let keyFee = "%s__fee"
138	140
139	141		let fee = valueOrElse(getInteger(this, keyFee), feeDefault)
140	142
141	143		let keyDLp = makeString(["%s", "dLp"], SEP)
142	144
143	145		let keyDLpRefreshedHeight = makeString(["%s", "dLpRefreshedHeight"], SEP)
144	146
145	147		let keyDLpRefreshDelay = makeString(["%s", "refreshDLpDelay"], SEP)
146	148
147	149		let dLpRefreshDelayDefault = 30
148	150
149	151		let dLpRefreshDelay = valueOrElse(getInteger(this, keyDLpRefreshDelay), dLpRefreshDelayDefault)
150	152
151	153		func fcfg () = "%s__factoryConfig"
152	154
153	155
154	156		func mtpk () = "%s%s__matcher__publicKey"
155	157
156	158
157	159		func pc (iAmtAs,iPrAs) = (((("%d%d%s__" + iAmtAs) + "__") + iPrAs) + "__config")
158	160
159	161
160	162		func mba (bAStr) = ("%s%s%s__mappings__baseAsset2internalId__" + bAStr)
161	163
162	164
163	165		func aps () = "%s__shutdown"
164	166
165	167
166	168		func keyAllowedLpStableScriptHash () = "%s__allowedLpStableScriptHash"
167	169
168	170
169	171		func keyFeeCollectorAddress () = "%s__feeCollectorAddress"
170	172
171	173
172	174		func keySkipOrderValidation (poolAddress) = ("%s%s__skipOrderValidation__" + poolAddress)
173	175
174	176
175	177		func throwOrderError (orderValid,orderValidInfo,senderValid,matcherValid) = throw((((((((("order validation failed: orderValid=" + toString(orderValid)) + " (") + orderValidInfo) + ")") + " senderValid=") + toString(senderValid)) + " matcherValid=") + toString(matcherValid)))
176	178
177	179
178	180		func addressFromStringOrThis (addressString) = match addressFromString(addressString) {
179	181		case a: Address =>
180	182		a
181	183		case _ =>
182	184		this
183	185		}
184	186
185	187
186	188		func getManagerVaultAddressOrThis () = {
187	189		let factoryAddress = match getString(fc()) {
188	190		case fca: String =>
189	191		addressFromStringOrThis(fca)
190	192		case _ =>
191	193		this
192	194		}
193	195		match getString(factoryAddress, keyManagerVaultAddress()) {
194	196		case s: String =>
195	197		addressFromStringOrThis(s)
196	198		case _ =>
197	199		this
198	200		}
199	201		}
200	202
201	203
202	204		func strf (addr,key) = valueOrErrorMessage(getString(addr, key), makeString(["mandatory ", toString(addr), ".", key, " not defined"], ""))
203	205
204	206
205	207		func intf (addr,key) = valueOrErrorMessage(getInteger(addr, key), makeString(["mandatory ", toString(addr), ".", key, " not defined"], ""))
206	208
207	209
208	210		func throwErr (msg) = throw(makeString(["lp_stable.ride:", msg], " "))
209	211
210	212
211	213		func fmtErr (msg) = makeString(["lp_stable.ride:", msg], " ")
212	214
213	215
214	216		let fca = addressFromStringValue(strf(this, fc()))
215	217
216	218		let inFee = {
217	219		let @ = invoke(fca, "getInFeeREADONLY", [toString(this)], nil)
218	220		if ($isInstanceOf(@, "Int"))
219	221		then @
220	222		else throw(($getType(@) + " couldn't be cast to Int"))
221	223		}
222	224
223	225		let outFee = {
224	226		let @ = invoke(fca, "getOutFeeREADONLY", [toString(this)], nil)
225	227		if ($isInstanceOf(@, "Int"))
226	228		then @
227	229		else throw(($getType(@) + " couldn't be cast to Int"))
228	230		}
229	231
230	232		let A = strf(this, amp())
231	233
232	234		func igs () = valueOrElse(getBoolean(fca, aps()), false)
233	235
234	236
235	237		func mp () = fromBase58String(strf(fca, mtpk()))
236	238
237	239
238	240		let feeCollectorAddress = addressFromStringValue(strf(fca, keyFeeCollectorAddress()))
239	241
240	242		func gpc () = {
241	243		let amtAs = strf(this, aa())
242	244		let priceAs = strf(this, pa())
243	245		let iPriceAs = intf(fca, mba(priceAs))
244	246		let iAmtAs = intf(fca, mba(amtAs))
245	247		split(strf(fca, pc(toString(iAmtAs), toString(iPriceAs))), SEP)
246	248		}
247	249
248	250
249	251		func parseAssetId (input) = if ((input == wavesString))
250	252		then unit
251	253		else fromBase58String(input)
252	254
253	255
254	256		func assetIdToString (input) = if ((input == unit))
255	257		then wavesString
256	258		else toBase58String(value(input))
257	259
258	260
259		-	func parsePoolConfig (poolConfig) = $~~Tuple9~~(addressFromStringValue(poolConfig[idxPoolAddress]), parseIntValue(poolConfig[idxPoolSt]), fromBase58String(poolConfig[idxLPAsId]), parseAssetId(poolConfig[idxAmAsId]), parseAssetId(poolConfig[idxPrAsId]), parseIntValue(poolConfig[idxAmtAsDcm]), parseIntValue(poolConfig[idxPriceAsDcm])~~, fromBase58String(poolConfig[idxIAmtAsId]~~)~~, fromBase58String(poolConfig[idxIPriceAsId]))~~
	261	+	func parsePoolConfig (poolConfig) = $Tuple7(addressFromStringValue(poolConfig[idxPoolAddress]), parseIntValue(poolConfig[idxPoolSt]), fromBase58String(poolConfig[idxLPAsId]), parseAssetId(poolConfig[idxAmAsId]), parseAssetId(poolConfig[idxPrAsId]), parseIntValue(poolConfig[idxAmtAsDcm]), parseIntValue(poolConfig[idxPriceAsDcm]))
260	262
261	263
262	264		let poolConfigParsed = parsePoolConfig(gpc())
263	265
264		-	let $~~t086868915~~ = poolConfigParsed
	266	+	let $t086088794 = poolConfigParsed
265	267
266		-	let cfgPoolAddress = $~~t086868915~~._1
	268	+	let cfgPoolAddress = $t086088794._1
267	269
268		-	let cfgPoolStatus = $~~t086868915~~._2
	270	+	let cfgPoolStatus = $t086088794._2
269	271
270		-	let cfgLpAssetId = $~~t086868915~~._3
	272	+	let cfgLpAssetId = $t086088794._3
271	273
272		-	let cfgAmountAssetId = $~~t086868915~~._4
	274	+	let cfgAmountAssetId = $t086088794._4
273	275
274		-	let cfgPriceAssetId = $~~t086868915~~._5
	276	+	let cfgPriceAssetId = $t086088794._5
275	277
276		-	let cfgAmountAssetDecimals = $~~t086868915~~._6
	278	+	let cfgAmountAssetDecimals = $t086088794._6
277	279
278		-	let cfgPriceAssetDecimals = $t086868915._7
279		-
280		-	let cfgInAmountAssedId = $t086868915._8
281		-
282		-	let cfgInPriceAssetId = $t086868915._9
	280	+	let cfgPriceAssetDecimals = $t086088794._7
283	281
284	282		func gfc () = split(strf(fca, fcfg()), SEP)
285	283
286	284
287	285		let factoryConfig = gfc()
288	286
289	287		let stakingContract = valueOrErrorMessage(addressFromString(factoryConfig[idxFactStakCntr]), "Invalid staking contract address")
290	288
291	289		let slipageContract = valueOrErrorMessage(addressFromString(factoryConfig[idxFactSlippCntr]), "Invalid slipage contract address")
292	290
293	291		let gwxContract = valueOrErrorMessage(addressFromString(factoryConfig[idxFactGwxRewCntr]), "Invalid gwx contract address")
294	292
295	293		let restContract = valueOrErrorMessage(addressFromString(factoryConfig[idxFactoryRestCntr]), "Invalid gwx contract address")
296	294
297	295		func dataPutActionInfo (inAmtAssetAmt,inPriceAssetAmt,outLpAmt,price,slipByUser,slippageReal,txHeight,txTimestamp,slipageAmAmt,slipagePrAmt) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(inAmtAssetAmt), toString(inPriceAssetAmt), toString(outLpAmt), toString(price), toString(slipByUser), toString(slippageReal), toString(txHeight), toString(txTimestamp), toString(slipageAmAmt), toString(slipagePrAmt)], SEP)
298	296
299	297
300	298		func dataGetActionInfo (outAmtAssetAmt,outPriceAssetAmt,inLpAmt,price,txHeight,txTimestamp) = makeString(["%d%d%d%d%d%d", toString(outAmtAssetAmt), toString(outPriceAssetAmt), toString(inLpAmt), toString(price), toString(txHeight), toString(txTimestamp)], SEP)
301	299
302	300
303	301		func getAccBalance (assetId) = if ((assetId == "WAVES"))
304	302		then wavesBalance(this).available
305	303		else assetBalance(this, fromBase58String(assetId))
306	304
307	305
308	306		func cpbi (prAmtX18,amAmtX18) = fraction(prAmtX18, scale18, amAmtX18)
309	307
310	308
311	309		func cpbir (prAmtX18,amAmtX18,round) = fraction(prAmtX18, scale18, amAmtX18, round)
312	310
313	311
314	312		func vad (A1,A2,slippage) = {
315	313		let diff = fraction((A1 - A2), scale8BigInt, A2)
316	314		let pass = ((slippage - abs(diff)) > zeroBigInt)
317	315		if (!(pass))
318	316		then throw(("Big slpg: " + toString(diff)))
319	317		else $Tuple2(pass, min([A1, A2]))
320	318		}
321	319
322	320
323	321		func vd (D1,D0,slpg) = {
324	322		let diff = fraction(D0, scale8BigInt, D1)
325	323		let fail = (slpg > diff)
326	324		if (if (fail)
327	325		then true
328	326		else (D0 > D1))
329	327		then throw(((((((toString(D0) + " ") + toString(D1)) + " ") + toString(diff)) + " ") + toString(slpg)))
330	328		else fail
331	329		}
332	330
333	331
334	332		func pcp (amAssetDcm,prAssetDcm,amAmt,prAmt) = {
335	333		let amtAsAmtX18 = t1(amAmt, amAssetDcm)
336	334		let prAsAmtX18 = t1(prAmt, prAssetDcm)
337	335		cpbi(prAsAmtX18, amtAsAmtX18)
338	336		}
339	337
340	338
341	339		func calcPrices (amAmt,prAmt,lpAmt) = {
342	340		let amtAsDcm = cfgAmountAssetDecimals
343	341		let prAsDcm = cfgPriceAssetDecimals
344	342		let priceX18 = pcp(amtAsDcm, prAsDcm, amAmt, prAmt)
345	343		let amAmtX18 = t1(amAmt, amtAsDcm)
346	344		let prAmtX18 = t1(prAmt, prAsDcm)
347	345		let lpAmtX18 = t1(lpAmt, scale8)
348	346		let lpPrInAmAsX18 = cpbi(amAmtX18, lpAmtX18)
349	347		let lpPrInPrAsX18 = cpbi(prAmtX18, lpAmtX18)
350	348		[priceX18, lpPrInAmAsX18, lpPrInPrAsX18]
351	349		}
352	350
353	351
354	352		func calculatePrices (amAmt,prAmt,lpAmt) = {
355	353		let p = calcPrices(amAmt, prAmt, lpAmt)
356	354		[f1(p[0], scale8), f1(p[1], scale8), f1(p[2], scale8)]
357	355		}
358	356
359	357
360	358		func takeFee (amount,fee) = {
361	359		let feeAmount = if ((fee == 0))
362	360		then 0
363	361		else fraction(amount, fee, scale8)
364	362		$Tuple2((amount - feeAmount), feeAmount)
365	363		}
366	364
367	365
368	366		func getD (xp) = {
369	367		let xp0 = xp[0]
370	368		let xp1 = xp[1]
371	369		let s = (xp0 + xp1)
372	370		if ((s == big0))
373	371		then big0
374	372		else {
375	373		let a = parseIntValue(A)
376	374		let ann = (a * 2)
377	375		let p = fraction(xp0, xp1, big1)
378	376		let xp0_xp1_n_n = fraction(p, big4, big1)
379	377		let ann_s = fraction(toBigInt(ann), s, big1)
380	378		let ann_1 = toBigInt((ann - 1))
381	379		func calcDNext (d) = {
382	380		let dd = fraction(d, d, big1)
383	381		let ddd = fraction(dd, d, big1)
384	382		let dp = fraction(ddd, big1, xp0_xp1_n_n)
385	383		fraction((ann_s + fraction(dp, big2, big1)), d, (fraction(ann_1, d, big1) + fraction(big3, dp, big1)))
386	384		}
387	385
388	386		func calc (acc,i) = if (acc._2)
389	387		then acc
390	388		else {
391	389		let d = acc._1
392	390		let dNext = calcDNext(d)
393	391		let dDiffRaw = (dNext - value(d))
394	392		let dDiff = if ((big0 > dDiffRaw))
395	393		then -(dDiffRaw)
396	394		else dDiffRaw
397	395		if ((big1 >= dDiff))
398	396		then $Tuple2(dNext, true)
399	397		else $Tuple2(dNext, false)
400	398		}
401	399
402	400		let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
403		-	let $~~t01342013468~~ = {
	401	+	let $t01329913347 = {
404	402		let $l = arr
405	403		let $s = size($l)
406	404		let $acc0 = $Tuple2(s, false)
407	405		func $f0_1 ($a,$i) = if (($i >= $s))
408	406		then $a
409	407		else calc($a, $l[$i])
410	408
411	409		func $f0_2 ($a,$i) = if (($i >= $s))
412	410		then $a
413	411		else throw("List size exceeds 17")
414	412
415	413		$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17)
416	414		}
417		-	let d = $~~t01342013468~~._1
418		-	let found = $~~t01342013468~~._2
	415	+	let d = $t01329913347._1
	416	+	let found = $t01329913347._2
419	417		if (found)
420	418		then d
421	419		else throw(("D calculation error, D = " + toString(d)))
422	420		}
423	421		}
424	422
425	423
426	424		func ego (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
427	425		let lpId = cfgLpAssetId
428	426		let amId = toBase58String(value(cfgAmountAssetId))
429	427		let prId = toBase58String(value(cfgPriceAssetId))
430	428		let amDcm = cfgAmountAssetDecimals
431	429		let prDcm = cfgPriceAssetDecimals
432	430		let sts = toString(cfgPoolStatus)
433	431		let lpEmiss = valueOrErrorMessage(assetInfo(lpId), "Wrong LP id").quantity
434	432		if ((toBase58String(lpId) != pmtAssetId))
435	433		then throw("Wrong pmt asset")
436	434		else {
437	435		let amBalance = getAccBalance(amId)
438	436		let amBalanceX18 = t1(amBalance, amDcm)
439	437		let prBalance = getAccBalance(prId)
440	438		let prBalanceX18 = t1(prBalance, prDcm)
441	439		let curPriceX18 = cpbi(prBalanceX18, amBalanceX18)
442	440		let curPrice = f1(curPriceX18, scale8)
443	441		let pmtLpAmtX18 = t1(pmtLpAmt, scale8)
444	442		let lpEmissX18 = t1(lpEmiss, scale8)
445	443		let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissX18)
446	444		let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissX18)
447	445		let outAmAmt = fromX18Round(outAmAmtX18, amDcm, FLOOR)
448	446		let outPrAmt = fromX18Round(outPrAmtX18, prDcm, FLOOR)
449	447		let state = if ((txId58 == ""))
450	448		then nil
451	449		else [ScriptTransfer(userAddress, outAmAmt, if ((amId == "WAVES"))
452	450		then unit
453	451		else fromBase58String(amId)), ScriptTransfer(userAddress, outPrAmt, if ((prId == "WAVES"))
454	452		then unit
455	453		else fromBase58String(prId)), StringEntry(gau(toString(userAddress), txId58), dataGetActionInfo(outAmAmt, outPrAmt, pmtLpAmt, curPrice, height, lastBlock.timestamp)), IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice)]
456	454		$Tuple10(outAmAmt, outPrAmt, amId, prId, amBalance, prBalance, lpEmiss, curPriceX18, sts, state)
457	455		}
458	456		}
459	457
460	458
461	459		func epo (txId58,slippage,inAmAmt,inAmId,inPrAmt,inPrId,userAddress,isEval,emitLp,isOneAsset,validateSlippage,pmtAmt,pmtId) = {
462	460		let lpId = cfgLpAssetId
463	461		let amIdStr = toBase58String(value(cfgAmountAssetId))
464	462		let prIdStr = toBase58String(value(cfgPriceAssetId))
465		-	let inAmIdStr = cfgInAmountAssedId
466		-	let inPrIdStr = cfgInPriceAssetId
467	463		let amtDcm = cfgAmountAssetDecimals
468	464		let priceDcm = cfgPriceAssetDecimals
469	465		let sts = toString(cfgPoolStatus)
470	466		let lpEm = valueOrErrorMessage(assetInfo(lpId), "Wr lp as").quantity
471	467		let amBalance = if (isEval)
472	468		then getAccBalance(amIdStr)
473	469		else if (if (isOneAsset)
474	470		then (pmtId == amIdStr)
475	471		else false)
476	472		then (getAccBalance(amIdStr) - pmtAmt)
477	473		else if (isOneAsset)
478	474		then getAccBalance(amIdStr)
479	475		else (getAccBalance(amIdStr) - inAmAmt)
480	476		let prBalance = if (isEval)
481	477		then getAccBalance(prIdStr)
482	478		else if (if (isOneAsset)
483	479		then (pmtId == prIdStr)
484	480		else false)
485	481		then (getAccBalance(prIdStr) - pmtAmt)
486	482		else if (isOneAsset)

github/deemru/w8io/026f985 
318.26 ms ◑