@aztec/accounts 0.67.0 → 0.67.1-devnet

package/artifacts/SchnorrSingleKeyAccount.json

@@ -1,6 +1,6 @@
 {
   "transpiled": true,
-  "noir_version": "1.0.0-beta.0+b3f4ad661c8c6f88544d714fd5b7b6f58a8ce4ad-x8664",
+  "noir_version": "1.0.0-beta.0+4184522b3ac6c4ce82aadf4911289cdf9fb0dd79-x8664",
   "name": "SchnorrSingleKeyAccount",
   "functions": [
     {
@@ -88,17 +88,36 @@
         }
       },
       "bytecode": "H4sIAAAAAAAA/9VZ227aQBBdsI2xiQmFP4jUt1ayCdc3pF7yHSiBL+gH+KEv7VeXFTv2YTypkJipykjRGs/6zNkz4931pufONjz99cJ1HNqB6xr12YW2vM0qRazSkmfvTnj274RndCc8Y0WePYGnb+l9S9z5nUvd+X3sOPFhn+gI/O5vQCzo79Bmoe2DXzExVSYMVgt/Uy5eM3dpyvyfs4CZ2uAvCX9og18S7y91i49jobhRaF/qVssXeMZbEa6xiAmXfH3wfWW+CHzfmA9r+DvzYd0TJ9JtAGNRrKuNdV5obCmMrfdO61yrHd4jrXNnWqMV5TxjfDh/4lNQn7rlM2C+GHwZ8yXgI/19+wT9eO5T6PcZ7vOajFy3hslPOUetLWoqNsA/2ULSneckri9jow91j0HPJ6aPxVqB+ljo7/WZvcOfrr2ltWssYnqiRqTZEPszXwa+uL6Mk4ffMcRBLOKRsP6fwu/H0A7gGXp+IsQfsPgXvIV7qBHHioR71N+/kx/D9cid6+cn9XfdeUpvU71aSHO2Hv66wc9s+B8JP7fBXxH+yAa/2cs8mODPS8IvbPhvCX9sUz/NXvLRhv+B8Ccm+IsDrbsfXGvN/BCup3Bfb+6uqmv2RBg/Z1yt9kRTxofrg+uv980ErhPBx3M4E+LMhDgSVqaI9aCI9fifjnGoiDVSxBorYmnmMVXE0tQrV8QqFLE0615TL8qjtE/ztgtteaNJ+zRF/Erap2l+u5PWVF+xoCGOL2H9fzCdRyY8qzmtOfSuUwyMXRjFvna9pviFwId454LvlkPZw3Jz3G6W29OWrFrNt00+C8aV38NvIpyPsb+09kv7PkWtS+m7fwy6eovBVzBfAj7iKH33j434X6M/xp8IPr7+X5vLqeuuhyM2bjzj2qmMuT3/k87mjeev5bXvJsXPXXe+/lfni6gP30vnAteJ4OP7k1yIkwtx7hGLn9Gjhr6uSae4bv1auVxv2n9w0VyUuMtzf8fiJ6z/r/Abx0btLXP+cb2vjs/74365f3tbvO6nDN9bH3T6A/vRhmkVHwAA",
-      "debug_symbols": "tdfRioQgFAbgd/HaC49aZq+yLIOVDYJYWC0s0buvDbE77FwO/0104vQJ4o+cnQ2+2+63kMZpYe3HzuLUuzVMqVT7wVmXQ4zhfnv+zMT5sOrRv8wuneWyuryythac+TSUl6b8PYboWauVPvhLp5FXpzG/nZU8PjmzGiZXMLmGyQYmNzDZomQSAkcTjpY4WuFojaMrHF3jaIOjGxyNSyPh0ki4NBIujYRLI+HSSLg00ptptOrqLFv7Yhug3QBti7OlANoEtCXQVkBbA+0KaANzKYG5lMBcSlQuj1J9uRxcF/01WI1b6p/mrPV79v9GrjlPvR+27M/h62/uOs+y0lzrx9VeClKSkzJlkbLQDw==",
+      "debug_symbols": "tdfRioQgFAbgd/HaC49aZq+yLIOVDYJYWC0s0buvDbE77FwO/0104vQJ4o+cnQ2+2+63kMZpYe3HzuLUuzVMqVT7wVmXQ4zhfnv+zMT5sOrRv8wuneWyuryythac+TSUl6b8PYboWas1Hfyl08ir05jfzkoen5xZDZMrmFzDZAOTG5hsUTIJgaMJR0scrXC0xtEVjq5xtMHRDY7GpZFwaSRcGgmXRsKlkXBpJFwa6c00WnV1lq19sQ3QboC2xdlSAG0C2hJoK6CtgXYFtIG5lMBcSmAuJSqXR6m+XA6ui/4arMYt9U9z1vo9+38j15yn3g9b9ufw9Td3nWdZaa7142ovBSnJSZmySFnoBw==",
       "brillig_names": [
         "compute_note_hash_and_optionally_a_nullifier"
       ]
     },
     {
-      "name": "verify_private_authwit",
+      "name": "sync_notes",
+      "is_unconstrained": true,
+      "custom_attributes": [],
+      "abi": {
+        "error_types": {
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        },
+        "parameters": [],
+        "return_type": null
+      },
+      "bytecode": "H4sIAAAAAAAA/9VUyw6CMBBseURBOaiJ3kz8gyIYOJJ49x8akKMe8OKNT5eabbqpVRKlJkzSbEs3szNlW0oUKESPvAH9tGnIFdhBDCA6aN/tRgFr9hviQKs7JH/O0iQw+BtQ/5OfWtIvIPktnT+bAM+xVfzYi6w77UaIesKWZ/nPbHpe9fhc/MFnh32k1caghm+uIYci3RuYR4Y8iRlRd9prh/eV5YzJei7w++RVO67va/lrWIeafvmOFV/qrDMe1wmv+YFXVVrypcYv4KBzGnMvbGHe1wvY45yo3mjul/J0vZ0b0gNB8gCVxsvQjgYAAA==",
+      "debug_symbols": "ndLBCoQgEAbgd5lzhzSt7FViCSsLQTTMFpbo3deiXdqli14GR/zGw/wr9KJdxkbqwcxQ1Sso03EnjfbduiXQWqmUHJvrNaR7Qeh4P09c7+3suHVQ5WkCQvf+UHo9SCWgIgRtjwQQDgVZKCChgAYCfPsDI4idhBGSfxGi6YFoDMpjUBGDygiU3W6f0bT8IIqLX7T59smt5K0SZ7qGRXeXsLnXJP5yN1nTiX6xYk/gJXy+1qhIMPZj/eg3",
+      "brillig_names": [
+        "sync_notes"
+      ]
+    },
+    {
+      "name": "entrypoint",
       "is_unconstrained": false,
       "custom_attributes": [
-        "private",
-        "view"
+        "private"
       ],
       "abi": {
         "error_types": {
@@ -110,18 +129,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"
@@ -236,7 +251,7 @@
                               }
                             },
                             {
-                              "name": "txs_effects_hash",
+                              "name": "blobs_hash",
                               "type": {
                                 "kind": "field"
                               }
@@ -567,6 +582,27 @@
                                 "kind": "struct",
                                 "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
                               }
+                            },
+                            {
+                              "name": "max_priority_fees_per_gas",
+                              "type": {
+                                "fields": [
+                                  {
+                                    "name": "fee_per_da_gas",
+                                    "type": {
+                                      "kind": "field"
+                                    }
+                                  },
+                                  {
+                                    "name": "fee_per_l2_gas",
+                                    "type": {
+                                      "kind": "field"
+                                    }
+                                  }
+                                ],
+                                "kind": "struct",
+                                "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
+                              }
                             }
                           ],
                           "kind": "struct",
@@ -593,9 +629,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"
           }
@@ -1335,7 +1535,7 @@
                             }
                           },
                           {
-                            "name": "txs_effects_hash",
+                            "name": "blobs_hash",
                             "type": {
                               "kind": "field"
                             }
@@ -1666,6 +1866,27 @@
                               "kind": "struct",
                               "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
                             }
+                          },
+                          {
+                            "name": "max_priority_fees_per_gas",
+                            "type": {
+                              "fields": [
+                                {
+                                  "name": "fee_per_da_gas",
+                                  "type": {
+                                    "kind": "field"
+                                  }
+                                },
+                                {
+                                  "name": "fee_per_l2_gas",
+                                  "type": {
+                                    "kind": "field"
+                                  }
+                                }
+                              ],
+                              "kind": "struct",
+                              "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
+                            }
                           }
                         ],
                         "kind": "struct",
@@ -1684,45 +1905,29 @@
           "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",
-        "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": "ff6671ddb572df3d961df43ed4c3adf75a7d3763-6e546195386f377a0e79408c93f24148-client-ivc-true"
+      "verification_key": "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",
+      "artifact_hash": "e7552d296af009c9ed2e2ca261de6124cad0b1c1-c26139d8c2da4ae4e00fd39931e9a628-client-ivc-true"
     },
     {
-      "name": "sync_notes",
-      "is_unconstrained": true,
-      "custom_attributes": [],
-      "abi": {
-        "error_types": {
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        },
-        "parameters": [],
-        "return_type": null
-      },
-      "bytecode": "H4sIAAAAAAAA/9VUyw6CMBBseURBOaiJ3kz8gyIYOJJ49x8akKMe8OKNT5eabbqpVRKlJkzSbEs3szNlW0oUKESPvAH9tGnIFdhBDCA6aN/tRgFr9hviQKs7JH/O0iQw+BtQ/5OfWtIvIPktnT+bAM+xVfzYi6w77UaIesKWZ/nPbHpe9fhc/MFnh32k1caghm+uIYci3RuYR4Y8iRlRd9prh/eV5YzJei7w++RVO67va/lrWIeafvmOFV/qrDMe1wmv+YFXVVrypcYv4KBzGnMvbGHe1wvY45yo3mjul/J0vZ0b0gNB8gCVxsvQjgYAAA==",
-      "debug_symbols": "ndLNCoQgEAfwd5lzh/yq7FViCSsLQTTMFpbo3deiXdqli10GR/yNh/kv0MlmHmplejtBWS2gbSu8siZ0y5pA45TWaqjP15BuBaH9/TQKs7WTF85DmaUJSNOFQxF0r7SEkhK6PhJAOBaQWEBjAYsE+PIHTnh2EE4x+SKOdsNumOyGyW+YIt6Qy8VzWrCPYSn9MWvonsIp0Wh55KqfTXuKmX+N8i9xo7Ot7GYnt+ydYhdqhfIE4zA2jH4D",
-      "brillig_names": [
-        "sync_notes"
-      ]
-    },
-    {
-      "name": "entrypoint",
+      "name": "verify_private_authwit",
       "is_unconstrained": false,
       "custom_attributes": [
-        "private"
+        "private",
+        "view"
       ],
       "abi": {
         "error_types": {
@@ -1734,13 +1939,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",
@@ -1856,7 +2065,7 @@
                               }
                             },
                             {
-                              "name": "txs_effects_hash",
+                              "name": "blobs_hash",
                               "type": {
                                 "kind": "field"
                               }
@@ -2187,6 +2396,27 @@
                                 "kind": "struct",
                                 "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
                               }
+                            },
+                            {
+                              "name": "max_priority_fees_per_gas",
+                              "type": {
+                                "fields": [
+                                  {
+                                    "name": "fee_per_da_gas",
+                                    "type": {
+                                      "kind": "field"
+                                    }
+                                  },
+                                  {
+                                    "name": "fee_per_l2_gas",
+                                    "type": {
+                                      "kind": "field"
+                                    }
+                                  }
+                                ],
+                                "kind": "struct",
+                                "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
+                              }
                             }
                           ],
                           "kind": "struct",
@@ -2213,173 +2443,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"
           }
@@ -3119,7 +3185,7 @@
                             }
                           },
                           {
-                            "name": "txs_effects_hash",
+                            "name": "blobs_hash",
                             "type": {
                               "kind": "field"
                             }
@@ -3450,6 +3516,27 @@
                               "kind": "struct",
                               "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
                             }
+                          },
+                          {
+                            "name": "max_priority_fees_per_gas",
+                            "type": {
+                              "fields": [
+                                {
+                                  "name": "fee_per_da_gas",
+                                  "type": {
+                                    "kind": "field"
+                                  }
+                                },
+                                {
+                                  "name": "fee_per_l2_gas",
+                                  "type": {
+                                    "kind": "field"
+                                  }
+                                }
+                              ],
+                              "kind": "struct",
+                              "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
+                            }
                           }
                         ],
                         "kind": "struct",
@@ -3468,55 +3555,25 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "7d3djjvJcef9e9HxHFRkZkRm+VYWxkK2tQsBgmTI8gILw/e+9X8hu2fIrpxeZpMR+c3n4IHGS3IiguzKX5CcD//rD//2p3/5z//9P//81//1t//4wz/9j//6w1/+9q9//Mef//bX45/+6w85f/+//ce///Gv3/7xP/7xx7//4w//JLZvv/zhT3/9t+N/1m3771/+8L/+/Jc//eGfSi7//cvNrVPL7eetU7O3W0vVO7fOKvvPW2fdU+fWbb8+dttVrrfOInduLfn62JJzu9462b0bb8kuN96+/cvfbvzPv/whlzWY+4PRNZj7g7E1mPuDqWsw9wfT1mDuD2Zfg7k7mLKtwdwfjKzB3B9MWoO5P5iVfD8YTFmDuT+YlXw/GMxKvh8MZiXfDwazku8Hg1nJ9/5gdCXfDwazku8Hg1nJ94PBrOT7wWDKGsz9wazk+8FgVvL9YDAr+X4wmJV8PxjMSr73B2Mr+X4wmJV8PxjMSr4fDGYl3w8GU9Zg7g9mJd8PBrOS7weDWcn3g8Gs5PvBYFbyvT+YupLvB4NZyfeDwazk+8FgVvL9YDBlDeb+YFby/WAw7pNv1etg2t4bTG35Unfb0kODcZ98XzUY98n3VYMZkHzLppfiy7a/XQfs+7+hbV/+b7ibxcwuz5Y16zy+qF4HqvZu/GW7d2tp9XLrVN9qz7nee2pVLo/dVLfOU9tSud467b1ratbLU1vSdv4ySGm/vB5Tlt5rZty1uqX15Ph9cvJ6cvw+OWU9OX6fHF1Pjt8nx9aT4/fJqevJ8fvktPXk+H1y9vXkuH1y9m09OX6fnPUOgeMnZ71D4PjJWe8QOH5yynpy/D456x0Cx0/OeofA8ZOz3iFw/OSsdwgcPznrHQK/T45s6y0Cz8/Oeo/A87Oz3iTw/Oysdwk8PztlPTuOn531PoHnZ2e9UeD52VnvFHh+dtZbBb/j2anXGaZaOjce+MVv2dZ7BY6fHRnwXkF9e3Za/9mpb8+OlnfPjq0r2+2zI+vZcfzspPXsOH528np2HD87ZT07jp8dXc+O42fH1rPj+Nmp69lx/Oy09ew4fnb29ez4fXbSeq/A87Oz3ivw/Oys9wo8PzvrvQLPz05Zz47jZ2e9V+D485203ivw/OwMeK9gu/4l2/sJ3n128PNua95Pnfe+5v3MeefHN3Sz6/W7vosRH1ztt71cbn2sOL967O/1iLN6krN6srN6irN61Fk95qye6qye5qye3Vc9xdn1uTi7Phdn1+fi7PpcnF2fi7Prc3F2fS7Ors/F2fW5OLs+q7Prszq7Pquz67M6uz6rs+uzOrs+q7Prszq7Pquz67M6uz6bs+uzObs+m7Prszm7Ppuz67M5uz6bs+uzObs+m7Prszm7Pldn1+fq7PpcnV2fq7Prc3V2fa7Ors/V2fW5Ors+V2fX5+rs+tycXZ+bs+tzc3Z9bs6uz83Z9bk5uz43Z9fn5uz63Jxdn5uz6/Pu7Pq8O7s+786uz7uz6/Pu7Pq8O7s+786uz7uz6/Pu7Pq8P/v6LPmtnnd20P3HTuVy42Tt3W3v/fBuSXqpo6Sar7eW/c6NtWyXb/lpSeX9jY+ppG1bU7kzFVlTuTOVtKZyZyp5TeXOVMqayp2p6JrKnanYmsqdqdQ1lTtTaWsqd6aysu2dqcjKtvemsrLtvamsbHtvKivb3ptKWVO5M5WVbe9NZWXbe1NZ2fbeVFa2vTeVlW3vTCWtbHtvKivb3pvKyrb3prKy7b2plDWVO1NZ2fbeVFa2vTeVlW3vTWVl23tTWdn2zlTyyrb3prKy7b2prGx7byrzZFvbLjcu9s5KuzRaKI3Ok0A7jc4TKjuNzpMTTfXaaL1tdJ7o12l0njR33miZJ6B1Gp0nc3UanSdGnV91CyUZPZ13e1mjlGRUJkpG5xcjSjIqlGRUKMlIKclIKclIJ0pG541OlIzOGy2URidKRueNUt4z0omS0XmjEyWj80YnSkanjRolGRklGRklGRklGT2dNH1Zo5RkZJT3jIzynpFR3jMyyntGdaJkdBoB60TJ6LxRyqdplfJp2tMx4ZddjCjJqFKSUaUko0pJRpWSjBrlPaNGec+oUd4zapT3jJ7OeL8qAjbK94wa5dO0Rvk0rVGSUaMko52SjHZKMtopyWinJKOnA/ova5TyntFOec9op7xntFO+ZzTRrx+cNpon+kGDTqOQT9PyRD87cHoxyhP9kkCn0UJpFJKM8kSEf6dRSDLKE0H7nUYh7xnliTj8TqOQ94zyRGj9eQScyKHvNFoojUI+TcsTAfCdixElGU3EtHcapSSjiTD1TqOUZDQRed5plPKe0UQweadRyntGE/Hh5xFwIhG80yjk07Q8kdt93uhEFPf5xWgiXbvTKCUZzWRgnzdaKI1SktFMBvZ5o5T3jCgGdqYY2HkmA/s0As5kYJ83Svk0jWJg55kM7POLESUZUQzsTDGwM8XAzhQDO1MM7EwxsDPFwM4UAzvPZGCfRsCZDOzzRimfplEM7DyTgX1+MaIkI4qBnSkGdqYY2JliYGeKgZ0pBnamGNiZYmDnmQzs0wg4k4F92ijFwM4UAzvPZGCfXoxmMrDPGy2URinJiGJgZ4qBnSkGdqYY2JliYGeKgZ1nMrBPI+BMBvZ5o4XSKOXTtJkM7POLESUZUQzsTDGwM8XAzhQDO1MM7EwxsDPFwM4UAzvPZGCfRsCZDOzzRimfplEM7DKTgX12MSozGdjnjUKSUaEY2GUrlEYhyahQDOxCMbALxcAuFAO7zGRgn0bAmQzs80Yhn6YVioFdZjKwzy9GlGREMbALxcAuFAO7UAzsQjGwC8XALhQDu1AM7DKTgX0aAWcysM8bhXyaVigGdpnJwD6/GFGSEcXALhQDu1AM7EIxsAvFwC4UA7tQDOxCMbDLTAb2aQScycA+bZRiYBeKgV1mMrBPL0YzGdjnjRZKo5RkRDGwC8XALhQDu1AM7EIxsAvFwC4zGdinEXAmA/u80UJplPJp2kwG9vnFiJKMKAZ2oRjYhWJgF4qBXSgGdqEY2IViYBeKgV1mMrBPI+BMBvZ5o5RP0ygGdpnJwD69GM1kYJ83SklGFAO7UAzsQjGwC8XALhQDu1AM7EIxsMtMBvZpBJzJwD5vlPJpGsXALjMZ2OcXI0oyohjYhWJgF4qBXSgGdqEY2IViYBeKgV0oBnaZycA+jYAzGdjnjVI+TaMY2GUmA/v8YgRJRkoxsJViYCvFwFaKga1boTQKec9IKQa2UgxsncnAPouAOpOBfdooxcBWioGtMxnYpxejmQzs80YLpVFKMqIY2EoxsJViYCvFwFaKga0UA1tnMrBPI+BMBvZ5o4XSKOTTNJ3JwD6/GFGSEcXAVoqBrRQDWykGtlIMbKUY2EoxsJViYOtMBvZpBJzJwD5vlPJpGsXA1pkM7NOL0UwG9nmjlGREMbCVYmArxcBWioGtFANbKQa2UgxsncnAPo2AMxnY541SPk2jGNg6k4F9fjGiJCOKga0UA1spBrZSDGylGNhKMbCVYmArxcDWmQzs0wg4k4F93ijl0zSKga0zGdjnFyNKMqIY2EoxsJViYCvFwFaKga0UA1spBrZSDGydycA+jYAzGdinjVIMbKUY2DqTgX16MZrJwD5vtFAapSQjioGtFANbKQa2UgxspRjYSjGwdSYD+zQCzmRgnzdaKI1SPk2bycA+vxhRkhHFwFaKgW0UA9soBrZRDGyjGNjHIUtpFPKekc1kYJ9FQJvJwD5vFPJpmlEMbJvJwD69GM1kYJ83SklGFAPbKAa2UQxsoxjYRjGwjWJgG8XAtpkM7NMIOJOBfd4o5NM0oxjYNpOBfX4xoiQjioFtFAPbKAa2UQxsoxjYRjGwjWJgG8XAtpkM7NMIOJOBfd4o5dO0mQzs879RyqdpFAPbZjKwzxulJKOZDOzzZ5TyntFMBvZ5o5RkRDGwjWJgG8XANoqBbTMZ2OeNUpLRTAb2eaOU94wmMrBrk0ujteWbRl0nI90uD62tdBqV1PbLI+cs726dfnTqOhp9rlNtb53abaeus9GnOj1aujxyKXrbqetwNLRT1+loZKe+IeyhnbrOR0M7dR2QhnbqOiF9rlPdrp1avu20YDqdJyP1Op0nI/U6nSgjdTqdKCN1Op0pI8lbp+WmU98k9uc6rdetrezpttOJMlKn04kyUqfTiTJSp9OC6XSijNTpdKKMtF/rUNluO50oI3U6nSgjdTqdKCOdd+obxx7a6UQZqdPpTBmpvXV6+2mFbx/7U51quZ6nJr/e2u58tLVdP65K8ptPcW5vneu1x9zePbbUH0Msa4iPD3GeZPfCIc4TGl84xHny6AuHOE/U/cohtv1y67zfGeI8Kfp1Q/RttEcZ4jzZ/4VDnGeteOEQ18YyYIhlDfHxIa6NZcAQ18YyYIjUjSWl6xCT7Z1bH++F6dt7YW+PneTu8yPXh95yO79xTtkuT0+q+/sbf396qLuQl6cnX7/InvNuN08PdcsK8ddTff+SBP2vp/r+/Yv110PdOYP89VC32S98enK6TC/l2m4mXqgT3/U6lrR1bl2SXgopqf7qP+e7U3TZLpcgLam8v/H3iVP35NdNnLpUv27i2A38ZRPHLtUvmzh2T37VxH3/VNCUE8dusy+bOHZBfdnEsTvnyyZe1sSfPPG1cz574mvnfPbE18757ImvnfPZE18755Mn7vtH2Kac+No5nz3xtXM+e+Jr53z2xMua+JMnvnbOZ0987ZzPnvjaOZ898bVzPnvia+d88sR9/7zllBNfO+ezJ752zmdPfO2cz554WRN/8sTXzvnsia+d89kTXzvnsye+ds7fM/HT30isvn+CN8gQff+8b5QhrmVvwBDX/va7hnj2e3fV908eRxliWUN8fIhrcRowxLULDRjiWm8GnM5rYxkwxLWxPD5E3z+7HWWIa2N5/GDx/XPhUYa4NpYBQyxriI8PcW0sA4a4NpYBQ1wby4Ahro1lwBDXxvL4EG1tLAOGuDaWx9c+WxvLgCGujWXAEMsa4uNDXBvLgINlbSwDhrg2lgFDXBvLgCGujeXxIda1sQwY4tpYBgxxbSwDhrg2lgFDLGuIjw9xbSyPr311bSwDhrg2lgFDXBvLgCGujeXxg6WtjWXAENfGMmCIa2MZMMS1sQwYYllDfHyIa2MZMMS1sQwY4tpYBgxxbSwDhrg2lsfXvn1tLAOGuDaWAUNcG8uAIa6N5fGDZS9riI8PcW0sA4a4NpYBQ1wby4Ahro1lwBDXxvLwENu2NpYBQ1wby4Ahro1lwBDXxvLw2te2sob4+BDXxjJgiGtjGTDEtbEMOFjWxjJgiGtjeXyIsjaWAUNcG8uAIa6NZcAQ18YyYIhlDfHxIa6NZcAQ18YyYIhrY3l87ZO1sQwY4tpYHh9iWhvLgCGujeXxgyWtjWXAENfGMmCIZQ3x8SGujWXAENfGMmCIa2MZMMS1sQwY4tpYHh9iXhvLgCGujeXxtS+vjWXAENfGMmCIZQ3x8SGujWXAwbI2lgFDXBvLgCGujWXAENfG8vgQ12/ejxji2lgGDHFtLAOGuDaWAUMsa4iPD3FtLI+vfes370cMcW0sA4a4NpYBQ1wby+MHy/rN+xFDXBvLgCGujWXAENfGMmCIZQ3x8SGujWXAENfGMmCIa2MZMMS1sQwY4tpYHl/71m/ejxji2lgGDHFtLAOGuDaWxw+W9Zv3I4a4NpYBQ1wby4Ahro1lwBDXxjJgiGtjeXyI6zfvRwxxbSwDhrg2lgFDXBvL42vf+s37EUNcG8uAIa6NZcAQ18Yy4GBZG8uAIa6N5fEhrt+8HzHEtbEMGOLaWAYMcW0sA4ZY1hAfH+LaWAYMcW0sA4a4NpbH1771m/cjhrg2lseHuH7zfsQQ18by+MGyfvN+xBDXxjJgiGUN8fEhro1lwBDXxjJgiGtjGTDEtbEMGOLaWB4e4r5+837EENfG8vDat6/fvB8xxLWxDBhiWUN8fIhrYxlwsKyNZcAQ18YyYIhrYxkwxLWxPD7E9Zv3I4a4NpYBQ1wby4Ahro1lwBDLGuLjQ1wby+Nr3/rN+xFDXBvLgCGujWXAENfG8vjBsn7zfsQQ18YyYIhrYxkwxLWxDBhiWUN8fIhrYxkwxLWxDBji2lgGDHFtLAOGuDaWx9e+9Zv3I4a4NpYBQ1wby4Ahro3l8YNl/eb9iCGujWXAENfGMmCIa2MZMMS1sQwY4tpYHh/i+s37EUNcG8uAIa6NZcAQ18by+Nq3fvN+xBDXxjJgiGtjGTDEtbEMOFjWxjJgiGtjeXyI6zfvRwxxbSwDhrg2lgFDXBvLgCGWNcTHh7g2lgFDXBvLgCGujeXxtW/95v2IIa6N5fEhrt+8HzHEtbE8frCs37wfMcS1sQwYYllDfHyIa2MZMMS1sQwY4tpYBgxxbSwDhrg2lseHuH7zfsQQ18by+Nq3fvN+xBDXxjJgiGUN8fEhro1lwMGyNpYBQ1wby4Ahro1lwBDXxvL4ENdv3o8Y4tpYBgxxbSwDhrg2lgFDLGuIjw9xbSyPr33rN+9HDHFtLAOGuDaWAUNcG8vjB8v6zfsRQ1wby4Ahro1lwBDXxjJgiGUN8fEhro1lwBDXxjJgiGtjGTDEtbEMGOLaWB5e+2RbP3o/ZIprZxkxxbW0jJji2loePlyOKZY1xQFTXHvLiCmuxWXEFNfmMmKKa3UZMcW1uwyYoqzdZcQU1+4yYoprdxkxxbW7DNgApawpDpji2l1GTHHtLiOmuHaXEafL2l1GTHHtLgOmmNbuMmKKa3cZMcW1u4yY4tpdRkyxrCkOmOLaXUZMce0uI6a4dpcBG2Bau8uIKa7dZcAU89pdRkxx7S4DTpe8dpcRU1y7y4gpljXFAVNcu8uIKa7dZcQU1+4yYoprdxkxxbW7DJhiWbvLiCmu3WXABljW7jJiimt3GTHFsqY4YIprdxlxuqzdZcQU1+4yYoprdxkxxbW7DJiirt1lxBTX7jJiimt3GTHFtbuMmGJZUxwwxbW7DNgAde0uI6a4dpcRU1y7y4gprt1lwOlia3cZMcW1u4yY4tpdRkxx7S4jpljWFAdMce0uI6a4dpcRU1y7y4gprt1lxBTX7jJgA6xrdxkxxbW7jJji2l1GTHHtLgNOl1rWFAdMce0uI6a4dpcRU1y7y4gprt1lxBTX7jJgim3tLiOmuHaXEVNcu8uIKa7dZcAG2Mqa4oAprt1lxBTX7jJiimt3GXG6rN1lxBTX7jJgivvaXUZMce0uI6a4dpcRU1y7y4gpljXFAVNcu8uIKa7dZcQU1+4yYAPc1+4yYoprd3l8irKt3WXEFNfu8vjpItvaXUZMce0uI6ZY1hQHTHHtLiOmuHaXEVNcu8uIKa7dZcQU1+4yYIqydpcRU1y7y4ANUNbuMmKKa3cZMcWypjhgimt3GXG6rN1lxBTX7jJiimt3GTHFtbsMmGJau8uIKa7dZcQU1+4yYoprdxkxxbKmOGCKa3cZsAGmtbuMmOLaXUZMce0uI6a4dpcBp0teu8uIKa7dZcQU1+4yYoprdxkxxbKmOGCKa3cZMcW1u4yY4tpdRkxx7S4jprh2lwEbYFm7y4gprt1lxBTX7jLguljW7jLitVjWFAdMce0uI6a4dpcR18W1u4x4La7dZcQU1+4yYIq6dpcRU1y7y4DTRdfuMmKKa3cZMcWypjhgimt3GTHFtbuMmOLaXUZMce0uI6a4dpffM8Xa5DLF2vLNFI26u7w9dNJkv7r1j8HMs45YutZhRe60Os/OYG17q2O70+o8wb7bauG0Ok9E7rY6T47ttjpP2Oy2Ok8i7LY6T2zrtTrR7353W50oLfVa5aSliX7muttq4bTKSUsT/apzt1VOWpro95G7rXLS0kS/NNxtlZOWJvrN3m6rnLQ00a/fdlvlpKWJfke22yonLU30i6zdVjlpaaLfNu22yklLE/1KaLdVTlpy/nub++ULAqbSaTW163cyUqtvtz7eaLlz67yl9PPWWUp7q1ruVd1U8s9bH/+W7d2t5d6tU7neOu3SuXVW+3nj8u4bE+le0Sntl68RpPxu1HdvLFmu3znIuXVuvKVLFbJVfX/jHy8T30lzvUycvEx8p/T1MnHyMvG94ayXiZOXie/tcL1MnLxMfG/W62Xi4mWSnP9q8XqZOHmZ+H5HZ71MnLxMfL8btl4mTl4mvt9JXC8TJy+Tsl4m62XSf5msd2HXy+R3vEzWu7DrZfI7XibrXdj1MvkdL5P1Lmygl0m9Ppmpls6NpbZLFdK29ODLZL0Lu14m/ZeJzPMu7L5dn/jNcudlsp74ed5XXU/8p574ad4pPZ6Et0u9WueJT+VqvqTS6rtb3yu6tesQ9+3da6r9HOI07yN+5RD368Ete23vh3h743IdR9lv6KEkZc27O+/jI9VLHcfnIeWheU/zztZXzluuR8lxQdhvLxLTvO/zlUM8bn25cWr5/EUruV3nUTa9nfg0b6GEmfg070a4mbjma9jT93X8f1zFp3kPYMInJ02zeft5cuo1b+r+UN5M02zHMz4582yw217enpzaeXJKuT6V5fj/zp+cXK8t5ibv3xX5OcR5NtgvHGK71pH3e0Msa4iPD3GeXfOFQ5xn13zhEOdZH184xHk2whcOcZ7N7XVDzPNsWC8c4jyb0AuHuDaWAUOcc2Ox3jdaZCtXM2T71fdf7pUh14fW41Oz2yGWNcTHhzjnxvLkIc65sTx5iHNuLIOHmIpdh2h2O8Q5N5YnD3HOjeW5QyxzbixPHuKcG8vgIVq91KFVOsm8Wr5MvFq7TeZlzvXG88TXLvQ7Jt7kOvGm6cGJlzXx0RPfL/OoVeR24mvLevbEn72Svc1Fjve8f/XYPwqq3gpaH278njfyrv/RRG6/euifQ1wfbjw+RP3SVeHHv+LxIF3TdfK17L3nqaXrha+Vt5Zztrt5as/XPLW1X83+R/kpdvk5dvnlyeXv2+WhZdfcKV92KdcX/y729sdo9/9r7+PP8efN07Fg5vc3/9Gusto1VruV1W5jtbuj2rWN1a6w2k2sdjOr3cJql5WqzHmqqnbdEPa9yG39zg/SdIUijv+t7ab++z/CLra//WbP1nv7oGzX/+i9bPvtjO7/+vngf0d6wr/jyRfelGS7/vG8+++YPniudX8jM+x4td7WX4LXr67rr/layfG/d72t34LXX4PX34LXv8euv23B65fg9afg9fs+f/v1+z5/+/UHP39b8PO3Pfst2dquy0Pb5Ff1/yioeStod1bQ/oT1an/CerU/Yb3ag69Xu+/Le79+35f3fv3OrkZ5c/6+dOe9obw5f6O5895c3sqXX7Ty/d/DGPzvsCf8O56dLYZ+9SJvLXb5e+jyBfXxahbUx6tZUB+vZkF9vJoHMMOh2kV9vJoF9aW1LKgvrWVBfWktC+pLazmxUlViparESlWJlaoGKJl+2rU39N8k32l2pkzVbTb2F9Zych2R0pbz5ebH/7bWebLa9T8vs5beSqk/e3Wdjwb36jocje01u05Gg3t1HYsG9+o6E326V7seJK3pTa+uA9HgXguoV9dhaHCvrrPQ4F7nyk3nvc6Vm857nSs3nfZa5spN573OlZvOewXlpgLKTQMArji9gnJTAeWmAspNBZSbCig3KSg3KSg3KSg3KSg3+Ya4BvcKyk2+Ca7BvYJyk298a3CvoNzkm90a3CsoN/kGtwb3CspNvqmtwb2CcpNvZGtwr6DcZKDc5BtaG9trBeWmCspNFZSbKig3PRvWe2mvoNxUp8pN+5V7sF1ue50qN3V6nSo3dXqdKjed99qmyk2dXqfKTZ1ep8pNnV6nyk2dXguo16lyU6dXUG5qoNzUQLmpgXLTDspNOyg37aDctINy07Ol0Zf2CspNOyg37aDctINy087JTWXj5KaycXJT8Q03D+6Vk5vKVkC9cnJT2Ti5qWyc3FQ2Tm4qGyg3+fbCB/cKyk2+pfDBvYJyk28jfHCvoNzkWwcf3CsoN/l2wQf3CspNvkXwwb2CcpNvC3xwr6Dc5FsBH9wrKDf5NsAH9wrKTXN54Z1eQblpLi+80ysoN83lhXd6BeWmubzwTq+g3DSXF97pFZSb5vLCO72CctNcXninV1BumssL7/QKyk1zeeGdXkG5aS4vvNMrKDfN5YV3egXlprm88E6voNw0lxfe6RWUm+bywju9gnLTXF54p1dQbprLC+/0CspNc3nhnV5BuWkuL7zTKyg3zeWFd3oF5aa5vPBOr6DcNJcX3ukVlJvm8sI7vYJy01xeeKdXUG6aywvv9ArKTSAvvIC88ALywgvICy8gL7yAvPAC8sILyAsvIC+8gLzwAvLCC8gLLyAvvIC88ALywgvICy8gL7yAvPAC8sILyAsvIC+8gLzwAvLCC8gLV5AXriAvXEFeuIK8cN0KqFdOblKQF64gL1xBXriCvHAFeeEK8sIV5IUryAtXkBeuIC9cQV64grxwBXnhCvLCFeSFK8gLV5AXriAvXEFeuIK8cAV54QrywhXkhSvIC1eQF64gL1xBXriCvHAFeeEK8sIV5IUryAtXkBeuIC9cQV64grxwBXnhCvLCFeSFK8gLV5AXriAvXEFeuIK8cAV54QrywhXkhSvIC1eQF64gL1xBXriCvHAFeeEK8sIV5IUryAtXkBeuIC9cQV64grxwBXnhCvLCFeSFK8gLV5AXriAvXEFeuIK8cAV54QrywhXkhSvIC1eQF64gL1xBXriCvHAFeeEK8sIV5IUryAtXkBeuIC9cQV64grxwBXnhCvLCFeSFK8gLV5AXriAvXEFeuIK8cAV54Qrywg3khRvICzeQF24gL9y2AuqVk5sM5IUbyAs3kBduIC/cQF64gbxwA3nhBvLCDeSFG8gLN5AXbiAv3EBeuIG8cAN54Qbywg3khRvICzeQF24gL9xAXriBvHADeeEG8sIN5IUbyAs3kBduIC/cQF64gbxwA3nhBvLCDeSFG8gLN5AXbiAv3EBeuIG8cAN54Qbywg3khRvICzeQF24gL9xAXriBvHADeeEG8sIN5IUbyAs3kBduIC/cQF64gbxwA3nhBvLCDeSFG8gLN5AXbiAv3EBeuIG8cAN54Qbywg3khRvICzeQF24gL9xAXriBvHADeeEG8sIN5IUbyAs3kBduIC/cQF64gbxwA3nhBvLCDeSFG8gLt2d74SnJdik+qXV6/eZy5suDm+z7+15/1L/Hrv/Zrvcn67eUtmv9SaXzWmtyfa21tP/2tfZs1/ulvSZQrxnUawH1qqBeDdRrnapXy9e6202+2X3nm7G9+s5CI3ut21y56bzXuXLTea9z5abzXufKTee9FlCvc+Wm817nyk3nvXJyU904ualuoNwkoNwkoNwkoNwkoNz0bNf7pb2CcpOAcpOAcpOAcpOAclMC5aYEyk0JlJsSKDc92/V+aa+g3JRAuSmBclMC5aYEyk0ZlJsyKDdlUG7KoNz0bNf7pb2CclMG5aYMyk0ZlJsyKDcVUG4qoNxUQLmpgHLTs13vl/YKyk0FlJsKKDcVUG4qoNykoNykoNykoNykU+Wm0//+uD7b9X5pr75z0/Ee0fU/Qz92bX3f64/6fWehfv2+802/ft+ZpV+/7xzSrd98Z4t+/b7zQr9+3xmgX7/vc71fv++zul9/8PPXgp+/Fvz8teDnrwU/f2vw87cGP39r8PO3Bj9/n20SD68/+Plbg5+/Nfj5W4OfvzX4+duCn78t+Pnbgp+/Lfj5+2zbdnj9wc/fFvz8bcHPX+dWbL/+4Oevcyu2X3/w89e56dqvP/j569xe7dcf/Px1bqT26w9+/jq3TPv1xz5/m3NztF9/7PO3ObdB+/XHPn/bFvv8bc5dzn79sc/f5tzP7Ncf+/xtzp3Lbv3O7cp+/cHPX+fGZL/+4OevcwuyX3/w89e52divP/j569xW7Ncf/Px1biD26w9+/jq3Cvv1Bz9/nZuC/fqDn7/O7b9+/cHPX+dGX7/+4Oevc0uvX3/w89e5edevP/j569ym69cf/Px1bsj16w9+/jq33vr1Bz9/nZts/fqDn7/O7bR+/cHPX+fGWb/+4Oevc4usX3/w89e5GdavP/j569z26tcf/Px1bnD16w9+/jq3svr1Bz9/g/tXLbh/1YL7Vy24f9WC+1ctuH/VgvtXLbh/1YL7Vy24f9WC+1ctuH/VgvtXLbh/1YL7Vy24f9WC+1ctuH/VgvtXLbh/1YL7Vy24f9WC+1ctuH/VgvtXLbh/1YL7Vy24f9WC+1ctuH/VgvtXLbh/1YL7Vy24f9WC+1ctuH/VgvtXLbh/1YL7Vy24f9WC+1ctuH/VgvtXLbh/tQf3r/bg/tUe3L/anftXI3/rb998n9Vje53q96A7vU71e9CdXqf6PehOr1P9HnSn16l+D/q8V+dm2NheXeeblMulkJT38u7Wl/Jdx5t++a7TTb/8Ert81xmkX77rWNEv33VS6Jfv+vDvl+/6PO+W75sV65f/7FNX834pSC13ym9V689bH5+fpPN8UdvlkVt61+m2/+w0ee707NY/ys+xyy+xy9fY5Vvs8mvs8lvs8vfQ5T/dHRtcvusDul9+7FM3xz51n26ODS4/9qmbY5+6Ofapm2Ofujn2qVtin7ol9qlbYp+6Jfap+3RpbHD5sU/dEvvULbFP3RL71C2xT12Nfepq7FN3hDBW87X8d99Bu1/+8Z6w/rz1sWd3Pn0XzdeHtndvpbefHwQM4MXadnmz/ps23in++Ddev2+3t3etHp9M3N5abb9Ur3Vr11tLvcy+xC5fY5dvzy0/bcUuf4rbLp3yv3094Prgx4fV5fwvJaXcLheRlIrk9zf/0W5ltdtY7e6odge4aKHaFVa7idVuZrVbWO0qq11WqjJWqjJWqjJWqhqh3X3mvYDuijaCrxtbUPJWUPZWUPFWkHoryLwVVL0V1LwVtDsrqDnff6td/xur/fhc+uakaa4X2rTlfP0G+patnR+s1uT634i19Pb+/c83qZvrbXZwr65X2cG9FlCvrpfYwb263mA/3avla93t5r9fba7X18G9ut5dB/fqenEd2+vuOgsN7nWu3HTe61y56bzXuXLTea8F1Otcuem8V1Bu2kG5aQflph2Tm9K2YXLT0SsmNx29YnLT0SsmNx29FlCvmNx09IrJTUevmNx09IrJTUevoNwkoNwkoNwkoNwkoNw0gFmM0ysoNwkoNwkoNwkoNwkoNyVQbkqg3JRAuSmBctMA/TJOr6DclEC5KYFyUwLlpgTKTRmUmzIoN2VQbsqg3DTAL43TKyg3ZVBuyqDclEG5KYNyUwHlpgLKTQWUmwooNw0QaOP0CspNBZSbCig3FVBuKqDcpKDcpKDcpKDcpKDc9GxF+KW9gnKTb594cK+g3ORbJh7cKyg3+TaJB/cKyk2+NeLBvYJyk2+HeHCvoNzkWyAe3CsoN/m2hwf3CspNFZSbKig3VVBuqqDcNEB4jtMrKDdVUG6qoNxUQbmpgnKTbwN8cK+g3DSZF37eKyg3TeaFn/cKyk0cL/zoFZSbOF740SsoN3G88G//upl63bfr7zbsctvrVLmp0+tUuanTawH1OlVu6vQ6VW7q9DpVbur0OlVu6vQ6VW467VXm8sI7vXJyk8zlhXd65eQm2QqoV05ukrm88E6vnNwkc3nhnV5BuWkuL7zTKyg3zeWFd3oF5aa5vPBOr6DcNJcX3ukVlJvm8sI7vYJy01xeeKdXUG6aywvv9ArKTXN54Z1eQblpLi+80ysoN83lhXd6BeWmubzwTq+g3DSXF97pFZSb5vLCO72CctNcXninV1BumssL7/QKyk1zeeGdXkG5aS4vvNMrKDfN5YV3egXlprm88E6voNw0lxfe6RWUm+bywju9gnLTXF54p1dQbprLC+/0CspNc3nhnV5BuWkuL7zTKyg3zeWFd3oF5aa5vPBOr6DcNJcX3ukVlJvm8sI7vYJy01xeeKdXUG6aywvv9ArKTXN54Z1eQblpLi+80ysoN83lhXd6BeWmubzwTq+g3DSXF97pFZSb5vLCO72CctNcXninV1BumssL7/QKyk1zeeGdXkG5aS4vvNMrKDeBvHABeeEC8sIF5IULyAsXkBcuIC9cQF54AnnhCeSFJ5AXnkBe+PGvBvXKyU0J5IUnkBeeQF54AnnhCeSFJ5AXnkBeeAJ54QnkhSeQF55AXngCeeEJ5IUnkBeeQF54AnnhCeSFJ5AXnkBeeAJ54QnkhSeQF55AXngCeeEJ5IUnkBeeQF54AnnhCeSFJ5AXnkBeeAJ54QnkhSeQF55AXngCeeEJ5IUnkBeeQF54AnnhCeSFJ5AXnkBeeAJ54QnkhSeQF55AXngCeeEJ5IUnkBeeQF54AnnhCeSFJ5AXnkBeeAJ54QnkhSeQF55AXngCeeEJ5IUnkBeeQF54AnnhCeSFJ5AXnkBeeAJ54QnkhSeQF55AXngCeeEJ5IUnkBeeQF54AnnhCeSFJ5AXnkBeeAJ54QnkhSeQF55AXngCeeEJ5IUnkBeeQF54AnnhCeSFJ5AXnkBeeAJ54QnkhSeQF55BXngGeeEZ5IVnkBeetwLqlZObMsgLzyAvPIO88AzywjPIC88gLzyDvPAM8sIzyAvPIC88g7zwDPLCM8gLzyAvPIO88AzywjPIC88gLzyDvPAM8sIzyAvPIC88g7zwDPLCM8gLzyAvPIO88AzywjPIC88gLzyDvPAM8sIzyAvPIC88g7zwDPLCM8gLzyAvPIO88AzywjPIC88gLzyDvPAM8sIzyAvPIC88g7zwDPLCM8gLzyAvPIO88AzywjPIC88gLzyDvPAM8sIzyAvPIC88g7zwDPLCM8gLzyAvPIO88AzywjPIC88gLzyDvPAM8sIzyAvPIC88g7zwDPLCM8gLzyAvPIO88AzywjPIC88gLzyDvPAM8sIzyAvPIC88g7zwDPLCM8gLzyAvPIO88AzywjPIC88gLzyDvPAM8sIzyAvPIC+8gLzwAvLCC8gLLyAvvGwF1CsnNxWQF15AXngBeeEF5IUXkBdeQF54AXnhBeSFF5AXXkBeeAF54QXkhReQF15AXngBeeEF5IUXkBdeQF54AXnhBeSFF5AXXkBeeAF54QXkhReQF15AXngBeeEF5IUXkBdeQF54AXnhBeSFF5AXXkBeeAF54QXkhReQF15AXngBeeEF5IUXkBdeQF54AXnhBeSFF5AXXkBeeAF54QXkhReQF15AXngBeeEF5IUXkBdeQF54AXnhBeSFF5AXXkBeeAF54QXkhReQF15AXngBeeEF5IUXkBdeQF54AXnhBeSFF5AXXkBeeAF54QXkhReQF15AXngBeeEF5IUXkBdeQF54AXnhBeSFF5AXXkBeeAF54QXkhReQF15AXngBeeEF5IUXkBdeQF54AXnhBeSFF5AXXkBeuIK8cAV54QrywhXkhetWQL1ycpOCvHAFeeEK8sIV5IUryAtXkBeuIC9cQV64grxwBXnhCvLCFeSFK8gLV5AXriAvXEFeuIK8cAV54QrywhXkhSvIC1eQF64gL1xBXriCvHAFeeEK8sIV5IUryAtXkBeuIC9cQV64grxwBXnhCvLCFeSFK8gLV5AXriAvXEFeuIK8cAV54QrywhXkhSvIC1eQF64gL1xBXriCvHAFeeEK8sIV5IUryAtXkBeuIC9cQV64grxwBXnhCvLCFeSFK8gLV5AXriAvXEFeuIK8cAV54QrywhXkhSvIC1eQF64gL1xBXriCvHAFeeEK8sL16V54Ltfi8146vYruLV8e3GTf3/f6o/4UvP7sun5LabvWn1Q6r7Um19daS/vNa62AelVQrwbqtYJ6baBed06vT3e9v7ZXy9e6202+2X3nm7G9+s5CY3udKzed91pAvc6Vm857nSs3nfc6V24673Wu3HTe61y56axX2zi5yTZObrKNk5ts4+Qm2wqoV05uso2Tm2zj5CbbOLnJNlBuElBuElBuElBuElBuerrr/cpeQblJQLlJQLlJQLlJQLkpgXJTAuWmBMpNCZSbnu56v7JXUG5KoNyUQLkpgXJTAuWmDMpNGZSbMig3ZVBuerrr/cpeQbkpg3JTBuWmDMpNGZSbCig3FVBuKqDcVEC56emu9yt7BeWmAspNBZSbCig3FVBuUlBuUlBuUlBuUlBuerrr/cpeQblJQblJQblJQblJQbnJQLnJQLnJQLnJQLnp6a73K3sF5SYD5SYD5SabKjedOoZmU+Wm816r79xU87WS43/v+r7XH/X7zkL9+n3nm379vjNLv/4SvH7f2aJfv++80K/fdwbo1+/7XO/X7/us7tbfgp+/zs3nfv3Bz1/n5nO//uDnr3ObuV9/8PPXuaHcrz/4+evcOu7W79wv7tcf/Px17gz36w9+/jr3gPv1Bz9/nbu9/fqDn7/Ofd1+/bHP3+rcwe3XH/v8rc692n79sc/fusU+f6tzK7Zff+zztzo3Xfv1xz5/q3N7tVu/c0+1X3/w89e5e9qvP/j569wn7dcf/Px17oj26w9+/jr3Pvv1Bz9/nbuc/fqDn7/O/cx+/cHPX+fOZb/+4Oevc4+yX3/w89e5G9mvP/j569x37Ncf/Px17jD26w9+/jr3Evv1Bz9/nbuG/fqDn7/O/cF+/cHPX+dOYL/+4Oevc8+vX3/w89e5u9evP/j569zH69cf/Px17tj16w9+/jr35vr1Bz9/nbtw/fqDn7/O/bZ+/cHPX+fOWr/+4Oevcw+tX3/w89e5W9avP/j569wX69cf/Px17oD16w9+/jr3uvr1Bz9/nbta/fqDn7/B/asa3L+qwf2rGty/qsH9qxrcv6rB/asa3L+qwf2rGty/qsH9qxrcv6rB/asa3L+qwf2rGty/qsH9qxrcv6rB/asa3L+qwf2rGty/qsH9qxrcv6rB/asa3L+qwf2rGty/qsH9qxrcv2rB/asW3L9qwf2rFty/alvs87cF969acP+qBfevWnD/qgX3r1pw/6oF969acP+qBfevWnD/qgX3r1pw/6oF969acP+qBfevWnD/qgX3r1pw/6oF969acP+qBfevWnD/qgX3r1pw/6oF969acP+qBfevWnD/qgX3r1pw/6oF969acP+qBfevWnD/qgX3r1pw/6oF969acP+qBfevWnD/qgX3r1pw/6oF969acP+qBfevWnD/qgX3r1pw/6oF969acP+qBfevWnD/qgX3r1pw/6oF969acP+qBfevWnD/qgX3r1pw/6oF969acP+qBfevWnD/qgX3r1pw/6oF969acP+qBfevWnD/qgX3r1pw/6oF969acP+qBfevWnD/qgX3r1pw/6oF969acP+qBfevWnD/qgX3r1pw/6oF96+ac//KUtouD25J5X39tze3fUuXund5a7b+7NX3WT22V9/n+thefWeAsb0WUK++s8XYXn3nkLG9+s4sY3t9PN/UVK5HeNk7vcq+XQ/8XfO7Xu8Vn7acr6PZjqzwWK87ptd9gFsWp1cB9ZpAvWZQrwXUq4J6NVCvFdQrJzftGyg3CSg3CSg3CSg3CSg3DfDx4vQKyk0Cyk0Cyk0Cyk0Cyk0JlJsSKDclUG5KoNw0wDWM0ysoNyVQbkqg3JRAuSmBclMG5aYMyk0ZlJsyKDcN8Cjj9ArKTRmUmzIoN2VQbsqg3FRAuamAclMB5aYCyk0DHNE4vYJyUwHlpgLKTQWUmwooNykoNykoNykoNykoNw3wX+P0CspNCspNCspNCspNCspNBspNBspNBspNBspNA9zeOL2CcpOBcpOBcpOBcpOBclMF5aYKyk0VlJsqKDcN8Jbj9ArKTRWUmyooN1VQbqqg3NRAuamBclMD5aYGyk0DnOw4vYJyUwPlpgbKTQ2UmxooN+2g3LSDctMOyk07KDcN8MLj9ArKTTsoN+2g3ATywneOF543jhd+9IrJTUevmNx09IrJTUevBdQrJjcdvWJy09ErJjcdvWJy09ErKDdxvPCjV1Bu4njhR6+g3MTxwo9eQbmJ44UfvYJyE8cLP3oF5SaOF370CspNHC/86BWUmzhe+NErKDdxvPCjV1Bu4njhR6+g3MTxwo9eQbmJ44UfvYJyE8cLP3oF5SaOF370CspNHC/86BWUmzhe+NErKDdxvPCjV1Bu4njhR6+g3MTxwo9eQbmJ44UfvYJyE8cLP3oF5SaOF370CspNHC/86BWUmzhe+NErKDdxvPCjV1Bu4njhR6+g3MTxwo9eQbmJ44UfvYJyE8cLP3oF5SaOF370CspNHC/86BWUmzhe+NErKDdxvPCjV1Bu4njhR6+g3MTxwo9eQbmJ44UfvYJyE8cLP3oF5SaOF370CspNHC/86BWUmzhe+NErKDdxvPCjV1Bu4njhR6+g3MTxwo9eQbmJ44UfvYJyE8cLP3rl5CYBeeEC8sIF5IULyAuXrYB65eQmAXnhAvLCBeSFC8gLF5AXLiAvXEBeuIC8cAF54QLywgXkhQvICxeQFy4gL1xAXriAvHABeeEC8sIF5IULyAsXkBcuIC9cQF64gLxwAXnhAvLCBeSFC8gLF5AXLiAvXEBeuIC8cAF54QLywgXkhQvICxeQFy4gL1xAXriAvHABeeEC8sIF5IULyAsXkBcuIC9cQF64gLxwAXnhAvLCBeSFC8gLF5AXLiAvXEBeuIC8cAF54QLywgXkhQvICxeQFy4gL1xAXriAvHABeeEC8sIF5IULyAsXkBcuIC9cQF64gLxwAXnhAvLCBeSFC8gLF5AXLiAvXEBeuIC8cAF54QLywgXkhQvICxeQFy4gL1xAXriAvHABeeEC8sIF5IULyAsXkBcuIC88gbzwBPLCE8gLTyAvPG0F1CsnNyWQF55AXngCeeEJ5IUnkBeeQF54AnnhCeSFJ5AXnkBeeAJ54QnkhSeQF55AXngCeeEJ5IUnkBeeQF54AnnhCeSFJ5AXnkBeeAJ54QnkhSeQF55AXngCeeEJ5IUnkBeeQF54AnnhCeSFJ5AXnkBeeAJ54QnkhSeQF55AXngCeeEJ5IUnkBeeQF54AnnhCeSFJ5AXnkZ44TVfe92106vafrm11u2tdqn2s6DkraDsraDirSD1VpB5K6h6K6h5K+jx86Vt9VJQy6l7zdW3a257V36u/z/lD6CSX1q+xC4/Pbf8tBW7nsC7dMqXXcr1wXexcn5gp+P9uEt4SMf7Gvn9zX+0m1ntFla7ymrXWO1WVruN1e6OardurHaF1S4rVVVWqhqAHodql5Wq6kypykQu+59JvtPsTJmq2+xMiarb7Ex5qtdsmylNdZudKUt1m50pSXWbnSlHdZstpGZnylDdZp0nqGrbtdm9yG39rkPRZz/EbnL9ELult8/Tf36I3VxnosG9uo5EY3vdXSeiwb26DkSDe3Wdhz7dq10PktZuvmCzu45Dg3stoF5dh6HBvbrOQoN7nSs3nfc6V24673Wu3HTWa97myk3nvc6Vm8575eSmvHFyU94KqFdObsobJzfljZOb8sbJTXkD5SYB5SYB5SYB5SYB5aYBsHGcXkG5SUC5SUC5SUC5SUC5KYFyUwLlpgTKTQmUmwbAxnF6BeWmBMpNCZSbEig3JVBuyqDclEG5KYNyUwblpgGwcZxeQbkpg3JTBuWmDMpNGZSbCig3FVBuKqDcVEC5aQBsHKdXUG4qoNxUQLmpgHJTAeUmBeUmBeUmBeUmBeWmAdJznF5BuUlBuUlBuUlBuUlBuclAuclAucm3Gz64V1Bu8i2GD+4VlJt8W+GDewXlJt9K+OBeQbnJtw8+uFdQbvItgw/uFZSbfJvgg3sF5SbfGvjgXkG5ybcFPrhXUG7yLYEP7hWUm3w74IN7BeUm3wr44F5Bucm3AT64V1BumswLP+8VlJsm88LPewXlJpAXnkFeeAZ54RnkhWeQF55BXngGeeEZ5IUXkBdeQF54AXnhBeSFl62AeuXkpgLywgvICy8gL7yAvPAC8sILyAsvc3nh+3b9Lb5dbnudKjd1ei2gXqfKTZ1ep8pNnV6nyk2dXqfKTZ1ep8pN573O5YV3ep0qN3V6BeWmubzwTq8F1CsoN83lhXd6BeWmubzwTq+g3DSXF97pFZSb5vLCO72CctNcXninV1BumssL7/QKyk1zeeGdXkG5aS4vvNMrKDfN5YV3egXlprm88E6voNw0lxfe6RWUm+bywju9gnLTXF54p1dQbprLC+/0CspNc3nhnV5BuWkuL7zTKyg3zeWFd3oF5aa5vPBOr6DcNJcX3ukVlJvm8sI7vYJy01xeeKdXUG6aywvv9ArKTXN54Z1eQblpLi+80ysoN83lhXd6BeWmubzwTq+g3DSXF97pFZSb5vLCO72CctNcXninV1BumssL7/QKyk1zeeGdXkG5aS4vvNMrKDfN5YV3egXlprm88E6voNw0lxfe6RWUm+bywju9gnLTXF54p1dObtK5vPBOr5zcpHN54Z1eOblJtwLqlZObdC4vvNMrJzfpXF54p1dQbprLC+/0CspNIC9cQV64grxwBXnhCvLCFeSFK8gLV5AXriAvXEFeuIK8cAV54QrywhXkhSvIC1eQF64gL1xBXriCvHAFeeEK8sIV5IUryAtXkBeuIC9cQV64grxwBXnhCvLCFeSFK8gLV5AXriAvXEFeuIK8cAV54QrywhXkhSvIC1eQF64gL1xBXriCvHAFeeEK8sIV5IUryAtXkBeuIC9cQV64grxwBXnhCvLCFeSFK8gLV5AXriAvXEFeuIK8cAV54QrywhXkhSvIC1eQF64gL1xBXriCvHAFeeEK8sIV5IUryAtXkBeuIC9cQV64grxwBXnhCvLCFeSFK8gLV5AXriAvXEFeuIK8cAV54QrywhXkhSvIC1eQF24gL9xAXriBvHADeeG2FVCvnNxkIC/cQF64gbxwA3nhBvLCDeSFG8gLN5AXbiAv3EBeuIG8cAN54Qbywg3khRvICzeQF24gL9xAXriBvHADeeEG8sIN5IUbyAs3kBduIC/cQF64gbxwA3nhBvLCDeSFG8gLN5AXbiAv3EBeuIG8cAN54Qbywg3khRvICzeQF24gL9xAXriBvHADeeEG8sIN5IUbyAs3kBduIC/cQF64gbxwA3nhBvLCDeSFG8gLN5AXbiAv3EBeuIG8cAN54Qbywg3khRvICzeQF24gL9xAXriBvHADeeEG8sIN5IUbyAs3kBduIC/cQF64gbxwA3nhBvLCDeSFG8gLN5AXbiAv3EBeuIG8cAN54Qbywg3khRvICzeQF24gL9xAXriBvHADeeEG8sIN5IVXkBdeQV54BXnhFeSF162AeuXkpgrywivIC68gL7yCvPAK8sIryAuvIC+8grzwCvLCK8gLryAvvIK88ArywivIC68gL7yCvPAK8sIryAuvIC+8grzwCvLCK8gLryAvvIK88ArywivIC68gL7yCvPAK8sIryAuvIC+8grzwCvLCK8gLryAvvIK88ArywivIC68gL7yCvPAK8sIryAuvIC+8grzwCvLCK8gLryAvvIK88ArywivIC68gL7yCvPAK8sIryAuvIC+8grzwCvLCK8gLryAvvIK88ArywivIC68gL7yCvPAK8sIryAuvIC+8grzwCvLCK8gLryAvvIK88ArywivIC68gL7yCvPAK8sIryAuvIC+8grzwCvLCK8gLryAvvIK88ArywivIC68gL7yCvPAK8sIryAuvIC+8grzwCvLCK8gLbyAvvIG88AbywhvIC29bAfXKyU0N5IU3kBfeQF54A3nhDeSFN5AX3kBeeAN54Q3khTeQF95AXngDeeEN5IU3kBfeQF54A3nhDeSFN5AX3kBeeAN54Q3khTeQF95AXngDeeEN5IU3kBfeQF54A3nhDeSFN5AX3kBeeAN54Q3khTeQF95AXngDeeEN5IU3kBfeQF54A3nhDeSFN5AX3kBeeAN54Q3khTeQF95AXngDeeEN5IU3kBfeQF54A3nhDeSFN5AX3kBeeAN54Q3khTeQF95AXngDeeEN5IU3kBfeQF54A3nhDeSFN5AX3kBeeAN54Q3khTeQF95AXngDeeEN5IU3kBfeQF54A3nhDeSFN5AX3kBeeAN54Q3khTeQF95AXngDeeEN5IU3kBfeQF54A3nhDeSFN5AX3kBeeAN54Q3khTeQF76DvPAd5IXvT/fCc7kWn/fS6VV0b/ny4Cb7/r7XH/Xn4PUX1/VbStu1/qTSea01ub7WWtpvXmsK6tVAvVZQrw3U687p9emu9yt7lal6tXytu93kG/Gdb8b26jsLje21gHqdKzed9zpXbjrvda7cdN7rXLnpvNe5ctNpr2mu3HTeKyg3JVBuSqDc9HTX+5W9gnJTAuWmBMpNCZSbEig3ZVBuyqDclEG5KYNy09Nd71f2CspNGZSbMig3ZVBuyqDcVEC5qYByUwHlpgLKTU93vV/ZKyg3FVBuKqDcVEC5qYByk4Jyk4Jyk4Jyk4Jy09Nd71f2CspNCspNCspNCspNCspNBspNBspNBspNBspNT3e9X9krKDcZKDcZKDcZKDcZKDdVUG6qoNxUQbmpgnLT013vV/YKyk0VlJsqKDdVUG6qoNzUQLmpgXJTA+WmBspNT3e9X9krKDc1UG5qoNzUQLmpgXLTDspNOyg37aDctINy09Nd71f2CspNOyg37aDctINy0z5Vbjrzn8u2TZWbOr36zk01Xys5/veu73v9Ub/vLNSv33e+6ddfgtfvO4f06/edLfr1+84L/fp9Z4B+/b7P9W79zo3qfv3Bz1/nlnS//uDnr3PzuV9/8PPXuc3crz/4+evcUO7XH/z8dW4d9+sPfv46N4n79Qc/f53bwf36g5+/zo3ffv3Bz1/nFm+//uDnr3Mzt19/8PPXuW3brz/4+evcoO3XH/z8dW7F9usPfv46N1379Qc/f53bq/36g5+/zo3Ufv3Bz1/nlmm//uDnr3NztF9/8PPXuQ3arz/4+evc8OzXH/z8dW5t9usPfv46NzH79Qc/f53blf36g5+/zo3Jfv3Bz1/nFmS//uDnr3OzsV9/8PPXua3Yrz/4+evcQOzXH/z8dW4V9usPfv46NwX79Qc/f53bf/36g5+/zo2+fv3Bz1/nll6//uDnr3Pzrl9/8PPXuU3Xrz/4+evckOvXH/z8dW699esPfv46N9n69Qc/f53baf36g5+/zo2zfv3Bz1/nFlm//uDnr3MzrF9/8PPXue3Vrz/4+evc4OrXH/v8FedWVr/+2OevBPevJLh/JVvs81eC+1cS3L+S4P6VBPevJLh/JcH9KwnuX0lw/0qC+1cS3L+S4P6VBPevJLh/JcH9KwnuX0lw/0qC+1cS3L+S4P6VBPevJLh/JcH9KwnuX0lw/0qC+1cS3L+S4P6VBPevJLh/JcH9KwnuX0lw/0qC+1cS3L+S4P6VBPevJLh/JcH9KwnuX0lw/0qC+1cS3L+S4P6VBPevJLh/JcH9KwnuX0lw/0qC+1cS3L+S4P6VBPevJLh/JcH9KwnuX0lw/0qC+1cS3L+S4P6VBPevJLh/JcH9KwnuX0lw/0qC+1cS3L+S4P6VBPevJLh/JcH9KwnuX0lw/0qC+1cS3L+S4P6VBPevJLh/JcH9KwnuX0lw/0qC+1cS3L+S4P6VBPevJLh/JcH9KwnuX0lw/0qC+1cS3L+S4P6VBPevJLh/JcH9KwnuX6Xg/lUK7l+l4P5VCu5fpS32+ZuC+1cpuH+VgvtXKbh/lYL7Vym4f5WC+1cpuH+VgvtXKbh/lYL7Vym4f5WC+1cpuH+VgvtXKbh/lZz7V3YM+PLgllTe1397c9u3dKl7l7dm689efZ/VY3v1fa6P7bWAevWdF8b26jtbjO3Vdw4Z26vvzDK2V9f55uzW38v3zYv1y3edbvrluw4s/fJdZ5B++SV2+a6TQr9814d/v3zX53m/fNdHdL/8J5+6sut1zd6bdspX2/PPW2vd2vXWUn8u5c9GxUaXL7HLf/apuxW7vJq3XXrxdJdyffBdrJzH0+ONgFYuj348M/nmHaCnC2Qvbrew2lVWu8Zqt7Labax2d1S7T6fcXtyusNplpSplpaqnM3QvbpeVqnSmVGUil/3PJN9pdqZM1W12pkTVbXamPNVr1mZKU91mZ8pS3WZnSlLdZmfKUd1mC6nZmTJUt1nnCara9SsP+17ktn7XoShtOV8/ENqytc6T1eT6lY2W9uuNf354ZK4z0eBeXUeisb1W14locK+uA9HgXl3noU/3ateDpLWbr5NV13FocK8F1KvrMDS4V9dZaHCvc+Wm817nyk3nvc6Vm057bXPlpvNe58pN572CclMD5aank5yv7BWUmxooNzVQbmqg3NRAuWkH5aYdlJt2UG7aQbnp6ZTqK3sF5aYdlJt2UG7aQblp5+SmvHFyU944uSlvnNyUN05uylsB9crJTXnj5Ka8cXJT3ji5KW+g3CSg3CSg3CSg3CSg3PR0uviVvYJyk4Byk4Byk4Byk4ByUwLlpgTKTQmUmxIoNz2de35lr6DclEC5KYFyUwLlpgTKTRmUmzIoN2VQbsqg3PR0z/qVvYJyUwblpgzKTRmUmzIoNxVQbiqg3OTbDR/cKyg3+RbDB/cKyk2+rfDBvYJyk28lfHCvoNzk2wcf3CsoN/mWwQf3CspNvk3wwb2CcpNvDXxwr6Dc5NsCH9wrKDf5lsAH9wrKTb4d8MG9gnKTbwV8cK+g3OTbAB/cKyg3TeaFn/cKyk2TeeHnvYJyE8gLzyAvPIO88AzywjPIC88gLzyDvPAM8sIzyAvPIC88g7zwDPLCM8gLzyAvPIO88AzywjPIC88gLzyDvPAM8sLzXF74vl1/i2+X216nyk2dXguo16lyU6fXqXJTp9epclOn16lyU6fXqXLTaa9lLi+80+tUuanTKyc3lbm88E6vBdQrJzeVubzwTq+c3FTm8sI7vYJy01xeeKdXUG6aywvv9ArKTXN54Z1eQblpLi+80ysoN83lhXd6BeWmubzwTq+g3DSXF97pFZSb5vLCO72CctNcXninV1BumssL7/QKyk1zeeGdXkG5aS4vvNMrKDfN5YV3egXlprm88E6voNw0lxfe6RWUm+bywju9gnLTXF54p1dQbprLC+/0CspNc3nhnV5BuWkuL7zTKyg3zeWFd3oF5aa5vPBOr6DcNJcX3ukVlJvm8sI7vYJy01xeeKdXUG6aywvv9ArKTXN54Z1eQblpLi+80ysoN83lhXd6BeWmubzwTq+g3DSXF97pFZSb5vLCO72CctNcXninV1BumssL7/QKyk1zeeGdXkG5aS4vvNMrKDfN5YV3egXlprm88E6voNw0lxfe6RWUm+bywju9gnLTXF54p1dQbgJ54QXkhReQF15AXngBeeEF5IUXkBdeQF64grxwBXnhCvLCFeSF61ZAvXJyk4K8cAV54QrywhXkhSvIC1eQF64gL1xBXriCvHAFeeEK8sIV5IUryAtXkBeuIC9cQV64grxwBXnhCvLCFeSFK8gLV5AXriAvXEFeuIK8cAV54QrywhXkhSvIC1eQF64gL1xBXriCvHAFeeEK8sIV5IUryAtXkBeuIC9cQV64grxwBXnhCvLCFeSFK8gLV5AXriAvXEFeuIK8cAV54QrywhXkhSvIC1eQF64gL1xBXriCvHAFeeEK8sIV5IUryAtXkBeuIC9cQV64grxwBXnhCvLCFeSFK8gLV5AXriAvXEFeuIK8cAV54QrywhXkhSvIC1eQF64gL1xBXriCvHAFeeEK8sIV5IUryAtXkBeuIC9cQV64grxwBXnhCvLCFeSFK8gLV5AXbiAv3EBeuIG8cAN54bYVUK+c3GQgL9xAXriBvHADeeEG8sIN5IUbyAs3kBduIC/cQF64gbxwA3nhBvLCDeSFG8gLN5AXbiAv3EBeuIG8cAN54Qbywg3khRvICzeQF24gL9xAXriBvHADeeEG8sIN5IUbyAs3kBduIC/cQF64gbxwA3nhBvLCDeSFG8gLN5AXbiAv3EBeuIG8cAN54Qbywg3khRvICzeQF24gL9xAXriBvHADeeEG8sIN5IUbyAs3kBduIC/cQF64gbxwA3nhBvLCDeSFG8gLN5AXbiAv3EBeuIG8cAN54Qbywg3khRvICzeQF24gL9xAXriBvHADeeEG8sIN5IUbyAs3kBduIC/cQF64gbxwA3nhBvLCDeSFG8gLN5AXbiAv3EBeuIG8cAN54Qbywg3khVeQF15BXngFeeEV5IXXrYB65eSmCvLCK8gLryAvvIK88ArywivIC68gL7yCvPAK8sIryAuvIC+8grzwCvLCK8gLryAvvIK88ArywivIC68gL7yCvPAK8sIryAuvIC+8grzwCvLCK8gLryAvvIK88ArywivIC68gL7yCvPAK8sIryAuvIC+8grzwCvLCK8gLryAvvIK88ArywivIC68gL7yCvPAK8sIryAuvIC+8grzwCvLCK8gLryAvvIK88ArywivIC68gL7yCvPAK8sIryAuvIC+8grzwCvLCK8gLryAvvIK88ArywivIC68gL7yCvPAK8sIryAuvIC+8grzwCvLCK8gLryAvvIK88ArywivIC68gL7yCvPAK8sIryAuvIC+8grzwCvLCK8gLryAvvIK88ArywivIC68gL7yCvPAK8sIryAtvIC+8gbzwBvLCG8gLb1sB9crJTQ3khTeQF95AXngDeeEN5IU3kBfeQF54A3nhDeSFN5AX3kBeeAN54Q3khTeQF95AXngDeeEN5IU3kBfeQF54A3nhDeSFN5AX3kBeeAN54Q3khTeQF95AXngDeeEN5IU3kBfeQF54A3nhDeSFN5AX3kBeeAN54Q3khTeQF95AXngDeeEN5IU3kBfeQF54A3nhDeSFN5AX3kBeeAN54Q3khTeQF95AXngDeeEN5IU3kBfeQF54A3nhDeSFN5AX3kBeeAN54Q3khTeQF95AXngDeeEN5IU3kBfeQF54A3nhDeSFN5AX3kBeeAN54Q3khTeQF95AXngDeeHt6V54Ltfi8146vYruLV8e3GTf3/f6o/4cvP7iun5LabvWn1Q6r7Um19daS/vNa01BvRqo1wrqtYF63Tm9Pt31fmWvMlWvlq91t5t8s/vON2N79Z2FxvZaQL3OlZvOe50rN533OlduOu91rtx03utcuems132bKzed98rJTfvGyU37xslN+1ZAvXJy075xctO+cXLTvnFy076BcpOAcpOAcpOAcpOActPTXe9X9grKTQLKTQLKTQLKTQLKTQmUmxIoNyVQbkqg3PR01/uVvYJyUwLlpgTKTQmUmxIoN2VQbsqg3JRBuSmDctPTXe9X9grKTRmUmzIoN2VQbsqg3FRAuamAclMB5aYCyk1Pd71f2SsoNxVQbiqg3FRAuamAcpOCcpOCcpOCcpOCctPTXe9X9grKTQrKTQrKTQrKTQrKTQbKTQbKTQbKTQbKTU93vV/ZKyg3GSg3GSg3GSg3GSg3VVBuqqDcVEG5qYJy09Nd71f2CspNFZSbKig3VVBuqlPlplP/eW9T5aZOr75zU83XSo7/vev7Xn/U7zsL9ev3nW/69Zfg9fvOIf36fWeLfv2+80K/ft8ZoF+/73O9W79zo7pff/Dz17kl3a8/+Pnr3Hzu1x/8/HVuM/frD37+OjeU+/WHPn91c24d9+sPff4e9Yc+f4/6Q5+/R/2hz9+j/tDn71F/6PP3qD/0+XvUH/r8PeoPfv46N3P79Qc/f53btv36g5+/zg3afv3Bz1/nVmy//uDnr3PTtV9/8PPXub3arz/4+evcSO3XH/z8dW6Z9usPfv46N0f79Qc/f53boP36g5+/zg3Pfv3Bz1/n1ma//uDnr3MTs19/8PPXuV3Zrz/4+evcmOzXH/z8dW5B9usPfv46Nxv79Qc/f53biv36g5+/zg3Efv3Bz1/nVmG//uDnr3NTsF9/8PPXuf3Xrz/4+evc6OvXH/z8dW7p9esPfv46N+/69Qc/f53bdP36g5+/zg25fv3Bz1/n1lu//uDnr3OTrV9/8PPXuZ3Wrz/4+evcOOvXH/z8dW6R9esPfv46N8P69Qc/f53bXv36g5+/zg2ufv3Bz1/nVla//uDnb2z/6qg/+Pkb27866g9+/sb2r476g5+/sf2ro/7g529s/+qoP/j5G9u/OuoPfv7G9q+O+oOfv7H9q6P+4OdvbP/qqD/2+SvB/SsJ7l9JcP9KgvtXssU+fyW4fyXB/SsJ7l9JcP9KgvtXEty/kuD+lQT3ryS4fyXB/SsJ7l9JcP9KgvtXEty/kuD+lQT3ryS4fyXB/SsJ7l9JcP9KgvtXEty/kuD+lQT3ryS4fyXB/SsJ7l9JcP9KgvtXEty/kuD+lQT3ryS4fyXB/SsJ7l9JcP9KgvtXEty/kuD+lQT3ryS4fyXB/SsJ7l9JcP9KgvtXEty/kuD+lQT3ryS4fyXB/SsJ7l9JcP9KgvtXEty/kuD+lQT3ryS4fyXB/SsJ7l9JcP9KgvtXEty/kuD+lQT3ryS4fyXB/SsJ7l9JcP9KgvtXEty/kuD+lQT3ryS4fyXB/SsJ7l9JcP9KgvtXEty/kuD+lQT3ryS4fyXB/SsJ7l9JcP9KgvtXEty/kuD+lQT3ryS4fyXB/SsJ7l9JcP9KgvtXEty/kuD+VQruXyXn/pWltF0e3JLK+/pvb277li517/LWbP3Zq++zemyvvs/1sb0WUK++88LYXn1ni7G9+s4hY3v1nVnG9uo635zd+nv5vnmxfvmu002/fNeBpV++6wzSL7/ELt91UuiX7/rw75fv+jzvl+/6iO6X/+RT93gb77pm70075avt+eettW7temupP5fyZ6Nio8uX2OU/+9Tdil1ezdsuvXi6S7k++C5WzuNpSrmVy6OnIvnmHaCnC2Qvbrew2lVWu8Zqt7Labax2d1S7T6fcXtyusNplparMSlVPZ+he3C4rVeWZUpWJXPY/k3yn2ZkyVbfZmRJVt9mZ8lSv2TJTmuo2O1OW6jY7U5LqNjtTjuo2W0jNzpShus06T1DVrl952Pcit/W7DkVpy/n6gdCWrXWerCbXr2y0tF9v/PPDo+I6Ew3u1XUkGturuk5Eg3t1HYgG9+o6D326V7seJK3dfJ1MXcehwb0WUK+uw9DgXl1nocG9zpWbznudKzed9zpXbjrt1ebKTee9zpWbznsF5SYD5aank5yv7BWUmwyUmwyUmwyUmwyUmyooN1VQbqqg3FRBuenplOorewXlpgrKTRWUmyooN1VQbmqg3NRAuamBclMD5aanE7iv7BWUmxooNzVQbmqg3NRAuWkH5aYdlJt2UG7aQbnp6XTxK3sF5aYdlJt2UG7aQblp5+SmvHFyU944uSlvnNyUN05uylsB9crJTXnj5Ka8cXJT3ji5KW+g3CSg3CSg3CSg3CSg3PR0z/qVvYJyk4Byk4Byk4Byk4ByUwLlpgTKTb7d8MG9gnKTbzF8cK+g3OTbCh/cKyg3+VbCB/cKyk2+ffDBvYJyk28ZfHCvoNzk2wQf3CsoN/nWwAf3CspNvi3wwb2CcpNvCXxwr6Dc5NsBH9wrKDf5VsAH9wrKTb4N8MG9gnLTZF74ea+g3DSZF37eKyg3gbzwDPLCM8gLzyAvPIO88AzywjPIC88gLzyDvPAM8sIzyAvPIC88g7zwDPLCM8gLzyAvPIO88AzywjPIC88gLzzP5YXv2/W3+Ha57XWq3NTptYB6nSo3dXqdKjd1ep0qN3V6nSo3dXqdKjed9zqXF97pdarc1OkVlJvm8sI7vRZQr6DcNJcX3ukVlJvm8sI7vYJy01xeeKdXUG6aywvv9ArKTXN54Z1eQblpLi+80ysoN83lhXd65eSmMpcX3umVk5vKXF54p1dObipbAfXKyU1lLi+80ysnN5W5vPBOr6DcNJcX3ukVlJvm8sI7vYJy01xeeKdXUG6aywvv9ArKTXN54Z1eQblpLi+80ysoN83lhXd6BeWmubzwTq+g3DSXF97pFZSb5vLCO72CctNcXninV1BumssL7/QKyk1zeeGdXkG5aS4vvNMrKDfN5YV3egXlprm88E6voNw0lxfe6RWUm+bywju9gnLTXF54p1dQbprLC+/0CspNc3nhnV5BuWkuL7zTKyg3zeWFd3oF5aa5vPBOr6DcNJcX3ukVlJvm8sI7vYJy01xeeKdXUG6aywvv9ArKTXN54Z1eQblpLi+80ysoN83lhXd6BeUmkBdeQF54AXnhBeSFF5AXXkBeeAF54QXkhReQF15AXngBeeEF5IUXkBdeQF54AXnhBeSFF5AXXkBeeAF54QXkhReQF15AXngBeeEF5IUXkBdeQF54AXnhBeSFK8gLV5AXriAvXEFeuG4F1CsnNynIC1eQF64gL1xBXriCvHAFeeEK8sIV5IUryAtXkBeuIC9cQV64grxwBXnhCvLCFeSFK8gLV5AXriAvXEFeuIK8cAV54QrywhXkhSvIC1eQF64gL1xBXriCvHAFeeEK8sIV5IUryAtXkBeuIC9cQV64grxwBXnhCvLCFeSFK8gLV5AXriAvXEFeuIK8cAV54QrywhXkhSvIC1eQF64gL1xBXriCvHAFeeEK8sIV5IUryAtXkBeuIC9cQV64grxwBXnhCvLCFeSFK8gLV5AXriAvXEFeuIK8cAV54QrywhXkhSvIC1eQF64gL1xBXriCvHAFeeEK8sIV5IUryAtXkBeuIC9cQV64grxwBXnhCvLCFeSFK8gLV5AXriAvXEFeuIK8cAV54Qbywg3khRvICzeQF25bAfXKyU0G8sIN5IUbyAs3kBduIC/cQF64gbxwA3nhBvLCDeSFG8gLN5AXbiAv3EBeuIG8cAN54Qbywg3khRvICzeQF24gL9xAXriBvHADeeEG8sIN5IUbyAs3kBduIC/cQF64gbxwA3nhBvLCDeSFG8gLN5AXbiAv3EBeuIG8cAN54Qbywg3khRvICzeQF24gL9xAXriBvHADeeEG8sIN5IUbyAs3kBduIC/cQF64gbxwA3nhBvLCDeSFG8gLN5AXbiAv3EBeuIG8cAN54Qbywg3khRvICzeQF24gL9xAXriBvHADeeEG8sIN5IUbyAs3kBduIC/cQF64gbxwA3nhBvLCDeSFG8gLN5AXbiAv3EBeuIG8cAN54Qbywg3khRvICzeQF24gL9xAXngFeeEV5IVXkBdeQV543QqoV05uqiAvvIK88ArywivIC68gL7yCvPAK8sIryAuvIC+8grzwCvLCK8gLryAvvIK88ArywivIC68gL7yCvPAK8sIryAuvIC+8grzwCvLCK8gLryAvvIK88ArywivIC68gL7yCvPAK8sIryAuvIC+8grzwCvLCK8gLryAvvIK88ArywivIC68gL7yCvPAK8sIryAuvIC+8grzwCvLCK8gLryAvvIK88ArywivIC68gL7yCvPAK8sIryAuvIC+8grzwCvLCK8gLryAvvIK88ArywivIC68gL7yCvPAK8sIryAuvIC+8grzwCvLCK8gLryAvvIK88ArywivIC68gL7yCvPAK8sIryAuvIC+8grzwCvLCK8gLryAvvIK88ArywivIC68gL7yCvPAK8sIryAuvIC+8grzwBvLCG8gLbyAvvIG88LYVUK+c3NRAXngDeeEN5IU3kBfeQF54A3nhDeSFN5AX3kBeeAN54Q3khTeQF95AXngDeeEN5IU3kBfeQF54A3nhDeSFN5AX3kBeeAN54Q3khTeQF95AXngDeeEN5IU3kBfeQF54A3nhDeSFN5AX3kBeeAN54Q3khTeQF95AXngDeeEN5IU3kBfeQF54A3nhDeSFN5AX3kBeeAN54e3pXngu1+LzXjq9iu4tXx7cZN/f9/qj/hy8/uK6fktpu9afVDqvtSbX19rxbvzNa01BvRqo1wrqtYF63Tm9Pt31fmWvMlWvlq91t5t8Y77zzdhefWehsb0WUK9z5abzXufKTee9zpWbznudKzed9zpXbjrttc6Vm857BeWmCspNFZSbnu56v7JXUG6qoNxUQbmpgnJTBeWmBspNDZSbGig3NVBuerrr/cpeQbmpgXJTA+WmBspNDZSbdlBu2kG5aQflph2Um57uer+yV1Bu2kG5aQflph2Um3ZObto3Tm7aN05u2jdObto3Tm7atwLqlZOb9o2Tm/aNk5v2jZOb9g2UmwSUmwSUmwSUmwSUm57uer+yV1BuElBuElBuElBuElBuSqDclEC5KYFyUwLlpqe73q/sFZSbEig3JVBuSqDclEC5KYNyUwblpgzKTRmUm57uer+yV1BuyqDclEG5KYNyUwblpgLKTQWUmwooNxVQbnq66/3KXkG5qYByUwHlpgLKTcV3bqr5Wsnxv3d93+v3+tV3FurX7zvf9Ov3nVn69fvOIf36S/D6feeFfv2+M0C/ft/ner9+32d1v/7g569zS7pff/Dz17n53K8/+Pnr3Gbu1x/8/HVuKPfrD37+OreO+/UHP3+dm8T9+oOfv87t4H79wc9f58Zvv/7g569zi7dff/Dz17mZ268/+Pnr3Lbt1x/8/HVu0PbrD37+Ordi+/UHP3+dm679+oOfv87t1X79wc9f50Zqv/7g569zy7Rff/Dz17k52q8/+Pnr3Abt1x/8/HVuePbrD33+2ubc2uzXH/r8PeoPff4e9Yc+f4/6Q5+/R/2hz9+j/tDn71F/6PP3qD/0+XvUH/z8dW429usPfv46txX79Qc/f50biP36g5+/zq3Cfv3Bz1/npmC//uDnr3P7r19/8PPXudHXrz/4+evc0uvXH/z8dW7e9esPfv46t+n69Qc/f50bcv36g5+/zq23fv3Bz1/nJlu//uDnr3M7rV9/8PPXuXHWrz/4+evcIuvXH/z8dW6G9esPfv46t7369Qc/f50bXP36g5+/zq2sfv3Bz9/Y/tVRf/DzN7Z/ddQf/PyN7V8d9Qc/f2P7V0f9wc/f2P7VUX/w8ze2f3XUH/z8je1fHfUHP39j+1dH/cHP39j+1VF/8PM3tn911B/8/I3tXx31Bz9/Y/tXR/3Bz9/Y/tVRf/DzN7Z/ddQf/PyN7V8d9Qc/f2P7V0f9wc/f2P7VUX/w8ze2f3XUH/z8je1fHfUHP39j+1dH/cHP39j+1VF/8PM3tn911B/8/I3tXx31Bz9/Y/tXR/3Bz9/Y/tVRf+zzV4L7VxLcv5Lg/pUE969ki33+SnD/SoL7VxLcv5Lg/pUE968kuH8lwf0rCe5fSXD/SoL7VxLcv5Lg/pUE968kuH8lwf0rCe5fSXD/SoL7VxLcv5Lg/pUE968kuH8lwf0rCe5fSXD/SoL7VxLcv5Lg/pUE968kuH8lwf0rCe5fSXD/SoL7VxLcv5Lg/pUE968kuH8lwf0rCe5fSXD/SoL7VxLcv5Lg/pUE968kuH8lwf0rCe5fSXD/SoL7VxLcv5Lg/pUE968kuH8lwf0rCe5fSXD/SoL7VxLcv5Lg/pUE968kuH8lwf0rCe5fyQD/ak/bpaJtk079TSX/vHVT3d5uLXLv1qlcb5126dw6q/28cUlvj5zs3hhrutw21dK5sdSWr8/Qljo33q6PLFvV9zf+PvABYNca+KcGLmvgzx34w5EsbaLXgZfeJdGOJ+Xy0Enq+0vcnYdOuZXLY6ci+eaK+LiI9tryS+zyNXb5Frv8Grv8Frv8PXT5j1Nory1fYpcf+9RtsU/d4AyaBGfQJDKDdvzDv/z9z3/5y5//9//8y9/+9Y//+PPf/vof3+68ffv/3f9+bW2Xh3tfasn3XrylXtK6vnvh5uMv5Jjc/a+/jnv48rUPr1/78Pa1D1+/9uHb5x7+2132T9/l/vf/zu9y96Bt+XqXKp2+87XvXOvNw6evffj8tQ9fvvbh9Wsf3r724evXPnz72offv/Th738TaNzDf+1frX7tX61+7V+tfu1frX7tX61+7V+tfu1frX7tX609PPuyXXaHstnNwz9cvRa5hACrvVKu57K+K0WO95q/lbK7KaVufkoRP6UkP6VkP6UUP6Won1LMTynVTyl+rrbVz9W2+bnaNj9X2+bnatv8XG2bn6tt83O1bU+9rmi6BErN8ttS9qf+BWlJl9uWdlPK439BUq+ltF6K3/d8zdnvnqIs2/disqdiiqdi9JnFlC3LtZhSbooxT8VUT8W05xZT92sxe7opZndUzAcI+cuqEVfVpFdVczwtt9VkV9UUV9U89zqc5PLAJWW5rcZcVVNdVdNcVfPca3F69x1U22+qkc1VNeKqmuSqmudei/Pb2+D53RdurtUUV9Woq2rMVTX1ZdUkva2muapm91RNeu61uFz/U4ZS1G6rEVfVJFfVZFfVPPdaXNp17y17ua1GXVVjrqqprqp57rVY03Wf0nK7+abdUzV5c1WNuKomvawavd3Dc3ZVTXFVzXOvxWbXDcbq7QaTzVU11VU1zVU1z70W17dcXKXdVFM2V9WIq2qSq2qeey2ues3F1W4331JcVaOuqjFX1dSXVVNv9/DSXFWze6pGv/Ba/P3x5YsfP33x4+cvfvyHr2lWLpHRdL99fP3ix7cvfvz6tY//3K+vnn51SJ77/VXVt9vabS3mqJbqqJbmqJbdTy3P/RJrpxZxVMtTv8Z6+n1Aee73WDu1FEe1qKNazFEt1VEtzVEtu59a9s1RLX6++yy7o+vu7ui6uzu67u6Orru7o+vu7ue6mx7/bu/pf3+bHv+27rsP001vHz998ePnL3788sWP//h/X53fPnq48/zaFz9+/eLHb1/8+PvXPv7j3wftPL588eOngY9f0+3j5y9+/PLFj//432+6fqkk59vHty9+/PrFj9+++PH3r338x79D2Hl8+eLHT1/8+PmLH7988eN/8d9v+uK/3/TFf7/pi/9+0xf//eav/Ps9/km+3fL+ISObXO4pW36Lft8+57+58dsXAaqk9zf9tpDo1z68Pf7w+ZJxa9l/+/B1wMNfVqRq+bcP37724ffHH75dPgCre/3Nw98/XsY9vDz88O2q3bfy21fO/cPlkw9/UWvbu29i/3z4/PjD18tT226HUwY+/P6bP6vjH9LJpUG2yx2P/9l+31+MFL3ex6xT2KYX37dt9d2Lev9eWv520/uvPd2vfwzvPq5t9fv9yvf73Zei8379F75NbU8fv05O75E/fY/y6Xvop+9hn75H/fQ92qfvsX/2Hh8citfvvrZ3b0R9+2+qb26a7fJSzO3txZXK9/esPvhy9ahHT1/66PlTj/7PHxm/p/fQT9/DPn2P+ul7tE/fY//sPcr26XvIp++RPn2P+8/5lTxv+/67X1G1/PYV9cGXJkc9un7po9uXPnr90kdvX/ro+1c++gdfChz16DLu0W+voB98IXDUo+cvffS7f6v7NQHvuf7m2nH/632n97BP36N++h7t0/fYP3uP+7/8enoP+ew97oufp/fIn77H3ec8XbN2evcB3s+Xyf3vCZ7fxT5/l/r5u7TP32X/9F3uf9Xs/C53n/pUL9/MTfvN3+L9L26d3yV//i7l83fRz9/FPn+X+sm7HP+k32553w7e62Wp3du7/3B127+/BuTzd0mfv0v+/F3K5++in7+Lff4u9fN3aZ+/y/7pu7TPP/vt889++/yz3z7/7LfPP/vt889++/yz3z7/7N//+tx+/Wr83urNXfZP3+X+l9HO7yKfv0v6/F3y5+9SPnmX45/s+ztu9981rG9v69V3n+N+f2Pr+Kf/88e///mP//KXP3376aFv/4//+dd/vfwS0fGP//i//375f7n8VtG///1v//qnf/vPv//p268Wvf1g0bdnIGn+JdXyz9/fZ/sf6XhvPJX8z9+oqm//WMrxj/u3f/w2+lT1uG19+yjh+23qLzm9vYX44zF/ydv1rbsf/6fjcdv1Xbnv/6cj3Nbt8tD79suerufCt1K0/WLtUshuvxzvdb6N7dv/TY5ijn/Lfx8z+X8=",
+      "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": "ff6671ddb572df3d961df43ed4c3adf75a7d3763-8cb9b5d75fb0c03d02ef0128073ac4df-client-ivc-true"
+      "verification_key": "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",
+      "artifact_hash": "e7552d296af009c9ed2e2ca261de6124cad0b1c1-daea7ec3fa031eaeae050c3deaddeb83-client-ivc-true"
     }
   ],
   "outputs": {
     "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": [
             {
@@ -3699,6 +3756,33 @@
           ],
           "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"
         }
       ]
     }
@@ -3733,88 +3817,88 @@
       "source": "pub fn panic<T, U, let N: u32>(message: fmtstr<N, T>) -> U {\n    assert(false, message);\n    crate::mem::zeroed()\n}\n"
     },
     "66": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/utils/array/subarray.nr",
+      "source": "/// Returns `DST_LEN` elements from a source array, starting at `offset`. `DST_LEN` must be large enough to hold all of\n/// the elements past `offset`.\n///\n/// Example:\n/// ```\n/// let foo: [Field; 2] = subarray([1, 2, 3, 4, 5], 2);\n/// assert_eq(foo, [3, 4]);\n/// ```\npub fn subarray<let SRC_LEN: u32, let DST_LEN: u32>(\n    src: [Field; SRC_LEN],\n    offset: u32,\n) -> [Field; DST_LEN] {\n    assert(offset + DST_LEN <= SRC_LEN, \"offset too large\");\n\n    let mut dst: [Field; DST_LEN] = std::mem::zeroed();\n    for i in 0..DST_LEN {\n        dst[i] = src[i + offset];\n    }\n\n    dst\n}\n\nmod test {\n    use super::subarray;\n\n    #[test]\n    unconstrained fn subarray_into_empty() {\n        // In all of these cases we're setting DST_LEN to be 0, so we always get back an emtpy array.\n        assert_eq(subarray([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 2), []);\n    }\n\n    #[test]\n    unconstrained fn subarray_complete() {\n        assert_eq(subarray([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), [1, 2, 3, 4, 5]);\n    }\n\n    #[test]\n    unconstrained fn subarray_different_end_sizes() {\n        // We implicitly select how many values to read in the size of the return array\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4, 5]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2]);\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subarray_offset_too_large() {\n        // With an offset of 1 we can only request up to 4 elements\n        let _: [_; 5] = subarray([1, 2, 3, 4, 5], 1);\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subarray_bad_return_value() {\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [3, 3, 4, 5]);\n    }\n}\n"
+    },
+    "98": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/context/private_context.nr",
       "source": "use dep::protocol_types::debug_log::debug_log_format;\n\nuse 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        block_header::get_block_header_at,\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        key_validation_request::get_key_validation_request,\n        returns::pack_returns,\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        log::Log,\n        log_hash::LogHash,\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::PrivateLogData,\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    block_header::BlockHeader,\n    constants::{\n        MAX_CONTRACT_CLASS_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_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_DISPATCH_SELECTOR,\n    },\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: BlockHeader,\n\n    pub private_logs: BoundedVec<PrivateLogData, MAX_PRIVATE_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            private_logs: 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        // WARNING(https://github.com/AztecProtocol/aztec-packages/issues/10558): if you delete this debug_log_format line, some tests fail.\n        debug_log_format(\n            \"Context.note_hashes, after pushing new note hash: {0}\",\n            self.note_hashes.storage().map(|nh: NoteHash| nh.value),\n        );\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_block_header(self) -> BlockHeader {\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_block_header_at(self, block_number: u32) -> BlockHeader {\n        get_block_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            private_logs: self.private_logs.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    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn emit_raw_note_log(\n        &mut self,\n        log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n        note_hash_counter: u32,\n    ) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n        self.private_logs.push(private_log);\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: BlockHeader::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
     },
-    "87": {
+    "137": {
       "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"
     },
-    "88": {
+    "145": {
       "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"
     },
-    "91": {
+    "150": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/notes.nr",
-      "source": "use crate::{note::{note_header::NoteHeader, note_interface::NoteInterface}, utils::array};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\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\n            let nonce = fields[read_offset];\n            let note_hash_counter = fields[read_offset + 1] as u32;\n            let note_content = array::subarray(fields, read_offset + 2);\n\n            let mut note = Note::deserialize_content(note_content);\n            note.set_header(NoteHeader { contract_address, nonce, storage_slot, note_hash_counter });\n\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, ready to be included in a log.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n    get_app_tagging_secret_as_sender(sender, recipient).compute_tag(recipient)\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"
+      "source": "use crate::{note::{note_header::NoteHeader, note_interface::NoteInterface}, utils::array};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\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\n            let nonce = fields[read_offset];\n            let note_hash_counter = fields[read_offset + 1] as u32;\n            let note_content = array::subarray(fields, read_offset + 2);\n\n            let mut note = Note::deserialize_content(note_content);\n            note.set_header(NoteHeader { contract_address, nonce, storage_slot, note_hash_counter });\n\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_indexed_tagging_secret_as_sender`, except it returns the derived tag, ready to be included in a log.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n    get_indexed_tagging_secret_as_sender(sender, recipient).compute_tag(recipient)\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 ivsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_indexed_tagging_secret_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n    let result = get_indexed_tagging_secret_as_sender_oracle(sender, recipient);\n    IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getIndexedTaggingSecretAsSender)]\nunconstrained fn get_indexed_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": {
+    "151": {
       "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"
     },
-    "111": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/utils/array/subarray.nr",
-      "source": "/// Returns `DST_LEN` elements from a source array, starting at `offset`. `DST_LEN` must be large enough to hold all of\n/// the elements past `offset`.\n///\n/// Example:\n/// ```\n/// let foo: [Field; 2] = subarray([1, 2, 3, 4, 5], 2);\n/// assert_eq(foo, [3, 4]);\n/// ```\npub fn subarray<let SRC_LEN: u32, let DST_LEN: u32>(\n    src: [Field; SRC_LEN],\n    offset: u32,\n) -> [Field; DST_LEN] {\n    assert(offset + DST_LEN <= SRC_LEN, \"offset too large\");\n\n    let mut dst: [Field; DST_LEN] = std::mem::zeroed();\n    for i in 0..DST_LEN {\n        dst[i] = src[i + offset];\n    }\n\n    dst\n}\n\nmod test {\n    use super::subarray;\n\n    #[test]\n    unconstrained fn subarray_into_empty() {\n        // In all of these cases we're setting DST_LEN to be 0, so we always get back an emtpy array.\n        assert_eq(subarray([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 2), []);\n    }\n\n    #[test]\n    unconstrained fn subarray_complete() {\n        assert_eq(subarray([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), [1, 2, 3, 4, 5]);\n    }\n\n    #[test]\n    unconstrained fn subarray_different_end_sizes() {\n        // We implicitly select how many values to read in the size of the return array\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4, 5]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2]);\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subarray_offset_too_large() {\n        // With an offset of 1 we can only request up to 4 elements\n        let _: [_; 5] = subarray([1, 2, 3, 4, 5], 1);\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subarray_bad_return_value() {\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [3, 3, 4, 5]);\n    }\n}\n"
-    },
-    "175": {
+    "156": {
       "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"
     },
     "176": {
-      "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};\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 ec::{pow, sqrt};\nuse std::embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key};\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\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 compute_preaddress_from_partial_and_pub_keys() {\n    let pre_address = poseidon2_hash_with_separator([1, 2], GENERATOR_INDEX__CONTRACT_ADDRESS_V1);\n    let expected_computed_preaddress_from_partial_and_pubkey =\n        0x23ce9be3fa3c846b0f9245cc796902e731d04f086e8a42473bb29e405fc98075;\n    assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\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"
+      "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"
     },
-    "241": {
+    "196": {
       "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"
     },
-    "309": {
-      "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"
+    "269": {
+      "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};\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 ec::{pow, sqrt};\nuse std::embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key};\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\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 compute_preaddress_from_partial_and_pub_keys() {\n    let pre_address = poseidon2_hash_with_separator([1, 2], GENERATOR_INDEX__CONTRACT_ADDRESS_V1);\n    let expected_computed_preaddress_from_partial_and_pubkey =\n        0x23ce9be3fa3c846b0f9245cc796902e731d04f086e8a42473bb29e405fc98075;\n    assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\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"
+    },
+    "284": {
+      "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, ScopedLogHash},\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::scoped::Scoped,\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::{arrays::array_concat, 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, siloed_note_hash: Field) -> Field {\n    let inputs = [nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n    siloed_note_hash: Field,\n    tx_hash: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    if siloed_note_hash == 0 {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(tx_hash, note_index_in_tx);\n        compute_unique_note_hash(nonce, 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) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\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 compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n    poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped<PrivateLogData>) -> PrivateLog {\n    if private_log.contract_address.is_zero() {\n        private_log.inner.log\n    } else {\n        let mut fields = private_log.inner.log.fields;\n        fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n        PrivateLog { fields }\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    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n    sponge.squeeze()\n}\n\n// NB the below is the same as std::hash::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n//  - absorb normally up to 2 times to set cache_size to 1\n//  - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n//  - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n) -> std::hash::poseidon2::Poseidon2 {\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    // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n    // since we cannot isolate computation branches. The below is just to avoid that.\n    let shift = if in_len == 0 { 0 } else { 1 };\n    if in_len != 0 {\n        // cache_size = 0, init absorb\n        sponge.cache[0] = input[0];\n        sponge.cache_size = 1;\n        // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n        // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n        // max_remainder = (N - 1) % 3;\n        // max_chunks = (N - 1 - max_remainder) / 3;\n        sponge = poseidon2_absorb_chunks_loop::<N, (N - 1 - (N - 1) % 3) / 3>(\n            sponge,\n            input,\n            in_len,\n            variable,\n            shift,\n        );\n    }\n    sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge<let N: u32>(\n    in_sponge: std::hash::poseidon2::Poseidon2,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> std::hash::poseidon2::Poseidon2 {\n    let mut sponge = in_sponge;\n    // 'shift' is to account for already added inputs\n    let mut shift = 0;\n    // 'stop' is to avoid an underflow when inputting in_len = 0\n    let mut stop = false;\n    for i in 0..3 {\n        if shift == in_len {\n            stop = true;\n        }\n        if (sponge.cache_size != 1) & (!stop) {\n            sponge.absorb(input[i]);\n            shift += 1;\n        }\n    }\n    sponge = if stop {\n        sponge\n    } else {\n        // max_chunks = (N - (N % 3)) / 3;\n        poseidon2_absorb_chunks_loop::<N, (N - (N % 3)) / 3>(\n            sponge,\n            input,\n            in_len,\n            skip_0_check,\n            shift,\n        )\n    };\n    sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop<let N: u32, let M: u32>(\n    in_sponge: std::hash::poseidon2::Poseidon2,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> std::hash::poseidon2::Poseidon2 {\n    assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n    // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n    // The below avoids an overflow\n    let skip_last = 3 * M == N;\n    // Writing in_sponge: &mut does not compile\n    let mut sponge = in_sponge;\n    let mut should_add = true;\n    // The num of things left over after absorbing in 3s\n    let remainder = (in_len - shift) % 3;\n    // The num of chunks of 3 to absorb (maximum M)\n    let chunks = (in_len - shift - remainder) / 3;\n    for i in 0..M {\n        // Now we loop through cache size = 1 -> 3\n        should_add &= i != chunks;\n        // This is the index at the start of the chunk (for readability)\n        let k = 3 * i + shift;\n        if should_add {\n            // cache_size = 1, 2 => just assign\n            sponge.cache[1] = input[k];\n            sponge.cache[2] = input[k + 1];\n            // cache_size = 3 => duplex + perm\n            for j in 0..3 {\n                sponge.state[j] += sponge.cache[j];\n            }\n            sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n            sponge.cache[0] = input[k + 2];\n            // cache_size is now 1 again, repeat loop\n        } else if (!variable) & (i != chunks) {\n            // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n            // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n            let last_0 = if (i == M - 1) & (skip_last) {\n                0\n            } else {\n                input[k + 2]\n            };\n            let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n            assert(all_0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    // we have 'remainder' num of items left to absorb\n    should_add = true;\n    // below is to avoid overflows (i.e. if inlen is close to N)\n    let mut should_check = !variable;\n    for i in 0..3 {\n        should_add &= i != remainder;\n        should_check &= in_len - remainder + i != N;\n        if should_add {\n            // we want to absorb the final 'remainder' items\n            sponge.absorb(input[in_len - remainder + i]);\n        } else if should_check {\n            assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    sponge\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    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\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            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n    let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n    let variable_len_hash = std::hash::poseidon2::Poseidon2::hash(input, in_len);\n    assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    // absorb 250 of the 501 things\n    let two_pow_64 = 18446744073709551616;\n    let empty_sponge = std::hash::poseidon2::Poseidon2::new((in_len as Field) * two_pow_64);\n    let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n    // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n    let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n    let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n    let in_len = 0;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut contructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(contructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == contructed_empty_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": {
+    "307": {
       "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"
     },
-    "311": {
-      "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, ScopedLogHash},\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::scoped::Scoped,\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::{arrays::array_concat, 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, siloed_note_hash: Field) -> Field {\n    let inputs = [nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n    siloed_note_hash: Field,\n    tx_hash: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    if siloed_note_hash == 0 {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(tx_hash, note_index_in_tx);\n        compute_unique_note_hash(nonce, 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) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\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 compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n    poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped<PrivateLogData>) -> PrivateLog {\n    if private_log.contract_address.is_zero() {\n        private_log.inner.log\n    } else {\n        let mut fields = private_log.inner.log.fields;\n        fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n        PrivateLog { fields }\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    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\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    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\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            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\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"
-    },
-    "336": {
-      "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"
+    "339": {
+      "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"
     },
-    "337": {
+    "340": {
       "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"
     },
-    "340": {
-      "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"
+    "341": {
+      "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"
     },
-    "342": {
+    "344": {
       "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"
     },
-    "343": {
+    "345": {
       "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: Field = 0x47dacd73; // 4 last bytes of poseidon2_hash_bytes(\"IS_VALID()\")\n\n/**\n * Assert that `on_behalf_of` has authorized the current call with a valid authentication witness\n *\n * Compute the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then make 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 has allegedly 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 has allegedly 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 allows the 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` has authorized the current call in the authentication registry\n *\n * Compute the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then make 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 has allegedly 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` has authorized a specific `inner_hash` in the authentication registry\n *\n * Compute the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then make 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 has allegedly 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 * Computes 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 has 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"
     },
-    "432": {
+    "437": {
       "path": "/root/nargo/github.com/noir-lang/schnorr/v0.1.1/src/lib.nr",
       "source": "use std::embedded_curve_ops::{EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul};\nuse std::hash::{blake2s, pedersen_hash};\n\npub fn verify_signature<let N: u32>(\n    public_key: EmbeddedCurvePoint,\n    signature: [u8; 64],\n    message: [u8; N],\n) -> bool {\n    //scalar lo/hi from bytes\n    let sig_s = scalar_from_bytes(signature, 0);\n    let sig_e = scalar_from_bytes(signature, 32);\n    // pub_key is on Grumpkin curve\n    let mut is_ok = (public_key.y * public_key.y == public_key.x * public_key.x * public_key.x - 17)\n        & (!public_key.is_infinite);\n\n    if ((sig_s.lo != 0) | (sig_s.hi != 0)) & ((sig_e.lo != 0) | (sig_e.hi != 0)) {\n        let (r_is_infinite, result) =\n            calculate_signature_challenge(public_key, sig_s, sig_e, message);\n\n        is_ok &= !r_is_infinite;\n        for i in 0..32 {\n            is_ok &= result[i] == signature[32 + i];\n        }\n    } else {\n        is_ok = false;\n    }\n    is_ok\n}\n\npub fn assert_valid_signature<let N: u32>(\n    public_key: EmbeddedCurvePoint,\n    signature: [u8; 64],\n    message: [u8; N],\n) {\n    //scalar lo/hi from bytes\n    let sig_s = scalar_from_bytes(signature, 0);\n    let sig_e = scalar_from_bytes(signature, 32);\n\n    // assert pub_key is on Grumpkin curve\n    assert(public_key.y * public_key.y == public_key.x * public_key.x * public_key.x - 17);\n    assert(public_key.is_infinite == false);\n    // assert signature is not null\n    assert((sig_s.lo != 0) | (sig_s.hi != 0));\n    assert((sig_e.lo != 0) | (sig_e.hi != 0));\n\n    let (r_is_infinite, result) = calculate_signature_challenge(public_key, sig_s, sig_e, message);\n\n    assert(!r_is_infinite);\n    for i in 0..32 {\n        assert(result[i] == signature[32 + i]);\n    }\n}\n\nfn calculate_signature_challenge<let N: u32>(\n    public_key: EmbeddedCurvePoint,\n    sig_s: EmbeddedCurveScalar,\n    sig_e: EmbeddedCurveScalar,\n    message: [u8; N],\n) -> (bool, [u8; 32]) {\n    let g1 = EmbeddedCurvePoint {\n        x: 1,\n        y: 17631683881184975370165255887551781615748388533673675138860,\n        is_infinite: false,\n    };\n    let r = multi_scalar_mul([g1, public_key], [sig_s, sig_e]);\n    // compare the _hashes_ rather than field elements modulo r\n    let pedersen_hash = pedersen_hash([r.x, public_key.x, public_key.y]);\n    let pde: [u8; 32] = pedersen_hash.to_be_bytes();\n\n    let mut hash_input = [0; N + 32];\n    for i in 0..32 {\n        hash_input[i] = pde[i];\n    }\n    for i in 0..N {\n        hash_input[32 + i] = message[i];\n    }\n\n    let result = blake2s(hash_input);\n    (r.is_infinite, result)\n}\n\n//Bytes to scalar: take the first (after the specified offset) 16 bytes of the input as the lo value, and the next 16 bytes as the hi value\nfn scalar_from_bytes(bytes: [u8; 64], offset: u32) -> EmbeddedCurveScalar {\n    let mut v: Field = 1;\n    let mut lo: Field = 0;\n    let mut hi: Field = 0;\n    for i in 0..16 {\n        lo = lo + (bytes[offset + 31 - i] as Field) * v;\n        hi = hi + (bytes[offset + 15 - i] as Field) * v;\n        v = v * 256;\n    }\n    let sig_s = EmbeddedCurveScalar::new(lo, hi);\n    sig_s\n}\n\nmod test {\n    use std::embedded_curve_ops::EmbeddedCurvePoint;\n\n    use super::verify_signature;\n\n    #[test]\n    fn test_zero_signature() {\n        let public_key: EmbeddedCurvePoint = EmbeddedCurvePoint {\n            x: 1,\n            y: 17631683881184975370165255887551781615748388533673675138860,\n            is_infinite: false,\n        };\n        let signature: [u8; 64] = [0; 64];\n        let message: [u8; _] = [2; 64]; // every message\n        let verified = verify_signature(public_key, signature, message);\n        assert(!verified);\n    }\n\n    #[test]\n    fn smoke_test() {\n        let message: [u8; 10] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];\n        let pub_key_x: Field = 0x04b260954662e97f00cab9adb773a259097f7a274b83b113532bce27fa3fb96a;\n        let pub_key_y: Field = 0x2fd51571db6c08666b0edfbfbc57d432068bccd0110a39b166ab243da0037197;\n        let signature: [u8; 64] = [\n            1, 13, 119, 112, 212, 39, 233, 41, 84, 235, 255, 93, 245, 172, 186, 83, 157, 253, 76,\n            77, 33, 128, 178, 15, 214, 67, 105, 107, 177, 234, 77, 48, 27, 237, 155, 84, 39, 84,\n            247, 27, 22, 8, 176, 230, 24, 115, 145, 220, 254, 122, 135, 179, 171, 4, 214, 202, 64,\n            199, 19, 84, 239, 138, 124, 12,\n        ];\n\n        let pub_key = EmbeddedCurvePoint { x: pub_key_x, y: pub_key_y, is_infinite: false };\n        let valid_signature = verify_signature(pub_key, signature, message);\n        assert(valid_signature);\n        super::assert_valid_signature(pub_key, signature, message);\n    }\n\n}\n\nmod bench {\n    use super::{assert_valid_signature, verify_signature};\n    use std::embedded_curve_ops::EmbeddedCurvePoint;\n\n    #[export]\n    pub fn bench_verify_signature(\n        public_key: EmbeddedCurvePoint,\n        signature: [u8; 64],\n        message: [u8; 32],\n    ) -> bool {\n        verify_signature(public_key, signature, message)\n    }\n\n    #[export]\n    pub fn bench_assert_valid_signature(\n        public_key: EmbeddedCurvePoint,\n        signature: [u8; 64],\n        message: [u8; 32],\n    ) {\n        assert_valid_signature(public_key, signature, message)\n    }\n}\n"
     },
-    "434": {
-      "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"
+    "439": {
+      "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::{\n    protocol_types::{address::PartialAddress, public_keys::{PUBLIC_KEYS_LENGTH, PublicKeys}},\n    utils::array,\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(array::subarray(values, 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"
     },
-    "435": {
+    "440": {
       "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::embedded_curve_ops::EmbeddedCurvePoint;\n\npub fn recover_address(message_hash: Field, witness: AuthWitness) -> AztecAddress {\n    let message_bytes: [u8; 32] = message_hash.to_be_bytes();\n    let public_key = EmbeddedCurvePoint {\n        x: witness.keys.ivpk_m.inner.x,\n        y: witness.keys.ivpk_m.inner.y,\n        is_infinite: false,\n    };\n\n    // In a single key account contract we re-used ivpk_m as signing key\n    schnorr::assert_valid_signature(public_key, witness.signature, message_bytes);\n\n    AztecAddress::compute(witness.keys, witness.partial_address)\n}\n"
     },
-    "436": {
-      "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::{\n    protocol_types::{address::PartialAddress, public_keys::{PUBLIC_KEYS_LENGTH, PublicKeys}},\n    utils::array,\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(array::subarray(values, 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"
+    "441": {
+      "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"
     }
   }
 }