diff --git a/api/spec/openapi.gen.go b/api/spec/openapi.gen.go index 94fc1a9e4..0b3bfaac5 100644 --- a/api/spec/openapi.gen.go +++ b/api/spec/openapi.gen.go @@ -20,209 +20,209 @@ import ( var swaggerSpec = []string{ "H4sIAAAAAAAC/+x963Ibt9Lgq6C4WxW7lqTsXM75ov2ziiQnzLEtfZJs16nYxYJmQBLWcDABMKL5pbS1", - "r7Gvt0+yhQYwA8xgbpSo+JzoV2JxcGt0N/ref4wits5YSlIpRod/jES0ImsM/3sURUSIK3ZD0gsiMpYK", - "ov4cExFxmknK0tHh6A2LSYIWjCP9OYLvkR0wHY1HGWcZ4ZISmBXDZ3OpPqtPd7UiSH+B4AtEhchJjK63", - "SKqfcrlinP4XVp8jQfgt4WoJuc3I6HAkJKfpcnQ3HnkfzmMiMU1EfbmL0/98N7s4PUGbFUlRcBDKMMdr", - "IglHVKBckBhJhjj5PSdCwvZwGhHEFgijiHCJaYqOOYlJKilOkNoZwgLFZEFTEiOaoksSwfZ/mL6cvpyi", - "mURv3l1eobdnV+ia6BWYXBG+oYLAz1QgnCLMOd6qddj1ZxJJMW6Y9u/qm98uXh3/+N2Pf/ukoEMlWcPh", - "/zsni9HhaHoQsfWapdMtXif/7aBEgANz+wdHLiRODPTuCjjDVtS/o3nK0iiAFpdwEyhiqQKI+l+M4FMF", - "PHtKyVDECZYEYZRxpo62QBkTggihTsIW6IZs0RpLwhUs4ZIM5PWUUQHoIBaY7c3Jl4xyIuY0gHGzVJIl", - "4SgmKYNZFZ4ldEEkXRMFV0EilsZC7Ub9ZOZ01qN6BrVg20JX7fO6WB+enJMFJ2LVRjrmEz3LGG1WNFqh", - "CKcuyNk14GhKNt6aIghBEbEscL1n51ezs7dHr8eILhCFK4gUsjM4CgyyF1USb5RQksr/WSL3GFn6C64N", - "25rrP4cOC6RloOcyi8BkAL3fc8pJPDr8zedB3kKfxiNJZaLGhthfMbGmwdF49GUi8VKoSRmNo+8jOvp0", - "Nx4dRTennDPezDePohvEG5kkUYPrg2BO5Pyt+6h6Ju9YN7sc50Lf5tCDlAQK/6xyojDziTKz2kySdZ3t", - "VE7oLlE9p95z/2N6CweO6v1eu7RbkgYAdOWgqWIxCxrp5wu+D2I+/DL3pqnO+ku+xumEExzj64Sgo8vj", - "2QxJ8kUqTnpLY+CPcUzV5zhBNF0wvoZ1xwUnwEJQIWFjzos1U0SksOyWJOp4ilflaUy4kDiNLYeELSK5", - "whKxKMo5D9LdeAQkyeeaRywoCWD1WWY3qVcuvw3O6MJwTuMwRs5OukmjOpGBOyCRhy9349FPWEarEkiN", - "1FCKQ2ezk2N0rYa5wDVMsY1Q5uab/gRT31d/milXc2in4bR96ag2vFt4BGj9VIdWI19pEjx+vTx7i8Tj", - "SB/H95c+YLv0IUUQ72o1+HxMYik5W4wOf/ujtuP+WKbnrdzz6O7TILyzm2tDvIEPVTn0mKULusw5ULe4", - "zLOMcUlC3CI1ArVmZvrHayKQyEik+EMBdleqV5+G+abQSwlXNQjgb4LpOqCQvGIcrQWbr2MWIZzG6Db6", - "HyKefN5IdBshlibbKTrT2/WwO1GMnC1Qitfk4BYnOUEZplwoGZBwggiOVvBjyV2Fkp/VNhC+Zrk+jsj1", - "3GyxIFyrFf4pp0hJXnoBI1fiFAQ6JPJoZUH5LNWSX4wlVtSYRzLnRDwfI8Y9XcYZ5AqgJeN1MAZ0HWqf", - "w966TLn5k3ICf2ZBlwqOc5ws53A2MRctGGM3H2FBkCCpoJLeEsN1hEYOA2ajtiZLxqlcrUWJOQZdckGU", - "AI7UFuDvRuH1eUtBvHUhuaqR8W0m2ZLjbEWj+TWFF3u+JnLF4gc81YptqvhPBbpmeRpbLaB8xi0Bnabx", - "5J0gHG1WzHJadXofwwYdN6YiS/A2SNZ1hdmhBeYRkd6EmQyVpGp3XsDN0Tjh3Sp1/gSnyxwvSUjh7sJL", - "c4jQ+VgUVoA8RlGwBqN222uyb0nFHlG1HPw2uzybvvyPFy+/m/zwKfiUaeExAGXkvrfVZfUoDUMqHNCN", - "EZ2S6Rh93sj5bTT/LNRzy1ESZ/PbaIpOSEa0pMlSdyIgzTH8pXp9i5wDEyIJWSso6+PZjWgjTBqjZ8zI", - "msn2OcowlzTKE8w1H9RI4Fzwm6N/2hVgtCNEG54JZMAKxPHHByHJeBySgQvq04qy4srArTU30sSneDzs", + "r7Gvt0+yhQYwA8xgbpSo+JzoV2IRg0uju9H3/mMUsXXGUpJKMTr8YySiFVlj+N+jKCJCXLEbkl4QkbFU", + "EPXnmIiI00xSlo4OR29YTBK0YBzp4QjGI/vBdDQeZZxlhEtKYFYMw+ZSDatPd7UiSI9AMAJRIXISo+st", + "kuqnXK4Yp/+F1XAkCL8lXC0htxkZHY6E5DRdju7GI2/gPCYS00TUl7s4/c93s4vTE7RZkRQFP0IZ5nhN", + "JOGICpQLEiPJECe/50RI2B5OI4LYAmEUES4xTdExJzFJJcUJUjtDWKCYLGhKYkRTdEki2P4P05fTl1M0", + "k+jNu8sr9PbsCl0TvQKTK8I3VBD4mQqEU4Q5x1u1Drv+TCIpxg3T/l2N+e3i1fGP3/34t08KOlSSNRz+", + "v3OyGB2OpgcRW69ZOt3idfLfDkoEODC3f3DkQuLEQO+ugDNsRf07mqcsjQJocQk3gSKWKoCo/8UIhirg", + "2VNKhiJOsCQIo4wzdbQFypgQRAh1ErZAN2SL1lgSrmAJl2Qgr6eMCkAHscBsb06+ZJQTMacBjJulkiwJ", + "RzFJGcyq8CyhCyLpmii4ChKxNBZqN+onM6ezHtUzqAXbFrpqn9fF+vDknCw4Eas20jFD9CxjtFnRaIUi", + "nLogZ9eAoynZeGuKIARFxLLA9Z6dX83O3h69HiO6QBSuIFLIzuAo8JG9qJJ4o4SSVP7PErnHyNJfcG3Y", + "1lz/OXRYIC0DPZdZBCYD6P2eU07i0eFvPg/yFvo0HkkqE/VtiP0VE2saHI1HXyYSL4WalNE4+j6io093", + "49FRdHPKOePNfPMoukG8kUkS9XH9I5gTOX/rPqqeyTvWzS7HudC3OfQgJYHCP6ucKMx8osysNpNkXWc7", + "lRO6S1TPqffc/5jewoGjer/XLu2WpAEAXTloqljMgkb6+YLxQcyHX+beNNVZf8nXOJ1wgmN8nRB0dHk8", + "myFJvkjFSW9pDPwxjqkajhNE0wXja1h3XHACLAQVEjbmvFgzRUQKy25Joo6neFWexoQLidPYckjYIpIr", + "LBGLopzzIN2NR0CSfK55xIKSAFafZXaTeuVybHBGF4ZzGocxcnbSTRrViQzcAYk8fLkbj37CMlqVQGqk", + "hlIcOpudHKNr9ZkLXMMU2whlbsb0J5j6vvrTTLmaQzsNp+1LR7XPu4VHgNZPdWg18pUmwePXy7O3SDyO", + "9HF8f+kDtksfUgTxrlaDz8cklpKzxejwtz9qO+6PZXreyj2P7j4Nwju7uTbEG/hQlZ8es3RBlzkH6haX", + "eZYxLkmIW6RGoNbMTP94TQQSGYkUfyjA7kr1amiYbwq9lHBVgwD+JpiuAwrJK8bRWrD5OmYRwmmMbqP/", + "IeLJ541EtxFiabKdojO9XQ+7E8XI2QKleE0ObnGSE5RhyoWSAQkniOBoBT+W3FUo+VltA+FrluvjiFzP", + "zRYLwrVa4Z9yipTkpRcwciVOQaBDIo9WFpTPUi35xVhiRY15JHNOxPMxYtzTZZyPXAG0ZLwOxoCuQ+1z", + "2FuXKTd/Uk7gzyzoUsFxjpPlHM4m5qIFY+zmIywIEiQVVNJbYriO0MhhwGzU1mTJOJWrtSgxx6BLLogS", + "wJHaAvzdKLw+bymIty4kVzUyvs0kW3KcrWg0v6bwYs/XRK5Y/ICnWrFNFf+pQNcsT2OrBZTPuCWg0zSe", + "vBOEo82KWU6rTu9j2KDjxlRkCd4GybquMDu0wDwi0pswk6GSVO3OC7g5Gie8W6XOn+B0meMlCSncXXhp", + "DhE6H4vCCpDHKArWYNRue032LanYI6qWg99ml2fTl//x4uV3kx8+BZ8yLTwGoIzc97a6rP5Kw5AKB3Rj", + "RKdkOkafN3J+G80/C/XccpTE2fw2mqITkhEtabLUnQhIcwx/qV7fIufAhEhC1grK+nh2I9oIk8boGTOy", + "ZrJ9jjLMJY3yBHPNBzUSOBf85uifdgX42hGiDc8EMmAF4vjfByHJeBySgQvq04qy4srArTU30sSneDzs", "cW35Mkym/m+LxIrlSaz4sdlMqXd/wElC5DC6AoEIVOIK0yh1inPvQWvD9HM1mVKDymdYobavBPR7g5VE", - "Bnt7Jp73eYWDb0qDUaMdmbVRQ798ZmEq2t5/xR7gGxfP2pHjNpJhSg9IAYbUY6JeDiw9VAdj5LFDbj69", - "r6TMxOHBgXqdJcfRDeFTSuRiyvjyIGbRwUquk4OY44WcqL9PGM7laqJ3MLmNJi9edipXhmM4sl2nbGaJ", - "unznp62Cn1YXK3LfSfkg+BLXNY5ullw9UPOIJdq6UruAhEU4IQ0/LVkXor9W3ygVFa/DkygFvWX5nCeB", - "v9+FYGjP2QCgRvjMjFT6CxWS8e0JlriOcq2fI04yTgRw2QrDLETelf7cPMGGKbcqvSFF3iWusInQmQB4", - "VYOCVUgCkf8QimFMERQ54xzAMsBBTosP0AmWpNEgomDUMIUFePsEoSdk1st6knG2oAmZ3xIugoYlM825", - "/g6Z78IGWo5TgaNGQ8xV+Xsvg4yPDsVJA9ccZCsVXC2sB8OZyIU2ox/dYprg64T0sWA4yPouU3fb4gO7", - "JZwuqJr5XFMS4IxjVGpjMu9bB1dh2r5UEI56+426dwVS/QxhA01g+1P12gyR5kl1NR2tJlc1f6XqEPVp", - "6ePQhiXjgEAfViQtHn/fezh2JdryVyVf4nSrnSPuguZLKwmVQ4TnNjQsuYtLWpqYkxQ0RR/CPe0+p+XY", - "Ft3glSP9e6+EBl2jr8YIn13b+vXDFciVDe/jUJvlDubKXoZKHEUkk8DwG/x2vtjpWXW0V0vk10KdJpXJ", - "turF84yQGiFKZNAmS+99RimTiBOZ87QB+E+W1W7LapcZtcIwP7VQiQtVb5cLj3yCVqHhrpGAfQCn9clL", - "zUrrjoimUZLHRFjFE0c3KdskJF6CZOfy9F5qgQfMT2H63dn022SebpMvjYhad0Fc9HBtBma2dongvQ1E", - "na/wVrtlPxshELRJYXRCFoRzEqNC3nUmnKIrsBeBGUT9j4ZmaY+27BbRRYP+v8EC5Sm4RiVDdL0mMcWS", - "JFsNlharNhWtDNcuTyKwjjorb6hcwc/F2ZwfT9M4YzSVQ4TgdsKoYvfudHLqiQJBs4zD710jmHoKrSBR", - "NzW2xIAlywAn/HCKcLIsjeUDpq970NMovAJJo4dZ4fPmpg+4MBI0XSYEZfl1QiN4+LCSKX/98A+NWzvv", - "oYI4akNjAK0+fiv2OHf+EIjT4l9rxyBtRt2sCIi9HR61UmYNuOSUAN3IvcGQzDI17Or1ZQgfe/t9gm43", - "tReFXb9dvDr++w8v//bJ3avj/XmmEFyv9Nx+/B+fHPeCMdl2ncuyE8WYSBqxuMrREOMt0ADB8dcPV3YL", - "P34aaAhJo0eClyLXfwt4mcPNS4qtgusnxhKCU/MMaX0PXst26jATalucE/HjEouL/MYuHWYyaKbvpngK", - "Jbcel5aVnaWAmd0Svg3CUd2NOgpZME5cSQQUFx24RNzpbshW1J3QyCh39e0ucCLMfu3MR/9E0YoJUoCR", - "2hApf+ewFONKQXJ47bW+lHoEYYhjNBBG+P57sucHMYpfSixz0SoAC/ik/lSLYmgDlv/R8SyZCcznwVNf", - "ep8MPdZZJptiyrQTRo0FpdUTwv1j9jtL1xHUVnqe4oRknERYkviYrTMmyNns5Pj741lVX7FfjQ6BFCvH", - "LGeZoneCoAO9woGx8oqDP8z/zU7uiv9/r026dwdKt+Va5BYHgF1Ykol68yeR3tQUlTYP/ScFSLPVVoC2", - "aUcXeIPUqRMiSdWhDnEQik9EuZBsbULQQ0ZIGs8lWWdJ2Ix+EjA82c/VbtM8AdOuhWvdUXtLOKcxmTfZ", - "28/MByZssWXSgok4s5pIm3kcVJ7s1M7mbWhOTON+S2WEKzlrro4UScWWaIzDUv65/hTpT1H5aZ+VHPNb", - "D6QOXOTpl2iF0yXxkg6OWUx6GJeJHgvSRS5XCJ72BWdrG0wKrstA+BUlqZxjIdTfWEM0vX5W4G2yYQBy", - "w5QgIMZIkAxzbGQQjD6O/vfHEYpWWBEU4VqjXFAuJAgOVDgh8AhLSYS2xKtf9YOlTVEtX56zc/V12CJW", - "OVBD2PyltiIbaUFHBZXhwLlc6Uh+Sbw9ZFliY5ZNbE8oDwc9e398+VwfnKXJ1pHSivf54yjn6SElcnEI", - "dmxxCPdzqFeaFNufqO0fft7Iif2lhMPHkU6KSWPYqRNSZfa7zoX0D5NrtqUQDH07fYGOytkmP2F1/GM9", - "9KgcpQ6mAdQG8KDbUs81OwEMfX98qc3FDrcNR4Zkc7WnHs9Q8aXzFHUSUc93qWWeJrN4Id6t70uWjVlb", - "+8tgkl/MHXa8/PBZP3gP8zr+TKRxN5LYc1+0sb0lkVL7n8zI1re49AHOM8cJWF+gdC0i11uoZrT269H1", - "VpJOW0TTig4Am8/dBjhz4FbIiWwvoPMlGpxutQ337tMAYISNey0H6QuLmZHerDm1IdjmPuHPb/JE0iyp", - "aYLYOEwCAc7zOBhecmGAA/dxzsnEEpFixIpTvErYZlpyzkvCb2lEEI6kQFigs3MYudEanvM8iWZxxYko", - "hp0RYxEIsW9M18j+bk9vdF7gYTqM1JHNtKUagp1XWBhXWOkbxgup46MjIsQiT5ItwpECAfDHag5ep2Rq", - "ZPMuB2kPYawaX92Sb+RcuvtDu7fZ+udCjq8T9TBXHJTCCWOMWCpoTLi6cD1P7LKhWKkqkq5JxxZsKFbj", - "aeCDjtAiozeEg1zMjyF9w4kJQJsVTYiPBBEDB4y2+lLhSQhFauTYOjmM9mYcIkDTWm7L1dNriTOg7oiw", - "7dhyn56s4x6GiJ4rHJd4/Ug8au866tdFC6VKG8Bj+2NhH1TyKyUJON3KSS61GjpFl9Yqb9CMpst+3Cu0", - "n4dUsUML7F/bdlb9ExTvx6Nh+4hoWu2hoduBJmZGjwvRZ2HV7a8WVJi6oUYi0EbxiRuaxhAKrV/YwjMM", - "gasMLektOIffH1+2anhm//MicNNE6fqLv7t47cZqwIHMUMj1dcQJbCPy0RW+IQKpZ1pBIyJIIaxRY+cb", - "kiQ3KdsUoTFl6BcYvq+ZUqxaNqlZVHUyzCEN2drAwSCfOh51e13FKdTJNjRJChuI5noNX9K0iFzJSErj", - "SWFXtJ8dHhy0wbvYaZ+iEloEPFixBLijY6gAbDMGgfLwkUcN7y5eh3fS8hBVk4ru/ST1yhUa+IIG9Nwl", - "x6lssAoZyohwWvhgzB3DKB0qjeSKs3y5qoQ1mliN8kNHAgbDkpZ7XINA6ld4gTQqz54E1gJIqQK5WZIM", - "RBiS5mvwvXjsQH08GjfYlWBb2piUcTLBhZ6hh33qMMME0c8kP0KAW8gBaaCpiI9l+PecWKOZ8UjZCFJr", - "drum2ium3pyJiTtxzVcKIpYDFDEm9fUkQxhIg3yRSBCJ8gzFOew44+SWslwYUFqvmaEOxX3oLcS56qO5", - "iSv6kseIGh+dCRlS/zZuuTJYpmo9M/zcHj8AIm2GtBB3omFhI9N6XRyaIs/gotXFRcI2WnwKXLICdVtw", - "bBERG6aNIpKr4JCA5OYS4RjkSwacQOmrRhzXSG8EAesyqWC5ja5CJ2SB80Q/StXyL52VWIr9we+i38bc", - "WMs65YGzp9Bo/f1ppj7M+50LwucZbfN997QI9HKRVw7v2p/066v2g85nbxFOmBpracpWrjKVnVKIXnXx", - "yYBHbWUUkgH1a1Q8xnHxGjc7+xcJXgrHlm0PooST1I2JQ6AfmokV1ymz+nrIhWGpbTfRb7jM968g6/nW", - "qr5e10PwujZJ2zQVkuB4ir4+g9cDH/DPtpk9Ce9PwnvdvhB1mr6/amk+XN6h2Vz70DT9EBbfB97TDoay", - "6f2sxvsD6i6G5wfezb+m7fpJmX1SZp+U2Sdl9kmZ/Usrs/fVYruzfPuosU0pTlBBzYn3CCseNpI2LI47", - "D4/hzCV7zLBQZJyQW/VWuSk1FQbNApPDrZcePFBGfrm6Okc/n14Br4d/XJCYcvD16WUFWkNxLJ1b/J8X", - "GoMcgd4ydlDqFAAVcurqZuo5Bj1QrgjlaM2uFel+KBTacI7hl7DH3QOLZb+OUmzClTkniRF4FiglJG7I", - "eLYkHXDP+RSjwfYzSYkO/Dy7OkeZ1pkK2HbnaQUxY1yPMGtC2F3w/f25LfRS8YCDZPTu4vWlUk3CNWtc", - "nlOWVXhFE0l4j9JPbYMbZ5/F4a3k3Dpmwk9KwFL02qQcGSHQfVl0SSThZs2YQmClHQKQ9hetokqGdISc", - "dkX3fTSaWJi5lLb7vDXLhW7U5WAtNjTHXBcgsNlJd+xjcDoz+FPj2drqhwDNOsU6glFiJR82j2BrukFD", - "Pc3LQjU0qrySuxYmIDigb7QHcbQGEtEUfd6IZxqIzxHj6LNgaRI/0zM9N6YVsUMG+F6DtPYeIXVcBzOC", - "+j4BdUUbNbvsJz76mFwfn9ACGNaXcYZnv3eKUbRSr126DAF7hROcLkG8x3FMihqaUD2jycyFg1mXVyuC", - "Yken11MoNYmtqVQsTWyFJGsEJTDANmhe0w5zWplE1q9aTJkSBXUs1zj0wp7A3wecW3NE/dC/gfD8MAje", - "XcwsBOpDysTrMIR03gaJv/3hh5c/upnbbIFOZifomRE6WFkn62R28rwLms34aZGsJ4oWtW/qD/pGtnQ5", - "oQtUFnZE5PccJwJFGzlFl3SZKvXkw5VSZIuiLVBusSjc0pAHP3jFz86Kvw5fEcqEZkMX1aOm6DVNb0iM", - "oJIdALFj+U73SrlU85amusbPZaDOi15aDZ+i45xzXXVC1pNoyg8VuXzzeSO/6RY2nc05T3WBP31z/1+b", - "4ofVtHk5l+SLbKhlSDusTiCDFRVcMZCsdhM5+otSHJzSGwlbskDy/6yID2wHh9qUAwc4Vr8KipA8dF7U", - "3moSV0D/Vkjk1OB2VSSnepfS7nKaxMbbwTgJ21TQs4tXx3/7+/c/PtdKqWY9MMgYOLVCaEIJjZMQ7AL+", - "fGA/nDblwtGwyG1+FSTiJHzRNZtTs7VngMTs3pq/gpt7Vd2fXcu54+rF9WSx55xkmHfXECqlVDMi1MVg", - "Dz0fzGrlMj/hcOBXkxI9sDajnmbc1TmiAWzDgA7eZMWgjxoUma4r0O5oYPG+hXV42MH+Ms9a8v06Dbnv", - "y8xUpdpoO8/HUcRi8nHUbnF9IBoM5SD2ur6HQYVu410PXGgsT+QhQ3OmkGbF34gKM/a5Lmmu/FRtU8f7", - "FQCtcjSnqquaT9/LXMokZNDS0mpRTRJSYrXD4urqdbjuXZaLFYnnwb0Oh8750UU7THoxLKgxaCx8BOVZ", - "xNZ1BwBvq99Us28vErYZROhaQrFmj/hVwjagZ7baT4pLHjeh2bjgtQ232p/ihlkMa0+KlvESY6nY5TXq", - "QZ493skHfcIC0Bv4TgVhBQcOGZD9z5D6TidKh/hOTEka6esMq7Uf1UcfR8alZbydcWFaN27QIMIHc19O", - "NCnpRoHG2++YxUr3N7T2GNQbYvf6rysMDKehXuov8Kvxtw+CQGHVnd+vIu6FnaerNG5DTfKy2QPEInRD", - "aMc3Wy8/ruBVBb5t9ABIvSv3uCAiT/qJa706fu2j+mqJozXc/1cpsDoGRX3edEKtXFbLSYepQ/JAI52r", - "i3eniC7ceE1TRnhLJMK2RLrduLHVn53b7rw6pAYsY9YzXAa6SmbqcVbLJNsYpUrR/iJu4VmoyKZ6wZ/3", - "KN4VuQy/AIgLRguNNuIw+N2fPNq9aD62Q+alGCivO1ttWau3vynQtqWpuqNvylkTiQFRysZijvGqZ9cW", - "Hx7ajvUn9ukKtHUpDXe7s+ge5/JwsHYjfdEvF6uQYtpHqc7FqqI6mcHNEtvXpU43lc9pahPuQrwDbgPA", - "T+LhOiwM6623tpVDN1Xm03x9DaFFWFb7uBRl0Y08Ys2P7y5mbqV0KF6bMUNLRk3UVZ/cEWWRdYEMJcVU", - "RJy45VuDZaSuc6mfC7nNaISTZKszAxKsVkyg1RWX6BmZLqdjdE3khpAU/QBxK3978cJu9HlTE22ttwbN", - "09VDgIapoK3jXEO1r4rwfiagCh+8dgAyUdT+neQCWnMTTkyl/EoVaS9wph6KGA6169R33KN6rckr+N2E", - "mH2dA6Z2jUlaqb9lQv9w2mgpsOku7WaBcEEzM9Sy4R71G8e1DTnwqJwl4O7xv5iZsOfGU/c26FZW7no4", - "7PSfgltcUiEJB0ORrkbW0Y28LI1WxNGqKUy8OPQQH96t/FIXvtatqfUcEDGmLydctlt9tWvja+c7y2D0", - "qoW3NybX+XIZXryrb3onUPuTS22ixle4/V6aHQvaKRKO7KgA0PSegG6DzIul1oq/eSNK3zxJ4wl4l0xA", - "tsed2pKDgiz33cVruwWIZ92Qa5ThJXHamNfrhXfo+SCIRrJN87YyYPEG6oSkrdCGRRiPMsKypOg2QBW0", - "CulPLz92HimyxjRBOI45tDUdFlZcZjS07bpEBz+Xwa9/qF6eJGGbIsOiCPW0pRjFIarnHYzRLmkHw475", - "eXMjmgomfiO0iPKBXKN/kC26JBLFLMpB/zWtP7WdymvaGtnBZZhGuOujWrsTB+0rbb3zUXBrz3798I/n", - "3gZ32ZrfW7Bza0ZmM1KEki7AGW6jWFroIWMJjbb9FoAXUegEjJXPKTJOb3G0RXq68m4qOXO2NXBMsoRt", - "4QvGlzgtw/KTRLfjzQURY8QJQGwMApySERMmiEAZ4QJCMiFuP2yw0PHJ6mBtVGOJwX6vswdnBQ+oQLDM", - "1gWrB5BUof3VycYhxWG04HnU+lG9l7ZRJ/wIp5AXYf7a4IcKMIPhhNyQwHEZaA8lMhyRSVku1/YAcBqq", - "Nh+l1hqqM/NXsIXcYB4ORTxCeUp/z73m1Ab7QZ9A797NTp4jLISOTjJh92ZTMbkliXpnEePIrqOJW6wI", - "L0LSfeHJwB1oyrM2WNyyE+n3Nt6meG2eFG5EhQY7eXHUxmaOR7Z/Y+DAPtqX2yi+hLN8dAHa4FuG2ygc", - "WNpdtW6IzSts50V14VDJ3WJz2hjYhrspS8kYeWEgc6WMVf92jQWNpugtS0mRsKZWMbxZfyzQsxTUTISz", - "TIxtnoL6x3PL4XEK1s8VvoWazZxIUaQVHQYXDcNM3JshS8LX4D4wykDJkit3W+HQOrVOqS052FR1loRY", - "0axQpz1Bz7Rt8GbzPwDrrdDUatmO/4S2h0O2yMT3Eqs7SxZDvFZJZqXpElJITFpkVQrviKEKVoPuaMta", - "TKBr4cXBMoFXdA3MXSOiK/GVxL3Bou5ac5vYfZWqQRleFgSe/tkYV4pi4m5iFGQVl6Ul7Cb9kuYsxFI6", - "d9VaubHxSvRYbcjSE6hH44WSKaj5s+Ii+qfWq3pSm57Upie16UltelKbntSmJ7XpSW16Upv+8mqTF8xS", - "T4bwtIhWPPMlqE8dCtlgR0efMLkeDUPLbOyn5rOh/OxQy9d+wO8ZvnBJpDuNdlRKLN363/3ysd+Sjcmx", - "n3bUy98h0bmrHlxHcnIwhnh4qvSQFs+WbAFYzu11Avz+F2eDMyuh1h1tvQfHXPvz9TvikLi6S8n4Tp3j", - "hGR8cNs4FofTdVpzeR4v08CJbCpKgllwt8LpnsAe0BlsF7C39OjqOt6wDIh3WYwlqaawNyJT6+dFUI+Q", - "PI+0bJGrAer0748bG66WzCFYm+P+GflOvlDDCn6f0O6AunK22tixf57A7h0cbQd/zzt8r3tokPMSH0jc", - "kyfY/hu6zFytWJYS6DKaTp/aST61k/zq20mGSkSG8pNQBcsHlsh6pxQZQxRdXCJcs9IQfyfd3p/+uwNu", - "d2UAPauWFxUqPI3PG+TUjXTKatq3pKjgBkb/iHDgIm5eyTYjCAtT2gpqTF4a290P05fTl4DrtUqUTK4I", - "31BoAK8N4fXSyOOGaf+uvvnt4tXxj9/9+LdPoRrI+4nxrhbj0VmszbnPIVNhYVSrXLYZMMSy15Cj6BU9", - "jLtrw5UCXLGHWtpiN4b3JZWiMaWbMdKs07UXMIKfTLHTYP5hewmg5oHUibHtH0FbRObejUe/5ySU2uTQ", - "jQsA9J/q84B+WrksPWtxsLEDIGfT7sW1wjugDsOArVPGeUWim6a8Ov1xMFvKsaUsME1yTlCkpkKG6YSK", - "VZHoJnTPahScpzl+tz4MAmXRmgiBl2Tnsk7vnW+a39Kqrg0HsTsLLlS9oQaA986bqk7SVd7OuTF3d8P6", - "FT5OIbqeBdqqEHArtDUk4rVcwrAqiU1rt9Zvu63Szr7Ltz1QPbS7Zqj1KSnWCrg+8lLBYbw0TdGFx4qq", - "+pe6aSPKtjTIxgMNBInLrPtwYK9I878MD27lmzXqbILJPUDbxSY9sLYj2CA25e6hYFR+Ydqg4lRuZm8M", - "t65BBVupN8DyHncxhGlmlU7xOwiNfz7fDB3+HvAbyjsH4PZOzLOJXLvZZ/BUvSHzgSTJP1K2Sc8yks5O", - "dC51R0f67jHVzFXTWdb/wgAXBCwsiPGyvj++1PYlSGSdnZzvXv3JaRp1dv6NcO1BnjnrtC3S8BrLaOWW", - "I+m1Xi1z/htRLztXrGtzUl9rxT8X2hy3kjITCPBEWzbeHP2zMExmjMsxyrBcwU+g6jimiRLR3Lqp44a0", - "/pgRXTHCmPDgs+b9DunqVCkAUFbyPvfutJ993EMhUebY3413bkgeKvnRXPfAte+Ya2OeNxzC14zNIsVr", - "cuCUmRyb4pkERysdswspyPXIHbO10p5aqzxjDxR3OWl3xtbHx9NO37CFT2tNiV5NO1oumBOZ89QvFe2u", - "7Zr/0rptvLAS2vYehss5zW10BxCurlybtNViZv06scY6AKc0qS9w4sUchFucNzVsv2q47q7o93uVY2qL", - "cKgQsa4Z8yD8NlSA5oFQebwvntu653DNMJEleNurd57Hf6psy0yEyqdWm7DrG4cOWoVpW+nVuVFYesk7", - "jtnA7L09bLyN2CF4WR/TC820HBie/uLV/xkCWq+2tehMCg083do2/c3KXsGpnXH1rTPLV4+k4c32cHHp", - "W8UpS7drlou5DnrtvGDL0h12GejAZGP1cKWzErBbHGzzpAuZyBXLpcJom6qjXZqW8bazXDckdoAoeqKD", - "Ya0b8sINrG2FqB9c/XC04c37gOShnSQPt8/fTKntT8Ewayqsb3rH3UJ09NzmmDXGgdumehiJoki+odZf", - "P1yVTLVOUEX6mlNnHIt6xF1TEPIQLUfTQSs6NUee3uvO2kKghSPXQhg6FbVo6JOS9j6OUpaamsk7VFrr", - "pasOccrdgb9rwXS0GeRTQYWVNabJ6HC0IknC/pfkuZDXCYumMbkdjUc6LHF0pf78U8IiJAleT6GPJAxS", - "DP3w4MAfVlNqyuGgJBuO7OgGhXKiGL9rpDABER++O0bvjydH5zO3GZ2GzPfvoQSwZBFze/ocWGuBG86g", - "x5Ut4RIaEWNLMSc9ynC0IpNvpy9qh9xsNlMMP08ZXx6YseLg9ez49O3lqRozlV+05aPmlnMpylYWgjAU", - "7TjS0VCjF1O1MHhDSIozOjocfTd9AXtRDyOg0IE5n2MUPxBFuFbGmsPJhAvyMkhMiU3YtsYanTPhRE8K", - "E0pVVLf6icVbi0FEU7UTdXPwWWihWstMXRJVe1TW3d2d827A6b598WLQ4lUvaw0zz/4BRCfy9RrzbRek", - "6jQ1Lq5jyVmeiYM/4L+zk7vA/Rz8of87O7lTm1uG0lIviOSU3Jq4px739TMJXlfm9JP4raGR7c9qqybW", - "lqq/Kxwrid6cZORainWjkhqAS+Nn/d3RJw4vIcpf+6/x6dGRoseltKGGw4DEgenwW4qXOrjLBlGF6ffU", - "DAq2Ia0GuRYF0evIYudpidbdB513LvsApL7j+uYF7YMFu13CENzIdCHYCQhVEyVtAZb818Qp3x9GEFNC", + "Bnt7Jp73eYWDb0qDUaMdmbVRQ798ZmEq2t5/xR5gjItn7chxG8kwpQekAEPqMVEvB5YeqoMx8tghN5/e", + "V1Jm4vDgQL3OkuPohvApJXIxZXx5ELPoYCXXyUHM8UJO1N8nDOdyNdE7mNxGkxcvO5UrwzEc2a5TNrNE", + "Xb7z01bBT6uLFbnvpHwQfInrGkc3S64eqHnEEm1dqV1AwiKckIaflqwL0V+rMUpFxevwJEpBb1k+50ng", + "73chGNpzNgCoET4zI5X+QoVkfHuCJa6jXOtwxEnGiQAuW2GYhci70sPNE2yYcqvSG1LkXeIKmwidCYBX", + "NShYhSQQ+Q+hGMYUQZEzzgEsAxzktBiATrAkjQYRBaOGKSzA2ycIPSGzXtaTjLMFTcj8lnARNCyZac71", + "OGTGhQ20HKcCR42GmKvy914GGR8dipMGrjnIViq4WlgPhjORC21GP7rFNMHXCeljwXCQ9V2m7rbFB3ZL", + "OF1QNfO5piTAGceo1MZk3rd+XIVp+1JBOOrtN+reFUj1M4QNNIHtT9VrM0SaJ9XVdLSaXNX8lapD1NDS", + "x6ENS8YBgT6sSFo8/r73cOxKtOWvSr7E6VY7R9wFzUgrCZWfCM9taFhyF5e0NDEnKWiKPoR72n1Oy29b", + "dINXjvTvvRIadI2+GiN8dm3r1w9XIFc2vI9DbZY7mCt7GSpxFJFMAsNv8Nv5Yqdn1dFeLZFfC3WaVCbb", + "qhfPM0JqhCiRQZssvfcZpUwiTmTO0wbgP1lWuy2rXWbUCsP81EIlLlS9XS488glahYa7RgL2AZzWJy81", + "K607IppGSR4TYRVPHN2kbJOQeAmSncvTe6kFHjA/hel3Z9Nvk3m6Tb40ImrdBXHRw7UZmNnaJYL3NhB1", + "vsJb7Zb9bIRA0CaF0QlZEM5JjAp515lwiq7AXgRmEPU/GpqlPdqyW0QXDfr/BguUp+AalQzR9ZrEFEuS", + "bDVYWqzaVLQyXLs8icA66qy8oXIFPxdnc348TeOM0VQOEYLbCaOK3bvTyaknCgTNMg6/d41g6im0gkTd", + "1NgSA5YsA5zwwynCybI0lg+Yvu5BT6PwCiSNHmaFz5ubPuDCSNB0mRCU5dcJjeDhw0qm/PXDPzRu7byH", + "CuKoDY0BtPr4rdjj3PlDIE6Lf60dg7QZdbMiIPZ2eNRKmTXgklMCdCP3BkMyy9RnV68vQ/jY2+8TdLup", + "vSjs+u3i1fHff3j5t0/uXh3vzzOF4Hql53bwf3xy3AvGZNt1LstOFGMiacTiKkdDjLdAAwTHXz9c2S38", + "+GmgISSNHgleilz/LeBlDjcvKbYKrp8YSwhOzTOk9T14Ldupw0yobXFOxI9LLC7yG7t0mMmgmb6b4imU", + "3HpcWlZ2lgJmdkv4NghHdTfqKGTBOHElEVBcdOAScae7IVtRd0Ijo9zVt7vAiTD7tTMf/RNFKyZIAUZq", + "Q6T8ncNSjCsFyeG11/pS6hGEIY7RQBjh++/Jnh/EKH4pscxFqwAsYEj9qRbFpw1Y/kfHs2QmMMODp770", + "hgw91lkmm2LKtBNGfQtKqyeE+8fsd5auI6it9DzFCck4ibAk8TFbZ0yQs9nJ8ffHs6q+YkeNDoEUK8cs", + "Z5mid4KgA73CgbHyioM/zP/NTu6K/3+vTbp3B0q35VrkFgeAXViSiXrzJ5He1BSVNg/9JwVIs9VWgLZp", + "Rxd4g9SpEyJJ1aEOcRCKT0S5kGxtQtBDRkgazyVZZ0nYjH4SMDzZ4Wq3aZ6AadfCte6ovSWc05jMm+zt", + "Z2aACVtsmbRgIs6sJtJmHgeVJzu1s3kbmhPTuN9SGeFKzpqrI0VSsSUa47CUf66HIj0UlUP7rOSY33og", + "deAiT79EK5wuiZd0cMxi0sO4TPS3IF3kcoXgaV9wtrbBpOC6DIRfUZLKORZC/Y01RNPrZwXeJhsGIDdM", + "CQJijATJMMdGBsHo4+h/fxyhaIUVQRGuNcoF5UKC4ECFEwKPsJREaEu8+lU/WNoU1TLynJ2r0WGLWOVA", + "DWHzl9qKbKQFHRVUhgPncqUj+SXx9pBliY1ZNrE9oTwc9Oz98eVzfXCWJltHSive54+jnKeHlMjFIdix", + "xSHcz6FeaVJsf6K2f/h5Iyf2lxIOH0c6KSaNYadOSJXZ7zoX0j9MrtmWQjD07fQFOipnm/yE1fGP9adH", + "5VfqYBpAbQAPui31XLMTwND3x5faXOxw23BkSDZXe+rxDBUjnaeok4h6vkst8zSZxQvxbn1fsmzM2tpf", + "BpP8Yu6w4+WHYf3gPczr+DORxt1IYs990cb2lkRK7X8yX7a+xaUPcJ45TsD6AqVrEbneQjWjtV+PrreS", + "dNoimlZ0ANh87jbAmQO3Qk5kewGdL9HgdKttuHefBgAjbNxrOUhfWMyM9GbNqQ3BNvcJf36TJ5JmSU0T", + "xMZhEghwnsfB8JILAxy4j3NOJpaIFCNWnOJVwjbTknNeEn5LI4JwJAXCAp2dw5cbreE5z5NoFleciGLY", + "GTEWgRD7xnSN7O/29EbnBR6mw0gd2UxbqiHYeYWFcYWVvmG8kDo+OiJCLPIk2SIcKRAAf6zm4HVKpkY2", + "73KQ9hDGqvHVLflGzqW7P7R7m61/LuT4OlEPc8VBKZwwxoilgsaEqwvX88QuG4qVqiLpmnRswYZiNZ4G", + "BnSEFhm9IRzkYn4M6RtOTADarGhCfCSIGDhgtNWXCk9CKFIjx9bJYbQ34xABmtZyW66eXkucAXVHhG3H", + "lvv0ZB33MET0XOG4xOtH4lF711G/LlooVdoAHtsfC/ugkl8pScDpVk5yqdXQKbq0VnmDZjRd9uNeof08", + "pIodWmD/2raz6p+geD8eDdtHRNNqDw3dfmhiZvR3IfosrLr91YIKUzfUSATaKD5xQ9MYQqH1C1t4hiFw", + "laElvQXn8Pvjy1YNz+x/XgRumihdf/F3F6/dWA04kPkUcn0dcQLbiHx0hW+IQOqZVtCICFIIa9TY+YYk", + "yU3KNkVoTBn6BYbva6YUq5ZNahZVnQxzSEO2NnAwyKeOR91eV3EKdbINTZLCBqK5XsNImhaRKxlJaTwp", + "7Ip22OHBQRu8i532KSqhRcCDFUuAOzqGCsA2YxAoDx951PDu4nV4Jy0PUTWp6N5PUq9coYEvaEDPXXKc", + "ygarkKGMCKeFD8bcMXylQ6WRXHGWL1eVsEYTq1EOdCRgMCxpucc1CKR+hRdIo/LsSWAtgJQqkJslyUCE", + "IWm+Bt+Lxw7U4NG4wa4E29LGpIyTCS70DP3Zpw4zTBD9TPIjBLiFHJAGmor4WIZ/z4k1mhmPlI0gtWa3", + "a6q9YurNmZi4E9d8pSBiOUARY1JfTzKEgTTIF4kEkSjPUJzDjjNObinLhQGl9ZoZ6lDch95CnKs+mpu4", + "oi95jKjx0ZmQIfVv45Yrg2Wq1jPDz+3xAyDSZkgLcScaFjYyrdfFoSnyDC5aXVwkbKPFp8AlK1C3BccW", + "EbFh2igiuQoOCUhuLhGOQb5kwAmUvmrEcY30RhCwLpMKltvoKnRCFjhP9KNULf/SWYml2B/8LvptzI21", + "rFMeOHsKjdbfn2bqw7zfuSB8ntE233dPi0AvF3nl8K79Sb++aj/ofPYW4YSpby1N2cpVprJTCtGrLj4Z", + "8KitjEIyoH6Nisc4Ll7jZmf/IsFL4diy7UGUcJK6MXEI9EMzseI6ZVZfD7kwLLXtJvoNl/n+FWQ931rV", + "1+t6CF7XJmmbpkISHE/R12fweuAD/tk2syfh/Ul4r9sXok7T91ctzYfLOzSbax+aph/C4vvAe9rBUDa9", + "n9V4f0DdxfD8wLv517RdPymzT8rskzL7pMw+KbN/aWX2vlpsd5ZvHzW2KcUJKqg58R5hxcNG0obFcefh", + "MZy5ZI8ZFoqME3Kr3io3pabCoFlgcrj10oMHysgvV1fn6OfTK+D18I8LElMOvj69rEBrKI6lc4v/80Jj", + "kCPQW8YOSp0CoEJOXd1MPcegB8oVoRyt2bUi3Q+FQhvOMfwS9rh7YLHs11GKTbgy5yQxAs8CpYTEDRnP", + "lqQD7jmfYjTYfiYp0YGfZ1fnKNM6UwHb7jytIGaM6xFmTQi7C76/P7eFXioecJCM3l28vlSqSbhmjctz", + "yrIKr2giCe9R+qnt48bZZ3F4Kzm3jpnwkxKwFL02KUdGCHRfFl0SSbhZM6YQWGmHAKT9RauokiEdIadd", + "0X0fjSYWZi6l7T5vzXKhG3U5WIsNzTHXBQhsdtId+xicznz8qfFsbfVDgGadYh3BKLGSD5tHsDXdoKGe", + "5mWhGhpVXsldCxMQHNA32oM4WgOJaIo+b8QzDcTniHH0WbA0iZ/pmZ4b04rYIQN8r0Fae4+QOq6DGUF9", + "n4C6oo2aXfYTH31Mro9PaAEM68s4w7PfO8UoWqnXLl2GgL3CCU6XIN7jOCZFDU2ontFk5sLBrMurFUGx", + "o9PrKZSaxNZUKpYmtkKSNYISGGAbNK9phzmtTCLrVy2mTImCOpZrHHphT+DvA86tOaJ+6N9AeH4YBO8u", + "ZhYC9U/KxOswhHTeBom//eGHlz+6mdtsgU5mJ+iZETpYWSfrZHbyvAuazfhpkawniha1b+oP+ka2dDmh", + "C1QWdkTk9xwnAkUbOUWXdJkq9eTDlVJki6ItUG6xKNzSkAc/eMXPzoq/Dl8RyoRmQxfVX03Ra5rekBhB", + "JTsAYsfyne6VcqnmLU11jZ/LQJ0XvbT6fIqOc8511QlZT6IpBypy+ebzRn7TLWw6m3Oe6gJ/+ub+vzbF", + "D6tp83IuyRfZUMuQdlidQAYrKrhiIFntJnL0F6U4OKU3ErZkgeT/WREf2A4OtSkHDnCsfhUUIXnovKi9", + "1SSugP6tkMipwe2qSE71LqXd5TSJjbeDcRK2qaBnF6+O//b37398rpVSzXrgI2Pg1AqhCSU0TkKwC/jz", + "gf1w2pQLR8Mit/lVkIiT8EXXbE7N1p4BErN7a/4Kbu5VdX92LeeOqxfXk8Wec5Jh3l1DqJRSzRehLgZ7", + "6PlgViuX+QmHA7+alOiBtRn1NOOuzhENYBsGdPAmKwZ91KDIdF2BdkcDi/ctrMPDDvaXedaS79dpyH1f", + "ZqYq1UbbeT6OIhaTj6N2i+sD0WAoB7HX9T0MKnQb73rgQmN5Ig8ZmjOFNCv+RlSYsc91SXPlp2qbOt6v", + "AGiVozlVXdV8+l7mUiYhg5aWVotqkpASqx0WV1evw3XvslysSDwP7nU4dM6PLtph0othQY1BY+EjKM8i", + "tq47AHhb/aaafXuRsM0gQtcSijV7xK8StgE9s9V+UlzyuAnNxgWvbbjV/hQ3zGJYe1K0jJcYS8Uur1EP", + "8uzxTj7oExaA3sB3KggrOHDIgOwPQ2qcTpQO8Z2YkjTS1xlWaz+qQR9HxqVlvJ1xYVo3btAgwgdzX040", + "KelGgcbb75jFSvc3tPYY1Bti9/qvKwwMp6Fe6i/wq/G3D4JAYdWd368i7oWdp6s0bkNN8rLZA8QidENo", + "xzdbLz+u4FUFvm30AEi9K/e4ICJP+olrvTp+7aP6aomjNdz/VymwOgZFfd50Qq1cVstJh6lD8kAjnauL", + "d6eILtx4TVNGeEskwrZEut24sdWfndvuvDqkBixj1jNcBrpKZupxVssk2xilStH+Im7hWajIpnrBn/co", + "3hW5DL8AiAtGC4024jD43Z882r1oPrZD5qUYKK87W21Zq7e/KdC2pam6o2/KWROJAVHKxmKO8apn1xYf", + "HtqO9Sf26Qq0dSkNd7uz6B7n8nCwdiN90S8Xq5Bi2kepzsWqojqZj5sltq9LnW4qn9PUJtyFeAfcBoCf", + "xMN1WPist97aVg7dVJlP8/U1hBZhWe3jUpRFN/KINT++u5i5ldKheG3GDC0ZNVFXfXK/KIusC2QoKaYi", + "4sQt3xosI3WdS/1cyG1GI5wkW50ZkGC1YgKtrrhEz8h0OR2jayI3hKToB4hb+duLF3ajz5uaaGu9NWie", + "rh4CNEwFbR3nGqp9VYT3MwFV+OC1A5CJovbvJBfQmptwYirlV6pIe4Ez9VDEcKhdp77jHtVrTV7B7ybE", + "7OscMLVrTNJK/S0T+ofTRkuBTXdpNwuEC5qZTy0b7lG/cVzbkAOPylkC7h5/xMyEPTeeurdBt7Jy18Nh", + "p/8U3OKSCkk4GIp0NbKObuRlabQijlZNYeLFoYf48G7ll7rwtW5NreeAiDF9OeGy3WrUro2vnXGWwehV", + "C29vTK7z5TK8eFff9E6g9ieX2kSNr3D7vTQ7FrRTJBzZUQGg6T0B3QaZF0utFX/zRpS+eZLGE/AumYBs", + "jzu1JQcFWe67i9d2CxDPuiHXKMNL4rQxr9cL79DzQRCNZJvmbWXA4g3UCUlboQ2L8D3KCMuSotsAVdAq", + "pD+9/Nh5pMga0wThOObQ1nRYWHGZ0dC26xId/FwGv/6henmShG2KDIsi1NOWYhSHqJ53MEa7pB0MO+bn", + "zY1oKpj4jdAiygdyjf5BtuiSSBSzKAf917T+1HYqr2lrZD8uwzTCXR/V2p04aF9p652Pglt79uuHfzz3", + "NrjL1vzegp1bMzKbkSKUdAHOcBvF0kIPGUtotO23ALyIQidgrHxOkXF6i6Mt0tOVd1PJmbOtgWOSJWwL", + "Ixhf4rQMy08S3Y43F0SMEScAsTEIcEpGTJggAmWECwjJhLj9sMFCxyerg7VRjSUGO15nD84KHlCBYJmt", + "C1YPIKlC+6uTjUOKw2jB86j1o3ovbaNO+BFOIS/C/LXBDxVgBsMJuSGB4zLQHkpkOCKTslyu7QHgNFRt", + "PkqtNVRn5q9gC7nBPByKeITylP6ee82pDfaDPoHevZudPEdYCB2dZMLuzaZicksS9c4ixpFdRxO3WBFe", + "hKT7wpOBO9CUZ22wuGUn0u9tvE3x2jwp3IgKDXby4qiNzRyPbP/GwIF9tC+3UYyEs3x0AdrgW4bbKBxY", + "2l21bojNK2znRXXhUMndYnPaGNiGuylLyRh5YSBzpYxV/3aNBY2m6C1LSZGwplYxvFkPFuhZCmomwlkm", + "xjZPQf3jueXwOAXr5wrfQs1mTqQo0ooOg4uGYSbuzZAl4WtwHxhloGTJlbutcGidWqfUlhxsqjpLQqxo", + "VqjTnqBn2jZ4s/kDwHorNLVatuM/oe3hkC0y8b3E6s6SxRCvVZJZabqEFBKTFlmVwjtiqILVoDvashYT", + "6Fp4cbBM4BVdA3PXiOhKfCVxb7Cou9bcJnZfpWpQhpcFgad/NsaVopi4mxgFWcVlaQm7Sb+kOQuxlM5d", + "tVZubLwS/a02ZOkJ1KPxQskU1PxZcRH9U+tVPalNT2rTk9r0pDY9qU1PatOT2vSkNj2pTX95tckLZqkn", + "Q3haRCue+RLUpw6FbLCjo0+YXI+GoWU29lPz2VB+dqjlaz/g9wxfuCTSnUY7KiWWbv3vfvnYb8nG5NhP", + "O+rl75Do3FUPriM5ORhDPDxVekiLZ0u2ACzn9joBfv+Ls8GZlVDrjrbeg2Ou/fn6HXFIXN2lZHynznFC", + "Mj64bRyLw+k6rbk8j5dp4EQ2FSXBLLhb4XRPYA/oDLYL2Ft6dHUdb1gGxLssxpJUU9gbkal1eBHUIyTP", + "Iy1b5OoDdfr3x40NV0vmEKzNcf+MfCdfqGEFv09od0BdOVvt27F/nsDuHRxtB3/PO3yve2iQ8xIfSNyT", + "J9j+G7rMXK1YlhLoMppOn9pJPrWT/OrbSYZKRIbyk1AFyweWyHqnFBlDFF1cIlyz0hB/J93en/67A253", + "ZQA9q5YXFSo8jc/7yKkb6ZTVtG9JUcENjP4R4cBF3LySbUYQFqa0FdSYvDS2ux+mL6cvAddrlSiZXBG+", + "odAAXhvC66WRxw3T/l2N+e3i1fGP3/34t0+hGsj7ifGuFuPRWazNuc8hU2FhVKtctvlgiGWvIUfRK3oY", + "d9eGKwW4Yg+1tMVuDO9LKkVjSjdjpFmnay9gBD+ZYqfB/MP2EkDNH1InxrZ/BG0RmXs3Hv2ek1Bqk0M3", + "LgDQf6rhAf20cll61uJgYwdAzqbdi2uFd0Adhg+2ThnnFYlumvLq9OBgtpRjS1lgmuScoEhNhQzTCRWr", + "ItFN6J7VV3Ce5vjd+mcQKIvWRAi8JDuXdXrvjGl+S6u6NhzE7iy4UPWGGgDeO2+qOklXeTvnxtzdDetX", + "+DiF6HoWaKtCwK3Q1pCI13IJw6okNq3dWr/ttko7+y7f9kD10O6aodanpFgr4PrISwWH8dI0RRceK6rq", + "X+qmjSjb0iAbDzQQJC6z7sOBvSLN/zI8uJVv1qizCSb3AG0Xm/TA2o5gg9iUu4eCUfmFaYOKU7mZvTHc", + "ugYVbKXeAMt73MUQpplVOsXvIDT++XwzdPh7wG8o7xyA2zsxzyZy7WafwVP1hswHkiT/SNkmPctIOjvR", + "udQdHem7v6lmrprOsv4IA1wQsLAgxsv6/vhS25cgkXV2cr579SenadTZ+TfCtQd55qzTtkjDayyjlVuO", + "pNd6tcz5b0S97Fyxrs1Jfa0V/1xoc9xKykwgwBNt2Xhz9M/CMJkxLscow3IFP4Gq45gmSkRz66aOG9L6", + "Y0Z0xQhjwoNhzfsd0tWpUgCgrOR97t1pP/u4h0KizLG/G+/ckDxU8qO57oFr3zHXxjxvOISvGZtFitfk", + "wCkzOTbFMwmOVjpmF1KQ65E7ZmulPbVWecYeKO5y0u6MrY+Pp52+YQuf1poSvZp2tFwwJzLnqV8q2l3b", + "Nf+lddt4YSW07T0Ml3Oa2+gOIFxduTZpq8XM+nVijXUATmlSX+DEizkItzhvath+1XDdXdHv9yrH1Bbh", + "UCFiXTPmQfhtqADNA6HyeF88t3XP4ZphIkvwtlfvPI//VNmWmQiVT602Ydc3Dh20CtO20qtzo7D0kncc", + "s4HZe3vYeBuxQ/CyPqYXmmk5MDz9xav/MwS0Xm1r0ZkUGni6tW36m5W9glM74+pbZ5avHknDm+3h4tK3", + "ilOWbtcsF3Md9Np5wZalO+wy0IHJxurhSmclYLc42OZJFzKRK5ZLhdE2VUe7NC3jbWe5bkjsAFH0RAfD", + "WjfkhRtY2wpRP7j64WjDm/cByUM7SR5un7+ZUtufgmHWVFjf9I67hejouc0xa4wDt031MBJFkXxDrb9+", + "uCqZap2givQ1p844FvWIu6Yg5CFajqaDVnRqjjy91521hUALR66FMHQqatHQJyXtfRylLDU1k3eotNZL", + "Vx3ilLsDf9eC6WgzyKeCCitrTJPR4WhFkoT9L8lzIa8TFk1jcjsaj3RY4uhK/fmnhEVIEryeQh9J+Egx", + "9MODA/+zmlJTfg5KsuHIjm5QKCeK8btGChMQ8eG7Y/T+eHJ0PnOb0WnIfP8eSgBLFjG3p8+BtRa44Qz6", + "u7IlXEIjYmwp5qRHGY5WZPLt9EXtkJvNZorh5ynjywPzrTh4PTs+fXt5qr6Zyi/a8lFzy7kUZSsLQRiK", + "dhzpaKjRi6laGLwhJMUZHR2Ovpu+gL2ohxFQ6MCczzGKH4giXCtjzeFkwgV5GSSmxCZsW2ONzplwoieF", + "CaUqqlv9xOKtxSCiqdqJujn4LLRQrWWmLomqPSrr7u7OeTfgdN++eDFo8aqXtYaZZ/8AohP5eo35tgtS", + "dZoaF9ex5CzPxMEf8N/ZyV3gfg7+0P+dndypzS1DaakXRHJKbk3cU4/7+pkErytz+kn81tDI9me1VRNr", + "S9XfFY6VRG9OMnItxbpRSQ3ApfGz/u7oE4eXEOWv/df49OhI0eNS2lDDYUDiwHT4LcVLHdxlg6jC9Htq", + "Pgq2Ia0GuRYF0evIYudpidbdB513LvsApL7j+uYF7YMFu13CENzIdCHYCQhVEyVtAZb818Qp3x9GEFNC", "1gpRwdYUruTm9L7zaugH3gM9c0PDhX1gS69eD3vGmH7V7/tgTd/GITvhiRe10fD0mxTIIrrTYV9WbnXj", "AP1G7aYXu3GE+F1em1DFK3q/TwQp13kkbKgWaB50/14rgN1vegJ+nYe7b5iuUgt7x4uvt+bZ4+1XF3sA", "FNitO1Kjv7M/blQdVoMwJBeriizR+VrUcMSk3LoNVKBSBQjDXnttbZTyGJgTZVJBi4YKx/tCjI6Cys0Y", "0nVNjWWqh1yUkIwPk/og80jcV+brSs/ax1W0r7lnbt2RsNWHMHeB/BBcMMkAZOLbmTvwwUZni8YMgtxJ", - "mfCxoEcOxD4QoXPZPeNCd0B7H3ToD/gOJDApbOLgjyKx7U7/FjtPvGizDuS8bp6Fp3lFFYfZ1q++/Nh+", - "+4v+dHRPwA80rTpBnIUx2bQvud6iJb0lKTJg2cEnVzmbTmLd4U22ylIHiAM5D60mF9serckS4iY63sPc", - "UmxVetnUdk2bV2AWhT7rg+b3ctobZq2kZbYYcroo4w8/5dO3qcFAYJY9TF0l+Kd7h7+znNl4+5plQusg", - "G1j4jZhVG9o3mHgrXaL3JZOFmqX/KXZd2AiK+orY/dDRe9Ph9IJMcBpPbEL+xCpOT3jaoII4fnDJkIUb", - "aCWzoIfI9eZQiLq0HUL8aHhRTlaMfXfx2qkZZFMU3XXVdpSO68l5Di4GqMnWTnCD/QATLC/eF2mZdRWo", - "vj+ePZJAVVnVHNVZvJsS3TtGZoLQc/vwJFqQJaNx9ESSfyGS/CvQ4iCVpkKFj0F9XCfRPtFdA92VNGcg", - "5RKbjrNRn7kUGNetPU21j/Zl6ekqJ7VvY09HracQLdxUrT1E+uXRNPQt2NrIoBX7pxuSJJOblG3SA5aR", - "lLpK/qQMdC5U/YyTCMsSmcLKv50KYoHqzO8MfvZZn40cGu3xJnok5AzRv98fX6LZyXkgA+crVr8rTOTh", - "eYhCPSW8HBRGqEZbUVPSkAGwrY9smALUs9SFc4uKrtXQWreweQXnaBwV9rWu6JP3ZbGia4IEAVfDRygr", - "ZqLlAkYFL8zzfpd0Fapu37SuWwPzHmseoSJbEcWEV/pKs5igIlzNhmgK2GDa3BhwbOrTmpExwkslZEmU", - "YNlyIBaTuVtO4l6nMoWZYM8bXFaV0WfUJysW67elsoDowDsNlnqyJaZ16E4uCJ/gpSnh71UEd2tRFz6w", - "jJNbynKRbBEREuuywrFJhGla0nQocOo8eeWHM86AvhjXeYNrfGM/b+zGGKaIstj2cGDpIGTbLFNTfMeC", - "usL0MARJEcvw77mtUOb1VShaKawx1SkAUKDGq3hrvdQ4jVGEk+QaRzdauQiCvuh1Lct2DqZgtbldA2kH", - "EdSUPjboBcrMg8tfzt69PimUE5Mxfmt6FEScCTERVJa7XTC+NHVegoAs6vD0BuRpqogkLjNjmvO3Ipbe", - "kq0wOVj6b06TBscKr/6tK0iiDTYljdm1uokpepMnkmZJ4yKOsqapYavQCUSPuR9JUFyhd2E01b2T2QKt", - "7VIVo2UIdOFqWINAqaN/vxEmfFjJFimJpI1zf3fxWt+/+Tf007AJLDEVEbuFvBRDxcDrJOFrmhIHoN8o", - "EGX4miYUMpIU/hZ1x6fo4vT47M2b07cnpycKEkVShSuEttKiLfypxZ8daRKcVivw9ZeY8Obon3BcRY5l", - "n1hLexpHMknX9L9IQUnfCES+ZIRTkkbkAU4HNeHUxkYDY02B8ZqEQ7dPfpH0Za7NlsQnX6StzV8xbBA+", - "RUdmqrIvt1tArewzkmEhdOUy05DfWEVAw3Y7+RYvfqnqlZA3aRi8GqznFmtTK8EQM4Mu6WW26TGy+mmu", - "ynWh7qDEN2C6YYr9s9yWEbd1wmwr/mWOlVRI9AYYp0uaqp/NWajpCcTHKGJ5EiuugFOEpVScuuF+3c3v", - "dMVOQpXuD1/0WdH5Atgrr6+OUW0gEHo+WipCdpSDpPFEZ7XpP08sn8DXCTGFIT+ObAo3EUratXLlx1E9", - "MbdgmVAu75erq/NLdA3VH99dvA63jv7o9PSBupMtbbCL3DiccILjra6cb+pslj2qAFHL1gO2vw7VvSC4", - "iYmujFNYob/8f//n/wpUasAoYWXdiVZJe65BORoSA/7di29bFNkvk81mM1kwvp7kPCH6LfU123A15nCN", - "xZAAohuPkJQUlVbbsSwwGjQi09AJGpEnW4QXgBaA2sZXrgQmKunS2kY5FTfqGU0IvmlowBEubFiUjKQL", - "g0LwoYeQSqY3BTEscjopUnVZFc5GvuDI5n1zEpGKttO3+4Ct4tnl63vF8jSuWBHAatAVZ1t2FCjU6mrR", - "jOZgnKu2QhP6rkQp2jieVgVHlgYGFyn3iuyzjLPbEpFO03gC9VDzDFQIp6YLJDtDQBE60nK8Tp/zGmkB", + "mfCxoEcOxD4QoXPZPeNCd0B7H3ToD/gOJDApbOLgjyKx7U7/FjtPvGizDuS8bp6Fp3lFFYfZ1q++HGzH", + "/qKHju4J+IGmVSeIszAmm/Yl11u0pLckRQYsO/jkKmfTSaw7vMlWWeoAcSDnodXkYtujNVlC3ETHe5hb", + "iq1KL5varmnzCsyi0Gd90PxeTnvDrJW0zBZDThdl/OGnfPo2NfgQmGUPU1cJ/une4e8sZzbevmaZ0DrI", + "BhZ+I2bVhvYNJt5Kl+h9yWShZul/il0XNoKiviJ2P3T03nQ4vSATnMYTm5A/sYrTE542qCCOH1wyZOEG", + "Wsks6CFyvTkUoi5thxA/Gl6UkxXfvrt47dQMsimK7rpqO0rH9eQ8BxcD1GRrJ7jBfoAJlhfvi7TMugpU", + "3x/PHkmgqqxqjuos3k2J7h0jM0HouX14Ei3IktE4eiLJvxBJ/hVocZBKU6HCx6A+rpNon+iuge5KmjOQ", + "colNx9moYS4FxnVrT1Pto31ZerrKSe3b2NNR6ylECzdVaw+Rfnk0DX0LtjYyaMX+6YYkyeQmZZv0gGUk", + "pa6SPykDnQtVP+MkwrJEprDyb6eCWKA68zuDn33WZyOHRnu8iR4JOUP07/fHl2h2ch7IwPmK1e8KE3l4", + "HqJQTwkvB4URqtFW1JQ0ZABs6yMbpgD1LHXh3KKiazW01i1sXsE5GkeFfa0r+uR9WazomiBBwNXwEcqK", + "mWi5gFHBC/O83yVdharbN63r1sC8x5pHqMhWRDHhlb7SLCaoCFezIZoCNpg2NwYcm/q05ssY4aUSsiRK", + "sGw5EIvJ3C0nca9TmcJMsOcNLqvK6DPqkxWL9dtSWUB04J0GSz3ZEtM6dCcXhE/w0pTw9yqCu7WoCx9Y", + "xsktZblItogIiXVZ4dgkwjQtaToUOHWevPLDGWdAX4zrvME1vrHDG7sxhimiLLY9HFg6CNk2y9QU37Gg", + "rjA9DEFSxDL8e24rlHl9FYpWCmtMdQoAFKjxKt5aLzVOYxThJLnG0Y1WLoKgL3pdy7KdgylYbW7XQNpB", + "BDWljw16gTLz4PKXs3evTwrlxGSM35oeBRFnQkwEleVuF4wvTZ2XICCLOjy9AXmaKiKJy8yY5vytiKW3", + "ZCtMDpb+m9OkwbHCq3/rCpJog01JY3atbmKK3uSJpFnSuIijrGlq2Cp0AtFj7kcSFFfoXRhNde9ktkBr", + "u1TFaBkCXbga1iBQ6ujfb4QJH1ayRUoiaePc31281vdv/g39NGwCS0xFxG4hL8VQMfA6SfiapsQB6DcK", + "RBm+pgmFjCSFv0Xd8Sm6OD0+e/Pm9O3J6YmCRJFU4QqhrbRoC39q8WdHmgSn1Qp8/SUmvDn6JxxXkWPZ", + "J9bSnsaRTNI1/S9SUNI3ApEvGeGUpBF5gNNBTTi1sdHAWFNgvCbh0O2TXyR9mWuzJfHJF2lr81cMG4RP", + "0ZGZquzL7RZQK/uMZFgIXbnMNOQ3VhHQsN1OvsWLX6p6JeRNGgavBuu5xdrUSvCJmUGX9DLb9BhZ/TRX", + "5bpQd1DiGzDdMMX+WW7LiNs6YbYV/zLHSiokegOM0yVN1c/mLNT0BOJjFLE8iRVXwCnCUipO3XC/7uZ3", + "umInoUr3hy/6rOh8AeyV11fHqDYQCD0fLRUhO8pB0niis9r0nyeWT+DrhJjCkB9HNoWbCCXtWrny46ie", + "mFuwTCiX98vV1fkluobqj+8uXodbR390evpA3cmWNthFbhxOOMHxVlfON3U2yx5VgKhl6wHbX4fqXhDc", + "xERXvlNYoUf+v//zfwUqNWCUsLLuRKukPdegHA2JAf/uxbctiuyXyWazmSwYX09ynhD9lvqabbgac7jG", + "YkgA0Y1HSEqKSqvtWBb4GjQi09AJGpEnW4QXgBaA2sZXrgQmKunS2kY5FTfqGU0IvmlowBEubFiUjKQL", + "g0Iw0ENIJdObghgWOZ0UqbqsCmcjX3Bk8745iUhF2+nbfcBW8ezy9b1ieRpXrAhgNeiKsy07ChRqdbVo", + "RnMwzlVboQl9V6IUbRxPq4IjSwMfFyn3iuyzjLPbEpFO03gC9VDzDFQIp6YLJDtDQBE60nK8Tp/zGmkB", "o9aT6gpkdf39caI3K6s8kpWwtmphKR/7s25k0NFcoGi3/QowryWgM4B0fdBtphEq8vHIJpPo1PZK3Ved", "nBi+7L3f86Nf8SPebt97pXH2wAbiBzYHv//2ySD872IQdss5PBobOYoU8iYkXpI1SfcVRHoU3bQyke8D", - "xu8bJfh8/4DYfBTdQJ3DNi8rfBDiGG7hiXaekWHefHtFz9I0tpleQTEMaWNXsrXF8msqAE5jtCSyVDff", - "XcwUJpT97ECtcqw8WJStDq3SoUM4PUOBna+2cLvz4DwXKxLfK8lssJDfs7J6zfT2b252G9JAoNGVEugA", - "67kdDr8OB0nHNht75u3g+Ght7PPXtWMV5qav2YbV2ug0TBX/xs6o9tI+wbSVdn9vuKtCGK4dfqu+to8n", - "x1S4EcsqWKnnK3MZNLZBaygd+C/n8Wk3jFVDIbw2nf4zGzKf1eXnlw+aglkT45rl5WNOsCmg+P2LHwIV", - "jfUj+5ZJdKRbRsOnL79r7GKLTlNJ5RZdMYZeY74kMODbHwPMhDH0BqdbC3cRktv1eXYxJBrbmyvL13Km", - "1QdhWO1N5qXxHNS5gGZ4YuyGZQ1jowk6hbDAmptprlewtML4X4q778/1ZENYMoTb6Sc5rNRAvWXGbXfc", - "YK+PrOl4dkfltllK1LO3ZhzUc1unya1KLRrqe3eTVCCt+DJX7EPt8ofQz6905f5qOSIjMIn8ek3rRner", - "rDFXOuYsX67Q++PLKobeZi6G2penOYBMUYD9CqC/wmmc6La5tgZ2GZOt+KtbSkQ/jUy9RTlBLDeVRorA", - "tYZaAkobvLBb6zDiOJ0ey3omTj5uU7DR/Ww61m3ZFtqxezWj714EuZsBSIBHOcBq4UcFWbTahdxm7nB/", - "ut0BaAe4CEvWP1sXYWE8qqrG+mZc/+wKC6PpKmUMXFsihyUXedKA3GEMAVreH5tsUXmt12xs3Wal7xlc", - "qg7DtHXqGj2BCm/yJFF8xyJKUCPto2IAsOvetnutOy8q7of0db7NJFtynK1sc3ycxmzt9Up3dD7Lukmz", - "dmGlXWkcWIVA1Lnbsuxub/3Dt7C0aCO92h16aGFHAIvrs/12fbKGch+9ATWHrXni4g7jiGkiT7mtRWpB", - "pE0OkXYUdu5dfhkMEr20HhdyMTtS8dli0QthKzKygw+f+j/YD2QoVgwNGFRXRk5hoa5UgscxKg3eNYbv", - "VQlu5/qt3iduGvE/JeTUXlsNGIFirabp9y91KtQapl+w9/fHl42sNiTf6AW0PX9PXhO7CGxar9TqRXm5", - "35V7aoEv9rmLTgdOB+XZKQ0iFNcXpkAjLrUSYaPwPaBiq9mwk/zUuwLoI1alqFP0gxP0Q1SreLwypH2D", - "GeBWj24xheev+0kJ+kPfMmQwqoLXPxNZyPUawSqNI13nus3gBO96A+sEAdRUDovRMzOExM/ba1L8TCwC", - "k9iLr3hC40dA44d/fcL3eUF+37f41bSwyHpGm/RG4DpVKK5vVSY/97laoK/s4Ra2DkIntSfb4JNtsMs2", - "eL0tTX9uUQS/dIP2e3hho6CHhY2FTp+9Zoz+Q36BKucJpmtHiqmKJjpIfOaMhEK4eyg9BjtxS4+5olNu", - "GyPsUBG+C8xLIm16fmHcMm5XY3Z1K2RMw4DueuhOwOdZFvUKvzqmoNfA+LHigocX4dKNOrs1yBPrsi2g", - "6FZ629uL/b6yGrp9BGWyXmyr2i54X9W2gu2t911hsakVcq/CitXm2D240P7r/vx1kbWoKEPjyOHZj1E1", - "5/35Y2BrZclByPro720/THdXeQCG/Keg+J/Bjl1hbq/8uNY9+1E4crC78gCenPngCeGqGgZWTo1hZbek", - "w4ODhEU4WTEhD//jxd9fjNSFmCmqOKHdthPtG4rRmsUkqYTPVDNHR3XMsvvqOU9xjIB7V0dsrQhO5ArZ", - "ZvVmnP6r/uPdp7v/HwAA//8MB7GU4zIBAA==", + "xu8bJfh8/4DYfBTdQJ3DNi8rDAhxDLfwRDvPyDBvvr2iZ2ka20yvoBiGtLEr2dpi+TUVAKcxWhJZqpvv", + "LmYKE8p+dqBWOVYeLMpWh1bp0CGcnqHAzldbuN15cJ6LFYnvlWQ2WMjvWVm9Znr7Nze7DWkg0OhKCXSA", + "9dwOh1+Hg6Rjm40983ZwfLQ29vnr2rEKc9PXbMNqbXQapop/Y2dUe2mfYNpKu7833FUhDNcOv1Vf28eT", + "YyrciGUVrNTzlbkMGtugNZQO/Jfz+LQbxqqhEF6bTv+ZDZnP6vLzywdNwayJcc3y8jEn2BRQ/P7FD4GK", + "xvqRfcskOtIto2Hoy+8au9ii01RSuUVXjKHXmC8JfPDtjwFmwhh6g9OthbsIye36PLsYEo3tzZXlaznT", + "akAYVnuTeRsquB9VeL1RAmA0yDJKWc2TBF8nxCql4erw7c01W9dxh/ZYjsZz0EwDSu6JMYGW5ZiNUuvU", + "9ALDdKYZeMGdCz9GKbm/P9eTTfvsqVGgK6SNsL4GpaQZt41/g21Msqbj2h2Wx2ApUS/6mnGwPNgSVG7B", + "bdHjPHe9uEcgg/oyV5xS7fqH0M+vdJOCauUlIxuK/HpN6/4Fq5cyVxHgLF+u0Pvjyyox3mYuMdpHtjlW", + "ThG7HQW3scJpnOgOwbbcdxl+rp4St2qKlgKYenZzglhuiqoUMXoNZROU4ntht9Zhr3KaWpalW5zU46a4", + "qvuZr6yHti2KZffCTd+9CDJyA5AAO3aA1cJ6CzJpNYG5fevh/nRnB1CEcBGBrX+23tDCTla1AuibcV3R", + "KyyMUq/0TvDiiRyWXORJA3KHMQRoe38vQot2bx2EY+shLN3s4D12GKotydfo9OzDPcNe1wZvad2xeK91", + "50VzgZBpgm8zyZYcZyujKnOcxmzttYV31FvLykmzImUFe2l8dYXs17nbssJwb1XLNya1KF69Ojt6aGG/", + "ABbXZ/vtqnMN5T56H9R80+bJizvsQKZfPuW27KoFkbauRNon2rl3+WUwSPTS+ruQN91RAM4Wi14IW1EH", + "HHz41P/BfiCbuGJowKC6ko8KY3yl6D2OUWnbrzF8ryByO9dvdbRpm4cm7qfcI++11YARKNYaqX7/UqcY", + "r2H6BXt/f3zZyGpD8o1eQLsu9uQgsovApvVKrQ6jl/tduafC+2Kfu+j0VXVQnp3SIEJxfWEKNOJSKxE2", + "Ct8DitOaDTt5Xr2LnT5iAY46RT84QT9EYY7Hq7jaN24DbvXoFlN4/rqflKDr9y1DBqMqeP0zkYVcrxGs", + "0iPTjSOwyaoQSNDAOkEANUXSYvTMfELi5+3lN34mFoFJ7IWSPKHxI6Dxw78+4fu8IL/vW/xqWlhkPQNr", + "eiNwnSoU17cqk5/mXa1FWLarCxtCoWnckxn0yQz6ZAbdOtUACiunW+rCL8ihvVleMDConGG7qNM9sZl4", + "/5BfoHZ9gunaEdiqUpgO/Z85X0J54z0UlIOduAXlXCkxt+0udqjz3wXmJZG26EJhxzPOdGNhduueTMOA", + "7nrTT8CTXZZqCz+wpkzbwKjA4oKHl1bT7Ve7leUT64gvoOjW79ubcPK+shq6fQS9uV5CrdoEel811IJN", + "y/ddN7OpwXWvcpnVluc9uND+qzn9dZG1qBNE48jh2Y9RC+n9+WNga2XJQcj66O9tP0x3V3kAhvynoPif", + "wY5d4W6v/LjWE/1ROHKwZ/YAnpz54AnhqvoMDLoaw8oeWIcHBwmLcLJiQh7+x4u/vxipCzFTVHFCe6gn", + "2g0WozWLSVIJiqrmA4/qmGX31XOe4hgBT7aOw1sRnMgVgk7n5Xf6r/qPd5/u/n8AAAD//xyxM6a5NAEA", } // GetSwagger returns the content of the embedded swagger specification file diff --git a/cmd/vc-rest/startcmd/start.go b/cmd/vc-rest/startcmd/start.go index c69d71fe7..7ca6e32e0 100644 --- a/cmd/vc-rest/startcmd/start.go +++ b/cmd/vc-rest/startcmd/start.go @@ -129,6 +129,7 @@ const ( healthCheckEndpoint = "/healthcheck" statusEndpoint = "/status" oidc4VPCheckEndpoint = "/oidc/present" + oidc4VPAckEndpoint = "/oidc/acknowledgement" defaultGracefulShutdownDuration = 1 * time.Second defaultHealthCheckTimeout = 5 * time.Second cslSize = 10000 @@ -884,12 +885,6 @@ func buildEchoHandler( IssuerVCSPublicHost: conf.StartupParameters.apiGatewayURL, })) - oidc4vpv1.RegisterHandlers(e, oidc4vpv1.NewController(&oidc4vpv1.Config{ - HTTPClient: getHTTPClient(metricsProvider.ClientOIDC4PV1), - ExternalHostURL: conf.StartupParameters.hostURLExternal, // use host external as this url will be called internally - Tracer: conf.Tracer, - })) - issuerv1.RegisterHandlers(e, issuerv1.NewController(&issuerv1.Config{ EventSvc: eventSvc, EventTopic: conf.StartupParameters.issuerEventTopic, @@ -984,6 +979,7 @@ func buildEchoHandler( PresentationVerifier: verifyPresentationSvc, TrustRegistry: trustRegistryService, ResponseURI: conf.StartupParameters.apiGatewayURL + oidc4VPCheckEndpoint, + AckEndpoint: conf.StartupParameters.apiGatewayURL + oidc4VPAckEndpoint, TokenLifetime: 15 * time.Minute, Metrics: metrics, AttachmentService: oidc4vp.NewAttachmentService(getHTTPClient(metricsProvider.Attachments)), @@ -1008,6 +1004,12 @@ func buildEchoHandler( verifierv1.RegisterHandlers(e, verifierController) + oidc4vpv1.RegisterHandlers(e, oidc4vpv1.NewController(&oidc4vpv1.Config{ + HTTPClient: getHTTPClient(metricsProvider.ClientOIDC4PV1), + ExternalHostURL: conf.StartupParameters.hostURLExternal, // use host external as this url will be called internally + Tracer: conf.Tracer, + })) + didConfigSvc := didconfiguration.New(&didconfiguration.Config{ VerifierProfileService: verifierProfileSvc, IssuerProfileService: issuerProfileSvc, diff --git a/component/wallet-cli/pkg/oidc4vp/models.go b/component/wallet-cli/pkg/oidc4vp/models.go index 3e559b4fd..3becba251 100644 --- a/component/wallet-cli/pkg/oidc4vp/models.go +++ b/component/wallet-cli/pkg/oidc4vp/models.go @@ -32,6 +32,7 @@ type ClientMetadata struct { ClientPurpose string `json:"client_purpose"` SubjectSyntaxTypesSupported []string `json:"subject_syntax_types_supported"` VPFormats *presexch.Format `json:"vp_formats"` + NotificationEndpoint string `json:"notification_endpoint"` } type Claims = map[string]interface{} diff --git a/component/wallet-cli/pkg/oidc4vp/oidc4vp_flow.go b/component/wallet-cli/pkg/oidc4vp/oidc4vp_flow.go index e00459035..b12ec9e7b 100644 --- a/component/wallet-cli/pkg/oidc4vp/oidc4vp_flow.go +++ b/component/wallet-cli/pkg/oidc4vp/oidc4vp_flow.go @@ -195,6 +195,19 @@ func (f *Flow) Run(ctx context.Context) error { vps, presentationSubmission, err := f.queryWallet(&pd, requestObject.ClientMetadata.VPFormats) if err != nil { + if strings.Contains(err.Error(), "no matching credentials found") { + // Send wallet notification no_match_found. + v := url.Values{} + + v.Add("error", "access_denied") + v.Add("error_description", "no_match_found") + v.Add("state", requestObject.State) + + if e := f.postAuthorizationResponse(ctx, requestObject.ResponseURI, []byte(v.Encode())); e != nil { + slog.Error("failed to send wallet notification", "err", e) + } + } + return fmt.Errorf("query wallet: %w", err) } diff --git a/docs/v1/openapi.yaml b/docs/v1/openapi.yaml index ad266952e..2af8ab846 100644 --- a/docs/v1/openapi.yaml +++ b/docs/v1/openapi.yaml @@ -230,9 +230,9 @@ paths: '200': description: OK content: - application/json: - schema: - $ref: '#/components/schemas/GetRefreshedCredentialResp' + application/json: + schema: + $ref: '#/components/schemas/GetRefreshedCredentialResp' get: summary: Get refresh status for credential. parameters: @@ -601,10 +601,20 @@ paths: properties: id_token: type: string + nullable: true description: ID Token serves as an authentication receipt and includes metadata about the VP Token. vp_token: type: string + nullable: true description: VP Token includes one or more Verifiable Presentations. + error: + type: string + nullable: true + description: Authorization response error code + error_description: + type: string + nullable: true + description: Authorization response error description state: type: string description: State from authorization request for correlation @@ -915,10 +925,20 @@ paths: properties: id_token: type: string + nullable: true description: ID Token serves as an authentication receipt and includes metadata about the VP Token. vp_token: type: string + nullable: true description: VP Token includes one or more Verifiable Presentations. + error: + type: string + nullable: true + description: Authorization response error code + error_description: + type: string + nullable: true + description: Authorization response error description state: type: string description: State from authorization request for correlation @@ -1629,7 +1649,7 @@ components: required: - verifiable_presentation x-tags: - - refresh + - refresh GetRefreshedCredentialResp: title: GetRefreshedCredentialResp type: object @@ -1640,7 +1660,7 @@ components: anyOf: - { } x-tags: - - refresh + - refresh required: - verifiable_credential DeprecatedComposeOIDC4CICredential: @@ -2547,4 +2567,4 @@ components: - alg_values_supported - enc_values_supported - encryption_required - securitySchemes: {} + securitySchemes: {} \ No newline at end of file diff --git a/pkg/event/spi/spi.go b/pkg/event/spi/spi.go index 0e697506e..44f4b1591 100644 --- a/pkg/event/spi/spi.go +++ b/pkg/event/spi/spi.go @@ -39,6 +39,10 @@ const ( VerifierOIDCInteractionFailed EventType = "verifier.oidc-interaction-failed.v1" VerifierOIDCInteractionClaimsRetrieved EventType = "verifier.oidc-interaction-claims-retrieved.v1" + VerifierOIDCInteractionNoConsent EventType = "verifier.oidc-interaction-no-consent.v1" + VerifierOIDCInteractionNoMatchFound EventType = "verifier.oidc-interaction-no-match-found.v1" + VerifierOIDCInteractionExpired EventType = "verifier.oidc-interaction-expired.v1" + // IssuerOIDCInteractionInitiated Issuer oidc event. IssuerOIDCInteractionInitiated EventType = "issuer.oidc-interaction-initiated.v1" // IssuerOIDCInteractionQRScanned Issuer oidc event. diff --git a/pkg/kms/aws/service_mocks.go b/pkg/kms/aws/service_mocks.go index bf804e464..3973e662b 100644 --- a/pkg/kms/aws/service_mocks.go +++ b/pkg/kms/aws/service_mocks.go @@ -357,4 +357,4 @@ func (m *MockmetricsProvider) VerifyTime(value time.Duration) { func (mr *MockmetricsProviderMockRecorder) VerifyTime(value interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyTime", reflect.TypeOf((*MockmetricsProvider)(nil).VerifyTime), value) -} \ No newline at end of file +} diff --git a/pkg/kms/mocks/kms_mocks.go b/pkg/kms/mocks/kms_mocks.go index 2b02f6366..8ca0def08 100644 --- a/pkg/kms/mocks/kms_mocks.go +++ b/pkg/kms/mocks/kms_mocks.go @@ -48,33 +48,9 @@ func (m *MockVCSKeyManager) CreateCryptoKey(keyType kms.KeyType) (string, interf } // CreateCryptoKey indicates an expected call of CreateCryptoKey. -func (mr *MockVCSKeyManagerMockRecorder) CreateCryptoKey(keyType interface{}) *VCSKeyManagerCreateCryptoKeyCall { +func (mr *MockVCSKeyManagerMockRecorder) CreateCryptoKey(keyType interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCryptoKey", reflect.TypeOf((*MockVCSKeyManager)(nil).CreateCryptoKey), keyType) - return &VCSKeyManagerCreateCryptoKeyCall{Call: call} -} - -// VCSKeyManagerCreateCryptoKeyCall wrap *gomock.Call -type VCSKeyManagerCreateCryptoKeyCall struct { - *gomock.Call -} - -// Return rewrite *gomock.Call.Return -func (c *VCSKeyManagerCreateCryptoKeyCall) Return(arg0 string, arg1 interface{}, arg2 error) *VCSKeyManagerCreateCryptoKeyCall { - c.Call = c.Call.Return(arg0, arg1, arg2) - return c -} - -// Do rewrite *gomock.Call.Do -func (c *VCSKeyManagerCreateCryptoKeyCall) Do(f func(kms.KeyType) (string, interface{}, error)) *VCSKeyManagerCreateCryptoKeyCall { - c.Call = c.Call.Do(f) - return c -} - -// DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *VCSKeyManagerCreateCryptoKeyCall) DoAndReturn(f func(kms.KeyType) (string, interface{}, error)) *VCSKeyManagerCreateCryptoKeyCall { - c.Call = c.Call.DoAndReturn(f) - return c + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCryptoKey", reflect.TypeOf((*MockVCSKeyManager)(nil).CreateCryptoKey), keyType) } // CreateJWKKey mocks base method. @@ -88,33 +64,9 @@ func (m *MockVCSKeyManager) CreateJWKKey(keyType kms.KeyType) (string, *jwk.JWK, } // CreateJWKKey indicates an expected call of CreateJWKKey. -func (mr *MockVCSKeyManagerMockRecorder) CreateJWKKey(keyType interface{}) *VCSKeyManagerCreateJWKKeyCall { +func (mr *MockVCSKeyManagerMockRecorder) CreateJWKKey(keyType interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateJWKKey", reflect.TypeOf((*MockVCSKeyManager)(nil).CreateJWKKey), keyType) - return &VCSKeyManagerCreateJWKKeyCall{Call: call} -} - -// VCSKeyManagerCreateJWKKeyCall wrap *gomock.Call -type VCSKeyManagerCreateJWKKeyCall struct { - *gomock.Call -} - -// Return rewrite *gomock.Call.Return -func (c *VCSKeyManagerCreateJWKKeyCall) Return(arg0 string, arg1 *jwk.JWK, arg2 error) *VCSKeyManagerCreateJWKKeyCall { - c.Call = c.Call.Return(arg0, arg1, arg2) - return c -} - -// Do rewrite *gomock.Call.Do -func (c *VCSKeyManagerCreateJWKKeyCall) Do(f func(kms.KeyType) (string, *jwk.JWK, error)) *VCSKeyManagerCreateJWKKeyCall { - c.Call = c.Call.Do(f) - return c -} - -// DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *VCSKeyManagerCreateJWKKeyCall) DoAndReturn(f func(kms.KeyType) (string, *jwk.JWK, error)) *VCSKeyManagerCreateJWKKeyCall { - c.Call = c.Call.DoAndReturn(f) - return c + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateJWKKey", reflect.TypeOf((*MockVCSKeyManager)(nil).CreateJWKKey), keyType) } // NewVCSigner mocks base method. @@ -127,33 +79,9 @@ func (m *MockVCSKeyManager) NewVCSigner(creator string, signatureType verifiable } // NewVCSigner indicates an expected call of NewVCSigner. -func (mr *MockVCSKeyManagerMockRecorder) NewVCSigner(creator, signatureType interface{}) *VCSKeyManagerNewVCSignerCall { +func (mr *MockVCSKeyManagerMockRecorder) NewVCSigner(creator, signatureType interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewVCSigner", reflect.TypeOf((*MockVCSKeyManager)(nil).NewVCSigner), creator, signatureType) - return &VCSKeyManagerNewVCSignerCall{Call: call} -} - -// VCSKeyManagerNewVCSignerCall wrap *gomock.Call -type VCSKeyManagerNewVCSignerCall struct { - *gomock.Call -} - -// Return rewrite *gomock.Call.Return -func (c *VCSKeyManagerNewVCSignerCall) Return(arg0 vc.SignerAlgorithm, arg1 error) *VCSKeyManagerNewVCSignerCall { - c.Call = c.Call.Return(arg0, arg1) - return c -} - -// Do rewrite *gomock.Call.Do -func (c *VCSKeyManagerNewVCSignerCall) Do(f func(string, verifiable.SignatureType) (vc.SignerAlgorithm, error)) *VCSKeyManagerNewVCSignerCall { - c.Call = c.Call.Do(f) - return c -} - -// DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *VCSKeyManagerNewVCSignerCall) DoAndReturn(f func(string, verifiable.SignatureType) (vc.SignerAlgorithm, error)) *VCSKeyManagerNewVCSignerCall { - c.Call = c.Call.DoAndReturn(f) - return c + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewVCSigner", reflect.TypeOf((*MockVCSKeyManager)(nil).NewVCSigner), creator, signatureType) } // SupportedKeyTypes mocks base method. @@ -165,31 +93,7 @@ func (m *MockVCSKeyManager) SupportedKeyTypes() []kms.KeyType { } // SupportedKeyTypes indicates an expected call of SupportedKeyTypes. -func (mr *MockVCSKeyManagerMockRecorder) SupportedKeyTypes() *VCSKeyManagerSupportedKeyTypesCall { +func (mr *MockVCSKeyManagerMockRecorder) SupportedKeyTypes() *gomock.Call { mr.mock.ctrl.T.Helper() - call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SupportedKeyTypes", reflect.TypeOf((*MockVCSKeyManager)(nil).SupportedKeyTypes)) - return &VCSKeyManagerSupportedKeyTypesCall{Call: call} + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SupportedKeyTypes", reflect.TypeOf((*MockVCSKeyManager)(nil).SupportedKeyTypes)) } - -// VCSKeyManagerSupportedKeyTypesCall wrap *gomock.Call -type VCSKeyManagerSupportedKeyTypesCall struct { - *gomock.Call -} - -// Return rewrite *gomock.Call.Return -func (c *VCSKeyManagerSupportedKeyTypesCall) Return(arg0 []kms.KeyType) *VCSKeyManagerSupportedKeyTypesCall { - c.Call = c.Call.Return(arg0) - return c -} - -// Do rewrite *gomock.Call.Do -func (c *VCSKeyManagerSupportedKeyTypesCall) Do(f func() []kms.KeyType) *VCSKeyManagerSupportedKeyTypesCall { - c.Call = c.Call.Do(f) - return c -} - -// DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *VCSKeyManagerSupportedKeyTypesCall) DoAndReturn(f func() []kms.KeyType) *VCSKeyManagerSupportedKeyTypesCall { - c.Call = c.Call.DoAndReturn(f) - return c -} \ No newline at end of file diff --git a/pkg/observability/tracing/wrappers/oidc4vp/oidc4vp_wrapper.go b/pkg/observability/tracing/wrappers/oidc4vp/oidc4vp_wrapper.go index 352ab6b44..09f1c152d 100644 --- a/pkg/observability/tracing/wrappers/oidc4vp/oidc4vp_wrapper.go +++ b/pkg/observability/tracing/wrappers/oidc4vp/oidc4vp_wrapper.go @@ -97,3 +97,13 @@ func (w *Wrapper) DeleteClaims(ctx context.Context, claimsID string) error { return w.svc.DeleteClaims(ctx, claimsID) } + +func (w *Wrapper) HandleWalletNotification(ctx context.Context, req *oidc4vp.WalletNotification) error { + ctx, span := w.tracer.Start(ctx, "oidc4vp.HandleWalletNotification") + defer span.End() + + span.SetAttributes(attribute.String("tx_id", string(req.TxID))) + span.SetAttributes(attribute.String("event", req.Error)) + + return w.svc.HandleWalletNotification(ctx, req) +} diff --git a/pkg/observability/tracing/wrappers/oidc4vp/oidc4vp_wrapper_test.go b/pkg/observability/tracing/wrappers/oidc4vp/oidc4vp_wrapper_test.go index 9025f4bf7..87b455e78 100644 --- a/pkg/observability/tracing/wrappers/oidc4vp/oidc4vp_wrapper_test.go +++ b/pkg/observability/tracing/wrappers/oidc4vp/oidc4vp_wrapper_test.go @@ -11,6 +11,8 @@ import ( "context" "testing" + "github.com/google/uuid" + "github.com/golang/mock/gomock" "github.com/stretchr/testify/require" "github.com/trustbloc/vc-go/presexch" @@ -76,3 +78,20 @@ func TestWrapper_DeleteClaims(t *testing.T) { _ = w.DeleteClaims(context.Background(), "claimsID") } + +func TestWrapper_HandleWalletNotification(t *testing.T) { + ctrl := gomock.NewController(t) + + ack := &oidc4vp.WalletNotification{ + TxID: oidc4vp.TxID(uuid.NewString()), + Error: uuid.NewString(), + ErrorDescription: uuid.NewString(), + } + + svc := NewMockService(ctrl) + svc.EXPECT().HandleWalletNotification(gomock.Any(), ack).Times(1) + + w := Wrap(svc, nooptracer.NewTracerProvider().Tracer("")) + + _ = w.HandleWalletNotification(context.Background(), ack) +} diff --git a/pkg/restapi/v1/oidc4ci/controller.go b/pkg/restapi/v1/oidc4ci/controller.go index fbaf0dbf1..a67605539 100644 --- a/pkg/restapi/v1/oidc4ci/controller.go +++ b/pkg/restapi/v1/oidc4ci/controller.go @@ -129,10 +129,7 @@ type CwtProofChecker interface { } type AckService interface { - Ack( - ctx context.Context, - req oidc4ci.AckRemote, - ) error + Ack(ctx context.Context, req oidc4ci.AckRemote) error } type LDPProofParser interface { @@ -623,7 +620,7 @@ func mustGenerateNonce() string { return base64.URLEncoding.EncodeToString(b) } -// OidcAcknowledgement handles OIDC acknowledgement request (POST /oidc/notification). +// OidcAcknowledgement handles OIDC4CI acknowledgement request (POST /oidc/notification). func (c *Controller) OidcAcknowledgement(e echo.Context) error { req := e.Request() diff --git a/pkg/restapi/v1/oidc4vp/controller.go b/pkg/restapi/v1/oidc4vp/controller.go index 4b7d443ad..ae416a71b 100644 --- a/pkg/restapi/v1/oidc4vp/controller.go +++ b/pkg/restapi/v1/oidc4vp/controller.go @@ -5,7 +5,7 @@ SPDX-License-Identifier: Apache-2.0 */ //go:generate oapi-codegen --config=openapi.cfg.yaml ../../../../docs/v1/openapi.yaml -//go:generate mockgen -destination controller_mocks_test.go -self_package mocks -package oidc4vp_test . HTTPClient +//go:generate mockgen -destination controller_mocks_test.go -self_package mocks -package oidc4vp_test -source=controller.go -mock_names httpClient=MockHTTPClient package oidc4vp diff --git a/pkg/restapi/v1/oidc4vp/controller_test.go b/pkg/restapi/v1/oidc4vp/controller_test.go index 2b3a8e38f..67486dfbe 100644 --- a/pkg/restapi/v1/oidc4vp/controller_test.go +++ b/pkg/restapi/v1/oidc4vp/controller_test.go @@ -17,9 +17,10 @@ import ( "github.com/golang/mock/gomock" "github.com/labstack/echo/v4" - "github.com/stretchr/testify/require" - "github.com/trustbloc/vcs/pkg/restapi/v1/oidc4vp" + "github.com/stretchr/testify/assert" nooptracer "go.opentelemetry.io/otel/trace/noop" + + "github.com/trustbloc/vcs/pkg/restapi/v1/oidc4vp" ) func TestController_OidcPresent(t *testing.T) { @@ -41,8 +42,8 @@ func TestController_OidcPresent(t *testing.T) { ) }, check: func(t *testing.T, rec *httptest.ResponseRecorder, err error) { - require.NoError(t, err) - require.Equal(t, http.StatusOK, rec.Code) + assert.NoError(t, err) + assert.Equal(t, http.StatusOK, rec.Code) }, }, { @@ -54,7 +55,7 @@ func TestController_OidcPresent(t *testing.T) { ) }, check: func(t *testing.T, rec *httptest.ResponseRecorder, err error) { - require.ErrorContains(t, err, "failed to send request") + assert.ErrorContains(t, err, "failed to send request") }, }, { @@ -68,7 +69,7 @@ func TestController_OidcPresent(t *testing.T) { ) }, check: func(t *testing.T, rec *httptest.ResponseRecorder, err error) { - require.ErrorContains(t, err, "failed to read response body") + assert.ErrorContains(t, err, "failed to read response body") }, }, { @@ -82,7 +83,7 @@ func TestController_OidcPresent(t *testing.T) { ) }, check: func(t *testing.T, rec *httptest.ResponseRecorder, err error) { - require.ErrorContains(t, err, "error check id token") + assert.ErrorContains(t, err, "error check id token") }, }, } diff --git a/pkg/restapi/v1/verifier/controller.go b/pkg/restapi/v1/verifier/controller.go index 194e1351d..d654388d4 100644 --- a/pkg/restapi/v1/verifier/controller.go +++ b/pkg/restapi/v1/verifier/controller.go @@ -64,6 +64,8 @@ type rawAuthorizationResponse struct { IDToken string VPToken []string PresentationSubmission string + Error string + ErrorDescription string State string } @@ -453,11 +455,21 @@ func (c *Controller) CheckAuthorizationResponse(e echo.Context) error { log.WithDuration(time.Since(startTime))) }() - rawAuthResp, err := validateAuthorizationResponse(e) + rawAuthResp, err := decodeAuthorizationResponse(e) if err != nil { return err } + if rawAuthResp.Error != "" { + // Error authorization response + // Spec: https://openid.github.io/OpenID4VP/openid-4-verifiable-presentations-wg-draft.html#section-6.4 + return c.oidc4VPService.HandleWalletNotification(ctx, &oidc4vp.WalletNotification{ + TxID: oidc4vp.TxID(rawAuthResp.State), + Error: rawAuthResp.Error, + ErrorDescription: rawAuthResp.ErrorDescription, + }) + } + responseParsed, err := c.verifyAuthorizationResponseTokens(ctx, rawAuthResp) if err != nil { if tenantID, authErr := util.GetTenantIDFromRequest(e); authErr == nil { @@ -820,11 +832,11 @@ func (c *Controller) validateVPToken(vpToken string) (*VPTokenClaims, error) { }, nil } -func validateAuthorizationResponse(ctx echo.Context) (*rawAuthorizationResponse, error) { +func decodeAuthorizationResponse(ctx echo.Context) (*rawAuthorizationResponse, error) { startTime := time.Now().UTC() defer func() { - logger.Debugc(ctx.Request().Context(), "validateAuthorizationResponse", log.WithDuration(time.Since(startTime))) + logger.Debugc(ctx.Request().Context(), "decodeAuthorizationResponse", log.WithDuration(time.Since(startTime))) }() req := ctx.Request() @@ -842,6 +854,25 @@ func validateAuthorizationResponse(ctx echo.Context) (*rawAuthorizationResponse, res := &rawAuthorizationResponse{} + err = decodeFormValue(&res.State, "state", req.PostForm) + if err != nil { + return nil, err + } + + err = decodeFormValue(&res.Error, "error", req.PostForm) + if err == nil { + // Error authorization response + // Spec: https://openid.github.io/OpenID4VP/openid-4-verifiable-presentations-wg-draft.html#section-6.4 + err = decodeFormValue(&res.ErrorDescription, "error_description", req.PostForm) + if err != nil { + return nil, err + } + + return res, nil + } + + logger.Debugc(ctx.Request().Context(), "AuthorizationResponse state decoded", log.WithState(res.State)) + err = decodeFormValue(&res.IDToken, "id_token", req.PostForm) if err != nil { return nil, err @@ -871,13 +902,6 @@ func validateAuthorizationResponse(ctx echo.Context) (*rawAuthorizationResponse, logger.Debugc(ctx.Request().Context(), "AuthorizationResponse presentation_submission decoded", log.WithState(res.State)) - err = decodeFormValue(&res.State, "state", req.PostForm) - if err != nil { - return nil, err - } - - logger.Debugc(ctx.Request().Context(), "AuthorizationResponse state decoded", log.WithState(res.State)) - return res, nil } diff --git a/pkg/restapi/v1/verifier/controller_test.go b/pkg/restapi/v1/verifier/controller_test.go index 3341c0e66..74384b2f3 100644 --- a/pkg/restapi/v1/verifier/controller_test.go +++ b/pkg/restapi/v1/verifier/controller_test.go @@ -470,62 +470,6 @@ func TestController_CheckAuthorizationResponse(t *testing.T) { svc.EXPECT().VerifyOIDCVerifiablePresentation(gomock.Any(), oidc4vp.TxID("txid"), gomock.Any()). AnyTimes().Return(nil) - t.Run("Success Controller JWT", func(t *testing.T) { - signedClaimsJWTResult := testutil.SignedClaimsJWT(t, - &IDTokenClaims{ - Nonce: validNonce, - Aud: validAud, - Exp: time.Now().Unix() + 1000, - }, - ) - - vpToken := testutil.SignedClaimsJWTWithExistingPrivateKey(t, - signedClaimsJWTResult.VerMethodDIDKeyID, - signedClaimsJWTResult.Signer, - &VPTokenClaims{ - Nonce: validNonce, - Aud: validAud, - Iss: signedClaimsJWTResult.VerMethodDID, - Exp: time.Now().Unix() + 1000, - VP: &verifiable.Presentation{ - Context: []string{ - "https://www.w3.org/2018/credentials/v1", - "https://identity.foundation/presentation-exchange/submission/v1", - }, - Type: []string{ - "VerifiablePresentation", - "PresentationSubmission", - }, - }, - }, - ) - - presentationSubmission, err := json.Marshal(map[string]interface{}{}) - require.NoError(t, err) - - body := "vp_token=" + vpToken + - "&id_token=" + signedClaimsJWTResult.JWT + - "&presentation_submission=" + string(presentationSubmission) + - "&state=txid" - - ctx := createContextApplicationForm([]byte(body)) - - mockEventSvc := NewMockeventService(gomock.NewController(t)) - mockEventSvc.EXPECT().Publish(gomock.Any(), spi.VerifierEventTopic, gomock.Any()).Times(0) - - c := NewController(&Config{ - VDR: signedClaimsJWTResult.VDR, - OIDCVPService: svc, - EventSvc: mockEventSvc, - EventTopic: spi.VerifierEventTopic, - DocumentLoader: testutil.DocumentLoader(t), - Tracer: nooptracer.NewTracerProvider().Tracer(""), - }) - - err = c.CheckAuthorizationResponse(ctx) - require.NoError(t, err) - }) - t.Run("Success JWT", func(t *testing.T) { signedClaimsJWTResult := testutil.SignedClaimsJWT(t, &IDTokenClaims{ @@ -839,6 +783,50 @@ func TestController_CheckAuthorizationResponse(t *testing.T) { require.Contains(t, responseParsed.VPTokens[0].Presentation.Type, "PresentationSubmission") }) + t.Run("Success error AR response", func(t *testing.T) { + body := "error=invalid_request" + + "&error_description=unsupported%20client_id_scheme" + + "&state=txid" + + ctx := createContextApplicationForm([]byte(body)) + + svc.EXPECT().HandleWalletNotification(gomock.Any(), &oidc4vp.WalletNotification{ + TxID: oidc4vp.TxID("txid"), + Error: "invalid_request", + ErrorDescription: "unsupported client_id_scheme", + }).Return(nil) + + c := NewController(&Config{ + OIDCVPService: svc, + Tracer: nooptracer.NewTracerProvider().Tracer(""), + }) + + err := c.CheckAuthorizationResponse(ctx) + require.NoError(t, err) + }) + + t.Run("Error: failed to HandleWalletNotification", func(t *testing.T) { + body := "error=invalid_request" + + "&error_description=unsupported%20client_id_scheme" + + "&state=txid" + + ctx := createContextApplicationForm([]byte(body)) + + svc.EXPECT().HandleWalletNotification(gomock.Any(), &oidc4vp.WalletNotification{ + TxID: oidc4vp.TxID("txid"), + Error: "invalid_request", + ErrorDescription: "unsupported client_id_scheme", + }).Return(errors.New("handle wallet notification error")) + + c := NewController(&Config{ + OIDCVPService: svc, + Tracer: nooptracer.NewTracerProvider().Tracer(""), + }) + + err := c.CheckAuthorizationResponse(ctx) + require.ErrorContains(t, err, "handle wallet notification error") + }) + t.Run("Presentation submission missed", func(t *testing.T) { signedClaimsJWTResult := testutil.SignedClaimsJWT(t, &IDTokenClaims{ @@ -1758,7 +1746,7 @@ func TestController_RetrieveInteractionsClaim(t *testing.T) { }) } -func TestController_validateAuthorizationResponse(t *testing.T) { +func TestController_decodeAuthorizationResponse(t *testing.T) { t.Run("Success", func(t *testing.T) { body := "vp_token=toke1&" + "&id_token=toke2" + @@ -1766,11 +1754,27 @@ func TestController_validateAuthorizationResponse(t *testing.T) { ctx := createContextApplicationForm([]byte(body)) - ar, err := validateAuthorizationResponse(ctx) + ar, err := decodeAuthorizationResponse(ctx) require.NoError(t, err) require.NotNil(t, ar) }) + t.Run("Success: authorization error response", func(t *testing.T) { + body := "error=invalid_request" + + "&error_description=unsupported%20client_id_scheme" + + "&state=txid" + + ctx := createContextApplicationForm([]byte(body)) + + ar, err := decodeAuthorizationResponse(ctx) + require.NoError(t, err) + require.NotNil(t, ar) + + require.Equal(t, ar.State, "txid") + require.Equal(t, ar.Error, "invalid_request") + require.Equal(t, ar.ErrorDescription, "unsupported client_id_scheme") + }) + t.Run("Success - vp token is an array", func(t *testing.T) { body := "vp_token=%5B%22token1%22%2C%22token2%22%5D" + "&id_token=idtoken" + @@ -1778,18 +1782,61 @@ func TestController_validateAuthorizationResponse(t *testing.T) { ctx := createContextApplicationForm([]byte(body)) - ar, err := validateAuthorizationResponse(ctx) + ar, err := decodeAuthorizationResponse(ctx) require.NoError(t, err) require.NotNil(t, ar) }) + t.Run("Missed state", func(t *testing.T) { + body := "id_token=v1&" + + "&vp_token=t" + + ctx := createContextApplicationForm([]byte(body)) + + _, err := decodeAuthorizationResponse(ctx) + requireValidationError(t, resterr.InvalidValue, "state", err) + }) + + t.Run("Duplicated state", func(t *testing.T) { + body := "id_token=v1&" + + "vp_token=1&state=2" + + "&state=txid" + + ctx := createContextApplicationForm([]byte(body)) + + _, err := decodeAuthorizationResponse(ctx) + requireValidationError(t, resterr.InvalidValue, "state", err) + }) + + t.Run("Error: authorization error response: missed error_description", func(t *testing.T) { + body := "error=invalid_request" + + "&state=txid" + + ctx := createContextApplicationForm([]byte(body)) + + _, err := decodeAuthorizationResponse(ctx) + requireValidationError(t, resterr.InvalidValue, "error_description", err) + }) + + t.Run("Error: authorization error response: duplicated error_description", func(t *testing.T) { + body := "error=invalid_request" + + "&error_description=unsupported%20client_id_scheme" + + "&error_description=unsupported%20client_id_scheme" + + "&state=txid" + + ctx := createContextApplicationForm([]byte(body)) + + _, err := decodeAuthorizationResponse(ctx) + requireValidationError(t, resterr.InvalidValue, "error_description", err) + }) + t.Run("Missed id_token", func(t *testing.T) { body := "vp_token=v1&" + "&state=txid" ctx := createContextApplicationForm([]byte(body)) - _, err := validateAuthorizationResponse(ctx) + _, err := decodeAuthorizationResponse(ctx) requireValidationError(t, resterr.InvalidValue, "id_token", err) }) @@ -1800,7 +1847,7 @@ func TestController_validateAuthorizationResponse(t *testing.T) { ctx := createContextApplicationForm([]byte(body)) - _, err := validateAuthorizationResponse(ctx) + _, err := decodeAuthorizationResponse(ctx) requireValidationError(t, resterr.InvalidValue, "id_token", err) }) @@ -1810,7 +1857,7 @@ func TestController_validateAuthorizationResponse(t *testing.T) { ctx := createContextApplicationForm([]byte(body)) - _, err := validateAuthorizationResponse(ctx) + _, err := decodeAuthorizationResponse(ctx) requireValidationError(t, resterr.InvalidValue, "vp_token", err) }) @@ -1821,30 +1868,9 @@ func TestController_validateAuthorizationResponse(t *testing.T) { ctx := createContextApplicationForm([]byte(body)) - _, err := validateAuthorizationResponse(ctx) + _, err := decodeAuthorizationResponse(ctx) requireValidationError(t, resterr.InvalidValue, "vp_token", err) }) - - t.Run("Missed state", func(t *testing.T) { - body := "id_token=v1&" + - "&vp_token=t" - - ctx := createContextApplicationForm([]byte(body)) - - _, err := validateAuthorizationResponse(ctx) - requireValidationError(t, resterr.InvalidValue, "state", err) - }) - - t.Run("Duplicated state", func(t *testing.T) { - body := "id_token=v1&" + - "vp_token=1&state=2" + - "&state=txid" - - ctx := createContextApplicationForm([]byte(body)) - - _, err := validateAuthorizationResponse(ctx) - requireValidationError(t, resterr.InvalidValue, "state", err) - }) } func Test_getVerifyCredentialOptions(t *testing.T) { diff --git a/pkg/service/oidc4ci/oidc4ci_acknowledgement.go b/pkg/service/oidc4ci/oidc4ci_acknowledgement.go index 30f81baf7..7b4507217 100644 --- a/pkg/service/oidc4ci/oidc4ci_acknowledgement.go +++ b/pkg/service/oidc4ci/oidc4ci_acknowledgement.go @@ -128,12 +128,11 @@ func (s *AckService) Ack( ProfileID: ack.ProfileID, ProfileVersion: ack.ProfileVersion, OrgID: ack.OrgID, + ErrorComponent: "wallet", + Error: req.EventDescription, + ErrorCode: req.Event, } - eventPayload.ErrorComponent = "wallet" - eventPayload.Error = req.EventDescription - eventPayload.ErrorCode = req.Event - err = s.sendEvent(ctx, s.AckEventMap(req.Event), extractTransactionID(ack.TxID), eventPayload) if err != nil { return err diff --git a/pkg/service/oidc4vp/api.go b/pkg/service/oidc4vp/api.go index c73d3f1aa..90bc27007 100644 --- a/pkg/service/oidc4vp/api.go +++ b/pkg/service/oidc4vp/api.go @@ -59,6 +59,12 @@ type CredentialMetadata struct { Attachments []*Attachment `json:"attachments"` } +type WalletNotification struct { + TxID TxID + Error string + ErrorDescription string +} + type ServiceInterface interface { InitiateOidcInteraction( ctx context.Context, @@ -72,6 +78,7 @@ type ServiceInterface interface { GetTx(ctx context.Context, id TxID) (*Transaction, error) RetrieveClaims(ctx context.Context, tx *Transaction, profile *profileapi.Verifier) map[string]CredentialMetadata DeleteClaims(ctx context.Context, receivedClaimsID string) error + HandleWalletNotification(ctx context.Context, req *WalletNotification) error } type EventPayload struct { @@ -151,6 +158,7 @@ type ClientMetadata struct { VPFormats *presexch.Format `json:"vp_formats"` ClientPurpose string `json:"client_purpose"` LogoURI string `json:"logo_uri"` + NotificationEndpoint string `json:"notification_endpoint"` } type attachmentData struct { diff --git a/pkg/service/oidc4vp/oidc4vp_service.go b/pkg/service/oidc4vp/oidc4vp_service.go index a1d150f6a..500a7f2b2 100644 --- a/pkg/service/oidc4vp/oidc4vp_service.go +++ b/pkg/service/oidc4vp/oidc4vp_service.go @@ -136,6 +136,7 @@ type Config struct { VDR vdrapi.Registry TrustRegistry trustRegistry ResponseURI string + AckEndpoint string TokenLifetime time.Duration Metrics metricsProvider AttachmentService attachmentService @@ -155,6 +156,7 @@ type Service struct { attachmentService attachmentService responseURI string + ackEndpoint string tokenLifetime time.Duration metrics metricsProvider @@ -177,6 +179,7 @@ func NewService(cfg *Config) *Service { profileService: cfg.ProfileService, presentationVerifier: cfg.PresentationVerifier, responseURI: cfg.ResponseURI, + ackEndpoint: cfg.AckEndpoint, tokenLifetime: cfg.TokenLifetime, vdr: cfg.VDR, trustRegistry: cfg.TrustRegistry, @@ -895,6 +898,7 @@ func (s *Service) createRequestObject( VPFormats: vpFormats, ClientPurpose: purpose, LogoURI: profile.LogoURL, + NotificationEndpoint: s.ackEndpoint, }, PresentationDefinition: presentationDefinition, } diff --git a/pkg/service/oidc4vp/oidc4vp_wallet_notification.go b/pkg/service/oidc4vp/oidc4vp_wallet_notification.go new file mode 100644 index 000000000..1b3a5f5d3 --- /dev/null +++ b/pkg/service/oidc4vp/oidc4vp_wallet_notification.go @@ -0,0 +1,133 @@ +/* +Copyright SecureKey Technologies Inc. All Rights Reserved. + +SPDX-License-Identifier: Apache-2.0 +*/ + +package oidc4vp + +import ( + "context" + "errors" + "fmt" + "strings" + + "go.uber.org/zap" + + "github.com/trustbloc/vcs/pkg/event/spi" + profileapi "github.com/trustbloc/vcs/pkg/profile" + "github.com/trustbloc/vcs/pkg/restapi/resterr" +) + +const ( + // Spec: https://openid.github.io/OpenID4VP/openid-4-verifiable-presentations-wg-draft.html#section-6.4 + authResponseErrTypeInvalidScope = "invalid_scope" + authResponseErrTypeInvalidRequest = "invalid_request" + authResponseErrTypeInvalidClient = "invalid_client" + authResponseErrTypeAccessDenied = "access_denied" + authResponseErrTypeVPFormatsNotSupported = "vp_formats_not_supported" + authResponseErrTypeInvalidPDURI = "invalid_presentation_definition_uri" + authResponseErrTypeInvalidPDReference = "invalid_presentation_definition_reference" + authResponseErrTypeInvalidRequestURIMethod = "invalid_request_uri_method" + authResponseErrTypeWalletUnavailable = "wallet_unavailable" + + errorComponentWallet = "wallet" + + errorDescriptionNoConsent = "no_consent" + errorDescriptionNoMatchFound = "no_match_found" +) + +var supportedAuthResponseErrTypes = map[string]struct{}{ //nolint:gochecknoglobals + authResponseErrTypeInvalidScope: {}, + authResponseErrTypeInvalidRequest: {}, + authResponseErrTypeInvalidClient: {}, + authResponseErrTypeAccessDenied: {}, + authResponseErrTypeVPFormatsNotSupported: {}, + authResponseErrTypeInvalidPDURI: {}, + authResponseErrTypeInvalidPDReference: {}, + authResponseErrTypeInvalidRequestURIMethod: {}, + authResponseErrTypeWalletUnavailable: {}, +} + +// HandleWalletNotification handles wallet notifications. +func (s *Service) HandleWalletNotification(ctx context.Context, req *WalletNotification) error { + tx, err := s.transactionManager.Get(req.TxID) + if err != nil { + if errors.Is(err, ErrDataNotFound) { + return s.handleAckNotFound(ctx, req) + } + + return resterr.NewSystemError(resterr.VerifierTxnMgrComponent, "get-txn", + fmt.Errorf("fail to get oidc tx: %w", err)) + } + + profile, err := s.profileService.GetProfile(tx.ProfileID, tx.ProfileVersion) + if err != nil { + if strings.Contains(err.Error(), "not found") { + return resterr.NewCustomError(resterr.ProfileNotFound, + fmt.Errorf("profile with given id %s_%s, doesn't exist", tx.ProfileID, tx.ProfileVersion)) + } + + return resterr.NewSystemError(resterr.IssuerProfileSvcComponent, "GetProfile", err) + } + + err = s.sendWalletNotificationEvent(ctx, tx, profile, req) + if err != nil { + return err + } + + return nil +} + +func (s *Service) handleAckNotFound(ctx context.Context, ackData *WalletNotification) error { + eventPayload := &EventPayload{ + Error: ackData.ErrorDescription, + ErrorCode: ackData.Error, + ErrorComponent: errorComponentWallet, + } + + event, err := CreateEvent(spi.VerifierOIDCInteractionExpired, ackData.TxID, eventPayload) + if err != nil { + return err + } + + return s.eventSvc.Publish(ctx, s.eventTopic, event) +} + +func (s *Service) sendWalletNotificationEvent( + ctx context.Context, + tx *Transaction, + profile *profileapi.Verifier, + notification *WalletNotification, +) error { + if _, isValidError := supportedAuthResponseErrTypes[notification.Error]; !isValidError { + logger.Infoc(ctx, "Ignoring unsupported error type", zap.String("error", notification.Error)) + return nil + } + + ep := createTxEventPayload(tx, profile) + + ep.Error, ep.ErrorCode, ep.ErrorComponent = notification.ErrorDescription, notification.Error, errorComponentWallet + + spiEventType := s.getEventType(notification.Error, notification.ErrorDescription) + + event, e := CreateEvent(spiEventType, tx.ID, ep) + if e != nil { + return e + } + + return s.eventSvc.Publish(ctx, s.eventTopic, event) +} + +func (s *Service) getEventType(e, errorDescription string) spi.EventType { + if strings.ToLower(e) == authResponseErrTypeAccessDenied { + switch strings.ToLower(errorDescription) { + case errorDescriptionNoConsent: + return spi.VerifierOIDCInteractionNoConsent + case errorDescriptionNoMatchFound: + return spi.VerifierOIDCInteractionNoMatchFound + } + } + + return spi.VerifierOIDCInteractionFailed +} diff --git a/pkg/service/oidc4vp/oidc4vp_wallet_notification_test.go b/pkg/service/oidc4vp/oidc4vp_wallet_notification_test.go new file mode 100644 index 000000000..2160daf2f --- /dev/null +++ b/pkg/service/oidc4vp/oidc4vp_wallet_notification_test.go @@ -0,0 +1,391 @@ +package oidc4vp_test + +import ( + "context" + "errors" + "fmt" + "testing" + + "github.com/golang/mock/gomock" + "github.com/google/uuid" + "github.com/stretchr/testify/assert" + + "github.com/trustbloc/vcs/pkg/event/spi" + profileapi "github.com/trustbloc/vcs/pkg/profile" + "github.com/trustbloc/vcs/pkg/restapi/resterr" + "github.com/trustbloc/vcs/pkg/service/oidc4vp" +) + +func TestService_HandleWalletNotification_SupportedAuthResponseErrorTypes(t *testing.T) { + var ( + ctx = context.Background() + transactionManager = NewMockTransactionManager(gomock.NewController(t)) + profileService = NewMockProfileService(gomock.NewController(t)) + eventService = NewMockeventService(gomock.NewController(t)) + + transactionID = oidc4vp.TxID(uuid.NewString()) + profileOrgID = uuid.NewString() + profileWebHook = "https://example/com/webhook" + ) + + tests := []struct { + Error string + ErrorDescription string + ExpectedEventType spi.EventType + }{ + { + Error: "invalid_scope", + ErrorDescription: "error description", + ExpectedEventType: spi.VerifierOIDCInteractionFailed, + }, + { + Error: "invalid_request", + ErrorDescription: "error description", + ExpectedEventType: spi.VerifierOIDCInteractionFailed, + }, + { + Error: "invalid_client", + ErrorDescription: "error description", + ExpectedEventType: spi.VerifierOIDCInteractionFailed, + }, + { + Error: "access_denied", + ErrorDescription: "error description", + ExpectedEventType: spi.VerifierOIDCInteractionFailed, + }, + { + Error: "access_denied", + ErrorDescription: "no_consent", + ExpectedEventType: spi.VerifierOIDCInteractionNoConsent, + }, + { + Error: "access_denied", + ErrorDescription: "no_match_found", + ExpectedEventType: spi.VerifierOIDCInteractionNoMatchFound, + }, + { + Error: "vp_formats_not_supported", + ErrorDescription: "error description", + ExpectedEventType: spi.VerifierOIDCInteractionFailed, + }, + { + Error: "invalid_presentation_definition_uri", + ErrorDescription: "error description", + ExpectedEventType: spi.VerifierOIDCInteractionFailed, + }, + { + Error: "invalid_presentation_definition_reference", + ErrorDescription: "error description", + ExpectedEventType: spi.VerifierOIDCInteractionFailed, + }, + { + Error: "invalid_request_uri_method", + ErrorDescription: "error description", + ExpectedEventType: spi.VerifierOIDCInteractionFailed, + }, + { + Error: "wallet_unavailable", + ErrorDescription: "error description", + ExpectedEventType: spi.VerifierOIDCInteractionFailed, + }, + } + + for _, tt := range tests { + t.Run(fmt.Sprintf("Success: %s error type", tt.Error), func(t *testing.T) { + transactionManager.EXPECT(). + Get(transactionID).Times(1). + Return(&oidc4vp.Transaction{ + ID: transactionID, + ProfileID: profileID, + ProfileVersion: profileVersion, + }, nil) + + profileService.EXPECT(). + GetProfile(profileID, profileVersion). + Return(&profileapi.Verifier{ + ID: profileID, + Version: profileVersion, + OrganizationID: profileOrgID, + WebHook: profileWebHook, + }, nil) + + eventService.EXPECT(). + Publish(gomock.Any(), spi.VerifierEventTopic, gomock.Any()). + DoAndReturn(func(_ context.Context, _ string, evt *spi.Event) error { + assert.NotEmpty(t, evt.ID) + assert.Equal(t, "source://vcs/verifier", evt.Source) + assert.Equal(t, string(transactionID), evt.TransactionID) + assert.Equal(t, tt.ExpectedEventType, evt.Type) + + assert.Equal(t, map[string]interface{}{ + "webHook": "https://example/com/webhook", + "profileID": profileID, + "profileVersion": profileVersion, + "orgID": profileOrgID, + "error": tt.ErrorDescription, + "errorCode": tt.Error, + "errorComponent": "wallet", + }, evt.Data) + + return nil + }) + + s := oidc4vp.NewService(&oidc4vp.Config{ + EventSvc: eventService, + EventTopic: spi.VerifierEventTopic, + TransactionManager: transactionManager, + ProfileService: profileService, + }) + + err := s.HandleWalletNotification(ctx, &oidc4vp.WalletNotification{ + TxID: transactionID, + Error: tt.Error, + ErrorDescription: tt.ErrorDescription, + }) + + assert.NoError(t, err) + }) + } +} + +func TestService_HandleWalletNotification_EdgeCases(t *testing.T) { + var ( + ctx = context.Background() + transactionManager = NewMockTransactionManager(gomock.NewController(t)) + profileService = NewMockProfileService(gomock.NewController(t)) + eventService = NewMockeventService(gomock.NewController(t)) + + transactionID = oidc4vp.TxID(uuid.NewString()) + profileOrgID = uuid.NewString() + profileWebHook = "https://example/com/webhook" + ) + + type fields struct { + setup func() + check func(t *testing.T, err error) + } + tests := []struct { + name string + fields fields + notification *oidc4vp.WalletNotification + }{ + { + name: "Success: failed to get transaction: not found", + fields: fields{ + setup: func() { + transactionManager.EXPECT(). + Get(transactionID).Times(1). + Return(nil, oidc4vp.ErrDataNotFound) + + eventService.EXPECT(). + Publish(gomock.Any(), spi.VerifierEventTopic, gomock.Any()). + DoAndReturn(func(_ context.Context, _ string, evt *spi.Event) error { + assert.NotEmpty(t, evt.ID) + assert.Equal(t, "source://vcs/verifier", evt.Source) + assert.Equal(t, string(transactionID), evt.TransactionID) + assert.Equal(t, spi.VerifierOIDCInteractionExpired, evt.Type) + + assert.Equal(t, map[string]interface{}{ + "errorCode": "invalid_scope", + "errorComponent": "wallet", + "error": "error description", + }, evt.Data) + + return nil + }) + }, + check: func(t *testing.T, err error) { + assert.NoError(t, err) + }, + }, + notification: &oidc4vp.WalletNotification{ + TxID: transactionID, + Error: "invalid_scope", + ErrorDescription: "error description", + }, + }, + { + name: "Success: unsupported error type", + fields: fields{ + setup: func() { + transactionManager.EXPECT(). + Get(transactionID).Times(1). + Return(&oidc4vp.Transaction{ + ID: transactionID, + ProfileID: profileID, + ProfileVersion: profileVersion, + }, nil) + + profileService.EXPECT(). + GetProfile(profileID, profileVersion). + Return(&profileapi.Verifier{ + ID: profileID, + Version: profileVersion, + OrganizationID: profileOrgID, + WebHook: profileWebHook, + }, nil) + }, + check: func(t *testing.T, err error) { + assert.NoError(t, err) + }, + }, + notification: &oidc4vp.WalletNotification{ + TxID: transactionID, + Error: uuid.NewString(), + }, + }, + { + name: "Error: failed to get transaction", + fields: fields{ + setup: func() { + transactionManager.EXPECT(). + Get(transactionID).Times(1). + Return(nil, errors.New("some error")) + }, + check: func(t *testing.T, err error) { + var sysError *resterr.CustomError + + assert.True(t, errors.As(err, &sysError)) + assert.Equal(t, sysError.Component, resterr.VerifierTxnMgrComponent) + assert.Equal(t, sysError.FailedOperation, "get-txn") + assert.ErrorContains(t, sysError.Err, "fail to get oidc tx") + }, + }, + notification: &oidc4vp.WalletNotification{ + TxID: transactionID, + }, + }, + { + name: "Error: failed to get transaction: not found: failed to publish event", + fields: fields{ + setup: func() { + transactionManager.EXPECT(). + Get(transactionID).Times(1). + Return(nil, oidc4vp.ErrDataNotFound) + + eventService.EXPECT(). + Publish(gomock.Any(), spi.VerifierEventTopic, gomock.Any()). + Return(errors.New("event service error")) + }, + check: func(t *testing.T, err error) { + assert.ErrorContains(t, err, "event service error") + }, + }, + notification: &oidc4vp.WalletNotification{ + TxID: transactionID, + Error: "invalid_scope", + ErrorDescription: "error description", + }, + }, + { + name: "Error: profile not found", + fields: fields{ + setup: func() { + transactionManager.EXPECT(). + Get(transactionID).Times(1). + Return(&oidc4vp.Transaction{ + ID: transactionID, + ProfileID: profileID, + ProfileVersion: profileVersion, + }, nil) + + profileService.EXPECT(). + GetProfile(profileID, profileVersion). + Return(nil, errors.New("not found")) + }, + check: func(t *testing.T, err error) { + var sysError *resterr.CustomError + + assert.True(t, errors.As(err, &sysError)) + assert.Equal(t, sysError.Code, resterr.ProfileNotFound) + assert.ErrorContains(t, + sysError.Err, + fmt.Sprintf("profile with given id %s_%s, doesn't exist", profileID, profileVersion)) + }, + }, + notification: &oidc4vp.WalletNotification{ + TxID: transactionID, + }, + }, + { + name: "Error: profile service error", + fields: fields{ + setup: func() { + transactionManager.EXPECT(). + Get(transactionID).Times(1). + Return(&oidc4vp.Transaction{ + ID: transactionID, + ProfileID: profileID, + ProfileVersion: profileVersion, + }, nil) + + profileService.EXPECT(). + GetProfile(profileID, profileVersion). + Return(nil, errors.New("some error")) + }, + check: func(t *testing.T, err error) { + var sysError *resterr.CustomError + + assert.True(t, errors.As(err, &sysError)) + assert.Equal(t, sysError.Component, resterr.IssuerProfileSvcComponent) + assert.Equal(t, sysError.FailedOperation, "GetProfile") + assert.ErrorContains(t, sysError.Err, "some error") + }, + }, + notification: &oidc4vp.WalletNotification{ + TxID: transactionID, + }, + }, + { + name: "Error: failed to publish event", + fields: fields{ + setup: func() { + transactionManager.EXPECT(). + Get(transactionID).Times(1). + Return(&oidc4vp.Transaction{ + ID: transactionID, + ProfileID: profileID, + ProfileVersion: profileVersion, + }, nil) + + profileService.EXPECT(). + GetProfile(profileID, profileVersion). + Return(&profileapi.Verifier{ + ID: profileID, + Version: profileVersion, + OrganizationID: profileOrgID, + WebHook: profileWebHook, + }, nil) + + eventService.EXPECT(). + Publish(gomock.Any(), spi.VerifierEventTopic, gomock.Any()). + Return(errors.New("event service error")) + }, + check: func(t *testing.T, err error) { + assert.ErrorContains(t, err, "event service error") + }, + }, + notification: &oidc4vp.WalletNotification{ + TxID: transactionID, + Error: "invalid_scope", + ErrorDescription: "error description", + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + tt.fields.setup() + + s := oidc4vp.NewService(&oidc4vp.Config{ + EventSvc: eventService, + EventTopic: spi.VerifierEventTopic, + TransactionManager: transactionManager, + ProfileService: profileService, + }) + + err := s.HandleWalletNotification(ctx, tt.notification) + + tt.fields.check(t, err) + }) + } +} diff --git a/test/bdd/features/oidc4vc_api.feature b/test/bdd/features/oidc4vc_api.feature index fa6da5057..44cf9ccca 100644 --- a/test/bdd/features/oidc4vc_api.feature +++ b/test/bdd/features/oidc4vc_api.feature @@ -106,13 +106,13 @@ Feature: OIDC4VC REST API And Verifier with profile "" requests deleted interactions claims # In examples below Initiate Issuence request and Credential request are based on credentialType param. Examples: - | issuerProfile | credentialType | useCredentialOfferForCredentialRequest | issuedCredentialsAmount | verifierProfile | presentationDefinitionID | fields | expectedCredentialCountVPFlow | + | issuerProfile | credentialType | useCredentialOfferForCredentialRequest | issuedCredentialsAmount | verifierProfile | presentationDefinitionID | fields | expectedCredentialCountVPFlow | # SDJWT issuer, JWT verifier, no limit disclosure in PD query. - | bank_issuer/v1.0 | UniversityDegreeCredential,CrudeProductCredential,VerifiedEmployee | false | 3 | v_myprofile_jwt/v1.0 | 32f54163-no-limit-disclosure-single-field | degree_type_id | 1 | - | bank_issuer/v1.0 | UniversityDegreeCredential,CrudeProductCredential | false | 2 | v_myprofile_jwt/v1.0 | 32f54163-no-limit-disclosure-single-field | degree_type_id | 1 | + | bank_issuer/v1.0 | UniversityDegreeCredential,CrudeProductCredential,VerifiedEmployee | false | 3 | v_myprofile_jwt/v1.0 | 32f54163-no-limit-disclosure-single-field | degree_type_id | 1 | + | bank_issuer/v1.0 | UniversityDegreeCredential,CrudeProductCredential | false | 2 | v_myprofile_jwt/v1.0 | 32f54163-no-limit-disclosure-single-field | degree_type_id | 1 | # Same VC type - | bank_issuer/v1.0 | UniversityDegreeCredential,UniversityDegreeCredential | false | 2 | v_myprofile_jwt/v1.0 | 32f54163-no-limit-disclosure-single-field | degree_type_id | 2 | - | bank_issuer/v1.0 | UniversityDegreeCredential,UniversityDegreeCredential | true | 2 | v_myprofile_jwt/v1.0 | 32f54163-no-limit-disclosure-single-field | degree_type_id | 2 | + | bank_issuer/v1.0 | UniversityDegreeCredential,UniversityDegreeCredential | false | 2 | v_myprofile_jwt/v1.0 | 32f54163-no-limit-disclosure-single-field | degree_type_id | 2 | + | bank_issuer/v1.0 | UniversityDegreeCredential,UniversityDegreeCredential | true | 2 | v_myprofile_jwt/v1.0 | 32f54163-no-limit-disclosure-single-field | degree_type_id | 2 | @oidc4vc_rest_auth_flow_credential_conf_id Scenario Outline: OIDC credential issuance and verification Auth flow using credential configuration ID to request specific credential type @@ -165,21 +165,21 @@ Feature: OIDC4VC REST API And Verifier with profile "" requests deleted interactions claims Examples: - | issuerProfile | credentialType | credentialTemplate | verifierProfile | presentationDefinitionID | fields | proofType | + | issuerProfile | credentialType | credentialTemplate | verifierProfile | presentationDefinitionID | fields | proofType | # SDJWT issuer, JWT verifier, no limit disclosure in PD query. - | bank_issuer/v1.0 | UniversityDegreeCredential | universityDegreeTemplateID | v_myprofile_jwt/v1.0 | 32f54163-no-limit-disclosure-single-field | degree_type_id | jwt | - | bank_issuer/v1.0 | UniversityDegreeCredential | universityDegreeTemplateID | v_myprofile_jwt/v1.0 | 32f54163-no-limit-disclosure-single-field | degree_type_id | ldp_vc | - | bank_issuer/v1.0 | UniversityDegreeCredential | universityDegreeTemplateID | v_myprofile_jwt/v1.0 | 32f54163-no-limit-disclosure-single-field | degree_type_id | cwt | - | acme_issuer/v1.0 | UniversityDegreeCredential | universityDegreeTemplateID | v_myprofile_jwt/v1.0 | 32f54163-no-limit-disclosure-single-field | degree_type_id | jwt | + | bank_issuer/v1.0 | UniversityDegreeCredential | universityDegreeTemplateID | v_myprofile_jwt/v1.0 | 32f54163-no-limit-disclosure-single-field | degree_type_id | jwt | + | bank_issuer/v1.0 | UniversityDegreeCredential | universityDegreeTemplateID | v_myprofile_jwt/v1.0 | 32f54163-no-limit-disclosure-single-field | degree_type_id | ldp_vc | + | bank_issuer/v1.0 | UniversityDegreeCredential | universityDegreeTemplateID | v_myprofile_jwt/v1.0 | 32f54163-no-limit-disclosure-single-field | degree_type_id | cwt | + | acme_issuer/v1.0 | UniversityDegreeCredential | universityDegreeTemplateID | v_myprofile_jwt/v1.0 | 32f54163-no-limit-disclosure-single-field | degree_type_id | jwt | ## SDJWT issuer, JWT verifier, limit disclosure and optional fields in PD query. - | bank_issuer/v1.0 | CrudeProductCredential | crudeProductCredentialTemplateID | v_myprofile_jwt/v1.0 | 3c8b1d9a-limit-disclosure-optional-fields | unit_of_measure_barrel,api_gravity,category,supplier_address | jwt | - | bank_issuer_sdjwt_v5/v1.0 | CrudeProductCredential | crudeProductCredentialTemplateID | v_myprofile_jwt/v1.0 | 3c8b1d9a-limit-disclosure-optional-fields | unit_of_measure_barrel,api_gravity,category,supplier_address | jwt | + | bank_issuer/v1.0 | CrudeProductCredential | crudeProductCredentialTemplateID | v_myprofile_jwt/v1.0 | 3c8b1d9a-limit-disclosure-optional-fields | unit_of_measure_barrel,api_gravity,category,supplier_address | jwt | + | bank_issuer_sdjwt_v5/v1.0 | CrudeProductCredential | crudeProductCredentialTemplateID | v_myprofile_jwt/v1.0 | 3c8b1d9a-limit-disclosure-optional-fields | unit_of_measure_barrel,api_gravity,category,supplier_address | jwt | ## JWT issuer, JWT verifier, no limit disclosure and optional fields in PD query. - | i_myprofile_ud_es256k_jwt/v1.0 | PermanentResidentCard | permanentResidentCardTemplateID | v_myprofile_jwt/v1.0 | 32f54163-no-limit-disclosure-optional-fields | lpr_category_id,commuter_classification,registration_city | jwt | + | i_myprofile_ud_es256k_jwt/v1.0 | PermanentResidentCard | permanentResidentCardTemplateID | v_myprofile_jwt/v1.0 | 32f54163-no-limit-disclosure-optional-fields | lpr_category_id,commuter_classification,registration_city | jwt | ## LDP issuer, LDP verifier, no limit disclosure and schema match in PD query. - | i_myprofile_cmtr_p256_ldp/v1.0 | CrudeProductCredential | crudeProductCredentialTemplateID | v_myprofile_ldp/v1.0 | lp403pb9-schema-match | schema_id | jwt | - | awesome_cwt/v1.0 | PermanentResidentCard | permanentResidentCardTemplateID | awesome_cwt_verifier/v1.0 | 32f54163-no-limit-disclosure-optional-fields | lpr_category_id,commuter_classification,registration_city | cwt | - | i_myprofile_ud_es256k_jwt/v1.0 | PermanentResidentCard | permanentResidentCardTemplateID | v_myprofile_jwt/v1.0 | 32f54163-no-limit-disclosure-optional-fields | lpr_category_id,commuter_classification,registration_city | cwt | + | i_myprofile_cmtr_p256_ldp/v1.0 | CrudeProductCredential | crudeProductCredentialTemplateID | v_myprofile_ldp/v1.0 | lp403pb9-schema-match | schema_id | jwt | + | awesome_cwt/v1.0 | PermanentResidentCard | permanentResidentCardTemplateID | awesome_cwt_verifier/v1.0 | 32f54163-no-limit-disclosure-optional-fields | lpr_category_id,commuter_classification,registration_city | cwt | + | i_myprofile_ud_es256k_jwt/v1.0 | PermanentResidentCard | permanentResidentCardTemplateID | v_myprofile_jwt/v1.0 | 32f54163-no-limit-disclosure-optional-fields | lpr_category_id,commuter_classification,registration_city | cwt | @oidc4vc_rest_pre_auth_flow_credential_refresh Scenario Outline: OIDC credential issuance and verification Pre Auth flow @@ -203,8 +203,8 @@ Feature: OIDC4VC REST API And Verifier with profile "" requests deleted interactions claims Examples: - | issuerProfile | credentialType | credentialTemplate | verifierProfile | presentationDefinitionID | fields | proofType | - | bank_issuer/v1.0 | UniversityDegreeCredential | universityDegreeTemplateID | v_myprofile_jwt/v1.0 | 32f54163-no-limit-disclosure-single-field | degree_type_id | jwt | + | issuerProfile | credentialType | credentialTemplate | verifierProfile | presentationDefinitionID | fields | proofType | + | bank_issuer/v1.0 | UniversityDegreeCredential | universityDegreeTemplateID | v_myprofile_jwt/v1.0 | 32f54163-no-limit-disclosure-single-field | degree_type_id | jwt | @oidc4vc_rest_pre_auth_flow_compose Scenario Outline: OIDC credential issuance and verification Pre Auth flow @@ -246,7 +246,7 @@ Feature: OIDC4VC REST API And Verifier with profile "" requests deleted interactions claims Examples: - | issuerProfile | credentialType | verifierProfile | presentationDefinitionID | fields | proofType | credentialEncoded | + | issuerProfile | credentialType | verifierProfile | presentationDefinitionID | fields | proofType | credentialEncoded | | bank_issuer/v1.0 | UniversityDegreeCredential | v_myprofile_jwt_no_strict/v1.0 | 32f54163-no-limit-disclosure-single-field | degree_type_id | jwt | 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 | @oidc4vc_rest_pre_auth_flow_compose_with_attachment_evidence @@ -268,8 +268,8 @@ Feature: OIDC4VC REST API And Verifier with profile "" requests deleted interactions claims Examples: - | issuerProfile | credentialType | attachmentData | verifierProfile | presentationDefinitionID | fields | proofType | credentialEncoded | - | bank_issuer/v1.0 | UniversityDegreeCredential | { "evidence_doc" : "data:text/plain;base64,aGVsbG8=" } | v_myprofile_jwt_no_strict/v1.0 | 32f54163-no-limit-disclosure-single-field | degree_type_id | jwt | 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 | + | issuerProfile | credentialType | attachmentData | verifierProfile | presentationDefinitionID | fields | proofType | credentialEncoded | + | bank_issuer/v1.0 | UniversityDegreeCredential | { "evidence_doc" : "data:text/plain;base64,aGVsbG8=" } | v_myprofile_jwt_no_strict/v1.0 | 32f54163-no-limit-disclosure-single-field | degree_type_id | jwt | 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 | @oidc4vc_rest_pre_auth_flow_trustlist_success Scenario Outline: OIDC credential issuance and verification Pre Auth flow with trustlist (Success) @@ -386,7 +386,7 @@ Feature: OIDC4VC REST API When User interacts with Wallet to initiate credential issuance using authorization code flow with wallet-initiated Then "1" credentials are issued Then User interacts with Verifier and initiate OIDC4VP interaction under "" profile with presentation definition ID "" and fields "" - And Verifier with profile "" waits for interaction succeeded event + And Verifier waits for "verifier.oidc-interaction-succeeded.v1" event Then we wait 15 seconds And Verifier with profile "" requests expired interactions claims @@ -404,6 +404,7 @@ Feature: OIDC4VC REST API When User interacts with Wallet to initiate credential issuance using pre authorization code flow Then "1" credentials are issued And User interacts with Verifier and initiate OIDC4VP interaction under "" profile with presentation definition ID "" and fields "" and receives "no matching credentials found" error + And Verifier waits for "verifier.oidc-interaction-no-match-found.v1" event Then we wait 15 seconds And Verifier with profile "" requests expired interactions claims @@ -424,6 +425,7 @@ Feature: OIDC4VC REST API Then "1" credentials are issued And wallet configured to use hardcoded vp_token format "jwt" for OIDC4VP interaction And User interacts with Verifier and initiate OIDC4VP interaction under "" profile with presentation definition ID "" and fields "" and receives "no matching credentials found" error + And Verifier waits for "verifier.oidc-interaction-no-match-found.v1" event Then we wait 15 seconds And Verifier with profile "" requests expired interactions claims @@ -438,7 +440,6 @@ Feature: OIDC4VC REST API And User holds credential "" with templateID "" And Profile "" verifier has been authorized with username "profile-user-verifier-1" and password "profile-user-verifier-1-pwd" - When User initiates credential issuance flow and receives "expected status code 200 but got status code 403" error Examples: | issuerProfile | credentialType | credentialTemplate | verifierProfile | @@ -450,7 +451,6 @@ Feature: OIDC4VC REST API And User holds credential "" with templateID "" And Profile "" verifier has been authorized with username "profile-user-non-verifier-1" and password "profile-user-non-verifier-1-pwd" - When User interacts with Wallet to initiate credential issuance using authorization code flow with client registration method "" Then "1" credentials are issued Then User interacts with Verifier and initiate OIDC4VP interaction under "" profile with presentation definition ID "" and fields "" and receives "expected status code 200 but got status code 403" error diff --git a/test/bdd/fixtures/cognito-config/db/local_5a9GzRvB.json b/test/bdd/fixtures/cognito-config/db/local_5a9GzRvB.json index 1db7c01e8..5340bf983 100644 --- a/test/bdd/fixtures/cognito-config/db/local_5a9GzRvB.json +++ b/test/bdd/fixtures/cognito-config/db/local_5a9GzRvB.json @@ -26,157 +26,6 @@ "UserCreateDate": "2023-09-06T09:10:29.107Z", "UserLastModifiedDate": "2023-09-06T09:10:29.107Z", "RefreshTokens": [ - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTAyNzM4MDcsImp0aSI6ImZlYmI1Yjg1LTk3NWQtNDRjOS1iYTdjLWQyM2VkMTFjN2Q4YyIsImV4cCI6MTcxMDg3ODYwNywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.kE2iy9i2JsMuPWyP3QLt2r6A6NJiZQbDr1lnAsTqYK7LZFmavDHuQDbhk3Nt40JCPo9NO4aE74aaFLsXWlCm5STFY_7rOwbWCt_58xA0pRZf0LgSgpznqjDjOC3H4Y20K2SDdoKNLhhwZtyDPjdaWw6Uj7I-9ZwN08N-QeRxTh_0QA6MpEZCoiQDwAwOrul2rtGpsIXEG0afl0uCOWPfZngHrNUvn9iIRY8LonqE2-vwO3mqP6lTpaF9v5DdhyEwIc_ExzGd_l8v9tpv9nWFHPF1KmYllGj8bm6S5w7jdYwbYR_IExNbCQBrZ7_K8esG-yyOSFRDHDMlhPAGbaye5w", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTAyNzM5ODEsImp0aSI6IjU1MjdiNjBhLWFiNDYtNDg3MS05ZGY2LWM1M2QzNTM4NDVmNiIsImV4cCI6MTcxMDg3ODc4MSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.BC5QZxai-2hjHeX1t7wQ9vfKXYJDqkvlDMlxB1Bb9Sk9UGOn6oL0j6zzshXap-jQFOxMF7uNvGOsg83JKkpygR-SJryql31tjbWvBxUEF8m9_j82A2nwwSuT7WxGCgEPAu3spC3UnNI0Js-y0G7hxSuyZxmLVvlsL9LCbWBagLgIgGy7_zfG8E0qvS_x-dKAoSKcimWkLbLmXuiyMC6x7N_h29CgZ0KxGNYDJsuejIVrbzYZ6T0-M7UFNQahvR4UTqBEXGZD7Zr_1-MChqD82dTKbRPEiZE_q-TyCvgHi5RMDnecpghD1Pk6nYWsUKiFYSlxIU8ZUZTZQqwYAmEELg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTAyNzQxNjEsImp0aSI6IjZmZTZlYTYxLTFjNWItNGU3Zi1iNzZkLTdjYmYxNDMxNmViMSIsImV4cCI6MTcxMDg3ODk2MSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.gN3RaQTo3FMMd9hs6VBYCko_D5TfKKsKldwR_fdboksBur_cMVM9dJhlFK9-jLtsAepbAGa08A9df9FTApaKzAZ-t0X1gKWbOlD7SRWzHJC1I917UhYb37Y2eZOZfknIg75Ucav-LhVvGhUQCMC9mR7Wfy2oQRMyQf30R7sDm7Mg969oEmGZKhmvN1GlnJhvPnunQjRLdHhOd00tDAh3dYjU4-Q-25GROzQVQ-HTI0a0kGD_dLreOH7lcxXUrOEZH6YGUIPxFB8crmDvJijgExGE87MltBBB-9owAImnu7iqsvmbQVGRHpDz0EJ0APaWBsTNXdiuFojvJrbk6Q74PQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTAyNzQxOTIsImp0aSI6IjNjOGZiNWM4LTY1NDYtNDhhMi1iZjExLWFiM2M2YjFjYmI2YiIsImV4cCI6MTcxMDg3ODk5MiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.WdZNIYoTy6RvFLQHRkSFxAPeDRbn19ypO_-HvV8iXTvFEYMQNQErX7a21WWYK90LcFVjdrn3z6WDjZlDQDRrIQaFJwUna5BQKt1Qg4r9O0WJAD2gpATfSLxcBfFOHkxvh51fVHM91RP9gbU3b3n4RGQJTLeoLSTg-r5JFrT2wPH4VmLU1ZWopFV3uQCwPbd7TyAsu3AfttOu1DjDiZn3k06f6VJcJajgQ3D4l0cHglV-7EPkm-YP1U-upvwbIIId7yBXknpqHU-EEJ5FlZLyllBa6gzF6PrndjSV7v9Xb07TvcJ4hDg0w9M8nuHBuju40oy_BKQYzOoLd7RsDlQpDQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTAyNzQyNDgsImp0aSI6ImY2NzkxMDI5LTE4NjAtNGU1MC04ZGZlLWY4MDUzYjE0MjZjNiIsImV4cCI6MTcxMDg3OTA0OCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.z7tVhJJE-7Y42wH_IxBF1yA5Ru48mLGM1nAhvgceZpLm9MGZWr6iTYC5E02owZFnELzcH3JkXrzYRz9qO1mw6ksjbV9N2mQohkjZzRERYUJ87lEACA1D9VFnYjPvAUeCsJWf5PCWPbH63F-PjENCE2qLsVrxjEAEYgVN4BbWrMoVek00QrCUXJLxhkRm9naRcLwEHRxrvLAS6oqzYji8ZFipJPS4fm-tHkK-IdHBDw7Y9UCmxDXvYvagBLLZNFE94wYeoXKV7W9pQEJF1SSipW0dWMGjcfDc_r954AkDFr2VNznk6XZshX-AJkuoEJmhbRWVeWSaS1PSRAa0sqCEdg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTAyNzQyOTIsImp0aSI6IjQ1MjdkOTU1LTY1ZmYtNDUwZi04ZWUxLTY3MGYwYTk4NjRiMiIsImV4cCI6MTcxMDg3OTA5MiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.DBxZ1xMmbvQ5ApW_HJTQxE8qbZgIUxRAMl986DiV_FyNXJ_7x0a2mD65dXWj7mXsSLarHc7xfCI2o_vcORAAE_NLCaBUKfkJ5NLX56D0Dg1PzxfHvEb780rIuvSlgK-O1W_Q-l4kUGYLnSD5HytSP1ljqLLpj3tOV8kbqEV0K0uLN7kRRCmsaqxhzgQ8izIZxwC_45W4c2UfJH8S8f8L4_4-W-2WSbPwiMf3-BouS_CtF1juuwR2og3dRxCRtnv-tKOM_Z2lEejNH9goT1MeQ_4UdIJevGdnKQ1L3V9Gpg5Hpizh8iibuyFqeqWnH7fvSg1lCpSsFevjzNYWB5xSWw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTA3OTE4MjIsImp0aSI6Ijk1NzljMzQyLWE1NmUtNGI0MS1hNzE5LWYwMDQwYTBlMzg1ZSIsImV4cCI6MTcxMTM5NjYyMiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.agoMioIxUnLJaS7Vvama3P06wRsXUOtj9LEZhb-YlxPU7t7cciQipkT9jv2LT56QXs3NFCIR-vB30AmvN74-y0yn0zfJZSvOnp9BsOprK_HUaIZ99q_4os7QIiByl14VRRu6WspUvBlX_4FtUIntSBa-sSJXOFDGZ6Easg04jHocMktHD61iT_RulP2GlCMPGndu75-7__w1vwjKGQwvioev-8cKssEZeyL80twPpe3MsU5QvOO8WLzbQ30cm3SRcroPER35Kb7uxmdoRClTcAb26PEX74RNs-4ZzAFWDOprxmI_ls5YyoFn1SZdhlZ4xFZ1qmPjbrRkU35gCCZAuA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTA3OTIwNTMsImp0aSI6IjFjMDljODU0LTNlNjctNGE5MC1hZTg4LTkxM2M5ZjBkNjVmNiIsImV4cCI6MTcxMTM5Njg1MywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.LVIGHcQGLcyKJslpoIzPs-qdK7EX1UYnoDRzEHlz4IugtuLnpyOotODfK4RalAxyub0jAcQRQqb0VZwNHphRC-rd2OvQA_i_GAVKc8NWUHxDMUJ860ySJSN2kVne5zfKCQHkwH3oV_TitbX-KtHZu9f-l_KdYZTpKL5ocK0xazkVqcv3pqKt4B4hTdYHetYY4as7fG6KW-LCRz6ep4SopJB4JDFEgVd9pQ-xwfwSiXrRZMdr3pknyqRIfKpJVywVTwvxhw4XIx1ZWo-WxMXWBzxIDjPl30SRipJYm3CHjJmngPlXoiF8puZT_K6jF4xrmZKEFBdwqr8lE_f6q3nvEw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTA3OTIwNjgsImp0aSI6ImUyNWFlY2E3LWViOTktNDY4Ni1hYmQ3LTA0YjYwODVhNzQ3NiIsImV4cCI6MTcxMTM5Njg2OCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.ACR_llJSuR4BTY6Qn8Y2Gpmw70INn74fgVcYvtHy7VKO-xZp5BQ0DSw6PMdU6Ay6MX5mLnLznHZy0SIArVPH2wPOoPROtbvVdYLk50P3fS61JeuL8BsKIrM-ELa0oo5uDsfG2HJqj8_Mlf4Av2N7woc_aWFu5ADtUu-y46VVh4HWkFAz91X-A9H2RcsFOmcR06CbfCoSD6o59YSLkpHl44bTLSSojxuGV7Empd_GiOifewYtA7wmIfvX46CLZ9dO_PH1n5TlQvAT_xruHWuGXZjuv36v06BPUVdqHtvP6vowMlnZSUWZTjkRAa6VbP250qXOhINVgljBYF26XKGtuQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTA4NzIyNTIsImp0aSI6IjU1M2FiZWZjLTJmZjQtNGE0ZC1hZjRlLWZjODUxZTdiNGI5NSIsImV4cCI6MTcxMTQ3NzA1MiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.C-dha-_W-qPK2ovJX6hoULAdiztum3sNvap96t4qcuVeWJMkeHbykosrKbXkk6XxBcfLLUwToRGzbkJZz2PqGcrz8-VrzsEy1SNFyvpwXYlwvbPDxwny0iLVrs22DLxPNVnD0DCrMcdNq5oaSLiFAEk3I_m0_5RGNsRzPMfP43Q9S07F3A734k3eXqcjeXNWR_iIVv11xks9SDVhB85SrEx5PtHnyg7E5VHCVPFPISInTTEk12m1-i_9X-kgHtN0XyJteH4S1wZZY84HJIVEzG21hcdGa3dmkGUAE8kkKI7DCe6QIxWWxRveE4W6AQ3KWGeN8RtF445N7HO8Yu_9fg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTA4NzIzNzYsImp0aSI6IjZjODlmZTlmLTNiM2YtNDA5OS1iMzkzLWQxNTM0ODI5YTUwMSIsImV4cCI6MTcxMTQ3NzE3NiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.0HyAOfxCVJ2xo6Y8tcTQ32l-40L3ViOFylIc6Rnsi25QKJv_0HFxHIneis63vB0MRioOOO7cSuwca3EzOLHlP0QeIqCozy7AcKGEgdVtHxW4L2xdNVubPWX5CC4UvuAcm-s0JmuVeAXrPfqCu9PohGzC9s8S3l4v3gw9mvDIj1OD77oJf0jLs9FY7rz5Y0qRYsCVIacd-0YXpEW6Bz0Wm9zgWZo3qVo7Rvx5DpYuXmH4EvXJ_LOIr68bFNJeweXmEUhwkCKSN31URYu7ZFQya_S2jEYjnOSXlFJYhjvZAlmk4ZZTFwMA8Db08fN4sUzXqT-iA_d1plh48wIbyTzkzg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTA4NzI4MDMsImp0aSI6ImMwNTllODc3LThlMWQtNGU5OC1iYzc4LWMzYTVjZTgzMDU4ZiIsImV4cCI6MTcxMTQ3NzYwMywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.PY6nedXSQvbLu8P5ICJp03QW5j5OtfBxX3T93szp8DJ0bKYurkAwcVlWJWhemORfay6nYDPUD1hST5vh19jGcmKAfEJi6SEcFUnDVxmjYfWuzn95zSpI5iBry19Vee0MekYKzvXNd7KK44XnPmNRFqpcwZTgmEIN1WV0YNSUZsbIc2xwP3z2r1FdEjb-aCJYospIE8IBkqw3rr4wdIWbqvuGhevzKxq5Jx5hycqgUve07mQWDxiNGC6UZbRyN7OkdzbE55dGGmUy0XgLsLREKA4ba7qeI2wvYNT3b6l36HO4R_F4u2aTQL37V-8SEmS-Z9M5yRSDbxyysH3bNxMP0w", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTA4NzI4NDQsImp0aSI6ImUxZDExZGU0LWFiYmYtNDJhMi05YWZlLTQ5YzFkY2ViMTUyYSIsImV4cCI6MTcxMTQ3NzY0NCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.KWstz6wCSdBJlUeWW9V2sgZEL8Qo3lT-fmz-qotzTgq9fHAA_3XMLV6qzOH4BwKaYr_CAsXD_RAfAY_P-eVoI58a1UxoIKF4LZF_QUeTQR_FbFlo2pIXfVMa-evTGJS9QXoShBUPy1dzOI47GTa0BkSaRTFcBSxeU57OboWo2U-YQwLxV9NGsZ6wrw0d3r3zaIjdzFHS77lPqAk8MVlpCI13qRgVxAmmS4ZnKi47n1YnNX0tRSKwMZtj9t19gUTeN6x1sIM3qt4SweIVTTUtEAVTED_7gNNfRPIcFNfeXm8D2vB6_XWzUgs6Fp8Jr0DrEuHIyCizZfSpLNeqkKQIHQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTA4NzMyMTAsImp0aSI6ImRkMjkzYjY5LTkwMjYtNDBlOS04ZDY3LTc5YjVhOGNjN2QwYyIsImV4cCI6MTcxMTQ3ODAxMCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.dww8N7_XXIMSL_hBB_T9FfTP_xMADBXgDjUpSYmYNleq8gitHjRxCh329JksxMBFlOLZC5QmwnXBhXfpAF5D1A-AAtHXrB-cuZo8oaqL1729B7mpCYuCagaf-vNS88Z5UobQAJh6P8rCykW7p4jYZgHMSqCsK2yhgO9_GHCHlXNovknGuArTU93-CMbzL_eY5N0yBKA_XV3V_LANCxcV7TTjoOokyIIEyFQYF3N_mQFUYrXLRc9L2WYTr5XPDpRMJziDMosip8PHZdt49EOHghJtox3JtVdaEO060fIBwZ2fJMibw5_wmfHk3PBaFgV26I2S1V3xXx2ln9JvqNyCzw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTA4NzQyNzgsImp0aSI6IjA5NDNhMzMxLTZlOGYtNDk4OC04YmU1LWFiODcxMDkxMDg3NyIsImV4cCI6MTcxMTQ3OTA3OCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.h6I5PXy0cxGf3CtMkhfAEkZbR6Uut2byWZOaMVJZZUv6iY_fK1q_p6bG0K8VPI6wdmmPzcGnr1fgGlYe-5kcTc0Ccmkm0eT-1FzOCVr1XbhVBtDCVh0JZP2vnRbVrvEWw_UoVIWb1FBR3os8hg4_JjX-hxM4Yp69tIktF7MCQA3RhDrdl-K5HNQo0LiLlR2wrk8e0LH-YD_VleL0E6i6WEhZTelXfX1KtniCPH4BgwX7QmQUWn3mtMkQx_Q9nP_KBR2s4KiZQelEtZLGvKhcij5bRpYqFXad0Ue5QC0gYIvdLTXm-veVRpkrhQiemP5ElQ7cLTIBshqZi_VEPoLmZg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTA4NzQ0NDQsImp0aSI6ImJmNDkwYjYzLWRlYWEtNDkyNy04NmI4LWQ5ZDY1NThkYzVhNSIsImV4cCI6MTcxMTQ3OTI0NCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.2ULtGPcNlO6TKuMw29DNXPPQx1DYCaFN3V_sMZQKGzB3Qfag71vwIBkkcPo4Rq93LgHsuRjGR309275LUoDp7VnmLxWbECC_TCbOJXSFOAXpvoHon1nkbnRNZ-Ejx4AN-y9boZSCYU6hwRHApedSZb2C4xPufCxdfuoJ5lQ2YD8-vUptc4JrQZJBh1KERfLAPeqKuzdGkfSWeNZ2oL4pF41D_elDxsSxRpyxIvmH0C7EdIGQJkiewg6kjJa-AUseLjeB9LB8EKyno5cBaEzaxjhczrwVG0we2R5VrZpnNWTQJ_BIKyRAXjn22l0vVHMxoLrowP00MXioslZXi-tiOw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTA4NzQ1NTksImp0aSI6IjZiMDdkMzFjLTIzMWQtNGM5YS1iZWQ5LWEzOGE0YTIxODkxYSIsImV4cCI6MTcxMTQ3OTM1OSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.FblMp_kwSg1oXXip58IaxYM-WCc9RC9VfS1p0LPJraKNesD3rKCUgT_ZJz6AyWlhXnIEEaGORX6SCDCukTWFwGOpHhorT46EZMP_sTo9I7hfWkB9q-vGhVXVQYXJqTVQu4keKdylW2Ua5LTGHWX3hR2EssCJfOUl-D2kDHss_2J6BuKbueyHv4jCAFfr6fK6_vRK_BqvM6oeSN1cK8t0tVn6esaomhytbsev8NrhpoYB2K8TPmtBwGtmJncUaE6dOJ-7xfM2sP-dGbZfxAmdv4GeZNOAIkDTfAOHawj8k_7mXKBO1izTracTB6dsaEJCyv6guIqNL7zXe9prhqwVuQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTA4NzQ1OTIsImp0aSI6IjlkM2QzOTc1LWY4ZDktNDM0Ni1iNTdhLTYwY2ZjMGRkZWYyNSIsImV4cCI6MTcxMTQ3OTM5MiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.N3fIxFLcrYumkJPx3PFbg6KvEYRLa7kbrlP2Q-Q-eNPb8f3WKqBGRqKCKBEaVTPK9GojaYC92hnvO4YFngKMpvoChHVhq6y2T5XdG-GPtyolfvLfqDZh21VNv64Sdt58QgobzKqA_tLEDoKoxIfqzVMqpCB5WIYyATYodg6Pnqyqf_VVM9eSX_N18Tk-0Cw9AVkzB12kr-X2-W4kio5nsKsmlP_ujyrZWmNPG6-eD4o-fwRtt5sX_X3O9CRdHj9Qjktfw-byLCHC9PA2OuNsiculVT3E09a-VEhAKcghwgVpAm_q3R6H_g2asdxIZY0a8GavBq21Kk6v64Ui_Ht5vg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4Nzg1OTEsImp0aSI6ImI2Y2YwMTk1LWM3MzgtNDMwNi1iOTYxLTVlMjc0NTgyMThiMCIsImV4cCI6MTcxOTQ4MzM5MSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.TaRGipmOAKZYKmv_ZycMG62jxfbxwaVQFcxakxlyTabpGSjQXThTeYh-WZT7YktmCd52Anuzx43ZZseEgwnd06gfGC1m86XPSOjlCh0txd5CEokdedMtWkppMxZl3zzzlcQm0yYSa2MkzrpHTJ9UKRhbyHXibSwSqIV-MXlCIJPLG6iSqTlD2pQE0YeTDxL_dgqqbHqorBd6trB3BuI4vcDb4u79hjSt3Gck1spYZ_UH7S1h-aSSAfIH9bvx07NVCEBQiIKfAe7M_KEaWJ8vOCmiXbCWp-ryOqmticcdi0fGsrLEUjqp0LIsrAm-A4TrpHuhrFrLUqw-0rYD48dxnA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4Nzg2MTMsImp0aSI6IjBjZWJiNzA3LWNhMjYtNDk1Yi1hNzdhLTk0M2QwNTE0ZmNkMSIsImV4cCI6MTcxOTQ4MzQxMywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.qk2G2PdaRsYWy0fnq_yIU24mfu1VUZksRTwtbYwy6NUzj9sO27D95PQEKJm6T8YQ_uYm6wrcxF3yScTX1AcPl2MPEBKWzD4pzRNZWpB-KQph24GZXnD21QkIaYQUcNZavVf8ki1Bi0p9WFZILuyqKDvwKBdjUENC5CY2KTSePBk2foVk76zP1kWRXKS87X1ZzgTjkWQGhlR6ZWH9QUnQv-OHMS3bdiffF5HdQ3dD72GzL7uFy2S5NSyi7DqLxasiZQEGw9bVXilZgJz-ENvKF3iWSp7lq1hUzAC5dbIDIbfGpBodTArdVUzJUBEiSZKeJ2eeGcGeI3fjY61JTHVCgg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4Nzg2NDUsImp0aSI6ImFjYjMyMDdjLTA5MmMtNDE3MS05YzNjLTMwNmZiNjkxMTM1NyIsImV4cCI6MTcxOTQ4MzQ0NSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.Wc7EbR5zXtB6264d9UXcENrJn6bHEksecoVpFo-tObISFj6DLuZb5XOUED-OQ1VJL7H8sMgRAQn-Oo2URpjjVFsGqGteED9q-znBsBIxAbz_z2zWTo2iuKoXmbEKHGUk4-mKjgPUliAPSH10VbUgoYMTLUxDl1t9lWEFhpYWyOB15joVsrj_O5rPtnh-3oR78AXb0xb6bbBSqQcuoNIcFzc0aUYX2S5FT2YcIxmBLuX0ZYzSa2QGiOXNYDunvmPcIyc2QvfvzEnmSErvMzBuP4R9l9blXOCLDTWJ9kx-fowBhZbC21vJMAWotCXv2t8fvcKARMyq7mpgGQM28-6ZNw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4Nzg4NjUsImp0aSI6IjRlYjk5NzIwLWU0ZTYtNDU5Zi1hMmJlLTNhMzIyNGQwZTZhZCIsImV4cCI6MTcxOTQ4MzY2NSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.u4DERTRTmbSeTY-Wcmf6jwUgEbncs74klP7ssB83OS6iecbuGAgIOQv7U5hx9Li8S0hxraFpGpNIxB14Ypckm3xmzCvPJEWFwnO5xdJ8TNTR2sT8rrVooEkNXE0h0sLOow3_Ngoptvek8Q0PaoJ3BjkfV9qNYkI8StHRAXMWbyo0OcPSLgMqzR4Ar6NSdoR9vJYH3rhaNA5PPo4k_iHqDpN__tjr2IEVFKCWdkfWi_k3yyleoKXTLT9boMWSQMGXso6Sp3SY0PTHyS_Wv77uvLP_l7Ad4_AOQlqef7ITSJm_iVdzu24f7e6TCqN_Mf9c3tXnJ8y69FkQKPVMirz3sA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4Nzg4OTIsImp0aSI6ImVlOWQyNjA1LTBiYjAtNDlhYi05MzE1LTQwMDcxZTBiMzVhNiIsImV4cCI6MTcxOTQ4MzY5MiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.aLBL8VsOs5QNJFfmT3s1amhDNXmBaYMuXLx2JZmmDkz0ctlySjOfM_dPMMAyI2BUs4BPPrGbcQhe1GbpJ-nowrlOE3h2anAXE-bzlCT-K4AJ2MaCWq5gWMgBiPYcxS3bM51XpYPZucb_TncaeAtBPNYtFSxOI0VK7_sNRFrJW3-8Spi0tmb3A9mLQkE0QP_Aj2bI8tJTSr-7dcwmMUFRDxfOx3SEqLGuGHESZP-3Gh95RpEBuS0IlZdCcci0lbRTm8uAY4vocdllyaqj_1J_huZbu82m4LvF4cOjTKaL-Uh2AaDgPBBdFk-9q18CWBeqQW98fIGVx5KHMxj3AsNBgQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4Nzg5MDEsImp0aSI6IjI4MDI3MWVjLWRlNTAtNGM4NS05ZGIyLWQ5ZTUyYjBhMDczOCIsImV4cCI6MTcxOTQ4MzcwMSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.Jee68QWQb-Y82aAmuYnQMaoRYc3Bjd3E995qhThQRR1WwIj-PZbOVz7WCAcu8H7aBv9HA4fAoX4ZbkeftQUv1ixsUjk3QKUjpD2ChWrtv8pGgZC-6DlzG4_u7sJzNkmPm1ZRfrCuAiIuUB5IdyCk4q-94mL2TnxE3Mc-bb1Ltnqe7HZGlHmpBTWyOpQ7f8-Dw6sd4XIBPgNGjXK-5uwvwdLYqC8Yhe32PwIQ8eSGLyiRDd8pC4TssyEOmznq9nzfJWHeQVXlXDdOzduJz7XGrrXiC0nHqrm8YcJGbPzMJYy1Zs6ZWyrUMejptgQOsLWODyHlD5czSq2RXdAh0X0ILA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4NzkxMjgsImp0aSI6ImNjZTFiYmEyLWE4NGMtNGFjMS05Y2RjLTk0Nzg0NDFiMTUyZiIsImV4cCI6MTcxOTQ4MzkyOCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.oOM8A3qGSm1RpDWkn-mNxiSB0eDSuKawcZDi_9Zn_bGs-AbjKkbvUMwbCMW7W2x7oeotCVZ8RRQLJ6k-Ahx76ZwgV0YWEjjkK1uGQqcBMoPMZaA28spDscfDqVoChUjX_0RFoC4rOpFUsQ6M0gUw4UvZ_J_uWH-ombUqJGxUSF19XpF5662LNbOOI-ObOHk4PO1M8_r0jbFafRaHysNU0frtC-TryqHB_zVqiTznvV_NcFmZB0XA0Mt-K70F7LbYLYbkkJuQNW3WNn60BRQNH8XdevMhHfhtlrwn_jq712qv9ADTMpu4LF9usjLby_9ITNcIOocjHz2_LDebzWPTIw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4NzkxNDcsImp0aSI6IjgwY2RhMWVkLTYxNzQtNGYyMi1hZGFjLWM3NTAzOGJjZGVkOSIsImV4cCI6MTcxOTQ4Mzk0NywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.uK-H8kVlNd6YJXUOHtB14-BJZ9toaHkeVDMMxPQScG6RYtVlw1JLF0FtwWPnQBPW8hmG8WkDyDCa2ioapFS8mIU8UC8YFoPZz8u7-jQyTz63MYk1WdGOp7rG1LPjtX5iDeWuYyHd_VgAF-WWn0_XQNG_PxArEjKDETEKZM0pIaPFXPnvCE_6xRAAMovAhZl30kONATbhgLNBVpEW4EMiLcO7PyBoXphIGZplZzTVvChFLK6BlEGYpDTv_nuhSV0vByBKklMuC0DP_Qmz-qMxx_MEt6Y_O61ormmarea2OcukTigttE4p42g_5YvUuZmoFLz1DdPrHNXw0y9u-NMwOg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4NzkzMTQsImp0aSI6IjVhZDVhNzhkLWRkYjQtNGU5NS05NTllLTU5MzAzZDMzMDMwNiIsImV4cCI6MTcxOTQ4NDExNCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.g9NdDyOpuuRAdgz1poH-421DsfYZNPiV3CSP0hpRXoX_MTZx4bMN2AL60H7O-4Gqv5x9m6hPpRYZ_Y2wJaD4oiy-X69eObtqPxwZa1qBs1BLWLLzECRbCyGVA0SF-NXTvcTy-toLEFwKG87pd7-5Sk8pVKRSfzluYAFrO7bvHcp0UX3m5PtIYELxbORfPBgvWJHLKNmZPOpxeN7hs4281FSd1v-Fg7vNsNsJ1PCGZ241me1NmxpzDx4pUAf2F8fqo0SLCabU-QBXr-1GG75HfjErvMYkt9ce46-aFxTyMfMEriQjx-lqOq7MScIlTDt6nXjQtwQKSEhx5qQ8bph5vw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4NzkzMTQsImp0aSI6ImY5OWViNDAyLTQ1MjYtNGM0OC1iMjkxLTk3OTdiMGNlZThiOCIsImV4cCI6MTcxOTQ4NDExNCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.tL_T9KM1KZ93RfaTE706JSFXY_fH4nskIDz23OvnjMvgDQG7F_yqLYuwGm-ao0N21ka3tf_90euysAaj3z8Y3yiZcb0P8KkpfXJ6HBKwoZnDE64pUl9N7ESC4S_r7usdZU4CQ8P8S70oFbuLW0tg0xxRruL1y8yDO3Emxe4fjHsrxGjrZFLbUaf2iDGbDGO6-4QCNITNQVrH5xjJtNItif4KcoTYCUxt-m2reWntt_Vu8CR3k8s7vwymvGv0cz4k3pJP2FNjx657NzWQ3ceRdN0ve0Fy7aIf0c5L-qYBQcRnAPkxZ8E44-DotEMjuGJrZPMM98tA01AW6CQiwnP0TQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4NzkzMzEsImp0aSI6IjdiNDY3M2ExLTAyZmYtNDZlZC05NTRhLWU3YzQ4MDFkNjMzNiIsImV4cCI6MTcxOTQ4NDEzMSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.2CC3o_2TupAo6FFSGAnkYU358YWsTz0Jlbdki4HZkKxTodYMr2zEulyozPbT8YVv8wcdRiwImoMIYZnENaupw8Z5VGtH2mE2TLDI550K0Lqb6E-M1NRjNOzm8pzEZ2bSwKNn5zRynhFEO0TimW_S_5vKdCYVcnwUsjc4q3u0_OovjkVZhtfQGUav_Klngwj4FlpId3fg_LvoN0eiZbuEU7gOiI37nXQJjMsFc2Ek1FLBmVPX-WJiUDMVtLCgbx_oEbHRRfZ_G0W43nmsYypldNcceFNJjXGvd-py0O2V2Ruaq4qaMCBcYl2xDG3xIqkjRu-kc6-c_RbqKYgAU4MqVg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4NzkzMzEsImp0aSI6ImM1ODgxZWNjLTg1ZGMtNDhhZS04MTI3LWZmMWVkMTljY2NmNCIsImV4cCI6MTcxOTQ4NDEzMSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.QTInP7UBl0bhc2uJchS0WnMtvZhifMC8QZGr6oR9gDoFPboyJ9RvXfhUqThmgsDBUYSYLt6xt7iKdUGxd1c77ZMGeqV7dE6tAYp5-6wY--QqTJhjXTzcPMbHkCOoTqlT612-TSc5HCaah2DK2lYL-XEAgSSt5vUIcJmGjAqdQm7C8xCnLnDPj0x8f-3YgyEUuX6uUphN3EU8I2tEbMRx4myzeY0hBrNVbneFwIkkvwGM4AsCkGaOQJPARX0S4eMonXg60plCfvipjnHh9TyKpL1K7k4gS5vqfVlIkinFuL2RCXjO7uIzbz_do9z-rhOLCzU51s4InXUR2jpbvwBm4w", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4Nzk0MTcsImp0aSI6ImQ0NmY3ZWZmLTY0NjEtNGZmNi05ZGRhLTk5YjNjOTNjZTdkMCIsImV4cCI6MTcxOTQ4NDIxNywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.0uRpFa6a3ABOK6_tTmVr15UB0WY2f4weF7nV7QZfue_k7_K9mMs7lgCF6sa9gbTW6F6kKf0diRxcaAeep9OufJMiBIdiBOGHf6pkzv0eOOydavikmDJzl_QeDMJ87_4uGyH2ojom1ku_yknkfvkNZbdOUnGCtchh4HEuvZUMYga2aHGDsUslxNvMhJOiJebqvNo2ccSwZtDIl9D0XL_DmnX20rtUIwcB-QHLKlYWIokEt_fFDTqcjslZAbFc5iHcbX4Xa_P39vOZXqEVfBKcmshXZth99bfzPUt-N35shLK-j6VwLtTrMA6m4mIp6HxJtEuP-eqR1N3lANByrKlOhA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4Nzk0MTcsImp0aSI6IjAyMzU0OWVjLTlhMDgtNGMwYi1iMWEzLTA4ZDFmYTQ2OTQ1ZiIsImV4cCI6MTcxOTQ4NDIxNywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.Bk7Yuo0Ji0l1eUievBUfsE0VhUiDy1Xj_Ud43nwmUQzDq3KTpC12XMYvuA3taaBtRKf_CJpq11BtFUBX51uawiLdjpmQGMqh_lofcUhENtH2a57oljNfENIo56S0PQqyu6Hc0ogNLY5_7XV1pLZJ8Ls2-lDqb8g-TzGRqbpz0L1hMWqL9k6vYyQ-hO6AkTbgqiYLMb4AnpstoKsyI6IonlWm4W16vaHiAfiJ3QJfxT2Bvdopc5HnTZkbsgEONIt9LK2tZmHBPg3YNX5B06djQ8NAKCvdCKGvb0D45cSwoShgTYy7Z3gQJ0ZHrKVo3z9VLlhf0okdBzFNOC05r2zlQA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODA5NjYsImp0aSI6ImI5Njk5ZmQ5LTM4ZWItNDMwMC1hNzFkLWMyZGZhY2IzMTU3MiIsImV4cCI6MTcxOTQ4NTc2NiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.LEunRN7Z58lQoOZP4mXhouZHBTZvHzypnWN8z-OLCRLJ51x4Fg8CrSJcqHYFPHEjJ9XmSVZlmsmYOiHLAgeyL4tW8FwV8wE_GksVYmSXG_jXdgltW7_TebTFmpLMYpp4C6piWFX3upqVJFAaVNDfYs3Meh9V_e1RjQlH7RqnREsWwEJN0No_Bv13JCNMj037cAw-QMcCBig8uFDfuY3kksEddx_SDmtzDunJ6dKd-bFfWuPF_c-zUN9q1GXvmMjI7nUklre_ZL9cxPpQgVmOr8O4A6SCGlvZYCRKNKiheJcOm3NCXyTWE8RJYFR8miNPbI0x28VYLIhCbH1OglJZFg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODA5NjYsImp0aSI6IjMzZGNjZmY1LWU3MWUtNDZmOC05ZjQ0LTY4NDAwM2RjMDk3ZiIsImV4cCI6MTcxOTQ4NTc2NiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.sOOZpXTxSsWfNjUk1C7Jr6uXrEFuDehzfPU3ig6ha8WDIVmtnmz-w2FJsDaUmfw1eozOm2w-L3fcevMXlHvovzqg1GpzUflZa-KO9lWqt3TEIuZ7JDkJl89Ky8CIeF-f9gMXOON_yHl6sUoc7kLvvsB5_I7y7pIhdIDBK8x-juiEReyRBq8PdF-9Xze79a9GIkhytmKirls0rhoATjYlXqdfX-IuocW2clIEC0ut7Jzse7D30_PdcEg7_XeWm1q_ApRW2YLMukrFCEH2HFmN-GjlQn2rh74pSK3wh01Ij4V5M--xOZNG1gdCnpe2mUsQHyQv3eQhAPnXk3gzu8H8CA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODExMTIsImp0aSI6IjQyZjdlMmQxLTQzMTMtNDk2MS1hMzllLWIxNmI5NWIzMjMyYSIsImV4cCI6MTcxOTQ4NTkxMiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.qBAmajo0TURBlsW9gwAHVBfpgdCfb7vuwuFbYfSDGEb0dtgTiE-5xuVV0695QtZb8_sEJbE3SRXrg693X6ewAaoJz3FDSVMsYMzazvvMGKKyj_Tjqn6KNyXlmMtlP_oESsp91zl9wCJhGwV0V-gxZx0Ag05wytq1SzRQqRvmKwDlKO_e-DhO0PnFUhUAe-k3YToruJQRXFwGm2vs1CZAs90W60ubKb1zKCVS1Htfhw7STIrOR1M-jth1Mq8SDXqv8nL9UrpaIHRwskF2YGi9jLjxXYg39xqK2MWCB7o0YLOBUvLL5P83iiLuJlECftIrrwWh7oHbVNg0NBUYbnfZEQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODExMTIsImp0aSI6Ijc3ZTMyYWI5LTlkNjMtNGRkMS04ODQ4LTQ2Y2Y3YTk5MTljMCIsImV4cCI6MTcxOTQ4NTkxMiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.eCEZQ3r9mq1fXqQlH7InqfsjcdmeizjxdKmQqjnsw8yV7H2gRaLBKd7POnYzVjfnqWxZuWJHZp17Moj4Iljp0JXEsxHzlTSkREzTwBzk7xyyNZS86iBsVmeKOyjvRMqdQG8CJ4IqH0znHxFF2vWMN94amsNPCBTPMvniml6nclNe7-QyxyCE-Be1sYNh0MMspW4h9vot9NwN5K8Jzkr1_H8FGx5ZNgGRPq8JNsdsGEkjG4zOpAb4LdXCW4Qkg7muqujatNvP7JACrIugmGsSsGq306TW6eKqOXL68XmAL7ZHCRadtxR_dFJYdrcH4XYG5hfIG__K-7QN8dsI_QMuNA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODE0MzcsImp0aSI6Ijg3ODAyN2E1LTI3MmUtNDE3OS04YWM5LWVmNGFhZDAzMzY3MiIsImV4cCI6MTcxOTQ4NjIzNywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.ynnsZOhIhowt3nibg635InFXHzPlmDa1Y6nDKpotManaGVZW6RkNd8yRJJLN5ADz_-1YESZihWGHVoXMfMOk_gqo7tZRugENxyNj_oyl4-xgtBslz5uEh_oqWTL1LMo-AiyXQKolpgbZrAWAjoLLW6iiAdcdGFwf9WBxOd34gHkKpMUoGvedV1xImJeniTovU06MdJnNBObTXqb1EohBlxSsNVUNiSLtrHTPALxmG5_sm5dV7xSlT_lYLiQ7Z-3hBIHPB1nKSPQUv7jzw7mRbgMIBsuqQYICXd0b23EiufbzQbfH7pU5N3EAw-JE2L52itL03YaUMSHY37TPd13qAg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODE0MzcsImp0aSI6ImQ4MjRjMTQ5LWMwYjQtNDVjNi04NWJlLWIyMGY0ZTE3ZjNlMSIsImV4cCI6MTcxOTQ4NjIzNywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.T0-bKut5yiWUoxinxmT5l_qDmfbpSJkWlDpEr07V1V9hWb2TO1ADomrt4NowWaQRqAFGWmYfdAWBDlFpWn1rbYk06XtF5dAFsAp-YAJA0UlpY9cetVdNIHkuTBT3VWxfqrhSrdgJAvDtbcUfmYD2ecsK1ddcODo8Lmd4UdqFddUaigyPLeb5vzF9XURsBxgsh9uH6rVwG1izomjd4yYQqGYQGg73uZoRmkxLHQE4gV88FkDCuRwp8Ddz4GffDwZC1s01XIBHzGt4YGbcUnjQD9K6Hz2DBDDW-4c2k_Z27EvfWQBKPUYNzoi9NDhEzezTH-9hu9bZJ2_kCr7ZKZJW_w", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODE2OTcsImp0aSI6ImVjZWVkMTdlLTBlODItNGJjOS04MDcxLWU2MTRmMGM0YTZjMiIsImV4cCI6MTcxOTQ4NjQ5NywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.ie9Jh2j_p4Z5VcgkdznEeIHJDnzZ8RObKVu_7RQY4ECZz5f5nuYDlP__6zqFMVc60eA5O0UMnsXBa0xZE6ilazo4grUjDRX_cHqzcB65ANbz-v5o5H3QHyMzneXfmwnJHA0GHghZ6hnRC5jidTPzwc_Kl9CGn9MF6IJaRWcIQLj0FzLVGkQ7CpzGIjCqFVmLPoldHFV7OskqF-gJFcCQGASoDd5hjvDxYRENak8QknMikd26KvWjj0Q1tg78S4evBuwPpedKjxczff_ooeQ1PC2SHtdtP_ZkHmhqpkmcNDt3R82iDWYeNum0pNal0kiZh01k6MGH-F9xl6GbX8rCog", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODE2OTgsImp0aSI6ImEyMmY3NzkzLTQ4NjItNDY5YS05OTI0LTk0ODFhN2U5NzEyYyIsImV4cCI6MTcxOTQ4NjQ5OCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.HA7SQ5UKpoJ-dEauyhQsgODwSJH8Us-fq1Ay4CDqcRasDRtNUKUXb7ML2ghfe2CFCtfORZfqbHYHAP33b8BwlXQDVmt7srSL6w6lUPaR17VMCddqMfy4Hv7C_113K6IqnMmePUfNs5Dw2J-2ZH7ZEKFsHspbirNF00yrP2oJg3VVVgXaEIcudAMLPoNs9HAI5DUNh1t8d_YgbdIO4PIJoWbtXGPxAvQ2cIE1shBgFpvbtHM0lMUiR1YDA1-5F46aIOR3bF-H-fMAsPbmnSxG841FDZ4kBgjUmPm-kWshrruvVJbby5I9WwJwtIAMFbU1RGPoPFMNEqMyl2Bsu2L7aA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODE4ODIsImp0aSI6IjU1ZWQyODU0LTA4MTMtNDQ0ZS1iMGJhLTdkZGQ1NDFiODFkNCIsImV4cCI6MTcxOTQ4NjY4MiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.SZ0hlH9bIaGCsEDb4Oy5QL5gYSPHbRMgwybvqiql23mY_Hz-rNaormNsIvX_VpSIzhMQOlPhSCQKU85EE6uySdiabHwP3p0BOQQ055fQZSd2urGvJm-UTMydakWkh6wZuBrvvLuFWHrTcxDWOSGXhVkgV8_I6nYorFpBjZR7D-Oh-bLwQdjBEc--L4CIiMVWVK1u9_Lslqkw6wMobVq7Zg44uJ3O3NE7CBDIDN6Ym5IQi4aTk-OzJd62GwmmY9Gpzw3ovylofN36C138D7CUMuPpA9E_EdjP0lUo8q-2YKtM94yMmPbAOZm7Sq9yljyOKrLj3YF-Rx2bHEMgEW3ONA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODE4ODIsImp0aSI6IjQ2NDNjNTE2LTJiNTEtNDk3ZS1iN2I5LWUwNjAxODlmNTZlNCIsImV4cCI6MTcxOTQ4NjY4MiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.foBtuRfPgKplFmMetwmBiDL6BCgKK2X52zNv38EZF3_c_lK-g-lofB0nTUSbiUtCNuoYHW5g19ORRbcDdJRaA3EVUjT0UQPuj9LsktSU60wdFeKyWpT_t_P26IkIrIbgq8EmnuYxNCWvSwTXLN8hNrb0Uvy6r2H_lbsfTwiJ2muNrlPoT6zPiIF8OE5umJYNHe63MtBrGpTvx-h81vJ4dI-57P36IsHzxGcAColySpL6Yh155-e-bjR2fKYXO1KQNQf9-lWSDmD8UqplBVOuixV1W_9H6NondT2fPF7K3njw3nng2_WTIlaTK9OpR5_ldEuon2SXyEtXj1TUa4IWDA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODE5OTQsImp0aSI6ImVjM2I0MmI1LWU3ZjMtNDU0Yi1iN2VlLTEwMGI3MzE1YTU4MyIsImV4cCI6MTcxOTQ4Njc5NCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.g0xq4ixhyPAgU6lX_c-wC3OlOZBr6Jaum6e1uTknaxneLeH8HzRmHzk8hUTi3MvNGZiGzeCbrLs5xWTUFR0Q4UHhTCTsUaXEYFgL7tBz50lSrmyoqfaIPUL2hZvrpLDMTQscsVtk6val2RiRr3KR27of-2aaF2YaULk3K6HN7YC_GlqdAI-mlwaKjLdzJ59bbiN4y-slpNBGwN7o1TIcDCqcX342eVuKgfIp75vPn89dgMnK2A8c9qLvSD2fFqsydRHvf46PPLyFGga_3yYYaK4IASR9YxvfDGhA2iMdZ98bruRCkMrcKKDCLv9VzGG3jzInlLWiiOvnwQESdDP8UQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODE5OTQsImp0aSI6ImU1YzdlNTEzLWZiZjEtNDRkNS05MmFmLTQ4NDg2ODQ4N2YwOSIsImV4cCI6MTcxOTQ4Njc5NCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.v3DYkGLkIfpJLodvwf-OPDBZqo_fcl7y0vqiRsqb_I6LJTqHHMONiWPEZSUJfsgCtuL2pIyKhbKM0rADMsAepf8MkGWxcmYn-wcZDgpNRRZ_uMSIEloEnjUL-o-1qM4Vo1f3g8yDCPYyk9Grt2Ez8RG-Ok9o2PC24FOZkNlmG8iYzGgMo4xQO2x5FOw3QMout9D6w7j1WsmoxHOSPvS0--6vBnDDDECndC_jVP2ZaCrorli9WMiy-AFEu_9ggyDicgKHJnazi9MobUmWXoc3r8jpO4n3poDF3NyL-Hqw4OFLrwJVclbUoLrSWC4vdtQDkAoAi3Vr_bkVUE4xN0do6A", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODIwNzMsImp0aSI6IjNiOTNkZTI1LWI3MjgtNDY3Mi04OTU5LWZlZDJkZjY2MzhiNSIsImV4cCI6MTcxOTQ4Njg3MywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.jprDQxBIvtP4WMjI-cwFlTAYUusSimmUNFeThgbFyR5TnlYPIMDLju6oVDcI0BAGy-U1d1DmxthwA9QxC0vAR7TLWldL3HI5eQD64fswySzqTV2XE224aIxRv7AOqbwMVp27I37snfmt7Z5W427M2rS_PtJUWcDIbiIAkCjnuuyuiTZwTc-o_olmgqUBSzGjkF9WCV0JVHLYlq8f8YElrb6bHGWILwDbhB7VqWNFkIs0nSOHe_8PN_YQ4Q1Wrqg6v8NgdJL2GSv5VbPfWct6gVvhvXn-_WI4tro4MiJ8_wknM1CXSF-6sxPQ9JWvR1KVPtkN1Zm-zOpjslQQ3MZS0A", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODIwNzMsImp0aSI6IjBiMDhlMGJiLWI0MjgtNDRiZC04MDQ2LWE4OGViMGFkZTVkZCIsImV4cCI6MTcxOTQ4Njg3MywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.Qgwv0Pf2SsHWm4rWjVVkNd5V9TFFq80PvX_tyvjhqZGFIc8xeb7kxCcEZa-keAx6g79mJT6PRkPoQxJWrG-HP-ae2Ndh7-rWFQsO7moqgfQrPXtZFYdkim-6UmQGUi2O7ua4qMQA56B4z4BWVc-jAlG4I4RO1MtpGn9KFR2Sbr2bg51xaoQja6500q0jqvNpYR7ufNWm--0NmFsV5nGjdBscL_k7aPkREXdWs6MWQYmoQvc4mslIItxusIlG-JGeAZCEZC8H6y1gUNFVZlh0ZFPan5poI7o00rRbpbbclFhmAVaA3vq1yU34_UfUYU1kowFxUKF_q7VOOtykWDNFqA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODIxNjIsImp0aSI6Ijg1NDI4NDQwLWQyZWQtNDQzOS04NDZhLTkzYzk4YjUxZjI3ZiIsImV4cCI6MTcxOTQ4Njk2MiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.t6j1AKtzS2pEm0NgOAeGQ6VAuGDjn_VbsZEn4Kn8PTgn5wurdbnr2eLIK8XIAXAaNcl-CoXyqkLwq2ERlASlnk__2Zr2eqV40Z1pJGekfWzKzUg4r2Rqt8D-aHorw7xeTHLJmGC_xRVjz3r_YScABW7pSkd8YUhOq3ovUMxFmutdN0_4Az9KU_yuWDyXLsDNGZ8wJEtP-p3xHGaIUryreb5Y7TUOAep_NF-T2AvR7kWqbMZJV0_bB1w5jgdm0q_3lrzmjgSVk2XVm2U_1AOjrOpdhxTqvMdEtwjZwBpWSa1ZkfTPt0WLONVAyUv8BWl4WcuurSE7ALu3-zmkIFmAFQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODIxNjIsImp0aSI6ImU1OGYyN2NlLTc1NTMtNGY5ZC1iODRmLTdkZTRlNjMzNDRjNyIsImV4cCI6MTcxOTQ4Njk2MiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.0VE9XT3hIxQaQsFDp6PY4_-IHwhAXqNFEjgEsdGYo2uYlxYEPsbXJrm5Hdj1RtYc_UBo6Wz-WlkvUhnZ47J9n6IxtgxhUgXaZmMcEze31q16jQEsm1GInTrGG9-HVkOK5fJYo7c0Vb3BEqqMTHlvuJ5UHsDE0TAh0bvAMD8cCkv-XgoSh2OX--xhJFkz7Zh4ZBDyC82M9CXUF_8QtwZBZJrGNhYJi62RzN0nQAJ1r-Cn4jzHP7_JVyEGkLq7PnDGCiXZUvcsWs-GqCYYEIPpdEMDf89-luwV-_laUdqva-GOdFa0HVRpHFh4LUR3S5FpVQlOqH1v5qGy436_OeI5jA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODIxNjksImp0aSI6ImRhODdhOGY2LTYwY2EtNGEzNi1hMjY0LTMzMWUxNDJjM2E5MiIsImV4cCI6MTcxOTQ4Njk2OSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.lxSrnFdLJznR02jjEF66FlGCb24I-ampS1_75EOT03mZDzICEHRP51f9_S3bxlAwqRlPwVkVqsMixIDJyHojTlRZCyYIRDAPUAZatzgSUjezy5Rj1pB-gWxOA1BgyFi6agyuseNG26jtH5QUGiH-ITGpaANyRwmEPpGlVVtadBV9P2ZOS4y34Qz3GcB75weGNXqWJc-fqH4n6kGRkMaeiYDswwvg6EobZvppzBUghw1QUog_hrODoOM4aBQr-469-KkTxtgOE-R3pabxX7BteXNrGZ4JfQPHeyihBaC66EbbBkh20htmWtxi4u8-Ynkp1V6hr8gVQNXChpZZyBkf3A", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODIxNjksImp0aSI6IjE3YWUyNGJlLTk3M2MtNDljMi1hNmRlLWM0ZDRmODgzNmJlMyIsImV4cCI6MTcxOTQ4Njk2OSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.x8mtkFXX9tiikrslpxNLRv7jkfrXewTIOdHbXlbvdgg8x5JLwB-ElvqBgA7nnDlsDIkjPNqf-9vGTLJe8uPkV5MdijRFyndmDnrDkbCa2qCghABSjFHkdUwspcYghNVB9epaSt0zOEkwsNSHdyJpY42c2P9NvVUxMxglinyqHleowYyIYAozODkLBh-ilvYHPemIcsvCVuHQnWM5aHUdDDQuhvlAGY_gSs2mDj1yTuS8QwgecD_u4uebdUW5-mYF3f6YRFCUwXAeOgLVQWT8ovwaSF15Zqfhy4HFFObSIPCr442J92bAuC3fJ_UzyB9LU5Mov_XlzjVct2jf-N0jxQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODIyNDIsImp0aSI6IjQ3ODIzYjhjLWMwZjgtNGE4Yy04NTlmLTJhY2Y2YzY2MGE5OCIsImV4cCI6MTcxOTQ4NzA0MiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.HmKG9Z4AQCDlaqpsz1KkiQEFutW455g_boz-JSQmcDnn7-RM2OWqQbKEDFr4A-M4asRChCftS2t6MAREFPFoRH5i_Hvn4xxqDKbKga1j9iToPdDi-YgVyulKTZu3MMfFuGDkE6TPWsZ9_1KSmy1oVTzVyj3JYmJq2_gD5xEzf-G8M0iVK1_vL7JtdLH3ApKI_ddOK8Oi09P-Dw4_b_OHMPdxd6EZBxU2w5FrQRKioirSpFmrf23ZE4xNoAm3TeiZX7KBt4u5898m_tbNDNgVmbQAHvHIa-LXkFU3_6bcffP9934G00OJ00Luuya4b2W08oJIylYQQtvK3X0dSTeD6g", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODIyNDIsImp0aSI6IjZhZjQ2ZDg2LWI4ZTItNGVkYS1iODczLWY0NTEyZWE5NzM5ZSIsImV4cCI6MTcxOTQ4NzA0MiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.XQgHEhxG8SpY0RhX6AWncS57Yr_SgskEGajR7n2oMld932ulO3e_aMNoZEuAis_czXLRFQeWAicBUPR6k4dfjF04eNyLx13qivuddZxX-JfohcbgRAqTCc-ot7JY1tUntKkFKtU9zOUii4hVW9wY3g7aRYKg9Z6RHP9XZA-ChM3qMkQ2tyS78Uxr-AWXlooVEtZXzU0jFjpSS7JD8K6pv_N6H635penZyAb-UKVp9gYjSW0zlbxG8K-3OTMwgvA4k6nOGq4IC8aZmo-Mdr_EUMR9yfRJn8CYg6Nbp5rsYxABnJ54vXQdLMmagG4-YHMwhs2_wkD503uHt5LfOepnGQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODIyNzcsImp0aSI6IjYyZTI4ZDU5LThhNzktNGQ0MC1hNGM5LTU3YTFlZjg0MmQwZCIsImV4cCI6MTcxOTQ4NzA3NywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.njaCM97uo4Ekhlqvc9oHCkjcIJ2IdcNHjFBqPM3ORPKrnS_IUs9JVXEVWahuH7JsHg3Ti051FkDi72lQHtUc9oN8N5mIwz2BSxgZX8DyYiooYsIKlBU-mDEHlbIVGRXpkVlfa6IMQF5mBWVTcF2M_dIpeHO_k40OldCSR1v5_G5xIgJGVvvR9qeR1A3VbhgZJvXgSW3E7oCQrUlrRmDK1vzoCIS2CDQ37sCGJCE2kzMa75kLICszYKPX2qnBD_PKtTrZF7GqBAQf3Sut_hdfJsSZ0VQiMlLjOEeyFxy70n0vVA1g9WK-_AN1UxpjchgYIm7-Nnw6RCkzbFwZrsh1Hw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODIyNzcsImp0aSI6ImI5MWViNTc2LWNhOWQtNGU5MC05NGZjLTU5Mjc1YzkyNTEyZCIsImV4cCI6MTcxOTQ4NzA3NywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.QFd9iXDCVwgMOeq4I6rqHv67FmvOhaItK29dgp_ZI8WqUJ_INXAM-jt5-XLwOBuxepW2qzJhrUjNfpf5KzRfkQfhKvIJnX9ie0NQRp6KltgtK9mdXy3TSYIDexc3HG0Ww8mZKBJ8umtB5nnA1c8KcafONsmT5DmJHwhIBnuWr6I2x0TOMCOwR80V4LbgsZH1DTkic2MnhNz78uth89CwHJ9UnCdYk_bmabNwWdQE-NouP2PyNZ9pwyhXYSu7vNwX98PO2Xpfu6QwmBm6HoFQtfmKFtrpNik8ZlCUSEKJmwnJm7UHdr2DF_1Q1RXQNSzJDiwaibP19uNKjuA2gnyk5Q", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODIzMDIsImp0aSI6ImE5OWY3MzJhLTA2YTktNGQxOC05YTE3LTk4Njk3ZmMwZDEyNyIsImV4cCI6MTcxOTQ4NzEwMiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.QRWkQsddjUuQN9xGn5lafAHR0h231BlUgJ6zF50BZ2B2421ail1cZajvcop5SGTCv9kbkiilXkrwXtHL6JwN89yoILdKMlFx3MgKwqoi8QM6RTTV3IXBD-yUROltVlXP8FesYaAHzbPSqylXT3pPt_i2uKZMDAdZpNlPt47wHMy3LUZnLoSg1wv4ODNPF4KHitwBGBlbfVonCksNIhtmf84p1bGqxVbRzoR277pY00dtU0gEyUocaidf6he1Gvgu1K6WrU_609k_5okvYZKZ9a-NV5NXOeYPJBrjB0NiF4IScaGYzPUFl5IFI8zreWZQpGWK2WS9ZXaYpsn6DSit0A", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODIzMDIsImp0aSI6Ijg3MDM4NmU2LTkzYmItNDc5Ny1iYThkLWQzM2NkMTc1NWIxNCIsImV4cCI6MTcxOTQ4NzEwMiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.JXg0FvcjpYfXt8bFdaxrJxP6O1Dy0u1pio8HD3a027fLcLd3Mm7T6u-HnRK-VvCArmGZl0jmigr7OV0ckk8MY3palBbeo8GTvg7t7V_2rmIyKtrGqDl2DV3glmdS1Puwiiiy0yktk724W5kluDhRGahmi_slg1BImAhu_PDcHjhyG_AqT-KapIt1D1658njVaTrMPrvfbec2ZTSkzS02o1Qnb6yIW_AoVwMOxlS1Sn4QRavvSC3UfwskJJXDUQ1LGubNWlGUZfYRHN0puHo1IzyIJ6Ar6jZJsw04l6-NsdIOR_TBCzkwMJlhWbjxig8BvvPg1LwwCeWWAnhr7VyIVQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODIzNTYsImp0aSI6ImU2ZTY1MTFjLTEwZjgtNDM4Yy05YWI5LTUyNGMwODhlMzhmMyIsImV4cCI6MTcxOTQ4NzE1NiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.oieo5h-lOq0yXSDHrc_em_Wj8z80ujCL8zzQK_MgNyYMxTCyhJADraW62nCaNmp1lH39tTAAmy3DN3WA7pZvjIHZtl4zYsqgxcLZoBQT2Mn3W_GnCkxdm37fuBhH-5gntZa79fGbixXFuFRk2SuZnb4tnl1Lz1KOE7SkswjahVLq_Tgek5w3YkbfE1cUXhm6MtyPx5QcUCsrBJdyQgHQ73on5TP0NxIJhiWK0K5fvmVghlxY2eIu-DnAaUHvF3HmdeRjwrAGh4vgbsKtJJkpE5Bro7CynnH4bkvLQVJ32F0B1D9AqNvqCfQYPUccGC69_Dnfpb-NNN3sAJCSX7GceA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODIzNTYsImp0aSI6IjBlYmJjMjIxLTBjOWUtNDNkZC1hM2UxLWZkZmFiNjQ5YWRiMyIsImV4cCI6MTcxOTQ4NzE1NiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.BAG3Na1tFlENMjC1kI_nceVZ1hCYr7c7Kl6T0Vw2aF-B4jBa47W48tCRtbTsrZF7QIsV_m8ve0oE8KPp6OFIw9zLYKF2xAYHYi0Zrafg0ZLQBocm_bST8NHE6lwVOCMxdyUfGSPe9gTUlbFoiPZ7SkaZrEuUVBkYH8M_aRwjeJ19J73isjhq4FL6V89e2wkmWUA_rMFDb6KyWdwiK_s-QTUbg5RpaW3hwYE-rcvUOKwCUzbMZg1TezwnmJMoNp4vCl7MSRDDWuTQWDzc79UqqgL6kxhXTw7SijIdpJ245SrFB62cr8Wt0gNnYR0hj3qvHSUBX0SdPNlTkmNwfSy0wg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODI0MTcsImp0aSI6IjhiZmUzNjhmLTNmODgtNDU1YS05N2FjLTFhYTYyZTE1MjQ0ZSIsImV4cCI6MTcxOTQ4NzIxNywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.xPRPWWrWubljLNq0mZNpAC1B5jPw40UO0tQcbyidMogNaJMscwnVgWuW0XgqnY8jANkxcmUvZXey2ADsrkizONX4Q0K7Z6tOm43GQlRJRd9pV61MRuBt14T3rQ6LA7kk_e8BaRPPoWNSvjH1gCPZLGmLVu3jYJy-e_E6CCmdFl7XztjCxDOGGKYPBqEWcLhL7rR1QC6f_8EsviSEDhYeWgtnIWKufXY5cxYz_MhBmmxH_s8RyYZ_eStzDe8zEtAQ9LuguERbK43kRUqKUfePiXutGtP1UeQmBDURvXk0iucyVOKG6OACAU25EvM5mhZsEKcNJFdtEwRkAZUkH0Ss3w", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODI0MTcsImp0aSI6IjM4Nzc3NGUzLTA1ZjItNDRmNi05OWJjLTEyNWY2Njc4YWRiOSIsImV4cCI6MTcxOTQ4NzIxNywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.jv5K8_W-dlfrvMQpLvm6TaEKMsNgt5CN0qeVyYYkv8nKfWu1o1fYhh75KP3o54XihiE2TA-QGSfRfwAE8l8l6OffYHMTenqWzXoTZ_JVN3ILayxN3QivjkuS_tpV8j0oapcG543gXORD07XpgjtOGr8ngiGWsJs51QVoo-Ckw32MUiN6uJ5lQbb2N1ilL0yOAoZFCZKKN7gE_JiOu0ZFcxVO0IuhQZqCD0zOTMoWnyfiWSKiq8Y6agcSRPKoRaerMQb0--uN1wgy5wdUyzZu_rBIKgV4R6XGwNCsW6BhwvQBDq75SB1w_23sbdzHQVRU9HTPYLn_f0guJKxgM5PbcQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODI1MDMsImp0aSI6IjFlYTVjNWY4LTQxYmEtNGQ4OC1iZTFjLWUyYzJmMzE3M2Y1MyIsImV4cCI6MTcxOTQ4NzMwMywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.nBcGHMSW5GTuDhf0xW2rhVpVaqTikXrvHczY9WKC-924T1nsmD7_HUCErbk0Qp0lRrPdd0j01yHC3QFGZhFMJ_G8bYIrJexEcGFNjY2KtJSQYa74K3AuSSV-PamWK4kXP8XuwAY4WEx64fdvl5cV8BI3qn4Q-awdV-TT-tzp2Vzmd1nfTRubugDyzCeglCFwrMLPCQaUzKir91wTkg3-RdHuHu1bsAQTCI8d6eqpnHPjFGErQCbqDADH4tA3WH3QWsSbNiOCgZJ5mvNy5gIkMNhhwNZJbRJZSeC35yfkxfup0L7w5unbkxHnyXqqpVnH8H3EyDtcNoQpDXxzdm3YdA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODI1MDMsImp0aSI6IjkxNDZmNmM1LTZlNDgtNGM5NC05MzVhLTc1NDBhZTc3MjAzMiIsImV4cCI6MTcxOTQ4NzMwMywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.JmeZNUXv4h9fLx4B-JQ59Nl8bOez_xdVSXFdpeR-opLyT0aJvF2x3ZqQHjSr78E4EYI53f7OYSgWemF_maSEyH7PV6OcF3GfOWxYuYLwqchsZZKmoAshqkLV_mOH-5nXP9UCDrKDrUYfuVN0tVAlf6Tx4vwv9OLTYrewfSLjmUyCEUPHo5Z3A0SJElfevSdfrl7Z0CRwQLAEuSCOCB-Sg99oeJhFcLi5OCpstezcqaxsDSUj57Igop_p0KEDfTujD0_rUKlUCu_9LQA9o5CmDVM0N3ibAuStlr76BXzKz6yKKptjNBlrDThvjrJqPU1S4XiaWCWavtb83ei8pszXtg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODI5MzQsImp0aSI6Ijk5YzkwODQxLWI5MmUtNGIwNS04YTBkLTc3YmRhMTY2OGMxOSIsImV4cCI6MTcxOTQ4NzczNCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.hNBSCrueGeHuYHmaylQlDP40lIiYk13xuKwjbLjwcYv-ziYyTkb2N1Eb80UCm7vENjslbdv0T3nSXSn8UnQsnaig7xLqM17mWTeMbeCw7Rsn3oacCFnLXWAo9t0XMFYS5NMII7IKtscfeoDqtyoV0UcQOxOdQ2uULDynyd4bUEmg08o5RZCwzAu9-7UlH04snFQhsiZLdax71kBLqH706LYf-zGvIn2Wda7iN8ofeC7Zo4nuU_FaDkPZ4YyH4awjMKizZHseHQeGkjkigaX7BiEMgH_naxaQFMvmf5g3id8SjVpSI-0W71uEz4cKwGV-UzED90KxipwC2xp1vijkEQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODI5MzQsImp0aSI6IjZiYTk1YWJmLTRjNmMtNDM5Zi1hYTdjLWFjOTljMGExMWFjYiIsImV4cCI6MTcxOTQ4NzczNCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.O17kmstFSH368TdD-HCld92V8VwM1lStUdUJ4cBG7-xU9AdEUvYsbq4yKjBbwFqwt46XYQzFh244UmrCXZEEWUoXIC80y260FD2bbwniOxGRQr6rRTlVTmZmB1J9P9-7eYNxjCywSXVvLU5TS5ERD64utr8wGzpVFBmr5qY8e-NMNGLpV3wMaWf_O0oQ8m9cMNiQSVVUGPfyeXVY3F0A6b3KAacgqN3FTtEkRm6pNUw0JOF8lNqGpflx3QveYG7Jhn60rxwePgzR-nUgeDN4rg3YWL7QYbAbmZwrfQTAuHSHd31-noLxK951RiWw3JmRV4XLgfauDZBvm5gYP1HG6A", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODMyMjksImp0aSI6ImExOWZmZjliLTBhM2UtNDE0ZS05NzQ0LTliN2UyZjQ1ZDM3ZiIsImV4cCI6MTcxOTQ4ODAyOSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.VMMU86lfVI6Gal1fohsXpGSwgxcJK97Xxb7HT3O6elno4j_0HXgvW9QqRxq7OVsid7JZIH1BHC3yjsyGCg58iLmZ8EpWK-HR9RX5ZiVxq-galoXCd4TEEsOKT7L2DcIBcZ-lnxBVyYHPobMuJ6gubrjAmxa2FaAmOOW1dtHiONEVUk2IA72X7-aADwKfBmZK4OwqERChERkhQqJcV7XHq1YVbZ4lRK75J7-VyRhUcY9Y2ZUStr8Qpra4x59pkkbuNr7B-1rtEXUFW6Uer87w5qii67VkQXNIYtUCq8WQxuvbMDAkG2imK7RKt58izFuSybbyV9sNyCVsVWE-3PrzIA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODMyMzAsImp0aSI6ImI1MjM3M2UwLThjMDItNDg2MS1hODE5LTRjOTcyODIxMTY5ZCIsImV4cCI6MTcxOTQ4ODAzMCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.G59wnQQsTw_cVduXwDzBRPRSoVTgeeasY04fQ8IHeZ0TapaounnJd9v8fTLBBAiEgWZxwyItnE_mvFqJCOjjZQYBTUA8eyDSuiflc6O0S5SGaEA_08jpQNCrUg9MPbdrDHgxz-aem-YNnJgVoNjCnVeB4551ln_BjTv9mSe3ZkAUWCUktlh8ZqNNMOae067e-_AHqQmkpaUmXJoE0M9-oBrbXErojnu4J-GexSzmcZPfPSSsAUe327GDfbDmmHk7XJg_qEfPW_ExANDcdTF3Jl4Z7u21tir4hODeZEsSxvPXieoLxGDpW9dvOwk4DE2oJ9Io7zlLqIJEqfOHDOMlPA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODMyOTgsImp0aSI6IjdlZjc3MzhmLTViYTEtNDUyZi1iMzg0LTZjZTdjMmU0Mzc3OCIsImV4cCI6MTcxOTQ4ODA5OCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.lwEAG_3Y0tbLgvkfZBgXedFpm4oCi0StO7_OXo38ehqcom70YMtY30MBEs_YS4teve68L7nTpzWIE5XoVO9WwdGbW5PQLiAvtCwf6b18lo20OEwzMZaeqsrv0GdFy-q60rYynO_AtpFy2xOJrxfUhOxz9vwoaSUsTuyiiK90hpgFu-lW0jiH6VqZgUNF81Oh6_JuuHiCSX0pc0LBh0-coWwx8j5NLEu1Ctw0d0y9PVk-FMS5otfwg5ZOz1RJyXVRbxkS1B0mhcWL0L6qvYg8PdVg0ElIo0_QzY9FkrlMtxhgkYZaCpsr_xcPcv-Dm3dMiAhxW8M9bHCcNsG1dgAchw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODMyOTgsImp0aSI6IjQ5Nzc4ZWQ1LTAxZDctNDk3YS05YmQzLTM4Y2M4ZGRjYWFiNSIsImV4cCI6MTcxOTQ4ODA5OCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.h30CPD-NugZpDFzKzLSCV3CLxbhgKY5uF5Jln2lakxgfZ39s8RUU1kcAHLc7wsjLtKdgPhidrilncWYth24ilaM2tP_Kh78T7nqj_lPEGbOkr05d4VyZcaGi46twq0t3whFGbXIO-EPa_AxOzS4kuPSmvuz0N5l0F2gbFJMwnlrpQzYjM_b0snnzOxBBu-SZRVuDVe5wQGU5r5lF9gIySHSA19gHUMaQMeo70GDXuzfsB1-dQzv3R1W4iOXQWqpCi3SBJ4kBvqxle16HgZAOuGIIv0OVrcAF6MerQgA8fRzZDwh2ZJlKgWzFZE7BHH4W0a56yH1AN4CrH2HUgaGexQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODMzMTksImp0aSI6IjBlN2RlY2RkLTYwYTAtNDUxYy05ODFjLWZmMTQ4N2JjN2I1NyIsImV4cCI6MTcxOTQ4ODExOSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.kJIz7mCJyASlI8X8i4G2S-fb9NMGir5QqSmHK6Hm6qDXwFnS6KVVvO_fcrJXl5h_ArI_quUmSexx8MW9hMxa6l7fFq8d2pC5sqR2OoU0YTbuVqb4XRiHlFJP0ZnmE2ExS0UbTcR57gK6vFwU7HooAoywzasvgg3B_3LrQikXAtGX1GpSY-QK-GiI_4vgFxa3s0dMLspcVzSewNYaSfYeLAw8okDOFaDvYNTwUC-LAC-RfAQaoXg7zY2wCBbfQf8jMwDR9xVj6kL0Vhffh7wHs2CPFn4LT-n1XAYolys2l5WEuHtCzwcmuHMV7iV5f35DusaNOSND8lwkXscTUuSatw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODMzMTksImp0aSI6IjgwNTE0ZjAwLTc5NGEtNGZmOC1iY2RhLTcxMjdiNzA2MzA2NyIsImV4cCI6MTcxOTQ4ODExOSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.wjN4N6kFfb7ulshSEcRAphhco-K6SgYLbrloqkoYGHm-VLJZ2VehRsvGRKeUi7Fks0nVkV9BVVoHaGHP2LwsK3a2FFVwIZ62OONJMe3DgjWK_rlSyulfnoiFPkQat9XoqbM_gm1ZWUCJe6yFCdoVODzLzJbfhBwnkJTDsLy8Bi0OZTVp5DiQEDW_sEn1Nlzs7y5DS9O3KJej3LGI6pM8GH3uITUNmi9TvnDru3hmEM7T1MnUvSQGHIR0lpv_BIAFBml36SZM6yehtqxHWo-jmoKiijSrzSSwSC2H-1JOkayFdHaWrYPvW-6qRhcGWVQJ1Sroj_AF1g0r7kpgrB859A", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODMzMzcsImp0aSI6IjQ3NjAwZWJiLWE3ZjUtNGI0NS04MzQwLTU3OThiYzU0YWNkMyIsImV4cCI6MTcxOTQ4ODEzNywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.VRTDhlT4GhqxMNNoeVzha0tM4UiqFgrSITvd1MiGBNaQ2jW4ZpDmUybAziGAzmSdhtv7PTfZDXnPhD9I4S4B_NYBoB9VSn_o0Hb0jVs81ahrrBNmFul4WAey7x-Kg8M1o5fOng_vEIc4VQ-qsG1OBX2mU3_Gafos4t0fYmrnjs3ByX0xa03Rq0GWoSvWl1KrUYSp1OGy2ugZluqq2hNNMfKxQ3mIsNWLS5cSsleowkPYCn0Rp3LsfpZ6eK-12XaBpDMJmgMUzrgZajsFHF-qfQRgmW5A2GHQMAx7rC_YR6O9htQgfBEaJuRDocr2s1IgWijz41miTs1iqTRCsW1rgw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODMzMzcsImp0aSI6IjA4NzkwZWRhLTczMzUtNGM1Ny04YzlmLTFlNjBkMTJhNDc0MiIsImV4cCI6MTcxOTQ4ODEzNywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.nQ_vf4HZlrol_lIjyVhhqXtPn3H9lBxo5WqCjvL6nUJCJf_HGwIVeqKLFpM4rLbjQgDjWKBvm1Hk1ncspYrEloJ37ZCZogYWDGFOdw0ooWptbMi2_hJLv6I0yfaM5gq121sCMFCA-8Z3FwgDnHuktLQs_IqHY1aORCyz_PioGb1yqumLdE09cbZNIdGrAV3j9ygIUAV44qX0lIMRrMehV_dIpizSmNZSw6Wzo601sPY-saKLl_9l9plP1TZkyJSTsfF_m0KXQEDE9tX5M1zyq2XdFIm0IW-UZ96dJuO18G9ftCemT3V1cNsAp6UZsnIPX0FYtDE6OuLnMjxgNhRWhA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODMzNjQsImp0aSI6ImQ0NWUwMjM0LWFmZjEtNDdiOS05N2U0LTZhNjZjZDI5OTM5NCIsImV4cCI6MTcxOTQ4ODE2NCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.xLmofgeZqFHc3UtlW3D73oNZrPJN2uIqfS14axyFAzVzjvg85qPCF3sEBh3JJniSSs3kG-LiW8XIUaZIrWMN8sa2XRIQwp0gvyqzqUpzvI_KRqdCY9ZZF3e09rKuqvvu4K3Ca5lCVxml-hQ62MLzatbgNtZO7aeAKg1lknIUKFMxifsYiFJwlRqT8O1LrD7sxijtUsiLvd6S8rDFK4xcpIUNY4-AkhtwRd7BV2SU7xymoCp8eRxKM2K00be-Y9UXZ8u4-wuyyaxdQtbKF1qmwYmiWGJToHKbtZ2rlYpBrXwv19M1RpEogqzUR1AUmirly3GGkwPmsVDcfQtzeuv1hg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODMzNjQsImp0aSI6IjE3ZGMwYWNlLTBlMWQtNDUwYy1hNjRjLTFiYmIzMmI4NzdlOCIsImV4cCI6MTcxOTQ4ODE2NCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.YXEYM3Ud-Ahm4AMs7mdoxfrtSB46odoejUMbs0rJ8nyN0kZxYhYKnI4Wo-3OPV38KgeqFHbrkh526rE2_PE3WK7S3b1EznStGAP7lSnz2tqSGFHmhNcyjgfEM5a3piQL31vSOMKP9yj6qhC2qSZkpM93QoiydC6B-d1Abmvy1HEggk1r4cAad0fp3IiILPoj1dVZlcFi6lgWMaaeIfhpz4fiEg0AcrLRIp5XTNYtdgTRCUxhPE8vTwyK-QmZprqNOS9U8WbsWvBYDdNfrVa_tFkwm00h_npEmILIV0xM8M2QBu17ODqjRajD9sG4aYPr1K2DFu4f2mcKdc2tk8lGjA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODM1ODAsImp0aSI6IjgzZmQzMTJhLTBjMmQtNDhhNS1iNDhjLTYzY2U4ZDVjNDQ4NiIsImV4cCI6MTcxOTQ4ODM4MCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.qw6YFpqMkuh2Ji1Fsg0_q11SF3aeRzPbey10jZ_p7OCeeQOPFG7sh2OBKIXTJxMaZojUT71UnGaI8OH0_I2oEmR7G-v6MXzTN3vy7IpWGE7UUxYNV04RMHsc8ytMomrQ8zjLp3QXKm3erwogf6iVnh7JCmUnYYSjOQwNdVVIZEhZcmmectvDt3pBkOjBHYXyCqcT_hBC95Frw09LL1VXvWezTFi7_yiU9BawecSXE2i3kaHYPiBnBIsFja3yo6HJe6IpMHHadr2Ec_jgQB7k6SOgJmxrWg0ZpoXBO7j5tcP1gRbNT83U4swobtj2zBkJVhFum9RAaPGNnO9hG5EiDA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODM1ODEsImp0aSI6IjUzMWIxODgxLWQ3MzUtNGM0MS04MWEzLTgwODhmYzU0NGVlNCIsImV4cCI6MTcxOTQ4ODM4MSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.n5BU6e3Ccek7t2RgaXk8N6wkWcj33-AnTJmWw_0KbZ_Zxao_qzRag1LtC74TBRxxkftY0fBkuIaZAvbVLUsBQueTcje7wZKPyvGticY8VaYXNj20bfrj-E3trJa-Z6OnouamTDwt6CM2c5b1GsONXjlaJMnqYu9zwVejunJmutt3sBVXYcNm6Ij-RHpVvmHMrRby07guocibnM57EpBBMJA7z3ZS3G-dcazLreVTzqQM5ZXuD4VMPnut2EKrOKLrfomJizhvtAQ02aUv4vGSnVcwLfCcMHtAW36dBhYiYGauUgEAeZ6d-L0wx8R9NuDoUcx-85SFrqV2M-HbPGYr_g", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODM4MzUsImp0aSI6IjY1MzY1ZThhLWQ0ODMtNDY2OC1iOTg0LTc4ZTFiMTgzZTBlNiIsImV4cCI6MTcxOTQ4ODYzNSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.W0LbpjwhUZaxoCjuJup4q5D6x5PMkDU0LL_bSPmjMPjjq9FF92ysvlxJcYlslzrKVDivBD7FwS5FyYzohjO-eJDWz5kS9nuERAziyTGPJgpvDQzNOpPUvkytLt4mG4PJ_MhH8kB2mWoLbBCorJ10mTtaeZzNonQ3m1dpZXx9Qwg8PHF8zwsz4_jYoT9EuOwaDga0XqhvtMGh2qIQRWo2Esib89MCahsLwKBd1ljl7rle4Ng-dLOCLJxfnsgN1iQjOL9CCeOPid6BQ0375Xt0QjfFmkCtrFjYSprc9KhEuV42g623TaV8LENdEcwrd-SRptoUzZLqruJZLlj_QszOYw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODM4MzUsImp0aSI6IjdkNzg0Njk5LTBkMTctNGEyYS04Y2I3LWU5Mjc5NDM4MWQyZCIsImV4cCI6MTcxOTQ4ODYzNSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.BpuFeZBI6EZyYgJgCdsYnnm6rzxhZSSBtkVaVgD_V3pMLblUvUVbHQuM60dNpWTk9mb4_7xDYqYzBGyUgAfRS_M_aI8o-Atyb9laT7zwnm7gBq0Jn58hbU2faH8FGdCz5hTJpaD8I4UQ01LJLzBSlBcn0Q-aphQ5A7L6y8lSJlpAcXxn74eCvWenLkFef2GBBl0L7MWaLtBJXf1EPRwCRZLoD2wA-2pA1PASHcWq-ILl837IhX_AfI_xcpWoymCm-s20mfOewOcmrgg-h-KWNWXrPnNKHtRrm18tUGF1noCqCCVdSUoDc7lvyBaa-CmwyQ8ZAax7fNY238rWlMNDfg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODQxMzIsImp0aSI6ImMwNmFjOWE5LWQ5ZTItNDZjZi1hMGNjLTVjOTAzYTA3OTJhYSIsImV4cCI6MTcxOTQ4ODkzMiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.mrQK3Qa7yKljEaohqNUaOKyHooZkZhQdbkX0rqoQe8dt7d9j44P_-0is_SlJB_-ZH-ECiCAObpo80IT80fC_I227k86n_8ccoydo8bOyq6KCYByYb2bLry0YnxGGuXjQDmFeixNfx3wDNaUEoiKOccMi3ZERysbjvmPKcKjeOeecn4S1rs6f7NT8xwDEvfTF4taC367Tg0aVD_HggzU-39XPDCXDsAv4VgYbFkiWAyJwSlagnwABczYm5f_C6-zQWy5igYg-REv11wi_JnsuQnAiRGgjsSsmkHZCce0kFItVzbv8xuXS6YlVecoeN_XL_BrHb11PzkFXrqNvdUP0kQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODQxMzIsImp0aSI6IjBhNDZjYWM5LWFiYmYtNDVmZS05OTkwLTJiMWExNWU0ODQzYiIsImV4cCI6MTcxOTQ4ODkzMiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.LConud2EfTgxdFeKGEifC6f2OChRkpX4MjufFYOKP9we728t2w6nVP2oUP3cJ6pBkz0nt4Fz3q35Dg-ofRa7tCZnmiD3CJmg9Bw4h36r_HQSrKHrwrwJRT1DHSzmDzH9K8b5d_TCpRU0lP4sply3v-la293IjgCoc8eISLpmyX7mpct1fuOsUjUsgho5JIseZFhn6i-rxNKIFKKZW0CvO9QOzVfL6HegbBzJoiOtNqzLZUFh8zdXDYRzK9qb6ug0VPtHR6MLyLw85LMhpFQuv556OC3B21AYnA58Unl4T14kOqmlECTb4laFfgHmTLqs8GD2yaENJ0xYFLIeomRpLw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODQxOTgsImp0aSI6ImY5NTdkOWRlLTE5MWYtNDQxYS1hZTY5LTM3OGRiZDk1Y2MwMCIsImV4cCI6MTcxOTQ4ODk5OCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.hu3JI8QH78hkhko__h-EBjZHB4p3MKFgxu9JXMksUBC8z3t7ymrnpIYE81MZvufmHmyZKFcYUCBrb2V0EFHXJnBTDVcqf3FB8Xi51EfmUuK4JA58XK5MNnuvhL8lUwtHPmuJmSBDtOfX6-DsPjMQMpuuHXlOEOYk5zDTqruG1JQsX-EF2nIkT5dDNMaS5E_yCQcm0cf_Qsj44F2rYlX6JkQd_DRpqQF84_mXmopJp7y6lSltYCP2XKv3QCVeOFA8-apz7h42bgovcsdXH-UmmUH8BE6hOaN-bEHsNqIuGD4mlvE_YCXOHfsUS8C6n29M9wTIEvk0f5RGbAFSxFgdkQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTg4ODQxOTgsImp0aSI6ImVkMWIwZGRlLTQzZTMtNDJiYS1iMGZmLTY5YTQ4ZGIzM2E3YiIsImV4cCI6MTcxOTQ4ODk5OCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.dKY6448rWB1b4uYwAuYsTHCwo8VQtuhzhytlC8RbYSwMQaIHGOJK2FUQSFAxruFx_IqmjQcMjPFf57qt_W94N3iKZlNOal2YlZIyH2rtwt7RMSeYojxnYNdalENCL8CW8z4l8mM3y5btLz0y6n-kaxSXs9WbtpZiNLDgZ_OQ8L7edlpiAIHocHdKC1vDfOYVf_Xs_fWxP2mno_YpySPuwdpDawuHnxcC2f5RXO6p50-jFEc7SEYSmeP2TT1rsTTVV-Ws3BZA7jwMnrNRasn_L3RNyGZkIMmbBsOX-UbFuWNZ6v-D8OvrUnHQGxU2cmobf0SA5Jd8R5Wr9Bb5L-UK3A", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTkzMTQ5MDAsImp0aSI6IjRjNDllOWM1LTBmYTMtNGZhYS04MzJlLTg2NWJjMDIzOWUwMiIsImV4cCI6MTcxOTkxOTcwMCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.Dv4UwPyezYLOWYzzPUqCspbmgSiscJ8YbxAS11A2ncTVVSRB_WJpWucGMJsZ9ydThfEp0cA4Gp3BOapiyJfEL00lFrZavkb_SPoWHgTFf_3WBdMe7B1S61CX4tjwOYZ0lVe7YbqGTJqXr1HntnucZRcWCZK-hKcF0Zec_GAuDtozJm3ek74lFvmlLox1OGDlUKOh29ouzYMo4SrtS3kM1kNmOdMtgdsMvdpJmmNIX6gKvAKVAjYR8ky9GT4xCh4V98zm28FYKkZl4_pKqEagyRXD57h93TZiitzizd4n8K2WJresv6mQUL4B6eF67ODIxq14U2-hpbIP-tAc668pjw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTkzMTQ5MDAsImp0aSI6IjIxNGJlYTYxLWFjOGYtNDQyMy1iNDhjLWE5YzAzNjU4ZjQ5OSIsImV4cCI6MTcxOTkxOTcwMCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.ZU77ypOy68rk5JcNyDk5ZqA9BZYZ9bgnrrqlPdrtfoSQ0xOmucpI969fVqAKcxL81Es7wcFxixnRrGUHJH2UqERLGYqAwnGXIiiXekKecF8ZnD0as05PXXrt2urgJ2w1iR3BxoaOLf7GrHMl-K2CN8MIyTxrRTIhqmEXGEBkbRMlLYsGnbXBR-p0-kHd3RZMT2qQL1_hiWzWSgObwXJs9HM29iE3sAGH-6uBNJtL5QWbn16vqBK0UhE9j1abUkWdhN-LlTuhJqS6dyzT3UexMCG6vS8JbXAndylt-fIpiXXzJLHSAKhWIsc8y5UqrcNLN-CvXgGsZua9esfVFhxQAw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTkzMTUyMzgsImp0aSI6ImNhYjI1MThkLTc5YWUtNGQyOC05NTAwLTk1YTBiZjU3MmUzOSIsImV4cCI6MTcxOTkyMDAzOCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.CgqomWlDsKDiB3iurFGZmm-EGNhzrCC1N_PQs_imlUIJh8M9iHILNEIN8IzXOlwbdp1x5q7kmx1xZeN8cuakm2w41GhlziRZNU3-rlarLXQE28fISl8KrSs-rG3xpZTPkw6e-MbDYyIhXhNobPQaa_-K4DIxZ77kozZUulLIvWfwrXn4cwWYSA2rFVXpqHhNfBax2YCn6MlieGDq3siGy-I4Dd-Jf-ANUGxhD6bJElp8YAVg_VwEh51-IaovpAbFOdX1a-JXSikHPhgW5374DpKn5rpn1XHPqV-maii1R0o83yvUzFD-WgY031wC2Tmb9cv5mxhilDgY8_dsIlvBjA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTkzMTUyMzksImp0aSI6ImVkOWUxNzg5LTcwYzMtNGYzMS04ZjExLWMxMzJjMjY4YzZmYyIsImV4cCI6MTcxOTkyMDAzOSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.umZdWsi010mvIYAIaUWYbWYeMl4kJfFCsWYN5NFE0yVezcAfhEBDf_F33fIYyd6MTf5IeBtkrMoKuKAgT7Q6WsfWSMJkXnjJH6Ks0Ygthvqs1swZ5pfevH9686EJP65H8GB9QNGBJASuEVlGJzWNYRJhNfwFl2wxtigs0h7PlmgzuYXLbAw8fWaCWkjuRpBc1YLaE5i1-It48-JR08K4xW6NAkM8du9D5Aq4-FPKoLuZI-0FFfCsUXoEKOsf9Pak4UQ3zdN4D2cRYF2xQ3yR1gNREfhSiLlg0mWuR--YgonpSqdZzW_f2pewtCKqVhGP8Nd_FqJSBD42EUhAILbz4g", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTkzMTUzODAsImp0aSI6IjM4YTZkNzM5LTEzYTctNDZmNS1hZTFkLWMwYjMxZWFkOTE3OSIsImV4cCI6MTcxOTkyMDE4MCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.syMbCiso6JIcx27tOF4bMefnkk9v0RtrXRbK0PiXhk4Lu50VROIFEUINOYnG8qwTGtj7SI-AWnSwWPqS3C13x_L65V_CNqVk4KxvjxGtXySyoUwU5bnP1sBC7WbZL0EsWyK4RRL-YlAMLwEVroUXZuPcjCPbr2Y0VdMgOGDkEefPIqVdeOiDMiBtKirk8GMyeA5V9WSFQCZeP77IrOZhKb0m64aPE7JWjirgCnEMu4SI5isCAl0VbDH3jTt_EYFfMKCs-mg4GcqEWhTmVyqwVE9p7tLGdrsIZ_lFmkY7kvymHBteb9fMRoik6929-KhdqLjEIXaeqLvpmoe6WOMIWQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTkzMTUzODAsImp0aSI6IjA3Y2IwZGVkLWFiZWEtNDNjMy04Yjg3LTQwODU4YzYyZGE3MSIsImV4cCI6MTcxOTkyMDE4MCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.S4lMwUaH2eK6_wOXFBRnpcbVA1uIFRK67FL05_kRymhqXZEug7EKYDly8fW9je12KtDSNEWZLJu89E2AclN-jkShNBup_oxREQlbT-mLUDVAhqkimI9yQfkaNYJX-b1lnazngliB8qQNj82U15AGu5NMDnC2lWhzKwh_4lO-ALeyjqGepYKtYAFHnfaGF0se05m6msQEZmB-0HTDix36xIQJeivQktk2vTlHQanzpVdB_GFSsd7JLRMpeHKg8iTZhmBnUd5ykSFYnRAhWSlv3PYGNUk0yFqdjmJBwgEAWsoh3RCgZWwYtVw37xH2Q_VmgKb8LHY7cvngTspsVAtPIA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTkzMTU0MTMsImp0aSI6IjMzMjk1ODRiLTU5YjQtNDQ5Yy1iOTJkLTRmMjNjMTNiNTQwOSIsImV4cCI6MTcxOTkyMDIxMywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.l_tlRnMq7oAZvYcFeXmQj2z3a3qg3eMtEPLuvM4dsrx8EPbXvEzSQJsmEzmy0XKdleQxrpcFyx6CBUj9FfDV6hoTokCHAZ6NGX8nyunDl9imJR5klhQEmB2KDviJoqM6yrHmHERjIi9cdOHTWyTMcbpng3xOL7HZZsEvIBuw0NjDut25MQi7GPGJNOgHTeJacLUn22xlpO6blqKQo2eQtZw9U_mOx14zNitN9xGBUqZgc721Oi5-LbuKwz0Px1RZBP5Uj262HGK0qs505MGqUIIXlMoli-h4WEz_6ayfI9wor0pKfOpVdLKc_s7d68rkZ0uTJBs2XV4k3yN_fTyz0g", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTkzMTU0MTMsImp0aSI6ImQxNDdlZDY1LWQ3MTUtNDZhMi04OTMwLTU1OGI3MGM0NWEzOCIsImV4cCI6MTcxOTkyMDIxMywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.eo6xxJLP5H4Y7Ak-1XeR3Mf-26WaD780oCXSbliKSjYS0X5KVku4hcjSej5VptgNkxHIZZiA4ruO-Hzo8kB_hKu9YS7pd03pXlW3mqNnisCcVprQQzqjDkqKKuftgRUk9p8hIObjV2mPEK_gKeOZTKbxVZlbQIt3goeETwlHxrGnBH3gTDY0kWrLgy1f0y-hoaJfh7bIR9AIDwdy9JRj9lCntYP_mqmv0A_NfwQH-DW4kERmvEJC-zyV72NLj4_JsXHUmuoHFlSp--nGKqK9dGzgmLOx36TrZoEzcPKbBdkAejMG4dAonBNYYEmm1wUm6fscVpbihBrMp9U3fHa77w", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTkzMjE4MDEsImp0aSI6Ijg5Y2YwNjcwLTdhOTAtNDc2ZC05NDRiLTY5MTc2NjZkMzNlYSIsImV4cCI6MTcxOTkyNjYwMSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.QLh3XpOM-a9k6MITyBfXjL9ZFG0Wj13MqIlLEir7_bzscJX8MhMaaO9X369oye8yrVjlg8y4Rrk5MxxdDovU6dJi_MgxZGn7xl1DTCgeV9lPWZbSLcJe47ylaz3nroE-19fkvbElLSBx6xaQNmbL1S75koCk1oPv6Wu0UVfiX-F6bm2rSh8sZDV-XCzSQfWomMAFfp9RK4bwTgM2lA0aUaDl4JIwN9HoxT-NRlbNmtpT_k1f6JodmRhBkDv0oc9eiVu_gp60zE0zAL-lvFGpMIfcLsfMWHI8ffaPKzjuM2393So5hYGidf8OzsattBgJZ6AKcPLejgEUa0uPFAenAQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTkzMjE4MDEsImp0aSI6IjlkZjcxMWNjLWFiNGUtNDIwNS04MGFmLTAxZTcyNTZhZWY2MCIsImV4cCI6MTcxOTkyNjYwMSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.eTGeS9QV7J37k2aeipL2a7pIKBv9PEPXD2WqPbwmWsYhFDHOrRG7oDykUwiUF7Q5MS-ibkkpjDWvQ0fQkBpwLwIbklp5EnsEeiVpiGVvpPSejGG8sSvoIYROpZA-FR95udulySnUoEcg9nPLEjCHIEvPgY7NX0NSbzpWbBvtzdnHYUl4QBiWB9m8k_B0BtUHIMddCpG14x73PgzuLNeulgJoE4xdviPt9dqP3axqHMAx2pJ8yXQ-4EkVG8YdqVjZ8Uhk-hQ138fDnoXk9ruegKe77bjDXQIpCZUYmZEPY0pOmE4LH7OBLd4nU0GH22Ur7YwtYjCzRh7B88yNTUI8WA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTkzMjI4NTUsImp0aSI6IjMyNDBhNTk2LTY5YjEtNDc5MS04MmJmLTY4NGQyNTFjZjRiNiIsImV4cCI6MTcxOTkyNzY1NSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.BetNuQcWDtpivOHQYG_3whnQWY4aZb502MOcR40e0DeKbqpGiD1m-K_3m2aQEvIQCWQ7MepabU2jWxLtrTBDVX9jMSLYyMESfcV1oS2DP9GZsUUYFoSWwx4ijk99fQm6Q3cAJ_2niPE_u60n__5Cp5khOc0jaelSGgOcrx6JlND879TvLzFtN3UC8oCKiB6a0hFWs5ikcxU4FX_oif-J8PEYH9Rg5h0P0zL4TM4vwoqBLZrQtlee62oZoLS0eqtTM_wvLlOPFSsFsvkTLiy6klihW-nZ5-tj5EGQSnAUi0B_1c7Y1ckzR7-GHrQAkb31olaTnQ_Bd3ju7HmV8Am2pA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTkzMjI4NTUsImp0aSI6IjkxNGUzYjIyLWEzM2QtNGIyNC05NDM2LTJjZDc5NDU5N2ZjYiIsImV4cCI6MTcxOTkyNzY1NSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.t9EH1ZDkTOog-3z2tKUz7MbXdrReAoscM0DuluNe9zU-J7lqQSX4RSkw4Y3WL9u9eEkF3_J9NI_nNAzCZDwjjK8RTSu-LXsFXEox9WRPguIj2qR33-yR6ZAoVSja4LDE_GoXMb1hg4QNJQ7JFYYdRpXQnxaXUw4TLApP8WFSL8huuso-G0y_GTgjHyEwIWE41msvrGKb1Bi84LjvUDT7mwFgeJJltry-nLUnL4W6vdfl2th3QxGK_4U25-2fAyo6nRrla3xlIK4IDMklbWQRfYQlZBLoXeaUc6ocgFxVHD6HzK4hZVbixrYyv3cJMRP99hlVXl05HCeqyFMuRuIoYg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTkzMjMzMDQsImp0aSI6IjAxNzIzMWI4LTZlMzYtNDY1Ny1hYmM2LThiOWEzNWE2YTlmZCIsImV4cCI6MTcxOTkyODEwNCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.s5oGt0idHaT4En9vfXlke5nBJoIrFManeigQBqYqpwoeZRmP5vvTs4NjyvW7kgrJLzRsRP4ott5EfSGSI8QhepDhxAJeCFNkuMaKwnwY09ypazfPHsPZyKX403YP1HnmbOZ3SLXei1amm0rRsJeUKsR5nL4IFQFEliuHM5M-7TtMYeUg9HCHDsBzRRLviDsnlrlITyclwGEvug1jQnpf4MEePaJDl9qGVos1TJY58WWO5jC0tqiRatdPFHpDcGUtxvXw2GQUvrsnHOPeFUL6mh01VUjnEB6NZJmvyFBgjR2UoOM2z9-4g2zMlhc-XYYIIVKTO916lZSM6XEYXeBn-w", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTkzMjMzMDQsImp0aSI6IjE3NDAxYjhlLTM0MGUtNDNjMy05MTFmLWUzYTYwYWQwZGY3MCIsImV4cCI6MTcxOTkyODEwNCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.azj_T6lcghpfibToZltVpUfK6ch6FjA8-DaHvWDHUny5M6mNXtyYnoNOOc7wFWBwQwqXkzhifRfa1gw4Mr-RvQuwvSNU0HlrVECGQTpUilw-x3tT1av9eBzThCZw5VbxC3aymX7UqETTb5bNT65CWZzBMTwPH4u8Z6pwC7jWgNNr7mCgTOI86sOWtGqiyfvW3EJwbY8r0sh-Whw-JL6WBgVfCY6Wr32Ga3ungyvCoEvoC4af5TTWoLzD31YLv5XGo0gZwD_QJr_kFDwwgLkQPSVAN4-mOBwyOkO6vfBpwiFqV-SWKS29eXrH1ZAoZh9sWA7M3u5eFTxyCERoKhV3Ig", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTkzMjM0MTMsImp0aSI6ImY2YzE1MDQ3LWYyZDgtNDEwZi1iMmI1LWFiMTg0ZWVkMzgyYyIsImV4cCI6MTcxOTkyODIxMywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.lD1OdXM0oiqD1Ai8nSPWXhD-7GxDMlGDvfRmZL400ncW3QchKhotwcLRcjIDlvIyD9u7-gLSi838N1z2et-KVSuqg1tPKsbslMuF0nfqgKafrLuVKdwgDBIhuE6Nskmu0oVf6Y0a9kO9MmirY49UhEq5hVdcmkyVXG9SLT8eLHUDvSXy54DMgDnmoXH6bdLCfrdsr84GqNrKaxHW8Zp-pmr7eZpEp6HQ1F_DPCyUBXsxTuUK5NHGoO90ZaxBF8l4F-j_Qfv4rS1xSvJOCHq-pwqYCivRigaMV2WJjk8L-TiWwv6SXB2s92_RJhY0Ca3IDvtAdzwt86eG2eT0Es6bYw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTkzMjM0MTMsImp0aSI6ImVhMGY3NTllLTk2ZjQtNGU3MC05N2QzLTI0MmJkYTE2YjVkNCIsImV4cCI6MTcxOTkyODIxMywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.XSd_U7eRZiYQpfl4sGQrHF1W8Ei4gq1bm-Pz9MljF8k5dS2_HRYBFoW40o-bz4UIjjY6Mgi1WpkTcYdyMCdyX0m9MT-7hOFR33RZVaVTM4j85xTDfXnaNpcwtHGtaZS-ckYXSZwPFjVMwEwGcWnZZErv8Y-DIBChNoCp41KNxJAPu7f9QHaukftihUwV1bbRyppAy05lVlwkX4mov6r0vpNhY8Un8hcOPoz1Y5cTO2SbKBgjzNlo0DkU0Vj_UEuC080l_OdLxNSk-rAnI9rLJida5G9ex_2zvA7TBtVs8t3BUHT7du6Gv0YISY_M3nro2rzwXZOI-NLk_MWNdlU8Gg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTkzMjM1MzAsImp0aSI6IjYxZmJhODQxLTg2NTUtNGNkMi1hYzhlLTczMDlhYjUyYjI1MyIsImV4cCI6MTcxOTkyODMzMCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.dc52GK-6FXw9iHiuRgv5Z8422XJuCqIDeM1D-9E2BOOheTqsoMkx4E5tmiQbLhRTxi5MPU0YMCX6fEH-q5encAXG3926hnEFNyhF4U4Z5izoPtjpeRlVIMQ-niHiCQSmvCx7CW9zCDnLlvtSoMX2R7vHJvrMeUXSrIt4BOcfpHiXV3bFjADbckWXq0nWbnq1hpDcYy8ZI9mh8IFUR5fUTWDJuKcEj5qgY1YSJT7jrMn9OeJg0eNXz09Gw0gm1j1Y0Mh-cYuxIQDnFr8nrXXNuwZwFUN02Ct9fLBAXp0wECB2-RZpwVDU_fbXsca-4_Np3ssouq-IS5vBShboyUsBWA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTkzMjM1MzAsImp0aSI6IjFiYzA2ZDA3LWQ2MjctNGE2NC1hYjZmLWE1NmIzODg4MWJlYyIsImV4cCI6MTcxOTkyODMzMCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.L2XS4joV6se2zw1ahjhCLMG0ggjqLqqRnXcNt0hn26kF-pUNZnjasHCEQ_D5_AjYYBfoKWvkWd8FDGzg983lsxxNCmp-RgOVFdxBA1rIzxSFPz3AtHDf9Pz8r6SxSTI8gI7UtCsrXPFonKjZtKM0LKHgvQEGj9Vl2PXyIMuRVZT4qf6whs8oFp3GwdWwLzQzlFP3gZdy2qxncOJZF5j1eqHZhLXD_-2s7v1bscZf8JLLR5jHRYgNYxlqcuYNUvccMPd0lkUajAxvbL9bb6HVDu0SH7cAL6xsxfLtfsLleuXXZqeUvhFBwclwOEGN3mTyuQmANnKiPvL19N_R8La-lQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTkzMjM2MDcsImp0aSI6IjlhNWNiZDRiLTc0NjItNDUzNi1hZWE5LWM2NzNmMjFkMWNiOCIsImV4cCI6MTcxOTkyODQwNywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.x_ziHVeUqDKQ01HnqeC58aR4ZIFUIW3D7IBQy9xk_HhxJo3tY_VNqoliMTGeBZ0oV1ga_VvDw_xQp8Qy15_QiYTIqVIsx9YhGzKra2Yf6wfmD3hGg8qm6FqPdxgnL2ppVbApjpPZ7Y7QzFftzbmeqH2NQIoGybQhs-bvdi6fjGoLOHFUe1HSWFxU8XYv3XzPEedVvkRltuDmgcNa2O2ChLkFLgEEJLCbELnR4S9KzmNhVDSJV3iFkI7qMKp2LLOj47IIsRVm1z-hz0c3s8fiqPIxIUPIq_RS65abw1sayZ9xu5xd12eNVVWlzv6jphGQivOYA7GiNpVEznXp-K8OPA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTkzMjM2MDcsImp0aSI6ImEzNGFhY2M3LWFiZjAtNDAzYy1hYjY2LTlkMmViZmYzYzRmZiIsImV4cCI6MTcxOTkyODQwNywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.pzcLdmr2wTQeMuBfVAYCp_9tAQwy6gUgLZ3R3t9--gN-HCXb7Msk-eafVlnYm8Z-XcLd6Z9gcmDmdUZoo3tdJRdtA-MF6ltZ2OTtFVI3_IIwGPRQ6UMU5M8O5onDBW312c0PYQjLUlw6F9cZJNUZD55-rOFKrU7G7DLhLV533PLr4xpmv98axL0I_czZO37Asj0hP3sxyTH8I6MgQwSwA4uLOgyCkVS34VV0Hjz2ALKKyNxxDrgiorFvLmT80p97bECIsVkpg3FeuEGlOuPEuq2qqiDcvIDp4pKyDo6rWXfom5a2xZUHx8rOOR4iqrGimZ6QNIyhpcJhPv4E-Jep8g", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTkzMjM5MTQsImp0aSI6IjdlZWNiYzk1LTc0NjMtNDZkMi04NjM5LWZhNWI1OGYxMTQ4MiIsImV4cCI6MTcxOTkyODcxNCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.r2_2_WdUhbUP7bp80_i9Q3Yl8zxHL8riGgDYiZG_HjX39NLt4odNZ-jF1_usN8qRyCV6b1uCBzWE6dW0uKjOGDm1l9hgvZ1yo6XH7b5YdDdPltKrZ6T2wGBSTa9B972oaIQbHhhMdp_hiG-p3uiY4CoVC9hOmdixG3NoH5RMMqYDkQqq4YcVyt68QYry8gnysrSd7RZ5bbkM-pgL8fdQqF3SUycVnSCkzLEbqpokC2yl0mrCrMLz-Ai7OqiY-pPHbHEmqngE43TLvqcZ-oeiTuE2XcArHsJr-mxys3G7Zetfo2McDXuMOxIQ940QQEFtkF8lemYAjJG__ty3XGFwJg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MTkzMjM5MTQsImp0aSI6ImQ4ZjQzYjg5LTM4OWYtNGE1Ni1hYzQyLWM4YmFhZDZlMzgwZSIsImV4cCI6MTcxOTkyODcxNCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.WVN_sJvf7AiC9mNEDVoPyrW5AwMGKd_roDjzJhKPSnUbN2hCWf__cqFM3yqNUdsHbSFC64B3u-9nV6G28WiSygyjWTMo8YbQ0kpfVNz99_kh-Wp96aO-vlMI5057oocfgjg6Vsh3SkJA7XrTJJyeOJsQBD9cFs6zKK3Cpdc8_3l82kLm_aHHTFkrpOERaHpSIOfiz2_eN844LdaWPJ6fDGdhjgj1obWhrCJYCb9v4KEqb0ppQuFRRDa3UewCLaWQAHC1MzJ51Z_ReOj0WU7AZD70XNJ_6t0KO5Wso2wN3rERD98DfpELx4cNnaqhUkZ5rkR2lune1-_dUP3yCCT5lA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0MzU0OTMsImp0aSI6ImQ1YTg2NDY2LWVhNmUtNDYyNi05Y2RmLTI1MGQzZTM3MjY2NSIsImV4cCI6MTcyMTA0MDI5MywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.mVHKpKv-mI6t2-cFwnotaRZ5KawLEwn6d1U69x-yAZBv3vt-7WR2zA07TDhFKe5D33LgA00VxfRGWOT8pdzciHJhN91XEgJd8UzCZ2pAxuVnhibHky3sfhMChWjaPDeHCp17WN0qxpJrJxF16fqoCcjzJyut2QZNKvWBF1uktR2og29ipt2sQxHzBGn31sZO5SH-6gWGlwv2ICsyMR84EPv5dNGg3ovZ1K5aCra8rk3kqX1wFsMTqBwyd2UZSNpiumyPvu6mFSRo8Vrfx_hUiVBNbAFOlvcT7hmqIfpPO1lQO8skxIH2MBnCuqIO2K0ZQ7JDZWd3odUrwZ59CfVjwQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0MzU0OTMsImp0aSI6ImIyNTJmNzc3LTVhN2QtNGZmMS1hYTBlLTFjY2IxNDE3MmIzNiIsImV4cCI6MTcyMTA0MDI5MywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.2NI88_SvJdz9yyNJ51b83g6STGv_ACnixKxBOT-R038ytu2THJ09TpSSk6tzJtZIXmHUvs_9hagCuh3WFJi5qDTmojwMvOSBPAcByj_4w8bvKIgiQid04RERCXSK8EcdpwndIAcdAk7yDjYaCHoi07Wdg-tmJ44gPdsDsL0QhjkPrFwlkgVBJfbUNIX_JiAQkAXkNcNJT4OtI2vwpB5OMfET0rCYx8xlQNqrBmUtXxAWazIZ5KHjvXbCwpdiXpDXWqOus5UbPjsPjw4k8Pk_8KAxfCK90Pb3VClEnjOIe84RZAnshTw53iLwM3dJr-pDfLXSDNcpr4ApjX5C9L5Scg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0MzU5MDUsImp0aSI6ImIxMTI5MWJmLTExYzctNDg2Mi04ZmU0LWU5OTQ0YWE3MzJlOSIsImV4cCI6MTcyMTA0MDcwNSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.j1kMTTq2grItbbD-taw4qMgGLhwApdMjC9Dui4WzYOuPnDSeQw781UAHRv7I1zmILGb9x29Ag5MV6ihdx7Qkfu6lIqOkrDiMaTPz_a2DfOFRlvQvR6ZMdOCHHnDujMfSyRPVhkGFTFJGzY2nwV5hsHARXkEi62QO3kOz4lkknALUtWY4uQwQ9wrEol9V2TIXpCvU46X5HdwUTD1wJbL1R7Wg0Br7Mf-vR9erEMs37nKD7uJTxQ_r1orlMkCBouYZulHiR3kqb5LKf12B7dqoyiEuUvuNSBCvPENGBowINWzG25uHhMl2vECwFCkmsFYWY8Q7RWkVUj5TAWMqD0LBEg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0MzYwOTMsImp0aSI6IjM5NGM2MDU4LTkwODUtNDNkMi1hY2I5LTNmZTg2MjYwMDJiNiIsImV4cCI6MTcyMTA0MDg5MywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.PEu2Zxl1klx5xfu-qpr6Iputl1APFdShXRSLOEOSfTejrMePJ-gb5Ht6VytycCI15r4WayBdeCASfTuCp0jqK3kCc0xordWD9KgX_GH6dp9wK_sfFS7023wYpdQEL8eVoYVNyrl0MqRJeRvcaXqlDKDvHnZhYW2AYxEwbBF8PBAY6MNJRm9R21SCxByz50KhjM_9hfmRPlSJX0yl5GU9YUiOnJanYZgtR68F8GoTJejgeDHWuOnz4-71sv4YWg1jGw0SFPY6DVJWWzlnGngbTue2Lud9LSaE9-Mm4r7PwWuQHLuXwByLOeMfXJD7PfpQFJnONv_OZFfLe6ts7gmklQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0MzYwOTMsImp0aSI6IjY0OWRjMGYzLWVkNzMtNGFjYS05Y2U0LTI5ZjY0M2EyYjcyNSIsImV4cCI6MTcyMTA0MDg5MywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.wEuc0ffFysuBs3G9P9fHEe_TPL-BAgGjFhbJOueEEXEWu2HC65H8llZE5kPksx3Uop3EtcaTslKvh5W8ekbO3yisQhiqB-pgdkd2F-GY9yU6RsvvFm8TiZGhNIV2kgFrcqT-mxin18uXHuS4mK0-TB-HXxZ2ODvqDBvtFzS6rQTw8RW9CSlTfB_Bn_i1s5ESEbuHe2cTiDFtaRUf70hfADWna24wal8_3y1KYW7YB2IZarkEOmqSmR1f5DqQp9Nkkg7PidwwR8YBhVjwM2wZKzqHfG9RXmr_ldx6Pptw2yoTdg3MRjDpG-cpdZ_FnAC7nGuri3-adouDb215ZGeS4g", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0MzYxNDQsImp0aSI6IjIyNjA0ZDZlLWFkOWUtNDg4Zi1hMWQ5LWRmM2UwY2YyMTA5MSIsImV4cCI6MTcyMTA0MDk0NCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.Twwvnlg21dZdR7T6oyhjfJPWHZkDop8yd-OoXc_MkBF114H694EEIpTzIkeQIrCEn5tmDu0qVWm_OScCObBgKwgXfYyPeDzPqxlZ9o247h9cM_3D6ceI9O2ISFfCnNRVj3vnsM1buhKJVzUtj3H4SytR7-oKXNE-VQ9da_I3HAqF8G0pj3dIvyi04Z-21YokG5OJTv_xPYV0cYmaLjVWz9clQeTgoVI6bTdzP5oM0M-x8XfEYpIQwZkpBeN5yzk_3pyC7p-XTJnqCXo0N-HHVoBu2YEmVStYlPS6c9bsSpViFKnggZ0UsSKTCOLLVOoe4wsZlkSWJXZIopzenEJu1g", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0MzYxNDQsImp0aSI6IjFiM2M1MjdmLWU4MTYtNGQ1NS04NTliLTEzNmQ5NzE1YWUwNSIsImV4cCI6MTcyMTA0MDk0NCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.DdtNAKcJYJw-oap8CyRC13G5AeYh5AZ6WWPaSGchmD4owWpzLYyXeUL7nOvmzez8l_EOmMW4RRV5OQBUKzPBmucTqzUL7IidteguSujce7_l2IccZdG34ivyJmdodFp2_q35J7m6jLVCJ44nPlV7_8FhJuxR3p1w0BDqJwJORpMbvPly0_fPKQ__HwGRzQjm41-zahCMPv9G9P13nbZYnuhaOzOAmsFgGR9UVuuO6L0R3Ih9mRI86JMMWJ_a3TWHhep94-NOHGZ5KO50hr-6pr5B5ZAKwIlyzyQ_2-7MM_bK981gsFvxyHx97U1y7h9XX4WUcLfj8Ekye2iEUJzFUg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0MzYzMDgsImp0aSI6ImNjOWVjOGQzLWM0NjktNDFmNC04OWE4LTZkZWIxNDY4MTc3YyIsImV4cCI6MTcyMTA0MTEwOCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.O6e7nFI88UmnAEZNMSWjEF2ItIyFD-p-WT8AkMtCEXpX1z-H5g3lpOwTVS0gMlLCJ-pw2OCGrwC2QOSdekqSassLFQh1OT6L26ns-sO30QxoABGE6vgclghChGDlLSHAy7IJWSyI8YzsCAJvi4Lo50BmdPzVZ-U38sYBivlsi9qT_nMLPGAwk_FjiAUF1TDBtzAVLce3U4nFV3MRK_ljuSyzsgxXQ8mRMKdjgVVJyOfe05vfxNp3gsMSs2n2R5AN--41BsfSsnKtehojboRa8cVd8GFI6bNVpdVxcpr5DHGNxua8B3xJxcTqMEhIf4mQJ2BEawAOhCCo5ZDqFIUJ8g", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0MzYzMDgsImp0aSI6ImYyNzhmODk1LTBmZGItNGFiYi1iNzc2LTc5ODU4OTYyOTYzMiIsImV4cCI6MTcyMTA0MTEwOCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.l-afFuX2V_3-9fH_N-WZq9gDm76cSGrV8HoJPTGc0CNZB0ULXgbg_X4S0PokuzkvndX8NbkhYVB8kqgA1f01InzOBVTqmsNxFT3gDN3RrXsbHF8eu-2yVahR6gPEYpNHu3y0IBwWPFbHXprYUAvSfOkGgD3lrKHfAdYB8aBZd1DQ017rXGFtoXJSFzP5aUtIpYZDOByNQpnLG-ZvApq1RF5FSbChPBCGMhCl2k1NEBo2llr0bsb6qR-y5LyD9PgAgPV1eclV_TeVYkoFXa9RZJiZEUeByQ_5GtMVhvN9-w2mwH3Tf0Ee1SiJxKIumCzNwMBMDQh-GDGpDQOOO9gZhQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0MzY0ODksImp0aSI6ImYwMDVlOWFjLTg1NWMtNGEzMC1iYzY0LTJmNzQ4ZGViNTVlYyIsImV4cCI6MTcyMTA0MTI4OSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.vXQxtlVIausPgJVezt_MSTLrjloUi9MYzRauVNMWIDT8NNFbcUHxKAqvb0hESNqh4MPUzE5XbbtZCB7u_F-AtW4Vd-qR1odYPMZc2Q2dD3SF4zS7zKdfYorlxWldhFHG7DukyOt_JGA1kbx5sX_TofkBNI2AbLY4Y3IuezS82Z5CQiKcNFW-afzsrkA4RvPxJrNjM60JuBVBct6LxARlekSstK0jzyvgZJwQPrAzMDK29TK1cbe-Otkpt6buHqPKQejQqGesymuNw_XI9cP2Dvgcs3AAIK9Am7oYryzbaYPw85c5-ACA0ZIU-9vvh3k69vf72MXXtqmWHTBaFNT_aQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0MzY0ODksImp0aSI6IjQyZjUzNTJhLWFmMDYtNGViNC05ZGNjLWQyNjdhYzlmYTAxYyIsImV4cCI6MTcyMTA0MTI4OSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.pvkOMtckYf5z10B7TfkDGHs__GQHaZlbDvb_8UBUkVf0ELpCwU87-gWSXIMUpgjAkG9Y9cDhlummytz6gODSFsAxKGM31yusRi5mHX_iEKy_t2CbtblsHjHGLu9RHhyqkm8YIzvk_5w_96xjVmpqj84PJaKXfar-vSGa3E6wn0y_UyLKS-dRk-Rp8dKP6Xpv5sSygnXV6le8UCJO-nqrEJ4bCjBFE30UWqsXukz-6MLaP__g3lfOx2yU6xhH17gDuZaZFPUVBv_Tao0qrF3m88NHg-vL-_tI_fLOv0Ap_TM4jP4cnY8VqcCxDlswweXP8sJkE9kFiiIBGL7WCiozFA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0MzY2NDQsImp0aSI6IjBjMDhiMTM0LTM3NjItNDY4NS1hOWE5LTMwZDIwNThlNjg0OSIsImV4cCI6MTcyMTA0MTQ0NCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.XbmKgOYDwGvW-mxSAC3RQGXA_uoFRkfmeHbrX_-HZbEW8bMWSvfOFHBnQs5hd1mpEU6I5LkPR_K6tJ6TfD3FMVzrF_1CLs5oKwGYGFJejIY_-cLGtbsf7w5tMcVzeCNOKs_SsPEi2_E1btfNAvD8yFPoEa6FUfmJlVDJiJauoqh_b_oIy16eAuzvMTwBmuskivdBLcuLp6DoWq2BZk54-uaIM-Ivb0t7EI43nC7eub71YjS2HBj4yTowmX_--hfP2_GsXKB8hd97rMC8HDe752vgQqJApVE99VsCVgnZcc7kVLR_2WHrvkFeaoT6xT7IONKV4bRo6scCWOMz6C2xjA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0MzY2NDQsImp0aSI6IjY0OTEzOThiLTE0MGMtNDA4Mi05ZGMzLWM3MTVmMzAyN2RmNiIsImV4cCI6MTcyMTA0MTQ0NCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.TDhoJoOD0mir_jbainmD-kN_AHISnd230FCzsfRKhULs11_ZY4HTl2dKQ3YKpmXqyc-0bPkXHSqs3gK7dNDhKivwefHqjJD8X9JaLCemWDaxAHAcNLNIhFLXSpqz8-UudaiGPkwBtiTM0ygg1fWXX8FxAzrAGotXo6sFLo-AUU9AMPfEPx508R_noFN5zfchnfjI9ZWG_SU2ABECc_EJ_9rsg-F899wBAulOeTF1g5fcLArHmuBj9n8WrQx7cUrtVmUsMHn-p0Tf0MDAQRZYNDDZ7Wlz8U1LtQ_1WIykSPniOp9pBIFqEpXryT9hCircwu740735YoRHFcHrb_-qcQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0MzY3ODYsImp0aSI6IjhhZjRiODI0LTNkNGItNDkzNi1iNTFjLTc1ZjdjNGRhMGZiZSIsImV4cCI6MTcyMTA0MTU4NiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.Dx4UP3s9i8mNGWjl1-LwWyhctf5Bv5Gqs1BCly6rzfLsQKIIe6ladwtdoc9QTlYSSWueFSJVhiBcIQ_oi8kH9GRqI6XUYhfRABQS8okr-ZYmpk7jVIx0LtWeJtTZiUiK-e2DHUwX0c0hRhlwESCWb54Vh1qjtlf0dQND-mmLwpmwAq9WfMQN6aht49ZEw8i5DXNEMyNyrdnF6oMbvT5A5EzWSn9Gl6xaVMLop2Si2c9V6_o6uhNNIkrIkOYxpVnJc0ybizhJUhPpsOmNsICxn6fzO2UbF9SKwMqydwYAKOgpSJrLr5daaR3KWVHim_zSeHf4aWiLkw_DGR8YPfklFQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0MzY3ODcsImp0aSI6ImFhODQyMmI2LWE5ZTItNDM3NS1hMTRhLTgwOGUwNjc3MWNmNyIsImV4cCI6MTcyMTA0MTU4NywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.JbtSSK_hPVXgarqaZRAI-9lxGObnxw7U730LTg4c9HhUYW0ShMWkwvc5LrG8ydtxOFJrX7Z3NVCKXhwJZgr8JaMoenZLDUCyHM6aAuk_jVVlJb7ZP4zDbm-T5GpN55jZ2AtTjcVPRtGJfQKPRhlbjCDdMlqnzJxJHpfvOpwoC_K9eahopwhn1sAmDlvNCY11lFoSGqQ4C8g02OSP38-Q1GWp9m92UJ7mWOewIM5VWXGN-eArlJrcyVOrfr6N2GZHQ3lvFjdBYSf39h2RhX0xfyxHZgHIkbXM6NMt6qYTho3m-32FEmGTBvIH00wj6hT__TJTSi2SBUAUM5qZkoTm8A", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0MzY4MDcsImp0aSI6Ijc4ZWFlNjVjLTQ5OTMtNDVhNS1hMjg2LTQ4YmQ2ZWY5ZjVlZCIsImV4cCI6MTcyMTA0MTYwNywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.SuQFcCLwFuihWMyUo-AKsTHeS33IKe0UavvHndG_2palehkFsbNtNTcr_fKL4Me1e-2fP68i40L7Cb0YANHoBT7K_Xs4bP7NL7XAHTTm9wq43PKlt4HKjWurXY71TivjyKk5AF2aMsYJ5Q-Po7q0cYxm8on8Gx4BxY3Pgx1JMhAU3iz3at3Q16LumO1iA1YRw4u_nSSSiyIyiGm8CmHeZl9TegcRo9Lz97B5g1kKFGOLd3-JFd3Dpu-32QCd6QZeJZ8ukJJsrD5ha7izMOdwb5LBt8pRx-QDhLfXZcQ3_PYX7qmyf9jLoqrl73qv2zvhGCOM08fQGlU65FB7wuT4SA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0MzY4MDcsImp0aSI6IjEzNTI2Yjc3LTc0ODctNDE0OC1iNjhlLTNkOGI2Y2I2ZmE5ZiIsImV4cCI6MTcyMTA0MTYwNywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.s2_hj-by01AqGmymeKOmM9jrgQQQXJvaMkLrzO8TIqgzzOZIIYGe830HWV77cem4i-NVRtMuaBNEx9vZCSsDVCeVAWZgHT9uUKUHzrDyn6Ay04rnVlyQdJ2bJbB5Cd_cnvlC5R1oPqCUr9IO4mO778aL0e5CXc9hKQCdHkK5ngvUyYvS_9qpPqXmx0T0dIDU5Smn2nuqvuCesrWD8isccX05fgYNNaAY_Y3XmMymBcR3EZDhzpdTtXSWckAewBNQ69mJVUlSDWh-aBT2MCzzOuihp5eEqMfEB3eblcTmKta2vXvz97_3Z-iExeW05guO9HaAkp0BBWIpFtpL7E-0Kw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0MzY4MjcsImp0aSI6IjIzOGE4MmZhLTEyMTktNDYzZS1hMGRmLThlNDVlMGQ0ZDhjZiIsImV4cCI6MTcyMTA0MTYyNywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.NXSA2L61NEJeLLqTqEvNxpxqpQyxec9bnZTVBTub6UblqzJjUzlQKiXcaQkenuUgY6NYsksMio6LMC7jfQQwGXzxaQlli--BoIbcmpfMNweWr58_LdGaXOqOgB91t9vcMTd_whDM3gJmPOFDsOBt3sFXRE2obIqAMGqqY5wgIhdfsWsGrPAAz4AC7tD2fyEFLY7gNUwjwSswo6N-sEnMD40ILq7ij-g4RKDsJ1MtPOmI5u9C6weRRozBrP4rVLr1erdSFxskgH596pEBPnowIWlbOHb75AgivishpKcYCDwuixntO9B6VzzjYqHJh2meOqV_kEOvEpVZC7Pm-3AqIw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0MzY4MjcsImp0aSI6IjMyNjczOTEwLTQyNGEtNDEyZS05OTg3LWU0YzIwMTUwNWMxYyIsImV4cCI6MTcyMTA0MTYyNywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.LwoFqrT_aLJaaDcsJ6xL9ITiLMHeTPQtnor7g1wiepXs3vLmXimIZ7Hlf2fG1dqGF4FxRSp_XERBlXAfe4aH1nC9ZFXGqJfcEh2XR7EVg05u4JgN2wcKYxQod-_B3oflkJUaiID1imHUKEjo4JdIR0_arBSllKEiY8LBc09R1MWUWQ8HTnSH02cH0BQkotcgrj9eHEKmA5fU-wbjT8_fM7afQzyu-imyp_cM6NukE91mjsGP4AafmMfVVA2hQYNQ652GPVqML5HkwnCWuB0LxgU43qvPHDjbiuy0TSsxXl5kEgkdO99dTTpa4XKFSpKA30ZhvVSq4eRzuKc37tcNVw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0MzY5MTcsImp0aSI6IjdhMjg4NGQ2LTYyMDMtNDA4Yy05NzMxLTMwNzAxNDkwOGI2MiIsImV4cCI6MTcyMTA0MTcxNywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.kpSFsGNJHwZyl-O_gF0sdPBM7hlRBtsK_h5aDyhU56M7yzxBMRAcVEMI5D5TkzXThTW6vIS8hdPo0eLUBWmjkiUbdevds8SJgdbDtgJpTnjvfGK7chLMnFB_wg8-eAJ5-IaHw5jW0boKohZELBKoAWCori_Nmfcl6du0ZXBoSrmuo1RghoqHfQMlFMeJNyhEQo-Q50XdCJfJYwZJm5TDEGwIgxk5qGXHxwmv5FMD4ndBlX7s3Uhu-DyYaeBynMd8fAbueaWdD6kT6eNSFcKHkhv07nsIuPvK2TcR8jyebWGjoTn9URl8Bw_Q9irXrPBo3Cm7dfeRCkJRaxYWzjq78g", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0MzY5MTcsImp0aSI6IjU3MWJiNjI5LTUyYzAtNDMwZi04ODU2LTZmMzRmYzA5NjYzZiIsImV4cCI6MTcyMTA0MTcxNywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.Yw4g6Qxp4BsqYGCtE6gA4_yuEg76Nady3PAsT2lxALFoXqW23x29w8V6nRTFYOG_epmfFZsk-v0hp6oxLjwSJiMsBS_30E3ebqc92CIe2VCF2c15fiHBpar4NVqmmRnCp-Hw94EIkgeermNvRcqXcejQ3xpNFFhce5tAkJyopE62WAs4gMQ3G2qJ7FA_7DtiNNBtbe_mPYWvLOwF9ckxPHLnlK8GzMOBlLjAQU_Do-rymNNGcPqKB6UKSJU9Njf7_bnzvMzUUpYzhVrhgv-iGpiYVFLVptWATLuVvDYq_NLqyIQH2_ciirMKFukhalR_52py2ZF3TSRxLCAP0-Cykw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0MzY5NzAsImp0aSI6IjIzMjAxOGY0LWI2YWMtNGE4My1hZWM2LWJjYzVhY2I3MDcxYyIsImV4cCI6MTcyMTA0MTc3MCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.SSs-WVru9FSa--zTmyVckIcqdXf5Q3w_npkCr0d84efff3YSDQbolOJuRnzgBGGzfi7ddWIF-2Jd2bNvIcV5F3z-Wc1YY4CPH6i38GD64CpCY8lATPtDQIZPZKaKsfDOo3ayRiTcFx34ZbkQH_oHKhK8efuK6uIjQ9SmArcKGV_ohFJVoKNJiioLRKuPOl7RRyh77irvRUKSKYjjlrB4daLdS6Y0UPvq01VvPBJ-iQye0w3IjI1fvkIfziw8U-ZZoCD8pp5oQD327ITzgB1wBUGNrBDgeqMUX8pAi52Ny9b68YmOEPSiwl7YdI8Hic-tqMbj4YkcZMePWH4WvfWYog", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0MzY5NzAsImp0aSI6ImNkZGJmNTU3LTM5ZDktNDhhOC05NmJjLWUzZjU1N2I5MzAwMSIsImV4cCI6MTcyMTA0MTc3MCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.pFmCb3-Xl61Qi4rmhChs9FngF9aYETcCsyWLvpnoar-A1DN749k0cCCx7BzgL-jaTEAolwUpII4a79KTIBzohoj7YwngmHYVF8IzwbWGBWgtAPP5IFBJ3xmVElRmsB4Ox1jNqr62vnnE1X12kGNx-vuCo1vesOq67yPlDadJaH9TDScIxiZYrVQiuS6JKhZHgIaReWivJ2-N1_XneT0572DVIdsvW_aCWzgDgtcc07t1x1s19nsJxV-3Nx9L5p_IsaDFlqxNNo6viSYMgPArjQAxMPpn1sruDO_uj8zbYSpaW4QuxGb98LCi78ymmw9Ogys_rz_TQ7HsDW2fB_XuyQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0MzcwMjEsImp0aSI6ImE4NjgzMTRiLWRmY2UtNDk4OC04MmI5LTFiOTE1MTY4YzEwOCIsImV4cCI6MTcyMTA0MTgyMSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.UVFW19nzVftO8SR_VMb4d6jS2s2bYkS3qA1qJUcSB_ngXBBAQGctYtPyWtm9kK7V2OW1AKx-nIo_oY18csTP4LQok_ykYPXO2B-WYWrAqBQYozyHoI_PlNc43SwK4SsScM4V1fTBoHS4hmsdUqx4pM2A3i3Z9eayronmNKD0Dzpvj59gJnuMt1_3fPOe-yvcXW5QskoMHNvl-3HS7oNHclA6NrBJ-276l_k9pfZ7qVDWQVKN8UpuEq4vHDC6A3OARjeTWaBkdasZ4Bz3lbeVv-5IRy9pRCsUAYYAcF0VWlAJ8sLdNQ3-lV5-VJGT602vwoJ8AtXx5Bk40DIzTWTBgw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0MzcwMjEsImp0aSI6IjUzNjg5N2M4LTgyYmQtNGMwNC04ZThlLWFhNzUxZWQ0YWI2NCIsImV4cCI6MTcyMTA0MTgyMSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.w-s0MREUQsDuIJ65N7KSa2WGPDcRb1shHI3-J43lJMtzj9-7tSm6qoXicwTQlf34POC7w4fsZKYHxXG-KpRsY_VwQ0ttBxgQJ6Pa8K6etWTFUGNw_TzYcy2CndW7lLmET6UPKMVN6rgUqbbKjlGpJGtZq9MEvG_Ug5-wOoUzs6mHPfPrJ1jW4qyBicA0sNEx7i3XzLqMVkOB4zfRsuAlVq0Ih1pQRClJtgdZVVBnwzf80Jjjln_PW1_ZkV4Jg0B0NMEtFPGmYiAkd9QwGsiAVl0rUUUYrmUvuYTY2uHkGNExeomyWg4wAU6oqhnU2QRPIIusGx6G7F3hxdDIKYi4Pg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0MzcwNTAsImp0aSI6ImQ4YjUzOTg4LTJlYTgtNDc4Mi04OGRmLWZkZDI5NjcwMDc2MiIsImV4cCI6MTcyMTA0MTg1MCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.ob0pmw1Gk3qSAUWl_-Vn1aHXEsBKAmdkS9xbVUlne2HZdsFx5aIokykGWIGlUNGDl5kQWAqSYJg6WqyqHLg89PgscnV4yRFb4SJpounZ1oMxG9B6Ul8h2Qj2brh-7GnVcPoxWTfRyboCZYYBKI7Qx7GPpLpEtLbynYKH8TAIT_jgRzQY9lGZPfrwsvfGGXI89iZk7MhlnIlm6-Xk-ifSnaFxIKSKf4yWZUS1br2A_4U3n-g4GfLxOYQz4vspqOVrnsCTYS6S3UQCvNSFvngV7GnelHFcy6-DyfVmtIZdOISndXvWmsLDLWNm-POwa3Pv2-o0NkBErWE6W6867bAF6g", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0MzcwNTAsImp0aSI6ImU3MzAzZTQ3LTZmZTItNGUyZS1hYTYxLWFkYzJjNjk2OWIzOSIsImV4cCI6MTcyMTA0MTg1MCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.KySb3I6BYJPBMOw6Pp2QRzV9yqFU3Zchd5_zQABHksTk8Eho-UEj5iCEY4JKqy8e2ZkbBWCoZGO5JtrRoMiFyWwEXZ0LG9IulXzVrD-3C1x2lA0qfrkKOyyp-cYhXT-rV4WZxLdnW2mjgX0cTMtGOSsWtsznpC1VKO0dh_nesoQtVjIszOe2NWhbZSMMuDZJUMl6g1jYdvyMVV7y_UvVgZ2BSsN_uWNrPST9ckc8pOeyN1Mt4gATZ2H3fCdoP_eAeFyHOcrH0t5eTbVCeq3c5UetfhvmuqGh4N6IuEAu56wtAFTlnC-khdlKT2ZHC-Fc_yOmDDtKZDPUCIFSSfbRfw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0NDEyMDEsImp0aSI6ImRiZmNkNDAzLTBmYTAtNDU4NS05MDU5LTU4OWZkNzYyZWQwMCIsImV4cCI6MTcyMTA0NjAwMSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.KnbzGL3Uw5nwGpr5serJsHncPNWFzooBFf6O2sQPV0cH4QBlODClrO775pv1bEBDXPgAXDw6svypnOKtRGABJ6Hpiw0uHuHfSj1fYxNAWaYqRbxytWkDcpEsBRqovPSLRtYRO_xYE2h9Vs6GnK_pOCKE6G3dG18g_QsV1q9ex7965p_DSuihbSqNSzgryx1Dm6rtCXBlHamo1jpKCiG1SBuvkzl3B0nlKbFfrnE-KZvIfOIYbYTXZPhS92GQp9s_WdxTeOUza02mV2qDa0ZkD_rCNR9jv4b4KVYM8W7hAC5olV1xWTMLNLD11PSl4wwf36YWQKGRGDRxDflvVtGu4A", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0NDEyMDEsImp0aSI6IjdlYzA4YjhjLWFiNDMtNDY3Mi1iZTE2LWNjMGY1ODdjZjcyZSIsImV4cCI6MTcyMTA0NjAwMSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.Cvasxn_UzDcT_TpcPppnEa8TmQ6SR-VrMyGZCbE4iTj8l3Nxn-luRJiRw-oxVZqLrHCf5Ue9FOggrfxp-Fo_hbN7OGFeel4zQbKAalU1d8rsxm5wT5DzwyvhQiHES_48qODRDXqy580qIC455u5ChBB5oS1IzpOreZCeGKXc6VDMFAh_t3I5eI3UR-TeSwfPVxCk2z-hKGNiKFC1Gfw9dj9FGEW4_X4u8Li51JaLWrGS4lZcSD-y9KvqScOfe5Nzza_DRJvHvE990xtjhDEazgjtrijDHHoZwlYkOtbe-f1LA27q4IiasmbxXgAyMw8vJpZWXdI9DuznBvjg0boghQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0NDE4ODMsImp0aSI6IjI3ZjljZDEwLWM4ODUtNGJmZC05MGJiLWQzNGVjZGQ3MjI0ZiIsImV4cCI6MTcyMTA0NjY4MywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.eDKEPv1EYqwyPGJr1GXjzyXDYAxlnhlVenjWxd0GQ1QHGpcuHBrtXRtDjQUUYs74a9Cbmv6eBXMo9MqDPPjmstJDfPLPd2aKpPgkI50fWVizwKEXeEvTwBV5lZrMuVyKcVwyI1nagmEzHUcyV0Hb1Jl66B91WaD-IeWui-v9XQou7fDtdIe4FPB63E5qAz8pHIULV8tzj48f5SuR9bNMn2w-J4iACod18a7ROuKyYRaMdL_G1L63mf7PIyqGSzpycMKLxXqqOKdxxIv11a_4qA478SfwEKKHxPgoeq0eOvY_uJCWNbxv8JsGGXUCqZ7rvcL_8v5KKXobBseZcZ2e9A", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0NDE4ODMsImp0aSI6ImYzYmM0ZTYzLWI1Y2UtNGM4YS1hNGY5LWQ4M2E0MDQ5YWY1YSIsImV4cCI6MTcyMTA0NjY4MywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.OlH1-Z9Pcv0TrxoBWFRAFQmxU0OpSInjwYKitrLYW5lQXgttBZfP_QoyXY4oXYGuBH1AvMFgiZ9Tl53eSX_uLpRMXx8_Gee8N7t-DM5tB020edDv6tkjsL_lSuRPh5Nh4rrOkoOIsezn5ceAQpdA-iLoAkkIrTjgyxFjRGXSRonwsM4mnP9ZYHq-k4MU3z2y5MGbfKomgakzRh2iDvCEYFadC_Zheh8UoLsJNJZj4fa1DA9RIywuQ2BCjReeZD7nTbmZiBPriTgc8I9F3gO9Ya8WzIoBq9tPrI-fzjevOo9_u7WnvlcSRZYzgD97kUcaHUqXIhbIfqrKMHIpZ4yAlQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0NDIxODAsImp0aSI6ImQ3MTAwOGEzLWYzNTAtNDI2Ni05MDQ1LTAxNjExYjU1NTAxOSIsImV4cCI6MTcyMTA0Njk4MCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.H8voG1vSIuWoPI1AA0G6hlrk4qpYiS9vUWBx-hxjA4NELgAcw0WpRmmOR9elaARuOE04V0MdM84xxAnGerK7PWP7Q2AGVB54yPiuhwJ02OtXcAHoQkyBD1QJ7CdXIjylK9Onf57-z9pHtPvbBDgy3E_A_KJI_NtioUygkoJRG99JJhxp-mGQvtCWPfKDIMYqvpCHJGjwE5cfeHgh6_WEyKpj9vZx-4OC7CxXchzUhUZITKD6AmlGsmKV8RRQf8NUP-v2EN6vmI1VUw__cknYNbhhyJvqbCbjbCuR_vms04uhEjFW2c6yLnzNTyfg5yet6V-GODpAdvOuzcuuRpjSNQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0NDIxODAsImp0aSI6ImFlNTVhNTdiLTA1YjAtNDcyNS1hMWMyLWFlNTlhN2RkNDY0NSIsImV4cCI6MTcyMTA0Njk4MCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.xbyzv5AchWJE4a-OcjjW_Ivuuw0SziQ1vsIga7Y3Nm9b5Vzhqu0wXGAntrAdInfM7h7AHXtscLsxfHE32EMvPZs5zLGl03w5xheZyAu4RPBbgs26uMmp2naTroIIO3M03DQHMdaUzKr2z6M_R-4NgY7FuTsc_eTY3GcvpN_gvcZDGD-B-W052WmIHZbthJUzgw1wzVmN3aNa2Vy3eiDxxUAR5QkGtMvjveBz7vNjhmLGmyKm-75Ser7yJHLZNxNBZKRuyXnEvp0BmFIIqxMJEEY1Au2dIBMmRtBqC2mDyHbfQRIHzOSfBB3Wtkg5o5cZxsuYimh3oFcyWdxEvW6g1w", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0NDIyODgsImp0aSI6ImVlOTk2NjZlLTVhZTItNDAwMy04YzYzLWZiMDM1ODM5NGFhYSIsImV4cCI6MTcyMTA0NzA4OCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.p4YrQHPYwMTBXd_ZGcIajVAxqEMHIHYDKDvWd0iBIL3GrSYHOxFp0JBmhrUrPWRFAqPufZsU-_xOIvr6Hd1OGl0cfKTUDGOKgVlEK80qzLwDT7y8eJbcZJSjmWYsCpyYtKZQExiFIEJuXFYMBGrnX8Beqblg2Pi5NKarLgM5oSrLIAwYoCYkca9KOf6_4sS_Hc9m2RyrKWeMqg6Dsa0eOPn1e_jPqBOkb_6PZNNYneBkyOW4k7tigNcgoY5M_cWJbBDm_TV5eON0zKJviHFv8RswunBdx0NfzHijf15Nngvj7J0_G8g9yYrK1Zb7p9pNQoevvutHSgr-XdbNP_BgUA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0NDIyODgsImp0aSI6IjFlMjU1OTFhLTVmMDEtNDcwMS1iNjY4LTJjNGNkM2JkYWMyOSIsImV4cCI6MTcyMTA0NzA4OCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.tdsiNYRMtDUdl5rSZPz5hvz0Wq0x08VrhItikmbxyksCE9R2omTQLi2AYR2IqSGmArh97hqC5POWil9fhIUqYZ5cgsZzasjK55VpQfNeEKwhbeir5_e4aUPbYEgbDgj_fhh_y7foHZ1PfmjEx77v-anMgNZcUwk0zcjsR2oV2U5X1DvY5MOvOoGmJLugde-Q_MfyeNlaIY3S7e8Hu7zZexEYrXb1SSyHfJtMon52Wa2_ijZXqkBJhSa0_32sPbIefiaTuXA1Cq4jKQ1e0F8RFvnSYVXlk-L4GLrsRnB6sLZPHvXDWr1-6kqlqlMS78NlxcvKRuXrfLlv3yvBbHv6eA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0NDI0NDMsImp0aSI6ImNiZDAyMWM5LTEwYTUtNDViMS1iNTJmLWFhODEwMzJiYjBhNCIsImV4cCI6MTcyMTA0NzI0MywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.BfIvVepHaHPzfMgNUp62VCKI_o8kI2Aqo966yJkeR5SCtkaaBnUEfvAR1rFhmAoegIhdeyv7r0nHVooCJDySc8JTkZY8MtQzvsFCHqXSxQxkDd-KLVEIUcwNvyIM2AuWUP4ZSvQaqJzTMpPDbYTL8C7K3f6eWjdZ5sc1jzm0FZGmjG04UPt3JoeDEKJwG48T8YhR95zbuGgewzEu9hZAHhDYtQJgIcuPnFKQbdVZpeTqe5vZ15G2CX8gmjoYqaiXu1wuLxmY0PSCptRi8GGArmqbvjIdK9J3NEmISKQaOky-9C8OX4rSLpOdpaRHSxhnyZsWOrg2-5VcA2R_9PY3Ew", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0NDI0NDMsImp0aSI6ImNmOTM5ZjUwLTc4ZjYtNDc5Mi04Zjk5LTY5YTA3MmQ1Y2NjMyIsImV4cCI6MTcyMTA0NzI0MywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.Cjd22ZfYEHhoe-NZYA0PEhsm0wjSSTuq8y6VI-KscwH735I7zXp0I8Cmtqo5VvSAUm3nS5g_e3DKChVhXWWExTNcjC3dLuIntsQvgNlUK7gYYiXVpI2jMioXEo0faX42iqtdwCVeoUYlbOUKPWx2npijWofGQYsXb69T-LzMHVcD4fHECaCNw2PRzmJ6swCR5BH0b9CDZAuEImMRQEA6_0UeTUncly8b83A6ulOmU2xxcl5XeyFxChc987wvbyTMa8LjqjPISdpb69sP8sV7B0L9MOvuHtGFc_JHWaN79aJYRWlg2OU6nCNbT_2WxpwbuWlgBEzwFu5XaeCCheh0MA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0NDI2NDAsImp0aSI6IjhlNjg2NmQ3LTEyYmMtNDY5MC1iZGM1LWY0NjE3NzhkZWI3MSIsImV4cCI6MTcyMTA0NzQ0MCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.wEv5T3of17rS-LpuTG43SpJkkkTk0KHYZsRl_Xc_BZ-8jv1AyKuMdS1AhI7qnRPkbnQDeMPtZqd5LOEkmoXJGIgDwKbjJRkIH4n3E0wkhTdCNPolXe40cKSBfLwBMM9lL7u2sOUMA0SSAYiMZIG-PSfs4-VrEL2kRsha0NLg4oPgj9GyhJftp-rUIHo1y3NUimCeM-grNIs7aYwVzIEVkels4rliDgVj1Q88hrGdIeLi8nJX3qTLvvuekoAj4_z5mBgLfirc8g5bXaERK1AfO_ZnBi0ZN1QSkwtrVrLHQfNL-gfyRExwwFWW1O53YtMasNx33beUrNgNR4VeS188DA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0NDI2NDAsImp0aSI6IjFlYmY2ZWFmLTg4YWMtNDU3NS04OWZmLTkwNjcyZDRiOWQ0OCIsImV4cCI6MTcyMTA0NzQ0MCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.G7da5aH9NA00bTUDQcVs5sz5SdLICwoIoCrCBCYjXKTHYBNZPKVZUqH9mMKJn8NLoU1qR5s70yTOFD_iDz1PyBJeS1NHYF20vA4YRFn_EFKSqKVqm65jiEDsQjmKNXiE-qzhOQzuJ5rzLo7mMn2RzacxBfilmJxRf8u1GEZPa0AkoOdmyd_leycUD-xNkh_9fk3Kt1ghrPGPXQvbSXe28iVSHGuSP_FbV7Mm3LVU0yusErS2Yxw78w--MismGE_WsU7jRwdOiCpkBn3eVC2NqrVQcrMRDwhU4hTd_hCMl5Cm_fbyorRSK-3pA6wTX1TrnfRaLbiryxVDGzPgNOk-WA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0NDI2NzcsImp0aSI6IjZiZDdhNGVhLWVlMzQtNGU3Ni05NTIxLWU2MjJkMDk2NDJkMSIsImV4cCI6MTcyMTA0NzQ3NywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.Ci0FgDU2RiP9Srf_zOEhJgzAkIz0uX9iVKXmNc7JInoanI4y_c-S_Dr60hk9LgW6pM1-krM5uIRMNM24EyCd8Dy6CS2n8ItUjnAtGC63kGV1wopV1_iPwM0ru1vCjtyrSFeJwy0BuhhTk1ERzygS7Tl4z1-ihodZDrC-HlMcAon8Wkgl8yULlApkilaMmNzEZXOQ7jSGe8q7mV1HnF1xuYmj1XBmXhlN4GW-fBud4kJHtdeSFBPJ8LYnWLGqXQiHm9hUIM96nuXLLQqHtHhXEArQJWS4VstDZ5_vFGZPHlFw6R7pPaJ1YvOJf51ApeCJOn4YdqdIVN3sE9JzTezKsg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0NDI2NzcsImp0aSI6Ijg2OWIyNjU4LTVjYzMtNDFmMy1iMzFmLTExZWYyMzQ0OTZhOSIsImV4cCI6MTcyMTA0NzQ3NywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.t9IZ7iSehcTB4yOizvKYjxn7qM8ekIvLJIbd8xCcb71BL_m93zJCJSMDTMaaQxrbYrUeZs2751_5r_w7ia3ewPSQLANHdvrdWVeKya6dhSUUlPd9TAnfrwlYsfkrKERpMs-RmAgJ27Nfrx6Za6AuL9i2TIkfuSuzj2orhfx5_Ys9S1pPw8MGI1SHwg89wh_plKcjlVrRwoxir4wSydwDskJRUIIEdevFl-sLF07NgTHFD_TvysRrvt7GINn-r6fEtwzoSMaa-GOmgzPvNgAaSERwOhxJCFgUxp2JoB3FKXhdbQFQofjqcsE_CwoApxW5MiO-86YQkJ76ANQtAwbWuA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0NDI2OTYsImp0aSI6Ijk4NGNjYzUyLWZhZWUtNDIxYi04NDAwLTJjZjQ3NmYyNmVlMCIsImV4cCI6MTcyMTA0NzQ5NiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.nWgn5qkGByuBHvrJm8fwoGoXAQ35LwUzPVnWGJejCYQaMH3dp3tPI4DWdGYZ1tFBd3zYDExlzPm0_eRsLZL_JFyWfwWh5kkplweIzgcbHsExOuBv2EMHrtf2IZBY2OZSZNMEA_Xd9A1o9l1cRQh3Q4NQC6XTR6seJabGcu9admYyHamp0c_Tdq3lfMDfeUFROqcrl_da-FonLWxmdn08UBAbyvHbC5FnF2Pzqpp1LkzwFTpDYz4XhTfr6E9TQALGJacgW0Jz8mARXrwY01NFFsMmtjIlkqfsLDPfWyZ9f0biWCnfq6tF6OUfRnI1z0JMDOurGuzdwTurMlj77PfHHQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0NDI2OTYsImp0aSI6IjhiYTI5OGI4LTUxMGQtNDQ2Ny1hZjI2LTMxMmViOWUyMmFlZiIsImV4cCI6MTcyMTA0NzQ5NiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.KXl-CD4oZbmAooH4SrFd9wREr7GEfN9cdl4D1dAR1LzFF3oKgor6_MoJZzPmlpBQqdBSHdVl1s6Ux3lmSojtNvXE2q8zjUsVKwEHzwwzO3-KDILqEz_oU5FfG1MBYQbPGRSpqcve_JRpNlv74LJGYNRFTaxGNUJem-wds88kre-Dsji1WdFezaeNQUc0F117XRpnpoj7nyI01Qcu1ivfDTgwaCgt6n5AQGqK5U2i85FfOpm0FR9JfZwWo4sYtAnPe-rvQs1ztW-VlMq1OokpVPpnsBuxrfM3hIJCkve-_K0zMF6Y4LlT6Ku8xUO4efYB_oAjz_4a5PANKKdjSF5g8A", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0NDI3MDMsImp0aSI6IjQ3MmEwMTU2LWFiOGMtNDIzYS1hY2U4LTVlMWU1Y2YyY2Q0MyIsImV4cCI6MTcyMTA0NzUwMywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.GykDspuzARaUjztKETUaYJkhZS9whx-FTA2yny8sNeEuk_PgzNivf2Fo5eSyv80FkO7SeezyRov-G7V_A2T0eQ-7D-9B1wwm2EOS4J71PZaCmv5HFwRqlX_d2Kj2Pwz4ceVysqqJwL0x2L3LE-KWEwmmlgoOydnGER7U_eVtKZTfH2vD61J8NwhCHxuoJKW47QhOJe98Y_UZ5-C246FV5ceVTdSQ_enOD0VSzvtzQa5zL-6rvC2qHNqh8Pf_mFTzj9I1G7_l2365pWjGLd2SnEAJu5UcpX4Xf2hzLPDlWaSP6nyKFwSt3fmqUxhbVbm7ngXqbdXhMaxB7CmAfzjU5Q", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0NDI3MDMsImp0aSI6IjJhYjg3NTA4LTUyMTAtNDBhOC1hMDZhLTJkMzZlMDNjNzI3YSIsImV4cCI6MTcyMTA0NzUwMywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.Jp3qZ95E-3gkye9uCciqxNiQ6VuqQezu5Uc_D3HhEFqYYcLzBpIEjyhED3DeSJ8YzkPHVLSTuVjx865nJz1A3ASwIQesBKbCyti_Rug7hdNjSlFaASF72QICdGbmvmEGXmV3MPoFcBmz0cFevhF-dRoSbUAc9XgWdFKtNCaYfTCJNKI2GOAEbdvhu6JMggJzGXAxOj7p0mAneVL7_FeXMPtGjkGgSzWcRchRaGlmHK7VBYVsYJGujIZAjLf95EichptCSfmEZBdZg4b5kBQus1_IYx-3Q0iGQHRwlHP0A5nJuc6e8paWjFtxi8gA73VhyxVI4_CIdpWoV0djpXV9IQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0NDQwNzcsImp0aSI6IjZkYzY4MTA5LWI3NWUtNDRjNi1iMzMyLThmNzAzN2E0NzMyMiIsImV4cCI6MTcyMTA0ODg3NywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.a_FYU0myjQo-ODIWPhl9NgYWfDNicCVG51wGZIwyGKhaF3M5A7kI6KQIvs8B5mklHL2ByBS1EqBIeV0t6RevzPupp2s2GT0nck2UOlV5X_RZKUO4eH6owZ7pPiyh-cSyWS7vg-juyKomhqAPgGNe1IQwQ3dNvyVzoN5mz1DhrEuSnwy5xm1tp0VHacP3y9Q8_S6-HWZbBvGdL5rwiwkOEIssHuYyE4U_UxhZ8rR77py11IJDqTZBpb5bMmjAQ-2ld5F38T-kJLObM0rx3bqAMyjiwlS55IEzgc1xYSbR_5eHqidq3eIK2-EahXH6W09QaodZnGAlxHFy_pK9-pe4Gw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjA0NDQwNzcsImp0aSI6Ijk2ZmE5MGY5LTRiMGEtNDUxMC05ZTY2LTAxY2U4MDY2ZDU5NCIsImV4cCI6MTcyMTA0ODg3NywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.c0azOfIk6ye666wyLuAUoKfxr5CnLq08okJr3fjWuLSgeJJhlMDx8ov9sxTdctR35odrb4c7AGtTWkICu1Fp2EfUzHnQ07oQwPiB9WBxxluAaV-IPRdcum7e_k7hrnMbqvPG6RHZijHbKBs4WVrTVo0VSCmN4cwOl_NsuK4wja6nGN8HLU9TsBlDZCRedpOhYei9qZ87QYUdCAv41e399O2yGgBm7VsetbXzR1jxlPUhwXL2l8BC1Na5BueyqonZa_IYEiB7QZlUTy3vMCLRtm0g3WPsztXZBCDb_tRMPzZLYvc3ANlWp9PQK8bqqIJr4wHkBZRAs5G2LmqYnMkXEQ" ] }, "profile-user-verifier-1": { @@ -205,86 +54,6 @@ "UserCreateDate": "2023-09-06T09:10:29.107Z", "UserLastModifiedDate": "2023-09-06T09:10:29.107Z", "RefreshTokens": [ - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzEwMjczODE0LCJqdGkiOiI5YWVkMTBlNy1jMmI0LTQ3OGUtOTkwZi0yMzQ4Nzg5MTNmMGEiLCJleHAiOjE3MTA4Nzg2MTQsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.DzDoen1x3dvPzAA3o12L-LIOrFLm4vXz2I1Bkpca_y4YosoLMV3OiSM8RU0toVomEhNratd4TCM_48H-hSfav6PGc6SzWDqeHFY8H8tD-HevwCV6WFBHBIRw2PINXR1Pt3DssPKOZ5B6V6HsznVRkyRv5z6lvSl-9DqX_rLihzDZ5qndaRvGSE71A4qxQXhNAW7dXYCBDrc1Q5j0IY86qIbtxahi_60FOKipuC9S_hH5vbIVcCceDne6PzDuukgAVWKuGzdyTqrD9ifG9s2pGyjUi9CdXfZoMiti5G8xJ8t5TBAKkBYIQgRVRRNFS6pSGMMdsfHhxzxBqACs0kg9cg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzEwMjc0MTY2LCJqdGkiOiI2M2RiZjE5Zi1jMzYxLTRhMmUtYjAxMi00NDZjNTViOTMwODciLCJleHAiOjE3MTA4Nzg5NjYsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.KYlQxTDB5OyjAY9L3IupSpytgTsx4l5B9C4q5qns_uwu1UPHSoM-cq6btYKqtHoPgpingh9jm_NTC5khUv6v74Vqq1RPt5OldB_lr_TjJmkDRzDO0LWMJooEkqjftk-b1hMBJV6KwMImbIyam2sod5n_RtYSfFWDOek2kLVnueHRphw-zCziJ1O-JZRm5kiabzA_vaFoN6-CZ3yptpwdOnoiITg88gtVblwO3BZopYvHJVnWKV-JZWk1_i9pS5UaR_ez6p0cdhf-dvHgFbrN5cC3s9klFZ4IqSwD1u1Z5CjVibjz5A_gY_WdqHTBwSRnoPGUcpLPEDPVTpaCUJScrw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzEwMjc0MjUzLCJqdGkiOiI5MWY0NDBiYS0xNTI2LTQ4YzgtODEzZi05NDk4MmMyZjIzODciLCJleHAiOjE3MTA4NzkwNTMsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.IqjrKDeVj8HwuSg9hmQ6MV7wS_inpE7F-TWsMjG7t-UOe-xpl6ImthnI0KFGuTNo17qVmRQ9d9pRVc2wDvoTVqBuyO9MuNlH9jyTNdSISFFFICkfYgxArLC4Fve7iCViKxwCY2qUpyQ-SKPumRr6lPj1qGxc9GTg3nKqMV9tXcx-_QG0yOBlCxT9bcMrP1Mq0-LOjAYMhq9XvYiTn_rRHnTRhJMx1rD1WP-m_UOwSbNo1dyC1VTKG6YEr-x6iB1Va20Mtzds-2ckdiNW7rXf7uh8BHP4cS8JbWEnvPWztOsKknEPClPJ2ZIAZRvgZNelfNENSdGA8_bCKK9c4d2HFw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzEwNzkxODI3LCJqdGkiOiI4ZjFlMmVhYi1lY2Q5LTQwMjQtOWQyZS1kZDU1MWYzMTUyMzkiLCJleHAiOjE3MTEzOTY2MjcsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.JZ1CDQmora5p4x469WDAVHTLhVdueJ0E8omFw7wwYvTZA47Z323sqsOHGPNuToCwk8bh4y1S6vyJDh2Ez4FGxSVzVqy7s_IM120xlVC43LN-wi8LYRSruNYSvBwf9ItQY0DRktOuFqCzZOv8VNkJMfOuk9WwFjFs26_0SESXQp0mBB26cG8lHDHWCULMSWrvLWIw0LhhAuNG8BHKSQWZrT_Gi54VLLV7OCb7_qK7ZkQKnSMpmOJ4wBEzPXcbtXMFmNbWfebP6AisSlY36liRQ32R9_tLBOGgLynJ42J8f2dAFcBXHfVwF_73Xcs1zWcC9kdqMP0j3g0AOXTMYUJTsw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzEwNzkyMDU4LCJqdGkiOiIwZjVjOTFlMS1hMjViLTRjOTYtYjQ4Yy1jYTU0ZGM2NGFmNDMiLCJleHAiOjE3MTEzOTY4NTgsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.zOjlGAsP8J4vq58cHp8FFRCMmyfURhJkQw24Y_ABbO8uYqAr8ULXMyCxyTSB403AEDKuSzXyvHCN3UpiGsGczPN0ezNSB3EBtGBasVvy49WRVBWstRwb5wDIcfz-dRbb9P3Uru46TQbYwUf87zdhrbLh6LH2DgcYlgDfS_y4Qce43bK_2Oe5CdDRpmCj6_gwLAM1h2Srguin_WWYT2BAojeSldY9QI8ExEPIBzOQfiaFthhvFioRZRk_mxTgH0cwoqC0kJ3H7uy5yhnPohy5czdPnBorjn4XoTvHXnI-PI3FYG1x36Zyq8aB2YLjdTYHc40wKBLIPs6pnOqObBU_Iw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzEwNzkyMDczLCJqdGkiOiJjY2I2OTE3OC03Y2FiLTQxYzktYmVkNC0wZGM4YTJiODhiNWMiLCJleHAiOjE3MTEzOTY4NzMsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.mXmmdp9w8Gm8pib6BqnBhsQHJemlVUJBwobpSScLImPCkq34Os_iV2EU5WKSht1_xvXGjiaLFdiRNqo5r8Rs4WpVyKQZxNc0RKtjPzbf1434REnfcc0PqfK4aY3XXxoUxFNczkY-EpHNAh-fGuo-3oGvnSnyrySu-Jm6FdiVA_kabYpX3rjhlh46jvnBkHtrlgNWg_XmPBQGs7qQfQiADZzgp84J9ZI2IjO5k3PcYg1hYiJqSTfcqsokmiXl6vWEwprb8cMTnTCU3BXMe82hHenukQwiUye3HSTUKk4t8ghfBlz8AN1La4bOZcFGNkvWBRDrKjshZWqHLjcQh9lVxg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzEwODcyMjU3LCJqdGkiOiI5MDIzNDcyMC1kMTEyLTQyOTYtOTVhMS04YjgxMmQ2YTNmYTUiLCJleHAiOjE3MTE0NzcwNTcsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.xtLkAAiGfQZaGNYhjSug24UtTmz1aJcrEhXDy874l9Ad90yIY3PEowz8dPl5HHalh-lsdyEKX145_5uYwodsB3f52fe0s_gU1EZWy9DLQUPl6pRZl3UBX5PdVU1wvtg9CcrN87gk8Wlbm86kqKAZHA2hGQZOYlQLLgA4Twl_0U6bPOGEXLf6VPOK3DmPHJpGkZbzmrHaAp-AMK_YIPCZwrkVRUf6qNiFcJPTIfEFmaWkFLfc5A1QRwuUx1BY0E0ImQezvUeGTYlvbNCUrtcRI6Ugatrwu2SnFVeuj1RAecRGLVkJUcE8cKCIb1apxf_JUambMayYBCjIC54OVxDkJg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzEwODcyODA4LCJqdGkiOiJiNmM0ZDY5NC1jZGQ1LTRkZmMtYjM5MS1hODhjMTYyMzNkMzQiLCJleHAiOjE3MTE0Nzc2MDgsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.jPRPYzsCXs4vM7qVkCKWzOH81F3iS5gLXkMYfv77P2HBef1Axx0esnvTzQI6-idHX4hZyyXan9rq5y0Pmmhl4adKR5aU7zY1D7LrB3EDvdmxa8DsZcrJtiVYUROfgH6m__GoQ1oJDnjLixb5-fdQ8bD4Xx5XoJh03qUcv61wXqnHMn15SyxakTNeNHfcs0VWv1zaL4Vkmn1tXBbF5oZlKinzHxfIl1QPholSwshYcjT154z9ZMmkjtyKQWaFuzMyzUJz3AsPXL5xaUPAaABuoLmaBMwGzCmITRmpwwV3NtcIjePwYQ91gFjggVOmKfMe1rQaw-KQ1tpvJv2JHWxRTA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzEwODczMjE1LCJqdGkiOiI2NzJiNjI3YS00NTM3LTQ0ZGYtOTE3OS1kMjA0YjRkMjEwZmMiLCJleHAiOjE3MTE0NzgwMTUsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.Tn4xs1YC7XGnKde7SaGrMty82WLt9JZCRFwySKpKJo0PFdGvIjwNfqj3lwRCTpKiCR2trGfkhsh06qhw87ljeILGxeJjUOVZe0W7_IJm8zF3ZCi9WA4-5nNoPZEU3i_jjYFssHhDMkJ-MU8T7BDEnPKfq2JeQMdLEp3pj7LthT-l0n5QXwrygMcy1-1iPOIVv5ELXHsAFSy8ZcSe6W0yuoY8bGjR1bqTxTrSGfNtumyK-KloEun5o2gwfoH07z_jvJtHUJ8PZO1ohchAHmzu-cPtkEb_DBVO8O4o_fllowHQcKCVabde7jCCpnC9J0KHn2J-iAI2V0iGWU3uCmoi7g", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzEwODc0MjgzLCJqdGkiOiJlY2EzNTk4OC1iZTQzLTQwNzEtYTQ0OC0wMDA2M2EzMjdmZjciLCJleHAiOjE3MTE0NzkwODMsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.nRnN4V-s9LKLnos7KCDjxQElC7C2zpPvOXgsMxe5FtgmhGKqMBMw-wUWtDzYFQudsFbGJs9MhkfXBalotQQYJElMybrpcgK6N5sMIxZjXmcsauWf5Qnabye2HfjnLKt2Xq_hoM8iKmcdfmIdMQDEjTLxgxpzjkwceKK9qAnGVkBAICacsRyzTqScjpEELEVBOtwbT4lMe_og30KA8nY3kSdCrQpWj3l5djb1P5tin-bxn7axsy7xR57S452YidgIeDpWY8knfMKpMOwcvWFoopznl2ylof3hvdZ_ogS8AbHNxGZL1RAPL65pne0RZvUmgu_HWnn__-rO7DnbVPBZ5Q", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzEwODc0NTY0LCJqdGkiOiI5Yzg3NDg4Ny0zOThmLTQ1ODQtYTU3NS0xMjE3YWM2NzVkM2QiLCJleHAiOjE3MTE0NzkzNjQsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.SgJ0Mb_tvLTKqmJj3qlFuZxNK4bFHINoJX4lbXLnxlrv6b2H1R4FgI4dRumFlJe7z_17qcjejMkqMglqTr_Un2u4yTHt2-b_amivI8r34sGIF3KSrl1cqEmSxHxA_H8egWxqcwXLyc4bmPpRRm8hogq4N56VksbYG27Cb6e9wCWJLa8ogrMmpsjp6dkikedMYZsuzzRcO6LOA0uD3LMmUaLmSglRKE8eQedvsDnbD6ewM6oMSrYznZxW2QBavxRMMEM5jwB9C04PxEGi97e1b22FDLnm1ysVV9wN_PKpz9UESF_HZHuTjOfwR_8R05x8BYa_jbMBe9G0S8PwpRTGYA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODc4NTkxLCJqdGkiOiIwNGU5NjRhZC0xODkwLTRiZTAtODM5Ny02ZDZiNzM4MWY3ZjIiLCJleHAiOjE3MTk0ODMzOTEsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.ihlHEJRvBiSsZso3pnPPNUG3h0zlXylec3N2pxWy47huFgt0IQRC_zxIQjfs-z-zG6OW7cl12IEtMpYNRqqba8Puo4YRS9rLzoS8NdHNoykgiv8wemA-t64HcoDvbbJcxS4zvHS1igyw2qa81JmqcAuWEvBZIxm2rSyk13rneWMmHQOefHRxSGbBFzFfcI2_c37H6ZAwRkB7EJM7tVDRm4tl2h-m7Enl9dIIa6KNIa5-DVAugdztaNIDvggQcXxjPvvzgfl9F4IxTA41SG2cAAgpXiK5N0kriezi-0G0bxKC7VczoWIIdyA-VP2cUh02v_oSuHAd9Ib-SvXNz2v_pg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODc4NjEzLCJqdGkiOiI4MThhNzk1ZC00YTA1LTQ4NjEtYTc1OC02OTFlMDQxZmU0MmQiLCJleHAiOjE3MTk0ODM0MTMsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.XmtiyPXhvZ4_10h4KIi0Eq3w1g85gW6NrYkC0ha0HHijRP2aTx5zY80KMI6JpwVaup8yr9faADegmgfjrSkoU0ub8o9VrZlpijEerEETpmy7u1BrGmlgMIoTXOGWKhW4ziD6uIvne7xct7dOVULulLdSxGhyLrhi0AKcoidH8q7V43mXmJBFTIxTvVIxGO-AwWmOn5ahU0UL2pWbrloyarv1floZRS-LWjE31UDN5OuFqX29AnyyJUtmI8aE3BpMCEjPa5NXIQa0OEM8Br7mRwVXektIdZcK-G9ssDvHupU3eECRYhNixZvT301qQJuk8BnotOuy7zwgknaSrszcRQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODc4NjQ1LCJqdGkiOiIzYjNkZjk2Ny02YmU2LTQ3NjEtOGNjZC04NTllZGVlM2E2NDMiLCJleHAiOjE3MTk0ODM0NDUsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.R3n6ECC15Bp8C0FQYRucyBjy_ZY-uxq9jjfsGdt_BWQ9FfOnj_7czW0WJffij_AWx4070qygH5wE-YvHt8ZIwa0PBkrSoqi9Xt5yLdLT2i6psKwDk2LButXCmDcA6Yb5bVroVBDVXOeBQMB-at3zzREeEDD4ue2grfWtbZxsatVyPoW3mc6NSjOlVxfAo6Duaq8lhFsjmcJ9YhhmL8xhfBmf-HwXG3UCtluRRXVMqeaZ3gnBHJll1gSRrDaHnFPSPt9n4ugWmmVnqb7wMubAeZB1DGxHgVkWM-8oMWq6zyTo0r9Ta-aP9vVQQEf9l6ZOZDEIB9w3BSa9vXsAKXy26g", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODc4ODY1LCJqdGkiOiI4ODMzMzQzYS04OWJhLTQxZmEtYTI2Yi1jNjgyMzIyZDQzNzkiLCJleHAiOjE3MTk0ODM2NjUsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.mYf_K7895Kp0mGiDfqmeY4W0nUuodKwfgD8UMCF4qNuQAeXWHNJYD7tAr0VaRdHaE_BySwoGfTX37IPzBvXSmJeuucFC68E-cSbE1VliwXQu0TUy52SxwvfoMqdXCJjKhBm6_aNGymstEo9ejhxl7utqrB89y4igFkKnfg9rJa9l68WsKYRfAdsFYrWll-yTEuGqDN-btLEaFo0Yjy_ydAXi70tbuhdWctC9yiGn63e_9FRGZGKdAwOcKAVdRmZ6HiemTn6by6WBSsfgtdy4UArDGzJfg9k_USYZNdMK6D-9iY7wzTdLqknsPyCA9kDCO7Uotxj9BHxnfjSFF6tsSw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODc4ODkyLCJqdGkiOiJjYWNiNzU5Yi0zMzFkLTRlYWItYmFiYi1lNzE5Yzg4MDQzYzQiLCJleHAiOjE3MTk0ODM2OTIsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.pYriy8q1uiswvIr-oRjmeDjiAZc8Vj3dr4_bec8i_OwL7I0lS4Ud3od4GzDBeui90-21PN5CcW7ro-aMhwjtiJfvq9MeWO80A53RBF116LMkw6Ny542v6WeM3LNhV7GrwabcfAqooxO2yVqgot6E_hgb70TQoFf9Qs3-VRUimC5Ov7yeKdSAf6bcW8aem3xZhC9WLVfdViXGDJD7AQBnmw-pZEn5K0Ix-Mn-gNQo8e-LZ0-ul27JWZI8TxOCxeNcey5XjPO-nD538YJtbpfpGhgmZ9I4y2qGWtukdtQ-pmfYkZla5G4Q7MLYf0r93BSmQzketqy20-wK_hAz6c7ORw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODc5MTI4LCJqdGkiOiJjZWU4MTc4MS02ZmM3LTQ1MjQtYTcwOC0zMTVmMmYxZjQ0MmYiLCJleHAiOjE3MTk0ODM5MjgsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.QOhpZaqnZD6qGtv966iPliA-VWD_BXyIoi03joUxTdDwExyMiBQkKDdgPF6euS0Lh1pmsXf9SC6SoB0uGJJSpBHxsm1XR6RTboM-QAtcDYr713M9fm4svkgtF2hk1MnpOmc5wOLUvXDcsZNjwL1OH7UuPOVbz8GTELxViOmCmg4h6KmD9esV1Jwx1u2XOA67OYvgNlnhnJdL4v7jaxUD4cDUKMVcOtFe9IoGHHrJWGF-hyUU3eINybF04vZSPZtC38r5AfKuGPH-c2WnzvaEpRgMi9aknWQlMwdGK4IfQQknaZ2VdZHvg_7s6Fj_Q1mjUElmBvm4QMbAPg7gY_918A", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODc5MzE0LCJqdGkiOiIzM2RjMWQzZC01ZDJjLTRlODgtOTBiNy1kZjc5OTg4MTdiNmUiLCJleHAiOjE3MTk0ODQxMTQsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.tulMMG1_S1g8csICkL5bYqJiY1BfR41n3wS1L6gTJ1Bz2uEEoszZelw1FJ3QPcrY2BMo5vw--sy1gCI9CyV9xqxh7B_hdlNYg-5UhYtM_-BTqrMeJ3l9ekzyfHalt3M0gVC5wXfAK0-v1apDufp2wL1IcjVpjFxWhCRg-Ugt6_gaY8_Vc-1keqxxxULa_7YOioLcxhhNYHu-cgLXARC5uxuEQHgwbpUvRDLRD7YyxaQYiwCi7v73Hv_hww5BE5drwzFxOE5d-4KMdydq0lsyEe0OcJnpkWJxb2X1AqRuoG05QrM2L0Tei3lvvAscNZFvOYYFRauXARzv4325MtCkUA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODc5MzMxLCJqdGkiOiJmZjY2ZTEwOS1iODI4LTQ2MWEtYWJmYS00MDdmNjU2MTc2Y2QiLCJleHAiOjE3MTk0ODQxMzEsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.AYqYWuElWzpLDoTZRrf-Il27lwMMwOoH-YPDgS7TebioCaxhkBDPsRPlTN5qkXv4C5u8sllZ45xnZ6WOLiGBWZ0I1p65V8c0kQErJNRD-2ypSzPs--qsu67WRJWYgc0ZC6rW7X6YPiJTTwl-mtvRYkClUWx7LhSuoO1bbfbB5bwW64TQ91ybsnztyGbFqAGGpZ23RS52Ass3vYkRNKOSqj12bhizKN_JiKvWmOXmepeKE_15Zq4AcwC2psr5OGg2e-MkKjFyRk0OQpnMYzetRR2RREM4Epc4ibSqenw9GwMFD6YHCbhZiLO0B3cBA8eAFrN-BnpGk4Aq09ZG0miEYw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODc5NDE3LCJqdGkiOiJjZThkYTA3MC01ZGIyLTQ3NjYtOTFiNS05MzkxNmQ3NmQ4MzEiLCJleHAiOjE3MTk0ODQyMTcsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.ivgkaG6dhqvd-5b40GwPSDZkqHGOJ8bkyP2zLgiiaWxcrUgzSNVfp0NCw7aaaxR8SuRu4e2bfgbU4qNFttKX8Q04PR01D-OYDAIPRLGtXlGEVCMDsv0Lo2BSEWkhBSS2smN6lxIReToXNaGTGVi3O5Ba20jWrqeBqIWksqtuxUHhkhxRMSfgLBG9W9hySjfI3vKf3SppbVJR-_nww42OPV4v8ptTU0xyULahi7k6Ns0AVD28Mmyss4hE4UcmcA_8XaT5HjLSwRZxsz1s-IQiZ0CVQfNAfSfts7NYzVCaSWRlOEpxQOAPTboLyHziG2UIdByHoa6Z6z1bBCudNAfVig", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODgwOTY2LCJqdGkiOiIyNmI4NDNlZi02YzcxLTRlZDktODNiYS04NGJmNjVjMDljZTgiLCJleHAiOjE3MTk0ODU3NjYsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.S0QbcAt72yrP1pOcV3ycrfME2g3XRf9scrOQ13ihBliHgv8QbXnFlgzH3axFUDCaw4nykpHWyaF6NysH_n8luKj1NyexqiR9K2VmjJOqqJw4o_43IJsnm9fIQrDxi2EqsSUxoIJxlmSD062h8EGxz-4s0kbloI6Z2aKQiTSXX_JOnUOawe9sAXZfZMCkaRicvVRty3a1yXvIfp9YDzHxLCtY2kdXhe_tpLo7mw70Tggi9yAThvDILYOBSs-c8GFaRB1rnJD68mjcArgFqgRZQ7iFhPcls9SWDW5oTs4DGPif6bVhbWEXJZFHfotQpGurClJBj4nRIPN6FhVRXw9nIQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODgxMTEyLCJqdGkiOiJhOGE1ZTU0My0wZTI4LTQwMTYtYWQ5Ny03MjIzZTQ4MjRhODMiLCJleHAiOjE3MTk0ODU5MTIsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.FyrF0SCnJIo7F8Gyii9Lvhf3NU6RZgKtJNn6BHfb52SL35aPaQTcrgi06wXTru7yIfUclMGHkDYVJz-YDZ1jXqo2Njy1NgcruMVssS_pJANnuKU8tlnDYjTa9yjJfa3f3WKOSDnIZZn27wkYtaBh_S_50k5ypUpLqt7E03LQb9-6V16DgtTFhif_x6OseDxigxT-Zbtb53OzzZbpw-SH5m_uBMMtS-LGh9bc5RA7RTev_SoOxnSwa7zx2ZnRV49JEz6XMXWlYFliQO2NxdVWMTEfKJuchJwboRoLDcc72LY3VCxy3l3omsZlDtjzjlnlPApmlHR3gAiZkEhUi1V6dg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODgxNDM3LCJqdGkiOiIxOGUwYjZhMS1hZGRiLTQ0M2ItYTRlOC04YTIwYzI4N2U0ZTciLCJleHAiOjE3MTk0ODYyMzcsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.iJc5G-JKiy-9g_o3Q7ao6dMNMnD1rcyU-t282Dhe1dIUYtURux2hS3Z3FsK2Z2Y6dhhh-upoRjkZkHAmGdFWo8gHAzedaskXOv1rpk-tltDmYpo-2PSuU-95mCHZn0d_QMicDXSmqUBYU2Yd5Fm_ixGwY3KjnGrasxyfxw0joWARP8D_b7Jfur-V641D-c4w0k7HdP3qjO-dtGuvVeuLaAbr5F3_XSuyVSz9jXItIAQCyweUwC0UBATKQJCBCcUvWS1Wz0uveqoBiNbjM04ejNK-F8dwOOiswsdt-yVMVfHbBolrANEiO6813LYE_ufzucEfOXMwaYQC6rVWcbebBw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODgxNjk3LCJqdGkiOiIxMzQxMWJhNi1jZWZmLTRlNzAtODlmNi02NzA2MTg2MGUzOTIiLCJleHAiOjE3MTk0ODY0OTcsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.VKolruyq1UsqdR1vjvWTS4Kzj1LxM5FUDjD95-2-U1cpmEQM0Gcuz5bwWN-JQVaY5Xai7u3qPuYJQeWQJpOoOCNRRlGFyN9nn6DeTet2P_vd3jAJ3CF1HJi4enoAQFcIUWInEsIsM7pl_YPeL-ETMsfEN86uBt_E7NSV50d_8rhEXpK7hhvhj-RXabswgDaT2_yEWNXEO4G16sUksA3cGX-7TSW_nh_tnuDidNhLhudfQvLohgwwM4qn9ofmbOczalgXoybzZKQJJKHoNcPpdQtn1ziN4kgWIu49lSYIPE8Njwuu-Evo6Sn8k_yydZFXqVrsJhVEdk2y-yGup0CqSQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODgxODgyLCJqdGkiOiIyMTc0ZjUwMS00NzMwLTQwMDYtYWM3Ny02ZTIyNTE0MzZhMWYiLCJleHAiOjE3MTk0ODY2ODIsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.kalYKQLVtF1s1aZ6t-ZYMNqiH03VN1_HMRSOYJRbC9G55hUJRaHYdHZvPXO2uLq-Coiug0Gm1JkjExQ72vvQWXV4ogevP8VaJb3sqDia_CtTu2kCREy6EE1mQ6r9OwPl59wAYWHAR_Nba3vytwzpqhgyHcuXZFZbzC13E8Xx6JxtDnMPlUmubUgy6pR12s0qQTLzKbjdOdlf9oEdTRKRY4c29yKRF0UjIFCu1yP7c-odOc03O62jKNBTFwTU-IALlyB_bI9rPz5k1YOatQNCHVgDcH2I7ddpGlNoNazlaNl6cZ_E_V8f2OBGopNRM9_eyKzfbAczCmX8TjcNSsqrow", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODgxOTk0LCJqdGkiOiI3YTM3ZDUyMy0yNWU3LTRkNjAtOWY3ZS1jYjQzNjk3NmMxOTkiLCJleHAiOjE3MTk0ODY3OTQsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.UyjRUIej227L390Iw9xSTdeGiDMGlV-4q9KjDKpZSTzQeRKyrnsPGARbtKSedHTA-VrciP41FM1jUdoH361QnLsxg44CBitqPUHNXE-ARpFFMzphBj0ifaa_uRRUGeVn9Di23r5P75Cz4iP6AAi9k2ubj0hpVFqUYP86LqJjgPCA8B3xV_oCiVTH2xlJkwMqYWRZyHjxYuu-tbj1FTeF2mhASb14yq9pDcGPJSsFKENie8kfJUITQjIKCa5UkAEzWGLjEBsagqqtYC9fxqkK4odOOjC3Jonn_qYeGtz97zEOjGHiAV-EtSVC5uKqZ3-2UaxgC6HQBgx7Vw0qAvgHvQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODgyMDczLCJqdGkiOiJkYTUwNDFkOS03NzIyLTQwZjQtODI2Yy1kYzUwNDQzYmJhNjgiLCJleHAiOjE3MTk0ODY4NzMsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.q6J1Qt8Lpxz7DC9eGQ5R82p6cLKwd_KWBsbLPQohSUqa7l1QURkNcNxroPdqb5OI5GZ9CLDZDLWHoZe8WsVSeKIMrTqHkauk2wCb_JyM1pTIovM_ngo5Bc0THFN8iUjSGZpQVX5LHWfM-TFQSlPke8SFCPJnNi_XNpn7IMXdgV2DU1BS7YiyQqRghd6UKX0sPTRWDJ2VwVihSH07umUJ0_wiMPK8nBNrVbUzwMIJueHO14QD71IRxOlRSDVQ4z9LUaiRMxFK6SZtStjzi3lUSvxPJV21liNMKLyeskqkcBOOjklWmog5V8jsXqG09idg6jar_6nEGZ_kFoU6d5oRhg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODgyMTYyLCJqdGkiOiI1MmFhNjM3Ny1jYjUyLTRmNTYtYWY4NC0zMDk3MjNhYWFlN2YiLCJleHAiOjE3MTk0ODY5NjIsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.fmWNb_p5_h6SsZT1oxxrADmXIDo5pUOJEriY5-pCjjIi4dusVm9POSKvTePympXIoLN-HYxXwSI2OKd7XUbyKw5VTPoL9ALQ8Mgr1OL0EYYcUhArJwhm7X74LKKUOx5ozYKggoGXJpUJxbivdaIR0Q95Nsi8jN2QIEcz_Nx8swhIrCKijusmmVg8tarZ_rM50Eatj-4cb6g8PC--3enDhF6Fiiy7u738KW0HwQ_GVzLJYL3Srdc2UHBww2UFOnHHSB1mvEo6ZL5AAy_40uah41wg7dG26JilJJC0cRanZ2iaOHbP-QaTJywMx_QyWD5k-MM6Z6pFN4ew7lyXFbWgig", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODgyMTY5LCJqdGkiOiJlYmI5MjY1Yy1hMGFhLTRjMDQtOWMxNS0wZTYxZGVhNDFkYjciLCJleHAiOjE3MTk0ODY5NjksImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.mbUQikfYxmkIsQG8YNCqi0FrIhGBjrZtpaeDKrDkQ4tmZgQxeZV_ZKjKy9Hn7gwxtZkjCwLfzPG8DsSb3_lGDSc8hRAtMv2yOOEvlmqbIRoKt0K7pKnTV59PRiPtcusjaa1JvzyCeIjNdsOw8KtvR54WtNtF0fwOMa43ijy3aGK53c__WQsVjCSGOvSPfK-FZsKHmWuXStDxdKvbqyGytipiNZj2wwjyw_LuGekokDRZJIe3X9V0aKbnlFPnRv759uCms4XZUpuCb2nNekNAguYRnO1vwKRzlauK7mNxLtbHWxelq9xgoREMWCUxGnh9ZloPR60nI1hs_bJaowx2yA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODgyMjQyLCJqdGkiOiJkOGM0MWRiYy1mZDYyLTQyZDYtOTM5Mi0yZDc1ZDA3ZjE0YzAiLCJleHAiOjE3MTk0ODcwNDIsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.lzfXUM3Up54E97TpdmXwBevMwBLJz6u6GgtJ406Heek068sXhmW6gphV9fGFeAkIdZM22-wiS0YZqU3X51B-wzvP1W04uDE3W0ghKmanuQqDhNXpGEVf4f9tGR0V-H2uLBPzc-r7cOygaXK5rSRb2fLH_fKbZl-HRCsn9ANaUEA8EmaWAkSISNy2DIxT0HCmJDGl5dnx6O_TMZlk_Byu3yvaKZitL09-CK1RDsDMpzqlb6-uZxatjSyoISZ8djRdND9X4viYXFvoTlhmrT9Vs3BgfWC9NyW33GNjchpQCAPg3h5B_lUOj4IPucpxegRT1fqDpWDCOtpCW3pr25UGpw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODgyMjc3LCJqdGkiOiJhNmNiZTQ3Ni1hZDllLTQwMDAtYmI3Zi0zOWEzMTkyYjY2ZjciLCJleHAiOjE3MTk0ODcwNzcsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.MzFzySe4jZnOLsEFK-VCRvmZw1Kvpvrgz8ustkm3N3WLvg1jyTmUMpClWS-lnqfwhlYCEgtOIftnN6giO6m_p-iGW1rui_1SE2viAnn20NpB3N6UV8yRSs_gBmSl4A_Y6r1O3sqwSC7HnEjE9lLEigKDMHPhr6T731wcAMuFvH4UOcLepY4gW05NZ4UoaperP_s6BdMVyPo9zqFgAcGIpgbDPmIKDd9oER3vPpUXJZcGLIPo_zGQDwCpjtGhflaM49nFS0eTjdnnIJpcwkWmr3rOn5AU3JEkHR0-WEoYso5IKQE7nINZ5oIRKR-6IgY8bZrK2b8zaHjAsL8po1lHww", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODgyMzAyLCJqdGkiOiI5YmQzMzUyZC01YzA1LTQ4OWQtOTBmMS00ZTgxMzFhMTI4YWQiLCJleHAiOjE3MTk0ODcxMDIsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.VJjz9OuD-YBZiyduXGRlCUCsZ0zeXXEfTEv_G9XflMIN4JK8hHy8A-U1TaagdZ0Pafd9Zf6B9O815JF73rakRPnOqBD-R6bho49GzyD6nUNpQYr7Ys4_1Hhv0s36f1jkvY2sDCcLP-0tQYUtLoz_EnFmhH4Tb5arA8vxEhSa4594ftDsrIxlLBaZ9_LSOIMNWkHxVD1AyVc1C8buw1FKlUvx_cnK9OxhmLfC1Ao1_3_xZZgYSi9nHaVE7a-MdwLTm0hKEBSPMu4y7DyOOuBVu9gA4Z8tpdq4o0eUgDgHsspMyZDv-lMpdcxPp443XlSLMmGfESYEy9eN_OsaqMa2Ew", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODgyMzU2LCJqdGkiOiI5YmQ5YjZiMC1jNWJjLTRiN2YtOGRiZC1kNDBiMDRkY2NiMjQiLCJleHAiOjE3MTk0ODcxNTYsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.Z6AmyAkTy_EwcFydHJBVnBeuJ_CJPSf-G-Gum7Ndu7rBmvEVhn2ajU0CFrJbMT12C8KHl_YqKLW9I5naHc5SSJlf7EGDduTEwmhgszTWz23jStF83y-ODNm6o9DTxcvPmj2BnXPht4EO5NBJrooOy0tn5NzwrhS7QYRtdZyFC201ZCktVBEhj7MpCpKt7dgiaEHoA5PFvO2EfJI_ED3vW9rIQcFaP8JLL1dbKOwJCdmyYA71M0NxXgEPyVb0acMW8h5jJYbkkXKBHRuJ6eQqdK4Ju7KvQFhY9D1QiinZr9a5_1-tarVWVuhh_nBENg7-paZ2cJ5JEHJ3OeL84aE4kg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODgyNDE3LCJqdGkiOiIwMzU3NmIwMy1kNGE5LTRlZjQtOThmMC1lZTk2YzU1MmEwMzciLCJleHAiOjE3MTk0ODcyMTcsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.0jzdsz72z3AT9FbjHTrsHMFlZAVP7r3MfL_N0RVZ8A6Ft-9mV50-Ue2RA-FWN65gEAmsn4j0lCG5ENGr9PqjLxFr-0IDfxFsOa0L7Hs2ZDXRGBOztVVAgCq3mW84js-Ffca5RyaroRkREfN_TWAb6jBGdoiHcVVaUY1YvUqTVGsxrCLTGo5sXELSz0ikX9NcVeeP2EKLFiAkrsDT_yZaEybwwBJnUITfso-CUxwFeuAri5zPe8xVVcxPDVEu6rrWvSO2wzRdKnyH89JXUSuzLLqIN-XqF6QczVI12WGiZR-SipOGbEfaI1qLCEkFB4QJ2JuFD3M_xaUdjAPL8f6ZGg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODgyNTAzLCJqdGkiOiJkZWFhZDYwYi00MGYzLTRmZDQtYTdjNy1kN2EwMjViZTBkNjYiLCJleHAiOjE3MTk0ODczMDMsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.burzcpJtkwI2f2INC7H3Cqgn9TJkYbSaTvSI-yEqR60ra-TKNRjGbuIrh6q34Am7AaMVzjLhmLsDTP_qhYA6l682yFc71mhnaVuyOR0fb0gJLnr38FMrPALq39N_Vz3htodDWJkvwnpqJS9SlTASWi6xy6k3hI7hucte9QsagGXVIG9jNrDvCum0wJwpK27Ln7akNFAmDfu6tAHA7yB8j1u5zUjBDUN0vQfS2RJzaa4_BtsVsy7_dvtu8VQQlGwxvcqRq9lJ6h_NIDtaH9HzQCcvPjVYVRTc-xGBC4WvUCOJuPw-SSxWZsqfjS6PykhVprpiQ5DndB9UI1AWA1-blA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODgyOTM0LCJqdGkiOiI5YWViMTk4NC1mMDFhLTRkNmYtYjQwZC0xZGU5MDY0NmQ0MjUiLCJleHAiOjE3MTk0ODc3MzQsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.WXlujBGN36G2YILAJQZkZUfZO2CVDwngNJnL2AYckTcFkU2CJCSvHKoRwVL74v9XnujCSBqdLbjCP42uzEPIc0iEhRZ0weIZ5ZBds3rhcpV0yDE_0QZVgdc0Yt20wKgWA_DOmcVZnSn4EYYdo8xHw5rdp3wM9mZunwP3SPxMUh8IbZW5LMfYb3FfHeRd1jpcw-ErmRYu0OagAz56_SqYc14TLaLK7XD0WmKL1HvIut7Z8aVU9vxmVQRj2Nu6bwVzryZRvwIBMDinInT1QAiLYqLKp1i8URdeUNZvQSNEFhue3VKS55x--_zEOFF0SzHlofbpHAqiDu3Nn_kH8uz_tw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODgzMjI5LCJqdGkiOiJmZjdlODVmZS00ZjVlLTQ2YTMtOWU3MS02N2M0Y2ZhZmY0ZTIiLCJleHAiOjE3MTk0ODgwMjksImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.e42oHE-ehK5jijv5K7tcAFCH667DcEWLs5RDbHrhZ39YhampehlKYBabXC9cXju6lw1bC2mBUL80rm_4bxLciPPuemUclKJtUJpdXoJF-kO_spY5ryM0ZVg3sC6vFax8XQ4V6132RhXCBNnReGGfHwInJoeB66nO8zGZEN9t3fvBaSuaReA1IblMLN6gXFguJmc353UNmKY9_HKnOzjaJYkXTFFatrqYhSpFbb-1yt8rsoNfhTzOg23grhiLUpaCY3U5bzE5iuMkw90rMvDtSpSqI3Y0LdkK5Ehg0fMQRl_T1Jw5bHufTTQKA6pBUdSU0dnVWsh0dV29j8Wwzofy0Q", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODgzMjk4LCJqdGkiOiIyZjRlZDRlNi1jOTBiLTQ5YWYtOTQ0Ny0wMzgxYmExZTFiYmYiLCJleHAiOjE3MTk0ODgwOTgsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.LMfH2GSS5rqf2FUIqXdM0bfSUwmz5_KC2uatRDYjg3-O__hseU_VRjD5IidTyMzD3t5AgWojOCti5DvywNNrN7CLylZ5vLSu8O2e9dAiZtKvoMuEPwnZNUvMsabV0afRryVfgXoXu26D9fdpwAGSZUksP1b8Z0A47fnvGM-xHIpAdsKRilUVyXaKCm2Kt4d7giRIDCkveoGETSbhg5ZRZ6P-d2Khcl2oyPUyAlYIZxePAaATLLjCIGvSohCZmm9jF3aKMW0_OTHNdY4dQKsSDHpb4L_EiUzHghboq26XpcRnBfeYCohC6nH88IrwCKRiTOah_CFNJ14qTGG4pCEf9A", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODgzMzE5LCJqdGkiOiI2OTYwM2Y4NS1jYjA4LTQ3ZDgtYjQ0YS05MDQ0M2YzOTgxMmEiLCJleHAiOjE3MTk0ODgxMTksImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.N44NOI79NV9hK3uCAC00UW1yMJlsSaMW9dHWM_QXUCD_2z-jbnw4bTfTDqVf_2kW1pAXFWZHpVrNZWopbRx43tvMB4K5hn3mdyftQdo_xEviGzlqE55xVLpNYgO6G9SxM84piEbqKb8rDs-nACEW-DKpYhIP4ZsH2R2oPeYbG4Cc62SgrQbmlOLxkZgyHqIP2xRnujSdfn3-PG9wuIhvB4n5YiaPoDs3KcidSlQIhu3z9bH8awzsWDCJf_TJL9oogP2YzlAJRZocKyuk5i5UfYnQ2mtAfN_nRUhezSStqTOcpGMfRSfFUa0IhRV2coXDBykU7jALKxiVdWDShexHZA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODgzMzM3LCJqdGkiOiI4MDhlZmY1MC1mZGE4LTQ5ZDMtYjE2OC1lOGNkMDFkNWYyMTEiLCJleHAiOjE3MTk0ODgxMzcsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.WFONPol2yVyvQd29F1TMu-Y1m7NdQj_2Mi_0FBPi6P4XhlOo64If0kelbFq1OaoHPrdBhmMEVcSor_7jcIwFpNIYPMMJx4OzReiT6f9e5_3RKnnMkevvN7694K25_3WhWDAIYAVXJPwjlQsgDZqO_Wj4olbbp2INCn_4hWtsmIuMo6ae-DtLesrMW3KXleUfM7aHofex7Muv7yJUZKRMxyUpk_dLafLFFQMPI0uB8PCehep4NUQnp-yWFEDi4Lo_nNv92Bucj5pGD7ilbGKTWgdN8G1nVoloFTSKdBjmczUbCDJAvMGSLYxxBHCrlux8FBNHzjZ93dDSKLhpWMWWyw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODgzMzY0LCJqdGkiOiJhYzgyOWQzZC0wYTc0LTRlYWQtYWQxMS02M2UyNWEwZDMxMTMiLCJleHAiOjE3MTk0ODgxNjQsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.a3__UdbxeYIIuv8-TRqIJ1M8kw7NaJxldO5DeHf-zZPmkB_nWRboIChWOZJopwxemy0yvCHsF-y-TF2AQW_YuUQuXCDvD04QPMnsnXdQX6NiBhAd9FK6KypOTIARq5iYEsK_2diHL1TyKfiapXGDtV8WI-Uff7QAKKCaq08dkqYwuGs28LZlalhhBaXbByQVZIEJ2w3WJWEvcaddu3VF23qB-htGJzk0DJj_4r43Yj_-kzF1YvYzxXWQ_ak0HvDxSyZIxIEwRy-tzOVScfMqXe-rXnITHO8bX2fFFJKz10TyIXD-QGEczvpGc4CuaciuTjQeKjrIg9k0NIjQ913pzQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODgzNTgwLCJqdGkiOiJkNjdmY2NjOC1mYzA3LTQ2NDAtOGQ3ZC1mYmFjYmNiNjAxMTEiLCJleHAiOjE3MTk0ODgzODAsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.SdMCchkRrsgRNYvc2EP306bFcjN5PeXNHBe9cEHJkH9E6SPMSM9rw_WYeAxCmteGgVSdsabdZ-1rn9HJ8C69rM_-IvUy1oXkEm8L1UmDm6voY7j2buIc9YkcWzKoAeVMnazyKloo0JzxjZZhkNNC0D6uJZVjn3dP82F5tQfiY8TX4GQq7ozvTks1qo2uUXu9OHHHZpp2RD_MVAr3TQ7rDpVlFBSUHRXJp8a3NNxK5Us0NrExNtcUlLwHZyWMfFY5hrEAnFTjxmTWnqVw6aDD0B9ZUZjTJ5cg-sady54zgZQD42JFlBhatxqgyU8ajc5qmMvpW2mb0cixvZGYoAdLpw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODgzODM1LCJqdGkiOiJjOTVhMDFjYi1lMjk3LTRlNTItYTY5My0zZTZmNjhlOTg4MjgiLCJleHAiOjE3MTk0ODg2MzUsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.PdhN23_g1a5iG3wYZPvEulY1mVFahz9OkmTUBUOD1_AK8USFManB0tj-OUeRIslAcVn96RgQDCLixw2sekdi3S8I3FzQ51YM1UsR16urnlI4NloeLkDfBO8gdOcIfZHZsz_5n08vyUmbmpyi0qq03h2lDIvEKyQ9mrIHnQ2zXLhDFDH787p4WUZFoZ5pUanmPJexq2a5paOR2mfUSRsvj2Rj3LeHXU7uyAXKYzmjFn-kMYg9FzyWIyy9mCAwauda0S4-Ew1w5jT6iWzKSGDiOK2S8rAIEuOg0fWsgWMkL4FiWUdGb39bXNmGTg2o7kT6JWyC4o2oLaT2X_NyCfPT2Q", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODg0MTMyLCJqdGkiOiJjMzE0OGUyNC05ZjQ0LTQwODktODhkYS1hNzYwMzlkNGZkNzgiLCJleHAiOjE3MTk0ODg5MzIsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.h75YttvxhBhL8Lovg8OVZ87dffOfrFoyEDgmwiz6BXBVXj8dnet1tG676DTGunyyX5uv1vZ3TVz9JDdzC4dTihWfP4060TPvGD2_ffHsBCX2OWgLNnUuBUMKbsLlumCHsOLcbhayP5nVxDrnplYp4uhfJupjToANuuQagZaOammPdomgz9a0L69aSnAoCZV7EQRmHorNEnbH0vlkJPj0Sn2PRAINoXYRNcL-ARSU0_fprLIC4nxhUOgSYrPNv2aOHFAM6w_YCMUW0XMYP40Hw7WIQJUdYENWY5MtOGx8CS9mDQYlZolJy4NNkW7P8busTMRWRxzxTZOq3Z4pAJohvQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE4ODg0MTk4LCJqdGkiOiJiYzYwMTE0YS0yNGFjLTQwODMtYTQ2Ny0yOGVmYzRkOTUzOTQiLCJleHAiOjE3MTk0ODg5OTgsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.tAUeI-Q6jeN3VznlnoIyZEEut31BPyBFQn3IoO74WoztL9vL6VfdN_Oro_bE87dnOzK8Rzd1dfjKTEGNNCkDgIuuLQxlExjzemB0DaimPGZwCv0K8gYsYCUWUQc2wM_YdtLLMo8DgVwbSYqKPkhK1nWl_TuHepKCJU0yOyM8yrgH4_nehut1XaNk6oH4EjLh1m7R3pYLuxDUzGaZ0JPSuzWFf4IX0oGQ_1bnUc-pWX4va9AR5-oQD3MjaXE9GyEeNXsmfMsjSv2qzF4Na2k_tZZ3bEN2kK3HzTiWHeO83IE-QT1KFzI4PD4XD5XjNNbfRfhWgR54hqsoJHfdZ60gmA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE5MzE0OTAwLCJqdGkiOiIxMTRhOWM5OS0wZDM1LTRmMWYtOWRlOS1lMjY3ZDI0NjgzY2IiLCJleHAiOjE3MTk5MTk3MDAsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.rAX72QMwAEUeH_UUVuGTk7TzsrNNDwEad7vil3G9frzk5v9BRjYGUf84w-0aDGt6WPguT7eGJGuLgL4D79p-bTkUZFBu3JUIvgcomcayYcslsk5sMrDwy-H1Tabw3eVDkVquawtAtAX-G_aczX-WScnA-gxSQd-5eGMtOLfJd9SgDMfnfFcJsiOTbxY-InDJp_UFiE9bCPbgdP9hl0p-x2HArQI6uFq6pijSCSQnkZE9wcOHMTSZwnI9AHmDjcsXWmeMJJCwbiLS7NKTFqiHgjSJSjqPX0Jv1k0r5cBFrexLY25rzIVqJ-IoM3nTYMxPZeWmjgogaFYAnhu095r6jA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE5MzE1MjM5LCJqdGkiOiI2NDVlZjYzYi0xZDRlLTRjNWUtOWE3MC1lNzMyNjA4YjM1ZDIiLCJleHAiOjE3MTk5MjAwMzksImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.Sp_qZuEbkWJ9bEgYM2HH1t3QiLlliKP7KmYguFgrkXWerITM_ZukSS2UZNetAMlL2OPEftBGegj9SrcYrsYMse9i9CXVRz7DruP5xkvze0NUlrwEq-qRr8A-i-ym-HiznRax-KQM86Y9VCuVKi8nwfii0coWWS0fE3Whltl4zgbU_a0PxhOQc_6nRMrp6_Kz4BiwjX3ImKHjyogKMe9F1vTnzG4lUXSpd423nr3x28Kg3zmvO-lcn1yW6sCn4x3hU1l6f69SL0U2aixD54RKTSRwxeK57aPvrWHe_UXnip_C4St-g38UjuGzUOE3l5whKrEZxG3RoCt1p3TWY7Lx1Q", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE5MzE1MzgwLCJqdGkiOiJkYjFmMWY1NS02ZjlkLTQ2MzUtOGM0Zi03MzYwYTY3NWVhMTUiLCJleHAiOjE3MTk5MjAxODAsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.q4zClgHy91xr-7bs95M_H_3fRkl0k-uvexUW8fYAHqdnE2j9Wp06mIsVpzqfpi5s8cYgz__RggCD0nbbRcbv78MlrduIfSVhh-haU61_Kd9slBsoWapx60i2urEHllP9-LhE48uXEjmPCeODzeyVj_KzarPx4qCloy10o_JCkiTypXeVhQRFsy4np8Rn0PAaNxkBSruLaKC92WB2AkTve-eDT3qelylRlbK6BhTIx6iS273aOZhV_QA3HiZh03dWnTLstfCsUvKCYeh8pz2-svSvhTg1WaDbrL3SegUoc3tTL_LJIdHvGbEvtHm3RyKBuIFvu1_93RPJn_VZ-YZLBw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE5MzE1NDEzLCJqdGkiOiI4NmQ5YmMzMS1hMmQ1LTRlZWMtOGRhNS05Nzk5ZTc5MmU5OGUiLCJleHAiOjE3MTk5MjAyMTMsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.0GanFn-3C_kTHi1UulRG_3cnAQb0dXCPr0Izklyz3GhkRmj7FgJohrZgbVxr0I1XHfItOqcHI6VDir_sfXnduC2fmTwENa8p_SaIZY_bultiKEPLL9DuEE4xB4SQ4fyf08eGgBkEjHikOJG5Q2MVZsUwwTgFkNgvQXMy3PmrFUCzcQeadQTq8Dak7Z02bv2CX8Rjg7eL8-osu13-RUt8VK8o7eiERRozYFlxIyKneIbgQvUhNOQW18O2mSIFfa5U9nUeKYl-LaGS7SiuzkT5rTqFqux6F3yYD6ISXDbnPlwl1OYAuW6NXKkLpah9O6_U4e80nHQNcwkGLA81dxpjoA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE5MzIxODAxLCJqdGkiOiI4NWJhYzg4Yy01YWY0LTQzNGItOGE1Zi0yZmIwYzA1NmQzYTkiLCJleHAiOjE3MTk5MjY2MDEsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.FyLMf71b8keFLv7pPP1wFORdjktOCUUz8_qeqtk4DQX9FKYynnGCTaG8UTJW8Osda4YDUB37QPZ_6zAt_Gv8OP17RJbqCSKQETRANUMyYwWIF8ToCoQ-3y74_Ppt5IeJPGsQrkWvOOLVuKugtn0pC2wyDIiA0muvakjsq_qXym9IWBjYx-JEowD85y8hE0kzfHn_lFcLWKlnxRVwwtw8Chg4k-XtDAhYSaIxN14wIHycS1nPFf_wb8x6Nt_E-ItcKTsLVwEUcvH4qte8Fh6stXrsig3D9zctr8m3XsleOKnXeIDD4ncwAudDPigFGgCdnSiGt95FdXKhDwHl2XNFVQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE5MzIyODU1LCJqdGkiOiJmNTY2NGZlYi1mMWEyLTRlNDctYjI0OS1hYjMyOGYwMDg4ZTUiLCJleHAiOjE3MTk5Mjc2NTUsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.AG5c1XpT5IWK5cLf0-7DugrO4tPGkBHDVmpHHeG0yXlOqPj_tq3M6H4PXcEExnZnJZ4pqR9jyIqYvPwVzyMakpEeCmFGh7qbOGqpkiOXfHgi6vlPmE8ApydbhGuMeKvA4UDWVCfYwg563A9abiCQiZ_gw3g-nmQ5TZvovr0b7pIV7xZDeRIEMfTi460Lz-0X3kt1fBui_kdeo22Utn0QkZgXcFgf5gLimYge_bgtYQJ-00jPGuhqrLHs5cLL8YNz4Jkbi794DfMmxFH_vAdYo8ZnSu74YrXA4DUW2AMi0WdOJ2r7dDwNfukhfiGV821G0cDlgG_FBE8VIunhx3aKGA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE5MzIzMzA0LCJqdGkiOiIwODYyZmI1MS1hYmI2LTQ4ODMtOGUzYS02NGYwZDQ5MTE4ZTYiLCJleHAiOjE3MTk5MjgxMDQsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.U-dXYgyleRAid6fCgvWtDmSrGSdzb2QMXD4DoNv19v7qkf_0U6hSLjlNK7nrHDuOuVmb5XahkUBBZdX-a2LMmJqpEfoCxlDwEZEh5qX3Kro5gYQEuVjf_htUDD1-J1Znha5qkp2XESuU64K3yQgOZoIAVpo-CZbJko5dpsm8iBSbrp6l67TBKkfzMAqziAjResm6CHAp3GLNfjsJTVn54jUtQEqyc2bycJjPJlFgMX-hlPl8jREjdUYqXqJcDZ1Whoh-8RbU6Pc1cvh2b8zUGvcVgNiO3MVzhNHpxdEHc--L28HiVF17wzcNYAGrQVXrBNNVnGtpNNfdbMe7Tbv9FQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE5MzIzNDEzLCJqdGkiOiJiY2Y4ZDZkZS1mMjg0LTQzMGUtYWU4MS1mYTc0NDc4ODdhMTUiLCJleHAiOjE3MTk5MjgyMTMsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.hfsvPyx9KLcx1SE_onsxIofdDFHNA6FoRrmwVaDOMLffKNFOHKbsx5ARUMdO8ymtsaZzjTWCDzQAoFR09npRbNsmJUVoJ-bg806WatJyMlmH3N26t5h6x9DicNA0qQmX0_hoHSuyi3-s_jfzcYiSRLMf9eaKgwWVBURGCNxQHqcTgTGIGnrUpdsLhPNYJqzzVGPO4SdJhpWbkC1QZ1Ktuy6iD1rtLmXgGqBIfVZQAxCoRhcv0EFsiYWE7xAxht_Dv7rRsIMXEIZSSIbglSaYCREM5vB3O30fxzlTuLs2AP4kAx-Ke_tBsHN_K-11kSDHGtKHR79_hm8-0ZVk4QxdzA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE5MzIzNTMwLCJqdGkiOiJlNzNlNTM1MS0yMGI0LTQ0NTUtODQxMi01NTY3OTk2ODZiMWUiLCJleHAiOjE3MTk5MjgzMzAsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.dSe12OgI8mtLmGGfcT0OEdU0HpqYfoY9FZbMCSxb403HGPjJqcIwyM5l-utnqmaIPZUcPJ2fVHH0B5lq257SZteKeSEzfgm_irjXj-tq5L-TciPVmRDbxm7hCa8S11jSTQyxTdHxmTI0Bt7RANrdY4p-Pv8RMsZtMr1c8-q3go6cp_--BrdOxa6zvBuKFYd-4TZu32KF9U4fXupIFZSM7-pCQd6ifWJ9C1xjusfVu0jIAw0qUCIqJOBoYirIipEAP5HKBiQNQEsaTwqeC0Y3ZZppR6Jvc8LPTt7RBENlfwjBVSopcVUPKOW1Z9xwYPTRPoFqQMh6xvbgdRg9yBFZ_Q", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE5MzIzNjA3LCJqdGkiOiIxZmNlYzllOS02ZmU0LTQwNTEtOTliMi01MTQzMzQ5ZjdiN2EiLCJleHAiOjE3MTk5Mjg0MDcsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.gtb_YC_nlo9N9KWkIQk_gi_tAOZmrpfWqi8bCwGiRalZcNI1jqThcSeSFCMa_jaEv4vZvPr10jLRaDdUv-bdJX6R12oESOC714IVJltB27MwI0PvYh3zAZs6V_DatcRZlV3lC0-OFVAlsHy7sKR2rEevz_4IcePvR0N1Ps-w0OcFbAIFAPBqCy0KX3bSY1GPwfrj5WUMano9KWdQkDk1O4l7CDeOvXEQT6DXeLrcFoBCPpQgc0rFmsBhYkhaN6zReaZYLkD6rlK2vzpH9UG-TaMKLj0AW6ay-eNfLs1xGor1MK6mm17xbwzZ1my0let5tx12DX1-sRD-Z83Lb-otZA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzE5MzIzOTE0LCJqdGkiOiI0N2U0NmZmMy01YWRiLTQzNTEtYjdkNi00YTQ3ZDVjNmFlMWQiLCJleHAiOjE3MTk5Mjg3MTQsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.hgRvCWUZi_vx2ClzdYs07AFfEOa1FuOgnY0fBYGxF2M2iGCBgY2T93d8yzo1EKFF6xjjBiVKocL_0zCuhO-hLmBs5pJVae5TMWylH3u3GM-PCVRRMAV-x5Xcd86lhiXBsNIOY9NjnNHTlCyLpvZUUZD2_mNnTdv1Qz3B5WouUCiySeVgcd0KKvNrfGBjTQcGjqQ8cB_GZb2ctjrs36WRO_Vjj914Mq5q1orUhG8m0osFfxjY_yBfghMDJXb2GGnp20aLjRM-6uNDYiYtzKTwYeKQjWGp4ZUBykqnosWUSObQkWGYv4oFoosgjQuCC9U0R4DspWciIjsLHEWr4j9dDQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIwNDM1NDkzLCJqdGkiOiI4YmE2N2ViNy1mOGFhLTRlN2MtYTZmZC0zNDljNjljZGE0NDciLCJleHAiOjE3MjEwNDAyOTMsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.zBj7sH2KIY4VpeMPIEOD_vpf0A1syNI_f1INoA-wH2RVlgG50bHK6DOmsQeK0zIyDHFzFvgjP_yRNSi6hnFe9xqw95Y42msv1bYSBwdafKAZyuSkECjg3iTk040oLsQzBk1Ol6G-2ZP_t0tBcZQEuSa_J4rtXIAM6zzTLlEQX_5wmSYtxcXQcFn4vYEqO8iw_4zpKMMlk9mQRQHwJqtgCiKnPf3PpbQEevq82wUtjGums_g2eqpNrS7QOz_GxB-QHiyTrkQPNUTJsARGB9nVc95Va1ZhBtxGJkEb2lFlF_zemQpu1J2VF715XGdEC_jVhJR7c2lvuxjU2_n4hJ2aFw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIwNDM1OTA1LCJqdGkiOiJjZGY5Mzc2MS1jNWYyLTQzZTAtOTNjYS1iNDdlNzdmNTFiMDYiLCJleHAiOjE3MjEwNDA3MDUsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.eFi34Bv8_SgdujTgm0kJ0BWn9fOObQ7Om-jnVcX3TO3vr1AT7xRDFq5pEVZKueR8n2qpT9iR5TjbXxhLRxgZ8wk89sX2zev0THbSSZ4JQb1SKPIqtTUiT6jNjX1s6DsVG17hmV2xC7MLEWioyH8Z-itDHjJ_ltY97H3o_4yDmYnmTK5evBGQvlQrFT9saVl_gEmutMULoynn2H7v0A9aISRDv2-AbJ2Qgaqko-Q004UtkeSWvGd_qzphFFsZ6h6zBc-_75-rSLSTns8nHsFvR_UVyuOPvg7SUpdwGcF4DVOx32a3vv1AXWxP84hTUd8EuSjubKd2leRE2qDIK8-1vw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIwNDM2MDkzLCJqdGkiOiI4NGY3ZmNmMS0yMTBhLTQ5NTEtODhjOC02NDkwZmE5ZTRmZDciLCJleHAiOjE3MjEwNDA4OTMsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.qQZpYtEDOplJZpo0pxGEFx8_uTafVj0dAziDF0bDp9zzswFDaDc8fgBJqEytt-jx5bQb07ZqUOTOQ7ABNouFWmdTPPCa4hjtjP_hZzEJzMqrTc6tNqj-6bgNR0LOdFBCgvECfMPrRy_MPG1TMJvLYxTUrIPAk9p39t3uFoEZxbC3fGmhc1go0rQQ5pqQ6PDOPu90aS0mcVpRCmpXouIEOKauKcKOOLrNhIXKp4np-ozstjHQ8rx2PtdUMp9tFw4MmUWvmmla2RuvR7Q_b55Hv7oVJyjekz-zM6c3ydX8_VN_LyCT3WHVqu-a9H4pbI6tmiIw_vnn0tu23ytkTtCV0Q", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIwNDM2MTQ0LCJqdGkiOiJmNzA3OTQyOC02Njg3LTQ3OWUtOWRjMC0zNGE1YTY5OGRkZjciLCJleHAiOjE3MjEwNDA5NDQsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.Ll6hKGp2D1VnRj0C0G1P3pOeC-pvlWxGfHKHKiN4FL78ttuDutX99xKbCcfxWbL9T1ykCHLwFh5ehgrFN-ZSevuPhcCUY5m1yCI-pP_9it5NO-u4Xt5aBvSOchbmTEH4BGZ6hQ_Q0F0zXC2Ao9wFZyPE0FcpOR96jz96p4O3yJOTg_UNcaB8uq-oMzEy8pl0VwNKF1jmyEbwjhdL3nXuMYfPau7KuhLbEESqc32NS_QFaJT-RqAt-Qued1sQ8xQ_OXqf9R8pivZBu6jZZUHOVkTX7qkMUBz3n-f6Yk_dq5zTMWgMnPwQqR_GhIx2_sZez9p5f7EY4uOeB6PnBlA39g", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIwNDM2MzA4LCJqdGkiOiI1YzE3MjM0ZS1iMmI3LTQ1MDMtYmFkYi0zZmUyNzVlMzg1NGQiLCJleHAiOjE3MjEwNDExMDgsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.rW32d8kXkmH1T-t_XJ5__YSszMn0EdsM2IFl9pD4IW_LVYFlknW3GLqsQg-aZBIASNlY7iQlS8nxEUzVFp1qeTdlr_LzBzYiM4tS_7Bzo7aYdq-zjBrf1S2Bt-f_OHeOFJsWLX1R1f0YO-_RCfLWI_3puYRMtFzpzLCD5Fe1obZGcUB4fPyBnICDVSeg72edxnUb1KvR0NcowvBdrHTWT9aYs2rWW7rDwwjSIjMB7GdpqQcVpI9NbyIdXP8sZHKyGkBY_j7L453pwOqr7pT8ON0UR5Wysw79uy8KK0utYGT5hy83HGJuhEh6Rhw0OoXSxKi3Uh2ViQ0vVcIGJqykkg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIwNDM2NDg5LCJqdGkiOiJmNzI5YjcwMC1kOGNlLTRkNDItOWM0ZC1hM2E5OTg4NWU3ODEiLCJleHAiOjE3MjEwNDEyODksImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.GyhV_f9HIXSVIDzhmtpfUxf7zp7DqQ4V31IrQg6exsALBBJ0pLGLjaIt8mQcN7txgZzgNDXDdM5W5zh9EJlTYQCmFtc0RZzPrdydUS5SEPNNZ2egjoc12ExTIEPTfuamW3ENnzFrQ1lfLdyu_9pbUj-ybFmMu3KtNVfSEXWltC__PxXYSqLW50jC-6Yl9NX0UT5-cYPrPSNDZ8gytuE2m9k74WBUDdTQ0S5y31bwYY2wpIiIUzuQBCWt4Aq4RhPW4qvTm4iKw9P-1dGANEB8lXRIhcIo1TGzrouqXjqHq7c3Qel8GovtAhncEgchR-5WMEcBTRap0b59oao3tACMVA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIwNDM2NjQ0LCJqdGkiOiIyMGYxNjU5Yy04YzZkLTRmYjUtOGZhMi1hOWE2ZDc0Nzg1YmUiLCJleHAiOjE3MjEwNDE0NDQsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.k4xLAbT2HaVDIjZXwp93GJE1s8v8Gfckg_K-PSazvnz4Yvpm_SoWWgitqZN8v1m4aE_DTK-ioo6LiOVTx6PeBse75VkKufBSueHYMFaCQ4PoBlHNA8SssEInP12pcF5KYMzZS_zSy940Tf16dKjJXhWcakgIoFmjtdiw7oROCAHvMrWGGlbJOXJdRQPiI48pqP5TBEBKBgo9BgS94SHxWj1TjKzdUJRIVT_xXVh5H3b39pRb0jF0Q75JtcncjVDwtxnLd8tZ_Vp45tR_FVWqQo5Aq3ojWI_JohqzJII7URTAIxA3k12oAcRC_DUWFtJhFgYhFtpujFmIQYW7y35pBg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIwNDM2Nzg2LCJqdGkiOiI2NWYxNzY5YS0wZjUzLTQwNjItYWJhYS00ZWZhYjllZTkwNDQiLCJleHAiOjE3MjEwNDE1ODYsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.pfZxdiw9Ujewo5kuQ5ULqsTvoikg2nQ4YDh_yjVRd-UzjdB3zvXNhYsHjCUrhguyJVnkWECVdG9MjJ3IKfOuIZe_d461Le9xxUnfWpi4JOCAvJyF4OOrSWyJ4PqX7ASUfo2cnsNM1-NhxxcGmeo6O7oco2CMLnqKvwFmSsbGv2ykO_qf9M934alYDQkbmGO06NmOyQwqB_HzJiwrd-YrjQOR2v2Kqcqd2uvF3_Ab1MXq0DEGMxwThSskAfFqw3Us2W_C1Ai2_FOleTOejM-3k7b-Ju9nIA9yUWVAp_F3hjMa7NnZlCPTZT83xdtwdj_-810XonhspkzSxfKtHmZb3g", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIwNDM2ODA3LCJqdGkiOiI5YjM1Y2JhZi05YTI1LTRlNzUtODI5Yy1mMzc3NWU1ZDk1MmUiLCJleHAiOjE3MjEwNDE2MDcsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.V_avudAqiVQ2HT2gdRkysItRjGeTYdtPy4nVCqZPhkYaGStv5yjsUKyzgrazaGW1vZ4tOdhAWf78KOTmZV-4cj5IjFdEeKlpt1NT-gXmPjdWmOT7YIETdlRj1DEHn3YTrmkh1nFOwq-MgB-1VP6qLibjsMFU0auVpIASbNOXwnu8la02BmiTvfNfi50P-TyV_tXau_aB7LcfMl2wFDDfK6VcZPEJx9FuhK56WxZwW3PFB6FgP2KoAiZ_ZUxtmxTi6k9kseepFfWuD6PhvKRn_2GcJcvzjj_T1JM5ai4AMJRx4l7uwLvAPTAWmsPiJO0tykT_VTR8JwMi7B55ctzGkA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIwNDM2ODI3LCJqdGkiOiIxYjdiMzRjYi1mNWI5LTQ3MjEtYjUzOS1iZTIyOGI5YTdmYjkiLCJleHAiOjE3MjEwNDE2MjcsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.xVOE6zjAPrGyk6JROdISb36Oy9-m7p-bREZY31LShobPVF7IlyQmqc3UG0Xp1gRN0sdTSLaTi20aympSNF9zNIwcZ8b5saMJ7VZyNuIi6B6Uhh5UiMnxtZW23IIuux5RcLYNBhS7g37rbh9uEkgzpQ92PdPLqIAYzpFRGW2XBH7UjJWWB7apY0zwxjp0Nhc66MaU1jDRh6SiGMDBvEUtgJwEo-5pBreCemnubjK76Mv21X7cqdbCyJTb9YUbrSh0TFqZB6rRH6sEB2NVux2_ztNhA3RQ_EicoAEXN5lWJJi0Yu6bxqNCx4HsRJ1mVQOFLVpw4VP4w4IFn85X_0brsA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIwNDM2OTE3LCJqdGkiOiIyNjNkNGZkNC05YWE0LTQ2ZTEtYjdkZC1kZmZjYzNkNmNmNjAiLCJleHAiOjE3MjEwNDE3MTcsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.uzUGDnGE0Ac0VFnsFxRfHzr4vdCHQQYFvZ2FR-aF7shMpy4Q5eVlrWpkw3YG89p-iMRmGP9vzBgia4ONGGVpLEZuBZuudOTop8vPTiqsKof2HGwYJivZ-P7xhGJGXE9biEaDZDSzVQLHPU4c41GgXluLLsgIOp8ZM8M1uoHwHkaExxnqYkGZCQcMhuCrC82F67x97Woq5g4owzWbVRlz3qZ3CMtPsWsJLcNnBed6YWJUWuwlkwY_wv_bcm7g-NRkxY8ImMivOCXCyJB31b_-EFZLCn07QHciAuvTZbfapXHE5NV5NmQ_XAj-MBQjQK0Yp2dIleHgKsnEOOFRTNWQnA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIwNDM2OTcwLCJqdGkiOiJmMDJmODZjYS1iOTExLTQyZGUtYjQzMy03NDViYmJlMDc4YmEiLCJleHAiOjE3MjEwNDE3NzAsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.hiMEVZGjs6iikHPq_HN4lF61Vnlc0uzcLGL5RNF4wV8b634g-ivhqo9Cv2SBTQYAlAvC334q15nhpxGHsI2EZLjVLlokIFeaPQ2dPs3wgjVg-_HQudbWJgS-WoMTLbe8QwOqc5FDeX3LXlPc57_zYBhzZn3HNOCpi8wuz6OiZCe_I5yIlO13nKwlMX-NnSvDjdQd5qtPQlLklOYDCpIi73Nf95qKXXRrwO7w2XLfZ3RZ-W71jWmVuC9gdPoRuhiIGCvx4T8d4_-WQ8f5PL2wubtLcv4KABKN5oTYPBsV_wIc7-d4od1wKs1Wz3N8vfh9hQaUdrzkExbRIUcD2E3MJQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIwNDM3MDIxLCJqdGkiOiI1YjU2MWQxNC01MDcxLTRkNDQtYmU0Mi1lZDIwZjg1OWNkOGMiLCJleHAiOjE3MjEwNDE4MjEsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.DPxh_gh3j_kuRv_WCZY5KG67NFE_mB6UwbR3qLnpLVMyQl7YxbwT6rwUxWRpi5kuD5rYWeEvJbXIrs_scZlIENCQQCM178Is_nKXs922RpGCyDnpAjeYhKhc2P7S-FSYFhY9WKXbkuuueJ2-TiFfEr66VEcKyCWE1mvBFuYJGe-GqRqENM1WxeiTO19ftpPOAsqkqtjw211dCBWSqnJw11sRWjeqANpeLOdoKwoGtdDlvHe2Ne6AA5lCgozewQRz72af7YbzcOMKtus8zOypeDSHCBRlljU_Ea5o1kWMZ1J-wkg4ZuCsRzWFlTpQKXilZdm7Qv5HfFBQ3YoDJHZHmA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIwNDM3MDUwLCJqdGkiOiI3ZTRjOGNkZi01NDg1LTRmNjktYjlmMS05ZDI4MjRjOGM5YTEiLCJleHAiOjE3MjEwNDE4NTAsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.d7AOCpk1DuScoG9c8spDFpdx-X7mZzp9WrjdvLnIWCfN-jT4-5OSI67VymIJuMvmqRhXLqlxL0QKaQM2Hnyt2v_N5XtbG3yAxINjXGOJd0PIzBdTYfBD4lrQrpOG-W9xyOjJqgZ5WRkBSWydZ2r1bzT1EKM8bA70uXypdcvgG_a4KBkQLRGdpY25fR4MjOZWS3AkSOACr6vAuuKNmIneaF5jLxVPizLy0bHK6-2ccGZd6QM4JVqukv7piCglKkB1HRY2ylmocWV5ZIwNk8o4nirso_ybjlAd2rH1OsIP-Q29Jwf8my_Tada2EsHaLCbVSs5u9RscmhNZEN2m2gmfOw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIwNDQxMjAxLCJqdGkiOiI1YWZiZDAyZi1iYzlmLTRhYTItODNiZC1jYzA4ODhkZGVlNGEiLCJleHAiOjE3MjEwNDYwMDEsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.i3Fdgrs2jtv5dCFiYK5wQAItLo51oWV7KhhEzIEs4HdWhDs4EmcFCCfbm8BPhs0MeTRrt9rQUlmx326YBi02n4JRRO8plHWYKC0VgyhnpRU5u5Nhx92G2Mefyso056rDLFsnCkNZd7lYKoMWc16ZsxjHarvmZ-5Qk3x29geTBBrz_8X2h9wFGbHbgkUpfcdRmnS-ITxMHFNOg6ykMSp_w4LqAKQE3L3rWDduhVIYktT2oDevX3nFd2ujYxisOvi2HFTsWClg8i0N_EvBuUl2aAggPsmjI5KlO8DVIPNXcB7cyfiHzZUmHtzG-al4HupixxIioA351Xxp-tRm3W-0lg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIwNDQxODgzLCJqdGkiOiJiNjgwYzIyZS1lMjM1LTQ2NjctYjUzYy01M2RjMzhiYTI0ZTMiLCJleHAiOjE3MjEwNDY2ODMsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.Hj6l3-egMZ_LNYIJK3Y18-Y-SKeUOY2Z8itCIoZi3NmwlkEZCQ5o6uJmg4Y6vSe0JzOoTVNj3dWKhB6F15-Qg-NU17gnfdwE9pXAazo5I-JSzkV1Nv9rY1UPIEshKp7j9zjdzF6at_MS42I04ubsVEOzhKBqSU-3DCIJRlD7a0SsjTgSlrnh52lc1JmHEv1hAL8naP5tmKYtMJ6ZUmbar2V38lE47kfuWQjdITDaLMJSkr_dWTk4K1nGk7azcsprNo95BYtJt9PIVy6mWdJyZRbTzzEn8hHaS8VlLxTPs1o-IyuhLmY13oSKlwNJ5YmdZezZhD7x8tucbgoQYZ1_IA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIwNDQyMTgwLCJqdGkiOiI0NjlkNWJmZC01MDcwLTQ0YWMtYjZmZC00MTBkZTE1MzQ0NjgiLCJleHAiOjE3MjEwNDY5ODAsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.cDovRMIPVE1AwHOEMx_TSF9g_8M2KZrWs1MOQGlzilvUGo1VldzKLpCACO2txk0G7spCe33Ti8YqVTo4v8Do6zDymtWo203euwZBfTuEUw7bKQAn-Nbovpy3KrNs90JkRVULrEdedJf-Yx-IlTBdHjX1jsVvU3fiJ4iBONtfdvn-5m1gEyJLLRV9498kI9BVKD1gc3qxA8ehEp7-JzGF-xhm-EFIFZAMxWVBTnkWgHUHvXNJOkIZGeCRou6sWTrMVgpxE2rcQcNiP7Q4kPYtODV81ZOKq-ooGGa2yjErFKkUdZuKOG9eg6w01Lq8cUJbFMdSjkSYVnvOiDQHVEGZCQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIwNDQyMjg4LCJqdGkiOiJkMDY0NzMzNS0xMDdkLTQ2ZTktYjQ5Zi0yYmEyYWMzOTJjNDAiLCJleHAiOjE3MjEwNDcwODgsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.JaagVzqh-fjaxiEJ0mDQH12VlRaRjZbDhduzwTYA17ficBZxaZSphlGULq7qj00cT1gh1z45KUujEVjGAajs5d_wiLKgv1di2h99ZEQ0l_wSO9lp4WcjKYbdaTrKXi9TsMUzBNtG-yBdt5PXsbU-g6ds7EoOKuSC6XNOsDPkotrc3K4rke9DdUtAKxEAYdUJ1hjwYuSLJ4Oe4pToK5Iq_rV7AaaF8uKDu4_9hN1shx2QgsAEVhalz-jULKt7euCpt3SCtUf1b7wMVSUIYhruD4qeueWboCmyaza3Yn-r0VEIRmw-PTtBbfZjef9hnmZ_z_CBZN6UHEdOORDnuiZMFA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIwNDQyNDQzLCJqdGkiOiI3NGVhZjE4OC1jNmYzLTQ4YWQtOWU2ZS0zMWRkZjFhNjM0MzkiLCJleHAiOjE3MjEwNDcyNDMsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.Rlvmgaa1fzCVHgAD8HIcpqSZS53ZHDGMVKZ61L_smUhza_nzLLRy_PkdsWlyK0LqwQMXIBrmg1KNmfRKFC1uXGLptRlEOccXCdvK7EC4Nk_4ojghjQJhwxE7H_LxkkdSvrzD-RPgtVLjK1loRhwzfBrYvazJ4SoZostzrzW68HsCPHEgnYdaE0wY0saSliJ7PpaILTM7v7Bk0r9mtPblYWrkyAVlgpBiM1GcL2Qceik3kbleGZikBT7QLprqwxhz0qlfHmsdHD-L_KJPvtwFXfkIkynSzczyn3p2FC7AKyUOW1OinUkHNHgDnttBVBKhJV9HSd4Aox6FPEPbD76AHQ", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIwNDQyNjQwLCJqdGkiOiJkYzdhZTFiZC04ZjliLTRlYTEtYmMzMi01NzRkOTkzMTZjYjIiLCJleHAiOjE3MjEwNDc0NDAsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.NgDHPaEQGYKkK94Gs_uOtx9L9w8-kFzULktdies6MljFlXyy3VAEzRVz5mWpJXz_DZ9e44ZnIMIxPItzMSoJlNpl6PeEkpVujemwnwdds5aHpKZZ4nsebDlbJjRDcGFFOIhsLVDai8g2Mkf3vKnPDCgCDf2An4SpoGxToZujeDIxWSOPtDCw3omHSGWGg5Nd2x0KN_CzXMVN4MskxINm-D6QMcH3xXDOJbxQj3BiIcaJ-tp8r9EEMHSeYsjl3vjh9lh8dy96ZvGNBWUWhN6G-xSd4t7WQOyepWLiPGPLlB3SJAoOBE4uCN_c5hHj_eX4NIa-R-RypJXNJxy5Yq6NDg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIwNDQyNjc3LCJqdGkiOiJlNzJmZWVlZi1kZGE2LTQ4NTYtYmZjNC05NDE5ODBiM2M5Y2EiLCJleHAiOjE3MjEwNDc0NzcsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.1Asp7YHeL8pzEFItfPh1-_ZO65UD-nPA4iYUByQgg5s6_n3xA87ltUukpmDuVpAvhJtPZVJM3Le0V-o1rx23WH9t7k1GfQM56DMWoICyw2qJ_P_SSl5ip8pOeJ4d4QZNIc9CslNRaqK6QQHNrMyrzf6wM26bmXvScYz5oJWZh7GRKYlWYAjzXfE_tjXXO3Hf0javFZ6l0ggVIhDT9pn7DucWLxrhMd8Q32VQUZg5NEQVC6jOfPu4PQTwJiIhdwD7a3mTYbJNHWrakOtBxlu1sGTtaaB1ky4-vQr8FBYOSkswBj1O8t2r3inzwTvIIzBjWxk-xKqeLeo1oZGmeEzvrg", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIwNDQyNjk2LCJqdGkiOiJkZjEwYTgwNC1hMTZmLTRiM2EtOWIwYy04N2NmNzczNTdiMTAiLCJleHAiOjE3MjEwNDc0OTYsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.SPgWZiK9FxL8pGsi-c2SCwq72y3dHUiKIb6A07P-mgbMsL52u15Slz6RZRD5_5hXemenursFUMLN8O_I6ROret3IcHPHLHhwK9HQy7XGiMdI9qzS-kSzFhz6YIAoD-AAzOIv6JLQzwFuCYhQr1R14_xx2alUaNWBAPhwEKh61ul900iy2KBTx8LHiUBKNGKEfjEX15m_DO0IC_nr5FcTZYp2GyPDvAJO991hmD6sVxdy4mLEhxz-KS2-P9-DGy554BrkqYCyfq4_-WfIljjJl9fuS5Q-XoLGDenOItGQnholcPhVsTJqS8ppkZT-wtjs44eivYcPkjZfAp1yfrNyiw", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIwNDQyNzAzLCJqdGkiOiI0OTExMjk1Ny00OGM5LTQ2MDYtYTMxNy02ODA4MDczZWMxNmUiLCJleHAiOjE3MjEwNDc1MDMsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.yA6osqGWdA6Ctt9zhBUpF30b44LTgl1RRDgaAVh3LUBOc0t_4P9xTm_rnSh4FnQiTRHze5tUmA8-unGReZ5HRKSe5f5IwD1sky_s7Wha3O9RnyNnB7f5l-u3QcB6xWDkUrp2j4X2HbvjHiEcWR1CqoAjrGHu9aoiq8CtyXvjwprhOunyH6pgk2ENDGyiXG2d843pv7cDHyOFTmmNquPbsYWEKQp0VI5eMji1bx9-zRUueMendkCRrbTx4XcXch_U6nEIvmIAU9-FHVWCcWjm_8icriABMhCHaoFm2DWsTVoYI3CDfTqWYTT-bfaEGDb-F5dycjLKOceUjk8MA1B-FA", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIwNDQ0MDc3LCJqdGkiOiI4ZDMwYmZhZS0zNjVlLTRhZTUtODZiOS1kYWNhYzUzNmVmZmIiLCJleHAiOjE3MjEwNDg4NzcsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.aODzbNIndDDqqSaJa8yLDg1EA8d-nCjllxaTRLqHRdHPY_DsfOQIO5pM-8sxznuIsq8tqqIByp52dWJikkcAw3z9HIyET2MFghXS4X4ppNvzKCDJU85NLEc8Smf6tJztLMaI6gHDNGmMb-3fDaTvim744hbM-Ov07kxfeksYH7ljSjyhiqY-oRxqYvDupUHBtx4wYaAByiVf4aISFt7yVfE2bdjXihcqUx9hodNjAnpGSOhxEsa2mWKeMBYMDGlHf2hFYJGdtF0dts-ONoRxBvo8PXM0452UKGx228i-e_D0l9Pf2h7ulzU8mKxZLMfhQowK0OmWne2dbHOfoGYPyg" ] }, "profile-user-non-issuer-1": { diff --git a/test/bdd/pkg/v1/oidc4vc/oidc4vp.go b/test/bdd/pkg/v1/oidc4vc/oidc4vp.go index c1f943561..b476d1fcd 100644 --- a/test/bdd/pkg/v1/oidc4vc/oidc4vp.go +++ b/test/bdd/pkg/v1/oidc4vc/oidc4vp.go @@ -105,7 +105,7 @@ func (s *Steps) initiateOIDC4VPInteraction(req *initiateOIDC4VPRequest) (*initia } func (s *Steps) retrieveInteractionsClaim(profile string) error { - if err := s.waitForOIDCInteractionSucceededEvent(profile); err != nil { + if err := s.waitForOIDCEvent("verifier.oidc-interaction-succeeded.v1"); err != nil { return err } @@ -118,7 +118,7 @@ func (s *Steps) retrieveInteractionsClaim(profile string) error { } func (s *Steps) retrieveInteractionsClaimWithCustomScopes(profile, customScopes string) error { - if err := s.waitForOIDCInteractionSucceededEvent(profile); err != nil { + if err := s.waitForOIDCEvent("verifier.oidc-interaction-succeeded.v1"); err != nil { return err } @@ -345,8 +345,8 @@ func (s *Steps) setHardcodedVPTokenFormat(vpTokenFormat string) error { return nil } -func (s *Steps) waitForOIDCInteractionSucceededEvent(profile string) error { - txID, err := s.waitForEvent("verifier.oidc-interaction-succeeded.v1") +func (s *Steps) waitForOIDCEvent(eventType string) error { + txID, err := s.waitForEvent(eventType) if err != nil { return err } diff --git a/test/bdd/pkg/v1/oidc4vc/steps.go b/test/bdd/pkg/v1/oidc4vc/steps.go index fd127258e..c3e70a4b4 100644 --- a/test/bdd/pkg/v1/oidc4vc/steps.go +++ b/test/bdd/pkg/v1/oidc4vc/steps.go @@ -141,7 +141,7 @@ func (s *Steps) RegisterSteps(sc *godog.ScenarioContext) { sc.Step(`^User interacts with Wallet to initiate credential issuance using pre authorization code flow and receives "([^"]*)" error$`, s.runOIDC4CIPreAuthWithError) sc.Step(`^Verifier with profile "([^"]*)" requests deleted interactions claims$`, s.retrieveExpiredOrDeletedInteractionsClaim) sc.Step(`^Verifier with profile "([^"]*)" requests expired interactions claims$`, s.retrieveExpiredOrDeletedInteractionsClaim) - sc.Step(`^Verifier with profile "([^"]*)" waits for interaction succeeded event$`, s.waitForOIDCInteractionSucceededEvent) + sc.Step(`^Verifier waits for "([^"]*)" event$`, s.waitForOIDCEvent) sc.Step(`^User interacts with Verifier and initiate OIDC4VP interaction under "([^"]*)" profile with presentation definition ID "([^"]*)" and fields "([^"]*)" and receives "([^"]*)" error$`, s.runOIDC4VPFlowWithError) sc.Step(`^Malicious attacker stealing auth code from User and using "([^"]*)" ClientID makes /token request and receives "([^"]*)" error$`, s.runOIDC4CIAuthWithErrorInvalidClient) sc.Step(`^Malicious attacker changed JWT kid header and makes /credential request and receives "([^"]*)" error$`, s.runOIDC4VCIAuthWithErrorInvalidSigningKeyID)