tx · BsdJS9tNiVPko7yW5hDkg42Qjyz7czJfikE7vv5LYJiy

3NCBJ4AUwYM4VGco2UxyouN63GYegq7Akgh:  -0.03400000 Waves

2022.12.20 11:41 [2368387] smart account 3NCBJ4AUwYM4VGco2UxyouN63GYegq7Akgh > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "BsdJS9tNiVPko7yW5hDkg42Qjyz7czJfikE7vv5LYJiy",
    "fee": 3400000,
    "feeAssetId": null,
    "timestamp": 1671525697874,
    "version": 2,
    "chainId": 84,
    "sender": "3NCBJ4AUwYM4VGco2UxyouN63GYegq7Akgh",
    "senderPublicKey": "GYvSkts7Df6hh2TqaQfE5RDMMx5WWyk3tbFsSBLGmkxr",
    "proofs": [
        "3NudFw4SSPB7pEuYsWnaN3QAMgHEKv9wNHJ1w9AfEfj4sPkVfiVwHJdwRhr8CHpu5nnxUWNbJtdw6jTZUDJxpCvM"
    ],
    "script": "base64:BgJKCAISBgoEAhgREhIGCgQCGBESEgYKBAIYERISBgoEAhgREhIGCgQCGBESEgYKBAIYERISBgoEAhgREhIGCgQCGBESEgYKBAIYERJMAAd2ZXJzaW9uAgUxLjAuMAAIa1ZlcnNpb24CB3ZlcnNpb24AB2tBY3RpdmUCBmFjdGl2ZQAJa0Fzc2V0SWRBAgpBX2Fzc2V0X2lkAAlrQXNzZXRJZEICCkJfYXNzZXRfaWQACWtCYWxhbmNlQQIPQV9hc3NldF9iYWxhbmNlAAlrQmFsYW5jZUICD0JfYXNzZXRfYmFsYW5jZQANa0JhbGFuY2VJbml0QQIMQV9hc3NldF9pbml0AA1rQmFsYW5jZUluaXRCAgxCX2Fzc2V0X2luaXQADWtTaGFyZUFzc2V0SWQCDnNoYXJlX2Fzc2V0X2lkABFrU2hhcmVBc3NldFN1cHBseQISc2hhcmVfYXNzZXRfc3VwcGx5AARrRmVlAgpjb21taXNzaW9uAAZrQ2F1c2UCDnNodXRkb3duX2NhdXNlAA1rRmlyc3RIYXJ2ZXN0Ag1maXJzdF9oYXJ2ZXN0ABNrRmlyc3RIYXJ2ZXN0SGVpZ2h0AhRmaXJzdF9oYXJ2ZXN0X2hlaWdodAALa1NoYXJlTGltaXQCHHNoYXJlX2xpbWl0X29uX2ZpcnN0X2hhcnZlc3QAC2tCYXNlUGVyaW9kAgtiYXNlX3BlcmlvZAANa1BlcmlvZExlbmd0aAINcGVyaW9kX2xlbmd0aAAMa1N0YXJ0SGVpZ2h0AgxzdGFydF9oZWlnaHQADGtVU0ROQWRkcmVzcwIYc3Rha2luZ191c2RubnNidF9hZGRyZXNzAAxrRVVSTkFkZHJlc3MCFHN0YWtpbmdfZXVybl9hZGRyZXNzAA5rTGVhc2luZ0Ftb3VudAIObGVhc2luZ19hbW91bnQADGtVU0ROQXNzZXRJZAINdXNkbl9hc3NldF9pZAAMa0VVUk5Bc3NldElkAg1ldXJuX2Fzc2V0X2lkAA5rU3Rha2luZ0Fzc2V0cwIOc3Rha2luZ19hc3NldHMADWtPcmFjbGVBY3RpdmUCFGFjdGl2ZV9hbGxfY29udHJhY3RzAAprRGlzY291bnRzAglkaXNjb3VudHMAD2tEaXNjb3VudFZhbHVlcwIPZGlzY291bnRfdmFsdWVzAA9rVXNlckdTd29wSW5Hb3YCDV9HU3dvcF9hbW91bnQADmtVc2VyU3dvcEluR292AgxfU1dPUF9hbW91bnQAC2tPcmFjbGVQb29sAgVwb29sXwANa0FkbWluUHViS2V5MQILYWRtaW5fcHViXzEADWtBZG1pblB1YktleTICC2FkbWluX3B1Yl8yAA1rQWRtaW5QdWJLZXkzAgthZG1pbl9wdWJfMwASa0FkbWluSW52b2tlUHViS2V5AhBhZG1pbl9pbnZva2VfcHViABBrTW9uZXlCb3hBZGRyZXNzAhFtb25leV9ib3hfYWRkcmVzcwAOa1ZvdGluZ0FkZHJlc3MCDnZvdGluZ19hZGRyZXNzAAtrR292QWRkcmVzcwISZ292ZXJuYW5jZV9hZGRyZXNzAA9rRmFybWluZ0FkZHJlc3MCD2Zhcm1pbmdfYWRkcmVzcwAGb3JhY2xlCQEHQWRkcmVzcwEBGgFU2XwKvR9YhSDEK+tQ4xPWoT2FmvQR69qhARNnZXRCYXNlNThGcm9tT3JhY2xlAQNrZXkEByRtYXRjaDAJAJ0IAgUGb3JhY2xlBQNrZXkDCQABAgUHJG1hdGNoMAIGU3RyaW5nBAZzdHJpbmcFByRtYXRjaDAJANkEAQUGc3RyaW5nBAdub3RoaW5nBQckbWF0Y2gwCQACAQkArAICBQNrZXkCCGlzIGVtcHR5AAxhZG1pblB1YktleTEJARNnZXRCYXNlNThGcm9tT3JhY2xlAQUNa0FkbWluUHViS2V5MQAMYWRtaW5QdWJLZXkyCQETZ2V0QmFzZTU4RnJvbU9yYWNsZQEFDWtBZG1pblB1YktleTIADGFkbWluUHViS2V5MwkBE2dldEJhc2U1OEZyb21PcmFjbGUBBQ1rQWRtaW5QdWJLZXkzABFhZG1pbkludm9rZVB1YktleQkBE2dldEJhc2U1OEZyb21PcmFjbGUBBRJrQWRtaW5JbnZva2VQdWJLZXkAD21vbmV5Qm94QWRkcmVzcwkBB0FkZHJlc3MBCQETZ2V0QmFzZTU4RnJvbU9yYWNsZQEFEGtNb25leUJveEFkZHJlc3MADXZvdGluZ0FkZHJlc3MJAQdBZGRyZXNzAQkBE2dldEJhc2U1OEZyb21PcmFjbGUBBQ5rVm90aW5nQWRkcmVzcwAKZ292QWRkcmVzcwkBB0FkZHJlc3MBCQETZ2V0QmFzZTU4RnJvbU9yYWNsZQEFC2tHb3ZBZGRyZXNzAA5mYXJtaW5nQWRkcmVzcwkBB0FkZHJlc3MBCQETZ2V0QmFzZTU4RnJvbU9yYWNsZQEFD2tGYXJtaW5nQWRkcmVzcwAEVVNETgkBE2dldEJhc2U1OEZyb21PcmFjbGUBBQxrVVNETkFzc2V0SWQABEVVUk4JARNnZXRCYXNlNThGcm9tT3JhY2xlAQUMa0VVUk5Bc3NldElkAA1zdGFraW5nQXNzZXRzCQERQGV4dHJOYXRpdmUoMTA1MykCBQZvcmFjbGUFDmtTdGFraW5nQXNzZXRzABJzdGFraW5nVVNETkFkZHJlc3MJAQdBZGRyZXNzAQkBE2dldEJhc2U1OEZyb21PcmFjbGUBBQxrVVNETkFkZHJlc3MAEnN0YWtpbmdFVVJOQWRkcmVzcwkBB0FkZHJlc3MBCQETZ2V0QmFzZTU4RnJvbU9yYWNsZQEFDGtFVVJOQWRkcmVzcwAKYmFzZVBlcmlvZAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCaCAIFDXZvdGluZ0FkZHJlc3MFC2tCYXNlUGVyaW9kAhFFbXB0eSBrQmFzZVBlcmlvZAALc3RhcnRIZWlnaHQJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAmggCBQ12b3RpbmdBZGRyZXNzBQxrU3RhcnRIZWlnaHQCEkVtcHR5IGtTdGFydEhlaWdodAAMcGVyaW9kTGVuZ3RoCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAJoIAgUNdm90aW5nQWRkcmVzcwUNa1BlcmlvZExlbmd0aAITRW1wdHkga1BlcmlvZExlbmd0aAAVZmlyc3RIYXJ2ZXN0RW5kUGVyaW9kCQBkAgkAZAIFCmJhc2VQZXJpb2QJAGkCCQBlAgUGaGVpZ2h0BQtzdGFydEhlaWdodAUMcGVyaW9kTGVuZ3RoAAMABmFjdGl2ZQkBEUBleHRyTmF0aXZlKDEwNTEpAgUGb3JhY2xlBQ1rT3JhY2xlQWN0aXZlAAlmZWVTY2FsZTYAwIQ9AAZzY2FsZTgAgMLXLwAHc2NhbGUxNgkAtgIBAICAhP6m3uERAQ5hY2NvdW50QmFsYW5jZQIHYXNzZXRJZARwb29sBAckbWF0Y2gwBQdhc3NldElkAwkAAQIFByRtYXRjaDACCkJ5dGVWZWN0b3IEAmlkBQckbWF0Y2gwCQDwBwIFBHBvb2wFAmlkAwkAAQIFByRtYXRjaDACBFVuaXQEBXdhdmVzBQckbWF0Y2gwCAkA7wcBBQRwb29sCWF2YWlsYWJsZQkAAgECC01hdGNoIGVycm9yAQxzdGFrZWRBbW91bnQCB2Fzc2V0SWQEcG9vbAQWc3Rha2VkQW1vdW50Q2FsY3VsYXRlZAQHJG1hdGNoMAUHYXNzZXRJZAMJAAECBQckbWF0Y2gwAgpCeXRlVmVjdG9yBANhSWQFByRtYXRjaDADCQAAAgUDYUlkBQRVU0ROCQCaCAIFEnN0YWtpbmdVU0ROQWRkcmVzcwkArAICCQCsAgIJAKwCAgIMcnBkX2JhbGFuY2VfCQDYBAEFA2FJZAIBXwkApQgBBQRwb29sAwkAAAIFA2FJZAUERVVSTgkAmggCBRJzdGFraW5nRVVSTkFkZHJlc3MJAKwCAgkArAICCQCsAgICGCVzJXMlc19fc3Rha2luZ0JhbGFuY2VfXwkA2AQBBQNhSWQCAl9fCQClCAEFBHBvb2wAAAMJAAECBQckbWF0Y2gwAgRVbml0CQELdmFsdWVPckVsc2UCCQCaCAIFBHBvb2wFDmtMZWFzaW5nQW1vdW50AAAJAAIBAgtNYXRjaCBlcnJvcgQHJG1hdGNoMAUWc3Rha2VkQW1vdW50Q2FsY3VsYXRlZAMJAAECBQckbWF0Y2gwAgNJbnQEAWkFByRtYXRjaDAFAWkAAAEMZ2V0QXNzZXRJbmZvAQdhc3NldElkBAckbWF0Y2gwBQdhc3NldElkAwMJAAECBQckbWF0Y2gwAgZTdHJpbmcGCQABAgUHJG1hdGNoMAIKQnl0ZVZlY3RvcgQCaWQFByRtYXRjaDAECyR0MDM5Mzk0MTExBAckbWF0Y2gxBQJpZAMJAAECBQckbWF0Y2gxAgpCeXRlVmVjdG9yBANhSWQFByRtYXRjaDEJAJQKAgkA2AQBBQNhSWQFA2FJZAMJAAECBQckbWF0Y2gxAgZTdHJpbmcEA2FJZAUHJG1hdGNoMQkAlAoCBQNhSWQJANkEAQUDYUlkCQACAQILTWF0Y2ggZXJyb3IECHN0cmluZ0lkCAULJHQwMzkzOTQxMTECXzEEB2J5dGVzSWQIBQskdDAzOTM5NDExMQJfMgQEaW5mbwkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQDsBwEFB2J5dGVzSWQJAKwCAgkArAICAgZBc3NldCAFCHN0cmluZ0lkAg4gZG9lc24ndCBleGlzdAkAlQoDBQhzdHJpbmdJZAgFBGluZm8EbmFtZQgFBGluZm8IZGVjaW1hbHMDCQABAgUHJG1hdGNoMAIEVW5pdAQFd2F2ZXMFByRtYXRjaDAJAJUKAwIFV0FWRVMCBVdBVkVTAAgJAAIBAgtNYXRjaCBlcnJvcgEHc3VzcGVuZAEFY2F1c2UJAMwIAgkBDEJvb2xlYW5FbnRyeQIFB2tBY3RpdmUHCQDMCAIJAQtTdHJpbmdFbnRyeQIFBmtDYXVzZQUFY2F1c2UFA25pbAEUY2FsY3VsYXRlRmVlRGlzY291bnQBCHVzZXJBZGRyBApzd29wQW1vdW50CQELdmFsdWVPckVsc2UCCQCaCAIFCmdvdkFkZHJlc3MJAKwCAgkApQgBBQh1c2VyQWRkcgUOa1VzZXJTd29wSW5Hb3YAAAQLZ1N3b3BBbW91bnQJAQt2YWx1ZU9yRWxzZQIJAJoIAgUKZ292QWRkcmVzcwkArAICCQClCAEFCHVzZXJBZGRyBQ9rVXNlckdTd29wSW5Hb3YFCnN3b3BBbW91bnQEDmRpc2NvdW50VmFsdWVzCQC1CQIJARFAZXh0ck5hdGl2ZSgxMDUzKQIFBm9yYWNsZQUPa0Rpc2NvdW50VmFsdWVzAgEsBAlkaXNjb3VudHMJALUJAgkBEUBleHRyTmF0aXZlKDEwNTMpAgUGb3JhY2xlBQprRGlzY291bnRzAgEsAwMJAGcCBQtnU3dvcEFtb3VudAkBDXBhcnNlSW50VmFsdWUBCQCRAwIFDmRpc2NvdW50VmFsdWVzAAAJAGYCCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUOZGlzY291bnRWYWx1ZXMAAQULZ1N3b3BBbW91bnQHCQBlAgUJZmVlU2NhbGU2CQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUJZGlzY291bnRzAAADAwkAZwIFC2dTd29wQW1vdW50CQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUOZGlzY291bnRWYWx1ZXMAAQkAZgIJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQ5kaXNjb3VudFZhbHVlcwACBQtnU3dvcEFtb3VudAcJAGUCBQlmZWVTY2FsZTYJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQlkaXNjb3VudHMAAQMDCQBnAgULZ1N3b3BBbW91bnQJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQ5kaXNjb3VudFZhbHVlcwACCQBmAgkBDXBhcnNlSW50VmFsdWUBCQCRAwIFDmRpc2NvdW50VmFsdWVzAAMFC2dTd29wQW1vdW50BwkAZQIFCWZlZVNjYWxlNgkBDXBhcnNlSW50VmFsdWUBCQCRAwIFCWRpc2NvdW50cwACAwMJAGcCBQtnU3dvcEFtb3VudAkBDXBhcnNlSW50VmFsdWUBCQCRAwIFDmRpc2NvdW50VmFsdWVzAAMJAGYCCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUOZGlzY291bnRWYWx1ZXMABAULZ1N3b3BBbW91bnQHCQBlAgUJZmVlU2NhbGU2CQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUJZGlzY291bnRzAAMDCQBnAgULZ1N3b3BBbW91bnQJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQ5kaXNjb3VudFZhbHVlcwAECQBlAgUJZmVlU2NhbGU2CQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUJZGlzY291bnRzAAQFCWZlZVNjYWxlNgENY2FsY3VsYXRlRmVlcwYJcG10QW1vdW50Em1pbkFtb3VudFRvUmVjZWl2ZQl0b2tlbkZyb20HdG9rZW5UbwNmZWUNZmVlR292ZXJuYW5jZQQQYW1vdW50V2l0aG91dEZlZQkAawMFB3Rva2VuVG8FCXBtdEFtb3VudAkAZAIFCXBtdEFtb3VudAUJdG9rZW5Gcm9tBA1hbW91bnRXaXRoRmVlCQBrAwUQYW1vdW50V2l0aG91dEZlZQkAZQIFCWZlZVNjYWxlNgUDZmVlBQlmZWVTY2FsZTYEEGdvdmVybmFuY2VSZXdhcmQJAGsDBRBhbW91bnRXaXRob3V0RmVlBQ1mZWVHb3Zlcm5hbmNlBQlmZWVTY2FsZTYDCQBmAgUSbWluQW1vdW50VG9SZWNlaXZlBQ1hbW91bnRXaXRoRmVlCQACAQkArAICCQCsAgIJAKwCAgIdQ2FsY3VsYXRlZCBhbW91bnQgdG8gcmVjZWl2ZSAJAKQDAQUNYW1vdW50V2l0aEZlZQIgIGlzIGxlc3MgdGhhbiBzcGVjaWZpZWQgbWluaW11bSAJAKQDAQUSbWluQW1vdW50VG9SZWNlaXZlCQCVCgMFEGFtb3VudFdpdGhvdXRGZWUFDWFtb3VudFdpdGhGZWUFEGdvdmVybmFuY2VSZXdhcmQBEGNhbGN1bGF0ZVZpcnRQYXkDCXBtdEFtb3VudAdiYWxhbmNlA2ZlZQQBRgkAZQIFCWZlZVNjYWxlNgUDZmVlBAFrCQBrAwUDZmVlADwAZAQBYQkAZAIFBnNjYWxlOAkAawMJAGgCBQFGBQFrBQZzY2FsZTgJAGgCBQlmZWVTY2FsZTYFCWZlZVNjYWxlNgQBYgkAZQIJAGUCCQBkAgkAZAIFB2JhbGFuY2UJAGsDBQdiYWxhbmNlBQFGBQlmZWVTY2FsZTYJAGsDBQlwbXRBbW91bnQFAUYFCWZlZVNjYWxlNgUJcG10QW1vdW50CQBrAwUJcG10QW1vdW50CQBoAgUBRgUBawkAaAIFCWZlZVNjYWxlNgUJZmVlU2NhbGU2BAFjCQC5AgIJAL4CAQkAtgIBBQdiYWxhbmNlCQC2AgEFCXBtdEFtb3VudAQBRAkAuAICCQC5AgIJALYCAQUBYgkAtgIBBQFiCQC8AgMJALkCAgkAtgIBAAQFAWMJALYCAQUBYQkAtgIBBQZzY2FsZTgJAKADAQkAvAIDCQC3AgIJAL4CAQkAtgIBBQFiCQEKc3FydEJpZ0ludAQFAUQAAAAABQRET1dOCQC2AgEFBnNjYWxlOAkAtgIBCQBoAgACBQFhARFwYXJzZVBheW1lbnRBc3NldAEHYXNzZXRJZAMJAAACBQdhc3NldElkAQAFBHVuaXQFB2Fzc2V0SWQBEXN1c3BlbmRTdXNwaWNpb3VzBg9hY2NvdW50QmFsYW5jZUEPYWNjb3VudEJhbGFuY2VCCGJhbGFuY2VBCGJhbGFuY2VCCGFzc2V0SWRBCGFzc2V0SWRCCQEHc3VzcGVuZAEJAKwCAgkArAICCQCsAgIJAKwCAgkArAICCQCsAgIJAKwCAgkArAICCQCsAgIJAKwCAgkArAICCQCsAgIJAKwCAgkArAICCQCsAgICI1N1c3BpY2lvdXMgc3RhdGUuIEFjdHVhbCBiYWxhbmNlczogCQCkAwEFD2FjY291bnRCYWxhbmNlQQIBIAUIYXNzZXRJZEECAiwgCQCkAwEFD2FjY291bnRCYWxhbmNlQgIBIAUIYXNzZXRJZEICCS4gU3RhdGU6IAkApAMBBQhiYWxhbmNlQQIBIAUIYXNzZXRJZEECAiwgCQCkAwEFCGJhbGFuY2VCAgEgBQhhc3NldElkQgEIaXNBY3RpdmUAAwUGYWN0aXZlBQR1bml0CQACAQIfREFwcCBpcyBpbmFjdGl2ZSBhdCB0aGlzIG1vbWVudAEMaXNPcmFjbGVQb29sAQtwb29sQWRkcmVzcwMJAQlpc0RlZmluZWQBCQCdCAIFBm9yYWNsZQkArAICBQtrT3JhY2xlUG9vbAULcG9vbEFkZHJlc3MFBHVuaXQJAAIBAhtEQXBwIGlzIG5vdCByZWdpc3RlcmVkIHBvb2wBD2dldFBvb2xCYWxhbmNlcwMEcG9vbAhhc3NldElkQQhhc3NldElkQgQIYmFsYW5jZUEJARFAZXh0ck5hdGl2ZSgxMDUwKQIFBHBvb2wFCWtCYWxhbmNlQQQIYmFsYW5jZUIJARFAZXh0ck5hdGl2ZSgxMDUwKQIFBHBvb2wFCWtCYWxhbmNlQgQNc3Rha2VkQW1vdW50QQkBDHN0YWtlZEFtb3VudAIFCGFzc2V0SWRBBQRwb29sBA1zdGFrZWRBbW91bnRCCQEMc3Rha2VkQW1vdW50AgUIYXNzZXRJZEIFBHBvb2wED2FjY291bnRCYWxhbmNlQQkAZAIJAQ5hY2NvdW50QmFsYW5jZQIFCGFzc2V0SWRBBQRwb29sBQ1zdGFrZWRBbW91bnRBBA9hY2NvdW50QmFsYW5jZUIJAGQCCQEOYWNjb3VudEJhbGFuY2UCBQhhc3NldElkQgUEcG9vbAUNc3Rha2VkQW1vdW50QgQLc2hhcmVTdXBwbHkJARFAZXh0ck5hdGl2ZSgxMDUwKQIFBHBvb2wFEWtTaGFyZUFzc2V0U3VwcGx5CQCXCgUFCGJhbGFuY2VBBQhiYWxhbmNlQgUPYWNjb3VudEJhbGFuY2VBBQ9hY2NvdW50QmFsYW5jZUIFC3NoYXJlU3VwcGx5AQ1nZXRQb29sQXNzZXRzAQRwb29sBAtzdHJBc3NldElkQQkBEUBleHRyTmF0aXZlKDEwNTMpAgUEcG9vbAUJa0Fzc2V0SWRBBAtzdHJBc3NldElkQgkBEUBleHRyTmF0aXZlKDEwNTMpAgUEcG9vbAUJa0Fzc2V0SWRCBAhhc3NldElkQQMJAAACBQtzdHJBc3NldElkQQIFV0FWRVMFBHVuaXQJANkEAQULc3RyQXNzZXRJZEEECGFzc2V0SWRCAwkAAAIFC3N0ckFzc2V0SWRCAgVXQVZFUwUEdW5pdAkA2QQBBQtzdHJBc3NldElkQgQMc2hhcmVBc3NldElkCQDZBAEJARFAZXh0ck5hdGl2ZSgxMDUzKQIFBHBvb2wFDWtTaGFyZUFzc2V0SWQJAJcKBQULc3RyQXNzZXRJZEEFC3N0ckFzc2V0SWRCBQhhc3NldElkQQUIYXNzZXRJZEIFDHNoYXJlQXNzZXRJZAEMZ2V0RmVlUGFyYW1zAgRwb29sBmNhbGxlcgQLZmVlRGlzY291bnQJARRjYWxjdWxhdGVGZWVEaXNjb3VudAEFBmNhbGxlcgQDZmVlCQBuBAkBEUBleHRyTmF0aXZlKDEwNTApAgUEcG9vbAUEa0ZlZQULZmVlRGlzY291bnQFCWZlZVNjYWxlNgUHQ0VJTElORwQGZ292RmVlCQBrAwUDZmVlACgAZAkAlAoCBQNmZWUFBmdvdkZlZQkBaQEEaW5pdAQLY2FsbGVyQnl0ZXMEYXJncwhwQW1vdW50cwlwQXNzZXRJZHMEBmNhbGxlcgkBB0FkZHJlc3MBBQtjYWxsZXJCeXRlcwQLJHQwOTA3NjkxNTQJAJQKAgkAkQMCBQhwQW1vdW50cwAACQERcGFyc2VQYXltZW50QXNzZXQBCQCRAwIFCXBBc3NldElkcwAABApwbXRBbW91bnRBCAULJHQwOTA3NjkxNTQCXzEEC3BtdEFzc2V0SWRBCAULJHQwOTA3NjkxNTQCXzIECyR0MDkxNTk5MjM3CQCUCgIJAJEDAgUIcEFtb3VudHMAAQkBEXBhcnNlUGF5bWVudEFzc2V0AQkAkQMCBQlwQXNzZXRJZHMAAQQKcG10QW1vdW50QggFCyR0MDkxNTk5MjM3Al8xBAtwbXRBc3NldElkQggFCyR0MDkxNTk5MjM3Al8yAwkBASEBCQEPY29udGFpbnNFbGVtZW50AgkAzAgCBQxhZG1pblB1YktleTEJAMwIAgUMYWRtaW5QdWJLZXkyCQDMCAIFDGFkbWluUHViS2V5MwkAzAgCBRFhZG1pbkludm9rZVB1YktleQUDbmlsCAUBaRVvcmlnaW5DYWxsZXJQdWJsaWNLZXkJAAIBAiFPbmx5IGFkbWluIGNhbiBjYWxsIHRoaXMgZnVuY3Rpb24DCQECIT0CCQCQAwEFBGFyZ3MAAQkAAgECD1dyb25nIGFyZ3Mgc2l6ZQMJAQlpc0RlZmluZWQBCQCbCAIFBmNhbGxlcgUHa0FjdGl2ZQkAAgECFkRBcHAgaXMgYWxyZWFkeSBhY3RpdmUDCQAAAgULcG10QXNzZXRJZEEFC3BtdEFzc2V0SWRCCQACAQIYQXNzZXRzIG11c3QgYmUgZGlmZmVyZW50BAskdDA5NjcyOTc0OQkBDGdldEFzc2V0SW5mbwEFC3BtdEFzc2V0SWRBBA5wbXRTdHJBc3NldElkQQgFCyR0MDk2NzI5NzQ5Al8xBA1wbXRBc3NldE5hbWVBCAULJHQwOTY3Mjk3NDkCXzIEDHBtdERlY2ltYWxzQQgFCyR0MDk2NzI5NzQ5Al8zBAskdDA5NzU4OTgzNQkBDGdldEFzc2V0SW5mbwEFC3BtdEFzc2V0SWRCBA5wbXRTdHJBc3NldElkQggFCyR0MDk3NTg5ODM1Al8xBA1wbXRBc3NldE5hbWVCCAULJHQwOTc1ODk4MzUCXzIEDHBtdERlY2ltYWxzQggFCyR0MDk3NTg5ODM1Al8zBAxmaXJzdEhhcnZlc3QJAAACCQCRAwIFBGFyZ3MAAAIEdHJ1ZQQJc2hhcmVOYW1lCQCsAgIJAKwCAgkArAICAgFzCQCvAgIFDXBtdEFzc2V0TmFtZUEABwIBXwkArwICBQ1wbXRBc3NldE5hbWVCAAcEEHNoYXJlRGVzY3JpcHRpb24JAKwCAgkArAICCQCsAgIJAKwCAgkArAICAiJTaGFyZVRva2VuIG9mIFN3b3BGaSBwcm90b2NvbCBmb3IgBQ1wbXRBc3NldE5hbWVBAgUgYW5kIAUNcG10QXNzZXROYW1lQgIMIGF0IGFkZHJlc3MgCQClCAEFBHRoaXMEDXNoYXJlRGVjaW1hbHMJAGkCCQBkAgUMcG10RGVjaW1hbHNBBQxwbXREZWNpbWFsc0IAAgQEYXJnMQkAbAYFCnBtdEFtb3VudEEFDHBtdERlY2ltYWxzQQAFAAEFDHBtdERlY2ltYWxzQQUERE9XTgQEYXJnMgkAbAYFCnBtdEFtb3VudEIFDHBtdERlY2ltYWxzQgAFAAEFDHBtdERlY2ltYWxzQgUERE9XTgQEYXJnMwkAbAYACgAABQ1zaGFyZURlY2ltYWxzAAAAAAUERE9XTgQSc2hhcmVJbml0aWFsU3VwcGx5CQBrAwUEYXJnMQUEYXJnMgUEYXJnMwQKc2hhcmVJc3N1ZQkAwggFBQlzaGFyZU5hbWUFEHNoYXJlRGVzY3JpcHRpb24FEnNoYXJlSW5pdGlhbFN1cHBseQUNc2hhcmVEZWNpbWFscwYEDHNoYXJlSXNzdWVJZAkAuAgBBQpzaGFyZUlzc3VlBAZzdGFrZTEDCQEIY29udGFpbnMCBQ1zdGFraW5nQXNzZXRzBQ5wbXRTdHJBc3NldElkQQkA/AcECAUBaQZjYWxsZXICDHN0YWtlVW5zdGFrZQkAzAgCBgkAzAgCBQpwbXRBbW91bnRBCQDMCAIFDnBtdFN0ckFzc2V0SWRBBQNuaWwFA25pbAAAAwkAAAIFBnN0YWtlMQUGc3Rha2UxBAZzdGFrZTIDCQEIY29udGFpbnMCBQ1zdGFraW5nQXNzZXRzBQ5wbXRTdHJBc3NldElkQgkA/AcECAUBaQZjYWxsZXICDHN0YWtlVW5zdGFrZQkAzAgCBgkAzAgCBQpwbXRBbW91bnRCCQDMCAIFDnBtdFN0ckFzc2V0SWRCBQNuaWwFA25pbAAAAwkAAAIFBnN0YWtlMgUGc3Rha2UyBAliYXNlRW50cnkJAMwIAgkBC1N0cmluZ0VudHJ5AgUIa1ZlcnNpb24FB3ZlcnNpb24JAMwIAgkBDEJvb2xlYW5FbnRyeQIFB2tBY3RpdmUGCQDMCAIJAQtTdHJpbmdFbnRyeQIFCWtBc3NldElkQQUOcG10U3RyQXNzZXRJZEEJAMwIAgkBC1N0cmluZ0VudHJ5AgUJa0Fzc2V0SWRCBQ5wbXRTdHJBc3NldElkQgkAzAgCCQEMSW50ZWdlckVudHJ5AgUJa0JhbGFuY2VBBQpwbXRBbW91bnRBCQDMCAIJAQxJbnRlZ2VyRW50cnkCBQlrQmFsYW5jZUIFCnBtdEFtb3VudEIJAMwIAgkBDEludGVnZXJFbnRyeQIFBGtGZWUJARFAZXh0ck5hdGl2ZSgxMDUwKQIFBm9yYWNsZQINYmFzZV9mZWVfY3BtbQkAzAgCBQpzaGFyZUlzc3VlCQDMCAIJAQtTdHJpbmdFbnRyeQIFDWtTaGFyZUFzc2V0SWQJANgEAQUMc2hhcmVJc3N1ZUlkCQDMCAIJAQxJbnRlZ2VyRW50cnkCBRFrU2hhcmVBc3NldFN1cHBseQUSc2hhcmVJbml0aWFsU3VwcGx5CQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMFBmNhbGxlcgUSc2hhcmVJbml0aWFsU3VwcGx5BQxzaGFyZUlzc3VlSWQFA25pbAMFDGZpcnN0SGFydmVzdAkAlAoCBQNuaWwJAJQKAgkAzggCBQliYXNlRW50cnkJAMwIAgkBDEJvb2xlYW5FbnRyeQIFDWtGaXJzdEhhcnZlc3QFDGZpcnN0SGFydmVzdAkAzAgCCQEMSW50ZWdlckVudHJ5AgUTa0ZpcnN0SGFydmVzdEhlaWdodAkAZAIFC3N0YXJ0SGVpZ2h0CQBoAgUVZmlyc3RIYXJ2ZXN0RW5kUGVyaW9kBQxwZXJpb2RMZW5ndGgFA25pbAUDbmlsCQCUCgIFA25pbAkAlAoCBQliYXNlRW50cnkFA25pbAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgFpARFpbml0V2l0aEluaXRSYXRpbwQLY2FsbGVyQnl0ZXMEYXJncwhwQW1vdW50cwlwQXNzZXRJZHMEBmNhbGxlcgkBB0FkZHJlc3MBBQtjYWxsZXJCeXRlcwQNJHQwMTIwNTYxMjI1NgkAlwoFCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUEYXJncwAACQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUEYXJncwABCQCRAwIFBGFyZ3MAAgkAkQMCBQRhcmdzAAMJAAACCQCRAwIFBGFyZ3MABAIEdHJ1ZQQJYW10QXNzZXRBCAUNJHQwMTIwNTYxMjI1NgJfMQQJYW10QXNzZXRCCAUNJHQwMTIwNTYxMjI1NgJfMgQLYXNzZXRJZEFTdHIIBQ0kdDAxMjA1NjEyMjU2Al8zBAthc3NldElkQlN0cggFDSR0MDEyMDU2MTIyNTYCXzQEDGZpcnN0SGFydmVzdAgFDSR0MDEyMDU2MTIyNTYCXzUDCQEBIQEJAQ9jb250YWluc0VsZW1lbnQCCQDMCAIFDGFkbWluUHViS2V5MQkAzAgCBQxhZG1pblB1YktleTIJAMwIAgUMYWRtaW5QdWJLZXkzCQDMCAIFEWFkbWluSW52b2tlUHViS2V5BQNuaWwIBQFpFW9yaWdpbkNhbGxlclB1YmxpY0tleQkAAgECIU9ubHkgYWRtaW4gY2FuIGNhbGwgdGhpcyBmdW5jdGlvbgMJAQIhPQIJAJADAQUEYXJncwAFCQACAQIPV3JvbmcgYXJncyBzaXplAwkBCWlzRGVmaW5lZAEJAJsIAgUGY2FsbGVyBQdrQWN0aXZlCQACAQIWREFwcCBpcyBhbHJlYWR5IGFjdGl2ZQMJAAACBQthc3NldElkQVN0cgULYXNzZXRJZEJTdHIJAAIBAhhBc3NldHMgbXVzdCBiZSBkaWZmZXJlbnQEDSR0MDEyNjkxMTI3NjgJAQxnZXRBc3NldEluZm8BBQthc3NldElkQVN0cgQOcG10U3RyQXNzZXRJZEEIBQ0kdDAxMjY5MTEyNzY4Al8xBA1wbXRBc3NldE5hbWVBCAUNJHQwMTI2OTExMjc2OAJfMgQMcG10RGVjaW1hbHNBCAUNJHQwMTI2OTExMjc2OAJfMwQNJHQwMTI3NzcxMjg1NAkBDGdldEFzc2V0SW5mbwEFC2Fzc2V0SWRCU3RyBA5wbXRTdHJBc3NldElkQggFDSR0MDEyNzc3MTI4NTQCXzEEDXBtdEFzc2V0TmFtZUIIBQ0kdDAxMjc3NzEyODU0Al8yBAxwbXREZWNpbWFsc0IIBQ0kdDAxMjc3NzEyODU0Al8zBAlzaGFyZU5hbWUJAKwCAgkArAICCQCsAgICAXMJAK8CAgUNcG10QXNzZXROYW1lQQAHAgFfCQCvAgIFDXBtdEFzc2V0TmFtZUIABwQQc2hhcmVEZXNjcmlwdGlvbgkArAICCQCsAgIJAKwCAgkArAICCQCsAgICIlNoYXJlVG9rZW4gb2YgU3dvcEZpIHByb3RvY29sIGZvciAFDXBtdEFzc2V0TmFtZUECBSBhbmQgBQ1wbXRBc3NldE5hbWVCAgwgYXQgYWRkcmVzcyAJAKUIAQUEdGhpcwQNc2hhcmVEZWNpbWFscwkAaQIJAGQCBQxwbXREZWNpbWFsc0EFDHBtdERlY2ltYWxzQgACBBJzaGFyZUluaXRpYWxTdXBwbHkAAAQKc2hhcmVJc3N1ZQkAwggFBQlzaGFyZU5hbWUFEHNoYXJlRGVzY3JpcHRpb24FEnNoYXJlSW5pdGlhbFN1cHBseQUNc2hhcmVEZWNpbWFscwYEDHNoYXJlSXNzdWVJZAkAuAgBBQpzaGFyZUlzc3VlBAliYXNlRW50cnkJAMwIAgkBC1N0cmluZ0VudHJ5AgUIa1ZlcnNpb24FB3ZlcnNpb24JAMwIAgkBDEJvb2xlYW5FbnRyeQIFB2tBY3RpdmUGCQDMCAIJAQtTdHJpbmdFbnRyeQIFCWtBc3NldElkQQUOcG10U3RyQXNzZXRJZEEJAMwIAgkBC1N0cmluZ0VudHJ5AgUJa0Fzc2V0SWRCBQ5wbXRTdHJBc3NldElkQgkAzAgCCQEMSW50ZWdlckVudHJ5AgUNa0JhbGFuY2VJbml0QQUJYW10QXNzZXRBCQDMCAIJAQxJbnRlZ2VyRW50cnkCBQ1rQmFsYW5jZUluaXRCBQlhbXRBc3NldEIJAMwIAgkBDEludGVnZXJFbnRyeQIFCWtCYWxhbmNlQQAACQDMCAIJAQxJbnRlZ2VyRW50cnkCBQlrQmFsYW5jZUIAAAkAzAgCCQEMSW50ZWdlckVudHJ5AgUEa0ZlZQkBEUBleHRyTmF0aXZlKDEwNTApAgUGb3JhY2xlAg1iYXNlX2ZlZV9jcG1tCQDMCAIFCnNoYXJlSXNzdWUJAMwIAgkBC1N0cmluZ0VudHJ5AgUNa1NoYXJlQXNzZXRJZAkA2AQBBQxzaGFyZUlzc3VlSWQJAMwIAgkBDEludGVnZXJFbnRyeQIFEWtTaGFyZUFzc2V0U3VwcGx5BRJzaGFyZUluaXRpYWxTdXBwbHkFA25pbAMFDGZpcnN0SGFydmVzdAkAlAoCBQNuaWwJAJQKAgkAzggCBQliYXNlRW50cnkJAMwIAgkBDEJvb2xlYW5FbnRyeQIFDWtGaXJzdEhhcnZlc3QFDGZpcnN0SGFydmVzdAkAzAgCCQEMSW50ZWdlckVudHJ5AgUTa0ZpcnN0SGFydmVzdEhlaWdodAkAZAIFC3N0YXJ0SGVpZ2h0CQBoAgUVZmlyc3RIYXJ2ZXN0RW5kUGVyaW9kBQxwZXJpb2RMZW5ndGgFA25pbAUDbmlsCQCUCgIFA25pbAkAlAoCBQliYXNlRW50cnkFA25pbAFpARhrZWVwTGltaXRGb3JGaXJzdEhhcnZlc3QEC2NhbGxlckJ5dGVzBGFyZ3MIcEFtb3VudHMJcEFzc2V0SWRzCQELdmFsdWVPckVsc2UCCQEMaXNPcmFjbGVQb29sAQkApQgBCAUBaQZjYWxsZXIJAQt2YWx1ZU9yRWxzZQIJAQhpc0FjdGl2ZQADCQEBIQEJAQ9jb250YWluc0VsZW1lbnQCCQDMCAIFDGFkbWluUHViS2V5MQkAzAgCBQxhZG1pblB1YktleTIJAMwIAgUMYWRtaW5QdWJLZXkzCQDMCAIFEWFkbWluSW52b2tlUHViS2V5BQNuaWwIBQFpFW9yaWdpbkNhbGxlclB1YmxpY0tleQkAAgECIU9ubHkgYWRtaW4gY2FuIGNhbGwgdGhpcyBmdW5jdGlvbgMJAQIhPQIJAJADAQUEYXJncwABCQACAQIPV3JvbmcgYXJncyBzaXplBApzaGFyZUxpbWl0CQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUEYXJncwAACQCUCgIFA25pbAkAlAoCCQDMCAIJAQxJbnRlZ2VyRW50cnkCBQtrU2hhcmVMaW1pdAUKc2hhcmVMaW1pdAUDbmlsBQNuaWwBaQEIZXhjaGFuZ2UEC2NhbGxlckJ5dGVzBGFyZ3MIcEFtb3VudHMJcEFzc2V0SWRzCQELdmFsdWVPckVsc2UCCQEMaXNPcmFjbGVQb29sAQkApQgBCAUBaQZjYWxsZXIJAQt2YWx1ZU9yRWxzZQIJAQhpc0FjdGl2ZQAEBmNhbGxlcgkBB0FkZHJlc3MBBQtjYWxsZXJCeXRlcwQNJHQwMTUyNDAxNTMxNgkAlAoCCQCRAwIFCHBBbW91bnRzAAAJARFwYXJzZVBheW1lbnRBc3NldAEJAJEDAgUJcEFzc2V0SWRzAAAECXBtdEFtb3VudAgFDSR0MDE1MjQwMTUzMTYCXzEECnBtdEFzc2V0SWQIBQ0kdDAxNTI0MDE1MzE2Al8yBBJtaW5BbW91bnRUb1JlY2VpdmUJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQRhcmdzAAAEDSR0MDE1Mzg5MTU0NjUJAQ1nZXRQb29sQXNzZXRzAQgFAWkGY2FsbGVyBAtzdHJBc3NldElkQQgFDSR0MDE1Mzg5MTU0NjUCXzEEC3N0ckFzc2V0SWRCCAUNJHQwMTUzODkxNTQ2NQJfMgQIYXNzZXRJZEEIBQ0kdDAxNTM4OTE1NDY1Al8zBAhhc3NldElkQggFDSR0MDE1Mzg5MTU0NjUCXzQEDSR0MDE1NDc4MTU1ODQJAQ9nZXRQb29sQmFsYW5jZXMDCAUBaQZjYWxsZXIFCGFzc2V0SWRBBQhhc3NldElkQgQIYmFsYW5jZUEIBQ0kdDAxNTQ3ODE1NTg0Al8xBAhiYWxhbmNlQggFDSR0MDE1NDc4MTU1ODQCXzIED2FjY291bnRCYWxhbmNlQQgFDSR0MDE1NDc4MTU1ODQCXzMED2FjY291bnRCYWxhbmNlQggFDSR0MDE1NDc4MTU1ODQCXzQDCQECIT0CCQCQAwEFBGFyZ3MAAQkAAgECD1dyb25nIGFyZ3Mgc2l6ZQMDCQAAAgUIYmFsYW5jZUEAAAYJAAACBQhiYWxhbmNlQgAACQACAQIgQ2FuJ3QgZXhjaGFuZ2Ugd2l0aCB6ZXJvIGJhbGFuY2UDCQBnAgAABRJtaW5BbW91bnRUb1JlY2VpdmUJAAIBCQCsAgICNE1pbmltYWwgYW1vdW50IHRvIHJlY2VpdmUgbXVzdCBiZSBwb3NpdGl2ZS4gQWN0dWFsOiAJAKQDAQUSbWluQW1vdW50VG9SZWNlaXZlAwkBAiE9AgkAkAMBBQhwQW1vdW50cwABCQACAQIdT25lIGF0dGFjaGVkIHBheW1lbnQgZXhwZWN0ZWQDCQEBIQEJAQ9jb250YWluc0VsZW1lbnQCCQDMCAIFCGFzc2V0SWRBCQDMCAIFCGFzc2V0SWRCBQNuaWwFCnBtdEFzc2V0SWQJAAIBCQCsAgIJAKwCAgkArAICAiRJbmNvcnJlY3QgYXNzZXQgYXR0YWNoZWQuIEV4cGVjdGVkOiAFC3N0ckFzc2V0SWRBAgQgb3IgBQtzdHJBc3NldElkQgMDCQBmAgUIYmFsYW5jZUEFD2FjY291bnRCYWxhbmNlQQYJAGYCBQhiYWxhbmNlQgUPYWNjb3VudEJhbGFuY2VCCQCUCgIFA25pbAkAzggCCQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMFBmNhbGxlcgUJcG10QW1vdW50BQpwbXRBc3NldElkBQNuaWwJARFzdXNwZW5kU3VzcGljaW91cwYFD2FjY291bnRCYWxhbmNlQQUPYWNjb3VudEJhbGFuY2VCBQhiYWxhbmNlQQUIYmFsYW5jZUIFC3N0ckFzc2V0SWRBBQtzdHJBc3NldElkQgQNJHQwMTY1NTIxNjYxMAkBDGdldEZlZVBhcmFtcwIIBQFpBmNhbGxlcggFAWkMb3JpZ2luQ2FsbGVyBANmZWUIBQ0kdDAxNjU1MjE2NjEwAl8xBAZnb3ZGZWUIBQ0kdDAxNjU1MjE2NjEwAl8yBA0kdDAxNjYyNzE2OTY0AwkAAAIFCnBtdEFzc2V0SWQFCGFzc2V0SWRBCQENY2FsY3VsYXRlRmVlcwYFCXBtdEFtb3VudAUSbWluQW1vdW50VG9SZWNlaXZlBQhiYWxhbmNlQQUIYmFsYW5jZUIFA2ZlZQUGZ292RmVlCQENY2FsY3VsYXRlRmVlcwYFCXBtdEFtb3VudAUSbWluQW1vdW50VG9SZWNlaXZlBQhiYWxhbmNlQgUIYmFsYW5jZUEFA2ZlZQUGZ292RmVlBBBhbW91bnRXaXRob3V0RmVlCAUNJHQwMTY2MjcxNjk2NAJfMQQNYW1vdW50V2l0aEZlZQgFDSR0MDE2NjI3MTY5NjQCXzIEEGdvdmVybmFuY2VSZXdhcmQIBQ0kdDAxNjYyNzE2OTY0Al8zBA0kdDAxNjk4MjE3MzA3AwkAAAIFCnBtdEFzc2V0SWQFCGFzc2V0SWRBCQCVCgMJAGQCBQhiYWxhbmNlQQUJcG10QW1vdW50CQBlAgkAZQIFCGJhbGFuY2VCBQ1hbW91bnRXaXRoRmVlBRBnb3Zlcm5hbmNlUmV3YXJkBQhhc3NldElkQgkAlQoDCQBlAgkAZQIFCGJhbGFuY2VBBQ1hbW91bnRXaXRoRmVlBRBnb3Zlcm5hbmNlUmV3YXJkCQBkAgUIYmFsYW5jZUIFCXBtdEFtb3VudAUIYXNzZXRJZEEEC25ld0JhbGFuY2VBCAUNJHQwMTY5ODIxNzMwNwJfMQQLbmV3QmFsYW5jZUIIBQ0kdDAxNjk4MjE3MzA3Al8yBAthc3NldElkU2VuZAgFDSR0MDE2OTgyMTczMDcCXzMEDSR0MDE3MzI1MTc1NzUDCQAAAgUKcG10QXNzZXRJZAUIYXNzZXRJZEEJAJQKAgUJcG10QW1vdW50CQBkAgUNYW1vdW50V2l0aEZlZQUQZ292ZXJuYW5jZVJld2FyZAkAlAoCCQBkAgUNYW1vdW50V2l0aEZlZQUQZ292ZXJuYW5jZVJld2FyZAUJcG10QW1vdW50BAxzdGFrZUFtb3VudEEIBQ0kdDAxNzMyNTE3NTc1Al8xBAxzdGFrZUFtb3VudEIIBQ0kdDAxNzMyNTE3NTc1Al8yBAZzdGFrZTEDCQEIY29udGFpbnMCBQ1zdGFraW5nQXNzZXRzBQtzdHJBc3NldElkQQkA/AcECAUBaQZjYWxsZXICDHN0YWtlVW5zdGFrZQkAzAgCCQAAAgUKcG10QXNzZXRJZAUIYXNzZXRJZEEJAMwIAgUMc3Rha2VBbW91bnRBCQDMCAIFC3N0ckFzc2V0SWRBBQNuaWwFA25pbAAAAwkAAAIFBnN0YWtlMQUGc3Rha2UxBAZzdGFrZTIDCQEIY29udGFpbnMCBQ1zdGFraW5nQXNzZXRzBQtzdHJBc3NldElkQgkA/AcECAUBaQZjYWxsZXICDHN0YWtlVW5zdGFrZQkAzAgCCQAAAgUKcG10QXNzZXRJZAUIYXNzZXRJZEIJAMwIAgUMc3Rha2VBbW91bnRCCQDMCAIFC3N0ckFzc2V0SWRCBQNuaWwFA25pbAAAAwkAAAIFBnN0YWtlMgUGc3Rha2UyCQCUCgIFA25pbAkAlAoCCQDMCAIJAQxJbnRlZ2VyRW50cnkCBQlrQmFsYW5jZUEFC25ld0JhbGFuY2VBCQDMCAIJAQxJbnRlZ2VyRW50cnkCBQlrQmFsYW5jZUIFC25ld0JhbGFuY2VCCQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMFBmNhbGxlcgUNYW1vdW50V2l0aEZlZQULYXNzZXRJZFNlbmQJAMwIAgkBDlNjcmlwdFRyYW5zZmVyAwUPbW9uZXlCb3hBZGRyZXNzBRBnb3Zlcm5hbmNlUmV3YXJkBQthc3NldElkU2VuZAUDbmlsCQDMCAIFDWFtb3VudFdpdGhGZWUJAMwIAgULYXNzZXRJZFNlbmQFA25pbAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgFpARZyZXBsZW5pc2hXaXRoVHdvVG9rZW5zBAtjYWxsZXJCeXRlcwRhcmdzCHBBbW91bnRzCXBBc3NldElkcwkBC3ZhbHVlT3JFbHNlAgkBDGlzT3JhY2xlUG9vbAEJAKUIAQgFAWkGY2FsbGVyCQELdmFsdWVPckVsc2UCCQEIaXNBY3RpdmUABAZjYWxsZXIJAQdBZGRyZXNzAQULY2FsbGVyQnl0ZXMEC3BtdEFzc2V0SWRBCQERcGFyc2VQYXltZW50QXNzZXQBCQCRAwIFCXBBc3NldElkcwAABAtwbXRBc3NldElkQgkBEXBhcnNlUGF5bWVudEFzc2V0AQkAkQMCBQlwQXNzZXRJZHMAAQQMc3Rha2VGYXJtaW5nCQAAAgkAkQMCBQRhcmdzAAACBHRydWUECGxvY2tUeXBlCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUEYXJncwABBA0kdDAxODgzODE4OTI4CQENZ2V0UG9vbEFzc2V0cwEIBQFpBmNhbGxlcgQLc3RyQXNzZXRJZEEIBQ0kdDAxODgzODE4OTI4Al8xBAtzdHJBc3NldElkQggFDSR0MDE4ODM4MTg5MjgCXzIECGFzc2V0SWRBCAUNJHQwMTg4MzgxODkyOAJfMwQIYXNzZXRJZEIIBQ0kdDAxODgzODE4OTI4Al80BAxzaGFyZUFzc2V0SWQIBQ0kdDAxODgzODE4OTI4Al81BA0kdDAxODk0MTE5MDY1CQEPZ2V0UG9vbEJhbGFuY2VzAwgFAWkGY2FsbGVyBQhhc3NldElkQQUIYXNzZXRJZEIECGJhbGFuY2VBCAUNJHQwMTg5NDExOTA2NQJfMQQIYmFsYW5jZUIIBQ0kdDAxODk0MTE5MDY1Al8yBA9hY2NvdW50QmFsYW5jZUEIBQ0kdDAxODk0MTE5MDY1Al8zBA9hY2NvdW50QmFsYW5jZUIIBQ0kdDAxODk0MTE5MDY1Al80BBBzaGFyZUFzc2V0U3VwcGx5CAUNJHQwMTg5NDExOTA2NQJfNQMJAQIhPQIJAJADAQUEYXJncwACCQACAQIPV3JvbmcgYXJncyBzaXplAwMJAQIhPQIJAJADAQUIcEFtb3VudHMAAgkBAiE9AgkAkAMBBQhwQW1vdW50cwADBwkAAgECHlR3byBvciB0aHJlZSBwYXltZW50cyBleHBlY3RlZAMDCQECIT0CBQtwbXRBc3NldElkQQUIYXNzZXRJZEEGCQECIT0CBQtwbXRBc3NldElkQgUIYXNzZXRJZEIJAAIBCQCsAgIJAKwCAgkArAICAiVJbmNvcnJlY3QgYXNzZXRzIGF0dGFjaGVkLiBFeHBlY3RlZDogBQtzdHJBc3NldElkQQIFIGFuZCAFC3N0ckFzc2V0SWRCAwMJAGYCBQhiYWxhbmNlQQUPYWNjb3VudEJhbGFuY2VBBgkAZgIFCGJhbGFuY2VCBQ9hY2NvdW50QmFsYW5jZUIJAJQKAgUDbmlsCQDOCAIJAMwIAgkBDlNjcmlwdFRyYW5zZmVyAwUGY2FsbGVyCQCRAwIFCHBBbW91bnRzAAAFC3BtdEFzc2V0SWRBCQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMFBmNhbGxlcgkAkQMCBQhwQW1vdW50cwABBQtwbXRBc3NldElkQgUDbmlsAwkAAAIJAJADAQUIcEFtb3VudHMAAwkAzAgCCQEPQXR0YWNoZWRQYXltZW50AgMJAAACCQCRAwIFCXBBc3NldElkcwACAQAFBHVuaXQJAJEDAgUJcEFzc2V0SWRzAAIJAJEDAgUIcEFtb3VudHMAAgUDbmlsCQDOCAIFA25pbAkBEXN1c3BlbmRTdXNwaWNpb3VzBgUPYWNjb3VudEJhbGFuY2VBBQ9hY2NvdW50QmFsYW5jZUIFCGJhbGFuY2VBBQhiYWxhbmNlQgULc3RyQXNzZXRJZEEFC3N0ckFzc2V0SWRCBA0kdDAyMDA2NjIwMTQzCQEMZ2V0QXNzZXRJbmZvAQULcG10QXNzZXRJZEEEDnBtdFN0ckFzc2V0SWRBCAUNJHQwMjAwNjYyMDE0MwJfMQQNcG10QXNzZXROYW1lQQgFDSR0MDIwMDY2MjAxNDMCXzIEDHBtdERlY2ltYWxzQQgFDSR0MDIwMDY2MjAxNDMCXzMEDSR0MDIwMTYwMjAyMzcJAQxnZXRBc3NldEluZm8BBQtwbXRBc3NldElkQgQOcG10U3RyQXNzZXRJZEIIBQ0kdDAyMDE2MDIwMjM3Al8xBA1wbXRBc3NldE5hbWVCCAUNJHQwMjAxNjAyMDIzNwJfMgQMcG10RGVjaW1hbHNCCAUNJHQwMjAxNjAyMDIzNwJfMwQHaW5pdGlhbAkAAAIJAGQCBQhiYWxhbmNlQQUIYmFsYW5jZUIAAAQNJHQwMjAzMTIyMTIxMgMFB2luaXRpYWwJAJcKBQkAkQMCBQhwQW1vdW50cwAACQCRAwIFCHBBbW91bnRzAAEAAAULcG10QXNzZXRJZEEJALYCAQABBBNyYXRpb1NoYXJlVG9rZW5zSW5BCQC8AgMFB3NjYWxlMTYJALYCAQkAkQMCBQhwQW1vdW50cwAACQC2AgEFCGJhbGFuY2VBBBNyYXRpb1NoYXJlVG9rZW5zSW5CCQC8AgMFB3NjYWxlMTYJALYCAQkAkQMCBQhwQW1vdW50cwABCQC2AgEFCGJhbGFuY2VCAwkAvwICBRNyYXRpb1NoYXJlVG9rZW5zSW5CBRNyYXRpb1NoYXJlVG9rZW5zSW5BBANwbXQJAGsDCQCRAwIFCHBBbW91bnRzAAAFCGJhbGFuY2VCBQhiYWxhbmNlQQkAlwoFCQCRAwIFCHBBbW91bnRzAAAFA3BtdAkAZQIJAJEDAgUIcEFtb3VudHMAAQUDcG10BQtwbXRBc3NldElkQgUTcmF0aW9TaGFyZVRva2Vuc0luQQQDcG10CQBrAwkAkQMCBQhwQW1vdW50cwABBQhiYWxhbmNlQQUIYmFsYW5jZUIJAJcKBQUDcG10CQCRAwIFCHBBbW91bnRzAAEJAGUCCQCRAwIFCHBBbW91bnRzAAAFA3BtdAULcG10QXNzZXRJZEEFE3JhdGlvU2hhcmVUb2tlbnNJbkIECnBtdEFtb3VudEEIBQ0kdDAyMDMxMjIxMjEyAl8xBApwbXRBbW91bnRCCAUNJHQwMjAzMTIyMTIxMgJfMgQGY2hhbmdlCAUNJHQwMjAzMTIyMTIxMgJfMwQNY2hhbmdlQXNzZXRJZAgFDSR0MDIwMzEyMjEyMTICXzQED3NoYXJlVG9rZW5SYXRpbwgFDSR0MDIwMzEyMjEyMTICXzUEFXNoYXJlVG9rZW5Ub1BheUFtb3VudAMFB2luaXRpYWwEDXNoYXJlRGVjaW1hbHMJAGkCCQBkAgUMcG10RGVjaW1hbHNBBQxwbXREZWNpbWFsc0IAAgkAawMJAGwGBQpwbXRBbW91bnRBBQxwbXREZWNpbWFsc0EABQABBQxwbXREZWNpbWFsc0EFBERPV04JAGwGBQpwbXRBbW91bnRCBQxwbXREZWNpbWFsc0IABQABBQxwbXREZWNpbWFsc0IFBERPV04JAGwGAAoAAAUNc2hhcmVEZWNpbWFscwAAAAAFBERPV04JAKADAQkAvAIDBQ9zaGFyZVRva2VuUmF0aW8JALYCAQUQc2hhcmVBc3NldFN1cHBseQUHc2NhbGUxNgMJAAACBRVzaGFyZVRva2VuVG9QYXlBbW91bnQAAAkAAgECHVRvbyBzbWFsbCBhbW91bnQgdG8gcmVwbGVuaXNoAwkAZgIAAAUGY2hhbmdlCQACAQIKQ2hhbmdlIDwgMAQGc3Rha2UxAwkBCGNvbnRhaW5zAgUNc3Rha2luZ0Fzc2V0cwUOcG10U3RyQXNzZXRJZEEJAPwHBAgFAWkGY2FsbGVyAgxzdGFrZVVuc3Rha2UJAMwIAgYJAMwIAgUKcG10QW1vdW50QQkAzAgCBQ5wbXRTdHJBc3NldElkQQUDbmlsBQNuaWwAAAMJAAACBQZzdGFrZTEFBnN0YWtlMQQGc3Rha2UyAwkBCGNvbnRhaW5zAgUNc3Rha2luZ0Fzc2V0cwUOcG10U3RyQXNzZXRJZEIJAPwHBAgFAWkGY2FsbGVyAgxzdGFrZVVuc3Rha2UJAMwIAgYJAMwIAgUKcG10QW1vdW50QgkAzAgCBQ5wbXRTdHJBc3NldElkQgUDbmlsBQNuaWwAAAMJAAACBQZzdGFrZTIFBnN0YWtlMgQMc2hhcmVUb2tlblNUAwUMc3Rha2VGYXJtaW5nBApzdFBheW1lbnRzCQDOCAIJAMwIAgkBD0F0dGFjaGVkUGF5bWVudAIFDHNoYXJlQXNzZXRJZAUVc2hhcmVUb2tlblRvUGF5QW1vdW50BQNuaWwDCQAAAgkAkAMBBQhwQW1vdW50cwADCQDMCAIJAQ9BdHRhY2hlZFBheW1lbnQCAwkAAAIJAJEDAgUJcEFzc2V0SWRzAAIBAAUEdW5pdAkAkQMCBQlwQXNzZXRJZHMAAgkAkQMCBQhwQW1vdW50cwACBQNuaWwFA25pbAQHcmVpc3N1ZQkA/AcECAUBaQZjYWxsZXICEXJlaXNzdWVTaGFyZVRva2VuCQDMCAIFFXNoYXJlVG9rZW5Ub1BheUFtb3VudAUDbmlsBQNuaWwDCQAAAgUHcmVpc3N1ZQUHcmVpc3N1ZQQGc3Rha2UzCQD8BwQFDmZhcm1pbmdBZGRyZXNzAhdsb2NrU2hhcmVUb2tlbnNGcm9tUG9vbAkAzAgCBQtjYWxsZXJCeXRlcwkAzAgCCQClCAEIBQFpBmNhbGxlcgkAzAgCBQhsb2NrVHlwZQUDbmlsBQpzdFBheW1lbnRzAwkAAAIFBnN0YWtlMwUGc3Rha2UzBQNuaWwJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAMwIAgkBB1JlaXNzdWUDBQxzaGFyZUFzc2V0SWQFFXNoYXJlVG9rZW5Ub1BheUFtb3VudAYJAMwIAgkBDlNjcmlwdFRyYW5zZmVyAwUGY2FsbGVyBRVzaGFyZVRva2VuVG9QYXlBbW91bnQFDHNoYXJlQXNzZXRJZAUDbmlsCQCUCgIFA25pbAkAlAoCCQDOCAIJAMwIAgkBDEludGVnZXJFbnRyeQIFCWtCYWxhbmNlQQkAZAIFCGJhbGFuY2VBBQpwbXRBbW91bnRBCQDMCAIJAQxJbnRlZ2VyRW50cnkCBQlrQmFsYW5jZUIJAGQCBQhiYWxhbmNlQgUKcG10QW1vdW50QgkAzAgCCQEMSW50ZWdlckVudHJ5AgURa1NoYXJlQXNzZXRTdXBwbHkJAGQCBRBzaGFyZUFzc2V0U3VwcGx5BRVzaGFyZVRva2VuVG9QYXlBbW91bnQJAMwIAgkBDlNjcmlwdFRyYW5zZmVyAwUGY2FsbGVyBQZjaGFuZ2UFDWNoYW5nZUFzc2V0SWQFA25pbAUMc2hhcmVUb2tlblNUBQNuaWwJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BaQEVcmVwbGVuaXNoV2l0aE9uZVRva2VuBAtjYWxsZXJCeXRlcwRhcmdzCHBBbW91bnRzCXBBc3NldElkcwkBC3ZhbHVlT3JFbHNlAgkBDGlzT3JhY2xlUG9vbAEJAKUIAQgFAWkGY2FsbGVyCQELdmFsdWVPckVsc2UCCQEIaXNBY3RpdmUABAZjYWxsZXIJAQdBZGRyZXNzAQULY2FsbGVyQnl0ZXMECnBtdEFzc2V0SWQJARFwYXJzZVBheW1lbnRBc3NldAEJAJEDAgUJcEFzc2V0SWRzAAAECXBtdEFtb3VudAkAkQMCBQhwQW1vdW50cwAABBB2aXJ0R2V0TWluQW1vdW50CQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUEYXJncwAABAxzdGFrZUZhcm1pbmcJAAACCQCRAwIFBGFyZ3MAAQIEdHJ1ZQQIbG9ja1R5cGUJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQRhcmdzAAIEDSR0MDI0MTM4MjQyMjgJAQ1nZXRQb29sQXNzZXRzAQgFAWkGY2FsbGVyBAtzdHJBc3NldElkQQgFDSR0MDI0MTM4MjQyMjgCXzEEC3N0ckFzc2V0SWRCCAUNJHQwMjQxMzgyNDIyOAJfMgQIYXNzZXRJZEEIBQ0kdDAyNDEzODI0MjI4Al8zBAhhc3NldElkQggFDSR0MDI0MTM4MjQyMjgCXzQEDHNoYXJlQXNzZXRJZAgFDSR0MDI0MTM4MjQyMjgCXzUEDSR0MDI0MjQxMjQzNjUJAQ9nZXRQb29sQmFsYW5jZXMDCAUBaQZjYWxsZXIFCGFzc2V0SWRBBQhhc3NldElkQgQIYmFsYW5jZUEIBQ0kdDAyNDI0MTI0MzY1Al8xBAhiYWxhbmNlQggFDSR0MDI0MjQxMjQzNjUCXzIED2FjY291bnRCYWxhbmNlQQgFDSR0MDI0MjQxMjQzNjUCXzMED2FjY291bnRCYWxhbmNlQggFDSR0MDI0MjQxMjQzNjUCXzQEEHNoYXJlQXNzZXRTdXBwbHkIBQ0kdDAyNDI0MTI0MzY1Al81BAdpbml0aWFsCQAAAgkAZAIFCGJhbGFuY2VBBQhiYWxhbmNlQgAAAwkBAiE9AgkAkAMBBQRhcmdzAAMJAAIBAg9Xcm9uZyBhcmdzIHNpemUDAwkBAiE9AgkAkAMBBQhwQW1vdW50cwABCQECIT0CCQCQAwEFCHBBbW91bnRzAAIHCQACAQIjVHdvIG9yIG9uZSBhdHRhY2hlZCBhc3NldHMgZXhwZWN0ZWQDAwkBAiE9AgUKcG10QXNzZXRJZAUIYXNzZXRJZEEJAQIhPQIFCnBtdEFzc2V0SWQFCGFzc2V0SWRCBwkAAgEJAKwCAgkArAICCQCsAgICJEluY29ycmVjdCBhc3NldCBhdHRhY2hlZC4gRXhwZWN0ZWQ6IAULc3RyQXNzZXRJZEECBCBvciAFC3N0ckFzc2V0SWRCAwUHaW5pdGlhbAkAAgECMEZvciBpbml0aWFsIGV4Y2hhbmdlciB5b3UgbmVlZCB0byB1c2UgdHdvIHRva2VucwMDCQBmAgUIYmFsYW5jZUEFD2FjY291bnRCYWxhbmNlQQYJAGYCBQhiYWxhbmNlQgUPYWNjb3VudEJhbGFuY2VCCQCUCgIFA25pbAkAzggCCQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMFBmNhbGxlcgUJcG10QW1vdW50BQpwbXRBc3NldElkBQNuaWwDCQAAAgkAkAMBBQhwQW1vdW50cwACCQDMCAIJAQ9BdHRhY2hlZFBheW1lbnQCAwkAAAIJAJEDAgUJcEFzc2V0SWRzAAIBAAUEdW5pdAkAkQMCBQlwQXNzZXRJZHMAAgkAkQMCBQhwQW1vdW50cwACBQNuaWwJAM4IAgUDbmlsCQERc3VzcGVuZFN1c3BpY2lvdXMGBQ9hY2NvdW50QmFsYW5jZUEFD2FjY291bnRCYWxhbmNlQgUIYmFsYW5jZUEFCGJhbGFuY2VCBQtzdHJBc3NldElkQQULc3RyQXNzZXRJZEIEDSR0MDI1NDIxMjU0NzkJAQxnZXRGZWVQYXJhbXMCCAUBaQZjYWxsZXIIBQFpDG9yaWdpbkNhbGxlcgQDZmVlCAUNJHQwMjU0MjEyNTQ3OQJfMQQGZ292RmVlCAUNJHQwMjU0MjEyNTQ3OQJfMgQNJHQwMjU0OTYyNzgzNAMJAAACBQpwbXRBc3NldElkBQhhc3NldElkQQQNdmlydFBheUFtb3VudAkBEGNhbGN1bGF0ZVZpcnRQYXkDBQlwbXRBbW91bnQFCGJhbGFuY2VBBQNmZWUEDSR0MDI1Nzc1MjU5MTIJAQ1jYWxjdWxhdGVGZWVzBgUNdmlydFBheUFtb3VudAUQdmlydEdldE1pbkFtb3VudAUIYmFsYW5jZUEFCGJhbGFuY2VCBQNmZWUFBmdvdkZlZQQQYW1vdW50V2l0aG91dEZlZQgFDSR0MDI1Nzc1MjU5MTICXzEEDWFtb3VudFdpdGhGZWUIBQ0kdDAyNTc3NTI1OTEyAl8yBBBnb3Zlcm5hbmNlUmV3YXJkCAUNJHQwMjU3NzUyNTkxMgJfMwQMYmFsYW5jZUFWaXJ0CQBkAgUIYmFsYW5jZUEFDXZpcnRQYXlBbW91bnQEDGJhbGFuY2VCVmlydAkAZQIJAGQCBQhiYWxhbmNlQgUQYW1vdW50V2l0aG91dEZlZQUQZ292ZXJuYW5jZVJld2FyZAQLbmV3QmFsYW5jZUEJAGQCBQhiYWxhbmNlQQUJcG10QW1vdW50BAtuZXdCYWxhbmNlQgkAZQIFCGJhbGFuY2VCBRBnb3Zlcm5hbmNlUmV3YXJkBBNyYXRpb1NoYXJlVG9rZW5zSW5BCQC8AgMJALYCAQkAZQIFCXBtdEFtb3VudAUNdmlydFBheUFtb3VudAUHc2NhbGUxNgkAtgIBBQxiYWxhbmNlQVZpcnQEE3JhdGlvU2hhcmVUb2tlbnNJbkIJALwCAwkAtgIBBQ1hbW91bnRXaXRoRmVlBQdzY2FsZTE2CQC2AgEFDGJhbGFuY2VCVmlydAQVc2hhcmVUb2tlblRvUGF5QW1vdW50CQCgAwEJALwCAwkAmQMBCQDMCAIFE3JhdGlvU2hhcmVUb2tlbnNJbkEJAMwIAgUTcmF0aW9TaGFyZVRva2Vuc0luQgUDbmlsCQC2AgEFEHNoYXJlQXNzZXRTdXBwbHkFB3NjYWxlMTYJAJkKBwULbmV3QmFsYW5jZUEFC25ld0JhbGFuY2VCBRVzaGFyZVRva2VuVG9QYXlBbW91bnQFEGdvdmVybmFuY2VSZXdhcmQFCGFzc2V0SWRCBQtzdHJBc3NldElkQgULc3RyQXNzZXRJZEEEDXZpcnRQYXlBbW91bnQJARBjYWxjdWxhdGVWaXJ0UGF5AwUJcG10QW1vdW50BQhiYWxhbmNlQgUDZmVlBA0kdDAyNjg3MzI3MDEwCQENY2FsY3VsYXRlRmVlcwYFDXZpcnRQYXlBbW91bnQFEHZpcnRHZXRNaW5BbW91bnQFCGJhbGFuY2VCBQhiYWxhbmNlQQUDZmVlBQZnb3ZGZWUEEGFtb3VudFdpdGhvdXRGZWUIBQ0kdDAyNjg3MzI3MDEwAl8xBA1hbW91bnRXaXRoRmVlCAUNJHQwMjY4NzMyNzAxMAJfMgQQZ292ZXJuYW5jZVJld2FyZAgFDSR0MDI2ODczMjcwMTACXzMEDGJhbGFuY2VBVmlydAkAZQIJAGQCBQhiYWxhbmNlQQUQYW1vdW50V2l0aG91dEZlZQUQZ292ZXJuYW5jZVJld2FyZAQMYmFsYW5jZUJWaXJ0CQBkAgUIYmFsYW5jZUIFDXZpcnRQYXlBbW91bnQEC25ld0JhbGFuY2VBCQBlAgUIYmFsYW5jZUEFEGdvdmVybmFuY2VSZXdhcmQEC25ld0JhbGFuY2VCCQBkAgUIYmFsYW5jZUIFCXBtdEFtb3VudAQTcmF0aW9TaGFyZVRva2Vuc0luQQkAvAIDCQC2AgEFDWFtb3VudFdpdGhGZWUFB3NjYWxlMTYJALYCAQUMYmFsYW5jZUFWaXJ0BBNyYXRpb1NoYXJlVG9rZW5zSW5CCQC8AgMJALYCAQkAZQIFCXBtdEFtb3VudAUNdmlydFBheUFtb3VudAUHc2NhbGUxNgkAtgIBBQxiYWxhbmNlQlZpcnQEFXNoYXJlVG9rZW5Ub1BheUFtb3VudAkAoAMBCQC8AgMJAJkDAQkAzAgCBRNyYXRpb1NoYXJlVG9rZW5zSW5BCQDMCAIFE3JhdGlvU2hhcmVUb2tlbnNJbkIFA25pbAkAtgIBBRBzaGFyZUFzc2V0U3VwcGx5BQdzY2FsZTE2CQCZCgcFC25ld0JhbGFuY2VBBQtuZXdCYWxhbmNlQgUVc2hhcmVUb2tlblRvUGF5QW1vdW50BRBnb3Zlcm5hbmNlUmV3YXJkBQhhc3NldElkQQULc3RyQXNzZXRJZEEFC3N0ckFzc2V0SWRCBAtuZXdCYWxhbmNlQQgFDSR0MDI1NDk2Mjc4MzQCXzEEC25ld0JhbGFuY2VCCAUNJHQwMjU0OTYyNzgzNAJfMgQVc2hhcmVUb2tlblRvUGF5QW1vdW50CAUNJHQwMjU0OTYyNzgzNAJfMwQJZ292UmV3YXJkCAUNJHQwMjU0OTYyNzgzNAJfNAQOZ292UmV3YXJkQXNzZXQIBQ0kdDAyNTQ5NjI3ODM0Al81BBFnb3ZSZXdhcmRBc3NldFN0cggFDSR0MDI1NDk2Mjc4MzQCXzYEDXBtdEFzc2V0SWRTdHIIBQ0kdDAyNTQ5NjI3ODM0Al83AwkAAAIFFXNoYXJlVG9rZW5Ub1BheUFtb3VudAAACQACAQIdVG9vIHNtYWxsIGFtb3VudCB0byByZXBsZW5pc2gEBnN0YWtlMQMJAQhjb250YWlucwIFDXN0YWtpbmdBc3NldHMFDXBtdEFzc2V0SWRTdHIJAPwHBAgFAWkGY2FsbGVyAgxzdGFrZVVuc3Rha2UJAMwIAgYJAMwIAgUJcG10QW1vdW50CQDMCAIFDXBtdEFzc2V0SWRTdHIFA25pbAUDbmlsAAADCQAAAgUGc3Rha2UxBQZzdGFrZTEEBnN0YWtlMgMJAQhjb250YWlucwIFDXN0YWtpbmdBc3NldHMFEWdvdlJld2FyZEFzc2V0U3RyCQD8BwQIBQFpBmNhbGxlcgIMc3Rha2VVbnN0YWtlCQDMCAIHCQDMCAIFCWdvdlJld2FyZAkAzAgCBRFnb3ZSZXdhcmRBc3NldFN0cgUDbmlsBQNuaWwAAAMJAAACBQZzdGFrZTIFBnN0YWtlMgQMc2hhcmVUb2tlblNUAwUMc3Rha2VGYXJtaW5nBApzdFBheW1lbnRzCQDOCAIJAMwIAgkBD0F0dGFjaGVkUGF5bWVudAIFDHNoYXJlQXNzZXRJZAUVc2hhcmVUb2tlblRvUGF5QW1vdW50BQNuaWwDCQAAAgkAkAMBBQhwQW1vdW50cwACCQDMCAIJAQ9BdHRhY2hlZFBheW1lbnQCAwkAAAIJAJEDAgUJcEFzc2V0SWRzAAEBAAUEdW5pdAkAkQMCBQlwQXNzZXRJZHMAAQkAkQMCBQhwQW1vdW50cwABBQNuaWwFA25pbAQHcmVpc3N1ZQkA/AcECAUBaQZjYWxsZXICEXJlaXNzdWVTaGFyZVRva2VuCQDMCAIFFXNoYXJlVG9rZW5Ub1BheUFtb3VudAUDbmlsBQNuaWwDCQAAAgUHcmVpc3N1ZQUHcmVpc3N1ZQQGc3Rha2UzCQD8BwQFDmZhcm1pbmdBZGRyZXNzAhdsb2NrU2hhcmVUb2tlbnNGcm9tUG9vbAkAzAgCBQtjYWxsZXJCeXRlcwkAzAgCCQClCAEIBQFpBmNhbGxlcgkAzAgCBQhsb2NrVHlwZQUDbmlsBQpzdFBheW1lbnRzAwkAAAIFBnN0YWtlMwUGc3Rha2UzBQNuaWwJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAMwIAgkBB1JlaXNzdWUDBQxzaGFyZUFzc2V0SWQFFXNoYXJlVG9rZW5Ub1BheUFtb3VudAYJAMwIAgkBDlNjcmlwdFRyYW5zZmVyAwUGY2FsbGVyBRVzaGFyZVRva2VuVG9QYXlBbW91bnQFDHNoYXJlQXNzZXRJZAUDbmlsCQCUCgIFA25pbAkAlAoCCQDOCAIJAMwIAgkBDEludGVnZXJFbnRyeQIFCWtCYWxhbmNlQQULbmV3QmFsYW5jZUEJAMwIAgkBDEludGVnZXJFbnRyeQIFCWtCYWxhbmNlQgULbmV3QmFsYW5jZUIJAMwIAgkBDEludGVnZXJFbnRyeQIFEWtTaGFyZUFzc2V0U3VwcGx5CQBkAgUQc2hhcmVBc3NldFN1cHBseQUVc2hhcmVUb2tlblRvUGF5QW1vdW50CQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMFD21vbmV5Qm94QWRkcmVzcwUJZ292UmV3YXJkBQ5nb3ZSZXdhcmRBc3NldAUDbmlsBQxzaGFyZVRva2VuU1QFA25pbAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgFpAQh3aXRoZHJhdwQLY2FsbGVyQnl0ZXMEYXJncwhwQW1vdW50cwlwQXNzZXRJZHMJAQt2YWx1ZU9yRWxzZQIJAQxpc09yYWNsZVBvb2wBCQClCAEIBQFpBmNhbGxlcgkBC3ZhbHVlT3JFbHNlAgkBCGlzQWN0aXZlAAQEdGltZQgFCWxhc3RCbG9jawl0aW1lc3RhbXAEBmNhbGxlcgkBB0FkZHJlc3MBBQtjYWxsZXJCeXRlcwQNJHQwMjk5ODgzMDA3OAkBDWdldFBvb2xBc3NldHMBCAUBaQZjYWxsZXIEC3N0ckFzc2V0SWRBCAUNJHQwMjk5ODgzMDA3OAJfMQQLc3RyQXNzZXRJZEIIBQ0kdDAyOTk4ODMwMDc4Al8yBAhhc3NldElkQQgFDSR0MDI5OTg4MzAwNzgCXzMECGFzc2V0SWRCCAUNJHQwMjk5ODgzMDA3OAJfNAQMc2hhcmVBc3NldElkCAUNJHQwMjk5ODgzMDA3OAJfNQQNJHQwMzAwOTEzMDIxNQkBD2dldFBvb2xCYWxhbmNlcwMIBQFpBmNhbGxlcgUIYXNzZXRJZEEFCGFzc2V0SWRCBAhiYWxhbmNlQQgFDSR0MDMwMDkxMzAyMTUCXzEECGJhbGFuY2VCCAUNJHQwMzAwOTEzMDIxNQJfMgQPYWNjb3VudEJhbGFuY2VBCAUNJHQwMzAwOTEzMDIxNQJfMwQPYWNjb3VudEJhbGFuY2VCCAUNJHQwMzAwOTEzMDIxNQJfNAQQc2hhcmVBc3NldFN1cHBseQgFDSR0MDMwMDkxMzAyMTUCXzUEDSR0MDMwMjI4MzA2MzYDCQAAAgkAkAMBBQhwQW1vdW50cwABBAZwQXNzZXQJARFwYXJzZVBheW1lbnRBc3NldAEJAJEDAgUJcEFzc2V0SWRzAAADCQECIT0CBQZwQXNzZXQFDHNoYXJlQXNzZXRJZAkAAgEJAKwCAgIkSW5jb3JyZWN0IGFzc2V0IGF0dGFjaGVkLiBFeHBlY3RlZDogCQDYBAEFDHNoYXJlQXNzZXRJZAkAlAoCCQCRAwIFCHBBbW91bnRzAAAFBnBBc3NldAkAlAoCAAAFDHNoYXJlQXNzZXRJZAQJcG10QW1vdW50CAUNJHQwMzAyMjgzMDYzNgJfMQQKcG10QXNzZXRJZAgFDSR0MDMwMjI4MzA2MzYCXzIDCQECIT0CCQCQAwEFBGFyZ3MAAQkAAgECD1dyb25nIGFyZ3Mgc2l6ZQMJAGYCCQCQAwEFCHBBbW91bnRzAAEJAAIBAh1PbmUgYXR0YWNoZWQgcGF5bWVudCBleHBlY3RlZAMDCQBmAgUIYmFsYW5jZUEFD2FjY291bnRCYWxhbmNlQQYJAGYCBQhiYWxhbmNlQgUPYWNjb3VudEJhbGFuY2VCCQCUCgIFA25pbAkAzggCCQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMFBmNhbGxlcgUJcG10QW1vdW50BQpwbXRBc3NldElkBQNuaWwJARFzdXNwZW5kU3VzcGljaW91cwYFD2FjY291bnRCYWxhbmNlQQUPYWNjb3VudEJhbGFuY2VCBQhiYWxhbmNlQQUIYmFsYW5jZUIFC3N0ckFzc2V0SWRBBQtzdHJBc3NldElkQgQMdW5sb2NrQW1vdW50CQENcGFyc2VJbnRWYWx1ZQEJAQt2YWx1ZU9yRWxzZQIJAJEDAgUEYXJncwAAAgEwBAZ1bmxvY2sDCQBmAgUMdW5sb2NrQW1vdW50AAAJAPwHBAUOZmFybWluZ0FkZHJlc3MCG3dpdGhkcmF3U2hhcmVUb2tlbnNGcm9tUG9vbAkAzAgCBQtjYWxsZXJCeXRlcwkAzAgCCQClCAEIBQFpBmNhbGxlcgkAzAgCBQx1bmxvY2tBbW91bnQFA25pbAUDbmlsAAADCQAAAgUGdW5sb2NrBQZ1bmxvY2sEDndpdGhkcmF3QW1vdW50CQBkAgUJcG10QW1vdW50BQx1bmxvY2tBbW91bnQEDGFtb3VudFRvUGF5QQkAawMFDndpdGhkcmF3QW1vdW50BQhiYWxhbmNlQQUQc2hhcmVBc3NldFN1cHBseQQMYW1vdW50VG9QYXlCCQBrAwUOd2l0aGRyYXdBbW91bnQFCGJhbGFuY2VCBRBzaGFyZUFzc2V0U3VwcGx5BAZzdGFrZTEDCQEIY29udGFpbnMCBQ1zdGFraW5nQXNzZXRzBQtzdHJBc3NldElkQQkA/AcECAUBaQZjYWxsZXICDHN0YWtlVW5zdGFrZQkAzAgCBwkAzAgCBQxhbW91bnRUb1BheUEJAMwIAgULc3RyQXNzZXRJZEEFA25pbAUDbmlsAAADCQAAAgUGc3Rha2UxBQZzdGFrZTEEBnN0YWtlMgMJAQhjb250YWlucwIFDXN0YWtpbmdBc3NldHMFC3N0ckFzc2V0SWRCCQD8BwQIBQFpBmNhbGxlcgIMc3Rha2VVbnN0YWtlCQDMCAIHCQDMCAIFDGFtb3VudFRvUGF5QgkAzAgCBQtzdHJBc3NldElkQgUDbmlsBQNuaWwAAAMJAAACBQZzdGFrZTIFBnN0YWtlMgkAlAoCCQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMIBQFpBmNhbGxlcgUMdW5sb2NrQW1vdW50BQxzaGFyZUFzc2V0SWQFA25pbAkAlAoCCQDMCAIJAQxJbnRlZ2VyRW50cnkCBQlrQmFsYW5jZUEJAGUCBQhiYWxhbmNlQQUMYW1vdW50VG9QYXlBCQDMCAIJAQxJbnRlZ2VyRW50cnkCBQlrQmFsYW5jZUIJAGUCBQhiYWxhbmNlQgUMYW1vdW50VG9QYXlCCQDMCAIJAQxJbnRlZ2VyRW50cnkCBRFrU2hhcmVBc3NldFN1cHBseQkAZQIFEHNoYXJlQXNzZXRTdXBwbHkFDndpdGhkcmF3QW1vdW50CQDMCAIJAQRCdXJuAgUMc2hhcmVBc3NldElkBQ53aXRoZHJhd0Ftb3VudAkAzAgCCQEOU2NyaXB0VHJhbnNmZXIDBQZjYWxsZXIFDGFtb3VudFRvUGF5QQUIYXNzZXRJZEEJAMwIAgkBDlNjcmlwdFRyYW5zZmVyAwUGY2FsbGVyBQxhbW91bnRUb1BheUIFCGFzc2V0SWRCBQNuaWwFA25pbAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgFpARB3aXRoZHJhd09uZVRva2VuBAtjYWxsZXJCeXRlcwRhcmdzCHBBbW91bnRzCXBBc3NldElkcwkBC3ZhbHVlT3JFbHNlAgkBDGlzT3JhY2xlUG9vbAEJAKUIAQgFAWkGY2FsbGVyCQELdmFsdWVPckVsc2UCCQEIaXNBY3RpdmUABAZjYWxsZXIJAQdBZGRyZXNzAQULY2FsbGVyQnl0ZXMEDXdpdGhkcmF3QXNzZXQDCQAAAgkAkQMCBQRhcmdzAAACAAUEdW5pdAkA2QQBCQCRAwIFBGFyZ3MAAAQNJHQwMzI5NDczMzAzNwkBDWdldFBvb2xBc3NldHMBCAUBaQZjYWxsZXIEC3N0ckFzc2V0SWRBCAUNJHQwMzI5NDczMzAzNwJfMQQLc3RyQXNzZXRJZEIIBQ0kdDAzMjk0NzMzMDM3Al8yBAhhc3NldElkQQgFDSR0MDMyOTQ3MzMwMzcCXzMECGFzc2V0SWRCCAUNJHQwMzI5NDczMzAzNwJfNAQMc2hhcmVBc3NldElkCAUNJHQwMzI5NDczMzAzNwJfNQQNJHQwMzMwNTAzMzE3NAkBD2dldFBvb2xCYWxhbmNlcwMIBQFpBmNhbGxlcgUIYXNzZXRJZEEFCGFzc2V0SWRCBAhiYWxhbmNlQQgFDSR0MDMzMDUwMzMxNzQCXzEECGJhbGFuY2VCCAUNJHQwMzMwNTAzMzE3NAJfMgQPYWNjb3VudEJhbGFuY2VBCAUNJHQwMzMwNTAzMzE3NAJfMwQPYWNjb3VudEJhbGFuY2VCCAUNJHQwMzMwNTAzMzE3NAJfNAQQc2hhcmVBc3NldFN1cHBseQgFDSR0MDMzMDUwMzMxNzQCXzUEDSR0MDMzMTg3MzM1NjcDCQAAAgkAkAMBBQhwQW1vdW50cwABBAZwQXNzZXQJARFwYXJzZVBheW1lbnRBc3NldAEJAJEDAgUJcEFzc2V0SWRzAAADCQECIT0CBQZwQXNzZXQFDHNoYXJlQXNzZXRJZAkAAgEJAKwCAgIkSW5jb3JyZWN0IGFzc2V0IGF0dGFjaGVkLiBFeHBlY3RlZDogCQDYBAEFDHNoYXJlQXNzZXRJZAkAlAoCCQCRAwIFCHBBbW91bnRzAAAFBnBBc3NldAkAlAoCAAAFDHNoYXJlQXNzZXRJZAQJcG10QW1vdW50CAUNJHQwMzMxODczMzU2NwJfMQQKcG10QXNzZXRJZAgFDSR0MDMzMTg3MzM1NjcCXzIED3ZpcnRNaW5Ub1JlY2l2ZQkBDXBhcnNlSW50VmFsdWUBCQCRAwIFBGFyZ3MAAQMJAQIhPQIJAJADAQUEYXJncwADCQACAQIPV3JvbmcgYXJncyBzaXplAwkAZgIJAJADAQUIcEFtb3VudHMAAQkAAgECHU9uZSBhdHRhY2hlZCBwYXltZW50IGV4cGVjdGVkAwkBAiE9AgUKcG10QXNzZXRJZAUMc2hhcmVBc3NldElkCQACAQkArAICAiRJbmNvcnJlY3QgYXNzZXQgYXR0YWNoZWQuIEV4cGVjdGVkOiAJANgEAQUMc2hhcmVBc3NldElkAwkBASEBCQEPY29udGFpbnNFbGVtZW50AgkAzAgCBQhhc3NldElkQQkAzAgCBQhhc3NldElkQgUDbmlsBQ13aXRoZHJhd0Fzc2V0CQACAQIZSW5jb3JyZWN0IHdpdGhkcmF3IGFzc2V0LgMDCQBmAgUIYmFsYW5jZUEFD2FjY291bnRCYWxhbmNlQQYJAGYCBQhiYWxhbmNlQgUPYWNjb3VudEJhbGFuY2VCCQCUCgIFA25pbAkAzggCCQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMFBmNhbGxlcgUJcG10QW1vdW50BQpwbXRBc3NldElkBQNuaWwJARFzdXNwZW5kU3VzcGljaW91cwYFD2FjY291bnRCYWxhbmNlQQUPYWNjb3VudEJhbGFuY2VCBQhiYWxhbmNlQQUIYmFsYW5jZUIFC3N0ckFzc2V0SWRBBQtzdHJBc3NldElkQgQMdW5sb2NrQW1vdW50CQENcGFyc2VJbnRWYWx1ZQEJAQt2YWx1ZU9yRWxzZQIJAJEDAgUEYXJncwACAgEwBAZ1bmxvY2sDCQBmAgUMdW5sb2NrQW1vdW50AAAJAPwHBAUOZmFybWluZ0FkZHJlc3MCG3dpdGhkcmF3U2hhcmVUb2tlbnNGcm9tUG9vbAkAzAgCBQtjYWxsZXJCeXRlcwkAzAgCCQClCAEIBQFpBmNhbGxlcgkAzAgCBQx1bmxvY2tBbW91bnQFA25pbAUDbmlsAAADCQAAAgUGdW5sb2NrBQZ1bmxvY2sEDndpdGhkcmF3QW1vdW50CQBkAgUJcG10QW1vdW50BQx1bmxvY2tBbW91bnQEDGFtb3VudFRvUGF5QQkAawMFDndpdGhkcmF3QW1vdW50BQhiYWxhbmNlQQUQc2hhcmVBc3NldFN1cHBseQQMYW1vdW50VG9QYXlCCQBrAwUOd2l0aGRyYXdBbW91bnQFCGJhbGFuY2VCBRBzaGFyZUFzc2V0U3VwcGx5BA0kdDAzNDkxNTM0OTczCQEMZ2V0RmVlUGFyYW1zAggFAWkGY2FsbGVyCAUBaQxvcmlnaW5DYWxsZXIEA2ZlZQgFDSR0MDM0OTE1MzQ5NzMCXzEEBmdvdkZlZQgFDSR0MDM0OTE1MzQ5NzMCXzIEDSR0MDM0OTkwMzUzOTADCQAAAgUNd2l0aGRyYXdBc3NldAUIYXNzZXRJZEEJAQ1jYWxjdWxhdGVGZWVzBgUMYW1vdW50VG9QYXlCBQ92aXJ0TWluVG9SZWNpdmUJAGUCBQhiYWxhbmNlQgUMYW1vdW50VG9QYXlCCQBlAgUIYmFsYW5jZUEFDGFtb3VudFRvUGF5QQUDZmVlBQZnb3ZGZWUJAQ1jYWxjdWxhdGVGZWVzBgUMYW1vdW50VG9QYXlBBQ92aXJ0TWluVG9SZWNpdmUJAGUCBQhiYWxhbmNlQQUMYW1vdW50VG9QYXlBCQBlAgUIYmFsYW5jZUIFDGFtb3VudFRvUGF5QgUDZmVlBQZnb3ZGZWUEEGFtb3VudFdpdGhvdXRGZWUIBQ0kdDAzNDk5MDM1MzkwAl8xBA1hbW91bnRXaXRoRmVlCAUNJHQwMzQ5OTAzNTM5MAJfMgQQZ292ZXJuYW5jZVJld2FyZAgFDSR0MDM0OTkwMzUzOTACXzMEDSR0MDM1NDA3MzY3NTMDCQAAAgUNd2l0aGRyYXdBc3NldAUIYXNzZXRJZEEEB3Vuc3Rha2UDCQEIY29udGFpbnMCBQ1zdGFraW5nQXNzZXRzBQtzdHJBc3NldElkQQkA/AcECAUBaQZjYWxsZXICDHN0YWtlVW5zdGFrZQkAzAgCBwkAzAgCCQBkAgkAZAIFDGFtb3VudFRvUGF5QQUNYW1vdW50V2l0aEZlZQUQZ292ZXJuYW5jZVJld2FyZAkAzAgCBQtzdHJBc3NldElkQQUDbmlsBQNuaWwAAAMJAAACBQd1bnN0YWtlBQd1bnN0YWtlCQCWCgQJAGUCCQBlAgkAZQIFCGJhbGFuY2VBBQxhbW91bnRUb1BheUEFDWFtb3VudFdpdGhGZWUFEGdvdmVybmFuY2VSZXdhcmQFCGJhbGFuY2VCBQhhc3NldElkQQkAzAgCCQEOU2NyaXB0VHJhbnNmZXIDBQZjYWxsZXIJAGQCBQxhbW91bnRUb1BheUEFDWFtb3VudFdpdGhGZWUFCGFzc2V0SWRBBQNuaWwJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4EB3Vuc3Rha2UDCQEIY29udGFpbnMCBQ1zdGFraW5nQXNzZXRzBQtzdHJBc3NldElkQgkA/AcECAUBaQZjYWxsZXICDHN0YWtlVW5zdGFrZQkAzAgCBwkAzAgCCQBkAgkAZAIFDGFtb3VudFRvUGF5QgUNYW1vdW50V2l0aEZlZQUQZ292ZXJuYW5jZVJld2FyZAkAzAgCBQtzdHJBc3NldElkQgUDbmlsBQNuaWwAAAMJAAACBQd1bnN0YWtlBQd1bnN0YWtlCQCWCgQFCGJhbGFuY2VBCQBlAgkAZQIJAGUCBQhiYWxhbmNlQgUMYW1vdW50VG9QYXlCBQ1hbW91bnRXaXRoRmVlBRBnb3Zlcm5hbmNlUmV3YXJkBQhhc3NldElkQgkAzAgCCQEOU2NyaXB0VHJhbnNmZXIDBQZjYWxsZXIJAGQCBQxhbW91bnRUb1BheUIFDWFtb3VudFdpdGhGZWUFCGFzc2V0SWRCBQNuaWwJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4EC25ld0JhbGFuY2VBCAUNJHQwMzU0MDczNjc1MwJfMQQLbmV3QmFsYW5jZUIIBQ0kdDAzNTQwNzM2NzUzAl8yBBBnb3ZSZXdhcmRBc3NldElkCAUNJHQwMzU0MDczNjc1MwJfMwQMdXNlclRyYW5zZmVyCAUNJHQwMzU0MDczNjc1MwJfNAkAlAoCCQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMIBQFpBmNhbGxlcgUMdW5sb2NrQW1vdW50BQxzaGFyZUFzc2V0SWQFA25pbAkAlAoCCQDOCAIJAMwIAgkBDEludGVnZXJFbnRyeQIFCWtCYWxhbmNlQQULbmV3QmFsYW5jZUEJAMwIAgkBDEludGVnZXJFbnRyeQIFCWtCYWxhbmNlQgULbmV3QmFsYW5jZUIJAMwIAgkBDEludGVnZXJFbnRyeQIFEWtTaGFyZUFzc2V0U3VwcGx5CQBlAgUQc2hhcmVBc3NldFN1cHBseQUOd2l0aGRyYXdBbW91bnQJAMwIAgkBBEJ1cm4CBQxzaGFyZUFzc2V0SWQFDndpdGhkcmF3QW1vdW50CQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMFD21vbmV5Qm94QWRkcmVzcwUQZ292ZXJuYW5jZVJld2FyZAUQZ292UmV3YXJkQXNzZXRJZAUDbmlsBQx1c2VyVHJhbnNmZXIFA25pbAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgFpARl0YWtlSW50b0FjY291bnRFeHRyYUZ1bmRzBAtjYWxsZXJCeXRlcwRhcmdzCHBBbW91bnRzCXBBc3NldElkcwkBC3ZhbHVlT3JFbHNlAgkBDGlzT3JhY2xlUG9vbAEJAKUIAQgFAWkGY2FsbGVyCQELdmFsdWVPckVsc2UCCQEIaXNBY3RpdmUABA0kdDAzNzQ3ODM3NTU0CQENZ2V0UG9vbEFzc2V0cwEIBQFpBmNhbGxlcgQLc3RyQXNzZXRJZEEIBQ0kdDAzNzQ3ODM3NTU0Al8xBAtzdHJBc3NldElkQggFDSR0MDM3NDc4Mzc1NTQCXzIECGFzc2V0SWRBCAUNJHQwMzc0NzgzNzU1NAJfMwQIYXNzZXRJZEIIBQ0kdDAzNzQ3ODM3NTU0Al80BAVjbGFpbQMDCQAAAgUIYXNzZXRJZEEFBFVTRE4GCQAAAgUIYXNzZXRJZEIFBFVTRE4JAPwHBAgFAWkGY2FsbGVyAhNjbGFpbU5ldHJpbm9SZXdhcmRzBQNuaWwFA25pbAAAAwkAAAIFBWNsYWltBQVjbGFpbQQNJHQwMzc3MzAzNzgzNgkBD2dldFBvb2xCYWxhbmNlcwMIBQFpBmNhbGxlcgUIYXNzZXRJZEEFCGFzc2V0SWRCBAhiYWxhbmNlQQgFDSR0MDM3NzMwMzc4MzYCXzEECGJhbGFuY2VCCAUNJHQwMzc3MzAzNzgzNgJfMgQPYWNjb3VudEJhbGFuY2VBCAUNJHQwMzc3MzAzNzgzNgJfMwQPYWNjb3VudEJhbGFuY2VCCAUNJHQwMzc3MzAzNzgzNgJfNAQNYW1vdW50RW5yb2xsQQkAZQIFD2FjY291bnRCYWxhbmNlQQUIYmFsYW5jZUEEDWFtb3VudEVucm9sbEIJAGUCBQ9hY2NvdW50QmFsYW5jZUIFCGJhbGFuY2VCAwkBAiE9AgkAkAMBBQRhcmdzAAAJAAIBAg9Xcm9uZyBhcmdzIHNpemUDCQECIT0CBQ9tb25leUJveEFkZHJlc3MIBQFpDG9yaWdpbkNhbGxlcgkAAgECJk9ubHkgdGhlIHdhbGxldCBjYW4gY2FsbCB0aGlzIGZ1bmN0aW9uAwMJAGYCAAAFDWFtb3VudEVucm9sbEEGCQBmAgAABQ1hbW91bnRFbnJvbGxCCQEHc3VzcGVuZAECFkVucm9sbCBhbW91bnQgbmVnYXRpdmUDAwkAAAIFDWFtb3VudEVucm9sbEEAAAkAAAIFDWFtb3VudEVucm9sbEIAAAcJAAIBAhBObyBtb25leSB0byB0YWtlBAZzdGFrZTEDAwkBCGNvbnRhaW5zAgUNc3Rha2luZ0Fzc2V0cwULc3RyQXNzZXRJZEEJAGYCBQ1hbW91bnRFbnJvbGxBAAAHCQD8BwQIBQFpBmNhbGxlcgIMc3Rha2VVbnN0YWtlCQDMCAIGCQDMCAIFDWFtb3VudEVucm9sbEEJAMwIAgULc3RyQXNzZXRJZEEFA25pbAUDbmlsAAADCQAAAgUGc3Rha2UxBQZzdGFrZTEEBnN0YWtlMgMDCQEIY29udGFpbnMCBQ1zdGFraW5nQXNzZXRzBQtzdHJBc3NldElkQgkAZgIFDWFtb3VudEVucm9sbEIAAAcJAPwHBAgFAWkGY2FsbGVyAgxzdGFrZVVuc3Rha2UJAMwIAgYJAMwIAgUNYW1vdW50RW5yb2xsQgkAzAgCBQtzdHJBc3NldElkQgUDbmlsBQNuaWwAAAMJAAACBQZzdGFrZTIFBnN0YWtlMgkAlAoCBQNuaWwJAJQKAgkAzAgCCQEMSW50ZWdlckVudHJ5AgUJa0JhbGFuY2VBCQBkAgUIYmFsYW5jZUEFDWFtb3VudEVucm9sbEEJAMwIAgkBDEludGVnZXJFbnRyeQIFCWtCYWxhbmNlQgkAZAIFCGJhbGFuY2VCBQ1hbW91bnRFbnJvbGxCBQNuaWwFA25pbAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgECdHgBBnZlcmlmeQAEE211bHRpU2lnbmVkQnlBZG1pbnMEEmFkbWluUHViS2V5MVNpZ25lZAMJAPQDAwgFAnR4CWJvZHlCeXRlcwkAkQMCCAUCdHgGcHJvb2ZzAAAFDGFkbWluUHViS2V5MQABAAAEEmFkbWluUHViS2V5MlNpZ25lZAMJAPQDAwgFAnR4CWJvZHlCeXRlcwkAkQMCCAUCdHgGcHJvb2ZzAAEFDGFkbWluUHViS2V5MgABAAAEEmFkbWluUHViS2V5M1NpZ25lZAMJAPQDAwgFAnR4CWJvZHlCeXRlcwkAkQMCCAUCdHgGcHJvb2ZzAAIFDGFkbWluUHViS2V5MwABAAAJAGcCCQBkAgkAZAIFEmFkbWluUHViS2V5MVNpZ25lZAUSYWRtaW5QdWJLZXkyU2lnbmVkBRJhZG1pblB1YktleTNTaWduZWQAAgUTbXVsdGlTaWduZWRCeUFkbWluc6fBZEs=",
    "height": 2368387,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let version = "1.0.0"
5+
6+let kVersion = "version"
7+
8+let kActive = "active"
9+
10+let kAssetIdA = "A_asset_id"
11+
12+let kAssetIdB = "B_asset_id"
13+
14+let kBalanceA = "A_asset_balance"
15+
16+let kBalanceB = "B_asset_balance"
17+
18+let kBalanceInitA = "A_asset_init"
19+
20+let kBalanceInitB = "B_asset_init"
21+
22+let kShareAssetId = "share_asset_id"
23+
24+let kShareAssetSupply = "share_asset_supply"
25+
26+let kFee = "commission"
27+
28+let kCause = "shutdown_cause"
29+
30+let kFirstHarvest = "first_harvest"
31+
32+let kFirstHarvestHeight = "first_harvest_height"
33+
34+let kShareLimit = "share_limit_on_first_harvest"
35+
36+let kBasePeriod = "base_period"
37+
38+let kPeriodLength = "period_length"
39+
40+let kStartHeight = "start_height"
41+
42+let kUSDNAddress = "staking_usdnnsbt_address"
43+
44+let kEURNAddress = "staking_eurn_address"
45+
46+let kLeasingAmount = "leasing_amount"
47+
48+let kUSDNAssetId = "usdn_asset_id"
49+
50+let kEURNAssetId = "eurn_asset_id"
51+
52+let kStakingAssets = "staking_assets"
53+
54+let kOracleActive = "active_all_contracts"
55+
56+let kDiscounts = "discounts"
57+
58+let kDiscountValues = "discount_values"
59+
60+let kUserGSwopInGov = "_GSwop_amount"
61+
62+let kUserSwopInGov = "_SWOP_amount"
63+
64+let kOraclePool = "pool_"
65+
66+let kAdminPubKey1 = "admin_pub_1"
67+
68+let kAdminPubKey2 = "admin_pub_2"
69+
70+let kAdminPubKey3 = "admin_pub_3"
71+
72+let kAdminInvokePubKey = "admin_invoke_pub"
73+
74+let kMoneyBoxAddress = "money_box_address"
75+
76+let kVotingAddress = "voting_address"
77+
78+let kGovAddress = "governance_address"
79+
80+let kFarmingAddress = "farming_address"
81+
82+let oracle = Address(base58'3N9k318h2ENuEEpdnbbCutHFturyWV5cYbS')
83+
84+func getBase58FromOracle (key) = match getString(oracle, key) {
85+    case string: String => 
86+        fromBase58String(string)
87+    case nothing => 
88+        throw((key + "is empty"))
89+}
90+
91+
92+let adminPubKey1 = getBase58FromOracle(kAdminPubKey1)
93+
94+let adminPubKey2 = getBase58FromOracle(kAdminPubKey2)
95+
96+let adminPubKey3 = getBase58FromOracle(kAdminPubKey3)
97+
98+let adminInvokePubKey = getBase58FromOracle(kAdminInvokePubKey)
99+
100+let moneyBoxAddress = Address(getBase58FromOracle(kMoneyBoxAddress))
101+
102+let votingAddress = Address(getBase58FromOracle(kVotingAddress))
103+
104+let govAddress = Address(getBase58FromOracle(kGovAddress))
105+
106+let farmingAddress = Address(getBase58FromOracle(kFarmingAddress))
107+
108+let USDN = getBase58FromOracle(kUSDNAssetId)
109+
110+let EURN = getBase58FromOracle(kEURNAssetId)
111+
112+let stakingAssets = getStringValue(oracle, kStakingAssets)
113+
114+let stakingUSDNAddress = Address(getBase58FromOracle(kUSDNAddress))
115+
116+let stakingEURNAddress = Address(getBase58FromOracle(kEURNAddress))
117+
118+let basePeriod = valueOrErrorMessage(getInteger(votingAddress, kBasePeriod), "Empty kBasePeriod")
119+
120+let startHeight = valueOrErrorMessage(getInteger(votingAddress, kStartHeight), "Empty kStartHeight")
121+
122+let periodLength = valueOrErrorMessage(getInteger(votingAddress, kPeriodLength), "Empty kPeriodLength")
123+
124+let firstHarvestEndPeriod = ((basePeriod + ((height - startHeight) / periodLength)) + 3)
125+
126+let active = getBooleanValue(oracle, kOracleActive)
127+
128+let feeScale6 = 1000000
129+
130+let scale8 = 100000000
131+
132+let scale16 = toBigInt(10000000000000000)
133+
134+func accountBalance (assetId,pool) = match assetId {
135+    case id: ByteVector => 
136+        assetBalance(pool, id)
137+    case waves: Unit => 
138+        wavesBalance(pool).available
139+    case _ => 
140+        throw("Match error")
141+}
142+
143+
144+func stakedAmount (assetId,pool) = {
145+    let stakedAmountCalculated =     match assetId {
146+        case aId: ByteVector => 
147+            if ((aId == USDN))
148+                then getInteger(stakingUSDNAddress, ((("rpd_balance_" + toBase58String(aId)) + "_") + toString(pool)))
149+                else if ((aId == EURN))
150+                    then getInteger(stakingEURNAddress, ((("%s%s%s__stakingBalance__" + toBase58String(aId)) + "__") + toString(pool)))
151+                    else 0
152+        case _: Unit => 
153+            valueOrElse(getInteger(pool, kLeasingAmount), 0)
154+        case _ => 
155+            throw("Match error")
156+    }
157+    match stakedAmountCalculated {
158+        case i: Int => 
159+            i
160+        case _ => 
161+            0
162+    }
163+    }
164+
165+
166+func getAssetInfo (assetId) = match assetId {
167+    case id: String|ByteVector => 
168+        let $t039394111 =         match id {
169+            case aId: ByteVector => 
170+                $Tuple2(toBase58String(aId), aId)
171+            case aId: String => 
172+                $Tuple2(aId, fromBase58String(aId))
173+            case _ => 
174+                throw("Match error")
175+        }
176+        let stringId = $t039394111._1
177+        let bytesId = $t039394111._2
178+        let info = valueOrErrorMessage(assetInfo(bytesId), (("Asset " + stringId) + " doesn't exist"))
179+        $Tuple3(stringId, info.name, info.decimals)
180+    case waves: Unit => 
181+        $Tuple3("WAVES", "WAVES", 8)
182+    case _ => 
183+        throw("Match error")
184+}
185+
186+
187+func suspend (cause) = [BooleanEntry(kActive, false), StringEntry(kCause, cause)]
188+
189+
190+func calculateFeeDiscount (userAddr) = {
191+    let swopAmount = valueOrElse(getInteger(govAddress, (toString(userAddr) + kUserSwopInGov)), 0)
192+    let gSwopAmount = valueOrElse(getInteger(govAddress, (toString(userAddr) + kUserGSwopInGov)), swopAmount)
193+    let discountValues = split(getStringValue(oracle, kDiscountValues), ",")
194+    let discounts = split(getStringValue(oracle, kDiscounts), ",")
195+    if (if ((gSwopAmount >= parseIntValue(discountValues[0])))
196+        then (parseIntValue(discountValues[1]) > gSwopAmount)
197+        else false)
198+        then (feeScale6 - parseIntValue(discounts[0]))
199+        else if (if ((gSwopAmount >= parseIntValue(discountValues[1])))
200+            then (parseIntValue(discountValues[2]) > gSwopAmount)
201+            else false)
202+            then (feeScale6 - parseIntValue(discounts[1]))
203+            else if (if ((gSwopAmount >= parseIntValue(discountValues[2])))
204+                then (parseIntValue(discountValues[3]) > gSwopAmount)
205+                else false)
206+                then (feeScale6 - parseIntValue(discounts[2]))
207+                else if (if ((gSwopAmount >= parseIntValue(discountValues[3])))
208+                    then (parseIntValue(discountValues[4]) > gSwopAmount)
209+                    else false)
210+                    then (feeScale6 - parseIntValue(discounts[3]))
211+                    else if ((gSwopAmount >= parseIntValue(discountValues[4])))
212+                        then (feeScale6 - parseIntValue(discounts[4]))
213+                        else feeScale6
214+    }
215+
216+
217+func calculateFees (pmtAmount,minAmountToReceive,tokenFrom,tokenTo,fee,feeGovernance) = {
218+    let amountWithoutFee = fraction(tokenTo, pmtAmount, (pmtAmount + tokenFrom))
219+    let amountWithFee = fraction(amountWithoutFee, (feeScale6 - fee), feeScale6)
220+    let governanceReward = fraction(amountWithoutFee, feeGovernance, feeScale6)
221+    if ((minAmountToReceive > amountWithFee))
222+        then throw(((("Calculated amount to receive " + toString(amountWithFee)) + " is less than specified minimum ") + toString(minAmountToReceive)))
223+        else $Tuple3(amountWithoutFee, amountWithFee, governanceReward)
224+    }
225+
226+
227+func calculateVirtPay (pmtAmount,balance,fee) = {
228+    let F = (feeScale6 - fee)
229+    let k = fraction(fee, 60, 100)
230+    let a = (scale8 + fraction((F * k), scale8, (feeScale6 * feeScale6)))
231+    let b = ((((balance + fraction(balance, F, feeScale6)) + fraction(pmtAmount, F, feeScale6)) - pmtAmount) - fraction(pmtAmount, (F * k), (feeScale6 * feeScale6)))
232+    let c = (-(toBigInt(balance)) * toBigInt(pmtAmount))
233+    let D = ((toBigInt(b) * toBigInt(b)) - fraction((toBigInt(4) * c), toBigInt(a), toBigInt(scale8)))
234+    toInt(fraction((-(toBigInt(b)) + sqrtBigInt(D, 0, 0, DOWN)), toBigInt(scale8), toBigInt((2 * a))))
235+    }
236+
237+
238+func parsePaymentAsset (assetId) = if ((assetId == base58''))
239+    then unit
240+    else assetId
241+
242+
243+func suspendSuspicious (accountBalanceA,accountBalanceB,balanceA,balanceB,assetIdA,assetIdB) = suspend(((((((((((((((("Suspicious state. Actual balances: " + toString(accountBalanceA)) + " ") + assetIdA) + ", ") + toString(accountBalanceB)) + " ") + assetIdB) + ". State: ") + toString(balanceA)) + " ") + assetIdA) + ", ") + toString(balanceB)) + " ") + assetIdB))
244+
245+
246+func isActive () = if (active)
247+    then unit
248+    else throw("DApp is inactive at this moment")
249+
250+
251+func isOraclePool (poolAddress) = if (isDefined(getString(oracle, (kOraclePool + poolAddress))))
252+    then unit
253+    else throw("DApp is not registered pool")
254+
255+
256+func getPoolBalances (pool,assetIdA,assetIdB) = {
257+    let balanceA = getIntegerValue(pool, kBalanceA)
258+    let balanceB = getIntegerValue(pool, kBalanceB)
259+    let stakedAmountA = stakedAmount(assetIdA, pool)
260+    let stakedAmountB = stakedAmount(assetIdB, pool)
261+    let accountBalanceA = (accountBalance(assetIdA, pool) + stakedAmountA)
262+    let accountBalanceB = (accountBalance(assetIdB, pool) + stakedAmountB)
263+    let shareSupply = getIntegerValue(pool, kShareAssetSupply)
264+    $Tuple5(balanceA, balanceB, accountBalanceA, accountBalanceB, shareSupply)
265+    }
266+
267+
268+func getPoolAssets (pool) = {
269+    let strAssetIdA = getStringValue(pool, kAssetIdA)
270+    let strAssetIdB = getStringValue(pool, kAssetIdB)
271+    let assetIdA = if ((strAssetIdA == "WAVES"))
272+        then unit
273+        else fromBase58String(strAssetIdA)
274+    let assetIdB = if ((strAssetIdB == "WAVES"))
275+        then unit
276+        else fromBase58String(strAssetIdB)
277+    let shareAssetId = fromBase58String(getStringValue(pool, kShareAssetId))
278+    $Tuple5(strAssetIdA, strAssetIdB, assetIdA, assetIdB, shareAssetId)
279+    }
280+
281+
282+func getFeeParams (pool,caller) = {
283+    let feeDiscount = calculateFeeDiscount(caller)
284+    let fee = fraction(getIntegerValue(pool, kFee), feeDiscount, feeScale6, CEILING)
285+    let govFee = fraction(fee, 40, 100)
286+    $Tuple2(fee, govFee)
287+    }
288+
289+
290+@Callable(i)
291+func init (callerBytes,args,pAmounts,pAssetIds) = {
292+    let caller = Address(callerBytes)
293+    let $t090769154 = $Tuple2(pAmounts[0], parsePaymentAsset(pAssetIds[0]))
294+    let pmtAmountA = $t090769154._1
295+    let pmtAssetIdA = $t090769154._2
296+    let $t091599237 = $Tuple2(pAmounts[1], parsePaymentAsset(pAssetIds[1]))
297+    let pmtAmountB = $t091599237._1
298+    let pmtAssetIdB = $t091599237._2
299+    if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminInvokePubKey], i.originCallerPublicKey)))
300+        then throw("Only admin can call this function")
301+        else if ((size(args) != 1))
302+            then throw("Wrong args size")
303+            else if (isDefined(getBoolean(caller, kActive)))
304+                then throw("DApp is already active")
305+                else if ((pmtAssetIdA == pmtAssetIdB))
306+                    then throw("Assets must be different")
307+                    else {
308+                        let $t096729749 = getAssetInfo(pmtAssetIdA)
309+                        let pmtStrAssetIdA = $t096729749._1
310+                        let pmtAssetNameA = $t096729749._2
311+                        let pmtDecimalsA = $t096729749._3
312+                        let $t097589835 = getAssetInfo(pmtAssetIdB)
313+                        let pmtStrAssetIdB = $t097589835._1
314+                        let pmtAssetNameB = $t097589835._2
315+                        let pmtDecimalsB = $t097589835._3
316+                        let firstHarvest = (args[0] == "true")
317+                        let shareName = ((("s" + take(pmtAssetNameA, 7)) + "_") + take(pmtAssetNameB, 7))
318+                        let shareDescription = ((((("ShareToken of SwopFi protocol for " + pmtAssetNameA) + " and ") + pmtAssetNameB) + " at address ") + toString(this))
319+                        let shareDecimals = ((pmtDecimalsA + pmtDecimalsB) / 2)
320+                        let arg1 = pow(pmtAmountA, pmtDecimalsA, 5, 1, pmtDecimalsA, DOWN)
321+                        let arg2 = pow(pmtAmountB, pmtDecimalsB, 5, 1, pmtDecimalsB, DOWN)
322+                        let arg3 = pow(10, 0, shareDecimals, 0, 0, DOWN)
323+                        let shareInitialSupply = fraction(arg1, arg2, arg3)
324+                        let shareIssue = Issue(shareName, shareDescription, shareInitialSupply, shareDecimals, true)
325+                        let shareIssueId = calculateAssetId(shareIssue)
326+                        let stake1 = if (contains(stakingAssets, pmtStrAssetIdA))
327+                            then invoke(i.caller, "stakeUnstake", [true, pmtAmountA, pmtStrAssetIdA], nil)
328+                            else 0
329+                        if ((stake1 == stake1))
330+                            then {
331+                                let stake2 = if (contains(stakingAssets, pmtStrAssetIdB))
332+                                    then invoke(i.caller, "stakeUnstake", [true, pmtAmountB, pmtStrAssetIdB], nil)
333+                                    else 0
334+                                if ((stake2 == stake2))
335+                                    then {
336+                                        let baseEntry = [StringEntry(kVersion, version), BooleanEntry(kActive, true), StringEntry(kAssetIdA, pmtStrAssetIdA), StringEntry(kAssetIdB, pmtStrAssetIdB), IntegerEntry(kBalanceA, pmtAmountA), IntegerEntry(kBalanceB, pmtAmountB), IntegerEntry(kFee, getIntegerValue(oracle, "base_fee_cpmm")), shareIssue, StringEntry(kShareAssetId, toBase58String(shareIssueId)), IntegerEntry(kShareAssetSupply, shareInitialSupply), ScriptTransfer(caller, shareInitialSupply, shareIssueId)]
337+                                        if (firstHarvest)
338+                                            then $Tuple2(nil, $Tuple2((baseEntry ++ [BooleanEntry(kFirstHarvest, firstHarvest), IntegerEntry(kFirstHarvestHeight, (startHeight + (firstHarvestEndPeriod * periodLength)))]), nil))
339+                                            else $Tuple2(nil, $Tuple2(baseEntry, nil))
340+                                        }
341+                                    else throw("Strict value is not equal to itself.")
342+                                }
343+                            else throw("Strict value is not equal to itself.")
344+                        }
345+    }
346+
347+
348+
349+@Callable(i)
350+func initWithInitRatio (callerBytes,args,pAmounts,pAssetIds) = {
351+    let caller = Address(callerBytes)
352+    let $t01205612256 = $Tuple5(parseIntValue(args[0]), parseIntValue(args[1]), args[2], args[3], (args[4] == "true"))
353+    let amtAssetA = $t01205612256._1
354+    let amtAssetB = $t01205612256._2
355+    let assetIdAStr = $t01205612256._3
356+    let assetIdBStr = $t01205612256._4
357+    let firstHarvest = $t01205612256._5
358+    if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminInvokePubKey], i.originCallerPublicKey)))
359+        then throw("Only admin can call this function")
360+        else if ((size(args) != 5))
361+            then throw("Wrong args size")
362+            else if (isDefined(getBoolean(caller, kActive)))
363+                then throw("DApp is already active")
364+                else if ((assetIdAStr == assetIdBStr))
365+                    then throw("Assets must be different")
366+                    else {
367+                        let $t01269112768 = getAssetInfo(assetIdAStr)
368+                        let pmtStrAssetIdA = $t01269112768._1
369+                        let pmtAssetNameA = $t01269112768._2
370+                        let pmtDecimalsA = $t01269112768._3
371+                        let $t01277712854 = getAssetInfo(assetIdBStr)
372+                        let pmtStrAssetIdB = $t01277712854._1
373+                        let pmtAssetNameB = $t01277712854._2
374+                        let pmtDecimalsB = $t01277712854._3
375+                        let shareName = ((("s" + take(pmtAssetNameA, 7)) + "_") + take(pmtAssetNameB, 7))
376+                        let shareDescription = ((((("ShareToken of SwopFi protocol for " + pmtAssetNameA) + " and ") + pmtAssetNameB) + " at address ") + toString(this))
377+                        let shareDecimals = ((pmtDecimalsA + pmtDecimalsB) / 2)
378+                        let shareInitialSupply = 0
379+                        let shareIssue = Issue(shareName, shareDescription, shareInitialSupply, shareDecimals, true)
380+                        let shareIssueId = calculateAssetId(shareIssue)
381+                        let baseEntry = [StringEntry(kVersion, version), BooleanEntry(kActive, true), StringEntry(kAssetIdA, pmtStrAssetIdA), StringEntry(kAssetIdB, pmtStrAssetIdB), IntegerEntry(kBalanceInitA, amtAssetA), IntegerEntry(kBalanceInitB, amtAssetB), IntegerEntry(kBalanceA, 0), IntegerEntry(kBalanceB, 0), IntegerEntry(kFee, getIntegerValue(oracle, "base_fee_cpmm")), shareIssue, StringEntry(kShareAssetId, toBase58String(shareIssueId)), IntegerEntry(kShareAssetSupply, shareInitialSupply)]
382+                        if (firstHarvest)
383+                            then $Tuple2(nil, $Tuple2((baseEntry ++ [BooleanEntry(kFirstHarvest, firstHarvest), IntegerEntry(kFirstHarvestHeight, (startHeight + (firstHarvestEndPeriod * periodLength)))]), nil))
384+                            else $Tuple2(nil, $Tuple2(baseEntry, nil))
385+                        }
386+    }
387+
388+
389+
390+@Callable(i)
391+func keepLimitForFirstHarvest (callerBytes,args,pAmounts,pAssetIds) = valueOrElse(isOraclePool(toString(i.caller)), valueOrElse(isActive(), if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminInvokePubKey], i.originCallerPublicKey)))
392+    then throw("Only admin can call this function")
393+    else if ((size(args) != 1))
394+        then throw("Wrong args size")
395+        else {
396+            let shareLimit = parseIntValue(args[0])
397+            $Tuple2(nil, $Tuple2([IntegerEntry(kShareLimit, shareLimit)], nil))
398+            }))
399+
400+
401+
402+@Callable(i)
403+func exchange (callerBytes,args,pAmounts,pAssetIds) = valueOrElse(isOraclePool(toString(i.caller)), valueOrElse(isActive(), {
404+    let caller = Address(callerBytes)
405+    let $t01524015316 = $Tuple2(pAmounts[0], parsePaymentAsset(pAssetIds[0]))
406+    let pmtAmount = $t01524015316._1
407+    let pmtAssetId = $t01524015316._2
408+    let minAmountToReceive = parseIntValue(args[0])
409+    let $t01538915465 = getPoolAssets(i.caller)
410+    let strAssetIdA = $t01538915465._1
411+    let strAssetIdB = $t01538915465._2
412+    let assetIdA = $t01538915465._3
413+    let assetIdB = $t01538915465._4
414+    let $t01547815584 = getPoolBalances(i.caller, assetIdA, assetIdB)
415+    let balanceA = $t01547815584._1
416+    let balanceB = $t01547815584._2
417+    let accountBalanceA = $t01547815584._3
418+    let accountBalanceB = $t01547815584._4
419+    if ((size(args) != 1))
420+        then throw("Wrong args size")
421+        else if (if ((balanceA == 0))
422+            then true
423+            else (balanceB == 0))
424+            then throw("Can't exchange with zero balance")
425+            else if ((0 >= minAmountToReceive))
426+                then throw(("Minimal amount to receive must be positive. Actual: " + toString(minAmountToReceive)))
427+                else if ((size(pAmounts) != 1))
428+                    then throw("One attached payment expected")
429+                    else if (!(containsElement([assetIdA, assetIdB], pmtAssetId)))
430+                        then throw(((("Incorrect asset attached. Expected: " + strAssetIdA) + " or ") + strAssetIdB))
431+                        else if (if ((balanceA > accountBalanceA))
432+                            then true
433+                            else (balanceB > accountBalanceB))
434+                            then $Tuple2(nil, ([ScriptTransfer(caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious(accountBalanceA, accountBalanceB, balanceA, balanceB, strAssetIdA, strAssetIdB)))
435+                            else {
436+                                let $t01655216610 = getFeeParams(i.caller, i.originCaller)
437+                                let fee = $t01655216610._1
438+                                let govFee = $t01655216610._2
439+                                let $t01662716964 = if ((pmtAssetId == assetIdA))
440+                                    then calculateFees(pmtAmount, minAmountToReceive, balanceA, balanceB, fee, govFee)
441+                                    else calculateFees(pmtAmount, minAmountToReceive, balanceB, balanceA, fee, govFee)
442+                                let amountWithoutFee = $t01662716964._1
443+                                let amountWithFee = $t01662716964._2
444+                                let governanceReward = $t01662716964._3
445+                                let $t01698217307 = if ((pmtAssetId == assetIdA))
446+                                    then $Tuple3((balanceA + pmtAmount), ((balanceB - amountWithFee) - governanceReward), assetIdB)
447+                                    else $Tuple3(((balanceA - amountWithFee) - governanceReward), (balanceB + pmtAmount), assetIdA)
448+                                let newBalanceA = $t01698217307._1
449+                                let newBalanceB = $t01698217307._2
450+                                let assetIdSend = $t01698217307._3
451+                                let $t01732517575 = if ((pmtAssetId == assetIdA))
452+                                    then $Tuple2(pmtAmount, (amountWithFee + governanceReward))
453+                                    else $Tuple2((amountWithFee + governanceReward), pmtAmount)
454+                                let stakeAmountA = $t01732517575._1
455+                                let stakeAmountB = $t01732517575._2
456+                                let stake1 = if (contains(stakingAssets, strAssetIdA))
457+                                    then invoke(i.caller, "stakeUnstake", [(pmtAssetId == assetIdA), stakeAmountA, strAssetIdA], nil)
458+                                    else 0
459+                                if ((stake1 == stake1))
460+                                    then {
461+                                        let stake2 = if (contains(stakingAssets, strAssetIdB))
462+                                            then invoke(i.caller, "stakeUnstake", [(pmtAssetId == assetIdB), stakeAmountB, strAssetIdB], nil)
463+                                            else 0
464+                                        if ((stake2 == stake2))
465+                                            then $Tuple2(nil, $Tuple2([IntegerEntry(kBalanceA, newBalanceA), IntegerEntry(kBalanceB, newBalanceB), ScriptTransfer(caller, amountWithFee, assetIdSend), ScriptTransfer(moneyBoxAddress, governanceReward, assetIdSend)], [amountWithFee, assetIdSend]))
466+                                            else throw("Strict value is not equal to itself.")
467+                                        }
468+                                    else throw("Strict value is not equal to itself.")
469+                                }
470+    }))
471+
472+
473+
474+@Callable(i)
475+func replenishWithTwoTokens (callerBytes,args,pAmounts,pAssetIds) = valueOrElse(isOraclePool(toString(i.caller)), valueOrElse(isActive(), {
476+    let caller = Address(callerBytes)
477+    let pmtAssetIdA = parsePaymentAsset(pAssetIds[0])
478+    let pmtAssetIdB = parsePaymentAsset(pAssetIds[1])
479+    let stakeFarming = (args[0] == "true")
480+    let lockType = parseIntValue(args[1])
481+    let $t01883818928 = getPoolAssets(i.caller)
482+    let strAssetIdA = $t01883818928._1
483+    let strAssetIdB = $t01883818928._2
484+    let assetIdA = $t01883818928._3
485+    let assetIdB = $t01883818928._4
486+    let shareAssetId = $t01883818928._5
487+    let $t01894119065 = getPoolBalances(i.caller, assetIdA, assetIdB)
488+    let balanceA = $t01894119065._1
489+    let balanceB = $t01894119065._2
490+    let accountBalanceA = $t01894119065._3
491+    let accountBalanceB = $t01894119065._4
492+    let shareAssetSupply = $t01894119065._5
493+    if ((size(args) != 2))
494+        then throw("Wrong args size")
495+        else if (if ((size(pAmounts) != 2))
496+            then (size(pAmounts) != 3)
497+            else false)
498+            then throw("Two or three payments expected")
499+            else if (if ((pmtAssetIdA != assetIdA))
500+                then true
501+                else (pmtAssetIdB != assetIdB))
502+                then throw(((("Incorrect assets attached. Expected: " + strAssetIdA) + " and ") + strAssetIdB))
503+                else if (if ((balanceA > accountBalanceA))
504+                    then true
505+                    else (balanceB > accountBalanceB))
506+                    then $Tuple2(nil, ([ScriptTransfer(caller, pAmounts[0], pmtAssetIdA), ScriptTransfer(caller, pAmounts[1], pmtAssetIdB)] ++ (if ((size(pAmounts) == 3))
507+                        then [AttachedPayment(if ((pAssetIds[2] == base58''))
508+                            then unit
509+                            else pAssetIds[2], pAmounts[2])]
510+                        else (nil ++ suspendSuspicious(accountBalanceA, accountBalanceB, balanceA, balanceB, strAssetIdA, strAssetIdB)))))
511+                    else {
512+                        let $t02006620143 = getAssetInfo(pmtAssetIdA)
513+                        let pmtStrAssetIdA = $t02006620143._1
514+                        let pmtAssetNameA = $t02006620143._2
515+                        let pmtDecimalsA = $t02006620143._3
516+                        let $t02016020237 = getAssetInfo(pmtAssetIdB)
517+                        let pmtStrAssetIdB = $t02016020237._1
518+                        let pmtAssetNameB = $t02016020237._2
519+                        let pmtDecimalsB = $t02016020237._3
520+                        let initial = ((balanceA + balanceB) == 0)
521+                        let $t02031221212 = if (initial)
522+                            then $Tuple5(pAmounts[0], pAmounts[1], 0, pmtAssetIdA, toBigInt(1))
523+                            else {
524+                                let ratioShareTokensInA = fraction(scale16, toBigInt(pAmounts[0]), toBigInt(balanceA))
525+                                let ratioShareTokensInB = fraction(scale16, toBigInt(pAmounts[1]), toBigInt(balanceB))
526+                                if ((ratioShareTokensInB > ratioShareTokensInA))
527+                                    then {
528+                                        let pmt = fraction(pAmounts[0], balanceB, balanceA)
529+                                        $Tuple5(pAmounts[0], pmt, (pAmounts[1] - pmt), pmtAssetIdB, ratioShareTokensInA)
530+                                        }
531+                                    else {
532+                                        let pmt = fraction(pAmounts[1], balanceA, balanceB)
533+                                        $Tuple5(pmt, pAmounts[1], (pAmounts[0] - pmt), pmtAssetIdA, ratioShareTokensInB)
534+                                        }
535+                                }
536+                        let pmtAmountA = $t02031221212._1
537+                        let pmtAmountB = $t02031221212._2
538+                        let change = $t02031221212._3
539+                        let changeAssetId = $t02031221212._4
540+                        let shareTokenRatio = $t02031221212._5
541+                        let shareTokenToPayAmount = if (initial)
542+                            then {
543+                                let shareDecimals = ((pmtDecimalsA + pmtDecimalsB) / 2)
544+                                fraction(pow(pmtAmountA, pmtDecimalsA, 5, 1, pmtDecimalsA, DOWN), pow(pmtAmountB, pmtDecimalsB, 5, 1, pmtDecimalsB, DOWN), pow(10, 0, shareDecimals, 0, 0, DOWN))
545+                                }
546+                            else toInt(fraction(shareTokenRatio, toBigInt(shareAssetSupply), scale16))
547+                        if ((shareTokenToPayAmount == 0))
548+                            then throw("Too small amount to replenish")
549+                            else if ((0 > change))
550+                                then throw("Change < 0")
551+                                else {
552+                                    let stake1 = if (contains(stakingAssets, pmtStrAssetIdA))
553+                                        then invoke(i.caller, "stakeUnstake", [true, pmtAmountA, pmtStrAssetIdA], nil)
554+                                        else 0
555+                                    if ((stake1 == stake1))
556+                                        then {
557+                                            let stake2 = if (contains(stakingAssets, pmtStrAssetIdB))
558+                                                then invoke(i.caller, "stakeUnstake", [true, pmtAmountB, pmtStrAssetIdB], nil)
559+                                                else 0
560+                                            if ((stake2 == stake2))
561+                                                then {
562+                                                    let shareTokenST = if (stakeFarming)
563+                                                        then {
564+                                                            let stPayments = ([AttachedPayment(shareAssetId, shareTokenToPayAmount)] ++ (if ((size(pAmounts) == 3))
565+                                                                then [AttachedPayment(if ((pAssetIds[2] == base58''))
566+                                                                    then unit
567+                                                                    else pAssetIds[2], pAmounts[2])]
568+                                                                else nil))
569+                                                            let reissue = invoke(i.caller, "reissueShareToken", [shareTokenToPayAmount], nil)
570+                                                            if ((reissue == reissue))
571+                                                                then {
572+                                                                    let stake3 = invoke(farmingAddress, "lockShareTokensFromPool", [callerBytes, toString(i.caller), lockType], stPayments)
573+                                                                    if ((stake3 == stake3))
574+                                                                        then nil
575+                                                                        else throw("Strict value is not equal to itself.")
576+                                                                    }
577+                                                                else throw("Strict value is not equal to itself.")
578+                                                            }
579+                                                        else [Reissue(shareAssetId, shareTokenToPayAmount, true), ScriptTransfer(caller, shareTokenToPayAmount, shareAssetId)]
580+                                                    $Tuple2(nil, $Tuple2(([IntegerEntry(kBalanceA, (balanceA + pmtAmountA)), IntegerEntry(kBalanceB, (balanceB + pmtAmountB)), IntegerEntry(kShareAssetSupply, (shareAssetSupply + shareTokenToPayAmount)), ScriptTransfer(caller, change, changeAssetId)] ++ shareTokenST), nil))
581+                                                    }
582+                                                else throw("Strict value is not equal to itself.")
583+                                            }
584+                                        else throw("Strict value is not equal to itself.")
585+                                    }
586+                        }
587+    }))
588+
589+
590+
591+@Callable(i)
592+func replenishWithOneToken (callerBytes,args,pAmounts,pAssetIds) = valueOrElse(isOraclePool(toString(i.caller)), valueOrElse(isActive(), {
593+    let caller = Address(callerBytes)
594+    let pmtAssetId = parsePaymentAsset(pAssetIds[0])
595+    let pmtAmount = pAmounts[0]
596+    let virtGetMinAmount = parseIntValue(args[0])
597+    let stakeFarming = (args[1] == "true")
598+    let lockType = parseIntValue(args[2])
599+    let $t02413824228 = getPoolAssets(i.caller)
600+    let strAssetIdA = $t02413824228._1
601+    let strAssetIdB = $t02413824228._2
602+    let assetIdA = $t02413824228._3
603+    let assetIdB = $t02413824228._4
604+    let shareAssetId = $t02413824228._5
605+    let $t02424124365 = getPoolBalances(i.caller, assetIdA, assetIdB)
606+    let balanceA = $t02424124365._1
607+    let balanceB = $t02424124365._2
608+    let accountBalanceA = $t02424124365._3
609+    let accountBalanceB = $t02424124365._4
610+    let shareAssetSupply = $t02424124365._5
611+    let initial = ((balanceA + balanceB) == 0)
612+    if ((size(args) != 3))
613+        then throw("Wrong args size")
614+        else if (if ((size(pAmounts) != 1))
615+            then (size(pAmounts) != 2)
616+            else false)
617+            then throw("Two or one attached assets expected")
618+            else if (if ((pmtAssetId != assetIdA))
619+                then (pmtAssetId != assetIdB)
620+                else false)
621+                then throw(((("Incorrect asset attached. Expected: " + strAssetIdA) + " or ") + strAssetIdB))
622+                else if (initial)
623+                    then throw("For initial exchanger you need to use two tokens")
624+                    else if (if ((balanceA > accountBalanceA))
625+                        then true
626+                        else (balanceB > accountBalanceB))
627+                        then $Tuple2(nil, ([ScriptTransfer(caller, pmtAmount, pmtAssetId)] ++ (if ((size(pAmounts) == 2))
628+                            then [AttachedPayment(if ((pAssetIds[2] == base58''))
629+                                then unit
630+                                else pAssetIds[2], pAmounts[2])]
631+                            else (nil ++ suspendSuspicious(accountBalanceA, accountBalanceB, balanceA, balanceB, strAssetIdA, strAssetIdB)))))
632+                        else {
633+                            let $t02542125479 = getFeeParams(i.caller, i.originCaller)
634+                            let fee = $t02542125479._1
635+                            let govFee = $t02542125479._2
636+                            let $t02549627834 = if ((pmtAssetId == assetIdA))
637+                                then {
638+                                    let virtPayAmount = calculateVirtPay(pmtAmount, balanceA, fee)
639+                                    let $t02577525912 = calculateFees(virtPayAmount, virtGetMinAmount, balanceA, balanceB, fee, govFee)
640+                                    let amountWithoutFee = $t02577525912._1
641+                                    let amountWithFee = $t02577525912._2
642+                                    let governanceReward = $t02577525912._3
643+                                    let balanceAVirt = (balanceA + virtPayAmount)
644+                                    let balanceBVirt = ((balanceB + amountWithoutFee) - governanceReward)
645+                                    let newBalanceA = (balanceA + pmtAmount)
646+                                    let newBalanceB = (balanceB - governanceReward)
647+                                    let ratioShareTokensInA = fraction(toBigInt((pmtAmount - virtPayAmount)), scale16, toBigInt(balanceAVirt))
648+                                    let ratioShareTokensInB = fraction(toBigInt(amountWithFee), scale16, toBigInt(balanceBVirt))
649+                                    let shareTokenToPayAmount = toInt(fraction(min([ratioShareTokensInA, ratioShareTokensInB]), toBigInt(shareAssetSupply), scale16))
650+                                    $Tuple7(newBalanceA, newBalanceB, shareTokenToPayAmount, governanceReward, assetIdB, strAssetIdB, strAssetIdA)
651+                                    }
652+                                else {
653+                                    let virtPayAmount = calculateVirtPay(pmtAmount, balanceB, fee)
654+                                    let $t02687327010 = calculateFees(virtPayAmount, virtGetMinAmount, balanceB, balanceA, fee, govFee)
655+                                    let amountWithoutFee = $t02687327010._1
656+                                    let amountWithFee = $t02687327010._2
657+                                    let governanceReward = $t02687327010._3
658+                                    let balanceAVirt = ((balanceA + amountWithoutFee) - governanceReward)
659+                                    let balanceBVirt = (balanceB + virtPayAmount)
660+                                    let newBalanceA = (balanceA - governanceReward)
661+                                    let newBalanceB = (balanceB + pmtAmount)
662+                                    let ratioShareTokensInA = fraction(toBigInt(amountWithFee), scale16, toBigInt(balanceAVirt))
663+                                    let ratioShareTokensInB = fraction(toBigInt((pmtAmount - virtPayAmount)), scale16, toBigInt(balanceBVirt))
664+                                    let shareTokenToPayAmount = toInt(fraction(min([ratioShareTokensInA, ratioShareTokensInB]), toBigInt(shareAssetSupply), scale16))
665+                                    $Tuple7(newBalanceA, newBalanceB, shareTokenToPayAmount, governanceReward, assetIdA, strAssetIdA, strAssetIdB)
666+                                    }
667+                            let newBalanceA = $t02549627834._1
668+                            let newBalanceB = $t02549627834._2
669+                            let shareTokenToPayAmount = $t02549627834._3
670+                            let govReward = $t02549627834._4
671+                            let govRewardAsset = $t02549627834._5
672+                            let govRewardAssetStr = $t02549627834._6
673+                            let pmtAssetIdStr = $t02549627834._7
674+                            if ((shareTokenToPayAmount == 0))
675+                                then throw("Too small amount to replenish")
676+                                else {
677+                                    let stake1 = if (contains(stakingAssets, pmtAssetIdStr))
678+                                        then invoke(i.caller, "stakeUnstake", [true, pmtAmount, pmtAssetIdStr], nil)
679+                                        else 0
680+                                    if ((stake1 == stake1))
681+                                        then {
682+                                            let stake2 = if (contains(stakingAssets, govRewardAssetStr))
683+                                                then invoke(i.caller, "stakeUnstake", [false, govReward, govRewardAssetStr], nil)
684+                                                else 0
685+                                            if ((stake2 == stake2))
686+                                                then {
687+                                                    let shareTokenST = if (stakeFarming)
688+                                                        then {
689+                                                            let stPayments = ([AttachedPayment(shareAssetId, shareTokenToPayAmount)] ++ (if ((size(pAmounts) == 2))
690+                                                                then [AttachedPayment(if ((pAssetIds[1] == base58''))
691+                                                                    then unit
692+                                                                    else pAssetIds[1], pAmounts[1])]
693+                                                                else nil))
694+                                                            let reissue = invoke(i.caller, "reissueShareToken", [shareTokenToPayAmount], nil)
695+                                                            if ((reissue == reissue))
696+                                                                then {
697+                                                                    let stake3 = invoke(farmingAddress, "lockShareTokensFromPool", [callerBytes, toString(i.caller), lockType], stPayments)
698+                                                                    if ((stake3 == stake3))
699+                                                                        then nil
700+                                                                        else throw("Strict value is not equal to itself.")
701+                                                                    }
702+                                                                else throw("Strict value is not equal to itself.")
703+                                                            }
704+                                                        else [Reissue(shareAssetId, shareTokenToPayAmount, true), ScriptTransfer(caller, shareTokenToPayAmount, shareAssetId)]
705+                                                    $Tuple2(nil, $Tuple2(([IntegerEntry(kBalanceA, newBalanceA), IntegerEntry(kBalanceB, newBalanceB), IntegerEntry(kShareAssetSupply, (shareAssetSupply + shareTokenToPayAmount)), ScriptTransfer(moneyBoxAddress, govReward, govRewardAsset)] ++ shareTokenST), nil))
706+                                                    }
707+                                                else throw("Strict value is not equal to itself.")
708+                                            }
709+                                        else throw("Strict value is not equal to itself.")
710+                                    }
711+                            }
712+    }))
713+
714+
715+
716+@Callable(i)
717+func withdraw (callerBytes,args,pAmounts,pAssetIds) = valueOrElse(isOraclePool(toString(i.caller)), valueOrElse(isActive(), {
718+    let time = lastBlock.timestamp
719+    let caller = Address(callerBytes)
720+    let $t02998830078 = getPoolAssets(i.caller)
721+    let strAssetIdA = $t02998830078._1
722+    let strAssetIdB = $t02998830078._2
723+    let assetIdA = $t02998830078._3
724+    let assetIdB = $t02998830078._4
725+    let shareAssetId = $t02998830078._5
726+    let $t03009130215 = getPoolBalances(i.caller, assetIdA, assetIdB)
727+    let balanceA = $t03009130215._1
728+    let balanceB = $t03009130215._2
729+    let accountBalanceA = $t03009130215._3
730+    let accountBalanceB = $t03009130215._4
731+    let shareAssetSupply = $t03009130215._5
732+    let $t03022830636 = if ((size(pAmounts) == 1))
733+        then {
734+            let pAsset = parsePaymentAsset(pAssetIds[0])
735+            if ((pAsset != shareAssetId))
736+                then throw(("Incorrect asset attached. Expected: " + toBase58String(shareAssetId)))
737+                else $Tuple2(pAmounts[0], pAsset)
738+            }
739+        else $Tuple2(0, shareAssetId)
740+    let pmtAmount = $t03022830636._1
741+    let pmtAssetId = $t03022830636._2
742+    if ((size(args) != 1))
743+        then throw("Wrong args size")
744+        else if ((size(pAmounts) > 1))
745+            then throw("One attached payment expected")
746+            else if (if ((balanceA > accountBalanceA))
747+                then true
748+                else (balanceB > accountBalanceB))
749+                then $Tuple2(nil, ([ScriptTransfer(caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious(accountBalanceA, accountBalanceB, balanceA, balanceB, strAssetIdA, strAssetIdB)))
750+                else {
751+                    let unlockAmount = parseIntValue(valueOrElse(args[0], "0"))
752+                    let unlock = if ((unlockAmount > 0))
753+                        then invoke(farmingAddress, "withdrawShareTokensFromPool", [callerBytes, toString(i.caller), unlockAmount], nil)
754+                        else 0
755+                    if ((unlock == unlock))
756+                        then {
757+                            let withdrawAmount = (pmtAmount + unlockAmount)
758+                            let amountToPayA = fraction(withdrawAmount, balanceA, shareAssetSupply)
759+                            let amountToPayB = fraction(withdrawAmount, balanceB, shareAssetSupply)
760+                            let stake1 = if (contains(stakingAssets, strAssetIdA))
761+                                then invoke(i.caller, "stakeUnstake", [false, amountToPayA, strAssetIdA], nil)
762+                                else 0
763+                            if ((stake1 == stake1))
764+                                then {
765+                                    let stake2 = if (contains(stakingAssets, strAssetIdB))
766+                                        then invoke(i.caller, "stakeUnstake", [false, amountToPayB, strAssetIdB], nil)
767+                                        else 0
768+                                    if ((stake2 == stake2))
769+                                        then $Tuple2([ScriptTransfer(i.caller, unlockAmount, shareAssetId)], $Tuple2([IntegerEntry(kBalanceA, (balanceA - amountToPayA)), IntegerEntry(kBalanceB, (balanceB - amountToPayB)), IntegerEntry(kShareAssetSupply, (shareAssetSupply - withdrawAmount)), Burn(shareAssetId, withdrawAmount), ScriptTransfer(caller, amountToPayA, assetIdA), ScriptTransfer(caller, amountToPayB, assetIdB)], nil))
770+                                        else throw("Strict value is not equal to itself.")
771+                                    }
772+                                else throw("Strict value is not equal to itself.")
773+                            }
774+                        else throw("Strict value is not equal to itself.")
775+                    }
776+    }))
777+
778+
779+
780+@Callable(i)
781+func withdrawOneToken (callerBytes,args,pAmounts,pAssetIds) = valueOrElse(isOraclePool(toString(i.caller)), valueOrElse(isActive(), {
782+    let caller = Address(callerBytes)
783+    let withdrawAsset = if ((args[0] == ""))
784+        then unit
785+        else fromBase58String(args[0])
786+    let $t03294733037 = getPoolAssets(i.caller)
787+    let strAssetIdA = $t03294733037._1
788+    let strAssetIdB = $t03294733037._2
789+    let assetIdA = $t03294733037._3
790+    let assetIdB = $t03294733037._4
791+    let shareAssetId = $t03294733037._5
792+    let $t03305033174 = getPoolBalances(i.caller, assetIdA, assetIdB)
793+    let balanceA = $t03305033174._1
794+    let balanceB = $t03305033174._2
795+    let accountBalanceA = $t03305033174._3
796+    let accountBalanceB = $t03305033174._4
797+    let shareAssetSupply = $t03305033174._5
798+    let $t03318733567 = if ((size(pAmounts) == 1))
799+        then {
800+            let pAsset = parsePaymentAsset(pAssetIds[0])
801+            if ((pAsset != shareAssetId))
802+                then throw(("Incorrect asset attached. Expected: " + toBase58String(shareAssetId)))
803+                else $Tuple2(pAmounts[0], pAsset)
804+            }
805+        else $Tuple2(0, shareAssetId)
806+    let pmtAmount = $t03318733567._1
807+    let pmtAssetId = $t03318733567._2
808+    let virtMinToRecive = parseIntValue(args[1])
809+    if ((size(args) != 3))
810+        then throw("Wrong args size")
811+        else if ((size(pAmounts) > 1))
812+            then throw("One attached payment expected")
813+            else if ((pmtAssetId != shareAssetId))
814+                then throw(("Incorrect asset attached. Expected: " + toBase58String(shareAssetId)))
815+                else if (!(containsElement([assetIdA, assetIdB], withdrawAsset)))
816+                    then throw("Incorrect withdraw asset.")
817+                    else if (if ((balanceA > accountBalanceA))
818+                        then true
819+                        else (balanceB > accountBalanceB))
820+                        then $Tuple2(nil, ([ScriptTransfer(caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious(accountBalanceA, accountBalanceB, balanceA, balanceB, strAssetIdA, strAssetIdB)))
821+                        else {
822+                            let unlockAmount = parseIntValue(valueOrElse(args[2], "0"))
823+                            let unlock = if ((unlockAmount > 0))
824+                                then invoke(farmingAddress, "withdrawShareTokensFromPool", [callerBytes, toString(i.caller), unlockAmount], nil)
825+                                else 0
826+                            if ((unlock == unlock))
827+                                then {
828+                                    let withdrawAmount = (pmtAmount + unlockAmount)
829+                                    let amountToPayA = fraction(withdrawAmount, balanceA, shareAssetSupply)
830+                                    let amountToPayB = fraction(withdrawAmount, balanceB, shareAssetSupply)
831+                                    let $t03491534973 = getFeeParams(i.caller, i.originCaller)
832+                                    let fee = $t03491534973._1
833+                                    let govFee = $t03491534973._2
834+                                    let $t03499035390 = if ((withdrawAsset == assetIdA))
835+                                        then calculateFees(amountToPayB, virtMinToRecive, (balanceB - amountToPayB), (balanceA - amountToPayA), fee, govFee)
836+                                        else calculateFees(amountToPayA, virtMinToRecive, (balanceA - amountToPayA), (balanceB - amountToPayB), fee, govFee)
837+                                    let amountWithoutFee = $t03499035390._1
838+                                    let amountWithFee = $t03499035390._2
839+                                    let governanceReward = $t03499035390._3
840+                                    let $t03540736753 = if ((withdrawAsset == assetIdA))
841+                                        then {
842+                                            let unstake = if (contains(stakingAssets, strAssetIdA))
843+                                                then invoke(i.caller, "stakeUnstake", [false, ((amountToPayA + amountWithFee) + governanceReward), strAssetIdA], nil)
844+                                                else 0
845+                                            if ((unstake == unstake))
846+                                                then $Tuple4((((balanceA - amountToPayA) - amountWithFee) - governanceReward), balanceB, assetIdA, [ScriptTransfer(caller, (amountToPayA + amountWithFee), assetIdA)])
847+                                                else throw("Strict value is not equal to itself.")
848+                                            }
849+                                        else {
850+                                            let unstake = if (contains(stakingAssets, strAssetIdB))
851+                                                then invoke(i.caller, "stakeUnstake", [false, ((amountToPayB + amountWithFee) + governanceReward), strAssetIdB], nil)
852+                                                else 0
853+                                            if ((unstake == unstake))
854+                                                then $Tuple4(balanceA, (((balanceB - amountToPayB) - amountWithFee) - governanceReward), assetIdB, [ScriptTransfer(caller, (amountToPayB + amountWithFee), assetIdB)])
855+                                                else throw("Strict value is not equal to itself.")
856+                                            }
857+                                    let newBalanceA = $t03540736753._1
858+                                    let newBalanceB = $t03540736753._2
859+                                    let govRewardAssetId = $t03540736753._3
860+                                    let userTransfer = $t03540736753._4
861+                                    $Tuple2([ScriptTransfer(i.caller, unlockAmount, shareAssetId)], $Tuple2(([IntegerEntry(kBalanceA, newBalanceA), IntegerEntry(kBalanceB, newBalanceB), IntegerEntry(kShareAssetSupply, (shareAssetSupply - withdrawAmount)), Burn(shareAssetId, withdrawAmount), ScriptTransfer(moneyBoxAddress, governanceReward, govRewardAssetId)] ++ userTransfer), nil))
862+                                    }
863+                                else throw("Strict value is not equal to itself.")
864+                            }
865+    }))
866+
867+
868+
869+@Callable(i)
870+func takeIntoAccountExtraFunds (callerBytes,args,pAmounts,pAssetIds) = valueOrElse(isOraclePool(toString(i.caller)), valueOrElse(isActive(), {
871+    let $t03747837554 = getPoolAssets(i.caller)
872+    let strAssetIdA = $t03747837554._1
873+    let strAssetIdB = $t03747837554._2
874+    let assetIdA = $t03747837554._3
875+    let assetIdB = $t03747837554._4
876+    let claim = if (if ((assetIdA == USDN))
877+        then true
878+        else (assetIdB == USDN))
879+        then invoke(i.caller, "claimNetrinoRewards", nil, nil)
880+        else 0
881+    if ((claim == claim))
882+        then {
883+            let $t03773037836 = getPoolBalances(i.caller, assetIdA, assetIdB)
884+            let balanceA = $t03773037836._1
885+            let balanceB = $t03773037836._2
886+            let accountBalanceA = $t03773037836._3
887+            let accountBalanceB = $t03773037836._4
888+            let amountEnrollA = (accountBalanceA - balanceA)
889+            let amountEnrollB = (accountBalanceB - balanceB)
890+            if ((size(args) != 0))
891+                then throw("Wrong args size")
892+                else if ((moneyBoxAddress != i.originCaller))
893+                    then throw("Only the wallet can call this function")
894+                    else if (if ((0 > amountEnrollA))
895+                        then true
896+                        else (0 > amountEnrollB))
897+                        then suspend("Enroll amount negative")
898+                        else if (if ((amountEnrollA == 0))
899+                            then (amountEnrollB == 0)
900+                            else false)
901+                            then throw("No money to take")
902+                            else {
903+                                let stake1 = if (if (contains(stakingAssets, strAssetIdA))
904+                                    then (amountEnrollA > 0)
905+                                    else false)
906+                                    then invoke(i.caller, "stakeUnstake", [true, amountEnrollA, strAssetIdA], nil)
907+                                    else 0
908+                                if ((stake1 == stake1))
909+                                    then {
910+                                        let stake2 = if (if (contains(stakingAssets, strAssetIdB))
911+                                            then (amountEnrollB > 0)
912+                                            else false)
913+                                            then invoke(i.caller, "stakeUnstake", [true, amountEnrollB, strAssetIdB], nil)
914+                                            else 0
915+                                        if ((stake2 == stake2))
916+                                            then $Tuple2(nil, $Tuple2([IntegerEntry(kBalanceA, (balanceA + amountEnrollA)), IntegerEntry(kBalanceB, (balanceB + amountEnrollB))], nil))
917+                                            else throw("Strict value is not equal to itself.")
918+                                        }
919+                                    else throw("Strict value is not equal to itself.")
920+                                }
921+            }
922+        else throw("Strict value is not equal to itself.")
923+    }))
924+
925+
926+@Verifier(tx)
927+func verify () = {
928+    let multiSignedByAdmins = {
929+        let adminPubKey1Signed = if (sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey1))
930+            then 1
931+            else 0
932+        let adminPubKey2Signed = if (sigVerify(tx.bodyBytes, tx.proofs[1], adminPubKey2))
933+            then 1
934+            else 0
935+        let adminPubKey3Signed = if (sigVerify(tx.bodyBytes, tx.proofs[2], adminPubKey3))
936+            then 1
937+            else 0
938+        (((adminPubKey1Signed + adminPubKey2Signed) + adminPubKey3Signed) >= 2)
939+        }
940+    multiSignedByAdmins
941+    }
942+
github/deemru/w8io/169f3d6 
49.60 ms ◑