tx · DbnRp5mQ4DLyhEMtNd2q6k11V95sNLWEiciDpiE8z6gp

3PMK5WbkFpGzQywPtoxxJwD3nYLKdecKGCQ:  -0.05400000 Waves

2024.04.23 15:34 [4141406] smart account 3PMK5WbkFpGzQywPtoxxJwD3nYLKdecKGCQ > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "DbnRp5mQ4DLyhEMtNd2q6k11V95sNLWEiciDpiE8z6gp",
    "fee": 5400000,
    "feeAssetId": null,
    "timestamp": 1713875671975,
    "version": 2,
    "chainId": 87,
    "sender": "3PMK5WbkFpGzQywPtoxxJwD3nYLKdecKGCQ",
    "senderPublicKey": "CgvNUXr8UnWfiAgC7t3BYPJEqQjAbSNaMyUbiUwtteh4",
    "proofs": [
        "2dVsANd1VFtafbW31kBBumiEidS8HQ74t2wXJLrzVqw1G31HyR8299hQt9mEatZLug9AxXESeUKczzJHoTfQtyJi"
    ],
    "script": "base64:BgJbCAISCAoGCAgICAgBEgASABIDCgEEEgMKAQQSABIDCgEIEgMKAQESABIDCgEIEgQKAggBEgUKAwgIARIDCgEIEgMKAQESBwoFCAgIAQESABIDCgEIEgUKAwgICFMAB1ZFUlNJT04CDVBaLTEuMi4zIFBST0QACWNvbmZpZ1N0cgkBC3ZhbHVlT3JFbHNlAgkAnQgCBQR0aGlzAg1jb25maWdBZGRyZXNzAiMzUFBFQlJnNHMyYWYyclEyWmJMdmR1MUhmZDRWbzZRVkRUbwAOQ09ORklHX0FERFJFU1MDCQAAAgUJY29uZmlnU3RyAgAFBHRoaXMJAQdBZGRyZXNzAQkA2QQBBQljb25maWdTdHIAFUFzc2V0c1dlaWdodHNEZWNpbWFscwAEAAVTY2FsZQCQTgAGU2NhbGU4AIDC1y8AB1NjYWxlMTYAgICE/qbe4REACEZlZVNjYWxlAJBOABFQb29sVG9rZW5EZWNpbWFscwAIAA5Qb29sVG9rZW5TY2FsZQkAbAYACgAABRFQb29sVG9rZW5EZWNpbWFscwAAAAAFBkhBTEZVUAAQTUlOX1NURVBTX0FNT1VOVAkBC3ZhbHVlT3JFbHNlAgkAmggCBQ5DT05GSUdfQUREUkVTUwIQbWluX3N0ZXBzX2Ftb3VudAABABBNQVhfU1RFUFNfQU1PVU5UCQELdmFsdWVPckVsc2UCCQCaCAIFDkNPTkZJR19BRERSRVNTAhBtYXhfc3RlcHNfYW1vdW50APQDABJNSU5fU1RFUFNfSU5URVJWQUwJAQt2YWx1ZU9yRWxzZQIJAJoIAgUOQ09ORklHX0FERFJFU1MCEm1pbl9zdGVwc19pbnRlcnZhbAABABJNQVhfU1RFUFNfSU5URVJWQUwJAQt2YWx1ZU9yRWxzZQIJAJoIAgUOQ09ORklHX0FERFJFU1MCEm1heF9zdGVwc19pbnRlcnZhbACQTgAKTUlOX1dFSUdIVAkBC3ZhbHVlT3JFbHNlAgkAmggCBQ5DT05GSUdfQUREUkVTUwIKbWluX3dlaWdodABkAApNQVhfV0VJR0hUCQELdmFsdWVPckVsc2UCCQCaCAIFDkNPTkZJR19BRERSRVNTAgptYXhfd2VpZ2h0AKxNAQ10cnlHZXRJbnRlZ2VyAQNrZXkEByRtYXRjaDAJAJoIAgUEdGhpcwUDa2V5AwkAAQIFByRtYXRjaDACA0ludAQBYgUHJG1hdGNoMAUBYgAAAQx0cnlHZXRCaW5hcnkBA2tleQQHJG1hdGNoMAkAnAgCBQR0aGlzBQNrZXkDCQABAgUHJG1hdGNoMAIKQnl0ZVZlY3RvcgQBYgUHJG1hdGNoMAUBYgEAAQx0cnlHZXRTdHJpbmcBA2tleQQHJG1hdGNoMAkAnQgCBQR0aGlzBQNrZXkDCQABAgUHJG1hdGNoMAIGU3RyaW5nBAFiBQckbWF0Y2gwBQFiAgABE3RyeUdldFN0cmluZ09yVGhyb3cBA2tleQQHJG1hdGNoMAkAnQgCBQR0aGlzBQNrZXkDCQABAgUHJG1hdGNoMAIGU3RyaW5nBAFiBQckbWF0Y2gwBQFiCQACAQkArAICAh1ubyBzdWNoIGtleSBpbiBkYXRhIHN0b3JhZ2U6IAUDa2V5AQ5nZXRBc3NldFN0cmluZwEHYXNzZXRJZAQHJG1hdGNoMAUHYXNzZXRJZAMJAAECBQckbWF0Y2gwAgpCeXRlVmVjdG9yBAFiBQckbWF0Y2gwCQDYBAEFAWICBVdBVkVTAQ1nZXRBc3NldEJ5dGVzAQphc3NldElkU3RyAwkAAAIFCmFzc2V0SWRTdHICBVdBVkVTBQR1bml0CQDZBAEFCmFzc2V0SWRTdHIBD2dldFRva2VuQmFsYW5jZQEHYXNzZXRJZAQHJG1hdGNoMAUHYXNzZXRJZAMJAAECBQckbWF0Y2gwAgpCeXRlVmVjdG9yBAF0BQckbWF0Y2gwCQDwBwIFBHRoaXMFAXQICQDvBwEFBHRoaXMJYXZhaWxhYmxlARNhZGRBc3NldEJ5dGVzVG9MaXN0AgVhY2N1bQRpdGVtCQDOCAIFBWFjY3VtCQDMCAIJAQ1nZXRBc3NldEJ5dGVzAQUEaXRlbQUDbmlsARRhZGRBc3NldFdlaWdodFRvTGlzdAIFYWNjdW0EaXRlbQkAzggCBQVhY2N1bQkAzAgCCQENdHJ5R2V0SW50ZWdlcgEJAKwCAgkArAICAgdzdGF0aWNfCQEOZ2V0QXNzZXRTdHJpbmcBBQRpdGVtAgdfd2VpZ2h0BQNuaWwBF2FkZEFzc2V0V2VpZ2h0VG9TdHJMaXN0AgVhY2N1bQRpdGVtCQDOCAIFBWFjY3VtCQDMCAIJAKQDAQkBDXRyeUdldEludGVnZXIBCQCsAgIJAKwCAgIHc3RhdGljXwUEaXRlbQIHX3dlaWdodAUDbmlsARZhZGRBc3NldERlY2ltYWxzVG9MaXN0AgVhY2N1bQRpdGVtCQDOCAIFBWFjY3VtCQDMCAIJAQ10cnlHZXRJbnRlZ2VyAQkArAICCQCsAgICB3N0YXRpY18JAQ5nZXRBc3NldFN0cmluZwEFBGl0ZW0CCV9kZWNpbWFscwUDbmlsARNhZGRBc3NldFNjYWxlVG9MaXN0AgVhY2N1bQRpdGVtCQDOCAIFBWFjY3VtCQDMCAIJAQ10cnlHZXRJbnRlZ2VyAQkArAICCQCsAgICB3N0YXRpY18JAQ5nZXRBc3NldFN0cmluZwEFBGl0ZW0CBl9zY2FsZQUDbmlsAQxhZGRJbnRUb0xpc3QCBWFjY3VtBGl0ZW0JAM4IAgUFYWNjdW0JAMwIAgkBDXBhcnNlSW50VmFsdWUBBQRpdGVtBQNuaWwADnVzZG5Bc3NldElkU3RyCQELdmFsdWVPckVsc2UCCQCdCAIFDkNPTkZJR19BRERSRVNTAg51c2RuQXNzZXRJZFN0cgIsREcyeEZrUGREd0tVb0JrekdBaFF0THBTR3pmWExpQ1lQRXplS0gyQWQyNHAAEHB1enpsZUFzc2V0SWRTdHIJAQt2YWx1ZU9yRWxzZQIJAJ0IAgUOQ09ORklHX0FERFJFU1MCEHB1enpsZUFzc2V0SWRTdHICLEhFQjhRYXc5eHJXcFdzOHRIc2lBVFlHQldEQnRQMlM3a2NQQUxyTXU0M0FTAA51c2R0QXNzZXRJZFN0cgkBC3ZhbHVlT3JFbHNlAgkAnQgCBQ5DT05GSUdfQUREUkVTUwIOdXNkdEFzc2V0SWRTdHICLDM0TjlZY0VFVExXbjkzcVlRNjRFc1AxeDg5dFNydUpVNDRSckVNU1hYRVBKABF1c2R0UHB0QXNzZXRJZFN0cgkBC3ZhbHVlT3JFbHNlAgkAnQgCBQ5DT05GSUdfQUREUkVTUwIRdXNkdFBwdEFzc2V0SWRTdHICLDl3YzNMWE5BNFRFQnNYeUt0b0xFOW1yYkREN1dNSFh2WHJDalp2YWJMQXNpAA5yb21lQXNzZXRJZFN0cgkBC3ZhbHVlT3JFbHNlAgkAnQgCBQ5DT05GSUdfQUREUkVTUwIOcm9tZUFzc2V0SWRTdHICLEFQNENiNXhMWUdINlppZ0hyZUNaSG9YcFFUV0RrUHNHMkJIcWZEVXg2dGFKAA93YXZlc0Fzc2V0SWRTdHICBVdBVkVTAAt1c2RuQXNzZXRJZAkA2QQBBQ51c2RuQXNzZXRJZFN0cgANcHV6emxlQXNzZXRJZAkA2QQBBRBwdXp6bGVBc3NldElkU3RyAAt1c2R0QXNzZXRJZAkA2QQBBQ51c2R0QXNzZXRJZFN0cgAOdXNkdFBwdEFzc2V0SWQJANkEAQURdXNkdFBwdEFzc2V0SWRTdHIAC3JvbWVBc3NldElkCQDZBAEFDnJvbWVBc3NldElkU3RyAAx3YXZlc0Fzc2V0SWQFBHVuaXQAFXN1cHBvcnRlZEZlZUFzc2V0c1N0cgkAzAgCBQ51c2RuQXNzZXRJZFN0cgkAzAgCBRBwdXp6bGVBc3NldElkU3RyCQDMCAIFDnVzZHRBc3NldElkU3RyCQDMCAIFEXVzZHRQcHRBc3NldElkU3RyCQDMCAIFD3dhdmVzQXNzZXRJZFN0cgkAzAgCBQ5yb21lQXNzZXRJZFN0cgUDbmlsABFwYXJlbnRQb29sQWRkcmVzcwkBB0FkZHJlc3MBCQDZBAEJAQt2YWx1ZU9yRWxzZQIJAJ0IAgUOQ09ORklHX0FERFJFU1MCEXBhcmVudFBvb2xBZGRyZXNzAiMzUEZEZ3p1MVV0c3dBa0NNeHFxUWpiVGVIYVg0Y01hYjhLaAANbWFzdGVyQWRkcmVzcwkBB0FkZHJlc3MBCQDZBAEJAQt2YWx1ZU9yRWxzZQIJAJ0IAgUOQ09ORklHX0FERFJFU1MCDW1hc3RlckFkZHJlc3MCIzNQTGp3SGN6OU5FdWFUbzYzTlpSOUI5b2tRaUtReFpTYm1mAAxtYXN0ZXJQdWJLZXkJANkEAQkBC3ZhbHVlT3JFbHNlAgkAnQgCBQ5DT05GSUdfQUREUkVTUwIMbWFzdGVyUHViS2V5Aiw0ejhDS1NZUUJLa3p4N1BCYjV1QlAxWVBhNllBSFJOVEFwVzFzUVZIVDVlVQANb3JhY2xlQWRkcmVzcwkBB0FkZHJlc3MBCQDZBAEJAQt2YWx1ZU9yRWxzZQIJAJ0IAgUOQ09ORklHX0FERFJFU1MCDW9yYWNsZUFkZHJlc3MCIzNQOGQxRTFCTEtvRDUyeTNiUUoxYkRUZDJURDFncGFMbjl0AA5zdGFraW5nQWRkcmVzcwkBB0FkZHJlc3MBCQDZBAEJAQt2YWx1ZU9yRWxzZQIJAJ0IAgUOQ09ORklHX0FERFJFU1MCDnN0YWtpbmdBZGRyZXNzAiMzUEZUYnl3cXh0RmZ1a1gzSHlUODgxZzRpVzVLNFFMM0ZBUwALZmVlc0FkZHJlc3MJAQdBZGRyZXNzAQkA2QQBCQELdmFsdWVPckVsc2UCCQCdCAIFDkNPTkZJR19BRERSRVNTAgtmZWVzQWRkcmVzcwIjM1BGV0FWS21YamZIWHl6SmIxMmpDYmhQNFVoaTl0NHVXaUQAD3Bvb2xzSHViQWRkcmVzcwkBB0FkZHJlc3MBCQDZBAEJAQt2YWx1ZU9yRWxzZQIJAJ0IAgUOQ09ORklHX0FERFJFU1MCD3Bvb2xzSHViQWRkcmVzcwIjM1A1WXV0akROQzNoQUJCVnN2ZUZ1WlRUYlE1UGR0U0RCZ2sAEnNodXRkb3duQWRkcmVzc1N0cgkBC3ZhbHVlT3JFbHNlAgkAnQgCBQ5DT05GSUdfQUREUkVTUwIPc2h1dGRvd25BZGRyZXNzAiMzUEVwdjloUkZXRUVCVTIyV1JuTHN3MWJINFlHdGNVNzI4bwAPbGF5ZXIyQWRkcmVzc2VzCQELdmFsdWVPckVsc2UCCQCdCAIFDkNPTkZJR19BRERSRVNTAg9sYXllcjJBZGRyZXNzZXMCRzNQUjFRdmk5bUhUMzVTd1dFa0xTcXFFMkw4dGhpUExkVldVLDNQUW9CZlVLSGtKQWVHV2hvb0xQN1dTOG92YjU0YXY5SnAyAApnb3ZBZGRyZXNzCQEHQWRkcmVzcwEJANkEAQkBC3ZhbHVlT3JFbHNlAgkAnQgCBQ5DT05GSUdfQUREUkVTUwIKZ292QWRkcmVzcwIjM1A2dXJvOXhDc0U4dGU3OFFaanpxeTdhcThuYXRTemRjZUMAEWNvbGRNYXN0ZXJBZGRyZXNzCQEHQWRkcmVzcwEJANkEAQkBC3ZhbHVlT3JFbHNlAgkAnQgCBQ5DT05GSUdfQUREUkVTUwIRY29sZE1hc3RlckFkZHJlc3MCIzNQSzluaFBmUGJNQnlnQjlaZ0hWTUhhUWJTb29qd3JCZnhqAAFUCQENdHJ5R2V0SW50ZWdlcgECE3N0YXRpY190b2tlbnNBbW91bnQACGFzc2V0SWRzCgACJGwJALUJAgkBDHRyeUdldFN0cmluZwECD3N0YXRpY190b2tlbklkcwIBLAoAAiRzCQCQAwEFAiRsCgAFJGFjYzAFA25pbAoBBSRmMF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQETYWRkQXNzZXRCeXRlc1RvTGlzdAIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQUkZjBfMgIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgANQXNzZXRzV2VpZ2h0cwoAAiRsBQhhc3NldElkcwoAAiRzCQCQAwEFAiRsCgAFJGFjYzAFA25pbAoBBSRmMV8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEUYWRkQXNzZXRXZWlnaHRUb0xpc3QCBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjFfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDEwCQEFJGYxXzICCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECCQEFJGYxXzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoACERlY2ltYWxzCgACJGwFCGFzc2V0SWRzCgACJHMJAJADAQUCJGwKAAUkYWNjMAUDbmlsCgEFJGYyXzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJARZhZGRBc3NldERlY2ltYWxzVG9MaXN0AgUCJGEJAJEDAgUCJGwFAiRpCgEFJGYyXzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxMAkBBSRmMl8yAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgkBBSRmMl8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKAAZTY2FsZXMKAAIkbAUIYXNzZXRJZHMKAAIkcwkAkAMBBQIkbAoABSRhY2MwBQNuaWwKAQUkZjNfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBE2FkZEFzc2V0U2NhbGVUb0xpc3QCBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjNfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDEwCQEFJGYzXzICCQEFJGYzXzECCQEFJGYzXzECCQEFJGYzXzECCQEFJGYzXzECCQEFJGYzXzECCQEFJGYzXzECCQEFJGYzXzECCQEFJGYzXzECCQEFJGYzXzECCQEFJGYzXzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoAA0ZlZQkBDXRyeUdldEludGVnZXIBAgpzdGF0aWNfZmVlAAxlYXJuZWRBc3NldHMFCGFzc2V0SWRzAQppc1NodXRkb3duAAQPc2h1dGRvd25BZGRyZXNzCQCmCAEFEnNodXRkb3duQWRkcmVzc1N0cgMJAAACBQ9zaHV0ZG93bkFkZHJlc3MFBHVuaXQHBAckbWF0Y2gwCQCbCAIJAQV2YWx1ZQEFD3NodXRkb3duQWRkcmVzcwILaXNfc2h1dGRvd24DCQABAgUHJG1hdGNoMAIHQm9vbGVhbgQBeAUHJG1hdGNoMAUBeAcBFmdldEN1cnJlbnRUb2tlbkJhbGFuY2UBCHRva2VuTnVtBAp0b2tlbklkU3RyCQEOZ2V0QXNzZXRTdHJpbmcBCQCRAwIFCGFzc2V0SWRzBQh0b2tlbk51bQkBDXRyeUdldEludGVnZXIBCQCsAgIJAKwCAgIHZ2xvYmFsXwUKdG9rZW5JZFN0cgIIX2JhbGFuY2UBCGdldEtNdWx0AAQHJG1hdGNoMAkAnwgBAgxzdGF0aWNfS011bHQDCQABAgUHJG1hdGNoMAIDSW50BAF4BQckbWF0Y2gwBQF4BQdTY2FsZTE2ARJzYXZlQ3VycmVudFdlaWdodHMABAphc3NldElkc0xpCQC1CQIJAQx0cnlHZXRTdHJpbmcBAg9zdGF0aWNfdG9rZW5JZHMCASwKAQFzAgVhY2N1bQdhc3NldElkCQDOCAIFBWFjY3VtCQDMCAIJAQxJbnRlZ2VyRW50cnkCCQCsAgICFnJlYmFsYW5jZV9zdGFydFdlaWdodF8FB2Fzc2V0SWQJAQ10cnlHZXRJbnRlZ2VyAQkArAICCQCsAgICB3N0YXRpY18FB2Fzc2V0SWQCB193ZWlnaHQFA25pbAoAAiRsBQphc3NldElkc0xpCgACJHMJAJADAQUCJGwKAAUkYWNjMAUDbmlsCgEFJGY0XzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQFzAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGY0XzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxMAkBBSRmNF8yAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKARlnZXRWaXJ0dWFsUG9vbFRva2VuQW1vdW50AAkAawMJAQ10cnlHZXRJbnRlZ2VyAQIXZ2xvYmFsX3Bvb2xUb2tlbl9hbW91bnQJAQhnZXRLTXVsdAAFB1NjYWxlMTYBEGNhbGN1bGF0ZVBJc3N1ZWQCBmFtb3VudAd0b2tlbklkBAdQc3VwcGx5CQEZZ2V0VmlydHVhbFBvb2xUb2tlbkFtb3VudAAEB0JhbGFuY2UJAQ10cnlHZXRJbnRlZ2VyAQkArAICCQCsAgICB2dsb2JhbF8JAQ5nZXRBc3NldFN0cmluZwEFB3Rva2VuSWQCCF9iYWxhbmNlBAJ0MQkAbgQFBmFtb3VudAUHUHN1cHBseQUHQmFsYW5jZQUERE9XTgUCdDEBDWdldE1pblBJc3N1ZWQBCHBheW1lbnRzCgEHaGFuZGxlcgIFYWNjdW0HY3VycmVudAQHUElzc3VlZAkBEGNhbGN1bGF0ZVBJc3N1ZWQCCAUHY3VycmVudAZhbW91bnQIBQdjdXJyZW50B2Fzc2V0SWQDCQAAAgUHUElzc3VlZAAACQACAQIkb25lIG9mIHRoZSB0b2tlbnMgYW1vdW50cyBpcyB0b28gbG93AwMJAAACBQVhY2N1bQAABgkAZgIFBWFjY3VtBQdQSXNzdWVkBQdQSXNzdWVkBQVhY2N1bQQJbWluUElzc2VkCgACJGwFCHBheW1lbnRzCgACJHMJAJADAQUCJGwKAAUkYWNjMAAACgEFJGY0XzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQdoYW5kbGVyAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGY0XzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxMAkBBSRmNF8yAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKBQltaW5QSXNzZWQBEmNhbGN1bGF0ZVVzZG5WYWx1ZQQHYXNzZXRJZAZhbW91bnQIYUJhbGFuY2UQZ2l2ZW5Vc2RuQmFsYW5jZQQKdXNkbkluUG9vbAkAzwgCBQhhc3NldElkcwULdXNkbkFzc2V0SWQEDHB1enpsZUluUG9vbAkAzwgCBQhhc3NldElkcwUNcHV6emxlQXNzZXRJZAQKdXNkdEluUG9vbAkAzwgCBQhhc3NldElkcwULdXNkdEFzc2V0SWQEDXVzZHRQcHRJblBvb2wJAM8IAgUIYXNzZXRJZHMFDnVzZHRQcHRBc3NldElkBAt3YXZlc0luUG9vbAkAzwgCBQhhc3NldElkcwUEdW5pdAQLYXNzZXRXZWlnaHQJAQ10cnlHZXRJbnRlZ2VyAQkArAICCQCsAgICB3N0YXRpY18JAQ5nZXRBc3NldFN0cmluZwEFB2Fzc2V0SWQCB193ZWlnaHQEC2ZlZUFzc2V0U3RyCQEMdHJ5R2V0U3RyaW5nAQIPc3RhdGljX2ZlZVRva2VuAwkAAAIFC2ZlZUFzc2V0U3RyBRBwdXp6bGVBc3NldElkU3RyBAxwdXp6bGVXZWlnaHQJAJEDAgUNQXNzZXRzV2VpZ2h0cwkBBXZhbHVlAQkAzwgCBQhhc3NldElkcwUNcHV6emxlQXNzZXRJZAQNcHV6emxlQmFsYW5jZQkBDXRyeUdldEludGVnZXIBCQCsAgIJAKwCAgIHZ2xvYmFsXwUQcHV6emxlQXNzZXRJZFN0cgIIX2JhbGFuY2UEDmFtb3VudEluUHV6emxlCQBrAwUGYW1vdW50CQBpAgUNcHV6emxlQmFsYW5jZQUMcHV6emxlV2VpZ2h0CQBpAgUIYUJhbGFuY2UFC2Fzc2V0V2VpZ2h0BAtwdXp6bGVQcmljZQkBEUBleHRyTmF0aXZlKDEwNTApAgURcGFyZW50UG9vbEFkZHJlc3MCFmdsb2JhbF9sYXN0UHV6emxlUHJpY2UJAGsDCQBoAgUOYW1vdW50SW5QdXp6bGUFC3B1enpsZVByaWNlAAEFBlNjYWxlOAMJAAACBQtmZWVBc3NldFN0cgUOdXNkdEFzc2V0SWRTdHIECnVzZHRXZWlnaHQJAJEDAgUNQXNzZXRzV2VpZ2h0cwkBBXZhbHVlAQUKdXNkdEluUG9vbAQLdXNkdEJhbGFuY2UJAQ10cnlHZXRJbnRlZ2VyAQkArAICCQCsAgICB2dsb2JhbF8FDnVzZHRBc3NldElkU3RyAghfYmFsYW5jZQkAawMFBmFtb3VudAkAaQIFC3VzZHRCYWxhbmNlBQp1c2R0V2VpZ2h0CQBpAgUIYUJhbGFuY2UFC2Fzc2V0V2VpZ2h0AwkAAAIFC2ZlZUFzc2V0U3RyBRF1c2R0UHB0QXNzZXRJZFN0cgQKdXNkdFdlaWdodAkAkQMCBQ1Bc3NldHNXZWlnaHRzCQEFdmFsdWUBBQ11c2R0UHB0SW5Qb29sBAt1c2R0QmFsYW5jZQkBDXRyeUdldEludGVnZXIBCQCsAgIJAKwCAgIHZ2xvYmFsXwURdXNkdFBwdEFzc2V0SWRTdHICCF9iYWxhbmNlCQBrAwUGYW1vdW50CQBpAgULdXNkdEJhbGFuY2UFCnVzZHRXZWlnaHQJAGkCBQhhQmFsYW5jZQULYXNzZXRXZWlnaHQDCQAAAgULZmVlQXNzZXRTdHIFDnVzZG5Bc3NldElkU3RyBAp1c2RuV2VpZ2h0CQCRAwIFDUFzc2V0c1dlaWdodHMJAQV2YWx1ZQEJAM8IAgUIYXNzZXRJZHMFC3VzZG5Bc3NldElkBAt1c2RuQmFsYW5jZQQHJG1hdGNoMAUQZ2l2ZW5Vc2RuQmFsYW5jZQMJAAECBQckbWF0Y2gwAgNJbnQEAXgFByRtYXRjaDAFEGdpdmVuVXNkbkJhbGFuY2UJAQ10cnlHZXRJbnRlZ2VyAQkArAICCQCsAgICB2dsb2JhbF8JAQ5nZXRBc3NldFN0cmluZwEFC3VzZG5Bc3NldElkAghfYmFsYW5jZQkAawMFBmFtb3VudAkAaQIJAQV2YWx1ZQEFC3VzZG5CYWxhbmNlBQp1c2RuV2VpZ2h0CQBpAgUIYUJhbGFuY2UFC2Fzc2V0V2VpZ2h0BAt3YXZlc1dlaWdodAC4FwQId0JhbGFuY2UJAGkCCQENdHJ5R2V0SW50ZWdlcgECFGdsb2JhbF9XQVZFU19iYWxhbmNlADIJAGsDBQZhbW91bnQJAGkCBQh3QmFsYW5jZQULd2F2ZXNXZWlnaHQJAGkCBQhhQmFsYW5jZQULYXNzZXRXZWlnaHQBEmdldFByaWNlRnJvbU9yYWNsZQEKYXNzZXRJZFN0cgQHJG1hdGNoMAkAmggCBQ1vcmFjbGVBZGRyZXNzCQCsAgIFCmFzc2V0SWRTdHICB190d2FwNUIDCQABAgUHJG1hdGNoMAIDSW50BAF4BQckbWF0Y2gwBQF4AAABEWNhbGN1bGF0ZVVzZFZhbHVlAwdhc3NldElkBmFtb3VudAhhQmFsYW5jZQQLYXNzZXRXZWlnaHQJAQ10cnlHZXRJbnRlZ2VyAQkArAICCQCsAgICB3N0YXRpY18JAQ5nZXRBc3NldFN0cmluZwEFB2Fzc2V0SWQCB193ZWlnaHQEC2ZlZUFzc2V0U3RyCQEMdHJ5R2V0U3RyaW5nAQIPc3RhdGljX2ZlZVRva2VuBA1mZWVBc3NldFNjYWxlCQERQGV4dHJOYXRpdmUoMTA1MCkCBQR0aGlzCQCsAgIJAKwCAgIHc3RhdGljXwULZmVlQXNzZXRTdHICBl9zY2FsZQQLZmVlQXNzZXROdW0JAQV2YWx1ZQEJAM8IAgUIYXNzZXRJZHMJAQ1nZXRBc3NldEJ5dGVzAQULZmVlQXNzZXRTdHIEDmZlZUFzc2V0V2VpZ2h0CQCRAwIFDUFzc2V0c1dlaWdodHMFC2ZlZUFzc2V0TnVtBA9mZWVBc3NldEJhbGFuY2UJAQ10cnlHZXRJbnRlZ2VyAQkArAICCQCsAgICB2dsb2JhbF8FC2ZlZUFzc2V0U3RyAghfYmFsYW5jZQQNdmFsSW5GZWVBc3NldAkAawMFBmFtb3VudAkAaQIFD2ZlZUFzc2V0QmFsYW5jZQUOZmVlQXNzZXRXZWlnaHQJAGkCBQhhQmFsYW5jZQULYXNzZXRXZWlnaHQEDWZlZUFzc2V0UHJpY2UJARJnZXRQcmljZUZyb21PcmFjbGUBBQtmZWVBc3NldFN0cgkAawMFDXZhbEluRmVlQXNzZXQFDWZlZUFzc2V0UHJpY2UFDWZlZUFzc2V0U2NhbGUBE2NoZWNrVG9rZW5zVmFsaWRpdHkBCHBheW1lbnRzCgEIaGFuZGxlcjECBWFjY3VtB3BheW1lbnQJAM4IAgUFYWNjdW0JAMwIAggFB3BheW1lbnQHYXNzZXRJZAUDbmlsBANpZHMKAAIkbAUIcGF5bWVudHMKAAIkcwkAkAMBBQIkbAoABSRhY2MwBQNuaWwKAQUkZjRfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBCGhhbmRsZXIxAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGY0XzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxMAkBBSRmNF8yAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKAwkAAAIFA2lkcwUDaWRzCgEIaGFuZGxlcjICBWFjY3VtB2Fzc2V0SWQDCQECIT0CCQDPCAIFA2lkcwUHYXNzZXRJZAUEdW5pdAkAZAIFBWFjY3VtAAEJAAIBCQCsAgICFGFzc2V0IG5vdCBhdHRhY2hlZDogCQEOZ2V0QXNzZXRTdHJpbmcBBQdhc3NldElkBAZjaGVja3MKAAIkbAUIYXNzZXRJZHMKAAIkcwkAkAMBBQIkbAoABSRhY2MwAAAKAQUkZjVfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBCGhhbmRsZXIyAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGY1XzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxMAkBBSRmNV8yAgkBBSRmNV8xAgkBBSRmNV8xAgkBBSRmNV8xAgkBBSRmNV8xAgkBBSRmNV8xAgkBBSRmNV8xAgkBBSRmNV8xAgkBBSRmNV8xAgkBBSRmNV8xAgkBBSRmNV8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKAwkAAAIFBmNoZWNrcwUGY2hlY2tzBgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgETaGFuZGxlUG9vbFRva2Vuc0FkZAQHUElzc3VlZAhwYXltZW50cwt1c2VyQWRkcmVzcwpuZWVkQ2hhbmdlCgEVZ2V0VG9rZW5QYXltZW50QW1vdW50AQd0b2tlbklkCgEHaGFuZGxlcgIFYWNjdW0HcGF5bWVudAMJAAACCAUHcGF5bWVudAdhc3NldElkBQd0b2tlbklkCAUHcGF5bWVudAZhbW91bnQFBWFjY3VtCgACJGwFCHBheW1lbnRzCgACJHMJAJADAQUCJGwKAAUkYWNjMAAACgEFJGY0XzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQdoYW5kbGVyAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGY0XzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxMAkBBSRmNF8yAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKCgERaGFuZGxlVG9rZW5DaGFuZ2UCBWFjY3VtB3Rva2VuSWQEAkJrCQENdHJ5R2V0SW50ZWdlcgEJAKwCAgkArAICAgdnbG9iYWxfCQEOZ2V0QXNzZXRTdHJpbmcBBQd0b2tlbklkAghfYmFsYW5jZQQHUFN1cHBseQkBGWdldFZpcnR1YWxQb29sVG9rZW5BbW91bnQABA10b2tlbkRlY2ltYWxzCQENdHJ5R2V0SW50ZWdlcgEJAKwCAgkArAICAgdzdGF0aWNfCQEOZ2V0QXNzZXRTdHJpbmcBBQd0b2tlbklkAgZfc2NhbGUEAmExCQC9AgQJALkCAgkAtgIBCQBkAgUHUFN1cHBseQUHUElzc3VlZAkAtgIBBQZTY2FsZTgJALYCAQUNdG9rZW5EZWNpbWFscwkAtgIBBQdQU3VwcGx5BQdDRUlMSU5HBAJEawkAoAMBCQC9AgQJALgCAgUCYTEJALkCAgkAtgIBBQ10b2tlbkRlY2ltYWxzCQC2AgEFBlNjYWxlOAkAtgIBBQJCawkAuQICCQC2AgEFDXRva2VuRGVjaW1hbHMJALYCAQUGU2NhbGU4BQdDRUlMSU5HBA1wYXltZW50QW1vdW50CQEVZ2V0VG9rZW5QYXltZW50QW1vdW50AQUHdG9rZW5JZAQIdG9SZXR1cm4JAGUCBQ1wYXltZW50QW1vdW50BQJEawQBdAMDBQpuZWVkQ2hhbmdlCQBmAgUIdG9SZXR1cm4AAAcJAMwIAgkBDlNjcmlwdFRyYW5zZmVyAwULdXNlckFkZHJlc3MFCHRvUmV0dXJuBQd0b2tlbklkBQNuaWwFA25pbAkAzggCCQDOCAIFBWFjY3VtBQF0CQDMCAIJAQxJbnRlZ2VyRW50cnkCCQCsAgIJAKwCAgIHZ2xvYmFsXwkBDmdldEFzc2V0U3RyaW5nAQUHdG9rZW5JZAIIX2JhbGFuY2UJAGQCBQJCawUCRGsFA25pbAoAAiRsBQhhc3NldElkcwoAAiRzCQCQAwEFAiRsCgAFJGFjYzAFA25pbAoBBSRmNF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQERaGFuZGxlVG9rZW5DaGFuZ2UCBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjRfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDEwCQEFJGY0XzICCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoBFmhhbmRsZVBvb2xUb2tlbnNSZWRlZW0CCVBSZWRlZW1lZAt1c2VyQWRkcmVzcwoBEWhhbmRsZVRva2VuUmVkZWVtAgVhY2N1bQd0b2tlbklkBAJCawkBDXRyeUdldEludGVnZXIBCQCsAgIJAKwCAgIHZ2xvYmFsXwkBDmdldEFzc2V0U3RyaW5nAQUHdG9rZW5JZAIIX2JhbGFuY2UEB1BTdXBwbHkJARlnZXRWaXJ0dWFsUG9vbFRva2VuQW1vdW50AAQNdG9rZW5EZWNpbWFscwkBDXRyeUdldEludGVnZXIBCQCsAgIJAKwCAgIHc3RhdGljXwkBDmdldEFzc2V0U3RyaW5nAQUHdG9rZW5JZAIGX3NjYWxlBAZwc3VwcGwJAL0CBAkAuQICCQC2AgEJAGUCBQdQU3VwcGx5BQlQUmVkZWVtZWQJALYCAQUGU2NhbGU4CQC2AgEFBlNjYWxlOAkAtgIBBQdQU3VwcGx5BQRET1dOBAZhbW91bnQJAKADAQkAvQIECQC4AgIJALYCAQUHU2NhbGUxNgUGcHN1cHBsCQC2AgEFAkJrCQC2AgEFB1NjYWxlMTYFB0NFSUxJTkcJAM4IAgUFYWNjdW0JAMwIAgkBDEludGVnZXJFbnRyeQIJAKwCAgkArAICAgdnbG9iYWxfCQEOZ2V0QXNzZXRTdHJpbmcBBQd0b2tlbklkAghfYmFsYW5jZQkAZQIFAkJrBQZhbW91bnQJAMwIAgkBDlNjcmlwdFRyYW5zZmVyAwULdXNlckFkZHJlc3MFBmFtb3VudAUHdG9rZW5JZAUDbmlsCgACJGwFCGFzc2V0SWRzCgACJHMJAJADAQUCJGwKAAUkYWNjMAUDbmlsCgEFJGY0XzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJARFoYW5kbGVUb2tlblJlZGVlbQIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmNF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQUkZjRfMgIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgESY2FsY3VsYXRlT3V0QW1vdW50BQhBbW91bnRJbgdhc3NldEluCGFzc2V0T3V0CUJhbGFuY2VJbgpCYWxhbmNlT3V0BAdJbmRleEluCQEFdmFsdWUBCQDPCAIFCGFzc2V0SWRzBQdhc3NldEluBAhJbmRleE91dAkBBXZhbHVlAQkAzwgCBQhhc3NldElkcwUIYXNzZXRPdXQDCQAAAgUHSW5kZXhJbgUISW5kZXhPdXQFCEFtb3VudEluCQBuBAUKQmFsYW5jZU91dAkAZQIJAGgCBQZTY2FsZTgFBlNjYWxlOAkAoAMBCQB2BgkAvQIECQC5AgIJALYCAQUJQmFsYW5jZUluCQC2AgEAkE4JALYCAQkAaAIFBlNjYWxlOAUGU2NhbGU4CQC5AgIJALYCAQkAZAIFCUJhbGFuY2VJbgUIQW1vdW50SW4JALYCAQCQTgUGSEFMRlVQABAJALYCAQkAawMJAJEDAgUNQXNzZXRzV2VpZ2h0cwUHSW5kZXhJbgCAoJSljR0JAJEDAgUNQXNzZXRzV2VpZ2h0cwUISW5kZXhPdXQADAAQBQdDRUlMSU5HCQBoAgUGU2NhbGU4BQZTY2FsZTgFCEhBTEZFVkVOAR1jYWxjdWxhdGVDdXJyZW50QXNzZXRJbnRlcmVzdAQHYXNzZXRJZAphc3NldElkU3RyCGFCYWxhbmNlFnRva2VuRWFybmluZ3NMYXN0Q2hlY2sEC3RvdGFsU3Rha2VkCQENdHJ5R2V0SW50ZWdlcgECEmdsb2JhbF9pbmRleFN0YWtlZAQVdG9rZW5CYWxhbmNlTGFzdENoZWNrBRZ0b2tlbkVhcm5pbmdzTGFzdENoZWNrBBNjdXJyZW50QmFsYW5jZURlbHRhCQBlAgkBD2dldFRva2VuQmFsYW5jZQEFB2Fzc2V0SWQFCGFCYWxhbmNlBBRjdXJyZW50VG9rZW5FYXJuaW5ncwMJAGYCBRNjdXJyZW50QmFsYW5jZURlbHRhBRV0b2tlbkJhbGFuY2VMYXN0Q2hlY2sFE2N1cnJlbnRCYWxhbmNlRGVsdGEFFXRva2VuQmFsYW5jZUxhc3RDaGVjawQLbmV3RWFybmluZ3MJAGUCBRRjdXJyZW50VG9rZW5FYXJuaW5ncwUVdG9rZW5CYWxhbmNlTGFzdENoZWNrBAtuZXdJbnRlcmVzdAMJAAACBQt0b3RhbFN0YWtlZAAAAAAJAGsDBQtuZXdFYXJuaW5ncwUGU2NhbGU4BQt0b3RhbFN0YWtlZAQRbGFzdENoZWNrSW50ZXJlc3QJAQ10cnlHZXRJbnRlZ2VyAQkArAICCQCsAgICEWdsb2JhbF9sYXN0Q2hlY2tfBQphc3NldElkU3RyAglfaW50ZXJlc3QJAGQCBRFsYXN0Q2hlY2tJbnRlcmVzdAULbmV3SW50ZXJlc3QBC2NsYWltUmVzdWx0AQdhZGRyZXNzBAphZGRyZXNzU3RyCQClCAEFB2FkZHJlc3MEDHB1enpsZUFtb3VudAkBDXRyeUdldEludGVnZXIBCQCsAgIFCmFkZHJlc3NTdHICDF9pbmRleFN0YWtlZAoBB2hhbmRsZXICBWFjY3VtB2Fzc2V0SWQECmFzc2V0SWRTdHIJAQ5nZXRBc3NldFN0cmluZwEFB2Fzc2V0SWQECGFCYWxhbmNlCQENdHJ5R2V0SW50ZWdlcgEJAKwCAgkArAICAgdnbG9iYWxfCQEOZ2V0QXNzZXRTdHJpbmcBBQdhc3NldElkAghfYmFsYW5jZQQWdG9rZW5FYXJuaW5nc0xhc3RDaGVjawkBDXRyeUdldEludGVnZXIBCQCsAgIJAKwCAgIRZ2xvYmFsX2xhc3RDaGVja18FCmFzc2V0SWRTdHICCV9lYXJuaW5ncwQUY3VycmVudFRva2VuSW50ZXJlc3QJAR1jYWxjdWxhdGVDdXJyZW50QXNzZXRJbnRlcmVzdAQFB2Fzc2V0SWQFCmFzc2V0SWRTdHIFCGFCYWxhbmNlBRZ0b2tlbkVhcm5pbmdzTGFzdENoZWNrBBRjdXJyZW50VG9rZW5FYXJuaW5ncwkAlgMBCQDMCAIFFnRva2VuRWFybmluZ3NMYXN0Q2hlY2sJAMwIAgkAZQIJAQ9nZXRUb2tlbkJhbGFuY2UBBQdhc3NldElkBQhhQmFsYW5jZQUDbmlsBAxyZXdhcmRBbW91bnQJAGsDBQxwdXp6bGVBbW91bnQJAGUCBRRjdXJyZW50VG9rZW5JbnRlcmVzdAkBDXRyeUdldEludGVnZXIBCQCsAgIJAKwCAgkArAICBQphZGRyZXNzU3RyAgtfbGFzdENoZWNrXwUKYXNzZXRJZFN0cgIJX2ludGVyZXN0BQZTY2FsZTgECHRyYW5zZmVyAwkAAAIFDHJld2FyZEFtb3VudAAABQNuaWwJAMwIAgkBDlNjcmlwdFRyYW5zZmVyAwUHYWRkcmVzcwUMcmV3YXJkQW1vdW50BQdhc3NldElkBQNuaWwJAJQKAgkAzggCCQDOCAIIBQVhY2N1bQJfMQUIdHJhbnNmZXIJAMwIAgkBDEludGVnZXJFbnRyeQIJAKwCAgkArAICAhFnbG9iYWxfbGFzdENoZWNrXwUKYXNzZXRJZFN0cgIJX2Vhcm5pbmdzCQBlAgUUY3VycmVudFRva2VuRWFybmluZ3MFDHJld2FyZEFtb3VudAkAzAgCCQEMSW50ZWdlckVudHJ5AgkArAICCQCsAgICEWdsb2JhbF9sYXN0Q2hlY2tfBQphc3NldElkU3RyAglfaW50ZXJlc3QFFGN1cnJlbnRUb2tlbkludGVyZXN0CQDMCAIJAQxJbnRlZ2VyRW50cnkCCQCsAgIJAKwCAgkArAICBQphZGRyZXNzU3RyAgtfbGFzdENoZWNrXwUKYXNzZXRJZFN0cgIJX2ludGVyZXN0BRRjdXJyZW50VG9rZW5JbnRlcmVzdAUDbmlsCQBkAggFBWFjY3VtAl8yCQERY2FsY3VsYXRlVXNkVmFsdWUDBQdhc3NldElkBQxyZXdhcmRBbW91bnQFCGFCYWxhbmNlBAVhY2N1bQoAAiRsBQxlYXJuZWRBc3NldHMKAAIkcwkAkAMBBQIkbAoABSRhY2MwCQCUCgIFA25pbAAACgEFJGY0XzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQdoYW5kbGVyAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGY0XzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxMAkBBSRmNF8yAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKCQCUCgIJAM4IAggFBWFjY3VtAl8xCQDMCAIJAQxJbnRlZ2VyRW50cnkCCQCsAgIFCmFkZHJlc3NTdHICEV9jbGFpbWVkUmV3YXJkVVNECQBkAgkBDXRyeUdldEludGVnZXIBCQCsAgIFCmFkZHJlc3NTdHICEV9jbGFpbWVkUmV3YXJkVVNECAUFYWNjdW0CXzIJAMwIAgkBDEludGVnZXJFbnRyeQIJAKwCAgUKYWRkcmVzc1N0cgIKX2xhc3RDbGFpbQgFCWxhc3RCbG9jawl0aW1lc3RhbXAFA25pbAgFBWFjY3VtAl8yARBpbmRleFN0YWtlUmVzdWx0AgphZGRyZXNzU3RyBmFtb3VudAQCbGkICQELY2xhaW1SZXN1bHQBCQERQGV4dHJOYXRpdmUoMTA2MikBBQphZGRyZXNzU3RyAl8xCQDOCAIFAmxpCQDMCAIJAQxJbnRlZ2VyRW50cnkCCQCsAgIFCmFkZHJlc3NTdHICDF9pbmRleFN0YWtlZAkAZAIJAQ10cnlHZXRJbnRlZ2VyAQkArAICBQphZGRyZXNzU3RyAgxfaW5kZXhTdGFrZWQFBmFtb3VudAkAzAgCCQEMSW50ZWdlckVudHJ5AgISZ2xvYmFsX2luZGV4U3Rha2VkCQBkAgkBDXRyeUdldEludGVnZXIBAhJnbG9iYWxfaW5kZXhTdGFrZWQFBmFtb3VudAUDbmlsAQNzdW0CBWFjY3VtAW4JAGQCBQVhY2N1bQkBDXBhcnNlSW50VmFsdWUBBQFuAQ1jaGVja0ZlZUFzc2V0AgVhY2N1bQRuZXh0AwMJAQIhPQIJAM8IAgUVc3VwcG9ydGVkRmVlQXNzZXRzU3RyBQRuZXh0BQR1bml0CQAAAgUFYWNjdW0CAAcFBG5leHQFBWFjY3VtARJnZXRUbXBSZWJhbGFuY2VJZHMBDW5ld0Fzc2V0SWRzTGkEEWN1cnJlbnRBc3NldElkc0xpCQC1CQIJAQx0cnlHZXRTdHJpbmcBAg9zdGF0aWNfdG9rZW5JZHMCASwEBnJlc3VsdAUNbmV3QXNzZXRJZHNMaQoBAWYCBWFjY3VtB2Fzc2V0SWQDCQAAAgkAzwgCBQZyZXN1bHQFB2Fzc2V0SWQFBHVuaXQJAM4IAgUFYWNjdW0JAMwIAgUHYXNzZXRJZAUDbmlsBQVhY2N1bQoAAiRsBRFjdXJyZW50QXNzZXRJZHNMaQoAAiRzCQCQAwEFAiRsCgAFJGFjYzAFBnJlc3VsdAoBBSRmNF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEBZgIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmNF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQUkZjRfMgIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgERY2hlY2tUb2tlbnNDaGFuZ2UBDW5ld0Fzc2V0SWRzTGkEEWN1cnJlbnRBc3NldElkc0xpCQC1CQIJAQx0cnlHZXRTdHJpbmcBAg9zdGF0aWNfdG9rZW5JZHMCASwKAQNyZW0CBWFjY3VtB2Fzc2V0SWQDCQAAAgkAzwgCBQ1uZXdBc3NldElkc0xpBQdhc3NldElkBQR1bml0CQBkAgUFYWNjdW0AAQUFYWNjdW0KAQNhZGQCBWFjY3VtB2Fzc2V0SWQDCQAAAgkAzwgCBRFjdXJyZW50QXNzZXRJZHNMaQUHYXNzZXRJZAUEdW5pdAkAZAIFBWFjY3VtAAEFBWFjY3VtBAdyZW1vdmVkCgACJGwFEWN1cnJlbnRBc3NldElkc0xpCgACJHMJAJADAQUCJGwKAAUkYWNjMAAACgEFJGY0XzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQNyZW0CBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjRfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDEwCQEFJGY0XzICCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoEBWFkZGVkCgACJGwFDW5ld0Fzc2V0SWRzTGkKAAIkcwkAkAMBBQIkbAoABSRhY2MwAAAKAQUkZjVfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBA2FkZAIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmNV8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQUkZjVfMgIJAQUkZjVfMQIJAQUkZjVfMQIJAQUkZjVfMQIJAQUkZjVfMQIJAQUkZjVfMQIJAQUkZjVfMQIJAQUkZjVfMQIJAQUkZjVfMQIJAQUkZjVfMQIJAQUkZjVfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgkAZAIFB3JlbW92ZWQFBWFkZGVkARB2YWxpZGF0ZVBheW1lbnRzAgphc3NldHNMaXN0CHBheW1lbnRzCgEQZ2V0UGF5bWVudEFzc2V0cwIFYWNjdW0EbmV4dAMJAGcCAAAIBQRuZXh0BmFtb3VudAkAAgEJAKwCAgkArAICCQCsAgICG1RvbyBsb3cgcGF5bWVudCBhbW91bnQgZm9yIAkBDmdldEFzc2V0U3RyaW5nAQgFBG5leHQHYXNzZXRJZAICOiAJAKQDAQgFBG5leHQGYW1vdW50CQDOCAIFBWFjY3VtCQDMCAIJAQ5nZXRBc3NldFN0cmluZwEIBQRuZXh0B2Fzc2V0SWQFA25pbAQLcGF5bWVudExpc3QKAAIkbAUIcGF5bWVudHMKAAIkcwkAkAMBBQIkbAoABSRhY2MwBQNuaWwKAQUkZjRfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBEGdldFBheW1lbnRBc3NldHMCBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjRfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDEwCQEFJGY0XzICCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoKAQJmMQIFYWNjdW0EbmV4dAMJAAACCQDPCAIFCmFzc2V0c0xpc3QFBG5leHQFBHVuaXQJAAIBCQCsAgIJAKwCAgUEbmV4dAI5IGFzc2V0IGlzIHByZXNlbnQgaW4gcGF5bWVudHMsIGJ1dCBpcyBub3QgaW4gbmV3IGFzc2V0czogCQC5CQIFCmFzc2V0c0xpc3QCASwJAGQCBQVhY2N1bQABCgECZjICBWFjY3VtBG5leHQDCQAAAgkAzwgCBQtwYXltZW50TGlzdAUEbmV4dAUEdW5pdAkAAgEJAKwCAgkArAICBQRuZXh0AjkgYXNzZXQgaXMgcHJlc2VudCBpbiBuZXcgYXNzZXRzLCBidXQgaXMgbm90IGluIHBheW1lbnRzOiAJALkJAgULcGF5bWVudExpc3QCASwJAGQCBQVhY2N1bQABBAJhMQoAAiRsBQtwYXltZW50TGlzdAoAAiRzCQCQAwEFAiRsCgAFJGFjYzAAAAoBBSRmNV8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQECZjECBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjVfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDEwCQEFJGY1XzICCQEFJGY1XzECCQEFJGY1XzECCQEFJGY1XzECCQEFJGY1XzECCQEFJGY1XzECCQEFJGY1XzECCQEFJGY1XzECCQEFJGY1XzECCQEFJGY1XzECCQEFJGY1XzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoEAmEyCgACJGwFCmFzc2V0c0xpc3QKAAIkcwkAkAMBBQIkbAoABSRhY2MwAAAKAQUkZjZfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBAmYyAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGY2XzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxMAkBBSRmNl8yAgkBBSRmNl8xAgkBBSRmNl8xAgkBBSRmNl8xAgkBBSRmNl8xAgkBBSRmNl8xAgkBBSRmNl8xAgkBBSRmNl8xAgkBBSRmNl8xAgkBBSRmNl8xAgkBBSRmNl8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKCQBkAgUCYTEFAmEyAQ92YWxpZGF0ZVdlaWdodHMBB3dlaWdodHMKAQF2AgVhY2N1bQF3BAR3SW50CQETdmFsdWVPckVycm9yTWVzc2FnZQIJALYJAQUBdwkArAICAhVXcm9uZyB3ZWlnaHQgZm9ybWF0OiAFAXcDAwkAZgIFCk1JTl9XRUlHSFQFBHdJbnQGCQBmAgUEd0ludAUKTUFYX1dFSUdIVAkAAgEJAKwCAgkArAICCQCsAgIJAKwCAgkArAICAhpXZWlnaHQgc2hvdWxkIGJlIGluIHJhbmdlIAkApAMBBQpNSU5fV0VJR0hUAgMgLSAJAKQDAQUKTUFYX1dFSUdIVAILLCBjdXJyZW50OiAFAXcFBWFjY3VtCgACJGwFB3dlaWdodHMKAAIkcwkAkAMBBQIkbAoABSRhY2MwAAAKAQUkZjRfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBAXYCBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjRfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDEwCQEFJGY0XzICCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoSAWkBB3ByZUluaXQGC2Fzc2V0SWRzU3RyD2Fzc2V0V2VpZ2h0c1N0cg5iYXNlVG9rZW5JZFN0cgpwb29sRG9tYWluCXBvb2xPd25lcgNmZWUEEHBvb2xPd25lckFkZHJlc3MJAQdBZGRyZXNzAQkA2QQBBQlwb29sT3duZXIEDWFzc2V0SWRzU3RyTGkJALUJAgULYXNzZXRJZHNTdHICASwECmFzc2V0SWRzTGkKAAIkbAUNYXNzZXRJZHNTdHJMaQoAAiRzCQCQAwEFAiRsCgAFJGFjYzAFA25pbAoBBSRmNF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQETYWRkQXNzZXRCeXRlc1RvTGlzdAIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmNF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQUkZjRfMgIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgQLZmVlQXNzZXRTdHIKAAIkbAUNYXNzZXRJZHNTdHJMaQoAAiRzCQCQAwEFAiRsCgAFJGFjYzACAAoBBSRmNV8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQENY2hlY2tGZWVBc3NldAIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmNV8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQUkZjVfMgIJAQUkZjVfMQIJAQUkZjVfMQIJAQUkZjVfMQIJAQUkZjVfMQIJAQUkZjVfMQIJAQUkZjVfMQIJAQUkZjVfMQIJAQUkZjVfMQIJAQUkZjVfMQIJAQUkZjVfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgMJAQppc1NodXRkb3duAAkAAgECE2NvbnRyYWN0IGlzIG9uIHN0b3ADCQECIT0CBQR0aGlzCAUBaQZjYWxsZXIJAAIBAgphZG1pbiBvbmx5AwkAAAIFC2ZlZUFzc2V0U3RyAgAJAAIBAkFwb29sIG11c3QgaGF2ZSBvbmUgb2YgdGhlIHN1cHBvcnRlZCBmZWUgYXNzZXRzIGluIHRoZSBjb21wb3NpdGlvbgMJAGYCCQCxAgEFCnBvb2xEb21haW4ADQkAAgECFXRvbyBsYXJnZSBwb29sIGRvbWFpbgMDCQBmAgUDZmVlAPQDBgkAZgIAAAUDZmVlCQACAQItZmVlIHZhbHVlIG11c3QgYmUgYmV0d2VlbiA1MCBhbmQgNTAwICgwLjUtNSUpBBFhc3NldFdlaWdodHNTdHJMaQkAtQkCBQ9hc3NldFdlaWdodHNTdHICASwED2Fzc2V0V2VpZ2h0c1N1bQoAAiRsBRFhc3NldFdlaWdodHNTdHJMaQoAAiRzCQCQAwEFAiRsCgAFJGFjYzAAAAoBBSRmNl8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEDc3VtAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGY2XzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxMAkBBSRmNl8yAgkBBSRmNl8xAgkBBSRmNl8xAgkBBSRmNl8xAgkBBSRmNl8xAgkBBSRmNl8xAgkBBSRmNl8xAgkBBSRmNl8xAgkBBSRmNl8xAgkBBSRmNl8xAgkBBSRmNl8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKCgETYWRkVG9rZW5EYXRhRW50cmllcwIFYWNjdW0IYXNzZXROdW0DCQBnAgUIYXNzZXROdW0JAJADAQUKYXNzZXRJZHNMaQUFYWNjdW0EDWFzc2V0RGVjaW1hbHMEByRtYXRjaDAJAJEDAgUKYXNzZXRJZHNMaQUIYXNzZXROdW0DCQABAgUHJG1hdGNoMAIKQnl0ZVZlY3RvcgQBeAUHJG1hdGNoMAgJAQV2YWx1ZQEJAOwHAQUBeAhkZWNpbWFscwAICQDOCAIFBWFjY3VtCQDMCAIJAQxJbnRlZ2VyRW50cnkCCQCsAgIJAKwCAgIHc3RhdGljXwkAkQMCBQ1hc3NldElkc1N0ckxpBQhhc3NldE51bQIGX3NjYWxlCQBsBgAKAAAFDWFzc2V0RGVjaW1hbHMAAAAABQRET1dOCQDMCAIJAQxJbnRlZ2VyRW50cnkCCQCsAgIJAKwCAgIHc3RhdGljXwkAkQMCBQ1hc3NldElkc1N0ckxpBQhhc3NldE51bQIJX2RlY2ltYWxzBQ1hc3NldERlY2ltYWxzCQDMCAIJAQxJbnRlZ2VyRW50cnkCCQCsAgIJAKwCAgIHc3RhdGljXwkAkQMCBQ1hc3NldElkc1N0ckxpBQhhc3NldE51bQIHX3dlaWdodAkBBXZhbHVlAQkAtgkBCQCRAwIFEWFzc2V0V2VpZ2h0c1N0ckxpBQhhc3NldE51bQUDbmlsAwkBAiE9AgUPYXNzZXRXZWlnaHRzU3VtAJBOCQACAQIrc3VtIG9mIHRva2VuIHdlaWdodHMgbXVzdCBiZSBlcXVhbCB0byAxMDAwMAkAzggCCgACJGwJAMwIAgAACQDMCAIAAQkAzAgCAAIJAMwIAgADCQDMCAIABAkAzAgCAAUJAMwIAgAGCQDMCAIABwkAzAgCAAgJAMwIAgAJBQNuaWwKAAIkcwkAkAMBBQIkbAoABSRhY2MwBQNuaWwKAQUkZjdfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBE2FkZFRva2VuRGF0YUVudHJpZXMCBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjdfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDEwCQEFJGY3XzICCQEFJGY3XzECCQEFJGY3XzECCQEFJGY3XzECCQEFJGY3XzECCQEFJGY3XzECCQEFJGY3XzECCQEFJGY3XzECCQEFJGY3XzECCQEFJGY3XzECCQEFJGY3XzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoJAMwIAgkBC1N0cmluZ0VudHJ5AgIPc3RhdGljX3Rva2VuSWRzBQthc3NldElkc1N0cgkAzAgCCQELU3RyaW5nRW50cnkCAg9zdGF0aWNfZmVlVG9rZW4FC2ZlZUFzc2V0U3RyCQDMCAIJAQtTdHJpbmdFbnRyeQICE3N0YXRpY190b2tlbldlaWdodHMFD2Fzc2V0V2VpZ2h0c1N0cgkAzAgCCQEMSW50ZWdlckVudHJ5AgITc3RhdGljX3Rva2Vuc0Ftb3VudAkAkAMBBQphc3NldElkc0xpCQDMCAIJAQtTdHJpbmdFbnRyeQICEXN0YXRpY19wb29sRG9tYWluBQpwb29sRG9tYWluCQDMCAIJAQtTdHJpbmdFbnRyeQICEnN0YXRpY19iYXNlVG9rZW5JZAUOYmFzZVRva2VuSWRTdHIJAMwIAgkBC1N0cmluZ0VudHJ5AgIQc3RhdGljX3Bvb2xPd25lcgUJcG9vbE93bmVyCQDMCAIJAQxJbnRlZ2VyRW50cnkCAgpzdGF0aWNfZmVlBQNmZWUJAMwIAgkBDEludGVnZXJFbnRyeQICDHN0YXRpY19LTXVsdAUHU2NhbGUxNgkAzAgCCQEMSW50ZWdlckVudHJ5AgITZ2xvYmFsX3dhc1ByZUluaXRlZAABBQNuaWwBaQEGZGVJbml0AAMJAQppc1NodXRkb3duAAkAAgECE2NvbnRyYWN0IGlzIG9uIHN0b3ADCQECIT0CCAUBaQZjYWxsZXIFBHRoaXMJAAIBAgphZG1pbiBvbmx5CQDMCAIJAQxJbnRlZ2VyRW50cnkCAhBnbG9iYWxfd2FzSW5pdGVkAAAFA25pbAFpAQRpbml0AAoBC3ByZXBhcmVMaXN0AAoBB2hhbmRsZXICBWFjY3VtAW4JAM4IAgUFYWNjdW0JAMwIAgkBDEludGVnZXJFbnRyeQIJAKwCAgkArAICAgdnbG9iYWxfCQEOZ2V0QXNzZXRTdHJpbmcBCAUBbgdhc3NldElkAghfYmFsYW5jZQgFAW4GYW1vdW50BQNuaWwKAAIkbAgFAWkIcGF5bWVudHMKAAIkcwkAkAMBBQIkbAoABSRhY2MwBQNuaWwKAQUkZjRfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBB2hhbmRsZXICBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjRfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDEwCQEFJGY0XzICCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECCQEFJGY0XzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoKARljYWxjdWxhdGVQb29sVG9rZW5zQW1vdW50AQhwYXltZW50cwoBB2hhbmRsZXICBWFjY3VtA3BtdAQHYXNzZXRJZAgFA3BtdAdhc3NldElkCgEIaGFuZGxlcjICBWFjY3VtAW4DCQAAAgUBbgUHYXNzZXRJZAkBBXZhbHVlAQkAzwgCBQhhc3NldElkcwUBbgUFYWNjdW0EBVRva2VuCgACJGwFCGFzc2V0SWRzCgACJHMJAJADAQUCJGwKAAUkYWNjMAABCgEFJGY0XzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQhoYW5kbGVyMgIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmNF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQUkZjRfMgIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgkAawMFBWFjY3VtCQBsBggFA3BtdAZhbW91bnQJAJEDAgUIRGVjaW1hbHMFBVRva2VuCQCRAwIFDUFzc2V0c1dlaWdodHMFBVRva2VuBRVBc3NldHNXZWlnaHRzRGVjaW1hbHMACAUFRkxPT1IFBlNjYWxlOAoAAiRsBQhwYXltZW50cwoAAiRzCQCQAwEFAiRsCgAFJGFjYzAFDlBvb2xUb2tlblNjYWxlCgEFJGY0XzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQdoYW5kbGVyAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGY0XzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxMAkBBSRmNF8yAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKAwkBCmlzU2h1dGRvd24ACQACAQITY29udHJhY3QgaXMgb24gc3RvcAMJAGYCCQENdHJ5R2V0SW50ZWdlcgECEGdsb2JhbF93YXNJbml0ZWQAAAkAAgECE3Bvb2wgYWxyZWFkeSBpbml0ZWQEEWluaXRpYWxQb29sVG9rZW5zCQEZY2FsY3VsYXRlUG9vbFRva2Vuc0Ftb3VudAEIBQFpCHBheW1lbnRzAwkAAAIFEWluaXRpYWxQb29sVG9rZW5zAAAJAAIBAjJ5b3UgbmVlZCBhIGJpZ2dlciB0b2tlbnMgYW1vdW50IHRvIGxhdW5jaCB0aGUgcG9vbAQOcG9vbFRva2VuSXNzdWUJAMMIBwkArAICAgNQWiAJAQx0cnlHZXRTdHJpbmcBAhFzdGF0aWNfcG9vbERvbWFpbgIdUHV6emxlIFN3YXA6IHBvb2wgaW5kZXggdG9rZW4FEWluaXRpYWxQb29sVG9rZW5zBRFQb29sVG9rZW5EZWNpbWFscwYFBHVuaXQAAAQLcG9vbFRva2VuSWQJALgIAQUOcG9vbFRva2VuSXNzdWUJAM4IAgkBC3ByZXBhcmVMaXN0AAkAzAgCBQ5wb29sVG9rZW5Jc3N1ZQkAzAgCCQEMSW50ZWdlckVudHJ5AgIXZ2xvYmFsX3Bvb2xUb2tlbl9hbW91bnQFEWluaXRpYWxQb29sVG9rZW5zCQDMCAIJAQxJbnRlZ2VyRW50cnkCAhBnbG9iYWxfd2FzSW5pdGVkAAEJAMwIAgkBC0JpbmFyeUVudHJ5AgITZ2xvYmFsX3Bvb2xUb2tlbl9pZAULcG9vbFRva2VuSWQJAMwIAgkBC1N0cmluZ0VudHJ5AgIWc3RhdGljX3Bvb2xUb2tlbl9pZFN0cgkBDmdldEFzc2V0U3RyaW5nAQULcG9vbFRva2VuSWQJAMwIAgkBDEludGVnZXJFbnRyeQIJAKwCAgkApQgBCAUBaQZjYWxsZXICDF9pbmRleFN0YWtlZAURaW5pdGlhbFBvb2xUb2tlbnMJAMwIAgkBDEludGVnZXJFbnRyeQICEmdsb2JhbF9pbmRleFN0YWtlZAURaW5pdGlhbFBvb2xUb2tlbnMFA25pbAFpAQ1nZW5lcmF0ZUluZGV4AQpuZWVkQ2hhbmdlAwkBAiE9AgkAkAMBCAUBaQhwYXltZW50cwUBVAkAAgEJAKwCAgI7eW91IG5lZWQgdG8gYXR0YWNoIGFsbCBwb29sIHRva2Vucy4gYW1vdW50IG9mIHBvb2wgdG9rZW5zOiAJAKQDAQUBVAMJAQEhAQkBE2NoZWNrVG9rZW5zVmFsaWRpdHkBCAUBaQhwYXltZW50cwkAAgECFXdyb25nIGFzc2V0cyBhdHRhY2hlZAQNUElzc3VlZE5vTXVsdAkBDWdldE1pblBJc3N1ZWQBCAUBaQhwYXltZW50cwQGcmVzdWx0CQETaGFuZGxlUG9vbFRva2Vuc0FkZAQFDVBJc3N1ZWROb011bHQIBQFpCHBheW1lbnRzCAUBaQxvcmlnaW5DYWxsZXIFCm5lZWRDaGFuZ2UED1BJc3N1ZWRXaXRoTXVsdAkAbgQFDVBJc3N1ZWROb011bHQFB1NjYWxlMTYJAQhnZXRLTXVsdAAFBERPV04EB3JlaXNzdWUJAQdSZWlzc3VlAwkBEUBleHRyTmF0aXZlKDEwNTcpAQITZ2xvYmFsX3Bvb2xUb2tlbl9pZAUPUElzc3VlZFdpdGhNdWx0BgkAlAoCCQDOCAIFBnJlc3VsdAkAzAgCBQdyZWlzc3VlCQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMIBQFpBmNhbGxlcgUPUElzc3VlZFdpdGhNdWx0CQEMdHJ5R2V0QmluYXJ5AQITZ2xvYmFsX3Bvb2xUb2tlbl9pZAkAzAgCCQEMSW50ZWdlckVudHJ5AgIXZ2xvYmFsX3Bvb2xUb2tlbl9hbW91bnQJAGQCCQENdHJ5R2V0SW50ZWdlcgECF2dsb2JhbF9wb29sVG9rZW5fYW1vdW50BQ9QSXNzdWVkV2l0aE11bHQFA25pbAUPUElzc3VlZFdpdGhNdWx0AWkBC3JlZGVlbUluZGV4AQxzZW5kVG9PcmlnaW4EA3BtdAkAkQMCCAUBaQhwYXltZW50cwAAAwkBAiE9AggFA3BtdAdhc3NldElkCQEMdHJ5R2V0QmluYXJ5AQITZ2xvYmFsX3Bvb2xUb2tlbl9pZAkAAgECHnBsZWFzZSBhdHRhY2ggcG9vbCBzaGFyZSB0b2tlbgMJAQppc1NodXRkb3duAAkAAgECE2NvbnRyYWN0IGlzIG9uIHN0b3AEEVBSZWRlZW1lZFdpdGhNdWx0CAUDcG10BmFtb3VudAQTUFJlZGVlbWVkV2l0aE5vTXVsdAkAbgQFEVBSZWRlZW1lZFdpdGhNdWx0CQEIZ2V0S011bHQABQdTY2FsZTE2BQRET1dOBAZyZXN1bHQJARZoYW5kbGVQb29sVG9rZW5zUmVkZWVtAgUTUFJlZGVlbWVkV2l0aE5vTXVsdAMFDHNlbmRUb09yaWdpbggFAWkMb3JpZ2luQ2FsbGVyCAUBaQZjYWxsZXIJAM4IAgUGcmVzdWx0CQDMCAIJAQRCdXJuAgkBDHRyeUdldEJpbmFyeQECE2dsb2JhbF9wb29sVG9rZW5faWQFEVBSZWRlZW1lZFdpdGhNdWx0CQDMCAIJAQxJbnRlZ2VyRW50cnkCAhdnbG9iYWxfcG9vbFRva2VuX2Ftb3VudAkAZQIJAQ10cnlHZXRJbnRlZ2VyAQIXZ2xvYmFsX3Bvb2xUb2tlbl9hbW91bnQFEVBSZWRlZW1lZFdpdGhNdWx0BQNuaWwBaQEKc3Rha2VJbmRleAAECmFkZHJlc3NTdHIJAKUIAQgFAWkMb3JpZ2luQ2FsbGVyBANwbXQJAJEDAggFAWkIcGF5bWVudHMAAAMJAQIhPQIJAQV2YWx1ZQEIBQNwbXQHYXNzZXRJZAkBDHRyeUdldEJpbmFyeQECE2dsb2JhbF9wb29sVG9rZW5faWQJAAIBAhR3cm9uZyBhc3NldCBhdHRhY2hlZAkBEGluZGV4U3Rha2VSZXN1bHQCBQphZGRyZXNzU3RyCAUDcG10BmFtb3VudAFpAQ1zdGFrZUluZGV4Rm9yAQphZGRyZXNzU3RyBANwbXQJAJEDAggFAWkIcGF5bWVudHMAAAMJAQIhPQIJAQV2YWx1ZQEIBQNwbXQHYXNzZXRJZAkBDHRyeUdldEJpbmFyeQECE2dsb2JhbF9wb29sVG9rZW5faWQJAAIBAhR3cm9uZyBhc3NldCBhdHRhY2hlZAkBEGluZGV4U3Rha2VSZXN1bHQCBQphZGRyZXNzU3RyCAUDcG10BmFtb3VudAFpAQx1bnN0YWtlSW5kZXgBC2luZGV4QW1vdW50BAphZGRyZXNzU3RyAwkBAiE9AgkAswkCBQ9sYXllcjJBZGRyZXNzZXMJAKUIAQgFAWkGY2FsbGVyBQR1bml0CQClCAEIBQFpDG9yaWdpbkNhbGxlcgkApQgBCAUBaQZjYWxsZXIEDmluZGV4QXZhaWxhYmxlCQENdHJ5R2V0SW50ZWdlcgEJAKwCAgUKYWRkcmVzc1N0cgIMX2luZGV4U3Rha2VkAwkBCmlzU2h1dGRvd24ACQACAQITY29udHJhY3QgaXMgb24gc3RvcAMJAGYCBQtpbmRleEFtb3VudAUOaW5kZXhBdmFpbGFibGUJAAIBAiV5b3UgZG9uJ3QgaGF2ZSBpbmRleCB0b2tlbnMgYXZhaWxhYmxlAwkBCmlzU2h1dGRvd24ACQACAQITY29udHJhY3QgaXMgb24gc3RvcAkAzggCCAkBC2NsYWltUmVzdWx0AQkBEUBleHRyTmF0aXZlKDEwNjIpAQUKYWRkcmVzc1N0cgJfMQkAzAgCCQEMSW50ZWdlckVudHJ5AgkArAICBQphZGRyZXNzU3RyAgxfaW5kZXhTdGFrZWQJAGUCBQ5pbmRleEF2YWlsYWJsZQULaW5kZXhBbW91bnQJAMwIAgkBDEludGVnZXJFbnRyeQICEmdsb2JhbF9pbmRleFN0YWtlZAkAZQIJAQ10cnlHZXRJbnRlZ2VyAQISZ2xvYmFsX2luZGV4U3Rha2VkBQtpbmRleEFtb3VudAkAzAgCCQEOU2NyaXB0VHJhbnNmZXIDCAUBaQZjYWxsZXIFC2luZGV4QW1vdW50CQERQGV4dHJOYXRpdmUoMTA1NykBAhNnbG9iYWxfcG9vbFRva2VuX2lkBQNuaWwBaQERY2xhaW1JbmRleFJld2FyZHMAAwkBCmlzU2h1dGRvd24ACQACAQITY29udHJhY3QgaXMgb24gc3RvcAkBC2NsYWltUmVzdWx0AQgFAWkGY2FsbGVyAWkBDWV2YWx1YXRlQ2xhaW0BBHVzZXIJAJQKAgUDbmlsCAkBC2NsYWltUmVzdWx0AQkBEUBleHRyTmF0aXZlKDEwNjIpAQUEdXNlcgJfMgFpAQRzd2FwAghhc3NldE91dAdtaW5pbXVtBANwbXQDCQAAAgkAkAMBCAUBaQhwYXltZW50cwABCQEFdmFsdWUBCQCRAwIIBQFpCHBheW1lbnRzAAAJAAIBAiFwbGVhc2UgYXR0YWNoIGV4YWN0bHkgb25lIHBheW1lbnQECEFtb3VudEluCQEFdmFsdWUBCAkAkQMCCAUBaQhwYXltZW50cwAABmFtb3VudAQHQXNzZXRJbggFA3BtdAdhc3NldElkBAhBc3NldE91dAkBDWdldEFzc2V0Qnl0ZXMBBQhhc3NldE91dAQHYXNzZXRJbgkBDmdldEFzc2V0U3RyaW5nAQUHQXNzZXRJbgQHc2NhbGVJbgkAaQIFBlNjYWxlOAkBDXRyeUdldEludGVnZXIBCQCsAgIJAKwCAgIHc3RhdGljXwUHYXNzZXRJbgIGX3NjYWxlBAhzY2FsZU91dAkAaQIFBlNjYWxlOAkBDXRyeUdldEludGVnZXIBCQCsAgIJAKwCAgIHc3RhdGljXwUIYXNzZXRPdXQCBl9zY2FsZQQOZmVlQXNzZXRPdXRTdHIJAQx0cnlHZXRTdHJpbmcBAg9zdGF0aWNfZmVlVG9rZW4EC2ZlZUFzc2V0T3V0AwkAAAIFDmZlZUFzc2V0T3V0U3RyAgAFC3VzZG5Bc3NldElkCQENZ2V0QXNzZXRCeXRlcwEFDmZlZUFzc2V0T3V0U3RyBA5Bc3NldEluQmFsYW5jZQkBDXRyeUdldEludGVnZXIBCQCsAgIJAKwCAgIHZ2xvYmFsXwkBDmdldEFzc2V0U3RyaW5nAQUHQXNzZXRJbgIIX2JhbGFuY2UED0Fzc2V0T3V0QmFsYW5jZQkBDXRyeUdldEludGVnZXIBCQCsAgIJAKwCAgIHZ2xvYmFsXwUIYXNzZXRPdXQCCF9iYWxhbmNlBBRBc3NldEluQmFsYW5jZVNjYWxlZAkAaAIFDkFzc2V0SW5CYWxhbmNlBQdzY2FsZUluBBVBc3NldE91dEJhbGFuY2VTY2FsZWQJAGgCBQ9Bc3NldE91dEJhbGFuY2UFCHNjYWxlT3V0BAtmZWVBbW91bnRJbgkAawMFCEFtb3VudEluBQNGZWUFCEZlZVNjYWxlBA1jbGVhbkFtb3VudEluCQBlAgUIQW1vdW50SW4FC2ZlZUFtb3VudEluBBNjbGVhbkFtb3VudEluU2NhbGVkCQBoAgUNY2xlYW5BbW91bnRJbgUHc2NhbGVJbgQKQW1vdW50T3V0MQkBEmNhbGN1bGF0ZU91dEFtb3VudAUFE2NsZWFuQW1vdW50SW5TY2FsZWQFB0Fzc2V0SW4FCEFzc2V0T3V0BRRBc3NldEluQmFsYW5jZVNjYWxlZAUVQXNzZXRPdXRCYWxhbmNlU2NhbGVkBAlBbW91bnRPdXQJAGsDBQpBbW91bnRPdXQxAAEFCHNjYWxlT3V0BBBBc3NldE91dEJhbGFuY2UyCQBlAgUPQXNzZXRPdXRCYWxhbmNlBQlBbW91bnRPdXQED0Fzc2V0SW5CYWxhbmNlMgkAZAIFDkFzc2V0SW5CYWxhbmNlBQ1jbGVhbkFtb3VudEluBBJmZWVBc3NldE91dEJhbGFuY2UDCQAAAgULZmVlQXNzZXRPdXQFB0Fzc2V0SW4FD0Fzc2V0SW5CYWxhbmNlMgMJAAACBQtmZWVBc3NldE91dAUIQXNzZXRPdXQFEEFzc2V0T3V0QmFsYW5jZTIJAQ10cnlHZXRJbnRlZ2VyAQkArAICCQCsAgICB2dsb2JhbF8JAQ5nZXRBc3NldFN0cmluZwEFC2ZlZUFzc2V0T3V0AghfYmFsYW5jZQQMZmVlQW1vdW50T3V0CQESY2FsY3VsYXRlT3V0QW1vdW50BQULZmVlQW1vdW50SW4FB0Fzc2V0SW4FC2ZlZUFzc2V0T3V0BQ5Bc3NldEluQmFsYW5jZQUSZmVlQXNzZXRPdXRCYWxhbmNlAwkAZgIFB21pbmltdW0FCUFtb3VudE91dAkAAgECKWFtb3VudCB0byByZWNpZXZlIGlzIGxvd2VyIHRoYW4gZ2l2ZW4gb25lAwkAAAIFCEFzc2V0T3V0BQdBc3NldEluCQACAQIYdGhpcyBzd2FwIGlzIG5vdCBhbGxvd2VkAwkAZgIAAAkAZQIFD0Fzc2V0T3V0QmFsYW5jZQUJQW1vdW50T3V0CQACAQIbY29udHJhY3QgaXMgb3V0IG9mIHJlc2VydmVzAwkBCmlzU2h1dGRvd24ACQACAQITY29udHJhY3QgaXMgb24gc3RvcAQKY3JlYXRvckZlZQkAawMFDGZlZUFtb3VudE91dAABAAoEC3Byb3RvY29sRmVlCQBrAwUMZmVlQW1vdW50T3V0AAQACgQMbmV3QmFsYW5jZUluBQ9Bc3NldEluQmFsYW5jZTIEDW5ld0JhbGFuY2VPdXQJAGUCBRBBc3NldE91dEJhbGFuY2UyAwkAAAIFCEFzc2V0T3V0BQtmZWVBc3NldE91dAUMZmVlQW1vdW50T3V0AAAEEm5ld0JhbGFuY2VGZWVBc3NldAMDCQECIT0CBQtmZWVBc3NldE91dAUHQXNzZXRJbgkBAiE9AgULZmVlQXNzZXRPdXQFCEFzc2V0T3V0BwkAZQIFEmZlZUFzc2V0T3V0QmFsYW5jZQUMZmVlQW1vdW50T3V0BQR1bml0BA1hc3NldEluQ2hhbmdlCQEMSW50ZWdlckVudHJ5AgkArAICCQCsAgICB2dsb2JhbF8JAQ5nZXRBc3NldFN0cmluZwEFB0Fzc2V0SW4CCF9iYWxhbmNlBQxuZXdCYWxhbmNlSW4EDmFzc2V0T3V0Q2hhbmdlCQEMSW50ZWdlckVudHJ5AgkArAICCQCsAgICB2dsb2JhbF8FCGFzc2V0T3V0AghfYmFsYW5jZQUNbmV3QmFsYW5jZU91dAQRZmVlQXNzZXRPdXRDaGFuZ2UDCQECIT0CBRJuZXdCYWxhbmNlRmVlQXNzZXQFBHVuaXQJAQxJbnRlZ2VyRW50cnkCCQCsAgIJAKwCAgIHZ2xvYmFsXwkBDmdldEFzc2V0U3RyaW5nAQULZmVlQXNzZXRPdXQCCF9iYWxhbmNlCQEFdmFsdWUBBRJuZXdCYWxhbmNlRmVlQXNzZXQJAQtTdHJpbmdFbnRyeQICBWhlbGxvAgV3b3JsZAQMdm9sdW1lVXBkYXRlCQESY2FsY3VsYXRlVXNkblZhbHVlBAUHQXNzZXRJbgUIQW1vdW50SW4FDkFzc2V0SW5CYWxhbmNlBRJmZWVBc3NldE91dEJhbGFuY2UED3ZvbHVtZVVzZFVwZGF0ZQkBEWNhbGN1bGF0ZVVzZFZhbHVlAwUHQXNzZXRJbgUIQW1vdW50SW4FDkFzc2V0SW5CYWxhbmNlCQCUCgIJAMwIAgUOYXNzZXRPdXRDaGFuZ2UJAMwIAgUNYXNzZXRJbkNoYW5nZQkAzAgCBRFmZWVBc3NldE91dENoYW5nZQkAzAgCCQEOU2NyaXB0VHJhbnNmZXIDCAUBaQZjYWxsZXIFCUFtb3VudE91dAUIQXNzZXRPdXQJAMwIAgkBDlNjcmlwdFRyYW5zZmVyAwkBEUBleHRyTmF0aXZlKDEwNjIpAQkBDHRyeUdldFN0cmluZwECEHN0YXRpY19wb29sT3duZXIFCmNyZWF0b3JGZWUFC2ZlZUFzc2V0T3V0CQDMCAIJAQxJbnRlZ2VyRW50cnkCAhRnbG9iYWxfZWFybmVkQnlPd25lcgkAZAIJAQ10cnlHZXRJbnRlZ2VyAQIUZ2xvYmFsX2Vhcm5lZEJ5T3duZXIFCmNyZWF0b3JGZWUJAMwIAgkBDEludGVnZXJFbnRyeQICDWdsb2JhbF92b2x1bWUJAGQCCQENdHJ5R2V0SW50ZWdlcgECDWdsb2JhbF92b2x1bWUFDHZvbHVtZVVwZGF0ZQkAzAgCCQEMSW50ZWdlckVudHJ5AgIRZ2xvYmFsX3ZvbHVtZV91c2QJAGQCCQENdHJ5R2V0SW50ZWdlcgECEWdsb2JhbF92b2x1bWVfdXNkBQ92b2x1bWVVc2RVcGRhdGUJAMwIAgkBDlNjcmlwdFRyYW5zZmVyAwULZmVlc0FkZHJlc3MFC3Byb3RvY29sRmVlBQtmZWVBc3NldE91dAUDbmlsBQlBbW91bnRPdXQBaQEMc3dhcFJlYWRPbmx5Awdhc3NldEluCGFzc2V0T3V0CEFtb3VudEluBAdBc3NldEluCQENZ2V0QXNzZXRCeXRlcwEFB2Fzc2V0SW4ECEFzc2V0T3V0CQENZ2V0QXNzZXRCeXRlcwEFCGFzc2V0T3V0BAdzY2FsZUluCQBpAgUGU2NhbGU4CQENdHJ5R2V0SW50ZWdlcgEJAKwCAgkArAICAgdzdGF0aWNfBQdhc3NldEluAgZfc2NhbGUECHNjYWxlT3V0CQBpAgUGU2NhbGU4CQENdHJ5R2V0SW50ZWdlcgEJAKwCAgkArAICAgdzdGF0aWNfBQhhc3NldE91dAIGX3NjYWxlBA5mZWVBc3NldE91dFN0cgkBDHRyeUdldFN0cmluZwECD3N0YXRpY19mZWVUb2tlbgQLZmVlQXNzZXRPdXQDCQAAAgUOZmVlQXNzZXRPdXRTdHICAAULdXNkbkFzc2V0SWQJAQ1nZXRBc3NldEJ5dGVzAQUOZmVlQXNzZXRPdXRTdHIEDkFzc2V0SW5CYWxhbmNlCQENdHJ5R2V0SW50ZWdlcgEJAKwCAgkArAICAgdnbG9iYWxfCQEOZ2V0QXNzZXRTdHJpbmcBBQdBc3NldEluAghfYmFsYW5jZQQPQXNzZXRPdXRCYWxhbmNlCQENdHJ5R2V0SW50ZWdlcgEJAKwCAgkArAICAgdnbG9iYWxfBQhhc3NldE91dAIIX2JhbGFuY2UEFEFzc2V0SW5CYWxhbmNlU2NhbGVkCQBoAgUOQXNzZXRJbkJhbGFuY2UFB3NjYWxlSW4EFUFzc2V0T3V0QmFsYW5jZVNjYWxlZAkAaAIFD0Fzc2V0T3V0QmFsYW5jZQUIc2NhbGVPdXQEC2ZlZUFtb3VudEluCQBrAwUIQW1vdW50SW4FA0ZlZQUIRmVlU2NhbGUEDWNsZWFuQW1vdW50SW4JAGUCBQhBbW91bnRJbgULZmVlQW1vdW50SW4EE2NsZWFuQW1vdW50SW5TY2FsZWQJAGgCBQ1jbGVhbkFtb3VudEluBQdzY2FsZUluBApBbW91bnRPdXQxCQESY2FsY3VsYXRlT3V0QW1vdW50BQUTY2xlYW5BbW91bnRJblNjYWxlZAUHQXNzZXRJbgUIQXNzZXRPdXQFFEFzc2V0SW5CYWxhbmNlU2NhbGVkBRVBc3NldE91dEJhbGFuY2VTY2FsZWQECUFtb3VudE91dAkAawMFCkFtb3VudE91dDEAAQUIc2NhbGVPdXQEEEFzc2V0T3V0QmFsYW5jZTIJAGUCBQ9Bc3NldE91dEJhbGFuY2UFCUFtb3VudE91dAQPQXNzZXRJbkJhbGFuY2UyCQBkAgUOQXNzZXRJbkJhbGFuY2UFDWNsZWFuQW1vdW50SW4EEmZlZUFzc2V0T3V0QmFsYW5jZQMJAAACBQtmZWVBc3NldE91dAUHQXNzZXRJbgUPQXNzZXRJbkJhbGFuY2UyAwkAAAIFC2ZlZUFzc2V0T3V0BQhBc3NldE91dAUQQXNzZXRPdXRCYWxhbmNlMgkBDXRyeUdldEludGVnZXIBCQCsAgIJAKwCAgIHZ2xvYmFsXwkBDmdldEFzc2V0U3RyaW5nAQULZmVlQXNzZXRPdXQCCF9iYWxhbmNlBAxmZWVBbW91bnRPdXQJARJjYWxjdWxhdGVPdXRBbW91bnQFBQtmZWVBbW91bnRJbgUHQXNzZXRJbgULZmVlQXNzZXRPdXQFDkFzc2V0SW5CYWxhbmNlBRJmZWVBc3NldE91dEJhbGFuY2UDCQAAAgUIQXNzZXRPdXQFB0Fzc2V0SW4JAAIBAhh0aGlzIHN3YXAgaXMgbm90IGFsbG93ZWQDCQBmAgAACQBlAgUPQXNzZXRPdXRCYWxhbmNlBQlBbW91bnRPdXQJAAIBAhtjb250cmFjdCBpcyBvdXQgb2YgcmVzZXJ2ZXMDCQEKaXNTaHV0ZG93bgAJAAIBAhNjb250cmFjdCBpcyBvbiBzdG9wCQCUCgIFA25pbAUJQW1vdW50T3V0AWkBEXRyYW5zZmVyT3duZXJzaGlwAQ9uZXdPd25lckFkZHJlc3MDCQECIT0CCQClCAEIBQFpBmNhbGxlcgkBDHRyeUdldFN0cmluZwECEHN0YXRpY19wb29sT3duZXIJAAIBAid0aGlzIGNhbGwgYXZhaWxhYmxlIG9ubHkgZm9yIHBvb2wgb3duZXIJAMwIAgkBC1N0cmluZ0VudHJ5AgIQc3RhdGljX3Bvb2xPd25lcgUPbmV3T3duZXJBZGRyZXNzBQNuaWwBaQEGc2V0RmVlAQZuZXdGZWUDCQECIT0CCQClCAEIBQFpBmNhbGxlcgkBDHRyeUdldFN0cmluZwECEHN0YXRpY19wb29sT3duZXIJAAIBAid0aGlzIGNhbGwgYXZhaWxhYmxlIG9ubHkgZm9yIHBvb2wgb3duZXIDCQBmAgABCQELdmFsdWVPckVsc2UCCQCaCAIFCmdvdkFkZHJlc3MJAKwCAgILYXBwcm92ZWRUeF8JANgEAQgFAWkNdHJhbnNhY3Rpb25JZAAACQACAQIzdGhpcyB0cmFuc2FjdGlvbiBuZWVkcyBhcHByb3ZhbCBmcm9tIHB1enpsZSBuZXR3b3JrCQDMCAIJAQxJbnRlZ2VyRW50cnkCAgpzdGF0aWNfZmVlBQZuZXdGZWUFA25pbAFpARJzZXRSZWJhbGFuY2luZ1BsYW4FC2Fzc2V0SWRzU3RyD2Fzc2V0V2VpZ2h0c1N0cg5iYXNlVG9rZW5JZFN0cgtzdGVwc0Ftb3VudA1zdGVwc0ludGVydmFsAwkBAiE9AggFAWkGY2FsbGVyCQERQGV4dHJOYXRpdmUoMTA2MikBCQEMdHJ5R2V0U3RyaW5nAQIQc3RhdGljX3Bvb2xPd25lcgkAAgECJ3RoaXMgY2FsbCBhdmFpbGFibGUgb25seSBmb3IgcG9vbCBvd25lcgMJAQt2YWx1ZU9yRWxzZQIJAJsIAgUEdGhpcwIUcmViYWxhbmNlX2luUHJvZ3Jlc3MHCQACAQIXcmViYWxhbmNpbmcgaW4gcHJvZ3Jlc3MEFG5ld0Fzc2V0V2VpZ2h0c1N0ckxpCQC1CQIFD2Fzc2V0V2VpZ2h0c1N0cgIBLAQQbmV3QXNzZXRJZHNTdHJMaQkAtQkCBQthc3NldElkc1N0cgIBLAQLZmVlQXNzZXRTdHIKAAIkbAUQbmV3QXNzZXRJZHNTdHJMaQoAAiRzCQCQAwEFAiRsCgAFJGFjYzACAAoBBSRmNF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQENY2hlY2tGZWVBc3NldAIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmNF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQUkZjRfMgIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgQPYXNzZXRXZWlnaHRzU3VtCgACJGwFFG5ld0Fzc2V0V2VpZ2h0c1N0ckxpCgACJHMJAJADAQUCJGwKAAUkYWNjMAAACgEFJGY1XzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQNzdW0CBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjVfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDEwCQEFJGY1XzICCQEFJGY1XzECCQEFJGY1XzECCQEFJGY1XzECCQEFJGY1XzECCQEFJGY1XzECCQEFJGY1XzECCQEFJGY1XzECCQEFJGY1XzECCQEFJGY1XzECCQEFJGY1XzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoEC29sZEFzc2V0SWRzCQERQGV4dHJOYXRpdmUoMTA1OCkBAg9zdGF0aWNfdG9rZW5JZHMEDW9sZEFzc2V0SWRzTGkJALUJAgULb2xkQXNzZXRJZHMCASwKAQlmaW5kQWRkZWQCBWFjY3VtBG5leHQDCQAAAgkAzwgCBQ1vbGRBc3NldElkc0xpBQRuZXh0BQR1bml0CQDOCAIFBWFjY3VtCQDMCAIFBG5leHQFA25pbAUFYWNjdW0KAQtmaW5kUmVtb3ZlZAIFYWNjdW0EbmV4dAMJAAACCQDPCAIFEG5ld0Fzc2V0SWRzU3RyTGkFBG5leHQFBHVuaXQJAM4IAgUFYWNjdW0JAMwIAgUEbmV4dAUDbmlsBQVhY2N1bQQLYWRkZWRBc3NldHMKAAIkbAUQbmV3QXNzZXRJZHNTdHJMaQoAAiRzCQCQAwEFAiRsCgAFJGFjYzAFA25pbAoBBSRmNl8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEJZmluZEFkZGVkAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGY2XzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxMAkBBSRmNl8yAgkBBSRmNl8xAgkBBSRmNl8xAgkBBSRmNl8xAgkBBSRmNl8xAgkBBSRmNl8xAgkBBSRmNl8xAgkBBSRmNl8xAgkBBSRmNl8xAgkBBSRmNl8xAgkBBSRmNl8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKBA1yZW1vdmVkQXNzZXRzCgACJGwFDW9sZEFzc2V0SWRzTGkKAAIkcwkAkAMBBQIkbAoABSRhY2MwBQNuaWwKAQUkZjdfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBC2ZpbmRSZW1vdmVkAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGY3XzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxMAkBBSRmN18yAgkBBSRmN18xAgkBBSRmN18xAgkBBSRmN18xAgkBBSRmN18xAgkBBSRmN18xAgkBBSRmN18xAgkBBSRmN18xAgkBBSRmN18xAgkBBSRmN18xAgkBBSRmN18xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKBA12YWxpZFBheW1lbnRzCQEQdmFsaWRhdGVQYXltZW50cwIFC2FkZGVkQXNzZXRzCAUBaQhwYXltZW50cwQMdmFsaWRXZWlnaHRzCQEPdmFsaWRhdGVXZWlnaHRzAQUUbmV3QXNzZXRXZWlnaHRzU3RyTGkDCQAAAgUMdmFsaWRXZWlnaHRzBQx2YWxpZFdlaWdodHMDCQECIT0CBQ12YWxpZFBheW1lbnRzCQBkAgkAkAMBBQthZGRlZEFzc2V0cwkAkAMBCAUBaQhwYXltZW50cwkAAgECMVBheW1lbnRzIG5vdCBwcmVzZW50IG9yIHNvbWV0aGluZyB3cm9uZyB3aXRoIHRoZW0DCQECIT0CCQCQAwEFEG5ld0Fzc2V0SWRzU3RyTGkJAJADAQUUbmV3QXNzZXRXZWlnaHRzU3RyTGkJAAIBAjFhc3NldElkcyBhbmQgYXNzZXRXZWlnaHRzIHNob3VsZCBoYXZlIHNhbWUgbGVuZ3RoAwkBAiE9AgUNdmFsaWRQYXltZW50cwkAZAIJAJADAQULYWRkZWRBc3NldHMJAJADAQgFAWkIcGF5bWVudHMJAAIBAjFQYXltZW50cyBub3QgcHJlc2VudCBvciBzb21ldGhpbmcgd3Jvbmcgd2l0aCB0aGVtAwkAAAIFC2ZlZUFzc2V0U3RyAgAJAAIBAkFwb29sIG11c3QgaGF2ZSBvbmUgb2YgdGhlIHN1cHBvcnRlZCBmZWUgYXNzZXRzIGluIHRoZSBjb21wb3NpdGlvbgMJAAACCQDPCAIFEG5ld0Fzc2V0SWRzU3RyTGkFDmJhc2VUb2tlbklkU3RyBQR1bml0CQACAQIpYmFzZVRva2VuSWQgc2hvdWxkIGJlIHByZXNlbnQgaW4gYXNzZXRJZHMDAwkAZgIFEE1JTl9TVEVQU19BTU9VTlQFC3N0ZXBzQW1vdW50BgkAZgIFC3N0ZXBzQW1vdW50BRBNQVhfU1RFUFNfQU1PVU5UCQACAQkArAICCQCsAgIJAKwCAgkArAICCQCsAgICH1N0ZXBzIGFtb3VudCBzaG91bGQgYmUgYmV0d2VlbiAJAKQDAQUQTUlOX1NURVBTX0FNT1VOVAIFIGFuZCAJAKQDAQUQTUFYX1NURVBTX0FNT1VOVAILLCBjdXJyZW50OiAJAKQDAQULc3RlcHNBbW91bnQDAwkAZgIFEk1JTl9TVEVQU19JTlRFUlZBTAUNc3RlcHNJbnRlcnZhbAYJAGYCBQ1zdGVwc0ludGVydmFsBRJNQVhfU1RFUFNfSU5URVJWQUwJAAIBCQCsAgIJAKwCAgkArAICCQCsAgIJAKwCAgIhU3RlcHMgaW50ZXJ2YWwgc2hvdWxkIGJlIGJldHdlZW4gCQCkAwEFEk1JTl9TVEVQU19JTlRFUlZBTAIFIGFuZCAJAKQDAQUSTUFYX1NURVBTX0lOVEVSVkFMAgssIGN1cnJlbnQ6IAkApAMBBQ1zdGVwc0ludGVydmFsAwkBAiE9AgUPYXNzZXRXZWlnaHRzU3VtAJBOCQACAQkArAICAjZzdW0gb2YgdG9rZW4gd2VpZ2h0cyBtdXN0IGJlIGVxdWFsIHRvIDEwMDAwLCBjdXJyZW50OiAJAKQDAQUPYXNzZXRXZWlnaHRzU3VtCgEBZgIFYWNjdW0KYXNzZXRJZFN0cgQJb2xkV2VpZ2h0CQENdHJ5R2V0SW50ZWdlcgEJAKwCAgkArAICAgdzdGF0aWNfBQphc3NldElkU3RyAgdfd2VpZ2h0BAluZXdXZWlnaHQDCQAAAgkAzwgCBRBuZXdBc3NldElkc1N0ckxpBQphc3NldElkU3RyBQR1bml0AAAJAQ1wYXJzZUludFZhbHVlAQkBBXZhbHVlAQkAkQMCBRRuZXdBc3NldFdlaWdodHNTdHJMaQkBBXZhbHVlAQkAzwgCBRBuZXdBc3NldElkc1N0ckxpBQphc3NldElkU3RyBAxkZWx0YVBlclN0ZXAJAGsDCQBlAgUJbmV3V2VpZ2h0BQlvbGRXZWlnaHQAkE4FC3N0ZXBzQW1vdW50CQDOCAIFBWFjY3VtCQDMCAIJAKQDAQUMZGVsdGFQZXJTdGVwBQNuaWwEDXRtcEFzc2V0SWRzTGkJARJnZXRUbXBSZWJhbGFuY2VJZHMBBRBuZXdBc3NldElkc1N0ckxpBAthc3NldERlbHRhcwoAAiRsBQ10bXBBc3NldElkc0xpCgACJHMJAJADAQUCJGwKAAUkYWNjMAUDbmlsCgEFJGY4XzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQFmAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGY4XzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxMAkBBSRmOF8yAgkBBSRmOF8xAgkBBSRmOF8xAgkBBSRmOF8xAgkBBSRmOF8xAgkBBSRmOF8xAgkBBSRmOF8xAgkBBSRmOF8xAgkBBSRmOF8xAgkBBSRmOF8xAgkBBSRmOF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKBA5uZXdUb2tlbnNBZGRlZAkAZgIJARFjaGVja1Rva2Vuc0NoYW5nZQEFEG5ld0Fzc2V0SWRzU3RyTGkAAAoBEnJlY29yZEFzc2V0UGF5bWVudAIFYWNjdW0EbmV4dAkAzggCBQVhY2N1bQkAzAgCCQEMSW50ZWdlckVudHJ5AgkArAICAhpyZWJhbGFuY2VfYXR0YWNoZWRQYXltZW50XwkBDmdldEFzc2V0U3RyaW5nAQgFBG5leHQHYXNzZXRJZAgFBG5leHQGYW1vdW50BQNuaWwEDnBheW1lbnRFbnRyaWVzCgACJGwIBQFpCHBheW1lbnRzCgACJHMJAJADAQUCJGwKAAUkYWNjMAUDbmlsCgEFJGY5XzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJARJyZWNvcmRBc3NldFBheW1lbnQCBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjlfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDEwCQEFJGY5XzICCQEFJGY5XzECCQEFJGY5XzECCQEFJGY5XzECCQEFJGY5XzECCQEFJGY5XzECCQEFJGY5XzECCQEFJGY5XzECCQEFJGY5XzECCQEFJGY5XzECCQEFJGY5XzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoEDHN0b3JlV2VpZ2h0cwkBEnNhdmVDdXJyZW50V2VpZ2h0cwAEEHJlcXVlc3RHb3ZJbnZva2UJAPwHBAUKZ292QWRkcmVzcwIScmVxdWVzdFJlYmFsYW5jaW5nCQDMCAIJANgEAQgFAWkNdHJhbnNhY3Rpb25JZAUDbmlsBQNuaWwDCQAAAgUQcmVxdWVzdEdvdkludm9rZQUQcmVxdWVzdEdvdkludm9rZQkAzggCCQDOCAIJAMwIAgkBC1N0cmluZ0VudHJ5AgIVcmViYWxhbmNlX2FkZGVkQXNzZXRzCQC5CQIFC2FkZGVkQXNzZXRzAgEsCQDMCAIJAQtTdHJpbmdFbnRyeQICF3JlYmFsYW5jZV9yZW1vdmVkQXNzZXRzCQC5CQIFDXJlbW92ZWRBc3NldHMCASwJAMwIAgkBC1N0cmluZ0VudHJ5AgIVdG1wX3JlYmFsYW5jZUFzc2V0SWRzCQC5CQIFDXRtcEFzc2V0SWRzTGkCASwJAMwIAgkBDEJvb2xlYW5FbnRyeQICFHJlYmFsYW5jZV9pblByb2dyZXNzBgkAzAgCCQEMQm9vbGVhbkVudHJ5AgIYcmViYWxhbmNlX25ld1Rva2Vuc0FkZGVkBQ5uZXdUb2tlbnNBZGRlZAkAzAgCCQEMSW50ZWdlckVudHJ5AgITcmViYWxhbmNlX3N0ZXBzRG9uZQAACQDMCAIJAQxJbnRlZ2VyRW50cnkCAhhyZWJhbGFuY2VfbGFzdFN0ZXBIZWlnaHQFBmhlaWdodAkAzAgCCQEMSW50ZWdlckVudHJ5AgIVcmViYWxhbmNlX3N0ZXBzQW1vdW50BQtzdGVwc0Ftb3VudAkAzAgCCQEMSW50ZWdlckVudHJ5AgIXcmViYWxhbmNlX3N0ZXBzSW50ZXJ2YWwFDXN0ZXBzSW50ZXJ2YWwJAMwIAgkBC1N0cmluZ0VudHJ5AgIScmViYWxhbmNlX2Fzc2V0SWRzBQthc3NldElkc1N0cgkAzAgCCQELU3RyaW5nRW50cnkCAhhyZWJhbGFuY2VfbmV3QmFzZVRva2VuSWQFDmJhc2VUb2tlbklkU3RyCQDMCAIJAQtTdHJpbmdFbnRyeQICFXJlYmFsYW5jZV9hc3NldERlbHRhcwkAuQkCBQthc3NldERlbHRhcwIBLAUDbmlsBQ5wYXltZW50RW50cmllcwUMc3RvcmVXZWlnaHRzCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAWkBD3N0ZXBSZWJhbGFuY2luZwAEBXJlYklkCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAJ0IAgUKZ292QWRkcmVzcwkArAICAhVwb29sX2xhc3RSZWJhbGFuY2luZ18JAKUIAQUEdGhpcwIscmViYWxhbmNpbmcgaXMgbm90IHJlZ2lzdGVyZWQgYXQgZ292IGFkZHJlc3MDCQEBIQEJAQt2YWx1ZU9yRWxzZQIJAJsIAgUEdGhpcwIUcmViYWxhbmNlX2luUHJvZ3Jlc3MHCQACAQIabm8gcmViYWxhbmNpbmcgaW4gcHJvZ3Jlc3MDCQECIT0CCQELdmFsdWVPckVsc2UCCQCaCAIFCmdvdkFkZHJlc3MJAKwCAgITcmViYWxhbmNpbmdfc3RhdHVzXwUFcmViSWQAAAACCQACAQIzdGhpcyB0cmFuc2FjdGlvbiBuZWVkcyBhcHByb3ZhbCBmcm9tIHB1enpsZSBuZXR3b3JrBA5sYXN0U3RlcEhlaWdodAkBEUBleHRyTmF0aXZlKDEwNTUpAQIYcmViYWxhbmNlX2xhc3RTdGVwSGVpZ2h0BAxzdGVwSW50ZXJ2YWwJARFAZXh0ck5hdGl2ZSgxMDU1KQECF3JlYmFsYW5jZV9zdGVwc0ludGVydmFsBAlzdGVwc0RvbmUJARFAZXh0ck5hdGl2ZSgxMDU1KQECE3JlYmFsYW5jZV9zdGVwc0RvbmUEDm5leHRTdGVwSGVpZ2h0CQBkAgUObGFzdFN0ZXBIZWlnaHQFDHN0ZXBJbnRlcnZhbAMJAGYCBQ5uZXh0U3RlcEhlaWdodAUGaGVpZ2h0CQACAQIRY2FuJ3QgYmUgZG9uZSB5ZXQEC2Fzc2V0RGVsdGFzCQC1CQIJARFAZXh0ck5hdGl2ZSgxMDU4KQECFXJlYmFsYW5jZV9hc3NldERlbHRhcwIBLAQObmV3QXNzZXRJZHNTdHIJARFAZXh0ck5hdGl2ZSgxMDU4KQECFXRtcF9yZWJhbGFuY2VBc3NldElkcwQLbmV3QXNzZXRJZHMJALUJAgUObmV3QXNzZXRJZHNTdHICASwKAQFmAgVhY2N1bQphc3NldElkU3RyCQDOCAIFBWFjY3VtCQDMCAIJAKQDAQkAbgQJAGQCCQBoAgkBC3ZhbHVlT3JFbHNlAgkAnwgBCQCsAgICFnJlYmFsYW5jZV9zdGFydFdlaWdodF8FCmFzc2V0SWRTdHIAAACQTgkAaAIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQthc3NldERlbHRhcwkBBXZhbHVlAQkAzwgCBQtuZXdBc3NldElkcwUKYXNzZXRJZFN0cgkAZAIFCXN0ZXBzRG9uZQABAAEAkE4FBkhBTEZVUAUDbmlsBAluZXdTaGFyZXMJALkJAgoAAiRsBQtuZXdBc3NldElkcwoAAiRzCQCQAwEFAiRsCgAFJGFjYzAFA25pbAoBBSRmNF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEBZgIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmNF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQUkZjRfMgIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgIBLAQObmV3VG9rZW5zQWRkZWQJARFAZXh0ck5hdGl2ZSgxMDU2KQECGHJlYmFsYW5jZV9uZXdUb2tlbnNBZGRlZAQDaW52AwMFDm5ld1Rva2Vuc0FkZGVkCQAAAgUJc3RlcHNEb25lAAAHCQD8BwQFBHRoaXMCGmRvUmViYWxhbmNpbmdXaXRoTmV3VG9rZW5zCQDMCAIFDm5ld0Fzc2V0SWRzU3RyCQDMCAIFCW5ld1NoYXJlcwkAzAgCCQERQGV4dHJOYXRpdmUoMTA1OCkBAhhyZWJhbGFuY2VfbmV3QmFzZVRva2VuSWQFA25pbAUDbmlsCQD8BwQFBHRoaXMCDWRvUmViYWxhbmNpbmcJAMwIAgUJbmV3U2hhcmVzBQNuaWwFA25pbAMJAAACBQNpbnYFA2ludgQMbm90aWZ5SW52b2tlCQD8BwQFD3Bvb2xzSHViQWRkcmVzcwIQbm90aWZ5UG9vbENoYW5nZQUDbmlsBQNuaWwDCQAAAgUMbm90aWZ5SW52b2tlBQxub3RpZnlJbnZva2UECmlzRmluaXNoZWQJAGcCCQBkAgUJc3RlcHNEb25lAAEJARFAZXh0ck5hdGl2ZSgxMDU1KQECFXJlYmFsYW5jZV9zdGVwc0Ftb3VudAQHYWN0aW9ucwkAzAgCCQEMQm9vbGVhbkVudHJ5AgIUcmViYWxhbmNlX2luUHJvZ3Jlc3MJAQEhAQUKaXNGaW5pc2hlZAkAzAgCCQEMSW50ZWdlckVudHJ5AgITcmViYWxhbmNlX3N0ZXBzRG9uZQkAZAIFCXN0ZXBzRG9uZQABCQDMCAIJAQxJbnRlZ2VyRW50cnkCAhhyZWJhbGFuY2VfbGFzdFN0ZXBIZWlnaHQFBmhlaWdodAUDbmlsAwkAAAIFCXN0ZXBzRG9uZQAACQDOCAIFB2FjdGlvbnMJAMwIAgkBC1N0cmluZ0VudHJ5AgIPc3RhdGljX3Rva2VuSWRzBQ5uZXdBc3NldElkc1N0cgUDbmlsAwUKaXNGaW5pc2hlZAQPcmVtb3ZlZEFzc2V0c0xpCQC1CQIJAQx0cnlHZXRTdHJpbmcBAhdyZWJhbGFuY2VfcmVtb3ZlZEFzc2V0cwIBLAoBBnJtRGF0YQIFYWNjdW0HYXNzZXRJZAkAzggCBQVhY2N1bQkAzAgCCQELRGVsZXRlRW50cnkBCQCsAgIJAKwCAgIHc3RhdGljXwUHYXNzZXRJZAIGX3NjYWxlCQDMCAIJAQtEZWxldGVFbnRyeQEJAKwCAgkArAICAgdzdGF0aWNfBQdhc3NldElkAglfZGVjaW1hbHMJAMwIAgkBC0RlbGV0ZUVudHJ5AQkArAICCQCsAgICB3N0YXRpY18FB2Fzc2V0SWQCB193ZWlnaHQJAMwIAgkBC0RlbGV0ZUVudHJ5AQkArAICCQCsAgICB2dsb2JhbF8FB2Fzc2V0SWQCCF9iYWxhbmNlCQDMCAIJAQtEZWxldGVFbnRyeQEJAKwCAgIacmViYWxhbmNlX2F0dGFjaGVkUGF5bWVudF8FB2Fzc2V0SWQFA25pbAQCcm0KAAIkbAUPcmVtb3ZlZEFzc2V0c0xpCgACJHMJAJADAQUCJGwKAAUkYWNjMAUDbmlsCgEFJGY1XzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQZybURhdGECBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjVfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDEwCQEFJGY1XzICCQEFJGY1XzECCQEFJGY1XzECCQEFJGY1XzECCQEFJGY1XzECCQEFJGY1XzECCQEFJGY1XzECCQEFJGY1XzECCQEFJGY1XzECCQEFJGY1XzECCQEFJGY1XzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoEDWFkZGVkQXNzZXRzTGkJALUJAgkBDHRyeUdldFN0cmluZwECFXJlYmFsYW5jZV9hZGRlZEFzc2V0cwIBLAoBEWFkZFJlbW92ZVBheW1lbnRzAgVhY2N1bQdhc3NldElkCQDOCAIFBWFjY3VtCQDMCAIJAQtEZWxldGVFbnRyeQEJAKwCAgIacmViYWxhbmNlX2F0dGFjaGVkUGF5bWVudF8FB2Fzc2V0SWQFA25pbAQKcm1QYXltZW50cwoAAiRsBQ1hZGRlZEFzc2V0c0xpCgACJHMJAJADAQUCJGwKAAUkYWNjMAUDbmlsCgEFJGY2XzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJARFhZGRSZW1vdmVQYXltZW50cwIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmNl8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQUkZjZfMgIJAQUkZjZfMQIJAQUkZjZfMQIJAQUkZjZfMQIJAQUkZjZfMQIJAQUkZjZfMQIJAQUkZjZfMQIJAQUkZjZfMQIJAQUkZjZfMQIJAQUkZjZfMQIJAQUkZjZfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgQRZmluYWxBc3NldHNJZHNTdHIJAQx0cnlHZXRTdHJpbmcBAhJyZWJhbGFuY2VfYXNzZXRJZHMEEEFzc2V0c1dlaWdodHNTdHIKAAIkbAkAtQkCBRFmaW5hbEFzc2V0c0lkc1N0cgIBLAoAAiRzCQCQAwEFAiRsCgAFJGFjYzAFA25pbAoBBSRmN18xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEXYWRkQXNzZXRXZWlnaHRUb1N0ckxpc3QCBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjdfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDEwCQEFJGY3XzICCQEFJGY3XzECCQEFJGY3XzECCQEFJGY3XzECCQEFJGY3XzECCQEFJGY3XzECCQEFJGY3XzECCQEFJGY3XzECCQEFJGY3XzECCQEFJGY3XzECCQEFJGY3XzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoEBm5vdGlmeQkA/AcEBQpnb3ZBZGRyZXNzAhVub3RpZnlSZWJhbGFuY2luZ0RvbmUJAMwIAgUFcmViSWQFA25pbAUDbmlsAwkAAAIFBm5vdGlmeQUGbm90aWZ5CQDOCAIJAM4IAgkAzggCBQdhY3Rpb25zBQJybQUKcm1QYXltZW50cwkAzAgCCQELU3RyaW5nRW50cnkCAg9zdGF0aWNfdG9rZW5JZHMFEWZpbmFsQXNzZXRzSWRzU3RyCQDMCAIJAQtTdHJpbmdFbnRyeQICE3N0YXRpY190b2tlbldlaWdodHMJALkJAgUQQXNzZXRzV2VpZ2h0c1N0cgIBLAkAzAgCCQEMSW50ZWdlckVudHJ5AgITc3RhdGljX3Rva2Vuc0Ftb3VudAkAkAMBCQC1CQIFEWZpbmFsQXNzZXRzSWRzU3RyAgEsBQNuaWwJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4EEWZpbmFsQXNzZXRzSWRzU3RyCQEMdHJ5R2V0U3RyaW5nAQIScmViYWxhbmNlX2Fzc2V0SWRzBBBBc3NldHNXZWlnaHRzU3RyCgACJGwJALUJAgURZmluYWxBc3NldHNJZHNTdHICASwKAAIkcwkAkAMBBQIkbAoABSRhY2MwBQNuaWwKAQUkZjVfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBF2FkZEFzc2V0V2VpZ2h0VG9TdHJMaXN0AgUCJGEJAJEDAgUCJGwFAiRpCgEFJGY1XzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxMAkBBSRmNV8yAgkBBSRmNV8xAgkBBSRmNV8xAgkBBSRmNV8xAgkBBSRmNV8xAgkBBSRmNV8xAgkBBSRmNV8xAgkBBSRmNV8xAgkBBSRmNV8xAgkBBSRmNV8xAgkBBSRmNV8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKCQDOCAIFB2FjdGlvbnMJAMwIAgkBC1N0cmluZ0VudHJ5AgITc3RhdGljX3Rva2VuV2VpZ2h0cwkAuQkCBRBBc3NldHNXZWlnaHRzU3RyAgEsBQNuaWwJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BaQENZG9SZWJhbGFuY2luZwEPYXNzZXRXZWlnaHRzU3RyBBFhc3NldFdlaWdodHNTdHJMaQkAtQkCBQ9hc3NldFdlaWdodHNTdHICASwED2Fzc2V0V2VpZ2h0c1N1bQoAAiRsBRFhc3NldFdlaWdodHNTdHJMaQoAAiRzCQCQAwEFAiRsCgAFJGFjYzAAAAoBBSRmNF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQEDc3VtAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGY0XzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxMAkBBSRmNF8yAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgkBBSRmNF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKBA1hc3NldElkc1N0ckxpCQC1CQIJAQx0cnlHZXRTdHJpbmcBAg9zdGF0aWNfdG9rZW5JZHMCASwDCQECIT0CCAUBaQZjYWxsZXIFBHRoaXMJAAIBAiJ0aGlzIGNhbGwgYXZhaWxhYmxlIG9ubHkgZm9yIGFkbWluBAhvbGRLTXVsdAkBCGdldEtNdWx0AAoBB2hhbmRsZXICBHBhcnMHYXNzZXRJZAQFYWNjdW0IBQRwYXJzAl8xBAphc3NldElkU3RyCQEOZ2V0QXNzZXRTdHJpbmcBBQdhc3NldElkCgEIaGFuZGxlcjICBWFjY3VtAW4DCQAAAgUBbgUHYXNzZXRJZAkBBXZhbHVlAQkAzwgCBQhhc3NldElkcwUBbgUFYWNjdW0EBVRva2VuCgACJGwFCGFzc2V0SWRzCgACJHMJAJADAQUCJGwKAAUkYWNjMAABCgEFJGY1XzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQhoYW5kbGVyMgIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmNV8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQUkZjVfMgIJAQUkZjVfMQIJAQUkZjVfMQIJAQUkZjVfMQIJAQUkZjVfMQIJAQUkZjVfMQIJAQUkZjVfMQIJAQUkZjVfMQIJAQUkZjVfMQIJAQUkZjVfMQIJAQUkZjVfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgQHYmFsYW5jZQkBDXRyeUdldEludGVnZXIBCQCsAgIJAKwCAgIHZ2xvYmFsXwUKYXNzZXRJZFN0cgIIX2JhbGFuY2UEBndlaWdodAMJAAACCAUEcGFycwJfMgIDbmV3CQENcGFyc2VJbnRWYWx1ZQEJAJEDAgURYXNzZXRXZWlnaHRzU3RyTGkFBVRva2VuCQENdHJ5R2V0SW50ZWdlcgEJAKwCAgkArAICAgdzdGF0aWNfBQphc3NldElkU3RyAgdfd2VpZ2h0CQCUCgIJAGsDBQVhY2N1bQkAbAYFB2JhbGFuY2UJAJEDAgUIRGVjaW1hbHMFBVRva2VuBQZ3ZWlnaHQFFUFzc2V0c1dlaWdodHNEZWNpbWFscwAIBQVGTE9PUgUGU2NhbGU4CAUEcGFycwJfMgQEbmV3SwgKAAIkbAUIYXNzZXRJZHMKAAIkcwkAkAMBBQIkbAoABSRhY2MwCQCUCgIFDlBvb2xUb2tlblNjYWxlAgNuZXcKAQUkZjVfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBB2hhbmRsZXICBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjVfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDEwCQEFJGY1XzICCQEFJGY1XzECCQEFJGY1XzECCQEFJGY1XzECCQEFJGY1XzECCQEFJGY1XzECCQEFJGY1XzECCQEFJGY1XzECCQEFJGY1XzECCQEFJGY1XzECCQEFJGY1XzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoCXzEEBG9sZEsICgACJGwFCGFzc2V0SWRzCgACJHMJAJADAQUCJGwKAAUkYWNjMAkAlAoCBQ5Qb29sVG9rZW5TY2FsZQIDb2xkCgEFJGY2XzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQdoYW5kbGVyAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGY2XzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxMAkBBSRmNl8yAgkBBSRmNl8xAgkBBSRmNl8xAgkBBSRmNl8xAgkBBSRmNl8xAgkBBSRmNl8xAgkBBSRmNl8xAgkBBSRmNl8xAgkBBSRmNl8xAgkBBSRmNl8xAgkBBSRmNl8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKAl8xBAhuZXdLTXVsdAkAawMFCG9sZEtNdWx0BQRuZXdLBQRvbGRLCgETYWRkVG9rZW5EYXRhRW50cmllcwIFYWNjdW0IYXNzZXROdW0DCQBnAgUIYXNzZXROdW0JAJADAQURYXNzZXRXZWlnaHRzU3RyTGkFBWFjY3VtCQDOCAIFBWFjY3VtCQDMCAIJAQxJbnRlZ2VyRW50cnkCCQCsAgIJAKwCAgIHc3RhdGljXwkAkQMCBQ1hc3NldElkc1N0ckxpBQhhc3NldE51bQIHX3dlaWdodAkBBXZhbHVlAQkAtgkBCQCRAwIFEWFzc2V0V2VpZ2h0c1N0ckxpBQhhc3NldE51bQUDbmlsCQDOCAIKAAIkbAkAzAgCAAAJAMwIAgABCQDMCAIAAgkAzAgCAAMJAMwIAgAECQDMCAIABQkAzAgCAAYJAMwIAgAHCQDMCAIACAkAzAgCAAkFA25pbAoAAiRzCQCQAwEFAiRsCgAFJGFjYzAFA25pbAoBBSRmN18xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQETYWRkVG9rZW5EYXRhRW50cmllcwIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmN18yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQUkZjdfMgIJAQUkZjdfMQIJAQUkZjdfMQIJAQUkZjdfMQIJAQUkZjdfMQIJAQUkZjdfMQIJAQUkZjdfMQIJAQUkZjdfMQIJAQUkZjdfMQIJAQUkZjdfMQIJAQUkZjdfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgkAzAgCCQEMSW50ZWdlckVudHJ5AgIMc3RhdGljX0tNdWx0BQhuZXdLTXVsdAUDbmlsAWkBGmRvUmViYWxhbmNpbmdXaXRoTmV3VG9rZW5zAwthc3NldElkc1N0cg9hc3NldFdlaWdodHNTdHIOYmFzZVRva2VuSWRTdHIEFG5ld0Fzc2V0V2VpZ2h0c1N0ckxpCQC1CQIFD2Fzc2V0V2VpZ2h0c1N0cgIBLAQRcHJldkFzc2V0SWRzU3RyTGkJALUJAgkBDHRyeUdldFN0cmluZwECD3N0YXRpY190b2tlbklkcwIBLAQQbmV3QXNzZXRJZHNTdHJMaQkAtQkCBQthc3NldElkc1N0cgIBLAQLbmV3QXNzZXRJZHMKAAIkbAUQbmV3QXNzZXRJZHNTdHJMaQoAAiRzCQCQAwEFAiRsCgAFJGFjYzAFA25pbAoBBSRmNF8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQETYWRkQXNzZXRCeXRlc1RvTGlzdAIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmNF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQUkZjRfMgIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIJAQUkZjRfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgQLZmVlQXNzZXRTdHIKAAIkbAUQbmV3QXNzZXRJZHNTdHJMaQoAAiRzCQCQAwEFAiRsCgAFJGFjYzACAAoBBSRmNV8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQENY2hlY2tGZWVBc3NldAIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmNV8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQUkZjVfMgIJAQUkZjVfMQIJAQUkZjVfMQIJAQUkZjVfMQIJAQUkZjVfMQIJAQUkZjVfMQIJAQUkZjVfMQIJAQUkZjVfMQIJAQUkZjVfMQIJAQUkZjVfMQIJAQUkZjVfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgQLYWRkZWRBc3NldHMJALUJAgkBDHRyeUdldFN0cmluZwECFXJlYmFsYW5jZV9hZGRlZEFzc2V0cwIBLAoBEGZpbmRBc3NldFBheW1lbnQBB2Fzc2V0SWQJAQt2YWx1ZU9yRWxzZQIJAJ8IAQkArAICAhpyZWJhbGFuY2VfYXR0YWNoZWRQYXltZW50XwkBDmdldEFzc2V0U3RyaW5nAQUHYXNzZXRJZAAACgETYWRkQXNzZXRCYWxhbmNlVG9MaQICbGkHYXNzZXRJZAkAzggCBQJsaQkAzAgCCQEQZmluZEFzc2V0UGF5bWVudAEFB2Fzc2V0SWQFA25pbAQQYXR0YWNoZWRCYWxhbmNlcwoAAiRsBQtuZXdBc3NldElkcwoAAiRzCQCQAwEFAiRsCgAFJGFjYzAFA25pbAoBBSRmNl8xAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQETYWRkQXNzZXRCYWxhbmNlVG9MaQIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmNl8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQUkZjZfMgIJAQUkZjZfMQIJAQUkZjZfMQIJAQUkZjZfMQIJAQUkZjZfMQIJAQUkZjZfMQIJAQUkZjZfMQIJAQUkZjZfMQIJAQUkZjZfMQIJAQUkZjZfMQIJAQUkZjZfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgMJAQIhPQIIBQFpBmNhbGxlcgUEdGhpcwkAAgEJAKwCAgIkdGhpcyBjYWxsIGF2YWlsYWJsZSBvbmx5IGZvciBhZG1pbiwgCQClCAEIBQFpBmNhbGxlcgQIb2xkS011bHQJAQhnZXRLTXVsdAAEBG9sZEsJARlnZXRWaXJ0dWFsUG9vbFRva2VuQW1vdW50AAoBEm15bHRpcGx5QXNzZXRzRm9ySwIEcGFycwdhc3NldElkCgEMZmluZEFzc2V0TnVtAgVhY2N1bQFuAwkAAAIFAW4FB2Fzc2V0SWQJAQV2YWx1ZQEJAM8IAgULbmV3QXNzZXRJZHMFAW4FBWFjY3VtBAhjdXJyZW50SwUEcGFycwQKYXNzZXRJZFN0cgkBDmdldEFzc2V0U3RyaW5nAQUHYXNzZXRJZAQIVG9rZW5OdW0KAAIkbAULbmV3QXNzZXRJZHMKAAIkcwkAkAMBBQIkbAoABSRhY2MwAAEKAQUkZjdfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBDGZpbmRBc3NldE51bQIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmN18yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTAJAQUkZjdfMgIJAQUkZjdfMQIJAQUkZjdfMQIJAQUkZjdfMQIJAQUkZjdfMQIJAQUkZjdfMQIJAQUkZjdfMQIJAQUkZjdfMQIJAQUkZjdfMQIJAQUkZjdfMQIJAQUkZjdfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgQGd2VpZ2h0CQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUUbmV3QXNzZXRXZWlnaHRzU3RyTGkFCFRva2VuTnVtBA5iYWxhbmNlSW5TdGF0ZQkBDXRyeUdldEludGVnZXIBCQCsAgIJAKwCAgIHZ2xvYmFsXwUKYXNzZXRJZFN0cgIIX2JhbGFuY2UEEGJhbGFuY2VJblBheW1lbnQJAJEDAgUQYXR0YWNoZWRCYWxhbmNlcwUIVG9rZW5OdW0EB2JhbGFuY2UJAGQCBQ5iYWxhbmNlSW5TdGF0ZQUQYmFsYW5jZUluUGF5bWVudAQNYXNzZXREZWNpbWFscwMJAAACBQdhc3NldElkBQR1bml0AAgICQEFdmFsdWUBCQDsBwEJAQV2YWx1ZQEFB2Fzc2V0SWQIZGVjaW1hbHMDCQBnAgAABQdiYWxhbmNlCQACAQkArAICAkR5b3UgbmVlZCB0byBhdHRhY2ggYWxsIG5ldyBhc3NldHMgaW4gcGF5bWVudC4gdGhpcyBhc3NldCBpcyBtaXNzZWQ6IAUKYXNzZXRJZFN0cgkAawMFCGN1cnJlbnRLCQBsBgUHYmFsYW5jZQUNYXNzZXREZWNpbWFscwUGd2VpZ2h0BRVBc3NldHNXZWlnaHRzRGVjaW1hbHMACAUFRkxPT1IFBlNjYWxlOAQEbmV3SwoAAiRsBQtuZXdBc3NldElkcwoAAiRzCQCQAwEFAiRsCgAFJGFjYzAFDlBvb2xUb2tlblNjYWxlCgEFJGY3XzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJARJteWx0aXBseUFzc2V0c0ZvcksCBQIkYQkAkQMCBQIkbAUCJGkKAQUkZjdfMgICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkAAgECFExpc3Qgc2l6ZSBleGNlZWRzIDEwCQEFJGY3XzICCQEFJGY3XzECCQEFJGY3XzECCQEFJGY3XzECCQEFJGY3XzECCQEFJGY3XzECCQEFJGY3XzECCQEFJGY3XzECCQEFJGY3XzECCQEFJGY3XzECCQEFJGY3XzECBQUkYWNjMAAAAAEAAgADAAQABQAGAAcACAAJAAoECG5ld0tNdWx0CQBrAwUIb2xkS011bHQFBG5ld0sFBG9sZEsKARNhZGRUb2tlbkRhdGFFbnRyaWVzAgVhY2N1bQhhc3NldE51bQQKYXNzZXRJZFN0cgkAkQMCBRBuZXdBc3NldElkc1N0ckxpBQhhc3NldE51bQQHYXNzZXRJZAkAkQMCBQtuZXdBc3NldElkcwUIYXNzZXROdW0EDWFzc2V0RGVjaW1hbHMDCQAAAgUHYXNzZXRJZAUEdW5pdAAICAkBBXZhbHVlAQkA7AcBCQEFdmFsdWUBBQdhc3NldElkCGRlY2ltYWxzBAxuZXdBc3NldERhdGEDCQECIT0CCQDPCAIFC2FkZGVkQXNzZXRzBQphc3NldElkU3RyBQR1bml0CQDMCAIJAQxJbnRlZ2VyRW50cnkCCQCsAgIJAKwCAgIHZ2xvYmFsXwUKYXNzZXRJZFN0cgIIX2JhbGFuY2UJAJEDAgUQYXR0YWNoZWRCYWxhbmNlcwUIYXNzZXROdW0JAMwIAgkBDEludGVnZXJFbnRyeQIJAKwCAgkArAICAgdzdGF0aWNfBQphc3NldElkU3RyAgZfc2NhbGUJAGwGAAoAAAUNYXNzZXREZWNpbWFscwAAAAAFBERPV04JAMwIAgkBDEludGVnZXJFbnRyeQIJAKwCAgkArAICAgdzdGF0aWNfBQphc3NldElkU3RyAglfZGVjaW1hbHMFDWFzc2V0RGVjaW1hbHMFA25pbAUDbmlsAwkAZwIFCGFzc2V0TnVtCQCQAwEFFG5ld0Fzc2V0V2VpZ2h0c1N0ckxpBQVhY2N1bQkAzggCCQDOCAIFBWFjY3VtCQDMCAIJAQxJbnRlZ2VyRW50cnkCCQCsAgIJAKwCAgIHc3RhdGljXwUKYXNzZXRJZFN0cgIHX3dlaWdodAkBBXZhbHVlAQkAtgkBCQCRAwIFFG5ld0Fzc2V0V2VpZ2h0c1N0ckxpBQhhc3NldE51bQUDbmlsBQxuZXdBc3NldERhdGEJAM4IAgoAAiRsCQDMCAIAAAkAzAgCAAEJAMwIAgACCQDMCAIAAwkAzAgCAAQJAMwIAgAFCQDMCAIABgkAzAgCAAcJAMwIAgAICQDMCAIACQUDbmlsCgACJHMJAJADAQUCJGwKAAUkYWNjMAUDbmlsCgEFJGY4XzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJARNhZGRUb2tlbkRhdGFFbnRyaWVzAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGY4XzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAxMAkBBSRmOF8yAgkBBSRmOF8xAgkBBSRmOF8xAgkBBSRmOF8xAgkBBSRmOF8xAgkBBSRmOF8xAgkBBSRmOF8xAgkBBSRmOF8xAgkBBSRmOF8xAgkBBSRmOF8xAgkBBSRmOF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKCQDMCAIJAQtTdHJpbmdFbnRyeQICD3N0YXRpY190b2tlbklkcwULYXNzZXRJZHNTdHIJAMwIAgkBC1N0cmluZ0VudHJ5AgIPc3RhdGljX2ZlZVRva2VuBQtmZWVBc3NldFN0cgkAzAgCCQELU3RyaW5nRW50cnkCAhNzdGF0aWNfdG9rZW5XZWlnaHRzBQ9hc3NldFdlaWdodHNTdHIJAMwIAgkBDEludGVnZXJFbnRyeQICE3N0YXRpY190b2tlbnNBbW91bnQJAJADAQULbmV3QXNzZXRJZHMJAMwIAgkBDEludGVnZXJFbnRyeQICDHN0YXRpY19LTXVsdAUIbmV3S011bHQFA25pbAECdHgBBnZlcmlmeQADAwkAAAIJAQt2YWx1ZU9yRWxzZQIJAJ8IAQITZ2xvYmFsX3dhc1ByZUluaXRlZAAAAAADCQD0AwMIBQJ0eAlib2R5Qnl0ZXMJAJEDAggFAnR4BnByb29mcwAACAUCdHgPc2VuZGVyUHVibGljS2V5BgkA9AMDCAUCdHgJYm9keUJ5dGVzCQCRAwIIBQJ0eAZwcm9vZnMAAAUMbWFzdGVyUHViS2V5BwYEByRtYXRjaDAFAnR4AwkAAQIFByRtYXRjaDACFFNldFNjcmlwdFRyYW5zYWN0aW9uBAJ0eAUHJG1hdGNoMAQKc2NyaXB0RnVsbAkBBXZhbHVlAQgFAnR4BnNjcmlwdAQEaGFzaAkA2AQBCQD3AwEFCnNjcmlwdEZ1bGwDCQD0AwMIBQJ0eAlib2R5Qnl0ZXMJAJEDAggFAnR4BnByb29mcwAABQxtYXN0ZXJQdWJLZXkJAGYCCQELdmFsdWVPckVsc2UCCQCaCAIFEWNvbGRNYXN0ZXJBZGRyZXNzCQCsAgICD2FwcHJvdmVkU2NyaXB0XwUEaGFzaAAABQZoZWlnaHQHAwkA9AMDCAUCdHgJYm9keUJ5dGVzCQCRAwIIBQJ0eAZwcm9vZnMAAAUMbWFzdGVyUHViS2V5CQBmAgkBC3ZhbHVlT3JFbHNlAgkAmggCBRFjb2xkTWFzdGVyQWRkcmVzcwkArAICAgthcHByb3ZlZFR4XwkA2AQBCAUCdHgCaWQAAAAAB2vb2Ig=",
    "height": 4141406,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 9Uw7xVa33m8ZWysVTAHbfmPYJhhgymMTAqNtZmjSmviv
Next: none

Diff: 

OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
4-let a = "PZ-1.0.11 PROD"
4+let a = "PZ-1.2.3 PROD"
55 
66 let b = valueOrElse(getString(this, "configAddress"), "3PPEBRg4s2af2rQ2ZbLvdu1Hfd4Vo6QVDTo")
77 
132132 
133133 let O = valueOrElse(getString(c, "usdtPptAssetIdStr"), "9wc3LXNA4TEBsXyKtoLE9mrbDD7WMHXvXrCjZvabLAsi")
134134 
135-let P = "WAVES"
135+let P = valueOrElse(getString(c, "romeAssetIdStr"), "AP4Cb5xLYGH6ZigHreCZHoXpQTWDkPsG2BHqfDUx6taJ")
136136 
137-let Q = fromBase58String(L)
137+let Q = "WAVES"
138138 
139-let R = fromBase58String(M)
139+let R = fromBase58String(L)
140140 
141-let S = fromBase58String(N)
141+let S = fromBase58String(M)
142142 
143-let T = fromBase58String(O)
143+let T = fromBase58String(N)
144144 
145-let U = unit
145+let U = fromBase58String(O)
146146 
147-let V = [L, M, N, O, P]
147+let V = fromBase58String(P)
148148 
149-let W = Address(fromBase58String(valueOrElse(getString(c, "parentPoolAddress"), "3PFDgzu1UtswAkCMxqqQjbTeHaX4cMab8Kh")))
149+let W = unit
150150 
151-let X = Address(fromBase58String(valueOrElse(getString(c, "masterAddress"), "3PLjwHcz9NEuaTo63NZR9B9okQiKQxZSbmf")))
151+let X = [L, M, N, O, Q, P]
152152 
153-let Y = fromBase58String(valueOrElse(getString(c, "masterPubKey"), "4z8CKSYQBKkzx7PBb5uBP1YPa6YAHRNTApW1sQVHT5eU"))
153+let Y = Address(fromBase58String(valueOrElse(getString(c, "parentPoolAddress"), "3PFDgzu1UtswAkCMxqqQjbTeHaX4cMab8Kh")))
154154 
155-let Z = Address(fromBase58String(valueOrElse(getString(c, "oracleAddress"), "3P8d1E1BLKoD52y3bQJ1bDTd2TD1gpaLn9t")))
155+let Z = Address(fromBase58String(valueOrElse(getString(c, "masterAddress"), "3PLjwHcz9NEuaTo63NZR9B9okQiKQxZSbmf")))
156156 
157-let aa = Address(fromBase58String(valueOrElse(getString(c, "stakingAddress"), "3PFTbywqxtFfukX3HyT881g4iW5K4QL3FAS")))
157+let aa = fromBase58String(valueOrElse(getString(c, "masterPubKey"), "4z8CKSYQBKkzx7PBb5uBP1YPa6YAHRNTApW1sQVHT5eU"))
158158 
159-let ab = Address(fromBase58String(valueOrElse(getString(c, "feesAddress"), "3P4kBiU4wr2yV1S5gMfu3MdkVvy7kxXHsKe")))
159+let ab = Address(fromBase58String(valueOrElse(getString(c, "oracleAddress"), "3P8d1E1BLKoD52y3bQJ1bDTd2TD1gpaLn9t")))
160160 
161-let ac = Address(fromBase58String(valueOrElse(getString(c, "poolsHubAddress"), "3P5YutjDNC3hABBVsveFuZTTbQ5PdtSDBgk")))
161+let ac = Address(fromBase58String(valueOrElse(getString(c, "stakingAddress"), "3PFTbywqxtFfukX3HyT881g4iW5K4QL3FAS")))
162162 
163-let ad = valueOrElse(getString(c, "shutdownAddress"), "3PEpv9hRFWEEBU22WRnLsw1bH4YGtcU728o")
163+let ad = Address(fromBase58String(valueOrElse(getString(c, "feesAddress"), "3PFWAVKmXjfHXyzJb12jCbhP4Uhi9t4uWiD")))
164164 
165-let ae = q("static_tokensAmount")
165+let ae = Address(fromBase58String(valueOrElse(getString(c, "poolsHubAddress"), "3P5YutjDNC3hABBVsveFuZTTbQ5PdtSDBgk")))
166166 
167-let af = {
168-    let ag = split(v("static_tokenIds"), ",")
169-    let ah = size(ag)
170-    let ai = nil
171-    func aj (ak,al) =     if ((al >= ah))
172-        then ak
173-        else D(ak, ag[al])
167+let af = valueOrElse(getString(c, "shutdownAddress"), "3PEpv9hRFWEEBU22WRnLsw1bH4YGtcU728o")
174168 
175-    func am (ak,al) =     if ((al >= ah))
176-        then ak
169+let ag = valueOrElse(getString(c, "layer2Addresses"), "3PR1Qvi9mHT35SwWEkLSqqE2L8thiPLdVWU,3PQoBfUKHkJAeGWhooLP7WS8ovb54av9Jp2")
170+
171+let ah = Address(fromBase58String(valueOrElse(getString(c, "govAddress"), "3P6uro9xCsE8te78QZjzqy7aq8natSzdceC")))
172+
173+let ai = Address(fromBase58String(valueOrElse(getString(c, "coldMasterAddress"), "3PK9nhPfPbMBygB9ZgHVMHaQbSoojwrBfxj")))
174+
175+let aj = q("static_tokensAmount")
176+
177+let ak = {
178+    let al = split(v("static_tokenIds"), ",")
179+    let am = size(al)
180+    let an = nil
181+    func ao (ap,aq) =     if ((aq >= am))
182+        then ap
183+        else D(ap, al[aq])
184+
185+    func ar (ap,aq) =     if ((aq >= am))
186+        then ap
177187         else throw("List size exceeds 10")
178188 
179-    am(aj(aj(aj(aj(aj(aj(aj(aj(aj(aj(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
189+    ar(ao(ao(ao(ao(ao(ao(ao(ao(ao(ao(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
180190     }
181191 
182-let an = {
183-    let ag = af
184-    let ah = size(ag)
185-    let ai = nil
186-    func ao (ak,al) =     if ((al >= ah))
187-        then ak
188-        else G(ak, ag[al])
192+let as = {
193+    let al = ak
194+    let am = size(al)
195+    let an = nil
196+    func at (ap,aq) =     if ((aq >= am))
197+        then ap
198+        else G(ap, al[aq])
189199 
190-    func ap (ak,al) =     if ((al >= ah))
191-        then ak
200+    func au (ap,aq) =     if ((aq >= am))
201+        then ap
192202         else throw("List size exceeds 10")
193203 
194-    ap(ao(ao(ao(ao(ao(ao(ao(ao(ao(ao(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
204+    au(at(at(at(at(at(at(at(at(at(at(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
195205     }
196206 
197-let aq = {
198-    let ag = af
199-    let ah = size(ag)
200-    let ai = nil
201-    func ar (ak,al) =     if ((al >= ah))
202-        then ak
203-        else I(ak, ag[al])
207+let av = {
208+    let al = ak
209+    let am = size(al)
210+    let an = nil
211+    func aw (ap,aq) =     if ((aq >= am))
212+        then ap
213+        else I(ap, al[aq])
204214 
205-    func as (ak,al) =     if ((al >= ah))
206-        then ak
215+    func ax (ap,aq) =     if ((aq >= am))
216+        then ap
207217         else throw("List size exceeds 10")
208218 
209-    as(ar(ar(ar(ar(ar(ar(ar(ar(ar(ar(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
219+    ax(aw(aw(aw(aw(aw(aw(aw(aw(aw(aw(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
210220     }
211221 
212-let at = {
213-    let ag = af
214-    let ah = size(ag)
215-    let ai = nil
216-    func au (ak,al) =     if ((al >= ah))
217-        then ak
218-        else J(ak, ag[al])
222+let ay = {
223+    let al = ak
224+    let am = size(al)
225+    let an = nil
226+    func az (ap,aq) =     if ((aq >= am))
227+        then ap
228+        else J(ap, al[aq])
219229 
220-    func av (ak,al) =     if ((al >= ah))
221-        then ak
230+    func aA (ap,aq) =     if ((aq >= am))
231+        then ap
222232         else throw("List size exceeds 10")
223233 
224-    av(au(au(au(au(au(au(au(au(au(au(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
234+    aA(az(az(az(az(az(az(az(az(az(az(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
225235     }
226236 
227-let aw = q("static_fee")
237+let aB = q("static_fee")
228238 
229-let ax = af
239+let aC = ak
230240 
231-func ay () = if ((ad == ""))
232-    then false
233-    else {
234-        let az = addressFromString(ad)
235-        if ((az == unit))
236-            then false
237-            else {
238-                let s = getBoolean(value(az), "is_shutdown")
239-                if ($isInstanceOf(s, "Boolean"))
240-                    then {
241-                        let aA = s
242-                        aA
243-                        }
244-                    else false
245-                }
246-        }
247-
248-
249-func aB (aC) = {
250-    let aD = x(af[aC])
251-    q((("global_" + aD) + "_balance"))
241+func aD () = {
242+    let aE = addressFromString(af)
243+    if ((aE == unit))
244+        then false
245+        else {
246+            let s = getBoolean(value(aE), "is_shutdown")
247+            if ($isInstanceOf(s, "Boolean"))
248+                then {
249+                    let aF = s
250+                    aF
251+                    }
252+                else false
253+            }
252254     }
253255 
254256 
255-func aE () = {
257+func aG (aH) = {
258+    let aI = x(ak[aH])
259+    q((("global_" + aI) + "_balance"))
260+    }
261+
262+
263+func aJ () = {
256264     let s = getInteger("static_KMult")
257265     if ($isInstanceOf(s, "Int"))
258266         then {
259-            let aA = s
260-            aA
267+            let aF = s
268+            aF
261269             }
262270         else g
263271     }
264272 
265273 
266-func aF () = {
267-    let aG = split(v("static_tokenIds"), ",")
268-    func aH (E,y) =     (E ++ [IntegerEntry(("rebalance_startWeight_" + y), q((("static_" + y) + "_weight")))])
274+func aK () = {
275+    let aL = split(v("static_tokenIds"), ",")
276+    func aM (E,y) =     (E ++ [IntegerEntry(("rebalance_startWeight_" + y), q((("static_" + y) + "_weight")))])
269277 
270-    let ag = aG
271-    let ah = size(ag)
272-    let ai = nil
273-    func aI (ak,al) =     if ((al >= ah))
274-        then ak
275-        else aH(ak, ag[al])
278+    let al = aL
279+    let am = size(al)
280+    let an = nil
281+    func aN (ap,aq) =     if ((aq >= am))
282+        then ap
283+        else aM(ap, al[aq])
276284 
277-    func aJ (ak,al) =     if ((al >= ah))
278-        then ak
285+    func aO (ap,aq) =     if ((aq >= am))
286+        then ap
279287         else throw("List size exceeds 10")
280288 
281-    aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
289+    aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
282290     }
283291 
284292 
285-func aK () = fraction(q("global_poolToken_amount"), aE(), g)
293+func aP () = fraction(q("global_poolToken_amount"), aJ(), g)
286294 
287295 
288-func aL (aM,aN) = {
289-    let aO = aK()
290-    let aP = q((("global_" + x(aN)) + "_balance"))
291-    let aQ = fraction(aM, aO, aP, DOWN)
292-    aQ
296+func aQ (aR,aS) = {
297+    let aT = aP()
298+    let aU = q((("global_" + x(aS)) + "_balance"))
299+    let aV = fraction(aR, aT, aU, DOWN)
300+    aV
293301     }
294302 
295303 
296-func aR (aS) = {
297-    func aT (E,aU) =     {
298-        let aV = aL(aU.amount, aU.assetId)
299-        if ((aV == 0))
304+func aW (aX) = {
305+    func aY (E,aZ) =     {
306+        let ba = aQ(aZ.amount, aZ.assetId)
307+        if ((ba == 0))
300308             then throw("one of the tokens amounts is too low")
301309             else if (if ((E == 0))
302310                 then true
303-                else (E > aV))
304-                then aV
311+                else (E > ba))
312+                then ba
305313                 else E
306314         }
307315 
308-    let aW = {
309-        let ag = aS
310-        let ah = size(ag)
311-        let ai = 0
312-        func aI (ak,al) =         if ((al >= ah))
313-            then ak
314-            else aT(ak, ag[al])
316+    let bb = {
317+        let al = aX
318+        let am = size(al)
319+        let an = 0
320+        func aN (ap,aq) =         if ((aq >= am))
321+            then ap
322+            else aY(ap, al[aq])
315323 
316-        func aJ (ak,al) =         if ((al >= ah))
317-            then ak
324+        func aO (ap,aq) =         if ((aq >= am))
325+            then ap
318326             else throw("List size exceeds 10")
319327 
320-        aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
328+        aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
321329         }
322-    aW
330+    bb
323331     }
324332 
325333 
326-func aX (y,aM,aY,aZ) = {
327-    let ba = indexOf(af, Q)
328-    let bb = indexOf(af, R)
329-    let bc = indexOf(af, S)
330-    let bd = indexOf(af, T)
331-    let be = indexOf(af, unit)
332-    let bf = q((("static_" + x(y)) + "_weight"))
333-    let bg = v("static_feeToken")
334-    if ((bg == M))
334+func bc (y,aR,bd,be) = {
335+    let bf = indexOf(ak, R)
336+    let bg = indexOf(ak, S)
337+    let bh = indexOf(ak, T)
338+    let bi = indexOf(ak, U)
339+    let bj = indexOf(ak, unit)
340+    let bk = q((("static_" + x(y)) + "_weight"))
341+    let bl = v("static_feeToken")
342+    if ((bl == M))
335343         then {
336-            let bh = an[value(indexOf(af, R))]
337-            let bi = q((("global_" + M) + "_balance"))
338-            let bj = fraction(aM, (bi / bh), (aY / bf))
339-            let bk = getIntegerValue(W, "global_lastPuzzlePrice")
340-            fraction((bj * bk), 1, f)
344+            let bm = as[value(indexOf(ak, S))]
345+            let bn = q((("global_" + M) + "_balance"))
346+            let bo = fraction(aR, (bn / bm), (bd / bk))
347+            let bp = getIntegerValue(Y, "global_lastPuzzlePrice")
348+            fraction((bo * bp), 1, f)
341349             }
342-        else if ((bg == N))
350+        else if ((bl == N))
343351             then {
344-                let bl = an[value(bc)]
345-                let bm = q((("global_" + N) + "_balance"))
346-                fraction(aM, (bm / bl), (aY / bf))
352+                let bq = as[value(bh)]
353+                let br = q((("global_" + N) + "_balance"))
354+                fraction(aR, (br / bq), (bd / bk))
347355                 }
348-            else if ((bg == O))
356+            else if ((bl == O))
349357                 then {
350-                    let bl = an[value(bd)]
351-                    let bm = q((("global_" + O) + "_balance"))
352-                    fraction(aM, (bm / bl), (aY / bf))
358+                    let bq = as[value(bi)]
359+                    let br = q((("global_" + O) + "_balance"))
360+                    fraction(aR, (br / bq), (bd / bk))
353361                     }
354-                else if ((bg == L))
362+                else if ((bl == L))
355363                     then {
356-                        let bn = an[value(indexOf(af, Q))]
357-                        let bo = {
358-                            let s = aZ
364+                        let bs = as[value(indexOf(ak, R))]
365+                        let bt = {
366+                            let s = be
359367                             if ($isInstanceOf(s, "Int"))
360368                                 then {
361-                                    let aA = s
362-                                    aZ
369+                                    let aF = s
370+                                    be
363371                                     }
364-                                else q((("global_" + x(Q)) + "_balance"))
372+                                else q((("global_" + x(R)) + "_balance"))
365373                             }
366-                        fraction(aM, (value(bo) / bn), (aY / bf))
374+                        fraction(aR, (value(bt) / bs), (bd / bk))
367375                         }
368376                     else {
369-                        let bp = 3000
370-                        let bq = (q("global_WAVES_balance") / 50)
371-                        fraction(aM, (bq / bp), (aY / bf))
377+                        let bu = 3000
378+                        let bv = (q("global_WAVES_balance") / 50)
379+                        fraction(aR, (bv / bu), (bd / bk))
372380                         }
373381     }
374382 
375383 
376-func br (A) = {
377-    let s = getInteger(Z, (A + "_twap5B"))
384+func bw (A) = {
385+    let s = getInteger(ab, (A + "_twap5B"))
378386     if ($isInstanceOf(s, "Int"))
379387         then {
380-            let aA = s
381-            aA
388+            let aF = s
389+            aF
382390             }
383391         else 0
384392     }
385393 
386394 
387-func bs (y,aM,aY) = {
388-    let bf = q((("static_" + x(y)) + "_weight"))
389-    let bg = v("static_feeToken")
390-    let bt = getIntegerValue(this, (("static_" + bg) + "_scale"))
391-    let bu = value(indexOf(af, z(bg)))
392-    let bv = an[bu]
393-    let bw = q((("global_" + bg) + "_balance"))
394-    let bx = fraction(aM, (bw / bv), (aY / bf))
395-    let by = br(bg)
396-    fraction(bx, by, bt)
395+func bx (y,aR,bd) = {
396+    let bk = q((("static_" + x(y)) + "_weight"))
397+    let bl = v("static_feeToken")
398+    let by = getIntegerValue(this, (("static_" + bl) + "_scale"))
399+    let bz = value(indexOf(ak, z(bl)))
400+    let bA = as[bz]
401+    let bB = q((("global_" + bl) + "_balance"))
402+    let bC = fraction(aR, (bB / bA), (bd / bk))
403+    let bD = bw(bl)
404+    fraction(bC, bD, by)
397405     }
398406 
399407 
400-func bz (aS) = {
401-    func bA (E,bB) =     (E ++ [bB.assetId])
408+func bE (aX) = {
409+    func bF (E,bG) =     (E ++ [bG.assetId])
402410 
403-    let bC = {
404-        let ag = aS
405-        let ah = size(ag)
406-        let ai = nil
407-        func aI (ak,al) =         if ((al >= ah))
408-            then ak
409-            else bA(ak, ag[al])
411+    let bH = {
412+        let al = aX
413+        let am = size(al)
414+        let an = nil
415+        func aN (ap,aq) =         if ((aq >= am))
416+            then ap
417+            else bF(ap, al[aq])
410418 
411-        func aJ (ak,al) =         if ((al >= ah))
412-            then ak
419+        func aO (ap,aq) =         if ((aq >= am))
420+            then ap
413421             else throw("List size exceeds 10")
414422 
415-        aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
423+        aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
416424         }
417-    if ((bC == bC))
425+    if ((bH == bH))
418426         then {
419-            func bD (E,y) =             if ((indexOf(bC, y) != unit))
427+            func bI (E,y) =             if ((indexOf(bH, y) != unit))
420428                 then (E + 1)
421429                 else throw(("asset not attached: " + x(y)))
422430 
423-            let bE = {
424-                let ag = af
425-                let ah = size(ag)
426-                let ai = 0
427-                func bF (ak,al) =                 if ((al >= ah))
428-                    then ak
429-                    else bD(ak, ag[al])
431+            let bJ = {
432+                let al = ak
433+                let am = size(al)
434+                let an = 0
435+                func bK (ap,aq) =                 if ((aq >= am))
436+                    then ap
437+                    else bI(ap, al[aq])
430438 
431-                func bG (ak,al) =                 if ((al >= ah))
432-                    then ak
439+                func bL (ap,aq) =                 if ((aq >= am))
440+                    then ap
433441                     else throw("List size exceeds 10")
434442 
435-                bG(bF(bF(bF(bF(bF(bF(bF(bF(bF(bF(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
443+                bL(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
436444                 }
437-            if ((bE == bE))
445+            if ((bJ == bJ))
438446                 then true
439447                 else throw("Strict value is not equal to itself.")
440448             }
442450     }
443451 
444452 
445-func bH (aV,aS,bI,bJ) = {
446-    func bK (aN) =     {
447-        func aT (E,bB) =         if ((bB.assetId == aN))
448-            then bB.amount
453+func bM (ba,aX,bN,bO) = {
454+    func bP (aS) =     {
455+        func aY (E,bG) =         if ((bG.assetId == aS))
456+            then bG.amount
449457             else E
450458 
451-        let ag = aS
452-        let ah = size(ag)
453-        let ai = 0
454-        func aI (ak,al) =         if ((al >= ah))
455-            then ak
456-            else aT(ak, ag[al])
459+        let al = aX
460+        let am = size(al)
461+        let an = 0
462+        func aN (ap,aq) =         if ((aq >= am))
463+            then ap
464+            else aY(ap, al[aq])
457465 
458-        func aJ (ak,al) =         if ((al >= ah))
459-            then ak
466+        func aO (ap,aq) =         if ((aq >= am))
467+            then ap
460468             else throw("List size exceeds 10")
461469 
462-        aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
470+        aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
463471         }
464472 
465-    func bL (E,aN) =     {
466-        let bM = q((("global_" + x(aN)) + "_balance"))
467-        let bN = aK()
468-        let bO = q((("static_" + x(aN)) + "_scale"))
469-        let bP = fraction((toBigInt((bN + aV)) * toBigInt(f)), toBigInt(bO), toBigInt(bN), CEILING)
470-        let bQ = toInt(fraction((bP - (toBigInt(bO) * toBigInt(f))), toBigInt(bM), (toBigInt(bO) * toBigInt(f)), CEILING))
471-        let bR = bK(aN)
472-        let bS = (bR - bQ)
473-        let C = if (if (bJ)
474-            then (bS > 0)
473+    func bQ (E,aS) =     {
474+        let bR = q((("global_" + x(aS)) + "_balance"))
475+        let bS = aP()
476+        let bT = q((("static_" + x(aS)) + "_scale"))
477+        let bU = fraction((toBigInt((bS + ba)) * toBigInt(f)), toBigInt(bT), toBigInt(bS), CEILING)
478+        let bV = toInt(fraction((bU - (toBigInt(bT) * toBigInt(f))), toBigInt(bR), (toBigInt(bT) * toBigInt(f)), CEILING))
479+        let bW = bP(aS)
480+        let bX = (bW - bV)
481+        let C = if (if (bO)
482+            then (bX > 0)
475483             else false)
476-            then [ScriptTransfer(bI, bS, aN)]
484+            then [ScriptTransfer(bN, bX, aS)]
477485             else nil
478-        ((E ++ C) ++ [IntegerEntry((("global_" + x(aN)) + "_balance"), (bM + bQ))])
486+        ((E ++ C) ++ [IntegerEntry((("global_" + x(aS)) + "_balance"), (bR + bV))])
479487         }
480488 
481-    let ag = af
482-    let ah = size(ag)
483-    let ai = nil
484-    func aI (ak,al) =     if ((al >= ah))
485-        then ak
486-        else bL(ak, ag[al])
489+    let al = ak
490+    let am = size(al)
491+    let an = nil
492+    func aN (ap,aq) =     if ((aq >= am))
493+        then ap
494+        else bQ(ap, al[aq])
487495 
488-    func aJ (ak,al) =     if ((al >= ah))
489-        then ak
496+    func aO (ap,aq) =     if ((aq >= am))
497+        then ap
490498         else throw("List size exceeds 10")
491499 
492-    aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
500+    aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
493501     }
494502 
495503 
496-func bT (bU,bI) = {
497-    func bV (E,aN) =     {
498-        let bM = q((("global_" + x(aN)) + "_balance"))
499-        let bN = aK()
500-        let bO = q((("static_" + x(aN)) + "_scale"))
501-        let bW = fraction((toBigInt((bN - bU)) * toBigInt(f)), toBigInt(f), toBigInt(bN), DOWN)
502-        let aM = toInt(fraction((toBigInt(g) - bW), toBigInt(bM), toBigInt(g), CEILING))
503-        (E ++ [IntegerEntry((("global_" + x(aN)) + "_balance"), (bM - aM)), ScriptTransfer(bI, aM, aN)])
504+func bY (bZ,bN) = {
505+    func ca (E,aS) =     {
506+        let bR = q((("global_" + x(aS)) + "_balance"))
507+        let bS = aP()
508+        let bT = q((("static_" + x(aS)) + "_scale"))
509+        let cb = fraction((toBigInt((bS - bZ)) * toBigInt(f)), toBigInt(f), toBigInt(bS), DOWN)
510+        let aR = toInt(fraction((toBigInt(g) - cb), toBigInt(bR), toBigInt(g), CEILING))
511+        (E ++ [IntegerEntry((("global_" + x(aS)) + "_balance"), (bR - aR)), ScriptTransfer(bN, aR, aS)])
504512         }
505513 
506-    let ag = af
507-    let ah = size(ag)
508-    let ai = nil
509-    func aI (ak,al) =     if ((al >= ah))
510-        then ak
511-        else bV(ak, ag[al])
514+    let al = ak
515+    let am = size(al)
516+    let an = nil
517+    func aN (ap,aq) =     if ((aq >= am))
518+        then ap
519+        else ca(ap, al[aq])
512520 
513-    func aJ (ak,al) =     if ((al >= ah))
514-        then ak
521+    func aO (ap,aq) =     if ((aq >= am))
522+        then ap
515523         else throw("List size exceeds 10")
516524 
517-    aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
525+    aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
518526     }
519527 
520528 
521-func bX (bY,bZ,ca,cb,cc) = {
522-    let cd = value(indexOf(af, bZ))
523-    let ce = value(indexOf(af, ca))
524-    if ((cd == ce))
525-        then bY
526-        else fraction(cc, ((f * f) - toInt(pow(fraction(toBigInt((cb * 10000)), toBigInt((f * f)), toBigInt(((cb + bY) * 10000)), HALFUP), 16, toBigInt(fraction(an[cd], 1000000000000, an[ce])), 12, 16, CEILING))), (f * f), HALFEVEN)
529+func cc (cd,ce,cf,cg,ch) = {
530+    let ci = value(indexOf(ak, ce))
531+    let cj = value(indexOf(ak, cf))
532+    if ((ci == cj))
533+        then cd
534+        else fraction(ch, ((f * f) - toInt(pow(fraction((toBigInt(cg) * toBigInt(10000)), toBigInt((f * f)), (toBigInt((cg + cd)) * toBigInt(10000)), HALFUP), 16, toBigInt(fraction(as[ci], 1000000000000, as[cj])), 12, 16, CEILING))), (f * f), HALFEVEN)
527535     }
528536 
529537 
530-func cf (y,A,aY,cg) = {
531-    let ch = q("global_indexStaked")
532-    let ci = cg
533-    let cj = (B(y) - aY)
534-    let ck = if ((cj > ci))
535-        then cj
536-        else ci
537-    let cl = (ck - ci)
538-    let cm = if ((ch == 0))
538+func ck (y,A,bd,cl) = {
539+    let cm = q("global_indexStaked")
540+    let cn = cl
541+    let co = (B(y) - bd)
542+    let cp = if ((co > cn))
543+        then co
544+        else cn
545+    let cq = (cp - cn)
546+    let cr = if ((cm == 0))
539547         then 0
540-        else fraction(cl, f, ch)
541-    let cn = q((("global_lastCheck_" + A) + "_interest"))
542-    (cn + cm)
548+        else fraction(cq, f, cm)
549+    let cs = q((("global_lastCheck_" + A) + "_interest"))
550+    (cs + cr)
543551     }
544552 
545553 
546-func co (cp) = {
547-    let cq = toString(cp)
548-    let cr = q((cq + "_indexStaked"))
549-    func aT (E,y) =     {
554+func ct (cu) = {
555+    let cv = toString(cu)
556+    let cw = q((cv + "_indexStaked"))
557+    func aY (E,y) =     {
550558         let A = x(y)
551-        let aY = q((("global_" + x(y)) + "_balance"))
552-        let cg = q((("global_lastCheck_" + A) + "_earnings"))
553-        let cs = cf(y, A, aY, cg)
554-        let ck = max([cg, (B(y) - aY)])
555-        let ct = fraction(cr, (cs - q((((cq + "_lastCheck_") + A) + "_interest"))), f)
556-        let cu = if ((ct == 0))
559+        let bd = q((("global_" + x(y)) + "_balance"))
560+        let cl = q((("global_lastCheck_" + A) + "_earnings"))
561+        let cx = ck(y, A, bd, cl)
562+        let cp = max([cl, (B(y) - bd)])
563+        let cy = fraction(cw, (cx - q((((cv + "_lastCheck_") + A) + "_interest"))), f)
564+        let cz = if ((cy == 0))
557565             then nil
558-            else [ScriptTransfer(cp, ct, y)]
559-        $Tuple2(((E._1 ++ cu) ++ [IntegerEntry((("global_lastCheck_" + A) + "_earnings"), (ck - ct)), IntegerEntry((("global_lastCheck_" + A) + "_interest"), cs), IntegerEntry((((cq + "_lastCheck_") + A) + "_interest"), cs)]), (E._2 + bs(y, ct, aY)))
566+            else [ScriptTransfer(cu, cy, y)]
567+        $Tuple2(((E._1 ++ cz) ++ [IntegerEntry((("global_lastCheck_" + A) + "_earnings"), (cp - cy)), IntegerEntry((("global_lastCheck_" + A) + "_interest"), cx), IntegerEntry((((cv + "_lastCheck_") + A) + "_interest"), cx)]), (E._2 + bx(y, cy, bd)))
560568         }
561569 
562570     let E = {
563-        let ag = ax
564-        let ah = size(ag)
565-        let ai = $Tuple2(nil, 0)
566-        func aI (ak,al) =         if ((al >= ah))
567-            then ak
568-            else aT(ak, ag[al])
571+        let al = aC
572+        let am = size(al)
573+        let an = $Tuple2(nil, 0)
574+        func aN (ap,aq) =         if ((aq >= am))
575+            then ap
576+            else aY(ap, al[aq])
569577 
570-        func aJ (ak,al) =         if ((al >= ah))
571-            then ak
578+        func aO (ap,aq) =         if ((aq >= am))
579+            then ap
572580             else throw("List size exceeds 10")
573581 
574-        aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
582+        aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
575583         }
576-    $Tuple2((E._1 ++ [IntegerEntry((cq + "_claimedRewardValue"), (q((cq + "_claimedRewardValue")) + E._2)), IntegerEntry((cq + "_lastClaim"), lastBlock.timestamp)]), E._2)
584+    $Tuple2((E._1 ++ [IntegerEntry((cv + "_claimedRewardUSD"), (q((cv + "_claimedRewardUSD")) + E._2)), IntegerEntry((cv + "_lastClaim"), lastBlock.timestamp)]), E._2)
577585     }
578586 
579587 
580-func cv (cq,aM) = {
581-    let cw = co(addressFromStringValue(cq))._1
582-    (cw ++ [IntegerEntry((cq + "_indexStaked"), (q((cq + "_indexStaked")) + aM)), IntegerEntry("global_indexStaked", (q("global_indexStaked") + aM))])
588+func cA (cv,aR) = {
589+    let cB = ct(addressFromStringValue(cv))._1
590+    (cB ++ [IntegerEntry((cv + "_indexStaked"), (q((cv + "_indexStaked")) + aR)), IntegerEntry("global_indexStaked", (q("global_indexStaked") + aR))])
583591     }
584592 
585593 
586-func cx (E,cy) = (E + parseIntValue(cy))
594+func cC (E,cD) = (E + parseIntValue(cD))
587595 
588596 
589-func cz (E,cA) = if (if ((indexOf(V, cA) != unit))
597+func cE (E,cF) = if (if ((indexOf(X, cF) != unit))
590598     then (E == "")
591599     else false)
592-    then cA
600+    then cF
593601     else E
594602 
595603 
596-func cB (cC) = {
597-    let cD = split(v("static_tokenIds"), ",")
598-    let cE = cC
599-    func cF (E,y) =     if ((indexOf(cE, y) == unit))
604+func cG (cH) = {
605+    let cI = split(v("static_tokenIds"), ",")
606+    let cJ = cH
607+    func cK (E,y) =     if ((indexOf(cJ, y) == unit))
600608         then (E ++ [y])
601609         else E
602610 
603-    let ag = cD
604-    let ah = size(ag)
605-    let ai = cE
606-    func aI (ak,al) =     if ((al >= ah))
607-        then ak
608-        else cF(ak, ag[al])
611+    let al = cI
612+    let am = size(al)
613+    let an = cJ
614+    func aN (ap,aq) =     if ((aq >= am))
615+        then ap
616+        else cK(ap, al[aq])
609617 
610-    func aJ (ak,al) =     if ((al >= ah))
611-        then ak
618+    func aO (ap,aq) =     if ((aq >= am))
619+        then ap
612620         else throw("List size exceeds 10")
613621 
614-    aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
622+    aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
615623     }
616624 
617625 
618-func cG (cC) = {
619-    let cD = split(v("static_tokenIds"), ",")
620-    func cH (E,y) =     if ((indexOf(cC, y) == unit))
626+func cL (cH) = {
627+    let cI = split(v("static_tokenIds"), ",")
628+    func cM (E,y) =     if ((indexOf(cH, y) == unit))
621629         then (E + 1)
622630         else E
623631 
624-    func cI (E,y) =     if ((indexOf(cD, y) == unit))
632+    func cN (E,y) =     if ((indexOf(cI, y) == unit))
625633         then (E + 1)
626634         else E
627635 
628-    let cJ = {
629-        let ag = cD
630-        let ah = size(ag)
631-        let ai = 0
632-        func aI (ak,al) =         if ((al >= ah))
633-            then ak
634-            else cH(ak, ag[al])
636+    let cO = {
637+        let al = cI
638+        let am = size(al)
639+        let an = 0
640+        func aN (ap,aq) =         if ((aq >= am))
641+            then ap
642+            else cM(ap, al[aq])
635643 
636-        func aJ (ak,al) =         if ((al >= ah))
637-            then ak
644+        func aO (ap,aq) =         if ((aq >= am))
645+            then ap
638646             else throw("List size exceeds 10")
639647 
640-        aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
648+        aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
641649         }
642-    let cK = {
643-        let ag = cC
644-        let ah = size(ag)
645-        let ai = 0
646-        func bF (ak,al) =         if ((al >= ah))
647-            then ak
648-            else cI(ak, ag[al])
650+    let cP = {
651+        let al = cH
652+        let am = size(al)
653+        let an = 0
654+        func bK (ap,aq) =         if ((aq >= am))
655+            then ap
656+            else cN(ap, al[aq])
649657 
650-        func bG (ak,al) =         if ((al >= ah))
651-            then ak
658+        func bL (ap,aq) =         if ((aq >= am))
659+            then ap
652660             else throw("List size exceeds 10")
653661 
654-        bG(bF(bF(bF(bF(bF(bF(bF(bF(bF(bF(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
662+        bL(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
655663         }
656-    (cJ + cK)
664+    (cO + cP)
657665     }
658666 
659667 
660-func cL (cM,aS) = {
661-    func cN (E,cA) =     if ((0 >= cA.amount))
662-        then throw(((("Too low payment amount for " + x(cA.assetId)) + ": ") + toString(cA.amount)))
663-        else (E ++ [x(cA.assetId)])
668+func cQ (cR,aX) = {
669+    func cS (E,cF) =     if ((0 >= cF.amount))
670+        then throw(((("Too low payment amount for " + x(cF.assetId)) + ": ") + toString(cF.amount)))
671+        else (E ++ [x(cF.assetId)])
664672 
665-    let cO = {
666-        let ag = aS
667-        let ah = size(ag)
668-        let ai = nil
669-        func aI (ak,al) =         if ((al >= ah))
670-            then ak
671-            else cN(ak, ag[al])
673+    let cT = {
674+        let al = aX
675+        let am = size(al)
676+        let an = nil
677+        func aN (ap,aq) =         if ((aq >= am))
678+            then ap
679+            else cS(ap, al[aq])
672680 
673-        func aJ (ak,al) =         if ((al >= ah))
674-            then ak
681+        func aO (ap,aq) =         if ((aq >= am))
682+            then ap
675683             else throw("List size exceeds 10")
676684 
677-        aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
685+        aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
678686         }
679-    func cP (E,cA) =     if ((indexOf(cM, cA) == unit))
680-        then throw(((cA + " asset is present in payments, but is not in new assets: ") + makeString(cM, ",")))
687+    func cU (E,cF) =     if ((indexOf(cR, cF) == unit))
688+        then throw(((cF + " asset is present in payments, but is not in new assets: ") + makeString(cR, ",")))
681689         else (E + 1)
682690 
683-    func cQ (E,cA) =     if ((indexOf(cO, cA) == unit))
684-        then throw(((cA + " asset is present in new assets, but is not in payments: ") + makeString(cO, ",")))
691+    func cV (E,cF) =     if ((indexOf(cT, cF) == unit))
692+        then throw(((cF + " asset is present in new assets, but is not in payments: ") + makeString(cT, ",")))
685693         else (E + 1)
686694 
687-    let bP = {
688-        let ag = cO
689-        let ah = size(ag)
690-        let ai = 0
691-        func bF (ak,al) =         if ((al >= ah))
692-            then ak
693-            else cP(ak, ag[al])
695+    let bU = {
696+        let al = cT
697+        let am = size(al)
698+        let an = 0
699+        func bK (ap,aq) =         if ((aq >= am))
700+            then ap
701+            else cU(ap, al[aq])
694702 
695-        func bG (ak,al) =         if ((al >= ah))
696-            then ak
703+        func bL (ap,aq) =         if ((aq >= am))
704+            then ap
697705             else throw("List size exceeds 10")
698706 
699-        bG(bF(bF(bF(bF(bF(bF(bF(bF(bF(bF(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
707+        bL(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
700708         }
701-    let cR = {
702-        let ag = cM
703-        let ah = size(ag)
704-        let ai = 0
705-        func cS (ak,al) =         if ((al >= ah))
706-            then ak
707-            else cQ(ak, ag[al])
709+    let cW = {
710+        let al = cR
711+        let am = size(al)
712+        let an = 0
713+        func cX (ap,aq) =         if ((aq >= am))
714+            then ap
715+            else cV(ap, al[aq])
708716 
709-        func cT (ak,al) =         if ((al >= ah))
710-            then ak
717+        func cY (ap,aq) =         if ((aq >= am))
718+            then ap
711719             else throw("List size exceeds 10")
712720 
713-        cT(cS(cS(cS(cS(cS(cS(cS(cS(cS(cS(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
721+        cY(cX(cX(cX(cX(cX(cX(cX(cX(cX(cX(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
714722         }
715-    (bP + cR)
723+    (bU + cW)
716724     }
717725 
718726 
719-func cU (cV) = {
720-    func cW (E,cX) =     {
721-        let cY = valueOrErrorMessage(parseInt(cX), ("Wrong weight format: " + cX))
722-        if (if ((o > cY))
727+func cZ (da) = {
728+    func db (E,dc) =     {
729+        let dd = valueOrErrorMessage(parseInt(dc), ("Wrong weight format: " + dc))
730+        if (if ((o > dd))
723731             then true
724-            else (cY > p))
725-            then throw(((((("Weight should be in range " + toString(o)) + " - ") + toString(p)) + ", current: ") + cX))
732+            else (dd > p))
733+            then throw(((((("Weight should be in range " + toString(o)) + " - ") + toString(p)) + ", current: ") + dc))
726734             else E
727735         }
728736 
729-    let ag = cV
730-    let ah = size(ag)
731-    let ai = 0
732-    func aI (ak,al) =     if ((al >= ah))
733-        then ak
734-        else cW(ak, ag[al])
737+    let al = da
738+    let am = size(al)
739+    let an = 0
740+    func aN (ap,aq) =     if ((aq >= am))
741+        then ap
742+        else db(ap, al[aq])
735743 
736-    func aJ (ak,al) =     if ((al >= ah))
737-        then ak
744+    func aO (ap,aq) =     if ((aq >= am))
745+        then ap
738746         else throw("List size exceeds 10")
739747 
740-    aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
748+    aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
741749     }
742750 
743751 
744-@Callable(cZ)
745-func preInit (da,db,dc,dd,de,df) = {
746-    let dg = Address(fromBase58String(de))
747-    let dh = split(da, ",")
748-    let aG = {
749-        let ag = dh
750-        let ah = size(ag)
751-        let ai = nil
752-        func aI (ak,al) =         if ((al >= ah))
753-            then ak
754-            else D(ak, ag[al])
752+@Callable(de)
753+func preInit (df,dg,dh,di,dj,dk) = {
754+    let dl = Address(fromBase58String(dj))
755+    let dm = split(df, ",")
756+    let aL = {
757+        let al = dm
758+        let am = size(al)
759+        let an = nil
760+        func aN (ap,aq) =         if ((aq >= am))
761+            then ap
762+            else D(ap, al[aq])
755763 
756-        func aJ (ak,al) =         if ((al >= ah))
757-            then ak
764+        func aO (ap,aq) =         if ((aq >= am))
765+            then ap
758766             else throw("List size exceeds 10")
759767 
760-        aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
768+        aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
761769         }
762-    let bg = {
763-        let ag = dh
764-        let ah = size(ag)
765-        let ai = ""
766-        func bF (ak,al) =         if ((al >= ah))
767-            then ak
768-            else cz(ak, ag[al])
770+    let bl = {
771+        let al = dm
772+        let am = size(al)
773+        let an = ""
774+        func bK (ap,aq) =         if ((aq >= am))
775+            then ap
776+            else cE(ap, al[aq])
769777 
770-        func bG (ak,al) =         if ((al >= ah))
771-            then ak
778+        func bL (ap,aq) =         if ((aq >= am))
779+            then ap
772780             else throw("List size exceeds 10")
773781 
774-        bG(bF(bF(bF(bF(bF(bF(bF(bF(bF(bF(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
782+        bL(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
775783         }
776-    if (ay())
784+    if (aD())
777785         then throw("contract is on stop")
778-        else if ((this != cZ.caller))
786+        else if ((this != de.caller))
779787             then throw("admin only")
780-            else if ((bg == ""))
788+            else if ((bl == ""))
781789                 then throw("pool must have one of the supported fee assets in the composition")
782-                else if ((size(dd) > 16))
790+                else if ((size(di) > 13))
783791                     then throw("too large pool domain")
784-                    else if (if ((df > 500))
792+                    else if (if ((dk > 500))
785793                         then true
786-                        else (0 > df))
794+                        else (0 > dk))
787795                         then throw("fee value must be between 50 and 500 (0.5-5%)")
788796                         else {
789-                            let di = split(db, ",")
790-                            let dj = {
791-                                let ag = di
792-                                let ah = size(ag)
793-                                let ai = 0
794-                                func cS (ak,al) =                                 if ((al >= ah))
795-                                    then ak
796-                                    else cx(ak, ag[al])
797+                            let dn = split(dg, ",")
798+                            let do = {
799+                                let al = dn
800+                                let am = size(al)
801+                                let an = 0
802+                                func cX (ap,aq) =                                 if ((aq >= am))
803+                                    then ap
804+                                    else cC(ap, al[aq])
797805 
798-                                func cT (ak,al) =                                 if ((al >= ah))
799-                                    then ak
806+                                func cY (ap,aq) =                                 if ((aq >= am))
807+                                    then ap
800808                                     else throw("List size exceeds 10")
801809 
802-                                cT(cS(cS(cS(cS(cS(cS(cS(cS(cS(cS(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
810+                                cY(cX(cX(cX(cX(cX(cX(cX(cX(cX(cX(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
803811                                 }
804-                            func dk (E,dl) =                             if ((dl >= size(aG)))
812+                            func dp (E,dq) =                             if ((dq >= size(aL)))
805813                                 then E
806814                                 else {
807-                                    let dm = {
808-                                        let s = aG[dl]
815+                                    let dr = {
816+                                        let s = aL[dq]
809817                                         if ($isInstanceOf(s, "ByteVector"))
810818                                             then {
811-                                                let aA = s
812-                                                value(assetInfo(aA)).decimals
819+                                                let aF = s
820+                                                value(assetInfo(aF)).decimals
813821                                                 }
814822                                             else 8
815823                                         }
816-                                    (E ++ [IntegerEntry((("static_" + dh[dl]) + "_scale"), pow(10, 0, dm, 0, 0, DOWN)), IntegerEntry((("static_" + dh[dl]) + "_decimals"), dm), IntegerEntry((("static_" + dh[dl]) + "_weight"), value(parseInt(di[dl])))])
824+                                    (E ++ [IntegerEntry((("static_" + dm[dq]) + "_scale"), pow(10, 0, dr, 0, 0, DOWN)), IntegerEntry((("static_" + dm[dq]) + "_decimals"), dr), IntegerEntry((("static_" + dm[dq]) + "_weight"), value(parseInt(dn[dq])))])
817825                                     }
818826 
819-                            if ((dj != 10000))
827+                            if ((do != 10000))
820828                                 then throw("sum of token weights must be equal to 10000")
821829                                 else ({
822-                                    let ag = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
823-                                    let ah = size(ag)
824-                                    let ai = nil
825-                                    func dn (ak,al) =                                     if ((al >= ah))
826-                                        then ak
827-                                        else dk(ak, ag[al])
830+                                    let al = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
831+                                    let am = size(al)
832+                                    let an = nil
833+                                    func ds (ap,aq) =                                     if ((aq >= am))
834+                                        then ap
835+                                        else dp(ap, al[aq])
828836 
829-                                    func do (ak,al) =                                     if ((al >= ah))
830-                                        then ak
837+                                    func dt (ap,aq) =                                     if ((aq >= am))
838+                                        then ap
831839                                         else throw("List size exceeds 10")
832840 
833-                                    do(dn(dn(dn(dn(dn(dn(dn(dn(dn(dn(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
834-                                    } ++ [StringEntry("static_tokenIds", da), StringEntry("static_feeToken", bg), StringEntry("static_tokenWeights", db), IntegerEntry("static_tokensAmount", size(aG)), StringEntry("static_poolDomain", dd), StringEntry("static_baseTokenId", dc), StringEntry("static_poolOwner", de), IntegerEntry("static_fee", df), IntegerEntry("static_KMult", g)])
841+                                    dt(ds(ds(ds(ds(ds(ds(ds(ds(ds(ds(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
842+                                    } ++ [StringEntry("static_tokenIds", df), StringEntry("static_feeToken", bl), StringEntry("static_tokenWeights", dg), IntegerEntry("static_tokensAmount", size(aL)), StringEntry("static_poolDomain", di), StringEntry("static_baseTokenId", dh), StringEntry("static_poolOwner", dj), IntegerEntry("static_fee", dk), IntegerEntry("static_KMult", g), IntegerEntry("global_wasPreInited", 1)])
835843                             }
836844     }
837845 
838846 
839847 
840-@Callable(cZ)
841-func deInit () = if (ay())
848+@Callable(de)
849+func deInit () = if (aD())
842850     then throw("contract is on stop")
843-    else if ((cZ.caller != this))
851+    else if ((de.caller != this))
844852         then throw("admin only")
845853         else [IntegerEntry("global_wasInited", 0)]
846854 
847855 
848856 
849-@Callable(cZ)
857+@Callable(de)
850858 func init () = {
851-    func dp () =     {
852-        func aT (E,cy) =         (E ++ [IntegerEntry((("global_" + x(cy.assetId)) + "_balance"), cy.amount)])
859+    func du () =     {
860+        func aY (E,cD) =         (E ++ [IntegerEntry((("global_" + x(cD.assetId)) + "_balance"), cD.amount)])
853861 
854-        let ag = cZ.payments
855-        let ah = size(ag)
856-        let ai = nil
857-        func aI (ak,al) =         if ((al >= ah))
858-            then ak
859-            else aT(ak, ag[al])
862+        let al = de.payments
863+        let am = size(al)
864+        let an = nil
865+        func aN (ap,aq) =         if ((aq >= am))
866+            then ap
867+            else aY(ap, al[aq])
860868 
861-        func aJ (ak,al) =         if ((al >= ah))
862-            then ak
869+        func aO (ap,aq) =         if ((aq >= am))
870+            then ap
863871             else throw("List size exceeds 10")
864872 
865-        aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
873+        aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
866874         }
867875 
868-    func dq (aS) =     {
869-        func aT (E,dr) =         {
870-            let y = dr.assetId
871-            func bD (E,cy) =             if ((cy == y))
872-                then value(indexOf(af, cy))
876+    func dv (aX) =     {
877+        func aY (E,dw) =         {
878+            let y = dw.assetId
879+            func bI (E,cD) =             if ((cD == y))
880+                then value(indexOf(ak, cD))
873881                 else E
874882 
875-            let ds = {
876-                let ag = af
877-                let ah = size(ag)
878-                let ai = 1
879-                func aI (ak,al) =                 if ((al >= ah))
880-                    then ak
881-                    else bD(ak, ag[al])
883+            let dx = {
884+                let al = ak
885+                let am = size(al)
886+                let an = 1
887+                func aN (ap,aq) =                 if ((aq >= am))
888+                    then ap
889+                    else bI(ap, al[aq])
882890 
883-                func aJ (ak,al) =                 if ((al >= ah))
884-                    then ak
891+                func aO (ap,aq) =                 if ((aq >= am))
892+                    then ap
885893                     else throw("List size exceeds 10")
886894 
887-                aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
895+                aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
888896                 }
889-            fraction(E, pow(dr.amount, aq[ds], an[ds], d, 8, FLOOR), f)
897+            fraction(E, pow(dw.amount, av[dx], as[dx], d, 8, FLOOR), f)
890898             }
891899 
892-        let ag = aS
893-        let ah = size(ag)
894-        let ai = j
895-        func aI (ak,al) =         if ((al >= ah))
896-            then ak
897-            else aT(ak, ag[al])
900+        let al = aX
901+        let am = size(al)
902+        let an = j
903+        func aN (ap,aq) =         if ((aq >= am))
904+            then ap
905+            else aY(ap, al[aq])
898906 
899-        func aJ (ak,al) =         if ((al >= ah))
900-            then ak
907+        func aO (ap,aq) =         if ((aq >= am))
908+            then ap
901909             else throw("List size exceeds 10")
902910 
903-        aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
911+        aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
904912         }
905913 
906-    if (ay())
914+    if (aD())
907915         then throw("contract is on stop")
908916         else if ((q("global_wasInited") > 0))
909917             then throw("pool already inited")
910918             else {
911-                let dt = dq(cZ.payments)
912-                if ((dt == 0))
919+                let dy = dv(de.payments)
920+                if ((dy == 0))
913921                     then throw("you need a bigger tokens amount to launch the pool")
914922                     else {
915-                        let du = Issue(v("static_poolDomain"), "Puzzle Swap: pool index token", dt, i, true, unit, 0)
916-                        let dv = calculateAssetId(du)
917-                        (dp() ++ [du, IntegerEntry("global_poolToken_amount", dt), IntegerEntry("global_wasInited", 1), BinaryEntry("global_poolToken_id", dv), StringEntry("static_poolToken_idStr", x(dv)), IntegerEntry((toString(cZ.caller) + "_indexStaked"), dt), IntegerEntry("global_indexStaked", dt)])
923+                        let dz = Issue(("PZ " + v("static_poolDomain")), "Puzzle Swap: pool index token", dy, i, true, unit, 0)
924+                        let dA = calculateAssetId(dz)
925+                        (du() ++ [dz, IntegerEntry("global_poolToken_amount", dy), IntegerEntry("global_wasInited", 1), BinaryEntry("global_poolToken_id", dA), StringEntry("static_poolToken_idStr", x(dA)), IntegerEntry((toString(de.caller) + "_indexStaked"), dy), IntegerEntry("global_indexStaked", dy)])
918926                         }
919927                 }
920928     }
921929 
922930 
923931 
924-@Callable(cZ)
925-func generateIndex (bJ) = if ((size(cZ.payments) != ae))
926-    then throw(("you need to attach all pool tokens. amount of pool tokens: " + toString(ae)))
927-    else if (!(bz(cZ.payments)))
932+@Callable(de)
933+func generateIndex (bO) = if ((size(de.payments) != aj))
934+    then throw(("you need to attach all pool tokens. amount of pool tokens: " + toString(aj)))
935+    else if (!(bE(de.payments)))
928936         then throw("wrong assets attached")
929937         else {
930-            let dw = aR(cZ.payments)
931-            let cE = bH(dw, cZ.payments, cZ.originCaller, bJ)
932-            let dx = fraction(dw, g, aE(), DOWN)
933-            let dy = Reissue(getBinaryValue("global_poolToken_id"), dx, true)
934-            $Tuple2((cE ++ [dy, ScriptTransfer(cZ.caller, dx, u("global_poolToken_id")), IntegerEntry("global_poolToken_amount", (q("global_poolToken_amount") + dx))]), dx)
938+            let dB = aW(de.payments)
939+            let cJ = bM(dB, de.payments, de.originCaller, bO)
940+            let dC = fraction(dB, g, aJ(), DOWN)
941+            let dD = Reissue(getBinaryValue("global_poolToken_id"), dC, true)
942+            $Tuple2((cJ ++ [dD, ScriptTransfer(de.caller, dC, u("global_poolToken_id")), IntegerEntry("global_poolToken_amount", (q("global_poolToken_amount") + dC))]), dC)
935943             }
936944 
937945 
938946 
939-@Callable(cZ)
940-func redeemIndex (dz) = {
941-    let dr = cZ.payments[0]
942-    if ((dr.assetId != u("global_poolToken_id")))
947+@Callable(de)
948+func redeemIndex (dE) = {
949+    let dw = de.payments[0]
950+    if ((dw.assetId != u("global_poolToken_id")))
943951         then throw("please attach pool share token")
944-        else if (ay())
952+        else if (aD())
945953             then throw("contract is on stop")
946954             else {
947-                let dA = dr.amount
948-                let dB = fraction(dA, aE(), g, DOWN)
949-                let cE = bT(dB, if (dz)
950-                    then cZ.originCaller
951-                    else cZ.caller)
952-                (cE ++ [Burn(u("global_poolToken_id"), dA), IntegerEntry("global_poolToken_amount", (q("global_poolToken_amount") - dA))])
955+                let dF = dw.amount
956+                let dG = fraction(dF, aJ(), g, DOWN)
957+                let cJ = bY(dG, if (dE)
958+                    then de.originCaller
959+                    else de.caller)
960+                (cJ ++ [Burn(u("global_poolToken_id"), dF), IntegerEntry("global_poolToken_amount", (q("global_poolToken_amount") - dF))])
953961                 }
954962     }
955963 
956964 
957965 
958-@Callable(cZ)
966+@Callable(de)
959967 func stakeIndex () = {
960-    let cq = toString(cZ.originCaller)
961-    let dr = cZ.payments[0]
962-    if ((value(dr.assetId) != u("global_poolToken_id")))
968+    let cv = toString(de.originCaller)
969+    let dw = de.payments[0]
970+    if ((value(dw.assetId) != u("global_poolToken_id")))
963971         then throw("wrong asset attached")
964-        else cv(cq, dr.amount)
972+        else cA(cv, dw.amount)
965973     }
966974 
967975 
968976 
969-@Callable(cZ)
970-func stakeIndexFor (cq) = {
971-    let dr = cZ.payments[0]
972-    if ((value(dr.assetId) != u("global_poolToken_id")))
977+@Callable(de)
978+func stakeIndexFor (cv) = {
979+    let dw = de.payments[0]
980+    if ((value(dw.assetId) != u("global_poolToken_id")))
973981         then throw("wrong asset attached")
974-        else cv(cq, dr.amount)
982+        else cA(cv, dw.amount)
975983     }
976984 
977985 
978986 
979-@Callable(cZ)
980-func unstakeIndex (dC) = {
981-    let cq = toString(cZ.originCaller)
982-    let dD = q((cq + "_indexStaked"))
983-    if (ay())
987+@Callable(de)
988+func unstakeIndex (dH) = {
989+    let cv = if ((indexOf(ag, toString(de.caller)) != unit))
990+        then toString(de.originCaller)
991+        else toString(de.caller)
992+    let dI = q((cv + "_indexStaked"))
993+    if (aD())
984994         then throw("contract is on stop")
985-        else if ((dC > dD))
995+        else if ((dH > dI))
986996             then throw("you don't have index tokens available")
987-            else if (ay())
997+            else if (aD())
988998                 then throw("contract is on stop")
989-                else (co(cZ.originCaller)._1 ++ [IntegerEntry((cq + "_indexStaked"), (dD - dC)), IntegerEntry("global_indexStaked", (q("global_indexStaked") - dC)), ScriptTransfer(cZ.caller, dC, getBinaryValue("global_poolToken_id"))])
999+                else (ct(addressFromStringValue(cv))._1 ++ [IntegerEntry((cv + "_indexStaked"), (dI - dH)), IntegerEntry("global_indexStaked", (q("global_indexStaked") - dH)), ScriptTransfer(de.caller, dH, getBinaryValue("global_poolToken_id"))])
9901000     }
9911001 
9921002 
9931003 
994-@Callable(cZ)
995-func claimIndexRewards () = if (ay())
1004+@Callable(de)
1005+func claimIndexRewards () = if (aD())
9961006     then throw("contract is on stop")
997-    else co(cZ.caller)
1007+    else ct(de.caller)
9981008 
9991009 
10001010 
1001-@Callable(cZ)
1002-func evaluateClaim (dE) = $Tuple2(nil, co(addressFromStringValue(dE))._2)
1011+@Callable(de)
1012+func evaluateClaim (dJ) = $Tuple2(nil, ct(addressFromStringValue(dJ))._2)
10031013 
10041014 
10051015 
1006-@Callable(cZ)
1007-func swap (ca,dF) = {
1008-    let dr = if ((size(cZ.payments) == 1))
1009-        then value(cZ.payments[0])
1016+@Callable(de)
1017+func swap (cf,dK) = {
1018+    let dw = if ((size(de.payments) == 1))
1019+        then value(de.payments[0])
10101020         else throw("please attach exactly one payment")
1011-    let bY = value(cZ.payments[0].amount)
1012-    let dG = dr.assetId
1013-    let dH = z(ca)
1014-    let bZ = x(dG)
1015-    let dI = (f / q((("static_" + bZ) + "_scale")))
1016-    let dJ = (f / q((("static_" + ca) + "_scale")))
1017-    let dK = v("static_feeToken")
1018-    let dL = if ((dK == ""))
1019-        then Q
1020-        else z(dK)
1021-    let dM = q((("global_" + x(dG)) + "_balance"))
1022-    let dN = q((("global_" + ca) + "_balance"))
1023-    let dO = (dM * dI)
1024-    let dP = (dN * dJ)
1025-    let dQ = fraction(bY, aw, h)
1026-    let dR = (bY - dQ)
1027-    let dS = (dR * dI)
1028-    let dT = bX(dS, dG, dH, dO, dP)
1029-    let dU = fraction(dT, 1, dJ)
1030-    let dV = (dN - dU)
1031-    let dW = (dM + dR)
1032-    let dX = if ((dL == dG))
1033-        then dW
1034-        else if ((dL == dH))
1035-            then dV
1036-            else q((("global_" + x(dL)) + "_balance"))
1037-    let dY = bX(dQ, dG, dL, dM, dX)
1038-    if ((dF > dU))
1021+    let cd = value(de.payments[0].amount)
1022+    let dL = dw.assetId
1023+    let dM = z(cf)
1024+    let ce = x(dL)
1025+    let dN = (f / q((("static_" + ce) + "_scale")))
1026+    let dO = (f / q((("static_" + cf) + "_scale")))
1027+    let dP = v("static_feeToken")
1028+    let dQ = if ((dP == ""))
1029+        then R
1030+        else z(dP)
1031+    let dR = q((("global_" + x(dL)) + "_balance"))
1032+    let dS = q((("global_" + cf) + "_balance"))
1033+    let dT = (dR * dN)
1034+    let dU = (dS * dO)
1035+    let dV = fraction(cd, aB, h)
1036+    let dW = (cd - dV)
1037+    let dX = (dW * dN)
1038+    let dY = cc(dX, dL, dM, dT, dU)
1039+    let dZ = fraction(dY, 1, dO)
1040+    let ea = (dS - dZ)
1041+    let eb = (dR + dW)
1042+    let ec = if ((dQ == dL))
1043+        then eb
1044+        else if ((dQ == dM))
1045+            then ea
1046+            else q((("global_" + x(dQ)) + "_balance"))
1047+    let ed = cc(dV, dL, dQ, dR, ec)
1048+    if ((dK > dZ))
10391049         then throw("amount to recieve is lower than given one")
1040-        else if ((dH == dG))
1050+        else if ((dM == dL))
10411051             then throw("this swap is not allowed")
1042-            else if ((0 > (dN - dU)))
1052+            else if ((0 > (dS - dZ)))
10431053                 then throw("contract is out of reserves")
1044-                else if (ay())
1054+                else if (aD())
10451055                     then throw("contract is on stop")
10461056                     else {
1047-                        let dZ = fraction(dY, 1, 10)
1048-                        let ea = fraction(dY, 4, 10)
1049-                        let eb = if (if ((dL == Q))
1050-                            then true
1051-                            else (dL == R))
1052-                            then reentrantInvoke(aa, "topUpReward", nil, [AttachedPayment(dL, ea)])
1057+                        let ee = fraction(ed, 1, 10)
1058+                        let ef = fraction(ed, 4, 10)
1059+                        let eg = eb
1060+                        let eh = (ea - (if ((dM == dQ))
1061+                            then ed
1062+                            else 0))
1063+                        let ei = if (if ((dQ != dL))
1064+                            then (dQ != dM)
1065+                            else false)
1066+                            then (ec - ed)
10531067                             else unit
1054-                        if ((eb == eb))
1055-                            then {
1056-                                let ec = dW
1057-                                let ed = (dV - (if ((dH == dL))
1058-                                    then dY
1059-                                    else 0))
1060-                                let ee = if (if ((dL != dG))
1061-                                    then (dL != dH)
1062-                                    else false)
1063-                                    then (dX - dY)
1064-                                    else unit
1065-                                let ef = IntegerEntry((("global_" + x(dG)) + "_balance"), ec)
1066-                                let eg = IntegerEntry((("global_" + ca) + "_balance"), ed)
1067-                                let eh = if ((ee != unit))
1068-                                    then IntegerEntry((("global_" + x(dL)) + "_balance"), value(ee))
1069-                                    else StringEntry("hello", "world")
1070-                                let ei = aX(dG, bY, dM, dX)
1071-                                let ej = bs(dG, bY, dM)
1072-                                $Tuple2(([eg, ef, eh, ScriptTransfer(cZ.caller, dU, dH), ScriptTransfer(addressFromStringValue(v("static_poolOwner")), dZ, dL), IntegerEntry("global_earnedByOwner", (q("global_earnedByOwner") + dZ)), IntegerEntry("global_volume", (q("global_volume") + ei)), IntegerEntry("global_volume_usd", (q("global_volume_usd") + ej))] ++ (if ((eb == unit))
1073-                                    then [ScriptTransfer(ab, ea, dL)]
1074-                                    else nil)), dU)
1075-                                }
1076-                            else throw("Strict value is not equal to itself.")
1068+                        let ej = IntegerEntry((("global_" + x(dL)) + "_balance"), eg)
1069+                        let ek = IntegerEntry((("global_" + cf) + "_balance"), eh)
1070+                        let el = if ((ei != unit))
1071+                            then IntegerEntry((("global_" + x(dQ)) + "_balance"), value(ei))
1072+                            else StringEntry("hello", "world")
1073+                        let em = bc(dL, cd, dR, ec)
1074+                        let en = bx(dL, cd, dR)
1075+                        $Tuple2([ek, ej, el, ScriptTransfer(de.caller, dZ, dM), ScriptTransfer(addressFromStringValue(v("static_poolOwner")), ee, dQ), IntegerEntry("global_earnedByOwner", (q("global_earnedByOwner") + ee)), IntegerEntry("global_volume", (q("global_volume") + em)), IntegerEntry("global_volume_usd", (q("global_volume_usd") + en)), ScriptTransfer(ad, ef, dQ)], dZ)
10771076                         }
10781077     }
10791078 
10801079 
10811080 
1082-@Callable(cZ)
1083-func swapReadOnly (bZ,ca,bY) = {
1084-    let dG = z(bZ)
1085-    let dH = z(ca)
1086-    let dI = (f / q((("static_" + bZ) + "_scale")))
1087-    let dJ = (f / q((("static_" + ca) + "_scale")))
1088-    let dK = v("static_feeToken")
1089-    let dL = if ((dK == ""))
1090-        then Q
1091-        else z(dK)
1092-    let dM = q((("global_" + x(dG)) + "_balance"))
1093-    let dN = q((("global_" + ca) + "_balance"))
1094-    let dO = (dM * dI)
1095-    let dP = (dN * dJ)
1096-    let dQ = fraction(bY, aw, h)
1097-    let dR = (bY - dQ)
1098-    let dS = (dR * dI)
1099-    let dT = bX(dS, dG, dH, dO, dP)
1100-    let dU = fraction(dT, 1, dJ)
1101-    let dV = (dN - dU)
1102-    let dW = (dM + dR)
1103-    let dX = if ((dL == dG))
1104-        then dW
1105-        else if ((dL == dH))
1106-            then dV
1107-            else q((("global_" + x(dL)) + "_balance"))
1108-    let dY = bX(dQ, dG, dL, dM, dX)
1109-    if ((dH == dG))
1081+@Callable(de)
1082+func swapReadOnly (ce,cf,cd) = {
1083+    let dL = z(ce)
1084+    let dM = z(cf)
1085+    let dN = (f / q((("static_" + ce) + "_scale")))
1086+    let dO = (f / q((("static_" + cf) + "_scale")))
1087+    let dP = v("static_feeToken")
1088+    let dQ = if ((dP == ""))
1089+        then R
1090+        else z(dP)
1091+    let dR = q((("global_" + x(dL)) + "_balance"))
1092+    let dS = q((("global_" + cf) + "_balance"))
1093+    let dT = (dR * dN)
1094+    let dU = (dS * dO)
1095+    let dV = fraction(cd, aB, h)
1096+    let dW = (cd - dV)
1097+    let dX = (dW * dN)
1098+    let dY = cc(dX, dL, dM, dT, dU)
1099+    let dZ = fraction(dY, 1, dO)
1100+    let ea = (dS - dZ)
1101+    let eb = (dR + dW)
1102+    let ec = if ((dQ == dL))
1103+        then eb
1104+        else if ((dQ == dM))
1105+            then ea
1106+            else q((("global_" + x(dQ)) + "_balance"))
1107+    let ed = cc(dV, dL, dQ, dR, ec)
1108+    if ((dM == dL))
11101109         then throw("this swap is not allowed")
1111-        else if ((0 > (dN - dU)))
1110+        else if ((0 > (dS - dZ)))
11121111             then throw("contract is out of reserves")
1113-            else if (ay())
1112+            else if (aD())
11141113                 then throw("contract is on stop")
1115-                else $Tuple2(nil, dU)
1114+                else $Tuple2(nil, dZ)
11161115     }
11171116 
11181117 
11191118 
1120-@Callable(cZ)
1121-func transferOwnership (ek) = if ((toString(cZ.caller) != v("static_poolOwner")))
1119+@Callable(de)
1120+func transferOwnership (eo) = if ((toString(de.caller) != v("static_poolOwner")))
11221121     then throw("this call available only for pool owner")
1123-    else [StringEntry("static_poolOwner", ek)]
1122+    else [StringEntry("static_poolOwner", eo)]
11241123 
11251124 
11261125 
1127-@Callable(cZ)
1128-func setFee (el) = if ((toString(cZ.caller) != v("static_poolOwner")))
1126+@Callable(de)
1127+func setFee (ep) = if ((toString(de.caller) != v("static_poolOwner")))
11291128     then throw("this call available only for pool owner")
1130-    else [IntegerEntry("static_fee", el)]
1129+    else if ((1 > valueOrElse(getInteger(ah, ("approvedTx_" + toBase58String(de.transactionId))), 0)))
1130+        then throw("this transaction needs approval from puzzle network")
1131+        else [IntegerEntry("static_fee", ep)]
11311132 
11321133 
11331134 
1134-@Callable(cZ)
1135-func setRebalancingPlan (da,db,dc,em,en) = if ((cZ.caller != addressFromStringValue(v("static_poolOwner"))))
1135+@Callable(de)
1136+func setRebalancingPlan (df,dg,dh,eq,er) = if ((de.caller != addressFromStringValue(v("static_poolOwner"))))
11361137     then throw("this call available only for pool owner")
11371138     else if (valueOrElse(getBoolean(this, "rebalance_inProgress"), false))
11381139         then throw("rebalancing in progress")
11391140         else {
1140-            let eo = split(db, ",")
1141-            let ep = split(da, ",")
1142-            let bg = {
1143-                let ag = ep
1144-                let ah = size(ag)
1145-                let ai = ""
1146-                func aI (ak,al) =                 if ((al >= ah))
1147-                    then ak
1148-                    else cz(ak, ag[al])
1141+            let es = split(dg, ",")
1142+            let et = split(df, ",")
1143+            let bl = {
1144+                let al = et
1145+                let am = size(al)
1146+                let an = ""
1147+                func aN (ap,aq) =                 if ((aq >= am))
1148+                    then ap
1149+                    else cE(ap, al[aq])
11491150 
1150-                func aJ (ak,al) =                 if ((al >= ah))
1151-                    then ak
1151+                func aO (ap,aq) =                 if ((aq >= am))
1152+                    then ap
11521153                     else throw("List size exceeds 10")
11531154 
1154-                aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1155+                aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
11551156                 }
1156-            let dj = {
1157-                let ag = eo
1158-                let ah = size(ag)
1159-                let ai = 0
1160-                func bF (ak,al) =                 if ((al >= ah))
1161-                    then ak
1162-                    else cx(ak, ag[al])
1157+            let do = {
1158+                let al = es
1159+                let am = size(al)
1160+                let an = 0
1161+                func bK (ap,aq) =                 if ((aq >= am))
1162+                    then ap
1163+                    else cC(ap, al[aq])
11631164 
1164-                func bG (ak,al) =                 if ((al >= ah))
1165-                    then ak
1165+                func bL (ap,aq) =                 if ((aq >= am))
1166+                    then ap
11661167                     else throw("List size exceeds 10")
11671168 
1168-                bG(bF(bF(bF(bF(bF(bF(bF(bF(bF(bF(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1169+                bL(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
11691170                 }
1170-            let eq = getStringValue("static_tokenIds")
1171-            let er = split(eq, ",")
1172-            func es (E,cA) =             if ((indexOf(er, cA) == unit))
1173-                then (E ++ [cA])
1171+            let eu = getStringValue("static_tokenIds")
1172+            let ev = split(eu, ",")
1173+            func ew (E,cF) =             if ((indexOf(ev, cF) == unit))
1174+                then (E ++ [cF])
11741175                 else E
11751176 
1176-            func et (E,cA) =             if ((indexOf(ep, cA) == unit))
1177-                then (E ++ [cA])
1177+            func ex (E,cF) =             if ((indexOf(et, cF) == unit))
1178+                then (E ++ [cF])
11781179                 else E
11791180 
1180-            let eu = {
1181-                let ag = ep
1182-                let ah = size(ag)
1183-                let ai = nil
1184-                func cS (ak,al) =                 if ((al >= ah))
1185-                    then ak
1186-                    else es(ak, ag[al])
1181+            let ey = {
1182+                let al = et
1183+                let am = size(al)
1184+                let an = nil
1185+                func cX (ap,aq) =                 if ((aq >= am))
1186+                    then ap
1187+                    else ew(ap, al[aq])
11871188 
1188-                func cT (ak,al) =                 if ((al >= ah))
1189-                    then ak
1189+                func cY (ap,aq) =                 if ((aq >= am))
1190+                    then ap
11901191                     else throw("List size exceeds 10")
11911192 
1192-                cT(cS(cS(cS(cS(cS(cS(cS(cS(cS(cS(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1193+                cY(cX(cX(cX(cX(cX(cX(cX(cX(cX(cX(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
11931194                 }
1194-            let ev = {
1195-                let ag = er
1196-                let ah = size(ag)
1197-                let ai = nil
1198-                func dn (ak,al) =                 if ((al >= ah))
1199-                    then ak
1200-                    else et(ak, ag[al])
1195+            let ez = {
1196+                let al = ev
1197+                let am = size(al)
1198+                let an = nil
1199+                func ds (ap,aq) =                 if ((aq >= am))
1200+                    then ap
1201+                    else ex(ap, al[aq])
12011202 
1202-                func do (ak,al) =                 if ((al >= ah))
1203-                    then ak
1203+                func dt (ap,aq) =                 if ((aq >= am))
1204+                    then ap
12041205                     else throw("List size exceeds 10")
12051206 
1206-                do(dn(dn(dn(dn(dn(dn(dn(dn(dn(dn(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1207+                dt(ds(ds(ds(ds(ds(ds(ds(ds(ds(ds(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
12071208                 }
1208-            let ew = cL(eu, cZ.payments)
1209-            let ex = cU(eo)
1210-            if ((ex == ex))
1211-                then if ((ew != (size(eu) + size(cZ.payments))))
1209+            let eA = cQ(ey, de.payments)
1210+            let eB = cZ(es)
1211+            if ((eB == eB))
1212+                then if ((eA != (size(ey) + size(de.payments))))
12121213                     then throw("Payments not present or something wrong with them")
1213-                    else if ((size(ep) != size(eo)))
1214+                    else if ((size(et) != size(es)))
12141215                         then throw("assetIds and assetWeights should have same length")
1215-                        else if ((ew != (size(eu) + size(cZ.payments))))
1216+                        else if ((eA != (size(ey) + size(de.payments))))
12161217                             then throw("Payments not present or something wrong with them")
1217-                            else if ((bg == ""))
1218+                            else if ((bl == ""))
12181219                                 then throw("pool must have one of the supported fee assets in the composition")
1219-                                else if ((indexOf(ep, dc) == unit))
1220+                                else if ((indexOf(et, dh) == unit))
12201221                                     then throw("baseTokenId should be present in assetIds")
1221-                                    else if (if ((k > em))
1222+                                    else if (if ((k > eq))
12221223                                         then true
1223-                                        else (em > l))
1224-                                        then throw(((((("Steps amount should be between " + toString(k)) + " and ") + toString(l)) + ", current: ") + toString(em)))
1225-                                        else if (if ((m > en))
1224+                                        else (eq > l))
1225+                                        then throw(((((("Steps amount should be between " + toString(k)) + " and ") + toString(l)) + ", current: ") + toString(eq)))
1226+                                        else if (if ((m > er))
12261227                                             then true
1227-                                            else (en > n))
1228-                                            then throw(((((("Steps interval should be between " + toString(m)) + " and ") + toString(n)) + ", current: ") + toString(en)))
1229-                                            else if ((dj != 10000))
1230-                                                then throw(("sum of token weights must be equal to 10000, current: " + toString(dj)))
1228+                                            else (er > n))
1229+                                            then throw(((((("Steps interval should be between " + toString(m)) + " and ") + toString(n)) + ", current: ") + toString(er)))
1230+                                            else if ((do != 10000))
1231+                                                then throw(("sum of token weights must be equal to 10000, current: " + toString(do)))
12311232                                                 else {
1232-                                                    func cF (E,A) =                                                     {
1233-                                                        let ey = q((("static_" + A) + "_weight"))
1234-                                                        let ez = if ((indexOf(ep, A) == unit))
1233+                                                    func cK (E,A) =                                                     {
1234+                                                        let eC = q((("static_" + A) + "_weight"))
1235+                                                        let eD = if ((indexOf(et, A) == unit))
12351236                                                             then 0
1236-                                                            else parseIntValue(value(eo[value(indexOf(ep, A))]))
1237-                                                        let eA = fraction((ez - ey), 10000, em)
1238-                                                        (E ++ [toString(eA)])
1237+                                                            else parseIntValue(value(es[value(indexOf(et, A))]))
1238+                                                        let eE = fraction((eD - eC), 10000, eq)
1239+                                                        (E ++ [toString(eE)])
12391240                                                         }
12401241 
1241-                                                    let eB = cB(ep)
1242-                                                    let eC = {
1243-                                                        let ag = eB
1244-                                                        let ah = size(ag)
1245-                                                        let ai = nil
1246-                                                        func eD (ak,al) =                                                         if ((al >= ah))
1247-                                                            then ak
1248-                                                            else cF(ak, ag[al])
1242+                                                    let eF = cG(et)
1243+                                                    let eG = {
1244+                                                        let al = eF
1245+                                                        let am = size(al)
1246+                                                        let an = nil
1247+                                                        func eH (ap,aq) =                                                         if ((aq >= am))
1248+                                                            then ap
1249+                                                            else cK(ap, al[aq])
12491250 
1250-                                                        func eE (ak,al) =                                                         if ((al >= ah))
1251-                                                            then ak
1251+                                                        func eI (ap,aq) =                                                         if ((aq >= am))
1252+                                                            then ap
12521253                                                             else throw("List size exceeds 10")
12531254 
1254-                                                        eE(eD(eD(eD(eD(eD(eD(eD(eD(eD(eD(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1255+                                                        eI(eH(eH(eH(eH(eH(eH(eH(eH(eH(eH(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
12551256                                                         }
1256-                                                    let eF = (cG(ep) > 0)
1257-                                                    func eG (E,cA) =                                                     (E ++ [IntegerEntry(("rebalance_attachedPayment_" + x(cA.assetId)), cA.amount)])
1257+                                                    let eJ = (cL(et) > 0)
1258+                                                    func eK (E,cF) =                                                     (E ++ [IntegerEntry(("rebalance_attachedPayment_" + x(cF.assetId)), cF.amount)])
12581259 
1259-                                                    let eH = {
1260-                                                        let ag = cZ.payments
1261-                                                        let ah = size(ag)
1262-                                                        let ai = nil
1263-                                                        func eI (ak,al) =                                                         if ((al >= ah))
1264-                                                            then ak
1265-                                                            else eG(ak, ag[al])
1260+                                                    let eL = {
1261+                                                        let al = de.payments
1262+                                                        let am = size(al)
1263+                                                        let an = nil
1264+                                                        func eM (ap,aq) =                                                         if ((aq >= am))
1265+                                                            then ap
1266+                                                            else eK(ap, al[aq])
12661267 
1267-                                                        func eJ (ak,al) =                                                         if ((al >= ah))
1268-                                                            then ak
1268+                                                        func eN (ap,aq) =                                                         if ((aq >= am))
1269+                                                            then ap
12691270                                                             else throw("List size exceeds 10")
12701271 
1271-                                                        eJ(eI(eI(eI(eI(eI(eI(eI(eI(eI(eI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1272+                                                        eN(eM(eM(eM(eM(eM(eM(eM(eM(eM(eM(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
12721273                                                         }
1273-                                                    let eK = aF()
1274-                                                    let eL = invoke(ac, "notifyPoolChange", nil, nil)
1275-                                                    if ((eL == eL))
1276-                                                        then (([StringEntry("rebalance_addedAssets", makeString(eu, ",")), StringEntry("rebalance_removedAssets", makeString(ev, ",")), StringEntry("tmp_rebalanceAssetIds", makeString(eB, ",")), BooleanEntry("rebalance_inProgress", true), BooleanEntry("rebalance_newTokensAdded", eF), IntegerEntry("rebalance_stepsDone", 0), IntegerEntry("rebalance_lastStepHeight", height), IntegerEntry("rebalance_stepsAmount", em), IntegerEntry("rebalance_stepsInterval", en), StringEntry("rebalance_assetIds", da), StringEntry("rebalance_newBaseTokenId", dc), StringEntry("rebalance_assetDeltas", makeString(eC, ","))] ++ eH) ++ eK)
1274+                                                    let eO = aK()
1275+                                                    let eP = invoke(ah, "requestRebalancing", [toBase58String(de.transactionId)], nil)
1276+                                                    if ((eP == eP))
1277+                                                        then (([StringEntry("rebalance_addedAssets", makeString(ey, ",")), StringEntry("rebalance_removedAssets", makeString(ez, ",")), StringEntry("tmp_rebalanceAssetIds", makeString(eF, ",")), BooleanEntry("rebalance_inProgress", true), BooleanEntry("rebalance_newTokensAdded", eJ), IntegerEntry("rebalance_stepsDone", 0), IntegerEntry("rebalance_lastStepHeight", height), IntegerEntry("rebalance_stepsAmount", eq), IntegerEntry("rebalance_stepsInterval", er), StringEntry("rebalance_assetIds", df), StringEntry("rebalance_newBaseTokenId", dh), StringEntry("rebalance_assetDeltas", makeString(eG, ","))] ++ eL) ++ eO)
12771278                                                         else throw("Strict value is not equal to itself.")
12781279                                                     }
12791280                 else throw("Strict value is not equal to itself.")
12811282 
12821283 
12831284 
1284-@Callable(cZ)
1285-func stepRebalancing () = if (!(valueOrElse(getBoolean(this, "rebalance_inProgress"), false)))
1286-    then throw("no rebalancing in progress")
1287-    else {
1288-        let eM = getIntegerValue("rebalance_lastStepHeight")
1289-        let eN = getIntegerValue("rebalance_stepsInterval")
1290-        let eO = getIntegerValue("rebalance_stepsDone")
1291-        let eP = (eM + eN)
1292-        if ((eP > height))
1293-            then throw("can't be done yet")
1285+@Callable(de)
1286+func stepRebalancing () = {
1287+    let eQ = valueOrErrorMessage(getString(ah, ("pool_lastRebalancing_" + toString(this))), "rebalancing is not registered at gov address")
1288+    if (!(valueOrElse(getBoolean(this, "rebalance_inProgress"), false)))
1289+        then throw("no rebalancing in progress")
1290+        else if ((valueOrElse(getInteger(ah, ("rebalancing_status_" + eQ)), 0) != 2))
1291+            then throw("this transaction needs approval from puzzle network")
12941292             else {
1295-                let eC = split(getStringValue("rebalance_assetDeltas"), ",")
1296-                let eQ = getStringValue("tmp_rebalanceAssetIds")
1297-                let eR = split(eQ, ",")
1298-                func cF (E,A) =                 (E ++ [toString(fraction(((valueOrElse(getInteger(("rebalance_startWeight_" + A)), 0) * 10000) + (parseIntValue(eC[value(indexOf(eR, A))]) * (eO + 1))), 1, 10000, HALFUP))])
1293+                let eR = getIntegerValue("rebalance_lastStepHeight")
1294+                let eS = getIntegerValue("rebalance_stepsInterval")
1295+                let eT = getIntegerValue("rebalance_stepsDone")
1296+                let eU = (eR + eS)
1297+                if ((eU > height))
1298+                    then throw("can't be done yet")
1299+                    else {
1300+                        let eG = split(getStringValue("rebalance_assetDeltas"), ",")
1301+                        let eV = getStringValue("tmp_rebalanceAssetIds")
1302+                        let eW = split(eV, ",")
1303+                        func cK (E,A) =                         (E ++ [toString(fraction(((valueOrElse(getInteger(("rebalance_startWeight_" + A)), 0) * 10000) + (parseIntValue(eG[value(indexOf(eW, A))]) * (eT + 1))), 1, 10000, HALFUP))])
12991304 
1300-                let eS = makeString({
1301-                    let ag = eR
1302-                    let ah = size(ag)
1303-                    let ai = nil
1304-                    func aI (ak,al) =                     if ((al >= ah))
1305-                        then ak
1306-                        else cF(ak, ag[al])
1305+                        let eX = makeString({
1306+                            let al = eW
1307+                            let am = size(al)
1308+                            let an = nil
1309+                            func aN (ap,aq) =                             if ((aq >= am))
1310+                                then ap
1311+                                else cK(ap, al[aq])
13071312 
1308-                    func aJ (ak,al) =                     if ((al >= ah))
1309-                        then ak
1310-                        else throw("List size exceeds 10")
1313+                            func aO (ap,aq) =                             if ((aq >= am))
1314+                                then ap
1315+                                else throw("List size exceeds 10")
13111316 
1312-                    aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1313-                    }, ",")
1314-                let eF = getBooleanValue("rebalance_newTokensAdded")
1315-                let eT = if (if (eF)
1316-                    then (eO == 0)
1317-                    else false)
1318-                    then invoke(this, "doRebalancingWithNewTokens", [eQ, eS, getStringValue("rebalance_newBaseTokenId")], nil)
1319-                    else invoke(this, "doRebalancing", [eS], nil)
1320-                if ((eT == eT))
1321-                    then {
1322-                        let eL = invoke(ac, "notifyPoolChange", nil, nil)
1323-                        if ((eL == eL))
1317+                            aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1318+                            }, ",")
1319+                        let eJ = getBooleanValue("rebalance_newTokensAdded")
1320+                        let eY = if (if (eJ)
1321+                            then (eT == 0)
1322+                            else false)
1323+                            then invoke(this, "doRebalancingWithNewTokens", [eV, eX, getStringValue("rebalance_newBaseTokenId")], nil)
1324+                            else invoke(this, "doRebalancing", [eX], nil)
1325+                        if ((eY == eY))
13241326                             then {
1325-                                let eU = ((eO + 1) >= getIntegerValue("rebalance_stepsAmount"))
1326-                                let eV = [BooleanEntry("rebalance_inProgress", !(eU)), IntegerEntry("rebalance_stepsDone", (eO + 1)), IntegerEntry("rebalance_lastStepHeight", height)]
1327-                                if ((eO == 0))
1328-                                    then (eV ++ [StringEntry("static_tokenIds", eQ)])
1329-                                    else if (eU)
1330-                                        then {
1331-                                            let eW = split(v("rebalance_removedAssets"), ",")
1332-                                            func eX (E,y) =                                             (E ++ [DeleteEntry((("static_" + y) + "_scale")), DeleteEntry((("static_" + y) + "_decimals")), DeleteEntry((("static_" + y) + "_weight")), DeleteEntry((("global_" + y) + "_balance")), DeleteEntry(("rebalance_attachedPayment_" + y))])
1327+                                let eZ = invoke(ae, "notifyPoolChange", nil, nil)
1328+                                if ((eZ == eZ))
1329+                                    then {
1330+                                        let fa = ((eT + 1) >= getIntegerValue("rebalance_stepsAmount"))
1331+                                        let fb = [BooleanEntry("rebalance_inProgress", !(fa)), IntegerEntry("rebalance_stepsDone", (eT + 1)), IntegerEntry("rebalance_lastStepHeight", height)]
1332+                                        if ((eT == 0))
1333+                                            then (fb ++ [StringEntry("static_tokenIds", eV)])
1334+                                            else if (fa)
1335+                                                then {
1336+                                                    let fc = split(v("rebalance_removedAssets"), ",")
1337+                                                    func fd (E,y) =                                                     (E ++ [DeleteEntry((("static_" + y) + "_scale")), DeleteEntry((("static_" + y) + "_decimals")), DeleteEntry((("static_" + y) + "_weight")), DeleteEntry((("global_" + y) + "_balance")), DeleteEntry(("rebalance_attachedPayment_" + y))])
13331338 
1334-                                            let eY = {
1335-                                                let ag = eW
1336-                                                let ah = size(ag)
1337-                                                let ai = nil
1338-                                                func bF (ak,al) =                                                 if ((al >= ah))
1339-                                                    then ak
1340-                                                    else eX(ak, ag[al])
1339+                                                    let fe = {
1340+                                                        let al = fc
1341+                                                        let am = size(al)
1342+                                                        let an = nil
1343+                                                        func bK (ap,aq) =                                                         if ((aq >= am))
1344+                                                            then ap
1345+                                                            else fd(ap, al[aq])
13411346 
1342-                                                func bG (ak,al) =                                                 if ((al >= ah))
1343-                                                    then ak
1344-                                                    else throw("List size exceeds 10")
1347+                                                        func bL (ap,aq) =                                                         if ((aq >= am))
1348+                                                            then ap
1349+                                                            else throw("List size exceeds 10")
13451350 
1346-                                                bG(bF(bF(bF(bF(bF(bF(bF(bF(bF(bF(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1347-                                                }
1348-                                            let eZ = split(v("rebalance_addedAssets"), ",")
1349-                                            func fa (E,y) =                                             (E ++ [DeleteEntry(("rebalance_attachedPayment_" + y))])
1351+                                                        bL(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1352+                                                        }
1353+                                                    let ff = split(v("rebalance_addedAssets"), ",")
1354+                                                    func fg (E,y) =                                                     (E ++ [DeleteEntry(("rebalance_attachedPayment_" + y))])
13501355 
1351-                                            let fb = {
1352-                                                let ag = eZ
1353-                                                let ah = size(ag)
1354-                                                let ai = nil
1355-                                                func cS (ak,al) =                                                 if ((al >= ah))
1356-                                                    then ak
1357-                                                    else fa(ak, ag[al])
1356+                                                    let fh = {
1357+                                                        let al = ff
1358+                                                        let am = size(al)
1359+                                                        let an = nil
1360+                                                        func cX (ap,aq) =                                                         if ((aq >= am))
1361+                                                            then ap
1362+                                                            else fg(ap, al[aq])
13581363 
1359-                                                func cT (ak,al) =                                                 if ((al >= ah))
1360-                                                    then ak
1361-                                                    else throw("List size exceeds 10")
1364+                                                        func cY (ap,aq) =                                                         if ((aq >= am))
1365+                                                            then ap
1366+                                                            else throw("List size exceeds 10")
13621367 
1363-                                                cT(cS(cS(cS(cS(cS(cS(cS(cS(cS(cS(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1364-                                                }
1365-                                            let fc = v("rebalance_assetIds")
1366-                                            let fd = {
1367-                                                let ag = split(fc, ",")
1368-                                                let ah = size(ag)
1369-                                                let ai = nil
1370-                                                func dn (ak,al) =                                                 if ((al >= ah))
1371-                                                    then ak
1372-                                                    else H(ak, ag[al])
1368+                                                        cY(cX(cX(cX(cX(cX(cX(cX(cX(cX(cX(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1369+                                                        }
1370+                                                    let fi = v("rebalance_assetIds")
1371+                                                    let fj = {
1372+                                                        let al = split(fi, ",")
1373+                                                        let am = size(al)
1374+                                                        let an = nil
1375+                                                        func ds (ap,aq) =                                                         if ((aq >= am))
1376+                                                            then ap
1377+                                                            else H(ap, al[aq])
13731378 
1374-                                                func do (ak,al) =                                                 if ((al >= ah))
1375-                                                    then ak
1376-                                                    else throw("List size exceeds 10")
1379+                                                        func dt (ap,aq) =                                                         if ((aq >= am))
1380+                                                            then ap
1381+                                                            else throw("List size exceeds 10")
13771382 
1378-                                                do(dn(dn(dn(dn(dn(dn(dn(dn(dn(dn(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1379-                                                }
1380-                                            (((eV ++ eY) ++ fb) ++ [StringEntry("static_tokenIds", fc), StringEntry("static_tokenWeights", makeString(fd, ",")), IntegerEntry("static_tokensAmount", size(split(fc, ",")))])
1381-                                            }
1382-                                        else {
1383-                                            let fc = v("rebalance_assetIds")
1384-                                            let fd = {
1385-                                                let ag = split(fc, ",")
1386-                                                let ah = size(ag)
1387-                                                let ai = nil
1388-                                                func bF (ak,al) =                                                 if ((al >= ah))
1389-                                                    then ak
1390-                                                    else H(ak, ag[al])
1383+                                                        dt(ds(ds(ds(ds(ds(ds(ds(ds(ds(ds(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1384+                                                        }
1385+                                                    let fk = invoke(ah, "notifyRebalancingDone", [eQ], nil)
1386+                                                    if ((fk == fk))
1387+                                                        then (((fb ++ fe) ++ fh) ++ [StringEntry("static_tokenIds", fi), StringEntry("static_tokenWeights", makeString(fj, ",")), IntegerEntry("static_tokensAmount", size(split(fi, ",")))])
1388+                                                        else throw("Strict value is not equal to itself.")
1389+                                                    }
1390+                                                else {
1391+                                                    let fi = v("rebalance_assetIds")
1392+                                                    let fj = {
1393+                                                        let al = split(fi, ",")
1394+                                                        let am = size(al)
1395+                                                        let an = nil
1396+                                                        func bK (ap,aq) =                                                         if ((aq >= am))
1397+                                                            then ap
1398+                                                            else H(ap, al[aq])
13911399 
1392-                                                func bG (ak,al) =                                                 if ((al >= ah))
1393-                                                    then ak
1394-                                                    else throw("List size exceeds 10")
1400+                                                        func bL (ap,aq) =                                                         if ((aq >= am))
1401+                                                            then ap
1402+                                                            else throw("List size exceeds 10")
13951403 
1396-                                                bG(bF(bF(bF(bF(bF(bF(bF(bF(bF(bF(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1397-                                                }
1398-                                            (eV ++ [StringEntry("static_tokenWeights", makeString(fd, ","))])
1399-                                            }
1404+                                                        bL(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1405+                                                        }
1406+                                                    (fb ++ [StringEntry("static_tokenWeights", makeString(fj, ","))])
1407+                                                    }
1408+                                        }
1409+                                    else throw("Strict value is not equal to itself.")
14001410                                 }
14011411                             else throw("Strict value is not equal to itself.")
14021412                         }
1403-                    else throw("Strict value is not equal to itself.")
14041413                 }
1405-        }
1414+    }
14061415 
14071416 
14081417 
1409-@Callable(cZ)
1410-func doRebalancing (db) = {
1411-    let di = split(db, ",")
1412-    let dj = {
1413-        let ag = di
1414-        let ah = size(ag)
1415-        let ai = 0
1416-        func aI (ak,al) =         if ((al >= ah))
1417-            then ak
1418-            else cx(ak, ag[al])
1418+@Callable(de)
1419+func doRebalancing (dg) = {
1420+    let dn = split(dg, ",")
1421+    let do = {
1422+        let al = dn
1423+        let am = size(al)
1424+        let an = 0
1425+        func aN (ap,aq) =         if ((aq >= am))
1426+            then ap
1427+            else cC(ap, al[aq])
14191428 
1420-        func aJ (ak,al) =         if ((al >= ah))
1421-            then ak
1429+        func aO (ap,aq) =         if ((aq >= am))
1430+            then ap
14221431             else throw("List size exceeds 10")
14231432 
1424-        aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1433+        aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
14251434         }
1426-    let dh = split(v("static_tokenIds"), ",")
1427-    if ((cZ.caller != this))
1435+    let dm = split(v("static_tokenIds"), ",")
1436+    if ((de.caller != this))
14281437         then throw("this call available only for admin")
14291438         else {
1430-            let fe = aE()
1431-            func aT (ff,y) =             {
1432-                let E = ff._1
1439+            let fl = aJ()
1440+            func aY (fm,y) =             {
1441+                let E = fm._1
14331442                 let A = x(y)
1434-                func bD (E,cy) =                 if ((cy == y))
1435-                    then value(indexOf(af, cy))
1443+                func bI (E,cD) =                 if ((cD == y))
1444+                    then value(indexOf(ak, cD))
14361445                     else E
14371446 
1438-                let ds = {
1439-                    let ag = af
1440-                    let ah = size(ag)
1441-                    let ai = 1
1442-                    func bF (ak,al) =                     if ((al >= ah))
1443-                        then ak
1444-                        else bD(ak, ag[al])
1447+                let dx = {
1448+                    let al = ak
1449+                    let am = size(al)
1450+                    let an = 1
1451+                    func bK (ap,aq) =                     if ((aq >= am))
1452+                        then ap
1453+                        else bI(ap, al[aq])
14451454 
1446-                    func bG (ak,al) =                     if ((al >= ah))
1447-                        then ak
1455+                    func bL (ap,aq) =                     if ((aq >= am))
1456+                        then ap
14481457                         else throw("List size exceeds 10")
14491458 
1450-                    bG(bF(bF(bF(bF(bF(bF(bF(bF(bF(bF(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1459+                    bL(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
14511460                     }
1452-                let fg = q((("global_" + A) + "_balance"))
1453-                let fh = if ((ff._2 == "new"))
1454-                    then parseIntValue(di[ds])
1461+                let fn = q((("global_" + A) + "_balance"))
1462+                let fo = if ((fm._2 == "new"))
1463+                    then parseIntValue(dn[dx])
14551464                     else q((("static_" + A) + "_weight"))
1456-                $Tuple2(fraction(E, pow(fg, aq[ds], fh, d, 8, FLOOR), f), ff._2)
1465+                $Tuple2(fraction(E, pow(fn, av[dx], fo, d, 8, FLOOR), f), fm._2)
14571466                 }
14581467 
1459-            let fi = (            let ag = af
1460-            let ah = size(ag)
1461-            let ai = $Tuple2(j, "new")
1462-            func bF (ak,al) =             if ((al >= ah))
1463-                then ak
1464-                else aT(ak, ag[al])
1468+            let fp = (            let al = ak
1469+            let am = size(al)
1470+            let an = $Tuple2(j, "new")
1471+            func bK (ap,aq) =             if ((aq >= am))
1472+                then ap
1473+                else aY(ap, al[aq])
14651474 
1466-            func bG (ak,al) =             if ((al >= ah))
1467-                then ak
1475+            func bL (ap,aq) =             if ((aq >= am))
1476+                then ap
14681477                 else throw("List size exceeds 10")
14691478 
1470-            bG(bF(bF(bF(bF(bF(bF(bF(bF(bF(bF(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10))._1
1471-            let fj = (            let ag = af
1472-            let ah = size(ag)
1473-            let ai = $Tuple2(j, "old")
1474-            func cS (ak,al) =             if ((al >= ah))
1475-                then ak
1476-                else aT(ak, ag[al])
1479+            bL(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10))._1
1480+            let fq = (            let al = ak
1481+            let am = size(al)
1482+            let an = $Tuple2(j, "old")
1483+            func cX (ap,aq) =             if ((aq >= am))
1484+                then ap
1485+                else aY(ap, al[aq])
14771486 
1478-            func cT (ak,al) =             if ((al >= ah))
1479-                then ak
1487+            func cY (ap,aq) =             if ((aq >= am))
1488+                then ap
14801489                 else throw("List size exceeds 10")
14811490 
1482-            cT(cS(cS(cS(cS(cS(cS(cS(cS(cS(cS(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10))._1
1483-            let fk = fraction(fe, fi, fj)
1484-            func dk (E,dl) =             if ((dl >= size(di)))
1491+            cY(cX(cX(cX(cX(cX(cX(cX(cX(cX(cX(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10))._1
1492+            let fr = fraction(fl, fp, fq)
1493+            func dp (E,dq) =             if ((dq >= size(dn)))
14851494                 then E
1486-                else (E ++ [IntegerEntry((("static_" + dh[dl]) + "_weight"), value(parseInt(di[dl])))])
1495+                else (E ++ [IntegerEntry((("static_" + dm[dq]) + "_weight"), value(parseInt(dn[dq])))])
14871496 
14881497             ({
1489-                let ag = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
1490-                let ah = size(ag)
1491-                let ai = nil
1492-                func dn (ak,al) =                 if ((al >= ah))
1493-                    then ak
1494-                    else dk(ak, ag[al])
1498+                let al = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
1499+                let am = size(al)
1500+                let an = nil
1501+                func ds (ap,aq) =                 if ((aq >= am))
1502+                    then ap
1503+                    else dp(ap, al[aq])
14951504 
1496-                func do (ak,al) =                 if ((al >= ah))
1497-                    then ak
1505+                func dt (ap,aq) =                 if ((aq >= am))
1506+                    then ap
14981507                     else throw("List size exceeds 10")
14991508 
1500-                do(dn(dn(dn(dn(dn(dn(dn(dn(dn(dn(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1501-                } ++ [IntegerEntry("static_KMult", fk)])
1509+                dt(ds(ds(ds(ds(ds(ds(ds(ds(ds(ds(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1510+                } ++ [IntegerEntry("static_KMult", fr)])
15021511             }
15031512     }
15041513 
15051514 
15061515 
1507-@Callable(cZ)
1508-func doRebalancingWithNewTokens (da,db,dc) = {
1509-    let eo = split(db, ",")
1510-    let fl = split(v("static_tokenIds"), ",")
1511-    let ep = split(da, ",")
1512-    let eR = {
1513-        let ag = ep
1514-        let ah = size(ag)
1515-        let ai = nil
1516-        func aI (ak,al) =         if ((al >= ah))
1517-            then ak
1518-            else D(ak, ag[al])
1516+@Callable(de)
1517+func doRebalancingWithNewTokens (df,dg,dh) = {
1518+    let es = split(dg, ",")
1519+    let fs = split(v("static_tokenIds"), ",")
1520+    let et = split(df, ",")
1521+    let eW = {
1522+        let al = et
1523+        let am = size(al)
1524+        let an = nil
1525+        func aN (ap,aq) =         if ((aq >= am))
1526+            then ap
1527+            else D(ap, al[aq])
15191528 
1520-        func aJ (ak,al) =         if ((al >= ah))
1521-            then ak
1529+        func aO (ap,aq) =         if ((aq >= am))
1530+            then ap
15221531             else throw("List size exceeds 10")
15231532 
1524-        aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1533+        aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
15251534         }
1526-    let bg = {
1527-        let ag = ep
1528-        let ah = size(ag)
1529-        let ai = ""
1530-        func bF (ak,al) =         if ((al >= ah))
1531-            then ak
1532-            else cz(ak, ag[al])
1535+    let bl = {
1536+        let al = et
1537+        let am = size(al)
1538+        let an = ""
1539+        func bK (ap,aq) =         if ((aq >= am))
1540+            then ap
1541+            else cE(ap, al[aq])
15331542 
1534-        func bG (ak,al) =         if ((al >= ah))
1535-            then ak
1543+        func bL (ap,aq) =         if ((aq >= am))
1544+            then ap
15361545             else throw("List size exceeds 10")
15371546 
1538-        bG(bF(bF(bF(bF(bF(bF(bF(bF(bF(bF(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1547+        bL(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
15391548         }
1540-    let eu = split(v("rebalance_addedAssets"), ",")
1541-    func fm (y) =     valueOrElse(getInteger(("rebalance_attachedPayment_" + x(y))), 0)
1549+    let ey = split(v("rebalance_addedAssets"), ",")
1550+    func ft (y) =     valueOrElse(getInteger(("rebalance_attachedPayment_" + x(y))), 0)
15421551 
1543-    func fn (cw,y) =     (cw ++ [fm(y)])
1552+    func fu (cB,y) =     (cB ++ [ft(y)])
15441553 
1545-    let fo = {
1546-        let ag = eR
1547-        let ah = size(ag)
1548-        let ai = nil
1549-        func cS (ak,al) =         if ((al >= ah))
1550-            then ak
1551-            else fn(ak, ag[al])
1554+    let fv = {
1555+        let al = eW
1556+        let am = size(al)
1557+        let an = nil
1558+        func cX (ap,aq) =         if ((aq >= am))
1559+            then ap
1560+            else fu(ap, al[aq])
15521561 
1553-        func cT (ak,al) =         if ((al >= ah))
1554-            then ak
1562+        func cY (ap,aq) =         if ((aq >= am))
1563+            then ap
15551564             else throw("List size exceeds 10")
15561565 
1557-        cT(cS(cS(cS(cS(cS(cS(cS(cS(cS(cS(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1566+        cY(cX(cX(cX(cX(cX(cX(cX(cX(cX(cX(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
15581567         }
1559-    if ((cZ.caller != this))
1560-        then throw(("this call available only for admin, " + toString(cZ.caller)))
1568+    if ((de.caller != this))
1569+        then throw(("this call available only for admin, " + toString(de.caller)))
15611570         else {
1562-            let fe = aE()
1563-            let fj = aK()
1564-            func fp (ff,y) =             {
1565-                func fq (E,cy) =                 if ((cy == y))
1566-                    then value(indexOf(eR, cy))
1571+            let fl = aJ()
1572+            let fq = aP()
1573+            func fw (fm,y) =             {
1574+                func fx (E,cD) =                 if ((cD == y))
1575+                    then value(indexOf(eW, cD))
15671576                     else E
15681577 
1569-                let fr = ff
1578+                let fy = fm
15701579                 let A = x(y)
1571-                let fs = {
1572-                    let ag = eR
1573-                    let ah = size(ag)
1574-                    let ai = 1
1575-                    func dn (ak,al) =                     if ((al >= ah))
1576-                        then ak
1577-                        else fq(ak, ag[al])
1580+                let fz = {
1581+                    let al = eW
1582+                    let am = size(al)
1583+                    let an = 1
1584+                    func ds (ap,aq) =                     if ((aq >= am))
1585+                        then ap
1586+                        else fx(ap, al[aq])
15781587 
1579-                    func do (ak,al) =                     if ((al >= ah))
1580-                        then ak
1588+                    func dt (ap,aq) =                     if ((aq >= am))
1589+                        then ap
15811590                         else throw("List size exceeds 10")
15821591 
1583-                    do(dn(dn(dn(dn(dn(dn(dn(dn(dn(dn(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1592+                    dt(ds(ds(ds(ds(ds(ds(ds(ds(ds(ds(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
15841593                     }
1585-                let fh = parseIntValue(eo[fs])
1586-                let ft = q((("global_" + A) + "_balance"))
1587-                let fu = fo[fs]
1588-                let fg = (ft + fu)
1589-                let dm = if ((y == unit))
1594+                let fo = parseIntValue(es[fz])
1595+                let fA = q((("global_" + A) + "_balance"))
1596+                let fB = fv[fz]
1597+                let fn = (fA + fB)
1598+                let dr = if ((y == unit))
15901599                     then 8
15911600                     else value(assetInfo(value(y))).decimals
1592-                if ((0 >= fg))
1601+                if ((0 >= fn))
15931602                     then throw(("you need to attach all new assets in payment. this asset is missed: " + A))
1594-                    else fraction(fr, pow(fg, dm, fh, d, 8, FLOOR), f)
1603+                    else fraction(fy, pow(fn, dr, fo, d, 8, FLOOR), f)
15951604                 }
15961605 
1597-            let fi = {
1598-                let ag = eR
1599-                let ah = size(ag)
1600-                let ai = j
1601-                func dn (ak,al) =                 if ((al >= ah))
1602-                    then ak
1603-                    else fp(ak, ag[al])
1606+            let fp = {
1607+                let al = eW
1608+                let am = size(al)
1609+                let an = j
1610+                func ds (ap,aq) =                 if ((aq >= am))
1611+                    then ap
1612+                    else fw(ap, al[aq])
16041613 
1605-                func do (ak,al) =                 if ((al >= ah))
1606-                    then ak
1614+                func dt (ap,aq) =                 if ((aq >= am))
1615+                    then ap
16071616                     else throw("List size exceeds 10")
16081617 
1609-                do(dn(dn(dn(dn(dn(dn(dn(dn(dn(dn(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1618+                dt(ds(ds(ds(ds(ds(ds(ds(ds(ds(ds(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
16101619                 }
1611-            let fk = fraction(fe, fi, fj)
1612-            func dk (E,dl) =             {
1613-                let A = ep[dl]
1614-                let y = eR[dl]
1615-                let dm = if ((y == unit))
1620+            let fr = fraction(fl, fp, fq)
1621+            func dp (E,dq) =             {
1622+                let A = et[dq]
1623+                let y = eW[dq]
1624+                let dr = if ((y == unit))
16161625                     then 8
16171626                     else value(assetInfo(value(y))).decimals
1618-                let fv = if ((indexOf(eu, A) != unit))
1619-                    then [IntegerEntry((("global_" + A) + "_balance"), fo[dl]), IntegerEntry((("static_" + A) + "_scale"), pow(10, 0, dm, 0, 0, DOWN)), IntegerEntry((("static_" + A) + "_decimals"), dm)]
1627+                let fC = if ((indexOf(ey, A) != unit))
1628+                    then [IntegerEntry((("global_" + A) + "_balance"), fv[dq]), IntegerEntry((("static_" + A) + "_scale"), pow(10, 0, dr, 0, 0, DOWN)), IntegerEntry((("static_" + A) + "_decimals"), dr)]
16201629                     else nil
1621-                if ((dl >= size(eo)))
1630+                if ((dq >= size(es)))
16221631                     then E
1623-                    else ((E ++ [IntegerEntry((("static_" + A) + "_weight"), value(parseInt(eo[dl])))]) ++ fv)
1632+                    else ((E ++ [IntegerEntry((("static_" + A) + "_weight"), value(parseInt(es[dq])))]) ++ fC)
16241633                 }
16251634 
16261635             ({
1627-                let ag = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
1628-                let ah = size(ag)
1629-                let ai = nil
1630-                func eD (ak,al) =                 if ((al >= ah))
1631-                    then ak
1632-                    else dk(ak, ag[al])
1636+                let al = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
1637+                let am = size(al)
1638+                let an = nil
1639+                func eH (ap,aq) =                 if ((aq >= am))
1640+                    then ap
1641+                    else dp(ap, al[aq])
16331642 
1634-                func eE (ak,al) =                 if ((al >= ah))
1635-                    then ak
1643+                func eI (ap,aq) =                 if ((aq >= am))
1644+                    then ap
16361645                     else throw("List size exceeds 10")
16371646 
1638-                eE(eD(eD(eD(eD(eD(eD(eD(eD(eD(eD(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1639-                } ++ [StringEntry("static_tokenIds", da), StringEntry("static_feeToken", bg), StringEntry("static_tokenWeights", db), IntegerEntry("static_tokensAmount", size(eR)), IntegerEntry("static_KMult", fk)])
1647+                eI(eH(eH(eH(eH(eH(eH(eH(eH(eH(eH(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1648+                } ++ [StringEntry("static_tokenIds", df), StringEntry("static_feeToken", bl), StringEntry("static_tokenWeights", dg), IntegerEntry("static_tokensAmount", size(eW)), IntegerEntry("static_KMult", fr)])
16401649             }
16411650     }
16421651 
16431652 
1644-@Verifier(fw)
1645-func fx () = if (sigVerify(fw.bodyBytes, fw.proofs[0], fw.senderPublicKey))
1653+@Verifier(fD)
1654+func fE () = if (if ((valueOrElse(getInteger("global_wasPreInited"), 0) == 0))
1655+    then if (sigVerify(fD.bodyBytes, fD.proofs[0], fD.senderPublicKey))
1656+        then true
1657+        else sigVerify(fD.bodyBytes, fD.proofs[0], aa)
1658+    else false)
16461659     then true
1647-    else sigVerify(fw.bodyBytes, fw.proofs[0], Y)
1660+    else {
1661+        let s = fD
1662+        if ($isInstanceOf(s, "SetScriptTransaction"))
1663+            then {
1664+                let fD = s
1665+                let fF = value(fD.script)
1666+                let fG = toBase58String(sha256(fF))
1667+                if (sigVerify(fD.bodyBytes, fD.proofs[0], aa))
1668+                    then (valueOrElse(getInteger(ai, ("approvedScript_" + fG)), 0) > height)
1669+                    else false
1670+                }
1671+            else if (sigVerify(fD.bodyBytes, fD.proofs[0], aa))
1672+                then (valueOrElse(getInteger(ai, ("approvedTx_" + toBase58String(fD.id))), 0) > 0)
1673+                else false
1674+        }
16481675 

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
4-let a = "PZ-1.0.11 PROD"
4+let a = "PZ-1.2.3 PROD"
55 
66 let b = valueOrElse(getString(this, "configAddress"), "3PPEBRg4s2af2rQ2ZbLvdu1Hfd4Vo6QVDTo")
77 
88 let c = if ((b == ""))
99     then this
1010     else Address(fromBase58String(b))
1111 
1212 let d = 4
1313 
1414 let e = 10000
1515 
1616 let f = 100000000
1717 
1818 let g = 10000000000000000
1919 
2020 let h = 10000
2121 
2222 let i = 8
2323 
2424 let j = pow(10, 0, i, 0, 0, HALFUP)
2525 
2626 let k = valueOrElse(getInteger(c, "min_steps_amount"), 1)
2727 
2828 let l = valueOrElse(getInteger(c, "max_steps_amount"), 500)
2929 
3030 let m = valueOrElse(getInteger(c, "min_steps_interval"), 1)
3131 
3232 let n = valueOrElse(getInteger(c, "max_steps_interval"), 10000)
3333 
3434 let o = valueOrElse(getInteger(c, "min_weight"), 100)
3535 
3636 let p = valueOrElse(getInteger(c, "max_weight"), 9900)
3737 
3838 func q (r) = {
3939     let s = getInteger(this, r)
4040     if ($isInstanceOf(s, "Int"))
4141         then {
4242             let t = s
4343             t
4444             }
4545         else 0
4646     }
4747 
4848 
4949 func u (r) = {
5050     let s = getBinary(this, r)
5151     if ($isInstanceOf(s, "ByteVector"))
5252         then {
5353             let t = s
5454             t
5555             }
5656         else base58''
5757     }
5858 
5959 
6060 func v (r) = {
6161     let s = getString(this, r)
6262     if ($isInstanceOf(s, "String"))
6363         then {
6464             let t = s
6565             t
6666             }
6767         else ""
6868     }
6969 
7070 
7171 func w (r) = {
7272     let s = getString(this, r)
7373     if ($isInstanceOf(s, "String"))
7474         then {
7575             let t = s
7676             t
7777             }
7878         else throw(("no such key in data storage: " + r))
7979     }
8080 
8181 
8282 func x (y) = {
8383     let s = y
8484     if ($isInstanceOf(s, "ByteVector"))
8585         then {
8686             let t = s
8787             toBase58String(t)
8888             }
8989         else "WAVES"
9090     }
9191 
9292 
9393 func z (A) = if ((A == "WAVES"))
9494     then unit
9595     else fromBase58String(A)
9696 
9797 
9898 func B (y) = {
9999     let s = y
100100     if ($isInstanceOf(s, "ByteVector"))
101101         then {
102102             let C = s
103103             assetBalance(this, C)
104104             }
105105         else wavesBalance(this).available
106106     }
107107 
108108 
109109 func D (E,F) = (E ++ [z(F)])
110110 
111111 
112112 func G (E,F) = (E ++ [q((("static_" + x(F)) + "_weight"))])
113113 
114114 
115115 func H (E,F) = (E ++ [toString(q((("static_" + F) + "_weight")))])
116116 
117117 
118118 func I (E,F) = (E ++ [q((("static_" + x(F)) + "_decimals"))])
119119 
120120 
121121 func J (E,F) = (E ++ [q((("static_" + x(F)) + "_scale"))])
122122 
123123 
124124 func K (E,F) = (E ++ [parseIntValue(F)])
125125 
126126 
127127 let L = valueOrElse(getString(c, "usdnAssetIdStr"), "DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p")
128128 
129129 let M = valueOrElse(getString(c, "puzzleAssetIdStr"), "HEB8Qaw9xrWpWs8tHsiATYGBWDBtP2S7kcPALrMu43AS")
130130 
131131 let N = valueOrElse(getString(c, "usdtAssetIdStr"), "34N9YcEETLWn93qYQ64EsP1x89tSruJU44RrEMSXXEPJ")
132132 
133133 let O = valueOrElse(getString(c, "usdtPptAssetIdStr"), "9wc3LXNA4TEBsXyKtoLE9mrbDD7WMHXvXrCjZvabLAsi")
134134 
135-let P = "WAVES"
135+let P = valueOrElse(getString(c, "romeAssetIdStr"), "AP4Cb5xLYGH6ZigHreCZHoXpQTWDkPsG2BHqfDUx6taJ")
136136 
137-let Q = fromBase58String(L)
137+let Q = "WAVES"
138138 
139-let R = fromBase58String(M)
139+let R = fromBase58String(L)
140140 
141-let S = fromBase58String(N)
141+let S = fromBase58String(M)
142142 
143-let T = fromBase58String(O)
143+let T = fromBase58String(N)
144144 
145-let U = unit
145+let U = fromBase58String(O)
146146 
147-let V = [L, M, N, O, P]
147+let V = fromBase58String(P)
148148 
149-let W = Address(fromBase58String(valueOrElse(getString(c, "parentPoolAddress"), "3PFDgzu1UtswAkCMxqqQjbTeHaX4cMab8Kh")))
149+let W = unit
150150 
151-let X = Address(fromBase58String(valueOrElse(getString(c, "masterAddress"), "3PLjwHcz9NEuaTo63NZR9B9okQiKQxZSbmf")))
151+let X = [L, M, N, O, Q, P]
152152 
153-let Y = fromBase58String(valueOrElse(getString(c, "masterPubKey"), "4z8CKSYQBKkzx7PBb5uBP1YPa6YAHRNTApW1sQVHT5eU"))
153+let Y = Address(fromBase58String(valueOrElse(getString(c, "parentPoolAddress"), "3PFDgzu1UtswAkCMxqqQjbTeHaX4cMab8Kh")))
154154 
155-let Z = Address(fromBase58String(valueOrElse(getString(c, "oracleAddress"), "3P8d1E1BLKoD52y3bQJ1bDTd2TD1gpaLn9t")))
155+let Z = Address(fromBase58String(valueOrElse(getString(c, "masterAddress"), "3PLjwHcz9NEuaTo63NZR9B9okQiKQxZSbmf")))
156156 
157-let aa = Address(fromBase58String(valueOrElse(getString(c, "stakingAddress"), "3PFTbywqxtFfukX3HyT881g4iW5K4QL3FAS")))
157+let aa = fromBase58String(valueOrElse(getString(c, "masterPubKey"), "4z8CKSYQBKkzx7PBb5uBP1YPa6YAHRNTApW1sQVHT5eU"))
158158 
159-let ab = Address(fromBase58String(valueOrElse(getString(c, "feesAddress"), "3P4kBiU4wr2yV1S5gMfu3MdkVvy7kxXHsKe")))
159+let ab = Address(fromBase58String(valueOrElse(getString(c, "oracleAddress"), "3P8d1E1BLKoD52y3bQJ1bDTd2TD1gpaLn9t")))
160160 
161-let ac = Address(fromBase58String(valueOrElse(getString(c, "poolsHubAddress"), "3P5YutjDNC3hABBVsveFuZTTbQ5PdtSDBgk")))
161+let ac = Address(fromBase58String(valueOrElse(getString(c, "stakingAddress"), "3PFTbywqxtFfukX3HyT881g4iW5K4QL3FAS")))
162162 
163-let ad = valueOrElse(getString(c, "shutdownAddress"), "3PEpv9hRFWEEBU22WRnLsw1bH4YGtcU728o")
163+let ad = Address(fromBase58String(valueOrElse(getString(c, "feesAddress"), "3PFWAVKmXjfHXyzJb12jCbhP4Uhi9t4uWiD")))
164164 
165-let ae = q("static_tokensAmount")
165+let ae = Address(fromBase58String(valueOrElse(getString(c, "poolsHubAddress"), "3P5YutjDNC3hABBVsveFuZTTbQ5PdtSDBgk")))
166166 
167-let af = {
168-    let ag = split(v("static_tokenIds"), ",")
169-    let ah = size(ag)
170-    let ai = nil
171-    func aj (ak,al) =     if ((al >= ah))
172-        then ak
173-        else D(ak, ag[al])
167+let af = valueOrElse(getString(c, "shutdownAddress"), "3PEpv9hRFWEEBU22WRnLsw1bH4YGtcU728o")
174168 
175-    func am (ak,al) =     if ((al >= ah))
176-        then ak
169+let ag = valueOrElse(getString(c, "layer2Addresses"), "3PR1Qvi9mHT35SwWEkLSqqE2L8thiPLdVWU,3PQoBfUKHkJAeGWhooLP7WS8ovb54av9Jp2")
170+
171+let ah = Address(fromBase58String(valueOrElse(getString(c, "govAddress"), "3P6uro9xCsE8te78QZjzqy7aq8natSzdceC")))
172+
173+let ai = Address(fromBase58String(valueOrElse(getString(c, "coldMasterAddress"), "3PK9nhPfPbMBygB9ZgHVMHaQbSoojwrBfxj")))
174+
175+let aj = q("static_tokensAmount")
176+
177+let ak = {
178+    let al = split(v("static_tokenIds"), ",")
179+    let am = size(al)
180+    let an = nil
181+    func ao (ap,aq) =     if ((aq >= am))
182+        then ap
183+        else D(ap, al[aq])
184+
185+    func ar (ap,aq) =     if ((aq >= am))
186+        then ap
177187         else throw("List size exceeds 10")
178188 
179-    am(aj(aj(aj(aj(aj(aj(aj(aj(aj(aj(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
189+    ar(ao(ao(ao(ao(ao(ao(ao(ao(ao(ao(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
180190     }
181191 
182-let an = {
183-    let ag = af
184-    let ah = size(ag)
185-    let ai = nil
186-    func ao (ak,al) =     if ((al >= ah))
187-        then ak
188-        else G(ak, ag[al])
192+let as = {
193+    let al = ak
194+    let am = size(al)
195+    let an = nil
196+    func at (ap,aq) =     if ((aq >= am))
197+        then ap
198+        else G(ap, al[aq])
189199 
190-    func ap (ak,al) =     if ((al >= ah))
191-        then ak
200+    func au (ap,aq) =     if ((aq >= am))
201+        then ap
192202         else throw("List size exceeds 10")
193203 
194-    ap(ao(ao(ao(ao(ao(ao(ao(ao(ao(ao(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
204+    au(at(at(at(at(at(at(at(at(at(at(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
195205     }
196206 
197-let aq = {
198-    let ag = af
199-    let ah = size(ag)
200-    let ai = nil
201-    func ar (ak,al) =     if ((al >= ah))
202-        then ak
203-        else I(ak, ag[al])
207+let av = {
208+    let al = ak
209+    let am = size(al)
210+    let an = nil
211+    func aw (ap,aq) =     if ((aq >= am))
212+        then ap
213+        else I(ap, al[aq])
204214 
205-    func as (ak,al) =     if ((al >= ah))
206-        then ak
215+    func ax (ap,aq) =     if ((aq >= am))
216+        then ap
207217         else throw("List size exceeds 10")
208218 
209-    as(ar(ar(ar(ar(ar(ar(ar(ar(ar(ar(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
219+    ax(aw(aw(aw(aw(aw(aw(aw(aw(aw(aw(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
210220     }
211221 
212-let at = {
213-    let ag = af
214-    let ah = size(ag)
215-    let ai = nil
216-    func au (ak,al) =     if ((al >= ah))
217-        then ak
218-        else J(ak, ag[al])
222+let ay = {
223+    let al = ak
224+    let am = size(al)
225+    let an = nil
226+    func az (ap,aq) =     if ((aq >= am))
227+        then ap
228+        else J(ap, al[aq])
219229 
220-    func av (ak,al) =     if ((al >= ah))
221-        then ak
230+    func aA (ap,aq) =     if ((aq >= am))
231+        then ap
222232         else throw("List size exceeds 10")
223233 
224-    av(au(au(au(au(au(au(au(au(au(au(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
234+    aA(az(az(az(az(az(az(az(az(az(az(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
225235     }
226236 
227-let aw = q("static_fee")
237+let aB = q("static_fee")
228238 
229-let ax = af
239+let aC = ak
230240 
231-func ay () = if ((ad == ""))
232-    then false
233-    else {
234-        let az = addressFromString(ad)
235-        if ((az == unit))
236-            then false
237-            else {
238-                let s = getBoolean(value(az), "is_shutdown")
239-                if ($isInstanceOf(s, "Boolean"))
240-                    then {
241-                        let aA = s
242-                        aA
243-                        }
244-                    else false
245-                }
246-        }
247-
248-
249-func aB (aC) = {
250-    let aD = x(af[aC])
251-    q((("global_" + aD) + "_balance"))
241+func aD () = {
242+    let aE = addressFromString(af)
243+    if ((aE == unit))
244+        then false
245+        else {
246+            let s = getBoolean(value(aE), "is_shutdown")
247+            if ($isInstanceOf(s, "Boolean"))
248+                then {
249+                    let aF = s
250+                    aF
251+                    }
252+                else false
253+            }
252254     }
253255 
254256 
255-func aE () = {
257+func aG (aH) = {
258+    let aI = x(ak[aH])
259+    q((("global_" + aI) + "_balance"))
260+    }
261+
262+
263+func aJ () = {
256264     let s = getInteger("static_KMult")
257265     if ($isInstanceOf(s, "Int"))
258266         then {
259-            let aA = s
260-            aA
267+            let aF = s
268+            aF
261269             }
262270         else g
263271     }
264272 
265273 
266-func aF () = {
267-    let aG = split(v("static_tokenIds"), ",")
268-    func aH (E,y) =     (E ++ [IntegerEntry(("rebalance_startWeight_" + y), q((("static_" + y) + "_weight")))])
274+func aK () = {
275+    let aL = split(v("static_tokenIds"), ",")
276+    func aM (E,y) =     (E ++ [IntegerEntry(("rebalance_startWeight_" + y), q((("static_" + y) + "_weight")))])
269277 
270-    let ag = aG
271-    let ah = size(ag)
272-    let ai = nil
273-    func aI (ak,al) =     if ((al >= ah))
274-        then ak
275-        else aH(ak, ag[al])
278+    let al = aL
279+    let am = size(al)
280+    let an = nil
281+    func aN (ap,aq) =     if ((aq >= am))
282+        then ap
283+        else aM(ap, al[aq])
276284 
277-    func aJ (ak,al) =     if ((al >= ah))
278-        then ak
285+    func aO (ap,aq) =     if ((aq >= am))
286+        then ap
279287         else throw("List size exceeds 10")
280288 
281-    aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
289+    aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
282290     }
283291 
284292 
285-func aK () = fraction(q("global_poolToken_amount"), aE(), g)
293+func aP () = fraction(q("global_poolToken_amount"), aJ(), g)
286294 
287295 
288-func aL (aM,aN) = {
289-    let aO = aK()
290-    let aP = q((("global_" + x(aN)) + "_balance"))
291-    let aQ = fraction(aM, aO, aP, DOWN)
292-    aQ
296+func aQ (aR,aS) = {
297+    let aT = aP()
298+    let aU = q((("global_" + x(aS)) + "_balance"))
299+    let aV = fraction(aR, aT, aU, DOWN)
300+    aV
293301     }
294302 
295303 
296-func aR (aS) = {
297-    func aT (E,aU) =     {
298-        let aV = aL(aU.amount, aU.assetId)
299-        if ((aV == 0))
304+func aW (aX) = {
305+    func aY (E,aZ) =     {
306+        let ba = aQ(aZ.amount, aZ.assetId)
307+        if ((ba == 0))
300308             then throw("one of the tokens amounts is too low")
301309             else if (if ((E == 0))
302310                 then true
303-                else (E > aV))
304-                then aV
311+                else (E > ba))
312+                then ba
305313                 else E
306314         }
307315 
308-    let aW = {
309-        let ag = aS
310-        let ah = size(ag)
311-        let ai = 0
312-        func aI (ak,al) =         if ((al >= ah))
313-            then ak
314-            else aT(ak, ag[al])
316+    let bb = {
317+        let al = aX
318+        let am = size(al)
319+        let an = 0
320+        func aN (ap,aq) =         if ((aq >= am))
321+            then ap
322+            else aY(ap, al[aq])
315323 
316-        func aJ (ak,al) =         if ((al >= ah))
317-            then ak
324+        func aO (ap,aq) =         if ((aq >= am))
325+            then ap
318326             else throw("List size exceeds 10")
319327 
320-        aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
328+        aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
321329         }
322-    aW
330+    bb
323331     }
324332 
325333 
326-func aX (y,aM,aY,aZ) = {
327-    let ba = indexOf(af, Q)
328-    let bb = indexOf(af, R)
329-    let bc = indexOf(af, S)
330-    let bd = indexOf(af, T)
331-    let be = indexOf(af, unit)
332-    let bf = q((("static_" + x(y)) + "_weight"))
333-    let bg = v("static_feeToken")
334-    if ((bg == M))
334+func bc (y,aR,bd,be) = {
335+    let bf = indexOf(ak, R)
336+    let bg = indexOf(ak, S)
337+    let bh = indexOf(ak, T)
338+    let bi = indexOf(ak, U)
339+    let bj = indexOf(ak, unit)
340+    let bk = q((("static_" + x(y)) + "_weight"))
341+    let bl = v("static_feeToken")
342+    if ((bl == M))
335343         then {
336-            let bh = an[value(indexOf(af, R))]
337-            let bi = q((("global_" + M) + "_balance"))
338-            let bj = fraction(aM, (bi / bh), (aY / bf))
339-            let bk = getIntegerValue(W, "global_lastPuzzlePrice")
340-            fraction((bj * bk), 1, f)
344+            let bm = as[value(indexOf(ak, S))]
345+            let bn = q((("global_" + M) + "_balance"))
346+            let bo = fraction(aR, (bn / bm), (bd / bk))
347+            let bp = getIntegerValue(Y, "global_lastPuzzlePrice")
348+            fraction((bo * bp), 1, f)
341349             }
342-        else if ((bg == N))
350+        else if ((bl == N))
343351             then {
344-                let bl = an[value(bc)]
345-                let bm = q((("global_" + N) + "_balance"))
346-                fraction(aM, (bm / bl), (aY / bf))
352+                let bq = as[value(bh)]
353+                let br = q((("global_" + N) + "_balance"))
354+                fraction(aR, (br / bq), (bd / bk))
347355                 }
348-            else if ((bg == O))
356+            else if ((bl == O))
349357                 then {
350-                    let bl = an[value(bd)]
351-                    let bm = q((("global_" + O) + "_balance"))
352-                    fraction(aM, (bm / bl), (aY / bf))
358+                    let bq = as[value(bi)]
359+                    let br = q((("global_" + O) + "_balance"))
360+                    fraction(aR, (br / bq), (bd / bk))
353361                     }
354-                else if ((bg == L))
362+                else if ((bl == L))
355363                     then {
356-                        let bn = an[value(indexOf(af, Q))]
357-                        let bo = {
358-                            let s = aZ
364+                        let bs = as[value(indexOf(ak, R))]
365+                        let bt = {
366+                            let s = be
359367                             if ($isInstanceOf(s, "Int"))
360368                                 then {
361-                                    let aA = s
362-                                    aZ
369+                                    let aF = s
370+                                    be
363371                                     }
364-                                else q((("global_" + x(Q)) + "_balance"))
372+                                else q((("global_" + x(R)) + "_balance"))
365373                             }
366-                        fraction(aM, (value(bo) / bn), (aY / bf))
374+                        fraction(aR, (value(bt) / bs), (bd / bk))
367375                         }
368376                     else {
369-                        let bp = 3000
370-                        let bq = (q("global_WAVES_balance") / 50)
371-                        fraction(aM, (bq / bp), (aY / bf))
377+                        let bu = 3000
378+                        let bv = (q("global_WAVES_balance") / 50)
379+                        fraction(aR, (bv / bu), (bd / bk))
372380                         }
373381     }
374382 
375383 
376-func br (A) = {
377-    let s = getInteger(Z, (A + "_twap5B"))
384+func bw (A) = {
385+    let s = getInteger(ab, (A + "_twap5B"))
378386     if ($isInstanceOf(s, "Int"))
379387         then {
380-            let aA = s
381-            aA
388+            let aF = s
389+            aF
382390             }
383391         else 0
384392     }
385393 
386394 
387-func bs (y,aM,aY) = {
388-    let bf = q((("static_" + x(y)) + "_weight"))
389-    let bg = v("static_feeToken")
390-    let bt = getIntegerValue(this, (("static_" + bg) + "_scale"))
391-    let bu = value(indexOf(af, z(bg)))
392-    let bv = an[bu]
393-    let bw = q((("global_" + bg) + "_balance"))
394-    let bx = fraction(aM, (bw / bv), (aY / bf))
395-    let by = br(bg)
396-    fraction(bx, by, bt)
395+func bx (y,aR,bd) = {
396+    let bk = q((("static_" + x(y)) + "_weight"))
397+    let bl = v("static_feeToken")
398+    let by = getIntegerValue(this, (("static_" + bl) + "_scale"))
399+    let bz = value(indexOf(ak, z(bl)))
400+    let bA = as[bz]
401+    let bB = q((("global_" + bl) + "_balance"))
402+    let bC = fraction(aR, (bB / bA), (bd / bk))
403+    let bD = bw(bl)
404+    fraction(bC, bD, by)
397405     }
398406 
399407 
400-func bz (aS) = {
401-    func bA (E,bB) =     (E ++ [bB.assetId])
408+func bE (aX) = {
409+    func bF (E,bG) =     (E ++ [bG.assetId])
402410 
403-    let bC = {
404-        let ag = aS
405-        let ah = size(ag)
406-        let ai = nil
407-        func aI (ak,al) =         if ((al >= ah))
408-            then ak
409-            else bA(ak, ag[al])
411+    let bH = {
412+        let al = aX
413+        let am = size(al)
414+        let an = nil
415+        func aN (ap,aq) =         if ((aq >= am))
416+            then ap
417+            else bF(ap, al[aq])
410418 
411-        func aJ (ak,al) =         if ((al >= ah))
412-            then ak
419+        func aO (ap,aq) =         if ((aq >= am))
420+            then ap
413421             else throw("List size exceeds 10")
414422 
415-        aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
423+        aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
416424         }
417-    if ((bC == bC))
425+    if ((bH == bH))
418426         then {
419-            func bD (E,y) =             if ((indexOf(bC, y) != unit))
427+            func bI (E,y) =             if ((indexOf(bH, y) != unit))
420428                 then (E + 1)
421429                 else throw(("asset not attached: " + x(y)))
422430 
423-            let bE = {
424-                let ag = af
425-                let ah = size(ag)
426-                let ai = 0
427-                func bF (ak,al) =                 if ((al >= ah))
428-                    then ak
429-                    else bD(ak, ag[al])
431+            let bJ = {
432+                let al = ak
433+                let am = size(al)
434+                let an = 0
435+                func bK (ap,aq) =                 if ((aq >= am))
436+                    then ap
437+                    else bI(ap, al[aq])
430438 
431-                func bG (ak,al) =                 if ((al >= ah))
432-                    then ak
439+                func bL (ap,aq) =                 if ((aq >= am))
440+                    then ap
433441                     else throw("List size exceeds 10")
434442 
435-                bG(bF(bF(bF(bF(bF(bF(bF(bF(bF(bF(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
443+                bL(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
436444                 }
437-            if ((bE == bE))
445+            if ((bJ == bJ))
438446                 then true
439447                 else throw("Strict value is not equal to itself.")
440448             }
441449         else throw("Strict value is not equal to itself.")
442450     }
443451 
444452 
445-func bH (aV,aS,bI,bJ) = {
446-    func bK (aN) =     {
447-        func aT (E,bB) =         if ((bB.assetId == aN))
448-            then bB.amount
453+func bM (ba,aX,bN,bO) = {
454+    func bP (aS) =     {
455+        func aY (E,bG) =         if ((bG.assetId == aS))
456+            then bG.amount
449457             else E
450458 
451-        let ag = aS
452-        let ah = size(ag)
453-        let ai = 0
454-        func aI (ak,al) =         if ((al >= ah))
455-            then ak
456-            else aT(ak, ag[al])
459+        let al = aX
460+        let am = size(al)
461+        let an = 0
462+        func aN (ap,aq) =         if ((aq >= am))
463+            then ap
464+            else aY(ap, al[aq])
457465 
458-        func aJ (ak,al) =         if ((al >= ah))
459-            then ak
466+        func aO (ap,aq) =         if ((aq >= am))
467+            then ap
460468             else throw("List size exceeds 10")
461469 
462-        aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
470+        aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
463471         }
464472 
465-    func bL (E,aN) =     {
466-        let bM = q((("global_" + x(aN)) + "_balance"))
467-        let bN = aK()
468-        let bO = q((("static_" + x(aN)) + "_scale"))
469-        let bP = fraction((toBigInt((bN + aV)) * toBigInt(f)), toBigInt(bO), toBigInt(bN), CEILING)
470-        let bQ = toInt(fraction((bP - (toBigInt(bO) * toBigInt(f))), toBigInt(bM), (toBigInt(bO) * toBigInt(f)), CEILING))
471-        let bR = bK(aN)
472-        let bS = (bR - bQ)
473-        let C = if (if (bJ)
474-            then (bS > 0)
473+    func bQ (E,aS) =     {
474+        let bR = q((("global_" + x(aS)) + "_balance"))
475+        let bS = aP()
476+        let bT = q((("static_" + x(aS)) + "_scale"))
477+        let bU = fraction((toBigInt((bS + ba)) * toBigInt(f)), toBigInt(bT), toBigInt(bS), CEILING)
478+        let bV = toInt(fraction((bU - (toBigInt(bT) * toBigInt(f))), toBigInt(bR), (toBigInt(bT) * toBigInt(f)), CEILING))
479+        let bW = bP(aS)
480+        let bX = (bW - bV)
481+        let C = if (if (bO)
482+            then (bX > 0)
475483             else false)
476-            then [ScriptTransfer(bI, bS, aN)]
484+            then [ScriptTransfer(bN, bX, aS)]
477485             else nil
478-        ((E ++ C) ++ [IntegerEntry((("global_" + x(aN)) + "_balance"), (bM + bQ))])
486+        ((E ++ C) ++ [IntegerEntry((("global_" + x(aS)) + "_balance"), (bR + bV))])
479487         }
480488 
481-    let ag = af
482-    let ah = size(ag)
483-    let ai = nil
484-    func aI (ak,al) =     if ((al >= ah))
485-        then ak
486-        else bL(ak, ag[al])
489+    let al = ak
490+    let am = size(al)
491+    let an = nil
492+    func aN (ap,aq) =     if ((aq >= am))
493+        then ap
494+        else bQ(ap, al[aq])
487495 
488-    func aJ (ak,al) =     if ((al >= ah))
489-        then ak
496+    func aO (ap,aq) =     if ((aq >= am))
497+        then ap
490498         else throw("List size exceeds 10")
491499 
492-    aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
500+    aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
493501     }
494502 
495503 
496-func bT (bU,bI) = {
497-    func bV (E,aN) =     {
498-        let bM = q((("global_" + x(aN)) + "_balance"))
499-        let bN = aK()
500-        let bO = q((("static_" + x(aN)) + "_scale"))
501-        let bW = fraction((toBigInt((bN - bU)) * toBigInt(f)), toBigInt(f), toBigInt(bN), DOWN)
502-        let aM = toInt(fraction((toBigInt(g) - bW), toBigInt(bM), toBigInt(g), CEILING))
503-        (E ++ [IntegerEntry((("global_" + x(aN)) + "_balance"), (bM - aM)), ScriptTransfer(bI, aM, aN)])
504+func bY (bZ,bN) = {
505+    func ca (E,aS) =     {
506+        let bR = q((("global_" + x(aS)) + "_balance"))
507+        let bS = aP()
508+        let bT = q((("static_" + x(aS)) + "_scale"))
509+        let cb = fraction((toBigInt((bS - bZ)) * toBigInt(f)), toBigInt(f), toBigInt(bS), DOWN)
510+        let aR = toInt(fraction((toBigInt(g) - cb), toBigInt(bR), toBigInt(g), CEILING))
511+        (E ++ [IntegerEntry((("global_" + x(aS)) + "_balance"), (bR - aR)), ScriptTransfer(bN, aR, aS)])
504512         }
505513 
506-    let ag = af
507-    let ah = size(ag)
508-    let ai = nil
509-    func aI (ak,al) =     if ((al >= ah))
510-        then ak
511-        else bV(ak, ag[al])
514+    let al = ak
515+    let am = size(al)
516+    let an = nil
517+    func aN (ap,aq) =     if ((aq >= am))
518+        then ap
519+        else ca(ap, al[aq])
512520 
513-    func aJ (ak,al) =     if ((al >= ah))
514-        then ak
521+    func aO (ap,aq) =     if ((aq >= am))
522+        then ap
515523         else throw("List size exceeds 10")
516524 
517-    aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
525+    aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
518526     }
519527 
520528 
521-func bX (bY,bZ,ca,cb,cc) = {
522-    let cd = value(indexOf(af, bZ))
523-    let ce = value(indexOf(af, ca))
524-    if ((cd == ce))
525-        then bY
526-        else fraction(cc, ((f * f) - toInt(pow(fraction(toBigInt((cb * 10000)), toBigInt((f * f)), toBigInt(((cb + bY) * 10000)), HALFUP), 16, toBigInt(fraction(an[cd], 1000000000000, an[ce])), 12, 16, CEILING))), (f * f), HALFEVEN)
529+func cc (cd,ce,cf,cg,ch) = {
530+    let ci = value(indexOf(ak, ce))
531+    let cj = value(indexOf(ak, cf))
532+    if ((ci == cj))
533+        then cd
534+        else fraction(ch, ((f * f) - toInt(pow(fraction((toBigInt(cg) * toBigInt(10000)), toBigInt((f * f)), (toBigInt((cg + cd)) * toBigInt(10000)), HALFUP), 16, toBigInt(fraction(as[ci], 1000000000000, as[cj])), 12, 16, CEILING))), (f * f), HALFEVEN)
527535     }
528536 
529537 
530-func cf (y,A,aY,cg) = {
531-    let ch = q("global_indexStaked")
532-    let ci = cg
533-    let cj = (B(y) - aY)
534-    let ck = if ((cj > ci))
535-        then cj
536-        else ci
537-    let cl = (ck - ci)
538-    let cm = if ((ch == 0))
538+func ck (y,A,bd,cl) = {
539+    let cm = q("global_indexStaked")
540+    let cn = cl
541+    let co = (B(y) - bd)
542+    let cp = if ((co > cn))
543+        then co
544+        else cn
545+    let cq = (cp - cn)
546+    let cr = if ((cm == 0))
539547         then 0
540-        else fraction(cl, f, ch)
541-    let cn = q((("global_lastCheck_" + A) + "_interest"))
542-    (cn + cm)
548+        else fraction(cq, f, cm)
549+    let cs = q((("global_lastCheck_" + A) + "_interest"))
550+    (cs + cr)
543551     }
544552 
545553 
546-func co (cp) = {
547-    let cq = toString(cp)
548-    let cr = q((cq + "_indexStaked"))
549-    func aT (E,y) =     {
554+func ct (cu) = {
555+    let cv = toString(cu)
556+    let cw = q((cv + "_indexStaked"))
557+    func aY (E,y) =     {
550558         let A = x(y)
551-        let aY = q((("global_" + x(y)) + "_balance"))
552-        let cg = q((("global_lastCheck_" + A) + "_earnings"))
553-        let cs = cf(y, A, aY, cg)
554-        let ck = max([cg, (B(y) - aY)])
555-        let ct = fraction(cr, (cs - q((((cq + "_lastCheck_") + A) + "_interest"))), f)
556-        let cu = if ((ct == 0))
559+        let bd = q((("global_" + x(y)) + "_balance"))
560+        let cl = q((("global_lastCheck_" + A) + "_earnings"))
561+        let cx = ck(y, A, bd, cl)
562+        let cp = max([cl, (B(y) - bd)])
563+        let cy = fraction(cw, (cx - q((((cv + "_lastCheck_") + A) + "_interest"))), f)
564+        let cz = if ((cy == 0))
557565             then nil
558-            else [ScriptTransfer(cp, ct, y)]
559-        $Tuple2(((E._1 ++ cu) ++ [IntegerEntry((("global_lastCheck_" + A) + "_earnings"), (ck - ct)), IntegerEntry((("global_lastCheck_" + A) + "_interest"), cs), IntegerEntry((((cq + "_lastCheck_") + A) + "_interest"), cs)]), (E._2 + bs(y, ct, aY)))
566+            else [ScriptTransfer(cu, cy, y)]
567+        $Tuple2(((E._1 ++ cz) ++ [IntegerEntry((("global_lastCheck_" + A) + "_earnings"), (cp - cy)), IntegerEntry((("global_lastCheck_" + A) + "_interest"), cx), IntegerEntry((((cv + "_lastCheck_") + A) + "_interest"), cx)]), (E._2 + bx(y, cy, bd)))
560568         }
561569 
562570     let E = {
563-        let ag = ax
564-        let ah = size(ag)
565-        let ai = $Tuple2(nil, 0)
566-        func aI (ak,al) =         if ((al >= ah))
567-            then ak
568-            else aT(ak, ag[al])
571+        let al = aC
572+        let am = size(al)
573+        let an = $Tuple2(nil, 0)
574+        func aN (ap,aq) =         if ((aq >= am))
575+            then ap
576+            else aY(ap, al[aq])
569577 
570-        func aJ (ak,al) =         if ((al >= ah))
571-            then ak
578+        func aO (ap,aq) =         if ((aq >= am))
579+            then ap
572580             else throw("List size exceeds 10")
573581 
574-        aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
582+        aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
575583         }
576-    $Tuple2((E._1 ++ [IntegerEntry((cq + "_claimedRewardValue"), (q((cq + "_claimedRewardValue")) + E._2)), IntegerEntry((cq + "_lastClaim"), lastBlock.timestamp)]), E._2)
584+    $Tuple2((E._1 ++ [IntegerEntry((cv + "_claimedRewardUSD"), (q((cv + "_claimedRewardUSD")) + E._2)), IntegerEntry((cv + "_lastClaim"), lastBlock.timestamp)]), E._2)
577585     }
578586 
579587 
580-func cv (cq,aM) = {
581-    let cw = co(addressFromStringValue(cq))._1
582-    (cw ++ [IntegerEntry((cq + "_indexStaked"), (q((cq + "_indexStaked")) + aM)), IntegerEntry("global_indexStaked", (q("global_indexStaked") + aM))])
588+func cA (cv,aR) = {
589+    let cB = ct(addressFromStringValue(cv))._1
590+    (cB ++ [IntegerEntry((cv + "_indexStaked"), (q((cv + "_indexStaked")) + aR)), IntegerEntry("global_indexStaked", (q("global_indexStaked") + aR))])
583591     }
584592 
585593 
586-func cx (E,cy) = (E + parseIntValue(cy))
594+func cC (E,cD) = (E + parseIntValue(cD))
587595 
588596 
589-func cz (E,cA) = if (if ((indexOf(V, cA) != unit))
597+func cE (E,cF) = if (if ((indexOf(X, cF) != unit))
590598     then (E == "")
591599     else false)
592-    then cA
600+    then cF
593601     else E
594602 
595603 
596-func cB (cC) = {
597-    let cD = split(v("static_tokenIds"), ",")
598-    let cE = cC
599-    func cF (E,y) =     if ((indexOf(cE, y) == unit))
604+func cG (cH) = {
605+    let cI = split(v("static_tokenIds"), ",")
606+    let cJ = cH
607+    func cK (E,y) =     if ((indexOf(cJ, y) == unit))
600608         then (E ++ [y])
601609         else E
602610 
603-    let ag = cD
604-    let ah = size(ag)
605-    let ai = cE
606-    func aI (ak,al) =     if ((al >= ah))
607-        then ak
608-        else cF(ak, ag[al])
611+    let al = cI
612+    let am = size(al)
613+    let an = cJ
614+    func aN (ap,aq) =     if ((aq >= am))
615+        then ap
616+        else cK(ap, al[aq])
609617 
610-    func aJ (ak,al) =     if ((al >= ah))
611-        then ak
618+    func aO (ap,aq) =     if ((aq >= am))
619+        then ap
612620         else throw("List size exceeds 10")
613621 
614-    aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
622+    aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
615623     }
616624 
617625 
618-func cG (cC) = {
619-    let cD = split(v("static_tokenIds"), ",")
620-    func cH (E,y) =     if ((indexOf(cC, y) == unit))
626+func cL (cH) = {
627+    let cI = split(v("static_tokenIds"), ",")
628+    func cM (E,y) =     if ((indexOf(cH, y) == unit))
621629         then (E + 1)
622630         else E
623631 
624-    func cI (E,y) =     if ((indexOf(cD, y) == unit))
632+    func cN (E,y) =     if ((indexOf(cI, y) == unit))
625633         then (E + 1)
626634         else E
627635 
628-    let cJ = {
629-        let ag = cD
630-        let ah = size(ag)
631-        let ai = 0
632-        func aI (ak,al) =         if ((al >= ah))
633-            then ak
634-            else cH(ak, ag[al])
636+    let cO = {
637+        let al = cI
638+        let am = size(al)
639+        let an = 0
640+        func aN (ap,aq) =         if ((aq >= am))
641+            then ap
642+            else cM(ap, al[aq])
635643 
636-        func aJ (ak,al) =         if ((al >= ah))
637-            then ak
644+        func aO (ap,aq) =         if ((aq >= am))
645+            then ap
638646             else throw("List size exceeds 10")
639647 
640-        aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
648+        aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
641649         }
642-    let cK = {
643-        let ag = cC
644-        let ah = size(ag)
645-        let ai = 0
646-        func bF (ak,al) =         if ((al >= ah))
647-            then ak
648-            else cI(ak, ag[al])
650+    let cP = {
651+        let al = cH
652+        let am = size(al)
653+        let an = 0
654+        func bK (ap,aq) =         if ((aq >= am))
655+            then ap
656+            else cN(ap, al[aq])
649657 
650-        func bG (ak,al) =         if ((al >= ah))
651-            then ak
658+        func bL (ap,aq) =         if ((aq >= am))
659+            then ap
652660             else throw("List size exceeds 10")
653661 
654-        bG(bF(bF(bF(bF(bF(bF(bF(bF(bF(bF(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
662+        bL(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
655663         }
656-    (cJ + cK)
664+    (cO + cP)
657665     }
658666 
659667 
660-func cL (cM,aS) = {
661-    func cN (E,cA) =     if ((0 >= cA.amount))
662-        then throw(((("Too low payment amount for " + x(cA.assetId)) + ": ") + toString(cA.amount)))
663-        else (E ++ [x(cA.assetId)])
668+func cQ (cR,aX) = {
669+    func cS (E,cF) =     if ((0 >= cF.amount))
670+        then throw(((("Too low payment amount for " + x(cF.assetId)) + ": ") + toString(cF.amount)))
671+        else (E ++ [x(cF.assetId)])
664672 
665-    let cO = {
666-        let ag = aS
667-        let ah = size(ag)
668-        let ai = nil
669-        func aI (ak,al) =         if ((al >= ah))
670-            then ak
671-            else cN(ak, ag[al])
673+    let cT = {
674+        let al = aX
675+        let am = size(al)
676+        let an = nil
677+        func aN (ap,aq) =         if ((aq >= am))
678+            then ap
679+            else cS(ap, al[aq])
672680 
673-        func aJ (ak,al) =         if ((al >= ah))
674-            then ak
681+        func aO (ap,aq) =         if ((aq >= am))
682+            then ap
675683             else throw("List size exceeds 10")
676684 
677-        aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
685+        aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
678686         }
679-    func cP (E,cA) =     if ((indexOf(cM, cA) == unit))
680-        then throw(((cA + " asset is present in payments, but is not in new assets: ") + makeString(cM, ",")))
687+    func cU (E,cF) =     if ((indexOf(cR, cF) == unit))
688+        then throw(((cF + " asset is present in payments, but is not in new assets: ") + makeString(cR, ",")))
681689         else (E + 1)
682690 
683-    func cQ (E,cA) =     if ((indexOf(cO, cA) == unit))
684-        then throw(((cA + " asset is present in new assets, but is not in payments: ") + makeString(cO, ",")))
691+    func cV (E,cF) =     if ((indexOf(cT, cF) == unit))
692+        then throw(((cF + " asset is present in new assets, but is not in payments: ") + makeString(cT, ",")))
685693         else (E + 1)
686694 
687-    let bP = {
688-        let ag = cO
689-        let ah = size(ag)
690-        let ai = 0
691-        func bF (ak,al) =         if ((al >= ah))
692-            then ak
693-            else cP(ak, ag[al])
695+    let bU = {
696+        let al = cT
697+        let am = size(al)
698+        let an = 0
699+        func bK (ap,aq) =         if ((aq >= am))
700+            then ap
701+            else cU(ap, al[aq])
694702 
695-        func bG (ak,al) =         if ((al >= ah))
696-            then ak
703+        func bL (ap,aq) =         if ((aq >= am))
704+            then ap
697705             else throw("List size exceeds 10")
698706 
699-        bG(bF(bF(bF(bF(bF(bF(bF(bF(bF(bF(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
707+        bL(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
700708         }
701-    let cR = {
702-        let ag = cM
703-        let ah = size(ag)
704-        let ai = 0
705-        func cS (ak,al) =         if ((al >= ah))
706-            then ak
707-            else cQ(ak, ag[al])
709+    let cW = {
710+        let al = cR
711+        let am = size(al)
712+        let an = 0
713+        func cX (ap,aq) =         if ((aq >= am))
714+            then ap
715+            else cV(ap, al[aq])
708716 
709-        func cT (ak,al) =         if ((al >= ah))
710-            then ak
717+        func cY (ap,aq) =         if ((aq >= am))
718+            then ap
711719             else throw("List size exceeds 10")
712720 
713-        cT(cS(cS(cS(cS(cS(cS(cS(cS(cS(cS(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
721+        cY(cX(cX(cX(cX(cX(cX(cX(cX(cX(cX(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
714722         }
715-    (bP + cR)
723+    (bU + cW)
716724     }
717725 
718726 
719-func cU (cV) = {
720-    func cW (E,cX) =     {
721-        let cY = valueOrErrorMessage(parseInt(cX), ("Wrong weight format: " + cX))
722-        if (if ((o > cY))
727+func cZ (da) = {
728+    func db (E,dc) =     {
729+        let dd = valueOrErrorMessage(parseInt(dc), ("Wrong weight format: " + dc))
730+        if (if ((o > dd))
723731             then true
724-            else (cY > p))
725-            then throw(((((("Weight should be in range " + toString(o)) + " - ") + toString(p)) + ", current: ") + cX))
732+            else (dd > p))
733+            then throw(((((("Weight should be in range " + toString(o)) + " - ") + toString(p)) + ", current: ") + dc))
726734             else E
727735         }
728736 
729-    let ag = cV
730-    let ah = size(ag)
731-    let ai = 0
732-    func aI (ak,al) =     if ((al >= ah))
733-        then ak
734-        else cW(ak, ag[al])
737+    let al = da
738+    let am = size(al)
739+    let an = 0
740+    func aN (ap,aq) =     if ((aq >= am))
741+        then ap
742+        else db(ap, al[aq])
735743 
736-    func aJ (ak,al) =     if ((al >= ah))
737-        then ak
744+    func aO (ap,aq) =     if ((aq >= am))
745+        then ap
738746         else throw("List size exceeds 10")
739747 
740-    aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
748+    aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
741749     }
742750 
743751 
744-@Callable(cZ)
745-func preInit (da,db,dc,dd,de,df) = {
746-    let dg = Address(fromBase58String(de))
747-    let dh = split(da, ",")
748-    let aG = {
749-        let ag = dh
750-        let ah = size(ag)
751-        let ai = nil
752-        func aI (ak,al) =         if ((al >= ah))
753-            then ak
754-            else D(ak, ag[al])
752+@Callable(de)
753+func preInit (df,dg,dh,di,dj,dk) = {
754+    let dl = Address(fromBase58String(dj))
755+    let dm = split(df, ",")
756+    let aL = {
757+        let al = dm
758+        let am = size(al)
759+        let an = nil
760+        func aN (ap,aq) =         if ((aq >= am))
761+            then ap
762+            else D(ap, al[aq])
755763 
756-        func aJ (ak,al) =         if ((al >= ah))
757-            then ak
764+        func aO (ap,aq) =         if ((aq >= am))
765+            then ap
758766             else throw("List size exceeds 10")
759767 
760-        aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
768+        aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
761769         }
762-    let bg = {
763-        let ag = dh
764-        let ah = size(ag)
765-        let ai = ""
766-        func bF (ak,al) =         if ((al >= ah))
767-            then ak
768-            else cz(ak, ag[al])
770+    let bl = {
771+        let al = dm
772+        let am = size(al)
773+        let an = ""
774+        func bK (ap,aq) =         if ((aq >= am))
775+            then ap
776+            else cE(ap, al[aq])
769777 
770-        func bG (ak,al) =         if ((al >= ah))
771-            then ak
778+        func bL (ap,aq) =         if ((aq >= am))
779+            then ap
772780             else throw("List size exceeds 10")
773781 
774-        bG(bF(bF(bF(bF(bF(bF(bF(bF(bF(bF(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
782+        bL(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
775783         }
776-    if (ay())
784+    if (aD())
777785         then throw("contract is on stop")
778-        else if ((this != cZ.caller))
786+        else if ((this != de.caller))
779787             then throw("admin only")
780-            else if ((bg == ""))
788+            else if ((bl == ""))
781789                 then throw("pool must have one of the supported fee assets in the composition")
782-                else if ((size(dd) > 16))
790+                else if ((size(di) > 13))
783791                     then throw("too large pool domain")
784-                    else if (if ((df > 500))
792+                    else if (if ((dk > 500))
785793                         then true
786-                        else (0 > df))
794+                        else (0 > dk))
787795                         then throw("fee value must be between 50 and 500 (0.5-5%)")
788796                         else {
789-                            let di = split(db, ",")
790-                            let dj = {
791-                                let ag = di
792-                                let ah = size(ag)
793-                                let ai = 0
794-                                func cS (ak,al) =                                 if ((al >= ah))
795-                                    then ak
796-                                    else cx(ak, ag[al])
797+                            let dn = split(dg, ",")
798+                            let do = {
799+                                let al = dn
800+                                let am = size(al)
801+                                let an = 0
802+                                func cX (ap,aq) =                                 if ((aq >= am))
803+                                    then ap
804+                                    else cC(ap, al[aq])
797805 
798-                                func cT (ak,al) =                                 if ((al >= ah))
799-                                    then ak
806+                                func cY (ap,aq) =                                 if ((aq >= am))
807+                                    then ap
800808                                     else throw("List size exceeds 10")
801809 
802-                                cT(cS(cS(cS(cS(cS(cS(cS(cS(cS(cS(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
810+                                cY(cX(cX(cX(cX(cX(cX(cX(cX(cX(cX(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
803811                                 }
804-                            func dk (E,dl) =                             if ((dl >= size(aG)))
812+                            func dp (E,dq) =                             if ((dq >= size(aL)))
805813                                 then E
806814                                 else {
807-                                    let dm = {
808-                                        let s = aG[dl]
815+                                    let dr = {
816+                                        let s = aL[dq]
809817                                         if ($isInstanceOf(s, "ByteVector"))
810818                                             then {
811-                                                let aA = s
812-                                                value(assetInfo(aA)).decimals
819+                                                let aF = s
820+                                                value(assetInfo(aF)).decimals
813821                                                 }
814822                                             else 8
815823                                         }
816-                                    (E ++ [IntegerEntry((("static_" + dh[dl]) + "_scale"), pow(10, 0, dm, 0, 0, DOWN)), IntegerEntry((("static_" + dh[dl]) + "_decimals"), dm), IntegerEntry((("static_" + dh[dl]) + "_weight"), value(parseInt(di[dl])))])
824+                                    (E ++ [IntegerEntry((("static_" + dm[dq]) + "_scale"), pow(10, 0, dr, 0, 0, DOWN)), IntegerEntry((("static_" + dm[dq]) + "_decimals"), dr), IntegerEntry((("static_" + dm[dq]) + "_weight"), value(parseInt(dn[dq])))])
817825                                     }
818826 
819-                            if ((dj != 10000))
827+                            if ((do != 10000))
820828                                 then throw("sum of token weights must be equal to 10000")
821829                                 else ({
822-                                    let ag = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
823-                                    let ah = size(ag)
824-                                    let ai = nil
825-                                    func dn (ak,al) =                                     if ((al >= ah))
826-                                        then ak
827-                                        else dk(ak, ag[al])
830+                                    let al = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
831+                                    let am = size(al)
832+                                    let an = nil
833+                                    func ds (ap,aq) =                                     if ((aq >= am))
834+                                        then ap
835+                                        else dp(ap, al[aq])
828836 
829-                                    func do (ak,al) =                                     if ((al >= ah))
830-                                        then ak
837+                                    func dt (ap,aq) =                                     if ((aq >= am))
838+                                        then ap
831839                                         else throw("List size exceeds 10")
832840 
833-                                    do(dn(dn(dn(dn(dn(dn(dn(dn(dn(dn(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
834-                                    } ++ [StringEntry("static_tokenIds", da), StringEntry("static_feeToken", bg), StringEntry("static_tokenWeights", db), IntegerEntry("static_tokensAmount", size(aG)), StringEntry("static_poolDomain", dd), StringEntry("static_baseTokenId", dc), StringEntry("static_poolOwner", de), IntegerEntry("static_fee", df), IntegerEntry("static_KMult", g)])
841+                                    dt(ds(ds(ds(ds(ds(ds(ds(ds(ds(ds(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
842+                                    } ++ [StringEntry("static_tokenIds", df), StringEntry("static_feeToken", bl), StringEntry("static_tokenWeights", dg), IntegerEntry("static_tokensAmount", size(aL)), StringEntry("static_poolDomain", di), StringEntry("static_baseTokenId", dh), StringEntry("static_poolOwner", dj), IntegerEntry("static_fee", dk), IntegerEntry("static_KMult", g), IntegerEntry("global_wasPreInited", 1)])
835843                             }
836844     }
837845 
838846 
839847 
840-@Callable(cZ)
841-func deInit () = if (ay())
848+@Callable(de)
849+func deInit () = if (aD())
842850     then throw("contract is on stop")
843-    else if ((cZ.caller != this))
851+    else if ((de.caller != this))
844852         then throw("admin only")
845853         else [IntegerEntry("global_wasInited", 0)]
846854 
847855 
848856 
849-@Callable(cZ)
857+@Callable(de)
850858 func init () = {
851-    func dp () =     {
852-        func aT (E,cy) =         (E ++ [IntegerEntry((("global_" + x(cy.assetId)) + "_balance"), cy.amount)])
859+    func du () =     {
860+        func aY (E,cD) =         (E ++ [IntegerEntry((("global_" + x(cD.assetId)) + "_balance"), cD.amount)])
853861 
854-        let ag = cZ.payments
855-        let ah = size(ag)
856-        let ai = nil
857-        func aI (ak,al) =         if ((al >= ah))
858-            then ak
859-            else aT(ak, ag[al])
862+        let al = de.payments
863+        let am = size(al)
864+        let an = nil
865+        func aN (ap,aq) =         if ((aq >= am))
866+            then ap
867+            else aY(ap, al[aq])
860868 
861-        func aJ (ak,al) =         if ((al >= ah))
862-            then ak
869+        func aO (ap,aq) =         if ((aq >= am))
870+            then ap
863871             else throw("List size exceeds 10")
864872 
865-        aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
873+        aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
866874         }
867875 
868-    func dq (aS) =     {
869-        func aT (E,dr) =         {
870-            let y = dr.assetId
871-            func bD (E,cy) =             if ((cy == y))
872-                then value(indexOf(af, cy))
876+    func dv (aX) =     {
877+        func aY (E,dw) =         {
878+            let y = dw.assetId
879+            func bI (E,cD) =             if ((cD == y))
880+                then value(indexOf(ak, cD))
873881                 else E
874882 
875-            let ds = {
876-                let ag = af
877-                let ah = size(ag)
878-                let ai = 1
879-                func aI (ak,al) =                 if ((al >= ah))
880-                    then ak
881-                    else bD(ak, ag[al])
883+            let dx = {
884+                let al = ak
885+                let am = size(al)
886+                let an = 1
887+                func aN (ap,aq) =                 if ((aq >= am))
888+                    then ap
889+                    else bI(ap, al[aq])
882890 
883-                func aJ (ak,al) =                 if ((al >= ah))
884-                    then ak
891+                func aO (ap,aq) =                 if ((aq >= am))
892+                    then ap
885893                     else throw("List size exceeds 10")
886894 
887-                aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
895+                aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
888896                 }
889-            fraction(E, pow(dr.amount, aq[ds], an[ds], d, 8, FLOOR), f)
897+            fraction(E, pow(dw.amount, av[dx], as[dx], d, 8, FLOOR), f)
890898             }
891899 
892-        let ag = aS
893-        let ah = size(ag)
894-        let ai = j
895-        func aI (ak,al) =         if ((al >= ah))
896-            then ak
897-            else aT(ak, ag[al])
900+        let al = aX
901+        let am = size(al)
902+        let an = j
903+        func aN (ap,aq) =         if ((aq >= am))
904+            then ap
905+            else aY(ap, al[aq])
898906 
899-        func aJ (ak,al) =         if ((al >= ah))
900-            then ak
907+        func aO (ap,aq) =         if ((aq >= am))
908+            then ap
901909             else throw("List size exceeds 10")
902910 
903-        aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
911+        aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
904912         }
905913 
906-    if (ay())
914+    if (aD())
907915         then throw("contract is on stop")
908916         else if ((q("global_wasInited") > 0))
909917             then throw("pool already inited")
910918             else {
911-                let dt = dq(cZ.payments)
912-                if ((dt == 0))
919+                let dy = dv(de.payments)
920+                if ((dy == 0))
913921                     then throw("you need a bigger tokens amount to launch the pool")
914922                     else {
915-                        let du = Issue(v("static_poolDomain"), "Puzzle Swap: pool index token", dt, i, true, unit, 0)
916-                        let dv = calculateAssetId(du)
917-                        (dp() ++ [du, IntegerEntry("global_poolToken_amount", dt), IntegerEntry("global_wasInited", 1), BinaryEntry("global_poolToken_id", dv), StringEntry("static_poolToken_idStr", x(dv)), IntegerEntry((toString(cZ.caller) + "_indexStaked"), dt), IntegerEntry("global_indexStaked", dt)])
923+                        let dz = Issue(("PZ " + v("static_poolDomain")), "Puzzle Swap: pool index token", dy, i, true, unit, 0)
924+                        let dA = calculateAssetId(dz)
925+                        (du() ++ [dz, IntegerEntry("global_poolToken_amount", dy), IntegerEntry("global_wasInited", 1), BinaryEntry("global_poolToken_id", dA), StringEntry("static_poolToken_idStr", x(dA)), IntegerEntry((toString(de.caller) + "_indexStaked"), dy), IntegerEntry("global_indexStaked", dy)])
918926                         }
919927                 }
920928     }
921929 
922930 
923931 
924-@Callable(cZ)
925-func generateIndex (bJ) = if ((size(cZ.payments) != ae))
926-    then throw(("you need to attach all pool tokens. amount of pool tokens: " + toString(ae)))
927-    else if (!(bz(cZ.payments)))
932+@Callable(de)
933+func generateIndex (bO) = if ((size(de.payments) != aj))
934+    then throw(("you need to attach all pool tokens. amount of pool tokens: " + toString(aj)))
935+    else if (!(bE(de.payments)))
928936         then throw("wrong assets attached")
929937         else {
930-            let dw = aR(cZ.payments)
931-            let cE = bH(dw, cZ.payments, cZ.originCaller, bJ)
932-            let dx = fraction(dw, g, aE(), DOWN)
933-            let dy = Reissue(getBinaryValue("global_poolToken_id"), dx, true)
934-            $Tuple2((cE ++ [dy, ScriptTransfer(cZ.caller, dx, u("global_poolToken_id")), IntegerEntry("global_poolToken_amount", (q("global_poolToken_amount") + dx))]), dx)
938+            let dB = aW(de.payments)
939+            let cJ = bM(dB, de.payments, de.originCaller, bO)
940+            let dC = fraction(dB, g, aJ(), DOWN)
941+            let dD = Reissue(getBinaryValue("global_poolToken_id"), dC, true)
942+            $Tuple2((cJ ++ [dD, ScriptTransfer(de.caller, dC, u("global_poolToken_id")), IntegerEntry("global_poolToken_amount", (q("global_poolToken_amount") + dC))]), dC)
935943             }
936944 
937945 
938946 
939-@Callable(cZ)
940-func redeemIndex (dz) = {
941-    let dr = cZ.payments[0]
942-    if ((dr.assetId != u("global_poolToken_id")))
947+@Callable(de)
948+func redeemIndex (dE) = {
949+    let dw = de.payments[0]
950+    if ((dw.assetId != u("global_poolToken_id")))
943951         then throw("please attach pool share token")
944-        else if (ay())
952+        else if (aD())
945953             then throw("contract is on stop")
946954             else {
947-                let dA = dr.amount
948-                let dB = fraction(dA, aE(), g, DOWN)
949-                let cE = bT(dB, if (dz)
950-                    then cZ.originCaller
951-                    else cZ.caller)
952-                (cE ++ [Burn(u("global_poolToken_id"), dA), IntegerEntry("global_poolToken_amount", (q("global_poolToken_amount") - dA))])
955+                let dF = dw.amount
956+                let dG = fraction(dF, aJ(), g, DOWN)
957+                let cJ = bY(dG, if (dE)
958+                    then de.originCaller
959+                    else de.caller)
960+                (cJ ++ [Burn(u("global_poolToken_id"), dF), IntegerEntry("global_poolToken_amount", (q("global_poolToken_amount") - dF))])
953961                 }
954962     }
955963 
956964 
957965 
958-@Callable(cZ)
966+@Callable(de)
959967 func stakeIndex () = {
960-    let cq = toString(cZ.originCaller)
961-    let dr = cZ.payments[0]
962-    if ((value(dr.assetId) != u("global_poolToken_id")))
968+    let cv = toString(de.originCaller)
969+    let dw = de.payments[0]
970+    if ((value(dw.assetId) != u("global_poolToken_id")))
963971         then throw("wrong asset attached")
964-        else cv(cq, dr.amount)
972+        else cA(cv, dw.amount)
965973     }
966974 
967975 
968976 
969-@Callable(cZ)
970-func stakeIndexFor (cq) = {
971-    let dr = cZ.payments[0]
972-    if ((value(dr.assetId) != u("global_poolToken_id")))
977+@Callable(de)
978+func stakeIndexFor (cv) = {
979+    let dw = de.payments[0]
980+    if ((value(dw.assetId) != u("global_poolToken_id")))
973981         then throw("wrong asset attached")
974-        else cv(cq, dr.amount)
982+        else cA(cv, dw.amount)
975983     }
976984 
977985 
978986 
979-@Callable(cZ)
980-func unstakeIndex (dC) = {
981-    let cq = toString(cZ.originCaller)
982-    let dD = q((cq + "_indexStaked"))
983-    if (ay())
987+@Callable(de)
988+func unstakeIndex (dH) = {
989+    let cv = if ((indexOf(ag, toString(de.caller)) != unit))
990+        then toString(de.originCaller)
991+        else toString(de.caller)
992+    let dI = q((cv + "_indexStaked"))
993+    if (aD())
984994         then throw("contract is on stop")
985-        else if ((dC > dD))
995+        else if ((dH > dI))
986996             then throw("you don't have index tokens available")
987-            else if (ay())
997+            else if (aD())
988998                 then throw("contract is on stop")
989-                else (co(cZ.originCaller)._1 ++ [IntegerEntry((cq + "_indexStaked"), (dD - dC)), IntegerEntry("global_indexStaked", (q("global_indexStaked") - dC)), ScriptTransfer(cZ.caller, dC, getBinaryValue("global_poolToken_id"))])
999+                else (ct(addressFromStringValue(cv))._1 ++ [IntegerEntry((cv + "_indexStaked"), (dI - dH)), IntegerEntry("global_indexStaked", (q("global_indexStaked") - dH)), ScriptTransfer(de.caller, dH, getBinaryValue("global_poolToken_id"))])
9901000     }
9911001 
9921002 
9931003 
994-@Callable(cZ)
995-func claimIndexRewards () = if (ay())
1004+@Callable(de)
1005+func claimIndexRewards () = if (aD())
9961006     then throw("contract is on stop")
997-    else co(cZ.caller)
1007+    else ct(de.caller)
9981008 
9991009 
10001010 
1001-@Callable(cZ)
1002-func evaluateClaim (dE) = $Tuple2(nil, co(addressFromStringValue(dE))._2)
1011+@Callable(de)
1012+func evaluateClaim (dJ) = $Tuple2(nil, ct(addressFromStringValue(dJ))._2)
10031013 
10041014 
10051015 
1006-@Callable(cZ)
1007-func swap (ca,dF) = {
1008-    let dr = if ((size(cZ.payments) == 1))
1009-        then value(cZ.payments[0])
1016+@Callable(de)
1017+func swap (cf,dK) = {
1018+    let dw = if ((size(de.payments) == 1))
1019+        then value(de.payments[0])
10101020         else throw("please attach exactly one payment")
1011-    let bY = value(cZ.payments[0].amount)
1012-    let dG = dr.assetId
1013-    let dH = z(ca)
1014-    let bZ = x(dG)
1015-    let dI = (f / q((("static_" + bZ) + "_scale")))
1016-    let dJ = (f / q((("static_" + ca) + "_scale")))
1017-    let dK = v("static_feeToken")
1018-    let dL = if ((dK == ""))
1019-        then Q
1020-        else z(dK)
1021-    let dM = q((("global_" + x(dG)) + "_balance"))
1022-    let dN = q((("global_" + ca) + "_balance"))
1023-    let dO = (dM * dI)
1024-    let dP = (dN * dJ)
1025-    let dQ = fraction(bY, aw, h)
1026-    let dR = (bY - dQ)
1027-    let dS = (dR * dI)
1028-    let dT = bX(dS, dG, dH, dO, dP)
1029-    let dU = fraction(dT, 1, dJ)
1030-    let dV = (dN - dU)
1031-    let dW = (dM + dR)
1032-    let dX = if ((dL == dG))
1033-        then dW
1034-        else if ((dL == dH))
1035-            then dV
1036-            else q((("global_" + x(dL)) + "_balance"))
1037-    let dY = bX(dQ, dG, dL, dM, dX)
1038-    if ((dF > dU))
1021+    let cd = value(de.payments[0].amount)
1022+    let dL = dw.assetId
1023+    let dM = z(cf)
1024+    let ce = x(dL)
1025+    let dN = (f / q((("static_" + ce) + "_scale")))
1026+    let dO = (f / q((("static_" + cf) + "_scale")))
1027+    let dP = v("static_feeToken")
1028+    let dQ = if ((dP == ""))
1029+        then R
1030+        else z(dP)
1031+    let dR = q((("global_" + x(dL)) + "_balance"))
1032+    let dS = q((("global_" + cf) + "_balance"))
1033+    let dT = (dR * dN)
1034+    let dU = (dS * dO)
1035+    let dV = fraction(cd, aB, h)
1036+    let dW = (cd - dV)
1037+    let dX = (dW * dN)
1038+    let dY = cc(dX, dL, dM, dT, dU)
1039+    let dZ = fraction(dY, 1, dO)
1040+    let ea = (dS - dZ)
1041+    let eb = (dR + dW)
1042+    let ec = if ((dQ == dL))
1043+        then eb
1044+        else if ((dQ == dM))
1045+            then ea
1046+            else q((("global_" + x(dQ)) + "_balance"))
1047+    let ed = cc(dV, dL, dQ, dR, ec)
1048+    if ((dK > dZ))
10391049         then throw("amount to recieve is lower than given one")
1040-        else if ((dH == dG))
1050+        else if ((dM == dL))
10411051             then throw("this swap is not allowed")
1042-            else if ((0 > (dN - dU)))
1052+            else if ((0 > (dS - dZ)))
10431053                 then throw("contract is out of reserves")
1044-                else if (ay())
1054+                else if (aD())
10451055                     then throw("contract is on stop")
10461056                     else {
1047-                        let dZ = fraction(dY, 1, 10)
1048-                        let ea = fraction(dY, 4, 10)
1049-                        let eb = if (if ((dL == Q))
1050-                            then true
1051-                            else (dL == R))
1052-                            then reentrantInvoke(aa, "topUpReward", nil, [AttachedPayment(dL, ea)])
1057+                        let ee = fraction(ed, 1, 10)
1058+                        let ef = fraction(ed, 4, 10)
1059+                        let eg = eb
1060+                        let eh = (ea - (if ((dM == dQ))
1061+                            then ed
1062+                            else 0))
1063+                        let ei = if (if ((dQ != dL))
1064+                            then (dQ != dM)
1065+                            else false)
1066+                            then (ec - ed)
10531067                             else unit
1054-                        if ((eb == eb))
1055-                            then {
1056-                                let ec = dW
1057-                                let ed = (dV - (if ((dH == dL))
1058-                                    then dY
1059-                                    else 0))
1060-                                let ee = if (if ((dL != dG))
1061-                                    then (dL != dH)
1062-                                    else false)
1063-                                    then (dX - dY)
1064-                                    else unit
1065-                                let ef = IntegerEntry((("global_" + x(dG)) + "_balance"), ec)
1066-                                let eg = IntegerEntry((("global_" + ca) + "_balance"), ed)
1067-                                let eh = if ((ee != unit))
1068-                                    then IntegerEntry((("global_" + x(dL)) + "_balance"), value(ee))
1069-                                    else StringEntry("hello", "world")
1070-                                let ei = aX(dG, bY, dM, dX)
1071-                                let ej = bs(dG, bY, dM)
1072-                                $Tuple2(([eg, ef, eh, ScriptTransfer(cZ.caller, dU, dH), ScriptTransfer(addressFromStringValue(v("static_poolOwner")), dZ, dL), IntegerEntry("global_earnedByOwner", (q("global_earnedByOwner") + dZ)), IntegerEntry("global_volume", (q("global_volume") + ei)), IntegerEntry("global_volume_usd", (q("global_volume_usd") + ej))] ++ (if ((eb == unit))
1073-                                    then [ScriptTransfer(ab, ea, dL)]
1074-                                    else nil)), dU)
1075-                                }
1076-                            else throw("Strict value is not equal to itself.")
1068+                        let ej = IntegerEntry((("global_" + x(dL)) + "_balance"), eg)
1069+                        let ek = IntegerEntry((("global_" + cf) + "_balance"), eh)
1070+                        let el = if ((ei != unit))
1071+                            then IntegerEntry((("global_" + x(dQ)) + "_balance"), value(ei))
1072+                            else StringEntry("hello", "world")
1073+                        let em = bc(dL, cd, dR, ec)
1074+                        let en = bx(dL, cd, dR)
1075+                        $Tuple2([ek, ej, el, ScriptTransfer(de.caller, dZ, dM), ScriptTransfer(addressFromStringValue(v("static_poolOwner")), ee, dQ), IntegerEntry("global_earnedByOwner", (q("global_earnedByOwner") + ee)), IntegerEntry("global_volume", (q("global_volume") + em)), IntegerEntry("global_volume_usd", (q("global_volume_usd") + en)), ScriptTransfer(ad, ef, dQ)], dZ)
10771076                         }
10781077     }
10791078 
10801079 
10811080 
1082-@Callable(cZ)
1083-func swapReadOnly (bZ,ca,bY) = {
1084-    let dG = z(bZ)
1085-    let dH = z(ca)
1086-    let dI = (f / q((("static_" + bZ) + "_scale")))
1087-    let dJ = (f / q((("static_" + ca) + "_scale")))
1088-    let dK = v("static_feeToken")
1089-    let dL = if ((dK == ""))
1090-        then Q
1091-        else z(dK)
1092-    let dM = q((("global_" + x(dG)) + "_balance"))
1093-    let dN = q((("global_" + ca) + "_balance"))
1094-    let dO = (dM * dI)
1095-    let dP = (dN * dJ)
1096-    let dQ = fraction(bY, aw, h)
1097-    let dR = (bY - dQ)
1098-    let dS = (dR * dI)
1099-    let dT = bX(dS, dG, dH, dO, dP)
1100-    let dU = fraction(dT, 1, dJ)
1101-    let dV = (dN - dU)
1102-    let dW = (dM + dR)
1103-    let dX = if ((dL == dG))
1104-        then dW
1105-        else if ((dL == dH))
1106-            then dV
1107-            else q((("global_" + x(dL)) + "_balance"))
1108-    let dY = bX(dQ, dG, dL, dM, dX)
1109-    if ((dH == dG))
1081+@Callable(de)
1082+func swapReadOnly (ce,cf,cd) = {
1083+    let dL = z(ce)
1084+    let dM = z(cf)
1085+    let dN = (f / q((("static_" + ce) + "_scale")))
1086+    let dO = (f / q((("static_" + cf) + "_scale")))
1087+    let dP = v("static_feeToken")
1088+    let dQ = if ((dP == ""))
1089+        then R
1090+        else z(dP)
1091+    let dR = q((("global_" + x(dL)) + "_balance"))
1092+    let dS = q((("global_" + cf) + "_balance"))
1093+    let dT = (dR * dN)
1094+    let dU = (dS * dO)
1095+    let dV = fraction(cd, aB, h)
1096+    let dW = (cd - dV)
1097+    let dX = (dW * dN)
1098+    let dY = cc(dX, dL, dM, dT, dU)
1099+    let dZ = fraction(dY, 1, dO)
1100+    let ea = (dS - dZ)
1101+    let eb = (dR + dW)
1102+    let ec = if ((dQ == dL))
1103+        then eb
1104+        else if ((dQ == dM))
1105+            then ea
1106+            else q((("global_" + x(dQ)) + "_balance"))
1107+    let ed = cc(dV, dL, dQ, dR, ec)
1108+    if ((dM == dL))
11101109         then throw("this swap is not allowed")
1111-        else if ((0 > (dN - dU)))
1110+        else if ((0 > (dS - dZ)))
11121111             then throw("contract is out of reserves")
1113-            else if (ay())
1112+            else if (aD())
11141113                 then throw("contract is on stop")
1115-                else $Tuple2(nil, dU)
1114+                else $Tuple2(nil, dZ)
11161115     }
11171116 
11181117 
11191118 
1120-@Callable(cZ)
1121-func transferOwnership (ek) = if ((toString(cZ.caller) != v("static_poolOwner")))
1119+@Callable(de)
1120+func transferOwnership (eo) = if ((toString(de.caller) != v("static_poolOwner")))
11221121     then throw("this call available only for pool owner")
1123-    else [StringEntry("static_poolOwner", ek)]
1122+    else [StringEntry("static_poolOwner", eo)]
11241123 
11251124 
11261125 
1127-@Callable(cZ)
1128-func setFee (el) = if ((toString(cZ.caller) != v("static_poolOwner")))
1126+@Callable(de)
1127+func setFee (ep) = if ((toString(de.caller) != v("static_poolOwner")))
11291128     then throw("this call available only for pool owner")
1130-    else [IntegerEntry("static_fee", el)]
1129+    else if ((1 > valueOrElse(getInteger(ah, ("approvedTx_" + toBase58String(de.transactionId))), 0)))
1130+        then throw("this transaction needs approval from puzzle network")
1131+        else [IntegerEntry("static_fee", ep)]
11311132 
11321133 
11331134 
1134-@Callable(cZ)
1135-func setRebalancingPlan (da,db,dc,em,en) = if ((cZ.caller != addressFromStringValue(v("static_poolOwner"))))
1135+@Callable(de)
1136+func setRebalancingPlan (df,dg,dh,eq,er) = if ((de.caller != addressFromStringValue(v("static_poolOwner"))))
11361137     then throw("this call available only for pool owner")
11371138     else if (valueOrElse(getBoolean(this, "rebalance_inProgress"), false))
11381139         then throw("rebalancing in progress")
11391140         else {
1140-            let eo = split(db, ",")
1141-            let ep = split(da, ",")
1142-            let bg = {
1143-                let ag = ep
1144-                let ah = size(ag)
1145-                let ai = ""
1146-                func aI (ak,al) =                 if ((al >= ah))
1147-                    then ak
1148-                    else cz(ak, ag[al])
1141+            let es = split(dg, ",")
1142+            let et = split(df, ",")
1143+            let bl = {
1144+                let al = et
1145+                let am = size(al)
1146+                let an = ""
1147+                func aN (ap,aq) =                 if ((aq >= am))
1148+                    then ap
1149+                    else cE(ap, al[aq])
11491150 
1150-                func aJ (ak,al) =                 if ((al >= ah))
1151-                    then ak
1151+                func aO (ap,aq) =                 if ((aq >= am))
1152+                    then ap
11521153                     else throw("List size exceeds 10")
11531154 
1154-                aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1155+                aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
11551156                 }
1156-            let dj = {
1157-                let ag = eo
1158-                let ah = size(ag)
1159-                let ai = 0
1160-                func bF (ak,al) =                 if ((al >= ah))
1161-                    then ak
1162-                    else cx(ak, ag[al])
1157+            let do = {
1158+                let al = es
1159+                let am = size(al)
1160+                let an = 0
1161+                func bK (ap,aq) =                 if ((aq >= am))
1162+                    then ap
1163+                    else cC(ap, al[aq])
11631164 
1164-                func bG (ak,al) =                 if ((al >= ah))
1165-                    then ak
1165+                func bL (ap,aq) =                 if ((aq >= am))
1166+                    then ap
11661167                     else throw("List size exceeds 10")
11671168 
1168-                bG(bF(bF(bF(bF(bF(bF(bF(bF(bF(bF(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1169+                bL(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
11691170                 }
1170-            let eq = getStringValue("static_tokenIds")
1171-            let er = split(eq, ",")
1172-            func es (E,cA) =             if ((indexOf(er, cA) == unit))
1173-                then (E ++ [cA])
1171+            let eu = getStringValue("static_tokenIds")
1172+            let ev = split(eu, ",")
1173+            func ew (E,cF) =             if ((indexOf(ev, cF) == unit))
1174+                then (E ++ [cF])
11741175                 else E
11751176 
1176-            func et (E,cA) =             if ((indexOf(ep, cA) == unit))
1177-                then (E ++ [cA])
1177+            func ex (E,cF) =             if ((indexOf(et, cF) == unit))
1178+                then (E ++ [cF])
11781179                 else E
11791180 
1180-            let eu = {
1181-                let ag = ep
1182-                let ah = size(ag)
1183-                let ai = nil
1184-                func cS (ak,al) =                 if ((al >= ah))
1185-                    then ak
1186-                    else es(ak, ag[al])
1181+            let ey = {
1182+                let al = et
1183+                let am = size(al)
1184+                let an = nil
1185+                func cX (ap,aq) =                 if ((aq >= am))
1186+                    then ap
1187+                    else ew(ap, al[aq])
11871188 
1188-                func cT (ak,al) =                 if ((al >= ah))
1189-                    then ak
1189+                func cY (ap,aq) =                 if ((aq >= am))
1190+                    then ap
11901191                     else throw("List size exceeds 10")
11911192 
1192-                cT(cS(cS(cS(cS(cS(cS(cS(cS(cS(cS(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1193+                cY(cX(cX(cX(cX(cX(cX(cX(cX(cX(cX(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
11931194                 }
1194-            let ev = {
1195-                let ag = er
1196-                let ah = size(ag)
1197-                let ai = nil
1198-                func dn (ak,al) =                 if ((al >= ah))
1199-                    then ak
1200-                    else et(ak, ag[al])
1195+            let ez = {
1196+                let al = ev
1197+                let am = size(al)
1198+                let an = nil
1199+                func ds (ap,aq) =                 if ((aq >= am))
1200+                    then ap
1201+                    else ex(ap, al[aq])
12011202 
1202-                func do (ak,al) =                 if ((al >= ah))
1203-                    then ak
1203+                func dt (ap,aq) =                 if ((aq >= am))
1204+                    then ap
12041205                     else throw("List size exceeds 10")
12051206 
1206-                do(dn(dn(dn(dn(dn(dn(dn(dn(dn(dn(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1207+                dt(ds(ds(ds(ds(ds(ds(ds(ds(ds(ds(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
12071208                 }
1208-            let ew = cL(eu, cZ.payments)
1209-            let ex = cU(eo)
1210-            if ((ex == ex))
1211-                then if ((ew != (size(eu) + size(cZ.payments))))
1209+            let eA = cQ(ey, de.payments)
1210+            let eB = cZ(es)
1211+            if ((eB == eB))
1212+                then if ((eA != (size(ey) + size(de.payments))))
12121213                     then throw("Payments not present or something wrong with them")
1213-                    else if ((size(ep) != size(eo)))
1214+                    else if ((size(et) != size(es)))
12141215                         then throw("assetIds and assetWeights should have same length")
1215-                        else if ((ew != (size(eu) + size(cZ.payments))))
1216+                        else if ((eA != (size(ey) + size(de.payments))))
12161217                             then throw("Payments not present or something wrong with them")
1217-                            else if ((bg == ""))
1218+                            else if ((bl == ""))
12181219                                 then throw("pool must have one of the supported fee assets in the composition")
1219-                                else if ((indexOf(ep, dc) == unit))
1220+                                else if ((indexOf(et, dh) == unit))
12201221                                     then throw("baseTokenId should be present in assetIds")
1221-                                    else if (if ((k > em))
1222+                                    else if (if ((k > eq))
12221223                                         then true
1223-                                        else (em > l))
1224-                                        then throw(((((("Steps amount should be between " + toString(k)) + " and ") + toString(l)) + ", current: ") + toString(em)))
1225-                                        else if (if ((m > en))
1224+                                        else (eq > l))
1225+                                        then throw(((((("Steps amount should be between " + toString(k)) + " and ") + toString(l)) + ", current: ") + toString(eq)))
1226+                                        else if (if ((m > er))
12261227                                             then true
1227-                                            else (en > n))
1228-                                            then throw(((((("Steps interval should be between " + toString(m)) + " and ") + toString(n)) + ", current: ") + toString(en)))
1229-                                            else if ((dj != 10000))
1230-                                                then throw(("sum of token weights must be equal to 10000, current: " + toString(dj)))
1228+                                            else (er > n))
1229+                                            then throw(((((("Steps interval should be between " + toString(m)) + " and ") + toString(n)) + ", current: ") + toString(er)))
1230+                                            else if ((do != 10000))
1231+                                                then throw(("sum of token weights must be equal to 10000, current: " + toString(do)))
12311232                                                 else {
1232-                                                    func cF (E,A) =                                                     {
1233-                                                        let ey = q((("static_" + A) + "_weight"))
1234-                                                        let ez = if ((indexOf(ep, A) == unit))
1233+                                                    func cK (E,A) =                                                     {
1234+                                                        let eC = q((("static_" + A) + "_weight"))
1235+                                                        let eD = if ((indexOf(et, A) == unit))
12351236                                                             then 0
1236-                                                            else parseIntValue(value(eo[value(indexOf(ep, A))]))
1237-                                                        let eA = fraction((ez - ey), 10000, em)
1238-                                                        (E ++ [toString(eA)])
1237+                                                            else parseIntValue(value(es[value(indexOf(et, A))]))
1238+                                                        let eE = fraction((eD - eC), 10000, eq)
1239+                                                        (E ++ [toString(eE)])
12391240                                                         }
12401241 
1241-                                                    let eB = cB(ep)
1242-                                                    let eC = {
1243-                                                        let ag = eB
1244-                                                        let ah = size(ag)
1245-                                                        let ai = nil
1246-                                                        func eD (ak,al) =                                                         if ((al >= ah))
1247-                                                            then ak
1248-                                                            else cF(ak, ag[al])
1242+                                                    let eF = cG(et)
1243+                                                    let eG = {
1244+                                                        let al = eF
1245+                                                        let am = size(al)
1246+                                                        let an = nil
1247+                                                        func eH (ap,aq) =                                                         if ((aq >= am))
1248+                                                            then ap
1249+                                                            else cK(ap, al[aq])
12491250 
1250-                                                        func eE (ak,al) =                                                         if ((al >= ah))
1251-                                                            then ak
1251+                                                        func eI (ap,aq) =                                                         if ((aq >= am))
1252+                                                            then ap
12521253                                                             else throw("List size exceeds 10")
12531254 
1254-                                                        eE(eD(eD(eD(eD(eD(eD(eD(eD(eD(eD(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1255+                                                        eI(eH(eH(eH(eH(eH(eH(eH(eH(eH(eH(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
12551256                                                         }
1256-                                                    let eF = (cG(ep) > 0)
1257-                                                    func eG (E,cA) =                                                     (E ++ [IntegerEntry(("rebalance_attachedPayment_" + x(cA.assetId)), cA.amount)])
1257+                                                    let eJ = (cL(et) > 0)
1258+                                                    func eK (E,cF) =                                                     (E ++ [IntegerEntry(("rebalance_attachedPayment_" + x(cF.assetId)), cF.amount)])
12581259 
1259-                                                    let eH = {
1260-                                                        let ag = cZ.payments
1261-                                                        let ah = size(ag)
1262-                                                        let ai = nil
1263-                                                        func eI (ak,al) =                                                         if ((al >= ah))
1264-                                                            then ak
1265-                                                            else eG(ak, ag[al])
1260+                                                    let eL = {
1261+                                                        let al = de.payments
1262+                                                        let am = size(al)
1263+                                                        let an = nil
1264+                                                        func eM (ap,aq) =                                                         if ((aq >= am))
1265+                                                            then ap
1266+                                                            else eK(ap, al[aq])
12661267 
1267-                                                        func eJ (ak,al) =                                                         if ((al >= ah))
1268-                                                            then ak
1268+                                                        func eN (ap,aq) =                                                         if ((aq >= am))
1269+                                                            then ap
12691270                                                             else throw("List size exceeds 10")
12701271 
1271-                                                        eJ(eI(eI(eI(eI(eI(eI(eI(eI(eI(eI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1272+                                                        eN(eM(eM(eM(eM(eM(eM(eM(eM(eM(eM(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
12721273                                                         }
1273-                                                    let eK = aF()
1274-                                                    let eL = invoke(ac, "notifyPoolChange", nil, nil)
1275-                                                    if ((eL == eL))
1276-                                                        then (([StringEntry("rebalance_addedAssets", makeString(eu, ",")), StringEntry("rebalance_removedAssets", makeString(ev, ",")), StringEntry("tmp_rebalanceAssetIds", makeString(eB, ",")), BooleanEntry("rebalance_inProgress", true), BooleanEntry("rebalance_newTokensAdded", eF), IntegerEntry("rebalance_stepsDone", 0), IntegerEntry("rebalance_lastStepHeight", height), IntegerEntry("rebalance_stepsAmount", em), IntegerEntry("rebalance_stepsInterval", en), StringEntry("rebalance_assetIds", da), StringEntry("rebalance_newBaseTokenId", dc), StringEntry("rebalance_assetDeltas", makeString(eC, ","))] ++ eH) ++ eK)
1274+                                                    let eO = aK()
1275+                                                    let eP = invoke(ah, "requestRebalancing", [toBase58String(de.transactionId)], nil)
1276+                                                    if ((eP == eP))
1277+                                                        then (([StringEntry("rebalance_addedAssets", makeString(ey, ",")), StringEntry("rebalance_removedAssets", makeString(ez, ",")), StringEntry("tmp_rebalanceAssetIds", makeString(eF, ",")), BooleanEntry("rebalance_inProgress", true), BooleanEntry("rebalance_newTokensAdded", eJ), IntegerEntry("rebalance_stepsDone", 0), IntegerEntry("rebalance_lastStepHeight", height), IntegerEntry("rebalance_stepsAmount", eq), IntegerEntry("rebalance_stepsInterval", er), StringEntry("rebalance_assetIds", df), StringEntry("rebalance_newBaseTokenId", dh), StringEntry("rebalance_assetDeltas", makeString(eG, ","))] ++ eL) ++ eO)
12771278                                                         else throw("Strict value is not equal to itself.")
12781279                                                     }
12791280                 else throw("Strict value is not equal to itself.")
12801281             }
12811282 
12821283 
12831284 
1284-@Callable(cZ)
1285-func stepRebalancing () = if (!(valueOrElse(getBoolean(this, "rebalance_inProgress"), false)))
1286-    then throw("no rebalancing in progress")
1287-    else {
1288-        let eM = getIntegerValue("rebalance_lastStepHeight")
1289-        let eN = getIntegerValue("rebalance_stepsInterval")
1290-        let eO = getIntegerValue("rebalance_stepsDone")
1291-        let eP = (eM + eN)
1292-        if ((eP > height))
1293-            then throw("can't be done yet")
1285+@Callable(de)
1286+func stepRebalancing () = {
1287+    let eQ = valueOrErrorMessage(getString(ah, ("pool_lastRebalancing_" + toString(this))), "rebalancing is not registered at gov address")
1288+    if (!(valueOrElse(getBoolean(this, "rebalance_inProgress"), false)))
1289+        then throw("no rebalancing in progress")
1290+        else if ((valueOrElse(getInteger(ah, ("rebalancing_status_" + eQ)), 0) != 2))
1291+            then throw("this transaction needs approval from puzzle network")
12941292             else {
1295-                let eC = split(getStringValue("rebalance_assetDeltas"), ",")
1296-                let eQ = getStringValue("tmp_rebalanceAssetIds")
1297-                let eR = split(eQ, ",")
1298-                func cF (E,A) =                 (E ++ [toString(fraction(((valueOrElse(getInteger(("rebalance_startWeight_" + A)), 0) * 10000) + (parseIntValue(eC[value(indexOf(eR, A))]) * (eO + 1))), 1, 10000, HALFUP))])
1293+                let eR = getIntegerValue("rebalance_lastStepHeight")
1294+                let eS = getIntegerValue("rebalance_stepsInterval")
1295+                let eT = getIntegerValue("rebalance_stepsDone")
1296+                let eU = (eR + eS)
1297+                if ((eU > height))
1298+                    then throw("can't be done yet")
1299+                    else {
1300+                        let eG = split(getStringValue("rebalance_assetDeltas"), ",")
1301+                        let eV = getStringValue("tmp_rebalanceAssetIds")
1302+                        let eW = split(eV, ",")
1303+                        func cK (E,A) =                         (E ++ [toString(fraction(((valueOrElse(getInteger(("rebalance_startWeight_" + A)), 0) * 10000) + (parseIntValue(eG[value(indexOf(eW, A))]) * (eT + 1))), 1, 10000, HALFUP))])
12991304 
1300-                let eS = makeString({
1301-                    let ag = eR
1302-                    let ah = size(ag)
1303-                    let ai = nil
1304-                    func aI (ak,al) =                     if ((al >= ah))
1305-                        then ak
1306-                        else cF(ak, ag[al])
1305+                        let eX = makeString({
1306+                            let al = eW
1307+                            let am = size(al)
1308+                            let an = nil
1309+                            func aN (ap,aq) =                             if ((aq >= am))
1310+                                then ap
1311+                                else cK(ap, al[aq])
13071312 
1308-                    func aJ (ak,al) =                     if ((al >= ah))
1309-                        then ak
1310-                        else throw("List size exceeds 10")
1313+                            func aO (ap,aq) =                             if ((aq >= am))
1314+                                then ap
1315+                                else throw("List size exceeds 10")
13111316 
1312-                    aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1313-                    }, ",")
1314-                let eF = getBooleanValue("rebalance_newTokensAdded")
1315-                let eT = if (if (eF)
1316-                    then (eO == 0)
1317-                    else false)
1318-                    then invoke(this, "doRebalancingWithNewTokens", [eQ, eS, getStringValue("rebalance_newBaseTokenId")], nil)
1319-                    else invoke(this, "doRebalancing", [eS], nil)
1320-                if ((eT == eT))
1321-                    then {
1322-                        let eL = invoke(ac, "notifyPoolChange", nil, nil)
1323-                        if ((eL == eL))
1317+                            aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1318+                            }, ",")
1319+                        let eJ = getBooleanValue("rebalance_newTokensAdded")
1320+                        let eY = if (if (eJ)
1321+                            then (eT == 0)
1322+                            else false)
1323+                            then invoke(this, "doRebalancingWithNewTokens", [eV, eX, getStringValue("rebalance_newBaseTokenId")], nil)
1324+                            else invoke(this, "doRebalancing", [eX], nil)
1325+                        if ((eY == eY))
13241326                             then {
1325-                                let eU = ((eO + 1) >= getIntegerValue("rebalance_stepsAmount"))
1326-                                let eV = [BooleanEntry("rebalance_inProgress", !(eU)), IntegerEntry("rebalance_stepsDone", (eO + 1)), IntegerEntry("rebalance_lastStepHeight", height)]
1327-                                if ((eO == 0))
1328-                                    then (eV ++ [StringEntry("static_tokenIds", eQ)])
1329-                                    else if (eU)
1330-                                        then {
1331-                                            let eW = split(v("rebalance_removedAssets"), ",")
1332-                                            func eX (E,y) =                                             (E ++ [DeleteEntry((("static_" + y) + "_scale")), DeleteEntry((("static_" + y) + "_decimals")), DeleteEntry((("static_" + y) + "_weight")), DeleteEntry((("global_" + y) + "_balance")), DeleteEntry(("rebalance_attachedPayment_" + y))])
1327+                                let eZ = invoke(ae, "notifyPoolChange", nil, nil)
1328+                                if ((eZ == eZ))
1329+                                    then {
1330+                                        let fa = ((eT + 1) >= getIntegerValue("rebalance_stepsAmount"))
1331+                                        let fb = [BooleanEntry("rebalance_inProgress", !(fa)), IntegerEntry("rebalance_stepsDone", (eT + 1)), IntegerEntry("rebalance_lastStepHeight", height)]
1332+                                        if ((eT == 0))
1333+                                            then (fb ++ [StringEntry("static_tokenIds", eV)])
1334+                                            else if (fa)
1335+                                                then {
1336+                                                    let fc = split(v("rebalance_removedAssets"), ",")
1337+                                                    func fd (E,y) =                                                     (E ++ [DeleteEntry((("static_" + y) + "_scale")), DeleteEntry((("static_" + y) + "_decimals")), DeleteEntry((("static_" + y) + "_weight")), DeleteEntry((("global_" + y) + "_balance")), DeleteEntry(("rebalance_attachedPayment_" + y))])
13331338 
1334-                                            let eY = {
1335-                                                let ag = eW
1336-                                                let ah = size(ag)
1337-                                                let ai = nil
1338-                                                func bF (ak,al) =                                                 if ((al >= ah))
1339-                                                    then ak
1340-                                                    else eX(ak, ag[al])
1339+                                                    let fe = {
1340+                                                        let al = fc
1341+                                                        let am = size(al)
1342+                                                        let an = nil
1343+                                                        func bK (ap,aq) =                                                         if ((aq >= am))
1344+                                                            then ap
1345+                                                            else fd(ap, al[aq])
13411346 
1342-                                                func bG (ak,al) =                                                 if ((al >= ah))
1343-                                                    then ak
1344-                                                    else throw("List size exceeds 10")
1347+                                                        func bL (ap,aq) =                                                         if ((aq >= am))
1348+                                                            then ap
1349+                                                            else throw("List size exceeds 10")
13451350 
1346-                                                bG(bF(bF(bF(bF(bF(bF(bF(bF(bF(bF(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1347-                                                }
1348-                                            let eZ = split(v("rebalance_addedAssets"), ",")
1349-                                            func fa (E,y) =                                             (E ++ [DeleteEntry(("rebalance_attachedPayment_" + y))])
1351+                                                        bL(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1352+                                                        }
1353+                                                    let ff = split(v("rebalance_addedAssets"), ",")
1354+                                                    func fg (E,y) =                                                     (E ++ [DeleteEntry(("rebalance_attachedPayment_" + y))])
13501355 
1351-                                            let fb = {
1352-                                                let ag = eZ
1353-                                                let ah = size(ag)
1354-                                                let ai = nil
1355-                                                func cS (ak,al) =                                                 if ((al >= ah))
1356-                                                    then ak
1357-                                                    else fa(ak, ag[al])
1356+                                                    let fh = {
1357+                                                        let al = ff
1358+                                                        let am = size(al)
1359+                                                        let an = nil
1360+                                                        func cX (ap,aq) =                                                         if ((aq >= am))
1361+                                                            then ap
1362+                                                            else fg(ap, al[aq])
13581363 
1359-                                                func cT (ak,al) =                                                 if ((al >= ah))
1360-                                                    then ak
1361-                                                    else throw("List size exceeds 10")
1364+                                                        func cY (ap,aq) =                                                         if ((aq >= am))
1365+                                                            then ap
1366+                                                            else throw("List size exceeds 10")
13621367 
1363-                                                cT(cS(cS(cS(cS(cS(cS(cS(cS(cS(cS(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1364-                                                }
1365-                                            let fc = v("rebalance_assetIds")
1366-                                            let fd = {
1367-                                                let ag = split(fc, ",")
1368-                                                let ah = size(ag)
1369-                                                let ai = nil
1370-                                                func dn (ak,al) =                                                 if ((al >= ah))
1371-                                                    then ak
1372-                                                    else H(ak, ag[al])
1368+                                                        cY(cX(cX(cX(cX(cX(cX(cX(cX(cX(cX(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1369+                                                        }
1370+                                                    let fi = v("rebalance_assetIds")
1371+                                                    let fj = {
1372+                                                        let al = split(fi, ",")
1373+                                                        let am = size(al)
1374+                                                        let an = nil
1375+                                                        func ds (ap,aq) =                                                         if ((aq >= am))
1376+                                                            then ap
1377+                                                            else H(ap, al[aq])
13731378 
1374-                                                func do (ak,al) =                                                 if ((al >= ah))
1375-                                                    then ak
1376-                                                    else throw("List size exceeds 10")
1379+                                                        func dt (ap,aq) =                                                         if ((aq >= am))
1380+                                                            then ap
1381+                                                            else throw("List size exceeds 10")
13771382 
1378-                                                do(dn(dn(dn(dn(dn(dn(dn(dn(dn(dn(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1379-                                                }
1380-                                            (((eV ++ eY) ++ fb) ++ [StringEntry("static_tokenIds", fc), StringEntry("static_tokenWeights", makeString(fd, ",")), IntegerEntry("static_tokensAmount", size(split(fc, ",")))])
1381-                                            }
1382-                                        else {
1383-                                            let fc = v("rebalance_assetIds")
1384-                                            let fd = {
1385-                                                let ag = split(fc, ",")
1386-                                                let ah = size(ag)
1387-                                                let ai = nil
1388-                                                func bF (ak,al) =                                                 if ((al >= ah))
1389-                                                    then ak
1390-                                                    else H(ak, ag[al])
1383+                                                        dt(ds(ds(ds(ds(ds(ds(ds(ds(ds(ds(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1384+                                                        }
1385+                                                    let fk = invoke(ah, "notifyRebalancingDone", [eQ], nil)
1386+                                                    if ((fk == fk))
1387+                                                        then (((fb ++ fe) ++ fh) ++ [StringEntry("static_tokenIds", fi), StringEntry("static_tokenWeights", makeString(fj, ",")), IntegerEntry("static_tokensAmount", size(split(fi, ",")))])
1388+                                                        else throw("Strict value is not equal to itself.")
1389+                                                    }
1390+                                                else {
1391+                                                    let fi = v("rebalance_assetIds")
1392+                                                    let fj = {
1393+                                                        let al = split(fi, ",")
1394+                                                        let am = size(al)
1395+                                                        let an = nil
1396+                                                        func bK (ap,aq) =                                                         if ((aq >= am))
1397+                                                            then ap
1398+                                                            else H(ap, al[aq])
13911399 
1392-                                                func bG (ak,al) =                                                 if ((al >= ah))
1393-                                                    then ak
1394-                                                    else throw("List size exceeds 10")
1400+                                                        func bL (ap,aq) =                                                         if ((aq >= am))
1401+                                                            then ap
1402+                                                            else throw("List size exceeds 10")
13951403 
1396-                                                bG(bF(bF(bF(bF(bF(bF(bF(bF(bF(bF(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1397-                                                }
1398-                                            (eV ++ [StringEntry("static_tokenWeights", makeString(fd, ","))])
1399-                                            }
1404+                                                        bL(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1405+                                                        }
1406+                                                    (fb ++ [StringEntry("static_tokenWeights", makeString(fj, ","))])
1407+                                                    }
1408+                                        }
1409+                                    else throw("Strict value is not equal to itself.")
14001410                                 }
14011411                             else throw("Strict value is not equal to itself.")
14021412                         }
1403-                    else throw("Strict value is not equal to itself.")
14041413                 }
1405-        }
1414+    }
14061415 
14071416 
14081417 
1409-@Callable(cZ)
1410-func doRebalancing (db) = {
1411-    let di = split(db, ",")
1412-    let dj = {
1413-        let ag = di
1414-        let ah = size(ag)
1415-        let ai = 0
1416-        func aI (ak,al) =         if ((al >= ah))
1417-            then ak
1418-            else cx(ak, ag[al])
1418+@Callable(de)
1419+func doRebalancing (dg) = {
1420+    let dn = split(dg, ",")
1421+    let do = {
1422+        let al = dn
1423+        let am = size(al)
1424+        let an = 0
1425+        func aN (ap,aq) =         if ((aq >= am))
1426+            then ap
1427+            else cC(ap, al[aq])
14191428 
1420-        func aJ (ak,al) =         if ((al >= ah))
1421-            then ak
1429+        func aO (ap,aq) =         if ((aq >= am))
1430+            then ap
14221431             else throw("List size exceeds 10")
14231432 
1424-        aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1433+        aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
14251434         }
1426-    let dh = split(v("static_tokenIds"), ",")
1427-    if ((cZ.caller != this))
1435+    let dm = split(v("static_tokenIds"), ",")
1436+    if ((de.caller != this))
14281437         then throw("this call available only for admin")
14291438         else {
1430-            let fe = aE()
1431-            func aT (ff,y) =             {
1432-                let E = ff._1
1439+            let fl = aJ()
1440+            func aY (fm,y) =             {
1441+                let E = fm._1
14331442                 let A = x(y)
1434-                func bD (E,cy) =                 if ((cy == y))
1435-                    then value(indexOf(af, cy))
1443+                func bI (E,cD) =                 if ((cD == y))
1444+                    then value(indexOf(ak, cD))
14361445                     else E
14371446 
1438-                let ds = {
1439-                    let ag = af
1440-                    let ah = size(ag)
1441-                    let ai = 1
1442-                    func bF (ak,al) =                     if ((al >= ah))
1443-                        then ak
1444-                        else bD(ak, ag[al])
1447+                let dx = {
1448+                    let al = ak
1449+                    let am = size(al)
1450+                    let an = 1
1451+                    func bK (ap,aq) =                     if ((aq >= am))
1452+                        then ap
1453+                        else bI(ap, al[aq])
14451454 
1446-                    func bG (ak,al) =                     if ((al >= ah))
1447-                        then ak
1455+                    func bL (ap,aq) =                     if ((aq >= am))
1456+                        then ap
14481457                         else throw("List size exceeds 10")
14491458 
1450-                    bG(bF(bF(bF(bF(bF(bF(bF(bF(bF(bF(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1459+                    bL(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
14511460                     }
1452-                let fg = q((("global_" + A) + "_balance"))
1453-                let fh = if ((ff._2 == "new"))
1454-                    then parseIntValue(di[ds])
1461+                let fn = q((("global_" + A) + "_balance"))
1462+                let fo = if ((fm._2 == "new"))
1463+                    then parseIntValue(dn[dx])
14551464                     else q((("static_" + A) + "_weight"))
1456-                $Tuple2(fraction(E, pow(fg, aq[ds], fh, d, 8, FLOOR), f), ff._2)
1465+                $Tuple2(fraction(E, pow(fn, av[dx], fo, d, 8, FLOOR), f), fm._2)
14571466                 }
14581467 
1459-            let fi = (            let ag = af
1460-            let ah = size(ag)
1461-            let ai = $Tuple2(j, "new")
1462-            func bF (ak,al) =             if ((al >= ah))
1463-                then ak
1464-                else aT(ak, ag[al])
1468+            let fp = (            let al = ak
1469+            let am = size(al)
1470+            let an = $Tuple2(j, "new")
1471+            func bK (ap,aq) =             if ((aq >= am))
1472+                then ap
1473+                else aY(ap, al[aq])
14651474 
1466-            func bG (ak,al) =             if ((al >= ah))
1467-                then ak
1475+            func bL (ap,aq) =             if ((aq >= am))
1476+                then ap
14681477                 else throw("List size exceeds 10")
14691478 
1470-            bG(bF(bF(bF(bF(bF(bF(bF(bF(bF(bF(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10))._1
1471-            let fj = (            let ag = af
1472-            let ah = size(ag)
1473-            let ai = $Tuple2(j, "old")
1474-            func cS (ak,al) =             if ((al >= ah))
1475-                then ak
1476-                else aT(ak, ag[al])
1479+            bL(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10))._1
1480+            let fq = (            let al = ak
1481+            let am = size(al)
1482+            let an = $Tuple2(j, "old")
1483+            func cX (ap,aq) =             if ((aq >= am))
1484+                then ap
1485+                else aY(ap, al[aq])
14771486 
1478-            func cT (ak,al) =             if ((al >= ah))
1479-                then ak
1487+            func cY (ap,aq) =             if ((aq >= am))
1488+                then ap
14801489                 else throw("List size exceeds 10")
14811490 
1482-            cT(cS(cS(cS(cS(cS(cS(cS(cS(cS(cS(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10))._1
1483-            let fk = fraction(fe, fi, fj)
1484-            func dk (E,dl) =             if ((dl >= size(di)))
1491+            cY(cX(cX(cX(cX(cX(cX(cX(cX(cX(cX(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10))._1
1492+            let fr = fraction(fl, fp, fq)
1493+            func dp (E,dq) =             if ((dq >= size(dn)))
14851494                 then E
1486-                else (E ++ [IntegerEntry((("static_" + dh[dl]) + "_weight"), value(parseInt(di[dl])))])
1495+                else (E ++ [IntegerEntry((("static_" + dm[dq]) + "_weight"), value(parseInt(dn[dq])))])
14871496 
14881497             ({
1489-                let ag = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
1490-                let ah = size(ag)
1491-                let ai = nil
1492-                func dn (ak,al) =                 if ((al >= ah))
1493-                    then ak
1494-                    else dk(ak, ag[al])
1498+                let al = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
1499+                let am = size(al)
1500+                let an = nil
1501+                func ds (ap,aq) =                 if ((aq >= am))
1502+                    then ap
1503+                    else dp(ap, al[aq])
14951504 
1496-                func do (ak,al) =                 if ((al >= ah))
1497-                    then ak
1505+                func dt (ap,aq) =                 if ((aq >= am))
1506+                    then ap
14981507                     else throw("List size exceeds 10")
14991508 
1500-                do(dn(dn(dn(dn(dn(dn(dn(dn(dn(dn(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1501-                } ++ [IntegerEntry("static_KMult", fk)])
1509+                dt(ds(ds(ds(ds(ds(ds(ds(ds(ds(ds(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1510+                } ++ [IntegerEntry("static_KMult", fr)])
15021511             }
15031512     }
15041513 
15051514 
15061515 
1507-@Callable(cZ)
1508-func doRebalancingWithNewTokens (da,db,dc) = {
1509-    let eo = split(db, ",")
1510-    let fl = split(v("static_tokenIds"), ",")
1511-    let ep = split(da, ",")
1512-    let eR = {
1513-        let ag = ep
1514-        let ah = size(ag)
1515-        let ai = nil
1516-        func aI (ak,al) =         if ((al >= ah))
1517-            then ak
1518-            else D(ak, ag[al])
1516+@Callable(de)
1517+func doRebalancingWithNewTokens (df,dg,dh) = {
1518+    let es = split(dg, ",")
1519+    let fs = split(v("static_tokenIds"), ",")
1520+    let et = split(df, ",")
1521+    let eW = {
1522+        let al = et
1523+        let am = size(al)
1524+        let an = nil
1525+        func aN (ap,aq) =         if ((aq >= am))
1526+            then ap
1527+            else D(ap, al[aq])
15191528 
1520-        func aJ (ak,al) =         if ((al >= ah))
1521-            then ak
1529+        func aO (ap,aq) =         if ((aq >= am))
1530+            then ap
15221531             else throw("List size exceeds 10")
15231532 
1524-        aJ(aI(aI(aI(aI(aI(aI(aI(aI(aI(aI(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1533+        aO(aN(aN(aN(aN(aN(aN(aN(aN(aN(aN(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
15251534         }
1526-    let bg = {
1527-        let ag = ep
1528-        let ah = size(ag)
1529-        let ai = ""
1530-        func bF (ak,al) =         if ((al >= ah))
1531-            then ak
1532-            else cz(ak, ag[al])
1535+    let bl = {
1536+        let al = et
1537+        let am = size(al)
1538+        let an = ""
1539+        func bK (ap,aq) =         if ((aq >= am))
1540+            then ap
1541+            else cE(ap, al[aq])
15331542 
1534-        func bG (ak,al) =         if ((al >= ah))
1535-            then ak
1543+        func bL (ap,aq) =         if ((aq >= am))
1544+            then ap
15361545             else throw("List size exceeds 10")
15371546 
1538-        bG(bF(bF(bF(bF(bF(bF(bF(bF(bF(bF(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1547+        bL(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
15391548         }
1540-    let eu = split(v("rebalance_addedAssets"), ",")
1541-    func fm (y) =     valueOrElse(getInteger(("rebalance_attachedPayment_" + x(y))), 0)
1549+    let ey = split(v("rebalance_addedAssets"), ",")
1550+    func ft (y) =     valueOrElse(getInteger(("rebalance_attachedPayment_" + x(y))), 0)
15421551 
1543-    func fn (cw,y) =     (cw ++ [fm(y)])
1552+    func fu (cB,y) =     (cB ++ [ft(y)])
15441553 
1545-    let fo = {
1546-        let ag = eR
1547-        let ah = size(ag)
1548-        let ai = nil
1549-        func cS (ak,al) =         if ((al >= ah))
1550-            then ak
1551-            else fn(ak, ag[al])
1554+    let fv = {
1555+        let al = eW
1556+        let am = size(al)
1557+        let an = nil
1558+        func cX (ap,aq) =         if ((aq >= am))
1559+            then ap
1560+            else fu(ap, al[aq])
15521561 
1553-        func cT (ak,al) =         if ((al >= ah))
1554-            then ak
1562+        func cY (ap,aq) =         if ((aq >= am))
1563+            then ap
15551564             else throw("List size exceeds 10")
15561565 
1557-        cT(cS(cS(cS(cS(cS(cS(cS(cS(cS(cS(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1566+        cY(cX(cX(cX(cX(cX(cX(cX(cX(cX(cX(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
15581567         }
1559-    if ((cZ.caller != this))
1560-        then throw(("this call available only for admin, " + toString(cZ.caller)))
1568+    if ((de.caller != this))
1569+        then throw(("this call available only for admin, " + toString(de.caller)))
15611570         else {
1562-            let fe = aE()
1563-            let fj = aK()
1564-            func fp (ff,y) =             {
1565-                func fq (E,cy) =                 if ((cy == y))
1566-                    then value(indexOf(eR, cy))
1571+            let fl = aJ()
1572+            let fq = aP()
1573+            func fw (fm,y) =             {
1574+                func fx (E,cD) =                 if ((cD == y))
1575+                    then value(indexOf(eW, cD))
15671576                     else E
15681577 
1569-                let fr = ff
1578+                let fy = fm
15701579                 let A = x(y)
1571-                let fs = {
1572-                    let ag = eR
1573-                    let ah = size(ag)
1574-                    let ai = 1
1575-                    func dn (ak,al) =                     if ((al >= ah))
1576-                        then ak
1577-                        else fq(ak, ag[al])
1580+                let fz = {
1581+                    let al = eW
1582+                    let am = size(al)
1583+                    let an = 1
1584+                    func ds (ap,aq) =                     if ((aq >= am))
1585+                        then ap
1586+                        else fx(ap, al[aq])
15781587 
1579-                    func do (ak,al) =                     if ((al >= ah))
1580-                        then ak
1588+                    func dt (ap,aq) =                     if ((aq >= am))
1589+                        then ap
15811590                         else throw("List size exceeds 10")
15821591 
1583-                    do(dn(dn(dn(dn(dn(dn(dn(dn(dn(dn(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1592+                    dt(ds(ds(ds(ds(ds(ds(ds(ds(ds(ds(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
15841593                     }
1585-                let fh = parseIntValue(eo[fs])
1586-                let ft = q((("global_" + A) + "_balance"))
1587-                let fu = fo[fs]
1588-                let fg = (ft + fu)
1589-                let dm = if ((y == unit))
1594+                let fo = parseIntValue(es[fz])
1595+                let fA = q((("global_" + A) + "_balance"))
1596+                let fB = fv[fz]
1597+                let fn = (fA + fB)
1598+                let dr = if ((y == unit))
15901599                     then 8
15911600                     else value(assetInfo(value(y))).decimals
1592-                if ((0 >= fg))
1601+                if ((0 >= fn))
15931602                     then throw(("you need to attach all new assets in payment. this asset is missed: " + A))
1594-                    else fraction(fr, pow(fg, dm, fh, d, 8, FLOOR), f)
1603+                    else fraction(fy, pow(fn, dr, fo, d, 8, FLOOR), f)
15951604                 }
15961605 
1597-            let fi = {
1598-                let ag = eR
1599-                let ah = size(ag)
1600-                let ai = j
1601-                func dn (ak,al) =                 if ((al >= ah))
1602-                    then ak
1603-                    else fp(ak, ag[al])
1606+            let fp = {
1607+                let al = eW
1608+                let am = size(al)
1609+                let an = j
1610+                func ds (ap,aq) =                 if ((aq >= am))
1611+                    then ap
1612+                    else fw(ap, al[aq])
16041613 
1605-                func do (ak,al) =                 if ((al >= ah))
1606-                    then ak
1614+                func dt (ap,aq) =                 if ((aq >= am))
1615+                    then ap
16071616                     else throw("List size exceeds 10")
16081617 
1609-                do(dn(dn(dn(dn(dn(dn(dn(dn(dn(dn(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1618+                dt(ds(ds(ds(ds(ds(ds(ds(ds(ds(ds(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
16101619                 }
1611-            let fk = fraction(fe, fi, fj)
1612-            func dk (E,dl) =             {
1613-                let A = ep[dl]
1614-                let y = eR[dl]
1615-                let dm = if ((y == unit))
1620+            let fr = fraction(fl, fp, fq)
1621+            func dp (E,dq) =             {
1622+                let A = et[dq]
1623+                let y = eW[dq]
1624+                let dr = if ((y == unit))
16161625                     then 8
16171626                     else value(assetInfo(value(y))).decimals
1618-                let fv = if ((indexOf(eu, A) != unit))
1619-                    then [IntegerEntry((("global_" + A) + "_balance"), fo[dl]), IntegerEntry((("static_" + A) + "_scale"), pow(10, 0, dm, 0, 0, DOWN)), IntegerEntry((("static_" + A) + "_decimals"), dm)]
1627+                let fC = if ((indexOf(ey, A) != unit))
1628+                    then [IntegerEntry((("global_" + A) + "_balance"), fv[dq]), IntegerEntry((("static_" + A) + "_scale"), pow(10, 0, dr, 0, 0, DOWN)), IntegerEntry((("static_" + A) + "_decimals"), dr)]
16201629                     else nil
1621-                if ((dl >= size(eo)))
1630+                if ((dq >= size(es)))
16221631                     then E
1623-                    else ((E ++ [IntegerEntry((("static_" + A) + "_weight"), value(parseInt(eo[dl])))]) ++ fv)
1632+                    else ((E ++ [IntegerEntry((("static_" + A) + "_weight"), value(parseInt(es[dq])))]) ++ fC)
16241633                 }
16251634 
16261635             ({
1627-                let ag = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
1628-                let ah = size(ag)
1629-                let ai = nil
1630-                func eD (ak,al) =                 if ((al >= ah))
1631-                    then ak
1632-                    else dk(ak, ag[al])
1636+                let al = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
1637+                let am = size(al)
1638+                let an = nil
1639+                func eH (ap,aq) =                 if ((aq >= am))
1640+                    then ap
1641+                    else dp(ap, al[aq])
16331642 
1634-                func eE (ak,al) =                 if ((al >= ah))
1635-                    then ak
1643+                func eI (ap,aq) =                 if ((aq >= am))
1644+                    then ap
16361645                     else throw("List size exceeds 10")
16371646 
1638-                eE(eD(eD(eD(eD(eD(eD(eD(eD(eD(eD(ai, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1639-                } ++ [StringEntry("static_tokenIds", da), StringEntry("static_feeToken", bg), StringEntry("static_tokenWeights", db), IntegerEntry("static_tokensAmount", size(eR)), IntegerEntry("static_KMult", fk)])
1647+                eI(eH(eH(eH(eH(eH(eH(eH(eH(eH(eH(an, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1648+                } ++ [StringEntry("static_tokenIds", df), StringEntry("static_feeToken", bl), StringEntry("static_tokenWeights", dg), IntegerEntry("static_tokensAmount", size(eW)), IntegerEntry("static_KMult", fr)])
16401649             }
16411650     }
16421651 
16431652 
1644-@Verifier(fw)
1645-func fx () = if (sigVerify(fw.bodyBytes, fw.proofs[0], fw.senderPublicKey))
1653+@Verifier(fD)
1654+func fE () = if (if ((valueOrElse(getInteger("global_wasPreInited"), 0) == 0))
1655+    then if (sigVerify(fD.bodyBytes, fD.proofs[0], fD.senderPublicKey))
1656+        then true
1657+        else sigVerify(fD.bodyBytes, fD.proofs[0], aa)
1658+    else false)
16461659     then true
1647-    else sigVerify(fw.bodyBytes, fw.proofs[0], Y)
1660+    else {
1661+        let s = fD
1662+        if ($isInstanceOf(s, "SetScriptTransaction"))
1663+            then {
1664+                let fD = s
1665+                let fF = value(fD.script)
1666+                let fG = toBase58String(sha256(fF))
1667+                if (sigVerify(fD.bodyBytes, fD.proofs[0], aa))
1668+                    then (valueOrElse(getInteger(ai, ("approvedScript_" + fG)), 0) > height)
1669+                    else false
1670+                }
1671+            else if (sigVerify(fD.bodyBytes, fD.proofs[0], aa))
1672+                then (valueOrElse(getInteger(ai, ("approvedTx_" + toBase58String(fD.id))), 0) > 0)
1673+                else false
1674+        }
16481675 
github/deemru/w8io/3ef1775 
724.35 ms ◑