tx · Cqrw878bgtgXFdcjgo6ukvwHRMhm8axqJmudCuEjFbVw

3N7PpjUKbQppPtukpzUWEgZtwiNhdf4WF4G:  -0.03600000 Waves

2022.06.06 21:28 [2084856] smart account 3N7PpjUKbQppPtukpzUWEgZtwiNhdf4WF4G > SELF 0.00000000 Waves

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

github/deemru/w8io/169f3d6 
41.83 ms