@aztec/accounts 0.63.1 → 0.64.0

package/artifacts/SchnorrSingleKeyAccount.json

@@ -1,14 +1,13 @@
 {
   "transpiled": true,
-  "noir_version": "0.38.0+c807678263164209f62fa5c9bf19f468cace1f98-x8664",
+  "noir_version": "0.39.0+5569eb8ea1578265649219a5497a61c4d93e8d83-x8664",
   "name": "SchnorrSingleKeyAccount",
   "functions": [
     {
-      "name": "verify_private_authwit",
+      "name": "entrypoint",
       "is_unconstrained": false,
       "custom_attributes": [
-        "private",
-        "view"
+        "private"
       ],
       "abi": {
         "error_types": {
@@ -20,18 +19,14 @@
             "error_kind": "string",
             "string": "Stack too deep"
           },
-          "19458536156181958": {
-            "error_kind": "string",
-            "string": "Function verify_private_authwit can only be called statically"
-          },
-          "4939791462094160055": {
-            "error_kind": "string",
-            "string": "Message not authorized by account"
-          },
           "5019202896831570965": {
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
+          "5727012404371710682": {
+            "error_kind": "string",
+            "string": "push out of bounds"
+          },
           "6485997221020871071": {
             "error_kind": "string",
             "string": "call to assert_max_bit_size"
@@ -497,9 +492,173 @@
             "visibility": "private"
           },
           {
-            "name": "inner_hash",
+            "name": "app_payload",
             "type": {
-              "kind": "field"
+              "fields": [
+                {
+                  "name": "function_calls",
+                  "type": {
+                    "kind": "array",
+                    "length": 4,
+                    "type": {
+                      "fields": [
+                        {
+                          "name": "args_hash",
+                          "type": {
+                            "kind": "field"
+                          }
+                        },
+                        {
+                          "name": "function_selector",
+                          "type": {
+                            "fields": [
+                              {
+                                "name": "inner",
+                                "type": {
+                                  "kind": "integer",
+                                  "sign": "unsigned",
+                                  "width": 32
+                                }
+                              }
+                            ],
+                            "kind": "struct",
+                            "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector"
+                          }
+                        },
+                        {
+                          "name": "target_address",
+                          "type": {
+                            "fields": [
+                              {
+                                "name": "inner",
+                                "type": {
+                                  "kind": "field"
+                                }
+                              }
+                            ],
+                            "kind": "struct",
+                            "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+                          }
+                        },
+                        {
+                          "name": "is_public",
+                          "type": {
+                            "kind": "boolean"
+                          }
+                        },
+                        {
+                          "name": "is_static",
+                          "type": {
+                            "kind": "boolean"
+                          }
+                        }
+                      ],
+                      "kind": "struct",
+                      "path": "authwit::entrypoint::function_call::FunctionCall"
+                    }
+                  }
+                },
+                {
+                  "name": "nonce",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "authwit::entrypoint::app::AppPayload"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "fee_payload",
+            "type": {
+              "fields": [
+                {
+                  "name": "function_calls",
+                  "type": {
+                    "kind": "array",
+                    "length": 2,
+                    "type": {
+                      "fields": [
+                        {
+                          "name": "args_hash",
+                          "type": {
+                            "kind": "field"
+                          }
+                        },
+                        {
+                          "name": "function_selector",
+                          "type": {
+                            "fields": [
+                              {
+                                "name": "inner",
+                                "type": {
+                                  "kind": "integer",
+                                  "sign": "unsigned",
+                                  "width": 32
+                                }
+                              }
+                            ],
+                            "kind": "struct",
+                            "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector"
+                          }
+                        },
+                        {
+                          "name": "target_address",
+                          "type": {
+                            "fields": [
+                              {
+                                "name": "inner",
+                                "type": {
+                                  "kind": "field"
+                                }
+                              }
+                            ],
+                            "kind": "struct",
+                            "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+                          }
+                        },
+                        {
+                          "name": "is_public",
+                          "type": {
+                            "kind": "boolean"
+                          }
+                        },
+                        {
+                          "name": "is_static",
+                          "type": {
+                            "kind": "boolean"
+                          }
+                        }
+                      ],
+                      "kind": "struct",
+                      "path": "authwit::entrypoint::function_call::FunctionCall"
+                    }
+                  }
+                },
+                {
+                  "name": "nonce",
+                  "type": {
+                    "kind": "field"
+                  }
+                },
+                {
+                  "name": "is_fee_payer",
+                  "type": {
+                    "kind": "boolean"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "authwit::entrypoint::fee::FeePayload"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "cancellable",
+            "type": {
+              "kind": "boolean"
             },
             "visibility": "private"
           }
@@ -1614,19 +1773,22 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "H4sIAAAAAAAA/+1dB5QURdedndldYJclo2JA+AQEBJmemd2dVVFAUFHBiAHjRjNKUlHBVUEBwYg555xzzjnnnHP8zDn870mXWzS1vcDe11+/c/4+556pqeqpvu/V69d1u3u6CxILlwmFicQThQvLBYSU/5kk9ArUFTnqSh11ZY66jo66zo665QjDAnU9Heut6qjr5ajr7ajr49fZS4H/Ocz/zKYrcrn6yky9l/Wq05mqmnx5OldeU5H38l55vrwuk89m6/O5fGVVTVVlusrLZeu9hvKqbEN64dIp2dRXulVLplaSZ2cYz3RakmeXZeeZCVYwt66EQosrj9dffrlvoqnc2arv4pfN77rS926E7oTlkk31ZkkGfJBu3eL1Afpzedy4e/a+xf32CvihAOyHFNAPCcGYXQGXA+olefZYdp7lwQrXvrWCtQ/xYsorW+UegX1rRfq+EmFlwiqOfSsFjqlVgH2tmMSNTU+h/Iz2X19gXysB/bcq0H+u2O5pxfaqVnllq7xKILZ70ffehP8QVvNj2+4zuKDzZy+gTzpYPPv4B7y+/mc//3N1/7O//znA/xzof67hfw7yPwf7n2v6n0OSC30wzHCm7x4hQ8gScoRyQgWhkpAnVBHWIqxNWIcwlLAuYT22nTCcMIKwPmEkYRRhA8KGhI0IowkbEzYhbEoYQxhL2IywOWELwpaErQhbE8YRtiFsS9iOsD1hPGEHwo6EnQg7E3Yh7EqoJtQQagl1hHpCA2E3wu6EPQh7EvYi7E3YhzCBsK/vk/2SiUUntf18J9l1Axx1gxx1Qxx17OS2gTrPUZdx1GUddTlHXbmjrsJRV+moyzvqqhx1aznq1nbUreOoG+qoW9dRt56jbpijbrijboSjbn1H3UhH3ShH3QaOug0ddRs56kY76jZ21G3iqNvUUTfGUTfWUbeZo25zR90WjrotHXVbOeq2dtSNc9Rt46jb1lG3naNue0fdeEfdDo66HR11OznqdnbU7eKo29VRV+2oq3HU1Trq6hx19Y66Bkfdbo663R11ezjq9nTU7eWo29tRt4+jboKjbl+/zhyIzeTIXgr8z2H+Z7p1C/Qg7KAL6jsj17e3cEJlfNvLL08kv0wiTCZMIUwl7E84gHAgYRrhIMLBhEMI0wkzCIcSGgmHEQ4nHEGYSZhFOJJwFGE2YQ5hLuFowjzCfMIxhGMJxwUPqhMdwTLJUTfZUTfFUTfVUbe/o+4AR92BjrppjrqDHHUHO+oOcdRNd9TNcNQd6qhrdNQd5qg73FF3hKNupqNulqPuSEfdUY662Y66OY66uY66ox118xx18x11xzjqjnXUHefX2Utv/3OY/5lu3bJI0mmtspoI6Ku+gZe0NwnUF9s4GdLXQn9NaX1fGd9f3tTW9pX71/fe/q3rK22No3dAa/rKLBIT3oHL3lc6EF/etGXsq6JhsVj1Dlq2vvKOuPcOXpa+8s59yDtk6fuqbGZ/9KYvbV+Vze7b3oyl6ysTkie8Q5emr8rQnOM1LnlftS3kL++wJe2rssVc6B2+ZH2llyCvekcsSV/pJcrR3syW+ypfwnzvzWqpr9wSHzu8I0P7yjUsxXHIOyqsr8qlOqZ5s5vvK7+Ux0dvTjN9VTUs9bHWm+vuK70Mx23vaFdf6WWaA3jzFu/LW8b5hDc/2FfdMs9NvGMW7SvbinmOd6zVV6ahVXMm77ikjOhL+p/Dljxnh87tjgPOE4+H2ZxNszjnuxAKEosvaIF+PHCsbL4nJAUJc+fofk8EBoOU3ScmmxwM6vefYCtONO1cksGGSwx1omdsbF8s8L+cFDxrssAPQrvuJIe6RV+DRGQto0gXAIP+JPDgSuzgCxyJo7V2L1BytDsWONYnw2yuyEV5tDs5KXO0OyUpSPgUgaPdqTE/2rHdpyo/2h0LC7aqWgddkaPdaf6X04NHu9McR7vTIzjaIbKWOdqdBgz604UGF531kTafgcueXiKBPxKf6CeNJDgGkdLgTPBsAZ20eIzPFJglxd1uEztou89SMjtExvjZwnki3brF4zE5WyBPnAn04TkK9pdzBPaXc8EzdDNXOdfiKuULdDydDYyn84T8el5yceWGzk3HAP1wPswPufoolev54PEzywVJQcIXCCjXC2OuXNnuC5NNDgb1G6lyPQYWbDUZB10R5XqR/+XioHK9yKFcL45AuSKyllGuFwGD/mKhwUVnfaTNl8R8RnqenzRSYB+eB/QhMvFeGvPx4Hi5VGB2C7TbefBCxMuFAjNZZOxcFnNlxD68TMCHlwJ9eDnYh2ZBHwOQ+euKmOccHpMrBHLOlULK70pBRW18gd6HkPF0lZBfr4pAUc8H+uFqmB8qM1Eq6qvB42eWa5KChK8RUNTXxlxRs93XJpscDOo3UkU9HxZs+XoHXRFFfZ3/5fqgor7Ooaivj0BRI7KWUdTXAYP+eqHBRWd9pM03xHw2dZWfNNCK+iqgD5GJ98aYjwfHy40Cs1ug3SKK2sQheiaLjJ2bYq6o2Yc3CfjwRqAPbwb70CzoYwAyf90S85zDY3KLQM65VUj53SqoqI0v0PsQMp5uE/LrbREo6nlAP9wO80O9F6Wivh08fma5IylI+A4BRX1nzBU1231nssnBoH4jVdTzYMHmNTjoiijqu/wvdwcV9V0ORX13BIoakbWMor4LGPR3Cw0uOusjbb4n5rOp2/ykgVbUtwF9iEy898Z8PDhe7hWY3QLtFlHUJg7RM1lk7NwXc0XNPrxPwIf3An14P9iHZkEfA5D564GY5xwekwcEcs6DQsrvQUFFbXyB3oeQ8fSQkF8fikBRHw30w8MwP2QjVdQPg8fPLI8kBQk/IqCoH425oma7H002ORjUb6SK+mhYsNVGpqgf8788HlTUjzkU9eMRKGpE1jKK+jFg0D8uNLjorI+0+YmYz6Ye8pMGWlE/BPQhMvE+GfPx4Hh5UmB2C7RbRFGbOETPZJGx81TMFTX78CkBHz4J9OHTYB+aBX0MQOavZ2Kec3hMnhHIOc8KKb9nBRW18QV6H0LG03NCfn0uAkU9F+iH52F+qI70eZfPg8fPLC8kBQm/IKCoX4y5oma7X0w2ORjUb6SKei4s2Coie97lS/6Xl4OK+iWHon45AkWNyFpGUb8EDPqXhQYXnfWRNr8S89nUc37SQCvq54A+RCbeV2M+HhwvrwrMboF2iyhqE4fomSwydl6LuaJmH74m4MNXgT58HexDs6CPAcj89UbMcw6PyRsCOedNIeX3pqCiNr5A70PIeHpLyK9vRaCo5wD98DbMD5mqKBX12+DxM8s7SUHC7wgo6ndjrqjZ7neTTQ4G9Rupop4DC7a6SgddEUX9nv/l/aCifs+hqN+PQFEjspZR1O8Bg/59ocFFZ32kzR/EfDb1lp800Ir6LaAPkYn3w5iPB8fLhwKzW6DdIoraxCF6JouMnY9irqjZhx8J+PBDoA8/BvvQLOhjADJ/fRLznMNj8olAzvlUSPl9KqiojS/Q+xAynj4T8utnESjq2UA/fA7zQ00+SkX9OXj8zPJFUpDwFwKK+suYK2q2+8tkk4NB/UaqqGfDgi2Xd9AVUdRf+V++DirqrxyK+usIFDUiaxlF/RUw6L8WGlx01kfa/N+Yz6Y+85MGWlF/BvQhMvF+E/Px4Hj5RmB2C7RbRFGbOETPZJGx823MFTX78FsBH34D9OF3YB+aBX0MQOav72Oec3hMvhfIOT8IKb8fBBW18QV6H0LG049Cfv0xAkV9FNAPP8H8UB7pXd8/gcfPLD8nBQn/LKCof4m5oma7f0k2ORjUb6SK+ijcaafI7vr+1f/yW1BR/+pQ1L9FoKgRWcso6l+BQf+b0OCisz7S5t9jPpv60U8aaEX9I9CHyMT7R8zHg+PlD4HZLdBuEUVt4hA9k0XGzp8xV9Tswz8FfPgH0Id/gX1oFvQxAJm//o55zuEx+Vsg5/BBBTXW9hyKC1KK2vgCvQ8h46lAyK8FKXlFfSTQD0mYH3LlUSrqJHj8zJJKCRJOpfD9FqbirajZ7sJUk4NB/UaqqI/Eia4aB10RRV3k+7zYZCbzWZRaXFHzStKKGpG1jKIuAgZ9cUpmcNFZH2lzm1S8Z1MFftJAK+oCoA+RibdtzMeD46VtCj+7BdotoqhNHKJnssjYaSfsw3Trln/25XYCPmwL9GEJ2IdmQR8DkPmrNOY5h8ekVCDntBdSfu0FFbXxBXofQsZTmZBfyyJQ1LOAiroDbj5ZEaWi7gAeP7N0TAkS7iigqDvFXFGz3Z2UK+pZMEWdq3bQFVHUnX2fdwkq6s4ORd0lAkWNyFpGUXcGBn2XlMzgorM+0uauMZ9NlflJA62oy4A+RCbebjEfD46XbgKzW6DdIoraxCF6JouMne4xV9Tsw+4CPuwG9OFyShQ1Mn8tH/Ocw2OyvEDOWUFI+a0gqKiNL9D7EDKeegj5tUcEinomUFGvCPNDPtK3Z60IHj+zrJQSJLySgKJeOeaKmu1eWbminglT1JWRvT1rFd/nPYOKehWHou4ZgaJGZC2jqFcBBn3PlMzgorM+0uZVYz6b6uEnDbSi7gH0ITLx9or5eHC89BKY3QLtFlHUJg7RM1lk7PSOuaJmH/YW8GEvoA//o0RRI/PXajHPOTwmqwnknD5Cyq+PoKI2vkDvQ8h46ivk174RKOojgIq6n1JF3Q88fmZZPSVIeHUBRd0/5oqa7e6vXFEfoVBRD/B9PjCoqAc4FPXACBQ1ImsZRT0AGPQDlShqpM1rxHw21ddPGmhF3RfoQ2TiHRTz8eB4GSQwuwXaLaKoTRyiZ7LI2Bkcc0XNPhws4MNBQB+uqURRI/PXkJjnHB6TIQI5Jy2k/NKCitr4Ar0PIePJE/KrF4GiPhyoqDMwP5RH+qzvDHj8zJJNCRLOCijqXMwVNdudU66oD4cp6urInvVd7vu8Iqioyx2KuiICRY3IWkZRlwODviIlM7jorI+0uTLmsynPTxpoRe0BfYhMvPmYjwfHS15gdgu0W0RRmzhEz2SRsVMVc0XNPqwS8GEe6MO1lChqZP5aO+Y5h8dkbYGcs46Q8ltHUFEbX6D3IWQ8DRXy69AIFPVhQEW9Lk5R10WpqNcFj59Z1ksJEl5PQFEPi7mi/meglCvqw3CKOptwLJC+A4p6uO/zEUFFPdyhqEdEoKgRWcso6uHAoB+RkhlcdNZH2rx+zGdTQ/2kgVbUQ4E+RCbekTEfD46XkQKzW6DdIoraxCF6JouMnVExV9Tsw1ECPhwJ9OEGShQ1Mn9tGPOcw2OyoUDO2UhI+W0kqKiNL9D7EDKeRgv5dXQEiroRqKg3hvkhE+k16o3B42eWTVKChDcRUNSbxlxRs92bKlfUjTBFXRfZNeoxvs/HBhX1GIeiHhuBokZkLaOoxwCDfmxKZnDRWR9p82Yxn02N9pMGWlGPBvoQmXg3j/l4cLxsLjC7BdotoqhNHKJnssjY2SLmipp9uIWADzcH+nBLJYoamb+2innO4THZSiDnbC2k/LYWVNTGF+h9CBlP44T8Oi4CRX0oUFFvA/NDNhulot4GPH5m2TYlSHhbAUW9XcwVNdu9nXJFfShMUdfWOeiKKOrtfZ+PDyrq7R2KenwEihqRtYyi3h4Y9ONTMoOLzvpIm3eI+WxqnJ800Ip6HNCHyMS7Y8zHg+NlR4HZLdBuEUVt4hA9k0XGzk4xV9Tsw50EfLgj0Ic7K1HUyPy1S8xzDo/JLgI5Z1ch5beroKI2vkDvQ8h4qhbya3UEinoGUFHXwPxQH+k16hrw+JmlNiVIuFZAUdfFXFGz3XXKFfUMmKL2IrtGXe/7vCGoqOsdirohAkWNyFpGUdcDg74hJTO46KyPtHm3mM+mqv2kgVbU1UAfIhPv7jEfD46X3QVmt0C7RRS1iUP0TBYZO3vEXFGzD/cQ8OHuQB/uqURRI/PXXjHPOTwmewnknL2FlN/egora+AK9DyHjaR8hv+4TgaKeDlTUE2B+yEWqqCeAx88s+6YECe8roKj3i7miZrv3U66op8MUdU1kinqi7/NJQUU90aGoJ0WgqBFZyyjqicCgn5SSGVx01kfaPDnms6l9/KSBVtT7AH2ITLxTYj4eHC9TBGa3QLtFFLWJQ/RMFhk7U2OuqNmHUwV8OAXow/2VKGpk/jog5jmHx+QAgZxzoJDyO1BQURtfoPchZDxNE/LrtAgU9SFARX0QzA+VVVEq6oPA42eWg1OChA8WUNSHxFxRs92HKFfUh8AUdb7SQVdEUU/3fT4jqKinOxT1jAgUNSJrGUU9HRj0M1Iygws/jwq0+dCYz6am+UkDrainAX2ITLyNMR8PjpdGgdkt0G4RRW3iED2TRcbOYTFX1OzDwwR82Aj04eFKFDUyfx0R85zDY3KEQM6ZKaT8ZgoqauML9D6EjKdZQn6dFYGiPhioqI/EXaGJVFEfCR4/sxyVEiR8lICinh1zRc12z1auqA+GKepcZIp6ju/zuUFFPcehqOdGoKgRWcso6jnAoJ+bkhlcdNZH2nx0zGdTs/ykgVbUs4A+RCbeeTEfD46XeQKzW6DdIoraxCF6JouMnfkxV9Tsw/kCPpwH9OExShQ1Mn8dG/Ocw2NyrEDOOU5I+R0nqKiNL9D7EDKejhfy6/ERKOqDgIr6BNw16nSUivoE8PiZ5cSUIOETBRT1gpgrarZ7gXJFfRBMUVelHXRFFPVJvs9PDirqkxyK+uQIFDUiaxlFfRIw6E9OyQwuOusjbT4l5rOp4/2kgVbUxwN9iEy8p8Z8PDheThWY3QLtFlHUJg7RM1lk7JwWc0XNPjxNwIenAn14uhJFjcxfZ8Q85/CYnCGQc84UUn5nCipq4wv0PoSMp7OE/HpWBIp6GlBRn42bT3pRKuqzweNnlnNSgoTPEVDU58ZcUbPd5ypX1NNgirqiwUFXRFGf5/v8/KCiPs+hqM+PQFEjspZR1OcBg/78lMzgorM+0uYLYj6bOstPGmhFfRbQh8jEe2HMx4Pj5UKB2S3QbhFFbeIQPZNFxs5FMVfU7MOLBHx4IdCHFytR1Mj8dUnMcw6PySUCOedSIeV3qaCiNr5A70PIeLpMyK+XRaCoDwQq6sthfshF+vasy8HjZ5YrUoKErxBQ1FfGXFGz3VcqV9QHwhR1TWRvz7rK9/nVQUV9lUNRXx2BokZkLaOorwIG/dUpmcFFZ32kzdfEfDZ1mZ800Ir6MqAPkYn32piPB8fLtQKzW6DdIoraxCF6JouMnetirqjZh9cJ+PBaoA+vV6KokfnrhpjnHB6TGwRyzo1Cyu9GQUVtfIHeh5DxdJOQX2+KQFEfAFTUN8P8UB/pNeqbweNnlltSgoRvEVDUt8ZcUbPdtypX1AfAFLUX2TXq23yf3x5U1Lc5FPXtEShqRNYyivo2YNDfnpIZXHTWR9p8R8xnUzf5SQOtqG8C+hCZeO+M+XhwvNwpMLsF2i2iqE0comeyyNi5K+aKmn14l4AP7wT68G4lihqZv+6Jec7hMblHIOfcK6T87hVU1MYX6H0IGU/3Cfn1vggU9f5ARX0/zA8N5VEq6vvB42eWB1KChB8QUNQPxlxRs90PKlfU+8MUdbrGQVdEUT/k+/zhoKJ+yKGoH45AUSOyllHUDwGD/uGUzOCisz7S5kdiPpu6z08aaEV9H9CHyMT7aMzHg+PlUYHZLdBuEUVt4hA9k0XGzmMxV9Tsw8cEfPgo0IePK1HUyPz1RMxzDo/JEwI550kh5fekoKI2vkDvQ8h4ekrIr09FoKinAhX10zA/VEV61/fT4PEzyzMpQcLPCCjqZ2OuqNnuZ5Ur6qkwRV0R2V3fz/k+fz6oqJ9zKOrnI1DUiKxlFPVzwKB/PiUzuOisj7T5hZjPpp7ykwZaUT8F9CEy8b4Y8/HgeHlRYHYLtFtEUZs4RM9kkbHzUswVNfvwJQEfvgj04ctKFDUyf70S85zDY/KKQM55VUj5vSqoqI0v0PsQMp5eE/LraxEo6ilARf067hp1pM/6fh08fmZ5IyVI+A0BRf1mzBU12/2mckU9Baaovcie9f2W7/O3g4r6LYeifjsCRY3IWkZRvwUM+rdTMoOLzvpIm9+J+WzqNT9poBX1a0AfIhPvuzEfD46XdwVmt0C7RRS1iUP0TBYZO+/FXFGzD98T8OG7QB++r0RRI/PXBzHPOTwmHwjknA+FlN+Hgora+AK9DyHj6SMhv37k+zVKdTk5ibXFLB+nBAl/LKAuP4m5umS7PxFQly6uiB3kE4GdGLjjiY93XH2ItPtTJZOJj4A2fxbzyQTb+qnAZOLzmE++eVw+F845rfXhF0IThy/+BxOHSUIThy9TgoS/FJg4fBXziQPb/ZWSiQMH8lcCOzFwxxMf77j6EGn310omDl8Abf5vzCcObOvXAhOHb2I+ceBx+UY457TWh98KTRy+Tclfw58IvIb/HXAfinKy9F1KZrL0fUqQ8PcCk6UfYj5ZYrt/iGiylG7d4n3rc0VfOvwWOEbI8f4x5gdQTnQ/ChxAf4r5AZRt/knA7p+FDno/O24BQftEeswQ+/gPApMe5P7+S8zjnn34i4APfwT68FclQgt5zPkt5scJHpPfBPLl70L58nfBy73N+SLdusVDxhNzK/ZtX50C/y+/3N8q8w2Jbf2yZ5UzVjlrlXNWudwqV1jlSquct8pVVnktq7y2VV7HKg+1yuta5fWs8jCrPNwqj7DK61vlkVZ5lFXewCpvaJU3ssqjrfLGVnkTq7ypVR5jlcda5c2s8uZWeQurvKVV3soqb22Vx1nlbazytlZ5O6u8vVUeb5V3sMo7WuWdrPLOVnkXq7yrVa62yjVWudYq11nleqvcYJV3s8q7W+U9rPKeVnkvq7y3Vd7HKk+wyvv65V6JhQvXHWe1H2uVj7HK863yPKt8tFWea5XnWOXZVvkoq3ykVZ5llWda5SOs8uFW+TCr3GiVD7XKM6zydKt8iFU+2CofZJWnWeUDrfIBVnl/qzzVKk+xypOt8iSrPNEv/2npVjMevAzzP9OtW7w/wdq9OZ6t7fsv2HEwm5Pk+fey86wLVjC3romFVwANV/aDOT71sY5Vfa3y3/465ndcKCAkCalCq95fguca0q1bvH5J4FytEDc2hYUy82a0/1YH+q8A6L8iJf7rD/RfEui/4kLsXD6YGzi+TQ4ossrFVjlVuGhuaEOFtoR2hJIIcsMA4Ni0AY5NqZLYHgj0X1ug/9or8d8aQP+1A/qvTDg3lFo5oL1VLrPKJYHc0IEKHQmdCJ0jyA2DgGPTATg2XZTE9mCg/zoC/ddVif/WBPqvE9B/3YRzQxcrB3S1yt2scudAbuhOheUIyxNWiCA3DAGOTXfg2PQQHpse1hgsZ5WXt8orBMZmRSqsRFiZsIpjbNCatyfOBw2SPFdddp7ZYIVrrHpaY7KiVd7P0uarBsaqFxV6E/5DWM0fq0J/3YLE4gv6/E8vYPwmLZ59fAP7GmPMhQduaAzU9fXr7AWdQHoBd/o+S95XbQt9eX2BA8C+TibcD5VILKU/W+KdEAzKPuCkapZ+wWDkioIWAg8ZLC1w9VpoT/cDBvHqhbBgWOTK4upLsDO3lntfoB+QPu2/FD5taVu2T/tbSbOd5U/bp+nWLd5f4f1lahu8bHl9ZXm6ojpXXleRzdRlKtN1ufIGjwhnqnLkmobaXL4un8k2ZCoztX9h+f0TYyaxmQPJv2e//fIA+hxIWMM/kkb1hJ01hBQOeIwzti8G+UfowcGkyA1/BuoGL0GiTLduWcSJrXvCTkPDIOBOPVhocJNg/yFtXtPqy8tnM5nKLK+Xr0t7uTqa02QydTW5dG26ujZTX5XzqhpymVy2tq62hvqs9hrSDdW1VQ35hbyivCd7TaGZw5BCQcJDCvH9poHBIGV32hKmoH5F7qsc7HNF9+uBg9Uka+43eNSTvEbZWj8MAMZqBiynokpcGaHElS0UJJwVSFy5mCcutjsnlLjMInlBvLU+HQgcn3KlO2u50M5aUShIuEJgZ62M+c7Kdlcq21kHFMYzmebBQV/ij3fe0vEDrXKusOkseHN3aPPdJPxZReuuRVjb/43pe0AzfQ+2+m5pnXXocyhh3UKZfTPnxyh6drkeWLai+UnZPQy4/ySsJQnmORi4bw4H24w+NcH7J3JceJ9cTyB2RkR0qqfVigk4oVs/5rHDuR94Cs7jfWWEQOyMBMcO2o8cM8i5BcfNSAE/FuBs/kcUpBKYC6ItLF5zV+wR28hV1lXX1lVmnZ2jkwvSKf0SOhIqMOi81ZXYnATa3F/IZvRkewB4P2lubNKtW7yBQJ5dkzrGZg2rr0x5dXltfXllbWU2X1tdn83XZCvrKnLV+Yr6mmxdOl1XXtNQn85W11d4dCU6W52tq8qmq3Ll9dUV9emqTLUkz0EJHf4crITnmkp4DlHCM62Ep6eEZ0YJz6wSnjklPMuV8KxQwrNSCc+8Ep5VSniupYTn2kp4rqOE51AlPNdVwnM9JTyHKeE5XAnPEUp4rq+E50glPEcp4bmBEp4bKuG5kRKeo5Xw3FgJz02U8NxUCc8xSniOVcJzMyU8N1fCcwslPLdUwnMrJTy3VsJznBKe2yjhua0Sntsp4bm9Ep7jlfDcQQnPHZXw3EkJz52V8NxFCc9dlfCsVsKzRgnPWiU865TwrFfCs0EJz92U8NxdCc89lPDcUwnPvZTw3FsJz32U8JyghOe+Snjup4TnRCU8JynhOVkJzylKeE5VwnN/JTwPUMLzQCU8pynheZASngcr4XmIEp7TlfCcoYTnoUp4NirheZgSnocr4XmEEp4zlfCcpYTnkUp4HqWE52wlPOco4TlXCc+jlfCcp4TnfCU8j1HC81glPI9TwvN4JTxPUMLzRCU8FyjheZISnicr4XmKEp6nKuF5mhKepyvheYYSnmcq4XmWEp5nK+F5jhKe5yrheZ4Snucr4XmBEp4XKuF5kRKeFyvheYkSnpcq4XmZEp6XK+F5hRKeVyrheZUSnlcr4XmNEp7XKuF5nRKe1yvheYMSnjcq4XmTEp43K+F5ixKetyrheZsSnrcr4XmHEp53KuF5lxKedyvheY8Snvcq4XmfEp73K+H5gBKeDyrh+ZASng8r4fmIEp6PKuH5mBKejyvh+YQSnk8q4fmUEp5PK+H5jBKezyrh+ZwSns8r4fmCEp4vKuH5khKeLyvh+YoSnq8q4fmaEp6vK+H5hhKebyrh+ZYSnm8r4fmOEp7vKuH5nhKe7yvh+YESnh8q4fmREp4fK+H5iRKenyrh+ZkSnp8r4fmFEp5fKuH5lRKeXyvh+V8lPL9RwvNbJTy/U8LzeyU8f1DC80clPH9SwvNnJTx/UcLzVyU8f1PC83clPP9QwvNPJTz/UsLzbyU8uUMNPAuU8Ewq4ZlSwrNQCc8iJTyLlfBso4RnWyU82ynhWaKEZ6kSnu2V8CxTwrODEp4dlfDspIRnZyU8uyjh2VUJz25KeHZXwnM5JTyXV8JzBSU8eyjhuaISnisp4bmyEp6rKOHZUwnPVZXw7KWEZ28lPP+jhOdqSnj2UcKzrxKe/ZTwXF0Jz/5KeA5QwnOgEp5rKOE5SAnPwUp4rqmE5xAlPNNKeHpKeGaU8Mwq4ZlTwrNcCc8KJTwrlfDMK+FZpYTnWkp4rq2E5zpKeA5VwnNdJTzXU8JzmBKew5XwHKGE5/pKeI5UwnOUEp4bKOG5oRKeGynhOVoJz42V8NxECc9NlfAco4TnWCU8N1PCc3MlPLdQwnNLJTy3UsJzayU8xynhuY0Sntsq4bmdEp7bK+E5XgnPHZTw3FEJz52U8NxZCc9dlPDcVQnPaiU8a5TwrFXCs04Jz3olPBuU8NxNCc/dlfDcQwnPPZXw3EsJz72V8NxHCc8JSnjuq4Tnfkp4TlTCc5ISnpOV8JyihOdUJTz3V8LzACU8D1TCc5oSngcp4XmwEp6HKOE5XQnPGUp4HqqEZ6MSnocp4Xm4Ep5HKOE5UwnPWUp4HqmE51FKeM5WwnOOEp5zlfA8WgnPeUp4zlfC8xglPI9VwvM4JTyPV8LzBCU8T1TCc4ESnicp4XmyEp6nKOF5qhKepynheboQz2SAZzZdkcvVV2bqvaxXnc5U1eTL07nymoq8l/fK8+V1mXw2W5/P5Suraqoq01VeLlvvNZRXZRv8vvsAbT4jIpvTrVu8Mwtw/ls+qSMez1Ky35ythOc5Snieq4TneUp4nq+E5wVKeF6ohOdFSnherITnJUp4XqqE52VKeF6uhOcVSnheqYTnVUp4Xq2E5zVKeF6rhOd1Snher4TnDUp43qiE501KeN6shOctSnjeqoTnbUp43q6E5x1KeN6phOddSnjerYTnPUp43quE531KeN6vhOcDSng+qITnQ0p4PqyE5yNKeD6qhOdjSng+roTnE0p4PqmE51NKeD6thOczSng+q4Tnc0p4Pq+E5wtKeL6ohOdLSni+rITnK0p4vqqE52tKeL6uhOcbSni+qYTnW0p4vq2E5ztKeL6rhOd7Sni+r4TnB0p4fqiE50dKeH6shOcnSnh+qoTnZ0p4fq6E5xdKeH6phOdXSnh+rYTnf4V4JgM8W/v/uEKgzd8osbkIaPO3SmwuBtr8nRKb2wBt/l6JzW2BNv+gxOZ2QJt/VGJzCdDmn5TYXAq0+WclNrcH2vyLEpvLgDb/qsTmDkCbf1Nic0egzb8rsbkT0OY/lNjcGWjzn0ps7gK0+S8lNncF2vy3Epu7AW1mchps7g60uUCJzcsBbU4qsXl5oM0pJTavALS5UInNPYA2FymxeUWgzcVKbF4JaHMbJTavDLS5rRKbVwHa3E6JzT2BNpcosXlVoM2lSmzuBbS5vRKbewNtLlNi83+ANndQYvNqQJs7Am1OJRZeH//cv0jej7A6oT9hAGEgYQ3CIMJgwpqEIbxdgkfIsG8IOUI5oYJQScgTqghrEdYmrEMYSliXsJ7vi+GEEYT1CSMJowgbEDYkbEQYTdiYsAlhU8IYwljCZoTNCVsQtiRsRdiaMI6wDWFbwnaE7QnjCTsQdiTsRNiZsAthV0I1oYZQS6gj1BMaCLsRdifsQdiTsBdhb8I+hAmEfQn7ESYSJhEmE6YQphL2JxxAOJAwjXAQ4WDCIYTphBmEQwmNhMMIhxOOIMwkzCIcSTiKMJswhzCXcDRhHmE+4RjCsYTjCMcTTiCcSFhAOIlwMuEUwqmE0winE84gnEk4i3A24RzCuYTzCOcTLiBcSLiIcDHhEsKlhMsIlxOuIFxJuIpwNeEawrWE6wjXE24g3Ei4iXAz4RbCrYTbCLcT7iDcSbiLcDfhHsK9hPsI9xMeIDxIeIjwMOERwqOExwiPE54gPEl4ivA04RnCs4TnCM8TXiC8SHiJ8DLhFcKrhNcIrxPeILxJeIvwNuEdwruE9wjvEz4gfEj4iPAx4RPCp4TPCJ8TviB8SfiK8DXhv4RvCN8SviN8T/iB8CPhJ8LPhF8IvxJ+I/xO+IPwJ+Evwt8E3ukKCElCilBIKCIUE9oQ2hLaEUoIpYT2hDJCB0JHQidCZ0IXQldCN0J3wnKE5QkrEHoQViSsRFiZsAqhJ2FVQi9Cb8J/CKsR+hD6EvoRVif0JwwgDCSsQRhEGExYkzCEkCZ4hAwhS8gRygkVhEpCnlBFWIuwNmEdwlDCuoT1+PwfYThhBGF9wkjCKMIGhA0JGxFGEzYmbELYlDCGMJawGWFzwhaELQlbEbYmjCNsQ9iWsB1he8J4wg6EHQk7EXYm7ELYlVBNqCHUEuoI9QR+tzy/t53fic7vG+d3efN7svkd1Px+Z353Mr+XmN/5y+/T5XfV8ntg+R2r/P5Sfjcov3eT32nJ74vkdzHyew75HYL8fj5+9x2/V66RwO9D43eN8Xu8+B1Z/P4pfrcTvzeJ30nE7/vhd+nwe2r4HTD8fhV+dwm/F4TfucHvs+B3RfB7GPgdB/z+AH42Pz/3np8pz89r52eh87PB+bnb/BxqfsYzPz/5XAI/95efqcvPq+VnwfJzVvkZpvx8UH72Jj/Xkp8Zyc9j5Gcd8nME+Rl9/Pw7frYcP7eNn4nGzxvjZ3nxc7L4GVT8fCd+dhI/l4if+cPP0+Fn1fBzYPgZK/z8knsJ/NwNfqYFPy+Cn8XAzzngZwjw//P5v+/8v3L+zzb/H5r/a8z/4+X/yPL/T/m/nfy/Sf5PIv/fj/9Lx/9T4/+A8f+r+L9L/L8g/s8N/5+F/yvC/8Pg/zjw/wf43ny+753vKef7tfleaL7PmO/h5ftj+d5Tvq+Tj4t8PyLf68f30fE9anz/F98PxfcH8f0yfP8I30/B9xfw9Xa+/szXY/n6JF+v4+tXfD2Hr2/w+X4+/80TDD4/yucL+fwZn0/i8yt8voH1N+tR1mesV3j+zvNZnt/xfIeP/8mFKSTB93jx0i/RtPjdJ1J+O98TxfcI8T0zfA8J31PB9xjwNXe+Bs3XZPkaJV+z42tYfE2Hr3HwOX8+B87nhPkcKZ8z5HNofE6Jz7HwOQfW4KxJWaOxZulF6E3gOR7PefgZ930Tiy/rW+XO/mf3D4f3mPj4JaPs9br4nw+X73fovr0XafrnGNfc704Pabs8pO3KkLY7Q9ruDml7OqTt2ZC2d0Pa3g9p+y6k7YeQNj4GNddWHNK2XEjbCiFt/UPaBoa0rRXStk5I26YhbWND2nYOads1pG2/kLZJIW2Hh7TNDGlbENJ2ckjbxSFtl4a03RrSdntI2+MhbU+GtL0Z0vZ2SNvXIW3fhLQZEehqS4a0dQlp6xbS1iekrV9IW0VIWz6kbaOQto1D2saHtO0Y0rZ3SNuEkLYZIW2NIW1zQtpOCGk73W97YsEzD186u7rObjs35He3+W3nXNbzppU+TI63224PabsnpO2+kLa3/bZbhp13/oDL54809W38z+X92G7nfzfnNLia5wbD/O/p1i1eO6tfdP95OpfSLrHoAuafbZdomjNJ+cf0KdB/2oz3+o1N/Qdt4aXM/15g+dL8hueFq1rr8TLS6q8g0DbKsS3TtkGje9u8bGi1FQbaNrLaigJto6224kDbxlZbm0DbJlZb20DbplZbu0DbGKutJNA21morDbRtZrW1TzSVGR0TTYs571Zm1Rk/mnjpZP0etz+Vp03/nQX6T6dzaWNTqrGp/44BPxVabZ0CbUVWm+HIY/dFYL3jrPU6BHzXUcR3uZzk2JDv6ro6+HeyfPCT5QN7/zLr2j4olOFYXxDYXiKxaG5LBLZfkhDNf15BYHuGT9A/Zv/i/dLEy271U4ZPnbL7tntMmVA/ebLN3u5xjFVvt9tLcJ3gesH12znaC3BeSZclFvdKMEKKrHpghHhLGiFm+yUJyYhtipCiAJ+gf4IZuFjGP+mCQP82n2KHf8xYtnG0mb7M0a3I6stev9iy0V7fLpvf23Xl/mcnR5/B2G2TWNweu874l7kM8csdHfYUBvp1jVuRo99Ojt8HfWj/rqCZT7OdYF1wOy7Orv0aGTuy2T2dlo39ptlwG5n+a804Jx1jwzYNt+qb22+SgXVMu73+41afRnoFt51ILHuMlSUW3zeD+dtWXkAf1i1p/jbbL0ksnlMk8ne7AJ+gf4L5u8RqG4bh8u/+USpja21BoH/b1lKH702ctHe0mb7+nVlbfdnrl1r+s9e3y+b3dt04/7OTo8+SAIf2icXtsevsY8NmgX7t/dGMd0eHrW0D23TFSzvHNjs5fh/0rx33dj7ZoZlt2r62f9vGarfXv9bqc+eAjfbvk4E2l28KHG3B3NaS/cEc6Dq2Fzj6CuZVe3075xcuhR3obRcHtl3o2LbwcTATxjXMtrAc6LLNtrtdyO/s9ex1ih2+sdtdfg0ep4R8mA3zSZgPSxzrt3PY0dHhp5JobMuFcQ2zzXXcKAmxzba7NBrbysO4htnmOoaUhthm290+5Hf2evY6xQ7f2O0uv0YU+xVhPgnzYZlj/fYOOzo6/FQWjW2VYVzDbOvgWL8sxDbb7g7R2JYP4xpmm+vscYcQ22y7O4b8zl7PXqfY4Ru73eXXiGK/KswnYT7s5Fi/o8OOjg4/dYrGtuowrmG2dXas3ynENtvuztHYVhPGNcy2Lo71O4fYZtvdJfA72zZ7PRcXe/3m+igI9OGas5vzRMLnXWvD/Os6E76k/i0K2Obyb5nDtqCGsucaZYG2sgAnu832ZfD8iOs8T/DcN5fbBtrsOV37QJvreFiWWHzsSwJt9nygQ6DNlUuCV3G43CbQZs+vSwNt9rHZ7M+lCffcLnhuxLYReQUreOxuTge3t9rt9W/yP3l8/rDWt3+TSCxZXLc01wnus2FznTIRfzWd7+nQgr9sf9rr3+nwl+sKbDvLHl4KG0XsqWMef1s8guNWZG23pTHiZWnneMZnnRKL73elgfXCdKMrz5vfFzezvn3ux17/Ef+TfdOtYFF+tn3BPOTq2z7n5NKnRUtgo73N4PWcEoeNyRAbzfrPOGyUPVfalGvsXOLS86UBzmb9FyzOwVzj0nthuaYlbWr4tEabFrRgn91HiWPbdkwIjks6bFySDt7BcXnL/2wpp9nn6ngpbBSxx3PlNHu/CuY013i4zjsvaewEz9OGnWd3naOztxfMaS3t7/b1MXv9T/1PV04LmwO6+g5el+OlTWNiETv++bTqjM9NXLS11w+0tbPaChsX3U6J/73Q2o7dl+FRFFj/R/+7mXcVW78xv+/k2H5xYPuL8HbU2f4K9pVy1NnXUb72yxxLkvtIZT6dNvyM74sSi+bLRGD7RYH1f/e/B8/F8WdrnmTcUFntNWSrG6rLq+vqcrXVXQL92z4rFdh+fb6qLl3VUF/teV6mLl3f0vZd8WTnPF5MTNoxa69v+isKrJ/yO+DYKPLLwbvu7O3xel1D1ito5vOfPhx1hY2L1rli2d7Hzfpm2yWNi3M0baVWm52PeWnvf7f9ZfdleBQF1u/sd2DGxN4vze87ObbfNrD9RXg76oL7eKlj/VLH+jw+Jf6PTNzatiOvwduxILGf5MqrK2urKz2vKufV57zylvaT3n5Z993tuQp7XiDA///vbk8snGfY55t4GWn1VxBoG+XYlqSd9p3FQvd1Zbo6+JttsX9W8sspx3rBfdw1Twwe61192P0E/WqP27Bls9kLVgTtDLPNtDV3H2JhM7+37ydMOPpwjWnCsY1UM7919ZsMsaOl39q+DzuHqmHO2Mv//r+eM5p/zvz/sSh0yQofKzLS98a6jkWufBp2LHLdIzrSb3Mdp+xj0b/z5oTcMZ3ioFx4nLyuieaPH+yDHk2uWcSvRYnmjyNFgXW7+Z88b+3cTH/FIf25rs3Yv1veL7dz9JEA+srFo8DBw3XO+F/tkIh/Lu/pf/9f5/IKv6w8l5f/fy4PX5Y0l6cC67l+E5bvhXO1tG7worqHM+y/Wfb2w/75GPxMJBY/D2VvK6p/Jrpsc11LCvtfUVhfRUvZ1/9yTG1fB//JbZ/nTAbaCq224L/DixoXt5HnET2t9cLmGwMCfpHMyVK5gJeuiebnM6Yu7tdV+vvf43xdpbdf5vkCx0/a6qu5uLfn+6bs+v9B8F4x6f8fpBxc7Zxhtt8+0XRNcr/q2r22rJ8yddKEyXaqDf404TDZtBVY9c0deoO/SVnr24uG6a35G+3/enpr3+pp80SnIvt2FYH+/50+C/2NNGv/5SgR2Jbtt+D0wi4bTsFbr8Bcq/9N7RaHVGCbQY72OoWJxZdk4Htwn0wtwbrB7dlt9u3Uzf0ueOtSsC44fUg41v/3cOB/FjXTl/23PHv9NoF1pcawq4NTQTPb7i7D4d99qptM/2nXPtXdKncL2GnH1TAQB9OfiYEiB6fg5XN7qmjzK8Dz84JcXPnFLCZmull13Zvhah930DKdF6G/Qztjxv5LXGmgzYydK6cVNPM9GfgMW7cgpF9XHjJ9mrGy+Ro7/g9P9Q4Vu9EDAA==",
-      "debug_symbols": "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",
+      "bytecode": "H4sIAAAAAAAA/+x9B5gU1bb1CEPOOecMAnMmkzNIEBREch5yUqIEAUHJkgUEBAQkCwgqCgoqKEhUUKKCgoKKgoqKgsBf59p9bbHve747a/Vf66P6++qbop+3Xu111t5rr92nq+8J++N1f9GwsH75/ji/xzmS+v4mcY6Cd7zn/xt4nizIf5cmyHvpgryXIch7mYK8l905qt/xXv4g/12BIO8VDPJeoSDvFQ3yXvEg75UMgkGpIO+VCfK/LRvkvysX5L2IIP/byCD/XVSQ92KC/G/jgvx38UHeqxTkf1slyH9XNch71YP8b2sG+e9qBXmvTpD36vr+Br78/67u+xsVERsd3TUusquJMp0iIit0jo+JiI7pHBtv4k1MfExCZHxUVNf46Pi4Cp0rxEVUMNFRXU23mApR3SL+eJkkf14rIlGvyC7M+4z8r+8zMurOd+y9ZXGO8IB7tTjc8p0XC/vzvHjAeaTvv/H/76Kcf0c7R4xzxCb5833/K+kdGEQk7mVKAK8VlQS3NnEwDkVEMPErCbxWNBC/eBH8SgGvFQPErwIQv2C1IS6gNsQHnFcIOI+9ozZUdP5dyTkqO0eVENSG0sBrVQSuTVURbpcBXqsSEL9qIvjdC7xWZSB+1cm1oWpADagWcF494LzKHbWhhvPvms5Ryzlqh6A2lAVeqwZwbeqIcLsc8Fo1gfjVFcGvPPBatYD41SPXhjoBNaBuwHm9gPPad9SG+5x/13eOBs7RMAS1IQJ4rfuAa9NIhNsGeK36QPzuF8EvEnitBkD8GpNrQ6OAGnB/wHnjgPOGd9SGJs6/H3COB52jaQhqQxTwWk2Aa9NMhNvRwGs9AMTvIRH8YoDXehCIX3NybWgWUAMeCjhvHnDe9I7a8LDz7xbO0dI5WoWgNsQCr/UwcG1ai3A7DnitFkD82ojgFw+8Vksgfm3JtaF1QA1oE3DeNuC81R21oZ3z7/bO0cE5OoagNlQAXqsdcG06iXC7IvBa7YH4dRbBrxLwWh2A+HUh14ZOATWgc8B5l4DzjnfUhgTn312do5tzdA9BbagMvFYCcG16iHC7CvBaXYH49RTBryrwWt2A+PUi14YeATWgZ8B5r4Dz7nfUht7Ov/s4R1/n6BeC2lANeK3ewLXpL8Lt6sBr9QHi94gIfjWA1+oLxO9Rcm3oH1ADHgk4fzTgvN8dtWGA8++BzjHIOQaHoDbUBF5rAHBthohwuxbwWgOB+A0Vwa828FqDgPg9Rq4NQwJqwNCA88cCzgffURuGOf8e7hwjnGNkCGpDHeC1hgHX5nERbtcFXms4EL9RZG4/HsDhUQHnIwLOR97B7dHOv8c4xxPOMTYIt5OA16ZoGA7PcTg8TeA+dXvdgnfggN7//STs3iMjmff51H99nyb2zneCcfbJJP/7PvWn7uDseOffE5xjonNMCkE9Ru5THw+sJ5NF6jFyn/oEIH5TRPBD7lOfCMRvKlnPJgfUhikB51MDzifdURuedv49zTmmO8eMENQG5D71p4FrM1OE28h96tOA+M0SwQ+5T306EL/Z5NowM6AGzAo4nx1wPuOO2jDH+fczzjHXOeaFoDYg96nPAa7NfBFuI/epPwPE71kR/JD71OcC8VtArg3zA2rAswHnCwLO591RGxY6/17kHM85x+IQ1AbkPvWFwLVZIsJt5D71RUD8lorgh9yn/hwQv+fJtWFJQA1YGnD+fMD54jtqwzLn38udY4VzvBCC2oDcp74MuDYrRbiN3Ke+HIjfKhH8kPvUVwDxW02uDSsDasCqgPPVAecv3FEb1jj/Xusc65xjfQhqA3Kf+hrg2rwowm3kPvW1QPw2iOCH3Ke+DojfRnJteDGgBmwION8YcL7+jtqwyfn3S86x2Tm2hKA2IPepbwKuzcvktXk5YA1eCjjfHHC+5Y61ecX596vOsdU5XguyNujP0V6HYWC6Mu9z239/nwkR/2CtXg9YE/u9AP95pYDzbXes1Xbn3284x5vOsSMEeYTc070dmEc7RTQCuaf7DSB+b4ngVxV4rTeB+L1NruM7A2rDWwHnbwec77ijNrzj/HuXc+x2jndDUBuQe7rfAa7NeyLcrg681i4gfntE8KsBvNZuIH57ybXhvYAasCfgfG/A+bt31Ib3nX/vc479znEgBLWhJvBa7wPX5qAIt5F7uvcB8Tskgh9yT/d+IH6HybXhYEANOBRwfjjg/MAdteED598fOscR5zgagtqA3NP9AXBtPiKvzUcBa/BhwPmRgPOjd6zNx86/jznHcec4EQJvfhLnzbsx7/PUf3+f/+iZ0ScD1uSVgPOPA85P3bFWp51/f+IcnzrHGd9ahd8R//+ESUTiXuY0kL/pA+7zbJI//n7m+/u57+8539/zvr9f+P5+6ft7wff3ou/vV76/X/v+fpPE9zxN3/+fS86/v3WO75zjsnNccY7vneMH5/jROa46x0/O8bNz/OIc15zjV+f4zTmuO8cN5/jdOW7adXGO2/b/j1O87nGOJM6R1DnCnSOZcyR3jhTOkdI5UjlHaudI4xxpnSOdc6R3jgzOkdE5MjlHZufI4hxZnSObc2R3jhzOkdM5cjlHbufI4xx5nSOfc+R3jgLOUdA5CjlHYeco4hxFnaOYcxR3jhLOUdI5SjlHaV+RLePfeO//+3mSvz88/osg710M8t43Qd6zIKe8471vg7z3XZD3Lgd570qQ974P8t4PQd77Mch7V4O891OQ934O8t4vQd67FuS9X4O891uQ964Hee9GkPd+D/LezSDv3Qry3u0g79mTO9+7J8h7SYK8lzTIe+FB3ksW5L3kQd5LEeS9lEHeSxXkvdRB3ksT5L20Qd5LF+S99EHeyxDkvYxB3ssU5L3MQd7LEuS9rEHeyxbkvexB3ssR5L2cQd7LFeS93EHeyxPkvbxB3ssX5L38Qd4rEOS9gkHeKxTkvcJB3isS5L2iQd4rFuS94kHeKxHkvZJB3isV5L3SvvesCKcI+7ORDXzd4/tb3fc3InEvqAgHuV3QtSN51zZ/NFR+bAv6zu91wC/rHOWco7xzRDiHcY5I54hyjmjniHGOWOeIc45456jgHBWdo5JzVHaOKs5R1TmqOUd156jhHDWdo5Zz1HaOOs5R1znqOcd9zlHfORo4R8N/F0ff33uDkKVskPfKBXmvfJD3IoK8Z4K8Fxnkvagg70UHeS8myHuxQd6LC/JefJD3KgR5r2KQ9yoFea9ykPeqBHmvapD3qgV5r3qQ92oEea9mkPdqBXmvdpD36gR5r26Q9+oFee++IO/VD/JegyDvNfS9F/gq5Ptb3fc3InGvvxSdxDormxuJvVbXbvYVYcqCrmVjLAe51h94lU/8tSK7+ctdYq8V/W/sjUnctSIC1tFEJuZakX/hhIn6768VcQe/TPR/ea3Ybn/jqon5764VH4T3Jva/uVZ80Bwycf/3a8X9h3w08f/Xa8X9x9w2Ff5v14r8H+qEqfh/uVbc/1hzTKV/fq0u/0v9MpX/6bXi/tdaaKr8s2tF/IO6aqr+k2tF/KMabar979eK+Yf13lT/364V/Y+1w9T4H68V3e3/oEOm5v90rbj/k6aZWv/5WvH/R300tf/DtSp0+z9rrakT/FoR/4Vum7rBrhXxX/UApt7fr2X+y37C3HfntRL+697E1P/rtaIS0eeYBgHXiuyWqJ7JNEzKMX2+QSmst2uYFHetRrCYoyKsQff3zXe+0Aa9EXCtAu/3/qTEG7YXR1+3MZAMrLgbJ/0TYNB1/0W2VGF/JheTbLjCkECd2ARi0cSH+QN3Tk2a+EgY+N4DQdxtUiKIiXWkTYCkfwC8uIwEbxKkcCQ27iYiatcAuNYPwmKOjQ6l2j1IUrumSYk33JSgds1crnY27mbiatcARrYKXYLcLkXtHvJh3vxOtXsoiNo1D4HaNQCq3UNA0jcnLS666iNjfhhXPe1DGuBK3NhXNJKAOYi0Bi3A3QK6aNk1bkHoktwet5876LhbinSHSI63IteJiMS9jF2TVoQ60QKIYWuBfGlNyJc24A7d36u0CbhXFhZoPrUC8qktCde2Sf/u3NC1qT4Qh3YwHKK7htK5tgOvn//VPinxhtsTnGsHlztXG3cHcedaH0a2zpFBbpfiXDv6MO90p3PtGMS5dgqBc0VULb9z7QgkfSfS4qKrPjLmzi7vSNv6ikZSMIZtgRgiC28Xl6+H5UsXQncLjDuoeCH40oHQySK5k+ByZ2QxTCBg2AWIYVeRqQSyfnVzec2xa9KNUHO6k5xfd6Kj9mOBziEkn3qQcO0RAkd9HxCHnjAc4iJD6ah7gtfP/+qVlHjDvQiOurfLHbWNu7e4o74PRrb4rkFul+Ko+/gw73uno+4TxFH3DYGjRlQtv6PuAyR9X9Lioqs+MuZ+Lu+meviKBtpR9wBiiCy8/V2+HpYv/QndLTBuiqP28xDdySK584jLHbXF8BEChv2BGD4q4qiR9WuAy2uOXZMBhJozkOT8BhIdtR8LdA4h+TSIhOugEDjqekAcBsNw6GpC6agHg9fP/xqSlHjDQwiOeqjLHbWNe6i4o64HI9tfH80HxeQOR/2YD/Nhdzrqx4I46mEhcNSIquV31I8BST+MtLjoqo+MebjLu6lBvqKBdtSDgBgiC+8Il6+H5csIQncLjJviqP08RHeySO6MdLmjthiOJGA4Aojh4yKOGlm/Rrm85tg1GUWoOaNJzm800VH7sUDnEJJPY0i4jgmBo64LxOEJGA5RIXXUT4DXz/8am5R4w2MJjnqcyx21jXucuKOuCyNbl5A56id9mD91p6N+MoijfioEjhpRtfyO+kkg6Z8iLS666iNjHu/ybmqMr2igHfUYIIbIwjvB5eth+TKB0N0C46Y4aj8P0Z0skjsTXe6oLYYTCRhOAGI4ScRRI+vXZJfXHLsmkwk1ZwrJ+U0hOmo/FugcQvJpKgnXqSFw1HWAODwNw6FTSJ93+TR4/fyvaUmJNzyN4Kinu9xR27inizvqOjCyxYbseZczfJjPvNNRzwjiqGeGwFEjqpbfUc8Akn4maXHRVR8Z8yyXd1NTfUUD7ainAjFEFt7ZLl8Py5fZhO4WGDfFUft5iO5kkdyZ43JHbTGcQ8BwNhDDZ0QcNbJ+zXV5zbFrMpdQc+aRnN88oqP2Y4HOISSf5pNwnR8CR10biMOzMBwiK4TSUT8LXj//a0FS4g0vIDjqhS531DbuheKOujaMbAlxQW6X4qgX+TB/7k5HvSiIo34uBI4aUbX8jnoRkPTPkRYXXfWRMS92eTc131c00I56PhBDZOFd4vL1sHxZQuhugXFTHLWfh+hOFsmdpS531BbDpQQMlwAxfF7EUSPr1zKX1xy7JssINWc5yfktJzpqPxboHELyaQUJ1xUhcNS1gDi8AMOhc3woHfUL4PXzv1YmJd7wSoKjXuVyR23jXiXuqGvByBYdH+R2KY56tQ/zNXc66tVBHPWaEDhqRNXyO+rVQNKvIS0uuuojY17r8m5qha9ooB31CiCGyMK7zuXrYfmyjtDdAuOmOGo/D9GdLJI7613uqC2G6wkYrgNi+KKIo0bWrw0urzl2TTYQas5GkvPbSHTUfizQOYTk0yYSrptC4KhrAnF4CYZDTEh3fb8EXj//a3NS4g1vJjjqLS531DbuLeKOuiZu7BSyXd8v+zB/5U5H/XIQR/1KCBw1omr5HfXLQNK/QlpcdNVHxvyqy7upTb6igXbUm4AYIgvvVpevh+XLVkJ3C4yb4qj9PER3skjuvOZyR20xfI2A4VYghq+LOGpk/drm8ppj12QboeZsJzm/7URH7ccCnUNIPr1BwvWNEDjqGkAc3sR9QhMTSkf9Jnj9/K8dSYk3vIPgqHe63FHbuHeKO+oaONPVOcjtUhz1Wz7M377TUb8VxFG/HQJHjahafkf9FpD0b5MWF131kTG/4/Ju6g1f0UA76jeAGCIL7y6Xr4flyy5CdwuMm+Ko/TxEd7JI7ux2uaO2GO4mYLgLiOG7Io4aWb/ec3nNsWvyHqHm7CE5vz1ER+3HAp1DSD7tJeG6NwSOujoQh/dx/WRsKB31++D187/2JSXe8D6Co97vckdt494v7qir48ZOnYLcLsVRH/BhfvBOR30giKM+GAJHjahafkd9AEj6g6TFRVd9ZMyHXN5N7fUVDbSj3gvEEFl4D7t8PSxfDhO6W2DcFEft5yG6k0Vy5wOXO2qL4QcEDA8DMfxQxFEj69cRl9ccuyZHCDXnKMn5HSU6aj8W6BxC8ukjEq4fhcBRVwPi8DEMh/iQ/nrWx+D187+OJSXe8DGCoz7uckdt4z4u7qirwcgWF7Jfzzrhw/zknY76RBBHfTIEjhpRtfyO+gSQ9CdJi4uu+siYT7m8m/rIVzTQjvojIIbIwnva5eth+XKa0N0C46Y4aj8P0Z0skjufuNxRWww/IWB4GojhpyKOGlm/zri85tg1OUOoOWdJzu8s0VH7sUDnEJJPn5Fw/SwEjroqEIfPRR315+D187/OJSXe8DmCoz7vckdt4z4v7qirCjrqL3yYf3mno/4iiKP+MgSOGlG1/I76CyDpvxRx1MiYL7i8m/rMVzTQjvozIIbIwnvR5eth+XKR0N0C46Y4aj8P0Z0skjtfudxRWwy/ImB4EYjh1yKOGlm/vnF5zbFr8g2h5lwiOb9LREftxwKdQ0g+fUvC9dsQOOoqQBy+g+EQE9JnfX8HXj//63JS4g1fJjjqKy531DbuK+KOugqMbJ1C9qzv732Y/3Cno/4+iKP+IQSOGlG1/I76eyDpfyAtLrrqI2P+0eXd1Le+ooF21N8CMUQW3qsuXw/Ll6uE7hYYN8VR+3mI7mSR3PnJ5Y7aYvgTAcOrQAx/FnHUyPr1i8trjl2TXwg15xrJ+V0jOmo/FugcQvLpVxKuv4bAUVcG4vAbzlEnhNJR/wZeP//relLiDV8nOOobLnfUNu4b4o66Ms50RQW5XYqj/t2H+c07HfXvQRz1zRA4akTV8jvq34Gkv0laXHTVR8Z8y+Xd1K++ooF21L8CMUQW3tsuXw/Ll9uE7hYYN8VR+3mI7mShoh3ubkdtMbT3iMbwNhDDe8AY+l9oDUDWryTh7q45dk3sPaJzOilwrQN7qKThPEftxwKdQ0g+hZNwDQ/nO+pKQBySwXCIDOln1MnA6+d/JQ8n3nDycPx1U4S721HbuFOE/wkw6LohddSVYI1fQsg+o07pwzxVeNhf3XPK8L87avsfsR11JaCjTgkkfapwzuKiqz4y5tQu76bCfUUD7ajDgRgiC28al6+H5UsaQncLjJviqP08RHeySO6kdbmjthimJWCYBohhOhFHjaxf6V1ec+yapCfUnAwk55eB6Kj9WKBzCMmnjCRcM4bAUVcEOupMMByiokLpqDOB18//yhxOvOHMBEedxeWO2sadRdxRV4Q56i4JQW6X4qiz+jDPdqejzhrEUWcLgaOuCHTUWYGkzxbOWVx01UfGnN3l3VRGX9FAO+qMQAyRhTeHy9fD8iUHobsFxk1x1H4eojtZJHdyutxRWwxzEjDMAcQwl4ijRtav3C6vOXZNchNqTh6S88tDdNR+LNA5hORTXhKueUPgqCsAHXU+GA5dQ/oZdT7w+vlf+cOJN5yf4KgLuNxR27gLiDvqCjBHbUL2GXVBH+aF7nTUBYM46kIhcNQVgI66IJD0hcI5i4uu+siYC7u8m8rrKxpoR50XiCGy8BZx+XpYvhQhdLfAuCmO2s9DdCeL5E5Rlztqi2FRAoZFgBgWE3HUyPpV3OU1x65JcULNKUFyfiWIjtqPBTqHkHwqScK1ZAgcdTzQUZeC4RAdUkddCrx+/lfpcOINlyY46jIud9Q27jLijjoe5qg7h8xR3+vDvOydjvreII66bAgcdTzQUd8LJH3ZcM7ioqs+MuZyLu+mSvqKBtpRlwRiiCy85V2+HpYv5QndLTBuiqP28xDdySK5E+FyR20xjCBgWB6IoRFx1Mj6FenymmPXJJJQc6JIzi+K6Kj9WKBzCMmnaBKu0SFw1HFARx0DwyGuQigddQx4/fyv2HDiDccSHHWcyx21jTtO3FHHwRx1fFyQ26U46ngf5hXudNTxQRx1hRA46jigo44Hkr5COGdx4XNUYMwVXd5NRfuKBtpRRwMxRBbeSi5fD8uXSoTuFhg3xVH7eYjuZJHcqexyR20xrEzAsBIQwyoijhpZv6q6vObYNalKqDnVSM6vGtFR+7FA5xCST9VJuFYPgaOOBTrqGrhPaELqqGuA18//qhlOvOGaBEddy+WO2sZdS9xRx8IcdXTIHHVtH+Z17nTUtYM46johcNSxQEddG0j6OuGcxUVXfWTMdV3eTVX3FQ20o64OxBBZeOu5fD0sX+oRultg3BRH7echupNFcuc+lztqi+F9BAzrATGsL+KokfWrgctrjl2TBoSa05Dk/BoSHbUfC3QOIfnUiIRroxA46higo74f9xl1RCgd9f3g9fO/GocTb7gxwVE3cbmjtnE3EXfUMTBHXSEiyO1SHPUDPswfvNNRPxDEUT8YAkcdA3TUDwBJ/2A4Z3HRVR8Zc1OXd1ONfEUD7agbATFEFt5mLl8Py5dmhO4WGDfFUft5iO5kkdx5yOWO2mL4EAHDZkAMm4s4amT9etjlNceuycOEmtOC5PxaEB21Hwt0DiH51JKEa8sQOOpooKNuhesnTSgddSvw+vlfrcOJN9ya4KjbuNxR27jbiDvqaJijju0W5HYpjrqtD/N2dzrqtkEcdbsQOOpooKNuCyR9u3DO4qKrPjLm9i7vplr6igbaUbcEYogsvB1cvh6WLx0I3S0wboqj9vMQ3ckiudPR5Y7aYtiRgGEHIIadRBw1sn51dnnNsWvSmVBzupCcXxeio/Zjgc4hJJ8SSLgmhMBRRwEddVfcnseQ/npWV/D6+V/dwok33I3gqLu73FHbuLuLO+oo3JPJEoLcLsVR9/Bh3vNOR90jiKPuGQJHHQV01D2ApO8ZzllcdNVHxtzL5d1Ugq9ooB11AhBDZOHt7fL1sHzpTehugXFTHLWfh+hOFsmdPi531BbDPgQMewMx7CviqJH1q5/La45dk36EmtOf5Pz6Ex21Hwt0DiH59AgJ10dC4KgjgY76URgOXUP6GfWj4PXzvwaEE294AMFRD3S5o7ZxDxR31JG4X88K2WfUg3yYD77TUQ8K4qgHh8BRRwId9SAg6QeHcxYXXfWRMQ9xeTf1iK9ooB31I0AMkYV3qMvXw/JlKKG7BcZNcdR+HqI7WSR3HnO5o7YYPkbAcCgQw2EijhpZv4a7vObYNRlOqDkjSM5vBNFR+7FA5xCSTyNJuI4MgaM2QEf9OAyHbjGhdNSPg9fP/xoVTrzhUQRHPdrljtrGPVrcURuYo47oHOR2KY56jA/zJ+501GOCOOonQuCoDdBRjwGS/olwzuKiqz4y5rEu76ZG+ooG2lGPBGKILLzjXL4eli/jCN0tMG6Ko/bzEN3JIrnzpMsdtcXwSQKG44AYPiXiqJH1a7zLa45dk/GEmjOB5PwmEB21Hwt0DiH5NJGE68QQOOoIoKOeBMOhQkh3fU8Cr5//NTmceMOTCY56issdtY17irijjsB9jzohyO1SHPVUH+ZP3+mopwZx1E+HwFFHAB31VCDpnw7nLC666iNjnubybmqir2igHfVEIIbIwjvd5eth+TKd0N0C46Y4aj8P0Z0skjszXO6oLYYzCBhOB2I4U8RRI+vXLJfXHLsmswg1ZzbJ+c0mOmo/FugcQvJpDgnXOSFw1OWBjvoZ3GfUIX3W9zPg9fO/5oYTb3guwVHPc7mjtnHPE3fU5XG7vkP2rO/5PsyfvdNRzw/iqJ8NgaMuD3TU84Gkfzacs7joqo+MeYHLu6k5vqKBdtRzgBgiC+9Cl6+H5ctCQncLjJviqP08RHeySO4scrmjthguImC4EIjhcyKOGlm/Fru85tg1WUyoOUtIzm8J0VH7sUDnEJJPS0m4LvXhGkp3WS4pNhb/6/lw4g0/T3CXy1zuLm3cywjuMti9IhJkGSGJgYlHX2+3YoiMe7lIM7EUGPMKlzcTNtblhGbiBZc333ZdXiDXnMRiuJLUOKz8/9A4lCU1DqvCiTe8itA4rHZ542DjXi3SOFgiryYkMTDx6OvtVgyRca8RaRxWAmNe6/LGwca6htA4rHN542DXZR255iQWw/WkxmF9CD7Dvxf4Gf6LwBwKZbP0YjinWdoQTrzhDYRmaaPLmyUb98YQNUsRiXuZ9b57RX90uB64Rsj13uRyAbWFbhNBQF9yuYDamF8ixL2ZJHqbg2wBQWPCXjNEjm8kND3IfN/ict5bDLcQMNwExPBlEaOF1JxXXK4Tdk1eIdTLV0n18lXix73/CYuIxL0Mkk/23pL7Yj/nEP+W7/x8wPmlJH+aiW8Dzr8LOL8ccH4l4Pz7gPMfAs5/DDi/GnD+U8D5zwHnvwScXws4/zXg/LeA8+sB5zcCzn8POL8ZcH4r4Px2wLkliv/8noDzJAHnSQPOwwPOkwWcJw84TxFwnjLgPFXAeeqA8zQB52kDztMFnKcPOM8QcJ4x4DxTwHnmgPMsAedZA86zBZxnDzjPEXCeM+A8V8B57oDzPAHneQPO8wWc5w84LxBwXjDgvFDAeeGA8yIB50UDzosFnBcPOC8RcF4y4LxUwHlp33nBsD9e9r2GAf/3BgHn9QPO7ws4rxdwXjfgvE7Aee2A81oB5zUDzmsEnFcPOK8WcF414LxKwHnlgPNKAecVA84rBJzHB5zHBZzHBpzHBJxHB5xHBZxHBpybgPOIgPPyAeflAs7LBpzf6zt/LcC3+tfDvqr7/kYk7mVeA3v3/3Sfib326zAdjIr+V+6H/fHJmv9e7fX9df9sgAZ8FnC+zXfu/99tc062O8cbzvFm+J/v+1/oLeifJ8Fdaxtw3XeQ+lE0fueA+G0H4rdTBL/zQPzeAOL3FrhHvrM27AioDTsDzt8KOH8z/K+14W3n5B3n2OUcu0NQG74Ars3bwLV5V4TbXwLxeweI33si+F0A4rcLiN8ecm14N6AGvBdwvifgfPcdtWGvc/K+c+xzjv0hqA0XgWuzF7g2B0S4/RUQv/eB+B0Uwe9rIH77gPgdIteGAwE14GDA+aGA8/131IbDzskHzvGhcxwJQW34Brg2h4Frc5S8NkcD1uCDgPMPA86P3LE2HzknHzvHMec4HmRt0J73BA6DbsEwOBEQ60cB52WS/nl+6g7Pe9I5OeUcp53jEx8G4b7/9p6wv7/Q84qTQF4kCbjPT30BnvEH4x+U2//DmDveO+N7L/CFTsyTwGT69J9fq8v/ci1zBrgAFuskYcEfghD2f8Tzf7vvMCIpPwUXK//r7J1kPBv+9yxD7xT5PwRj/pf/e8RZIIk/C4eR4S+fhH32D5I5sfd+BogDEtPP/w+Y/m//vwIx/TygaKYKwDMQ04jEvcyt//l6kV26maiYrnExEbGdomMSYqMiEyLjIhKiY7oZ54YjK0Q70HTrEh2fEB8Z1S0yLrLLLez9/Ytj/sLmFxK/qp7xnZ9z/p53ji98ShqqJ8J8QXIO4DWODMTiS59CX7izKNr/w8073rvwDwplROJefwExcU+E6dbtS2BSXyAtbhIwfsiYLwZcy8RHRUbGRdn/Lj4hwkQnOD1NZGRC5+iILhGdukR2rRBtKnSLjoyO6pLQpbNzzU6mW0S3Tl0qdIv/474sv0K1h/giqXP4Kpx4w1+F46/7NZAMrLi/DjB8oOtS9gFe8N0r+rrfgMnqL9b2uneqHvOzv8TicA7I1UtgOxWqwnWJVLi+DSfe8LeEwvWdywuXjfs7UuHyv5gfNCcW0/PA9bksmqyXScl6JZx4w1cIyfq9y5PVxv29WLKeC3dnMf0BTPrUvvX+IcDHnw84/y78zyn4f9pRbHdp2L8/Ov/tVef4yfe/8V/73H+49oXAa/8v/83Pzt9fnONaOCc3v/NxFN1d/gq2rej7Y8X9GzB/wgJeScD3eQGYm9fBMaNHEzY/ketic/JXAnduhGjUk9j7/ALY0P3ucu7Y2g8cwRmbKzcI3LkJ5g4aR8sZZG9heXOTgOM9uJhDagoqh2H7I//rVjjxhm8RTMFtl5sCG/dtsilAJ+84YMEPS4Yt+OgCUMW3PmgMqwDv8Z5kWN6gOW7X2N4jem2SJMMWOf/I2l63YNgfH9ra95KF/f3l5oLNvM9KIvdZUeQ+A2tpRCJfwe4vsTlWNeyPHEDXv6TAa1UN4zQ7SQNqFnzhkUXbv0/TK1R/3qdXqLD36RUqdxWqJAFrHe5L/GS2YDEcVJUw/NgI2QHfBo4SAjvBcF8nGPhCEyw8GQ6H5GQ3FZG4l/G7KfQWXBaXEnutFC5fD8uXFARnlpLkzFIG5KOKS02VjCPw6HqM5H1ql/PerklqwlqnIfE+DZH3rBqQ1uVTKbv+aQlxpyNxIB2RA6x8GJLt7uTA0Gycmo/um9ID6zRwrQ0Sv8AcSk/MITtwYNTRDAJ1NAMh7oykOprxf+BAYu/Z/v/wDyKQGLOGEImNN5PLuWmHVoyczCyQk5kJcWch5WQWYl0OJ/W3WQU4kJUQdzYSB7IROJAQEx1tOkck3EPqb7OTsMhOzAdbExlzjhwC+ZCDEHdOEgdyBpk9o/v/XHdZ/5+LnFe3CVsQc5P4lfsf8CsicS+D5Fdu4OckeUiY5iHyy16P0cfkdXndrkyKO99d6qvzk7ifn8h9u/6ZCFgUcDkHKpK4X9DlcScjebZCd6lvL0zK+cLEnGf51yIkLIqQtZ/h2YoKaD8j7mIujZs9ryhO4n5xJvdJ2l/C5dy3cSclxF3yLp3TlCJxv1TAt0VC9fW+GmHYWPyv0smIN1w6Gf66ZYBDAVbcZZL9CTDoutSv9+UBYnoveSNYYu+vpm990BjWBN5jWZcXbLvGZQkFuxypYJf7//D1PmTBZt5ndZH7rCZyn3nIuZvYHKsV5v5vzdQK4zQ75ZMRv96HLNrBHh7N6LrvATYqvkcfMx4g/e8H0wfiEeG7d5PMB46/2kf4VjnwPUO2q6mTwbbnR/p/4iAC2JWZZNgFRlclmzwRpK4ZvN6xrFFNpMu7PrtGkYS4o0hdXxR5VF2UgEW0wKimGCHuGIG4SxDijhWIuyQh7jhw3GH/Ic8Te5/xwPu0damkc3T0Xc/muuW9HaVbHlhM7Ggx3jtCcvwnzkQk7kXTyQpALibxcfHOF+r6LGyRGLDusSL6HtFW3QZcFmgu7LUqJsPfZ0XgPVbSSR5zNydPJfQ9sqp7EsJ1UWSvTHJUlYmOSgHXKp4CmyoCRaSq2xW4RhhegasSkqcq8B6reQoskTzV7lIFjkQmZHWSAlfXU2AorjU8BTY1BIpITXYRQSimvUnU99/8+3iBnwL/BcREf+zvqa9E4tS6S9U3CqkStUnqW1tPfaG41vHU19QRKCJ13a6+NqH8G9GQgbM2oSU23nrgBUkCXg9bJICk+Vcxq0eYR9QFFrP7vI5Iopjdd5d2RNFI5a5P6ojq63VEUFwbeB2RaSBQRBq6/RMBS8ry4E8EGhIUuCHwHht5CiyRPI3uUgWOQSrF/SQFvl9PgaG4NvYU2DQWKCJN3K7A9ot76M/kmxAUuAnwHh/wFFgieR5wuwKzvhP1YDIsgRgK+SAh7qakbqFpsj+/CR+q34+sEYZPMMZ9Vhe5z7v1m/Cs+6wHFkH/q5kvuR6y9YHxGJyaYfhPAmoCr1UGWLwDi1izgCIWim/Jpwiokom9ru9L1F3CgrwSee2g35Jv7rv3h5OF/fUb8c2T/f1b8g8TvWSKZJxvyTcHtsMPJ+MsMDpJkTG3cHmHZQtSmWT4B+GzCl1ir9XS5eth+dKS0PG2BHcL4LjjU5AcTit3x23surQixN2a5HBaEzXMrn9eAhZtXM4BG3c+QtxtBeIuQIi7nUDcBQlxtxeIuxAh7g7AuG2dKxX2Z42ztcPmkf0xBssri7H9/2cf1G4fUK76FAWW7nQEu/1SYX9/oa7PwhaJAeseO7n98yIbcEtw49+J8HlRJ+A9dtZJHtrnRQrJ0xl9j6zqnoRwXRTZu5AcSheiQ1HANcFTYJMgUES6ul2Ba4ThFbgrIXm6Au+xm6fAEsnT7S5V4EhkQnYnKXB3PQWG4trDU2DTQ6CI9HS7AtvroBW4J0GBewLvsZenwBLJ0+suVeAoZEL2Jilwbz0FhuLax1Ng00egiPR1uwLXS4ZX4L4EBe4LvMd+ngJLJE+/u1SBo5EJ2Z+kwP31FBiK6yOeAptHBIrIo25XYPt1DLQCP0pQ4EeB9zjAU2CJ5BlwlypwDDIhB5IUeKCeAkNxHeQpsBkkUEQGu12BHyJ44MEEBR4MvMchngJLJM+Qu1SBY5EJOZSkwEP1FBiK62OeApvHBIrIMLcrcB6CAg8jKPAw4D0O9xRYInmG36UKHIdMyBEkBR6hp8BQXEd6CmxGChSRx92uwM0ICvw4QYEfB97jKE+BJZJnlNsVmPVsh9HJsARiKORoQtxjSN3CGGK34C+g6IKHLMpPkHB9gojrvcn+eKwqmmNjCYXPvpKA7xP5bKBxLq8ndk3GEdb6SRLvn7zL68lT4BxCY2i59BSBT+NJfBpP5BMrtzZkuzs5sDEbRz/Qz6mbAKz5wLU2SPwCc2iCL4dUpxnxAoZsIql3gifpJCD5VQk1SYBQk1UINQV3o5GqhJoiQKipbh8Z5SfZ2qcFWvKnCXFPI7Xk08gfME0lYDFdgAPTCXHPIHFgBpEDrHzYLGDLGBzYImLLZgI7U+Bamy0kWzYzIIfC/kMuJRbTWThMo1Sbs1kCzdlst38Ybhsz4DOW/yX0swnFbo6A0M8hxP0MSeifCbhX/wvMrehxwPn7XG/3j5krUPDmscYbYHLGIMk53yOnmS9AzmdFyAmtnAu8OZ5ZIEDOhW6f4xUmzfEWCbR2iwhxP0dq7Z4jz/EWErBYLMCBxYS4l5A4sIQ8x2PkwzaBOR6DA9tF5nhLgWMC4Fqb7aQ53tIgczw3u5DnvUbPPC/Q6C1ze6NXhNToLRcQ+eWEuFeQRH4FudFbRsDiBQEOvECIeyWJAyvJjR4jH3YINHoMDuwUafRWARs94FqbnaRGbxW/0YtHNnqrvXGzWS3Q6K0RGTdXQJJzrUdOs1aAnOtEyAmtnOs9i2zWC5DzRbdbZGuPXmR8xUzAHm1gfMWMZI82irV2m7x9fWaTQIF6SUQ9uyDJudlr7cxmAXJuESFnApKcL3vkNC8LkPOVu7Fyvur5DvOqADm3KviOrYT++zUB3/EaIe7XSb7jdb7vgKrnNq9AmW0CBWq7QoHaTkjUNwQK1BuEuN8kFag36QXKRCAL1A6vvTc7BArUTo323hgkOd/yyGneEiDn2yLkhFbOd7zWzrwjQM5dCq3dLkKLs1ugtdtNiPtdUmv3rlhr9573mZd5T6BA7RFRT+i3Z/d6rZ3ZK0DO90XICf3Gzz6PnGafADn3342V84DnO8wBAXIeVPAdBwn99yEB33GIEPdhku84zPcdUPX8wCtQ5gOBAvWhQoH6kJCoRwQK1BFC3EdJBeoov0BBNwN/5LX35iOBAvWxSHsP/Z7XMY+c5pgAOY+LkBNaOU94rZ05IUDOkwqt3UlCi3NKoLU7RYj7NKm1Oy3W2n3ifeZlPhEoUJ+KqCf02wpnvNbOnBEg51kRckJ3qn/mkdN8JkDOz+/GynnO8x3mnAA5zyv4jvOE/vsLAd/xBSHuL0m+40u+74Cq5wWvQJkLAgXqokKBukhI1K8ECtRXhLi/JhWor5Pxng+awrl2agIW37icA/bZyN8Q4r4kwP1LhLi/JXH/WyL3bf0bTcDiOwEOfEeI+zKJA5eJHGDlwzsCz0dmcGCXyPORr+C4aoBrbXaRno98xZdDtuEvGfb3F3rN0HyNF2j4v0feo+pCTRJYqB+8hYowUwQW6ke3W2hrI34kyOhVgRbyKiHun0gt5E/EFrK4c+2WBCx+FuDAz4S4fyFx4BeyjWDkw3sCNoLBgT0iNuIa0EYA19rsIdmIa+I2YpZA0/Mr+h6TgG/QNj3AmzSxJAH9TUBAfyPEfZ0koNcD7vU/kT+x934Dd+/RqkXqhkCR+p21NQhNqJu4G41RJdRNAULdUrD6twjV+raASt0mxB2WnKNS9roFSSQtRepU7knufg7Ye0THnYTEgSTJuVafkQ+HBKw+gwOHRax+UhxXDXCtzWGS1U8akENh/yGXEotpOA7TWNXmLDy5++8xWXJOjsIJlRx3o3GqhEouQKgUKoRKibvReFVCpRQgVCr0PTLsYypC+5RawDqkJsSdhmQd0oSg7UmLu/cKqkUlrUBRSaeiUulxN9pJlVDpBQiVQYVQGXE32lmVUBkFCJVJoe3JRJD/zAJtT2ZC3FlIbU+WELQ9WXH33kW1qGQVKCrZVFQqO+5GE1QJlV2AUDlUCJUTd6NdVQmVU4BQuRTanlwE+c8t0PbkJsSdh9T25EmuvZ/1RLj77zEvq/ongd4o9gfR8gGDViVnPgElya9BzohuSHIWwAUdqUrOAgLkLKjQ5hQkyH0hgTanECHuwqQ2p3CQ6Q5YPSORBaqIp56miECBKirS2kUhyVnMI6cpJkDO4iLkhFbOEl5rZ0oIkLOkQmtXktDilBJo7UoR4i5Nau1Ki7V2ZXA4RKkWqDICBepeEfWMRZKzrNfambIC5CwnQk7ob92W91o7U16AnBEKrV0EocUxAq2dIcQdSWrtIvmtHfQH0aI89TRRAgUqWkQ9ob91G+OR08QIkDNWhJzQyhnntXYmToCc8QqtXTyhxakg0NpVIMRdkdTaVRRr7Sp5UztTSaBAVRZRT+gvNlbxWjtTRYCcVUXI2RlJzmpea2eqCZCzukJrV53Q4tQQaO1qEOKuSWrtavJbu67IAlXLU09TS6BA1RZRT+hO9ToeOU0dAXLWFSEntHLW81o7U0+AnPcptHb3EVqc+gKtXX1C3A1IrV0DsdauoTe1Mw0FClQjDfWMhG4Evd9r7cz9AuRsLEJOgyRnE6+1M00EyPmAQmv3AKHFeVCgtXuQEHdTUmvXlN7aRUYjC1QzTz1NM4EC9ZCIekJ3qjf3yGmaC5DzYRFyQitnC6+1My0EyNlSobVrSWhxWgm0dq0IcbcmtXatxVq7Nt7UzrQRKFBtRdQTuhG0ndfamXYC5GwvQs44JDk7eK2d6SBAzo4KrV1HQovTSaC160SIuzOptevMb+06IQtUF089TReBApUgop7QnepdPXKargLk7CZCTmjl7O61dqa7ADl7KLR2PQgtTk+B1q4nIe5epNaul1hr19ub2pneAgWqj4h6QjeC9vVaO9NXgJz9RMiZgCRnf6+1M/0FyPmIQmv3CKHFeVSgtXuUEPcAUms3gN7aRUF/y2mgp55moECBGqShnlHQneqDPXKawQLkHCJCTmjlHOq1dmaoADkfU2jtHiO0OMMEWrthhLiHk1q74WKt3QhvamdGCBSokSLqCd0I+rjX2pnHBcg5SoSc0F/BG+21dma0ADnHKLR2YwgtzhMCrd0ThLjHklq7sfzWDvpbTuM89TTjBArUkyLqCd2p/pRHTvOUADnHi5ATWjkneK2dmSBAzokKrd1EQoszSaC1m0SIezKptZss1tpN8aZ2ZopAgZoqop7QjaBPe62deVqAnNNEyAn9FbzpXmtnpguQc4ZCazeD0OLMFGjtZhLinkVq7WbxWzvobznN9tTTzBYoUHNE1BO6U/0Zj5zmGQFyzhUhJ7RyzvNaOzNPgJzzFVq7+YQW51mB1u5ZQtwLSK3dArHWbqE3tTMLBQrUIg31jIZuBH3Oa+3McwLkXCzS2kF/BW+J19qZJQLkXKrQ2i0ltDjPC7R2zxPiXkZq7ZbRW7to6G85LffU0ywXKFArRFo76E71FzxymhcEyLlShJzQyrnKa+3MKgFyrlZo7VYTWpw1Aq3dGkLca0mt3Vqx1m6dN7Uz6wQK1HoR9YRuBH3Ra+3MiwLk3CBCTuiv4G30WjuzUYCcmxRau02EFuclgdbuJULcm0mt3WZ+awf9LactnnqaLQIF6mUR9YTuVH/FI6d5RYCcr4qQE1o5t3qtndkqQM7XFFq71wgtzusCrd3rhLi3kVq7bWKt3XZvame2CxSoN0TUE7oR9E2vtTNvCpBzhwg5ob+Ct9Nr7cxOAXK+pdDavUVocd4WaO3eJsT9Dqm1e4ff2kF/y2mXp55ml0CB2i2intCd6u965DTvCpDzPRFyQivnHq+1M3sEyLlXobXbS2hx3hdo7d4nxL2P1NrtE2vt9ntTO7NfoEAd0FDPGOhG0INea2cOCpDzkAg5ob+Cd9hr7cxhAXJ+oNDafUBocT4UaO0+JMR9hNTaHaG3djHQ33I66qmnOSpQoD4SUU/oTvWPPXKajwXIeUyEnNDKedxr7cxxAXKeUGjtThBanJMCrd1JQtynSK3dKbHW7rQ3tTOnBQrUJyLqCd0I+qnX2plPBch5RoSc0F/BO+u1duasADk/U2jtPiO0OJ8LtHafE+I+R2rtzvFbO+hvOZ331NOcFyhQX4ioJ3Sn+pceOc2XAuS8IEJOaOW86LV25qIAOb9SaO2+IrQ4Xwu0dl8T4v6G1Np9I9baXfKmduaSQIH6VkQ9oRtBv/NaO/OdADkvi5AT+it4V7zWzlwRIOf3Cq3d94QW5weB1u4HQtw/klq7HwNaOwYHHkyGx+KqAAeuEjjwE4kDPxE5cI+DRWoCB352OQdaOjH/TODALwLc/4UQ9zUS968Ruc+qA0ey3Z0cOJoN35iF+biAvM9fcVw1wLU2SPwCc+jXIOMhNKa/ATHdAMR0IwnT34h1KY+Tn2UImnydVKOv/wN+RSTuZZD8CsQhsZjeIGF6IwBT7EDij76/TTJsLzWRwNffwb0UA8e2YBwnE3C8mVxDl28Bc3wzUEO2kDTkFlFD8pM05Dap3t0OgYYg+XUbqCFhKTiY2usW9F0XXfsst9oBa5/1JHMIfL2HhK297j0kbK2utAfryjwCtklSuF+fO4BxfJaAY9IUGvocjrtPsw2oz9tJ+hyegqfPhUn6nIxU75Kl4Oszkl+BOCQW0+QkTJOn4M9lUgAx3QHM2Z2knE1BzNkipJxNSeJXyhDkLJJfKYE5m4qEaSoiv2x/sYbAr9Tg/oIR9zpC3GlcHrf1PBsIcaclcT8tmfsvEbBIJ8D9LYS40wvE/Qoh7gwCOf8aIe6MpJzPSMx5i8UbBCwykbDIRK5/OwlYZBaoA28T4s4iUAd2E+LOSuJ+VjL39xCwyCbA/fcJcWcXiHs/Ie4cAjl/iBB3TlLO5yRr/xECFrlIWOQi17+PCVjkFqgDxwlx5xGoA6cIceclcT8vmfufErDIJ8D9s4S48wvE/Tkh7gICOf8FIe6CpJwvSNb+rwhYFCJhUSgEn9MVBn6O8g7wc7pdpM/pChP5ZT+j+4bAryIkfhUJwed0SH4VAX5OV5SEaVHi3rd/fXcWuK8o2rlWSwJfiwnsz/oBiGMMCcfiIvuzSgBz/D2ghuwhaUgJooYUJ+31KEmqdyVDoCFIfpUEakgpEqalyPunY8H7p38j8LU0CdvS5P3TvwOxjSPpShkRXbkXmPeHgLpymKQr9xJ1pRRJV8qS8rRsCHQFya+yQF0pR8K0HJFftvYlI3y3v7zL52s27hSEuCME5oqpCXEbEvcNmfvpCFhECnA/AyHuKAHuZybEHU3ifjSZ+9kIWMQIcD8HIe5YAe7nJsQdR+J+HJn7eQlYxAtwPz8h7goC3C9EiLsiifsVydwvSsCikgD3ixPirizA/VKEuKuQuF+FzP17CVhUFeB+OULc1QS4bwhxVydxvzqZ+9EELGoIcD+WEHdNAe5XIMRdi8T9WmTuVyZgUVuA+1UJcdcR4H4NQtx1SdyvS+Z+bQIW9QS4X5cQ930C3K9PiLs+ifv1ydxvRMCigQD3GxPibijA/QcJcTcicb8RmfsPEbC4X4D7DxPibizA/VaEuJuQuN+EzP22BCweEOB+e0LcDwpwvxMh7qYk7jclcz+BgEUzAe53I8T9kAD3exLibk7ifnMy9/sQsHhYgPv9CHG3EOD+o4S4W5K435LM/UEELFoJcH8IIe7WAtwfRoi7DYn7bcjcH0nAoq0A90cR4m4nwP0nCHG3J3G/PZn7TxKw6CDA/fGEuDsKcH8SIe5OJO53InN/KgGLzgLcn0aIu4sA92cS4k4gcT+BzP05BCy6CnB/LiHubgLcf5YQd3cS97uTub+IgEUPAe4vJsTdU4D7zxPi7kXifi8y91cQsOgtwP2VhLj7CHB/DSHuviTu9yVzfz0Bi34C3N9AiLu/APdfIsT9CIn7j5C5/zIBi0cFuP8qIe4BAtx/nRD3QBL3B5K5/wYBi0EC3N9BiHuwAPffJsQ9hMT9IWTu7yZgMVSA++8R4n5MgPvvE+IeRuL+MDL3DxCwGC7A/UOEuEcIcP9DQtwjSdwfSeb+RwQsHhfg/jFC3KMEuH+SEPdoEvdHk7n/CQGLMQLcP0OI+wkB7n9OiHssiftjydz/goDFOAHuXyDE/aQA978mxP0UiftPkbn/LQGL8QLcv0yIe4IA938gxD2RxP2J/+DZ1om990nAZ1sfAT47/Sjp2emTiPXEPjf9ZwK/JpP4Nfkf8CsicS+D5Ndk4LPTp5AwneLDNNw5HDqEJQngWs6w4C/MfcREca4bG8O5bly01nVjK5Cu25V03TjOdSMjSOvWmXPdKNb9JmjhG2tIOJDqDg2HWNJ1Y7SuS8tjNf6y6jpLNyNtL3HPHddG97L34K4Vcec9wm+2DvhmGfd3g2AMppKa2Kn/g0lK9MMcfVgkAWNsr4m6x6dJuD4dAsMF5IR5Gmi4ppEwnUY09Jar9od60TkwnYTFdHLeWizQeVsUyLEZJFxnhCBvgZwwM4CYziRhOpOct1MIeTuLhMUsct5OIeTtFCDHZpNwnR2CvAVywswGYjqHhOmcgAFn8rC/G5FgHI5I3Msge4d/36QNIGWIAigRhl0M/+uZFMQbfiYF/rpzgQxnxT03xZ8Ag677l5EIuhJPA2I6D1jNgq1Pon+e3rc+aAxLAu9xvss/BrdrPJ/QHT1LUpxnAxTHvpcs7O8vNxds5n0WF7nPYiL3OY2cu4nNsVJhf+QAuv4lBV6rVBin2VmQgjhCRhZtW6hSBSwSk7CINr/bH6+IILeb2Gsb/0kgFgt9DdaiFD5A/JV+oW+FA99bFAIPNyfxHVSkL0PNQmA3tgi8uOhqZJNmIalbBidK7BxS1/Mcqet5LoD36GpvN6pFJ8Ndz26sLEbAdjFYjRk4xoBxLE7AcYkAjnFgHMsQcFwqsMG5PCHu5wXijiDEvUwg7khC3MsF4o4ixL1CIO4YQtwvCMQdS4h7pUDc8YS4VwnEXYEQ92qBuCsR4l4jEHdlQtxrBeKuSoh7nUDc1QhxrxeIuwYh7hcF4q5JiHuDQNy1CXFvFIi7DiHuTQJx1yPE/ZJA3PcR4t4sEHcDQtxbBOJuSIj7ZYG47yfE/YpA3I0Jcb8qEPcDhLi3CsT9ICHu1wTibkaI+3WBuB8ixL1NIO6HCXFvF4i7BSHuNwTibkWI+02BuFsT4t4hEHdbQtw7BeJuR4j7LYG4OxDiflsg7o6EuN8RiLszIe5dAnF3IcS9WyDuroS43xWIuxsh7vcE4u5BiHuPQNw9CXHvFYi7NyHu9wXi7kOIe59A3P0Ice8XiLs/Ie4DAnE/Soj7oEDcAwhxHxKIexAh7sMCcQ8mxP2BQNxDCXF/KBD3Y4S4jwjEPZwQ91GBuEcQ4v5IIO7HCXF/LBD3KELcxwTiHkOI+7hA3E8Q4j4hEPc4QtwnBeJ+khD3KYG4xxPiPi0Q9wRC3J8A47bfAy/tHB1917Pfhbbf4y3lHKWdw34XtZxz2O9m2u8pGuew39uz32GLdg77nS77/aY457Df97HffanoHPa7IPZ7EVWcw35P4F975p3D7iG3+6lrOYfdX2z32tZ1Drv31O7DrO8cdl+i3aPXyDnsnjW7f6uJc9j9THZvT1PnsHtd7L6P5s5h90HYPQEtncN+Rm4/L27jHPbzU/tZYnvnsJ+t2c+ZOjmH/dzFfgaR4Bx2Jm/n092dw85r7eyyl3PYWZ6da/V1DjvnsTOPR5zDzgCsH7Y/DG79ofVK9oeSrXewfbT94VjbV9oey/6Qpu05rP7aHxa0emRrs/2hNVurbN7aH56yPLZran+Ix/8Cc5H2XIJPgVxM4uPinS/U9UnYGiQGrHs8g77HJOAbtAEHPh0H8dAQGzT6Ps8A7/GsTvKYuzl5zqLvkVXd0WRHJuRnQBAtfv4n2NjrFuQsvASun3sKbD4XKCLn3K7AJcLwCnyOkDzngPd43lNgieQ5f5cqcCQyIb8gKfAXegoMxfVLT4HNlwJF5AK7iCAU094k6sGjCTHR0aZzRALwqbN/ATGx8V701FcicS7epeobhVSJr0jq+5We+kJx/dpTX/O1QBH5xu3qaxPK/+B7ZOCsh94nNt5L4AVJAl4PWySApPnX0O0SYR7xDbCYfet1RBLF7Nu7tCOKRir3d6SO6Du9jgiK62WvIzKXBYrIFbd/ImBJuQD8icAVggJfAd7j954CSyTP93epAscgleIHkgL/oKfAUFx/9BTY/ChQRK66XYGnpcB/Jn+VoMBXgff4k6fAEsnzk8sV2Cjs3vqZpMA/+xQ43Hd4v2b75316v2aLvc9pKTTu8xJYWPyvX3zf27hmv1+Bvmn7M+T2Z8PR03XkT5HPBU7pA4vYLwFFLFS/dDsTEIvvx1C7BLndxF476C/d/uoj4G8pfID4AfzV942fwPd+C/Bm/hf6I6+ZiVfIf//S7a9Atf2NtLjo5ETGfB2YnGFh+ISzhWhukE1Pbi1wib3WDZevh+XLjRT4j9dvgLsEcNzxM0lx/07q8H8PqONoh2N/KbcN+Jdyf0+Ox/YmeQtDROJe/8KxLRjHmwQcbwng2B6MYxJCrt8WwLEDGMekBBzDUrpaK/4Vd2pC3PcIxJ2GEHcSgbjTEeJOKhB3ekLc4QJxZyDEnUwg7syEuJMLxJ2FEHcKgbizEeJOKRB3dkLcqQTizkGIO7VA3LkJcacRiDsPIe60AnHnI8SdTiDu/IS40wvEXYAQdwZg3HZuVybsz5mdnV3ZuUuYvW/nsLMD63uTO39T2fecc+uL0trZuPPX9sy2f8zo/DuTc9ieyvYXWZ1zq7dWe2wdzun8O5dz2Npk8zSvc255a9fQxlPQ+Xch3wdGhLWgzVEzAtciiW8t7nyhrk/C1mRM6f57zIS+xyTgG7QB3wB/oGODRt9nIJCJvcfMOslD21OnkDyZ0ffIqu5osiMTMgsQxMBP3Ox1C3IWXgLXrJ4Cm6wCRSSb2xW4RBhegbMRFDgbUIGzewoskTzZ71IFjkQmZA6SAufQU2Aorjk9BTY5BYpILrcrsP0KBFqBcxEUOBdQgXN7CiyRPLnvUgWOQiZkHpIC59FTYCiueT0FNnkFikg+tyvwpRR4Bc5HUOB8QAXO7ymwRPLkv0sVOBqZkAVIClxAT4GhuBb0FNgUFCgihdyuwPbr9WgFLkRQ4EJABS7sKbBE8hS+SxU4BpmQRUgKXERPgaG4FvUU2BQVKCLF3K7A1wgeuBhBgYsBFbi4p8ASyVP8LlXgWGRCliApcAk9BYbiWtJTYFNSoIiUcrsCTyMocCmCApcCKnBpT4Elkqf0XarAcciELENS4DJ6CgzF9V5Pgc29AkWkrNsV+BeCApclKHBZoAKX8xRYInnKuVyBjcK3ZsqTFLg8T4H/XZTcjGsECdcIIq7zUvzxRHr0d6MNoZjYVxLwfSKfoxqZElvk0Wtt18TeI3qto0i8j7rL60m0y59xYbkUTeBTDIlPMUQ+sXKrQfa7kwMNs3P0A/1M71hgzQeutUHiF5hDsb4cUp0QxCdz/z3GIeu+6kJNElioeG+hIswUgYWq4PaxQRjJhlUUaCErEtqHSqQWshKxhbTWoQIBi8oCHKhMiLsKiQNViBxg5UNjARvB4EATERtRFWgjgGttmpBsRFVxGzFLoOmp5vrHHqb4608JRyTu9S8BrUYoItUFBLQ6Ie4aJAGtEXCv/heYW9GRwA+Ha3o7K0zNlO6/x1qkz5zQ5IxBkrO2R05TW4CcdUTICa2cdXFBR6qSs64AOeu5fT6WnDQfu0+gtbuP0NrVJ7V29cnzsXqMj1gFONCA8REriQMNyfMxRj48LDAfY3Cghch8rBFwPgZca9OCNB9rFJBD/pebXcj9XqNn7hdo9Bq7vdFLRWr0mgiIfBNCgX+AJPIPkBu9xgQsHhTgwIOEuJuSONCU3Ogx8qG1QKPH4EAbkUavGbDRA661aUNq9JrxG714ZKP3kDduNg8JNHrNRcbNFZDkfNgjp3lYgJwtRMgJrZwtPYtsWgqQs5XbLXJakkVuLWCPWjNaY5I9akO2yK0IWLQV4EBbQtztSBxoR7bIjHxoL2CRGRzoIGKR2wMtMnCtTQeSRW4vZpE74NYnSrXR6yDQ6HV0+/5o2+QlTYltGjoSCmcngaahEyHuzqSmoTN/f3QXZMHr4o1dTBeBgpcgMnZJQJKzq0dO01WAnN1EyAmtnN29maDpLkDOHm6fCWYkzQR7CrR2PQmtXS9Sa9eLPBPsQcCitwAHehPi7kPiQB/yTJCRD90EZoIMDnQXmQn2BY4JgGttupNmgn35M0GoC+nnNXqmn0Cj19/tjV4mUqP3iIDIP0Io8I+SRP5RcqPXn4DFAAEODCDEPZDEgYHkRo+RD70EGj0GB3qLNHqDgI0ecK1Nb1KjN4je6JkIZKM32Bs3m8ECjd4QjXGzMUhyDvXIaYYKkPMxEXJCK+cwzyKbYQLkHO52i5yVZJFHCNijEYTWeCTJHo0kW+ThBCweF+DA44S4R5E4MIpskRn50E/AIjM40F/EIo8GWmTgWpv+JIs8Wswij/H2R5sxAo3eEwr7o1OC90c/QSicYwWahrGEuMeRmoZx9P3RBvoU1Ce9sYt5UqDgPSUydoE+uW28R04zXoCcE0TICa2cE72ZoJkoQM5Jbp8J5iTNBCcLtHaTCa3dFFJrN4U8E5xEwGKqAAemEuJ+msSBp8kzQUY+DBGYCTI4MFRkJjgNOCYArrUZSpoJTuPPBKEuZLrX6JnpAo3eDLc3erlIjd5MAZGfSSjws0giP4vc6M0gYDFbgAOzCXHPIXFgDrnRY+TDcIFGj8GBESKN3jPARg+41mYEqdF7ht/oQR+ONdcbN5u5Ao3ePJFxM/T50fM9cpr5AuR8VoSc0Mq5wLPIZoEAORe63SLnJVnkRQL2aBGhNX6OZI+eI1vkhQQsFgtwYDEh7iUkDiwhW2RGPowSsMgMDowWschLgRYZuNZmNMkiLxWzyM97+6PN8wKN3jKF/dHpwPujlxEK53KBpmE5Ie4VpKZhBX9/NPQpqC94YxfzgkDBWykydoE+uW2VR06zSoCcq0XICa2ca7yZoFkjQM61bp8JFiTNBNcJtHbrCK3delJrt548E1xLwOJFAQ68SIh7A4kDG8gzQUY+jBeYCTI4MEFkJrgROCYArrWZQJoJbuTPBKEuZJPX6JlNAo3eS25v9AqRGr3NAiK/mVDgt5BEfgu50XuJgMXLAhx4mRD3KyQOvEJu9Bj5MFmg0WNwYIpIo/cqsNEDrrWZQmr0XiXm0EySlm4VqKNbCTn0GqmOvkbmgNVT9Ge39pooXF8X4NPrBD5tI/FpG1mXGbk1TUCXGRyYLqLL24G6DFxrM52ky9t9OWTrZumwv7/Qa4bma3wy99/jG8i6r7pQkwQW6k1voRwHILBQO9w+3rN2ZAdBRncKtJA7CXG/RWoh3yK2kKV8lgSNxdsCHHibwIF3SBx4h2wjGPkwS8BGMDgwW8RG7ALaCOBam9kkG7FL3EbMEmh6drv9ew6lfYKHup5tonYTisi7AgL6LiHu90gC+p7vXlWT/4ZA8u/xrGmEuSmwUHsVrOleQnV5X6Cqvk+Iex+pqu4j2pJyJGu6X4AD+wkcOEDiwAGyNWXkwwIBa8rgwEIRa3oQaE2Ba20WkqzpQXFrGp7c/fd4yOtOI0xygYU67C1UhEkpsFAfKNiIDwgy+qFAC/khIe4jpBbyCLGFNCQbcVSAA0cJHPiIxIGPyDaCkQ+LBWwEgwNLRGzEx0AbAVxrs4RkIz4WtxFpBZqeY27/hMs2PcCbNMtJAnpcQECPE4rnCZKAnhD/hCu9QPKf9KxphMkosFCnFKzpKUJ1OS1QVU8T4v6EVFU/IdqSaJKyfirAgU8JHDhD4sAZsjVl5MNKAWvK4MAqEWt6FtihA9farCJZ07Pi1jSrQNPzmdedRpjsAgv1ubdQESanwEKdU7AR5wgyel6ghTxPiPsLUgv5BbGFjCPZiC8FOPAlgQMXSBy4QLYRjHxYK2AjGBxYJ2IjLgJtBHCtzTqSjbgobiNOhLv/Hr9S+IQLeJNmFUlAvxYQ0K8JxfMbkoB+E3Cv/heWWyYC+SDeS0AcVAvepZTuv8dvCfdIIGdENyQ5v8MFHalKzu8EyHlZYQRxmaAiVwTU8woh7u9J6vk90X5WJHVQPwhw4AcCB34kceBH8giCkQ+bBUYQDA5sERlBXAU6MeBamy2kEcTVgBzyv8AuJBLZ6P3kuRDzk0Cj97OGCzFRSHL+4pHT/CJAzmsi5IRWzl89i2x+FSDnbwoW+TdCi3hdwB5dJ8R9g2SPbhDtURWSRf5dgAO/Ezhwk8SBm2SLzMiHVwUsMoMDW0Us8i2gRQautdlKssi3xCzybdz6RKk2ercFGr2wVAI7E4A3adaRmoZ7UrlfMOw9ouNOkopT8JKkou9MiEUWvKRAHFQLXtJU7r/HcMI9MsgZgyRnMlzQsmOXZALkTI6+R8bYJTlBRVIIqGcKQtwpSeppr1uQRNLqpA4qlQAHUhE4kJrEgdSpuGMXRj7sEBi7MDiwU2TskgboxIBrbXaSxi5pUtHHLvHIRi+t50JMWoFGL52IC6mAJGd6j5wmvQA5M4iQE1o5M3oW2WQUIGcmBYucidAiZhawR5kJcWch2aMsRHtUi2SRswpwICuBA9lIHMhGtsiMfHhHwCIzOLBLxCJnB1pk4FqbXSSLnF3MIufArY/szoQcAo1eToWdCcCbNBtJTUMugaYhF0EwcpOahtz8nQldkAUvjzd2MXkECl5ekbFLZyQ583ljF5NPgJz5FcYu+QkqUkBAPQsQ4i5IUs+CRMtdl9RBFRLgQCECBwqTOFCYPHZh5MM+gbELgwP7RcYuRYBODLjWZj9p7FKEP3bpimz0inouxBQVaPSKibgQ6JPbinvkNMUFyFlChJzQylnSs8impAA5SylY5FKEFrG0gD0qTYi7DMkelSHao/oki3yvAAfuJXCgLIkDZckWmZEPhwQsMoMDh0UscjmgRQautTlMssjlxCxyeW9ngikv0OhFKOxMAN6k2UJqGoxA02AIghFJahoi6TsTIqEPiYnyxi4mSqDgRWuMXSINkpwx3tjFxAiQM1Zh7BJLUJE4AfWMI8QdT1LPeKLlbkTqoCoIcKACgQMVSRyoSB67MPLhmMDYhcGB4yJjl0pAJwZca3OcNHapRB+7REYjG73KngsxlQUavSoiLgT65LaqHjlNVQFyVhMhJ7RyVvcssqkuQM4aCha5BqFFrClgj2oS4q5Fske1iPaoCcki1xbgQG0CB+qQOFCHbJEZ+XBKwCIzOHBaxCLXBVpk4Fqb0ySLXFfMItfzdiaYegKN3n0KOxOAN2m2kpqG+gJNQ32CYDQgNQ0N+DsToA+JaeiNXUxDgYLXSGTsEock5/3e2MXcL0DOxgpjl8YEFWkioJ5NCHE/QFLPB4iWuympg3pQgAMPEjjQlMSBpuSxCyMfzgmMXRgcOC8ydmkGdGLAtTbnSWOXZvyxSydko/eQ50LMQwKNXnMRFwJ9ctvDHjnNwwLkbCFCTmjlbOlZZNNSgJytFCxyK0KL2FrAHrUmxN2GZI/aEO1Rc5JFbivAgbYEDrQjcaAd2SIz8uGCgEVmcOCiiEVuD7TIwLU2F0kWub2YRe7g7UwwHQQavY4KOxOAN2m2k5qGTgJNQyeCYHQmNQ2d+TsToA+J6eKNXUwXgYKXIDJ2SUCSs6s3djFdBcjZTWHs0o2gIt0F1LM7Ie4eJPXsQbTcLUkdVE8BDvQkcKAXiQO9yGMXRj5cFhi7MDhwRWTs0hvoxIBrba6Qxi696WOXqAhko9fHcyGmj0Cj11fDhURBn9zWzyOn6SdAzv4i5IRWzkc8i2weESDnowoW+VFCizhAwB4NIMQ9kGSPBhLtURuSRR4kwIFBBA4MJnFgMNkiM/LhRwGLzODAVRGLPARokYFrba6SLPIQMYs81NuZYIYKNHqPKexMAN6k2UlqGoYJNA3DCIIxnNQ0DKfvTIiCPiRmhDd2MSMECt5IkbFLFJKcj3tjF/O4ADlHKYxdRhFUZLSAeo4mxD2GpJ5jiJa7PamDekKAA08QODCWxIGx5LELIx+uC4xdGBy4ITJ2GQd0YsC1NjdIY5dx/LFLLLLRe9JzIeZJgUbvKREXAn1y23iPnGa8ADkniJATWjknehbZTBQg5yQFizyJ0CJOFrBHkwlxTyHZoylEe9SJZJGnCnBgKoEDT5M48DTZIjPy4ZaARWZw4LaIRZ4GtMjAtTa3SRZ5mphFnu7tTDDTBRq9GQo7E4A3aXaRmoaZAk3DTIJgzCI1DbP4OxOgD4mZ7Y1dzGyBgjdHZOxSAUnOZ7yxi3lGgJxzFcYucwkqMk9APecR4p5PUs/5RMudQOqgnhXgwLMEDiwgcWABeezCyIfkOe5ODqTIgRensDD82GUh0IkB19og8QvMoYX8sUsXZKO3yHMhZpFAo/eciAuBPrltsUdOs1iAnEtEyAmtnEs9i2yWCpDzeQWL/DyhRVwmYI+WEeJeTrJHy4n2qDvJIq8Q4MAKAgdeIHHgBbJFZuRDagGLzOBAGhGLvBJokYFrbdKQLPJKMYu8ytuZYFYJNHqrFXYmAG/S7CE1DWsEmoY1BMFYS2oa1tJ3JkRDHxKzzhu7mHUCBW+9yNilG5KcL3pjF/OiADk3KIxdNhBUZKOAem4kxL2JpJ6biJa7F6mDekmAAy8ROLCZxIHN5LELIx8yC4xdGBzIIjJ22QJ0YsC1NllIY5ct9LFLdCSy0XvZcyHmZYFG7xUNFxINfXLbqx45zasC5NwqQk5o5XzNs8jmNQFyvq5gkV8ntIjbBOzRNkLc20n2aDvRHvUlWeQ3BDjwBoEDb5I48CbZIjPyIbuARWZwIIeIRd4BtMjAtTY5SBZ5h5hF3untTDA7BRq9txR2JgBv0uwnNQ1vCzQNbxME4x1S0/AOf2cC9CExu7yxi9klUPB2i4xdYpDkfNcbu5h3Bcj5nsLY5T2CiuwRUM89hLj3ktRzL9FyP0LqoN4X4MD7BA7sI3FgH3nswsiH/AJjFwYHCoiMXfYDnRhwrU0B0thlP3/sEo9s9A54LsQcEGj0Doq4EOiT2w555DSHBMh5WISc0Mr5gWeRzQcC5PxQwSJ/SGgRjwjYoyOEuI+S7NFRoj0aSLLIHwlw4CMCBz4mceBjskVm5ENhAYvM4EAREYt8DGiRgWttipAs8jExi3zc25lgjgs0eicUdiYAb9IcJjUNJwWahpMEwThFahpO8XcmQB8Sc9obu5jTAgXvE5GxS2ckOT/1xi7mUwFynlEYu5whqMhZAfU8S4j7M5J6fka03ENIHdTnAhz4nMCBcyQOnCOPXRj5UFpg7MLgQBmRsct5oBMDrrUpQxq7nOePXboiG70vPBdivhBo9L4UcSHQJ7dd8MhpLgiQ86IIOaGV8yvPIpuvBMj5tYJF/prQIn4jYI++IcR9iWSPLhHt0TCSRf5WgAPfEjjwHYkD35EtMiMfyglYZAYHyotY5MtAiwxca1OeZJEvi1nkK97OBHNFoNH7XmFnAvAmzVFS0/CDQNPwA0EwfiQ1DT/SdybEQB8Sc9Ubu5irAgXvJ42xS4xBkvNnb+xifhYg5y8KY5dfCCpyTUA9rxHi/pWknr8SLfdIUgf1mwAHfiNw4DqJA9fJYxdGPsQKjF0YHIgTGbvcADox4FqbONLY5QZ97BITjWz0fvdciPldoNG7KeJCoE9uu+WR09wSIOdtEXJCK2dYas8iAzGg3eM96HtkWGR7k+gWMQk4cEZrnIQQd9LUnNbOXrcgiaSjSRY5XIAD4QQOJCNxIFlqrkVm5ENFAYvM4EAlEYucHMdVA1xrU4lkkZOn1rLIKXDrI7szIYVAo5cSfY+MnQnAmzTHSU1DKoGmIRVBMFKTmobUqek7E6APiUkDxEG14KURKHhpCffIIGcckpzpvLGLSSdAzvQKY5f0BBXJIKCeGQhxZySpZ0ai5R5L6qAyCXAgE4EDmUkcyEweuzDyoabA2IXBgVoiY5csQCcGXGtTizR2ycIfu3RCNnpZPRdisgo0etlEXAj0yW3ZPXKa7ALkzCFCTmjlzOlZZJNTgJy5FCxyLkKLmFvAHuUmxJ2HZI/yEO3RUySLnFeAA3kJHMhH4kA+skVm5ENdAYvM4EA9EYucH2iRgWtt6pEscn4xi1zA25lgCgg0egUVdiYAb9KcJjUNhQSahkIEwShMahoK83cmQB8SU8Qbu5giAgWvqMjYJQFJzmLe2MUUEyBncYWxS3GCipQQUM8ShLhLktSzJNFyTyR1UKUEOFCKwIHSJA6UJo9dGPnQWGDswuBAE5GxSxmgEwOutWlCGruUIebQHKeGWj1lOGbUet8rUJPvJeRjWVJNLkvmE0OXywlwoByBA+VJHChP1mVGPjQV0GUGB5qJ6HIEUJeBa22akXQ5IsjHIWhMDRDTBtlx12qYnYOpIdalaY4uzSVoUySpRkf+A35FJO5lkPwKxCGxmEaRMI0KwJTR895Mgbue7aPiUuL5Gg3upRg43gLjGE/AMSa1hi7HIv0yUEOakDQklqghYSQNiSPVu7gQaAiSX3FADYknYRpP1JB7fPxCXe9fH+ARal8FErYVAvwTQ1dug3WlFgHbigL6HJYSi2MdAo6VRPS5MrB+PgzU5xYkfa5M1OfkJH2uQqp3VUKgz0h+VQHqc1USplVDMJepBsS0NTBn25BythoxZ1ORcrY6iV/VQ5CzSH5VB+ZsDRKmNchzmXvA/UpzQr9SU6DvSwLGsQUBx1oifV9tYI63B2pIB5KG1CZqSFqShtQh1bs6IdAQJL/qADWkLgnTukQNsdxKCqx9di7TiVD76pGwrUeey4SDdSWBgO19AvqcDIxjNwKO9UX0uQGwfnYD6nN3kj43IOpzRpI+NyTVu4Yh0GckvxoC9bkRCdNGIZjL3A/EtBcwZ3uTcvZ+Ys5mIuVsYxK/GocgZ5H8agzM2SYkTJuQ5zLJwf3KEEK/8oBA35cCjONjBBwfFOn7mgJzvB9QQ/qTNKQpUUOykjSkGaneNQuBhiD51QyoIQ+RMH2IPJdJCZ7LjCXUvuYkbJuT5zKpwLryFAHbhwX0OTUYxwkEHFuI6HNLYP0cAtTnoSR9bknU55wkfW5FqnetQqDPSH61AupzaxKmrUMwl2kDxHQ4MGdHkHK2DTFnc5Fyti2JX21DkLNIfrUF5mw7EqbtyHOZNOB+ZR6hX2kv0PelBeP4LAHHDiJ9X0dgjo8CashokoZ0JGpIXpKGdCLVu04h0BAkvzoBNaQzCdPO5LlMOvBcZjmh9nUhYduFPJdJD9aVlQRsEwT0OQMYx9UEHLuK6HM3YP0cD9TnCSR97kbU54Ikfe5OqnfdQ6DPSH51B+pzDxKmPUIwl+kJxHQyMGenkHK2JzFnC5FytheJX71CkLNIfvUC5mxvEqa9Q5CzfYCYTgPm7HRSzvYh5uxMUs72JfGrbwhyFsmvvsCc7UfCtB95lvoG0GMsJj1fs7+AV3sTiOMSEo6PiHi1R4E5PguoIbNJGvIoUUNKkTRkAKneDQiBhiD5NQCoIQNJmA4kakhpwjOh3iXMqQaRsB1EnqXuAerKUpKuDBbRlSHAvF8A1JWFJF0ZQtSVciRdGUrK06Eh0BUkv4YCdeUxEqaPkb3JIWDte55U+4YJeJPDQByXkXAcLqIhI4A5vhioIUtIGjKCqCGGpCEjSfVuZAg0BMmvkUANeZyE6ePkfR7Lwd7kOMGbjCJhO4rsTU4CdWUFSVdGi+jKGGDerwTqyiqSrowh6ko0SVeeIOXpEyHQFSS/ngDqylgSpmPJ3uQzYO17gVT7xgl4k8+BOK4k4fikiIY8BczxtUANWUfSkKeIGhJH0pDxpHo3PgQaguTXeKCGTCBhOoHsTVaBvcnXBG8ykYTtRLI3+RaoK6tJujJJRFcmA/N+M1BXtpB0ZTJRVyqSdGUKKU+nhEBXkPyaAtSVqSRMp5K9yc/A2reGVPueFvAm14A4riXhOE1EQ6YDc/xVoIZsJWnIdKKGVCFpyAxSvZsRAg1B8msGUENmkjCdSfYm68De5J5UeL7OImE7i+xNwlPhrreepCuzRXRlDjDvdwB1ZSdJV+YQdaU6SVeeIeXpMyHQFSS/ngHqylwSpnPJ3iQdsPa9SKp98xSeDQDEcQMJx/kiGvIsMMffAWrILpKGPEvUkFokDVlAqncLQqAhSH4tAGrIQhKmC8neZCPYm+QieJNFJGwXkb1JXqCubCLpynMiurIYmPf7gLqyn6Qri4m6UpekK0tIebokBLqC5NcSoK4sJWG6lOxNigFr30uk2ve8gDcpAcRxMwnHZSIashyY44eAGnKYpCHLiRpSn6QhK0j1bkUINATJrxVADXmBhOkLZG+yBexNDMGbrCRhu5LsTaKBuvIySVdWiejKamDeHwPqynGSrqwm6kojkq6sIeXpmhDoCpJfa4C6spaE6VqyN6kCrH2vkGrfOgFvUg2I46skHNeLaMiLwBw/BdSQ0yQNeZGoIU1IGrKBVO82hEBDkPzaANSQjSRMN5K9yVawN6lP8CabSNhuInuTRkBdeY2kKy+J6MpmYN6fA+rKeZKubCbqSlOSrmwh5emWEOgKkl9bgLryMgnTl8nepDmw9r1Oqn2vCHiTFkAct5FwfFVEQ7YCc/wCUEMukjRkK1FDmpM05DVSvXstBBqC5NdrQA15nYTp62Rvsh3sTToRvMk2ErbbyN4kAagrb5B0ZbuIrrwBzPvLQF25QtKVN4i60pKkK2+S8vTNEOgKkl9vAnVlBwnTHWRv0hdY+94k1b6dAt6kPxDHHSQc3xLRkLeBOf4jUEOukjTkbaKGtCFpyDukevdOCDQEya93gBqyi4TpLrI32Qn2JsMI3mQ3CdvdZG8yEqgrb5F05V0RXXkPmPfXgbpyg6Qr7xF1pT1JV/aQ8nRPCHQFya89QF3ZS8J0L9mbPAWsfW+Tat/7At5kAhDHd0g47hPRkP3AHL8F1JDbJA3ZT9SQTiQNOUCqdwdCoCFIfh0AashBEqYHyd5kF9ibzCR4k0MkbA+RvckcoK7sJunKYRFd+QCY98lz4K6VIgeHmx8QdSWBpCsfkvL0wxDoCpJfHwJ15QgJ0yNkb/IcsPa9S6p9RwW8yRIgju+RcPxIREM+BuZ4aqCGpCFpyMdEDelO0pBjpHp3LAQaguTXMaCGHCdhepzsTfaAvckagjc5QcL2BNmbrAfqyl6SrpwU0ZVTwLzPDNSVLCRdOUXUlV4kXTlNytPTIdAVJL9OA3XlExKmn5C9ySvA2vc+qfZ9KuBNtgJx3EfC8YyIhpwF5nh2oIbkIGnIWaKG9CVpyGekevdZCDQEya/PgBryOQnTz8neZD/Ym7xN8CbnSNieI3uT3UBdOUDSlfMiuvIFMO/zA3WlAElXviDqyiMkXfmSlKdfhkBXkPz6EqgrF0iYXiB7k4PA2neQVPsuCniTw0AcD5Fw/EpEQ74G5nhhoIYUIWnI10QNGUjSkG9I9e6bEGgIkl/fADXkEgnTS2RvchjsTU4SvMm3JGy/JXuTT4C68gFJV74T0ZXLwLwvDdSVMiRduUzUlSEkXblCytMrIdAVJL+uAHXlexKm35O9yZfA2vchqfb9IOBNLgJxPELC8UcRDbkKzPFyQA0pT9KQq0QNGUbSkJ9I9e6nEGgIkl8/ATXkZxKmP5O9yVGwN/mB4E1+IWH7C9mb/ATUlY9IunJNRFd+BeZ9LFBX4ki68itRV0aSdOU3Up7+FgJdQfLrN6CuXCdhep3sTW4Ca9/HpNp3Q8Cb3AbieIyE4+8iGnITmOMVgRpSiaQhN4kaMpqkIbdI9e5WCDQEya9bQA25TcL0NtmbHAd7k1Sp8XwNS8PB1l6X6U3SArl6gqQr96TR0JUkuPs0NYG6UoukKzbegr7ronVlLElXkpLyNGkavq4g+RWIQ2IxDSdhGp6G602yAWvfSVLtSwaufQwccwBxPEXCMbmIhqQA5nhdoIbUI2lICqKGPEXSkJSkepcyBBqC5FdKoIakImGaKg3Xm5wGe5NCBG+SmoRtarI3KQrUlU9IupJGRFfSAvO+MVBXmpB0JS1RVyaSdCUdKU/ThUBXkPxKB9SV9CRM0/8DTBN77xmAmDYF5mwzUs5mIObsHFLOZiTxK2MIchbJr4zAnM1EwjSTD9Nw50gZwLHAF5p394ZhY/G/Mqch3nDmNPjrZgEShBV3ljR/Agy67l+aOnSTHAX8cCgrsBgEW5/E3l9Z3/qgMSwLvMdsYDOA5rhd42xp8GuTnVSwswcUbPtesrC/v9xcsJn3WUbkPkuL3GdUam7uJjbHyoX9kQPo+pcUeK1yYZxmJ0dAzYIvPLJo20KVKmCRmIRFdMnd/nhFBLndxF7b+E8Cscjpa7BypfEB4q/0OX0rHPherhBYoEyJ70ojfRlqcgI73FzgxUVXI5s0OUndMjhRYjORup7cpK4nN/kji8Xgjyz6Ez6yyOPyj70tjkvAOD5CwDGvAI5LwTgOJuCYTwDH59E/Z0rAMb8AjsvAOA4n4FhAAMcVYBxHE3AsKIDjC2AcxxFwLCSA40owjk8ScCwsgONqMI6TCDgWEcBxDRjHpwk4FhXAcS0Yx2kEHIsJ4LgejONsAo7FBXB8EYzjPAKOJQRw3ADGcT4Bx5ICOG4C4/gcAcdSAji+BMbxeQKOpQVw3AzGcRkBxzICOL4MxnEVAcd7BXB8BYzjOgKOZQVwfBWM43oCjuUEcHwNjONLBBzLC+D4OhjHVwg4RgjguA2M46sEHI0Ajm+AcdxOwDFSAMc3wTjuJOAYJYDjDjCObxFwjBbA8S0wju8ScIwRwPFtMI7vE3CMFcDxHTCO+wg4xgnguBuM42ECjvECOL4LxvEoAccKAji+B8bxIwKOFQVw3Iv+GR4CjpUEcHwfjOOnBBwrC+C4D4zjGQKOVQRwPADG8TwBx6oCOB4E43iRgGM1ARwPgXH8ioBjdQEcPwDj+B0BxxoCOH6I/okPAo41BXA8AsbxRwKOtQRw/AiM4zUCjrUFcPwYjOMNAo51BHA8BsbxdwKOdQVwPAHG8R7CdzfrCeB4EoxjMgKO9wngeAqMY3ICjvUFcPwEjGMaAo4NgDja72Pbp8F09F3PfifZfp92oFPXBzmH/U7oY85f+51G+328x53zUfanMJzzsc5f+50o+32eCc75ROew30mZ6vy136mw3weY6ZzPcg67p32u89fuybb7iRc654ucw+6JXer8tXs67X7EF5zzlc5h99Stdf7aPWF2P9NG53yTc9g9OS87f+2eErsf4nXnfJtz2M/0dzh/7WfS9vPUXc75buewnwnudf7az7Ts5zEHnfNDzmE/Uzji/LUzcTvPPe6cn3AOO5P8xPlrZ2p2HvS5c37OOexM44Lz91+ePM0fP6Nuf+7beiL707e2p7f9qP0JQ/tTe7ansj87ZXsCq2f250Psz1zYmmwf+W5ris0H++he+4hZu6bpA541oPJ8gIZALibxcfHOF+r6JGwNEgPWPTZC3yO6+NqAswEfLmKvZYNG32cj4D3er5M85m5OnvvR98iq7miyIxOyMelJMo3T0B6oK4FrE0+BTROBIvKA2xXYLjxagR8gJM8DwHt80FNgieR58C5V4EhkQjYlKXBTPQWG4trMU2DTTKCIPMQuIgjFtDeJegBoQkx0tOkckQB8+utfQExsvM099ZVInOZ3qfpGIVXiYZL6PqynvlBcW3jqa1oIFJGWbldfm1D+B9AjA2c9fD6x8bYifxyL6IaApPnX0K0VYR7REljMWnsdkUQxa32XdkTRSOVuQ+qI2uh1RFBc23odkWkrUETauf0TAUvKHOBPBNoRFLgd8B7bewoskTzt71IFjkEqRQeSAnfQU2Aorh09BTYdBYpIJ7crsP3BPvRn8p0ICtwJeI+dPQWWSJ7OLldgo7B7qwtJgbuk+fNXZe3h/arsn/dZRuQ+S4vcJ/pXZVn32QosLP5Xgu97G13t9yvQN21/Dtz+fDd6uo78SfAswCl9YBFLCChiofrF2X4AMvt+lLRLkNtN7LWD/uJsNx8Bu6cJ++uvy3ZL8/dfnO0e4M38L/RHXoEgJvYXZ7sB1bZ7Gs7iopMTGXMPYHKGheETzhaiLEE2Pbm1wCX2Wj1dvh6WLz3T4D9e7wm2C+C4423NYsTdi9Th90rD/QXlm+BvQkcTnhTRm7yFISJxr3/heAuMYwwBxz4CON4G41iRgGNfARzDUmJxrETAsZ8AjveAcaxJwLG/AI5JwDjWIuD4iACO4WAc7yPg+KgAjsnAONYn4DhAAMfkYBwfIOA4UADHFGAcHyTgOEgAx1RgHB8m4DhYAMfUYBxbEHAcIoBjGjCO7Qk4DhXAMS0Yxw4EHB8TwDE9GMcEAo7DBHDMAMaxKwHH4UAc7TzSztoL+q5nZ3J2nhRvn67nHHYmYv18Vfu0POewntT6qbrOeT3nsJ7A9rONnPMmzmF7MttPPOScN3cOq4m2nrd2zts5h61JNp86O+ddnMNywsbTwznvnTrs3y+V+fAI8KfSZcP+/kJdn4StGZHG/fc40u17BW3APcEfVI0kbJ8aCbzHx3WSh7ZXUCF5HkffI6u6o8mOTMhRpE8SR/F260vgOtpTYDNaoIiMcbsC2w2waAUeQ0ieMcB7fMJTYInkeeIuVeBIZEKOJSnwWD0FhuI6zlNgM06giDzpdgUuE4ZX4CcJCvwk8B6f8hRYInmeuksVOAqZkONJCjxeT4GhuE7wFNhMECgiE92uwK3S4BV4IkGBJwLvcZKnwBLJM+kuVeBoZEJOJinwZD0FhuI6xVNgM0WgiEx1uwKXDsMr8FSCAk8F3uPTngJLJM/Td6kCxyATchpJgafpKTAU1+meApvpAkVkhtsVuCvBA88gKPAM4D3O9BRYInlm3qUKHItMyFkkBZ6lp8BQXGd7CmxmCxSROW5X4KjUeAWeQ1DgOcB7fMZTYInkeeYuVeA4ZELOJSnwXD0FhuI6z1NgM0+giMx3uwInEDzwfIICzwfe47OeAkskz7MuV2Cj8K2ZBSQFXsBT4H8XJTfjupCE60IirlnT/PGkffR3oxcRiol9JQHfJ/L5sM+lwRZ59FrbNXmOsNaLSbxffJfXkyXgHEJjaLm0hMCnpSQ+LSXyiZVbp3LdnRw4nYujH+hnlT8PrPnAtTZI/AJz6HlfDqlOCOKTuf8elyHrvupCTRJYqOXeQkWYKQILtcLtY4P41Bwb9oJAC/kCIe6VpBZyJbGFtNZhBQGLVQIcWEWIezWJA6uJHGDlwxkBG8HgwFkRG7EGaCOAa23OkmzEGnEbMUug6Vnr9g8aK9zxE8kRiXv9S0DXEorIOgEBXUeIez1JQNcH3Kv/BeZW9HPAOeyL3s4K82Ia99/jBtJnTmhyxiDJudEjp9koQM5NIuSEVs6XcEFHqpLzJQFybnb7fKwqaT62RaC120KI+2VSa/cyeT62mYDFKwIceIUQ96skDrxKno8x8uGCwHyMwYGLIvOxrcAxAXCtzUXSfGxrQA75X252Ia95jZ55TaDRe93tjV4NUqO3TUDktxHi3k4S+e3kRu91AhZvCHDgDULcb5I48Ca50WPkwzcCjR6DA5dEGr0dwEYPuNbmEqnR28Fv9OKRjd5Ob9xsdgo0em+JjJsrIMn5tkdO87YAOd8RISe0cu7yLLLZJUDO3W63yHVJFvldAXv0LiHu90j26D2yRd5NwGKPAAf2EOLeS+LAXrJFZuTDZQGLzODAFRGL/D7QIgPX2lwhWeT3xSzyPtz6RKk2evsEGr39bt8fXY+wP3o/oXAeEGgaDhDiPkhqGg7y90d3QRa8Q97YxRwSKHiHRcYuCUhyfuCR03wgQM4PRcgJrZxHvJmgOSJAzqNunwk2Is0EPxJo7T4ixP0xqbX7mDwTPErA4pgAB44R4j5O4sBx8kyQkQ+/CMwEGRy4JjITPAEcEwDX2lwjzQRP8GeCUBdy0mv0zEmBRu+U2xu9JqRG77SAyJ8mxP0JSeQ/ITd6pwhYfCrAgU8JcZ8hceAMudFj5MN1gUaPwYEbIo3eWWCjB1xrc4PU6J2lN3omAtnofeaNm81nAo3e5xrjZmOQ5DznkdOcEyDneRFyQivnF55FNl8IkPNLt1vkh0gW+YKAPbpAiPsiyR5dJFvkLwlYfCXAga8IcX9N4sDXZIvMyIdbAhaZwYHbIhb5G6BFBq61uU2yyN+IWeRL3v5oc0mg0fvW7fujmxP2R39LKJzfCTQN3zG+SERqGi7T90cb6FNQr3hjF3NFoOB9LzJ2gT657QePnOYHAXL+KEJOaOW86s0EzVUBcv7k9plga9JM8GeB1u5nxn5QUmv3C3km+BNjj6gAB64R4v6VxIFfyTNBRj4kz313ciBFbrw4hYXhZ4K/AccEwLU2SPwCc+g3/kwQ6kKue42euS7Q6N1we6PXjtTo/S4g8r8T4r5JEvmb5EbvBuODPwEO3GJ88EfiwG1yo8fIh9QCjR6DA2lEGr2wtDgsgWtt0pAaPRtvwbC/vsCNHvThWPfg1kd23IzEgHWPSdJy8h1NTujzo5N65DRJBcgZLkJOaOVMhgta1iInEyBncvQ9om+wM8kipwAHzmiN7T2i406ZltPapUzLtcjJCVikEuBAKkLcqUkcSJ2Wa5EZ+ZBewCIzOJBBxCKnAVpk4FqbDCSLnEbMIqfFrY/s/ui0Ao1eOvQ9JgHfYBfC/uh0DMEQaBrSMwSD1DRkSEvfHw19CmpGb+xiMgoUvEwiYxfok9sye+Q0mQXImUWEnNDKmdWbCZqsAuTM5vaZYA/STDC7QGuXndDa5SC1djnIM8FsBCxyCnAgJyHuXCQO5CLPBBn5kF1gJsjgQA6RmWBu4EwQuNYmB2kmmJs/E4S6kDxeo2fyCDR6ed3e6PUmNXr5BEQ+H6HA5yeJfH5yo5eXgEUBAQ4UIMRdkMSBguRGj5EPuQUaPQYH8og0eoWAjR5wrU0eUqNXiJhD/UhaWligjhYm5FARUh0tQuaA1VP0Z7c9geahqACfihL4VIzEp2JkXWbkVn4BXWZwoICILhcH6jJwrU0Bki4X9+WQrZv3hv39hV4zNF/jk7n/Hksg677qQk0SWKiS3kJFmCkCC1XK7eM9a0dKEWS0tEALWZoQdxlSC1mG2EIO9FkSNBb3CnDgXgIHypI4UJZsIxj5UFjARjA4UETERpQD2gjgWpsiJBtRTtxGzBJoesq7/XsOg3yCh7qebaLKE4pIhICARhDiNiQBNb57VU3+GwLJH+lZ0whzU2ChohSsaRShukQLVNVoQtwxpKoaQ7Qlj5GsaawAB2IJHIgjcSCObE0Z+VBawJoyOFBGxJrGA60pcK1NGZI1jRe3puHJ3X+PFbzuNMIkF1ioit5CRZiUAgtVScFGVCLIaGWBFrIyIe4qpBayCrGFfJxkI6oKcKAqgQPVSByoRrYRjHwoJ2AjGBwoL2IjqgNtBHCtTXmSjagubiPSCjQ9Ndz+CdcowidcNQhFpKaAgNYkxF2LJKC1xD/hSi+Q/LU9axphMgosVB0Fa1qHUF3qClTVuoS465Gqaj2iLRlLsqb3CXDgPgIH6pM4UJ9sTRn5ECtgTRkciBOxpg2A1hS41iaOZE0biFvTrAJNT0OvO40w2QUWqpG3UBEmp8BC3a9gI+4nyGhjgRayMSHuJqQWsgmxhZxAshEPCHDgAQIHHiRx4EGyjWDkQ0UBG8HgQCURG9EUaCOAa20qkWxEU3EbcSLc/ffYzO2fcE0kfMLVjFBEHhIQ0IcIcTcnCWjzgHv1v7DcMhHIB/E+DMRBteA9nNb999iCcI8EckZ0Q5KzJS7oSFVythQgZyuFEUQrgoq0FlDP1oS425DUsw3Rfk4ljSDaCnCgLYED7UgcaEceQTDyoabACILBgVoiI4j2wBEEcK1NLdIIon1ADvlfYBcSiWz0OnguxHQQaPQ6argQE4UkZyePnKaTADk7i5ATWjm7eBbZdBEgZ4KCRU4gtIhdBexRV0Lc3Uj2qBvRHs0kWeTuAhzoTuBADxIHepAtMiMf6gpYZAYH6olY5J5Aiwxca1OPZJF7ilnkXrj1iVJt9HoJNHq93b4zYRZhZ0JvQuHsI9A09CHE3ZfUNPTl70yIRRa8ft7YxfQTKHj9RcYuMUhyPuKNXcwjAuR8VGHs8ihBRQYIqOcAQtwDSeo5kGi555LGLoMEODCIwIHBJA4MJo9dGPnQWGDswuBAE5GxyxDg2AW41qYJaewyhD92iUc2ekM9F2KGCjR6j4m4kApIcg7zyGmGCZBzuAg5oZVzhGeRzQgBco5UsMgjCS3i4wL26HFC3KNI9mgU0R4tJFnk0QIcGE3gwBgSB8aQLTIjH5oKWGQGB5qJWOQngBYZuNamGckiPyFmkcd6OxPMWIFGb5zbdyYsIuxMGEconE8KNA1PEuJ+itQ0PMXfmdAFWfDGe2MXM16g4E0QGbt0RpJzojd2MRMFyDlJYewyiaAikwXUczIh7ikk9ZxCtNxLSWOXqQIcmErgwNMkDjxNHrsw8qG1wNiFwYE2ImOXacCxC3CtTRvS2GUaf+zSFdnoTfdciJku0OjNEHEh0Ce3zfTIaWYKkHOWCDmhlXO2Z5HNbAFyzlGwyHMILeIzAvboGULcc0n2aC7RHr1AssjzBDgwj8CB+SQOzCdbZEY+tBewyAwOdBCxyM8CLTJwrU0HkkV+VswiL/B2JpgFAo3eQrfvTFhJ2JmwkFA4Fwk0DYsIcT9Hahqeo+9MiIQ+JGaxN3YxiwUK3hKNsUukQZJzqTd2MUsFyPm8wtjleYKKLBNQz2WEuJeT1HM50XKvJY1dVghwYAWBAy+QOPACeezCyIduAmMXBge6i4xdVgLHLsC1Nt1JY5eV9LFLZDSy0VvluRCzSqDRWy3iQqBPblvjkdOsESDnWhFyQivnOs8im3UC5FyvYJHXE1rEFwXs0YuEuDeQ7NEGoj3aSLLIGwU4sJHAgU0kDmwiW2RGPvQSsMgMDvQWscgvAS0ycK1Nb5JFfknMIm/2diaYzQKN3ha370zYRNiZsIVQOF8WaBpeJsT9CqlpeIW/MwH6kJhXvbGLeVWg4G0VGbvEIcn5mjd2Ma8JkPN1hbHL6wQV2SagntsIcW8nqed2ouV+mTR2eUOAA28QOPAmiQNvkscujHwYIDB2YXBgoMjYZQdw7AJcazOQNHbZwR+7dEI2ejs9F2J2CjR6b4m4EOiT2972yGneFiDnOyLkhFbOXZ5FNrsEyLlbwSLvJrSI7wrYo3cJcb9HskfvEe3R6ySLvEeAA3sIHNhL4sBeskVm5MMQAYvM4MBQEYv8PtAiA9faDCVZ5PfFLPI+b2eC2SfQ6O13+86EbYSdCfsJhfOAQNNwgBD3QVLTcJC/MwH6kJhD3tjFHBIoeIdFxi4JSHJ+4I1dzAcC5PxQYezyIUFFjgio5xFC3EdJ6nmUaLl3kMYuHwlw4CMCBz4mceBj8tiFkQ+jBMYuDA6MFhm7HAOOXYBrbUaTxi7H6GOXqAhko3fccyHmuECjd0LDhURBn9x20iOnOSlAzlMi5IRWztOeRTanBcj5iYJF/oTQIn4qYI8+JcR9hmSPzhDt0S6SRT4rwIGzBA58RuLAZ2SLzMiHsQIWmcGBcSIW+XOgRQautRlHssifi1nkc97OBHNOoNE77/adCbsJOxPOEwrnFwJNwxeEuL8kNQ1f0ncmREEfEnPBG7uYCwIF76LI2CUKSc6vvLGL+UqAnF8rjF2+JqjINwLq+Q0h7ksk9bxEtNx7SWOXbwU48C2BA9+ROPAdeezCyIfJAmMXBgemiIxdLgPHLsC1NlNIY5fL/LFLLLLRu+K5EHNFoNH7XsSFQJ/c9oNHTvODADl/FCEntHJe9SyyuSpAzp8ULPJPhBbxZwF79DMh7l9I9ugXoj06SLLI1wQ4cI3AgV9JHPiVbJEZ+TBNwCIzODBdxCL/BrTIwLU200kW+Tcxi3zd25lgrgs0ejfcvjPhEGFnwg1C4fxdoGn4nRD3TVLTcJO/MwH6kJhb3tjF3BIoeLdFxi4VkOQMS+eNXYAY0O7xHvQ9MsYu9ibRKpIknfvVMwkh7qTpOOppr1uQRNIjpLFLuAAHwgkcSEbiQLJ03LELIx/mCoxdGByYJzJ2SY7jqgGutZlHGrskT0cfu3RBNnopgLVEtdFLIdDopUzHyXc0OaFPbkvlkdOkEiBnahFyQitnGs8imzQC5EyrYJHTElrEdAL2KB0h7vQke5SeaI+OkyxyBgEOZCBwICOJAxnJFpmRDwsELDKDAwtFLHImoEUGrrVZSLLImcQscmbc+sjuTMgs0OhlQd8jemfCCcLOhCyEwplVoGnISog7G6lpyJaOvTMhGvqQmOze2MVkFyh4OUTGLt2Q5MzpjV1MTgFy5lIYu+QiqEhuAfXMTYg7D0k98xAt9yeksUteAQ7kJXAgH4kD+chjF0Y+LBMYuzA4sFxk7JIfOHYBrrVZThq75KePXaIjkY1eAc+FmAICjV5BDRcSDX1yWyGPnKaQADkLi5ATWjmLeBbZFBEgZ1EFi1yU0CIWE7BHxQhxFyfZo+JEe/Q5ySKXEOBACQIHSpI4UJJskRn5sFLAIjM4sErEIpcCWmTgWptVJItcSswil/Z2JpjSAo1eGbfvTDhH2JlQhlA47xVoGu4lxF2W1DSU5e9MgD4kppw3djHlBApeeZGxSwySnBHe2MVECJDTKIxdDEFFIgXUM5IQdxRJPaOIlvsCaewSLcCBaAIHYkgciCGPXRj5sEFg7MLgwEaRsUsscOwCXGuzkTR2ieWPXeKRjV6c50JMnECjFy/iQqBPbqvgkdNUECBnRRFyQitnJc8im0oC5KysYJErE1rEKgL2qAoh7qoke1SVaI8ukSxyNQEOVCNwoDqJA9XJFpmRD5sFLDKDA1tELHINoEUGrrXZQrLINcQsck1vZ4KpKdDo1XL7zoRvCTsTahEKZ22BpqE2Ie46pKahDn9nAvQhMXW9sYupK1Dw6omMXTojyXmfN3Yx9wmQs77C2KU+QUUaCKhnA0LcDUnq2ZBoub8njV0aCXCgEYED95M4cD957MLIh20CYxcGB7aLjF0aA8cuwLU220ljl8b8sUtXZKPXxHMhpolAo/eAiAuBPrntQY+c5kEBcjYVISe0cjbzLLJpJkDOhxQs8kOEFrG5gD1qToj7YZI9ephoj34mWeQWAhxoQeBASxIHWpItMiMfdghYZAYHdopY5FZAiwxca7OTZJFbiVnk1t7OBNNaoNFr4/adCb8Qdia0IRTOtgJNQ1tC3O1ITUM7+s6EGOhDYtp7YxfTXqDgddAYu8QYJDk7emMX01GAnJ0Uxi6dCCrSWUA9OxPi7kJSzy5Ey32dNHZJEOBAAoEDXUkc6EoeuzDy4T2BsQuDA3tExi7dgGMX4FqbPaSxSzf62CUmGtnodfdciOku0Oj1EHEh0Ce39fTIaXoKkLOXCDmhlbO3Z5FNbwFy9lGwyH0ILWJfAXvUlxB3P5I96ke0R7dJFrm/AAf6EzjwCIkDj5AtMiMf9glYZAYH9otY5EeBFhm41mY/ySI/KmaRB3g7E8wAgUZvoNt3JoSlwe9MGEgonIMEmoZBhLgHk5qGwfydCdCHxAzxxi5miEDBGyoydolDkvMxb+xiHhMg5zCFscswgooMF1DP4YS4R5DUcwTRcoen4YxdRgpwYCSBA4+TOPA4eezCyIcjAmMXBgeOioxdRgHHLsC1NkdJY5dR/LFLJ2SjN9pzIWa0QKM3RsSFQJ/c9oRHTvOEADnHipATWjnHeRbZjBMg55MKFvlJQov4lIA9eooQ93iSPRpPtEepSBZ5ggAHJhA4MJHEgYlki8zIh2MCFpnBgeMiFnkS0CID19ocJ1nkSWIWebK3M8FMFmj0prh9Z0Jqws6EKYTCOVWgaZhKiPtpUtPwNH9nAvQhMdO8sYuZJlDwpouMXRKQ5JzhjV3MDAFyzlQYu8wkqMgsAfWcRYh7Nkk9ZxMtd3rS2GWOAAfmEDjwDIkDz5DHLox8OCMwdmFw4KzI2GUucOwCXGtzljR2mUvMoUwOl6yeoh1zNmDjOE+gJs8j5ON8Uk2eT+YTQ5efFeDAswQOLCBxYAFZlxn5cE5AlxkcOC+iywuBugxca3OepMsLg3wcgsZ0ERDTU7lw1zqdi4PpImJdikodFpaFoE3PkWr0c/+AXxGJexkkvwJxSCymi0mYLg7AlNHz9gZ+SmT7qGUEvi4B91IMHPuAcVxOwHFpOg1dfh7pl4EacpakIc8TNSSepCHLSPVuWQg0BMmvZUANWU7CdDlRQyr4+IW6nvUk6wh8XUHCdkWAf2LoSl+wrmwgYPuCgD73A+O4iYDjShF9XgWsnxeA+nyRpM+riPpclaTPq0n1bnUI9BnJr9VAfV5DwnRNCOYya4GYfgPM2UuknF1LzNkapJxdR+LXuhDkLJJf64A5u56E6XryXKY/uF95i8DXFwX6vkfAOL5DwHGDSN+3EZjjl4EacoWkIRuJGlKXpCGbSPVuUwg0BMmvTUANeYmE6UtEDalHmMscIPB1MwnbzeS5zKNgXTlMwHaLgD4PAOP4IQHHl0X0+RVg/fwFqM/XSPr8ClGfG5H0+VVSvXs1BPqM5NerQH3eSsJ0awjmMq8BMb0OzNkbpJx9jZizTUg5+zqJX6+HIGeR/HodmLPbSJhuI89lBoL7lc8JfN0u0PcNAuN4noDjGyJ935vAHL8F1JDbJA15k6ghD5E0ZAep3u0IgYYg+bUDqCE7SZjuJGpIc8Jc5jsCX98iYfsWeS4zGKwr3xOwfVtAn4eAcfyRgOM7Ivq8C1g/kwO/Z5KC9D2TXUR9bk3S592kerc7BPqM5NduoD6/S8L03RDMZd4DYpoamLNpSDn7HjFn25Fydg+JX3tCkLNIfu0B5uxeEqZ7yXOZoeB+JUlaPF/fF+j7HgPjGE7AcZ9I37cfmOPpgRqSgaQh+4ka0pmkIQdI9e5ACDQEya8DQA05SML0IFFDuhDmMukJte8QCdtD5LnMMLCuZCJge1hAn4eDccxCwPEDEX3+EFg/swP1OQdJnz8k6nMPkj4fIdW7IyHQZyS/jgD1+SgJ06MhmMt8BMQ0NzBn85By9iNizvYm5ezHJH59HIKcRfLrY2DOHiNheiwEOXsciGl+YM4WIOXscWLO9iPl7AkSv06EIGeR/DoBzNmTJExPkmepJdICdZH0fM1TAl6tJBDHvCQcT4t4tU+AOV4YqCFFSBryCVFDBpI05FNSvfs0BBqC5NenQA05Q8L0DFFDBhFmqRGEOdVZErZnybPUSKCu5CPpymciuvI5MO9LA3WlDElXPifqymMkXTlHytNzIdAVJL/OAXXlPAnT82RvUgFY+/KTat8XAt6kIhDHAiQcvxTRkAvAHC8H1JDyJA25QNSQx0kacpFU7y6GQEOQ/LoI1JCvSJh+RdSQUQRvUpPgTb4mYfs12ZvUBupKQZKufCOiK5eAeR8L1JU4kq5cIurKWJKufEvK029DoCtIfn0L1JXvSJh+R/YmDYG1rxCp9l0W8CaNgDgWJuF4RURDvgfmeEWghlQiacj3RA2ZQNKQH0j17ocQaAiSXz8ANeRHEqY/EjVkIsGbPETwJldJ2F4le5MWQF0pQtKVn0R05Wdg3tcE6kotkq78TNSVqSRd+YWUp7+EQFeQ/PoFqCvXSJheI3uTjsDaV5RU+34V8CadgTgWI+H4m4iGXAfmeF2ghtQjach1oobMJGnIDVK9uxECDUHy6wZQQ34nYfo7UUNmEbxJH4I3uUnC9ibZm/QH6kpxkq7cEtGV28C8bwzUlSYkXblN1JW5JF0JS8/Bwl63YNhfX2hdQfIrEIfEYnoPCdN70nO9yWPA2leCVPuSpMfWPgaOw4E4liThmDS9hoaE4+7TNAVqSDOShoSn52nIQpKGJCPVu2Qh0BAkv5IBNSQ5CdPkRA1ZRPAmTxK8SQoStva6TG8yAagrpUi6klJEV1IB8741UFfakHQlFVFXlpJ0JTUpT1OHQFeQ/EoN1JU0JEzTkL3JDGDtK02qfWkFvMksII5lSDimE9GQ9MAcbw/UkA4kDUlP1JAXSBqSgVTvMoRAQ5D8ygDUkIwkTDMSNWQlwZssIniTTCRsM5G9yRKgrtxL0pXMIrqSBZj33YC60p2kK1mIurKWpCtZSXmaNQS6guRXVqCuZCNhmo3sTVYDa19ZUu3LLuBN1gJxLEfCMYeIhuQE5ngvoIb0JmlITqKGbCRpSC5SvcsVAg1B8isXUENykzDNTdSQTQRv8jLBm+QhYZuH7E22AnWlPElX8oroSj5g3g8A6spAkq7kI+rKyyRdyU/K0/wh0BUkv/IDdaUACdMCZG/yFrD2RZBqX0EBb/IOEEdDwrGQiIYUBub4EKCGDCVpSGGihrxO0pAipHpXJAQaguRXEaCGFCVhWpSoIdsI3uQAwZsUI2FbjOxNDgN1JZKkK8VFdKUEMO9HAXVlNElXShB1ZQdJV0qS8rRkCHQFya+SQF0pRcK0FNmbnADWvihS7Sst4E1OAXGMJuFYRkRD7gXm+Fighowjaci9RA3ZRdKQsqR6VzYEGoLkV1mghpQjYVqOqCG7Cd7kC4I3KU/CtjzZm1wE6koMSVciRHTFAPN+MlBXppB0xRB1ZS9JVyJJeRoZAl1B8isSqCtRJEyjyN7ke2DtiyXVvmgBb/IjEMc4Eo4xIhoSC8zxaUANmU7SkFiihhwkaUgcqd7FhUBDkPyKA2pIPAnTeKKGHCJ4k98J3qQCCdsKZG9yG6gr8SRdqSiiK5WAeT8XqCvzSLpSiagrR0i6UpmUp5VDoCtIflUG6koVEqZVyN4kJfC5ZxVIta+qgDdJjfxNDhKO1UQ0pDowxxcANWQhSUOqEzXkOElDapDqXY0QaAiSXzWAGlKThGlNooacIHiTrOnwfK1FwrYW2ZvkAOpKJZKu1BbRlTrAvF8G1JXlJF2pQ9SVT0i6UpeUp3VDoCtIftUF6ko9Eqb1yN6kILD2VSbVvvsEvElhII5VSDjWF9GQBsAcXwnUkFUkDWlA1JDPSRrSkFTvGoZAQ5D8agjUkEYkTBsRNeQcwZvcS/Am95OwvZ/sTcoDdaUqSVcai+hKE2DebwDqykaSrjQh6soFkq48QMrTB0KgK0h+PQDUlQdJmD5I9ibxwNpXjVT7mgp4k4pAHKuTcGwmoiEPAXN8M1BDtpA05CGihlwiaUhzUr1rHgINQfKrOVBDHiZh+jBRQ74leJPaBG/SgoRtC7I3qQfUlRokXWkpoiutgHm/Dagr20m60oqoK9+TdKU1KU9bh0BXkPxqDdSVNiRM25C9yQPA2leTVPvaCniTpkAca5FwbCeiIe2BOb4DqCE7SRrSnqghP5M0pAOp3nUIgYYg+dUBqCEdSZh2JGrILwRv0pbgTTqRsO1E9iYdgLpSm6QrnUV0pQsw798D6soekq50IerKdZKuJJDyNCEEuoLkVwJQV7qSMO1K9iY9gLWvDqn2dRPwJr2AONYl4dhdREN6AHN8H1BD9pM0pAdRQ26TNKQnqd71DIGGIPnVE6ghvUiY9iJqSFgavDcZRPAmvUnY9iZ7k6FAXalH0pU+IrrSF5j3R4C6cpSkK32JuhKehqMr/Uh52i8EuoLkVz+grvQnYdqf7E3GAGvffaTa94iANxkLxLE+CcdHRTRkADDHjwE15DhJQwYQNSQVSUMGkurdwBBoCJJfA4EaMoiE6SCihqQmeJOpBG8ymITtYLI3mQ7UlQYkXRkioitDgXl/BqgrZ0m6MpSoK+lJuvIYKU8fC4GuIPn1GFBXhpEwHfYPME3svQ8HYnoOmLPnSTk7nJizmUg5O4LErxEhyFkkv0YAc3YkCdORPkzDnSNlAMcCX2jemTBsLP7X4+mJN/x4evx1RwEJwop7VPo/AQZd9y9NHbpJXpwOh+loYDEItj6J/oEF3/qgMYwE3uMYsBlAc9yu8Zj0+LV5glSwnwgo2Pa9ZGF/f7m5YDPvM0LkPsuL3OfidNzcTfSPoYT9kQPo+pcUeK2oME6zMzagZsEXHlm0baFKFbBITMIiuuRuf7wigtxuYq9t/CeBWIzzNVhPpvcB4q/043wrHPjekyGwQCMT35VG+jLUjAN2uE+CFxddjWzSjCN1y+BEiR1J6nqeInU9TxE/srAjkDzgjyxOET6yGO/yj70tjnnBOJ4m4DhBAMd8YBw/I+A4UQDH/OifMyXgOEkAxwJgHL8k4DhZAMeCYBy/IeA4RQDHQmAcLxNwnCqAY2EwjlcIOD4tgGMRMI4/EXCcJoBjUTCOvxJwnC6AYzEwjr8RcJwhgGNxMI63CDjOFMCxBBjHJITZxSwBHEuCcUxKwHG2AI6lwDimJOA4RwDH0mAc0xJwfEYAxzJgHNMRcJwrgOO9YBwzE3CcJ4BjWTCO2Qk4zhfAsRwYxxwEHJ8VwLE8GMe8BBwXCOAYAcaxIAHHhQI4GjCOhQg4LhLAMRKMY3ECjs8J4BgFxrE0AcfFAjhGg3EsQ8BxiQCOMWAcIwg4LhXAMRaMYzQBx+cFcIwD4xhDwHGZAI7xYBwrEnBcLoBjBTCOVQk4rhDAsSIYx2oEHF8QwLESGMfaBBxXCuBYGYzjfQQcVwngWAWMY30CjqsFcKwKxrExAcc1AjhWA+PYlIDjWgEcq4NxbEbAcZ0AjjXAOLYk4LheAMeaYBzbEnB8UQDHWmAc2xFw3CCAY20wjp0JOG4UwLEOGMduBBw3CeBYF4xjdwKOLwngWA+MYx8CjpsFcLwPjOMjBBy3COBYH4zjowQcXxbAsQEYxyEEHF8B4mi/j13OOTr6rme/k2y/T3smXVjYWeew3wk97/y132m038f7yjn/2jnsd8q+c/7a70TZ7/P86JxfdQ77nZRrzl/7nQr7fYDfnfObzmH3tN/jHHZPtt1PnNw5UjiH3RObxjnsnk67HzGjc2RyDrunLptz2D1hdj9TbufI4xx2T04B57B7Sux+iKLOUcw57Gf6pZzDfiZtP08t5xzlncN+JhjlHPYzLft5TLxzVHAO+5lCFeewM3E7z63pHLWcw84k6zmHnanZeVAj57jfOexM40HnsJ7c+kn7M+r2576tJ7I/fWt7etuP2p8wtD+1Z3sq+7NTtiewemZ/PsT+zIWtyfaR77am2Hywj+61j5i1a2oft+h/qTwf4FUgF5P4uHjnC3V9ErYGiQHrHrei7xFdfG3AgU+pQTy8wwaNvs+twHt8TSd5zN2cPK+h75FV3dFkRybk60AQA58kY69bkLPwErhu8xTYbBMoItvdrsC2xKMVeDshebYD7/ENT4ElkueNu1SBI5EJ+SZJgd/UU2Aorjs8BTY7BIrITnYRQSimvUnUA0ATYqKjTeeIBODTX/8CYmLjfctTX4nEeesuVd8opEq8TVLft/XUF4rrO576mncEisgut6uvTSj/A+iRgbMePp/YeHeDFyQJeD1skQCS5l9Dt92EecQuYDF71+uIJIrZu3dpRxSNVO73SB3Re3odERTXPV5HZPYIFJG9bv9EwJJyLPgTgb0EBd4LvMf3PQWWSJ7371IFjkEqxT6SAu/TU2Aorvs9BTb7BYrIAbcrsP3BPvRn8gcICnwAeI8HPQWWSJ6DLldgo7B76xBJgQ+l//NXZe3h/arsn/fp/aos9j7RvyrLus/dYGHxvw6n/+PvB/b7Feibtj8Hbn++Gz1dR/4k+CjglD6wiB0OKGKh+sXZkwAy+36UtEuQ203stYP+4uyHPgIeSR/211+X/TD9339x9kiAN/O/0B95BYKY2F+c/RCotkfScxYXnZzImI8CkzMsDJ9wthCNCrLpya0FLrHX+sjl62H58lF6/MfrH4HtAjjueFuzGHF/TOrwP07P/QXl3uBvQi8h/FLWMfIWhojEvf6FYx8wjksJOB4XwLEvGMcXCDieEMCxHxjHlQQcTwrg2B+M44sEHE8J4PgIGMcNBBxPC+D4KBjHLQQcPxHAcQAYx5cJOH4qgONAMI7bCTieEcBxEBjHNwg4nhXAcTAYx7cJOH4mgOMQMI7vEHD8XADHoWAc3yfgeE4Ax8fAOO4j4HheAMdhYBwPE3D8QgDH4WAcPyDg+CUQRzuPtJ9UF/Rdz87k7DxpuXPfK5zDzkSsn1/jnK93DutJrZ96yTnf7BzWE9h+dqtzvs05bE9m+4mdzvlbzmE10dbzd53zvc5ha5LNp4PO+SHnsJyw8Rx1zo+lC/v3S2U+fAH8qXT5sL+/UNcnYWsupHf/PV50+15BG/BH4A+qLhK2T10E3uNXOslD2yuokDxfoe+RVd3RZEcm5NekTxK/5u3Wl8D1G0+BzTcCReSS2xXYlni0Al8iJM8l4D1+6ymwRPJ8e5cqcCQyIb8jKfB3egoMxfWyp8DmskARueJ2BbZXRSvwFYICXwHe4/eeAkskz/d3qQJHIRPyB5IC/6CnwFBcf/QU2PwoUESuul2Bd6fHK/BVggJfBd7jT54CSyTPT3epAkcjE/JnkgL/rKfAUFx/8RTY/CJQRK65XYHtwqMV+BpBga8B7/FXT4ElkufXu1SBY5AJ+RtJgX/TU2Aortc9BTbXBYrIDbcr8AcED3yDoMA3gPf4u6fAEsnz+12qwLHIhLxJUuCbegoMxfWWp8DmlkARue12BV6cDq/AtwkKfBt4j2EZPAVWSB7kOjFukKUUcciEvCcDR4HtdQtyFl4C1yQ6RYSWoEkyuP8ek2ZwuQIfJnhgGzT6PgOBTOw9hnsKLJE84S5XYKPwrZlkJAVOxlPgfxclN+OanIRrciKuo9P/8aR99HejUxCKiX0lAd8n8vmwKTNgizx6re2a2HtEr3UqEu9T3eX1JDU4h9AYWi6lJvApDYlPaYh8YuVWr3x3Jwd65+PoB/pZ5WmBNR+41gaJX2AOpfXlkOqEID6Z++8xHbLuqy7UJIGFSu8tVISZIrBQGdw+NliejmPDMgq0kBkJ7UMmUguZidhCWuuQgYBFZgEOZCbEnYXEgSxEDrDyoZ+AjWBwoL+IjcgKtBHAtTb9STYiq7iNmCXQ9GRz+weNK+74ieSIxL3+JaDZCEUku4CAZifEnYMkoDkC7tX/AnMrOiXww+Gc3s4KkzOD++8xF+kzJzQ5Y5DkzO2R0+QWIGceEXJCK2deXNCRquTMK0DOfG6fj60hzcfyC7R2+QmtXQFSa1eAPB/LR8CioAAHChLiLkTiQCHyfIyRD0ME5mMMDgwVmY8VBs7HgGtthpLmY4UDcsj/crMLKeI1eqaIQKNX1O2N3npSo1dMQOSLEQp8cZLIFyc3ekUJWJQQ4EAJQtwlSRwoSW70GPkwXKDRY3BghEijVwrY6AHX2owgNXql+I1ePLLRK+2Nm01pgUavjMi4uQKSnPd65DT3CpCzrAg5oZWznGeRTTkBcpZ3u0V+iWSRIwTsUQShNTYke2TIFrk8AYtIAQ5EEuKOInEgimyRGfkwSsAiMzgwWsQiRwMtMnCtzWiSRY4Ws8gxuPWJUm30YgQavVi374/eTNgfHUsonHECTUMcIe54UtMQz98f3QVZ8Cp4YxdTQaDgVRQZuyQgyVnJI6epJEDOyiLkhFbOKt5M0FQRIGdVt88Et5JmgtUEWrtqhNauOqm1q06eCVYlYFFDgAM1CHHXJHGgJnkmyMiH8QIzQQYHJojMBGsBZ4LAtTYTSDPBWvyZINSF1PYaPVNboNGr4/ZGbxup0asrIPJ1CQW+Hknk65EbvToELO4T4MB9hLjrkzhQn9zoMfJhskCjx+DAFJFGrwGw0QOutZlCavQa0Bs9E4Fs9Bp642bTUKDRa6QxbjYGSc77PXKa+wXI2ViEnNDK2cSzyKaJADkfcLtF3kmyyA8K2KMHCa1xU5I9akq2yA8QsGgmwIFmhLgfInHgIbJFZuTDNAGLzODAdBGL3BxokYFrbaaTLHJzMYv8sLc/2jws0Oi1cPv+6LcI+6NbEApnS4GmoSUh7lakpqEVfX+0gT4FtbU3djGtBQpeG5GxC/TJbW09cpq2AuRsJ0JOaOVs780ETXsBcnZw+0zwXdJMsKNAa9eR0Np1IrV2ncgzwQ4ELDoLcKAzIe4uJA50Ic8EGfkwV2AmyODAPJGZYAJwJghcazOPNBNM4M8EoS6kq9foma4CjV43tzd6e0mNXncBke9OKPA9SCLfg9zodSNg0VOAAz0JcfcicaAXudFj5MMCgUaPwYGFIo1eb2CjB1xrs5DU6PXmN3rQh2P18cbNpo9Ao9dXZNwMfX50P4+cpp8AOfuLkBNaOR/xLLJ5RICcj7rdIh8kWeQBAvZoAKE1HkiyRwPJFvlRAhaDBDgwiBD3YBIHBpMtMiMfFgtYZAYHlohY5CFAiwxca7OEZJGHiFnkod7+aDNUoNF7zO37ow8R9kc/RiicwwSahmGEuIeTmobh/P3R0KegjvDGLmaEQMEbKTJ2gT657XGPnOZxAXKOEiEntHKO9maCZrQAOce4fSZ4lDQTfEKgtXuC0NqNJbV2Y8kzwTEELMYJcGAcIe4nSRx4kjwTZOTDSoGZIIMDq0Rmgk8BZ4LAtTarSDPBp/gzQagLGe81ema8QKM3we2N3jFSozdRQOQnEgr8JJLITyI3ehMIWEwW4MBkQtxTSByYQm70GPmwVqDRY3BgnUijNxXY6AHX2qwjNXpTiTl0kqSlTwvU0acJOTSNVEenkTlg9RT92e1H6XG4Thfg03QCn2aQ+DSDrMuM3NogoMsMDmwU0eWZQF0GrrXZSNLlmb4csnWzXNjfX+g1Q/M1Ppn773EWsu6rLtQkgYWa7S1UhJkisFBz3D7es3ZkDkFGnxFoIZ8hxD2X1ELOJbaQZ3yWBI3FPAEOzCNwYD6JA/PJNoKRD5sFbASDA1tEbMSzQBsBXGuzhWQjnhW3EbMEmp4Fbv+ew1mf4KGuZ5uoBYQislBAQBcS4l5EEtBFvntVTf4bAsn/nGdNI8xNgYVarGBNFzO+ditQVZcQ4l5KqqpLibbkPMmaPi/AgecJHFhG4sAysjVl5MM2AWvK4MB2EWu6HGhNgWtttpOs6XJxaxqe3P33uMLrTiNMcoGFesFbKEcBBBZqpYKNWMn4po5AC7mKEPdqUgu5mthCfkWyEWsEOLCGsWmbxIG1ZBvByIcdAjaCwYGdIjZiHdBGANfa7CTZiHXiNiKtQNOz3u2fcH1N+IRrPaGIvCggoC8ydleTBHSD+Cdc6QWSf6NnTSNMRoGF2qRgTTcRqstLAlX1JcZmM1JV3Uy0Jd+RrOkWAQ5sIXDgZRIHXiZbU0Y+vCdgTRkc2CNiTV8BWlPgWps9JGv6irg1zSrQ9LzqdacRJrvAQm31FirC5BRYqNcUbMRrBBl9XaCFfJ2xMYjUQm4jtpA/kmzEdgEObCdw4A0SB94g2whGPuwTsBEMDuwXsRFvAm0EcK3NfpKNeFPcRpwId/897nD7J1xXCZ9w7WB8TC4goDsJcb9FEtC3Au7V/8Jyy0QgH8T7NhAH1YL3dgb33+M7hHskkDOiG5Kcu3BBR6qSc5cAOXcrjCB2E1TkXQH1fJfxyQ1JPd8j2s9rpBHEHgEO7CFwYC+JA3vJIwhGPhwRGEEwOHBUZATxPnAEAVxrc5Q0gng/IIf8L7ALiUQ2evs8F2L2CTR6+zVciIlCkvOAR05zQICcB0XICa2chzyLbA4JkPOwgkU+TGgRPxCwRx8Q4v6QZI8+JNqj30kW+YgAB44w7BGJA0fJFpmRD8cELDKDA8dFLPJHQIsMXGtznGSRPxKzyB/j1idKtdH7WKDRO+b2nQk3CTsTjjEKp0DTcJwQ9wlS03CCvzMhFlnwTnpjF3NSoOCdEhm7xCDJedobu5jTAuT8RGHs8glBRT4VUM9PCXGfIannGaLlvic9Z+xyVoADZwkc+IzEgc/IYxdKPgiMXRgcOCsydvkcOHYBrrU5Sxq7fM4fu8QjG71zngsx5wQavfMiLqQCkpxfeOQ0XwiQ80sRckIr5wXPIpsLAuS8qGCRLxJaxK8E7NFXhLi/Jtmjr4n2KDnJIn8jwIFvCBy4ROLAJbJFZuTDOQGLzODAeRGL/C3QIgPX2pwnWeRvxSzyd97OBPOdQKN32e07E1Kkx+9MuEwonFcEmoYrhLi/JzUN3/N3JnRBFrwfvLGL+UGg4P0oMnbpjCTnVW/sYq4KkPMnhbHLTwQV+VlAPX8mxP0LST1/IVruNKSxyzUBDlwjcOBXEgd+JY9dGPnwjcDYhcGBSyJjl9+AYxfgWptLpLHLb/yxS1dko3fdcyHmukCjd0PEhUCf3Pa7R07zuwA5b4qQE1o5b3kW2dwSIOdtBYt8m9AihmV0f2ts7xEd9z0ZOa2dvW5BEkkzkixyEgEOJCFwICmJA0kzci0yIx8uC1hkBgeuiFjkcBxXDXCtzRWSRQ7PqGWRk+HWR3ZnQrKM7r/H5Oh7RO9MyETYmZCcUDhTCDQNKQhxpyQ1DSkzsncmREIfEpMKiINqwUslUPBSE+6RQU6DJGcaXNCyY5c0AuRMi75HxtglLUFF0gmoZzpC3OlJ6pmeaLmzkcYuGQQ4kIHAgYwkDmQkj10Y+fCLwNiFwYFrImOXTMCxC3CtzTXS2CUTfewSGY1s9DJ7LsRkFmj0soi4EOiT27J65DRZBciZTYSc0MqZ3bPIJrsAOXMoWOQchBYxp4A9ykmIOxfJHuUi2qPcJIucW4ADuQkcyEPiQB6yRWbkw3UBi8zgwA0Ri5wXaJGBa21ukCxyXjGLnM/bmWDyCTR6+d2+MyEPYWdCfkLhLCDQNBQgxF2Q1DQU5O9MgD4kppA3djGFBApeYZGxSxySnEW8sYspIkDOogpjl6IEFSkmoJ7FCHEXJ6lncaLlLkAau5QQ4EAJAgdKkjhQkjx2YeRDkvx3JweS5seLU1gYfuxSCjh2Aa61QeIXmEOl+GOXTshGr7TnQkxpgUavjIgLgT657V6PnOZeAXKWFSEntHKW8yyyKSdAzvIKFrk8oUWMELBHEYS4DckeGaI9KkqyyJECHIgkcCCKxIEoskVm5ENyAYvM4EAKEYscDbTIwLU2KUgWOVrMIsd4OxNMjECjF+v2nQnFCDsTYgmFM06gaYgjxB1Pahri+TsToA+JqeCNXUwFgYJXUWTskoAkZyVv7GIqCZCzssLYpTJBRaoIqGcVQtxVSepZlWi5S5HGLtUEOFCNwIHqJA5UJ49dGPmQXmDswuBABpGxSw3g2AW41iYDaexSgz52iYpANno1PRdiago0erU0XEgU9MlttT1ymtoC5KwjQk5o5azrWWRTV4Cc9RQscj1Ci3ifgD26jxB3fZI9qk+0R+VIFrmBAAcaEDjQkMSBhmSLzMiHzAIWmcGBLCIWuRHQIgPX2mQhWeRGYhb5fm9ngrlfoNFr7PadCeUJOxMaEwpnE4GmoQkh7gdITcMD9J0JUdCHxDzojV3MgwIFr6nI2CUKSc5m3tjFNBMg50MKY5eHCCrSXEA9mxPifpikng8TLXcUaezSQoADLQgcaEniQEvy2IWRD7kFxi4MDuQRGbu0Ao5dgGtt8pDGLq34Y5dYZKPX2nMhprVAo9dGxIVAn9zW1iOnaStAznYi5IRWzvaeRTbtBcjZQcEidyC0iB0F7FFHQtydSPaoE9EexZMscmcBDnQmcKALiQNdyBaZkQ/5BSwygwMFRCxyAtAiA9faFCBZ5AQxi9zV25lgugo0et3cvjOhAmFnQjdC4ewu0DR0J8Tdg9Q09ODvTIA+JKanN3YxPQUKXi+RsUsFJDl7e2MX01uAnH0Uxi59CCrSV0A9+xLi7kdSz35Ey12FNHbpL8CB/gQOPELiwCPksQsjH4oLjF0YHCghMnZ5FDh2Aa61KUEauzzKH7t0QTZ6AzwXYgYINHoDRVwI9MltgzxymkEC5BwsQk5o5RziWWQzRICcQxUs8lBCi/iYgD16jBD3MJI9Gka0RzVJFnm4AAeGEzgwgsSBEWSLzMiH0gIWmcGBMiIWeSTQIgPX2pQhWeSRYhb5cW9ngnlcoNEb5fadCbUIOxNGEQrnaIGmYTQh7jGkpmEMfWdCNPQhMU94YxfzhEDBGysydumGJOc4b+xixgmQ80mFscuTBBV5SkA9nyLEPZ6knuOJlrseaewyQYADEwgcmEjiwETy2IWRD5ECYxcGB6JExi6TgGMX4FqbKNLYZRJ97BIdiWz0JnsuxEwWaPSmaLiQaOiT26Z65DRTBcj5tAg5oZVzmmeRzTQBck5XsMjTCS3iDAF7NIMQ90ySPZpJtEeNSBZ5lgAHZhE4MJvEgdlki8zIh1gBi8zgQJyIRZ4DtMjAtTZxJIs8R8wiP+PtTDDPCDR6c92+M+F+ws6EuYTCOU+gaZhHiHs+qWmYz9+ZAH1IzLPe2MU8K1DwFoiMXWKQ5FzojV3MQgFyLlIYuywiqMhzAur5HCHuxST1XEy03A+Sxi5LBDiwhMCBpSQOLCWPXRj5UFVg7MLgQDWRscvzwLELcK1NNdLY5Xn+2CUe2egt81yIWSbQ6C0XcSHQJ7et8MhpVgiQ8wURckIr50rPIpuVAuRcpWCRVxFaxNUC9mg1Ie41JHu0hmiPHiZZ5LUCHFhL4MA6EgfWkS0yIx9qClhkBgdqiVjk9UCLDFxrU4tkkdeLWeQXvZ0J5kWBRm+D23cmtCDsTNhAKJwbBZqGjYS4N5Gahk38nQnQh8S85I1dzEsCBW+zyNilM5KcW7yxi9kiQM6XFcYuLxNU5BUB9XyFEPerJPV8lWi525DGLlsFOLCVwIHXSBx4jTx2YeRDA4GxC4MDDUXGLq8Dxy7AtTYNSWOX1/ljl67IRm+b50LMNoFGb7uIC4E+ue0Nj5zmDQFyvilCTmjl3OFZZLNDgJw7FSzyTkKL+JaAPXqLEPfbJHv0NtEedSRZ5HcEOPAOgQO7SBzYRbbIjHxoLGCRGRxoImKRdwMtMnCtTROSRd4tZpHf9XYmmHcFGr333L4zoRNhZ8J7hMK5R6Bp2EOIey+padhL35kQA31IzPve2MW8L1Dw9mmMXWIMkpz7vbGL2S9AzgMKY5cDBBU5KKCeBwlxHyKp5yGi5e5KGrscFuDAYQIHPiBx4APy2IWRDw8LjF0YHGghMnb5EDh2Aa61aUEau3xIH7vERCMbvSOeCzFHBBq9oyIuBPrkto88cpqPBMj5sQg5oZXzmGeRzTEBch5XsMjHCS3iCQF7dIIQ90mSPTpJtEe9SBb5lAAHThE4cJrEgdNki8zIh9YCFpnBgTYiFvkToEUGrrVpQ7LIn4hZ5E+9nQnmU4FG74zbdyb0JuxMOEMonGcFmoazhLg/IzUNn/F3JkAfEvO5N3YxnwsUvHMiY5c4JDnPe2MXc16AnF8ojF2+IKjIlwLq+SUh7gsk9bxAtNz9SWOXiwIcuEjgwFckDnxFHrsw8qGzwNiFwYEuImOXr4FjF+Bamy6kscvX/LFLJ2Sj943nQsw3Ao3eJREXAn1y27ceOc23AuT8ToSc0Mp52bPI5rIAOa8oWOQrhBbxewF79D0h7h9I9ugHoj0aRLLIPwpw4EcCB66SOHCVbJEZ+dBNwCIzONBdxCL/BLTIwLU23UkW+Scxi/yztzPB/CzQ6P3i9p0Jgwk7E34hFM5rAk3DNULcv5Kahl/5OxOgD4n5zRu7mN8ECt51kbFLApKcN7yxi7khQM7fFcYuvxNU5KaAet4kxH2LpJ63iJZ7GGnscluAA7cJHAjLxOGAvW5BEgdY+dBPYOzC4EB/kbHLPTiuGuBam/6kscs9xBwa6dRQq6doxzwmPW69k2Ryfz7ae0TnY1JSTU5K5hNDl8MFOBBO4EAyEgeSkXWZkQ8DBHSZwYGBIrqcHKjLwLU2A0m6nDzT3z8OQWOaAohpr3y4a/XOx8E0BbEuLU4XFjaKoE0pSTU65T/gV0TiXgbJr0AcEotpKhKmqQIwZfS8x4CfEtk+Kl0GPF9Tg3spBo7HwTimJ+CYJpOGLqdF+mWghvQnaUhaooYsJ2lIOlK9SxcCDUHyKx1QQ9KTME1P1JAVPn6hrmc9SXZC7ctAwjZDgH9i6MoJsK7kImCbUUCfT4JxzEPAMZOIPmcG1s8hQH0eStLnzER9XkPS5yykepclBPqM5FcWoD5nJWGaNQRzmWxATIcDc3YEKWezEXN2PSlns5P4lT0EOYvkV3ZgzuYgYZqDPJc5Be5XyhD6lZwCfd9pMI5lCTjmEun7cgNzfBRQQ0aTNCQ3UUNeImlIHlK9yxMCDUHyKw9QQ/KSMM1L1JDNhLlMHKH25SNhm488l/kErCsVCdjmF9DnT8E4VibgWEBEnwsC6+d4oD5PIOlzQaI+byXpcyFSvSsUAn1G8qsQUJ8LkzAtHIK5TBEgppOBOTuFlLNFiDm7jZSzRUn8KhqCnEXyqygwZ4uRMC1GnsucAfcrjQj9SnGBvu8sGMfGBBxLiPR9JYE5Pg2oIdNJGlKSqCE7SRpSilTvSoVAQ5D8KgXUkNIkTEsTNeQtwlymJaH2lSFhW4Y8l/kMrCttCNjeK6DPn4NxbEfAsayIPpcD1s+5QH2eR9LnckR9fpekz+VJ9a58CPQZya/yQH2OIGEaEYK5jAFiugCYswtJOWuIObuXlLORJH5FhiBnkfyKBOZsFAnTKPJc5hy4X+lL6FeiBfq+82Ac+xNwjBHp+2KBOb4YqCFLSBoSS9SQgyQNiSPVu7gQaAiSX3FADYknYRpP1JBDhLnMMELtq0DCtgJ5LvMFWFdGErCtKKDPX4JxHEXAsZKIPlcG1s+VQH1eRdLnykR9PkrS5yqkelclBPqM5FcVoD5XJWFaNQRzmWpATNcCc3YdKWerEXP2GClnq5P4VT0EOYvkV3VgztYgYVojBDlbE4jpBmDObiTlbE1izp4k5WwtEr9qhSBnkfyqBczZ2iRMa5NnqbMy4K43nvR8zToCXm02EMcJJBzrini1esAc3wzUkC0kDalH1JAzJA25j1Tv7guBhiD5dR9QQ+qTMK1P1JCzhFnqQsKcqgEJ2wbkWepzQF2ZSNKVhiK60giY99uAurKdpCuNiLpynqQr95Py9P4Q6AqSX/cDdaUxCdPGZG+yAlj7JpFqXxMBb/ICEMfJJBwfENGQB4E5vgOoITtJGvIgUUO+ImlIU1K9axoCDUHyqylQQ5qRMG1G1JCvCd7kRYI3eYiE7UNkb7IRqCtTSLrSXERXHgbm/XtAXdlD0pWHibryHUlXWpDytEUIdAXJrxZAXWlJwrQl2Zu8Cqx9U0m1r5WAN9kKxPFpEo6tRTSkDTDH9wE1ZD9JQ9oQNeRHkoa0JdW7tiHQECS/2gI1pB0J03ZEDblK8CY7Cd6kPQnb9mRv8g5QV6aRdKWDiK50BOb9EaCuHCXpSkeirlwj6UonUp52CoGuIPnVCagrnUmYdiZ7k/3A2jedVPu6CHiTg0AcZ5BwTBDRkK7AHD8G1JDjJA3pStSQ30ka0o1U77qFQEOQ/OoG1JDuJEy7EzXkJsGbHCd4kx4kbHuQvckpoK7MJOlKTxFd6QXM+zNAXTlL0pVeRF25Jz1HV3qT8rR3CHQFya/eQF3pQ8K0D9mbnAfWvlmk2tdX4dkAQBxnk3DsJ6Ih/YE5fg6oIedJGtKfqCHJSRryCKnePRICDUHy6xGghjxKwvRRooakSI/3JlcI3mQACdsBZG/yI1BX5pB0ZaCIrgwC5v03QF25RNKVQURdSUPSlcGkPB0cAl1B8mswUFeGkDAdQvYmN4C17xlS7Rsq4E1uAnGcS8LxMRENGQbM8ctADblC0pBhRA3JSNKQ4aR6NzwEGoLk13CghowgYTqCqCGZCN4kRUY8X0eSsB1J9iapM+KuN4+kK4+L6MooYN7/AtSVayRdGUXUlWwkXRlNytPRIdAVJL9GA3VlDAnTMWRvkgVY++aTat8TAt4kGxDHZ0k4jhXRkHHAHL8O1JAbJA0ZR9SQ3CQNeZJU754MgYYg+fUkUEOeImH6FFFD8hC8SQGCNxlPwnY82ZsUBurKApKuTBDRlYnAvE+SH3etpPk53JxI1JUCJF2ZRMrTSSHQFSS/JgF1ZTIJ08lkb1IGWPsWkmrfFAFvUhaI4yISjlNFNORpYI4nB2pICpKGPE3UkKIkDZlGqnfTQqAhSH5NA2rIdBKm04kaUozgTeII3mQGCdsZZG9SEagrz5F0ZaaIrswC5n16oK5kIOnKLKKulCLpymxSns4Oga4g+TUbqCtzSJjOIXuTWsDat5hU+54R8CZ1gDguIeE4V0RD5gFzPDNQQ7KQNGQeUUPKkTRkPqnezQ+BhiD5NR+oIc+SMH2WqCHlCd6kCcGbLCBhu4DsTZoCdWUpSVcWiujKImDe5wbqSh6Sriwi6koUSVeeI+XpcyHQFSS/ngPqymISpovJ3qQNsPY9T6p9SwS8STsgjstIOC4V0ZDngTmeH6ghBUga8jxRQ+JJGrKMVO+WhUBDkPxaBtSQ5SRMlxM1pALBm3QneJMVJGxXkL1JL6CuLCfpygsiurISmPfFgbpSgqQrK4m6UoWkK6tIeboqBLqC5NcqoK6sJmG6muxNBgJr3wpS7Vsj4E0GA3F8gYTjWhENWQfM8dJADSlD0pB1RA2pSdKQ9aR6tz4EGoLk13qghrxIwvRFoobUIniT0QRvsoGE7QayNxkL1JWVJF3ZKKIrm4B5HwnUlSiSrmwi6ko9kq68RMrTl0KgK0h+vQTUlc0kTDeTvckUYO1bRap9WwS8ydNAHFeTcHxZRENeAeZ4LFBD4kga8gpRQxqRNORVUr17NQQaguTXq0AN2UrCdCtRQ+4neJN5BG/yGgnb18jeZAFQV9aQdOV1EV3ZBsz7qkBdqUbSlW1EXXmQpCvbSXm6PQS6guTXdqCuvEHC9A2yN1kOrH1rSbXvTQFv8gIQx3UkHHeIaMhOYI7XBGpILZKG7CRqyMMkDXmLVO/eCoGGIPn1FlBD3iZh+jZRQ1oQvMlGgjd5h4TtO2RvshmoK+tJurJLRFd2A/O+AVBXGpJ0ZTdRV9qQdOVdUp6+GwJdQfLrXaCuvEfC9D2yN9kOrH0vkmrfHgFv8iYQxw0kHPeKaMj7wBxvDNSQJiQNeZ+oIR1JGrKPVO/2hUBDkPzaB9SQ/SRM9xM1pBPBm+wheJMDJGwPkL3JPqCubCTpykERXTkEzPuHgbrSgqQrh4i60pWkK4dJeXo4BLqC5NdhoK58QML0A7I3OQqsfZtIte9DAW/yMRDHl0g4HhHRkKPAHG8N1JA2JA05StSQXiQN+YhU7z4KgYYg+fURUEM+JmH6MVFDehO8yVmCNzlGwvYY2ZucA+rKZpKuHBfRlRPAvO8M1JUuJF05QdSV/iRdOUnK05Mh0BUkv04CdeUUCdNTZG9yCVj7tpBq32kBb/IdEMeXSTh+IqIhnwJzvBtQQ7qTNORTooYMImnIGVK9OxMCDUHy6wxQQ86SMD1L1JDBBG9yjeBNPiNh+xnZm1wH6sorJF35XERXzgHzvh9QV/qTdOUcUVeGkXTlPClPz4dAV5D8Og/UlS9ImH7xDzBN7L1/CcR0ADBnB5Jy9ktizo4k5ewFEr8uhCBnkfy6AMzZiyRML/owDXeOlAEcC3yheRcbho3F//oqE/GGv8qEv+7XQIKw4v46058Ag677l6YO3SSnAmL6DbAYBFufxN5fnG990BjGAe/xEtgMoDlu1/hSJvzafEsq2N8GFGz7XrKwv7/cXLCZ9xkjcp/RIveZipy7ic2x+LA/cgBd/5ICrxUfxml2vguoWfCFRxZtW6hSBSwSk7CILrnbH6+IILeb2Gsb/0kgFpd9DdaVTD5A/JX+sm+FA9+7EgILdDHxHVSkL0PNZWA3dgW8uOhqZJPmMqlbBidK7EVS1/M9qev5nviRhR2BjAd/ZFGHgO0PLv/Y2+I4AYxjXQKOPwrgOBGMY0MCjlcFcJyE/jlTAo4/CeA4GYzjAwQcfxbAcQoYx+YEHH8RwHEqGMdWBByvCeD4NBjH1gQcfxXAcRoYxw4EHH8TwHE6GMcuBByvC+A4A4xjAgHHGwI4zgTj2JOA4+8COM4C49iXgONNARxng3HsR8DxlgCOc8A4DiTgeFsAx2fAOA4l4BiW2f04zgXj+BgBx3sEcJwHxvFxAo5JBHCcD8bxCQKOSQVwfBaM41gCjuECOC4A4ziBgGMyARwXgnGcQsAxuQCOi8A4TiXgmEIAx+fAOM4k4JhSAMfFYByfIeCYSgDHJWAc5xJwTC2A41IwjgsJOKYRwPF5MI5LCDimFcBxGRjHpQQc0wnguByM4wsEHNML4LgCjOMaAo4ZBHB8AYzjWgKOGQVwXIn+GR4CjpkEcFwFxnELAcfMAjiuBuP4MgHHLAI4rgHj+DoBx6wCOK4F4/gmAcdsAjiuA+O4g4BjdgEc14Nx3EXAMYcAji+if+KDgGNOARw3gHHcS8AxlwCOG8E4HiTgmFsAx01gHD8k4JhHAMeXwDgeIeCYVwDHzWAcjxNwzCeA4xYwjqcJOOYXwPFlMI6fEHAsIIDjK2AcPyfgWBCIo/0+tgWzo+969jvJ9vu09Z2jgXPY74Q2dg77nUb7fbxmzvGQc9jvlLV0DvudKPt9nnbO0d457HdSOjuH/U6F/T5Ad+fo4Rx2T3sf57B7su1+4kedY4Bz2D2xQ+x37J2Y7H7EEc75SPsEJOd8jPPX7gmz+5mecs7HO4fdkzPZ+Wv3lNj9ENOd8xnOYT/Tn+P8tZ9J289Tn3XOFziH/UxwsfPXfqZlP49Z7pyvcA77mcJq56+didt57ovO+QbnsDPJzc5fO1Oz86CtzvlrzmFnGm84f60nt37S/oy6/blv64nsT9/ant72o/YnDO1P7dmeyv7slO0JrJ7Znw+xP3Nha7J95LutKTYf7KN77SNm7Zraxy36XyrPBygE5GISHxfvfKGuT8LWIDFg3WNh9D2ii68NOPApNYiHd9ig0fcZCGRi77GITvIYFjEVkqcI+h5Z1R1NdmRCFgWCGPgkGXvdgpyFl8C1mKfApphAESnudgW2D4VEK3BxggIXBypwCU+BJZKnxF2qwJHIhCxJUuCSegoMxbWUp8CmlEARKc0uIgjFtDeJegBoQkx0tOkckQB8+utfQExsvGU89ZVInDJ3qfpGIVXiXpL63qunvlBcy3rqa8oKFJFybldfm1D+B9AjA2c9fD6x8ZYnfxyL6IaApPnX0K08YR5RDtgRRXgdkUQxi7hLO6JopHIbUkdk9DoiKK6RXkdkIgWKSJTbPxGwpPwO/IlAFEGBo4AKHO0psETyRN+lChyDVIoYkgLH6CkwFNdYT4FNrEARiXO7AqfKhP9MPo6gwHFABY73FFgieZDr9K9fP7WH9+unf96n9+un2PtE//op6z7Lgwug/1Uh8x9/K9rvWqBv2v5stf2ZafQUGPnT1V8DPwcPbHcrZP7zJ5xD9cuotQGx+H48s0uQ203stYP+MmolHwErZw7766+g2v/Dnb+MWjnAQ/hf6I9maie+tfr3L6NWArZAlTNzFhednMiYqwA/6gkLI3gF5xq2gCQFY8gqcIm9VlWXr4flS9XM+I+Bq4Jbb3Dc8bZmMeKuRpoFVcvM/aXfY+Bv7KYmfEuyusA3n4+DcUxDwLGGAI4nwDhmJOBYUwDHk2AcMxFwrCWA4ykwjjkJONYWwPE0GMdcBBzrCOD4CRjH/AQc6wrg+CkYxwIEHOsJ4HgGjGNxAo73CeB4FoxjCQKO9QVw/AyM470EHBsI4Pg5GMeyBBwbCuB4DoxjNAHHRgI4ngfjGEPA8X4BHL8A41iRgGNjARy/BONYiYBjEyCOdh5pB9EF/ffoXNvOk9Lbp8A5h52JWD+f1T7VzTmsJ7V+Kq99aptzWE9g+9nCznkx57A9me0nSjvnZZzDaqKt5xF2k6tz2Jpk8yneOa/gHJYTNp6qznkN3pPeaPPhB8CfSpuwv79Q1ydhax7I7P57fFDhSW9VgR8c2ms9SNjT9iDwHpvqJA9tT5tC8jRF3yOruqPJjkzIZqRPEpvxdpVL4PqQp8DmIYEi0lzhSW9oBW5OSJ7mwHt82FNgieR5+C5V4EhkQrYgKXALPQWG4trSU2DTUqCItHK7AtuvdqAVuBVBgVsB77G1p8ASydP6LlXgKGRCtiEpcBs9BYbi2tZTYNNWoIi0c7sCl8+MV+B2BAVuB7zH9p4CSyRP+7tUgaORCdmBpMAd9BQYimtHT4FNR4Ei0sntCmwfG4BW4E4EBe4EvMfOngJLJE/nu1SBY5AJ2YWkwF30FBiKa4KnwCZBoIh0dbsCVyR44K4EBe4KvMdungJLJE+3u1SBY5EJ2Z2kwN31FBiKaw9PgU0PgSLS0+0KnCoTXoF7EhS4J/Aee3kKLJE8ve5SBY5DJmRvkgL31lNgKK59PAU2fQSKSF+3K3AFggfuS1DgvsB77OcpsETy9HO5Av87edBkRyZkf5IC9+cpsPnG99h/9Hd4HyGQ3r6SgO8T+RzTRzNjixF6re2a2HtEr/UAEu8HEHmvUE8GgnMIjaHl0kACnwaR+DSIyCdWbl0veHdy4EZBjn6gn6k9GFjzgWttkPgF5tBgXw6pOtn4ZO6/xyHIuq+6UJMEFmqot1ARZorAQj3mdnubnmTDhgm0kMMI7cNwUgs5nNhCWuvwGAGLEQIcGEGIeySJAyOJHGDlw62CdycHbhfEi1NYGN5GPA60EcC1Nkj8AnPocXEbMUug6Rnl9g/EMtzxk7MRiXv9S0BHEYrIaAEBHU2IewxJQMcE3Kv/BeZW9KPAOewT3g4A80Rm99/jWNJnTmhyxiDJOc4jpxknQM4nRcgJrZxP4YKOVCXnUwLkHO/2+VhW0nxsgkBrN4HQ2k0ktXYTyfOx8QQsJglwYBIh7skkDkwmz8cY+ZC80N3JgRSF8OIUFoafj00BzseAa22Q+AXm0JSAHPK/3OxCpnqNnpkq0Og97fZGLwep0ZsmIPLTCAV+Oknkp5MbvacJWMwQ4MAMQtwzSRyYSW70GPmQWqDRY3AgjUijNwvY6AHX2qQhNXqz+I1ePLLRm+2Nm81sgUZvjsi4uQKSnM945DTPCJBzrgg5oZVznmeRzTwBcs53u0XOS7LIzwrYo2cJrfECkj1aQLbI8wlYLBTgwEJC3ItIHFhEtsiMfEgvYJEZHMggYpGfA1pk4FqbDCSL/JyYRV6MW58o1UZvsUCjt8Tt+6PzEfZHLyEUzqUCTcNSQtzPk5qG5/n7o7sgC94yb+xilgkUvOUiY5cEJDlXeOQ0KwTI+YIIOaGVc6U3EzQrBci5yu0zwcKkmeBqgdZuNaG1W0Nq7daQZ4KrCFisFeDAWkLc60gcWEeeCTLyIbvATJDBgRwiM8H1wJkgcK0NEr/AHFrPnwlCXciLXqNnXhRo9Da4vdErRmr0NgqI/EZCgd9EEvlN5EZvAwGLlwQ48BIh7s0kDmwmN3qMfMgt0OgxOJBHpNHbAmz0gGtt8pAavS30Rs9EIBu9l71xs3lZoNF7RWPcbAySnK965DSvCpBzqwg5oZXzNc8im9cEyPm62y1yaZJF3iZgj7YRWuPtJHu0nWyRXydg8YYAB94gxP0miQNvki0yIx/yC1hkBgcKiFjkHUCLDFxrU4BkkXeIWeSd3v5os1Og0XvL7fujyxD2R79FKJxvCzQNbxPifofUNLxD3x9toE9B3eWNXcwugYK3W2TsAn1y27seOc27AuR8T4Sc0Mq5x5sJmj0C5Nzr9plgBGkm+L5Aa/c+obXbR2rt9pFngnsJWOwX4MB+QtwHSBw4QJ4JMvKhuMBMkMGBEiIzwYPAmSBwrQ0Sv8AcOsifCUJdyCGv0TOHBBq9w25v9KJIjd4HAiL/AaHAf0gS+Q/Jjd5hAhZHBDhwhBD3URIHjpIbPUY+lBZo9BgcKCPS6H0EbPSAa23KkBq9j/iNHvThWB9742bzsUCjd0xk3Ax9fvRxj5zmuAA5T4iQE1o5T3oW2ZwUIOcpt1vkeJJFPi1gj04TWuNPSPboE7JFPkXA4lMBDnxKiPsMiQNnyBaZkQ/lBCwygwPlRSzyWaBFBq61KU+yyGfFLPJn3v5o85lAo/e52/dHVyDsj/6cUDjPCTQN5whxnyc1Def5+6OhT0H9whu7mC8ECt6XImMX6JPbLnjkNBcEyHlRhJzQyvmVNxM0XwmQ82u3zwSrkmaC3wi0dt8QWrtLpNbuEnkm+DUBi28FOPAtIe7vSBz4jjwTZORDrMBMkMGBOJGZ4GXgTBC41gaJX2AOXebPBKEu5IrX6JkrAo3e925v9GqQGr0fBET+B0KB/5Ek8j+SG73vCVhcFeDAVULcP5E48BO50WPkQ0WBRo/BgUoijd7PwEYPuNamEqnR+9mXQ7bp+etcD8orWkMRn8z99/gLsu6rLtQkgYW65i1UhJkisFC/ut1GWAvxK0FGfxNoIX8jxH2d1EJeJ7aQ9R0OVCVgcUOAAzcIcf9O4sDvZBvByIeqAjaCwYFqIjbiJtBGANfaVCPZiJviNmKWQNNzy+37KRv4BA91PdtE3SIUkdsCAnqbEHdYFk7y2+veE6ab/DcEkv8e4NrJLtRNgYVKkgV8jwxrmiQLvrokzeL+qpqUEHc4qara6xYkkbQxyZomE+BAMgIHkpM4kDwL15oy8qGugDVlcKCeiDVNgeOqAa61QeIXmEMpsmhb0/Dk7r/HlF53GmGSCyxUKm+hHLYKLFRqBRuRmiCjaQRayDSEuNOSWsi0xBayGclGpBPgQDoCB9KTOJCebCMY+dBAwEYwONBQxEZkANoI4FqbhiQbkUHcRqQVaHoyopueJOAbfIjwCVdGQhHJJCCgmQhxZyYJaGbxT7jSCyR/Fs+aRpiMAguVVcGaZiVUl2wCVTUbIe7spKqanWhLWpKsaQ4BDuQgcCAniQM5ydaUkQ9NBawpgwPNRKxpLqA1Ba61QeIXmEO5xK1pVoGmJ7fXnUaY7AILlcdbqAiTU2Ch8irYiLwEGc0n0ELmI8Sdn9RC5ie2kO1INqKAAAcKEDhQkMSBgmQbwciHhwVsBIMDLURsRCGgjQCutWlBshGFxG3EiXD332Nht3/C1Z7wCVdhQhEpIiCgRQhxFyUJaNGAe/W/sNwyEcgH/hUD4qBa8Iplcf89FifcI4GcEd2Q5CyBCzpSlZwlBMhZUmEEUZKgIqUE1LMUIe7SJPUsTbSfnUkjiDICHChD4MC9JA7cSx5BMPKhvcAIgsGBDiIjiLLAEQRwrQ0Sv8AcKhuQQ/4X2IVEIhu9cp4LMeUEGr3yGi7ERCHJGeGR00QIkNOIkBNaOSM9i2wiBcgZpWCRowgtYrSAPYomxB1DskcxRHvUnWSRYwU4EEvgQByJA3Fki8zIh84CFpnBgS4iFjkeaJGBa226kCxyvJhFroBbnyjVRq+CQKNX0e07E3oQdiZUJBTOSgJNQyVC3JVJTUNl/s6EWGTBq+KNXUwVgYJXVWTsEoMkZzVv7GKqCZCzusLYpTpBRWoIqGcNQtw1SepZk2i5+5DGLrUEOFCLwIHaJA7UJo9dGPnQS2DswuBAb5GxSx3g2AW41gaJX2AO1eGPXeKRjV5dz4WYugKNXj0RF1IBSc77PHKa+wTIWV+EnNDK2cCzyKaBADkbKljkhoQWsZGAPWpEiPt+kj26n2mPSBa5sQAHGhM40ITEgSZki8zIh34CFpnBgf4iFvkBoEUGrrXpT7LID4hZ5Ae9nQnmQYFGr6nbdyYMIOxMaMp4fqNA09CMEPdDpKbhIf7OhC7IgtfcG7uY5gIF72GRsUtnJDlbeGMX00KAnC0Vxi4tCSrSSkA9WxHibk1Sz9ZEyz2ENHZpI8CBNgQOtCVxoC157MLIhyECYxcGB4aKjF3aAccuwLU2SPwCc6gdf+zSFdnotfdciGkv0Oh1EHEh0Ce3dfTIaToKkLOTCDmhlbOzZ5FNZwFydlGwyF0ILWKCgD1KIMTdlWSPuhLt0QiSRe4mwIFuBA50J3GgO9kiM/JhuIBFZnBghIhF7gG0yMC1NiNIFrmHmEXu6e1MMD0FGr1ebt+ZMJKwM6EX41tPAk1Db0LcfUhNQx/6zoRI6ENi+npjF9NXoOD10xi7RBokOft7YxfTX4CcjyiMXR4hqMijAur5KCHuAST1HEC03GNIY5eBAhwYSODAIBIHBpHHLox8GCswdmFwYJzI2GUwcOwCXGuDxC8whwbTxy6R0chGb4jnQswQgUZvqIgLgT657TGPnOYxAXIOEyEntHIO9yyyGS5AzhEKFnkEoUUcKWCPRhLifpxkjx4n2qOnSBZ5lAAHRhE4MJrEgdFki8zIh/ECFpnBgQkiFnkM0CID19pMIFnkMWIW+QlvZ4J5QqDRG+v2nQnjCTsTxjJmiwJNwzhC3E+SmoYn+TsToA+Jecobu5inBAreeJGxSxySnBO8sYuZIEDOiQpjl4kEFZkkoJ6TCHFPJqnnZKLlnkwau0wR4MAUAgemkjgwlTx2YeTDNIGxC4MD00XGLk8Dxy7AtTZI/AJz6Gn+2KUTstGb5rkQM02g0Zsu4kKgT26b4ZHTzBAg50wRckIr5yzPIptZAuScrWCRZxNaxDkC9mgOIe5nSPboGaI9mk6yyHMFODCXwIF5JA7MI1tkRj7MErDIDA7MFrHI84EWGbjWZjbJIs8Xs8jPejsTzLMCjd4Ct+9MmEHYmbCAUDgXCjQNCwlxLyI1DYv4OxOgD4l5zhu7mOcECt5ikbFLApKcS7yxi1kiQM6lCmOXpQQVeV5APZ8nxL2MpJ7LiJZ7DmnsslyAA8sJHFhB4sAK8tiFkQ8LBMYuDA4sFBm7vAAcuwDX2iDxC8yhF+hjl6gIZKO30nMhZqVAo7dKw4VEQZ/cttojp1ktQM41IuSEVs61nkU2awXIuU7BIq8jtIjrBezRekLcL5Ls0YtEe/QsySJvEODABgIHNpI4sJFskRn5sFjAIjM4sETEIm8CWmTgWpslJIu8Scwiv+TtTDAvCTR6m92+M2EBYWfCZkLh3CLQNGwhxP0yqWl4mb4zIQr6kJhXvLGLeUWg4L0qMnaJQpJzqzd2MVsFyPmawtjlNYKKvC6gnq8T4t5GUs9tRMu9mDR22S7Age0EDrxB4sAb5LELIx9WCoxdGBxYJTJ2eRM4dgGutUHiF5hDb/LHLrHIRm+H50LMDoFGb6eIC4E+ue0tj5zmLQFyvi1CTmjlfMezyOYdAXLuUrDIuwgt4m4Be7SbEPe7JHv0LtEeLSdZ5PcEOPAegQN7SBzYQ7bIjHxYK2CRGRxYJ2KR9wItMnCtzTqSRd4rZpHf93YmmPcFGr19bt+ZsIKwM2EfoXDuF2ga9hPiPkBqGg7wdyZAHxJz0Bu7mIMCBe+QyNilApKch72xizksQM4PFMYuHxBU5EMB9fyQEPcRknoeIVru1aSxy1EBDhwlcOAjEgc+Io9dGPmwWWDswuDAFpGxy8fAsQtwrQ0Sv8Ac+pg/dumCbPSOeS7EHBNo9I6LuBDok9tOeOQ0JwTIeVKEnNDKecqzyOaUADlPK1jk04QW8RMBe/QJIe5PSfboU6I9epFkkc8IcOAMgQNnSRw4S7bIjHx4VcAiMziwVcQifwa0yMC1NltJFvkzMYv8ubczwXwu0Oidc/vOhA2EnQnnCIXzvEDTcJ4Q9xekpuEL+s6EaOhDYr70xi7mS4GCd0Fk7NINSc6L3tjFXBQg51cKY5evCCrytYB6fk2I+xuSen5DtNybSWOXSwIcuETgwLckDnxLHrsw8mGHwNiFwYGdImOX74BjF+BaGyR+gTn0HX3sEh2JbPQuey7EXBZo9K5ouJBo6JPbvvfIab4XIOcPIuSEVs4fPYtsfhQg51UFi3yV0CL+JGCPfiLE/TPJHv1MtEdbSRb5FwEO/ELgwDUSB66RLTIjH94RsMgMDuwSsci/Ai0ycK3NLpJF/lXMIv/m7Uwwvwk0etfdvjPhNcLOhOuEwnlDoGm4QYj7d1LT8Dt/ZwL0ITE3vbGLuSlQ8G6JjF1ikOS87Y1dzG0BcoZlFRi72JtEq8g9Wd2vnvcQ4k6SlaOe9roFSSR9gzR2SSrAgaQEDoSTOBCelTt2YeTDPoGxC4MD+0XGLslwXDXAtTZI/AJzKFlW+tglHtnoJQfWEtVGL3lW999jiqycfEeTE/rktpQeOU1KAXKmEiEntHKmxgUta5FTC5AzjYJFTkNoEdMK2KO0hLjTkexROqI9eptkkdMLcCA9gQMZSBzIQLbIjHw4JGCRGRw4LGKRMwItMnCtzWGSRc4oZpEz4dZHdmdCJoFGLzP6HtE7E94h7EzITCicWQSahiyEuLOSmoasWek7E6APicnmjV1MNoGCl11k7NIZSc4c3tjF5BAgZ06FsUtOgorkElDPXIS4c5PUMzfRcr9HGrvkEeBAHgIH8pI4kJc8dmHkwzGBsQuDA8dFxi75gGMX4FobJH6BOZSPP3bpimz08nsuxOQXaPQKiLgQ6JPbCnrkNAUFyFlIhJzQylnYs8imsAA5iyhY5CKEFrGogD0qSoi7GMkeFSPao/0ki1xcgAPFCRwoQeJACbJFZuTDKQGLzODAaRGLXBJokYFrbU6TLHJJMYtcytuZYEoJNHql3b4z4QBhZ0JpQuEsI9A0lCHEfS+pabiXvjMhBvqQmLLe2MWUFSh45TTGLjEGSc7y3tjFlBcgZ4TC2CWCoCJGQD0NIe5IknpGEi33B6SxS5QAB6IIHIgmcSCaPHZh5MM5gbELgwPnRcYuMcCxC3CtDRK/wByKoY9dYqKRjV6s50JMrECjFyfiQqBPbov3yGniBchZQYSc0MpZ0bPIpqIAOSspWORKhBaxsoA9qkyIuwrJHlUh2qOPSRa5qgAHqhI4UI3EgWpki8zIhwsCFpnBgYsiFrk60CID19pcJFnk6mIWuYa3M8HUEGj0arp9Z8Ixws6EmoTCWUugaahFiLs2qWmozd+ZAH1ITB1v7GLqCBS8uiJjlzgkOet5YxdTT4Cc9ymMXe4jqEh9AfWsT4i7AUk9GxAt9ynS2KWhAAcaEjjQiMSBRuSxCyMfLguMXRgcuCIydrkfOHYBrrVB4heYQ/fzxy6dkI1eY8+FmMYCjV4TERcCfXLbAx45zQMC5HxQhJzQytnUs8imqQA5mylY5GaEFvEhAXv0ECHu5iR71Jxoj86SLPLDAhx4mMCBFiQOtCBbZEY+/ChgkRkcuCpikVsCLTJwrc1VkkVuKWaRW3k7E0wrgUavtdt3JnxG2JnQmlA42wg0DW0IcbclNQ1t+TsToA+JaeeNXUw7gYLXXmTskoAkZwdv7GI6CJCzo8LYpSNBRToJqGcnQtydSerZmWi5vyCNXboIcKALgQMJJA4kkMcujHy4LjB2YXDghsjYpStw7AJca4PELzCHugYZu6Ax7YbEtCAQ04IcTLsR61IqR5u+zoTPz+6kGt39H/ArInEvg+RXIA6JxbQHCdMeAZiip1G2/60OnEbZPmoIoZfqCe6lGDjWAOM4lIBjr6wautwbmOO3CuKudbsgJ8d7EzUkPUlD+pDqXZ8QaAiSX32AGtKXhGlfooZk8PELdT3rSUYTal8/Erb9AvwTQ1dqgnVlLAHb/gL6XAuM45MEHB8R0edHgfUzOdA3pyD55keJ+pyVpM8DSPVuQAj0GcmvAUB9HkjCdGAI5jKDgJimBuZsGlLODiLmbA5Szg4m8WtwCHIWya/BwJwdQsJ0CHkuUxvcr8wh9CtDBfq+OmAc5xJwfEyk7xsGzPH0QA3JQNKQYUQNyUvSkOGkejc8BBqC5NdwoIaMIGE6gqgh+QhzmaWE2jeShO1I8lymLlhXlhOwfVxAn+uBcXyBgOMoEX0eDayf2YH6nIOkz6OJ+lyYpM9jSPVuTAj0GcmvMUB9foKE6RMhmMuMBWKaG5izeUg5O5aYs8VIOTuOxK9xIchZJL/GAXP2SRKmT5LnMveB+5VXCP3KUwJ9X30wjlsJOI4X6fsmAHM8P1BDCpA0ZAJRQ0qTNGQiqd5NDIGGIPk1Eaghk0iYTiJqSBnCXOZtQu2bTMJ2Mnku0wCsK7sJ2E4R0OeGYBzfI+A4VUSfnwbWz+JAfS5B0uenifocQdLnaaR6Ny0E+ozk1zSgPk8nYTo9BHOZGUBMSwNztgwpZ2cQczaKlLMzSfyaGYKcRfJrJjBnZ5EwnUWeyzQC9yvHCP3KbIG+734wjicIOM4R6fueAeZ4OaCGlCdpyDNEDYknachcUr2bGwINQfJrLlBD5pEwnUfUkAqEucw5Qu2bT8J2Pnku0xisK18SsH1WQJ+bgHG8SMBxgYg+LwTWz1igPseR9HkhUZ+rkvR5EaneLQqBPiP5tQioz8+RMH0uBHOZxUBMKwJzthIpZxcTc7YGKWeXkPi1JAQ5i+TXEmDOLiVhupQ8l/kF2K/8QHpW3/MCfd81II4/knBcJtL3LQfmeFWghlQjachyoobUJ2nIClK9WxECDUHyawVQQ14gYfoCUUMaEOYytwm1byUJ25Xkucw9WXDXu0rSlVUiurIamPd1gbpSj6Qrq4m60pikK2tIebomBLqC5NcaoK6sJWG69v+1dyZwVk5vHL+zNzNNMzVN+54WQjPtyVLaN0mUZGuZtCdKKMmSnWTfs/wRIQkhimRJCElShEqWSNKm7X9O7uV4e+8Xf+eZPJ/P/34+z2fm3u95fvc5zz3nPPe8973vFd6bFPO49v0stPZNV7A3SfeYx81CeXxMSQ153OMc7+SxhnQWqiGPC9aQHkI15Amh9e6JIqghPsfXEx5ryAyhnM4QrCHHC+xNSub6H69PCuX2SeG9Sa7HurJFqK7MVFJXnvI474/zWFd6CNWVpwTryolCdWWW0DydVQR1xef4muWxrjwtlNOnhfcmFTyufVuF1r5nFOxNKnrM4zahPD6rpIbM9jjHe3qsIb2EashswRpyilANeU5ovXuuCGqIz/H1nMca8rxQTp8XrCGnCuxNagrsTV4Qyu0LwnuT2h7rynahujJHSV150eO8P9VjXTlNqK68KFhX+gnVlZeE5ulLRVBXfI6vlzzWlblCOZ0rvDep73Ht+0Vo7ZunYG9S4DGPO4Ty+LKSGvKKxznez2MN6S9UQ14RrCFnCNWQ+ULr3fwiqCE+x9d8jzXkVaGcvipYQwYJ7E1aCOxNFgjldoHw3uRIj3Vlp1BdeU1JXXnd47wf4rGuDBWqK68L1pVhQnXlDaF5+kYR1BWf4+sNj3XlTaGcvim8N2nvce3bJbT2LVSwN+noMY+7hfL4lpIassjjHB/hsYaMFKohiwRryCihGvK20Hr3dhHUEJ/j622PNeQdoZy+I1hDzhLYm/QQ2Ju8K5Tbd4X3Jj091pU9QnVlsZK68p7HeX+Ox7oyVqiuvCdYV84RqivvC83T94ugrvgcX+97rCsfCOX0A+G9yWke175IKZm1b4mCvUlfj3lMEMrjh0pqyFKPc/x8jzVknFANWSpYQ8YJ1ZCPhNa7j4qghvgcXx95rCHLhHK6TLCGjBfYmwwV2Jt8LJTbj4X3JiM81pVEobqyXEld+cTjvL/YY125RKiufCJYVyYK1ZUVQvN0RRHUFZ/ja4XHurJSKKcrhfcmYz2ufUlCa9+nCvYm53nMY7JQHj9TUkNWeZzjl3msIZcL1ZBVgjVkklAN+Vxovfu8CGqIz/H1ucca8oVQTr8QrCGXCexNLhHYm3wplNsvhfcml3msKylCdWW1krqyxuO8v85jXZksVFfWCNaVq4Tqylqhebq2COqKz/G11mNd+Uoop18J700me1z7UoXWvnUK9iZTPOYxTSiPXyupId94nOM3eKwhNwrVkG8Ea8hkoRryrdB6920R1BCf4+tbjzXkO6GcfidYQ64X2JvcKbA3WS+U2/XCe5N7PNaVYkJ15XsldeUHj/P+Do915U6huvKDYF25SaiubBCapxuKoK74HF8bPNaVH4Vy+qPw3uRhj2tfutDat1HB3uQRj3nMEMrjT0pqyCaPc/wejzVkqlAN2SRYQ24XqiE/C613PxdBDfE5vn72WEM2C+V0s2ANuUNgbzJLYG+yRSi3W4T3Js96rCuZQnVlq5K6ss3jvH/IY115WKiubBOsK/cI1ZXtQvN0exHUFZ/ja7vHuvKLUE5/Ed6bzPO49hUXWvt2KNibvOIxj1lCedyppIbs8jjHH/VYQ6YL1ZBdgjXkAaEasltovdtdBDXE5/ja7bGG7BHK6R7BGvIfgb3JIoG9SSRPJrdWV3Jv8q7HulJCqK4k5OmoK4n+4ix4ymNdmSVUV2x/q0V1fdeVaUJ1JUloniblydcVn+PLzcM/zWmyUE6T82T3Jss8rn3ZQmtfiue1TyKPyz3mMUcoj6lKakiaxzn+rMcaMluohqQJ1pDHhWpIMaH1rlgR1BCf46uYxxqSLpTTdMEa8oTA3mS1wN4kQyi3GcJ7k6881pWSQnUlU0ldKe5x3s/1WFfmCdWV4oJ15SmhupIlNE+ziqCu+BxfWR7rSgmhnJYQ3pts8Lj2lRJa+7IV7E02esxjrlAec5TUkJIe5/h8jzXkVaEaUlKwhswWqiGlhNa7UkVQQ3yOr1Iea0iuUE5zBWvIcwJ7kx0Ce5PSQrktLbw32e2xrpQWqit5SupKGY/z/i2PdWWRUF0pI1hXXhSqK2WF5mnZIqgrPsdXWY91pZxQTssJ703SPJ7fkCe09pVXsDdJ95jHMkJ5rKCkhlT0OMff9VhDFgvVkIqCNeQVoRpSSWi9q1QENcTn+KrksYZUFsppZcEaMl9gb5Jb2v94rSKU2yrCe5MyHutKWaG6UlVJXanmcd5/5LGuLBOqK9UE68rrQnWlutA8rV4EdcXn+Krusa7UEMppDeG9SVWPa185obWvpoK9SXWPeSwvlMcDlNSQWh7n+Ccea8gKoRpSS7CGLBKqIbWF1rvaRVBDfI6v2h5rSB2hnNYRrCFvC+xN6gnsTeoK5bau8N7kUI91pYJQXTlQSV05yOO8/9JjXVktVFcOEqwr7wnVlXpC87ReEdQVn+Ornse6crBQTg8W3ps09bj2VRRa+w5RsDdp7jGPlYTyeKiSGlLf4xz/ymMNWSdUQ+oL1pClQjUkX2i9yy+CGuJzfOV7rCEFQjktEKwhHwnsTVoL7E0aCOW2gfDepJ3HulJZqK40VFJXGnmc9z94rCsbhOpKI8G68olQXWksNE8bF0Fd8Tm+GnusK02EctpEeG/SzePaV0Vo7WuqYG/S3WMeqwrlsZmSGtLc4xz/yWMN2SRUQ5oL1pBVQjXkMKH17rAiqCE+x9dhHmtIC6GcthCsIZ8L7E36COxNDhfK7eHCe5NTPdaVakJ15QgldeVIj/P+F491ZYdQXTlSsK6sEaorRwnN06OKoK74HF9HeawrLYVy2jIkp77HQytvsTfIl4zz6P89zgbBB2xsucaSnVhtHnZH/28e+f3/Zim//390tE3Mr7W538ZYW2Pt8v6o53PctzMag0r7r3/tPL4+7YXmQHvBNVZDXjsI5bUD5PWfxiyV10Eer9nbUSivHYugDnocEwUdPdbBTkI57VQEa4DvOdBZKBedQ8ZXoufYfea3vT+tfMk+J3jscwclfU702OeOSvqc5LHPnYqoz/n/7FbQ2WP+LkyU6bPvdb2Lktemq8fX5ro0HXOwrcf8HRPRMR67KYnzWCVxdlcS53FK4uyhJM7jlcR5gpI4eyqJs5eSOE9UEmdvJXGepCTOPkriPFlJnKcoifNUJXGepiTO05XE2VdJnP2UxNlfSZwDlMRZqCTOgUriPENJnIOUxDlYSZxDlMQ5VEmcw5TEOVxJnCOUxDlSSZxnKolzlJI4z1IS59lK4hytJM4xSuI8R0mcY5XEea6SOM9TEuf5SuIcpyTO8UrivEBJnBOUxHmhkjgnKonzIiVxXqwkzkuUxHmpkjgnKYnzMiVxXq4kziuUxHmlkjivUhLn1UrivEZJnNcqifM6JXFOVhLn9UrinKIkzhuUxHmjkjhvUhLnzUrivEVJnLcqifM2JXHeriTOO5TEeaeSOO9SEufdSuK8R0mcU5XEea+SOO9TEuf9SuJ8QEmc/1ES54NK4nxISZwPK4lzmpI4H1ES56NK4pyuJM7HlMT5uJI4n1AS5wwlcT6pJM6ZSuJ8Skmcs5TE+bSSOJ9REuezSuKcrSTO55TE+bySOF9QEuccJXG+qCTOl5TEOVdJnPOUxPmykjhfURLnfCVxvqokzgVK4nxNSZyvK4nzDSVxvqkkzoVK4nxLSZyLlMT5tpI431ES57tK4lysJM73lMT5vpI4P1AS5xIlcX6oJM6lSuL8SEmcy5TE+bGSOJcrifMTJXGuUBLnSiVxfqokzs+UxLlKSZyfK4nzCyVxfqkkztVK4lyjJM61SuL8Skmc65TE+bWSOL9REue3SuL8Tkmc65XE+b2SOH9QEucGJXH+qCTOjUri/ElJnJuUxPmzkjg3K4lzi5I4tyqJc5uSOLcrifMXJXHuUBLnTiVx7lIS524lce5REqcV9BlnML5/+tut9vfSW+f573dCgszrk+g5zsQEf7n0+RvxkmMyKUFHnMlK4kxREmeqkjjTlMRZTEmc6UrizFASZ6aSOIsriTNLSZwllMSZrSTOHCVxllQSZyklceYqibO0kjjzlMRZRkmcZZXEWU5JnOWVxFlBSZwVlcRZSUmclZXEWUVJnFWVxFlNSZzVlcRZQ0mcNZXEeYCSOGspibO2kjjrKImzrpI4D1QS50FK4qynJM6DlcR5iJI4D1USZ30lceZ7jjP42fg//Tz7m5JGq5Q/vVFGa3Bp/3ksUJDHVp7zOEQgjw2UnLPR0OM5G8NL6+hzI499HlH63z9fjvY8X0YKzJfGCtad1p7zeKZAHpsoWXeaepyDZytZd5p57PM5CtadNp7ny1iB+dJcwbrT1nMezxXI42FK1p0WHufgOCXrzuEe+zxewbrTzvN8uUBgvhyhYN1p7zmPEwTyeKSSdecoj3PwIiXrTkuPfb5UwbrTwfN8mSQwX1opWHc6es7jZQJ5PFrJutPa4xy8Usm608Zjn69SsO508jxfrhaYL20VrDudPefxGoE8tlOy7rT3OAcnK1l3Onjs8w0K1p0unufLjQLzpaOCdaer5zzeJJDHTkrWnc4e5+CtStadLh77fJuCdecYz/PldoH50lXButPNcx7vEMjjMUrWnW4e5+DdStadYz32+V4F687Gkn7ny30C86W7gnXnJ895vF8gj8cpWXd6eJyDDypZd4732OeHFKw7mzzPl4cF5ssJSuZLT49j51EFY+dnz2NnusDY6aWgZm32nMfHBPJ4opI52NvjHJyhpGad5LHPTypYd7Z4ni8zBeZLHyXz5WSPY+dpBWNnq+ex84zA2DlFQc3a5jmPzwrk8VQlc/A0j3PweSU163SPfX5Bwbqz3fN8mSMwX/oqmS/9PI6duQrGzi+ex848gbHTX0HN2uE5jy8L5HGAkjlY6HEOvqqkZg302OcFCtadnZ7ny2sC8+UMJfNlkMex86aCsbPL89hZKDB2BiuoWbs95/EtgTwOUTIHh3qcg+8oqVnDPPb5XQXrzh7P82WxwHwZrmS+jPA4dj5QMHYins9ZWiIwdkYqqFkJnvP4oUAez1QyB0d5nIPLlNSsszz2+WMF606i5/myXGC+nK1kvoz2OHZWKhg7SZ7HzqcCY2eMgpqV7DmPnwnk8Rwlc3Csxzn4hZKada7HPn+pYN1J8TxfVgvMl/OUzJfzPY6drxSMnVTPY2edwNgZp6BmpXnO49cCeRyvZA5e4HEOfqekZk3w2Of1CtadYp7ny/cC8+VCJfNlosex86OCsZPueexsFBg7FymoWRme8/iTQB4vVjIHL/E4BzcrqVmXeuzzFgXrTqbn+bJVYL5MUjJfLvM4dn5RMHaKex47OwTGzuUKalaW5zzuFMjjFUrm4JUe5+AeJTXrKo99juT9++dLCc/zJSHP/3y5Wsl8ucbj2ElWMHayPY+dFIGxc62CmpXjOY+pAnm8TskcnOxxDqbn6ejz9R77nKFg3Snpeb5kCsyXKUrmyw0ex04JBWOnlOexky0wdm5UULNyPecxRyCPNymZgzd7nIO5SmrWLR77XFrBulPa83zJE5gvtyqZL7d5HDvlFIydPM9jp7zA2LldQc0q4zmPFQTyeIeSOXinxzlYWUnNustjn6soWHfKep4vVQXmy91K5ss9HsdODQVjp5znsVNTYOxMVVCzynvO4wECebxXyRy8z+McrKOkZt3vsc91Faw7FTzPlwMF5ssDSubLfzyOnYMVjJ2KnsfOIQJj50EFNauS5zweKpDHh5TMwYc9zsECJTVrmsc+N1Cw7lT2PF8aCsyXR5TMl0c9jp0mCsZOFc9jp6nA2JmuoGZV9ZzHZgJ5fEzJHHzc4xxsoaRmPeGxz4crWHeqeZ4vRwjMlxlK5suTHsdOS6H54vu1mZmgI86nlMQ5S0mcTyuJ8xklcT6rJM7ZSuJ8TkmczyuJ8wUlcc4povcK/7S+H+Cxzy8qeX/0ksf3R52UvD+aq2TezFMS58tK4nxFSZzzlcT5qpI4FyiJ8zUlcb6uJM43lMT5ppI4FyqJ8y0lcS5SEufbSuJ8R0mc7yqJc7GSON9TEuf7SuL8QEmcS5TE+aGSOJcqifMjJXEuUxLnx0riXK4kzk+UxLlCSZwrlcT5qZI4P1MS5yolcX6uJM4vlMT5pZI4VyuJc42SONcqifMrJXGuUxLn10ri/EZJnN8qifM7JXGuVxLn90ri/EFJnBuUxPmjkjg3KonzJyVxblIS589K4tysJM4tSuLcqiTObUri3K4kzl+UxLlDSZw7lcS5S0mcu5XEuUdJnJFEHXEmKIkzUUmcSUriTFYSZ4qSOFOVxJmmJM5iSuJMVxJnhpI4M5XEWVxJnFlK4iyhJM5sJXHmCMWZGIjzH//ukMc+l1TS5xSPfS6lpM+pHvucq6TPaR77XFpJn4t57HOekj6ne+xzGSV9zvDY57JK+pzpsc/llPS5uMc+l1fS5yyPfa6gpM8lPPa5opI+Z3vscyUlfc7x2OfKSvpc0mOfqyjpcymPfa6qpM+5HvtcTUmfS3vsc3Ulfc7z2OcaSvpcxmOfayrpc1mPfT5ASZ/LeexzLSV9Lu+xz7WV9LmCxz7XUdLnih77XFdJnyt57POBSvpc2WOfD1LS5yoe+1xPSZ+reuzzwUr6XM1jnw9R0ufqHvt8qJI+1/DY5/pK+lzTY5/zPfY5yWhY+zb6IXl7Yx2MdTTWyVhnY12MdTV2jLFuxo411t3YccZ6GDve2AnGehrrZexEY72NnWSsj7GTjZ1i7FRjpxk73VhfY/2M9Tc2wFihsYHGzjA2yNhgY0OMDTU2zNhwYyOMjTR2prFRxs4ydrax0cbGGDvH2Fhj5xo7z9j5xsYZG2/sAmMTjF1obKKxi4xdbOwSY5cam2TsMmOXG7vC2JXGrjJ2tbFrjF1r7Dpjk41db2yKsRuM3WjsJmM3G7vF2K3GbjN2u7E7jN1p7C5jdxu7x9hUY/cau8/Y/cYeMPYfYw8ae8jYw8amGXvE2KPGpht7zNjjxp4wNsPYk8ZmGnvK2CxjTxt7xtizxmYbe87Y88ZeMDbH2IvGXjI219g8Yy8be8XYfGOvGltg7DVjrxt7w9ibxhYae8vYImNvG3vH2LvGFht7z9j7xj4wtsTYh8aWGvvI2DJjHxtbbuwTYyuMrTT2qbHPjK0y9rmxL4x9aWy1sTXG1hr7ytg6Y18b+8bYt8a+M7be2PfGfjC2wdiPxjYa+8nYJmM/G9tsbIuxrca2Gdtu7BdjO4ztNLbL2G5je4zZE0ISjCUaSzKWbCzFWKqxNGPFjKUbyzCWaay4sSxjJYxlG8sxVtJYKWO5xkobyzNWxlhZY+WMlTdWwVhFY5WMVTZWxVhVY9WMVTdWw1hNYwcYq2WstrE6xuoaO9DYQcbqGTvY2CHGDjVW31i+sQJjDYw1NNbIWGNjTYw1NdbMWHNjhxlrYexwY0cYO9LYUfYcb2OtjB1trLWxNsbaGmtnrL2xDsY6GutkrLOxLsa6GjvGWDdjxxrrbuw4Yz2MHW/sBGM9jfUydqKx3sZOMtbH2MnGTjF2qrHTjJ1urK+xfsb6GxtgrNDYQGNnGBtkbLCxIcaGGhtmbLixEcZGGjvT2ChjZxk729hoY2OMnWNsrLFzjZ1n7Hxj44yNN3aBsQnGLjQ20dhFxi42domxS41NMnaZscuNXWHsSmNXGbva2DXGrjV2nbHJxq43NsXYDcZuNHaTsZuN3WLsVmP2N+3tb6jb3/+2v61tf2va/rax/d1g+zu19xqzv19qf8/T/n6k/W1G+1uA9nfs7G/E2d9Ms7/RZX//yv7ekv2tIPs7PPZ3aezvoNjfGLG/uWF/z8L+VoT9HQb7Gwf29wPstfntde/tNeXt9drttdDttcHtdbftdajtNZ5fNmavTWyv+2uvqWuvV2uvBWuvs2qvYWqvD2qvvWmva2mvGWmvx2ivdWivI2iv0Wevf2evLWev22aviWavN2av5WWvk2WvQWWv72SvnWSvS2Sv+WOvp2OvVWOvA2OvsfK5MXttEHvdDXtNC3u9CHstBnudA3sNAfv9fPvdd1uT7He27feh7XeN7fd47Xdk7fdP7Xc77fcm7XcS7ff97Hfp7PfU7HfA7Per7HeX7PeC7Hdu7PdZ7HdF7Pcw7HccbHG35+bb897tOeX2fG17LrQ9z9iew2vPj7XnntrzOu05k/Z8RHuunz2Pzp6jZs//sudD2fOD7Pky9vwRez6FPb/Aft5uP3+2n8fazyft53X28yv7eY79fMMe77fHv+3xYHt81B4vtMfP7PEke3zFHm+w+2+7H7X7M7tfse/f7ftZ+/7Ovt+x9T/x12UsYs/xsrf2kd9v0S7ureuW23Oi7DlC9pwZew6JPafCnmNgP3O3n0Hbz2TtZ5T2Mzv7GZb9TMd+xmGP+dtj4PaYsD1Gao8Z2mNo9piSPcZijznYPbjdk9o9mt2zVDNW3VgNY/Y9j73GfS1jtY3VMVbX2IHGDjJWz9jBxg4xdqix+sbsm7ACYw2MNTTWyFhjY02MNTXWzFhzY4cZa2HscGNHGDvS2FGRX98XtTJ2tLHWxtoYa2usXWTfW6vU3/8/Nvo3b02r8qPeerit287WingsCVgusDxgtYDVAdYUWHNgHYF1BtYH2CnAhgMbCexCYBcBmwLsRmAPAHsQ2DPAZgN7A9hCYMuBrQD2HbDvge0CtgdYdmJ8VhJYdWA1gTUE1hhYW2DtgfUC1hvYYGBDgY0DdgGwa4FNBjYV2H3AZgKbBexVYK8BWwpsGbB1wL4B9hOwHcCSkn79u+imxa9Pu6LvAJelJ8X3qxZlUx+p8kzFNYknuaw6sNrA6gLrArH0ANYL+ncSsFNBsy/4FQIbBGwIsOHARgIbBexs6N9Y8BsPbAKwi4FdBuxaiPPGKPvkyw+PO3Pk+d1cdgto3g+a04A9AewZYHOAzQe2CPr3LvTvE9D8HNhXwNYD+wnYNmC7gaUkx2dpwDKjLCwvJYCVAs0K4FcZWHXQrA2sPmg2ANYENFuA35HAjgbNzuDXE1gfYAOAjQQ2GtgFwK4Adi2wKcBuAnYb5PMe8LsP2IOg+QiwJ0FzFrDZoPky+C0E9gGwT4CtBrYe2GZgu4GlpcRnOcDKA6sBrB6wRsCOANYOWDdgJwLrC2wIsLOBjQc2Cdh1wG4Fdi+wR4A9BWwOsAXA3gC2CNjiKAubm++D3xJgS0FzOfitAPYpaK4Ctho01wJbB5rfgN93wL4HzY3gtwXYNmA7gSWkxmdJwNKAFQdWAlgOsFLASkdZWD7LgV8FYJVAswqw6qBZE1gt0DwQ/A4BVgCsMbDmwI4A1gpYW2AdgXUF1h3YCcB6AzsFWF9ghcAGAxsObBSwMcDOA3YBsIuATQJ2JbBrgU0BdjOw24HdDWwqsPuAPQBz8yHwmwbsUdB8DPyeAPYkaD4Ffk8DexY05wJbEGVhxyBep9qRFl+zFLBywKoCqwWsHrBGafH71yQtfv+OBc2ewE4G1g/YIGAjgI0Gdj6w8cAmQl4uAXY5aF4LftcDuwk0bwN2H2j+B9g00Hwc/J4E9jRovgR+LwNbAJoLgX0AmkuBLQfNz8DvC2BrQfMH8NsIbDNo/gIsqVh8zVRgGcXia2aDXylgZUCzKvjVAFYbNOsBawSaTYG1AM2W4NcaWHvQ7AR+XYF1B81e4HcSsFNBsx+wM0BzCLARoDka/MYCGweaFwK7FDQvB3Y1aE4Bv5uA3QaadwF7ADQfAvYoaM4Cv2eBvQCa84C9DpoLgb0Dmh+B33Jgn4Lml8C+Ac31wH4Eze3gtxPY3hPa4mimACueHl8zG1guaFYCv6rAaoJmXWD1QbMBsCageRT4HQ2sHWh2BnYcaJ4ArDdo9gO/QmCDQXMEsDGgeS6w8aA5CfyuAHYNaE4Bdhto3glsKmhOA7/pwGaA5tPA5oDmXGDzQXMR+L0L7APQXAbsM9D8Atha0PwB/DYC2wyavwBLyIivmQysWEZ8zZLgVxpYOdCsDOwA0KwDrB5oNgK/psBagGZLYO1BsxOwY0CzF/idBOxU0OwPbAhoDgc2CjRHg99YYONA8wLwuxDYRaA5CfwuB3YlaF4NbDJoTgF2I2jeDH63ArsdNO8Gv6nA7gPNB4A9DJqPAJsOmo+D3wxgM0HzGfCbDex50JwDbB5ovgLsVdB8DfzeALYQNN8Bv8XA3gfNJcCWgeZyYCtA81PwWwXsC9BcDX5rga0Dze/A73tgG0BzI7CfQXMLsG2guRP8dgPb+6WqOJqJwFIy42umAUsHzSzwywZWEjRzgZUBzXLAKoBmFfCrBqwGaB4ArA5oHgisHmjWB78CYA1BszGwZqB5GLDDQbMl+B0NrA1otgPWETQ7A+sKmt3BrwewE0CzF7CTQPNkYKeCZj/wGwBsIGgOAjYUNIcDGwmaZ4PfGGBjQfM8YONBcwKwiaB5KfhdBuwK0LwK2LWgORnYFNC8GfxuBXY7aN4J7B7QvBfY/aD5EPhNA/YoaD4GbAZozgQ2CzRng9/zwOaA5kvAXgbN+cAWgOab4PcWsLdB811g74PmEmBLQXM5+K0A9ilorgL2JWiuAfYVaH4LfuuB/QCaPwLbBJqbgW0Fze3gtwPYLtBMLh6fZURZ2HlIxYvHf77WoNkRWDdgPYGdDKwfsKHQv+HQv0tB8ypg1wO7BdhdwO4HNg3YE8CeBPY05GU2sDmg+Qr4LQD2Jmi+DWwpaH4MbCVofgF+a4B9DZobwe9nYNtAcxew1Kz4munAsrLia5YCvzxg5UGzBvjVAnYgaB4KrCloHgbsSNBsDX7tgHUCzR7g1xPYSaB5GrBBoDkU2EjQHA1+Y4GNA80J4HcRsEmgeTX4XQfsBtC8BdidoHkPsPtBcxr4TQc2AzRnAXsONOcAmwear4Hfm8DeBs33gC0DzU+AfQaa68DvW2A/gOYmYL+A5i5gCSXia2aUiO+XBawkaJYBVhk0qwE7ADQPAb98YI1AszmwlqDZGlh70DwW/HoA6wWaJwPrD5oDgQ0BzbPB7xxg54PmhcAuA80rgV0LmreA3+3A7gbN+4E9ApqPAXsSNJ8HvxeBvQyarwF7GzQXA1sCmivBbxWw1aD5NbANoPkTsC2guQf8ErPjs9Ts+JqZwEqBZh6w8qBZA/xqATsQNA8F1hg0mwE7HDTbgl8HYF1AszuwE0GzD7DTQHMQ+A0FNhI0RwMbB5oTgF0MmleD33XAbgDNW4HdA5r3AXsQNKeB33RgM0BzJvjNAvYMaD4PfnOAvQSa84C9CpqvAXsDNBeC3yJg74Dm++C3BNhS0FwGbAVofgpsFWh+AX6rga0FzW/A7ztg34PmBmCbQHMzsK2guR38dgDbBZoJOfH9koCl5MTXTAOWCZpZwLJBsyT45QLLA82y4FceWEXQrAp+1YHVBM1awOqC5kHADgbNfPBrAKwRaDYB1hw0WwA7AjRbgV9rYG1Bsz2wTqDZBdgxoHkc+B0PrCdongisD2ieAuw00OwPfoXAzgDNwcCGgeYIYGeC5mjwOwfYuaB5PrALQPNCYBeB5iTwuxzYlaB5NbDrQPN6YDeA5i3gdxuwO0DzLmBTQfM+YA+A5sPg9wiw6aD5OLAnQfMpYE+D5nPg9wKwF0FzLrBXQPNVYK+B5kLwWwTsHdBcDOwD0PwQ2Eeg+Qn4rQT2GWh+Dmw1aK4Ftg40vwO/74FtAM2NwH4GzS3AtoHmTvDbDWzvj3rE0UwEllIyvmYasHTQzAK/bGAlQTMXWBnQLAesAmhWAb9qwGqA5gHA6oDmgcDqgeYh4FcfWAFoNgN2ZJSFnYfUEp5vLGheAOwSYFcBux7YLcCmQv/ug/49B5pzgS0A9haw94B9BGwlsC+BrQH2NeTlO2AbQHMz+G0DthM09/4gUhyWXiq+ZnFgOaCZB37lgFUCzVrgVxfYwaBZAOww0DwCWCvQbAd+HYF1Bc2e4Ncb2Cmg2Q/YUNAcAews0BwLfucDmwCal4PfVcCuA80bgd0FmlOBPQCa08BvOrAZoPkU+D0D7HnQnAd+84G9DppvAVsMmh8A+wg0V4LfKmCrQXMdsPWguQHYJtDcDn47ge39sbw4msnAMnPja5YAVgo0K4JfFWA1QLMOsENBswBYY9A8EvxaAWsLmp2AdQfN44GdCJp9wW8AsEGgORzYaNAcC2wcaF4KfpcDuxo0rwd2K2jeAewe0HwY/B4F9gRozgL2Ami+BOwV0HwL/N4B9j5ofgTsU9D8HNga0Pwe/H4E9jNobge298dL42gmAUsrHV8zB/xygZUFzUrAaoJmbWAHgWZD8GsC7DDQPApYO9DsCKwraPYEv97ATgHNfsAGg+YwYGeC5nngNx7YRNCcBOwa0JwM7EbQvAv8pgJ7ADSnAZsBmk8BexY054HffGCvg+YiYB+A5lJgy0FzJfitArYaNNeC3zpg34Dm9+C3AdhG0NwEbCtobge2AzR3gd8eYAl58TVT8uL7pQFLB81MYNmgWRJYLmjmgV9ZYOVBszL4VQVWHTRrAqsDmgcCqweah4BffWAFoNkY/JoCaw6aLYAdBZqtgLUGzbbg1x5YR9DsDH5dgXUDzR7gdwKwXqDZG9jJoHkqsNNBcwD4DQQ2CDSHABsOmiOBjQLNMeA3Fth5oDkO2ATQnAjsYtC8DPyuAHYVaF4DbDJoTgF2I2jeCn63A7sTNO8Gdi9o3g/sP6A5DfweBfYYaD4BbCZozgL2DGg+D35zgL0EmvOAzQfNBcBeB823wO9tYO+C5nvAloDmUmDLQHMF+H0KbBVofgFsDWh+Bexr0FwPfj8A+xE0fwK2GTS3AtsOmrvAbw+whDLxNZOApZaJr1kMWAZolgC/HGClQLM0sLKgWR5YRdCsCn7VgdUEzVrA6oLmQcAOBs188GsArBFoNgHWHDRbADsCNFuBX2tgbUGzPbBOoNkF2DGgeRz4HQ+sJ2ieCKwPaJ4C7DTQ7At+/YEVguYwYGdFWdh5SKPh+aaD5kxgs4HNBbYA2PvQhyXQh29B80dgW4DtBJZYNj4rBqwEsNLAypWN3/eKwKqCZi3wqwvsYNDMB9YcNA8H1hI024JfB2BdQPME8DsR2Mmg2RfYENAcDmwUaJ4DfucBuwA0LwO/K4FdC5o3ALsTNO8Bdj9oPgx+jwJ7AjRng98LwOaC5qvA3gbNxcCWgObH4LcC2CrQXAt+XwNbD5o/AtsMmtuA7QTNxHLx/VKApZeLr5kFrBRo5gErD5pVwa8GsNqgeRCwAtBsBKwZaLYCvzbAOoBmV2DHg2YvYH1AcwD4nQFsKGieCWwsaJ4PbAJoXg5+VwG7DjRvBHYHaN4N7D7QfBT8Hgc2EzSfBfYSaL4MbAFovgN+7wH7EDSXA/scNFcDWweaP4LfJmBbQXMnsKTy8TVTgWWUj6+ZC35lgFUAzarAaoPmgcAOAc0m4Ncc2BGgeTSwjqDZBdixoNkb/E4GdjpoFgIbBpojgZ0NmuPB70Jgl4DmFcAmg+YNwG4Bzangdz+wh0BzOrCnQPMZYM+D5nzwew3YQtB8F9hS0PwY2ErQXAt+XwNbD5obgW0DzR3A9oBmQoX4fknAUirE10wHv0xgWaCZDSwXNPOAlQXN8uBXEVhl0KwOfjWB1QLNOsDqgeYhwOqDZgH4NQTWGDSbg18LYEeA5lHAWoNmW2DtQbMj+HUG1hU0u4NfD2AngGYvYH1A8xRgp4FmX/DrD6wQNAeD31Bgw0FzJLCzQHM0sHNA83zwGw9sAmhOBHYJaE4CdjloXg1+1wKbDJpTgN0EmrcAuw007wK/e4DdC5r3A3sQNB8G9ghoPg5+M4DNBM1ZwJ4FzeeAvQCac8HvZWDzQXMBsDdAcyGwRaC5GPzeB7YENJcC+xg0PwG2EjQ/B78vga0Bza+AfQOa3wH7HjQ3gt8mYJtBcyuwX0BzJ7DdoJlYMb5fMrDUivE1iwHLBM0sYNmgmQt+ecDKgmZ5YJVAswqwaqB5APjVBlYXNA8Cdgho1gdWAJqNwa8psOag2QLYkaDZEtjRoNkO/DoA6wSaXYB1A83uwHqAZi/w6w2sD2ieAux00OwHbABoDgK/IcCGgeYIYKNA82xgY0DzfGDjQXMCsImgeXEcv+hPXUfKJfz6Nz16PzH61z6cZKxl9H7+P7sVpDu6vvWb5Tf/TT8iE3/D9KimZH5imgL6+WlRndYTf9cP9sXesqL3E5xcxnyKGavqtLO3No5eQoC1DXmuGGs3Mfy57a29w5IDrIPDUgKso8NSA6yTw9ICrLPDigVYF4elB1hXh2UE2DEOywywbg6L/pzdb/mLXoJ77y0p+liW81gsj7HxkuP4+5tPjfNj+iUF9PPzG+XH+pQ08Xf97ECekh2WE2ApDovFaF+79YF21zvtSgRyly2Su0aNJF8bk7u9lxgJxp/j5GCrkwN3fsXaujlIlomxMCHwfJHIH9e2SOD5MyKi619BQuD5YvEE8xObX3ZexsbLGYWjW40ZPajX4NEjCs8+243eVezqPO5y9xZsE2wXbJ8ewhP8ZSU/K7JvVoIjJMV53OMIKfirIyT2/BkRyRH7+whJCcQTzE9wBU6VyU9+QkDfjSc1JD+x1zIthMW0YtUtxdFy26c6fXTbu//H/N3HGkf/5oRoBsduWmTf/riPxfJrY6kf/T87RCs5oJsQopsQopsTx9/ewt79JMT5G3ueyJ88T1jMwqtvvuzczc+XHfu/vxtOk9HvH3ud3XfAsVzZPrVyHo83bxJDXtfgvFjkaLaJ89pHIv7Xc3euBtfzdJmcDvir63ns+TMi+64xEut5eiCeYH6C63mGTDz9EwL6bjwZIfmJvZaZISymFds9uOPSbZ/h9NFt7/4f83cf6xH9mxOiGVw3MyP79sd9zF3Puwb6Fva+439dZ924Yq9vrG6khzAaH+nwPK5/8LWKt570ifOc8daTNIe77Wc6mqcG+hi2HmVH4ucmIRJeg4KvC/U/OBbCantiiFZwXXXbh71/+Sv98P3cqYHnTgl5buE62IBipb7RmhfWN7ff6eDntnPbpIbkxuVheQ3WJaEcNqScUA7D1un0kH5kh+Qpo2j61ohipb6FrdkZ0De335lF07fGFCv1rXhI+0zom9vv4uDntnPbpIbkxuVheS2isd+EckI5zAppXzykH9khecoqmr41pVipbyVC2mdB39x+lyiavjWjWKlvYUePS0Df3H5ng5/bzm2TGpIbl4fltYjGfnPKCeUwJ6R9dkg/skPylFM0fetLsVLfSoa0z4G+uf0uWTR960exUt9KhbQvCX1z+10q4Of2zW0XFovbPp5GYkAj7D17cF4kOMzjsaH+lN+wI+F/Nb/BvoXlNyvELzHA3H4nB1jY+//gMQ93zc6KROLWrqzIvq9TRoC5tbtEgIXNe9oHZgXu2/+D+0f3fVZWgLlrackAc/fHaQHmvvfODDC3bsfmemYk/H1f8Nil6+vz063YGAg7tpEY0pfgsYtno3/teNjltHd9IpG/Nub/7L1krD29l0yP7DsGJY4r/fbJaJx8ufl0278Ukq+wT2fTnf7YW/JEkf4MKBYTjew7TvfG7zzvn71Gkcjff28bPN7hzruMgBbtKYNri+ufGqe9e1zIbf9m9K/NTV7CH+Nz18Tg/A7Tdo9Hhe1dE/5mH9M89fG9kD7uz7UmbM8bXGs+dGKWXmti8fyTfWvCn/TP1Qg7Ju2OCcHXJf+f1oDPon//bE1zj+PZW/JEkf4UhK1p7rwKrmlhr0fYMem/W6dyIvuud8HxQcca/5c1zf3szG3/TfRv2JqW4PjTMfZiznO3ch63t7SJkT/0Y+9f57FYzmPjopjbPsDSHZY88Y/PkxG9n+w8j6sViyMl0H5L9H7sfVeq4xPzzwl5/tTA8/8h7pDHgnuP9JD26SHtbU43RP+3Y0lyjjRtlp8fiy+W+5TIH9fLSOD5UwLtd0bvB4/TxWpky/8xzoFN+xYMbNh3YN/GfQcMaNS/b6mAvpuzTIHnL2zWfEB+84GFfQsKChoMyC/8s+cPG0/ummdvsTHpjlm3fUwvJdg+KmDHRqqznu1tG/J8tl1paJcQ5+9ejZDHkif+8bGwsezO8Vj72HNnTNw3xhjLdJi7Httb8eh9N1+uViyOlED7UlGB2GvizsuYf07I8xcLPP8f4g55LDjHM0PaZ4a0t69PZtQpNm7dvvv8PN4dCxLzpFHjvk37921aUNC8UUFho4LGfzZPqkf/133me6Mm7vsCgfj/f+Z75Nf3Ge7xGHtr4+glBFjbkOeS7Kd71rHQ+ZENckPijz2XzU/0iyb77HWC7+eSI+HvE4O1PkzD1Qnm1X3dWv5vfS4IPhDsJ/UtxlICfQ3rt+vvnm8aCdEIe00jIc+RFMc3TDcR+vFnvm7uw96Tx+LR8J6xWvT+/n7PGPtWzf9rEd4aCteKBsJraGgtCltPqRYF55y9tYmysDrl1qLf3jdH5Gq6GQeNhV+ngtxI/Pphc1DeyY2b15RI/DqSEmgb/cG3ve+RS8bRSwW9sM9mXL/oRWlDP++LeMxVWBwJIXGEff72294h8u9fy6tE7+/vtbxy9H/la3nzolrLpc4fE/4OQeha7vYlxmNjuM3E33PZZuIfY4q1aee0aRenTXunTXunjb39r3Uj7JuCbQPMPSe4XYC572FjMdl1ONeJy97cb+8WUS1qtr9rUWx9tcfcY3WpcMSoMYVjCo8d02/Y4P7txozoP3rwyBGt+w4bFnzTHTxpKnZLCbQL+iUG7sfbNMTup4ToxvMPPhZv8LnxaygglaL393cB6Rf9X3kB6fv/AsK3/xeQPy8gpZ247C2sgIRd/qGIDro1298H3Y6M/DGP7omIwQIrNI4bJgSeLxLZtza4z58REZ23v33xL+wLQW5+YmPEFubYG5X+pgYfe9bgc/qOLoyVZbcLrmxiSBeDZTr4OVpYu/1VrsO+Ux38bD/4kgYfC55XEPS3N+nvVAfP50z08DzSn0nkROK/Z8wOee5gXpMC/Qg+Rq/Lb5/5R0SXrsZhS3vslhX58/HiLlfBuRYJ9N+9BZfINo5usF0wnrCchx1XD46LpMi+uQy7jkTYMh57XPg7+03CSkSw/2HXbQg7v/rvvh6xPv3d18PNUfC8ZndOBz/D0/p5ROvo/f29BXHfWoStR8Ea4r5OwTVU+rux7nelw+ZhqsPd9p2jf21fTw70Lez7HGHrazAGt73b7+D3sd05nhZg/7I849upsDzH2rvn5oW1D37HPdb+hOhfe/+06P9hdT8pwBJDtLPBLyEOcx+LRPatpWGvT9iaFHuN/w3nhO3vc20GRv/XfUijcX/dn28WNP+3fL6ZFGgX9HH92jht2sRp09Zp0zZOm3iHRtw28Q6NuG06OG06xGnT0WnTMU6bTk6bTnHadHbadI7TpovTpkucNl2dNl3jtDnGaXNMnDbdnDbd4rQ51mlzbJw23Z023eO0Oc5pc1ycNj2cNj3itDneaXN8nDYnOG1OiNOmp9OmZ5w2vZw2veK0OdFpc2KcNr2dNr3jtDnJaXNSoI3kd0jNYa+GsutIQbOww4mxvsjukwqaJwSeLxIJP5wVvC6h0LECvC5h2HvSsO+5JARY8sR9+xE8P9t9fe17scOcdmFjy95kP8tr3E+4fhXsv3H3637Gfb5IRP+4C7Lkifv24++Ou3ifs7aN/i+79v36HlBqjNtbbkj8weMtaRMjv91iOfg3fbcpdozn3/zdpiOi/8eOd5weax8RnecFwTruHj9051pwfy/58U1CJPyYR9hxirCP8xLi/I1pBVnsuYrqmr5hfaNr3IVdX5e0Uv+m1v58TcOOwSQE7rvtE0P6FrbWB6+qn+yw4NX43bXePTZ8WCA/UscJqLYlhPQ39njYd2PDxlHYdfWC1wwUug5rA3rtw65dWdx5fEBhvzFndBl5RiRwCx7ziuWtnNPGfb0SI/uO/bQ4WpHA/aBmkqPn3jQczy+M3t/fx/Pzov8rP6Wo0f+/68a3v/pdtz87/mb5n30fLnh9G8nXXPA1wffbtp+x97C2v3Wi/48YOXrwwPN6FI7uOnjEcYXnFJ41enC/YYU9Bg8obDtwYGH/0a1HjhkxuvCsSOAWttyFPW67p2F5i52dtb+XN/fSdG6cvoeKewkdAf3flk+pt4Xu27tI4LncvAXfsrv/x2IKXg7Kc6x9f9vqOjEkBZ4zGKPbJjmy7y0xcD858HjSX2gbfD6XuZd/jOcXvJxS8LHgW+VISPvftsfRvylxtNyPWN32aYG2Uq9hbkhMCXGeO08mht/mVGkZ/fywOZXn/F860E93XLX0FENMLzYGwk65Cp6K6B46c+NL8B9fQSRwC1tfYrfYmCntPJYXJ1ahn2poENOXubxV+JhxL+GdGWCx1y5sTUuIcz8x8JfaJoBu2DoU04y9Vm68sX78F7Rhk0eITxsA",
+      "debug_symbols": "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",
       "brillig_names": [
         "get_auth_witness",
         "decompose_hint",
         "lte_hint",
-        "pack_returns_oracle_wrapper",
+        "enqueue_public_function_call_internal",
+        "call_private_function_internal",
+        "debug_log_oracle_wrapper",
+        "notify_set_min_revertible_side_effect_counter_oracle_wrapper",
         "directive_to_radix",
         "directive_invert",
         "directive_integer_quotient"
       ],
-      "verification_key": "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",
-      "artifact_hash": "2b327f55c56d891bd26827aab8d7966172b21e72-b9b88f4d1aaa4c85199879d9d572d549-mega-honk-true"
+      "verification_key": "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",
+      "artifact_hash": "212cda3aaf31be03e5d6bcdebffe191826f41b55-0ea4c30d8e3ac641ac508c86aa5368a6-mega-honk-true"
     },
     {
       "name": "sync_notes",
@@ -1643,16 +1805,17 @@
         "return_type": null
       },
       "bytecode": "H4sIAAAAAAAA/9VUyw6CMBBseURBOaiJ3kz8gyIYOJJ49x8akKMe8OKNT5eabbqpVRKlJkzSbEs3szNlW0oUKESPvAH9tGnIFdhBDCA6aN/tRgFr9hviQKs7JH/O0iQw+BtQ/5OfWtIvIPktnT+bAM+xVfzYi6w77UaIesKWZ/nPbHpe9fhc/MFnh32k1caghm+uIYci3RuYR4Y8iRlRd9prh/eV5YzJei7w++RVO67va/lrWIeafvmOFV/qrDMe1wmv+YFXVVrypcYv4KBzGnMvbGHe1wvY45yo3mjul/J0vZ0b0gNB8gCVxsvQjgYAAA==",
-      "debug_symbols": "ndLBCoQgEAbgd5lzh7S07FViCSsLQTTMFpbo3deiXdqli14GR/xmDv4r9KJdxkbqwcxQ1Sso03EnjfbduiXQWqmUHJvrNaR7Qeh4P09c7+3suHVQ0TQBoXt/KL0epBJQ5bjYHgkgHAqyUJCHAhII8O0GRnB5EkYI+SKUsgORGERjUBGDygiU3f4+o6j4IJrRX7T59smt5K0SZ7qGRXeXsLnXJP5yN1nTiX6xYk/gJXy+1n4Xxn6sH/0G",
+      "debug_symbols": "ndLNCoQgEAfwd5lzh7S0j1eJJawsBNEwW1iid98p2qVduthlcMTfzMH/Ap1s5qFWprcTlNUC2rbCK2uwW9YIGqe0VkN9voZ4K4Ts76dRmK2dvHAeSh5HIE2Hhxx1r7SEMqV8fURAaChIQkEaClggoJcbCkbzgxSMsS/KyW7YDcNvmOyGycNNcvnxBSfZx/CE/5gVu6dwSjRaHrnqZ9OeYuZfo/xL3OhsK7vZyS17p9hhrXAVpTgWR78B",
       "brillig_names": [
         "sync_notes"
       ]
     },
     {
-      "name": "entrypoint",
+      "name": "verify_private_authwit",
       "is_unconstrained": false,
       "custom_attributes": [
-        "private"
+        "private",
+        "view"
       ],
       "abi": {
         "error_types": {
@@ -1664,13 +1827,17 @@
             "error_kind": "string",
             "string": "Stack too deep"
           },
-          "5019202896831570965": {
+          "19458536156181958": {
             "error_kind": "string",
-            "string": "attempt to add with overflow"
+            "string": "Function verify_private_authwit can only be called statically"
           },
-          "5727012404371710682": {
+          "4939791462094160055": {
             "error_kind": "string",
-            "string": "push out of bounds"
+            "string": "Message not authorized by account"
+          },
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
           },
           "6485997221020871071": {
             "error_kind": "string",
@@ -2137,173 +2304,9 @@
             "visibility": "private"
           },
           {
-            "name": "app_payload",
-            "type": {
-              "fields": [
-                {
-                  "name": "function_calls",
-                  "type": {
-                    "kind": "array",
-                    "length": 4,
-                    "type": {
-                      "fields": [
-                        {
-                          "name": "args_hash",
-                          "type": {
-                            "kind": "field"
-                          }
-                        },
-                        {
-                          "name": "function_selector",
-                          "type": {
-                            "fields": [
-                              {
-                                "name": "inner",
-                                "type": {
-                                  "kind": "integer",
-                                  "sign": "unsigned",
-                                  "width": 32
-                                }
-                              }
-                            ],
-                            "kind": "struct",
-                            "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector"
-                          }
-                        },
-                        {
-                          "name": "target_address",
-                          "type": {
-                            "fields": [
-                              {
-                                "name": "inner",
-                                "type": {
-                                  "kind": "field"
-                                }
-                              }
-                            ],
-                            "kind": "struct",
-                            "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-                          }
-                        },
-                        {
-                          "name": "is_public",
-                          "type": {
-                            "kind": "boolean"
-                          }
-                        },
-                        {
-                          "name": "is_static",
-                          "type": {
-                            "kind": "boolean"
-                          }
-                        }
-                      ],
-                      "kind": "struct",
-                      "path": "authwit::entrypoint::function_call::FunctionCall"
-                    }
-                  }
-                },
-                {
-                  "name": "nonce",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "authwit::entrypoint::app::AppPayload"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "fee_payload",
-            "type": {
-              "fields": [
-                {
-                  "name": "function_calls",
-                  "type": {
-                    "kind": "array",
-                    "length": 2,
-                    "type": {
-                      "fields": [
-                        {
-                          "name": "args_hash",
-                          "type": {
-                            "kind": "field"
-                          }
-                        },
-                        {
-                          "name": "function_selector",
-                          "type": {
-                            "fields": [
-                              {
-                                "name": "inner",
-                                "type": {
-                                  "kind": "integer",
-                                  "sign": "unsigned",
-                                  "width": 32
-                                }
-                              }
-                            ],
-                            "kind": "struct",
-                            "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector"
-                          }
-                        },
-                        {
-                          "name": "target_address",
-                          "type": {
-                            "fields": [
-                              {
-                                "name": "inner",
-                                "type": {
-                                  "kind": "field"
-                                }
-                              }
-                            ],
-                            "kind": "struct",
-                            "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-                          }
-                        },
-                        {
-                          "name": "is_public",
-                          "type": {
-                            "kind": "boolean"
-                          }
-                        },
-                        {
-                          "name": "is_static",
-                          "type": {
-                            "kind": "boolean"
-                          }
-                        }
-                      ],
-                      "kind": "struct",
-                      "path": "authwit::entrypoint::function_call::FunctionCall"
-                    }
-                  }
-                },
-                {
-                  "name": "nonce",
-                  "type": {
-                    "kind": "field"
-                  }
-                },
-                {
-                  "name": "is_fee_payer",
-                  "type": {
-                    "kind": "boolean"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "authwit::entrypoint::fee::FeePayload"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "cancellable",
+            "name": "inner_hash",
             "type": {
-              "kind": "boolean"
+              "kind": "field"
             },
             "visibility": "private"
           }
@@ -3418,22 +3421,19 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "get_auth_witness",
         "decompose_hint",
         "lte_hint",
-        "enqueue_public_function_call_internal",
-        "call_private_function_internal",
-        "debug_log_oracle_wrapper",
-        "notify_set_min_revertible_side_effect_counter_oracle_wrapper",
+        "pack_returns_oracle_wrapper",
         "directive_to_radix",
         "directive_invert",
         "directive_integer_quotient"
       ],
-      "verification_key": "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",
-      "artifact_hash": "2b327f55c56d891bd26827aab8d7966172b21e72-e81621bab5e96113801a485c09c53796-mega-honk-true"
+      "verification_key": "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",
+      "artifact_hash": "212cda3aaf31be03e5d6bcdebffe191826f41b55-cb6cb551134fb090c44ad87ffd442452-mega-honk-true"
     },
     {
       "name": "compute_note_hash_and_optionally_a_nullifier",
@@ -3519,8 +3519,8 @@
           "visibility": "public"
         }
       },
-      "bytecode": "H4sIAAAAAAAA/9VZ23LaMBAV2AbshIRA0kIfM9O3dsYO5pI3ZnrJd7hJ+IJ+gB/60n51o0FrHy+bDMGrB3aGke2Vzh6dlSzJdMzOBi+/jrsOXdkz+0Z1Nq5M21mmiJX65Nk5EZ7dE+EZnAjPUJFnR+BpS5pvkdnNub7Zzcc9Jza2iQ7Ab94CYkH/uTJ2ZRf8ionJYqGzWvjrNH+MTdOU+c9jh9n3g78g/IEf/JR4fytrfOwLxQ1c+VDWWj5AG2tDd42DmHDJ1wXfd+YLwPeD+XAM/2Q+HPfEiXTrQV8Ux9Xad16ob33oW+eV0phaO3xGWifG6xjNKOcx48P5E58h1SlrPj3mC8EXM18EPtLflrdQj+e+D/W+wnM+JgOzP4bJTzlHrX2MqdAD/ovlku48J2HZjI0+1D0EPW+ZPj7WCtTHh/5Wn8kr/OnaWr80lQVMT9SINBtgfeaLwReWzTiJuw8hDmIRj4jV/+LuL13ZgzbUfiTE77H4Dd7CM9SIYwXCM6pv5+Rnd31mduPnD9U3++8pvU318l56Z+vhr6q9QOyH/zPhJ17w8wr/DPA11zTCP/ejz5Lwh37wq73YhRf8u0qfS8A3evpntC7S/McYFPvKS+6z7JA9C8ZPGFdfe5Yrxofrg+uj9Y0FriPBx+foWIgzFuJQHias/Ual38utxHVyJFcJ60IRK1bEOraPlI9r1n7j7tNWtsolrteK/R4qYg0UsY4dJ5SPG9Z+4+7TVrYU83Gj2G/NfJwrYvUVsTTnraZelEdprbO2cWXa0jhXPM9hTFrnI1b/N+P5Adoorsl3tKZ9NLXx/cDUU+xD9wMUfyjwId6J4GvzUfb512KR3RerLEu3y3xe5XPKuPJneCayv5lQX9pbkNafjBetU+ncPwNdrYXgmzJfBD7iKJ37Z574H6I/xh8JPjzTvCeXY9Mcazgf+XnVGL13CI136du8dM7U/OZ86Nyk+Anjqsznze+LqA/fqycC15Hg42tfIsRJhDiniMW/0aOGdo6QTmFZ+7VyuVrXf3DRuygyze/+hsWPWP2/7h77RmWbd/52VWTbebEtFsXTU/5YjBm+tS7o9B+RfvSPFR8AAA==",
-      "debug_symbols": "tdnRaoMwFIDhd8m1F0aTc076KmMM26ZFEC3WDkbx3RdL2cp2/d+IkfgHxO/q3N0x72/nj348TVe3e7u7YTp0Sz+NZXVfK7ef+2Hozx+vj129XYI89l8v3bgtr0s3L24ndeXyeCw3Vt4+9UN2u9DoWv3bqc1zp+rPzmjre+WCYmXDyokqxxore6zcYOUWKwesHLEyZjBiBiNmMGIGBTMomEHBDApmUDCDghkUzKBgBgUzKJhBxQwqZlAxg4oZVMygYgYVM6iYQcUMKmbQMIOGGTTMoGEGDTNomEHDDBpm0DCDhhlMmMGEGUyYwYQZTJjBhBlMmMGEGUyYwYQZ9HXNpT2Xbrh0y6UDl45cWri0cmnj0pxGz2n0nEbPafScRs9p9JDGtaw+u7nv9kN+jjVOt/HwMuVYvi75z8DjMk+HfLzNeRt9/E49tg/bhiqExy9dFr5tKt9qOaQc9A0=",
+      "bytecode": "H4sIAAAAAAAA/9VZS27bMBClLcmy5Mh27RsE6K4FxFj+ZGegn5xDTewT9ABadNOeuiHMkZ5Hk8KAh0U8QEBZQ715fDMiKWZgTjZ+/Rv469i3I9M36rP3bXmdWUWsMiTPwY3wHN4Iz+hGeMaKPAcCT9fS+5aY0zuXmtP72HPiwy7REfjNv4BY0D++zXw7BL9iYmwmDFYLf1dWz5k5N2X+q8xjpmHw14Q/DoNfEu8vTYePY6G4kW+fmk7LJ3jGWeGvsYgJl3xD8H1lvgh835gPa/g782HdEyfSbQRjUayrXei80NhSGNvgjdaYTju8R1rnJmiNWsp5xvhw/sSnoD5Nx2fEfDH4MuZLwEf6u/Ye+vHcp9DvM9znNRmZfg2Tn3KOWoeoqTgA/qtVku48J3FzHht9qHsMet4zfUKsFahPCP2dPss3+NO1s7QxrUVMT9SINBtjf+bLwBc353Fy/zuGOIhFPBLW/5P/PfPtCJ6h5+dC/BGLf8ZbuIcacaxIuEf93Tv50V9PzKl+flF/05+n9DbVm0qas/Xwty1+Fob/kfDzMPgbwp+EwW/3MndB8B9Kwi/C8H8k/GmY+mn3krMw/A+EPw+CXx1o3f1gOmvnB3+9gPt6c7e1l+yJMH7OuIbaEy0YH64Prr/OtxS4zgUfz+FSiLMU4khYmSLWnSLW7J2OcayINVHEmipiaeYxVcTS1CtXxCoUsTTrXlMvyqO0T3O29215pUn7NEV8K+3TNL/dSWuqr1jQEMeXsP4/mc6TIDztA6059K5TDIxdBIp96XpN8QuBD/HOBd81h7KHH+u1fay31pbHTbVq81kwrvwefhPhfIz9pbVf2vcpal1K3/1T0NVZDL6C+RLwEUfpu38aiP8l+mP8ueDj6/+luVyY/no4YePGM669ypi78z/pbD7w/LW+9N2k+Lnpz9f/63wR9eF76VzgOhd8fH+SC3FyIc4tYvEzetTQ1TXpFDedXyuX2133Dy6aixJzfu5vWPyE9f/tf+PYqL1mzj9ua3tc1cd6Xb+8VM/1guE7G4JOfwHiE0IYFR8AAA==",
+      "debug_symbols": "tdfRioQgFAbgd/Hai45aaq+yLIOVDYJYWC0s0buvDbE77FwO/0104vQJ4o+cnQ2+2+63kMZpYe3HzuLUuzVMqVT7wVmXQ4zhfnv+zKrzYeWjf5ldOstldXllbVNx5tNQXkz5ewzRs1aJ5uAvnVpcnVr/dtbm+OTMKphcw+QGJmuYbGCyRclUVTiacLTA0RJHKxxd4+gGR2scbXA0Lo2ESyPh0ki4NBIujYRLI+HSSG+m0cqrs2zti62BtgHaFmeLCmgT0BZAWwJtBbRroA3MpQDmUgBzKVC5PEr15XJwXfTXYDVuqX+as9bv2f8bueY89X7Ysj+Hr7+56zzLUnGlHld7KUgKTlKXRcpCPw==",
       "brillig_names": [
         "compute_note_hash_and_optionally_a_nullifier"
       ]
@@ -3530,6 +3530,33 @@
     "globals": {},
     "structs": {
       "functions": [
+        {
+          "fields": [
+            {
+              "name": "parameters",
+              "type": {
+                "fields": [
+                  {
+                    "name": "inner_hash",
+                    "type": {
+                      "kind": "field"
+                    }
+                  }
+                ],
+                "kind": "struct",
+                "path": "SchnorrSingleKeyAccount::verify_private_authwit_parameters"
+              }
+            },
+            {
+              "name": "return_type",
+              "type": {
+                "kind": "field"
+              }
+            }
+          ],
+          "kind": "struct",
+          "path": "SchnorrSingleKeyAccount::verify_private_authwit_abi"
+        },
         {
           "fields": [
             {
@@ -3712,33 +3739,6 @@
           ],
           "kind": "struct",
           "path": "SchnorrSingleKeyAccount::entrypoint_abi"
-        },
-        {
-          "fields": [
-            {
-              "name": "parameters",
-              "type": {
-                "fields": [
-                  {
-                    "name": "inner_hash",
-                    "type": {
-                      "kind": "field"
-                    }
-                  }
-                ],
-                "kind": "struct",
-                "path": "SchnorrSingleKeyAccount::verify_private_authwit_parameters"
-              }
-            },
-            {
-              "name": "return_type",
-              "type": {
-                "kind": "field"
-              }
-            }
-          ],
-          "kind": "struct",
-          "path": "SchnorrSingleKeyAccount::verify_private_authwit_abi"
         }
       ]
     }
@@ -3768,85 +3768,85 @@
       "path": "std/panic.nr",
       "source": "pub fn panic<T, U, let N: u32>(message: fmtstr<N, T>) -> U {\n    assert(false, message);\n    crate::mem::zeroed()\n}\n"
     },
-    "72": {
+    "74": {
       "path": "/usr/src/noir-projects/aztec-nr/authwit/src/auth.nr",
       "source": "use dep::aztec::{context::{gas::GasOpts, PrivateContext, PublicContext}, hash::hash_args_array};\nuse dep::aztec::protocol_types::{\n    abis::function_selector::FunctionSelector,\n    address::AztecAddress,\n    constants::{\n        CANONICAL_AUTH_REGISTRY_ADDRESS, GENERATOR_INDEX__AUTHWIT_INNER,\n        GENERATOR_INDEX__AUTHWIT_NULLIFIER, GENERATOR_INDEX__AUTHWIT_OUTER,\n    },\n    hash::poseidon2_hash_with_separator,\n};\n\n/**\n * Authenticaion witness helper library\n *\n * Authentication Witness is a scheme for authenticating actions on Aztec, so users can allow third-parties\n * (e.g. protocols or other users) to execute an action on their behalf.\n *\n * This library provides helper functions to manage such witnesses.\n * The authentication witness, is some \"witness\" (data) that authenticates a `message_hash`.\n * The simplest example of an authentication witness, is a signature. The signature is the \"evidence\",\n * that the signer has seen the message, agrees with it, and has allowed it.\n * It does not need to be a signature. It could be any kind of \"proof\" that the message is allowed.\n * Another proof could be knowing some kind of secret, or having some kind of \"token\" that allows the message.\n *\n * The `message_hash` is a hash of the following structure:\n * hash(consumer, chain_id, version, inner_hash)\n * - consumer: the address of the contract that is \"consuming\" the message,\n * - chain_id: the chain id of the chain that the message is being consumed on,\n * - version: the version of the chain that the message is being consumed on,\n * - inner_hash: the hash of the \"inner\" message that is being consumed, this is the \"actual\" message or action.\n *\n * While the `inner_hash` could be anything, such as showing you signed a specific message, it will often be\n * a hash of the \"action\" to approve, along with who made the call. As part of this library, we provide a few\n * helper functions to deal with such messages.\n *\n * For example, we provide helper function that is used for checking that the message is an encoding of the current call.\n * This can be used to let some contract \"allow\" another contract to act on its behalf, as long as it can\n * show that it is acting on behalf of the contract.\n *\n * If we take a case of allowing a contract to transfer tokens on behalf of an account, the `inner_hash` can be\n * derived as:\n * inner_hash = hash(caller, \"transfer\", hash(to, amount))\n *\n * Where the `caller` would be the address of the contract that is trying to transfer the tokens, and `to` and `amount`\n * the arguments for the transfer.\n *\n * Note that we have both a `caller` and a `consumer`, the `consumer` will be the contract that is consuming the message,\n * in the case of the transfer, it would be the `Token` contract itself, while the caller, will be the actor that is\n * allowed to transfer the tokens.\n *\n *\n * The authentication mechanism works differently in public and private contexts. In private, we recall that everything\n * is executed on the user's device, so we can use `oracles` to \"ask\" the user (not contract) for information. In public\n * we cannot do this, since it is executed by the sequencer (someone else). Therefore we can instead use a \"registry\"\n * to store the messages that we have approved.\n *\n * A simple example would be a \"token\" that is being \"pulled\" from one account into another. We will first outline\n * how this would look in private, and then in public later.\n *\n * Say that a user `Alice` wants to deposit some tokens into a DeFi protocol (say a DEX).\n * `Alice` would make a `deposit` transaction, that she is executing using her account contract.\n * The account would call the `DeFi` contract to execute `deposit`, which would try to pull funds from the `Token`\n * contract. Since the `DeFi` contract is trying to pull funds from an account that is not its own, it needs to\n * convince the `Token` contract that it is allowed to do so.\n *\n * This is where the authentication witness comes in The `Token` contract computes a `message_hash` from the\n * `transfer` call, and then asks `Alice Account` contract to verify that the `DeFi` contract is allowed to\n * execute that call.\n *\n * `Alice Account` contract can then ask `Alice` if she wants to allow the `DeFi` contract to pull funds from her\n * account. If she does, she will sign the `message_hash` and return the signature to the `Alice Account` which\n * will validate it and return success to the `Token` contract which will then allow the `DeFi` contract to pull\n * funds from `Alice`.\n *\n * To ensure that the same \"approval\" cannot be used multiple times, we also compute a `nullifier` for the\n * authentication witness, and emit it from the `Token` contract (consumer).\n *\n * Note that we can do this flow as we are in private were we can do oracle calls out from contracts.\n *\n *\n *  Person          Contract              Contract               Contract\n *  Alice          Alice Account          Token                   DeFi\n *   |                  |                  |                      |\n *   | Defi.deposit(Token, 1000)           |                      |\n *   |----------------->|                  |                      |\n *   |                  | deposit(Token, 1000)                    |\n *   |                  |---------------------------------------->|\n *   |                  |                  |                      |\n *   |                  |                  | transfer(Alice, Defi, 1000)\n *   |                  |                  |<---------------------|\n *   |                  |                  |                      |\n *   |                  | Check if Defi may call transfer(Alice, Defi, 1000)\n *   |                  |<-----------------|                      |\n *   |                  |                  |                      |\n *   | Please give me AuthWit for DeFi     |                      |\n *   | calling transfer(Alice, Defi, 1000) |                      |\n *   |<-----------------|                  |                      |\n *   |                  |                  |                      |\n *   |                  |                  |                      |\n *   | AuthWit for transfer(Alice, Defi, 1000)                    |\n *   |----------------->|                  |                      |\n *   |                  | AuthWit validity |                      |\n *   |                  |----------------->|                      |\n *   |                  |                  |                      |\n *   |                  |       throw if invalid AuthWit          |\n *   |                  |                  |                      |\n *   |                  |       emit AuthWit nullifier            |\n *   |                  |                  |                      |\n *   |                  |       transfer(Alice, Defi, 1000)       |\n *   |                  |                  |                      |\n *   |                  |                  |                      |\n *   |                  |                  | success              |\n *   |                  |                  |--------------------->|\n *   |                  |                  |                      |\n *   |                  |                  |                      |\n *   |                  |                  |           deposit(Token, 1000)\n *   |                  |                  |                      |\n *   |                  |                  |                      |\n *\n *\n * If we instead were in public, we cannot do the same flow. Instead we would use an authentication registry to store\n * the messages that we have approved.\n *\n * To approve a message, `Alice Account` can make a `set_authorized` call to the registry, to set a `message_hash`\n * as authorized. This is essentially a mapping from `message_hash` to `true` for `Alice Contract`. Every account\n * has its own map in the registry, so `Alice` cannot approve a message for `Bob`.\n *\n * The `Token` contract can then try to \"spend\" the approval by calling `consume` on the registry. If the message\n * was approved, the value is updated to `false`, and we return the success flag. For more information on the\n * registry, see `main.nr` in `auth_registry_contract`.\n *\n * Person          Contract              Contract            Contract               Contract\n * Alice          Alice Account          Registry             Token                   DeFi\n *   |                  |                    |                   |                      |\n *   | Registry.set_authorized(..., true)    |                   |                      |\n *   |----------------->|                    |                   |                      |\n *   |                  | set_authorized(..., true)              |                      |\n *   |                  |------------------->|                   |                      |\n *   |                  |                    |                   |                      |\n *   |                  |         set authorized to true         |                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   |                      |\n *   | Defi.deposit(Token, 1000)             |                   |                      |\n *   |----------------->|                    |                   |                      |\n *   |                  | deposit(Token, 1000)                   |                      |\n *   |                  |-------------------------------------------------------------->|\n *   |                  |                    |                   |                      |\n *   |                  |                    |              transfer(Alice, Defi, 1000) |\n *   |                  |                    |                   |<---------------------|\n *   |                  |                    |                   |                      |\n *   |                  |                    | Check if Defi may call transfer(Alice, Defi, 1000)\n *   |                  |                    |<------------------|                      |\n *   |                  |                    |                   |                      |\n *   |                  |          throw if invalid AuthWit      |                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   |                      |\n *   |                  |           set authorized to false      |                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    | AuthWit validity  |                      |\n *   |                  |                    |------------------>|                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   | transfer(Alice, Defi, 1000)\n *   |                  |                    |                   |<-------------------->|\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   | success              |\n *   |                  |                    |                   |--------------------->|\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   |     deposit(Token, 1000)\n *   |                  |                    |                   |                      |\n *\n *\n * --- FAQ ---\n * Q:   Why are we using a success flag of `poseidon2_hash_bytes(\"IS_VALID()\")` instead of just returning a boolean?\n * A:   We want to make sure that we don't accidentally return `true` if there is a collision in the function selector.\n *      By returning a hash of `IS_VALID()`, it becomes very unlikely that there is both a collision and we return\n *      a success flag.\n *\n * Q:   Why are we using static calls?\n * A:   We are using static calls to ensure that the account contract cannot re-enter. If it was a normal call, it\n *      could make a new call and do a re-entry attack. Using a static ensures that it cannot update any state.\n *\n * Q:   Would it not be cheaper to use a nullifier instead of updating state in public?\n * A:   At a quick glance, a public state update + nullifier is 96 bytes, but two state updates are 128, so it would be\n *      cheaper to use a nullifier, if this is the way it would always be done. However, if both the approval and the\n *      consumption is done in the same transaction, then we will be able to squash the updates (only final tx state diff is posted to DA), and now it is cheaper.\n *\n * Q:   Why is the chain id and the version part of the message hash?\n * A:   The chain id and the version is part of the message hash to ensure that the message is only valid on a specific\n *      chain to avoid a case where the same message could be used across multiple chains.\n */\n\nglobal IS_VALID_SELECTOR = 0x47dacd73; // 4 last bytes of poseidon2_hash_bytes(\"IS_VALID()\")\n\n/**\n * Assert that `on_behalf_of` have authorized the current call with a valid authentication witness\n *\n * Computing the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then making a call out to the\n * `on_behalf_of` contract to verify that the `inner_hash` is valid.\n *\n * @param on_behalf_of The address that have authorized the current call\n */\n// docs:start:assert_current_call_valid_authwit\npub fn assert_current_call_valid_authwit(context: &mut PrivateContext, on_behalf_of: AztecAddress) {\n    let inner_hash = compute_inner_authwit_hash([\n        context.msg_sender().to_field(),\n        context.selector().to_field(),\n        context.args_hash,\n    ]);\n    assert_inner_hash_valid_authwit(context, on_behalf_of, inner_hash);\n}\n// docs:end:assert_current_call_valid_authwit\n\n/**\n * Assert that a specific `inner_hash` is valid for the `on_behalf_of` address\n *\n * Used as an internal function for `assert_current_call_valid_authwit` and can be used as a standalone function when\n * the `inner_hash` is from a different source, e.g., say a block of text etc.\n *\n * @param on_behalf_of The address that have authorized the current call\n * @param inner_hash The hash of the message to authorize\n */\npub fn assert_inner_hash_valid_authwit(\n    context: &mut PrivateContext,\n    on_behalf_of: AztecAddress,\n    inner_hash: Field,\n) {\n    // We perform a static call here and not a standard one to ensure that the account contract cannot re-enter.\n    let result: Field = context\n        .static_call_private_function(\n            on_behalf_of,\n            comptime { FunctionSelector::from_signature(\"verify_private_authwit(Field)\") },\n            [inner_hash],\n        )\n        .unpack_into();\n    assert(result == IS_VALID_SELECTOR, \"Message not authorized by account\");\n    // Compute the nullifier, similar computation to the outer hash, but without the chain_id and version.\n    // Those should already be handled in the verification, so we just need something to nullify, that allow same inner_hash for multiple actors.\n    let nullifier = compute_authwit_nullifier(on_behalf_of, inner_hash);\n    context.push_nullifier(nullifier);\n}\n\n/**\n * Assert that `on_behalf_of` have authorized the current call in the authentication registry\n *\n * Computing the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then making a call out to the\n * `on_behalf_of` contract to verify that the `inner_hash` is valid.\n *\n * Note that the authentication registry will take the `msg_sender` into account as the consumer, so this will only\n * work if the `msg_sender` is the same as the `consumer` when the `message_hash` was inserted into the registry.\n *\n * @param on_behalf_of The address that have authorized the current call\n */\n// docs:start:assert_current_call_valid_authwit_public\npub unconstrained fn assert_current_call_valid_authwit_public(\n    context: &mut PublicContext,\n    on_behalf_of: AztecAddress,\n) {\n    let inner_hash = compute_inner_authwit_hash([\n        (*context).msg_sender().to_field(),\n        (*context).selector().to_field(),\n        (*context).get_args_hash(),\n    ]);\n    assert_inner_hash_valid_authwit_public(context, on_behalf_of, inner_hash);\n}\n// docs:end:assert_current_call_valid_authwit_public\n\n/**\n * Assert that `on_behalf_of` have authorized a speicifc `inner_hash` in the authentication registry\n *\n * Computing the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then making a call out to the\n * `on_behalf_of` contract to verify that the `inner_hash` is valid.\n *\n * Note that the authentication registry will take the `msg_sender` into account as the consumer, so this will only\n * work if the `msg_sender` is the same as the `consumer` when the `message_hash` was inserted into the registry.\n *\n * @param on_behalf_of The address that have authorized the `inner_hash`\n */\npub unconstrained fn assert_inner_hash_valid_authwit_public(\n    context: &mut PublicContext,\n    on_behalf_of: AztecAddress,\n    inner_hash: Field,\n) {\n    let results: [Field] = context.call_public_function(\n        CANONICAL_AUTH_REGISTRY_ADDRESS,\n        comptime { FunctionSelector::from_signature(\"consume((Field),Field)\") },\n        [on_behalf_of.to_field(), inner_hash].as_slice(),\n        GasOpts::default(),\n    );\n    assert(results.len() == 1, \"Invalid response from registry\");\n    assert(results[0] == IS_VALID_SELECTOR, \"Message not authorized by account\");\n}\n\n/**\n * Compute the `message_hash` from a function call to be used by an authentication witness\n *\n * Useful for when you need a non-account contract to approve during execution. For example if you need a contract\n * to make a call to nested contract, e.g., contract A wants to exit token T to L1 using bridge B, so it needs to allow\n * B to transfer T on its behalf.\n *\n * @param caller The address of the contract that is calling the function, in the example above, this would be B\n * @param consumer The address of the contract that is consuming the message, in the example above, this would be T\n * @param chain_id The chain id of the chain that the message is being consumed on\n * @param version The version of the chain that the message is being consumed on\n * @param selector The function selector of the function that is being called\n * @param args The arguments of the function that is being called\n */\n// docs:start:compute_authwit_message_hash_from_call\npub fn compute_authwit_message_hash_from_call<let N: u32>(\n    caller: AztecAddress,\n    consumer: AztecAddress,\n    chain_id: Field,\n    version: Field,\n    selector: FunctionSelector,\n    args: [Field; N],\n) -> Field {\n    let args_hash = hash_args_array(args);\n    let inner_hash =\n        compute_inner_authwit_hash([caller.to_field(), selector.to_field(), args_hash]);\n    compute_authwit_message_hash(consumer, chain_id, version, inner_hash)\n}\n// docs:end:compute_authwit_message_hash_from_call\n\n/**\n * Computes the `inner_hash` of the authentication witness\n *\n * This is used internally, but also useful in cases where you want to compute the `inner_hash` for a specific message\n * that is not necessarily a call, but just some \"bytes\" or text.\n *\n * @param args The arguments to hash\n */\npub fn compute_inner_authwit_hash<let N: u32>(args: [Field; N]) -> Field {\n    poseidon2_hash_with_separator(args, GENERATOR_INDEX__AUTHWIT_INNER)\n}\n\n/**\n * Computs the `authwit_nullifier` for a specific `on_behalf_of` and `inner_hash`\n *\n * Using the `on_behalf_of` and the `inner_hash` to ensure that the nullifier is siloed for a specific `on_behalf_of`.\n *\n * @param on_behalf_of The address that have authorized the `inner_hash`\n * @param inner_hash The hash of the message to authorize\n */\npub fn compute_authwit_nullifier(on_behalf_of: AztecAddress, inner_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [on_behalf_of.to_field(), inner_hash],\n        GENERATOR_INDEX__AUTHWIT_NULLIFIER,\n    )\n}\n\n/**\n * Computes the `message_hash` for the authentication witness\n *\n * @param consumer The address of the contract that is consuming the message\n * @param chain_id The chain id of the chain that the message is being consumed on\n * @param version The version of the chain that the message is being consumed on\n * @param inner_hash The hash of the \"inner\" message that is being consumed\n */\npub fn compute_authwit_message_hash(\n    consumer: AztecAddress,\n    chain_id: Field,\n    version: Field,\n    inner_hash: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [consumer.to_field(), chain_id, version, inner_hash],\n        GENERATOR_INDEX__AUTHWIT_OUTER,\n    )\n}\n\n/**\n * Helper function to set the authorization status of a message hash\n *\n * Wraps a public call to the authentication registry to set the authorization status of a `message_hash`\n *\n * @param message_hash The hash of the message to authorize\n * @param authorize True if the message should be authorized, false if it should be revoked\n */\npub unconstrained fn set_authorized(\n    context: &mut PublicContext,\n    message_hash: Field,\n    authorize: bool,\n) {\n    let res = context.call_public_function(\n        CANONICAL_AUTH_REGISTRY_ADDRESS,\n        comptime { FunctionSelector::from_signature(\"set_authorized(Field,bool)\") },\n        [message_hash, authorize as Field].as_slice(),\n        GasOpts::default(),\n    );\n    assert(res.len() == 0);\n}\n\n/**\n * Helper function to reject all authwits\n *\n * Wraps a public call to the authentication registry to set the `reject_all` flag\n *\n * @param reject True if all authwits should be rejected, false otherwise\n */\npub unconstrained fn set_reject_all(context: &mut PublicContext, reject: bool) {\n    let res = context.call_public_function(\n        CANONICAL_AUTH_REGISTRY_ADDRESS,\n        comptime { FunctionSelector::from_signature(\"set_reject_all(bool)\") },\n        [context.this_address().to_field(), reject as Field].as_slice(),\n        GasOpts::default(),\n    );\n    assert(res.len() == 0);\n}\n"
     },
-    "73": {
+    "75": {
+      "path": "/usr/src/noir-projects/aztec-nr/authwit/src/entrypoint/fee.nr",
+      "source": "use crate::entrypoint::function_call::FunctionCall;\nuse dep::aztec::prelude::PrivateContext;\nuse dep::aztec::protocol_types::{\n    constants::GENERATOR_INDEX__FEE_PAYLOAD,\n    hash::poseidon2_hash_with_separator,\n    traits::{Hash, Serialize},\n};\n\n// 2 * 5 (FUNCTION_CALL_SIZE) + 2\nglobal FEE_PAYLOAD_SIZE: u32 = 12;\n\n// 2 * 98 (FUNCTION_CALL_SIZE_IN_BYTES) + 32\nglobal FEE_PAYLOAD_SIZE_IN_BYTES: u32 = 228;\n\nglobal MAX_FEE_FUNCTION_CALLS: u32 = 2;\n\n// docs:start:fee-payload-struct\npub struct FeePayload {\n    function_calls: [FunctionCall; MAX_FEE_FUNCTION_CALLS],\n    nonce: Field,\n    is_fee_payer: bool,\n}\n// docs:end:fee-payload-struct\n\nimpl Serialize<FEE_PAYLOAD_SIZE> for FeePayload {\n    // Serializes the entrypoint struct\n    fn serialize(self) -> [Field; FEE_PAYLOAD_SIZE] {\n        let mut fields: BoundedVec<Field, FEE_PAYLOAD_SIZE> = BoundedVec::new();\n        for i in 0..MAX_FEE_FUNCTION_CALLS {\n            fields.extend_from_array(self.function_calls[i].serialize());\n        }\n        fields.push(self.nonce);\n        fields.push(self.is_fee_payer as Field);\n        fields.storage()\n    }\n}\n\nimpl Hash for FeePayload {\n    fn hash(self) -> Field {\n        poseidon2_hash_with_separator(self.serialize(), GENERATOR_INDEX__FEE_PAYLOAD)\n    }\n}\n\nimpl FeePayload {\n    fn to_be_bytes(self) -> [u8; FEE_PAYLOAD_SIZE_IN_BYTES] {\n        let mut bytes: BoundedVec<u8, FEE_PAYLOAD_SIZE_IN_BYTES> = BoundedVec::new();\n\n        for i in 0..MAX_FEE_FUNCTION_CALLS {\n            bytes.extend_from_array(self.function_calls[i].to_be_bytes());\n        }\n        bytes.extend_from_array(self.nonce.to_be_bytes::<32>());\n        bytes.push(self.is_fee_payer as u8);\n\n        bytes.storage()\n    }\n\n    fn execute_calls(self, context: &mut PrivateContext) {\n        for call in self.function_calls {\n            if !call.target_address.is_zero() {\n                if call.is_public {\n                    context.call_public_function_with_packed_args(\n                        call.target_address,\n                        call.function_selector,\n                        call.args_hash,\n                        call.is_static,\n                    );\n                } else {\n                    let _result = context.call_private_function_with_packed_args(\n                        call.target_address,\n                        call.function_selector,\n                        call.args_hash,\n                        call.is_static,\n                    );\n                }\n            }\n        }\n        if self.is_fee_payer {\n            context.set_as_fee_payer();\n        }\n    }\n}\n"
+    },
+    "76": {
+      "path": "/usr/src/noir-projects/aztec-nr/authwit/src/entrypoint/app.nr",
+      "source": "use dep::aztec::prelude::PrivateContext;\nuse dep::aztec::protocol_types::{\n    constants::GENERATOR_INDEX__SIGNATURE_PAYLOAD,\n    hash::poseidon2_hash_with_separator,\n    traits::{Hash, Serialize},\n};\n\nuse crate::entrypoint::function_call::FunctionCall;\n\n// FUNCTION_CALL_SIZE * ACCOUNT_MAX_CALLS + 1\nglobal APP_PAYLOAD_SIZE: u32 = 21;\n// FUNCTION_CALL_SIZE_IN_BYTES * ACCOUNT_MAX_CALLS + 32\nglobal APP_PAYLOAD_SIZE_IN_BYTES: u32 = 424;\n\nglobal ACCOUNT_MAX_CALLS: u32 = 4;\n\n// Note: If you change the following struct you have to update default_entrypoint.ts\n// docs:start:app-payload-struct\npub struct AppPayload {\n    function_calls: [FunctionCall; ACCOUNT_MAX_CALLS],\n    nonce: Field,\n}\n// docs:end:app-payload-struct\n\nimpl Serialize<APP_PAYLOAD_SIZE> for AppPayload {\n    // Serializes the entrypoint struct\n    fn serialize(self) -> [Field; APP_PAYLOAD_SIZE] {\n        let mut fields: BoundedVec<Field, APP_PAYLOAD_SIZE> = BoundedVec::new();\n        for call in self.function_calls {\n            fields.extend_from_array(call.serialize());\n        }\n        fields.push(self.nonce);\n        fields.storage()\n    }\n}\n\nimpl Hash for AppPayload {\n    fn hash(self) -> Field {\n        poseidon2_hash_with_separator(self.serialize(), GENERATOR_INDEX__SIGNATURE_PAYLOAD)\n    }\n}\n\nimpl AppPayload {\n    // Serializes the payload as an array of bytes. Useful for hashing with sha256.\n    fn to_be_bytes(self) -> [u8; APP_PAYLOAD_SIZE_IN_BYTES] {\n        let mut bytes: BoundedVec<u8, APP_PAYLOAD_SIZE_IN_BYTES> = BoundedVec::new();\n\n        for i in 0..ACCOUNT_MAX_CALLS {\n            bytes.extend_from_array(self.function_calls[i].to_be_bytes());\n        }\n        bytes.extend_from_array(self.nonce.to_be_bytes::<32>());\n\n        bytes.storage()\n    }\n\n    // Executes all private and public calls\n    // docs:start:entrypoint-execute-calls\n    fn execute_calls(self, context: &mut PrivateContext) {\n        for call in self.function_calls {\n            if !call.target_address.is_zero() {\n                if call.is_public {\n                    context.call_public_function_with_packed_args(\n                        call.target_address,\n                        call.function_selector,\n                        call.args_hash,\n                        call.is_static,\n                    );\n                } else {\n                    let _result = context.call_private_function_with_packed_args(\n                        call.target_address,\n                        call.function_selector,\n                        call.args_hash,\n                        call.is_static,\n                    );\n                }\n            }\n        }\n    }\n    // docs:end:entrypoint-execute-calls\n}\n"
+    },
+    "79": {
       "path": "/usr/src/noir-projects/aztec-nr/authwit/src/account.nr",
       "source": "use dep::aztec::{\n    context::PrivateContext,\n    hash::poseidon2_hash_with_separator,\n    protocol_types::constants::{GENERATOR_INDEX__COMBINED_PAYLOAD, GENERATOR_INDEX__TX_NULLIFIER},\n};\n\nuse crate::auth::{compute_authwit_message_hash, IS_VALID_SELECTOR};\nuse crate::entrypoint::{app::AppPayload, fee::FeePayload};\n\npub struct AccountActions<Context> {\n    context: Context,\n    is_valid_impl: fn(&mut PrivateContext, Field) -> bool,\n}\n\nimpl<Context> AccountActions<Context> {\n    pub fn init(context: Context, is_valid_impl: fn(&mut PrivateContext, Field) -> bool) -> Self {\n        AccountActions { context, is_valid_impl }\n    }\n}\n\n/**\n * An implementation of the Account Action struct for the private context.\n *\n * Implements logic to verify authorization and execute payloads.\n */\nimpl AccountActions<&mut PrivateContext> {\n\n    /**\n     * Verifies that the `app_hash` and `fee_hash` are authorized and then executes them.\n     *\n     * Executes the `fee_payload` and `app_payload` in sequence.\n     * Will execute the `fee_payload` as part of the setup, and then enter the app phase.\n     *\n     * @param app_payload The payload that contains the calls to be executed in the app phase.\n     * @param fee_payload The payload that contains the calls to be executed in the setup phase.\n     */\n    // docs:start:entrypoint\n    pub fn entrypoint(self, app_payload: AppPayload, fee_payload: FeePayload, cancellable: bool) {\n        let valid_fn = self.is_valid_impl;\n\n        let combined_payload_hash = poseidon2_hash_with_separator(\n            [app_payload.hash(), fee_payload.hash()],\n            GENERATOR_INDEX__COMBINED_PAYLOAD,\n        );\n        assert(valid_fn(self.context, combined_payload_hash));\n\n        fee_payload.execute_calls(self.context);\n        self.context.end_setup();\n        app_payload.execute_calls(self.context);\n        if cancellable {\n            let tx_nullifier =\n                poseidon2_hash_with_separator([app_payload.nonce], GENERATOR_INDEX__TX_NULLIFIER);\n            self.context.push_nullifier(tx_nullifier);\n        }\n    }\n    // docs:end:entrypoint\n\n    /**\n     * Verifies that the `msg_sender` is authorized to consume `inner_hash` by the account.\n     *\n     * Computes the `message_hash` using the `msg_sender`, `chain_id`, `version` and `inner_hash`.\n     * Then executes the `is_valid_impl` function to verify that the message is authorized.\n     *\n     * Will revert if the message is not authorized.\n     *\n     * @param inner_hash The hash of the message that the `msg_sender` is trying to consume.\n     */\n    // docs:start:verify_private_authwit\n    pub fn verify_private_authwit(self, inner_hash: Field) -> Field {\n        // The `inner_hash` is \"siloed\" with the `msg_sender` to ensure that only it can\n        // consume the message.\n        // This ensures that contracts cannot consume messages that are not intended for them.\n        let message_hash = compute_authwit_message_hash(\n            self.context.msg_sender(),\n            self.context.chain_id(),\n            self.context.version(),\n            inner_hash,\n        );\n        let valid_fn = self.is_valid_impl;\n        assert(valid_fn(self.context, message_hash) == true, \"Message not authorized by account\");\n        IS_VALID_SELECTOR\n    }\n    // docs:end:verify_private_authwit\n}\n"
     },
-    "74": {
+    "80": {
       "path": "/usr/src/noir-projects/aztec-nr/authwit/src/auth_witness.nr",
       "source": "#[oracle(getAuthWitness)]\nunconstrained fn get_auth_witness_oracle<let N: u32>(_message_hash: Field) -> [Field; N] {}\n\n/**\n * Oracle wrapper to fetch an `auth_witness` for a given `message_hash` from the PXE.\n *\n * @param message_hash The hash of the message for which the `auth_witness` is to be fetched.\n * @return The `auth_witness` for the given `message_hash` as Field array.\n */\npub unconstrained fn get_auth_witness<let N: u32>(message_hash: Field) -> [Field; N] {\n    get_auth_witness_oracle(message_hash)\n}\n"
     },
-    "75": {
-      "path": "/usr/src/noir-projects/aztec-nr/authwit/src/entrypoint/app.nr",
-      "source": "use dep::aztec::prelude::PrivateContext;\nuse dep::aztec::protocol_types::{\n    constants::GENERATOR_INDEX__SIGNATURE_PAYLOAD,\n    hash::poseidon2_hash_with_separator,\n    traits::{Hash, Serialize},\n};\n\nuse crate::entrypoint::function_call::FunctionCall;\n\n// FUNCTION_CALL_SIZE * ACCOUNT_MAX_CALLS + 1\nglobal APP_PAYLOAD_SIZE: u32 = 21;\n// FUNCTION_CALL_SIZE_IN_BYTES * ACCOUNT_MAX_CALLS + 32\nglobal APP_PAYLOAD_SIZE_IN_BYTES: u32 = 424;\n\nglobal ACCOUNT_MAX_CALLS: u32 = 4;\n\n// Note: If you change the following struct you have to update default_entrypoint.ts\n// docs:start:app-payload-struct\npub struct AppPayload {\n    function_calls: [FunctionCall; ACCOUNT_MAX_CALLS],\n    nonce: Field,\n}\n// docs:end:app-payload-struct\n\nimpl Serialize<APP_PAYLOAD_SIZE> for AppPayload {\n    // Serializes the entrypoint struct\n    fn serialize(self) -> [Field; APP_PAYLOAD_SIZE] {\n        let mut fields: BoundedVec<Field, APP_PAYLOAD_SIZE> = BoundedVec::new();\n        for call in self.function_calls {\n            fields.extend_from_array(call.serialize());\n        }\n        fields.push(self.nonce);\n        fields.storage()\n    }\n}\n\nimpl Hash for AppPayload {\n    fn hash(self) -> Field {\n        poseidon2_hash_with_separator(self.serialize(), GENERATOR_INDEX__SIGNATURE_PAYLOAD)\n    }\n}\n\nimpl AppPayload {\n    // Serializes the payload as an array of bytes. Useful for hashing with sha256.\n    fn to_be_bytes(self) -> [u8; APP_PAYLOAD_SIZE_IN_BYTES] {\n        let mut bytes: BoundedVec<u8, APP_PAYLOAD_SIZE_IN_BYTES> = BoundedVec::new();\n\n        for i in 0..ACCOUNT_MAX_CALLS {\n            bytes.extend_from_array(self.function_calls[i].to_be_bytes());\n        }\n        bytes.extend_from_array(self.nonce.to_be_bytes::<32>());\n\n        bytes.storage()\n    }\n\n    // Executes all private and public calls\n    // docs:start:entrypoint-execute-calls\n    fn execute_calls(self, context: &mut PrivateContext) {\n        for call in self.function_calls {\n            if !call.target_address.is_zero() {\n                if call.is_public {\n                    context.call_public_function_with_packed_args(\n                        call.target_address,\n                        call.function_selector,\n                        call.args_hash,\n                        call.is_static,\n                    );\n                } else {\n                    let _result = context.call_private_function_with_packed_args(\n                        call.target_address,\n                        call.function_selector,\n                        call.args_hash,\n                        call.is_static,\n                    );\n                }\n            }\n        }\n    }\n    // docs:end:entrypoint-execute-calls\n}\n"
-    },
-    "77": {
-      "path": "/usr/src/noir-projects/aztec-nr/authwit/src/entrypoint/fee.nr",
-      "source": "use crate::entrypoint::function_call::FunctionCall;\nuse dep::aztec::prelude::PrivateContext;\nuse dep::aztec::protocol_types::{\n    constants::GENERATOR_INDEX__FEE_PAYLOAD,\n    hash::poseidon2_hash_with_separator,\n    traits::{Hash, Serialize},\n};\n\n// 2 * 5 (FUNCTION_CALL_SIZE) + 2\nglobal FEE_PAYLOAD_SIZE: u32 = 12;\n\n// 2 * 98 (FUNCTION_CALL_SIZE_IN_BYTES) + 32\nglobal FEE_PAYLOAD_SIZE_IN_BYTES: u32 = 228;\n\nglobal MAX_FEE_FUNCTION_CALLS: u32 = 2;\n\n// docs:start:fee-payload-struct\npub struct FeePayload {\n    function_calls: [FunctionCall; MAX_FEE_FUNCTION_CALLS],\n    nonce: Field,\n    is_fee_payer: bool,\n}\n// docs:end:fee-payload-struct\n\nimpl Serialize<FEE_PAYLOAD_SIZE> for FeePayload {\n    // Serializes the entrypoint struct\n    fn serialize(self) -> [Field; FEE_PAYLOAD_SIZE] {\n        let mut fields: BoundedVec<Field, FEE_PAYLOAD_SIZE> = BoundedVec::new();\n        for i in 0..MAX_FEE_FUNCTION_CALLS {\n            fields.extend_from_array(self.function_calls[i].serialize());\n        }\n        fields.push(self.nonce);\n        fields.push(self.is_fee_payer as Field);\n        fields.storage()\n    }\n}\n\nimpl Hash for FeePayload {\n    fn hash(self) -> Field {\n        poseidon2_hash_with_separator(self.serialize(), GENERATOR_INDEX__FEE_PAYLOAD)\n    }\n}\n\nimpl FeePayload {\n    fn to_be_bytes(self) -> [u8; FEE_PAYLOAD_SIZE_IN_BYTES] {\n        let mut bytes: BoundedVec<u8, FEE_PAYLOAD_SIZE_IN_BYTES> = BoundedVec::new();\n\n        for i in 0..MAX_FEE_FUNCTION_CALLS {\n            bytes.extend_from_array(self.function_calls[i].to_be_bytes());\n        }\n        bytes.extend_from_array(self.nonce.to_be_bytes::<32>());\n        bytes.push(self.is_fee_payer as u8);\n\n        bytes.storage()\n    }\n\n    fn execute_calls(self, context: &mut PrivateContext) {\n        for call in self.function_calls {\n            if !call.target_address.is_zero() {\n                if call.is_public {\n                    context.call_public_function_with_packed_args(\n                        call.target_address,\n                        call.function_selector,\n                        call.args_hash,\n                        call.is_static,\n                    );\n                } else {\n                    let _result = context.call_private_function_with_packed_args(\n                        call.target_address,\n                        call.function_selector,\n                        call.args_hash,\n                        call.is_static,\n                    );\n                }\n            }\n        }\n        if self.is_fee_payer {\n            context.set_as_fee_payer();\n        }\n    }\n}\n"
+    "81": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/notes.nr",
+      "source": "use crate::note::{note_header::NoteHeader, note_interface::NoteInterface};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n    utils::arr_copy_slice,\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            serialized_note,\n            note_hash,\n            counter,\n        )\n    };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_created_note_oracle(\n        storage_slot,\n        note_type_id,\n        serialized_note,\n        note_hash,\n        counter,\n    );\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _serialized_note: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(\n    _nullifier: Field,\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let S: u32>(\n    _storage_slot: Field,\n    _num_selects: u8,\n    _select_by_indexes: [u8; N],\n    _select_by_offsets: [u8; N],\n    _select_by_lengths: [u8; N],\n    _select_values: [Field; N],\n    _select_comparators: [u8; N],\n    _sort_by_indexes: [u8; N],\n    _sort_by_offsets: [u8; N],\n    _sort_by_lengths: [u8; N],\n    _sort_order: [u8; N],\n    _limit: u32,\n    _offset: u32,\n    _status: u8,\n    _return_size: u32,\n    _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let S: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; N],\n    select_by_offsets: [u8; N],\n    select_by_lengths: [u8; N],\n    select_values: [Field; N],\n    select_comparators: [u8; N],\n    sort_by_indexes: [u8; N],\n    sort_by_offsets: [u8; N],\n    sort_by_lengths: [u8; N],\n    sort_order: [u8; N],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_fields: [Field; S],\n) -> [Field; S] {\n    let return_size = placeholder_fields.len() as u32;\n    get_notes_oracle(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        return_size,\n        placeholder_fields,\n    )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let S: u32, let NS: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; M],\n    select_by_offsets: [u8; M],\n    select_by_lengths: [u8; M],\n    select_values: [Field; M],\n    select_comparators: [u8; M],\n    sort_by_indexes: [u8; M],\n    sort_by_offsets: [u8; M],\n    sort_by_lengths: [u8; M],\n    sort_order: [u8; M],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_opt_notes: [Option<Note>; S], // TODO: Remove it and use `limit` to initialize the note array.\n    placeholder_fields: [Field; NS], // TODO: Remove it and use `limit` to initialize the note array.\n    _placeholder_note_length: [Field; N], // Turbofish hack? Compiler breaks calculating read_offset unless we add this parameter\n) -> [Option<Note>; S]\nwhere\n    Note: NoteInterface<N>,\n{\n    sync_notes_oracle_wrapper();\n    let fields = get_notes_oracle_wrapper(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        placeholder_fields,\n    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n    for i in 0..placeholder_opt_notes.len() {\n        if i < num_notes {\n            // lengths named as per typescript.\n            let return_header_length: u32 = 2; // num_notes & contract_address.\n            let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n            let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n            let nonce = fields[read_offset];\n            let note_hash_counter = fields[read_offset + 1] as u32;\n            let header = NoteHeader { contract_address, nonce, storage_slot, note_hash_counter };\n            let serialized_note = arr_copy_slice(fields, [0; N], read_offset + 2);\n            let mut note = Note::deserialize_content(serialized_note);\n            note.set_header(header);\n            placeholder_opt_notes[i] = Option::some(note);\n        };\n    }\n    placeholder_opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier) == 1\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\n/// Same as `get_app_tagging_secret_as_sender`, except it returns the derived tag as an array of bytes, ready to be included in a\n/// log.\npub unconstrained fn get_app_tag_bytes_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> [u8; 32] {\n    let tag = get_app_tagging_secret_as_sender(sender, recipient).compute_tag(recipient);\n    tag.to_be_bytes()\n}\n\n/// Returns the tagging secret for a given sender and recipient pair, siloed for the current contract address.\n/// Includes the last known index used to send a note tagged with this secret.\n/// For this to work, PXE must know the ivpsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_app_tagging_secret_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n    let result = get_app_tagging_secret_as_sender_oracle(sender, recipient);\n    IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getAppTaggingSecretAsSender)]\nunconstrained fn get_app_tagging_secret_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) -> [Field; INDEXED_TAGGING_SECRET_LENGTH] {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n    }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) {\n    increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) {}\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them available\n/// for later querying via the `get_notes` oracle.\npub fn sync_notes() {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        sync_notes_oracle_wrapper();\n    }\n}\n\nunconstrained fn sync_notes_oracle_wrapper() {\n    sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n"
     },
-    "98": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/call_private_function.nr",
-      "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector, address::AztecAddress, utils::reader::Reader,\n};\n\n#[oracle(callPrivateFunction)]\nunconstrained fn call_private_function_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _start_side_effect_counter: u32,\n    _is_static_call: bool,\n) -> [Field; 2] {}\n\npub unconstrained fn call_private_function_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    start_side_effect_counter: u32,\n    is_static_call: bool,\n) -> (u32, Field) {\n    let fields = call_private_function_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        start_side_effect_counter,\n        is_static_call,\n    );\n\n    let mut reader = Reader::new(fields);\n    let end_side_effect_counter = reader.read_u32();\n    let returns_hash = reader.read();\n\n    (end_side_effect_counter, returns_hash)\n}\n"
+    "83": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/returns.nr",
+      "source": "/// Notifies the simulator that `returns` will be later fetched once the function return is processed, referenced by\n/// their hash. This allows the simulator to know how to respond to this future request.\n///\n/// This is only used during private execution, since in public it is the VM itself that keeps track of return values.\npub fn pack_returns(returns: [Field]) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call. When\n    // unpacking however the caller must check that the returned value is indeed the preimage.\n    unsafe { pack_returns_oracle_wrapper(returns) };\n}\n\npub unconstrained fn pack_returns_oracle_wrapper(returns: [Field]) {\n    let _ = pack_returns_oracle(returns);\n}\n\npub unconstrained fn unpack_returns<let N: u32>(return_hash: Field) -> [Field; N] {\n    unpack_returns_oracle(return_hash)\n}\n\n#[oracle(packReturns)]\nunconstrained fn pack_returns_oracle(_returns: [Field]) -> Field {}\n\n#[oracle(unpackReturns)]\nunconstrained fn unpack_returns_oracle<let N: u32>(_return_hash: Field) -> [Field; N] {}\n"
     },
-    "100": {
+    "86": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr",
       "source": "use dep::protocol_types::{abis::function_selector::FunctionSelector, address::AztecAddress};\n\n#[oracle(enqueuePublicFunctionCall)]\nunconstrained fn enqueue_public_function_call_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn enqueue_public_function_call_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) -> Field {\n    enqueue_public_function_call_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\n#[oracle(setPublicTeardownFunctionCall)]\nunconstrained fn set_public_teardown_function_call_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn set_public_teardown_function_call_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) -> Field {\n    set_public_teardown_function_call_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\npub fn notify_set_min_revertible_side_effect_counter(counter: u32) {\n    unsafe { notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter) };\n}\n\npub unconstrained fn notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter: u32) {\n    notify_set_min_revertible_side_effect_counter_oracle(counter);\n}\n\n#[oracle(notifySetMinRevertibleSideEffectCounter)]\nunconstrained fn notify_set_min_revertible_side_effect_counter_oracle(_counter: u32) {}\n"
     },
-    "108": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/returns.nr",
-      "source": "/// Notifies the simulator that `returns` will be later fetched once the function return is processed, referenced by\n/// their hash. This allows the simulator to know how to respond to this future request.\n///\n/// This is only used during private execution, since in public it is the VM itself that keeps track of return values.\npub fn pack_returns(returns: [Field]) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call. When\n    // unpacking however the caller must check that the returned value is indeed the preimage.\n    unsafe { pack_returns_oracle_wrapper(returns) };\n}\n\npub unconstrained fn pack_returns_oracle_wrapper(returns: [Field]) {\n    let _ = pack_returns_oracle(returns);\n}\n\npub unconstrained fn unpack_returns<let N: u32>(return_hash: Field) -> [Field; N] {\n    unpack_returns_oracle(return_hash)\n}\n\n#[oracle(packReturns)]\nunconstrained fn pack_returns_oracle(_returns: [Field]) -> Field {}\n\n#[oracle(unpackReturns)]\nunconstrained fn unpack_returns_oracle<let N: u32>(_return_hash: Field) -> [Field; N] {}\n"
-    },
-    "109": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/notes.nr",
-      "source": "use crate::note::{note_header::NoteHeader, note_interface::NoteInterface};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n    utils::arr_copy_slice,\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            serialized_note,\n            note_hash,\n            counter,\n        )\n    };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_created_note_oracle(\n        storage_slot,\n        note_type_id,\n        serialized_note,\n        note_hash,\n        counter,\n    );\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _serialized_note: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(\n    _nullifier: Field,\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let S: u32>(\n    _storage_slot: Field,\n    _num_selects: u8,\n    _select_by_indexes: [u8; N],\n    _select_by_offsets: [u8; N],\n    _select_by_lengths: [u8; N],\n    _select_values: [Field; N],\n    _select_comparators: [u8; N],\n    _sort_by_indexes: [u8; N],\n    _sort_by_offsets: [u8; N],\n    _sort_by_lengths: [u8; N],\n    _sort_order: [u8; N],\n    _limit: u32,\n    _offset: u32,\n    _status: u8,\n    _return_size: u32,\n    _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let S: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; N],\n    select_by_offsets: [u8; N],\n    select_by_lengths: [u8; N],\n    select_values: [Field; N],\n    select_comparators: [u8; N],\n    sort_by_indexes: [u8; N],\n    sort_by_offsets: [u8; N],\n    sort_by_lengths: [u8; N],\n    sort_order: [u8; N],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_fields: [Field; S],\n) -> [Field; S] {\n    let return_size = placeholder_fields.len() as u32;\n    get_notes_oracle(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        return_size,\n        placeholder_fields,\n    )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let S: u32, let NS: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; M],\n    select_by_offsets: [u8; M],\n    select_by_lengths: [u8; M],\n    select_values: [Field; M],\n    select_comparators: [u8; M],\n    sort_by_indexes: [u8; M],\n    sort_by_offsets: [u8; M],\n    sort_by_lengths: [u8; M],\n    sort_order: [u8; M],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_opt_notes: [Option<Note>; S], // TODO: Remove it and use `limit` to initialize the note array.\n    placeholder_fields: [Field; NS], // TODO: Remove it and use `limit` to initialize the note array.\n    _placeholder_note_length: [Field; N], // Turbofish hack? Compiler breaks calculating read_offset unless we add this parameter\n) -> [Option<Note>; S]\nwhere\n    Note: NoteInterface<N>,\n{\n    sync_notes_oracle_wrapper();\n    let fields = get_notes_oracle_wrapper(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        placeholder_fields,\n    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n    for i in 0..placeholder_opt_notes.len() {\n        if i < num_notes {\n            // lengths named as per typescript.\n            let return_header_length: u32 = 2; // num_notes & contract_address.\n            let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n            let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n            let nonce = fields[read_offset];\n            let note_hash_counter = fields[read_offset + 1] as u32;\n            let header = NoteHeader { contract_address, nonce, storage_slot, note_hash_counter };\n            let serialized_note = arr_copy_slice(fields, [0; N], read_offset + 2);\n            let mut note = Note::deserialize_content(serialized_note);\n            note.set_header(header);\n            placeholder_opt_notes[i] = Option::some(note);\n        };\n    }\n    placeholder_opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier) == 1\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\n/// Same as `get_app_tagging_secret_as_sender`, except it returns the derived tag as an array of bytes, ready to be included in a\n/// log.\npub unconstrained fn get_app_tag_bytes_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> [u8; 32] {\n    let tag = get_app_tagging_secret_as_sender(sender, recipient).compute_tag(recipient);\n    tag.to_be_bytes()\n}\n\n/// Returns the tagging secret for a given sender and recipient pair, siloed for the current contract address.\n/// Includes the last known index used to send a note tagged with this secret.\n/// For this to work, PXE must know the ivpsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_app_tagging_secret_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n    let result = get_app_tagging_secret_as_sender_oracle(sender, recipient);\n    IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getAppTaggingSecretAsSender)]\nunconstrained fn get_app_tagging_secret_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) -> [Field; INDEXED_TAGGING_SECRET_LENGTH] {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n    }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) {\n    increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) {}\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them available\n/// for later querying via the `get_notes` oracle.\npub fn sync_notes() {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        sync_notes_oracle_wrapper();\n    }\n}\n\nunconstrained fn sync_notes_oracle_wrapper() {\n    sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n"
+    "92": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/call_private_function.nr",
+      "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector, address::AztecAddress, utils::reader::Reader,\n};\n\n#[oracle(callPrivateFunction)]\nunconstrained fn call_private_function_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _start_side_effect_counter: u32,\n    _is_static_call: bool,\n) -> [Field; 2] {}\n\npub unconstrained fn call_private_function_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    start_side_effect_counter: u32,\n    is_static_call: bool,\n) -> (u32, Field) {\n    let fields = call_private_function_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        start_side_effect_counter,\n        is_static_call,\n    );\n\n    let mut reader = Reader::new(fields);\n    let end_side_effect_counter = reader.read_u32();\n    let returns_hash = reader.read();\n\n    (end_side_effect_counter, returns_hash)\n}\n"
     },
-    "119": {
+    "167": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/hash.nr",
       "source": "use crate::utils::to_bytes::{arr_to_be_bytes_arr, str_to_be_bytes_arr};\nuse dep::protocol_types::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n        GENERATOR_INDEX__SECRET_HASH,\n    },\n    hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice, sha256_to_field},\n    point::Point,\n    traits::Hash,\n};\n\npub use dep::protocol_types::hash::{compute_siloed_nullifier, pedersen_hash};\n\npub fn pedersen_commitment<let N: u32>(inputs: [Field; N], hash_index: u32) -> Point {\n    std::hash::pedersen_commitment_with_separator(inputs, hash_index)\n}\n\npub fn compute_secret_hash(secret: Field) -> Field {\n    poseidon2_hash_with_separator([secret], GENERATOR_INDEX__SECRET_HASH)\n}\n\npub fn compute_unencrypted_log_hash<let N: u32>(\n    contract_address: AztecAddress,\n    log: [u8; N],\n) -> Field {\n    let mut hash_bytes = [0; N + 36];\n    // Address is converted to 32 bytes in ts\n    let address_bytes: [u8; 32] = contract_address.to_field().to_be_bytes();\n    for i in 0..32 {\n        hash_bytes[i] = address_bytes[i];\n    }\n    let len_bytes: [u8; 4] = (N as Field).to_be_bytes();\n    for i in 0..4 {\n        hash_bytes[32 + i] = len_bytes[i];\n    }\n    for i in 0..N {\n        hash_bytes[36 + i] = log[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\npub fn compute_l1_to_l2_message_hash(\n    sender: EthAddress,\n    chain_id: Field,\n    recipient: AztecAddress,\n    version: Field,\n    content: Field,\n    secret_hash: Field,\n    leaf_index: Field,\n) -> Field {\n    let mut hash_bytes = [0 as u8; 224];\n    let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n    let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n    let version_bytes: [u8; 32] = version.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n    let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n    for i in 0..32 {\n        hash_bytes[i] = sender_bytes[i];\n        hash_bytes[i + 32] = chain_id_bytes[i];\n        hash_bytes[i + 64] = recipient_bytes[i];\n        hash_bytes[i + 96] = version_bytes[i];\n        hash_bytes[i + 128] = content_bytes[i];\n        hash_bytes[i + 160] = secret_hash_bytes[i];\n        hash_bytes[i + 192] = leaf_index_bytes[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n    poseidon2_hash_with_separator([message_hash, secret], GENERATOR_INDEX__MESSAGE_NULLIFIER)\n}\n\npub struct ArgsHasher {\n    pub fields: [Field],\n}\n\nimpl Hash for ArgsHasher {\n    fn hash(self) -> Field {\n        hash_args(self.fields)\n    }\n}\n\nimpl ArgsHasher {\n    pub fn new() -> Self {\n        Self { fields: [] }\n    }\n\n    pub fn add(&mut self, field: Field) {\n        self.fields = self.fields.push_back(field);\n    }\n\n    pub fn add_multiple<let N: u32>(&mut self, fields: [Field; N]) {\n        for i in 0..N {\n            self.fields = self.fields.push_back(fields[i]);\n        }\n    }\n}\n\npub fn hash_args_array<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\npub fn hash_args(args: [Field]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator_slice(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\n#[test]\nunconstrained fn compute_var_args_hash() {\n    let mut input = ArgsHasher::new();\n    for i in 0..100 {\n        input.add(i as Field);\n    }\n    let hash = input.hash();\n    dep::std::println(hash);\n    assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_array() {\n    let contract_address = AztecAddress::from_field(\n        0x233a3e0df23b2b15b324194cb4a151f26c0b7333250781d34cc269d85dc334c6,\n    );\n    let log = [\n        0x20660de09f35f876e3e69d227b2a35166ad05f09d82d06366ec9b6f65a51fec2,\n        0x1b52bfe3b8689761916f76dc3d38aa8810860db325cd39ca611eed980091f01c,\n        0x2e559c4045c378a56ad13b9edb1e8de4e7ad3b3aa35cc7ba9ec77f7a68fa43a4,\n        0x25d0f689c4a4178a29d59306f2675824d19be6d25e44fa03b03f49c263053dd2,\n        0x2d513a722d6f352dc0961f156afdc5e31495b9f0e35cb069261a8e55e2df67fd,\n    ];\n    let serialized_log = arr_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0095b2d17ab72f4b27a341f7ac63e49ec73935ae8c9181a0ac02023eb12f3284);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_addr() {\n    let contract_address = AztecAddress::from_field(\n        0x233a3e0df23b2b15b324194cb4a151f26c0b7333250781d34cc269d85dc334c6,\n    );\n    let log = AztecAddress::from_field(\n        0x26aa302d4715fd8a687453cb26d616b0768027bd54bcae56b09d908ecd9f8303,\n    );\n    let serialized_log: [u8; 32] = log.to_field().to_be_bytes();\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0083ab647dfb26e7ddee90a0f4209d049d4660cab42000c544b986aaa84c55a3);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_str() {\n    let contract_address = AztecAddress::from_field(\n        0x1b401e1146c5c507962287065c81f0ef7590adae3802c533d7549d6bf0a41bd8,\n    );\n    let log = \"dummy\";\n    let serialized_log = str_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x00629e88ebd6374f44aa6cfe07e251ecf07213ebc7267e8f6b578ae57ffd6c20);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_longer_str() {\n    let contract_address = AztecAddress::from_field(\n        0x1b401e1146c5c507962287065c81f0ef7590adae3802c533d7549d6bf0a41bd8,\n    );\n    let log = \"Hello this is a string\";\n    let serialized_log = str_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0098637962f7d34fa202b7ffad8a07a238c5d1fd897b82a108f7f467fa73b841);\n}\n"
     },
-    "130": {
+    "178": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/context/private_context.nr",
       "source": "use crate::{\n    context::{inputs::PrivateContextInputs, packed_returns::PackedReturns},\n    hash::{ArgsHasher, hash_args_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        arguments,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            enqueue_public_function_call_internal, notify_set_min_revertible_side_effect_counter,\n            set_public_teardown_function_call_internal,\n        },\n        header::get_header_at,\n        key_validation_request::get_key_validation_request,\n        logs::{emit_encrypted_event_log, emit_encrypted_note_log},\n        returns::pack_returns,\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        log_hash::{EncryptedLogHash, LogHash, NoteLogHash},\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENCRYPTED_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_ENCRYPTED_LOGS_PER_CALL, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,\n        MAX_NOTE_HASHES_PER_CALL, MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, PUBLIC_DISPATCH_SELECTOR,\n    },\n    header::Header,\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::Empty,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: Header,\n\n    pub note_encrypted_logs_hashes: BoundedVec<NoteLogHash, MAX_NOTE_ENCRYPTED_LOGS_PER_CALL>,\n    pub encrypted_logs_hashes: BoundedVec<EncryptedLogHash, MAX_ENCRYPTED_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<LogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            note_encrypted_logs_hashes: BoundedVec::new(),\n            encrypted_logs_hashes: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: self.next_counter(),\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_header(self) -> Header {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_header_at(self, block_number: u32) -> Header {\n        get_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        pack_returns(returns_hasher.fields);\n        self.return_hash = returns_hasher.hash();\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            note_encrypted_logs_hashes: self.note_encrypted_logs_hashes.storage(),\n            encrypted_logs_hashes: self.encrypted_logs_hashes.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request =\n            self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert(request.pk_m.hash() == pk_m_hash);\n\n            self.key_validation_requests_and_generators.push(\n                KeyValidationRequestAndGenerator {\n                    request,\n                    sk_app_generator: sk_generators[key_index],\n                },\n            );\n            self.last_key_validation_requests[key_index] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n        self.l2_to_l1_msgs.push(message);\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    // NB: A randomness value of 0 signals that the kernels should not mask the contract address\n    // used in siloing later on e.g. 'handshaking' contract w/ known address.\n    pub fn emit_raw_event_log_with_masked_address<let M: u32>(\n        &mut self,\n        randomness: Field,\n        log: [u8; M],\n        log_hash: Field,\n    ) {\n        let counter = self.next_counter();\n        let contract_address = self.this_address();\n        let len = log.len() as Field + 4;\n        let side_effect = EncryptedLogHash { value: log_hash, counter, length: len, randomness };\n        self.encrypted_logs_hashes.push(side_effect);\n\n        emit_encrypted_event_log(contract_address, randomness, log, counter);\n    }\n\n    pub fn emit_raw_note_log<let M: u32>(\n        &mut self,\n        note_hash_counter: u32,\n        log: [u8; M],\n        log_hash: Field,\n    ) {\n        let counter = self.next_counter();\n        let len = log.len() as Field + 4;\n        let side_effect = NoteLogHash { value: log_hash, counter, length: len, note_hash_counter };\n        self.note_encrypted_logs_hashes.push(side_effect);\n\n        emit_encrypted_note_log(note_hash_counter, log, counter);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> PackedReturns {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        // The oracle simulates the private call and returns the value of the side effects counter after execution of\n        // the call (which means that end_side_effect_counter - start_side_effect_counter is the number of side effects\n        // that took place), along with the hash of the return values. We validate these by requesting a private kernel\n        // iteration in which the return values are constrained to hash to `returns_hash` and the side effects counter\n        // to increment from start to end.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        // TODO (fees) figure out why this crashes the prover and enable it\n        // we need this in order to pay fees inside child call contexts\n        // assert(\n        //     (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n        //     | (item.public_inputs.min_revertible_side_effect_counter\n        //         > self.min_revertible_side_effect_counter)\n        // );\n        // if item.public_inputs.min_revertible_side_effect_counter\n        //     > self.min_revertible_side_effect_counter {\n        //     self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n        // }\n        self.side_effect_counter = end_side_effect_counter + 1;\n        PackedReturns::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_public_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = enqueue_public_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\n        );\n\n        // Public calls are rerouted through the dispatch function.\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.set_public_teardown_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn set_public_teardown_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = set_public_teardown_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\n        );\n\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: Header::empty(),\n            note_encrypted_logs_hashes: BoundedVec::new(),\n            encrypted_logs_hashes: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
     },
-    "205": {
-      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr",
-      "source": "pub struct Reader<let N: u32> {\n    data: [Field; N],\n    offset: u32,\n}\n\nimpl<let N: u32> Reader<N> {\n    pub fn new(data: [Field; N]) -> Self {\n        Self { data, offset: 0 }\n    }\n\n    pub fn read(&mut self) -> Field {\n        let result = self.data[self.offset];\n        self.offset += 1;\n        result\n    }\n\n    pub fn read_u32(&mut self) -> u32 {\n        self.read() as u32\n    }\n\n    pub fn read_bool(&mut self) -> bool {\n        self.read() as bool\n    }\n\n    pub fn read_array<let K: u32>(&mut self) -> [Field; K] {\n        let mut result = [0; K];\n        for i in 0..K {\n            result[i] = self.data[self.offset + i];\n        }\n        self.offset += K;\n        result\n    }\n\n    pub fn read_struct<T, let K: u32>(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n        let result = deserialise(self.read_array());\n        result\n    }\n\n    pub fn read_struct_array<T, let K: u32, let C: u32>(\n        &mut self,\n        deserialise: fn([Field; K]) -> T,\n        mut result: [T; C],\n    ) -> [T; C] {\n        for i in 0..C {\n            result[i] = self.read_struct(deserialise);\n        }\n        result\n    }\n\n    pub fn finish(self) {\n        assert(self.offset == self.data.len(), \"Reader did not read all data\");\n    }\n}\n"
-    },
-    "222": {
-      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/utils/mod.nr",
-      "source": "// general util packages/modules are usually bad practice\n// because there is no criteria for what we should not put in here.\n// Reducing the size of this package would be welcome.\n\npub mod arrays;\npub mod field;\npub mod reader;\npub mod uint256;\n\n// if predicate == true then return lhs, else return rhs\npub fn conditional_assign(predicate: bool, lhs: Field, rhs: Field) -> Field {\n    if predicate {\n        lhs\n    } else {\n        rhs\n    }\n}\n\npub fn arr_copy_slice<T, let N: u32, let M: u32>(\n    src: [T; N],\n    mut dst: [T; M],\n    offset: u32,\n) -> [T; M] {\n    let iterator_len = if N > M { M } else { N };\n    for i in 0..iterator_len {\n        dst[i] = src[i + offset];\n    }\n    dst\n}\n"
-    },
-    "225": {
+    "232": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr",
       "source": "/// Utility function to console.log data in the acir simulator.\n/// Example:\n///   debug_log(\"blah blah this is a debug string\");\npub fn debug_log<let N: u32>(msg: str<N>) {\n    debug_log_format(msg, []);\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` array.\n/// Examples:\n///   debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n///   debug_log_format(\"whole array: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { debug_log_oracle_wrapper(msg, args) };\n}\n\npub unconstrained fn debug_log_oracle_wrapper<let M: u32, let N: u32>(\n    msg: str<M>,\n    args: [Field; N],\n) {\n    debug_log_oracle(msg, args.as_slice());\n}\n\n// WARNING: sometimes when using debug logs the ACVM errors with: `thrown: \"solver opcode resolution error: cannot solve opcode: expression has too many unknowns x155\"`\n#[oracle(debugLog)]\nunconstrained fn debug_log_oracle<let M: u32>(_msg: str<M>, args: [Field]) {}\n"
     },
-    "286": {
+    "240": {
+      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
+      "source": "use crate::{\n    abis::function_selector::FunctionSelector,\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{\n        AZTEC_ADDRESS_LENGTH, FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        MAX_FIELD_VALUE,\n    },\n    contract_class_id::ContractClassId,\n    hash::{poseidon2_hash_with_separator, private_functions_root_from_siblings},\n    merkle_tree::membership::MembershipWitness,\n    public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, TpkM},\n    traits::{Deserialize, Empty, FromField, Serialize, ToField},\n    utils,\n};\n\n// We do below because `use crate::point::Point;` does not work\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\nuse crate::public_keys::AddressPoint;\nuse std::{\n    ec::{pow, sqrt},\n    embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\n};\n\n// Aztec address\npub struct AztecAddress {\n    pub inner: Field,\n}\n\nimpl Eq for AztecAddress {\n    fn eq(self, other: Self) -> bool {\n        self.to_field() == other.to_field()\n    }\n}\n\nimpl Empty for AztecAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl ToField for AztecAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl FromField for AztecAddress {\n    fn from_field(value: Field) -> AztecAddress {\n        AztecAddress { inner: value }\n    }\n}\n\nimpl Serialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn serialize(self: Self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n        [self.to_field()]\n    }\n}\n\nimpl Deserialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn deserialize(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n        FromField::from_field(fields[0])\n    }\n}\n\nimpl AztecAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    pub fn to_address_point(self) -> AddressPoint {\n        // We compute the address point by taking our address, setting it to x, and then solving for y in the\n        // equation which defines our bn curve:\n        // y^2 = x^3 - 17; x = address\n        let x = self.inner;\n        let y_squared = pow(x, 3) - 17;\n\n        // TODO (#8970): Handle cases where we cannot recover a point from an address\n        let mut y = sqrt(y_squared);\n\n        // If we get a negative y coordinate (any y where y > MAX_FIELD_VALUE / 2), we pin it to the\n        // positive one (any value where y <= MAX_FIELD_VALUE / 2) by subtracting it from the Field modulus\n        // note: The field modulus is MAX_FIELD_VALUE + 1\n        if (!(y.lt(MAX_FIELD_VALUE / 2) | y.eq(MAX_FIELD_VALUE / 2))) {\n            y = (MAX_FIELD_VALUE + 1) - y;\n        }\n\n        AddressPoint { inner: Point { x: self.inner, y, is_infinite: false } }\n    }\n\n    pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n        let public_keys_hash = public_keys.hash();\n\n        let pre_address = poseidon2_hash_with_separator(\n            [public_keys_hash.to_field(), partial_address.to_field()],\n            GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        );\n\n        let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n            public_keys.ivpk_m.to_point(),\n        );\n\n        // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n        // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n        // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n        // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n        // our secrect can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n        // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n        // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n        AztecAddress::from_field(address_point.x)\n    }\n\n    pub fn compute_from_private_function(\n        function_selector: FunctionSelector,\n        function_vk_hash: Field,\n        function_leaf_membership_witness: MembershipWitness<FUNCTION_TREE_HEIGHT>,\n        contract_class_artifact_hash: Field,\n        contract_class_public_bytecode_commitment: Field,\n        salted_initialization_hash: SaltedInitializationHash,\n        public_keys: PublicKeys,\n    ) -> Self {\n        let private_functions_root = private_functions_root_from_siblings(\n            function_selector,\n            function_vk_hash,\n            function_leaf_membership_witness.leaf_index,\n            function_leaf_membership_witness.sibling_path,\n        );\n\n        let contract_class_id = ContractClassId::compute(\n            contract_class_artifact_hash,\n            private_functions_root,\n            contract_class_public_bytecode_commitment,\n        );\n\n        // Compute contract address using the preimage which includes the class_id.\n        let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            salted_initialization_hash,\n        );\n\n        AztecAddress::compute(public_keys, partial_address)\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n\n    pub fn conditional_assign(predicate: bool, lhs: Self, rhs: Self) -> Self {\n        let result = utils::conditional_assign(predicate, rhs.to_field(), lhs.to_field());\n        Self { inner: result }\n    }\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n    let public_keys = PublicKeys {\n        npk_m: NpkM {\n            inner: Point {\n                x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n                y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n                is_infinite: false,\n            },\n        },\n        ivpk_m: IvpkM {\n            inner: Point {\n                x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n                y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n                is_infinite: false,\n            },\n        },\n        ovpk_m: OvpkM {\n            inner: Point {\n                x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n                y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n                is_infinite: false,\n            },\n        },\n        tpk_m: TpkM {\n            inner: Point {\n                x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n                y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n                is_infinite: false,\n            },\n        },\n    };\n\n    let partial_address = PartialAddress::from_field(\n        0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n    );\n\n    let address = AztecAddress::compute(public_keys, partial_address);\n\n    // The following value was generated by `derivation.test.ts`.\n    // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n    let expected_computed_address_from_partial_and_pubkeys =\n        0x24e4646f58b9fbe7d38e317db8d5636c423fbbdfbe119fc190fe9c64747e0c62;\n    assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn from_field_to_field() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(Deserialize::deserialize(address.serialize()), address);\n}\n"
+    },
+    "301": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/public_keys.nr",
       "source": "use crate::{\n    address::public_keys_hash::PublicKeysHash,\n    constants::{\n        DEFAULT_IVPK_M_X, DEFAULT_IVPK_M_Y, DEFAULT_NPK_M_X, DEFAULT_NPK_M_Y, DEFAULT_OVPK_M_X,\n        DEFAULT_OVPK_M_Y, DEFAULT_TPK_M_X, DEFAULT_TPK_M_Y, GENERATOR_INDEX__PUBLIC_KEYS_HASH,\n    },\n    hash::poseidon2_hash_with_separator,\n    point::POINT_LENGTH,\n    traits::{Deserialize, Hash, Serialize},\n};\n\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\nuse std::default::Default;\n\npub global PUBLIC_KEYS_LENGTH: u32 = 12;\n\npub struct PublicKeys {\n    pub npk_m: NpkM,\n    pub ivpk_m: IvpkM,\n    pub ovpk_m: OvpkM,\n    pub tpk_m: TpkM,\n}\n\npub trait ToPoint {\n    fn to_point(self) -> Point;\n}\n\npub struct NpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for NpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for NpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\n// Note: If we store npk_m_hash directly we can remove this trait implementation. See #8091\nimpl Hash for NpkM {\n    fn hash(self) -> Field {\n        self.inner.hash()\n    }\n}\n\npub struct IvpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for IvpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for IvpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\npub struct OvpkM {\n    pub inner: Point,\n}\n\nimpl Hash for OvpkM {\n    fn hash(self) -> Field {\n        self.inner.hash()\n    }\n}\n\nimpl ToPoint for OvpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for OvpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\npub struct TpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for TpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for TpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\nimpl Default for PublicKeys {\n    fn default() -> Self {\n        PublicKeys {\n            npk_m: NpkM {\n                inner: Point { x: DEFAULT_NPK_M_X, y: DEFAULT_NPK_M_Y, is_infinite: false },\n            },\n            ivpk_m: IvpkM {\n                inner: Point { x: DEFAULT_IVPK_M_X, y: DEFAULT_IVPK_M_Y, is_infinite: false },\n            },\n            ovpk_m: OvpkM {\n                inner: Point { x: DEFAULT_OVPK_M_X, y: DEFAULT_OVPK_M_Y, is_infinite: false },\n            },\n            tpk_m: TpkM {\n                inner: Point { x: DEFAULT_TPK_M_X, y: DEFAULT_TPK_M_Y, is_infinite: false },\n            },\n        }\n    }\n}\n\nimpl Eq for PublicKeys {\n    fn eq(self, other: PublicKeys) -> bool {\n        (self.npk_m.inner == other.npk_m.inner)\n            & (self.ivpk_m.inner == other.ivpk_m.inner)\n            & (self.ovpk_m.inner == other.ovpk_m.inner)\n            & (self.tpk_m.inner == other.tpk_m.inner)\n    }\n}\n\nimpl PublicKeys {\n    pub fn hash(self) -> PublicKeysHash {\n        PublicKeysHash::from_field(poseidon2_hash_with_separator(\n            self.serialize(),\n            GENERATOR_INDEX__PUBLIC_KEYS_HASH as Field,\n        ))\n    }\n}\n\nimpl Serialize<PUBLIC_KEYS_LENGTH> for PublicKeys {\n    fn serialize(self) -> [Field; PUBLIC_KEYS_LENGTH] {\n        [\n            self.npk_m.inner.x,\n            self.npk_m.inner.y,\n            self.npk_m.inner.is_infinite as Field,\n            self.ivpk_m.inner.x,\n            self.ivpk_m.inner.y,\n            self.ivpk_m.inner.is_infinite as Field,\n            self.ovpk_m.inner.x,\n            self.ovpk_m.inner.y,\n            self.ovpk_m.inner.is_infinite as Field,\n            self.tpk_m.inner.x,\n            self.tpk_m.inner.y,\n            self.tpk_m.inner.is_infinite as Field,\n        ]\n    }\n}\n\nimpl Deserialize<PUBLIC_KEYS_LENGTH> for PublicKeys {\n    fn deserialize(serialized: [Field; PUBLIC_KEYS_LENGTH]) -> PublicKeys {\n        PublicKeys {\n            npk_m: NpkM {\n                inner: Point {\n                    x: serialized[0],\n                    y: serialized[1],\n                    is_infinite: serialized[2] as bool,\n                },\n            },\n            ivpk_m: IvpkM {\n                inner: Point {\n                    x: serialized[3],\n                    y: serialized[4],\n                    is_infinite: serialized[5] as bool,\n                },\n            },\n            ovpk_m: OvpkM {\n                inner: Point {\n                    x: serialized[6],\n                    y: serialized[7],\n                    is_infinite: serialized[8] as bool,\n                },\n            },\n            tpk_m: TpkM {\n                inner: Point {\n                    x: serialized[9],\n                    y: serialized[10],\n                    is_infinite: serialized[11] as bool,\n                },\n            },\n        }\n    }\n}\n\npub struct AddressPoint {\n    pub inner: Point,\n}\n\nimpl ToPoint for AddressPoint {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\n#[test]\nunconstrained fn compute_public_keys_hash() {\n    let keys = PublicKeys {\n        npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n        ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n        ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n        tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n    };\n\n    let actual = keys.hash();\n    let expected_public_keys_hash =\n        0x0fecd9a32db731fec1fded1b9ff957a1625c069245a3613a2538bd527068b0ad;\n\n    assert(actual.to_field() == expected_public_keys_hash);\n}\n\n#[test]\nunconstrained fn compute_default_hash() {\n    let keys = PublicKeys::default();\n\n    let actual = keys.hash();\n    let test_data_default_hash = 0x1d3bf1fb93ae0e9cda83b203dd91c3bfb492a9aecf30ec90e1057eced0f0e62d;\n\n    assert(actual.to_field() == test_data_default_hash);\n}\n\n#[test]\nunconstrained fn test_public_keys_serialization() {\n    let keys = PublicKeys {\n        npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n        ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n        ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n        tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n    };\n\n    let serialized = keys.serialize();\n    let deserialized = PublicKeys::deserialize(serialized);\n\n    assert_eq(keys.npk_m.inner.x, deserialized.npk_m.inner.x);\n    assert_eq(keys.npk_m.inner.y, deserialized.npk_m.inner.y);\n    assert_eq(keys.ivpk_m.inner.x, deserialized.ivpk_m.inner.x);\n    assert_eq(keys.ivpk_m.inner.y, deserialized.ivpk_m.inner.y);\n    assert_eq(keys.ovpk_m.inner.x, deserialized.ovpk_m.inner.x);\n    assert_eq(keys.ovpk_m.inner.y, deserialized.ovpk_m.inner.y);\n    assert_eq(keys.tpk_m.inner.x, deserialized.tpk_m.inner.x);\n    assert_eq(keys.tpk_m.inner.y, deserialized.tpk_m.inner.y);\n}\n"
     },
-    "291": {
+    "302": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
       "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector,\n        log_hash::{LogHash, ScopedEncryptedLogHash, ScopedLogHash},\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    traits::{is_empty, ToField},\n    utils::field::field_from_bytes_32_trunc,\n};\nuse super::utils::field::field_from_bytes;\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = std::hash::sha256(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\nfn compute_note_hash_nonce(tx_hash: Field, note_index_in_tx: u32) -> Field {\n    // Hashing tx hash with note index in tx is guaranteed to be unique\n    poseidon2_hash_with_separator(\n        [tx_hash, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(nonce: Field, note_hash: Field) -> Field {\n    let inputs = [nonce, note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, unique_note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), unique_note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash, tx_hash: Field, note_index_in_tx: u32) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(tx_hash, note_index_in_tx);\n        let unique_note_hash = compute_unique_note_hash(nonce, note_hash.value());\n        compute_siloed_note_hash(note_hash.contract_address, unique_note_hash)\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn silo_encrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n    // We assume contract address has already been masked\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        accumulate_sha256(\n            [log_hash.contract_address.to_field(), log_hash.log_hash.value],\n        )\n    }\n}\n\npub fn mask_encrypted_log_hash(scoped_log: ScopedEncryptedLogHash) -> AztecAddress {\n    if scoped_log.contract_address.is_zero() {\n        AztecAddress::from_field(0)\n    } else if (scoped_log.log_hash.randomness == 0) {\n        scoped_log.contract_address\n    } else {\n        AztecAddress::from_field(poseidon2_hash_with_separator(\n            [scoped_log.contract_address.to_field(), scoped_log.log_hash.randomness],\n            0,\n        ))\n    }\n}\n\nfn compute_siloed_unencrypted_log_hash(address: AztecAddress, log_hash: Field) -> Field {\n    accumulate_sha256([address.to_field(), log_hash])\n}\n\npub fn silo_unencrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_unencrypted_log_hash(log_hash.contract_address, log_hash.value())\n    }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: BoundedVec<u8, 160> = BoundedVec::new();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..inputs.len() {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes.push(item_bytes[j]);\n        }\n    }\n\n    sha256_to_field(bytes.storage())\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a U128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\n// Computes the final logs hash for a tx.\npub fn compute_tx_logs_hash<let N: u32>(logs: [LogHash; N]) -> Field {\n    // Convert each field element into a byte array and append the bytes to `hash_input_flattened`\n    let mut hash_input_flattened = [0; N * 32];\n    for offset in 0..N {\n        // TODO: This is not checking that the decomposition is smaller than P\n        let input_as_bytes: [u8; 32] = logs[offset].value.to_be_radix(256);\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n    // Ideally we would push to a slice then hash, but there is no sha_slice\n    // Hardcode to 256 bytes for now\n    let mut hash = sha256_to_field(hash_input_flattened);\n    // Not having a 0 value hash for empty logs causes issues with empty txs\n    // used for padding. Returning early is currently unsupported.\n    // We always provide sorted logs here, so 0 being empty means all are empty.\n    if is_empty(logs[0]) {\n        hash = 0;\n    }\n    hash\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    // We manually hash the inputs here, since we cannot express with the type system a constant size inputs array of N + 1\n    let in_len = N + 1;\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    // We manually hash the inputs here, since we cannot express with the type system a constant size inputs array of Math.ceil(N/31)\n    let mut in_len = N / 31;\n    let mut has_padding = false;\n    if N % 31 != 0 {\n        in_len += 1;\n        has_padding = true;\n    }\n\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            sponge.absorb(field_from_bytes(current_field, false));\n            current_field = [0; 31];\n        }\n    }\n    if has_padding {\n        sponge.absorb(field_from_bytes(current_field, false));\n    }\n\n    sponge.squeeze()\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = std::hash::sha256(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
     },
-    "310": {
-      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
-      "source": "use crate::{\n    abis::function_selector::FunctionSelector,\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{\n        AZTEC_ADDRESS_LENGTH, FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        MAX_FIELD_VALUE,\n    },\n    contract_class_id::ContractClassId,\n    hash::{poseidon2_hash_with_separator, private_functions_root_from_siblings},\n    merkle_tree::membership::MembershipWitness,\n    public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, TpkM},\n    traits::{Deserialize, Empty, FromField, Serialize, ToField},\n    utils,\n};\n\n// We do below because `use crate::point::Point;` does not work\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\nuse crate::public_keys::AddressPoint;\nuse std::{\n    ec::{pow, sqrt},\n    embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\n};\n\n// Aztec address\npub struct AztecAddress {\n    pub inner: Field,\n}\n\nimpl Eq for AztecAddress {\n    fn eq(self, other: Self) -> bool {\n        self.to_field() == other.to_field()\n    }\n}\n\nimpl Empty for AztecAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl ToField for AztecAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl FromField for AztecAddress {\n    fn from_field(value: Field) -> AztecAddress {\n        AztecAddress { inner: value }\n    }\n}\n\nimpl Serialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn serialize(self: Self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n        [self.to_field()]\n    }\n}\n\nimpl Deserialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn deserialize(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n        FromField::from_field(fields[0])\n    }\n}\n\nimpl AztecAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    pub fn to_address_point(self) -> AddressPoint {\n        // We compute the address point by taking our address, setting it to x, and then solving for y in the\n        // equation which defines our bn curve:\n        // y^2 = x^3 - 17; x = address\n        let x = self.inner;\n        let y_squared = pow(x, 3) - 17;\n\n        // TODO (#8970): Handle cases where we cannot recover a point from an address\n        let mut y = sqrt(y_squared);\n\n        // If we get a negative y coordinate (any y where y > MAX_FIELD_VALUE / 2), we pin it to the\n        // positive one (any value where y <= MAX_FIELD_VALUE / 2) by subtracting it from the Field modulus\n        // note: The field modulus is MAX_FIELD_VALUE + 1\n        if (!(y.lt(MAX_FIELD_VALUE / 2) | y.eq(MAX_FIELD_VALUE / 2))) {\n            y = (MAX_FIELD_VALUE + 1) - y;\n        }\n\n        AddressPoint { inner: Point { x: self.inner, y, is_infinite: false } }\n    }\n\n    pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n        let public_keys_hash = public_keys.hash();\n\n        let pre_address = poseidon2_hash_with_separator(\n            [public_keys_hash.to_field(), partial_address.to_field()],\n            GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        );\n\n        let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n            public_keys.ivpk_m.to_point(),\n        );\n\n        // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n        // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n        // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n        // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n        // our secrect can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n        // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n        // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n        AztecAddress::from_field(address_point.x)\n    }\n\n    pub fn compute_from_private_function(\n        function_selector: FunctionSelector,\n        function_vk_hash: Field,\n        function_leaf_membership_witness: MembershipWitness<FUNCTION_TREE_HEIGHT>,\n        contract_class_artifact_hash: Field,\n        contract_class_public_bytecode_commitment: Field,\n        salted_initialization_hash: SaltedInitializationHash,\n        public_keys: PublicKeys,\n    ) -> Self {\n        let private_functions_root = private_functions_root_from_siblings(\n            function_selector,\n            function_vk_hash,\n            function_leaf_membership_witness.leaf_index,\n            function_leaf_membership_witness.sibling_path,\n        );\n\n        let contract_class_id = ContractClassId::compute(\n            contract_class_artifact_hash,\n            private_functions_root,\n            contract_class_public_bytecode_commitment,\n        );\n\n        // Compute contract address using the preimage which includes the class_id.\n        let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            salted_initialization_hash,\n        );\n\n        AztecAddress::compute(public_keys, partial_address)\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n\n    pub fn conditional_assign(predicate: bool, lhs: Self, rhs: Self) -> Self {\n        let result = utils::conditional_assign(predicate, rhs.to_field(), lhs.to_field());\n        Self { inner: result }\n    }\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n    let public_keys = PublicKeys {\n        npk_m: NpkM {\n            inner: Point {\n                x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n                y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n                is_infinite: false,\n            },\n        },\n        ivpk_m: IvpkM {\n            inner: Point {\n                x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n                y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n                is_infinite: false,\n            },\n        },\n        ovpk_m: OvpkM {\n            inner: Point {\n                x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n                y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n                is_infinite: false,\n            },\n        },\n        tpk_m: TpkM {\n            inner: Point {\n                x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n                y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n                is_infinite: false,\n            },\n        },\n    };\n\n    let partial_address = PartialAddress::from_field(\n        0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n    );\n\n    let address = AztecAddress::compute(public_keys, partial_address);\n\n    // The following value was generated by `derivation.test.ts`.\n    // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n    let expected_computed_address_from_partial_and_pubkeys =\n        0x24e4646f58b9fbe7d38e317db8d5636c423fbbdfbe119fc190fe9c64747e0c62;\n    assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn from_field_to_field() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(Deserialize::deserialize(address.serialize()), address);\n}\n"
+    "322": {
+      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr",
+      "source": "pub struct Reader<let N: u32> {\n    data: [Field; N],\n    offset: u32,\n}\n\nimpl<let N: u32> Reader<N> {\n    pub fn new(data: [Field; N]) -> Self {\n        Self { data, offset: 0 }\n    }\n\n    pub fn read(&mut self) -> Field {\n        let result = self.data[self.offset];\n        self.offset += 1;\n        result\n    }\n\n    pub fn read_u32(&mut self) -> u32 {\n        self.read() as u32\n    }\n\n    pub fn read_bool(&mut self) -> bool {\n        self.read() as bool\n    }\n\n    pub fn read_array<let K: u32>(&mut self) -> [Field; K] {\n        let mut result = [0; K];\n        for i in 0..K {\n            result[i] = self.data[self.offset + i];\n        }\n        self.offset += K;\n        result\n    }\n\n    pub fn read_struct<T, let K: u32>(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n        let result = deserialise(self.read_array());\n        result\n    }\n\n    pub fn read_struct_array<T, let K: u32, let C: u32>(\n        &mut self,\n        deserialise: fn([Field; K]) -> T,\n        mut result: [T; C],\n    ) -> [T; C] {\n        for i in 0..C {\n            result[i] = self.read_struct(deserialise);\n        }\n        result\n    }\n\n    pub fn finish(self) {\n        assert(self.offset == self.data.len(), \"Reader did not read all data\");\n    }\n}\n"
     },
-    "425": {
-      "path": "/usr/src/noir-projects/noir-contracts/contracts/schnorr_single_key_account_contract/src/util.nr",
-      "source": "use crate::auth_oracle::AuthWitness;\nuse dep::aztec::prelude::AztecAddress;\nuse std::schnorr::verify_signature;\n\npub fn recover_address(message_hash: Field, witness: AuthWitness) -> AztecAddress {\n    let message_bytes: [u8; 32] = message_hash.to_be_bytes();\n    // In a single key account contract we re-used ivpk_m as signing key\n    let verification = verify_signature(\n        witness.keys.ivpk_m.inner.x,\n        witness.keys.ivpk_m.inner.y,\n        witness.signature,\n        message_bytes,\n    );\n    assert(verification == true);\n\n    AztecAddress::compute(witness.keys, witness.partial_address)\n}\n"
+    "324": {
+      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/utils/mod.nr",
+      "source": "// general util packages/modules are usually bad practice\n// because there is no criteria for what we should not put in here.\n// Reducing the size of this package would be welcome.\n\npub mod arrays;\npub mod field;\npub mod reader;\npub mod uint256;\n\n// if predicate == true then return lhs, else return rhs\npub fn conditional_assign(predicate: bool, lhs: Field, rhs: Field) -> Field {\n    if predicate {\n        lhs\n    } else {\n        rhs\n    }\n}\n\npub fn arr_copy_slice<T, let N: u32, let M: u32>(\n    src: [T; N],\n    mut dst: [T; M],\n    offset: u32,\n) -> [T; M] {\n    let iterator_len = if N > M { M } else { N };\n    for i in 0..iterator_len {\n        dst[i] = src[i + offset];\n    }\n    dst\n}\n"
     },
-    "426": {
+    "425": {
       "path": "/usr/src/noir-projects/noir-contracts/contracts/schnorr_single_key_account_contract/src/auth_oracle.nr",
       "source": "use dep::authwit::auth_witness;\nuse dep::aztec::protocol_types::{\n    address::PartialAddress,\n    public_keys::{PUBLIC_KEYS_LENGTH, PublicKeys},\n    utils::arr_copy_slice,\n};\n\npub struct AuthWitness {\n    keys: PublicKeys,\n    signature: [u8; 64],\n    partial_address: PartialAddress,\n}\n\nimpl AuthWitness {\n    fn deserialize(values: [Field; 77]) -> Self {\n        let mut signature = [0; 64];\n        for i in 0..64 {\n            signature[i] = values[i + PUBLIC_KEYS_LENGTH] as u8;\n        }\n        Self {\n            keys: PublicKeys::deserialize(arr_copy_slice(values, [0; PUBLIC_KEYS_LENGTH], 0)),\n            signature,\n            partial_address: PartialAddress::from_field(values[76]),\n        }\n    }\n}\n\npub unconstrained fn get_auth_witness(message_hash: Field) -> AuthWitness {\n    let witness: [Field; 77] = auth_witness::get_auth_witness(message_hash);\n    AuthWitness::deserialize(witness)\n}\n"
     },
-    "427": {
+    "426": {
       "path": "/usr/src/noir-projects/noir-contracts/contracts/schnorr_single_key_account_contract/src/main.nr",
       "source": "mod util;\nmod auth_oracle;\n\nuse dep::aztec::macros::aztec;\n\n#[aztec]\ncontract SchnorrSingleKeyAccount {\n    use dep::aztec::prelude::PrivateContext;\n\n    use dep::authwit::{account::AccountActions, entrypoint::{app::AppPayload, fee::FeePayload}};\n\n    use crate::{auth_oracle::get_auth_witness, util::recover_address};\n\n    use dep::aztec::macros::functions::{private, view};\n\n    // Note: If you globally change the entrypoint signature don't forget to update account_entrypoint.ts\n    #[private]\n    fn entrypoint(app_payload: AppPayload, fee_payload: FeePayload, cancellable: bool) {\n        let actions = AccountActions::init(&mut context, is_valid_impl);\n        actions.entrypoint(app_payload, fee_payload, cancellable);\n    }\n\n    #[private]\n    #[view]\n    fn verify_private_authwit(inner_hash: Field) -> Field {\n        let actions = AccountActions::init(&mut context, is_valid_impl);\n        actions.verify_private_authwit(inner_hash)\n    }\n\n    #[contract_library_method]\n    fn is_valid_impl(context: &mut PrivateContext, outer_hash: Field) -> bool {\n        let witness = unsafe { get_auth_witness(outer_hash) };\n        recover_address(outer_hash, witness).eq(context.this_address())\n    }\n}\n"
+    },
+    "427": {
+      "path": "/usr/src/noir-projects/noir-contracts/contracts/schnorr_single_key_account_contract/src/util.nr",
+      "source": "use crate::auth_oracle::AuthWitness;\nuse dep::aztec::prelude::AztecAddress;\nuse std::schnorr::verify_signature;\n\npub fn recover_address(message_hash: Field, witness: AuthWitness) -> AztecAddress {\n    let message_bytes: [u8; 32] = message_hash.to_be_bytes();\n    // In a single key account contract we re-used ivpk_m as signing key\n    let verification = verify_signature(\n        witness.keys.ivpk_m.inner.x,\n        witness.keys.ivpk_m.inner.y,\n        witness.signature,\n        message_bytes,\n    );\n    assert(verification == true);\n\n    AztecAddress::compute(witness.keys, witness.partial_address)\n}\n"
     }
   }
 }