tx · 2zgdk9hXGmnEVrZ2yEa4byHxrwZtiLwVW5TBCLYYrvbm

3P3Y38zymCHoTM6qcE9JcEA8rhaGTQbVMgu:  -0.04200000 Waves

2023.04.14 10:49 [3599554] smart account 3P3Y38zymCHoTM6qcE9JcEA8rhaGTQbVMgu > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "2zgdk9hXGmnEVrZ2yEa4byHxrwZtiLwVW5TBCLYYrvbm",
    "fee": 4200000,
    "feeAssetId": null,
    "timestamp": 1681458577169,
    "version": 2,
    "chainId": 87,
    "sender": "3P3Y38zymCHoTM6qcE9JcEA8rhaGTQbVMgu",
    "senderPublicKey": "CC44CoqmZoJUL984AgQ5WmsUxBjMoHuRwXpLzSQsNhqB",
    "proofs": [
        "5em72ZP2xk7DuR9E3qwQdGpmPVU3gcKGkon1TkeqrgBdYoUp9kKQqrSMq2QFqX3rqfNBXteEZbSnxqfYvbEvtPRM"
    ],
    "script": "base64:BgK9NwgCEgASBQoDAQQBEgcKBQEEAQgBEgMKAQgSABIECgIBBBIDCgEBEgQKAgEEEgQKAggBEgQKAggBEgQKAggBEgUKAwEIARIAEgQKAgEBEgMKAQESBQoDAQEBEgQKAggIEgASABIDCgEIEgUKAwEBARIECgIBARIECgIIARIECgIICBILCgkIAQECAQIIBAQSBgoECAgBCBIAEgMKAQESAwoBARIECgIIASIKbFBkZWNpbWFscyIGc2NhbGU4IgxzY2FsZThCaWdJbnQiB3NjYWxlMTgiCnplcm9CaWdJbnQiBGJpZzAiBGJpZzEiBGJpZzIiC3dhdmVzU3RyaW5nIgNTRVAiClBvb2xBY3RpdmUiD1Bvb2xQdXREaXNhYmxlZCITUG9vbE1hdGNoZXJEaXNhYmxlZCIMUG9vbFNodXRkb3duIg5pZHhQb29sQWRkcmVzcyINaWR4UG9vbFN0YXR1cyIQaWR4UG9vbExQQXNzZXRJZCINaWR4QW10QXNzZXRJZCIPaWR4UHJpY2VBc3NldElkIg5pZHhBbXRBc3NldERjbSIQaWR4UHJpY2VBc3NldERjbSIOaWR4SUFtdEFzc2V0SWQiEGlkeElQcmljZUFzc2V0SWQiDWlkeExQQXNzZXREY20iEmlkeFBvb2xBbXRBc3NldEFtdCIUaWR4UG9vbFByaWNlQXNzZXRBbXQiEWlkeFBvb2xMUEFzc2V0QW10IhlpZHhGYWN0b3J5U3Rha2luZ0NvbnRyYWN0IhppZHhGYWN0b3J5U2xpcHBhZ2VDb250cmFjdCIFdG9YMTgiB29yaWdWYWwiDW9yaWdTY2FsZU11bHQiC3RvWDE4QmlnSW50Igdmcm9tWDE4IgN2YWwiD3Jlc3VsdFNjYWxlTXVsdCIMZnJvbVgxOFJvdW5kIgVyb3VuZCIHdG9TY2FsZSIDYW10IghyZXNTY2FsZSIIY3VyU2NhbGUiA2FicyIJYWJzQmlnSW50Igxzd2FwQ29udHJhY3QiAmZjIgNtcGsiBHBtcGsiAnBsIgJwaCIBaCIJdGltZXN0YW1wIgNwYXUiC3VzZXJBZGRyZXNzIgR0eElkIgNnYXUiAmFhIgJwYSIGa2V5RmVlIgpmZWVEZWZhdWx0IgNmZWUiBmtleUtMcCIVa2V5S0xwUmVmcmVzaGVkSGVpZ2h0IhJrZXlLTHBSZWZyZXNoRGVsYXkiFmtMcFJlZnJlc2hEZWxheURlZmF1bHQiD2tMcFJlZnJlc2hEZWxheSIUa2V5QWRkaXRpb25hbEJhbGFuY2UiB2Fzc2V0SWQiFmtleVN0YWtpbmdBc3NldEJhbGFuY2UiGmdldEFkZGl0aW9uYWxCYWxhbmNlT3JaZXJvIhxnZXRTdGFraW5nQXNzZXRCYWxhbmNlT3JaZXJvIhBrZXlGYWN0b3J5Q29uZmlnIg1rZXlNYXRjaGVyUHViIilrZXlNYXBwaW5nUG9vbENvbnRyYWN0QWRkcmVzc1RvUG9vbEFzc2V0cyITcG9vbENvbnRyYWN0QWRkcmVzcyINa2V5UG9vbENvbmZpZyIJaUFtdEFzc2V0IgtpUHJpY2VBc3NldCIfa2V5TWFwcGluZ3NCYXNlQXNzZXQyaW50ZXJuYWxJZCIMYmFzZUFzc2V0U3RyIhNrZXlBbGxQb29sc1NodXRkb3duIg1rZXlQb29sV2VpZ2h0Ig9jb250cmFjdEFkZHJlc3MiFmtleUFsbG93ZWRMcFNjcmlwdEhhc2giFmtleUZlZUNvbGxlY3RvckFkZHJlc3MiD3Rocm93T3JkZXJFcnJvciIKb3JkZXJWYWxpZCIOb3JkZXJWYWxpZEluZm8iC3NlbmRlclZhbGlkIgxtYXRjaGVyVmFsaWQiD2dldFN0cmluZ09yRmFpbCIHYWRkcmVzcyIDa2V5IgxnZXRJbnRPckZhaWwiCHRocm93RXJyIgNtc2ciBmZtdEVyciIPZmFjdG9yeUNvbnRyYWN0IhNmZWVDb2xsZWN0b3JBZGRyZXNzIgVpbkZlZSIBQCIGb3V0RmVlIhBpc0dsb2JhbFNodXRkb3duIhNnZXRNYXRjaGVyUHViT3JGYWlsIg1nZXRQb29sQ29uZmlnIghhbXRBc3NldCIKcHJpY2VBc3NldCIMcGFyc2VBc3NldElkIgVpbnB1dCIPYXNzZXRJZFRvU3RyaW5nIg9wYXJzZVBvb2xDb25maWciCnBvb2xDb25maWciEHBvb2xDb25maWdQYXJzZWQiCyR0MDg5NjI5MTI4Ig5jZmdQb29sQWRkcmVzcyINY2ZnUG9vbFN0YXR1cyIMY2ZnTHBBc3NldElkIhBjZmdBbW91bnRBc3NldElkIg9jZmdQcmljZUFzc2V0SWQiFmNmZ0Ftb3VudEFzc2V0RGVjaW1hbHMiFWNmZ1ByaWNlQXNzZXREZWNpbWFscyIQZ2V0RmFjdG9yeUNvbmZpZyIPc3Rha2luZ0NvbnRyYWN0IhBzbGlwcGFnZUNvbnRyYWN0IhFkYXRhUHV0QWN0aW9uSW5mbyINaW5BbXRBc3NldEFtdCIPaW5QcmljZUFzc2V0QW10IghvdXRMcEFtdCIFcHJpY2UiHXNsaXBwYWdlVG9sZXJhbmNlUGFzc2VkQnlVc2VyIhVzbGlwcGFnZVRvbGVyYW5jZVJlYWwiCHR4SGVpZ2h0Igt0eFRpbWVzdGFtcCISc2xpcGFnZUFtdEFzc2V0QW10IhRzbGlwYWdlUHJpY2VBc3NldEFtdCIRZGF0YUdldEFjdGlvbkluZm8iDm91dEFtdEFzc2V0QW10IhBvdXRQcmljZUFzc2V0QW10IgdpbkxwQW10Ig1nZXRBY2NCYWxhbmNlIg1iYWxhbmNlT25Qb29sIgx0b3RhbEJhbGFuY2UiD2NhbGNQcmljZUJpZ0ludCIIcHJBbXRYMTgiCGFtQW10WDE4IhRjYWxjUHJpY2VCaWdJbnRSb3VuZCIHZ2V0UmF0ZSIFcHJveHkiA2ludiIHJG1hdGNoMCIBciIHZGVwb3NpdCIGYW1vdW50Ig5zdGFraW5nQXNzZXRJZCIYY3VycmVudEFkZGl0aW9uYWxCYWxhbmNlIhpjdXJyZW50U3Rha2luZ0Fzc2V0QmFsYW5jZSIFYXNzZXQiDWRlcG9zaXRJbnZva2UiFHJlY2VpdmVkU3Rha2luZ0Fzc2V0IhRuZXdBZGRpdGlvbmFsQmFsYW5jZSIWbmV3U3Rha2luZ0Fzc2V0QmFsYW5jZSIId2l0aGRyYXciDHByb3h5UmF0ZU11bCINcHJvZml0QWRkcmVzcyIQY3VycmVudFByb3h5UmF0ZSIHb2xkUmF0ZSIMc3Rha2luZ0Fzc2V0IhRvbGRTZW5kU3Rha2luZ0Ftb3VudCIWc2VuZFN0YWtpbmdBc3NldEFtb3VudCIMcHJvZml0QW1vdW50Ig53aXRoZHJhd0ludm9rZSIOcmVjZWl2ZWRBc3NldHMiE2dldExlYXNlUHJveHlDb25maWciAWEiEXJlYmFsYW5jZUludGVybmFsIgt0YXJnZXRSYXRpbyIKbWluQmFsYW5jZSIUbGVhc2FibGVUb3RhbEJhbGFuY2UiF3RhcmdldEFkZGl0aW9uYWxCYWxhbmNlIgRkaWZmIg9zZW5kQXNzZXRBbW91bnQiDmdldEFzc2V0QW1vdW50Ig5yZWJhbGFuY2VBc3NldCINJHQwMTUzNjQxNTUwMCIKaXNMZWFzYWJsZSILbGVhc2VkUmF0aW8iDHByb3h5QWRkcmVzcyIMcHJveHlBc3NldElkIhRzdGFraW5nUHJvZml0QWRkcmVzcyIZd2l0aGRyYXdBbmRSZWJhbGFuY2VBc3NldCIJZ2V0QW1vdW50Ig0kdDAxNTg5OTE2MDM1IhduZXdUb3RhbExlYXNhYmxlQmFsYW5jZSIOd2l0aGRyYXdBbW91bnQiF3dpdGhkcmF3QW5kUmViYWxhbmNlQWxsIhRhbW91bnRBc3NldE91dEFtb3VudCITcHJpY2VBc3NldE91dEFtb3VudCISQW1BbXRXaXRoZHJhd1N0YXRlIhJQckFtdFdpdGhkcmF3U3RhdGUiEHByaXZhdGVDYWxjUHJpY2UiCmFtQXNzZXREY20iCnByQXNzZXREY20iBWFtQW10IgVwckFtdCIOYW10QXNzZXRBbXRYMTgiEHByaWNlQXNzZXRBbXRYMTgiCmNhbGNQcmljZXMiBWxwQW10IgNjZmciC2FtdEFzc2V0RGNtIg1wcmljZUFzc2V0RGNtIghwcmljZVgxOCIIbHBBbXRYMTgiE2xwUHJpY2VJbkFtQXNzZXRYMTgiE2xwUHJpY2VJblByQXNzZXRYMTgiD2NhbGN1bGF0ZVByaWNlcyIGcHJpY2VzIhRlc3RpbWF0ZUdldE9wZXJhdGlvbiIGdHhJZDU4IgpwbXRBc3NldElkIghwbXRMcEFtdCIJbHBBc3NldElkIglhbUFzc2V0SWQiCXByQXNzZXRJZCIKcG9vbFN0YXR1cyIKbHBFbWlzc2lvbiIJYW1CYWxhbmNlIgxhbUJhbGFuY2VYMTgiCXByQmFsYW5jZSIMcHJCYWxhbmNlWDE4IgtjdXJQcmljZVgxOCIIY3VyUHJpY2UiC3BtdExwQW10WDE4Ig1scEVtaXNzaW9uWDE4IgtvdXRBbUFtdFgxOCILb3V0UHJBbXRYMTgiCG91dEFtQW10IghvdXRQckFtdCIFc3RhdGUiFGVzdGltYXRlUHV0T3BlcmF0aW9uIhFzbGlwcGFnZVRvbGVyYW5jZSIMaW5BbUFzc2V0QW10IgtpbkFtQXNzZXRJZCIMaW5QckFzc2V0QW10IgtpblByQXNzZXRJZCIKaXNFdmFsdWF0ZSIGZW1pdExwIgxhbUFzc2V0SWRTdHIiDHByQXNzZXRJZFN0ciILaUFtdEFzc2V0SWQiDWlQcmljZUFzc2V0SWQiDmluQW1Bc3NldElkU3RyIg5pblByQXNzZXRJZFN0ciIPaW5BbUFzc2V0QW10WDE4Ig9pblByQXNzZXRBbXRYMTgiDHVzZXJQcmljZVgxOCIDcmVzIgtzbGlwcGFnZVgxOCIUc2xpcHBhZ2VUb2xlcmFuY2VYMTgiCnByVmlhQW1YMTgiCmFtVmlhUHJYMTgiDGV4cGVjdGVkQW10cyIRZXhwQW10QXNzZXRBbXRYMTgiE2V4cFByaWNlQXNzZXRBbXRYMTgiCWNhbGNMcEFtdCIOY2FsY0FtQXNzZXRQbXQiDmNhbGNQckFzc2V0UG10IgxzbGlwcGFnZUNhbGMiCWVtaXRMcEFtdCIGYW1EaWZmIgZwckRpZmYiC2NvbW1vblN0YXRlIgdjYWxjS0xwIg1hbW91bnRCYWxhbmNlIgxwcmljZUJhbGFuY2UiEGFtb3VudEJhbGFuY2VYMTgiD3ByaWNlQmFsYW5jZVgxOCIKdXBkYXRlZEtMcCIOY2FsY0N1cnJlbnRLTHAiEGFtb3VudEFzc2V0RGVsdGEiD3ByaWNlQXNzZXREZWx0YSIUbHBBc3NldEVtaXNzaW9uRGVsdGEiEmFtb3VudEFzc2V0QmFsYW5jZSIRcHJpY2VBc3NldEJhbGFuY2UiD2xwQXNzZXRFbWlzc2lvbiIKY3VycmVudEtMcCIScmVmcmVzaEtMcEludGVybmFsIhdhbW91bnRBc3NldEJhbGFuY2VEZWx0YSIWcHJpY2VBc3NldEJhbGFuY2VEZWx0YSIHYWN0aW9ucyISdmFsaWRhdGVVcGRhdGVkS0xwIgZvbGRLTHAiG3ZhbGlkYXRlTWF0Y2hlck9yZGVyQWxsb3dlZCIFb3JkZXIiEWFtb3VudEFzc2V0QW1vdW50IhBwcmljZUFzc2V0QW1vdW50Ig0kdDAyODMwMTI4NTEzIgNrTHAiDSR0MDI4OTUzMjkwNTMiDXVudXNlZEFjdGlvbnMiBmtMcE5ldyIMaXNPcmRlclZhbGlkIgRpbmZvIgljb21tb25HZXQiAWkiA3BtdCIGcG10QW10Igljb21tb25QdXQiCmFtQXNzZXRQbXQiCnByQXNzZXRQbXQiBmVzdFB1dCIEZW1pdCIHZW1pdEludiINZW1pdEludkxlZ2FjeSIVbGVnYWN5RmFjdG9yeUNvbnRyYWN0Igd0YWtlRmVlIglmZWVBbW91bnQiD2NhbGNQdXRPbmVUb2tlbiIQcGF5bWVudEFtb3VudFJhdyIOcGF5bWVudEFzc2V0SWQiBmlzRXZhbCIQYW1vdW50QmFsYW5jZVJhdyIPcHJpY2VCYWxhbmNlUmF3IhRwYXltZW50SW5BbW91bnRBc3NldCINJHQwMzIxNjYzMjQ1OSIQYW1vdW50QmFsYW5jZU9sZCIPcHJpY2VCYWxhbmNlT2xkIg0kdDAzMjQ2MzMyNjEyIhRhbW91bnRBc3NldEFtb3VudFJhdyITcHJpY2VBc3NldEFtb3VudFJhdyINJHQwMzI3NDQzMjgwOCINcGF5bWVudEFtb3VudCIQYW1vdW50QmFsYW5jZU5ldyIPcHJpY2VCYWxhbmNlTmV3IgtwcmljZU5ld1gxOCIIcHJpY2VOZXciDnBheW1lbnRCYWxhbmNlIhRwYXltZW50QmFsYW5jZUJpZ0ludCIMc3VwcGx5QmlnSW50IgtjaGVjaFN1cHBseSINZGVwb3NpdEJpZ0ludCILaXNzdWVBbW91bnQiC3ByaWNlT2xkWDE4IghwcmljZU9sZCIEbG9zcyINJHQwMzQ0ODkzNDY1NiIHYmFsYW5jZSIPaXNzdWVBbW91bnRCb3RoIg9jYWxjR2V0T25lVG9rZW4iCm91dEFzc2V0SWQiBmNoZWNrcyIQb3V0SW5BbW91bnRBc3NldCINYmFsYW5jZUJpZ0ludCIYb3V0SW5BbW91bnRBc3NldERlY2ltYWxzIgxhbUJhbGFuY2VPbGQiDHByQmFsYW5jZU9sZCIKb3V0QmFsYW5jZSIQb3V0QmFsYW5jZUJpZ0ludCIOcmVkZWVtZWRCaWdJbnQiCWFtb3VudFJhdyINJHQwMzY3MzQzNjc5MCILdG90YWxBbW91bnQiDSR0MDM2Nzk0MzcwMjAiC291dEFtQW1vdW50IgtvdXRQckFtb3VudCIMYW1CYWxhbmNlTmV3IgxwckJhbGFuY2VOZXciGGFtb3VudEJvdGhJblBheW1lbnRBc3NldCIWbWFuYWdlclB1YmxpY0tleU9yVW5pdCIBcyIdcGVuZGluZ01hbmFnZXJQdWJsaWNLZXlPclVuaXQiCWlzTWFuYWdlciICcGsiC211c3RNYW5hZ2VyIgJwZCINY2xlYW5BbW91bnRJbiIJaXNSZXZlcnNlIg1mZWVQb29sQW1vdW50Ig0kdDAzODkwNjM5MjExIghhc3NldE91dCIHYXNzZXRJbiIScG9vbEFzc2V0SW5CYWxhbmNlIhNwb29sQXNzZXRPdXRCYWxhbmNlIglhbW91bnRPdXQiBG9sZEsiBG5ld0siBmNoZWNrSyIMYW1vdW50T3V0TWluIglhZGRyZXNzVG8iC3N3YXBDb250YWN0IghjaGVja01pbiIOcmViYWxhbmNlU3RhdGUiDXdpdGhkcmF3U3RhdGUiF3BlbmRpbmdNYW5hZ2VyUHVibGljS2V5IgtjaGVja0NhbGxlciIVY2hlY2tNYW5hZ2VyUHVibGljS2V5IgJwbSIFaGFzUE0iB2NoZWNrUE0iD3Nob3VsZEF1dG9TdGFrZSIEYW1JZCIEcHJJZCIMc2xpcHBhZ2VBSW52IgxzbGlwcGFnZVBJbnYiCmxwVHJhbnNmZXIiC3NscFN0YWtlSW52Ig0kdDA0NDI1NzQ0NzE5IhFyZWZyZXNoS0xwQWN0aW9ucyIRaXNVcGRhdGVkS0xwVmFsaWQiA3JlYiILbWF4U2xpcHBhZ2UiDSR0MDQ1MzMxNDUzOTYiDG1pbk91dEFtb3VudCIJYXV0b1N0YWtlIiBpc1Bvb2xPbmVUb2tlbk9wZXJhdGlvbnNEaXNhYmxlZCINaXNQdXREaXNhYmxlZCIHcGF5bWVudCINJHQwNDY1ODQ0NjczNiIFYm9udXMiE2VtaXRBbW91bnRFc3RpbWF0ZWQiCmVtaXRBbW91bnQiCHN0YWtlSW52IgdzZW5kRmVlIg0kdDA0NzMyMjQ3NTE5Ig0kdDA0NzUyMjQ3NjMwIg0kdDA0Nzk4NTQ4MTQyIg1vdXRBc3NldElkU3RyIg1pc0dldERpc2FibGVkIg0kdDA0OTAyNzQ5MTgwIg9hbW91bnRFc3RpbWF0ZWQiB2J1cm5JbnYiDWFzc2V0VHJhbnNmZXIiDSR0MDQ5ODQ0NTAwOTEiEGZlZUFtb3VudEZvckNhbGMiDSR0MDUwMDk0NTAyMDIiDSR0MDUwNDgwNTA2MzYiDXVuc3Rha2VBbW91bnQiCnVuc3Rha2VJbnYiDSR0MDUxNTQxNTE2OTIiDSR0MDUyMzUxNTI1OTgiDSR0MDUyNjAxNTI3MDkiFGJ1cm5MUEFzc2V0T25GYWN0b3J5Ig0kdDA1MzgwNDUzODg1IhJub0xlc3NUaGVuQW10QXNzZXQiFG5vTGVzc1RoZW5QcmljZUFzc2V0Ig0kdDA1NDk4MDU1MDYxIg1jaGVja1BheW1lbnRzIg9jaGVja1Bvb2xTdGF0dXMiDSR0MDU2MzMzNTY0MTQiFW5vTGVzc1RoZW5BbW91bnRBc3NldCIMY2hlY2tBbW91bnRzIg0kdDA1Nzg1NTU3OTM2IgthbXRBc3NldFN0ciINcHJpY2VBc3NldFN0ciIYbGFzdFJlZnJlc2hlZEJsb2NrSGVpZ2h0Ih1jaGVja0xhc3RSZWZyZXNoZWRCbG9ja0hlaWdodCINJHQwNTkxNDA1OTIwNCIQa0xwVXBkYXRlQWN0aW9ucyIKYW10QXNzZXRJZCIMcHJpY2VBc3NldElkIg1wb29sTFBCYWxhbmNlIhJhY2NBbXRBc3NldEJhbGFuY2UiFGFjY1ByaWNlQXNzZXRCYWxhbmNlIgpwcmljZXNMaXN0Ig9scEFtdEFzc2V0U2hhcmUiEWxwUHJpY2VBc3NldFNoYXJlIgpwb29sV2VpZ2h0IgxjdXJQcmljZUNhbGMiDGFtQmFsYW5jZVJhdyIMcHJCYWxhbmNlUmF3Ig9hbUJhbGFuY2VSYXdYMTgiD3ByQmFsYW5jZVJhd1gxOCIQcGF5bWVudExwQXNzZXRJZCIMcGF5bWVudExwQW10IgJ0eCIGdmVyaWZ5Ig90YXJnZXRQdWJsaWNLZXkiCm1hdGNoZXJQdWIiDSR0MDY3ODY2Njc5MzUiB25ld0hhc2giC2FsbG93ZWRIYXNoIgtjdXJyZW50SGFzaH8AAWEACAABYgCAwtcvAAFjCQC2AgEAgMLXLwABZAkAtgIBAICAkLu61q3wDQABZQkAtgIBAAAAAWYJALYCAQAAAAFnCQC2AgEAAQABaAkAtgIBAAIAAWkCBVdBVkVTAAFqAgJfXwABawABAAFsAAIAAW0AAwABbgAEAAFvAAEAAXAAAgABcQADAAFyAAQAAXMABQABdAAGAAF1AAcAAXYACAABdwAJAAF4AAoAAXkAAQABegACAAFBAAMAAUIAAQABQwAHAQFEAgFFAUYJALwCAwkAtgIBBQFFBQFkCQC2AgEFAUYBAUcCAUUBRgkAvAIDBQFFBQFkBQFGAQFIAgFJAUoJAKADAQkAvAIDBQFJCQC2AgEFAUoFAWQBAUsDAUkBSgFMCQCgAwEJAL0CBAUBSQkAtgIBBQFKBQFkBQFMAQFNAwFOAU8BUAkAawMFAU4FAU8FAVABAVEBAUkDCQBmAgAABQFJCQEBLQEFAUkFAUkBAVIBAUkDCQC/AgIFAWUFAUkJAL4CAQUBSQUBSQEBUwACECVzX19zd2FwQ29udHJhY3QBAVQAAhMlc19fZmFjdG9yeUNvbnRyYWN0AQFVAAIUJXNfX21hbmFnZXJQdWJsaWNLZXkBAVYAAhslc19fcGVuZGluZ01hbmFnZXJQdWJsaWNLZXkBAVcAAhElcyVzX19wcmljZV9fbGFzdAEBWAIBWQFaCQC5CQIJAMwIAgIYJXMlcyVkJWRfX3ByaWNlX19oaXN0b3J5CQDMCAIJAKQDAQUBWQkAzAgCCQCkAwEFAVoFA25pbAUBagECYWECAmFiAmFjCQCsAgIJAKwCAgkArAICAgslcyVzJXNfX1BfXwUCYWICAl9fBQJhYwECYWQCAmFiAmFjCQCsAgIJAKwCAgkArAICAgslcyVzJXNfX0dfXwUCYWICAl9fBQJhYwECYWUAAg8lc19fYW1vdW50QXNzZXQBAmFmAAIOJXNfX3ByaWNlQXNzZXQAAmFnAgclc19fZmVlAAJhaAkAawMACgUBYgCQTgACYWkJAQt2YWx1ZU9yRWxzZQIJAJoIAgUEdGhpcwUCYWcFAmFoAAJhagkAuQkCCQDMCAICAiVzCQDMCAICA2tMcAUDbmlsBQFqAAJhawkAuQkCCQDMCAICAiVzCQDMCAICEmtMcFJlZnJlc2hlZEhlaWdodAUDbmlsBQFqAAJhbAkAuQkCCQDMCAICAiVzCQDMCAICD3JlZnJlc2hLTHBEZWxheQUDbmlsBQFqAAJhbQAeAAJhbgkBC3ZhbHVlT3JFbHNlAgkAmggCBQR0aGlzBQJhbAUCYW0BAmFvAQJhcAkAuQkCCQDMCAICBCVzJXMJAMwIAgINc3Rha2VkQmFsYW5jZQkAzAgCBQJhcAUDbmlsBQFqAQJhcQECYXAJALkJAgkAzAgCAgQlcyVzCQDMCAICEXNoYXJlQXNzZXRCYWxhbmNlCQDMCAIFAmFwBQNuaWwFAWoBAmFyAQJhcAkBC3ZhbHVlT3JFbHNlAgkAmggCBQR0aGlzCQECYW8BBQJhcAAAAQJhcwECYXAJAQt2YWx1ZU9yRWxzZQIJAJoIAgUEdGhpcwkBAmFxAQUCYXAAAAECYXQAAhElc19fZmFjdG9yeUNvbmZpZwECYXUAAhglcyVzX19tYXRjaGVyX19wdWJsaWNLZXkBAmF2AQJhdwkArAICCQCsAgICCCVzJXMlc19fBQJhdwIgX19tYXBwaW5nc19fcG9vbENvbnRyYWN0MkxwQXNzZXQBAmF4AgJheQJhegkArAICCQCsAgIJAKwCAgkArAICAgglZCVkJXNfXwUCYXkCAl9fBQJhegIIX19jb25maWcBAmFBAQJhQgkArAICAiglcyVzJXNfX21hcHBpbmdzX19iYXNlQXNzZXQyaW50ZXJuYWxJZF9fBQJhQgECYUMAAgwlc19fc2h1dGRvd24BAmFEAQJhRQkArAICAhIlcyVzX19wb29sV2VpZ2h0X18FAmFFAQJhRgACFyVzX19hbGxvd2VkTHBTY3JpcHRIYXNoAAJhRwIXJXNfX2ZlZUNvbGxlY3RvckFkZHJlc3MBAmFIBAJhSQJhSgJhSwJhTAkAAgEJAKwCAgkArAICCQCsAgIJAKwCAgkArAICCQCsAgIJAKwCAgkArAICAiRvcmRlciB2YWxpZGF0aW9uIGZhaWxlZDogb3JkZXJWYWxpZD0JAKUDAQUCYUkCAiAoBQJhSgIBKQINIHNlbmRlclZhbGlkPQkApQMBBQJhSwIOIG1hdGNoZXJWYWxpZD0JAKUDAQUCYUwBAmFNAgJhTgJhTwkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCdCAIFAmFOBQJhTwkAuQkCCQDMCAICCm1hbmRhdG9yeSAJAMwIAgkApQgBBQJhTgkAzAgCAgEuCQDMCAIFAmFPCQDMCAICDyBpcyBub3QgZGVmaW5lZAUDbmlsAgABAmFQAgJhTgJhTwkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCaCAIFAmFOBQJhTwkAuQkCCQDMCAICCm1hbmRhdG9yeSAJAMwIAgkApQgBBQJhTgkAzAgCAgEuCQDMCAIFAmFPCQDMCAICDyBpcyBub3QgZGVmaW5lZAUDbmlsAgABAmFRAQJhUgkAAgEJALkJAgkAzAgCAghscC5yaWRlOgkAzAgCBQJhUgUDbmlsAgEgAQJhUwECYVIJALkJAgkAzAgCAghscC5yaWRlOgkAzAgCBQJhUgUDbmlsAgEgAAJhVAkBEUBleHRyTmF0aXZlKDEwNjIpAQkBAmFNAgUEdGhpcwkBAVQAAAJhVQkBEUBleHRyTmF0aXZlKDEwNjIpAQkBAmFNAgUCYVQFAmFHAAJhVgoAAmFXCQD8BwQFAmFUAhBnZXRJbkZlZVJFQURPTkxZCQDMCAIJAKUIAQUEdGhpcwUDbmlsBQNuaWwDCQABAgUCYVcCA0ludAUCYVcJAAIBCQCsAgIJAAMBBQJhVwIYIGNvdWxkbid0IGJlIGNhc3QgdG8gSW50AAJhWAoAAmFXCQD8BwQFAmFUAhFnZXRPdXRGZWVSRUFET05MWQkAzAgCCQClCAEFBHRoaXMFA25pbAUDbmlsAwkAAQIFAmFXAgNJbnQFAmFXCQACAQkArAICCQADAQUCYVcCGCBjb3VsZG4ndCBiZSBjYXN0IHRvIEludAECYVkACQELdmFsdWVPckVsc2UCCQCbCAIFAmFUCQECYUMABwECYVoACQDZBAEJAQJhTQIFAmFUCQECYXUAAQJiYQAEAmJiCQECYU0CBQR0aGlzCQECYWUABAJiYwkBAmFNAgUEdGhpcwkBAmFmAAQCYXoJAQJhUAIFAmFUCQECYUEBBQJiYwQCYXkJAQJhUAIFAmFUCQECYUEBBQJiYgkAtQkCCQECYU0CBQJhVAkBAmF4AgkApAMBBQJheQkApAMBBQJhegUBagECYmQBAmJlAwkAAAIFAmJlBQFpBQR1bml0CQDZBAEFAmJlAQJiZgECYmUDCQAAAgUCYmUFBHVuaXQFAWkJANgEAQkBBXZhbHVlAQUCYmUBAmJnAQJiaAkAmQoHCQERQGV4dHJOYXRpdmUoMTA2MikBCQCRAwIFAmJoBQFvCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUCYmgFAXAJANkEAQkAkQMCBQJiaAUBcQkBAmJkAQkAkQMCBQJiaAUBcgkBAmJkAQkAkQMCBQJiaAUBcwkBDXBhcnNlSW50VmFsdWUBCQCRAwIFAmJoBQF0CQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUCYmgFAXUAAmJpCQECYmcBCQECYmEAAAJiagUCYmkAAmJrCAUCYmoCXzEAAmJsCAUCYmoCXzIAAmJtCAUCYmoCXzMAAmJuCAUCYmoCXzQAAmJvCAUCYmoCXzUAAmJwCAUCYmoCXzYAAmJxCAUCYmoCXzcBAmJyAAkAtQkCCQECYU0CBQJhVAkBAmF0AAUBagACYnMJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkApggBCQCRAwIJAQJicgAFAUICGWluY29ycmVjdCBzdGFraW5nIGFkZHJlc3MAAmJ0CQETdmFsdWVPckVycm9yTWVzc2FnZQIJAKYIAQkAkQMCCQECYnIABQFDAhlpbmNvcnJlY3Qgc3Rha2luZyBhZGRyZXNzAQJidQoCYnYCYncCYngCYnkCYnoCYkECYkICYkMCYkQCYkUJALkJAgkAzAgCAhQlZCVkJWQlZCVkJWQlZCVkJWQlZAkAzAgCCQCkAwEFAmJ2CQDMCAIJAKQDAQUCYncJAMwIAgkApAMBBQJieAkAzAgCCQCkAwEFAmJ5CQDMCAIJAKQDAQUCYnoJAMwIAgkApAMBBQJiQQkAzAgCCQCkAwEFAmJCCQDMCAIJAKQDAQUCYkMJAMwIAgkApAMBBQJiRAkAzAgCCQCkAwEFAmJFBQNuaWwFAWoBAmJGBgJiRwJiSAJiSQJieQJiQgJiQwkAuQkCCQDMCAICDCVkJWQlZCVkJWQlZAkAzAgCCQCkAwEFAmJHCQDMCAIJAKQDAQUCYkgJAMwIAgkApAMBBQJiSQkAzAgCCQCkAwEFAmJ5CQDMCAIJAKQDAQUCYkIJAMwIAgkApAMBBQJiQwUDbmlsBQFqAQJiSgECYXAEAmJLAwkAAAIFAmFwAgVXQVZFUwgJAO8HAQUEdGhpcwlhdmFpbGFibGUJAPAHAgUEdGhpcwkA2QQBBQJhcAQCYkwJAGUCCQBkAgUCYksJAQJhcgEFAmFwCQECYXMBBQJhcAkAlgMBCQDMCAIAAAkAzAgCBQJiTAUDbmlsAQJiTQICYk4CYk8JALwCAwUCYk4FAWQFAmJPAQJiUAMCYk4CYk8BTAkAvQIEBQJiTgUBZAUCYk8FAUwBAmJRAQJiUgQCYlMJAPwHBAUCYlICB2dldFJhdGUFA25pbAUDbmlsAwkAAAIFAmJTBQJiUwQCYlQFAmJTAwkAAQIFAmJUAgNJbnQEAmJVBQJiVAUCYlUJAQJhUQECIHByb3h5LmdldFJhdGUoKSB1bmV4cGVjdGVkIHZhbHVlCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAQJiVgQCYXACYlcCYlgCYlIEAmJZCQECYXIBBQJhcAMJAAACBQJiWQUCYlkEAmJaCQECYXMBBQJiWAMJAAACBQJiWgUCYloEAmNhCQECYmQBBQJhcAMJAGYCBQJiVwAABAJjYgkA/AcEBQJiUgIHZGVwb3NpdAUDbmlsCQDMCAIJAQ9BdHRhY2hlZFBheW1lbnQCBQJjYQUCYlcFA25pbAMJAAACBQJjYgUCY2IEAmJUBQJjYgMJAAECBQJiVAIDSW50BAJjYwUCYlQEAmNkCQBkAgUCYlkFAmJXBAJjZQkAZAIFAmJaBQJjYwkAzAgCCQEMSW50ZWdlckVudHJ5AgkBAmFvAQUCYXAFAmNkCQDMCAIJAQxJbnRlZ2VyRW50cnkCCQECYXEBBQJiWAUCY2UFA25pbAUDbmlsCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuBQNuaWwJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BAmNmBgJhcAJiVwJiWAJiUgJjZwJjaAQCYlkJAQJhcgEFAmFwAwkAAAIFAmJZBQJiWQQCYloJAQJhcwEFAmJYAwkAAAIFAmJaBQJiWgQCY2kJAQJiUQEFAmJSAwkAAAIFAmNpBQJjaQQCY2oJAGsDBQJjZwUCYlkFAmJaBAJjawkBAmJkAQUCYlgEAmNsCQBrAwUCY2cFAmJXBQJjagQCY20JAGsDBQJjZwUCYlcFAmNpBAJjbgkAlgMBCQDMCAIAAAkAzAgCCQBlAgUCY2wFAmNtBQNuaWwDCQBmAgUCY20AAAQCY28JAPwHBAUCYlICCHdpdGhkcmF3BQNuaWwJAMwIAgkBD0F0dGFjaGVkUGF5bWVudAIFAmNrBQJjbQUDbmlsAwkAAAIFAmNvBQJjbwQCYlQFAmNvAwkAAQIFAmJUAgNJbnQEAmNwBQJiVAQCY2QJAGUCBQJiWQUCY3AEAmNlCQBlAgkAZQIFAmJaBQJjbQUCY24JAMwIAgkBDEludGVnZXJFbnRyeQIJAQJhbwEFAmFwBQJjZAkAzAgCCQEMSW50ZWdlckVudHJ5AgkBAmFxAQUCYlgFAmNlCQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMFAmNoBQJjbgkBAmJkAQUCYlgFA25pbAUDbmlsCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuBQNuaWwJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BAmNxAQJhcAQCYlQJAPwHBAUCYVQCGmdldFBvb2xMZWFzZUNvbmZpZ1JFQURPTkxZCQDMCAIJAKUIAQUEdGhpcwkAzAgCBQJhcAUDbmlsBQNuaWwDCQABAgUCYlQCMChCb29sZWFuLCBJbnQsIEludCwgU3RyaW5nLCBTdHJpbmcsIEludCwgU3RyaW5nKQQCY3IFAmJUBQJjcgkBAmFRAQkArAICCQCsAgICAVsFAmFwAh1dIGdldExlYXNlUHJveHlDb25maWcoKSBlcnJvcgECY3MHAmN0AmFwAmJYAmN1AmJSAmNnAmNoBAJiWQkBAmFyAQUCYXADCQAAAgUCYlkFAmJZBAJiWgkBAmFzAQUCYlgDCQAAAgUCYloFAmJaBAJjdgkAlgMBCQDMCAIAAAkAzAgCCQBlAgkBAmJKAQUCYXAFAmN1BQNuaWwEAmN3CQBrAwUCY3QFAmN2AGQEAmN4CQBlAgUCYlkFAmN3AwkAAAIFAmN4AAAFA25pbAMJAGYCAAAFAmN4BAJjeQkBAS0BBQJjeAkBAmJWBAUCYXAFAmN5BQJiWAUCYlIEAmN6BQJjeAkBAmNmBgUCYXAFAmN6BQJiWAUCYlIFAmNnBQJjaAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgECY0EBAmFwBAJjQgkBAmNxAQUCYXAEAmNDCAUCY0ICXzEEAmNECAUCY0ICXzIEAmN1CAUCY0ICXzMEAmNFCAUCY0ICXzQEAmNGCAUCY0ICXzUEAmNnCAUCY0ICXzYEAmNHCAUCY0ICXzcDBQJjQwkBAmNzBwUCY0QFAmFwBQJjRgUCY3UJARFAZXh0ck5hdGl2ZSgxMDYyKQEFAmNFBQJjZwkBEUBleHRyTmF0aXZlKDEwNjIpAQUCY0cFA25pbAECY0gCAmFwAmNJBAJjSgkBAmNxAQUCYXAEAmNDCAUCY0oCXzEEAmNECAUCY0oCXzIEAmN1CAUCY0oCXzMEAmNFCAUCY0oCXzQEAmNGCAUCY0oCXzUEAmNnCAUCY0oCXzYEAmNHCAUCY0oCXzcDBQJjQwQCY0sJAJYDAQkAzAgCAAAJAMwIAgkAZQIJAGUCCQECYkoBBQJhcAUCY0kFAmN1BQNuaWwDCQAAAgUCY0sFAmNLBAJjZAkAawMFAmNEBQJjSwBkAwkAAAIFAmNkBQJjZAQCY0wJAGUCCQECYXIBBQJhcAUCY2QDCQAAAgUCY0wFAmNMAwkAZgIAAAUCY0wJAQJiVgQFAmFwCQEBLQEFAmNMBQJjRgkBEUBleHRyTmF0aXZlKDEwNjIpAQUCY0UJAQJjZgYFAmFwBQJjTAUCY0YJARFAZXh0ck5hdGl2ZSgxMDYyKQEFAmNFBQJjZwkBEUBleHRyTmF0aXZlKDEwNjIpAQUCY0cJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4FA25pbAECY00CAmNOAmNPBAJjUAkBAmNIAgkBAmFNAgUEdGhpcwkBAmFlAAUCY04EAmNRCQECY0gCCQECYU0CBQR0aGlzCQECYWYABQJjTwkAzggCBQJjUAUCY1EBAmNSBAJjUwJjVAJjVQJjVgQCY1cJAQFEAgUCY1UFAmNTBAJjWAkBAUQCBQJjVgUCY1QJAQJiTQIFAmNYBQJjVwECY1kDAmNVAmNWAmNaBAJkYQkBAmJhAAQCZGIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQJkYQUBdAQCZGMJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQJkYQUBdQQCZGQJAQJjUgQFAmRiBQJkYwUCY1UFAmNWBAJiTwkBAUQCBQJjVQUCZGIEAmJOCQEBRAIFAmNWBQJkYwQCZGUJAQFEAgUCY1oFAWIEAmRmCQECYk0CBQJiTwUCZGUEAmRnCQECYk0CBQJiTgUCZGUJAMwIAgUCZGQJAMwIAgUCZGYJAMwIAgUCZGcFA25pbAECZGgDAmNVAmNWAmNaBAJkaQkBAmNZAwUCY1UFAmNWBQJjWgkAzAgCCQEBSAIJAJEDAgUCZGkAAAUBYgkAzAgCCQEBSAIJAJEDAgUCZGkAAQUBYgkAzAgCCQEBSAIJAJEDAgUCZGkAAgUBYgUDbmlsAQJkagQCZGsCZGwCZG0CYWIEAmRhCQECYmEABAJkbgkAkQMCBQJkYQUBcQQCZG8JAJEDAgUCZGEFAXIEAmRwCQCRAwIFAmRhBQFzBAJjUwkBDXBhcnNlSW50VmFsdWUBCQCRAwIFAmRhBQF0BAJjVAkBDXBhcnNlSW50VmFsdWUBCQCRAwIFAmRhBQF1BAJkcQkAkQMCBQJkYQUBcAQCZHIICQETdmFsdWVPckVycm9yTWVzc2FnZQIJAOwHAQkA2QQBBQJkbgkArAICCQCsAgICBkFzc2V0IAUCZG4CDiBkb2Vzbid0IGV4aXN0CHF1YW50aXR5AwkBAiE9AgUCZG4FAmRsCQACAQIVSW52YWxpZCBhc3NldCBwYXNzZWQuBAJkcwkBAmJKAQUCZG8EAmR0CQEBRAIFAmRzBQJjUwQCZHUJAQJiSgEFAmRwBAJkdgkBAUQCBQJkdQUCY1QEAmR3CQECYk0CBQJkdgUCZHQEAmR4CQEBSAIFAmR3BQFiBAJkeQkBAUQCBQJkbQUBYgQCZHoJAQFEAgUCZHIFAWIEAmRBCQC8AgMFAmR0BQJkeQUCZHoEAmRCCQC8AgMFAmR2BQJkeQUCZHoEAmRDCQEBSwMFAmRBBQJjUwUFRkxPT1IEAmRECQEBSwMFAmRCBQJjVAUFRkxPT1IEAmRFAwkAAAIFAmRrAgAFA25pbAkAzAgCCQEOU2NyaXB0VHJhbnNmZXIDBQJhYgUCZEMDCQAAAgUCZG8CBVdBVkVTBQR1bml0CQDZBAEFAmRvCQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMFAmFiBQJkRAMJAAACBQJkcAIFV0FWRVMFBHVuaXQJANkEAQUCZHAJAMwIAgkBC1N0cmluZ0VudHJ5AgkBAmFkAgkApQgBBQJhYgUCZGsJAQJiRgYFAmRDBQJkRAUCZG0FAmR4BQZoZWlnaHQIBQlsYXN0QmxvY2sJdGltZXN0YW1wCQDMCAIJAQxJbnRlZ2VyRW50cnkCCQEBVwAFAmR4CQDMCAIJAQxJbnRlZ2VyRW50cnkCCQEBWAIFBmhlaWdodAgFCWxhc3RCbG9jawl0aW1lc3RhbXAFAmR4BQNuaWwJAJwKCgUCZEMFAmREBQJkbwUCZHAFAmRzBQJkdQUCZHIFAmR3BQJkcQUCZEUBAmRGCQJkawJkRwJkSAJkSQJkSgJkSwJhYgJkTAJkTQQCZGEJAQJiYQAEAmRuCQDZBAEJAJEDAgUCZGEFAXEEAmROCQCRAwIFAmRhBQFyBAJkTwkAkQMCBQJkYQUBcwQCZFAJAJEDAgUCZGEFAXYEAmRRCQCRAwIFAmRhBQF3BAJkYgkBDXBhcnNlSW50VmFsdWUBCQCRAwIFAmRhBQF0BAJkYwkBDXBhcnNlSW50VmFsdWUBCQCRAwIFAmRhBQF1BAJkcQkAkQMCBQJkYQUBcAQCZHIICQETdmFsdWVPckVycm9yTWVzc2FnZQIJAOwHAQUCZG4JAKwCAgkArAICAgZBc3NldCAJANgEAQUCZG4CDiBkb2Vzbid0IGV4aXN0CHF1YW50aXR5BAJkUgkA2AQBCQELdmFsdWVPckVsc2UCBQJkSQkA2QQBAgVXQVZFUwQCZFMJANgEAQkBC3ZhbHVlT3JFbHNlAgUCZEsJANkEAQIFV0FWRVMDAwkBAiE9AgUCZE4FAmRSBgkBAiE9AgUCZE8FAmRTCQACAQIiSW52YWxpZCBhbXQgb3IgcHJpY2UgYXNzZXQgcGFzc2VkLgQCZHMDBQJkTAkBAmJKAQUCZE4JAGUCCQECYkoBBQJkTgUCZEgEAmR1AwUCZEwJAQJiSgEFAmRPCQBlAgkBAmJKAQUCZE8FAmRKBAJkVAkBAUQCBQJkSAUCZGIEAmRVCQEBRAIFAmRKBQJkYwQCZFYJAQJiTQIFAmRVBQJkVAQCZHQJAQFEAgUCZHMFAmRiBAJkdgkBAUQCBQJkdQUCZGMEAmRXAwkAAAIFAmRyAAAEAmR3BQFlBAJkWAUBZQQCZGUJAHYGCQC5AgIFAmRUBQJkVQAACQC2AgEABQABAAAFBERPV04JAJcKBQkBAUgCBQJkZQUBYgkBAUgCBQJkVAUCZGIJAQFIAgUCZFUFAmRjCQECYk0CCQC3AgIFAmR2BQJkVQkAtwICBQJkdAUCZFQFAmRYBAJkdwkBAmJNAgUCZHYFAmR0BAJkWAkAvAIDCQEBUgEJALgCAgUCZHcFAmRWBQFkBQJkdwQCZFkJAQFEAgUCZEcFAWIDAwkBAiE9AgUCZHcFAWUJAL8CAgUCZFgFAmRZBwkAAgEJAKwCAgkArAICCQCsAgICD1ByaWNlIHNsaXBwYWdlIAkApgMBBQJkWAIeIGV4Y2VlZGVkIHRoZSBwYXNzZWQgbGltaXQgb2YgCQCmAwEFAmRZBAJkegkBAUQCBQJkcgUBYgQCZFoJAL0CBAUCZFQJAQJiUAMFAmR2BQJkdAUHQ0VJTElORwUBZAUHQ0VJTElORwQCZWEJAL0CBAUCZFUFAWQJAQJiUAMFAmR2BQJkdAUFRkxPT1IFB0NFSUxJTkcEAmViAwkAvwICBQJkWgUCZFUJAJQKAgUCZWEFAmRVCQCUCgIFAmRUBQJkWgQCZWMIBQJlYgJfMQQCZWQIBQJlYgJfMgQCZGUJAL0CBAUCZHoFAmVkBQJkdgUFRkxPT1IJAJcKBQkBAUsDBQJkZQUBYgUFRkxPT1IJAQFLAwUCZWMFAmRiBQdDRUlMSU5HCQEBSwMFAmVkBQJkYwUHQ0VJTElORwUCZHcFAmRYBAJlZQgFAmRXAl8xBAJlZggFAmRXAl8yBAJlZwgFAmRXAl8zBAJkeAkBAUgCCAUCZFcCXzQFAWIEAmVoCQEBSAIIBQJkVwJfNQUBYgMJAGcCAAAFAmVlCQACAQI2SW52YWxpZCBjYWxjdWxhdGlvbnMuIExQIGNhbGN1bGF0ZWQgaXMgbGVzcyB0aGFuIHplcm8uBAJlaQMJAQEhAQUCZE0AAAUCZWUEAmVqCQBlAgUCZEgFAmVmBAJlawkAZQIFAmRKBQJlZwQCZWwJAMwIAgkBDEludGVnZXJFbnRyeQIJAQFXAAUCZHgJAMwIAgkBDEludGVnZXJFbnRyeQIJAQFYAgUGaGVpZ2h0CAUJbGFzdEJsb2NrCXRpbWVzdGFtcAUCZHgJAMwIAgkBC1N0cmluZ0VudHJ5AgkBAmFhAgUCYWIFAmRrCQECYnUKBQJlZgUCZWcFAmVpBQJkeAUCZEcFAmVoBQZoZWlnaHQIBQlsYXN0QmxvY2sJdGltZXN0YW1wBQJlagUCZWsFA25pbAkAnwoNBQJlZQUCZWkFAmR4BQJkcwUCZHUFAmRyBQJkbgUCZHEFAmVsBQJlagUCZWsFAmRJBQJkSwECZW0DAmVuAmVvAmRyBAJlcAkBAUcCBQJlbgkAtgIBBQJicAQCZXEJAQFHAgUCZW8JALYCAQUCYnEEAmVyCQC8AgMJAHYGCQC5AgIFAmVwBQJlcQAACQC2AgEABQABABIFBERPV04FAWcFAmRyAwkAAAIFAmRyBQFmBQFmBQJlcgECZXMDAmV0AmV1AmV2BAJldwkAuAICCQC2AgEJAQJiSgEJAQJiZgEFAmJuBQJldAQCZXgJALgCAgkAtgIBCQECYkoBCQECYmYBBQJibwUCZXUEAmV5CQC4AgIJALYCAQgJAQV2YWx1ZQEJAOwHAQUCYm0IcXVhbnRpdHkFAmV2BAJlegkBAmVtAwUCZXcFAmV4BQJleQUCZXoBAmVBAwJlQgJlQwJldgQCZXcJAGQCCQECYkoBCQECYmYBBQJibgUCZUIEAmV4CQBkAgkBAmJKAQkBAmJmAQUCYm8FAmVDBAJleQkAZAIICQEFdmFsdWUBCQDsBwEFAmJtCHF1YW50aXR5BQJldgQCZXIJAQJlbQMJALYCAQUCZXcJALYCAQUCZXgJALYCAQUCZXkEAmVECQDMCAIJAQxJbnRlZ2VyRW50cnkCBQJhawUGaGVpZ2h0CQDMCAIJAQtTdHJpbmdFbnRyeQIFAmFqCQCmAwEFAmVyBQNuaWwJAJQKAgUCZUQFAmVyAQJlRQICZUYCZXIDCQDAAgIFAmVyBQJlRgYJAQJhUQEJALkJAgkAzAgCAiJ1cGRhdGVkIEtMcCBsb3dlciB0aGFuIGN1cnJlbnQgS0xwCQDMCAIJAKYDAQUCZUYJAMwIAgkApgMBBQJlcgUDbmlsAgEgAQJlRwECZUgEAmV3CQECYkoBCQECYmYBBQJibgQCZXgJAQJiSgEJAQJiZgEFAmJvBAJlSQgFAmVIBmFtb3VudAQCZUoJAG4ECAUCZUgGYW1vdW50CAUCZUgFcHJpY2UFAWIFBUZMT09SBAJlSwMJAAACCAUCZUgJb3JkZXJUeXBlBQNCdXkJAJQKAgUCZUkJAQEtAQUCZUoJAJQKAgkBAS0BBQJlSQUCZUoEAmVCCAUCZUsCXzEEAmVDCAUCZUsCXzIDAwMJAQJhWQAGCQAAAgUCYmwFAW0GCQAAAgUCYmwFAW4JAAIBAhxFeGNoYW5nZSBvcGVyYXRpb25zIGRpc2FibGVkAwMJAQIhPQIICAUCZUgJYXNzZXRQYWlyC2Ftb3VudEFzc2V0BQJibgYJAQIhPQIICAUCZUgJYXNzZXRQYWlyCnByaWNlQXNzZXQFAmJvCQACAQITV3Jvbmcgb3JkZXIgYXNzZXRzLgQCZUwJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAqAMBCQELdmFsdWVPckVsc2UCCQCdCAIFBHRoaXMFAmFqAgEwCQECYVMBAgtpbnZhbGlkIGtMcAQCZU0JAQJlQQMFAmVCBQJlQwAABAJlTggFAmVNAl8xBAJlTwgFAmVNAl8yBAJlUAkAwAICBQJlTwUCZUwEAmVRCQC5CQIJAMwIAgIEa0xwPQkAzAgCCQCmAwEFAmVMCQDMCAICCCBrTHBOZXc9CQDMCAIJAKYDAQUCZU8JAMwIAgIUIGFtb3VudEFzc2V0QmFsYW5jZT0JAMwIAgkApAMBBQJldwkAzAgCAhMgcHJpY2VBc3NldEJhbGFuY2U9CQDMCAIJAKQDAQUCZXgJAMwIAgIZIGFtb3VudEFzc2V0QmFsYW5jZURlbHRhPQkAzAgCCQCkAwEFAmVCCQDMCAICGCBwcmljZUFzc2V0QmFsYW5jZURlbHRhPQkAzAgCCQCkAwEFAmVDCQDMCAICCCBoZWlnaHQ9CQDMCAIJAKQDAQUGaGVpZ2h0BQNuaWwCAAkAlAoCBQJlUAUCZVEBAmVSAQJlUwMJAQIhPQIJAJADAQgFAmVTCHBheW1lbnRzAAEJAAIBAh1leGFjdGx5IDEgcGF5bWVudCBpcyBleHBlY3RlZAQCZVQJAQV2YWx1ZQEJAJEDAggFAmVTCHBheW1lbnRzAAAEAmRsCQEFdmFsdWUBCAUCZVQHYXNzZXRJZAQCZVUIBQJlVAZhbW91bnQEAmRXCQECZGoECQDYBAEIBQJlUw10cmFuc2FjdGlvbklkCQDYBAEFAmRsBQJlVQgFAmVTBmNhbGxlcgQCZEMIBQJkVwJfMQQCZEQIBQJkVwJfMgQCZHEJAQ1wYXJzZUludFZhbHVlAQgFAmRXAl85BAJkRQgFAmRXA18xMAMDCQECYVkABgkAAAIFAmRxBQFuCQACAQkArAICAixHZXQgb3BlcmF0aW9uIGlzIGJsb2NrZWQgYnkgYWRtaW4uIFN0YXR1cyA9IAkApAMBBQJkcQkAlwoFBQJkQwUCZEQFAmVVBQJkbAUCZEUBAmVWAwJlUwJkRwJkTQMJAQIhPQIJAJADAQgFAmVTCHBheW1lbnRzAAIJAAIBAh9leGFjdGx5IDIgcGF5bWVudHMgYXJlIGV4cGVjdGVkBAJlVwkBBXZhbHVlAQkAkQMCCAUCZVMIcGF5bWVudHMAAAQCZVgJAQV2YWx1ZQEJAJEDAggFAmVTCHBheW1lbnRzAAEEAmVZCQECZEYJCQDYBAEIBQJlUw10cmFuc2FjdGlvbklkBQJkRwgFAmVXBmFtb3VudAgFAmVXB2Fzc2V0SWQIBQJlWAZhbW91bnQIBQJlWAdhc3NldElkCQClCAEIBQJlUwZjYWxsZXIHBQJkTQQCZHEJAQ1wYXJzZUludFZhbHVlAQgFAmVZAl84AwMDCQECYVkABgkAAAIFAmRxBQFsBgkAAAIFAmRxBQFuCQACAQkArAICAixQdXQgb3BlcmF0aW9uIGlzIGJsb2NrZWQgYnkgYWRtaW4uIFN0YXR1cyA9IAkApAMBBQJkcQUCZVkBAmVaAQJiVwQCZmEJAPwHBAUCYVQCBGVtaXQJAMwIAgUCYlcFA25pbAUDbmlsAwkAAAIFAmZhBQJmYQQCZmIEAmJUBQJmYQMJAAECBQJiVAIHQWRkcmVzcwQCZmMFAmJUCQD8BwQFAmZjAgRlbWl0CQDMCAIFAmJXBQNuaWwFA25pbAUEdW5pdAMJAAACBQJmYgUCZmIFAmJXCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAQJmZAICYlcCYWkEAmZlAwkAAAIFAmFpAAAAAAkAawMFAmJXBQJhaQUBYgkAlAoCCQBlAgUCYlcFAmZlBQJmZQECZmYEAmZnAmZoAmFiAmFjBAJmaQkAAAIFAmFjBQR1bml0BAJmagkBAmJKAQkBAmJmAQUCYm4EAmZrCQECYkoBCQECYmYBBQJibwQCZmwDCQAAAgUCZmgFAmJuBgMJAAACBQJmaAUCYm8HCQECYVEBAg1pbnZhbGlkIGFzc2V0BAJmbQMFAmZpCQCUCgIFAmZqBQJmawMFAmZsCQCUCgIJAGUCBQJmagUCZmcFAmZrCQCUCgIFAmZqCQBlAgUCZmsFAmZnBAJmbggFAmZtAl8xBAJmbwgFAmZtAl8yBAJmcAMFAmZsCQCUCgIFAmZnAAAJAJQKAgAABQJmZwQCZnEIBQJmcAJfMQQCZnIIBQJmcAJfMgQCZUkICQECZmQCBQJmcQUCYVYCXzEEAmVKCAkBAmZkAgUCZnIFAmFWAl8xBAJmcwkBAmZkAgUCZmcFAmFWBAJmdAgFAmZzAl8xBAJmZQgFAmZzAl8yBAJmdQkAZAIFAmZuBQJlSQQCZnYJAGQCBQJmbwUCZUoEAmZ3CQECYk0CCQEBRAIFAmZ2BQJicQkBAUQCBQJmdQUCYnAEAmZ4CQEBSAIFAmZ3BQFiBAJmeQMFAmZsBQJmbgUCZm8EAmZ6CQC2AgEFAmZ5BAJmQQkAtgIBCAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQDsBwEFAmJtCQCsAgIJAKwCAgIGYXNzZXQgCQDYBAEFAmJtAg4gZG9lc24ndCBleGlzdAhxdWFudGl0eQQCZkIDCQC/AgIFAmZBBQFmBgkBAmFRAQIiaW5pdGlhbCBkZXBvc2l0IHJlcXVpcmVzIGFsbCBjb2lucwMJAAACBQJmQgUCZkIEAmZDCQC2AgEFAmZ0BAJmRAkAlgMBCQDMCAIAAAkAzAgCCQCgAwEJALoCAgkAuQICBQJmQQkAuAICCQEKc3FydEJpZ0ludAQJALcCAgUBZAkAugICCQC5AgIFAmZDBQFkBQJmegASABIFBERPV04FAWQFAWQFA25pbAQCZWwDBQJmaQUDbmlsCQDMCAIJAQxJbnRlZ2VyRW50cnkCCQEBVwAFAmZ4CQDMCAIJAQxJbnRlZ2VyRW50cnkCCQEBWAIFBmhlaWdodAgFCWxhc3RCbG9jawl0aW1lc3RhbXAFAmZ4CQDMCAIJAQtTdHJpbmdFbnRyeQIJAQJhYQIJAKUIAQkBBXZhbHVlAQUCYWIJANgEAQkBBXZhbHVlAQUCYWMJAQJidQoFAmZxBQJmcgUCZkQFAmZ4AAAAAAUGaGVpZ2h0CAUJbGFzdEJsb2NrCXRpbWVzdGFtcAAAAAAFA25pbAQCZkUJAQJiTQIJAQFEAgUCZm8FAmJxCQEBRAIFAmZuBQJicAQCZkYJAQFIAgUCZkUFAWIEAmZHBAJmSAMFAmZsCQCUCgIFAmZxBQJmbgkAlAoCBQJmcgUCZm8EAmJXCAUCZkgCXzEEAmZJCAUCZkgCXzIEAmZKCQCgAwEJALwCAwUCZkEJALYCAQkAaQIFAmJXAAIJALYCAQUCZkkJAGsDCQBlAgUCZkQFAmZKBQFiBQJmSgkAlwoFBQJmRAUCZWwFAmZlBQJmRwUCZmwJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BAmZLBQJmTAJmdAJmaAJhYgJhYwQCZmkJAAACBQJhYwUEdW5pdAQCZGEJAQJiYQAEAmRiCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUCZGEFAXQEAmRjCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUCZGEFAXUEAmZNCQDMCAIDCQAAAgUCZmgFAmJtBgkBAmFRAQIQaW52YWxpZCBscCBhc3NldAUDbmlsAwkAAAIFAmZNBQJmTQQCZk4DCQAAAgUCZkwFAmJuBgMJAAACBQJmTAUCYm8HCQECYVEBAg1pbnZhbGlkIGFzc2V0BAJmTwMFAmZOCQC2AgEJAQJiSgEJAQJiZgEFAmJuCQC2AgEJAQJiSgEJAQJiZgEFAmJvBAJmUAMFAmZOBQJkYgUCZGMEAmZRCQECYkoBCQECYmYBBQJibgQCZlIJAQJiSgEJAQJiZgEFAmJvBAJmUwMFAmZOBQJmUQUCZlIEAmZUCQC2AgEFAmZTBAJmQQkAtgIBCAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQDsBwEFAmJtCQCsAgIJAKwCAgIGYXNzZXQgCQDYBAEFAmJtAg4gZG9lc24ndCBleGlzdAhxdWFudGl0eQQCZlUJALYCAQUCZnQEAmZWCQCWAwEJAMwIAgAACQDMCAIJAKADAQkAugICCQC5AgIFAmZPCQC4AgIFAWQJAHYGCQC4AgIFAWQJALoCAgkAuQICBQJmVQUBZAUCZkEAEgUBaAAAABIFBERPV04FAWQFA25pbAQCZlcJAQJmZAIFAmZWBQJhWAQCZlgIBQJmVwJfMQQCZmUIBQJmVwJfMgQCZlkDBQJmTgkAlgoEBQJmWAAACQBlAgUCZlEFAmZWBQJmUgkAlgoEAAAFAmZYBQJmUQkAZQIFAmZSBQJmVgQCZloIBQJmWQJfMQQCZ2EIBQJmWQJfMgQCZ2IIBQJmWQJfMwQCZ2MIBQJmWQJfNAQCZncJAQJiTQIJAQFEAgUCZ2MFAmJxCQEBRAIFAmdiBQJicAQCZngJAQFIAgUCZncFAWIEAmVsAwUCZmkFA25pbAkAzAgCCQELU3RyaW5nRW50cnkCCQECYWQCCQClCAEJAQV2YWx1ZQEFAmFiCQDYBAEJAQV2YWx1ZQEFAmFjCQECYkYGBQJmWgUCZ2EFAmZ0BQJmeAUGaGVpZ2h0CAUJbGFzdEJsb2NrCXRpbWVzdGFtcAkAzAgCCQEMSW50ZWdlckVudHJ5AgkBAVcABQJmeAkAzAgCCQEMSW50ZWdlckVudHJ5AgkBAVgCBQZoZWlnaHQIBQlsYXN0QmxvY2sJdGltZXN0YW1wBQJmeAUDbmlsBAJmRQkBAmJNAgkBAUQCBQJmUgUCYnEJAQFEAgUCZlEFAmJwBAJmRgkBAUgCBQJmRQUBYgQCZkcEAmdkCQBoAgkAoAMBCQC8AgMFAmZPBQJmVQUCZkEAAgkAawMJAGUCBQJmWAUCZ2QFAWIFAmdkCQCXCgUFAmZYBQJlbAUCZmUFAmZHBQJmTgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgECZ2UABAJiVAkAoggBCQEBVQADCQABAgUCYlQCBlN0cmluZwQCZ2YFAmJUCQDZBAEFAmdmAwkAAQIFAmJUAgRVbml0BQR1bml0CQACAQILTWF0Y2ggZXJyb3IBAmdnAAQCYlQJAKIIAQkBAVYAAwkAAQIFAmJUAgZTdHJpbmcEAmdmBQJiVAkA2QQBBQJnZgMJAAECBQJiVAIEVW5pdAUEdW5pdAkAAgECC01hdGNoIGVycm9yAQJnaAECZVMEAmJUCQECZ2UAAwkAAQIFAmJUAgpCeXRlVmVjdG9yBAJnaQUCYlQJAAACCAUCZVMPY2FsbGVyUHVibGljS2V5BQJnaQMJAAECBQJiVAIEVW5pdAkAAAIIBQJlUwZjYWxsZXIFBHRoaXMJAAIBAgtNYXRjaCBlcnJvcgECZ2oBAmVTBAJnawkAAgECEVBlcm1pc3Npb24gZGVuaWVkBAJiVAkBAmdlAAMJAAECBQJiVAIKQnl0ZVZlY3RvcgQCZ2kFAmJUAwkAAAIIBQJlUw9jYWxsZXJQdWJsaWNLZXkFAmdpBgUCZ2sDCQABAgUCYlQCBFVuaXQDCQAAAggFAmVTBmNhbGxlcgUEdGhpcwYFAmdrCQACAQILTWF0Y2ggZXJyb3IeAmVTAQlyZWJhbGFuY2UACQDOCAIJAQJjQQEJAQJhTQIFBHRoaXMJAQJhZQAJAQJjQQEJAQJhTQIFBHRoaXMJAQJhZgACZVMBIWNhbGN1bGF0ZUFtb3VudE91dEZvclN3YXBSRUFET05MWQMCZ2wCZ20CZ24EAmdvAwkAAAIFAmdtBwQCZ3AJAQJhTQIFBHRoaXMJAQJhZgAEAmdxCQECYU0CBQR0aGlzCQECYWUACQCUCgIFAmdwBQJncQQCZ3AJAQJhTQIFBHRoaXMJAQJhZQAEAmdxCQECYU0CBQR0aGlzCQECYWYACQCUCgIFAmdwBQJncQQCZ3AIBQJnbwJfMQQCZ3EIBQJnbwJfMgQCZ3IJAQJiSgEFAmdxBAJncwkBAmJKAQUCZ3AEAmd0CQBrAwUCZ3MFAmdsCQBkAgUCZ3IFAmdsBAJndQkAuQICCQC2AgEFAmdyCQC2AgEFAmdzBAJndgkAuQICCQC3AgIJALcCAgkAtgIBCQECYkoBBQJncQkAtgIBBQJnbAkAtgIBBQJnbgkAuAICCQC2AgEJAQJiSgEFAmdwCQC2AgEFAmd0BAJndwMJAMACAgUCZ3YFAmd1BgkAAgECFG5ldyBLIGlzIGZld2VyIGVycm9yAwkAAAIFAmd3BQJndwkAlAoCBQNuaWwFAmd0CQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAmVTASZjYWxjdWxhdGVBbW91bnRPdXRGb3JTd2FwQW5kU2VuZFRva2VucwUCZ2wCZ20CZ3gCZ3kCZ24EAmd6CgACYVcJAPwHBAUCYVQCF2dldFN3YXBDb250cmFjdFJFQURPTkxZBQNuaWwFA25pbAMJAAECBQJhVwIGU3RyaW5nBQJhVwkAAgEJAKwCAgkAAwEFAmFXAhsgY291bGRuJ3QgYmUgY2FzdCB0byBTdHJpbmcEAmZNCQDMCAIDCQBnAggJAQV2YWx1ZQEJAJEDAggFAmVTCHBheW1lbnRzAAAGYW1vdW50BQJnbAYJAQJhUQECDFdyb25nIGFtb3VudAkAzAgCAwkAAAIIBQJlUwZjYWxsZXIJARFAZXh0ck5hdGl2ZSgxMDYyKQEFAmd6BgkBAmFRAQIRUGVybWlzc2lvbiBkZW5pZWQFA25pbAMJAAACBQJmTQUCZk0EAmVUCQEFdmFsdWUBCQCRAwIIBQJlUwhwYXltZW50cwAABAJncQkBAmJmAQgFAmVUB2Fzc2V0SWQEAmdwAwkAAAIFAmdtBwkBAmFNAgUEdGhpcwkBAmFmAAkBAmFNAgUEdGhpcwkBAmFlAAQCZ3IJAGUCCQECYkoBBQJncQgJAQV2YWx1ZQEJAJEDAggFAmVTCHBheW1lbnRzAAAGYW1vdW50BAJncwkBAmJKAQUCZ3AEAmd0CQBrAwUCZ3MFAmdsCQBkAgUCZ3IFAmdsBAJndQkAuQICCQC2AgEFAmdyCQC2AgEFAmdzBAJndgkAuQICCQC3AgIJALYCAQkBAmJKAQUCZ3EJALYCAQUCZ24JALgCAgkAtgIBCQECYkoBBQJncAkAtgIBBQJndAQCZ3cDCQDAAgIFAmd2BQJndQYJAAIBAhRuZXcgSyBpcyBmZXdlciBlcnJvcgMJAAACBQJndwUCZ3cEAmdBAwkAZwIFAmd0BQJneAYJAAIBAixFeGNoYW5nZSByZXN1bHQgaXMgZmV3ZXIgY29pbnMgdGhhbiBleHBlY3RlZAMJAAACBQJnQQUCZ0EEAmdCCQECY0EBBQJncQMJAAACBQJnQgUCZ0IEAmdDCQECY0gCBQJncAUCZ3QDCQAAAgUCZ0MFAmdDCQCUCgIJAM4IAgkAzggCBQJnQwUCZ0IJAMwIAgkBDlNjcmlwdFRyYW5zZmVyAwkBEUBleHRyTmF0aXZlKDEwNjIpAQUCZ3kFAmd0CQECYmQBBQJncAUDbmlsBQJndAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgJlUwEKc2V0TWFuYWdlcgECZ0QEAmdFCQECZ2oBBQJlUwMJAAACBQJnRQUCZ0UEAmdGCQDZBAEFAmdEAwkAAAIFAmdGBQJnRgkAzAgCCQELU3RyaW5nRW50cnkCCQEBVgAFAmdEBQNuaWwJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4CZVMBDmNvbmZpcm1NYW5hZ2VyAAQCZ0cJAQJnZwAEAmdIAwkBCWlzRGVmaW5lZAEFAmdHBgkAAgECEk5vIHBlbmRpbmcgbWFuYWdlcgMJAAACBQJnSAUCZ0gEAmdJAwkAAAIIBQJlUw9jYWxsZXJQdWJsaWNLZXkJAQV2YWx1ZQEFAmdHBgkAAgECG1lvdSBhcmUgbm90IHBlbmRpbmcgbWFuYWdlcgMJAAACBQJnSQUCZ0kJAMwIAgkBC1N0cmluZ0VudHJ5AgkBAVUACQDYBAEJAQV2YWx1ZQEFAmdHCQDMCAIJAQtEZWxldGVFbnRyeQEJAQFWAAUDbmlsCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAmVTAQNwdXQCAmRHAmdKAwkAZgIAAAUCZEcJAAIBAiBJbnZhbGlkIHNsaXBwYWdlVG9sZXJhbmNlIHBhc3NlZAQCZVkJAQJlVgMFAmVTBQJkRwYEAmVpCAUCZVkCXzIEAmRuCAUCZVkCXzcEAmRFCAUCZVkCXzkEAmVqCAUCZVkDXzEwBAJlawgFAmVZA18xMQQCZ0sIBQJlWQNfMTIEAmdMCAUCZVkDXzEzBAJlVwkAtgIBCAkBBXZhbHVlAQkAkQMCCAUCZVMIcGF5bWVudHMAAAZhbW91bnQEAmVYCQC2AgEICQEFdmFsdWUBCQCRAwIIBQJlUwhwYXltZW50cwABBmFtb3VudAQCZXoJAQJlcwMFAmVXBQJlWAkAtgIBAAADCQAAAgUCZXoFAmV6BAJmYQkA/AcEBQJhVAIEZW1pdAkAzAgCBQJlaQUDbmlsBQNuaWwDCQAAAgUCZmEFAmZhBAJmYgQCYlQFAmZhAwkAAQIFAmJUAgdBZGRyZXNzBAJmYwUCYlQJAPwHBAUCZmMCBGVtaXQJAMwIAgUCZWkFA25pbAUDbmlsBQR1bml0AwkAAAIFAmZiBQJmYgQCZ00DCQBmAgUCZWoAAAkA/AcEBQJidAIDcHV0BQNuaWwJAMwIAgkBD0F0dGFjaGVkUGF5bWVudAIFAmdLBQJlagUDbmlsBQNuaWwDCQAAAgUCZ00FAmdNBAJnTgMJAGYCBQJlawAACQD8BwQFAmJ0AgNwdXQFA25pbAkAzAgCCQEPQXR0YWNoZWRQYXltZW50AgUCZ0wFAmVrBQNuaWwFA25pbAMJAAACBQJnTgUCZ04EAmdPAwUCZ0oEAmdQCQD8BwQFAmJzAgVzdGFrZQUDbmlsCQDMCAIJAQ9BdHRhY2hlZFBheW1lbnQCBQJkbgUCZWkFA25pbAMJAAACBQJnUAUCZ1AFA25pbAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAzAgCCQEOU2NyaXB0VHJhbnNmZXIDCAUCZVMGY2FsbGVyBQJlaQUCZG4FA25pbAQCZ1EJAQJlQQMAAAAAAAADCQAAAgUCZ1EFAmdRBAJlcggFAmdRAl8yBAJnUggFAmdRAl8xBAJnUwkBAmVFAgUCZXoFAmVyAwkAAAIFAmdTBQJnUwQCZ1QJAPwHBAUEdGhpcwIJcmViYWxhbmNlBQNuaWwFA25pbAMJAAACBQJnVAUCZ1QJAM4IAgkAzggCBQJkRQUCZ08FAmdSCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAmVTAQpwdXRGb3JGcmVlAQJnVQMJAGYCAAAFAmdVCQACAQIUSW52YWxpZCB2YWx1ZSBwYXNzZWQEAmVZCQECZVYDBQJlUwUCZ1UHBAJkRQgFAmVZAl85BAJlVwkAtgIBCAkBBXZhbHVlAQkAkQMCCAUCZVMIcGF5bWVudHMAAAZhbW91bnQEAmVYCQC2AgEICQEFdmFsdWUBCQCRAwIIBQJlUwhwYXltZW50cwABBmFtb3VudAQCZXoJAQJlcwMFAmVXBQJlWAkAtgIBAAADCQAAAgUCZXoFAmV6BAJnVgkBAmVBAwAAAAAAAAQCZ1IIBQJnVgJfMQQCZXIIBQJnVgJfMgQCZ1MJAQJlRQIFAmV6BQJlcgMJAAACBQJnUwUCZ1MJAM4IAgUCZEUFAmdSCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAmVTAQlwdXRPbmVUa24CAmdXAmdYBAJnWQoAAmFXCQD8BwQFAmFUAihpc1Bvb2xPbmVUb2tlbk9wZXJhdGlvbnNEaXNhYmxlZFJFQURPTkxZCQDMCAIJAKUIAQUEdGhpcwUDbmlsBQNuaWwDCQABAgUCYVcCB0Jvb2xlYW4FAmFXCQACAQkArAICCQADAQUCYVcCHCBjb3VsZG4ndCBiZSBjYXN0IHRvIEJvb2xlYW4EAmdaAwMDCQECYVkABgkAAAIFAmJsBQFsBgkAAAIFAmJsBQFuBgUCZ1kEAmZNCQDMCAIDAwkBASEBBQJnWgYJAQJnaAEFAmVTBgkBAmFRAQIhcHV0IG9wZXJhdGlvbiBpcyBibG9ja2VkIGJ5IGFkbWluCQDMCAIDCQAAAgkAkAMBCAUCZVMIcGF5bWVudHMAAQYJAQJhUQECHmV4YWN0bHkgMSBwYXltZW50IGFyZSBleHBlY3RlZAUDbmlsAwkAAAIFAmZNBQJmTQQCaGEJAJEDAggFAmVTCHBheW1lbnRzAAAEAmZoCAUCaGEHYXNzZXRJZAQCZmcIBQJoYQZhbW91bnQEAmV6AwkAAAIFAmZoBQJibgkBAmVzAwkAtgIBBQJmZwkAtgIBAAAJALYCAQAAAwkAAAIFAmZoBQJibwkBAmVzAwkAtgIBAAAJALYCAQUCZmcJALYCAQAACQECYVEBAh5wYXltZW50IGFzc2V0IGlzIG5vdCBzdXBwb3J0ZWQDCQAAAgUCZXoFAmV6BAJhYggFAmVTBmNhbGxlcgQCYWMIBQJlUw10cmFuc2FjdGlvbklkBAJoYgkBAmZmBAUCZmcFAmZoBQJhYgUCYWMDCQAAAgUCaGIFAmhiBAJmbAgFAmhiAl81BAJoYwgFAmhiAl80BAJmZQgFAmhiAl8zBAJlbAgFAmhiAl8yBAJoZAgFAmhiAl8xBAJoZQMDCQBmAgUCZ1cAAAkAZgIFAmdXBQJoZAcJAQJhUQEJALkJAgkAzAgCAh9hbW91bnQgdG8gcmVjZWl2ZSBpcyBsZXNzIHRoYW4gCQDMCAIJAKQDAQUCZ1cFA25pbAIABQJoZAQCZmEJAQJlWgEFAmhlAwkAAAIFAmZhBQJmYQQCZ08DBQJnWAQCaGYJAPwHBAUCYnMCBXN0YWtlBQNuaWwJAMwIAgkBD0F0dGFjaGVkUGF5bWVudAIFAmJtBQJoZQUDbmlsAwkAAAIFAmhmBQJoZgUDbmlsCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMIBQJlUwZjYWxsZXIFAmhlBQJibQUDbmlsBAJoZwMJAGYCBQJmZQAACQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMFAmFVBQJmZQUCZmgFA25pbAUDbmlsBAJoaAMJAAACBQR0aGlzBQJhVQkAlAoCAAAAAAMFAmZsCQCUCgIJAQEtAQUCZmUAAAkAlAoCAAAJAQEtAQUCZmUEAmVCCAUCaGgCXzEEAmVDCAUCaGgCXzIEAmhpCQECZUEDBQJlQgUCZUMAAAQCZ1IIBQJoaQJfMQQCZXIIBQJoaQJfMgQCZUwJAQV2YWx1ZQEJAKIIAQUCYWoEAmdTCQECZUUCBQJlegUCZXIDCQAAAgUCZ1MFAmdTBAJnVAkA/AcEBQR0aGlzAglyZWJhbGFuY2UFA25pbAUDbmlsAwkAAAIFAmdUBQJnVAkAlAoCCQDOCAIJAM4IAgkAzggCBQJlbAUCZ08FAmhnBQJnUgUCaGUJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4CZVMBEXB1dE9uZVRrblJFQURPTkxZAgJmaAJmZwQCaGoJAQJmZgQFAmZnCQECYmQBBQJmaAUEdW5pdAUEdW5pdAQCaGQIBQJoagJfMQQCZWwIBQJoagJfMgQCZmUIBQJoagJfMwQCaGMIBQJoagJfNAQCZmwIBQJoagJfNQkAlAoCBQNuaWwJAJUKAwUCaGQFAmZlBQJoYwJlUwEJZ2V0T25lVGtuAgJoawJnVwQCZ1kKAAJhVwkA/AcEBQJhVAIoaXNQb29sT25lVG9rZW5PcGVyYXRpb25zRGlzYWJsZWRSRUFET05MWQkAzAgCCQClCAEFBHRoaXMFA25pbAUDbmlsAwkAAQIFAmFXAgdCb29sZWFuBQJhVwkAAgEJAKwCAgkAAwEFAmFXAhwgY291bGRuJ3QgYmUgY2FzdCB0byBCb29sZWFuBAJobAMDCQECYVkABgkAAAIFAmJsBQFuBgUCZ1kEAmZNCQDMCAIDAwkBASEBBQJobAYJAQJnaAEFAmVTBgkBAmFRAQIhZ2V0IG9wZXJhdGlvbiBpcyBibG9ja2VkIGJ5IGFkbWluCQDMCAIDCQAAAgkAkAMBCAUCZVMIcGF5bWVudHMAAQYJAQJhUQECHmV4YWN0bHkgMSBwYXltZW50IGFyZSBleHBlY3RlZAUDbmlsAwkAAAIFAmZNBQJmTQQCZkwJAQJiZAEFAmhrBAJoYQkAkQMCCAUCZVMIcGF5bWVudHMAAAQCZmgIBQJoYQdhc3NldElkBAJmdAgFAmhhBmFtb3VudAQCZXoJAQJlcwMJALYCAQAACQC2AgEAAAkAtgIBAAADCQAAAgUCZXoFAmV6BAJhYggFAmVTBmNhbGxlcgQCYWMIBQJlUw10cmFuc2FjdGlvbklkBAJobQkBAmZLBQUCZkwFAmZ0BQJmaAUCYWIFAmFjAwkAAAIFAmhtBQJobQQCZk4IBQJobQJfNQQCaGMIBQJobQJfNAQCZmUIBQJobQJfMwQCZWwIBQJobQJfMgQCaG4IBQJobQJfMQQCYlcDAwkAZgIFAmdXAAAJAGYCBQJnVwUCaG4HCQECYVEBCQC5CQIJAMwIAgIfYW1vdW50IHRvIHJlY2VpdmUgaXMgbGVzcyB0aGFuIAkAzAgCCQCkAwEFAmdXBQNuaWwCAAUCaG4EAmhvCQD8BwQFAmFUAgRidXJuCQDMCAIFAmZ0BQNuaWwJAMwIAgkBD0F0dGFjaGVkUGF5bWVudAIFAmZoBQJmdAUDbmlsAwkAAAIFAmhvBQJobwQCZ0MJAQJjSAIFAmhrCQBkAgUCYlcJAJYDAQkAzAgCAAAJAMwIAgUCZmUFA25pbAQCaHAJAMwIAgkBDlNjcmlwdFRyYW5zZmVyAwUCYWIFAmJXBQJmTAUDbmlsBAJoZwMJAGYCBQJmZQAACQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMFAmFVBQJmZQUCZkwFA25pbAUDbmlsBAJocQQCaHIDCQAAAgUEdGhpcwUCYVUAAAUCZmUDBQJmTgkAlAoCCQEBLQEJAGQCBQJiVwUCaHIAAAkAlAoCAAAJAQEtAQkAZAIFAmJXBQJocgQCZUIIBQJocQJfMQQCZUMIBQJocQJfMgQCaHMJAQJlQQMFAmVCBQJlQwAABAJnUggFAmhzAl8xBAJlcggFAmhzAl8yBAJnUwkBAmVFAgUCZXoFAmVyAwkAAAIFAmdTBQJnUwkAlAoCCQDOCAIJAM4IAgkAzggCCQDOCAIFAmVsBQJnQwUCaHAFAmhnBQJnUgUCYlcJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4CZVMBEWdldE9uZVRrblJFQURPTkxZAgJmTAJmdAQCaHQJAQJmSwUJAQJiZAEFAmZMBQJmdAUCYm0FBHVuaXQFBHVuaXQEAmhuCAUCaHQCXzEEAmVsCAUCaHQCXzIEAmZlCAUCaHQCXzMEAmhjCAUCaHQCXzQEAmZOCAUCaHQCXzUJAJQKAgUDbmlsCQCVCgMFAmhuBQJmZQUCaGMCZVMBE3Vuc3Rha2VBbmRHZXRPbmVUa24DAmh1AmhrAmdXBAJnWQoAAmFXCQD8BwQFAmFUAihpc1Bvb2xPbmVUb2tlbk9wZXJhdGlvbnNEaXNhYmxlZFJFQURPTkxZCQDMCAIJAKUIAQUEdGhpcwUDbmlsBQNuaWwDCQABAgUCYVcCB0Jvb2xlYW4FAmFXCQACAQkArAICCQADAQUCYVcCHCBjb3VsZG4ndCBiZSBjYXN0IHRvIEJvb2xlYW4EAmhsAwMJAQJhWQAGCQAAAgUCYmwFAW4GBQJnWQQCZk0JAMwIAgMDCQEBIQEFAmhsBgkBAmdoAQUCZVMGCQECYVEBAiFnZXQgb3BlcmF0aW9uIGlzIGJsb2NrZWQgYnkgYWRtaW4JAMwIAgMJAAACCQCQAwEIBQJlUwhwYXltZW50cwAABgkBAmFRAQIYbm8gcGF5bWVudHMgYXJlIGV4cGVjdGVkBQNuaWwDCQAAAgUCZk0FAmZNBAJmTAkBAmJkAQUCaGsEAmFiCAUCZVMGY2FsbGVyBAJhYwgFAmVTDXRyYW5zYWN0aW9uSWQEAmV6CQECZXMDCQC2AgEAAAkAtgIBAAAJALYCAQAAAwkAAAIFAmV6BQJlegQCaHYJAPwHBAUCYnMCB3Vuc3Rha2UJAMwIAgkA2AQBBQJibQkAzAgCBQJodQUDbmlsBQNuaWwDCQAAAgUCaHYFAmh2BAJodwkBAmZLBQUCZkwFAmh1BQJibQUCYWIFAmFjAwkAAAIFAmh3BQJodwQCZk4IBQJodwJfNQQCaGMIBQJodwJfNAQCZmUIBQJodwJfMwQCZWwIBQJodwJfMgQCaG4IBQJodwJfMQQCYlcDAwkAZgIFAmdXAAAJAGYCBQJnVwUCaG4HCQECYVEBCQC5CQIJAMwIAgIfYW1vdW50IHRvIHJlY2VpdmUgaXMgbGVzcyB0aGFuIAkAzAgCCQCkAwEFAmdXBQNuaWwCAAUCaG4EAmhvCQD8BwQFAmFUAgRidXJuCQDMCAIFAmh1BQNuaWwJAMwIAgkBD0F0dGFjaGVkUGF5bWVudAIFAmJtBQJodQUDbmlsAwkAAAIFAmhvBQJobwQCZ0MJAQJjSAIFAmhrCQBkAgUCYlcJAJYDAQkAzAgCAAAJAMwIAgUCZmUFA25pbAQCaHAJAMwIAgkBDlNjcmlwdFRyYW5zZmVyAwgFAmVTBmNhbGxlcgUCYlcFAmZMBQNuaWwEAmhnAwkAZgIFAmZlAAAJAMwIAgkBDlNjcmlwdFRyYW5zZmVyAwUCYVUFAmZlBQJmTAUDbmlsBQNuaWwEAmh4BAJocgMJAAACBQR0aGlzBQJhVQAABQJmZQMFAmZOCQCUCgIJAQEtAQkAZAIFAmJXBQJocgAACQCUCgIAAAkBAS0BCQBkAgUCYlcFAmhyBAJlQggFAmh4Al8xBAJlQwgFAmh4Al8yBAJoeQkBAmVBAwUCZUIFAmVDAAAEAmdSCAUCaHkCXzEEAmVyCAUCaHkCXzIEAmdTCQECZUUCBQJlegUCZXIDCQAAAgUCZ1MFAmdTCQCUCgIJAM4IAgkAzggCCQDOCAIJAM4IAgUCZWwFAmdDBQJocAUCaGcFAmdSBQJiVwkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgJlUwEDZ2V0AAQCZFcJAQJlUgEFAmVTBAJkQwgFAmRXAl8xBAJkRAgFAmRXAl8yBAJlVQgFAmRXAl8zBAJkbAgFAmRXAl80BAJkRQgFAmRXAl81BAJnQwkBAmNNAgUCZEMFAmREBAJlegkBAmVzAwkAtgIBAAAJALYCAQAACQC2AgEAAAMJAAACBQJlegUCZXoEAmh6CQD8BwQFAmFUAgRidXJuCQDMCAIFAmVVBQNuaWwJAMwIAgkBD0F0dGFjaGVkUGF5bWVudAIFAmRsBQJlVQUDbmlsAwkAAAIFAmh6BQJoegQCaEEJAQJlQQMJAQEtAQUCZEMJAQEtAQUCZEQAAAQCZ1IIBQJoQQJfMQQCZXIIBQJoQQJfMgQCZ1MJAQJlRQIFAmV6BQJlcgMJAAACBQJnUwUCZ1MJAM4IAgkAzggCBQJnQwUCZEUFAmdSCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAmVTAQlnZXROb0xlc3MCAmhCAmhDBAJkVwkBAmVSAQUCZVMEAmRDCAUCZFcCXzEEAmRECAUCZFcCXzIEAmVVCAUCZFcCXzMEAmRsCAUCZFcCXzQEAmRFCAUCZFcCXzUDCQBmAgUCaEIFAmRDCQACAQkArAICCQCsAgIJAKwCAgIcbm9MZXNzVGhlbkFtdEFzc2V0IGZhaWxlZDogIAkApAMBBQJkQwIDIDwgCQCkAwEFAmhCAwkAZgIFAmhDBQJkRAkAAgEJAKwCAgkArAICCQCsAgICHW5vTGVzc1RoZW5QcmljZUFzc2V0IGZhaWxlZDogCQCkAwEFAmREAgMgPCAJAKQDAQUCaEMEAmdDCQECY00CBQJkQwUCZEQEAmV6CQECZXMDCQC2AgEAAAkAtgIBAAAJALYCAQAAAwkAAAIFAmV6BQJlegQCaHoJAPwHBAUCYVQCBGJ1cm4JAMwIAgUCZVUFA25pbAkAzAgCCQEPQXR0YWNoZWRQYXltZW50AgUCZGwFAmVVBQNuaWwDCQAAAgUCaHoFAmh6BAJoRAkBAmVBAwkBAS0BBQJkQwkBAS0BBQJkRAAABAJnUggFAmhEAl8xBAJlcggFAmhEAl8yBAJnUwkBAmVFAgUCZXoFAmVyAwkAAAIFAmdTBQJnUwkAzggCCQDOCAIFAmdDBQJkRQUCZ1IJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4CZVMBDXVuc3Rha2VBbmRHZXQBAmJXBAJoRQMJAQIhPQIJAJADAQgFAmVTCHBheW1lbnRzAAAJAAIBAhhObyBwYXltZW50cyBhcmUgZXhwZWN0ZWQGAwkAAAIFAmhFBQJoRQQCZGEJAQJiYQAEAmRuCQDZBAEJAJEDAgUCZGEFAXEEAmV6CQECZXMDCQC2AgEAAAkAtgIBAAAJALYCAQAAAwkAAAIFAmV6BQJlegQCaHYJAPwHBAUCYnMCB3Vuc3Rha2UJAMwIAgkA2AQBBQJkbgkAzAgCBQJiVwUDbmlsBQNuaWwDCQAAAgUCaHYFAmh2BAJkVwkBAmRqBAkA2AQBCAUCZVMNdHJhbnNhY3Rpb25JZAkA2AQBBQJkbgUCYlcIBQJlUwZjYWxsZXIEAmRDCAUCZFcCXzEEAmRECAUCZFcCXzIEAmRxCQENcGFyc2VJbnRWYWx1ZQEIBQJkVwJfOQQCZEUIBQJkVwNfMTAEAmdDCQECY00CBQJkQwUCZEQEAmhGAwMJAQJhWQAGCQAAAgUCZHEFAW4JAAIBCQCsAgICLEdldCBvcGVyYXRpb24gaXMgYmxvY2tlZCBieSBhZG1pbi4gU3RhdHVzID0gCQCkAwEFAmRxBgMJAAACBQJoRgUCaEYEAmh6CQD8BwQFAmFUAgRidXJuCQDMCAIFAmJXBQNuaWwJAMwIAgkBD0F0dGFjaGVkUGF5bWVudAIFAmRuBQJiVwUDbmlsAwkAAAIFAmh6BQJoegQCaEcJAQJlQQMJAQEtAQUCZEMJAQEtAQUCZEQAAAQCZ1IIBQJoRwJfMQQCZXIIBQJoRwJfMgQCZ1MJAQJlRQIFAmV6BQJlcgMJAAACBQJnUwUCZ1MJAM4IAgkAzggCBQJnQwUCZEUFAmdSCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAmVTARN1bnN0YWtlQW5kR2V0Tm9MZXNzAwJodQJoSAJoQwQCaGwDCQECYVkABgkAAAIFAmJsBQFuBAJmTQkAzAgCAwkBASEBBQJobAYJAAIBAiFnZXQgb3BlcmF0aW9uIGlzIGJsb2NrZWQgYnkgYWRtaW4JAMwIAgMJAAACCQCQAwEIBQJlUwhwYXltZW50cwAABgkAAgECGG5vIHBheW1lbnRzIGFyZSBleHBlY3RlZAUDbmlsAwkAAAIFAmZNBQJmTQQCZXoJAQJlcwMJALYCAQAACQC2AgEAAAkAtgIBAAADCQAAAgUCZXoFAmV6BAJodgkA/AcEBQJicwIHdW5zdGFrZQkAzAgCCQDYBAEFAmJtCQDMCAIFAmh1BQNuaWwFA25pbAMJAAACBQJodgUCaHYEAmRXCQECZGoECQDYBAEIBQJlUw10cmFuc2FjdGlvbklkCQDYBAEFAmJtBQJodQgFAmVTBmNhbGxlcgQCZEMIBQJkVwJfMQQCZEQIBQJkVwJfMgQCZEUIBQJkVwNfMTAEAmdDCQECY00CBQJkQwUCZEQEAmhJCQDMCAIDCQBnAgUCZEMFAmhIBgkAAgEJALkJAgkAzAgCAixhbW91bnQgYXNzZXQgYW1vdW50IHRvIHJlY2VpdmUgaXMgbGVzcyB0aGFuIAkAzAgCCQCkAwEFAmhIBQNuaWwCAAkAzAgCAwkAZwIFAmREBQJoQwYJAAIBCQC5CQIJAMwIAgIrcHJpY2UgYXNzZXQgYW1vdW50IHRvIHJlY2VpdmUgaXMgbGVzcyB0aGFuIAkAzAgCCQCkAwEFAmhDBQNuaWwCAAUDbmlsAwkAAAIFAmhJBQJoSQQCaHoJAPwHBAUCYVQCBGJ1cm4JAMwIAgUCaHUFA25pbAkAzAgCCQEPQXR0YWNoZWRQYXltZW50AgUCYm0FAmh1BQNuaWwDCQAAAgUCaHoFAmh6BAJoSgkBAmVBAwkBAS0BBQJkQwkBAS0BBQJkRAAABAJnUggFAmhKAl8xBAJlcggFAmhKAl8yBAJnUwkBAmVFAgUCZXoFAmVyAwkAAAIFAmdTBQJnUwkAzggCCQDOCAIFAmdDBQJkRQUCZ1IJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4CZVMBCGFjdGl2YXRlAgJoSwJoTAMJAQIhPQIJAKUIAQgFAmVTBmNhbGxlcgkApQgBBQJhVAkAAgECEnBlcm1pc3Npb25zIGRlbmllZAkAlAoCCQDMCAIJAQtTdHJpbmdFbnRyeQIJAQJhZQAFAmhLCQDMCAIJAQtTdHJpbmdFbnRyeQIJAQJhZgAFAmhMBQNuaWwCB3N1Y2Nlc3MCZVMBCnJlZnJlc2hLTHAABAJoTQkBC3ZhbHVlT3JFbHNlAgkAnwgBBQJhawAABAJoTgMJAGcCCQBlAgUGaGVpZ2h0BQJoTQUCYW4FBHVuaXQJAQJhUQEJALkJAgkAzAgCCQCkAwEFAmFuCQDMCAICLyBibG9ja3MgaGF2ZSBub3QgcGFzc2VkIHNpbmNlIHRoZSBwcmV2aW91cyBjYWxsBQNuaWwCAAMJAAACBQJoTgUCaE4EAmVMCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAKgDAQkBC3ZhbHVlT3JFbHNlAgkAnQgCBQR0aGlzBQJhagIBMAkBAmFTAQILaW52YWxpZCBrTHAEAmhPCQECZUEDAAAAAAAABAJoUAgFAmhPAl8xBAJlcggFAmhPAl8yBAJlRAMJAQIhPQIFAmVMBQJlcgUCaFAJAQJhUQECEm5vdGhpbmcgdG8gcmVmcmVzaAkAlAoCBQJlRAkApgMBBQJlcgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgJlUwEcZ2V0UG9vbENvbmZpZ1dyYXBwZXJSRUFET05MWQAJAJQKAgUDbmlsCQECYmEAAmVTARxnZXRBY2NCYWxhbmNlV3JhcHBlclJFQURPTkxZAQJhcAkAlAoCBQNuaWwJAQJiSgEFAmFwAmVTARljYWxjUHJpY2VzV3JhcHBlclJFQURPTkxZAwJjVQJjVgJjWgQCZGkJAQJjWQMFAmNVBQJjVgUCY1oJAJQKAgUDbmlsCQDMCAIJAKYDAQkAkQMCBQJkaQAACQDMCAIJAKYDAQkAkQMCBQJkaQABCQDMCAIJAKYDAQkAkQMCBQJkaQACBQNuaWwCZVMBFHRvWDE4V3JhcHBlclJFQURPTkxZAgFFAUYJAJQKAgUDbmlsCQCmAwEJAQFEAgUBRQUBRgJlUwEWZnJvbVgxOFdyYXBwZXJSRUFET05MWQIBSQFKCQCUCgIFA25pbAkBAUgCCQCnAwEFAUkFAUoCZVMBHmNhbGNQcmljZUJpZ0ludFdyYXBwZXJSRUFET05MWQICYk4CYk8JAJQKAgUDbmlsCQCmAwEJAQJiTQIJAKcDAQUCYk4JAKcDAQUCYk8CZVMBI2VzdGltYXRlUHV0T3BlcmF0aW9uV3JhcHBlclJFQURPTkxZCQJkawJkRwJkSAJkSQJkSgJkSwJhYgJkTAJkTQkAlAoCBQNuaWwJAQJkRgkFAmRrBQJkRwUCZEgFAmRJBQJkSgUCZEsFAmFiBQJkTAUCZE0CZVMBI2VzdGltYXRlR2V0T3BlcmF0aW9uV3JhcHBlclJFQURPTkxZBAJkawJkbAJkbQJhYgQCZFcJAQJkagQFAmRrBQJkbAUCZG0JARFAZXh0ck5hdGl2ZSgxMDYyKQEFAmFiCQCUCgIFA25pbAkAnAoKCAUCZFcCXzEIBQJkVwJfMggFAmRXAl8zCAUCZFcCXzQIBQJkVwJfNQgFAmRXAl82CAUCZFcCXzcJAKYDAQgFAmRXAl84CAUCZFcCXzkIBQJkVwNfMTACZVMBDXN0YXRzUkVBRE9OTFkABAJkYQkBAmJhAAQCZG4JANkEAQkAkQMCBQJkYQUBcQQCaFEJAJEDAgUCZGEFAXIEAmhSCQCRAwIFAmRhBQFzBAJkUAkAkQMCBQJkYQUBdgQCZFEJAJEDAgUCZGEFAXcEAmRiCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUCZGEFAXQEAmRjCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUCZGEFAXUEAmhTCAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQDsBwEFAmRuCQCsAgIJAKwCAgIGQXNzZXQgCQDYBAEFAmRuAg4gZG9lc24ndCBleGlzdAhxdWFudGl0eQQCaFQJAQJiSgEFAmhRBAJoVQkBAmJKAQUCaFIEAmhWAwkAAAIFAmhTAAAJAMwIAgUBZQkAzAgCBQFlCQDMCAIFAWUFA25pbAkBAmNZAwUCaFQFAmhVBQJoUwQCZHgAAAQCaFcJAQFIAgkAkQMCBQJoVgABBQFiBAJoWAkBAUgCCQCRAwIFAmhWAAIFAWIEAmhZCQEFdmFsdWUBCQCaCAIFAmFUCQECYUQBCQClCAEFBHRoaXMJAJQKAgUDbmlsCQC5CQIJAMwIAgIOJWQlZCVkJWQlZCVkJWQJAMwIAgkApAMBBQJoVAkAzAgCCQCkAwEFAmhVCQDMCAIJAKQDAQUCaFMJAMwIAgkApAMBBQJkeAkAzAgCCQCkAwEFAmhXCQDMCAIJAKQDAQUCaFgJAMwIAgkApAMBBQJoWQUDbmlsBQFqAmVTASBldmFsdWF0ZVB1dEJ5QW1vdW50QXNzZXRSRUFET05MWQECZEgEAmRhCQECYmEABAJkbgkA2QQBCQCRAwIFAmRhBQFxBAJkTgkAkQMCBQJkYQUBcgQCZG8JANkEAQUCZE4EAmRPCQCRAwIFAmRhBQFzBAJkcAkA2QQBBQJkTwQCZGIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQJkYQUBdAQCZGMJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQJkYQUBdQQCZHEJAJEDAgUCZGEFAXAEAmhTCAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQDsBwEFAmRuCQCsAgIJAKwCAgIGQXNzZXQgCQDYBAEFAmRuAg4gZG9lc24ndCBleGlzdAhxdWFudGl0eQQCaFQJAQJiSgEFAmROBAJoVQkBAmJKAQUCZE8EAmNXCQEBRAIFAmhUBQJkYgQCY1gJAQFEAgUCaFUFAmRjBAJkdwMJAAACBQJoUwAABQFlCQECYk0CBQJjWAUCY1cEAmRUCQEBRAIFAmRIBQJkYgQCZFUJALwCAwUCZFQFAmR3BQFkBAJkSgkBAUgCBQJkVQUCZGMEAmVZCQECZEYJAgAAoMIeBQJkSAUCZG8FAmRKBQJkcAIABgcEAmVlCAUCZVkCXzEEAmhaCAUCZVkCXzMEAmRzCAUCZVkCXzQEAmR1CAUCZVkCXzUEAmRyCAUCZVkCXzYJAJQKAgUDbmlsCQC5CQIJAMwIAgIQJWQlZCVkJWQlZCVkJWQlZAkAzAgCCQCkAwEFAmVlCQDMCAIJAKQDAQkBAUgCBQJkdwUBYgkAzAgCCQCkAwEFAmRzCQDMCAIJAKQDAQUCZHUJAMwIAgkApAMBBQJkcgkAzAgCBQJkcQkAzAgCCQCkAwEFAmRICQDMCAIJAKQDAQUCZEoFA25pbAUBagJlUwEfZXZhbHVhdGVQdXRCeVByaWNlQXNzZXRSRUFET05MWQECZEoEAmRhCQECYmEABAJkbgkA2QQBCQCRAwIFAmRhBQFxBAJkTgkAkQMCBQJkYQUBcgQCZG8JANkEAQUCZE4EAmRPCQCRAwIFAmRhBQFzBAJkcAkA2QQBBQJkTwQCZGIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQJkYQUBdAQCZGMJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQJkYQUBdQQCZHEJAJEDAgUCZGEFAXAEAmhTCAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQDsBwEFAmRuCQCsAgIJAKwCAgIGQXNzZXQgCQDYBAEFAmRuAg4gZG9lc24ndCBleGlzdAhxdWFudGl0eQQCaWEJAQJiSgEFAmROBAJpYgkBAmJKAQUCZE8EAmljCQEBRAIFAmlhBQJkYgQCaWQJAQFEAgUCaWIFAmRjBAJkdwMJAAACBQJoUwAABQFlCQECYk0CBQJpZAUCaWMEAmRVCQEBRAIFAmRKBQJkYwQCZFQJALwCAwUCZFUFAWQFAmR3BAJkSAkBAUgCBQJkVAUCZGIEAmVZCQECZEYJAgAAoMIeBQJkSAUCZG8FAmRKBQJkcAIABgcEAmVlCAUCZVkCXzEEAmhaCAUCZVkCXzMEAmRzCAUCZVkCXzQEAmR1CAUCZVkCXzUEAmRyCAUCZVkCXzYJAJQKAgUDbmlsCQC5CQIJAMwIAgIQJWQlZCVkJWQlZCVkJWQlZAkAzAgCCQCkAwEFAmVlCQDMCAIJAKQDAQkBAUgCBQJkdwUBYgkAzAgCCQCkAwEFAmRzCQDMCAIJAKQDAQUCZHUJAMwIAgkApAMBBQJkcgkAzAgCBQJkcQkAzAgCCQCkAwEFAmRICQDMCAIJAKQDAQUCZEoFA25pbAUBagJlUwETZXZhbHVhdGVHZXRSRUFET05MWQICaWUCaWYEAmRXCQECZGoEAgAFAmllBQJpZgUEdGhpcwQCZEMIBQJkVwJfMQQCZEQIBQJkVwJfMgQCZHMIBQJkVwJfNQQCZHUIBQJkVwJfNgQCZHIIBQJkVwJfNwQCZHgIBQJkVwJfOAQCZHEJAQ1wYXJzZUludFZhbHVlAQgFAmRXAl85CQCUCgIFA25pbAkAuQkCCQDMCAICDiVkJWQlZCVkJWQlZCVkCQDMCAIJAKQDAQUCZEMJAMwIAgkApAMBBQJkRAkAzAgCCQCkAwEFAmRzCQDMCAIJAKQDAQUCZHUJAMwIAgkApAMBBQJkcgkAzAgCCQCmAwEFAmR4CQDMCAIJAKQDAQUCZHEFA25pbAUBagECaWcBAmloAAQCaWkEAmJUCQECZ2UAAwkAAQIFAmJUAgpCeXRlVmVjdG9yBAJnaQUCYlQFAmdpAwkAAQIFAmJUAgRVbml0CAUCaWcPc2VuZGVyUHVibGljS2V5CQACAQILTWF0Y2ggZXJyb3IEAmJUBQJpZwMJAAECBQJiVAIFT3JkZXIEAmVIBQJiVAQCaWoJAQJhWgAEAmlrCQECZUcBBQJlSAQCYUkIBQJpawJfMQQCYUoIBQJpawJfMgQCYUsJAPQDAwgFAmVICWJvZHlCeXRlcwkAkQMCCAUCZUgGcHJvb2ZzAAAIBQJlSA9zZW5kZXJQdWJsaWNLZXkEAmFMCQD0AwMIBQJlSAlib2R5Qnl0ZXMJAJEDAggFAmVIBnByb29mcwABBQJpagMDAwUCYUkFAmFLBwUCYUwHBgkBAmFIBAUCYUkFAmFKBQJhSwUCYUwDCQABAgUCYlQCFFNldFNjcmlwdFRyYW5zYWN0aW9uBAJnZgUCYlQDCQD0AwMIBQJpZwlib2R5Qnl0ZXMJAJEDAggFAmlnBnByb29mcwAABQJpaQYEAmlsCQD2AwEJAQV2YWx1ZQEIBQJnZgZzY3JpcHQEAmltCQDbBAEJAQV2YWx1ZQEJAJ0IAgUCYVQJAQJhRgAEAmluCQDxBwEFBHRoaXMDCQAAAgUCaW0FAmlsCQECIT0CBQJpbgUCaWwHCQD0AwMIBQJpZwlib2R5Qnl0ZXMJAJEDAggFAmlnBnByb29mcwAABQJpaQh2GPI=",
    "height": 3599554,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: Fbs6ZkBAdj1CUAUXUPboD3dCrDY9GMNdGUW6TVUQXkjC
Next: 9qtc4yRMEb7sLh2RvpHf3KtWZLCyWEugcPSFswMDAFNg

Diff: 

OldNewDifferences
130130 
131131 let an = valueOrElse(getInteger(this, al), am)
132132 
133-func ao () = "%s__factoryConfig"
133+func ao (ap) = makeString(["%s%s", "stakedBalance", ap], j)
134134 
135135 
136-func ap () = "%s%s__matcher__publicKey"
136+func aq (ap) = makeString(["%s%s", "shareAssetBalance", ap], j)
137137 
138138 
139-func aq (ar) = (("%s%s%s__" + ar) + "__mappings__poolContract2LpAsset")
139+func ar (ap) = valueOrElse(getInteger(this, ao(ap)), 0)
140140 
141141 
142-func as (at,au) = (((("%d%d%s__" + at) + "__") + au) + "__config")
142+func as (ap) = valueOrElse(getInteger(this, aq(ap)), 0)
143143 
144144 
145-func av (aw) = ("%s%s%s__mappings__baseAsset2internalId__" + aw)
145+func at () = "%s__factoryConfig"
146146 
147147 
148-func ax () = "%s__shutdown"
148+func au () = "%s%s__matcher__publicKey"
149149 
150150 
151-func ay (az) = ("%s%s__poolWeight__" + az)
151+func av (aw) = (("%s%s%s__" + aw) + "__mappings__poolContract2LpAsset")
152152 
153153 
154-func aA () = "%s__allowedLpScriptHash"
154+func ax (ay,az) = (((("%d%d%s__" + ay) + "__") + az) + "__config")
155155 
156156 
157-let aB = "%s__feeCollectorAddress"
158-
159-func aC (aD,aE,aF,aG) = throw((((((((("order validation failed: orderValid=" + toString(aD)) + " (") + aE) + ")") + " senderValid=") + toString(aF)) + " matcherValid=") + toString(aG)))
157+func aA (aB) = ("%s%s%s__mappings__baseAsset2internalId__" + aB)
160158 
161159 
162-func aH (aI,aJ) = valueOrErrorMessage(getString(aI, aJ), makeString(["mandatory ", toString(aI), ".", aJ, " is not defined"], ""))
160+func aC () = "%s__shutdown"
163161 
164162 
165-func aK (aI,aJ) = valueOrErrorMessage(getInteger(aI, aJ), makeString(["mandatory ", toString(aI), ".", aJ, " is not defined"], ""))
163+func aD (aE) = ("%s%s__poolWeight__" + aE)
166164 
167165 
168-func aL (aM) = throw(makeString(["lp.ride:", aM], " "))
166+func aF () = "%s__allowedLpScriptHash"
169167 
170168 
171-func aN (aM) = makeString(["lp.ride:", aM], " ")
169+let aG = "%s__feeCollectorAddress"
170+
171+func aH (aI,aJ,aK,aL) = throw((((((((("order validation failed: orderValid=" + toString(aI)) + " (") + aJ) + ")") + " senderValid=") + toString(aK)) + " matcherValid=") + toString(aL)))
172172 
173173 
174-let aO = addressFromStringValue(aH(this, T()))
174+func aM (aN,aO) = valueOrErrorMessage(getString(aN, aO), makeString(["mandatory ", toString(aN), ".", aO, " is not defined"], ""))
175175 
176-let aP = addressFromStringValue(aH(aO, aB))
177176 
178-let aQ = {
179-    let aR = invoke(aO, "getInFeeREADONLY", [toString(this)], nil)
180-    if ($isInstanceOf(aR, "Int"))
181-        then aR
182-        else throw(($getType(aR) + " couldn't be cast to Int"))
177+func aP (aN,aO) = valueOrErrorMessage(getInteger(aN, aO), makeString(["mandatory ", toString(aN), ".", aO, " is not defined"], ""))
178+
179+
180+func aQ (aR) = throw(makeString(["lp.ride:", aR], " "))
181+
182+
183+func aS (aR) = makeString(["lp.ride:", aR], " ")
184+
185+
186+let aT = addressFromStringValue(aM(this, T()))
187+
188+let aU = addressFromStringValue(aM(aT, aG))
189+
190+let aV = {
191+    let aW = invoke(aT, "getInFeeREADONLY", [toString(this)], nil)
192+    if ($isInstanceOf(aW, "Int"))
193+        then aW
194+        else throw(($getType(aW) + " couldn't be cast to Int"))
183195     }
184196 
185-let aS = {
186-    let aR = invoke(aO, "getOutFeeREADONLY", [toString(this)], nil)
187-    if ($isInstanceOf(aR, "Int"))
188-        then aR
189-        else throw(($getType(aR) + " couldn't be cast to Int"))
197+let aX = {
198+    let aW = invoke(aT, "getOutFeeREADONLY", [toString(this)], nil)
199+    if ($isInstanceOf(aW, "Int"))
200+        then aW
201+        else throw(($getType(aW) + " couldn't be cast to Int"))
190202     }
191203 
192-func aT () = valueOrElse(getBoolean(aO, ax()), false)
204+func aY () = valueOrElse(getBoolean(aT, aC()), false)
193205 
194206 
195-func aU () = fromBase58String(aH(aO, ap()))
207+func aZ () = fromBase58String(aM(aT, au()))
196208 
197209 
198-func aV () = {
199-    let aW = aH(this, ae())
200-    let aX = aH(this, af())
201-    let au = aK(aO, av(aX))
202-    let at = aK(aO, av(aW))
203-    split(aH(aO, as(toString(at), toString(au))), j)
210+func ba () = {
211+    let bb = aM(this, ae())
212+    let bc = aM(this, af())
213+    let az = aP(aT, aA(bc))
214+    let ay = aP(aT, aA(bb))
215+    split(aM(aT, ax(toString(ay), toString(az))), j)
204216     }
205217 
206218 
207-func aY (aZ) = if ((aZ == i))
219+func bd (be) = if ((be == i))
208220     then unit
209-    else fromBase58String(aZ)
221+    else fromBase58String(be)
210222 
211223 
212-func ba (aZ) = if ((aZ == unit))
224+func bf (be) = if ((be == unit))
213225     then i
214-    else toBase58String(value(aZ))
226+    else toBase58String(value(be))
215227 
216228 
217-func bb (bc) = $Tuple7(addressFromStringValue(bc[o]), parseIntValue(bc[p]), fromBase58String(bc[q]), aY(bc[r]), aY(bc[s]), parseIntValue(bc[t]), parseIntValue(bc[u]))
229+func bg (bh) = $Tuple7(addressFromStringValue(bh[o]), parseIntValue(bh[p]), fromBase58String(bh[q]), bd(bh[r]), bd(bh[s]), parseIntValue(bh[t]), parseIntValue(bh[u]))
218230 
219231 
220-let bd = bb(aV())
232+let bi = bg(ba())
221233 
222-let be = bd
234+let bj = bi
223235 
224-let bf = be._1
236+let bk = bj._1
225237 
226-let bg = be._2
238+let bl = bj._2
227239 
228-let bh = be._3
240+let bm = bj._3
229241 
230-let bi = be._4
242+let bn = bj._4
231243 
232-let bj = be._5
244+let bo = bj._5
233245 
234-let bk = be._6
246+let bp = bj._6
235247 
236-let bl = be._7
248+let bq = bj._7
237249 
238-func bm () = split(aH(aO, ao()), j)
250+func br () = split(aM(aT, at()), j)
239251 
240252 
241-let bn = valueOrErrorMessage(addressFromString(bm()[B]), "incorrect staking address")
253+let bs = valueOrErrorMessage(addressFromString(br()[B]), "incorrect staking address")
242254 
243-let bo = valueOrErrorMessage(addressFromString(bm()[C]), "incorrect staking address")
255+let bt = valueOrErrorMessage(addressFromString(br()[C]), "incorrect staking address")
244256 
245-func bp (bq,br,bs,bt,bu,bv,bw,bx,by,bz) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(bq), toString(br), toString(bs), toString(bt), toString(bu), toString(bv), toString(bw), toString(bx), toString(by), toString(bz)], j)
257+func bu (bv,bw,bx,by,bz,bA,bB,bC,bD,bE) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(bv), toString(bw), toString(bx), toString(by), toString(bz), toString(bA), toString(bB), toString(bC), toString(bD), toString(bE)], j)
246258 
247259 
248-func bA (bB,bC,bD,bt,bw,bx) = makeString(["%d%d%d%d%d%d", toString(bB), toString(bC), toString(bD), toString(bt), toString(bw), toString(bx)], j)
260+func bF (bG,bH,bI,by,bB,bC) = makeString(["%d%d%d%d%d%d", toString(bG), toString(bH), toString(bI), toString(by), toString(bB), toString(bC)], j)
249261 
250262 
251-func bE (bF) = if ((bF == "WAVES"))
252-    then wavesBalance(this).available
253-    else assetBalance(this, fromBase58String(bF))
254-
255-
256-func bG (bH,bI) = fraction(bH, d, bI)
257-
258-
259-func bJ (bH,bI,L) = fraction(bH, d, bI, L)
260-
261-
262-func bK (bL,bM,bN,bO) = {
263-    let bP = D(bN, bL)
264-    let bQ = D(bO, bM)
265-    bG(bQ, bP)
263+func bJ (ap) = {
264+    let bK = if ((ap == "WAVES"))
265+        then wavesBalance(this).available
266+        else assetBalance(this, fromBase58String(ap))
267+    let bL = ((bK + ar(ap)) - as(ap))
268+    max([0, bL])
266269     }
267270 
268271 
269-func bR (bN,bO,bS) = {
270-    let bT = aV()
271-    let bU = parseIntValue(bT[t])
272-    let bV = parseIntValue(bT[u])
273-    let bW = bK(bU, bV, bN, bO)
274-    let bI = D(bN, bU)
275-    let bH = D(bO, bV)
276-    let bX = D(bS, b)
277-    let bY = bG(bI, bX)
278-    let bZ = bG(bH, bX)
279-[bW, bY, bZ]
272+func bM (bN,bO) = fraction(bN, d, bO)
273+
274+
275+func bP (bN,bO,L) = fraction(bN, d, bO, L)
276+
277+
278+func bQ (bR) = {
279+    let bS = invoke(bR, "getRate", nil, nil)
280+    if ((bS == bS))
281+        then {
282+            let bT = bS
283+            if ($isInstanceOf(bT, "Int"))
284+                then {
285+                    let bU = bT
286+                    bU
287+                    }
288+                else aQ("proxy.getRate() unexpected value")
289+            }
290+        else throw("Strict value is not equal to itself.")
280291     }
281292 
282293 
283-func ca (bN,bO,bS) = {
284-    let cb = bR(bN, bO, bS)
285-[H(cb[0], b), H(cb[1], b), H(cb[2], b)]
286-    }
287-
288-
289-func cc (cd,ce,cf,ab) = {
290-    let bT = aV()
291-    let cg = bT[q]
292-    let ch = bT[r]
293-    let ci = bT[s]
294-    let bL = parseIntValue(bT[t])
295-    let bM = parseIntValue(bT[u])
296-    let cj = bT[p]
297-    let ck = valueOrErrorMessage(assetInfo(fromBase58String(cg)), (("Asset " + cg) + " doesn't exist")).quantity
298-    if ((cg != ce))
299-        then throw("Invalid asset passed.")
300-        else {
301-            let cl = bE(ch)
302-            let cm = D(cl, bL)
303-            let cn = bE(ci)
304-            let co = D(cn, bM)
305-            let cp = bG(co, cm)
306-            let cq = H(cp, b)
307-            let cr = D(cf, b)
308-            let cs = D(ck, b)
309-            let ct = fraction(cm, cr, cs)
310-            let cu = fraction(co, cr, cs)
311-            let cv = K(ct, bL, FLOOR)
312-            let cw = K(cu, bM, FLOOR)
313-            let cx = if ((cd == ""))
314-                then nil
315-                else [ScriptTransfer(ab, cv, if ((ch == "WAVES"))
316-                    then unit
317-                    else fromBase58String(ch)), ScriptTransfer(ab, cw, if ((ci == "WAVES"))
318-                    then unit
319-                    else fromBase58String(ci)), StringEntry(ad(toString(ab), cd), bA(cv, cw, cf, cq, height, lastBlock.timestamp)), IntegerEntry(W(), cq), IntegerEntry(X(height, lastBlock.timestamp), cq)]
320-            $Tuple10(cv, cw, ch, ci, cl, cn, ck, cp, cj, cx)
321-            }
322-    }
323-
324-
325-func cy (cd,cz,cA,cB,cC,cD,ab,cE,cF) = {
326-    let bT = aV()
327-    let cg = fromBase58String(bT[q])
328-    let cG = bT[r]
329-    let cH = bT[s]
330-    let cI = bT[v]
331-    let cJ = bT[w]
332-    let bU = parseIntValue(bT[t])
333-    let bV = parseIntValue(bT[u])
334-    let cj = bT[p]
335-    let ck = valueOrErrorMessage(assetInfo(cg), (("Asset " + toBase58String(cg)) + " doesn't exist")).quantity
336-    let cK = toBase58String(valueOrElse(cB, fromBase58String("WAVES")))
337-    let cL = toBase58String(valueOrElse(cD, fromBase58String("WAVES")))
338-    if (if ((cG != cK))
339-        then true
340-        else (cH != cL))
341-        then throw("Invalid amt or price asset passed.")
342-        else {
343-            let cl = if (cE)
344-                then bE(cG)
345-                else (bE(cG) - cA)
346-            let cn = if (cE)
347-                then bE(cH)
348-                else (bE(cH) - cC)
349-            let cM = D(cA, bU)
350-            let cN = D(cC, bV)
351-            let cO = bG(cN, cM)
352-            let cm = D(cl, bU)
353-            let co = D(cn, bV)
354-            let cP = if ((ck == 0))
294+func bV (ap,bW,bX,bR) = {
295+    let bY = ar(ap)
296+    if ((bY == bY))
297+        then {
298+            let bZ = as(bX)
299+            if ((bZ == bZ))
355300                 then {
356-                    let cp = e
357-                    let cQ = e
358-                    let bX = pow((cM * cN), 0, toBigInt(5), 1, 0, DOWN)
359-                    $Tuple5(H(bX, b), H(cM, bU), H(cN, bV), bG((co + cN), (cm + cM)), cQ)
301+                    let ca = bd(ap)
302+                    if ((bW > 0))
303+                        then {
304+                            let cb = invoke(bR, "deposit", nil, [AttachedPayment(ca, bW)])
305+                            if ((cb == cb))
306+                                then {
307+                                    let bT = cb
308+                                    if ($isInstanceOf(bT, "Int"))
309+                                        then {
310+                                            let cc = bT
311+                                            let cd = (bY + bW)
312+                                            let ce = (bZ + cc)
313+[IntegerEntry(ao(ap), cd), IntegerEntry(aq(bX), ce)]
314+                                            }
315+                                        else nil
316+                                    }
317+                                else throw("Strict value is not equal to itself.")
318+                            }
319+                        else nil
360320                     }
361-                else {
362-                    let cp = bG(co, cm)
363-                    let cQ = fraction(R((cp - cO)), d, cp)
364-                    let cR = D(cz, b)
365-                    if (if ((cp != e))
366-                        then (cQ > cR)
367-                        else false)
368-                        then throw(((("Price slippage " + toString(cQ)) + " exceeded the passed limit of ") + toString(cR)))
369-                        else {
370-                            let cs = D(ck, b)
371-                            let cS = fraction(cM, bJ(co, cm, CEILING), d, CEILING)
372-                            let cT = fraction(cN, d, bJ(co, cm, FLOOR), CEILING)
373-                            let cU = if ((cS > cN))
374-                                then $Tuple2(cT, cN)
375-                                else $Tuple2(cM, cS)
376-                            let cV = cU._1
377-                            let cW = cU._2
378-                            let bX = fraction(cs, cW, co, FLOOR)
379-                            $Tuple5(K(bX, b, FLOOR), K(cV, bU, CEILING), K(cW, bV, CEILING), cp, cQ)
380-                            }
381-                    }
382-            let cX = cP._1
383-            let cY = cP._2
384-            let cZ = cP._3
385-            let cq = H(cP._4, b)
386-            let da = H(cP._5, b)
387-            if ((0 >= cX))
388-                then throw("Invalid calculations. LP calculated is less than zero.")
389-                else {
390-                    let db = if (!(cF))
391-                        then 0
392-                        else cX
393-                    let dc = (cA - cY)
394-                    let dd = (cC - cZ)
395-                    let de = [IntegerEntry(W(), cq), IntegerEntry(X(height, lastBlock.timestamp), cq), StringEntry(aa(ab, cd), bp(cY, cZ, db, cq, cz, da, height, lastBlock.timestamp, dc, dd))]
396-                    $Tuple13(cX, db, cq, cl, cn, ck, cg, cj, de, dc, dd, cB, cD)
397-                    }
398-            }
399-    }
400-
401-
402-func df (dg,dh,ck) = {
403-    let di = G(dg, toBigInt(bk))
404-    let dj = G(dh, toBigInt(bl))
405-    let dk = fraction(pow((di * dj), 0, toBigInt(5), 1, 18, DOWN), g, ck)
406-    if ((ck == f))
407-        then f
408-        else dk
409-    }
410-
411-
412-func dl (dm,dn,do) = {
413-    let dp = (toBigInt(bE(ba(bi))) - dm)
414-    let dq = (toBigInt(bE(ba(bj))) - dn)
415-    let dr = (toBigInt(value(assetInfo(bh)).quantity) - do)
416-    let ds = df(dp, dq, dr)
417-    ds
418-    }
419-
420-
421-func dt (du,dv,do) = {
422-    let dp = (bE(ba(bi)) + du)
423-    let dq = (bE(ba(bj)) + dv)
424-    let dr = (value(assetInfo(bh)).quantity + do)
425-    let dk = df(toBigInt(dp), toBigInt(dq), toBigInt(dr))
426-    let dw = [IntegerEntry(ak, height), StringEntry(aj, toString(dk))]
427-    $Tuple2(dw, dk)
428-    }
429-
430-
431-func dx (dy,dk) = if ((dk >= dy))
432-    then true
433-    else aL(makeString(["updated KLp lower than current KLp", toString(dy), toString(dk)], " "))
434-
435-
436-func dz (dA) = {
437-    let dp = bE(ba(bi))
438-    let dq = bE(ba(bj))
439-    let dB = dA.amount
440-    let dC = fraction(dA.amount, dA.price, b, FLOOR)
441-    let dD = if ((dA.orderType == Buy))
442-        then $Tuple2(dB, -(dC))
443-        else $Tuple2(-(dB), dC)
444-    let du = dD._1
445-    let dv = dD._2
446-    if (if (if (aT())
447-        then true
448-        else (bg == m))
449-        then true
450-        else (bg == n))
451-        then throw("Exchange operations disabled")
452-        else if (if ((dA.assetPair.amountAsset != bi))
453-            then true
454-            else (dA.assetPair.priceAsset != bj))
455-            then throw("Wrong order assets.")
456-            else {
457-                let dE = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, aj), "0")), aN("invalid kLp"))
458-                let dF = dt(du, dv, 0)
459-                let dG = dF._1
460-                let dH = dF._2
461-                let dI = (dH >= dE)
462-                let dJ = makeString(["kLp=", toString(dE), " kLpNew=", toString(dH), " amountAssetBalance=", toString(dp), " priceAssetBalance=", toString(dq), " amountAssetBalanceDelta=", toString(du), " priceAssetBalanceDelta=", toString(dv), " height=", toString(height)], "")
463-                $Tuple2(dI, dJ)
464-                }
465-    }
466-
467-
468-func dK (dL) = if ((size(dL.payments) != 1))
469-    then throw("exactly 1 payment is expected")
470-    else {
471-        let dM = value(dL.payments[0])
472-        let ce = value(dM.assetId)
473-        let dN = dM.amount
474-        let cP = cc(toBase58String(dL.transactionId), toBase58String(ce), dN, dL.caller)
475-        let cv = cP._1
476-        let cw = cP._2
477-        let cj = parseIntValue(cP._9)
478-        let cx = cP._10
479-        if (if (aT())
480-            then true
481-            else (cj == n))
482-            then throw(("Get operation is blocked by admin. Status = " + toString(cj)))
483-            else $Tuple5(cv, cw, dN, ce, cx)
484-        }
485-
486-
487-func dO (dL,cz,cF) = if ((size(dL.payments) != 2))
488-    then throw("exactly 2 payments are expected")
489-    else {
490-        let dP = value(dL.payments[0])
491-        let dQ = value(dL.payments[1])
492-        let dR = cy(toBase58String(dL.transactionId), cz, dP.amount, dP.assetId, dQ.amount, dQ.assetId, toString(dL.caller), false, cF)
493-        let cj = parseIntValue(dR._8)
494-        if (if (if (aT())
495-            then true
496-            else (cj == l))
497-            then true
498-            else (cj == n))
499-            then throw(("Put operation is blocked by admin. Status = " + toString(cj)))
500-            else dR
501-        }
502-
503-
504-func dS (dT) = {
505-    let dU = invoke(aO, "emit", [dT], nil)
506-    if ((dU == dU))
507-        then {
508-            let dV = {
509-                let dW = dU
510-                if ($isInstanceOf(dW, "Address"))
511-                    then {
512-                        let dX = dW
513-                        invoke(dX, "emit", [dT], nil)
514-                        }
515-                    else unit
516-                }
517-            if ((dV == dV))
518-                then dT
519321                 else throw("Strict value is not equal to itself.")
520322             }
521323         else throw("Strict value is not equal to itself.")
522324     }
523325 
524326 
525-func dY (dT,ai) = {
526-    let dZ = if ((ai == 0))
527-        then 0
528-        else fraction(dT, ai, b)
529-    $Tuple2((dT - dZ), dZ)
530-    }
531-
532-
533-func ea (eb,ec,ab,ac) = {
534-    let ed = (ac == unit)
535-    let ee = bE(ba(bi))
536-    let ef = bE(ba(bj))
537-    let eg = if ((ec == bi))
538-        then true
539-        else if ((ec == bj))
540-            then false
541-            else aL("invalid asset")
542-    let eh = if (ed)
543-        then $Tuple2(ee, ef)
544-        else if (eg)
545-            then $Tuple2((ee - eb), ef)
546-            else $Tuple2(ee, (ef - eb))
547-    let ei = eh._1
548-    let ej = eh._2
549-    let ek = if (eg)
550-        then $Tuple2(eb, 0)
551-        else $Tuple2(0, eb)
552-    let el = ek._1
553-    let em = ek._2
554-    let dB = dY(el, aQ)._1
555-    let dC = dY(em, aQ)._1
556-    let en = dY(eb, aQ)
557-    let eo = en._1
558-    let dZ = en._2
559-    let ep = (ei + dB)
560-    let eq = (ej + dC)
561-    let er = bG(D(eq, bl), D(ep, bk))
562-    let es = H(er, b)
563-    let et = if (eg)
564-        then ei
565-        else ej
566-    let eu = toBigInt(et)
567-    let ev = toBigInt(valueOrErrorMessage(assetInfo(bh), (("asset " + toBase58String(bh)) + " doesn't exist")).quantity)
568-    let ew = if ((ev > f))
569-        then true
570-        else aL("initial deposit requires all coins")
571-    if ((ew == ew))
327+func cf (ap,bW,bX,bR,cg,ch) = {
328+    let bY = ar(ap)
329+    if ((bY == bY))
572330         then {
573-            let ex = toBigInt(eo)
574-            let ey = max([0, toInt(((ev * (sqrtBigInt((d + ((ex * d) / eu)), 18, 18, DOWN) - d)) / d))])
575-            let de = if (ed)
576-                then nil
577-                else [IntegerEntry(W(), es), IntegerEntry(X(height, lastBlock.timestamp), es), StringEntry(aa(toString(value(ab)), toBase58String(value(ac))), bp(el, em, ey, es, 0, 0, height, lastBlock.timestamp, 0, 0))]
578-            let ez = bG(D(ej, bl), D(ei, bk))
579-            let eA = H(ez, b)
580-            let eB = {
581-                let eC = if (eg)
582-                    then $Tuple2(el, ei)
583-                    else $Tuple2(em, ej)
584-                let dT = eC._1
585-                let eD = eC._2
586-                let eE = toInt(fraction(ev, toBigInt((dT / 2)), toBigInt(eD)))
587-                fraction((ey - eE), b, eE)
588-                }
589-            $Tuple5(ey, de, dZ, eB, eg)
331+            let bZ = as(bX)
332+            if ((bZ == bZ))
333+                then {
334+                    let ci = bQ(bR)
335+                    if ((ci == ci))
336+                        then {
337+                            let cj = fraction(cg, bY, bZ)
338+                            let ck = bd(bX)
339+                            let cl = fraction(cg, bW, cj)
340+                            let cm = fraction(cg, bW, ci)
341+                            let cn = max([0, (cl - cm)])
342+                            if ((cm > 0))
343+                                then {
344+                                    let co = invoke(bR, "withdraw", nil, [AttachedPayment(ck, cm)])
345+                                    if ((co == co))
346+                                        then {
347+                                            let bT = co
348+                                            if ($isInstanceOf(bT, "Int"))
349+                                                then {
350+                                                    let cp = bT
351+                                                    let cd = (bY - cp)
352+                                                    let ce = ((bZ - cm) - cn)
353+[IntegerEntry(ao(ap), cd), IntegerEntry(aq(bX), ce), ScriptTransfer(ch, cn, bd(bX))]
354+                                                    }
355+                                                else nil
356+                                            }
357+                                        else throw("Strict value is not equal to itself.")
358+                                    }
359+                                else nil
360+                            }
361+                        else throw("Strict value is not equal to itself.")
362+                    }
363+                else throw("Strict value is not equal to itself.")
590364             }
591365         else throw("Strict value is not equal to itself.")
592366     }
593367 
594368 
595-func eF (eG,eo,ec,ab,ac) = {
596-    let ed = (ac == unit)
597-    let bT = aV()
598-    let bU = parseIntValue(bT[t])
599-    let bV = parseIntValue(bT[u])
600-    let eH = [if ((ec == bh))
601-        then true
602-        else aL("invalid lp asset")]
603-    if ((eH == eH))
369+func cq (ap) = {
370+    let bT = invoke(aT, "getPoolLeaseConfigREADONLY", [toString(this), ap], nil)
371+    if ($isInstanceOf(bT, "(Boolean, Int, Int, String, String, Int, String)"))
604372         then {
605-            let eI = if ((eG == bi))
606-                then true
607-                else if ((eG == bj))
608-                    then false
609-                    else aL("invalid asset")
610-            let eJ = if (eI)
611-                then toBigInt(bE(ba(bi)))
612-                else toBigInt(bE(ba(bj)))
613-            let eK = if (eI)
614-                then bU
615-                else bV
616-            let eL = bE(ba(bi))
617-            let eM = bE(ba(bj))
618-            let eN = if (eI)
619-                then eL
620-                else eM
621-            let eO = toBigInt(eN)
622-            let ev = toBigInt(valueOrErrorMessage(assetInfo(bh), (("asset " + toBase58String(bh)) + " doesn't exist")).quantity)
623-            let eP = toBigInt(eo)
624-            let eQ = max([0, toInt(((eJ * (d - pow((d - ((eP * d) / ev)), 18, h, 0, 18, DOWN))) / d))])
625-            let eR = dY(eQ, aS)
626-            let eS = eR._1
627-            let dZ = eR._2
628-            let eT = if (eI)
629-                then $Tuple4(eS, 0, (eL - eQ), eM)
630-                else $Tuple4(0, eS, eL, (eM - eQ))
631-            let eU = eT._1
632-            let eV = eT._2
633-            let eW = eT._3
634-            let eX = eT._4
635-            let er = bG(D(eX, bl), D(eW, bk))
636-            let es = H(er, b)
637-            let de = if (ed)
638-                then nil
639-                else [StringEntry(ad(toString(value(ab)), toBase58String(value(ac))), bA(eU, eV, eo, es, height, lastBlock.timestamp)), IntegerEntry(W(), es), IntegerEntry(X(height, lastBlock.timestamp), es)]
640-            let ez = bG(D(eM, bl), D(eL, bk))
641-            let eA = H(ez, b)
642-            let eB = {
643-                let eY = (toInt(fraction(eJ, eP, ev)) * 2)
644-                fraction((eS - eY), b, eY)
645-                }
646-            $Tuple5(eS, de, dZ, eB, eI)
373+            let cr = bT
374+            cr
375+            }
376+        else aQ((("[" + ap) + "] getLeaseProxyConfig() error"))
377+    }
378+
379+
380+func cs (ct,ap,bX,cu,bR,cg,ch) = {
381+    let bY = ar(ap)
382+    if ((bY == bY))
383+        then {
384+            let bZ = as(bX)
385+            if ((bZ == bZ))
386+                then {
387+                    let cv = max([0, (bJ(ap) - cu)])
388+                    let cw = fraction(ct, cv, 100)
389+                    let cx = (bY - cw)
390+                    if ((cx == 0))
391+                        then nil
392+                        else if ((0 > cx))
393+                            then {
394+                                let cy = -(cx)
395+                                bV(ap, cy, bX, bR)
396+                                }
397+                            else {
398+                                let cz = cx
399+                                cf(ap, cz, bX, bR, cg, ch)
400+                                }
401+                    }
402+                else throw("Strict value is not equal to itself.")
647403             }
648404         else throw("Strict value is not equal to itself.")
649405     }
650406 
651407 
652-func eZ () = {
653-    let dW = getString(U())
654-    if ($isInstanceOf(dW, "String"))
408+func cA (ap) = {
409+    let cB = cq(ap)
410+    let cC = cB._1
411+    let cD = cB._2
412+    let cu = cB._3
413+    let cE = cB._4
414+    let cF = cB._5
415+    let cg = cB._6
416+    let cG = cB._7
417+    if (cC)
418+        then cs(cD, ap, cF, cu, addressFromStringValue(cE), cg, addressFromStringValue(cG))
419+        else nil
420+    }
421+
422+
423+func cH (ap,cI) = {
424+    let cJ = cq(ap)
425+    let cC = cJ._1
426+    let cD = cJ._2
427+    let cu = cJ._3
428+    let cE = cJ._4
429+    let cF = cJ._5
430+    let cg = cJ._6
431+    let cG = cJ._7
432+    if (cC)
655433         then {
656-            let fa = dW
657-            fromBase58String(fa)
434+            let cK = max([0, ((bJ(ap) - cI) - cu)])
435+            if ((cK == cK))
436+                then {
437+                    let cd = fraction(cD, cK, 100)
438+                    if ((cd == cd))
439+                        then {
440+                            let cL = (ar(ap) - cd)
441+                            if ((cL == cL))
442+                                then if ((0 > cL))
443+                                    then bV(ap, -(cL), cF, addressFromStringValue(cE))
444+                                    else cf(ap, cL, cF, addressFromStringValue(cE), cg, addressFromStringValue(cG))
445+                                else throw("Strict value is not equal to itself.")
446+                            }
447+                        else throw("Strict value is not equal to itself.")
448+                    }
449+                else throw("Strict value is not equal to itself.")
658450             }
659-        else if ($isInstanceOf(dW, "Unit"))
451+        else nil
452+    }
453+
454+
455+func cM (cN,cO) = {
456+    let cP = cH(aM(this, ae()), cN)
457+    let cQ = cH(aM(this, af()), cO)
458+    (cP ++ cQ)
459+    }
460+
461+
462+func cR (cS,cT,cU,cV) = {
463+    let cW = D(cU, cS)
464+    let cX = D(cV, cT)
465+    bM(cX, cW)
466+    }
467+
468+
469+func cY (cU,cV,cZ) = {
470+    let da = ba()
471+    let db = parseIntValue(da[t])
472+    let dc = parseIntValue(da[u])
473+    let dd = cR(db, dc, cU, cV)
474+    let bO = D(cU, db)
475+    let bN = D(cV, dc)
476+    let de = D(cZ, b)
477+    let df = bM(bO, de)
478+    let dg = bM(bN, de)
479+[dd, df, dg]
480+    }
481+
482+
483+func dh (cU,cV,cZ) = {
484+    let di = cY(cU, cV, cZ)
485+[H(di[0], b), H(di[1], b), H(di[2], b)]
486+    }
487+
488+
489+func dj (dk,dl,dm,ab) = {
490+    let da = ba()
491+    let dn = da[q]
492+    let do = da[r]
493+    let dp = da[s]
494+    let cS = parseIntValue(da[t])
495+    let cT = parseIntValue(da[u])
496+    let dq = da[p]
497+    let dr = valueOrErrorMessage(assetInfo(fromBase58String(dn)), (("Asset " + dn) + " doesn't exist")).quantity
498+    if ((dn != dl))
499+        then throw("Invalid asset passed.")
500+        else {
501+            let ds = bJ(do)
502+            let dt = D(ds, cS)
503+            let du = bJ(dp)
504+            let dv = D(du, cT)
505+            let dw = bM(dv, dt)
506+            let dx = H(dw, b)
507+            let dy = D(dm, b)
508+            let dz = D(dr, b)
509+            let dA = fraction(dt, dy, dz)
510+            let dB = fraction(dv, dy, dz)
511+            let dC = K(dA, cS, FLOOR)
512+            let dD = K(dB, cT, FLOOR)
513+            let dE = if ((dk == ""))
514+                then nil
515+                else [ScriptTransfer(ab, dC, if ((do == "WAVES"))
516+                    then unit
517+                    else fromBase58String(do)), ScriptTransfer(ab, dD, if ((dp == "WAVES"))
518+                    then unit
519+                    else fromBase58String(dp)), StringEntry(ad(toString(ab), dk), bF(dC, dD, dm, dx, height, lastBlock.timestamp)), IntegerEntry(W(), dx), IntegerEntry(X(height, lastBlock.timestamp), dx)]
520+            $Tuple10(dC, dD, do, dp, ds, du, dr, dw, dq, dE)
521+            }
522+    }
523+
524+
525+func dF (dk,dG,dH,dI,dJ,dK,ab,dL,dM) = {
526+    let da = ba()
527+    let dn = fromBase58String(da[q])
528+    let dN = da[r]
529+    let dO = da[s]
530+    let dP = da[v]
531+    let dQ = da[w]
532+    let db = parseIntValue(da[t])
533+    let dc = parseIntValue(da[u])
534+    let dq = da[p]
535+    let dr = valueOrErrorMessage(assetInfo(dn), (("Asset " + toBase58String(dn)) + " doesn't exist")).quantity
536+    let dR = toBase58String(valueOrElse(dI, fromBase58String("WAVES")))
537+    let dS = toBase58String(valueOrElse(dK, fromBase58String("WAVES")))
538+    if (if ((dN != dR))
539+        then true
540+        else (dO != dS))
541+        then throw("Invalid amt or price asset passed.")
542+        else {
543+            let ds = if (dL)
544+                then bJ(dN)
545+                else (bJ(dN) - dH)
546+            let du = if (dL)
547+                then bJ(dO)
548+                else (bJ(dO) - dJ)
549+            let dT = D(dH, db)
550+            let dU = D(dJ, dc)
551+            let dV = bM(dU, dT)
552+            let dt = D(ds, db)
553+            let dv = D(du, dc)
554+            let dW = if ((dr == 0))
555+                then {
556+                    let dw = e
557+                    let dX = e
558+                    let de = pow((dT * dU), 0, toBigInt(5), 1, 0, DOWN)
559+                    $Tuple5(H(de, b), H(dT, db), H(dU, dc), bM((dv + dU), (dt + dT)), dX)
560+                    }
561+                else {
562+                    let dw = bM(dv, dt)
563+                    let dX = fraction(R((dw - dV)), d, dw)
564+                    let dY = D(dG, b)
565+                    if (if ((dw != e))
566+                        then (dX > dY)
567+                        else false)
568+                        then throw(((("Price slippage " + toString(dX)) + " exceeded the passed limit of ") + toString(dY)))
569+                        else {
570+                            let dz = D(dr, b)
571+                            let dZ = fraction(dT, bP(dv, dt, CEILING), d, CEILING)
572+                            let ea = fraction(dU, d, bP(dv, dt, FLOOR), CEILING)
573+                            let eb = if ((dZ > dU))
574+                                then $Tuple2(ea, dU)
575+                                else $Tuple2(dT, dZ)
576+                            let ec = eb._1
577+                            let ed = eb._2
578+                            let de = fraction(dz, ed, dv, FLOOR)
579+                            $Tuple5(K(de, b, FLOOR), K(ec, db, CEILING), K(ed, dc, CEILING), dw, dX)
580+                            }
581+                    }
582+            let ee = dW._1
583+            let ef = dW._2
584+            let eg = dW._3
585+            let dx = H(dW._4, b)
586+            let eh = H(dW._5, b)
587+            if ((0 >= ee))
588+                then throw("Invalid calculations. LP calculated is less than zero.")
589+                else {
590+                    let ei = if (!(dM))
591+                        then 0
592+                        else ee
593+                    let ej = (dH - ef)
594+                    let ek = (dJ - eg)
595+                    let el = [IntegerEntry(W(), dx), IntegerEntry(X(height, lastBlock.timestamp), dx), StringEntry(aa(ab, dk), bu(ef, eg, ei, dx, dG, eh, height, lastBlock.timestamp, ej, ek))]
596+                    $Tuple13(ee, ei, dx, ds, du, dr, dn, dq, el, ej, ek, dI, dK)
597+                    }
598+            }
599+    }
600+
601+
602+func em (en,eo,dr) = {
603+    let ep = G(en, toBigInt(bp))
604+    let eq = G(eo, toBigInt(bq))
605+    let er = fraction(pow((ep * eq), 0, toBigInt(5), 1, 18, DOWN), g, dr)
606+    if ((dr == f))
607+        then f
608+        else er
609+    }
610+
611+
612+func es (et,eu,ev) = {
613+    let ew = (toBigInt(bJ(bf(bn))) - et)
614+    let ex = (toBigInt(bJ(bf(bo))) - eu)
615+    let ey = (toBigInt(value(assetInfo(bm)).quantity) - ev)
616+    let ez = em(ew, ex, ey)
617+    ez
618+    }
619+
620+
621+func eA (eB,eC,ev) = {
622+    let ew = (bJ(bf(bn)) + eB)
623+    let ex = (bJ(bf(bo)) + eC)
624+    let ey = (value(assetInfo(bm)).quantity + ev)
625+    let er = em(toBigInt(ew), toBigInt(ex), toBigInt(ey))
626+    let eD = [IntegerEntry(ak, height), StringEntry(aj, toString(er))]
627+    $Tuple2(eD, er)
628+    }
629+
630+
631+func eE (eF,er) = if ((er >= eF))
632+    then true
633+    else aQ(makeString(["updated KLp lower than current KLp", toString(eF), toString(er)], " "))
634+
635+
636+func eG (eH) = {
637+    let ew = bJ(bf(bn))
638+    let ex = bJ(bf(bo))
639+    let eI = eH.amount
640+    let eJ = fraction(eH.amount, eH.price, b, FLOOR)
641+    let eK = if ((eH.orderType == Buy))
642+        then $Tuple2(eI, -(eJ))
643+        else $Tuple2(-(eI), eJ)
644+    let eB = eK._1
645+    let eC = eK._2
646+    if (if (if (aY())
647+        then true
648+        else (bl == m))
649+        then true
650+        else (bl == n))
651+        then throw("Exchange operations disabled")
652+        else if (if ((eH.assetPair.amountAsset != bn))
653+            then true
654+            else (eH.assetPair.priceAsset != bo))
655+            then throw("Wrong order assets.")
656+            else {
657+                let eL = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, aj), "0")), aS("invalid kLp"))
658+                let eM = eA(eB, eC, 0)
659+                let eN = eM._1
660+                let eO = eM._2
661+                let eP = (eO >= eL)
662+                let eQ = makeString(["kLp=", toString(eL), " kLpNew=", toString(eO), " amountAssetBalance=", toString(ew), " priceAssetBalance=", toString(ex), " amountAssetBalanceDelta=", toString(eB), " priceAssetBalanceDelta=", toString(eC), " height=", toString(height)], "")
663+                $Tuple2(eP, eQ)
664+                }
665+    }
666+
667+
668+func eR (eS) = if ((size(eS.payments) != 1))
669+    then throw("exactly 1 payment is expected")
670+    else {
671+        let eT = value(eS.payments[0])
672+        let dl = value(eT.assetId)
673+        let eU = eT.amount
674+        let dW = dj(toBase58String(eS.transactionId), toBase58String(dl), eU, eS.caller)
675+        let dC = dW._1
676+        let dD = dW._2
677+        let dq = parseIntValue(dW._9)
678+        let dE = dW._10
679+        if (if (aY())
680+            then true
681+            else (dq == n))
682+            then throw(("Get operation is blocked by admin. Status = " + toString(dq)))
683+            else $Tuple5(dC, dD, eU, dl, dE)
684+        }
685+
686+
687+func eV (eS,dG,dM) = if ((size(eS.payments) != 2))
688+    then throw("exactly 2 payments are expected")
689+    else {
690+        let eW = value(eS.payments[0])
691+        let eX = value(eS.payments[1])
692+        let eY = dF(toBase58String(eS.transactionId), dG, eW.amount, eW.assetId, eX.amount, eX.assetId, toString(eS.caller), false, dM)
693+        let dq = parseIntValue(eY._8)
694+        if (if (if (aY())
695+            then true
696+            else (dq == l))
697+            then true
698+            else (dq == n))
699+            then throw(("Put operation is blocked by admin. Status = " + toString(dq)))
700+            else eY
701+        }
702+
703+
704+func eZ (bW) = {
705+    let fa = invoke(aT, "emit", [bW], nil)
706+    if ((fa == fa))
707+        then {
708+            let fb = {
709+                let bT = fa
710+                if ($isInstanceOf(bT, "Address"))
711+                    then {
712+                        let fc = bT
713+                        invoke(fc, "emit", [bW], nil)
714+                        }
715+                    else unit
716+                }
717+            if ((fb == fb))
718+                then bW
719+                else throw("Strict value is not equal to itself.")
720+            }
721+        else throw("Strict value is not equal to itself.")
722+    }
723+
724+
725+func fd (bW,ai) = {
726+    let fe = if ((ai == 0))
727+        then 0
728+        else fraction(bW, ai, b)
729+    $Tuple2((bW - fe), fe)
730+    }
731+
732+
733+func ff (fg,fh,ab,ac) = {
734+    let fi = (ac == unit)
735+    let fj = bJ(bf(bn))
736+    let fk = bJ(bf(bo))
737+    let fl = if ((fh == bn))
738+        then true
739+        else if ((fh == bo))
740+            then false
741+            else aQ("invalid asset")
742+    let fm = if (fi)
743+        then $Tuple2(fj, fk)
744+        else if (fl)
745+            then $Tuple2((fj - fg), fk)
746+            else $Tuple2(fj, (fk - fg))
747+    let fn = fm._1
748+    let fo = fm._2
749+    let fp = if (fl)
750+        then $Tuple2(fg, 0)
751+        else $Tuple2(0, fg)
752+    let fq = fp._1
753+    let fr = fp._2
754+    let eI = fd(fq, aV)._1
755+    let eJ = fd(fr, aV)._1
756+    let fs = fd(fg, aV)
757+    let ft = fs._1
758+    let fe = fs._2
759+    let fu = (fn + eI)
760+    let fv = (fo + eJ)
761+    let fw = bM(D(fv, bq), D(fu, bp))
762+    let fx = H(fw, b)
763+    let fy = if (fl)
764+        then fn
765+        else fo
766+    let fz = toBigInt(fy)
767+    let fA = toBigInt(valueOrErrorMessage(assetInfo(bm), (("asset " + toBase58String(bm)) + " doesn't exist")).quantity)
768+    let fB = if ((fA > f))
769+        then true
770+        else aQ("initial deposit requires all coins")
771+    if ((fB == fB))
772+        then {
773+            let fC = toBigInt(ft)
774+            let fD = max([0, toInt(((fA * (sqrtBigInt((d + ((fC * d) / fz)), 18, 18, DOWN) - d)) / d))])
775+            let el = if (fi)
776+                then nil
777+                else [IntegerEntry(W(), fx), IntegerEntry(X(height, lastBlock.timestamp), fx), StringEntry(aa(toString(value(ab)), toBase58String(value(ac))), bu(fq, fr, fD, fx, 0, 0, height, lastBlock.timestamp, 0, 0))]
778+            let fE = bM(D(fo, bq), D(fn, bp))
779+            let fF = H(fE, b)
780+            let fG = {
781+                let fH = if (fl)
782+                    then $Tuple2(fq, fn)
783+                    else $Tuple2(fr, fo)
784+                let bW = fH._1
785+                let fI = fH._2
786+                let fJ = toInt(fraction(fA, toBigInt((bW / 2)), toBigInt(fI)))
787+                fraction((fD - fJ), b, fJ)
788+                }
789+            $Tuple5(fD, el, fe, fG, fl)
790+            }
791+        else throw("Strict value is not equal to itself.")
792+    }
793+
794+
795+func fK (fL,ft,fh,ab,ac) = {
796+    let fi = (ac == unit)
797+    let da = ba()
798+    let db = parseIntValue(da[t])
799+    let dc = parseIntValue(da[u])
800+    let fM = [if ((fh == bm))
801+        then true
802+        else aQ("invalid lp asset")]
803+    if ((fM == fM))
804+        then {
805+            let fN = if ((fL == bn))
806+                then true
807+                else if ((fL == bo))
808+                    then false
809+                    else aQ("invalid asset")
810+            let fO = if (fN)
811+                then toBigInt(bJ(bf(bn)))
812+                else toBigInt(bJ(bf(bo)))
813+            let fP = if (fN)
814+                then db
815+                else dc
816+            let fQ = bJ(bf(bn))
817+            let fR = bJ(bf(bo))
818+            let fS = if (fN)
819+                then fQ
820+                else fR
821+            let fT = toBigInt(fS)
822+            let fA = toBigInt(valueOrErrorMessage(assetInfo(bm), (("asset " + toBase58String(bm)) + " doesn't exist")).quantity)
823+            let fU = toBigInt(ft)
824+            let fV = max([0, toInt(((fO * (d - pow((d - ((fU * d) / fA)), 18, h, 0, 18, DOWN))) / d))])
825+            let fW = fd(fV, aX)
826+            let fX = fW._1
827+            let fe = fW._2
828+            let fY = if (fN)
829+                then $Tuple4(fX, 0, (fQ - fV), fR)
830+                else $Tuple4(0, fX, fQ, (fR - fV))
831+            let fZ = fY._1
832+            let ga = fY._2
833+            let gb = fY._3
834+            let gc = fY._4
835+            let fw = bM(D(gc, bq), D(gb, bp))
836+            let fx = H(fw, b)
837+            let el = if (fi)
838+                then nil
839+                else [StringEntry(ad(toString(value(ab)), toBase58String(value(ac))), bF(fZ, ga, ft, fx, height, lastBlock.timestamp)), IntegerEntry(W(), fx), IntegerEntry(X(height, lastBlock.timestamp), fx)]
840+            let fE = bM(D(fR, bq), D(fQ, bp))
841+            let fF = H(fE, b)
842+            let fG = {
843+                let gd = (toInt(fraction(fO, fU, fA)) * 2)
844+                fraction((fX - gd), b, gd)
845+                }
846+            $Tuple5(fX, el, fe, fG, fN)
847+            }
848+        else throw("Strict value is not equal to itself.")
849+    }
850+
851+
852+func ge () = {
853+    let bT = getString(U())
854+    if ($isInstanceOf(bT, "String"))
855+        then {
856+            let gf = bT
857+            fromBase58String(gf)
858+            }
859+        else if ($isInstanceOf(bT, "Unit"))
660860             then unit
661861             else throw("Match error")
662862     }
663863 
664864 
665-func fb () = {
666-    let dW = getString(V())
667-    if ($isInstanceOf(dW, "String"))
865+func gg () = {
866+    let bT = getString(V())
867+    if ($isInstanceOf(bT, "String"))
668868         then {
669-            let fa = dW
670-            fromBase58String(fa)
869+            let gf = bT
870+            fromBase58String(gf)
671871             }
672-        else if ($isInstanceOf(dW, "Unit"))
872+        else if ($isInstanceOf(bT, "Unit"))
673873             then unit
674874             else throw("Match error")
675875     }
676876 
677877 
678-func fc (dL) = {
679-    let dW = eZ()
680-    if ($isInstanceOf(dW, "ByteVector"))
878+func gh (eS) = {
879+    let bT = ge()
880+    if ($isInstanceOf(bT, "ByteVector"))
681881         then {
682-            let fd = dW
683-            (dL.callerPublicKey == fd)
882+            let gi = bT
883+            (eS.callerPublicKey == gi)
684884             }
685-        else if ($isInstanceOf(dW, "Unit"))
686-            then (dL.caller == this)
885+        else if ($isInstanceOf(bT, "Unit"))
886+            then (eS.caller == this)
687887             else throw("Match error")
688888     }
689889 
690890 
691-func fe (dL) = {
692-    let ff = throw("Permission denied")
693-    let dW = eZ()
694-    if ($isInstanceOf(dW, "ByteVector"))
891+func gj (eS) = {
892+    let gk = throw("Permission denied")
893+    let bT = ge()
894+    if ($isInstanceOf(bT, "ByteVector"))
695895         then {
696-            let fd = dW
697-            if ((dL.callerPublicKey == fd))
896+            let gi = bT
897+            if ((eS.callerPublicKey == gi))
698898                 then true
699-                else ff
899+                else gk
700900             }
701-        else if ($isInstanceOf(dW, "Unit"))
702-            then if ((dL.caller == this))
901+        else if ($isInstanceOf(bT, "Unit"))
902+            then if ((eS.caller == this))
703903                 then true
704-                else ff
904+                else gk
705905             else throw("Match error")
706906     }
707907 
708908 
709-@Callable(dL)
710-func calculateAmountOutForSwapREADONLY (fg,fh,fi) = {
711-    let fj = if ((fh == false))
909+@Callable(eS)
910+func rebalance () = (cA(aM(this, ae())) ++ cA(aM(this, af())))
911+
912+
913+
914+@Callable(eS)
915+func calculateAmountOutForSwapREADONLY (gl,gm,gn) = {
916+    let go = if ((gm == false))
712917         then {
713-            let fk = aH(this, af())
714-            let fl = aH(this, ae())
715-            $Tuple2(fk, fl)
918+            let gp = aM(this, af())
919+            let gq = aM(this, ae())
920+            $Tuple2(gp, gq)
716921             }
717922         else {
718-            let fk = aH(this, ae())
719-            let fl = aH(this, af())
720-            $Tuple2(fk, fl)
923+            let gp = aM(this, ae())
924+            let gq = aM(this, af())
925+            $Tuple2(gp, gq)
721926             }
722-    let fk = fj._1
723-    let fl = fj._2
724-    let fm = bE(fl)
725-    let fn = bE(fk)
726-    let fo = fraction(fn, fg, (fm + fg))
727-    let fp = (toBigInt(fm) * toBigInt(fn))
728-    let fq = (((toBigInt(bE(fl)) + toBigInt(fg)) + toBigInt(fi)) * (toBigInt(bE(fk)) - toBigInt(fo)))
729-    let fr = if ((fq >= fp))
927+    let gp = go._1
928+    let gq = go._2
929+    let gr = bJ(gq)
930+    let gs = bJ(gp)
931+    let gt = fraction(gs, gl, (gr + gl))
932+    let gu = (toBigInt(gr) * toBigInt(gs))
933+    let gv = (((toBigInt(bJ(gq)) + toBigInt(gl)) + toBigInt(gn)) * (toBigInt(bJ(gp)) - toBigInt(gt)))
934+    let gw = if ((gv >= gu))
730935         then true
731936         else throw("new K is fewer error")
732-    if ((fr == fr))
733-        then $Tuple2(nil, fo)
937+    if ((gw == gw))
938+        then $Tuple2(nil, gt)
734939         else throw("Strict value is not equal to itself.")
735940     }
736941 
737942 
738943 
739-@Callable(dL)
740-func calculateAmountOutForSwapAndSendTokens (fg,fh,fs,ft,fi) = {
741-    let fu = {
742-        let aR = invoke(aO, "getSwapContractREADONLY", nil, nil)
743-        if ($isInstanceOf(aR, "String"))
744-            then aR
745-            else throw(($getType(aR) + " couldn't be cast to String"))
944+@Callable(eS)
945+func calculateAmountOutForSwapAndSendTokens (gl,gm,gx,gy,gn) = {
946+    let gz = {
947+        let aW = invoke(aT, "getSwapContractREADONLY", nil, nil)
948+        if ($isInstanceOf(aW, "String"))
949+            then aW
950+            else throw(($getType(aW) + " couldn't be cast to String"))
746951         }
747-    let eH = [if ((value(dL.payments[0]).amount >= fg))
952+    let fM = [if ((value(eS.payments[0]).amount >= gl))
748953         then true
749-        else aL("Wrong amount"), if ((dL.caller == addressFromStringValue(fu)))
954+        else aQ("Wrong amount"), if ((eS.caller == addressFromStringValue(gz)))
750955         then true
751-        else aL("Permission denied")]
752-    if ((eH == eH))
956+        else aQ("Permission denied")]
957+    if ((fM == fM))
753958         then {
754-            let dM = value(dL.payments[0])
755-            let fl = ba(dM.assetId)
756-            let fk = if ((fh == false))
757-                then aH(this, af())
758-                else aH(this, ae())
759-            let fm = (bE(fl) - value(dL.payments[0]).amount)
760-            let fn = bE(fk)
761-            let fo = fraction(fn, fg, (fm + fg))
762-            let fp = (toBigInt(fm) * toBigInt(fn))
763-            let fq = ((toBigInt(bE(fl)) + toBigInt(fi)) * (toBigInt(bE(fk)) - toBigInt(fo)))
764-            let fr = if ((fq >= fp))
959+            let eT = value(eS.payments[0])
960+            let gq = bf(eT.assetId)
961+            let gp = if ((gm == false))
962+                then aM(this, af())
963+                else aM(this, ae())
964+            let gr = (bJ(gq) - value(eS.payments[0]).amount)
965+            let gs = bJ(gp)
966+            let gt = fraction(gs, gl, (gr + gl))
967+            let gu = (toBigInt(gr) * toBigInt(gs))
968+            let gv = ((toBigInt(bJ(gq)) + toBigInt(gn)) * (toBigInt(bJ(gp)) - toBigInt(gt)))
969+            let gw = if ((gv >= gu))
765970                 then true
766971                 else throw("new K is fewer error")
767-            if ((fr == fr))
972+            if ((gw == gw))
768973                 then {
769-                    let fv = if ((fo >= fs))
974+                    let gA = if ((gt >= gx))
770975                         then true
771976                         else throw("Exchange result is fewer coins than expected")
772-                    if ((fv == fv))
773-                        then $Tuple2([ScriptTransfer(addressFromStringValue(ft), fo, aY(fk))], fo)
977+                    if ((gA == gA))
978+                        then {
979+                            let gB = cA(gq)
980+                            if ((gB == gB))
981+                                then {
982+                                    let gC = cH(gp, gt)
983+                                    if ((gC == gC))
984+                                        then $Tuple2(((gC ++ gB) ++ [ScriptTransfer(addressFromStringValue(gy), gt, bd(gp))]), gt)
985+                                        else throw("Strict value is not equal to itself.")
986+                                    }
987+                                else throw("Strict value is not equal to itself.")
988+                            }
774989                         else throw("Strict value is not equal to itself.")
775990                     }
776991                 else throw("Strict value is not equal to itself.")
780995 
781996 
782997 
783-@Callable(dL)
784-func setManager (fw) = {
785-    let fx = fe(dL)
786-    if ((fx == fx))
998+@Callable(eS)
999+func setManager (gD) = {
1000+    let gE = gj(eS)
1001+    if ((gE == gE))
7871002         then {
788-            let fy = fromBase58String(fw)
789-            if ((fy == fy))
790-                then [StringEntry(V(), fw)]
1003+            let gF = fromBase58String(gD)
1004+            if ((gF == gF))
1005+                then [StringEntry(V(), gD)]
7911006                 else throw("Strict value is not equal to itself.")
7921007             }
7931008         else throw("Strict value is not equal to itself.")
7951010 
7961011 
7971012 
798-@Callable(dL)
1013+@Callable(eS)
7991014 func confirmManager () = {
800-    let fz = fb()
801-    let fA = if (isDefined(fz))
1015+    let gG = gg()
1016+    let gH = if (isDefined(gG))
8021017         then true
8031018         else throw("No pending manager")
804-    if ((fA == fA))
1019+    if ((gH == gH))
8051020         then {
806-            let fB = if ((dL.callerPublicKey == value(fz)))
1021+            let gI = if ((eS.callerPublicKey == value(gG)))
8071022                 then true
8081023                 else throw("You are not pending manager")
809-            if ((fB == fB))
810-                then [StringEntry(U(), toBase58String(value(fz))), DeleteEntry(V())]
1024+            if ((gI == gI))
1025+                then [StringEntry(U(), toBase58String(value(gG))), DeleteEntry(V())]
8111026                 else throw("Strict value is not equal to itself.")
8121027             }
8131028         else throw("Strict value is not equal to itself.")
8151030 
8161031 
8171032 
818-@Callable(dL)
819-func put (cz,fC) = if ((0 > cz))
1033+@Callable(eS)
1034+func put (dG,gJ) = if ((0 > dG))
8201035     then throw("Invalid slippageTolerance passed")
8211036     else {
822-        let dR = dO(dL, cz, true)
823-        let db = dR._2
824-        let cg = dR._7
825-        let cx = dR._9
826-        let dc = dR._10
827-        let dd = dR._11
828-        let fD = dR._12
829-        let fE = dR._13
830-        let dP = toBigInt(value(dL.payments[0]).amount)
831-        let dQ = toBigInt(value(dL.payments[1]).amount)
832-        let ds = dl(dP, dQ, toBigInt(0))
833-        if ((ds == ds))
1037+        let eY = eV(eS, dG, true)
1038+        let ei = eY._2
1039+        let dn = eY._7
1040+        let dE = eY._9
1041+        let ej = eY._10
1042+        let ek = eY._11
1043+        let gK = eY._12
1044+        let gL = eY._13
1045+        let eW = toBigInt(value(eS.payments[0]).amount)
1046+        let eX = toBigInt(value(eS.payments[1]).amount)
1047+        let ez = es(eW, eX, toBigInt(0))
1048+        if ((ez == ez))
8341049             then {
835-                let dU = invoke(aO, "emit", [db], nil)
836-                if ((dU == dU))
1050+                let fa = invoke(aT, "emit", [ei], nil)
1051+                if ((fa == fa))
8371052                     then {
838-                        let dV = {
839-                            let dW = dU
840-                            if ($isInstanceOf(dW, "Address"))
1053+                        let fb = {
1054+                            let bT = fa
1055+                            if ($isInstanceOf(bT, "Address"))
8411056                                 then {
842-                                    let dX = dW
843-                                    invoke(dX, "emit", [db], nil)
1057+                                    let fc = bT
1058+                                    invoke(fc, "emit", [ei], nil)
8441059                                     }
8451060                                 else unit
8461061                             }
847-                        if ((dV == dV))
1062+                        if ((fb == fb))
8481063                             then {
849-                                let fF = if ((dc > 0))
850-                                    then invoke(bo, "put", nil, [AttachedPayment(fD, dc)])
1064+                                let gM = if ((ej > 0))
1065+                                    then invoke(bt, "put", nil, [AttachedPayment(gK, ej)])
8511066                                     else nil
852-                                if ((fF == fF))
1067+                                if ((gM == gM))
8531068                                     then {
854-                                        let fG = if ((dd > 0))
855-                                            then invoke(bo, "put", nil, [AttachedPayment(fE, dd)])
1069+                                        let gN = if ((ek > 0))
1070+                                            then invoke(bt, "put", nil, [AttachedPayment(gL, ek)])
8561071                                             else nil
857-                                        if ((fG == fG))
1072+                                        if ((gN == gN))
8581073                                             then {
859-                                                let fH = if (fC)
1074+                                                let gO = if (gJ)
8601075                                                     then {
861-                                                        let fI = invoke(bn, "stake", nil, [AttachedPayment(cg, db)])
862-                                                        if ((fI == fI))
1076+                                                        let gP = invoke(bs, "stake", nil, [AttachedPayment(dn, ei)])
1077+                                                        if ((gP == gP))
8631078                                                             then nil
8641079                                                             else throw("Strict value is not equal to itself.")
8651080                                                         }
866-                                                    else [ScriptTransfer(dL.caller, db, cg)]
867-                                                let fJ = dt(0, 0, 0)
868-                                                if ((fJ == fJ))
1081+                                                    else [ScriptTransfer(eS.caller, ei, dn)]
1082+                                                let gQ = eA(0, 0, 0)
1083+                                                if ((gQ == gQ))
8691084                                                     then {
870-                                                        let dk = fJ._2
871-                                                        let fK = fJ._1
872-                                                        let fL = dx(ds, dk)
873-                                                        if ((fL == fL))
874-                                                            then ((cx ++ fH) ++ fK)
1085+                                                        let er = gQ._2
1086+                                                        let gR = gQ._1
1087+                                                        let gS = eE(ez, er)
1088+                                                        if ((gS == gS))
1089+                                                            then {
1090+                                                                let gT = invoke(this, "rebalance", nil, nil)
1091+                                                                if ((gT == gT))
1092+                                                                    then ((dE ++ gO) ++ gR)
1093+                                                                    else throw("Strict value is not equal to itself.")
1094+                                                                }
8751095                                                             else throw("Strict value is not equal to itself.")
8761096                                                         }
8771097                                                     else throw("Strict value is not equal to itself.")
8891109 
8901110 
8911111 
892-@Callable(dL)
893-func putForFree (fM) = if ((0 > fM))
1112+@Callable(eS)
1113+func putForFree (gU) = if ((0 > gU))
8941114     then throw("Invalid value passed")
8951115     else {
896-        let dR = dO(dL, fM, false)
897-        let cx = dR._9
898-        let dP = toBigInt(value(dL.payments[0]).amount)
899-        let dQ = toBigInt(value(dL.payments[1]).amount)
900-        let ds = dl(dP, dQ, toBigInt(0))
901-        if ((ds == ds))
1116+        let eY = eV(eS, gU, false)
1117+        let dE = eY._9
1118+        let eW = toBigInt(value(eS.payments[0]).amount)
1119+        let eX = toBigInt(value(eS.payments[1]).amount)
1120+        let ez = es(eW, eX, toBigInt(0))
1121+        if ((ez == ez))
9021122             then {
903-                let fN = dt(0, 0, 0)
904-                let fK = fN._1
905-                let dk = fN._2
906-                let fL = dx(ds, dk)
907-                if ((fL == fL))
908-                    then (cx ++ fK)
1123+                let gV = eA(0, 0, 0)
1124+                let gR = gV._1
1125+                let er = gV._2
1126+                let gS = eE(ez, er)
1127+                if ((gS == gS))
1128+                    then (dE ++ gR)
9091129                     else throw("Strict value is not equal to itself.")
9101130                 }
9111131             else throw("Strict value is not equal to itself.")
9131133 
9141134 
9151135 
916-@Callable(dL)
917-func putOneTkn (fO,fP) = {
918-    let fQ = {
919-        let aR = invoke(aO, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
920-        if ($isInstanceOf(aR, "Boolean"))
921-            then aR
922-            else throw(($getType(aR) + " couldn't be cast to Boolean"))
1136+@Callable(eS)
1137+func putOneTkn (gW,gX) = {
1138+    let gY = {
1139+        let aW = invoke(aT, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1140+        if ($isInstanceOf(aW, "Boolean"))
1141+            then aW
1142+            else throw(($getType(aW) + " couldn't be cast to Boolean"))
9231143         }
924-    let fR = if (if (if (aT())
1144+    let gZ = if (if (if (aY())
9251145         then true
926-        else (bg == l))
1146+        else (bl == l))
9271147         then true
928-        else (bg == n))
1148+        else (bl == n))
9291149         then true
930-        else fQ
931-    let eH = [if (if (!(fR))
1150+        else gY
1151+    let fM = [if (if (!(gZ))
9321152         then true
933-        else fc(dL))
1153+        else gh(eS))
9341154         then true
935-        else aL("put operation is blocked by admin"), if ((size(dL.payments) == 1))
1155+        else aQ("put operation is blocked by admin"), if ((size(eS.payments) == 1))
9361156         then true
937-        else aL("exactly 1 payment are expected")]
938-    if ((eH == eH))
1157+        else aQ("exactly 1 payment are expected")]
1158+    if ((fM == fM))
9391159         then {
940-            let fS = dL.payments[0]
941-            let ec = fS.assetId
942-            let eb = fS.amount
943-            let ds = if ((ec == bi))
944-                then dl(toBigInt(eb), toBigInt(0), toBigInt(0))
945-                else if ((ec == bj))
946-                    then dl(toBigInt(0), toBigInt(eb), toBigInt(0))
947-                    else aL("payment asset is not supported")
948-            if ((ds == ds))
1160+            let ha = eS.payments[0]
1161+            let fh = ha.assetId
1162+            let fg = ha.amount
1163+            let ez = if ((fh == bn))
1164+                then es(toBigInt(fg), toBigInt(0), toBigInt(0))
1165+                else if ((fh == bo))
1166+                    then es(toBigInt(0), toBigInt(fg), toBigInt(0))
1167+                    else aQ("payment asset is not supported")
1168+            if ((ez == ez))
9491169                 then {
950-                    let ab = dL.caller
951-                    let ac = dL.transactionId
952-                    let fT = ea(eb, ec, ab, ac)
953-                    if ((fT == fT))
1170+                    let ab = eS.caller
1171+                    let ac = eS.transactionId
1172+                    let hb = ff(fg, fh, ab, ac)
1173+                    if ((hb == hb))
9541174                         then {
955-                            let eg = fT._5
956-                            let fU = fT._4
957-                            let dZ = fT._3
958-                            let de = fT._2
959-                            let fV = fT._1
960-                            let fW = if (if ((fO > 0))
961-                                then (fO > fV)
1175+                            let fl = hb._5
1176+                            let hc = hb._4
1177+                            let fe = hb._3
1178+                            let el = hb._2
1179+                            let hd = hb._1
1180+                            let he = if (if ((gW > 0))
1181+                                then (gW > hd)
9621182                                 else false)
963-                                then aL(makeString(["amount to receive is less than ", toString(fO)], ""))
964-                                else fV
965-                            let dU = dS(fW)
966-                            if ((dU == dU))
1183+                                then aQ(makeString(["amount to receive is less than ", toString(gW)], ""))
1184+                                else hd
1185+                            let fa = eZ(he)
1186+                            if ((fa == fa))
9671187                                 then {
968-                                    let fH = if (fP)
1188+                                    let gO = if (gX)
9691189                                         then {
970-                                            let fX = invoke(bn, "stake", nil, [AttachedPayment(bh, fW)])
971-                                            if ((fX == fX))
1190+                                            let hf = invoke(bs, "stake", nil, [AttachedPayment(bm, he)])
1191+                                            if ((hf == hf))
9721192                                                 then nil
9731193                                                 else throw("Strict value is not equal to itself.")
9741194                                             }
975-                                        else [ScriptTransfer(dL.caller, fW, bh)]
976-                                    let fY = if ((dZ > 0))
977-                                        then [ScriptTransfer(aP, dZ, ec)]
1195+                                        else [ScriptTransfer(eS.caller, he, bm)]
1196+                                    let hg = if ((fe > 0))
1197+                                        then [ScriptTransfer(aU, fe, fh)]
9781198                                         else nil
979-                                    let fZ = if ((this == aP))
1199+                                    let hh = if ((this == aU))
9801200                                         then $Tuple2(0, 0)
981-                                        else if (eg)
982-                                            then $Tuple2(-(dZ), 0)
983-                                            else $Tuple2(0, -(dZ))
984-                                    let du = fZ._1
985-                                    let dv = fZ._2
986-                                    let ga = dt(du, dv, 0)
987-                                    let fK = ga._1
988-                                    let dk = ga._2
989-                                    let dE = value(getString(aj))
990-                                    let fL = dx(ds, dk)
991-                                    if ((fL == fL))
992-                                        then $Tuple2((((de ++ fH) ++ fY) ++ fK), fW)
993-                                        else throw("Strict value is not equal to itself.")
994-                                    }
995-                                else throw("Strict value is not equal to itself.")
996-                            }
997-                        else throw("Strict value is not equal to itself.")
998-                    }
999-                else throw("Strict value is not equal to itself.")
1000-            }
1001-        else throw("Strict value is not equal to itself.")
1002-    }
1003-
1004-
1005-
1006-@Callable(dL)
1007-func putOneTknREADONLY (ec,eb) = {
1008-    let gb = ea(eb, aY(ec), unit, unit)
1009-    let fV = gb._1
1010-    let de = gb._2
1011-    let dZ = gb._3
1012-    let fU = gb._4
1013-    let eg = gb._5
1014-    $Tuple2(nil, $Tuple3(fV, dZ, fU))
1015-    }
1016-
1017-
1018-
1019-@Callable(dL)
1020-func getOneTkn (gc,fO) = {
1021-    let fQ = {
1022-        let aR = invoke(aO, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1023-        if ($isInstanceOf(aR, "Boolean"))
1024-            then aR
1025-            else throw(($getType(aR) + " couldn't be cast to Boolean"))
1026-        }
1027-    let gd = if (if (aT())
1028-        then true
1029-        else (bg == n))
1030-        then true
1031-        else fQ
1032-    let eH = [if (if (!(gd))
1033-        then true
1034-        else fc(dL))
1035-        then true
1036-        else aL("get operation is blocked by admin"), if ((size(dL.payments) == 1))
1037-        then true
1038-        else aL("exactly 1 payment are expected")]
1039-    if ((eH == eH))
1040-        then {
1041-            let eG = aY(gc)
1042-            let fS = dL.payments[0]
1043-            let ec = fS.assetId
1044-            let eo = fS.amount
1045-            let ds = dl(toBigInt(0), toBigInt(0), toBigInt(0))
1046-            if ((ds == ds))
1047-                then {
1048-                    let ab = dL.caller
1049-                    let ac = dL.transactionId
1050-                    let ge = eF(eG, eo, ec, ab, ac)
1051-                    if ((ge == ge))
1052-                        then {
1053-                            let eI = ge._5
1054-                            let fU = ge._4
1055-                            let dZ = ge._3
1056-                            let de = ge._2
1057-                            let gf = ge._1
1058-                            let dT = if (if ((fO > 0))
1059-                                then (fO > gf)
1060-                                else false)
1061-                                then aL(makeString(["amount to receive is less than ", toString(fO)], ""))
1062-                                else gf
1063-                            let gg = invoke(aO, "burn", [eo], [AttachedPayment(ec, eo)])
1064-                            if ((gg == gg))
1065-                                then {
1066-                                    let gh = [ScriptTransfer(ab, dT, eG)]
1067-                                    let fY = if ((dZ > 0))
1068-                                        then [ScriptTransfer(aP, dZ, eG)]
1069-                                        else nil
1070-                                    let gi = {
1071-                                        let gj = if ((this == aP))
1072-                                            then 0
1073-                                            else dZ
1074-                                        if (eI)
1075-                                            then $Tuple2(-((dT + gj)), 0)
1076-                                            else $Tuple2(0, -((dT + gj)))
1077-                                        }
1078-                                    let du = gi._1
1079-                                    let dv = gi._2
1080-                                    let gk = dt(du, dv, 0)
1081-                                    let fK = gk._1
1082-                                    let dk = gk._2
1083-                                    let fL = dx(ds, dk)
1084-                                    if ((fL == fL))
1085-                                        then $Tuple2((((de ++ gh) ++ fY) ++ fK), dT)
1086-                                        else throw("Strict value is not equal to itself.")
1087-                                    }
1088-                                else throw("Strict value is not equal to itself.")
1089-                            }
1090-                        else throw("Strict value is not equal to itself.")
1091-                    }
1092-                else throw("Strict value is not equal to itself.")
1093-            }
1094-        else throw("Strict value is not equal to itself.")
1095-    }
1096-
1097-
1098-
1099-@Callable(dL)
1100-func getOneTknREADONLY (eG,eo) = {
1101-    let gl = eF(aY(eG), eo, bh, unit, unit)
1102-    let gf = gl._1
1103-    let de = gl._2
1104-    let dZ = gl._3
1105-    let fU = gl._4
1106-    let eI = gl._5
1107-    $Tuple2(nil, $Tuple3(gf, dZ, fU))
1108-    }
1109-
1110-
1111-
1112-@Callable(dL)
1113-func unstakeAndGetOneTkn (gm,gc,fO) = {
1114-    let fQ = {
1115-        let aR = invoke(aO, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1116-        if ($isInstanceOf(aR, "Boolean"))
1117-            then aR
1118-            else throw(($getType(aR) + " couldn't be cast to Boolean"))
1119-        }
1120-    let gd = if (if (aT())
1121-        then true
1122-        else (bg == n))
1123-        then true
1124-        else fQ
1125-    let eH = [if (if (!(gd))
1126-        then true
1127-        else fc(dL))
1128-        then true
1129-        else aL("get operation is blocked by admin"), if ((size(dL.payments) == 0))
1130-        then true
1131-        else aL("no payments are expected")]
1132-    if ((eH == eH))
1133-        then {
1134-            let eG = aY(gc)
1135-            let ab = dL.caller
1136-            let ac = dL.transactionId
1137-            let ds = dl(toBigInt(0), toBigInt(0), toBigInt(0))
1138-            if ((ds == ds))
1139-                then {
1140-                    let gn = invoke(bn, "unstake", [toBase58String(bh), gm], nil)
1141-                    if ((gn == gn))
1142-                        then {
1143-                            let go = eF(eG, gm, bh, ab, ac)
1144-                            if ((go == go))
1145-                                then {
1146-                                    let eI = go._5
1147-                                    let fU = go._4
1148-                                    let dZ = go._3
1149-                                    let de = go._2
1150-                                    let gf = go._1
1151-                                    let dT = if (if ((fO > 0))
1152-                                        then (fO > gf)
1153-                                        else false)
1154-                                        then aL(makeString(["amount to receive is less than ", toString(fO)], ""))
1155-                                        else gf
1156-                                    let gg = invoke(aO, "burn", [gm], [AttachedPayment(bh, gm)])
1157-                                    if ((gg == gg))
1201+                                        else if (fl)
1202+                                            then $Tuple2(-(fe), 0)
1203+                                            else $Tuple2(0, -(fe))
1204+                                    let eB = hh._1
1205+                                    let eC = hh._2
1206+                                    let hi = eA(eB, eC, 0)
1207+                                    let gR = hi._1
1208+                                    let er = hi._2
1209+                                    let eL = value(getString(aj))
1210+                                    let gS = eE(ez, er)
1211+                                    if ((gS == gS))
11581212                                         then {
1159-                                            let gh = [ScriptTransfer(dL.caller, dT, eG)]
1160-                                            let fY = if ((dZ > 0))
1161-                                                then [ScriptTransfer(aP, dZ, eG)]
1162-                                                else nil
1163-                                            let gp = {
1164-                                                let gj = if ((this == aP))
1165-                                                    then 0
1166-                                                    else dZ
1167-                                                if (eI)
1168-                                                    then $Tuple2(-((dT + gj)), 0)
1169-                                                    else $Tuple2(0, -((dT + gj)))
1170-                                                }
1171-                                            let du = gp._1
1172-                                            let dv = gp._2
1173-                                            let gq = dt(du, dv, 0)
1174-                                            let fK = gq._1
1175-                                            let dk = gq._2
1176-                                            let fL = dx(ds, dk)
1177-                                            if ((fL == fL))
1178-                                                then $Tuple2((((de ++ gh) ++ fY) ++ fK), dT)
1213+                                            let gT = invoke(this, "rebalance", nil, nil)
1214+                                            if ((gT == gT))
1215+                                                then $Tuple2((((el ++ gO) ++ hg) ++ gR), he)
11791216                                                 else throw("Strict value is not equal to itself.")
11801217                                             }
11811218                                         else throw("Strict value is not equal to itself.")
11911228 
11921229 
11931230 
1194-@Callable(dL)
1195-func get () = {
1196-    let cP = dK(dL)
1197-    let gr = cP._1
1198-    let cw = cP._2
1199-    let dN = cP._3
1200-    let ce = cP._4
1201-    let cx = cP._5
1202-    let ds = dl(toBigInt(0), toBigInt(0), toBigInt(0))
1203-    if ((ds == ds))
1231+@Callable(eS)
1232+func putOneTknREADONLY (fh,fg) = {
1233+    let hj = ff(fg, bd(fh), unit, unit)
1234+    let hd = hj._1
1235+    let el = hj._2
1236+    let fe = hj._3
1237+    let hc = hj._4
1238+    let fl = hj._5
1239+    $Tuple2(nil, $Tuple3(hd, fe, hc))
1240+    }
1241+
1242+
1243+
1244+@Callable(eS)
1245+func getOneTkn (hk,gW) = {
1246+    let gY = {
1247+        let aW = invoke(aT, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1248+        if ($isInstanceOf(aW, "Boolean"))
1249+            then aW
1250+            else throw(($getType(aW) + " couldn't be cast to Boolean"))
1251+        }
1252+    let hl = if (if (aY())
1253+        then true
1254+        else (bl == n))
1255+        then true
1256+        else gY
1257+    let fM = [if (if (!(hl))
1258+        then true
1259+        else gh(eS))
1260+        then true
1261+        else aQ("get operation is blocked by admin"), if ((size(eS.payments) == 1))
1262+        then true
1263+        else aQ("exactly 1 payment are expected")]
1264+    if ((fM == fM))
12041265         then {
1205-            let gs = invoke(aO, "burn", [dN], [AttachedPayment(ce, dN)])
1206-            if ((gs == gs))
1266+            let fL = bd(hk)
1267+            let ha = eS.payments[0]
1268+            let fh = ha.assetId
1269+            let ft = ha.amount
1270+            let ez = es(toBigInt(0), toBigInt(0), toBigInt(0))
1271+            if ((ez == ez))
12071272                 then {
1208-                    let gt = dt(-(gr), -(cw), 0)
1209-                    let fK = gt._1
1210-                    let dk = gt._2
1211-                    let fL = dx(ds, dk)
1212-                    if ((fL == fL))
1213-                        then (cx ++ fK)
1273+                    let ab = eS.caller
1274+                    let ac = eS.transactionId
1275+                    let hm = fK(fL, ft, fh, ab, ac)
1276+                    if ((hm == hm))
1277+                        then {
1278+                            let fN = hm._5
1279+                            let hc = hm._4
1280+                            let fe = hm._3
1281+                            let el = hm._2
1282+                            let hn = hm._1
1283+                            let bW = if (if ((gW > 0))
1284+                                then (gW > hn)
1285+                                else false)
1286+                                then aQ(makeString(["amount to receive is less than ", toString(gW)], ""))
1287+                                else hn
1288+                            let ho = invoke(aT, "burn", [ft], [AttachedPayment(fh, ft)])
1289+                            if ((ho == ho))
1290+                                then {
1291+                                    let gC = cH(hk, (bW + max([0, fe])))
1292+                                    let hp = [ScriptTransfer(ab, bW, fL)]
1293+                                    let hg = if ((fe > 0))
1294+                                        then [ScriptTransfer(aU, fe, fL)]
1295+                                        else nil
1296+                                    let hq = {
1297+                                        let hr = if ((this == aU))
1298+                                            then 0
1299+                                            else fe
1300+                                        if (fN)
1301+                                            then $Tuple2(-((bW + hr)), 0)
1302+                                            else $Tuple2(0, -((bW + hr)))
1303+                                        }
1304+                                    let eB = hq._1
1305+                                    let eC = hq._2
1306+                                    let hs = eA(eB, eC, 0)
1307+                                    let gR = hs._1
1308+                                    let er = hs._2
1309+                                    let gS = eE(ez, er)
1310+                                    if ((gS == gS))
1311+                                        then $Tuple2(((((el ++ gC) ++ hp) ++ hg) ++ gR), bW)
1312+                                        else throw("Strict value is not equal to itself.")
1313+                                    }
1314+                                else throw("Strict value is not equal to itself.")
1315+                            }
12141316                         else throw("Strict value is not equal to itself.")
12151317                     }
12161318                 else throw("Strict value is not equal to itself.")
12201322 
12211323 
12221324 
1223-@Callable(dL)
1224-func getNoLess (gu,gv) = {
1225-    let cP = dK(dL)
1226-    let cv = cP._1
1227-    let cw = cP._2
1228-    let dN = cP._3
1229-    let ce = cP._4
1230-    let cx = cP._5
1231-    if ((gu > cv))
1232-        then throw(((("noLessThenAmtAsset failed:  " + toString(cv)) + " < ") + toString(gu)))
1233-        else if ((gv > cw))
1234-            then throw(((("noLessThenPriceAsset failed: " + toString(cw)) + " < ") + toString(gv)))
1235-            else {
1236-                let ds = dl(toBigInt(0), toBigInt(0), toBigInt(0))
1237-                if ((ds == ds))
1238-                    then {
1239-                        let gs = invoke(aO, "burn", [dN], [AttachedPayment(ce, dN)])
1240-                        if ((gs == gs))
1241-                            then {
1242-                                let gw = dt(-(cv), -(cw), 0)
1243-                                let fK = gw._1
1244-                                let dk = gw._2
1245-                                let fL = dx(ds, dk)
1246-                                if ((fL == fL))
1247-                                    then (cx ++ fK)
1248-                                    else throw("Strict value is not equal to itself.")
1249-                                }
1250-                            else throw("Strict value is not equal to itself.")
1251-                        }
1252-                    else throw("Strict value is not equal to itself.")
1253-                }
1325+@Callable(eS)
1326+func getOneTknREADONLY (fL,ft) = {
1327+    let ht = fK(bd(fL), ft, bm, unit, unit)
1328+    let hn = ht._1
1329+    let el = ht._2
1330+    let fe = ht._3
1331+    let hc = ht._4
1332+    let fN = ht._5
1333+    $Tuple2(nil, $Tuple3(hn, fe, hc))
12541334     }
12551335 
12561336 
12571337 
1258-@Callable(dL)
1259-func unstakeAndGet (dT) = {
1260-    let gx = if ((size(dL.payments) != 0))
1261-        then throw("No payments are expected")
1262-        else true
1263-    if ((gx == gx))
1338+@Callable(eS)
1339+func unstakeAndGetOneTkn (hu,hk,gW) = {
1340+    let gY = {
1341+        let aW = invoke(aT, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1342+        if ($isInstanceOf(aW, "Boolean"))
1343+            then aW
1344+            else throw(($getType(aW) + " couldn't be cast to Boolean"))
1345+        }
1346+    let hl = if (if (aY())
1347+        then true
1348+        else (bl == n))
1349+        then true
1350+        else gY
1351+    let fM = [if (if (!(hl))
1352+        then true
1353+        else gh(eS))
1354+        then true
1355+        else aQ("get operation is blocked by admin"), if ((size(eS.payments) == 0))
1356+        then true
1357+        else aQ("no payments are expected")]
1358+    if ((fM == fM))
12641359         then {
1265-            let bT = aV()
1266-            let cg = fromBase58String(bT[q])
1267-            let ds = dl(toBigInt(0), toBigInt(0), toBigInt(0))
1268-            if ((ds == ds))
1360+            let fL = bd(hk)
1361+            let ab = eS.caller
1362+            let ac = eS.transactionId
1363+            let ez = es(toBigInt(0), toBigInt(0), toBigInt(0))
1364+            if ((ez == ez))
12691365                 then {
1270-                    let gn = invoke(bn, "unstake", [toBase58String(cg), dT], nil)
1271-                    if ((gn == gn))
1366+                    let hv = invoke(bs, "unstake", [toBase58String(bm), hu], nil)
1367+                    if ((hv == hv))
12721368                         then {
1273-                            let cP = cc(toBase58String(dL.transactionId), toBase58String(cg), dT, dL.caller)
1274-                            let cv = cP._1
1275-                            let cw = cP._2
1276-                            let cj = parseIntValue(cP._9)
1277-                            let cx = cP._10
1278-                            let gy = if (if (aT())
1279-                                then true
1280-                                else (cj == n))
1281-                                then throw(("Get operation is blocked by admin. Status = " + toString(cj)))
1282-                                else true
1283-                            if ((gy == gy))
1369+                            let hw = fK(fL, hu, bm, ab, ac)
1370+                            if ((hw == hw))
12841371                                 then {
1285-                                    let gs = invoke(aO, "burn", [dT], [AttachedPayment(cg, dT)])
1286-                                    if ((gs == gs))
1372+                                    let fN = hw._5
1373+                                    let hc = hw._4
1374+                                    let fe = hw._3
1375+                                    let el = hw._2
1376+                                    let hn = hw._1
1377+                                    let bW = if (if ((gW > 0))
1378+                                        then (gW > hn)
1379+                                        else false)
1380+                                        then aQ(makeString(["amount to receive is less than ", toString(gW)], ""))
1381+                                        else hn
1382+                                    let ho = invoke(aT, "burn", [hu], [AttachedPayment(bm, hu)])
1383+                                    if ((ho == ho))
12871384                                         then {
1288-                                            let gz = dt(-(cv), -(cw), 0)
1289-                                            let fK = gz._1
1290-                                            let dk = gz._2
1291-                                            let fL = dx(ds, dk)
1292-                                            if ((fL == fL))
1293-                                                then (cx ++ fK)
1385+                                            let gC = cH(hk, (bW + max([0, fe])))
1386+                                            let hp = [ScriptTransfer(eS.caller, bW, fL)]
1387+                                            let hg = if ((fe > 0))
1388+                                                then [ScriptTransfer(aU, fe, fL)]
1389+                                                else nil
1390+                                            let hx = {
1391+                                                let hr = if ((this == aU))
1392+                                                    then 0
1393+                                                    else fe
1394+                                                if (fN)
1395+                                                    then $Tuple2(-((bW + hr)), 0)
1396+                                                    else $Tuple2(0, -((bW + hr)))
1397+                                                }
1398+                                            let eB = hx._1
1399+                                            let eC = hx._2
1400+                                            let hy = eA(eB, eC, 0)
1401+                                            let gR = hy._1
1402+                                            let er = hy._2
1403+                                            let gS = eE(ez, er)
1404+                                            if ((gS == gS))
1405+                                                then $Tuple2(((((el ++ gC) ++ hp) ++ hg) ++ gR), bW)
12941406                                                 else throw("Strict value is not equal to itself.")
12951407                                             }
12961408                                         else throw("Strict value is not equal to itself.")
13061418 
13071419 
13081420 
1309-@Callable(dL)
1310-func unstakeAndGetNoLess (gm,gA,gv) = {
1311-    let gd = if (aT())
1312-        then true
1313-        else (bg == n)
1314-    let eH = [if (!(gd))
1315-        then true
1316-        else throw("get operation is blocked by admin"), if ((size(dL.payments) == 0))
1317-        then true
1318-        else throw("no payments are expected")]
1319-    if ((eH == eH))
1421+@Callable(eS)
1422+func get () = {
1423+    let dW = eR(eS)
1424+    let dC = dW._1
1425+    let dD = dW._2
1426+    let eU = dW._3
1427+    let dl = dW._4
1428+    let dE = dW._5
1429+    let gC = cM(dC, dD)
1430+    let ez = es(toBigInt(0), toBigInt(0), toBigInt(0))
1431+    if ((ez == ez))
13201432         then {
1321-            let ds = dl(toBigInt(0), toBigInt(0), toBigInt(0))
1322-            if ((ds == ds))
1433+            let hz = invoke(aT, "burn", [eU], [AttachedPayment(dl, eU)])
1434+            if ((hz == hz))
13231435                 then {
1324-                    let gn = invoke(bn, "unstake", [toBase58String(bh), gm], nil)
1325-                    if ((gn == gn))
1436+                    let hA = eA(-(dC), -(dD), 0)
1437+                    let gR = hA._1
1438+                    let er = hA._2
1439+                    let gS = eE(ez, er)
1440+                    if ((gS == gS))
1441+                        then ((gC ++ dE) ++ gR)
1442+                        else throw("Strict value is not equal to itself.")
1443+                    }
1444+                else throw("Strict value is not equal to itself.")
1445+            }
1446+        else throw("Strict value is not equal to itself.")
1447+    }
1448+
1449+
1450+
1451+@Callable(eS)
1452+func getNoLess (hB,hC) = {
1453+    let dW = eR(eS)
1454+    let dC = dW._1
1455+    let dD = dW._2
1456+    let eU = dW._3
1457+    let dl = dW._4
1458+    let dE = dW._5
1459+    if ((hB > dC))
1460+        then throw(((("noLessThenAmtAsset failed:  " + toString(dC)) + " < ") + toString(hB)))
1461+        else if ((hC > dD))
1462+            then throw(((("noLessThenPriceAsset failed: " + toString(dD)) + " < ") + toString(hC)))
1463+            else {
1464+                let gC = cM(dC, dD)
1465+                let ez = es(toBigInt(0), toBigInt(0), toBigInt(0))
1466+                if ((ez == ez))
1467+                    then {
1468+                        let hz = invoke(aT, "burn", [eU], [AttachedPayment(dl, eU)])
1469+                        if ((hz == hz))
1470+                            then {
1471+                                let hD = eA(-(dC), -(dD), 0)
1472+                                let gR = hD._1
1473+                                let er = hD._2
1474+                                let gS = eE(ez, er)
1475+                                if ((gS == gS))
1476+                                    then ((gC ++ dE) ++ gR)
1477+                                    else throw("Strict value is not equal to itself.")
1478+                                }
1479+                            else throw("Strict value is not equal to itself.")
1480+                        }
1481+                    else throw("Strict value is not equal to itself.")
1482+                }
1483+    }
1484+
1485+
1486+
1487+@Callable(eS)
1488+func unstakeAndGet (bW) = {
1489+    let hE = if ((size(eS.payments) != 0))
1490+        then throw("No payments are expected")
1491+        else true
1492+    if ((hE == hE))
1493+        then {
1494+            let da = ba()
1495+            let dn = fromBase58String(da[q])
1496+            let ez = es(toBigInt(0), toBigInt(0), toBigInt(0))
1497+            if ((ez == ez))
1498+                then {
1499+                    let hv = invoke(bs, "unstake", [toBase58String(dn), bW], nil)
1500+                    if ((hv == hv))
13261501                         then {
1327-                            let cP = cc(toBase58String(dL.transactionId), toBase58String(bh), gm, dL.caller)
1328-                            let cv = cP._1
1329-                            let cw = cP._2
1330-                            let cx = cP._10
1331-                            let gB = [if ((cv >= gA))
1502+                            let dW = dj(toBase58String(eS.transactionId), toBase58String(dn), bW, eS.caller)
1503+                            let dC = dW._1
1504+                            let dD = dW._2
1505+                            let dq = parseIntValue(dW._9)
1506+                            let dE = dW._10
1507+                            let gC = cM(dC, dD)
1508+                            let hF = if (if (aY())
13321509                                 then true
1333-                                else throw(makeString(["amount asset amount to receive is less than ", toString(gA)], "")), if ((cw >= gv))
1334-                                then true
1335-                                else throw(makeString(["price asset amount to receive is less than ", toString(gv)], ""))]
1336-                            if ((gB == gB))
1510+                                else (dq == n))
1511+                                then throw(("Get operation is blocked by admin. Status = " + toString(dq)))
1512+                                else true
1513+                            if ((hF == hF))
13371514                                 then {
1338-                                    let gs = invoke(aO, "burn", [gm], [AttachedPayment(bh, gm)])
1339-                                    if ((gs == gs))
1515+                                    let hz = invoke(aT, "burn", [bW], [AttachedPayment(dn, bW)])
1516+                                    if ((hz == hz))
13401517                                         then {
1341-                                            let gC = dt(-(cv), -(cw), 0)
1342-                                            let fK = gC._1
1343-                                            let dk = gC._2
1344-                                            let fL = dx(ds, dk)
1345-                                            if ((fL == fL))
1346-                                                then (cx ++ fK)
1518+                                            let hG = eA(-(dC), -(dD), 0)
1519+                                            let gR = hG._1
1520+                                            let er = hG._2
1521+                                            let gS = eE(ez, er)
1522+                                            if ((gS == gS))
1523+                                                then ((gC ++ dE) ++ gR)
13471524                                                 else throw("Strict value is not equal to itself.")
13481525                                             }
13491526                                         else throw("Strict value is not equal to itself.")
13591536 
13601537 
13611538 
1362-@Callable(dL)
1363-func activate (gD,gE) = if ((toString(dL.caller) != toString(aO)))
1364-    then throw("permissions denied")
1365-    else $Tuple2([StringEntry(ae(), gD), StringEntry(af(), gE)], "success")
1366-
1367-
1368-
1369-@Callable(dL)
1370-func refreshKLp () = {
1371-    let gF = valueOrElse(getInteger(ak), 0)
1372-    let gG = if (((height - gF) >= an))
1373-        then unit
1374-        else aL(makeString([toString(an), " blocks have not passed since the previous call"], ""))
1375-    if ((gG == gG))
1539+@Callable(eS)
1540+func unstakeAndGetNoLess (hu,hH,hC) = {
1541+    let hl = if (aY())
1542+        then true
1543+        else (bl == n)
1544+    let fM = [if (!(hl))
1545+        then true
1546+        else throw("get operation is blocked by admin"), if ((size(eS.payments) == 0))
1547+        then true
1548+        else throw("no payments are expected")]
1549+    if ((fM == fM))
13761550         then {
1377-            let dE = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, aj), "0")), aN("invalid kLp"))
1378-            let gH = dt(0, 0, 0)
1379-            let gI = gH._1
1380-            let dk = gH._2
1381-            let dw = if ((dE != dk))
1382-                then gI
1383-                else aL("nothing to refresh")
1384-            $Tuple2(dw, toString(dk))
1551+            let ez = es(toBigInt(0), toBigInt(0), toBigInt(0))
1552+            if ((ez == ez))
1553+                then {
1554+                    let hv = invoke(bs, "unstake", [toBase58String(bm), hu], nil)
1555+                    if ((hv == hv))
1556+                        then {
1557+                            let dW = dj(toBase58String(eS.transactionId), toBase58String(bm), hu, eS.caller)
1558+                            let dC = dW._1
1559+                            let dD = dW._2
1560+                            let dE = dW._10
1561+                            let gC = cM(dC, dD)
1562+                            let hI = [if ((dC >= hH))
1563+                                then true
1564+                                else throw(makeString(["amount asset amount to receive is less than ", toString(hH)], "")), if ((dD >= hC))
1565+                                then true
1566+                                else throw(makeString(["price asset amount to receive is less than ", toString(hC)], ""))]
1567+                            if ((hI == hI))
1568+                                then {
1569+                                    let hz = invoke(aT, "burn", [hu], [AttachedPayment(bm, hu)])
1570+                                    if ((hz == hz))
1571+                                        then {
1572+                                            let hJ = eA(-(dC), -(dD), 0)
1573+                                            let gR = hJ._1
1574+                                            let er = hJ._2
1575+                                            let gS = eE(ez, er)
1576+                                            if ((gS == gS))
1577+                                                then ((gC ++ dE) ++ gR)
1578+                                                else throw("Strict value is not equal to itself.")
1579+                                            }
1580+                                        else throw("Strict value is not equal to itself.")
1581+                                    }
1582+                                else throw("Strict value is not equal to itself.")
1583+                            }
1584+                        else throw("Strict value is not equal to itself.")
1585+                    }
1586+                else throw("Strict value is not equal to itself.")
13851587             }
13861588         else throw("Strict value is not equal to itself.")
13871589     }
13881590 
13891591 
13901592 
1391-@Callable(dL)
1392-func getPoolConfigWrapperREADONLY () = $Tuple2(nil, aV())
1593+@Callable(eS)
1594+func activate (hK,hL) = if ((toString(eS.caller) != toString(aT)))
1595+    then throw("permissions denied")
1596+    else $Tuple2([StringEntry(ae(), hK), StringEntry(af(), hL)], "success")
13931597 
13941598 
13951599 
1396-@Callable(dL)
1397-func getAccBalanceWrapperREADONLY (bF) = $Tuple2(nil, bE(bF))
1398-
1399-
1400-
1401-@Callable(dL)
1402-func calcPricesWrapperREADONLY (bN,bO,bS) = {
1403-    let cb = bR(bN, bO, bS)
1404-    $Tuple2(nil, [toString(cb[0]), toString(cb[1]), toString(cb[2])])
1600+@Callable(eS)
1601+func refreshKLp () = {
1602+    let hM = valueOrElse(getInteger(ak), 0)
1603+    let hN = if (((height - hM) >= an))
1604+        then unit
1605+        else aQ(makeString([toString(an), " blocks have not passed since the previous call"], ""))
1606+    if ((hN == hN))
1607+        then {
1608+            let eL = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, aj), "0")), aS("invalid kLp"))
1609+            let hO = eA(0, 0, 0)
1610+            let hP = hO._1
1611+            let er = hO._2
1612+            let eD = if ((eL != er))
1613+                then hP
1614+                else aQ("nothing to refresh")
1615+            $Tuple2(eD, toString(er))
1616+            }
1617+        else throw("Strict value is not equal to itself.")
14051618     }
14061619 
14071620 
14081621 
1409-@Callable(dL)
1622+@Callable(eS)
1623+func getPoolConfigWrapperREADONLY () = $Tuple2(nil, ba())
1624+
1625+
1626+
1627+@Callable(eS)
1628+func getAccBalanceWrapperREADONLY (ap) = $Tuple2(nil, bJ(ap))
1629+
1630+
1631+
1632+@Callable(eS)
1633+func calcPricesWrapperREADONLY (cU,cV,cZ) = {
1634+    let di = cY(cU, cV, cZ)
1635+    $Tuple2(nil, [toString(di[0]), toString(di[1]), toString(di[2])])
1636+    }
1637+
1638+
1639+
1640+@Callable(eS)
14101641 func toX18WrapperREADONLY (E,F) = $Tuple2(nil, toString(D(E, F)))
14111642 
14121643 
14131644 
1414-@Callable(dL)
1645+@Callable(eS)
14151646 func fromX18WrapperREADONLY (I,J) = $Tuple2(nil, H(parseBigIntValue(I), J))
14161647 
14171648 
14181649 
1419-@Callable(dL)
1420-func calcPriceBigIntWrapperREADONLY (bH,bI) = $Tuple2(nil, toString(bG(parseBigIntValue(bH), parseBigIntValue(bI))))
1650+@Callable(eS)
1651+func calcPriceBigIntWrapperREADONLY (bN,bO) = $Tuple2(nil, toString(bM(parseBigIntValue(bN), parseBigIntValue(bO))))
14211652 
14221653 
14231654 
1424-@Callable(dL)
1425-func estimatePutOperationWrapperREADONLY (cd,cz,cA,cB,cC,cD,ab,cE,cF) = $Tuple2(nil, cy(cd, cz, cA, cB, cC, cD, ab, cE, cF))
1655+@Callable(eS)
1656+func estimatePutOperationWrapperREADONLY (dk,dG,dH,dI,dJ,dK,ab,dL,dM) = $Tuple2(nil, dF(dk, dG, dH, dI, dJ, dK, ab, dL, dM))
14261657 
14271658 
14281659 
1429-@Callable(dL)
1430-func estimateGetOperationWrapperREADONLY (cd,ce,cf,ab) = {
1431-    let cP = cc(cd, ce, cf, addressFromStringValue(ab))
1432-    $Tuple2(nil, $Tuple10(cP._1, cP._2, cP._3, cP._4, cP._5, cP._6, cP._7, toString(cP._8), cP._9, cP._10))
1660+@Callable(eS)
1661+func estimateGetOperationWrapperREADONLY (dk,dl,dm,ab) = {
1662+    let dW = dj(dk, dl, dm, addressFromStringValue(ab))
1663+    $Tuple2(nil, $Tuple10(dW._1, dW._2, dW._3, dW._4, dW._5, dW._6, dW._7, toString(dW._8), dW._9, dW._10))
14331664     }
14341665 
14351666 
14361667 
1437-@Callable(dL)
1668+@Callable(eS)
14381669 func statsREADONLY () = {
1439-    let bT = aV()
1440-    let cg = fromBase58String(bT[q])
1441-    let gJ = bT[r]
1442-    let gK = bT[s]
1443-    let cI = bT[v]
1444-    let cJ = bT[w]
1445-    let bU = parseIntValue(bT[t])
1446-    let bV = parseIntValue(bT[u])
1447-    let gL = valueOrErrorMessage(assetInfo(cg), (("Asset " + toBase58String(cg)) + " doesn't exist")).quantity
1448-    let gM = bE(gJ)
1449-    let gN = bE(gK)
1450-    let gO = if ((gL == 0))
1670+    let da = ba()
1671+    let dn = fromBase58String(da[q])
1672+    let hQ = da[r]
1673+    let hR = da[s]
1674+    let dP = da[v]
1675+    let dQ = da[w]
1676+    let db = parseIntValue(da[t])
1677+    let dc = parseIntValue(da[u])
1678+    let hS = valueOrErrorMessage(assetInfo(dn), (("Asset " + toBase58String(dn)) + " doesn't exist")).quantity
1679+    let hT = bJ(hQ)
1680+    let hU = bJ(hR)
1681+    let hV = if ((hS == 0))
14511682         then [e, e, e]
1452-        else bR(gM, gN, gL)
1453-    let cq = 0
1454-    let gP = H(gO[1], b)
1455-    let gQ = H(gO[2], b)
1456-    let gR = value(getInteger(aO, ay(toString(this))))
1457-    $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(gM), toString(gN), toString(gL), toString(cq), toString(gP), toString(gQ), toString(gR)], j))
1683+        else cY(hT, hU, hS)
1684+    let dx = 0
1685+    let hW = H(hV[1], b)
1686+    let hX = H(hV[2], b)
1687+    let hY = value(getInteger(aT, aD(toString(this))))
1688+    $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(hT), toString(hU), toString(hS), toString(dx), toString(hW), toString(hX), toString(hY)], j))
14581689     }
14591690 
14601691 
14611692 
1462-@Callable(dL)
1463-func evaluatePutByAmountAssetREADONLY (cA) = {
1464-    let bT = aV()
1465-    let cg = fromBase58String(bT[q])
1466-    let cG = bT[r]
1467-    let ch = fromBase58String(cG)
1468-    let cH = bT[s]
1469-    let ci = fromBase58String(cH)
1470-    let bU = parseIntValue(bT[t])
1471-    let bV = parseIntValue(bT[u])
1472-    let cj = bT[p]
1473-    let gL = valueOrErrorMessage(assetInfo(cg), (("Asset " + toBase58String(cg)) + " doesn't exist")).quantity
1474-    let gM = bE(cG)
1475-    let gN = bE(cH)
1476-    let bP = D(gM, bU)
1477-    let bQ = D(gN, bV)
1478-    let cp = if ((gL == 0))
1693+@Callable(eS)
1694+func evaluatePutByAmountAssetREADONLY (dH) = {
1695+    let da = ba()
1696+    let dn = fromBase58String(da[q])
1697+    let dN = da[r]
1698+    let do = fromBase58String(dN)
1699+    let dO = da[s]
1700+    let dp = fromBase58String(dO)
1701+    let db = parseIntValue(da[t])
1702+    let dc = parseIntValue(da[u])
1703+    let dq = da[p]
1704+    let hS = valueOrErrorMessage(assetInfo(dn), (("Asset " + toBase58String(dn)) + " doesn't exist")).quantity
1705+    let hT = bJ(dN)
1706+    let hU = bJ(dO)
1707+    let cW = D(hT, db)
1708+    let cX = D(hU, dc)
1709+    let dw = if ((hS == 0))
14791710         then e
1480-        else bG(bQ, bP)
1481-    let cM = D(cA, bU)
1482-    let cN = fraction(cM, cp, d)
1483-    let cC = H(cN, bV)
1484-    let dR = cy("", 500000, cA, ch, cC, ci, "", true, false)
1485-    let cX = dR._1
1486-    let gS = dR._3
1487-    let cl = dR._4
1488-    let cn = dR._5
1489-    let ck = dR._6
1490-    $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(cX), toString(H(cp, b)), toString(cl), toString(cn), toString(ck), cj, toString(cA), toString(cC)], j))
1711+        else bM(cX, cW)
1712+    let dT = D(dH, db)
1713+    let dU = fraction(dT, dw, d)
1714+    let dJ = H(dU, dc)
1715+    let eY = dF("", 500000, dH, do, dJ, dp, "", true, false)
1716+    let ee = eY._1
1717+    let hZ = eY._3
1718+    let ds = eY._4
1719+    let du = eY._5
1720+    let dr = eY._6
1721+    $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(ee), toString(H(dw, b)), toString(ds), toString(du), toString(dr), dq, toString(dH), toString(dJ)], j))
14911722     }
14921723 
14931724 
14941725 
1495-@Callable(dL)
1496-func evaluatePutByPriceAssetREADONLY (cC) = {
1497-    let bT = aV()
1498-    let cg = fromBase58String(bT[q])
1499-    let cG = bT[r]
1500-    let ch = fromBase58String(cG)
1501-    let cH = bT[s]
1502-    let ci = fromBase58String(cH)
1503-    let bU = parseIntValue(bT[t])
1504-    let bV = parseIntValue(bT[u])
1505-    let cj = bT[p]
1506-    let gL = valueOrErrorMessage(assetInfo(cg), (("Asset " + toBase58String(cg)) + " doesn't exist")).quantity
1507-    let gT = bE(cG)
1508-    let gU = bE(cH)
1509-    let gV = D(gT, bU)
1510-    let gW = D(gU, bV)
1511-    let cp = if ((gL == 0))
1726+@Callable(eS)
1727+func evaluatePutByPriceAssetREADONLY (dJ) = {
1728+    let da = ba()
1729+    let dn = fromBase58String(da[q])
1730+    let dN = da[r]
1731+    let do = fromBase58String(dN)
1732+    let dO = da[s]
1733+    let dp = fromBase58String(dO)
1734+    let db = parseIntValue(da[t])
1735+    let dc = parseIntValue(da[u])
1736+    let dq = da[p]
1737+    let hS = valueOrErrorMessage(assetInfo(dn), (("Asset " + toBase58String(dn)) + " doesn't exist")).quantity
1738+    let ia = bJ(dN)
1739+    let ib = bJ(dO)
1740+    let ic = D(ia, db)
1741+    let id = D(ib, dc)
1742+    let dw = if ((hS == 0))
15121743         then e
1513-        else bG(gW, gV)
1514-    let cN = D(cC, bV)
1515-    let cM = fraction(cN, d, cp)
1516-    let cA = H(cM, bU)
1517-    let dR = cy("", 500000, cA, ch, cC, ci, "", true, false)
1518-    let cX = dR._1
1519-    let gS = dR._3
1520-    let cl = dR._4
1521-    let cn = dR._5
1522-    let ck = dR._6
1523-    $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(cX), toString(H(cp, b)), toString(cl), toString(cn), toString(ck), cj, toString(cA), toString(cC)], j))
1744+        else bM(id, ic)
1745+    let dU = D(dJ, dc)
1746+    let dT = fraction(dU, d, dw)
1747+    let dH = H(dT, db)
1748+    let eY = dF("", 500000, dH, do, dJ, dp, "", true, false)
1749+    let ee = eY._1
1750+    let hZ = eY._3
1751+    let ds = eY._4
1752+    let du = eY._5
1753+    let dr = eY._6
1754+    $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(ee), toString(H(dw, b)), toString(ds), toString(du), toString(dr), dq, toString(dH), toString(dJ)], j))
15241755     }
15251756 
15261757 
15271758 
1528-@Callable(dL)
1529-func evaluateGetREADONLY (gX,gY) = {
1530-    let cP = cc("", gX, gY, this)
1531-    let cv = cP._1
1532-    let cw = cP._2
1533-    let cl = cP._5
1534-    let cn = cP._6
1535-    let ck = cP._7
1536-    let cq = cP._8
1537-    let cj = parseIntValue(cP._9)
1538-    $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(cv), toString(cw), toString(cl), toString(cn), toString(ck), toString(cq), toString(cj)], j))
1759+@Callable(eS)
1760+func evaluateGetREADONLY (ie,if) = {
1761+    let dW = dj("", ie, if, this)
1762+    let dC = dW._1
1763+    let dD = dW._2
1764+    let ds = dW._5
1765+    let du = dW._6
1766+    let dr = dW._7
1767+    let dx = dW._8
1768+    let dq = parseIntValue(dW._9)
1769+    $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(dC), toString(dD), toString(ds), toString(du), toString(dr), toString(dx), toString(dq)], j))
15391770     }
15401771 
15411772 
1542-@Verifier(gZ)
1543-func ha () = {
1544-    let hb = {
1545-        let dW = eZ()
1546-        if ($isInstanceOf(dW, "ByteVector"))
1773+@Verifier(ig)
1774+func ih () = {
1775+    let ii = {
1776+        let bT = ge()
1777+        if ($isInstanceOf(bT, "ByteVector"))
15471778             then {
1548-                let fd = dW
1549-                fd
1779+                let gi = bT
1780+                gi
15501781                 }
1551-            else if ($isInstanceOf(dW, "Unit"))
1552-                then gZ.senderPublicKey
1782+            else if ($isInstanceOf(bT, "Unit"))
1783+                then ig.senderPublicKey
15531784                 else throw("Match error")
15541785         }
1555-    let dW = gZ
1556-    if ($isInstanceOf(dW, "Order"))
1786+    let bT = ig
1787+    if ($isInstanceOf(bT, "Order"))
15571788         then {
1558-            let dA = dW
1559-            let hc = aU()
1560-            let hd = dz(dA)
1561-            let aD = hd._1
1562-            let aE = hd._2
1563-            let aF = sigVerify(dA.bodyBytes, dA.proofs[0], dA.senderPublicKey)
1564-            let aG = sigVerify(dA.bodyBytes, dA.proofs[1], hc)
1565-            if (if (if (aD)
1566-                then aF
1789+            let eH = bT
1790+            let ij = aZ()
1791+            let ik = eG(eH)
1792+            let aI = ik._1
1793+            let aJ = ik._2
1794+            let aK = sigVerify(eH.bodyBytes, eH.proofs[0], eH.senderPublicKey)
1795+            let aL = sigVerify(eH.bodyBytes, eH.proofs[1], ij)
1796+            if (if (if (aI)
1797+                then aK
15671798                 else false)
1568-                then aG
1799+                then aL
15691800                 else false)
15701801                 then true
1571-                else aC(aD, aE, aF, aG)
1802+                else aH(aI, aJ, aK, aL)
15721803             }
1573-        else if ($isInstanceOf(dW, "SetScriptTransaction"))
1804+        else if ($isInstanceOf(bT, "SetScriptTransaction"))
15741805             then {
1575-                let fa = dW
1576-                if (sigVerify(gZ.bodyBytes, gZ.proofs[0], hb))
1806+                let gf = bT
1807+                if (sigVerify(ig.bodyBytes, ig.proofs[0], ii))
15771808                     then true
15781809                     else {
1579-                        let he = blake2b256(value(fa.script))
1580-                        let hf = fromBase64String(value(getString(aO, aA())))
1581-                        let hg = scriptHash(this)
1582-                        if ((hf == he))
1583-                            then (hg != he)
1810+                        let il = blake2b256(value(gf.script))
1811+                        let im = fromBase64String(value(getString(aT, aF())))
1812+                        let in = scriptHash(this)
1813+                        if ((im == il))
1814+                            then (in != il)
15841815                             else false
15851816                         }
15861817                 }
1587-            else sigVerify(gZ.bodyBytes, gZ.proofs[0], hb)
1818+            else sigVerify(ig.bodyBytes, ig.proofs[0], ii)
15881819     }
15891820 

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let a = 8
55 
66 let b = 100000000
77 
88 let c = toBigInt(100000000)
99 
1010 let d = toBigInt(1000000000000000000)
1111 
1212 let e = toBigInt(0)
1313 
1414 let f = toBigInt(0)
1515 
1616 let g = toBigInt(1)
1717 
1818 let h = toBigInt(2)
1919 
2020 let i = "WAVES"
2121 
2222 let j = "__"
2323 
2424 let k = 1
2525 
2626 let l = 2
2727 
2828 let m = 3
2929 
3030 let n = 4
3131 
3232 let o = 1
3333 
3434 let p = 2
3535 
3636 let q = 3
3737 
3838 let r = 4
3939 
4040 let s = 5
4141 
4242 let t = 6
4343 
4444 let u = 7
4545 
4646 let v = 8
4747 
4848 let w = 9
4949 
5050 let x = 10
5151 
5252 let y = 1
5353 
5454 let z = 2
5555 
5656 let A = 3
5757 
5858 let B = 1
5959 
6060 let C = 7
6161 
6262 func D (E,F) = fraction(toBigInt(E), d, toBigInt(F))
6363 
6464 
6565 func G (E,F) = fraction(E, d, F)
6666 
6767 
6868 func H (I,J) = toInt(fraction(I, toBigInt(J), d))
6969 
7070 
7171 func K (I,J,L) = toInt(fraction(I, toBigInt(J), d, L))
7272 
7373 
7474 func M (N,O,P) = fraction(N, O, P)
7575 
7676 
7777 func Q (I) = if ((0 > I))
7878     then -(I)
7979     else I
8080 
8181 
8282 func R (I) = if ((e > I))
8383     then -(I)
8484     else I
8585 
8686 
8787 func S () = "%s__swapContract"
8888 
8989 
9090 func T () = "%s__factoryContract"
9191 
9292 
9393 func U () = "%s__managerPublicKey"
9494 
9595 
9696 func V () = "%s__pendingManagerPublicKey"
9797 
9898 
9999 func W () = "%s%s__price__last"
100100 
101101 
102102 func X (Y,Z) = makeString(["%s%s%d%d__price__history", toString(Y), toString(Z)], j)
103103 
104104 
105105 func aa (ab,ac) = ((("%s%s%s__P__" + ab) + "__") + ac)
106106 
107107 
108108 func ad (ab,ac) = ((("%s%s%s__G__" + ab) + "__") + ac)
109109 
110110 
111111 func ae () = "%s__amountAsset"
112112 
113113 
114114 func af () = "%s__priceAsset"
115115 
116116 
117117 let ag = "%s__fee"
118118 
119119 let ah = fraction(10, b, 10000)
120120 
121121 let ai = valueOrElse(getInteger(this, ag), ah)
122122 
123123 let aj = makeString(["%s", "kLp"], j)
124124 
125125 let ak = makeString(["%s", "kLpRefreshedHeight"], j)
126126 
127127 let al = makeString(["%s", "refreshKLpDelay"], j)
128128 
129129 let am = 30
130130 
131131 let an = valueOrElse(getInteger(this, al), am)
132132 
133-func ao () = "%s__factoryConfig"
133+func ao (ap) = makeString(["%s%s", "stakedBalance", ap], j)
134134 
135135 
136-func ap () = "%s%s__matcher__publicKey"
136+func aq (ap) = makeString(["%s%s", "shareAssetBalance", ap], j)
137137 
138138 
139-func aq (ar) = (("%s%s%s__" + ar) + "__mappings__poolContract2LpAsset")
139+func ar (ap) = valueOrElse(getInteger(this, ao(ap)), 0)
140140 
141141 
142-func as (at,au) = (((("%d%d%s__" + at) + "__") + au) + "__config")
142+func as (ap) = valueOrElse(getInteger(this, aq(ap)), 0)
143143 
144144 
145-func av (aw) = ("%s%s%s__mappings__baseAsset2internalId__" + aw)
145+func at () = "%s__factoryConfig"
146146 
147147 
148-func ax () = "%s__shutdown"
148+func au () = "%s%s__matcher__publicKey"
149149 
150150 
151-func ay (az) = ("%s%s__poolWeight__" + az)
151+func av (aw) = (("%s%s%s__" + aw) + "__mappings__poolContract2LpAsset")
152152 
153153 
154-func aA () = "%s__allowedLpScriptHash"
154+func ax (ay,az) = (((("%d%d%s__" + ay) + "__") + az) + "__config")
155155 
156156 
157-let aB = "%s__feeCollectorAddress"
158-
159-func aC (aD,aE,aF,aG) = throw((((((((("order validation failed: orderValid=" + toString(aD)) + " (") + aE) + ")") + " senderValid=") + toString(aF)) + " matcherValid=") + toString(aG)))
157+func aA (aB) = ("%s%s%s__mappings__baseAsset2internalId__" + aB)
160158 
161159 
162-func aH (aI,aJ) = valueOrErrorMessage(getString(aI, aJ), makeString(["mandatory ", toString(aI), ".", aJ, " is not defined"], ""))
160+func aC () = "%s__shutdown"
163161 
164162 
165-func aK (aI,aJ) = valueOrErrorMessage(getInteger(aI, aJ), makeString(["mandatory ", toString(aI), ".", aJ, " is not defined"], ""))
163+func aD (aE) = ("%s%s__poolWeight__" + aE)
166164 
167165 
168-func aL (aM) = throw(makeString(["lp.ride:", aM], " "))
166+func aF () = "%s__allowedLpScriptHash"
169167 
170168 
171-func aN (aM) = makeString(["lp.ride:", aM], " ")
169+let aG = "%s__feeCollectorAddress"
170+
171+func aH (aI,aJ,aK,aL) = throw((((((((("order validation failed: orderValid=" + toString(aI)) + " (") + aJ) + ")") + " senderValid=") + toString(aK)) + " matcherValid=") + toString(aL)))
172172 
173173 
174-let aO = addressFromStringValue(aH(this, T()))
174+func aM (aN,aO) = valueOrErrorMessage(getString(aN, aO), makeString(["mandatory ", toString(aN), ".", aO, " is not defined"], ""))
175175 
176-let aP = addressFromStringValue(aH(aO, aB))
177176 
178-let aQ = {
179-    let aR = invoke(aO, "getInFeeREADONLY", [toString(this)], nil)
180-    if ($isInstanceOf(aR, "Int"))
181-        then aR
182-        else throw(($getType(aR) + " couldn't be cast to Int"))
177+func aP (aN,aO) = valueOrErrorMessage(getInteger(aN, aO), makeString(["mandatory ", toString(aN), ".", aO, " is not defined"], ""))
178+
179+
180+func aQ (aR) = throw(makeString(["lp.ride:", aR], " "))
181+
182+
183+func aS (aR) = makeString(["lp.ride:", aR], " ")
184+
185+
186+let aT = addressFromStringValue(aM(this, T()))
187+
188+let aU = addressFromStringValue(aM(aT, aG))
189+
190+let aV = {
191+    let aW = invoke(aT, "getInFeeREADONLY", [toString(this)], nil)
192+    if ($isInstanceOf(aW, "Int"))
193+        then aW
194+        else throw(($getType(aW) + " couldn't be cast to Int"))
183195     }
184196 
185-let aS = {
186-    let aR = invoke(aO, "getOutFeeREADONLY", [toString(this)], nil)
187-    if ($isInstanceOf(aR, "Int"))
188-        then aR
189-        else throw(($getType(aR) + " couldn't be cast to Int"))
197+let aX = {
198+    let aW = invoke(aT, "getOutFeeREADONLY", [toString(this)], nil)
199+    if ($isInstanceOf(aW, "Int"))
200+        then aW
201+        else throw(($getType(aW) + " couldn't be cast to Int"))
190202     }
191203 
192-func aT () = valueOrElse(getBoolean(aO, ax()), false)
204+func aY () = valueOrElse(getBoolean(aT, aC()), false)
193205 
194206 
195-func aU () = fromBase58String(aH(aO, ap()))
207+func aZ () = fromBase58String(aM(aT, au()))
196208 
197209 
198-func aV () = {
199-    let aW = aH(this, ae())
200-    let aX = aH(this, af())
201-    let au = aK(aO, av(aX))
202-    let at = aK(aO, av(aW))
203-    split(aH(aO, as(toString(at), toString(au))), j)
210+func ba () = {
211+    let bb = aM(this, ae())
212+    let bc = aM(this, af())
213+    let az = aP(aT, aA(bc))
214+    let ay = aP(aT, aA(bb))
215+    split(aM(aT, ax(toString(ay), toString(az))), j)
204216     }
205217 
206218 
207-func aY (aZ) = if ((aZ == i))
219+func bd (be) = if ((be == i))
208220     then unit
209-    else fromBase58String(aZ)
221+    else fromBase58String(be)
210222 
211223 
212-func ba (aZ) = if ((aZ == unit))
224+func bf (be) = if ((be == unit))
213225     then i
214-    else toBase58String(value(aZ))
226+    else toBase58String(value(be))
215227 
216228 
217-func bb (bc) = $Tuple7(addressFromStringValue(bc[o]), parseIntValue(bc[p]), fromBase58String(bc[q]), aY(bc[r]), aY(bc[s]), parseIntValue(bc[t]), parseIntValue(bc[u]))
229+func bg (bh) = $Tuple7(addressFromStringValue(bh[o]), parseIntValue(bh[p]), fromBase58String(bh[q]), bd(bh[r]), bd(bh[s]), parseIntValue(bh[t]), parseIntValue(bh[u]))
218230 
219231 
220-let bd = bb(aV())
232+let bi = bg(ba())
221233 
222-let be = bd
234+let bj = bi
223235 
224-let bf = be._1
236+let bk = bj._1
225237 
226-let bg = be._2
238+let bl = bj._2
227239 
228-let bh = be._3
240+let bm = bj._3
229241 
230-let bi = be._4
242+let bn = bj._4
231243 
232-let bj = be._5
244+let bo = bj._5
233245 
234-let bk = be._6
246+let bp = bj._6
235247 
236-let bl = be._7
248+let bq = bj._7
237249 
238-func bm () = split(aH(aO, ao()), j)
250+func br () = split(aM(aT, at()), j)
239251 
240252 
241-let bn = valueOrErrorMessage(addressFromString(bm()[B]), "incorrect staking address")
253+let bs = valueOrErrorMessage(addressFromString(br()[B]), "incorrect staking address")
242254 
243-let bo = valueOrErrorMessage(addressFromString(bm()[C]), "incorrect staking address")
255+let bt = valueOrErrorMessage(addressFromString(br()[C]), "incorrect staking address")
244256 
245-func bp (bq,br,bs,bt,bu,bv,bw,bx,by,bz) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(bq), toString(br), toString(bs), toString(bt), toString(bu), toString(bv), toString(bw), toString(bx), toString(by), toString(bz)], j)
257+func bu (bv,bw,bx,by,bz,bA,bB,bC,bD,bE) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(bv), toString(bw), toString(bx), toString(by), toString(bz), toString(bA), toString(bB), toString(bC), toString(bD), toString(bE)], j)
246258 
247259 
248-func bA (bB,bC,bD,bt,bw,bx) = makeString(["%d%d%d%d%d%d", toString(bB), toString(bC), toString(bD), toString(bt), toString(bw), toString(bx)], j)
260+func bF (bG,bH,bI,by,bB,bC) = makeString(["%d%d%d%d%d%d", toString(bG), toString(bH), toString(bI), toString(by), toString(bB), toString(bC)], j)
249261 
250262 
251-func bE (bF) = if ((bF == "WAVES"))
252-    then wavesBalance(this).available
253-    else assetBalance(this, fromBase58String(bF))
254-
255-
256-func bG (bH,bI) = fraction(bH, d, bI)
257-
258-
259-func bJ (bH,bI,L) = fraction(bH, d, bI, L)
260-
261-
262-func bK (bL,bM,bN,bO) = {
263-    let bP = D(bN, bL)
264-    let bQ = D(bO, bM)
265-    bG(bQ, bP)
263+func bJ (ap) = {
264+    let bK = if ((ap == "WAVES"))
265+        then wavesBalance(this).available
266+        else assetBalance(this, fromBase58String(ap))
267+    let bL = ((bK + ar(ap)) - as(ap))
268+    max([0, bL])
266269     }
267270 
268271 
269-func bR (bN,bO,bS) = {
270-    let bT = aV()
271-    let bU = parseIntValue(bT[t])
272-    let bV = parseIntValue(bT[u])
273-    let bW = bK(bU, bV, bN, bO)
274-    let bI = D(bN, bU)
275-    let bH = D(bO, bV)
276-    let bX = D(bS, b)
277-    let bY = bG(bI, bX)
278-    let bZ = bG(bH, bX)
279-[bW, bY, bZ]
272+func bM (bN,bO) = fraction(bN, d, bO)
273+
274+
275+func bP (bN,bO,L) = fraction(bN, d, bO, L)
276+
277+
278+func bQ (bR) = {
279+    let bS = invoke(bR, "getRate", nil, nil)
280+    if ((bS == bS))
281+        then {
282+            let bT = bS
283+            if ($isInstanceOf(bT, "Int"))
284+                then {
285+                    let bU = bT
286+                    bU
287+                    }
288+                else aQ("proxy.getRate() unexpected value")
289+            }
290+        else throw("Strict value is not equal to itself.")
280291     }
281292 
282293 
283-func ca (bN,bO,bS) = {
284-    let cb = bR(bN, bO, bS)
285-[H(cb[0], b), H(cb[1], b), H(cb[2], b)]
286-    }
287-
288-
289-func cc (cd,ce,cf,ab) = {
290-    let bT = aV()
291-    let cg = bT[q]
292-    let ch = bT[r]
293-    let ci = bT[s]
294-    let bL = parseIntValue(bT[t])
295-    let bM = parseIntValue(bT[u])
296-    let cj = bT[p]
297-    let ck = valueOrErrorMessage(assetInfo(fromBase58String(cg)), (("Asset " + cg) + " doesn't exist")).quantity
298-    if ((cg != ce))
299-        then throw("Invalid asset passed.")
300-        else {
301-            let cl = bE(ch)
302-            let cm = D(cl, bL)
303-            let cn = bE(ci)
304-            let co = D(cn, bM)
305-            let cp = bG(co, cm)
306-            let cq = H(cp, b)
307-            let cr = D(cf, b)
308-            let cs = D(ck, b)
309-            let ct = fraction(cm, cr, cs)
310-            let cu = fraction(co, cr, cs)
311-            let cv = K(ct, bL, FLOOR)
312-            let cw = K(cu, bM, FLOOR)
313-            let cx = if ((cd == ""))
314-                then nil
315-                else [ScriptTransfer(ab, cv, if ((ch == "WAVES"))
316-                    then unit
317-                    else fromBase58String(ch)), ScriptTransfer(ab, cw, if ((ci == "WAVES"))
318-                    then unit
319-                    else fromBase58String(ci)), StringEntry(ad(toString(ab), cd), bA(cv, cw, cf, cq, height, lastBlock.timestamp)), IntegerEntry(W(), cq), IntegerEntry(X(height, lastBlock.timestamp), cq)]
320-            $Tuple10(cv, cw, ch, ci, cl, cn, ck, cp, cj, cx)
321-            }
322-    }
323-
324-
325-func cy (cd,cz,cA,cB,cC,cD,ab,cE,cF) = {
326-    let bT = aV()
327-    let cg = fromBase58String(bT[q])
328-    let cG = bT[r]
329-    let cH = bT[s]
330-    let cI = bT[v]
331-    let cJ = bT[w]
332-    let bU = parseIntValue(bT[t])
333-    let bV = parseIntValue(bT[u])
334-    let cj = bT[p]
335-    let ck = valueOrErrorMessage(assetInfo(cg), (("Asset " + toBase58String(cg)) + " doesn't exist")).quantity
336-    let cK = toBase58String(valueOrElse(cB, fromBase58String("WAVES")))
337-    let cL = toBase58String(valueOrElse(cD, fromBase58String("WAVES")))
338-    if (if ((cG != cK))
339-        then true
340-        else (cH != cL))
341-        then throw("Invalid amt or price asset passed.")
342-        else {
343-            let cl = if (cE)
344-                then bE(cG)
345-                else (bE(cG) - cA)
346-            let cn = if (cE)
347-                then bE(cH)
348-                else (bE(cH) - cC)
349-            let cM = D(cA, bU)
350-            let cN = D(cC, bV)
351-            let cO = bG(cN, cM)
352-            let cm = D(cl, bU)
353-            let co = D(cn, bV)
354-            let cP = if ((ck == 0))
294+func bV (ap,bW,bX,bR) = {
295+    let bY = ar(ap)
296+    if ((bY == bY))
297+        then {
298+            let bZ = as(bX)
299+            if ((bZ == bZ))
355300                 then {
356-                    let cp = e
357-                    let cQ = e
358-                    let bX = pow((cM * cN), 0, toBigInt(5), 1, 0, DOWN)
359-                    $Tuple5(H(bX, b), H(cM, bU), H(cN, bV), bG((co + cN), (cm + cM)), cQ)
301+                    let ca = bd(ap)
302+                    if ((bW > 0))
303+                        then {
304+                            let cb = invoke(bR, "deposit", nil, [AttachedPayment(ca, bW)])
305+                            if ((cb == cb))
306+                                then {
307+                                    let bT = cb
308+                                    if ($isInstanceOf(bT, "Int"))
309+                                        then {
310+                                            let cc = bT
311+                                            let cd = (bY + bW)
312+                                            let ce = (bZ + cc)
313+[IntegerEntry(ao(ap), cd), IntegerEntry(aq(bX), ce)]
314+                                            }
315+                                        else nil
316+                                    }
317+                                else throw("Strict value is not equal to itself.")
318+                            }
319+                        else nil
360320                     }
361-                else {
362-                    let cp = bG(co, cm)
363-                    let cQ = fraction(R((cp - cO)), d, cp)
364-                    let cR = D(cz, b)
365-                    if (if ((cp != e))
366-                        then (cQ > cR)
367-                        else false)
368-                        then throw(((("Price slippage " + toString(cQ)) + " exceeded the passed limit of ") + toString(cR)))
369-                        else {
370-                            let cs = D(ck, b)
371-                            let cS = fraction(cM, bJ(co, cm, CEILING), d, CEILING)
372-                            let cT = fraction(cN, d, bJ(co, cm, FLOOR), CEILING)
373-                            let cU = if ((cS > cN))
374-                                then $Tuple2(cT, cN)
375-                                else $Tuple2(cM, cS)
376-                            let cV = cU._1
377-                            let cW = cU._2
378-                            let bX = fraction(cs, cW, co, FLOOR)
379-                            $Tuple5(K(bX, b, FLOOR), K(cV, bU, CEILING), K(cW, bV, CEILING), cp, cQ)
380-                            }
381-                    }
382-            let cX = cP._1
383-            let cY = cP._2
384-            let cZ = cP._3
385-            let cq = H(cP._4, b)
386-            let da = H(cP._5, b)
387-            if ((0 >= cX))
388-                then throw("Invalid calculations. LP calculated is less than zero.")
389-                else {
390-                    let db = if (!(cF))
391-                        then 0
392-                        else cX
393-                    let dc = (cA - cY)
394-                    let dd = (cC - cZ)
395-                    let de = [IntegerEntry(W(), cq), IntegerEntry(X(height, lastBlock.timestamp), cq), StringEntry(aa(ab, cd), bp(cY, cZ, db, cq, cz, da, height, lastBlock.timestamp, dc, dd))]
396-                    $Tuple13(cX, db, cq, cl, cn, ck, cg, cj, de, dc, dd, cB, cD)
397-                    }
398-            }
399-    }
400-
401-
402-func df (dg,dh,ck) = {
403-    let di = G(dg, toBigInt(bk))
404-    let dj = G(dh, toBigInt(bl))
405-    let dk = fraction(pow((di * dj), 0, toBigInt(5), 1, 18, DOWN), g, ck)
406-    if ((ck == f))
407-        then f
408-        else dk
409-    }
410-
411-
412-func dl (dm,dn,do) = {
413-    let dp = (toBigInt(bE(ba(bi))) - dm)
414-    let dq = (toBigInt(bE(ba(bj))) - dn)
415-    let dr = (toBigInt(value(assetInfo(bh)).quantity) - do)
416-    let ds = df(dp, dq, dr)
417-    ds
418-    }
419-
420-
421-func dt (du,dv,do) = {
422-    let dp = (bE(ba(bi)) + du)
423-    let dq = (bE(ba(bj)) + dv)
424-    let dr = (value(assetInfo(bh)).quantity + do)
425-    let dk = df(toBigInt(dp), toBigInt(dq), toBigInt(dr))
426-    let dw = [IntegerEntry(ak, height), StringEntry(aj, toString(dk))]
427-    $Tuple2(dw, dk)
428-    }
429-
430-
431-func dx (dy,dk) = if ((dk >= dy))
432-    then true
433-    else aL(makeString(["updated KLp lower than current KLp", toString(dy), toString(dk)], " "))
434-
435-
436-func dz (dA) = {
437-    let dp = bE(ba(bi))
438-    let dq = bE(ba(bj))
439-    let dB = dA.amount
440-    let dC = fraction(dA.amount, dA.price, b, FLOOR)
441-    let dD = if ((dA.orderType == Buy))
442-        then $Tuple2(dB, -(dC))
443-        else $Tuple2(-(dB), dC)
444-    let du = dD._1
445-    let dv = dD._2
446-    if (if (if (aT())
447-        then true
448-        else (bg == m))
449-        then true
450-        else (bg == n))
451-        then throw("Exchange operations disabled")
452-        else if (if ((dA.assetPair.amountAsset != bi))
453-            then true
454-            else (dA.assetPair.priceAsset != bj))
455-            then throw("Wrong order assets.")
456-            else {
457-                let dE = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, aj), "0")), aN("invalid kLp"))
458-                let dF = dt(du, dv, 0)
459-                let dG = dF._1
460-                let dH = dF._2
461-                let dI = (dH >= dE)
462-                let dJ = makeString(["kLp=", toString(dE), " kLpNew=", toString(dH), " amountAssetBalance=", toString(dp), " priceAssetBalance=", toString(dq), " amountAssetBalanceDelta=", toString(du), " priceAssetBalanceDelta=", toString(dv), " height=", toString(height)], "")
463-                $Tuple2(dI, dJ)
464-                }
465-    }
466-
467-
468-func dK (dL) = if ((size(dL.payments) != 1))
469-    then throw("exactly 1 payment is expected")
470-    else {
471-        let dM = value(dL.payments[0])
472-        let ce = value(dM.assetId)
473-        let dN = dM.amount
474-        let cP = cc(toBase58String(dL.transactionId), toBase58String(ce), dN, dL.caller)
475-        let cv = cP._1
476-        let cw = cP._2
477-        let cj = parseIntValue(cP._9)
478-        let cx = cP._10
479-        if (if (aT())
480-            then true
481-            else (cj == n))
482-            then throw(("Get operation is blocked by admin. Status = " + toString(cj)))
483-            else $Tuple5(cv, cw, dN, ce, cx)
484-        }
485-
486-
487-func dO (dL,cz,cF) = if ((size(dL.payments) != 2))
488-    then throw("exactly 2 payments are expected")
489-    else {
490-        let dP = value(dL.payments[0])
491-        let dQ = value(dL.payments[1])
492-        let dR = cy(toBase58String(dL.transactionId), cz, dP.amount, dP.assetId, dQ.amount, dQ.assetId, toString(dL.caller), false, cF)
493-        let cj = parseIntValue(dR._8)
494-        if (if (if (aT())
495-            then true
496-            else (cj == l))
497-            then true
498-            else (cj == n))
499-            then throw(("Put operation is blocked by admin. Status = " + toString(cj)))
500-            else dR
501-        }
502-
503-
504-func dS (dT) = {
505-    let dU = invoke(aO, "emit", [dT], nil)
506-    if ((dU == dU))
507-        then {
508-            let dV = {
509-                let dW = dU
510-                if ($isInstanceOf(dW, "Address"))
511-                    then {
512-                        let dX = dW
513-                        invoke(dX, "emit", [dT], nil)
514-                        }
515-                    else unit
516-                }
517-            if ((dV == dV))
518-                then dT
519321                 else throw("Strict value is not equal to itself.")
520322             }
521323         else throw("Strict value is not equal to itself.")
522324     }
523325 
524326 
525-func dY (dT,ai) = {
526-    let dZ = if ((ai == 0))
527-        then 0
528-        else fraction(dT, ai, b)
529-    $Tuple2((dT - dZ), dZ)
530-    }
531-
532-
533-func ea (eb,ec,ab,ac) = {
534-    let ed = (ac == unit)
535-    let ee = bE(ba(bi))
536-    let ef = bE(ba(bj))
537-    let eg = if ((ec == bi))
538-        then true
539-        else if ((ec == bj))
540-            then false
541-            else aL("invalid asset")
542-    let eh = if (ed)
543-        then $Tuple2(ee, ef)
544-        else if (eg)
545-            then $Tuple2((ee - eb), ef)
546-            else $Tuple2(ee, (ef - eb))
547-    let ei = eh._1
548-    let ej = eh._2
549-    let ek = if (eg)
550-        then $Tuple2(eb, 0)
551-        else $Tuple2(0, eb)
552-    let el = ek._1
553-    let em = ek._2
554-    let dB = dY(el, aQ)._1
555-    let dC = dY(em, aQ)._1
556-    let en = dY(eb, aQ)
557-    let eo = en._1
558-    let dZ = en._2
559-    let ep = (ei + dB)
560-    let eq = (ej + dC)
561-    let er = bG(D(eq, bl), D(ep, bk))
562-    let es = H(er, b)
563-    let et = if (eg)
564-        then ei
565-        else ej
566-    let eu = toBigInt(et)
567-    let ev = toBigInt(valueOrErrorMessage(assetInfo(bh), (("asset " + toBase58String(bh)) + " doesn't exist")).quantity)
568-    let ew = if ((ev > f))
569-        then true
570-        else aL("initial deposit requires all coins")
571-    if ((ew == ew))
327+func cf (ap,bW,bX,bR,cg,ch) = {
328+    let bY = ar(ap)
329+    if ((bY == bY))
572330         then {
573-            let ex = toBigInt(eo)
574-            let ey = max([0, toInt(((ev * (sqrtBigInt((d + ((ex * d) / eu)), 18, 18, DOWN) - d)) / d))])
575-            let de = if (ed)
576-                then nil
577-                else [IntegerEntry(W(), es), IntegerEntry(X(height, lastBlock.timestamp), es), StringEntry(aa(toString(value(ab)), toBase58String(value(ac))), bp(el, em, ey, es, 0, 0, height, lastBlock.timestamp, 0, 0))]
578-            let ez = bG(D(ej, bl), D(ei, bk))
579-            let eA = H(ez, b)
580-            let eB = {
581-                let eC = if (eg)
582-                    then $Tuple2(el, ei)
583-                    else $Tuple2(em, ej)
584-                let dT = eC._1
585-                let eD = eC._2
586-                let eE = toInt(fraction(ev, toBigInt((dT / 2)), toBigInt(eD)))
587-                fraction((ey - eE), b, eE)
588-                }
589-            $Tuple5(ey, de, dZ, eB, eg)
331+            let bZ = as(bX)
332+            if ((bZ == bZ))
333+                then {
334+                    let ci = bQ(bR)
335+                    if ((ci == ci))
336+                        then {
337+                            let cj = fraction(cg, bY, bZ)
338+                            let ck = bd(bX)
339+                            let cl = fraction(cg, bW, cj)
340+                            let cm = fraction(cg, bW, ci)
341+                            let cn = max([0, (cl - cm)])
342+                            if ((cm > 0))
343+                                then {
344+                                    let co = invoke(bR, "withdraw", nil, [AttachedPayment(ck, cm)])
345+                                    if ((co == co))
346+                                        then {
347+                                            let bT = co
348+                                            if ($isInstanceOf(bT, "Int"))
349+                                                then {
350+                                                    let cp = bT
351+                                                    let cd = (bY - cp)
352+                                                    let ce = ((bZ - cm) - cn)
353+[IntegerEntry(ao(ap), cd), IntegerEntry(aq(bX), ce), ScriptTransfer(ch, cn, bd(bX))]
354+                                                    }
355+                                                else nil
356+                                            }
357+                                        else throw("Strict value is not equal to itself.")
358+                                    }
359+                                else nil
360+                            }
361+                        else throw("Strict value is not equal to itself.")
362+                    }
363+                else throw("Strict value is not equal to itself.")
590364             }
591365         else throw("Strict value is not equal to itself.")
592366     }
593367 
594368 
595-func eF (eG,eo,ec,ab,ac) = {
596-    let ed = (ac == unit)
597-    let bT = aV()
598-    let bU = parseIntValue(bT[t])
599-    let bV = parseIntValue(bT[u])
600-    let eH = [if ((ec == bh))
601-        then true
602-        else aL("invalid lp asset")]
603-    if ((eH == eH))
369+func cq (ap) = {
370+    let bT = invoke(aT, "getPoolLeaseConfigREADONLY", [toString(this), ap], nil)
371+    if ($isInstanceOf(bT, "(Boolean, Int, Int, String, String, Int, String)"))
604372         then {
605-            let eI = if ((eG == bi))
606-                then true
607-                else if ((eG == bj))
608-                    then false
609-                    else aL("invalid asset")
610-            let eJ = if (eI)
611-                then toBigInt(bE(ba(bi)))
612-                else toBigInt(bE(ba(bj)))
613-            let eK = if (eI)
614-                then bU
615-                else bV
616-            let eL = bE(ba(bi))
617-            let eM = bE(ba(bj))
618-            let eN = if (eI)
619-                then eL
620-                else eM
621-            let eO = toBigInt(eN)
622-            let ev = toBigInt(valueOrErrorMessage(assetInfo(bh), (("asset " + toBase58String(bh)) + " doesn't exist")).quantity)
623-            let eP = toBigInt(eo)
624-            let eQ = max([0, toInt(((eJ * (d - pow((d - ((eP * d) / ev)), 18, h, 0, 18, DOWN))) / d))])
625-            let eR = dY(eQ, aS)
626-            let eS = eR._1
627-            let dZ = eR._2
628-            let eT = if (eI)
629-                then $Tuple4(eS, 0, (eL - eQ), eM)
630-                else $Tuple4(0, eS, eL, (eM - eQ))
631-            let eU = eT._1
632-            let eV = eT._2
633-            let eW = eT._3
634-            let eX = eT._4
635-            let er = bG(D(eX, bl), D(eW, bk))
636-            let es = H(er, b)
637-            let de = if (ed)
638-                then nil
639-                else [StringEntry(ad(toString(value(ab)), toBase58String(value(ac))), bA(eU, eV, eo, es, height, lastBlock.timestamp)), IntegerEntry(W(), es), IntegerEntry(X(height, lastBlock.timestamp), es)]
640-            let ez = bG(D(eM, bl), D(eL, bk))
641-            let eA = H(ez, b)
642-            let eB = {
643-                let eY = (toInt(fraction(eJ, eP, ev)) * 2)
644-                fraction((eS - eY), b, eY)
645-                }
646-            $Tuple5(eS, de, dZ, eB, eI)
373+            let cr = bT
374+            cr
375+            }
376+        else aQ((("[" + ap) + "] getLeaseProxyConfig() error"))
377+    }
378+
379+
380+func cs (ct,ap,bX,cu,bR,cg,ch) = {
381+    let bY = ar(ap)
382+    if ((bY == bY))
383+        then {
384+            let bZ = as(bX)
385+            if ((bZ == bZ))
386+                then {
387+                    let cv = max([0, (bJ(ap) - cu)])
388+                    let cw = fraction(ct, cv, 100)
389+                    let cx = (bY - cw)
390+                    if ((cx == 0))
391+                        then nil
392+                        else if ((0 > cx))
393+                            then {
394+                                let cy = -(cx)
395+                                bV(ap, cy, bX, bR)
396+                                }
397+                            else {
398+                                let cz = cx
399+                                cf(ap, cz, bX, bR, cg, ch)
400+                                }
401+                    }
402+                else throw("Strict value is not equal to itself.")
647403             }
648404         else throw("Strict value is not equal to itself.")
649405     }
650406 
651407 
652-func eZ () = {
653-    let dW = getString(U())
654-    if ($isInstanceOf(dW, "String"))
408+func cA (ap) = {
409+    let cB = cq(ap)
410+    let cC = cB._1
411+    let cD = cB._2
412+    let cu = cB._3
413+    let cE = cB._4
414+    let cF = cB._5
415+    let cg = cB._6
416+    let cG = cB._7
417+    if (cC)
418+        then cs(cD, ap, cF, cu, addressFromStringValue(cE), cg, addressFromStringValue(cG))
419+        else nil
420+    }
421+
422+
423+func cH (ap,cI) = {
424+    let cJ = cq(ap)
425+    let cC = cJ._1
426+    let cD = cJ._2
427+    let cu = cJ._3
428+    let cE = cJ._4
429+    let cF = cJ._5
430+    let cg = cJ._6
431+    let cG = cJ._7
432+    if (cC)
655433         then {
656-            let fa = dW
657-            fromBase58String(fa)
434+            let cK = max([0, ((bJ(ap) - cI) - cu)])
435+            if ((cK == cK))
436+                then {
437+                    let cd = fraction(cD, cK, 100)
438+                    if ((cd == cd))
439+                        then {
440+                            let cL = (ar(ap) - cd)
441+                            if ((cL == cL))
442+                                then if ((0 > cL))
443+                                    then bV(ap, -(cL), cF, addressFromStringValue(cE))
444+                                    else cf(ap, cL, cF, addressFromStringValue(cE), cg, addressFromStringValue(cG))
445+                                else throw("Strict value is not equal to itself.")
446+                            }
447+                        else throw("Strict value is not equal to itself.")
448+                    }
449+                else throw("Strict value is not equal to itself.")
658450             }
659-        else if ($isInstanceOf(dW, "Unit"))
451+        else nil
452+    }
453+
454+
455+func cM (cN,cO) = {
456+    let cP = cH(aM(this, ae()), cN)
457+    let cQ = cH(aM(this, af()), cO)
458+    (cP ++ cQ)
459+    }
460+
461+
462+func cR (cS,cT,cU,cV) = {
463+    let cW = D(cU, cS)
464+    let cX = D(cV, cT)
465+    bM(cX, cW)
466+    }
467+
468+
469+func cY (cU,cV,cZ) = {
470+    let da = ba()
471+    let db = parseIntValue(da[t])
472+    let dc = parseIntValue(da[u])
473+    let dd = cR(db, dc, cU, cV)
474+    let bO = D(cU, db)
475+    let bN = D(cV, dc)
476+    let de = D(cZ, b)
477+    let df = bM(bO, de)
478+    let dg = bM(bN, de)
479+[dd, df, dg]
480+    }
481+
482+
483+func dh (cU,cV,cZ) = {
484+    let di = cY(cU, cV, cZ)
485+[H(di[0], b), H(di[1], b), H(di[2], b)]
486+    }
487+
488+
489+func dj (dk,dl,dm,ab) = {
490+    let da = ba()
491+    let dn = da[q]
492+    let do = da[r]
493+    let dp = da[s]
494+    let cS = parseIntValue(da[t])
495+    let cT = parseIntValue(da[u])
496+    let dq = da[p]
497+    let dr = valueOrErrorMessage(assetInfo(fromBase58String(dn)), (("Asset " + dn) + " doesn't exist")).quantity
498+    if ((dn != dl))
499+        then throw("Invalid asset passed.")
500+        else {
501+            let ds = bJ(do)
502+            let dt = D(ds, cS)
503+            let du = bJ(dp)
504+            let dv = D(du, cT)
505+            let dw = bM(dv, dt)
506+            let dx = H(dw, b)
507+            let dy = D(dm, b)
508+            let dz = D(dr, b)
509+            let dA = fraction(dt, dy, dz)
510+            let dB = fraction(dv, dy, dz)
511+            let dC = K(dA, cS, FLOOR)
512+            let dD = K(dB, cT, FLOOR)
513+            let dE = if ((dk == ""))
514+                then nil
515+                else [ScriptTransfer(ab, dC, if ((do == "WAVES"))
516+                    then unit
517+                    else fromBase58String(do)), ScriptTransfer(ab, dD, if ((dp == "WAVES"))
518+                    then unit
519+                    else fromBase58String(dp)), StringEntry(ad(toString(ab), dk), bF(dC, dD, dm, dx, height, lastBlock.timestamp)), IntegerEntry(W(), dx), IntegerEntry(X(height, lastBlock.timestamp), dx)]
520+            $Tuple10(dC, dD, do, dp, ds, du, dr, dw, dq, dE)
521+            }
522+    }
523+
524+
525+func dF (dk,dG,dH,dI,dJ,dK,ab,dL,dM) = {
526+    let da = ba()
527+    let dn = fromBase58String(da[q])
528+    let dN = da[r]
529+    let dO = da[s]
530+    let dP = da[v]
531+    let dQ = da[w]
532+    let db = parseIntValue(da[t])
533+    let dc = parseIntValue(da[u])
534+    let dq = da[p]
535+    let dr = valueOrErrorMessage(assetInfo(dn), (("Asset " + toBase58String(dn)) + " doesn't exist")).quantity
536+    let dR = toBase58String(valueOrElse(dI, fromBase58String("WAVES")))
537+    let dS = toBase58String(valueOrElse(dK, fromBase58String("WAVES")))
538+    if (if ((dN != dR))
539+        then true
540+        else (dO != dS))
541+        then throw("Invalid amt or price asset passed.")
542+        else {
543+            let ds = if (dL)
544+                then bJ(dN)
545+                else (bJ(dN) - dH)
546+            let du = if (dL)
547+                then bJ(dO)
548+                else (bJ(dO) - dJ)
549+            let dT = D(dH, db)
550+            let dU = D(dJ, dc)
551+            let dV = bM(dU, dT)
552+            let dt = D(ds, db)
553+            let dv = D(du, dc)
554+            let dW = if ((dr == 0))
555+                then {
556+                    let dw = e
557+                    let dX = e
558+                    let de = pow((dT * dU), 0, toBigInt(5), 1, 0, DOWN)
559+                    $Tuple5(H(de, b), H(dT, db), H(dU, dc), bM((dv + dU), (dt + dT)), dX)
560+                    }
561+                else {
562+                    let dw = bM(dv, dt)
563+                    let dX = fraction(R((dw - dV)), d, dw)
564+                    let dY = D(dG, b)
565+                    if (if ((dw != e))
566+                        then (dX > dY)
567+                        else false)
568+                        then throw(((("Price slippage " + toString(dX)) + " exceeded the passed limit of ") + toString(dY)))
569+                        else {
570+                            let dz = D(dr, b)
571+                            let dZ = fraction(dT, bP(dv, dt, CEILING), d, CEILING)
572+                            let ea = fraction(dU, d, bP(dv, dt, FLOOR), CEILING)
573+                            let eb = if ((dZ > dU))
574+                                then $Tuple2(ea, dU)
575+                                else $Tuple2(dT, dZ)
576+                            let ec = eb._1
577+                            let ed = eb._2
578+                            let de = fraction(dz, ed, dv, FLOOR)
579+                            $Tuple5(K(de, b, FLOOR), K(ec, db, CEILING), K(ed, dc, CEILING), dw, dX)
580+                            }
581+                    }
582+            let ee = dW._1
583+            let ef = dW._2
584+            let eg = dW._3
585+            let dx = H(dW._4, b)
586+            let eh = H(dW._5, b)
587+            if ((0 >= ee))
588+                then throw("Invalid calculations. LP calculated is less than zero.")
589+                else {
590+                    let ei = if (!(dM))
591+                        then 0
592+                        else ee
593+                    let ej = (dH - ef)
594+                    let ek = (dJ - eg)
595+                    let el = [IntegerEntry(W(), dx), IntegerEntry(X(height, lastBlock.timestamp), dx), StringEntry(aa(ab, dk), bu(ef, eg, ei, dx, dG, eh, height, lastBlock.timestamp, ej, ek))]
596+                    $Tuple13(ee, ei, dx, ds, du, dr, dn, dq, el, ej, ek, dI, dK)
597+                    }
598+            }
599+    }
600+
601+
602+func em (en,eo,dr) = {
603+    let ep = G(en, toBigInt(bp))
604+    let eq = G(eo, toBigInt(bq))
605+    let er = fraction(pow((ep * eq), 0, toBigInt(5), 1, 18, DOWN), g, dr)
606+    if ((dr == f))
607+        then f
608+        else er
609+    }
610+
611+
612+func es (et,eu,ev) = {
613+    let ew = (toBigInt(bJ(bf(bn))) - et)
614+    let ex = (toBigInt(bJ(bf(bo))) - eu)
615+    let ey = (toBigInt(value(assetInfo(bm)).quantity) - ev)
616+    let ez = em(ew, ex, ey)
617+    ez
618+    }
619+
620+
621+func eA (eB,eC,ev) = {
622+    let ew = (bJ(bf(bn)) + eB)
623+    let ex = (bJ(bf(bo)) + eC)
624+    let ey = (value(assetInfo(bm)).quantity + ev)
625+    let er = em(toBigInt(ew), toBigInt(ex), toBigInt(ey))
626+    let eD = [IntegerEntry(ak, height), StringEntry(aj, toString(er))]
627+    $Tuple2(eD, er)
628+    }
629+
630+
631+func eE (eF,er) = if ((er >= eF))
632+    then true
633+    else aQ(makeString(["updated KLp lower than current KLp", toString(eF), toString(er)], " "))
634+
635+
636+func eG (eH) = {
637+    let ew = bJ(bf(bn))
638+    let ex = bJ(bf(bo))
639+    let eI = eH.amount
640+    let eJ = fraction(eH.amount, eH.price, b, FLOOR)
641+    let eK = if ((eH.orderType == Buy))
642+        then $Tuple2(eI, -(eJ))
643+        else $Tuple2(-(eI), eJ)
644+    let eB = eK._1
645+    let eC = eK._2
646+    if (if (if (aY())
647+        then true
648+        else (bl == m))
649+        then true
650+        else (bl == n))
651+        then throw("Exchange operations disabled")
652+        else if (if ((eH.assetPair.amountAsset != bn))
653+            then true
654+            else (eH.assetPair.priceAsset != bo))
655+            then throw("Wrong order assets.")
656+            else {
657+                let eL = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, aj), "0")), aS("invalid kLp"))
658+                let eM = eA(eB, eC, 0)
659+                let eN = eM._1
660+                let eO = eM._2
661+                let eP = (eO >= eL)
662+                let eQ = makeString(["kLp=", toString(eL), " kLpNew=", toString(eO), " amountAssetBalance=", toString(ew), " priceAssetBalance=", toString(ex), " amountAssetBalanceDelta=", toString(eB), " priceAssetBalanceDelta=", toString(eC), " height=", toString(height)], "")
663+                $Tuple2(eP, eQ)
664+                }
665+    }
666+
667+
668+func eR (eS) = if ((size(eS.payments) != 1))
669+    then throw("exactly 1 payment is expected")
670+    else {
671+        let eT = value(eS.payments[0])
672+        let dl = value(eT.assetId)
673+        let eU = eT.amount
674+        let dW = dj(toBase58String(eS.transactionId), toBase58String(dl), eU, eS.caller)
675+        let dC = dW._1
676+        let dD = dW._2
677+        let dq = parseIntValue(dW._9)
678+        let dE = dW._10
679+        if (if (aY())
680+            then true
681+            else (dq == n))
682+            then throw(("Get operation is blocked by admin. Status = " + toString(dq)))
683+            else $Tuple5(dC, dD, eU, dl, dE)
684+        }
685+
686+
687+func eV (eS,dG,dM) = if ((size(eS.payments) != 2))
688+    then throw("exactly 2 payments are expected")
689+    else {
690+        let eW = value(eS.payments[0])
691+        let eX = value(eS.payments[1])
692+        let eY = dF(toBase58String(eS.transactionId), dG, eW.amount, eW.assetId, eX.amount, eX.assetId, toString(eS.caller), false, dM)
693+        let dq = parseIntValue(eY._8)
694+        if (if (if (aY())
695+            then true
696+            else (dq == l))
697+            then true
698+            else (dq == n))
699+            then throw(("Put operation is blocked by admin. Status = " + toString(dq)))
700+            else eY
701+        }
702+
703+
704+func eZ (bW) = {
705+    let fa = invoke(aT, "emit", [bW], nil)
706+    if ((fa == fa))
707+        then {
708+            let fb = {
709+                let bT = fa
710+                if ($isInstanceOf(bT, "Address"))
711+                    then {
712+                        let fc = bT
713+                        invoke(fc, "emit", [bW], nil)
714+                        }
715+                    else unit
716+                }
717+            if ((fb == fb))
718+                then bW
719+                else throw("Strict value is not equal to itself.")
720+            }
721+        else throw("Strict value is not equal to itself.")
722+    }
723+
724+
725+func fd (bW,ai) = {
726+    let fe = if ((ai == 0))
727+        then 0
728+        else fraction(bW, ai, b)
729+    $Tuple2((bW - fe), fe)
730+    }
731+
732+
733+func ff (fg,fh,ab,ac) = {
734+    let fi = (ac == unit)
735+    let fj = bJ(bf(bn))
736+    let fk = bJ(bf(bo))
737+    let fl = if ((fh == bn))
738+        then true
739+        else if ((fh == bo))
740+            then false
741+            else aQ("invalid asset")
742+    let fm = if (fi)
743+        then $Tuple2(fj, fk)
744+        else if (fl)
745+            then $Tuple2((fj - fg), fk)
746+            else $Tuple2(fj, (fk - fg))
747+    let fn = fm._1
748+    let fo = fm._2
749+    let fp = if (fl)
750+        then $Tuple2(fg, 0)
751+        else $Tuple2(0, fg)
752+    let fq = fp._1
753+    let fr = fp._2
754+    let eI = fd(fq, aV)._1
755+    let eJ = fd(fr, aV)._1
756+    let fs = fd(fg, aV)
757+    let ft = fs._1
758+    let fe = fs._2
759+    let fu = (fn + eI)
760+    let fv = (fo + eJ)
761+    let fw = bM(D(fv, bq), D(fu, bp))
762+    let fx = H(fw, b)
763+    let fy = if (fl)
764+        then fn
765+        else fo
766+    let fz = toBigInt(fy)
767+    let fA = toBigInt(valueOrErrorMessage(assetInfo(bm), (("asset " + toBase58String(bm)) + " doesn't exist")).quantity)
768+    let fB = if ((fA > f))
769+        then true
770+        else aQ("initial deposit requires all coins")
771+    if ((fB == fB))
772+        then {
773+            let fC = toBigInt(ft)
774+            let fD = max([0, toInt(((fA * (sqrtBigInt((d + ((fC * d) / fz)), 18, 18, DOWN) - d)) / d))])
775+            let el = if (fi)
776+                then nil
777+                else [IntegerEntry(W(), fx), IntegerEntry(X(height, lastBlock.timestamp), fx), StringEntry(aa(toString(value(ab)), toBase58String(value(ac))), bu(fq, fr, fD, fx, 0, 0, height, lastBlock.timestamp, 0, 0))]
778+            let fE = bM(D(fo, bq), D(fn, bp))
779+            let fF = H(fE, b)
780+            let fG = {
781+                let fH = if (fl)
782+                    then $Tuple2(fq, fn)
783+                    else $Tuple2(fr, fo)
784+                let bW = fH._1
785+                let fI = fH._2
786+                let fJ = toInt(fraction(fA, toBigInt((bW / 2)), toBigInt(fI)))
787+                fraction((fD - fJ), b, fJ)
788+                }
789+            $Tuple5(fD, el, fe, fG, fl)
790+            }
791+        else throw("Strict value is not equal to itself.")
792+    }
793+
794+
795+func fK (fL,ft,fh,ab,ac) = {
796+    let fi = (ac == unit)
797+    let da = ba()
798+    let db = parseIntValue(da[t])
799+    let dc = parseIntValue(da[u])
800+    let fM = [if ((fh == bm))
801+        then true
802+        else aQ("invalid lp asset")]
803+    if ((fM == fM))
804+        then {
805+            let fN = if ((fL == bn))
806+                then true
807+                else if ((fL == bo))
808+                    then false
809+                    else aQ("invalid asset")
810+            let fO = if (fN)
811+                then toBigInt(bJ(bf(bn)))
812+                else toBigInt(bJ(bf(bo)))
813+            let fP = if (fN)
814+                then db
815+                else dc
816+            let fQ = bJ(bf(bn))
817+            let fR = bJ(bf(bo))
818+            let fS = if (fN)
819+                then fQ
820+                else fR
821+            let fT = toBigInt(fS)
822+            let fA = toBigInt(valueOrErrorMessage(assetInfo(bm), (("asset " + toBase58String(bm)) + " doesn't exist")).quantity)
823+            let fU = toBigInt(ft)
824+            let fV = max([0, toInt(((fO * (d - pow((d - ((fU * d) / fA)), 18, h, 0, 18, DOWN))) / d))])
825+            let fW = fd(fV, aX)
826+            let fX = fW._1
827+            let fe = fW._2
828+            let fY = if (fN)
829+                then $Tuple4(fX, 0, (fQ - fV), fR)
830+                else $Tuple4(0, fX, fQ, (fR - fV))
831+            let fZ = fY._1
832+            let ga = fY._2
833+            let gb = fY._3
834+            let gc = fY._4
835+            let fw = bM(D(gc, bq), D(gb, bp))
836+            let fx = H(fw, b)
837+            let el = if (fi)
838+                then nil
839+                else [StringEntry(ad(toString(value(ab)), toBase58String(value(ac))), bF(fZ, ga, ft, fx, height, lastBlock.timestamp)), IntegerEntry(W(), fx), IntegerEntry(X(height, lastBlock.timestamp), fx)]
840+            let fE = bM(D(fR, bq), D(fQ, bp))
841+            let fF = H(fE, b)
842+            let fG = {
843+                let gd = (toInt(fraction(fO, fU, fA)) * 2)
844+                fraction((fX - gd), b, gd)
845+                }
846+            $Tuple5(fX, el, fe, fG, fN)
847+            }
848+        else throw("Strict value is not equal to itself.")
849+    }
850+
851+
852+func ge () = {
853+    let bT = getString(U())
854+    if ($isInstanceOf(bT, "String"))
855+        then {
856+            let gf = bT
857+            fromBase58String(gf)
858+            }
859+        else if ($isInstanceOf(bT, "Unit"))
660860             then unit
661861             else throw("Match error")
662862     }
663863 
664864 
665-func fb () = {
666-    let dW = getString(V())
667-    if ($isInstanceOf(dW, "String"))
865+func gg () = {
866+    let bT = getString(V())
867+    if ($isInstanceOf(bT, "String"))
668868         then {
669-            let fa = dW
670-            fromBase58String(fa)
869+            let gf = bT
870+            fromBase58String(gf)
671871             }
672-        else if ($isInstanceOf(dW, "Unit"))
872+        else if ($isInstanceOf(bT, "Unit"))
673873             then unit
674874             else throw("Match error")
675875     }
676876 
677877 
678-func fc (dL) = {
679-    let dW = eZ()
680-    if ($isInstanceOf(dW, "ByteVector"))
878+func gh (eS) = {
879+    let bT = ge()
880+    if ($isInstanceOf(bT, "ByteVector"))
681881         then {
682-            let fd = dW
683-            (dL.callerPublicKey == fd)
882+            let gi = bT
883+            (eS.callerPublicKey == gi)
684884             }
685-        else if ($isInstanceOf(dW, "Unit"))
686-            then (dL.caller == this)
885+        else if ($isInstanceOf(bT, "Unit"))
886+            then (eS.caller == this)
687887             else throw("Match error")
688888     }
689889 
690890 
691-func fe (dL) = {
692-    let ff = throw("Permission denied")
693-    let dW = eZ()
694-    if ($isInstanceOf(dW, "ByteVector"))
891+func gj (eS) = {
892+    let gk = throw("Permission denied")
893+    let bT = ge()
894+    if ($isInstanceOf(bT, "ByteVector"))
695895         then {
696-            let fd = dW
697-            if ((dL.callerPublicKey == fd))
896+            let gi = bT
897+            if ((eS.callerPublicKey == gi))
698898                 then true
699-                else ff
899+                else gk
700900             }
701-        else if ($isInstanceOf(dW, "Unit"))
702-            then if ((dL.caller == this))
901+        else if ($isInstanceOf(bT, "Unit"))
902+            then if ((eS.caller == this))
703903                 then true
704-                else ff
904+                else gk
705905             else throw("Match error")
706906     }
707907 
708908 
709-@Callable(dL)
710-func calculateAmountOutForSwapREADONLY (fg,fh,fi) = {
711-    let fj = if ((fh == false))
909+@Callable(eS)
910+func rebalance () = (cA(aM(this, ae())) ++ cA(aM(this, af())))
911+
912+
913+
914+@Callable(eS)
915+func calculateAmountOutForSwapREADONLY (gl,gm,gn) = {
916+    let go = if ((gm == false))
712917         then {
713-            let fk = aH(this, af())
714-            let fl = aH(this, ae())
715-            $Tuple2(fk, fl)
918+            let gp = aM(this, af())
919+            let gq = aM(this, ae())
920+            $Tuple2(gp, gq)
716921             }
717922         else {
718-            let fk = aH(this, ae())
719-            let fl = aH(this, af())
720-            $Tuple2(fk, fl)
923+            let gp = aM(this, ae())
924+            let gq = aM(this, af())
925+            $Tuple2(gp, gq)
721926             }
722-    let fk = fj._1
723-    let fl = fj._2
724-    let fm = bE(fl)
725-    let fn = bE(fk)
726-    let fo = fraction(fn, fg, (fm + fg))
727-    let fp = (toBigInt(fm) * toBigInt(fn))
728-    let fq = (((toBigInt(bE(fl)) + toBigInt(fg)) + toBigInt(fi)) * (toBigInt(bE(fk)) - toBigInt(fo)))
729-    let fr = if ((fq >= fp))
927+    let gp = go._1
928+    let gq = go._2
929+    let gr = bJ(gq)
930+    let gs = bJ(gp)
931+    let gt = fraction(gs, gl, (gr + gl))
932+    let gu = (toBigInt(gr) * toBigInt(gs))
933+    let gv = (((toBigInt(bJ(gq)) + toBigInt(gl)) + toBigInt(gn)) * (toBigInt(bJ(gp)) - toBigInt(gt)))
934+    let gw = if ((gv >= gu))
730935         then true
731936         else throw("new K is fewer error")
732-    if ((fr == fr))
733-        then $Tuple2(nil, fo)
937+    if ((gw == gw))
938+        then $Tuple2(nil, gt)
734939         else throw("Strict value is not equal to itself.")
735940     }
736941 
737942 
738943 
739-@Callable(dL)
740-func calculateAmountOutForSwapAndSendTokens (fg,fh,fs,ft,fi) = {
741-    let fu = {
742-        let aR = invoke(aO, "getSwapContractREADONLY", nil, nil)
743-        if ($isInstanceOf(aR, "String"))
744-            then aR
745-            else throw(($getType(aR) + " couldn't be cast to String"))
944+@Callable(eS)
945+func calculateAmountOutForSwapAndSendTokens (gl,gm,gx,gy,gn) = {
946+    let gz = {
947+        let aW = invoke(aT, "getSwapContractREADONLY", nil, nil)
948+        if ($isInstanceOf(aW, "String"))
949+            then aW
950+            else throw(($getType(aW) + " couldn't be cast to String"))
746951         }
747-    let eH = [if ((value(dL.payments[0]).amount >= fg))
952+    let fM = [if ((value(eS.payments[0]).amount >= gl))
748953         then true
749-        else aL("Wrong amount"), if ((dL.caller == addressFromStringValue(fu)))
954+        else aQ("Wrong amount"), if ((eS.caller == addressFromStringValue(gz)))
750955         then true
751-        else aL("Permission denied")]
752-    if ((eH == eH))
956+        else aQ("Permission denied")]
957+    if ((fM == fM))
753958         then {
754-            let dM = value(dL.payments[0])
755-            let fl = ba(dM.assetId)
756-            let fk = if ((fh == false))
757-                then aH(this, af())
758-                else aH(this, ae())
759-            let fm = (bE(fl) - value(dL.payments[0]).amount)
760-            let fn = bE(fk)
761-            let fo = fraction(fn, fg, (fm + fg))
762-            let fp = (toBigInt(fm) * toBigInt(fn))
763-            let fq = ((toBigInt(bE(fl)) + toBigInt(fi)) * (toBigInt(bE(fk)) - toBigInt(fo)))
764-            let fr = if ((fq >= fp))
959+            let eT = value(eS.payments[0])
960+            let gq = bf(eT.assetId)
961+            let gp = if ((gm == false))
962+                then aM(this, af())
963+                else aM(this, ae())
964+            let gr = (bJ(gq) - value(eS.payments[0]).amount)
965+            let gs = bJ(gp)
966+            let gt = fraction(gs, gl, (gr + gl))
967+            let gu = (toBigInt(gr) * toBigInt(gs))
968+            let gv = ((toBigInt(bJ(gq)) + toBigInt(gn)) * (toBigInt(bJ(gp)) - toBigInt(gt)))
969+            let gw = if ((gv >= gu))
765970                 then true
766971                 else throw("new K is fewer error")
767-            if ((fr == fr))
972+            if ((gw == gw))
768973                 then {
769-                    let fv = if ((fo >= fs))
974+                    let gA = if ((gt >= gx))
770975                         then true
771976                         else throw("Exchange result is fewer coins than expected")
772-                    if ((fv == fv))
773-                        then $Tuple2([ScriptTransfer(addressFromStringValue(ft), fo, aY(fk))], fo)
977+                    if ((gA == gA))
978+                        then {
979+                            let gB = cA(gq)
980+                            if ((gB == gB))
981+                                then {
982+                                    let gC = cH(gp, gt)
983+                                    if ((gC == gC))
984+                                        then $Tuple2(((gC ++ gB) ++ [ScriptTransfer(addressFromStringValue(gy), gt, bd(gp))]), gt)
985+                                        else throw("Strict value is not equal to itself.")
986+                                    }
987+                                else throw("Strict value is not equal to itself.")
988+                            }
774989                         else throw("Strict value is not equal to itself.")
775990                     }
776991                 else throw("Strict value is not equal to itself.")
777992             }
778993         else throw("Strict value is not equal to itself.")
779994     }
780995 
781996 
782997 
783-@Callable(dL)
784-func setManager (fw) = {
785-    let fx = fe(dL)
786-    if ((fx == fx))
998+@Callable(eS)
999+func setManager (gD) = {
1000+    let gE = gj(eS)
1001+    if ((gE == gE))
7871002         then {
788-            let fy = fromBase58String(fw)
789-            if ((fy == fy))
790-                then [StringEntry(V(), fw)]
1003+            let gF = fromBase58String(gD)
1004+            if ((gF == gF))
1005+                then [StringEntry(V(), gD)]
7911006                 else throw("Strict value is not equal to itself.")
7921007             }
7931008         else throw("Strict value is not equal to itself.")
7941009     }
7951010 
7961011 
7971012 
798-@Callable(dL)
1013+@Callable(eS)
7991014 func confirmManager () = {
800-    let fz = fb()
801-    let fA = if (isDefined(fz))
1015+    let gG = gg()
1016+    let gH = if (isDefined(gG))
8021017         then true
8031018         else throw("No pending manager")
804-    if ((fA == fA))
1019+    if ((gH == gH))
8051020         then {
806-            let fB = if ((dL.callerPublicKey == value(fz)))
1021+            let gI = if ((eS.callerPublicKey == value(gG)))
8071022                 then true
8081023                 else throw("You are not pending manager")
809-            if ((fB == fB))
810-                then [StringEntry(U(), toBase58String(value(fz))), DeleteEntry(V())]
1024+            if ((gI == gI))
1025+                then [StringEntry(U(), toBase58String(value(gG))), DeleteEntry(V())]
8111026                 else throw("Strict value is not equal to itself.")
8121027             }
8131028         else throw("Strict value is not equal to itself.")
8141029     }
8151030 
8161031 
8171032 
818-@Callable(dL)
819-func put (cz,fC) = if ((0 > cz))
1033+@Callable(eS)
1034+func put (dG,gJ) = if ((0 > dG))
8201035     then throw("Invalid slippageTolerance passed")
8211036     else {
822-        let dR = dO(dL, cz, true)
823-        let db = dR._2
824-        let cg = dR._7
825-        let cx = dR._9
826-        let dc = dR._10
827-        let dd = dR._11
828-        let fD = dR._12
829-        let fE = dR._13
830-        let dP = toBigInt(value(dL.payments[0]).amount)
831-        let dQ = toBigInt(value(dL.payments[1]).amount)
832-        let ds = dl(dP, dQ, toBigInt(0))
833-        if ((ds == ds))
1037+        let eY = eV(eS, dG, true)
1038+        let ei = eY._2
1039+        let dn = eY._7
1040+        let dE = eY._9
1041+        let ej = eY._10
1042+        let ek = eY._11
1043+        let gK = eY._12
1044+        let gL = eY._13
1045+        let eW = toBigInt(value(eS.payments[0]).amount)
1046+        let eX = toBigInt(value(eS.payments[1]).amount)
1047+        let ez = es(eW, eX, toBigInt(0))
1048+        if ((ez == ez))
8341049             then {
835-                let dU = invoke(aO, "emit", [db], nil)
836-                if ((dU == dU))
1050+                let fa = invoke(aT, "emit", [ei], nil)
1051+                if ((fa == fa))
8371052                     then {
838-                        let dV = {
839-                            let dW = dU
840-                            if ($isInstanceOf(dW, "Address"))
1053+                        let fb = {
1054+                            let bT = fa
1055+                            if ($isInstanceOf(bT, "Address"))
8411056                                 then {
842-                                    let dX = dW
843-                                    invoke(dX, "emit", [db], nil)
1057+                                    let fc = bT
1058+                                    invoke(fc, "emit", [ei], nil)
8441059                                     }
8451060                                 else unit
8461061                             }
847-                        if ((dV == dV))
1062+                        if ((fb == fb))
8481063                             then {
849-                                let fF = if ((dc > 0))
850-                                    then invoke(bo, "put", nil, [AttachedPayment(fD, dc)])
1064+                                let gM = if ((ej > 0))
1065+                                    then invoke(bt, "put", nil, [AttachedPayment(gK, ej)])
8511066                                     else nil
852-                                if ((fF == fF))
1067+                                if ((gM == gM))
8531068                                     then {
854-                                        let fG = if ((dd > 0))
855-                                            then invoke(bo, "put", nil, [AttachedPayment(fE, dd)])
1069+                                        let gN = if ((ek > 0))
1070+                                            then invoke(bt, "put", nil, [AttachedPayment(gL, ek)])
8561071                                             else nil
857-                                        if ((fG == fG))
1072+                                        if ((gN == gN))
8581073                                             then {
859-                                                let fH = if (fC)
1074+                                                let gO = if (gJ)
8601075                                                     then {
861-                                                        let fI = invoke(bn, "stake", nil, [AttachedPayment(cg, db)])
862-                                                        if ((fI == fI))
1076+                                                        let gP = invoke(bs, "stake", nil, [AttachedPayment(dn, ei)])
1077+                                                        if ((gP == gP))
8631078                                                             then nil
8641079                                                             else throw("Strict value is not equal to itself.")
8651080                                                         }
866-                                                    else [ScriptTransfer(dL.caller, db, cg)]
867-                                                let fJ = dt(0, 0, 0)
868-                                                if ((fJ == fJ))
1081+                                                    else [ScriptTransfer(eS.caller, ei, dn)]
1082+                                                let gQ = eA(0, 0, 0)
1083+                                                if ((gQ == gQ))
8691084                                                     then {
870-                                                        let dk = fJ._2
871-                                                        let fK = fJ._1
872-                                                        let fL = dx(ds, dk)
873-                                                        if ((fL == fL))
874-                                                            then ((cx ++ fH) ++ fK)
1085+                                                        let er = gQ._2
1086+                                                        let gR = gQ._1
1087+                                                        let gS = eE(ez, er)
1088+                                                        if ((gS == gS))
1089+                                                            then {
1090+                                                                let gT = invoke(this, "rebalance", nil, nil)
1091+                                                                if ((gT == gT))
1092+                                                                    then ((dE ++ gO) ++ gR)
1093+                                                                    else throw("Strict value is not equal to itself.")
1094+                                                                }
8751095                                                             else throw("Strict value is not equal to itself.")
8761096                                                         }
8771097                                                     else throw("Strict value is not equal to itself.")
8781098                                                 }
8791099                                             else throw("Strict value is not equal to itself.")
8801100                                         }
8811101                                     else throw("Strict value is not equal to itself.")
8821102                                 }
8831103                             else throw("Strict value is not equal to itself.")
8841104                         }
8851105                     else throw("Strict value is not equal to itself.")
8861106                 }
8871107             else throw("Strict value is not equal to itself.")
8881108         }
8891109 
8901110 
8911111 
892-@Callable(dL)
893-func putForFree (fM) = if ((0 > fM))
1112+@Callable(eS)
1113+func putForFree (gU) = if ((0 > gU))
8941114     then throw("Invalid value passed")
8951115     else {
896-        let dR = dO(dL, fM, false)
897-        let cx = dR._9
898-        let dP = toBigInt(value(dL.payments[0]).amount)
899-        let dQ = toBigInt(value(dL.payments[1]).amount)
900-        let ds = dl(dP, dQ, toBigInt(0))
901-        if ((ds == ds))
1116+        let eY = eV(eS, gU, false)
1117+        let dE = eY._9
1118+        let eW = toBigInt(value(eS.payments[0]).amount)
1119+        let eX = toBigInt(value(eS.payments[1]).amount)
1120+        let ez = es(eW, eX, toBigInt(0))
1121+        if ((ez == ez))
9021122             then {
903-                let fN = dt(0, 0, 0)
904-                let fK = fN._1
905-                let dk = fN._2
906-                let fL = dx(ds, dk)
907-                if ((fL == fL))
908-                    then (cx ++ fK)
1123+                let gV = eA(0, 0, 0)
1124+                let gR = gV._1
1125+                let er = gV._2
1126+                let gS = eE(ez, er)
1127+                if ((gS == gS))
1128+                    then (dE ++ gR)
9091129                     else throw("Strict value is not equal to itself.")
9101130                 }
9111131             else throw("Strict value is not equal to itself.")
9121132         }
9131133 
9141134 
9151135 
916-@Callable(dL)
917-func putOneTkn (fO,fP) = {
918-    let fQ = {
919-        let aR = invoke(aO, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
920-        if ($isInstanceOf(aR, "Boolean"))
921-            then aR
922-            else throw(($getType(aR) + " couldn't be cast to Boolean"))
1136+@Callable(eS)
1137+func putOneTkn (gW,gX) = {
1138+    let gY = {
1139+        let aW = invoke(aT, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1140+        if ($isInstanceOf(aW, "Boolean"))
1141+            then aW
1142+            else throw(($getType(aW) + " couldn't be cast to Boolean"))
9231143         }
924-    let fR = if (if (if (aT())
1144+    let gZ = if (if (if (aY())
9251145         then true
926-        else (bg == l))
1146+        else (bl == l))
9271147         then true
928-        else (bg == n))
1148+        else (bl == n))
9291149         then true
930-        else fQ
931-    let eH = [if (if (!(fR))
1150+        else gY
1151+    let fM = [if (if (!(gZ))
9321152         then true
933-        else fc(dL))
1153+        else gh(eS))
9341154         then true
935-        else aL("put operation is blocked by admin"), if ((size(dL.payments) == 1))
1155+        else aQ("put operation is blocked by admin"), if ((size(eS.payments) == 1))
9361156         then true
937-        else aL("exactly 1 payment are expected")]
938-    if ((eH == eH))
1157+        else aQ("exactly 1 payment are expected")]
1158+    if ((fM == fM))
9391159         then {
940-            let fS = dL.payments[0]
941-            let ec = fS.assetId
942-            let eb = fS.amount
943-            let ds = if ((ec == bi))
944-                then dl(toBigInt(eb), toBigInt(0), toBigInt(0))
945-                else if ((ec == bj))
946-                    then dl(toBigInt(0), toBigInt(eb), toBigInt(0))
947-                    else aL("payment asset is not supported")
948-            if ((ds == ds))
1160+            let ha = eS.payments[0]
1161+            let fh = ha.assetId
1162+            let fg = ha.amount
1163+            let ez = if ((fh == bn))
1164+                then es(toBigInt(fg), toBigInt(0), toBigInt(0))
1165+                else if ((fh == bo))
1166+                    then es(toBigInt(0), toBigInt(fg), toBigInt(0))
1167+                    else aQ("payment asset is not supported")
1168+            if ((ez == ez))
9491169                 then {
950-                    let ab = dL.caller
951-                    let ac = dL.transactionId
952-                    let fT = ea(eb, ec, ab, ac)
953-                    if ((fT == fT))
1170+                    let ab = eS.caller
1171+                    let ac = eS.transactionId
1172+                    let hb = ff(fg, fh, ab, ac)
1173+                    if ((hb == hb))
9541174                         then {
955-                            let eg = fT._5
956-                            let fU = fT._4
957-                            let dZ = fT._3
958-                            let de = fT._2
959-                            let fV = fT._1
960-                            let fW = if (if ((fO > 0))
961-                                then (fO > fV)
1175+                            let fl = hb._5
1176+                            let hc = hb._4
1177+                            let fe = hb._3
1178+                            let el = hb._2
1179+                            let hd = hb._1
1180+                            let he = if (if ((gW > 0))
1181+                                then (gW > hd)
9621182                                 else false)
963-                                then aL(makeString(["amount to receive is less than ", toString(fO)], ""))
964-                                else fV
965-                            let dU = dS(fW)
966-                            if ((dU == dU))
1183+                                then aQ(makeString(["amount to receive is less than ", toString(gW)], ""))
1184+                                else hd
1185+                            let fa = eZ(he)
1186+                            if ((fa == fa))
9671187                                 then {
968-                                    let fH = if (fP)
1188+                                    let gO = if (gX)
9691189                                         then {
970-                                            let fX = invoke(bn, "stake", nil, [AttachedPayment(bh, fW)])
971-                                            if ((fX == fX))
1190+                                            let hf = invoke(bs, "stake", nil, [AttachedPayment(bm, he)])
1191+                                            if ((hf == hf))
9721192                                                 then nil
9731193                                                 else throw("Strict value is not equal to itself.")
9741194                                             }
975-                                        else [ScriptTransfer(dL.caller, fW, bh)]
976-                                    let fY = if ((dZ > 0))
977-                                        then [ScriptTransfer(aP, dZ, ec)]
1195+                                        else [ScriptTransfer(eS.caller, he, bm)]
1196+                                    let hg = if ((fe > 0))
1197+                                        then [ScriptTransfer(aU, fe, fh)]
9781198                                         else nil
979-                                    let fZ = if ((this == aP))
1199+                                    let hh = if ((this == aU))
9801200                                         then $Tuple2(0, 0)
981-                                        else if (eg)
982-                                            then $Tuple2(-(dZ), 0)
983-                                            else $Tuple2(0, -(dZ))
984-                                    let du = fZ._1
985-                                    let dv = fZ._2
986-                                    let ga = dt(du, dv, 0)
987-                                    let fK = ga._1
988-                                    let dk = ga._2
989-                                    let dE = value(getString(aj))
990-                                    let fL = dx(ds, dk)
991-                                    if ((fL == fL))
992-                                        then $Tuple2((((de ++ fH) ++ fY) ++ fK), fW)
993-                                        else throw("Strict value is not equal to itself.")
994-                                    }
995-                                else throw("Strict value is not equal to itself.")
996-                            }
997-                        else throw("Strict value is not equal to itself.")
998-                    }
999-                else throw("Strict value is not equal to itself.")
1000-            }
1001-        else throw("Strict value is not equal to itself.")
1002-    }
1003-
1004-
1005-
1006-@Callable(dL)
1007-func putOneTknREADONLY (ec,eb) = {
1008-    let gb = ea(eb, aY(ec), unit, unit)
1009-    let fV = gb._1
1010-    let de = gb._2
1011-    let dZ = gb._3
1012-    let fU = gb._4
1013-    let eg = gb._5
1014-    $Tuple2(nil, $Tuple3(fV, dZ, fU))
1015-    }
1016-
1017-
1018-
1019-@Callable(dL)
1020-func getOneTkn (gc,fO) = {
1021-    let fQ = {
1022-        let aR = invoke(aO, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1023-        if ($isInstanceOf(aR, "Boolean"))
1024-            then aR
1025-            else throw(($getType(aR) + " couldn't be cast to Boolean"))
1026-        }
1027-    let gd = if (if (aT())
1028-        then true
1029-        else (bg == n))
1030-        then true
1031-        else fQ
1032-    let eH = [if (if (!(gd))
1033-        then true
1034-        else fc(dL))
1035-        then true
1036-        else aL("get operation is blocked by admin"), if ((size(dL.payments) == 1))
1037-        then true
1038-        else aL("exactly 1 payment are expected")]
1039-    if ((eH == eH))
1040-        then {
1041-            let eG = aY(gc)
1042-            let fS = dL.payments[0]
1043-            let ec = fS.assetId
1044-            let eo = fS.amount
1045-            let ds = dl(toBigInt(0), toBigInt(0), toBigInt(0))
1046-            if ((ds == ds))
1047-                then {
1048-                    let ab = dL.caller
1049-                    let ac = dL.transactionId
1050-                    let ge = eF(eG, eo, ec, ab, ac)
1051-                    if ((ge == ge))
1052-                        then {
1053-                            let eI = ge._5
1054-                            let fU = ge._4
1055-                            let dZ = ge._3
1056-                            let de = ge._2
1057-                            let gf = ge._1
1058-                            let dT = if (if ((fO > 0))
1059-                                then (fO > gf)
1060-                                else false)
1061-                                then aL(makeString(["amount to receive is less than ", toString(fO)], ""))
1062-                                else gf
1063-                            let gg = invoke(aO, "burn", [eo], [AttachedPayment(ec, eo)])
1064-                            if ((gg == gg))
1065-                                then {
1066-                                    let gh = [ScriptTransfer(ab, dT, eG)]
1067-                                    let fY = if ((dZ > 0))
1068-                                        then [ScriptTransfer(aP, dZ, eG)]
1069-                                        else nil
1070-                                    let gi = {
1071-                                        let gj = if ((this == aP))
1072-                                            then 0
1073-                                            else dZ
1074-                                        if (eI)
1075-                                            then $Tuple2(-((dT + gj)), 0)
1076-                                            else $Tuple2(0, -((dT + gj)))
1077-                                        }
1078-                                    let du = gi._1
1079-                                    let dv = gi._2
1080-                                    let gk = dt(du, dv, 0)
1081-                                    let fK = gk._1
1082-                                    let dk = gk._2
1083-                                    let fL = dx(ds, dk)
1084-                                    if ((fL == fL))
1085-                                        then $Tuple2((((de ++ gh) ++ fY) ++ fK), dT)
1086-                                        else throw("Strict value is not equal to itself.")
1087-                                    }
1088-                                else throw("Strict value is not equal to itself.")
1089-                            }
1090-                        else throw("Strict value is not equal to itself.")
1091-                    }
1092-                else throw("Strict value is not equal to itself.")
1093-            }
1094-        else throw("Strict value is not equal to itself.")
1095-    }
1096-
1097-
1098-
1099-@Callable(dL)
1100-func getOneTknREADONLY (eG,eo) = {
1101-    let gl = eF(aY(eG), eo, bh, unit, unit)
1102-    let gf = gl._1
1103-    let de = gl._2
1104-    let dZ = gl._3
1105-    let fU = gl._4
1106-    let eI = gl._5
1107-    $Tuple2(nil, $Tuple3(gf, dZ, fU))
1108-    }
1109-
1110-
1111-
1112-@Callable(dL)
1113-func unstakeAndGetOneTkn (gm,gc,fO) = {
1114-    let fQ = {
1115-        let aR = invoke(aO, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1116-        if ($isInstanceOf(aR, "Boolean"))
1117-            then aR
1118-            else throw(($getType(aR) + " couldn't be cast to Boolean"))
1119-        }
1120-    let gd = if (if (aT())
1121-        then true
1122-        else (bg == n))
1123-        then true
1124-        else fQ
1125-    let eH = [if (if (!(gd))
1126-        then true
1127-        else fc(dL))
1128-        then true
1129-        else aL("get operation is blocked by admin"), if ((size(dL.payments) == 0))
1130-        then true
1131-        else aL("no payments are expected")]
1132-    if ((eH == eH))
1133-        then {
1134-            let eG = aY(gc)
1135-            let ab = dL.caller
1136-            let ac = dL.transactionId
1137-            let ds = dl(toBigInt(0), toBigInt(0), toBigInt(0))
1138-            if ((ds == ds))
1139-                then {
1140-                    let gn = invoke(bn, "unstake", [toBase58String(bh), gm], nil)
1141-                    if ((gn == gn))
1142-                        then {
1143-                            let go = eF(eG, gm, bh, ab, ac)
1144-                            if ((go == go))
1145-                                then {
1146-                                    let eI = go._5
1147-                                    let fU = go._4
1148-                                    let dZ = go._3
1149-                                    let de = go._2
1150-                                    let gf = go._1
1151-                                    let dT = if (if ((fO > 0))
1152-                                        then (fO > gf)
1153-                                        else false)
1154-                                        then aL(makeString(["amount to receive is less than ", toString(fO)], ""))
1155-                                        else gf
1156-                                    let gg = invoke(aO, "burn", [gm], [AttachedPayment(bh, gm)])
1157-                                    if ((gg == gg))
1201+                                        else if (fl)
1202+                                            then $Tuple2(-(fe), 0)
1203+                                            else $Tuple2(0, -(fe))
1204+                                    let eB = hh._1
1205+                                    let eC = hh._2
1206+                                    let hi = eA(eB, eC, 0)
1207+                                    let gR = hi._1
1208+                                    let er = hi._2
1209+                                    let eL = value(getString(aj))
1210+                                    let gS = eE(ez, er)
1211+                                    if ((gS == gS))
11581212                                         then {
1159-                                            let gh = [ScriptTransfer(dL.caller, dT, eG)]
1160-                                            let fY = if ((dZ > 0))
1161-                                                then [ScriptTransfer(aP, dZ, eG)]
1162-                                                else nil
1163-                                            let gp = {
1164-                                                let gj = if ((this == aP))
1165-                                                    then 0
1166-                                                    else dZ
1167-                                                if (eI)
1168-                                                    then $Tuple2(-((dT + gj)), 0)
1169-                                                    else $Tuple2(0, -((dT + gj)))
1170-                                                }
1171-                                            let du = gp._1
1172-                                            let dv = gp._2
1173-                                            let gq = dt(du, dv, 0)
1174-                                            let fK = gq._1
1175-                                            let dk = gq._2
1176-                                            let fL = dx(ds, dk)
1177-                                            if ((fL == fL))
1178-                                                then $Tuple2((((de ++ gh) ++ fY) ++ fK), dT)
1213+                                            let gT = invoke(this, "rebalance", nil, nil)
1214+                                            if ((gT == gT))
1215+                                                then $Tuple2((((el ++ gO) ++ hg) ++ gR), he)
11791216                                                 else throw("Strict value is not equal to itself.")
11801217                                             }
11811218                                         else throw("Strict value is not equal to itself.")
11821219                                     }
11831220                                 else throw("Strict value is not equal to itself.")
11841221                             }
11851222                         else throw("Strict value is not equal to itself.")
11861223                     }
11871224                 else throw("Strict value is not equal to itself.")
11881225             }
11891226         else throw("Strict value is not equal to itself.")
11901227     }
11911228 
11921229 
11931230 
1194-@Callable(dL)
1195-func get () = {
1196-    let cP = dK(dL)
1197-    let gr = cP._1
1198-    let cw = cP._2
1199-    let dN = cP._3
1200-    let ce = cP._4
1201-    let cx = cP._5
1202-    let ds = dl(toBigInt(0), toBigInt(0), toBigInt(0))
1203-    if ((ds == ds))
1231+@Callable(eS)
1232+func putOneTknREADONLY (fh,fg) = {
1233+    let hj = ff(fg, bd(fh), unit, unit)
1234+    let hd = hj._1
1235+    let el = hj._2
1236+    let fe = hj._3
1237+    let hc = hj._4
1238+    let fl = hj._5
1239+    $Tuple2(nil, $Tuple3(hd, fe, hc))
1240+    }
1241+
1242+
1243+
1244+@Callable(eS)
1245+func getOneTkn (hk,gW) = {
1246+    let gY = {
1247+        let aW = invoke(aT, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1248+        if ($isInstanceOf(aW, "Boolean"))
1249+            then aW
1250+            else throw(($getType(aW) + " couldn't be cast to Boolean"))
1251+        }
1252+    let hl = if (if (aY())
1253+        then true
1254+        else (bl == n))
1255+        then true
1256+        else gY
1257+    let fM = [if (if (!(hl))
1258+        then true
1259+        else gh(eS))
1260+        then true
1261+        else aQ("get operation is blocked by admin"), if ((size(eS.payments) == 1))
1262+        then true
1263+        else aQ("exactly 1 payment are expected")]
1264+    if ((fM == fM))
12041265         then {
1205-            let gs = invoke(aO, "burn", [dN], [AttachedPayment(ce, dN)])
1206-            if ((gs == gs))
1266+            let fL = bd(hk)
1267+            let ha = eS.payments[0]
1268+            let fh = ha.assetId
1269+            let ft = ha.amount
1270+            let ez = es(toBigInt(0), toBigInt(0), toBigInt(0))
1271+            if ((ez == ez))
12071272                 then {
1208-                    let gt = dt(-(gr), -(cw), 0)
1209-                    let fK = gt._1
1210-                    let dk = gt._2
1211-                    let fL = dx(ds, dk)
1212-                    if ((fL == fL))
1213-                        then (cx ++ fK)
1273+                    let ab = eS.caller
1274+                    let ac = eS.transactionId
1275+                    let hm = fK(fL, ft, fh, ab, ac)
1276+                    if ((hm == hm))
1277+                        then {
1278+                            let fN = hm._5
1279+                            let hc = hm._4
1280+                            let fe = hm._3
1281+                            let el = hm._2
1282+                            let hn = hm._1
1283+                            let bW = if (if ((gW > 0))
1284+                                then (gW > hn)
1285+                                else false)
1286+                                then aQ(makeString(["amount to receive is less than ", toString(gW)], ""))
1287+                                else hn
1288+                            let ho = invoke(aT, "burn", [ft], [AttachedPayment(fh, ft)])
1289+                            if ((ho == ho))
1290+                                then {
1291+                                    let gC = cH(hk, (bW + max([0, fe])))
1292+                                    let hp = [ScriptTransfer(ab, bW, fL)]
1293+                                    let hg = if ((fe > 0))
1294+                                        then [ScriptTransfer(aU, fe, fL)]
1295+                                        else nil
1296+                                    let hq = {
1297+                                        let hr = if ((this == aU))
1298+                                            then 0
1299+                                            else fe
1300+                                        if (fN)
1301+                                            then $Tuple2(-((bW + hr)), 0)
1302+                                            else $Tuple2(0, -((bW + hr)))
1303+                                        }
1304+                                    let eB = hq._1
1305+                                    let eC = hq._2
1306+                                    let hs = eA(eB, eC, 0)
1307+                                    let gR = hs._1
1308+                                    let er = hs._2
1309+                                    let gS = eE(ez, er)
1310+                                    if ((gS == gS))
1311+                                        then $Tuple2(((((el ++ gC) ++ hp) ++ hg) ++ gR), bW)
1312+                                        else throw("Strict value is not equal to itself.")
1313+                                    }
1314+                                else throw("Strict value is not equal to itself.")
1315+                            }
12141316                         else throw("Strict value is not equal to itself.")
12151317                     }
12161318                 else throw("Strict value is not equal to itself.")
12171319             }
12181320         else throw("Strict value is not equal to itself.")
12191321     }
12201322 
12211323 
12221324 
1223-@Callable(dL)
1224-func getNoLess (gu,gv) = {
1225-    let cP = dK(dL)
1226-    let cv = cP._1
1227-    let cw = cP._2
1228-    let dN = cP._3
1229-    let ce = cP._4
1230-    let cx = cP._5
1231-    if ((gu > cv))
1232-        then throw(((("noLessThenAmtAsset failed:  " + toString(cv)) + " < ") + toString(gu)))
1233-        else if ((gv > cw))
1234-            then throw(((("noLessThenPriceAsset failed: " + toString(cw)) + " < ") + toString(gv)))
1235-            else {
1236-                let ds = dl(toBigInt(0), toBigInt(0), toBigInt(0))
1237-                if ((ds == ds))
1238-                    then {
1239-                        let gs = invoke(aO, "burn", [dN], [AttachedPayment(ce, dN)])
1240-                        if ((gs == gs))
1241-                            then {
1242-                                let gw = dt(-(cv), -(cw), 0)
1243-                                let fK = gw._1
1244-                                let dk = gw._2
1245-                                let fL = dx(ds, dk)
1246-                                if ((fL == fL))
1247-                                    then (cx ++ fK)
1248-                                    else throw("Strict value is not equal to itself.")
1249-                                }
1250-                            else throw("Strict value is not equal to itself.")
1251-                        }
1252-                    else throw("Strict value is not equal to itself.")
1253-                }
1325+@Callable(eS)
1326+func getOneTknREADONLY (fL,ft) = {
1327+    let ht = fK(bd(fL), ft, bm, unit, unit)
1328+    let hn = ht._1
1329+    let el = ht._2
1330+    let fe = ht._3
1331+    let hc = ht._4
1332+    let fN = ht._5
1333+    $Tuple2(nil, $Tuple3(hn, fe, hc))
12541334     }
12551335 
12561336 
12571337 
1258-@Callable(dL)
1259-func unstakeAndGet (dT) = {
1260-    let gx = if ((size(dL.payments) != 0))
1261-        then throw("No payments are expected")
1262-        else true
1263-    if ((gx == gx))
1338+@Callable(eS)
1339+func unstakeAndGetOneTkn (hu,hk,gW) = {
1340+    let gY = {
1341+        let aW = invoke(aT, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1342+        if ($isInstanceOf(aW, "Boolean"))
1343+            then aW
1344+            else throw(($getType(aW) + " couldn't be cast to Boolean"))
1345+        }
1346+    let hl = if (if (aY())
1347+        then true
1348+        else (bl == n))
1349+        then true
1350+        else gY
1351+    let fM = [if (if (!(hl))
1352+        then true
1353+        else gh(eS))
1354+        then true
1355+        else aQ("get operation is blocked by admin"), if ((size(eS.payments) == 0))
1356+        then true
1357+        else aQ("no payments are expected")]
1358+    if ((fM == fM))
12641359         then {
1265-            let bT = aV()
1266-            let cg = fromBase58String(bT[q])
1267-            let ds = dl(toBigInt(0), toBigInt(0), toBigInt(0))
1268-            if ((ds == ds))
1360+            let fL = bd(hk)
1361+            let ab = eS.caller
1362+            let ac = eS.transactionId
1363+            let ez = es(toBigInt(0), toBigInt(0), toBigInt(0))
1364+            if ((ez == ez))
12691365                 then {
1270-                    let gn = invoke(bn, "unstake", [toBase58String(cg), dT], nil)
1271-                    if ((gn == gn))
1366+                    let hv = invoke(bs, "unstake", [toBase58String(bm), hu], nil)
1367+                    if ((hv == hv))
12721368                         then {
1273-                            let cP = cc(toBase58String(dL.transactionId), toBase58String(cg), dT, dL.caller)
1274-                            let cv = cP._1
1275-                            let cw = cP._2
1276-                            let cj = parseIntValue(cP._9)
1277-                            let cx = cP._10
1278-                            let gy = if (if (aT())
1279-                                then true
1280-                                else (cj == n))
1281-                                then throw(("Get operation is blocked by admin. Status = " + toString(cj)))
1282-                                else true
1283-                            if ((gy == gy))
1369+                            let hw = fK(fL, hu, bm, ab, ac)
1370+                            if ((hw == hw))
12841371                                 then {
1285-                                    let gs = invoke(aO, "burn", [dT], [AttachedPayment(cg, dT)])
1286-                                    if ((gs == gs))
1372+                                    let fN = hw._5
1373+                                    let hc = hw._4
1374+                                    let fe = hw._3
1375+                                    let el = hw._2
1376+                                    let hn = hw._1
1377+                                    let bW = if (if ((gW > 0))
1378+                                        then (gW > hn)
1379+                                        else false)
1380+                                        then aQ(makeString(["amount to receive is less than ", toString(gW)], ""))
1381+                                        else hn
1382+                                    let ho = invoke(aT, "burn", [hu], [AttachedPayment(bm, hu)])
1383+                                    if ((ho == ho))
12871384                                         then {
1288-                                            let gz = dt(-(cv), -(cw), 0)
1289-                                            let fK = gz._1
1290-                                            let dk = gz._2
1291-                                            let fL = dx(ds, dk)
1292-                                            if ((fL == fL))
1293-                                                then (cx ++ fK)
1385+                                            let gC = cH(hk, (bW + max([0, fe])))
1386+                                            let hp = [ScriptTransfer(eS.caller, bW, fL)]
1387+                                            let hg = if ((fe > 0))
1388+                                                then [ScriptTransfer(aU, fe, fL)]
1389+                                                else nil
1390+                                            let hx = {
1391+                                                let hr = if ((this == aU))
1392+                                                    then 0
1393+                                                    else fe
1394+                                                if (fN)
1395+                                                    then $Tuple2(-((bW + hr)), 0)
1396+                                                    else $Tuple2(0, -((bW + hr)))
1397+                                                }
1398+                                            let eB = hx._1
1399+                                            let eC = hx._2
1400+                                            let hy = eA(eB, eC, 0)
1401+                                            let gR = hy._1
1402+                                            let er = hy._2
1403+                                            let gS = eE(ez, er)
1404+                                            if ((gS == gS))
1405+                                                then $Tuple2(((((el ++ gC) ++ hp) ++ hg) ++ gR), bW)
12941406                                                 else throw("Strict value is not equal to itself.")
12951407                                             }
12961408                                         else throw("Strict value is not equal to itself.")
12971409                                     }
12981410                                 else throw("Strict value is not equal to itself.")
12991411                             }
13001412                         else throw("Strict value is not equal to itself.")
13011413                     }
13021414                 else throw("Strict value is not equal to itself.")
13031415             }
13041416         else throw("Strict value is not equal to itself.")
13051417     }
13061418 
13071419 
13081420 
1309-@Callable(dL)
1310-func unstakeAndGetNoLess (gm,gA,gv) = {
1311-    let gd = if (aT())
1312-        then true
1313-        else (bg == n)
1314-    let eH = [if (!(gd))
1315-        then true
1316-        else throw("get operation is blocked by admin"), if ((size(dL.payments) == 0))
1317-        then true
1318-        else throw("no payments are expected")]
1319-    if ((eH == eH))
1421+@Callable(eS)
1422+func get () = {
1423+    let dW = eR(eS)
1424+    let dC = dW._1
1425+    let dD = dW._2
1426+    let eU = dW._3
1427+    let dl = dW._4
1428+    let dE = dW._5
1429+    let gC = cM(dC, dD)
1430+    let ez = es(toBigInt(0), toBigInt(0), toBigInt(0))
1431+    if ((ez == ez))
13201432         then {
1321-            let ds = dl(toBigInt(0), toBigInt(0), toBigInt(0))
1322-            if ((ds == ds))
1433+            let hz = invoke(aT, "burn", [eU], [AttachedPayment(dl, eU)])
1434+            if ((hz == hz))
13231435                 then {
1324-                    let gn = invoke(bn, "unstake", [toBase58String(bh), gm], nil)
1325-                    if ((gn == gn))
1436+                    let hA = eA(-(dC), -(dD), 0)
1437+                    let gR = hA._1
1438+                    let er = hA._2
1439+                    let gS = eE(ez, er)
1440+                    if ((gS == gS))
1441+                        then ((gC ++ dE) ++ gR)
1442+                        else throw("Strict value is not equal to itself.")
1443+                    }
1444+                else throw("Strict value is not equal to itself.")
1445+            }
1446+        else throw("Strict value is not equal to itself.")
1447+    }
1448+
1449+
1450+
1451+@Callable(eS)
1452+func getNoLess (hB,hC) = {
1453+    let dW = eR(eS)
1454+    let dC = dW._1
1455+    let dD = dW._2
1456+    let eU = dW._3
1457+    let dl = dW._4
1458+    let dE = dW._5
1459+    if ((hB > dC))
1460+        then throw(((("noLessThenAmtAsset failed:  " + toString(dC)) + " < ") + toString(hB)))
1461+        else if ((hC > dD))
1462+            then throw(((("noLessThenPriceAsset failed: " + toString(dD)) + " < ") + toString(hC)))
1463+            else {
1464+                let gC = cM(dC, dD)
1465+                let ez = es(toBigInt(0), toBigInt(0), toBigInt(0))
1466+                if ((ez == ez))
1467+                    then {
1468+                        let hz = invoke(aT, "burn", [eU], [AttachedPayment(dl, eU)])
1469+                        if ((hz == hz))
1470+                            then {
1471+                                let hD = eA(-(dC), -(dD), 0)
1472+                                let gR = hD._1
1473+                                let er = hD._2
1474+                                let gS = eE(ez, er)
1475+                                if ((gS == gS))
1476+                                    then ((gC ++ dE) ++ gR)
1477+                                    else throw("Strict value is not equal to itself.")
1478+                                }
1479+                            else throw("Strict value is not equal to itself.")
1480+                        }
1481+                    else throw("Strict value is not equal to itself.")
1482+                }
1483+    }
1484+
1485+
1486+
1487+@Callable(eS)
1488+func unstakeAndGet (bW) = {
1489+    let hE = if ((size(eS.payments) != 0))
1490+        then throw("No payments are expected")
1491+        else true
1492+    if ((hE == hE))
1493+        then {
1494+            let da = ba()
1495+            let dn = fromBase58String(da[q])
1496+            let ez = es(toBigInt(0), toBigInt(0), toBigInt(0))
1497+            if ((ez == ez))
1498+                then {
1499+                    let hv = invoke(bs, "unstake", [toBase58String(dn), bW], nil)
1500+                    if ((hv == hv))
13261501                         then {
1327-                            let cP = cc(toBase58String(dL.transactionId), toBase58String(bh), gm, dL.caller)
1328-                            let cv = cP._1
1329-                            let cw = cP._2
1330-                            let cx = cP._10
1331-                            let gB = [if ((cv >= gA))
1502+                            let dW = dj(toBase58String(eS.transactionId), toBase58String(dn), bW, eS.caller)
1503+                            let dC = dW._1
1504+                            let dD = dW._2
1505+                            let dq = parseIntValue(dW._9)
1506+                            let dE = dW._10
1507+                            let gC = cM(dC, dD)
1508+                            let hF = if (if (aY())
13321509                                 then true
1333-                                else throw(makeString(["amount asset amount to receive is less than ", toString(gA)], "")), if ((cw >= gv))
1334-                                then true
1335-                                else throw(makeString(["price asset amount to receive is less than ", toString(gv)], ""))]
1336-                            if ((gB == gB))
1510+                                else (dq == n))
1511+                                then throw(("Get operation is blocked by admin. Status = " + toString(dq)))
1512+                                else true
1513+                            if ((hF == hF))
13371514                                 then {
1338-                                    let gs = invoke(aO, "burn", [gm], [AttachedPayment(bh, gm)])
1339-                                    if ((gs == gs))
1515+                                    let hz = invoke(aT, "burn", [bW], [AttachedPayment(dn, bW)])
1516+                                    if ((hz == hz))
13401517                                         then {
1341-                                            let gC = dt(-(cv), -(cw), 0)
1342-                                            let fK = gC._1
1343-                                            let dk = gC._2
1344-                                            let fL = dx(ds, dk)
1345-                                            if ((fL == fL))
1346-                                                then (cx ++ fK)
1518+                                            let hG = eA(-(dC), -(dD), 0)
1519+                                            let gR = hG._1
1520+                                            let er = hG._2
1521+                                            let gS = eE(ez, er)
1522+                                            if ((gS == gS))
1523+                                                then ((gC ++ dE) ++ gR)
13471524                                                 else throw("Strict value is not equal to itself.")
13481525                                             }
13491526                                         else throw("Strict value is not equal to itself.")
13501527                                     }
13511528                                 else throw("Strict value is not equal to itself.")
13521529                             }
13531530                         else throw("Strict value is not equal to itself.")
13541531                     }
13551532                 else throw("Strict value is not equal to itself.")
13561533             }
13571534         else throw("Strict value is not equal to itself.")
13581535     }
13591536 
13601537 
13611538 
1362-@Callable(dL)
1363-func activate (gD,gE) = if ((toString(dL.caller) != toString(aO)))
1364-    then throw("permissions denied")
1365-    else $Tuple2([StringEntry(ae(), gD), StringEntry(af(), gE)], "success")
1366-
1367-
1368-
1369-@Callable(dL)
1370-func refreshKLp () = {
1371-    let gF = valueOrElse(getInteger(ak), 0)
1372-    let gG = if (((height - gF) >= an))
1373-        then unit
1374-        else aL(makeString([toString(an), " blocks have not passed since the previous call"], ""))
1375-    if ((gG == gG))
1539+@Callable(eS)
1540+func unstakeAndGetNoLess (hu,hH,hC) = {
1541+    let hl = if (aY())
1542+        then true
1543+        else (bl == n)
1544+    let fM = [if (!(hl))
1545+        then true
1546+        else throw("get operation is blocked by admin"), if ((size(eS.payments) == 0))
1547+        then true
1548+        else throw("no payments are expected")]
1549+    if ((fM == fM))
13761550         then {
1377-            let dE = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, aj), "0")), aN("invalid kLp"))
1378-            let gH = dt(0, 0, 0)
1379-            let gI = gH._1
1380-            let dk = gH._2
1381-            let dw = if ((dE != dk))
1382-                then gI
1383-                else aL("nothing to refresh")
1384-            $Tuple2(dw, toString(dk))
1551+            let ez = es(toBigInt(0), toBigInt(0), toBigInt(0))
1552+            if ((ez == ez))
1553+                then {
1554+                    let hv = invoke(bs, "unstake", [toBase58String(bm), hu], nil)
1555+                    if ((hv == hv))
1556+                        then {
1557+                            let dW = dj(toBase58String(eS.transactionId), toBase58String(bm), hu, eS.caller)
1558+                            let dC = dW._1
1559+                            let dD = dW._2
1560+                            let dE = dW._10
1561+                            let gC = cM(dC, dD)
1562+                            let hI = [if ((dC >= hH))
1563+                                then true
1564+                                else throw(makeString(["amount asset amount to receive is less than ", toString(hH)], "")), if ((dD >= hC))
1565+                                then true
1566+                                else throw(makeString(["price asset amount to receive is less than ", toString(hC)], ""))]
1567+                            if ((hI == hI))
1568+                                then {
1569+                                    let hz = invoke(aT, "burn", [hu], [AttachedPayment(bm, hu)])
1570+                                    if ((hz == hz))
1571+                                        then {
1572+                                            let hJ = eA(-(dC), -(dD), 0)
1573+                                            let gR = hJ._1
1574+                                            let er = hJ._2
1575+                                            let gS = eE(ez, er)
1576+                                            if ((gS == gS))
1577+                                                then ((gC ++ dE) ++ gR)
1578+                                                else throw("Strict value is not equal to itself.")
1579+                                            }
1580+                                        else throw("Strict value is not equal to itself.")
1581+                                    }
1582+                                else throw("Strict value is not equal to itself.")
1583+                            }
1584+                        else throw("Strict value is not equal to itself.")
1585+                    }
1586+                else throw("Strict value is not equal to itself.")
13851587             }
13861588         else throw("Strict value is not equal to itself.")
13871589     }
13881590 
13891591 
13901592 
1391-@Callable(dL)
1392-func getPoolConfigWrapperREADONLY () = $Tuple2(nil, aV())
1593+@Callable(eS)
1594+func activate (hK,hL) = if ((toString(eS.caller) != toString(aT)))
1595+    then throw("permissions denied")
1596+    else $Tuple2([StringEntry(ae(), hK), StringEntry(af(), hL)], "success")
13931597 
13941598 
13951599 
1396-@Callable(dL)
1397-func getAccBalanceWrapperREADONLY (bF) = $Tuple2(nil, bE(bF))
1398-
1399-
1400-
1401-@Callable(dL)
1402-func calcPricesWrapperREADONLY (bN,bO,bS) = {
1403-    let cb = bR(bN, bO, bS)
1404-    $Tuple2(nil, [toString(cb[0]), toString(cb[1]), toString(cb[2])])
1600+@Callable(eS)
1601+func refreshKLp () = {
1602+    let hM = valueOrElse(getInteger(ak), 0)
1603+    let hN = if (((height - hM) >= an))
1604+        then unit
1605+        else aQ(makeString([toString(an), " blocks have not passed since the previous call"], ""))
1606+    if ((hN == hN))
1607+        then {
1608+            let eL = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, aj), "0")), aS("invalid kLp"))
1609+            let hO = eA(0, 0, 0)
1610+            let hP = hO._1
1611+            let er = hO._2
1612+            let eD = if ((eL != er))
1613+                then hP
1614+                else aQ("nothing to refresh")
1615+            $Tuple2(eD, toString(er))
1616+            }
1617+        else throw("Strict value is not equal to itself.")
14051618     }
14061619 
14071620 
14081621 
1409-@Callable(dL)
1622+@Callable(eS)
1623+func getPoolConfigWrapperREADONLY () = $Tuple2(nil, ba())
1624+
1625+
1626+
1627+@Callable(eS)
1628+func getAccBalanceWrapperREADONLY (ap) = $Tuple2(nil, bJ(ap))
1629+
1630+
1631+
1632+@Callable(eS)
1633+func calcPricesWrapperREADONLY (cU,cV,cZ) = {
1634+    let di = cY(cU, cV, cZ)
1635+    $Tuple2(nil, [toString(di[0]), toString(di[1]), toString(di[2])])
1636+    }
1637+
1638+
1639+
1640+@Callable(eS)
14101641 func toX18WrapperREADONLY (E,F) = $Tuple2(nil, toString(D(E, F)))
14111642 
14121643 
14131644 
1414-@Callable(dL)
1645+@Callable(eS)
14151646 func fromX18WrapperREADONLY (I,J) = $Tuple2(nil, H(parseBigIntValue(I), J))
14161647 
14171648 
14181649 
1419-@Callable(dL)
1420-func calcPriceBigIntWrapperREADONLY (bH,bI) = $Tuple2(nil, toString(bG(parseBigIntValue(bH), parseBigIntValue(bI))))
1650+@Callable(eS)
1651+func calcPriceBigIntWrapperREADONLY (bN,bO) = $Tuple2(nil, toString(bM(parseBigIntValue(bN), parseBigIntValue(bO))))
14211652 
14221653 
14231654 
1424-@Callable(dL)
1425-func estimatePutOperationWrapperREADONLY (cd,cz,cA,cB,cC,cD,ab,cE,cF) = $Tuple2(nil, cy(cd, cz, cA, cB, cC, cD, ab, cE, cF))
1655+@Callable(eS)
1656+func estimatePutOperationWrapperREADONLY (dk,dG,dH,dI,dJ,dK,ab,dL,dM) = $Tuple2(nil, dF(dk, dG, dH, dI, dJ, dK, ab, dL, dM))
14261657 
14271658 
14281659 
1429-@Callable(dL)
1430-func estimateGetOperationWrapperREADONLY (cd,ce,cf,ab) = {
1431-    let cP = cc(cd, ce, cf, addressFromStringValue(ab))
1432-    $Tuple2(nil, $Tuple10(cP._1, cP._2, cP._3, cP._4, cP._5, cP._6, cP._7, toString(cP._8), cP._9, cP._10))
1660+@Callable(eS)
1661+func estimateGetOperationWrapperREADONLY (dk,dl,dm,ab) = {
1662+    let dW = dj(dk, dl, dm, addressFromStringValue(ab))
1663+    $Tuple2(nil, $Tuple10(dW._1, dW._2, dW._3, dW._4, dW._5, dW._6, dW._7, toString(dW._8), dW._9, dW._10))
14331664     }
14341665 
14351666 
14361667 
1437-@Callable(dL)
1668+@Callable(eS)
14381669 func statsREADONLY () = {
1439-    let bT = aV()
1440-    let cg = fromBase58String(bT[q])
1441-    let gJ = bT[r]
1442-    let gK = bT[s]
1443-    let cI = bT[v]
1444-    let cJ = bT[w]
1445-    let bU = parseIntValue(bT[t])
1446-    let bV = parseIntValue(bT[u])
1447-    let gL = valueOrErrorMessage(assetInfo(cg), (("Asset " + toBase58String(cg)) + " doesn't exist")).quantity
1448-    let gM = bE(gJ)
1449-    let gN = bE(gK)
1450-    let gO = if ((gL == 0))
1670+    let da = ba()
1671+    let dn = fromBase58String(da[q])
1672+    let hQ = da[r]
1673+    let hR = da[s]
1674+    let dP = da[v]
1675+    let dQ = da[w]
1676+    let db = parseIntValue(da[t])
1677+    let dc = parseIntValue(da[u])
1678+    let hS = valueOrErrorMessage(assetInfo(dn), (("Asset " + toBase58String(dn)) + " doesn't exist")).quantity
1679+    let hT = bJ(hQ)
1680+    let hU = bJ(hR)
1681+    let hV = if ((hS == 0))
14511682         then [e, e, e]
1452-        else bR(gM, gN, gL)
1453-    let cq = 0
1454-    let gP = H(gO[1], b)
1455-    let gQ = H(gO[2], b)
1456-    let gR = value(getInteger(aO, ay(toString(this))))
1457-    $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(gM), toString(gN), toString(gL), toString(cq), toString(gP), toString(gQ), toString(gR)], j))
1683+        else cY(hT, hU, hS)
1684+    let dx = 0
1685+    let hW = H(hV[1], b)
1686+    let hX = H(hV[2], b)
1687+    let hY = value(getInteger(aT, aD(toString(this))))
1688+    $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(hT), toString(hU), toString(hS), toString(dx), toString(hW), toString(hX), toString(hY)], j))
14581689     }
14591690 
14601691 
14611692 
1462-@Callable(dL)
1463-func evaluatePutByAmountAssetREADONLY (cA) = {
1464-    let bT = aV()
1465-    let cg = fromBase58String(bT[q])
1466-    let cG = bT[r]
1467-    let ch = fromBase58String(cG)
1468-    let cH = bT[s]
1469-    let ci = fromBase58String(cH)
1470-    let bU = parseIntValue(bT[t])
1471-    let bV = parseIntValue(bT[u])
1472-    let cj = bT[p]
1473-    let gL = valueOrErrorMessage(assetInfo(cg), (("Asset " + toBase58String(cg)) + " doesn't exist")).quantity
1474-    let gM = bE(cG)
1475-    let gN = bE(cH)
1476-    let bP = D(gM, bU)
1477-    let bQ = D(gN, bV)
1478-    let cp = if ((gL == 0))
1693+@Callable(eS)
1694+func evaluatePutByAmountAssetREADONLY (dH) = {
1695+    let da = ba()
1696+    let dn = fromBase58String(da[q])
1697+    let dN = da[r]
1698+    let do = fromBase58String(dN)
1699+    let dO = da[s]
1700+    let dp = fromBase58String(dO)
1701+    let db = parseIntValue(da[t])
1702+    let dc = parseIntValue(da[u])
1703+    let dq = da[p]
1704+    let hS = valueOrErrorMessage(assetInfo(dn), (("Asset " + toBase58String(dn)) + " doesn't exist")).quantity
1705+    let hT = bJ(dN)
1706+    let hU = bJ(dO)
1707+    let cW = D(hT, db)
1708+    let cX = D(hU, dc)
1709+    let dw = if ((hS == 0))
14791710         then e
1480-        else bG(bQ, bP)
1481-    let cM = D(cA, bU)
1482-    let cN = fraction(cM, cp, d)
1483-    let cC = H(cN, bV)
1484-    let dR = cy("", 500000, cA, ch, cC, ci, "", true, false)
1485-    let cX = dR._1
1486-    let gS = dR._3
1487-    let cl = dR._4
1488-    let cn = dR._5
1489-    let ck = dR._6
1490-    $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(cX), toString(H(cp, b)), toString(cl), toString(cn), toString(ck), cj, toString(cA), toString(cC)], j))
1711+        else bM(cX, cW)
1712+    let dT = D(dH, db)
1713+    let dU = fraction(dT, dw, d)
1714+    let dJ = H(dU, dc)
1715+    let eY = dF("", 500000, dH, do, dJ, dp, "", true, false)
1716+    let ee = eY._1
1717+    let hZ = eY._3
1718+    let ds = eY._4
1719+    let du = eY._5
1720+    let dr = eY._6
1721+    $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(ee), toString(H(dw, b)), toString(ds), toString(du), toString(dr), dq, toString(dH), toString(dJ)], j))
14911722     }
14921723 
14931724 
14941725 
1495-@Callable(dL)
1496-func evaluatePutByPriceAssetREADONLY (cC) = {
1497-    let bT = aV()
1498-    let cg = fromBase58String(bT[q])
1499-    let cG = bT[r]
1500-    let ch = fromBase58String(cG)
1501-    let cH = bT[s]
1502-    let ci = fromBase58String(cH)
1503-    let bU = parseIntValue(bT[t])
1504-    let bV = parseIntValue(bT[u])
1505-    let cj = bT[p]
1506-    let gL = valueOrErrorMessage(assetInfo(cg), (("Asset " + toBase58String(cg)) + " doesn't exist")).quantity
1507-    let gT = bE(cG)
1508-    let gU = bE(cH)
1509-    let gV = D(gT, bU)
1510-    let gW = D(gU, bV)
1511-    let cp = if ((gL == 0))
1726+@Callable(eS)
1727+func evaluatePutByPriceAssetREADONLY (dJ) = {
1728+    let da = ba()
1729+    let dn = fromBase58String(da[q])
1730+    let dN = da[r]
1731+    let do = fromBase58String(dN)
1732+    let dO = da[s]
1733+    let dp = fromBase58String(dO)
1734+    let db = parseIntValue(da[t])
1735+    let dc = parseIntValue(da[u])
1736+    let dq = da[p]
1737+    let hS = valueOrErrorMessage(assetInfo(dn), (("Asset " + toBase58String(dn)) + " doesn't exist")).quantity
1738+    let ia = bJ(dN)
1739+    let ib = bJ(dO)
1740+    let ic = D(ia, db)
1741+    let id = D(ib, dc)
1742+    let dw = if ((hS == 0))
15121743         then e
1513-        else bG(gW, gV)
1514-    let cN = D(cC, bV)
1515-    let cM = fraction(cN, d, cp)
1516-    let cA = H(cM, bU)
1517-    let dR = cy("", 500000, cA, ch, cC, ci, "", true, false)
1518-    let cX = dR._1
1519-    let gS = dR._3
1520-    let cl = dR._4
1521-    let cn = dR._5
1522-    let ck = dR._6
1523-    $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(cX), toString(H(cp, b)), toString(cl), toString(cn), toString(ck), cj, toString(cA), toString(cC)], j))
1744+        else bM(id, ic)
1745+    let dU = D(dJ, dc)
1746+    let dT = fraction(dU, d, dw)
1747+    let dH = H(dT, db)
1748+    let eY = dF("", 500000, dH, do, dJ, dp, "", true, false)
1749+    let ee = eY._1
1750+    let hZ = eY._3
1751+    let ds = eY._4
1752+    let du = eY._5
1753+    let dr = eY._6
1754+    $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(ee), toString(H(dw, b)), toString(ds), toString(du), toString(dr), dq, toString(dH), toString(dJ)], j))
15241755     }
15251756 
15261757 
15271758 
1528-@Callable(dL)
1529-func evaluateGetREADONLY (gX,gY) = {
1530-    let cP = cc("", gX, gY, this)
1531-    let cv = cP._1
1532-    let cw = cP._2
1533-    let cl = cP._5
1534-    let cn = cP._6
1535-    let ck = cP._7
1536-    let cq = cP._8
1537-    let cj = parseIntValue(cP._9)
1538-    $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(cv), toString(cw), toString(cl), toString(cn), toString(ck), toString(cq), toString(cj)], j))
1759+@Callable(eS)
1760+func evaluateGetREADONLY (ie,if) = {
1761+    let dW = dj("", ie, if, this)
1762+    let dC = dW._1
1763+    let dD = dW._2
1764+    let ds = dW._5
1765+    let du = dW._6
1766+    let dr = dW._7
1767+    let dx = dW._8
1768+    let dq = parseIntValue(dW._9)
1769+    $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(dC), toString(dD), toString(ds), toString(du), toString(dr), toString(dx), toString(dq)], j))
15391770     }
15401771 
15411772 
1542-@Verifier(gZ)
1543-func ha () = {
1544-    let hb = {
1545-        let dW = eZ()
1546-        if ($isInstanceOf(dW, "ByteVector"))
1773+@Verifier(ig)
1774+func ih () = {
1775+    let ii = {
1776+        let bT = ge()
1777+        if ($isInstanceOf(bT, "ByteVector"))
15471778             then {
1548-                let fd = dW
1549-                fd
1779+                let gi = bT
1780+                gi
15501781                 }
1551-            else if ($isInstanceOf(dW, "Unit"))
1552-                then gZ.senderPublicKey
1782+            else if ($isInstanceOf(bT, "Unit"))
1783+                then ig.senderPublicKey
15531784                 else throw("Match error")
15541785         }
1555-    let dW = gZ
1556-    if ($isInstanceOf(dW, "Order"))
1786+    let bT = ig
1787+    if ($isInstanceOf(bT, "Order"))
15571788         then {
1558-            let dA = dW
1559-            let hc = aU()
1560-            let hd = dz(dA)
1561-            let aD = hd._1
1562-            let aE = hd._2
1563-            let aF = sigVerify(dA.bodyBytes, dA.proofs[0], dA.senderPublicKey)
1564-            let aG = sigVerify(dA.bodyBytes, dA.proofs[1], hc)
1565-            if (if (if (aD)
1566-                then aF
1789+            let eH = bT
1790+            let ij = aZ()
1791+            let ik = eG(eH)
1792+            let aI = ik._1
1793+            let aJ = ik._2
1794+            let aK = sigVerify(eH.bodyBytes, eH.proofs[0], eH.senderPublicKey)
1795+            let aL = sigVerify(eH.bodyBytes, eH.proofs[1], ij)
1796+            if (if (if (aI)
1797+                then aK
15671798                 else false)
1568-                then aG
1799+                then aL
15691800                 else false)
15701801                 then true
1571-                else aC(aD, aE, aF, aG)
1802+                else aH(aI, aJ, aK, aL)
15721803             }
1573-        else if ($isInstanceOf(dW, "SetScriptTransaction"))
1804+        else if ($isInstanceOf(bT, "SetScriptTransaction"))
15741805             then {
1575-                let fa = dW
1576-                if (sigVerify(gZ.bodyBytes, gZ.proofs[0], hb))
1806+                let gf = bT
1807+                if (sigVerify(ig.bodyBytes, ig.proofs[0], ii))
15771808                     then true
15781809                     else {
1579-                        let he = blake2b256(value(fa.script))
1580-                        let hf = fromBase64String(value(getString(aO, aA())))
1581-                        let hg = scriptHash(this)
1582-                        if ((hf == he))
1583-                            then (hg != he)
1810+                        let il = blake2b256(value(gf.script))
1811+                        let im = fromBase64String(value(getString(aT, aF())))
1812+                        let in = scriptHash(this)
1813+                        if ((im == il))
1814+                            then (in != il)
15841815                             else false
15851816                         }
15861817                 }
1587-            else sigVerify(gZ.bodyBytes, gZ.proofs[0], hb)
1818+            else sigVerify(ig.bodyBytes, ig.proofs[0], ii)
15881819     }
15891820 
github/deemru/w8io/3ef1775 
351.24 ms ◑