tx · DCFYBRJjig5dgHv27KYVfvuN9wBKLx6GNXvdj9We582b

3N3c8hF3E1qiSZ27uH3XZvtWSso9QFckZUb:  -0.03200000 Waves

2024.08.06 16:54 [3227011] smart account 3N3c8hF3E1qiSZ27uH3XZvtWSso9QFckZUb > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "DCFYBRJjig5dgHv27KYVfvuN9wBKLx6GNXvdj9We582b",
    "fee": 3200000,
    "feeAssetId": null,
    "timestamp": 1722952494284,
    "version": 1,
    "sender": "3N3c8hF3E1qiSZ27uH3XZvtWSso9QFckZUb",
    "senderPublicKey": "9Dkh2UiuYRqFTQrAXgJJbJuG3Q6VDPhiYHrsdfQx42Zx",
    "proofs": [
        "2zw89CzBXtyt3k3QmQ7sAZ8dpfHG5xUcq3dtXwkRbHaqHZ4BXVJFPoh2dx2hvn2dG29D8C4YCQJEo6hHw5wgoVMx"
    ],
    "script": "base64:BwJhCAISAwoBCBIECgICGBIECgICGBIECgICGBIECgICGBIECgICGBIECgICGBIECgICGBIECgICGBIECgICGBIECgICGBIECgICGBIECgICGBIECgICGBIECgICGBIECgICGGAACXNlcGFyYXRvcgICX18AB2NoYWluSWQJAMkBAgkAygECCAUEdGhpcwVieXRlcwABAAEACGNoYWluSWRXAQFXABBjb250cmFjdEZpbGVuYW1lAhdmdXR1cmVzX2NhbGN1bGF0b3IucmlkZQAFbXVsdDgAgMLXLwAMbXVsdDE4QmlnSW50CQC2AgEAgICQu7rWrfANAA13YXZlc0RlY2ltYWxzAAgADHVzZHREZWNpbWFscwAGAAt3YXZlc1N0cmluZwIFV0FWRVMADXF1ZXVlSXRlbVNpemUAIAAEYmlnMAkAtgIBAAAACklOREVYX0xJU1QJAMwIAgAACQDMCAIAAQkAzAgCAAIJAMwIAgADCQDMCAIABAkAzAgCAAUJAMwIAgAGCQDMCAIABwkAzAgCAAgJAMwIAgAJCQDMCAIACgkAzAgCAAsJAMwIAgAMCQDMCAIADQkAzAgCAA4JAMwIAgAPCQDMCAIAEAkAzAgCABEJAMwIAgASCQDMCAIAEwUDbmlsAAlrTXVsdGlzaWcCDCVzX19tdWx0aXNpZwEHa1N0YXR1cwIEZGFwcAR0eElkCQC5CQIJAMwIAgIKJXNfX3N0YXR1cwkAzAgCBQRkYXBwCQDMCAIFBHR4SWQFA25pbAUJc2VwYXJhdG9yAAlrU2h1dGRvd24CDCVzX19zaHV0ZG93bgALa1B1YmxpY0tleXMCDiVzX19wdWJsaWNLZXlzABFrTWF0Y2hlclB1YmxpY0tleQIUJXNfX21hdGNoZXJQdWJsaWNLZXkBBXRvWDE4AgdvcmlnVmFsDW9yaWdTY2FsZU11bHQJALwCAwkAtgIBBQdvcmlnVmFsBQxtdWx0MThCaWdJbnQJALYCAQUNb3JpZ1NjYWxlTXVsdAEHZnJvbVgxOAIDdmFsD3Jlc3VsdFNjYWxlTXVsdAkAoAMBCQC8AgMFA3ZhbAkAtgIBBQ9yZXN1bHRTY2FsZU11bHQFDG11bHQxOEJpZ0ludAEPdmFsaWRhdGVBZGRyZXNzAQdhZGRyZXNzCQEJaXNEZWZpbmVkAQkApggBBQdhZGRyZXNzAQd3cmFwRXJyAQFzCQCsAgIJAKwCAgUQY29udHJhY3RGaWxlbmFtZQICOiAFAXMBCHRocm93RXJyAQFzCQACAQkBB3dyYXBFcnIBBQFzAQ5lbnN1cmVQb3NpdGl2ZQIBdgFzAwkAZwIFAXYAAAUBdgkBCHRocm93RXJyAQkArAICBQFzAhkgdmFsdWUgc2hvdWxkIGJlIHBvc2l0aXZlAQxwYXJzZUFzc2V0SWQBBWlucHV0AwkAAAIFBWlucHV0BQt3YXZlc1N0cmluZwUEdW5pdAkA2QQBBQVpbnB1dAEPYXNzZXRJZFRvU3RyaW5nAQVpbnB1dAMJAAACBQVpbnB1dAUEdW5pdAULd2F2ZXNTdHJpbmcJANgEAQkBBXZhbHVlAQUFaW5wdXQBEmdldEFzc2V0SW5mb09yRmFpbAEHYXNzZXRJZAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQDsBwEFB2Fzc2V0SWQJAQd3cmFwRXJyAQISaW52YWxpZCBhc3NldCBpbmZvARZnZXRBc3NldERlY2ltYWxzT3JGYWlsAQdhc3NldElkBAckbWF0Y2gwBQdhc3NldElkAwkAAQIFByRtYXRjaDACBFVuaXQFDXdhdmVzRGVjaW1hbHMDCQABAgUHJG1hdGNoMAIKQnl0ZVZlY3RvcgQHYXNzZXRJZAUHJG1hdGNoMAgJARJnZXRBc3NldEluZm9PckZhaWwBBQdhc3NldElkCGRlY2ltYWxzCQACAQILTWF0Y2ggZXJyb3IBD2dldEFzc2V0QmFsYW5jZQIHYXNzZXRJZAdhZGRyZXNzBAckbWF0Y2gwBQdhc3NldElkAwkAAQIFByRtYXRjaDACBFVuaXQICQDvBwEFB2FkZHJlc3MJYXZhaWxhYmxlAwkAAQIFByRtYXRjaDACCkJ5dGVWZWN0b3IEB2Fzc2V0SWQFByRtYXRjaDAJAPAHAgUHYWRkcmVzcwUHYXNzZXRJZAkAAgECC01hdGNoIGVycm9yAQVwb3cxMAEBbgkAbAYACgAABQFuAAAAAAUERE9XTgENcG93MTBEZWNpbWFscwEHYXNzZXRJZAkBBXBvdzEwAQkBFmdldEFzc2V0RGVjaW1hbHNPckZhaWwBBQdhc3NldElkAA9rRmFjdG9yeUFkZHJlc3MCEiVzX19mYWN0b3J5QWRkcmVzcwAUZmFjdG9yeUFkZHJlc3NPcHRpb24EByRtYXRjaDAJAJ0IAgUEdGhpcwUPa0ZhY3RvcnlBZGRyZXNzAwkAAQIFByRtYXRjaDACBlN0cmluZwQBcwUHJG1hdGNoMAkApggBBQFzAwkAAQIFByRtYXRjaDACBFVuaXQFBHVuaXQJAAIBAgtNYXRjaCBlcnJvcgAOZmFjdG9yeUFkZHJlc3MJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgUUZmFjdG9yeUFkZHJlc3NPcHRpb24JAQd3cmFwRXJyAQIXaW52YWxpZCBmYWN0b3J5IGFkZHJlc3MADGtVc2R0QXNzZXRJZAIPJXNfX3VzZHRBc3NldElkABF1c2R0QXNzZXRJZE9wdGlvbgQHJG1hdGNoMAkAnQgCBQ5mYWN0b3J5QWRkcmVzcwUMa1VzZHRBc3NldElkAwkAAQIFByRtYXRjaDACBlN0cmluZwQBcwUHJG1hdGNoMAkBDHBhcnNlQXNzZXRJZAEFAXMDCQABAgUHJG1hdGNoMAIEVW5pdAUEdW5pdAkAAgECC01hdGNoIGVycm9yAAt1c2R0QXNzZXRJZAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCBRF1c2R0QXNzZXRJZE9wdGlvbgkBB3dyYXBFcnIBAhVpbnZhbGlkIHVzZHQgYXNzZXQgaWQADmtQcmljZXNBZGRyZXNzAhUlc19fY2FsY3VsYXRvckFkZHJlc3MACHNodXRkb3duCQELdmFsdWVPckVsc2UCCQCbCAIFDmZhY3RvcnlBZGRyZXNzBQlrU2h1dGRvd24HAQttdXN0QWRkcmVzcwIGY2FsbGVyB2FkZHJlc3MDCQAAAgUGY2FsbGVyBQdhZGRyZXNzBgkBCHRocm93RXJyAQIRcGVybWlzc2lvbiBkZW5pZWQBCG11c3RUaGlzAQZjYWxsZXIJAQttdXN0QWRkcmVzcwIFBmNhbGxlcgUEdGhpcwELbXVzdEZhY3RvcnkBBmNhbGxlcgkBC211c3RBZGRyZXNzAgUGY2FsbGVyBQ5mYWN0b3J5QWRkcmVzcwEJbXVzdEFkbWluAQ9jYWxsZXJQdWJsaWNLZXkECG11bHRpc2lnCQERQGV4dHJOYXRpdmUoMTA2MikBCQERQGV4dHJOYXRpdmUoMTA1MykCBQ5mYWN0b3J5QWRkcmVzcwUJa011bHRpc2lnBA5wdWJsaWNLZXlzTGlzdAkAtQkCCQERQGV4dHJOYXRpdmUoMTA1MykCBQhtdWx0aXNpZwULa1B1YmxpY0tleXMFCXNlcGFyYXRvcgMJAQ9jb250YWluc0VsZW1lbnQCBQ5wdWJsaWNLZXlzTGlzdAkA2AQBBQ9jYWxsZXJQdWJsaWNLZXkGCQEIdGhyb3dFcnIBAgtub3QgYWxsb3dlZAAOa0FjY291bnRTY3JpcHQCESVzX19hY2NvdW50U2NyaXB0AQ1hY2NvdW50U2NyaXB0AAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCcCAIFDmZhY3RvcnlBZGRyZXNzBQ5rQWNjb3VudFNjcmlwdAkBB3dyYXBFcnIBAhlhY2NvdW50IHNjcmlwdCBpcyBub3Qgc2V0AA1rUmV3YXJkQW1vdW50AhAlc19fcmV3YXJkQW1vdW50AQxyZXdhcmRBbW91bnQACQETdmFsdWVPckVycm9yTWVzc2FnZQIJAJoIAgUOZmFjdG9yeUFkZHJlc3MFDWtSZXdhcmRBbW91bnQJAQd3cmFwRXJyAQIYcmV3YXJkIGFtb3VudCBpcyBub3Qgc2V0AA5rQWNjb3VudHNMaW1pdAIRJXNfX2FjY291bnRzTGltaXQAFGFjY291bnRzTGltaXREZWZhdWx0ABQBDWFjY291bnRzTGltaXQACQELdmFsdWVPckVsc2UCCQCaCAIFDmZhY3RvcnlBZGRyZXNzBQ5rQWNjb3VudHNMaW1pdAUUYWNjb3VudHNMaW1pdERlZmF1bHQBCmtEZXBvc2l0ZWQBDmFjY291bnRBZGRyZXNzCQC5CQIJAMwIAgIEJXMlcwkAzAgCAglkZXBvc2l0ZWQJAMwIAgkApQgBBQ5hY2NvdW50QWRkcmVzcwUDbmlsBQlzZXBhcmF0b3IBD2RlcG9zaXRlZE9wdGlvbgEOYWNjb3VudEFkZHJlc3MJAJoIAgUOZmFjdG9yeUFkZHJlc3MJAQprRGVwb3NpdGVkAQUOYWNjb3VudEFkZHJlc3MBB2tDcmVkaXQCDmFjY291bnRBZGRyZXNzB2Fzc2V0SWQJALkJAgkAzAgCAgYlcyVzJXMJAMwIAgIGY3JlZGl0CQDMCAIJAKUIAQUOYWNjb3VudEFkZHJlc3MJAMwIAgkBD2Fzc2V0SWRUb1N0cmluZwEFB2Fzc2V0SWQFA25pbAUJc2VwYXJhdG9yAQxjcmVkaXRPcHRpb24CDmFjY291bnRBZGRyZXNzB2Fzc2V0SWQJAJoIAgUOZmFjdG9yeUFkZHJlc3MJAQdrQ3JlZGl0AgUOYWNjb3VudEFkZHJlc3MFB2Fzc2V0SWQBCWtMZXZlcmFnZQEOYWNjb3VudEFkZHJlc3MJALkJAgkAzAgCAgQlcyVzCQDMCAICCGxldmVyYWdlCQDMCAIJAKUIAQUOYWNjb3VudEFkZHJlc3MFA25pbAUJc2VwYXJhdG9yARBrUmVxdWVzdExldmVyYWdlAQlyZXF1ZXN0SWQJALkJAgkAzAgCAgQlcyVzCQDMCAICD3JlcXVlc3RMZXZlcmFnZQkAzAgCCQDYBAEFCXJlcXVlc3RJZAUDbmlsBQlzZXBhcmF0b3IBEWtTeW50aGV0aWNBc3NldElkAQtiYXNlQXNzZXRJZAkAuQkCCQDMCAICBCVzJXMJAMwIAgIQc3ludGhldGljQXNzZXRJZAkAzAgCCQEPYXNzZXRJZFRvU3RyaW5nAQULYmFzZUFzc2V0SWQFA25pbAUJc2VwYXJhdG9yAQxrQmFzZUFzc2V0SWQBEHN5bnRoZXRpY0Fzc2V0SWQJALkJAgkAzAgCAgQlcyVzCQDMCAICC2Jhc2VBc3NldElkCQDMCAIJAQ9hc3NldElkVG9TdHJpbmcBBRBzeW50aGV0aWNBc3NldElkBQNuaWwFCXNlcGFyYXRvcgAUUkVRVUVTVF9TVEFUVVNfRU1QVFkAAAAUUkVRVUVTVF9TVEFUVVNfUkVBRFkAAQEOa1JlcXVlc3RTdGF0dXMBCXJlcXVlc3RJZAkAuQkCCQDMCAICBCVzJXMJAMwIAgkA2AQBBQlyZXF1ZXN0SWQJAMwIAgIGc3RhdHVzBQNuaWwFCXNlcGFyYXRvcgEYa0FjY291bnRDcmVhdG9yUHVibGljS2V5AQ5hY2NvdW50QWRkcmVzcwkAuQkCCQDMCAICBCVzJXMJAMwIAgkApQgBBQ5hY2NvdW50QWRkcmVzcwkAzAgCAhBjcmVhdG9yUHVibGljS2V5BQNuaWwFCXNlcGFyYXRvcgEWa1JlcXVlc3RPd25lclB1YmxpY0tleQEJcmVxdWVzdElkCQC5CQIJAMwIAgIEJXMlcwkAzAgCCQDYBAEFCXJlcXVlc3RJZAkAzAgCAg5vd25lclB1YmxpY0tleQUDbmlsBQlzZXBhcmF0b3IBFWtSZXF1ZXN0QW1vdW50QXNzZXRJZAEJcmVxdWVzdElkCQC5CQIJAMwIAgIEJXMlcwkAzAgCCQDYBAEFCXJlcXVlc3RJZAkAzAgCAg1hbW91bnRBc3NldElkBQNuaWwFCXNlcGFyYXRvcgEUa1JlcXVlc3RQcmljZUFzc2V0SWQBCXJlcXVlc3RJZAkAuQkCCQDMCAICBCVzJXMJAMwIAgkA2AQBBQlyZXF1ZXN0SWQJAMwIAgIMcHJpY2VBc3NldElkBQNuaWwFCXNlcGFyYXRvcgEca1JlcXVlc3RJZFRvQWNjb3VudFB1YmxpY0tleQEJcmVxdWVzdElkCQC5CQIJAMwIAgIEJXMlcwkAzAgCCQDYBAEFCXJlcXVlc3RJZAkAzAgCAhtyZXF1ZXN0SWRUb0FjY291bnRQdWJsaWNLZXkFA25pbAUJc2VwYXJhdG9yARprQWNjb3VudEFkZHJlc3NUb1JlcXVlc3RJZAEOYWNjb3VudEFkZHJlc3MJALkJAgkAzAgCAgQlcyVzCQDMCAIJAKUIAQUOYWNjb3VudEFkZHJlc3MJAMwIAgIZYWNjb3VudEFkZHJlc3NUb1JlcXVlc3RJZAUDbmlsBQlzZXBhcmF0b3IBDmtSZXF1ZXN0c1F1ZXVlAAkAuQkCCQDMCAICAiVzCQDMCAICDXJlcXVlc3RzUXVldWUFA25pbAUJc2VwYXJhdG9yAQ1yZXF1ZXN0c1F1ZXVlAAkBC3ZhbHVlT3JFbHNlAgkAnAgCBQ5mYWN0b3J5QWRkcmVzcwkBDmtSZXF1ZXN0c1F1ZXVlAAEAAQ5rQWNjb3VudHNRdWV1ZQAJALkJAgkAzAgCAgIlcwkAzAgCAg1hY2NvdW50c1F1ZXVlBQNuaWwFCXNlcGFyYXRvcgENYWNjb3VudHNRdWV1ZQAJAQt2YWx1ZU9yRWxzZQIJAJwIAgUOZmFjdG9yeUFkZHJlc3MJAQ5rQWNjb3VudHNRdWV1ZQABAAEQa1JlcXVlc3RzQnlPd25lcgEMb3duZXJBZGRyZXNzCQC5CQIJAMwIAgIEJXMlcwkAzAgCAghyZXF1ZXN0cwkAzAgCCQClCAEFDG93bmVyQWRkcmVzcwUDbmlsBQlzZXBhcmF0b3IBD3JlcXVlc3RzQnlPd25lcgEMb3duZXJBZGRyZXNzCQELdmFsdWVPckVsc2UCCQCcCAIFDmZhY3RvcnlBZGRyZXNzCQEQa1JlcXVlc3RzQnlPd25lcgEFDG93bmVyQWRkcmVzcwEAAQxrUGFpckFsbG93ZWQCDWFtb3VudEFzc2V0SWQMcHJpY2VBc3NldElkCQC5CQIJAMwIAgIGJXMlcyVzCQDMCAIJAQ9hc3NldElkVG9TdHJpbmcBBQ1hbW91bnRBc3NldElkCQDMCAIJAQ9hc3NldElkVG9TdHJpbmcBBQxwcmljZUFzc2V0SWQJAMwIAgILcGFpckFsbG93ZWQFA25pbAUJc2VwYXJhdG9yAQtwYWlyQWxsb3dlZAINYW1vdW50QXNzZXRJZAxwcmljZUFzc2V0SWQJAQt2YWx1ZU9yRWxzZQIJAJsIAgUOZmFjdG9yeUFkZHJlc3MJAQxrUGFpckFsbG93ZWQCBQ1hbW91bnRBc3NldElkBQxwcmljZUFzc2V0SWQHAQZrUHJpY2UBB2Fzc2V0SWQJALkJAgkAzAgCAgIlcwkAzAgCCQEPYXNzZXRJZFRvU3RyaW5nAQUHYXNzZXRJZAUDbmlsBQlzZXBhcmF0b3IBEmtQYWlyUHJpY2VzTGlzdEtleQINYW1vdW50QXNzZXRJZAxwcmljZUFzc2V0SWQJALkJAgkAzAgCAgYlcyVzJXMJAMwIAgkBD2Fzc2V0SWRUb1N0cmluZwEFDWFtb3VudEFzc2V0SWQJAMwIAgkBD2Fzc2V0SWRUb1N0cmluZwEFDHByaWNlQXNzZXRJZAkAzAgCAhFwYWlyU2V0dGluZ1ByaWNlcwUDbmlsBQlzZXBhcmF0b3IBEWdldFBhaXJQcmljZXNMaXN0Ag1hbW91bnRBc3NldElkDHByaWNlQXNzZXRJZAQHJG1hdGNoMAkAnQgCBQ5mYWN0b3J5QWRkcmVzcwkBEmtQYWlyUHJpY2VzTGlzdEtleQIFDWFtb3VudEFzc2V0SWQFDHByaWNlQXNzZXRJZAMJAAECBQckbWF0Y2gwAgZTdHJpbmcEAXMFByRtYXRjaDAJALUJAgUBcwUJc2VwYXJhdG9yBQNuaWwBEGtQYWlyU2V0dGluZ3NLZXkDDWFtb3VudEFzc2V0SWQMcHJpY2VBc3NldElkC3ByaWNlU3RyaW5nCQC5CQIJAMwIAgIIJXMlcyVkJXMJAMwIAgkBD2Fzc2V0SWRUb1N0cmluZwEFDWFtb3VudEFzc2V0SWQJAMwIAgkBD2Fzc2V0SWRUb1N0cmluZwEFDHByaWNlQXNzZXRJZAkAzAgCBQtwcmljZVN0cmluZwkAzAgCAghzZXR0aW5ncwUDbmlsBQlzZXBhcmF0b3IBD2dldEN1cnJlbnRQcmljZQEHYXNzZXRJZAQQbWF0Y2hlclB1YmxpY0tleQkA2QQBCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAJ0IAgUOZmFjdG9yeUFkZHJlc3MFEWtNYXRjaGVyUHVibGljS2V5CQEHd3JhcEVycgECGmludmFsaWQgbWF0Y2hlciBwdWJsaWMga2V5BA5tYXRjaGVyQWRkcmVzcwkApwgBBRBtYXRjaGVyUHVibGljS2V5BAVwcmljZQkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCaCAIFDm1hdGNoZXJBZGRyZXNzCQEGa1ByaWNlAQUHYXNzZXRJZAkBB3dyYXBFcnIBCQCsAgICGWludmFsaWQgcHJpY2UsIGFzc2V0SWQgPSAJAQ9hc3NldElkVG9TdHJpbmcBBQdhc3NldElkBQVwcmljZQEPY2FsY1RvdGFsQ3JlZGl0AwdjcmVkaXRBB2NyZWRpdEIMY3VycmVudFByaWNlCQC3AgIJALwCAwUHY3JlZGl0QQUMY3VycmVudFByaWNlBQxtdWx0MThCaWdJbnQFB2NyZWRpdEIBEGNhbGNUb3RhbEJhbGFuY2UDCGJhbGFuY2VBCGJhbGFuY2VCDGN1cnJlbnRQcmljZQkAtwICCQC8AgMFCGJhbGFuY2VBBQxjdXJyZW50UHJpY2UFDG11bHQxOEJpZ0ludAUIYmFsYW5jZUIBB2NhbGNQbmwCDHRvdGFsQmFsYW5jZQt0b3RhbENyZWRpdAkAuAICBQx0b3RhbEJhbGFuY2UFC3RvdGFsQ3JlZGl0ARNjYWxjQ3JlZGl0QXZhaWxhYmxlAwdkZXBvc2l0CGxldmVyYWdlC3RvdGFsQ3JlZGl0CQC4AgIJALwCAwUHZGVwb3NpdAUIbGV2ZXJhZ2UFDG11bHQxOEJpZ0ludAULdG90YWxDcmVkaXQBEGNhbGNSZWFsSW5DcmVkaXQCBmNyZWRpdAdiYWxhbmNlAwkAvwICBQZjcmVkaXQFBGJpZzAJALgCAgUGY3JlZGl0BQdiYWxhbmNlBQRiaWcwAQhjYWxjRnJlZQIGY3JlZGl0B2JhbGFuY2UDCQC/AgIFBmNyZWRpdAUEYmlnMAkAuAICBQdiYWxhbmNlBQZjcmVkaXQFBGJpZzABDmNhbGNTaG9ydFByaWNlAgRmcmVlDHJlYWxJbkNyZWRpdAMJAL8CAgUMcmVhbEluQ3JlZGl0BQRiaWcwCQCYAwEJAMwIAgUEYmlnMAkAzAgCCQC8AgMFBGZyZWUFDG11bHQxOEJpZ0ludAUMcmVhbEluQ3JlZGl0BQNuaWwFBGJpZzABDWNhbGNMb25nUHJpY2UCBGZyZWUMcmVhbEluQ3JlZGl0AwkAvwICBQxyZWFsSW5DcmVkaXQFBGJpZzAJAJgDAQkAzAgCBQRiaWcwCQDMCAIJALwCAwUMcmVhbEluQ3JlZGl0BQxtdWx0MThCaWdJbnQFBGZyZWUFA25pbAUEYmlnMAEPY2FsY1N0YXJ0TWFyZ2luBA1yZWFsSW5DcmVkaXRBDXJlYWxJbkNyZWRpdEIMY3VycmVudFByaWNlDnNldHRpbmdzTWFyZ2luCQC8AgMJALcCAgkAvAIDBQ1yZWFsSW5DcmVkaXRBBQxjdXJyZW50UHJpY2UFDG11bHQxOEJpZ0ludAUNcmVhbEluQ3JlZGl0QgUOc2V0dGluZ3NNYXJnaW4FDG11bHQxOEJpZ0ludAEQY2FsY01hcmdpblN1cHBseQMUc2V0dGluZ3NNYXJnaW5TdXBwbHkOc2V0dGluZ3NNYXJnaW4Lc3RhcnRNYXJnaW4JALwCAwUUc2V0dGluZ3NNYXJnaW5TdXBwbHkFC3N0YXJ0TWFyZ2luBQ5zZXR0aW5nc01hcmdpbgEUY2FsY0xpcXVpZGF0aW9uUHJpY2UGB2RlcG9zaXQMbWFyZ2luU3VwcGx5DXJlYWxJbkNyZWRpdEENcmVhbEluQ3JlZGl0QgpzaG9ydFByaWNlCWxvbmdQcmljZQQRbGlxdWlkYXRpb25QcmljZUEDCQC/AgIFDXJlYWxJbkNyZWRpdEEFBGJpZzAJALcCAgkAugICCQC4AgIFB2RlcG9zaXQFDG1hcmdpblN1cHBseQUNcmVhbEluQ3JlZGl0QQUKc2hvcnRQcmljZQUEYmlnMAQRbGlxdWlkYXRpb25QcmljZUIDCQC/AgIFDXJlYWxJbkNyZWRpdEIFBGJpZzAJALgCAgUJbG9uZ1ByaWNlCQC6AgIJALgCAgUHZGVwb3NpdAUMbWFyZ2luU3VwcGx5CQC6AgIFDXJlYWxJbkNyZWRpdEEFCWxvbmdQcmljZQUEYmlnMAkAtwICBRFsaXF1aWRhdGlvblByaWNlQQURbGlxdWlkYXRpb25QcmljZUIBDGdldFJlcXVlc3RJZAEOYWNjb3VudEFkZHJlc3MECXJlcXVlc3RJZAkA2QQBCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAJ0IAgUOZmFjdG9yeUFkZHJlc3MJARprQWNjb3VudEFkZHJlc3NUb1JlcXVlc3RJZAEFDmFjY291bnRBZGRyZXNzCQEHd3JhcEVycgECMGludmFsaWQgYWNjb3VudCBhZGRyZXNzOiByZXF1ZXN0IGlkIGlzIHVuZGVmaW5lZAUJcmVxdWVzdElkARBnZXRBY2NvdW50QXNzZXRzAQ5hY2NvdW50QWRkcmVzcwQJcmVxdWVzdElkCQEMZ2V0UmVxdWVzdElkAQUOYWNjb3VudEFkZHJlc3MEDWFtb3VudEFzc2V0SWQJAQxwYXJzZUFzc2V0SWQBCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAJ0IAgUOZmFjdG9yeUFkZHJlc3MJARVrUmVxdWVzdEFtb3VudEFzc2V0SWQBBQlyZXF1ZXN0SWQJAQd3cmFwRXJyAQIXaW52YWxpZCBhbW91bnQgYXNzZXQgaWQEDHByaWNlQXNzZXRJZAkBDHBhcnNlQXNzZXRJZAEJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAnQgCBQ5mYWN0b3J5QWRkcmVzcwkBFGtSZXF1ZXN0UHJpY2VBc3NldElkAQUJcmVxdWVzdElkCQEHd3JhcEVycgECF2ludmFsaWQgYW1vdW50IHByaWNlIGlkCQCUCgIFDWFtb3VudEFzc2V0SWQFDHByaWNlQXNzZXRJZAEYZ2V0QWNjb3VudE93bmVyUHVibGljS2V5AQ5hY2NvdW50QWRkcmVzcwQJcmVxdWVzdElkCQEMZ2V0UmVxdWVzdElkAQUOYWNjb3VudEFkZHJlc3MEFXJlcXVlc3RPd25lclB1YmxpY0tleQkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCcCAIFDmZhY3RvcnlBZGRyZXNzCQEWa1JlcXVlc3RPd25lclB1YmxpY0tleQEFCXJlcXVlc3RJZAkBB3dyYXBFcnIBAhdpbnZhbGlkIGFtb3VudCBhc3NldCBpZAUVcmVxdWVzdE93bmVyUHVibGljS2V5ARZnZXRBY2NvdW50SW5mb0ludGVybmFsAQ5hY2NvdW50QWRkcmVzcwQNJHQwMTExODcxMTI1NQkBEGdldEFjY291bnRBc3NldHMBBQ5hY2NvdW50QWRkcmVzcwQNYW1vdW50QXNzZXRJZAgFDSR0MDExMTg3MTEyNTUCXzEEDHByaWNlQXNzZXRJZAgFDSR0MDExMTg3MTEyNTUCXzIECGxldmVyYWdlCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAJoIAgUOZmFjdG9yeUFkZHJlc3MJAQlrTGV2ZXJhZ2UBBQ5hY2NvdW50QWRkcmVzcwkBB3dyYXBFcnIBAhpsZXZlcmFnZSBzaG91bGQgYmUgZGVmaW5lZAQJcmVxdWVzdElkCQEMZ2V0UmVxdWVzdElkAQUOYWNjb3VudEFkZHJlc3MEEGFjY291bnRQdWJsaWNLZXkJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAnAgCBQ5mYWN0b3J5QWRkcmVzcwkBHGtSZXF1ZXN0SWRUb0FjY291bnRQdWJsaWNLZXkBBQlyZXF1ZXN0SWQCJmtSZXF1ZXN0SWRUb0FjY291bnRQdWJsaWNLZXkgbm90IGZvdW5kBAlkZXBvc2l0ZWQJAQt2YWx1ZU9yRWxzZQIJAQ9kZXBvc2l0ZWRPcHRpb24BBQ5hY2NvdW50QWRkcmVzcwAABAxjdXJyZW50UHJpY2UJAQV0b1gxOAIJAQ9nZXRDdXJyZW50UHJpY2UBBQ1hbW91bnRBc3NldElkCQENcG93MTBEZWNpbWFscwEFDHByaWNlQXNzZXRJZAQHY3JlZGl0QQkBC3ZhbHVlT3JFbHNlAgkAmggCBQ5mYWN0b3J5QWRkcmVzcwkBB2tDcmVkaXQCBQ5hY2NvdW50QWRkcmVzcwUNYW1vdW50QXNzZXRJZAAABAdjcmVkaXRCCQELdmFsdWVPckVsc2UCCQCaCAIFDmZhY3RvcnlBZGRyZXNzCQEHa0NyZWRpdAIFDmFjY291bnRBZGRyZXNzBQxwcmljZUFzc2V0SWQAAAQGc3RhdHVzCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAJoIAgUOZmFjdG9yeUFkZHJlc3MJAQ5rUmVxdWVzdFN0YXR1cwEFCXJlcXVlc3RJZAkArAICAh5zdGF0dXMgbm90IGZvdW5kLiBSZXF1ZXN0SWQgPSAJANgEAQUJcmVxdWVzdElkBBJzeW50aEFtb3VudEFzc2V0SWQJAJ0IAgUOZmFjdG9yeUFkZHJlc3MJARFrU3ludGhldGljQXNzZXRJZAEFDWFtb3VudEFzc2V0SWQEF3N5bnRoQW1vdW50QXNzZXRCYWxhbmNlBAckbWF0Y2gwBRJzeW50aEFtb3VudEFzc2V0SWQDCQABAgUHJG1hdGNoMAIGU3RyaW5nBAFzBQckbWF0Y2gwCQEPZ2V0QXNzZXRCYWxhbmNlAgkBDHBhcnNlQXNzZXRJZAEFAXMFDmFjY291bnRBZGRyZXNzAAAEEXN5bnRoUHJpY2VBc3NldElkCQCdCAIFDmZhY3RvcnlBZGRyZXNzCQERa1N5bnRoZXRpY0Fzc2V0SWQBBQxwcmljZUFzc2V0SWQEFnN5bnRoUHJpY2VBc3NldEJhbGFuY2UEByRtYXRjaDAFEXN5bnRoUHJpY2VBc3NldElkAwkAAQIFByRtYXRjaDACBlN0cmluZwQBcwUHJG1hdGNoMAkBD2dldEFzc2V0QmFsYW5jZQIJAQxwYXJzZUFzc2V0SWQBBQFzBQ5hY2NvdW50QWRkcmVzcwAACQCeCgwJAQ9hc3NldElkVG9TdHJpbmcBBQ1hbW91bnRBc3NldElkCQEPYXNzZXRJZFRvU3RyaW5nAQUMcHJpY2VBc3NldElkCQClCAEFDmFjY291bnRBZGRyZXNzCQDYBAEFEGFjY291bnRQdWJsaWNLZXkFCGxldmVyYWdlCQDYBAEFCXJlcXVlc3RJZAUJZGVwb3NpdGVkBQdjcmVkaXRBBQdjcmVkaXRCBRdzeW50aEFtb3VudEFzc2V0QmFsYW5jZQUWc3ludGhQcmljZUFzc2V0QmFsYW5jZQUGc3RhdHVzAQ9kZXBvc2l0SU5URVJOQUwDD2NhbGxlclB1YmxpY0tleQRhcmdzAWkEB3BheW1lbnQJAJEDAggFAWkIcGF5bWVudHMAAAQOYWNjb3VudEFkZHJlc3MJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkApggBCQCRAwIFBGFyZ3MAAAkBB3dyYXBFcnIBAhdpbnZhbGlkIGFjY291bnQgYWRkcmVzcwQGY2tlY2tzCQDMCAIDCQEBIQEFCHNodXRkb3duBgkBCHRocm93RXJyAQILbm90IGFsbG93ZWQJAMwIAgkBC211c3RGYWN0b3J5AQgFAWkGY2FsbGVyCQDMCAIDCQAAAgkAkAMBCAUBaQhwYXltZW50cwABBgkBCHRocm93RXJyAQIVMSBwYXltZW50IGlzIHJlcXVpcmVkCQDMCAIDCQAAAggFB3BheW1lbnQHYXNzZXRJZAULdXNkdEFzc2V0SWQGCQEIdGhyb3dFcnIBAg1pbnZhbGlkIGFzc2V0CQDMCAIDCQAAAgkAmggCBQ5mYWN0b3J5QWRkcmVzcwkBDmtSZXF1ZXN0U3RhdHVzAQkBDGdldFJlcXVlc3RJZAEFDmFjY291bnRBZGRyZXNzBRRSRVFVRVNUX1NUQVRVU19SRUFEWQYJAQh0aHJvd0VycgECFGFjY291bnQgaXMgbm90IHJlYWR5BQNuaWwDCQAAAgUGY2tlY2tzBQZja2Vja3MEB2FjdGlvbnMJAMwIAgkBDlNjcmlwdFRyYW5zZmVyAwUOYWNjb3VudEFkZHJlc3MIBQdwYXltZW50BmFtb3VudAgFB3BheW1lbnQHYXNzZXRJZAUDbmlsBA5mYWN0b3J5QWN0aW9ucwkAzAgCCQD8BwQFDmZhY3RvcnlBZGRyZXNzAgxpbnRlZ2VyRW50cnkJAMwIAgkBCmtEZXBvc2l0ZWQBBQ5hY2NvdW50QWRkcmVzcwkAzAgCCQBkAgkBC3ZhbHVlT3JFbHNlAgkBD2RlcG9zaXRlZE9wdGlvbgEFDmFjY291bnRBZGRyZXNzAAAIBQdwYXltZW50BmFtb3VudAUDbmlsBQNuaWwFA25pbAkAlAoCBQdhY3Rpb25zBQ5mYWN0b3J5QWN0aW9ucwkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgEOYm9ycm93SU5URVJOQUwDD2NhbGxlclB1YmxpY0tleQRhcmdzAWkEDmFjY291bnRBZGRyZXNzCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAKYIAQkAkQMCBQRhcmdzAAAJAQd3cmFwRXJyAQIXaW52YWxpZCBhY2NvdW50IGFkZHJlc3MEEGFzc2V0SWRSZXF1ZXN0ZWQJAQxwYXJzZUFzc2V0SWQBCQCRAwIFBGFyZ3MAAQQPYW1vdW50UmVxdWVzdGVkCQEOZW5zdXJlUG9zaXRpdmUCCQETdmFsdWVPckVycm9yTWVzc2FnZQIJALYJAQkAkQMCBQRhcmdzAAIJAQd3cmFwRXJyAQIYaW52YWxpZCByZXF1ZXN0ZWQgYW1vdW50AhByZXF1ZXN0ZWQgYW1vdW50BBVhY2NvdW50T3duZXJQdWJsaWNLZXkJARhnZXRBY2NvdW50T3duZXJQdWJsaWNLZXkBBQ5hY2NvdW50QWRkcmVzcwQLdXNlckFkZHJlc3MJAKcIAQUPY2FsbGVyUHVibGljS2V5BAZja2Vja3MJAMwIAgMJAQEhAQUIc2h1dGRvd24GCQEIdGhyb3dFcnIBAgtub3QgYWxsb3dlZAkAzAgCCQELbXVzdEZhY3RvcnkBCAUBaQZjYWxsZXIJAMwIAgMJAAACBQ9jYWxsZXJQdWJsaWNLZXkFFWFjY291bnRPd25lclB1YmxpY0tleQYJAQh0aHJvd0VycgECI2NhbiBiZSBjYWxsZWQgYnkgYWNjb3VudCBvd25lciBvbmx5BQNuaWwDCQAAAgUGY2tlY2tzBQZja2Vja3MEDWFtb3VudEFzc2V0SWQICQEQZ2V0QWNjb3VudEFzc2V0cwEFDmFjY291bnRBZGRyZXNzAl8xBAlkZXBvc2l0ZWQJAQV0b1gxOAIJAQt2YWx1ZU9yRWxzZQIJAQ9kZXBvc2l0ZWRPcHRpb24BBQ5hY2NvdW50QWRkcmVzcwAACQENcG93MTBEZWNpbWFscwEFC3VzZHRBc3NldElkBAxjdXJyZW50UHJpY2UJAQV0b1gxOAIJAQ9nZXRDdXJyZW50UHJpY2UBBQ1hbW91bnRBc3NldElkCQENcG93MTBEZWNpbWFscwEFC3VzZHRBc3NldElkBAdjcmVkaXRBCQEFdG9YMTgCCQELdmFsdWVPckVsc2UCCQCaCAIFDmZhY3RvcnlBZGRyZXNzCQEHa0NyZWRpdAIFDmFjY291bnRBZGRyZXNzBQ1hbW91bnRBc3NldElkAAAJAQ1wb3cxMERlY2ltYWxzAQUNYW1vdW50QXNzZXRJZAQHY3JlZGl0QgkBBXRvWDE4AgkBC3ZhbHVlT3JFbHNlAgkAmggCBQ5mYWN0b3J5QWRkcmVzcwkBB2tDcmVkaXQCBQ5hY2NvdW50QWRkcmVzcwULdXNkdEFzc2V0SWQAAAkBDXBvdzEwRGVjaW1hbHMBBQt1c2R0QXNzZXRJZAQLdG90YWxDcmVkaXQJAQ9jYWxjVG90YWxDcmVkaXQDBQdjcmVkaXRBBQdjcmVkaXRCBQxjdXJyZW50UHJpY2UECGxldmVyYWdlCQEFdG9YMTgCCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAJoIAgUOZmFjdG9yeUFkZHJlc3MJAQlrTGV2ZXJhZ2UBBQ5hY2NvdW50QWRkcmVzcwkBB3dyYXBFcnIBAhpsZXZlcmFnZSBzaG91bGQgYmUgZGVmaW5lZAABBBNjcmVkaXRBdmFpbGFibGVVc2R0CQETY2FsY0NyZWRpdEF2YWlsYWJsZQMFCWRlcG9zaXRlZAUIbGV2ZXJhZ2UFC3RvdGFsQ3JlZGl0BA9jcmVkaXRBdmFpbGFibGUDCQAAAgUQYXNzZXRJZFJlcXVlc3RlZAUNYW1vdW50QXNzZXRJZAkBB2Zyb21YMTgCCQC8AgMFE2NyZWRpdEF2YWlsYWJsZVVzZHQFDG11bHQxOEJpZ0ludAUMY3VycmVudFByaWNlCQENcG93MTBEZWNpbWFscwEFDWFtb3VudEFzc2V0SWQDCQAAAgUQYXNzZXRJZFJlcXVlc3RlZAULdXNkdEFzc2V0SWQJAQdmcm9tWDE4AgUTY3JlZGl0QXZhaWxhYmxlVXNkdAkBDXBvdzEwRGVjaW1hbHMBBQt1c2R0QXNzZXRJZAkBCHRocm93RXJyAQIaaW52YWxpZCByZXF1ZXN0ZWQgYXNzZXQgaWQEEHN5bnRoZXRpY0Fzc2V0SWQJAQxwYXJzZUFzc2V0SWQBCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAJ0IAgUOZmFjdG9yeUFkZHJlc3MJARFrU3ludGhldGljQXNzZXRJZAEFEGFzc2V0SWRSZXF1ZXN0ZWQJAQd3cmFwRXJyAQIwc3ludGhldGljIGFzc2V0IGZvciByZXF1ZXN0ZWQgYXNzZXQgaXMgdW5kZWZpbmVkBAxhbW91bnRUb1NlbmQDCQBnAgUPY3JlZGl0QXZhaWxhYmxlBQ9hbW91bnRSZXF1ZXN0ZWQFD2Ftb3VudFJlcXVlc3RlZAkBCHRocm93RXJyAQkArAICAhNjcmVkaXQgYXZhaWxhYmxlID0gCQCkAwEFD2NyZWRpdEF2YWlsYWJsZQQOZmFjdG9yeUFjdGlvbnMJAMwIAgkA/AcEBQ5mYWN0b3J5QWRkcmVzcwIMaW50ZWdlckVudHJ5CQDMCAIJAQdrQ3JlZGl0AgUOYWNjb3VudEFkZHJlc3MFEGFzc2V0SWRSZXF1ZXN0ZWQJAMwIAgkAZAIJAQt2YWx1ZU9yRWxzZQIJAQxjcmVkaXRPcHRpb24CBQ5hY2NvdW50QWRkcmVzcwUQYXNzZXRJZFJlcXVlc3RlZAAABQxhbW91bnRUb1NlbmQFA25pbAUDbmlsCQDMCAIJAPwHBAUOZmFjdG9yeUFkZHJlc3MCDXRyYW5zZmVyQXNzZXQJAMwIAgUOYWNjb3VudEFkZHJlc3MJAMwIAgUMYW1vdW50VG9TZW5kCQDMCAIJAQ9hc3NldElkVG9TdHJpbmcBBRBzeW50aGV0aWNBc3NldElkBQNuaWwFA25pbAUDbmlsCQCUCgIFA25pbAkAzAgCBQ5mYWN0b3J5QWN0aW9ucwkAzAgCBQ9jcmVkaXRBdmFpbGFibGUFA25pbAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLhABaQEEaW5pdAERZmFjdG9yeUFkZHJlc3NTdHIEC2NoZWNrQ2FsbGVyCQEIbXVzdFRoaXMBCAUBaQZjYWxsZXIDCQAAAgULY2hlY2tDYWxsZXIFC2NoZWNrQ2FsbGVyCQCUCgIJAMwIAgkBC1N0cmluZ0VudHJ5AgUPa0ZhY3RvcnlBZGRyZXNzBRFmYWN0b3J5QWRkcmVzc1N0cgUDbmlsBQR1bml0CQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAWkBDnJlcXVlc3RBY2NvdW50Ag9jYWxsZXJQdWJsaWNLZXkEYXJncwQGY2tlY2tzCQDMCAIDCQEBIQEFCHNodXRkb3duBgkBCHRocm93RXJyAQILbm90IGFsbG93ZWQJAMwIAgkBC211c3RGYWN0b3J5AQgFAWkGY2FsbGVyBQNuaWwDCQAAAgUGY2tlY2tzBQZja2Vja3MEEGFtb3VudEFzc2V0SWRTdHIJAJEDAgUEYXJncwAABA9wcmljZUFzc2V0SWRTdHIJAJEDAgUEYXJncwABBAhsZXZlcmFnZQkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQC2CQEJAJEDAgUEYXJncwACCQEHd3JhcEVycgECEGludmFsaWQgbGV2ZXJhZ2UEC3VzZXJBZGRyZXNzCQCnCAEFD2NhbGxlclB1YmxpY0tleQQJcmVxdWVzdElkCQD3AwEJAMsBAgkAywECCAULdXNlckFkZHJlc3MFYnl0ZXMJANkEAQUQYW1vdW50QXNzZXRJZFN0cgkA2QQBBQ9wcmljZUFzc2V0SWRTdHIEDWFtb3VudEFzc2V0SWQJAQxwYXJzZUFzc2V0SWQBBRBhbW91bnRBc3NldElkU3RyBAxwcmljZUFzc2V0SWQJAQxwYXJzZUFzc2V0SWQBBQ9wcmljZUFzc2V0SWRTdHIEEnVzZXJSZXF1ZXN0c051bWJlcgkAaQIJALECAQkBEGtSZXF1ZXN0c0J5T3duZXIBBQt1c2VyQWRkcmVzcwUNcXVldWVJdGVtU2l6ZQQGY2hlY2tzCQDMCAIDCQAAAgkAkAMBCAUBaQhwYXltZW50cwABBgkBCHRocm93RXJyAQIVMSBwYXltZW50IGlzIHJlcXVpcmVkCQDMCAIDCQAAAggJAJEDAggFAWkIcGF5bWVudHMAAAdhc3NldElkBQR1bml0BgkBCHRocm93RXJyAQINaW52YWxpZCBhc3NldAkAzAgCAwkAAAIICQCRAwIIBQFpCHBheW1lbnRzAAAGYW1vdW50CQEMcmV3YXJkQW1vdW50AAYJAQh0aHJvd0VycgECDmludmFsaWQgYW1vdW50CQDMCAIDCQELcGFpckFsbG93ZWQCBQ1hbW91bnRBc3NldElkBQxwcmljZUFzc2V0SWQGCQEIdGhyb3dFcnIBAhNwYWlyIGlzIG5vdCBhbGxvd2VkCQDMCAIDCQAAAgkAmggCBQ5mYWN0b3J5QWRkcmVzcwkBDmtSZXF1ZXN0U3RhdHVzAQUJcmVxdWVzdElkBQR1bml0BgkBCHRocm93RXJyAQIZYWNjb3VudCBpcyBhbHJlYWR5IGV4aXN0cwkAzAgCAwkAZgIJAQ1hY2NvdW50c0xpbWl0AAUSdXNlclJlcXVlc3RzTnVtYmVyBgkBCHRocm93RXJyAQkArAICAhJhY2NvdW50cyBsaW1pdCBpcyAJAKQDAQkBDWFjY291bnRzTGltaXQABQNuaWwDCQAAAgUGY2hlY2tzBQZjaGVja3MEDSR0MDE4MjU1MTk3ODgDCQAAAgkAyAEBCQENYWNjb3VudHNRdWV1ZQAAAAkAlAoCCQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMFDmZhY3RvcnlBZGRyZXNzCQEMcmV3YXJkQW1vdW50AAUEdW5pdAUDbmlsCQDMCAIJAPwHBAUOZmFjdG9yeUFkZHJlc3MCDGludGVnZXJFbnRyeQkAzAgCCQEOa1JlcXVlc3RTdGF0dXMBBQlyZXF1ZXN0SWQJAMwIAgUUUkVRVUVTVF9TVEFUVVNfRU1QVFkFA25pbAUDbmlsCQDMCAIJAPwHBAUOZmFjdG9yeUFkZHJlc3MCC2JpbmFyeUVudHJ5CQDMCAIJAQ5rUmVxdWVzdHNRdWV1ZQAJAMwIAgkAywECCQENcmVxdWVzdHNRdWV1ZQAFCXJlcXVlc3RJZAUDbmlsBQNuaWwJAMwIAgkA/AcEBQ5mYWN0b3J5QWRkcmVzcwIMaW50ZWdlckVudHJ5CQDMCAIJARBrUmVxdWVzdExldmVyYWdlAQUJcmVxdWVzdElkCQDMCAIFCGxldmVyYWdlBQNuaWwFA25pbAUDbmlsBBBhY2NvdW50UHVibGljS2V5CQDJAQIJAQ1hY2NvdW50c1F1ZXVlAAUNcXVldWVJdGVtU2l6ZQQOYWNjb3VudEFkZHJlc3MJAKcIAQUQYWNjb3VudFB1YmxpY0tleQQOY3JlYXRvckFkZHJlc3MJAKcIAQkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCcCAIFDmZhY3RvcnlBZGRyZXNzCQEYa0FjY291bnRDcmVhdG9yUHVibGljS2V5AQUOYWNjb3VudEFkZHJlc3MJAQd3cmFwRXJyAQIaaW52YWxpZCBjcmVhdG9yIHB1YmxpYyBrZXkJAJQKAgkAzAgCCQEOU2NyaXB0VHJhbnNmZXIDBQ5jcmVhdG9yQWRkcmVzcwkBDHJld2FyZEFtb3VudAAFBHVuaXQFA25pbAkAzAgCCQD8BwQFDmZhY3RvcnlBZGRyZXNzAgtiaW5hcnlFbnRyeQkAzAgCCQEOa0FjY291bnRzUXVldWUACQDMCAIJAMoBAgkBDWFjY291bnRzUXVldWUABQ1xdWV1ZUl0ZW1TaXplBQNuaWwFA25pbAkAzAgCCQD8BwQFDmZhY3RvcnlBZGRyZXNzAgxpbnRlZ2VyRW50cnkJAMwIAgkBDmtSZXF1ZXN0U3RhdHVzAQUJcmVxdWVzdElkCQDMCAIFFFJFUVVFU1RfU1RBVFVTX1JFQURZBQNuaWwFA25pbAkAzAgCCQD8BwQFDmZhY3RvcnlBZGRyZXNzAgtiaW5hcnlFbnRyeQkAzAgCCQEca1JlcXVlc3RJZFRvQWNjb3VudFB1YmxpY0tleQEFCXJlcXVlc3RJZAkAzAgCBRBhY2NvdW50UHVibGljS2V5BQNuaWwFA25pbAkAzAgCCQD8BwQFDmZhY3RvcnlBZGRyZXNzAgtzdHJpbmdFbnRyeQkAzAgCCQEaa0FjY291bnRBZGRyZXNzVG9SZXF1ZXN0SWQBBQ5hY2NvdW50QWRkcmVzcwkAzAgCCQDYBAEFCXJlcXVlc3RJZAUDbmlsBQNuaWwJAMwIAgkA/AcEBQ5mYWN0b3J5QWRkcmVzcwIMaW50ZWdlckVudHJ5CQDMCAIJAQlrTGV2ZXJhZ2UBBQ5hY2NvdW50QWRkcmVzcwkAzAgCBQhsZXZlcmFnZQUDbmlsBQNuaWwFA25pbAQHYWN0aW9ucwgFDSR0MDE4MjU1MTk3ODgCXzEEDmZhY3RvcnlBY3Rpb25zCAUNJHQwMTgyNTUxOTc4OAJfMgkAlAoCBQdhY3Rpb25zCQDOCAIFDmZhY3RvcnlBY3Rpb25zCQDMCAIJAPwHBAUOZmFjdG9yeUFkZHJlc3MCC2JpbmFyeUVudHJ5CQDMCAIJARZrUmVxdWVzdE93bmVyUHVibGljS2V5AQUJcmVxdWVzdElkCQDMCAIFD2NhbGxlclB1YmxpY0tleQUDbmlsBQNuaWwJAMwIAgkA/AcEBQ5mYWN0b3J5QWRkcmVzcwILYmluYXJ5RW50cnkJAMwIAgkBEGtSZXF1ZXN0c0J5T3duZXIBBQt1c2VyQWRkcmVzcwkAzAgCCQDLAQIJAQ9yZXF1ZXN0c0J5T3duZXIBBQt1c2VyQWRkcmVzcwUJcmVxdWVzdElkBQNuaWwFA25pbAkAzAgCCQD8BwQFDmZhY3RvcnlBZGRyZXNzAgtzdHJpbmdFbnRyeQkAzAgCCQEVa1JlcXVlc3RBbW91bnRBc3NldElkAQUJcmVxdWVzdElkCQDMCAIFEGFtb3VudEFzc2V0SWRTdHIFA25pbAUDbmlsCQDMCAIJAPwHBAUOZmFjdG9yeUFkZHJlc3MCC3N0cmluZ0VudHJ5CQDMCAIJARRrUmVxdWVzdFByaWNlQXNzZXRJZAEFCXJlcXVlc3RJZAkAzAgCBQ9wcmljZUFzc2V0SWRTdHIFA25pbAUDbmlsBQNuaWwJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BaQEKYWRkQWNjb3VudAIPY2FsbGVyUHVibGljS2V5BGFyZ3MEBmNrZWNrcwkAzAgCAwkBASEBBQhzaHV0ZG93bgYJAQh0aHJvd0VycgECC25vdCBhbGxvd2VkCQDMCAIJAQttdXN0RmFjdG9yeQEIBQFpBmNhbGxlcgUDbmlsAwkAAAIFBmNrZWNrcwUGY2tlY2tzBBBjcmVhdG9yUHVibGljS2V5CQDZBAEJAJEDAgUEYXJncwAABBBhY2NvdW50UHVibGljS2V5BQ9jYWxsZXJQdWJsaWNLZXkEDmFjY291bnRBZGRyZXNzCQCnCAEFD2NhbGxlclB1YmxpY0tleQQOY3JlYXRvckFkZHJlc3MJAKcIAQUQY3JlYXRvclB1YmxpY0tleQQGY2hlY2tzCQDMCAIDCQAAAgkAnAgCBQ5mYWN0b3J5QWRkcmVzcwkBGGtBY2NvdW50Q3JlYXRvclB1YmxpY0tleQEFDmFjY291bnRBZGRyZXNzBQR1bml0BgkBCHRocm93RXJyAQIZYWNjb3VudCBpcyBhbHJlYWR5IGV4aXN0cwkAzAgCAwQHJG1hdGNoMAkA8QcBBQ5hY2NvdW50QWRkcmVzcwMJAAECBQckbWF0Y2gwAgpCeXRlVmVjdG9yBAFiBQckbWF0Y2gwCQAAAgUBYgkA8RUBCQENYWNjb3VudFNjcmlwdAAHBgkBCHRocm93RXJyAQIOaW52YWxpZCBzY3JpcHQFA25pbAMJAAACBQZjaGVja3MFBmNoZWNrcwQNJHQwMjEwNDMyMjI4NAMJAAACCQDIAQEJAQ1yZXF1ZXN0c1F1ZXVlAAAACQCUCgIFA25pbAkAzAgCCQD8BwQFDmZhY3RvcnlBZGRyZXNzAgtiaW5hcnlFbnRyeQkAzAgCCQEOa0FjY291bnRzUXVldWUACQDMCAIJAMsBAgkBDWFjY291bnRzUXVldWUABRBhY2NvdW50UHVibGljS2V5BQNuaWwFA25pbAUDbmlsBAlyZXF1ZXN0SWQJAMkBAgkBDXJlcXVlc3RzUXVldWUABQ1xdWV1ZUl0ZW1TaXplBAhsZXZlcmFnZQkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCaCAIFDmZhY3RvcnlBZGRyZXNzCQEQa1JlcXVlc3RMZXZlcmFnZQEFCXJlcXVlc3RJZAkBB3dyYXBFcnIBAh9yZXF1ZXN0J3MgbGV2ZXJhZ2UgaXMgdW5kZWZpbmVkCQCUCgIFA25pbAkAzAgCCQD8BwQFDmZhY3RvcnlBZGRyZXNzAgxpbnRlZ2VyRW50cnkJAMwIAgkBDmtSZXF1ZXN0U3RhdHVzAQUJcmVxdWVzdElkCQDMCAIFFFJFUVVFU1RfU1RBVFVTX1JFQURZBQNuaWwFA25pbAkAzAgCCQD8BwQFDmZhY3RvcnlBZGRyZXNzAgtiaW5hcnlFbnRyeQkAzAgCCQEca1JlcXVlc3RJZFRvQWNjb3VudFB1YmxpY0tleQEFCXJlcXVlc3RJZAkAzAgCBRBhY2NvdW50UHVibGljS2V5BQNuaWwFA25pbAkAzAgCCQD8BwQFDmZhY3RvcnlBZGRyZXNzAgtiaW5hcnlFbnRyeQkAzAgCCQEOa1JlcXVlc3RzUXVldWUACQDMCAIJAMoBAgkBDXJlcXVlc3RzUXVldWUABQ1xdWV1ZUl0ZW1TaXplBQNuaWwFA25pbAkAzAgCCQD8BwQFDmZhY3RvcnlBZGRyZXNzAgtzdHJpbmdFbnRyeQkAzAgCCQEaa0FjY291bnRBZGRyZXNzVG9SZXF1ZXN0SWQBBQ5hY2NvdW50QWRkcmVzcwkAzAgCCQDYBAEFCXJlcXVlc3RJZAUDbmlsBQNuaWwJAMwIAgkA/AcEBQ5mYWN0b3J5QWRkcmVzcwINdHJhbnNmZXJXYXZlcwkAzAgCCAUOY3JlYXRvckFkZHJlc3MFYnl0ZXMJAMwIAgkBDHJld2FyZEFtb3VudAAFA25pbAUDbmlsCQDMCAIJAPwHBAUOZmFjdG9yeUFkZHJlc3MCDGludGVnZXJFbnRyeQkAzAgCCQEJa0xldmVyYWdlAQUOYWNjb3VudEFkZHJlc3MJAMwIAgUIbGV2ZXJhZ2UFA25pbAUDbmlsBQNuaWwEB2FjdGlvbnMIBQ0kdDAyMTA0MzIyMjg0Al8xBA5mYWN0b3J5QWN0aW9ucwgFDSR0MDIxMDQzMjIyODQCXzIJAJQKAgUHYWN0aW9ucwkAzggCBQ5mYWN0b3J5QWN0aW9ucwkAzAgCCQD8BwQFDmZhY3RvcnlBZGRyZXNzAgtiaW5hcnlFbnRyeQkAzAgCCQEYa0FjY291bnRDcmVhdG9yUHVibGljS2V5AQUOYWNjb3VudEFkZHJlc3MJAMwIAgUQY3JlYXRvclB1YmxpY0tleQUDbmlsBQNuaWwFA25pbAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgFpAQh3aXRoZHJhdwIPY2FsbGVyUHVibGljS2V5BGFyZ3MEBmNoZWNrcwkAzAgCAwkBASEBBQhzaHV0ZG93bgYJAQh0aHJvd0VycgECC25vdCBhbGxvd2VkCQDMCAIJAQttdXN0RmFjdG9yeQEIBQFpBmNhbGxlcgUDbmlsAwkAAAIFBmNoZWNrcwUGY2hlY2tzBAt1c2VyQWRkcmVzcwkApwgBBQ9jYWxsZXJQdWJsaWNLZXkEDmFjY291bnRBZGRyZXNzCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAKYIAQkAkQMCBQRhcmdzAAAJAQd3cmFwRXJyAQIXaW52YWxpZCBhY2NvdW50IGFkZHJlc3MEBmFtb3VudAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQC2CQEJAJEDAgUEYXJncwABCQEHd3JhcEVycgECDmludmFsaWQgYW1vdW50BAdhc3NldElkCQEMcGFyc2VBc3NldElkAQkAkQMCBQRhcmdzAAIEC2ludm9jYXRpb25zCQDMCAIJAPwHBAUOYWNjb3VudEFkZHJlc3MCDXRyYW5zZmVyQXNzZXQJAMwIAggFC3VzZXJBZGRyZXNzBWJ5dGVzCQDMCAIFBmFtb3VudAkAzAgCBQdhc3NldElkBQNuaWwFA25pbAUDbmlsCQCUCgIFA25pbAULaW52b2NhdGlvbnMJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BaQEHZGVwb3NpdAIPY2FsbGVyUHVibGljS2V5BGFyZ3MEDSR0MDIzMzA1MjMzNzgJAQ9kZXBvc2l0SU5URVJOQUwDBQ9jYWxsZXJQdWJsaWNLZXkFBGFyZ3MFAWkEB2FjdGlvbnMIBQ0kdDAyMzMwNTIzMzc4Al8xBA5mYWN0b3J5QWN0aW9ucwgFDSR0MDIzMzA1MjMzNzgCXzIJAJQKAgUHYWN0aW9ucwUOZmFjdG9yeUFjdGlvbnMBaQEGYm9ycm93Ag9jYWxsZXJQdWJsaWNLZXkEYXJncwQNJHQwMjM1MzMyMzYwNQkBDmJvcnJvd0lOVEVSTkFMAwUPY2FsbGVyUHVibGljS2V5BQRhcmdzBQFpBAdhY3Rpb25zCAUNJHQwMjM1MzMyMzYwNQJfMQQOZmFjdG9yeUFjdGlvbnMIBQ0kdDAyMzUzMzIzNjA1Al8yCQCUCgIFB2FjdGlvbnMFDmZhY3RvcnlBY3Rpb25zAWkBEGRlcG9zaXRBbmRCb3Jyb3cCD2NhbGxlclB1YmxpY0tleQRhcmdzBA5hY2NvdW50QWRkcmVzcwkAkQMCBQRhcmdzAAAEDSR0MDIzODAxMjM5MDAJAQ9kZXBvc2l0SU5URVJOQUwDBQ9jYWxsZXJQdWJsaWNLZXkJAMwIAgUOYWNjb3VudEFkZHJlc3MFA25pbAUBaQQOZGVwb3NpdEFjdGlvbnMIBQ0kdDAyMzgwMTIzOTAwAl8xBBVkZXBvc2l0RmFjdG9yeUFjdGlvbnMIBQ0kdDAyMzgwMTIzOTAwAl8yBA0kdDAyMzkwMzIzOTg3CQEOYm9ycm93SU5URVJOQUwDBQ9jYWxsZXJQdWJsaWNLZXkFBGFyZ3MFAWkEDWJvcnJvd0FjdGlvbnMIBQ0kdDAyMzkwMzIzOTg3Al8xBBRib3Jyb3dGYWN0b3J5QWN0aW9ucwgFDSR0MDIzOTAzMjM5ODcCXzIJAJQKAgkAzggCBQ5kZXBvc2l0QWN0aW9ucwUNYm9ycm93QWN0aW9ucwkAzggCBRVkZXBvc2l0RmFjdG9yeUFjdGlvbnMFFGJvcnJvd0ZhY3RvcnlBY3Rpb25zAWkBBXJlcGF5Ag9jYWxsZXJQdWJsaWNLZXkEYXJncwQGY2tlY2tzCQDMCAIDCQEBIQEFCHNodXRkb3duBgkBCHRocm93RXJyAQILbm90IGFsbG93ZWQJAMwIAgkBC211c3RGYWN0b3J5AQgFAWkGY2FsbGVyBQNuaWwDCQAAAgUGY2tlY2tzBQZja2Vja3MJAJQKAgUDbmlsBQR1bml0CQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAWkBEHNldFBhaXJBbGxvd2FuY2UCD2NhbGxlclB1YmxpY0tleQRhcmdzBAZja2Vja3MJAMwIAgMJAQEhAQUIc2h1dGRvd24GCQEIdGhyb3dFcnIBAgtub3QgYWxsb3dlZAkAzAgCCQELbXVzdEZhY3RvcnkBCAUBaQZjYWxsZXIJAMwIAgkBCW11c3RBZG1pbgEFD2NhbGxlclB1YmxpY0tleQUDbmlsAwkAAAIFBmNrZWNrcwUGY2tlY2tzBBBhbW91bnRBc3NldElkU3RyCQCRAwIFBGFyZ3MAAAQPcHJpY2VBc3NldElkU3RyCQCRAwIFBGFyZ3MAAQQIYWxsb3dTdHIJAJEDAgUEYXJncwACBA1hbW91bnRBc3NldElkCQEMcGFyc2VBc3NldElkAQUQYW1vdW50QXNzZXRJZFN0cgQMcHJpY2VBc3NldElkCQEMcGFyc2VBc3NldElkAQUPcHJpY2VBc3NldElkU3RyBAVhbGxvdwkAAAIFCGFsbG93U3RyAgR0cnVlBAtpbnZvY2F0aW9ucwkAzAgCCQD8BwQFDmZhY3RvcnlBZGRyZXNzAgxib29sZWFuRW50cnkJAMwIAgkBDGtQYWlyQWxsb3dlZAIFDWFtb3VudEFzc2V0SWQFDHByaWNlQXNzZXRJZAkAzAgCBQVhbGxvdwUDbmlsBQNuaWwFA25pbAkAlAoCBQNuaWwFC2ludm9jYXRpb25zCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAWkBEWFkZFN5bnRoZXRpY0Fzc2V0Ag9jYWxsZXJQdWJsaWNLZXkEYXJncwQLYmFzZUFzc2V0SWQJAQxwYXJzZUFzc2V0SWQBCQCRAwIFBGFyZ3MAAAQQc3ludGhldGljQXNzZXRJZAkBDHBhcnNlQXNzZXRJZAEJAJEDAgUEYXJncwABBAZja2Vja3MJAMwIAgMJAQEhAQUIc2h1dGRvd24GCQEIdGhyb3dFcnIBAgtub3QgYWxsb3dlZAkAzAgCCQELbXVzdEZhY3RvcnkBCAUBaQZjYWxsZXIJAMwIAgkBCW11c3RBZG1pbgEFD2NhbGxlclB1YmxpY0tleQkAzAgCAwkAAAIJAJ0IAgUOZmFjdG9yeUFkZHJlc3MJARFrU3ludGhldGljQXNzZXRJZAEFC2Jhc2VBc3NldElkBQR1bml0BgkBCHRocm93RXJyAQISaW52YWxpZCBiYXNlIGFzc2V0CQDMCAIDCQAAAgkAnQgCBQ5mYWN0b3J5QWRkcmVzcwkBDGtCYXNlQXNzZXRJZAEFEHN5bnRoZXRpY0Fzc2V0SWQFBHVuaXQGCQEIdGhyb3dFcnIBAhdpbnZhbGlkIHN5bnRoZXRpYyBhc3NldAUDbmlsAwkAAAIFBmNrZWNrcwUGY2tlY2tzBAtpbnZvY2F0aW9ucwkAzAgCCQD8BwQFDmZhY3RvcnlBZGRyZXNzAgtzdHJpbmdFbnRyeQkAzAgCCQERa1N5bnRoZXRpY0Fzc2V0SWQBBQtiYXNlQXNzZXRJZAkAzAgCCQEPYXNzZXRJZFRvU3RyaW5nAQUQc3ludGhldGljQXNzZXRJZAUDbmlsBQNuaWwJAMwIAgkA/AcEBQ5mYWN0b3J5QWRkcmVzcwILc3RyaW5nRW50cnkJAMwIAgkBDGtCYXNlQXNzZXRJZAEFEHN5bnRoZXRpY0Fzc2V0SWQJAMwIAgkBD2Fzc2V0SWRUb1N0cmluZwEFC2Jhc2VBc3NldElkBQNuaWwFA25pbAUDbmlsCQCUCgIFA25pbAULaW52b2NhdGlvbnMJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BaQEKZG9TaHV0ZG93bgIPY2FsbGVyUHVibGljS2V5BGFyZ3MEBmNoZWNrcwkAzAgCCQELbXVzdEZhY3RvcnkBCAUBaQZjYWxsZXIJAMwIAgkBCW11c3RBZG1pbgEFD2NhbGxlclB1YmxpY0tleQUDbmlsAwkAAAIFBmNoZWNrcwUGY2hlY2tzBAtpbnZvY2F0aW9ucwkAzAgCCQD8BwQFDmZhY3RvcnlBZGRyZXNzAgxib29sZWFuRW50cnkJAMwIAgUJa1NodXRkb3duCQDMCAIGBQNuaWwFA25pbAUDbmlsCQCUCgIFA25pbAULaW52b2NhdGlvbnMJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BaQEWZ2V0QWNjb3VudEluZm9SRUFET05MWQIPY2FsbGVyUHVibGljS2V5BGFyZ3MEBmNoZWNrcwkAzAgCCQELbXVzdEZhY3RvcnkBCAUBaQZjYWxsZXIFA25pbAMJAAACBQZjaGVja3MFBmNoZWNrcwQOYWNjb3VudEFkZHJlc3MJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkApggBCQCRAwIFBGFyZ3MAAAkBB3dyYXBFcnIBAhdpbnZhbGlkIGFjY291bnQgYWRkcmVzcwQEZGF0YQkBFmdldEFjY291bnRJbmZvSW50ZXJuYWwBBQ5hY2NvdW50QWRkcmVzcwkAlAoCBQNuaWwFBGRhdGEJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BaQETZ2V0VXNlckluZm9SRUFET05MWQIPY2FsbGVyUHVibGljS2V5BGFyZ3MEBmNoZWNrcwkAzAgCCQELbXVzdEZhY3RvcnkBCAUBaQZjYWxsZXIFA25pbAMJAAACBQZjaGVja3MFBmNoZWNrcwQLdXNlckFkZHJlc3MJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkApggBCQCRAwIFBGFyZ3MAAAkBB3dyYXBFcnIBAhRpbnZhbGlkIHVzZXIgYWRkcmVzcwQMdXNlclJlcXVlc3RzCQELdmFsdWVPckVsc2UCCQCcCAIFDmZhY3RvcnlBZGRyZXNzCQEQa1JlcXVlc3RzQnlPd25lcgEFC3VzZXJBZGRyZXNzAQAEEnVzZXJSZXF1ZXN0c051bWJlcgkAaQIJAMgBAQUMdXNlclJlcXVlc3RzBQ1xdWV1ZUl0ZW1TaXplCgEPZ2V0QWNjb3VudHNEYXRhAgNhY2MFY291bnQEDSR0MDI2OTIwMjY5NjIFA2FjYwQLYWNjRGF0YUxpc3QIBQ0kdDAyNjkyMDI2OTYyAl8xBAhyYXdCeXRlcwgFDSR0MDI2OTIwMjY5NjICXzIEB21heFNpemUIBQ0kdDAyNjkyMDI2OTYyAl8zAwkAZgIFB21heFNpemUFBWNvdW50BAlyZXF1ZXN0SWQJAMkBAgUIcmF3Qnl0ZXMFDXF1ZXVlSXRlbVNpemUEC25ld1Jhd0J5dGVzCQDKAQIFCHJhd0J5dGVzBQ1xdWV1ZUl0ZW1TaXplBBBhY2NvdW50UHVibGljS2V5CQETdmFsdWVPckVycm9yTWVzc2FnZQIJAJwIAgUOZmFjdG9yeUFkZHJlc3MJARxrUmVxdWVzdElkVG9BY2NvdW50UHVibGljS2V5AQUJcmVxdWVzdElkAiZrUmVxdWVzdElkVG9BY2NvdW50UHVibGljS2V5IG5vdCBmb3VuZAQOYWNjb3VudEFkZHJlc3MJAKcIAQUQYWNjb3VudFB1YmxpY0tleQQEZGF0YQkBFmdldEFjY291bnRJbmZvSW50ZXJuYWwBBQ5hY2NvdW50QWRkcmVzcwkAlQoDCQDNCAIFC2FjY0RhdGFMaXN0BQRkYXRhBQtuZXdSYXdCeXRlcwUHbWF4U2l6ZQUDYWNjBA0kdDAyNzQ2NjI3NTcxCgACJGwFCklOREVYX0xJU1QKAAIkcwkAkAMBBQIkbAoABSRhY2MwCQCVCgMFA25pbAUMdXNlclJlcXVlc3RzBRJ1c2VyUmVxdWVzdHNOdW1iZXIKAQUkZjBfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBD2dldEFjY291bnRzRGF0YQIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMjAJAQUkZjBfMgIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgALAAwADQAOAA8AEAARABIAEwAUBAthY2NEYXRhTGlzdAgFDSR0MDI3NDY2Mjc1NzECXzEEAl9hCAUNJHQwMjc0NjYyNzU3MQJfMgQCX2IIBQ0kdDAyNzQ2NjI3NTcxAl8zCQCUCgIFA25pbAULYWNjRGF0YUxpc3QJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BaQEbZ2V0UGFpclNldHRpbmdzSW5mb1JFQURPTkxZAg9jYWxsZXJQdWJsaWNLZXkEYXJncwQLYW1vdW50QXNzZXQJAQxwYXJzZUFzc2V0SWQBCQCRAwIFBGFyZ3MAAAQKcHJpY2VBc3NldAkBDHBhcnNlQXNzZXRJZAEJAJEDAgUEYXJncwABBApwcmljZXNMaXN0CQERZ2V0UGFpclByaWNlc0xpc3QCBQthbW91bnRBc3NldAUKcHJpY2VBc3NldAoBD2dldFBhaXJTZXR0aW5ncwIDYWNjDHByaWNlc1N0cmluZwQLc2V0dGluZ3NLZXkJARBrUGFpclNldHRpbmdzS2V5AwULYW1vdW50QXNzZXQFCnByaWNlQXNzZXQFDHByaWNlc1N0cmluZwQTc2V0dGluZ3NTdHJpbmdWYWx1ZQkBEUBleHRyTmF0aXZlKDEwNTMpAgUOZmFjdG9yeUFkZHJlc3MFC3NldHRpbmdzS2V5BAVzTGlzdAkAtQkCBRNzZXR0aW5nc1N0cmluZ1ZhbHVlBQlzZXBhcmF0b3IEBXByaWNlCQC2CQEFDHByaWNlc1N0cmluZwQLbWF4TGV2ZXJhZ2UJALYJAQkAkQMCBQVzTGlzdAABBA1pbml0aWFsTWFyZ2luCQC2CQEJAJEDAgUFc0xpc3QAAgQRbWFpbnRlbmFuY2VNYXJnaW4JALYJAQkAkQMCBQVzTGlzdAADCQDNCAIFA2FjYwkAlgoEBQVwcmljZQULbWF4TGV2ZXJhZ2UFDWluaXRpYWxNYXJnaW4FEW1haW50ZW5hbmNlTWFyZ2luBARkYXRhCgACJGwFCnByaWNlc0xpc3QKAAIkcwkAkAMBBQIkbAoABSRhY2MwBQNuaWwKAQUkZjBfMQICJGECJGkDCQBnAgUCJGkFAiRzBQIkYQkBD2dldFBhaXJTZXR0aW5ncwIFAiRhCQCRAwIFAiRsBQIkaQoBBSRmMF8yAgIkYQIkaQMJAGcCBQIkaQUCJHMFAiRhCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMjAJAQUkZjBfMgIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIJAQUkZjBfMQIFBSRhY2MwAAAAAQACAAMABAAFAAYABwAIAAkACgALAAwADQAOAA8AEAARABIAEwAUCQCUCgIFA25pbAUEZGF0YQFpARBlZGl0UGFpclNldHRpbmdzAg9jYWxsZXJQdWJsaWNLZXkEYXJncwQGY2hlY2tzCQDMCAIJAQttdXN0RmFjdG9yeQEIBQFpBmNhbGxlcgUDbmlsAwkAAAIFBmNoZWNrcwUGY2hlY2tzBAthbW91bnRBc3NldAkBDHBhcnNlQXNzZXRJZAEJAJEDAgUEYXJncwAABApwcmljZUFzc2V0CQEMcGFyc2VBc3NldElkAQkAkQMCBQRhcmdzAAEEBXByaWNlCQCRAwIFBGFyZ3MAAgQLbWF4TGV2ZXJhZ2UJAJEDAgUEYXJncwADBA1pbml0aWFsTWFyZ2luCQCRAwIFBGFyZ3MABAQRbWFpbnRlbmFuY2VNYXJnaW4JAJEDAgUEYXJncwAFBBFwYWlyUHJpY2VzTGlzdEtleQkBEmtQYWlyUHJpY2VzTGlzdEtleQIFC2Ftb3VudEFzc2V0BQpwcmljZUFzc2V0BAtzZXR0aW5nc0tleQkBEGtQYWlyU2V0dGluZ3NLZXkDBQthbW91bnRBc3NldAUKcHJpY2VBc3NldAUFcHJpY2UECnByaWNlc0xpc3QJARFnZXRQYWlyUHJpY2VzTGlzdAIFC2Ftb3VudEFzc2V0BQpwcmljZUFzc2V0BAduZXdMaXN0BAckbWF0Y2gwCQDPCAIFCnByaWNlc0xpc3QFBXByaWNlAwkAAQIFByRtYXRjaDACA0ludAQDaW5kBQckbWF0Y2gwBQpwcmljZXNMaXN0CQDNCAIFCnByaWNlc0xpc3QFBXByaWNlBAZjaGVjazIJAMwIAgkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQC2CQEFBXByaWNlCQEHd3JhcEVycgECGXByaWNlIHZhbHVlIGlzIG5vdCBhbiBJbnQJAMwIAgkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCBQttYXhMZXZlcmFnZQkBB3dyYXBFcnIBAh9tYXhMZXZlcmFnZSB2YWx1ZSBpcyBub3QgYW4gSW50CQDMCAIJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgUNaW5pdGlhbE1hcmdpbgkBB3dyYXBFcnIBAiFpbml0aWFsTWFyZ2luIHZhbHVlIGlzIG5vdCBhbiBJbnQJAMwIAgkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCBRFtYWludGVuYW5jZU1hcmdpbgkBB3dyYXBFcnIBAiVtYWludGVuYW5jZU1hcmdpbiB2YWx1ZSBpcyBub3QgYW4gSW50CQDMCAIDCQBnAgAUCQCQAwEFB25ld0xpc3QGCQEIdGhyb3dFcnIBAiJleGNlZWRlZCBtYXggcHJpY2VzIGxpc3Qgc2l6ZSAoMjApBQNuaWwDCQAAAgUGY2hlY2syBQZjaGVjazIEEHBhaXJTZXR0aW5nVmFsdWUJALkJAgkAzAgCAgYlcyVzJXMJAMwIAgULbWF4TGV2ZXJhZ2UJAMwIAgUNaW5pdGlhbE1hcmdpbgkAzAgCBRFtYWludGVuYW5jZU1hcmdpbgUDbmlsBQlzZXBhcmF0b3IEC2ludm9jYXRpb25zCQDMCAIJAPwHBAUOZmFjdG9yeUFkZHJlc3MCC3N0cmluZ0VudHJ5CQDMCAIJARJrUGFpclByaWNlc0xpc3RLZXkCBQthbW91bnRBc3NldAUKcHJpY2VBc3NldAkAzAgCCQC5CQIFB25ld0xpc3QFCXNlcGFyYXRvcgUDbmlsBQNuaWwJAMwIAgkA/AcEBQ5mYWN0b3J5QWRkcmVzcwILc3RyaW5nRW50cnkJAMwIAgkBEGtQYWlyU2V0dGluZ3NLZXkDBQthbW91bnRBc3NldAUKcHJpY2VBc3NldAUFcHJpY2UJAMwIAgUQcGFpclNldHRpbmdWYWx1ZQUDbmlsBQNuaWwFA25pbAkAlAoCBQNuaWwFC2ludm9jYXRpb25zCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAWkBEmRlbGV0ZVBhaXJTZXR0aW5ncwIPY2FsbGVyUHVibGljS2V5BGFyZ3MEBmNoZWNrcwkAzAgCCQELbXVzdEZhY3RvcnkBCAUBaQZjYWxsZXIFA25pbAMJAAACBQZjaGVja3MFBmNoZWNrcwQLYW1vdW50QXNzZXQJAQxwYXJzZUFzc2V0SWQBCQCRAwIFBGFyZ3MAAAQKcHJpY2VBc3NldAkBDHBhcnNlQXNzZXRJZAEJAJEDAgUEYXJncwABBAVwcmljZQkAkQMCBQRhcmdzAAIEC3NldHRpbmdzS2V5CQEQa1BhaXJTZXR0aW5nc0tleQMFC2Ftb3VudEFzc2V0BQpwcmljZUFzc2V0BQVwcmljZQQRcGFpclByaWNlc0xpc3RLZXkJARJrUGFpclByaWNlc0xpc3RLZXkCBQthbW91bnRBc3NldAUKcHJpY2VBc3NldAQKcHJpY2VzTGlzdAkBEWdldFBhaXJQcmljZXNMaXN0AgULYW1vdW50QXNzZXQFCnByaWNlQXNzZXQEB25ld0xpc3QEByRtYXRjaDAJAM8IAgUKcHJpY2VzTGlzdAUFcHJpY2UDCQABAgUHJG1hdGNoMAIDSW50BANpbmQFByRtYXRjaDAJANEIAgUKcHJpY2VzTGlzdAUDaW5kBQpwcmljZXNMaXN0BAtpbnZvY2F0aW9ucwkAzAgCCQD8BwQFDmZhY3RvcnlBZGRyZXNzAgtkZWxldGVFbnRyeQkAzAgCBQtzZXR0aW5nc0tleQUDbmlsBQNuaWwJAMwIAgMJAAACCQCQAwEFB25ld0xpc3QAAAkA/AcEBQ5mYWN0b3J5QWRkcmVzcwILZGVsZXRlRW50cnkJAMwIAgkBEmtQYWlyUHJpY2VzTGlzdEtleQIFC2Ftb3VudEFzc2V0BQpwcmljZUFzc2V0BQNuaWwFA25pbAkA/AcEBQ5mYWN0b3J5QWRkcmVzcwILc3RyaW5nRW50cnkJAMwIAgkBEmtQYWlyUHJpY2VzTGlzdEtleQIFC2Ftb3VudEFzc2V0BQpwcmljZUFzc2V0CQDMCAIJALkJAgUHbmV3TGlzdAUJc2VwYXJhdG9yBQNuaWwFA25pbAUDbmlsCQCUCgIFA25pbAULaW52b2NhdGlvbnMJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BAnR4AQZ2ZXJpZnkAAwMJAQlpc0RlZmluZWQBBRRmYWN0b3J5QWRkcmVzc09wdGlvbgkBCWlzRGVmaW5lZAEJAJ0IAgUOZmFjdG9yeUFkZHJlc3MFCWtNdWx0aXNpZwcEByRtYXRjaDAJAJ0IAgUOZmFjdG9yeUFkZHJlc3MFCWtNdWx0aXNpZwMJAAECBQckbWF0Y2gwAgZTdHJpbmcECG11bHRpc2lnBQckbWF0Y2gwBAlzdGF0dXNLZXkJAQdrU3RhdHVzAgkApQgBBQR0aGlzCQDYBAEIBQJ0eAJpZAQGc3RhdHVzCQELdmFsdWVPckVsc2UCCQCbCAIJARFAZXh0ck5hdGl2ZSgxMDYyKQEFCG11bHRpc2lnBQlzdGF0dXNLZXkHBQZzdGF0dXMHCQD0AwMIBQJ0eAlib2R5Qnl0ZXMJAJEDAggFAnR4BnByb29mcwAACAUCdHgPc2VuZGVyUHVibGljS2V56nvv0w==",
    "chainId": 84,
    "height": 3227011,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 9R9bHgYLUM8y4VnDoLJWivceefE4eaeEZU5Gprj5UsgD
Next: APBJm28T5c36uoZZ8EcAuo7gzaJcTAhvPSX37FDNZgjb

Diff: 

OldNewDifferences
412412             let amountToSend = if ((creditAvailable >= amountRequested))
413413                 then amountRequested
414414                 else throwErr(("credit available = " + toString(creditAvailable)))
415-            let factoryActions = [invoke(factoryAddress, "integerEntry", [kCredit(accountAddress, assetIdRequested), (valueOrElse(creditOption(accountAddress, assetIdRequested), 0) + amountToSend)], nil), invoke(factoryAddress, "transferAsset", [accountAddress, amountToSend, syntheticAssetId], nil)]
415+            let factoryActions = [invoke(factoryAddress, "integerEntry", [kCredit(accountAddress, assetIdRequested), (valueOrElse(creditOption(accountAddress, assetIdRequested), 0) + amountToSend)], nil), invoke(factoryAddress, "transferAsset", [accountAddress, amountToSend, assetIdToString(syntheticAssetId)], nil)]
416416             $Tuple2(nil, [factoryActions, creditAvailable])
417417             }
418418         else throw("Strict value is not equal to itself.")
459459                 else throwErr(("accounts limit is " + toString(accountsLimit())))]
460460             if ((checks == checks))
461461                 then {
462-                    let $t01823719770 = if ((size(accountsQueue()) == 0))
462+                    let $t01825519788 = if ((size(accountsQueue()) == 0))
463463                         then $Tuple2([ScriptTransfer(factoryAddress, rewardAmount(), unit)], [invoke(factoryAddress, "integerEntry", [kRequestStatus(requestId), REQUEST_STATUS_EMPTY], nil), invoke(factoryAddress, "binaryEntry", [kRequestsQueue(), (requestsQueue() + requestId)], nil), invoke(factoryAddress, "integerEntry", [kRequestLeverage(requestId), leverage], nil)])
464464                         else {
465465                             let accountPublicKey = take(accountsQueue(), queueItemSize)
467467                             let creatorAddress = addressFromPublicKey(valueOrErrorMessage(getBinary(factoryAddress, kAccountCreatorPublicKey(accountAddress)), wrapErr("invalid creator public key")))
468468                             $Tuple2([ScriptTransfer(creatorAddress, rewardAmount(), unit)], [invoke(factoryAddress, "binaryEntry", [kAccountsQueue(), drop(accountsQueue(), queueItemSize)], nil), invoke(factoryAddress, "integerEntry", [kRequestStatus(requestId), REQUEST_STATUS_READY], nil), invoke(factoryAddress, "binaryEntry", [kRequestIdToAccountPublicKey(requestId), accountPublicKey], nil), invoke(factoryAddress, "stringEntry", [kAccountAddressToRequestId(accountAddress), toBase58String(requestId)], nil), invoke(factoryAddress, "integerEntry", [kLeverage(accountAddress), leverage], nil)])
469469                             }
470-                    let actions = $t01823719770._1
471-                    let factoryActions = $t01823719770._2
470+                    let actions = $t01825519788._1
471+                    let factoryActions = $t01825519788._2
472472                     $Tuple2(actions, (factoryActions ++ [invoke(factoryAddress, "binaryEntry", [kRequestOwnerPublicKey(requestId), callerPublicKey], nil), invoke(factoryAddress, "binaryEntry", [kRequestsByOwner(userAddress), (requestsByOwner(userAddress) + requestId)], nil), invoke(factoryAddress, "stringEntry", [kRequestAmountAssetId(requestId), amountAssetIdStr], nil), invoke(factoryAddress, "stringEntry", [kRequestPriceAssetId(requestId), priceAssetIdStr], nil)]))
473473                     }
474474                 else throw("Strict value is not equal to itself.")
501501                 else throwErr("invalid script")]
502502             if ((checks == checks))
503503                 then {
504-                    let $t02102522266 = if ((size(requestsQueue()) == 0))
504+                    let $t02104322284 = if ((size(requestsQueue()) == 0))
505505                         then $Tuple2(nil, [invoke(factoryAddress, "binaryEntry", [kAccountsQueue(), (accountsQueue() + accountPublicKey)], nil)])
506506                         else {
507507                             let requestId = take(requestsQueue(), queueItemSize)
508508                             let leverage = valueOrErrorMessage(getInteger(factoryAddress, kRequestLeverage(requestId)), wrapErr("request's leverage is undefined"))
509509                             $Tuple2(nil, [invoke(factoryAddress, "integerEntry", [kRequestStatus(requestId), REQUEST_STATUS_READY], nil), invoke(factoryAddress, "binaryEntry", [kRequestIdToAccountPublicKey(requestId), accountPublicKey], nil), invoke(factoryAddress, "binaryEntry", [kRequestsQueue(), drop(requestsQueue(), queueItemSize)], nil), invoke(factoryAddress, "stringEntry", [kAccountAddressToRequestId(accountAddress), toBase58String(requestId)], nil), invoke(factoryAddress, "transferWaves", [creatorAddress.bytes, rewardAmount()], nil), invoke(factoryAddress, "integerEntry", [kLeverage(accountAddress), leverage], nil)])
510510                             }
511-                    let actions = $t02102522266._1
512-                    let factoryActions = $t02102522266._2
511+                    let actions = $t02104322284._1
512+                    let factoryActions = $t02104322284._2
513513                     $Tuple2(actions, (factoryActions ++ [invoke(factoryAddress, "binaryEntry", [kAccountCreatorPublicKey(accountAddress), creatorPublicKey], nil)]))
514514                     }
515515                 else throw("Strict value is not equal to itself.")
540540 
541541 @Callable(i)
542542 func deposit (callerPublicKey,args) = {
543-    let $t02328723360 = depositINTERNAL(callerPublicKey, args, i)
544-    let actions = $t02328723360._1
545-    let factoryActions = $t02328723360._2
543+    let $t02330523378 = depositINTERNAL(callerPublicKey, args, i)
544+    let actions = $t02330523378._1
545+    let factoryActions = $t02330523378._2
546546     $Tuple2(actions, factoryActions)
547547     }
548548 
550550 
551551 @Callable(i)
552552 func borrow (callerPublicKey,args) = {
553-    let $t02351523587 = borrowINTERNAL(callerPublicKey, args, i)
554-    let actions = $t02351523587._1
555-    let factoryActions = $t02351523587._2
553+    let $t02353323605 = borrowINTERNAL(callerPublicKey, args, i)
554+    let actions = $t02353323605._1
555+    let factoryActions = $t02353323605._2
556556     $Tuple2(actions, factoryActions)
557557     }
558558 
561561 @Callable(i)
562562 func depositAndBorrow (callerPublicKey,args) = {
563563     let accountAddress = args[0]
564-    let $t02378323882 = depositINTERNAL(callerPublicKey, [accountAddress], i)
565-    let depositActions = $t02378323882._1
566-    let depositFactoryActions = $t02378323882._2
567-    let $t02388523969 = borrowINTERNAL(callerPublicKey, args, i)
568-    let borrowActions = $t02388523969._1
569-    let borrowFactoryActions = $t02388523969._2
564+    let $t02380123900 = depositINTERNAL(callerPublicKey, [accountAddress], i)
565+    let depositActions = $t02380123900._1
566+    let depositFactoryActions = $t02380123900._2
567+    let $t02390323987 = borrowINTERNAL(callerPublicKey, args, i)
568+    let borrowActions = $t02390323987._1
569+    let borrowFactoryActions = $t02390323987._2
570570     $Tuple2((depositActions ++ borrowActions), (depositFactoryActions ++ borrowFactoryActions))
571571     }
572572 
662662             let userRequests = valueOrElse(getBinary(factoryAddress, kRequestsByOwner(userAddress)), base58'')
663663             let userRequestsNumber = (size(userRequests) / queueItemSize)
664664             func getAccountsData (acc,count) =             {
665-                let $t02690226944 = acc
666-                let accDataList = $t02690226944._1
667-                let rawBytes = $t02690226944._2
668-                let maxSize = $t02690226944._3
665+                let $t02692026962 = acc
666+                let accDataList = $t02692026962._1
667+                let rawBytes = $t02692026962._2
668+                let maxSize = $t02692026962._3
669669                 if ((maxSize > count))
670670                     then {
671671                         let requestId = take(rawBytes, queueItemSize)
678678                     else acc
679679                 }
680680 
681-            let $t02744827553 = {
681+            let $t02746627571 = {
682682                 let $l = INDEX_LIST
683683                 let $s = size($l)
684684                 let $acc0 = $Tuple3(nil, userRequests, userRequestsNumber)
692692 
693693                 $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20)
694694                 }
695-            let accDataList = $t02744827553._1
696-            let _a = $t02744827553._2
697-            let _b = $t02744827553._3
695+            let accDataList = $t02746627571._1
696+            let _a = $t02746627571._2
697+            let _b = $t02746627571._3
698698             $Tuple2(nil, accDataList)
699699             }
700700         else throw("Strict value is not equal to itself.")

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 7 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let separator = "__"
55 
66 let chainId = take(drop(this.bytes, 1), 1)
77 
88 let chainIdW = base58'2W'
99 
1010 let contractFilename = "futures_calculator.ride"
1111 
1212 let mult8 = 100000000
1313 
1414 let mult18BigInt = toBigInt(1000000000000000000)
1515 
1616 let wavesDecimals = 8
1717 
1818 let usdtDecimals = 6
1919 
2020 let wavesString = "WAVES"
2121 
2222 let queueItemSize = 32
2323 
2424 let big0 = toBigInt(0)
2525 
2626 let INDEX_LIST = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
2727 
2828 let kMultisig = "%s__multisig"
2929 
3030 func kStatus (dapp,txId) = makeString(["%s__status", dapp, txId], separator)
3131 
3232 
3333 let kShutdown = "%s__shutdown"
3434 
3535 let kPublicKeys = "%s__publicKeys"
3636 
3737 let kMatcherPublicKey = "%s__matcherPublicKey"
3838 
3939 func toX18 (origVal,origScaleMult) = fraction(toBigInt(origVal), mult18BigInt, toBigInt(origScaleMult))
4040 
4141 
4242 func fromX18 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), mult18BigInt))
4343 
4444 
4545 func validateAddress (address) = isDefined(addressFromString(address))
4646 
4747 
4848 func wrapErr (s) = ((contractFilename + ": ") + s)
4949 
5050 
5151 func throwErr (s) = throw(wrapErr(s))
5252 
5353 
5454 func ensurePositive (v,s) = if ((v >= 0))
5555     then v
5656     else throwErr((s + " value should be positive"))
5757 
5858 
5959 func parseAssetId (input) = if ((input == wavesString))
6060     then unit
6161     else fromBase58String(input)
6262 
6363 
6464 func assetIdToString (input) = if ((input == unit))
6565     then wavesString
6666     else toBase58String(value(input))
6767 
6868 
6969 func getAssetInfoOrFail (assetId) = valueOrErrorMessage(assetInfo(assetId), wrapErr("invalid asset info"))
7070 
7171 
7272 func getAssetDecimalsOrFail (assetId) = match assetId {
7373     case _: Unit => 
7474         wavesDecimals
7575     case assetId: ByteVector => 
7676         getAssetInfoOrFail(assetId).decimals
7777     case _ => 
7878         throw("Match error")
7979 }
8080 
8181 
8282 func getAssetBalance (assetId,address) = match assetId {
8383     case _: Unit => 
8484         wavesBalance(address).available
8585     case assetId: ByteVector => 
8686         assetBalance(address, assetId)
8787     case _ => 
8888         throw("Match error")
8989 }
9090 
9191 
9292 func pow10 (n) = pow(10, 0, n, 0, 0, DOWN)
9393 
9494 
9595 func pow10Decimals (assetId) = pow10(getAssetDecimalsOrFail(assetId))
9696 
9797 
9898 let kFactoryAddress = "%s__factoryAddress"
9999 
100100 let factoryAddressOption = match getString(this, kFactoryAddress) {
101101     case s: String => 
102102         addressFromString(s)
103103     case _: Unit => 
104104         unit
105105     case _ => 
106106         throw("Match error")
107107 }
108108 
109109 let factoryAddress = valueOrErrorMessage(factoryAddressOption, wrapErr("invalid factory address"))
110110 
111111 let kUsdtAssetId = "%s__usdtAssetId"
112112 
113113 let usdtAssetIdOption = match getString(factoryAddress, kUsdtAssetId) {
114114     case s: String => 
115115         parseAssetId(s)
116116     case _: Unit => 
117117         unit
118118     case _ => 
119119         throw("Match error")
120120 }
121121 
122122 let usdtAssetId = valueOrErrorMessage(usdtAssetIdOption, wrapErr("invalid usdt asset id"))
123123 
124124 let kPricesAddress = "%s__calculatorAddress"
125125 
126126 let shutdown = valueOrElse(getBoolean(factoryAddress, kShutdown), false)
127127 
128128 func mustAddress (caller,address) = if ((caller == address))
129129     then true
130130     else throwErr("permission denied")
131131 
132132 
133133 func mustThis (caller) = mustAddress(caller, this)
134134 
135135 
136136 func mustFactory (caller) = mustAddress(caller, factoryAddress)
137137 
138138 
139139 func mustAdmin (callerPublicKey) = {
140140     let multisig = addressFromStringValue(getStringValue(factoryAddress, kMultisig))
141141     let publicKeysList = split(getStringValue(multisig, kPublicKeys), separator)
142142     if (containsElement(publicKeysList, toBase58String(callerPublicKey)))
143143         then true
144144         else throwErr("not allowed")
145145     }
146146 
147147 
148148 let kAccountScript = "%s__accountScript"
149149 
150150 func accountScript () = valueOrErrorMessage(getBinary(factoryAddress, kAccountScript), wrapErr("account script is not set"))
151151 
152152 
153153 let kRewardAmount = "%s__rewardAmount"
154154 
155155 func rewardAmount () = valueOrErrorMessage(getInteger(factoryAddress, kRewardAmount), wrapErr("reward amount is not set"))
156156 
157157 
158158 let kAccountsLimit = "%s__accountsLimit"
159159 
160160 let accountsLimitDefault = 20
161161 
162162 func accountsLimit () = valueOrElse(getInteger(factoryAddress, kAccountsLimit), accountsLimitDefault)
163163 
164164 
165165 func kDeposited (accountAddress) = makeString(["%s%s", "deposited", toString(accountAddress)], separator)
166166 
167167 
168168 func depositedOption (accountAddress) = getInteger(factoryAddress, kDeposited(accountAddress))
169169 
170170 
171171 func kCredit (accountAddress,assetId) = makeString(["%s%s%s", "credit", toString(accountAddress), assetIdToString(assetId)], separator)
172172 
173173 
174174 func creditOption (accountAddress,assetId) = getInteger(factoryAddress, kCredit(accountAddress, assetId))
175175 
176176 
177177 func kLeverage (accountAddress) = makeString(["%s%s", "leverage", toString(accountAddress)], separator)
178178 
179179 
180180 func kRequestLeverage (requestId) = makeString(["%s%s", "requestLeverage", toBase58String(requestId)], separator)
181181 
182182 
183183 func kSyntheticAssetId (baseAssetId) = makeString(["%s%s", "syntheticAssetId", assetIdToString(baseAssetId)], separator)
184184 
185185 
186186 func kBaseAssetId (syntheticAssetId) = makeString(["%s%s", "baseAssetId", assetIdToString(syntheticAssetId)], separator)
187187 
188188 
189189 let REQUEST_STATUS_EMPTY = 0
190190 
191191 let REQUEST_STATUS_READY = 1
192192 
193193 func kRequestStatus (requestId) = makeString(["%s%s", toBase58String(requestId), "status"], separator)
194194 
195195 
196196 func kAccountCreatorPublicKey (accountAddress) = makeString(["%s%s", toString(accountAddress), "creatorPublicKey"], separator)
197197 
198198 
199199 func kRequestOwnerPublicKey (requestId) = makeString(["%s%s", toBase58String(requestId), "ownerPublicKey"], separator)
200200 
201201 
202202 func kRequestAmountAssetId (requestId) = makeString(["%s%s", toBase58String(requestId), "amountAssetId"], separator)
203203 
204204 
205205 func kRequestPriceAssetId (requestId) = makeString(["%s%s", toBase58String(requestId), "priceAssetId"], separator)
206206 
207207 
208208 func kRequestIdToAccountPublicKey (requestId) = makeString(["%s%s", toBase58String(requestId), "requestIdToAccountPublicKey"], separator)
209209 
210210 
211211 func kAccountAddressToRequestId (accountAddress) = makeString(["%s%s", toString(accountAddress), "accountAddressToRequestId"], separator)
212212 
213213 
214214 func kRequestsQueue () = makeString(["%s", "requestsQueue"], separator)
215215 
216216 
217217 func requestsQueue () = valueOrElse(getBinary(factoryAddress, kRequestsQueue()), base58'')
218218 
219219 
220220 func kAccountsQueue () = makeString(["%s", "accountsQueue"], separator)
221221 
222222 
223223 func accountsQueue () = valueOrElse(getBinary(factoryAddress, kAccountsQueue()), base58'')
224224 
225225 
226226 func kRequestsByOwner (ownerAddress) = makeString(["%s%s", "requests", toString(ownerAddress)], separator)
227227 
228228 
229229 func requestsByOwner (ownerAddress) = valueOrElse(getBinary(factoryAddress, kRequestsByOwner(ownerAddress)), base58'')
230230 
231231 
232232 func kPairAllowed (amountAssetId,priceAssetId) = makeString(["%s%s%s", assetIdToString(amountAssetId), assetIdToString(priceAssetId), "pairAllowed"], separator)
233233 
234234 
235235 func pairAllowed (amountAssetId,priceAssetId) = valueOrElse(getBoolean(factoryAddress, kPairAllowed(amountAssetId, priceAssetId)), false)
236236 
237237 
238238 func kPrice (assetId) = makeString(["%s", assetIdToString(assetId)], separator)
239239 
240240 
241241 func kPairPricesListKey (amountAssetId,priceAssetId) = makeString(["%s%s%s", assetIdToString(amountAssetId), assetIdToString(priceAssetId), "pairSettingPrices"], separator)
242242 
243243 
244244 func getPairPricesList (amountAssetId,priceAssetId) = match getString(factoryAddress, kPairPricesListKey(amountAssetId, priceAssetId)) {
245245     case s: String => 
246246         split(s, separator)
247247     case _ => 
248248         nil
249249 }
250250 
251251 
252252 func kPairSettingsKey (amountAssetId,priceAssetId,priceString) = makeString(["%s%s%d%s", assetIdToString(amountAssetId), assetIdToString(priceAssetId), priceString, "settings"], separator)
253253 
254254 
255255 func getCurrentPrice (assetId) = {
256256     let matcherPublicKey = fromBase58String(valueOrErrorMessage(getString(factoryAddress, kMatcherPublicKey), wrapErr("invalid matcher public key")))
257257     let matcherAddress = addressFromPublicKey(matcherPublicKey)
258258     let price = valueOrErrorMessage(getInteger(matcherAddress, kPrice(assetId)), wrapErr(("invalid price, assetId = " + assetIdToString(assetId))))
259259     price
260260     }
261261 
262262 
263263 func calcTotalCredit (creditA,creditB,currentPrice) = (fraction(creditA, currentPrice, mult18BigInt) + creditB)
264264 
265265 
266266 func calcTotalBalance (balanceA,balanceB,currentPrice) = (fraction(balanceA, currentPrice, mult18BigInt) + balanceB)
267267 
268268 
269269 func calcPnl (totalBalance,totalCredit) = (totalBalance - totalCredit)
270270 
271271 
272272 func calcCreditAvailable (deposit,leverage,totalCredit) = (fraction(deposit, leverage, mult18BigInt) - totalCredit)
273273 
274274 
275275 func calcRealInCredit (credit,balance) = if ((credit > big0))
276276     then (credit - balance)
277277     else big0
278278 
279279 
280280 func calcFree (credit,balance) = if ((credit > big0))
281281     then (balance - credit)
282282     else big0
283283 
284284 
285285 func calcShortPrice (free,realInCredit) = if ((realInCredit > big0))
286286     then max([big0, fraction(free, mult18BigInt, realInCredit)])
287287     else big0
288288 
289289 
290290 func calcLongPrice (free,realInCredit) = if ((realInCredit > big0))
291291     then max([big0, fraction(realInCredit, mult18BigInt, free)])
292292     else big0
293293 
294294 
295295 func calcStartMargin (realInCreditA,realInCreditB,currentPrice,settingsMargin) = fraction((fraction(realInCreditA, currentPrice, mult18BigInt) + realInCreditB), settingsMargin, mult18BigInt)
296296 
297297 
298298 func calcMarginSupply (settingsMarginSupply,settingsMargin,startMargin) = fraction(settingsMarginSupply, startMargin, settingsMargin)
299299 
300300 
301301 func calcLiquidationPrice (deposit,marginSupply,realInCreditA,realInCreditB,shortPrice,longPrice) = {
302302     let liquidationPriceA = if ((realInCreditA > big0))
303303         then (((deposit - marginSupply) / realInCreditA) + shortPrice)
304304         else big0
305305     let liquidationPriceB = if ((realInCreditB > big0))
306306         then (longPrice - ((deposit - marginSupply) / (realInCreditA / longPrice)))
307307         else big0
308308     (liquidationPriceA + liquidationPriceB)
309309     }
310310 
311311 
312312 func getRequestId (accountAddress) = {
313313     let requestId = fromBase58String(valueOrErrorMessage(getString(factoryAddress, kAccountAddressToRequestId(accountAddress)), wrapErr("invalid account address: request id is undefined")))
314314     requestId
315315     }
316316 
317317 
318318 func getAccountAssets (accountAddress) = {
319319     let requestId = getRequestId(accountAddress)
320320     let amountAssetId = parseAssetId(valueOrErrorMessage(getString(factoryAddress, kRequestAmountAssetId(requestId)), wrapErr("invalid amount asset id")))
321321     let priceAssetId = parseAssetId(valueOrErrorMessage(getString(factoryAddress, kRequestPriceAssetId(requestId)), wrapErr("invalid amount price id")))
322322     $Tuple2(amountAssetId, priceAssetId)
323323     }
324324 
325325 
326326 func getAccountOwnerPublicKey (accountAddress) = {
327327     let requestId = getRequestId(accountAddress)
328328     let requestOwnerPublicKey = valueOrErrorMessage(getBinary(factoryAddress, kRequestOwnerPublicKey(requestId)), wrapErr("invalid amount asset id"))
329329     requestOwnerPublicKey
330330     }
331331 
332332 
333333 func getAccountInfoInternal (accountAddress) = {
334334     let $t01118711255 = getAccountAssets(accountAddress)
335335     let amountAssetId = $t01118711255._1
336336     let priceAssetId = $t01118711255._2
337337     let leverage = valueOrErrorMessage(getInteger(factoryAddress, kLeverage(accountAddress)), wrapErr("leverage should be defined"))
338338     let requestId = getRequestId(accountAddress)
339339     let accountPublicKey = valueOrErrorMessage(getBinary(factoryAddress, kRequestIdToAccountPublicKey(requestId)), "kRequestIdToAccountPublicKey not found")
340340     let deposited = valueOrElse(depositedOption(accountAddress), 0)
341341     let currentPrice = toX18(getCurrentPrice(amountAssetId), pow10Decimals(priceAssetId))
342342     let creditA = valueOrElse(getInteger(factoryAddress, kCredit(accountAddress, amountAssetId)), 0)
343343     let creditB = valueOrElse(getInteger(factoryAddress, kCredit(accountAddress, priceAssetId)), 0)
344344     let status = valueOrErrorMessage(getInteger(factoryAddress, kRequestStatus(requestId)), ("status not found. RequestId = " + toBase58String(requestId)))
345345     let synthAmountAssetId = getString(factoryAddress, kSyntheticAssetId(amountAssetId))
346346     let synthAmountAssetBalance =     match synthAmountAssetId {
347347         case s: String => 
348348             getAssetBalance(parseAssetId(s), accountAddress)
349349         case _ => 
350350             0
351351     }
352352     let synthPriceAssetId = getString(factoryAddress, kSyntheticAssetId(priceAssetId))
353353     let synthPriceAssetBalance =     match synthPriceAssetId {
354354         case s: String => 
355355             getAssetBalance(parseAssetId(s), accountAddress)
356356         case _ => 
357357             0
358358     }
359359     $Tuple12(assetIdToString(amountAssetId), assetIdToString(priceAssetId), toString(accountAddress), toBase58String(accountPublicKey), leverage, toBase58String(requestId), deposited, creditA, creditB, synthAmountAssetBalance, synthPriceAssetBalance, status)
360360     }
361361 
362362 
363363 func depositINTERNAL (callerPublicKey,args,i) = {
364364     let payment = i.payments[0]
365365     let accountAddress = valueOrErrorMessage(addressFromString(args[0]), wrapErr("invalid account address"))
366366     let ckecks = [if (!(shutdown))
367367         then true
368368         else throwErr("not allowed"), mustFactory(i.caller), if ((size(i.payments) == 1))
369369         then true
370370         else throwErr("1 payment is required"), if ((payment.assetId == usdtAssetId))
371371         then true
372372         else throwErr("invalid asset"), if ((getInteger(factoryAddress, kRequestStatus(getRequestId(accountAddress))) == REQUEST_STATUS_READY))
373373         then true
374374         else throwErr("account is not ready")]
375375     if ((ckecks == ckecks))
376376         then {
377377             let actions = [ScriptTransfer(accountAddress, payment.amount, payment.assetId)]
378378             let factoryActions = [invoke(factoryAddress, "integerEntry", [kDeposited(accountAddress), (valueOrElse(depositedOption(accountAddress), 0) + payment.amount)], nil)]
379379             $Tuple2(actions, factoryActions)
380380             }
381381         else throw("Strict value is not equal to itself.")
382382     }
383383 
384384 
385385 func borrowINTERNAL (callerPublicKey,args,i) = {
386386     let accountAddress = valueOrErrorMessage(addressFromString(args[0]), wrapErr("invalid account address"))
387387     let assetIdRequested = parseAssetId(args[1])
388388     let amountRequested = ensurePositive(valueOrErrorMessage(parseInt(args[2]), wrapErr("invalid requested amount")), "requested amount")
389389     let accountOwnerPublicKey = getAccountOwnerPublicKey(accountAddress)
390390     let userAddress = addressFromPublicKey(callerPublicKey)
391391     let ckecks = [if (!(shutdown))
392392         then true
393393         else throwErr("not allowed"), mustFactory(i.caller), if ((callerPublicKey == accountOwnerPublicKey))
394394         then true
395395         else throwErr("can be called by account owner only")]
396396     if ((ckecks == ckecks))
397397         then {
398398             let amountAssetId = getAccountAssets(accountAddress)._1
399399             let deposited = toX18(valueOrElse(depositedOption(accountAddress), 0), pow10Decimals(usdtAssetId))
400400             let currentPrice = toX18(getCurrentPrice(amountAssetId), pow10Decimals(usdtAssetId))
401401             let creditA = toX18(valueOrElse(getInteger(factoryAddress, kCredit(accountAddress, amountAssetId)), 0), pow10Decimals(amountAssetId))
402402             let creditB = toX18(valueOrElse(getInteger(factoryAddress, kCredit(accountAddress, usdtAssetId)), 0), pow10Decimals(usdtAssetId))
403403             let totalCredit = calcTotalCredit(creditA, creditB, currentPrice)
404404             let leverage = toX18(valueOrErrorMessage(getInteger(factoryAddress, kLeverage(accountAddress)), wrapErr("leverage should be defined")), 1)
405405             let creditAvailableUsdt = calcCreditAvailable(deposited, leverage, totalCredit)
406406             let creditAvailable = if ((assetIdRequested == amountAssetId))
407407                 then fromX18(fraction(creditAvailableUsdt, mult18BigInt, currentPrice), pow10Decimals(amountAssetId))
408408                 else if ((assetIdRequested == usdtAssetId))
409409                     then fromX18(creditAvailableUsdt, pow10Decimals(usdtAssetId))
410410                     else throwErr("invalid requested asset id")
411411             let syntheticAssetId = parseAssetId(valueOrErrorMessage(getString(factoryAddress, kSyntheticAssetId(assetIdRequested)), wrapErr("synthetic asset for requested asset is undefined")))
412412             let amountToSend = if ((creditAvailable >= amountRequested))
413413                 then amountRequested
414414                 else throwErr(("credit available = " + toString(creditAvailable)))
415-            let factoryActions = [invoke(factoryAddress, "integerEntry", [kCredit(accountAddress, assetIdRequested), (valueOrElse(creditOption(accountAddress, assetIdRequested), 0) + amountToSend)], nil), invoke(factoryAddress, "transferAsset", [accountAddress, amountToSend, syntheticAssetId], nil)]
415+            let factoryActions = [invoke(factoryAddress, "integerEntry", [kCredit(accountAddress, assetIdRequested), (valueOrElse(creditOption(accountAddress, assetIdRequested), 0) + amountToSend)], nil), invoke(factoryAddress, "transferAsset", [accountAddress, amountToSend, assetIdToString(syntheticAssetId)], nil)]
416416             $Tuple2(nil, [factoryActions, creditAvailable])
417417             }
418418         else throw("Strict value is not equal to itself.")
419419     }
420420 
421421 
422422 @Callable(i)
423423 func init (factoryAddressStr) = {
424424     let checkCaller = mustThis(i.caller)
425425     if ((checkCaller == checkCaller))
426426         then $Tuple2([StringEntry(kFactoryAddress, factoryAddressStr)], unit)
427427         else throw("Strict value is not equal to itself.")
428428     }
429429 
430430 
431431 
432432 @Callable(i)
433433 func requestAccount (callerPublicKey,args) = {
434434     let ckecks = [if (!(shutdown))
435435         then true
436436         else throwErr("not allowed"), mustFactory(i.caller)]
437437     if ((ckecks == ckecks))
438438         then {
439439             let amountAssetIdStr = args[0]
440440             let priceAssetIdStr = args[1]
441441             let leverage = valueOrErrorMessage(parseInt(args[2]), wrapErr("invalid leverage"))
442442             let userAddress = addressFromPublicKey(callerPublicKey)
443443             let requestId = sha256(((userAddress.bytes + fromBase58String(amountAssetIdStr)) + fromBase58String(priceAssetIdStr)))
444444             let amountAssetId = parseAssetId(amountAssetIdStr)
445445             let priceAssetId = parseAssetId(priceAssetIdStr)
446446             let userRequestsNumber = (size(kRequestsByOwner(userAddress)) / queueItemSize)
447447             let checks = [if ((size(i.payments) == 1))
448448                 then true
449449                 else throwErr("1 payment is required"), if ((i.payments[0].assetId == unit))
450450                 then true
451451                 else throwErr("invalid asset"), if ((i.payments[0].amount == rewardAmount()))
452452                 then true
453453                 else throwErr("invalid amount"), if (pairAllowed(amountAssetId, priceAssetId))
454454                 then true
455455                 else throwErr("pair is not allowed"), if ((getInteger(factoryAddress, kRequestStatus(requestId)) == unit))
456456                 then true
457457                 else throwErr("account is already exists"), if ((accountsLimit() > userRequestsNumber))
458458                 then true
459459                 else throwErr(("accounts limit is " + toString(accountsLimit())))]
460460             if ((checks == checks))
461461                 then {
462-                    let $t01823719770 = if ((size(accountsQueue()) == 0))
462+                    let $t01825519788 = if ((size(accountsQueue()) == 0))
463463                         then $Tuple2([ScriptTransfer(factoryAddress, rewardAmount(), unit)], [invoke(factoryAddress, "integerEntry", [kRequestStatus(requestId), REQUEST_STATUS_EMPTY], nil), invoke(factoryAddress, "binaryEntry", [kRequestsQueue(), (requestsQueue() + requestId)], nil), invoke(factoryAddress, "integerEntry", [kRequestLeverage(requestId), leverage], nil)])
464464                         else {
465465                             let accountPublicKey = take(accountsQueue(), queueItemSize)
466466                             let accountAddress = addressFromPublicKey(accountPublicKey)
467467                             let creatorAddress = addressFromPublicKey(valueOrErrorMessage(getBinary(factoryAddress, kAccountCreatorPublicKey(accountAddress)), wrapErr("invalid creator public key")))
468468                             $Tuple2([ScriptTransfer(creatorAddress, rewardAmount(), unit)], [invoke(factoryAddress, "binaryEntry", [kAccountsQueue(), drop(accountsQueue(), queueItemSize)], nil), invoke(factoryAddress, "integerEntry", [kRequestStatus(requestId), REQUEST_STATUS_READY], nil), invoke(factoryAddress, "binaryEntry", [kRequestIdToAccountPublicKey(requestId), accountPublicKey], nil), invoke(factoryAddress, "stringEntry", [kAccountAddressToRequestId(accountAddress), toBase58String(requestId)], nil), invoke(factoryAddress, "integerEntry", [kLeverage(accountAddress), leverage], nil)])
469469                             }
470-                    let actions = $t01823719770._1
471-                    let factoryActions = $t01823719770._2
470+                    let actions = $t01825519788._1
471+                    let factoryActions = $t01825519788._2
472472                     $Tuple2(actions, (factoryActions ++ [invoke(factoryAddress, "binaryEntry", [kRequestOwnerPublicKey(requestId), callerPublicKey], nil), invoke(factoryAddress, "binaryEntry", [kRequestsByOwner(userAddress), (requestsByOwner(userAddress) + requestId)], nil), invoke(factoryAddress, "stringEntry", [kRequestAmountAssetId(requestId), amountAssetIdStr], nil), invoke(factoryAddress, "stringEntry", [kRequestPriceAssetId(requestId), priceAssetIdStr], nil)]))
473473                     }
474474                 else throw("Strict value is not equal to itself.")
475475             }
476476         else throw("Strict value is not equal to itself.")
477477     }
478478 
479479 
480480 
481481 @Callable(i)
482482 func addAccount (callerPublicKey,args) = {
483483     let ckecks = [if (!(shutdown))
484484         then true
485485         else throwErr("not allowed"), mustFactory(i.caller)]
486486     if ((ckecks == ckecks))
487487         then {
488488             let creatorPublicKey = fromBase58String(args[0])
489489             let accountPublicKey = callerPublicKey
490490             let accountAddress = addressFromPublicKey(callerPublicKey)
491491             let creatorAddress = addressFromPublicKey(creatorPublicKey)
492492             let checks = [if ((getBinary(factoryAddress, kAccountCreatorPublicKey(accountAddress)) == unit))
493493                 then true
494494                 else throwErr("account is already exists"), if (            match scriptHash(accountAddress) {
495495                 case b: ByteVector => 
496496                     (b == blake2b256_32Kb(accountScript()))
497497                 case _ => 
498498                     false
499499             })
500500                 then true
501501                 else throwErr("invalid script")]
502502             if ((checks == checks))
503503                 then {
504-                    let $t02102522266 = if ((size(requestsQueue()) == 0))
504+                    let $t02104322284 = if ((size(requestsQueue()) == 0))
505505                         then $Tuple2(nil, [invoke(factoryAddress, "binaryEntry", [kAccountsQueue(), (accountsQueue() + accountPublicKey)], nil)])
506506                         else {
507507                             let requestId = take(requestsQueue(), queueItemSize)
508508                             let leverage = valueOrErrorMessage(getInteger(factoryAddress, kRequestLeverage(requestId)), wrapErr("request's leverage is undefined"))
509509                             $Tuple2(nil, [invoke(factoryAddress, "integerEntry", [kRequestStatus(requestId), REQUEST_STATUS_READY], nil), invoke(factoryAddress, "binaryEntry", [kRequestIdToAccountPublicKey(requestId), accountPublicKey], nil), invoke(factoryAddress, "binaryEntry", [kRequestsQueue(), drop(requestsQueue(), queueItemSize)], nil), invoke(factoryAddress, "stringEntry", [kAccountAddressToRequestId(accountAddress), toBase58String(requestId)], nil), invoke(factoryAddress, "transferWaves", [creatorAddress.bytes, rewardAmount()], nil), invoke(factoryAddress, "integerEntry", [kLeverage(accountAddress), leverage], nil)])
510510                             }
511-                    let actions = $t02102522266._1
512-                    let factoryActions = $t02102522266._2
511+                    let actions = $t02104322284._1
512+                    let factoryActions = $t02104322284._2
513513                     $Tuple2(actions, (factoryActions ++ [invoke(factoryAddress, "binaryEntry", [kAccountCreatorPublicKey(accountAddress), creatorPublicKey], nil)]))
514514                     }
515515                 else throw("Strict value is not equal to itself.")
516516             }
517517         else throw("Strict value is not equal to itself.")
518518     }
519519 
520520 
521521 
522522 @Callable(i)
523523 func withdraw (callerPublicKey,args) = {
524524     let checks = [if (!(shutdown))
525525         then true
526526         else throwErr("not allowed"), mustFactory(i.caller)]
527527     if ((checks == checks))
528528         then {
529529             let userAddress = addressFromPublicKey(callerPublicKey)
530530             let accountAddress = valueOrErrorMessage(addressFromString(args[0]), wrapErr("invalid account address"))
531531             let amount = valueOrErrorMessage(parseInt(args[1]), wrapErr("invalid amount"))
532532             let assetId = parseAssetId(args[2])
533533             let invocations = [invoke(accountAddress, "transferAsset", [userAddress.bytes, amount, assetId], nil)]
534534             $Tuple2(nil, invocations)
535535             }
536536         else throw("Strict value is not equal to itself.")
537537     }
538538 
539539 
540540 
541541 @Callable(i)
542542 func deposit (callerPublicKey,args) = {
543-    let $t02328723360 = depositINTERNAL(callerPublicKey, args, i)
544-    let actions = $t02328723360._1
545-    let factoryActions = $t02328723360._2
543+    let $t02330523378 = depositINTERNAL(callerPublicKey, args, i)
544+    let actions = $t02330523378._1
545+    let factoryActions = $t02330523378._2
546546     $Tuple2(actions, factoryActions)
547547     }
548548 
549549 
550550 
551551 @Callable(i)
552552 func borrow (callerPublicKey,args) = {
553-    let $t02351523587 = borrowINTERNAL(callerPublicKey, args, i)
554-    let actions = $t02351523587._1
555-    let factoryActions = $t02351523587._2
553+    let $t02353323605 = borrowINTERNAL(callerPublicKey, args, i)
554+    let actions = $t02353323605._1
555+    let factoryActions = $t02353323605._2
556556     $Tuple2(actions, factoryActions)
557557     }
558558 
559559 
560560 
561561 @Callable(i)
562562 func depositAndBorrow (callerPublicKey,args) = {
563563     let accountAddress = args[0]
564-    let $t02378323882 = depositINTERNAL(callerPublicKey, [accountAddress], i)
565-    let depositActions = $t02378323882._1
566-    let depositFactoryActions = $t02378323882._2
567-    let $t02388523969 = borrowINTERNAL(callerPublicKey, args, i)
568-    let borrowActions = $t02388523969._1
569-    let borrowFactoryActions = $t02388523969._2
564+    let $t02380123900 = depositINTERNAL(callerPublicKey, [accountAddress], i)
565+    let depositActions = $t02380123900._1
566+    let depositFactoryActions = $t02380123900._2
567+    let $t02390323987 = borrowINTERNAL(callerPublicKey, args, i)
568+    let borrowActions = $t02390323987._1
569+    let borrowFactoryActions = $t02390323987._2
570570     $Tuple2((depositActions ++ borrowActions), (depositFactoryActions ++ borrowFactoryActions))
571571     }
572572 
573573 
574574 
575575 @Callable(i)
576576 func repay (callerPublicKey,args) = {
577577     let ckecks = [if (!(shutdown))
578578         then true
579579         else throwErr("not allowed"), mustFactory(i.caller)]
580580     if ((ckecks == ckecks))
581581         then $Tuple2(nil, unit)
582582         else throw("Strict value is not equal to itself.")
583583     }
584584 
585585 
586586 
587587 @Callable(i)
588588 func setPairAllowance (callerPublicKey,args) = {
589589     let ckecks = [if (!(shutdown))
590590         then true
591591         else throwErr("not allowed"), mustFactory(i.caller), mustAdmin(callerPublicKey)]
592592     if ((ckecks == ckecks))
593593         then {
594594             let amountAssetIdStr = args[0]
595595             let priceAssetIdStr = args[1]
596596             let allowStr = args[2]
597597             let amountAssetId = parseAssetId(amountAssetIdStr)
598598             let priceAssetId = parseAssetId(priceAssetIdStr)
599599             let allow = (allowStr == "true")
600600             let invocations = [invoke(factoryAddress, "booleanEntry", [kPairAllowed(amountAssetId, priceAssetId), allow], nil)]
601601             $Tuple2(nil, invocations)
602602             }
603603         else throw("Strict value is not equal to itself.")
604604     }
605605 
606606 
607607 
608608 @Callable(i)
609609 func addSyntheticAsset (callerPublicKey,args) = {
610610     let baseAssetId = parseAssetId(args[0])
611611     let syntheticAssetId = parseAssetId(args[1])
612612     let ckecks = [if (!(shutdown))
613613         then true
614614         else throwErr("not allowed"), mustFactory(i.caller), mustAdmin(callerPublicKey), if ((getString(factoryAddress, kSyntheticAssetId(baseAssetId)) == unit))
615615         then true
616616         else throwErr("invalid base asset"), if ((getString(factoryAddress, kBaseAssetId(syntheticAssetId)) == unit))
617617         then true
618618         else throwErr("invalid synthetic asset")]
619619     if ((ckecks == ckecks))
620620         then {
621621             let invocations = [invoke(factoryAddress, "stringEntry", [kSyntheticAssetId(baseAssetId), assetIdToString(syntheticAssetId)], nil), invoke(factoryAddress, "stringEntry", [kBaseAssetId(syntheticAssetId), assetIdToString(baseAssetId)], nil)]
622622             $Tuple2(nil, invocations)
623623             }
624624         else throw("Strict value is not equal to itself.")
625625     }
626626 
627627 
628628 
629629 @Callable(i)
630630 func doShutdown (callerPublicKey,args) = {
631631     let checks = [mustFactory(i.caller), mustAdmin(callerPublicKey)]
632632     if ((checks == checks))
633633         then {
634634             let invocations = [invoke(factoryAddress, "booleanEntry", [kShutdown, true], nil)]
635635             $Tuple2(nil, invocations)
636636             }
637637         else throw("Strict value is not equal to itself.")
638638     }
639639 
640640 
641641 
642642 @Callable(i)
643643 func getAccountInfoREADONLY (callerPublicKey,args) = {
644644     let checks = [mustFactory(i.caller)]
645645     if ((checks == checks))
646646         then {
647647             let accountAddress = valueOrErrorMessage(addressFromString(args[0]), wrapErr("invalid account address"))
648648             let data = getAccountInfoInternal(accountAddress)
649649             $Tuple2(nil, data)
650650             }
651651         else throw("Strict value is not equal to itself.")
652652     }
653653 
654654 
655655 
656656 @Callable(i)
657657 func getUserInfoREADONLY (callerPublicKey,args) = {
658658     let checks = [mustFactory(i.caller)]
659659     if ((checks == checks))
660660         then {
661661             let userAddress = valueOrErrorMessage(addressFromString(args[0]), wrapErr("invalid user address"))
662662             let userRequests = valueOrElse(getBinary(factoryAddress, kRequestsByOwner(userAddress)), base58'')
663663             let userRequestsNumber = (size(userRequests) / queueItemSize)
664664             func getAccountsData (acc,count) =             {
665-                let $t02690226944 = acc
666-                let accDataList = $t02690226944._1
667-                let rawBytes = $t02690226944._2
668-                let maxSize = $t02690226944._3
665+                let $t02692026962 = acc
666+                let accDataList = $t02692026962._1
667+                let rawBytes = $t02692026962._2
668+                let maxSize = $t02692026962._3
669669                 if ((maxSize > count))
670670                     then {
671671                         let requestId = take(rawBytes, queueItemSize)
672672                         let newRawBytes = drop(rawBytes, queueItemSize)
673673                         let accountPublicKey = valueOrErrorMessage(getBinary(factoryAddress, kRequestIdToAccountPublicKey(requestId)), "kRequestIdToAccountPublicKey not found")
674674                         let accountAddress = addressFromPublicKey(accountPublicKey)
675675                         let data = getAccountInfoInternal(accountAddress)
676676                         $Tuple3((accDataList :+ data), newRawBytes, maxSize)
677677                         }
678678                     else acc
679679                 }
680680 
681-            let $t02744827553 = {
681+            let $t02746627571 = {
682682                 let $l = INDEX_LIST
683683                 let $s = size($l)
684684                 let $acc0 = $Tuple3(nil, userRequests, userRequestsNumber)
685685                 func $f0_1 ($a,$i) =                 if (($i >= $s))
686686                     then $a
687687                     else getAccountsData($a, $l[$i])
688688 
689689                 func $f0_2 ($a,$i) =                 if (($i >= $s))
690690                     then $a
691691                     else throw("List size exceeds 20")
692692 
693693                 $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20)
694694                 }
695-            let accDataList = $t02744827553._1
696-            let _a = $t02744827553._2
697-            let _b = $t02744827553._3
695+            let accDataList = $t02746627571._1
696+            let _a = $t02746627571._2
697+            let _b = $t02746627571._3
698698             $Tuple2(nil, accDataList)
699699             }
700700         else throw("Strict value is not equal to itself.")
701701     }
702702 
703703 
704704 
705705 @Callable(i)
706706 func getPairSettingsInfoREADONLY (callerPublicKey,args) = {
707707     let amountAsset = parseAssetId(args[0])
708708     let priceAsset = parseAssetId(args[1])
709709     let pricesList = getPairPricesList(amountAsset, priceAsset)
710710     func getPairSettings (acc,pricesString) =     {
711711         let settingsKey = kPairSettingsKey(amountAsset, priceAsset, pricesString)
712712         let settingsStringValue = getStringValue(factoryAddress, settingsKey)
713713         let sList = split(settingsStringValue, separator)
714714         let price = parseInt(pricesString)
715715         let maxLeverage = parseInt(sList[1])
716716         let initialMargin = parseInt(sList[2])
717717         let maintenanceMargin = parseInt(sList[3])
718718         (acc :+ $Tuple4(price, maxLeverage, initialMargin, maintenanceMargin))
719719         }
720720 
721721     let data = {
722722         let $l = pricesList
723723         let $s = size($l)
724724         let $acc0 = nil
725725         func $f0_1 ($a,$i) =         if (($i >= $s))
726726             then $a
727727             else getPairSettings($a, $l[$i])
728728 
729729         func $f0_2 ($a,$i) =         if (($i >= $s))
730730             then $a
731731             else throw("List size exceeds 20")
732732 
733733         $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20)
734734         }
735735     $Tuple2(nil, data)
736736     }
737737 
738738 
739739 
740740 @Callable(i)
741741 func editPairSettings (callerPublicKey,args) = {
742742     let checks = [mustFactory(i.caller)]
743743     if ((checks == checks))
744744         then {
745745             let amountAsset = parseAssetId(args[0])
746746             let priceAsset = parseAssetId(args[1])
747747             let price = args[2]
748748             let maxLeverage = args[3]
749749             let initialMargin = args[4]
750750             let maintenanceMargin = args[5]
751751             let pairPricesListKey = kPairPricesListKey(amountAsset, priceAsset)
752752             let settingsKey = kPairSettingsKey(amountAsset, priceAsset, price)
753753             let pricesList = getPairPricesList(amountAsset, priceAsset)
754754             let newList =             match indexOf(pricesList, price) {
755755                 case ind: Int => 
756756                     pricesList
757757                 case _ => 
758758                     (pricesList :+ price)
759759             }
760760             let check2 = [valueOrErrorMessage(parseInt(price), wrapErr("price value is not an Int")), valueOrErrorMessage(maxLeverage, wrapErr("maxLeverage value is not an Int")), valueOrErrorMessage(initialMargin, wrapErr("initialMargin value is not an Int")), valueOrErrorMessage(maintenanceMargin, wrapErr("maintenanceMargin value is not an Int")), if ((20 >= size(newList)))
761761                 then true
762762                 else throwErr("exceeded max prices list size (20)")]
763763             if ((check2 == check2))
764764                 then {
765765                     let pairSettingValue = makeString(["%s%s%s", maxLeverage, initialMargin, maintenanceMargin], separator)
766766                     let invocations = [invoke(factoryAddress, "stringEntry", [kPairPricesListKey(amountAsset, priceAsset), makeString(newList, separator)], nil), invoke(factoryAddress, "stringEntry", [kPairSettingsKey(amountAsset, priceAsset, price), pairSettingValue], nil)]
767767                     $Tuple2(nil, invocations)
768768                     }
769769                 else throw("Strict value is not equal to itself.")
770770             }
771771         else throw("Strict value is not equal to itself.")
772772     }
773773 
774774 
775775 
776776 @Callable(i)
777777 func deletePairSettings (callerPublicKey,args) = {
778778     let checks = [mustFactory(i.caller)]
779779     if ((checks == checks))
780780         then {
781781             let amountAsset = parseAssetId(args[0])
782782             let priceAsset = parseAssetId(args[1])
783783             let price = args[2]
784784             let settingsKey = kPairSettingsKey(amountAsset, priceAsset, price)
785785             let pairPricesListKey = kPairPricesListKey(amountAsset, priceAsset)
786786             let pricesList = getPairPricesList(amountAsset, priceAsset)
787787             let newList =             match indexOf(pricesList, price) {
788788                 case ind: Int => 
789789                     removeByIndex(pricesList, ind)
790790                 case _ => 
791791                     pricesList
792792             }
793793             let invocations = [invoke(factoryAddress, "deleteEntry", [settingsKey], nil), if ((size(newList) == 0))
794794                 then invoke(factoryAddress, "deleteEntry", [kPairPricesListKey(amountAsset, priceAsset)], nil)
795795                 else invoke(factoryAddress, "stringEntry", [kPairPricesListKey(amountAsset, priceAsset), makeString(newList, separator)], nil)]
796796             $Tuple2(nil, invocations)
797797             }
798798         else throw("Strict value is not equal to itself.")
799799     }
800800 
801801 
802802 @Verifier(tx)
803803 func verify () = if (if (isDefined(factoryAddressOption))
804804     then isDefined(getString(factoryAddress, kMultisig))
805805     else false)
806806     then     match getString(factoryAddress, kMultisig) {
807807         case multisig: String => 
808808             let statusKey = kStatus(toString(this), toBase58String(tx.id))
809809             let status = valueOrElse(getBoolean(addressFromStringValue(multisig), statusKey), false)
810810             status
811811         case _ => 
812812             false
813813     }
814814     else sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
815815 
github/deemru/w8io/026f985 
100.38 ms ◑