tx · GRAHuWZ7iUBFNXKh9M8oYyjd8GGzAjtxVK6LP96dGWfC

3N5tyhTmPiVsCaHPRS7JMrfMByZjWSzibUa:  -0.03200000 Waves

2022.05.23 19:34 [2064578] smart account 3N5tyhTmPiVsCaHPRS7JMrfMByZjWSzibUa > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "GRAHuWZ7iUBFNXKh9M8oYyjd8GGzAjtxVK6LP96dGWfC",
    "fee": 3200000,
    "feeAssetId": null,
    "timestamp": 1653323683193,
    "version": 2,
    "chainId": 84,
    "sender": "3N5tyhTmPiVsCaHPRS7JMrfMByZjWSzibUa",
    "senderPublicKey": "HJQRYoqp2ohC2ypdUWP2dvx9Z2987oD9JKy63cTr56pj",
    "proofs": [
        "3BzuegXqaaiK6fjEG3ac2u9t9GcbYfijiV5ZDR9XihZAjpSoMB7iAXztiwgTEWVKgjcJseQRL7WFTFcPLDUevT4x"
    ],
    "script": "base64:AAIFAAAAAAAAACwIAhIJCgcBAQEBAQEBEgYKBAEBAQESBQoDAQEBEgASAwoBARIAEgMKAQgSAAAAAE0AAAAAC29yYV9rX3ByaWNlAgAAAAVwcmljZQAAAAAJa19iYWxhbmNlAgAAAAlrX2JhbGFuY2UAAAAADmtfcG9zaXRpb25TaXplAgAAAA5rX3Bvc2l0aW9uU2l6ZQAAAAAQa19wb3NpdGlvbk1hcmdpbgIAAAAQa19wb3NpdGlvbk1hcmdpbgAAAAAFa19wb24CAAAABWtfcG9uAAAAABNrX3Bvc2l0aW9uTHN0VXBkQ1BGAgAAABJrX3Bvc2l0aW9uRnJhY3Rpb24AAAAADWtfaW5pdGlhbGl6ZWQCAAAADWtfaW5pdGlhbGl6ZWQAAAAABWtfZmVlAgAAAAVrX2ZlZQAAAAAPa19mdW5kaW5nUGVyaW9kAgAAAA9rX2Z1bmRpbmdQZXJpb2QAAAAAEWtfaW5pdE1hcmdpblJhdGlvAgAAABFrX2luaXRNYXJnaW5SYXRpbwAAAAAFa19tbXICAAAABWtfbW1yAAAAABVrX2xpcXVpZGF0aW9uRmVlUmF0aW8CAAAAFWtfbGlxdWlkYXRpb25GZWVSYXRpbwAAAAALa19sYXRlc3RDUEYCAAAAF2tfbGF0ZXN0UHJlbWl1bUZyYWN0aW9uAAAAABJrX25leHRGdW5kaW5nQmxvY2sCAAAAHmtfbmV4dEZ1bmRpbmdCbG9ja01pblRpbWVzdGFtcAAAAAANa19mdW5kaW5nUmF0ZQIAAAANa19mdW5kaW5nUmF0ZQAAAAAIa19xdEFzdFICAAAACGtfcXRBc3RSAAAAAAhrX2JzQXN0UgIAAAAIa19ic0FzdFIAAAAAIWtfYmFzZUFzc2V0RGVsdGFUaGlzRnVuZGluZ1BlcmlvZAIAAAAQa19iYXNlQXNzZXREZWx0YQAAAAATa190b3RhbFBvc2l0aW9uU2l6ZQIAAAATa190b3RhbFBvc2l0aW9uU2l6ZQAAAAAUa19jdW11bGF0aXZlTm90aW9uYWwCAAAAFGtfY3VtdWxhdGl2ZU5vdGlvbmFsAAAAABdrX29wZW5JbnRlcmVzZXROb3Rpb25hbAIAAAAXa19vcGVuSW50ZXJlc2V0Tm90aW9uYWwAAAAADUFETUlOX0FERFJFU1MJAQAAAAdBZGRyZXNzAAAAAQEAAAAaAVTXI8iG9R+K/uEeNaLD+weRcd9eCZO/tJ8AAAAAEEFETUlOX1BVQkxJQ19LRVkBAAAAIIcmSBJTUFXoPpNHZpHF6Io4+qdHJU/YbDcbopIgeR0fAAAAAARVU0ROAQAAACD3dur394PKZdtuE+4CO89YKZWpwdGN8kvabNgdYoDI3gAAAAAMVVNETl9TVEFLSU5HCQEAAAAHQWRkcmVzcwAAAAEBAAAAGgFU1RSI+hLarpHDNucd0rt6s3mn30OjjZimAAAAAAZPUkFDTEUJAQAAAAdBZGRyZXNzAAAAAQEAAAAaAVSejY4Al5SfQ9KNGpQt9mxR9NCIt5FVwUMAAAAADEZFRVNfQUNDT1VOVAkBAAAAB0FkZHJlc3MAAAABAQAAABoBVCjg9skERvjNwYufmcNFym7jAT7H5g2REwAAAAARSU5TVVJBTkNFX0FERFJFU1MJAQAAAAdBZGRyZXNzAAAAAQEAAAAaAVS4x4gL3KSCO/UcuS6PxsYUq83miVh3cegAAAAACERJUl9MT05HAAAAAAAAAAABAAAAAAlESVJfU0hPUlQAAAAAAAAAAAIAAAAAFkZVTkRJTkdfQkxPQ0tfSU5URVJWQUwAAAAAAAAAADwAAAAAB1NFQ09ORFMAAAAAAAAAA+gAAAAADERFQ0lNQUxfVU5JVAkAAGgAAAACAAAAAAAAAAABCQAAaAAAAAIJAABoAAAAAgkAAGgAAAACCQAAaAAAAAIJAABoAAAAAgAAAAAAAAAACgAAAAAAAAAACgAAAAAAAAAACgAAAAAAAAAACgAAAAAAAAAACgAAAAAAAAAACgAAAAAHT05FX0RBWQkAAGgAAAACAAAAAAAAAVGABQAAAAxERUNJTUFMX1VOSVQBAAAABGRpdmQAAAACAAAAAl94AAAAAl95CQEAAAAIZnJhY3Rpb24AAAAEBQAAAAJfeAUAAAAMREVDSU1BTF9VTklUBQAAAAJfeQUAAAAISEFMRkVWRU4BAAAABG11bGQAAAACAAAAAl94AAAAAl95CQEAAAAIZnJhY3Rpb24AAAAEBQAAAAJfeAUAAAACX3kFAAAADERFQ0lNQUxfVU5JVAUAAAAISEFMRkVWRU4BAAAAA2FicwAAAAEAAAACX3gDCQAAZgAAAAIFAAAAAl94AAAAAAAAAAAABQAAAAJfeAkBAAAAAS0AAAABBQAAAAJfeAEAAAAOdG9Db21wb3NpdGVLZXkAAAACAAAABF9rZXkAAAAIX2FkZHJlc3MJAAEsAAAAAgkAASwAAAACBQAAAARfa2V5AgAAAAFfBQAAAAhfYWRkcmVzcwEAAAAWcmVxdWlyZU1vcmVNYXJnaW5SYXRpbwAAAAMAAAAMX21hcmdpblJhdGlvAAAAEF9iYXNlTWFyZ2luUmF0aW8AAAAUX2xhcmdlclRoYW5PckVxdWFsVG8EAAAAFHJlbWFpbmluZ01hcmdpblJhdGlvCQAAZQAAAAIFAAAADF9tYXJnaW5SYXRpbwUAAAAQX2Jhc2VNYXJnaW5SYXRpbwMDBQAAABRfbGFyZ2VyVGhhbk9yRXF1YWxUbwkAAGYAAAACAAAAAAAAAAAABQAAABRyZW1haW5pbmdNYXJnaW5SYXRpbwcJAAACAAAAAQkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAICAAAAHEludmFsaWQgbWFyZ2luIF9tYXJnaW5SYXRpbz0JAAGkAAAAAQUAAAAMX21hcmdpblJhdGlvAgAAABIgX2Jhc2VNYXJnaW5SYXRpbz0JAAGkAAAAAQUAAAAQX2Jhc2VNYXJnaW5SYXRpbwIAAAAWIHJlbWFpbmluZ01hcmdpblJhdGlvPQkAAaQAAAABBQAAABRyZW1haW5pbmdNYXJnaW5SYXRpbwMDCQEAAAABIQAAAAEFAAAAFF9sYXJnZXJUaGFuT3JFcXVhbFRvCQAAZwAAAAIFAAAAFHJlbWFpbmluZ01hcmdpblJhdGlvAAAAAAAAAAAABwkAAAIAAAABCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgIAAAAbSW52YWxpZCBtYXJnaW4gbWFyZ2luUmF0aW89CQABpAAAAAEFAAAADF9tYXJnaW5SYXRpbwIAAAARIGJhc2VNYXJnaW5SYXRpbz0JAAGkAAAAAQUAAAAQX2Jhc2VNYXJnaW5SYXRpbwIAAAAWIHJlbWFpbmluZ01hcmdpblJhdGlvPQkAAaQAAAABBQAAABRyZW1haW5pbmdNYXJnaW5SYXRpbwYBAAAAA2ludAAAAAEAAAABawkBAAAAE3ZhbHVlT3JFcnJvck1lc3NhZ2UAAAACCQAEGgAAAAIFAAAABHRoaXMFAAAAAWsJAAEsAAAAAgIAAAANbm8gdmFsdWUgZm9yIAUAAAABawEAAAAIY2JhbGFuY2UAAAAACQEAAAADaW50AAAAAQUAAAAJa19iYWxhbmNlAQAAAANmZWUAAAAACQEAAAADaW50AAAAAQUAAAAFa19mZWUBAAAAD2luaXRNYXJnaW5SYXRpbwAAAAAJAQAAAANpbnQAAAABBQAAABFrX2luaXRNYXJnaW5SYXRpbwEAAAAGcXRBc3RSAAAAAAkBAAAAA2ludAAAAAEFAAAACGtfcXRBc3RSAQAAAAZic0FzdFIAAAAACQEAAAADaW50AAAAAQUAAAAIa19ic0FzdFIBAAAAH2Jhc2VBc3NldERlbHRhVGhpc0Z1bmRpbmdQZXJpb2QAAAAACQEAAAADaW50AAAAAQUAAAAha19iYXNlQXNzZXREZWx0YVRoaXNGdW5kaW5nUGVyaW9kAQAAABF0b3RhbFBvc2l0aW9uU2l6ZQAAAAAJAQAAAANpbnQAAAABBQAAABNrX3RvdGFsUG9zaXRpb25TaXplAQAAABJjdW11bGF0aXZlTm90aW9uYWwAAAAACQEAAAADaW50AAAAAQUAAAAUa19jdW11bGF0aXZlTm90aW9uYWwBAAAACWxhdGVzdENQRgAAAAAJAQAAAANpbnQAAAABBQAAAAtrX2xhdGVzdENQRgEAAAAVb3BlbkludGVyZXNldE5vdGlvbmFsAAAAAAkBAAAAA2ludAAAAAEFAAAAF2tfb3BlbkludGVyZXNldE5vdGlvbmFsAQAAABluZXh0RnVuZGluZ0Jsb2NrVGltZXN0YW1wAAAAAAkBAAAAA2ludAAAAAEFAAAAEmtfbmV4dEZ1bmRpbmdCbG9jawEAAAAQZnVuZGluZ1BlcmlvZFJhdwAAAAAJAQAAAANpbnQAAAABBQAAAA9rX2Z1bmRpbmdQZXJpb2QBAAAAFGZ1bmRpbmdQZXJpb2REZWNpbWFsAAAAAAkAAGgAAAACCQEAAAAQZnVuZGluZ1BlcmlvZFJhdwAAAAAFAAAADERFQ0lNQUxfVU5JVAEAAAAUZnVuZGluZ1BlcmlvZFNlY29uZHMAAAAACQAAaAAAAAIJAQAAABBmdW5kaW5nUGVyaW9kUmF3AAAAAAUAAAAHU0VDT05EUwEAAAADbW1yAAAAAAkBAAAAA2ludAAAAAEFAAAABWtfbW1yAQAAABNsaXF1aWRhdGlvbkZlZVJhdGlvAAAAAAkBAAAAA2ludAAAAAEFAAAAFWtfbGlxdWlkYXRpb25GZWVSYXRpbwEAAAALZ2V0UG9zaXRpb24AAAABAAAAB2ludmVzb3IEAAAAD3Bvc2l0aW9uU2l6ZU9wdAkABBoAAAACBQAAAAR0aGlzCQEAAAAOdG9Db21wb3NpdGVLZXkAAAACBQAAAA5rX3Bvc2l0aW9uU2l6ZQUAAAAHaW52ZXNvcgQAAAAHJG1hdGNoMAUAAAAPcG9zaXRpb25TaXplT3B0AwkAAAEAAAACBQAAAAckbWF0Y2gwAgAAAANJbnQEAAAADHBvc2l0aW9uU2l6ZQUAAAAHJG1hdGNoMAkABRYAAAAEBQAAAAxwb3NpdGlvblNpemUJAQAAABFAZXh0ck5hdGl2ZSgxMDUwKQAAAAIFAAAABHRoaXMJAQAAAA50b0NvbXBvc2l0ZUtleQAAAAIFAAAAEGtfcG9zaXRpb25NYXJnaW4FAAAAB2ludmVzb3IJAQAAABFAZXh0ck5hdGl2ZSgxMDUwKQAAAAIFAAAABHRoaXMJAQAAAA50b0NvbXBvc2l0ZUtleQAAAAIFAAAABWtfcG9uBQAAAAdpbnZlc29yCQEAAAARQGV4dHJOYXRpdmUoMTA1MCkAAAACBQAAAAR0aGlzCQEAAAAOdG9Db21wb3NpdGVLZXkAAAACBQAAABNrX3Bvc2l0aW9uTHN0VXBkQ1BGBQAAAAdpbnZlc29yCQAFFgAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAE3JlcXVpcmVPcGVuUG9zaXRpb24AAAABAAAAB190cmFkZXIEAAAACyR0MDQyOTU0NDA2CQEAAAALZ2V0UG9zaXRpb24AAAABBQAAAAdfdHJhZGVyBAAAAAxwb3NpdGlvblNpemUIBQAAAAskdDA0Mjk1NDQwNgAAAAJfMQQAAAAOcG9zaXRpb25NYXJnaW4IBQAAAAskdDA0Mjk1NDQwNgAAAAJfMgQAAAADcG9uCAUAAAALJHQwNDI5NTQ0MDYAAAACXzMEAAAAEXBvc2l0aW9uTHN0VXBkQ1BGCAUAAAALJHQwNDI5NTQ0MDYAAAACXzQDCQAAAAAAAAIFAAAADHBvc2l0aW9uU2l6ZQAAAAAAAAAAAAkAAAIAAAABAgAAABBObyBvcGVuIHBvc2l0aW9uBgEAAAALaW5pdGlhbGl6ZWQAAAAACQEAAAALdmFsdWVPckVsc2UAAAACCQAEGwAAAAIFAAAABHRoaXMFAAAADWtfaW5pdGlhbGl6ZWQHAQAAAA11cGRhdGVSZXNlcnZlAAAAAwAAAAZfaXNBZGQAAAARX3F1b3RlQXNzZXRBbW91bnQAAAAQX2Jhc2VBc3NldEFtb3VudAMFAAAABl9pc0FkZAkABRcAAAAFCQAAZAAAAAIJAQAAAAZxdEFzdFIAAAAABQAAABFfcXVvdGVBc3NldEFtb3VudAkAAGUAAAACCQEAAAAGYnNBc3RSAAAAAAUAAAAQX2Jhc2VBc3NldEFtb3VudAkAAGUAAAACCQEAAAAfYmFzZUFzc2V0RGVsdGFUaGlzRnVuZGluZ1BlcmlvZAAAAAAFAAAAEF9iYXNlQXNzZXRBbW91bnQJAABkAAAAAgkBAAAAEXRvdGFsUG9zaXRpb25TaXplAAAAAAUAAAAQX2Jhc2VBc3NldEFtb3VudAkAAGQAAAACCQEAAAASY3VtdWxhdGl2ZU5vdGlvbmFsAAAAAAUAAAARX3F1b3RlQXNzZXRBbW91bnQJAAUXAAAABQkAAGUAAAACCQEAAAAGcXRBc3RSAAAAAAUAAAARX3F1b3RlQXNzZXRBbW91bnQJAABkAAAAAgkBAAAABmJzQXN0UgAAAAAFAAAAEF9iYXNlQXNzZXRBbW91bnQJAABkAAAAAgkBAAAAH2Jhc2VBc3NldERlbHRhVGhpc0Z1bmRpbmdQZXJpb2QAAAAABQAAABBfYmFzZUFzc2V0QW1vdW50CQAAZQAAAAIJAQAAABF0b3RhbFBvc2l0aW9uU2l6ZQAAAAAFAAAAEF9iYXNlQXNzZXRBbW91bnQJAABlAAAAAgkBAAAAEmN1bXVsYXRpdmVOb3Rpb25hbAAAAAAFAAAAEV9xdW90ZUFzc2V0QW1vdW50AQAAAAlzd2FwSW5wdXQAAAACAAAABl9pc0FkZAAAABBfcXVvdGVBc3NldEFtb3VuBAAAAAdfcXRBc3RSCQEAAAAGcXRBc3RSAAAAAAQAAAAHX2JzQXN0UgkBAAAABmJzQXN0UgAAAAAEAAAAAWsJAQAAAARtdWxkAAAAAgUAAAAHX3F0QXN0UgUAAAAHX2JzQXN0UgQAAAALcXRBc3RSQWZ0ZXIDBQAAAAZfaXNBZGQJAABkAAAAAgUAAAAHX3F0QXN0UgUAAAAQX3F1b3RlQXNzZXRBbW91bgkAAGUAAAACBQAAAAdfcXRBc3RSBQAAABBfcXVvdGVBc3NldEFtb3VuBAAAAAtic0FzdFJBZnRlcgkBAAAABGRpdmQAAAACBQAAAAFrBQAAAAtxdEFzdFJBZnRlcgQAAAAYYW1vdW50QmFzZUFzc2V0Qm91Z2h0QWJzCQEAAAADYWJzAAAAAQkAAGUAAAACBQAAAAtic0FzdFJBZnRlcgUAAAAHX2JzQXN0UgQAAAAVYW1vdW50QmFzZUFzc2V0Qm91Z2h0AwUAAAAGX2lzQWRkBQAAABhhbW91bnRCYXNlQXNzZXRCb3VnaHRBYnMJAQAAAAEtAAAAAQUAAAAYYW1vdW50QmFzZUFzc2V0Qm91Z2h0QWJzBAAAAAskdDA1Njk0NTkwOAkBAAAADXVwZGF0ZVJlc2VydmUAAAADBQAAAAZfaXNBZGQFAAAAEF9xdW90ZUFzc2V0QW1vdW4FAAAAGGFtb3VudEJhc2VBc3NldEJvdWdodEFicwQAAAAMcXRBc3RSQWZ0ZXIxCAUAAAALJHQwNTY5NDU5MDgAAAACXzEEAAAADGJzQXN0UkFmdGVyMQgFAAAACyR0MDU2OTQ1OTA4AAAAAl8yBAAAACViYXNlQXNzZXREZWx0YVRoaXNGdW5kaW5nUGVyaW9kQWZ0ZXIxCAUAAAALJHQwNTY5NDU5MDgAAAACXzMEAAAAF3RvdGFsUG9zaXRpb25TaXplQWZ0ZXIxCAUAAAALJHQwNTY5NDU5MDgAAAACXzQEAAAAGGN1bXVsYXRpdmVOb3Rpb25hbEFmdGVyMQgFAAAACyR0MDU2OTQ1OTA4AAAAAl81CQAFGAAAAAYFAAAAFWFtb3VudEJhc2VBc3NldEJvdWdodAUAAAAMcXRBc3RSQWZ0ZXIxBQAAAAxic0FzdFJBZnRlcjEFAAAAJWJhc2VBc3NldERlbHRhVGhpc0Z1bmRpbmdQZXJpb2RBZnRlcjEFAAAAF3RvdGFsUG9zaXRpb25TaXplQWZ0ZXIxBQAAABhjdW11bGF0aXZlTm90aW9uYWxBZnRlcjEBAAAAImNhbGNSZW1haW5NYXJnaW5XaXRoRnVuZGluZ1BheW1lbnQAAAAEAAAAEF9vbGRQb3NpdGlvblNpemUAAAASX29sZFBvc2l0aW9uTWFyZ2luAAAAFV9vbGRQb3NpdGlvbkxzdFVwZENQRgAAAAxfbWFyZ2luRGVsdGEEAAAACl9sYXRlc3RDUEYJAQAAAAlsYXRlc3RDUEYAAAAABAAAAA5mdW5kaW5nUGF5bWVudAMJAQAAAAIhPQAAAAIFAAAAEF9vbGRQb3NpdGlvblNpemUAAAAAAAAAAAAJAQAAAARtdWxkAAAAAgkAAGUAAAACBQAAAApfbGF0ZXN0Q1BGBQAAABVfb2xkUG9zaXRpb25Mc3RVcGRDUEYFAAAAEF9vbGRQb3NpdGlvblNpemUAAAAAAAAAAAAEAAAADHNpZ25lZE1hcmdpbgkAAGQAAAACCQAAZQAAAAIFAAAADF9tYXJnaW5EZWx0YQUAAAAOZnVuZGluZ1BheW1lbnQFAAAAEl9vbGRQb3NpdGlvbk1hcmdpbgQAAAALJHQwNjQ5ODY2MjUDCQAAZgAAAAIAAAAAAAAAAAAFAAAADHNpZ25lZE1hcmdpbgkABRQAAAACAAAAAAAAAAAACQEAAAADYWJzAAAAAQUAAAAMc2lnbmVkTWFyZ2luCQAFFAAAAAIJAQAAAANhYnMAAAABBQAAAAxzaWduZWRNYXJnaW4AAAAAAAAAAAAEAAAADHJlbWFpbk1hcmdpbggFAAAACyR0MDY0OTg2NjI1AAAAAl8xBAAAAAdiYWREZWJ0CAUAAAALJHQwNjQ5ODY2MjUAAAACXzIJAAUWAAAABAUAAAAMcmVtYWluTWFyZ2luBQAAAAdiYWREZWJ0BQAAAA5mdW5kaW5nUGF5bWVudAUAAAAKX2xhdGVzdENQRgEAAAAaZ2V0T3V0cHV0UHJpY2VXaXRoUmVzZXJ2ZXMAAAAEAAAABF9hZGQAAAAQX2Jhc2VBc3NldEFtb3VudAAAABVfcXVvdGVBc3NldFBvb2xBbW91bnQAAAAUX2Jhc2VBc3NldFBvb2xBbW91bnQDCQAAAAAAAAIFAAAAEF9iYXNlQXNzZXRBbW91bnQAAAAAAAAAAAAJAAACAAAAAQIAAAAZSW52YWxpZCBiYXNlIGFzc2V0IGFtb3VudAQAAAABawkBAAAABG11bGQAAAACBQAAABVfcXVvdGVBc3NldFBvb2xBbW91bnQFAAAAFF9iYXNlQXNzZXRQb29sQW1vdW50BAAAABhiYXNlQXNzZXRQb29sQW1vdW50QWZ0ZXIDBQAAAARfYWRkCQAAZAAAAAIFAAAAFF9iYXNlQXNzZXRQb29sQW1vdW50BQAAABBfYmFzZUFzc2V0QW1vdW50CQAAZQAAAAIFAAAAFF9iYXNlQXNzZXRQb29sQW1vdW50BQAAABBfYmFzZUFzc2V0QW1vdW50BAAAAA9xdW90ZUFzc2V0QWZ0ZXIJAQAAAARkaXZkAAAAAgUAAAABawUAAAAYYmFzZUFzc2V0UG9vbEFtb3VudEFmdGVyBAAAAA5xdW90ZUFzc2V0U29sZAkBAAAAA2FicwAAAAEJAABlAAAAAgUAAAAPcXVvdGVBc3NldEFmdGVyBQAAABVfcXVvdGVBc3NldFBvb2xBbW91bnQEAAAACyR0MDcyNzQ3NDg5CQEAAAANdXBkYXRlUmVzZXJ2ZQAAAAMJAQAAAAEhAAAAAQUAAAAEX2FkZAUAAAAOcXVvdGVBc3NldFNvbGQFAAAAEF9iYXNlQXNzZXRBbW91bnQEAAAADHF0QXN0UkFmdGVyMQgFAAAACyR0MDcyNzQ3NDg5AAAAAl8xBAAAAAxic0FzdFJBZnRlcjEIBQAAAAskdDA3Mjc0NzQ4OQAAAAJfMgQAAAAlYmFzZUFzc2V0RGVsdGFUaGlzRnVuZGluZ1BlcmlvZEFmdGVyMQgFAAAACyR0MDcyNzQ3NDg5AAAAAl8zBAAAABd0b3RhbFBvc2l0aW9uU2l6ZUFmdGVyMQgFAAAACyR0MDcyNzQ3NDg5AAAAAl80BAAAABhjdW11bGF0aXZlTm90aW9uYWxBZnRlcjEIBQAAAAskdDA3Mjc0NzQ4OQAAAAJfNQkABRgAAAAGBQAAAA5xdW90ZUFzc2V0U29sZAUAAAAMcXRBc3RSQWZ0ZXIxBQAAAAxic0FzdFJBZnRlcjEFAAAAJWJhc2VBc3NldERlbHRhVGhpc0Z1bmRpbmdQZXJpb2RBZnRlcjEFAAAAF3RvdGFsUG9zaXRpb25TaXplQWZ0ZXIxBQAAABhjdW11bGF0aXZlTm90aW9uYWxBZnRlcjEBAAAAI2dldFBvc2l0aW9uTm90aW9uYWxBbmRVbnJlYWxpemVkUG5sAAAAAQAAAAdfdHJhZGVyBAAAAAskdDA3NzQzNzg1NAkBAAAAC2dldFBvc2l0aW9uAAAAAQUAAAAHX3RyYWRlcgQAAAAMcG9zaXRpb25TaXplCAUAAAALJHQwNzc0Mzc4NTQAAAACXzEEAAAADnBvc2l0aW9uTWFyZ2luCAUAAAALJHQwNzc0Mzc4NTQAAAACXzIEAAAAA3BvbggFAAAACyR0MDc3NDM3ODU0AAAAAl8zBAAAABFwb3NpdGlvbkxzdFVwZENQRggFAAAACyR0MDc3NDM3ODU0AAAAAl80BAAAAA9wb3NpdGlvblNpemVBYnMJAQAAAANhYnMAAAABBQAAAAxwb3NpdGlvblNpemUDCQAAAAAAAAIFAAAAD3Bvc2l0aW9uU2l6ZUFicwAAAAAAAAAAAAkAAAIAAAABAgAAABVJbnZhbGlkIHBvc2l0aW9uIHNpemUEAAAAB2lzU2hvcnQJAABmAAAAAgAAAAAAAAAAAAUAAAAMcG9zaXRpb25TaXplBAAAAAskdDA4MDMxODE4MQkBAAAAGmdldE91dHB1dFByaWNlV2l0aFJlc2VydmVzAAAABAkBAAAAASEAAAABBQAAAAdpc1Nob3J0BQAAAA9wb3NpdGlvblNpemVBYnMJAQAAAAZxdEFzdFIAAAAACQEAAAAGYnNBc3RSAAAAAAQAAAAQcG9zaXRpb25Ob3Rpb25hbAgFAAAACyR0MDgwMzE4MTgxAAAAAl8xBAAAAAJ4MQgFAAAACyR0MDgwMzE4MTgxAAAAAl8yBAAAAAJ4MggFAAAACyR0MDgwMzE4MTgxAAAAAl8zBAAAAAJ4MwgFAAAACyR0MDgwMzE4MTgxAAAAAl80BAAAAA11bnJlYWxpemVkUG5sAwUAAAAHaXNTaG9ydAkAAGUAAAACBQAAAANwb24FAAAAEHBvc2l0aW9uTm90aW9uYWwJAABlAAAAAgUAAAAQcG9zaXRpb25Ob3Rpb25hbAUAAAADcG9uCQAFFAAAAAIFAAAAEHBvc2l0aW9uTm90aW9uYWwFAAAADXVucmVhbGl6ZWRQbmwBAAAAEmdldE9yYWNsZVR3YXBQcmljZQAAAAAJAQAAABFAZXh0ck5hdGl2ZSgxMDUwKQAAAAIFAAAABk9SQUNMRQUAAAALb3JhX2tfcHJpY2UBAAAAEGdldFR3YXBTcG90UHJpY2UAAAAACQEAAAAEZGl2ZAAAAAIJAQAAAAZxdEFzdFIAAAAACQEAAAAGYnNBc3RSAAAAAAEAAAAOZ2V0TWFyZ2luUmF0aW8AAAABAAAAB190cmFkZXIEAAAACyR0MDg1NjE4NjcyCQEAAAALZ2V0UG9zaXRpb24AAAABBQAAAAdfdHJhZGVyBAAAAAxwb3NpdGlvblNpemUIBQAAAAskdDA4NTYxODY3MgAAAAJfMQQAAAAOcG9zaXRpb25NYXJnaW4IBQAAAAskdDA4NTYxODY3MgAAAAJfMgQAAAADcG9uCAUAAAALJHQwODU2MTg2NzIAAAACXzMEAAAAEXBvc2l0aW9uTHN0VXBkQ1BGCAUAAAALJHQwODU2MTg2NzIAAAACXzQEAAAACyR0MDg2Nzg4NzYyCQEAAAAjZ2V0UG9zaXRpb25Ob3Rpb25hbEFuZFVucmVhbGl6ZWRQbmwAAAABBQAAAAdfdHJhZGVyBAAAABBwb3NpdGlvbk5vdGlvbmFsCAUAAAALJHQwODY3ODg3NjIAAAACXzEEAAAADXVucmVhbGl6ZWRQbmwIBQAAAAskdDA4Njc4ODc2MgAAAAJfMgQAAAALJHQwODc2Nzg5MzMJAQAAACJjYWxjUmVtYWluTWFyZ2luV2l0aEZ1bmRpbmdQYXltZW50AAAABAUAAAAMcG9zaXRpb25TaXplBQAAAA5wb3NpdGlvbk1hcmdpbgUAAAARcG9zaXRpb25Mc3RVcGRDUEYFAAAADXVucmVhbGl6ZWRQbmwEAAAADHJlbWFpbk1hcmdpbggFAAAACyR0MDg3Njc4OTMzAAAAAl8xBAAAAAdiYWREZWJ0CAUAAAALJHQwODc2Nzg5MzMAAAACXzIJAQAAAARkaXZkAAAAAgkAAGUAAAACBQAAAAxyZW1haW5NYXJnaW4FAAAAB2JhZERlYnQFAAAAEHBvc2l0aW9uTm90aW9uYWwBAAAAFWludGVybmFsQ2xvc2VQb3NpdGlvbgAAAAEAAAAHX3RyYWRlcgQAAAALJHQwOTA0MDkxNTEJAQAAAAtnZXRQb3NpdGlvbgAAAAEFAAAAB190cmFkZXIEAAAADHBvc2l0aW9uU2l6ZQgFAAAACyR0MDkwNDA5MTUxAAAAAl8xBAAAAA5wb3NpdGlvbk1hcmdpbggFAAAACyR0MDkwNDA5MTUxAAAAAl8yBAAAAANwb24IBQAAAAskdDA5MDQwOTE1MQAAAAJfMwQAAAARcG9zaXRpb25Mc3RVcGRDUEYIBQAAAAskdDA5MDQwOTE1MQAAAAJfNAQAAAALJHQwOTE1NzkyMjcJAQAAACNnZXRQb3NpdGlvbk5vdGlvbmFsQW5kVW5yZWFsaXplZFBubAAAAAEFAAAAB190cmFkZXIEAAAAAngxCAUAAAALJHQwOTE1NzkyMjcAAAACXzEEAAAADXVucmVhbGl6ZWRQbmwIBQAAAAskdDA5MTU3OTIyNwAAAAJfMgQAAAALJHQwOTIzMjk0MDQJAQAAACJjYWxjUmVtYWluTWFyZ2luV2l0aEZ1bmRpbmdQYXltZW50AAAABAUAAAAMcG9zaXRpb25TaXplBQAAAA5wb3NpdGlvbk1hcmdpbgUAAAARcG9zaXRpb25Mc3RVcGRDUEYFAAAADXVucmVhbGl6ZWRQbmwEAAAADHJlbWFpbk1hcmdpbggFAAAACyR0MDkyMzI5NDA0AAAAAl8xBAAAAAdiYWREZWJ0CAUAAAALJHQwOTIzMjk0MDQAAAACXzIEAAAAAngyCAUAAAALJHQwOTIzMjk0MDQAAAACXzMEAAAAFWV4Y2hhbmdlZFBvc2l0aW9uU2l6ZQkBAAAAAS0AAAABBQAAAAxwb3NpdGlvblNpemUEAAAAC3JlYWxpemVkUG5sBQAAAA11bnJlYWxpemVkUG5sBAAAAA1tYXJnaW5Ub1ZhdWx0CQEAAAABLQAAAAEFAAAADHJlbWFpbk1hcmdpbgQAAAALJHQwOTUzMTk4NTQJAQAAABpnZXRPdXRwdXRQcmljZVdpdGhSZXNlcnZlcwAAAAQJAABmAAAAAgUAAAAMcG9zaXRpb25TaXplAAAAAAAAAAAACQEAAAADYWJzAAAAAQUAAAAMcG9zaXRpb25TaXplCQEAAAAGcXRBc3RSAAAAAAkBAAAABmJzQXN0UgAAAAAEAAAAGWV4Y2hhbmdlZFF1b3RlQXNzZXRBbW91bnQIBQAAAAskdDA5NTMxOTg1NAAAAAJfMQQAAAAWcXVvdGVBc3NldFJlc2VydmVBZnRlcggFAAAACyR0MDk1MzE5ODU0AAAAAl8yBAAAAAtic0FzdFJBZnRlcggFAAAACyR0MDk1MzE5ODU0AAAAAl8zBAAAACRiYXNlQXNzZXREZWx0YVRoaXNGdW5kaW5nUGVyaW9kQWZ0ZXIIBQAAAAskdDA5NTMxOTg1NAAAAAJfNAQAAAAWdG90YWxQb3NpdGlvblNpemVBZnRlcggFAAAACyR0MDk1MzE5ODU0AAAAAl81BAAAABdjdW11bGF0aXZlTm90aW9uYWxBZnRlcggFAAAACyR0MDk1MzE5ODU0AAAAAl82BAAAABpvcGVuSW50ZXJlc2V0Tm90aW9uYWxBZnRlcgkAAGUAAAACCQEAAAAVb3BlbkludGVyZXNldE5vdGlvbmFsAAAAAAUAAAADcG9uCQAFHQAAAAsFAAAAFWV4Y2hhbmdlZFBvc2l0aW9uU2l6ZQUAAAAHYmFkRGVidAUAAAALcmVhbGl6ZWRQbmwFAAAADW1hcmdpblRvVmF1bHQFAAAAFnF1b3RlQXNzZXRSZXNlcnZlQWZ0ZXIFAAAAC2JzQXN0UkFmdGVyBQAAACRiYXNlQXNzZXREZWx0YVRoaXNGdW5kaW5nUGVyaW9kQWZ0ZXIFAAAAFnRvdGFsUG9zaXRpb25TaXplQWZ0ZXIFAAAAF2N1bXVsYXRpdmVOb3Rpb25hbEFmdGVyBQAAABpvcGVuSW50ZXJlc2V0Tm90aW9uYWxBZnRlcgUAAAAZZXhjaGFuZ2VkUXVvdGVBc3NldEFtb3VudAEAAAAOdXBkYXRlU2V0dGluZ3MAAAAFAAAAEF9pbml0TWFyZ2luUmF0aW8AAAAEX21tcgAAABRfbGlxdWlkYXRpb25GZWVSYXRpbwAAAA5fZnVuZGluZ1BlcmlvZAAAAARfZmVlCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACBQAAABFrX2luaXRNYXJnaW5SYXRpbwUAAAAQX2luaXRNYXJnaW5SYXRpbwkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgUAAAAFa19tbXIFAAAABF9tbXIJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIFAAAAFWtfbGlxdWlkYXRpb25GZWVSYXRpbwUAAAAUX2xpcXVpZGF0aW9uRmVlUmF0aW8JAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIFAAAAD2tfZnVuZGluZ1BlcmlvZAUAAAAOX2Z1bmRpbmdQZXJpb2QJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIFAAAABWtfZmVlBQAAAARfZmVlBQAAAANuaWwBAAAADXVwZGF0ZUZ1bmRpbmcAAAAEAAAACl9iYXNlQURURlAAAAARX25leHRGdW5kaW5nQmxvY2sAAAAKX2xhdGVzdENQRgAAAAxfZnVuZGluZ1JhdGUJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIFAAAAIWtfYmFzZUFzc2V0RGVsdGFUaGlzRnVuZGluZ1BlcmlvZAUAAAAKX2Jhc2VBRFRGUAkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgUAAAASa19uZXh0RnVuZGluZ0Jsb2NrBQAAABFfbmV4dEZ1bmRpbmdCbG9jawkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgUAAAALa19sYXRlc3RDUEYFAAAACl9sYXRlc3RDUEYJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIFAAAADWtfZnVuZGluZ1JhdGUFAAAADF9mdW5kaW5nUmF0ZQUAAAADbmlsAQAAAA51cGRhdGVQb3NpdGlvbgAAAAUAAAAIX2FkZHJlc3MAAAAFX3NpemUAAAAHX21hcmdpbgAAAAxfb3Blbk5vdGluYWwAAAAKX0xzdFVwZENQRgkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgkBAAAADnRvQ29tcG9zaXRlS2V5AAAAAgUAAAAOa19wb3NpdGlvblNpemUFAAAACF9hZGRyZXNzBQAAAAVfc2l6ZQkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgkBAAAADnRvQ29tcG9zaXRlS2V5AAAAAgUAAAAQa19wb3NpdGlvbk1hcmdpbgUAAAAIX2FkZHJlc3MFAAAAB19tYXJnaW4JAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIJAQAAAA50b0NvbXBvc2l0ZUtleQAAAAIFAAAABWtfcG9uBQAAAAhfYWRkcmVzcwUAAAAMX29wZW5Ob3RpbmFsCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACCQEAAAAOdG9Db21wb3NpdGVLZXkAAAACBQAAABNrX3Bvc2l0aW9uTHN0VXBkQ1BGBQAAAAhfYWRkcmVzcwUAAAAKX0xzdFVwZENQRgUAAAADbmlsAQAAAAl1cGRhdGVBbW0AAAAGAAAAB19xdEFzdFIAAAAHX2JzQXN0UgAAACVfYmFzZUFzc2V0RGVsdGFUaGlzRnVuZGluZ1BlcmlvZEFmdGVyAAAAF190b3RhbFBvc2l0aW9uU2l6ZUFmdGVyAAAAGF9jdW11bGF0aXZlTm90aW9uYWxBZnRlcgAAABZfb3BlbkludGVyZXNldE5vdGlvbmFsCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACBQAAAAhrX3F0QXN0UgUAAAAHX3F0QXN0UgkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgUAAAAIa19ic0FzdFIFAAAAB19ic0FzdFIJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIFAAAAIWtfYmFzZUFzc2V0RGVsdGFUaGlzRnVuZGluZ1BlcmlvZAUAAAAlX2Jhc2VBc3NldERlbHRhVGhpc0Z1bmRpbmdQZXJpb2RBZnRlcgkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgUAAAATa190b3RhbFBvc2l0aW9uU2l6ZQUAAAAXX3RvdGFsUG9zaXRpb25TaXplQWZ0ZXIJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIFAAAAFGtfY3VtdWxhdGl2ZU5vdGlvbmFsBQAAABhfY3VtdWxhdGl2ZU5vdGlvbmFsQWZ0ZXIJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIFAAAAF2tfb3BlbkludGVyZXNldE5vdGlvbmFsBQAAABZfb3BlbkludGVyZXNldE5vdGlvbmFsBQAAAANuaWwBAAAADmRlbGV0ZVBvc2l0aW9uAAAAAQAAAAhfYWRkcmVzcwkABEwAAAACCQEAAAALRGVsZXRlRW50cnkAAAABCQEAAAAOdG9Db21wb3NpdGVLZXkAAAACBQAAAA5rX3Bvc2l0aW9uU2l6ZQUAAAAIX2FkZHJlc3MJAARMAAAAAgkBAAAAC0RlbGV0ZUVudHJ5AAAAAQkBAAAADnRvQ29tcG9zaXRlS2V5AAAAAgUAAAAQa19wb3NpdGlvbk1hcmdpbgUAAAAIX2FkZHJlc3MJAARMAAAAAgkBAAAAC0RlbGV0ZUVudHJ5AAAAAQkBAAAADnRvQ29tcG9zaXRlS2V5AAAAAgUAAAAFa19wb24FAAAACF9hZGRyZXNzCQAETAAAAAIJAQAAAAtEZWxldGVFbnRyeQAAAAEJAQAAAA50b0NvbXBvc2l0ZUtleQAAAAIFAAAAE2tfcG9zaXRpb25Mc3RVcGRDUEYFAAAACF9hZGRyZXNzBQAAAANuaWwBAAAACHdpdGhkcmF3AAAAAgAAAAhfYWRkcmVzcwAAAAdfYW1vdW50BAAAAAdiYWxhbmNlCQAD8AAAAAIFAAAABHRoaXMFAAAABFVTRE4DCQAAZgAAAAIFAAAAB19hbW91bnQFAAAAB2JhbGFuY2UJAAACAAAAAQkAASwAAAACCQABLAAAAAIJAAEsAAAAAgIAAAATVW5hYmxlIHRvIHdpdGhkcmF3IAkAAaQAAAABBQAAAAdfYW1vdW50AgAAABcgZnJvbSBjb250cmFjdCBiYWxhbmNlIAkAAaQAAAABBQAAAAdiYWxhbmNlCQAETAAAAAIJAQAAAA5TY3JpcHRUcmFuc2ZlcgAAAAMFAAAACF9hZGRyZXNzBQAAAAdfYW1vdW50BQAAAARVU0ROBQAAAANuaWwBAAAADndyaXRlQ29uc3RhbnRzAAAAAAkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACAgAAAA1BRE1JTl9BRERSRVNTCQAEJQAAAAEFAAAADUFETUlOX0FERFJFU1MJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgIAAAAEVVNETgkAAlgAAAABBQAAAARVU0ROCQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAICAAAADFVTRE5fU1RBS0lORwkABCUAAAABBQAAAAxVU0ROX1NUQUtJTkcJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgIAAAAGT1JBQ0xFCQAEJQAAAAEFAAAABk9SQUNMRQUAAAADbmlsAQAAAAV1cGJsYwAAAAEAAAABaQMJAABmAAAAAgAAAAAAAAAAAAUAAAABaQkAAAIAAAABAgAAAAdCYWxhbmNlCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACBQAAAAlrX2JhbGFuY2UFAAAAAWkFAAAAA25pbAEAAAALdHJhbnNmZXJGZWUAAAABAAAAAWkJAARMAAAAAgkBAAAADlNjcmlwdFRyYW5zZmVyAAAAAwUAAAAMRkVFU19BQ0NPVU5UBQAAAAFpBQAAAARVU0ROBQAAAANuaWwAAAAIAAAAAWkBAAAACmluaXRpYWxpemUAAAAHAAAAB19xdEFzdFIAAAAHX2JzQXN0UgAAAA5fZnVuZGluZ1BlcmlvZAAAABBfaW5pdE1hcmdpblJhdGlvAAAABF9tbXIAAAAUX2xpcXVpZGF0aW9uRmVlUmF0aW8AAAAEX2ZlZQMDAwMDAwMDCQAAZwAAAAIAAAAAAAAAAAAFAAAAB19xdEFzdFIGCQAAZwAAAAIAAAAAAAAAAAAFAAAAB19ic0FzdFIGCQAAZwAAAAIAAAAAAAAAAAAFAAAADl9mdW5kaW5nUGVyaW9kBgkAAGcAAAACAAAAAAAAAAAABQAAABBfaW5pdE1hcmdpblJhdGlvBgkAAGcAAAACAAAAAAAAAAAABQAAAARfbW1yBgkAAGcAAAACAAAAAAAAAAAABQAAABRfbGlxdWlkYXRpb25GZWVSYXRpbwYJAQAAAAIhPQAAAAIIBQAAAAFpAAAABmNhbGxlcgUAAAANQURNSU5fQUREUkVTUwYJAQAAAAtpbml0aWFsaXplZAAAAAAJAAACAAAAAQIAAAAdSW52YWxpZCBpbml0aWFsaXplIHBhcmFtZXRlcnMJAAROAAAAAgkABE4AAAACCQAETgAAAAIJAAROAAAAAgkABE4AAAACCQEAAAAJdXBkYXRlQW1tAAAABgUAAAAHX3F0QXN0UgUAAAAHX2JzQXN0UgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkBAAAADnVwZGF0ZVNldHRpbmdzAAAABQUAAAAQX2luaXRNYXJnaW5SYXRpbwUAAAAEX21tcgUAAAAUX2xpcXVpZGF0aW9uRmVlUmF0aW8FAAAADl9mdW5kaW5nUGVyaW9kBQAAAARfZmVlCQEAAAANdXBkYXRlRnVuZGluZwAAAAQAAAAAAAAAAAAJAABkAAAAAggFAAAACWxhc3RCbG9jawAAAAl0aW1lc3RhbXAFAAAADl9mdW5kaW5nUGVyaW9kAAAAAAAAAAAAAAAAAAAAAAAACQEAAAAFdXBibGMAAAABAAAAAAAAAAAACQEAAAAOd3JpdGVDb25zdGFudHMAAAAACQAETAAAAAIJAQAAAAxCb29sZWFuRW50cnkAAAACBQAAAA1rX2luaXRpYWxpemVkBgUAAAADbmlsAAAAAWkBAAAAEGRlY3JlYXNlUG9zaXRpb24AAAAEAAAACl9kaXJlY3Rpb24AAAAHX2Ftb3VudAAAAAlfbGV2ZXJhZ2UAAAATX21pbkJhc2VBc3NldEFtb3VudAMDAwMDAwkBAAAAAiE9AAAAAgUAAAAKX2RpcmVjdGlvbgUAAAAIRElSX0xPTkcJAQAAAAIhPQAAAAIFAAAACl9kaXJlY3Rpb24FAAAACURJUl9TSE9SVAcGCQAAZwAAAAIAAAAAAAAAAAAFAAAAB19hbW91bnQGAwkAAGYAAAACCQAAaAAAAAIAAAAAAAAAAAEFAAAADERFQ0lNQUxfVU5JVAUAAAAJX2xldmVyYWdlBgkAAGYAAAACBQAAAAlfbGV2ZXJhZ2UJAABoAAAAAgAAAAAAAAAAAwUAAAAMREVDSU1BTF9VTklUBgkBAAAAASEAAAABCQEAAAALaW5pdGlhbGl6ZWQAAAAABgkBAAAAASEAAAABCQEAAAAWcmVxdWlyZU1vcmVNYXJnaW5SYXRpbwAAAAMJAQAAAARkaXZkAAAAAgUAAAAMREVDSU1BTF9VTklUBQAAAAlfbGV2ZXJhZ2UJAQAAAA9pbml0TWFyZ2luUmF0aW8AAAAABgkAAAIAAAABAgAAACNJbnZhbGlkIGRlY3JlYXNlUG9zaXRpb24gcGFyYW1ldGVycwQAAAANJHQwMTQyNTUxNDQwNwkBAAAAC2dldFBvc2l0aW9uAAAAAQkABCUAAAABCAUAAAABaQAAAAZjYWxsZXIEAAAAD29sZFBvc2l0aW9uU2l6ZQgFAAAADSR0MDE0MjU1MTQ0MDcAAAACXzEEAAAAEW9sZFBvc2l0aW9uTWFyZ2luCAUAAAANJHQwMTQyNTUxNDQwNwAAAAJfMgQAAAAXb2xkUG9zaXRpb25PcGVuTm90aW9uYWwIBQAAAA0kdDAxNDI1NTE0NDA3AAAAAl8zBAAAABRvbGRQb3NpdGlvbkxzdFVwZENQRggFAAAADSR0MDE0MjU1MTQ0MDcAAAACXzQEAAAADWlzTmV3UG9zaXRpb24JAAAAAAAAAgUAAAAPb2xkUG9zaXRpb25TaXplAAAAAAAAAAAABAAAAA9pc1NhbWVEaXJlY3Rpb24DCQAAZgAAAAIFAAAAD29sZFBvc2l0aW9uU2l6ZQAAAAAAAAAAAAkAAAAAAAACBQAAAApfZGlyZWN0aW9uBQAAAAhESVJfTE9ORwkAAAAAAAACBQAAAApfZGlyZWN0aW9uBQAAAAlESVJfU0hPUlQEAAAADmV4cGFuZEV4aXN0aW5nAwkBAAAAASEAAAABBQAAAA1pc05ld1Bvc2l0aW9uBQAAAA9pc1NhbWVEaXJlY3Rpb24HBAAAAAVpc0FkZAkAAAAAAAACBQAAAApfZGlyZWN0aW9uBQAAAAhESVJfTE9ORwQAAAANJHQwMTQ2OTYxNzQ5MwMDBQAAAA1pc05ld1Bvc2l0aW9uBgUAAAAOZXhwYW5kRXhpc3RpbmcJAAACAAAAAQIAAAA1VXNlIGluY3JlYXNlUG9zaXRpb24gdG8gb3BlbiBuZXcgb3IgaW5jcmVhc2UgcG9zaXRpb24EAAAADG9wZW5Ob3Rpb25hbAkBAAAABG11bGQAAAACBQAAAAdfYW1vdW50BQAAAAlfbGV2ZXJhZ2UEAAAADSR0MDE1MTgwMTUyNzkJAQAAACNnZXRQb3NpdGlvbk5vdGlvbmFsQW5kVW5yZWFsaXplZFBubAAAAAEJAAQlAAAAAQgFAAAAAWkAAAAGY2FsbGVyBAAAABNvbGRQb3NpdGlvbk5vdGlvbmFsCAUAAAANJHQwMTUxODAxNTI3OQAAAAJfMQQAAAANdW5yZWFsaXplZFBubAgFAAAADSR0MDE1MTgwMTUyNzkAAAACXzIDCQAAZgAAAAIFAAAAE29sZFBvc2l0aW9uTm90aW9uYWwFAAAADG9wZW5Ob3Rpb25hbAQAAAANJHQwMTUzNDExNTYwMAkBAAAACXN3YXBJbnB1dAAAAAIFAAAABWlzQWRkBQAAAAxvcGVuTm90aW9uYWwEAAAAFWV4Y2hhbmdlZFBvc2l0aW9uU2l6ZQgFAAAADSR0MDE1MzQxMTU2MDAAAAACXzEEAAAAC3F0QXN0UkFmdGVyCAUAAAANJHQwMTUzNDExNTYwMAAAAAJfMgQAAAALYnNBc3RSQWZ0ZXIIBQAAAA0kdDAxNTM0MTE1NjAwAAAAAl8zBAAAACRiYXNlQXNzZXREZWx0YVRoaXNGdW5kaW5nUGVyaW9kQWZ0ZXIIBQAAAA0kdDAxNTM0MTE1NjAwAAAAAl80BAAAABZ0b3RhbFBvc2l0aW9uU2l6ZUFmdGVyCAUAAAANJHQwMTUzNDExNTYwMAAAAAJfNQQAAAAXY3VtdWxhdGl2ZU5vdGlvbmFsQWZ0ZXIIBQAAAA0kdDAxNTM0MTE1NjAwAAAAAl82BAAAABhleGNoYW5nZWRQb3NpdGlvblNpemVBYnMJAQAAAANhYnMAAAABBQAAABVleGNoYW5nZWRQb3NpdGlvblNpemUDAwkBAAAAAiE9AAAAAgUAAAATX21pbkJhc2VBc3NldEFtb3VudAAAAAAAAAAAAAkAAGYAAAACBQAAABNfbWluQmFzZUFzc2V0QW1vdW50BQAAABhleGNoYW5nZWRQb3NpdGlvblNpemVBYnMHCQAAAgAAAAEJAAEsAAAAAgkAASwAAAACCQABLAAAAAICAAAAJlRvbyBsaXR0bGUgYmFzc2UgYXNzZXQgZXhjaGFuZ2VkLCBnb3QgCQABpAAAAAEFAAAAGGV4Y2hhbmdlZFBvc2l0aW9uU2l6ZUFicwIAAAAKIGV4cGVjdGVkIAkAAaQAAAABBQAAABNfbWluQmFzZUFzc2V0QW1vdW50BAAAAAtyZWFsaXplZFBubAMJAQAAAAIhPQAAAAIFAAAAD29sZFBvc2l0aW9uU2l6ZQAAAAAAAAAAAAkBAAAABGRpdmQAAAACCQEAAAAEbXVsZAAAAAIFAAAADXVucmVhbGl6ZWRQbmwFAAAAGGV4Y2hhbmdlZFBvc2l0aW9uU2l6ZUFicwUAAAAPb2xkUG9zaXRpb25TaXplAAAAAAAAAAAABAAAAA0kdDAxNjE0MTE2NDEyCQEAAAAiY2FsY1JlbWFpbk1hcmdpbldpdGhGdW5kaW5nUGF5bWVudAAAAAQFAAAAD29sZFBvc2l0aW9uU2l6ZQUAAAARb2xkUG9zaXRpb25NYXJnaW4FAAAAFG9sZFBvc2l0aW9uTHN0VXBkQ1BGBQAAAAtyZWFsaXplZFBubAQAAAAMcmVtYWluTWFyZ2luCAUAAAANJHQwMTYxNDExNjQxMgAAAAJfMQQAAAAHYmFkRGVidAgFAAAADSR0MDE2MTQxMTY0MTIAAAACXzIEAAAADmZ1bmRpbmdQYXltZW50CAUAAAANJHQwMTYxNDExNjQxMgAAAAJfMwQAAAAMb2xkTGF0ZXN0Q1BGCAUAAAANJHQwMTYxNDExNjQxMgAAAAJfNAQAAAAZZXhjaGFuZ2VkUXVvdGVBc3NldEFtb3VudAUAAAAMb3Blbk5vdGlvbmFsBAAAABJ1bnJlYWxpemVkUG5sQWZ0ZXIJAABlAAAAAgUAAAANdW5yZWFsaXplZFBubAUAAAALcmVhbGl6ZWRQbmwEAAAAEnJlbWFpbk9wZW5Ob3Rpb25hbAMJAABmAAAAAgUAAAAPb2xkUG9zaXRpb25TaXplAAAAAAAAAAAACQAAZQAAAAIJAABlAAAAAgUAAAATb2xkUG9zaXRpb25Ob3Rpb25hbAUAAAAZZXhjaGFuZ2VkUXVvdGVBc3NldEFtb3VudAUAAAASdW5yZWFsaXplZFBubEFmdGVyCQAAZQAAAAIJAABkAAAAAgUAAAASdW5yZWFsaXplZFBubEFmdGVyBQAAABNvbGRQb3NpdGlvbk5vdGlvbmFsBQAAABlleGNoYW5nZWRRdW90ZUFzc2V0QW1vdW50CQAFHAAAAAoJAABkAAAAAgUAAAAPb2xkUG9zaXRpb25TaXplBQAAABVleGNoYW5nZWRQb3NpdGlvblNpemUFAAAADHJlbWFpbk1hcmdpbgkBAAAAA2FicwAAAAEFAAAAEnJlbWFpbk9wZW5Ob3Rpb25hbAUAAAAMb2xkTGF0ZXN0Q1BGBQAAAAtic0FzdFJBZnRlcgUAAAALcXRBc3RSQWZ0ZXIFAAAAJGJhc2VBc3NldERlbHRhVGhpc0Z1bmRpbmdQZXJpb2RBZnRlcgUAAAAWdG90YWxQb3NpdGlvblNpemVBZnRlcgUAAAAXY3VtdWxhdGl2ZU5vdGlvbmFsQWZ0ZXIJAABlAAAAAgkBAAAAFW9wZW5JbnRlcmVzZXROb3Rpb25hbAAAAAAFAAAADG9wZW5Ob3Rpb25hbAkAAAIAAAABAgAAABRDbG9zZSBwb3NpdGlvbiBmaXJzdAQAAAAPbmV3UG9zaXRpb25TaXplCAUAAAANJHQwMTQ2OTYxNzQ5MwAAAAJfMQQAAAAXbmV3UG9zaXRpb25SZW1haW5NYXJnaW4IBQAAAA0kdDAxNDY5NjE3NDkzAAAAAl8yBAAAABZuZXdQb3NpaW9uT3Blbk5vdGlvbmFsCAUAAAANJHQwMTQ2OTYxNzQ5MwAAAAJfMwQAAAAUbmV3UG9zaXRpb25MYXRlc3RDUEYIBQAAAA0kdDAxNDY5NjE3NDkzAAAAAl80BAAAAAtic0FzdFJBZnRlcggFAAAADSR0MDE0Njk2MTc0OTMAAAACXzUEAAAAC3F0QXN0UkFmdGVyCAUAAAANJHQwMTQ2OTYxNzQ5MwAAAAJfNgQAAAAkYmFzZUFzc2V0RGVsdGFUaGlzRnVuZGluZ1BlcmlvZEFmdGVyCAUAAAANJHQwMTQ2OTYxNzQ5MwAAAAJfNwQAAAAWdG90YWxQb3NpdGlvblNpemVBZnRlcggFAAAADSR0MDE0Njk2MTc0OTMAAAACXzgEAAAAF2N1bXVsYXRpdmVOb3Rpb25hbEFmdGVyCAUAAAANJHQwMTQ2OTYxNzQ5MwAAAAJfOQQAAAAab3BlbkludGVyZXNldE5vdGlvbmFsQWZ0ZXIIBQAAAA0kdDAxNDY5NjE3NDkzAAAAA18xMAkABE4AAAACCQEAAAAOdXBkYXRlUG9zaXRpb24AAAAFCQAEJQAAAAEIBQAAAAFpAAAABmNhbGxlcgUAAAAPbmV3UG9zaXRpb25TaXplBQAAABduZXdQb3NpdGlvblJlbWFpbk1hcmdpbgUAAAAWbmV3UG9zaWlvbk9wZW5Ob3Rpb25hbAUAAAAUbmV3UG9zaXRpb25MYXRlc3RDUEYJAQAAAAl1cGRhdGVBbW0AAAAGBQAAAAtxdEFzdFJBZnRlcgUAAAALYnNBc3RSQWZ0ZXIFAAAAJGJhc2VBc3NldERlbHRhVGhpc0Z1bmRpbmdQZXJpb2RBZnRlcgUAAAAWdG90YWxQb3NpdGlvblNpemVBZnRlcgUAAAAXY3VtdWxhdGl2ZU5vdGlvbmFsQWZ0ZXIFAAAAGm9wZW5JbnRlcmVzZXROb3Rpb25hbEFmdGVyAAAAAWkBAAAAEGluY3JlYXNlUG9zaXRpb24AAAADAAAACl9kaXJlY3Rpb24AAAAJX2xldmVyYWdlAAAAE19taW5CYXNlQXNzZXRBbW91bnQEAAAACl9yYXdBbW91bnQICQABkQAAAAIIBQAAAAFpAAAACHBheW1lbnRzAAAAAAAAAAAAAAAABmFtb3VudAMDAwMDAwMJAQAAAAIhPQAAAAIFAAAACl9kaXJlY3Rpb24FAAAACERJUl9MT05HCQEAAAACIT0AAAACBQAAAApfZGlyZWN0aW9uBQAAAAlESVJfU0hPUlQHBgkAAGcAAAACAAAAAAAAAAAABQAAAApfcmF3QW1vdW50BgMJAABmAAAAAgkAAGgAAAACAAAAAAAAAAABBQAAAAxERUNJTUFMX1VOSVQFAAAACV9sZXZlcmFnZQYJAABmAAAAAgUAAAAJX2xldmVyYWdlCQAAaAAAAAIAAAAAAAAAAAMFAAAADERFQ0lNQUxfVU5JVAYJAQAAAAEhAAAAAQkBAAAAC2luaXRpYWxpemVkAAAAAAYJAQAAAAIhPQAAAAIICQABkQAAAAIIBQAAAAFpAAAACHBheW1lbnRzAAAAAAAAAAAAAAAAB2Fzc2V0SWQFAAAABFVTRE4GCQEAAAABIQAAAAEJAQAAABZyZXF1aXJlTW9yZU1hcmdpblJhdGlvAAAAAwkBAAAABGRpdmQAAAACBQAAAAxERUNJTUFMX1VOSVQFAAAACV9sZXZlcmFnZQkBAAAAD2luaXRNYXJnaW5SYXRpbwAAAAAGCQAAAgAAAAECAAAAI0ludmFsaWQgaW5jcmVhc2VQb3NpdGlvbiBwYXJhbWV0ZXJzBAAAAAlmZWVBbW91bnQJAQAAAARtdWxkAAAAAgUAAAAKX3Jhd0Ftb3VudAkBAAAAA2ZlZQAAAAAEAAAAB19hbW91bnQJAABlAAAAAgUAAAAKX3Jhd0Ftb3VudAUAAAAJZmVlQW1vdW50BAAAAA0kdDAxODQ4MzE4NjM1CQEAAAALZ2V0UG9zaXRpb24AAAABCQAEJQAAAAEIBQAAAAFpAAAABmNhbGxlcgQAAAAPb2xkUG9zaXRpb25TaXplCAUAAAANJHQwMTg0ODMxODYzNQAAAAJfMQQAAAARb2xkUG9zaXRpb25NYXJnaW4IBQAAAA0kdDAxODQ4MzE4NjM1AAAAAl8yBAAAABdvbGRQb3NpdGlvbk9wZW5Ob3Rpb25hbAgFAAAADSR0MDE4NDgzMTg2MzUAAAACXzMEAAAAFG9sZFBvc2l0aW9uTHN0VXBkQ1BGCAUAAAANJHQwMTg0ODMxODYzNQAAAAJfNAQAAAANaXNOZXdQb3NpdGlvbgkAAAAAAAACBQAAAA9vbGRQb3NpdGlvblNpemUAAAAAAAAAAAAEAAAAD2lzU2FtZURpcmVjdGlvbgMJAABmAAAAAgUAAAAPb2xkUG9zaXRpb25TaXplAAAAAAAAAAAACQAAAAAAAAIFAAAACl9kaXJlY3Rpb24FAAAACERJUl9MT05HCQAAAAAAAAIFAAAACl9kaXJlY3Rpb24FAAAACURJUl9TSE9SVAQAAAAOZXhwYW5kRXhpc3RpbmcDCQEAAAABIQAAAAEFAAAADWlzTmV3UG9zaXRpb24FAAAAD2lzU2FtZURpcmVjdGlvbgcEAAAABWlzQWRkCQAAAAAAAAIFAAAACl9kaXJlY3Rpb24FAAAACERJUl9MT05HBAAAAA0kdDAxODkyNDIxMTEyAwMFAAAADWlzTmV3UG9zaXRpb24GBQAAAA5leHBhbmRFeGlzdGluZwQAAAAMb3Blbk5vdGlvbmFsCQEAAAAEbXVsZAAAAAIFAAAAB19hbW91bnQFAAAACV9sZXZlcmFnZQQAAAANJHQwMTkzMjYxOTU1NwkBAAAACXN3YXBJbnB1dAAAAAIFAAAABWlzQWRkBQAAAAxvcGVuTm90aW9uYWwEAAAAFWFtb3VudEJhc2VBc3NldEJvdWdodAgFAAAADSR0MDE5MzI2MTk1NTcAAAACXzEEAAAAC3F0QXN0UkFmdGVyCAUAAAANJHQwMTkzMjYxOTU1NwAAAAJfMgQAAAALYnNBc3RSQWZ0ZXIIBQAAAA0kdDAxOTMyNjE5NTU3AAAAAl8zBAAAACRiYXNlQXNzZXREZWx0YVRoaXNGdW5kaW5nUGVyaW9kQWZ0ZXIIBQAAAA0kdDAxOTMyNjE5NTU3AAAAAl80BAAAABZ0b3RhbFBvc2l0aW9uU2l6ZUFmdGVyCAUAAAANJHQwMTkzMjYxOTU1NwAAAAJfNQQAAAAXY3VtdWxhdGl2ZU5vdGlvbmFsQWZ0ZXIIBQAAAA0kdDAxOTMyNjE5NTU3AAAAAl82AwMJAQAAAAIhPQAAAAIFAAAAE19taW5CYXNlQXNzZXRBbW91bnQAAAAAAAAAAAAJAABmAAAAAgUAAAATX21pbkJhc2VBc3NldEFtb3VudAkBAAAAA2FicwAAAAEFAAAAFWFtb3VudEJhc2VBc3NldEJvdWdodAcJAAACAAAAAQkAASwAAAACCQABLAAAAAIJAAEsAAAAAgIAAAANTGltaXQgZXJyb3I6IAkAAaQAAAABCQEAAAADYWJzAAAAAQUAAAAVYW1vdW50QmFzZUFzc2V0Qm91Z2h0AgAAAAMgPCAJAAGkAAAAAQUAAAATX21pbkJhc2VBc3NldEFtb3VudAQAAAAPbmV3UG9zaXRpb25TaXplCQAAZAAAAAIFAAAAD29sZFBvc2l0aW9uU2l6ZQUAAAAVYW1vdW50QmFzZUFzc2V0Qm91Z2h0BAAAABlpbmNyZWFzZU1hcmdpblJlcXVpcmVtZW50CQEAAAAEZGl2ZAAAAAIFAAAADG9wZW5Ob3Rpb25hbAUAAAAJX2xldmVyYWdlBAAAAA0kdDAxOTkzODIwMTkxCQEAAAAiY2FsY1JlbWFpbk1hcmdpbldpdGhGdW5kaW5nUGF5bWVudAAAAAQFAAAAD29sZFBvc2l0aW9uU2l6ZQUAAAARb2xkUG9zaXRpb25NYXJnaW4FAAAAFG9sZFBvc2l0aW9uTHN0VXBkQ1BGBQAAABlpbmNyZWFzZU1hcmdpblJlcXVpcmVtZW50BAAAAAxyZW1haW5NYXJnaW4IBQAAAA0kdDAxOTkzODIwMTkxAAAAAl8xBAAAAAJ4MQgFAAAADSR0MDE5OTM4MjAxOTEAAAACXzIEAAAAAngyCAUAAAANJHQwMTk5MzgyMDE5MQAAAAJfMwQAAAAMb2xkTGF0ZXN0Q1BGCAUAAAANJHQwMTk5MzgyMDE5MQAAAAJfNAkABRwAAAAKBQAAAA9uZXdQb3NpdGlvblNpemUFAAAADHJlbWFpbk1hcmdpbgkAAGQAAAACBQAAABdvbGRQb3NpdGlvbk9wZW5Ob3Rpb25hbAUAAAAMb3Blbk5vdGlvbmFsBQAAAAxvbGRMYXRlc3RDUEYFAAAAC2JzQXN0UkFmdGVyBQAAAAtxdEFzdFJBZnRlcgUAAAAkYmFzZUFzc2V0RGVsdGFUaGlzRnVuZGluZ1BlcmlvZEFmdGVyBQAAABZ0b3RhbFBvc2l0aW9uU2l6ZUFmdGVyBQAAABdjdW11bGF0aXZlTm90aW9uYWxBZnRlcgkAAGQAAAACCQEAAAAVb3BlbkludGVyZXNldE5vdGlvbmFsAAAAAAUAAAAMb3Blbk5vdGlvbmFsBAAAAAxvcGVuTm90aW9uYWwJAQAAAARtdWxkAAAAAgUAAAAHX2Ftb3VudAUAAAAJX2xldmVyYWdlBAAAAA0kdDAyMDgyMjIwOTIxCQEAAAAjZ2V0UG9zaXRpb25Ob3Rpb25hbEFuZFVucmVhbGl6ZWRQbmwAAAABCQAEJQAAAAEIBQAAAAFpAAAABmNhbGxlcgQAAAATb2xkUG9zaXRpb25Ob3Rpb25hbAgFAAAADSR0MDIwODIyMjA5MjEAAAACXzEEAAAADXVucmVhbGl6ZWRQbmwIBQAAAA0kdDAyMDgyMjIwOTIxAAAAAl8yAwkAAGYAAAACBQAAABNvbGRQb3NpdGlvbk5vdGlvbmFsBQAAAAxvcGVuTm90aW9uYWwJAAACAAAAAQIAAAAuVXNlIGRlY3JlYXNlUG9zaXRpb24gdG8gZGVjcmVhc2UgcG9zaXRpb24gc2l6ZQkAAAIAAAABAgAAABRDbG9zZSBwb3NpdGlvbiBmaXJzdAQAAAAPbmV3UG9zaXRpb25TaXplCAUAAAANJHQwMTg5MjQyMTExMgAAAAJfMQQAAAAXbmV3UG9zaXRpb25SZW1haW5NYXJnaW4IBQAAAA0kdDAxODkyNDIxMTEyAAAAAl8yBAAAABZuZXdQb3NpaW9uT3Blbk5vdGlvbmFsCAUAAAANJHQwMTg5MjQyMTExMgAAAAJfMwQAAAAUbmV3UG9zaXRpb25MYXRlc3RDUEYIBQAAAA0kdDAxODkyNDIxMTEyAAAAAl80BAAAAAtic0FzdFJBZnRlcggFAAAADSR0MDE4OTI0MjExMTIAAAACXzUEAAAAC3F0QXN0UkFmdGVyCAUAAAANJHQwMTg5MjQyMTExMgAAAAJfNgQAAAAkYmFzZUFzc2V0RGVsdGFUaGlzRnVuZGluZ1BlcmlvZEFmdGVyCAUAAAANJHQwMTg5MjQyMTExMgAAAAJfNwQAAAAWdG90YWxQb3NpdGlvblNpemVBZnRlcggFAAAADSR0MDE4OTI0MjExMTIAAAACXzgEAAAAF2N1bXVsYXRpdmVOb3Rpb25hbEFmdGVyCAUAAAANJHQwMTg5MjQyMTExMgAAAAJfOQQAAAAab3BlbkludGVyZXNldE5vdGlvbmFsQWZ0ZXIIBQAAAA0kdDAxODkyNDIxMTEyAAAAA18xMAQAAAAFc3Rha2UJAAP8AAAABAUAAAAMVVNETl9TVEFLSU5HAgAAAAxsb2NrTmV1dHJpbm8FAAAAA25pbAkABEwAAAACCQEAAAAPQXR0YWNoZWRQYXltZW50AAAAAgUAAAAEVVNETgUAAAAHX2Ftb3VudAUAAAADbmlsAwkAAAAAAAACBQAAAAVzdGFrZQUAAAAFc3Rha2UJAAROAAAAAgkABE4AAAACCQAETgAAAAIJAQAAAA51cGRhdGVQb3NpdGlvbgAAAAUJAAQlAAAAAQgFAAAAAWkAAAAGY2FsbGVyBQAAAA9uZXdQb3NpdGlvblNpemUFAAAAF25ld1Bvc2l0aW9uUmVtYWluTWFyZ2luBQAAABZuZXdQb3NpaW9uT3Blbk5vdGlvbmFsBQAAABRuZXdQb3NpdGlvbkxhdGVzdENQRgkBAAAACXVwZGF0ZUFtbQAAAAYFAAAAC3F0QXN0UkFmdGVyBQAAAAtic0FzdFJBZnRlcgUAAAAkYmFzZUFzc2V0RGVsdGFUaGlzRnVuZGluZ1BlcmlvZEFmdGVyBQAAABZ0b3RhbFBvc2l0aW9uU2l6ZUFmdGVyBQAAABdjdW11bGF0aXZlTm90aW9uYWxBZnRlcgUAAAAab3BlbkludGVyZXNldE5vdGlvbmFsQWZ0ZXIJAQAAAAt0cmFuc2ZlckZlZQAAAAEFAAAACWZlZUFtb3VudAkBAAAABXVwYmxjAAAAAQkAAGQAAAACCQEAAAAIY2JhbGFuY2UAAAAABQAAAAdfYW1vdW50CQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgAAAAFpAQAAAAlhZGRNYXJnaW4AAAAABAAAAApfcmF3QW1vdW50CAkAAZEAAAACCAUAAAABaQAAAAhwYXltZW50cwAAAAAAAAAAAAAAAAZhbW91bnQDAwkBAAAAAiE9AAAAAggJAAGRAAAAAggFAAAAAWkAAAAIcGF5bWVudHMAAAAAAAAAAAAAAAAHYXNzZXRJZAUAAAAEVVNETgYJAQAAAAEhAAAAAQkBAAAAE3JlcXVpcmVPcGVuUG9zaXRpb24AAAABCQAEJQAAAAEIBQAAAAFpAAAABmNhbGxlcgkAAAIAAAABAgAAABxJbnZhbGlkIGFkZE1hcmdpbiBwYXJhbWV0ZXJzBAAAAAlmZWVBbW91bnQJAQAAAARtdWxkAAAAAgUAAAAKX3Jhd0Ftb3VudAkBAAAAA2ZlZQAAAAAEAAAAB19hbW91bnQJAABlAAAAAgUAAAAKX3Jhd0Ftb3VudAUAAAAJZmVlQW1vdW50BAAAAA0kdDAyMjAxNDIyMTY2CQEAAAALZ2V0UG9zaXRpb24AAAABCQAEJQAAAAEIBQAAAAFpAAAABmNhbGxlcgQAAAAPb2xkUG9zaXRpb25TaXplCAUAAAANJHQwMjIwMTQyMjE2NgAAAAJfMQQAAAARb2xkUG9zaXRpb25NYXJnaW4IBQAAAA0kdDAyMjAxNDIyMTY2AAAAAl8yBAAAABdvbGRQb3NpdGlvbk9wZW5Ob3Rpb25hbAgFAAAADSR0MDIyMDE0MjIxNjYAAAACXzMEAAAAFG9sZFBvc2l0aW9uTHN0VXBkQ1BGCAUAAAANJHQwMjIwMTQyMjE2NgAAAAJfNAQAAAAFc3Rha2UJAAP8AAAABAUAAAAMVVNETl9TVEFLSU5HAgAAAAxsb2NrTmV1dHJpbm8FAAAAA25pbAkABEwAAAACCQEAAAAPQXR0YWNoZWRQYXltZW50AAAAAgUAAAAEVVNETgUAAAAHX2Ftb3VudAUAAAADbmlsAwkAAAAAAAACBQAAAAVzdGFrZQUAAAAFc3Rha2UJAAROAAAAAgkABE4AAAACCQEAAAAOdXBkYXRlUG9zaXRpb24AAAAFCQAEJQAAAAEIBQAAAAFpAAAABmNhbGxlcgUAAAAPb2xkUG9zaXRpb25TaXplCQAAZAAAAAIFAAAAEW9sZFBvc2l0aW9uTWFyZ2luCAkAAZEAAAACCAUAAAABaQAAAAhwYXltZW50cwAAAAAAAAAAAAAAAAZhbW91bnQFAAAAF29sZFBvc2l0aW9uT3Blbk5vdGlvbmFsBQAAABRvbGRQb3NpdGlvbkxzdFVwZENQRgkBAAAAC3RyYW5zZmVyRmVlAAAAAQUAAAAJZmVlQW1vdW50CQEAAAAFdXBibGMAAAABCQAAZAAAAAIJAQAAAAhjYmFsYW5jZQAAAAAFAAAAB19hbW91bnQJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAAAAAWkBAAAADHJlbW92ZU1hcmdpbgAAAAEAAAAHX2Ftb3VudAMDCQAAZwAAAAIAAAAAAAAAAAAFAAAAB19hbW91bnQGCQEAAAABIQAAAAEJAQAAABNyZXF1aXJlT3BlblBvc2l0aW9uAAAAAQkABCUAAAABCAUAAAABaQAAAAZjYWxsZXIJAAACAAAAAQIAAAAfSW52YWxpZCByZW1vdmVNYXJnaW4gcGFyYW1ldGVycwQAAAANJHQwMjI3NTIyMjkwNAkBAAAAC2dldFBvc2l0aW9uAAAAAQkABCUAAAABCAUAAAABaQAAAAZjYWxsZXIEAAAAD29sZFBvc2l0aW9uU2l6ZQgFAAAADSR0MDIyNzUyMjI5MDQAAAACXzEEAAAAEW9sZFBvc2l0aW9uTWFyZ2luCAUAAAANJHQwMjI3NTIyMjkwNAAAAAJfMgQAAAAXb2xkUG9zaXRpb25PcGVuTm90aW9uYWwIBQAAAA0kdDAyMjc1MjIyOTA0AAAAAl8zBAAAABRvbGRQb3NpdGlvbkxzdFVwZENQRggFAAAADSR0MDIyNzUyMjI5MDQAAAACXzQEAAAAC21hcmdpbkRlbHRhCQEAAAABLQAAAAEFAAAAB19hbW91bnQEAAAADSR0MDIyOTQxMjMxMzYJAQAAACJjYWxjUmVtYWluTWFyZ2luV2l0aEZ1bmRpbmdQYXltZW50AAAABAUAAAAPb2xkUG9zaXRpb25TaXplBQAAABFvbGRQb3NpdGlvbk1hcmdpbgUAAAAUb2xkUG9zaXRpb25Mc3RVcGRDUEYFAAAAC21hcmdpbkRlbHRhBAAAAAxyZW1haW5NYXJnaW4IBQAAAA0kdDAyMjk0MTIzMTM2AAAAAl8xBAAAAAdiYWREZWJ0CAUAAAANJHQwMjI5NDEyMzEzNgAAAAJfMgQAAAACeDEIBQAAAA0kdDAyMjk0MTIzMTM2AAAAAl8zBAAAAApsYXRlc3RDUEYxCAUAAAANJHQwMjI5NDEyMzEzNgAAAAJfNAMJAQAAAAIhPQAAAAIFAAAAB2JhZERlYnQAAAAAAAAAAAAJAAACAAAAAQIAAAAbSW52YWxpZCBhZGRlZCBtYXJnaW4gYW1vdW50BAAAAAd1bnN0YWtlCQAD/AAAAAQFAAAADFVTRE5fU1RBS0lORwIAAAAOdW5sb2NrTmV1dHJpbm8JAARMAAAAAgUAAAAHX2Ftb3VudAkABEwAAAACCQACWAAAAAEFAAAABFVTRE4FAAAAA25pbAUAAAADbmlsAwkAAAAAAAACBQAAAAd1bnN0YWtlBQAAAAd1bnN0YWtlCQAETgAAAAIJAAROAAAAAgkBAAAADnVwZGF0ZVBvc2l0aW9uAAAABQkABCUAAAABCAUAAAABaQAAAAZjYWxsZXIFAAAAD29sZFBvc2l0aW9uU2l6ZQUAAAAMcmVtYWluTWFyZ2luBQAAABdvbGRQb3NpdGlvbk9wZW5Ob3Rpb25hbAUAAAAKbGF0ZXN0Q1BGMQkBAAAACHdpdGhkcmF3AAAAAggFAAAAAWkAAAAGY2FsbGVyBQAAAAdfYW1vdW50CQEAAAAFdXBibGMAAAABCQAAZQAAAAIJAQAAAAhjYmFsYW5jZQAAAAAFAAAAB19hbW91bnQJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAAAAAWkBAAAADWNsb3NlUG9zaXRpb24AAAAAAwkBAAAAASEAAAABCQEAAAATcmVxdWlyZU9wZW5Qb3NpdGlvbgAAAAEJAAQlAAAAAQgFAAAAAWkAAAAGY2FsbGVyCQAAAgAAAAECAAAAIEludmFsaWQgY2xvc2VQb3NpdGlvbiBwYXJhbWV0ZXJzBAAAAA0kdDAyMzc4NjI0MTM0CQEAAAAVaW50ZXJuYWxDbG9zZVBvc2l0aW9uAAAAAQkABCUAAAABCAUAAAABaQAAAAZjYWxsZXIEAAAAAngxCAUAAAANJHQwMjM3ODYyNDEzNAAAAAJfMQQAAAAHYmFkRGVidAgFAAAADSR0MDIzNzg2MjQxMzQAAAACXzIEAAAAC3JlYWxpemVkUG5sCAUAAAANJHQwMjM3ODYyNDEzNAAAAAJfMwQAAAANbWFyZ2luVG9WYXVsdAgFAAAADSR0MDIzNzg2MjQxMzQAAAACXzQEAAAAFnF1b3RlQXNzZXRSZXNlcnZlQWZ0ZXIIBQAAAA0kdDAyMzc4NjI0MTM0AAAAAl81BAAAAAtic0FzdFJBZnRlcggFAAAADSR0MDIzNzg2MjQxMzQAAAACXzYEAAAAJGJhc2VBc3NldERlbHRhVGhpc0Z1bmRpbmdQZXJpb2RBZnRlcggFAAAADSR0MDIzNzg2MjQxMzQAAAACXzcEAAAAFnRvdGFsUG9zaXRpb25TaXplQWZ0ZXIIBQAAAA0kdDAyMzc4NjI0MTM0AAAAAl84BAAAABdjdW11bGF0aXZlTm90aW9uYWxBZnRlcggFAAAADSR0MDIzNzg2MjQxMzQAAAACXzkEAAAAGm9wZW5JbnRlcmVzZXROb3Rpb25hbEFmdGVyCAUAAAANJHQwMjM3ODYyNDEzNAAAAANfMTADCQAAZgAAAAIFAAAAB2JhZERlYnQAAAAAAAAAAAAJAAACAAAAAQIAAAAmVW5hYmxlIHRvIGNsb3NlIHBvc2l0aW9uIHdpdGggYmFkIGRlYnQEAAAADndpdGhkcmF3QW1vdW50CQEAAAADYWJzAAAAAQUAAAANbWFyZ2luVG9WYXVsdAQAAAACYmQJAABlAAAAAgkBAAAACGNiYWxhbmNlAAAAAAUAAAAOd2l0aGRyYXdBbW91bnQEAAAADSR0MDI0MzI3MjQ0MjMDCQAAZgAAAAIAAAAAAAAAAAAFAAAAAmJkCQAFFAAAAAIAAAAAAAAAAAAJAQAAAANhYnMAAAABBQAAAAJiZAkABRQAAAACBQAAAAJiZAAAAAAAAAAAAAQAAAACbmIIBQAAAA0kdDAyNDMyNzI0NDIzAAAAAl8xBAAAAAVmcm9taQgFAAAADSR0MDI0MzI3MjQ0MjMAAAACXzIEAAAAAXgDCQAAZgAAAAIFAAAABWZyb21pAAAAAAAAAAAABAAAABF3aXRoZHJhd0luc3VyYW5jZQkAA/wAAAAEBQAAABFJTlNVUkFOQ0VfQUREUkVTUwIAAAAId2l0aGRyYXcJAARMAAAAAgUAAAAFZnJvbWkFAAAAA25pbAUAAAADbmlsAwkAAAAAAAACBQAAABF3aXRoZHJhd0luc3VyYW5jZQUAAAARd2l0aGRyYXdJbnN1cmFuY2UFAAAAA25pbAkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4FAAAAA25pbAMJAAAAAAAAAgUAAAABeAUAAAABeAQAAAAHdW5zdGFrZQkAA/wAAAAEBQAAAAxVU0ROX1NUQUtJTkcCAAAADnVubG9ja05ldXRyaW5vCQAETAAAAAIJAABlAAAAAgUAAAAOd2l0aGRyYXdBbW91bnQFAAAABWZyb21pCQAETAAAAAIJAAJYAAAAAQUAAAAEVVNETgUAAAADbmlsBQAAAANuaWwDCQAAAAAAAAIFAAAAB3Vuc3Rha2UFAAAAB3Vuc3Rha2UJAAROAAAAAgkABE4AAAACCQAETgAAAAIJAQAAAA5kZWxldGVQb3NpdGlvbgAAAAEJAAQlAAAAAQgFAAAAAWkAAAAGY2FsbGVyCQEAAAAJdXBkYXRlQW1tAAAABgUAAAAWcXVvdGVBc3NldFJlc2VydmVBZnRlcgUAAAALYnNBc3RSQWZ0ZXIFAAAAJGJhc2VBc3NldERlbHRhVGhpc0Z1bmRpbmdQZXJpb2RBZnRlcgUAAAAWdG90YWxQb3NpdGlvblNpemVBZnRlcgUAAAAXY3VtdWxhdGl2ZU5vdGlvbmFsQWZ0ZXIFAAAAGm9wZW5JbnRlcmVzZXROb3Rpb25hbEFmdGVyCQEAAAAId2l0aGRyYXcAAAACCAUAAAABaQAAAAZjYWxsZXIFAAAADndpdGhkcmF3QW1vdW50CQEAAAAFdXBibGMAAAABBQAAAAJuYgkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAAAAAWkBAAAACWxpcXVpZGF0ZQAAAAEAAAAHX3RyYWRlcgMDCQEAAAABIQAAAAEJAQAAABZyZXF1aXJlTW9yZU1hcmdpblJhdGlvAAAAAwkBAAAADmdldE1hcmdpblJhdGlvAAAAAQUAAAAHX3RyYWRlcgkBAAAAA21tcgAAAAAHBgkBAAAAASEAAAABCQEAAAALaW5pdGlhbGl6ZWQAAAAACQAAAgAAAAECAAAAE1VuYWJsZSB0byBsaXF1aWRhdGUEAAAADSR0MDI1Mzc3MjU2OTcJAQAAABVpbnRlcm5hbENsb3NlUG9zaXRpb24AAAABBQAAAAdfdHJhZGVyBAAAAAJ4MQgFAAAADSR0MDI1Mzc3MjU2OTcAAAACXzEEAAAAB2JhZERlYnQIBQAAAA0kdDAyNTM3NzI1Njk3AAAAAl8yBAAAAAJ4MggFAAAADSR0MDI1Mzc3MjU2OTcAAAACXzMEAAAADW1hcmdpblRvVmF1bHQIBQAAAA0kdDAyNTM3NzI1Njk3AAAAAl80BAAAABZxdW90ZUFzc2V0UmVzZXJ2ZUFmdGVyCAUAAAANJHQwMjUzNzcyNTY5NwAAAAJfNQQAAAALYnNBc3RSQWZ0ZXIIBQAAAA0kdDAyNTM3NzI1Njk3AAAAAl82BAAAACRiYXNlQXNzZXREZWx0YVRoaXNGdW5kaW5nUGVyaW9kQWZ0ZXIIBQAAAA0kdDAyNTM3NzI1Njk3AAAAAl83BAAAABZ0b3RhbFBvc2l0aW9uU2l6ZUFmdGVyCAUAAAANJHQwMjUzNzcyNTY5NwAAAAJfOAQAAAAXY3VtdWxhdGl2ZU5vdGlvbmFsQWZ0ZXIIBQAAAA0kdDAyNTM3NzI1Njk3AAAAAl85BAAAABpvcGVuSW50ZXJlc2V0Tm90aW9uYWxBZnRlcggFAAAADSR0MDI1Mzc3MjU2OTcAAAADXzEwBAAAABlleGNoYW5nZWRRdW90ZUFzc2V0QW1vdW50CAUAAAANJHQwMjUzNzcyNTY5NwAAAANfMTEEAAAAD2ZlZVRvTGlxdWlkYXRvcgkAAGkAAAACCQEAAAAEbXVsZAAAAAIFAAAAGWV4Y2hhbmdlZFF1b3RlQXNzZXRBbW91bnQJAQAAABNsaXF1aWRhdGlvbkZlZVJhdGlvAAAAAAAAAAAAAAAAAgQAAAANJHQwMjU3ODcyNjE5MQMJAABmAAAAAgUAAAAPZmVlVG9MaXF1aWRhdG9yBQAAAA1tYXJnaW5Ub1ZhdWx0CQAFFQAAAAMJAABlAAAAAgUAAAAPZmVlVG9MaXF1aWRhdG9yBQAAAA1tYXJnaW5Ub1ZhdWx0BQAAAA1tYXJnaW5Ub1ZhdWx0CQAAZQAAAAIJAABkAAAAAgUAAAAHYmFkRGVidAUAAAAPZmVlVG9MaXF1aWRhdG9yBQAAAA1tYXJnaW5Ub1ZhdWx0CQAFFQAAAAMAAAAAAAAAAAAJAABlAAAAAgUAAAANbWFyZ2luVG9WYXVsdAUAAAAPZmVlVG9MaXF1aWRhdG9yBQAAAAdiYWREZWJ0BAAAABJsaXF1aWRhdGlvbkJhZERlYnQIBQAAAA0kdDAyNTc4NzI2MTkxAAAAAl8xBAAAAAxyZW1haW5NYXJnaW4IBQAAAA0kdDAyNTc4NzI2MTkxAAAAAl8yBAAAAAx0b3RhbEJhZERlYnQIBQAAAA0kdDAyNTc4NzI2MTkxAAAAAl8zCQAETgAAAAIJAAROAAAAAgkBAAAADmRlbGV0ZVBvc2l0aW9uAAAAAQUAAAAHX3RyYWRlcgkBAAAACXVwZGF0ZUFtbQAAAAYFAAAAFnF1b3RlQXNzZXRSZXNlcnZlQWZ0ZXIFAAAAC2JzQXN0UkFmdGVyBQAAACRiYXNlQXNzZXREZWx0YVRoaXNGdW5kaW5nUGVyaW9kQWZ0ZXIFAAAAFnRvdGFsUG9zaXRpb25TaXplQWZ0ZXIFAAAAF2N1bXVsYXRpdmVOb3Rpb25hbEFmdGVyBQAAABpvcGVuSW50ZXJlc2V0Tm90aW9uYWxBZnRlcgkBAAAACHdpdGhkcmF3AAAAAggFAAAAAWkAAAAGY2FsbGVyBQAAAA9mZWVUb0xpcXVpZGF0b3IAAAABaQEAAAAKcGF5RnVuZGluZwAAAAAEAAAAFWZ1bmRpbmdCbG9ja1RpbWVzdGFtcAkBAAAAGW5leHRGdW5kaW5nQmxvY2tUaW1lc3RhbXAAAAAAAwMJAABmAAAAAgUAAAAVZnVuZGluZ0Jsb2NrVGltZXN0YW1wCAUAAAAJbGFzdEJsb2NrAAAACXRpbWVzdGFtcAYJAQAAAAEhAAAAAQkBAAAAC2luaXRpYWxpemVkAAAAAAkAAAIAAAABCQABLAAAAAIJAAEsAAAAAgkAASwAAAACAgAAACFJbnZhbGlkIGZ1bmRpbmcgYmxvY2sgdGltZXN0YW1wOiAJAAGkAAAAAQgFAAAACWxhc3RCbG9jawAAAAl0aW1lc3RhbXACAAAAAyA8IAkAAaQAAAABBQAAABVmdW5kaW5nQmxvY2tUaW1lc3RhbXAEAAAAD3VuZGVybHlpbmdQcmljZQkBAAAAEmdldE9yYWNsZVR3YXBQcmljZQAAAAAEAAAADXNwb3RUd2FwUHJpY2UJAQAAABBnZXRUd2FwU3BvdFByaWNlAAAAAAQAAAAHcHJlbWl1bQkAAGUAAAACBQAAAA1zcG90VHdhcFByaWNlBQAAAA91bmRlcmx5aW5nUHJpY2UEAAAAD3ByZW1pdW1GcmFjdGlvbgkBAAAABGRpdmQAAAACCQEAAAAEbXVsZAAAAAIFAAAAB3ByZW1pdW0JAQAAABRmdW5kaW5nUGVyaW9kRGVjaW1hbAAAAAAFAAAAB09ORV9EQVkEAAAAF3RvdGFsVHJhZGVyUG9zaXRpb25TaXplCQEAAAARdG90YWxQb3NpdGlvblNpemUAAAAABAAAABdhbW1GdW5kaW5nUGF5bWVudFByb2ZpdAkBAAAABG11bGQAAAACBQAAAA9wcmVtaXVtRnJhY3Rpb24FAAAAF3RvdGFsVHJhZGVyUG9zaXRpb25TaXplBAAAAA1mdW5kaW5nQW1vdW50CQEAAAADYWJzAAAAAQUAAAAXYW1tRnVuZGluZ1BheW1lbnRQcm9maXQDCQAAZgAAAAIAAAAAAAAAAAAFAAAAF2FtbUZ1bmRpbmdQYXltZW50UHJvZml0BAAAABF3aXRoZHJhd0luc3VyYW5jZQkAA/wAAAAEBQAAABFJTlNVUkFOQ0VfQUREUkVTUwIAAAAId2l0aGRyYXcJAARMAAAAAgUAAAANZnVuZGluZ0Ftb3VudAUAAAADbmlsBQAAAANuaWwDCQAAAAAAAAIFAAAAEXdpdGhkcmF3SW5zdXJhbmNlBQAAABF3aXRoZHJhd0luc3VyYW5jZQQAAAAFc3Rha2UJAAP8AAAABAUAAAAMVVNETl9TVEFLSU5HAgAAAAxsb2NrTmV1dHJpbm8FAAAAA25pbAkABEwAAAACCQEAAAAPQXR0YWNoZWRQYXltZW50AAAAAgUAAAAEVVNETgUAAAANZnVuZGluZ0Ftb3VudAUAAAADbmlsAwkAAAAAAAACBQAAAAVzdGFrZQUAAAAFc3Rha2UJAQAAAAV1cGJsYwAAAAEJAABkAAAAAgkBAAAACGNiYWxhbmNlAAAAAAUAAAANZnVuZGluZ0Ftb3VudAkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQAETgAAAAIEAAAAB3Vuc3Rha2UJAAP8AAAABAUAAAAMVVNETl9TVEFLSU5HAgAAAA51bmxvY2tOZXV0cmlubwkABEwAAAACBQAAAA1mdW5kaW5nQW1vdW50CQAETAAAAAIJAAJYAAAAAQUAAAAEVVNETgUAAAADbmlsBQAAAANuaWwDCQAAAAAAAAIFAAAAB3Vuc3Rha2UFAAAAB3Vuc3Rha2UEAAAAEGRlcG9zaXRJbnN1cmFuY2UJAAP8AAAABAUAAAARSU5TVVJBTkNFX0FERFJFU1MCAAAAB2RlcG9zaXQFAAAAA25pbAkABEwAAAACCQEAAAAPQXR0YWNoZWRQYXltZW50AAAAAgUAAAAEVVNETgUAAAANZnVuZGluZ0Ftb3VudAUAAAADbmlsAwkAAAAAAAACBQAAABBkZXBvc2l0SW5zdXJhbmNlBQAAABBkZXBvc2l0SW5zdXJhbmNlCQEAAAAFdXBibGMAAAABCQAAZQAAAAIJAQAAAAhjYmFsYW5jZQAAAAAFAAAADWZ1bmRpbmdBbW91bnQJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkBAAAADXVwZGF0ZUZ1bmRpbmcAAAAEAAAAAAAAAAAACQAAZAAAAAIFAAAAFWZ1bmRpbmdCbG9ja1RpbWVzdGFtcAkBAAAAFGZ1bmRpbmdQZXJpb2RTZWNvbmRzAAAAAAkAAGQAAAACCQEAAAAJbGF0ZXN0Q1BGAAAAAAUAAAAPcHJlbWl1bUZyYWN0aW9uCQEAAAAEZGl2ZAAAAAIFAAAAD3ByZW1pdW1GcmFjdGlvbgUAAAAPdW5kZXJseWluZ1ByaWNlAAAAAQAAAAJ0eAEAAAAGdmVyaWZ5AAAAAAkAAfQAAAADCAUAAAACdHgAAAAJYm9keUJ5dGVzCQABkQAAAAIIBQAAAAJ0eAAAAAZwcm9vZnMAAAAAAAAAAAAFAAAAEEFETUlOX1BVQkxJQ19LRVkGqMH2",
    "height": 2064578,
    "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'3N9XdvS1Vkr3AdBBcTektHxCuZjcLUzcwDg')
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'3N6m78uQ2AhDKoTw5Si8i5Br4mT1tp4hNFy')
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 _marginRatio=" + toString(R)) + " _baseMarginRatio=") + toString(S)) + " remainingMarginRatio=") + toString(U)))
92+        else if (if (!(T))
93+            then (U >= 0)
94+            else false)
95+            then throw(((((("Invalid margin marginRatio=" + toString(R)) + " baseMarginRatio=") + toString(S)) + " remainingMarginRatio=") + toString(U)))
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/026f985 
53.79 ms ◑