tx · CHFE2WYdEr5iiKUshHTcGLXgwSPyj7fnJgnivf6td3Qy

3N3tT5Kyp9orgzLHoNh6mS2e6nQSL3jHLw5:  -0.03100000 Waves

2022.05.23 14:27 [2064275] smart account 3N3tT5Kyp9orgzLHoNh6mS2e6nQSL3jHLw5 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "CHFE2WYdEr5iiKUshHTcGLXgwSPyj7fnJgnivf6td3Qy",
    "fee": 3100000,
    "feeAssetId": null,
    "timestamp": 1653305237703,
    "version": 2,
    "chainId": 84,
    "sender": "3N3tT5Kyp9orgzLHoNh6mS2e6nQSL3jHLw5",
    "senderPublicKey": "AVpPAHZYhsvbo1cNfAos8vZJb6zVVLPrnKxUXjZEssNP",
    "proofs": [
        "4kUgXb1u1L8iZ2uKTFtWWstnWJbTvJrECHwzbNqHRU86FDs9XuCW9Sdq64knv3T2Vx8QB3TGrBgPiM6r5x4mE9RD"
    ],
    "script": "base64:AAIFAAAAAAAAACwIAhIJCgcBAQEBAQEBEgYKBAEBAQESBQoDAQEBEgASAwoBARIAEgMKAQgSAAAAAE0AAAAAC29yYV9rX3ByaWNlAgAAAAVwcmljZQAAAAAJa19iYWxhbmNlAgAAAAlrX2JhbGFuY2UAAAAADmtfcG9zaXRpb25TaXplAgAAAA5rX3Bvc2l0aW9uU2l6ZQAAAAAQa19wb3NpdGlvbk1hcmdpbgIAAAAQa19wb3NpdGlvbk1hcmdpbgAAAAAFa19wb24CAAAABWtfcG9uAAAAABNrX3Bvc2l0aW9uTHN0VXBkQ1BGAgAAABJrX3Bvc2l0aW9uRnJhY3Rpb24AAAAADWtfaW5pdGlhbGl6ZWQCAAAADWtfaW5pdGlhbGl6ZWQAAAAABWtfZmVlAgAAAAVrX2ZlZQAAAAAPa19mdW5kaW5nUGVyaW9kAgAAAA9rX2Z1bmRpbmdQZXJpb2QAAAAAEWtfaW5pdE1hcmdpblJhdGlvAgAAABFrX2luaXRNYXJnaW5SYXRpbwAAAAAFa19tbXICAAAABWtfbW1yAAAAABVrX2xpcXVpZGF0aW9uRmVlUmF0aW8CAAAAFWtfbGlxdWlkYXRpb25GZWVSYXRpbwAAAAALa19sYXRlc3RDUEYCAAAAF2tfbGF0ZXN0UHJlbWl1bUZyYWN0aW9uAAAAABJrX25leHRGdW5kaW5nQmxvY2sCAAAAHmtfbmV4dEZ1bmRpbmdCbG9ja01pblRpbWVzdGFtcAAAAAANa19mdW5kaW5nUmF0ZQIAAAANa19mdW5kaW5nUmF0ZQAAAAAIa19xdEFzdFICAAAACGtfcXRBc3RSAAAAAAhrX2JzQXN0UgIAAAAIa19ic0FzdFIAAAAAIWtfYmFzZUFzc2V0RGVsdGFUaGlzRnVuZGluZ1BlcmlvZAIAAAAQa19iYXNlQXNzZXREZWx0YQAAAAATa190b3RhbFBvc2l0aW9uU2l6ZQIAAAATa190b3RhbFBvc2l0aW9uU2l6ZQAAAAAUa19jdW11bGF0aXZlTm90aW9uYWwCAAAAFGtfY3VtdWxhdGl2ZU5vdGlvbmFsAAAAABdrX29wZW5JbnRlcmVzZXROb3Rpb25hbAIAAAAXa19vcGVuSW50ZXJlc2V0Tm90aW9uYWwAAAAADUFETUlOX0FERFJFU1MJAQAAAAdBZGRyZXNzAAAAAQEAAAAaAVThY3GJftErRm52k60Ne932xNaQJif5MJ4AAAAAEEFETUlOX1BVQkxJQ19LRVkBAAAAIIcmSBJTUFXoPpNHZpHF6Io4+qdHJU/YbDcbopIgeR0fAAAAAARVU0ROAQAAACD3dur394PKZdtuE+4CO89YKZWpwdGN8kvabNgdYoDI3gAAAAAMVVNETl9TVEFLSU5HCQEAAAAHQWRkcmVzcwAAAAEBAAAAGgFU1RSI+hLarpHDNucd0rt6s3mn30OjjZimAAAAAAZPUkFDTEUJAQAAAAdBZGRyZXNzAAAAAQEAAAAaAVSejY4Al5SfQ9KNGpQt9mxR9NCIt5FVwUMAAAAADEZFRVNfQUNDT1VOVAkBAAAAB0FkZHJlc3MAAAABAQAAABoBVCjg9skERvjNwYufmcNFym7jAT7H5g2REwAAAAARSU5TVVJBTkNFX0FERFJFU1MJAQAAAAdBZGRyZXNzAAAAAQEAAAAaAVRWZDtBdd8NGqQ6AamRsrH6oKtG2RKa+P8AAAAACERJUl9MT05HAAAAAAAAAAABAAAAAAlESVJfU0hPUlQAAAAAAAAAAAIAAAAAFkZVTkRJTkdfQkxPQ0tfSU5URVJWQUwAAAAAAAAAADwAAAAAB1NFQ09ORFMAAAAAAAAAA+gAAAAADERFQ0lNQUxfVU5JVAkAAGgAAAACAAAAAAAAAAABCQAAaAAAAAIJAABoAAAAAgkAAGgAAAACCQAAaAAAAAIJAABoAAAAAgAAAAAAAAAACgAAAAAAAAAACgAAAAAAAAAACgAAAAAAAAAACgAAAAAAAAAACgAAAAAAAAAACgAAAAAHT05FX0RBWQkAAGgAAAACAAAAAAAAAVGABQAAAAxERUNJTUFMX1VOSVQBAAAABGRpdmQAAAACAAAAAl94AAAAAl95CQEAAAAIZnJhY3Rpb24AAAAEBQAAAAJfeAUAAAAMREVDSU1BTF9VTklUBQAAAAJfeQUAAAAISEFMRkVWRU4BAAAABG11bGQAAAACAAAAAl94AAAAAl95CQEAAAAIZnJhY3Rpb24AAAAEBQAAAAJfeAUAAAACX3kFAAAADERFQ0lNQUxfVU5JVAUAAAAISEFMRkVWRU4BAAAAA2FicwAAAAEAAAACX3gDCQAAZgAAAAIFAAAAAl94AAAAAAAAAAAABQAAAAJfeAkBAAAAAS0AAAABBQAAAAJfeAEAAAAOdG9Db21wb3NpdGVLZXkAAAACAAAABF9rZXkAAAAIX2FkZHJlc3MJAAEsAAAAAgkAASwAAAACBQAAAARfa2V5AgAAAAFfBQAAAAhfYWRkcmVzcwEAAAAWcmVxdWlyZU1vcmVNYXJnaW5SYXRpbwAAAAMAAAAMX21hcmdpblJhdGlvAAAAEF9iYXNlTWFyZ2luUmF0aW8AAAAUX2xhcmdlclRoYW5PckVxdWFsVG8EAAAAFHJlbWFpbmluZ01hcmdpblJhdGlvCQAAZQAAAAIFAAAADF9tYXJnaW5SYXRpbwUAAAAQX2Jhc2VNYXJnaW5SYXRpbwMDBQAAABRfbGFyZ2VyVGhhbk9yRXF1YWxUbwkAAGYAAAACAAAAAAAAAAAABQAAABRyZW1haW5pbmdNYXJnaW5SYXRpbwcJAAACAAAAAQIAAAAOSW52YWxpZCBtYXJnaW4DAwkBAAAAASEAAAABBQAAABRfbGFyZ2VyVGhhbk9yRXF1YWxUbwkAAGcAAAACBQAAABRyZW1haW5pbmdNYXJnaW5SYXRpbwAAAAAAAAAAAAcJAAACAAAAAQIAAAAOSW52YWxpZCBtYXJnaW4GAQAAAANpbnQAAAABAAAAAWsJAQAAABN2YWx1ZU9yRXJyb3JNZXNzYWdlAAAAAgkABBoAAAACBQAAAAR0aGlzBQAAAAFrCQABLAAAAAICAAAADW5vIHZhbHVlIGZvciAFAAAAAWsBAAAACGNiYWxhbmNlAAAAAAkBAAAAA2ludAAAAAEFAAAACWtfYmFsYW5jZQEAAAADZmVlAAAAAAkBAAAAA2ludAAAAAEFAAAABWtfZmVlAQAAAA9pbml0TWFyZ2luUmF0aW8AAAAACQEAAAADaW50AAAAAQUAAAARa19pbml0TWFyZ2luUmF0aW8BAAAABnF0QXN0UgAAAAAJAQAAAANpbnQAAAABBQAAAAhrX3F0QXN0UgEAAAAGYnNBc3RSAAAAAAkBAAAAA2ludAAAAAEFAAAACGtfYnNBc3RSAQAAAB9iYXNlQXNzZXREZWx0YVRoaXNGdW5kaW5nUGVyaW9kAAAAAAkBAAAAA2ludAAAAAEFAAAAIWtfYmFzZUFzc2V0RGVsdGFUaGlzRnVuZGluZ1BlcmlvZAEAAAARdG90YWxQb3NpdGlvblNpemUAAAAACQEAAAADaW50AAAAAQUAAAATa190b3RhbFBvc2l0aW9uU2l6ZQEAAAASY3VtdWxhdGl2ZU5vdGlvbmFsAAAAAAkBAAAAA2ludAAAAAEFAAAAFGtfY3VtdWxhdGl2ZU5vdGlvbmFsAQAAAAlsYXRlc3RDUEYAAAAACQEAAAADaW50AAAAAQUAAAALa19sYXRlc3RDUEYBAAAAFW9wZW5JbnRlcmVzZXROb3Rpb25hbAAAAAAJAQAAAANpbnQAAAABBQAAABdrX29wZW5JbnRlcmVzZXROb3Rpb25hbAEAAAAZbmV4dEZ1bmRpbmdCbG9ja1RpbWVzdGFtcAAAAAAJAQAAAANpbnQAAAABBQAAABJrX25leHRGdW5kaW5nQmxvY2sBAAAAEGZ1bmRpbmdQZXJpb2RSYXcAAAAACQEAAAADaW50AAAAAQUAAAAPa19mdW5kaW5nUGVyaW9kAQAAABRmdW5kaW5nUGVyaW9kRGVjaW1hbAAAAAAJAABoAAAAAgkBAAAAEGZ1bmRpbmdQZXJpb2RSYXcAAAAABQAAAAxERUNJTUFMX1VOSVQBAAAAFGZ1bmRpbmdQZXJpb2RTZWNvbmRzAAAAAAkAAGgAAAACCQEAAAAQZnVuZGluZ1BlcmlvZFJhdwAAAAAFAAAAB1NFQ09ORFMBAAAAA21tcgAAAAAJAQAAAANpbnQAAAABBQAAAAVrX21tcgEAAAATbGlxdWlkYXRpb25GZWVSYXRpbwAAAAAJAQAAAANpbnQAAAABBQAAABVrX2xpcXVpZGF0aW9uRmVlUmF0aW8BAAAAC2dldFBvc2l0aW9uAAAAAQAAAAdpbnZlc29yBAAAAA9wb3NpdGlvblNpemVPcHQJAAQaAAAAAgUAAAAEdGhpcwkBAAAADnRvQ29tcG9zaXRlS2V5AAAAAgUAAAAOa19wb3NpdGlvblNpemUFAAAAB2ludmVzb3IEAAAAByRtYXRjaDAFAAAAD3Bvc2l0aW9uU2l6ZU9wdAMJAAABAAAAAgUAAAAHJG1hdGNoMAIAAAADSW50BAAAAAxwb3NpdGlvblNpemUFAAAAByRtYXRjaDAJAAUWAAAABAUAAAAMcG9zaXRpb25TaXplCQEAAAARQGV4dHJOYXRpdmUoMTA1MCkAAAACBQAAAAR0aGlzCQEAAAAOdG9Db21wb3NpdGVLZXkAAAACBQAAABBrX3Bvc2l0aW9uTWFyZ2luBQAAAAdpbnZlc29yCQEAAAARQGV4dHJOYXRpdmUoMTA1MCkAAAACBQAAAAR0aGlzCQEAAAAOdG9Db21wb3NpdGVLZXkAAAACBQAAAAVrX3BvbgUAAAAHaW52ZXNvcgkBAAAAEUBleHRyTmF0aXZlKDEwNTApAAAAAgUAAAAEdGhpcwkBAAAADnRvQ29tcG9zaXRlS2V5AAAAAgUAAAATa19wb3NpdGlvbkxzdFVwZENQRgUAAAAHaW52ZXNvcgkABRYAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAABNyZXF1aXJlT3BlblBvc2l0aW9uAAAAAQAAAAdfdHJhZGVyBAAAAAskdDAzOTg4NDA5OQkBAAAAC2dldFBvc2l0aW9uAAAAAQUAAAAHX3RyYWRlcgQAAAAMcG9zaXRpb25TaXplCAUAAAALJHQwMzk4ODQwOTkAAAACXzEEAAAADnBvc2l0aW9uTWFyZ2luCAUAAAALJHQwMzk4ODQwOTkAAAACXzIEAAAAA3BvbggFAAAACyR0MDM5ODg0MDk5AAAAAl8zBAAAABFwb3NpdGlvbkxzdFVwZENQRggFAAAACyR0MDM5ODg0MDk5AAAAAl80AwkAAAAAAAACBQAAAAxwb3NpdGlvblNpemUAAAAAAAAAAAAJAAACAAAAAQIAAAAQTm8gb3BlbiBwb3NpdGlvbgYBAAAAC2luaXRpYWxpemVkAAAAAAkBAAAAC3ZhbHVlT3JFbHNlAAAAAgkABBsAAAACBQAAAAR0aGlzBQAAAA1rX2luaXRpYWxpemVkBwEAAAANdXBkYXRlUmVzZXJ2ZQAAAAMAAAAGX2lzQWRkAAAAEV9xdW90ZUFzc2V0QW1vdW50AAAAEF9iYXNlQXNzZXRBbW91bnQDBQAAAAZfaXNBZGQJAAUXAAAABQkAAGQAAAACCQEAAAAGcXRBc3RSAAAAAAUAAAARX3F1b3RlQXNzZXRBbW91bnQJAABlAAAAAgkBAAAABmJzQXN0UgAAAAAFAAAAEF9iYXNlQXNzZXRBbW91bnQJAABlAAAAAgkBAAAAH2Jhc2VBc3NldERlbHRhVGhpc0Z1bmRpbmdQZXJpb2QAAAAABQAAABBfYmFzZUFzc2V0QW1vdW50CQAAZAAAAAIJAQAAABF0b3RhbFBvc2l0aW9uU2l6ZQAAAAAFAAAAEF9iYXNlQXNzZXRBbW91bnQJAABkAAAAAgkBAAAAEmN1bXVsYXRpdmVOb3Rpb25hbAAAAAAFAAAAEV9xdW90ZUFzc2V0QW1vdW50CQAFFwAAAAUJAABlAAAAAgkBAAAABnF0QXN0UgAAAAAFAAAAEV9xdW90ZUFzc2V0QW1vdW50CQAAZAAAAAIJAQAAAAZic0FzdFIAAAAABQAAABBfYmFzZUFzc2V0QW1vdW50CQAAZAAAAAIJAQAAAB9iYXNlQXNzZXREZWx0YVRoaXNGdW5kaW5nUGVyaW9kAAAAAAUAAAAQX2Jhc2VBc3NldEFtb3VudAkAAGUAAAACCQEAAAARdG90YWxQb3NpdGlvblNpemUAAAAABQAAABBfYmFzZUFzc2V0QW1vdW50CQAAZQAAAAIJAQAAABJjdW11bGF0aXZlTm90aW9uYWwAAAAABQAAABFfcXVvdGVBc3NldEFtb3VudAEAAAAJc3dhcElucHV0AAAAAgAAAAZfaXNBZGQAAAAQX3F1b3RlQXNzZXRBbW91bgQAAAAHX3F0QXN0UgkBAAAABnF0QXN0UgAAAAAEAAAAB19ic0FzdFIJAQAAAAZic0FzdFIAAAAABAAAAAFrCQEAAAAEbXVsZAAAAAIFAAAAB19xdEFzdFIFAAAAB19ic0FzdFIEAAAAC3F0QXN0UkFmdGVyAwUAAAAGX2lzQWRkCQAAZAAAAAIFAAAAB19xdEFzdFIFAAAAEF9xdW90ZUFzc2V0QW1vdW4JAABlAAAAAgUAAAAHX3F0QXN0UgUAAAAQX3F1b3RlQXNzZXRBbW91bgQAAAALYnNBc3RSQWZ0ZXIJAQAAAARkaXZkAAAAAgUAAAABawUAAAALcXRBc3RSQWZ0ZXIEAAAAGGFtb3VudEJhc2VBc3NldEJvdWdodEFicwkBAAAAA2FicwAAAAEJAABlAAAAAgUAAAALYnNBc3RSQWZ0ZXIFAAAAB19ic0FzdFIEAAAAFWFtb3VudEJhc2VBc3NldEJvdWdodAMFAAAABl9pc0FkZAUAAAAYYW1vdW50QmFzZUFzc2V0Qm91Z2h0QWJzCQEAAAABLQAAAAEFAAAAGGFtb3VudEJhc2VBc3NldEJvdWdodEFicwQAAAALJHQwNTM4NzU2MDEJAQAAAA11cGRhdGVSZXNlcnZlAAAAAwUAAAAGX2lzQWRkBQAAABBfcXVvdGVBc3NldEFtb3VuBQAAABhhbW91bnRCYXNlQXNzZXRCb3VnaHRBYnMEAAAADHF0QXN0UkFmdGVyMQgFAAAACyR0MDUzODc1NjAxAAAAAl8xBAAAAAxic0FzdFJBZnRlcjEIBQAAAAskdDA1Mzg3NTYwMQAAAAJfMgQAAAAlYmFzZUFzc2V0RGVsdGFUaGlzRnVuZGluZ1BlcmlvZEFmdGVyMQgFAAAACyR0MDUzODc1NjAxAAAAAl8zBAAAABd0b3RhbFBvc2l0aW9uU2l6ZUFmdGVyMQgFAAAACyR0MDUzODc1NjAxAAAAAl80BAAAABhjdW11bGF0aXZlTm90aW9uYWxBZnRlcjEIBQAAAAskdDA1Mzg3NTYwMQAAAAJfNQkABRgAAAAGBQAAABVhbW91bnRCYXNlQXNzZXRCb3VnaHQFAAAADHF0QXN0UkFmdGVyMQUAAAAMYnNBc3RSQWZ0ZXIxBQAAACViYXNlQXNzZXREZWx0YVRoaXNGdW5kaW5nUGVyaW9kQWZ0ZXIxBQAAABd0b3RhbFBvc2l0aW9uU2l6ZUFmdGVyMQUAAAAYY3VtdWxhdGl2ZU5vdGlvbmFsQWZ0ZXIxAQAAACJjYWxjUmVtYWluTWFyZ2luV2l0aEZ1bmRpbmdQYXltZW50AAAABAAAABBfb2xkUG9zaXRpb25TaXplAAAAEl9vbGRQb3NpdGlvbk1hcmdpbgAAABVfb2xkUG9zaXRpb25Mc3RVcGRDUEYAAAAMX21hcmdpbkRlbHRhBAAAAApfbGF0ZXN0Q1BGCQEAAAAJbGF0ZXN0Q1BGAAAAAAQAAAAOZnVuZGluZ1BheW1lbnQDCQEAAAACIT0AAAACBQAAABBfb2xkUG9zaXRpb25TaXplAAAAAAAAAAAACQEAAAAEbXVsZAAAAAIJAABlAAAAAgUAAAAKX2xhdGVzdENQRgUAAAAVX29sZFBvc2l0aW9uTHN0VXBkQ1BGBQAAABBfb2xkUG9zaXRpb25TaXplAAAAAAAAAAAABAAAAAxzaWduZWRNYXJnaW4JAABkAAAAAgkAAGUAAAACBQAAAAxfbWFyZ2luRGVsdGEFAAAADmZ1bmRpbmdQYXltZW50BQAAABJfb2xkUG9zaXRpb25NYXJnaW4EAAAACyR0MDYxOTE2MzE4AwkAAGYAAAACAAAAAAAAAAAABQAAAAxzaWduZWRNYXJnaW4JAAUUAAAAAgAAAAAAAAAAAAkBAAAAA2FicwAAAAEFAAAADHNpZ25lZE1hcmdpbgkABRQAAAACCQEAAAADYWJzAAAAAQUAAAAMc2lnbmVkTWFyZ2luAAAAAAAAAAAABAAAAAxyZW1haW5NYXJnaW4IBQAAAAskdDA2MTkxNjMxOAAAAAJfMQQAAAAHYmFkRGVidAgFAAAACyR0MDYxOTE2MzE4AAAAAl8yCQAFFgAAAAQFAAAADHJlbWFpbk1hcmdpbgUAAAAHYmFkRGVidAUAAAAOZnVuZGluZ1BheW1lbnQFAAAACl9sYXRlc3RDUEYBAAAAGmdldE91dHB1dFByaWNlV2l0aFJlc2VydmVzAAAABAAAAARfYWRkAAAAEF9iYXNlQXNzZXRBbW91bnQAAAAVX3F1b3RlQXNzZXRQb29sQW1vdW50AAAAFF9iYXNlQXNzZXRQb29sQW1vdW50AwkAAAAAAAACBQAAABBfYmFzZUFzc2V0QW1vdW50AAAAAAAAAAAACQAAAgAAAAECAAAAGUludmFsaWQgYmFzZSBhc3NldCBhbW91bnQEAAAAAWsJAQAAAARtdWxkAAAAAgUAAAAVX3F1b3RlQXNzZXRQb29sQW1vdW50BQAAABRfYmFzZUFzc2V0UG9vbEFtb3VudAQAAAAYYmFzZUFzc2V0UG9vbEFtb3VudEFmdGVyAwUAAAAEX2FkZAkAAGQAAAACBQAAABRfYmFzZUFzc2V0UG9vbEFtb3VudAUAAAAQX2Jhc2VBc3NldEFtb3VudAkAAGUAAAACBQAAABRfYmFzZUFzc2V0UG9vbEFtb3VudAUAAAAQX2Jhc2VBc3NldEFtb3VudAQAAAAPcXVvdGVBc3NldEFmdGVyCQEAAAAEZGl2ZAAAAAIFAAAAAWsFAAAAGGJhc2VBc3NldFBvb2xBbW91bnRBZnRlcgQAAAAOcXVvdGVBc3NldFNvbGQJAQAAAANhYnMAAAABCQAAZQAAAAIFAAAAD3F1b3RlQXNzZXRBZnRlcgUAAAAVX3F1b3RlQXNzZXRQb29sQW1vdW50BAAAAAskdDA2OTY3NzE4MgkBAAAADXVwZGF0ZVJlc2VydmUAAAADCQEAAAABIQAAAAEFAAAABF9hZGQFAAAADnF1b3RlQXNzZXRTb2xkBQAAABBfYmFzZUFzc2V0QW1vdW50BAAAAAxxdEFzdFJBZnRlcjEIBQAAAAskdDA2OTY3NzE4MgAAAAJfMQQAAAAMYnNBc3RSQWZ0ZXIxCAUAAAALJHQwNjk2NzcxODIAAAACXzIEAAAAJWJhc2VBc3NldERlbHRhVGhpc0Z1bmRpbmdQZXJpb2RBZnRlcjEIBQAAAAskdDA2OTY3NzE4MgAAAAJfMwQAAAAXdG90YWxQb3NpdGlvblNpemVBZnRlcjEIBQAAAAskdDA2OTY3NzE4MgAAAAJfNAQAAAAYY3VtdWxhdGl2ZU5vdGlvbmFsQWZ0ZXIxCAUAAAALJHQwNjk2NzcxODIAAAACXzUJAAUYAAAABgUAAAAOcXVvdGVBc3NldFNvbGQFAAAADHF0QXN0UkFmdGVyMQUAAAAMYnNBc3RSQWZ0ZXIxBQAAACViYXNlQXNzZXREZWx0YVRoaXNGdW5kaW5nUGVyaW9kQWZ0ZXIxBQAAABd0b3RhbFBvc2l0aW9uU2l6ZUFmdGVyMQUAAAAYY3VtdWxhdGl2ZU5vdGlvbmFsQWZ0ZXIxAQAAACNnZXRQb3NpdGlvbk5vdGlvbmFsQW5kVW5yZWFsaXplZFBubAAAAAEAAAAHX3RyYWRlcgQAAAALJHQwNzQzNjc1NDcJAQAAAAtnZXRQb3NpdGlvbgAAAAEFAAAAB190cmFkZXIEAAAADHBvc2l0aW9uU2l6ZQgFAAAACyR0MDc0MzY3NTQ3AAAAAl8xBAAAAA5wb3NpdGlvbk1hcmdpbggFAAAACyR0MDc0MzY3NTQ3AAAAAl8yBAAAAANwb24IBQAAAAskdDA3NDM2NzU0NwAAAAJfMwQAAAARcG9zaXRpb25Mc3RVcGRDUEYIBQAAAAskdDA3NDM2NzU0NwAAAAJfNAQAAAAPcG9zaXRpb25TaXplQWJzCQEAAAADYWJzAAAAAQUAAAAMcG9zaXRpb25TaXplAwkAAAAAAAACBQAAAA9wb3NpdGlvblNpemVBYnMAAAAAAAAAAAAJAAACAAAAAQIAAAAVSW52YWxpZCBwb3NpdGlvbiBzaXplBAAAAAdpc1Nob3J0CQAAZgAAAAIAAAAAAAAAAAAFAAAADHBvc2l0aW9uU2l6ZQQAAAALJHQwNzcyNDc4NzQJAQAAABpnZXRPdXRwdXRQcmljZVdpdGhSZXNlcnZlcwAAAAQJAQAAAAEhAAAAAQUAAAAHaXNTaG9ydAUAAAAPcG9zaXRpb25TaXplQWJzCQEAAAAGcXRBc3RSAAAAAAkBAAAABmJzQXN0UgAAAAAEAAAAEHBvc2l0aW9uTm90aW9uYWwIBQAAAAskdDA3NzI0Nzg3NAAAAAJfMQQAAAACeDEIBQAAAAskdDA3NzI0Nzg3NAAAAAJfMgQAAAACeDIIBQAAAAskdDA3NzI0Nzg3NAAAAAJfMwQAAAACeDMIBQAAAAskdDA3NzI0Nzg3NAAAAAJfNAQAAAANdW5yZWFsaXplZFBubAMFAAAAB2lzU2hvcnQJAABlAAAAAgUAAAADcG9uBQAAABBwb3NpdGlvbk5vdGlvbmFsCQAAZQAAAAIFAAAAEHBvc2l0aW9uTm90aW9uYWwFAAAAA3BvbgkABRQAAAACBQAAABBwb3NpdGlvbk5vdGlvbmFsBQAAAA11bnJlYWxpemVkUG5sAQAAABJnZXRPcmFjbGVUd2FwUHJpY2UAAAAACQEAAAARQGV4dHJOYXRpdmUoMTA1MCkAAAACBQAAAAZPUkFDTEUFAAAAC29yYV9rX3ByaWNlAQAAABBnZXRUd2FwU3BvdFByaWNlAAAAAAkBAAAABGRpdmQAAAACCQEAAAAGcXRBc3RSAAAAAAkBAAAABmJzQXN0UgAAAAABAAAADmdldE1hcmdpblJhdGlvAAAAAQAAAAdfdHJhZGVyBAAAAAskdDA4MjU0ODM2NQkBAAAAC2dldFBvc2l0aW9uAAAAAQUAAAAHX3RyYWRlcgQAAAAMcG9zaXRpb25TaXplCAUAAAALJHQwODI1NDgzNjUAAAACXzEEAAAADnBvc2l0aW9uTWFyZ2luCAUAAAALJHQwODI1NDgzNjUAAAACXzIEAAAAA3BvbggFAAAACyR0MDgyNTQ4MzY1AAAAAl8zBAAAABFwb3NpdGlvbkxzdFVwZENQRggFAAAACyR0MDgyNTQ4MzY1AAAAAl80BAAAAAskdDA4MzcxODQ1NQkBAAAAI2dldFBvc2l0aW9uTm90aW9uYWxBbmRVbnJlYWxpemVkUG5sAAAAAQUAAAAHX3RyYWRlcgQAAAAQcG9zaXRpb25Ob3Rpb25hbAgFAAAACyR0MDgzNzE4NDU1AAAAAl8xBAAAAA11bnJlYWxpemVkUG5sCAUAAAALJHQwODM3MTg0NTUAAAACXzIEAAAACyR0MDg0NjA4NjI2CQEAAAAiY2FsY1JlbWFpbk1hcmdpbldpdGhGdW5kaW5nUGF5bWVudAAAAAQFAAAADHBvc2l0aW9uU2l6ZQUAAAAOcG9zaXRpb25NYXJnaW4FAAAAEXBvc2l0aW9uTHN0VXBkQ1BGBQAAAA11bnJlYWxpemVkUG5sBAAAAAxyZW1haW5NYXJnaW4IBQAAAAskdDA4NDYwODYyNgAAAAJfMQQAAAAHYmFkRGVidAgFAAAACyR0MDg0NjA4NjI2AAAAAl8yCQEAAAAEZGl2ZAAAAAIJAABlAAAAAgUAAAAMcmVtYWluTWFyZ2luBQAAAAdiYWREZWJ0BQAAABBwb3NpdGlvbk5vdGlvbmFsAQAAABVpbnRlcm5hbENsb3NlUG9zaXRpb24AAAABAAAAB190cmFkZXIEAAAACyR0MDg3MzM4ODQ0CQEAAAALZ2V0UG9zaXRpb24AAAABBQAAAAdfdHJhZGVyBAAAAAxwb3NpdGlvblNpemUIBQAAAAskdDA4NzMzODg0NAAAAAJfMQQAAAAOcG9zaXRpb25NYXJnaW4IBQAAAAskdDA4NzMzODg0NAAAAAJfMgQAAAADcG9uCAUAAAALJHQwODczMzg4NDQAAAACXzMEAAAAEXBvc2l0aW9uTHN0VXBkQ1BGCAUAAAALJHQwODczMzg4NDQAAAACXzQEAAAACyR0MDg4NTA4OTIwCQEAAAAjZ2V0UG9zaXRpb25Ob3Rpb25hbEFuZFVucmVhbGl6ZWRQbmwAAAABBQAAAAdfdHJhZGVyBAAAAAJ4MQgFAAAACyR0MDg4NTA4OTIwAAAAAl8xBAAAAA11bnJlYWxpemVkUG5sCAUAAAALJHQwODg1MDg5MjAAAAACXzIEAAAACyR0MDg5MjU5MDk3CQEAAAAiY2FsY1JlbWFpbk1hcmdpbldpdGhGdW5kaW5nUGF5bWVudAAAAAQFAAAADHBvc2l0aW9uU2l6ZQUAAAAOcG9zaXRpb25NYXJnaW4FAAAAEXBvc2l0aW9uTHN0VXBkQ1BGBQAAAA11bnJlYWxpemVkUG5sBAAAAAxyZW1haW5NYXJnaW4IBQAAAAskdDA4OTI1OTA5NwAAAAJfMQQAAAAHYmFkRGVidAgFAAAACyR0MDg5MjU5MDk3AAAAAl8yBAAAAAJ4MggFAAAACyR0MDg5MjU5MDk3AAAAAl8zBAAAABVleGNoYW5nZWRQb3NpdGlvblNpemUJAQAAAAEtAAAAAQUAAAAMcG9zaXRpb25TaXplBAAAAAtyZWFsaXplZFBubAUAAAANdW5yZWFsaXplZFBubAQAAAANbWFyZ2luVG9WYXVsdAkBAAAAAS0AAAABBQAAAAxyZW1haW5NYXJnaW4EAAAACyR0MDkyMjQ5NTQ3CQEAAAAaZ2V0T3V0cHV0UHJpY2VXaXRoUmVzZXJ2ZXMAAAAECQAAZgAAAAIFAAAADHBvc2l0aW9uU2l6ZQAAAAAAAAAAAAkBAAAAA2FicwAAAAEFAAAADHBvc2l0aW9uU2l6ZQkBAAAABnF0QXN0UgAAAAAJAQAAAAZic0FzdFIAAAAABAAAABlleGNoYW5nZWRRdW90ZUFzc2V0QW1vdW50CAUAAAALJHQwOTIyNDk1NDcAAAACXzEEAAAAFnF1b3RlQXNzZXRSZXNlcnZlQWZ0ZXIIBQAAAAskdDA5MjI0OTU0NwAAAAJfMgQAAAALYnNBc3RSQWZ0ZXIIBQAAAAskdDA5MjI0OTU0NwAAAAJfMwQAAAAkYmFzZUFzc2V0RGVsdGFUaGlzRnVuZGluZ1BlcmlvZEFmdGVyCAUAAAALJHQwOTIyNDk1NDcAAAACXzQEAAAAFnRvdGFsUG9zaXRpb25TaXplQWZ0ZXIIBQAAAAskdDA5MjI0OTU0NwAAAAJfNQQAAAAXY3VtdWxhdGl2ZU5vdGlvbmFsQWZ0ZXIIBQAAAAskdDA5MjI0OTU0NwAAAAJfNgQAAAAab3BlbkludGVyZXNldE5vdGlvbmFsQWZ0ZXIJAABlAAAAAgkBAAAAFW9wZW5JbnRlcmVzZXROb3Rpb25hbAAAAAAFAAAAA3BvbgkABR0AAAALBQAAABVleGNoYW5nZWRQb3NpdGlvblNpemUFAAAAB2JhZERlYnQFAAAAC3JlYWxpemVkUG5sBQAAAA1tYXJnaW5Ub1ZhdWx0BQAAABZxdW90ZUFzc2V0UmVzZXJ2ZUFmdGVyBQAAAAtic0FzdFJBZnRlcgUAAAAkYmFzZUFzc2V0RGVsdGFUaGlzRnVuZGluZ1BlcmlvZEFmdGVyBQAAABZ0b3RhbFBvc2l0aW9uU2l6ZUFmdGVyBQAAABdjdW11bGF0aXZlTm90aW9uYWxBZnRlcgUAAAAab3BlbkludGVyZXNldE5vdGlvbmFsQWZ0ZXIFAAAAGWV4Y2hhbmdlZFF1b3RlQXNzZXRBbW91bnQBAAAADnVwZGF0ZVNldHRpbmdzAAAABQAAABBfaW5pdE1hcmdpblJhdGlvAAAABF9tbXIAAAAUX2xpcXVpZGF0aW9uRmVlUmF0aW8AAAAOX2Z1bmRpbmdQZXJpb2QAAAAEX2ZlZQkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgUAAAARa19pbml0TWFyZ2luUmF0aW8FAAAAEF9pbml0TWFyZ2luUmF0aW8JAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIFAAAABWtfbW1yBQAAAARfbW1yCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACBQAAABVrX2xpcXVpZGF0aW9uRmVlUmF0aW8FAAAAFF9saXF1aWRhdGlvbkZlZVJhdGlvCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACBQAAAA9rX2Z1bmRpbmdQZXJpb2QFAAAADl9mdW5kaW5nUGVyaW9kCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACBQAAAAVrX2ZlZQUAAAAEX2ZlZQUAAAADbmlsAQAAAA11cGRhdGVGdW5kaW5nAAAABAAAAApfYmFzZUFEVEZQAAAAEV9uZXh0RnVuZGluZ0Jsb2NrAAAACl9sYXRlc3RDUEYAAAAMX2Z1bmRpbmdSYXRlCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACBQAAACFrX2Jhc2VBc3NldERlbHRhVGhpc0Z1bmRpbmdQZXJpb2QFAAAACl9iYXNlQURURlAJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIFAAAAEmtfbmV4dEZ1bmRpbmdCbG9jawUAAAARX25leHRGdW5kaW5nQmxvY2sJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIFAAAAC2tfbGF0ZXN0Q1BGBQAAAApfbGF0ZXN0Q1BGCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACBQAAAA1rX2Z1bmRpbmdSYXRlBQAAAAxfZnVuZGluZ1JhdGUFAAAAA25pbAEAAAAOdXBkYXRlUG9zaXRpb24AAAAFAAAACF9hZGRyZXNzAAAABV9zaXplAAAAB19tYXJnaW4AAAAMX29wZW5Ob3RpbmFsAAAACl9Mc3RVcGRDUEYJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIJAQAAAA50b0NvbXBvc2l0ZUtleQAAAAIFAAAADmtfcG9zaXRpb25TaXplBQAAAAhfYWRkcmVzcwUAAAAFX3NpemUJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIJAQAAAA50b0NvbXBvc2l0ZUtleQAAAAIFAAAAEGtfcG9zaXRpb25NYXJnaW4FAAAACF9hZGRyZXNzBQAAAAdfbWFyZ2luCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACCQEAAAAOdG9Db21wb3NpdGVLZXkAAAACBQAAAAVrX3BvbgUAAAAIX2FkZHJlc3MFAAAADF9vcGVuTm90aW5hbAkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgkBAAAADnRvQ29tcG9zaXRlS2V5AAAAAgUAAAATa19wb3NpdGlvbkxzdFVwZENQRgUAAAAIX2FkZHJlc3MFAAAACl9Mc3RVcGRDUEYFAAAAA25pbAEAAAAJdXBkYXRlQW1tAAAABgAAAAdfcXRBc3RSAAAAB19ic0FzdFIAAAAlX2Jhc2VBc3NldERlbHRhVGhpc0Z1bmRpbmdQZXJpb2RBZnRlcgAAABdfdG90YWxQb3NpdGlvblNpemVBZnRlcgAAABhfY3VtdWxhdGl2ZU5vdGlvbmFsQWZ0ZXIAAAAWX29wZW5JbnRlcmVzZXROb3Rpb25hbAkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgUAAAAIa19xdEFzdFIFAAAAB19xdEFzdFIJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIFAAAACGtfYnNBc3RSBQAAAAdfYnNBc3RSCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACBQAAACFrX2Jhc2VBc3NldERlbHRhVGhpc0Z1bmRpbmdQZXJpb2QFAAAAJV9iYXNlQXNzZXREZWx0YVRoaXNGdW5kaW5nUGVyaW9kQWZ0ZXIJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIFAAAAE2tfdG90YWxQb3NpdGlvblNpemUFAAAAF190b3RhbFBvc2l0aW9uU2l6ZUFmdGVyCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACBQAAABRrX2N1bXVsYXRpdmVOb3Rpb25hbAUAAAAYX2N1bXVsYXRpdmVOb3Rpb25hbEFmdGVyCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACBQAAABdrX29wZW5JbnRlcmVzZXROb3Rpb25hbAUAAAAWX29wZW5JbnRlcmVzZXROb3Rpb25hbAUAAAADbmlsAQAAAA5kZWxldGVQb3NpdGlvbgAAAAEAAAAIX2FkZHJlc3MJAARMAAAAAgkBAAAAC0RlbGV0ZUVudHJ5AAAAAQkBAAAADnRvQ29tcG9zaXRlS2V5AAAAAgUAAAAOa19wb3NpdGlvblNpemUFAAAACF9hZGRyZXNzCQAETAAAAAIJAQAAAAtEZWxldGVFbnRyeQAAAAEJAQAAAA50b0NvbXBvc2l0ZUtleQAAAAIFAAAAEGtfcG9zaXRpb25NYXJnaW4FAAAACF9hZGRyZXNzCQAETAAAAAIJAQAAAAtEZWxldGVFbnRyeQAAAAEJAQAAAA50b0NvbXBvc2l0ZUtleQAAAAIFAAAABWtfcG9uBQAAAAhfYWRkcmVzcwkABEwAAAACCQEAAAALRGVsZXRlRW50cnkAAAABCQEAAAAOdG9Db21wb3NpdGVLZXkAAAACBQAAABNrX3Bvc2l0aW9uTHN0VXBkQ1BGBQAAAAhfYWRkcmVzcwUAAAADbmlsAQAAAAh3aXRoZHJhdwAAAAIAAAAIX2FkZHJlc3MAAAAHX2Ftb3VudAQAAAAHYmFsYW5jZQkAA/AAAAACBQAAAAR0aGlzBQAAAARVU0ROAwkAAGYAAAACBQAAAAdfYW1vdW50BQAAAAdiYWxhbmNlCQAAAgAAAAEJAAEsAAAAAgkAASwAAAACCQABLAAAAAICAAAAE1VuYWJsZSB0byB3aXRoZHJhdyAJAAGkAAAAAQUAAAAHX2Ftb3VudAIAAAAXIGZyb20gY29udHJhY3QgYmFsYW5jZSAJAAGkAAAAAQUAAAAHYmFsYW5jZQkABEwAAAACCQEAAAAOU2NyaXB0VHJhbnNmZXIAAAADBQAAAAhfYWRkcmVzcwUAAAAHX2Ftb3VudAUAAAAEVVNETgUAAAADbmlsAQAAAA53cml0ZUNvbnN0YW50cwAAAAAJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgIAAAANQURNSU5fQUREUkVTUwkABCUAAAABBQAAAA1BRE1JTl9BRERSRVNTCQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAICAAAABFVTRE4JAAJYAAAAAQUAAAAEVVNETgkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACAgAAAAxVU0ROX1NUQUtJTkcJAAQlAAAAAQUAAAAMVVNETl9TVEFLSU5HCQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAICAAAABk9SQUNMRQkABCUAAAABBQAAAAZPUkFDTEUFAAAAA25pbAEAAAAFdXBibGMAAAABAAAAAWkDCQAAZgAAAAIAAAAAAAAAAAAFAAAAAWkJAAACAAAAAQIAAAAHQmFsYW5jZQkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgUAAAAJa19iYWxhbmNlBQAAAAFpBQAAAANuaWwBAAAAC3RyYW5zZmVyRmVlAAAAAQAAAAFpCQAETAAAAAIJAQAAAA5TY3JpcHRUcmFuc2ZlcgAAAAMFAAAADEZFRVNfQUNDT1VOVAUAAAABaQUAAAAEVVNETgUAAAADbmlsAAAACAAAAAFpAQAAAAppbml0aWFsaXplAAAABwAAAAdfcXRBc3RSAAAAB19ic0FzdFIAAAAOX2Z1bmRpbmdQZXJpb2QAAAAQX2luaXRNYXJnaW5SYXRpbwAAAARfbW1yAAAAFF9saXF1aWRhdGlvbkZlZVJhdGlvAAAABF9mZWUDAwMDAwMDAwkAAGcAAAACAAAAAAAAAAAABQAAAAdfcXRBc3RSBgkAAGcAAAACAAAAAAAAAAAABQAAAAdfYnNBc3RSBgkAAGcAAAACAAAAAAAAAAAABQAAAA5fZnVuZGluZ1BlcmlvZAYJAABnAAAAAgAAAAAAAAAAAAUAAAAQX2luaXRNYXJnaW5SYXRpbwYJAABnAAAAAgAAAAAAAAAAAAUAAAAEX21tcgYJAABnAAAAAgAAAAAAAAAAAAUAAAAUX2xpcXVpZGF0aW9uRmVlUmF0aW8GCQEAAAACIT0AAAACCAUAAAABaQAAAAZjYWxsZXIFAAAADUFETUlOX0FERFJFU1MGCQEAAAALaW5pdGlhbGl6ZWQAAAAACQAAAgAAAAECAAAAHUludmFsaWQgaW5pdGlhbGl6ZSBwYXJhbWV0ZXJzCQAETgAAAAIJAAROAAAAAgkABE4AAAACCQAETgAAAAIJAAROAAAAAgkBAAAACXVwZGF0ZUFtbQAAAAYFAAAAB19xdEFzdFIFAAAAB19ic0FzdFIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJAQAAAA51cGRhdGVTZXR0aW5ncwAAAAUFAAAAEF9pbml0TWFyZ2luUmF0aW8FAAAABF9tbXIFAAAAFF9saXF1aWRhdGlvbkZlZVJhdGlvBQAAAA5fZnVuZGluZ1BlcmlvZAUAAAAEX2ZlZQkBAAAADXVwZGF0ZUZ1bmRpbmcAAAAEAAAAAAAAAAAACQAAZAAAAAIIBQAAAAlsYXN0QmxvY2sAAAAJdGltZXN0YW1wBQAAAA5fZnVuZGluZ1BlcmlvZAAAAAAAAAAAAAAAAAAAAAAAAAkBAAAABXVwYmxjAAAAAQAAAAAAAAAAAAkBAAAADndyaXRlQ29uc3RhbnRzAAAAAAkABEwAAAACCQEAAAAMQm9vbGVhbkVudHJ5AAAAAgUAAAANa19pbml0aWFsaXplZAYFAAAAA25pbAAAAAFpAQAAABBkZWNyZWFzZVBvc2l0aW9uAAAABAAAAApfZGlyZWN0aW9uAAAAB19hbW91bnQAAAAJX2xldmVyYWdlAAAAE19taW5CYXNlQXNzZXRBbW91bnQDAwMDAwMJAQAAAAIhPQAAAAIFAAAACl9kaXJlY3Rpb24FAAAACERJUl9MT05HCQEAAAACIT0AAAACBQAAAApfZGlyZWN0aW9uBQAAAAlESVJfU0hPUlQHBgkAAGcAAAACAAAAAAAAAAAABQAAAAdfYW1vdW50BgMJAABmAAAAAgkAAGgAAAACAAAAAAAAAAABBQAAAAxERUNJTUFMX1VOSVQFAAAACV9sZXZlcmFnZQYJAABmAAAAAgUAAAAJX2xldmVyYWdlCQAAaAAAAAIAAAAAAAAAAAMFAAAADERFQ0lNQUxfVU5JVAYJAQAAAAEhAAAAAQkBAAAAC2luaXRpYWxpemVkAAAAAAYJAQAAAAEhAAAAAQkBAAAAFnJlcXVpcmVNb3JlTWFyZ2luUmF0aW8AAAADCQEAAAAEZGl2ZAAAAAIFAAAADERFQ0lNQUxfVU5JVAUAAAAJX2xldmVyYWdlCQEAAAAPaW5pdE1hcmdpblJhdGlvAAAAAAYJAAACAAAAAQIAAAAjSW52YWxpZCBkZWNyZWFzZVBvc2l0aW9uIHBhcmFtZXRlcnMEAAAADSR0MDEzOTQ4MTQxMDAJAQAAAAtnZXRQb3NpdGlvbgAAAAEJAAQlAAAAAQgFAAAAAWkAAAAGY2FsbGVyBAAAAA9vbGRQb3NpdGlvblNpemUIBQAAAA0kdDAxMzk0ODE0MTAwAAAAAl8xBAAAABFvbGRQb3NpdGlvbk1hcmdpbggFAAAADSR0MDEzOTQ4MTQxMDAAAAACXzIEAAAAF29sZFBvc2l0aW9uT3Blbk5vdGlvbmFsCAUAAAANJHQwMTM5NDgxNDEwMAAAAAJfMwQAAAAUb2xkUG9zaXRpb25Mc3RVcGRDUEYIBQAAAA0kdDAxMzk0ODE0MTAwAAAAAl80BAAAAA1pc05ld1Bvc2l0aW9uCQAAAAAAAAIFAAAAD29sZFBvc2l0aW9uU2l6ZQAAAAAAAAAAAAQAAAAPaXNTYW1lRGlyZWN0aW9uAwkAAGYAAAACBQAAAA9vbGRQb3NpdGlvblNpemUAAAAAAAAAAAAJAAAAAAAAAgUAAAAKX2RpcmVjdGlvbgUAAAAIRElSX0xPTkcJAAAAAAAAAgUAAAAKX2RpcmVjdGlvbgUAAAAJRElSX1NIT1JUBAAAAA5leHBhbmRFeGlzdGluZwMJAQAAAAEhAAAAAQUAAAANaXNOZXdQb3NpdGlvbgUAAAAPaXNTYW1lRGlyZWN0aW9uBwQAAAAFaXNBZGQJAAAAAAAAAgUAAAAKX2RpcmVjdGlvbgUAAAAIRElSX0xPTkcEAAAADSR0MDE0Mzg5MTcxODYDAwUAAAANaXNOZXdQb3NpdGlvbgYFAAAADmV4cGFuZEV4aXN0aW5nCQAAAgAAAAECAAAANVVzZSBpbmNyZWFzZVBvc2l0aW9uIHRvIG9wZW4gbmV3IG9yIGluY3JlYXNlIHBvc2l0aW9uBAAAAAxvcGVuTm90aW9uYWwJAQAAAARtdWxkAAAAAgUAAAAHX2Ftb3VudAUAAAAJX2xldmVyYWdlBAAAAA0kdDAxNDg3MzE0OTcyCQEAAAAjZ2V0UG9zaXRpb25Ob3Rpb25hbEFuZFVucmVhbGl6ZWRQbmwAAAABCQAEJQAAAAEIBQAAAAFpAAAABmNhbGxlcgQAAAATb2xkUG9zaXRpb25Ob3Rpb25hbAgFAAAADSR0MDE0ODczMTQ5NzIAAAACXzEEAAAADXVucmVhbGl6ZWRQbmwIBQAAAA0kdDAxNDg3MzE0OTcyAAAAAl8yAwkAAGYAAAACBQAAABNvbGRQb3NpdGlvbk5vdGlvbmFsBQAAAAxvcGVuTm90aW9uYWwEAAAADSR0MDE1MDM0MTUyOTMJAQAAAAlzd2FwSW5wdXQAAAACBQAAAAVpc0FkZAUAAAAMb3Blbk5vdGlvbmFsBAAAABVleGNoYW5nZWRQb3NpdGlvblNpemUIBQAAAA0kdDAxNTAzNDE1MjkzAAAAAl8xBAAAAAtxdEFzdFJBZnRlcggFAAAADSR0MDE1MDM0MTUyOTMAAAACXzIEAAAAC2JzQXN0UkFmdGVyCAUAAAANJHQwMTUwMzQxNTI5MwAAAAJfMwQAAAAkYmFzZUFzc2V0RGVsdGFUaGlzRnVuZGluZ1BlcmlvZEFmdGVyCAUAAAANJHQwMTUwMzQxNTI5MwAAAAJfNAQAAAAWdG90YWxQb3NpdGlvblNpemVBZnRlcggFAAAADSR0MDE1MDM0MTUyOTMAAAACXzUEAAAAF2N1bXVsYXRpdmVOb3Rpb25hbEFmdGVyCAUAAAANJHQwMTUwMzQxNTI5MwAAAAJfNgQAAAAYZXhjaGFuZ2VkUG9zaXRpb25TaXplQWJzCQEAAAADYWJzAAAAAQUAAAAVZXhjaGFuZ2VkUG9zaXRpb25TaXplAwMJAQAAAAIhPQAAAAIFAAAAE19taW5CYXNlQXNzZXRBbW91bnQAAAAAAAAAAAAJAABmAAAAAgUAAAATX21pbkJhc2VBc3NldEFtb3VudAUAAAAYZXhjaGFuZ2VkUG9zaXRpb25TaXplQWJzBwkAAAIAAAABCQABLAAAAAIJAAEsAAAAAgkAASwAAAACAgAAACZUb28gbGl0dGxlIGJhc3NlIGFzc2V0IGV4Y2hhbmdlZCwgZ290IAkAAaQAAAABBQAAABhleGNoYW5nZWRQb3NpdGlvblNpemVBYnMCAAAACiBleHBlY3RlZCAJAAGkAAAAAQUAAAATX21pbkJhc2VBc3NldEFtb3VudAQAAAALcmVhbGl6ZWRQbmwDCQEAAAACIT0AAAACBQAAAA9vbGRQb3NpdGlvblNpemUAAAAAAAAAAAAJAQAAAARkaXZkAAAAAgkBAAAABG11bGQAAAACBQAAAA11bnJlYWxpemVkUG5sBQAAABhleGNoYW5nZWRQb3NpdGlvblNpemVBYnMFAAAAD29sZFBvc2l0aW9uU2l6ZQAAAAAAAAAAAAQAAAANJHQwMTU4MzQxNjEwNQkBAAAAImNhbGNSZW1haW5NYXJnaW5XaXRoRnVuZGluZ1BheW1lbnQAAAAEBQAAAA9vbGRQb3NpdGlvblNpemUFAAAAEW9sZFBvc2l0aW9uTWFyZ2luBQAAABRvbGRQb3NpdGlvbkxzdFVwZENQRgUAAAALcmVhbGl6ZWRQbmwEAAAADHJlbWFpbk1hcmdpbggFAAAADSR0MDE1ODM0MTYxMDUAAAACXzEEAAAAB2JhZERlYnQIBQAAAA0kdDAxNTgzNDE2MTA1AAAAAl8yBAAAAA5mdW5kaW5nUGF5bWVudAgFAAAADSR0MDE1ODM0MTYxMDUAAAACXzMEAAAADG9sZExhdGVzdENQRggFAAAADSR0MDE1ODM0MTYxMDUAAAACXzQEAAAAGWV4Y2hhbmdlZFF1b3RlQXNzZXRBbW91bnQFAAAADG9wZW5Ob3Rpb25hbAQAAAASdW5yZWFsaXplZFBubEFmdGVyCQAAZQAAAAIFAAAADXVucmVhbGl6ZWRQbmwFAAAAC3JlYWxpemVkUG5sBAAAABJyZW1haW5PcGVuTm90aW9uYWwDCQAAZgAAAAIFAAAAD29sZFBvc2l0aW9uU2l6ZQAAAAAAAAAAAAkAAGUAAAACCQAAZQAAAAIFAAAAE29sZFBvc2l0aW9uTm90aW9uYWwFAAAAGWV4Y2hhbmdlZFF1b3RlQXNzZXRBbW91bnQFAAAAEnVucmVhbGl6ZWRQbmxBZnRlcgkAAGUAAAACCQAAZAAAAAIFAAAAEnVucmVhbGl6ZWRQbmxBZnRlcgUAAAATb2xkUG9zaXRpb25Ob3Rpb25hbAUAAAAZZXhjaGFuZ2VkUXVvdGVBc3NldEFtb3VudAkABRwAAAAKCQAAZAAAAAIFAAAAD29sZFBvc2l0aW9uU2l6ZQUAAAAVZXhjaGFuZ2VkUG9zaXRpb25TaXplBQAAAAxyZW1haW5NYXJnaW4JAQAAAANhYnMAAAABBQAAABJyZW1haW5PcGVuTm90aW9uYWwFAAAADG9sZExhdGVzdENQRgUAAAALYnNBc3RSQWZ0ZXIFAAAAC3F0QXN0UkFmdGVyBQAAACRiYXNlQXNzZXREZWx0YVRoaXNGdW5kaW5nUGVyaW9kQWZ0ZXIFAAAAFnRvdGFsUG9zaXRpb25TaXplQWZ0ZXIFAAAAF2N1bXVsYXRpdmVOb3Rpb25hbEFmdGVyCQAAZQAAAAIJAQAAABVvcGVuSW50ZXJlc2V0Tm90aW9uYWwAAAAABQAAAAxvcGVuTm90aW9uYWwJAAACAAAAAQIAAAAUQ2xvc2UgcG9zaXRpb24gZmlyc3QEAAAAD25ld1Bvc2l0aW9uU2l6ZQgFAAAADSR0MDE0Mzg5MTcxODYAAAACXzEEAAAAF25ld1Bvc2l0aW9uUmVtYWluTWFyZ2luCAUAAAANJHQwMTQzODkxNzE4NgAAAAJfMgQAAAAWbmV3UG9zaWlvbk9wZW5Ob3Rpb25hbAgFAAAADSR0MDE0Mzg5MTcxODYAAAACXzMEAAAAFG5ld1Bvc2l0aW9uTGF0ZXN0Q1BGCAUAAAANJHQwMTQzODkxNzE4NgAAAAJfNAQAAAALYnNBc3RSQWZ0ZXIIBQAAAA0kdDAxNDM4OTE3MTg2AAAAAl81BAAAAAtxdEFzdFJBZnRlcggFAAAADSR0MDE0Mzg5MTcxODYAAAACXzYEAAAAJGJhc2VBc3NldERlbHRhVGhpc0Z1bmRpbmdQZXJpb2RBZnRlcggFAAAADSR0MDE0Mzg5MTcxODYAAAACXzcEAAAAFnRvdGFsUG9zaXRpb25TaXplQWZ0ZXIIBQAAAA0kdDAxNDM4OTE3MTg2AAAAAl84BAAAABdjdW11bGF0aXZlTm90aW9uYWxBZnRlcggFAAAADSR0MDE0Mzg5MTcxODYAAAACXzkEAAAAGm9wZW5JbnRlcmVzZXROb3Rpb25hbEFmdGVyCAUAAAANJHQwMTQzODkxNzE4NgAAAANfMTAJAAROAAAAAgkBAAAADnVwZGF0ZVBvc2l0aW9uAAAABQkABCUAAAABCAUAAAABaQAAAAZjYWxsZXIFAAAAD25ld1Bvc2l0aW9uU2l6ZQUAAAAXbmV3UG9zaXRpb25SZW1haW5NYXJnaW4FAAAAFm5ld1Bvc2lpb25PcGVuTm90aW9uYWwFAAAAFG5ld1Bvc2l0aW9uTGF0ZXN0Q1BGCQEAAAAJdXBkYXRlQW1tAAAABgUAAAALcXRBc3RSQWZ0ZXIFAAAAC2JzQXN0UkFmdGVyBQAAACRiYXNlQXNzZXREZWx0YVRoaXNGdW5kaW5nUGVyaW9kQWZ0ZXIFAAAAFnRvdGFsUG9zaXRpb25TaXplQWZ0ZXIFAAAAF2N1bXVsYXRpdmVOb3Rpb25hbEFmdGVyBQAAABpvcGVuSW50ZXJlc2V0Tm90aW9uYWxBZnRlcgAAAAFpAQAAABBpbmNyZWFzZVBvc2l0aW9uAAAAAwAAAApfZGlyZWN0aW9uAAAACV9sZXZlcmFnZQAAABNfbWluQmFzZUFzc2V0QW1vdW50BAAAAApfcmF3QW1vdW50CAkAAZEAAAACCAUAAAABaQAAAAhwYXltZW50cwAAAAAAAAAAAAAAAAZhbW91bnQDAwMDAwMDCQEAAAACIT0AAAACBQAAAApfZGlyZWN0aW9uBQAAAAhESVJfTE9ORwkBAAAAAiE9AAAAAgUAAAAKX2RpcmVjdGlvbgUAAAAJRElSX1NIT1JUBwYJAABnAAAAAgAAAAAAAAAAAAUAAAAKX3Jhd0Ftb3VudAYDCQAAZgAAAAIJAABoAAAAAgAAAAAAAAAAAQUAAAAMREVDSU1BTF9VTklUBQAAAAlfbGV2ZXJhZ2UGCQAAZgAAAAIFAAAACV9sZXZlcmFnZQkAAGgAAAACAAAAAAAAAAADBQAAAAxERUNJTUFMX1VOSVQGCQEAAAABIQAAAAEJAQAAAAtpbml0aWFsaXplZAAAAAAGCQEAAAACIT0AAAACCAkAAZEAAAACCAUAAAABaQAAAAhwYXltZW50cwAAAAAAAAAAAAAAAAdhc3NldElkBQAAAARVU0ROBgkBAAAAASEAAAABCQEAAAAWcmVxdWlyZU1vcmVNYXJnaW5SYXRpbwAAAAMJAQAAAARkaXZkAAAAAgUAAAAMREVDSU1BTF9VTklUBQAAAAlfbGV2ZXJhZ2UJAQAAAA9pbml0TWFyZ2luUmF0aW8AAAAABgkAAAIAAAABAgAAACNJbnZhbGlkIGluY3JlYXNlUG9zaXRpb24gcGFyYW1ldGVycwQAAAAJZmVlQW1vdW50CQEAAAAEbXVsZAAAAAIFAAAACl9yYXdBbW91bnQJAQAAAANmZWUAAAAABAAAAAdfYW1vdW50CQAAZQAAAAIFAAAACl9yYXdBbW91bnQFAAAACWZlZUFtb3VudAQAAAANJHQwMTgxNzYxODMyOAkBAAAAC2dldFBvc2l0aW9uAAAAAQkABCUAAAABCAUAAAABaQAAAAZjYWxsZXIEAAAAD29sZFBvc2l0aW9uU2l6ZQgFAAAADSR0MDE4MTc2MTgzMjgAAAACXzEEAAAAEW9sZFBvc2l0aW9uTWFyZ2luCAUAAAANJHQwMTgxNzYxODMyOAAAAAJfMgQAAAAXb2xkUG9zaXRpb25PcGVuTm90aW9uYWwIBQAAAA0kdDAxODE3NjE4MzI4AAAAAl8zBAAAABRvbGRQb3NpdGlvbkxzdFVwZENQRggFAAAADSR0MDE4MTc2MTgzMjgAAAACXzQEAAAADWlzTmV3UG9zaXRpb24JAAAAAAAAAgUAAAAPb2xkUG9zaXRpb25TaXplAAAAAAAAAAAABAAAAA9pc1NhbWVEaXJlY3Rpb24DCQAAZgAAAAIFAAAAD29sZFBvc2l0aW9uU2l6ZQAAAAAAAAAAAAkAAAAAAAACBQAAAApfZGlyZWN0aW9uBQAAAAhESVJfTE9ORwkAAAAAAAACBQAAAApfZGlyZWN0aW9uBQAAAAlESVJfU0hPUlQEAAAADmV4cGFuZEV4aXN0aW5nAwkBAAAAASEAAAABBQAAAA1pc05ld1Bvc2l0aW9uBQAAAA9pc1NhbWVEaXJlY3Rpb24HBAAAAAVpc0FkZAkAAAAAAAACBQAAAApfZGlyZWN0aW9uBQAAAAhESVJfTE9ORwQAAAANJHQwMTg2MTcyMDgwNQMDBQAAAA1pc05ld1Bvc2l0aW9uBgUAAAAOZXhwYW5kRXhpc3RpbmcEAAAADG9wZW5Ob3Rpb25hbAkBAAAABG11bGQAAAACBQAAAAdfYW1vdW50BQAAAAlfbGV2ZXJhZ2UEAAAADSR0MDE5MDE5MTkyNTAJAQAAAAlzd2FwSW5wdXQAAAACBQAAAAVpc0FkZAUAAAAMb3Blbk5vdGlvbmFsBAAAABVhbW91bnRCYXNlQXNzZXRCb3VnaHQIBQAAAA0kdDAxOTAxOTE5MjUwAAAAAl8xBAAAAAtxdEFzdFJBZnRlcggFAAAADSR0MDE5MDE5MTkyNTAAAAACXzIEAAAAC2JzQXN0UkFmdGVyCAUAAAANJHQwMTkwMTkxOTI1MAAAAAJfMwQAAAAkYmFzZUFzc2V0RGVsdGFUaGlzRnVuZGluZ1BlcmlvZEFmdGVyCAUAAAANJHQwMTkwMTkxOTI1MAAAAAJfNAQAAAAWdG90YWxQb3NpdGlvblNpemVBZnRlcggFAAAADSR0MDE5MDE5MTkyNTAAAAACXzUEAAAAF2N1bXVsYXRpdmVOb3Rpb25hbEFmdGVyCAUAAAANJHQwMTkwMTkxOTI1MAAAAAJfNgMDCQEAAAACIT0AAAACBQAAABNfbWluQmFzZUFzc2V0QW1vdW50AAAAAAAAAAAACQAAZgAAAAIFAAAAE19taW5CYXNlQXNzZXRBbW91bnQJAQAAAANhYnMAAAABBQAAABVhbW91bnRCYXNlQXNzZXRCb3VnaHQHCQAAAgAAAAEJAAEsAAAAAgkAASwAAAACCQABLAAAAAICAAAADUxpbWl0IGVycm9yOiAJAAGkAAAAAQkBAAAAA2FicwAAAAEFAAAAFWFtb3VudEJhc2VBc3NldEJvdWdodAIAAAADIDwgCQABpAAAAAEFAAAAE19taW5CYXNlQXNzZXRBbW91bnQEAAAAD25ld1Bvc2l0aW9uU2l6ZQkAAGQAAAACBQAAAA9vbGRQb3NpdGlvblNpemUFAAAAFWFtb3VudEJhc2VBc3NldEJvdWdodAQAAAAZaW5jcmVhc2VNYXJnaW5SZXF1aXJlbWVudAkBAAAABGRpdmQAAAACBQAAAAxvcGVuTm90aW9uYWwFAAAACV9sZXZlcmFnZQQAAAANJHQwMTk2MzExOTg4NAkBAAAAImNhbGNSZW1haW5NYXJnaW5XaXRoRnVuZGluZ1BheW1lbnQAAAAEBQAAAA9vbGRQb3NpdGlvblNpemUFAAAAEW9sZFBvc2l0aW9uTWFyZ2luBQAAABRvbGRQb3NpdGlvbkxzdFVwZENQRgUAAAAZaW5jcmVhc2VNYXJnaW5SZXF1aXJlbWVudAQAAAAMcmVtYWluTWFyZ2luCAUAAAANJHQwMTk2MzExOTg4NAAAAAJfMQQAAAACeDEIBQAAAA0kdDAxOTYzMTE5ODg0AAAAAl8yBAAAAAJ4MggFAAAADSR0MDE5NjMxMTk4ODQAAAACXzMEAAAADG9sZExhdGVzdENQRggFAAAADSR0MDE5NjMxMTk4ODQAAAACXzQJAAUcAAAACgUAAAAPbmV3UG9zaXRpb25TaXplBQAAAAxyZW1haW5NYXJnaW4JAABkAAAAAgUAAAAXb2xkUG9zaXRpb25PcGVuTm90aW9uYWwFAAAADG9wZW5Ob3Rpb25hbAUAAAAMb2xkTGF0ZXN0Q1BGBQAAAAtic0FzdFJBZnRlcgUAAAALcXRBc3RSQWZ0ZXIFAAAAJGJhc2VBc3NldERlbHRhVGhpc0Z1bmRpbmdQZXJpb2RBZnRlcgUAAAAWdG90YWxQb3NpdGlvblNpemVBZnRlcgUAAAAXY3VtdWxhdGl2ZU5vdGlvbmFsQWZ0ZXIJAABkAAAAAgkBAAAAFW9wZW5JbnRlcmVzZXROb3Rpb25hbAAAAAAFAAAADG9wZW5Ob3Rpb25hbAQAAAAMb3Blbk5vdGlvbmFsCQEAAAAEbXVsZAAAAAIFAAAAB19hbW91bnQFAAAACV9sZXZlcmFnZQQAAAANJHQwMjA1MTUyMDYxNAkBAAAAI2dldFBvc2l0aW9uTm90aW9uYWxBbmRVbnJlYWxpemVkUG5sAAAAAQkABCUAAAABCAUAAAABaQAAAAZjYWxsZXIEAAAAE29sZFBvc2l0aW9uTm90aW9uYWwIBQAAAA0kdDAyMDUxNTIwNjE0AAAAAl8xBAAAAA11bnJlYWxpemVkUG5sCAUAAAANJHQwMjA1MTUyMDYxNAAAAAJfMgMJAABmAAAAAgUAAAATb2xkUG9zaXRpb25Ob3Rpb25hbAUAAAAMb3Blbk5vdGlvbmFsCQAAAgAAAAECAAAALlVzZSBkZWNyZWFzZVBvc2l0aW9uIHRvIGRlY3JlYXNlIHBvc2l0aW9uIHNpemUJAAACAAAAAQIAAAAUQ2xvc2UgcG9zaXRpb24gZmlyc3QEAAAAD25ld1Bvc2l0aW9uU2l6ZQgFAAAADSR0MDE4NjE3MjA4MDUAAAACXzEEAAAAF25ld1Bvc2l0aW9uUmVtYWluTWFyZ2luCAUAAAANJHQwMTg2MTcyMDgwNQAAAAJfMgQAAAAWbmV3UG9zaWlvbk9wZW5Ob3Rpb25hbAgFAAAADSR0MDE4NjE3MjA4MDUAAAACXzMEAAAAFG5ld1Bvc2l0aW9uTGF0ZXN0Q1BGCAUAAAANJHQwMTg2MTcyMDgwNQAAAAJfNAQAAAALYnNBc3RSQWZ0ZXIIBQAAAA0kdDAxODYxNzIwODA1AAAAAl81BAAAAAtxdEFzdFJBZnRlcggFAAAADSR0MDE4NjE3MjA4MDUAAAACXzYEAAAAJGJhc2VBc3NldERlbHRhVGhpc0Z1bmRpbmdQZXJpb2RBZnRlcggFAAAADSR0MDE4NjE3MjA4MDUAAAACXzcEAAAAFnRvdGFsUG9zaXRpb25TaXplQWZ0ZXIIBQAAAA0kdDAxODYxNzIwODA1AAAAAl84BAAAABdjdW11bGF0aXZlTm90aW9uYWxBZnRlcggFAAAADSR0MDE4NjE3MjA4MDUAAAACXzkEAAAAGm9wZW5JbnRlcmVzZXROb3Rpb25hbEFmdGVyCAUAAAANJHQwMTg2MTcyMDgwNQAAAANfMTAEAAAABXN0YWtlCQAD/AAAAAQFAAAADFVTRE5fU1RBS0lORwIAAAAMbG9ja05ldXRyaW5vBQAAAANuaWwJAARMAAAAAgkBAAAAD0F0dGFjaGVkUGF5bWVudAAAAAIFAAAABFVTRE4FAAAAB19hbW91bnQFAAAAA25pbAMJAAAAAAAAAgUAAAAFc3Rha2UFAAAABXN0YWtlCQAETgAAAAIJAAROAAAAAgkABE4AAAACCQEAAAAOdXBkYXRlUG9zaXRpb24AAAAFCQAEJQAAAAEIBQAAAAFpAAAABmNhbGxlcgUAAAAPbmV3UG9zaXRpb25TaXplBQAAABduZXdQb3NpdGlvblJlbWFpbk1hcmdpbgUAAAAWbmV3UG9zaWlvbk9wZW5Ob3Rpb25hbAUAAAAUbmV3UG9zaXRpb25MYXRlc3RDUEYJAQAAAAl1cGRhdGVBbW0AAAAGBQAAAAtxdEFzdFJBZnRlcgUAAAALYnNBc3RSQWZ0ZXIFAAAAJGJhc2VBc3NldERlbHRhVGhpc0Z1bmRpbmdQZXJpb2RBZnRlcgUAAAAWdG90YWxQb3NpdGlvblNpemVBZnRlcgUAAAAXY3VtdWxhdGl2ZU5vdGlvbmFsQWZ0ZXIFAAAAGm9wZW5JbnRlcmVzZXROb3Rpb25hbEFmdGVyCQEAAAALdHJhbnNmZXJGZWUAAAABBQAAAAlmZWVBbW91bnQJAQAAAAV1cGJsYwAAAAEJAABkAAAAAgkBAAAACGNiYWxhbmNlAAAAAAUAAAAHX2Ftb3VudAkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4AAAABaQEAAAAJYWRkTWFyZ2luAAAAAAQAAAAKX3Jhd0Ftb3VudAgJAAGRAAAAAggFAAAAAWkAAAAIcGF5bWVudHMAAAAAAAAAAAAAAAAGYW1vdW50AwMJAQAAAAIhPQAAAAIICQABkQAAAAIIBQAAAAFpAAAACHBheW1lbnRzAAAAAAAAAAAAAAAAB2Fzc2V0SWQFAAAABFVTRE4GCQEAAAABIQAAAAEJAQAAABNyZXF1aXJlT3BlblBvc2l0aW9uAAAAAQkABCUAAAABCAUAAAABaQAAAAZjYWxsZXIJAAACAAAAAQIAAAAcSW52YWxpZCBhZGRNYXJnaW4gcGFyYW1ldGVycwQAAAAJZmVlQW1vdW50CQEAAAAEbXVsZAAAAAIFAAAACl9yYXdBbW91bnQJAQAAAANmZWUAAAAABAAAAAdfYW1vdW50CQAAZQAAAAIFAAAACl9yYXdBbW91bnQFAAAACWZlZUFtb3VudAQAAAANJHQwMjE3MDcyMTg1OQkBAAAAC2dldFBvc2l0aW9uAAAAAQkABCUAAAABCAUAAAABaQAAAAZjYWxsZXIEAAAAD29sZFBvc2l0aW9uU2l6ZQgFAAAADSR0MDIxNzA3MjE4NTkAAAACXzEEAAAAEW9sZFBvc2l0aW9uTWFyZ2luCAUAAAANJHQwMjE3MDcyMTg1OQAAAAJfMgQAAAAXb2xkUG9zaXRpb25PcGVuTm90aW9uYWwIBQAAAA0kdDAyMTcwNzIxODU5AAAAAl8zBAAAABRvbGRQb3NpdGlvbkxzdFVwZENQRggFAAAADSR0MDIxNzA3MjE4NTkAAAACXzQEAAAABXN0YWtlCQAD/AAAAAQFAAAADFVTRE5fU1RBS0lORwIAAAAMbG9ja05ldXRyaW5vBQAAAANuaWwJAARMAAAAAgkBAAAAD0F0dGFjaGVkUGF5bWVudAAAAAIFAAAABFVTRE4FAAAAB19hbW91bnQFAAAAA25pbAMJAAAAAAAAAgUAAAAFc3Rha2UFAAAABXN0YWtlCQAETgAAAAIJAAROAAAAAgkBAAAADnVwZGF0ZVBvc2l0aW9uAAAABQkABCUAAAABCAUAAAABaQAAAAZjYWxsZXIFAAAAD29sZFBvc2l0aW9uU2l6ZQkAAGQAAAACBQAAABFvbGRQb3NpdGlvbk1hcmdpbggJAAGRAAAAAggFAAAAAWkAAAAIcGF5bWVudHMAAAAAAAAAAAAAAAAGYW1vdW50BQAAABdvbGRQb3NpdGlvbk9wZW5Ob3Rpb25hbAUAAAAUb2xkUG9zaXRpb25Mc3RVcGRDUEYJAQAAAAt0cmFuc2ZlckZlZQAAAAEFAAAACWZlZUFtb3VudAkBAAAABXVwYmxjAAAAAQkAAGQAAAACCQEAAAAIY2JhbGFuY2UAAAAABQAAAAdfYW1vdW50CQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgAAAAFpAQAAAAxyZW1vdmVNYXJnaW4AAAABAAAAB19hbW91bnQDAwkAAGcAAAACAAAAAAAAAAAABQAAAAdfYW1vdW50BgkBAAAAASEAAAABCQEAAAATcmVxdWlyZU9wZW5Qb3NpdGlvbgAAAAEJAAQlAAAAAQgFAAAAAWkAAAAGY2FsbGVyCQAAAgAAAAECAAAAH0ludmFsaWQgcmVtb3ZlTWFyZ2luIHBhcmFtZXRlcnMEAAAADSR0MDIyNDQ1MjI1OTcJAQAAAAtnZXRQb3NpdGlvbgAAAAEJAAQlAAAAAQgFAAAAAWkAAAAGY2FsbGVyBAAAAA9vbGRQb3NpdGlvblNpemUIBQAAAA0kdDAyMjQ0NTIyNTk3AAAAAl8xBAAAABFvbGRQb3NpdGlvbk1hcmdpbggFAAAADSR0MDIyNDQ1MjI1OTcAAAACXzIEAAAAF29sZFBvc2l0aW9uT3Blbk5vdGlvbmFsCAUAAAANJHQwMjI0NDUyMjU5NwAAAAJfMwQAAAAUb2xkUG9zaXRpb25Mc3RVcGRDUEYIBQAAAA0kdDAyMjQ0NTIyNTk3AAAAAl80BAAAAAttYXJnaW5EZWx0YQkBAAAAAS0AAAABBQAAAAdfYW1vdW50BAAAAA0kdDAyMjYzNDIyODI5CQEAAAAiY2FsY1JlbWFpbk1hcmdpbldpdGhGdW5kaW5nUGF5bWVudAAAAAQFAAAAD29sZFBvc2l0aW9uU2l6ZQUAAAARb2xkUG9zaXRpb25NYXJnaW4FAAAAFG9sZFBvc2l0aW9uTHN0VXBkQ1BGBQAAAAttYXJnaW5EZWx0YQQAAAAMcmVtYWluTWFyZ2luCAUAAAANJHQwMjI2MzQyMjgyOQAAAAJfMQQAAAAHYmFkRGVidAgFAAAADSR0MDIyNjM0MjI4MjkAAAACXzIEAAAAAngxCAUAAAANJHQwMjI2MzQyMjgyOQAAAAJfMwQAAAAKbGF0ZXN0Q1BGMQgFAAAADSR0MDIyNjM0MjI4MjkAAAACXzQDCQEAAAACIT0AAAACBQAAAAdiYWREZWJ0AAAAAAAAAAAACQAAAgAAAAECAAAAG0ludmFsaWQgYWRkZWQgbWFyZ2luIGFtb3VudAQAAAAHdW5zdGFrZQkAA/wAAAAEBQAAAAxVU0ROX1NUQUtJTkcCAAAADnVubG9ja05ldXRyaW5vCQAETAAAAAIFAAAAB19hbW91bnQJAARMAAAAAgkAAlgAAAABBQAAAARVU0ROBQAAAANuaWwFAAAAA25pbAMJAAAAAAAAAgUAAAAHdW5zdGFrZQUAAAAHdW5zdGFrZQkABE4AAAACCQAETgAAAAIJAQAAAA51cGRhdGVQb3NpdGlvbgAAAAUJAAQlAAAAAQgFAAAAAWkAAAAGY2FsbGVyBQAAAA9vbGRQb3NpdGlvblNpemUFAAAADHJlbWFpbk1hcmdpbgUAAAAXb2xkUG9zaXRpb25PcGVuTm90aW9uYWwFAAAACmxhdGVzdENQRjEJAQAAAAh3aXRoZHJhdwAAAAIIBQAAAAFpAAAABmNhbGxlcgUAAAAHX2Ftb3VudAkBAAAABXVwYmxjAAAAAQkAAGUAAAACCQEAAAAIY2JhbGFuY2UAAAAABQAAAAdfYW1vdW50CQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgAAAAFpAQAAAA1jbG9zZVBvc2l0aW9uAAAAAAMJAQAAAAEhAAAAAQkBAAAAE3JlcXVpcmVPcGVuUG9zaXRpb24AAAABCQAEJQAAAAEIBQAAAAFpAAAABmNhbGxlcgkAAAIAAAABAgAAACBJbnZhbGlkIGNsb3NlUG9zaXRpb24gcGFyYW1ldGVycwQAAAANJHQwMjM0NzkyMzgyNwkBAAAAFWludGVybmFsQ2xvc2VQb3NpdGlvbgAAAAEJAAQlAAAAAQgFAAAAAWkAAAAGY2FsbGVyBAAAAAJ4MQgFAAAADSR0MDIzNDc5MjM4MjcAAAACXzEEAAAAB2JhZERlYnQIBQAAAA0kdDAyMzQ3OTIzODI3AAAAAl8yBAAAAAtyZWFsaXplZFBubAgFAAAADSR0MDIzNDc5MjM4MjcAAAACXzMEAAAADW1hcmdpblRvVmF1bHQIBQAAAA0kdDAyMzQ3OTIzODI3AAAAAl80BAAAABZxdW90ZUFzc2V0UmVzZXJ2ZUFmdGVyCAUAAAANJHQwMjM0NzkyMzgyNwAAAAJfNQQAAAALYnNBc3RSQWZ0ZXIIBQAAAA0kdDAyMzQ3OTIzODI3AAAAAl82BAAAACRiYXNlQXNzZXREZWx0YVRoaXNGdW5kaW5nUGVyaW9kQWZ0ZXIIBQAAAA0kdDAyMzQ3OTIzODI3AAAAAl83BAAAABZ0b3RhbFBvc2l0aW9uU2l6ZUFmdGVyCAUAAAANJHQwMjM0NzkyMzgyNwAAAAJfOAQAAAAXY3VtdWxhdGl2ZU5vdGlvbmFsQWZ0ZXIIBQAAAA0kdDAyMzQ3OTIzODI3AAAAAl85BAAAABpvcGVuSW50ZXJlc2V0Tm90aW9uYWxBZnRlcggFAAAADSR0MDIzNDc5MjM4MjcAAAADXzEwAwkAAGYAAAACBQAAAAdiYWREZWJ0AAAAAAAAAAAACQAAAgAAAAECAAAAJlVuYWJsZSB0byBjbG9zZSBwb3NpdGlvbiB3aXRoIGJhZCBkZWJ0BAAAAA53aXRoZHJhd0Ftb3VudAkBAAAAA2FicwAAAAEFAAAADW1hcmdpblRvVmF1bHQEAAAAAmJkCQAAZQAAAAIJAQAAAAhjYmFsYW5jZQAAAAAFAAAADndpdGhkcmF3QW1vdW50BAAAAA0kdDAyNDAyMDI0MTE2AwkAAGYAAAACAAAAAAAAAAAABQAAAAJiZAkABRQAAAACAAAAAAAAAAAACQEAAAADYWJzAAAAAQUAAAACYmQJAAUUAAAAAgUAAAACYmQAAAAAAAAAAAAEAAAAAm5iCAUAAAANJHQwMjQwMjAyNDExNgAAAAJfMQQAAAAFZnJvbWkIBQAAAA0kdDAyNDAyMDI0MTE2AAAAAl8yBAAAAAF4AwkAAGYAAAACBQAAAAVmcm9taQAAAAAAAAAAAAQAAAARd2l0aGRyYXdJbnN1cmFuY2UJAAP8AAAABAUAAAARSU5TVVJBTkNFX0FERFJFU1MCAAAACHdpdGhkcmF3CQAETAAAAAIFAAAABWZyb21pBQAAAANuaWwFAAAAA25pbAMJAAAAAAAAAgUAAAARd2l0aGRyYXdJbnN1cmFuY2UFAAAAEXdpdGhkcmF3SW5zdXJhbmNlBQAAAANuaWwJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuBQAAAANuaWwDCQAAAAAAAAIFAAAAAXgFAAAAAXgEAAAAB3Vuc3Rha2UJAAP8AAAABAUAAAAMVVNETl9TVEFLSU5HAgAAAA51bmxvY2tOZXV0cmlubwkABEwAAAACCQAAZQAAAAIFAAAADndpdGhkcmF3QW1vdW50BQAAAAVmcm9taQkABEwAAAACCQACWAAAAAEFAAAABFVTRE4FAAAAA25pbAUAAAADbmlsAwkAAAAAAAACBQAAAAd1bnN0YWtlBQAAAAd1bnN0YWtlCQAETgAAAAIJAAROAAAAAgkABE4AAAACCQEAAAAOZGVsZXRlUG9zaXRpb24AAAABCQAEJQAAAAEIBQAAAAFpAAAABmNhbGxlcgkBAAAACXVwZGF0ZUFtbQAAAAYFAAAAFnF1b3RlQXNzZXRSZXNlcnZlQWZ0ZXIFAAAAC2JzQXN0UkFmdGVyBQAAACRiYXNlQXNzZXREZWx0YVRoaXNGdW5kaW5nUGVyaW9kQWZ0ZXIFAAAAFnRvdGFsUG9zaXRpb25TaXplQWZ0ZXIFAAAAF2N1bXVsYXRpdmVOb3Rpb25hbEFmdGVyBQAAABpvcGVuSW50ZXJlc2V0Tm90aW9uYWxBZnRlcgkBAAAACHdpdGhkcmF3AAAAAggFAAAAAWkAAAAGY2FsbGVyBQAAAA53aXRoZHJhd0Ftb3VudAkBAAAABXVwYmxjAAAAAQUAAAACbmIJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgAAAAFpAQAAAAlsaXF1aWRhdGUAAAABAAAAB190cmFkZXIDAwkBAAAAASEAAAABCQEAAAAWcmVxdWlyZU1vcmVNYXJnaW5SYXRpbwAAAAMJAQAAAA5nZXRNYXJnaW5SYXRpbwAAAAEFAAAAB190cmFkZXIJAQAAAANtbXIAAAAABwYJAQAAAAEhAAAAAQkBAAAAC2luaXRpYWxpemVkAAAAAAkAAAIAAAABAgAAABNVbmFibGUgdG8gbGlxdWlkYXRlBAAAAA0kdDAyNTA3MDI1MzkwCQEAAAAVaW50ZXJuYWxDbG9zZVBvc2l0aW9uAAAAAQUAAAAHX3RyYWRlcgQAAAACeDEIBQAAAA0kdDAyNTA3MDI1MzkwAAAAAl8xBAAAAAdiYWREZWJ0CAUAAAANJHQwMjUwNzAyNTM5MAAAAAJfMgQAAAACeDIIBQAAAA0kdDAyNTA3MDI1MzkwAAAAAl8zBAAAAA1tYXJnaW5Ub1ZhdWx0CAUAAAANJHQwMjUwNzAyNTM5MAAAAAJfNAQAAAAWcXVvdGVBc3NldFJlc2VydmVBZnRlcggFAAAADSR0MDI1MDcwMjUzOTAAAAACXzUEAAAAC2JzQXN0UkFmdGVyCAUAAAANJHQwMjUwNzAyNTM5MAAAAAJfNgQAAAAkYmFzZUFzc2V0RGVsdGFUaGlzRnVuZGluZ1BlcmlvZEFmdGVyCAUAAAANJHQwMjUwNzAyNTM5MAAAAAJfNwQAAAAWdG90YWxQb3NpdGlvblNpemVBZnRlcggFAAAADSR0MDI1MDcwMjUzOTAAAAACXzgEAAAAF2N1bXVsYXRpdmVOb3Rpb25hbEFmdGVyCAUAAAANJHQwMjUwNzAyNTM5MAAAAAJfOQQAAAAab3BlbkludGVyZXNldE5vdGlvbmFsQWZ0ZXIIBQAAAA0kdDAyNTA3MDI1MzkwAAAAA18xMAQAAAAZZXhjaGFuZ2VkUXVvdGVBc3NldEFtb3VudAgFAAAADSR0MDI1MDcwMjUzOTAAAAADXzExBAAAAA9mZWVUb0xpcXVpZGF0b3IJAABpAAAAAgkBAAAABG11bGQAAAACBQAAABlleGNoYW5nZWRRdW90ZUFzc2V0QW1vdW50CQEAAAATbGlxdWlkYXRpb25GZWVSYXRpbwAAAAAAAAAAAAAAAAIEAAAADSR0MDI1NDgwMjU4ODQDCQAAZgAAAAIFAAAAD2ZlZVRvTGlxdWlkYXRvcgUAAAANbWFyZ2luVG9WYXVsdAkABRUAAAADCQAAZQAAAAIFAAAAD2ZlZVRvTGlxdWlkYXRvcgUAAAANbWFyZ2luVG9WYXVsdAUAAAANbWFyZ2luVG9WYXVsdAkAAGUAAAACCQAAZAAAAAIFAAAAB2JhZERlYnQFAAAAD2ZlZVRvTGlxdWlkYXRvcgUAAAANbWFyZ2luVG9WYXVsdAkABRUAAAADAAAAAAAAAAAACQAAZQAAAAIFAAAADW1hcmdpblRvVmF1bHQFAAAAD2ZlZVRvTGlxdWlkYXRvcgUAAAAHYmFkRGVidAQAAAASbGlxdWlkYXRpb25CYWREZWJ0CAUAAAANJHQwMjU0ODAyNTg4NAAAAAJfMQQAAAAMcmVtYWluTWFyZ2luCAUAAAANJHQwMjU0ODAyNTg4NAAAAAJfMgQAAAAMdG90YWxCYWREZWJ0CAUAAAANJHQwMjU0ODAyNTg4NAAAAAJfMwkABE4AAAACCQAETgAAAAIJAQAAAA5kZWxldGVQb3NpdGlvbgAAAAEFAAAAB190cmFkZXIJAQAAAAl1cGRhdGVBbW0AAAAGBQAAABZxdW90ZUFzc2V0UmVzZXJ2ZUFmdGVyBQAAAAtic0FzdFJBZnRlcgUAAAAkYmFzZUFzc2V0RGVsdGFUaGlzRnVuZGluZ1BlcmlvZEFmdGVyBQAAABZ0b3RhbFBvc2l0aW9uU2l6ZUFmdGVyBQAAABdjdW11bGF0aXZlTm90aW9uYWxBZnRlcgUAAAAab3BlbkludGVyZXNldE5vdGlvbmFsQWZ0ZXIJAQAAAAh3aXRoZHJhdwAAAAIIBQAAAAFpAAAABmNhbGxlcgUAAAAPZmVlVG9MaXF1aWRhdG9yAAAAAWkBAAAACnBheUZ1bmRpbmcAAAAABAAAABVmdW5kaW5nQmxvY2tUaW1lc3RhbXAJAQAAABluZXh0RnVuZGluZ0Jsb2NrVGltZXN0YW1wAAAAAAMDCQAAZgAAAAIFAAAAFWZ1bmRpbmdCbG9ja1RpbWVzdGFtcAgFAAAACWxhc3RCbG9jawAAAAl0aW1lc3RhbXAGCQEAAAABIQAAAAEJAQAAAAtpbml0aWFsaXplZAAAAAAJAAACAAAAAQkAASwAAAACCQABLAAAAAIJAAEsAAAAAgIAAAAhSW52YWxpZCBmdW5kaW5nIGJsb2NrIHRpbWVzdGFtcDogCQABpAAAAAEIBQAAAAlsYXN0QmxvY2sAAAAJdGltZXN0YW1wAgAAAAMgPCAJAAGkAAAAAQUAAAAVZnVuZGluZ0Jsb2NrVGltZXN0YW1wBAAAAA91bmRlcmx5aW5nUHJpY2UJAQAAABJnZXRPcmFjbGVUd2FwUHJpY2UAAAAABAAAAA1zcG90VHdhcFByaWNlCQEAAAAQZ2V0VHdhcFNwb3RQcmljZQAAAAAEAAAAB3ByZW1pdW0JAABlAAAAAgUAAAANc3BvdFR3YXBQcmljZQUAAAAPdW5kZXJseWluZ1ByaWNlBAAAAA9wcmVtaXVtRnJhY3Rpb24JAQAAAARkaXZkAAAAAgkBAAAABG11bGQAAAACBQAAAAdwcmVtaXVtCQEAAAAUZnVuZGluZ1BlcmlvZERlY2ltYWwAAAAABQAAAAdPTkVfREFZBAAAABd0b3RhbFRyYWRlclBvc2l0aW9uU2l6ZQkBAAAAEXRvdGFsUG9zaXRpb25TaXplAAAAAAQAAAAXYW1tRnVuZGluZ1BheW1lbnRQcm9maXQJAQAAAARtdWxkAAAAAgUAAAAPcHJlbWl1bUZyYWN0aW9uBQAAABd0b3RhbFRyYWRlclBvc2l0aW9uU2l6ZQQAAAANZnVuZGluZ0Ftb3VudAkBAAAAA2FicwAAAAEFAAAAF2FtbUZ1bmRpbmdQYXltZW50UHJvZml0AwkAAGYAAAACAAAAAAAAAAAABQAAABdhbW1GdW5kaW5nUGF5bWVudFByb2ZpdAQAAAARd2l0aGRyYXdJbnN1cmFuY2UJAAP8AAAABAUAAAARSU5TVVJBTkNFX0FERFJFU1MCAAAACHdpdGhkcmF3CQAETAAAAAIFAAAADWZ1bmRpbmdBbW91bnQFAAAAA25pbAUAAAADbmlsAwkAAAAAAAACBQAAABF3aXRoZHJhd0luc3VyYW5jZQUAAAARd2l0aGRyYXdJbnN1cmFuY2UEAAAABXN0YWtlCQAD/AAAAAQFAAAADFVTRE5fU1RBS0lORwIAAAAMbG9ja05ldXRyaW5vBQAAAANuaWwJAARMAAAAAgkBAAAAD0F0dGFjaGVkUGF5bWVudAAAAAIFAAAABFVTRE4FAAAADWZ1bmRpbmdBbW91bnQFAAAAA25pbAMJAAAAAAAAAgUAAAAFc3Rha2UFAAAABXN0YWtlCQEAAAAFdXBibGMAAAABCQAAZAAAAAIJAQAAAAhjYmFsYW5jZQAAAAAFAAAADWZ1bmRpbmdBbW91bnQJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkABE4AAAACBAAAAAd1bnN0YWtlCQAD/AAAAAQFAAAADFVTRE5fU1RBS0lORwIAAAAOdW5sb2NrTmV1dHJpbm8JAARMAAAAAgUAAAANZnVuZGluZ0Ftb3VudAkABEwAAAACCQACWAAAAAEFAAAABFVTRE4FAAAAA25pbAUAAAADbmlsAwkAAAAAAAACBQAAAAd1bnN0YWtlBQAAAAd1bnN0YWtlBAAAABBkZXBvc2l0SW5zdXJhbmNlCQAD/AAAAAQFAAAAEUlOU1VSQU5DRV9BRERSRVNTAgAAAAdkZXBvc2l0BQAAAANuaWwJAARMAAAAAgkBAAAAD0F0dGFjaGVkUGF5bWVudAAAAAIFAAAABFVTRE4FAAAADWZ1bmRpbmdBbW91bnQFAAAAA25pbAMJAAAAAAAAAgUAAAAQZGVwb3NpdEluc3VyYW5jZQUAAAAQZGVwb3NpdEluc3VyYW5jZQkBAAAABXVwYmxjAAAAAQkAAGUAAAACCQEAAAAIY2JhbGFuY2UAAAAABQAAAA1mdW5kaW5nQW1vdW50CQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAQAAAA11cGRhdGVGdW5kaW5nAAAABAAAAAAAAAAAAAkAAGQAAAACBQAAABVmdW5kaW5nQmxvY2tUaW1lc3RhbXAJAQAAABRmdW5kaW5nUGVyaW9kU2Vjb25kcwAAAAAJAABkAAAAAgkBAAAACWxhdGVzdENQRgAAAAAFAAAAD3ByZW1pdW1GcmFjdGlvbgkBAAAABGRpdmQAAAACBQAAAA9wcmVtaXVtRnJhY3Rpb24FAAAAD3VuZGVybHlpbmdQcmljZQAAAAEAAAACdHgBAAAABnZlcmlmeQAAAAAJAAH0AAAAAwgFAAAAAnR4AAAACWJvZHlCeXRlcwkAAZEAAAACCAUAAAACdHgAAAAGcHJvb2ZzAAAAAAAAAAAABQAAABBBRE1JTl9QVUJMSUNfS0VZfMbsrQ==",
    "height": 2064275,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 5 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let a = "price"
5+
6+let b = "k_balance"
7+
8+let c = "k_positionSize"
9+
10+let d = "k_positionMargin"
11+
12+let e = "k_pon"
13+
14+let f = "k_positionFraction"
15+
16+let g = "k_initialized"
17+
18+let h = "k_fee"
19+
20+let i = "k_fundingPeriod"
21+
22+let j = "k_initMarginRatio"
23+
24+let k = "k_mmr"
25+
26+let l = "k_liquidationFeeRatio"
27+
28+let m = "k_latestPremiumFraction"
29+
30+let n = "k_nextFundingBlockMinTimestamp"
31+
32+let o = "k_fundingRate"
33+
34+let p = "k_qtAstR"
35+
36+let q = "k_bsAstR"
37+
38+let r = "k_baseAssetDelta"
39+
40+let s = "k_totalPositionSize"
41+
42+let t = "k_cumulativeNotional"
43+
44+let u = "k_openInteresetNotional"
45+
46+let v = Address(base58'3NATpwYAjd9oHzzDGdqMsQQyfrgXyP9Jz45')
47+
48+let w = base58'A6ZtwikNTr19YpC1t6HnNGCBJF6GTx62DhEkJpgpzpmL'
49+
50+let x = base58'HezsdQuRDtzksAYUy97gfhKy7Z1NW2uXYSHA3bgqenNZ'
51+
52+let y = Address(base58'3N9LkJahTMx41wGhSxLS42prCZtRCp4dhTs')
53+
54+let z = Address(base58'3N4NS7d4Jo9a6F14LiFUKKYVdUkkf2eP4Zx')
55+
56+let A = Address(base58'3MseEJNEHkYhvcHre6Mann1F8e27S1qptdg')
57+
58+let B = Address(base58'3Mwnsxd44irC1JNzGfrU4wTjW3icVPgexSa')
59+
60+let C = 1
61+
62+let D = 2
63+
64+let E = 60
65+
66+let F = 1000
67+
68+let G = (1 * (((((10 * 10) * 10) * 10) * 10) * 10))
69+
70+let H = (86400 * G)
71+
72+func I (J,K) = fraction(J, G, K, HALFEVEN)
73+
74+
75+func L (J,K) = fraction(J, K, G, HALFEVEN)
76+
77+
78+func M (J) = if ((J > 0))
79+    then J
80+    else -(J)
81+
82+
83+func N (O,P) = ((O + "_") + P)
84+
85+
86+func Q (R,S,T) = {
87+    let U = (R - S)
88+    if (if (T)
89+        then (0 > U)
90+        else false)
91+        then throw("Invalid margin")
92+        else if (if (!(T))
93+            then (U >= 0)
94+            else false)
95+            then throw("Invalid margin")
96+            else true
97+    }
98+
99+
100+func V (W) = valueOrErrorMessage(getInteger(this, W), ("no value for " + W))
101+
102+
103+func X () = V(b)
104+
105+
106+func Y () = V(h)
107+
108+
109+func Z () = V(j)
110+
111+
112+func aa () = V(p)
113+
114+
115+func ab () = V(q)
116+
117+
118+func ac () = V(r)
119+
120+
121+func ad () = V(s)
122+
123+
124+func ae () = V(t)
125+
126+
127+func af () = V(m)
128+
129+
130+func ag () = V(u)
131+
132+
133+func ah () = V(n)
134+
135+
136+func ai () = V(i)
137+
138+
139+func aj () = (ai() * G)
140+
141+
142+func ak () = (ai() * F)
143+
144+
145+func al () = V(k)
146+
147+
148+func am () = V(l)
149+
150+
151+func an (ao) = {
152+    let ap = getInteger(this, N(c, ao))
153+    let aq = ap
154+    if ($isInstanceOf(aq, "Int"))
155+        then {
156+            let ar = aq
157+            $Tuple4(ar, getIntegerValue(this, N(d, ao)), getIntegerValue(this, N(e, ao)), getIntegerValue(this, N(f, ao)))
158+            }
159+        else $Tuple4(0, 0, 0, 0)
160+    }
161+
162+
163+func as (at) = {
164+    let au = an(at)
165+    let ar = au._1
166+    let av = au._2
167+    let aw = au._3
168+    let ax = au._4
169+    if ((ar == 0))
170+        then throw("No open position")
171+        else true
172+    }
173+
174+
175+func ay () = valueOrElse(getBoolean(this, g), false)
176+
177+
178+func az (aA,aB,aC) = if (aA)
179+    then $Tuple5((aa() + aB), (ab() - aC), (ac() - aC), (ad() + aC), (ae() + aB))
180+    else $Tuple5((aa() - aB), (ab() + aC), (ac() + aC), (ad() - aC), (ae() - aB))
181+
182+
183+func aD (aA,aE) = {
184+    let aF = aa()
185+    let aG = ab()
186+    let W = L(aF, aG)
187+    let aH = if (aA)
188+        then (aF + aE)
189+        else (aF - aE)
190+    let aI = I(W, aH)
191+    let aJ = M((aI - aG))
192+    let aK = if (aA)
193+        then aJ
194+        else -(aJ)
195+    let aL = az(aA, aE, aJ)
196+    let aM = aL._1
197+    let aN = aL._2
198+    let aO = aL._3
199+    let aP = aL._4
200+    let aQ = aL._5
201+    $Tuple6(aK, aM, aN, aO, aP, aQ)
202+    }
203+
204+
205+func aR (aS,aT,aU,aV) = {
206+    let aW = af()
207+    let aX = if ((aS != 0))
208+        then L((aW - aU), aS)
209+        else 0
210+    let aY = ((aV - aX) + aT)
211+    let aZ = if ((0 > aY))
212+        then $Tuple2(0, M(aY))
213+        else $Tuple2(M(aY), 0)
214+    let ba = aZ._1
215+    let bb = aZ._2
216+    $Tuple4(ba, bb, aX, aW)
217+    }
218+
219+
220+func bc (bd,aC,be,bf) = if ((aC == 0))
221+    then throw("Invalid base asset amount")
222+    else {
223+        let W = L(be, bf)
224+        let bg = if (bd)
225+            then (bf + aC)
226+            else (bf - aC)
227+        let bh = I(W, bg)
228+        let bi = M((bh - be))
229+        let bj = az(!(bd), bi, aC)
230+        let aM = bj._1
231+        let aN = bj._2
232+        let aO = bj._3
233+        let aP = bj._4
234+        let aQ = bj._5
235+        $Tuple6(bi, aM, aN, aO, aP, aQ)
236+        }
237+
238+
239+func bk (at) = {
240+    let bl = an(at)
241+    let ar = bl._1
242+    let av = bl._2
243+    let aw = bl._3
244+    let ax = bl._4
245+    let bm = M(ar)
246+    if ((bm == 0))
247+        then throw("Invalid position size")
248+        else {
249+            let bn = (0 > ar)
250+            let bo = bc(!(bn), bm, aa(), ab())
251+            let bp = bo._1
252+            let bq = bo._2
253+            let br = bo._3
254+            let bs = bo._4
255+            let bt = if (bn)
256+                then (aw - bp)
257+                else (bp - aw)
258+            $Tuple2(bp, bt)
259+            }
260+    }
261+
262+
263+func bu () = getIntegerValue(z, a)
264+
265+
266+func bv () = I(aa(), ab())
267+
268+
269+func bw (at) = {
270+    let bx = an(at)
271+    let ar = bx._1
272+    let av = bx._2
273+    let aw = bx._3
274+    let ax = bx._4
275+    let by = bk(at)
276+    let bp = by._1
277+    let bt = by._2
278+    let bz = aR(ar, av, ax, bt)
279+    let ba = bz._1
280+    let bb = bz._2
281+    I((ba - bb), bp)
282+    }
283+
284+
285+func bA (at) = {
286+    let bB = an(at)
287+    let ar = bB._1
288+    let av = bB._2
289+    let aw = bB._3
290+    let ax = bB._4
291+    let bC = bk(at)
292+    let bq = bC._1
293+    let bt = bC._2
294+    let bD = aR(ar, av, ax, bt)
295+    let ba = bD._1
296+    let bb = bD._2
297+    let br = bD._3
298+    let bE = -(ar)
299+    let bF = bt
300+    let bG = -(ba)
301+    let bH = bc((ar > 0), M(ar), aa(), ab())
302+    let bI = bH._1
303+    let bJ = bH._2
304+    let aI = bH._3
305+    let bK = bH._4
306+    let bL = bH._5
307+    let bM = bH._6
308+    let bN = (ag() - aw)
309+    $Tuple11(bE, bb, bF, bG, bJ, aI, bK, bL, bM, bN, bI)
310+    }
311+
312+
313+func bO (bP,bQ,bR,bS,bT) = [IntegerEntry(j, bP), IntegerEntry(k, bQ), IntegerEntry(l, bR), IntegerEntry(i, bS), IntegerEntry(h, bT)]
314+
315+
316+func bU (bV,bW,aW,bX) = [IntegerEntry(r, bV), IntegerEntry(n, bW), IntegerEntry(m, aW), IntegerEntry(o, bX)]
317+
318+
319+func bY (P,bZ,ca,cb,cc) = [IntegerEntry(N(c, P), bZ), IntegerEntry(N(d, P), ca), IntegerEntry(N(e, P), cb), IntegerEntry(N(f, P), cc)]
320+
321+
322+func cd (aF,aG,ce,cf,cg,ch) = [IntegerEntry(p, aF), IntegerEntry(q, aG), IntegerEntry(r, ce), IntegerEntry(s, cf), IntegerEntry(t, cg), IntegerEntry(u, ch)]
323+
324+
325+func ci (P) = [DeleteEntry(N(c, P)), DeleteEntry(N(d, P)), DeleteEntry(N(e, P)), DeleteEntry(N(f, P))]
326+
327+
328+func cj (P,ck) = {
329+    let cl = assetBalance(this, x)
330+    if ((ck > cl))
331+        then throw(((("Unable to withdraw " + toString(ck)) + " from contract balance ") + toString(cl)))
332+        else [ScriptTransfer(P, ck, x)]
333+    }
334+
335+
336+func cm () = [StringEntry("ADMIN_ADDRESS", toString(v)), StringEntry("USDN", toBase58String(x)), StringEntry("USDN_STAKING", toString(y)), StringEntry("ORACLE", toString(z))]
337+
338+
339+func cn (co) = if ((0 > co))
340+    then throw("Balance")
341+    else [IntegerEntry(b, co)]
342+
343+
344+func cp (co) = [ScriptTransfer(A, co, x)]
345+
346+
347+@Callable(co)
348+func initialize (aF,aG,bS,bP,bQ,bR,bT) = if (if (if (if (if (if (if (if ((0 >= aF))
349+    then true
350+    else (0 >= aG))
351+    then true
352+    else (0 >= bS))
353+    then true
354+    else (0 >= bP))
355+    then true
356+    else (0 >= bQ))
357+    then true
358+    else (0 >= bR))
359+    then true
360+    else (co.caller != v))
361+    then true
362+    else ay())
363+    then throw("Invalid initialize parameters")
364+    else (((((cd(aF, aG, 0, 0, 0, 0) ++ bO(bP, bQ, bR, bS, bT)) ++ bU(0, (lastBlock.timestamp + bS), 0, 0)) ++ cn(0)) ++ cm()) ++ [BooleanEntry(g, true)])
365+
366+
367+
368+@Callable(co)
369+func decreasePosition (cq,ck,cr,cs) = if (if (if (if (if (if ((cq != C))
370+    then (cq != D)
371+    else false)
372+    then true
373+    else (0 >= ck))
374+    then true
375+    else if (((1 * G) > cr))
376+        then true
377+        else (cr > (3 * G)))
378+    then true
379+    else !(ay()))
380+    then true
381+    else !(Q(I(G, cr), Z(), true)))
382+    then throw("Invalid decreasePosition parameters")
383+    else {
384+        let ct = an(toString(co.caller))
385+        let cu = ct._1
386+        let cv = ct._2
387+        let cw = ct._3
388+        let cx = ct._4
389+        let cy = (cu == 0)
390+        let cz = if ((cu > 0))
391+            then (cq == C)
392+            else (cq == D)
393+        let cA = if (!(cy))
394+            then cz
395+            else false
396+        let cB = (cq == C)
397+        let cC = if (if (cy)
398+            then true
399+            else cA)
400+            then throw("Use increasePosition to open new or increase position")
401+            else {
402+                let cD = L(ck, cr)
403+                let cE = bk(toString(co.caller))
404+                let cF = cE._1
405+                let bt = cE._2
406+                if ((cF > cD))
407+                    then {
408+                        let cG = aD(cB, cD)
409+                        let bE = cG._1
410+                        let aH = cG._2
411+                        let aI = cG._3
412+                        let bK = cG._4
413+                        let bL = cG._5
414+                        let bM = cG._6
415+                        let cH = M(bE)
416+                        if (if ((cs != 0))
417+                            then (cs > cH)
418+                            else false)
419+                            then throw(((("Too little basse asset exchanged, got " + toString(cH)) + " expected ") + toString(cs)))
420+                            else {
421+                                let bF = if ((cu != 0))
422+                                    then I(L(bt, cH), cu)
423+                                    else 0
424+                                let cI = aR(cu, cv, cx, bF)
425+                                let ba = cI._1
426+                                let bb = cI._2
427+                                let aX = cI._3
428+                                let cJ = cI._4
429+                                let bI = cD
430+                                let cK = (bt - bF)
431+                                let cL = if ((cu > 0))
432+                                    then ((cF - bI) - cK)
433+                                    else ((cK + cF) - bI)
434+                                $Tuple10((cu + bE), ba, M(cL), cJ, aI, aH, bK, bL, bM, (ag() - cD))
435+                                }
436+                        }
437+                    else throw("Close position first")
438+                }
439+        let cM = cC._1
440+        let cN = cC._2
441+        let cO = cC._3
442+        let cP = cC._4
443+        let aI = cC._5
444+        let aH = cC._6
445+        let bK = cC._7
446+        let bL = cC._8
447+        let bM = cC._9
448+        let bN = cC._10
449+        (bY(toString(co.caller), cM, cN, cO, cP) ++ cd(aH, aI, bK, bL, bM, bN))
450+        }
451+
452+
453+
454+@Callable(co)
455+func increasePosition (cq,cr,cs) = {
456+    let cQ = co.payments[0].amount
457+    if (if (if (if (if (if (if ((cq != C))
458+        then (cq != D)
459+        else false)
460+        then true
461+        else (0 >= cQ))
462+        then true
463+        else if (((1 * G) > cr))
464+            then true
465+            else (cr > (3 * G)))
466+        then true
467+        else !(ay()))
468+        then true
469+        else (co.payments[0].assetId != x))
470+        then true
471+        else !(Q(I(G, cr), Z(), true)))
472+        then throw("Invalid increasePosition parameters")
473+        else {
474+            let cR = L(cQ, Y())
475+            let ck = (cQ - cR)
476+            let cS = an(toString(co.caller))
477+            let cu = cS._1
478+            let cv = cS._2
479+            let cw = cS._3
480+            let cx = cS._4
481+            let cy = (cu == 0)
482+            let cz = if ((cu > 0))
483+                then (cq == C)
484+                else (cq == D)
485+            let cA = if (!(cy))
486+                then cz
487+                else false
488+            let cB = (cq == C)
489+            let cT = if (if (cy)
490+                then true
491+                else cA)
492+                then {
493+                    let cD = L(ck, cr)
494+                    let cU = aD(cB, cD)
495+                    let aK = cU._1
496+                    let aH = cU._2
497+                    let aI = cU._3
498+                    let bK = cU._4
499+                    let bL = cU._5
500+                    let bM = cU._6
501+                    if (if ((cs != 0))
502+                        then (cs > M(aK))
503+                        else false)
504+                        then throw(((("Limit error: " + toString(M(aK))) + " < ") + toString(cs)))
505+                        else {
506+                            let cM = (cu + aK)
507+                            let cV = I(cD, cr)
508+                            let cW = aR(cu, cv, cx, cV)
509+                            let ba = cW._1
510+                            let bq = cW._2
511+                            let br = cW._3
512+                            let cJ = cW._4
513+                            $Tuple10(cM, ba, (cw + cD), cJ, aI, aH, bK, bL, bM, (ag() + cD))
514+                            }
515+                    }
516+                else {
517+                    let cD = L(ck, cr)
518+                    let cX = bk(toString(co.caller))
519+                    let cF = cX._1
520+                    let bt = cX._2
521+                    if ((cF > cD))
522+                        then throw("Use decreasePosition to decrease position size")
523+                        else throw("Close position first")
524+                    }
525+            let cM = cT._1
526+            let cN = cT._2
527+            let cO = cT._3
528+            let cP = cT._4
529+            let aI = cT._5
530+            let aH = cT._6
531+            let bK = cT._7
532+            let bL = cT._8
533+            let bM = cT._9
534+            let bN = cT._10
535+            let cY = invoke(y, "lockNeutrino", nil, [AttachedPayment(x, ck)])
536+            if ((cY == cY))
537+                then (((bY(toString(co.caller), cM, cN, cO, cP) ++ cd(aH, aI, bK, bL, bM, bN)) ++ cp(cR)) ++ cn((X() + ck)))
538+                else throw("Strict value is not equal to itself.")
539+            }
540+    }
541+
542+
543+
544+@Callable(co)
545+func addMargin () = {
546+    let cQ = co.payments[0].amount
547+    if (if ((co.payments[0].assetId != x))
548+        then true
549+        else !(as(toString(co.caller))))
550+        then throw("Invalid addMargin parameters")
551+        else {
552+            let cR = L(cQ, Y())
553+            let ck = (cQ - cR)
554+            let cZ = an(toString(co.caller))
555+            let cu = cZ._1
556+            let cv = cZ._2
557+            let cw = cZ._3
558+            let cx = cZ._4
559+            let cY = invoke(y, "lockNeutrino", nil, [AttachedPayment(x, ck)])
560+            if ((cY == cY))
561+                then ((bY(toString(co.caller), cu, (cv + co.payments[0].amount), cw, cx) ++ cp(cR)) ++ cn((X() + ck)))
562+                else throw("Strict value is not equal to itself.")
563+            }
564+    }
565+
566+
567+
568+@Callable(co)
569+func removeMargin (ck) = if (if ((0 >= ck))
570+    then true
571+    else !(as(toString(co.caller))))
572+    then throw("Invalid removeMargin parameters")
573+    else {
574+        let da = an(toString(co.caller))
575+        let cu = da._1
576+        let cv = da._2
577+        let cw = da._3
578+        let cx = da._4
579+        let db = -(ck)
580+        let dc = aR(cu, cv, cx, db)
581+        let ba = dc._1
582+        let bb = dc._2
583+        let bq = dc._3
584+        let dd = dc._4
585+        if ((bb != 0))
586+            then throw("Invalid added margin amount")
587+            else {
588+                let de = invoke(y, "unlockNeutrino", [ck, toBase58String(x)], nil)
589+                if ((de == de))
590+                    then ((bY(toString(co.caller), cu, ba, cw, dd) ++ cj(co.caller, ck)) ++ cn((X() - ck)))
591+                    else throw("Strict value is not equal to itself.")
592+                }
593+        }
594+
595+
596+
597+@Callable(co)
598+func closePosition () = if (!(as(toString(co.caller))))
599+    then throw("Invalid closePosition parameters")
600+    else {
601+        let df = bA(toString(co.caller))
602+        let bq = df._1
603+        let bb = df._2
604+        let bF = df._3
605+        let bG = df._4
606+        let bJ = df._5
607+        let aI = df._6
608+        let bK = df._7
609+        let bL = df._8
610+        let bM = df._9
611+        let bN = df._10
612+        if ((bb > 0))
613+            then throw("Unable to close position with bad debt")
614+            else {
615+                let dg = M(bG)
616+                let dh = (X() - dg)
617+                let di = if ((0 > dh))
618+                    then $Tuple2(0, M(dh))
619+                    else $Tuple2(dh, 0)
620+                let dj = di._1
621+                let dk = di._2
622+                let dl = if ((dk > 0))
623+                    then {
624+                        let dm = invoke(B, "withdraw", [dk], nil)
625+                        if ((dm == dm))
626+                            then nil
627+                            else throw("Strict value is not equal to itself.")
628+                        }
629+                    else nil
630+                if ((dl == dl))
631+                    then {
632+                        let de = invoke(y, "unlockNeutrino", [(dg - dk), toBase58String(x)], nil)
633+                        if ((de == de))
634+                            then (((ci(toString(co.caller)) ++ cd(bJ, aI, bK, bL, bM, bN)) ++ cj(co.caller, dg)) ++ cn(dj))
635+                            else throw("Strict value is not equal to itself.")
636+                        }
637+                    else throw("Strict value is not equal to itself.")
638+                }
639+        }
640+
641+
642+
643+@Callable(co)
644+func liquidate (at) = if (if (!(Q(bw(at), al(), false)))
645+    then true
646+    else !(ay()))
647+    then throw("Unable to liquidate")
648+    else {
649+        let dn = bA(at)
650+        let bq = dn._1
651+        let bb = dn._2
652+        let br = dn._3
653+        let bG = dn._4
654+        let bJ = dn._5
655+        let aI = dn._6
656+        let bK = dn._7
657+        let bL = dn._8
658+        let bM = dn._9
659+        let bN = dn._10
660+        let bI = dn._11
661+        let do = (L(bI, am()) / 2)
662+        let dp = if ((do > bG))
663+            then $Tuple3((do - bG), bG, ((bb + do) - bG))
664+            else $Tuple3(0, (bG - do), bb)
665+        let dq = dp._1
666+        let ba = dp._2
667+        let dr = dp._3
668+        ((ci(at) ++ cd(bJ, aI, bK, bL, bM, bN)) ++ cj(co.caller, do))
669+        }
670+
671+
672+
673+@Callable(co)
674+func payFunding () = {
675+    let ds = ah()
676+    if (if ((ds > lastBlock.timestamp))
677+        then true
678+        else !(ay()))
679+        then throw(((("Invalid funding block timestamp: " + toString(lastBlock.timestamp)) + " < ") + toString(ds)))
680+        else {
681+            let dt = bu()
682+            let du = bv()
683+            let dv = (du - dt)
684+            let dw = I(L(dv, aj()), H)
685+            let dx = ad()
686+            let dy = L(dw, dx)
687+            let dz = M(dy)
688+            if ((0 > dy))
689+                then {
690+                    let dm = invoke(B, "withdraw", [dz], nil)
691+                    if ((dm == dm))
692+                        then {
693+                            let cY = invoke(y, "lockNeutrino", nil, [AttachedPayment(x, dz)])
694+                            if ((cY == cY))
695+                                then cn((X() + dz))
696+                                else throw("Strict value is not equal to itself.")
697+                            }
698+                        else throw("Strict value is not equal to itself.")
699+                    }
700+                else ({
701+                    let de = invoke(y, "unlockNeutrino", [dz, toBase58String(x)], nil)
702+                    if ((de == de))
703+                        then {
704+                            let dA = invoke(B, "deposit", nil, [AttachedPayment(x, dz)])
705+                            if ((dA == dA))
706+                                then cn((X() - dz))
707+                                else throw("Strict value is not equal to itself.")
708+                            }
709+                        else throw("Strict value is not equal to itself.")
710+                    } ++ bU(0, (ds + ak()), (af() + dw), I(dw, dt)))
711+            }
712+    }
713+
714+
715+@Verifier(dB)
716+func dC () = sigVerify(dB.bodyBytes, dB.proofs[0], w)
717+
github/deemru/w8io/169f3d6 
41.10 ms ◑