@aztec/accounts 0.66.0 → 0.67.1-devnet

package/artifacts/SchnorrSingleKeyAccount.json

@@ -1,6 +1,6 @@
 {
   "transpiled": true,
-  "noir_version": "1.0.0-beta.0+a46035ba69b0a659897fe25271c346e005925a6c-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+TSUl6b8PYboWauVPPhLp5FXpzG/nRUdn5xZDZMrmFzDZAOTG5hsUTIJgaMJR0scrXC0xtEVjq5xtMHRDY7GpZFwaSRcGgmXRsKlkXBpJFwa6c00WnV1lq19sQ3QboC2xdlSAG0C2hJoK6CtgXYFtIG5lMBcSmAuJSqXR6m+XA6ui/4arMYt9U9z1vo9+38j15yn3g9b9ufw9Td3nWdZaa7142ovBSnJSZmySFnoBw==",
+      "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"
                               }
@@ -474,7 +489,7 @@
                       }
                     ],
                     "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::header::Header"
+                    "path": "authwit::aztec::protocol_types::block_header::BlockHeader"
                   }
                 },
                 {
@@ -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"
                             }
@@ -1573,7 +1773,7 @@
                     }
                   ],
                   "kind": "struct",
-                  "path": "authwit::aztec::protocol_types::header::Header"
+                  "path": "authwit::aztec::protocol_types::block_header::BlockHeader"
                 }
               },
               {
@@ -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,25 +1905,29 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "H4sIAAAAAAAA/+19B5gT1fd2djdZunQ7CKgoFsikbBILgoJIVcEOlmyKBaU3BQQUEOy9F+xiF8WGUqRXKYJiw957r/idizNyGe6Gsu+Z35zn+8/zvE9m78zevKfMmfNOJpOiwL/LytJAIF3l3/UiQon9Wkxo4hoLGcZqGMZqGcZqG8bqGsZ2JLRxje1h2K+JYaypYayZYWxve0xfiuzXNvZrNFwWi+USkZwVtdLhSKo8GQ/H4uVlSStpxZPxbCQZjeaSsWQiVZ5KhFNWLJqz8vFUNB/+d6lesnGucKWWSIaTZw0Yz3CYk2fN7ecZcQ8obvUIQY2ritd6e715YON6DW28pr3u/F8t+nsHQm1CnZKN485S7PJBuHKLtTfQn3Vxcbc2OaZLtnxshSu3WCVAPwQYc7YergbkOHnW336ecfeA6diqpx1DanHWG2nr9V3HVgP6uyFhR8JOhmOrBJxTjYFzNSjBxWZnpvqM9l9z4FwNgf7bBeg/U27vrOX2Ltr6jtr6Tq7c3pX+3o2wO6GRndv6nO4FXT93BfpkB41nYzup9rBfm9ivTe3XZvbrnvbrXvbr3vZrc/t1H/t1X/u1Rcm/Pmhjv89+9Pf+hAMIBxJaEloRwgR1cogQooQYIU4oIyQISUKKcBDhYMIhhEMJrQmHKZ8Q2hIOJxxBaEdoTziS0IFwFKEjoROhM6ELoSuhG+FowjGEYwndCT0IxxGOJ5xAOJFwEuFkwimEnoRehFMJpxFOJ5xBSBPKCRlClpAj5AlnEs4inG375BznhPtfQ2w7SR/b0zDW3DDWwjCmnFzVNba/YewAw9iBhrGWhrFWhrGwYcwyjEUMY1HDWMwwFjeMlRnGEoaxpGEsZRg7yDB2sGHsEMPYoYax1oaxwwxjbQxjbQ1jhxvGjjCMtTOMtTeMHWkY62AYO8ow1tEw1skw1tkw1sUw1tUw1s0wdrRh7BjD2LGGse6GsR6GseMMY8cbxk4wjJ1oGDvJMHayYewUw1hPw1gvw9iphrHTDGOnG8bOMIylDWPlhrGMYSxrGMsZxvKGsTMNY2cZxs62x5wTsRp3L0X2axv7NVy5BXoSNtBFCQ++ua1/GyrHt03s9d7kl3MJ5xH6EPoS+hH6EwYQBhIGEQYThhCGEoYRzidcQBhOGEEYSbiQMIowmjCGcBHhYsJYwjjCeMIlhAmEiYRLS1yJ0duQLOcaxs4zjPUxjPU1jPUzjPU3jA0wjA00jA0yjA02jA0xjA01jA0zjJ1vGLvAMDbcMDbCMDbSMHahYWyUYWy0YWyMYewiw9jFhrGxhrFxhrHxhrFLDGMTDGMTDWOX2mP60tR+bWO/hiu3bFJ0KqusegPmyuXVErbOBc2lbDwPMte//upT+bkitr+svpWdK/af761+lZsrrMXR6l+ZuSKb5IQ1YPvnCrvyyxq4nXOV5TfLVWvQ9s2VNOS9NXh75koajyFryLbPlajgeLSGbutciQqPbWvYts0VKVAnrPO3Za5EwZpjXbD1c2W2UL+s4Vs7V2KLtdAasXVzhbeirlojt2au8FbVaOvCLc8V38p6b43a0lyxrT53WKMLzhXLb8N5yBpTaK7ENp3TrIsqniu5jedH6+IK5krlt/lca401zxXejvO2Nc40V3i7egBr/OZzWdvZT1iXuOfKbndvYk3YdK5oJfoca6I2VyRfqZ7JurSER/S5P2msbG93KbBPvAxmczSsxLm6C6EosPmCFuiXAWOl8728hJGwmhw97xXAZOCy+4qSjQ4Gzbsh2UoDGw8uzmTDFYYs6xUb3RdX2j6/yn3V5Eo7CfWxqwzqtoTRiZVVpFcCk/4qcHA5DvArDYWjsnZfKeRsNxEY66thNpfFvDzbXc10trumhJHwNQxnu2t9frZTdl8r/Gw3EZZsqYyBLsvZ7jrb59e7z3bXGc5213twtpsIPNtdB0z665mCi676SJtvwFVPKxDAn4mvsIsG+o5UpDS4EdwtoIuWivGNDF2S3+2+wrYbffwhc+cm5uMvXLnFUv67iSF3bgZ3bc756+aSzbtOdPwnAON/C8wPsZyXXfct4Pg5y60ljIRvZei6b/N5163svk141z0BlmzlEQNdlq77dtvnd7i77tsNXfcdHnTdiKrldN23A5P+Dqbgoqs+0uY7fX7Wv8kuGiVgH94E9CGy8N7l83iofLmLoQsD2m08eSHy5a4SfC1Edt13AfNwks8VlbJ1EkMe3s2kBu72QA1cAoz/PTA/JCJeqoF7wPFzlntLGAnfy6AG7vO5GlB23ydcDVwCS7ZkzkCXRQ3cb/v8AbcauN+gBh7wQA0gqpajBu4HJv0DTMFFV32kzQ/6vPucZBcNtBqYBPQhsvA+5PN4qHx5iKELA9rNogYm2XajayGw67YeAubhZJ+rAWXrZIY8fJhJDTzsgRoYD4z/IzA/5Cwv1cAj4Pg5y6MljIQfZVADj/lcDSi7HxOuBsbDks3KG+iyqIHHbZ8/4VYDjxvUwBMeqAFE1XLUwOPApH+CKbjoqo+0+Umfd5+T7aKBVgOTgT5EFt6nfB4PlS9PMXRhQLtZ1MBk2250LQR23dZTwDyc4nM1oGydwpCHTzOpgac9UAPjgPF/BuaHqKdq4Blw/Jxlagkj4akMauBZn6sBZfezwtXAOFiyZTxTA8/ZPn/erQaeM6iB5z1QA4iq5aiB54BJ/zxTcNFVH2nzCz7vPqfYRQOtBqYAfYgsvC/6PB4qX15k6MKAdrOogSm23ehaCOy6rReBeTjN52pA2TqNIQ9fYlIDL3mgBsYC4/8yzA9pT59N8TI4fs4yvYSR8HQGNTDD52pA2T1DuBoYC0u2Ms+eTTHT9vkstxqYaVADszxQA4iq5aiBmcCkn8UUXHTVR9r8is+7z2l20UCrgWlAHyIL72yfx0Ply2yGLgxoN4samGbbja6FwK7bmg3Mwzk+VwPK1jkMeTiXSQ3M9UANXAyM/zyYHyIpL9XAPHD8nGV+CSPh+QxqYIHP1YCye4FwNXAxLNmyCQNdFjWw0Pb5IrcaWGhQA4s8UAOIquWogYXApF/EFFx01UfavNjn3eccu2ig1cAcoA+RhXeJz+Oh8mUJQxcGtJtFDcyx7UbXQmDXbS0B5uFSn6sBZetShjxcxqQGlnmgBi4Cxv9VmB/Kk16qgVfB8XOW5SWMhJczqIEVPlcDyu4VwtXARbBkiyUNdFnUwErb56vcamClQQ2s8kANIKqWowZWApN+FVNw0VUfafNrPu8+l9pFA60GlgJ9iCy8q30eD5Uvqxm6MKDdLGpgqW03uhYCu25rNTAP1/hcDShb1zDk4etMauB1D9TAGGD834D5Ie7pnUJvgOPnLGtLGAmvZVADb/pcDSi73xSuBsbgJLNndwq9Zfv8bbcaeMugBt72QA0gqpajBt4CJv3bTMFFV32kze/4vPtcYxcNtBpYA/QhsvC+6/N4qHx5l6ELA9rNogbW2HajayGw67beBebhOp+rAWXrOoY8fI9JDbzngRoYDYz/+7grY3Ev1cD74Pg5ywcljIQ/YFADH/pcDSi7PxSuBkbjGsZyA10WNfCR7fOP3WrgI4Ma+NgDNYCoWo4a+AiY9B8zBRdd9ZE2f+Lz7nOdXTTQamAd0IfIwvupz+Oh8uVThi4MaDeLGlhn242uhcCu2/oUmIef+VwNKFs/Y8jDz5nUwOceqIFRwPh/gTsXlnmpBr4Ax89ZvixhJPwlgxr4yudqQNn9lXA1MAonmdMGuixq4Gvb59+41cDXBjXwjQdqAFG1HDXwNTDpv2EKLrrqI23+1ufd52d20UCrgc+APkQW3u98Hg+VL98xdGFAu1nUwGe23ehaCOy6re+Aefi9z9WAsvV7hjz8gUkN/OCBGrgQGP8fYX5IevqE0R/B8XOWn0oYCf/EoAZ+9rkaUHb/LFwNXAhLtoRnTxj9xfb5r2418ItBDfzqgRpAVC1HDfwCTPpfmYKLrvpIm3/zeff5vV000Grge6APkYX3d5/HQ+XL7wxdGNBuFjXwvW03uhYCu27rd2Ae/uFzNaBs/YMhD/9kUgN/eqAGRgLj/5dQNfAXOH7O8ncJI+G/GdTAep+rAWX3euFqYKRANfCP4/NgYNPO/x+DGlA7casBRNVy1MA/yKQPylADSJuLgri4BgL4A+4Pu2ig1cAfQB8iC2+xz+Oh8kVxRHdhQLtZ1IDKF8URXQuBXbel+7Cy9pYwxyNcuWWDrSUMeRgMYrtJ57waDPKrgRHAOhSC+SHu6TOFQuD4OUtpkJFwaRA/bxVgMeCyu0pwo4NB83qqBkbAinfas2cKVbV9Xs2tBqoGN1cD1TxQAyOAaqAqMOmrBXmCi676SJur+7z7LLGLBloNlAB9iCy8NXweD5UvNRi6sBrM3SciX2owqAFg123VAOZhTZ+rAWVrTYY8rMWkBmp5oAaGA9XADjg1kPVSDewAjp+z1A4yEq7NoAbq+FwNKLvrCFcDw3FqIGqgy6IG6to+r+dWA3UNaqCeB2pgOFAN1AUmfb0gT3DRVR9pc32fd5817aKBVgM1gT5EFt4GPo+HypcGDF1YA+buE5EvDRjUALDrthoA87Chz9WAsrUhQx7uyKQGdvRADVwAVAM7wfwQ8fSzgZ3A8XOWnYOMhHdmUAO7+FwNKLt3Ea4GLoCpgaxnnw3savt8N7ca2NWgBnbzQA1cAFQDuwKTfrcgT3DRVR9p8+4+7z4b2kUDrQYaAn2ILLyNfB4PlS+NGLqwRszdJyJfGjGoAWDXbTUC5mFjn6sBZWtjhjzcg0kN7OGBGjgfqAaawPwQjXqpBpqA4+csTYOMhJsyqIFmPlcDyu5mwtXA+TA1kMka6LKogT1tn+/lVgN7GtTAXh6ogfOBamBPYNLvFeQJLrrqI23e2+fdZ2O7aKDVQGOgD5GFt7nP46HypTlDF9acuftE5EtzBjUA7Lqt5sA83MfnakDZug9DHu7LpAb29UANDAOqgRYwP+Q8/WygBTh+zrJfkJHwfgxqYH+fqwFl9/7C1cAwmBqwPPts4ADb5we61cABBjVwoAdqYBhQDRwATPoDgzzBRVd9pM0tfd597mMXDbQa2AfoQ2ThbeXzeKh8acXQhbVi7j4R+dKKQQ0Au26rFTAPwz5XA8rWMEMeWkxqwPJADQwFqoEIzA8xT9VABBw/Z4kGGQlHGdRAzOdqQNkdE64GhsLUQLlnaiBu+7zMrQbiBjVQ5oEaGApUA3Fg0pcFeYKLrvpImxM+7z7DdtFAq4Ew0IfIwpv0eTxUviQZurAkc/eJyJckgxoAdt1WEpiHKZ+rAWVriiEPD2JSAwd5oAaGANXAwTA/JFJeqoGDwfFzlkOCjIQPYVADh/pcDSi7DxWuBobgHsObMNBlUQOtbZ8f5lYDrQ1q4DAP1MAQoBpoDUz6w4I8wUVXfaTNbXzefabsooFWAymgD5GFt63P46HypS1DF9aWuftE5EtbBjUA7LqttsA8PNznakDZejhDHh7BpAaO8EANDAaqgXa4K2OeqoF24Pg5S/sgI+H2DGrgSJ+rAWX3kcLVwGCYGoh5pgY62D4/yq0GOhjUwFEeqIHBQDXQAZj0RwV5gouu+kibO/q8+zzcLhpoNXA40IfIwtvJ5/FQ+dKJoQvrxNx9IvKlE4MaAHbdVidgHnb2uRpQtnZmyMMuTGqgiwdqYBBQDXTFfTYQ9lINdAXHz1m6BRkJd2NQA0f7XA0ou48WrgYGwdRAKmygy6IGjrF9fqxbDRxjUAPHeqAGBgHVwDHApD82yBNcdNVH2tzd591nZ7tooNVAZ6APkYW3h8/jofKlB0MX1oO5+0TkSw8GNQDsuq0ewDw8zudqQNl6HEMeHs+kBo73QA0MBKqBE3DnQk9/i/gEcPyc5cQgI+ETGdTAST5XA8ruk4SrgYEwNVDm2W8Rn2z7/BS3GjjZoAZO8UANDASqgZOBSX9KkCe46KqPtLmnz7vP4+yigVYDxwF9iCy8vXweD5UvvRi6sF7M3SciX3oxqAFg1231AubhqT5XA8rWUxny8DQmNXCaB2pgAFANnI77nNzTJ4yeDo6fs5wRZCR8BoMaSPtcDSi708LVwADct4izBrosaqDc9nnGrQbKDWog44EaGABUA+XApM8EeYKLrvpIm7M+7z5PtYsGWg2cCvQhsvDmfB4PlS85hi4sx9x9IvIlx6AGgF23lQPmYd7nakDZmmfIwzOZ1MCZHqiB/kA1cBbMDzlPPxs4Cxw/Zzk7yEj4bAY1cI7P1YCy+xzhaqA/7gmjnn020Nv2+bluNdDboAbO9UAN9Aeqgd7ApD83yBNcdNVH2nyez7vPvF000GogD/QhsvD28Xk8VL70YejC+jB3n4h86cOgBoBdt9UHmId9fa4GlK19GfKwH5Ma6OeBGugHVAP9YX7Ix71UA/3B8XOWAUFGwgMY1MBAn6sBZfdA4WqgH0wNhMsNdFnUwCDb54PdamCQQQ0M9kAN9AOqgUHApB8c5AkuuuojbR7i8+6zr1000GqgL9CHyMI71OfxUPkylKELG8rcfSLyZSiDGgB23dZQYB4O87kaULYOY8jD85nUwPkeqIG+QDVwAcwPKU/vFLoAHD9nGR5kJDycQQ2M8LkaUHaPEK4G+uK+N5A10GVRAyNtn1/oVgMjDWrgQg/UQF+gGhgJTPoLgzzBRVd9pM2jfN59DrOLBloNDAP6EFl4R/s8HipfRjN0YaOZu09EvoxmUAPArtsaDczDMT5XA8rWMQx5eBGTGrjIAzXQB6gGLsZ9NuDpM4UuBsfPWcYGGQmPZVAD43yuBpTd44SrgT64O4U8e6bQeNvnl7jVwHiDGrjEAzXQB6gGxgOT/pIgT3DRVR9p8wSfd59j7KKBVgNjgD5EFt6JPo+HypeJDF3YRObuE5EvExnUALDrtiYC8/BSn6sBZeulDHl4GZMauMzm6mVnfF4J1hZnuTzISPhyhs74Cp93xsruKxg6YxNXRGFQXIvBPgAWHGi8vTxgz2U6YK8MMhK+kuGAvcrnB6yy+ypBB+xVPj9g0fF2FrTy6g283nY10H9eFqmrgzxF6pogI+FrGIrUtT4vUsruaz0qUuHKLRuKybUMMv9SYIyQ8b7O5zJfFbrrGOTV9T6Xlcrm6xnsvoFJVt5guFyL9gl3zBDH+HUMl2aQDc51wNpxo4Bj6EaGY+gmpmPoJsMHtWif3OjzXqEpOUMBHbObwbmKbuiVzUCOVjOar1nJxjzCzGtZAW2puq0+SBT0gXXQtomaSKG5Dt5WgZSoeK5Dtl1sJSqa69DtEW5J81ytt08EJk1zHQYUlB2Bcw0pxR63zlK9EsdvWX5z/7XZfpvD7rnaVsZ/kU3nOrxysQjrcx1R2bjGNs7VrvI5EnHmag/5GP/fuY4E3RKg5uoAvL3gKOAxNZTpmEJr5luA50NgHbGQ/vPygtkt4L7VWW4NMhK+leGC2W0+b4KV3bcxXTBzFnTzth+wedsf2LwdAGzeDgQ2by2BzVsr4MkhBZxrrJDmLQxs3ixg8xYBNm9RYPMWAzZvcWDzVgZs3hLA5i0JPKbGCWnebgc2b8A6Yo0T2rzdztS83RFkJHwHQ/N2p8+bN2X3nUJuybiNkauzoBvNU4CNZk9go9kL2GieCmw0TwM2mqcDT2RnA+e6VkijeQaw0UwDG81yYKOZATaaWWCjmQM2mnlgo3kmsNE8C3hMXSek0bwL2GgC64h1ndBG8y6mRnNSkJHwJIZG826fN5rK7ruFNW+dgM1bZ2Dz1gXYvHUFNm/dgM3b0cCTw8nAuSYJad6OATZvxwKbt+7A5q0HsHk7Dti8HQ9s3k4ANm8nApu3k4DH1N1Cmrd7gM0bsI5Ydwtt3u5hat7uDTISvpehebvP582bsvs+IVcJ72bk6izownI/MP76vSP/v9x78wDQf2OB/pPy8deDyO/7AP0n5arOQ0D/TSr1Z2Ol6rQS2KWaH0FzW+sLzxfJ5K1oPJeIh8vSsXi2LBoh6R7OxuJ5ixwRScXIDflMLJlNRqL5SCKSWY/lF3Ye96Tue19vrzez19Hvo/cu6rzgvN8D2vqD2vpD9vpken2Y8Ejw3zm8erbXI0GeYxScYxHdF4/aTn4sGNj0OV5qw98uAugvSD0CKBb/qrB8/lFg4XmMKZDFYP8hbX5cm8uiK3h0RVDtl8yGrVg2E0lGItnyWDgTTmciuVTMSuVjkVg0k82U05xpKx/OpzOpfPJfXl4qp8eZlNMTQUbCTzAopyd9rpyU3U8KUU6P2VzR8z7F9A3Ep+zHczhF3IsDbzLQFv2MNMXOkaeDLgPQZ5/JwANmytbPldnCXNbTQMd6mRBNS3gS4hk7EaZyJ0RT4IXcZ4AJMVVoQjRjSohn7UR4jjshmgET4llgQjwHPo0oMVtT8+N/cyfpw9eUZWWT0Xg4lSiLpIhBWSIetfIZK55J57OJVDqZKs/lMuXRVCoczZel4iQ6y6Jl+Vg6nnaLQiudyMdz+XQ6m8hHaYJIPJ2ykvloOJNJZukTaJKumXR5gjZnUuE89Z25pFWeycQjyXwqFY1nOUTmJvPFY+l0siydiFJbm47G4pF4Ll5ensuW5WLR8rRlpZK5ZBl98JaPpuLhSFkyn7Cy+Vg8ZZVnc7FwxM0vEk5lM/nyPKn28ngin8qXhWPkmVg2YaUzZfl0PpmI0FvmM4lYOJEJx3LlZRErXRZJJjLpjBUp47bXysRi+Ug6HqF3T1qUdmlq/K10nLIwk0uWU3Za4UhMOYBWk1aqvDybzsfTkXQ2TZ+jx5Kb8Yum07lctCxXFotE0hZJh5RFlyjI1ngqlc6lcuWUFJlIxkqkk5lUJJxORymJkuXJVCaepzfntjeSpTdLxcK5eDIVzsXo8EskcuF4NBHNp3NlKWKciMcoh+kKCyVBMlxeVlaWIkMp3yMkdTbLv0guk00ms1Y8VZYoz8Sj5ckk5UIkF85aZcmyMotimykvS5PJ2Wg+Gc9FKK6JXC5fTi5I0cHFYa9z54dan6JdHHlaW39GW5+qrT+rrT8XhF/Ugdur5nueeL5AeNG+2KPgnAf0BX1ye17ExZ4I60PiizTfNrHXp5FfXiK8TJhOmEGYSZhFeIUwmzCHMJcwjzCfsICwkLCIsJiwhLCUsIzwKmE5YQVhJWEV4TXCasIawuuENwhrCW+6L2IpMlVdYy8Zxl42jE03jM0wjM00jM0yjL1iGJttGJtjGJtrGJtnGJtvGFtgGFtoGFtkGFtsGFtiGFtqGFtmGHvVMLbcMLbCMLbSMLbKMPaaYWy1YWyNYex1w9gbhrG1hrE3g5s/Saup/drGfg1Xbtmk6FS2IZ0Gu/gatl4CzaVsfBky17/+ml75uf67lWlGZefSbrGaWbm5Nrn1a1Zl5nLdkvbK9s+12a1ys7dzLtMtfHO2by7j7ZRzt2euCm7znLftc1V4++n8bZ2rwG2xC7ZtroK36y7clrm2cBvxIqAIXry1cyW2WAutJVs3V3gr6qq1dGvmCm9VjbaWbXmu+FbWe+vVLc0V2+pzh7W84Fyx/Dach6wVheZKbNM5zVpZ8VzJbTw/WqsqmCuV3+ZzrfWaea7wdpy3rdWmucLb1QNYazafy9rOfsJ63T1Xdrt7E+uNTeeKVqLPsdZqc0XyleqZrDeZRJ/7g+HK9nZvAvvEt2A2Rz29pfYtYKx0vm8HGQmrydHzvgNMBi673wludDBoXk9/1g9XGLKe/azfu7bP17mvmrwb3PgZkTO2Lsj/s36IquUo0neBSb8OHFyOA/zdIP5uhXeFnO3WAmP9HszmspiXZ7v3mM527wcZCb/PcLb7wOdnO2X3B8LPdmthyZbKGOiynO0+tH3+kfts96HhbPeRB2e7tcCz3YfApP+IKbjoqo+0+WNc9TT+mkpl+b1jF41icA4ipcEn4G4BXbRUjD9h6JL8bvc7tt3o4w+ZO58yH3/hyi2W8t+nDLnzGbhrc85fnwU37zrR8X8DGP/PYX6I5bzsuj8Hx89ZvggyEv6Coev+0uddt7L7S+Fd9xuwZCuPGOiydN1f2T7/2t11f2Xour/2oOtGVC2n6/4KmPRfMwUXXfWRNn/j87P+p3bRQH9H+lOgD5GF91ufx0Ply7cMXRjQbpZvo31q242uhciu+1tgHn7nc0WlbP2OIQ+/Z1ID33ugBl4Hxv8HmB8SES/VwA/g+DnLj0FGwj8yqIGffK4GlN0/CVcDr8OSLZkz0GVRAz/bPv/FrQZ+NqiBXzxQA4iq5aiBn4FJ/wtTcNFVH2nzrz7vPr+ziwZaDXwH9CGy8P7m83iofPmNoQv7jbn7ROTLbwxqANh1W78B8/B3n6sBZevvDHn4B5Ma+MMDNbAGGP8/YX7Iefpgoj/B8XOWv4KMhP9iUAN/+1wNKLv/Fq4G1sCSzcob6LKogfW2z/9xq4H1BjXwjwdqAFG1HDWwHpj0/zAFF131kTarMo2KayCAP+B+t4sGWg38DvQhsvAW+TweKl8UR3QXBrSbRQ1s6DxD+FoI7Lot3YeVtbeYOR7hyi0bbC1myMOSELabdM6rJSF+NbAaWIeCMD9EPVUDQXD8nCUUYiQcCuHnLQUWAy67S0MbHQya11M1sBpWvDOeqYEqts+rOkekU6GqhDZXA2onbjWwGqgGqgCTvmqIJ7joqo+0uZrPu89iu2ig1UAx0IfIwlvd5/FQ+VKdoQur7nM1UGzbja6FwK7bqg7Mwxo+VwPK1hoMeViTSQ3U9EANvAZUA7Vgfkh7+myKWuD4OcsOIUbCOzCogdo+VwPK7trC1cBrMDVQ5tmzKerYPq/rVgN1DGqgrgdq4DWgGqgDTPq6IZ7goqs+0uZ6Pu8+a9hFA60GagB9iCy89X0eD5Uv9Rm6sPrM3SciX+ozqAFg123VB+ZhA5+rAWVrA4Y8bMikBhp6oAZWAdXAjjA/RFJeqoEdwfFzlp1CjIR3YlADO/tcDSi7dxauBlbB1EA2YaDLogZ2sX2+q1sN7GJQA7t6oAZWAdXALsCk3zXEE1x01UfavJvPu88GdtFAq4EGQB8iC+/uPo+HypfdGbqw3Zm7T0S+7M6gBoBdt7U7MA8b+VwNKFsbMeRhYyY10NgDNbASqAb2gPmhPOmlGtgDHD9naRJiJNyEQQ009bkaUHY3Fa4GVuIevJU00GVRA81sn+/pVgPNDGpgTw/UwEqgGmgGTPo9QzzBRVd9pM17+bz7bGQXDbQaaAT0IbLw7u3zeKh82ZuhC9ubuftE5MveDGoA2HVbewPzsLnP1YCytTlDHu7DpAb28UANrACqgX1hfoh7eqfQvuD4OUuLECPhFgxqYD+fqwFl937C1cAK3EMoPbtTaH/b5we41cD+BjVwgAdqYAVQDewPTPoDQjzBRVd9pM0H+rz7bG4XDbQaaA70IbLwtvR5PFS+tGTowloyd5+IfGnJoAaAXbfVEpiHrXyuBpStrRjyMMykBsIeqIHlQDVg4a6Mxb1UAxY4fs4SCTESjjCogajP1YCyOypcDSzHqYFyA10WNRCzfR53q4GYQQ3EPVADy4FqIAZM+niIJ7joqo+0uczn3Wcru2ig1UAroA+RhTfh83iofEkwdGEJ5u4TkS8JBjUA7LqtBDAPkz5XA8rWJEMeppjUQMoDNfAqUA0chDsXlnmpBg4Cx89ZDg4xEj6YQQ0c4nM1oOw+RLgaeBV3p1DaQJdFDRxq+7y1Ww0calADrT1QA68C1cChwKRvHeIJLrrqI20+zOfdZ9IuGmg1kAT6EFl42/g8HhvyhaELa8PcfULyhUENALtuqw0wD9v6XA0oW9sy5OHhTGrgcA/UwDKgGjgC5oekp08YPQIcP2dpF2Ik3I5BDbT3uRpQdrcXrgaW4X6iz7MnjB5p+7yDWw0caVADHTxQA8uAauBIYNJ3CPEEF131kTYf5fPus61dNNBqoC3Qh8jC29Hn8VD50pGhC+vI3H0i8qUjgxoAdt1WR2AedvK5GlC2dmLIw85MaqCzB2pgKVANdBGqBrqA4+csXUOMhLsyqIFuPlcDyu5uwtXAUoFq4Gjb58e41cDRBjVwjAdqYClQDRwNTPpjhKgBpM3H+rz77GQXDbQa6AT0IbLwdvd5PFS+dGfowrozd5+IfOnOoAaAXbfVHZiHPXyuBpStPRjy8DgmNXCcB2pgCVANHA/zQ9zTZwodD46fs5wQYiR8AoMaONHnakDZfaJwNbAEpgbSnj1T6CTb5ye71cBJBjVwsgdqYAlQDZwETPqTQzzBRVd9pM2n+Lz77GEXDbQa6AH0IbLw9vR5PFS+9GTownoyd5+IfOnJoAaAXbfVE5iHvXyuBpStvRjy8FQmNXCqB2pgMVANnIZTA1kv1cBp4Pg5y+khRsKnM6iBM3yuBpTdZwhXA4txaiBqoMuiBtK2z8vdaiBtUAPlHqiBxUA1kAYmfXmIJ7joqo+0OePz7rOXXTTQaqAX0IfIwpv1eTxUvmQZurAsc/eJyJcsgxoAdt1WFpiHOZ+rAWVrjiEP80xqIO+BGlgEVANnwvwQ8fSzgTPB8XOWs0KMhM9iUANn+1wNKLvPFq4GFuF+fcyzzwbOsX3e260GzjGogd4eqIFFQDVwDjDpe4d4gouu+kibz/V595mziwZaDeSAPkQW3vN8Hg+VL+cxdGHnMXefiHw5j0ENALtu6zxgHvbxuRpQtvZhyMO+TGqgrwdqYCFQDfSD+SEa9VIN9APHz1n6hxgJ92dQAwN8rgaU3QOEq4GFMDWQyRrosqiBgbbPB7nVwECDGhjkgRpYCFQDA4FJPyjEE1x01UfaPNjn3Wcfu2ig1UAfoA+RhXeIz+Oh8mUIQxc2hLn7ROTLEAY1AOy6rSHAPBzqczWgbB3KkIfDmNTAMA/UwAKgGjgf5oecp58NnA+On7NcEGIkfAGDGhjuczWg7B4uXA0sgKkBy7PPBkbYPh/pVgMjDGpgpAdqYAFQDYwAJv3IEE9w0VUfafOFPu8+h9pFA60GhgJ9iCy8o3weD5Uvoxi6sFHM3SciX0YxqAFg122NAubhaJ+rAWXraIY8HMOkBsZ4oAbmA9XARTA/xDxVAxeB4+csF4cYCV/MoAbG+lwNKLvHClcD83G/PuaZGhhn+3y8Ww2MM6iB8R6ogflANTAOmPTjQzzBRVd9pM2X+Lz7HG0XDbQaGA30IbLwTvB5PFS+TGDowiYwd5+IfJnAoAaAXbc1AZiHE32uBpStExny8FImNXCpB2pgHlANXAbzQyLlpRq4DBw/Z7k8xEj4cgY1cIXP1YCy+wrhamAeTA0kEwa6LGrgStvnV7nVwJUGNXCVB2pgHlANXAlM+qtCPMFFV32kzVf7vPucaBcNtBqYCPQhsvBe4/N4qHy5hqELu4a5+0TkyzUMagDYdVvXAPPwWp+rAWXrtQx5eB2TGrjOAzUwF6gGrsddGfNUDVwPjp+z3BBiJHwDgxq40edqQNl9o3A1MBf3W8SeqYGbbJ/f7FYDNxnUwM0eqIG5QDVwEzDpbw7xBBdd9ZE23+Lz7vNau2ig1cC1QB8iC++tPo+HypdbGbqwW5m7T0S+3MqgBoBdt3UrMA9v87kaULbexpCHtzOpgds9UANzgGrgDtxnA2Ev1cAd4Pg5y50hRsJ3MqiBu3yuBpTddwlXA3NgaiAVNtBlUQOTbJ/f7VYDkwxq4G4P1MAcoBqYBEz6u0M8wUVXfaTN9/i8+7zNLhpoNXAb0IfIwnuvz+Oh8uVehi7sXubuE5Ev9zKoAWDXbd0LzMP7fK4GlK33MeTh/Uxq4H4P1MBsoBp4AHcu9PS3iB8Ax89ZHgwxEn6QQQ085HM1oOx+SLgamA1TA2We/RbxZNvnD7vVwGSDGnjYAzUwG6gGJgOT/uEQT3DRVR9p8yM+7z7vs4sGWg3cB/QhsvA+6vN4qHx5lKELe5S5+0Tky6MMagDYdVuPAvPwMZ+rAWXrYwx5+DiTGnjcAzXwClANPIH7nNzTJ4w+AY6fszwZYiT8JIMaeMrnakDZ/ZRwNfAK7lvEnj1hdIrt86fdamCKQQ087YEaeAWoBqYAk/7pEE9w0VUfafMzPu8+H7OLBloNPAb0IbLwTvV5PFS+TGXowqYyd5+IfJnKoAaAXbc1FZiHz/pcDShbn2XIw+eY1MBzHqiBWUA18DzMDzlPPxt4Hhw/Z3khxEj4BQY18KLP1YCy+0XhamAW7gmjnn02MM32+UtuNTDNoAZe8kANzAKqgWnApH8pxBNcdNVH2vyyz7vPZ+2igVYDzwJ9iCy8030eD5Uv0xm6sOnM3SciX6YzqAFg121NB+bhDJ+rAWXrDIY8nMmkBmZ6oAZmAtXALJgf8nEv1cAscPyc5ZUQI+FXGNTAbJ+rAWX3bOFqYCZMDYTLDXRZ1MAc2+dz3WpgjkENzPVADcwEqoE5wKSfG+IJLrrqI22e5/Puc4ZdNNBqYAbQh8jCO9/n8VD5Mp+hC5vP3H0i8mU+gxoAdt3WfGAeLvC5GlC2LmDIw4VMamChB2pgBlANLIL5IeXpnUKLwPFzlsUhRsKLGdTAEp+rAWX3EuFqYAbuewOe3Sm01Pb5MrcaWGpQA8s8UAMzgGpgKTDpl4V4gouu+kibX/V597nALhpoNbAA6ENk4V3u83iofFnO0IUtZ+4+EfmynEENALtuazkwD1f4XA0oW1cw5OFKJjWw0gM1MB2oBlbhPhvw9JlCq8Dxc5bXQoyEX2NQA6t9rgaU3auFq4HpuDuFPHum0Brb56+71cAagxp43QM1MB2oBtYAk/71EE9w0VUfafMbPu8+V9hFA60GVgB9iCy8a30eD5Uvaxm6sLXM3SciX9YyqAFg122tBebhmz5XA8rWNxny8C0mNfCWzdXLzvjlINYWZ3k7xEj4bYbO+B2fd8bK7ncYOmMTV0RhUFyLwT4AFhxovL08YF9iOmDfDTESfpfhgF3n8wNW2b1O0AG7zucHLDrezoJWXtOA19veA/rPyyL1XoinSL0fYiT8PkOR+sDnRUrZ/YFHRSpcuWVDMfmAQea/CYwRMt4f+lzmq0L3IYO8+sjnslLZ/BGD3R8zycqPDZdr0T7hjhniGP+Q4dIMssH5EFg7PhFwDH3CcAx9ynQMfWr4oBbtk0+A8XcuI7XRuL4Z/LcOqPW12vob2vrr2voabX21tv6atr5KW1+pra/Q1pdr669q68u09aXa+hJtfbG2vkhbX6itL9DW52vr87T1udr6HG19trb+irY+S1ufqa3P0Nana+sva+svaevTtPVLSzauT9TWJ2jrl2jr47X1cdr6WG39Ym39Im19jLY+Wlsfpa1fqK2P1NZHaOvDtfULtPXztfVh2vpQbX2Itj5YWx+krQ/U1gdo6/219X7ael9tvY+2fp62fq623tte/4yOrc8JXxC+JHxF+JrwDeFbwneE7wk/EH4k/ET4mfAL4VfCb4TfCX8Q/iT8RfibsJ7wj+qf6cPlIkIxoYQQJIQIpYQq6oNnbUHXjceC2FrvLGhh3KkEZ/NnIRk2dwba/LkQm7sAbf5CiM1dgTZ/KcTmbkCbvxJi89FAm78WYvMxQJu/EWLzsUCbvxVic3egzd8JsbkH0Obvhdh8HNDmH4TYfDzQ5h+F2HwC0OafhNh8ItDmn4XYfBLQ5l+E2Hwy0OZfhdh8CtDm34TY3BNo8+9CbO4FtPkPITafCrT5TyE2nwa0+S8hNp8OtPlvITafAbR5vRCb00Cb/xFicznQZvV5ggSbM0Cbi4TYnAXaXCzE5hzQ5hIhNueBNgeF2Hwm0OaQEJvPAtpcKsTms4E2V2GyGX1vUFUYz2iMk2e17eeZdQ8obvUC/94L5HBVflhvrzcu2bi+h7Zezd7H+b/q9HcNQk1CrdKN486Cvq+uCTA/q5fiYrMDU66j/dcU6L8aQP/VFuK/ZkD/1QT6rw7Qf6basINWG2pr63W09Vqu2lCX/q5HqE9o4EFt2BMYm7rA2DQUktt7Af1XD+i/HYX4b2+g/+oD/bcTc21oqNWAHbX1nbT1Bq7asDP9vQthV8JuHtSG5sDY7AyMze5CcnsfoP92AfqvkRD/7Qv0365A/zVmrg27azWgka4vtPXdXLVhD/q7CaEpoZkHtaEFMDZ7AGOzJ3Ns9tRi0ERbb6qtN3PFZi/6e29Cc8I+htigNe++OB/kOXm22H6eUfeAKVb7ajHZS1s/R9PmLVyx2o/+3p9wAOFAO1ZBe18vvuy9HzB/izWeLe3vTbQqtUk7X8ZSG0a7xlrZY/qCLiD7AQ/6lls/V2YLc1mtgAFQiVMcMD8oMbCN/twS7wBjUrYEF1VnCbuTUQ0UbSHxkMmyBa5WeEsLMImtUlgybPJtS2srDubKcm8F9APSp5Ft8OmW3kv3aUQrmlU1f+o+DVdusdYXni+SyVvReC4RD5elY/FsWTSSjSTC2Vg8bxHhSCpGrslnYslsMhLNRxKRzHosvw055hQ250TinFVb2etReo0R4vaZ1KunxsaZFA44xhHdF2X2GTrhLopqw9+uscRWFMpw5ZZNnFi5p8bm82XAgzrh0ceC4cotFtLmpDaXlYxGIomo2i+ZDVuxLPU0kUi2PBbOhNOZSC4Vs1L5WCQWzWQz5TRn2sqH8+lMKp/8l5eXzy5KMnUOqVJGwqlS/LwHAZOBy+6DSjc6GDQvy/NHEjZX9LwHg5PVKdZqXvdZj/Mzysr6IQrM1UPAcsqrwnUIU+E6tJSR8KEMhau1zwuXsrs1U+FyFs4PxCvr0xgwPocJPVgPYzpY25RyEmY4WNv6/GBVdrcVdrBGS/1ZTA8HJ301O96Hazo+pq23Lt14FbypdgW9mbau7iZRr0fQvu0I7e3/ceaOVjB3Qpt7S/scSa8dCEeV8hybre0cRXeXHcGyFc2Py+5OwOMnoC3FYJ4J4LHZGWwz+tKEOj6RcVHHZEeG3Oni0aWeSn/qDGzouvo8d1TtB16Cs9Sx0oUhd7qBcwftR5UzyN5C5U03Bj8W4WzeIApKApgPRLewWBV9Yo94j1gim85kE1Hj5OjignTKPgEZBRWYdNa+QmwuBtrcgslm+O0u4OOkotiEK7dY+wN51iqREZsDtLki8XQ8k4snMoloMpPORZPl0US2LJZOluXKo9lwOBsvz+fC0XSuzKJPoqPpaDYVDadi8Vy6LBdORdKcPA8MyPBnSyE8WwnhGRbC0xLCMyKEZ1QIz5gQnnEhPMuE8EwI4ZkUwjMlhOdBQngeLITnIUJ4HiqEZ2shPA8TwrONEJ5thfA8XAjPI4TwbCeEZ3shPI8UwrODEJ5HCeHZUQjPTkJ4dhbCs4sQnl2F8OwmhOfRQngeI4TnsUJ4dhfCs4cQnscJ4Xm8EJ4nCOF5ohCeJwnhebIQnqcI4dlTCM9eQnieKoTnaUJ4ni6E5xlCeKaF8CwXwjMjhGdWCM+cEJ55ITzPFMLzLCE8zxbC8xwhPHsL4XmuEJ7nCeHZRwjPvkJ49hPCs78QngOE8BwohOcgITwHC+E5RAjPoUJ4DhPC83whPC8QwnO4EJ4jhPAcKYTnhUJ4jhLCc7QQnmOE8LxICM+LhfAcK4TnOCE8xwvheYkQnhOE8JwohOelQnheJoTn5UJ4XiGE55VCeF4lhOfVQnheI4TntUJ4XieE5/VCeN4ghOeNQnjeJITnzUJ43iKE561CeN4mhOftQnjeIYTnnUJ43iWE5yQhPO8WwvMeITzvFcLzPiE87xfC8wEhPB8UwvMhITwnC+H5sBCejwjh+agQno8J4fm4EJ5PCOH5pBCeTwnhOUUIz6eF8HxGCM+pQng+K4Tnc0J4Pi+E5wtCeL4ohOc0ITxfEsLzZSE8pwvhOUMIz5lCeM4SwvMVITxnC+E5RwjPuUJ4zhPCc74QnguE8FwohOciITwXC+G5RAjPpUJ4LhPC81UhPJcL4blCCM+VQniuEsLzNSE8VwvhuUYIz9eF8HxDCM+1Qni+KYTnW0J4vi2E5ztCeL4rhOc6ITzfE8LzfSE8PxDC80MhPD8SwvNjITw/EcLzUyE8PxPC83MhPL8QwvNLITy/EsLzayE8vxHC81shPL8TwvN7ITx/EMLzRyE8fxLC82chPH8RwvNXITx/E8LzdyE8/xDC808hPP8SwvNvITzXC+H5jxCeakIJPIuE8CwWwrNECM+gEJ4hITxLhfCsIoRnVSE8qwnhWV0IzxpCeNYUwrOWEJ47COFZWwjPOkJ41hXCs54QnvWF8GwghGdDITx3FMJzJyE8dxbCcxchPHcVwnM3ITx3F8KzkRCejYXw3EMIzyZCeDYVwrOZEJ57CuG5lxCeewvh2VwIz32E8NxXCM8WQnjuJ4Tn/kJ4HiCE54FCeLYUwrOVEJ5hITwtITwjQnhGhfCMCeEZF8KzTAjPhBCeSSE8U0J4HiSE58FCeB4ihOehQni2FsLzMCE82wjh2VYIz8OF8DxCCM92Qni2F8LzSCE8OwjheZQQnh2F8OwkhGdnITy7COHZVQjPbkJ4Hi2E5zFCeB4rhGd3ITx7COF5nBCexwvheYIQnicK4XmSEJ4nC+F5ihCePYXw7CWE56lCeJ4mhOfpQnieIYRnWgjPciE8M0J4ZoXwzAnhmRfC80whPM8SwvNsITzPEcKztxCe5wrheZ4Qnn2E8OwrhGc/ITz7C+E5QAjPgUJ4DhLCc7AQnkOE8BwqhOcwITzPF8LzAiE8hwvhOUIIz5FCeF4ohOcoITxHC+E5RgjPi4TwvFgIz7FCeI4TwnO8EJ6XCOE5QQjPiUJ4XiqE52VCeF4uhOcVQnheKYTnVUJ4Xi2E5zVCeF4rhOd1QnheL4TnDUJ43iiE501CeN4shOctQnjeKoTnbUJ43i6E5x1CeN4phOddQnhOEsLzbiE87xHC814hPO8TwvN+ITwfEMLzQSE8HxLCc7IQng8L4fmIEJ6PCuH5mBCejwvh+YQQnk8K4fmUEJ5ThPB8WgjPZ4TwnCqE57NCeD4nhOfzQni+IITni0J4ThPC8yUhPF8WwnO6EJ4zhPCcKYTnLCE8XxHCc7YQnnOE8JwrhOc8ITznC+G5QAjPhUJ4LhLCc7EQnkuE8FwqhOcyITxfFcJzuRCeK4TwXCmE5yohPF8TwnO1EJ5rhPB8XQjPN4TwXCuE55tCeL4lhOfbQni+I4Tnu0J4rhPC8z0hPN8XwvMDITw/FMLzIyE8PxbC8xMhPD8VwvMzITw/F8LzCyE8vxTC8yshPL8WwvMbITy/FcLzOyE8vxfC8wchPH8UwvMnITx/FsLzFyE8fxXC8zchPH8XwvMPITz/FMLzLyE8/xbCc70Qnv8I4RkolsGzSAjPYiE8S4TwDArhGRLCs1QIzypCeFYVwrOaEJ7VhfCsIYRnTSE8awnhuYMQnrWF8KwjhGddITzrCeFZXwjPBkJ4NhTCc0chPHcSwnNnITx3EcJzVyE8dxPCc3chPBsJ4dlYCM89hPBsIoRnUyE8mwnhuacQnnsJ4bm3EJ7NhfDcRwjPfYXwbCGE535CeO4vhOcBQngeKIRnSyE8WwnhGRbC0xLCMyKEZ1QIz5gQnnEhPMuE8EwI4ZkUwjMlhOdBQngeLITnIUJ4HiqEZ2shPA8TwrONEJ5thfA8XAjPI4TwbCeEZ3shPI8UwrODEJ5HCeHZUQjPTkJ4dhbCs4sQnl2F8OwmhOfRQngeI4TnsUJ4dhfCs4cQnscJ4Xm8EJ4nCOF5ohCeJwnhebIQnqcI4dlTCM9eQnieKoTnaUJ4ni6E5xlCeKaF8CwXwjMjhGdWCM+cEJ55ITzPFMLzLCE8zxbC8xwhPHsL4XmuEJ7nCeHZRwjPvkJ49hPCs78QngOE8BwohOcgITwHC+E5RAjPoUJ4DhPC83whPC8QwnO4EJ4jhPAcKYTnhUJ4jhLCc7QQnmOE8LxICM+LhfAcK4TnOCE8xwvheYkQnhOE8JwohOelQnheJoTn5UJ4XiGE55VCeF4lhOfVQnheI4TntUJ4XieE5/VCeN4ghOeNQnjeJITnzUJ43iKE561CeN4mhOftQnjeIYTnnUJ43iWE5yQhPO8WwvMeITzvFcLzPiE87xfC8wEhPB8UwvMhITwnC+H5sBCejwjh+agQno8J4fm4EJ5PCOH5pBCeTwnhOUUIz6eF8HxGCM+pQng+K4Tnc0J4Pi+E5wtCeL4ohOc0ITxfEsLzZSE8pwvhOUMIz5lCeM4SwvMVITxnC+E5RwjPuUJ4zhPCc74QnguE8FwohOciITwXC+G5RAjPpUJ4LhPC81UhPJcL4blCCM+VQniuEsLzNSE8VwvhuUYIz9eF8HxDCM+1Qni+KYTnW0J4vi2E5ztCeL4rhOc6ITzfE8LzfSE8PxDC80MhPD8SwvNjITw/YeJZ7OIZDZfFYrlEJGdFrXQ4kipPxsOxeHlZ0kpa8WQ8G0lGo7lkLJlIlacS4ZQVi+asfDwVzdtz7w20+VOPbA5XbrE+K8b5r26JjDgHgf77XEhuh4A2fyHE5lKgzV8KsbkK0OavhNhcFWjz10Jsrga0+RshNlcH2vytEJtrAG3+TojNNYE2fy/E5lpAm38QYvMOQJt/FGJzbaDNPwmxuQ7Q5p+F2FwXaPMvQmyuB7T5VyE21wfa/JsQmxsAbf5diM0NgTb/IcTmHYE2/ynE5p2ANv8lxOadgTb/LcTmXYA2rxdi865Am/8RYvNuQJsDQq5v7w60uUiIzY2ANhcLsbkx0OYSITbvAbQ5KMTmJkCbQ0Jsbgq0uVSIzc2ANlcRYvOeQJurCrF5L6DN1YA201Qb7v340DZ4H8K+hBaE/Qj7Ew4gHEhoSWil3pNgESLKL4QYIU4oIyQISUKKcBDhYMIhhEMJrQmH2X5oSziccAShHaE94UhCB8JRhI6EToTOhC6EroRuhKMJxxCOJXQn9CAcRziecALhRMJJhJMJpxB6EnoRTiWcRjidcAYhTSgnZAhZQo6QJ5xJOItwNuEcQm/CuYTzCH0IfQn9CP0JAwgDCYMIgwlDCEMJwwjnEy4gDCeMIIwkXEgYRRhNGEO4iHAxYSxhHGE84RLCBMJEwqWEywiXE64gXEm4inA14RrCtYTrCNcTbiDcSLiJcDPhFsKthNsItxPuINxJuIswiXA34R7CvYT7CPcTHiA8SHiIMJnwMOERwqOExwiPE54gPEl4ijCF8DThGcJUwrOE5wjPE14gvEiYRniJ8DJhOmEGYSZhFuEVwmzCHMJcwjzCfMICwkLCIsJiwhLCUsIywquE5YQVhJWEVYTXCKsJawivE94grCW8SXiL8DbhHcK7hHWE9wjvEz4gfEj4iPAx4RPCp4TPCJ8TviB8SfiK8DXhG8K3hO8I3xN+IPxI+InwM+EXwq+E3wi/E/4g/En4i/A3YT3hH4I64IoIxYQSQpAQIpQSqhCqEqoRqhNqEGoSahF2INQm1CHUJdQj1Cc0IDQk7EjYibAzYRfCroTdCLsTGhEaE/YgNCE0JTQj7EnYi7A3oTlhH8K+hBaE/Qj7Ew4gHEhoSWhFCBMsQoQQJcQIcUIZIUFIElKEgwgHEw4hHEpoTTiM0IbQlnA44QhCO0J7wpGEDoSjCB0JnQidCV0IXQndCEcTjiEcS+hO6EE4jnA84QTCiYSTCCcTTiH0JPQinEo4jXA64QxCmlBOyBCyhBwhTziTcBbhbMI5hN6EcwnnEfoQ+hL6EfoTBhAGEgYRBhOGEIYShhHOJ1xAGE4YQRhJuJAwijCaMIZwEeFiwljCOMJ4wiWECYSJhEsJlxEuJ1xBuJJwFeFqwjWEawnXEa4n3EC4kXAT4WbCLYRbCbcRbifcQbiTcBdhEuFuwj2Eewn3Ee4nPEB4kPAQYTLhYcIjhEcJjxEeJzxBeJLwFGEK4WnCM4SphGcJzxGeJ7xAeJEwjfAS4WXCdMIMwkzCLMIrhNmEOYS5hHmE+YQFhIWERYTFhCWEpYRlhFcJywkrCCsJqwivEVYT1hBeJ7xBWEt4k/AW4W3CO4R3CesI7xHeJ3xA+JDwEeFjwieETwmfET4nfEH4kvAV4WvCN4RvCd8Rvif8QPiR8BPhZ8IvhF8JvxF+J/xB+JPwF+FvwnrCPwTVXBQRigklhCAhRCglVCFUJVQjVCfUINQk1CLsQKhNqEOoS6hHqE9oQGhI2JGwE2Fnwi6EXQm7EXYnNCI0JuxBaEJoSmhG2JOwF2FvQnPCPoR9CS0I+xH2JxxAOJDQktCKECZYhAghSogR4oQyQoKQJKQIBxEOJhxCOJTQmnCYuoZEaEs4nHAEoR2hPeFIQgfCUYSOhE6EzoQuhK6EboSjCccQjiV0J/QgHEc4nnAC4UTCSYSTCacQehJ6EU4lnEY4nXAGIU0oJ2QIWUKOoH6zXv0evPqtdfU75uo3wtXvb6vftla/G61+k1n93rH6LWH1O73qN3DV78uq325Vv4uqfnNU/Z6n+q1M9TuU6jce1e8nqt8mVL/7p35TT/1e3WiC+p019Rtm6vfB1G9vqd+1Ur8ZpX6PSf3WkfodIfUbPer3b9Rvy6jfbVG/iaJ+b0T9lof6nQz1GxTq9x3Ubyeo3yVQz/xXz9NXz6pXz4FXz1hXzy9XzwZXz91Wz7RWz4ueRFDPOVbPEFbP51XPvlXPlVXPbFXPQ1XPGlXP8VTPyFTPn1TPdlTPTVTPJFTP+1PP0lPPqVPPgFPPV1PPLlPPBVPP3FLPs1LPilLPYVLPOFLPD1LP5lHPvVHPlFHPa5lJUM8ZUc/wUM/HUM+eUM91UM9MUM8jUN/1V9+jV99RV9//Vt+tVt9bVt8JVt+3Vd9lVd8TVd/BVN9vVN8dVN/LU995U98nU9/VUt+DUt8xUt/fUd+NUd87Ud/pUN+XeI+g7vNX99Crvlfd+63uq1b3LKt7eNX9seoeT3XPo7oHUN0Tp+4RU/dMqXuI1D016h4Tdc+FugdBfSavPqNWn9mqzzDVZ3rqMy71mY/6DER9JqCukatrxuoaqrqmqK6xqWtO6hqMuiahNLrSrErDKU2jevzif1uFgLp3VS37BDYudhlRU23Yru71VPc+qnsB1b1x6l4xde+UupdI3Vuj7jVR916oexHUZ/Pqs2r12a36LFN9tqc+61Kf/ajPQtRnA+paubp2rK6lqmuL6lqbuvakrsU0ITQlNCMoLae0jbqPunlg8+UIbb2u/drwo7a79F/0YHt9v3r267x4v1F9m26yaUNfW9H/3Vdg25QC22YW2LaswLa3C2z7osC23wpsU31fRdsaFNjWrMC2cIFtrQts61Jg2ykFtp1VYNuQAtvGFth2bYFtkwpse7zAtpcKbFtUYNsbBbZ9UmDbTwW2qfN/RdvqFNjWxN62+PpX5z00IZ3Vt+1V4P+uKrDtjgLbHimw7YUC2+YX2La6wLYPC2z7vsC2fwpsq1VS8bbdCmxrUWBbosC29gW29SiwLV1gW98C20YW2HZZgW23FNj2YIFtUwtsm11g24oC29YV2PZ1gW1/FthWLVjxtl3sbabjqFGB/zvB3nbX5MZTd/uo+BR924kFtvUqsO20AtuG29uea3P3PS0evqKdM17FscOuMdXsv+3DYEOPoFzTxv47XLnFqqbNi54/SddMqwU2XcD8o9UCG/smLv84czLMH3bifcTojfO7bVFLLfvvIs2Xzv+o3nAPbT+1tNPmK3Jta294L2fbkaPN762WDtq2oGvbUdq2kGtbR21bqWtbJ21bFde2ztq2qq5tXbRt1Vzbumrbqru2ddO21XBtO1rbVjOwcV2hdmDj4lxfr6WNOX508qWO9v+44ykeduavyzB/OBwLOzaVjN44f22Xn4LatjqubSFtm8NRxe4r135Xa/vt4PJdbRbfxWKcsSHfZesb+NfRfPCr5gP9+HL21X0Q5OGYK3K9XyCwaW0LuN6/eoC1/llFrvdz+Lj94xxf6rh08uXM3KC2gweddeLZg/rkBg7U2eszdtXG9e364t7HvZ97/9qG7SWu/3N72D3mWFSngv9XSzXD+yi0sf8OV3JxMjHoslt/75DLRsx7x6ytzUTn/asHOI+MjZkYcvFx+8dd6Ut5/BMucs2v8yk1+MeJZRXDNmcu5ywa0ubS9y/VbNT319ed/9fHkvZrHcOc7tytEtjcHn3M8a/iEnHZ5j4+Ta/OvO4x9/Fmqna81XdjN8lzTIUz3DlZLbB5fJHdsBNnvQN23kvZ1FYbryif9f8t1bbr+y/W5mznir1+vLUB26UfQ+46W43Hp9mtrbPO+1cPbH7sc9TZai4+bv+462x1Hj6ZItf8Op/qBv84saxh2ObM5agHPS/1/atrNur76+vO/+tjPezXOoY5S10cagQ2t0cf0+us0//UNsxV1TVvofORPm8dw//r6s/9f5Wt5ybOW6onPbXxraknIW27vv9T2pyn2eu1AxXXo0K+LDbY6Oan719qsK12YPPzjDuOVQDvrZ8Hgq73NsWD+fwaKcS1kG2FapHJNt3uagX+T99P3ydo8I2+3eRX9/mCyYfRQj4p5ENT/axmsKO2wU/VvbEtVohrIdtMtbR6Adt0u2t4Y1u8ENdCttU07F+jgG263TUL/J++n75P0OAbfbvJrx7lflkhnxTyYS3D/jUNdtQ2+KmWN7YlCnEtZNsOhv1rFbBNt3sHb2xLFuJayDbTVd0dCtim2127wP/p++n7BA2+0beb/OpR7qcK+aSQD+sY9q9tsKO2wU91vLEtXYhrIdvqGvavU8A23e663thWXohrIdvqGfavW8A23e56rv/TbdP3M3HR969ojmLXHKZe2r2tqIL/17fp76ePubWE6X1M12KB11YyheJouhK+tXF0+8kUx1qBiuNfy2C3+5qjrjPcOlnvhWq5tun1rti1zaSb3LpR7xdquf7Wa02tQMW1x30NXK279aPeq9Z0bdPPd3Vd23TdWsW1Te/xa7i26f2BU1NqBMy9s+ML3usksWyRi1tFGrm6tl3f/1n7VXH/W9tf/59AYOtyfkt9o7P/1vTjNVj8tfG6Us0t+Ev3p77/ywZ/mT6d1bW1WoKjWezJVnUmDWx+rG3gr73vlmIUCGy7DnHXaP24c19/K6T/3ce6/v+lFeyvXxfS919gv6rtOxZtyq9QjTLNrV+PMh3nRRVwrshG92c/1bdgYzWXjc7+yw028h47G2uN6dgxHcvuY+c1jbO71pjyslCt2VJeOnwqo4+LtmCfPofpmrSeE4xxCVe2pr1rv/qjpsUsU03Tj6utqWn6/sia5s6Pba1pWzre3TXN2f9z+9VU04q0/3f3eRXVtLbauFqqjA5sYseGV23M8bmTF1X1/V3bqmnbgqM3fZ/q9t9B7X30uRweIdf+v9h/O31XqfY/zv/XMbx/qev9N+FtGHNrnGqG/asZ9lc+/dZeV7nEeYwkkmHnSwf/+T4U2LReBlzvH3Lt/5f9t/t6oJOzbbaTZz6RtvLRdD4dT2ezsUy6nmt+3Wc1GN4/l0xlw6l8Lm1ZViQbzm3p/U35pNc8tTg5qeesvr8zX8i9vz2Byo1SrZ5t2Nfwfmq/hgX2K6rgdcMchrHg6E3HTLmsH+PO/s57Vx+9OUdnWw1tm16P1VLT/lv3lz6XwyPk2r+ePYETE/24dP6/juH9q7refxPehjH3MV7DsH8Nw/4qPjXsf/pPT2nvjf48fsN7uubXx9zcnNzhOK5i8XQik05YVipm5WJWfEvHVVN7Xfad8rGy/7tTvvCCulNevwallnbafEWube0N78Vpp36XMtdn5PUN/J33Uv7ZzV4vMeznPsZNfaW7NzDNoc/j9qsetzbbZ7PlHnDbWcg2Z1vIZavJbv3/9ftGA4Y5TDENGN6jpIL/Nc1bXMCOLf2v7ntTD+/wkdBjNrH//l/3mM63cP7vXFRwiTKfKyLMNdR4LjLV00LnIvcxp5Z29jbTeUo/F/3XZwf4zumUB3HmOFn1AxWfP5QPdtnomk38GgpUfB4JufZtYL+qvrVuBfOVFpjP9FmO/n872eumzwcDQF+ZeBQZeJg+r/tPawT8X8sb23//r2t5mb0uvJbH/6+WF162tpaXuPYz/U+hes9cq7l1g8X73ZKN950W+v6V/v6FvkXpfg0ENr9upb+XV99yNNlm+uypTqCwBqlortA2zvW/jKnua/e3wvXrosWubUFtm/ub5qHRm9uo+ojG2n6F+o0WLr9w1mSuWqCW+oGK+xlnzO+fw+xr/+3nz2Ga2uuqX1D5E9bmqijv9X7ffZ+Kfow7/8t8jP73nYkSA1e9ZjjvXzOw8TPMfulM7+65QYMH9Bmol1r3vwYMJjvbirTxik697v8p0fbXFwntbdz++3/d3uq3p+o80aVIv7WGYf7/2memr6RG9a9JBVzvpfvN3V7o6w6nai6fg7mm/yvtGocS13u6Oer7BAObL8Wuv93HZMlW7Ot+P32bfgt4Rf/nvtXJPeZuHwKG/f87HdivoQrmqqJt1/ev4tqXK4b1DZyKKnjvhjwc/jumGvDMHzYdUw219QYuO/W8agPi4Mzn5EDIwMn9cbveKur8ivD8LDcXU31xFidnGmhjDSvgyvQ16ogzP9PttMac0W8nreHa5sTOVNOKKvi72PVaaN+iAvOa6pAzpxMrna9jx/8DtzYnPvLrBQA=",
-      "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": "51138cca3416c965bb4ccec1358c0c804a4ada84-9e46ddc0d812ed1c7f905e43befa6173-mega-honk-true"
+      "verification_key": "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",
+      "artifact_hash": "e7552d296af009c9ed2e2ca261de6124cad0b1c1-c26139d8c2da4ae4e00fd39931e9a628-client-ivc-true"
     },
     {
-      "name": "entrypoint",
+      "name": "verify_private_authwit",
       "is_unconstrained": false,
       "custom_attributes": [
-        "private"
+        "private",
+        "view"
       ],
       "abi": {
         "error_types": {
@@ -1714,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",
@@ -1836,7 +2065,7 @@
                               }
                             },
                             {
-                              "name": "txs_effects_hash",
+                              "name": "blobs_hash",
                               "type": {
                                 "kind": "field"
                               }
@@ -2074,7 +2303,7 @@
                       }
                     ],
                     "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::header::Header"
+                    "path": "authwit::aztec::protocol_types::block_header::BlockHeader"
                   }
                 },
                 {
@@ -2167,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",
@@ -2193,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"
           }
@@ -3099,7 +3185,7 @@
                             }
                           },
                           {
-                            "name": "txs_effects_hash",
+                            "name": "blobs_hash",
                             "type": {
                               "kind": "field"
                             }
@@ -3337,7 +3423,7 @@
                     }
                   ],
                   "kind": "struct",
-                  "path": "authwit::aztec::protocol_types::header::Header"
+                  "path": "authwit::aztec::protocol_types::block_header::BlockHeader"
                 }
               },
               {
@@ -3430,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",
@@ -3448,42 +3555,19 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "7d3djiPNce77e9GxDio/IjLKt7JgLMi21oIAQTJseQMbhu9913yQ3a/IqVRvJsmI/KcODI1M1kREd1c+web8+N+/+7c//st//d///ae//J+//ufv/ul//ffv/vzXf/3D3/70178cf/rv35Xy/X/7z3//w1++/fE///aH//jb7/4p6b79/nd//Mu/Hf+1bdv//P53/+dPf/7j7/6plvw/v795dLZiPx+dTT8eneq9RxdJ+89HF9lz59H7JpdK9k3L9dE5b3cencr12qkU+3i03nvwlvXy4K3J5wf/8+9/V+oazP3ByBrM/cHoGsz9wbQ1mPuDsTWY+4PZ12DuDqZuazD3B5PWYO4PJq/B3B/MSr6/GExdg7k/mJV8fzGYlXx/MZiVfH8xmJV8fzGYlXzvD0ZW8v3FYFby/cVgVvL9xWBW8v3FYOoazP3BrOT7i8Gs5PuLwazk+4vBrOT7i8Gs5Ht/MLqS7y8Gs5LvLwazku8vBrOS7y8GU9dg7g9mJd9fDGYl318MZiXfXwxmJd9fDGYl3/uDaSv5/mIwK/n+YjAr+f5iMCv5/mIwdQ3m/mBW8v3FYNwnX2uXwaQt9QbTrFzqti0/NBj3yfddg3GffN81mAHJt+wt/3x03baPn+y9fPsbbHv633A3i6levlpq2rl+ErkOVHS/PrqUeu/R6frFSrltnx59b/7Ht8rlG8E059fdJS2vsdwbS1ljuTeWusZybyyyxnJvLLrGcm8sbY3l3lhsjeXeWPY1ljtj2bc1lntjWSn37lhWyr07lpVy746lrrHcG8tKuXfHslLu3bGslHt3LCvl3h3LSrn3xpK2FXPvz2Xl3PtzWUH3/lxW0r0/l7rmcncuK+ven8sKu/fnstLu/bk4j7tVr3P59Mv6p/9CPW3O8+675pIG5N32MRfrz6V9zEXqp0c3Vz9HKa253J1LXnO5O5ey5nJ3LnXN5e5cZM3l7lx0zeXuXNqay9252JrL3bnsay735pJX3r0/l5V3789l5d37c1l59/5c6prL3bk4z7vvev0lO8+7b5vLgLx7/V5PKltnLm/s1DCd7pROy+MpU/X6c9pS7v1Ub3u9PDp9uq9/u/b3epKzerKzeoqzeqqzesRZPeqsnuasHnNWz+6rnurs/lyd3Z+rs/tzdXZ/rs7uz9XZ/bk6uz9XZ/fn6uz+XJ3dn8XZ/Vmc3Z/F2f1ZnN2fxdn9WZzdn8XZ/Vmc3Z/F2f1ZnN2f1dn9WZ3dn9XZ/Vmd3Z/V2f1Znd2f1dn9WZ3dn9XZ/Vmd3Z+bs/tzc3Z/bs7uz83Z/bk5uz83Z/fn5uz+3Jzdn5uz+3Nzdn82Z/dnc3Z/Nmf3Z3N2fzZn92dzdn82Z/dnc3Z/Nmf3Z3N2f96d3Z93Z/fn3dn9eXd2f96d3Z93Z/fn3dn9eXd2f96d3Z/3V9+fU/mop3UJ+Hp5cFb79Nh057E1y6WOmtvHpyOk/c6DpW6Xd/lJzfXzg4+p5G1bU7kzlbSmcmcqeU3lzlTKmsqdqdQ1lTtTkTWVO1PRNZU7U2lrKnemYmsqd6aysu2dqaSVbe9NZWXbe1NZ2fbeVFa2vTeVuqZyZyor296bysq296aysu29qaxse28qK9vemUpe2fbeVFa2vTeVlW3vTWVl23tTqWsqd6aysu29qaxse28qK9vem8rKtvemsrLtnamUlW3vTWVl23tTWdn23lTmyba6XR5cNW83jVZKo/Mk0E6j84TKTqPz5EQVuTbabhudJ/p1Gp0nzZ03WucJaJ1G58lcnUbniVHnd91KSUYv593e1iglGdWJktH5zYiSjColGVVKMhJKMhJKMpKJktF5oxMlo/NGK6XRiZLReaOU14xkomR03uhEyei80YmS0WmjSklGSklGSklGSklGLydN39YoJRkp5TUjpbxmpJTXjJTymlGbKBmdRsA2UTI6b5Ty27RG+W3ayzHht92MKMmoUZJRoySjRklGjZKMjPKakVFeMzLKa0ZGec3o5Yz3uyKgUd5nZJTfphnlt2lGSUZGSUY7JRntlGS0U5LRTklGLwf039Yo5TWjnfKa0U55zWinvM9ook8/OG20TPSBBp1GIb9NKxN97MDpzahM9EkCnUYrpVFIMioTEf6dRiHJqEwE7XcahbxmVCbi8DuNQl4zKhOh9ecRcCKHvtNopTQK+W1amQiA79yMKMloIqa90yglGU2EqXcapSSjicjzTqOU14wmgsk7jVJeM5qIDz+PgBOJ4J1GIb9NKxO53eeNTkRxn9+MJtK1O41SktFMBvZ5o5XSKCUZzWRgnzdKec2IYmAXioFdZjKwTyPgTAb2eaOU36ZRDOwyk4F9fjOiJCOKgV0oBnahGNiFYmAXioFdKAZ2oRjYhWJgl5kM7NMIOJOBfd4o5bdpFAO7zGRgn9+MKMmIYmAXioFdKAZ2oRjYhWJgF4qBXSgGdqEY2GUmA/s0As5kYJ82SjGwC8XALjMZ2Kc3o5kM7PNGK6VRSjKiGNiFYmAXioFdKAZ2oRjYhWJgl5kM7NMIOJOBfd5opTRK+W3aTAb2+c2IkowoBnahGNiFYmAXioFdKAZ2oRjYhWJgF4qBXWYysE8j4EwG9nmjlN+mUQzsOpOBfXYzqjMZ2OeNQpJRpRjYdauURiHJqFIM7EoxsCvFwK4UA7vOZGCfRsCZDOzzRiG/TasUA7vOZGCf34woyYhiYFeKgV0pBnalGNiVYmBXioFdKQZ2pRjYdSYD+zQCzmRgnzcK+W1apRjYdSYD+/xmRElGFAO7UgzsSjGwK8XArhQDu1IM7EoxsCvFwK4zGdinEXAmA/u0UYqBXSkGdp3JwD69Gc1kYJ83WimNUpIRxcCuFAO7UgzsSjGwK8XArhQDu85kYJ9GwJkM7PNGK6VRym/TZjKwz29GlGREMbArxcCuFAO7UgzsSjGwK8XArhQDu1IM7DqTgX0aAWcysM8bpfw2jWJg15kM7NOb0UwG9nmjlGREMbArxcCuFAO7UgzsSjGwK8XArhQDu85kYJ9GwJkM7PNGKb9NoxjYdSYD+/xmRElGFAO7UgzsSjGwK8XArhQDu1IM7EoxsCvFwK4zGdinEXAmA/u8Ucpv0ygGdp3JwD6/GUGSkVAMbKEY2EIxsIViYMtWKY1CXjMSioEtFANbZjKwzyKgzGRgnzZKMbCFYmDLTAb26c1oJgP7vNFKaZSSjCgGtlAMbKEY2EIxsIViYAvFwJaZDOzTCDiTgX3eaKU0CvltmsxkYJ/fjCjJiGJgC8XAFoqBLRQDWygGtlAMbKEY2EIxsGUmA/s0As5kYJ83SvltGsXAlpkM7NOb0UwG9nmjlGREMbCFYmALxcAWioEtFANbKAa2UAxsmcnAPo2AMxnY541SfptGMbBlJgP7/GZESUYUA1soBrZQDGyhGNhCMbCFYmALxcAWioEtMxnYpxFwJgP7vFHKb9MoBrbMZGCf34woyYhiYAvFwBaKgS0UA1soBrZQDGyhGNhCMbBlJgP7NALOZGCfNkoxsIViYMtMBvbpzWgmA/u80UpplJKMKAa2UAxsoRjYQjGwhWJgC8XAlpkM7NMIOJOBfd5opTRK+W3aTAb2+c2IkowoBrZQDGylGNhKMbCVYmArxcA+DllKo5DXjHQmA/ssAupMBvZ5o5DfpinFwNaZDOzTm9FMBvZ5o5RkRDGwlWJgK8XAVoqBrRQDWykGtlIMbJ3JwD6NgDMZ2OeNQn6bphQDW2cysM9vRpRkRDGwlWJgK8XAVoqBrRQDWykGtlIMbKUY2DqTgX0aAWcysM8bpfw2bSYD+/xnlPLbNIqBrTMZ2OeNUpLRTAb2+VeU8prRTAb2eaOUZEQxsJViYCvFwFaKga0zGdjnjVKS0UwG9nmjlNeMJjKwm6VLo83KTaOuk5Fsl0uL1U6jKdt+uXL59ojLo/PPTl1Ho691KvbRqd526jobfanT4xKXK9cqt526DkdDO3WdjkZ26hvCHtqp63w0tFPXAWlop64T0tc6le3aqZbbTium03kyUq/TeTJSr9OJMlKn04kyUqfTmTJS+ui03nTqm8T+WqfturXVPd92OlFG6nQ6UUbqdDpRRup0WjGdTpSROp1OlJH2ax2StttOJ8pInU4nykidTifKSOed+saxh3Y6UUbqdDpTRrKPTm9/W+Hbx/5Sp1Kv56mm325td361tV1/XZXT3/0W5/bRpV17LPbp2qn9GGJdQ3x8iPMkuzcOcZ7Q+MYhzpNH3zjEeaLuM4do++XRZb8zxHlS9PuG6NtojzLEebL/G4c4z1rxxiGujWXAEOsa4uNDXBvLgCGujWXAEKkbS87XIWbdO48+XguTj9fCPq6d092vT7peeit2/uCSi16+PLntnx/8/ctD3YW8fHnK9Y3spex68+Whblkhfnqa70+SoP/0NN+ff7F+eqg7Z5CfHuo2+8QvT8mX6eXS7GbilTrxXa5jyVvn0TXLpZCa22/+Od+dout2uQVJzfXzg79PnLonv2/i1KX6fRPHbuBvmzh2qX7bxLF78rsm7vujgqacOHabfdvEsQvq2yaO3TnfNvG6Jv7iia+d89UTXzvnqye+ds5XT3ztnK+e+No5Xzxx3x/CNuXE18756omvnfPVE18756snXtfEXzzxtXO+euJr53z1xNfO+eqJr53z1RNfO+eLJ+774y2nnPjaOV898bVzvnria+d89cTrmviLJ752zldPfO2cr5742jlfPfG1c/4jEz/9jMTm+yN4gwzR98f7RhniWvYGDHHtb//QEM8+7675/sjjKEOsa4iPD3EtTgOGuHahAUNc682A03ltLAOGuDaWx4fo+2O3owxxbSyPHyy+Py48yhDXxjJgiHUN8fEhro1lwBDXxjJgiGtjGTDEtbEMGOLaWB4foq6NZcAQ18by+Nqna2MZMMS1sQwYYl1DfHyIa2MZcLCsjWXAENfGMmCIa2MZMMS1sTw+xLY2lgFDXBvLgCGujWXAENfGMmCIdQ3x8SGujeXxta+tjWXAENfGMmCIa2MZMMS1sTx+sNjaWAYMcW0sA4a4NpYBQ1wby4Ah1jXEx4e4NpYBQ1wby4Ahro1lwBDXxjJgiGtjeXzt29fGMmCIa2MZMMS1sQwY4tpYHj9Y9rqG+PgQ18YyYIhrYxkwxLWxDBji2lgGDHFtLA8P0ba1sQwY4tpYBgxxbSwDhrg2lofXPtvqGuLjQ1wby4Ahro1lwBDXxjLgYFkby4Ahro3l8SGmtbEMGOLaWAYMcW0sA4a4NpYBQ6xriI8PcW0sA4a4NpYBQ1wby+NrX1oby4Ahro3l8SHmtbEMGOLaWB4/WPLaWAYMcW0sA4ZY1xAfH+LaWAYMcW0sA4a4NpYBQ1wby4Ahro3l8SGWtbEMGOLaWB5f+8raWAYMcW0sA4ZY1xAfH+LaWAYcLGtjGTDEtbEMGOLaWAYMcW0sjw9xfeb9iCGujWXAENfGMmCIa2MZMMS6hvj4ENfG8vjatz7zfsQQ18YyYIhrYxkwxLWxPH6wrM+8HzHEtbEMGOLaWAYMcW0sA4ZY1xAfH+LaWAYMcW0sA4a4NpYBQ1wby4Ahro3l8bVvfeb9iCGujWXAENfGMmCIa2N5/GBZn3k/YohrYxkwxLWxDBji2lgGDHFtLAOGuDaWx4e4PvN+xBDXxjJgiGtjGTDEtbE8vvatz7wfMcS1sQwY4tpYBgxxbSwDDpa1sQwY4tpYHh/i+sz7EUNcG8uAIa6NZcAQ18YyYIh1DfHxIa6NZcAQ18YyYIhrY3l87VufeT9iiGtjeXyI6zPvRwxxbSyPHyzrM+9HDHFtLAOGWNcQHx/i2lgGDHFtLAOGuDaWAUNcG8uAIa6N5eEh7usz70cMcW0sD699+/rM+xFDXBvLgCHWNcTHh7g2lgEHy9pYBgxxbSwDhrg2lgFDXBvL40Ncn3k/YohrYxkwxLWxDBji2lgGDLGuIT4+xLWxPL72rc+8HzHEtbEMGOLaWAYMcW0sjx8s6zPvRwxxbSwDhrg2lgFDXBvLgCHWNcTHh7g2lgFDXBvLgCGujWXAENfGMmCIa2N5fO1bn3k/YohrYxkwxLWxDBji2lgeP1jWZ96PGOLaWAYMcW0sA4a4NpYBQ1wby4Ahro3l8SGuz7wfMcS1sQwY4tpYBgxxbSyPr33rM+9HDHFtLAOGuDaWAUNcG8uAg2VtLAOGuDaWx4e4PvN+xBDXxjJgiGtjGTDEtbEMGGJdQ3x8iGtjGTDEtbEMGOLaWB5f+9Zn3o8Y4tpYHh/i+sz7EUNcG8vjB8v6zPsRQ1wby4Ah1jXEx4e4NpYBQ1wby4Ahro1lwBDXxjJgiGtjeXyI6zPvRwxxbSyPr33rM+9HDHFtLAOGWNcQHx/i2lgGHCxrYxkwxLWxDBji2lgGDHFtLI8PcX3m/Yghro1lwBDXxjJgiGtjGTDEuob4+BDXxvL42rc+837EENfGMmCIa2MZMMS1sTx+sKzPvB8xxLWxDBji2lgGDHFtLAOGWNcQHx/i2lgGDHFtLAOGuDaWAUNcG8uAIa6N5eG1L23rQ++HTHHtLCOmuJaWEVNcW8vDh8sxxbqmOGCKa28ZMcW1uIyY4tpcRkxxrS4jprh2lwFTTGt3GTHFtbuMmOLaXUZMce0uAzbAVNcUB0xx7S4jprh2lxFTXLvLiNNl7S4jprh2lwFTzGt3GTHFtbuMmOLaXUZMce0uI6ZY1xQHTHHtLiOmuHaXEVNcu8uADTCv3WXEFNfuMmCKZe0uI6a4dpcBp0tZu8uIKa7dZcQU65rigCmu3WXEFNfuMmKKa3cZMcW1u4yY4tpdBkyxrt1lxBTX7jJgA6xrdxkxxbW7jJhiXVMcMMW1u4w4XdbuMmKKa3cZMcW1u4yY4tpdBkxR1u4yYoprdxkxxbW7jJji2l1GTLGuKQ6Y4tpdBmyAsnaXEVNcu8uIKa7dZcQU1+4y4HTRtbuMmOLaXUZMce0uI6a4dpcRU6xrigOmuHaXEVNcu8uIKa7dZcQU1+4yYoprdxmwAba1u4yY4tpdRkxx7S4jprh2lwGnS6trigOmuHaXEVNcu8uIKa7dZcQU1+4yYoprdxkwRVu7y4gprt1lxBTX7jJiimt3GbABWl1THDDFtbuMmOLaXUZMce0uI06XtbuMmOLaXQZMcV+7y4gprt1lxBTX7jJiimt3GTHFuqY4YIprdxkxxbW7jJji2l0GbID72l1GTHHtLo9PMW1rdxkxxbW7PH66pG3tLiOmuHaXEVOsa4oDprh2lxFTXLvLiCmu3WXEFNfuMmKKa3cZMMW0dpcRU1y7y4ANMK3dZcQU1+4yYop1TXHAFNfuMuJ0WbvLiCmu3WXEFNfuMmKKa3cZMMW8dpcRU1y7y4gprt1lxBTX7jJiinVNccAU1+4yYAPMa3cZMcW1u4yY4tpdRkxx7S4DTpeydpcRU1y7y4gprt1lxBTX7jJiinVNccAU1+4yYoprdxkxxbW7jJji2l1GTHHtLgM2wLp2lxFTXLvLiCmu3WXAfbGu3WXE92JdUxwwxbW7jJji2l1G3BfX7jLie3HtLiOmuHaXAVOUtbuMmOLaXQacLrJ2lxFTXLvLiCnWNcUBU1y7y4gprt1lxBTX7jJiimt3GTHFtbv8I1Nsli5TbFZupqjU3eXj0lmy/ubRPwYzzzqi+VqH1nSn1Xl2BrXto47tTqvzBPtuq5XT6jwRudvqPDm22+o8YbPb6jyJsNvqPLGt1+pEn/vdbXWitNRrlZOWJvqY626rldMqJy1N9KnO3VY5aWmiz0futspJSxN90nC3VU5amugze7utctLSRJ9+222Vk5Ym+hzZbquctDTRJ7J2W+WkpYk+27TbKictTfQpod1WOWnJ+edt7pc3CKikTqvZVH8+OJt91JF2ufPosuX889ElVft49Lf3Idw82nS7/P7eNH9cO397j8NtjyVdf9tfyse1v/0q//bBW76UnbYmnx/84wvkO+OtL5DzTwldXyDnH0C6vkDOP9t0fYGcf2wq/guUnX8i6/oCOf+w1/UFcv45susL5PwjatcXaKvrC+T7C7ReSXD+BVqvJDj/Aq1XEpx/gdYrCf/QF6jq9QukW+8L1KxcerQtP/gFWq8k+P4COf985K98gfZ0GUvZWu18gd458nleGwgz8mm2/ZLydeRJW2fkuV7/HXKu9unR7V7RZtch7tunf55tP4c4zUb+zCHuVyng+EXU5xv/nQfX6zjqfvPP4bPzj2j2Me/jpfBLHcdrevWheU+zLz9z3ul6yz9uCPvtTWKanfaZQzwefXlwtnL+TZuKXedRN7md+DRLapiJT7N1upm4lGvYE9GH7uLTbJwTfnGcf6J1yC9Ou+ZN2R/Km84/KBv+xZlog93k44tjnS9OrenyQlo9/nP+xSnt2mKxT+zW8eAfQ5xog33eEO1aR9nvDbGuIT4+xIl2zfcNcaJd831DnGh9fN8QJ9oI3zfEiTa3tw3R+eduBxniRJvQ+4a4NpYBQ5xzY2m990+krV7/HevW0vkQJe2XouX4rdntEOsa4uNDnHNjefEQ59xYXjzEOTeWwUPM1zfbSFa9HeKcG8uLhzjnxvLaITr/tO0gQ5xzYxk8RG2XOqSlTjJvWi4Tb2q3ydz5B3PPOPG1C/0DE7d0nbhJfnDidU189MT3yzxaS+l24mvLevXEX72SbfvHxD/9a6lv1/5RUPNW0Prlxj/yQl69vuXEpN1+m61fbjw+xOd+uPWPv+LxIN3ydfKt7r2vk+Xrjc9q+/Tou3e+dv3c6iNP7b+Z/Y/yc+zyS+zy64vL37fLpY8aSqf8ZO3jn95aKx+17Pf+UWI+Lnn9F49pN/n88B/tCqtdZbXbWO0aq90d1e6Aj5YN1W5itZtZ7RZWu5XVLitVqe9UtZeSPx7+6R061/q9H6TtenGzst3Uf/+DQZPuH4781nv5oOztuuRvm93+HekFf0d+wd/x4htvzulSfc6f/uXdL77WIh/2gLRPr6Je66/B6xfX9ev+8SK27p/+3dm1fg1efwtevwWvf49dv23B60/B68/B6/d9/vbr933+9usPfv5a8PPXXv2SbLPr8mNb+k39PwoybwXtzgraX7Be7S9Yr/YXrFd78PVq931779fv+/ber9/Z3ahs3l+XPn9tqGy+X2juvTZXtvr0m1a5r+wP/jv0BX/Hq7PF0LdelM1il7+HLj+hfr1aEurXqyWhfr1aEurXq2UAMxyqXdSvV0tCvWmtJNSb1kpCvWmtJNSb1kpmparMSlWZlaoyK1UNUDL9tHssfeW6/5Xb11nyTJmq22zsN6yV7Dsi7fv1ReHjv9ft/Iuldv3nZWr5o5SfL8Bm3/lobK++w9HQXovvZDS2V9+xaGyvvjPRV3vVcq37U0S49Or8lytDe62gXn2HobG9Os9CQ3udKzed9zpXbjrvda7cdNprnSs3nfc6V2467xWUmyooNw0AuOL0CspNFZSbKig3VVBuqqDcJKDcJKDcJKDcJKDc5BziGtsrKDc5J7jG9grKTc7xrbG9gnKTc3ZrbK+g3OQc3BrbKyg3Oae2xvYKyk3eka2hvYJyk4Jyk3NobWivDZSbGig3NVBuaqDc9GpY7629gnJTmyo37dv1vZd7uu11qtzU6XWq3NTpdarcdN6rTZWbOr1OlZs6vU6Vmzq9TpWbOr1WUK9T5aZOr6DcZKDcZKDcZKDctINy0w7KTTsoN+2g3PRqafStvYJy0w7KTTsoN+2g3LRzclPdOLmpbpzcVJ3DzWN75eSmulVQr5zcVDdObqobJzfVjZOb6gbKTc698LG9gnKTcyl8bK+g3OTcCB/bKyg3OdfBx/YKyk3OXfCxvYJyk3MRfGyvoNzk3AIf2ysoNzlXwMf2CspN3g3wob2CctNcXninV1BumssL7/QKyk1zeeGdXkG5aS4vvNMrKDfN5YV3egXlprm88E6voNw0lxfe6RWUm+bywju9gnLTXF54p1dQbprLC+/0CspNc3nhnV5BuWkuL7zTKyg3zeWFd3oF5aa5vPBOr6DcNJcX3ukVlJvm8sI7vYJy01xeeKdXUG6aywvv9ArKTXN54Z1eQblpLi+80ysoN83lhXd6BeWmubzwTq+g3DSXF97pFZSb5vLCO72CchPIC68gL7yCvPAK8sIryAuvIC+8grzwCvLCK8gLryAvvIK88ArywivIC68gL7yCvPAK8sIryAuvIC+8grzwCvLCK8gLryAvvIK88ArywgXkhQvICxeQFy4gL1y2CuqVk5sE5IULyAsXkBcuIC9cQF64gLxwAXnhAvLCBeSFC8gLF5AXLiAvXEBeuIC8cAF54QLywgXkhQvICxeQFy4gL1xAXriAvHABeeEC8sIF5IULyAsXkBcuIC9cQF64gLxwAXnhAvLCBeSFC8gLF5AXLiAvXEBeuIC8cAF54QLywgXkhQvICxeQFy4gL1xAXriAvHABeeEC8sIF5IULyAsXkBcuIC9cQF64gLxwAXnhAvLCBeSFC8gLF5AXLiAvXEBeuIC8cAF54QLywgXkhQvICxeQFy4gL1xAXriAvHABeeEC8sIF5IULyAsXkBcuIC9cQF64gLxwAXnhAvLCBeSFC8gLF5AXLiAvXEBeuIC8cAF54QLywgXkhQvICxeQFy4gL1xAXriAvHAFeeEK8sIV5IUryAvXrYJ65eQmBXnhCvLCFeSFK8gLV5AXriAvXEFeuIK8cAV54QrywhXkhSvIC1eQF64gL1xBXriCvHAFeeEK8sIV5IUryAtXkBeuIC9cQV64grxwBXnhCvLCFeSFK8gLV5AXriAvXEFeuIK8cAV54QrywhXkhSvIC1eQF64gL1xBXriCvHAFeeEK8sIV5IUryAtXkBeuIC9cQV64grxwBXnhCvLCFeSFK8gLV5AXriAvXEFeuIK8cAV54QrywhXkhSvIC1eQF64gL1xBXriCvHAFeeEK8sIV5IUryAtXkBeuIC9cQV64grxwBXnhCvLCFeSFK8gLV5AXriAvXEFeuIK8cAV54QrywvXVXnjO1+JzFu31Ksd/LheX1tLnXn/Uv8eu/9Wu91frb3u+1m+5dL7XLF2/1yzvf/+99mrX+629ZlCvBdRrBfUqoF4V1Gubqlct17rtJt/szvPN0F6dZ6GBvbZtrtx03utcuem817ly03mvc+Wm814rqNe5ctN5r3PlpvNeObmpbZzc1DZQbkqg3JRAuSmBclMC5aZXu95v7RWUmxIoNyVQbkqg3JRAuSmDclMG5aYMyk0ZlJte7Xq/tVdQbsqg3JRBuSmDclMG5aYCyk0FlJsKKDcVUG56tev91l5BuamAclMB5aYCyk0FlJsqKDdVUG6qoNxUQbnp1a73W3sF5aYKyk0VlJsqKDdVUG4SUG4SUG4SUG6SqXLT6b8/bq92vd/aq+/cpHu9/rty3bV97vVH/b6zUL9+3/mmX7/vzNKv33cO6davvrNFv37feaFfv+8M0K/f97ner9/3Wd2vP/j5q8HPXw1+/mrw81eDn78t+Pnbgp+/Lfj524Kfv682iYfXH/z8bcHP3xb8/G3Bz98W/Py14OevBT9/Lfj5a8HP31fbtsPrD37+WvDz14Kfv86t2H79wc9f51Zsv/7g569z07Vff/Dz17m92q8/+Pnr3Ejt1x/8/HVumfbrj33+mnNztF9/7PPXnNug/fpjn7+2xT5/zbnL2a8/9vlrzv3Mfv2xz19z7lx263duV/brD37+Ojcm+/UHP3+dW5D9+oOfv87Nxn79wc9f57Ziv/7g569zA7Fff/Dz17lV2K8/+Pnr3BTs1x/8/HVu//XrD37+Ojf6+vUHP3+dW3r9+oOfv87Nu379wc9f5zZdv/7g569zQ65ff/Dz17n11q8/+Pnr3GTr1x/8/HVup/XrD37+OjfO+vUHP3+dW2T9+oOfv87NsH79wc9f57ZXv/7g569zg6tff/Dz17mV1a8/+Pkb3L+y4P6VBfevLLh/ZcH9KwvuX1lw/8qC+1cW3L+y4P6VBfevLLh/ZcH9KwvuX1lw/8qC+1cW3L+y4P6VBfevLLh/ZcH9KwvuX1lw/8qC+1cW3L+y4P6VBfevLLh/ZcH9KwvuX1lw/8qC+1cW3L+y4P6VBfevLLh/ZcH9KwvuX1lw/8qC+1cW3L+y4P6VBfevLLh/tQf3r/bg/tUe3L/anftXIz/rb998n9Vje53q86A7vU71edCdXqf6POhOr1N9HnSn16k+D/q8V+dm2NheXeebXOqlkFz2+unR+rN81/GmX77rdNMvv8Yu33UG6ZfvOlb0y3edFPrluz78++W7Ps+75ftmxfrlv/rUlbJfChItnfKt5MujrbZ6ni+aXR+bPx56fIP97DR77vTs0T/KL7HLr7HLl9jla+zyW+zyLXb5e+jyX+6ODS7f9QHdLz/2qVtin7ovN8cGlx/71C2xT90S+9QtsU/dEvvUrbFP3Rr71K2xT90a+9R9uTQ2uPzYp26NferW2KdujX3q1tinrsQ+dSX2qTtCGGvlWv4unfLNtnZ5xdv2zm/fk5TrpXXL1wenvP2s/vFD96Oeb9x4p/rjb7xcOu32uVe982hp2+ULKy19fGGPq/wsv8YuX2KXr68tP29VLz+L2/EbnvPyv+EN+/Xirej5j0r+1s/l6r+ZzuW9oAMsslDtGqvdHdXuABgtVLuJ1W5mtVtY7VZWu8Jql5WqlJWqlJWqlJWqRnB3X3kxoLuijfDrxhaUvRVUvBVUvRUk3gpSbwU1bwWZt4J2ZwWZ7/13L+X6j6yOV8jLzUljvhfafb++Yf3473U7P1jV0vUfiVn++Gr9fIndfG+zY3v1vcqO7bWCevW9xI7t1fcG+9VetVzrtpt/wGq+19exvfreXcf26ntxHdrr7jwLDe11rtx03utcuem817ly03mvFdTrXLnpvFdQbtpBuWkH5aYdk5vytmFy09ErJjcdvWJy09ErJjcdvVZQr5jcdPSKyU1Hr5jcdPSKyU1Hr6DclEC5KYFyUwLlpgTKTQOcxTi9gnJTAuWmBMpNCZSbEig3ZVBuyqDclEG5KYNy0wD+Mk6voNyUQbkpg3JTBuWmDMpNBZSbCig3FVBuKqDcNAAwjdMrKDcVUG4qoNxUQLmpgHJTBeWmCspNFZSbKig3DSBo4/QKyk0VlJsqKDdVUG6qoNwkoNwkoNwkoNwkoNz0akX4rb2CcpNzn3hsr6Dc5FwmHtsrKDc5N4nH9grKTc414rG9gnKTc4d4bK+g3ORcIB7bKyg3ObeHx/YKyk0NlJsaKDc1UG5qoNw0QHiO0ysoNzVQbmqg3NRAuamBcpN3A3xor6DcNJkXft4rKDdN5oWf9wrKTRwv/OgVlJs4XvjRKyg3cbzwb3/dTL3u2/VzG/Z02+tUuanT61S5qdNrBfU6VW7q9DpVbur0OlVu6vQ6VW7q9DpVbjrtNc3lhXd65eSmNJcX3umVk5vSVkG9cnJTmssL7/TKyU1pLi+80ysoN83lhXd6BeWmubzwTq+g3DSXF97pFZSb5vLCO72CctNcXninV1BumssL7/QKyk1zeeGdXkG5aS4vvNMrKDfN5YV3egXlprm88E6voNw0lxfe6RWUm+bywju9gnLTXF54p1dQbprLC+/0CspNc3nhnV5BuWkuL7zTKyg3zeWFd3oF5aa5vPBOr6DcNJcX3ukVlJvm8sI7vYJy01xeeKdXUG6aywvv9ArKTXN54Z1eQblpLi+80ysoN83lhXd6BeWmubzwTq+g3DSXF97pFZSb5vLCO72CctNcXninV1BumssL7/QKyk1zeeGdXkG5aS4vvNMrKDfN5YV3egXlprm88E6voNw0lxfe6RWUm+bywju9gnLTXF54p1dQbprLC+/0CspNc3nhnV5BuWkuL7zTKyg3zeWFd3oF5SaQF55AXngCeeEJ5IUnkBeeQF54AnnhCeSFZ5AXnkFeeAZ54RnkhR9/NahXTm7KIC88g7zwDPLCM8gLzyAvPIO88AzywjPIC88gLzyDvPAM8sIzyAvPIC88g7zwDPLCM8gLzyAvPIO88AzywjPIC88gLzyDvPAM8sIzyAvPIC88g7zwDPLCM8gLzyAvPIO88AzywjPIC88gLzyDvPAM8sIzyAvPIC88g7zwDPLCM8gLzyAvPIO88AzywjPIC88gLzyDvPAM8sIzyAvPIC88g7zwDPLCM8gLzyAvPIO88AzywjPIC88gLzyDvPAM8sIzyAvPIC88g7zwDPLCM8gLzyAvPIO88AzywjPIC88gLzyDvPAM8sIzyAvPIC88g7zwDPLCM8gLzyAvPIO88AzywjPIC88gLzyDvPAM8sIzyAvPIC88g7zwDPLCM8gLzyAvPIO88AzywjPIC88gLzyDvPAC8sILyAsvIC+8gLzwslVQr5zcVEBeeAF54QXkhReQF15AXngBeeEF5IUXkBdeQF54AXnhBeSFF5AXXkBeeAF54QXkhReQF15AXngBeeEF5IUXkBdeQF54AXnhBeSFF5AXXkBeeAF54QXkhReQF15AXngBeeEF5IUXkBdeQF54AXnhBeSFF5AXXkBeeAF54QXkhReQF15AXngBeeEF5IUXkBdeQF54AXnhBeSFF5AXXkBeeAF54QXkhReQF15AXngBeeEF5IUXkBdeQF54AXnhBeSFF5AXXkBeeAF54QXkhReQF15AXngBeeEF5IUXkBdeQF54AXnhBeSFF5AXXkBeeAF54QXkhReQF15AXngBeeEF5IUXkBdeQF54AXnhBeSFF5AXXkBeeAF54QXkhReQF15AXngBeeEF5IUXkBdeQF54AXnhFeSFV5AXXkFeeAV54XWroF45uamCvPAK8sIryAuvIC+8grzwCvLCK8gLryAvvIK88ArywivIC68gL7yCvPAK8sIryAuvIC+8grzwCvLCK8gLryAvvIK88ArywivIC68gL7yCvPAK8sIryAuvIC+8grzwCvLCK8gLryAvvIK88ArywivIC68gL7yCvPAK8sIryAuvIC+8grzwCvLCK8gLryAvvIK88ArywivIC68gL7yCvPAK8sIryAuvIC+8grzwCvLCK8gLryAvvIK88ArywivIC68gL7yCvPAK8sIryAuvIC+8grzwCvLCK8gLryAvvIK88ArywivIC68gL7yCvPAK8sIryAuvIC+8grzwCvLCK8gLryAvvIK88ArywivIC68gL7yCvPAK8sIryAuvIC+8grzwCvLCK8gLryAvvIK88ArywgXkhQvICxeQFy4gL1y2CuqVk5sE5IULyAsXkBcuIC9cQF64gLxwAXnhAvLCBeSFC8gLF5AXLiAvXEBeuIC8cAF54QLywgXkhQvICxeQFy4gL1xAXriAvHABeeEC8sIF5IULyAsXkBcuIC9cQF64gLxwAXnhAvLCBeSFC8gLF5AXLiAvXEBeuIC8cAF54QLywgXkhQvICxeQFy4gL1xAXriAvHABeeEC8sIF5IULyAsXkBcuIC9cQF64gLxwAXnhAvLCBeSFC8gLF5AXLiAvXEBeuIC8cAF54QLywgXkhQvICxeQFy4gL1xAXriAvHABeeEC8sIF5IULyAsXkBcuL/fCS71cOpe99no9fi8hl4sf95b0udcf9efg9Rff9bc9X+u3XDrfa5au32uW95vvtQrqVUC9KqjXBurVQL3unF5f7no/t1ct17rtJt/szvPN0F6dZ6Ghvc6Vm857raBe58pN573OlZvOe50rN533OlduOu91rtx01qtunNykGyc36cbJTbpxcpNuFdQrJzfpxslNunFyk26c3KQbKDclUG5KoNyUQLkpgXLTy13vd/YKyk0JlJsSKDclUG5KoNyUQbkpg3JTBuWmDMpNL3e939krKDdlUG7KoNyUQbkpg3JTAeWmAspNBZSbCig3vdz1fmevoNxUQLmpgHJTAeWmAspNFZSbKig3VVBuqqDc9HLX+529gnJTBeWmCspNFZSbKig3CSg3CSg3CSg3CSg3vdz1fmevoNwkoNwkoNwkoNwkoNykoNykoNykoNykoNz0ctf7nb2CcpOCcpOCcpNOlZtOHUPVqXLTea/Nd27SvV59St21fe71R/2+s1C/ft/5pl+/78zSr78Gr993tujX7zsv9Ov3nQH69fs+1/v1+z6ru/Vb8PPXufncrz/4+evcfO7XH/z8dW4z9+sPfv46N5T79Qc/f51bx936nfvF/fqDn7/OneF+/cHPX+cecL/+4Oevc7e3X3/w89e5r9uvP/b525w7uP36Y5+/zblX268/9vnbttjnb3Nuxfbrj33+Nuema7/+2Odvc26vdut37qn26w9+/jp3T/v1Bz9/nfuk/fqDn7/OHdF+/cHPX+feZ7/+4Oevc5ezX3/w89e5n9mvP/j569y57Ncf/Px17lH26w9+/jp3I/v1Bz9/nfuO/fqDn7/OHcZ+/cHPX+deYr/+4Oevc9ewX3/w89e5P9ivP/j569wJ7Ncf/Px17vn16w9+/jp39/r1Bz9/nft4/fqDn7/OHbt+/cHPX+feXL/+4OevcxeuX3/w89e539avP/j569xZ69cf/Px17qH16w9+/jp3y/r1Bz9/nfti/fqDn7/OHbB+/cHPX+deV7/+4Oevc1erX3/w8ze4f9WC+1ctuH/VgvtXLbh/1YL7Vy24f9WC+1ctuH/VgvtXLbh/1YL7Vy24f9WC+1ctuH/VgvtXLbh/1YL7Vy24f9WC+1ctuH/VgvtXLbh/1YL7Vy24f9WC+1ctuH/VgvtXLbh/1YL7Vxbcv7Lg/pUF968suH9lW+zz14L7Vxbcv7Lg/pUF968suH9lwf0rC+5fWXD/yoL7Vxbcv7Lg/pUF968suH9lwf0rC+5fWXD/yoL7Vxbcv7Lg/pUF968suH9lwf0rC+5fWXD/yoL7Vxbcv7Lg/pUF968suH9lwf0rC+5fWXD/yoL7Vxbcv7Lg/pUF968suH9lwf0rC+5fWXD/yoL7Vxbcv7Lg/pUF968suH9lwf0rC+5fWXD/yoL7Vxbcv7Lg/pUF968suH9lwf0rC+5fWXD/yoL7Vxbcv7Lg/pUF968suH9lwf0rC+5fWXD/yoL7Vxbcv7Lg/pUF968suH9lwf0rC+5fWXD/yoL7Vxbcv7Lg/pUF968suH9lwf0rC+5fWXD/yoL7Vxbcv7Lg/pUF968suH9lzv0raXu+XFwsl8/13z5c9+3yaN2TXB/cfvbq+6we26vvc31sr74zwNheK6hX39libK++c8jYXn1nlrG9Pp5vWq6XclrdO72mfbtcOu1SPj263X30nq75YD+ywmO97phe9wFuWZxeE6jXDOq1gHqtoF4F1KuCem2gXjm5ad9AuSmBclMC5aYEyk0JlJsG+HhxegXlpgTKTQmUmxIoNyVQbsqg3JRBuSmDclMG5aYBrmGcXkG5KYNyUwblpgzKTRmUmwooNxVQbiqg3FRAuWmARxmnV1BuKqDcVEC5qYByUwHlpgrKTRWUmyooN1VQbhrgiMbpFZSbKig3VVBuqqDcVEG5SUC5SUC5SUC5SUC5aYD/GqdXUG4SUG4SUG4SUG4SUG5SUG5SUG5SUG5SUG4a4PbG6RWUmxSUmxSUmxSUmxSUmxooNzVQbmqg3NRAuWmAtxynV1BuaqDc1EC5qYFyUwPlJgPlJgPlJgPlJgPlpgFOdpxeQbnJQLnJQLnJQLnJQLlpB+WmHZSbdlBu2kG5aYAXHqdXUG7aQblpB+UmkBe+c7zwsnG88KNXTG46esXkpqNXTG46eq2gXjG56egVk5uOXjG56egVk5uOXkG5ieOFH72CchPHCz96BeUmjhd+9ArKTRwv/OgVlJs4XvjRKyg3cbzwo1dQbuJ44UevoNzE8cKPXkG5ieOFH72CchPHCz96BeUmjhd+9ArKTRwv/OgVlJs4XvjRKyg3cbzwo1dQbuJ44UevoNzE8cKPXkG5ieOFH72CchPHCz96BeUmjhd+9ArKTRwv/OgVlJs4XvjRKyg3cbzwo1dQbuJ44UevoNzE8cKPXkG5ieOFH72CchPHCz96BeUmjhd+9ArKTRwv/OgVlJs4XvjRKyg3cbzwo1dQbuJ44UevoNzE8cKPXkG5ieOFH72CchPHCz96BeUmjhd+9ArKTRwv/OgVlJs4XvjRKyg3cbzwo1dQbuJ44UevoNzE8cKPXkG5ieOFH72CchPHCz96BeUmjhd+9ArKTRwv/OgVlJs4XvjRKyc3JZAXnkBeeAJ54Qnkhaetgnrl5KYE8sITyAtPIC88gbzwBPLCE8gLTyAvPIG88ATywhPIC08gLzyBvPAE8sITyAtPIC88gbzwBPLCE8gLTyAvPIG88ATywhPIC08gLzyBvPAE8sITyAtPIC88gbzwBPLCE8gLTyAvPIG88ATywhPIC08gLzyBvPAE8sITyAtPIC88gbzwBPLCE8gLTyAvPIG88ATywhPIC08gLzyBvPAE8sITyAtPIC88gbzwBPLCE8gLTyAvPIG88ATywhPIC08gLzyBvPAE8sITyAtPIC88gbzwBPLCE8gLTyAvPIG88ATywhPIC08gLzyBvPAE8sITyAtPIC88gbzwBPLCE8gLTyAvPIG88ATywhPIC08gLzyBvPAE8sITyAtPIC88gbzwBPLCE8gLTyAvPIG88ATywhPIC88gLzyDvPAM8sIzyAvPWwX1yslNGeSFZ5AXnkFeeAZ54RnkhWeQF55BXngGeeEZ5IVnkBeeQV54BnnhGeSFZ5AXnkFeeAZ54RnkhWeQF55BXngGeeEZ5IVnkBeeQV54BnnhGeSFZ5AXnkFeeAZ54RnkhWeQF55BXngGeeEZ5IVnkBeeQV54BnnhGeSFZ5AXnkFeeAZ54RnkhWeQF55BXngGeeEZ5IXnEV54K9ded+n0Km27TEZa+pjM0fjPgrK3goq3gqq3gsRbQeqtoOatIPNW0OPni23tUpB9e0Tnnisf91z7XL7+/yl/AJX81vJT7PLza8vPW9Wfj87bnjrlJzuKvl68FT0/sPPR1vXqv5nO8fAf7RZWu5XVrrDaVVa7jdWusdrdUe22jdVuYrXLSlWNlaoGoMeh2mWlqjZTqjqWvnLd/0q5bXamTNVtdqZE1W12pjzVa9ZmSlPdZmfKUt1mZ0pS3WZnylHdZiup2ZkyVLdZ3wlqLyVfX0GXdKd+36Hoi7/EtnT9Jbblj98A/PwltvnORGN79R2Jhva6+05EY3v1HYjG9uo7D321Vy3Xuu3mDTa77zg0ttcK6tV3GBrbq/MsNLTXuXLTea9z5abzXufKTWe9lm2u3HTe61y56bxXTm4qGyc3la2CeuXkprJxclPZOLmpbJzcVDZQbkqg3JRAuSmBclMC5aYBsHGcXkG5KYFyUwLlpgTKTQmUmzIoN2VQbsqg3JRBuWkAbBynV1BuyqDclEG5KYNyUwblpgLKTQWUmwooNxVQbhoAG8fpFZSbCig3FVBuKqDcVEC5qYJyUwXlpgrKTRWUmwbAxnF6BeWmCspNFZSbKig3VVBuElBuElBuElBuElBuGiA9x+kVlJsElJsElJsElJsElJsUlJsUlJucu+FjewXlJudi+NheQbnJuRU+tldQbnKuhI/tFZSbnPvgY3sF5SbnMvjYXkG5ybkJPrZXUG5yroGP7RWUm5xb4GN7BeUm5xL42F5Bucm5Az62V1Bucq6Aj+0VlJu8G+BDewXlpsm88PNeQblpMi/8vFdQbgJ54QXkhReQF15AXngBeeEF5IUXkBdeQF54BXnhFeSFV5AXXkFeeN0qqFdObqogL7yCvPAK8sIryAuvIC+8grzwOpcXvm/Xz+Lb022vU+WmTq8V1OtUuanT61S5qdPrVLmp0+tUuanT61S56bzXubzwTq9T5aZOr6DcNJcX3um1gnoF5aa5vPBOr6DcNJcX3ukVlJvm8sI7vYJy01xeeKdXUG6aywvv9ArKTXN54Z1eQblpLi+80ysoN83lhXd6BeWmubzwTq+g3DSXF97pFZSb5vLCO72CctNcXninV1BumssL7/QKyk1zeeGdXkG5aS4vvNMrKDfN5YV3egXlprm88E6voNw0lxfe6RWUm+bywju9gnLTXF54p1dQbprLC+/0CspNc3nhnV5BuWkuL7zTKyg3zeWFd3oF5aa5vPBOr6DcNJcX3ukVlJvm8sI7vYJy01xeeKdXUG6aywvv9ArKTXN54Z1eQblpLi+80ysoN83lhXd6BeWmubzwTq+g3DSXF97pFZSb5vLCO72CctNcXninV1BumssL7/TKyU0ylxfe6ZWTm2QuL7zTKyc3yVZBvXJyk8zlhXd65eQmmcsL7/QKyk1zeeGdXkG5CeSFC8gLF5AXLiAvXEBeuIC8cAF54QLywgXkhQvICxeQFy4gL1xAXriAvHABeeEC8sIF5IULyAsXkBcuIC9cQF64gLxwAXnhAvLCBeSFC8gLF5AXLiAvXEBeuIC8cAF54QLywgXkhQvICxeQFy4gL1xAXriAvHABeeEC8sIF5IULyAsXkBcuIC9cQF64gLxwAXnhAvLCBeSFC8gLF5AXLiAvXEBeuIC8cAF54QLywgXkhQvICxeQFy4gL1xAXriAvHABeeEC8sIF5IULyAsXkBcuIC9cQF64gLxwAXnhAvLCBeSFC8gLF5AXLiAvXEBeuIC8cAF54QLywgXkhQvICxeQFy4gL1xAXriAvHABeeEC8sIV5IUryAtXkBeuIC9ctwrqlZObFOSFK8gLV5AXriAvXEFeuIK8cAV54QrywhXkhSvIC1eQF64gL1xBXriCvHAFeeEK8sIV5IUryAtXkBeuIC9cQV64grxwBXnhCvLCFeSFK8gLV5AXriAvXEFeuIK8cAV54QrywhXkhSvIC1eQF64gL1xBXriCvHAFeeEK8sIV5IUryAtXkBeuIC9cQV64grxwBXnhCvLCFeSFK8gLV5AXriAvXEFeuIK8cAV54QrywhXkhSvIC1eQF64gL1xBXriCvHAFeeEK8sIV5IUryAtXkBeuIC9cQV64grxwBXnhCvLCFeSFK8gLV5AXriAvXEFeuIK8cAV54QrywhXkhSvIC1eQF64gL1xBXriCvHAFeeEK8sIV5IUryAtXkBeuIC9cQV64grzwBvLCG8gLbyAvvIG88LZVUK+c3NRAXngDeeEN5IU3kBfeQF54A3nhDeSFN5AX3kBeeAN54Q3khTeQF95AXngDeeEN5IU3kBfeQF54A3nhDeSFN5AX3kBeeAN54Q3khTeQF95AXngDeeEN5IU3kBfeQF54A3nhDeSFN5AX3kBeeAN54Q3khTeQF95AXngDeeEN5IU3kBfeQF54A3nhDeSFN5AX3kBeeAN54Q3khTeQF95AXngDeeEN5IU3kBfeQF54A3nhDeSFN5AX3kBeeAN54Q3khTeQF95AXngDeeEN5IU3kBfeQF54A3nhDeSFN5AX3kBeeAN54Q3khTeQF95AXngDeeEN5IU3kBfeQF54A3nhDeSFN5AX3kBeeAN54Q3khTeQF95AXngDeeEN5IU3kBfeQF54A3nhDeSFN5AX3kBeeAN54Qbywg3khRvICzeQF25bBfXKyU0G8sIN5IUbyAs3kBduIC/cQF64gbxwA3nhBvLCDeSFG8gLN5AXbiAv3EBeuIG8cAN54Qbywg3khRvICzeQF24gL9xAXriBvHADeeEG8sIN5IUbyAs3kBduIC/cQF64gbxwA3nhBvLCDeSFG8gLN5AXbiAv3EBeuIG8cAN54Qbywg3khRvICzeQF24gL9xAXriBvHADeeEG8sIN5IUbyAs3kBduIC/cQF64gbxwA3nhBvLCDeSFG8gLN5AXbiAv3EBeuIG8cAN54Qbywg3khRvICzeQF24gL9xAXriBvHADeeEG8sIN5IUbyAs3kBduIC/cQF64gbxwA3nhBvLCDeSFG8gLN5AXbiAv3EBeuIG8cAN54Qbywg3khRvICzeQF24gL9xAXvgO8sJ3kBe+v9wLL/Vy6Vz22utVjv9cLi6tpc+9/qi/BK+/+q6/7flav+XS+V6zdP1es7zffK8JqFcF9dpAvRqo153T68td73f2mqbqVcu1brvJN8l5vhnaq/MsNLTXCup1rtx03utcuem817ly03mvc+Wm817nyk2nvea5ctN5r6DclEG5KYNy08td73f2CspNGZSbMig3ZVBuyqDcVEC5qYByUwHlpgLKTS93vd/ZKyg3FVBuKqDcVEC5qYByUwXlpgrKTRWUmyooN73c9X5nr6DcVEG5qYJyUwXlpgrKTQLKTQLKTQLKTQLKTS93vd/ZKyg3CSg3CSg3CSg3CSg3KSg3KSg3KSg3KSg3vdz1fmevoNykoNykoNykoNykoNzUQLmpgXJTA+WmBspNL3e939krKDc1UG5qoNzUQLmpgXKTgXKTgXKTgXKTgXLTy13vd/YKyk0Gyk0Gyk0Gyk0Gyk07KDftoNy0g3LTDspNL3e939krKDftoNy0g3LTDspN+1S56cx/rts2VW7q9Oo7N+ler6637to+9/qjft9ZqF+/73zTr78Gr993DunX7ztb9Ov3nRf69fvOAP36fZ/r3fqdG9X9+oOfv84t6X79wc9f5+Zzv/7g569zm7lff/Dz17mh3K8/+Pnr3Dru1x/8/HVuEvfrD37+OreD+/UHP3+dG7/9+oOfv84t3n79wc9f52Zuv/7g569z27Zff/Dz17lB268/+Pnr3Irt1x/8/HVuuvbrD37+OrdX+/UHP3+dG6n9+oOfv84t0379wc9f5+Zov/7g569zG7Rff/Dz17nh2a8/+Pnr3Nrs1x/8/HVuYvbrD37+Orcr+/UHP3+dG5P9+oOfv84tyH79wc9f52Zjv/7g569zW7Fff/Dz17mB2K8/+Pnr3Crs1x/8/HVuCvbrD37+Orf/+vUHP3+dG339+oOfv84tvX79wc9f5+Zdv/7g569zm65ff/Dz17kh168/+Pnr3Hrr1x/8/HVusvXrD37+OrfT+vUHP3+dG2f9+oOfv84tsn79wc9f52ZYv/7g569z26tff/Dz17nB1a8/9vmbnFtZ/fpjn78puH+VgvtXaYt9/qbg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQ7uX+Xg/lUO7l/l4P5V3mKfvzm4f5WD+1c5uH+Vg/tXObh/lYP7Vzm4f5WD+1c5uH+Vg/tXObh/lYP7Vzm4f5WD+1c5uH+Vg/tX2bl/JW3Pl4uL5fK5/tuH675dHq17kuuD289efZ/VY3v1fa6P7bWCevWdF8b26jtbjO3Vdw4Z26vvzDK2V9f55uzR38v3zYv1y3edbvrluw4s/fJdZ5B++TV2+a6TQr9814d/v3zX53m/fNdHdL/8F5+6aZfLpdNu0ilf2lZ/Plpa2q+PPq7yo/xXo2Kjy0+xy3/1qbtVvXw3b3vqxVM7ir5evBU9j6fHC2xyvfpvpnN5BejlAtmb262sdoXVrrLabax2jdXujmr35ZTbm9tNrHZZqUpYqerlDN2b22WlKpkpVR1LX7nuf6XcNjtTpuo2O1Oi6jY7U57qNaszpaluszNlqW6zMyWpbrMz5ahus5XU7EwZqtus7wS1l3J9y8Mu6U79vkPRvqfr2xz3vW7nXyy1dH3LhuWP3wD8fMuG+s5EY3v1HYmG9tp8J6KxvfoORGN79Z2HvtqrlmvddvN2suY7Do3ttYJ69R2GxvbqPAsN7XWu3HTe61y56bzXuXLTaa82V24673Wu3HTeKyg3GSg3vZzkfGevoNxkoNxkoNxkoNxkoNy0g3LTDspNOyg37aDc9HJK9Z29gnLTDspNOyg37aDctHNyU9k4ualsnNxUNk5uKhsnN5Wtgnrl5KaycXJT2Ti5qWyc3FQ2UG5KoNyUQLkpgXJTAuWml9PF7+wVlJsSKDclUG5KoNyUQLkpg3JTBuWmDMpNGZSbXs49v7NXUG7KoNyUQbkpg3JTBuWmAspNBZSbCig3FVBuerln/c5eQbmpgHJTAeWmAspNBZSbKig3VVBucu6Gj+0VlJuci+FjewXlJudW+NheQbnJuRI+tldQbnLug4/tFZSbnMvgY3sF5SbnJvjYXkG5ybkGPrZXUG5yboGP7RWUm5xL4GN7BeUm5w742F5Bucm5Aj62V1Bu8m6AD+0VlJsm88LPewXlpsm88PNeQbkJ5IUXkBdeQF54AXnhBeSFF5AXXkBeeAF54QXkhReQF15AXngBeeEF5IUXkBdeQF54AXnhBeSFF5AXXkBeeAF54WUuL3zfrp/Ft6fbXqfKTZ1eK6jXqXJTp9epclOn16lyU6fXqXJTp9epctNpr3UuL7zT61S5qdMrJzfVubzwTq8V1CsnN9W5vPBOr5zcVOfywju9gnLTXF54p1dQbprLC+/0CspNc3nhnV5BuWkuL7zTKyg3zeWFd3oF5aa5vPBOr6DcNJcX3ukVlJvm8sI7vYJy01xeeKdXUG6aywvv9ArKTXN54Z1eQblpLi+80ysoN83lhXd6BeWmubzwTq+g3DSXF97pFZSb5vLCO72CctNcXninV1BumssL7/QKyk1zeeGdXkG5aS4vvNMrKDfN5YV3egXlprm88E6voNw0lxfe6RWUm+bywju9gnLTXF54p1dQbprLC+/0CspNc3nhnV5BuWkuL7zTKyg3zeWFd3oF5aa5vPBOr6DcNJcX3ukVlJvm8sI7vYJy01xeeKdXUG6aywvv9ArKTXN54Z1eQblpLi+80ysoN83lhXd6BeWmubzwTq+g3DSXF97pFZSb5vLCO72CctNcXninV1BuAnnhFeSFV5AXXkFeeAV54RXkhVeQF15BXriAvHABeeEC8sIF5IXLVkG9cnKTgLxwAXnhAvLCBeSFC8gLF5AXLiAvXEBeuIC8cAF54QLywgXkhQvICxeQFy4gL1xAXriAvHABeeEC8sIF5IULyAsXkBcuIC9cQF64gLxwAXnhAvLCBeSFC8gLF5AXLiAvXEBeuIC8cAF54QLywgXkhQvICxeQFy4gL1xAXriAvHABeeEC8sIF5IULyAsXkBcuIC9cQF64gLxwAXnhAvLCBeSFC8gLF5AXLiAvXEBeuIC8cAF54QLywgXkhQvICxeQFy4gL1xAXriAvHABeeEC8sIF5IULyAsXkBcuIC9cQF64gLxwAXnhAvLCBeSFC8gLF5AXLiAvXEBeuIC8cAF54QLywgXkhQvICxeQFy4gL1xAXriAvHABeeEC8sIF5IULyAsXkBeuIC9cQV64grxwBXnhulVQr5zcpCAvXEFeuIK8cAV54QrywhXkhSvIC1eQF64gL1xBXriCvHAFeeEK8sIV5IUryAtXkBeuIC9cQV64grxwBXnhCvLCFeSFK8gLV5AXriAvXEFeuIK8cAV54QrywhXkhSvIC1eQF64gL1xBXriCvHAFeeEK8sIV5IUryAtXkBeuIC9cQV64grxwBXnhCvLCFeSFK8gLV5AXriAvXEFeuIK8cAV54QrywhXkhSvIC1eQF64gL1xBXriCvHAFeeEK8sIV5IUryAtXkBeuIC9cQV64grxwBXnhCvLCFeSFK8gLV5AXriAvXEFeuIK8cAV54QrywhXkhSvIC1eQF64gL1xBXriCvHAFeeEK8sIV5IUryAtXkBeuIC9cQV64grxwBXnhCvLCFeSFN5AX3kBeeAN54Q3khbetgnrl5KYG8sIbyAtvIC+8gbzwBvLCG8gLbyAvvIG88AbywhvIC28gL7yBvPAG8sIbyAtvIC+8gbzwBvLCG8gLbyAvvIG88AbywhvIC28gL7yBvPAG8sIbyAtvIC+8gbzwBvLCG8gLbyAvvIG88AbywhvIC28gL7yBvPAG8sIbyAtvIC+8gbzwBvLCG8gLbyAvvIG88AbywhvIC28gL7yBvPAG8sIbyAtvIC+8gbzwBvLCG8gLbyAvvIG88AbywhvIC28gL7yBvPAG8sIbyAtvIC+8gbzwBvLCG8gLbyAvvIG88AbywhvIC28gL7yBvPAG8sIbyAtvIC+8gbzwBvLCG8gLbyAvvIG88AbywhvIC28gL7yBvPAG8sIbyAtvIC+8gbzwBvLCG8gLbyAvvIG88AbywhvICzeQF24gL9xAXriBvHDbKqhXTm4ykBduIC/cQF64gbxwA3nhBvLCDeSFG8gLN5AXbiAv3EBeuIG8cAN54Qbywg3khRvICzeQF24gL9xAXriBvHADeeEG8sIN5IUbyAs3kBduIC/cQF64gbxwA3nhBvLCDeSFG8gLN5AXbiAv3EBeuIG8cAN54Qbywg3khRvICzeQF24gL9xAXriBvHADeeEG8sIN5IUbyAs3kBduIC/cQF64gbxwA3nhBvLCDeSFG8gLN5AXbiAv3EBeuIG8cAN54Qbywg3khRvICzeQF24gL9xAXriBvHADeeEG8sIN5IUbyAs3kBduIC/cQF64gbxwe7kXXurl0rnstderHP+5XFxaS597/VF/CV5/9V1/2/O1fsul871m6fq9Znm/+V4TUK8K6rWBejVQrzun15e73u/sNU3Vq5Zr3XaTb3bn+WZor86z0NBeK6jXuXLTea9z5abzXufKTee9zpWbznudKzed9bpvc+Wm8145uWnfOLlp3zi5ad8qqFdObto3Tm7aN05u2jdObto3UG5KoNyUQLkpgXJTAuWml7ve7+wVlJsSKDclUG5KoNyUQLkpg3JTBuWmDMpNGZSbXu56v7NXUG7KoNyUQbkpg3JTBuWmAspNBZSbCig3FVBuernr/c5eQbmpgHJTAeWmAspNBZSbKig3VVBuqqDcVEG56eWu9zt7BeWmCspNFZSbKig3VVBuElBuElBuElBuElBuernr/c5eQblJQLlJQLlJQLlJQLlJQblJQblJQblJQbnp5a73O3sF5SYF5SYF5SYF5SYF5aYGyk0NlJsaKDc1UG56uev9zl5BuamBclMD5aYGyk1tqtx06j/vNlVu6vTqOzfpXq+utx5L2edef9TvOwv16/edb/r11+D1+84h/fp9Z4t+/b7zQr9+3xmgX7/vc71bv3Ojul9/8PPXuSXdrz/4+evcfO7XH/z8dW4z9+sPfv46N5T79Yc+f2Vzbh336w99/h71hz5/j/pDn79H/aHP36P+0OfvUX/o8/eoP/T5e9Qf+vw96g9+/jo3c/v1Bz9/ndu2/fqDn7/ODdp+/cHPX+dWbL/+4Oevc9O1X3/w89e5vdqvP/j569xI7dcf/Px1bpn26w9+/jo3R/v1Bz9/ndug/fqDn7/ODc9+/cHPX+fWZr/+4OevcxOzX3/w89e5XdmvP/j569yY7Ncf/Px1bkH26w9+/jo3G/v1Bz9/nduK/fqDn7/ODcR+/cHPX+dWYb/+4Oevc1OwX3/w89e5/devP/j569zo69cf/Px1bun16w9+/jo37/r1Bz9/ndt0/fqDn7/ODbl+/cHPX+fWW7/+4Oevc5OtX3/w89e5ndavP/j569w469cf/Px1bpH16w9+/jo3w/r1Bz9/ndte/fqDn7/ODa5+/cHPX+dWVr/+4OdvbP/qqD/4+RvbvzrqD37+xvavjvqDn7+x/auj/uDnb2z/6qg/+Pkb27866g9+/sb2r476g5+/sf2ro/7g529s/+qoP/b5m4L7Vym4f5WC+1cpuH+VttjnbwruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5f5eD+VXbuX0nb8+XiYrl8rv/24bpvl0frnuT64PazV99n9dhefZ/rY3utoF5954WxvfrOFmN79Z1DxvbqO7OM7dV1vjl79PfyffNi/fJdp5t++a4DS7981xmkX36NXb7rpNAv3/Xh3y/f9XneL9/1Ed0v/8Wn7vEy3uXSxysy0ilf2lZ/Plpa2q+PPq7yo/xXo2Kjy0+xy3/1qbtVvXw3b3vqxVM7ir5evBU9j6fHj4Jcr/6b6VxeAXq5QPbmdiurXWG1q6x2G6tdY7W7o9p9OeX25nYTq11WqiqsVPVyhu7N7bJSVZkpVR1LX7nuf6XcNjtTpuo2O1Oi6jY7U57qNVtnSlPdZmfKUt1mZ0pS3WZnylHdZiup2ZkyVLdZ3wlqL+X6lodd0p36fYeifU/Xtznue93Ov1hq6fqWDcsfvwH4+ZaN6jsTje3VdyQa2qv4TkRje/UdiMb26jsPfbVXLde67ebtZOI7Do3ttYJ69R2GxvbqPAsN7XWu3HTe61y56bzXuXLTaa86V24673Wu3HTeKyg3KSg3vZzkfGevoNykoNykoNykoNykoNzUQLmpgXJTA+WmBspNL6dU39krKDc1UG5qoNzUQLmpgXKTgXKTgXKTgXKTgXLTywncd/YKyk0Gyk0Gyk0Gyk0Gyk07KDftoNy0g3LTDspNL6eL39krKDftoNy0g3LTDspNOyc3lY2Tm8rGyU1l4+SmsnFyU9kqqFdObiobJzeVjZObysbJTWUD5aYEyk0JlJsSKDclUG56uWf9zl5BuSmBclMC5aYEyk0JlJsyKDdlUG5y7oaP7RWUm5yL4WN7BeUm51b42F5Bucm5Ej62V1Bucu6Dj+0VlJucy+BjewXlJucm+NheQbnJuQY+tldQbnJugY/tFZSbnEvgY3sF5SbnDvjYXkG5ybkCPrZXUG7yboAP7RWUmybzws97BeWmybzw815BuQnkhReQF15AXngBeeEF5IUXkBdeQF54AXnhBeSFF5AXXkBeeAF54QXkhReQF15AXngBeeEF5IUXkBdeQF54AXnhZS4vfN+un8W3p9tep8pNnV4rqNepclOn16lyU6fXqXJTp9epclOn16ly03mvc3nhnV6nyk2dXkG5aS4vvNNrBfUKyk1zeeGdXkG5aS4vvNMrKDfN5YV3egXlprm88E6voNw0lxfe6RWUm+bywju9gnLTXF54p1dObqpzeeGdXjm5qc7lhXd65eSmulVQr5zcVOfywju9cnJTncsL7/QKyk1zeeGdXkG5aS4vvNMrKDfN5YV3egXlprm88E6voNw0lxfe6RWUm+bywju9gnLTXF54p1dQbprLC+/0CspNc3nhnV5BuWkuL7zTKyg3zeWFd3oF5aa5vPBOr6DcNJcX3ukVlJvm8sI7vYJy01xeeKdXUG6aywvv9ArKTXN54Z1eQblpLi+80ysoN83lhXd6BeWmubzwTq+g3DSXF97pFZSb5vLCO72CctNcXninV1BumssL7/QKyk1zeeGdXkG5aS4vvNMrKDfN5YV3egXlprm88E6voNw0lxfe6RWUm+bywju9gnLTXF54p1dQbgJ54RXkhVeQF15BXngFeeEV5IVXkBdeQV54BXnhFeSFV5AXXkFeeAV54RXkhVeQF15BXngFeeEV5IVXkBdeQV54BXnhFeSFV5AXXkFeeAV54RXkhVeQF15BXriAvHABeeEC8sIF5IXLVkG9cnKTgLxwAXnhAvLCBeSFC8gLF5AXLiAvXEBeuIC8cAF54QLywgXkhQvICxeQFy4gL1xAXriAvHABeeEC8sIF5IULyAsXkBcuIC9cQF64gLxwAXnhAvLCBeSFC8gLF5AXLiAvXEBeuIC8cAF54QLywgXkhQvICxeQFy4gL1xAXriAvHABeeEC8sIF5IULyAsXkBcuIC9cQF64gLxwAXnhAvLCBeSFC8gLF5AXLiAvXEBeuIC8cAF54QLywgXkhQvICxeQFy4gL1xAXriAvHABeeEC8sIF5IULyAsXkBcuIC9cQF64gLxwAXnhAvLCBeSFC8gLF5AXLiAvXEBeuIC8cAF54QLywgXkhQvICxeQFy4gL1xAXriAvHABeeEC8sIF5IULyAsXkBeuIC9cQV64grxwBXnhulVQr5zcpCAvXEFeuIK8cAV54QrywhXkhSvIC1eQF64gL1xBXriCvHAFeeEK8sIV5IUryAtXkBeuIC9cQV64grxwBXnhCvLCFeSFK8gLV5AXriAvXEFeuIK8cAV54QrywhXkhSvIC1eQF64gL1xBXriCvHAFeeEK8sIV5IUryAtXkBeuIC9cQV64grxwBXnhCvLCFeSFK8gLV5AXriAvXEFeuIK8cAV54QrywhXkhSvIC1eQF64gL1xBXriCvHAFeeEK8sIV5IUryAtXkBeuIC9cQV64grxwBXnhCvLCFeSFK8gLV5AXriAvXEFeuIK8cAV54QrywhXkhSvIC1eQF64gL1xBXriCvHAFeeEK8sIV5IUryAtXkBeuIC9cQV64grxwBXnhCvLCFeSFN5AX3kBeeAN54Q3khbetgnrl5KYG8sIbyAtvIC+8gbzwBvLCG8gLbyAvvIG88AbywhvIC28gL7yBvPAG8sIbyAtvIC+8gbzwBvLCG8gLbyAvvIG88AbywhvIC28gL7yBvPAG8sIbyAtvIC+8gbzwBvLCG8gLbyAvvIG88AbywhvIC28gL7yBvPAG8sIbyAtvIC+8gbzwBvLCG8gLbyAvvIG88AbywhvIC28gL7yBvPAG8sIbyAtvIC+8gbzwBvLCG8gLbyAvvIG88AbywhvIC28gL7yBvPAG8sIbyAtvIC+8gbzwBvLCG8gLbyAvvIG88AbywhvIC28gL7yBvPAG8sIbyAtvIC+8gbzwBvLCG8gLbyAvvIG88AbywhvIC28gL7yBvPAG8sIbyAtvIC+8gbzwBvLCG8gLbyAvvIG88AbywhvICzeQF24gL9xAXriBvHDbKqhXTm4ykBduIC/cQF64gbxwA3nhBvLCDeSFG8gLN5AXbiAv3EBeuIG8cAN54Qbywg3khRvICzeQF24gL9xAXriBvHADeeEG8sIN5IUbyAs3kBduIC/cQF64gbxwA3nhBvLCDeSFG8gLN5AXbiAv3EBeuIG8cAN54Qbywg3khRvICzeQF24gL9xAXriBvHADeeEG8sLt5V54qZdL57LXXq9y/Ody8W+w1udef9Rfgtdffdff9nyt//hFZ+d7zdL1e+14Nf7me01AvSqo1wbq1UC97pxeX+56v7PXNFWvWq51202+Uef5ZmivzrPQ0F4rqNe5ctN5r3PlpvNe58pN573OlZvOe50rN5322ubKTee9gnJTA+WmBspNL3e939krKDc1UG5qoNzUQLmpgXKTgXKTgXKTgXKTgXLTy13vd/YKyk0Gyk0Gyk0Gyk0Gyk07KDftoNy0g3LTDspNL3e939krKDftoNy0g3LTDspNOyc37RsnN+0bJzftGyc37RsnN+1bBfXKyU37xslN+8bJTfvGyU37BspNCZSbEig3JVBuSqDc9HLX+529gnJTAuWmBMpNCZSbEig3ZVBuyqDclEG5KYNy08td73f2CspNGZSbMig3ZVBuyqDcVEC5qYByUwHlpgLKTS93vd/ZKyg3FVBuKqDcVEC5qYByUwXlpgrKTRWUmyooN73c9X5nr6DcVEG5qYJyUwXlpuo7N+kRdi4X113b516/1y++s1C/ft/5pl+/78zSr993DunXX4PX7zsv9Ov3nQH69fs+1/v1+z6r+/UHP3+dW9L9+oOfv87N5379wc9f5zZzv/7g569zQ7lff/Dz17l13K8/+Pnr3CTu1x/8/HVuB/frD37+Ojd++/UHP3+dW7z9+oOfv87N3H79wc9f57Ztv/7g569zg7Zff/Dz17kV268/+Pnr3HTt1x/8/HVur/brD37+OjdS+/UHP3+dW6b9+oOfv87N0X79wc9f5zZov/7g569zw7Nff+jzVzfn1ma//tDn71F/6PP3qD/0+XvUH/r8PeoPff4e9Yc+f4/6Q5+/R/2hz9+j/uDnr3OzsV9/8PPXua3Yrz/4+evcQOzXH/z8dW4V9usPfv46NwX79Qc/f53bf/36g5+/zo2+fv3Bz1/nll6//uDnr3Pzrl9/8PPXuU3Xrz/4+evckOvXH/z8dW699esPfv46N9n69Qc/f53baf36g5+/zo2zfv3Bz1/nFlm//uDnr3MzrF9/8PPXue3Vrz/4+evc4OrXH/z8dW5l9esPfv7G9q+O+oOfv7H9q6P+4OdvbP/qqD/4+RvbvzrqD37+xvavjvqDn7+x/auj/uDnb2z/6qg/+Pkb27866g9+/sb2r476g5+/sf2ro/7g529s/+qoP/j5G9u/OuoPfv7G9q+O+oOfv7H9q6P+4OdvbP/qqD/4+RvbvzrqD37+xvavjvqDn7+x/auj/uDnb2z/6qg/+Pkb27866g9+/sb2r476g5+/sf2ro/7g529s/+qoP/j5G9u/OuoPfv7G9q+O+mOfvym4f5WC+1cpuH+VgvtXaYt9/qbg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpeD+VQruX6Xg/lUK7l+l4P5VCu5fpQH+1Z4vf0XettSp37Tqz0eb6nZ9dM7bvWs3K9fZbB+zyXeb3fLl0mlr8vnB31sdQGWFaTVxWn04AOQtybXV2vsBFNsugxFLv/mBunPptMul+uO/m9z8/D3ub723/Bq7fIldvsYuv8Uu32KXv4cu/3F4673lp9jlxz51LfapGxzdSsHRrRQZ3Tr+8C//8ac///lP//d///mv//qHv/3pr3/5z29P3r79n/vv5rRcruG+fWrs3jdvbZdvXUnlo9C6fZvc/Tdbjrt8fe7l5bmX1+devj338va1y397yv7lp9x/t9n5U+4etNYuT9k37fRd7PKjWsxuLp+fe/ny3MvX515ennt5fe7l23Mvb8+9/P7Uy99/38m4yz/3p1ae+1Mrz/2plef+1Mpzf2rluT+18tyfWnnuT60+PPt63UtqujkM9eHq5SMEtNvL70+9fNuee/n03Mvn516+PPfy9bmXl+deXp97+fbcyz/3p7Y996fWnvtTa8/9qbXn/tTa4z+1ki+vOnz6Vdr9x6pcjh7d5aaU6qcU8VOK+iml+SnF3JSyp5eWUq6PrZ9eh0vfXwPZX/wTdAl6qummlMd/gvL11cyt9CLtvl8uXLdPVz5e2vxejHoqpnkqxl5ZTN1Kuhbz6dv3UszuqJhfwMJvqya9tpq2X6vZ82012VU1xVU11VU18q5qjh+g22rUVTXNVTWvvRXndHlwzSXdVrN7qiZtrqpJrqp57b04X98aULPut9UUV9VUV9WIq2peey8uW71UUz69LnytprmqxlxVs3uqJm9vqybLbTXJVTXZVTWvvRfXet00q+htNdVVNeKqGnVVzWvvxdWum2/dbzffbK6q2T1VUzZX1bz2Xiz5uk9Jvd18S3ZVTXFVTXVVjbytGrndw4u6qqa5qua192LV6waj7XaDKbunaurmqprkqprX3ovbRy5uyW6rKa6qqa6qEVfVvPZe3OSai5vebr61uarGXFWze6pGtrdV0273cEmuqsmuqnnivfj79euTry9Pvr4++foP39PULrdw/bQTXq9vT77+/tzr6/bc67fXvqfq7N1Dqb32TVV6ncunxHitZfdTy4A3kI6rJTmqJTuqpTiqpTqq5cXvZD15S2B69VtZT2tpjmoxR7XsfmrZN0e1JEe1ZEe1FEe1VEe1OLrv7o7uu7uj++7u6L67+7nv5s3PfTc//t7e03+PmreH7xnHr7Q+Xoq6vb48+fr65Ou3J1//4Z/BWtvHC0y319+fe/3H35nauX568vXzk69fnnz9+uTry8DrW7m9vj75+u3J13/85/f6mlSt9fb6+3Ov//i7GTvXT0++fn7y9cuTr1+ffH158vX1yddvT77+k39+85N/fsuTf37Lk39+y5N/fsszf36PP6Vvj7x/CKctXd4umLby+Vd/d/6WjzcCtPT5HWI/fsnz3Mvr45cvl3m2uv/95duAy1++BE3L31/ennv5/fHL2+U9ZW1vf3f5+8fvuMunhy9vV/3d6t9/59w/fL94+ct2ar95J/aPH97HL98uX1q7HU4dePn9736sjj/kk1tD2i5PPP6r/WM/ManK9TmqncI2uQiktrVP39T799LKt4fe/96T/frDIJ9+lPP2/Yn1+xPv08llv/6Nn8aW0q+/U86fUr7+lPr1p8jXn6Jff0r7+lPs60/Zv/yUX8SH67tgrdpvnnL7nVb08l1ZPq1HZfv+nfyL9DDs8vm5ly9fu/w//1rAPXuKfP0p+vWntK8/xb7+lP3LT6nb15+Svv6U/PWn3P/qX9/NYvv+j39ztfr331y/eNvrsMvLcy+vz718e+7l7bmX3596+V+8uXPY5dPAy9/eVH/x9sthly/Pvfzdn9r9mpH30v7+PnL/HZLnT9GvP6V9/Sn29afsX37K/TcQnj8lffkp923P86eUrz/l7lc/X3N5/vRW7J/fMPddzfOn6Nef0r7+FPv6U/YvP+X+WwfPn3L3q5/b5VX4vN/8VN5/I975U8rXn1K//hT5+lP0609pX3zK8Sf59sj7nu/eLgvwbp/+kev+40cgff0p+etPKV9/Sv36U+TrT9GvP6V9/Sn29afsX36Kff2rb1//6tvXv/r29a++ff2rb1//6tvXv/r29a/+/bdD7nW/PqXdPGX/8lPuv7nw/Cnp60/JX39K+fpT6hefcvxJv786d/8VxvbxEmBrn17X+/4i2PHH/+cP//GnP/zLn//47XN7vv1//+sv/3r5GJ/jj3/7f//98v+5fNDPv//HX//1j//2X//xx28f+fPxaT/fvgTflKLjVv3P31+U+1+5HH+q+s/fBLJvfzx+95wlf/tj+v7YcvxRPn7v8P0x7fclf7ze+OOavy/b9XW+H//T8Uy7voL3/X86cm7bLpfet9/v+XowfCtF7Pdql0J2/f3xwujH3L79b0l+n4+/5X+Omfx/",
+      "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": "51138cca3416c965bb4ccec1358c0c804a4ada84-d3d22b0b1c576bab0484f5bce48953c8-mega-honk-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": "ndLBCoQgEAbgd5lzh7TM7FViCSsLQTTMFpbo3dd2t6VduuhlcMRvPMy/Qi/aZWykHswMVb2CMh130mjfrVsCrZVKybE5X0O6F4Re7+eJ672dHbcOqiJNQOjeH0qvB6kEVHmGt1sCCIeCLBTkoYAEAnz5A8vJQVhO6Rch9EYkBhUxiMagMgJll9tnJGMHIqT8RZtv79xK3irxSdew6O4UNveYxF/uJms60S9W7Ak8hc/XGtEEYz/Wj34C",
-      "brillig_names": [
-        "sync_notes"
-      ]
+      "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAFAAAABgAAAAcAAAAIAAAACQAAAAoAAAALAAAADAAAAA0AAAAOAAAADwAAAAAAAAAAABJja7x52FZn9EkTyTrgnbnvwy/X7u+x9KdtZ9Eh1C7NLUn6CduREit8Jpxf6kKHynKN64+t7/75h4teh9S2zUAkqDB6wUoMDZ38Ozs//HGMa1ysS+Q5U7JO02IijHOeBQZ5N/RdFzzH5vDs0zenWr8FEs4l53oZz1NDYF2a0N+XHFR5Txn2TWzISS0ZjG++lYU06LNZXJJ99CJmvKcI58YlnOsRTpV/ZYp3MyVl4gDpgJUE6ZqiHn0SYhHpf2eaMxxn7iele3R7Kb8//Wxo+xjgmqNBCLLSNy9Pj/6hgs6bDtyIS1EzndR1JR7uHDUjYiesBYfT9pS/Oy4vF/v9alcH9LNI1Jh3uk3UzBYUdfFCzXFb7S4m4FYe67TrxXM0Ax+2kX8hVpKjUFlmgQtD/qn9hzL0D7/Tx3mkk7DIFN0kLijJvq8lk1mkrXUHVfO9qlP+lSjfBNIGVCczmZpFqLYBt54xF5Eycbpt7EggYPC36FjKupBjayMQZZ68RQY9TARWu3AbWwtGO7zwxP5xkFUjk9CVM+GyAEvYTp+KU6iPA4D05rswR3a/1Psi4gmHdBVkgemj+PCR0w2xADptqrQNVrvvFHJ4/cBX+aM22YTQoACAzY80ug43VGwQJmXI/ikfu+C39vKCPVRpz5gaHvEfPq7YcmAmIR0u4Pg+MuRTAbCj7OjZupV0dXSVEKdpM68YAAgEuqx5TTAyK+RTXysooZB9qUIpUzf5M4nKoKE5Hdg185nsZk9fiMCWZu4FAAOlKt8ytmMdFx6t1hMaGWUjlBnqY4B46CseF69v0VomLEEEbsrZiz0FLBdA5SdDyOxyPYGMeX2vTBheH4Yx8IkGNzNlEuD6wQlGaKOL3lek7uh1KINo49XuEMOduMI8OwgtTMus4vu9fLXXKAmXuAdQq1bV3GcWCi7/SJp5lbR7JVUIHpC+NywbUxAv6gU7IJpihfVdfTpwNN3r+dCKDaYHbL6FYXV0gaZPUfxv0EcYYu6pAgzMQ5OCNjEAZlyZ0xLZ8guns9X8N9VuyBRf5UByz5gr0skY9TOdWe5FOK50AHPtO7NoyGCb8JFn0KLn8wpuu3oh0ENsb9UQLXxCwvAK8L1gS0e3t2rLeKNfxRMimEoOh+BKsJC5g7Mmy19c4SP7Yd6m5JkYl/R6IUnZFLk7Mdydra5I0rlUM7PhFM5FI11Ix/Bfr8uLfXVMXLflh0YdzNiFraYGM4ACR1XcDI0Zf8sTEwB9VLEWRx1bq8wqRajA4jXX9QcOMV9j1pW5vg70b48KcHnDrglDUKVjPIMmb/45eNd9h6K9mrp/0lw/BY9iszEgAUIAANoc5wjW8K0PQx5prUJrHi09b8wcn9MIpPWC5PlxXcaueJPFANzI1hpHJl31kkAiGqHJpxwziyO847SteobFqSowo3w7c1+3exo2ZDMOYiVDgkiUSVLtMC442Ep0MTpLAXPY3sm8HYykCjI/pfPDtWOyFpoEN5cb2wpIkLq2l0OthXJfuWGmg8korCkrQ/z8YSGy+BcG3iOOcDPvocV9zjxikleWm6LR/9CTCOISEhHwvuktEfouL4Et9mVuIiXAEz87n/x5mtisBy8OpGkt1ITc//pegtIcU3jH5Ub263VhpFiNhHhATcfUTdErlcuSB8+Evr8HUAWr70CPPASQbdho+EaZre/d/U0nYAqkVmnz0/obBNLrCsGqb1iPrvxY20+iznNdLJNSDtRAK6/HVnv7irDdbn0SUowpljQlqD22gY/xp/nAmxa4880/WpNHlBua9Fnh2iZiY6GM3nXK2DTXl8PspLrWIHzgDjBd6row1m3jDrFZIQqlAa0xx7ZbFpBgoOxpLOqQlScW90TyPaljm7xCbQwKhQGeElJpkxLL1exqI7KEqbNSfNLr/2KyRaBKqyWPkhu6Gm5J8LpmZD6LMv0JDgC17ucjNkMMP+t9pri1fhVRALNOAIK8Wu2BmoG7NnRMTWEsgPyRommqqql1yEyOWNYAE66jvMCEHsbZSyhfG+u+uWng8seFYnDcX9osXTmdzAWqHutNNpSlBjdj+CMY/bZLyyMBKu90Ia4bl6mjP5QbGzk4ugOtfRU7H/t9ahjeuNMVLJrIE2d2u9IbcxrvxkMngHpPeyPZzByGXvmTCZk6M56MuMZI0Hw03ctO9EUngwy/nW4Lb6pgndvVgX9dELxP2BDHgdeyOaR6CGNhaG7cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAhN89ebDOTmbb5Oc8VbcYl7eq01OyuvYaethFsMK69N1HofN404S/fYzJEmvB0jSEdB1hdj9h3Wf8XX2Z/CshccPy7+dPPQCuqPu2l8Knkm1werJWyZMMC3IVObyLXMw3yg+39qJyUgFl/CzRC6XUt751Y/Ckgg2GUJh97Fj/vuvHViqYcZK1SIEPXnEgCIZ5Vuhl1Gt/mw2Mk0/tsLaCYktfBipPD2uWICfqu7GqGp49LO8YfGdbnBpNZu/R+f5Bw==",
+      "artifact_hash": "e7552d296af009c9ed2e2ca261de6124cad0b1c1-daea7ec3fa031eaeae050c3deaddeb83-client-ivc-true"
     }
   ],
   "outputs": {
@@ -3728,93 +3812,93 @@
       "path": "std/hash/poseidon2.nr",
       "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n    cache: [Field; 3],\n    state: [Field; 4],\n    cache_size: u32,\n    squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2 {\n        let mut result =\n            Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = crate::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let two_pow_64 = 18446744073709551616;\n        let iv: Field = (in_len as Field) * two_pow_64;\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\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 is_variable_length {\n            sponge.absorb(1);\n        }\n        sponge.squeeze()\n    }\n}\n\npub struct Poseidon2Hasher {\n    _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n    fn finish(self) -> Field {\n        let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..self._state.len() {\n            sponge.absorb(self._state[i]);\n        }\n        sponge.squeeze()\n    }\n\n    fn write(&mut self, input: Field) {\n        self._state = self._state.push_back(input);\n    }\n}\n\nimpl Default for Poseidon2Hasher {\n    fn default() -> Self {\n        Poseidon2Hasher { _state: &[] }\n    }\n}\n"
     },
-    "51": {
+    "52": {
       "path": "std/panic.nr",
       "source": "pub fn panic<T, U, let N: u32>(message: fmtstr<N, T>) -> U {\n    assert(false, message);\n    crate::mem::zeroed()\n}\n"
     },
-    "93": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/context/private_context.nr",
-      "source": "use crate::{\n    context::{inputs::PrivateContextInputs, packed_returns::PackedReturns},\n    hash::{ArgsHasher, hash_args_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        arguments,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            enqueue_public_function_call_internal, notify_set_min_revertible_side_effect_counter,\n            set_public_teardown_function_call_internal,\n        },\n        header::get_header_at,\n        key_validation_request::get_key_validation_request,\n        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    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    header::Header,\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::Empty,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: Header,\n\n    pub 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\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: self.next_counter(),\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_header(self) -> Header {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_header_at(self, block_number: u32) -> Header {\n        get_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        pack_returns(returns_hasher.fields);\n        self.return_hash = returns_hasher.hash();\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            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: Header::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"
+    "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"
     },
-    "111": {
-      "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"
+    "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"
     },
-    "112": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/notes.nr",
-      "source": "use crate::note::{note_header::NoteHeader, note_interface::NoteInterface};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n    utils::arr_copy_slice,\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            serialized_note,\n            note_hash,\n            counter,\n        )\n    };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_created_note_oracle(\n        storage_slot,\n        note_type_id,\n        serialized_note,\n        note_hash,\n        counter,\n    );\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _serialized_note: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(\n    _nullifier: Field,\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let S: u32>(\n    _storage_slot: Field,\n    _num_selects: u8,\n    _select_by_indexes: [u8; N],\n    _select_by_offsets: [u8; N],\n    _select_by_lengths: [u8; N],\n    _select_values: [Field; N],\n    _select_comparators: [u8; N],\n    _sort_by_indexes: [u8; N],\n    _sort_by_offsets: [u8; N],\n    _sort_by_lengths: [u8; N],\n    _sort_order: [u8; N],\n    _limit: u32,\n    _offset: u32,\n    _status: u8,\n    _return_size: u32,\n    _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let S: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; N],\n    select_by_offsets: [u8; N],\n    select_by_lengths: [u8; N],\n    select_values: [Field; N],\n    select_comparators: [u8; N],\n    sort_by_indexes: [u8; N],\n    sort_by_offsets: [u8; N],\n    sort_by_lengths: [u8; N],\n    sort_order: [u8; N],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_fields: [Field; S],\n) -> [Field; S] {\n    let return_size = placeholder_fields.len() as u32;\n    get_notes_oracle(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        return_size,\n        placeholder_fields,\n    )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let S: u32, let NS: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; M],\n    select_by_offsets: [u8; M],\n    select_by_lengths: [u8; M],\n    select_values: [Field; M],\n    select_comparators: [u8; M],\n    sort_by_indexes: [u8; M],\n    sort_by_offsets: [u8; M],\n    sort_by_lengths: [u8; M],\n    sort_order: [u8; M],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_opt_notes: [Option<Note>; S], // TODO: Remove it and use `limit` to initialize the note array.\n    placeholder_fields: [Field; NS], // TODO: Remove it and use `limit` to initialize the note array.\n    _placeholder_note_length: [Field; N], // Turbofish hack? Compiler breaks calculating read_offset unless we add this parameter\n) -> [Option<Note>; S]\nwhere\n    Note: NoteInterface<N>,\n{\n    sync_notes_oracle_wrapper();\n    let fields = get_notes_oracle_wrapper(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        placeholder_fields,\n    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n    for i in 0..placeholder_opt_notes.len() {\n        if i < num_notes {\n            // lengths named as per typescript.\n            let return_header_length: u32 = 2; // num_notes & contract_address.\n            let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n            let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n            let nonce = fields[read_offset];\n            let note_hash_counter = fields[read_offset + 1] as u32;\n            let header = NoteHeader { contract_address, nonce, storage_slot, note_hash_counter };\n            let serialized_note = arr_copy_slice(fields, [0; N], read_offset + 2);\n            let mut note = Note::deserialize_content(serialized_note);\n            note.set_header(header);\n            placeholder_opt_notes[i] = Option::some(note);\n        };\n    }\n    placeholder_opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier) == 1\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\n/// Same as `get_app_tagging_secret_as_sender`, except it returns the derived tag, 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"
+    "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"
     },
-    "114": {
+    "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"
     },
-    "120": {
-      "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"
+    "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_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"
+    },
+    "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"
     },
-    "142": {
+    "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"
     },
-    "183": {
-      "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"
-    },
-    "191": {
+    "176": {
       "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"
     },
-    "195": {
+    "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"
+    },
+    "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    utils,\n};\n\n// We do below because `use crate::point::Point;` does not work\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\nuse crate::public_keys::AddressPoint;\nuse 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    pub fn conditional_assign(predicate: bool, lhs: Self, rhs: Self) -> Self {\n        let result = utils::conditional_assign(predicate, rhs.to_field(), lhs.to_field());\n        Self { inner: result }\n    }\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n    let public_keys = PublicKeys {\n        npk_m: NpkM {\n            inner: Point {\n                x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n                y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n                is_infinite: false,\n            },\n        },\n        ivpk_m: IvpkM {\n            inner: Point {\n                x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n                y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n                is_infinite: false,\n            },\n        },\n        ovpk_m: OvpkM {\n            inner: Point {\n                x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n                y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n                is_infinite: false,\n            },\n        },\n        tpk_m: TpkM {\n            inner: Point {\n                x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n                y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n                is_infinite: false,\n            },\n        },\n    };\n\n    let partial_address = PartialAddress::from_field(\n        0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n    );\n\n    let address = AztecAddress::compute(public_keys, partial_address);\n\n    // The following value was generated by `derivation.test.ts`.\n    // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n    let expected_computed_address_from_partial_and_pubkeys =\n        0x24e4646f58b9fbe7d38e317db8d5636c423fbbdfbe119fc190fe9c64747e0c62;\n    assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn 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"
+      "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"
     },
-    "220": {
+    "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::field::field_from_bytes;\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = std::hash::sha256(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\nfn compute_note_hash_nonce(tx_hash: Field, note_index_in_tx: u32) -> Field {\n    // Hashing tx hash with note index in tx is guaranteed to be unique\n    poseidon2_hash_with_separator(\n        [tx_hash, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(nonce: Field, note_hash: Field) -> Field {\n    let inputs = [nonce, note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, unique_note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), unique_note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash, tx_hash: Field, note_index_in_tx: u32) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(tx_hash, note_index_in_tx);\n        let unique_note_hash = compute_unique_note_hash(nonce, note_hash.value());\n        compute_siloed_note_hash(note_hash.contract_address, unique_note_hash)\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn 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    // We manually hash the inputs here, since we cannot express with the type system a constant size inputs array of N + 1\n    let in_len = N + 1;\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    // We manually hash the inputs here, since we cannot express with the type system a constant size inputs array of Math.ceil(N/31)\n    let mut in_len = N / 31;\n    let mut has_padding = false;\n    if N % 31 != 0 {\n        in_len += 1;\n        has_padding = true;\n    }\n\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            sponge.absorb(field_from_bytes(current_field, false));\n            current_field = [0; 31];\n        }\n    }\n    if has_padding {\n        sponge.absorb(field_from_bytes(current_field, false));\n    }\n\n    sponge.squeeze()\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = std::hash::sha256(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
+      "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"
     },
-    "308": {
-      "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"
-    },
-    "310": {
-      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/utils/mod.nr",
-      "source": "// general util packages/modules are usually bad practice\n// because there is no criteria for what we should not put in here.\n// Reducing the size of this package would be welcome.\n\npub mod arrays;\npub mod field;\npub mod reader;\npub mod uint256;\n\n// if predicate == true then return lhs, else return rhs\npub fn conditional_assign(predicate: bool, lhs: Field, rhs: Field) -> Field {\n    if predicate {\n        lhs\n    } else {\n        rhs\n    }\n}\n\npub fn arr_copy_slice<T, let N: u32, let M: u32>(\n    src: [T; N],\n    mut dst: [T; M],\n    offset: u32,\n) -> [T; M] {\n    let iterator_len = if N > M { M } else { N };\n    for i in 0..iterator_len {\n        dst[i] = src[i + offset];\n    }\n    dst\n}\n"
+    "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"
     },
-    "334": {
+    "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"
     },
-    "336": {
+    "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"
     },
-    "337": {
+    "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"
     },
-    "340": {
+    "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"
     },
-    "341": {
+    "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"
     },
-    "429": {
-      "path": "/root/nargo/github.com/noir-lang/schnorrv0.1.1/src/lib.nr",
+    "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"
     },
-    "431": {
+    "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"
+    },
+    "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"
     },
-    "432": {
+    "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"
-    },
-    "433": {
-      "path": "/usr/src/noir-projects/noir-contracts/contracts/schnorr_single_key_account_contract/src/auth_oracle.nr",
-      "source": "use dep::authwit::auth_witness;\nuse dep::aztec::protocol_types::{\n    address::PartialAddress,\n    public_keys::{PUBLIC_KEYS_LENGTH, PublicKeys},\n    utils::arr_copy_slice,\n};\n\npub struct AuthWitness {\n    keys: PublicKeys,\n    signature: [u8; 64],\n    partial_address: PartialAddress,\n}\n\nimpl AuthWitness {\n    fn deserialize(values: [Field; 77]) -> Self {\n        let mut signature = [0; 64];\n        for i in 0..64 {\n            signature[i] = values[i + PUBLIC_KEYS_LENGTH] as u8;\n        }\n        Self {\n            keys: PublicKeys::deserialize(arr_copy_slice(values, [0; PUBLIC_KEYS_LENGTH], 0)),\n            signature,\n            partial_address: PartialAddress::from_field(values[76]),\n        }\n    }\n}\n\npub unconstrained fn get_auth_witness(message_hash: Field) -> AuthWitness {\n    let witness: [Field; 77] = auth_witness::get_auth_witness(message_hash);\n    AuthWitness::deserialize(witness)\n}\n"
     }
   }
 }