@aztec/protocol-contracts 0.65.2 → 0.66.0

package/artifacts/FeeJuice.json

@@ -1,8 +1,164 @@
 {
   "transpiled": true,
-  "noir_version": "1.0.0-beta.0+d9e6d430f90682f49805eba18941129678cf1930-x8664",
+  "noir_version": "1.0.0-beta.0+a46035ba69b0a659897fe25271c346e005925a6c-x8664",
   "name": "FeeJuice",
   "functions": [
+    {
+      "name": "balance_of_public",
+      "is_unconstrained": true,
+      "custom_attributes": [
+        "public",
+        "view"
+      ],
+      "abi": {
+        "error_types": {
+          "16761564377371454734": {
+            "error_kind": "string",
+            "string": "Array index out of bounds"
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          },
+          "206160798890201757": {
+            "error_kind": "string",
+            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
+          },
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
+          },
+          "6067862452620309358": {
+            "error_kind": "string",
+            "string": "Function balance_of_public can only be called statically"
+          },
+          "6485997221020871071": {
+            "error_kind": "string",
+            "string": "call to assert_max_bit_size"
+          }
+        },
+        "parameters": [
+          {
+            "name": "owner",
+            "type": {
+              "fields": [
+                {
+                  "name": "inner",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": {
+          "abi_type": {
+            "kind": "field"
+          },
+          "visibility": "public"
+        }
+      },
+      "bytecode": "JgACBAEnAAABBIBFJgAABAMmAgIEASYCAwQAHxgAAwACgEMtCIBDAAEkAAAARi0EAAGARCcCAAIEgEQmAgMEAToNAAIAAyQAAAQsLAgBAwAAAQIBJgIEAQAsDgQDLAgBAwAAAQIBJgIFAAAsDgUDLAgBAwAAAQIBJgIGAAIsDgYDHgIAAwkmAgYAAQo4AwYHIwIABwAAAJ0kAAAEVSwIAQMmAgcEAwAQAQcBJgMDBAEAKAMCBywMBwgsDgYIACgIAggsDgEILAgBASYCBgQEABABBgEmAwEEAQAoAQIGLAwGBywOBQcAKAcCBywOBQcAKAcCBywOBQcsDQEGACgGAgYsDgYBKgIABgAAAAAAAAAAAgAAAAAAAAAALAgBByYCCAQFABABCAEmAwcEAQAoBwIILAwICSwOBQkAKAkCCSwOBQkAKAkCCSwOBQkAKAkCCSwOBgksDQEGACgGAgYsDgYBLAgBBgAAAQIBLA4BBiwNBwEAKAECASwOAQcsCAEBAAABAgEsDgcBLAgBBwAAAQIBJgIIBAAsDggHLAgBCQAAAQIBLA4ECSYCCgQBJgILBAImAgwEAywMCAIiAAABwAw4AgsNIwIADQAAAsMiAAAB0iwNCQIKOAIEAyMCAAMAAAHsJgIKBAA7CQEKJgICBAosCAAKLAwGCywMAQwsDAcNLAwJDgAQAAIAJAAABGcsBAAALA0GAiwNAQMsDQcKLA4CBiwOAwEsDgoHJgIBAQEsDgEJACgDAgIAOAIIBiwNBgEKOAEFAgo4AgQDIwIAAwAAAlkkAAAF2C4MAAEAAhwMAgEAKgIAAwD/////////////////////DjgBAwQjAgAEAAACiyQAAAXqHAwCAwUcDAMBAAI4AgEDKgIAAgAAAAAAAAAAAQAAAAAAAAAACDgDAgQEOAQCAwA4AQMCLAwCASUjAgANAAAC0CIAAAQMJgIOBAIMOAIODyMCAA8AAALnJAAABfwAKAMCDgA4DgIPLA0PDSwNBw4sDQkPCjgPBBAjAgAQAAADEyYCEQQAOwkBEQo4DgwPIwIADwAAA54iAAADJSwNBg4sDQEPLA0HECwNCREmAhMEAww4EBMUIwIAFAAAA0wkAAAF/C0EAA6AAycAgAQEAAQkAAAGDi0IgAUAEgAoEgITADgTEBQsDg0UADgQCg0OOBANDiMCAA4AAAOJJAAABpwsDhIGLA4PASwODQcsDhEJIgAABAwmAg4EDywIAA8sDAYQLAwBESwMBxIsDAkTABAADgAkAAAEZywEAAAsDQYOLA0BDywNCRAtBAAOgAMnAIAEBAAEJAAABg4tCIAFABEAKBECEgA4EggTLA4NEywOEQYsDg8BLA4KBywOEAkiAAAEDAA4AgoNDjgCDQ4jAgAOAAAEIyQAAAacLAwNAiIAAAHAJwCABAR4AA0AAACABIADIwCAAwAABFQpAQABBfeh86+lrdTKOwEBAiUpAQABBVQ1YMByXTNuOwEBAiUkAAAELCYCBgQAJgIHBAEmAggEAywMBgUiAAAEhAw4BQgGIwIABgAABPEiAAAEliwNAQUsDQIGLA0DBywNBAgmAgkEBCwIAQomAgsEBQAQAQsBJgMKBAEAKAYCCyYCDAQEACgKAg0+DwALAA0sDQoGACgGAgYsDgYKLA4FASwOCgIsDgcDLA4IBCUsDQMGDDgFBgkjAgAJAAAFByIAAAW4LA0BBiwNAgksDQMKLA0ECyYCDQQEDDgFDQ4jAgAOAAAFLiQAAAX8ACgJAg0AOA0FDiwNDgwmAg4EAww4BQ4PIwIADwAABVMkAAAF/AAoBgIOADgOBQ8sDQ8NADgMDQ4mAg0EBAw4BQ0PIwIADwAABX0kAAAF/C0EAAmAAycAgAQEAAUkAAAGDi0IgAUADAAoDAINADgNBQ8sDg4PLA4GASwODAIsDgoDLA4LBCIAAAW4ADgFBwYOOAUGCSMCAAkAAAXPJAAABpwsDAYFIgAABIQpAQABBQLcbieAdhKdOwEBAiUpAQABBVoC5Bu1HqmfOwEBAiUpAQABBeidCf6hES0OOwEBAiUtAYADgAYLAIAGAAKAByMAgAcAAAYpIgAABjQtAIADgAUiAAAGmy0AAAGABQEAAAGABAABAQCAA4AEgAktAIADgAotAIAFgAsLAIAKgAmADCMAgAwAAAaHLQGACoAILQKACIALAQCACgACgAoBAIALAAKACyIAAAZWJwGABQQAAQMAgAYAAoAGIgAABpslKQEAAQVFp8pxGUHkFTsBAQIlLQAYyhjK",
+      "debug_symbols": "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",
+      "brillig_names": [
+        "balance_of_public"
+      ]
+    },
+    {
+      "name": "public_dispatch",
+      "is_unconstrained": true,
+      "custom_attributes": [
+        "public"
+      ],
+      "abi": {
+        "error_types": {
+          "10502589790419500451": {
+            "error_kind": "string",
+            "string": "Function _increase_public_balance can only be called internally"
+          },
+          "15238796416211288225": {
+            "error_kind": "string",
+            "string": "Balance too low"
+          },
+          "16541607464495309456": {
+            "error_kind": "fmtstring",
+            "item_types": [],
+            "length": 16
+          },
+          "16761564377371454734": {
+            "error_kind": "string",
+            "string": "Array index out of bounds"
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          },
+          "206160798890201757": {
+            "error_kind": "string",
+            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
+          },
+          "2236649814169388962": {
+            "error_kind": "string",
+            "string": "PublicImmutable already initialized"
+          },
+          "3219842053230618354": {
+            "error_kind": "string",
+            "string": "Function check_balance can only be called statically"
+          },
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
+          },
+          "6067862452620309358": {
+            "error_kind": "string",
+            "string": "Function balance_of_public can only be called statically"
+          },
+          "6485997221020871071": {
+            "error_kind": "string",
+            "string": "call to assert_max_bit_size"
+          }
+        },
+        "parameters": [
+          {
+            "name": "selector",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": null
+      },
+      "bytecode": "JgACBAEnAAABBIBEJgAABAMmAgIEASYCAwQAHxgAAwACgEMtCIBDAAEkAAAAQCcCAAEEgEQmAgIEADoNAAEAAiQAAAqGKAIAAgDsuv9WCjgBAgMmAgQEACYCBgQDADgEBgUsCAECABABBQEmAwIEAQAoAgIFLA4EBQAoBQIFLA4EBSYCBQQDADgCBQQsDQIEACgEAgQsDgQCJgIEAAAmAgUEASYCBgQAIwIAAwAAALUiAAACHSwIAQMmAgcEAgAQAQcBJgMDBAEAKAMCBx88AAUABQAHLA0DBwAoBwIHLA4HAywNAwcAKAcCBywOBwMsDQMHACgHAgcsDgcDLAgBBwAAAQIBLA4DBywIAQMAAAECASwOBgMmAgkECiwIAAosDAcLLAwDDAAQAAkAJAAACq8sBAAALAwLCCYCAwAEJgIJBAosCAAKLAwDCywMCAwAEAAJACQAAAsqLAQAACwMCwcmAgMAAi4MAAMACBwMCAkAKwIACgAAAAAAAAAAAAAAAAD//////////////////////////w44CQoLIwIACwAAAagkAAAL8Ao4CAQJIwIACQAAAb4mAgoEADsJAQooAgAIADuaygIuDAAIAAkKOAkECiMCAAoAAAHfJAAADAInAgAJAN6tLwwACQAILwwABwADLA0CAwAoAwIDLA4DAgAoAgIILA0IByYCCQQCADgICQM6DQADAAciAAACHSgCAAMArRLwowo4AQMHJgIDAAEmAggADCoCAAkAAAAAAAAAAAEAAAAAAAAAACYCCgAsJgILAAomAgwBACMCAAcAAAJmIgAABN0mAgcEAiwIAQ0mAg4EAwAQAQ4BJgMNBAEAKA0CDh88AAUABwAOLA0NBwAoBwIHLA4HDSwNDQcAKAcCBywOBw0sDQ0HACgHAgcsDgcNLAgBBwAAAQIBLA4NBywIAQ0AAAECASwOBg0mAg8EECwIABAsDAcRLAwNEgAQAA8AJAAADBQsBAAALAwRDiYCEAQRLAgAESwMCxIsDA4TABAAEAAkAAALKiwEAAAsDBIPJgIQBBEsCAARLAwHEiwMDRMAEAAQACQAAAwULAQAACwMEg4mAg0EECwIABAsDAgRLAwOEgAQAA0AJAAACyosBAAALAwRBywIAQ0AAAECASwODA0sCAEOAAABAgEsDgQOLAgBEAAAAQIBJgIRAD4sDhEQHgIAEQEeAgASAAo4ERITIwIAEwAAA6AkAAAMjyYCFQQWLAgAFiwMDRcsDA4YLAwQGSwMAxosDAobLAwPHAAQABUAJAAADKEsBAAALAwXESwMGBIsDBkTLAwaFCYCFwQYLAgAGCwMERksDBIaLAwTGywMFBwAEAAXACQAAA/aLAQAACwMGRUsDBoWJgITBBcsCAAXLAwHGAAQABMAJAAAEBEsBAAALAwYESwMGRIAOBURBxwMBxMFHAwTEQACOAcREwg4EwkHADgWEhMAOBMHEhwMEhMFHAwTBwAKOAcSEyMCABMAAARwJAAAEHQmAhYEFywIABcsDA0YLAwOGSwMEBosDAMbLAwKHCwMDx0AEAAWACQAAAyhLAQAACwMGBIsDBkTLAwaFCwMGxUEOAcJDQA4EQ0HLwwABwAVACgCAg4sDQ4NJgIPBAIAOA4PBzoNAAcADSIAAATdKAIABwAILNgwCjgBBw0jAgANAAAE+CIAAAdTLAgBDSYCDgQCABABDgEmAw0EAQAoDQIOHzwABQAFAA4sDQ0OACgOAg4sDg4NLA0NDgAoDgIOLA4ODSwNDQ4AKA4CDiwODg0sCAEOAAABAgEsDg0OLAgBDQAAAQIBLA4GDSYCEAQRLAgAESwMDhIsDA0TABAAEAAkAAAKrywEAAAsDBIPJgIOBBAsCAAQLAwIESwMDxIAEAAOACQAAAsqLAQAACwMEQ0sCAEIAAABAgEsDgwILAgBDgAAAQIBLA4EDiwIAQ8AAAECASYCEAA1LA4QDx4CABAJCjgQAxEjAgARAAAF4iQAABCGJgISBBMsCAATLAwNFAAQABIAJAAAEBEsBAAALAwUECwMFREeAgANASYCFgQXLAgAFywMCBgsDA4ZLAwPGiwMAxssDAocLAwNHQAQABYAJAAADKEsBAAALAwYEiwMGRMsDBoULAwbFSYCDgQWLAgAFiwMEhcsDBMYLAwUGSwMFRoAEAAOACQAAA/aLAQAACwMFwgsDBgNHAwNDwUcDA8OABwMDg0FHAwRDwUcDA8OABwMDg8FJgIRBBIsCAASLAwNEywMDxQAEAARACQAABCYLAQAACwMEw4cDAgPBRwMDw0AHAwNCAUcDBAPBRwMDw0AHAwNDwUmAhAEESwIABEsDAgSLAwPEwAQABAAJAAAEJgsBAAALAwSDQo4DgMIIwIACAAABxUiAAAHDCwMDgciAAAHHiwMDQciAAAHHgo4BwQICjgIDAcjAgAHAAAHNSQAABD5ACgCAg0sDQ0IJgIOBAIAOA0OBzoNAAcACCIAAAdTKAIAAgD/eUnyCjgBAgcjAgAHAAAHbiIAAAkvLAgBASYCAgQCABABAgEmAwEEAQAoAQICHzwABQAFAAIsDQECACgCAgIsDgIBLA0BAgAoAgICLA4CASwNAQIAKAICAiwOAgEsCAECAAABAgEsDgECLAgBAQAAAQIBLA4GASYCCAQNLAgADSwMAg4sDAEPABAACAAkAAAKrywEAAAsDA4HJgICBA0sCAANLAwLDiwMBw8AEAACACQAAAsqLAQAACwMDgEsCAECAAABAgEsDgwCLAgBBwAAAQIBLA4EBywIAQQAAAECASYCCAAVLA4IBB4CAAgJCjgIAwsjAgALAAAIWCQAABELJgIPBBAsCAAQLAwCESwMBxIsDAQTLAwDFCwMChUsDAEWABAADwAkAAAMoSwEAAAsDBEILAwSCywMEw0sDBQOJgIDBA8sCAAPLAwIECwMCxEsDA0SLAwOEwAQAAMAJAAAD9osBAAALAwQASwMEQIEOAIJAwA4AQMCJgIDBAEmAgcEAwA4AwcELAgBAQAQAQQBJgMBBAEAKAECBCwOAwQAKAQCBCwOAwQmAgQEAwA4AQQDLAwDBCwOAgQAKAECBCwNBAMmAgcEAgA4BAcCOg0AAgADIgAACS8mAgECICYCAgJrJgIDAmwmAgQCcyYCBQJvJgIHAlUmAggCYyYCCQJ0JgIKAmUmAgsCdyYCDQJuJgIOAnIsCAEPJgIQBBEAEAEQASYDDwQBACgPAhAsDBARLA4HEQAoEQIRLA4NEQAoEQIRLA4CEQAoEQIRLA4NEQAoEQIRLA4FEQAoEQIRLA4LEQAoEQIRLA4NEQAoEQIRLA4BEQAoEQIRLA4EEQAoEQIRLA4KEQAoEQIRLA4DEQAoEQIRLA4KEQAoEQIRLA4IEQAoEQIRLA4JEQAoEQIRLA4FEQAoEQIRLA4OESYCAQEBCjgMAQIjAgACAAAKhSYCAwQSLAgBBCYCBQQSABABBQEsDAQFKQMABQXlj5hZBzFikAAoBQIFACgPAgcmAggEEC0EAAeAAy0EAAWABC0EAAiABSQAABEdJgIHBBAAOAUHBSwOBgUAKAUCBTsNBAMlJwCABAR4AA0AAACABIADIwCAAwAACq4pAQABBfeh86+lrdTKOwEBAiUkAAAKhiwNAQMsDQIEJgIGBAEMOAQGByMCAAcAAArTJAAAEWMAKAMCBgA4BgQHLA0HBSwIAQYmAgcEAgAQAQcBJgMGBAEAKAYCBywMBwgsDgUIJgIFBAEAOAQFBw44BAcIIwIACAAACx0kAAAQdCwOAwEsDgcCLAwGASUkAAAKhiYCBAAECjgBBAUmAgQEAAAoAgIHADgHBAgsDQgGIwIABQAAC6YiAAALWSYCBAAKCjgBBAUjAgAFAAALlCIAAAtwJgIEAAwKOAEEBSMCAAUAAAuLJgIHBAA7CQEHLAwGAiIAAAudLAwGAiIAAAudLAwCAyIAAAvrHAwGAQArAgACAAAAAAAAAAAAAAAAAP//////////////////////////DjgBAgQjAgAEAAAL4iQAAAvwLAwGAyIAAAvrLAwDASUpAQABBVoC5Bu1HqmfOwEBAiUpAQABBR8KLSfcgoeiOwEBAiUkAAAKhiwNAQMsDQIEJgIGBAIMOAQGByMCAAcAAAw4JAAAEWMAKAMCBgA4BgQHLA0HBSwIAQYmAgcEAgAQAQcBJgMGBAEAKAYCBywMBwgsDgUIJgIFBAEAOAQFBw44BAcIIwIACAAADIIkAAAQdCwOAwEsDgcCLAwGASUpAQABBZHAscTvmT2jOwEBAiUkAAAKhiwIAQgmAgkEAwAQAQkBJgMIBAEAKAgCCSwMCQosDgQKACgKAgosDgYKJgIEAAAsCAEGJgIJBAQAEAEJASYDBgQBACgGAgksDAkKLA4ECgAoCgIKLA4ECgAoCgIKLA4ECiwNBgkAKAkCCSwOCQYqAgAJAAAAAAAAAAACAAAAAAAAAAAsCAEKJgILBAUAEAELASYDCgQBACgKAgssDAsMLA4EDAAoDAIMLA4EDAAoDAIMLA4EDAAoDAIMLA4JDCwNBgkAKAkCCSwOCQYsCAEJAAABAgEsDgYJLA0KBgAoBgIGLA4GCiwIAQYAAAECASwOCgYsCAEKAAABAgEmAgsEACwOCwosCAEMAAABAgEmAg0BACwODQwmAg4EAiYCDwQBJgIQBAMsDAsHIgAADdMMOAcOBSMCAAUAAA5xIgAADeUsDQwFCjgFDQcjAgAHAAAN/yYCCAQAOwkBCCYCBQQOLAgADiwMCQ8sDAYQLAwKESwMDBIAEAAFACQAABF1LAQAACwNCQUsDQYHLA0KCCwOBQksDgcGLA4ICiYCBQEBLA4FDAAoBwIGADgGCwgsDQgFCjgFBAYKOAYNBCMCAAQAAA5sJAAAEuYsDAUEJSMCAAUAAA5+IgAAD7omAhEEAgw4BxESIwIAEgAADpUkAAARYwAoCAIRADgRBxIsDRIFLA0KESwNDBIKOBINEyMCABMAAA7BJgIUBAA7CQEUCjgREBIjAgASAAAPTCIAAA7TLA0JESwNBhIsDQoTLA0MFCYCFgQDDDgTFhcjAgAXAAAO+iQAABFjLQQAEYADJwCABAQABCQAABL4LQiABQAVACgVAhYAOBYTFywOBRcAOBMPBQ44EwURIwIAEQAADzckAAAQdCwOFQksDhIGLA4FCiwOFAwiAAAPuiYCEQQSLAgAEiwMCRMsDAYULAwKFSwMDBYAEAARACQAABF1LAQAACwNCREsDQYSLA0MEy0EABGAAycAgAQEAAQkAAAS+C0IgAUAFAAoFAIVADgVCxYsDgUWLA4UCSwOEgYsDg8KLA4TDCIAAA+6ADgHDwUOOAcFESMCABEAAA/RJAAAEHQsDAUHIgAADdMkAAAKhi4MAAQABSYCBwQILAgACCwMBQkAEAAHACQAABARLAQAACwMCQQsDAoGLAwGAiwMBAElJAAACoYcDAECACoCAAMA/////////////////////w44AgMEIwIABAAAEEIkAAAL8BwMAQMFHAwDAgACOAECAyoCAAEAAAAAAAAAAAEAAAAAAAAAAAg4AwEELAwCASwMBAIlKQEAAQVFp8pxGUHkFTsBAQIlKQEAAQUsry1Jt6zm8jsBAQIlJAAACoYMOAECBCMCAAQAABDmIgAAEK8MOAIBBSMCAAUAABDPIgAAEMEmAgEAASwMAQQiAAAQ3SYCAQACLAwBBCIAABDdLAwEAyIAABD0JgIBAAAsDAEDIgAAEPQsDAMBJSkBAAEF03sUmhjFAKE7AQECJSkBAAEFVDVgwHJdM247AQECJQEAgAOABYAHLQCAA4AILQCABIAJCwCACIAHgAojAIAKAAARYi0BgAiABi0CgAaACQEAgAgAAoAIAQCACQACgAkiAAARMSUpAQABBeidCf6hES0OOwEBAiUkAAAKhiYCBgQAJgIHBAEmAggEAywMBgUiAAARkgw4BQgGIwIABgAAEf8iAAARpCwNAQUsDQIGLA0DBywNBAgmAgkEBCwIAQomAgsEBQAQAQsBJgMKBAEAKAYCCyYCDAQEACgKAg0+DwALAA0sDQoGACgGAgYsDgYKLA4FASwOCgIsDgcDLA4IBCUsDQMGDDgFBgkjAgAJAAASFSIAABLGLA0BBiwNAgksDQMKLA0ECyYCDQQEDDgFDQ4jAgAOAAASPCQAABFjACgJAg0AOA0FDiwNDgwmAg4EAww4BQ4PIwIADwAAEmEkAAARYwAoBgIOADgOBQ8sDQ8NADgMDQ4mAg0EBAw4BQ0PIwIADwAAEoskAAARYy0EAAmAAycAgAQEAAUkAAAS+C0IgAUADAAoDAINADgNBQ8sDg4PLA4GASwODAIsDgoDLA4LBCIAABLGADgFBwYOOAUGCSMCAAkAABLdJAAAEHQsDAYFIgAAEZIpAQABBQLcbieAdhKdOwEBAiUtAYADgAYLAIAGAAKAByMAgAcAABMTIgAAEx4tAIADgAUiAAAThS0AAAGABQEAAAGABAABAQCAA4AEgAktAIADgAotAIAFgAsLAIAKgAmADCMAgAwAABNxLQGACoAILQKACIALAQCACgACgAoBAIALAAKACyIAABNAJwGABQQAAQMAgAYAAoAGIgAAE4UlLQAYyhjK",
+      "debug_symbols": "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",
+      "brillig_names": [
+        "public_dispatch"
+      ]
+    },
+    {
+      "name": "sync_notes",
+      "is_unconstrained": true,
+      "custom_attributes": [],
+      "abi": {
+        "error_types": {
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        },
+        "parameters": [],
+        "return_type": null
+      },
+      "bytecode": "H4sIAAAAAAAA/9VUyw6CMBBseURBOaiJ3kz8gyIYOJJ49x8akKMe8OKNT5eabbqpVRKlJkzSbEs3szNlW0oUKESPvAH9tGnIFdhBDCA6aN/tRgFr9hviQKs7JH/O0iQw+BtQ/5OfWtIvIPktnT+bAM+xVfzYi6w77UaIesKWZ/nPbHpe9fhc/MFnh32k1caghm+uIYci3RuYR4Y8iRlRd9prh/eV5YzJei7w++RVO67va/lrWIeafvmOFV/qrDMe1wmv+YFXVVrypcYv4KBzGnMvbGHe1wvY45yo3mjul/J0vZ0b0gNB8gCVxsvQjgYAAA==",
+      "debug_symbols": "ndLBCoQgEAbgd5lzB7Vc114llrCyEETDbGGJ3n0t2qVduuhlYAa/8TD/Ap1s5qFWprcTlNUC2rbCK2tCt6wZNE5prYb6PAa0FYz399MozNZOXjgPZUEykKaDkqKge6VlmCG0PjLAJBbksaCIBTQSkMsfeEHRQXjB2BdhTHZEU9AtBbEUdE9A+eX1Oc35B1F6/0VraJ/CKdFoeaSrn017Cpt/jfIvd6OzrexmJ7cEnsIXaoVZRkhYG1a/AQ==",
+      "brillig_names": [
+        "sync_notes"
+      ]
+    },
     {
       "name": "claim",
       "is_unconstrained": false,
@@ -853,7 +1009,7 @@
                 "name": "private_call_requests",
                 "type": {
                   "kind": "array",
-                  "length": 4,
+                  "length": 5,
                   "type": {
                     "fields": [
                       {
@@ -1037,7 +1193,7 @@
                       }
                     ],
                     "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::abis::side_effect::Counted"
+                    "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted"
                   }
                 }
               },
@@ -1152,46 +1308,29 @@
                 }
               },
               {
-                "name": "start_side_effect_counter",
-                "type": {
-                  "kind": "integer",
-                  "sign": "unsigned",
-                  "width": 32
-                }
-              },
-              {
-                "name": "end_side_effect_counter",
-                "type": {
-                  "kind": "integer",
-                  "sign": "unsigned",
-                  "width": 32
-                }
-              },
-              {
-                "name": "note_encrypted_logs_hashes",
+                "name": "private_logs",
                 "type": {
                   "kind": "array",
                   "length": 16,
                   "type": {
                     "fields": [
                       {
-                        "name": "value",
-                        "type": {
-                          "kind": "field"
-                        }
-                      },
-                      {
-                        "name": "counter",
+                        "name": "log",
                         "type": {
-                          "kind": "integer",
-                          "sign": "unsigned",
-                          "width": 32
-                        }
-                      },
-                      {
-                        "name": "length",
-                        "type": {
-                          "kind": "field"
+                          "fields": [
+                            {
+                              "name": "fields",
+                              "type": {
+                                "kind": "array",
+                                "length": 18,
+                                "type": {
+                                  "kind": "field"
+                                }
+                              }
+                            }
+                          ],
+                          "kind": "struct",
+                          "path": "authwit::aztec::protocol_types::abis::log::Log"
                         }
                       },
                       {
@@ -1201,25 +1340,6 @@
                           "sign": "unsigned",
                           "width": 32
                         }
-                      }
-                    ],
-                    "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::abis::log_hash::NoteLogHash"
-                  }
-                }
-              },
-              {
-                "name": "encrypted_logs_hashes",
-                "type": {
-                  "kind": "array",
-                  "length": 4,
-                  "type": {
-                    "fields": [
-                      {
-                        "name": "value",
-                        "type": {
-                          "kind": "field"
-                        }
                       },
                       {
                         "name": "counter",
@@ -1228,22 +1348,10 @@
                           "sign": "unsigned",
                           "width": 32
                         }
-                      },
-                      {
-                        "name": "length",
-                        "type": {
-                          "kind": "field"
-                        }
-                      },
-                      {
-                        "name": "randomness",
-                        "type": {
-                          "kind": "field"
-                        }
                       }
                     ],
                     "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::abis::log_hash::EncryptedLogHash"
+                    "path": "authwit::aztec::protocol_types::abis::private_log::PrivateLogData"
                   }
                 }
               },
@@ -1280,6 +1388,22 @@
                   }
                 }
               },
+              {
+                "name": "start_side_effect_counter",
+                "type": {
+                  "kind": "integer",
+                  "sign": "unsigned",
+                  "width": 32
+                }
+              },
+              {
+                "name": "end_side_effect_counter",
+                "type": {
+                  "kind": "integer",
+                  "sign": "unsigned",
+                  "width": 32
+                }
+              },
               {
                 "name": "historical_header",
                 "type": {
@@ -1667,8 +1791,8 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "7b3djvNIkqR9L31cB4wIj7+9lcVgMDM7u2ig0b2Ynw/4MJh7X75VJWW+JVHeSTEpk5udNKq6FKlwNzLoYZQ/8V9/+l//+s//+X/+8c9//d9/+/c//Y//+V9/+svf/uWf/uPPf/vr+m//9adUfv3//v3//tNff/zrv//HP/3bf/zpf6Q2l1/+9K9//V/rP/Zl+e9f/vS///yXf/3T/yiz/PcvN5/Oo4zfP51H+/h0qunOp0tN8/dPlzqz8+mZzX7/9My1Xz+d87zz6WQ5X+Ztlj4+3e59OOXLRFLq4/OH/+GXPyVTYu4npiox9xPT0BMz0jUxs3qJGaNd5j2X+lRiuhJzPzFDibmfmPl8Yizl+vunLbWPOzst+cdX5OX7vyLd+4q8pMuKkxfrzleUMT6+4dNn7d501uXu8uHcy8d07qlVbbmoVS3b5w//mHp+36mX9526ve/U6/tOvb3v1Pv7Tn2879Tn2069LO879fd9mpb3fZqW932alvd9mpb3fZqW932alvd9mpb3fZqW932a2vs+Te19n6b2vk9Te9+nqb3v09Te92lq7/s0tfd9mtr7Pk3tfZ+m9X2fpvV9n6b1fZ+m9X2fpvV9n6b17KdpWy7vc63l5Y+zaVCz6VCzGVCzOfvJ1Or15Vzrf5xNW6Bmk6Bmk6FmU6BmY0j3VINaixvUWtyg1uI2oK5iqLW4Q63FHWot7lBrcYdai7tBzaZCzQZqLe5Qa3GHqov7RJrNWKBmk6BmA7UWD6i1eECtxQNqLR4NajYdajZQdfGAqosnVF08odbimaFmU6BmY1CzgfIoJlRdPKHq4glVF0+otTgtUItxWqBcirRAlcZpgaqN0wJVHKcFqjpOC1R5nBao+jgtUItyWqDcipSg7IqUoGrklKCK5JSgquSUoMrklKDq5JSwVuWEtSonKNsiJaxaOWPVyhmrVs5YtXLGqpVP74F2poO1Kmco+yJlKP8iZaxaOWPVygWrVi5YtXLBWpUL1qpcsFblguVgFKxauWDVygWrVi5YtbJh1cqGtSobloNhWA7G6T2ZznSwamXDqpUNq1Y2rFXZsFblirUqVywHo2LVyhWrVj69t8+ZDlatXLFqZayOvYTVspcqloPRsByMhlUrN6xauWHVyg1rVW5Yq3LDWpUbloOB1byXsLr3Elb7XsLq30tYDXypY63K57fwPZ4OloOB1cSXsLr4ElYbX8Lq40tYjXxpYK3KWK18CauXL2E18yWsbr6E1c6XsPr5ElZDX8Lq6EsTa1XG6ulLWE19CaurL2G19SWsvr6E1diXJtaqPLFWZazevozV25exevsyVm9fxurtW78MazpQtXJeoFblvEA5GBmrty9j9fZlrN6+jNXbl7F6+zJWb19OWKtywlqVsXr7MlZvX8bq7ctYvX0Zq7cvY/X2ZazevpyxVuXze/seTwfKwchYvX0Zq7cvY/X2ZazevozV25cL1qqM1duXsXr7MlZvX8bq7ctYvX0Zq7cvY/X2ZazevmxYqzJWb1/G6u3LWL19Gau3L2P19mWs3r6M1duXsXr7MlZvX8bq7ctYvX0Zq7cvY/X2ZazevozV25exevsyVm9fxurty1i9fRmrty9j9fZlrN6+jNXbl7EO5ctYvX0Zq7cvY/X2ZazevozV25exevsyVm9fxurty1in82Ws3r6M1duXsXr7MlZvX8bq7ctYvX0Zq7cvY53SlwdWrYzV25exevsyVm9fxurty1i9fRmrty9j9fZlrOP68sSqlbF6+zJWb1/G6u3LWL19Gau3L2Od2pexju3LWL19Bau3r2D19hWs3r6C1dtXFqhauWD19hWsc/sK1rl9Bau3r2D19hWs3r6C1dtXsHr7ClZvX8E6t69gndtXElStXLB6+wpWb1/B6u0rWL19Bau3r2D19hWsc/sK1rl9JWPVyli9fQWrt69g9fYVrN6+gtXbV7DO7SsFq1YuWLUyVm9fwertK1i9fQWrt69g9fYVrN6+gnVuXzGsWtmwamWs3r6C1dtXsHr7ClZvX8Hq7SuGVSsbVq1csWplrN6+gtXbV7B6+wpWb1/B6u0rWL19pWLVyhWrVq5YtTJWb1/B6u0rWL19Bau3r2D19pWGVSs3rFq5YdXKWL19Bau3r2D19hWs3r6C1dtXsHr7yvm9fY+ng1Urd6xaGau3r2D19hWs3r6C1dtXsHr7ClZvXxlYtfL5vX2Pp4O1KmP19hWs3r6C1dtXsHr7ClZvX8Hq7SsTq1aeWLUyVm9fwertK1i9fQWrt69g9faVCVUr2wJVKxtWb59h9fYZVm+fLYY1Haha2bB6+wyrt88WqFrZFqha2bB6+wyrt8+wevsMq7fPsHr7DKu3z7B6+yxB1cqG1dtnWL19htXbZ1i9fYbV22dYvX2G1dtnWL19lrFqZazePsPq7TOs3j7D6u0zrN4+w+rtM6zePju/t+/xdLBqZazePsPq7TOs3j7D6u0zrN4+w+rtM6zePjOsWvn83r7H08FalbF6+wyrt8+wevsMq7fPsHr7rGLVyhWrVsbq7TOs3j7D6u0zrN4+w+rtM6zePsPq7bOGVSs3rFoZq7fPsHr7DKu3z7B6+wyrt8+wevusYdXKDatW7li1MlZvn2H19hlWb59h9fYZVm+fYfX2WceqlTtWrdyxamWs3j7D6u0zrN4+w+rtM6zePhtYtfLAqpUHVq2M1dtnWL19htXbZ1i9fYbV22dYvX12fm/f4+lg1coTq1bG6u0zrN4+w+rtq1i9fXWBqpXrAlUr1wWqVq4LVK1csXr7KlZvX8Xq7atYvX0Vq7evJqhauSaoWrkmqFq5JqhauWL19lWs3r6K1dtXsXr7aoKqlWvCqpUzVq2csWplrN6+itXbV7F6+ypWb1/F6u2rGatWzli1csaqlQtWrYzV21exevsqVm9fxertq1i9fbVg1coFq1bG6u2rBatWNqxa2bBWZcNalbHO7atYvX0Vq7evYvX2VazevorV21exevsqVm9fxTq3r2Kd21exevsqVm9fxertq1i9fRWrt6+e3tvXR7p8uI9yM50DVmWr5foNyZtOrv3y4dx/ms7th9fSuf3+4bVOtD/O/YhGwJfNPb3x3PMbz7288dztjede33ju7Y3n3t947uON5/7Gz9X+xs/V/sbP1f7Gz9X+xs/VI9pPXzb3N36u9jd+rvY3fq72N36u9jd+ro43fq6ON36ujjd+ro43fq4e0UD8srm/8XN1vPFzdbzxc3W88XN1vPFzdb7xc3W+8XN1vvFzdZ79XH38+veIru4jp1OxptOwpnP2M+rxG8U5sKYzkabTlgVrOglrOhnpzmoL1Kq8/kes6UCtym1pWJcy1KrcFqhVuS1Yq3LCWpUT1qqcMtZ0CtZ0sFblhLUqJ6hauaWONZ2BNZ0JNZ2MtSpnrFU5Y63KGWtVzoY1nYo1HaxaOWPVyhmrVs5Yq3JZsKaTsKaD5WAULAejGNZ0sGrlglUrF6xVuWCtygXLwTCsWtmwamXDqpUNq1Y2w5oOVq1sWKuyYTkYhuVgGFatXLFq5YpVK1esWrli1coVa1WuWKtyxXIwKlatXLFq5YpVKzesWrlh1coNq1ZuWKvy6U3PznSwHIyGVSs3rFq5YdXKDatW7lircsdalTvWqtyxHIzTW2ad6WDVyh2rVu5YtXLHqpU71qo8sByMgeVgDCwHY2DVyqc3XDrTwaqVB9aqPLBW5YG1Kg8sB2Ni1coTq1aeWLXyxKqVz+/tezwdrFUZq7evTSwHY2I5GBOqVu4LVK3cF6hauS9Qq3JfoFblvkCtyn2BcjA6Vm9fx+rt61i9fR2rt69j9fb1hLUqJygHoycoB6Nj9fZ1rN6+jtXb17F6+zpWb19PWKsyVm9fx+rt61i9fR2rt69j9fZ1rN6+jtXb17F6+3rGWpWxevs6Vm9fx+rt61i9fR2rt69j9fb1grUqF6xVGau3r2P19nWs3r6O1dvXsXr7OlZvX8fq7euGtSobloOB1dvXsXr7OlZvX8fq7etYvX0dq7evV6xVuWKtyli9fR2rt69j9fZ1rN6+jtXb17F6+zpWb19vWKtyw3IwsHr7OlZvX8fq7etYvX0dq7evY/X29Ya1KmP19nWs3r6O1dvXsXr7OlZvX8fq7etYvX0dq7evd6xVGau3r2P19nWs3r6O1dvXsXr7OlZvX8fq7etYvX0dq7evY/X2dazevo7V29exevs6Vm9fx+rt61i9fR2rt69j9fZ1rN6+jtXb17F6+wZWb9/A6u0bWOf2DazevrFArcoDq7dvYPX2DazevoHV2zewevsGVm/fwDq3b2D19g2s3r6B1ds3sHr7BlZv38Dq7RtYvX0D69y+kbFqZazevoHV2zewevsGVm/fwOrtG1i9fQOrt29gnds3MlatjNXbN7B6+wZWb9/A6u0bWL19A+vcvoF1bt/A6u0bWL19A6u3b2D19g2s3r6B1ds3sHr7Bta5fQPr3L6B1ds3sHr7BlZv38Dq7RtYvX0Dq7dvYJ3bN7DO7Rvn9/Y9ng7WqozV2zewevsGVm/fwOrtG1i9fQPr3L6BdW7faFi1MlZv38Dq7RtYvX0Dq7dvYPX2Daxz+0bHqpU7Vq2M1ds3sHr7BlZv38Dq7RtYvX0Dq7dvYJ3bNzpWrTywamWs3r6B1ds3sHr7BlZv38Dq7RsDq1YeWLXywKqVsXr7BlZv38Dq7RtYvX0Dq7dvYPX2jYlVK0+sWnli1cpYvX0Dq7dvYvX2TazevonV2zcXqFp5LlC18lygauWJ1ds3sXr7JlZv38Tq7ZtYvX0Tq7dvJqhaeSaoWnme39v3eDpYqzJWb9/E6u2bWL19E6u3b2L19s2MVStnrFoZq7dvYvX2TazevonV2zexevsmVm/fxOrtmwWrVi5YtTJWb9/E6u2bWL19E6u3b2L19s2CVSsXrFoZq7dvYvX2TazevonV2zexevsmVm/fxOrtm4ZVKxtWrYzV2zexevsmVm/fxOrtm1i9fROrt29i9fbNilUrY/X2TazevonV2zexevsmVm/fxOrtm1i9fROrt2+e39v3eDpYqzJWb9/E6u2bWL19E6u3b2L19k2s3r7ZsWrljlUrY/X2TazevonV2zexevsmVm/fxOrtm1i9fXNg1coDq1bG6u2bWL19E6u3b2L19k2s3r6J1ds3B1atPLFqZazevonV2zexevsmVm/fxOrtm1i9fROrt29OrFp5QtXKacFq7lvnA+VhrPOBMjHW+UDVy+t8oArmdT5QFfM6H6iSeZ0PVM28zgeqaF7nA7Y+Y7X5rfOBqpvX+UAVzut8oCrndT5QpfM6H6jaeZ0PVPG8zgeqel7nA7Y+Y/X7pQWr4W+dD1j9jNXyt84HrH4+v+nPmQ9Y/YzV9rfOB2x9xmr8W+cDVj9jtf6t8wGrnwtY/VzA6ufz2/+c+YCtz1gNgOt8wPwNrBbAdT5g9bOB1c8GVj8bWP2M1Qe4zgdsfcbqBFznA1Y/Y/UCrvMBq58NrH6uYPVzBaufsRoC1/mA+RtYLYHrfMDq5wpWP1ew+rmC1c8VrH7Gagxc5wO2PmO1Bq7zAaufsZoD1/mA1c8NrH5uYPVzA6ufsToE04LVIrjOB8zfwGoSXOcDVj+f3ybozAesfsZqFFznA1Y/d7D6uYOtzwNsfcY6CXCdD1j9jNUvuM4HbH3G6hhc5wPmb2D1DK7zAVufsU4ETAvWkYDrfMD8DazGwXU+YP4GVuvgOh8wf+P05sE+0vXDo9zO54D1edbLEjeHN5/R2+Wzy7h+Nud557PpI5eptU+f7vc+PPplymnM/vjDubZ5ia8l+/zh37IylJU7WZnKyk1W0hEdnQGzkpSVO1nJysqdrBRl5U5WTFm5k5WqrNzJSlNW7mRFte29rKi2vZcV1bZ3spJU297Limrbe1lRbXsvK6pt72XFKLMy6mUaeaby+MPD2sW4GzaX2xRyFsJfSmEfl6twjJ8//FsKOavmQ1PIWWJ/KYUtXz48mjVnGlaXcZmH1Xxn6eQs31+Zcc6twZHLRObcRxyaQs5Nxwvv+8y5oXllxjk3S4cuE6YUPptC7aye3Zxm7ayevgq1s3o6hdoqnf0A11bp5IwX7ayeXSaKdlZPp1BbpbPve22Vzs64KePPLhPaWT2dQu2snt2cFu2snr4KtbN6OoXaKp38ADdtlc7OuHZWzy4Tpp3V0ynUVuns+96U8ZMzrp3V08uEdlZPp1A7q2c3p6ad1dNXoXZWz6awaqt08gO8aqt0dsa1s3p6mdDO6ukUmlJ48n2vrdLZGdfO6ullQjurp1OondWzm9OqndWzV2HTzurpFGqrdPIDvGmrdHbGtbN6epkwpfDZFGqrdPZ9r63S2RnXzurpZUI7q6dTqJ3Vs5vTrp3Vs1dh187q6RRqq3TyA7xrq3R2xk0Zf3aZ0M7q6RRqq3T2fa+t0tkZ187q6WVCO6tnUzi0s3p2czq0s3r6KtTO6ukUaqt08gP8iONqlfEvZVw7q6eXCe2snk6htkpn3/faKp2dce2snl0mpnZWT6dQO6tnN6dTO6unr0LtrJ5OoSmF5z7Ap7ZKZ2dcO6unlwntrJ5OobZKZ9/32iqdm/G8aGf15DKx5kopfDaF2lk9uTnNi3ZWT1+FphQ+m0Jtlc5+gGurdHbGtbN6epnQzurpFGqrdPJ9n7RVOjvj2lk9u0wk7ayeTqF2Vs9uTpMphc9ehdpZPZ1CbZXOfoBrq3R2xrWzenqZ0M7q2RRmbZVOvu+ztkpnZ1w7q6eXCe2snk6hKYVPbk6zdlZPX4XaWT2dQm2Vzn6Aa6t0dsa1s3p2mSjaWT2dQm2VTr7vi7ZKZ2dcO6unlwlTCp9NoXZWz25Oi3ZWT1+F2lk9nUJtlc5+gGurdHLGTTurZ5cJ087q6RRqq3T2fa+t0tkZN2X82WVCO6unU6id1bObU9PO6umrUDurp1OordLJD/CqrdLZGdfO6tllompn9XQKtVU6+743ZfzkjGtn9fQyoZ3V0ynUzurZzWnVzurpq1A7q2dT2LRVOvkB3rRVOjvj2lk9vUxoZ/V0Ck0pPPm+11bp7IxrZ/X0MqGd1dMp1M7q2c1p087q2auwa2f1dAq1VTr5Ad61VTo749pZPb1MmFL4bAq1VTr7vtdW6eyMa2f19DKhndXTKdTO6tnN6aDcWZWSLlMu5efV8LesUG6W3KxQbmjcrFBuOtysmLJyJyuUWwM3K5Tlu5sVyhLbzQpl1exmhbIQ9rIyOWvbft27l15vN02Ts7b1ssJZ23pZ4axt58e6Mnt6zqOYphQ+m0LOqvlLKTzW3p2cFfkrM85Z7R+6THBuDQ5NIec+4nX3fVk49yivzDjn/ufAZaIsnJulQ1OonZWbwsevLstijCm0ZSy/f9jSj+9+9OGZl8s0ZnansdRySfj6zzZvM065EXtpxik3Yi/NOOVG7KUZp9y3vTTjlNu8V2Y8UW7zXppxym3eSzNOuSt8acYpN5Evzbgp4ydnXHvOszOuPefZGdee8+yMa895dsYp95w1t8s0asnjJiuZcl/oZoVy7+ZmhXJ/5WaFcg9US7+s5NVKdf5yL7lf/nQvw13L12XpupaXevvmLZtyfnrOKfdBL8455U7ozJy325xT7oW+N+debZ4pd0MvzjnnfuilOS+cu63X5pxzL/fanHPuFF+bc+1Dz8+5Keen51z70PNzrn3o+TnXPvT8nGsfen7OtQ/1c25X4l7qNTt9K+nHXC8fT31JNzk37UMPz3mfds35yHdyrn2on/N1cbnmvLd8m0RtLA9IonaKfhLH/EjiTLddvGaUSTQb1yR29y+vBcL1T+fl9tlvnHu5g5PIuTk7OImcu62vJbEsH3969Rsff9xyvewTLPePD6d5dyLL9Uc29omZsH74N3k4N2ZvIw/nHu5d5Kmc2723kYdzZ/g28nDuOd9GHs7d7NvIY5IHWR7twKHl0d4eWh65BtDyyDWAlkeuAbI8Ta4BtDxyDaDlkWsALY9cA2h5TPIgyyPXAFoeuQbQ8sg1gJZHrgG0PHINkOXpcg2g5ZFrAC2PXANoeeQaQMtjkgdZHrkG0PLINYCWR64BtDxyDaDlkWuALM+QawAtj1wDaHnkGkDLI9cAWh6TPMjyyDWAlkeuAbQ8cg2g5ZFrAC2PXANkeaZcA2h55BpAyyPXAFoeuQbQ8pjkQZZnwzXol+nntFRHnjz6vHx6po+TotLI9wQq7Y6Y6ce4288Ou7Aox6jmyTnGlUQ7P8063/vTKeXLpFP6rFD7PTFNibmfmK7E3E/MUGLuJ2aenZifZ7T8lJofU7JlwZtSwptSxptSwZuS4U2p4k2p4U2p401p4E3p/NV7GddjGXKut1NKC96Uzl+9u10PUuh/EO7OpqFedhjWPk3/x7Ekd4It17+82Pjp078Fm5mCLUzBWqRg65VlvrR7wVamYBtTsD1SsB9I/mXmO8EOpmAnUbB5CfXo+RRsuRNsqApqXs9+W6vqO8GGqqC8YENVUF6wFvOeTenOczaDV1A1XebfxnCCHTlfZj1y/5jHfYN0fWl/SWP5dHLYvUlku77dyWvN+fjDP5aGS3xm6b+fMV4tg9d87PKAV6kY8oxrEvOw4mT8wNcWlsHranZ5wHcCR8nza7AFfCdwbLAv2Ank6+HLY8lOsN0uJWD//KOR8fuFWfJ7T7+89/Ttvadf33v67b2n3997+uO9pz/fevq2vPf03/upa+/91LX3furaez917b2fuvbeT11776euvfdT1977qVvf+6lb3/upW9/7qVvf+6lb3/upW9/7qVvf+6lb3/upW9/7qVvf+6nb3vup2977qdve+6nb3vup2977qdve+6nb3vup2977qdve+6nb3vup29/7qdvf+6nb3/up28GfuqNdWAxjLHemD/7U9aZP8kvJ34IFf0bPdv0N77Kkn8S6/fBqU1x/DVU/S3v3p1MBf2jVwUsWqfklNcErOKn5JTXBC1qp+RU1B3h9LzW/pCb4dkdqfklN8N2f1PySmuCbYan5JTVNagZSE/wFhdT8kprygiKpKS8okprygiKpKS8okJpTXlAkNeUFRVJTXlAkNeUFRVLTpGYgNeUFRVJTXlAkNeUFRVJTXlAkNeUFxVGzLvKCIqkpLyiSmvKCIqkpLyiSmiY1A6kpLyiSmvKCIqkpLyiSmvKCIqkpLyiQmkleUCQ15QVFUlNeUCQ15QVFUtOkZiA15QVFUlNeUCQ15QVFUlNeUCQ15QUFUjPLC4qkprygSGrKC4qkprygSGqa1AykprygSGrKC4qkprygSGrKC4qkprygQGoWeUGR1JQXFElNeUGR1JQXFElNk5qB1JQXFElNeUGR1JQXFElNeUGR1JQXFEhNkxcUSU15QZHUlBcUSU15QZHUNKkZSE15QZHUlBcUSU15QZHUlBcUSU15QYHUrPKCIqkpLyiSmvKCIqkpLyiSmiY1A6kpLyiSmvKCIqkpLyiSmvKCIqkpLyiQmk1eUCQ15QVFUlNeUCQ15QVFUtOkZiA15QVFUlNeUCQ15QVFUlNeUCQ15QUFUrPLC4qkprygSGrKC4qkprygSGqa1AykprygSGrKC4qkprygSGrKC4qkprygQGoOeUGR1JQXFElNeUGR1JQXFElNk5qB1JQXFElNeUGR1JQXFElNeUGR1JQXFEjNKS8okprygiKpKS8okprygiKpaVIzkJrygiKpKS8okprygiKpKS8okpryguKo2RZ5QZHUlBcUSU15QZHUlBcUSU2TmoHUlBcUSU15QZHUlBcUSU15QZHUlBcUSM0kLyiSmvKCIqkpLyiSmvKCIqlpUjOQmvKCIqkpLyiSmvKCIqkpLyiSmvKCAqmZ5QVFUlNeUCQ15QVFUlNeUCQ1TWoGUlNeUCQ15QVFUlNeUCQ15QVFUlNeUCA1i7ygSGrKC4qkprygSGrKC4qkpknNQGrKC4qkprygSGrKC4qkprygSGrKCwqkpskLiqSmvKBIasoLiqSmvKBIaprUDKSmvKBIasoLiqSmvKBIasoLiqSmvKBAalZ5QZHUlBcUSU15QZHUlBcUSU2TmoHUlBcUSU15QZHUlBcUSU15QZHUlBcUSM0mLyiSmvKCIqkpLyiSmvKCIqlpUjOQmvKCIqkpLyiSmvKCIqkpLyiSmvKCAqnZ5QVFUlNeUCQ15QVFUlNeUCQ1TWoGUvN8L2h9b7Ol5m9TOt3QyOtlcPl0TeZcYClnuwSQy8c1U9K9v93qcpl3q+Xjekx3L5mcLxMpuZRP074fY7peNL1//vBveezK4yF5HMrjIXmcyuMReRyL8vh35XHOyzzKkuptHpPyeEges/L49+SxLOUjjzadpH9MI9e8PP7wzxVhuVWoSKEXKzSv+UjzUxl+98N23cHYLJ/D+01Mk5hxxKwSM46Y2ri+WMy8Oj6XDy/ZnhJTu+dAYmoL/2oxUyrXXJd5W6LKHABXaMp2QFdIhsarFcp2+cvrqyJnGqmM65sqW259lSlfJZScMmHeSs5aLottqrU9U31Ok/KkysveYVVeXtB7Kd+vLmCdT7mAU8YRq/Jymb5D+Q8x3TXZexE65TK9WqHDXrf0RYZUIDHlXb1YzONet/RFzlUgMeVbvVrMx75/X0wKgSskHwhdIfk1r1bowJctfZEJE0pOOStvJedhPnpf5NiQKp9k77AqLy/ovZQ/6g1KTzKOWJWXy/QNyrecLyG2Wp+rwZNJIXCF5DK9WqEDiyAZUoHElB0VSEyZUS8X87i6U/5SHDGzLKO/T8yUlsuHU67e9vE4EknPsnZerdBxv9nKcmsCiSkDJpCYJjFfK+aBP8DLsnUCiSlb59ViOr8Ey/Jq0BWSAYOukFyVVyt05M/vinyVUHLKhHkrOY97dVHk2LAqL3uHVXmT8m+l/GGvw4qMI1bl5TJ9h/LHkUh6kcv0aoWOe91SZEgFElPe1YvFPPB1i8m5CiSmfKtXi+n4/iZ/CV0h+UDoCpkUerFCR75sMZkwoeSUs/JWch7no5scG1blZe+wKi8v6L2UP+wNSpVxxKq8XKZvUP5IzkWVy4SukFymVyt0XBFUTWLGEVN2VCAxZUa9XMzj6k75S4HEPN8yqv36nr2V+iZirjFeZz16vy0kp/J4RB7bojweksekPB6Sx6w8/l15nPMDu5VuN9qtKI+H5NGUx7+r+Pq2Q1u9H8y3KoVerNBxv7FuTWLGEbNLzDhiauP6YjEP/MF80+45jphdW/hXi+n8crvLHEBXSLYDukIyNF6t0JE/l+8mOSPJKRPmreQ87qcGXY4Nq/Kyd1iVlxf0Xsof9vOVLuOIVPkhl+k7lD+QHDbkMr1aoeNetwwZUoHElHf1YjEPfN0yTGLGEVO+1avFdHz/IX8JXSH5QOgKya95tUJHvmwZMmEiyTnlrLyVnMf56FOODavysndYlZcX9F7KH/YGZZqUJ1VeLtM3KH8kl2rKZUJXSC7TqxU6sAiSIRVITNlRYcQci8yol4t5VN05FvlLgcSUZfT3iflth7Y6P8Abi6ydVyt02G+2xmISM46YMmACiSmv5sViHvcDvLHI1gkkpmydV4v5+JdgY5FXA65QkgGDrpBclVcrdODP70aSrxJKTpkwbyXnca8ukkl5UuVl77AqLy/ovZQ/7HVYknHEqrxcpu9Q/jgSyUhymV6t0HGvW7IMqUBiyrt6sZgHvm7Jcq4CiSnf6tViOr5/NikErpB8IHSF5Ne8WqEjX7ZkmTCh5JSz8lZyHuejZzk2pMoX2TusyssLei/lD3uDUmQcsSovl+kblD+QczGKSSFwheQyvVqhA4sgGVKBxJQdFUhMmVEvF/O4ulP+Uhwx7XzLqH+IOZblJzF/m1LCm9L5m+xel48ppTtTKnhTstOnNMtVuDnGnSlVvCmdXqWmZYzrgpjrnSl1vCkdUDGUxS5LX1nadKbU02VN7fYhW/7xLTefHfOi8edQ73/WWX8nR5z1/nMmXZ+nOVl34kzLct3MLzn/NJ/fviSd8SX5jC8pG19iH18yf/qS34bdX4Hz9dtyLtObW87zo36q/ZOWy73rqV7v5JY+3cil3b32LtdTH58eszXdu/bW2uT3D481sI8c5XuV2c8/Y/+YR75bIaZ8WatS+vQj3Pz74lOr0nhEGtv5aWwf0ebhpDE1u+Qxte4l0tZvvyxwuZfHG4VqyyWP1T7/mPSyHHalZis1Q6nZSs1UajZS0xalZis1SanZSk1WarZSU5SardSYUrOVmqrUbKVG1fBmalQNb6ZG1fBmalQNb6WmqxreTI2q4c3UqBreTI2q4c3UmFKzlRpVw5upUTW8mRpVw5upUTW8mRpVw1upGaqGN1OjangzNaqGN1OjangzNabUbKVG1fBmalQNb6ZG1fBmalQNb6ZG1fBWamasargtl4lY+0w5vkQbq8D1oo1Vs3rRxipDvWgtVrRXDq799OlLtLGKRS/aWPWfF22sks6LNlaV5kUbq/B6vCbPhamWmgtTLTUXplpqLsFqqYer1FyMKlqmWmouTLXUXJhqqbkw1VJzCVZLPY42BaulnGipaqlEVUslJl9qpmC1lBNtsFrKiTZYLeVES1VLJapaKlHVUpmqlsrBaikn2mC1lBMtlS+VqXypTOVLZapaKgerpZxog9VSTrRU7/gK1Tu+QuVLFSpfqlD5UoWqlipUtVShesdXqHypQuVLFSpfyqh8KaPypYzKlzKqWsqC1VJOtFTv+IzKlzIqX8qofCmj8qUqlS9VqWqpSlVLVap3fK84o+OF0VL5UsFOvPCipfKlgp1L4UVL5UsFOz3CqaWCHQjhRUv1ji/YsQ1etEYVLZUvFey8BC9aqloq2KkGXrRUtVSwswe8aKl8qWAnBHjRUvlSwTj+XrRUvlQw2r5TSwUD6HvRUr3jC4a5d6INRq73oqXypYLx5b1oqWqpYBR4L1qqWioYq92LlsqXCkZU96Kl8qWicc+daKl8KSru+aTins9o3HMnWqp3fNG45060VL5UNO65Ey1RLZWXaNxzJ1qiWmqNlugd3xotkS+1RmtU0RL5Umu0RL7UGi2RL7VGS1RLrdESvePLSzTuuRMt0Tu+NVoiX2qNlsiXWqM1qmiJfKk1Wqpaiol7vkZL9I5vjZbKl2Linq/RUvlSTNzzNVoqX4qJe75GS1VLMXHP12iJ3vGt0VL5Ukzc87wwcc/XaKl8qWjc88fP22jccydao4qW6h0fE/d8jZbKl2Linq/RUvlSTNzzNVqqWioa99yJluodHxP3fI2Wypdi4p6v0VL5Ukzc8zVaqloqGvfciZbqHR8T93yNlsqXYuKer9FS+VJM3PM1WipfKhr3/HEtFY17/jhaJu75Gi2VL8XEPV+jpfKlmLjna7RUvlQ07vnj6oKJe75GS/WOj4l7vgZF5Usxcc/XoKh8KSbu+RqUUUVLVUsxcc/XoKje8TFxz9egqHwpJu75Gi2VL8XEPV+jpaqlmLjna7RU7/iYuOdrtFS+FBP3fI2Wypdi4p6v0VL5Ukzc8zVaqnd8TNzzNVoqX4qJe75GS+VLMXHP12iZfKlExT1PVNzzRMU9T1Tc87QYVbRMvlSi4p4nKu55isY9d6KlqqWouOeJinueqLjniYp7nqi454mKe56icc+daJl8qUTFPU9U3PNExT1PVNzzRMU9T1Tc80TFPU/RuOdOtFS+FBX3PFFxzxMV9zxRcc8TFfc8ReOeO9FS+VJU3PNExT1PVNzzRMU9T1Tc80TFPU9U3PMUjXvuREvlS1FxzxMV9zxRcc8TFfc8UXHPExX3PEXjnj+ONhr33ImWypei4p4nKu55ouKeJyrueaLinicq7nmKxj13oqXypaJxz51oqWopKu55ouKeJyrueaLinqdo3HMnWipfKhr33ImWqpai4p4nKu55ouKeJyrueaLinqdo3HMnWipfKhr33ImWqpai4p4nKu55ouKeJyrueYrGPXeiNapoqXwpKu55ouKeJyrueaLinicq7nmi4p6naNxzJ1oqXyoa99yJlqqWouKeJyrueaLinicq7nmOxj13omXypXI07rkTLVMtlRejipbpHV+m4p5nKu55puKe52jc88fRRuOeO9Ey+VKZinueqbjnmYp7nqm455mKe56puOc5GvfciZbKl6Linmcq7nmm4p5nKu55puKeZyrueabinudo3HMnWipfiop7nqm455mKe56puOeZinueo3HPnWipfCkq7nmm4p5nKu55puKeZyrueabinmcq7nmOxj13ojWqaKlqKSrueabinmcq7nmm4p5nKu55puKe52jccydaqlqKinueqbjnmYp7nqm455mKe56puOeZinueo3HPnWipaikq7nmm4p5nKu55puKeZyrueabinudo3PPH0UbjnjvRUtVSVNzzTMU9z1Tc80zFPc9U3PNMxT3P0bjnTrRUvhQV9zxTcc8zFfc8U3HPMxX3PFNxz3M07rkTLZUvRcU9z1Tc80zFPc9U3PNMxT3PVNzzTMU9z9G45060VL4UFfc8U3HPMxX3vFBxzwsV97xQcc9LNO65E61RRcvkSxUq7nmh4p4XKu55oeKeFyrueaHinpdo3HMnWiZfqkTjnjvRUtVSVNzzQsU9L1Tc80LFPS/RuOdOtFS+VDTuuRMtVS1FxT0vVNzzQsU9L1Tc80LFPS/RuOePo43GPXeipfKlqLjnhYp7Xqi454WKe16icc+daKl8qWjccydaKl+KinteqLjnhYp7Xqi454WKe16icc+daKl8qWjccydaKl+KinteqLjnhYp7Xqi45yUa99yJ1qiipfKlonHPnWipaikq7nmh4p4XKu55oeKel2jccydaKl8qGvfciZbKl6Linhcq7nmh4p4XKu55oeKel2jccydaKl+KinteonHPHW2pfKlo3HMnWqpaKhr33ImWypei4p4XKu55oeKeFyrueaHinhcq7nmJxj13nkBU7/iouOeFinteqLjnhYp7Xqi45yUY97yPy6fXfyy30Rp4tH2Zlz/d8/SiXb/9Em3uP0V7++FqS/v9w9Wy3aYGvfB6YWrQq7QXpga9pHthatDrvxemBr1YfFlqDJ4C/8LUoJehL0wNes36wtSgF7gvTI0pNVupUTW8mRpVw5upUTW8mRpVw5upUTW8lRp4jv8LU6NqeDM1qoY3U6NqeDM1ptRspUbV8GZqVA1vpkbV8GZqVA1vpkbV8FZq4E9ieGFqVA1vpkbV8GZqVA1vpsaUmq3UqBreTI2q4c3UqBreTE2savjxb74N/sSLQ6OFP/Hi2GhjlaFetLEqy8e/lDX4Ey+Ojdaooo1V0nnRxqrSvGhjFV7emkxVS8GfeHFotPAnXhwbbbBa6vEqBX/ixbHRUtVS8CdeHBstVS0Ff+LFsdEGq6WcaIPVUk60VLUU/IkXx0ZL5UvBn3hxbLTBaiknWqOKlqqWgj/x4thoqWop+BMvjo02WC31OFr4Ey+OjZbKl4I/8eLYaKl8KfgTLw6tpeBPvDg22mC1lBMt1Ts++BMvjo2WypeCP/Hi2GipfCn4Ey8OrS7gT7w4NlqjipbKl4I/8eLYaKl8KfgTL46NlsqXgj/x4thoqWop+BMvjo2W6h0f/IkXx0ZL5UvBn3hxbLRUvhT8iRfHRktVS8GfeHFstFTv+OBPvDg2WipfKtiJF160VL5UsHMpvGipfKlgp0c4tVSwAyEeR1uDnfHgRcvkS9VgJzF40TL5UnUxqmiZaqka7FQDL1qmWqoGO3vAi5bJl6rBTgjwomXypWowjr8XLZMvVYPR9p1aKhhA34uW6R1fDYa596Jl8qVqMBi9E20wvrwXLVUtFYwC70VLVUsFY7V70VL5UsGI6l60VL5UNO65Ey2VL0XFPa9U3PMajXvuREv1ji8a99yJlsqXisY9d6KlqqWicc+daKlqqWjccydaKl+KinteqbjnlYp7Xqm45zUa9/xxLRWNe+5ES/WOj4p7Xqm455WKe16puOeVinteo3HPH1cXVNzzSsU9r1Tc80rFPa9U3PNKxT2vVNzzSsU9r9G4549rKSrueaXinlcq7nml4p5XKu55peKe12jc88fP22jccydaqlqKinteqbjnlYp7Xqm455WKe16puOc1Gvf8cS0VjXvuREv1jo+Ke16puOeVinteqbjnlYp7XqNxzx9XF9G45060VO/4qLjnlYp7Xqm455WKe16puOeVinteo3HPH9dS0bjnTrRU7/iouOeNinveqLjnjYp73qi45+t/JaouGhX3vFFxzxsV97xRcc8bFfe8UXHPGxX3vFFxz1s07vnjWoqKe96ouOeNinveqLjnjYp73qi4542Ke96ouOeNinveqLjnjYp73qi4542Ke96ouOeNinveqLjnjYp73qi4542Ke96ouOeNinveqLjnjYp73qJxz51oqWopKu55o+KeNyrueaPinjcq7nmj4p43Ku55i8Y9d6KlqqWouOeNinveqLjnjYp73qi4542Ke96icc+daKl8KSrueaPinjcq7nmj4p43Ku55o+KeNyrueYvGPXeiNapoqWopKu55o+KeNyrueaPinrdo3HMnWipfiop73qi4542Ke96ouOeNinveqLjnjYp73qJxzx9HG4177kRLVUtRcc8bFfe8UXHPGxX3vFFxz1s07rkTLZUvFY17/jhaKu55o+KeNyrueaPinjcq7nmj4p63aNxzJ1oqXyoa99yJlqmW6lTc807FPe9U3PNOxT3vi1FFy+RL9WjccydaplqqU3HPOxX3vFNxzzsV97xTcc97NO65E61RRcvkS3Uq7nmn4p53Ku55p+KedyrueY/GPXeipfKlonHPnWiNqbqg4p53Ku55p+Kedyrueafinvdo3HMnWipfKhr33ImWqpai4p53Ku55p+KedyrueY/GPXeipfKlonHPnWipaikq7nmn4p53Ku55p+KedyrueY/GPXeipfKlonHPH0dLxT3vVNzzTsU971Tc807FPe9U3PMejXvuREvlS1FxzzsV97xTcc87Ffe8U3HPOxX3vFNxz3s07rkTLZUvRcU971Tc807FPe9U3PNOxT3v0bjnTrRUvhQV97xTcc87Ffe8U3HPOxX3vFNxzzsV97xH45470VL5UlTc807FPe9U3PNOxT3vVNzzTsU971Tc8x6Ne+5ES1VLUXHPOxX3vFNxzzsV97xTcc87Ffe8U3HPezTu+cNoBxX3fFBxzwcV93xQcc/HYlTRMvlSg4p7PqJxz51omXypQcU9H1Tc80HFPR9U3PNBxT0fVNzzQcU9H9G45060TL7UoOKeDyru+aDing8q7vmg4p4PKu75iMY9d6Kl8qWouOeDins+qLjng4p7Pqi454OKez6ouOcjGvfcidaooqWqpai454OKez6ouOeDins+qLjnIxr33ImWypeKxj13ojWmWoqKez6ouOeDins+qLjng4p7PqJxz51oqXypaNxzJ1qqWoqKez6ouOeDins+qLjnIxr33ImWypeKxj13oqWqpai454OKez6ouOeDins+qLjnIxr33ImWypeKxj1/HC0V93xQcc8HFfd8UHHPRzTuuRMtlS8VjXvuREvlS1FxzwcV93xQcc8HFfd8UHHPRzTuuROtUUVL5UtF45470VLVUlTc80HFPR9U3PMRjXvuREvlS0XjnjvRGlW0VLUUFfd8UHHPBxX3fFBxz2c07rkTLZMvNaNxz51omXypuRhRLTWpuOeTins+qbjnk4p7PqNxzx9HG4177kRLVUtF45472jL5UjMa99yJlqqWisY9d6Jl8qUmFfd8UnHPJxX3fFJxzycV93xScc9nNO754ydQNO65Ey3TO75JxT2fVNzzScU9n1Tc8xmMe95HukTbR7mNFr6Watdox5K8aNdvv0Sb+0/R3n642tJ+/3C1bLepgS+8XpcaU2q2UgNf0r0uNfD13+tSA18svi418JXl61IDX4a+LDX4fPnXpQa+wH1dalQNb6ZG1fBmakyp2UqNquHN1Kga3kyNquHN1Kga3kyNquGt1OCfEPC61Kga3kyNquHN1Kga3kyNKTVbqVE1vJkaVcObqVE1vJkaVcObqVE1vJUa/DMeXpcaVcObqVE1vJkaVcObqTGlZis1qoY3UxOrGnZ+841/4sWh0caqWb1oY5WhTrT4J158LdrHv5TFP/Hi0Ghj1X9etLFKOi9ao4o2VuHlrclUtRT+iReHRktVS+GfeHHkKoV/4sWh0VLVUvgnXhwaLVUthX/ixaHRBqulnGiD1VJOtFS1FP6JF4dGS+VL4Z94cWi0wWopJ9pgtZQTLVUthX/ixaHRUtVS+CdeHBptsFrKiTZYLeVES+RLlQX/xItDoyXypdZoiWqpNdpgtZQTrVFFS/SOb42W6B3fGi2RL7VGS+RLrdES+VJlwT/x4sjqAv/Ei0OjJXrHt0ZL5Eut0RpVtES+1BotkS+1RkvkS63REvlSa7RUtRT+iReHRkv0jm+NlsqXwj/x4tBojSpaKl8K/8SLQ6OlqqXwT7w4NFqqd3z4J14cGi2VLxXsxAsvWipfKti5FF60VL5UsNMjnFoq2IEQXrRU7/iCHdvgRBvsJAYvWipfKth5CV60VLVUsFMNvGipaqlgZw940VL5UsFOCPCipfKlgnH8vWipfKlgtH2nlgoG0PeiNapoqd7xBSPXe9FS+VLB+PJetFS1VDAKvBctVS0VjNXuRUvlSwUjqnvRUvlS0bjnTrRUvhQT93yNluodXzTuuRMt1Tu+aNxzJ1oqXyoa99yJlqqWisY9d6KlqqWicc+daKl8KSbu+RotlS/FxD1fo6XypaJxzx/XUtG45060VO/4mLjna7RUvhQT97wsTNzzNVoqXyoa9/xxdcHEPV+jNapoqXwpJu75Gi2VL8XEPV+jZfKlEhX3PEXjnj+spRIV9zxRcc/TYlTRMvlSiYp7nqi45yka99x53lLVUlTc80TFPU9U3PNExT1PVNzzRMU9T1Tc8xSNe/64lorGPXeiZXrHl6i454mKe56ouOeJinueqLjnKRr3/HF1EY177kTL9I4vUXHPExX3PFFxzxMV9zxRcc8TFfc8ReOeP66lonHPnWip3vFRcc8TFfc8UXHPExX3PFFxz1M07vnj6oKKe56ouOeJinueqLjniYp7nqi454mKe56ouOcpGvf8cS1FxT1PVNzzRMU9T1Tc80TFPU9U3PNExT1PVNzzRMU9T1Tc80TFPU9U3PNExT1PVNzzRMU9T1Tc80TFPU9U3PNExT1PVNzzRMU9T1Tc80TFPU/RuOdOtFS1FBX3PFFxzxMV9zxRcc8TFfc8UXHPExX3PEXjnjvRUtVSVNzzRMU9T1Tc80TFPU9U3PNExT1P0bjnTrRUvhQV9zxRcc8TFfc8UXHPExX3PFFxzzMV9zxH45470TL5UpmKe54Xo4qWyZfKVNzzTMU9z9G45060TL5UpuKeZyrueabinmcq7nmm4p5nKu55puKe52jccydaJl8qU3HPMxX3PFNxzzMV9zxTcc8zFfc8R+OeO9FS+VLRuOdOtFS1FBX3PFNxzzMV9zxTcc8zFfc8R+OeO9FS+VLRuOdOtFS1FBX3PFNxzzMV9zxTcc9zNO65Ey2VLxWNe+5ES1VLUXHPMxX3PFNxzzMV9zxTcc9zNO65Ey2VLxWNe+5Ea0y1FBX3PFNxzzMV9zxTcc9zNO7542ijcc+daKl8KSrueabinmcq7nmm4p5nKu55puKe52jccydaKl8qGvfciZaqlqLinmcq7nmm4p5nKu55jsY9d6Kl8qWicc+daKlqKSrueabinmcq7nmm4p5nKu55jsY9d6Kl8qWicc+daKlqKSrueabinmcq7nmm4p5nKu55jsY9d6Kl8qWouOeZinueqbjnmYp7Xqi454WKe16ouOclGvfcidaoomWqpQoV97xQcc8LFfe8UHHPSzTuuRMtky9VqLjnhYp7Xqi454WKe16ouOeFinteqLjnJRr3/HG00bjnTrRUtRQV97xQcc8LFfe8UHHPCxX3vFBxz0s07rkTLVUtRcU9L1Tc80LFPS9U3PNCxT0vVNzzQsU9L9G45060VLUUFfe8UHHPCxX3vFBxzwsV97xQcc9LNO65Ey2VL0XFPS9U3PNCxT0vVNzzQsU9L1Tc80LFPS/RuOdOtFS+FBX3vFBxzwsV97xQcc8LFfe8UHHPSzTuuRMtlS9FxT0vVNzzQsU9L1Tc80LFPS9U3PNCxT0v0bjnTrRUvhQV97xQcc8LFfe8UHHPCxX3vFBxz0s07vnjaKNxz51oqXwpKu55oeKeFyrueaHinhcq7nmh4p6XaNxzJ1oqXyoa99yJlqqWouKeFyrueaHinhcq7nmJxj13oqXypaJxz51omWopo+KeGxX33Ki450bFPbfFqKJl8qUsGvfciZbJlzIq7rlRcc+NintuVNxzi8Y9d6Jl8qUsGvfciZbJlzIq7rlRcc+NintuVNxzo+KeWzTuuRMtlS8VjXvuRGtU0VLVUlTcc6PinhsV99yicc8fRxuNe+5ES+VLReOeO9FS1VJU3HOj4p4bFffcqLjnFo177kRL5UtF45470VL5UlTcc6PinhsV99youOdGxT23aNxzJ1oqX4qKe27RuOePtY3GPXeipaqlonHPnWiNKloqX4qKe25U3HOj4p4bFffcqLjnRsU9t2jc88dPoGjccydao4qWqpai4p4bFffcqLjnFox73ke6RNtHuYkWnns+yke0dXjRrt9+iTb3n6K9/XC1pf3+4WrZblODXni9MDXoVdoLU4Ne0r0wNabUbKUGvVh8YWrQK8sXpga9DH1hatBr1hemBr3AfV1q4Mn1L0yNquHN1Kga3kyNquHN1JhSs5UaVcObqVE1vJkaVcObqVE1vJkaVcNbqYE/e+CFqVE1vJkaVcObqVE1vJkaU2q2UqNqeDM1qoY3U6NqeDM1qoY3U6NqeCM1Ff70iBemRtXwZmpUDW+mRtXwZmosVGoe/+a7wp94cWy0sWpWL9pYZagXbazK8vEvZSv8iReHRgt/4sWx0cYq6bxoY1VpXrSxCi9nTYY/8eLYaKlqKfgTL46NNlgt5axSVLUU/IkXh0YLf+LFsdFS1VLwJ14cG22wWsqJ1qiipaql4E+8ODZaKl8K/sSLY6MNVks9jhb+xItjo6WqpeBPvDg2WqpaCv7Ei2OjDVZLOdEGq6WcaKl8KfgTL46NlsqXgj/x4tBaCv7Ei2OjDVZLOdFSveODP/Hi2GipfCn4Ey+OjZbKl4I/8eLY6oKqloI/8eLYaKl8KfgTL46NlsqXgj/x4thoqXwp+BMvjo2WqpaCP/Hi2Gip3vHBn3hxbLRUvhT8iRfHRkvlS8GfeHFstFS1FPyJF8dGS/WOD/7Ei2OjpfKlgp144UVL5UsFO5fCi5bKlwp2eoRTSwU7EMKLluodX7BjG7xoqXypYIcrONEGOy/Bi5aqlgp2qoEXLVUtFezsAS9aKl8q2AkBXrRUvlQwjr8XLZUvFYy279RSwQD6XrRU7/iCYe69aI0qWipfKhhf3ouWqpYKRoH3omWqpVowVrsXLZMv1YIR1b1omXyp9flEFS2TL9WouOeNinveonHPnWiZ3vG1aNxzJ1omX6pF45470VLVUtG45060VLVUNO65Ey2TL9WouOeNinveqLjnjYp73qJxzx/XUtG45060RhUt0zu+RsU9b1Tc80bFPW9U3PMWjXv+uLqg4p43Ku55o+KeNyrueaPinjcq7nmj4p43Ku55i8Y9f1xLUXHPGxX3vFFxzxsV97xRcc8bFfe8ReOeP37eRuOeO9FS1VJU3PNGxT1vVNzzRsU9b1Tc80bFPW/RuOePa6lo3HMnWqp3fFTc80bFPW9U3PNGxT1vVNzzFo17/ri6iMY9d6KlesdHxT1vVNzzRsU9b1Tc80bFPW9U3PMWjXv+uJaKxj13ojWqaKl8KSrueaPinjcq7nmj4p63aNzzx9UFFfe8UXHPGxX3vFFxzxsV97xRcc8bFfe8UXHPWzTu+eNaiop73qi4542Ke96ouOeNinveqLjnjYp73qi4542Ke96ouOedinveqbjnnYp73qm4530xqmiZfKlOxT3vVNzzTsU971Tc807FPe9U3PNOxT3v0bjnTrTGVF1Qcc87Ffe8U3HPOxX3vFNxzzsV97xTcc97NO65Ey1VLUXFPe9U3PNOxT3vVNzzTsU971Tc8x6Ne+5ES+VLUXHPOxX3vFNxzzsV97xTcc87Ffe8U3HPezTu+eNoo3HPnWipaikq7nmn4p53Ku55p+Ke92jccydaKl+KinveqbjnnYp73qm4552Ke96puOedinveo3HPnWipfCkq7nmn4p53Ku55p+Kedyrueafinvdo3HMnWqOKlsqXouKedyrueafinncq7nmn4p53Ku55j8Y9d6Kl8qWicc+daKlqKSrueafinncq7nmn4p73aNxzJ1oqXyoa99yJlqqWouKedyrueafinncq7nmn4p73aNzzx9FG45470VL5UlTc807FPe9U3PNOxT3vVNzzHo177kRL5UtF454/jHZQcc8HFfd8UHHPBxX3fCxGFS2TLzWicc+daJl8qRGNe+5ES1VLUXHPBxX3fFBxzwcV93xE45470TL5UiMa99yJlqqWouKeDyru+aDing8q7vmg4p6PaNxzJ1qjipbKl6Ling8q7vmg4p4PKu75oOKeDyru+YjGPXeipfKlqLjng4p7Pqi454OKez6ouOeDins+qLjnIxr33ImWypei4p4PKu75oOKeDyru+aDino9o3HMnWipfiop7Pqi454OKez6ouOeDins+qLjng4p7PqJxz51oqXwpKu75oOKeDyru+aDing8q7vmg4p4PKu75iMY9d6KlqqWouOeDins+qLjng4p7Pqi454OKez6ouOcjGvfciZaqlqLing8q7vmg4p4PKu75oOKeDyru+YjGPXeiNapoqWopKu75oOKeDyru+aDing8q7vmg4p6PaNxzJ1oqX4qKez6ouOeDins+qLjng4p7Pqi45zMa99yJlsmXmlTc80nFPZ+LUUXL5EtNKu75pOKeTyru+YzGPX8cbTTuuRMtVS1FxT2fVNzzScU9n1Tc80nFPZ/RuOdOtEy+1IzGPX8cLRX3fFJxzycV93xScc8nFfd8UnHPZzTuuRMtlS8VjXvuREtVS1FxzycV93xScc8nFfd8RuOeO9FS+VLRuOdOtFS1FBX3fFJxzycV93xScc8nFfd8RuOeO9EaVbRUvhQV93xScc8nFfd8UnHPZzTuuRMtlS8VjXvuREvlS1FxzycV93xScc8nFfd8UnHPZzTu+eNoo3HPnWipfKlo3HMnWqpaiop7Pqm455OKez6jcc+daKl8qWjc88fRRuOeO9FS1VJU3PNJxT2fVNzzScU9n9G45060VL5UNO65Ey2VL0XFPZ9U3PNJxT2fVNzzScU9n9G45060VL4UFfd8RuOeO9pS+VLRuOdOtFS1VDTuuRMtlS9FxT2fVNzzScU9n1Tc80nFPZ9M3HNbonHPHz2B1miJ3vGt0RK941ujJaql1miNKlqid3xrtETv+NZoY9VSfaRLtH2U22jha6nZLn96pupFu377Jdrcf4r29sPVlsufrpbtNjXwhdfLUoNPVH9dauBLutelBr7+e11q4IvF16XGlJqt1MCXoa9LDXzN+rrUwBe4r0uNquHN1Kga3koNPhP/dalRNbyZGlXDm6lRNbyZGlNqtlKjangzNaqGN1OjangzNaqGN1OjangrNfinGrwuNaqGN1OjangzNaqGN1NjSs1WalQNb6ZG1fBmalQNb6ZG1fBmalQNb6UG/1yK16VG1fBmamJVw85vvvFPvDg0WqOKNlYZ6kUbq7J0fimLf+LFodHGqv+8aGOVdE60+CdeHBptrMLLWZPxT7w4NFqqWgr/xItDow1WSzmrFFUthX/ixaHRUtVS+CdeHBkt/okXh0YbrJZyog1WSznRUtVS+CdeHBotlS+Ff+LFodEGq6WcaIPVUk60VLUU/okXh0ZLVUvhn3hxaLTBaiknWqOKlsqXwj/x4tBoqXwp/BMvjqyl8E+8ODJa/BMvDo2W6h0f/okXh0ZL5Uvhn3hxaLRUvhT+iRdHVhf4J14cGi3VOz78Ey+OjBb/xItDo6XypfBPvDg0WipfCv/Ei0Ojpaql8E+8ODRaqnd8+CdeHBotky+V8E+8ODRaJl8q4Z94cWi0TLVUWowqWqZ3fAn/xItDo2XypVKwEy+8aJl8qRTsXAovWiZfKgU7PcKppYIdCOFFa1TRMvlSKdhJDF60TL5UCnZeghctVS0V7FQDL1qqWirY2QNetFS+VLATArxoqXypYBx/L1oqXyoYbd+ppYIB9J1ogzHxvWip3vEFI9d70VL5UsH48l60VLVUMAq8Fy1VLRWM1e5FS+VLBSOqe9FS+VLRuOdOtFS+FBX3PFFxz1M07rkTLdU7vmjccydaKl8qGvfciZaqlorGPXeipaqlonHPnWipfCkq7nmi4p4nKu55ouKep2jc88e1VDTuuRMt1Ts+Ku55ouKeJyrueaLinicq7nmKxj13qguqWoqKe56ouOeJinueqLjniYp7nqi454mKe56icc8f11JU3PNExT1PVNzzRMU9T1Tc80TFPU/RuOePn7fRuOdOtFS1FBX3PFFxzxMV9zxRcc8TFfc8UXHPUzTu+eNaKhr33ImW6h0fFfc8UXHPExX3PFFxzzMV9zxH454/rC5yNO65Ey3TO768GFW0TL5UpuKeZyrueabinmcq7nmOxj1/XEtF45470TK948tU3PNMxT3PVNzzTMU9z1Tc8xyNe+5UF1S1FBX3PFNxzzMV9zxTcc8zFfc8U3HPMxX3PEfjnj+upai455mKe56puOeZinueqbjnmYp7nqm455mKe56puOeZinueqbjnmYp7nqm455mKe56puOeZinueqbjnmYp7nqm455mKe56puOeZinueqbjnORr33ImWqpai4p5nKu55puKeZyrueabinmcq7nmm4p7naNxzJ1qqWoqKe56puOeZinueqbjnmYp7nqm45zka99yJlsqXouKeZyrueabinmcq7nmm4p5nKu55puKe52jccydaKl+KinueqbjnmYp7nqm455mKe56jcc+daKl8KSrueabinmcq7nmm4p5nKu55puKeZyrueY7GPXeiNapoqWopKu55puKeZyrueabinhcq7nmJxj13omXypUo07rkTrRHVUoWKe16ouOeFinteqLjnhYp7XqJxz51omXypEo177kRLVUtRcc8LFfe8UHHPCxX3vETjnjvRUvlS0bjnTrRUtRQV97xQcc8LFfe8UHHPCxX3vETjnjvRUvlS0bjnj6Ol4p4XKu55oeKeFyrueaHinpdo3HMnWipfKhr33ImWqpai4p4XKu55oeKeFyrueaHinpdo3HMnWipfKhr33ImWqpai4p4XKu55oeKeFyrueYnGPXeipfKlonHPnWipaikq7nmh4p4XKu55oeKeFyrueYnGPXeipfKlonHPnWiNqZai4p4XKu55oeKeFyrueaHinpdo3HMnWipfiop7Xqi454WKe16ouOeFinteqLjnhYp7XqJxzx9HG4177kRLVUtRcc8LFfe8UHHPCxX3vETjnjvRUvlSVNzzQsU9L1Tc80LFPS9U3PNCxT0vVNzzEo177kRL5UtRcc8LFfe8UHHPjYp7blTcc6PinhsV99wWo4qWqZYyKu65UXHPjYp7blTcc6PinhsV99youOcWjXvuRGtMtRQV99youOdGxT03Ku65UXHPjYp7btG45060VL4UFffcqLjnRsU9NyruuVFxz42Ke25U3HOLxj13oqXypai450bFPTcq7rlRcc+NintuVNxzi8Y9d6Kl8qWouOdGxT03Ku65UXHPjYp7blTcc6Pinls07rkTLZUvRcU9NyruuVFxz42Ke25U3HOj4p5bNO65Ey2VLxWNe+5ES1VLUXHPjYp7blTcc6PinhsV99yicc+daKl8qWjccydaqlqKintuVNxzo+KeGxX33KJxz51oqXypaNxzJ1qqWoqKe25U3HOj4p4bFffcqLjnFo177kRL5UtF45470RpTLUXFPTcq7rlRcc8tGvfciZbKl4rGPXeipfKlqLjnRsU9NyruuVFxz42Ke27RuOdOtFS+VDTu+cNoazTuuRMtUy1VqbjnlYp7XhejipbJl6rRuOdOtEy+VI3GPXeipaqlqLjnlYp7Xqm455WKe16jcc+daJl8qRqNe+5Ey+RLVSrueaXinlcq7nml4p5XKu55jcY9d6I1qmipaqlo3HNHWypfKhr33ImWqpaKxj13oqXypai455WKe16puOeVinteqbjnlYp7XqNxz50nENU7PirueaXinlcq7nml4p5XKu55DcY97yNdou2j3EaLXkvN2q/RjsWLNl8/bbn/FO3th9fn0SWR6/Jlt6lBL7xemBr0Ku2FqUEv6V6XGnhW+wtTg14svjA16JXlC1ODXoa+MDWm1GylBr3AfWFqVA1vpkbV8GZqVA1vpkbV8FZq4Gn7L0yNquHN1Kga3kyNquHN1JhSs5UaVcObqVE1vJkaVcObqVE1vJkaVcNbqYE/L+GFqVE1vJkaVcObqVE1vJkaU2q2UqNqeDM1qoY3U6NqeDM1qoY3U6NqeCs18CdefC01zm++4U+8ODbaWDWrF22sMtSL1mJF+/iXsvAnXhwbbaz6z4s2VknnRRurSvOijVV4OWsy/IkXx0ZLVUvBn3hxbLTBaqnHqxT8iRfHRktVS8GfeHFstFS1FPyJF8dGG6yWehhtgz/x4thomWqpBn/ixbHRMvlS63+lijZYLeVEG6yWcqJlqqUa/IkXx0ZLVUvBn3hxbLTBaikn2mC1lBMtky/V4E+8ODZaJl+qwZ94cWgtBX/ixbHRBqulnGiZ3vE1+BMvjo2WypeCP/Hi2GipfCn4Ey8OrS7gT7w4Nlqmd3wN/sSLY6Ol8qXgT7w4NFr4Ey+OjZbKl4I/8eLYaKlqKfgTL46NluodH/yJF8dGS+VLwZ94cWy0VL4U/IkXx0ZLVUvBn3hxbLRU7/jgT7w4NloqXyrYiRdetFS+VLBzKbxoqXypYKdHOLVUsAMhvGip3vEFO7bBi9aooqXypYKdl+BFS1VLBTvVwIuWqpYKdvaAFy2VLxXshAAvWipfKhjH34uWypcKRtt3aqlgAH0vWqp3fMEw9060wcj1XrRUvlQwvrwXLVUtFYwC70VLVUsFY7V70VL5UsGI6l60VL5UNO65Ey2VL0XFPW9U3PMWjXvuREv1ji8a99yJlsqXisY9d6KlqqWicc+daKlqqWjccydaKl+KinveqLjnjYp73qi45y0a9/xxLRWNe/4w2h6Ne+5Ey/SOr1NxzzsV97wvRhUtky/Vo3HPH1YXnYp73qm4552Ke96puOedinveqbjnnYp73qm45z0a9/xxLUXFPe9U3PNOxT3vVNzzTsU971Tc8x6Ne/74eRuNe+5Ea1TRMr3j61Tc807FPe9U3PNOxT3vVNzzHo17/riWisY9d6KlesdHxT3vVNzzTsU971Tc807FPe/RuOePq4to3HMnWqp3fFTc807FPe9U3PNOxT3vVNzzTsU979G4549rqWjc88fRUnHPOxX3vFNxzzsV97xTcc87Ffe8R+OeP64uqLjnnYp73qm4552Ke96puOedinveqbjnnYp73qNxzx/XUlTc807FPe9U3PNOxT3vVNzzTsU971Tc807FPe9U3PNOxT3vVNzzTsU971Tc807FPe9U3PNOxT3vVNzzTsU971Tc807FPe9U3PNOxT3vVNzzHo17/jhaKu55p+Kedyrueafinncq7nmn4p53Ku55p+Ke92jccydaplpqUHHPBxX3fFBxzwcV93wsRhUtky81onHPnWiZfKlBxT0fVNzzQcU9H1Tc80HFPR9U3PNBxT0f0bjnTrRMvtSg4p4PKu75oOKeDyru+aDino9o3HMnWipfiop7Pqi454OKez6ouOeDins+qLjng4p7PqJxz51oqXwpKu75oOKeDyru+aDing8q7vmg4p6PaNzzx9FG45470VL5UlTc80HFPR9U3PNBxT0fVNzzQcU9H9G45060VL5UNO65Ey1VLUXFPR9U3PNBxT0fVNzzEY177kRL5UtF45470VLVUlTc80HFPR9U3PNBxT0fVNzzEY177kRL5UtF45470VLVUlTc80HFPR9U3PNBxT0f0bjnTrRGFS2VL0XFPR9U3PNBxT0fVNzzQcU9H1Tc8xGNe+5ES+VLReOeO9FS1VJU3PNBxT0fVNzzQcU9H9G45060VL5UNO65Ey1VLUXFPR9U3PNBxT0fVNzzQcU9H9G45w+jndG45060TL7UpOKeTyru+VyMKlomX2pScc8nFfd8RuOeO9Ey+VKTins+qbjnk4p7Pqm455OKez6puOeTins+o3HPnWiZfKlJxT2fVNzzScU9n1Tc80nFPZ/RuOdOtFS+FBX3fFJxzycV93xScc8nFfd8UnHPJxX3fEbjnjvRGlW0VLUUFfd8UnHPJxX3fFJxzycV93xScc9nNO65Ey1VLUXFPZ9U3PNJxT2fVNzzScU9n1Tc80nFPZ/RuOdOtFS1FBX3fFJxzycV93xScc8nFfd8UnHPZzTu+eNoo3HPnWipaikq7vmk4p5PKu75pOKeTyru+aTins9o3HMnWipfiop7Pqm455OKez6puOeTins+qbjnMxr33ImWypei4p5PKu75pOKeTyru+aTink8q7vmk4p7PaNxzJ1oqX4qKez6puOeTins+qbjnk4p7Pqm45zMa99yJ1qiipfKlqLjnk4p7Pqm455OJe14XJu75Gi2RL7VGS+RLrdES+VJrtEYVLVEttUZL9I5vjZbIl1qjJfKl1miJfKm6ROOeO9ES+VJrtES+1BotVS3FxD1foyV6x7dGS+RLrdES+VJrtES+1BotlS8VjXvuREvlSzFxz9doid7xrdEaVbRUvlQ07rkTLZUvFY177kRL5Usxcc/XaKlqKSbu+RotlS/FxD1fo6XypaJxz51oqXypaNxzJ1qqWoqJe75GS/WOj4l7vkZL5UtF45470VL5UtG45060VLUUE/d8jZbqHR8T93yNlsqXisY9d6Kl8qWicc+daKl8KSbu+Rot1Ts+Ju75Gi2VL8XEPV+jpfKlonHPnWipaqlo3HNHWypfKhr33ImWqpaKxj13oqXypZi452u0VLUUE/d8jZbqHR8T93yNlqqWisY9d55AVO/4mLjna7RUtRQT93yNluodHxP3fI02Vi3VR7pE20e5jdawo81Lvsw/L1a8aPM1N5b7T9Hefrja0n7/cLVst6kBL7xemRrwKu2VqQEv6V6ZGvD675WpAS8WX5gadAr8K1MDXoa+MjXgNesrUwNe4L4yNabUbKVG1fBmalQNb6ZG1fBmalQNb6ZG1fBGahI6x/+VqVE1vJkaVcObqVE1vJkaU2q2UqNqeDM1qoY3U6NqeDM1qoY3U6NqeCs16CcxvDI1qoY3U6NqeDM1qoY3U2NKzVZqVA1vpkbV8GZqVA1vpiZWNfz4N98J/cSLY6NFP/Hi4GhjlaFetLEqy8e/lE3oJ14cHK1RRRurpPOijVWledHGKry8NZmqlkI/8eLYaNFPvDg42mC11ONVCv3Ei4Ojpaql0E+8ODhaqloK/cSLg6MNVks50QarpZxoqWop9BMvDo6WypdCP/Hi4GiD1VJOtEYVLVUthX7ixcHRUtVS6CdeHBxtsFrqcbToJ14cHC2VL4V+4sXB0VL5UugnXhxbS6GfeHFwtMFqKSdaqnd86CdeHBwtlS+FfuLFwdFS+VLoJ14cW12gn3hxcLRGFS2VL4V+4sXB0VL5UugnXhwcLZUvhX7ixcHRUtVS6CdeHBwt1Ts+9BMvDo6WypdCP/Hi4GipfCn0Ey8OjpaqlkI/8eLgaKne8aGfeHFwtFS+VLATL7xoqXypYOdSeNFS+VLBTo9waqlgB0I40QY748GLlsqXCnYSgxctlS8V7LwEL1qqWirYqQZetFS1VLCzB7xomXypHOyEAC9aJl8qB+P4e9Ey+VLrXyCqpXIwgL4XLdM7vhwMc+9Fy+RL5WAweifaYHx5L1qqWioYBd6LlqqWCsZq96Jl8qVyMKK6Fy2TL5Wjcc+daKl8KSrueabinudo3HMnWqZ3fDka99yJlsqXisY9d6KlqqWicc+daKlqqWjccydaKl+KinueqbjnmYp7nqm45zka9/xxLRWNe+5ES/WOj4p7nqm455mKe56puOeZinueo3HPH1cXVNzzTMU9z1Tc80zFPc9U3PNMxT3PVNzzTMU9z9G4549rKSrueabinmcq7nmm4p5nKu55puKe52jc88fP22jccydaqlqKinueqbjnmYp7nqm455mKe56puOc5Gvf8cS0VjXvuREv1jo+Ke56puOeZinueqbjnmYp7nqNxzx9XF9G45060VO/4qLjnmYp7nqm455mKe56puOeZinueo3HPH9dS0bjnTrRU7/iouOeZinueqbjnmYp7nqm45zka9/xxdUHFPc9U3PNMxT3PVNzzTMU9L1Tc80LFPS9U3PMSjXv+sJYqi1FFy/SOr1BxzwsV97xQcc8LFfe8UHHPCxX3vFBxzwsV97xQcc8LFfe8UHHPCxX3vFBxzwsV97xQcc8LFfe8UHHPCxX3vFBxzwsV97xQcc9LNO65Ey1VLUXFPS9U3PNCxT0vVNzzQsU9L1Tc80LFPS/RuOdOtFS1FBX3vFBxzwsV97xQcc8LFfe8UHHPSzTuuRMtlS9FxT0vVNzzQsU9L1Tc80LFPS9U3PNCxT0v0bjnTrRGFS1VLUXFPS9U3PNCxT0vVNzzEo177kRL5UtRcc8LFfe8UHHPCxX3vFBxzwsV97xQcc9LNO7542ijcc+daKlqKSrueaHinhcq7nmh4p4XKu55icY9d6Kl8qWicc8fR0vFPS9U3PNCxT0vVNzzQsU9L1Tc8xKNe+5ES+VLReOeO9FS1VJU3PNCxT0vVNzzQsU9L9G45060VL5UNO65Ey1VLUXFPS9U3HOj4p4bFffcqLjnFo177kRrVNEy+VJGxT03Ku65UXHPjYp7blTcc4vGPXeiZfKlLBr33InWmKoLKu65UXHPjYp7blTcc6Pinls07rkTLZUvFY177kRLVUtRcc+NintuVNxzo+KeWzTuuRMtlS8VjXvuREtVS1Fxz42Ke25U3HOj4p4bFffconHPnWipfKlo3PPH0VJxz42Ke25U3HOj4p4bFffcqLjnFo177kRL5UtRcc+NintuVNxzo+KeGxX33Ki450bFPbdo3HMnWipfiop7blTcc6PinhsV99youOcWjXvuREvlS1Fxz42Ke25U3HOj4p4bFffcqLjnRsU9t2jccydaKl+KintuVNxzo+KeGxX33Ki450bFPTcq7rlF45470VLVUlTcc6PinhsV99youOdGxT03Ku65UXHPLRr3/HG0VNxzo+KeGxX33Ki450bFPTcq7rlRcc8tGvfciZbKl6Linlcq7nml4p5XKu55peKe18WoomXypWo07rkTLZMvVam455WKe16puOeVinteqbjnlYp7XqNxz51omXypSsU9r1Tc80rFPa9U3PNKxT2vVNzzSsU9r9G45060RhUtVS1FxT2vVNzzSsU9r1Tc80rFPa/RuOdOtFS+VDTuuROtMdVSVNzzSsU9r1Tc80rFPa9U3PMajXvuREvlS0XjnjvRUtVSVNzzSsU9r1Tc80rFPa/RuOdOtFS+VDTuuRMtVS1FxT2vVNzzSsU9r1Tc80rFPa/RuOdOtFS+VDTu+eNoqbjnlYp7Xqm455WKe16jcc+daKl8qWjccydaKl+KinteqbjnlYp7Xqm455WKe16jcc+daI0qWipfKhr33ImWqpai4p5XKu55peKe12jccydaKl8qGvfcidaooqWqpai455WKe16puOeVinteo3HPnWipfKlo3HMnWipfiop7Xqm455WKe16puOeVinteo3HPH0bbonHPnWiZaqkWjXvuaMvkS63/lSpaplqqReOeO9Ey+VKNinveqLjnjYp73qi4542Ke96ouOctGvf88RMoGvfciZbpHV+j4p43Ku55o+KeNyrueQvGPe/j8un1H8tttOi1lKV2mYm50Y5++fBcPv7yOr17s/64DlJrnz7d73149Hz58Jj98YdzbfMy57Wg+fzh33KOXtFFzLkp56fnHL26jZhz9Bo7Ys7RK/2IOUffb0TMOfquJ2DO4c9JiJhz9B1gxJxrH3p+zrUPPT/nppyfnnPtQ8/Pufah5+dc+9Dzc6596Pk51z709JzDnzHzjjkf9TrnmcrjD48+LgKN8fOHfxNIm1ZwgbTDfbFA68uRSzaaNWcaVpdxmYfVfGdF1O45lp4mPbEXUG3jwQXSnj/Wiig/IZae8irAF1AZG9gCwZ8OF14ga5efMw+by61AckHA7yC5IOACydYIVfTBH4woPb+mp1wQ8AVULgi4QLI1Yq2IsjVi6SkXBHsBhT/XlV4guSDYNhX86bn0d5BcEHCBTAJFKvrgT2GWnl/TUy4I+AIqFwRcINkasVZE2Rqh9IQ/kZ19AYU/RJ5eILkg2DZVlwsCfgeZBMIWSLZGrKJPtkYsPeWCgC+gckHABZKtEWpFHLI1YukpFwR7AR1yQcAFkguCbVMNk0DYd5BcEHCBZGvEKvpka8TSUy4I+AIqFwRboClbI9SKOGVrxNJTLgj4AioXBFwgk0DQNtWUCwJ+B8kFARdItkasok+2Riw95YJAL6B9kQsCLpBsjUgrYl9ka8TSUy4I+AJqEghbILkg0DZVX+SCgN9BckHABZKtEavok60RSs8kFwR7AU1yQcAFkq0Ra0WUrRFLT5Oe2AuoXBBwgeSCYNtUSS4I+B0kFwRcINkaoYq+LFsjlp5yQbAX0CwXBFwg2RqxVkSTnqH0lAsCvoDKBQEXSC4Itk2V5YKA30FyQbAFKrI1QhV9RbZGLD3lgoAvoHJBwAUyCRRqRZStEUtPuSDgC6hcEHCB5IJg21RFLgj2HWRyQcAFkq0Rqugz2Rqx9JQLAr6AmgTCFki2RqwVUbZGLD3lgoAvoHJBwAWSC4JtU1W5INh3UJULAi6QbI1QRV+VrRFLT5Oe2AuoXBBwgWRrxFoRZWvE0lMuCPgCKhcEW6AmFwTbpmpyQcDvILkg4ALJ1ghV9DWTnqH0lAsCvoDKBQEXSLZGrBVRtkYsPeWCYC+gXS4IuEByQbBtqi4XBPwOkgsCLpBJoEhFX5etEUtPuSDgC6hcEHCBZGvEWhFla4TSc8gFwV5Ah1wQcIHkgmDbVEMuCPgdZBIIWyDZGrGKPtkasfSUCwK+gMoFARdItkaoFXHK1oilp1wQ7AV0ygUBF0guCLZNNU0CYd9BckHABZKtEavok60RS0+5IOALqFwQaIHGIlsj0oo4FtkasfSUCwK+gMoFARfIJBCyTTUWuSDgd5BcEHCBZGvEKvpka8TSUy4I9gKa5IKACyRbI9SKmGRrxNJTLgj4AmoSCFsguSDYNlWSC3K4QKWkSzpK+fkp9FvOZWwcf1PUdlmIckt3HuUyH87PuQyC03Oetec/P+faxp+fc221z8+5tsPn59yU89Nzrk3r+TnXPvT8nGsfen7OtQ89P+fah56e86J96Pk51z70/JxrH3p+zrUPPT/nppyfnnPtQ4/P+ZFvt4s2reACaYf7YoGO/UFW0e45lp7amWMvoKZtPLhA2vOHWhFNfkIsPeVVgC+gJoGwBZIL8mKBnJ+Qm1wQ8DtILgi4QLI1YhV9sjVC6VnlgmAvoFUuCLhAsjVirYiyNWLpadITewGVCwIukFwQbJuqygUBv4PkgoALJFsjVNHXZGvE0lMuCPYC2uSCgAskWyPWimjSM5SeckHAF1C5IOACyQXBtqmaXBDwO0guCLZAXbZGqKKvy9aIpadcEPAFVC4IuEAmgUKtiLI1YukpFwR8AZULAi6QXBBsm6rLBcG+g4ZcEHCBZGuEKvqGbI1YesoFAV9ATQJhCyRbI9aKKFsjlp5yQcAXULkg4ALJBcG2qaZcEOw7aMoFARdItkaoom/K1oilp0lP7AVULgi4QLI1Yq2IsjVi6SkXBHwBlQsCLdBc5IJA21RzkQsCfgfJBQEXSLZGpKJvLiY9Q+kpFwR8AZULAi6QbI1YK6JsjVh6ygXBXkCTXBBwgeSCYNtUSS4I+B0kFwRcIJNAkYq+JFsjlp5yQcAXULkg4ALJ1oi1IsrWCKVnlguCvYBmuSDgAskFwbapslwQ8DvIJBC2QLI1YhV9sjVi6SkXBHwBlQsCLpBsjVArYpGtEUtPuSDYC2iRCwIukFwQbJuqmATCvoPkgoALJFsjVtEnWyOWnnJBwBdQuSDYAplsjVArosnWiKWnXBDwBVQuCLhAJoGgbSqTCwJ+B8kFARdItkasok+2Riw95YJgL6BVLgi4QLI1Qq2IVbZGLD3lgoAvoCaBsAWSC4JtU1W5IOB3kFwQcIFka8Qq+mRrhNKzyQXBXkCbXBBwgWRrxFoRZWvE0tOkJ/YCKhcEXCC5INg2VZMLAn4HyQUBF0i2Rqiir8vWiKWnXBDsBbTLBQEXSLZGrBXRpGcoPeWCgC+gckHABZILgm1Tdbkg4HeQXBBsgYZsjVBF35CtEUtPuSDgC6hcEHCBTAKFWhFla8TSUy4I+AIqFwRcILkg2DbVkAuCfQdNuSDgAsnWCFX0TdkasfSUCwK+gJoEwhZItkasFVG2Riw95YKAL6ByQcAFkguCbFO1ZZELgnwHrQLJBQEXSLZGoKJv1VO2Riw9TXpiL6ByQcAFkq0Ra0WUrRFLT7kg4AuoXBBsgZJcEGybKskFOVygUtIlHaX8/BT6LecyNo6/KWq7LES5pdtHeZL5cH7OTTk/Pefa85+fc23jz8+5ttrn51zb4fNzrh3u6TnP2rSen3PtQ8/Pufah5+dc+9Dzc27K+ek51z70/JxrH3p+zrUPPT/n2oeen3PtQ0/PedE+9PicH/l2u2jTCi6QdrgvFujYH2QV7Z5j6WnSE3sB1TYeXCDt+WOtiPITYukprwJ8AZWxgS2QyQV5sUDOT8hNLgj4HSQXBFwg2Rqhij4z6RlKT7kg4AuoXBBwgWRrxFoRZWvE0lMuCPYCWuWCgAskFwTbpqpyQcDvILkg4AKZBIpU9FXZGrH0lAsCvoDKBQEXSLZGrBVRtkYoPZtcEOwFtMkFARdILgi2TdXkgoDfQSaBsAWSrRGr6JOtEUtPuSDgC6hcEHCBZGuEWhG7bI1YesoFwV5Au1wQcIHkgmDbVN0kEPYdJBcEXCDZGrGKPtkasfSUCwK+gMoFwRZoyNYItSIO2Rqx9JQLAr6AygUBF8gkELRNNeSCgN9BckHABZKtEavok60RS0+5INgL6JQLAi6QbI1QK+KUrRFLT7kg4AuoSSBsgeSCYNtUUy4I+B0kFwRcINkasYo+2RqR9EyLXBDoBTQtckHABZKtEWtFlK0RS0+TntgLqFwQcIHkgkDbVGmRCwJ+B8kFARdItkaooi/J1oilp1wQ7AU0yQUBF0i2RqwV0aRnKD3lgoAvoHJBwAWSC4JtUyW5IOB3kFwQbIGybI1QRV+WrRFLT7kg4AuoXBBwgUwChVoRZWvE0lMuCPgCKhcEXCC5INg2VZYLgn0HFbkg4ALJ1ghV9BXZGrH0lAsCvoCaBMIWSLZGrBVRtkYsPeWCgC+gckHABZILgm1TmVwQ7DvI5IKACyRbI1TRZ7I1Yulp0hN7AZULAi6QbI1YK6JsjVh6ygUBX0DlgmALVOWCYNtUVS4I+B0kFwRcINkaoYq+atIzlJ5yQcAXULkg4ALJ1oi1IsrWiKWnXBDsBbTJBQEXSC4Itk3V5IKA30FyQcAFMgkUqehrsjVi6SkXBHwBlQsCLpBsjVgromyNUHp2uSDYC2iXCwIukFwQbJuqywUBv4NMAmELJFsjVtEnWyOWnnJBwBdQuSDgAsnWCLUiDtkasfSUC4K9gA65IOACyQXBtqmGSSDsO0guCLhAsjViFX2yNWLpKRcEfAGVC4It0JStEWpFnLI1YukpFwR8AZULAi6QSSBom2rKBQG/g+SCgAskWyNW0SdbI5aeckGgF9C8yAUBF0i2RqQVMS+yNWLpKRcEfAE1CYQtkFwQaJsqL3JBDheolHRJRyk/P4V+y7mMjeNz3q/P8tLrnYVI5sP5OZdBcHrOk/b85+dc2/jzc66t9vk513b4/Jybcn56zrVpPT/n2oeen3PtQ4/P+fzY+8+ennPPkjat4AJph/tigY594ZO1e46lp3bm2Ato1jYeXCDt+WOtiCY9Q+kprwJ8AZWxAS6QXJAXC+T8RCXLBQG/g+SCYAtUZGuEKvqKbI1YesoFAV9A5YKAC2QSKNSKKFsjlp5yQcAXULkg4ALJBcG2qYpcEOw7yOSCgAskWyNU0WeyNWLpKRcEfAE1CYQtkGyNWCuibI1YesoFAV9A5YKACyQXBNumqnJBsO+gKhcEXCDZGqGKvipbI5aeJj2xF1C5IOACydaItSLK1oilp1wQ8AVULgi2QE0uCLZN1eSCgN9BckHABZKtEaroayY9Q+kpFwR8AZULAi6QbI1YK6JsjVh6ygXBXkC7XBBwgeSCYNtUXS4I+B0kFwRcIJNAkYq+Llsjlp5yQcAXULkg4ALJ1oi1IsrWCKXnkAuCvYAOuSDgAskFwbaphlwQ8DvIJBC2QLI1YhV9sjVi6SkXBHwBlQsCLpBsjVAr4pStEUtPuSDYC+iUCwIukFwQbJtqmgTCvoPkgoALJFsjVtEnWyOWnnJBwBdQuSDQApVFtkakFbEssjVi6SkXBHwBlQsCLpBJIGSbqixyQQ4XyJZxCdBSno8/PPNymcbM7jSWWi5yrv9s81ZPmSax9JRpEktPmSax9JTHEkrPJEsmlp6yZGLpKUsmlp5ycA7Xs+Z2mUYtedzm3JTz03Mun+X8nMsLOT/n8ivOz7k8hfNzrn3/6TnP2pufn3Ptn8/Pufa45+dc+9Dzc27K+eE5L/0SYLVSnb/cS77kev3n4bo56yP46uaUevtrgqxdbjRFtYeOpqh26G+taLtVVPv/N1PUeyuS5S4EU7TIu4imqJyRaIrKd4mmqFydVytqtV0VrdnpVkg/5nr5eOpLulXUpOh7Kdo/cp1GvqOoPKNoisoziqaoPKNoisoziqaoPKNgipo8o2iKyjOKpqg8o1cruppGV0V7y7cSyQSCl8gk0YslGvNDopluWUgmm+Z4iczGVaLu/uXVEr/+6bzcut0m3+XVEpXl40+vbx8ef9zW/P7+acufMz3vTmS5/pjSPrHK1g//Jr4sGmLx5eYQiy/jh1f8Ko+IWHzZScTiy3kiFl+eFrH4JvF5xZcPRyy+HD5i8eXwEYsvh49YfDl8vOI3OXzE4svhIxZfDh+x+HL4iMU3ic8rvhw+YvHl8BGLL4ePWHw5fMTiy+HjFb/L4SMWXw4fsfhy+IjFl8NHLL5JfF7x5fARiy+Hj1h8OXzE4svhIxZfDh+v+EMOH7H4cviIxZfDRyy+HD5i8U3i84ovh49YfDl8xOLL4SMWXw4fsfhy+HjFn3L4iMWXw0csvhw+YvHl8BGLb+eLn5aPI29//cQn+X+b1Aucp7QOuE5qmHNNdrtMpX++bsYlgPbuAfR3D2C8ewDzvQOwZXn3ANK7B5DfPYDy7gHYuwfw5k/itfp59wDe/Elsy5s/iW159ydxevcncXr3J3F69ydxevcncXr3J3F69ydxevcncXr3J3F69ydxevcncX73J3F+9ydxfvcncX73J3F+9ydxfvcncX73J3F+9ydxfvcncX73J3F59ydxefcncXn3J3F59ydxefcncXn3J3GBfxLPdplKWpb0UwS3H7ZaLy/2rY7l49N3f30xcr78RmLk3pxPl3n90+XjJwP57g9GRp6X/I1PPxi5++E0xuUHEmku1flwuv7llD7/rOOiJ3xhIj2/pCd8nSY9v6QnfNkqPb+ip8FX8dLzS3rCb2qk55f0hN/jSc8v6Qm/5ZWeX9LTpGcoPeENEen5JT3lD8XSU/5QLD3lD8XSU/5QKD2r/KFYesofiqWn/KFYesofiqWnSc9QesofiqWn/KFYesofiqWn/KFYesofCqVnkz8US0/5Q7H0lD8US0/5Q7H0NOkZSk/5Q7H0lD8US0/5Q7H0lD8US0/5Q6H07PKHYukpfyiWnvKHYukpfyiWniY9Q+kpfyiWnvKHYukpfyiWnvKHYukpfyiUnkP+UCw95Q/F0lP+UCw95Q/F0tOkZyg95Q/F0lP+UCw95Q/F0lP+UCw95Q+F0nPKH4qlp/yhWHrKH4qlp/yhWHqa9Aylp/yhWHrKH4qlp/yhWHrKH4qlp/yhSHrWRf5QLD3lD8XSU/5QLD3lD8XS06RnKD3lD8XSU/5QLD3lD8XSU/5QLD3lD4XSM8kfiqWn/KFYesofiqWn/KFYepr0DKWn/KFYesofiqWn/KFYesofiqWn/KFQemb5Q7H0lD8US0/5Q7H0lD8US0+TnqH0lD8US0/5Q7H0lD8US0/5Q7H0lD8USs8ifyiWnvKHYukpfyiWnvKHYulp0jOUnvKHYukpfyiWnvKHYukpfyiWnvKHQulp8odi6Sl/KJae8odi6Sl/KJaeJj1D6Sl/KJae8odi6Sl/KJae8odi6Sl/KJSeVf5QLD3lD8XSU/5QLD3lD8XS06RnKD3lD8XSU/5QLD3lD8XSU/5QLD3lD4XSs8kfiqWn/KFYesofiqWn/KFYepr0DKWn/KFYesofiqWn/KFYesofiqWn/KFQenb5Q7H0lD8US0/5Q7H0lD8US0+TnqH0lD8US0/5Q7H0lD8US0/5Q7H0lD8USs8hfyiWnvKHYukpfyiWnvKHYulp0jOUnvKHYukpfyiWnvKHYukpfyiWnvKHQuk55Q/F0lP+UCw95Q/F0lP+UCw9TXqG0lP+UCw95Q/F0lP+UCw95Q/F0lP+UCQ92yJ/KJae8odi6Sl/KJae8odi6WnSM5Se8odi6Sl/KJae8odi6Sl/KJae8odC6ZnkD8XSU/5QLD3lD8XSU/5QLD1NeobSU/5QLD3lD8XSU/5QLD3lD8XSU/5QKD2z/KFYesofiqWn/KFYesofiqWnSc9QesofiqWn/KFYesofiqWn/KFYesofCqVnkT8US0/5Q7H0lD8US0/5Q7H0NOkZSk/5Q7H0lD8US0/5Q7H0lD8US0/5Q6H0NPlDsfSUPxRLT/lDsfSUPxRLT5OeofSUPxRLT/lDsfSUPxRLT/lDsfSUPxRKzyp/KJaeL/GH5lWinMZPev42qVeYHLkul4+XpTkXWW4fgvXPIdR077oZdvnbY1Rzrptj9S1K5VGpNKXyqFQesqtu/Zqb3MZ0UtmWfFmP21KG8+l1pa8fkxmj/fT534JoEYK4v3+y6wq9XqTDCaKXfPl0L9Y/fUm991is6XJtlDqzc5HOPC4BzzzrqRfpOCI19SM1IzupWSuQi7jpY/Ip998nNI+Y0LzUUt2Kp1WaLV8vz9l++vzOC64tEYJIZweRl1zK5Y8vluznSa3/9s//9ue//OXP/+cf//K3f/mn//jz3/767z9GLz/+J92HntVxXUvWf/xUof56uaX7ZC1vUNszqO8ZNPYMmjsG3UdqeIPSnkF5z6CyZ9CeKyLvuSLynisi77ki8p4rIu+5IsqeK6LsuSLKniui7Lkiyp4r4v6vZ+ssl3WwzjpvBrU9g/qeQWPPoLlj0P2fzfw0qNvNoI3sjXEt8dJNyu8bpG2tHS+D8rwdNHcMum/1eIPSnkH3Y6qlXgbV2m8GzR2D7lcf3qC0Z1DeM6jcH9TaddAYN4Nsz6C6Z1DbM6i7g2a5GTR2DOr3U97SdVDLN3duL3sG2Z5Bdc+gtmfQ/eytV9x1ULtZjUbZM+ju9PoyrqXtMm8H3b9z27xsx9Y98fLHQXPZMyjtGXRf3JGuiRj55tq7f05uX7JdE9Fu1r37h7F6g+bXU57vHyvpDUp7BuU9g8qeQbZnUN0zqO0Z1PcMGnsG7bki0p4rIu25ItKeKyLtuSLSnivi/u6zDbuusKOOm0Fjz6C5Y9D93ac3KO0ZlPcMKnsG2Z5B1R10s1jm+7tPb1DfM2jsGbRxRVzfEbS5/PHpnu/v1Nos+TrI6s2gumdQ2zOo7xl0P3vz+r51HdRuBs0dg+7v1LxBac+gvGdQ2TPI9gza0Gl8XHvjRifzKxa7WWFt7hhUlz2D0p5Bec+gsmeQ7RlU9wzaqFisb1eWue6oYXMdewbNHYPasmdQ2jMo7xlU9gyyPYPq1weV+5VlsnVrcHk3sv7zvBk2dw27X/MlK7leh5VSb4aVfcNs37C6b1jbN6zvGzb2DZu7ht2vNv1haWPY1ab4MazdDMv7hpV9w2zfsLpvWPv6sPVf0o8P31+01heD5WLGr/9sf7zp7q9a7qiya5TtGlV3jWq7RvVdo8auUXPPqH7/Xqvz49dxbcl/tKd62jUq7xpVdo26f22sn5wfo+xmVN01qu0ZNe5nvq2Psuuo1SH/46i0MWp8ZGM1pf44Ku8aVXaNsl2j6q5RbdeovmvU/buyrRufj1H1j0vwfZvZGzWXXaPSrlF516iya5TtGrVxbaxl/8eo9seVbbZdo/quUVvXxqcVIPefVoC7P8u065esptFwPl4/NlLrP9+8x5sTb05pWRAnlRAnlREnVRAnZYiTqoiTaoiT6i+ZVBmfJnXze4HlqAX943fVP/Xq/P4t84xvScsp35JO+ZZ8yreUU77FTvmWesq3bK0s6VNhl2+H9X3Dxr5hc9ewvOwblvYNy/uGlX3DbN+wum/Yvqsk77tK8tZVMq82Yiup3gybu4aVZd+wtG9Y3jdsQ+4yPxYD+3t/YesOs42U2IeP2z43HVyGbVzKtX9swertD7rM9g2r+4a1fcP6vmFj37C5a1hd9g1L+4ZtXMrrNvs6rJWbCq2WrWEfF1er6fFzbb0SL7Wp5c99kPf6uqotlxlVy/b5w79OyNAmVNEm1NAm1NEmNNAmNMEm1LYu6v7hmrf+d/6UO7Weri9H1lG3Pxufu4ZtvFRxh6V9w7YWnvmxgPYl3Qyr+4a1fcP6vmFj37C5a9jWKxlvWNo3LO8btvHg6/nzVXJTVW29lvGG1X3D2r5hG1dJbx+Vfh83P5bfejXjDZu7hm29nPGGpX3D8r5hZd+wjatkLB/DRrptPKj7hrV9w/q+YVtXyfw87KY+3XqP8nhY3nrT4Q1L+4blfcPKvmG2b9jWVfLhxbZh/WZY2zes7xs29g3buEpG/jzs9tf4y75had+wvG9Y2TfM9g2r+4ZtXSWfCsMx0s2wvm/Y2Dds7hq25UCO9nnY7Q/7075hed+wsm+Y7RtW9w1r+4Zt1SX2Uc6Mn3tB75jopX+AYUqfN79r3zIsv/gtY7neKGXkm1V4y9889lu27NCDvyWd8i35lG8pp3yLnfIt9ZRvacd8yxUctf5zuW3w6cfHcudbxinfMs/4FltO+ZaD7n2bH9/SbnuN8infUk75FjvlW+op39JO+ZZ+yreMU77loHu/fbor+80+qC7Hx3LnW9Ip35JP+ZZyyrccdO/PDxLoXG7W5FpP+ZZ2yrf0U75lnPIt84xvacsp35JO+ZZj7v25fNyVM92YFq0cH8udb7FTvqWe8i3tlG/pe97E5X1vGfO+t4x531vGvO8tY+5537Cyb5jtG1b3DWv7hu27Svq+q6Tvu0rGvqtk7LtKxr6rZOst4+NfiuWtt4z28VvwZm25Gdb3DRv7hs1dw7beMnrD0r5hed+wsm+Y7RtW9w3bd5XMfVfJ3HeVzF1XSVmWfcN2XSWbjfkOh2GrMd8bdv8qcTEA+4AKeR9QIe8DKuR9QIW8D6hQ9gEVSto3bB92o+wDKhTbN2wfUKG0fcP6vmHj68PWf8k/PrwFHbvsR/qnTqxU0m8lxteHjK8PmV8eUpavD0lfH3IfuDOvpy0tt0PK14fY14fUrw+5q/7ol/DHGDdD+teHjK8PmV8ecv91wsfOeqbbIenrQ/LXh5SvD7mr/ry2v89abobUrw9pXx/Svz5kOEM+FRCXIfPLQ+4byo+H3Fd/XB4/c9rNkPz1IeXrQ+zrQzZoNR8H9iw93Qxqewb1PYPGnkFzx6ANc9EZlPYMynsGlT2DbM+gPVdE23NFtD1XRNtzRbQ9V8SG//VxOFVK1n4a9MuXPv0Pm5yjQ78if/9XlO//Cvv+r6jf/hXjgCuqfSBmPxExf/Ri/sMmUelrX/CJhZ9uvsC++wvqd39B++YvmPWbRZ5HRPBxVMnnM7x+/4L+3V8wvvsL5jd/wRZo6IvfcKUQ93n7DenbvyF/+zeUb/8G+/ZvqN/+De3bv6F/86K3BbQ58hvmd39DWr79G9K3f0P+9m8o3/4N9u3fUL/9G9q3f8O339Pp2+/p9O33dP72ezp/+z2dv/eeXv+t/Pjk/dtuLNfDuVcf+Kfm+h8jbXvkWsF8kIE/vY/54VrefLhfeyv7p+MA14/+SED93j/fnv/z12Nr+ycC8u9/vh/w569n+7Tyxz8/vvfPz+f//MdLkdn/8Oe3bs+j/nx6+s+PKyZm2B+vnK0b80t//nJfjk9c2t//fHn+z18b/8ZtcuzAPz//cFut/1IfLA3r4nVdu5bx990xya7vd1Nrf99t8HjM/PqYjQv28Zi0Y0zeMabsGGNfH7Pxju3xg6L9+OjGbwofH8C78YtCb1DeM6jsGWR7BtU9g9qeQX3PoLFn0I5jpjd+P+gN2nNFjD1XxNhzRYw9V8TYc0WMPVfE2HNFjD1XxNhzRcw9V8T93yU+PtB641eJ3qCyZ5DtGVT3DPIPHr85pHvj93qPD+ku9623x6dgl/tumjeo7RnUdwy6X648PtB644glb1DbM6jvGTT2DNo4ePzRKdgbv9/0BqU9g/KeQf7B4zfnbW/8StQbtHE29aMDrTd+fOkM2vjpmjMo7RmU9wy6n72H522XjSMvHw+yHQfwFts4rfzR0dnF2p5BfceguvG7xEeHdJe/49DG24Pz/o5DG+8M2nHMdKltz6C+Z9DYM2jHMdOlLXsGpT2D9lzlrewZZHsG7bki2p4rou25ItqeK6LtuSL6niui7zhmutzffXqD6p5Bbc+gvmfQ2DNox8HjZSx7BvkHj98uliPvGVT2DLI9gzauiEeHdJe5ccz0o1Owy0x7BuU9g8qeQfez9/CY6TLrnkFtz6C+Z9DYM2jHweO2LHsGbej06JBuW/yK5ebEaFvqnkFtz6C+Z9DYM2jHweOWlj2D0p5BGxXLo0O6Le2oYS3ZnkF1z6C2Z1DfM2jsGbTj4HHLy55BOw4et41fpTvtmrbxu3R32K5OSGu7OiGtL/uGpX3D8r5hZd8w2zes7hvW9g3b1QlpfewbNncNG8u+YWnfsB0HkK//0n98+L7PtopzMZPr546i5cf33XfZHg+xrw+pXx/Svj6kf33I/fck/cN+bzdD5peH3Lf9Hg9JXx+y4bJ+GMe3Q8rXh9jXh9SvD2lfH9K/PmR8fcj88hBbvj4kfX3I19W3r6tvX1ffvq6+fV39Dcf2+hayjf7TkF++8Nl/2OpuPe7Pz2/98xvO9GF/Pn3vn8/f++efv3Ie9f+053P/6OemLX3vn8/f++fL9/758b3SPn/XPupa6sv3/vn0vX8+f++ff/7KedSDs+HTH/bn6/f++fa9f75/758f3/vn57f++fG96/343vV+fO96P753vR/2vX++fu+fb9/75/v3/vnxvX9+fuufn997187vvGvXfxs/PrlxOEFaPhqP8qcf7//uN5U9g2zPoLpnUPvyoPXf5q9m2H3TZV7f6X/6NWbKP372vv7r//dP//bnf/rnv/zrv69DfvzX//zrv/zHn//219//9T/+//97+S///G9//stf/vx//vH//tvf/uVf/9d//tu//uNf/vYvP/7bn5bf/+d/5lF+KUv5h18btv7njx6KdbL/8KM39sd/XIub3H/8x1/f0+TV2Ml9/ph8uowvVn8prf4+3uYvdV5Gl8XWPz0vo0tafinr3/7v32lvPz6SbPyS2rh8++rDplIv41NpvyRLl/E/+geS9Y/esl8/s84ofzSN/Trp/kvJH80iv84k/1L6tWPgx/9jZf5iv071xxfnusb56zR+/bit7xosXydu6zysjKuB+ev3rl+c1r/52/j1jXZa7DrvZZ1oWq7zTmn913K9A8qvqfnFluvXjV9quV4Rv8VQfsnrF/73qvf/Aw==",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "build_msg_block",
         "attach_len_to_msg_block",
@@ -1684,8 +1808,8 @@
         "directive_invert",
         "directive_integer_quotient"
       ],
-      "verification_key": "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",
-      "artifact_hash": "74acc0382b362be946a173c5740463f2803bc3a9-33b56c74f69f7b67c83c62a02107f215-mega-honk-true"
+      "verification_key": "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",
+      "artifact_hash": "51138cca3416c965bb4ccec1358c0c804a4ada84-bef675b7a684e2c714f9f8a6499fb8fe-mega-honk-true"
     },
     {
       "name": "check_balance",
@@ -1736,59 +1860,12 @@
         ],
         "return_type": null
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "check_balance"
       ]
     },
-    {
-      "name": "set_portal",
-      "is_unconstrained": true,
-      "custom_attributes": [
-        "public"
-      ],
-      "abi": {
-        "error_types": {
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          },
-          "2236649814169388962": {
-            "error_kind": "string",
-            "string": "PublicImmutable already initialized"
-          },
-          "6485997221020871071": {
-            "error_kind": "string",
-            "string": "call to assert_max_bit_size"
-          }
-        },
-        "parameters": [
-          {
-            "name": "portal_address",
-            "type": {
-              "fields": [
-                {
-                  "name": "inner",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": null
-      },
-      "bytecode": "JgACBAEnAAABBIBEJgAABAMmAgIEASYCAwQAHxgAAwACgEMtCIBDAAEkAAAAQCcCAAEEgEQmAgIEADoNAAEAAiQAAADcJgICAAIuDAACAAMcDAMEACsCAAUAAAAAAAAAAAAAAAAA//////////////////////////8OOAQFBiMCAAYAAACMJAAAAQUmAgQAAAo4AwQFIwIABQAAAKcmAgYEADsJAQYoAgADADuaygIuDAADAAUKOAUEBiMCAAYAAADIJAAAARcnAgAEAN6tLwwABAADLwwAAQACJScAgAQEeAANAAAAgASAAyMAgAMAAAEEKQEAAQX3ofOvpa3UyjsBAQIlKQEAAQVaAuQbtR6pnzsBAQIlKQEAAQUfCi0n3IKHojsBAQIlLQAYyhjK",
-      "debug_symbols": "7VfbioMwEP2XPPuQmSSTpL+yLMW2tgiixdqFpfTfN5FG2yoEpF0K+iKOnLmcw8zIXNgu25wP67zcVye2+rqwotqmTV6VzrpcE7ap86LID+v7z4z7B9kWfzqmpTdPTVo3bAVaY8KycudfrXUR9nmRsZWw4poM0AhG39CIgB0aDI6gNQLd0BqF7tF8LLbmPMTWXFIEDcDJhMKdAQ/474RpOSu6hv8/XQ4dXYUxuqACWJoOi1yNYI0NgS1QBCsplCw9p1CDbTVRiybPmgDiIspQFL2IMhBFLOMzFEVG96wBeBCl9VJTvNSkXMpM8SIxyWt8bgz2XkpFWsQVHPQG+uyfLGiaF1+DL+BLind8ST3wbXPo9+ew6u05kPMX5DBoerSM9QZRty7JiFhvSBIBrUBGe8PNftcbbo0/9wZyPS++IF7B14aawIL9XL5XZ/6kdZ5uiux2We7P5fbu0Gx+j9nTzXmsq222O9eZvz77wxP8YAiRCONHEZwhMZHS5XB5/gA=",
-      "brillig_names": [
-        "set_portal"
-      ]
-    },
     {
       "name": "_increase_public_balance",
       "is_unconstrained": true,
@@ -1850,8 +1927,8 @@
         ],
         "return_type": null
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "_increase_public_balance"
       ]
@@ -1922,164 +1999,28 @@
             "type": {
               "kind": "array",
               "length": 0,
-              "type": {
-                "kind": "field"
-              }
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": {
-          "abi_type": {
-            "kind": "array",
-            "length": 4,
-            "type": {
-              "kind": "field"
-            }
-          },
-          "visibility": "public"
-        }
-      },
-      "bytecode": "H4sIAAAAAAAA/9VZ227aQBBdsI2xiQmFP4jUt1ayCdc3pF7yHSiBL+gH+KEv7VeXFTv2YTypkJipykjRGs/6zNkz4931pufONjz99cJ1HNqB6xr12YW2vM0qRazSkmfvTnj274RndCc8Y0WePYGnb+l9S9z5nUvd+X3sOPFhn+gI/O5vQCzo79Bmoe2DXzExVSYMVgt/Uy5eM3dpyvyfs4CZ2uAvCX9og18S7y91i49jobhRaF/qVssXeMZbEa6xiAmXfH3wfWW+CHzfmA9r+DvzYd0TJ9JtAGNRrKuNdV5obCmMrfdO61yrHd4jrXNnWqMV5TxjfDh/4lNQn7rlM2C+GHwZ8yXgI/19+wT9eO5T6PcZ7vOajFy3hslPOUetLWoqNsA/2ULSneckri9jow91j0HPJ6aPxVqB+ljo7/WZvcOfrr2ltWssYnqiRqTZEPszXwa+uL6Mk4ffMcRBLOKRsP6fwu/H0A7gGXp+IsQfsPgXvIV7qBHHioR71N+/kx/D9cid6+cn9XfdeUpvU71aSHO2Hv66wc9s+B8JP7fBXxH+yAa/2cs8mODPS8IvbPhvCX9sUz/NXvLRhv+B8Ccm+IsDrbsfXGvN/BCup3Bfb+6uqmv2RBg/Z1yt9kRTxofrg+uv980ErhPBx3M4E+LMhDgSVqaI9aCI9fifjnGoiDVSxBorYmnmMVXE0tQrV8QqFLE0615TL8qjtE/ztgtteaNJ+zRF/Erap2l+u5PWVF+xoCGOL2H9fzCdRyY8qzmtOfSuUwyMXRjFvna9pviFwId454LvlkPZw3Jz3G6W29OWrFrNt00+C8aV38NvIpyPsb+09kv7PkWtS+m7fwy6eovBVzBfAj7iKH33j434X6M/xp8IPr7+X5vLqeuuhyM2bjzj2qmMuT3/k87mjeev5bXvJsXPXXe+/lfni6gP30vnAteJ4OP7k1yIkwtx7hGLn9Gjhr6uSae4bv1auVxv2n9w0VyUuMtzf8fiJ6z/r/Abx0btLXP+cb2vjs/74365f3tbvO6nDN9bH3T6A/vRhmkVHwAA",
-      "debug_symbols": "tdfNaoQwFAXgd8k6i9z8TIyvUsoQNQ6BECVqoYjv3jhM26GzLGcjXLl+AfEgZ2dD6LbbNeZxWlj7trM09X6NU67TfnDWlZhSvF2fbzNxXpy67y+zz+e4rL6srNWSs5AH1hpRnx5jCqxVTh38ZdN+b1r7s2noeOfMaZhsYPIFJluY3MBkh5JJCBxNOFriaIWjNY42OPqCoy2ObnA0Lo2ESyPh0ki4NBIujYRLI+HSSP9Mo1OPzfpqX2wLtBug7XC2FECbgLYE2gpoa6BtgDYwlxKYSwnMpUTl8qjThy/Rdyk8itW45f6pZ62fc/hTueYy9WHYSjjL12/vOr9lpbnW9197HUhJTsrWQ+pBXw==",
-      "brillig_names": [
-        "compute_note_hash_and_optionally_a_nullifier"
-      ]
-    },
-    {
-      "name": "balance_of_public",
-      "is_unconstrained": true,
-      "custom_attributes": [
-        "public",
-        "view"
-      ],
-      "abi": {
-        "error_types": {
-          "16761564377371454734": {
-            "error_kind": "string",
-            "string": "Array index out of bounds"
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          },
-          "206160798890201757": {
-            "error_kind": "string",
-            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
-          },
-          "5019202896831570965": {
-            "error_kind": "string",
-            "string": "attempt to add with overflow"
-          },
-          "6067862452620309358": {
-            "error_kind": "string",
-            "string": "Function balance_of_public can only be called statically"
-          },
-          "6485997221020871071": {
-            "error_kind": "string",
-            "string": "call to assert_max_bit_size"
-          }
-        },
-        "parameters": [
-          {
-            "name": "owner",
-            "type": {
-              "fields": [
-                {
-                  "name": "inner",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": {
-          "abi_type": {
-            "kind": "field"
-          },
-          "visibility": "public"
-        }
-      },
-      "bytecode": "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",
-      "debug_symbols": "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",
-      "brillig_names": [
-        "balance_of_public"
-      ]
-    },
-    {
-      "name": "public_dispatch",
-      "is_unconstrained": true,
-      "custom_attributes": [
-        "public"
-      ],
-      "abi": {
-        "error_types": {
-          "10502589790419500451": {
-            "error_kind": "string",
-            "string": "Function _increase_public_balance can only be called internally"
-          },
-          "15238796416211288225": {
-            "error_kind": "string",
-            "string": "Balance too low"
-          },
-          "16541607464495309456": {
-            "error_kind": "fmtstring",
-            "item_types": [],
-            "length": 16
-          },
-          "16761564377371454734": {
-            "error_kind": "string",
-            "string": "Array index out of bounds"
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          },
-          "206160798890201757": {
-            "error_kind": "string",
-            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
-          },
-          "2236649814169388962": {
-            "error_kind": "string",
-            "string": "PublicImmutable already initialized"
-          },
-          "3219842053230618354": {
-            "error_kind": "string",
-            "string": "Function check_balance can only be called statically"
-          },
-          "5019202896831570965": {
-            "error_kind": "string",
-            "string": "attempt to add with overflow"
-          },
-          "6067862452620309358": {
-            "error_kind": "string",
-            "string": "Function balance_of_public can only be called statically"
-          },
-          "6485997221020871071": {
-            "error_kind": "string",
-            "string": "call to assert_max_bit_size"
-          }
-        },
-        "parameters": [
-          {
-            "name": "selector",
-            "type": {
-              "kind": "field"
+              "type": {
+                "kind": "field"
+              }
             },
             "visibility": "private"
           }
         ],
-        "return_type": null
+        "return_type": {
+          "abi_type": {
+            "kind": "array",
+            "length": 4,
+            "type": {
+              "kind": "field"
+            }
+          },
+          "visibility": "public"
+        }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "H4sIAAAAAAAA/9VZ227aQBBdsI2xiQmFP4jUt1ayCdc3pF7yHSiBL+gH+KEv7VeXFTv2YTypkJipykjRGs/6zNkz4931pufONjz99cJ1HNqB6xr12YW2vM0qRazSkmfvTnj274RndCc8Y0WePYGnb+l9S9z5nUvd+X3sOPFhn+gI/O5vQCzo79Bmoe2DXzExVSYMVgt/Uy5eM3dpyvyfs4CZ2uAvCX9og18S7y91i49jobhRaF/qVssXeMZbEa6xiAmXfH3wfWW+CHzfmA9r+DvzYd0TJ9JtAGNRrKuNdV5obCmMrfdO61yrHd4jrXNnWqMV5TxjfDh/4lNQn7rlM2C+GHwZ8yXgI/19+wT9eO5T6PcZ7vOajFy3hslPOUetLWoqNsA/2ULSneckri9jow91j0HPJ6aPxVqB+ljo7/WZvcOfrr2ltWssYnqiRqTZEPszXwa+uL6Mk4ffMcRBLOKRsP6fwu/H0A7gGXp+IsQfsPgXvIV7qBHHioR71N+/kx/D9cid6+cn9XfdeUpvU71aSHO2Hv66wc9s+B8JP7fBXxH+yAa/2cs8mODPS8IvbPhvCX9sUz/NXvLRhv+B8Ccm+IsDrbsfXGvN/BCup3Bfb+6uqmv2RBg/Z1yt9kRTxofrg+uv980ErhPBx3M4E+LMhDgSVqaI9aCI9fifjnGoiDVSxBorYmnmMVXE0tQrV8QqFLE0615TL8qjtE/ztgtteaNJ+zRF/Erap2l+u5PWVF+xoCGOL2H9fzCdRyY8qzmtOfSuUwyMXRjFvna9pviFwId454LvlkPZw3Jz3G6W29OWrFrNt00+C8aV38NvIpyPsb+09kv7PkWtS+m7fwy6eovBVzBfAj7iKH33j434X6M/xp8IPr7+X5vLqeuuhyM2bjzj2qmMuT3/k87mjeev5bXvJsXPXXe+/lfni6gP30vnAteJ4OP7k1yIkwtx7hGLn9Gjhr6uSae4bv1auVxv2n9w0VyUuMtzf8fiJ6z/r/Abx0btLXP+cb2vjs/74365f3tbvO6nDN9bH3T6A/vRhmkVHwAA",
+      "debug_symbols": "tdfNaoQwFAXgd8k6i9z8TIyvUsoQNQ6BECVqoYjv3jhM26GzLGcj3nD9ApJDuDsbQrfdrjGP08Lat52lqfdrnHKt9oOzrsSU4u36vMzE+XDq3r/MPp/lsvqyslZLzkIeWGtE/XqMKdQ1Ud9fOu13p7U/nYaOd86chskGJl9gsoXJDUx2KJmEwNGEoyWOVjha42iDoy842uLoBkfj0ki4NBIujYRLI+HSSLg0Ei6N9M80OvXorL/2xbZAuwHaDmdLAbQJaEugrYC2BtoGaANzKYG5lMBcSlQuj1p9+BJ9l8JjsBq33D/NWevnHP6MXHOZ+jBsJZzD1+/cdZ5lpbnW96u9FqQkJ2XrJnWjLw==",
       "brillig_names": [
-        "public_dispatch"
+        "compute_note_hash_and_optionally_a_nullifier"
       ]
     },
     {
@@ -2886,7 +2827,7 @@
                 "name": "private_call_requests",
                 "type": {
                   "kind": "array",
-                  "length": 4,
+                  "length": 5,
                   "type": {
                     "fields": [
                       {
@@ -3070,7 +3011,7 @@
                       }
                     ],
                     "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::abis::side_effect::Counted"
+                    "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted"
                   }
                 }
               },
@@ -3185,46 +3126,29 @@
                 }
               },
               {
-                "name": "start_side_effect_counter",
-                "type": {
-                  "kind": "integer",
-                  "sign": "unsigned",
-                  "width": 32
-                }
-              },
-              {
-                "name": "end_side_effect_counter",
-                "type": {
-                  "kind": "integer",
-                  "sign": "unsigned",
-                  "width": 32
-                }
-              },
-              {
-                "name": "note_encrypted_logs_hashes",
+                "name": "private_logs",
                 "type": {
                   "kind": "array",
                   "length": 16,
                   "type": {
                     "fields": [
                       {
-                        "name": "value",
-                        "type": {
-                          "kind": "field"
-                        }
-                      },
-                      {
-                        "name": "counter",
-                        "type": {
-                          "kind": "integer",
-                          "sign": "unsigned",
-                          "width": 32
-                        }
-                      },
-                      {
-                        "name": "length",
+                        "name": "log",
                         "type": {
-                          "kind": "field"
+                          "fields": [
+                            {
+                              "name": "fields",
+                              "type": {
+                                "kind": "array",
+                                "length": 18,
+                                "type": {
+                                  "kind": "field"
+                                }
+                              }
+                            }
+                          ],
+                          "kind": "struct",
+                          "path": "authwit::aztec::protocol_types::abis::log::Log"
                         }
                       },
                       {
@@ -3234,25 +3158,6 @@
                           "sign": "unsigned",
                           "width": 32
                         }
-                      }
-                    ],
-                    "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::abis::log_hash::NoteLogHash"
-                  }
-                }
-              },
-              {
-                "name": "encrypted_logs_hashes",
-                "type": {
-                  "kind": "array",
-                  "length": 4,
-                  "type": {
-                    "fields": [
-                      {
-                        "name": "value",
-                        "type": {
-                          "kind": "field"
-                        }
                       },
                       {
                         "name": "counter",
@@ -3261,22 +3166,10 @@
                           "sign": "unsigned",
                           "width": 32
                         }
-                      },
-                      {
-                        "name": "length",
-                        "type": {
-                          "kind": "field"
-                        }
-                      },
-                      {
-                        "name": "randomness",
-                        "type": {
-                          "kind": "field"
-                        }
                       }
                     ],
                     "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::abis::log_hash::EncryptedLogHash"
+                    "path": "authwit::aztec::protocol_types::abis::private_log::PrivateLogData"
                   }
                 }
               },
@@ -3313,6 +3206,22 @@
                   }
                 }
               },
+              {
+                "name": "start_side_effect_counter",
+                "type": {
+                  "kind": "integer",
+                  "sign": "unsigned",
+                  "width": 32
+                }
+              },
+              {
+                "name": "end_side_effect_counter",
+                "type": {
+                  "kind": "integer",
+                  "sign": "unsigned",
+                  "width": 32
+                }
+              },
               {
                 "name": "historical_header",
                 "type": {
@@ -3700,8 +3609,8 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "7VjbiiIxEP2Xfu6HVOVW5a8sy+ClZ2gQFS8Li/jvm4hJdMxsU647g4wvYnWfQ06d6uS07ptZN9m9vfSL1+WmGf3YN/PldLztl4tQ7RvQx2ub1XgRy812vN42I3Cs2qZbzMJXr9ShbV77edeMNOtDe4VG0nRCI7mCBgsVtLbAJ7S2jANoRoITmpFtRiNyBQ1ELulmdYZ2NTBgEgLg6Rz8s23API2pG2OfxtSNcf9ujAG0J7QBB6VVhccl/P9fgqpLACdTAR0OLOE1+hPaa+PPlrAPPF6+hzG2GEM4YIylNFYHRTqgj3JQ3UMOY5Jj9NCcgB3m54zdBR5rmxwpdxu+k3v/qCE8fgv42S2gQq2TJGXAXEmqJzqWjaBh6IwgZ1MD5NkNuOQpbRvCIgfDSRTl1HNUI2Y5mgfkcNmYjOdboSoHbDYInDrbZOGEiILq+WVUFmSs/Y4HHLqnMXVj/NOYujF0D2PuF4l8DzlfmidaPX4L8NktDERiqCbrfj7v314ufvqq+GE+CHCVAzwk5/sHzehbSOYWkr2F5MSkUEHE1t8qbZmG5cs8DRVGpK8S2eeDia7eDDzIKSinaDnFyClWTnFyipdTSE5hMYXk0yf59Ek+fZJPn+TTJ/n0ST59kk+f6tM3+W2a/BWFxRRWcgrIKSinaDnFCCmh0n/5I9VDPnS9x6uz0zwzqGRQKH+N1/14Mu9iQMe7u8U05XUot79X6U5K9NV6Oe1mu3UXs73EejRHq9aoIAXi42motTrH3PES6hYpB1hkWGodJQa7Nqgt843XwLao8tw+WuQQevkD",
+      "bytecode": "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",
+      "debug_symbols": "7VhbjuIwELxLvvPh7vajm6usViNeM4qEAPFYaYXm7msj7DDgATXLzgoNPyhOqnClynEFds1kOtq+vXTz18W6GfzYNbPFeLjpFvM42jVA+3Pr5XCehuvNcLVpBuDFtM10PomHwZj3tnntZtNmYNPxGRqZ+IBG9j0aLFbQ5EAOaHKCV9BiOBzQAgYKGrGmBAJT1s2m/270NbBBn8EmuGPwz7YB+zSmbox7GlM3xv+9MSQBD+gI4IIW2s8Q/vkMXJ0BBPIM6PHKDIEwBxDIhn4G/8DZyj18cb0vjJd9cZwz9dCLAeCkBs091EheB8HSlZSAQ4kpHpM/XjaVxxvEZTPjMbuTVYbw4Prxq/ULUUZHbUCnguotHvfWTCK4tjEwYbaIbbCXHQpcsNhDowF7NfXqJCy3QCTX1LDJDwuz0GU14Kg86P7oQYe4LSQ99caypuixzn3DTQ3905eqL+HpS9UXvocvdytBuYea/1ciZB5cP3y1/oslGAejVTebdW8vH37gmvRhPylsUwo7duXpArN0C8neQnK3kLyaFEeQsPX3R9dn4eRjh8YRJmSoEiXkKYXPXgYC6Cmop5CeYvUUp6d4PSXoKayniJrC+vRZnz7r02d9+qxPn/Xpsz591qfP9fStFEo4o4iaIkZPAT0F9RTSU6ySEkd04e/SAGXTDQHP9k777KC+g+Lw13DVDUezaSrodHU7H+e+jsPN72W+kht9uVqMp5Ptapq6va/1ZA6Z1pooBdLytNw6KjW3P4XUIpcCSwzHrefMEN9GtX2+6Ry4Fk3J7bNJ3uO9/AE=",
       "brillig_names": [
         "pack_arguments_oracle_wrapper",
         "enqueue_public_function_call_internal",
@@ -3709,27 +3618,54 @@
         "notify_set_min_revertible_side_effect_counter_oracle_wrapper",
         "pack_arguments_oracle_wrapper"
       ],
-      "verification_key": "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",
-      "artifact_hash": "74acc0382b362be946a173c5740463f2803bc3a9-f78a5a4fbfaed16b6eb17638bb8138b0-mega-honk-true"
+      "verification_key": "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",
+      "artifact_hash": "51138cca3416c965bb4ccec1358c0c804a4ada84-0bd3dd2a03004ee692247c75fe17f898-mega-honk-true"
     },
     {
-      "name": "sync_notes",
+      "name": "set_portal",
       "is_unconstrained": true,
-      "custom_attributes": [],
+      "custom_attributes": [
+        "public"
+      ],
       "abi": {
         "error_types": {
           "17843811134343075018": {
             "error_kind": "string",
             "string": "Stack too deep"
+          },
+          "2236649814169388962": {
+            "error_kind": "string",
+            "string": "PublicImmutable already initialized"
+          },
+          "6485997221020871071": {
+            "error_kind": "string",
+            "string": "call to assert_max_bit_size"
           }
         },
-        "parameters": [],
+        "parameters": [
+          {
+            "name": "portal_address",
+            "type": {
+              "fields": [
+                {
+                  "name": "inner",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
+            },
+            "visibility": "private"
+          }
+        ],
         "return_type": null
       },
-      "bytecode": "H4sIAAAAAAAA/9VUyw6CMBBseURBOaiJ3kz8gyIYOJJ49x8akKMe8OKNT5eabbqpVRKlJkzSbEs3szNlW0oUKESPvAH9tGnIFdhBDCA6aN/tRgFr9hviQKs7JH/O0iQw+BtQ/5OfWtIvIPktnT+bAM+xVfzYi6w77UaIesKWZ/nPbHpe9fhc/MFnh32k1caghm+uIYci3RuYR4Y8iRlRd9prh/eV5YzJei7w++RVO67va/lrWIeafvmOFV/qrDMe1wmv+YFXVVrypcYv4KBzGnMvbGHe1wvY45yo3mjul/J0vZ0b0gNB8gCVxsvQjgYAAA==",
-      "debug_symbols": "ndLNCoQgEAfwd5lzh9Tsw1eJJawsBNEwW1iid1+LdmmXLnoZGPE3c5j/Cr1ol7GRejAzsHoFZTrupNG+W7cEWiuVkmNzfYZ0Lwgd/+eJ672dHbcOWIYTELoHRlOvB6kEMFKR7ZEAwqGAhIIsFNBAgG83VBSXJ6kopV+EMDoQjUF5DCpiUBmByO31qxwVH5ST/Bdtvn1yK3mrxJmuYdHdJWzuNYm/3E3WdKJfrNgTeAmfr7XfhbEf60e/AQ==",
+      "bytecode": "JgACBAEnAAABBIBEJgAABAMmAgIEASYCAwQAHxgAAwACgEMtCIBDAAEkAAAAQCcCAAEEgEQmAgIEADoNAAEAAiQAAADcJgICAAIuDAACAAMcDAMEACsCAAUAAAAAAAAAAAAAAAAA//////////////////////////8OOAQFBiMCAAYAAACMJAAAAQUmAgQAAAo4AwQFIwIABQAAAKcmAgYEADsJAQYoAgADADuaygIuDAADAAUKOAUEBiMCAAYAAADIJAAAARcnAgAEAN6tLwwABAADLwwAAQACJScAgAQEeAANAAAAgASAAyMAgAMAAAEEKQEAAQX3ofOvpa3UyjsBAQIlKQEAAQVaAuQbtR6pnzsBAQIlKQEAAQUfCi0n3IKHojsBAQIlLQAYyhjK",
+      "debug_symbols": "7VfdqoJAEH6XvfZiZnZ3ZrdXORzCykIQDbMDh+jdj0pqmRxBKoK8EUe++fk+Z3aZk9pEq+NuGafb7KAWXyeVZOuwiLO0tE7nQK3yOEni3fL6s4Lqwb7GH/ZhWpmHIswLtUARClSUbqpX78sI2ziJ1MIAnIM7NKGTC5oIqUWj6AG0EPIFLaSlRXszBAZoQgsY/h+M4EQ3ZYOHG/h3oMR8DlcHr+cK2HK1NMIVbYM1rgvseQDrfBPXI49gDTcVG6+vsLUkdpakJwkSzZrcaSKzJn1N9Dw7d5qY0SPWId5oUnvZKV52Ui7rpnixnuQ1PDWOOi9rRzqkLLjRG/mNL1cU/iCyjh5Ali20ZNnekK1zyPNzePv0HATwgByOXIc2Y43B3J6T7PRIYxhufrVYNGON4V1bNgLpXmMQyAeRRf0Isr6dNI/+TcmeS+snzONwlUSX/XF7TNdX62Txu496m+U+z9bR5phH1Y7ZrZdYzYPWgXbVBGJpGAqMKXOUef4A",
       "brillig_names": [
-        "sync_notes"
+        "set_portal"
       ]
     }
   ],
@@ -3799,7 +3735,7 @@
               "type": {
                 "fields": [
                   {
-                    "name": "to",
+                    "name": "portal_address",
                     "type": {
                       "fields": [
                         {
@@ -3810,44 +3746,17 @@
                         }
                       ],
                       "kind": "struct",
-                      "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-                    }
-                  },
-                  {
-                    "name": "amount",
-                    "type": {
-                      "kind": "field"
-                    }
-                  }
-                ],
-                "kind": "struct",
-                "path": "FeeJuice::_increase_public_balance_parameters"
-              }
-            }
-          ],
-          "kind": "struct",
-          "path": "FeeJuice::_increase_public_balance_abi"
-        },
-        {
-          "fields": [
-            {
-              "name": "parameters",
-              "type": {
-                "fields": [
-                  {
-                    "name": "fee_limit",
-                    "type": {
-                      "kind": "field"
+                      "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "FeeJuice::check_balance_parameters"
+                "path": "FeeJuice::set_portal_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "FeeJuice::check_balance_abi"
+          "path": "FeeJuice::set_portal_abi"
         },
         {
           "fields": [
@@ -3856,7 +3765,7 @@
               "type": {
                 "fields": [
                   {
-                    "name": "owner",
+                    "name": "portal_address",
                     "type": {
                       "fields": [
                         {
@@ -3867,23 +3776,23 @@
                         }
                       ],
                       "kind": "struct",
-                      "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+                      "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
+                    }
+                  },
+                  {
+                    "name": "initial_mint",
+                    "type": {
+                      "kind": "field"
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "FeeJuice::balance_of_public_parameters"
-              }
-            },
-            {
-              "name": "return_type",
-              "type": {
-                "kind": "field"
+                "path": "FeeJuice::initialize_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "FeeJuice::balance_of_public_abi"
+          "path": "FeeJuice::initialize_abi"
         },
         {
           "fields": [
@@ -3892,7 +3801,7 @@
               "type": {
                 "fields": [
                   {
-                    "name": "portal_address",
+                    "name": "to",
                     "type": {
                       "fields": [
                         {
@@ -3903,17 +3812,23 @@
                         }
                       ],
                       "kind": "struct",
-                      "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
+                      "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+                    }
+                  },
+                  {
+                    "name": "amount",
+                    "type": {
+                      "kind": "field"
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "FeeJuice::set_portal_parameters"
+                "path": "FeeJuice::_increase_public_balance_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "FeeJuice::set_portal_abi"
+          "path": "FeeJuice::_increase_public_balance_abi"
         },
         {
           "fields": [
@@ -3970,7 +3885,28 @@
               "type": {
                 "fields": [
                   {
-                    "name": "portal_address",
+                    "name": "fee_limit",
+                    "type": {
+                      "kind": "field"
+                    }
+                  }
+                ],
+                "kind": "struct",
+                "path": "FeeJuice::check_balance_parameters"
+              }
+            }
+          ],
+          "kind": "struct",
+          "path": "FeeJuice::check_balance_abi"
+        },
+        {
+          "fields": [
+            {
+              "name": "parameters",
+              "type": {
+                "fields": [
+                  {
+                    "name": "owner",
                     "type": {
                       "fields": [
                         {
@@ -3981,23 +3917,23 @@
                         }
                       ],
                       "kind": "struct",
-                      "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
-                    }
-                  },
-                  {
-                    "name": "initial_mint",
-                    "type": {
-                      "kind": "field"
+                      "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "FeeJuice::initialize_parameters"
+                "path": "FeeJuice::balance_of_public_parameters"
+              }
+            },
+            {
+              "name": "return_type",
+              "type": {
+                "kind": "field"
               }
             }
           ],
           "kind": "struct",
-          "path": "FeeJuice::initialize_abi"
+          "path": "FeeJuice::balance_of_public_abi"
         }
       ]
     }
@@ -4017,16 +3953,12 @@
     },
     "26": {
       "path": "std/hash/poseidon2.nr",
-      "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n    cache: [Field; 3],\n    state: [Field; 4],\n    cache_size: u32,\n    squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        if message_size == N {\n            Poseidon2::hash_internal(input, N, false)\n        } else {\n            Poseidon2::hash_internal(input, message_size, true)\n        }\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2 {\n        let mut result =\n            Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = crate::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let two_pow_64 = 18446744073709551616;\n        let iv: Field = (in_len as Field) * two_pow_64;\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n        // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n        // fixed-length and variable-length hashes do not collide)\n        if is_variable_length {\n            sponge.absorb(1);\n        }\n        sponge.squeeze()\n    }\n}\n\npub struct Poseidon2Hasher {\n    _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n    fn finish(self) -> Field {\n        let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..self._state.len() {\n            sponge.absorb(self._state[i]);\n        }\n        sponge.squeeze()\n    }\n\n    fn write(&mut self, input: Field) {\n        self._state = self._state.push_back(input);\n    }\n}\n\nimpl Default for Poseidon2Hasher {\n    fn default() -> Self {\n        Poseidon2Hasher { _state: &[] }\n    }\n}\n"
+      "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n    cache: [Field; 3],\n    state: [Field; 4],\n    cache_size: u32,\n    squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2 {\n        let mut result =\n            Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = crate::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let two_pow_64 = 18446744073709551616;\n        let iv: Field = (in_len as Field) * two_pow_64;\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n        // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n        // fixed-length and variable-length hashes do not collide)\n        if is_variable_length {\n            sponge.absorb(1);\n        }\n        sponge.squeeze()\n    }\n}\n\npub struct Poseidon2Hasher {\n    _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n    fn finish(self) -> Field {\n        let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..self._state.len() {\n            sponge.absorb(self._state[i]);\n        }\n        sponge.squeeze()\n    }\n\n    fn write(&mut self, input: Field) {\n        self._state = self._state.push_back(input);\n    }\n}\n\nimpl Default for Poseidon2Hasher {\n    fn default() -> Self {\n        Poseidon2Hasher { _state: &[] }\n    }\n}\n"
     },
     "27": {
       "path": "std/hash/sha256.nr",
       "source": "use crate::runtime::is_unconstrained;\n\n// Implementation of SHA-256 mapping a byte array of variable length to\n// 32 bytes.\n\n// A message block is up to 64 bytes taken from the input.\nglobal BLOCK_SIZE: u32 = 64;\n\n// The first index in the block where the 8 byte message size will be written.\nglobal MSG_SIZE_PTR: u32 = 56;\n\n// Size of the message block when packed as 4-byte integer array.\nglobal INT_BLOCK_SIZE: u32 = 16;\n\n// A `u32` integer consists of 4 bytes.\nglobal INT_SIZE: u32 = 4;\n\n// Index of the integer in the `INT_BLOCK` where the length is written.\nglobal INT_SIZE_PTR: u32 = MSG_SIZE_PTR / INT_SIZE;\n\n// Magic numbers for bit shifting.\n// Works with actual bit shifting as well as the compiler turns them into * and /\n// but circuit execution appears to be 10% faster this way.\nglobal TWO_POW_8: u32 = 256;\nglobal TWO_POW_16: u32 = TWO_POW_8 * 256;\nglobal TWO_POW_24: u32 = TWO_POW_16 * 256;\nglobal TWO_POW_32: u64 = TWO_POW_24 as u64 * 256;\n\n// Index of a byte in a 64 byte block; ie. 0..=63\ntype BLOCK_BYTE_PTR = u32;\n\n// The foreign function to compress blocks works on 16 pieces of 4-byte integers, instead of 64 bytes.\ntype INT_BLOCK = [u32; INT_BLOCK_SIZE];\n\n// A message block is a slice of the original message of a fixed size,\n// potentially padded with zeros, with neighbouring 4 bytes packed into integers.\ntype MSG_BLOCK = INT_BLOCK;\n\n// The hash is 32 bytes.\ntype HASH = [u8; 32];\n\n// The state accumulates the blocks.\n// Its overall size is the same as the `HASH`.\ntype STATE = [u32; 8];\n\n// Deprecated in favour of `sha256_var`\n// docs:start:sha256\npub fn sha256<let N: u32>(input: [u8; N]) -> HASH\n// docs:end:sha256\n{\n    digest(input)\n}\n\n#[foreign(sha256_compression)]\npub fn sha256_compression(_input: INT_BLOCK, _state: STATE) -> STATE {}\n\n// SHA-256 hash function\n#[no_predicates]\npub fn digest<let N: u32>(msg: [u8; N]) -> HASH {\n    sha256_var(msg, N as u64)\n}\n\n// Variable size SHA-256 hash\npub fn sha256_var<let N: u32>(msg: [u8; N], message_size: u64) -> HASH {\n    let message_size = message_size as u32;\n    let num_blocks = N / BLOCK_SIZE;\n    let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n    // Intermediate hash, starting with the canonical initial value\n    let mut h: STATE = [\n        1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635,\n        1541459225,\n    ];\n    // Pointer into msg_block on a 64 byte scale\n    let mut msg_byte_ptr = 0;\n    for i in 0..num_blocks {\n        let msg_start = BLOCK_SIZE * i;\n        let (new_msg_block, new_msg_byte_ptr) =\n            unsafe { build_msg_block(msg, message_size, msg_start) };\n\n        if msg_start < message_size {\n            msg_block = new_msg_block;\n        }\n\n        if !is_unconstrained() {\n            // Verify the block we are compressing was appropriately constructed\n            let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n            if msg_start < message_size {\n                msg_byte_ptr = new_msg_byte_ptr;\n            }\n        } else if msg_start < message_size {\n            msg_byte_ptr = new_msg_byte_ptr;\n        }\n\n        // If the block is filled, compress it.\n        // An un-filled block is handled after this loop.\n        if (msg_start < message_size) & (msg_byte_ptr == BLOCK_SIZE) {\n            h = sha256_compression(msg_block, h);\n        }\n    }\n\n    let modulo = N % BLOCK_SIZE;\n    // Handle setup of the final msg block.\n    // This case is only hit if the msg is less than the block size,\n    // or our message cannot be evenly split into blocks.\n    if modulo != 0 {\n        let msg_start = BLOCK_SIZE * num_blocks;\n        let (new_msg_block, new_msg_byte_ptr) =\n            unsafe { build_msg_block(msg, message_size, msg_start) };\n\n        if msg_start < message_size {\n            msg_block = new_msg_block;\n        }\n\n        if !is_unconstrained() {\n            let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n            if msg_start < message_size {\n                msg_byte_ptr = new_msg_byte_ptr;\n                verify_msg_block_padding(msg_block, msg_byte_ptr);\n            }\n        } else if msg_start < message_size {\n            msg_byte_ptr = new_msg_byte_ptr;\n        }\n    }\n\n    // If we had modulo == 0 then it means the last block was full,\n    // and we can reset the pointer to zero to overwrite it.\n    if msg_byte_ptr == BLOCK_SIZE {\n        msg_byte_ptr = 0;\n    }\n\n    // Pad the rest such that we have a [u32; 2] block at the end representing the length\n    // of the message, and a block of 1 0 ... 0 following the message (i.e. [1 << 7, 0, ..., 0]).\n    // Here we rely on the fact that everything beyond the available input is set to 0.\n    msg_block = update_block_item(\n        msg_block,\n        msg_byte_ptr,\n        |msg_item| set_item_byte_then_zeros(msg_item, msg_byte_ptr, 1 << 7),\n    );\n    msg_byte_ptr = msg_byte_ptr + 1;\n    let last_block = msg_block;\n\n    // If we don't have room to write the size, compress the block and reset it.\n    if msg_byte_ptr > MSG_SIZE_PTR {\n        h = sha256_compression(msg_block, h);\n        // `attach_len_to_msg_block` will zero out everything after the `msg_byte_ptr`.\n        msg_byte_ptr = 0;\n    }\n\n    msg_block = unsafe { attach_len_to_msg_block(msg_block, msg_byte_ptr, message_size) };\n\n    if !is_unconstrained() {\n        verify_msg_len(msg_block, last_block, msg_byte_ptr, message_size);\n    }\n\n    hash_final_block(msg_block, h)\n}\n\n// Take `BLOCK_SIZE` number of bytes from `msg` starting at `msg_start`.\n// Returns the block and the length that has been copied rather than padded with zeros.\nunconstrained fn build_msg_block<let N: u32>(\n    msg: [u8; N],\n    message_size: u32,\n    msg_start: u32,\n) -> (MSG_BLOCK, BLOCK_BYTE_PTR) {\n    let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n\n    // We insert `BLOCK_SIZE` bytes (or up to the end of the message)\n    let block_input = if msg_start + BLOCK_SIZE > message_size {\n        if message_size < msg_start {\n            // This function is sometimes called with `msg_start` past the end of the message.\n            // In this case we return an empty block and zero pointer to signal that the result should be ignored.\n            0\n        } else {\n            message_size - msg_start\n        }\n    } else {\n        BLOCK_SIZE\n    };\n\n    // Figure out the number of items in the int array that we have to pack.\n    // e.g. if the input is [0,1,2,3,4,5] then we need to pack it as 2 items: [0123, 4500]\n    let mut int_input = block_input / INT_SIZE;\n    if block_input % INT_SIZE != 0 {\n        int_input = int_input + 1;\n    };\n\n    for i in 0..int_input {\n        let mut msg_item: u32 = 0;\n        // Always construct the integer as 4 bytes, even if it means going beyond the input.\n        for j in 0..INT_SIZE {\n            let k = i * INT_SIZE + j;\n            let msg_byte = if k < block_input {\n                msg[msg_start + k]\n            } else {\n                0\n            };\n            msg_item = lshift8(msg_item, 1) + msg_byte as u32;\n        }\n        msg_block[i] = msg_item;\n    }\n\n    // Returning the index as if it was a 64 byte array.\n    // We have to project it down to 16 items and bit shifting to get a byte back if we need it.\n    (msg_block, block_input)\n}\n\n// Verify the block we are compressing was appropriately constructed by `build_msg_block`\n// and matches the input data. Returns the index of the first unset item.\n// If `message_size` is less than `msg_start` then this is called with the old non-empty block;\n// in that case we can skip verification, ie. no need to check that everything is zero.\nfn verify_msg_block<let N: u32>(\n    msg: [u8; N],\n    message_size: u32,\n    msg_block: MSG_BLOCK,\n    msg_start: u32,\n) -> BLOCK_BYTE_PTR {\n    let mut msg_byte_ptr = 0;\n    let mut msg_end = msg_start + BLOCK_SIZE;\n    if msg_end > N {\n        msg_end = N;\n    }\n    // We might have to go beyond the input to pad the fields.\n    if msg_end % INT_SIZE != 0 {\n        msg_end = msg_end + INT_SIZE - msg_end % INT_SIZE;\n    }\n\n    // Reconstructed packed item.\n    let mut msg_item: u32 = 0;\n\n    // Inclusive at the end so that we can compare the last item.\n    let mut i: u32 = 0;\n    for k in msg_start..=msg_end {\n        if k % INT_SIZE == 0 {\n            // If we consumed some input we can compare against the block.\n            if (msg_start < message_size) & (k > msg_start) {\n                assert_eq(msg_block[i], msg_item as u32);\n                i = i + 1;\n                msg_item = 0;\n            }\n        }\n        // Shift the accumulator\n        msg_item = lshift8(msg_item, 1);\n        // If we have input to consume, add it at the rightmost position.\n        if k < message_size & k < msg_end {\n            msg_item = msg_item + msg[k] as u32;\n            msg_byte_ptr = msg_byte_ptr + 1;\n        }\n    }\n\n    msg_byte_ptr\n}\n\n// Verify the block we are compressing was appropriately padded with zeros by `build_msg_block`.\n// This is only relevant for the last, potentially partially filled block.\nfn verify_msg_block_padding(msg_block: MSG_BLOCK, msg_byte_ptr: BLOCK_BYTE_PTR) {\n    // Check all the way to the end of the block.\n    verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_BLOCK_SIZE);\n}\n\n// Verify that a region of ints in the message block are (partially) zeroed,\n// up to an (exclusive) maximum which can either be the end of the block\n// or just where the size is to be written.\nfn verify_msg_block_zeros(\n    msg_block: MSG_BLOCK,\n    mut msg_byte_ptr: BLOCK_BYTE_PTR,\n    max_int_byte_ptr: u32,\n) {\n    // This variable is used to get around the compiler under-constrained check giving a warning.\n    // We want to check against a constant zero, but if it does not come from the circuit inputs\n    // or return values the compiler check will issue a warning.\n    let zero = msg_block[0] - msg_block[0];\n\n    // First integer which is supposed to be (partially) zero.\n    let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n    // Check partial zeros.\n    let modulo = msg_byte_ptr % INT_SIZE;\n    if modulo != 0 {\n        let zeros = INT_SIZE - modulo;\n        let mask = if zeros == 3 {\n            TWO_POW_24\n        } else if zeros == 2 {\n            TWO_POW_16\n        } else {\n            TWO_POW_8\n        };\n        assert_eq(msg_block[int_byte_ptr] % mask, zero);\n        int_byte_ptr = int_byte_ptr + 1;\n    }\n\n    // Check the rest of the items.\n    for i in 0..max_int_byte_ptr {\n        if i >= int_byte_ptr {\n            assert_eq(msg_block[i], zero);\n        }\n    }\n}\n\n// Verify that up to the byte pointer the two blocks are equal.\n// At the byte pointer the new block can be partially zeroed.\nfn verify_msg_block_equals_last(\n    msg_block: MSG_BLOCK,\n    last_block: MSG_BLOCK,\n    mut msg_byte_ptr: BLOCK_BYTE_PTR,\n) {\n    // msg_byte_ptr is the position at which they are no longer have to be the same.\n    // First integer which is supposed to be (partially) zero contains that pointer.\n    let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n    // Check partial zeros.\n    let modulo = msg_byte_ptr % INT_SIZE;\n    if modulo != 0 {\n        // Reconstruct the partially zero item from the last block.\n        let last_field = last_block[int_byte_ptr];\n        let mut msg_item: u32 = 0;\n        // Reset to where they are still equal.\n        msg_byte_ptr = msg_byte_ptr - modulo;\n        for i in 0..INT_SIZE {\n            msg_item = lshift8(msg_item, 1);\n            if i < modulo {\n                msg_item = msg_item + get_item_byte(last_field, msg_byte_ptr) as u32;\n                msg_byte_ptr = msg_byte_ptr + 1;\n            }\n        }\n        assert_eq(msg_block[int_byte_ptr], msg_item);\n    }\n\n    for i in 0..INT_SIZE_PTR {\n        if i < int_byte_ptr {\n            assert_eq(msg_block[i], last_block[i]);\n        }\n    }\n}\n\n// Apply a function on the block item which the pointer indicates.\nfn update_block_item<Env>(\n    mut msg_block: MSG_BLOCK,\n    msg_byte_ptr: BLOCK_BYTE_PTR,\n    f: fn[Env](u32) -> u32,\n) -> MSG_BLOCK {\n    let i = msg_byte_ptr / INT_SIZE;\n    msg_block[i] = f(msg_block[i]);\n    msg_block\n}\n\n// Set the rightmost `zeros` number of bytes to 0.\nfn set_item_zeros(item: u32, zeros: u8) -> u32 {\n    lshift8(rshift8(item, zeros), zeros)\n}\n\n// Replace one byte in the item with a value, and set everything after it to zero.\nfn set_item_byte_then_zeros(msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR, msg_byte: u8) -> u32 {\n    let zeros = INT_SIZE - msg_byte_ptr % INT_SIZE;\n    let zeroed_item = set_item_zeros(msg_item, zeros as u8);\n    let new_item = byte_into_item(msg_byte, msg_byte_ptr);\n    zeroed_item + new_item\n}\n\n// Get a byte of a message item according to its overall position in the `BLOCK_SIZE` space.\nfn get_item_byte(mut msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR) -> u8 {\n    // How many times do we have to shift to the right to get to the position we want?\n    let max_shifts = INT_SIZE - 1;\n    let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n    msg_item = rshift8(msg_item, shifts as u8);\n    // At this point the byte we want is in the rightmost position.\n    msg_item as u8\n}\n\n// Project a byte into a position in a field based on the overall block pointer.\n// For example putting 1 into pointer 5 would be 100, because overall we would\n// have [____, 0100] with indexes [0123,4567].\nfn byte_into_item(msg_byte: u8, msg_byte_ptr: BLOCK_BYTE_PTR) -> u32 {\n    let mut msg_item = msg_byte as u32;\n    // How many times do we have to shift to the left to get to the position we want?\n    let max_shifts = INT_SIZE - 1;\n    let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n    lshift8(msg_item, shifts as u8)\n}\n\n// Construct a field out of 4 bytes.\nfn make_item(b0: u8, b1: u8, b2: u8, b3: u8) -> u32 {\n    let mut item = b0 as u32;\n    item = lshift8(item, 1) + b1 as u32;\n    item = lshift8(item, 1) + b2 as u32;\n    item = lshift8(item, 1) + b3 as u32;\n    item\n}\n\n// Shift by 8 bits to the left between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise multiplies by 256.\nfn lshift8(item: u32, shifts: u8) -> u32 {\n    if is_unconstrained() {\n        if item == 0 {\n            0\n        } else {\n            // Brillig wouldn't shift 0<<4 without overflow.\n            item << (8 * shifts)\n        }\n    } else {\n        // We can do a for loop up to INT_SIZE or an if-else.\n        if shifts == 0 {\n            item\n        } else if shifts == 1 {\n            item * TWO_POW_8\n        } else if shifts == 2 {\n            item * TWO_POW_16\n        } else if shifts == 3 {\n            item * TWO_POW_24\n        } else {\n            // Doesn't make sense, but it's most likely called on 0 anyway.\n            0\n        }\n    }\n}\n\n// Shift by 8 bits to the right between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise divides by 256.\nfn rshift8(item: u32, shifts: u8) -> u32 {\n    if is_unconstrained() {\n        item >> (8 * shifts)\n    } else {\n        // Division wouldn't work on `Field`.\n        if shifts == 0 {\n            item\n        } else if shifts == 1 {\n            item / TWO_POW_8\n        } else if shifts == 2 {\n            item / TWO_POW_16\n        } else if shifts == 3 {\n            item / TWO_POW_24\n        } else {\n            0\n        }\n    }\n}\n\n// Zero out all bytes between the end of the message and where the length is appended,\n// then write the length into the last 8 bytes of the block.\nunconstrained fn attach_len_to_msg_block(\n    mut msg_block: MSG_BLOCK,\n    mut msg_byte_ptr: BLOCK_BYTE_PTR,\n    message_size: u32,\n) -> MSG_BLOCK {\n    // We assume that `msg_byte_ptr` is less than 57 because if not then it is reset to zero before calling this function.\n    // In any case, fill blocks up with zeros until the last 64 bits (i.e. until msg_byte_ptr = 56).\n    // There can be one item which has to be partially zeroed.\n    let modulo = msg_byte_ptr % INT_SIZE;\n    if modulo != 0 {\n        // Index of the block in which we find the item we need to partially zero.\n        let i = msg_byte_ptr / INT_SIZE;\n        let zeros = INT_SIZE - modulo;\n        msg_block[i] = set_item_zeros(msg_block[i], zeros as u8);\n        msg_byte_ptr = msg_byte_ptr + zeros;\n    }\n\n    // The rest can be zeroed without bit shifting anything.\n    for i in (msg_byte_ptr / INT_SIZE)..INT_SIZE_PTR {\n        msg_block[i] = 0;\n    }\n\n    // Set the last two 4 byte ints as the first/second half of the 8 bytes of the length.\n    let len = 8 * message_size;\n    let len_bytes: [u8; 8] = (len as Field).to_be_bytes();\n    for i in 0..=1 {\n        let shift = i * 4;\n        msg_block[INT_SIZE_PTR + i] = make_item(\n            len_bytes[shift],\n            len_bytes[shift + 1],\n            len_bytes[shift + 2],\n            len_bytes[shift + 3],\n        );\n    }\n    msg_block\n}\n\n// Verify that the message length was correctly written by `attach_len_to_msg_block`,\n// and that everything between the byte pointer and the size pointer was zeroed,\n// and that everything before the byte pointer was untouched.\nfn verify_msg_len(\n    msg_block: MSG_BLOCK,\n    last_block: MSG_BLOCK,\n    msg_byte_ptr: BLOCK_BYTE_PTR,\n    message_size: u32,\n) {\n    // Check zeros up to the size pointer.\n    verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_SIZE_PTR);\n\n    // Check that up to the pointer we match the last block.\n    verify_msg_block_equals_last(msg_block, last_block, msg_byte_ptr);\n\n    // We verify the message length was inserted correctly by reversing the byte decomposition.\n    let mut reconstructed_len: u64 = 0;\n    for i in INT_SIZE_PTR..INT_BLOCK_SIZE {\n        reconstructed_len = reconstructed_len * TWO_POW_32;\n        reconstructed_len = reconstructed_len + msg_block[i] as u64;\n    }\n    let len = 8 * message_size as u64;\n    assert_eq(reconstructed_len, len);\n}\n\n// Perform the final compression, then transform the `STATE` into `HASH`.\nfn hash_final_block(msg_block: MSG_BLOCK, mut state: STATE) -> HASH {\n    let mut out_h: HASH = [0; 32]; // Digest as sequence of bytes\n    // Hash final padded block\n    state = sha256_compression(msg_block, state);\n\n    // Return final hash as byte array\n    for j in 0..8 {\n        let h_bytes: [u8; 4] = (state[j] as Field).to_be_bytes();\n        for k in 0..4 {\n            out_h[4 * j + k] = h_bytes[k];\n        }\n    }\n\n    out_h\n}\n\nmod tests {\n    use super::{\n        attach_len_to_msg_block, build_msg_block, byte_into_item, get_item_byte, make_item,\n        set_item_byte_then_zeros, set_item_zeros,\n    };\n    use super::INT_BLOCK;\n    use super::sha256_var;\n\n    #[test]\n    fn smoke_test() {\n        let input = [0xbd];\n        let result = [\n            0x68, 0x32, 0x57, 0x20, 0xaa, 0xbd, 0x7c, 0x82, 0xf3, 0x0f, 0x55, 0x4b, 0x31, 0x3d,\n            0x05, 0x70, 0xc9, 0x5a, 0xcc, 0xbb, 0x7d, 0xc4, 0xb5, 0xaa, 0xe1, 0x12, 0x04, 0xc0,\n            0x8f, 0xfe, 0x73, 0x2b,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_just_over_block() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116,\n        ];\n        let result = [\n            91, 122, 146, 93, 52, 109, 133, 148, 171, 61, 156, 70, 189, 238, 153, 7, 222, 184, 94,\n            24, 65, 114, 192, 244, 207, 199, 87, 232, 192, 224, 171, 207,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_multiple_over_block() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116, 61, 117, 115, 45, 97, 115,\n            99, 105, 105, 13, 10, 109, 105, 109, 101, 45, 118, 101, 114, 115, 105, 111, 110, 58, 49,\n            46, 48, 32, 40, 77, 97, 99, 32, 79, 83, 32, 88, 32, 77, 97, 105, 108, 32, 49, 54, 46,\n            48, 32, 92, 40, 51, 55, 51, 49, 46, 53, 48, 48, 46, 50, 51, 49, 92, 41, 41, 13, 10, 115,\n            117, 98, 106, 101, 99, 116, 58, 72, 101, 108, 108, 111, 13, 10, 109, 101, 115, 115, 97,\n            103, 101, 45, 105, 100, 58, 60, 56, 70, 56, 49, 57, 68, 51, 50, 45, 66, 54, 65, 67, 45,\n            52, 56, 57, 68, 45, 57, 55, 55, 70, 45, 52, 51, 56, 66, 66, 67, 52, 67, 65, 66, 50, 55,\n            64, 109, 101, 46, 99, 111, 109, 62, 13, 10, 100, 97, 116, 101, 58, 83, 97, 116, 44, 32,\n            50, 54, 32, 65, 117, 103, 32, 50, 48, 50, 51, 32, 49, 50, 58, 50, 53, 58, 50, 50, 32,\n            43, 48, 52, 48, 48, 13, 10, 116, 111, 58, 122, 107, 101, 119, 116, 101, 115, 116, 64,\n            103, 109, 97, 105, 108, 46, 99, 111, 109, 13, 10, 100, 107, 105, 109, 45, 115, 105, 103,\n            110, 97, 116, 117, 114, 101, 58, 118, 61, 49, 59, 32, 97, 61, 114, 115, 97, 45, 115,\n            104, 97, 50, 53, 54, 59, 32, 99, 61, 114, 101, 108, 97, 120, 101, 100, 47, 114, 101,\n            108, 97, 120, 101, 100, 59, 32, 100, 61, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109,\n            59, 32, 115, 61, 49, 97, 49, 104, 97, 105, 59, 32, 116, 61, 49, 54, 57, 51, 48, 51, 56,\n            51, 51, 55, 59, 32, 98, 104, 61, 55, 120, 81, 77, 68, 117, 111, 86, 86, 85, 52, 109, 48,\n            87, 48, 87, 82, 86, 83, 114, 86, 88, 77, 101, 71, 83, 73, 65, 83, 115, 110, 117, 99, 75,\n            57, 100, 74, 115, 114, 99, 43, 118, 85, 61, 59, 32, 104, 61, 102, 114, 111, 109, 58, 67,\n            111, 110, 116, 101, 110, 116, 45, 84, 121, 112, 101, 58, 77, 105, 109, 101, 45, 86, 101,\n            114, 115, 105, 111, 110, 58, 83, 117, 98, 106, 101, 99,\n        ];\n        let result = [\n            116, 90, 151, 31, 78, 22, 138, 180, 211, 189, 69, 76, 227, 200, 155, 29, 59, 123, 154,\n            60, 47, 153, 203, 129, 157, 251, 48, 2, 79, 11, 65, 47,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_just_under_block() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59,\n        ];\n        let result = [\n            143, 140, 76, 173, 222, 123, 102, 68, 70, 149, 207, 43, 39, 61, 34, 79, 216, 252, 213,\n            165, 74, 16, 110, 74, 29, 64, 138, 167, 30, 1, 9, 119,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_big_not_block_multiple() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116, 61, 117, 115, 45, 97, 115,\n            99, 105, 105, 13, 10, 109, 105, 109, 101, 45, 118, 101, 114, 115, 105, 111, 110, 58, 49,\n            46, 48, 32, 40, 77, 97, 99, 32, 79, 83, 32, 88, 32, 77, 97, 105, 108, 32, 49, 54, 46,\n            48, 32, 92, 40, 51, 55, 51, 49, 46, 53, 48, 48, 46, 50, 51, 49, 92, 41, 41, 13, 10, 115,\n            117, 98, 106, 101, 99, 116, 58, 72, 101, 108, 108, 111, 13, 10, 109, 101, 115, 115, 97,\n            103, 101, 45, 105, 100, 58, 60, 56, 70, 56, 49, 57, 68, 51, 50, 45, 66, 54, 65, 67, 45,\n            52, 56, 57, 68, 45, 57, 55, 55, 70, 45, 52, 51, 56, 66, 66, 67, 52, 67, 65, 66, 50, 55,\n            64, 109, 101, 46, 99, 111, 109, 62, 13, 10, 100, 97, 116, 101, 58, 83, 97, 116, 44, 32,\n            50, 54, 32, 65, 117, 103, 32, 50, 48, 50, 51, 32, 49, 50, 58, 50, 53, 58, 50, 50, 32,\n            43, 48, 52, 48, 48, 13, 10, 116, 111, 58, 122, 107, 101, 119, 116, 101, 115, 116, 64,\n            103, 109, 97, 105, 108, 46, 99, 111, 109, 13, 10, 100, 107, 105, 109, 45, 115, 105, 103,\n            110, 97, 116, 117, 114, 101, 58, 118, 61, 49, 59, 32, 97, 61, 114, 115, 97, 45, 115,\n            104, 97, 50, 53, 54, 59, 32, 99, 61, 114, 101, 108, 97, 120, 101, 100, 47, 114, 101,\n            108, 97, 120, 101, 100, 59, 32, 100, 61, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109,\n            59, 32, 115, 61, 49, 97, 49, 104, 97, 105, 59, 32, 116, 61, 49, 54, 57, 51, 48, 51, 56,\n            51, 51, 55, 59, 32, 98, 104, 61, 55, 120, 81, 77, 68, 117, 111, 86, 86, 85, 52, 109, 48,\n            87, 48, 87, 82, 86, 83, 114, 86, 88, 77, 101, 71, 83, 73, 65, 83, 115, 110, 117, 99, 75,\n            57, 100, 74, 115, 114, 99, 43, 118, 85, 61, 59, 32, 104, 61, 102, 114, 111, 109, 58, 67,\n            111, 110, 116, 101, 110, 116, 45, 84, 121, 112, 101, 58, 77, 105, 109, 101, 45, 86, 101,\n            114, 115, 105, 111, 110, 58, 83, 117, 98, 106, 101, 99, 116, 58, 77, 101, 115, 115, 97,\n            103, 101, 45, 73, 100, 58, 68, 97, 116, 101, 58, 116, 111, 59, 32, 98, 61,\n        ];\n        let result = [\n            112, 144, 73, 182, 208, 98, 9, 238, 54, 229, 61, 145, 222, 17, 72, 62, 148, 222, 186,\n            55, 192, 82, 220, 35, 66, 47, 193, 200, 22, 38, 26, 186,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_big_with_padding() {\n        let input = [\n            48, 130, 1, 37, 2, 1, 0, 48, 11, 6, 9, 96, 134, 72, 1, 101, 3, 4, 2, 1, 48, 130, 1, 17,\n            48, 37, 2, 1, 1, 4, 32, 176, 223, 31, 133, 108, 84, 158, 102, 70, 11, 165, 175, 196, 12,\n            201, 130, 25, 131, 46, 125, 156, 194, 28, 23, 55, 133, 157, 164, 135, 136, 220, 78, 48,\n            37, 2, 1, 2, 4, 32, 190, 82, 180, 235, 222, 33, 79, 50, 152, 136, 142, 35, 116, 224, 6,\n            242, 156, 141, 128, 248, 10, 61, 98, 86, 248, 45, 207, 210, 90, 232, 175, 38, 48, 37, 2,\n            1, 3, 4, 32, 0, 194, 104, 108, 237, 246, 97, 230, 116, 198, 69, 110, 26, 87, 17, 89,\n            110, 199, 108, 250, 36, 21, 39, 87, 110, 102, 250, 213, 174, 131, 171, 174, 48, 37, 2,\n            1, 11, 4, 32, 136, 155, 87, 144, 111, 15, 152, 127, 85, 25, 154, 81, 20, 58, 51, 75,\n            193, 116, 234, 0, 60, 30, 29, 30, 183, 141, 72, 247, 255, 203, 100, 124, 48, 37, 2, 1,\n            12, 4, 32, 41, 234, 106, 78, 31, 11, 114, 137, 237, 17, 92, 71, 134, 47, 62, 78, 189,\n            233, 201, 214, 53, 4, 47, 189, 201, 133, 6, 121, 34, 131, 64, 142, 48, 37, 2, 1, 13, 4,\n            32, 91, 222, 210, 193, 62, 222, 104, 82, 36, 41, 138, 253, 70, 15, 148, 208, 156, 45,\n            105, 171, 241, 195, 185, 43, 217, 162, 146, 201, 222, 89, 238, 38, 48, 37, 2, 1, 14, 4,\n            32, 76, 123, 216, 13, 51, 227, 72, 245, 59, 193, 238, 166, 103, 49, 23, 164, 171, 188,\n            194, 197, 156, 187, 249, 28, 198, 95, 69, 15, 182, 56, 54, 38, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n        ];\n        let result = [\n            32, 85, 108, 174, 127, 112, 178, 182, 8, 43, 134, 123, 192, 211, 131, 66, 184, 240, 212,\n            181, 240, 180, 106, 195, 24, 117, 54, 129, 19, 10, 250, 53,\n        ];\n        let message_size = 297;\n        assert_eq(sha256_var(input, message_size), result);\n    }\n\n    #[test]\n    fn msg_big_no_padding() {\n        let input = [\n            48, 130, 1, 37, 2, 1, 0, 48, 11, 6, 9, 96, 134, 72, 1, 101, 3, 4, 2, 1, 48, 130, 1, 17,\n            48, 37, 2, 1, 1, 4, 32, 176, 223, 31, 133, 108, 84, 158, 102, 70, 11, 165, 175, 196, 12,\n            201, 130, 25, 131, 46, 125, 156, 194, 28, 23, 55, 133, 157, 164, 135, 136, 220, 78, 48,\n            37, 2, 1, 2, 4, 32, 190, 82, 180, 235, 222, 33, 79, 50, 152, 136, 142, 35, 116, 224, 6,\n            242, 156, 141, 128, 248, 10, 61, 98, 86, 248, 45, 207, 210, 90, 232, 175, 38, 48, 37, 2,\n            1, 3, 4, 32, 0, 194, 104, 108, 237, 246, 97, 230, 116, 198, 69, 110, 26, 87, 17, 89,\n            110, 199, 108, 250, 36, 21, 39, 87, 110, 102, 250, 213, 174, 131, 171, 174, 48, 37, 2,\n            1, 11, 4, 32, 136, 155, 87, 144, 111, 15, 152, 127, 85, 25, 154, 81, 20, 58, 51, 75,\n            193, 116, 234, 0, 60, 30, 29, 30, 183, 141, 72, 247, 255, 203, 100, 124, 48, 37, 2, 1,\n            12, 4, 32, 41, 234, 106, 78, 31, 11, 114, 137, 237, 17, 92, 71, 134, 47, 62, 78, 189,\n            233, 201, 214, 53, 4, 47, 189, 201, 133, 6, 121, 34, 131, 64, 142, 48, 37, 2, 1, 13, 4,\n            32, 91, 222, 210, 193, 62, 222, 104, 82, 36, 41, 138, 253, 70, 15, 148, 208, 156, 45,\n            105, 171, 241, 195, 185, 43, 217, 162, 146, 201, 222, 89, 238, 38, 48, 37, 2, 1, 14, 4,\n            32, 76, 123, 216, 13, 51, 227, 72, 245, 59, 193, 238, 166, 103, 49, 23, 164, 171, 188,\n            194, 197, 156, 187, 249, 28, 198, 95, 69, 15, 182, 56, 54, 38,\n        ];\n        let result = [\n            32, 85, 108, 174, 127, 112, 178, 182, 8, 43, 134, 123, 192, 211, 131, 66, 184, 240, 212,\n            181, 240, 180, 106, 195, 24, 117, 54, 129, 19, 10, 250, 53,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn same_msg_len_variable_padding() {\n        let input = [\n            29, 81, 165, 84, 243, 114, 101, 37, 242, 146, 127, 99, 69, 145, 39, 72, 213, 39, 253,\n            179, 218, 37, 217, 201, 172, 93, 198, 50, 249, 70, 15, 30, 162, 112, 187, 40, 140, 9,\n            236, 53, 32, 44, 38, 163, 113, 254, 192, 197, 44, 89, 71, 130, 169, 242, 17, 211, 214,\n            72, 19, 178, 186, 168, 147, 127, 99, 101, 252, 227, 8, 147, 150, 85, 97, 158, 17, 107,\n            218, 244, 82, 113, 247, 91, 208, 214, 60, 244, 87, 137, 173, 201, 130, 18, 66, 56, 198,\n            149, 207, 189, 175, 120, 123, 224, 177, 167, 251, 159, 143, 110, 68, 183, 189, 70, 126,\n            32, 35, 164, 44, 30, 44, 12, 65, 18, 62, 239, 242, 2, 248, 104, 2, 178, 64, 28, 126, 36,\n            137, 24, 14, 116, 91, 98, 90, 159, 218, 102, 45, 11, 110, 223, 245, 184, 52, 99, 59,\n            245, 136, 175, 3, 72, 164, 146, 145, 116, 22, 66, 24, 49, 193, 121, 3, 60, 37, 41, 97,\n            3, 190, 66, 195, 225, 63, 46, 3, 118, 4, 208, 15, 1, 40, 254, 235, 151, 123, 70, 180,\n            170, 44, 172, 90, 4, 254, 53, 239, 116, 246, 67, 56, 129, 61, 22, 169, 213, 65, 27, 216,\n            116, 162, 239, 214, 207, 126, 177, 20, 100, 25, 48, 143, 84, 215, 70, 197, 53, 65, 70,\n            86, 172, 61, 62, 9, 212, 167, 169, 133, 41, 126, 213, 196, 33, 192, 238, 0, 63, 246,\n            215, 58, 128, 110, 101, 92, 3, 170, 214, 130, 149, 52, 81, 125, 118, 233, 3, 118, 193,\n            104, 207, 120, 115, 77, 253, 191, 122, 0, 107, 164, 207, 113, 81, 169, 36, 201, 228, 74,\n            134, 131, 218, 178, 35, 30, 216, 101, 2, 103, 174, 87, 95, 50, 50, 215, 157, 5, 210,\n            188, 54, 211, 78, 45, 199, 96, 121, 241, 241, 176, 226, 194, 134, 130, 89, 217, 210,\n            186, 32, 140, 39, 91, 103, 212, 26, 87, 32, 72, 144, 228, 230, 117, 99, 188, 50, 15, 69,\n            79, 179, 50, 12, 106, 86, 218, 101, 73, 142, 243, 29, 250, 122, 228, 233, 29, 255, 22,\n            121, 114, 125, 103, 41, 250, 241, 179, 126, 158, 198, 116, 209, 65, 94, 98, 228, 175,\n            169, 96, 3, 9, 233, 133, 214, 55, 161, 164, 103, 80, 85, 24, 186, 64, 167, 92, 131, 53,\n            101, 202, 47, 25, 104, 118, 155, 14, 12, 12, 25, 116, 45, 221, 249, 28, 246, 212, 200,\n            157, 167, 169, 56, 197, 181, 4, 245, 146, 1, 140, 234, 191, 212, 228, 125, 87, 81, 86,\n            119, 30, 63, 129, 143, 32, 96,\n        ];\n\n        // Prepare inputs of different lengths\n        let mut input_511 = [0; 511];\n        let mut input_512 = [0; 512]; // Next block\n        let mut input_575 = [0; 575];\n        let mut input_576 = [0; 576]; // Next block\n        for i in 0..input.len() {\n            input_511[i] = input[i];\n            input_512[i] = input[i];\n            input_575[i] = input[i];\n            input_576[i] = input[i];\n        }\n\n        // Compute hashes of all inputs (with same message length)\n        let fixed_length_hash = super::sha256(input);\n        let var_full_length_hash = sha256_var(input, input.len() as u64);\n        let var_length_hash_511 = sha256_var(input_511, input.len() as u64);\n        let var_length_hash_512 = sha256_var(input_512, input.len() as u64);\n        let var_length_hash_575 = sha256_var(input_575, input.len() as u64);\n        let var_length_hash_576 = sha256_var(input_576, input.len() as u64);\n\n        // All of the above should have produced the same hash\n        assert_eq(var_full_length_hash, fixed_length_hash);\n        assert_eq(var_length_hash_511, fixed_length_hash);\n        assert_eq(var_length_hash_512, fixed_length_hash);\n        assert_eq(var_length_hash_575, fixed_length_hash);\n        assert_eq(var_length_hash_576, fixed_length_hash);\n    }\n\n    #[test]\n    fn test_get_item_byte() {\n        let fld = make_item(10, 20, 30, 40);\n        assert_eq(fld, 0x0a141e28);\n        assert_eq(get_item_byte(fld, 0), 10);\n        assert_eq(get_item_byte(fld, 4), 10);\n        assert_eq(get_item_byte(fld, 6), 30);\n    }\n\n    #[test]\n    fn test_byte_into_item() {\n        let fld = make_item(0, 20, 0, 0);\n        assert_eq(byte_into_item(20, 1), fld);\n        assert_eq(byte_into_item(20, 5), fld);\n    }\n\n    #[test]\n    fn test_set_item_zeros() {\n        let fld0 = make_item(10, 20, 30, 40);\n        let fld1 = make_item(10, 0, 0, 0);\n        assert_eq(set_item_zeros(fld0, 3), fld1);\n        assert_eq(set_item_zeros(fld0, 4), 0);\n        assert_eq(set_item_zeros(0, 4), 0);\n    }\n\n    #[test]\n    fn test_set_item_byte_then_zeros() {\n        let fld0 = make_item(10, 20, 30, 40);\n        let fld1 = make_item(10, 50, 0, 0);\n        assert_eq(set_item_byte_then_zeros(fld0, 1, 50), fld1);\n    }\n\n    #[test]\n    fn test_build_msg_block_start_0() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48,\n        ];\n        assert_eq(input.len(), 22);\n        let (msg_block, msg_byte_ptr) = unsafe { build_msg_block(input, input.len(), 0) };\n        assert_eq(msg_byte_ptr, input.len());\n        assert_eq(msg_block[0], make_item(input[0], input[1], input[2], input[3]));\n        assert_eq(msg_block[1], make_item(input[4], input[5], input[6], input[7]));\n        assert_eq(msg_block[5], make_item(input[20], input[21], 0, 0));\n        assert_eq(msg_block[6], 0);\n    }\n\n    #[test]\n    fn test_build_msg_block_start_1() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116,\n        ];\n        assert_eq(input.len(), 68);\n        let (msg_block, msg_byte_ptr) = unsafe { build_msg_block(input, input.len(), 64) };\n        assert_eq(msg_byte_ptr, 4);\n        assert_eq(msg_block[0], make_item(input[64], input[65], input[66], input[67]));\n        assert_eq(msg_block[1], 0);\n    }\n\n    #[test]\n    fn test_attach_len_to_msg_block() {\n        let input: INT_BLOCK = [\n            2152555847, 1397309779, 1936618851, 1262052426, 1936876331, 1985297723, 543702374,\n            1919905082, 1131376244, 1701737517, 1417244773, 978151789, 1697470053, 1920166255,\n            1849316213, 1651139939,\n        ];\n        let msg_block = unsafe { attach_len_to_msg_block(input, 1, 448) };\n        assert_eq(msg_block[0], ((1 << 7) as u32) * 256 * 256 * 256);\n        assert_eq(msg_block[1], 0);\n        assert_eq(msg_block[15], 3584);\n    }\n}\n"
     },
-    "50": {
-      "path": "std/option.nr",
-      "source": "use crate::cmp::{Eq, Ord, Ordering};\nuse crate::default::Default;\nuse crate::hash::{Hash, Hasher};\n\npub struct Option<T> {\n    _is_some: bool,\n    _value: T,\n}\n\nimpl<T> Option<T> {\n    /// Constructs a None value\n    pub fn none() -> Self {\n        Self { _is_some: false, _value: crate::mem::zeroed() }\n    }\n\n    /// Constructs a Some wrapper around the given value\n    pub fn some(_value: T) -> Self {\n        Self { _is_some: true, _value }\n    }\n\n    /// True if this Option is None\n    pub fn is_none(self) -> bool {\n        !self._is_some\n    }\n\n    /// True if this Option is Some\n    pub fn is_some(self) -> bool {\n        self._is_some\n    }\n\n    /// Asserts `self.is_some()` and returns the wrapped value.\n    pub fn unwrap(self) -> T {\n        assert(self._is_some);\n        self._value\n    }\n\n    /// Returns the inner value without asserting `self.is_some()`\n    /// Note that if `self` is `None`, there is no guarantee what value will be returned,\n    /// only that it will be of type `T`.\n    pub fn unwrap_unchecked(self) -> T {\n        self._value\n    }\n\n    /// Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.\n    pub fn unwrap_or(self, default: T) -> T {\n        if self._is_some {\n            self._value\n        } else {\n            default\n        }\n    }\n\n    /// Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return\n    /// a default value.\n    pub fn unwrap_or_else<Env>(self, default: fn[Env]() -> T) -> T {\n        if self._is_some {\n            self._value\n        } else {\n            default()\n        }\n    }\n\n    /// Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value\n    pub fn expect<let N: u32, MessageTypes>(self, message: fmtstr<N, MessageTypes>) -> T {\n        assert(self.is_some(), message);\n        self._value\n    }\n\n    /// If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.\n    pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> Option<U> {\n        if self._is_some {\n            Option::some(f(self._value))\n        } else {\n            Option::none()\n        }\n    }\n\n    /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.\n    pub fn map_or<U, Env>(self, default: U, f: fn[Env](T) -> U) -> U {\n        if self._is_some {\n            f(self._value)\n        } else {\n            default\n        }\n    }\n\n    /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.\n    pub fn map_or_else<U, Env1, Env2>(self, default: fn[Env1]() -> U, f: fn[Env2](T) -> U) -> U {\n        if self._is_some {\n            f(self._value)\n        } else {\n            default()\n        }\n    }\n\n    /// Returns None if self is None. Otherwise, this returns `other`.\n    pub fn and(self, other: Self) -> Self {\n        if self.is_none() {\n            Option::none()\n        } else {\n            other\n        }\n    }\n\n    /// If self is None, this returns None. Otherwise, this calls the given function\n    /// with the Some value contained within self, and returns the result of that call.\n    ///\n    /// In some languages this function is called `flat_map` or `bind`.\n    pub fn and_then<U, Env>(self, f: fn[Env](T) -> Option<U>) -> Option<U> {\n        if self._is_some {\n            f(self._value)\n        } else {\n            Option::none()\n        }\n    }\n\n    /// If self is Some, return self. Otherwise, return `other`.\n    pub fn or(self, other: Self) -> Self {\n        if self._is_some {\n            self\n        } else {\n            other\n        }\n    }\n\n    /// If self is Some, return self. Otherwise, return `default()`.\n    pub fn or_else<Env>(self, default: fn[Env]() -> Self) -> Self {\n        if self._is_some {\n            self\n        } else {\n            default()\n        }\n    }\n\n    // If only one of the two Options is Some, return that option.\n    // Otherwise, if both options are Some or both are None, None is returned.\n    pub fn xor(self, other: Self) -> Self {\n        if self._is_some {\n            if other._is_some {\n                Option::none()\n            } else {\n                self\n            }\n        } else if other._is_some {\n            other\n        } else {\n            Option::none()\n        }\n    }\n\n    /// Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true.\n    /// Otherwise, this returns `None`\n    pub fn filter<Env>(self, predicate: fn[Env](T) -> bool) -> Self {\n        if self._is_some {\n            if predicate(self._value) {\n                self\n            } else {\n                Option::none()\n            }\n        } else {\n            Option::none()\n        }\n    }\n\n    /// Flattens an Option<Option<T>> into a Option<T>.\n    /// This returns None if the outer Option is None. Otherwise, this returns the inner Option.\n    pub fn flatten(option: Option<Option<T>>) -> Option<T> {\n        if option._is_some {\n            option._value\n        } else {\n            Option::none()\n        }\n    }\n}\n\nimpl<T> Default for Option<T> {\n    fn default() -> Self {\n        Option::none()\n    }\n}\n\nimpl<T> Eq for Option<T>\nwhere\n    T: Eq,\n{\n    fn eq(self, other: Self) -> bool {\n        if self._is_some == other._is_some {\n            if self._is_some {\n                self._value == other._value\n            } else {\n                true\n            }\n        } else {\n            false\n        }\n    }\n}\n\nimpl<T> Hash for Option<T>\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self._is_some.hash(state);\n        if self._is_some {\n            self._value.hash(state);\n        }\n    }\n}\n\n// For this impl we're declaring Option::none < Option::some\nimpl<T> Ord for Option<T>\nwhere\n    T: Ord,\n{\n    fn cmp(self, other: Self) -> Ordering {\n        if self._is_some {\n            if other._is_some {\n                self._value.cmp(other._value)\n            } else {\n                Ordering::greater()\n            }\n        } else if other._is_some {\n            Ordering::less()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n"
-    },
     "51": {
       "path": "std/panic.nr",
       "source": "pub fn panic<T, U, let N: u32>(message: fmtstr<N, T>) -> U {\n    assert(false, message);\n    crate::mem::zeroed()\n}\n"
@@ -4035,115 +3967,115 @@
       "path": "std/uint128.nr",
       "source": "use crate::cmp::{Eq, Ord, Ordering};\nuse crate::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Not, Rem, Shl, Shr, Sub};\n\nglobal pow64: Field = 18446744073709551616; //2^64;\nglobal pow63: Field = 9223372036854775808; // 2^63;\npub struct U128 {\n    pub(crate) lo: Field,\n    pub(crate) hi: Field,\n}\n\nimpl U128 {\n\n    pub fn from_u64s_le(lo: u64, hi: u64) -> U128 {\n        // in order to handle multiplication, we need to represent the product of two u64 without overflow\n        assert(crate::field::modulus_num_bits() as u32 > 128);\n        U128 { lo: lo as Field, hi: hi as Field }\n    }\n\n    pub fn from_u64s_be(hi: u64, lo: u64) -> U128 {\n        U128::from_u64s_le(lo, hi)\n    }\n\n    pub fn zero() -> U128 {\n        U128 { lo: 0, hi: 0 }\n    }\n\n    pub fn one() -> U128 {\n        U128 { lo: 1, hi: 0 }\n    }\n    pub fn from_le_bytes(bytes: [u8; 16]) -> U128 {\n        let mut lo = 0;\n        let mut base = 1;\n        for i in 0..8 {\n            lo += (bytes[i] as Field) * base;\n            base *= 256;\n        }\n        let mut hi = 0;\n        base = 1;\n        for i in 8..16 {\n            hi += (bytes[i] as Field) * base;\n            base *= 256;\n        }\n        U128 { lo, hi }\n    }\n\n    pub fn to_be_bytes(self: Self) -> [u8; 16] {\n        let lo: [u8; 8] = self.lo.to_be_bytes();\n        let hi: [u8; 8] = self.hi.to_be_bytes();\n        let mut bytes = [0; 16];\n        for i in 0..8 {\n            bytes[i] = hi[i];\n            bytes[i + 8] = lo[i];\n        }\n        bytes\n    }\n\n    pub fn to_le_bytes(self: Self) -> [u8; 16] {\n        let lo: [u8; 8] = self.lo.to_le_bytes();\n        let hi: [u8; 8] = self.hi.to_le_bytes();\n        let mut bytes = [0; 16];\n        for i in 0..8 {\n            bytes[i] = lo[i];\n            bytes[i + 8] = hi[i];\n        }\n        bytes\n    }\n\n    pub fn from_hex<let N: u32>(hex: str<N>) -> U128 {\n        let N = N as u32;\n        let bytes = hex.as_bytes();\n        // string must starts with \"0x\"\n        assert((bytes[0] == 48) & (bytes[1] == 120), \"Invalid hexadecimal string\");\n        assert(N < 35, \"Input does not fit into a U128\");\n\n        let mut lo = 0;\n        let mut hi = 0;\n        let mut base = 1;\n        if N <= 18 {\n            for i in 0..N - 2 {\n                lo += U128::decode_ascii(bytes[N - i - 1]) * base;\n                base = base * 16;\n            }\n        } else {\n            for i in 0..16 {\n                lo += U128::decode_ascii(bytes[N - i - 1]) * base;\n                base = base * 16;\n            }\n            base = 1;\n            for i in 17..N - 1 {\n                hi += U128::decode_ascii(bytes[N - i]) * base;\n                base = base * 16;\n            }\n        }\n        U128 { lo: lo as Field, hi: hi as Field }\n    }\n\n    unconstrained fn uconstrained_check_is_upper_ascii(ascii: u8) -> bool {\n        ((ascii >= 65) & (ascii <= 90)) // Between 'A' and 'Z'\n    }\n\n    pub(crate) fn decode_ascii(ascii: u8) -> Field {\n        (\n            if ascii < 58 {\n                ascii - 48\n            } else {\n                let ascii =\n                    ascii + 32 * (unsafe { U128::uconstrained_check_is_upper_ascii(ascii) as u8 });\n                assert(ascii >= 97); // enforce >= 'a'\n                assert(ascii <= 102); // enforce <= 'f'\n                ascii - 87\n            }\n        ) as Field\n    }\n\n    // TODO: Replace with a faster version.\n    // A circuit that uses this function can be slow to compute\n    // (we're doing up to 127 calls to compute the quotient)\n    unconstrained fn unconstrained_div(self: Self, b: U128) -> (U128, U128) {\n        if b == U128::zero() {\n            // Return 0,0 to avoid eternal loop\n            (U128::zero(), U128::zero())\n        } else if self < b {\n            (U128::zero(), self)\n        } else if self == b {\n            (U128::one(), U128::zero())\n        } else {\n            let (q, r) = if b.hi as u64 >= pow63 as u64 {\n                // The result of multiplication by 2 would overflow\n                (U128::zero(), self)\n            } else {\n                self.unconstrained_div(b * U128::from_u64s_le(2, 0))\n            };\n            let q_mul_2 = q * U128::from_u64s_le(2, 0);\n            if r < b {\n                (q_mul_2, r)\n            } else {\n                (q_mul_2 + U128::one(), r - b)\n            }\n        }\n    }\n\n    pub fn from_integer<T>(i: T) -> U128 {\n        let f = crate::as_field(i);\n        // Reject values which would overflow a u128\n        f.assert_max_bit_size::<128>();\n        let lo = f as u64 as Field;\n        let hi = (f - lo) / pow64;\n        U128 { lo, hi }\n    }\n\n    pub fn to_integer<T>(self) -> T {\n        crate::from_field(self.lo + self.hi * pow64)\n    }\n\n    fn wrapping_mul(self: Self, b: U128) -> U128 {\n        let low = self.lo * b.lo;\n        let lo = low as u64 as Field;\n        let carry = (low - lo) / pow64;\n        let high = self.lo * b.hi + self.hi * b.lo + carry;\n        let hi = high as u64 as Field;\n        U128 { lo, hi }\n    }\n}\n\nimpl Add for U128 {\n    fn add(self: Self, b: U128) -> U128 {\n        let low = self.lo + b.lo;\n        let lo = low as u64 as Field;\n        let carry = (low - lo) / pow64;\n        let high = self.hi + b.hi + carry;\n        let hi = high as u64 as Field;\n        assert(hi == high, \"attempt to add with overflow\");\n        U128 { lo, hi }\n    }\n}\n\nimpl Sub for U128 {\n    fn sub(self: Self, b: U128) -> U128 {\n        let low = pow64 + self.lo - b.lo;\n        let lo = low as u64 as Field;\n        let borrow = (low == lo) as Field;\n        let high = self.hi - b.hi - borrow;\n        let hi = high as u64 as Field;\n        assert(hi == high, \"attempt to subtract with underflow\");\n        U128 { lo, hi }\n    }\n}\n\nimpl Mul for U128 {\n    fn mul(self: Self, b: U128) -> U128 {\n        assert(self.hi * b.hi == 0, \"attempt to multiply with overflow\");\n        let low = self.lo * b.lo;\n        let lo = low as u64 as Field;\n        let carry = (low - lo) / pow64;\n        let high = if crate::field::modulus_num_bits() as u32 > 196 {\n            (self.lo + self.hi) * (b.lo + b.hi) - low + carry\n        } else {\n            self.lo * b.hi + self.hi * b.lo + carry\n        };\n        let hi = high as u64 as Field;\n        assert(hi == high, \"attempt to multiply with overflow\");\n        U128 { lo, hi }\n    }\n}\n\nimpl Div for U128 {\n    fn div(self: Self, b: U128) -> U128 {\n        unsafe {\n            let (q, r) = self.unconstrained_div(b);\n            let a = b * q + r;\n            assert_eq(self, a);\n            assert(r < b);\n            q\n        }\n    }\n}\n\nimpl Rem for U128 {\n    fn rem(self: Self, b: U128) -> U128 {\n        unsafe {\n            let (q, r) = self.unconstrained_div(b);\n            let a = b * q + r;\n            assert_eq(self, a);\n            assert(r < b);\n\n            r\n        }\n    }\n}\n\nimpl Eq for U128 {\n    fn eq(self: Self, b: U128) -> bool {\n        (self.lo == b.lo) & (self.hi == b.hi)\n    }\n}\n\nimpl Ord for U128 {\n    fn cmp(self, other: Self) -> Ordering {\n        let hi_ordering = (self.hi as u64).cmp((other.hi as u64));\n        let lo_ordering = (self.lo as u64).cmp((other.lo as u64));\n\n        if hi_ordering == Ordering::equal() {\n            lo_ordering\n        } else {\n            hi_ordering\n        }\n    }\n}\n\nimpl Not for U128 {\n    fn not(self) -> U128 {\n        U128 { lo: (!(self.lo as u64)) as Field, hi: (!(self.hi as u64)) as Field }\n    }\n}\n\nimpl BitOr for U128 {\n    fn bitor(self, other: U128) -> U128 {\n        U128 {\n            lo: ((self.lo as u64) | (other.lo as u64)) as Field,\n            hi: ((self.hi as u64) | (other.hi as u64)) as Field,\n        }\n    }\n}\n\nimpl BitAnd for U128 {\n    fn bitand(self, other: U128) -> U128 {\n        U128 {\n            lo: ((self.lo as u64) & (other.lo as u64)) as Field,\n            hi: ((self.hi as u64) & (other.hi as u64)) as Field,\n        }\n    }\n}\n\nimpl BitXor for U128 {\n    fn bitxor(self, other: U128) -> U128 {\n        U128 {\n            lo: ((self.lo as u64) ^ (other.lo as u64)) as Field,\n            hi: ((self.hi as u64) ^ (other.hi as u64)) as Field,\n        }\n    }\n}\n\nimpl Shl for U128 {\n    fn shl(self, other: u8) -> U128 {\n        assert(other < 128, \"attempt to shift left with overflow\");\n        let exp_bits: [u1; 7] = (other as Field).to_be_bits();\n\n        let mut r: Field = 2;\n        let mut y: Field = 1;\n        for i in 1..8 {\n            let bit = exp_bits[7 - i] as Field;\n            y = bit * (r * y) + (1 - bit) * y;\n            r *= r;\n        }\n        self.wrapping_mul(U128::from_integer(y))\n    }\n}\n\nimpl Shr for U128 {\n    fn shr(self, other: u8) -> U128 {\n        assert(other < 128, \"attempt to shift right with overflow\");\n        let exp_bits: [u1; 7] = (other as Field).to_be_bits();\n\n        let mut r: Field = 2;\n        let mut y: Field = 1;\n        for i in 1..8 {\n            let bit = exp_bits[7 - i] as Field;\n            y = bit * (r * y) + (1 - bit) * y;\n            r *= r;\n        }\n        self / U128::from_integer(y)\n    }\n}\n\nmod tests {\n    use crate::uint128::{pow63, pow64, U128};\n\n    #[test]\n    fn test_not(lo: u64, hi: u64) {\n        let num = U128::from_u64s_le(lo, hi);\n        let not_num = num.not();\n\n        assert_eq(not_num.hi, (hi.not() as Field));\n        assert_eq(not_num.lo, (lo.not() as Field));\n\n        let not_not_num = not_num.not();\n        assert_eq(num, not_not_num);\n    }\n    #[test]\n    fn test_construction() {\n        // Check little-endian u64 is inversed with big-endian u64 construction\n        let a = U128::from_u64s_le(2, 1);\n        let b = U128::from_u64s_be(1, 2);\n        assert_eq(a, b);\n        // Check byte construction is equivalent\n        let c = U128::from_le_bytes([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]);\n        let d = U128::from_u64s_le(0x0706050403020100, 0x0f0e0d0c0b0a0908);\n        assert_eq(c, d);\n    }\n    #[test]\n    fn test_byte_decomposition() {\n        let a = U128::from_u64s_le(0x0706050403020100, 0x0f0e0d0c0b0a0908);\n        // Get big-endian and little-endian byte decompostions\n        let le_bytes_a = a.to_le_bytes();\n        let be_bytes_a = a.to_be_bytes();\n\n        // Check equivalence\n        for i in 0..16 {\n            assert_eq(le_bytes_a[i], be_bytes_a[15 - i]);\n        }\n        // Reconstruct U128 from byte decomposition\n        let b = U128::from_le_bytes(le_bytes_a);\n        // Check that it's the same element\n        assert_eq(a, b);\n    }\n    #[test]\n    fn test_hex_constuction() {\n        let a = U128::from_u64s_le(0x1, 0x2);\n        let b = U128::from_hex(\"0x20000000000000001\");\n        assert_eq(a, b);\n\n        let c = U128::from_hex(\"0xffffffffffffffffffffffffffffffff\");\n        let d = U128::from_u64s_le(0xffffffffffffffff, 0xffffffffffffffff);\n        assert_eq(c, d);\n\n        let e = U128::from_hex(\"0x00000000000000000000000000000000\");\n        let f = U128::from_u64s_le(0, 0);\n        assert_eq(e, f);\n    }\n\n    // Ascii decode tests\n\n    #[test]\n    fn test_ascii_decode_correct_range() {\n        // '0'..'9' range\n        for i in 0..10 {\n            let decoded = U128::decode_ascii(48 + i);\n            assert_eq(decoded, i as Field);\n        }\n        // 'A'..'F' range\n        for i in 0..6 {\n            let decoded = U128::decode_ascii(65 + i);\n            assert_eq(decoded, (i + 10) as Field);\n        }\n        // 'a'..'f' range\n        for i in 0..6 {\n            let decoded = U128::decode_ascii(97 + i);\n            assert_eq(decoded, (i + 10) as Field);\n        }\n    }\n\n    #[test(should_fail)]\n    fn test_ascii_decode_range_less_than_48_fails_0() {\n        crate::println(U128::decode_ascii(0));\n    }\n    #[test(should_fail)]\n    fn test_ascii_decode_range_less_than_48_fails_1() {\n        crate::println(U128::decode_ascii(47));\n    }\n\n    #[test(should_fail)]\n    fn test_ascii_decode_range_58_64_fails_0() {\n        let _ = U128::decode_ascii(58);\n    }\n    #[test(should_fail)]\n    fn test_ascii_decode_range_58_64_fails_1() {\n        let _ = U128::decode_ascii(64);\n    }\n    #[test(should_fail)]\n    fn test_ascii_decode_range_71_96_fails_0() {\n        let _ = U128::decode_ascii(71);\n    }\n    #[test(should_fail)]\n    fn test_ascii_decode_range_71_96_fails_1() {\n        let _ = U128::decode_ascii(96);\n    }\n    #[test(should_fail)]\n    fn test_ascii_decode_range_greater_than_102_fails() {\n        let _ = U128::decode_ascii(103);\n    }\n\n    #[test(should_fail)]\n    fn test_ascii_decode_regression() {\n        // This code will actually fail because of ascii_decode,\n        // but in the past it was possible to create a value > (1<<128)\n        let a = U128::from_hex(\"0x~fffffffffffffffffffffffffffffff\");\n        let b: Field = a.to_integer();\n        let c: [u8; 17] = b.to_le_bytes();\n        assert(c[16] != 0);\n    }\n\n    #[test]\n    fn test_unconstrained_div() {\n        // Test the potential overflow case\n        let a = U128::from_u64s_le(0x0, 0xffffffffffffffff);\n        let b = U128::from_u64s_le(0x0, 0xfffffffffffffffe);\n        let c = U128::one();\n        let d = U128::from_u64s_le(0x0, 0x1);\n        unsafe {\n            let (q, r) = a.unconstrained_div(b);\n            assert_eq(q, c);\n            assert_eq(r, d);\n        }\n\n        let a = U128::from_u64s_le(2, 0);\n        let b = U128::one();\n        // Check the case where a is a multiple of b\n        unsafe {\n            let (c, d) = a.unconstrained_div(b);\n            assert_eq((c, d), (a, U128::zero()));\n        }\n\n        // Check where b is a multiple of a\n        unsafe {\n            let (c, d) = b.unconstrained_div(a);\n            assert_eq((c, d), (U128::zero(), b));\n        }\n\n        // Dividing by zero returns 0,0\n        let a = U128::from_u64s_le(0x1, 0x0);\n        let b = U128::zero();\n        unsafe {\n            let (c, d) = a.unconstrained_div(b);\n            assert_eq((c, d), (U128::zero(), U128::zero()));\n        }\n        // Dividing 1<<127 by 1<<127 (special case)\n        let a = U128::from_u64s_le(0x0, pow63 as u64);\n        let b = U128::from_u64s_le(0x0, pow63 as u64);\n        unsafe {\n            let (c, d) = a.unconstrained_div(b);\n            assert_eq((c, d), (U128::one(), U128::zero()));\n        }\n    }\n\n    #[test]\n    fn integer_conversions() {\n        // Maximum\n        let start: Field = 0xffffffffffffffffffffffffffffffff;\n        let a = U128::from_integer(start);\n        let end = a.to_integer();\n        assert_eq(start, end);\n\n        // Minimum\n        let start: Field = 0x0;\n        let a = U128::from_integer(start);\n        let end = a.to_integer();\n        assert_eq(start, end);\n\n        // Low limb\n        let start: Field = 0xffffffffffffffff;\n        let a = U128::from_integer(start);\n        let end = a.to_integer();\n        assert_eq(start, end);\n\n        // High limb\n        let start: Field = 0xffffffffffffffff0000000000000000;\n        let a = U128::from_integer(start);\n        let end = a.to_integer();\n        assert_eq(start, end);\n    }\n\n    #[test]\n    fn integer_conversions_fuzz(lo: u64, hi: u64) {\n        let start: Field = (lo as Field) + pow64 * (hi as Field);\n        let a = U128::from_integer(start);\n        let end = a.to_integer();\n        assert_eq(start, end);\n    }\n\n    #[test]\n    fn test_wrapping_mul() {\n        // 1*0==0\n        assert_eq(U128::zero(), U128::zero().wrapping_mul(U128::one()));\n\n        // 0*1==0\n        assert_eq(U128::zero(), U128::one().wrapping_mul(U128::zero()));\n\n        // 1*1==1\n        assert_eq(U128::one(), U128::one().wrapping_mul(U128::one()));\n\n        // 0 * ( 1 << 64 ) ==  0\n        assert_eq(U128::zero(), U128::zero().wrapping_mul(U128::from_u64s_le(0, 1)));\n\n        // ( 1 << 64 ) * 0 == 0\n        assert_eq(U128::zero(), U128::from_u64s_le(0, 1).wrapping_mul(U128::zero()));\n\n        // 1 * ( 1 << 64 ) == 1 << 64\n        assert_eq(U128::from_u64s_le(0, 1), U128::from_u64s_le(0, 1).wrapping_mul(U128::one()));\n\n        // ( 1 << 64 ) * 1 == 1 << 64\n        assert_eq(U128::from_u64s_le(0, 1), U128::one().wrapping_mul(U128::from_u64s_le(0, 1)));\n\n        // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n        assert_eq(U128::zero(), U128::from_u64s_le(0, 1).wrapping_mul(U128::from_u64s_le(0, 1)));\n        // -1 * -1 == 1\n        assert_eq(\n            U128::one(),\n            U128::from_u64s_le(0xffffffffffffffff, 0xffffffffffffffff).wrapping_mul(\n                U128::from_u64s_le(0xffffffffffffffff, 0xffffffffffffffff),\n            ),\n        );\n    }\n}\n"
     },
-    "102": {
+    "93": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/context/private_context.nr",
-      "source": "use crate::{\n    context::{inputs::PrivateContextInputs, packed_returns::PackedReturns},\n    hash::{ArgsHasher, hash_args_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        arguments,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            enqueue_public_function_call_internal, notify_set_min_revertible_side_effect_counter,\n            set_public_teardown_function_call_internal,\n        },\n        header::get_header_at,\n        key_validation_request::get_key_validation_request,\n        logs::{emit_encrypted_event_log, emit_encrypted_note_log},\n        returns::pack_returns,\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        log_hash::{EncryptedLogHash, LogHash, NoteLogHash},\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENCRYPTED_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_ENCRYPTED_LOGS_PER_CALL, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,\n        MAX_NOTE_HASHES_PER_CALL, MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, PUBLIC_DISPATCH_SELECTOR,\n    },\n    header::Header,\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::Empty,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: Header,\n\n    pub note_encrypted_logs_hashes: BoundedVec<NoteLogHash, MAX_NOTE_ENCRYPTED_LOGS_PER_CALL>,\n    pub encrypted_logs_hashes: BoundedVec<EncryptedLogHash, MAX_ENCRYPTED_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<LogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            note_encrypted_logs_hashes: BoundedVec::new(),\n            encrypted_logs_hashes: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: self.next_counter(),\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_header(self) -> Header {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_header_at(self, block_number: u32) -> Header {\n        get_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        pack_returns(returns_hasher.fields);\n        self.return_hash = returns_hasher.hash();\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            note_encrypted_logs_hashes: self.note_encrypted_logs_hashes.storage(),\n            encrypted_logs_hashes: self.encrypted_logs_hashes.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request =\n            self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert(request.pk_m.hash() == pk_m_hash);\n\n            self.key_validation_requests_and_generators.push(\n                KeyValidationRequestAndGenerator {\n                    request,\n                    sk_app_generator: sk_generators[key_index],\n                },\n            );\n            self.last_key_validation_requests[key_index] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n        self.l2_to_l1_msgs.push(message);\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    // NB: A randomness value of 0 signals that the kernels should not mask the contract address\n    // used in siloing later on e.g. 'handshaking' contract w/ known address.\n    pub fn emit_raw_event_log_with_masked_address<let M: u32>(\n        &mut self,\n        randomness: Field,\n        log: [u8; M],\n        log_hash: Field,\n    ) {\n        let counter = self.next_counter();\n        let contract_address = self.this_address();\n        let len = log.len() as Field + 4;\n        let side_effect = EncryptedLogHash { value: log_hash, counter, length: len, randomness };\n        self.encrypted_logs_hashes.push(side_effect);\n\n        emit_encrypted_event_log(contract_address, randomness, log, counter);\n    }\n\n    pub fn emit_raw_note_log<let M: u32>(\n        &mut self,\n        note_hash_counter: u32,\n        log: [u8; M],\n        log_hash: Field,\n    ) {\n        let counter = self.next_counter();\n        let len = log.len() as Field + 4;\n        let side_effect = NoteLogHash { value: log_hash, counter, length: len, note_hash_counter };\n        self.note_encrypted_logs_hashes.push(side_effect);\n\n        emit_encrypted_note_log(note_hash_counter, log, counter);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> PackedReturns {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        // The oracle simulates the private call and returns the value of the side effects counter after execution of\n        // the call (which means that end_side_effect_counter - start_side_effect_counter is the number of side effects\n        // that took place), along with the hash of the return values. We validate these by requesting a private kernel\n        // iteration in which the return values are constrained to hash to `returns_hash` and the side effects counter\n        // to increment from start to end.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        // TODO (fees) figure out why this crashes the prover and enable it\n        // we need this in order to pay fees inside child call contexts\n        // assert(\n        //     (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n        //     | (item.public_inputs.min_revertible_side_effect_counter\n        //         > self.min_revertible_side_effect_counter)\n        // );\n        // if item.public_inputs.min_revertible_side_effect_counter\n        //     > self.min_revertible_side_effect_counter {\n        //     self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n        // }\n        self.side_effect_counter = end_side_effect_counter + 1;\n        PackedReturns::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_public_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = enqueue_public_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\n        );\n\n        // Public calls are rerouted through the dispatch function.\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.set_public_teardown_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn set_public_teardown_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = set_public_teardown_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\n        );\n\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: Header::empty(),\n            note_encrypted_logs_hashes: BoundedVec::new(),\n            encrypted_logs_hashes: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
+      "source": "use crate::{\n    context::{inputs::PrivateContextInputs, packed_returns::PackedReturns},\n    hash::{ArgsHasher, hash_args_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        arguments,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            enqueue_public_function_call_internal, notify_set_min_revertible_side_effect_counter,\n            set_public_teardown_function_call_internal,\n        },\n        header::get_header_at,\n        key_validation_request::get_key_validation_request,\n        returns::pack_returns,\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        log::Log,\n        log_hash::LogHash,\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::PrivateLogData,\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_DISPATCH_SELECTOR,\n    },\n    header::Header,\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::Empty,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: Header,\n\n    pub private_logs: BoundedVec<PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<LogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: self.next_counter(),\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_header(self) -> Header {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_header_at(self, block_number: u32) -> Header {\n        get_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        pack_returns(returns_hasher.fields);\n        self.return_hash = returns_hasher.hash();\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: self.private_logs.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request =\n            self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert(request.pk_m.hash() == pk_m_hash);\n\n            self.key_validation_requests_and_generators.push(\n                KeyValidationRequestAndGenerator {\n                    request,\n                    sk_app_generator: sk_generators[key_index],\n                },\n            );\n            self.last_key_validation_requests[key_index] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n        self.l2_to_l1_msgs.push(message);\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn emit_raw_note_log(\n        &mut self,\n        log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n        note_hash_counter: u32,\n    ) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> PackedReturns {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        // The oracle simulates the private call and returns the value of the side effects counter after execution of\n        // the call (which means that end_side_effect_counter - start_side_effect_counter is the number of side effects\n        // that took place), along with the hash of the return values. We validate these by requesting a private kernel\n        // iteration in which the return values are constrained to hash to `returns_hash` and the side effects counter\n        // to increment from start to end.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        // TODO (fees) figure out why this crashes the prover and enable it\n        // we need this in order to pay fees inside child call contexts\n        // assert(\n        //     (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n        //     | (item.public_inputs.min_revertible_side_effect_counter\n        //         > self.min_revertible_side_effect_counter)\n        // );\n        // if item.public_inputs.min_revertible_side_effect_counter\n        //     > self.min_revertible_side_effect_counter {\n        //     self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n        // }\n        self.side_effect_counter = end_side_effect_counter + 1;\n        PackedReturns::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_public_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = enqueue_public_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\n        );\n\n        // Public calls are rerouted through the dispatch function.\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.set_public_teardown_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn set_public_teardown_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = set_public_teardown_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\n        );\n\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: Header::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
     },
-    "103": {
+    "94": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/context/public_context.nr",
-      "source": "use crate::context::gas::GasOpts;\nuse crate::hash::{\n    compute_l1_to_l2_message_hash, compute_l1_to_l2_message_nullifier, compute_secret_hash,\n};\nuse dep::protocol_types::abis::function_selector::FunctionSelector;\nuse dep::protocol_types::address::{AztecAddress, EthAddress};\nuse dep::protocol_types::constants::MAX_FIELD_VALUE;\nuse dep::protocol_types::traits::{Deserialize, Empty, Serialize};\n\npub struct PublicContext {\n    pub args_hash: Option<Field>,\n    pub compute_args_hash: fn() -> Field,\n}\n\nimpl PublicContext {\n    pub fn new(compute_args_hash: fn() -> Field) -> Self {\n        PublicContext { args_hash: Option::none(), compute_args_hash }\n    }\n\n    pub fn emit_unencrypted_log<T, let N: u32>(_self: &mut Self, log: T)\n    where\n        T: Serialize<N>,\n    {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { emit_unencrypted_log(Serialize::serialize(log).as_slice()) };\n    }\n\n    pub fn note_hash_exists(_self: Self, note_hash: Field, leaf_index: Field) -> bool {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { note_hash_exists(note_hash, leaf_index) } == 1\n    }\n\n    pub fn l1_to_l2_msg_exists(_self: Self, msg_hash: Field, msg_leaf_index: Field) -> bool {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { l1_to_l2_msg_exists(msg_hash, msg_leaf_index) } == 1\n    }\n\n    pub fn nullifier_exists(_self: Self, unsiloed_nullifier: Field, address: AztecAddress) -> bool {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { nullifier_exists(unsiloed_nullifier, address.to_field()) } == 1\n    }\n\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        let secret_hash = compute_secret_hash(secret);\n        let message_hash = compute_l1_to_l2_message_hash(\n            sender,\n            self.chain_id(),\n            /*recipient=*/\n            self.this_address(),\n            self.version(),\n            content,\n            secret_hash,\n            leaf_index,\n        );\n        let nullifier = compute_l1_to_l2_message_nullifier(message_hash, secret);\n\n        assert(\n            !self.nullifier_exists(nullifier, self.this_address()),\n            \"L1-to-L2 message is already nullified\",\n        );\n        assert(\n            self.l1_to_l2_msg_exists(message_hash, leaf_index),\n            \"Tried to consume nonexistent L1-to-L2 message\",\n        );\n\n        self.push_nullifier(nullifier);\n    }\n\n    pub fn message_portal(_self: &mut Self, recipient: EthAddress, content: Field) {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { send_l2_to_l1_msg(recipient, content) };\n    }\n\n    pub unconstrained fn call_public_function(\n        _self: &mut Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let args = args.push_front(function_selector.to_field());\n        let success = call(gas_for_call(gas_opts), contract_address, args);\n\n        let result_data = returndata_copy(0, returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm_revert(result_data);\n        }\n        result_data\n    }\n\n    pub unconstrained fn static_call_public_function(\n        _self: &mut Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let args = args.push_front(function_selector.to_field());\n        let success = call_static(gas_for_call(gas_opts), contract_address, args);\n\n        let result_data = returndata_copy(0, returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm_revert(result_data);\n        }\n        result_data\n    }\n\n    pub fn push_note_hash(_self: &mut Self, note_hash: Field) {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { emit_note_hash(note_hash) };\n    }\n    pub fn push_nullifier(_self: &mut Self, nullifier: Field) {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { emit_nullifier(nullifier) };\n    }\n\n    pub fn this_address(_self: Self) -> AztecAddress {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            address()\n        }\n    }\n    pub fn msg_sender(_self: Self) -> AztecAddress {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            sender()\n        }\n    }\n    pub fn selector(_self: Self) -> FunctionSelector {\n        // The selector is the first element of the calldata when calling a public function through dispatch.\n        // AVM opcodes are constrained by the AVM itself.\n        let raw_selector: [Field; 1] = unsafe { calldata_copy(0, 1) };\n        FunctionSelector::from_field(raw_selector[0])\n    }\n    pub fn get_args_hash(mut self) -> Field {\n        if !self.args_hash.is_some() {\n            self.args_hash = Option::some((self.compute_args_hash)());\n        }\n\n        self.args_hash.unwrap_unchecked()\n    }\n    pub fn transaction_fee(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            transaction_fee()\n        }\n    }\n\n    pub fn chain_id(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            chain_id()\n        }\n    }\n    pub fn version(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            version()\n        }\n    }\n    pub fn block_number(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            block_number()\n        }\n    }\n    pub fn timestamp(_self: Self) -> u64 {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            timestamp()\n        }\n    }\n    pub fn fee_per_l2_gas(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            fee_per_l2_gas()\n        }\n    }\n    pub fn fee_per_da_gas(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            fee_per_da_gas()\n        }\n    }\n\n    pub fn l2_gas_left(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            l2_gas_left()\n        }\n    }\n    pub fn da_gas_left(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            da_gas_left()\n        }\n    }\n    pub fn is_static_call(_self: Self) -> bool {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { is_static_call() } == 1\n    }\n\n    pub fn raw_storage_read<let N: u32>(_self: Self, storage_slot: Field) -> [Field; N] {\n        let mut out = [0; N];\n        for i in 0..N {\n            // AVM opcodes are constrained by the AVM itself\n            out[i] = unsafe { storage_read(storage_slot + i as Field) };\n        }\n        out\n    }\n\n    pub fn storage_read<T, let N: u32>(self, storage_slot: Field) -> T\n    where\n        T: Deserialize<N>,\n    {\n        T::deserialize(self.raw_storage_read(storage_slot))\n    }\n\n    pub fn raw_storage_write<let N: u32>(_self: Self, storage_slot: Field, values: [Field; N]) {\n        for i in 0..N {\n            // AVM opcodes are constrained by the AVM itself\n            unsafe { storage_write(storage_slot + i as Field, values[i]) };\n        }\n    }\n\n    pub fn storage_write<T, let N: u32>(self, storage_slot: Field, value: T)\n    where\n        T: Serialize<N>,\n    {\n        self.raw_storage_write(storage_slot, value.serialize());\n    }\n}\n\n// Helper functions\nfn gas_for_call(user_gas: GasOpts) -> [Field; 2] {\n    // It's ok to use the max possible gas here, because the gas will be\n    // capped by the gas left in the (STATIC)CALL instruction.\n    [user_gas.l2_gas.unwrap_or(MAX_FIELD_VALUE), user_gas.da_gas.unwrap_or(MAX_FIELD_VALUE)]\n}\n\n// Unconstrained opcode wrappers (do not use directly).\nunconstrained fn address() -> AztecAddress {\n    address_opcode()\n}\nunconstrained fn sender() -> AztecAddress {\n    sender_opcode()\n}\n// TODO(9396): Remove.\nunconstrained fn portal() -> EthAddress {\n    portal_opcode()\n}\n// TODO(9396): Remove.\n//unconstrained fn function_selector() -> u32 {\n//    function_selector_opcode()\n//}\nunconstrained fn transaction_fee() -> Field {\n    transaction_fee_opcode()\n}\nunconstrained fn chain_id() -> Field {\n    chain_id_opcode()\n}\nunconstrained fn version() -> Field {\n    version_opcode()\n}\nunconstrained fn block_number() -> Field {\n    block_number_opcode()\n}\nunconstrained fn timestamp() -> u64 {\n    timestamp_opcode()\n}\nunconstrained fn fee_per_l2_gas() -> Field {\n    fee_per_l2_gas_opcode()\n}\nunconstrained fn fee_per_da_gas() -> Field {\n    fee_per_da_gas_opcode()\n}\nunconstrained fn l2_gas_left() -> Field {\n    l2_gas_left_opcode()\n}\nunconstrained fn da_gas_left() -> Field {\n    da_gas_left_opcode()\n}\nunconstrained fn is_static_call() -> Field {\n    is_static_call_opcode()\n}\nunconstrained fn note_hash_exists(note_hash: Field, leaf_index: Field) -> u1 {\n    note_hash_exists_opcode(note_hash, leaf_index)\n}\nunconstrained fn emit_note_hash(note_hash: Field) {\n    emit_note_hash_opcode(note_hash)\n}\nunconstrained fn nullifier_exists(nullifier: Field, address: Field) -> u1 {\n    nullifier_exists_opcode(nullifier, address)\n}\nunconstrained fn emit_nullifier(nullifier: Field) {\n    emit_nullifier_opcode(nullifier)\n}\nunconstrained fn emit_unencrypted_log(message: [Field]) {\n    emit_unencrypted_log_opcode(message)\n}\nunconstrained fn l1_to_l2_msg_exists(msg_hash: Field, msg_leaf_index: Field) -> u1 {\n    l1_to_l2_msg_exists_opcode(msg_hash, msg_leaf_index)\n}\nunconstrained fn send_l2_to_l1_msg(recipient: EthAddress, content: Field) {\n    send_l2_to_l1_msg_opcode(recipient, content)\n}\nunconstrained fn call(gas: [Field; 2], address: AztecAddress, args: [Field]) -> bool {\n    call_opcode(gas, address, args)\n}\nunconstrained fn call_static(gas: [Field; 2], address: AztecAddress, args: [Field]) -> bool {\n    call_static_opcode(gas, address, args)\n}\n\npub unconstrained fn calldata_copy<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {\n    calldata_copy_opcode(cdoffset, copy_size)\n}\n\nunconstrained fn returndata_size() -> u32 {\n    returndata_size_opcode()\n}\n\nunconstrained fn returndata_copy(rdoffset: u32, copy_size: u32) -> [Field] {\n    returndata_copy_opcode(rdoffset, copy_size)\n}\n\npub unconstrained fn avm_return(returndata: [Field]) {\n    return_opcode(returndata)\n}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\nunconstrained fn avm_revert(revertdata: [Field]) {\n    revert_opcode(revertdata)\n}\n\nunconstrained fn storage_read(storage_slot: Field) -> Field {\n    storage_read_opcode(storage_slot)\n}\n\nunconstrained fn storage_write(storage_slot: Field, value: Field) {\n    storage_write_opcode(storage_slot, value);\n}\n\nimpl Empty for PublicContext {\n    fn empty() -> Self {\n        PublicContext::new(|| 0)\n    }\n}\n\n// AVM oracles (opcodes) follow, do not use directly.\n#[oracle(avmOpcodeAddress)]\nunconstrained fn address_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeSender)]\nunconstrained fn sender_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodePortal)]\nunconstrained fn portal_opcode() -> EthAddress {}\n\n// TODO(9396): Remove.\n//#[oracle(avmOpcodeFunctionSelector)]\n//unconstrained fn function_selector_opcode() -> u32 {}\n\n#[oracle(avmOpcodeTransactionFee)]\nunconstrained fn transaction_fee_opcode() -> Field {}\n\n#[oracle(avmOpcodeChainId)]\nunconstrained fn chain_id_opcode() -> Field {}\n\n#[oracle(avmOpcodeVersion)]\nunconstrained fn version_opcode() -> Field {}\n\n#[oracle(avmOpcodeBlockNumber)]\nunconstrained fn block_number_opcode() -> Field {}\n\n#[oracle(avmOpcodeTimestamp)]\nunconstrained fn timestamp_opcode() -> u64 {}\n\n#[oracle(avmOpcodeFeePerL2Gas)]\nunconstrained fn fee_per_l2_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeFeePerDaGas)]\nunconstrained fn fee_per_da_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeL2GasLeft)]\nunconstrained fn l2_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeDaGasLeft)]\nunconstrained fn da_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeIsStaticCall)]\nunconstrained fn is_static_call_opcode() -> Field {}\n\n#[oracle(avmOpcodeNoteHashExists)]\nunconstrained fn note_hash_exists_opcode(note_hash: Field, leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNoteHash)]\nunconstrained fn emit_note_hash_opcode(note_hash: Field) {}\n\n#[oracle(avmOpcodeNullifierExists)]\nunconstrained fn nullifier_exists_opcode(nullifier: Field, address: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNullifier)]\nunconstrained fn emit_nullifier_opcode(nullifier: Field) {}\n\n#[oracle(avmOpcodeEmitUnencryptedLog)]\nunconstrained fn emit_unencrypted_log_opcode(message: [Field]) {}\n\n#[oracle(avmOpcodeL1ToL2MsgExists)]\nunconstrained fn l1_to_l2_msg_exists_opcode(msg_hash: Field, msg_leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeSendL2ToL1Msg)]\nunconstrained fn send_l2_to_l1_msg_opcode(recipient: EthAddress, content: Field) {}\n\n#[oracle(avmOpcodeCalldataCopy)]\nunconstrained fn calldata_copy_opcode<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {}\n\n#[oracle(avmOpcodeReturndataSize)]\nunconstrained fn returndata_size_opcode() -> u32 {}\n\n#[oracle(avmOpcodeReturndataCopy)]\nunconstrained fn returndata_copy_opcode(rdoffset: u32, copy_size: u32) -> [Field] {}\n\n#[oracle(avmOpcodeReturn)]\nunconstrained fn return_opcode(returndata: [Field]) {}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\n#[oracle(avmOpcodeRevert)]\nunconstrained fn revert_opcode(revertdata: [Field]) {}\n\n#[oracle(avmOpcodeCall)]\nunconstrained fn call_opcode(\n    gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n    address: AztecAddress,\n    args: [Field],\n) -> bool {}\n\n#[oracle(avmOpcodeStaticCall)]\nunconstrained fn call_static_opcode(\n    gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n    address: AztecAddress,\n    args: [Field],\n) -> bool {}\n\n#[oracle(avmOpcodeStorageRead)]\nunconstrained fn storage_read_opcode(storage_slot: Field) -> Field {}\n\n#[oracle(avmOpcodeStorageWrite)]\nunconstrained fn storage_write_opcode(storage_slot: Field, value: Field) {}\n"
+      "source": "use crate::context::gas::GasOpts;\nuse crate::hash::{\n    compute_l1_to_l2_message_hash, compute_l1_to_l2_message_nullifier, compute_secret_hash,\n};\nuse dep::protocol_types::abis::function_selector::FunctionSelector;\nuse dep::protocol_types::address::{AztecAddress, EthAddress};\nuse dep::protocol_types::constants::MAX_FIELD_VALUE;\nuse dep::protocol_types::traits::{Deserialize, Empty, Serialize};\n\npub struct PublicContext {\n    pub args_hash: Option<Field>,\n    pub compute_args_hash: fn() -> Field,\n}\n\nimpl PublicContext {\n    pub fn new(compute_args_hash: fn() -> Field) -> Self {\n        PublicContext { args_hash: Option::none(), compute_args_hash }\n    }\n\n    pub fn emit_unencrypted_log<T, let N: u32>(_self: &mut Self, log: T)\n    where\n        T: Serialize<N>,\n    {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { emit_unencrypted_log(Serialize::serialize(log).as_slice()) };\n    }\n\n    pub fn note_hash_exists(_self: Self, note_hash: Field, leaf_index: Field) -> bool {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { note_hash_exists(note_hash, leaf_index) } == 1\n    }\n\n    pub fn l1_to_l2_msg_exists(_self: Self, msg_hash: Field, msg_leaf_index: Field) -> bool {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { l1_to_l2_msg_exists(msg_hash, msg_leaf_index) } == 1\n    }\n\n    pub fn nullifier_exists(_self: Self, unsiloed_nullifier: Field, address: AztecAddress) -> bool {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { nullifier_exists(unsiloed_nullifier, address.to_field()) } == 1\n    }\n\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        let secret_hash = compute_secret_hash(secret);\n        let message_hash = compute_l1_to_l2_message_hash(\n            sender,\n            self.chain_id(),\n            /*recipient=*/\n            self.this_address(),\n            self.version(),\n            content,\n            secret_hash,\n            leaf_index,\n        );\n        let nullifier = compute_l1_to_l2_message_nullifier(message_hash, secret);\n\n        assert(\n            !self.nullifier_exists(nullifier, self.this_address()),\n            \"L1-to-L2 message is already nullified\",\n        );\n        assert(\n            self.l1_to_l2_msg_exists(message_hash, leaf_index),\n            \"Tried to consume nonexistent L1-to-L2 message\",\n        );\n\n        self.push_nullifier(nullifier);\n    }\n\n    pub fn message_portal(_self: &mut Self, recipient: EthAddress, content: Field) {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { send_l2_to_l1_msg(recipient, content) };\n    }\n\n    pub unconstrained fn call_public_function(\n        _self: &mut Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let args = args.push_front(function_selector.to_field());\n        let success = call(gas_for_call(gas_opts), contract_address, args);\n\n        let result_data = returndata_copy(0, returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm_revert(result_data);\n        }\n        result_data\n    }\n\n    pub unconstrained fn static_call_public_function(\n        _self: &mut Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let args = args.push_front(function_selector.to_field());\n        let success = call_static(gas_for_call(gas_opts), contract_address, args);\n\n        let result_data = returndata_copy(0, returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm_revert(result_data);\n        }\n        result_data\n    }\n\n    pub fn push_note_hash(_self: &mut Self, note_hash: Field) {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { emit_note_hash(note_hash) };\n    }\n    pub fn push_nullifier(_self: &mut Self, nullifier: Field) {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { emit_nullifier(nullifier) };\n    }\n\n    pub fn this_address(_self: Self) -> AztecAddress {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            address()\n        }\n    }\n    pub fn msg_sender(_self: Self) -> AztecAddress {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            sender()\n        }\n    }\n    pub fn selector(_self: Self) -> FunctionSelector {\n        // The selector is the first element of the calldata when calling a public function through dispatch.\n        // AVM opcodes are constrained by the AVM itself.\n        let raw_selector: [Field; 1] = unsafe { calldata_copy(0, 1) };\n        FunctionSelector::from_field(raw_selector[0])\n    }\n    pub fn get_args_hash(mut self) -> Field {\n        if !self.args_hash.is_some() {\n            self.args_hash = Option::some((self.compute_args_hash)());\n        }\n\n        self.args_hash.unwrap_unchecked()\n    }\n    pub fn transaction_fee(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            transaction_fee()\n        }\n    }\n\n    pub fn chain_id(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            chain_id()\n        }\n    }\n    pub fn version(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            version()\n        }\n    }\n    pub fn block_number(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            block_number()\n        }\n    }\n    pub fn timestamp(_self: Self) -> u64 {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            timestamp()\n        }\n    }\n    pub fn fee_per_l2_gas(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            fee_per_l2_gas()\n        }\n    }\n    pub fn fee_per_da_gas(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            fee_per_da_gas()\n        }\n    }\n\n    pub fn l2_gas_left(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            l2_gas_left()\n        }\n    }\n    pub fn da_gas_left(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            da_gas_left()\n        }\n    }\n    pub fn is_static_call(_self: Self) -> bool {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { is_static_call() } == 1\n    }\n\n    pub fn raw_storage_read<let N: u32>(_self: Self, storage_slot: Field) -> [Field; N] {\n        let mut out = [0; N];\n        for i in 0..N {\n            // AVM opcodes are constrained by the AVM itself\n            out[i] = unsafe { storage_read(storage_slot + i as Field) };\n        }\n        out\n    }\n\n    pub fn storage_read<T, let N: u32>(self, storage_slot: Field) -> T\n    where\n        T: Deserialize<N>,\n    {\n        T::deserialize(self.raw_storage_read(storage_slot))\n    }\n\n    pub fn raw_storage_write<let N: u32>(_self: Self, storage_slot: Field, values: [Field; N]) {\n        for i in 0..N {\n            // AVM opcodes are constrained by the AVM itself\n            unsafe { storage_write(storage_slot + i as Field, values[i]) };\n        }\n    }\n\n    pub fn storage_write<T, let N: u32>(self, storage_slot: Field, value: T)\n    where\n        T: Serialize<N>,\n    {\n        self.raw_storage_write(storage_slot, value.serialize());\n    }\n}\n\n// Helper functions\nfn gas_for_call(user_gas: GasOpts) -> [Field; 2] {\n    // It's ok to use the max possible gas here, because the gas will be\n    // capped by the gas left in the (STATIC)CALL instruction.\n    [user_gas.l2_gas.unwrap_or(MAX_FIELD_VALUE), user_gas.da_gas.unwrap_or(MAX_FIELD_VALUE)]\n}\n\n// Unconstrained opcode wrappers (do not use directly).\nunconstrained fn address() -> AztecAddress {\n    address_opcode()\n}\nunconstrained fn sender() -> AztecAddress {\n    sender_opcode()\n}\nunconstrained fn transaction_fee() -> Field {\n    transaction_fee_opcode()\n}\nunconstrained fn chain_id() -> Field {\n    chain_id_opcode()\n}\nunconstrained fn version() -> Field {\n    version_opcode()\n}\nunconstrained fn block_number() -> Field {\n    block_number_opcode()\n}\nunconstrained fn timestamp() -> u64 {\n    timestamp_opcode()\n}\nunconstrained fn fee_per_l2_gas() -> Field {\n    fee_per_l2_gas_opcode()\n}\nunconstrained fn fee_per_da_gas() -> Field {\n    fee_per_da_gas_opcode()\n}\nunconstrained fn l2_gas_left() -> Field {\n    l2_gas_left_opcode()\n}\nunconstrained fn da_gas_left() -> Field {\n    da_gas_left_opcode()\n}\nunconstrained fn is_static_call() -> Field {\n    is_static_call_opcode()\n}\nunconstrained fn note_hash_exists(note_hash: Field, leaf_index: Field) -> u1 {\n    note_hash_exists_opcode(note_hash, leaf_index)\n}\nunconstrained fn emit_note_hash(note_hash: Field) {\n    emit_note_hash_opcode(note_hash)\n}\nunconstrained fn nullifier_exists(nullifier: Field, address: Field) -> u1 {\n    nullifier_exists_opcode(nullifier, address)\n}\nunconstrained fn emit_nullifier(nullifier: Field) {\n    emit_nullifier_opcode(nullifier)\n}\nunconstrained fn emit_unencrypted_log(message: [Field]) {\n    emit_unencrypted_log_opcode(message)\n}\nunconstrained fn l1_to_l2_msg_exists(msg_hash: Field, msg_leaf_index: Field) -> u1 {\n    l1_to_l2_msg_exists_opcode(msg_hash, msg_leaf_index)\n}\nunconstrained fn send_l2_to_l1_msg(recipient: EthAddress, content: Field) {\n    send_l2_to_l1_msg_opcode(recipient, content)\n}\nunconstrained fn call(gas: [Field; 2], address: AztecAddress, args: [Field]) -> bool {\n    call_opcode(gas, address, args)\n}\nunconstrained fn call_static(gas: [Field; 2], address: AztecAddress, args: [Field]) -> bool {\n    call_static_opcode(gas, address, args)\n}\n\npub unconstrained fn calldata_copy<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {\n    calldata_copy_opcode(cdoffset, copy_size)\n}\n\nunconstrained fn returndata_size() -> u32 {\n    returndata_size_opcode()\n}\n\nunconstrained fn returndata_copy(rdoffset: u32, copy_size: u32) -> [Field] {\n    returndata_copy_opcode(rdoffset, copy_size)\n}\n\npub unconstrained fn avm_return(returndata: [Field]) {\n    return_opcode(returndata)\n}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\nunconstrained fn avm_revert(revertdata: [Field]) {\n    revert_opcode(revertdata)\n}\n\nunconstrained fn storage_read(storage_slot: Field) -> Field {\n    storage_read_opcode(storage_slot)\n}\n\nunconstrained fn storage_write(storage_slot: Field, value: Field) {\n    storage_write_opcode(storage_slot, value);\n}\n\nimpl Empty for PublicContext {\n    fn empty() -> Self {\n        PublicContext::new(|| 0)\n    }\n}\n\n// AVM oracles (opcodes) follow, do not use directly.\n#[oracle(avmOpcodeAddress)]\nunconstrained fn address_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeSender)]\nunconstrained fn sender_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeTransactionFee)]\nunconstrained fn transaction_fee_opcode() -> Field {}\n\n#[oracle(avmOpcodeChainId)]\nunconstrained fn chain_id_opcode() -> Field {}\n\n#[oracle(avmOpcodeVersion)]\nunconstrained fn version_opcode() -> Field {}\n\n#[oracle(avmOpcodeBlockNumber)]\nunconstrained fn block_number_opcode() -> Field {}\n\n#[oracle(avmOpcodeTimestamp)]\nunconstrained fn timestamp_opcode() -> u64 {}\n\n#[oracle(avmOpcodeFeePerL2Gas)]\nunconstrained fn fee_per_l2_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeFeePerDaGas)]\nunconstrained fn fee_per_da_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeL2GasLeft)]\nunconstrained fn l2_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeDaGasLeft)]\nunconstrained fn da_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeIsStaticCall)]\nunconstrained fn is_static_call_opcode() -> Field {}\n\n#[oracle(avmOpcodeNoteHashExists)]\nunconstrained fn note_hash_exists_opcode(note_hash: Field, leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNoteHash)]\nunconstrained fn emit_note_hash_opcode(note_hash: Field) {}\n\n#[oracle(avmOpcodeNullifierExists)]\nunconstrained fn nullifier_exists_opcode(nullifier: Field, address: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNullifier)]\nunconstrained fn emit_nullifier_opcode(nullifier: Field) {}\n\n#[oracle(avmOpcodeEmitUnencryptedLog)]\nunconstrained fn emit_unencrypted_log_opcode(message: [Field]) {}\n\n#[oracle(avmOpcodeL1ToL2MsgExists)]\nunconstrained fn l1_to_l2_msg_exists_opcode(msg_hash: Field, msg_leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeSendL2ToL1Msg)]\nunconstrained fn send_l2_to_l1_msg_opcode(recipient: EthAddress, content: Field) {}\n\n#[oracle(avmOpcodeCalldataCopy)]\nunconstrained fn calldata_copy_opcode<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {}\n\n#[oracle(avmOpcodeReturndataSize)]\nunconstrained fn returndata_size_opcode() -> u32 {}\n\n#[oracle(avmOpcodeReturndataCopy)]\nunconstrained fn returndata_copy_opcode(rdoffset: u32, copy_size: u32) -> [Field] {}\n\n#[oracle(avmOpcodeReturn)]\nunconstrained fn return_opcode(returndata: [Field]) {}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\n#[oracle(avmOpcodeRevert)]\nunconstrained fn revert_opcode(revertdata: [Field]) {}\n\n#[oracle(avmOpcodeCall)]\nunconstrained fn call_opcode(\n    gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n    address: AztecAddress,\n    args: [Field],\n) -> bool {}\n\n#[oracle(avmOpcodeStaticCall)]\nunconstrained fn call_static_opcode(\n    gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n    address: AztecAddress,\n    args: [Field],\n) -> bool {}\n\n#[oracle(avmOpcodeStorageRead)]\nunconstrained fn storage_read_opcode(storage_slot: Field) -> Field {}\n\n#[oracle(avmOpcodeStorageWrite)]\nunconstrained fn storage_write_opcode(storage_slot: Field, value: Field) {}\n"
     },
-    "105": {
+    "96": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/context/call_interfaces.nr",
       "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector, address::AztecAddress, traits::Deserialize,\n};\n\nuse crate::context::{gas::GasOpts, private_context::PrivateContext, public_context::PublicContext};\n\nuse crate::hash::hash_args;\nuse crate::oracle::arguments::pack_arguments;\n\npub trait CallInterface<let N: u32> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PrivateCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: T,\n    pub is_static: bool,\n}\n\nimpl<let N: u32, T> PrivateCallInterface<N, T> {\n    pub fn call<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        pack_arguments(self.args);\n        let returns = context.call_private_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            false,\n        );\n        let unpacked: T = returns.unpack_into();\n        unpacked\n    }\n\n    pub fn view<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        pack_arguments(self.args);\n        let returns = context.call_private_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            true,\n        );\n        returns.unpack_into()\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PrivateVoidCallInterface<N> {}\n\npub struct PrivateVoidCallInterface<let N: u32> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: (),\n    pub is_static: bool,\n}\n\nimpl<let N: u32> PrivateVoidCallInterface<N> {\n    pub fn call(self, context: &mut PrivateContext) {\n        pack_arguments(self.args);\n        context\n            .call_private_function_with_packed_args(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                false,\n            )\n            .assert_empty();\n    }\n\n    pub fn view(self, context: &mut PrivateContext) {\n        pack_arguments(self.args);\n        context\n            .call_private_function_with_packed_args(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                true,\n            )\n            .assert_empty();\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PrivateStaticCallInterface<N, T> {}\n\npub struct PrivateStaticCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: T,\n    pub is_static: bool,\n}\n\nimpl<let N: u32, T> PrivateStaticCallInterface<N, T> {\n    pub fn view<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        pack_arguments(self.args);\n        let returns = context.call_private_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            true,\n        );\n        returns.unpack_into()\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PrivateStaticVoidCallInterface<N> {}\n\npub struct PrivateStaticVoidCallInterface<let N: u32> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: (),\n    pub is_static: bool,\n}\n\nimpl<let N: u32> PrivateStaticVoidCallInterface<N> {\n    pub fn view(self, context: &mut PrivateContext) {\n        pack_arguments(self.args);\n        context\n            .call_private_function_with_packed_args(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                true,\n            )\n            .assert_empty();\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PublicCallInterface<N, T> {}\n\npub struct PublicCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args: [Field],\n    pub gas_opts: GasOpts,\n    pub return_type: T,\n    pub is_static: bool,\n}\n\nimpl<let N: u32, T> PublicCallInterface<N, T> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn call<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub unconstrained fn view<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub fn enqueue(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            false,\n        )\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PublicVoidCallInterface<N> {}\n\npub struct PublicVoidCallInterface<let N: u32> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args: [Field],\n    pub return_type: (),\n    pub is_static: bool,\n    pub gas_opts: GasOpts,\n}\n\nimpl<let N: u32> PublicVoidCallInterface<N> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn call(self, context: &mut PublicContext) {\n        let returns = context.call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub unconstrained fn view(self, context: &mut PublicContext) {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub fn enqueue(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            false,\n        )\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PublicStaticCallInterface<N, T> {}\n\npub struct PublicStaticCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args: [Field],\n    pub return_type: T,\n    pub is_static: bool,\n    pub gas_opts: GasOpts,\n}\n\nimpl<let N: u32, T> PublicStaticCallInterface<N, T> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn view<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PublicStaticVoidCallInterface<N> {}\n\npub struct PublicStaticVoidCallInterface<let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args: [Field],\n    return_type: (),\n    is_static: bool,\n    gas_opts: GasOpts,\n}\n\nimpl<let N: u32> PublicStaticVoidCallInterface<N> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn view(self, context: &mut PublicContext) {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n"
     },
-    "116": {
+    "107": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/history/public_storage.nr",
       "source": "use dep::protocol_types::{\n    address::AztecAddress, constants::GENERATOR_INDEX__PUBLIC_LEAF_INDEX,\n    hash::poseidon2_hash_with_separator, header::Header, utils::field::full_field_less_than,\n};\nuse dep::protocol_types::merkle_tree::root::root_from_sibling_path;\n\nuse crate::oracle::get_public_data_witness::get_public_data_witness;\n\ntrait PublicStorageHistoricalRead {\n    fn public_storage_historical_read(\n        header: Header,\n        storage_slot: Field,\n        contract_address: AztecAddress,\n    ) -> Field;\n}\n\nimpl PublicStorageHistoricalRead for Header {\n    fn public_storage_historical_read(\n        self,\n        storage_slot: Field,\n        contract_address: AztecAddress,\n    ) -> Field {\n        // 1) Compute the leaf index by siloing the storage slot with the contract address\n        let public_data_tree_index = poseidon2_hash_with_separator(\n            [contract_address.to_field(), storage_slot],\n            GENERATOR_INDEX__PUBLIC_LEAF_INDEX,\n        );\n\n        // 2) Get the membership witness for the tree index.\n        let witness = unsafe {\n            get_public_data_witness(\n                self.global_variables.block_number as u32,\n                public_data_tree_index,\n            )\n        };\n\n        // 3) The witness is made up of two parts: the preimage of the leaf and the proof that it exists in the tree.\n        // We first prove that the witness is indeed valid for the public data tree, i.e. that the preimage is of a\n        // value present in the tree. Note that `hash` returns not just the hash of the value but also the metadata\n        // (slot, next index and next slot).\n        assert(\n            self.state.partial.public_data_tree.root\n                == root_from_sibling_path(witness.leaf_preimage.hash(), witness.index, witness.path)\n                ,\n                \"Proving public value inclusion failed\",\n            );\n\n            // 4) Now that we know the preimage is valid, we determine the value that's represented by this tree entry. Here\n            // we have two scenarios:\n            // 1. The tree entry is initialized, and the value is the same as the one in the witness\n            // 2. The entry was never initialized, and the value is default zero (the default)\n            // The code below is based on the same checks in `validate_public_data_reads` in `base_rollup_inputs`.\n            let preimage = witness.leaf_preimage;\n\n            let is_less_than_slot = full_field_less_than(preimage.slot, public_data_tree_index);\n            let is_next_greater_than =\n                full_field_less_than(public_data_tree_index, preimage.next_slot);\n            let is_max = ((preimage.next_index == 0) & (preimage.next_slot == 0));\n            let is_in_range = is_less_than_slot & (is_next_greater_than | is_max);\n\n            let value = if is_in_range {\n                0\n            } else {\n                assert_eq(\n                    preimage.slot,\n                    public_data_tree_index,\n                    \"Public data tree index doesn't match witness\",\n                );\n                preimage.value\n            };\n\n            value\n        }\n}\n"
     },
-    "121": {
+    "112": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/notes.nr",
-      "source": "use crate::note::{note_header::NoteHeader, note_interface::NoteInterface};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n    utils::arr_copy_slice,\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            serialized_note,\n            note_hash,\n            counter,\n        )\n    };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_created_note_oracle(\n        storage_slot,\n        note_type_id,\n        serialized_note,\n        note_hash,\n        counter,\n    );\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _serialized_note: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(\n    _nullifier: Field,\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let S: u32>(\n    _storage_slot: Field,\n    _num_selects: u8,\n    _select_by_indexes: [u8; N],\n    _select_by_offsets: [u8; N],\n    _select_by_lengths: [u8; N],\n    _select_values: [Field; N],\n    _select_comparators: [u8; N],\n    _sort_by_indexes: [u8; N],\n    _sort_by_offsets: [u8; N],\n    _sort_by_lengths: [u8; N],\n    _sort_order: [u8; N],\n    _limit: u32,\n    _offset: u32,\n    _status: u8,\n    _return_size: u32,\n    _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let S: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; N],\n    select_by_offsets: [u8; N],\n    select_by_lengths: [u8; N],\n    select_values: [Field; N],\n    select_comparators: [u8; N],\n    sort_by_indexes: [u8; N],\n    sort_by_offsets: [u8; N],\n    sort_by_lengths: [u8; N],\n    sort_order: [u8; N],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_fields: [Field; S],\n) -> [Field; S] {\n    let return_size = placeholder_fields.len() as u32;\n    get_notes_oracle(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        return_size,\n        placeholder_fields,\n    )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let S: u32, let NS: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; M],\n    select_by_offsets: [u8; M],\n    select_by_lengths: [u8; M],\n    select_values: [Field; M],\n    select_comparators: [u8; M],\n    sort_by_indexes: [u8; M],\n    sort_by_offsets: [u8; M],\n    sort_by_lengths: [u8; M],\n    sort_order: [u8; M],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_opt_notes: [Option<Note>; S], // TODO: Remove it and use `limit` to initialize the note array.\n    placeholder_fields: [Field; NS], // TODO: Remove it and use `limit` to initialize the note array.\n    _placeholder_note_length: [Field; N], // Turbofish hack? Compiler breaks calculating read_offset unless we add this parameter\n) -> [Option<Note>; S]\nwhere\n    Note: NoteInterface<N>,\n{\n    sync_notes_oracle_wrapper();\n    let fields = get_notes_oracle_wrapper(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        placeholder_fields,\n    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n    for i in 0..placeholder_opt_notes.len() {\n        if i < num_notes {\n            // lengths named as per typescript.\n            let return_header_length: u32 = 2; // num_notes & contract_address.\n            let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n            let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n            let nonce = fields[read_offset];\n            let note_hash_counter = fields[read_offset + 1] as u32;\n            let header = NoteHeader { contract_address, nonce, storage_slot, note_hash_counter };\n            let serialized_note = arr_copy_slice(fields, [0; N], read_offset + 2);\n            let mut note = Note::deserialize_content(serialized_note);\n            note.set_header(header);\n            placeholder_opt_notes[i] = Option::some(note);\n        };\n    }\n    placeholder_opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier) == 1\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\n/// Same as `get_app_tagging_secret_as_sender`, except it returns the derived tag as an array of bytes, ready to be included in a\n/// log.\npub unconstrained fn get_app_tag_bytes_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> [u8; 32] {\n    let tag = get_app_tagging_secret_as_sender(sender, recipient).compute_tag(recipient);\n    tag.to_be_bytes()\n}\n\n/// Returns the tagging secret for a given sender and recipient pair, siloed for the current contract address.\n/// Includes the last known index used to send a note tagged with this secret.\n/// For this to work, PXE must know the ivpsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_app_tagging_secret_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n    let result = get_app_tagging_secret_as_sender_oracle(sender, recipient);\n    IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getAppTaggingSecretAsSender)]\nunconstrained fn get_app_tagging_secret_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) -> [Field; INDEXED_TAGGING_SECRET_LENGTH] {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n    }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) {\n    increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) {}\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them available\n/// for later querying via the `get_notes` oracle.\npub fn sync_notes() {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        sync_notes_oracle_wrapper();\n    }\n}\n\nunconstrained fn sync_notes_oracle_wrapper() {\n    sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n"
+      "source": "use crate::note::{note_header::NoteHeader, note_interface::NoteInterface};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n    utils::arr_copy_slice,\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            serialized_note,\n            note_hash,\n            counter,\n        )\n    };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_created_note_oracle(\n        storage_slot,\n        note_type_id,\n        serialized_note,\n        note_hash,\n        counter,\n    );\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _serialized_note: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(\n    _nullifier: Field,\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let S: u32>(\n    _storage_slot: Field,\n    _num_selects: u8,\n    _select_by_indexes: [u8; N],\n    _select_by_offsets: [u8; N],\n    _select_by_lengths: [u8; N],\n    _select_values: [Field; N],\n    _select_comparators: [u8; N],\n    _sort_by_indexes: [u8; N],\n    _sort_by_offsets: [u8; N],\n    _sort_by_lengths: [u8; N],\n    _sort_order: [u8; N],\n    _limit: u32,\n    _offset: u32,\n    _status: u8,\n    _return_size: u32,\n    _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let S: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; N],\n    select_by_offsets: [u8; N],\n    select_by_lengths: [u8; N],\n    select_values: [Field; N],\n    select_comparators: [u8; N],\n    sort_by_indexes: [u8; N],\n    sort_by_offsets: [u8; N],\n    sort_by_lengths: [u8; N],\n    sort_order: [u8; N],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_fields: [Field; S],\n) -> [Field; S] {\n    let return_size = placeholder_fields.len() as u32;\n    get_notes_oracle(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        return_size,\n        placeholder_fields,\n    )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let S: u32, let NS: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; M],\n    select_by_offsets: [u8; M],\n    select_by_lengths: [u8; M],\n    select_values: [Field; M],\n    select_comparators: [u8; M],\n    sort_by_indexes: [u8; M],\n    sort_by_offsets: [u8; M],\n    sort_by_lengths: [u8; M],\n    sort_order: [u8; M],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_opt_notes: [Option<Note>; S], // TODO: Remove it and use `limit` to initialize the note array.\n    placeholder_fields: [Field; NS], // TODO: Remove it and use `limit` to initialize the note array.\n    _placeholder_note_length: [Field; N], // Turbofish hack? Compiler breaks calculating read_offset unless we add this parameter\n) -> [Option<Note>; S]\nwhere\n    Note: NoteInterface<N>,\n{\n    sync_notes_oracle_wrapper();\n    let fields = get_notes_oracle_wrapper(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        placeholder_fields,\n    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n    for i in 0..placeholder_opt_notes.len() {\n        if i < num_notes {\n            // lengths named as per typescript.\n            let return_header_length: u32 = 2; // num_notes & contract_address.\n            let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n            let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n            let nonce = fields[read_offset];\n            let note_hash_counter = fields[read_offset + 1] as u32;\n            let header = NoteHeader { contract_address, nonce, storage_slot, note_hash_counter };\n            let serialized_note = arr_copy_slice(fields, [0; N], read_offset + 2);\n            let mut note = Note::deserialize_content(serialized_note);\n            note.set_header(header);\n            placeholder_opt_notes[i] = Option::some(note);\n        };\n    }\n    placeholder_opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier) == 1\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\n/// Same as `get_app_tagging_secret_as_sender`, except it returns the derived tag, ready to be included in a log.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n    get_app_tagging_secret_as_sender(sender, recipient).compute_tag(recipient)\n}\n\n/// Returns the tagging secret for a given sender and recipient pair, siloed for the current contract address.\n/// Includes the last known index used to send a note tagged with this secret.\n/// For this to work, PXE must know the ivpsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_app_tagging_secret_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n    let result = get_app_tagging_secret_as_sender_oracle(sender, recipient);\n    IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getAppTaggingSecretAsSender)]\nunconstrained fn get_app_tagging_secret_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) -> [Field; INDEXED_TAGGING_SECRET_LENGTH] {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n    }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) {\n    increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) {}\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them available\n/// for later querying via the `get_notes` oracle.\npub fn sync_notes() {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        sync_notes_oracle_wrapper();\n    }\n}\n\nunconstrained fn sync_notes_oracle_wrapper() {\n    sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n"
     },
-    "127": {
+    "118": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/arguments.nr",
       "source": "/// Notifies the simulator that `args` will later be used at some point during execution, referenced by their hash. This\n/// allows the simulator to know how to respond to this future request.\n///\n/// This is only used during private execution, since in public it is the VM itself that keeps track of arguments.\npub fn pack_arguments(args: [Field]) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call. When\n    // unpacking however the caller must check that the returned value is indeed the preimage.\n    unsafe { pack_arguments_oracle_wrapper(args) };\n}\n\n/// Same as `pack_arguments`, but using arrays instead of slices.\npub fn pack_arguments_array<let N: u32>(args: [Field; N]) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call. When\n    // unpacking however the caller must check that the returned value is indeed the preimage.\n    unsafe { pack_arguments_array_oracle_wrapper(args) };\n}\n\nunconstrained fn pack_arguments_oracle_wrapper(args: [Field]) {\n    let _ = pack_arguments_oracle(args);\n}\n\nunconstrained fn pack_arguments_array_oracle_wrapper<let N: u32>(args: [Field; N]) {\n    let _ = pack_arguments_array_oracle(args);\n}\n\n#[oracle(packArguments)]\nunconstrained fn pack_arguments_oracle(_args: [Field]) -> Field {}\n\n#[oracle(packArgumentsArray)]\nunconstrained fn pack_arguments_array_oracle<let N: u32>(_args: [Field; N]) -> Field {}\n"
     },
-    "129": {
+    "120": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr",
       "source": "use dep::protocol_types::{abis::function_selector::FunctionSelector, address::AztecAddress};\n\n#[oracle(enqueuePublicFunctionCall)]\nunconstrained fn enqueue_public_function_call_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn enqueue_public_function_call_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) -> Field {\n    enqueue_public_function_call_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\n#[oracle(setPublicTeardownFunctionCall)]\nunconstrained fn set_public_teardown_function_call_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn set_public_teardown_function_call_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) -> Field {\n    set_public_teardown_function_call_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\npub fn notify_set_min_revertible_side_effect_counter(counter: u32) {\n    unsafe { notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter) };\n}\n\npub unconstrained fn notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter: u32) {\n    notify_set_min_revertible_side_effect_counter_oracle(counter);\n}\n\n#[oracle(notifySetMinRevertibleSideEffectCounter)]\nunconstrained fn notify_set_min_revertible_side_effect_counter_oracle(_counter: u32) {}\n"
     },
-    "130": {
+    "121": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/get_l1_to_l2_membership_witness.nr",
       "source": "use dep::protocol_types::{\n    address::AztecAddress, constants::L1_TO_L2_MSG_TREE_HEIGHT, utils::arr_copy_slice,\n};\n\n/// Returns the leaf index and sibling path of an entry in the L1 to L2 messaging tree, which can then be used to prove\n/// its existence.\npub unconstrained fn get_l1_to_l2_membership_witness(\n    contract_address: AztecAddress,\n    message_hash: Field,\n    secret: Field,\n) -> (Field, [Field; L1_TO_L2_MSG_TREE_HEIGHT]) {\n    let returned_message =\n        get_l1_to_l2_membership_witness_oracle(contract_address, message_hash, secret);\n    let leaf_index = returned_message[0];\n    let sibling_path = arr_copy_slice(returned_message, [0; L1_TO_L2_MSG_TREE_HEIGHT], 1);\n\n    (leaf_index, sibling_path)\n}\n\n// Obtains membership witness (index and sibling path) for a message in the L1 to L2 message tree.\n#[oracle(getL1ToL2MembershipWitness)]\nunconstrained fn get_l1_to_l2_membership_witness_oracle(\n    _contract_address: AztecAddress,\n    _message_hash: Field,\n    _secret: Field,\n) -> [Field; L1_TO_L2_MSG_TREE_HEIGHT + 1] {}\n"
     },
-    "131": {
+    "122": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/get_public_data_witness.nr",
       "source": "use dep::protocol_types::{\n    constants::PUBLIC_DATA_TREE_HEIGHT, data::PublicDataTreeLeafPreimage, utils::arr_copy_slice,\n};\n\nglobal LEAF_PREIMAGE_LENGTH: u32 = 4;\nglobal PUBLIC_DATA_WITNESS: u32 = 45;\n\npub struct PublicDataWitness {\n    pub index: Field,\n    pub leaf_preimage: PublicDataTreeLeafPreimage,\n    pub path: [Field; PUBLIC_DATA_TREE_HEIGHT],\n}\n\n#[oracle(getPublicDataTreeWitness)]\nunconstrained fn get_public_data_witness_oracle(\n    _block_number: u32,\n    _public_data_tree_index: Field,\n) -> [Field; PUBLIC_DATA_WITNESS] {}\n\npub unconstrained fn get_public_data_witness(\n    block_number: u32,\n    public_data_tree_index: Field,\n) -> PublicDataWitness {\n    let fields = get_public_data_witness_oracle(block_number, public_data_tree_index);\n    PublicDataWitness {\n        index: fields[0],\n        leaf_preimage: PublicDataTreeLeafPreimage {\n            slot: fields[1],\n            value: fields[2],\n            next_index: fields[3] as u32,\n            next_slot: fields[4],\n        },\n        path: arr_copy_slice(\n            fields,\n            [0; PUBLIC_DATA_TREE_HEIGHT],\n            1 + LEAF_PREIMAGE_LENGTH,\n        ),\n    }\n}\n"
     },
-    "136": {
+    "127": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/messaging.nr",
       "source": "use crate::{\n    hash::{compute_l1_to_l2_message_hash, compute_l1_to_l2_message_nullifier, compute_secret_hash},\n    oracle::get_l1_to_l2_membership_witness::get_l1_to_l2_membership_witness,\n};\n\nuse dep::protocol_types::{\n    address::{AztecAddress, EthAddress},\n    merkle_tree::root::root_from_sibling_path,\n};\n\npub fn process_l1_to_l2_message(\n    l1_to_l2_root: Field,\n    contract_address: AztecAddress,\n    portal_contract_address: EthAddress,\n    chain_id: Field,\n    version: Field,\n    content: Field,\n    secret: Field,\n    leaf_index: Field,\n) -> Field {\n    let secret_hash = compute_secret_hash(secret);\n    let message_hash = compute_l1_to_l2_message_hash(\n        portal_contract_address,\n        chain_id,\n        contract_address,\n        version,\n        content,\n        secret_hash,\n        leaf_index,\n    );\n\n    // We prove that `message_hash` is in the tree by showing the derivation of the tree root, using a merkle path we\n    // get from an oracle.\n    let (_leaf_index, sibling_path) =\n        unsafe { get_l1_to_l2_membership_witness(contract_address, message_hash, secret) };\n\n    let root = root_from_sibling_path(message_hash, leaf_index, sibling_path);\n    assert(root == l1_to_l2_root, \"Message not in state\");\n\n    compute_l1_to_l2_message_nullifier(message_hash, secret)\n}\n"
     },
-    "151": {
+    "142": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/hash.nr",
       "source": "use crate::utils::to_bytes::{arr_to_be_bytes_arr, str_to_be_bytes_arr};\nuse dep::protocol_types::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n        GENERATOR_INDEX__SECRET_HASH,\n    },\n    hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice, sha256_to_field},\n    point::Point,\n    traits::Hash,\n};\n\npub use dep::protocol_types::hash::{compute_siloed_nullifier, pedersen_hash};\n\npub fn pedersen_commitment<let N: u32>(inputs: [Field; N], hash_index: u32) -> Point {\n    std::hash::pedersen_commitment_with_separator(inputs, hash_index)\n}\n\npub fn compute_secret_hash(secret: Field) -> Field {\n    poseidon2_hash_with_separator([secret], GENERATOR_INDEX__SECRET_HASH)\n}\n\npub fn compute_unencrypted_log_hash<let N: u32>(\n    contract_address: AztecAddress,\n    log: [u8; N],\n) -> Field {\n    let mut hash_bytes = [0; N + 36];\n    // Address is converted to 32 bytes in ts\n    let address_bytes: [u8; 32] = contract_address.to_field().to_be_bytes();\n    for i in 0..32 {\n        hash_bytes[i] = address_bytes[i];\n    }\n    let len_bytes: [u8; 4] = (N as Field).to_be_bytes();\n    for i in 0..4 {\n        hash_bytes[32 + i] = len_bytes[i];\n    }\n    for i in 0..N {\n        hash_bytes[36 + i] = log[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\npub fn compute_l1_to_l2_message_hash(\n    sender: EthAddress,\n    chain_id: Field,\n    recipient: AztecAddress,\n    version: Field,\n    content: Field,\n    secret_hash: Field,\n    leaf_index: Field,\n) -> Field {\n    let mut hash_bytes = [0 as u8; 224];\n    let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n    let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n    let version_bytes: [u8; 32] = version.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n    let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n    for i in 0..32 {\n        hash_bytes[i] = sender_bytes[i];\n        hash_bytes[i + 32] = chain_id_bytes[i];\n        hash_bytes[i + 64] = recipient_bytes[i];\n        hash_bytes[i + 96] = version_bytes[i];\n        hash_bytes[i + 128] = content_bytes[i];\n        hash_bytes[i + 160] = secret_hash_bytes[i];\n        hash_bytes[i + 192] = leaf_index_bytes[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n    poseidon2_hash_with_separator([message_hash, secret], GENERATOR_INDEX__MESSAGE_NULLIFIER)\n}\n\npub struct ArgsHasher {\n    pub fields: [Field],\n}\n\nimpl Hash for ArgsHasher {\n    fn hash(self) -> Field {\n        hash_args(self.fields)\n    }\n}\n\nimpl ArgsHasher {\n    pub fn new() -> Self {\n        Self { fields: [] }\n    }\n\n    pub fn add(&mut self, field: Field) {\n        self.fields = self.fields.push_back(field);\n    }\n\n    pub fn add_multiple<let N: u32>(&mut self, fields: [Field; N]) {\n        for i in 0..N {\n            self.fields = self.fields.push_back(fields[i]);\n        }\n    }\n}\n\npub fn hash_args_array<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\npub fn hash_args(args: [Field]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator_slice(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\n#[test]\nunconstrained fn compute_var_args_hash() {\n    let mut input = ArgsHasher::new();\n    for i in 0..100 {\n        input.add(i as Field);\n    }\n    let hash = input.hash();\n    dep::std::println(hash);\n    assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_array() {\n    let contract_address = AztecAddress::from_field(\n        0x233a3e0df23b2b15b324194cb4a151f26c0b7333250781d34cc269d85dc334c6,\n    );\n    let log = [\n        0x20660de09f35f876e3e69d227b2a35166ad05f09d82d06366ec9b6f65a51fec2,\n        0x1b52bfe3b8689761916f76dc3d38aa8810860db325cd39ca611eed980091f01c,\n        0x2e559c4045c378a56ad13b9edb1e8de4e7ad3b3aa35cc7ba9ec77f7a68fa43a4,\n        0x25d0f689c4a4178a29d59306f2675824d19be6d25e44fa03b03f49c263053dd2,\n        0x2d513a722d6f352dc0961f156afdc5e31495b9f0e35cb069261a8e55e2df67fd,\n    ];\n    let serialized_log = arr_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0095b2d17ab72f4b27a341f7ac63e49ec73935ae8c9181a0ac02023eb12f3284);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_addr() {\n    let contract_address = AztecAddress::from_field(\n        0x233a3e0df23b2b15b324194cb4a151f26c0b7333250781d34cc269d85dc334c6,\n    );\n    let log = AztecAddress::from_field(\n        0x26aa302d4715fd8a687453cb26d616b0768027bd54bcae56b09d908ecd9f8303,\n    );\n    let serialized_log: [u8; 32] = log.to_field().to_be_bytes();\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0083ab647dfb26e7ddee90a0f4209d049d4660cab42000c544b986aaa84c55a3);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_str() {\n    let contract_address = AztecAddress::from_field(\n        0x1b401e1146c5c507962287065c81f0ef7590adae3802c533d7549d6bf0a41bd8,\n    );\n    let log = \"dummy\";\n    let serialized_log = str_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x00629e88ebd6374f44aa6cfe07e251ecf07213ebc7267e8f6b578ae57ffd6c20);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_longer_str() {\n    let contract_address = AztecAddress::from_field(\n        0x1b401e1146c5c507962287065c81f0ef7590adae3802c533d7549d6bf0a41bd8,\n    );\n    let log = \"Hello this is a string\";\n    let serialized_log = str_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0098637962f7d34fa202b7ffad8a07a238c5d1fd897b82a108f7f467fa73b841);\n}\n"
     },
-    "179": {
+    "170": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/state_vars/public_mutable.nr",
       "source": "use crate::context::{PublicContext, UnconstrainedContext};\nuse crate::state_vars::storage::Storage;\nuse dep::protocol_types::traits::{Deserialize, Serialize};\n\n// docs:start:public_mutable_struct\npub struct PublicMutable<T, Context> {\n    context: Context,\n    storage_slot: Field,\n}\n// docs:end:public_mutable_struct\n\nimpl<T, Context, let N: u32> Storage<T, N> for PublicMutable<T, Context>\nwhere\n    T: Serialize<N> + Deserialize<N>,\n{}\n\nimpl<T, Context> PublicMutable<T, Context> {\n    // docs:start:public_mutable_struct_new\n    pub fn new(\n        // Note: Passing the contexts to new(...) just to have an interface compatible with a Map.\n        context: Context,\n        storage_slot: Field,\n    ) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        PublicMutable { context, storage_slot }\n    }\n    // docs:end:public_mutable_struct_new\n}\n\nimpl<T, let T_SERIALIZED_LEN: u32> PublicMutable<T, &mut PublicContext>\nwhere\n    T: Serialize<T_SERIALIZED_LEN> + Deserialize<T_SERIALIZED_LEN>,\n{\n    // docs:start:public_mutable_struct_read\n    pub fn read(self) -> T {\n        self.context.storage_read(self.storage_slot)\n    }\n    // docs:end:public_mutable_struct_read\n\n    // docs:start:public_mutable_struct_write\n    pub fn write(self, value: T) {\n        self.context.storage_write(self.storage_slot, value);\n    }\n    // docs:end:public_mutable_struct_write\n}\n\nimpl<T, let T_SERIALIZED_LEN: u32> PublicMutable<T, UnconstrainedContext>\nwhere\n    T: Deserialize<T_SERIALIZED_LEN>,\n{\n    pub unconstrained fn read(self) -> T {\n        self.context.storage_read(self.storage_slot)\n    }\n}\n"
     },
-    "182": {
+    "173": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/state_vars/public_immutable.nr",
       "source": "use crate::{\n    context::{PrivateContext, PublicContext, UnconstrainedContext},\n    state_vars::storage::Storage,\n};\nuse dep::protocol_types::{\n    constants::INITIALIZATION_SLOT_SEPARATOR,\n    traits::{Deserialize, Serialize},\n};\n\n/// Stores an immutable value in public state which can be read from public, private and unconstrained execution\n/// contexts.\n// docs:start:public_immutable_struct\npub struct PublicImmutable<T, Context> {\n    context: Context,\n    storage_slot: Field,\n}\n// docs:end:public_immutable_struct\n\nimpl<T, Context, let N: u32> Storage<T, N> for PublicImmutable<T, Context>\nwhere\n    T: Serialize<N> + Deserialize<N>,\n{}\n\nimpl<T, Context> PublicImmutable<T, Context> {\n    // docs:start:public_immutable_struct_new\n    pub fn new(\n        // Note: Passing the contexts to new(...) just to have an interface compatible with a Map.\n        context: Context,\n        storage_slot: Field,\n    ) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        PublicImmutable { context, storage_slot }\n    }\n    // docs:end:public_immutable_struct_new\n}\n\nimpl<T, let T_SERIALIZED_LEN: u32> PublicImmutable<T, &mut PublicContext>\nwhere\n    T: Serialize<T_SERIALIZED_LEN> + Deserialize<T_SERIALIZED_LEN>,\n{\n    // docs:start:public_immutable_struct_write\n    pub fn initialize(self, value: T) {\n        // We check that the struct is not yet initialized by checking if the initialization slot is 0\n        let initialization_slot = INITIALIZATION_SLOT_SEPARATOR + self.storage_slot;\n        let init_field: Field = self.context.storage_read(initialization_slot);\n        assert(init_field == 0, \"PublicImmutable already initialized\");\n\n        // We populate the initialization slot with a non-zero value to indicate that the struct is initialized\n        self.context.storage_write(initialization_slot, 0xdead);\n        self.context.storage_write(self.storage_slot, value);\n    }\n    // docs:end:public_immutable_struct_write\n\n    // Note that we don't access the context, but we do call oracles that are only available in public\n    // docs:start:public_immutable_struct_read\n    pub fn read(self) -> T {\n        self.context.storage_read(self.storage_slot)\n    }\n    // docs:end:public_immutable_struct_read\n}\n\nimpl<T, let T_SERIALIZED_LEN: u32> PublicImmutable<T, UnconstrainedContext>\nwhere\n    T: Serialize<T_SERIALIZED_LEN> + Deserialize<T_SERIALIZED_LEN>,\n{\n    pub unconstrained fn read(self) -> T {\n        self.context.storage_read(self.storage_slot)\n    }\n}\n\nimpl<T, let T_SERIALIZED_LEN: u32> PublicImmutable<T, &mut PrivateContext>\nwhere\n    T: Serialize<T_SERIALIZED_LEN> + Deserialize<T_SERIALIZED_LEN>,\n{\n    pub fn read(self) -> T {\n        let header = self.context.get_header();\n        let mut fields = [0; T_SERIALIZED_LEN];\n\n        for i in 0..fields.len() {\n            fields[i] = header.public_storage_historical_read(\n                self.storage_slot + i as Field,\n                (*self.context).this_address(),\n            );\n        }\n        T::deserialize(fields)\n    }\n}\n"
     },
-    "183": {
+    "174": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/state_vars/map.nr",
       "source": "use crate::state_vars::storage::Storage;\nuse dep::protocol_types::{\n    storage::map::derive_storage_slot_in_map,\n    traits::{Deserialize, Serialize, ToField},\n};\n\n// docs:start:map\npub struct Map<K, V, Context> {\n    context: Context,\n    storage_slot: Field,\n    state_var_constructor: fn(Context, Field) -> V,\n}\n// docs:end:map\n\nimpl<K, T, Context, let N: u32> Storage<T, N> for Map<K, T, Context>\nwhere\n    T: Serialize<N> + Deserialize<N>,\n{}\n\nimpl<K, V, Context> Map<K, V, Context> {\n    // docs:start:new\n    pub fn new(\n        context: Context,\n        storage_slot: Field,\n        state_var_constructor: fn(Context, Field) -> V,\n    ) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        Map { context, storage_slot, state_var_constructor }\n    }\n    // docs:end:new\n\n    // docs:start:at\n    pub fn at(self, key: K) -> V\n    where\n        K: ToField,\n    {\n        // TODO(#1204): use a generator index for the storage slot\n        let derived_storage_slot = derive_storage_slot_in_map(self.storage_slot, key);\n\n        let state_var_constructor = self.state_var_constructor;\n        state_var_constructor(self.context, derived_storage_slot)\n    }\n    // docs:end:at\n}\n"
     },
-    "184": {
+    "175": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/type_serialization.nr",
       "source": "use crate::traits::{Deserialize, Serialize};\n\nglobal BOOL_SERIALIZED_LEN: u32 = 1;\nglobal U8_SERIALIZED_LEN: u32 = 1;\nglobal U16_SERIALIZED_LEN: u32 = 1;\nglobal U32_SERIALIZED_LEN: u32 = 1;\nglobal U64_SERIALIZED_LEN: u32 = 1;\nglobal U128_SERIALIZED_LEN: u32 = 1;\nglobal FIELD_SERIALIZED_LEN: u32 = 1;\nglobal I8_SERIALIZED_LEN: u32 = 1;\nglobal I16_SERIALIZED_LEN: u32 = 1;\nglobal I32_SERIALIZED_LEN: u32 = 1;\nglobal I64_SERIALIZED_LEN: u32 = 1;\n\nimpl Serialize<BOOL_SERIALIZED_LEN> for bool {\n    fn serialize(self) -> [Field; BOOL_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<BOOL_SERIALIZED_LEN> for bool {\n    fn deserialize(fields: [Field; BOOL_SERIALIZED_LEN]) -> bool {\n        fields[0] as bool\n    }\n}\n\nimpl Serialize<U8_SERIALIZED_LEN> for u8 {\n    fn serialize(self) -> [Field; U8_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U8_SERIALIZED_LEN> for u8 {\n    fn deserialize(fields: [Field; U8_SERIALIZED_LEN]) -> Self {\n        fields[0] as u8\n    }\n}\n\nimpl Serialize<U16_SERIALIZED_LEN> for u16 {\n    fn serialize(self) -> [Field; U16_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U16_SERIALIZED_LEN> for u16 {\n    fn deserialize(fields: [Field; U16_SERIALIZED_LEN]) -> Self {\n        fields[0] as u16\n    }\n}\n\nimpl Serialize<U32_SERIALIZED_LEN> for u32 {\n    fn serialize(self) -> [Field; U32_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U32_SERIALIZED_LEN> for u32 {\n    fn deserialize(fields: [Field; U32_SERIALIZED_LEN]) -> Self {\n        fields[0] as u32\n    }\n}\n\nimpl Serialize<U64_SERIALIZED_LEN> for u64 {\n    fn serialize(self) -> [Field; U64_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U64_SERIALIZED_LEN> for u64 {\n    fn deserialize(fields: [Field; U64_SERIALIZED_LEN]) -> Self {\n        fields[0] as u64\n    }\n}\n\nimpl Serialize<U128_SERIALIZED_LEN> for U128 {\n    fn serialize(self) -> [Field; U128_SERIALIZED_LEN] {\n        [self.to_integer()]\n    }\n}\n\nimpl Deserialize<U128_SERIALIZED_LEN> for U128 {\n    fn deserialize(fields: [Field; U128_SERIALIZED_LEN]) -> Self {\n        U128::from_integer(fields[0])\n    }\n}\n\nimpl Serialize<FIELD_SERIALIZED_LEN> for Field {\n    fn serialize(self) -> [Field; FIELD_SERIALIZED_LEN] {\n        [self]\n    }\n}\n\nimpl Deserialize<FIELD_SERIALIZED_LEN> for Field {\n    fn deserialize(fields: [Field; FIELD_SERIALIZED_LEN]) -> Self {\n        fields[0]\n    }\n}\n\nimpl Serialize<I8_SERIALIZED_LEN> for i8 {\n    fn serialize(self) -> [Field; I8_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I8_SERIALIZED_LEN> for i8 {\n    fn deserialize(fields: [Field; I8_SERIALIZED_LEN]) -> Self {\n        fields[0] as i8\n    }\n}\n\nimpl Serialize<I16_SERIALIZED_LEN> for i16 {\n    fn serialize(self) -> [Field; I16_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I16_SERIALIZED_LEN> for i16 {\n    fn deserialize(fields: [Field; I16_SERIALIZED_LEN]) -> Self {\n        fields[0] as i16\n    }\n}\n\nimpl Serialize<I32_SERIALIZED_LEN> for i32 {\n    fn serialize(self) -> [Field; I32_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I32_SERIALIZED_LEN> for i32 {\n    fn deserialize(fields: [Field; I32_SERIALIZED_LEN]) -> Self {\n        fields[0] as i32\n    }\n}\n\nimpl Serialize<I64_SERIALIZED_LEN> for i64 {\n    fn serialize(self) -> [Field; I64_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I64_SERIALIZED_LEN> for i64 {\n    fn deserialize(fields: [Field; I64_SERIALIZED_LEN]) -> Self {\n        fields[0] as i64\n    }\n}\n\nimpl<T, let N: u32, let M: u32> Serialize<N * M> for [T; N]\nwhere\n    T: Serialize<M>,\n{\n    fn serialize(self) -> [Field; N * M] {\n        let mut result: [Field; N * M] = std::mem::zeroed();\n        let mut serialized: [Field; M] = std::mem::zeroed();\n        for i in 0..N {\n            serialized = self[i].serialize();\n            for j in 0..M {\n                result[i * M + j] = serialized[j];\n            }\n        }\n        result\n    }\n}\n\nimpl<T, let N: u32, let M: u32> Deserialize<N * M> for [T; N]\nwhere\n    T: Deserialize<M>,\n{\n    fn deserialize(fields: [Field; N * M]) -> Self {\n        let mut reader = crate::utils::reader::Reader::new(fields);\n        let mut result: [T; N] = std::mem::zeroed();\n        reader.read_struct_array::<T, M, N>(Deserialize::deserialize, result)\n    }\n}\n\n#[test]\nfn test_u16_serialization() {\n    let a: u16 = 10;\n    assert_eq(a, u16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i8_serialization() {\n    let a: i8 = -10;\n    assert_eq(a, i8::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i16_serialization() {\n    let a: i16 = -10;\n    assert_eq(a, i16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i32_serialization() {\n    let a: i32 = -10;\n    assert_eq(a, i32::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i64_serialization() {\n    let a: i64 = -10;\n    assert_eq(a, i64::deserialize(a.serialize()));\n}\n"
     },
-    "188": {
+    "179": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/data/public_data_tree_leaf_preimage.nr",
-      "source": "use crate::{merkle_tree::leaf_preimage::IndexedTreeLeafPreimage, traits::{Empty, Hash}};\n\npub struct PublicDataTreeLeafPreimage {\n    pub slot: Field,\n    pub value: Field,\n    pub next_slot: Field,\n    pub next_index: u32,\n}\n\nimpl Empty for PublicDataTreeLeafPreimage {\n    fn empty() -> Self {\n        Self { slot: 0, value: 0, next_slot: 0, next_index: 0 }\n    }\n}\n\nimpl Hash for PublicDataTreeLeafPreimage {\n    fn hash(self) -> Field {\n        if self.is_empty() {\n            0\n        } else {\n            crate::hash::poseidon2_hash([\n                self.slot,\n                self.value,\n                (self.next_index as Field),\n                self.next_slot,\n            ])\n        }\n    }\n}\n\nimpl IndexedTreeLeafPreimage for PublicDataTreeLeafPreimage {\n    fn get_key(self) -> Field {\n        self.slot\n    }\n\n    fn get_next_key(self) -> Field {\n        self.next_slot\n    }\n\n    fn as_leaf(self) -> Field {\n        self.hash()\n    }\n}\n\nimpl PublicDataTreeLeafPreimage {\n    pub fn is_empty(self) -> bool {\n        (self.slot == 0) & (self.value == 0) & (self.next_slot == 0) & (self.next_index == 0)\n    }\n}\n"
+      "source": "use crate::{\n    data::public_data_tree_leaf::PublicDataTreeLeaf,\n    merkle_tree::leaf_preimage::IndexedTreeLeafPreimage,\n    traits::{Empty, Hash},\n};\n\npub struct PublicDataTreeLeafPreimage {\n    pub slot: Field,\n    pub value: Field,\n    pub next_slot: Field,\n    pub next_index: u32,\n}\n\nimpl Empty for PublicDataTreeLeafPreimage {\n    fn empty() -> Self {\n        Self { slot: 0, value: 0, next_slot: 0, next_index: 0 }\n    }\n}\n\nimpl Eq for PublicDataTreeLeafPreimage {\n    fn eq(self, other: Self) -> bool {\n        (self.slot == other.slot)\n            & (self.value == other.value)\n            & (self.next_slot == other.next_slot)\n            & (self.next_index == other.next_index)\n    }\n}\n\nimpl Hash for PublicDataTreeLeafPreimage {\n    fn hash(self) -> Field {\n        if self.is_empty() {\n            0\n        } else {\n            crate::hash::poseidon2_hash([\n                self.slot,\n                self.value,\n                (self.next_index as Field),\n                self.next_slot,\n            ])\n        }\n    }\n}\n\nimpl IndexedTreeLeafPreimage<PublicDataTreeLeaf> for PublicDataTreeLeafPreimage {\n    fn get_key(self) -> Field {\n        self.slot\n    }\n\n    fn get_next_key(self) -> Field {\n        self.next_slot\n    }\n\n    fn points_to_infinity(self) -> bool {\n        (self.next_slot == 0) & (self.next_index == 0)\n    }\n\n    fn as_leaf(self) -> Field {\n        self.hash()\n    }\n\n    fn update_pointers(self, next_slot: Field, next_index: u32) -> Self {\n        Self { slot: self.slot, value: self.value, next_slot, next_index }\n    }\n\n    fn update_value(self, write: PublicDataTreeLeaf) -> Self {\n        Self {\n            slot: self.slot,\n            value: write.value,\n            next_slot: self.next_slot,\n            next_index: self.next_index,\n        }\n    }\n\n    fn build_insertion_leaf(write: PublicDataTreeLeaf, low_leaf: Self) -> Self {\n        Self {\n            slot: write.slot,\n            value: write.value,\n            next_slot: low_leaf.next_slot,\n            next_index: low_leaf.next_index,\n        }\n    }\n}\n\nimpl PublicDataTreeLeafPreimage {\n    pub fn is_empty(self) -> bool {\n        (self.slot == 0) & (self.value == 0) & (self.next_slot == 0) & (self.next_index == 0)\n    }\n}\n"
     },
-    "197": {
+    "188": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/traits.nr",
       "source": "use crate::meta::{derive_deserialize, derive_serialize};\nuse crate::utils::field::field_from_bytes;\n\n// Trait: is_empty\n//\n// The general is_empty trait checks if a data type is is empty,\n// and it defines empty for the basic data types as 0.\n//\n// If a Field is equal to zero, then it is regarded as zero.\n// We will go with this definition for now, however it can be problematic\n// if a value can actually be zero. In a future refactor, we can\n// use the optional type for safety. Doing it now would lead to a worse devex\n// and would make it harder to sync up with the cpp code.\n// Preferred over Default trait to convey intent, as default doesn't necessarily mean empty.\npub trait Empty {\n    fn empty() -> Self;\n}\n\nimpl Empty for Field {\n    fn empty() -> Self {\n        0\n    }\n}\n\nimpl Empty for u1 {\n    fn empty() -> Self {\n        0\n    }\n}\nimpl Empty for u8 {\n    fn empty() -> Self {\n        0\n    }\n}\nimpl Empty for u32 {\n    fn empty() -> Self {\n        0\n    }\n}\nimpl Empty for u64 {\n    fn empty() -> Self {\n        0\n    }\n}\nimpl Empty for U128 {\n    fn empty() -> Self {\n        U128::from_integer(0)\n    }\n}\n\npub fn is_empty<T>(item: T) -> bool\nwhere\n    T: Empty + Eq,\n{\n    item.eq(T::empty())\n}\n\npub fn is_empty_array<T, let N: u32>(array: [T; N]) -> bool\nwhere\n    T: Empty + Eq,\n{\n    array.all(|elem| is_empty(elem))\n}\n\npub trait Hash {\n    fn hash(self) -> Field;\n}\n\npub trait ToField {\n    fn to_field(self) -> Field;\n}\n\nimpl ToField for Field {\n    fn to_field(self) -> Field {\n        self\n    }\n}\n\nimpl ToField for bool {\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u1 {\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u8 {\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u32 {\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u64 {\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for U128 {\n    fn to_field(self) -> Field {\n        self.to_integer()\n    }\n}\nimpl<let N: u32> ToField for str<N> {\n    fn to_field(self) -> Field {\n        assert(N < 32, \"String doesn't fit in a field, consider using Serialize instead\");\n        field_from_bytes(self.as_bytes(), true)\n    }\n}\n\npub trait FromField {\n    fn from_field(value: Field) -> Self;\n}\n\nimpl FromField for Field {\n    fn from_field(value: Field) -> Self {\n        value\n    }\n}\n\nimpl FromField for bool {\n    fn from_field(value: Field) -> Self {\n        value as bool\n    }\n}\nimpl FromField for u1 {\n    fn from_field(value: Field) -> Self {\n        value as u1\n    }\n}\nimpl FromField for u8 {\n    fn from_field(value: Field) -> Self {\n        value as u8\n    }\n}\nimpl FromField for u32 {\n    fn from_field(value: Field) -> Self {\n        value as u32\n    }\n}\nimpl FromField for u64 {\n    fn from_field(value: Field) -> Self {\n        value as u64\n    }\n}\nimpl FromField for U128 {\n    fn from_field(value: Field) -> Self {\n        U128::from_integer(value)\n    }\n}\n\n// docs:start:serialize\n#[derive_via(derive_serialize)]\npub trait Serialize<let N: u32> {\n    fn serialize(self) -> [Field; N];\n}\n// docs:end:serialize\n\nimpl<let N: u32> Serialize<N> for str<N> {\n    fn serialize(self) -> [Field; N] {\n        let bytes = self.as_bytes();\n        let mut fields = [0; N];\n        for i in 0..bytes.len() {\n            fields[i] = bytes[i] as Field;\n        }\n        fields\n    }\n}\n\n// docs:start:deserialize\n#[derive_via(derive_deserialize)]\npub trait Deserialize<let N: u32> {\n    fn deserialize(fields: [Field; N]) -> Self;\n}\n// docs:end:deserialize\n\nimpl<let N: u32> Deserialize<N> for str<N> {\n    fn deserialize(fields: [Field; N]) -> Self {\n        str<N>::from(fields.map(|value| value as u8))\n    }\n}\n"
     },
-    "199": {
+    "190": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/storage/map.nr",
       "source": "use crate::{hash::poseidon2_hash, traits::ToField};\n\npub fn derive_storage_slot_in_map<K>(storage_slot: Field, key: K) -> Field\nwhere\n    K: ToField,\n{\n    poseidon2_hash([storage_slot, key.to_field()])\n}\n\nmod test {\n    use crate::{address::AztecAddress, storage::map::derive_storage_slot_in_map};\n\n    #[test]\n    fn test_derive_storage_slot_in_map_matches_typescript() {\n        let map_slot = 0x132258fb6962c4387ba659d9556521102d227549a386d39f0b22d1890d59c2b5;\n        let key = AztecAddress::from_field(\n            0x302dbc2f9b50a73283d5fb2f35bc01eae8935615817a0b4219a057b2ba8a5a3f,\n        );\n\n        let slot = derive_storage_slot_in_map(map_slot, key);\n\n        // The following value was generated by `map_slot.test.ts`\n        let slot_from_typescript =\n            0x15b9fe39449affd8b377461263e9d2b610b9ad40580553500b4e41d9cbd887ac;\n\n        assert_eq(slot, slot_from_typescript);\n    }\n}\n"
     },
-    "200": {
+    "191": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr",
       "source": "/// Utility function to console.log data in the acir simulator.\n/// Example:\n///   debug_log(\"blah blah this is a debug string\");\npub fn debug_log<let N: u32>(msg: str<N>) {\n    debug_log_format(msg, []);\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` array.\n/// Examples:\n///   debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n///   debug_log_format(\"whole array: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { debug_log_oracle_wrapper(msg, args) };\n}\n\npub unconstrained fn debug_log_oracle_wrapper<let M: u32, let N: u32>(\n    msg: str<M>,\n    args: [Field; N],\n) {\n    debug_log_oracle(msg, args.as_slice());\n}\n\n// WARNING: sometimes when using debug logs the ACVM errors with: `thrown: \"solver opcode resolution error: cannot solve opcode: expression has too many unknowns x155\"`\n#[oracle(debugLog)]\nunconstrained fn debug_log_oracle<let M: u32>(_msg: str<M>, args: [Field]) {}\n"
     },
-    "204": {
+    "195": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
       "source": "use crate::{\n    abis::function_selector::FunctionSelector,\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{\n        AZTEC_ADDRESS_LENGTH, FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        MAX_FIELD_VALUE,\n    },\n    contract_class_id::ContractClassId,\n    hash::{poseidon2_hash_with_separator, private_functions_root_from_siblings},\n    merkle_tree::membership::MembershipWitness,\n    public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, TpkM},\n    traits::{Deserialize, Empty, FromField, Serialize, ToField},\n    utils,\n};\n\n// We do below because `use crate::point::Point;` does not work\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\nuse crate::public_keys::AddressPoint;\nuse ec::{pow, sqrt};\nuse std::embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key};\n\n// Aztec address\npub struct AztecAddress {\n    pub inner: Field,\n}\n\nimpl Eq for AztecAddress {\n    fn eq(self, other: Self) -> bool {\n        self.to_field() == other.to_field()\n    }\n}\n\nimpl Empty for AztecAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl ToField for AztecAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl FromField for AztecAddress {\n    fn from_field(value: Field) -> AztecAddress {\n        AztecAddress { inner: value }\n    }\n}\n\nimpl Serialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn serialize(self: Self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n        [self.to_field()]\n    }\n}\n\nimpl Deserialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn deserialize(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n        FromField::from_field(fields[0])\n    }\n}\n\nimpl AztecAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    pub fn to_address_point(self) -> AddressPoint {\n        // We compute the address point by taking our address, setting it to x, and then solving for y in the\n        // equation which defines our bn curve:\n        // y^2 = x^3 - 17; x = address\n        let x = self.inner;\n        let y_squared = pow(x, 3) - 17;\n\n        // TODO (#8970): Handle cases where we cannot recover a point from an address\n        let mut y = sqrt(y_squared);\n\n        // If we get a negative y coordinate (any y where y > MAX_FIELD_VALUE / 2), we pin it to the\n        // positive one (any value where y <= MAX_FIELD_VALUE / 2) by subtracting it from the Field modulus\n        // note: The field modulus is MAX_FIELD_VALUE + 1\n        if (!(y.lt(MAX_FIELD_VALUE / 2) | y.eq(MAX_FIELD_VALUE / 2))) {\n            y = (MAX_FIELD_VALUE + 1) - y;\n        }\n\n        AddressPoint { inner: Point { x: self.inner, y, is_infinite: false } }\n    }\n\n    pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n        let public_keys_hash = public_keys.hash();\n\n        let pre_address = poseidon2_hash_with_separator(\n            [public_keys_hash.to_field(), partial_address.to_field()],\n            GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        );\n\n        let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n            public_keys.ivpk_m.to_point(),\n        );\n\n        // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n        // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n        // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n        // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n        // our secrect can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n        // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n        // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n        AztecAddress::from_field(address_point.x)\n    }\n\n    pub fn compute_from_private_function(\n        function_selector: FunctionSelector,\n        function_vk_hash: Field,\n        function_leaf_membership_witness: MembershipWitness<FUNCTION_TREE_HEIGHT>,\n        contract_class_artifact_hash: Field,\n        contract_class_public_bytecode_commitment: Field,\n        salted_initialization_hash: SaltedInitializationHash,\n        public_keys: PublicKeys,\n    ) -> Self {\n        let private_functions_root = private_functions_root_from_siblings(\n            function_selector,\n            function_vk_hash,\n            function_leaf_membership_witness.leaf_index,\n            function_leaf_membership_witness.sibling_path,\n        );\n\n        let contract_class_id = ContractClassId::compute(\n            contract_class_artifact_hash,\n            private_functions_root,\n            contract_class_public_bytecode_commitment,\n        );\n\n        // Compute contract address using the preimage which includes the class_id.\n        let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            salted_initialization_hash,\n        );\n\n        AztecAddress::compute(public_keys, partial_address)\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n\n    pub fn conditional_assign(predicate: bool, lhs: Self, rhs: Self) -> Self {\n        let result = utils::conditional_assign(predicate, rhs.to_field(), lhs.to_field());\n        Self { inner: result }\n    }\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n    let public_keys = PublicKeys {\n        npk_m: NpkM {\n            inner: Point {\n                x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n                y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n                is_infinite: false,\n            },\n        },\n        ivpk_m: IvpkM {\n            inner: Point {\n                x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n                y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n                is_infinite: false,\n            },\n        },\n        ovpk_m: OvpkM {\n            inner: Point {\n                x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n                y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n                is_infinite: false,\n            },\n        },\n        tpk_m: TpkM {\n            inner: Point {\n                x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n                y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n                is_infinite: false,\n            },\n        },\n    };\n\n    let partial_address = PartialAddress::from_field(\n        0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n    );\n\n    let address = AztecAddress::compute(public_keys, partial_address);\n\n    // The following value was generated by `derivation.test.ts`.\n    // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n    let expected_computed_address_from_partial_and_pubkeys =\n        0x24e4646f58b9fbe7d38e317db8d5636c423fbbdfbe119fc190fe9c64747e0c62;\n    assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n    let pre_address = poseidon2_hash_with_separator([1, 2], GENERATOR_INDEX__CONTRACT_ADDRESS_V1);\n    let expected_computed_preaddress_from_partial_and_pubkey =\n        0x23ce9be3fa3c846b0f9245cc796902e731d04f086e8a42473bb29e405fc98075;\n    assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(Deserialize::deserialize(address.serialize()), address);\n}\n"
     },
-    "205": {
+    "196": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/address/eth_address.nr",
       "source": "use crate::{constants::ETH_ADDRESS_LENGTH, traits::{Deserialize, Empty, Serialize, ToField}, utils};\n\npub struct EthAddress {\n    inner: Field,\n}\n\nimpl Eq for EthAddress {\n    fn eq(self, other: Self) -> bool {\n        self.to_field() == other.to_field()\n    }\n}\n\nimpl Empty for EthAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl ToField for EthAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl Serialize<ETH_ADDRESS_LENGTH> for EthAddress {\n    fn serialize(self: Self) -> [Field; ETH_ADDRESS_LENGTH] {\n        [self.inner]\n    }\n}\n\nimpl Deserialize<ETH_ADDRESS_LENGTH> for EthAddress {\n    fn deserialize(fields: [Field; ETH_ADDRESS_LENGTH]) -> Self {\n        EthAddress::from_field(fields[0])\n    }\n}\n\nimpl EthAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    pub fn from_field(field: Field) -> Self {\n        field.assert_max_bit_size::<160>();\n        Self { inner: field }\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n\n    pub fn conditional_assign(predicate: bool, lhs: Self, rhs: Self) -> Self {\n        let result = utils::conditional_assign(predicate, rhs.to_field(), lhs.to_field());\n        Self { inner: result }\n    }\n}\n"
     },
-    "229": {
+    "220": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
-      "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector,\n        log_hash::{LogHash, ScopedEncryptedLogHash, ScopedLogHash},\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    traits::{is_empty, ToField},\n    utils::field::field_from_bytes_32_trunc,\n};\nuse super::utils::field::field_from_bytes;\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = std::hash::sha256(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\nfn compute_note_hash_nonce(tx_hash: Field, note_index_in_tx: u32) -> Field {\n    // Hashing tx hash with note index in tx is guaranteed to be unique\n    poseidon2_hash_with_separator(\n        [tx_hash, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(nonce: Field, note_hash: Field) -> Field {\n    let inputs = [nonce, note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, unique_note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), unique_note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash, tx_hash: Field, note_index_in_tx: u32) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(tx_hash, note_index_in_tx);\n        let unique_note_hash = compute_unique_note_hash(nonce, note_hash.value());\n        compute_siloed_note_hash(note_hash.contract_address, unique_note_hash)\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn silo_encrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n    // We assume contract address has already been masked\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        accumulate_sha256(\n            [log_hash.contract_address.to_field(), log_hash.log_hash.value],\n        )\n    }\n}\n\npub fn mask_encrypted_log_hash(scoped_log: ScopedEncryptedLogHash) -> AztecAddress {\n    if scoped_log.contract_address.is_zero() {\n        AztecAddress::from_field(0)\n    } else if (scoped_log.log_hash.randomness == 0) {\n        scoped_log.contract_address\n    } else {\n        AztecAddress::from_field(poseidon2_hash_with_separator(\n            [scoped_log.contract_address.to_field(), scoped_log.log_hash.randomness],\n            0,\n        ))\n    }\n}\n\nfn compute_siloed_unencrypted_log_hash(address: AztecAddress, log_hash: Field) -> Field {\n    accumulate_sha256([address.to_field(), log_hash])\n}\n\npub fn silo_unencrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_unencrypted_log_hash(log_hash.contract_address, log_hash.value())\n    }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: BoundedVec<u8, 160> = BoundedVec::new();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..inputs.len() {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes.push(item_bytes[j]);\n        }\n    }\n\n    sha256_to_field(bytes.storage())\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a U128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\n// Computes the final logs hash for a tx.\npub fn compute_tx_logs_hash<let N: u32>(logs: [LogHash; N]) -> Field {\n    // Convert each field element into a byte array and append the bytes to `hash_input_flattened`\n    let mut hash_input_flattened = [0; N * 32];\n    for offset in 0..N {\n        // TODO: This is not checking that the decomposition is smaller than P\n        let input_as_bytes: [u8; 32] = logs[offset].value.to_be_radix(256);\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n    // Ideally we would push to a slice then hash, but there is no sha_slice\n    // Hardcode to 256 bytes for now\n    let mut hash = sha256_to_field(hash_input_flattened);\n    // Not having a 0 value hash for empty logs causes issues with empty txs\n    // used for padding. Returning early is currently unsupported.\n    // We always provide sorted logs here, so 0 being empty means all are empty.\n    if is_empty(logs[0]) {\n        hash = 0;\n    }\n    hash\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    // We manually hash the inputs here, since we cannot express with the type system a constant size inputs array of N + 1\n    let in_len = N + 1;\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    // We manually hash the inputs here, since we cannot express with the type system a constant size inputs array of Math.ceil(N/31)\n    let mut in_len = N / 31;\n    let mut has_padding = false;\n    if N % 31 != 0 {\n        in_len += 1;\n        has_padding = true;\n    }\n\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            sponge.absorb(field_from_bytes(current_field, false));\n            current_field = [0; 31];\n        }\n    }\n    if has_padding {\n        sponge.absorb(field_from_bytes(current_field, false));\n    }\n\n    sponge.squeeze()\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = std::hash::sha256(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
+      "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector,\n        log_hash::{LogHash, ScopedLogHash},\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::scoped::Scoped,\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    traits::{is_empty, ToField},\n    utils::field::field_from_bytes_32_trunc,\n};\nuse super::utils::field::field_from_bytes;\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = std::hash::sha256(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\nfn compute_note_hash_nonce(tx_hash: Field, note_index_in_tx: u32) -> Field {\n    // Hashing tx hash with note index in tx is guaranteed to be unique\n    poseidon2_hash_with_separator(\n        [tx_hash, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(nonce: Field, note_hash: Field) -> Field {\n    let inputs = [nonce, note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, unique_note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), unique_note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash, tx_hash: Field, note_index_in_tx: u32) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(tx_hash, note_index_in_tx);\n        let unique_note_hash = compute_unique_note_hash(nonce, note_hash.value());\n        compute_siloed_note_hash(note_hash.contract_address, unique_note_hash)\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n    poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped<PrivateLogData>) -> PrivateLog {\n    if private_log.contract_address.is_zero() {\n        private_log.inner.log\n    } else {\n        let mut fields = private_log.inner.log.fields;\n        fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n        PrivateLog { fields }\n    }\n}\n\nfn compute_siloed_unencrypted_log_hash(address: AztecAddress, log_hash: Field) -> Field {\n    accumulate_sha256([address.to_field(), log_hash])\n}\n\npub fn silo_unencrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_unencrypted_log_hash(log_hash.contract_address, log_hash.value())\n    }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: BoundedVec<u8, 160> = BoundedVec::new();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..inputs.len() {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes.push(item_bytes[j]);\n        }\n    }\n\n    sha256_to_field(bytes.storage())\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a U128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\n// Computes the final logs hash for a tx.\npub fn compute_tx_logs_hash<let N: u32>(logs: [LogHash; N]) -> Field {\n    // Convert each field element into a byte array and append the bytes to `hash_input_flattened`\n    let mut hash_input_flattened = [0; N * 32];\n    for offset in 0..N {\n        // TODO: This is not checking that the decomposition is smaller than P\n        let input_as_bytes: [u8; 32] = logs[offset].value.to_be_radix(256);\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n    // Ideally we would push to a slice then hash, but there is no sha_slice\n    // Hardcode to 256 bytes for now\n    let mut hash = sha256_to_field(hash_input_flattened);\n    // Not having a 0 value hash for empty logs causes issues with empty txs\n    // used for padding. Returning early is currently unsupported.\n    // We always provide sorted logs here, so 0 being empty means all are empty.\n    if is_empty(logs[0]) {\n        hash = 0;\n    }\n    hash\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    // We manually hash the inputs here, since we cannot express with the type system a constant size inputs array of N + 1\n    let in_len = N + 1;\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    // We manually hash the inputs here, since we cannot express with the type system a constant size inputs array of Math.ceil(N/31)\n    let mut in_len = N / 31;\n    let mut has_padding = false;\n    if N % 31 != 0 {\n        in_len += 1;\n        has_padding = true;\n    }\n\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            sponge.absorb(field_from_bytes(current_field, false));\n            current_field = [0; 31];\n        }\n    }\n    if has_padding {\n        sponge.absorb(field_from_bytes(current_field, false));\n    }\n\n    sponge.squeeze()\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = std::hash::sha256(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
     },
-    "286": {
+    "281": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/merkle_tree/root.nr",
       "source": "use crate::{hash::merkle_hash, merkle_tree::merkle_tree::MerkleTree};\n\n// Calculate the Merkle tree root from the sibling path and leaf.\n//\n// The leaf is hashed with its sibling, and then the result is hashed\n// with the next sibling etc in the path. The last hash is the root.\n//\n// TODO(David/Someone): The cpp code is using a uint256, whereas its\n// TODO a bit simpler in Noir to just have a bit array.\n// TODO: I'd generally like to avoid u256 for algorithms like\n// this because it means we never even need to consider cases where\n// the index is greater than p.\npub fn root_from_sibling_path<let N: u32>(\n    leaf: Field,\n    leaf_index: Field,\n    sibling_path: [Field; N],\n) -> Field {\n    let mut node = leaf;\n    let indices: [u1; N] = leaf_index.to_le_bits();\n\n    for i in 0..N {\n        let (hash_left, hash_right) = if indices[i] == 1 {\n            (sibling_path[i], node)\n        } else {\n            (node, sibling_path[i])\n        };\n        node = merkle_hash(hash_left, hash_right);\n    }\n    node\n}\n\npub fn calculate_subtree_root<let N: u32>(leaves: [Field; N]) -> Field {\n    MerkleTree::new(leaves).get_root()\n}\n\n// These values are precomputed and we run tests to ensure that they\n// are correct. The values themselves were computed from the cpp code.\n//\n// Would be good if we could use width since the compute_subtree\n// algorithm uses depth.\npub fn calculate_empty_tree_root(depth: u32) -> Field {\n    if depth == 0 {\n        0\n    } else if depth == 1 {\n        0x0b63a53787021a4a962a452c2921b3663aff1ffd8d5510540f8e659e782956f1\n    } else if depth == 2 {\n        0x0e34ac2c09f45a503d2908bcb12f1cbae5fa4065759c88d501c097506a8b2290\n    } else if depth == 3 {\n        0x21f9172d72fdcdafc312eee05cf5092980dda821da5b760a9fb8dbdf607c8a20\n    } else if depth == 4 {\n        0x2373ea368857ec7af97e7b470d705848e2bf93ed7bef142a490f2119bcf82d8e\n    } else if depth == 5 {\n        0x120157cfaaa49ce3da30f8b47879114977c24b266d58b0ac18b325d878aafddf\n    } else if depth == 6 {\n        0x01c28fe1059ae0237b72334700697bdf465e03df03986fe05200cadeda66bd76\n    } else if depth == 7 {\n        0x2d78ed82f93b61ba718b17c2dfe5b52375b4d37cbbed6f1fc98b47614b0cf21b\n    } else if depth == 8 {\n        0x067243231eddf4222f3911defbba7705aff06ed45960b27f6f91319196ef97e1\n    } else if depth == 9 {\n        0x1849b85f3c693693e732dfc4577217acc18295193bede09ce8b97ad910310972\n    } else if depth == 10 {\n        0x2a775ea761d20435b31fa2c33ff07663e24542ffb9e7b293dfce3042eb104686\n    } else {\n        panic(f\"depth should be between 0 and 10\")\n    }\n}\n\n#[test]\nfn test_merkle_root_interop_test() {\n    // This is a test to ensure that we match the cpp implementation.\n    // You can grep for `TEST_F(root_rollup_tests, noir_interop_test)`\n    // to find the test that matches this.\n    let root = calculate_subtree_root([1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]);\n    assert(0x1a09d935ae110b4c861fcec8f9099ec30b4485022aeb3d3cf9d7168e38fdc231 == root);\n\n    let empty_root = calculate_subtree_root([0; 16]);\n    assert(0x2373ea368857ec7af97e7b470d705848e2bf93ed7bef142a490f2119bcf82d8e == empty_root);\n}\n\n#[test]\nfn test_empty_subroot() {\n    assert(calculate_empty_tree_root(0) == 0);\n\n    let expected_empty_root_2 = calculate_subtree_root([0; 2]);\n    assert(calculate_empty_tree_root(1) == expected_empty_root_2);\n\n    let expected_empty_root_4 = calculate_subtree_root([0; 4]);\n    assert(calculate_empty_tree_root(2) == expected_empty_root_4);\n\n    let expected_empty_root_8 = calculate_subtree_root([0; 8]);\n    assert(calculate_empty_tree_root(3) == expected_empty_root_8);\n\n    let expected_empty_root_16 = calculate_subtree_root([0; 16]);\n    assert(calculate_empty_tree_root(4) == expected_empty_root_16);\n\n    let expected_empty_root_32 = calculate_subtree_root([0; 32]);\n    assert(calculate_empty_tree_root(5) == expected_empty_root_32);\n\n    let expected_empty_root_64 = calculate_subtree_root([0; 64]);\n    assert(calculate_empty_tree_root(6) == expected_empty_root_64);\n\n    let expected_empty_root_128 = calculate_subtree_root([0; 128]);\n    assert(calculate_empty_tree_root(7) == expected_empty_root_128);\n\n    let expected_empty_root_256 = calculate_subtree_root([0; 256]);\n    assert(calculate_empty_tree_root(8) == expected_empty_root_256);\n\n    let expected_empty_root_512 = calculate_subtree_root([0; 512]);\n    assert(calculate_empty_tree_root(9) == expected_empty_root_512);\n\n    let expected_empty_root_1024 = calculate_subtree_root([0; 1024]);\n    assert(calculate_empty_tree_root(10) == expected_empty_root_1024);\n}\n"
     },
-    "312": {
+    "307": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/utils/field.nr",
       "source": "pub fn field_from_bytes<let N: u32>(bytes: [u8; N], big_endian: bool) -> Field {\n    assert(bytes.len() < 32, \"field_from_bytes: N must be less than 32\");\n    let mut as_field = 0;\n    let mut offset = 1;\n    for i in 0..N {\n        let mut index = i;\n        if big_endian {\n            index = N - i - 1;\n        }\n        as_field += (bytes[index] as Field) * offset;\n        offset *= 256;\n    }\n\n    as_field\n}\n\n// Convert a 32 byte array to a field element by truncating the final byte\npub fn field_from_bytes_32_trunc(bytes32: [u8; 32]) -> Field {\n    // Convert it to a field element\n    let mut v = 1;\n    let mut high = 0 as Field;\n    let mut low = 0 as Field;\n\n    for i in 0..15 {\n        // covers bytes 16..30 (31 is truncated and ignored)\n        low = low + (bytes32[15 + 15 - i] as Field) * v;\n        v = v * 256;\n        // covers bytes 0..14\n        high = high + (bytes32[14 - i] as Field) * v;\n    }\n    // covers byte 15\n    low = low + (bytes32[15] as Field) * v;\n\n    low + high * v\n}\n\n// TODO to radix returns u8, so we cannot use bigger radixes. It'd be ideal to use a radix of the maximum range-constrained integer noir supports\npub fn full_field_less_than(lhs: Field, rhs: Field) -> bool {\n    lhs.lt(rhs)\n}\n\npub fn full_field_greater_than(lhs: Field, rhs: Field) -> bool {\n    rhs.lt(lhs)\n}\n\n#[test]\nunconstrained fn bytes_field_test() {\n    // Tests correctness of field_from_bytes_32_trunc against existing methods\n    // Bytes representing 0x543e0a6642ffeb8039296861765a53407bba62bd1c97ca43374de950bbe0a7\n    let inputs = [\n        84, 62, 10, 102, 66, 255, 235, 128, 57, 41, 104, 97, 118, 90, 83, 64, 123, 186, 98, 189, 28,\n        151, 202, 67, 55, 77, 233, 80, 187, 224, 167,\n    ];\n    let field = field_from_bytes(inputs, true);\n    let return_bytes: [u8; 31] = field.to_be_bytes();\n    assert_eq(inputs, return_bytes);\n    // 32 bytes - we remove the final byte, and check it matches the field\n    let inputs2 = [\n        84, 62, 10, 102, 66, 255, 235, 128, 57, 41, 104, 97, 118, 90, 83, 64, 123, 186, 98, 189, 28,\n        151, 202, 67, 55, 77, 233, 80, 187, 224, 167, 158,\n    ];\n    let field2 = field_from_bytes_32_trunc(inputs2);\n    let return_bytes2: [u8; 31] = field.to_be_bytes();\n\n    assert_eq(return_bytes2, return_bytes);\n    assert_eq(field2, field);\n}\n\n#[test]\nunconstrained fn max_field_test() {\n    // Tests the hardcoded value in constants.nr vs underlying modulus\n    // NB: We can't use 0-1 in constants.nr as it will be transpiled incorrectly to ts and sol constants files\n    let max_value = crate::constants::MAX_FIELD_VALUE;\n    assert_eq(max_value, 0 - 1);\n    // modulus == 0 is tested elsewhere, so below is more of a sanity check\n    let max_bytes: [u8; 32] = max_value.to_be_bytes();\n    let mod_bytes = std::field::modulus_be_bytes();\n    for i in 0..31 {\n        assert_eq(max_bytes[i], mod_bytes[i]);\n    }\n    assert_eq(max_bytes[31], mod_bytes[31] - 1);\n}\n"
     },
-    "313": {
+    "308": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr",
       "source": "pub struct Reader<let N: u32> {\n    data: [Field; N],\n    offset: u32,\n}\n\nimpl<let N: u32> Reader<N> {\n    pub fn new(data: [Field; N]) -> Self {\n        Self { data, offset: 0 }\n    }\n\n    pub fn read(&mut self) -> Field {\n        let result = self.data[self.offset];\n        self.offset += 1;\n        result\n    }\n\n    pub fn read_u32(&mut self) -> u32 {\n        self.read() as u32\n    }\n\n    pub fn read_bool(&mut self) -> bool {\n        self.read() as bool\n    }\n\n    pub fn read_array<let K: u32>(&mut self) -> [Field; K] {\n        let mut result = [0; K];\n        for i in 0..K {\n            result[i] = self.data[self.offset + i];\n        }\n        self.offset += K;\n        result\n    }\n\n    pub fn read_struct<T, let K: u32>(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n        let result = deserialise(self.read_array());\n        result\n    }\n\n    pub fn read_struct_array<T, let K: u32, let C: u32>(\n        &mut self,\n        deserialise: fn([Field; K]) -> T,\n        mut result: [T; C],\n    ) -> [T; C] {\n        for i in 0..C {\n            result[i] = self.read_struct(deserialise);\n        }\n        result\n    }\n\n    pub fn finish(self) {\n        assert(self.offset == self.data.len(), \"Reader did not read all data\");\n    }\n}\n"
     },
-    "315": {
+    "310": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/utils/mod.nr",
       "source": "// general util packages/modules are usually bad practice\n// because there is no criteria for what we should not put in here.\n// Reducing the size of this package would be welcome.\n\npub mod arrays;\npub mod field;\npub mod reader;\npub mod uint256;\n\n// if predicate == true then return lhs, else return rhs\npub fn conditional_assign(predicate: bool, lhs: Field, rhs: Field) -> Field {\n    if predicate {\n        lhs\n    } else {\n        rhs\n    }\n}\n\npub fn arr_copy_slice<T, let N: u32, let M: u32>(\n    src: [T; N],\n    mut dst: [T; M],\n    offset: u32,\n) -> [T; M] {\n    let iterator_len = if N > M { M } else { N };\n    for i in 0..iterator_len {\n        dst[i] = src[i + offset];\n    }\n    dst\n}\n"
     },
-    "393": {
+    "400": {
       "path": "/usr/src/noir-projects/noir-contracts/contracts/fee_juice_contract/src/main.nr",
       "source": "mod lib;\n\nuse dep::aztec::macros::aztec;\n\n#[aztec]\ncontract FeeJuice {\n    use dep::aztec::{\n        macros::{functions::{internal, private, public, view}, storage::storage},\n        protocol_types::address::{AztecAddress, EthAddress},\n        state_vars::{Map, PublicImmutable, PublicMutable},\n    };\n\n    use crate::lib::get_bridge_gas_msg_hash;\n\n    #[storage]\n    struct Storage<Context> {\n        // This map is accessed directly by protocol circuits to check balances for fee payment.\n        // Do not change this storage layout unless you also update the base rollup circuits.\n        balances: Map<AztecAddress, PublicMutable<U128, Context>, Context>,\n        portal_address: PublicImmutable<EthAddress, Context>,\n    }\n\n    // Not flagged as initializer to reduce cost of checking init nullifier in all functions.\n    // This function should be called as entrypoint to initialize the contract by minting itself funds.\n    #[private]\n    fn initialize(portal_address: EthAddress, initial_mint: Field) {\n        // Validate contract class parameters are correct\n        let self = context.this_address();\n\n        // Increase self balance and set as fee payer, and end setup\n        FeeJuice::at(self)._increase_public_balance(self, initial_mint).enqueue(&mut context);\n        context.set_as_fee_payer();\n        context.end_setup();\n\n        // Enqueue call to set the portal address\n        FeeJuice::at(self).set_portal(portal_address).enqueue(&mut context);\n    }\n\n    // We purposefully not set this function as an initializer so we do not bind\n    // the contract to a specific L1 portal address, since the Fee Juice address\n    // is a hardcoded constant in the rollup circuits.\n    #[public]\n    fn set_portal(portal_address: EthAddress) {\n        assert(storage.portal_address.read().is_zero());\n        storage.portal_address.initialize(portal_address);\n    }\n\n    #[private]\n    fn claim(to: AztecAddress, amount: Field, secret: Field, message_leaf_index: Field) {\n        let content_hash = get_bridge_gas_msg_hash(to, amount);\n        let portal_address = storage.portal_address.read();\n        assert(!portal_address.is_zero());\n\n        // Consume message and emit nullifier\n        context.consume_l1_to_l2_message(content_hash, secret, portal_address, message_leaf_index);\n\n        // TODO(palla/gas) Emit an unencrypted log to announce which L1 to L2 message has been claimed\n        // Otherwise, we cannot trace L1 deposits to their corresponding claims on L2\n        FeeJuice::at(context.this_address())._increase_public_balance(to, amount).enqueue(\n            &mut context,\n        );\n    }\n\n    #[public]\n    #[internal]\n    fn _increase_public_balance(to: AztecAddress, amount: Field) {\n        let new_balance = storage.balances.at(to).read().add(U128::from_integer(amount));\n        storage.balances.at(to).write(new_balance);\n    }\n\n    #[public]\n    #[view]\n    fn check_balance(fee_limit: Field) {\n        let fee_limit = U128::from_integer(fee_limit);\n        assert(storage.balances.at(context.msg_sender()).read() >= fee_limit, \"Balance too low\");\n    }\n\n    // utility function for testing\n    #[public]\n    #[view]\n    fn balance_of_public(owner: AztecAddress) -> pub Field {\n        storage.balances.at(owner).read().to_field()\n    }\n}\n"
     },
-    "394": {
+    "401": {
       "path": "/usr/src/noir-projects/noir-contracts/contracts/fee_juice_contract/src/lib.nr",
       "source": "use dep::aztec::context::PublicContext;\nuse dep::aztec::prelude::AztecAddress;\nuse dep::aztec::protocol_types::hash::sha256_to_field;\n\npub fn calculate_fee<TPublicContext>(context: PublicContext) -> Field {\n    context.transaction_fee()\n}\n\npub fn get_bridge_gas_msg_hash(owner: AztecAddress, amount: Field) -> Field {\n    let mut hash_bytes = [0; 68];\n    let recipient_bytes: [u8; 32] = owner.to_field().to_be_bytes();\n    let amount_bytes: [u8; 32] = amount.to_be_bytes();\n\n    // The purpose of including the following selector is to make the message unique to that specific call. Note that\n    // it has nothing to do with calling the function.\n    let selector = comptime { std::hash::keccak256(\"claim(bytes32,uint256)\".as_bytes(), 22) };\n\n    for i in 0..4 {\n        hash_bytes[i] = selector[i];\n    }\n\n    for i in 0..32 {\n        hash_bytes[i + 4] = recipient_bytes[i];\n        hash_bytes[i + 36] = amount_bytes[i];\n    }\n\n    let content_hash = sha256_to_field(hash_bytes);\n    content_hash\n}\n"
     }