@aztec/accounts 0.77.0 → 0.77.1

package/artifacts/SchnorrSingleKeyAccount.json

@@ -4,11 +4,142 @@
   "name": "SchnorrSingleKeyAccount",
   "functions": [
     {
-      "name": "verify_private_authwit",
+      "name": "process_log",
+      "is_unconstrained": true,
+      "custom_attributes": [],
+      "abi": {
+        "error_types": {
+          "16775516380094354375": {
+            "error_kind": "fmtstring",
+            "item_types": [],
+            "length": 40
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        },
+        "parameters": [
+          {
+            "name": "_log_plaintext",
+            "type": {
+              "fields": [
+                {
+                  "name": "storage",
+                  "type": {
+                    "kind": "array",
+                    "length": 18,
+                    "type": {
+                      "kind": "field"
+                    }
+                  }
+                },
+                {
+                  "name": "len",
+                  "type": {
+                    "kind": "integer",
+                    "sign": "unsigned",
+                    "width": 32
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "std::collections::bounded_vec::BoundedVec"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "_tx_hash",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "_unique_note_hashes_in_tx",
+            "type": {
+              "fields": [
+                {
+                  "name": "storage",
+                  "type": {
+                    "kind": "array",
+                    "length": 64,
+                    "type": {
+                      "kind": "field"
+                    }
+                  }
+                },
+                {
+                  "name": "len",
+                  "type": {
+                    "kind": "integer",
+                    "sign": "unsigned",
+                    "width": 32
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "std::collections::bounded_vec::BoundedVec"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "_first_nullifier_in_tx",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "_recipient",
+            "type": {
+              "fields": [
+                {
+                  "name": "inner",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": null
+      },
+      "bytecode": "H4sIAAAAAAAA/+Wc6XLbNhDHKZu0TcmyZPmK3Svp3bRpKYnU0dNt0/u+lM+KYz8HHyPta7Rf2qer/jFXWsHojDteTPxPMMOhpYV2f1wuARBYuBadl8nsqFV/x9V5vTrj+060XKTucXXOrla6hrqyUIw1AsYVAsZVAsaYgDEhYFwjYFwnYNwgYEwJGOsEjA0Cxk0CxiYB4xYBY4uAsU3AuB2AMQRnh4Rzx5BTj+1D8e5G1z9G9wgY9wkYDwgYbxAwHhIwHhEwPkPA+CwB43MEjM8TML5AwHiTgPEWAeOLBIwvETC+TMD4CgHjqwSMrxEwvk7A+AYB420CxjcJGN8iYLxDwPg2AeM7BIwZAWOXgLFHwNgnYMwJGAsCxgEB45CAcUTAOCZgfJeA8T0CxvcJGD8gYPyQgPEjAsZjAsaPCRg/IWD8lIDxLgHjZwSMnxMwfkHA+CUB41cEjF8TMH5DwPgtAeN3BIzfEzD+QMD4IwHjTwSMPxMw/hKAMQTnryScv5FwTgJxRvcc6JXZgY1b2BiFjUfY2IONM9iYgo0f2FiBjQvYGIDEeyS2I3G8PTuQ+IykYiTsIgkWSaZI4kSSJJIQkeSHJDokqSEJDElWSGJCktDN2XFrdiCJBEkaSIJAkgEW8bFIjkVoLPJiERWLlFgExCIbFrGwSISrwiIHFhEwSY9JcEwyYxIXk6SYhMQkHybRMEmFSSBMsmASQyYJ8JKLl0i8pOElCC8ZGMRjkIxBKAZ5GERhkIJBADpZdGLoJNAIo5FDI4KHFA8AgmsS/XeRIPmnOqfVeUXJDTfRdVPHrqX+UTa+n3quz5C/n1Y6N4LoL4aiPw3Dn8lG27vlQr++FrG7Wp0n5cKXk3KZSeo8VHUeOnXkesLc7zwP669ur+n4KFLXIrbrYWz3a449fV+0TOzXo5Cxeb4pWdsTHtc/0nY0pU654Kk5sri8eB0iS5RM7i/s3Fb13NjacGTCgiLx21S+kXKvksk9jZVOu3gtRmHjNc8eX7zm3ScxXmNHFpcXr+P/xquOLTdek2hRpC0V2ZqS/e7I1pXsj3Jhu1Acg+rvsG3yeR+snz3rPmzHw69toayXC39IDK6q7xLlv0f+0fUdWapkcblsp159jpUdrUs4Eqd+Xn1uVec19Rv5fdtjf82xv8Tt+c71S+qpn3rqI9buVH83qgMx9Jf8Jrr47OI4rj5nVyrDwtdO2ukfdH1toaH+U9HfCKK/l4n+zTD8836qGeb+DkT/Vhj+efy0wvD3RH87DP+Z6N8Owz9/j+kE0V/Mx+U7Yfjn8b8bxv9z/r0w/HP9+2H45/f3IIz+sYw7bkSL4o4zD9X3dv1/b3zZcabYrzusocaZhw6P6x89zoTsyMPa9sjcZ/TIY+fIY8ena9NQ14Ghrm1DXQ1DXfuGutqGuuqGuvYMdbUMdaWGuizvo6W/LGN111CXZaxuGeq6ru2E5fNo6fvrGqsbhrosY8IyVi39tWOoy7KNthwDNA11WfYdls/QdY2vp6H9CtEPhV0PzDLfPFhkp987D2aoPxNfS6zquW9tU64vcer/6fh5M4ife1N5J5M2SPvCN1dlabvm2Isi//us2G96eIS77pFd5R/Mno5OTsf383wwzIuifzKsOfqF1f1OzzvrPkfX970b++bVDH098q3xtJRfUWIl23JkiZIJo17j8c07WvJfxv/aftsjc8del72XnWg51vTz2IgWz3Bc2l/7cHTeljxirPQn0fIabuTYT5z6f1ef3bbuqs/I2XDaPetPz6bF9MGD/GTacfRrH8JP/wJJ9PoyCV0AAA==",
+      "debug_symbols": "tZbRCsIgGIXfxWsvpkt/61Uiwm0uBHHDbUGMvXsaUaOuz83YkV8/L/zgrKxzzXK7+tgPEzudVxaG1s5+iDmtG2dN8iH423W/zKryEUq/NkyjjSVPs00zO4laGsOZi135r2uTD+l9cCVVG/+bJ/keJvpMKrFdeAYQGmDQgCMYoCs0QKABEg2o0YADGqDQALTJGm2yRpus0SYT2mRCm0xokwltMqFNJrTJhDaZ0CYT1OQtp7tN3jbBvRtOv8R2V3jmx+h+us+YhtZ1S3KlBX0LUHmNB8mVLNcu9gpTcWFUhmTQEw==",
+      "brillig_names": [
+        "process_log"
+      ]
+    },
+    {
+      "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/7WTyw7CIBBFqcUo0sTEx39MU0y7dOHafyCtLHVRN+766dZkJkyI0QVwEzJMgMNcHoXwKjBKESGCHDEqjAs2Xs7tjDnEqVbBvin5HRijvvhLWH+jkFnk4QPxM50/rJBzmTyfe6F913PTrF8J/z5y+af7y+l//8OzRq9bzCvh/8P4uvfXx/M2ij/SbJGc0ptoOwAqvkT+EvmhJBvn8w+Yb4Svj6KMqNO1tnaNdfZkh8H0dhfwP+KH/QbzqHp4zgQAAA==",
+      "debug_symbols": "ZY5bCoMwEEX3Mt/5MGoF3YoUiTpKICQhj0IJ2XsnIjS0P5e5w+FyEuy4xnOR+jAepjmBMpsI0mhqKTNYnVRKnkv9hqYE7y7eW6FL9UG4ABPvxnZggHq/7mGkjUMqLK3J7I8n/KZ7zr/s0OdnpvoSTopV4W1zRL1VcuFt8cfTOrPhHh0W40qWcuYP1jY0S9Mf",
+      "brillig_names": [
+        "sync_notes"
+      ]
+    },
+    {
+      "name": "entrypoint",
       "is_unconstrained": false,
       "custom_attributes": [
-        "private",
-        "view"
+        "private"
       ],
       "abi": {
         "error_types": {
@@ -20,18 +151,14 @@
             "error_kind": "string",
             "string": "Stack too deep"
           },
-          "19458536156181958": {
-            "error_kind": "string",
-            "string": "Function verify_private_authwit can only be called statically"
-          },
-          "4939791462094160055": {
-            "error_kind": "string",
-            "string": "Message not authorized by account"
-          },
           "5019202896831570965": {
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
+          "5727012404371710682": {
+            "error_kind": "string",
+            "string": "push out of bounds"
+          },
           "6485997221020871071": {
             "error_kind": "string",
             "string": "call to assert_max_bit_size"
@@ -520,9 +647,173 @@
             "visibility": "private"
           },
           {
-            "name": "inner_hash",
+            "name": "app_payload",
             "type": {
-              "kind": "field"
+              "fields": [
+                {
+                  "name": "function_calls",
+                  "type": {
+                    "kind": "array",
+                    "length": 4,
+                    "type": {
+                      "fields": [
+                        {
+                          "name": "args_hash",
+                          "type": {
+                            "kind": "field"
+                          }
+                        },
+                        {
+                          "name": "function_selector",
+                          "type": {
+                            "fields": [
+                              {
+                                "name": "inner",
+                                "type": {
+                                  "kind": "integer",
+                                  "sign": "unsigned",
+                                  "width": 32
+                                }
+                              }
+                            ],
+                            "kind": "struct",
+                            "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector"
+                          }
+                        },
+                        {
+                          "name": "target_address",
+                          "type": {
+                            "fields": [
+                              {
+                                "name": "inner",
+                                "type": {
+                                  "kind": "field"
+                                }
+                              }
+                            ],
+                            "kind": "struct",
+                            "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+                          }
+                        },
+                        {
+                          "name": "is_public",
+                          "type": {
+                            "kind": "boolean"
+                          }
+                        },
+                        {
+                          "name": "is_static",
+                          "type": {
+                            "kind": "boolean"
+                          }
+                        }
+                      ],
+                      "kind": "struct",
+                      "path": "authwit::entrypoint::function_call::FunctionCall"
+                    }
+                  }
+                },
+                {
+                  "name": "nonce",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "authwit::entrypoint::app::AppPayload"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "fee_payload",
+            "type": {
+              "fields": [
+                {
+                  "name": "function_calls",
+                  "type": {
+                    "kind": "array",
+                    "length": 2,
+                    "type": {
+                      "fields": [
+                        {
+                          "name": "args_hash",
+                          "type": {
+                            "kind": "field"
+                          }
+                        },
+                        {
+                          "name": "function_selector",
+                          "type": {
+                            "fields": [
+                              {
+                                "name": "inner",
+                                "type": {
+                                  "kind": "integer",
+                                  "sign": "unsigned",
+                                  "width": 32
+                                }
+                              }
+                            ],
+                            "kind": "struct",
+                            "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector"
+                          }
+                        },
+                        {
+                          "name": "target_address",
+                          "type": {
+                            "fields": [
+                              {
+                                "name": "inner",
+                                "type": {
+                                  "kind": "field"
+                                }
+                              }
+                            ],
+                            "kind": "struct",
+                            "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+                          }
+                        },
+                        {
+                          "name": "is_public",
+                          "type": {
+                            "kind": "boolean"
+                          }
+                        },
+                        {
+                          "name": "is_static",
+                          "type": {
+                            "kind": "boolean"
+                          }
+                        }
+                      ],
+                      "kind": "struct",
+                      "path": "authwit::entrypoint::function_call::FunctionCall"
+                    }
+                  }
+                },
+                {
+                  "name": "nonce",
+                  "type": {
+                    "kind": "field"
+                  }
+                },
+                {
+                  "name": "is_fee_payer",
+                  "type": {
+                    "kind": "boolean"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "authwit::entrypoint::fee::FeePayload"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "cancellable",
+            "type": {
+              "kind": "boolean"
             },
             "visibility": "private"
           }
@@ -1615,175 +1906,48 @@
                               ],
                               "kind": "struct",
                               "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
-                            }
-                          }
-                        ],
-                        "kind": "struct",
-                        "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings"
-                      }
-                    }
-                  ],
-                  "kind": "struct",
-                  "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext"
-                }
-              }
-            ],
-            "kind": "struct",
-            "path": "authwit::aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs"
-          },
-          "visibility": "databus"
-        }
-      },
-      "bytecode": "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",
-      "debug_symbols": "7Z3bjtxG0oTfRde6YFVlnfwqi8VCtrULAYJk+PADPwy/+3aPRHZPN1XccQzZqczYi4XHrq7J/MhOZpCcyD/f/Pz+xz/+868Pn/79+bc3P/zjzzcfP//07vcPnz+dfvrzTYhP/+63X959Ov/42+/vfv39zQ9Rcn/75v2nn8//WPNfb9/8+8PH929+CLH/9fZ+dSx1Xh1bv6yewtrqLu3r6jTFsLE65J7l6/LTP5e2rI8tru0eYpljCXKJPPa1yEMqad5cwvRs9T/fvgmJcL4NRwjn23Ay4XwbTlmFk3q6wGkbcCTEGY6EkpbVLTz9hrr7b2hrvyGEUvOceajx+SE+f6yvfaxPM9yeyvKRsnogeozLYe71sljWFk+1LCfc1Ker5XlleYthDr7FHDdOidplXl17TxurU55TlHh1QuTV877PKcY05fHikMK8OKQUNhZPYcYRputzPp+PTZx4bNQem8Bjo/bYRB6bzWNTF4KxprSBu9Z541B7ho5N4rFRe2yEx0btscngsUkhz91jCldEVo9NiG1pxk91+XrncyxFUSxVUSxNUSxdTyxpUhRLUBRLVBRLUhSLKIpFUd1NiupuUlR3k6K6mxTVXVFUd0VR3RVFdVcU1V1RVHdFUd0VRXVXFNVdUVR3RVHdzYrqblZUd7OiupsV1d2sqO5mRXU3K6q7WVHdzYrqblZUd4uiulsU1d2iqO4WRXW3KKq7RVHdLYrqblFUd4uiulsU1d2qqO5WRXW3Kqq7VVHdrYrqblVUd6uiulsV1d2qqO5WRXW3Kaq7TVHdbYrqblNUd5uiutsU1d2mqO42RXW3Kaq7TVHd7YrqbldUd7uiutsV1d1+bN1N8RJLmcY7R5nXxqtXzs5/XHC3tPQpfF1beri8rRfayuJ22bjFEq8Xn4FkAnkOpBDIcyCVQJ4DaQTyHEgnkGdAwjSRyA2RQCI3RCKJ3BBJJHJDREjkhgj71VsibFhvibBjvSXClvWWCHvWGyKBPestEfast0TYs94SYc96S0RI5IYIe9ZbIuxZb4mwZ70lwp71lgh71hsikT3rLRH2rLdE2LPeEmHPektESOSGCHvWWyLsWW+JsGe9JWKiZ61xsYut8fybb5I00YZuJJlMdJZbSZpoFmvss1tbTeE+SRP931aSJlq6rSTFQ5ImGq+tJE30UlvV1UR7tJWkh44nGel4ht9JMdLxjJP00PGIh45HPHQ8B9vAPShJDx2PeOh4xEPHIx46HvFwjyd7uMeTPXQ82UPHkz10PAcbMD4oSQ8dTzbS8YyTNNLxjJM00vGMk/Rwj6d46HiKkY5nnKSRjmecpJGOZ5ykeEjSQ8dTPHQ8xUPHUzx0PMVDx1M9PNWqHu7xVA/3eKqHezwHmw4/puOpRjqecZIenmpVD0+1qoenWtVDx9M8dDzNQ8fTPHQ8zUPHc7Dd94OS9HCPp3m4x9M83ONpHjqe5uE9nu7hqVb38FSre3iq1T10PDaM9reS9NDx2DDE30rSQ8djw7h+K0kH93iiDX/5rSQd3OOJNlzgxx1PtGHsvpWkeEjSwVOtaMNRfStJBx1PtOF7vpWkh47Hhjv5VpIeOh4bHuJbSTq4xxNtOH1vJengHk+04ce90fHYsNjeStLBU61owwh7I0kb3tZbSXroeGw4UG8l6aHjseETvZWkh47HhpvzVpIe7vFY8VweJ+nhHo8Hz+VoxXN5nKSHp1pWPJfHSYqHJD10PFY8l8dJeuh4rHguj5P00PF48FyOHjyXowfP5ejBczla8VwedjxWPJfHSXp4quXBczl68FyOVjyXh9XViufyOEkPHY8Hz+XowXM5evBcjh48l6MHz+XowXM5WvFcHnY8VjyXh0l68FyOHjyXowfP5WjFc3lYXa14Lo+T9NDxePBcjh48l6MHz+XowXM5evBcjh48l6MVz+Vhx2PFc3mcpHhI0sNTLQ+ey9GK5/K4unroeDx4LkcPnsvRg+dy9OC5HD14LkcPnsvRg+dytOK5POx4rHguj5P08FTLg+dy9OC5HK14Lg+rqxXP5XGSHjoeD57L0YPncvTguRw9eC5HD57L0YPncrLiuTzqeJIVz+Vxkg6eaiUPnstpEg9JOuh4khXP5XGSDjqe5MFzOXnwXE4ePJeTB8/l5MFzOXnwXE5WPJeHHY8Vz+Vxkg6eaiUPnsvJg+dysuK5PKyuVjyXx0l66Hg8eC4nD57LyYPncvLguZw8eC4nD57LyYrn8rDjseK5PEzSg+dy8uC5nDx4LicrnsvD6mrFc3mcpIeOx4PncvLguZw8eC4nD57LyYPncvLguZyseC4POx4rnsvjJMVDkh6eannwXE5WPJfH1dVDx+PBczl58FxOHjyXkwfP5eTBczl58FxOHjyXkxXP5WHHY8VzeZykh6daHjyXkwfP5WTFc3lYXa14Lo+T9NDxePBcTh48l5MHz+XkwXM5efBcTh48l5MVz+Vhx2PFc3mcpIenWh48l5MHz+VkxXN5XF09dDwePJeTB8/l5MFzOXnwXE4ePJeTB8/l5MFzOVnxXB52PFY8l8dJeniq5cFzOXnwXE5WPJeH1dWK5/I4SQ8djwfP5eTBczl58FxOHjyXkwfP5eTBczlZ8VwedjxWPJdHSYoHz2Xx4LksHjyXxYrn8qi6yiQeknTQ8YgHz2Xx4LksHjyXxYPnsnjwXBYPnstixXN52PFY8VweJykeknTwVEs8eC6LFc/lcXX10PF48FwWD57L4sFzWTx4LosHz2Xx4LksHjyXxYrn8rDjseK5PE7SwVMt8eC5LB48l8WK5/KwulrxXB4n6aHj8eC5LB48l8WD57J48FwWD57L4sFzWax4Lg87Hiuey+MkPTzV8uC5LB48l8WK5/K4unroeDx4LosHz2Xx4LksHjyXxYPnsnjwXBYPnstixXN52PFY8VweJ+nhqZYHz2Xx4LksVjyXh9XViufyOEkPHY8Hz2Xx4LksHjyXxYPnsnjwXBYPnstixXN52PFY8VweJunBc1k8eC6LB89lseK5PKyuVjyXx0l66Hg8eC6LB89l8eC5LB48l8WD57J48FwWK57Lw47HiufyOEnxkKSHp1oePJfFiufyuLp66Hg8eC6LB89l8eC5LB48l8WD57J48FwWD57LYsVzedjxWPFcHifp4amWB8/l7MFzOVvxXB5V12zFc3mcpIOOJ0/iIUkHHU/24LmcPXguZw+ey9mD53K24rk87HiseC6Pk3TwVCt78FzOHjyXsxXP5XF19dDxePBczh48l7MHz+XswXM5e/Bczh48l7MHz+VsxXN52PFY8VweJ+ngqVb24LmcPXguZyuey8Pq6sFzOVvxXB4n6eEejxXP5XGS4iFJD/d4rHguj4+kh47HiufyOEkP7/F48FzOVjyXh9XViufyOEkP93iseC6Pk7TR8UjMc5IS612SejuePM0b5ybjJENsfdk3hWVxqtOXLPW2PC/KMrdLluU+S709z0uylBTnfUXyfZZ6m55XzFKx7/JrZqm37XnNLPX2Pa+Zpd7G5zWzFBtZ5mnJsqT7LPW2Pq+ZpY3eZytLG73PVpZGep+NLI30PuMsFTswv+xKEi5Zyn2WRnqfuigv6fE+SyO9z0aWRnqfjSzFRZZGep+NLI30PhtZGul9+rw25DDdZ2mk99nI0kjvM85SsRfza2ZppPfZyNJI77ORpZXep12yvH+CoNiP+SVZnu6ez/uW8Fx5rTxlmtqsYGK4eaqykmAtS4Ltau9QvgC00VY9EKCNju2BAG00gw8EaKPPfCBAGy3sngBbn1enfg9QsW/3dwLQRuP9QIA2evoHArQhFx4IUAgQA0glAgKkEgEBelQiMS4AY+kbq0+3Y/Lldsxl77h+bMKy9ZTaeHGKfaaRUqrXi58OjUeNo+XQyDS/e5Uky92h8aievo9vjeLpAt6/NYpnIrj/1njUkt/Jt8ajSt3x0KQ4P12LqbY72uKRds8LkjhtrC59mo9N6eHZX3HdL26XPw9rscTrxU+0Perfx9H2KJYfR9ulsn4YbZdi+WG0XerfB9EuisfHWKTtUqU+jLZL4fkw2i615MNoC2kfSJta8kja1JJH0qaWPJI2teSRtKklD6SteDCXRdrUkkfSppY8kja15JG0hbQPpE0teSRtaskjaVNLHkmbWvJI2tSSB9JWPPLQIm1qySNpU0seSZta8kjaQtoH0qaWPJI2teSRtKklj6RNLbmxejzaqigey/p9AFQ88vU7AUgRtwlwNAmrKB5V+50ApNQCAQoBYgApiECA1DjgVZiyBQRIJQICpBLBaqDiUczfCUAqERAglQgIkEoEBCgEiAGkEgEBUolgfaCRaeAPBEglAgKkEsEAGhmP/kCAVCLYVdjIUPcHAqQSAQEKAWIAqURAgFQiIEAqERAglQgIkEoEA1ioRDAlUqhEQIBUIiBAKhEQoBAgBpBKBLwKU4mAAKlEQIBUIiBAKhEMYKUSAQFSiYAAqURAgFQiIEAhQEiJVCoRECCVCAiQSgQESCUCAqQSwa7CjUoEBEglAgKkEgEBUomAAIUAMYBUIiBAKhEQIJUICJBKBFMijUoEA9ipRECAVCIgQCoRECCVCHYV7kKAGEAqERAglQgIkEoEBEglAgKkEoEA1olKBARIJQICpBKBlEidqERAgEKAGEAqERAglQgIkEoEvApTiYAAqUQwgIFKBARIJQICpBIBAVKJgACFADGAVCIgQCoRTIkEKhEQIJUICJBKBAPIWfYoQCoR7CrMifMoQCoREKAQIAaQSgQESCUCAqQSAQFSiYAAqUQwgJyxDioRzlhHAVKJgACpRECAQoAYQCoR8CpMJQICpBIBAVKJgACpRDCAnLGOAqQSAQFSiYAAqURAgEKAkBLhjHUUIJUICJBKBARIJQICpBLBrsKcsY4CpBIBAVKJgACpRECAQoAYQCoRECCVCAiQSgQESCWCKRHOWAcBcsY6CpBKBARIJQICpBLBrsKcsY4CpBIBAVKJgACpRECAVCIgQCoRDCBnrKMAqURAgFQimBLhjHUUoBAgBpBKBARIJQICpBIBr8JUIiBAKhEMIGesowCpRECAVCIgQCoREKAQIAaQSgQESCWCKRHOWEcBUomAAKlEMICcsY4CpBLBrsKcsY4CpBIBAQoBYgCpRECAVCIgQCoRECCVCAiQSgQC2DhjHVMijTPWUYBUIiBAKhEQoBAgBpBKBLwKU4mAAKlEQIBUIiBAKhEMIGesowCpRECAVCIgQCoREKAQIKREOGMdBUglAgKkEgEBUomAAKlEsKswZ6yjAKlEQIBUIiBAKhEQoBAgBpBKBARIJQICpBIBAVKJYEqEM9ZBgJyxjgKkEgEBUomAAKlEsKswZ6yjAKlEQIBUIiBAKhEQIJUICJBKBAPIGesoQCoRECCVCKZEOGMdBSgEiAGkEgEBUomAAKlEwKswlQgIkEoEA8gZ6yhAKhEQIJUICJBKBAQoBIgBpBIBAVKJYEqEM9ZRgFQiIEAqEQwgZ6yjAKlEsKswZ6yjAKlEQIBCgBhAKhEQIJUICJBKBARIJQICpBLBAHLGOqhEOGMdBUglAgKkEgEBCgFiAKlEwKswlQgIkEoEBEglAgKkEsEAcsY6CpBKBARIJQICpBIBAQoBQkqEM9ZRgFQiIEAqERAglQgIkEoEuwpzxjoKkEoEBEglAgKkEgEBCgFiAKlEQIBUIiBAKhEQIJUIpkQ4Yx0D2DljHQVIJQICpBIBAVKJQFfhPgkBYgCpRECAVCIgQCoRECCVCAiQSgQDyBnrKEAqERAglQimRDhjHQUoBIgBpBIBAVKJgACpRMCrMJUICJBKBAPIGesoQCoRECCVCAiQSgQEKASIAaQSAQFSiWBKhDPWUYBUIiBAKhEMIGesowCpRLCrMGesowCpRECAQoAYQCoRECCVCAiQSgQESCUCAqQSwQByxjqoRDhjHQVIJQICpBIBAQoBYgCpRMCrMJUICJBKBARIJQICpBLBAHLGOgqQSgQESCUCAqQSAQEKAUJKhDPWUYBUIiBAKhEQIJUICJBKBLsKc8Y6CpBKBARIJQICpBIBAQoBYgCpRECAVCIgQCoRECCVCKZEOGMdBMgZ6yhAKhEQIJUICJBKBLsKc8Y6CpBKBARIJQICpBIBAVKJgACpRDCAnLGOAqQSAQFSiWBKhDPWUYBCgBhAKhEQIJUICJBKBLwKU4mAAKlEMICcsY4CpBIBAVKJgACpRECAQoAYQCoRECCVCKZEOGMdBUglAgKkEoEAholD1mGC1CLQdfhEkGIEJUg1ghIUEgQJUo+gBClIUIJUJChBShKUIDUJSJDj1lFNwnnrMEFqEpQgNQlKUEgQJEhNgl6LqUlQgtQkKEFqEpQgNQlIkIPXYYLUJChBahKUIDUJSlBIENMknL4OE6QmQQlSk6AEqUlQgtQk4LWYI9jRc5Az2GGC1CQoQWoSlKCQIEiQmgS9FlOToOcgNQlKkJoEJUhNAhLkMHaYIDUJeC3mOHaYIDUJSlBIECRITbJFUOK8+vSP9Z6gR01y2TnmWJ6t/gLFhswosS5QJKykaUMLlDbN+9YwraRpo2HfStPIYPHNNG20vptp2uhPN9O00URupik+0rTRjm2maaNn2kzTSBe0laaPLsjIuOStNI0MNd5M00cXZGRA8GaaProgI8N2N9P00QUZGVy7maaPLsjIENjNNH10QUYGqm6m6aMLMjKcdDNNH12QkUGfm2n66IKMDM3cTNNHF2RkAOVmmj66IM3DHHv4urbkME4zhTotQbRLxHE1ijTFuKyWdoEytZXVLYb57YB2ehR+2butBV27LO8S9Csc66tTnjnL1VsKMa8sjbHPQcc05fHikEJcOKewsXgKy4sBJ41zvfjLKaK4g+QpouMUUdx98xTRcYooVi48RXScIsJThKfI+BRRrJh5iug4RRTfbeApouMUUXynhqeIjlNE8V0uniI6ThHFdwh5iqg4RTQPqOYpouMU4d1VniIbpwjvrvIU2ThFeHeVp8jGKSI8RXiKjE8R3l39Tk6RuhzIWFPaOOq1zhuH2jN4ivDuKk+RjVPExt3VGJYgUm0bpwgPuo37pTzoLzroNu6A8qC/4KCHycY9TVmMf5LUsHHQoyzeSVHalUNUWVscZG4uTufK1eL6FaCNO347AozTsjimeA1wJeSavq7NvV+Wtq+sbdw625N1XpzS4lXx+zusbdyD2pF1KounWrrKbykMQoBjgNJny9eYUx2frCG35c5ImaZ72jZudnwvtG3cN9BCu8a2NHRXQf+dqm1DrRs8MDYUtZoDUy9/CPf82vviA2ND9do7MMGIMl3Uz+nAxI0DI7I8/5HT/8YHJtWlAU3tygL4tPgLQCPKdD+AbQkj9TWARuTm4wAa0ZCPAygEiAE0IgsfB9CI0nscQCOK7HEAjSinxwE0onAeBjAaVCJbb8mcZ5bNUUxXgnIVYA59DjnHIPcADSqRYwEaVCLHAjSoRI4FKAQ4BhilLABLuQdoUIkcC9CgEjkWoEElcixAg0rkdQGWOoeRa9joumtJM7ha2krXbVC26KWdqHE2aLew0G5Xb4r+PdoURK9Ku88wag3hnjbV05G0j5VasV1oh3i985doRFU0fBzx18atOJnfCUgt1/uTi48jQICvKQLiFK4BfvkFq01ynpa/gs2nh3KXsGJfKzGydDY1h0tALawFVOZXnuXqGxfyKZ7TTz/++uHjxw//+dfHzz+9+/3D50+/nT85nf9v/VSqbX7ZpV29q17WfrEsf4aRr24alyfQ65hfa/O25+Z9x81l2nPzsOfmqz1ES8vmV9fY1c3Tsnmq9XrpefO05+ay5+Z5z83LnpvXPTdve27ed9x8fab2a20e9tx8z29o3vMbmvf8huY9v6F5z29o3vMbmvf8huY9v6EFPaAyzU2tTOV2cxRLlkVJljpeWqZ51xKvbrb2p0aydCWB1ElLIEFLIFFLIElLIKIlkKwlkKIlkKolEC2VtWqprE1LZW1aKmvTUlmblsratFTWpqWytiPriMjKLc2vgfQjvzVlvntYrjxM5kDgb83iGJOvdl9vzHtPS/N81T2fzcPOoSQ9ochxociUwhLK1R3qOZSsJ5SiJ5R6ZCi1L6H0eBdK0xNKf0wo4crl4Gso3/BGelAsQVEsBxZciWHeVuKVI+oSS1IUiyiK5ciaG6+czkq/j6UoiqUqiuXIspsud/1SqPexdD2xhElRLOFBscR8H0tUFEtSFMuRdVeW9ytEcrmPJSuKpSiK5ci6K21pvKXLfSxNUSxdTyzxyLqb49JjZon3sQRFsURFsaQHxZLvdUAURbFkRbEcWXdLWXrMUu97zFgVxdIUxXJk3a2X/qWGdhdLmhTFEhTFcmTdrXnpX2q51wEpKYpFHhRLve+9U1YUS1EUy25192n3tuvufc/dZdp1d7R+lcUaseR+t3vcdfe05+75yOf+oweHoRz54H/5S4LSyn0kQU0kUU0kSU0koiaSrCaSoiaSI9+sGj3/D4e+tDqOpGuJ5NDXVseRaHlPJBz64uo4kqQmElETSVYTSVETiZoaW9XU2KqmxsKva47+EiPA72BePZEp+W539Hsv6XJ/7T72vOvuZdfd6667t11373vu3qdddw+vt3uNd7vHXXdPu+4Of1fj8tzvarjgvHvedfey6+51193brrv3HXeP8LuL493DrrvHXXdPu+4uu+6ed919v+/q6YdwXrj+GkiYFv+hMKUrd5C1qTGXh0Y1PJsm+XQB3Hf7jm+f5qasSr/Zfv39ixduPzestdyOJFx/peJl27f5BnPtt6NQ19+SeL3tE7x9i/NFtsntoV1/l+GF2y+jhK9egPq6fca3r/Ohbfdwyitu32/O+9MP8em7u/5LwrSMCgxT+9++MWGZoxxCKePAzkPtLqunfvUr2lNw6bx43eUkX3zNrt7TePIG+pZ3yfgj5eUfqS//SHvhR/46/fh/73798O7Hj+/PBkfn//rHp59mv6PTj7///y/zf5kdkX759fNP73/+49f3Z2+kiy3SuQbF2N/GPP3zie0/zvN7Y+jno/nlP05vY8znH8PTj+X0Y7tU+POaNL1N+XLiPH2svk1xOVznfVN4K2HeNU9v8+kTf52S+S8=",
-      "brillig_names": [
-        "get_auth_witness",
-        "decompose_hint",
-        "lte_hint",
-        "store_in_execution_cache_oracle_wrapper",
-        "directive_to_radix",
-        "directive_invert",
-        "directive_integer_quotient"
-      ],
-      "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAFAAAABgAAAAcAAAAIAAAACQAAAAoAAAALAAAADAAAAA0AAAAOAAAADwAAAAAAAAAAACiPlV8hjnKRdGhPUZHUZgYpY1545ebNTWU7wnpm6YI1LSjJqLFoYUq6DVDUeGYw7cAEfeYcHgs8C7lQR8jGiOQm1onSGQ0igOFVdSfW7vugawIel99cf/5lYMYXU5Sv+yeCWG1HA50eXDM7E2lIC41aouqzHnmhBQM1x8XMmbJ/DWooGAzxKFSL/6gwa6J7dDw6O1sbnO7rlz2ppbhXh98rfBbHtwUvryaApXOZl5GIXycZAn2iWRB96KYtuiZb8gbiddPauRNq14ZXskcLyKd+ElgF2nS7mbPQSCOpF+SuBLmn33jNtBvnO7O29Qh6yeLeE8r0ljDx0VpfrdeLVmoqsvUVlfIGRVtx7qTbt87erkrrv0uj2huc4fSGWjxBFhYvq7cImP/V8MNIMD/Ge/8pu0da85dGSJXjkOTDu092L4Xc7ZBFghtWreFD09dL93eDckaxDAFTjgf4BpTi0iUkdxStWtf4fcPMeJZ0hBGwMKz2ZFNniLLZCejecJ5kXQRWu3AbWwtGO7zwxP5xkFUjk9CVM+GyAEvYTp+KU6iPA4D05rswR3a/1Psi4gmHdBVkgemj+PCR0w2xADptqrQNVrvvFHJ4/cBX+aM22YTQoACAzY80ug43VGwQJmXI/ikfu+C39vKCPVRpz5gaHvEfPq7YcmAmIR0u4Pg+MuRTJFneFFyD919tXO+hj2U4DEgO9grPnhHaakksrwCqJforSIOtHNTfUmm1eKctW6qQcv+sUkawTIOQiUVRLGJ9oSHg0Yy0nhk7HbkPxqvEeM+Wj3Ld4RsQfQDWzmCdEI28J8BHSR/uwq3NIAZ2AYAghogPw2PFjAMT9S3dB42VxkgL8tk8RlWiMnZAHemXBl5+Bn3K7Ey/nwDDDvP12aZ7hgZXScNkI75sewVh9PzCUKT5vUC4zboBHeMLUiMq2WJyJVUIHpC+NywbUxAv6gU7IJpihfVdfTpwNN3r+dCKDaYHbL6FYXV0gaZPUfxv0EcYYu6pAgzMQ5OCNjEAZlyZ0xLZ8guns9X8N9VuyBRf5UByz5gr0skY9TOdWe5FOK50AHPtO7NoyGCb8JFn0KLn8wpuu3oh0ENsb9UQLXxCwvAK8L1gS0e3t2rLeKNfxRMimEoOh+BKsJC5g7Mmy19c4SP7Yd6m5JkYl/R6IUnZFLk7Mdydra5I0rlUM7PhFM5FFU0cv4YQP6DXrPRreiFHuvkOIm/B1i/cDUzl2CGaw/8PoybtbTV77tyTXARQ3R2SzGEHHbcpAUIgxZNPGmsygiDKVgQkmwXAP2b/dz4QvSL3AMnzyk7z1RMrFUSj5gpbHR0PbcO9Vu5FsQTDv5MuUhiMiS8/TFHPtTo6eOrZr6MQ0InMEgKPJtXyi0ufKHw8XwDWlQqaRY/KQvdKtd1pHRtQ6WZxduYORCY7SbOI1py88Giq87VLC+dFvsAvsNgsCOULc9qzmvSeL3QT8R3yq7ly4Y4sXC8jG1YmhXOqZ0wn6DTIXbEk1WnHtzfdGAM2vdGVkkmnFXIQyliGQ45EmAAM4h096VkmFojAqzbjYoo3j5+3tW5m+v6AKL+03aSiC02dxRNuR1bFqtV4kgRjta9u7qzSZ0qVRMCA49zyhnUSRxxz2b/lnjJG1ywkns0221yIWTOCkk0jCgyds/RumxUQQC1Dv1CMeWPUEXpSfsz8dn/sBiTJoRJbE8mmvWPhBDHNyXfKyeTrdAvx6z/pZqyICm5p79+CCSZBmzZEytYAk8Hgb94hwvCmwMEm1ole13dVzjJlRFv35u5IRj4YSAK/RM8EEneR3YKZOsonm7N0vC/Q4YOrssNPFfCMWZVbBdq3lYs72TzVNnMFypsj+OKSn6WBhJDHX9nmjprghnwKhQGeElJpkxLL1exqI7KEqbNSfNLr/2KyRaBKqyWPkhu6Gm5J8LpmZD6LMv0JDgC17ucjNkMMP+t9pri1fhVRALNOAIK8Wu2BmoG7NnRMTWEsgPyRommqqql1yEyOWNYAE66jvMCEHsbZSyhfG+u+uWng8seFYnDcX9osXTmdzALZ8EZe9LKxFtS4hiU0TyZxeCqTNyqtNpUwrkt1wivbJl8McFNuwC98m+TOGcKdJumDmULXKSAUH+vasH5MIMMngHpPeyPZzByGXvmTCZk6M56MuMZI0Hw03ctO9EUngwy/nW4Lb6pgndvVgX9dELxP2BDHgdeyOaR6CGNhaG7cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAhN89ebDOTmbb5Oc8VbcYl7eq01OyuvYaethFsMK69N1HofN404S/fYzJEmvB0jSEdB1hdj9h3Wf8XX2Z/CshccAxDcm91tv2g3iLODg36trzHoF/5WpayiUJMX3M2cNli+bbgtOLAGWjeXDJIKqfR0KCdcXjsk7rXhY+W5k8LSNHViqYcZK1SIEPXnEgCIZ5Vuhl1Gt/mw2Mk0/tsLaCYktfBipPD2uWICfqu7GqGp49LO8YfGdbnBpNZu/R+f5Bw=="
-    },
-    {
-      "name": "process_log",
-      "is_unconstrained": true,
-      "custom_attributes": [],
-      "abi": {
-        "error_types": {
-          "16775516380094354375": {
-            "error_kind": "fmtstring",
-            "item_types": [],
-            "length": 40
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        },
-        "parameters": [
-          {
-            "name": "_log_plaintext",
-            "type": {
-              "fields": [
-                {
-                  "name": "storage",
-                  "type": {
-                    "kind": "array",
-                    "length": 18,
-                    "type": {
-                      "kind": "field"
-                    }
-                  }
-                },
-                {
-                  "name": "len",
-                  "type": {
-                    "kind": "integer",
-                    "sign": "unsigned",
-                    "width": 32
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "std::collections::bounded_vec::BoundedVec"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "_tx_hash",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "_unique_note_hashes_in_tx",
-            "type": {
-              "fields": [
-                {
-                  "name": "storage",
-                  "type": {
-                    "kind": "array",
-                    "length": 64,
-                    "type": {
-                      "kind": "field"
-                    }
-                  }
-                },
-                {
-                  "name": "len",
-                  "type": {
-                    "kind": "integer",
-                    "sign": "unsigned",
-                    "width": 32
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "std::collections::bounded_vec::BoundedVec"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "_first_nullifier_in_tx",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "_recipient",
-            "type": {
-              "fields": [
-                {
-                  "name": "inner",
-                  "type": {
-                    "kind": "field"
-                  }
+                            }
+                          }
+                        ],
+                        "kind": "struct",
+                        "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings"
+                      }
+                    }
+                  ],
+                  "kind": "struct",
+                  "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext"
                 }
-              ],
-              "kind": "struct",
-              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": null
-      },
-      "bytecode": "H4sIAAAAAAAA/+Wc6XLbNhDHKZu0TcmyZPmK3Svp3bRpKYnU0dNt0/u+lM+KYz8HHyPta7Rf2qer/jFXWsHojDteTPxPMMOhpYV2f1wuARBYuBadl8nsqFV/x9V5vTrj+060XKTucXXOrla6hrqyUIw1AsYVAsZVAsaYgDEhYFwjYFwnYNwgYEwJGOsEjA0Cxk0CxiYB4xYBY4uAsU3AuB2AMQRnh4Rzx5BTj+1D8e5G1z9G9wgY9wkYDwgYbxAwHhIwHhEwPkPA+CwB43MEjM8TML5AwHiTgPEWAeOLBIwvETC+TMD4CgHjqwSMrxEwvk7A+AYB420CxjcJGN8iYLxDwPg2AeM7BIwZAWOXgLFHwNgnYMwJGAsCxgEB45CAcUTAOCZgfJeA8T0CxvcJGD8gYPyQgPEjAsZjAsaPCRg/IWD8lIDxLgHjZwSMnxMwfkHA+CUB41cEjF8TMH5DwPgtAeN3BIzfEzD+QMD4IwHjTwSMPxMw/hKAMQTnryScv5FwTgJxRvcc6JXZgY1b2BiFjUfY2IONM9iYgo0f2FiBjQvYGIDEeyS2I3G8PTuQ+IykYiTsIgkWSaZI4kSSJJIQkeSHJDokqSEJDElWSGJCktDN2XFrdiCJBEkaSIJAkgEW8bFIjkVoLPJiERWLlFgExCIbFrGwSISrwiIHFhEwSY9JcEwyYxIXk6SYhMQkHybRMEmFSSBMsmASQyYJ8JKLl0i8pOElCC8ZGMRjkIxBKAZ5GERhkIJBADpZdGLoJNAIo5FDI4KHFA8AgmsS/XeRIPmnOqfVeUXJDTfRdVPHrqX+UTa+n3quz5C/n1Y6N4LoL4aiPw3Dn8lG27vlQr++FrG7Wp0n5cKXk3KZSeo8VHUeOnXkesLc7zwP669ur+n4KFLXIrbrYWz3a449fV+0TOzXo5Cxeb4pWdsTHtc/0nY0pU654Kk5sri8eB0iS5RM7i/s3Fb13NjacGTCgiLx21S+kXKvksk9jZVOu3gtRmHjNc8eX7zm3ScxXmNHFpcXr+P/xquOLTdek2hRpC0V2ZqS/e7I1pXsj3Jhu1Acg+rvsG3yeR+snz3rPmzHw69toayXC39IDK6q7xLlv0f+0fUdWapkcblsp159jpUdrUs4Eqd+Xn1uVec19Rv5fdtjf82xv8Tt+c71S+qpn3rqI9buVH83qgMx9Jf8Jrr47OI4rj5nVyrDwtdO2ukfdH1toaH+U9HfCKK/l4n+zTD8836qGeb+DkT/Vhj+efy0wvD3RH87DP+Z6N8Owz9/j+kE0V/Mx+U7Yfjn8b8bxv9z/r0w/HP9+2H45/f3IIz+sYw7bkSL4o4zD9X3dv1/b3zZcabYrzusocaZhw6P6x89zoTsyMPa9sjcZ/TIY+fIY8ena9NQ14Ghrm1DXQ1DXfuGutqGuuqGuvYMdbUMdaWGuizvo6W/LGN111CXZaxuGeq6ru2E5fNo6fvrGqsbhrosY8IyVi39tWOoy7KNthwDNA11WfYdls/QdY2vp6H9CtEPhV0PzDLfPFhkp987D2aoPxNfS6zquW9tU64vcer/6fh5M4ife1N5J5M2SPvCN1dlabvm2Isi//us2G96eIS77pFd5R/Mno5OTsf383wwzIuifzKsOfqF1f1OzzvrPkfX970b++bVDH098q3xtJRfUWIl23JkiZIJo17j8c07WvJfxv/aftsjc8del72XnWg51vTz2IgWz3Bc2l/7cHTeljxirPQn0fIabuTYT5z6f1ef3bbuqs/I2XDaPetPz6bF9MGD/GTacfRrH8JP/wJJ9PoyCV0AAA==",
-      "debug_symbols": "tZbdCoMgGIbvxWMP0tKv7VbGGFY2BLGwGozo3qdjP7EdvyfRK58+HvjAu7LONsv14kI/TOx4WpkfWjO7IaS0bpw10Xnvrpf9MivyRyj93DCNJuQ8zSbO7ChKeZCc2dDl/7KS6ZDeeZtTsfG/eXoPE30mldjOPAEIDajRgAMYoAs0QKABEg0o0YAKDVBoANpkjTZZo03WaJMJbTKhTSa0yYQ2mdAmE9pkQptMaJMJavKW0s1EZxpvXw2nX0K7KzzzfbQ/3WeMQ2u7Jdrcgr4FKL/GSnIl87WzvaIuuKhVgiTQAw==",
-      "brillig_names": [
-        "process_log"
-      ]
-    },
-    {
-      "name": "sync_notes",
-      "is_unconstrained": true,
-      "custom_attributes": [],
-      "abi": {
-        "error_types": {
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        },
-        "parameters": [],
-        "return_type": null
+              }
+            ],
+            "kind": "struct",
+            "path": "authwit::aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs"
+          },
+          "visibility": "databus"
+        }
       },
-      "bytecode": "H4sIAAAAAAAA/7WTyw7CIBBFqcUo0sTEx39MU0y7dOHafyCtLHVRN+766dZkJkyI0QVwEzJMgMNcHoXwKjBKESGCHDEqjAs2Xs7tjDnEqVbBvin5HRijvvhLWH+jkFnk4QPxM50/rJBzmTyfe6F913PTrF8J/z5y+af7y+l//8OzRq9bzCvh/8P4uvfXx/M2ij/SbJGc0ptoOwAqvkT+EvmhJBvn8w+Yb4Svj6KMqNO1tnaNdfZkh8H0dhfwP+KH/QbzqHp4zgQAAA==",
-      "debug_symbols": "ZY5bCsMgEEX3Mt9+aExbkq2EEkwyCYKo+CgUce/VEKi0P5e5w+FyEmy4xGOWejceximBMqsI0ujSUiawOKmUPOb2DbQG4yfvrdC1+iBcgJHxgVMCqLfzfvCysUuFtdFM/ng+dBfdM/Zl731+5lJfwkmxKLxs9qjXRi68Lf54WmdW3KLDatzIlpzYjXS0zJbpDw==",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
-        "sync_notes"
-      ]
+        "get_auth_witness",
+        "decompose_hint",
+        "lte_hint",
+        "enqueue_public_function_call_internal",
+        "call_private_function_internal",
+        "debug_log_oracle_wrapper",
+        "notify_set_min_revertible_side_effect_counter_oracle_wrapper",
+        "notify_created_nullifier_oracle_wrapper",
+        "directive_to_radix",
+        "directive_invert",
+        "directive_integer_quotient"
+      ],
+      "verification_key": "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"
     },
     {
-      "name": "entrypoint",
+      "name": "verify_private_authwit",
       "is_unconstrained": false,
       "custom_attributes": [
-        "private"
+        "private",
+        "view"
       ],
       "abi": {
         "error_types": {
@@ -1795,13 +1959,17 @@
             "error_kind": "string",
             "string": "Stack too deep"
           },
-          "5019202896831570965": {
+          "19458536156181958": {
             "error_kind": "string",
-            "string": "attempt to add with overflow"
+            "string": "Function verify_private_authwit can only be called statically"
           },
-          "5727012404371710682": {
+          "4939791462094160055": {
             "error_kind": "string",
-            "string": "push out of bounds"
+            "string": "Message not authorized by account"
+          },
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
           },
           "6485997221020871071": {
             "error_kind": "string",
@@ -2291,173 +2459,9 @@
             "visibility": "private"
           },
           {
-            "name": "app_payload",
-            "type": {
-              "fields": [
-                {
-                  "name": "function_calls",
-                  "type": {
-                    "kind": "array",
-                    "length": 4,
-                    "type": {
-                      "fields": [
-                        {
-                          "name": "args_hash",
-                          "type": {
-                            "kind": "field"
-                          }
-                        },
-                        {
-                          "name": "function_selector",
-                          "type": {
-                            "fields": [
-                              {
-                                "name": "inner",
-                                "type": {
-                                  "kind": "integer",
-                                  "sign": "unsigned",
-                                  "width": 32
-                                }
-                              }
-                            ],
-                            "kind": "struct",
-                            "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector"
-                          }
-                        },
-                        {
-                          "name": "target_address",
-                          "type": {
-                            "fields": [
-                              {
-                                "name": "inner",
-                                "type": {
-                                  "kind": "field"
-                                }
-                              }
-                            ],
-                            "kind": "struct",
-                            "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-                          }
-                        },
-                        {
-                          "name": "is_public",
-                          "type": {
-                            "kind": "boolean"
-                          }
-                        },
-                        {
-                          "name": "is_static",
-                          "type": {
-                            "kind": "boolean"
-                          }
-                        }
-                      ],
-                      "kind": "struct",
-                      "path": "authwit::entrypoint::function_call::FunctionCall"
-                    }
-                  }
-                },
-                {
-                  "name": "nonce",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "authwit::entrypoint::app::AppPayload"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "fee_payload",
-            "type": {
-              "fields": [
-                {
-                  "name": "function_calls",
-                  "type": {
-                    "kind": "array",
-                    "length": 2,
-                    "type": {
-                      "fields": [
-                        {
-                          "name": "args_hash",
-                          "type": {
-                            "kind": "field"
-                          }
-                        },
-                        {
-                          "name": "function_selector",
-                          "type": {
-                            "fields": [
-                              {
-                                "name": "inner",
-                                "type": {
-                                  "kind": "integer",
-                                  "sign": "unsigned",
-                                  "width": 32
-                                }
-                              }
-                            ],
-                            "kind": "struct",
-                            "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector"
-                          }
-                        },
-                        {
-                          "name": "target_address",
-                          "type": {
-                            "fields": [
-                              {
-                                "name": "inner",
-                                "type": {
-                                  "kind": "field"
-                                }
-                              }
-                            ],
-                            "kind": "struct",
-                            "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-                          }
-                        },
-                        {
-                          "name": "is_public",
-                          "type": {
-                            "kind": "boolean"
-                          }
-                        },
-                        {
-                          "name": "is_static",
-                          "type": {
-                            "kind": "boolean"
-                          }
-                        }
-                      ],
-                      "kind": "struct",
-                      "path": "authwit::entrypoint::function_call::FunctionCall"
-                    }
-                  }
-                },
-                {
-                  "name": "nonce",
-                  "type": {
-                    "kind": "field"
-                  }
-                },
-                {
-                  "name": "is_fee_payer",
-                  "type": {
-                    "kind": "boolean"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "authwit::entrypoint::fee::FeePayload"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "cancellable",
+            "name": "inner_hash",
             "type": {
-              "kind": "boolean"
+              "kind": "field"
             },
             "visibility": "private"
           }
@@ -3569,22 +3573,18 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "H4sIAAAAAAAA/+1dB5gUxfPdi+RswogZFaF7b+9uD5QgWcWEOV9UzGLOiBmzIqKIiIiIiIiIqCgqIuacM+acc8J/l+z+GIY5DPvq/vOw+/vqu7nZvb6q96qrumZ6evISi9rQdonEpa0WHec5Kcj8zHfSIXQu+zN4XBTxvWYR51pEnGsVca5NxLmVnPQMnVsr4nsdIs6tHXFunYhzG0ac2yji3CYRGHSKONc54m9NxPdsxLmSiL8tjfheWcS5dMTfdo34XreIc90j/rZnxPd6RZzrHfG3fSO+1y/i3ICIcwMzP4Mt+3vPzM8SU5ZK1ZYna22JrTTJiqp0qUmVVpWlbdqWpktrkumSktp0Kl1eUVVRbipsqqTW1pVWlNSZRa1LweK+TE4tWa2pp/nXeiZLwmdEt7ZOCgO6Cg4LM8cdE4uPNwocm8x3sn9n3e9JJyVOUgWLz2dbQQgDk1uzGwP7sgU4bkphPmSMJn6bAPtKAvErI8GvE7CvEiB+5UD8omJDaSA2lAWOywPHqVBsSLvfK5x0ddKtAWLDpsC+0kBuNiPx7c7AviqA+G1Ogl8XYF9dgfh1V44NmwViwOaB4+6B426h2NBDdHLSy8kWDRAbDLCvHkBuepP4tgX21ROIXx8S/JLAvnoB8eurHBt6B2JAn8Bx38DxFqHY0M/93t/JACcDGyA2lAD76gfkZksS304B++oPxG8rEvxKgX0NAOK3tXJs2DIQA7YKHG8dOB4Yig2D3O/bONnWyXYNEBvKgH0NAnKzPYlvlwP72gaI3w4k+KWBfW0LxG+wcmzYPhADdggcDw4cbxeKDTu633dysrOTXRogNlQA+9oRyM2uJL7dFdjXTkD8diPBrxuwr52B+O2uHBt2DcSA3QLHuweOdwnFhj3c73s62cvJ3g0QGzYD9rUHkJt9SHx7c2BfewLx25cEv+7AvvYC4lepHBv2CcSAfQPHlYHjvUOxocr9Xu2kxkltA8SGHsC+qoDc1JH4dk9gX9VA/PYjwa8XsK8aIH77K8eGukAM2C9wvH/guDYUG4a43w9wcqCTgxogNmwB7GsIkJuDSXy7N7CvA4D4HUKCXx9gXwcC8TtUOTYcHIgBhwSODw0cHxSKDYe53w93MtTJEQ0QG/oC+zoMyM2RJL7dD9jX4UD8jiLBrz+wr6FA/I5Wjg1HBmLAUYHjowPHR4RiwzHu92OdHOfk+AaIDQOAfR0D5OYEEt8eCOzrWCB+Jyr79gkBHz4xcHxc4Pj4kG+f5H4/2ckpToZF+HY+mJsNEzg8T8XhaYPr1KXfDiEc0Ou/h8N0TyY19TztX+tpy8Jnonx2eMFfr1M/LeSzp7vfz3ByppOzGiAeI9epnw6MJ2eTxGPkOvUzgPidQ4Ifcp36mUD8Rijns7MDseGcwPGIwPFZodhwrvv9PCfnO7mgAWIDcp36uUBuLiTxbeQ69fOA+F1Egh9ynfr5QPwuVo4NFwZiwEWB44sDxxeEYsMl7vdLnYx0clkDxAbkOvVLgNyMIvFt5Dr1S4H4XU6CH3Kd+kggfqOVY8OoQAy4PHA8OnB8WSg2XOF+v9LJGCdXNUBsQK5TvwLIzVgS30auU78SiN/VJPgh16mPAeI3Tjk2jA3EgKsDx+MCx1eFYsM17vfxTq51MqEBYgNynfo1QG6uI/Ft5Dr18UD8JpLgh1ynfi0Qv+uVY8N1gRgwMXB8feB4Qig2THK/3+BkspMbGyA2INepTwJyM4XEt5Hr1G8A4ncTCX7IdeqTgfhNVY4NUwIx4KbA8dTA8Y2h2HCz+32ak1ucTG+A2IBcp34zkJtblbm5NcDBtMDxLYHj6SFuZrjfb3My08ntEdyg76PNgmFgazX1vOPf61lj/gZXswKcyHMB/9tfInB8R4irO93vdzmZ7eTuBhhHyDXddwLH0T0kOaInsK+7gPjNIcGvF7Cv2UD87lWO4/cEYsOcwPG9geO7Q7HhPvf7/U7mOnmgAWLDFsC+7gNyM4/Et3sD+7ofiN+DJPgh13TPBeI3Xzk2zAvEgAcDx/MDxw+EYsND7veHnTzi5NEGiA3INd0PAbl5jMS3kWu6Hwbi9zgJfsg13Y8A8XtCOTY8FogBjweOnwgcPxqKDU+6359y8rSTZxogNiDXdD8J5OZZZW6eDXDwVOD46cDxMyFunnO/P+/kBScvNkBt/hKuNq/T1PPlf6/n39oz+qUAJzMCx88Fjl8OcfWK+/1VJ685eT3DVWHI/mVhYnJr9hWg/7YM6PlGJgC8mfn5VubngszPtzM/38n8fDfz873Mz/czPz/I/Pww8/OjgkUY9Mz8n4/d7584+dTJZ04+d/KFky+dfOXkayffOPnWyXdOvnfyg5Mfnfzk5Gcnvzj51clvTn4Xfpz8UbCIiDwn+U4KnBQ6KXJS7KSRk8ZOmjhp6qSZk+ZOWjhp6aSVk9ZO2jhp66SdkxWcrOhkJScrO1nFSXsnqzpZzcnqTtZwsqaTtZx0cLK2k3WcrOtkPSfrO9nAyYZOOmYcZaPCxJIbxb9VsPTm8e9EnHs/4txHEecE5Mahc59EnPs04txnEec+jzj3RcS5LyPOfRVx7uuIc99EnPs24tx3Eee+jzj3Q8S5HyPO/RRx7ueIc79EnPs14txvEed+jzi3MOLcHxHnxKnD5/IizuVHnCuIOFcYca4o4lxxxLlGEecaR5xrEnGuacS5ZhHnmkecaxFxrmXEuVYR51pHnGsTca5txLl2EedWiDi3YsS5lSLOrRxxbpWIc+0jzq0acW61iHOrR5xbI+LcmhHn1oo41yHi3NoR59aJOLduxLn1Is6tH3Fug4hzG0ac65g5JzG1cWLxRDbY8jI/e2Z+mtwaNAlHqAvqO6nXt100ocpi2yFzvLEjYRMnnZxs6qSzky5OjBPrJOmkxEnKSamTMiflTtJOKpx0ddLNyWZONnfS3UkPJz2d9HKyhZPeTvo46eukn5P+TgY4GRhOqhtHOMsmEec6RZzbNOJc54hzXSLOmYhzNuJcMuJcScS5VMS50ohzZRHnyiPOpSPOVUSc6xpxrlvEuc0izm0eca57xLkeEed6RpzrFXFui4hzvSPO9Yk41zfiXL+Ic/0jzg2IODcwcy7Y1s787Jn5aXJrSwSdXCsrGRu59lVbJ83YTUB9iY2dIH0twmvT3PtKZvCynXPtK/U/7G2X3PoyAR6tyaWv5BI+Ye2/78uE/Msm/2VfZXVL+aot+Xd9pSP83qb+TV/pyDFkS/95X+X1jEdb9k/7Kq93bNvyf9ZXchlxwqb/SV/ly4w5tuLv91X9F/HLdv27fZX/ZSy03f5eX+ZvxFW72d/py/ytGG03/+u+Sv9mvLfd/6qv1N/OHbbHMvtK1f2DPGR7Lquv8n+U02yv+vtK/8P8aLeop6+Kun+ca23v6L7Mv8jbtk9UX+ZfzQFs36X7sv9yPmH7hfuq+ddzE9t/yb5Kcpjn2AGBvpJ1Oc2Z7MBCXNEntUqTxOLCNNjQxepA2Fyvxgb13bJQUWHpPD/Ub67Kb4kj0G4FADU7GdfCUHTMA2O4FXgQNE0s5rmhBoHJqdWoXlUJYrF1ZoANCl/Z2DpDbPDcoIgKtEARxFyrxq2BA2gQmFy088mg2Ro4GP/3jhvSjDQA5kcVNUF9tylUVHgbeEaqqNkGmJG2jXlGEgy3hWekipptSTPSAJjeFdUR6qpkpO0yA2z7cEbaLiIjbd8AGWkAMCNtBxxA2yuRiwpAWT2RNu8ADGaJBD5bbpUJQPlgH0SWAoOBwSwKQ5Nbs8LxYIWZzGDSmUx/WPypKgnqu2OhosI7wmcyVSU7Agf/TjGfyQiGO8FnMlUlOykPfkQAHRzzALozGMNsQydepI/vAhx7DTkD7g/TuyoZoa7KDHjXTGDeLTwD3jViBrxbA8yAcRnI2F2BTrmbErnogYi0eXflGbDJrVkJjrsozN72iPmsVXjZg8BuLR/fA+jje8bcx+ubpCAmP6i+9gIn7IaqdvrBck26Lqjv3oWKCu8Nr3bSdXsDCdwn5tWOYLgPvNpJ1+0T82pHAt1ehfEOxvuCg3G2oW1G+nglabXTD6Z3ujZCXZVqpyoTmKvD1U5VRLVT3QDVDi4DGVsFdMpqJXLRAxFpc03MZ4ISHCsVZv21Ma92hJdaAru1fLwW6ON1Mffx+iYpJrdmkZOU/Ujv7fSF5ZqkCeq7f6GiwvvDq52k2R84CIbEvNoRDIfAq52kGRLzakcC3X6F8Q7GB5BUO0gfP5C02ukL03vJLWYSSD1D1c5BmcB8cLjaOSii2jm4AaodXAYy9iCgUx6sRC56ICJtPiTmM0EJjgcqzPoPjXm1I7wcSmC3lo8fCvTxw2Lu4/VNUkxuzSInKYeTVjt9YLmmZolqZ2ihosJD4dVOjRkKHARHxLzaEQyPgFc7NeaImFc7EugOL4x3MD6SpNpB+vhRpNVOH5je1Q1W7RydCczHhKudoyOqnWMaoNrBZSBjjwY65TFK5KIHItLmY2M+E5TgeJTCrP+4mFc7wstxBHZr+fhxQB8/PuY+Xt8kxeTWLHKScgJptdMblmvKltgT48RCRYVPhFc7ZfZE4CA4KebVjmB4ErzaKVvCbpNji7IbEehOKIx3MD6ZpNpB+vgppNVOb5jeZQ22l8qwTGA+NVztDIuodk5tgGoHl4GMHQZ0ylOVyEUPRKTNw2M+E5TgeIrCrP+0mFc7wstpBHZr+fhpQB8/PeY+Xt8kxeTWLHKScgZptbMF7t5OOqjvmYWKCp+Jv7eTPhM4CM6KebUjGJ6Fv7eTPivm1Y4EujMK4x2MzyapdpA+fg5ptbMFTO+a8gh1VaqdEZnAfG642hkRUe2c2wDVDi4DGTsC6JTnKpGLHohIm8+L+UxQguM5CrP+82Ne7Qgv5xPYreXj5wN9/IKY+3h9kxSTW7PIScqFpNVOL1iuSVUE9b2oUFHhi+DVTqriIuAguDjm1Y5geDG82klVXBzzakcC3YWF8Q7Gl5BUO0gfv5S02ukF0zuVjlBXpdoZmQnMl4WrnZER1c5lDVDt4DKQsSOBTnmZErnogYi0eVTMZ4ISHC9VmPVfHvNqR3i5nMBuLR+/HOjjo2Pu4/VNUkxuzSInKVeQVjs9YbmmaomVbFcWKip8JbzaqbJXAgfBmJhXO4LhGHi1U7WE3SbHFmU3ItBdURjvYHwVSbWD9PGxpNVOT5jeVQ22ku3qTGAeF652ro6odsY1QLWDy0DGXg10ynFK5KIHItLma2I+E5TgOFZh1j8+5tWO8DKewG4tHx8P9PFrY+7j9U1STG7NIicpE0irnR64aqc6qO91hYoKX4evdqqvAw6CiTGvdgTDifhqp3pizKsdCXQTCuMdjK8nqXaQPj6JtNrpgZsQV0Woq1Lt3JAJzJPD1c4NEdXO5AaodnAZyNgbgE45WYlc9EBE2nxjzGeCEhwnKcz6p8S82hFephDYreXjU4A+flPMfby+SYrJrVnkJGUqabXTHbeSrSqo782FigrfjF/JVnUzcBBMi3m1IxhOw69kq5oW82pHAt3UwngH41tIqh2kj08nrXa64xY7VUaoq1Lt3JoJzDPC1c6tEdXOjAaodnAZyNhbgU45Q4lc9EBE2nxbzGeCEhynK8z6Z8a82hFeZhLYreXjM4E+fnvMfby+SYrJrVnkJGUWabWzOSzXpJfYgfqOQkWF74BXO2lzB3AQ3BnzakcwvBNe7aTNnTGvdiTQzSqMdzC+i6TaQfr4bNJqZ3OY3uUNtgP13ZnAfE+42rk7otq5pwGqHVwGMvZuoFPeo0QueiAibZ4T85mgBMfZCrP+e2Ne7Qgv9xLYreXj9wJ9/L6Y+3h9kxSTW7PIScr9pNXOZkrVztxCRYXnKlQ7c4GD4IGYVzuC4QMK1c4DMa92JNDdXxjvYDyPpNpB+viDpNXOZoTVzvxMYH4oXO3Mj6h2HmqAageXgYydD3TKh0iqHaTND8d8JijB8UGFWf8jMa92hJdHCOzW8vFHgD7+aMx9vL5JismtWeQk5THSaqcbLNdULrEn2+OFigo/Dq92KiseBw6CJ2Je7QiGT8CrncqKJ2Je7Uige6ww3sH4SZJqB+njT5FWO91gelc22J5sT2cC8zPhaufpiGrnmQaodnAZyNingU75jBK56IGItPnZmM8EJTg+pTDrfy7m1Y7w8hyB3Vo+/hzQx5+PuY/XN0kxuTWLnKS8QFrtdMVVO6mgvi8WKir8Ir7aSb0IHAQvxbzaEQxfwlc7qZdiXu1IoHuhMN7B+GWSagfp46+QVjtdcRPikgh1VaqdVzOB+bVwtfNqRLXzWgNUO7gMZOyrQKd8TYlc9EBE2vx6zGeCEhxfUZj1vxHzakd4eYPAbi0ffwPo42/G3Mfrm6SY3JpFTlLeIq12KmC5pmaJezsLChUVXgCvdmoqFgAHwdsxr3YEw7fh1U5Nxdsxr3Yk0L1VGO9g/A5JtYP08XdJq50KmN41DXZv571MYH4/XO28F1HtvN8A1Q4uAxn7HtAp31ciFz0QkTZ/EPOZoATHdxVm/R/GvNoRXj4ksFvLxz8E+vhHMffx+iYpJrdmkZOUj0mrnTQs11TXBvX9pFBR4U/g1U517SfAQfBpzKsdwfBTeLVTXftpzKsdCXQfF8Y7GH9GUu0gffxz0monDdO7uiZCXZVq54tMYP4yXO18EVHtfNkA1Q4uAxn7BdApv1QiFz0QkTZ/FfOZoATHzxVm/V/HvNoRXr4msFvLx78G+vg3Mffx+iYpJrdmkZOUb0mrnXJYrrFL3Nv5rlBR4e/g1Y6t+A44CL6PebUjGH4Pr3Zsxfcxr3Yk0H1bGO9g/ANJtYP08R9Jq51ymN62we7t/JQJzD+Hq52fIqqdnxug2sFlIGN/Ajrlz0rkogci0uZfYj4TlOD4o8Ks/9eYVzvCy68Edmv5+K9AH/8t5j5e3yTF5NYscpLyO2m1UwbLNVVLVDsLCxUVXgivdqoqFgIHwR8xr3YEwz/g1U5VxR8xr3Yk0P1eGO9gnCjiqHaQPp4HtLkhq50ymL9XNVi1k1+06GdBUWLJykY+CFc78iXtageXgYzNL8I5ZUGRDrnogYi0uRAcfNADToJjXhE+MRQV6SYuk1uzwksRgd1aPl4E9PHimPt4fZMUk1uzyElKI6DfNGS1UwrLNel0UN/GRYoKS+fYaiedbgwcBE2Ag1MLwyZF6GonnW6inDQQga5RUbyDcVOSagfp481Iq51SWLWTLo9QV6XaaZ4JzC3C1U7ziGqnRQNUO6XAaqc50ClbFOmQix6ISJtbxnwmKMGxmcKsv1XMqx3hpRWB3Vo+3gro461j7uP1TVJMbs0iJyltSKudFCzXpJaodtoWKSrcFl7tpNJtgYOgXcyrHcGwHbzaSaXbxbzakUDXpijewXgFkmoH6eMrklY7KVi1k2qwamelTGBeOVztrBRR7azcANVOCljtrAR0ypWLdMhFD0SkzavEfCYowXFFhVl/+5hXO8JLewK7tXy8PdDHV425j9c3STG5NYucpKxGWu2UwHJNhQ3qu3qRosKrw6udCrs6cBCsEfNqRzBcA17tVCxht8mxRdmNCHSrFcU7GK9JUu0gfXwt0mqnBFbtVJgIdVWqnQ6ZwLx2uNrpEFHtrN0A1U4JsNrpAHTKtYt0yEUPRKTN68R8JijBcS2FWf+6Ma92hJd1CezW8vF1gT6+Xsx9vL5JismtWeQkZX3SaicJyzXlJqjvBkWKCm8Ar3bKzQbAQbBhzKsdwXBDeLVTbjaMebUjgW79ongH444k1Q7SxzcirXaSsGqnrC5CXZVqZ+NMYN4kXO1sHFHtbNIA1U4SWO1sDHTKTYp0yEUPRKTNnWI+E5TguJHCrH/TmFc7wsumBHZr+fimQB/vHHMfr2+SYnJrFjlJ6UJa7VjcLgVL7EBtihQVNvBqp6rWAAeBjXm1IxhaeLVTVWtjXu1IoOtSFO9gnCSpdpA+XkJa7VjcLgU1EeqqVDupTGAuDVc7qYhqp7QBqh0LrHZSQKcsLdIhFz0QkTaXxXwmKMGxRGHWXx7zakd4KSewW8vHy4E+no65j9c3STG5NYucpFSQVjsGlmuSS9zb6VqkqHBXeLWTNF2Bg6BbzKsdwbAbvNpJmm4xr3Yk0FUUxTsYb0ZS7SB9fHPSasfgNilusHs73TOBuUe42ukeUe30aIBqxwCrne5Ap+xRpEMueiAibe4Z85mgBMfNFWb9vWJe7QgvvQjs1vLxXkAf3yLmPl7fJMXk1ixyktKbtNrpgss11UF9+xQpKtwHXu2Y6j7AQdA35tWOYNgXXu2Y6r4xr3Yk0PUuincw7kdS7SB9vD9ptdMFt+N6VYS6KtXOgExgHhiudgZEVDsDG6DaAWYgOwDolAOLdMhFD0SkzVvGfCYowbG/wqx/q5hXO8LLVgR2a/n4VkAf3zrmPl7fJMXk1ixykjKItNrpDMs1ZUusZNumSFHhbeDVTlntNsBBsG3Mqx3BcFt4tVNWu23Mqx0JdIOK4h2MtyOpdpA+vj1ptdMZ99xOg61k2yETmAeHq50dIqqdwQ1Q7XQGVjs7AJ1ycJEOueiBiLR5x5jPBCU4bq8w698p5tWO8LITgd1aPr4T0Md3jrmP1zdJMbk1i5yk7EJa7WwKyzV2iT3Zdi1SVHhXeLVj7a7AQbBbzKsdwXA3eLVjl7Db5Nii7EYEul2K4h2MdyepdpA+vgdptbMpbiVbg+3JtmcmMO8Vrnb2jKh29mqAamdTYLWzJ9Ap9yrSIRc9EJE27x3zmaAExz0UZv37xLzaEV72IbBby8f3Afr4vjH38fomKSa3ZpGTlErSaqcTbjHGEs/tVBUpKlxVhO+3OuYVithdXbQYYFC/KlWFBJTKongHvRqSqgLpl7XKgR7BSa2CjzdkQN1EKaDWFSkqXKcQUPeLeUAVu/fzARXW1/4kARXpl0NiHlCFkyHkAXXjQhweQX0PKFJU+ACFwXoA0NkOjHlwFgwPVCjvD4z59XiGQH8QSaBH+vjBMb9EIpwcrDBeDon5ZUCJE4coTeK0/PIQoF8eGnO/rC+emdyaRcazw2Lu48LxYQoF2iExnwMscPfVRNAx7XAw3+j4IDYDdbRvu/7ezt6jhPFjl8jdjf9p33bZH/9c8I/0XGZvvxT8Q5uX0duvBf8Yv3p7+63gX3BRT2+/F/wrXiN7W1iA873GwOLtnJY6+b3pP/XdJSxc+tQf/x6/pXpL5HI1MdRbXm5XJpfoLT/Xq5yB3gpyv2L6v94KEVdfM70VYa7k/tlbMeqqsOutEXBMjVAaU+ElMbnqORSYD4FxxCLxa8iLakA8l7iodkSRosJHKEyCj4z5JFjsPlK5wEVP3j4GTt4+AU7ePgVO3j4DTt4+B07evgBO3n4qwI2Ni0gmb18CJ29fFeAmb18X4CZv3xTgJm/fFuAmb98V4CZv3xfgJm8/FOAmbz8Cx9TFJJO3o4CTN2AcsReTTt6OUpq8HV2kqPDRCpO3Y2I+eRO7jyFZYnKkoq7Zhp5oti/ETTRXLcRNNFcrxE00Vy/ETTTXKMRNNNfErXOzHYFXNC4nmWiuVYibaHYAXiVcG3iVcB3gVcJ1gVcJ1wNeJVwfeJVwA+BVwg2BY2o0yUTzWOBEExhH7GjSieaxShPN44oUFT5OYaJ5fMwnmmL38WSTtybAyVtT4OStGXDy1hw4eWsBnLy1BE7eVgEmmqtJJm+tgJO31sDJWxvg5K0tcPLWDjh5WwE4eVsROHlbCTh5Wxk4psaRTN5OAE7egHHEjiOdvJ2gNHk7sUhR4RMVJm8nxXzyJnafRHKV8HhFXbMNHVhO/g+sHdHE75T/wO0bTfyG/QeuSmjid+p/YGIgcVoK7OIAjig9Fy67v2R1nS0prS0vNWWVqdKaspJkTbLc1KRK66wjKFmRcvTUVafSNelkSV2yPFm9EKufyW6xJeveF2aO384co/9PYaYvOZa8kP1/pwSOhwWOT80cD3c/T3NyetGiPhpqP7XTi3TGKNjHkkEszsjMD84M76cmH/weUgC9d9rpgMneor3T6urOAE4cz/x/2h8oV72DGNh0STJZXiLfS9cYm6qpTqaTyZqqlKk2ldXJ2oqUrahLJVMl1TXVVa7PSltn6iqrK+rSi/oK6ntWkaLCZ0U8cZar8mcBs9DZyhUJAsOzIyqxXDE8O+ZPX59Zj905P7kCLsWzAfWcjJ8XJhZvVBlu6Iw0HGhLMGuMyASEc4tCBqAzxHDg4Bvx9/uq/ou+7LngDNFQDrGgQMchzss4wvnaDrEAuCTzPKBDnE/qEG8rOcQFGUe4UNsh3gY6xAVAh7gQnEak4GwewPF/fadLassrrK1Jl5SaivKyZIXToKy8tMTWVdvS6sq6mvKKynRFVW1tdVVJRYUpqSurKHWFYVlJWV2qsrQyXLjZyvK60tq6ysqa8roS10GytLLCputKTHV1uqa8RMrL6sqqcvdxdYWpc9OK2rStqq4uTabrKipKSms0CsEl+itNVVamyyrLS9yspbIkVZosrS2tqqqtKatNlVRVWluRrk2XmbrSupKKUpMsS9eV25q6VGmFraqpTZlkWL+kqaiprquqc5V1VWl5XUVdmUk5ZFI15bayuqyusi5dnnT/sq66PGXKq02qtqosaSvLkuny6spqmyzTttdWp1J1ycrSpPvvaevcrtLN62xlqfPC6tp0lfNOa5IpAcAdpm1FVVVNZV1pZbKypjKdKk+ll9KvpLKytrakrLYslUxWWjczrLDuMoKztbSiorK2orbKOUV1stqWV6arK5KmsrLEOVG6Kl1RXVrn/rm2vcka988qUqa2NF1halNu+JWX15rSkvKSusrasgqncXlpyvmwuwrinCBtqsrKyiqcoc7fk24mu5T/JWura9LpGltaUVZeVV1aUpVOO19I1poaW5YuK7OO2+qqskpnck1JXbq0Nul4La+tratyEFS4waVhb3Z1hhyPCFzAODdwfF7g+PzA8QWB4wuL4Bde4PZKfxc5PS92cknmgozYH9jj4H8Nndwuorggk1TdPD8vgG2HzPGlDpeRTi5zMsrJ5U5GO7nCyZVOxji5yslYJ1c7GefkGifjnVzrZIKT65xMdHK9k0lObnAy2cmNTqY4ucnJVCc3O5nm5BYn053cGr7QJMo0Dp0bGXHusohzoyLOXR5xbnTEuSsizl0ZcW5MxLmrIs6NjTh3dcS5cRHnrok4Nz7i3LUR5yZEnLsu4tzEiHPXR5ybFHHuhohzkyPO3RhxbkrEuZsizk2NOHdzxLlpEeduiTg3PeLcrUVLvxBi7czPnpmfJre2RNDJdUJ6KewCqbEjQX2JjZdB+lqE16jc+0pmJ92X59pXavEEfnRufZlgMXBFLn0llywsrvz3fZlwkTLmX/ZVVrd0wXPVv+srHVU8jf03faWjC7Gr/3lf5fUVdeP+aV/l9ReI1/yzvpLLKjbH/5O+ypdduF4LLIIn/N2+yv8yFtrr/l5f5m/EVTvx7/Rl/laMttf/dV+lfzPe20l/1Vfqb+cOe8My+0rV/YM8ZCcvq6/yf5TT7I3195X+h/nRTqmnr4q6f5xr7U3RfZl/kbft1Ki+zL+aA9ibl+7L/sv5hJ0W7qvmX89N7C1L9lWSwzzHTg/0lazLac5kbwVfiW2oJaC3wuZ6NUu8ynJGkaLCM4rQr7KssTNwBNrbgJNxLQxFR9RNzCyGt4EHQUMtocEN3poGeyXhzMwAuz18ZWNm0eL7ONlztxfpv5IQF0mMnQkcQLeDyUU7nwyamcDBmLV7JmlGmg7zo4qaoL6zihQVngXPSBU1s4AZ6Y6YZyTB8A54RqqouYM0I02H6V1RHaGuSka6MzPA7gpnpDsjMtJdDZCRpgMz0p3AAXSXErmoAJTVE2nzbGAwSyTw2fK2TADKB/sgshS4GxjMojA0uTUrHN+tMJO5m3Qmcwss/lSVBPW9p0hR4XvgM5mqknuAg39OzGcyguEc+EymqmSO8uBHBNC7Yx5A7wVjmG3oxIv08fuAY68hZ8C3wPSuSkaoqzIDvj8TmOeGZ8D3R8yA5zbADBiXgYy9H+iUc5XIRQ9EpM0PKM+ATW7NSnC8T2H2Ni/ms1bhZR6B3Vo+Pg/o4w/G3Mfrm6QgJj+ovuaDE3ZDVTvTYLkmXRfU96EiRYUfglc76bqHgAQ+HPNqRzB8GF7tpOsejnm1I4FuflG8g/Ej4GCcbWibkT7+KGm1Mw2md7o2Ql2VauexTGB+PFztPBZR7TzeANUOLgMZ+xjQKR9XIhc9EJE2PxHzmaAEx0cVZv1PxrzaEV6eJLBby8efBPr4UzH38fomKSa3ZpGTlKdJ7+3cDMs1ySU2vXmmSFHhZ+DVTtI8AxwEz8a82hEMn4VXO0nzbMyrHQl0TxfFOxg/R1LtIH38edJq52aY3rYuQl2VaueFTGB+MVztvBBR7bzYANUOLgMZ+wLQKV9UIhc9EJE2vxTzmaAEx+cVZv0vx7zaEV5eJrBby8dfBvr4KzH38fomKSa3ZpGTlFdJq52psFxTs0S181qRosKvwaudGvMacBC8HvNqRzB8HV7t1JjXY17tSKB7tSjewfgNkmoH6eNvklY7U2F6VzdYtfNWJjAvCFc7b0VUOwsaoNrBZSBj3wI65QIlctEDEWnz2zGfCUpwfFNh1v9OzKsd4eUdAru1fPwdoI+/G3Mfr2+SYnJrFjlJeY+02rkJlmvKltgT4/0iRYXfh1c7ZfZ94CD4IObVjmD4AbzaKVvCbpNji7IbEejeK4p3MP6QpNpB+vhHpNXOTTC9yxpsL5WPM4H5k3C183FEtfNJA1Q7uAxk7MdAp/xEiVz0QETa/GnMZ4ISHD9SmPV/FvNqR3j5jMBuLR//DOjjn8fcx+ubpJjcmkVOUr4grXam4O7tpIP6flmkqPCX+Hs76S+Bg+CrmFc7guFX+Hs76a9iXu1IoPuiKN7B+GuSagfp49+QVjtTYHrXlEeoq1LtfJsJzN+Fq51vI6qd7xqg2sFlIGO/BTrld0rkogci0ubvYz4TlOD4jcKs/4eYVzvCyw8Edmv5+A9AH/8x5j5e3yTF5NYscpLyE2m1cyMs16Qqgvr+XKSo8M/waidV8TNwEPwS82pHMPwFXu2kKn6JebUjge6nongH419Jqh2kj/9GWu3cCNM7lY5QV6Xa+T0TmBeGq53fI6qdhQ1Q7eAykLG/A51yoRK56IGItPmPmM8EJTj+pjDrTxTHu9oRXkTHuNut5eNBPXPtK6843j5e3yTF5NYscpKSD/Sbhqx2JsNyTdUSK9kKihUVls6x1U6VLQAOgkLg4NTCsLAYXe1ULWG3ybFF2Y0IdPnF8Q7GReBgnG1om5E+Xowce4mGq3YmwyaHVQ22kq1RJjA3Lk4sWdk0Kl662pEvaVc7k4HVTiOgUzYu1iEXPRCRNjeJ+UxQgmOxwqy/acyrHeGlKYHdWj7eFOjjzWLu4/VNUkxuzSInKc1Jq50bcNVOdVDfFsWKCrfAVzvVLYCDoGXMqx3BsCW+2qluGfNqRwJd8+J4B+NWJNUO0sdbk1Y7N+CqnaoIdVWqnTaZwNw2XO20iah22jZAtXMDsNppA3TKtsU65KIHItLmdjGfCUpwbK0w618h5tWO8LICgd1aPr4C0MdXjLmP1zdJMbk1i5ykrERa7UzCrWSrCuq7crGiwivDq51U1crAQbBKzKsdwXAVeLWTqlol5tWOBLqViuMdjNuTVDtIH1+VtNqZhFvsVBmhrkq1s1omMK8ernZWi6h2Vm+AamcSsNpZDeiUqxfrkIseiEib14j5TFCC46oKs/41Y17tCC9rEtit5eNrAn18rZj7eH2TFJNbs8hJSgfSaud6WK5JL7ED9drFigqvDa920mZt4CBYJ+bVjmC4DrzaSZt1Yl7tSKDrUBzvYLwuSbWD9PH1SKud62HVTnldhLoq1c76mcC8QbjaWT+i2tmgAaqd64HVzvpAp9ygWIdc9EBE2rxhzGeCEhzXU5j1d4x5tSO8dCSwW8vHOwJ9fKOY+3h9kxSTW7PIScrGpNXORKVqZ5NiRYU3Uah2NgEOgk4xr3YEw04K1U6nmFc7Eug2Lo53MN6UpNpB+nhn0mpnImG10yUTmE242ukSUe2YBqh2JgKrnS5ApzQk1Q7SZhvzmaAEx84Ks/5kzKsd4SVJYLeWjyeBPl4Scx+vb5JicmsWOUlJkVY718FyTeUSe7KVFisqXAqvdiorSoGDoCzm1Y5gWAavdiorymJe7UigSxXHOxiXk1Q7SB9Pk1Y718GqncoG25OtIhOYu4arnYqIaqdrA1Q71wGrnQqgU3Yt1iEXPRCRNneL+UxQgmNaYda/WcyrHeFlMwK7tXx8M6CPbx5zH69vkmJyaxY5SelOWu1MwFU7qaC+PYoVFe6Br3ZSPYCDoGfMq50/ScdXO6meMa92JNB1L453MO5FUu0gfXwL0mpnAq7aKYlQV6Xa6Z0JzH3C1U7viGqnTwNUOxOA1U5voFP2KdYhFz0QkTb3jflMUILjFgqz/n4xr3aEl34Edmv5eD+gj/ePuY/XN0kxuTWLnKQMIK12rsW9XXSJezsDixUVHgivdmoqBgIHwZYxr3YEwy3h1U5NxZYxr3Yk0A0ojncw3oqk2kH6+Nak1c61uBdQNti9nUGZwLxNuNoZFFHtbNMA1c61wGpnENAptynWIRc9EJE2bxvzmaAEx60VZv3bxbzaEV62I7Bby8e3A/r49jH38fomKSa3ZpGTlB1Iq53xsFxTXRvUd3CxosKD4dVOde1g4CDYMebVjmC4I7zaqa7dMebVjgS6HYrjHYx3Iql2kD6+M2m1Mx5W7VTXRKirUu3skgnMu4arnV0iqp1dG6DaGQ+sdnYBOuWuxTrkogci0ubdYj4TlOC4s8Ksf/eYVzvCy+4Edmv5+O5AH98j5j5e3yTF5NYscpKyJ2m1cw0s19gl7u3sVayo8F7wasdW7AUcBHvHvNoRDPeGVzu2Yu+YVzsS6PYsjncw3oek2kH6+L6k1c41sGrHNti9ncpMYK4KVzuVEdVOVQNUO9cAq51KoFNWFeuQix6ISJurYz4TlOC4r8Ksvybm1Y7wUkNgt5aP1wB9vDbmPl7fJMXk1ixyklJHWu2Mw71ddIlqZ79iRYX3g1c7VRX7AQfB/jGvdgTD/eHVTlXF/jGvdiTQ1RXHOxgPIal2kD5+AGm1Mw73dtEGq3YOzATmg8LVzoER1c5BDVDtjANWOwcCnfKgYh1y0QMRafPBMZ8JSnA8QGHWf0jMqx3h5RACu7V8/BCgjx8acx+vb5JicmsWOUk5jLTauRq3A3U6qO/hxYoKHw6vdtLpw4GDYGjMqx3BcCi82kmnh8a82pFAd1hxvIPxESTVDtLHjyStdq6GVTvp8gh1VaqdozKB+ehwtXNURLVzdANUO1cDq52jgE55dLEOueiBiLT5mJjPBCU4Hqkw6z825tWO8HIsgd1aPn4s0MePi7mP1zdJMbk1i5ykHE9a7YyF5ZrUEtXOCcWKCp8Ar3ZS6ROAg+DEmFc7guGJ8GonlT4x5tWOBLrji+MdjE8iqXaQPn4yabUzFlbtpBqs2jklE5iHhaudUyKqnWENUO2MBVY7pwCdclixDrnogYi0+dSYzwQlOJ6sMOsfHvNqR3gZTmC3lo8PB/r4aTH38fomKSa3ZpGTlNNJq52rYLmmwgb1PaNYUeEz4NVOhT0DOAjOjHm1IxieCa92Kpaw2+TYouxGBLrTi+MdjM8iqXaQPn42abVzFazaqTAR6qpUO+dkAvOIcLVzTkS1M6IBqp2rgNXOOUCnHFGsQy56ICJtPjfmM0EJjmcrzPrPi3m1I7ycR2C3lo+fB/Tx82Pu4/VNUkxuzSInKReQVjtjYLmm3AT1vbBYUeEL4dVOubkQOAguinm1IxheBK92ys1FMa92JNBdUBzvYHwxSbWD9PFLSKudMbBqp6wuQl2VaufSTGAeGa52Lo2odkY2QLUzBljtXAp0ypHFOuSiByLS5stiPhOU4HiJwqx/VMyrHeFlFIHdWj4+Cujjl8fcx+ubpJjcmkVOUkaTVjtX4nYpWGIH6iuKFRW+Al7tVNVeARwEV8a82hEMr4RXO1W1V8a82pFAN7o43sF4DEm1g/Txq0irnStxuxQ02A7UYzOB+epwtTM2otq5ugGqnSuB1c5YoFNeXaxDLnogIm0eF/OZoATHqxRm/dfEvNoRXq4hsFvLx68B+vj4mPt4fZMUk1uzyEnKtaTVzhWwXJNc4t7OhGJFhSfAq52kmQAcBNfFvNoRDK+DVztJc13Mqx0JdNcWxzsYTySpdpA+fj1ptXMFbgfqugh1VaqdSZnAfEO42pkUUe3c0ADVzhXAamcS0ClvKNYhFz0QkTZPjvlMUILj9Qqz/htjXu0ILzcS2K3l4zcCfXxKzH28vkmKya1Z5CTlJtJqZzQu11QH9Z1arKjwVHi1Y6qnAgfBzTGvdgTDm+HVjqm+OebVjgS6m4rjHYynkVQ7SB+/hbTaGQ2rdkxVhLoq1c70TGC+NVztTI+odm5tgGoHmIHsdKBT3lqsQy56ICJtnhHzmaAEx1sUZv23xbzaEV5uI7Bby8dvA/r4zJj7eH2TFJNbs8hJyu2k1c7lsFxTtsRKtlnFigrPglc7ZbWzgIPgjphXO4LhHfBqp6z2jphXOxLobi+OdzC+k6TaQfr4XaTVzuW453YabCXb7Exgvjtc7cyOqHbuboBq53JgtTMb6JR3F+uQix6ISJvviflMUILjXQqz/jkxr3aElzkEdmv5+Bygj98bcx+vb5JicmsWOUm5j7TaGQXLNXaJPdnuL1ZU+H54tWPt/cBBMDfm1Y5gOBde7dgl7DY5tii7EYHuvuJ4B+MHSKodpI/PI612RuFWsjXYnmwPZgLz/HC182BEtTO/AaqdUcBq50GgU84v1iEXPRCRNj8U85mgBMd5CrP+h2Ne7QgvDxPYreXjDwN9/JGY+3h9kxSTW7PIScqjpNXOZbjFGEs8t/NYsaLCjxXj+3085hWK2P148WKAQf2qVBUSUB4tjnfQe4KkqkD65ZPKgR7ByZMKPt6QAXWkUkB9qlhR4acUAurTMQ+oYvfTPqDC+nqGJKAi/fLZmAdU4eRZ8oB6aREOj6C+zxUrKvycwmB9Duhsz8c8OAuGzyuU98/H/Ho8Q6B/gSTQI338xZhfIhFOXlQYLy/F/DKgxImXlCZxWn75EtAvX465X9YXz0xuzSLj2Ssx93Hh+BWFAg3ph6JbYUC3Px+DKlp0q+zPx6QCx7cEjqcFjm8OHE8NHN8UOJ4SOL4xcDw5cHxD4HhS4Pj6wPHEwPF1geMJgeNrA8fjA8fXBI7HBY6vDhyPDRxfFTgeEzi+MnB8ReB4dOD48sDxqMDxZYHjkYHjSwPHAwsXHw8IHPcPHPcLHPcNHPcJHPcOHG8ROO4VOO4ZOO4ROO4eON48cLxZ4Lhb4Lhr4LgicJwOHJcHjssCx6WB41TguCRwnAwc28CxCRx3CRx3DhxvGjjuFDjeJHC8ceb4VTe2XnPyupM3nLzp5C0nC5y87eQdJ+86ec/J+04+cPKhk4+cfOzkEyefOvnMyedOvnDypZOvnHzt5Bsn3zr5zsn3Tn5w8qOTn5z8HMiHiQQ+bpxZxJFnmxTibH6V5LZgU6DNr5HY3Axo8+skNjcH2vwGic0tgDa/SWJzS6DNb5HY3Apo8wISm1sDbX6bxOY2QJvfIbG5LdDmd0lsbge0+T0Sm1cA2vw+ic0rAm3+gMTmlYA2f0hi88pAmz8isXkVoM0fk9jcHmjzJyQ2rwq0+VMSm1cD2vwZic2rA23+nMTmNYA2f0Fi85pAm78ksXktoM1fkdjcAWjz1yQ2rw20+RsSm9cB2vwtic3rAm3+jsTm9YA2f09i8/pAm38gsXkDoM0/kti8IdDmn0hs7gi0+Wclm9Fr536B6VmSEt3aJhatscnqKv0vzBy/UbD4+M3A8R2Z4+zf/er+5jcnv8vfFi8+n23oR9nfKsD19StwvdIfSj6Exm8BEL/fgPglGnHg9zYQv9+R6+WA+EXFhj8CsUG4yh7nBY4XFi8ZG/LdZwVOCp0UNdKPDe8AuclvhOOmmMS33wXiVwDErxEJfu8B8SsE4tdYOTYUB2JAo8Bx48BxUaMlY0MT93tTJ82cNG+A2PA+kJsmQG5akPj2B0D8mgLxa0mC34dA/JoB8WulHBtaBGJAy8Bxq8Bx81BsaO1+b+OkrZN2DRAbPgJy0xrIzQrK3KwQ4KBN4Lht4LhdiJsV3e8rOVnZySoR3KBr3vY4DOqiMGgfsHXFwPFGhYuPXw7VvKu6763mZHUna2QwKEws3tot8ReYmNyaXRXoF/kBPddstOjnWo0SS+5RJx8MC51bK3Mu2NADc1XgYFrz7/dV/Rd92bWABIjj5CeiN1NM/EM8/0rvhKJTrgkOVtnWIeyMciLvLxwP6Sx/oav9i89NB6ATr90I5gwmiOnaf2Mw53wXGYgDEtN1/gGmf/W/gpiuEwiajQN4BjE1uTW7cNn9JavrbElpbXmpKatMldaUlSRrkuWmJlVaZ53CyYqUg6auOpWuSSdL6pLlyeqFWP3+9LFsYMsmkmxWXStzvK77uZ6T9TOZtKF2ll1fqXIAc5wMYrFBJkNvGA6K8sHvoXMb/o1AaXJrS4CY286ydXUbAAf1huAM/Xf3psn59mVAb5suSSbLS+R76RpjUzVuXpJM1lSlTLWprE7WVqRsRV0qmSqprqmucn1W2jpTV1ldUZde1FdQ346NFBWWzsP393JVviOOQLsR0LG0MNyo0dL95orhRuAIh7Z7w3rszrXfjcFT0WxA3bjR0pkJPUtC3p9bF+j3m/w/BVSTW7ObgH0h2zo1UlS4UyN8v5sqB0GTW/vT7k0bLQYY1O8yL+rmigPyZvB6QH46kw7WzkqDtUsjRYW7KAxWE/PBKnabBh6sJre2RDY0uTVoMLVgp88OVhuotdcLHG/aaPGV6gWBlV1vB45lJcWfu9u475Y4SWX+Jtv3uvX0vWGg77/6Tqn7WeakvJHO2Nw046Po2WU65rNqLbsrgOMnEWjolaEbAsdmV7DNYVtNbs3K+ETyImMyreA73ZSutaF9J7iCLNe+Nou570jsB14mszJWuin4zuZg30HjKD6DnFuI32yugGMezuYGLQp6JLDzo2zr3khR4e4KRUGPmBcFYncP5aIAPXhPBQb8nuCAjw4APTP8oDHsCdSxl/Lk2uTWrHDcSyE4b6F0yVr67ZBYdGNVzhUllm5xDtiaenYn0XNzEj1PLdAduznHlsSiMYCOfwXAvnoldCY7vYNrAdDEawftXIkXgrLkMxCfq719wJf/RXziWKynTxxYPdGJQ0tP5LjKD+jZN1M09ZMgrVU1oi+V9QT21QNYOQVnv30zs99gQ2f/vsCqvL9yBWlya39WesIV+j66li/l2teAmPMh/jJAoRodqFSNDvwb4xHJWa59bal8CT9X/SRxAiff/7u6EeerbFvF/AqR9KdxhWjrmNvdQ8nuQTG3W2zuo2D3NgR291awe9uY252NuWi7tyNds9cngZ0rZNv2jRQV3l7h9twOMb89J3bvoHR7jmViO6tlvO2WCedWCnbfAbY729CF4GDgZBbItQXip3Jrt29mbMMvbgB13DHmiV18b0eFsbeTUjG9UwMU0zsCc9rOSutH0TFol+U/BpmGXA6AnCBq6tmbRM8tSPTcRTne5zrO+yXivxygXwKbO7JtV83lADuCK9nwhhAak+5ewMIos52BxqYQ/9tsJojHbhndd2+UWHIDiN0CT+Nkz+0emDVoXBLashFsFpLMjFS7G3AWsnsjLMHoqCSDZzeSKl243lphxrxHzCsFsXuQgt17xtTumtJUylaZmuz4Rtu9FwHf2yjYvTeB3dsq2L0Pgd3bKdi9r9JTcGg9K4F6yryjk5N9M/1JbJc4J2Ne/F98QXCp9NIgUp/PmNxaWS+l3FAV81gh87UqBburgXbnZ8ZguCFx1cC2ulH8daxB64i+HCEGIy/jSl9iNFrPGqCOtTyDx/6XB08tWkeWrFbXCOtAGlmtTsHu/XxWs/sRDMz9457V5KYSOqvtr5DV9gfqOMRnNYrBM+S/mtUOwBme1CBGBvkBCnYf6LOaPZBgYB6kPTARWUiURD2onL1wD7wjuwSIudp7sM9oFAPn4P9qRjsEZ3iJBjEysA9RsPtQn9HsoQQD87C4ZzTJZNmFVkjDtRZZ5Wrv4WBC8sF8SMAAOs2fAehwhbr5MOAsY6ifZVAEs6H/1VnGETjDUxrEyCA/QsHuI/0swx5JMDCPivvVYHHQXcFXg49SyGpHAXU82mc1isFz9H81qx2DM7xUgxgZ5Mco2H2sz2r2WIKBeRxDVtsFnNWOU8hqxwF1PN5nNYrBc3zMs5rVymonEKzcOUHB7hOBhAefR5N+OyQWBSXGTFdJMFhPUtAxUtFcnexk4OBidaiTCRzqFBaHGgZckcLqUMMIHOpUFocaDrwhzOpQwwkc6jQWhzodeO2f1aFOJ3CoM1gc6kzgZTdWhzqTwKHOYnGos3GKlrE61NkEDnUOi0ONwClazupQIwgc6lwWhzoPp2ia1aHOI3Co81kc6gKcohWsDnUBgUNdyOJQF+EUrWR1qIsIHOpiFoe6BKdoFatDXULgUJeyONRInKLVrA41ksChLmNxqFE4RWtYHWoUgUNdzuJQo3GK1rI61GgCh7oCqSMrUe0JiLqSZeSPgSlqaVfUjiFwqKtYHGoszqFo1xmNJXCoq1kcahzOoWjXGY0jcKhrWBxqPM6haNcZjSdwqGtZHGoCzqFo1xlNIHCo61gcaiLOoWjXGU0kcKjrWRxqEs6haNcZTSJwqBtYHGoyzqFo1xlNJnCoG1kcagrOoWjXGU0hcKibWBxqKs6haNcZTSVwqJtZHGoazqFo1xlNI3CoW1gcajrOoWjXGU0ncKhbWRxqBs6haNcZzSBwqNtYHGomzqFo1xnNJHCo2/2yEGNnFRDo6Iky9iUCou5gCdF3whRN0q7fuZMgRN/F4lCzcQ5Fu35nNoFD3e1TibHDCVLJPSwjfw5u5NOui5lDMPLvZXGo+3AORbsu5j4Ch7qfxaHm4hyKdl3MXAKHeoDFoebhHIp2Xcw8Aod6kMWh5uMcinZdzHwCh3qIxaEexjkU7bqYhwkc6hEWh3oU51C062IeJXCox1gc6nGcQ9Gui3mcwKGeYHGoJ3EORbsu5kkCh3rKX4E2tgvBFeinWUb+M7iRT7ve5BmCkf8si0M9h3Mo2n1tniNwqOdZHOoFnEPVsTrUCwQO9SKLQ70EU7SEdv3OSwQO9TKLQ72Ccyja9TuvEDjUqywO9RrOoWj333mNwKFeZ3GoN3AORbvO6A0Ch3rTX98x9pfi+Ov4FsvIX4Ab+bTrdxYQjPy3WRzqHZxD0a7feYfAod5lcaj3cA5Fu37nPQKHep/FoT7AORTt+p0PCBzqQxaH+gjnULTrdz4icKiPWRzqE5xD0a7f+YTAoT5lcajPcA5Fu37nMwKH+pzFob7AORTtvjZfEDjUlywO9RXOoWjXGX1F4FBfszjUNziHol1n9A2BQ33L4lDf4RyKdp3RdwQO9T2LQ/0AUzRFu87oBwKH+pHFoX7CORTtOqOfCBzqZxaH+gXnULTrjH4hcKhfWRzqN5xD0a4z+o3AoX5ncaiFOIei3c9oIYFD/cHiUInGMIeiXQ+Fw0BPx7zGJA6Vj3Mo2vVQ+QQOVcDiUIU4h6JdD1VI4FBFLA5VjHMo2vVQxQQO1YjFoRrjHIp2PVRjAodqwuJQTXEORbseqimBQzVjcajmOIeiXQ/VnMChWrA4VEucQ9Guh2pJ4FCtWByqNc6haNdDtSZwqDYsDtUW51C066HaEjhUOxaHWgHnULTroVYgcKgVWRxqJZiipbTroVYicKiVWRxqFZxD0a6HWoXAodqzONSqOIeiXQ+1KoFDrcbiUKvjHIp2PdTqBA61BotDrYlzKNr1UGsSONRaLA7VAedQtOuhOhA41NosDrUOzqFo10OtQ+BQ67I41Ho4h6JdD7UegUOtz+JQG+AcinY91AYEDrUhi0N1xDkU7XqojgQOtRGLQ22Mcyja9VAbEzjUJiwO1QnnULTroToRONSmLA7VGedQtOuhOhM4VBcWhzI4h6JdD2UIHMqyOFQS51C066GSBA5VwuJQKZxD0a6HShE4VClaR7SCvRolEls2wjtoGdDwQteHSFFi6YbGo09CJwKg9exNoucWYD3zwfrt6Hx/MG6/CLuz62uXRovxZODocOB+GfkBPcsbL/qZdj/z0Erv4JTuG+EQuQauvsC+dgA6luBXkCFfgO2QWBQUmwYw0BogA8ADZABwgNQtalWJiJZj3zZ7EMS3IuPUXRtnyMiSIh/khc51zRCVSOBHrYC4o0LmfqAlNmpp2L2zgt3zWupE60KMnsmMnraiMc7mrrhZmgX6jUVwERUY0MkCyUU3IBca404SoyS0AjCGWgk31742izkf4i+bNcbHwc0axzv+S38DFOL/5jG3u4eS3d1jbnd3Jbt7xNzuPo107O4Zc7s3V+K7V8zt7qfE9xYxt/vUAh27e8fc7r5KfPcB2i1zvU2ddMz0JzlS8sWfsdOJjCnxL8Fa/m9lo/9fCTf4XBWHbRpYL6XnxbxmlzllX4W5aj+gr+dnfD3ckLhqYNuvcfx17I/WMR+soBi8GbCYl77EaLSe/YE6DuAZPPa/PHgGKOj4Z0Nnx4HLf3ZUuZIjwWKgQnbc0mdHuyXBAN8q7tlRFkWgs+NWCtlxK6COW/vsSDF4tmbJjoOW/+yY1CBYgsUghey4jc+OdhuCAb5t3LOjLMVDZ8dtFbLjtkAdt/PZkWLwbMeSHbdf/rNjiQbBEiy2V8iOO/jsaHcgGOCD454dZXExOjsOVsiOg4E67uizI8Xg2ZElO+60/GfHlAbBEix2UsiOO/vsaHcmGOC7xD07bpHAZ8ddFLLjLkAdd/XZkWLw7MqSHXdb/rNjqQbBEix2U8iOu/vsaHcnGOB7xD07phvjs+MeCtlxD6COe/rsSDF49mTJjnst/9mxTINgCRZ7KWTHvX12tHsTDPB94p4dB2ceAEf1l926Au3w+4KBzAfrJwMdSPafgWNfhVnGPsBZRqWfZVAEoUqWWUbV8j/LKNcgWIJFlcIso9rPMmw1wQCvifsso1yhBq9RyI41QB1rfXakGDy1LNmxDji9jNs+O9m+NAiWYFGnkB33AzpOcL8v6beDkrNnAzE6cCKD+/5KuO6fwZV1JlLZKP46DkEGU1aiTiYg6gBPlLHDCIg60BNl7HACog7yRBl7OgFRB3uijD2TgKhDPFHGnk1A1KGeKGNHEBB1mCfK2PMIiDrcE2XsBQREDfVEGXsRAVFHeKKMvYSAqCM9UcaOJCDqKE+UsaMIiDraE2XsaAKijvFEGduegKhjPVHGjiEg6jhPlLFjCYg63hNl7DgCok7wRBk7noCoEz1Rxk4gIOokT5SxEwmIOtkTZewkAqJO8UQZO5mAqGGeKGOnEBB1qifK2KkERA33RBk7jYCo0zxRxk4nIOp0T5SxMwiIOsMTZexMAqLO9EQZO6sg/jqe5Yky9iUCos72RBl7J0HoO8cTZexsAqJGeKJcMUkQ+s71RBk7h2BEneeJMvY+AqLO90QZO5eAqAs8UcbOIyDqQk+UsfMJiLpIay+Y/JCiiA2QUH1dDNxXJmgzev+bS5b//W8it6Y0uTUr23ueAN7is0xhP51LgYOv0PVRFMBSdF0lEd0w/7O0RKffslKdfstTXP2WVSj1W6vUb7lOv0mjxFuVTr8lWvrWcOFbZpVwUIo7ajiUKfVbytWv2jhm81+tuK6VN5Myl8gL9Y0uRPJwfS1VLMGVHQBWFj0B1th9VvZmLwDruRmwwNkXaO/IxvHmN7vBJ6o/KYgvUShwLiPA8VIwjpcq4DgKXCgWJ5YO6ImEwkP9GleXxIAmDWTAxri+TFDfyxsrKnx5Y4WHyYHRVcvu0Y0XAwzqd4mpJTr6jARiegX4kiY6gm2S4QeN4SZAHa8ERyu0jwvHVypklzFK20+PyWw/XZg5V5RYusU5YGvquRGJnh1J9BypPHZzHWOdEovGADr+FQD76pTQmexc1VixFL8SPDVuGiBJ02ERU/q6Rc1EqJtr3zZ7EMRibGaCdXXjDCDZSD82w3Dw3NWZ6B9s6OsHo3KfQSUzI9SOBc7GrgaTi45GMmjGKs2WNW7mngS+mbuHwvsax8X8WofgeAoYxz0VcLyGAMdTwTjupYDjeAIcTwPjuLcCjtcS4HgGGMd9FHCcQIDjWWAc91XA8bqYX6UQHM9RsHsigd3nKth9PYHd5yvYPYnA7gsV7L6BwO6LFeyeTGD3pQp230hg92UKdk8hsPtyBbtvIrD7CgW7pxLYfaWC3TcT2H2Vgt3TCOy+WsHuWwjsvkbB7ukEdl+rYPetBHZfp2D3DAK7r1ew+zYCu29QsHsmgd03Kth9O4HdNynYPYvA7psV7L6DwO5bFOy+k8DuWxXsvovA7tsU7J5NYPftCnbfTWD3LAW77yGw+w4Fu+cQ2H2Xgt33Eth9t4Ld9xHYfY+C3fcT2H2vgt1zCey+X8HuBwjsfkDB7nkEdj+oYPeDBHY/pGD3fAK7H1Gw+yECux9TsPthArufULD7EQK7n1Kw+1ECu59WsPsxArufVbD7cQK7n1ew+wkCu19UsPtJArtfVrD7KQK7X1Ww+2kCu19XsPsZArvfVLD7WQK731Kw+zkCu99WsPt5ArvfVbD7BQK731ew+0UCuz9UsPslArs/VrD7ZQK7P1Ww+xUCuz9XsPtVAru/VLD7NQK7v1aw+3UCu79VsPsNAru/V7D7TQK7f1Sw+y0Cu39WsHsBgd2/Ktj9NoHdvyvY/Q6B3X8o2P0ugd15Cru1vUdgd4GC3e8T2F2kYPcHBHY3UrD7QwK7myjY/RGB3c0U7P6YwO4WCnZ/QmB3KwW7PyWwu42C3Z8R2N1Owe7PCexeUcHuLwjsXlnB7i8J7G6vYPdXBHavpmD31wR2r6Fg9zcEdq+lYPe3BHavrWD3dwR2r6tg9/cEdq+vYPcPBHZvqGD3jwR2b6Rg908Edm+iYPfPBHZvqmD3LwR2d1Gw+1cCu62C3b8R2F2iYPfvBHaXKti9EGi3vL+gs5N9M/3Jnu+yX7nstS37RMsex7I/r+xVK/u2yh6msp+n7G0p+zzKnoey/5/shSf7wskeabJfmOydJftIyZ5Ksr+Q7LUj+87IHiyyH4nszSH7VMieDbJ/gTzLL8+1yzPe8ryzPPsrz8HKM6HyfKQ8KyjPzckzZPI8lTxbJM/ZyDMn8vyFPIsg6/Jljbqs15a1y7KOV9a0yvpOWeso6/5kDZysB5O1UbJOSNbMyPoRWUsh6wrkHrvcb5Z7r3IfUu7Jyf0puVcj9y3kGr5cz5Zru3KdU675yfUvuRYk10XkGoHUy1I7Sh0lNYXMr2WuKfMumYNIPpbcJHFaYpaMX/Fl4TXbwL5YJu+V0HjT0h9AX8zP+GK4ofpXwtYiMdDSUd4vCNUxH6ygGBx88w3ihSBiNFrPIJC56pjXhGbw2P/y4MlDDx6t6I52duSAzOdxdjVHym8Sfx0L4p4p5IWI6ExRoJApCoCZotBnCorBU/gfzRRJ5IAs8pnCFhE4e7G2syMiuyiJekljTWkqZatMDfANnUuAmKu9jXyWoBg4jf6jWaIEmSUa+yxhGxM4e5O4ZwnJDtmXWSMN13qRda72NgUTkg/mQ4IE0Gn+vIjRVKG+awLM3M185qYIZs3+o5k7hczczX3mts0JnL1F3K8EilNeBb4S2EIhU7QAZoqWPlNQDJ6W/9FMUYrMFK18prCtCJy9dcyd3Y5UWv7yTUus4RpXQFs3wde2rYEZrQ2w1kPywZodGQJGm7gHDIYVFW2BIAp+BRkcpd8OiUW2M2bMykbx17EdcgCwEnUyAVEreKKMHUZA1IqeKGOHExC1kifK2NMJiFrZE2XsmQREreKJMvZsAqLae6KMHUFA1KqeKGPPIyBqNU+UsRcQELW6J8rYiwiIWsMTZewlBESt6YlyN3YIiFrLE+UuqBMQ1cETZexoAqLW9kS5YpKAqHU8UcaOISBqXU+UsWMJiFrPE2XsOAKi1vdEGTuegKgNPFHGTiAgakNPlLETCYjq6IkydhIBURt5ooydTEDUxp4oY6cQELWJJ8rYqQREdfJEGTuNgKhNPVHGTicgqrMnytgZBER18UQZO5OAKOOJMnZWQfx1tJ4oY18iICrpiTL2ToLQV+KJMnY2AVEpT5SxwwlCX6knytg5BCOqzBNl7H0ERJV7ooydS0BU2hNl7DwCoio8UcbOJyCqqyfK2IcJiOrmiTL2UQKiNvNEGfs4AVGbe6KMfZKAqO6eKHevh+DKRA9PlLHPEIyonp4oY58jIKqXJ8rYFwiI2sIT5W4cEhDV2xNl7CsERPXxRBn7GgFRfT1Rxr5BQFQ/T5SxvxTHX8f+nihjFxCMqAGeKGPfISBqoCfK2PcIiNrSE2XsBwREbeWJMvYjAqK29kQZ+wkBUYM8UcZ+RkDUNp4oY78gIGpbT5SxXxEQtZ0nythvCIja3hNl7HcERO3giTL2BwKiBnuijP2JgKgdPVHu6jkBUTt5ooz9jYConT1Rxi4kIGoXT5Sxicbx13FXT5Sx+QRE7eaJMraQgKjdPVHGFhMQtYcnytjGBETt6YkytikBUXt5ooxtTkDU3p4oY1sSELWPJ8rY1gRE7euJMrYtAVGVnihjVyAgqsoTZexKBERVe6KMXYWAqBpPlLGrEhBV64kydnUCouo8UcauSUDUfp4oYzsQELW/J8rYdQiIGuKJMnY9AqIO8EQZuwEBUQd6ooztSEDUQZ4oYzcmIOpgT5SxnQiIOsQTZWxnAqIO9UQZawiIOswTZWySgKjDPVHGpgiIGookqtB1IlK0NFf4mVoCD66GnhuR6NmRRM+RjTn0bAocWPkBPY9osujnke5nHlrp0Q7cTVw/+aF+S0xZKlVbnqy1JbbSJCuq0qUmVVpVlrZpW5ourUmmS0pq06l0eUVVRbmpsKmSWltXWlFSl+l4E2Bfo3EOYAW/ggz5AmyHxKIA1jSAgaaTXAawpW5Rq4pQN9e+bfYgiMVRGQc8ukkGkCyA8kFe6NzRGVCDrUARxH/pXMmMc9mjmuAc9egmOuSiByfS5mNwUc8mEvgBJ4FIAkgBGEOtAJdrX8fGnA/xl2ObLN1vjOw2GmNuM8fx5sBEJv0Naby0nia3ZjcH+uJxBJx0B3NygAIn3YGcHE/ASQ8wJwcqcNIDyMkJBJz0BHNykAInPYGcnEjASS8wJwcrcNILyMlJBJxsAebkEAVOtgBycjIBJ73BnByqwElvICenEHDSB8zJYQqc9AFyMgzMCbouEwwPb4yvy04lsHuogt3DCew+QsHu0wjsPlLB7tMJ7D5Kwe4zCOw+WsHuMwnsPkbB7rMI7D5Wwe6zCew+TsHucwjsPl7B7hEEdp+gYPe5BHafqGD3eQR2n6Rg9/kEdp+sYPcFBHafomD3hQR2D1Ow+yICu09VsPtiAruHK9h9CYHdpynYfSmB3acr2D2SwO4zFOy+jMDuMxXsHkVg91kKdl9OYPfZCnaPJrD7HAW7ryCwe4SC3VcS2H2ugt1jCOw+T8HuqwjsPl/B7rEEdl+gYPfVBHZfqGD3OAK7L1Kw+xqg3bKWu4uTjpn+ZJ2prGuUdXSybkvWCcm6FFkHIffd5R603I+Ve5Nyn07uWcn9G7mXIdf15Rq3XO+Va59yHVCuicn1IblWItcNpIaWelJqK6kzZM4t80+Zi8m8RHK05CuJ3RLHZEyLfwvX12QenlDgKi3PQWispR4PfpKpS2LphupfCVuLxEBLx2vROuaDFRSDjwU+bCJ9idFoPa8F6jiBZ/DY//LgmYDWUSu6o50dOSCv85nCXkfg7BPjnink4X50ppioMHgmAnW83mcKisFz/X80UySRA3KSzxR2EoGz3xD3TLFRAp8pblDIFDcAdZzsMwXF4Jn8H80UJcgBeaPPFPZGAmefEvdM0bQJPlNMUcgUU4A63uQzBcXguek/milSyAE51WcKO5XA2W+Oe6aQG4noTHGzQqa4GajjNJ8pKAbPtP9opihFDshbfKawtxA4+/S4Z4ojFWqK6QqZYjpQx1t9pqAYPLf+RzNFGXJAzvCZws4gcPbb4p4pRjbGZ4rbFDLFbUAdZ/pMQTF4Zv5HM0U5ckDe7jOFvZ3A2WfF3NntEU10lnG3bYU1XGPLbiEH/XqAWcBBfgfOeSySD9bsyBAw7oh7wGBYGXwnEMTg+0Wk3w5KxGcDcZxxvUsJ17sCuGZbGAdEwEf1NbsJNtihfekKN0avbIxPbiOBe9LeDeTjm5Z+NlzZKP463oNMbqxEnUxA1BxPlLHDCIi61xNl7HACou7zRBl7OgFR93uijD2TgKi5nihjzyYg6gFPlLEjCIia54ky9jwCoh70RBl7AQFR8z1Rxl5EQNRDnihjLyEg6mFPlLsOS0DUI54oY0cREPWoJ8rY0QREPeaJMrY9AVGPe6KMHUNA1BOeKGPHEhD1pCfK2HEERD3liTJ2PAFRT3uijJ1AQNQznihjJxIQ9awnythJBEQ954kydjIBUc97ooydQkDUC54oY6cSEPWiJ8rYaQREveSJMnY6AVEve6KMnUFA1CueKGNnEhD1qifK2FkF8dfxNU+US9QERL3uiTL2ToLQ94YnytjZBES96YkydjhB6HvLE2XsHIIRtcATZex9BES97Ykydi4BUe94ooydR0DUu54oY+cTEPWe9raPue6DIXt+jGuMM1j6a6ewJ8044D4i74NJ0eDkGjAnKyhwcg2Qkw8IOBkP5mRFBU7GAzn5kICTa8GcrKTAybVATj4i4GQCmJOVFTiZAOTkYwJOrgNzsooCJ9cBOfmEgJOJYE7aK3AyEcjJpwScXA/mZFUFTq4HcvIZASeTwJyspsDJJCAnnxNwcgOYk9UVOLkByMkXBJxMBnOyhgInk4GcfEnAyY1gTtZU4ORGICdfEXAyBczJWgqcTAFy8jUBJzeBOemgwMlNQE6+IeBkKpiTtRU4mQrk5FsCTm4Gc7KOxmtfgZx8R8DJNDAn6ypwMg3IyfcEnNwC5mQ9BU5uAXLyAwEn08GcrK/xIlIgJz8ScHIrmJMNFDi5FcjJTwSczABzsqECJzOAnPxMwMltYE46arwaE8jJLwSczARzspECJzOBnPxKwMntYE42VuDkdiAnvxFwMgvMySYKnMwCcvI7ASd3gDnppMDJHUBOFhJwcieYk00VOLkTyMkfBJzcBeakswIndwE5STSNPyezwZx0UeBkNpCTPAJO7gZzYhQ4uRvIST4BJ/eAObEKnNwD5KSAgJM5YE6SCpzMAXJSSMDJvWBOShQ4uRfISREBJ/eBOUkpcHIfkJNiAk7uB3NSqsDJ/UBOGhFwMhfMSZkCJ3OBnDQm4OQBMCflCpw8AOSkCQEn88CcpBU4mQfkpCkBJw+COalQ4ORBICfNCDiZD+akqwIn84GcNCfg5CEwJ90UOHkIyEkLAk4eBnOymQInDwM5aUnAySNgTjZX4OQRICetCDh5FMxJdwVOHgVy0pqAk8fAnPRQ4OQxICdtCDh5HMxJTwVOHgdy0paAkyfAnPRS4OQJICftCDh5EszJFgqcPAnkZAUCTp4Cc9JbgZOngJysSMDJ02BO+ihw8jSQk5UIOHkGzElfBU6eAXKyMgEnz4I56afAybNATlYh4OQ5MCf9FTh5DshJewJOngdzMkCBk+eBnKxKwMkLYE4GKnDyApCT1Qg4eRHMyZYKnLwI5GR1Ak5eAnOylQInLwE5WYOAk5fBnGytwMnLQE7WJODkFTAngxQ4eQXIyVoEnLwK5mQbBU5eBXLSgYCT18CcbKvAyWtATtYm4OR1MCfbKXDyOpCTdQg4eQPMyfYKnLwB5GRdAk7eBHOygwInbwI5WY+Ak7fAnAxW4OQtICfrE3CyAMzJjgqcLABysgEBJ2+DOdlJgZO3gZxsSMDJO2BOdlbg5B0gJx0JOHkXzMkuCpy8C+RkIwJO3gNzsqsCJ+8BOdmYgJP3wZzspsDJ+0BONiHg5AMwJ7srcPIBkJNOBJx8COZkDwVOPgRysikBJx+BOdlTgZOPgJx0JuDkYzAneylw8jGQky4EnHwC5mRvBU4+AXJiCDj5FMzJPgqcfArkxBJw8hmYk30VOPkMyEmSgJPPwZxUKnDyOZCTEgJOvgBzUqXAyRdATlIEnHwJ5qRagZMvgZyUEnDyFZiTGgVOvgJyUkbAyddgTmoVOPkayEk5ASffgDmpU+DkGyAnaQJOvgVzsp8CJ98COakg4OQ7MCf7K3DyHZCTrgScfA/mZIgCJ98DOelGwMkPYE4OUODkByAnmxFw8iOYkwMVOPkRyMnmBJz8BObkIAVOfgJy0p2Ak5/BnByswMnPQE56EHDyC5iTQxQ4+QXISU8CTn4Fc3KoAie/AjnpRcDJb2BODlPg5DcgJ1sQcPI7mJPDFTj5HchJbwJOFoI5GarAyUIgJ33AnGRbAdjmUWBeUPj1BeJX6Ppw7pLISyzd8sB4dsH1ZYL69muqqLB0ngfut39TnDNo2d2/6WKAQf2q6Drbee/dTZbuN1dcX2ilE6QKwfYf2wRn8wBcYLFtcfhZIBc2ygdzXmCWGS/opGuAOg5sGu9xLL43sCmemy2bYpNOQcZ26bdDYsmGnhwOBOaJrZpix1C2xTmebb38x7PIosTk1uxlbrJ6bBNsf7MVihKkrwwCT6olThQllm5xnlRr6tmZRM9NSfTcWjmf57zAO7FoDKDHfAGwL5vAzg2ybZvAPAZO/EBwoGoaICmR0AnSyCspkkj6AovTukVticEK6ttmD4L4bpvRfbumGefIzii3zXhN8Nx2gVkm2pFGZbI8euS/3Eo3Mpnc2v8cCG33Kw10xeBf6pnM6Gm3BVYV2wFn2EC/sQgugoEB7SsSxLdVusKGDuDjwNWAjL/3FeLO9k3jjeM1Cjh+oIDjDjHHcbwCjh8q4Dg45jheq4DjRwo47hhzHCco4PixAo47xRzH6xRw/EQBx51jjuNEBRw/VcBxl5jjeL0Cjp8p4LhrzHGcpIDj5wo47hZzHG9QwPELBRx3jzmOkxVw/FIBxz1ijuONCjh+pYDjnjHHcYoCjl8r4LhXzHG8SQHHbxRw3DvmOE5VwPFbBRz3iTmONyvg+J0CjvvGHMdpCjh+r4BjZcxxvEUBxx8UcKyKOY7TFXD8UQHH6pjjeKsCjj8p4FgTcxxnKOD4swKOtTHH8TYFHH9RwLEu5jjOVMDxVwUc94s5jrcr4PibAo77xxzHWQo4/q6A45CY43iHAo4LFXA8IOY43qmA4x8KOB4YcxzvUsAxobAu7KCY4zhbAcc8BRwPjjmOdyvgmK+A4yExx/EeBRwLFHA8NOY4zlHAsVABx8NijuO9CjgWKeB4eMxxvE8Bx2IFHIfGHMf7FXBspIDjETHHca4Cjo0VcDwy5jg+oIBjEwUcj4o5jvMUcGyqgOPRMcfxQQUcmyngeEzMcZyvgGNzBRyPjTmODyng2EIBx+NijuPDCji2VMDx+Jjj+IgCjq0UcDwh5jg+qoBjawUcT4w5jo8p4NhGAceTYo7j4wo4tlXA8eSY4/iEAo7tFHA8JeY4PqmA4woKOA6LOY5PKeC4ogKOp8Ycx6cVcFxJAcfhMcfxGQUcV1bA8bSY4/isAo6rKOB4esxxfE4Bx/YKOJ4RcxyfV8BxVQUcz4w5ji8o4LiaAo5nxRzHFxVwXF0Bx7NjjuNLCjiuoYDjOTHH8WUFHNdUwHFEzHF8RQHHtRRwPDfmOL6qgGMHBRzPizmOrynguLYCjufHHMfXFXBcRwHHC2KO4xsKOK6rgOOFMcfxTQUc11PA8aKY4/iWAo7rK+B4ccxxXKCA4wYKOF4ScxzfVsBxQwUcL405ju8o4NhRAceRMcfxXQUcN1LA8bKY4/ieAo4bK+A4KuY4vq+A4yYKOF4ecxw/UMCxkwKOo2OO44cKOG6qgOMVMcfxIwUcOyvgeGXMcfxYAccuCjiOiTmOnyjgaBRwvCrmOH6qgKNVwHFszHH8TAHHpAKOV8ccx88VcCxRwHFczHH8QgHHlAKO18Qcxy8VcCxVwHF8zHH8SgHHMgUcr405jl8r4FiugOOEmOP4jQKOaQUcr4s5jt8q4FihgOPEmOP4nQKOXRVwvD7mOH6vgGM3BRwnxRzHHxRw3EwBxxtijuOPCjhuroDj5Jjj+JMCjt0VcLwx5jj+rIBjDwUcp8Qcx18UcOypgONNMcfxVwUceyngODXmOP6mgOMWCjjeHHMcf1fAsbcCjtNijuNCBRz7KOB4CxDHAunDyb6Z/uSd0PI+Y3kXr7xHVt6BKu/vlHdPynsT5Z1/8r46edeavCdM3nEl72eSdwvJe3HknS7yPhJ5l4a8B0LeYSD778ve8bLvuezZLftNy17Jss+v7FEr+6vK3qCyr6XsySj7CcpeeLKPm+xBJvtnyd5Psm+R7Lkj+8XIXieyT4fsMSH7I8iz/fJcujxTLc8Dy7Os8hymPEMoz7/Js1vy3JE8MyPPe8izCrLOXtaIy/pmWZsr60plTaSs55O1aLKOStYAyfoVWXsh6wbknrfcr5V7jXKfTO7xyP0JubYu14XlmqZcj5NrSXIdRGp4qT+ldpJ5v8xZZb4lcwXJcxKjJb7I2BBew60A7DvTcb5TBnz/fNkrrbCxITzmTG7NyvvnpyuM5VuBYzk/M5bDDYmrBrZIDLR0nIHWEZ28xOCBTXGOKX2J0Wg9ZwB1vI1n8Fgtx2QYPLcp6PhnQ2fHmct/drQaBEuwmKmQHW/32dHeTjDAZ8U9O3ZJ4LPjLIXsOAuo4x0+O1IMnjtYsuOdy392TGoQLMHiToXseJfPjvYuggE+G60j2pHEQUXJApDhNaWplK0yNQOb6oCYq713+8xIMXDuZsmM9yz/mbFEg2AJEPcoZMY5PjPaOQQD/N64Z0YJFBKCUZkx02wBsC8LtPc+MCH5YD4kYACd5s8AdJ9CHX8vcLZyv5+tUASz+1lmK3OX/9lKSoNgCRZzFWYrD/jZin2AYIDPi/tVbnHQbcBXuecpZMd5QB0f9NmRYvA8yJId5y//2bFUg2AJFvMVsuNDPjvahwgG+MMM2XFrcHZ8WCE7PgzU8RGfHSkGzyMs2fFR4MUXYHa0DCukHlXIjo8BHScv4y/yU/rtkFgU3BgzZmWj+Ov4OHLQsxJ1MgFRT3iijB1GQNSTnihjhxMQ9ZQnytjTCYh62hNl7JkERD3jiTL2bAKinvVEGTuCgKjnPFHGnkdA1POeKGMvICDqBU+UsRcREPWiJ8rYSwiIeskTZexIAqJe9kQZO4qAqFc8UcaOJiDqVU+Use0JiHrNE2XsGAKiXvdEGTuWgKg3PFHGjiMg6k1PlLHjCYh6yxNl7AQCohZ4ooydSEDU254oYycREPWOJ8rYyQREveuJMnYKAVHveaKMnUpA1PueKGOnERD1gSfK2OkERH3oiTJ2BgFRH3mijJ1JQNTHnihjZxXEX8dPPFHGvkRA1KeeKGPvJAh9n3mijJ1NQNTnnihjhxOEvi88UcbOIRhRX3qijL2PgKivPFHGziUg6mtPlLHzCIj6xhNl7HwCor71RBn7MAFR33mijH2UgKjvPVHGPk5A1A+eKGOfJCDqR0+UsV0Irkz85Iky9hmCEfWzJ8rY5wiI+sUTZewLBET96olyNw4JiPrNE2XsKwRE/e6JMvY1AqIWeqKMfYOAqD88UW5GVRx/HRPNPFF2AcGIyvNEGfsOAVH5nihj3yMgqsATZewHBEQVeqKM/YiAqCJPlLGfEBBV7Iky9jMCohp5ooz9goCoxp4oY78iIKqJJ8rYbwiIauqJMvY7AqKaeaKM/YGAqOaeKGN/IiCqhSfKXT0nIKqlJ8rd5iYgqpUnyt09JSCqtSfK3ZRrHH8d23ii3L0eAqLaeqLcLQQCotp5otyVaQKiVvBEuQueBESt6Ily19EIiFrJE+UuzxAQtbInylX9BESt4okytjUBUe09Ua5GISBqVU+Um/oSELWaJ8rNqAiIWt0T5RI1AVFreKJc/Ccgak1PlAsrBESt5Yly3kpAVAdPlAOBgKi1PVHGrkNA1DqeKGPXIyBqXU+UsRsQELWeJ8rYjgREre+JMnZjAqI28EQZ24mAqA09UcZ2JiCqoyfKWENA1EaeKGOTBERt7IkyNkVA1CbN8Dr+2QpCipaYslSqtjxZa0tspUlWVKVLTaq0qixt07Y0XVqTTJeU1KZT6fKKqopyU2FTJbW2rrSipC7TeSecovblVri+XsH1ZQpdHyJFiaUbfB/dhA7x8PkDiZ6bgvXMB+s3sGkiMQC38ZndyvW1ddPFeDJwdB9w47f8gJ6bNlv0s7P7mYdWun/TRdkv7BC5BlQD7Ks/0LEEv4IM+QJsh8SioNg0gIHWABkEHiCDgAOkblGrSkS0HPu22YMgvl0yTm2aZcjIkiIf5IXOmQxRiQR+1GaJCfebq9Ne1xobtdB2b6Vk98TWOtG6EKNnMqOn7dIMGOyAs0eg31gEF1GBAZ0skFxYIBca406cWhIauoLRSri59pWMOR/iL8lm+DiYBJe+6AnJsU0SiXua4Po7zvU1uwkexxICHOcAcTxeCccUAY73AnE8QQnHUgIc7wPieKISjmUEON4PxPEkJRzLCXCcC8TxZCUc0wQ4PgDE8RQlHCsIcJwHxHGYEo5dCXB8EIjjqUo4diPAcT4Qx+FKOG5GgONDQBxPU8JxcwIcHwbieLoSjt0JcHwEiOMZSjj2IMDxUSCOZyrh2JMAx8eAOJ6lhGMvAhwfB+J4thKOWxDg+AQQx3OUcOxNgOOTQBxHKOHYhwDHp4A4nquEY18CHJ8G4nieEo79CHB8Bojj+Uo49ifA8Vkgjhco4TiAAMfngDheqITjQAIcnwfieJESjlsS4PgCEMeLlXDcigDHF4E4XqKE49YEOL4ExPFSJRwHEeD4MhDHkUo4bkOA4ytAHC9TwnFbAhxfBeI4SgnH7QhwfA2I4+VKOG5PgOPrQBxHK+G4AwGObwBxvEIJx8EEOL4JxPFKJRx3JMDxLSCOY5Rw3IkAxwVAHK9SwnFnAhzfBuI4VgnHXQhwfAeI49VKOO5KgOO7QBzHKeG4GwGO7wFxvEYJx92BOMqzVvLwUMesbq5veR5C1vLLOnRZQy3rf2Xtqqy7lDWDst5N1mrJOqM/18g4kbUJcl9d7gnL/Uy5Fyf3keQeiFy/l2vPct1UrvnJ9Sq51iLXCaTGlfpMaguZF8ucTuYjkkslD0gMk/EnvrN75sHYYEM/K7YHDts08HnFNPrZUfjeOA63PRSeFdsT6Ov5GV8PNySuGtgiMdDScS+0jujgLgYngQ/TSl9iNFrPvYA67s0zeOx/efDsraDjnw2dHfdZ/rOjypPUEiz2UciO+/rsaPclGOCVcc+OsikZOjtWKmTHSqCOVT47UgyeKpbsWL38Z8ekBsESLKoVsmONz462hmCA18Y9O8pWmOjsWKuQHWuBOtb57EgxeOpYsuN+y392LNEgWILFfgrZcX+fHe3+BAN8SNyzo2zui86OQxSy4xCgjgf47EgxeA5gyY4HLv/ZMaVBsASLAxWy40E+O9qDCAb4wXHPjvJ6AnR2PFghOx4M1PEQnx0pBs8hLNnx0OU/O5ZqECzB4lCF7HiYz472MIIBfnjsr6w2w2fHwxWy4+FAHYf67EgxeIayZMcjlv/sWKZBsASLIxSy45E+O9ojCQb4UXHPjvLauIEKr45DO/zRyg92IGYFQLL/DBxHK8wyjgLOMo7xswyKIHQMyyzj2OV/llGuQbAEi2MVZhnH+VmGPY5ggB8f+yvUCjX48QrZ8Xigjif47EgxeE5gyY4nAqeXcXvPZbYvDYIlWJyokB1PAjpO8H270m8HJWfPBmJ04EQG95OVcD05gyvrTKSyUfx1PAUZTFmJOpmAqGGeKAcCAVGneqKMHU5A1HBPlLGnExB1mifK2DMJiDrdE2Xs2QREneGJMnYEAVFneqKMPY+AqLM8UcZeQEDU2Z4oYy8iIOocT5SxlxAQNcITZexIAqLO9UQZO4qAqPM8UcaOJiDqfE+Use0JiLrAE2XsGAKiLvREGTuWgKiLPFHGjiMg6mJPlLHjCYi6xBNl7AQCoi71RBk7kYCokZ4oYycREHWZJ8rYyQREjfJEGTuFgKjLPVHGTiUgarQnythpBERd4YkydjoBUVd6ooydQUDUGE+UsTMJiLrKE2XsrAKCC8eeKGNfIiDqak+UsXcShL5xnihjZxMQdY0nytjhBKFvvCfK2DkEI+paT5Sx9xEQNcETZexcAqKu80QZO4+AqImeKGPnExB1vdZeMPkhRREbIKH6mgTcVyZoM3r/mxuW//1vIremNLk1K9t7Pgre4rOTwn46k4GDr9D10SSxWMdgQweNFK4vE9T3xmaKCt/YTOFGNjAoadk9pdligEH9RuqKCPCy/2sBGIMkMIgeDeS7aRtdPkxurd6Ns3K1+yYgH0AMrYZPl2bGHzrBlQJ1nNos3n4o/jJVIfnerLTp2s2BzeyyDT2GpgLj0LRmumPI5NbU4tAt8YxDKhPi7IaQqP6kgLpBYUxOB0+IZUwWJZZucZ4Qa+pZQqJnkkTPW5RzZ67jSd7wImMAHU8KgH2VJbB5ONtuDcQn/MJYcKBqGiApkdBJAJPBCWAysLCsW9SWvISI6dtmD4L4zsjofluzjHNkZ28zMl4TPHeb4vbEWWLQI79FzKvLSUp2t2yjkzkKMXomM3raGcAZ/G3AgQ30G4vgIhgY0L4iQXyG0tUxjUvaj4MvaW+v8Naqmc3ij+MTYBx3UMDxdgIcnwTjOFgBx1kEOD4FxnFHBRzvIMDxaTCOOyngeCcBjs+AcdxZAce7CHB8FozjLgo4zibA8Tkwjrsq4Hg3AY7Pg3HcTQHHewhwfAGM4+4KOM4hwPFFMI57KOB4LwGOL4Fx3FMBx/sIcHwZjONeCjjeT4DjK2Ac91bAcS4Bjq+CcdxHAccHCHB8DYzjvgo4ziPA8XUwjpUKOD5IgOMbYByrFHCcT4Djm2AcqxVwfIgAx7fAONYo4PgwAY4LwDjWKuD4CAGOb4NxrFPA8VECHN8B47ifAo6PEeD4LhjH/RVwfJwAx/fAOA5RwPEJAhzfB+N4gAKOTxLg+AEYxwMVcHyKAMcPwTgepIDj0wQ4fgTG8WAFHJ8hwPFjMI6HKOD4LAGOn4BxPFQBx+cIcPwUjONhCjg+T4DjZ2AcD1fA8QUCHD8H4zhUAccXCXD8AozjEQo4vkSA45dgHI9UwPFlAhy/AuN4lAKOrxDg+DUYx6MVcHyVAMdvwDgeo4DjawQ4fgvG8VgFHF8nwPE7MI7HKeD4BgGO34NxPF4BxzcJcPwBjOMJCji+RYDjj2AcT1TAcQEBjj+BcTxJAce3CXD8GYzjyQo4vkOA4y9gHE9RwPFdAhx/BeM4TAHH9whw/A2M46kKOL5PgOPvYByHK+D4AQGOC8E4nqaA44cEOP4BxvF0BRw/IsAx0QyL4xkKOH5MgGMeGMczFXD8hADHfDCOZyng+CkBjgVgHM9WwPEzAhwLwTieo4Dj5wQ4FoFxHKGA4xcEOBaDcTxXAccvCXBsBMbxPAUcvyLAsTEYx/MVcPyaAMcmYBwvUMDxGwIcm4JxvFABx28JcGwGxvEiBRy/I8CxORjHixVw/J4AxxZgHC9RwPEHAhxbgnG8VAHHHwlwbAXGcaQCjj8R4NgajONlCjj+TIBjGzCOoxRw/IUAx7ZgHC9XwPFXAhzbgXEcrYDjbwQ4rgDG8QoFHH8nwHFFMI5XKuC4kADHlcA4jlHA8Q8CHFcG43iVAo6J5vHHcRUwjmMVcMwjwLE9GMerFXDMJ8BxVTCO4xRwLCDAcTUwjtco4FhIgOPqYBzHK+BYRIDjGmAcr1XAsZgAxzXBOE5QwLERAY5rgXG8TgHHxgQ4dgDjOFEBxyYEOK4NxvF6BRybEuC4DhjHSQo4NiPAcV0wjjco4NicAMf1wDhOVsCxBQGO64NxvFEBx5YEOG4AxnGKAo6tCHDcEIzjTQo4tibAsSMYx6kKOLYhwHEjMI43K+DYlgDHjcE4TlPAsR0BjpuAcbxFAccVgDgWuD6STvbN9CfvhJb3Gcu7eOU9svIOVHl/p7x7Ut6bKO/8k/fVybvW5D1h8o4reT+TvFtI3osj73SR95HIuzTkPRDyDgPZf1/2jpd9z2XPbtlvWvZKln1+ZY9a2V9V9gaVfS1lT0bZT1D2wpN93GQPMtk/S/Z+kn2LZM8d2S9G9jqRfTpkjwnZH0Ge7Zfn0uWZankeWJ5llecw5RlCef5Nnt2S547kmRl53kOeVZB19rJGXNY3y9pcWVcqayJlPZ+sRZN1VLIGSNavyNoLWTcg97zlfq3ca5T7ZHKPR+5PyLV1uS4s1zTlepxcS5LrIFLDS/0ptZPM+2XOKvMtmStInpMYLfFFxobwGm4FYN9ZEec7ZcD3z5e1bIONDeExZ3JrVt4/L9ihx/JKwLGcnxnL4YbEVQNbJAZaOq6M1hGdvMTgqc1wjil9idFoPYNA5qrjKjyDx2o5JsPgWUVBxz8bOju2X/6zo9UgWIJFe4XsuKrPjnZVggG+WtyzYyqBz46rKWTH1YDZcXWfHSkGz+os2XGN5T87JjUIlmCxhkJ2XNNnR7smwQBfC60j2pHEQUXJApDhNaWplK0yNVOb6YCYq70dfGakGDgdWDLj2st/ZizRIFgCxNoKmXEdnxntOgQDfN24Z0YJFGUJXGbMNFsA7KsMaO96yrdoETMVoNP8GYDWU6jj1wXOVtb3sxWKYLY+y2xlg+V/tpLSIFiCxQYKs5UN/WzFbkgwwDvG/Sq3OOit4KvcHRWyY0dgdtzIZ0eKwbMRS3bcePnPjqUaBEuw2FghO27is6PdhGCAd2LIjreAs2MnhezYCZgdN/XZkWLwbMqSHTsDL74As6NlWCHVWSE7dgE6Tl7GX+Sn9NshsSi4MWbMykbx19EgBz0rUScTEGU9UcYOIyAq6YkydjgBUSWeKGNPJyAq5Yky9kwCoko9UcaeTUBUmSfK2BEERJV7oow9j4CotCfK2AsIiKrwRBl7EQFRXT1Rxl5CQFQ3T5SxIwmI2swTZewoAqI290QZO5qAqO6eKGPbExDVwxNl7BgConp6oowdS0BUL0+UseMIiNrCE2XseAKienuijJ1AQFQfT5SxEwmI6uuJMnYSAVH9PFHGTiYgqr8nytgpBEQN8EQZO5WAqIGeKGOnERC1pSfK2OkERG3liTJ2BgFRW3uijJ1JQNQgT5Sxswrir+M2nihjXyIgaltPlLF3EoS+7TxRxs4mIGp7T5SxwwlC3w6eKGPnEIyowZ4oY+8jIGpHT5SxcwmI2skTZew8AqJ29kQZO5+AqF08UcY+TEDUrp4oYx8lIGo3T5SxjxMQtbsnytgnCYjawxNlbBeCKxN7eqKMfYZgRO3liTL2OQKi9vZEGfsCAVH7eKLcjUMCovb1RBn7CgFRlZ4oY18jIKrKE2XsGwREVXuijP2lOP461niijF1AMKJqPVHGvkNAVJ0nytj3CIjazxNl7AcERO3viTL2IwKihniijP2EgKgDPFHGfkZA1IGeKGO/ICDqIE+UsV8REHWwJ8rYbwiIOsQTZex3BEQd6oky9gcCog7zRBn7EwFRh3ui3NVzAqKGeqKM/Y2AqCM8UcYuJCDqSE+UsYnG8dfxKE+UsfkERB3tiTK2kICoYzxRxhYTEHWsJ8rYxgREHeeJMrYpAVHHe6KMbU5A1AmeKGNbEhB1oifK2NYERJ3kiTK2LQFRJ3uijF2BgKhTPFHGrkRA1DBPlLGrEBB1qifK2FUJiBruiTJ2dQKiTvNEGbsmAVGne6KM7UBA1BmeKGPXISDqTE+UsesREHWWJ8rYDQiIOtsTZWxHAqLO8UQZuzEBUSM8UcZ2IiDqXE+UsZ0JiDrPE2WsISDqfE+UsUkCoi7wRBmbIiDqwuZ4Hf9sBSFFS0xZKlVbnqy1JbbSJCuq0qUmVVpVlrZpW5ourUmmS0pq06l0eUVVRbmpsKmSWltXWlFSl+n8IpyitkUb4HoLXF+m0PUhUpRYusGdM6FDPFrPEhI9k2A988H6TW2WSNzUDNffNNfXLc0W48nA0XrAYJcf0PPi5ot+XuJ+5qGVnuJALo1wiFwDaimwrylAxxL8CjLkC7AdEouCYtMABloDZDp4gEwHDpC6Ra0qEdFy7NtmD4L4Xppx6pHNM2RkSZEP8kLnRmaISiTwozZLTLjfXJ32lTbYqIW2e5qS3a+20YnWhRg9kxk97aXNcTaPBM4egX5jEVxEBQZ0skBycRmQC41xJ4lREhq6gtFKuLn2NSrmfIi/jGqOj4OjwKUveswlHcclwAmJ9HdKM/zEqQToi5cTcJICczJMgZMUkJPRBJyUgjk5VYGTUiAnVxBwUgbmZLgCJ2VATq4k4KQczMlpCpyUAzkZQ8BJGszJ6QqcpIGcXEXASQWYkzMUOKkAcjKWgJOuYE7OVOCkK5CTqwk46Qbm5CwFTroBORlHwMlmYE7OVuBkMyAn1xBwsjmYk3MUONkcyMl4Ak66gzkZocBJdyAn1xJw0gPMybkKnPQAcjKBgJOeYE7OU+CkJ5CT6wg46QXm5HwFTnoBOZlIwMkWYE4uUOBkCyAn1xNw0hvMyYUKnPQGcjKJgJM+YE4uUuCkD5CTGwg46Qvm5GIFTvoCOZlMwEk/MCeXKHDSD8jJjQSc9AdzcqkCJ/2BnEwh4GQAmJORCpwMAHJyEwEnA8GcXKbAyUAgJ1MJONkSzMkoBU62BHJyMwEnW4E5uVyBk62AnEwj4GRrMCejFTjZGsjJLQScDAJzcoUCJ4OAnEwn4GQbMCdXKnCyDZCTWwk42RbMyRgFTrYFcjKDgJPtwJxcpcDJdkBObiPgZHswJ2MVONkeyMlMAk52AHNytQInOwA5uZ2Ak8FgTsYpcDIYyMksAk52BHNyjQInOwI5uYOAk53AnIxX4GQnICd3EnCyM5iTaxU42RnIyV0EnOwC5mSCAie7ADmZTcDJrmBOrlPgZFcgJ3cTcLIbmJOJCpzsBuTkHgJOdgdzcr0CJ7sDOZkD5ET2UpCdvDpm+pPnvOW5YnmOVZ6blOf05LkweQ5JnnuR5yxkXb+sI5d1y7JOVtZlyjpAWXcm65xkXY2s45B1A3KfWu6Lyn04ue8j9xnkurZcR5XrdnKdSK5LSB0sdZfM82VeKfMYyZsSpyUuiB/OyWx8E2zovSDuxWGbBu5Hkn415nviyJ4N9yrsBXEfeGewkqVdCIqrBrZIDLR0vB+tIzoAi8GjgJvlSF9iNFrP+4E6zuUZPPa/PHjmKuj4Z0NnxweW/+yoslOSBIsHFLLjPJ8d7TyCAf5g3LOjbDqMzo4PKmTHB4E6zvfZkWLwzGfJjg8t/9kxqUGwBIuHFLLjwz472ocJBvgjcc+OQjw6Oz6ikB0fAer4qM+OFIPnUZbs+Njynx1LNAiWYPGYQnZ83GdH+zjBAH8i7tlxveb47PiEQnZ8Aqjjkz47UgyeJ1my41PLf3ZMaRAsweIphez4tM+O9mmCAf5M3LOjXDFBZ8dnFLLjM0Adn/XZkWLwPMuSHZ9b/rNjqQbBEiyeU8iOz/vsaJ8nGOAvxD07XqJQO76gkB1fAOr4os+OFIPnRZbs+NLynx3LNAiWYPGSQnZ82WdH+zLBAH8l7tlRXgs9FfhwQ/bV0PAXl4KBzAfrJwMdSPafgeNVhVnGK8BZxmt+lkERhF5jmWW8vvzPMso1CJZg8brCLOMNP8uwbxAM8DfjPsu4WKEGf1MhO74J1PEtnx0pBs9bLNlxAXB6Gbf32Gf70iBYgsUChez4NtBx8jL+Ij+l3w5Kzp4NxOjAiQzu7yjh+k4GV9aZSGWj+Ov4LjKYshJ1MgFR73mijB1GQNT7nihjhxMQ9YEnytjTCYj60BNl7JkERH3kiTL2bAKiPvZEGTuCgKhPPFHGnkdA1KeeKGMvICDqM0+UsRcREPW5J8rYSwiI+sITZexIAqK+9ES5C98ERH3liTJ2NAFRX3uijG1PQNQ3nihjxxAQ9a0nytixBER954kydhwBUd97oowdT0DUD54oYycQEPWjJ8rYiQRE/eSJMnYSAVE/e6KMnUxA1C+eKGOnEBD1qyfK2KkERP3miTJ2GgFRv3uijJ1OQNRCT5SxMwiI+sMTZexMAqISLTxRdlZB/HXM80QZ+xIBUfmeKGPvJAh9BZ4oY2cTEFXoiTJ2OEHoK/JEGTuHYEQVe6KMvY+AqEaeKGPnEhDV2BNl7DwCopp4ooydT0BU0xZ4Hf9s+SFFERsgofpqhjPaBm1G73/THKhnTPe/idya0uTWrGzv2Rm4d5Bs8XmRwn46LYCDr9D10SSxWMdgQweNClxfJqhvyxaKCkvn6H5btcA5g5bdrVosBhjUb6SuiAAv+78WgDEYBQwErwKTUI+2unyY3Fq9G2flandrYFIDYmg1fLprZvyhE1xXoI5tWsTbD8Vf2rTAc9O2BTaJZTddk347JJZs6DHUBph32rXQHUMmt6YWh1aIZxxSmRBnN4RE9ScFVHOFMbkieEIsY7IosXSL84RYU880iZ7lJHquoJw7cx1P3RKLxgA6nhQA++qWwObhbFspEJ/gxLcBB6qmAZISCZ0EALza8GcCaAEsLOsWtSUvIWL6ttmDIL4rZ3RfpUXGObKzt5UzXhM8t0oLve2Js8SgR/4WMa8usw6Etrt3W53MUYjRM5nR064MnMGvAhzYQL+xCC6CgQHtKxLEV1a6OqZxSduAL2nPVHhrVfsW8cfRgnG8XQHHVQlwTIJxnKWA42oEOJaAcbxDAcfVCXBMgXG8UwHHNQhwLAXjeJcCjmsS4FgGxnG2Ao5rEeBYDsbxbgUcOxDgmAbjeI8CjmsT4FgBxnGOAo7rEODYFYzjvQo4rkuAYzcwjvcp4LgeAY6bgXG8XwHH9Qlw3ByM41wFHDcgwLE7GMcHFHDckADHHmAc5yng2JEAx55gHB9UwHEjAhx7gXGcr4DjxgQ4bgHG8SEFHDchwLE3GMeHFXDsRIBjHzCOjyjguCkBjn3BOD6qgGNnAhz7gXF8TAHHLgQ49gfj+LgCjoYAxwFgHJ9QwNES4DgQjOOTCjgmCXDcEozjUwo4lhDguBUYx6cVcEwR4Lg1GMdnFHAsJcBxEBjHZxVwLCPAcRswjs8p4FhOgOO2YByfV8AxTYDjdmAcX1DAsYIAx+3BOL6ogGNXAhx3AOP4kgKO3QhwHAzG8WUFHDcjwHFHMI6vKOC4OQGOO4FxfFUBx+4EOO4MxvE1BRx7EOC4CxjH1xVw7EmA465gHN9QwLEXAY67gXF8UwHHLQhw3B2M41sKOPYmwHEPMI4LFHDsQ4DjnmAc31bAsS8BjnuBcXxHAcd+BDjuDcbxXQUc+xPguA8Yx/cUcBxAgOO+YBzfV8BxIAGOlWAcP1DAcUsCHKvAOH6ogONWBDhWg3H8SAHHrQlwrAHj+LECjoMIcKwF4/iJAo7bEOBYB8bxUwUctyXAcT8wjp8p4LgdAY77g3H8XAHH7QlwHALG8QsFHHcgwPEAMI5fKuA4mADHA8E4fqWA444EOB4ExvFrBRx3IsDxYDCO3yjguDMBjoeAcfxWAcddCHA8FIzjdwo47kqA42FgHL9XwHE3AhwPB+P4gwKOuxPgOBSM448KOO5BgOMRYBx/UsBxTwIcjwTj+LMCjnsR4HgUGMdfFHDcmwDHo8E4/qqA4z4EOB4DxvE3BRz3JcDxWDCOvyvgWEmA43FgHBcq4FhFgOPxYBz/UMCxmgDHE8A4JhRedVtDgOOJYBzzFHCsJcDxJDCO+Qo41hHgeDIYxwIFHPcjwPEUMI6FCjjuT4DjMDCORQo4DiHA8VQwjsUKOB5AgONwMI6NFHA8kADH08A4NlbA8SACHE8H49hEAceDCXA8A4xjUwUcDyHA8Uwwjs0UcDyUAMezwDg2V8DxMAIczwbj2EIBx8MJcDwHjGNLBRyHEuA4AoxjKwUcjyDA8Vwwjq0VcDySAMfzwDi2UcDxKAIczwfj2FYBx6MJcLwAjGM7BRyPIcDxQjCOKyjgeCwQxwLXR8rJvpn+5J3Q8j5jeRevvEdW3oEq7++Ud0/KexPlnX/yvjp515q8J0zecSXvZ5J3C8l7ceSdLvI+EnmXhrwHQt5hIPvvy97xsu+57Nkt+03LXsmyz6/sUSv7q8reoLKvpezJKPsJyl54so+b7EEm+2f9ufeTE9lzR/aLkb1OZJ8O2WNC9keQZ/vluXR5plqeB5ZnWeU5THmGUJ5/k2e35LkjeWZGnveQZxVknb2sEZf1zbI2V9aVyppIWc8na9FkHZWsAZL1K7L2QtYNyD1vuV8r9xrlPpnc45H7E3JtXa4LyzVNuR4n15LkOojU8FJ/Su0k836Zs8p8S+YKkuckRkt8kbEhvIZbAdh3jsP5Thnw/fNlvdtiY0N4zJncmpX3zwt26LF8PHAs52fGcrghcdXAFomBlo4noHVEJy8xuE0LnGNKX2I0Ws8TgDqeyDN4rJZjMgyeExV0/LOhs+NJy392tBoES7A4SSE7nuyzoz2ZYICfEvfsWJHAZ8dTFLLjKUAdh/nsSDF4hrFkx1OX/+yY1CBYgsWpCtlxuM+OdjjBAD8NrSPakcRBRckCkOE1pamUrTI1bVrogJirvaf7zEgxcE5nyYxnLP+ZsUSDYAkQZyhkxjN9ZrRnEgzws+KeGSVQdEvgMmOm2QJgX92A9p4NJiQfzIcEDKDT/BmAzlao488CzlbO8bMVimB2DstsZcTyP1tJaRAswWKEwmzlXD9bsecSDPDz4n6VWxx0JfBV7vMUsuN5QB3P99mRYvCcz5IdL1j+s2OpBsESLC5QyI4X+uxoLyQY4BcxZMcVwNnxIoXseBFQx4t9dqQYPEieEqxRrrJR/HW8xBNl7MkERF3qiTJ2GAFRIz1R7m4sAVGXeaLcLWkCokZ5otwdAwKiLvdEGXs2AVGjPVHGjiAg6gpPlLu8TkDUlZ4oYy8gIGqMJ8pdkiMg6ipPlLs8Q0DUWE+Uq/oJiLraE+WKSQKixnmiXI1CQNQ1nihj2xMQNd4T5aa+BERd64lyMyoCoiZ4olyiJiDqOk+Ui/8ERE30RLmwQkDU9Z4o560ERE3yRDkQCIi6wRNl7GQCoiZ7ooydQkDUjZ4oY6cSEDXFE2XsNAKibvJEGTudgKipnihjZxAQdbMnytiZBERN80QZO6sg/jre4oky9iUCoqZ7ooy9kyD03eqJMnY2AVEzPFHGDicIfbd5ooydQzCiZnqijL2PgKjbPVHGziUgapYnyth5BETd4Ykydj4BUXd6oox9mICouzxRxj5KQNRsT5SxjxMQdbcnytgnCYi6xxNlbBeCKxNzPFHGPkMwou71RBn7HAFR93mijH2BgKj7PVHuxiEBUXM9Uca+QkDUA54oY18jIGqeJ8rYNwiIetATZewvxQQXjj1Rxi4gGFEPeaKMfYeAqIc9Uca+R0DUI54oYz8gIOpRT5SxHxEQ9ZgnythPCIh63BNl7GcERD3hiTL2CwKinvREGfsVAVFPeaKM/YaAqKc9UcZ+R0DUM54oY38gIOpZT5SxPxEQ9Zwnyl09JyDqeU+Usb8REPWCJ8rYhQREveiJMjbROP46vuSJMjafgKiXPVHGFhIQ9YonythiAqJe9UQZ25iAqNc8UcY2JSDqdU+Usc0JiHrDE2VsSwKi3vREGduagKi3PFHGtiUgaoEnytgVCIh62xNl7EoERL3jiTJ2FQKi3vVEGbsqAVHveaKMXZ2AqPc9UcauSUDUB54oYzsQEPWhJ8rYdQiI+sgTZex6BER97IkydgMCoj7xRBnbkYCoTz1Rxm5MQNRnnihjOxEQ9bknytjOBER94Yky1hAQ9aUnytgkAVFfeaKMTREQ9TWSqELXiUjR0lzBFa9I4MHV0DNNomc5WM98sH5tnKO2xjmrbef6WqHFYjwZODobOFjzA3p+k8HhW/czD610K9dp1wiHKDFlqVRtebLWlthKk6yoSpeaVGlVWdqmbWm6tCaZLimpTafS5RVVFeWmwqZKam1daUVJXabjrsC+WgEdS/AryJAvwHZILAqKTQMYaA2QFcEDZEXgAKlb1KoSES3Hvm32IIjvdxndv2+RISNLinyQFzr3fYaoRAI/arPEhPvN1WlbtsNGLbTd7ZTsbtVOJ1oXYvRMZvS037XA2fw9cGAD/cYiuIgKDOhkgeTiByAXGuNOEqMktAIwhloJN9e+fow5H+IvPyrEwR9bYOMgesyNap5IXN4ch6P0925z/MQpqGOuNv9EwMloMCfvKXAyGsjJzwScXAHm5H0FTq4AcvILASdXgjn5QIGTK4Gc/ErAyRgwJx8qcDIGyMlvBJxcBebkIwVOrgJy8jsBJ2PBnHyswMlYICcLCTi5GszJJwqcXA3k5A8CTsaBOflUgZNxQE4SLePPyTVgTj5T4OQaICd5BJyMB3PyuQIn44Gc5BNwci2Yky8UOLkWyEkBAScTwJx8qcDJBCAnhQScXAfm5CsFTq4DclJEwMlEMCdfK3AyEchJMQEn14M5+UaBk+uBnDQi4GQSmJNvFTiZBOSkMQEnN4A5+U6BkxuAnDQh4GQymJPvFTiZDOSkKQEnN4I5+UGBkxuBnDQj4GQKmJMfFTiZAuSkOQEnN4E5+UmBk5uAnLQg4GQqmJOfFTiZCuSkJQEnN4M5+UWBk5uBnLQi4GQamJNfFTiZBuSkNQEnt4A5+U2Bk1uAnLQh4GQ6mJPfFTiZDuSkLQEnt4I5WajAya1ATtoRcDIDzMkfCpzMAHKyAgEnt4E5SbTAc3IbkJMVCTiZCeYkT4GTmUBOViLg5HYwJ/kKnNwO5GRlAk5mgTkpUOBkFpCTVQg4uQPMSaECJ3cAOWlPwMmdYE6KFDi5E8jJqgSc3AXmpFiBk7uAnKxGwMlsMCeNFDiZDeRkdQJO7gZz0liBk7uBnKxBwMk9YE6aKHByD5CTNQk4mQPmpKkCJ3OAnKwF5ET2Uih10jHTnzznLc8Vy3Os8tykPKcnz4XJc0jy3Is8ZyHr+mUduaxblnWysi5T1gHKujNZ5yTramQdh6wbkPvUcl9U7sPJfR+5zyDXteU6qly3k+tEcl1C6mCpu2SeL/NKmcdI3pQ4LXFB/FDsDjf0XhAdcNimgfuRpFvFfE8c2bNBsEPvBbE20NfzM74ebkhcNbBFYqCl4zpoHdEBWAz+Ebw5ixiN1jMIZK46rsszeOx/efCsq6Djnw2dHddb/rOjyk5JEizWU8iO6/vsaNcnGOAbxD07yqbD6Oy4gUJ23ACYHTf02ZFi8GzIkh07Lv/ZMalBsASLjgrZcSOfHe1GBAN847hnR9nqHp0dN1bIjhsDs+MmPjtSDJ5NWLJjp+U/O5ZoECzBopNCdtzUZ0e7KcEA7xz37Hh2C3x27KyQHTsDs2MXnx0pBk8Xluxolv/smNIgWIKFUciO1mdHawkGeDLu2VFeP4bOjkmF7JgEZscSnx0pBk8JS3ZMLf/ZsVSDYAkWKYXsWOqzoy0lGOBlcc+O3yrUjmUK2bEMmB3LfXakGDzlLNkxvfxnxzINgiVYpBWyY4XPjraCYIB3jXt2lNdCt1F4NTTa4bvF/CERGehAsv8MHN0UZhldgbOMzfwsgyIIbcYyy9h8+Z9llGsQLMFic4VZRnc/y7DdCQZ4j7jPMr5RqMF7KGTHHsDs2NNnR4rB0xOtI1rB7OBBOztyQPYCgij4FWRwlH47JBbZzpg9KhvFX8ctkAOAlaiTCYjq7YkydhgBUX08UcYOJyCqryfK2NMJiOrniTL2TAKi+nuijD2bgKgBnihjRxAQNdATZex5BERt6Yky9gICorbyRBl7EQFRW3uijL2EgKhBnihjRxIQtY0nythRBERt64kydjQBUdt5ooxtT0DU9p4oY8cQELWDJ8rYsQREDfZEGTuOgKgdPVHGjicgaidPlLETCIja2RNl7EQConbxRBk7iYCoXT1Rxk4mIGo3T5SxUwiI2t0TZexUAqL28EQZO42AqD09UcZOJyBqL0+UsTMIiNrbE2XsTAKi9vFEGTurIP467uuJMvYlAqIqPVHG3kkQ+qo8UcbOJiCq2hNl7HCC0FfjiTJ2DsGIqvVEGXsfAVF1nihj5xIQtZ8nyth5BETt74kydj4BUUO0drdC76Z0wL9XNBk+Ibq1dVIY0FVqqYWZ480Si48rA+dFh4WBvzvQ/X6Qk4OdHNJy0XmRRgH7l4WJya3ZAxU3iME/iZfAKot2sOyegQVgu38E7g/ZDbjD0tB2unyY3Fq9G/fkavehwH0mh8b8tdYy5g5V2NruMKUNiw7LbFgUbGj+BwL7OrxlvPnXGkND4zmGjKbfIHnZMsFhcx7Q5q1IbM4H2rw1ic0FQJsHNZDNJrdmtwHid1KBjs3w5yJJuNkOyM3IxhxjcAAQv+0THP64A4meg0n03JFEz51I9NyZRM9dSPTclUTP3Uj03J1Ezz1I9NyTRM+9SPTcm0TPfUj03JdEz0oSPatI9Kwm0bOGRM9aEj3rSPTcj0TP/Un0HEKi5wEkeh5IoudBJHoeTKLnISR6Hkqi52Ekeh5OoudQEj2PINHzSBI9jyLR82gSPY8h0fNYEj2PI9HzeBI9TyDR80QSPU8i0fNkEj1PIdFzGImep5LoOZxEz9NI9DydRM8zSPQ8k0TPs0j0PJtEz3NI9BxBoue5JHqeR6Ln+SR6XkCi54Ukel5EoufFJHpeQqLnpSR6jiTR8zISPUeR6Hk5iZ6jSfS8gkTPK0n0HEOi51Ukeo4l0fNqEj3Hkeh5DYme40n0vJZEzwkkel5HoudEEj2vJ9FzEomeN5DoOZlEzxtJ9JxCoudNJHpOJdHzZhI9p5HoeQuJntNJ9LyVRM8ZJHreRqLnTBI9byfRcxaJnneQ6HkniZ53keg5m0TPu0n0vIdEzzkket5Loud9JHreT6LnXBI9HyDRcx6Jng+S6DmfRM+HSPR8mETPR0j0fJREz8dI9HycRM8nSPR8kkTPp0j0fJpEz2dI9HyWRM/nSPR8nkTPF0j0fJFEz5dI9HyZRM9XSPR8lUTP10j0fJ1EzzdI9HyTRM+3SPRcQKLn2yR6vkOi57sker5Houf7JHp+QKLnhyR6fkSi58cken5CouenJHp+RqLn5yR6fkGi55cken5FoufXJHp+Q6LntyR6fkei5/ckev5AouePJHr+RKLnzyR6/kKi568kev5GoufvJHouJNHzDxI9pUMGPfNI9Mwn0bMArGdYP8Q75Q9sibe7kMDuoQp2F5H4ZTGJno1I9GxMomcTEj2bkujZjETP5iR6tiDRsyWJnq1I9GxNomcbEj3bkujZjkTPFUj0XJFEz5VI9FyZRM9VSPRsT6LnqiR6rkai5+okeq5BoueaJHquRaJnBxI91ybRcx0SPdcl0XM9Ej3XJ9FzAxI9NyTRsyOJnhuR6LkxiZ6bkOjZiUTPTUn07EyiZxcSPQ2JnpZEzySJniVgPfPB+v3YIpH4qQXuvrv0t0VLvJ6pPJyOQXtNjk2Lk5/BnPRW4KQUyMnPBJz8AuakjwInZUBOfiHg5FcwJ30VOCkHcvIrASe/gTnpp8BJGsjJbwSc/A7mpL8CJxVATn4n4GQhmJMBCpx0BXKykICTP8CcDFTgpBuQkz8IOEm0xHKypQInmwE5CdprcmxanOSBOdlKgZPNgZzkEXCSD+ZkawVOugM5ySfgpADMySAFTnoAOSkg4KQQzMk2Cpz0BHJSSMBJEZiTbRU46QXkpIiAk2IwJ9spcLIFkJNiAk4agTnZXoGT3kBOGhFw0hjMyQ4KnPQBctKYgJMmYE4GK3DSF8hJEwJOmoI52VGBk35ATpoScNIMzMlOCpz0B3LSjICT5mBOdlbgZACQk+YEnLQAc7KLAicDgZy0IOCkJZiTXRU42RLISUsCTlqBOdlNgZOtgJy0IuCkNZiT3RU42RrISWsCTtqAOdlDgZNBQE7aEHDSFszJngqcbAPkpC0BJ+3AnOylwMm2QE7aEXCyApiTvRU42Q7IyQoEnKwI5mQfBU62B3KyIgEnK4E52VeBkx2AnKxEwMnKYE4qFTgZDORkZQJOVgFzUqXAyY5ATlYh4KQ9mJNqBU52AnLSnoCTVcGc1ChwsjOQk1UJOFkNzEmtAie7ADlZjYCT1cGc1ClwsiuQk9UJOFkDzMl+CpzsBuRkDQJO1gRzsr8CJ7sDOVmTgJO1wJwMUeBkDyAnaylzkvN1a4fhJcBngtrJ3LoFfp+BPfPij+OlYBxXVcBxLwIcR4JxXE0Bx70JcLwMjOPqCjjuQ4DjKDCOayjguC8BjpeDcVxTAcdKAhxHg3FcSwHHKgIcrwDj2EEBx2oCHK8E47i2Ao41BDiOAeO4jgKOtQQ4XgXGcV0FHOsIcBwLxnE9BRz3I8DxajCO6yvguD8BjuPAOG6ggOMQAhyvAeO4oQKOBxDgOB6MY0cFHA8kwPFaMI4bKeB4EAGOE8A4bqyA48EEOF4HxnETBRwPIcBxIhjHTgo4HkqA4/VgHDdVwPEwAhwngXHsrIDj4QQ43gDGsYsCjkMJcJwMxtEo4HgEAY43gnG0CjgeSYDjFDCOSQUcjyLA8SYwjiUKOB5NgONUMI4pBRyPIcDxZjCOpQo4HkuA4zQwjmUKOB5HgOMtYBzLFXA8ngDH6WAc0wo4nkCA461gHCsUcDyRAMcZYBy7KuB4EgGOt4Fx7KaA48kEOM4E47iZAo6nEOB4OxjHzRVwHEaA4ywwjt0VcDyVAMc7wDj2UMBxOAGOd4Jx7KmA42kEON4FxrGXAo6nE+A4G4zjFgo4nkGA491gHHsr4HgmAY73gHHso4DjWQQ4zgHj2FcBx7MJcLwXjGM/BRzPIcDxPjCO/RVwHEGA4/1gHAco4HguAY5zwTgOVMDxPAIcHwDjuKUCjucT4DgPjONWCjheQIDjg2Act1bA8UICHOeDcRykgONFBDg+BMZxGwUcLybA8WEwjtsq4HgJAY6PgHHcTgHHSwlwfBSM4/YKOI4kwPExMI47KOB4GQGOj4NxHKyA4ygCHJ8A47ijAo6XE+D4JBjHnRRwHE2A41NgHHdWwPEKAhyfBuO4iwKOVxLg+AwYx10VcBxDgOOzYBx3U8DxKgIcnwPjuLsCjmMJcHwejOMeCjheTYDjC2Ac91TAcRwBji+CcdxLAcdrCHB8CYzj3go4jifA8WUwjvso4HgtAY6vgHHcVwHHCQQ4vgrGsVIBx+sIcHwNjGOVAo4TCXB8HYxjtQKO1xPg+AYYxxoFHCcR4PgmGMdaBRxvIMDxLTCOdQo4TibAcQEYx/0UcLyRAMe3wTjur4DjFAIc3wHjOEQBx5sIcHwXjOMBCjhOJcDxPTCOByrgeDMBju+DcTxIAcdpBDh+AMbxYAUcbyHA8UMwjoco4DidAMePwDgeqoDjrQQ4fgzG8TAFHGcQ4PgJGMfDFXC8jQDHT8E4DlXAcSYBjp+BcTxCAcfbCXD8HIzjkQo4ziLA8Qswjkcp4HgHAY5fgnE8WgHHOwlw/AqM4zEKON5FgOPXYByPVcBxNhjHbEPreTeJnveQ6DmHRM97SfS8j0TP+0n0nEui5wMkes4j0fNBEj3nk+j5EImeD5Po+QiJno+S6PkYiZ6Pk+j5BImeT5Lo+RSJnk+T6PkMiZ7Pkuj5HImez5Po+QKJni+S6PkSiZ4vk+j5Comer5Lo+RqJnq+T6PkGiZ5vkuj5FomeC0j0fJtEz3dI9HyXRM/3SPR8n0TPD0j0/JBEz49I9PyYRM9PSPT8lETPz0j0/JxEzy9I9PySRM+vSPT8mkTPb0j0/JZEz+9I9PyeRM8fSPT8kUTPn0j0/JlEz19I9PyVRM/fSPT8nUTPhSR6/kGiZyKfQ888Ej3zSfQsINGzkETPIhI9i0n0bESiZ2MSPZuQ6NmURM9mJHo2J9GzBYmeLUn0bEWiZ2sSPduQ6NmWRM92JHquQKLniiR6rkSi58okeq5Comd7Ej1XJdFzNRI9VyfRcw0SPdck0XMtEj07kOi5Nome65DouS6JnuuR6Lk+iZ4bkOi5IYmeHUn03IhEz41J9NyERM9OJHpuSqJnZxI9u5DoaUj0tCR6Jkn0LCHRM0WiZymJnmUkepaT6Jkm0bOCRM+uJHp2I9FzMxI9NyfRszuJnj1I9OxJomcvEj23INGzN4mefUj07EuiZz8SPfuT6DmARM+BJHpuSaLnViR6bk2i5yASPbch0XNbEj23I9FzexI9dyDRczCJnjuS6LkTiZ47k+i5C4meu5LouRuJnruT6LkHiZ57kui5F4mee5PouQ+JnvuS6FlJomcViZ7VJHrWkOhZS6JnHYme+5HouT+JnkNI9DyARM8DSfQ8iETPg0n0PIREz0NJ9DyMRM/DSfQcSqLnESR6Hkmi51Ekeh5NoucxJHoeS6LncSR6Hk+i5wkkep5IoudJJHqeTKLnKSR6DiPR81QSPYeT6HkaiZ6nk+h5BomeZ5LoeRaJnmeT6HkOiZ4jSPQ8l0TP80j0PJ9EzwtI9LyQRM+LSPS8mETPS0j0vJREz5Ekel5GoucoEj0vJ9FzNImeV5DoeSWJnmNI9LyKRM+xJHpeTaLnOBI9ryHRczyJnteS6DmBRM/rSPScSKLn9SR6TiLR8wYSPSeT6HkjiZ5TSPS8iUTPqSR63kyi5zQSPW8h0XM6iZ63kug5g0TP20j0nEmi5+0kes4i0fMOEj3vJNHzLhI9Z5PoeTeJnveQ6DmHRM97SfS8j0TP+0n0nEui5wMkes4j0fNBEj3nk+j5EImeD5Po+QiJno+S6PkYiZ6Pk+j5BImeT5Lo+RSJnk+T6PkMiZ7Pkuj5HImez5Po+QKJni+S6PkSiZ4vk+j5Comer5Lo+RqJnq+T6PkGiZ5vkuj5FomeC0j0fJtEz3dI9HyXRM/3SPR8n0TPD0j0/JBEz49I9PyYRM9PSPT8lETPz0j0/JxEzy9I9PySRM+vSPT8mkTPb0j0/JZEz+9I9PyeRM8fSPT8kUTPn0j0/JlEz19I9PyVRM/fSPT8nUTPhSR6/kGiZ6KAQ888Ej3zSfQsINGzkETPIhI9i0n0bESiZ2MSPZso6Zkf0rPElKVSteXJWltiK02yoipdalKlVWVpm7al6dKaZLqkpDadSpdXVFWUmwqbKqm1daUVJXWZvjcE2twUbDPa1oGuj0Nb4vo73PU1tCXed5qR+E4h0ObmJDYXAW1uQWJzMdDmliQ2NwLa3IrE5sZAm1uT2NwEaHMbEpubAm1uS2JzM6DN7Uhsbg60eQUSm1sAbV6RxOaWQJtXIrG5FdDmlUlsbg20eRUSm9sAbW5PYnNboM2rktjcDmjzaiQ2rwC0eXUSm1cE2rwGic0rAW1ek8TmlYE2r0Vi8ypAmzuQ2NweaPPaJDavCrR5HRKbVwPavC6JzasDbV6PxOY1gDavT2LzmkCbNyCxeS2gzRuS2NwBaHNHEpvXBtq8EYnN6wBt3pjE5nWBNm9CYvN6QJs7kdi8PtDmTUls3gBoc2egza4rWc6ZeD9j8JZOtnKytZNBTrZxsq2T7Zxs72QHJ4Od7OhkJyc7O9nFya5OdnOyu5M9nOzpZC8nezvZx8m+TiqdVDmpdlLjpNZJnZP9nOzvZIiTA5wc6OQgJwc7OcTJoU4Oc3K4k6FOjnBypJOjnBzt5Bgnxzo5zsnxTk5wcqKTk5yc7OQUJ8OcnOpkuJPTnJzu5AwnZzo5y8nZTs5xMsLJuU7Oc3K+kwucXOjkIicXO7nEyaVORjq5zMkoJ5c7Ge3kCidXOhnj5ConY51c7WSck2ucjHdyrZMJTq5zMtHJ9U4mObnByWQnNzqZ4uQmJ1Od3OxkmpNbnEx3cquTGU5uczLTye1OZjm5w8mdTu5yMtvJ3U7ucTLHyb1O7nNyv5O5Th5wMs/Jg07mO3nIycNOHnHyqJPHnDzu5AknTzp5ysnTTp5x8qyT55w87+QFJy86ecnJy05ecfKqk9ecvO7kDSdvOnnLyQInbzt5x8m7Tt5z8r6TD5x86OQjJx87+cTJp04+c/K5ky+cfOnkKydfO/nGybdOvnPyvZMfnPzo5CcnPzv5xcmvTn5z8ruThU7+cCILnPKc5DspcFLopMhJsZNGTho7aeKkqZNmTpo7aeGkpZNWTlo7aeOkrZN2TlZwsqKTlZys7GQVJ+2drOpkNSerO1nDyZpO1nLSwcnaTtZxsq6T9Zys72QDJxs66ehkIycbO9nESScnmzrp7KSLE+PEOkk6KXGSclLqpMxJuZO0kwonXZ10c7KZk82ddHfSw0lPJ72cbOGkt5M+Tvo66eekv5MBTgY62dLJVk62djLIyTZOtnWynZPtnezgZLCTHZ3s5GRnJ7s42dXJbk52d7KHkz2d7OVkbyf7ONnXSaWTKifVTmqc1Dqpc7Kfk/2dDHFygJMDnRzk5GAnhzg51MlhTg53MtTJEU6OdHKUk6OdHOPkWCfHOTneyQlOTnRykpOTnZziZJiTU50Md3Kak9OdnOHkTCdnOTnbyTlORjg518l5Ts53coGTC51c5ORiJ5c4udTJSCeXORnl5HIno51c4eRKJ2OcXOVkrJOrnYxzco2T8U6udTLByXVOJjq53skkJzc4mezkRidTnNzkZKqTm51Mc3KLk+lObnUyw8ltTmY6ud3JLCd3OLnTyV1OZju528k9TuY4udfJfU7udzLXyQNO5jl50Ml8Jw85edjJI04edfKYk8edPOHkSSdPOXnayTNOnnXynJPnnbzg5EUnLzl52ckrTl518pqT15284eRNJ285WeDkbSfvOHnXyXtO3nfygZMPnXzk5GMnnzj51MlnTj538oWTL5185eRrJ984+dbJd06+d/KDkx+d/OTkZye/OPnVyW9Ofney0MkfTiSh5znJd1LgpNBJkZNiJ42cNHbSxElTJ82cNHfSwklLJ62ctHbSxklbJ+2crOBkRScrOVnZySpO2jtZ1clqTlZ3soaTNZ2s5aSDk7WdrONkXSfrOVnfyQZONnTS0clGTjZ2somTTk42ddLZSRcnxol1knRS4iTlpNRJmZNyJ2knFU66OunmZDMnmzvp7qSHk55OejnZwklvJ32c9HXSz0l/JwOcDHSypZOtnGztZJCTbZxs62Q7J9s72cHJYCc7OtnJyc5OdnGyq5PdnOzuZA8nezrZy8neTvZxsq+TSidVTqqd1DipdVLnZD8n+zsZ4uQAJwc6OcjJwU4OcXKok8OcHO5kqJMjnBzp5CgnRzs5xsmxTo5zcryTE5yc6OQkJyc7OcXJMCenOhnu5DQnpzs5w8mZTs5ycraTc5yMcHKuk/OcyPvl5d3t8l50eee4vM9b3pUt76GWdzzL+5Pl3cTy3l95p668r1beBSvvWZV3mMr7QeXdm/Jey2ucyPsY5V2H8h5BeUefvP9O3i0n722Td6LJ+8bkXV7ynix5B5W830nenSTvJZJ3/sj7dORdNfIeGHnHiry/RN4NIu/dkHdayPsi5F0M8p4DeYeA7M8ve9/LvvL3OZH90GWvcdnHW/bIlv2nZW9n2TdZ9iSW/X5lL13Zp1b2gJX9VWXvUtkXVPbclP0sZa9I2YdR9jiU/QNlbz7Z9072lJP92mQvNNlnTPbwkv2xZO8p2ddpgRPZj0j2+pF9dGSPGplzyt4qsm+J7Aki+23IXhayT4TswSD7G8jeAfJcvjzzLs+Ty7Pa8hy0PGMsz+/Ks7Hy3Kk80ynPS8qziPKcnzxDJ8+nybNf8lyVTHLleSB51kaeY5FnROT5C3m2QZ4bkDX5st5d1n/L2mVZyytrW2Wtp6x9lLWAsjZO1orJ2ilZSyRra2Stiay9kLUIcm9e7lXLvVu5lyn39uRel9z7kXshcm9ArpXLtWO5lirXFuVam1x7kmsxcm1CanWpXaWWk9pG5vr5i6YvCVmrLG3LxOKWCW1/zuHlc1nbK2tdZe2nrIWUtYGyVk7WjslaKllbJGttZO2JrMWQtQlyr17uXcu9XLm3Kff65N6X3AuSeyNyr0Cuncu1ZLm2Ktca5dpbBydrO1nHybpOpJaV2k5qHVmT39HJRk42drKJk05ONnXS2UkXJ1JwWSdJJyVOUk5KnZQ5KXeSdlLhpKuTbk42c7K5k+5OeiQW1UC9nGzhpLeTPk76OunnpL+TAU4GJpZu6wWOt8v8XPG9Xu0Pf3RS3+D3bssAPm7ymjNXey9/9+BnM5fx2V3L+OzuZXz2VmH9uny4jM9+XMZnf2Q+e/Wd53c47NDjtw1+tlFR/X/3RVH9f7ducf1/t/4yPttzGZ9VFdf//95axt8NaFT/341sVP/fjVrGZxs1rv+zVOP6/9+sZfzduk3q/7tjm9T/d8cv47Opy/jsjmX8v25N6/+7SU3r/7vflvF3C5fxmW1W/2ebNav//23YvP7PTmhef5831vNZ5l/9WR9Ky0D0v2s9EksljvbM/G5ya7ZJoF90/2lTUdIksWQD6/9n/3nK+GT7VOjfZIZ4ou+wxf2HbZHWIvN7XgDL7N/IkO6QWHy8buBvpPUL9J0X+qx/xP/NfjZgWLQe0gYGPisMfbZl4LOi0GdbBT4rDn22deCzRqHPBgU+axz6bJvAZ01Cn20b+Kxp6LPtAp81C322feCzzFD9H36tEotbQeZci8C5LI5Z32kd+Hvc2CpNZvtvo9C/MSmTtalg2OL+W4VwKgx81jr0WVHgs6yOwt0zoe9dEvheyxB2rVSwS5VpcuOwq2kXoX/rgG3Seg/T+N+mOtt/H53+S5pleHw9wGMwRmT/Z5DHQh2ca/NC/y+RWDJWJ0L/v2lCNZ7bvND/y+oTxicbIyS2ZH1+v9ojex115P67DDnykNojjghqH+xxUOB88PNgC38n/L3w95tEfJ6HQ8W0SCyNSthDigLngR5i/66HZP9/04Smxy72kKKQPmF8wlmkWAcfkxfqP6hPcQQ+WS4bRXyW7SuboYsCfQW/XxywMfj94HH274PnKjI/W0f0GfbdRoml7Qmey+IrupSEbAuPm6if2X7D5/JDOkZFIeWoaHTH1OJZsY5PLo4XwZlwcYCvXoHzQV6D/pYfgXtR6Pu3B/rsUw83CQW7gn4YjoONdTCt+btxMPv/myaWHmMacbBxSJ/6xmkWnyY6+lTnhfoP6tMkAp8sl00jPsv2la0qgn4Z/H6wug9+P3ic/fvgucGZn60j+iwM6dA0sbQ9wXPBODgoZFtUvv63cTCoV6PQ/6lvnO+aWNKW7GdR41xadkZdFPr+uECfe2SOWyXqjxPLyonB7xeF+iqMsEM5FieXle+WpWswdofz6LL6ktZn2JJ9FUX0lf27xhE65IW+E/z/UfGgqB5dpTVJqMap1LLiQn6EXq0i7G7SMLqWLmvML0vXYHxr2jC6loVj5N/VNRjrmoX+rlmEHcvytaj/3TTifzeQr5VnMWme+GeYBO1u3jC6prO6tviHugavprVoGF0rsrq2/Ie6tgh81jL0dy0j7FiWr0X97xYR/7uBfK0yi0mrf4hJ0O5WDaNrVVbX1v9Q16irb3+nL2nZuUSrCNtah/6udYQOecvQM+p/B/8uP9RH1Fwl/FlePX8f/Cz4/4LnwnO1qP8TdY0IecU023ebCF0LlmF3EPvs37aI+Lvw9YvgnKJJ6LNgPmwR+iw4ZvNDn0XNY1uEfg/mmKgaomXos+B4ax36LMhFYeiz4Fw0XLME5ybNQ58F43N4nh6VO1uEfg+Ou2aJ6Plm+DqITs272KeyfNZ3fSB4vSr4/esyP+XzdwLfD/5NIrHsK7xhHYLfD9qd/X5UvAnPH7Vr4KZ/gVcQz+D3p0TgFXUXKVgbSSscpmJPjejxfkCPMG9Fgf/7VxwlEktzGjXPDnITjqtRc8uo+jh8HeHv1qF/t56O8rG80HHjZfxPadn82CTCNo0xHHUtJYhT0GeD37878zNqDEfxt6wx/Ff1QlafqLqq2TL+rkno/yzLvmAfUdelgr6syItZFi/5EXqHeZmf+flXsSLro7qxImX/aayI4mNZseKvfCccK4L5tEnos+BYDfP+d68DRcWK7N+Gr7FLazRsyX7//Bk4l8Uny2Hj4PdDnzUJfFY4bMn/0zTze2Hg/wT7yupRFPr+a5nfs3OP4sDfZP++dcT/Lw79/yX0jjgXnps3ifh+k4jvC6bPZ46FW01/Lk8bk9Uvi31RYsnYlgj9/6LQ99/O/B6+jpLNVT3/pZ515ZW2rqSyrrK0sqYmVV3ZNtR/ELNmCv+/Nl1RYyrqaiuttckaU/tX/z/Kn4LxSVrWJ4M+G/x+tr+i0Pc/zn43seiJMmnh1TPB/yff+2UZ38ur5+effUScKxy25LkoXw6O8ez3s/+76bCldcx+1izwWTB2Smue+T2IV7CvrB5Foe//mPk9y0lwXGb/vnXE/28c+v9L6B1xLjzGm0V8v1nE94Wfr7L9ZX4GbUffP/vzf4b6D54L65b1HfHr7Apz7hWmqXK/wnTZLZvT+wxb3H/YFmlRax+yfyNzjOx1CDkOr/TrG+g7L/RZv4j/q2mz84lS3fUVJtkuQv/gNQ1p2foo8e//rw2fyK68WzPT37Kuj2V1ipoDhucBUX0E+8kPffd/c4uI/rJ2h9c0LUu3KBwTEeeidCv4C90KI3QL95u/DDvq+z9BnZZ1HTAv9FmU7gzzwXUzv/9/zwfXzhz7vLXMVqKcV5LKMTYyb0XFiWXlrfB4lJbNVeGcFl7ZHsxb/5sfJ/TmAsFV6Uqc2XaJ+nNBNreslljcgjgXJerPC0Wh766U+Slzznb19Fe8jP6i7t8E/6595jjqnlQCiFeUHnkRerDH9g6Z3/+/Y/tamWPy2F7ZULFdaf1tqfL9/MjYHrUeLevD2ZgdPM7qlP1O/8B3+tfznQGB7wSfbpP2b/NI1NMv/UKfBeeg/UOfBZ8DyOokcXiFxOLjFQM6Sgs+fddAuakiDrkpG2+bB45rDzn8qNqjarc7quqgIdX9jjqk+sghhx7Su/Kgg4JEhh0s2IpC3wv/Xbj4qa8QyP5eFNFvfX8fPresYiGrP0NCyRao/98JZc/MMXlCqfIJZdnNJ5S/TijZJCLHKwV0lBaVUKIe526gC3gV/58X8LLJZvPEkrgGF2GEk66SX5fkhf5fIrF0rgj+/6YJ1XH8v4d2om4yB/HJ+okk6mwBWO1y8nZDhxxdeWRtNk0HTQh2mx9hYjhth++pRX3v/yt9R63JLA7pGKY0fC68HiD899K0n1cMr2HMB/wf7fsdUWtYC0L/WymslEaF4EQIw2XxuKw1wIkIfBOB72RtktDVO9Bv+HthfYI8FAf6D9oRxVfU9f2oZ5qjQmz2vPKzUWVRoTtsf9QauKh1sv+Uj6xN/5SPZT0nFxxr4ft2Qf2CqSzupcIWmd//v0uFYMpvlVjad8OxPer+j/I0eqln/YJr7qKePQw/77xl5qfYunPItqg1pgURWIV1CH4/ao33sp4RVMZrmdOVKLyy38+O++J6vh/EP/j9HTI/5ffdMsdRebUg9FnUGryoMZ/FMA7rotD/P1VaWV5dWW5tRcrWpmzpX/3//TPH3KV9aQ33fUBbEZf7gAWh74X/Jvh3fQPf6VvPd/oFvtOvnu/Ud4kg+J36LhEEvzMw8J2B9Xxny8B3tqznO1sFvrNVPd/ZOvCdrev5zqDAdwbV851tAt/Zpp7vbBv4zrb1fGe7wHe2q+c72we+s30939kh8J0d6vnO4MB3BtfznR0D39mxnu/sFPjOTvV8Z+fAd3au5zu7BL6zSz3f2TXwnV3r+c5uge/sVs93dg98Z/d6vrNH4Dt7hL6j+fyfu+ST0o0jNh11WS1ri24dYivyQv8vkYi+jBPeg0rrXkte6P9l9alvzhf1XEZe6LPCYUvbEV6jHORX5kjdAt+L8i1puve1SquV85f9//O7RfVC8P8lEvx+F/6scNjSdvxTv4u6ViTf6xc47p851o2Di+aDWv4urV2E/uFrG42GJf7XsnjE6Vmfvpnf4/ysT/fMcbPE4usLVdm/SaiOexvO68HrdcGxF75uoXkbIy8RfY0h6rpA1G2uvHp+ZvsKf5b9Xw21n2OUbVH7OUZdzw/vn7isvRj/bl//n5xGXSvJC/0e/H5+hG3LehY0KvaHd5MOxv7gtdhuIXy0rhssK9flRdibPR/13HWUH0U9w904ZJvSPgHJZXEfte9V88D5mtqqo/bb+tD9EqEWvtaaxW2VwHeCfOUnlvb9RvX0lQj9Hu6zINBfsDFcP88C+f99/XzlzDH5UptS/zzZstvffZ7sr67Hyed/9czZ/+aXiaV3htfkX5GfZc6/s/PE7D5GEjc3zBwfcuiRQ+qOG1x75KAhh+xQe3Tt0COHVB1UO3hITW3furra6iN7H3rUIUfWDk2EWlT4izpfkOAId9mVS//f4S6rhw93y2z+8dnEoiGd3VYrGNb+C6EsW4aL/dkxsyiU9R5aW3lkbc02Rx100JC6IbVDwxEpXHwnIn6vL6JlNYh7NMuuyfz/jmbZhBPc2AuNl7Rs/1o3/LP9axW9weI1EfpfQdzCFySCx1mdgpu6KehamRehX0Hof4Z1DH4n/CC2tPzQ74Wh8wV/47vh/xf8LPyKnKi/C2/SFj4XvhCQiPh+tq/wiyrCfQUXegS/H96USovDdhE65dXzv1fU0eF/Y2oFnf5N1JhaMXC8QsjOoF/1BOmQ7S/rA1ELOMMLjoM3CoL65eH1s2FdouJLtmV9ZoXAueDa/6CuOpvDLXo4XFoznf4jfSa4IVuz0GdZ7qJiWn3zi/zQz2V9N28Z/UbFoWyfWa6C+mbt+D/MHC4JsuIRAA==",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "get_auth_witness",
         "decompose_hint",
         "lte_hint",
-        "enqueue_public_function_call_internal",
-        "call_private_function_internal",
-        "debug_log_oracle_wrapper",
-        "notify_set_min_revertible_side_effect_counter_oracle_wrapper",
-        "notify_created_nullifier_oracle_wrapper",
+        "store_in_execution_cache_oracle_wrapper",
         "directive_to_radix",
         "directive_invert",
         "directive_integer_quotient"
       ],
-      "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAFAAAABgAAAAcAAAAIAAAACQAAAAoAAAALAAAADAAAAA0AAAAOAAAADwAAAAAAAAAAAC/+mHCcz+jq407ZQQ8iqK5WhEMG6ovg0czCiBIj1ZsBAQbzkUDTFplayjWuZYPsnFCPRaOYYEkKPCA93zGNZqsO3XBVVHH6wKsNPAsZQwIp/s64o1GsqOkTNiXwIs4YASBwBhVsl3n0sg6EOPVWSnF4jt9fOmlTz0s2DABufzb0HzGPgZ5Pfj4HifLCZGK2Sm668x8RE89Eq482+lGCHKgb0kZOvqyCiYTW0bM+0OTRpgePrC5NqlNbxxGgEP+0ISHolbsvZMVt4xY3VUp+qvAuVGKCriPRsu+D/kCX105yG1CnJdhoQthJX0PlJvLF7GzIAsBhw0fuJg+UtIL2g7QYLs7EOR6ojrj1mYM92bQDk8/hVVaxwLS8wwXGG4VdcRJu2IDrEhAUW69OO8JWttGSUS6Q4cW+4XTJEBDUo/59HetEvAS76gaBj2SczkhcZ1BJx21QeGb+CsSctx6csP4tKvvdL+AX6P8NY6Nw8iSYMvDe70jTr4HGZTjLdZqNLARWu3AbWwtGO7zwxP5xkFUjk9CVM+GyAEvYTp+KU6iPA4D05rswR3a/1Psi4gmHdBVkgemj+PCR0w2xADptqrQNVrvvFHJ4/cBX+aM22YTQoACAzY80ug43VGwQJmXI/ikfu+C39vKCPVRpz5gaHvEfPq7YcmAmIR0u4Pg+MuRTDgg7wWfAtBKHji2ULCv/c05LrlCLSIxN9I5dVnSVOFQmDgAKuBstdDzJ79r8JkgT2OkB/rMf6AKfjVaq55xB1BalfgL38DiZ3P2ns6fmcitKymmYy9cDrvV3ucpWimGkARlSkEJmoeoLxg/jYyT2H59juNUVcLPfSOv4R7fT0H8L8tk8RlWiMnZAHemXBl5+Bn3K7Ey/nwDDDvP12aZ7hgZXScNkI75sewVh9PzCUKT5vUC4zboBHeMLUiMq2WJyFt3+AyJ+MXFmmpHrNNKl8vhUM8nfIW92qMPTAIk82UIQCuVmjiaymVN1HdMxvZ7Xjt4a4Omx+x4wiqKm12m7ISgIAYOm6QgjwN6FUyQ0lloFPZTTmk0JJbtMFBBJ0mCGCjQ6kiLRkmWI6g8/bqYfT1al6pOubTRN53bFoyqsAPAQ9+OpFBLgqm9xzkvy6iA11eTrJaPN9KQfjy0X0TH+rSTZrig6oSdZJ1c4EEaTlUxB2GQK+UcrddTJPRWkv2L2KMHxZJWFYl7SKzKxfhOVUn1YavbWuKUuDfxvH+Qe8MEmv8uKIaC7ORIPPA9FrJpx7X2S0mJthwVO5A0rUrcdVyIYWoEvf5koprAOXkR0LR6alaT61+Pk0tUmhsBeCZRSLzdFITilpbW0AoY0lFyk1zvfrtZMnu+vTBFqKep1dSYqeGer49xEp6iUpaO6FCmXAZ0LAvjJ42pqPK14nmnXKgI4jbchsl/s8rYIQHXHunWrZKwZp8gAi7yTzjEPIRjyJRaOlbaNBtl5YltO1sTZ94VvztRTH5ghpm+8rNBIEEsCj2dWiH+WmKFNu4lJJhB7pe1we+4gx/HQcPdPyA+UmSLJpo14r1NR4PetUffyN08H3MSJpEbVduBIaW70x4O0GG7M1IbR+RaBn3bQKXBGWx/7BOOi+2x3BRghS+vliS0MmKU6bx9pq2brnBbFtSPRKIywXOciI5/4CUHhD6941x3PwOJrBzlqT0lucGJIzsL+5ksxMjovCejng3dzgoANGjXlt4y+f48bVHZvm45ogRfVnCgHHm5tS5bMrtZjSmcG7+NyQCekPk5NcUExeWLzBjixYNSDoKhFmVLpFILPWSNR2x/MyXAF40tuleb7Qwf1OSSdgG2N7LW9x7kjw5SZHXLYXjLGNm5/cRN104IC5OwuC+YJBM8Q+sNBmvHqnG8KhQGeElJpkxLL1exqI7KEqbNSfNLr/2KyRaBKqyWPkhu6Gm5J8LpmZD6LMv0JDgC17ucjNkMMP+t9pri1fhVRALNOAIK8Wu2BmoG7NnRMTWEsgPyRommqqql1yEyOWNYAE66jvMCEHsbZSyhfG+u+uWng8seFYnDcX9osXTmdzALZ8EZe9LKxFtS4hiU0TyZxeCqTNyqtNpUwrkt1wivbJl8McFNuwC98m+TOGcKdJumDmULXKSAUH+vasH5MIMMngHpPeyPZzByGXvmTCZk6M56MuMZI0Hw03ctO9EUngwy/nW4Lb6pgndvVgX9dELxP2BDHgdeyOaR6CGNhaG7cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiRZjLLFScfOsLo060OJsUxIajUo55Ebv4B17xLfkBNjDo22o+66BFRahR/4atgmh60oBZOk38fDhMoPZPUoOqQAxDcm91tv2g3iLODg36trzHoF/5WpayiUJMX3M2cNli+bbgtOLAGWjeXDJIKqfR0KCdcXjsk7rXhY+W5k8LSNHViqYcZK1SIEPXnEgCIZ5Vuhl1Gt/mw2Mk0/tsLaCYktfBipPD2uWICfqu7GqGp49LO8YfGdbnBpNZu/R+f5Bw=="
+      "verification_key": "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"
     }
   ],
   "outputs": {
@@ -3807,15 +3807,15 @@
   "file_map": {
     "101": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/hash.nr",
-      "source": "use crate::utils::to_bytes::{arr_to_be_bytes_arr, str_to_be_bytes_arr};\nuse dep::protocol_types::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n        GENERATOR_INDEX__SECRET_HASH,\n    },\n    hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice, sha256_to_field},\n    point::Point,\n    traits::Hash,\n};\n\npub use dep::protocol_types::hash::{compute_siloed_nullifier, pedersen_hash};\n\npub fn pedersen_commitment<let N: u32>(inputs: [Field; N], hash_index: u32) -> Point {\n    std::hash::pedersen_commitment_with_separator(inputs, hash_index)\n}\n\npub fn compute_secret_hash(secret: Field) -> Field {\n    poseidon2_hash_with_separator([secret], GENERATOR_INDEX__SECRET_HASH)\n}\n\npub fn compute_l1_to_l2_message_hash(\n    sender: EthAddress,\n    chain_id: Field,\n    recipient: AztecAddress,\n    version: Field,\n    content: Field,\n    secret_hash: Field,\n    leaf_index: Field,\n) -> Field {\n    let mut hash_bytes = [0 as u8; 224];\n    let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n    let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n    let version_bytes: [u8; 32] = version.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n    let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n    for i in 0..32 {\n        hash_bytes[i] = sender_bytes[i];\n        hash_bytes[i + 32] = chain_id_bytes[i];\n        hash_bytes[i + 64] = recipient_bytes[i];\n        hash_bytes[i + 96] = version_bytes[i];\n        hash_bytes[i + 128] = content_bytes[i];\n        hash_bytes[i + 160] = secret_hash_bytes[i];\n        hash_bytes[i + 192] = leaf_index_bytes[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n    poseidon2_hash_with_separator([message_hash, secret], GENERATOR_INDEX__MESSAGE_NULLIFIER)\n}\n\npub struct ArgsHasher {\n    pub fields: [Field],\n}\n\nimpl Hash for ArgsHasher {\n    fn hash(self) -> Field {\n        hash_args(self.fields)\n    }\n}\n\nimpl ArgsHasher {\n    pub fn new() -> Self {\n        Self { fields: [] }\n    }\n\n    pub fn add(&mut self, field: Field) {\n        self.fields = self.fields.push_back(field);\n    }\n\n    pub fn add_multiple<let N: u32>(&mut self, fields: [Field; N]) {\n        for i in 0..N {\n            self.fields = self.fields.push_back(fields[i]);\n        }\n    }\n}\n\npub fn hash_args_array<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\npub fn hash_args(args: [Field]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator_slice(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\n#[test]\nunconstrained fn compute_var_args_hash() {\n    let mut input = ArgsHasher::new();\n    for i in 0..100 {\n        input.add(i as Field);\n    }\n    let hash = input.hash();\n    dep::std::println(hash);\n    assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);\n}\n"
+      "source": "use dep::protocol_types::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n        GENERATOR_INDEX__SECRET_HASH,\n    },\n    hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice, sha256_to_field},\n    point::Point,\n    traits::{Hash, ToField},\n};\n\npub use dep::protocol_types::hash::{compute_siloed_nullifier, pedersen_hash};\n\npub fn pedersen_commitment<let N: u32>(inputs: [Field; N], hash_index: u32) -> Point {\n    std::hash::pedersen_commitment_with_separator(inputs, hash_index)\n}\n\npub fn compute_secret_hash(secret: Field) -> Field {\n    poseidon2_hash_with_separator([secret], GENERATOR_INDEX__SECRET_HASH)\n}\n\npub fn compute_l1_to_l2_message_hash(\n    sender: EthAddress,\n    chain_id: Field,\n    recipient: AztecAddress,\n    version: Field,\n    content: Field,\n    secret_hash: Field,\n    leaf_index: Field,\n) -> Field {\n    let mut hash_bytes = [0 as u8; 224];\n    let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n    let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n    let version_bytes: [u8; 32] = version.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n    let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n    for i in 0..32 {\n        hash_bytes[i] = sender_bytes[i];\n        hash_bytes[i + 32] = chain_id_bytes[i];\n        hash_bytes[i + 64] = recipient_bytes[i];\n        hash_bytes[i + 96] = version_bytes[i];\n        hash_bytes[i + 128] = content_bytes[i];\n        hash_bytes[i + 160] = secret_hash_bytes[i];\n        hash_bytes[i + 192] = leaf_index_bytes[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n    poseidon2_hash_with_separator([message_hash, secret], GENERATOR_INDEX__MESSAGE_NULLIFIER)\n}\n\npub struct ArgsHasher {\n    pub fields: [Field],\n}\n\nimpl Hash for ArgsHasher {\n    fn hash(self) -> Field {\n        hash_args(self.fields)\n    }\n}\n\nimpl ArgsHasher {\n    pub fn new() -> Self {\n        Self { fields: [] }\n    }\n\n    pub fn add(&mut self, field: Field) {\n        self.fields = self.fields.push_back(field);\n    }\n\n    pub fn add_multiple<let N: u32>(&mut self, fields: [Field; N]) {\n        for i in 0..N {\n            self.fields = self.fields.push_back(fields[i]);\n        }\n    }\n}\n\npub fn hash_args_array<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\npub fn hash_args(args: [Field]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator_slice(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\n#[test]\nunconstrained fn compute_var_args_hash() {\n    let mut input = ArgsHasher::new();\n    for i in 0..100 {\n        input.add(i as Field);\n    }\n    let hash = input.hash();\n    dep::std::println(hash);\n    assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);\n}\n"
     },
     "129": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/functions/utils.nr",
-      "source": "use crate::macros::{\n    functions::{abi_export::create_fn_abi_export, call_interface_stubs::stub_fn, stub_registry},\n    notes::NOTES,\n    utils::{\n        add_to_hasher, fn_has_noinitcheck, get_fn_visibility, is_fn_initializer, is_fn_internal,\n        is_fn_private, is_fn_view, modify_fn_body, module_has_initializer, module_has_storage,\n    },\n};\nuse protocol_types::meta::generate_serialize_to_fields;\nuse std::meta::type_of;\n\npub(crate) comptime fn transform_private(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[private] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Private functions undergo a lot of transformations from their Aztec.nr form into a circuit that can be fed to the\n    // Private Kernel Circuit.\n    // First we change the function signature so that it also receives `PrivateContextInputs`, which contain information\n    // about the execution context (e.g. the caller).\n    let original_params = f.parameters();\n    f.set_parameters(&[(\n        quote { inputs },\n        quote { crate::context::inputs::private_context_inputs::PrivateContextInputs }.as_type(),\n    )]\n        .append(original_params));\n\n    let mut body = f.body().as_block().unwrap();\n\n    // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received\n    // the correct values.\n    // TODO: Optimize args_hasher for small number of arguments\n    let args_hasher_name = quote { args_hasher };\n    let args_hasher = original_params.fold(\n        quote {\n            let mut $args_hasher_name = dep::aztec::hash::ArgsHasher::new();\n        },\n        |args_hasher, param: (Quoted, Type)| {\n            let (name, typ) = param;\n            let appended_arg = add_to_hasher(args_hasher_name, name, typ);\n            quote {\n                $args_hasher\n                $appended_arg\n            }\n        },\n    );\n\n    let context_creation = quote { let mut context = dep::aztec::context::private_context::PrivateContext::new(inputs, args_hasher.hash()); };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    // All private functions perform note discovery, since they may need to access notes. This is slightly inefficient\n    // and could be improved by only doing it once we actually attempt to read any.\n    let note_discovery_call = if NOTES.len() > 0 {\n        create_note_discovery_call()\n    } else {\n        quote {}\n    };\n\n    // Finally, we need to change the return type to be `PrivateCircuitPublicInputs`, which is what the Private Kernel\n    // circuit expects.\n    let return_value_var_name = quote { macro__returned__values };\n\n    let return_value_type = f.return_type();\n    let return_value = if body.len() == 0 {\n        quote {}\n    } else if return_value_type != type_of(()) {\n        // The original return value is passed to a second args hasher which the context receives.\n        let (body_without_return, last_body_expr) = body.pop_back();\n        let return_value = last_body_expr.quoted();\n        let return_value_assignment =\n            quote { let $return_value_var_name: $return_value_type = $return_value; };\n        let return_hasher_name = quote { return_hasher };\n        let return_value_into_hasher =\n            add_to_hasher(return_hasher_name, return_value_var_name, return_value_type);\n\n        body = body_without_return;\n\n        quote {\n            let mut $return_hasher_name = dep::aztec::hash::ArgsHasher::new();\n            $return_value_assignment\n            $return_value_into_hasher\n            context.set_return_hash($return_hasher_name);\n        }\n    } else {\n        let (body_without_return, last_body_expr) = body.pop_back();\n        if !last_body_expr.has_semicolon()\n            & last_body_expr.as_for().is_none()\n            & last_body_expr.as_assert().is_none()\n            & last_body_expr.as_for_range().is_none()\n            & last_body_expr.as_assert_eq().is_none()\n            & last_body_expr.as_let().is_none() {\n            let unused_return_value_name = f\"_{return_value_var_name}\".quoted_contents();\n            body = body_without_return.push_back(\n                quote { let $unused_return_value_name = $last_body_expr; }.as_expr().unwrap(),\n            );\n        }\n        quote {}\n    };\n\n    let context_finish = quote { context.finish() };\n\n    let to_prepend = quote {\n        $args_hasher\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n        $note_discovery_call\n    };\n\n    let to_append = quote {\n        $return_value\n        $mark_as_initialized\n        $context_finish\n    };\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n    f.set_return_type(\n        quote { dep::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs }\n            .as_type(),\n    );\n    f.set_return_data();\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_public(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[public] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Public functions undergo a lot of transformations from their Aztec.nr form.\n    let original_params = f.parameters();\n    let args_len = original_params\n        .map(|(name, typ): (Quoted, Type)| {\n            generate_serialize_to_fields(name, typ, &[], false).0.len()\n        })\n        .fold(0, |acc: u32, val: u32| acc + val);\n\n    // Unlike in the private case, in public the `context` does not need to receive the hash of the original params.\n    let context_creation = quote {\n        let mut context = dep::aztec::context::public_context::PublicContext::new(|| {\n        // We start from 1 because we skip the selector for the dispatch function.\n        let serialized_args : [Field; $args_len] = dep::aztec::context::public_context::calldata_copy(1, $args_len);\n        dep::aztec::hash::hash_args_array(serialized_args)\n        });\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n        // referenced. We instead ignore 'unused variable' warnings for it.\n        quote {\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    let to_prepend = quote {\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n    };\n\n    let to_append = quote {\n        $mark_as_initialized\n    };\n\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n\n    // All public functions are automatically made unconstrained, even if they were not marked as such. This is because\n    // instead of compiling into a circuit, they will compile to bytecode that will be later transpiled into AVM\n    // bytecode.\n    f.set_unconstrained(true);\n    f.set_return_public(true);\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_unconstrained(f: FunctionDefinition) {\n    let context_creation = quote { let mut context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new(); };\n    let module_has_storage = module_has_storage(f.module());\n\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(context);\n        }\n    } else {\n        quote {}\n    };\n\n    // All unconstrained functions perform note discovery, since they may need to access notes. This is slightly\n    // inefficient and could be improved by only doing it once we actually attempt to read any.\n    let note_discovery_call = if NOTES.len() > 0 {\n        create_note_discovery_call()\n    } else {\n        quote {}\n    };\n\n    let to_prepend = quote {\n        $context_creation\n        $storage_init\n        $note_discovery_call\n    };\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, quote {});\n    f.set_return_public(true);\n    f.set_body(modified_body);\n}\n\ncomptime fn create_internal_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called internally\";\n    quote { assert(context.msg_sender() == context.this_address(), $assertion_message); }\n}\n\ncomptime fn create_view_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called statically\";\n    if is_fn_private(f) {\n        // Here `context` is of type context::PrivateContext\n        quote { assert(context.inputs.call_context.is_static_call == true, $assertion_message); }\n    } else {\n        // Here `context` is of type context::PublicContext\n        quote { assert(context.is_static_call(), $assertion_message); }\n    }\n}\n\ncomptime fn create_assert_correct_initializer_args(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_{fn_visibility}(context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_mark_as_initialized(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::mark_as_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_init_check(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_is_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\n/// Injects a call to `aztec::discovery::discover_new_notes`, causing for new notes to be added to PXE and made\n/// available for the current execution.\ncomptime fn create_note_discovery_call() -> Quoted {\n    quote {\n        /// Safety: note discovery returns nothing and is performed solely for its side-effects. It is therefore always\n        /// safe to call.\n        unsafe {\n            dep::aztec::discovery::discover_new_notes(\n                context.this_address(),\n                _compute_note_hash_and_nullifier,\n            )\n        };\n    }\n}\n"
+      "source": "use crate::macros::{\n    functions::{abi_export::create_fn_abi_export, call_interface_stubs::stub_fn, stub_registry},\n    notes::NOTES,\n    utils::{\n        add_to_hasher, fn_has_noinitcheck, get_fn_visibility, is_fn_initializer, is_fn_internal,\n        is_fn_private, is_fn_view, modify_fn_body, module_has_initializer, module_has_storage,\n    },\n};\nuse protocol_types::meta::generate_serialize_to_fields;\nuse std::meta::type_of;\n\npub(crate) comptime fn transform_private(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[private] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Private functions undergo a lot of transformations from their Aztec.nr form into a circuit that can be fed to the\n    // Private Kernel Circuit.\n    // First we change the function signature so that it also receives `PrivateContextInputs`, which contain information\n    // about the execution context (e.g. the caller).\n    let original_params = f.parameters();\n    f.set_parameters(&[(\n        quote { inputs },\n        quote { crate::context::inputs::private_context_inputs::PrivateContextInputs }.as_type(),\n    )]\n        .append(original_params));\n\n    let mut body = f.body().as_block().unwrap();\n\n    // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received\n    // the correct values.\n    // TODO: Optimize args_hasher for small number of arguments\n    let args_hasher_name = quote { args_hasher };\n    let args_hasher = original_params.fold(\n        quote {\n            let mut $args_hasher_name = dep::aztec::hash::ArgsHasher::new();\n        },\n        |args_hasher, param: (Quoted, Type)| {\n            let (name, typ) = param;\n            let appended_arg = add_to_hasher(args_hasher_name, name, typ);\n            quote {\n                $args_hasher\n                $appended_arg\n            }\n        },\n    );\n\n    let context_creation = quote {\n        let mut context = dep::aztec::context::private_context::PrivateContext::new(inputs, dep::aztec::protocol_types::traits::Hash::hash($args_hasher_name));\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    // All private functions perform note discovery, since they may need to access notes. This is slightly inefficient\n    // and could be improved by only doing it once we actually attempt to read any.\n    let note_discovery_call = if NOTES.len() > 0 {\n        create_note_discovery_call()\n    } else {\n        quote {}\n    };\n\n    // Finally, we need to change the return type to be `PrivateCircuitPublicInputs`, which is what the Private Kernel\n    // circuit expects.\n    let return_value_var_name = quote { macro__returned__values };\n\n    let return_value_type = f.return_type();\n    let return_value = if body.len() == 0 {\n        quote {}\n    } else if return_value_type != type_of(()) {\n        // The original return value is passed to a second args hasher which the context receives.\n        let (body_without_return, last_body_expr) = body.pop_back();\n        let return_value = last_body_expr.quoted();\n        let return_value_assignment =\n            quote { let $return_value_var_name: $return_value_type = $return_value; };\n        let return_hasher_name = quote { return_hasher };\n        let return_value_into_hasher =\n            add_to_hasher(return_hasher_name, return_value_var_name, return_value_type);\n\n        body = body_without_return;\n\n        quote {\n            let mut $return_hasher_name = dep::aztec::hash::ArgsHasher::new();\n            $return_value_assignment\n            $return_value_into_hasher\n            context.set_return_hash($return_hasher_name);\n        }\n    } else {\n        let (body_without_return, last_body_expr) = body.pop_back();\n        if !last_body_expr.has_semicolon()\n            & last_body_expr.as_for().is_none()\n            & last_body_expr.as_assert().is_none()\n            & last_body_expr.as_for_range().is_none()\n            & last_body_expr.as_assert_eq().is_none()\n            & last_body_expr.as_let().is_none() {\n            let unused_return_value_name = f\"_{return_value_var_name}\".quoted_contents();\n            body = body_without_return.push_back(\n                quote { let $unused_return_value_name = $last_body_expr; }.as_expr().unwrap(),\n            );\n        }\n        quote {}\n    };\n\n    let context_finish = quote { context.finish() };\n\n    let to_prepend = quote {\n        $args_hasher\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n        $note_discovery_call\n    };\n\n    let to_append = quote {\n        $return_value\n        $mark_as_initialized\n        $context_finish\n    };\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n    f.set_return_type(\n        quote { dep::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs }\n            .as_type(),\n    );\n    f.set_return_data();\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_public(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[public] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Public functions undergo a lot of transformations from their Aztec.nr form.\n    let original_params = f.parameters();\n    let args_len = original_params\n        .map(|(name, typ): (Quoted, Type)| {\n            generate_serialize_to_fields(name, typ, &[], false).0.len()\n        })\n        .fold(0, |acc: u32, val: u32| acc + val);\n\n    // Unlike in the private case, in public the `context` does not need to receive the hash of the original params.\n    let context_creation = quote {\n        let mut context = dep::aztec::context::public_context::PublicContext::new(|| {\n        // We start from 1 because we skip the selector for the dispatch function.\n        let serialized_args : [Field; $args_len] = dep::aztec::context::public_context::calldata_copy(1, $args_len);\n        dep::aztec::hash::hash_args_array(serialized_args)\n        });\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n        // referenced. We instead ignore 'unused variable' warnings for it.\n        quote {\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    let to_prepend = quote {\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n    };\n\n    let to_append = quote {\n        $mark_as_initialized\n    };\n\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n\n    // All public functions are automatically made unconstrained, even if they were not marked as such. This is because\n    // instead of compiling into a circuit, they will compile to bytecode that will be later transpiled into AVM\n    // bytecode.\n    f.set_unconstrained(true);\n    f.set_return_public(true);\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_unconstrained(f: FunctionDefinition) {\n    let context_creation = quote { let mut context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new(); };\n    let module_has_storage = module_has_storage(f.module());\n\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(context);\n        }\n    } else {\n        quote {}\n    };\n\n    // All unconstrained functions perform note discovery, since they may need to access notes. This is slightly\n    // inefficient and could be improved by only doing it once we actually attempt to read any.\n    let note_discovery_call = if NOTES.len() > 0 {\n        create_note_discovery_call()\n    } else {\n        quote {}\n    };\n\n    let to_prepend = quote {\n        $context_creation\n        $storage_init\n        $note_discovery_call\n    };\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, quote {});\n    f.set_return_public(true);\n    f.set_body(modified_body);\n}\n\ncomptime fn create_internal_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called internally\";\n    quote { assert(context.msg_sender() == context.this_address(), $assertion_message); }\n}\n\ncomptime fn create_view_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called statically\";\n    if is_fn_private(f) {\n        // Here `context` is of type context::PrivateContext\n        quote { assert(context.inputs.call_context.is_static_call == true, $assertion_message); }\n    } else {\n        // Here `context` is of type context::PublicContext\n        quote { assert(context.is_static_call(), $assertion_message); }\n    }\n}\n\ncomptime fn create_assert_correct_initializer_args(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_{fn_visibility}(context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_mark_as_initialized(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::mark_as_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_init_check(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_is_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\n/// Injects a call to `aztec::discovery::discover_new_notes`, causing for new notes to be added to PXE and made\n/// available for the current execution.\ncomptime fn create_note_discovery_call() -> Quoted {\n    quote {\n        /// Safety: note discovery returns nothing and is performed solely for its side-effects. It is therefore always\n        /// safe to call.\n        unsafe {\n            dep::aztec::discovery::discover_new_notes(\n                context.this_address(),\n                _compute_note_hash_and_nullifier,\n            )\n        };\n    }\n}\n"
     },
     "130": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/mod.nr",
-      "source": "pub mod dispatch;\npub mod functions;\npub mod utils;\npub mod notes;\npub mod storage;\npub mod events;\n\nuse functions::{stub_registry, utils::transform_unconstrained};\nuse notes::{generate_note_export, NOTES};\nuse storage::STORAGE_LAYOUT_NAME;\n\nuse dispatch::generate_public_dispatch;\nuse utils::{get_trait_impl_method, module_has_storage};\n\nuse crate::discovery::MAX_NOTE_PACKED_LEN;\n\n/// Marks a contract as an Aztec contract, generating the interfaces for its functions and notes, as well as injecting\n/// the `process_log` and `sync_notes` functions PXE requires in order to discover notes.\n/// Note: This is a module annotation, so the returned quote gets injected inside the module (contract) itself.\npub comptime fn aztec(m: Module) -> Quoted {\n    let interface = generate_contract_interface(m);\n    let unconstrained_functions = m.functions().filter(|f: FunctionDefinition| {\n        f.is_unconstrained() & !f.has_named_attribute(\"test\") & !f.has_named_attribute(\"public\")\n    });\n    for f in unconstrained_functions {\n        transform_unconstrained(f);\n    }\n\n    let contract_library_method_compute_note_hash_and_nullifier =\n        generate_contract_library_method_compute_note_hash_and_nullifier();\n    let process_log = generate_process_log();\n    let note_exports = generate_note_exports();\n    let public_dispatch = generate_public_dispatch(m);\n    let sync_notes = generate_sync_notes();\n\n    quote {\n        $note_exports\n        $interface\n        $contract_library_method_compute_note_hash_and_nullifier\n        $process_log\n        $public_dispatch\n        $sync_notes\n    }\n}\n\ncomptime fn generate_contract_interface(m: Module) -> Quoted {\n    let module_name = m.name();\n    let contract_stubs = stub_registry::get(m);\n    let fn_stubs_quote = if contract_stubs.is_some() {\n        contract_stubs.unwrap().join(quote {})\n    } else {\n        quote {}\n    };\n\n    let has_storage_layout = module_has_storage(m) & STORAGE_LAYOUT_NAME.get(m).is_some();\n    let storage_layout_getter = if has_storage_layout {\n        let storage_layout_name = STORAGE_LAYOUT_NAME.get(m).unwrap();\n        quote {\n            pub fn storage_layout() -> StorageLayoutFields {\n                $storage_layout_name.fields\n            }\n        }\n    } else {\n        quote {}\n    };\n\n    let library_storage_layout_getter = if has_storage_layout {\n        quote {\n            #[contract_library_method]\n            $storage_layout_getter\n        }\n    } else {\n        quote {}\n    };\n\n    quote {\n        pub struct $module_name {\n            pub target_contract: dep::aztec::protocol_types::address::AztecAddress\n        }\n\n        impl $module_name {\n            $fn_stubs_quote\n\n            pub fn at(\n                addr: aztec::protocol_types::address::AztecAddress\n            ) -> Self {\n                Self { target_contract: addr }\n            }\n\n            pub fn interface() -> Self {\n                Self { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n            }\n\n            $storage_layout_getter\n        }\n\n        #[contract_library_method]\n        pub fn at(\n            addr: aztec::protocol_types::address::AztecAddress\n        ) -> $module_name {\n            $module_name { target_contract: addr }\n        }\n\n        #[contract_library_method]\n        pub fn interface() -> $module_name {\n            $module_name { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n        }\n\n        $library_storage_layout_getter\n\n    }\n}\n\n/// Generates a contract library method called `_compute_note_hash_and_nullifier` which is used for note\n/// discovery (to create the `aztec::discovery::ComputeNoteHashAndNullifier` function) and to implement the\n/// `compute_note_hash_and_nullifier` unconstrained contract function.\ncomptime fn generate_contract_library_method_compute_note_hash_and_nullifier() -> Quoted {\n    let notes = NOTES.entries();\n\n    let mut max_note_packed_len: u32 = 0;\n    if notes.len() > 0 {\n        max_note_packed_len = notes.fold(\n            0,\n            |acc, (_, (_, len, _, _)): (Type, (StructDefinition, u32, Field, [(Quoted, u32, bool)]))| {\n                if len > acc {\n                    len\n                } else {\n                    acc\n                }\n            },\n        );\n\n        if max_note_packed_len > MAX_NOTE_PACKED_LEN {\n            panic(\n                f\"One of the notes has packed len {max_note_packed_len} but the maximum is {MAX_NOTE_PACKED_LEN}\",\n            );\n        }\n\n        // Contracts that do define notes produce an if-else chain where `note_type_id` is matched against the\n        // `get_note_type_id()` function of each note type that we know of, in order to identify the note type. Once we\n        // know it we call we correct `unpack` method from the `Packable` trait to obtain the underlying note type, and\n        // compute the note hash (non-siloed) and inner nullifier (also non-siloed).\n\n        let mut if_note_type_id_match_statements_list = &[];\n        for i in 0..notes.len() {\n            let (typ, (_, packed_note_length, _, _)) = notes[i];\n\n            let get_note_type_id = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteType },\n                quote { get_id },\n            );\n            let unpack = get_trait_impl_method(\n                typ,\n                quote { crate::protocol_types::traits::Packable<_> },\n                quote { unpack },\n            );\n\n            let compute_note_hash = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteHash },\n                quote { compute_note_hash },\n            );\n\n            let compute_nullifier_unconstrained = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteHash },\n                quote { compute_nullifier_unconstrained },\n            );\n\n            let if_or_else_if = if i == 0 {\n                quote { if }\n            } else {\n                quote { else if }\n            };\n\n            if_note_type_id_match_statements_list = if_note_type_id_match_statements_list.push_back(\n                quote {\n                    $if_or_else_if note_type_id == $get_note_type_id() {\n                        // As an extra safety check we make sure that the packed_note BoundedVec has the expected\n                        // length, since we're about to interpret it's raw storage as a fixed-size array by calling the\n                        // unpack function on it.\n                        let expected_len = $packed_note_length;\n                        let actual_len = packed_note.len();\n                        assert(\n                            actual_len == expected_len,\n                            f\"Expected packed note of length {expected_len} but got {actual_len} for note type id {note_type_id}\"\n                        );\n\n                        let note = $unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n\n                        let note_hash = $compute_note_hash(note, storage_slot);\n    \n                        // The note discovery process finds settled notes, that is, notes that were created in prior\n                        // transactions and are therefore already part of the note hash tree. We therefore compute the\n                        // nullification note hash by treating the note as a settled note with the provided nonce.\n                        let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n                            aztec::note::retrieved_note::RetrievedNote{ \n                                note, \n                                contract_address, \n                                metadata: aztec::note::note_metadata::SettledNoteMetadata::new(nonce).into() \n                            }, \n                            storage_slot,\n                        );\n\n                        let inner_nullifier = $compute_nullifier_unconstrained(note, note_hash_for_nullify);\n\n                        Option::some(\n                            aztec::discovery::NoteHashAndNullifier {\n                                note_hash, inner_nullifier\n                            }\n                        )\n                    }\n                },\n            );\n        }\n\n        let if_note_type_id_match_statements = if_note_type_id_match_statements_list.join(quote {});\n\n        quote {\n            /// Unpacks an array into a note corresponding to `note_type_id` and then computes its note hash\n            /// (non-siloed) and inner nullifier (non-siloed) assuming the note has been inserted into the note hash\n            /// tree with `nonce`.\n            ///\n            /// The signature of this function notably matches the `aztec::discovery::ComputeNoteHashAndNullifier` type,\n            /// and so it can be used to call functions from that module such as `discover_new_notes`, `do_process_log`\n            /// and `process_private_note_log`.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_hash_and_nullifier(\n                packed_note: BoundedVec<Field, aztec::discovery::MAX_NOTE_PACKED_LEN>,\n                storage_slot: Field,\n                note_type_id: Field,\n                contract_address: aztec::protocol_types::address::AztecAddress,\n                nonce: Field,\n            ) -> pub Option<aztec::discovery::NoteHashAndNullifier> {\n                $if_note_type_id_match_statements\n                else {\n                    Option::none()\n                }\n            }\n        }\n    } else {\n        // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n        // simply throws immediately.\n        quote {\n            /// This contract does not use private notes, so this function should never be called as it will\n            /// unconditionally fail.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_hash_and_nullifier(\n                _packed_note: BoundedVec<Field, aztec::discovery::MAX_NOTE_PACKED_LEN>,\n                _storage_slot: Field,\n                _note_type_id: Field,\n                _contract_address: aztec::protocol_types::address::AztecAddress,\n            ) -> pub Option<aztec::discovery::NoteHashAndNullifier> {\n                panic(f\"This contract does not use private notes\")\n            }\n        }\n    }\n}\n\ncomptime fn generate_process_log() -> Quoted {\n    // This mandatory function processes a log emitted by the contract. This is currently used to process private logs\n    // and perform note discovery of either private notes or partial notes.\n    // The bulk of the work of this function is done by aztec::discovery::do_process_log, so all we need to do is call\n    // that function.\n\n    // We'll produce the entire body of the function in one go and then insert it into the function.\n    let notes = NOTES.entries();\n\n    if notes.len() > 0 {\n        quote {\n            unconstrained fn process_log(\n                log_plaintext: BoundedVec<Field, dep::aztec::protocol_types::constants::PRIVATE_LOG_SIZE_IN_FIELDS>,\n                tx_hash: Field,\n                unique_note_hashes_in_tx: BoundedVec<Field, dep::aztec::protocol_types::constants::MAX_NOTE_HASHES_PER_TX>,\n                first_nullifier_in_tx: Field,\n                recipient: aztec::protocol_types::address::AztecAddress,\n            ) {\n                // Because this unconstrained function is injected after the contract is processed by the macros, it'll not\n                // be modified by the macros that alter unconstrained functions. As such, we need to manually inject the\n                // unconstrained execution context since it will not be available otherwise.\n                let context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new();\n\n                // TODO(#10727): allow other contracts to process logs and deliver notes\n                let contract_address = context.this_address();\n\n                aztec::discovery::private_logs::do_process_log(\n                    contract_address,\n                    log_plaintext,\n                    tx_hash,\n                    unique_note_hashes_in_tx,\n                    first_nullifier_in_tx,\n                    recipient,\n                    _compute_note_hash_and_nullifier,\n                );\n            }\n        }\n    } else {\n        // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n        // simply throws immediately.\n        quote {\n            unconstrained fn process_log(\n                _log_plaintext: BoundedVec<Field, dep::aztec::protocol_types::constants::PRIVATE_LOG_SIZE_IN_FIELDS>,\n                _tx_hash: Field,\n                _unique_note_hashes_in_tx: BoundedVec<Field, dep::aztec::protocol_types::constants::MAX_NOTE_HASHES_PER_TX>,\n                _first_nullifier_in_tx: Field,\n                _recipient: aztec::protocol_types::address::AztecAddress,\n            ) {\n                panic(f\"This contract does not use private notes\")\n            }\n        }\n    }\n}\n\ncomptime fn generate_note_exports() -> Quoted {\n    let notes = NOTES.values();\n    // Second value in each tuple is `note_packed_len` and that is ignored here because it's only used when\n    // generating partial note helper functions.\n    notes\n        .map(|(s, _, note_type_id, fields): (StructDefinition, u32, Field, [(Quoted, u32, bool)])| {\n            generate_note_export(s, note_type_id, fields)\n        })\n        .join(quote {})\n}\n\ncomptime fn generate_sync_notes() -> Quoted {\n    quote {\n        unconstrained fn sync_notes() {\n            aztec::oracle::note_discovery::sync_notes();\n        }\n    }\n}\n"
+      "source": "pub mod dispatch;\npub mod functions;\npub mod utils;\npub mod notes;\npub mod storage;\npub mod events;\n\nuse functions::{stub_registry, utils::transform_unconstrained};\nuse notes::{generate_note_export, NOTES};\nuse storage::STORAGE_LAYOUT_NAME;\n\nuse dispatch::generate_public_dispatch;\nuse utils::{get_trait_impl_method, module_has_storage};\n\nuse crate::discovery::MAX_NOTE_PACKED_LEN;\n\n/// Marks a contract as an Aztec contract, generating the interfaces for its functions and notes, as well as injecting\n/// the `process_log` and `sync_notes` functions PXE requires in order to discover notes.\n/// Note: This is a module annotation, so the returned quote gets injected inside the module (contract) itself.\npub comptime fn aztec(m: Module) -> Quoted {\n    let interface = generate_contract_interface(m);\n    let unconstrained_functions = m.functions().filter(|f: FunctionDefinition| {\n        f.is_unconstrained() & !f.has_named_attribute(\"test\") & !f.has_named_attribute(\"public\")\n    });\n    for f in unconstrained_functions {\n        transform_unconstrained(f);\n    }\n\n    let contract_library_method_compute_note_hash_and_nullifier =\n        generate_contract_library_method_compute_note_hash_and_nullifier();\n    let process_log = generate_process_log();\n    let note_exports = generate_note_exports();\n    let public_dispatch = generate_public_dispatch(m);\n    let sync_notes = generate_sync_notes();\n\n    quote {\n        $note_exports\n        $interface\n        $contract_library_method_compute_note_hash_and_nullifier\n        $process_log\n        $public_dispatch\n        $sync_notes\n    }\n}\n\ncomptime fn generate_contract_interface(m: Module) -> Quoted {\n    let module_name = m.name();\n    let contract_stubs = stub_registry::get(m);\n    let fn_stubs_quote = if contract_stubs.is_some() {\n        contract_stubs.unwrap().join(quote {})\n    } else {\n        quote {}\n    };\n\n    let has_storage_layout = module_has_storage(m) & STORAGE_LAYOUT_NAME.get(m).is_some();\n    let storage_layout_getter = if has_storage_layout {\n        let storage_layout_name = STORAGE_LAYOUT_NAME.get(m).unwrap();\n        quote {\n            pub fn storage_layout() -> StorageLayoutFields {\n                $storage_layout_name.fields\n            }\n        }\n    } else {\n        quote {}\n    };\n\n    let library_storage_layout_getter = if has_storage_layout {\n        quote {\n            #[contract_library_method]\n            $storage_layout_getter\n        }\n    } else {\n        quote {}\n    };\n\n    quote {\n        pub struct $module_name {\n            pub target_contract: dep::aztec::protocol_types::address::AztecAddress\n        }\n\n        impl $module_name {\n            $fn_stubs_quote\n\n            pub fn at(\n                addr: aztec::protocol_types::address::AztecAddress\n            ) -> Self {\n                Self { target_contract: addr }\n            }\n\n            pub fn interface() -> Self {\n                Self { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n            }\n\n            $storage_layout_getter\n        }\n\n        #[contract_library_method]\n        pub fn at(\n            addr: aztec::protocol_types::address::AztecAddress\n        ) -> $module_name {\n            $module_name { target_contract: addr }\n        }\n\n        #[contract_library_method]\n        pub fn interface() -> $module_name {\n            $module_name { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n        }\n\n        $library_storage_layout_getter\n\n    }\n}\n\n/// Generates a contract library method called `_compute_note_hash_and_nullifier` which is used for note\n/// discovery (to create the `aztec::discovery::ComputeNoteHashAndNullifier` function) and to implement the\n/// `compute_note_hash_and_nullifier` unconstrained contract function.\ncomptime fn generate_contract_library_method_compute_note_hash_and_nullifier() -> Quoted {\n    let notes = NOTES.entries();\n\n    let mut max_note_packed_len: u32 = 0;\n    if notes.len() > 0 {\n        max_note_packed_len = notes.fold(\n            0,\n            |acc, (_, (_, len, _, _)): (Type, (StructDefinition, u32, Field, [(Quoted, u32, bool)]))| {\n                if len > acc {\n                    len\n                } else {\n                    acc\n                }\n            },\n        );\n\n        if max_note_packed_len > MAX_NOTE_PACKED_LEN {\n            panic(\n                f\"One of the notes has packed len {max_note_packed_len} but the maximum is {MAX_NOTE_PACKED_LEN}\",\n            );\n        }\n\n        // Contracts that do define notes produce an if-else chain where `note_type_id` is matched against the\n        // `get_note_type_id()` function of each note type that we know of, in order to identify the note type. Once we\n        // know it we call we correct `unpack` method from the `Packable` trait to obtain the underlying note type, and\n        // compute the note hash (non-siloed) and inner nullifier (also non-siloed).\n\n        let mut if_note_type_id_match_statements_list = &[];\n        for i in 0..notes.len() {\n            let (typ, (_, packed_note_length, _, _)) = notes[i];\n\n            let get_note_type_id = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteType },\n                quote { get_id },\n            );\n            let unpack = get_trait_impl_method(\n                typ,\n                quote { crate::protocol_types::traits::Packable<_> },\n                quote { unpack },\n            );\n\n            let compute_note_hash = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteHash },\n                quote { compute_note_hash },\n            );\n\n            let compute_nullifier_unconstrained = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteHash },\n                quote { compute_nullifier_unconstrained },\n            );\n\n            let if_or_else_if = if i == 0 {\n                quote { if }\n            } else {\n                quote { else if }\n            };\n\n            if_note_type_id_match_statements_list = if_note_type_id_match_statements_list.push_back(\n                quote {\n                    $if_or_else_if note_type_id == $get_note_type_id() {\n                        // As an extra safety check we make sure that the packed_note BoundedVec has the expected\n                        // length, since we're about to interpret it's raw storage as a fixed-size array by calling the\n                        // unpack function on it.\n                        let expected_len = $packed_note_length;\n                        let actual_len = packed_note.len();\n                        assert(\n                            actual_len == expected_len,\n                            f\"Expected packed note of length {expected_len} but got {actual_len} for note type id {note_type_id}\"\n                        );\n\n                        let note = $unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n\n                        let note_hash = $compute_note_hash(note, storage_slot);\n    \n                        // The note discovery process finds settled notes, that is, notes that were created in prior\n                        // transactions and are therefore already part of the note hash tree. We therefore compute the\n                        // nullification note hash by treating the note as a settled note with the provided nonce.\n                        let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n                            aztec::note::retrieved_note::RetrievedNote{ \n                                note, \n                                contract_address, \n                                metadata: aztec::note::note_metadata::SettledNoteMetadata::new(nonce).into() \n                            }, \n                            storage_slot,\n                        );\n\n                        let inner_nullifier = $compute_nullifier_unconstrained(note, note_hash_for_nullify);\n\n                        Option::some(\n                            aztec::discovery::NoteHashAndNullifier {\n                                note_hash, inner_nullifier\n                            }\n                        )\n                    }\n                },\n            );\n        }\n\n        let if_note_type_id_match_statements = if_note_type_id_match_statements_list.join(quote {});\n\n        quote {\n            /// Unpacks an array into a note corresponding to `note_type_id` and then computes its note hash\n            /// (non-siloed) and inner nullifier (non-siloed) assuming the note has been inserted into the note hash\n            /// tree with `nonce`.\n            ///\n            /// The signature of this function notably matches the `aztec::discovery::ComputeNoteHashAndNullifier` type,\n            /// and so it can be used to call functions from that module such as `discover_new_notes`, `do_process_log`\n            /// and `process_private_note_log`.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_hash_and_nullifier(\n                packed_note: BoundedVec<Field, aztec::discovery::MAX_NOTE_PACKED_LEN>,\n                storage_slot: Field,\n                note_type_id: Field,\n                contract_address: aztec::protocol_types::address::AztecAddress,\n                nonce: Field,\n            ) -> Option<aztec::discovery::NoteHashAndNullifier> {\n                $if_note_type_id_match_statements\n                else {\n                    Option::none()\n                }\n            }\n        }\n    } else {\n        // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n        // simply throws immediately.\n        quote {\n            /// This contract does not use private notes, so this function should never be called as it will\n            /// unconditionally fail.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_hash_and_nullifier(\n                _packed_note: BoundedVec<Field, aztec::discovery::MAX_NOTE_PACKED_LEN>,\n                _storage_slot: Field,\n                _note_type_id: Field,\n                _contract_address: aztec::protocol_types::address::AztecAddress,\n            ) -> pub Option<aztec::discovery::NoteHashAndNullifier> {\n                panic(f\"This contract does not use private notes\")\n            }\n        }\n    }\n}\n\ncomptime fn generate_process_log() -> Quoted {\n    // This mandatory function processes a log emitted by the contract. This is currently used to process private logs\n    // and perform note discovery of either private notes or partial notes.\n    // The bulk of the work of this function is done by aztec::discovery::do_process_log, so all we need to do is call\n    // that function.\n\n    // We'll produce the entire body of the function in one go and then insert it into the function.\n    let notes = NOTES.entries();\n\n    if notes.len() > 0 {\n        quote {\n            unconstrained fn process_log(\n                log_plaintext: BoundedVec<Field, dep::aztec::protocol_types::constants::PRIVATE_LOG_SIZE_IN_FIELDS>,\n                tx_hash: Field,\n                unique_note_hashes_in_tx: BoundedVec<Field, dep::aztec::protocol_types::constants::MAX_NOTE_HASHES_PER_TX>,\n                first_nullifier_in_tx: Field,\n                recipient: aztec::protocol_types::address::AztecAddress,\n            ) {\n                // Because this unconstrained function is injected after the contract is processed by the macros, it'll not\n                // be modified by the macros that alter unconstrained functions. As such, we need to manually inject the\n                // unconstrained execution context since it will not be available otherwise.\n                let context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new();\n\n                // TODO(#10727): allow other contracts to process logs and deliver notes\n                let contract_address = context.this_address();\n\n                aztec::discovery::private_logs::do_process_log(\n                    contract_address,\n                    log_plaintext,\n                    tx_hash,\n                    unique_note_hashes_in_tx,\n                    first_nullifier_in_tx,\n                    recipient,\n                    _compute_note_hash_and_nullifier,\n                );\n            }\n        }\n    } else {\n        // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n        // simply throws immediately.\n        quote {\n            unconstrained fn process_log(\n                _log_plaintext: BoundedVec<Field, dep::aztec::protocol_types::constants::PRIVATE_LOG_SIZE_IN_FIELDS>,\n                _tx_hash: Field,\n                _unique_note_hashes_in_tx: BoundedVec<Field, dep::aztec::protocol_types::constants::MAX_NOTE_HASHES_PER_TX>,\n                _first_nullifier_in_tx: Field,\n                _recipient: aztec::protocol_types::address::AztecAddress,\n            ) {\n                panic(f\"This contract does not use private notes\")\n            }\n        }\n    }\n}\n\ncomptime fn generate_note_exports() -> Quoted {\n    let notes = NOTES.values();\n    // Second value in each tuple is `note_packed_len` and that is ignored here because it's only used when\n    // generating partial note helper functions.\n    notes\n        .map(|(s, _, note_type_id, fields): (StructDefinition, u32, Field, [(Quoted, u32, bool)])| {\n            generate_note_export(s, note_type_id, fields)\n        })\n        .join(quote {})\n}\n\ncomptime fn generate_sync_notes() -> Quoted {\n    quote {\n        unconstrained fn sync_notes() {\n            aztec::oracle::note_discovery::sync_notes();\n        }\n    }\n}\n"
     },
     "150": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/call_private_function.nr",
@@ -3911,11 +3911,11 @@
     },
     "64": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/authwit/src/account.nr",
-      "source": "use dep::aztec::{\n    context::PrivateContext,\n    hash::poseidon2_hash_with_separator,\n    protocol_types::constants::{GENERATOR_INDEX__COMBINED_PAYLOAD, GENERATOR_INDEX__TX_NULLIFIER},\n};\n\nuse crate::auth::{compute_authwit_message_hash, IS_VALID_SELECTOR};\nuse crate::entrypoint::{app::AppPayload, fee::FeePayload};\n\npub struct AccountActions<Context> {\n    context: Context,\n    is_valid_impl: fn(&mut PrivateContext, Field) -> bool,\n}\n\nimpl<Context> AccountActions<Context> {\n    pub fn init(context: Context, is_valid_impl: fn(&mut PrivateContext, Field) -> bool) -> Self {\n        AccountActions { context, is_valid_impl }\n    }\n}\n\n/**\n * An implementation of the Account Action struct for the private context.\n *\n * Implements logic to verify authorization and execute payloads.\n */\nimpl AccountActions<&mut PrivateContext> {\n\n    /**\n     * Verifies that the `app_hash` and `fee_hash` are authorized and then executes them.\n     *\n     * Executes the `fee_payload` and `app_payload` in sequence.\n     * Will execute the `fee_payload` as part of the setup, and then enter the app phase.\n     *\n     * @param app_payload The payload that contains the calls to be executed in the app phase.\n     * @param fee_payload The payload that contains the calls to be executed in the setup phase.\n     */\n    // docs:start:entrypoint\n    pub fn entrypoint(self, app_payload: AppPayload, fee_payload: FeePayload, cancellable: bool) {\n        let valid_fn = self.is_valid_impl;\n\n        let combined_payload_hash = poseidon2_hash_with_separator(\n            [app_payload.hash(), fee_payload.hash()],\n            GENERATOR_INDEX__COMBINED_PAYLOAD,\n        );\n        assert(valid_fn(self.context, combined_payload_hash));\n\n        fee_payload.execute_calls(self.context);\n        self.context.end_setup();\n        app_payload.execute_calls(self.context);\n        if cancellable {\n            let tx_nullifier =\n                poseidon2_hash_with_separator([app_payload.nonce], GENERATOR_INDEX__TX_NULLIFIER);\n            self.context.push_nullifier(tx_nullifier);\n        }\n    }\n    // docs:end:entrypoint\n\n    /**\n     * Verifies that the `msg_sender` is authorized to consume `inner_hash` by the account.\n     *\n     * Computes the `message_hash` using the `msg_sender`, `chain_id`, `version` and `inner_hash`.\n     * Then executes the `is_valid_impl` function to verify that the message is authorized.\n     *\n     * Will revert if the message is not authorized.\n     *\n     * @param inner_hash The hash of the message that the `msg_sender` is trying to consume.\n     */\n    // docs:start:verify_private_authwit\n    pub fn verify_private_authwit(self, inner_hash: Field) -> Field {\n        // The `inner_hash` is \"siloed\" with the `msg_sender` to ensure that only it can\n        // consume the message.\n        // This ensures that contracts cannot consume messages that are not intended for them.\n        let message_hash = compute_authwit_message_hash(\n            self.context.msg_sender(),\n            self.context.chain_id(),\n            self.context.version(),\n            inner_hash,\n        );\n        let valid_fn = self.is_valid_impl;\n        assert(valid_fn(self.context, message_hash) == true, \"Message not authorized by account\");\n        IS_VALID_SELECTOR\n    }\n    // docs:end:verify_private_authwit\n}\n"
+      "source": "use dep::aztec::{\n    context::PrivateContext,\n    hash::poseidon2_hash_with_separator,\n    protocol_types::{\n        constants::{GENERATOR_INDEX__COMBINED_PAYLOAD, GENERATOR_INDEX__TX_NULLIFIER},\n        traits::Hash,\n    },\n};\n\nuse crate::auth::{compute_authwit_message_hash, IS_VALID_SELECTOR};\nuse crate::entrypoint::{app::AppPayload, fee::FeePayload};\n\npub struct AccountActions<Context> {\n    context: Context,\n    is_valid_impl: fn(&mut PrivateContext, Field) -> bool,\n}\n\nimpl<Context> AccountActions<Context> {\n    pub fn init(context: Context, is_valid_impl: fn(&mut PrivateContext, Field) -> bool) -> Self {\n        AccountActions { context, is_valid_impl }\n    }\n}\n\n/**\n * An implementation of the Account Action struct for the private context.\n *\n * Implements logic to verify authorization and execute payloads.\n */\nimpl AccountActions<&mut PrivateContext> {\n\n    /**\n     * Verifies that the `app_hash` and `fee_hash` are authorized and then executes them.\n     *\n     * Executes the `fee_payload` and `app_payload` in sequence.\n     * Will execute the `fee_payload` as part of the setup, and then enter the app phase.\n     *\n     * @param app_payload The payload that contains the calls to be executed in the app phase.\n     * @param fee_payload The payload that contains the calls to be executed in the setup phase.\n     */\n    // docs:start:entrypoint\n    pub fn entrypoint(self, app_payload: AppPayload, fee_payload: FeePayload, cancellable: bool) {\n        let valid_fn = self.is_valid_impl;\n\n        let combined_payload_hash = poseidon2_hash_with_separator(\n            [app_payload.hash(), fee_payload.hash()],\n            GENERATOR_INDEX__COMBINED_PAYLOAD,\n        );\n        assert(valid_fn(self.context, combined_payload_hash));\n\n        fee_payload.execute_calls(self.context);\n        self.context.end_setup();\n        app_payload.execute_calls(self.context);\n        if cancellable {\n            let tx_nullifier =\n                poseidon2_hash_with_separator([app_payload.nonce], GENERATOR_INDEX__TX_NULLIFIER);\n            self.context.push_nullifier(tx_nullifier);\n        }\n    }\n    // docs:end:entrypoint\n\n    /**\n     * Verifies that the `msg_sender` is authorized to consume `inner_hash` by the account.\n     *\n     * Computes the `message_hash` using the `msg_sender`, `chain_id`, `version` and `inner_hash`.\n     * Then executes the `is_valid_impl` function to verify that the message is authorized.\n     *\n     * Will revert if the message is not authorized.\n     *\n     * @param inner_hash The hash of the message that the `msg_sender` is trying to consume.\n     */\n    // docs:start:verify_private_authwit\n    pub fn verify_private_authwit(self, inner_hash: Field) -> Field {\n        // The `inner_hash` is \"siloed\" with the `msg_sender` to ensure that only it can\n        // consume the message.\n        // This ensures that contracts cannot consume messages that are not intended for them.\n        let message_hash = compute_authwit_message_hash(\n            self.context.msg_sender(),\n            self.context.chain_id(),\n            self.context.version(),\n            inner_hash,\n        );\n        let valid_fn = self.is_valid_impl;\n        assert(valid_fn(self.context, message_hash) == true, \"Message not authorized by account\");\n        IS_VALID_SELECTOR\n    }\n    // docs:end:verify_private_authwit\n}\n"
     },
     "65": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/authwit/src/auth.nr",
-      "source": "use dep::aztec::{context::{gas::GasOpts, PrivateContext, PublicContext}, hash::hash_args_array};\nuse dep::aztec::protocol_types::{\n    abis::function_selector::FunctionSelector,\n    address::AztecAddress,\n    constants::{\n        CANONICAL_AUTH_REGISTRY_ADDRESS, GENERATOR_INDEX__AUTHWIT_INNER,\n        GENERATOR_INDEX__AUTHWIT_NULLIFIER, GENERATOR_INDEX__AUTHWIT_OUTER,\n    },\n    hash::poseidon2_hash_with_separator,\n};\n\n/**\n * Authenticaion witness helper library\n *\n * Authentication Witness is a scheme for authenticating actions on Aztec, so users can allow third-parties\n * (e.g. protocols or other users) to execute an action on their behalf.\n *\n * This library provides helper functions to manage such witnesses.\n * The authentication witness, is some \"witness\" (data) that authenticates a `message_hash`.\n * The simplest example of an authentication witness, is a signature. The signature is the \"evidence\",\n * that the signer has seen the message, agrees with it, and has allowed it.\n * It does not need to be a signature. It could be any kind of \"proof\" that the message is allowed.\n * Another proof could be knowing some kind of secret, or having some kind of \"token\" that allows the message.\n *\n * The `message_hash` is a hash of the following structure:\n * hash(consumer, chain_id, version, inner_hash)\n * - consumer: the address of the contract that is \"consuming\" the message,\n * - chain_id: the chain id of the chain that the message is being consumed on,\n * - version: the version of the chain that the message is being consumed on,\n * - inner_hash: the hash of the \"inner\" message that is being consumed, this is the \"actual\" message or action.\n *\n * While the `inner_hash` could be anything, such as showing you signed a specific message, it will often be\n * a hash of the \"action\" to approve, along with who made the call. As part of this library, we provide a few\n * helper functions to deal with such messages.\n *\n * For example, we provide helper function that is used for checking that the message is an encoding of the current call.\n * This can be used to let some contract \"allow\" another contract to act on its behalf, as long as it can\n * show that it is acting on behalf of the contract.\n *\n * If we take a case of allowing a contract to transfer tokens on behalf of an account, the `inner_hash` can be\n * derived as:\n * inner_hash = hash(caller, \"transfer\", hash(to, amount))\n *\n * Where the `caller` would be the address of the contract that is trying to transfer the tokens, and `to` and `amount`\n * the arguments for the transfer.\n *\n * Note that we have both a `caller` and a `consumer`, the `consumer` will be the contract that is consuming the message,\n * in the case of the transfer, it would be the `Token` contract itself, while the caller, will be the actor that is\n * allowed to transfer the tokens.\n *\n *\n * The authentication mechanism works differently in public and private contexts. In private, we recall that everything\n * is executed on the user's device, so we can use `oracles` to \"ask\" the user (not contract) for information. In public\n * we cannot do this, since it is executed by the sequencer (someone else). Therefore we can instead use a \"registry\"\n * to store the messages that we have approved.\n *\n * A simple example would be a \"token\" that is being \"pulled\" from one account into another. We will first outline\n * how this would look in private, and then in public later.\n *\n * Say that a user `Alice` wants to deposit some tokens into a DeFi protocol (say a DEX).\n * `Alice` would make a `deposit` transaction, that she is executing using her account contract.\n * The account would call the `DeFi` contract to execute `deposit`, which would try to pull funds from the `Token`\n * contract. Since the `DeFi` contract is trying to pull funds from an account that is not its own, it needs to\n * convince the `Token` contract that it is allowed to do so.\n *\n * This is where the authentication witness comes in The `Token` contract computes a `message_hash` from the\n * `transfer` call, and then asks `Alice Account` contract to verify that the `DeFi` contract is allowed to\n * execute that call.\n *\n * `Alice Account` contract can then ask `Alice` if she wants to allow the `DeFi` contract to pull funds from her\n * account. If she does, she will sign the `message_hash` and return the signature to the `Alice Account` which\n * will validate it and return success to the `Token` contract which will then allow the `DeFi` contract to pull\n * funds from `Alice`.\n *\n * To ensure that the same \"approval\" cannot be used multiple times, we also compute a `nullifier` for the\n * authentication witness, and emit it from the `Token` contract (consumer).\n *\n * Note that we can do this flow as we are in private were we can do oracle calls out from contracts.\n *\n *\n *  Person          Contract              Contract               Contract\n *  Alice          Alice Account          Token                   DeFi\n *   |                  |                  |                      |\n *   | Defi.deposit(Token, 1000)           |                      |\n *   |----------------->|                  |                      |\n *   |                  | deposit(Token, 1000)                    |\n *   |                  |---------------------------------------->|\n *   |                  |                  |                      |\n *   |                  |                  | transfer(Alice, Defi, 1000)\n *   |                  |                  |<---------------------|\n *   |                  |                  |                      |\n *   |                  | Check if Defi may call transfer(Alice, Defi, 1000)\n *   |                  |<-----------------|                      |\n *   |                  |                  |                      |\n *   | Please give me AuthWit for DeFi     |                      |\n *   | calling transfer(Alice, Defi, 1000) |                      |\n *   |<-----------------|                  |                      |\n *   |                  |                  |                      |\n *   |                  |                  |                      |\n *   | AuthWit for transfer(Alice, Defi, 1000)                    |\n *   |----------------->|                  |                      |\n *   |                  | AuthWit validity |                      |\n *   |                  |----------------->|                      |\n *   |                  |                  |                      |\n *   |                  |       throw if invalid AuthWit          |\n *   |                  |                  |                      |\n *   |                  |       emit AuthWit nullifier            |\n *   |                  |                  |                      |\n *   |                  |       transfer(Alice, Defi, 1000)       |\n *   |                  |                  |                      |\n *   |                  |                  |                      |\n *   |                  |                  | success              |\n *   |                  |                  |--------------------->|\n *   |                  |                  |                      |\n *   |                  |                  |                      |\n *   |                  |                  |           deposit(Token, 1000)\n *   |                  |                  |                      |\n *   |                  |                  |                      |\n *\n *\n * If we instead were in public, we cannot do the same flow. Instead we would use an authentication registry to store\n * the messages that we have approved.\n *\n * To approve a message, `Alice Account` can make a `set_authorized` call to the registry, to set a `message_hash`\n * as authorized. This is essentially a mapping from `message_hash` to `true` for `Alice Contract`. Every account\n * has its own map in the registry, so `Alice` cannot approve a message for `Bob`.\n *\n * The `Token` contract can then try to \"spend\" the approval by calling `consume` on the registry. If the message\n * was approved, the value is updated to `false`, and we return the success flag. For more information on the\n * registry, see `main.nr` in `auth_registry_contract`.\n *\n * Person          Contract              Contract            Contract               Contract\n * Alice          Alice Account          Registry             Token                   DeFi\n *   |                  |                    |                   |                      |\n *   | Registry.set_authorized(..., true)    |                   |                      |\n *   |----------------->|                    |                   |                      |\n *   |                  | set_authorized(..., true)              |                      |\n *   |                  |------------------->|                   |                      |\n *   |                  |                    |                   |                      |\n *   |                  |         set authorized to true         |                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   |                      |\n *   | Defi.deposit(Token, 1000)             |                   |                      |\n *   |----------------->|                    |                   |                      |\n *   |                  | deposit(Token, 1000)                   |                      |\n *   |                  |-------------------------------------------------------------->|\n *   |                  |                    |                   |                      |\n *   |                  |                    |              transfer(Alice, Defi, 1000) |\n *   |                  |                    |                   |<---------------------|\n *   |                  |                    |                   |                      |\n *   |                  |                    | Check if Defi may call transfer(Alice, Defi, 1000)\n *   |                  |                    |<------------------|                      |\n *   |                  |                    |                   |                      |\n *   |                  |          throw if invalid AuthWit      |                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   |                      |\n *   |                  |           set authorized to false      |                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    | AuthWit validity  |                      |\n *   |                  |                    |------------------>|                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   | transfer(Alice, Defi, 1000)\n *   |                  |                    |                   |<-------------------->|\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   | success              |\n *   |                  |                    |                   |--------------------->|\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   |     deposit(Token, 1000)\n *   |                  |                    |                   |                      |\n *\n *\n * --- FAQ ---\n * Q:   Why are we using a success flag of `poseidon2_hash_bytes(\"IS_VALID()\")` instead of just returning a boolean?\n * A:   We want to make sure that we don't accidentally return `true` if there is a collision in the function selector.\n *      By returning a hash of `IS_VALID()`, it becomes very unlikely that there is both a collision and we return\n *      a success flag.\n *\n * Q:   Why are we using static calls?\n * A:   We are using static calls to ensure that the account contract cannot re-enter. If it was a normal call, it\n *      could make a new call and do a re-entry attack. Using a static ensures that it cannot update any state.\n *\n * Q:   Would it not be cheaper to use a nullifier instead of updating state in public?\n * A:   At a quick glance, a public state update + nullifier is 96 bytes, but two state updates are 128, so it would be\n *      cheaper to use a nullifier, if this is the way it would always be done. However, if both the approval and the\n *      consumption is done in the same transaction, then we will be able to squash the updates (only final tx state diff is posted to DA), and now it is cheaper.\n *\n * Q:   Why is the chain id and the version part of the message hash?\n * A:   The chain id and the version is part of the message hash to ensure that the message is only valid on a specific\n *      chain to avoid a case where the same message could be used across multiple chains.\n */\n\nglobal IS_VALID_SELECTOR: Field = 0x47dacd73; // 4 last bytes of poseidon2_hash_bytes(\"IS_VALID()\")\n\n/**\n * Assert that `on_behalf_of` has authorized the current call with a valid authentication witness\n *\n * Compute the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then make a call out to the\n * `on_behalf_of` contract to verify that the `inner_hash` is valid.\n *\n * @param on_behalf_of The address that has allegedly authorized the current call\n */\n// docs:start:assert_current_call_valid_authwit\npub fn assert_current_call_valid_authwit(context: &mut PrivateContext, on_behalf_of: AztecAddress) {\n    let inner_hash = compute_inner_authwit_hash([\n        context.msg_sender().to_field(),\n        context.selector().to_field(),\n        context.args_hash,\n    ]);\n    assert_inner_hash_valid_authwit(context, on_behalf_of, inner_hash);\n}\n// docs:end:assert_current_call_valid_authwit\n\n/**\n * Assert that a specific `inner_hash` is valid for the `on_behalf_of` address\n *\n * Used as an internal function for `assert_current_call_valid_authwit` and can be used as a standalone function when\n * the `inner_hash` is from a different source, e.g., say a block of text etc.\n *\n * @param on_behalf_of The address that has allegedly authorized the current call\n * @param inner_hash The hash of the message to authorize\n */\npub fn assert_inner_hash_valid_authwit(\n    context: &mut PrivateContext,\n    on_behalf_of: AztecAddress,\n    inner_hash: Field,\n) {\n    // We perform a static call here and not a standard one to ensure that the account contract cannot re-enter.\n    let result: Field = context\n        .static_call_private_function(\n            on_behalf_of,\n            comptime { FunctionSelector::from_signature(\"verify_private_authwit(Field)\") },\n            [inner_hash],\n        )\n        .get_preimage();\n    assert(result == IS_VALID_SELECTOR, \"Message not authorized by account\");\n    // Compute the nullifier, similar computation to the outer hash, but without the chain_id and version.\n    // Those should already be handled in the verification, so we just need something to nullify, that allows the same inner_hash for multiple actors.\n    let nullifier = compute_authwit_nullifier(on_behalf_of, inner_hash);\n    context.push_nullifier(nullifier);\n}\n\n/**\n * Assert that `on_behalf_of` has authorized the current call in the authentication registry\n *\n * Compute the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then make a call out to the\n * `on_behalf_of` contract to verify that the `inner_hash` is valid.\n *\n * Note that the authentication registry will take the `msg_sender` into account as the consumer, so this will only\n * work if the `msg_sender` is the same as the `consumer` when the `message_hash` was inserted into the registry.\n *\n * @param on_behalf_of The address that has allegedly authorized the current call\n */\n// docs:start:assert_current_call_valid_authwit_public\npub unconstrained fn assert_current_call_valid_authwit_public(\n    context: &mut PublicContext,\n    on_behalf_of: AztecAddress,\n) {\n    let inner_hash = compute_inner_authwit_hash([\n        (*context).msg_sender().to_field(),\n        (*context).selector().to_field(),\n        (*context).get_args_hash(),\n    ]);\n    assert_inner_hash_valid_authwit_public(context, on_behalf_of, inner_hash);\n}\n// docs:end:assert_current_call_valid_authwit_public\n\n/**\n * Assert that `on_behalf_of` has authorized a specific `inner_hash` in the authentication registry\n *\n * Compute the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then make a call out to the\n * `on_behalf_of` contract to verify that the `inner_hash` is valid.\n *\n * Note that the authentication registry will take the `msg_sender` into account as the consumer, so this will only\n * work if the `msg_sender` is the same as the `consumer` when the `message_hash` was inserted into the registry.\n *\n * @param on_behalf_of The address that has allegedly authorized the `inner_hash`\n */\npub unconstrained fn assert_inner_hash_valid_authwit_public(\n    context: &mut PublicContext,\n    on_behalf_of: AztecAddress,\n    inner_hash: Field,\n) {\n    let results: [Field] = context.call_public_function(\n        CANONICAL_AUTH_REGISTRY_ADDRESS,\n        comptime { FunctionSelector::from_signature(\"consume((Field),Field)\") },\n        [on_behalf_of.to_field(), inner_hash].as_slice(),\n        GasOpts::default(),\n    );\n    assert(results.len() == 1, \"Invalid response from registry\");\n    assert(results[0] == IS_VALID_SELECTOR, \"Message not authorized by account\");\n}\n\n/**\n * Compute the `message_hash` from a function call to be used by an authentication witness\n *\n * Useful for when you need a non-account contract to approve during execution. For example if you need a contract\n * to make a call to nested contract, e.g., contract A wants to exit token T to L1 using bridge B, so it needs to allow\n * B to transfer T on its behalf.\n *\n * @param caller The address of the contract that is calling the function, in the example above, this would be B\n * @param consumer The address of the contract that is consuming the message, in the example above, this would be T\n * @param chain_id The chain id of the chain that the message is being consumed on\n * @param version The version of the chain that the message is being consumed on\n * @param selector The function selector of the function that is being called\n * @param args The arguments of the function that is being called\n */\n// docs:start:compute_authwit_message_hash_from_call\npub fn compute_authwit_message_hash_from_call<let N: u32>(\n    caller: AztecAddress,\n    consumer: AztecAddress,\n    chain_id: Field,\n    version: Field,\n    selector: FunctionSelector,\n    args: [Field; N],\n) -> Field {\n    let args_hash = hash_args_array(args);\n    let inner_hash =\n        compute_inner_authwit_hash([caller.to_field(), selector.to_field(), args_hash]);\n    compute_authwit_message_hash(consumer, chain_id, version, inner_hash)\n}\n// docs:end:compute_authwit_message_hash_from_call\n\n/**\n * Computes the `inner_hash` of the authentication witness\n *\n * This is used internally, but also useful in cases where you want to compute the `inner_hash` for a specific message\n * that is not necessarily a call, but just some \"bytes\" or text.\n *\n * @param args The arguments to hash\n */\npub fn compute_inner_authwit_hash<let N: u32>(args: [Field; N]) -> Field {\n    poseidon2_hash_with_separator(args, GENERATOR_INDEX__AUTHWIT_INNER)\n}\n\n/**\n * Computes the `authwit_nullifier` for a specific `on_behalf_of` and `inner_hash`\n *\n * Using the `on_behalf_of` and the `inner_hash` to ensure that the nullifier is siloed for a specific `on_behalf_of`.\n *\n * @param on_behalf_of The address that has authorized the `inner_hash`\n * @param inner_hash The hash of the message to authorize\n */\npub fn compute_authwit_nullifier(on_behalf_of: AztecAddress, inner_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [on_behalf_of.to_field(), inner_hash],\n        GENERATOR_INDEX__AUTHWIT_NULLIFIER,\n    )\n}\n\n/**\n * Computes the `message_hash` for the authentication witness\n *\n * @param consumer The address of the contract that is consuming the message\n * @param chain_id The chain id of the chain that the message is being consumed on\n * @param version The version of the chain that the message is being consumed on\n * @param inner_hash The hash of the \"inner\" message that is being consumed\n */\npub fn compute_authwit_message_hash(\n    consumer: AztecAddress,\n    chain_id: Field,\n    version: Field,\n    inner_hash: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [consumer.to_field(), chain_id, version, inner_hash],\n        GENERATOR_INDEX__AUTHWIT_OUTER,\n    )\n}\n\n/**\n * Helper function to set the authorization status of a message hash\n *\n * Wraps a public call to the authentication registry to set the authorization status of a `message_hash`\n *\n * @param message_hash The hash of the message to authorize\n * @param authorize True if the message should be authorized, false if it should be revoked\n */\npub unconstrained fn set_authorized(\n    context: &mut PublicContext,\n    message_hash: Field,\n    authorize: bool,\n) {\n    let res = context.call_public_function(\n        CANONICAL_AUTH_REGISTRY_ADDRESS,\n        comptime { FunctionSelector::from_signature(\"set_authorized(Field,bool)\") },\n        [message_hash, authorize as Field].as_slice(),\n        GasOpts::default(),\n    );\n    assert(res.len() == 0);\n}\n\n/**\n * Helper function to reject all authwits\n *\n * Wraps a public call to the authentication registry to set the `reject_all` flag\n *\n * @param reject True if all authwits should be rejected, false otherwise\n */\npub unconstrained fn set_reject_all(context: &mut PublicContext, reject: bool) {\n    let res = context.call_public_function(\n        CANONICAL_AUTH_REGISTRY_ADDRESS,\n        comptime { FunctionSelector::from_signature(\"set_reject_all(bool)\") },\n        [context.this_address().to_field(), reject as Field].as_slice(),\n        GasOpts::default(),\n    );\n    assert(res.len() == 0);\n}\n"
+      "source": "use dep::aztec::{context::{gas::GasOpts, PrivateContext, PublicContext}, hash::hash_args_array};\nuse dep::aztec::protocol_types::{\n    abis::function_selector::FunctionSelector,\n    address::AztecAddress,\n    constants::{\n        CANONICAL_AUTH_REGISTRY_ADDRESS, GENERATOR_INDEX__AUTHWIT_INNER,\n        GENERATOR_INDEX__AUTHWIT_NULLIFIER, GENERATOR_INDEX__AUTHWIT_OUTER,\n    },\n    hash::poseidon2_hash_with_separator,\n    traits::ToField,\n};\n\n/**\n * Authenticaion witness helper library\n *\n * Authentication Witness is a scheme for authenticating actions on Aztec, so users can allow third-parties\n * (e.g. protocols or other users) to execute an action on their behalf.\n *\n * This library provides helper functions to manage such witnesses.\n * The authentication witness, is some \"witness\" (data) that authenticates a `message_hash`.\n * The simplest example of an authentication witness, is a signature. The signature is the \"evidence\",\n * that the signer has seen the message, agrees with it, and has allowed it.\n * It does not need to be a signature. It could be any kind of \"proof\" that the message is allowed.\n * Another proof could be knowing some kind of secret, or having some kind of \"token\" that allows the message.\n *\n * The `message_hash` is a hash of the following structure:\n * hash(consumer, chain_id, version, inner_hash)\n * - consumer: the address of the contract that is \"consuming\" the message,\n * - chain_id: the chain id of the chain that the message is being consumed on,\n * - version: the version of the chain that the message is being consumed on,\n * - inner_hash: the hash of the \"inner\" message that is being consumed, this is the \"actual\" message or action.\n *\n * While the `inner_hash` could be anything, such as showing you signed a specific message, it will often be\n * a hash of the \"action\" to approve, along with who made the call. As part of this library, we provide a few\n * helper functions to deal with such messages.\n *\n * For example, we provide helper function that is used for checking that the message is an encoding of the current call.\n * This can be used to let some contract \"allow\" another contract to act on its behalf, as long as it can\n * show that it is acting on behalf of the contract.\n *\n * If we take a case of allowing a contract to transfer tokens on behalf of an account, the `inner_hash` can be\n * derived as:\n * inner_hash = hash(caller, \"transfer\", hash(to, amount))\n *\n * Where the `caller` would be the address of the contract that is trying to transfer the tokens, and `to` and `amount`\n * the arguments for the transfer.\n *\n * Note that we have both a `caller` and a `consumer`, the `consumer` will be the contract that is consuming the message,\n * in the case of the transfer, it would be the `Token` contract itself, while the caller, will be the actor that is\n * allowed to transfer the tokens.\n *\n *\n * The authentication mechanism works differently in public and private contexts. In private, we recall that everything\n * is executed on the user's device, so we can use `oracles` to \"ask\" the user (not contract) for information. In public\n * we cannot do this, since it is executed by the sequencer (someone else). Therefore we can instead use a \"registry\"\n * to store the messages that we have approved.\n *\n * A simple example would be a \"token\" that is being \"pulled\" from one account into another. We will first outline\n * how this would look in private, and then in public later.\n *\n * Say that a user `Alice` wants to deposit some tokens into a DeFi protocol (say a DEX).\n * `Alice` would make a `deposit` transaction, that she is executing using her account contract.\n * The account would call the `DeFi` contract to execute `deposit`, which would try to pull funds from the `Token`\n * contract. Since the `DeFi` contract is trying to pull funds from an account that is not its own, it needs to\n * convince the `Token` contract that it is allowed to do so.\n *\n * This is where the authentication witness comes in The `Token` contract computes a `message_hash` from the\n * `transfer` call, and then asks `Alice Account` contract to verify that the `DeFi` contract is allowed to\n * execute that call.\n *\n * `Alice Account` contract can then ask `Alice` if she wants to allow the `DeFi` contract to pull funds from her\n * account. If she does, she will sign the `message_hash` and return the signature to the `Alice Account` which\n * will validate it and return success to the `Token` contract which will then allow the `DeFi` contract to pull\n * funds from `Alice`.\n *\n * To ensure that the same \"approval\" cannot be used multiple times, we also compute a `nullifier` for the\n * authentication witness, and emit it from the `Token` contract (consumer).\n *\n * Note that we can do this flow as we are in private were we can do oracle calls out from contracts.\n *\n *\n *  Person          Contract              Contract               Contract\n *  Alice          Alice Account          Token                   DeFi\n *   |                  |                  |                      |\n *   | Defi.deposit(Token, 1000)           |                      |\n *   |----------------->|                  |                      |\n *   |                  | deposit(Token, 1000)                    |\n *   |                  |---------------------------------------->|\n *   |                  |                  |                      |\n *   |                  |                  | transfer(Alice, Defi, 1000)\n *   |                  |                  |<---------------------|\n *   |                  |                  |                      |\n *   |                  | Check if Defi may call transfer(Alice, Defi, 1000)\n *   |                  |<-----------------|                      |\n *   |                  |                  |                      |\n *   | Please give me AuthWit for DeFi     |                      |\n *   | calling transfer(Alice, Defi, 1000) |                      |\n *   |<-----------------|                  |                      |\n *   |                  |                  |                      |\n *   |                  |                  |                      |\n *   | AuthWit for transfer(Alice, Defi, 1000)                    |\n *   |----------------->|                  |                      |\n *   |                  | AuthWit validity |                      |\n *   |                  |----------------->|                      |\n *   |                  |                  |                      |\n *   |                  |       throw if invalid AuthWit          |\n *   |                  |                  |                      |\n *   |                  |       emit AuthWit nullifier            |\n *   |                  |                  |                      |\n *   |                  |       transfer(Alice, Defi, 1000)       |\n *   |                  |                  |                      |\n *   |                  |                  |                      |\n *   |                  |                  | success              |\n *   |                  |                  |--------------------->|\n *   |                  |                  |                      |\n *   |                  |                  |                      |\n *   |                  |                  |           deposit(Token, 1000)\n *   |                  |                  |                      |\n *   |                  |                  |                      |\n *\n *\n * If we instead were in public, we cannot do the same flow. Instead we would use an authentication registry to store\n * the messages that we have approved.\n *\n * To approve a message, `Alice Account` can make a `set_authorized` call to the registry, to set a `message_hash`\n * as authorized. This is essentially a mapping from `message_hash` to `true` for `Alice Contract`. Every account\n * has its own map in the registry, so `Alice` cannot approve a message for `Bob`.\n *\n * The `Token` contract can then try to \"spend\" the approval by calling `consume` on the registry. If the message\n * was approved, the value is updated to `false`, and we return the success flag. For more information on the\n * registry, see `main.nr` in `auth_registry_contract`.\n *\n * Person          Contract              Contract            Contract               Contract\n * Alice          Alice Account          Registry             Token                   DeFi\n *   |                  |                    |                   |                      |\n *   | Registry.set_authorized(..., true)    |                   |                      |\n *   |----------------->|                    |                   |                      |\n *   |                  | set_authorized(..., true)              |                      |\n *   |                  |------------------->|                   |                      |\n *   |                  |                    |                   |                      |\n *   |                  |         set authorized to true         |                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   |                      |\n *   | Defi.deposit(Token, 1000)             |                   |                      |\n *   |----------------->|                    |                   |                      |\n *   |                  | deposit(Token, 1000)                   |                      |\n *   |                  |-------------------------------------------------------------->|\n *   |                  |                    |                   |                      |\n *   |                  |                    |              transfer(Alice, Defi, 1000) |\n *   |                  |                    |                   |<---------------------|\n *   |                  |                    |                   |                      |\n *   |                  |                    | Check if Defi may call transfer(Alice, Defi, 1000)\n *   |                  |                    |<------------------|                      |\n *   |                  |                    |                   |                      |\n *   |                  |          throw if invalid AuthWit      |                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   |                      |\n *   |                  |           set authorized to false      |                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    | AuthWit validity  |                      |\n *   |                  |                    |------------------>|                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   | transfer(Alice, Defi, 1000)\n *   |                  |                    |                   |<-------------------->|\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   | success              |\n *   |                  |                    |                   |--------------------->|\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   |     deposit(Token, 1000)\n *   |                  |                    |                   |                      |\n *\n *\n * --- FAQ ---\n * Q:   Why are we using a success flag of `poseidon2_hash_bytes(\"IS_VALID()\")` instead of just returning a boolean?\n * A:   We want to make sure that we don't accidentally return `true` if there is a collision in the function selector.\n *      By returning a hash of `IS_VALID()`, it becomes very unlikely that there is both a collision and we return\n *      a success flag.\n *\n * Q:   Why are we using static calls?\n * A:   We are using static calls to ensure that the account contract cannot re-enter. If it was a normal call, it\n *      could make a new call and do a re-entry attack. Using a static ensures that it cannot update any state.\n *\n * Q:   Would it not be cheaper to use a nullifier instead of updating state in public?\n * A:   At a quick glance, a public state update + nullifier is 96 bytes, but two state updates are 128, so it would be\n *      cheaper to use a nullifier, if this is the way it would always be done. However, if both the approval and the\n *      consumption is done in the same transaction, then we will be able to squash the updates (only final tx state diff is posted to DA), and now it is cheaper.\n *\n * Q:   Why is the chain id and the version part of the message hash?\n * A:   The chain id and the version is part of the message hash to ensure that the message is only valid on a specific\n *      chain to avoid a case where the same message could be used across multiple chains.\n */\n\nglobal IS_VALID_SELECTOR: Field = 0x47dacd73; // 4 last bytes of poseidon2_hash_bytes(\"IS_VALID()\")\n\n/**\n * Assert that `on_behalf_of` has authorized the current call with a valid authentication witness\n *\n * Compute the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then make a call out to the\n * `on_behalf_of` contract to verify that the `inner_hash` is valid.\n *\n * @param on_behalf_of The address that has allegedly authorized the current call\n */\n// docs:start:assert_current_call_valid_authwit\npub fn assert_current_call_valid_authwit(context: &mut PrivateContext, on_behalf_of: AztecAddress) {\n    let inner_hash = compute_inner_authwit_hash([\n        context.msg_sender().to_field(),\n        context.selector().to_field(),\n        context.args_hash,\n    ]);\n    assert_inner_hash_valid_authwit(context, on_behalf_of, inner_hash);\n}\n// docs:end:assert_current_call_valid_authwit\n\n/**\n * Assert that a specific `inner_hash` is valid for the `on_behalf_of` address\n *\n * Used as an internal function for `assert_current_call_valid_authwit` and can be used as a standalone function when\n * the `inner_hash` is from a different source, e.g., say a block of text etc.\n *\n * @param on_behalf_of The address that has allegedly authorized the current call\n * @param inner_hash The hash of the message to authorize\n */\npub fn assert_inner_hash_valid_authwit(\n    context: &mut PrivateContext,\n    on_behalf_of: AztecAddress,\n    inner_hash: Field,\n) {\n    // We perform a static call here and not a standard one to ensure that the account contract cannot re-enter.\n    let result: Field = context\n        .static_call_private_function(\n            on_behalf_of,\n            comptime { FunctionSelector::from_signature(\"verify_private_authwit(Field)\") },\n            [inner_hash],\n        )\n        .get_preimage();\n    assert(result == IS_VALID_SELECTOR, \"Message not authorized by account\");\n    // Compute the nullifier, similar computation to the outer hash, but without the chain_id and version.\n    // Those should already be handled in the verification, so we just need something to nullify, that allows the same inner_hash for multiple actors.\n    let nullifier = compute_authwit_nullifier(on_behalf_of, inner_hash);\n    context.push_nullifier(nullifier);\n}\n\n/**\n * Assert that `on_behalf_of` has authorized the current call in the authentication registry\n *\n * Compute the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then make a call out to the\n * `on_behalf_of` contract to verify that the `inner_hash` is valid.\n *\n * Note that the authentication registry will take the `msg_sender` into account as the consumer, so this will only\n * work if the `msg_sender` is the same as the `consumer` when the `message_hash` was inserted into the registry.\n *\n * @param on_behalf_of The address that has allegedly authorized the current call\n */\n// docs:start:assert_current_call_valid_authwit_public\npub unconstrained fn assert_current_call_valid_authwit_public(\n    context: &mut PublicContext,\n    on_behalf_of: AztecAddress,\n) {\n    let inner_hash = compute_inner_authwit_hash([\n        (*context).msg_sender().to_field(),\n        (*context).selector().to_field(),\n        (*context).get_args_hash(),\n    ]);\n    assert_inner_hash_valid_authwit_public(context, on_behalf_of, inner_hash);\n}\n// docs:end:assert_current_call_valid_authwit_public\n\n/**\n * Assert that `on_behalf_of` has authorized a specific `inner_hash` in the authentication registry\n *\n * Compute the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then make a call out to the\n * `on_behalf_of` contract to verify that the `inner_hash` is valid.\n *\n * Note that the authentication registry will take the `msg_sender` into account as the consumer, so this will only\n * work if the `msg_sender` is the same as the `consumer` when the `message_hash` was inserted into the registry.\n *\n * @param on_behalf_of The address that has allegedly authorized the `inner_hash`\n */\npub unconstrained fn assert_inner_hash_valid_authwit_public(\n    context: &mut PublicContext,\n    on_behalf_of: AztecAddress,\n    inner_hash: Field,\n) {\n    let results: [Field] = context.call_public_function(\n        CANONICAL_AUTH_REGISTRY_ADDRESS,\n        comptime { FunctionSelector::from_signature(\"consume((Field),Field)\") },\n        [on_behalf_of.to_field(), inner_hash].as_slice(),\n        GasOpts::default(),\n    );\n    assert(results.len() == 1, \"Invalid response from registry\");\n    assert(results[0] == IS_VALID_SELECTOR, \"Message not authorized by account\");\n}\n\n/**\n * Compute the `message_hash` from a function call to be used by an authentication witness\n *\n * Useful for when you need a non-account contract to approve during execution. For example if you need a contract\n * to make a call to nested contract, e.g., contract A wants to exit token T to L1 using bridge B, so it needs to allow\n * B to transfer T on its behalf.\n *\n * @param caller The address of the contract that is calling the function, in the example above, this would be B\n * @param consumer The address of the contract that is consuming the message, in the example above, this would be T\n * @param chain_id The chain id of the chain that the message is being consumed on\n * @param version The version of the chain that the message is being consumed on\n * @param selector The function selector of the function that is being called\n * @param args The arguments of the function that is being called\n */\n// docs:start:compute_authwit_message_hash_from_call\npub fn compute_authwit_message_hash_from_call<let N: u32>(\n    caller: AztecAddress,\n    consumer: AztecAddress,\n    chain_id: Field,\n    version: Field,\n    selector: FunctionSelector,\n    args: [Field; N],\n) -> Field {\n    let args_hash = hash_args_array(args);\n    let inner_hash =\n        compute_inner_authwit_hash([caller.to_field(), selector.to_field(), args_hash]);\n    compute_authwit_message_hash(consumer, chain_id, version, inner_hash)\n}\n// docs:end:compute_authwit_message_hash_from_call\n\n/**\n * Computes the `inner_hash` of the authentication witness\n *\n * This is used internally, but also useful in cases where you want to compute the `inner_hash` for a specific message\n * that is not necessarily a call, but just some \"bytes\" or text.\n *\n * @param args The arguments to hash\n */\npub fn compute_inner_authwit_hash<let N: u32>(args: [Field; N]) -> Field {\n    poseidon2_hash_with_separator(args, GENERATOR_INDEX__AUTHWIT_INNER)\n}\n\n/**\n * Computes the `authwit_nullifier` for a specific `on_behalf_of` and `inner_hash`\n *\n * Using the `on_behalf_of` and the `inner_hash` to ensure that the nullifier is siloed for a specific `on_behalf_of`.\n *\n * @param on_behalf_of The address that has authorized the `inner_hash`\n * @param inner_hash The hash of the message to authorize\n */\npub fn compute_authwit_nullifier(on_behalf_of: AztecAddress, inner_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [on_behalf_of.to_field(), inner_hash],\n        GENERATOR_INDEX__AUTHWIT_NULLIFIER,\n    )\n}\n\n/**\n * Computes the `message_hash` for the authentication witness\n *\n * @param consumer The address of the contract that is consuming the message\n * @param chain_id The chain id of the chain that the message is being consumed on\n * @param version The version of the chain that the message is being consumed on\n * @param inner_hash The hash of the \"inner\" message that is being consumed\n */\npub fn compute_authwit_message_hash(\n    consumer: AztecAddress,\n    chain_id: Field,\n    version: Field,\n    inner_hash: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [consumer.to_field(), chain_id, version, inner_hash],\n        GENERATOR_INDEX__AUTHWIT_OUTER,\n    )\n}\n\n/**\n * Helper function to set the authorization status of a message hash\n *\n * Wraps a public call to the authentication registry to set the authorization status of a `message_hash`\n *\n * @param message_hash The hash of the message to authorize\n * @param authorize True if the message should be authorized, false if it should be revoked\n */\npub unconstrained fn set_authorized(\n    context: &mut PublicContext,\n    message_hash: Field,\n    authorize: bool,\n) {\n    let res = context.call_public_function(\n        CANONICAL_AUTH_REGISTRY_ADDRESS,\n        comptime { FunctionSelector::from_signature(\"set_authorized(Field,bool)\") },\n        [message_hash, authorize as Field].as_slice(),\n        GasOpts::default(),\n    );\n    assert(res.len() == 0);\n}\n\n/**\n * Helper function to reject all authwits\n *\n * Wraps a public call to the authentication registry to set the `reject_all` flag\n *\n * @param reject True if all authwits should be rejected, false otherwise\n */\npub unconstrained fn set_reject_all(context: &mut PublicContext, reject: bool) {\n    let res = context.call_public_function(\n        CANONICAL_AUTH_REGISTRY_ADDRESS,\n        comptime { FunctionSelector::from_signature(\"set_reject_all(bool)\") },\n        [context.this_address().to_field(), reject as Field].as_slice(),\n        GasOpts::default(),\n    );\n    assert(res.len() == 0);\n}\n"
     },
     "66": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/authwit/src/auth_witness.nr",
@@ -3931,7 +3931,7 @@
     },
     "81": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/private_context.nr",
-      "source": "use dep::protocol_types::debug_log::debug_log_format;\n\nuse crate::{\n    context::{inputs::PrivateContextInputs, returns_hash::ReturnsHash},\n    hash::{ArgsHasher, hash_args_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        block_header::get_block_header_at,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            enqueue_public_function_call_internal, notify_set_min_revertible_side_effect_counter,\n            set_public_teardown_function_call_internal,\n        },\n        execution_cache,\n        key_validation_request::get_key_validation_request,\n        notes::{notify_created_nullifier, notify_nullified_note},\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        gas_settings::GasSettings,\n        log::Log,\n        log_hash::LogHash,\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::PrivateLogData,\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    block_header::BlockHeader,\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_DISPATCH_SELECTOR,\n    },\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::Empty,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: BlockHeader,\n\n    pub private_logs: BoundedVec<PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<LogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn gas_settings(self) -> GasSettings {\n        self.inputs.tx_context.gas_settings\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n\n        // WARNING(https://github.com/AztecProtocol/aztec-packages/issues/10558): if you delete this debug_log_format line, some tests fail.\n        debug_log_format(\n            \"Context.note_hashes, after pushing new note hash: {0}\",\n            self.note_hashes.storage().map(|nh: NoteHash| nh.value),\n        );\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        notify_created_nullifier(nullifier);\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        let nullifier_counter = self.next_counter();\n        notify_nullified_note(nullifier, nullified_note_hash, nullifier_counter);\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: nullifier_counter,\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_block_header(self) -> BlockHeader {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_block_header_at(self, block_number: u32) -> BlockHeader {\n        get_block_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        execution_cache::store(returns_hasher.fields);\n        self.return_hash = returns_hasher.hash();\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: self.private_logs.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request =\n            self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n\n            // Safety: Kernels verify that the key validation request is valid and below we verify that a request\n            // for the correct public key has been received.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert_eq(request.pk_m.hash(), pk_m_hash, \"Obtained invalid key validation request\");\n\n            self.key_validation_requests_and_generators.push(\n                KeyValidationRequestAndGenerator {\n                    request,\n                    sk_app_generator: sk_generators[key_index],\n                },\n            );\n            self.last_key_validation_requests[key_index] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n        self.l2_to_l1_msgs.push(message);\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn emit_raw_note_log(\n        &mut self,\n        log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n        note_hash_counter: u32,\n    ) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> ReturnsHash {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        // Safety: The oracle simulates the private call and returns the value of the side effects counter after\n        // execution of the call (which means that end_side_effect_counter - start_side_effect_counter is\n        // the number of side effects that took place), along with the hash of the return values. We validate these\n        // by requesting a private kernel iteration in which the return values are constrained to hash\n        // to `returns_hash` and the side effects counter to increment from start to end.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        // TODO (fees) figure out why this crashes the prover and enable it\n        // we need this in order to pay fees inside child call contexts\n        // assert(\n        //     (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n        //     | (item.public_inputs.min_revertible_side_effect_counter\n        //         > self.min_revertible_side_effect_counter)\n        // );\n        // if item.public_inputs.min_revertible_side_effect_counter\n        //     > self.min_revertible_side_effect_counter {\n        //     self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n        // }\n        self.side_effect_counter = end_side_effect_counter + 1;\n        ReturnsHash::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_public_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_public_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_args_hash(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_public_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // Safety: TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle hashes the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = unsafe {\n            enqueue_public_function_call_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                counter,\n                is_static_call,\n            )\n        };\n\n        // Public calls are rerouted through the dispatch function.\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.set_public_teardown_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn set_public_teardown_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // Safety: TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle hashes the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = unsafe {\n            set_public_teardown_function_call_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                counter,\n                is_static_call,\n            )\n        };\n\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: BlockHeader::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
+      "source": "use dep::protocol_types::debug_log::debug_log_format;\n\nuse crate::{\n    context::{inputs::PrivateContextInputs, returns_hash::ReturnsHash},\n    hash::{ArgsHasher, hash_args_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        block_header::get_block_header_at,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            enqueue_public_function_call_internal, notify_set_min_revertible_side_effect_counter,\n            set_public_teardown_function_call_internal,\n        },\n        execution_cache,\n        key_validation_request::get_key_validation_request,\n        notes::{notify_created_nullifier, notify_nullified_note},\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        gas_settings::GasSettings,\n        log::Log,\n        log_hash::LogHash,\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::PrivateLogData,\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    block_header::BlockHeader,\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_DISPATCH_SELECTOR,\n    },\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::{Empty, FromField, Hash, ToField},\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: BlockHeader,\n\n    pub private_logs: BoundedVec<PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<LogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn gas_settings(self) -> GasSettings {\n        self.inputs.tx_context.gas_settings\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n\n        // WARNING(https://github.com/AztecProtocol/aztec-packages/issues/10558): if you delete this debug_log_format line, some tests fail.\n        debug_log_format(\n            \"Context.note_hashes, after pushing new note hash: {0}\",\n            self.note_hashes.storage().map(|nh: NoteHash| nh.value),\n        );\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        notify_created_nullifier(nullifier);\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        let nullifier_counter = self.next_counter();\n        notify_nullified_note(nullifier, nullified_note_hash, nullifier_counter);\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: nullifier_counter,\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_block_header(self) -> BlockHeader {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_block_header_at(self, block_number: u32) -> BlockHeader {\n        get_block_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        execution_cache::store(returns_hasher.fields);\n        self.return_hash = returns_hasher.hash();\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: self.private_logs.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request =\n            self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n\n            // Safety: Kernels verify that the key validation request is valid and below we verify that a request\n            // for the correct public key has been received.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert_eq(request.pk_m.hash(), pk_m_hash, \"Obtained invalid key validation request\");\n\n            self.key_validation_requests_and_generators.push(\n                KeyValidationRequestAndGenerator {\n                    request,\n                    sk_app_generator: sk_generators[key_index],\n                },\n            );\n            self.last_key_validation_requests[key_index] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n        self.l2_to_l1_msgs.push(message);\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn emit_raw_note_log(\n        &mut self,\n        log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n        note_hash_counter: u32,\n    ) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> ReturnsHash {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        // Safety: The oracle simulates the private call and returns the value of the side effects counter after\n        // execution of the call (which means that end_side_effect_counter - start_side_effect_counter is\n        // the number of side effects that took place), along with the hash of the return values. We validate these\n        // by requesting a private kernel iteration in which the return values are constrained to hash\n        // to `returns_hash` and the side effects counter to increment from start to end.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        // TODO (fees) figure out why this crashes the prover and enable it\n        // we need this in order to pay fees inside child call contexts\n        // assert(\n        //     (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n        //     | (item.public_inputs.min_revertible_side_effect_counter\n        //         > self.min_revertible_side_effect_counter)\n        // );\n        // if item.public_inputs.min_revertible_side_effect_counter\n        //     > self.min_revertible_side_effect_counter {\n        //     self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n        // }\n        self.side_effect_counter = end_side_effect_counter + 1;\n        ReturnsHash::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_public_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_public_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_args_hash(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_public_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // Safety: TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle hashes the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = unsafe {\n            enqueue_public_function_call_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                counter,\n                is_static_call,\n            )\n        };\n\n        // Public calls are rerouted through the dispatch function.\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.set_public_teardown_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn set_public_teardown_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // Safety: TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle hashes the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = unsafe {\n            set_public_teardown_function_call_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                counter,\n                is_static_call,\n            )\n        };\n\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: BlockHeader::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
     }
   }
 }