npm - @aztec/protocol-contracts - Versions diffs - 0.69.0 → 0.69.1 - Mend

@aztec/protocol-contracts 0.69.0 → 0.69.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/artifacts/AuthRegistry.json +251 -251
package/artifacts/ContractClassRegisterer.json +203 -203
package/artifacts/ContractInstanceDeployer.json +23 -23
package/artifacts/FeeJuice.json +294 -294
package/artifacts/MultiCallEntrypoint.json +2 -2
package/artifacts/Router.json +96 -96
package/dest/protocol_contract_data.js +2 -2
package/package.json +4 -4
package/src/protocol_contract_data.ts +2 -2

package/artifacts/FeeJuice.json CHANGED Viewed

@@ -3,151 +3,6 @@
   "noir_version": "1.0.0-beta.1+74f0a50ed44e5712",
   "name": "FeeJuice",
   "functions": [
-    {
-      "name": "check_balance",
-      "is_unconstrained": true,
-      "custom_attributes": [
-        "public",
-        "view"
-      ],
-      "abi": {
-        "error_types": {
-          "15238796416211288225": {
-            "error_kind": "string",
-            "string": "Balance too low"
-          },
-          "16761564377371454734": {
-            "error_kind": "string",
-            "string": "Array index out of bounds"
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          },
-          "206160798890201757": {
-            "error_kind": "string",
-            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
-          },
-          "3219842053230618354": {
-            "error_kind": "string",
-            "string": "Function check_balance can only be called statically"
-          },
-          "5019202896831570965": {
-            "error_kind": "string",
-            "string": "attempt to add with overflow"
-          },
-          "6485997221020871071": {
-            "error_kind": "string",
-            "string": "call to assert_max_bit_size"
-          }
-        },
-        "parameters": [
-          {
-            "name": "fee_limit",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": null
-      },
-      "bytecode": "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",
-      "debug_symbols": "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",
-      "brillig_names": [
-        "check_balance"
-      ]
-    },
-    {
-      "name": "compute_note_hash_and_optionally_a_nullifier",
-      "is_unconstrained": true,
-      "custom_attributes": [],
-      "abi": {
-        "error_types": {
-          "16541607464495309456": {
-            "error_kind": "fmtstring",
-            "item_types": [],
-            "length": 16
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        },
-        "parameters": [
-          {
-            "name": "contract_address",
-            "type": {
-              "fields": [
-                {
-                  "name": "inner",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "nonce",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "storage_slot",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "note_type_id",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "compute_nullifier",
-            "type": {
-              "kind": "boolean"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "serialized_note",
-            "type": {
-              "kind": "array",
-              "length": 0,
-              "type": {
-                "kind": "field"
-              }
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": {
-          "abi_type": {
-            "kind": "array",
-            "length": 4,
-            "type": {
-              "kind": "field"
-            }
-          },
-          "visibility": "public"
-        }
-      },
-      "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": "tdfNaoQwFAXgd8k6C29+jPFVShmixiEQokQtFPHdG4dpO8wsh7MRrly/gHiQs7PBd9v1EtI4Laz92FmcereGKZVpPzjrcogxXC+Pt1l1Xqy87S+zS+e4rC6vrFWCM58G1uqqPD2G6Flby4O/LJrfRWP+FrU4PjmzCgVrFFyjYIOCGxRsQTBVFUwmmCxgsoTJCiZrmFzDZAOTG5gMyyDBMkiwDBIsgwTLIMEySLAM0nsZtPK+WF7rC21wdIOjLYwWFY4mHC1wtMTRCkdrHI1Lo8ClUeDSKEBpPMr05XJwXfT3zjRuqX+oUOv37J/a1Jyn3g9b9mev+q9U50csFVfq9hcvA0nBSZpySDnoBw==",
-      "brillig_names": [
-        "compute_note_hash_and_optionally_a_nullifier"
-      ]
-    },
     {
       "name": "initialize",
       "is_unconstrained": false,
@@ -1777,7 +1632,7 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "7VjbjuIwDP2XPvchsZ3E5ldWqxGXzqgSAsRlpRXi3zdFJGUg05FZdlZoeEG4nINPj5Ocwr6aNZPd20u7eF1uqtGPfTVfTsfbdrmI1b6yeLy2WY0XXbnZjtfbamS9mLpqFrP4NhhzqKvXdt5UI4+H+goMjHwCA/seLCUwOisnMDqBYbD15LIOT54yHByX8IExwdn0Xw6+BDbgE9gEdw7+WVeWnr4UfXFPX4q++L/2hYxzJzAZsRnM9tgg/OsGXGxgxaYG4GG4QUAIJ3BAChkcHnqycgdfXO8Lw7AvjtONettrsWg6MWDuIEYgiSH8ZEjxiylJj+/PfI+LprC1AZnS3gayeLHGwD62fPhq+cHnVS9Cl1sWyuEdT9VEQvvJmcAhL02Ws41S9Cdw2rEM5zswHMWUExMBshiUYTECmA4oQbDDYqzDvMX9mfLY5iinHFRkshxy7hseZ+CfvhR9CU9fir7wHXy5W/zJHcT8v/xA89jy7VfLH4q/WEzW7Xzevr28+0Vruhf6IKlNTuqYkperi/AWEt1CcreQvJoUK9thy4+Nrp+Fk/f5GSvokKFIlJBaCl89BwSrp4CegnoK6SlOT/F6StBTWE8RNYX102f99Fk/fdZPn/XTZ/30WT991k+fy9MnyZRwRRE1RYyeYvUU0FNQTyElJVY48P9osPnQDQGuzk56ZlCfQbH8NV6348m86QK6+3S3mKa8juX29yp9khJ9tV5Om9lu3XTZ3sd6Zw6amkyUYrvlSVw7zDF3vARYA+cA6xiOa8+JIb6Oavv5dtesq8HkuX3U5BDv5Q8=",
+      "debug_symbols": "7VjbjuIwDP2XPvchtnOx+ZXVasRtRpUQIC4rrRD/vikiaQcyHZllZ4WGF0TKOfXhOPEpHKrZfLJ/e2mWr6ttNfpxqBar6XjXrJZxdaiATte26/GyXW53482uGoEXU1fz5Sy+DcYc6+q1WcyrkadjfQVGJj6DkX0HlhKYHMgZTE5wGAzeYrp1fG87ODou4QNTgrPpoX0JbNAnsAmuD/5ZV2CfvhR9cU9fir74v/bFGufOYGsEMpjhVCD86wJcLAACqQB6HC7AQslPFkcZHB66s3IHX3znC/OwL45TRz10WoBMKwbNHcRIclKM/aRJ8cY2pFtLdL6/aQpHG4ltOttogS72GMJjy8evlh98Pt4i9vLIYjm841RNJIJPZgIHF/LW7B2Uoj+B04lltL0TGE5iyolJiFkMybAYQUoDSghhWAy4PGzA95THMic55aCyJsuxzn3DcYb+6UvRl/D0pegL38GXu8Wf3EHM/8sPMo8tH75a/lD8xcVk0ywWzdvLu1+0pn2xHyS1yUkdU/Jyd1m6hWRvIblbSF5NiitoseXHxjh2zszg5H1+xhW2yFAkSkglha+eAwLoKainkJ5i9RSnp3g9JegprKeImsL67rO++6zvPuu7z/rus777rO8+67vP5e5byZRwRRE1RYyeAnoK6imkp1glJa5o4P/RAHnohoBXs9M+M6jLoLj8Nd4048li3gZ0++l+OU15HZe73+v0SUr09WY1nc/2m3mb7V2st+aQqa2JUqDdnpZrRznmTpeQauQcYC3Dce05McTXUW3X3/YauBpN7ttHRY7xu/wB",
       "brillig_names": [
         "pack_arguments_oracle_wrapper",
         "enqueue_public_function_call_internal",
@@ -1788,42 +1643,44 @@
       "verification_key": "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"
     },
     {
-      "name": "balance_of_public",
+      "name": "sync_notes",
       "is_unconstrained": true,
-      "custom_attributes": [
-        "public",
-        "view"
-      ],
+      "custom_attributes": [],
       "abi": {
         "error_types": {
-          "16761564377371454734": {
-            "error_kind": "string",
-            "string": "Array index out of bounds"
-          },
           "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": "nZLNCoQgFIXf5a5bpGk/vkoMYWUhiIbZwBC9+1g0QzO00c2FI+c7G78VetEuYyP1YGZg9QrKdNxJo31atwRaK5WSY3N9hnQ/CB39eeJ6j7Pj1gEjOAGhe2A09fQglQCWZ9sjAYQD+1lgnwT2aVgf3+5XBFUnURGSfxlE6AHRGCiPgYoYqIyAstuPr2hafiCKi19o8/HJreStEqdYw6K7i2fuNYk/5SZrOtEvVuzyXbzzt0ZFgrGf9dNv",
+      "brillig_names": [
+        "sync_notes"
+      ]
+    },
+    {
+      "name": "compute_note_hash_and_optionally_a_nullifier",
+      "is_unconstrained": true,
+      "custom_attributes": [],
+      "abi": {
+        "error_types": {
+          "16541607464495309456": {
+            "error_kind": "fmtstring",
+            "item_types": [],
+            "length": 16
           },
-          "206160798890201757": {
-            "error_kind": "string",
-            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
-          },
-          "5019202896831570965": {
-            "error_kind": "string",
-            "string": "attempt to add with overflow"
-          },
-          "6067862452620309358": {
-            "error_kind": "string",
-            "string": "Function balance_of_public can only be called statically"
-          },
-          "6485997221020871071": {
+          "17843811134343075018": {
             "error_kind": "string",
-            "string": "call to assert_max_bit_size"
+            "string": "Stack too deep"
           }
         },
         "parameters": [
           {
-            "name": "owner",
+            "name": "contract_address",
             "type": {
               "fields": [
                 {
@@ -1837,36 +1694,96 @@
               "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
             },
             "visibility": "private"
+          },
+          {
+            "name": "nonce",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "storage_slot",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "note_type_id",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "compute_nullifier",
+            "type": {
+              "kind": "boolean"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "serialized_note",
+            "type": {
+              "kind": "array",
+              "length": 0,
+              "type": {
+                "kind": "field"
+              }
+            },
+            "visibility": "private"
           }
         ],
         "return_type": {
           "abi_type": {
-            "kind": "field"
+            "kind": "array",
+            "length": 4,
+            "type": {
+              "kind": "field"
+            }
           },
           "visibility": "public"
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "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": "tdfNaoQwFAXgd8k6C29+jPFVShmixiEQokQtFPHdG4dpO8wsh7MRrly/gHiQs7PBd9v1EtI4Laz92FmcereGKZVpPzjrcogxXC+Pt1l1Xqy87S+zS+e4rC6vrFWCM58G1uqqPD2G6Flby4O/LJrfRWP+FrU4PjmzCgVrFFyjYIOCGxRsQTBVFUwmmCxgsoTJCiZrmFzDZAOTG5gMyyDBMkiwDBIsgwTLIMEySLAM0nsZtPK+WF7rC21wdIOjLYwWFY4mHC1wtMTRCkdrHI1Lo8ClUeDSKEBpPMr05XJwXfT3zjRuqX+oUOv37J/a1Jyn3g9b9mev+q9U50csFVfq9hcvA0nBSZpySDnoBw==",
       "brillig_names": [
-        "balance_of_public"
+        "compute_note_hash_and_optionally_a_nullifier"
       ]
     },
     {
-      "name": "set_portal",
+      "name": "check_balance",
       "is_unconstrained": true,
       "custom_attributes": [
-        "public"
+        "public",
+        "view"
       ],
       "abi": {
         "error_types": {
+          "15238796416211288225": {
+            "error_kind": "string",
+            "string": "Balance too low"
+          },
+          "16761564377371454734": {
+            "error_kind": "string",
+            "string": "Array index out of bounds"
+          },
           "17843811134343075018": {
             "error_kind": "string",
             "string": "Stack too deep"
           },
-          "2236649814169388962": {
+          "206160798890201757": {
             "error_kind": "string",
-            "string": "PublicImmutable already initialized"
+            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
+          },
+          "3219842053230618354": {
+            "error_kind": "string",
+            "string": "Function check_balance can only be called statically"
+          },
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
           },
           "6485997221020871071": {
             "error_kind": "string",
@@ -1875,28 +1792,19 @@
         },
         "parameters": [
           {
-            "name": "portal_address",
+            "name": "fee_limit",
             "type": {
-              "fields": [
-                {
-                  "name": "inner",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
+              "kind": "field"
             },
             "visibility": "private"
           }
         ],
         "return_type": null
       },
-      "bytecode": "JgACBAEnAAABBIBEJgAABAMmAgIEASYCAwQAHxgAAwACgEMtCIBDAAEkAAAAQCcCAAEEgEQmAgIEADoNAAEAAiQAAADcJgICAAIuDAACAAMcDAMEACsCAAUAAAAAAAAAAAAAAAAA//////////////////////////8OOAQFBiMCAAYAAACMJAAAAQUmAgQAAAo4AwQFIwIABQAAAKcmAgYEADsJAQYoAgADADuaygIuDAADAAUKOAUEBiMCAAYAAADIJAAAARcnAgAEAN6tLwwABAADLwwAAQACJScAgAQEeAANAAAAgASAAyMAgAMAAAEEKQEAAQX3ofOvpa3UyjsBAQIlKQEAAQVaAuQbtR6pnzsBAQIlKQEAAQUfCi0n3IKHojsBAQIlLQAYyhjK",
-      "debug_symbols": "7ZfdaoNAEIXfZa+92Jn9mdm8SinBJCYIosGYQgl596rE1ViJ1DSloDchK986Z44zu8xF7KLN+bCO0312Equ3i0iybVjEWVquLtdAbPI4SeLDuvtYyOrHupo/HcO0Wp6KMC/EiqSkQETprvqrbfmGfZxEYsV4Db7BIJnUjQbp5BhOhA1NznnYqgEYgRshiIAeBkMDNCHYRjYq6up4DwTp2aTKcijVl8qR4OUYfGwLSW5YDR5FPcQy6xvrpBthtW0Ua6dawa52xCyO3DsCiIslfUtosaRniVoap2+JHj1dGaBrSb3JTNhkpkQyPGGTVVM20Z/fqIytIGMe113pRCME7JM3KpCdT648fDP8SI810uux5k5PHYJeHsKZV4dAOdifpG3zmcmAHisKx14QSFS/WRSM3MJ6rCis9QevZdUrCpQ0n1xB/fNcnT9HHLgncr2Wq48wj8NNEt1mxf053XZGx+LzGPWmyGOebaPdOY+qebIdJaFqBqUCxVX3QbVwgYYyRhnnCw==",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
-        "set_portal"
+        "check_balance"
       ]
     },
     {
@@ -1965,59 +1873,26 @@
         "return_type": null
       },
       "bytecode": "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",
-      "debug_symbols": "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",
+      "debug_symbols": "7V3bbhw3Ev0XPfuBlyKrKr+yWARO4g0MGHbgOAssgvz7tjRqzkTNHrrYc6TONF+MKMM6dXhYzfvlz4dfPvz0x68/fvz8ny+/P/zwrz8fPn35+f23j18+T3/9+de7h5++fvz06eOvP17+7wf3+E/Wp/S///b+8+Ofv397//Xbww8U3j18+PzLww/JTdb/+fjpw8MPOf7173cPLLb0Eo3pjfhqxFcjvnfBasBGA2/14K0egrcaZKNBdFaDZDTIloJ7t0jondP4nNY7H6kkl/CEzwGMz1h8AfMXMH/F8g/OGKHBkdXAWJUGH60Gxg8/hGA1MH74wfrhB+uHH6JuCgzx+pxSLoIihlNUECHBBQieAhI8A8GzR4IjmbNDgm8MRccFnJfgCgQXJHMRIPjGRqcBnnHg0XkkOJK5d0jwaiiyK0bsKF92DWo9CeFzT0JdI/n391CY56SeVa8nnhpi/5w4BDlT8IkrqTn4POcvXKgiz6LoEGUhSkh1UWS2IV9MAtUyKULPadVpIy3lWWvSeCauu9XO+aJdCi+1q3f6hnbfo13moV2vdvUx+tDue7ST8c32a5c2dVkuiYv3Lwa4UR0UXYDo5CIUnffbcZFwZp5SI3EuwTjNY27ruJDPQ5SFKGHj7KGJOAcq9VDUvxF/4sL74RLTfrhQvQWiPIciJ0+twFUphKalmfgmgauuJNYgrcA9hzlniS8Dl3iIshAlxXsRpXSDvF72g7pEMS4vTGpZDYxro7R5zYxKt2v675BfZnnzmlkDXzwYP2PxFcs/Wde+kzcuNCfe2D41Vv2SODA+gfEVi69g/orlnx2Wf7buzcjeuICarXszckhWA2PDkSNZDYwNRyarrGRc+c4JuMiYkcujOTskOCHBgevdmSMSHMlcAhIcuFSX1SPBExIcuN7NGye9GuDA9W72SOaegeABWJ9zANbnHB0SnJDgwFqRKSLBkcyRO684Aetzzh4JnpDgyPqckbUiI+tzQTIXZH2+deoiqytzzW5xSGFj3+I6ujgHRScouiDRN/YvWuiMRA8eip6R6BHKPcK+pspEfErzhAylfF4Rrs7aSyiLDlPxvVwUFHKvyDvKvJOConKDt49p5u2TX/CG1l4JWnslaP2St9UvgWluk8K02rJAFyT6xsWSFnpGom+cRm+hExQdWqoKLVVFlqpu3EPeQody9w6KTlB0ZERqCFD0G5Yqp5fo0UPRExRdkegUoeiMRE/QUk3QiMxQ7hkakRkakbw1Isv+nDCNShfogkSXAEXPSHT1UHQk92m53WHhCQt/w4Zb/PXEKeV5JJQSnyeKsztx8fE1uZRdEhOruOQi++ESXlOXXMbxKVOFi7wqFypcLo4wzFziq+rC5zISXnKRN+KiacGFXlMX9qWMOFS4yH64pFfVJfnC5WLSr3CR/XDJeT9ceGNX4LwUGSQum7utc0oN+K2TSi14wsILFH7rvFILHlq03jksPGHhFQrvsew9NDB9CFh4bGBGbGDGGxYtyfXE/mLzPoVzJ8snqaTmrOWkL/tzV7V+eEbLSRs/jcRL4uiqrZQv51aS5/yylfJRDylKuipK/eKpXRxxggp+7YiT91vXJhsHWiYHCe1AwQ427uD+DgfoHIj1rkgvxhMMPjjwbYXBe7SDDHYQ0DkI6BxEdA6iOe4omi2sF9Labv47WVivc7Xd0XeySGYLs7qmK/JOFsCNwD5IhKIzEl09FD0B0aNzUHQsd0WiIw94TOiCRA8Bip6R6NFB0RMSnaDct96w20BHbjf0ceNRjyY8Q+Gzx8InKDw7LDxh4bGBKRELj2WvsM9qmTgzzcPRzKm1MVu0bChXn14OCKJCP1hy0OqGvMPCb9zMpOcb+1SX8MFh4QkLL1D4rav7LXgsewpY+AyF3zhpGV2YuzjRUeNGqRsej5mIp43E3Zl4yAtdssPCExZeoPAbT4M04TMUXrBFK9iiFWzRasTCQ9knF7Dw0MBM3mHhCQt/w6JNcQEfIhaeofAbZ/ub8AkLr1B4whYtYQMzYdknbGBmbGDmGwZmbqzmM/N5Q4QuNhEndjvisiNd5FV10XkJgMXTkkvaDxfdkS76uvHC53hZbIDPzu2IC+2Ii+yHiw874sL74RJ2pEvI++ESX/ObFkqlrku65JL2w4V2pAu9qi65vFghsji8kZPbEZcd6ZJfN16ocMm05JJ2xEX3w4XjjrjwfrhI2BGXHemifkdcXvWb1tJn0PC39qiCHKUg0+UA5ok3R5iGJ/gMhScse1IofCLsnnhGHxvgjTenfYcDATtgdA5Mq05PFmrd7S3oYwPiE9hBcGgH6BxEdA4iOgfmUwZifT/Di/mUgZhPGUh2ZotktrCeMhA2q8vWMxyCfBNiQkeeHBDoyQGBnhwQRe6+141TqS10KHcfoejAu8S9Qk8OKPTkgEJPDujW9yEa6IpEh54cUEKeZVHswYGtdx624LEHBxR7cGDrtYcteOzBAcUeHNh682ETHrpBXhXLXmGf1TLxDc8lBOeQH+wEn6HwnrDwG+eGQpj3fsRAvIDfeHCgCS9Q+Biw8BkKv3VtsQWPLVrCFm3CFu3WXXUN+Ixln7GBydjAZGxgMjYw5YZFe7nIP8MzFH7rWlYLPmHhFQnvNz6N2YSHFq33AQuPZR88Fj5h4W8YmNxIPPWqyom+qYtSEgfVSurr99uFrZf+QZmn68yNc+PBm3pEJwuzj2T2kcRqkaPZwuyDzT6YrRYSzBbZaqHebGH1EZwzW2wcNDaWgycHCnbgI9qBgB0EdA6itSowX9kWgrlKC+YqLZirtJDMPrLZRzb7YLMPNvsQsw8x+1CzD7VW/9FFs4XZhzf78GYfIZgtrNV/jN5skawW5MwWZLawRmJM5hI0d3ZiNpdgtnZEIptLkM1RIuYSFHOUmOuSaK5LorkuIXNdQs5aguSD2cJaghS82cJaghSd2YLMFtYoITKXIJmjJJlLMJmjZOPSMM8J+TwtmMIzdIZBM441Kwx64zUoV6EFBr3x+pOr0DDWW689uQa9cUvuNeiNm3GvQuNYRxzrCKtDEuEihHBxnSIOGsc641hnhkEzLEJyfaYllfc/0sVjGs+b0CYj7jCqD8Wyn7dY5ItZ57NR7jCiHk/1EVbDqD790jLq8ZR7PNWnllN5myY7XhrVg61lxB1G0uNJejxpj6f6ZPN1I67PN+c0n0ye5K0YpQ4j3+PJ93iq1xEtI+kwqm8aahjV96x6LhtpPfuLBS3yJ7P6gKNt1ueNu7ytHEthVy4NIn9hVN/hNx9aVaeNtJRnNlNnu6T1euJS33ryJly0PgvxNlzq8xtvwyXsqIzqs2rXewlaH5q2jMTeOGp9ONkysnuKK7tcG0be9xj1eAo9nuqjuKuN42SkHUb1SbSWUY8n6vFEPZ7qg6eWEZsbx7iy27Fl1OOJezyJ6zFKPUZqN1rZ+fT4kOvcavuLHUf+cSC2TC2zC6/nCwCmpv3ZRYK7qE+L3NYFPheEzwW9Qi4U7qJeudzWhcBd1Csuo4vydQcX/uai0u8JZQOcTGO/c+rqe6OxIFM4z76EGnAIZS/K5EKvJ05xPqCfLk67hlkTHpq81IT90GShSR6avNRERpwsNRlxstBER5wsNUlDk4UmOjR5ocnK1umDayJDk5ea+Dg0WWgy+vYLTcJoi5eajD7bQpObTHD98zQpqy/p4mbRoskx2+Lrmhyzz3ZVEzpkW5xL2vz3pE+a5EN+Ow1NDtmPva4Jj29nqcmIk4UmMuJkqcmIk4Umesg1r4YmhxzvXNUkukOOixuaHHKO+rom/pDj4oYmNDRZaHLIcfF1TcIB+mynjB5g4vkpo/EAvatTRg/QZXrKKB2gfTtl9ACdm1NGD9ASPWU0HaV5SQcY5z9l9AgbVk8ZPUrzcoStpaeMHqV54aM0L3KAUe4po0cpUT1Kh0EPMh4ld5AOw8qVcXeY0Xg/7SidM5rCIqP3M3rhUFgw9Sc+qXI3cW5RxWcuryRlWWwwovsZF91SFb6bqaubqnI3FehNVbmbPq5JFZbyWLW4ZRt0P0Ocm6pyN9Ntt1TlfjbW3FSVu5nIu6EqyR2zZW6pMmrbmiqjZa6ocj9bbG6qymiZK6qE0TLXVBktc0WV+znmd1NVRm1bU2XUthVVaNS2NVWOOW/bUCXdze4HkyrqS/40VlQ5ZsvcUCWPWKmpUp/NDnG+YdkH9Q1VppbsOXHM55uPq888iKOiySWsnNisrDi8FZtdabNyQPNt2GR3N3VM9LMmIV7k9PkDyf5uqo1WRo9SooGOktG7mflrZPR+hpetjB6lRFdufHGl5+Mdp0bP55+4pUm1qOLDUhUeqixVWRsEkjtnVI6nSh6qLFVZuzXp4KroUGWpytrNSeWpQu/1eLXtyt3TdH4kjNzxYmXl9umjq6JDlYUqXH/P/vCq1Pu204LqnNGU+HCq1N/tO7wqI1Yqqqy80nVwVVY2ZBxdlTxUWaqyMut0dFVkqLJUpf6s+uFV0aHKUpU8YqWmyqhXKqrwaINqqoxYqagioxdXUWVlhjJxyWhSPZ4qaahSUUWHKgtVZGWG8uCqrMzFxfMGyxgPN28rK3NxB1dl5VW4o6uShioVVXSoslQlxqFKRZVR21ZUodEy11QZsVJRJY2WuabKaJlrqoyWuaJKXmmZUzmIFPPhZp1kZQ/lwVXhPFRZqiJ+qFJRhYcqS1VWroU7uiojVpaqqBt7s2uqjL3ZNVXG3uyKKn7sza6ocj8XoLUyej+vAFzP6B29M3g9o3f0/N71jNbnKtiVmosd5WIloZZPJ1yuW3LqWsmDL7VioHAhYi2rHPycVw6RL6Gf+K9dRGPzUd6+4MsnIar0w1Tys6CeqCSOLp4YrV1G84aMaHeMZG+M1q7JeUNGu9NoZUz5lozyvhiRq18QTFoaDtJ4rrJzrd2gzOe0Z/L67EDBDupN3y0dJLCD+hM+t3QgdQdJilHOlw6erHLsslrxpXMcJuf8wopXfCkVK+8WVkodVr7+sC1J2U5KcvER5pNR5rqRhiKGoxdGsc6PqfQQknvRwSGqb79SmmNBc1jaZLtNcB021GEjxstcnqxi7LLiHquVZfWWVZev1OUrdfnKXb5yly/uKi/u8iVd+VrZRN6wUtdlRV1WPV9Kqm9ivVrHpPohdPVzv+KyuZlt6pvaGjZqt6l/+Q2bjvyQN9dliez17MrdvQ0btdtk6rDp8MMdfurDp6n3MNuwLmzqA5yGTYefepf8qk2uL0A0bDr8+A4/PjXKp2LT0RfIIdltYoef+u3x123qB5wbNvZvYeXyses22XfYsN2GQ4dNhx/pyI90xI50lI/a44Bd6LCx68Yd/Xy2fqd/TX/99/3Xj+9/+vTh98ni8cc/Pv/87eOXz89/fvvfb/MvP339+OnTx19//O3rl58//PLH1w8/fvry8+NvD+75n39pSu+U88TlUVjJ8d00kzr95R9/TNG/S/Hxx6dqa6pY3yWVicPE4/8=",
       "brillig_names": [
         "public_dispatch"
       ]
     },
     {
-      "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": "nZLNCoQgFIXf5a5bpGk/vkoMYWUhiIbZwBC9+1g0QzO00c2FI+c7G78VetEuYyP1YGZg9QrKdNxJo31atwRaK5WSY3N9hnQ/CB39eeJ6j7Pj1gEjOAGhe2A09fQglQCWZ9sjAYQD+1lgnwT2aVgf3+5XBFUnURGSfxlE6AHRGCiPgYoYqIyAstuPr2hafiCKi19o8/HJreStEqdYw6K7i2fuNYk/5SZrOtEvVuzyXbzzt0ZFgrGf9dNv",
-      "brillig_names": [
-        "sync_notes"
-      ]
-    },
-    {
-      "name": "_increase_public_balance",
+      "name": "set_portal",
       "is_unconstrained": true,
       "custom_attributes": [
-        "public",
-        "internal"
+        "public"
       ],
       "abi": {
         "error_types": {
-          "10502589790419500451": {
-            "error_kind": "string",
-            "string": "Function _increase_public_balance can only be called internally"
-          },
-          "16761564377371454734": {
-            "error_kind": "string",
-            "string": "Array index out of bounds"
-          },
           "17843811134343075018": {
             "error_kind": "string",
             "string": "Stack too deep"
           },
-          "206160798890201757": {
-            "error_kind": "string",
-            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
-          },
-          "5019202896831570965": {
+          "2236649814169388962": {
             "error_kind": "string",
-            "string": "attempt to add with overflow"
+            "string": "PublicImmutable already initialized"
           },
           "6485997221020871071": {
             "error_kind": "string",
@@ -2026,7 +1901,7 @@
         },
         "parameters": [
           {
-            "name": "to",
+            "name": "portal_address",
             "type": {
               "fields": [
                 {
@@ -2037,24 +1912,17 @@
                 }
               ],
               "kind": "struct",
-              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "amount",
-            "type": {
-              "kind": "field"
+              "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
             },
             "visibility": "private"
           }
         ],
         "return_type": null
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "JgACBAEnAAABBIBEJgAABAMmAgIEASYCAwQAHxgAAwACgEMtCIBDAAEkAAAAQCcCAAEEgEQmAgIEADoNAAEAAiQAAADcJgICAAIuDAACAAMcDAMEACsCAAUAAAAAAAAAAAAAAAAA//////////////////////////8OOAQFBiMCAAYAAACMJAAAAQUmAgQAAAo4AwQFIwIABQAAAKcmAgYEADsJAQYoAgADADuaygIuDAADAAUKOAUEBiMCAAYAAADIJAAAARcnAgAEAN6tLwwABAADLwwAAQACJScAgAQEeAANAAAAgASAAyMAgAMAAAEEKQEAAQX3ofOvpa3UyjsBAQIlKQEAAQVaAuQbtR6pnzsBAQIlKQEAAQUfCi0n3IKHojsBAQIlLQAYyhjK",
+      "debug_symbols": "7VfbioNADP2XefZhkrlk0l9ZlmJbWwTRYu3CUvrvq6KjdaVSd7ss1BcxcmJOziQTchG7aHM+rON0n53E6u0ikmwbFnGWltblGohNHidJfFj3PwtZPSzX+NMxTCvzVIR5IVYkJQUiSnfVq7blH/ZxEomVw2vwDQzSkWrQIFlOwYmwRROzB1s1Aka00IARXfdnMDSCJgTb0kZFfR7vgSD9Mqk6OZbqU+lI8HQM3peFpGuxGjwU9RjWOd1gWfIEVtv2JDWrjjDXiphFkVtFAHGRZCgJLZIMJFFL4wwl0ZO3qwPoS1I7mRlOZk4k42Y4WTXHif58ojrsCBlzv+7A+roD+8OJCmRfJ1c3Phke4kOo/QWh+IZPHYKeHoLNs0OgHO1P0rY9ZjKgp4qCnScEEtVvFgVLD2Z0U0XRlRBZpwZFgZJeJ1dQ/zxXP56A+/Pp4VyvpfUR5nG4SaJmV9yf021vdSw+j9Fgizzm2TbanfOo2ie7VRKqZlAqUK7qPqgMDjSUMco4Xw==",
       "brillig_names": [
-        "_increase_public_balance"
+        "set_portal"
       ]
     },
     {
@@ -3732,7 +3600,7 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "7b3truNKdqR9L/37/GB+Z86tDAzD9ngGDTS6B/54gReG731U55S0d5W4mV0URYUi4o9xyq3c5FohJRcjcz35X3/6X//6z//5f/7xz3/933/79z/9j//5X3/6y9/+5Z/+489/++vlX//1p5B+///9+//9p79+++e//8c//dt//Ol/hDqW3/70r3/9X5f/bMvy37/96X//+S//+qf/UdN//3b34dhT//7h2OvHh8fah1MJ4/uHUxlx+8Oh5pCu91FzrLePx9LXPp9ufzyk1D8+Xdc+vMR6/fDSyucP/8NvfwrZeVnNS3FeVvNSsfNSlo+81DzLS+u3NPYlPpSX5rys5qU7L6t5GQ/nJS+lfP9wXka4fbiHbxeIy7MvENYuEJcQr2ItuW1fIPWrsDl8zGE1rt1LLO362djS7cNhrHy45OWa+pJj/vzhbzce3/XG07veeH7XGy/veuP1XW+8veuN93e98fGmN56Wd73xd31ypnd9cqZ3fXKmd31ypnd9cqZ3fXKmd31ypnd9cqZ3fXLmd31y5nd9cuZ3fXLmd31y5nd9cuZ3fXLmd31y5nd9cuZ3fXLmd31ylnd9cpZ3fXKWd31ylnd9cpZ3fXKWc5+cdcnXz9a4/HwvFeheGtC9dKB7OfcpVD9W02r7+V7qAnQvAeheItC9JKB7yTi/owo071agebcCzbu1A313gebdBjTvNqB5twHNuw1o3m0Z6F4K0L1UoHtpQPcCVO+2gXMvfQG6lwB0L0DzbgeadzvQvNuB5t0ONO92oHm3A9W7HajeHUD17gCqd0fEeQaMBHQvGehegHyGATTvDqB5dwDNuwNo3g0L0MQbFqCZNyxAJW9YgGresAAVvWEBqnrDAmTzhgXI5w0LkOEQFiDHIQSkGTggzcABaQYOSDNwQJqBA9IMHIAK4BCAKuAQgErgEJBq4Ahk+oYI5PqGCGQ/hAjkP4SINANHpBk4Is3AEWkGjkgzcESagRNSDZyQauCEVAMnpBr45B7U7cdBAvKAQ0JyIRKSC5GQZuCENANnpBk4I83AGWkGzkgz8Mm9jJObQaqBM1INnJFq4IzkA2ckH7gguRAFyYUoSDNwQZqBC9IMXJBm4II0AxekGbgg1cBIvW4BqdktIHW7hYrkA1ckHxip4S0gdbyFijQDV6QZGKnpLSB1vQWktreA1PcWkBrfAlLnW0BqfQtIvW+hIfnADckHRmp/C0j9b6EjzcAdaQZGaoELSD1wAakJLiB1wQWkNriA1AcXkBrhAlInXBhIPvBA8oGRmuECUjdcGEgz8ECagZEa4gJSR1xAaokLSD1xEaknLiL1xEWknriI1BN3uRTO4yAuQD5wROqJi0g9cXEBmoHjgjQDI/XERaSeuIjUExeReuIiUk9cROqJi0g9cRGpJy4GIB84BiAfOCL1xEWknrgYkWbgiDQDI/XERaSeuIjUExeReuIiUk9cROqJi0g9cRGpJy4mIB84JiAfOCL1xEWknriYkGbghDQDI/XERaSeuIjUExeReuIiUk9cROqJi0g9cRGpJy5mJB84I/nASD1xEaknLhakGbggzcBIPXERqScuIvXERaSeuIjUExeReuIiUk9cROqJixXJB65IPjBST1xE6omLFWkGrkgzMFJPXETqiYtIPXERqScuIvXERaSeuIjUExeReuLi2T1xm4+DhuQDI/XERaSeuNiQZuCGNAMj9cRFpJ64iNQTF5F64iJST1xE6omLSD1xEaknLnYkH7gj+cBIPXERqScuDqQZeCDNwEg9cRGpJy4i9cRFpJ64iNQTF5F64hJST1xC6olLC5APnBYgHzgtGelmgFyItADNwGkBmoETUk9cQuqJS0g9cQmpJy4h9cQlpJ64hNQTl5B64lIA8oFTAPKBE1JPXELqiUsRaQaOSDMwUk9cQuqJS0g9cQmpJy4h9cQlpJ64hNQTl5B64lIC8oFTAvKBE1JPXELqiUsJaQZOSDMwUk9cQuqJS0g9cQmpJy4h9cQlpJ64hNQTl5B64tLZPXGbj4OM5AMj9cQlpJ64lJFm4Iw0AyP1xCWknriE1BOXkHriElJPXELqiUtIPXEJqScuFSQfuCD5wEg9cQmpJy5VpBm4Is3ASD1xCaknLiH1xCWknriE1BOXkHriElJPXELqiUsNyQduSD4wUk9cQuqJSw1pBm5IMzBST1xC6olLSD1xCaknLiH1xCWknriE1BOXkHriUkfygTuSD4zUE5eQeuLSQJqBB9IMjNQTl5B64hJST1xC6olLSD1xCaknLiH1xCWknri8APnAeQHygTNST1xG6onLC9AMnBegGTgj9cRlpJ64jNQTl5F64jJST1xG6onLSD1xGaknLp/dE7f5OAhAPnBG6onLSD1xOSDNwAFpBkbqictIPXEZqScuI/XEZaSeuIzUE5eReuIyUk9cjkA+cI5APnBG6onLSD1xOSHNwAlpBkbqictIPXEZqScuI/XEZaSeuIzUE5eReuIyUk9czkg+cEbygZF64jJST1zOSDNwRpqBkXriMlJPXEbqictIPXEZqScuI/XEZaSeuIzUE5cLkg9ckHxgpJ64jHROXEbqictIPXEZ6Zy4jNQTl8/uidvODFINXJFm4Io0AyP1xGWknriM1BOXkXriMtI5cRnpnLh8dk/c9s0g1cAn98S1Hq6fbT3d3czjM/Dl3et2gTC5mVja9bOx/XAz9x8ueanfP1wuC7t3d97f9s7Hu975Aa15r7rz8LZ3Ht/2ztPb3nl+2zsvb3vn9W3v/G2fof1tn6H9bZ+h422foeNtn6HjbZ+h422foQc0hL7qzt/2GTre9hk63vYZOt72GTre9Rlalnd9hpblXZ+hZXnXZ2hZ3vUZWpZ3fYaW5V2foWV512doWd71GVqWd32GluVtn6HhbZ+h4dxn6OaqcQkR6WYS0s1kpJs593m0uQJYQkW6mYZ0Mx3pZgbQzcQF6NcUkWbgiDQDR6QZOGakLzDSDByRZuCINANHpBk4Is3AaUG6mYB0MxHpZhLSzSDVwKkg3UxFupmGdDNIM3BCmoEz0gyckWbgjDQDZ6QZOGekm0GqgTNSDZyRauDcgR4HeQDdTEFyIQqSC1GQZuCCNAMXpBm4IM3ABWkGLkgzcEGqgQtSDVyRauCKVANXJB+4IvnANSPdDJILUZFm4Io0A1ekGbgizcANaQZuSDNwQ6qBG1IN3DLSzSDVwA3JB25IPnBDciEakgvRkWbgjjQDd6QZuCPNwB1pBu5IM3BHqoE7Ug3ckWrgjlQDDyQfeCD5wAPJhRhILsRAmoEH0gw8kGbggTQDD6QZeADNwHUBqoHrAlQD1wWoBq4LUA18mZ5xHgd1AfKB6wLkQtQFyIWoC9AMXBekGTggzcABaQYOSDNwQJqBz+6J274ZoBq4IvXEVaSeuBqAfOAagHzgitQTV5F64mpEmoEj0gyM1BNXkXriKlJPXEXqiatIPXEVqSeuIvXEVaSeuJqAfOCagHzgitQTV5F64mpCmoET0gyM1BNXkXriKlJPXEXqiatIPXEVqSeuIvXEVaSeuJqRfOCM5AMj9cRVpJ64WpBm4II0AyP1xFWknriK1BNXkXriKlJPXEXqiatIPXEVqSeuViQfuCL5wEg9cRWpJ65WpBm4Is3ASD1xFaknriL1xFWknriK1BNXkXriKlJPXEXqiatn98RtPg4akg+M1BNXkXriakOagRvSDIzUE1eReuIqUk9cReqJq0g9cRWpJ64i9cRVpJ642pF84I7kAyP1xFWknrg6kGbggTQDI/XEVaSeuIrUE1eReuIqUk9cReqJa0g9cQ2pJ64tQD5wW4B84LZkpJsBciHaAjQDtwVoBm5IPXENqSeuIfXENaSeuIbUE9eQeuIaUk9cQ+qJawHIB24ByAduSD1xDaknrkWkGTgizcBIPXENqSeuIfXENaSeuIbUE9eQeuIaUk9cQ+qJawnIB24JyAduSD1xDaknriWkGTghzcBIPXENqSeuIfXENaSeuIbUE9eQeuIaUk9cQ+qJa2f3xG0+DjKSD4zUE9eQeuJaRpqBM9IMjNQT15B64hpST1xD6olrSD1xDaknriH1xDWknrhWkHzgguQDI/XENaSeuFaRZuCKNAMj9cQ1pJ64htQT15B64hpST1xD6olrSD1xDaknrjUkH7gh+cBIPXENqSeuNaQZuCHNwEg9cQ2pJ64h9cQ1pJ64htQT15B64hpST1xD6olrHckH7kg+MFJPXEPqiWsDaQYeSDMwUk9cQ+qJa0g9cQ2pJ64h9cQ1pJ64htQT15B64voC5AP3BcgH7kg9cR2pJ64vQDNwX4Bm4I7UE9eReuI6Uk9cR+qJ60g9cR2pJ64j9cR1pJ64fnZP3ObjIAD5wB2pJ64j9cT1gDQDB6QZGKknriP1xHWknriO1BPXkXriOlJPXEfqietIPXE9AvnAPQL5wB2pJ64j9cT1hDQDJ6QZGKknriP1xHWknriO1BPXkXriOlJPXEfqietIPXE9I/nAGckHRuqJ60g9cT0jzcAZaQZG6onrSD1xHaknriP1xHWknriO1BPXkXriOlJPXC9IPnBB8oGReuI6Uk9cr0gzcEWagZF64jpST1xH6onrSD1xHaknriP1xHWknriO1BPXG5IP3JB8YKSeuI7UE9cb0gzckGZgpJ64jtQT15F64jpST1xH6onrSD1xHaknriP1xPWze+I2HwcdyQdG6onrSD1xvSPNwB1pBkbqietIPXEdqSeuI/XEdaSeuI7UE9eReuI6Uk9cH0g+8ADygQdST9xA6okbC9AMPBagGXgsQDPwQOqJG0g9cQOpJ24g9cQNpJ64gdQTN5B64kYA8oFHAPKBB1JP3EA6J24g9cQNpJ64gXRO3EDqiRsRqQaOSDVwRJqBI9IMjNQTN5B64gZST9xA6okbSOfEDaRz4kZCqoETUg18ck9c6+H22Z7ubmZ1Bg69XW8mXGy/26DYVq4Qa27XO68jTj78K2GOcp2vR5+EOerto6N+3ELpK58NH/qEWvvnG/49Jdkp+TklxSn5OSXVKfk5Jc0p+Tkl3Sn5OSXDKfkpJevdq9opCU7JzymJTsnPKXH1epeS7JT8nBJXr3cpcfV6lxJXr3cpcfV6lxJXrz+npBxQvV6Km2uUY4ztD/e2jO8f7i31989fODd/Y0nX799Yanj//EXn76H8pZN/v71d7733kbc/HHIr9XofuTWC6TI73Wemu3h2eCh/1fl7KH/NP/cz092d7jPTPTw7PJK/ujh/D+Uv+N3zofz53emx/CXn76H8ZT+uz0x3cbrPTLffnR7LX3P+HsqfX4ZOTfdwuk9Md/O702P587rTY/mLfvd8KH9+d3osf9n5eyh/fhk6Nd3V6T4z3X53eix/3fl7KH9+GToz3X1xus9Mt9+dHsuf150ey1/yu+dD+cv+/j2UP++qeyx/fhk6Nd3ehHdquv3u9Fj+vKvuofwNvwydmu7gdJ+Zbr87PZY/rzs9lr/sd8+H8ud3p8fy5111j+XPL0Onptub8E5Nt9+dHslfWBZvq3swgX4dOjff0fk+Nd9+f3owgdkJfCyBxW+gjyXQr1APJtC76x5MoN+Kzs23t+Odmu/gt6gHE+gddg8m0K9F5+bbGL1z8509QTyWQK9DPZjA6tfQxxLot6gHE+iNdg8m0K9Fp+Y7emfeufn2W9SDCfRmuwcT6Neic/Odne9T8+23qAcT6LWoBxPY/Br6WAL9FvVgAr3n7rEEJr8WnZtvb9E7N99+i3owgd5z92ACs3/xp+bbcL1z8+23qAcT6LWoBxPY/Rr6WAL9FvVYArP33D2YQL8WnZtvb9E7N99+i3owgdkJfCyBfi06N9/m7J2bb79FPZhAr0U9mMDh19CHElj8FvVgAr3n7sEE+rXo3Hx7i965+c6eIB5LoPfcPZhAvxadm28j987Nt9+iHkyg16IeS2Bd/Br6WAL9FvVgAr3n7sEE+rXo3Hxn5/vUfPst6sEEes/dgwn0a9G5+TZ079x8+y3qsQQ2r0U9mMDg19DHEui3qAcT6D13DyYw+6F9ar69Re/cfPst6sEEes/dgwn0a9G5+TZ079R8d79FPZhAr0U9mMDo19DHEui3qAcTmJ3AxxLo16Jz8+0teufm229RDybQe+4eTKBfi07N9zB079x8+y3qwQR6LerBBCa/hj6WwOxv4GMJ9J67BxPo16Jz8+0teufm229RDybQe+4eSmBY/Fp0br4N3Ts3336LejCBXot6MIHZr6GPJdBvUQ8m0HvuHkygX4vOzbe36J2bb79FPZbA4D13DybQr0Xn5tvQvXPz7beoBxOYncDHElj8GvpYAh9/i0p5Wb5/OOXEMK015+QuJ905ucvJcE5+zklcnJO7nATn5C4n0Tm5y0lyTu5ykp2Tu5wU5+QuJwfUsb1ea/s0QibISXNO7nLSnZO7nDxex+alp+8fziEv/63lQqTFCXwsgeHcBKobtyk636fmO3mCeCyB2Ql8LIHFv/hT812d71Pz3TxBPJbA7gQ+lsCT36LoliLzAW9RMV9zkuOY5GTkcs32KKFOpsylteuf/kZ/awT5Ds73qfmOzvep+U7O96n5zs73qfkuzvep+a7O96n5bs73qfnuzvep+R7O95n5Ln6/PDfffr88N99+vzw3336/PDff2fk+Nd+Pv1+WEq7bDEthWGYq1Tm5y0lzTu5y0p2Tu5w8/r5TaujXnNSeJlNyK+12Q62m6Qx++ZO3GbzMng7vkPG6OOMnZzw44ydnPL5RxutCsF28JvCM01XiNTvjJ2e8OOMnZ7w64ydnvDnjJ2e8O+MnZxz9nZMu4w39nZMv4+jvnHwZR3/n5Mu43znPznh2xk/O+OnvnG3Jt4y3OkHfhTDCrWksjDwIMl6xM35J3O1O4lIZMn76O+foy+1PL2EhSGF3Ch9N4dlvhT3kjxSGSrCY2494zRvX58llfXv2vO85htufzoXged+DU/hoCqNT+GgK09kpLOVjLix90vmdY7m2iefYPubZMNZuJC+3G8kxb3/4LcTJFgdXnGJxcMWpFgdXnGZxcMXpFgdXnGFxYMUZi8XBFSdYHFxxosXBFccOAbA42eLgimOHAFgcOwTA4tghABbHDgGwOHYIYMWJix0CYHHsEACLY4cAWBw7BMDiZIuDK44dAmBx7BAAi2OHAFgcOwTA4tghwBUn2CEAFscOAbA4dgiAxbFDACxOtji44tghABbHDgGwOHYIgMWxQwAsjh0CXHGiHQJgcewQAItjhwBYHDsEwOJki4Mrjh0CYHHsEACLY4cAWBw7BMDi2CHAFSfZIQAWZ9UhiEu74iRjWMr2ncfer5eII37AJENZVSd8iBPGR6RhWb7fUYS7owR3RxnujgrcHVW4O2pwd9Th7mig3VFe4O5odc5Opd4eY5+gyHXtfi7P0Ov9tDz5cGg93Z6mS5x8eLn95bC0sv3hXsL1L397ZE+eZD3m26fjp7Ssf/qJ+vRbvXBRJK7IEy0PsjzJ8iDLky0Psjzn13nL7WCVmOvKHVW4Ozq9zmv146yanyqG+09/fOXbD6+Pqz+mkPPtpkv/4dN/xNqFYh06sZaFKNaabjfd1mINQrFGoVgTUay3D8f4uU65xZqFYi1CsVamZ86nWNNKrER10+Wub7HGthIrUd00jZWobprFWpnqpk+/17jyfK0P+5BxXN+kLgtRs7fvFG6vXSn1A1/VYdTpt6I8LGFM5NmyDP6QJ1oeZHlIfEhWebLlQZYH+x3g4GDPfwn4OOm3xzQrKvK1Jmqfd5jU6923t777/tZ3P9757tvy1ncf3vru41vffXrru89vffflre/+rZ+17a2fte2tn7XtrZ+1/a2ftf2tn7X9rZ+1/a2ftf2tn7X9rZ+1/a2ftf2tn7X9rZ+1/a2fteOtn7XjrZ+1462fteOtn7XjrZ+1462fteOtn7XjrZ+1462fteOdn7VpeednbVre+Vmblnd+1qblnZ+1aXnnZ21a3vlZm5Z3ftam5Z2ftWnBftb22y6C3peVu8d+1k7ufv20EO+Z2Z3vUT9144UfEn7/4VzqLdFlfArxlzsO/xCTpMvcYn4Tk6Qn3WJ+E9M7R4nEzBaTR8xiMXnErBaTR8xmMXnE7BaTR8xhMWnEjHaAiMS0A0Qkph0gIjHtABGJmS0mj5h2gIjEtANEJKYdICIx7QARiWkHiEfMZAeISEw7QERi2gEiEtMOEJGY2WLyiGkHiEhMO0BEYtoBIhLTDhCRmHaAeMTMdoCIxLQDRCSmHSAiMe0AEYmZLSaPmHaAiMS0A0Qkph0gIjHtABGJaQeIR8xiB4hITDtARGLaASIS0w4QkZjZYvKIaQeISEw7QERi2gEiEtMOEJGYdoB4xKx2gIjEtANEJKYdICIx7QARiZktJo+YdoCIxLQDRCSmHSAiMe0AEYlpB4hHzGYHiEhMO0BEYtoBIhLTDhCRmNli8ohpB4hITDtARGLaASIS0w4QkZh2gHjE7HaAiMS0A0Qkph0gIjHtABGJmS0mj5h2gIjEtANEJKYdICIx7QARiWkHiEfMYQeISEw7QERi2gEiEtMOEJGY2WLyiGkHiEhMO0BEYtoBIhLTDhCRmHaAaMTMix0gIjHtABGJaQeISEw7QERiZovJI6YdICIx7QARiWkHiEhMO0BEYtoB4hEz2AEiEtMOEJGYdoCIxLQDRCRmtpg8YtoBIhLTDhCRmHaAiMS0A0Qkph0gHjGjHSAiMe0AEYlpB4hITDtARGJmi8kjph0gIjHtABGJaQeISEw7QERi2gHiETPZASIS0w4QkZh2gIjEtANEJGa2mDxi2gEiEtMOEJGYdoCIxLQDRCSmHSAeMbMdICIx7QARiWkHiEhMO0BEYmaLySOmHSAiMe0AEYlpB4hITDtARGLaAeIRs9gBIhLTDhCRmHaAiMS0A0QkZraYPGLaASIS0w4QkZh2gIjEtANEJKYdIB4xqx0gIjHtABGJaQeISEw7QERiZovJI6YdICIx7QARiWkHiEhMO0BEYtoB4hGz2QEiEtMOEJGYdoCIxLQDRCRmtpg8YtoBIhLTDhCRmHaAiMS0A0Qkph0gHjG7HSAiMe0AEYlpB4hITDtARGJmi8kjph0gIjHtABGJaQeISEw7QERi2gHiEXPYASIS0w4QkZh2gIjEtANEJGa2mDxi2gEiEtMOEJGYdoCIxLQDRCSmHSAaMctiB4hITDtARGLaASIS0w4QkZjZYvKIaQeISEw7QERi2gEiEtMOEJGYqw7QM1NT+5ep+f2OwnLyHcXcbl/HkspErBBjvt5/TB9f3hTXPl0vv5bvn64lfeQ/jJUPp1rH9w+n2trHh9eUTWm5Knv5z/H5w3+kMTiNR6QxOo1HpDE5jUekMTuNf08ac7r+5XR5SN6nsTiNR6SxOo1/VxrbRxpH2v5w7CPdEvIpe+sfDi3cUt37vUDNAr1WoJiX64djnfzlfHsN+OEmxnctu7Wk0XJYSxYto19XX61lv+Xjp5r5l7X0OzOPln5xf7GWadxSnWO+K06jLQFwgbIFwhbINsaLBSpx3PJR+/aHQ11uyzw1lns17aYwqWnr5Z3UbOW2yNxafajutE8jKrxNHU3hkx2gtxJ+XFMdeugPCW+7SFR4e0vHCz8+tBw5TD48WfhM9pZeLNBxCywpW0saLe1YvVrLwxZYkv0qHi3tVr1Yy4nVn+wqgQtk9wdboGyX5sUCHbm8km29MKlpP+Wd1DzOOs/2aUSFzxZeU3g7QG8l/GFrJtl2kajw9pYOFz4tt4I6LZ8IGvuqb3tL4ALZW3qxQMfVP8U2FI+WNqF4tLQF9WotD6s4i10lHi2ztfx7tLwk6vrhUid7AQ5ljBQbOi8W6LjtWcUeDY+Wtl14tLRD82otD9tqV2zm0GhZbea8WMvJpq9qhwZcINsu4ALZS3mxQEdutKvZahKpaevlndQ8brGi2qcRFd6mjqjwdoDeSvjD1r+q7SJN4Zu9peOFP5Ix0uwtvVig4xZYmm0oHi3tWL1ay8MWWFq2ljRa2q16sZYTq7/ZVQIXyO4PuEB2aV4s0JHLK83WC5Ga3X7KO6l5nHXe7dOICm9TR1R4O0BvJfxhayY9W3hN4e0tHS78oQiLbm8JXCB7Sy8W6MD6xzYUj5Y2oWi0HLagXq3lYRXnsKvEo+XpRtHlktdP11LfRcu0XGfC9NNegD/SmJzGI9KYncYj0licxiPSWJ3Gv4ullT5YWmUljc1pPCKN3Wk8HCJ9JA1sDAv0WoEO20hdl8Va0mgZrCWNln5dfbWWR22Kr4vfmXm0zNbytVpub8+uiy0BcIFsNoALZBvjxQIduCW+LnZTmNS09fJOah62raAG+zSiwtvUERXeDtBbCX/UTpUabBeJCp8t/OHCH0gDq8He0osFOm6BJdiG4tHSjtWrtTxsgSXYr+LR0m7Vi7WcWP3RrhK4QHZ/wAWyS/NigY5cXom2XpjUzFbzjdQ8zjqP9mlEhbepIyq8HaC3Ev6wNZNou0hUeHtLhwt/JGyqJntL4ALZW3qxQMfVP8k2FI+WNqF4tMzW8sVaHlZxJrtKPFraKPq7tHzeiauTrXbJhs6LBTpue1ayR8OjpW0XGi2zHZpXa3nYVrtsM4dHS5s5L9Zysukr26EBFyhbIGyB7KW8WKAjN9pluylMatp6eSc1j1usyPZpRIW3qaMpfLED9FbCH7b+VWwXiQpvb+l44Y9kjBR7Sy8W6LgFlpKtJY2WdqxereVhCyzFfhWPlnarXqzlxOovdpXABbL7gy1QtUvzYoGOXF6ptl6Y1LSf8k5qHmedV/s0osJnC68pvB2gtxL+sDWTartIVHh7S4cLfyjCotpbAhfI3tKLBTqu/mm2oXi0tAnFo6UtqFdreVjF2ewq8WiZz9ayfWjZY/hByz/uqMDd0emv1u1j+13//OnbHTW4Ozr9JWeUePvBfN6dcbujgXZH/fHaNC23J3JaWpncUbtNbe2Te3FZvl35bO/XyWp8uvf1z25PKT1ohLle0YR4+8qE3LbDvHwzrjv/whLKD7fzxzXSCdfIJ1yjfHGN/HGN8fkaf4xanXcvz9KrKvHjORnr6qwVbzu4Wp58OLR+K3b7EicfXm5/OXz+gq5+uJdw/cu9lE+3Udae1z3m26fjCJNPx3irG2JMY6JTzB9CxcsMeft4DysfL/1WGX0SNYS1GFu4Ph9a/4hwXJVsVpJEyfXn/BPvvd52R/fYJ/f+DTFzc/raD3e/Mr3HcpvfY0vblX/Jy/VrUn7Y/nR9GgznZS0vY3FeVvMSnJfVvETnZTUvyXlZzUt2XlbzUpyX1bxU52U1L815Wc2L6931vLjeXctLW1zvrufF9e56XlzvrufF9e56XrLzspoX17vreXG9u54X17vreXG9u54X17ureQmud9fz4np3PS+ud9fz4np3PS/ZeVnNi+vd9by43l3Pi+vd9by43l3Pi+vd1bxE17vreXG9u54Xonq3Ltftmrl+2rB3C5WohJ2FmnVCJSo0Z6ES1Y61lFuobSVUonJwFipRhTcLlahom4SaiOqwWahEpdVkBk461VLSqZZS1gmVqVqaTEs61VLSqZaSTrWUdKqlrFMtZaZqaRIqU7U0CZWpWpqEmnVC1fGWMlO1NAmVqVqahMpULU1C1amWik61VHSqpaJTLRWdaqnoVEtFx1sqOt5S0fGWio63VJiqpe3CsDJVS5NQdVbiqs5KXNWplqpOtVR1qqWqUy1VnWqp6lRLVcdbajreUtPxlpqOt9R09i01pmppEqrOSlzTWYlrOtVS06mWmk611HWqpa5TLXWdaqnreEtdx1vqOt5S1/GWus6+JaZTHGah6qzEMZ21MAtVp1piOhFhFqpOtcR0bsEsVJ1qiel0gVmoOt4S0xkAs1BlvKXOROqfhSqzb6kz8fRnocqsxPUl64QqUy11Jjb9LFSZaqkzEeRnoepUS0yc91moMt5SZ6Kxz0KV8ZY6EzN9FqrMvqXORDafhSqzEteZ+OOzUHWqJSZK+CxUnWqJiuU9CVWnWqJieU9C1fGWdFjeXYfl3XVY3p2K5b1dGFKxvCeh6qzE6bC8OxXLe3taomJ5T0LVqZZ0WN5dh+XddVjeXYfl3XVY3l2H5d11WN6diuW9XRhSsbwnoeqsxOmwvDsVy3syLelUSzos767D8u46LO+uw/LuOizvrsPy7jos767D8u5ULO/twpCK5T0JVWclTofl3alY3tvTEhXLexKqTrWkw/LuOizvrsPy7jos767D8u46LO+uw/LuVCzv7cKQiuU9CVVnJU6H5d2pWN6TaUmnWtJheXcdlnfXYXl3HZZ312F5dx2Wd9dheXcdlnenYnlvF4ZULO9JqDorcTos707F8t6elqhY3pNQdaolHZZ312F5dx2Wd9dheXcdlnfXYXl3HZZ3p2J5bxaGg4rlPQlVZiVu6LC8BxXLe3NaGkvWCVWmWho6LO+hw/IeOizvocPyHjos76HD8h46LO9BxfLeLgypWN6TUGVW4oYOy3tQsbwn05JOtaTD8h46LO+hw/IeOizvocPyHjos76HD8h46LO9BxfLeLgypWN6TUHVW4nRY3oOK5b09LVGxvCeh6lRLOizvocPyHjos76HD8h46LO+hw/IeOizvQcXy3i4MqVjek1B1VuJ0WN6DiuU9mZZ0qiUdlvfQYXkPHZb30GF5Dx2W99BheQ8dlvfQYXkPKpb3dmFIxfKehKqzEqfD8h5ULO/taYmK5T0JVada0mF5Dx2W99BheQ8dlvfQYXkPHZb30GF5DyqW93ZhSMXynoSqsxKnw/IeVCzv7WmJiuU9CVWnWtJheQ8dlvfQYXkPHZb30GF5Dx2W99BheQ8qlvd2YUjF8p6EqrMSp8PyHlQs78m0pFMt6bC8hw7Le+iwvIcOy3vosLyHDst76LC8hw7Le1CxvLcLQyqW9yRUlZW4uMiwvC+hqlRLl1BVqqVLqCrV0iXUrBOqSrV0CVWlWrqEquItXUJV8ZYuoap4S3GRYXlfQlXZt3QJVWXf0iVUlZW4S6hZJ1SdaomK5T0JVadakmF5X0LVqZZkWN6XUHW8JRmW9yVUHW9JhuV9CVVl39IlVJV9S5dQVVbiLqGqrMRdQtWplqhY3pNQdaolGZb3JVSdakmG5X0JVcdbkmF5X0LV8ZZkWN6XUHX2LVGxvCeh6qzEybC8L6HqVEtULO9JqDrVkgzL+xKqTrUkw/K+hKrjLcmwvC+h6nhLMizvS6g6+5aoWN6TUHVW4mRY3pdQdaolKpb3JFSdakmG5X0JVadakmF5X0LV8ZZkWN6XUHW8JRmW9yVUnX1LVCzvSag6K3EyLO9LRDrVEhXLexKqTrUkw/K+RKRTLcmwvC8R6XhLMizvS0Q63pIMy/sSqs6+JSqW9yRUnZU4GZb3JVSdaomK5T0JVadakmF5X0LVqZZkWN6XUHW8JRmW9yVUHW9JhuV9CVVn3xIVy3sSqs5KnAzL+xKqTLUUqFjek1BlqqWgw/IOOizvsGSdUGW8paDD8g46LO+gw/IOVCzvzcIwULG8J6HKrMQFHZZ3oGJ5b09LVCzvSag61ZIOyzvosLyDDss76LC8gw7LO+iwvIMOyztQsby3C0MqlvckVJmVuEDF8p78VmVW4oIOyztQsby3Q9VheQcqlvdEVR1viYrlPQk164Sq4y3psLyDDss76LC8AxXLeztUKpb3JFQdb4mK5T0Jlahaav364ct/pvtQM3SobRnXv9zimIQay/Wmc2w/hHr/4ZKX+v3DJcd8nxfs0up1ecGuw16XF+yi7XV5wa7wXpcX7HLwZXkBJ5u/Li/Yhebr8oJdlb4uL9gl7Ovykp2X1by43l3Pi+vd9by43l3Pi+vd9by43l3NCzib/nV5cb27nhfXu+t5cb27npfsvKzmxfXuel5c767nxfXuel5c767nxfXual7ATxd4XV5c767nxfXuel5c767nJTsvq3lxvbueF9e763lxvbueF6J6d7K7HPwUhyNDBT/F4dBQiQrNWahEteNkxyr4KQ6Hhpp1QiUq2mahEtVhs1CJSqvZDKxTLYGf4nBkqOCnOBwaKlO1tD0tgZ/icGioOtUS+CkOh4aqUy2Bn+JwaKhM1dIkVKZqaRIqU7W0GWoEP8Xh0FBlvKUIforDoaEyVUuTULNOqDLVUgQ/xeHQUGWqpQh+isOhoepUS+CnOBwaqoy3FMFPcTg0VBlvKYKf4nBoqEzV0nZhCH6Kw6GhyqzERfBTHA4NVadaAj/F4dBQdaol8FMcDg1Vp1oCP8Xh0FB1vCXwUxwODVXHWwI/xeHQUGX2LUXwUxwODVVnJQ78FIdDQ9WplsBPcTg0VJ1qCfwUh0ND1amWwE9xODRUHW8J/BSHQ0PV8ZbAT3E4NFSdfUtMpzjMQtVZiWM6a2EWqk61xHQiwixUnWqJ6dyCWag61RLT6QKzUHW8JaYzAGah6nhLTKT+Wag6+5aYePqzUHVW4pio97NQdaolJjb9LFSdaomJID8LVadaYuK8z0LV8ZaYaOyzUHW8JSZm+ixUnX1LTGTzWag6K3FM/PFZqDrVEhMlfBaqTrVExfKehKpTLVGxvCeh6nhLOizvqMPyjjos70jF8t4uDKlY3pNQdVbidFjekYrlvT0tUbG8J6HqVEs6LO+ow/KOOizvqMPyjjos76jD8o46LO9IxfLeLAwTFct7EqrMSlzSYXknKpb35rSUlqwTqky1lHRY3kmH5Z10WN5Jh+WddFjeSYflnXRY3omK5b1dGFKxvCehyqzEJR2Wd6JieU+mJZ1qSYflnXRY3kmH5Z10WN5Jh+WddFjeSYflnXRY3omK5b1dGFKxvCeh6qzE6bC8ExXLe3taomJ5T0LVqZZ0WN5Jh+WddFjeSYflnXRY3kmH5Z10WN6JiuW9XRhSsbwnoeqsxOmwvBMVy3syLelUSzos76TD8k46LO+kw/JOOizvpMPyTjos76TD8k5ULO/twpCK5T0JVWclToflnahY3tvTEhXLexKqTrWkw/JOOizvpMPyTjos76TD8k46LO+kw/JOVCzv7cKQiuU9CVVnJU6H5Z2oWN7b0xIVy3sSqk61pMPyTjos76TD8k46LO+kw/JOOizvpMPyTlQs7+3CkIrlPQlVZyVOh+WdqFjek2lJp1rSYXknHZZ30mF5Jx2Wd9JheScdlnfSYXknHZZ3omJ5bxeGVCzvSagyK3FZh+WdqVjem9NSpmJ5T0KVqZbyknVClamWsg7LO+uwvLMOyzvrsLyzDss7U7G8twtDKpb3JFSZlbisw/LOVCzvybSkUy3psLyzDss767C8sw7LO+uwvLMOyzvrsLyzDss7U7G8twtDKpb3JFSZlbisw/LOVCzv7WmJiuU9CVWnWtJheWcdlnfWYXlnHZZ31mF5Zx2Wd9ZheWcqlvd2YUjF8p6EqrMSp8PyzlQs7+1piYrlPQlVp1rSYXlnHZZ31mF5Zx2Wd9ZheWcdlnfWYXlnKpb3dmFIxfKehKqzEqfD8s5ULO/JtKRTLemwvLMOyzvrsLyzDss767C8sw7LO+uwvLMOyztTsby3C0MqlvckVJ2VOB2Wd6ZieW9PS1Qs70moOtWSDss767C8sw7LO+uwvLMOyzvrsLyzDss7U7G8twtDKpb3JFSdlTgdlnemYnlPpiWdakmH5Z11WN5Zh+WddVjeWYflnXVY3lmH5Z11WN6ZiuW9XRhSsbwnoeqsxOmwvDMVy3tzWipULO9JqDLVUtFheRcdlndZsk6oMt5S0WF5Fx2Wd9FheRcqlvdmYVioWN6TUGVW4ooOy7tQsby3pyUqlvckVJ1qSYflXXRY3kWH5V10WN5Fh+VddFjeRYflXahY3tuFIRXLexKqzEpc0WF5FyqW92Ra0qmWdFjeRYflXXRY3kWH5V10WN5Fh+VddFjeRYflXahY3tuFIRXLexKqzkqcDsu7ULG8t6clKpb3JFSdakmH5V10WN5Fh+VddFjeRYflXXRY3kWH5V2oWN7bhSEVy3sSqs5KnA7Lu1CxvCfTkk61pMPyLjos76LD8i46LO+iw/IuOizvosPyLjos70LF8t4uDKlY3pNQdVbidFjehYrlvT0tUbG8J6HqVEs6LO+iw/IuOizvosPyLjos76LD8i46LO9CxfLeLgypWN6TUHVW4qhY3tu/VR2Wd9FheRcqlvckVJ1qiYrlPVFVx1uiYnlvh0rF8p6EquMt6bC8iw7Lu+iwvAsVy3sSqk61RMXynoSq4y0xsbxbD9dQW08/h1rRWd71FmpfwiTUiyl4DTW2H0K9/3DJS/3+4ZJjvs8LeGn1sryA12Evywt40fayvGTnZTUv4OXgy/ICXju+LC/ghebL8gJelb4sL+Al7Kvygk5jf1leXO+u58X17npeXO+u5yU7L6t5cb27nhfXu+t5cb27nhfXu+t5cb27mhd0nv7L8uJ6dz0vrnfX8+J6dz0v2XlZzYvr3fW8uN5dz4vr3fW8uN5dz4vr3dW8oJ+I8LK8uN5dz4vr3fW8uN5dz0vmycv27vKKforDkaESVaWzUIkKzVmoRLXj9o7Vin6Kw4Ghop/icGSoREXbLFSiOmwWKlFpNZmB0U9xODJUnWoJ/RSHI0NlqpYm05JOtYR+isOBoaKf4nBkqDrVEvopDkeGylQtTULNOqEyVUuTUJmqpUmoOt4S+ikOR4bKVC1th4p+isORoepUS+inOBwZqk61hH6Kw5Gh6lRL6Kc4HBmqjreEforDkaHqeEvopzgcGSpTtbRdGKKf4nBkqDorceinOBwZqk61hH6Kw5Gh6lRL6Kc4HBmqTrWEforDkaHqeEvopzgcGaqOt4R+isORoersW0I/xeHIUHVW4tBPcTgyVJ1qCf0UhyND1amW0E9xODJUnWoJ/RSHI0PV8ZbQT3E4MlQdbwn9FIcjQ5XZt9SYTnGYhSqzEteYzlqYhSpTLbUl64QqUy01pnMLZqHKVEuN6XSBWagy3lJjOgNgFqqMt9SYSP2zUGX2LTUmnv4sVJmVuMZEvZ+FqlMtMbHpZ6HqVEtMBPlZqDrVEhPnfRaqjrfERGOfharjLTEx02ehyuxbakxk81moOitxTPzxWag61RITJXwWqk61RMXynoSqUy1Rsbwnoep4Szos76bD8m46LO9GxfLeLgypWN6TUHVW4nRY3o2K5T2ZlnSqJR2Wd9NheTcdlnfTYXk3HZZ302F5Nx2Wd9NheTcqlvd2YUjF8p6EqrMSp8PyblQs7+1piYrlPQlVp1rSYXk3HZZ302F5Nx2Wd9NheTcdlnfTYXk3Kpb3dmFIxfKehKqzEqfD8m5ULO/taYmK5T0JVada0mF5Nx2Wd9NheTcdlnfTYXk3HZZ302F5NyqW93ZhSMXynoSqsxKnw/JuVCzvybSkUy3psLybDsu76bC8mw7Lu+mwvJsOy7vpsLybDsu7UbG8twtDKpb3JFSZlbiuw/LuVCzvzWmpU7G8J6HKVEt9yTqhylRLXYfl3XVY3l2H5d11WN5dh+XdqVje24UhFct7EqrMSlzXYXl3Kpb3ZFrSqZZ0WN5dh+XddVjeXYfl3XVY3l2H5d11WN5dh+XdqVje24UhFct7EqrMSlzXYXl3Kpb39rRExfKehKpTLemwvLsOy7vrsLy7Dsu767C8uw7Lu+uwvDsVy3u7MKRieU9C1VmJ02F5dyqW9/a0RMXynoSqUy3psLy7Dsu767C8uw7Lu+uwvLsOy7vrsLw7Fct7uzCkYnlPQtVZidNheXcqlvdkWtKplnRY3l2H5d11WN5dh+XddVjeXYfl3XVY3l2H5d2pWN7bhSEVy3sSqs5KnA7Lu1OxvLenJSqW9yRUnWpJh+XddVjeXYfl3XVY3l2H5d11WN5dh+XdqVje24UhFct7EqrOSpwOy7tTsbwn05JOtaTD8u46LO+uw/LuOizvrsPy7jos767D8u46LO9OxfLeLgypWN6TUHVW4nRY3p2K5b05LQ0qlvckVJlqaeiwvIcOy3ssWSdUGW9p6LC8hw7Le+iwvAcVy3uzMBxULO9JqDIrcUOH5T2oWN7b0xIVy3sSqk61pMPyHjos76HD8h46LO+hw/IeOizvocPyHlQs7+3CkIrlPQlVZiVu6LC8BxXLezIt6VRLOizvocPyHjos76HD8h46LO+hw/IeOizvocPyHlQs7+3CkIrlPQlVZyVOh+U9qFje29MSFct7EqpOtaTD8h46LO+hw/IeOizvocPyHjos76HD8h5ULO/twpCK5T0JVWclToflPahY3pNpSada0mF5Dx2W99BheQ8dlvfQYXkPHZb30GF5Dx2W96BieW8XhlQs70moOitxOizvQcXy3p6WqFjek1B1qiUdlvfQYXkPHZb30GF5Dx2W99BheQ8dlvegYnlvF4ZULO9JqDorcTos70HF8t6elqhY3pNQdaolHZb30GF5Dx2W99BheQ8dlvfQYXkPHZb3oGJ5bxeGVCzvSag6K3E6LO9BxfKeTEs61ZIMyzstMizvS6gq1dIlVJVq6RKqird0CTXrhKriLV1CVfGWLqGq7Fu6hKqyb+kSqspKXFpkWN6XUHWqJSqW9yRUnWpJhuV9CVWnWpJheV9CVfGWLqGqeEuXUHW8JRmW9yVUlX1Ll1BV9i1dQlVZibuEmnVC1amWqFjek1B1qiUZlvclVJ1qSYblfQlVx1uSYXlfQtXxlmRY3pdQVfYtXUJV2bd0CVVnJY6K5T35reqsxMmwvC+h6nhLMizvS6g63hIVy3sSqk61RMXynoSq4y3JsLwvoep4SzIs70uoOt4SFct7EqqOt0TF8p6ESlQttR6uobae7kPFrpZ6+gi19EmosVxvOsf2Q6j3Hy55qd8/XHLM93nBLq1elxfsOux1ecEu2l6WF3D++Ovygl0Ovi4v2LXj6/KCXWi+Li/ZeVnNC3YJ+7q8uN5dz4vr3fW8uN5dz4vr3dW8gBPkX5cX17vreXG9u54X17vrecnOy2peXO+u58X17npeXO+u58X17npeXO+u5gX8DIDX5cX17npeXO+u58X17npesvOymhfXu+t5cb27nhfXu+t5cb27nhfXu6t5AT/F4ZfyMtldDn6Kw6GhElWls1CJCs1ZqJko1O0dq+CnOBwaKlGFNwuVqGibhUpUh81CJSqttmfgAH6Kw6GhylRLAfwUh0NDZaqWNqelsGSdUGWqpQB+isOhocpUSwH8FIdDQ2WqlrZDBT/F4dBQmaqlSahM1dIkVBlvKYCf4nBoqEzV0iRUpmppEqpOtQR+isOhoepUS+CnOBwaqk61BH6Kw6Gh6nhL4Kc4HBqqjrcEforDoaEyVUvbhSH4KQ6HhqqzEgd+isOhoepUS+CnOBwaqk61BH6Kw6Gh6lRL4Kc4HBqqjrcEforDoaHqeEvgpzgcGqrOviXwUxwODVVnJQ78FIdDQ9WplsBPcTg0VJ1qCfwUh0ND1amWwE9xODRUHW8J/BSHQ0PV8ZbAT3E4NFSdfUtMpzjMQtVZiWM6a2EWqk61xHQiwixUnWqJ6dyCWag61RLT6QKzUHW8JaYzAGah6nhLTKT+Wag6+5aYePqzUHVW4pio97NQdaolJjb9LFSdaomJID8LVadaYuK8z0LV8ZaYaOyzUHW8JSZm+ixUnX1LTGTzWag6K3FM/PFZqDrVEhMlfBaqTrVExfKehKpTLVGxvCeh6nhLOizvoMPyDjos70DF8t4uDKlY3pNQZVbiog7LO1KxvDenpUjF8p6EKlMtxSXrhCpTLUUdlnfUYXlHHZZ31GF5Rx2Wd6RieW8XhlQs70moMitxUYflHalY3pNpSada0mF5Rx2Wd9RheUcdlnfUYXlHHZZ31GF5Rx2Wd6RieW8XhlQs70moMitxUYflHalY3tvTEhXLexKqTrWkw/KOOizvqMPyjjos76jD8o46LO+ow/KOVCzv7cKQiuU9CVVnJU6H5R2pWN7b0xIVy3sSqk61pMPyjjos76jD8o46LO+ow/KOOizvqMPyjlQs7+3CkIrlPQlVZyVOh+UdqVjek2lJp1rSYXlHHZZ31GF5Rx2Wd9RheUcdlnfUYXlHHZZ3pGJ5bxeGVCzvSag6K3E6LO9IxfLenpaoWN6TUHWqJR2Wd9RheUcdlnfUYXlHHZZ31GF5Rx2Wd6RieW8XhlQs70moOitxOizvSMXynkxLOtWSDss76rC8ow7LO+qwvKMOyzvqsLyjDss76rC8IxXLe7swpGJ5T0LVWYnTYXlHKpb35rSUqFjek1BlqqWkw/JOOizvtGSdUGW8paTD8k46LO+kw/JOVCzvzcIwUbG8J6HKrMQlHZZ3omJ5b09LVCzvSag61ZIOyzvpsLyTDss76bC8kw7LO+mwvJMOyztRsby3C0MqlvckVJmVuKTD8k5ULO/JtKRTLemwvJMOyzvpsLyTDss76bC8kw7LO+mwvJMOyztRsby3C0MqlvckVJ2VOB2Wd6JieW9PS1Qs70moOtWSDss76bC8kw7LO+mwvJMOyzvpsLyTDss7UbG8twtDKpb3JFSdlTgdlneiYnlPpiWdakmH5Z10WN5Jh+WddFjeSYflnXRY3kmH5Z10WN6JiuW9XRhSsbwnoeqsxOmwvBMVy3t7WqJieU9C1amWdFjeSYflnXRY3kmH5Z10WN5Jh+WddFjeiYrlvV0YUrG8J6HqrMTpsLwTFct7e1qiYnlPQtWplnRY3kmH5Z10WN5Jh+WddFjeSYflnXRY3omK5b1dGFKxvCeh6qzE6bC8ExXLezIt6VRLOizvrMPyzjos76zD8s46LO+8ZJ1QZbylrMPyzlQs783CMFOxvCehyqzEZR2Wd6ZieW9PS1Qs70moOtWSDss767C8sw7LO+uwvLMOyzvrsLyzDss7U7G8twtDKpb3JFSZlbisw/LOVCzvybSkUy3psLyzDss767C8sw7LO+uwvLMOyzvrsLyzDss7U7G8twtDKpb3JFSdlTgdlnemYnlvT0tULO9JqDrVkg7LO+uwvLMOyzvrsLyzDss767C8sw7LO1OxvLcLQyqW9yRUnZU4HZZ3pmJ5b09LVCzvSag61ZIOyzvrsLyzDss767C8sw7LO+uwvLMOyztTsby3C0MqlvckVJ2VOB2Wd6ZieU+mJZ1qSYflnXVY3lmH5Z11WN5Zh+WddVjeWYflnXVY3pmK5b1dGFKxvCeh6qzE6bC8MxXLe3taomJ5T0LVqZZ0WN5Zh+WddVjeWYflnXVY3lmH5Z11WN6ZiuW9XRhSsbwnoeqsxFGxvCe/VZ2VOB2Wd6ZieU9C1amWqFjem6oWKpb3JFSZaqlQsbwnocp4S2XJOqHKeEtFh+VdqFjek1BlqqVCxfLeDpWK5T0Jlahaaj1cQ2093YcKXi2Nev3LI5RJqLFcbzrH9kOo9x8uebn+5ZJjvs8LeGn1srxk52U1L+BF28vyAl7hvSwv4OXgy/ICXju+LC/ghear8oLOTH9ZXsBL2JflxfXuel5c767nJTsvq3lxvbueF9e763lxvbueF9e763lxvbuaF3Tq/cvy4np3PS+ud9fz4np3PS/ZeVnNi+vd9by43l3Pi+vd9by43l3Pi+vd1bygn1vwsry43l3Pi+vd9by43l3PS3ZeVvPienc9L0T17mR3OfopDkeGSlSVzkIlKjQnoaKf4vBLoW7vWEU/xeHIUIkqvFmoREXbLNSsEypRaTWbgXWqJfRTHI4MVadaQj/F4cBpCf0UhyND1amW0E9xODJUnWoJ/RSHI0NlqpYmoTJVS5NQmaqlSahM1dIkVB1vCf0UhyNDZaqWJqEyVUuTUHWqJfRTHI4MVadaQj/F4chQdaol9FMcjgxVx1tCP8XhyFB1vCX0UxyODJWpWtouDNFPcTgyVJ2VOPRTHI4MVadaQj/F4chQdaol9FMcjgxVp1pCP8XhyFB1vCX0UxyODFXHW0I/xeHIUHX2LaGf4nBkqDIrcRX9FIcjQ5Wplir6KQ5HhipTLV2+3jqhylRLFf0UhyNDlfGWKvopDkeGKuMtVfRTHI4MVWbfUmU6xWEWqsxKXGU6a2EWqk61xHQiwixUnWqJ6dyCWag61RLT6QKzUHW8JaYzAGah6nhLTKT+Wagy+5YqE09/FqrMSlxlot7PQtWplpjY9LNQdaolJoL8LFSdaomJ8z4LVcdbYqKxz0LV8ZaYmOmzUHX2LTGRzWeh6qzEMfHHZ6HqVEtMlPBZqDrVEhXLexKqTrVExfKehKrjLemwvKsOy7vqsLwrFct7uzCkYnlPQtVZidNheVcqlvdkWtKplnRY3lWH5V11WN5Vh+VddVjeVYflXXVY3lWH5V2pWN7bhSEVy3sSqs5KnA7Lu1KxvLenJSqW9yRUnWpJh+VddVjeVYflXXVY3lWH5V11WN5Vh+VdqVje24UhFct7EqrOSpwOy7tSsbwn05JOtaTD8q46LO+qw/KuOizvqsPyrjos76rD8q46LO9KxfLeLgypWN6TUHVW4nRY3pWK5b05LTUqlvckVJlqqemwvJsOy7stWSdUGW+p6bC8mw7Lu+mwvBsVy3uzMGxULO9JqDIrcU2H5d2oWN7b0xIVy3sSqk61pMPybjos76bD8m46LO+mw/JuOizvpsPyblQs7+3CkIrlPQlVZiWu6bC8GxXLezIt6VRLOizvpsPybjos76bD8m46LO+mw/JuOizvpsPyblQs7+3CkIrlPQlVZyVOh+XdqFje29MSFct7EqpOtaTD8m46LO+mw/JuOizvpsPybjos76bD8m5ULO/twpCK5T0JVWclTofl3ahY3pNpSada0mF5Nx2Wd9NheTcdlnfTYXk3HZZ302F5Nx2Wd6NieW8XhlQs70moOitxOizvRsXy3p6WqFjek1B1qiUdlnfTYXk3HZZ302F5Nx2Wd9NheTcdlnejYnlvF4ZULO9JqDorcTos70bF8t6elqhY3pNQdaolHZZ302F5Nx2Wd9NheTcdlnfTYXk3HZZ3o2J5bxeGVCzvSag6K3E6LO9GxfKeTEs61ZIOy7vrsLy7Dsu767C8uw7Luy9ZJ1QZb6nrsLw7Fct7szDsVCzvSagyK3Fdh+XdqVje29MSFct7EqpOtaTD8u46LO+uw/LuOizvrsPy7jos767D8u5ULO/twpCK5T0JVWYlruuwvDsVy3syLelUSzos767D8u46LO+uw/LuOizvrsPy7jos767D8u5ULO/twpCK5T0JVWclTofl3alY3tvTEhXLexKqTrWkw/LuOizvrsPy7jos767D8u46LO+uw/LuVCzv7cKQiuU9CVVnJU6H5d2pWN7b0xIVy3sSqk61pMPy7jos767D8u46LO+uw/LuOizvrsPy7lQs7+3CkIrlPQlVZyVOh+XdqVjek2lJp1rSYXl3HZZ312F5dx2Wd9dheXcdlnfXYXl3HZZ3p2J5bxeGVCzvSag6K3E6LO9OxfLenpaoWN6TUHWqJR2Wd9dheXcdlnfXYXl3HZZ312F5dx2Wd6dieW8XhlQs70moOitxOizvTsXynkxLOtWSDsu767C8uw7Le+iwvIcOy3vosLyHDst7LFknVJl9S4OK5T0JVWYlbuiwvAcVy3t7WqJieU9C1amWdFjeQ4flPXRY3kOH5T10WN5Dh+U9dFjeg4rlvV0YUrG8J6HKrMQNHZb3oGJ5b09LVCzvSag61ZIOy3vosLyHDst76LC8hw7Le+iwvIcOy3tQsby3C0MqlvckVJ2VOB2W96BieU+mJZ1qSYflPXRY3kOH5T10WN5Dh+U9dFjeQ4flPXRY3oOK5b1dGFKxvCeh6qzEUbG8t3+rOizvocPyHlQs70moWee3quMtUbG8J6HqVEtULO9JqDrekg7Le+iwvIcOy3tQsbwnoWadUHW8JSqW9yRUomqp9XANtfV0Hyp2tXQpXG+h9mUSarx9OMf2Q6j3Hy55uSax5Jjv84JdWr0sL+CU8NflBbtoe11esCu81+UFuxx8XV6y87KaF+xC83V5wa5KX5cX7BL2dXlxvbueF9e7q3kB57y/Li+ud9fz4np3PS+ud9fzkp2X1by43l3Pi+vd9by43l3Pi+vd9by43l3NCzip/3V5cb27nhfXu+t5cb27npfsvKzmxfXuel5c767nxfXuel5c767nxfXuSl4uAbneXc+L6931vBDVu5u7yy/3SFTCzkLNOqESFZqzUIlqx80dq5d7JCoHZ6ESVXizUImKtkmo4Kc4HBoqUWk1mYHBT3E4NFSdagn8FIdDQ2WqlibTkk61BH6Kw6Gh6lRL4Kc4HBkq+CkOh4bKVC1NQmWqliahMlVLk1CzTqg63hL4KQ6HhspULU1CZaqWJqHqVEvgpzgcGqpOtQR+isOhoepUS+CnOBwaqo63BH6Kw6Gh6nhL4Kc4HBoqU7W0XRiCn+JwaKg6K3HgpzgcGqpOtQR+isOhoepUS+CnOBwaqk61BH6Kw6Gh6nhL4Kc4HBqqjrcEforDoaHq7FsCP8Xh0FB1VuLAT3E4NFSdagn8FIdDQ9WplsBPcTg0VJ1qCfwUh0ND1fGWwE9xODRUHW8J/BSHQ0PV2bfEdIrDLFSdlTimsxZmoepUS0wnIsxC1amWmM4tmIWqUy0xnS4wC1XHW2I6A2AWqo63xETqn4Wqs2+Jiac/C1VnJY6Jej8LVadaYmLTz0LVqZaYCPKzUHWqJSbO+yxUHW+JicY+C1XHW2Jips9C1dm3xEQ2n4WqsxLHxB+fhSpTLQUmSvgsVJlqKVCxvCehylRLYck6ocp4S0GH5R10WN5Bh+UdqFjem4VhoGJ5T0KVWYkLOizvQMXy3p6WqFjek1B1qiUdlnfQYXkHHZZ30GF5Bx2Wd9BheQcdlnegYnlvF4ZULO9JqDIrcUGH5R2oWN6TaUmnWtJheQcdlnfQYXkHHZZ30GF5Bx2Wd9BheQcdlnegYnlvF4ZULO9JqDorcTos70DF8t6elqhY3pNQdaolHZZ30GF5Bx2Wd9BheQcdlnfQYXkHHZZ3oGJ5bxeGVCzvSag6K3E6LO9AxfKeTEs61ZIOyzvosLyDDss76LC8gw7LO+iwvIMOyzvosLwDFct7uzCkYnlPQtVZidNheQcqlvf2tETF8p6EqlMt6bC8gw7LO+iwvIMOyzvosLyDDss76LC8AxXLe7swpGJ5T0LVWYnTYXkHKpb39rRExfKehKpTLemwvIMOyzvosLyDDss76LC8gw7LO+iwvAMVy3u7MKRieU9C1VmJ02F5ByqW92Ra0qmWdFjeUYflHXVY3lGH5R11WN5xyTqhynhLUYflHalY3puFYaRieU9ClVmJizos70jF8t6elqhY3pNQdaolHZZ31GF5Rx2Wd9RheUcdlnfUYXlHHZZ3pGJ5bxeGVCzvSagyK3FRh+UdqVjek2lJp1rSYXlHHZZ31GF5Rx2Wd9RheUcdlnfUYXlHHZZ3pGJ5bxeGVCzvSag6K3E6LO9IxfLenpaoWN6TUHWqJR2Wd9RheUcdlnfUYXlHHZZ31GF5Rx2Wd6RieW8XhlQs70moOitxOizvSMXy3p6WqFjek1B1qiUdlnfUYXlHHZZ31GF5Rx2Wd9RheUcdlnekYnlvF4ZULO9JqDorcTos70jF8p5MSzrVkg7LO+qwvKMOyzvqsLyjDss76rC8ow7LO+qwvCMVy3u7MKRieU9C1VmJ02F5RyqW9/a0RMXynoSqUy3psLyjDss76rC8ow7LO+qwvKMOyzvqsLwjFct7uzCkYnlPQtVZidNheUcqlvdkWtKplnRY3lGH5R11WN5Jh+WddFjeSYflnXRY3mnJOqHK7FtKVCzvSagyK3FJh+WdqFje29MSFct7EqpOtaTD8k46LO+kw/JOOizvpMPyTjos76TD8k5ULO/twpCK5T0JVWYlLumwvBMVy3t7WqJieU9C1amWdFjeSYflnXRY3kmH5Z10WN5Jh+WddFjeiYrlvV0YUrG8J6HqrMTpsLwTFct7Mi3pVEs6LO+kw/JOOizvpMPyTjos76TD8k46LO+kw/JOVCzv7cKQiuU9CVVnJU6H5Z2oWN7b0xIVy3sSqk61pMPyTjos76TD8k46LO+kw/JOOizvpMPyTlQs7+3CkIrlPQlVZyVOh+WdqFjek2lJp1rSYXknHZZ30mF5Jx2Wd9JheScdlnfSYXknHZZ3omJ5bxeGVCzvSag6K3E6LO9ExfLenpaoWN6TUHWqJR2Wd9JheScdlnfSYXknHZZ30mF5Jx2Wd6JieW8XhlQs70moOitxOizvRMXy3p6WqFjek1B1qiUdlnfSYXknHZZ30mF5Zx2Wd9ZheWcdlnemYnlvFoZ5yTqhyqzEZSqW9+S3KrMSl3VY3pmK5b0dqg7LO1OxvCeqynhLmYrlPQk164Qq4y1lHZZ31mF5Zx2Wd6ZieW+HSsXynoSq4y1RsbwnoRJVS62Ha6itp/tQM3KocYnXu49LTpNQ4y0vObYfQr3/cLn4L98/XC5JuM8LdGn1wrxA12EvzAt00fbCvEBXeC/MC3Q5+Lq8YJPNX5gX6ELzhXmBrkpfmBfoEvaFecnOy2peXO+u58X17npeXO+u58X17npeXO+u5gWbTf/CvLjeXc+L6931vLjeXc9Ldl5W8+J6dz0vrnfX8+J6dz0vrnfX8+J6dzUv2KcLvDAvrnfX8+J6dz0vrnfX85Kdl9W8uN5dz4vr3fW8uN5dzwtRvTvZXY59isOhoWKf4nBsqESF5ixUotpxsmMV+xSHY0PNOqESFW2zUInqsFmoRKXVbAbWqZawT3E4NFTsUxyODZWpWtqelrBPcTg2VJ1qCfsUh2ND1amWsE9xODZUpmppEipTtTQJlala2g4V+xSHY0PV8ZawT3E4NlSmamkSatYJVadawj7F4dhQdaol7FMcjg1Vp1rCPsXh2FB1vCXsUxyODVXHW8I+xeHYUJmqpe3CEPsUh2ND1VmJwz7F4dhQZaqlgn2Kw7GhylRLBfsUh2NDlamWypJ1QpXxlgr2KQ7HhirjLRXsUxyODVVm31LBPsXh2FBlVuIK9ikOx4aqUy1hn+JwbKg61RL2KQ7HhqpTLWGf4nBsqDreEvYpDseGquMtYZ/icGyoMvuWCtMpDrNQZVbiCtNZC7NQdaolphMRZqHqVEtM5xbMQtWplphOF5iFquMtMZ0BMAtVx1tiIvXPQpXZt1SYePqzUHVW4pio97NQdaolJjb9LFSdaomJID8LVadaYuK8z0LV8ZaYaOyzUHW8JSZm+ixUnX1LTGTzWag6K3FM/PFZqDrVEhMlfBaqTrVExfKehKpTLVGxvCeh6nhLOizvosPyLjos70LF8t4uDKlY3pNQdVbidFjehYrlvT0tUbG8J6HqVEs6LO+iw/IuOizvosPyLjos76LD8i46LO9CxfLeLgypWN6TUHVW4nRY3oWK5b09LVGxvCeh6lRLOizvosPyLjos76LD8i46LO+iw/IuOizvQsXy3i4MqVjek1B1VuJ0WN6FiuU9mZZ0qiUdlnfVYXlXHZZ31WF5Vx2W9+VRpBOqjLdUdVjelYrlvVkYViqW9yRUmZW4qsPyrlQs7+1piYrlPQlVp1rSYXlXHZZ31WF5Vx2Wd9VheVcdlnfVYXlXKpb3dmFIxfKehCqzEld1WN6ViuU9mZZ0qiUdlnfVYXlXHZZ31WF5Vx2Wd9VheVcdlnfVYXlXKpb3dmFIxfKehKqzEqfD8q5ULO/taYmK5T0JVada0mF5Vx2Wd9VheVcdlnfVYXlXHZZ31WF5VyqW93ZhSMXynoSqsxKnw/KuVCzv7WmJiuU9CVWnWtJheVcdlnfVYXlXHZZ31WF5Vx2Wd9VheVcqlvd2YUjF8p6EqrMSp8PyrlQs78m0pFMt6bC8qw7Lu+qwvKsOy7vqsLyrDsu76rC8qw7Lu1KxvLcLQyqW9yRUnZU4HZZ3pWJ5b09LVCzvSag61ZIOy7vqsLyrDsu76rC8qw7Lu+qwvKsOy7tSsby3C0MqlvckVJ2VOB2Wd6VieU+mJZ1qSYflXXVY3lWH5d10WN5Nh+XddFjeTYfl3ZasE6rMvqVGxfKehCqzEtd0WN6NiuW9PS1RsbwnoepUSzos76bD8m46LO+mw/JuOizvpsPybjos70bF8t4uDKlY3pNQZVbimg7Lu1GxvLenJSqW9yRUnWpJh+XddFjeTYfl3XRY3k2H5d10WN5Nh+XdqFje24UhFct7EqrOSpwOy7tRsbwn05JOtaTD8m46LO+mw/JuOizvpsPybjos76bD8m46LO9GxfLeLgypWN6TUHVW4nRY3o2K5b09LVGxvCeh6lRLOizvpsPybjos76bD8m46LO+mw/JuOizvRsXy3i4MqVjek1B1VuJ0WN6NiuU9mZZ0qiUdlnfTYXk3HZZ302F5Nx2Wd9NheTcdlnfTYXk3Kpb3dmFIxfKehKqzEqfD8m5ULO/taYmK5T0JVada0mF5Nx2Wd9NheTcdlnfTYXk3HZZ302F5NyqW93ZhSMXynoSqsxKnw/JuVCzv7WmJiuU9CVWnWtJheTcdlnfTYXk3HZZ312F5dx2Wd9dheXcqlvdmYdiXrBOqzEpc12F5dyqW92RakqmWug7Lu+uwvLsOy7vrsLy7Dsu767C8uw7Lu+uwvDsVy3u7MKRieU9ClVmJ6zos707F8t6elqhY3pNQdaolHZZ312F5dx2Wd9dheXcdlnfXYXl3HZZ3p2J5bxeGVCzvSag6K3E6LO9OxfKeTEs61ZIOy7vrsLy7Dsu767C8uw7Lu+uwvLsOy7vrsLw7Fct7uzCkYnlPQtVZidNheXcqlvf2tETF8p6EqlMt6bC8uw7Lu+uwvLsOy7vrsLy7Dsu767C8OxXLe7swpGJ5T0LVWYmjYnlv/1Z1WN5dh+XdqVjek1B1qiUqlvdEVR1viYrlvR0qFct7EqqOt6TD8u46LO+uw/LuVCzvSag61RIVy3sSqo63xMTybv364W/c47tQ11ne4fK8vd58H+02Kra1+6n5lpc64uTDKEnMoV7vI8+SOOq1DBujfsRX+to9f3y3Qq39czb+SHhwws9NeHTCz014csLPTXh2ws9NeHHCz014dcLPTXhzws9NeHfCz034cMJPTfjwm+bJCfeb5skJ95vmyQn3m+bJCc9O+LkJ95vmyQn3m+bJCfeb5skJP+BNc+Trh+MYY/vDY0nXhI+lBquzrc6wOrDqjGU5V52LD3e9+Ythkbc/HHIr17Rc/rt5IpyIGSwmj5jR8yawOsnqAKuTPRHyiFksJo+Y1fMmsDrN6gCrc7LP0dsyrllpqVudbXXscwCrExarA6yOjQsiMaPF5BHTPgeyOtnqAKtj44JIzGoxecS0z4GsjvdzIKsz7ELhqhPtcyCrE6wOsDo2LojETBaTR8zseRNYnWJ1gNWxcUEkZrOYPGLa50BWx/s5gNVJi10oYHXscyCr484SZHVsXBCJmS0mj5j2OZDVcWcJsjo2LojE7BaTR0z7HMDqZO/nQFYn2IUCVsc+B7I67ixBVie7xOMR040oRGLa50BWx50lyOrYuCASc1hMGjGLfQ5kdbyfA1mdaBcKWB37HMjqZKsDrI6NCyIx3YhCJKZ9DmR13FmCrI6NCx4xqw9QIRLTPgeyOt7PgaxOsgsFrE72bwdYHXeWIKtj44JITDeiEIlpnwNZHXeWAKvTbFwQiekDVIjEtM+BrI73cyCrk+1CAatjnwNZHXeWIKtj44JITDeiEIlpnwNYne7OEmR1bFwQiekDVIjEtM+BrE62OsDqFLtQwOrY50BWx50lyOrYuCAS040oPGIO+xzI6rizBFkdGxdEYvoAFSIxs+dNYHW8nwNZnWoXClgd+xzI6rizBFkdGxcsYpZlcSMKkZj2OZDVcWcJsjo2LojEzBaTR0z7HMjqeD8HsjrNLhSwOvY5kNVxZwmwOsHGBZGYbkQhEtM+B7I67ixBVid7IuQR0weoEIlpnwNZHe/nQFan24UCVsc+B7A60Z0lyOrYuCAS040oRGLa50BWJ1sdYHVsXBCJ6QNUiMS0z4GsjvdzIKsz7ELhqpPscyCr484SZHVsXBCJ6UYUIjGz501gddxZgqyOjQsiMX2ACpGY9jmQ1fF+DmB18mIXClgd+xzI6rizBFkdGxdEYmaLySOmfQ5kddxZgqyOjQsiMX2ACpGY9jmA1Snez4GsTrALBayOfQ5kddxZgqxOdonHI6YbUYjEtM+BrI47S5DVsXFBJKYPUOERs9rnQFbH+zmQ1Yl2oYDVsc+BrE62OsDq2LggEtONKERi2udAVsedJcjq2LjgEbP5ABUiMe1zIKvj/RzI6iS7UMDq5IfVSR9ZSTn5UTJJ+AHWRc23HNbhhE8SXp3wcxPenPBzE96d8HMTPpzwUxPeFyf83IQHJ/zchEcn/NyEJyf83IRnJ/zchPtN8+SE+03z5IT7TfPkhPtN8+SE+03z3IQPv2menHC/aZ6ccL9pnpxwb/RGVidbHWB1vNGbSExv9CYS0xu9kdXxRm9kdbzRm0bMsHijN5GY3uiNrI43eiOr443eyOpk/3aA1fERAsjq2LggEtMnDhCJaZ8DWR0fIQCsTrBxQSRmsJg8YtrnQFbH+zmQ1cl2oYDVsc+BrI6PEEBWx8YFkZg+cYBITPscwOpEHyGArI6NCyIxo8XkEdM+B7I62eoAq1PsQgGrY58DWR13liCrY+OCSEw3ovCImexzIKvjzhJkdWxcEImZLCaPmNnzJrA63s+BrE61CwWsjn0OZHXcWYKsjo0LHjGzG1GIxLTPgayOO0uQ1bFxQSRmtpg8YtrnQFbH+zmQ1Wl2oYDVsc+BrI47S4DVKTYuiMR0IwqRmPY5kNVxZwmyOtkTIY+YPkCFSEz7HMjqeD8HsjrdLhSwOvY5gNWp7ixBVsfGBZGYbkQhEtM+B7I62eoAq2PjgkhMH6BCJKZ9DmR1vJ8DWZ1hFwpXnWafA1kdd5Ygq2PjgkhMN6IQiZk9bwKr484SZHVsXBCJ6QNUiMS0z4GsjvdzAKvTF7tQwOrY50BWx50lyOrYuCASM1tMHjHtcyCr484SZHVsXBCJ6QNUiMS0zwGszvB+DmR1gl0oYHXscyCr484SZHWySzweMd2IQiSmfQ5kddxZgqyOjQsiMX2ACo2YcbHPgayO93MgqxPtQgGrY58DWZ1sdYDVsXFBJKYbUYjEtM+BrI47S5DVsXHBI2bwASpEYtrnQFbH+zmQ1Ul2oYDVyf7tAKvjzhJkdWxcEInpRhQiMe1zIKvjzhJgdaKNCyIxfYAKkZj2OZDV8X4OZHWyXShgdexzIKvjzhJkdWxcEInpRhQiMe1zAKuT3FmCrI6NCyIxfYAKkZj2OZDVyVYHWJ1iFwpYHfscyOq4swRZHRsXRGK6EYVHzGyfA1kdd5Ygq2PjgkhMH6BCJGb2vAmsjvdzIKtT7UIBq2OfA1kdd5Ygq2PjgkfM4kYUIjHtcyCr484SZHVsXBCJmS0mj5j2OZDV8X4OZHWaXShgdexzIKvjzhJgdaqNCyIx3YhCJKZ9DmR13FmCrE72RMgjpg9QIRLTPgeyOt7PgaxOtwsFrM7jPkf6yErKyY+S7YS3A6yLmm85rMMJnyQ8OOHnJjw64ecmPDnh5yY8O+HnJrw44ecmvDrh5ya8OeHnJrw74ecmfDjhpya8+03z5IT7TfPkhPtN8+SE+03z5IRnJ/zchPtN8+SE+03z5IT7TfPkhHujN7I63ugNrM7wRm8iMb3Rm0hMb/RGVscbvZHVyZ4IecT0Rm8iMb3RG1kdb/RGVscbvZHVsc+Bq05afIQAsjo2LojE9IkDRGLa50BWJ1sdYHVsXBCJWS0mj5j2OZDV8X4OZHWGXShcdYJ9DmR1fIQAsjo2LojE9IkDRGJmz5vA6vgIAWR1bFwQidksJo+Y9jmQ1fF+DmB14mIXClgd+xzI6rizBFkdGxdEYmaLySOmfQ5kddxZgqyOjQsiMbvF5BHTPgewOsn7OZDVCXahgNWxz4GsjjtLkNXJLvF4xHQjCpGY9jmQ1XFnCbI6Ni6IxBwWk0bMbJ8DWR3v50BWJ9qFAlbHPgeyOtnqAKtj44JITDeiEIlpnwNZHXeWIKtj44JHzOIDVIjEtM+BrI73cyCrk+xCAauT/dsBVsedJcjq2LggEtONKERi2udAVsedJcDqVBsXRGL6ABUiMe1zIKvj/RzI6mS7UMDq2OdAVsedJcjq2LggEtONKERi2ucAVqe5swRZHRsXRGL6ABUiMe1zIKuTrQ6wOsUuFLA69jmQ1XFnCbI6Ni6IxHQjCo+Y3T4HsjruLEFWx8YFkZg+QIVIzOx5E1gd7+dAVqfahQJWxz4HsjruLEFWx8YFj5jDjShEYtrnQFbHnSXI6ti4IBIzW0weMe1zIKvj/RzI6jS7UMDq2OdAVsedJbjqXAJyiccjphtRiMS0z4GsjjtLkNXJngh5xPQBKkRi2udAVsf7OZDV6XahgNWxzwGsTnBnCbI6Ni6IxHQjCpGY9jmQ1clWB1gdGxdEYvoAFSIx7XMgq+P9HMjqDLtQuOpE+xzI6rizBFkdGxdEYroRhUjM7HkTWB13liCrY+OCSEwfoEIkpn0OZHW8nwNYnbTYhQJWxz4HsjruLEFWx8YFkZjZYvKIaZ8DWR13liCrY+OCSEwfoEIkpn0OYHWy93MgqxPsQgGrY58DWR13liCrk13i8YjpRhQiMe1zIKvjzhJkdWxcEInpA1R4xCz2OZDV8X4OZHWiXShgdexzIKuTrQ6wOjYuiMR0IwqRmPY5kNVxZwmyOjYueMSsPkCFSEz7HMjqeD8HsjrJLhSwOvlhddJHVlJOfpRMEv64dZF6vX7D0wjZCd9OeHXCz014c8LPTXh3ws9N+HDCT014W5zwcxMenPBzEx6d8HMTnpzwcxOenfBzE/74m2Zeevr+4RzyYlvsQHWq1QFWp52rjldvnilmt5g8Yg7Pm7jq9MXqAKsTPBHyiBktJo+YyfMmsDrZ6gCrc7LP4Q0mv6SOfQ5kdZrVAVbHxgWRmMNi0og57HMgqxOsDrA6Ni6IxEwWk0fM7HkTWB3v50BWp9qFAlbHPgeyOt3qAKtj44JGzLIsFpNHTPscyOpEqwOsjo0LIjGzxeQR0z4Hsjrez4GsTrMLBayOfQ5kddxZAqxOsHFBJKYbUYjEtM+BrI47S5DVyZ4IecQsFpNHTPscyOp4PweyOt0uFLA69jmA1YnuLEFWx8YFkZhuRCES0z4HsjrZ6gCrY+OCSMxqMXnEtM+BrI73cyCrM+xC4aqT7HMgq+POEmR1bFwQielGFCIxs+dNYHXcWYKsjo0LIjF9gAqRmPY5kNXxfg5gdfJiFwpYHfscyOq4swRZHRsXRGJmi8kjpn0OZHXcWYKsjo0LIjF9gAqRmPY5gNUp3s+BrE6wCwWsjn0OZHXcWYKsTnaJxyOmG1GIxLTPgayOO0uQ1bFxQSSmD1DhEbPa50BWx/s5kNWJdqGA1TnA54j5mvAcxyThI5erlKOEOnlMLa1d//Tlv2c3YjGzxeQRs1hMHjGrxeQRs1lMHjG7xeQRc1hMGjHbYjF5xHzco/l2HND3D1/+ni3LScKjE35uwpMTfm7CsxN+bsKLE35uwqsTfm7CmxN+bsK7E35uwocTfmrC++KEn5twv2menPAD3jRr6NeE154m1ku7VKLXP91qmjo1lz95c2rKzAWynMlyMsmZLSeTnOWN5KxLtpzbclZwOb3K8UtyNsvJJGe3nExyDstJJOdYLCeTnOFsOduSb3K2OiYfD+OWmMt/52E5t+WM2HLGJd/uJC7Vck7kTJaTSc5sOZnkLJaTSc5qOZnkbJaTSc5uOZnkHJaTR866nO4KjX7LYV/CYn229QnWB1qfs32bHvKHPqF6t9VEnyOMmHG999LizMbuOYbbn87FNvZEn3y2PqV8/H5Kn+CIcixXfXJsH3kJY+1G8nK7kRzz9oetfLHyospXKy+qfLPyosp3Ky+q/LDymsqHxcqLKh+svKjy0cqLKp+svKjy2cqLKm8PT1V5e3iqytvDU1XeHp6q8vbwRJWP9vBUlbeHp6q8PTxV5e3hqSqfrbyo8vbwVJW3h6eqvD08VeXt4akqbw9PVPlkD09VeXt4qsrbw1NV3h6eqvLZyosqbw9PVXl7eKrK28NTVd4enqry9vBElc/28FSVt4enqrw9PFXl7eGpKp+tvKjy9vBUlbeHp6q8PTxV5e3hqSpvD09U+WIPT1V5e3iqyq96eM9MS1jS7QCCsMQfEvPHLaXTbynE2xc99DzRquXrjbTPCb389x+3n9/79st7335979tv7337/b1vf7z17dflvW8/vPftx/e+/fd+6tb3furW937q1vd+6tb3furW937q1vd+6rb3fuq2937qtvd+6rb3fuq2937qtvd+6rb3fuq2937qtvd+6rb3fur2937q9vd+6vb3fur2937q9vd+6vb3fur2937q9vd+6vb3fur2937qjvd+6o73fuqO937qjvd+6o7Vp24q13X7HJdPg1b+fmzxtsbf8uTDofV0vfX+aZV8/cPL7S+HpZXJbcAkfNR2u+sl/JDx+w/ni1F4zXQZn2Jc3fbQY76mr8cRfvj0H2oWq0mkZrWaRGo2q0mkZreaRGoOq0mjZlsWq0mkZrCaRGpGq0mkZrKaRGpmq0mkpr0gJjXtBTGpaS+ISU17QUxq2gsiUjPYC2JS014Qk5r2gpjUtBfEpGa2mkRq2gtiUtNeEJOa9oKY1LQXxKSmvSAiNaO9ICY17QUxqWkviElNe0FMamarSaSmvSAmNe0FMalpL4hJTXtBTGraCyJSM9kLYlLTXhCTmvaCmNS0F8SkZraaRGraC2JS014Qk5r2gpjUtBfEpKa9ICI1s70gJjXtBTGpaS+ISU17QUxqZqtJpKa9ICY17QUxqWkviElNe0FMatoLIlKz2AtiUtNeEJOa9oKY1LQXxKRmtppEatoLYlLTXhCTmvaCmNS0F8Skpr0gIjWrvSAmNe0FMalpL4hJTXtBTGpmq0mkpr0gJjXtBTGpaS+ISU17QUxq2gsiUrPZC2JS014Qk5r2gpjUtBfEpGa2mkRq2gtiUtNeEJOa9oKY1LQXxKSmvSAiNbu9ICY17QUxqWkviElNe0FMamarSaSmvSAmNe0FMalpL4hJTXtBTGraCyJSc9gLYlLTXhCTmvaCmNS0F8SkZraaRGraC2JS014Qk5r2gpjUtBfEpKa9IB41+2IviElNe0FMatoLYlLTXhCTmtlqEqlpL4hJTXtBTGraC2JS014Qk5r2gojUDPaCmNS0F8Skpr0gJjXtBTGpma0mkZr2gpjUtBfEpKa9ICY17QUxqWkviEjNaC+ISU17QUxq2gtiUtNeEJOa2WoSqWkviElNe0FMatoLYlLTXhCTmvaCiNRM9oKY1LQXxKSmvSAmNe0FMamZrSaRmvaCmNS0F8Skpr0gJjXtBTGpaS+ISM1sL4hJTXtBTGraC2JS014Qk5rZahKpaS+ISU17QUxq2gtiUtNeEJOa9oKI1Cz2gpjUtBfEpKa9ICY17QUxqZmtJpGa9oKY1LQXxKSmvSAmNe0FMalpL4hIzWoviElNe0FMatoLYlLTXhCTmtlqEqlpL4hJTXtBTGraC2JS014Qk5r2gojUbPaCmNS0F8Skpr0gJjXtBTGpma0mkZr2gpjUtBfEpKa9ICY17QUxqWkviEjNbi+ISU17QUxq2gtiUtNeEJOa2WoSqWkviElNe0FMatoLYlLTXhCTmvaCiNQc9oKY1LQXxKSmvSAmNe0FMamZrSaRmvaCmNS0F8Skpr0gJjXtBTGpaS+IR82x2AtiUtNeEJOa9oKY1LQXxKRmtppEatoLYlLTXhCTmvaCmNS0F8Sk5qoX9NzcjFu4MfQfcvP7LQUSQ6OXcMt9KcsDSp385Y3l9um01MmXN9Y4bsn+JOdI39UkMTSs5u9qkhgaVvN3NdMBk39rt7TH9umBtHr/Nd6irTG07Q9frt7z7U5ySJ8//kcA+d0DWH1tjfn2iIyl9e0AWorXD7eUP+6orX04lXD9RqQy4udvxEpqav74ttVc8+SLf9TP9Y/M1AMyUz4y0+N2Zkq/6Ro+7ubyI/t+O+2A2xnXorDlNBEqXL7btzLpkoz88Detv3sA4+wAWr19+8fI4Yc7uvzjn//tz3/5y5//zz/+5W//8k//8ee//fXfvw1evv2fsD4v1aVef3x1aZ8eOu1bhGF9LpgNqnsGtT2D+p5BY8eguOwZFPYMinsGpT2D9nwj4p5vRNzzjYh7vhFxzzci7vlGpD3fiLTnG5H2fCPSnm9E2vONSOvfiNDLrShZ2t2gumdQ2zOo7xk0dgzKy3RQjHeD1rMXU70Nqncpz+sxlXAbVPL9oLFj0Pop4LNBYc+g9Zg+6rfal3I3aOwYtH6a1WxQ2DMo7hm0/svtId8GpXo3KO8ZVPYMqnsGtemgT8XM90HrbOLa68egdvcjXEfgzgalPYPynkFlz6D17F0W/6+DLibIz4PW+S+zQau311JaPl7n7get/3LHrda+/Ge/GzR2DFrvMZwNWv0atWVcU97CcveFXe+Ymg1KewblPYPKnkF1z6C2Z1D/9UFx+UKnev3CtqWFu0Hr2btYercvbFjuBpU9g+qv/zTi+jLjbFDfM2jsGLS+rDEbFPYMinsGpT2D8p5BZc+gPd+IsOcbEfZ8I8Keb0Tc842Ie74RcT7v3f8IY9kzqO4Z1PYMWtcp5NvEEsrPT/e4/qZ28cZv2Qsj3Q3KewaVPYPqnkHr2Qs3W/syKN8N6nsGjR2D1t/UZoPCnkFxz6C0Z9C6TjHdvnuXb9rdoDZ7EsZx98tdf/ucDRo7Bq2/fc4GhT2D4p5Bac+gvGfQFxXLKBsVS6k7ypzS9gzqewaNHYPqsmdQ2DMo7hmU9gzaUcOm9SIx5Jz7dYEg57uHTVovE6fD1su3i3nVbqtrufR0NyztG5b3DSv7htV9w9q+YX3fsLFr2Ho5Nx8Wvhh2sym+Dct3w+K+YWnfsLxvWNk3rP76sMs/wrcPr88/lyXmdvXVL/89fv7RrU9A01Fp16i8a1TZNaruGtV2jeq7Ro09o9YPxrt4wPn6kL78d/3Znlo3Oaej4q5Radeo/MWo1j5G9btRZdeo9czXND5t+gg/z1f9i8zn9BFXLj8XVT3sGhV3jUq7Rn2R+XzbMnCx8Jefp6pedo2qu0a1XaP6rlFjz6ix7Br1xXejLPVjVPh5Bhhx16i0a9RX341Pv68Sfvh9re70Gx8bzUqok4+XjxeOUNLd0tUogPdUAe+pAd5TB7yngXdPYVkQbyog3lREvKn0kpvq9dNN3a2XLQdN5r1/3FTMd1cpp1ylnnKVdspV+ilXGWdcJSynXCWccpWvZpb6UdTldj8s7RuW9w0r+4bVfcPavmF937Cxa1hc9g0L+4bt+5bEfd+SL+yoWm59Opf/ruluWNk3rO4b1vYN67uGpS/krh+78Gv9ezfJzod9kZL64XXW2u8KgvTFV7l/9ILUfr/pKS/7hoV9w+K+YWnfsLxvWNk3rO4b1vYN++Kr3Fv+GNbvKrT81bfk05erj7H9XMvx1vyTY/v4uYSx1vyTb+//JX96BF4+/A9fbsx95Q0FtBuKaDeU0G4oo91QQbuhinZDDeyGvlhvqiN+OPYj3u3t/mIRqI4yPobdT8NfrOfUkT9m75HH3bCxa9hXKzqzYWHfsLhvWNo3LO8bVvYNq/uGffFtH/Xzt+SupGt937Cxa9hXq0+zYevfkraE22tGW+L9vvm4b1jaNyzvG1b2Dav7hrV9w/oXw8qnYfVu5vpiGWo27It1qOmwsG/YV9+S/HnYXXE80r5hed+wsm9Y3Tes7RvW9w376lvyYQS3Zfw8KcRl2Tcs7BsW9w376lvSPg+77+/I+4aVfcPqvmFt37C+b9jYNewLK7eFj5rr8t/jbljYNyzuG5b2DfviW3Lxrz+Gpbs9lF+YrdNhdd+wtm9Y3zds7BoWl33Dvqpe+/gY9mOz5oqDn5f0sS9uyXcbz7/yZn/1KjfK0+W/232PSTrlKvmUq5RTrlJPuUo75Sr9lKuMM67ylZX+q1dp5eMq/b6ZJhwfy8pV4ilXSadcJZ9ylYN++x+UyxzC39npdfhV2ilX6adcZZxxlbyccpVwylXiKVc55rcfwsev8rJQe3eVfHwsK1cpp1ylnnKVdspVjvnth/TREnVZKrm7yjjjKmU55SrhlKvEU66STrlKPuUq5ZSrHPPbD+XTr7LemRalHR/LylX6KVcZZ1ylLqdcJexZifuiPXY+LO0blvcNK/uG1X3D2r5hfd+wsWvYl2uak2H7viVt37ek7fuWtH3fkrbvW9L2fUu+WmXc3qYWv1plrB8b0evFuL8bFvYNi/uGpX3D8r5hZd+wum9Y2zes7xs2dg0b+74lY9+3ZOz7lox935Kx71sydn1LvmQQzEAJZd+wt6YCTIbtY0fEfeyIL6kAk2H72BFxHzsifsWOmDAI+r5hY9ewtOwbto8dkXawIy7/iN8+/AVe+gZvb586q0MafzyGf31I//Uh45eHfIGV3hwSfn3IOtxm3I4UWe6HpF8fkn99SPn1Iavqf+zn7p9+f9ch7deH9F8fMn55yLrVO5brkBHuh4RfHxJ/fUj69SGr6o90rY4/o1qvQ8qvD6m/PqT9+pA+GVLK3ZDxy0PWzb7tIevq3+B8F6/gbkj89SHp14fkXx/yBU7mw4Vf6o8JWNnafGscLJ+PImp/HC1Xn32B9uwL9GdfYDz5Al+YWgdeIDz7AvHZF0jPvkB+9gWe/Uuuz/4l12f/kuuzf8n12b/k9uxfcnv2L7k9+5fcnv1Lbs/+Jbdn/5L7Ad+iEq9laEnh7gIHaFBum73L59rwjwuM+OQIxhERlOvGr/L5s98vkJ99gfLsC9RnX6AdcYFwu8Dd72D0Z19gPPkCX5GRjrxCePoV4tOvkJ5+hfzkGe8rktCRV6hPv0J7+hX6068wnn2FsDz9CuHpV4hPv0J6+hWe/psOT/9Nh6f/psPTf9Ph6b/p8Nzf9OVf6dsn179QfbmdrtyXH8kA30bmr0debjDcbjB9usG1U5nb8nGKSvz80W8JKM/98/XxP59uJ1J9aln//ufbAX/+xv3/hFT6/uf7c//8ePzP3zanfSZk//Hn4/LcPx8e/vMf8KDP6KDvfz4e8Oevrxi91J//fHr8z99OjOj3yckH/vnx08/q8o+yMTVcqurrRcKnnRabv5jwwST/vGlx82ewPWb8+pgvvrDbY8KOMXHHmLRjTP71MV+sYm4/KOq3j36x13D7OOEvdhrOBsU9g9KeQXnPoLJnUN0zqO0Z1PcM2nFo9he7GGeD9nwj+p5vRN/zjeh7vhF9zzei7/lG9D3fiL7nG9H3fCPGnm/E+n7F7eO5v9itOBuU9gzKewaVPYPmx6jfHTme1l207SPH07qptH2md1r3iWaD6p5Bbceg9XJl+3juL3Z4zgbVPYPankF9z6Av9qltnen9xS7S2aCwZ1DcM2h+jPrdkePpq22BW8dzp682Bm4PGjsGfbU5cHtQ2DNoPXubp4en1HcMyjsOj03re8u2DwJP67vLZoPqnkE7Ds1Oue8ZNHYM+uJYzcmgsGdQ3DMo7RmU9wz6QqetI8fTniMo054jKFPdcWh2qmnPoLxnUNkzqO4Z1PYM6nsG7Tg0O7Vlz6A9817b841oe74Rbc83ou35RrQ934i25xvR5/Pe/Y+whz2D4p5Bac+gdZ02jxxP/YtDs7fO9E5j2TMo7BkU9wzacWh2GnnPoLJnUN0zqO0Z1PcM2nGMel6+OCJ568jxvOw4NDuvv33OBpU9g+qeQW3PoL5n0I5j1HNY9gz6omLZOnI8hx2HZueQ9gzKewaVPYPqnkFtz6C+Z9COY9Rz3FHD5i+2jU96W3Mt+4btaonNdVdLbG7LvmFh37C4b1jaNyzvG1b2Dav7hu1qic2t7xu2qyU292XfsLBv2L6W2Pbtw+uW2eX7+n1k+bxz4WKe/cNXC4rbQ/KvDym/PqT++pD260NWv0nlNiOWEe6GjF8esu7gbQ8Jvz7ki6WODzM8/jDkF/fsf2EOHvbn83P/fHnun6/P/fPtuX++P/fPj6f++fX26eP+fHjun3/urzY/91ebn/urzc/91ebn/mrzc3+1+bm/2vzcX2157q+2PPdXW577qy0Pf3M2e8vqw7nf3M1cy3Pv/uFf7WbTV23P/fP9uX9+PPXPt8e/OVtdTC0898/H5/759Nw/n5/758tz/3x97p9vT53SWn/unx9P/fP9ufN9D8/98/G5fz4998/n5/758tw/X5/755/7q+3P/NVe/tW/ffKLww3CcuuxCPEzWmr5+rVsNijvGVT2DKq/POjyr/G7B7nudY3bGkP5bMKly8DLP/+/f/q3P//TP//lX//9MuTb//qff/2X//jz3/76/Z//8f//3+v/8s//9ue//OXP/+cf/++//e1f/vV//ee//es//uVv//Ltf/vT8v3//M/Yy29pqf/we8vb//zWhXK52X/41jf77X+s7bfLese3f36btOJlpTO2/u3mw3V8SuO3VJfv4/P4rYzb6NEvfzpdR6cl/36l//5OJPz2kW9dFaHerh4vV0+3q1/ivfyzX8eHy5VCDh/deb9/5nKD8aPt7vfLtt9S/Gi3+f0m42+p3Xouvv1/cg6/5Rq/XziW/lus/XrhHNNvOd4unC/Dc8o33/j364Z8ubfyffwIv13Evt33tyQu7XbfS7/kdLn9AtLvufgtL7fL9d9Kun0j/ogh/Xa5/n//90Xv/wc=",
+      "debug_symbols": "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",
       "brillig_names": [
         "build_msg_block",
         "attach_len_to_msg_block",
@@ -3749,6 +3617,138 @@
         "directive_integer_quotient"
       ],
       "verification_key": "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"
+    },
+    {
+      "name": "_increase_public_balance",
+      "is_unconstrained": true,
+      "custom_attributes": [
+        "public",
+        "internal"
+      ],
+      "abi": {
+        "error_types": {
+          "10502589790419500451": {
+            "error_kind": "string",
+            "string": "Function _increase_public_balance can only be called internally"
+          },
+          "16761564377371454734": {
+            "error_kind": "string",
+            "string": "Array index out of bounds"
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          },
+          "206160798890201757": {
+            "error_kind": "string",
+            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
+          },
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
+          },
+          "6485997221020871071": {
+            "error_kind": "string",
+            "string": "call to assert_max_bit_size"
+          }
+        },
+        "parameters": [
+          {
+            "name": "to",
+            "type": {
+              "fields": [
+                {
+                  "name": "inner",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "amount",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": null
+      },
+      "bytecode": "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",
+      "debug_symbols": "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",
+      "brillig_names": [
+        "_increase_public_balance"
+      ]
+    },
+    {
+      "name": "balance_of_public",
+      "is_unconstrained": true,
+      "custom_attributes": [
+        "public",
+        "view"
+      ],
+      "abi": {
+        "error_types": {
+          "16761564377371454734": {
+            "error_kind": "string",
+            "string": "Array index out of bounds"
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          },
+          "206160798890201757": {
+            "error_kind": "string",
+            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
+          },
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
+          },
+          "6067862452620309358": {
+            "error_kind": "string",
+            "string": "Function balance_of_public can only be called statically"
+          },
+          "6485997221020871071": {
+            "error_kind": "string",
+            "string": "call to assert_max_bit_size"
+          }
+        },
+        "parameters": [
+          {
+            "name": "owner",
+            "type": {
+              "fields": [
+                {
+                  "name": "inner",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": {
+          "abi_type": {
+            "kind": "field"
+          },
+          "visibility": "public"
+        }
+      },
+      "bytecode": "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",
+      "debug_symbols": "7d3dTuM6EAfwd+l1Lzz2+ItXWR0hvhZVqigqcKQjxLufFJq0YDdpZqrdQv43aLt4YvtXJ3ac2LzObu+uX+4vFw+/V0+zi1+vs+Xq5up5sXpoPr2+zWfX68Vyubi/3P/vmdn8iP49/dPj1cPm49Pz1fp5dkEhm/ns7uG2+Wc0pjnC78XybnYR3Ns/81nM42MSC2IE+WQniInjY8hYSZAkJyJJkOB7JWskQaKcxn618yJxiEzbxCH62CVOtpI4pWy3iVMmv594UxwnaJ3kBM2TWJKTl7Q1X21rztq0DXKWYz8xkcltDuRzl5i8qaVOoU2cU5fWpvBenEDnVZxwVsWJ56UTz0snnZdO8udVnHxWxcl8XsVJf7o4vi2ONfZTcSrdkrVtH5Zs2B3Z+lRJ7bojs91d7m3twNaa9sBNFrk/sXdum9Y73k/a+Nn6OAd+R/tF+Gn8CO1P54f2p/KzaH86vwA/jZ8z8FP5efip/DL8NH7M8FP54f5N5ecxftH5Yfys8vvz877fzy/E1i+kwg/jF5VfxPhZ58fwG/ALXdrwOenGL+P81fnh/kPj5wzOX50f2p/Kj9D+dH5ofyo/6+Cn8sP9r8rPYf5F54fnRyo/xvyLzg/3byo/j/kXnR/Dr0TBQ6ESJWCkW0HB8LVEiRgTVFAw0CxREnrvCgq65AoK5qlKlIwuuYKCLrlAYSyzqKGgSy5RCF1yBQWzNCWKRUupoDBQShTMp5QoDoO3EmWqr3PyDsXbryhxmvc+0XaliCxPvBFM0zzXxghSiN12HyGlQnCal/ATCuZp3m2cTtCbaXYOpxSc5n3MKMGY2uUmlMzXvthP9Pb4lIIMQaUg+mKl4ER3XTilIEYzSsGJ7rxwSkGMZpSCjDaoFWQIKgUxmlEKTnQPhlMKYjSjFAzoSbSC6Em0guhJlIIRz0m0gtN8+2yUYKauftkVggmjGa0g2qBSMJ/gSZN13OZgMw0IOt9eVNzmaH0HToY7v/3Dpo+Sh29a8mC+q3k4xR4ef6fkRzyL2Tv5D5ScYldytp+yKFNHS+1JGq0b+Ksq0Zj20NFw6E9MJsWuYzbZfEq+qesRryueuq7dq05x/62eavFtc5ltr17Eu23unKkVhHN3eebsdte6UGst3O2/1aTdlTl/qHiolCocoFKqeIJKRSVDpVQ5YjbjG6n41NU0hH2V96r+qAbQW9X4o77V3Kb2xlBR1R/1rWbuqkrmS1WbYdZ0qjo83Immv6rNLW73srZxu1PE5lxJ7Sm0qT3FrydUPOJ1slOXx/eVZ6KLEhy1tw7W7d0mfcwGRDfNeeV+FEZLKVH8NN9QHkCZ5sPVfpSJLnQaQEFLKVHqO8yT6Wa7yUTfn8PPXz+XcydIthBkCCoFqyMgIja7eiYI9gjWVyBC8HjB+jM5CI4QDBBUCab6TAlRtF09M3qSPsH62qWmCXbTR2zQBvsE62uXIDhCMEBQJ1hfuwTBEYJcFfSu64u9jxDsE8wQ1Aky2qBSsL7yBoIjBCMEdYL1fdkheLzggRlWCB4v6CGoE0wEQaVggKBOMKMNagVxHdQJZoO+WCuINqgUJIyotYL1WX4fu3r6nCHYI3hglh+CxwsGCOoED8zyQ/B4wfoctdstPnYOz0n6BA/MUUPweMEEQZ3ggVl+CB4vGCCoE6zvrwXBEYLoSbSCGM0oBSPaoFYQoxmlYMJoRiuI0YxSMB8YzfhuEyQXMMPaKxggqBIkYxwItYQJhEpCYhBqCTMIlYQWrVBNiJVNWkKHpU1qQqxt0hIyFjepCaf5F4sHVDxDpaKCtlJRCdPcw71fhepPICK3GURvipj6bviZ24xyKPOpvwk9EOMFMXl0jD0wbXF4N5uPqCSJIiuKipIoK8rLivJyorycKC8W5cWi78uL8vKietV3MBuM8qKoLImKojOl/oSp9xpj689UMrVXyf29lLcxrv6m+0AMC2LS+BgS1IfC6GuZsySIEeRTX20/EDP+2uxYkA8L8vHVlp1D20ZzzGVMGh8TBPlEEsSE8TFJkE8S5FN/VrX3/dRixo8F2BhBjCCf+uqGgZg0PsaOPxfYkSBm/PWA633yQMz4cSR7QT5eUJ8gaDtB8P0EQTuIArckcBOM83nsefrWfPr3ar24ul7ePTURm1++PNw8L1YP24/P/z22v7leL5bLxf3l43p1c3f7sr67XK5uNr+bme2PX86EubNxU5bNR0tubim93xq8/9bMnbFNrk3O/wM=",
+      "brillig_names": [
+        "balance_of_public"
+      ]
     }
   ],
   "outputs": {
@@ -3817,7 +3817,7 @@
               "type": {
                 "fields": [
                   {
-                    "name": "portal_address",
+                    "name": "to",
                     "type": {
                       "fields": [
                         {
@@ -3828,23 +3828,23 @@
                         }
                       ],
                       "kind": "struct",
-                      "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
+                      "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
                     }
                   },
                   {
-                    "name": "initial_mint",
+                    "name": "amount",
                     "type": {
                       "kind": "field"
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "FeeJuice::initialize_parameters"
+                "path": "FeeJuice::_increase_public_balance_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "FeeJuice::initialize_abi"
+          "path": "FeeJuice::_increase_public_balance_abi"
         },
         {
           "fields": [
@@ -3853,7 +3853,7 @@
               "type": {
                 "fields": [
                   {
-                    "name": "to",
+                    "name": "owner",
                     "type": {
                       "fields": [
                         {
@@ -3866,33 +3866,21 @@
                       "kind": "struct",
                       "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
                     }
-                  },
-                  {
-                    "name": "amount",
-                    "type": {
-                      "kind": "field"
-                    }
-                  },
-                  {
-                    "name": "secret",
-                    "type": {
-                      "kind": "field"
-                    }
-                  },
-                  {
-                    "name": "message_leaf_index",
-                    "type": {
-                      "kind": "field"
-                    }
                   }
                 ],
                 "kind": "struct",
-                "path": "FeeJuice::claim_parameters"
+                "path": "FeeJuice::balance_of_public_parameters"
+              }
+            },
+            {
+              "name": "return_type",
+              "type": {
+                "kind": "field"
               }
             }
           ],
           "kind": "struct",
-          "path": "FeeJuice::claim_abi"
+          "path": "FeeJuice::balance_of_public_abi"
         },
         {
           "fields": [
@@ -3901,7 +3889,7 @@
               "type": {
                 "fields": [
                   {
-                    "name": "portal_address",
+                    "name": "to",
                     "type": {
                       "fields": [
                         {
@@ -3912,17 +3900,35 @@
                         }
                       ],
                       "kind": "struct",
-                      "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
+                      "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+                    }
+                  },
+                  {
+                    "name": "amount",
+                    "type": {
+                      "kind": "field"
+                    }
+                  },
+                  {
+                    "name": "secret",
+                    "type": {
+                      "kind": "field"
+                    }
+                  },
+                  {
+                    "name": "message_leaf_index",
+                    "type": {
+                      "kind": "field"
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "FeeJuice::set_portal_parameters"
+                "path": "FeeJuice::claim_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "FeeJuice::set_portal_abi"
+          "path": "FeeJuice::claim_abi"
         },
         {
           "fields": [
@@ -3931,7 +3937,7 @@
               "type": {
                 "fields": [
                   {
-                    "name": "to",
+                    "name": "portal_address",
                     "type": {
                       "fields": [
                         {
@@ -3942,23 +3948,23 @@
                         }
                       ],
                       "kind": "struct",
-                      "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+                      "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
                     }
                   },
                   {
-                    "name": "amount",
+                    "name": "initial_mint",
                     "type": {
                       "kind": "field"
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "FeeJuice::_increase_public_balance_parameters"
+                "path": "FeeJuice::initialize_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "FeeJuice::_increase_public_balance_abi"
+          "path": "FeeJuice::initialize_abi"
         },
         {
           "fields": [
@@ -3988,7 +3994,7 @@
               "type": {
                 "fields": [
                   {
-                    "name": "owner",
+                    "name": "portal_address",
                     "type": {
                       "fields": [
                         {
@@ -3999,23 +4005,17 @@
                         }
                       ],
                       "kind": "struct",
-                      "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+                      "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "FeeJuice::balance_of_public_parameters"
-              }
-            },
-            {
-              "name": "return_type",
-              "type": {
-                "kind": "field"
+                "path": "FeeJuice::set_portal_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "FeeJuice::balance_of_public_abi"
+          "path": "FeeJuice::set_portal_abi"
         }
       ]
     }
@@ -4051,15 +4051,15 @@
     },
     "150": {
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/state_vars/map.nr",
-      "source": "use crate::state_vars::storage::Storage;\nuse dep::protocol_types::{\n    storage::map::derive_storage_slot_in_map,\n    traits::{Deserialize, Serialize, ToField},\n};\n\n// docs:start:map\npub struct Map<K, V, Context> {\n    context: Context,\n    storage_slot: Field,\n    state_var_constructor: fn(Context, Field) -> V,\n}\n// docs:end:map\n\nimpl<K, T, Context, let N: u32> Storage<T, N> for Map<K, T, Context>\nwhere\n    T: Serialize<N> + Deserialize<N>,\n{}\n\nimpl<K, V, Context> Map<K, V, Context> {\n    // docs:start:new\n    pub fn new(\n        context: Context,\n        storage_slot: Field,\n        state_var_constructor: fn(Context, Field) -> V,\n    ) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        Map { context, storage_slot, state_var_constructor }\n    }\n    // docs:end:new\n\n    // docs:start:at\n    pub fn at(self, key: K) -> V\n    where\n        K: ToField,\n    {\n        // TODO(#1204): use a generator index for the storage slot\n        let derived_storage_slot = derive_storage_slot_in_map(self.storage_slot, key);\n\n        let state_var_constructor = self.state_var_constructor;\n        state_var_constructor(self.context, derived_storage_slot)\n    }\n    // docs:end:at\n}\n"
+      "source": "use crate::state_vars::storage::Storage;\nuse dep::protocol_types::{\n    storage::map::derive_storage_slot_in_map,\n    traits::{Deserialize, Serialize, ToField},\n};\n\n// docs:start:map\npub struct Map<K, V, Context> {\n    context: Context,\n    storage_slot: Field,\n    state_var_constructor: fn(Context, Field) -> V,\n}\n// docs:end:map\n\nimpl<K, T, Context, let N: u32> Storage<T, N> for Map<K, T, Context>\nwhere\n    T: Serialize<N> + Deserialize<N>,\n{\n    fn get_storage_slot(self) -> Field {\n        self.storage_slot\n    }\n}\n\nimpl<K, V, Context> Map<K, V, Context> {\n    // docs:start:new\n    pub fn new(\n        context: Context,\n        storage_slot: Field,\n        state_var_constructor: fn(Context, Field) -> V,\n    ) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        Map { context, storage_slot, state_var_constructor }\n    }\n    // docs:end:new\n\n    // docs:start:at\n    pub fn at(self, key: K) -> V\n    where\n        K: ToField,\n    {\n        // TODO(#1204): use a generator index for the storage slot\n        let derived_storage_slot = derive_storage_slot_in_map(self.storage_slot, key);\n\n        let state_var_constructor = self.state_var_constructor;\n        state_var_constructor(self.context, derived_storage_slot)\n    }\n    // docs:end:at\n}\n"
     },
     "157": {
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/state_vars/public_immutable.nr",
-      "source": "use crate::{\n    context::{PrivateContext, PublicContext, UnconstrainedContext},\n    state_vars::storage::Storage,\n};\nuse dep::protocol_types::{\n    constants::INITIALIZATION_SLOT_SEPARATOR,\n    traits::{Deserialize, Serialize},\n};\n\n/// Stores an immutable value in public state which can be read from public, private and unconstrained execution\n/// contexts.\n// docs:start:public_immutable_struct\npub struct PublicImmutable<T, Context> {\n    context: Context,\n    storage_slot: Field,\n}\n// docs:end:public_immutable_struct\n\nimpl<T, Context, let N: u32> Storage<T, N> for PublicImmutable<T, Context>\nwhere\n    T: Serialize<N> + Deserialize<N>,\n{}\n\nimpl<T, Context> PublicImmutable<T, Context> {\n    // docs:start:public_immutable_struct_new\n    pub fn new(\n        // Note: Passing the contexts to new(...) just to have an interface compatible with a Map.\n        context: Context,\n        storage_slot: Field,\n    ) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        PublicImmutable { context, storage_slot }\n    }\n    // docs:end:public_immutable_struct_new\n}\n\nimpl<T, let T_SERIALIZED_LEN: u32> PublicImmutable<T, &mut PublicContext>\nwhere\n    T: Serialize<T_SERIALIZED_LEN> + Deserialize<T_SERIALIZED_LEN>,\n{\n    // docs:start:public_immutable_struct_write\n    pub fn initialize(self, value: T) {\n        // We check that the struct is not yet initialized by checking if the initialization slot is 0\n        let initialization_slot = INITIALIZATION_SLOT_SEPARATOR + self.storage_slot;\n        let init_field: Field = self.context.storage_read(initialization_slot);\n        assert(init_field == 0, \"PublicImmutable already initialized\");\n\n        // We populate the initialization slot with a non-zero value to indicate that the struct is initialized\n        self.context.storage_write(initialization_slot, 0xdead);\n        self.context.storage_write(self.storage_slot, value);\n    }\n    // docs:end:public_immutable_struct_write\n\n    // Note that we don't access the context, but we do call oracles that are only available in public\n    // docs:start:public_immutable_struct_read\n    pub fn read(self) -> T {\n        self.context.storage_read(self.storage_slot)\n    }\n    // docs:end:public_immutable_struct_read\n}\n\nimpl<T, let T_SERIALIZED_LEN: u32> PublicImmutable<T, UnconstrainedContext>\nwhere\n    T: Serialize<T_SERIALIZED_LEN> + Deserialize<T_SERIALIZED_LEN>,\n{\n    pub unconstrained fn read(self) -> T {\n        self.context.storage_read(self.storage_slot)\n    }\n}\n\nimpl<T, let T_SERIALIZED_LEN: u32> PublicImmutable<T, &mut PrivateContext>\nwhere\n    T: Serialize<T_SERIALIZED_LEN> + Deserialize<T_SERIALIZED_LEN>,\n{\n    pub fn read(self) -> T {\n        let header = self.context.get_block_header();\n        let mut fields = [0; T_SERIALIZED_LEN];\n\n        for i in 0..fields.len() {\n            fields[i] = header.public_storage_historical_read(\n                self.storage_slot + i as Field,\n                (*self.context).this_address(),\n            );\n        }\n        T::deserialize(fields)\n    }\n}\n"
+      "source": "use crate::{\n    context::{PrivateContext, PublicContext, UnconstrainedContext},\n    state_vars::storage::Storage,\n};\nuse dep::protocol_types::{\n    constants::INITIALIZATION_SLOT_SEPARATOR,\n    traits::{Deserialize, Serialize},\n};\n\n/// Stores an immutable value in public state which can be read from public, private and unconstrained execution\n/// contexts.\n// docs:start:public_immutable_struct\npub struct PublicImmutable<T, Context> {\n    context: Context,\n    storage_slot: Field,\n}\n// docs:end:public_immutable_struct\n\nimpl<T, Context, let N: u32> Storage<T, N> for PublicImmutable<T, Context>\nwhere\n    T: Serialize<N> + Deserialize<N>,\n{\n    fn get_storage_slot(self) -> Field {\n        self.storage_slot\n    }\n}\n\nimpl<T, Context> PublicImmutable<T, Context> {\n    // docs:start:public_immutable_struct_new\n    pub fn new(\n        // Note: Passing the contexts to new(...) just to have an interface compatible with a Map.\n        context: Context,\n        storage_slot: Field,\n    ) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        PublicImmutable { context, storage_slot }\n    }\n    // docs:end:public_immutable_struct_new\n}\n\nimpl<T, let T_SERIALIZED_LEN: u32> PublicImmutable<T, &mut PublicContext>\nwhere\n    T: Serialize<T_SERIALIZED_LEN> + Deserialize<T_SERIALIZED_LEN>,\n{\n    // docs:start:public_immutable_struct_write\n    pub fn initialize(self, value: T) {\n        // We check that the struct is not yet initialized by checking if the initialization slot is 0\n        let initialization_slot = INITIALIZATION_SLOT_SEPARATOR + self.storage_slot;\n        let init_field: Field = self.context.storage_read(initialization_slot);\n        assert(init_field == 0, \"PublicImmutable already initialized\");\n\n        // We populate the initialization slot with a non-zero value to indicate that the struct is initialized\n        self.context.storage_write(initialization_slot, 0xdead);\n        self.context.storage_write(self.storage_slot, value);\n    }\n    // docs:end:public_immutable_struct_write\n\n    // Note that we don't access the context, but we do call oracles that are only available in public\n    // docs:start:public_immutable_struct_read\n    pub fn read(self) -> T {\n        self.context.storage_read(self.storage_slot)\n    }\n    // docs:end:public_immutable_struct_read\n}\n\nimpl<T, let T_SERIALIZED_LEN: u32> PublicImmutable<T, UnconstrainedContext>\nwhere\n    T: Serialize<T_SERIALIZED_LEN> + Deserialize<T_SERIALIZED_LEN>,\n{\n    pub unconstrained fn read(self) -> T {\n        self.context.storage_read(self.storage_slot)\n    }\n}\n\nimpl<T, let T_SERIALIZED_LEN: u32> PublicImmutable<T, &mut PrivateContext>\nwhere\n    T: Serialize<T_SERIALIZED_LEN> + Deserialize<T_SERIALIZED_LEN>,\n{\n    pub fn read(self) -> T {\n        let header = self.context.get_block_header();\n        let mut fields = [0; T_SERIALIZED_LEN];\n\n        for i in 0..fields.len() {\n            fields[i] = header.public_storage_historical_read(\n                self.storage_slot + i as Field,\n                (*self.context).this_address(),\n            );\n        }\n        T::deserialize(fields)\n    }\n}\n"
     },
     "158": {
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/state_vars/public_mutable.nr",
-      "source": "use crate::context::{PublicContext, UnconstrainedContext};\nuse crate::state_vars::storage::Storage;\nuse dep::protocol_types::traits::{Deserialize, Serialize};\n\n// docs:start:public_mutable_struct\npub struct PublicMutable<T, Context> {\n    context: Context,\n    storage_slot: Field,\n}\n// docs:end:public_mutable_struct\n\nimpl<T, Context, let N: u32> Storage<T, N> for PublicMutable<T, Context>\nwhere\n    T: Serialize<N> + Deserialize<N>,\n{}\n\nimpl<T, Context> PublicMutable<T, Context> {\n    // docs:start:public_mutable_struct_new\n    pub fn new(\n        // Note: Passing the contexts to new(...) just to have an interface compatible with a Map.\n        context: Context,\n        storage_slot: Field,\n    ) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        PublicMutable { context, storage_slot }\n    }\n    // docs:end:public_mutable_struct_new\n}\n\nimpl<T, let T_SERIALIZED_LEN: u32> PublicMutable<T, &mut PublicContext>\nwhere\n    T: Serialize<T_SERIALIZED_LEN> + Deserialize<T_SERIALIZED_LEN>,\n{\n    // docs:start:public_mutable_struct_read\n    pub fn read(self) -> T {\n        self.context.storage_read(self.storage_slot)\n    }\n    // docs:end:public_mutable_struct_read\n\n    // docs:start:public_mutable_struct_write\n    pub fn write(self, value: T) {\n        self.context.storage_write(self.storage_slot, value);\n    }\n    // docs:end:public_mutable_struct_write\n}\n\nimpl<T, let T_SERIALIZED_LEN: u32> PublicMutable<T, UnconstrainedContext>\nwhere\n    T: Deserialize<T_SERIALIZED_LEN>,\n{\n    pub unconstrained fn read(self) -> T {\n        self.context.storage_read(self.storage_slot)\n    }\n}\n"
+      "source": "use crate::context::{PublicContext, UnconstrainedContext};\nuse crate::state_vars::storage::Storage;\nuse dep::protocol_types::traits::{Deserialize, Serialize};\n\n// docs:start:public_mutable_struct\npub struct PublicMutable<T, Context> {\n    context: Context,\n    storage_slot: Field,\n}\n// docs:end:public_mutable_struct\n\nimpl<T, Context, let N: u32> Storage<T, N> for PublicMutable<T, Context>\nwhere\n    T: Serialize<N> + Deserialize<N>,\n{\n    fn get_storage_slot(self) -> Field {\n        self.storage_slot\n    }\n}\n\nimpl<T, Context> PublicMutable<T, Context> {\n    // docs:start:public_mutable_struct_new\n    pub fn new(\n        // Note: Passing the contexts to new(...) just to have an interface compatible with a Map.\n        context: Context,\n        storage_slot: Field,\n    ) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        PublicMutable { context, storage_slot }\n    }\n    // docs:end:public_mutable_struct_new\n}\n\nimpl<T, let T_SERIALIZED_LEN: u32> PublicMutable<T, &mut PublicContext>\nwhere\n    T: Serialize<T_SERIALIZED_LEN> + Deserialize<T_SERIALIZED_LEN>,\n{\n    // docs:start:public_mutable_struct_read\n    pub fn read(self) -> T {\n        self.context.storage_read(self.storage_slot)\n    }\n    // docs:end:public_mutable_struct_read\n\n    // docs:start:public_mutable_struct_write\n    pub fn write(self, value: T) {\n        self.context.storage_write(self.storage_slot, value);\n    }\n    // docs:end:public_mutable_struct_write\n}\n\nimpl<T, let T_SERIALIZED_LEN: u32> PublicMutable<T, UnconstrainedContext>\nwhere\n    T: Deserialize<T_SERIALIZED_LEN>,\n{\n    pub unconstrained fn read(self) -> T {\n        self.context.storage_read(self.storage_slot)\n    }\n}\n"
     },
     "178": {
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/utils/array/subarray.nr",
@@ -4083,7 +4083,7 @@
     },
     "256": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/data/public_data_tree_leaf_preimage.nr",
-      "source": "use crate::{\n    data::public_data_tree_leaf::PublicDataTreeLeaf,\n    merkle_tree::leaf_preimage::IndexedTreeLeafPreimage,\n    traits::{Empty, Hash},\n};\n\npub struct PublicDataTreeLeafPreimage {\n    pub slot: Field,\n    pub value: Field,\n    pub next_slot: Field,\n    pub next_index: u32,\n}\n\nimpl Empty for PublicDataTreeLeafPreimage {\n    fn empty() -> Self {\n        Self { slot: 0, value: 0, next_slot: 0, next_index: 0 }\n    }\n}\n\nimpl Eq for PublicDataTreeLeafPreimage {\n    fn eq(self, other: Self) -> bool {\n        (self.slot == other.slot)\n            & (self.value == other.value)\n            & (self.next_slot == other.next_slot)\n            & (self.next_index == other.next_index)\n    }\n}\n\nimpl Hash for PublicDataTreeLeafPreimage {\n    fn hash(self) -> Field {\n        if self.is_empty() {\n            0\n        } else {\n            crate::hash::poseidon2_hash([\n                self.slot,\n                self.value,\n                (self.next_index as Field),\n                self.next_slot,\n            ])\n        }\n    }\n}\n\nimpl IndexedTreeLeafPreimage<PublicDataTreeLeaf> for PublicDataTreeLeafPreimage {\n    fn get_key(self) -> Field {\n        self.slot\n    }\n\n    fn get_next_key(self) -> Field {\n        self.next_slot\n    }\n\n    fn points_to_infinity(self) -> bool {\n        (self.next_slot == 0) & (self.next_index == 0)\n    }\n\n    fn as_leaf(self) -> Field {\n        self.hash()\n    }\n\n    fn update_pointers(self, next_slot: Field, next_index: u32) -> Self {\n        Self { slot: self.slot, value: self.value, next_slot, next_index }\n    }\n\n    fn update_value(self, write: PublicDataTreeLeaf) -> Self {\n        Self {\n            slot: self.slot,\n            value: write.value,\n            next_slot: self.next_slot,\n            next_index: self.next_index,\n        }\n    }\n\n    fn build_insertion_leaf(write: PublicDataTreeLeaf, low_leaf: Self) -> Self {\n        Self {\n            slot: write.slot,\n            value: write.value,\n            next_slot: low_leaf.next_slot,\n            next_index: low_leaf.next_index,\n        }\n    }\n}\n\nimpl PublicDataTreeLeafPreimage {\n    pub fn is_empty(self) -> bool {\n        (self.slot == 0) & (self.value == 0) & (self.next_slot == 0) & (self.next_index == 0)\n    }\n}\n"
+      "source": "use crate::{\n    data::public_data_tree_leaf::PublicDataTreeLeaf,\n    merkle_tree::leaf_preimage::{IndexedTreeLeafPreimage, LeafPreimage},\n    traits::{Empty, Hash},\n};\n\npub struct PublicDataTreeLeafPreimage {\n    pub slot: Field,\n    pub value: Field,\n    pub next_slot: Field,\n    pub next_index: u32,\n}\n\nimpl Empty for PublicDataTreeLeafPreimage {\n    fn empty() -> Self {\n        Self { slot: 0, value: 0, next_slot: 0, next_index: 0 }\n    }\n}\n\nimpl Eq for PublicDataTreeLeafPreimage {\n    fn eq(self, other: Self) -> bool {\n        (self.slot == other.slot)\n            & (self.value == other.value)\n            & (self.next_slot == other.next_slot)\n            & (self.next_index == other.next_index)\n    }\n}\n\nimpl Hash for PublicDataTreeLeafPreimage {\n    fn hash(self) -> Field {\n        if self.is_empty() {\n            0\n        } else {\n            crate::hash::poseidon2_hash([\n                self.slot,\n                self.value,\n                (self.next_index as Field),\n                self.next_slot,\n            ])\n        }\n    }\n}\n\nimpl LeafPreimage for PublicDataTreeLeafPreimage {\n    fn get_key(self) -> Field {\n        self.slot\n    }\n\n    fn as_leaf(self) -> Field {\n        self.hash()\n    }\n}\n\nimpl IndexedTreeLeafPreimage<PublicDataTreeLeaf> for PublicDataTreeLeafPreimage {\n    fn get_next_key(self) -> Field {\n        self.next_slot\n    }\n\n    fn points_to_infinity(self) -> bool {\n        (self.next_slot == 0) & (self.next_index == 0)\n    }\n\n    fn update_pointers(self, next_slot: Field, next_index: u32) -> Self {\n        Self { slot: self.slot, value: self.value, next_slot, next_index }\n    }\n\n    fn update_value(self, write: PublicDataTreeLeaf) -> Self {\n        Self {\n            slot: self.slot,\n            value: write.value,\n            next_slot: self.next_slot,\n            next_index: self.next_index,\n        }\n    }\n\n    fn build_insertion_leaf(write: PublicDataTreeLeaf, low_leaf: Self) -> Self {\n        Self {\n            slot: write.slot,\n            value: write.value,\n            next_slot: low_leaf.next_slot,\n            next_index: low_leaf.next_index,\n        }\n    }\n}\n\nimpl PublicDataTreeLeafPreimage {\n    pub fn is_empty(self) -> bool {\n        (self.slot == 0) & (self.value == 0) & (self.next_slot == 0) & (self.next_index == 0)\n    }\n}\n"
     },
     "257": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr",
@@ -4091,7 +4091,7 @@
     },
     "258": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
-      "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector,\n        log_hash::{LogHash, ScopedLogHash},\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::scoped::Scoped,\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    traits::{is_empty, ToField},\n    utils::field::field_from_bytes_32_trunc,\n};\nuse super::utils::{arrays::array_concat, field::field_from_bytes};\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = std::hash::sha256(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\nfn compute_note_hash_nonce(tx_hash: Field, note_index_in_tx: u32) -> Field {\n    // Hashing tx hash with note index in tx is guaranteed to be unique\n    poseidon2_hash_with_separator(\n        [tx_hash, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n    siloed_note_hash: Field,\n    tx_hash: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    if siloed_note_hash == 0 {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(tx_hash, note_index_in_tx);\n        compute_unique_note_hash(nonce, siloed_note_hash)\n    }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n    poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped<PrivateLogData>) -> PrivateLog {\n    if private_log.contract_address.is_zero() {\n        private_log.inner.log\n    } else {\n        let mut fields = private_log.inner.log.fields;\n        fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n        PrivateLog { fields }\n    }\n}\n\nfn compute_siloed_unencrypted_log_hash(address: AztecAddress, log_hash: Field) -> Field {\n    accumulate_sha256([address.to_field(), log_hash])\n}\n\npub fn silo_unencrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_unencrypted_log_hash(log_hash.contract_address, log_hash.value())\n    }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: BoundedVec<u8, 160> = BoundedVec::new();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..inputs.len() {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes.push(item_bytes[j]);\n        }\n    }\n\n    sha256_to_field(bytes.storage())\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a U128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\n// Computes the final logs hash for a tx.\npub fn compute_tx_logs_hash<let N: u32>(logs: [LogHash; N]) -> Field {\n    // Convert each field element into a byte array and append the bytes to `hash_input_flattened`\n    let mut hash_input_flattened = [0; N * 32];\n    for offset in 0..N {\n        // TODO: This is not checking that the decomposition is smaller than P\n        let input_as_bytes: [u8; 32] = logs[offset].value.to_be_radix(256);\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n    // Ideally we would push to a slice then hash, but there is no sha_slice\n    // Hardcode to 256 bytes for now\n    let mut hash = sha256_to_field(hash_input_flattened);\n    // Not having a 0 value hash for empty logs causes issues with empty txs\n    // used for padding. Returning early is currently unsupported.\n    // We always provide sorted logs here, so 0 being empty means all are empty.\n    if is_empty(logs[0]) {\n        hash = 0;\n    }\n    hash\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n    sponge.squeeze()\n}\n\n// NB the below is the same as std::hash::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n//  - absorb normally up to 2 times to set cache_size to 1\n//  - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n//  - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n) -> std::hash::poseidon2::Poseidon2 {\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n    // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n    // since we cannot isolate computation branches. The below is just to avoid that.\n    let shift = if in_len == 0 { 0 } else { 1 };\n    if in_len != 0 {\n        // cache_size = 0, init absorb\n        sponge.cache[0] = input[0];\n        sponge.cache_size = 1;\n        // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n        // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n        // max_remainder = (N - 1) % 3;\n        // max_chunks = (N - 1 - max_remainder) / 3;\n        sponge = poseidon2_absorb_chunks_loop::<N, (N - 1 - (N - 1) % 3) / 3>(\n            sponge,\n            input,\n            in_len,\n            variable,\n            shift,\n        );\n    }\n    sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge<let N: u32>(\n    in_sponge: std::hash::poseidon2::Poseidon2,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> std::hash::poseidon2::Poseidon2 {\n    let mut sponge = in_sponge;\n    // 'shift' is to account for already added inputs\n    let mut shift = 0;\n    // 'stop' is to avoid an underflow when inputting in_len = 0\n    let mut stop = false;\n    for i in 0..3 {\n        if shift == in_len {\n            stop = true;\n        }\n        if (sponge.cache_size != 1) & (!stop) {\n            sponge.absorb(input[i]);\n            shift += 1;\n        }\n    }\n    sponge = if stop {\n        sponge\n    } else {\n        // max_chunks = (N - (N % 3)) / 3;\n        poseidon2_absorb_chunks_loop::<N, (N - (N % 3)) / 3>(\n            sponge,\n            input,\n            in_len,\n            skip_0_check,\n            shift,\n        )\n    };\n    sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop<let N: u32, let M: u32>(\n    in_sponge: std::hash::poseidon2::Poseidon2,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> std::hash::poseidon2::Poseidon2 {\n    assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n    // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n    // The below avoids an overflow\n    let skip_last = 3 * M == N;\n    // Writing in_sponge: &mut does not compile\n    let mut sponge = in_sponge;\n    let mut should_add = true;\n    // The num of things left over after absorbing in 3s\n    let remainder = (in_len - shift) % 3;\n    // The num of chunks of 3 to absorb (maximum M)\n    let chunks = (in_len - shift - remainder) / 3;\n    for i in 0..M {\n        // Now we loop through cache size = 1 -> 3\n        should_add &= i != chunks;\n        // This is the index at the start of the chunk (for readability)\n        let k = 3 * i + shift;\n        if should_add {\n            // cache_size = 1, 2 => just assign\n            sponge.cache[1] = input[k];\n            sponge.cache[2] = input[k + 1];\n            // cache_size = 3 => duplex + perm\n            for j in 0..3 {\n                sponge.state[j] += sponge.cache[j];\n            }\n            sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n            sponge.cache[0] = input[k + 2];\n            // cache_size is now 1 again, repeat loop\n        } else if (!variable) & (i != chunks) {\n            // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n            // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n            let last_0 = if (i == M - 1) & (skip_last) {\n                0\n            } else {\n                input[k + 2]\n            };\n            let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n            assert(all_0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    // we have 'remainder' num of items left to absorb\n    should_add = true;\n    // below is to avoid overflows (i.e. if inlen is close to N)\n    let mut should_check = !variable;\n    for i in 0..3 {\n        should_add &= i != remainder;\n        should_check &= in_len - remainder + i != N;\n        if should_add {\n            // we want to absorb the final 'remainder' items\n            sponge.absorb(input[in_len - remainder + i]);\n        } else if should_check {\n            assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    sponge\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n    let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n    let variable_len_hash = std::hash::poseidon2::Poseidon2::hash(input, in_len);\n    assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    // absorb 250 of the 501 things\n    let two_pow_64 = 18446744073709551616;\n    let empty_sponge = std::hash::poseidon2::Poseidon2::new((in_len as Field) * two_pow_64);\n    let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n    // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n    let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n    let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n    let in_len = 0;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut contructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(contructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == contructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = std::hash::sha256(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
+      "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: [u8; 160] = std::mem::zeroed();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..5 {\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[32 * i + j] = item_bytes[j];\n        }\n    }\n\n    sha256_to_field(bytes)\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"
     },
     "26": {
       "path": "std/hash/poseidon2.nr",
@@ -4147,7 +4147,7 @@
     },
     "73": {
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/context/call_interfaces.nr",
-      "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector, address::AztecAddress, traits::Deserialize,\n};\n\nuse crate::context::{gas::GasOpts, private_context::PrivateContext, public_context::PublicContext};\n\nuse crate::hash::hash_args;\nuse crate::oracle::arguments::pack_arguments;\n\npub trait CallInterface<let N: u32> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PrivateCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: T,\n    pub is_static: bool,\n}\n\nimpl<let N: u32, T> PrivateCallInterface<N, T> {\n    pub fn call<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        pack_arguments(self.args);\n        let returns = context.call_private_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            false,\n        );\n        let unpacked: T = returns.unpack_into();\n        unpacked\n    }\n\n    pub fn view<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        pack_arguments(self.args);\n        let returns = context.call_private_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            true,\n        );\n        returns.unpack_into()\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PrivateVoidCallInterface<N> {}\n\npub struct PrivateVoidCallInterface<let N: u32> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: (),\n    pub is_static: bool,\n}\n\nimpl<let N: u32> PrivateVoidCallInterface<N> {\n    pub fn call(self, context: &mut PrivateContext) {\n        pack_arguments(self.args);\n        context\n            .call_private_function_with_packed_args(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                false,\n            )\n            .assert_empty();\n    }\n\n    pub fn view(self, context: &mut PrivateContext) {\n        pack_arguments(self.args);\n        context\n            .call_private_function_with_packed_args(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                true,\n            )\n            .assert_empty();\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PrivateStaticCallInterface<N, T> {}\n\npub struct PrivateStaticCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: T,\n    pub is_static: bool,\n}\n\nimpl<let N: u32, T> PrivateStaticCallInterface<N, T> {\n    pub fn view<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        pack_arguments(self.args);\n        let returns = context.call_private_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            true,\n        );\n        returns.unpack_into()\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PrivateStaticVoidCallInterface<N> {}\n\npub struct PrivateStaticVoidCallInterface<let N: u32> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: (),\n    pub is_static: bool,\n}\n\nimpl<let N: u32> PrivateStaticVoidCallInterface<N> {\n    pub fn view(self, context: &mut PrivateContext) {\n        pack_arguments(self.args);\n        context\n            .call_private_function_with_packed_args(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                true,\n            )\n            .assert_empty();\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PublicCallInterface<N, T> {}\n\npub struct PublicCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args: [Field],\n    pub gas_opts: GasOpts,\n    pub return_type: T,\n    pub is_static: bool,\n}\n\nimpl<let N: u32, T> PublicCallInterface<N, T> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn call<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub unconstrained fn view<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub fn enqueue(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            false,\n        )\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PublicVoidCallInterface<N> {}\n\npub struct PublicVoidCallInterface<let N: u32> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args: [Field],\n    pub return_type: (),\n    pub is_static: bool,\n    pub gas_opts: GasOpts,\n}\n\nimpl<let N: u32> PublicVoidCallInterface<N> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn call(self, context: &mut PublicContext) {\n        let returns = context.call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub unconstrained fn view(self, context: &mut PublicContext) {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub fn enqueue(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            false,\n        )\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PublicStaticCallInterface<N, T> {}\n\npub struct PublicStaticCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args: [Field],\n    pub return_type: T,\n    pub is_static: bool,\n    pub gas_opts: GasOpts,\n}\n\nimpl<let N: u32, T> PublicStaticCallInterface<N, T> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn view<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PublicStaticVoidCallInterface<N> {}\n\npub struct PublicStaticVoidCallInterface<let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args: [Field],\n    return_type: (),\n    is_static: bool,\n    gas_opts: GasOpts,\n}\n\nimpl<let N: u32> PublicStaticVoidCallInterface<N> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn view(self, context: &mut PublicContext) {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n"
+      "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector, address::AztecAddress, traits::Deserialize,\n};\n\nuse crate::context::{gas::GasOpts, private_context::PrivateContext, public_context::PublicContext};\n\nuse crate::hash::hash_args;\nuse crate::oracle::arguments::pack_arguments;\n\npub trait CallInterface<let N: u32> {\n    fn get_args(self) -> [Field];\n    fn get_selector(self) -> FunctionSelector;\n    fn get_name(self) -> str<N>;\n    fn get_contract_address(self) -> AztecAddress;\n    fn get_is_static(self) -> bool;\n}\n\npub struct PrivateCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: T,\n    pub is_static: bool,\n}\n\nimpl<let N: u32, T> PrivateCallInterface<N, T> {\n    pub fn call<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        pack_arguments(self.args);\n        let returns = context.call_private_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            false,\n        );\n        let unpacked: T = returns.unpack_into();\n        unpacked\n    }\n\n    pub fn view<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        pack_arguments(self.args);\n        let returns = context.call_private_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            true,\n        );\n        returns.unpack_into()\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PrivateVoidCallInterface<N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PrivateVoidCallInterface<let N: u32> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: (),\n    pub is_static: bool,\n}\n\nimpl<let N: u32> PrivateVoidCallInterface<N> {\n    pub fn call(self, context: &mut PrivateContext) {\n        pack_arguments(self.args);\n        context\n            .call_private_function_with_packed_args(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                false,\n            )\n            .assert_empty();\n    }\n\n    pub fn view(self, context: &mut PrivateContext) {\n        pack_arguments(self.args);\n        context\n            .call_private_function_with_packed_args(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                true,\n            )\n            .assert_empty();\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PrivateStaticCallInterface<N, T> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PrivateStaticCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: T,\n    pub is_static: bool,\n}\n\nimpl<let N: u32, T> PrivateStaticCallInterface<N, T> {\n    pub fn view<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        pack_arguments(self.args);\n        let returns = context.call_private_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            true,\n        );\n        returns.unpack_into()\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PrivateStaticVoidCallInterface<N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PrivateStaticVoidCallInterface<let N: u32> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: (),\n    pub is_static: bool,\n}\n\nimpl<let N: u32> PrivateStaticVoidCallInterface<N> {\n    pub fn view(self, context: &mut PrivateContext) {\n        pack_arguments(self.args);\n        context\n            .call_private_function_with_packed_args(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                true,\n            )\n            .assert_empty();\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PublicCallInterface<N, T> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PublicCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args: [Field],\n    pub gas_opts: GasOpts,\n    pub return_type: T,\n    pub is_static: bool,\n}\n\nimpl<let N: u32, T> PublicCallInterface<N, T> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn call<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub unconstrained fn view<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub fn enqueue(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            false,\n        )\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PublicVoidCallInterface<N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PublicVoidCallInterface<let N: u32> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args: [Field],\n    pub return_type: (),\n    pub is_static: bool,\n    pub gas_opts: GasOpts,\n}\n\nimpl<let N: u32> PublicVoidCallInterface<N> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn call(self, context: &mut PublicContext) {\n        let returns = context.call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub unconstrained fn view(self, context: &mut PublicContext) {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub fn enqueue(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            false,\n        )\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PublicStaticCallInterface<N, T> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PublicStaticCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args: [Field],\n    pub return_type: T,\n    pub is_static: bool,\n    pub gas_opts: GasOpts,\n}\n\nimpl<let N: u32, T> PublicStaticCallInterface<N, T> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn view<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PublicStaticVoidCallInterface<N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PublicStaticVoidCallInterface<let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args: [Field],\n    return_type: (),\n    is_static: bool,\n    gas_opts: GasOpts,\n}\n\nimpl<let N: u32> PublicStaticVoidCallInterface<N> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn view(self, context: &mut PublicContext) {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n"
     },
     "81": {
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/context/private_context.nr",