@aztec/protocol-contracts 3.0.0-nightly.20251111 → 3.0.0-nightly.20251113

package/artifacts/Router.json

@@ -1,6 +1,6 @@
 {
   "transpiled": true,
-  "noir_version": "1.0.0-beta.15+89c2b2d0a5c8a60db85a7224398cd9ed0f010c4e-aztec",
+  "noir_version": "1.0.0-beta.15+1b1985e6fa77e221a6723006389c1351bc28b2b1-aztec",
   "name": "Router",
   "functions": [
     {
@@ -37,6 +37,11 @@
             "error_kind": "string",
             "string": "Block number mismatch."
           },
+          "4820051788501785972": {
+            "error_kind": "fmtstring",
+            "length": 17,
+            "item_types": []
+          },
           "7259463707251703666": {
             "error_kind": "string",
             "string": "Function check_block_number can only be called statically"
@@ -44,16 +49,11 @@
           "15764276373176857197": {
             "error_kind": "string",
             "string": "Stack too deep"
-          },
-          "17044658090447215604": {
-            "error_kind": "fmtstring",
-            "length": 17,
-            "item_types": []
           }
         }
       },
-      "bytecode": "JwACBAEoAAABBIBLJwAABEsnAgMEAicCBAQAHwoAAwAEAEkcAElJAhwASkoELQhJAS0ISgIlAAAATyUAAABuJwIBBEsnAgIEADsOAAIAAScAQwIDJwBEAgInAEUCAScARgIEJwBHAgYnAEgCBSYlAAAC/x4CAAQAHgIABQAeAgAGCScCBwEBJAIABgAAAJQlAAADJR4CAAYFHAoGCAAcCgIGAAoqCAYCDCoIBgkKIgFFBiQCAAYAAALoIwAAAL8KIgFEBRYKAgYkAgAFAAAC1iMAAADVCiIBQwgkAgAIAAACxCMAAADnCiIBRgokAgAKAAACrSMAAAD5CiIBSAoWCgkLJAIACgAAApYjAAABDwoiAUcGJAIABgAAAoQjAAABIScCAQJJJwICAm4nAgMCdicCBAJhJwIFAmwnAgYCaScCCAJkJwIJAiAnAgoCbycCCwJwJwIMAmUnAg0CcicCDgJ0LQgBDycCEAQSAAgBEAEnAw8EAQAiDwIQLQoQES0OAREAIhECES0OAhEAIhECES0OAxEAIhECES0OBBEAIhECES0OBREAIhECES0OBhEAIhECES0OCBEAIhECES0OCREAIhECES0OChEAIhECES0OCxEAIhECES0ODBEAIhECES0ODREAIhECES0OBBEAIhECES0ODhEAIhECES0OBhEAIhECES0OChEAIhECES0OAhEnAgEBACcCAgAACioBBwMkAgADAAAChCcCBAQTLQgBBScCBgQTAAgBBgEtCgUGKgMABgXsiso6Dxgb9AAiBgIGACIPAggnAgkEES0CCAMtAgYELQIJBSUAAAM3JwIIBBEAKgYIBi0OAgYAIgYCBjwOBAUtCgsBIwAAAo0tCgECIwAAAqQEKgsGAS0KAQIjAAACpC0KAggjAAACuxIqCQIBLQoBCCMAAAK7LQoIBSMAAALNLQoJBSMAAALNLQoFBCMAAALfLQoGBCMAAALfLQoEAyMAAALxLQoCAyMAAALxJAIAAwAAAv4lAAADaSYoAAAEBHhLDAAABAMkAAADAAADJCoBAAEF2sX11rRKMm08BAIBJioBAAEFZL7Lx4qT/3I8BAIBJgAAAwUHLQADCC0ABAkKAAgHCiQAAAoAAANoLQEIBi0EBgkAAAgCCAAACQIJIwAAA0QmKgEAAQUv0lArDpHQmTwEAgEm",
-      "debug_symbols": "tZfdauMwEIXfxde50IxGf32VpZS0dUvAJMFNFpaSd98ZW8dxFmza0L1pPh3FRzPSjBp/Nq/t8/n9abd/O3w0D78+m+d+13W796fu8LI97Q57VT8bZ3+IQvPgNw2xDpN96picgleByCBUEA/ICqIQTAkGpkSFaEo2UIXNOKnC9uVCCvblEkdgsil9ir1N6eosRUEf5yAVkk0VhVwqFAFUxTsBQCEoBIWhMBQPxUMRKAIlQLEEB7AER4CSoCQomQGxQiFAGEGcAwigLirkAdVQmAGpgidAXUIEhoIlkIUgC0EWgiwkwjBhiQTDjCUyDAuWwBEIjiA4D6hLBGJAXSIwAeoSwWrMk0GoIFAEitXYCLlCZECqkKBY8ANYtQxgoY5QlegEUA0jMaA+Hi3UEaB4KAg1ItQ4xMMKtlFeaz4NfaH1nCIZXC6bBq33dOrb1jpv1ovaocdt3+5PzcP+3HWb5ve2Ow9f+jhu98PnadvrrPZlu3/VTzV823Wt0WVzfdotP0qUcqiPE2UXJgty5caEVkyyE4aJetBkkm4D4WUPz3rs1UNZ4pLHWjLMdv+McejtkRaTkWUT9tFumMFEWfI1EH/jEX5gQ+L/3pAS07QhpcjihuSVDSneoUSUeTGZspKM3q8RyXi9fn8gmbiYzJqJi1OFuHwNI9yGQSuVypJ52g/JfjEX8munmyNNp5sz37Mhs1zIuaVcVrtfrs0fyj0OzpfJIcnifqaVrShoN3HXZmPmLzsIo7bE87LDSn2mkHAaKczbJN/eX26txHOZKrzMrp50a0FrnZanmnCOFy147URnN48WSFhKZXU/ZTqR2ZF+50QC4eoKPt3nkFDbcVba33GI9j93dIj3OSSHGJK/0yGhMrPzdzlkQRY5LcfgVwozoR7S9STEfz2FqZ7SndsYpwhi/qfBH3W4fdn1N68gF7Pqd9vnrq3Dt/P+ZTZ7+nPEDF5hjv3hpX099605Xd9j9AfXL9JbUq+mR33FcDYMYUPR2ZCGWdKhf7xYMH8B"
+      "bytecode": "JwACBAEoAAABBIBLJwAABEsnAgMEAicCBAQAHwoAAwAEAEkcAElJAhwASkoELQhJAS0ISgIlAAAATyUAAABuJwIBBEsnAgIEADsOAAIAAScAQwIDJwBEAgInAEUCAScARgIEJwBHAgYnAEgCBSYlAAAC/x4CAAQAHgIABQAeAgAGCScCBwEBJAIABgAAAJQlAAADJR4CAAYFHAoGCAAcCgIGAAoqCAYCDCoIBgkKIgFFBiQCAAYAAALoIwAAAL8KIgFEBRYKAgYkAgAFAAAC1iMAAADVCiIBQwgkAgAIAAACxCMAAADnCiIBRgokAgAKAAACrSMAAAD5CiIBSAoWCgkLJAIACgAAApYjAAABDwoiAUcGJAIABgAAAoQjAAABIScCAQJJJwICAm4nAgMCdicCBAJhJwIFAmwnAgYCaScCCAJkJwIJAiAnAgoCbycCCwJwJwIMAmUnAg0CcicCDgJ0LQgBDycCEAQSAAgBEAEnAw8EAQAiDwIQLQoQES0OAREAIhECES0OAhEAIhECES0OAxEAIhECES0OBBEAIhECES0OBREAIhECES0OBhEAIhECES0OCBEAIhECES0OCREAIhECES0OChEAIhECES0OCxEAIhECES0ODBEAIhECES0ODREAIhECES0OBBEAIhECES0ODhEAIhECES0OBhEAIhECES0OChEAIhECES0OAhEnAgEBACcCAgAACioBBwMkAgADAAAChCcCBAQTLQgBBScCBgQTAAgBBgEtCgUGKgMABgVC5EOQXKKddAAiBgIGACIPAggnAgkEES0CCAMtAgYELQIJBSUAAAM3JwIIBBEAKgYIBi0OAgYAIgYCBjwOBAUtCgsBIwAAAo0tCgECIwAAAqQEKgsGAS0KAQIjAAACpC0KAggjAAACuxIqCQIBLQoBCCMAAAK7LQoIBSMAAALNLQoJBSMAAALNLQoFBCMAAALfLQoGBCMAAALfLQoEAyMAAALxLQoCAyMAAALxJAIAAwAAAv4lAAADaSYoAAAEBHhLDAAABAMkAAADAAADJCoBAAEF2sX11rRKMm08BAIBJioBAAEFZL7Lx4qT/3I8BAIBJgAAAwUHLQADCC0ABAkKAAgHCiQAAAoAAANoLQEIBi0EBgkAAAgCCAAACQIJIwAAA0QmKgEAAQUv0lArDpHQmTwEAgEm",
+      "debug_symbols": "tZfdauMwEIXfxde50IxGf32VUkqauiVgkuAmC0vJu++Mo+M4Czab0L1pPh3ZRzOjkai/m/f27fT5ut197L+ap+fv5q3fdt3287Xbb9bH7X6n6nfj7A9RaJ78qiHWYbJfHZNT8CoQGYQK4gFZQRSCKcHAlKgQTckGqrAZJ1XYHi6kYA+XeAEmm9K32NuUrs5SFPR1DlIh2VRRyKVCEUBVvBMAFIJCUBgKQ/FQPBSBIlACFEtwAEvwAlASlAQlMyBWKAQIFxDnAAKoiwp5QDUUZkCq4AlQlxCBoWAJZCHIQpCFIAuJMExYIsEwY4kMw4IlsAWCLQjOA+oSgRhQlwhMgLpEsB7zZBAqCBSBYj12gVwhMiBVSFAs+AGsWwawUC9QlegEUA0jMaC+Hi3UC0DxUBBqRKhxiIcVrFBeez4N50L7OUUyOJ9XDY7e67FvWzt5k7OoJ/Sw7tvdsXnanbpu1fxad6fhoa/Dejf8Hte9zuq5bHfv+quGH9uuNTqvrm+7+VeJUg71daLswmhBdGtCCybZCcNEPWg0SXTjwfMennXbq4eyxDmPpWSY7f65xKG3R5pNRuZN2Ee7YQYTZcnXQOTGI/xAQeL/LkiJaSxIKTJbkLxQkOIdWkSZZ5MpC8no/RqRjNfr9weSibPJLJm4OHaIy9cwwm0YtNCpLJnHekj2s7mQX9rdHGnc3Zz5kYJMciHn5nJZPP1yPfyhPOLgfBkdkszWMy2UouC4ibseNmb/zw7C6C3xPO+w0J8pJOxGCtNjkm/vr4VKeKFxQ2XS4MM9P7FYuEe9cx4WjmXWgpd2dHLzaIOEuVQW6ynjjky29J4dCYSrK/j0mENCb8dJa9/jED2KGeNjDskhhuQfdEjozOz8Qw5ZkEVO8zH4hcZM6Id03Qm5I4Wxn9KDZYxjBDH/dcBfdLjebPubT5CzWfXb9VvX1uHHabeZzB5/HzCDT5hDv9+076e+Nafrd4z+w/VMekvq1fSinxjOhiGsKDob0jBLOvQvZwvmDw=="
     },
     {
       "name": "check_timestamp",
@@ -85,6 +85,11 @@
         ],
         "return_type": null,
         "error_types": {
+          "4820051788501785972": {
+            "error_kind": "fmtstring",
+            "length": 17,
+            "item_types": []
+          },
           "6989792215391248978": {
             "error_kind": "string",
             "string": "Function check_timestamp can only be called statically"
@@ -96,16 +101,11 @@
           "15764276373176857197": {
             "error_kind": "string",
             "string": "Stack too deep"
-          },
-          "17044658090447215604": {
-            "error_kind": "fmtstring",
-            "length": 17,
-            "item_types": []
           }
         }
       },
-      "bytecode": "JwACBAEoAAABBIBLJwAABEsnAgMEAicCBAQAHwoAAwAEAEkcAElJAhwASkoFLQhJAS0ISgIlAAAATyUAAABuJwIBBEsnAgIEADsOAAIAAScAQwIDJwBEAgInAEUCAScARgIEJwBHAgYnAEgCBSYlAAAC/x4CAAQAHgIABQAeAgAGCScCBwEBJAIABgAAAJQlAAADJR4CAAYGHAoGCAAcCgIGAAoqCAYCDCoIBgkKIgFFBiQCAAYAAALoIwAAAL8KIgFEBRYKAgYkAgAFAAAC1iMAAADVCiIBQwgkAgAIAAACxCMAAADnCiIBRgokAgAKAAACrSMAAAD5CiIBSAoWCgkLJAIACgAAApYjAAABDwoiAUcGJAIABgAAAoQjAAABIScCAQJJJwICAm4nAgMCdicCBAJhJwIFAmwnAgYCaScCCAJkJwIJAiAnAgoCbycCCwJwJwIMAmUnAg0CcicCDgJ0LQgBDycCEAQSAAgBEAEnAw8EAQAiDwIQLQoQES0OAREAIhECES0OAhEAIhECES0OAxEAIhECES0OBBEAIhECES0OBREAIhECES0OBhEAIhECES0OCBEAIhECES0OCREAIhECES0OChEAIhECES0OCxEAIhECES0ODBEAIhECES0ODREAIhECES0OBBEAIhECES0ODhEAIhECES0OBhEAIhECES0OChEAIhECES0OAhEnAgEBACcCAgAACioBBwMkAgADAAAChCcCBAQTLQgBBScCBgQTAAgBBgEtCgUGKgMABgXsiso6Dxgb9AAiBgIGACIPAggnAgkEES0CCAMtAgYELQIJBSUAAAM3JwIIBBEAKgYIBi0OAgYAIgYCBjwOBAUtCgsBIwAAAo0tCgECIwAAAqQEKgsGAS0KAQIjAAACpC0KAggjAAACuxIqCQIBLQoBCCMAAAK7LQoIBSMAAALNLQoJBSMAAALNLQoFBCMAAALfLQoGBCMAAALfLQoEAyMAAALxLQoCAyMAAALxJAIAAwAAAv4lAAADaSYoAAAEBHhLDAAABAMkAAADAAADJCoBAAEF2sX11rRKMm08BAIBJioBAAEFYQC6/IQvolI8BAIBJgAAAwUHLQADCC0ABAkKAAgHCiQAAAoAAANoLQEIBi0EBgkAAAgCCAAACQIJIwAAA0QmKgEAAQXBmTXwTaZKMzwEAgEm",
-      "debug_symbols": "tZfRTuMwEEX/Jc998IzHHptfQQgVCKhSVVBpV1qh/vvOpL5pulIitmJfyPF1fD1jj03z1b30T8e3x83u9f2zu7v/6p72m+128/a4fX9eHzbvO1O/uuB/iFJ3F1cdsTXVn9amYBBNIHJIDSQCioEYJFeSgyvZILtSHExhN1ZT2F+uZOAv13wGJu+yURy9y2ZnqQY2nJM0UO+qBqU2qAJoSgwCgEJQCApDYSgRSoQiUARKguIJDuAJngGKQlEohQG5QSVAOoOEABBAm1QoApqhMAO0QSRAm0IEhoIpkIUgC0EWgiwkw1AxhcKwYIoCw4opsAWCLUghAtoUiRjQpkhMgDZF8hqL5JAaCBSB4jV2htIgM0AbKBQPfgCvlgE81DM0JQcBNMNMDGjDs4d6BigRCkLNCDUP8bCBL1S0mtfhXFg9ayaH02nV4eg9HvZ97ydvchbthH6s9/3u0N3tjtvtqvu13h6Hlz4/1rvheVjvrdfOZb97sacZvm62vdNpdRkd5ocSaUltOFEJabSgUK9MaMGkBGGYmAeNJnodCM97RLZtbx7Gkuc8lpJh9vvnHIfdHjqbjMybcMx+wwwmxlIugcQrj/QDC5L/94LUrOOC1CqzC1IWFqTGgBIx5tlk6kIydr9mJBPt+v2BZPJsMgsmmZBKjpfySNdB0EKdcqoZNWasaS4Tikt7W1nHva2SbliOSSaTGk3fH69II5dbxutYFDqJ/++V1IVFqDhmEi4BMPO3HYRRUxJ53mGhLjUpIYs0PR7l+t4KS6Vd6ljZdXLl6LUFLZ2wgihiCDxrwUv3+OTGoZDTXCqL6ynjjqjctCOJcGWlyfH6J4dLWYZwk0P2/7Vnh3ybgwbEoPFGB0VllhBvciiCLIrOxxCXDijqQS87IfH7KYz1pDcuYx4jmN4wg8ODNdfPm/3Vp8fJrfab9dO2b83X4+550nv4/YEefLp87N+f+5fjvneny/eL/dC6J7unSeXBPi2CN1NaUQ7eJG+qNVUfTh7MHw=="
+      "bytecode": "JwACBAEoAAABBIBLJwAABEsnAgMEAicCBAQAHwoAAwAEAEkcAElJAhwASkoFLQhJAS0ISgIlAAAATyUAAABuJwIBBEsnAgIEADsOAAIAAScAQwIDJwBEAgInAEUCAScARgIEJwBHAgYnAEgCBSYlAAAC/x4CAAQAHgIABQAeAgAGCScCBwEBJAIABgAAAJQlAAADJR4CAAYGHAoGCAAcCgIGAAoqCAYCDCoIBgkKIgFFBiQCAAYAAALoIwAAAL8KIgFEBRYKAgYkAgAFAAAC1iMAAADVCiIBQwgkAgAIAAACxCMAAADnCiIBRgokAgAKAAACrSMAAAD5CiIBSAoWCgkLJAIACgAAApYjAAABDwoiAUcGJAIABgAAAoQjAAABIScCAQJJJwICAm4nAgMCdicCBAJhJwIFAmwnAgYCaScCCAJkJwIJAiAnAgoCbycCCwJwJwIMAmUnAg0CcicCDgJ0LQgBDycCEAQSAAgBEAEnAw8EAQAiDwIQLQoQES0OAREAIhECES0OAhEAIhECES0OAxEAIhECES0OBBEAIhECES0OBREAIhECES0OBhEAIhECES0OCBEAIhECES0OCREAIhECES0OChEAIhECES0OCxEAIhECES0ODBEAIhECES0ODREAIhECES0OBBEAIhECES0ODhEAIhECES0OBhEAIhECES0OChEAIhECES0OAhEnAgEBACcCAgAACioBBwMkAgADAAAChCcCBAQTLQgBBScCBgQTAAgBBgEtCgUGKgMABgVC5EOQXKKddAAiBgIGACIPAggnAgkEES0CCAMtAgYELQIJBSUAAAM3JwIIBBEAKgYIBi0OAgYAIgYCBjwOBAUtCgsBIwAAAo0tCgECIwAAAqQEKgsGAS0KAQIjAAACpC0KAggjAAACuxIqCQIBLQoBCCMAAAK7LQoIBSMAAALNLQoJBSMAAALNLQoFBCMAAALfLQoGBCMAAALfLQoEAyMAAALxLQoCAyMAAALxJAIAAwAAAv4lAAADaSYoAAAEBHhLDAAABAMkAAADAAADJCoBAAEF2sX11rRKMm08BAIBJioBAAEFYQC6/IQvolI8BAIBJgAAAwUHLQADCC0ABAkKAAgHCiQAAAoAAANoLQEIBi0EBgkAAAgCCAAACQIJIwAAA0QmKgEAAQXBmTXwTaZKMzwEAgEm",
+      "debug_symbols": "tZfRauMwEEX/xc950EgjjdRfWUpJW7cEQhLcZGEp+fedcXRtZ8GmNd2X5ujaupqRRkP92by2z5f3p93h7fjRPPz6bJ673X6/e3/aH1+2593xoOpn4+wPUWwewqYhr0OxXx2TUwgqEBnEChwAWYEVoinRwJSkkEzJBqp4MxZVvL1cSMFeLukGnuyRzvLBHunqnouCTveRK4g9Kgq5VCgMqEpwDIBCUAiKh+KhBCgBCkNhKBGKJdiDJXgDKAJFoGQPSBUKAeIN2DkAA+qiTAFQDdl7gFQIBKhLMMOQsQSyYGTByIKRBScYCpYQGGYskWFYsASOgHEE0QVAXSKSB9QloidAXSJajQUyiBUYCkOxGrtBrpA8QCoIFAu+B6uWHizUG1QlOQZUw0QeUKcnC/UGUAIUhJoQaurj8Qq2UUFrXvp7ofUsiQyu102Dq/d07trWbt7kLuoNPW279nBuHg6X/X7T/N7uL/1LH6ftof89bzt9qveyPbzqrxq+7fat0XUzznbzU4kkxzqdKLs4WBDdm9CCSXbsYaIeNJgI3Xn4eY/g9dirhzKnOY+lZLy3/nOLQ7uHzCbD8yY+JOswvYky5zEQvvOIP7Ah6X9vSEkybEgpPLsheWFDSnAoEWU/m0xZSEb7a0IyQdvvDySTZpNZMEmEVFIYyyPeB0ELdepjSagxZYlzmVBYOtviZTjbwnHFdkwymdRo/Pp8QRopr5kvQ1HIJP5/d1IWNqHgmrEbA/A+fNmBPWqKg593WKhLiULIIk6vR77vWwv7EJhgoTgWdt/fJxYL/TM4F2DhPM9a+KU+Puk45FKcS2VxP3k4EeFVJxIJLStOrte3HMaydG6VQwrYzJTWOYhDDBJWOggqM7uwyiEzssgyH0NYuqCoBxlPgr+RwlBPsnIb0xDBtMP0Do863L7surtPj6tZdbvt876tw7fL4WXy9PznhCf4dDl1x5f29dK15jR+v+g/Wr9I+zQJP+qnhbNhjBtKzoZkQ9GhyOPVgvkL"
     },
     {
       "name": "process_message",
@@ -241,6 +241,11 @@
             "error_kind": "string",
             "string": "Input length must be a multiple of 32"
           },
+          "6504742485148360234": {
+            "error_kind": "fmtstring",
+            "length": 40,
+            "item_types": []
+          },
           "7564993426627941149": {
             "error_kind": "fmtstring",
             "length": 48,
@@ -277,11 +282,6 @@
             "error_kind": "string",
             "string": "Attempted to read past the length of a CapsuleArray"
           },
-          "9921926525851912681": {
-            "error_kind": "fmtstring",
-            "length": 98,
-            "item_types": []
-          },
           "10791800398362570014": {
             "error_kind": "string",
             "string": "extend_from_bounded_vec out of bounds"
@@ -298,6 +298,11 @@
             "error_kind": "string",
             "string": "push out of bounds"
           },
+          "13060541637244024094": {
+            "error_kind": "fmtstring",
+            "length": 98,
+            "item_types": []
+          },
           "13450089406971132036": {
             "error_kind": "fmtstring",
             "length": 144,
@@ -309,11 +314,6 @@
               }
             ]
           },
-          "13921208329385594075": {
-            "error_kind": "fmtstring",
-            "length": 40,
-            "item_types": []
-          },
           "14990209321349310352": {
             "error_kind": "string",
             "string": "attempt to add with overflow"
@@ -359,8 +359,8 @@
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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"
+      "bytecode": "H4sIAAAAAAAA/+29CZxdR3UmXre71eqnXl5rly3Jbsm7bIMXbIzN4hVjS7JkybJk2cZuY2HJki1Zi+WNQMKWMEAAJ0yAmckOTAIhCWSGkAyTkIH8gPALE09CwpABkvAHwhIymMDwJ8NQ9jvqr7/+br26950nPeyu3096t2+d+s6pU6dO7XWL8GRotn737d/7kh0HDtx2z4/+m7xrx5YfvSpaUQOt37mt3/h+fpgejHYiZIWiAu30RBV4FKH7PPpC93n0h+7zGAjd5zEndJ/HYOg+j7mh+zyGQvd5NEL3ecwL3ecxHLrPYyR0n8do6D6PsdB9Hs3QfR7joTqPOnzmh6PDZ0E+7RPYl4p3VfgtDN0vo0Wh+zwWh+7zWBK6z2Np6D6PZaH7PI4L3edxfOg+j+Wh+zxWhO7zWBm6z+OE0H0eJ4bu85gI3eexKnSfx+rQfR4nhe7zODl0n8cpofs8Tg3d53Fa6D6P00P3eZwRus9jTeg+jzND93mcFbrP4+zQfR7PCN3n8czQfR7nhO7zODd0n8d5ofs8zg/d5/Gs0H0eF4Tu87gwdJ/Hs0P3eVwUus/jOaH7PC4O3edxSeg+j+eG7vN4Xug+j+eH7vN4Qeg+j0tD93lcFrrP4/LQfR5XhO7zuDJ0n8dVofs8Xhi6z+Pq0H0eLwrd53FN6D6Pa0P3eawN3eexLnSfx/rQfR7Xhe7z2BC6z2Nj6D6P60P3eWwK1XnU4bM5HB0+N4Sjw2dLqMHnRmIYNzTEDQdxQ0BcsI8L6nHBOy5IxwXjuKAbF1zjgmhcsIwLinHBLy7IxcWyuJAVF5fi4k9cnImLJ3FxIy4+xMWBOHkfJ9fj5HecnI6Txza5u+pH/+LkZZxcjJN/cXIuTp7Fya04+RQnh+LkTZxciZMfcXIiTh7EwX0cfMfBcRy8xsFlHPzFwVkcPMXBTRx8xMFB7LzHznXs/MbOaew8xs7dpT/6FztHsfMSOxex8Y+Nc2w8Y+MWG5/YOETnHZ1rdH7ROUXnESt3rHyxckTjjYYVC31LKA9WuCX7bz5x0pOvh1rRfZCswn6QYojYVUv/iseGGLBS+vBE+phmqF76Gy19o176J8w3hpdBepTFcPtbv2+EtG8knkbzaaD5NNGYvPX0HV7WYX7nj4TpeTSMALLNq4e9APNkoZ/eIX4jdFT2RUF4xo/zZ3VjBGiMX0FxA0JOi5sDcab/6PrWAB2X7RDFmSwxvJHi+iHuZ1u/ViYoVwUdvalDe7m0i/Zy2Y+jvQxQnIe9IAbbi2HE8GmKG4S4/05xcyHuL4D3BfC8r/XcoU864sNrtkFPdAmYP2KZvBb66TcG05PpfkjQW1wD4lD3McyD9/0Cay6lM/pntX7HWr9YNpa+KfgPEn8lt7LNQmD1i3dGH/VzNshsmFcA7YQ9PH7gM+/85Bve/9/effBdv/7W+Z8dfdvwWfNe/upX/9Pyb654+7de/auW9kqQpQjZ5T1o6a9SvJ//n/u37/yd7+8dvvqV7zv82b+57tDoismPnPjTv779o28+8au3vcbSvlCl/crr3/Hy5vve8ksTZ37qO4NX/+zXb/v2NXMu+uynHjnuT37qB1/91qOW9mqV9i+2/+BvP9B89KEH3vD7D190+sLJ9zz6mX/+xz/95G81v/3F9973mQss7Ysgz1X2xFr6a+qlP9JPu7Ze+j5LvxbS1+knrquXftzSr4eXE/bwk7/27r+97A2fOufvfzDvdesnX/XA+f/msa3feGjZu0750t3vXfGe+Zb2OpX27w5e8eaDS++58BtDf/6Gc395+crPP/6uD3z5Xx7ccdHXv/yV/7Tq25Z2g0i77LzTnrPvFz696HOnr/6fl/7Re57xc8c9fvJzP/fBF/3yt77/8e+FqTLbWC/PR3R+fb30A5Z+U730/ZZ+M7ycSKc50hRb2hvy01qYY2m36LTFK1cf+LeNNxTrP/JTZ39gZN5HvnrZL15+xac++arXndh8zy9a2htF2jXPbXzr11/3E68OX3jX1974L2v+8NKz559w2fxn/I93/NXye/fffNy3LO1WyEwFfa2w9NsgPcmeDJb+pnr8j6TfDu8mQl6wtDcD7wrpj9TvW6rzPpL21uppj9SRFxtYqKSzYUt/W730I5b+9nrpRy39JKSv0BZOWPo76qU/x9K/pF76cy39nZC+yvjA0u+ox/8yS//SeulfaOnvqpf+Bku/s176SUu/q176l1j6u+ulv9PS766Xfoel31Mv/Ust/T310t9l6e+tl36npd9bL/0uS7+vXvo9lv6+eunvsfT766W/19IfqJd+r6U/WC/9Pkt/qF76/Zb+/nrpD1j6w/XSH7T0D9RLf8jSP1gv/f2W/qF66R+09A/XS/+wpX+kXvqXxbFkHBM/vvLJF3Hqf1kr8tDBXXt2HXzw6h0Htzz5dMXeew/ueOAgzmlEXjy31KC/59Hfw/Q3z7fYezVvkxNsPmMU0lfQyUabgxkjeRC7SXJOhKywsiC8EPScGc41oCwV+R2ZM2sSP84fzpnFuHEhS1PEsY7HBZ9xwacp4nY7Yh1yxNrjiHXAEcszj/c5Yu11xNrviHWPI9akI5an7j3r0P09irXTEcvTJjx172lfdztiedZtT5vY5Yjl6aMfdMTq1fbR+r7Wd8C+RlHya3z4nfFpEFbdfo/KV1PwS9GPJejnZ+IPw/tWv/rKHXccumvd3rsCBe7qXlki4gqiuykhGuMW9I/fr6B3/YIWQ8zektZzK3sv3HHwJTtvmLzrrh13/iiTBzgFI11R8p47pEhjnfH5JOlEyAp9OUaJ+A2Spa5RKqNRlS1qdUHruaXVdXsn77xict+BQ3t24FYENFPmUhAqvlNlWoBk+G4e0V1Bf68V6YLAxm00C+n9RMgKi8wqFolIi1sM2GMUtwTisDQ59Av5TeY4bP7+yilcpmN5sDwWU9wCiFsCvLlc1bVMJn+foF9AWPNFOtN9O379Ih0PS1ND55zaZvmIoSl4GO8ueoVFve4VLH8L6vFbWFB65IeYJo/peqGIMyyrh4MlWJZ2gOg/1/ptEl0M24nHQiEvvsOtEp8h2VG3bCed6BHxTC58h/iN0JFdFqlyw/yxndT0sQty9I7ysE9m3aLfGyzBsrQDRP/V1m8zzPT7bCeLhLz4Du3kH0h21C3bSU09Zm+TM/xG6Mgui1S5Yf7YThbV43dpjt5RHtU+o26xDRwswbK0A0T/L63fJtHFwHayWMiL79BO/rn1PFQi70TICodVv4XtDPVSZftDrp0ZfiN0VO5FSo+qvqm+l6VtijieWl4i+CwRfJoi7pAj1gFHrF2OWLsdse7vUay9jlj7HbHuccSadMTa54jlafe9qK9UO1QVKwZPWz3siHWvI5anrXrmcacjVq/W7Ycdse5wxLKtCNzPM/wYhsLMuld1bIJ4Jie+Q/wGyVKRX5HSi+ozWv6W1uM3v6D0yA8xTR7T9TIRZ1jHtf4eLMGytANE/4KWQptEFwP3qZcJefEd9qkvbuGOCXl5fqGqPWJ61hGmY3vspLwQz+TEd4jfCB3Zf5GyD6UXy9+yevzGc8oX5TFdHyfiDOv41t+DJViWdoDoN5A9HgcysT0eJ+TFd2iP1xbTZUfdsp3U1ONVuXZi+I3QkV0WqXLD/LGdHFeP35U5ekd5TNfHizjDWt76e7AEy9IOEP0tZCfHg0xsJ8cLefEd2snWFu5QibwTIS9wHTEMxEa95JdD8c+5dmb4jdBRuRcpPar6ZvlbXotf8S22DeSHmCaP6XqFiDOs1lLONDtDLEs7QPR3k50hD7aNFUJefId2toP8EeqW7aSeHsPluXZi+I3QiV1O2YkqN1XfLH8r6vG7LEfvKI/peqWIM6wTWn8PlmBZ2gGiP0x2shJkYn+0UsiL79BO9rdwx4S8PP+eqi+I2xTpjU7ZXAW/d5sq0wrp77P0K+ulf8DK+AR4yfXpRHhfwd7Oza1Pht8gWerWpxOJH+eP52AnhCzNMFOPqWM5/eJdXwLrXkes3Y5Yk45Yuxyx9jli7XTE2uuIdZ8jlqdN3O2E1c5PVpXrfke5VjhhxXDIEeuwI9akI9bDjlievtCzPu53xPIsx0ccsTxtwlP3XnU7Bs88etrEAUesXvUTnnI9HfpMs23asdO9Z33c44jllcf4vNIJy1OuGLz6E9555PU7HFsWrd8hIUOFcevzC8IzOfEd4jdIlor8ipReMH88Tl4lZGlSXAw8Tl4l+KwSfBTWvY5Yux2xJh2xPPO41xFrvyPWYUcsT90/7Ig1W47VsB5xxJp0xLrbEeuAI5an/7rfEctT95626qn7XvVfnrbqaV/3OWJ5lqOnfXnWIU/7OuSItdMRyzOPvdqX88yjZ3+iV8vRU/defbn4vNIJK4Ze7ed49jFn+xNPjTrk6Sc85fKyr/i8wgkrhgccsTx179kHsLaW940ZfgxqH0qFOalVBeGZnPgO8RthZlnWmQNTe4vUHrQO5/gmCkqP/BDT5FFzbtwmrW79PViCZWkHiP7eVqZU3eA9erl2E/de7Wr9MSbk5TqXu6dL7SNkHWE6tscJeF+hvPpz7XGi9dwIHdl/kbIPpZcqc7KePg+xxsJMHXe65rRC5GdEpONyRvkq6D37rILhN0JHdlWk9D8B79jvrK7Hb5x9BfJDTJPHdH2SiDOsk1t/D5ZgWdoBon8d+R3kwX7H4lBefId+59Xkd1SdqGv3mN7onmp8RkQ6rl817W9Obv0y/EboqD4XKXtXelH2bmmVnU7AcxU7/XHEMvtbneCT8iuKD6ZfPcunIz4jIh3XWyzX/HpUfCG33hp+I3TkJ4qU3Sq9WP5OrsWv+HxB6ZEfYpo8putTRJxhndr6e7AEy9IOEP3vU7uIPLhdtDiUF99hu/iBvumyo27ZTurpMTRz7cTwG6ETu5yyE1Vuyr9Z/k6px28sR+8oj+n6VBFnWKe1/h4swbK0A0T/MbKTU0EmPjNzqpAX36Gd/HHrj6ESeSdCVrhO6bpC+i8OhZm6q5D+lyz9afXSn2HpT6+X/oOW/ox66a+y9Gvqpf9Plv7Meul/0tKfVS/9Nkt/dr30t1r6Z9RLf7qlf2a99Odb+nPqpf+KpT+3XvoXWfrz6qX/fUt/fr30b7b0z6qX/gpLf0G99N+x9BfWS/+opX92vfTfsvQX1UtfWPqLIX2VOUJL/9x66ftN3kvwpZDJ8K2teg7QFyW/hsVxxqtBWHXbdSU7ysf94kuAH+axDOuSilhDIq5OmVwcyvOF+CMJWVjOGO4Auk7yHMPdTljx+WQnrBgOOcp1ihNWDC9xlOtUR6zTHLFOd8QadcQ6wxFrjSPWmT2KdZYj1tmOWM9wxHqmI9Y5jljnOmHF8JCjXOc5YcVw0FGu8x2xnuWI5dV2xOcLHLEudMR6tiPWsh7Fsv59h/MV13Q4X3Fxh/MV6zucr9jc4XzD1R3ON1zZ4XzBOusrPwNeFq1fNRdQod9+XUF4Iejxj+E3SJaK/I6Mf55J/Dh/vG51jpClKeLYxs8RfM4RfJoibr8j1oOOWDsdsfY5Yu11xLrbEWvSEes+R6zdjlj39yiWp63e44jlpXvVLvaKrXrWx8OOWL1aHx9wxPKsQ72q+3sdsTz9hGdb6+mjPXXvqa9eta99jlie5eip+6eDn3jYCSs+n+aIdYYj1uk9iBXDDke51jhieep+eY/KdZYj1qgTVgyeNnGyI9aZjlie5egpl6et9qIvjOEuRyxPW/UqR0+5YuhVfXna6tmOWJ5128t/xfCII9akI9YeR6y9jlieffJ9jliec4/Wv7d57LMgrmj9djiHP1YQnsmJ7xC/QbJU5Jecw8f88d7kc+rxG80pB5THdH2uiDMsWxMeLMGytANE/9mWYptEFwPvTT5XyIvvcG/yX/ZPlx11y3ZSU4/Z3wo1/EboyC6LVLlh/nit51whS1PEcZ84V9+q7A45Yh1wxNrliLXbEev+HsXa64i13xHrHkesSUesg45YnnXIsxwfdMTa6Yh12BHLs2572pdnHfL0q08H3d/niOXpo80X2vlR7M80iU/VvjemN7oOz7ts6vC8y40dnnfZYP2i8+Fl0fpVZ1Eq9NF+siC8EHSf0PAbJEtFfkf6hBcQP84f9wkvFLI0RRzv/7lQ8LlQ8GmKuP2OWA86Yu10xNrniLXXEetuR6xJR6yDjliHHLE8dd+rtnrYEWu3I5anfXn6nAOOWE8H3d/niOWZx/t7FMuzbt/jiOWl+/h8qhNWDJ622qt9AE8sT33Nttuz7fZsuz3bbrfDmm23f/zb7Rg89dWrtvqAI5anvjx9jqfu73XE8qxDnu12r/roXu1PeObRs+/rWY6eun86+ImHnbDi86gj1jmOWF7z5PH5XCesGHY4Yt3lhBWfz3DEWu6IdbIj1nlOWDE8HXR/miPW6Y5YaxyxPPX1LEcsL1v1rEMx9Krd92oen+q+0Fuu2bbjx7/tiOGljnJ59uU89XW2I9aZjlieba1nffTUV6+2HY84Yk06Yu1xxNrriOU5D+A5P+G5P+f+1q/t9cK9YUXrV92ZHPlMhKxwVkF4Jie+Q/wGyVKRX5HSC+bP9GJ5f7aQpSni2B8+W/B5tuDTFHF7HbHud8Ta5Yh1wBHrQUes3Y5Yh3pUrrsdsSYdsR52xLrDEesRRyxPfe13xPKsj4cdsTzt3tMXepbjHkcsT5/jaRP3OWJ56n5nj8rF+6N6xSY8+yae7bZnOR52xPL0X5725Vkfe9VHe2J52tc9jlj8jWwc3xStX/V9mgpjp5MLwjM58R3iN0iWivyKlF7UGNbyfpGQpSnieA34IsHnIsGnKeIOOWIdcMTa5Yi12xHr/h7F2uuItd8R6x5HrElHrIOOWDsdsTzr42FHLE/78tTXPkcsT/vyrEOeftXTJjz9aq/Wbc/66FmHHnTE8qyPTwf7us8Ry7MPwPcgYH+5SXyq9tkxvdGNiHRF61d9E7JCH/rNBeGZnPgO8RthZp7r9NmV/pVeLO8XC1maIo7X1NV3DS8WfJoibr8j1oOOWDsdsfY5Yu11xLrbEWvSEeugI9YhRyxP3feqrR52xNrtiOVpX54+54Aj1tNB9/c5Ynnm8f4exfKs2/c4YnnpPj6f6oQVg6et9mofwBPLU1+e7ban7j37AJ4+2rM/0au26mlfs+32U6Nuz/bJZ+2L42b7hcfOvnqxXxiDp7561VYfcMTy1Jenz/HU/b2OWJ51yLPt6FUf3attmmcePfu+nuXoqfung5942AkrPo86YcWww1Guc5ywYrjLUS7P9SFPfZ3tiLXcEetkR6zznLBi8LSJMxyxPHXvVbc966NnHYrP5zphxeBVH2N4OtjXaY5YpztirXHE8tTXsxyxvHyhp4+OoVftvlfz+FRva73lmu2b/Pi3HTG81FEuz/6Ep748++RnOmJ5trWe9dFTX73adjziiDXpiLXHEWuvI5bnPJPn/Jfn/kK+BwX3that36Ew0y4jn4mQFUYKwjM58R3iN0iWivyKlF7UPmnL3yX1+A0XlB75IabJY7p+rogzrOe1/h4swbK0A0T//w8++dskuhi2E4/nCnnxneknfiv4Xwany466ZTupqceVuXZi+I3QkV0WqXJT9UeVm6VtijieA8nVtyq7Q45YBxyxdjli7XbEur9HsfY6Yu13xLrHEWvSEeugI5ZnHfIsxwcdsXY6Yh12xPKs25725SmXZzl6yuXpJzxtwrMc73PE8vT3fN4O+0ZN4pPqPyo+mN7oRkS6ovU7FGb2USr0l15dEJ7Jie8QvxFm5rlO/0zpX+nF8v48IUtTxPHczfMEn+cJPk0Rt98R60FHrJ2OWPscsfY6Yt3tiDXpiHXQEeuQI5an7nvVVg87Yu12xPK0L0+5PMvRUy5Pv+ppE57leJ8jlqfu7+9RLE8/cY8jlpfu4/OpTlgxeNpqr/YnPLE89TXbB5jtA8z2AWb7AO2wZvsAs32AbuqrV231AUcsT331qp+41xHLsw71atvhqfte7Zt45tGzH+1Zjp66fzr4iYedsOLzqCPWOY5YXvP38flcJ6wYdjhi3eWEFZ/PcMRa3qNyeZWjt1wnO2HF4GkTnuV4miPW6Y5YaxyxPPX1LEes8xyxetVWZ+vjscljr9rXbDs0a/dKrpc6yuXZx/Qsx7Mdsc50xPJstz3rtqe+erU+PuKINemItccRa68jluf8hOe8ied+Jj7fMwpxRevX9gVifYt8JkJWGCgIz+TEd4jfIFkq8juyL3A58eP8mV4s7ycLWZoUFwOfkzlZ8DlZ8DlaWKq84r+JkBW2DAXteyby0u82fZ4CL9mWcP9ChbJdlmtLht8gWera0qnEj/PHtnSakKUp4riMThN8ThN8miJuvxOWKvtekCuGA05Y8XmhE5Z3Hicdse5zxLrfEeseRyxPfR12xHrIEeugI9ZuRyxP3e91xLrbEcszjw87Yt3hiGVjA2u/sO/EbTe2DRXa0tHcttvwG2FmG1mn7VZ9Ksyf6aXDvslIqq+AmCaP6itwu2vj5cESLEs7QPQ/P/Tkrypr7nPm2k085/2mFu6YkPcswq3al8X0Rjck0k3Yw+MHPvPOT77h/f/t3Qff9etvnf/Z0bcNnzXv5a9+9T8t/+aKt3/r1b/WYXlutfSn1Uu/0NKfXi/9Akt/Rr308y39mnrpr7T0Z9dLf5mlP6dW+uJI2Z8Lbyey0k7l/bxavMOJnZ2FK75l6XEupy87fRiy9M+vl/5CS/+CeumfbekvhfQV9Ddh6S+rl/5I/i+vlb74vKW/AoVq/Z78Vx+a+93f+NmB3/3rb+09/J01j37i6jd8+Def+5ZPnf38V2z++7d+c72lvVKkbcP3iM1edeRNpXyPWfoXVuYdLrG0V6u0z//P/dt3/s739w5f/cr3Hf7s31x3aHTF5EdO/Olf3/7RN5/41dtea2lfpNL+xfYf/O0Hmo8+9MAbfv/hi05fOPmeRz/zz//4p5/8rea3v/je+z5zYWwXfpvahdafTzyPwXP812j9HdNZ+38T0FjaAaJ/ZPFUug+0iEYojWGEMNV2NOB9hbI4Lre/YviNMDPvdforDeLH+eO5hmEhS5PiYuC+57DgMyz4KKxHHLEmHbEOOmLtdsTa74h1tyPWXkcszzze44jVq/a10xHrkCPWYUcsT/vy1Nc+RyxP+/KsQwccsTxtYrcjFq9fYRz3A0bgfYV2uS+3H2D4jTCzXa7TDxghfmV6ie8WtJ4PHdy1Z9fBB9ftnbzzisl9Bw7t2dGH0GF6b4i1gqj4rgjTc49x/fRuHtFdRX+vFemCwI7xVnLj9H4iZIVrzCquEZEWdy1gNyhuLcRhaXLoF/KbzHN/9O/7K6dwmY7lwfK4luKwJ4165HJVfEz+PkE/RlgjIp3pvh2/p3NNVOVkaZsijutibs+/jodotp5bHuLKHXccumvd3rsChQH6+8oSEZcR3doS0QqBW9A/fr+M3vWHtAtKDQJzTCYGbmQQ6ybiM9vIPJUaGeM7BnFKE4ZpUxyYp7GSdFyp+V2foB8hrBGRjp2xSo8YmI4tZijMzOuEPfzkr737by97w6fO+fsfzHvd+slXPXD+v3ls6zceWvauU75093tXvGdBnIpZ1ijXC06FoJ7mtMnfANFfBlM/K1pEUd6lrfiWRV5+aM/uTTsO7t+14/4dP/JtBwKFdma0nv6+TqRTYSTMLGp2DDUrarZjMPxG0KYyEbLCEcegeuWYv3qOgQ2Ce1XejuE6+rtO73OM3k+ErFC59zlEcdikYmlyUL1Pk7lq7xPLg3ufWFG594nlOiz4sMNDenZ4ynmywyvjN9tEPxlmx4EQZseBQv5ujwM53Zwws+Zyc2+0V7ciOqyxYT6kYxln2+wnw2ybDWG2zRbyd7vNVp6E11C7OcRH3rxmHMOEPfzdwSvefHDpPRd+Y+jP33DuLy9f+fnH3/WBL//Lgzsu+vqXv/KfVj3eode4sUNvtyV62DtoMIb1gOuxtUxl6/CWdoDoN4xPpXspDMZsP3zLo9w4uWfXnZMHd1x1732Hdhzaced1ew/uOHDZvXdedf+Oew9WHpq9kP6+WqRTwRTB3R18VtNuym02RfqyKbwypRoWb264p/UQK39xwnRMVVnQsNcm8jpMccMkbzs+qYWYIpPPkg75LBF8Uh39ug5Byawcj5VnLOOHGlNpsPLiDAemXdf6HSD650GlehlVYuU4i6CdDdpYDGXzsrahlGn6SuT7KbDPAbLPPsoz5lPJPAI8mG8M20pkeC11C2s28rJbaFhjJE98Pi5Mlx9lVTpnu8L0vFRQ1nnCX+PD75iPkpk7Ah58EMvqQk6Do2ZYxxJ81CayEcBjGaL9/XxD88T6qPwWzzjOgfr4C1Qf0Z5NZmU3IxRXNpxinfaLdylfNVKCldsGGf0vJdqgdpMQ3Ab1Zcg3EGbWqfi8DPJchhXEOzWk5eHdGNGOJGhZbrRt25R8tKcmePi6Fug3AB2HdlMTc0+YwmU6lgf1cG0JpqrztxCt+eE+gTtOtFiPMW0M20tk4DKO4YbWL9f3/9qYwv89amewvehm2aLuOKjyM7li+V3QYfkpv7qN4pQ/jvr6+DHSF09ZYjgW+rqZ4trpy+JsKkYNtHkztPH7JtjrnxFeAbzY/vnwz0LA5/QxcF/M6D8NbcUrWroco/Tx90TCRWw1luF2jtOHRD4XQNw4yW20XyNbxUPAFWz1MivjRSQTYi+uiY36s6CmDw1/RPAzuRoibiBDlnu/O3n+5OBDHy8ovcnC73hryhJBf6KgN10thfQVdPU8nIgKxFuNMxZT3ByIMxmiTa8h+ZbUlC9Hf4jfFPS3Al2VsmgKPkOOWCM1seaH6TaK9ZB9bgzcDqm2P5bjSGvSSPmhE0jWQsia8kOcPoi/lR9Sfd0YGi1ZO+w/Pst0spBkQuxFNbFz/ZDhj4Tycm2IuBw/tPMHl+37yKbHVhZhpr/tF+/YDymbPEHQd1jPz1F+iH0N+qFFFId+yGRQfqhmm3JOjv4Qvyno2Q/llkVT8BlyxBqpiWV+CPsAVg+VH+L+3XyRH/RDPMZYOG+KZmzedCysY2X97hi2U9xIIm5cYEbeq2FyHf1V6xve08aRPEZbKNIFyIO9Q1vHNDz3YPTLQTfLSD6s05hPlE/11XFecuW8crr5CTosl1T/nrcMqN2BueXCbcUp1FbUXCaW856GFedyzO+0FnCu3nFw887J/Tvu3LzjJft3HOQVmoL+Lptp4ZFYILoYeHfwXPqbl/14NnNc4LTjqWbXV8Az81Wz+eyVVgiZjyWflR3yWSn4dHspdiXxUTPXHfaaVuXIifiNMLNW19mgMU78OH/cG6k5kzJRUHrkh5jc2qkRtGGZFx8swULPj/QvaHmvpuCxjHgsEPLiO/ToF5OnxpUUXBG4bN50HmpFANNupHwY/U81p9JdSSMNbKFS9XEiTJelan2cmOXTVT6rOuSzSvDptr9cRXxSG9pq+q/5uf6St752uqFNrTqpnRkdrgiPs29AfuowF/fkWLfoGwdLsHiG0ujvJH+JPNhfqvYE36G/vI18llr5Suk9tRqpNoG2W6ndNU/zVCu1MbBfNvoLwC/vyfDLqTyqnRPKT5StDJZhbSQsNTo4Wivoik9OflJ8jmV+UnUBy2BTQi7u68xvg3U9YWH6+RTXl5C56k4SNbpVfMY75DOeyedo5We4Qz65OzYaHfJpCD7d3unDMw9l/vYt5G95pyKnXdf65Z2KJ4G//Xnyt1Xz3+E4J7tfYviNMFN/dfol7fwD90sW1ON3pF+SGhehPLwawLqN/2wmdLAEC1eEkf5XqV+CPLhfslDIi++wX/IfaByHuu20nmDej0Z9jIFPi5fVx9+k+rgA4nLqo9EPQ338rUR9nE8yo24aifysC9PlVD5R9clTdWU8Qa9sXfUJurjyle1XeJW95m6CI35FrVapejMMvFuztZftOHDueRdd+aOp2gf3HSxbBeNdVYsIl23O/uZ0UTbeMdIneMTA9jOf6LjceS63ikztaNvFqz7BwpJ8hpDXJ1CrH4xVtlPTymeA6P+oVc/VTk11mgFtKLVTs0HpGiWy94s8zCtJd1nQ8mGe1ybybPR/msjzWJs88/grdeix7IKWfpGHoTDTBhBD6Xh1mC57VXvC9Eerj7ma+JS1aY9lzLWiPJe3nnmu9XtjU+n+ito01Zfvdv7LTl1gvi4HGh5H4FEqxoyBd9kZ/ed9donIlT+e+y+E/DF/X6QyVXlPlanR/yOU6T9klGmqfqjTQilfMJKgV/MGao431T/trJ9ffCHHRhG/QbJUtIcj/Q3VT8f81e1vGO7nIUMof7v+BqdL9TeYtqzucR9gnN63628omcpoO+lvzC/JZwh57YMa85h98rHaiZAVJrjd6w967Fh2VLwv6L4B06s+BuKzH8bd0Uo3N0E80n8P+hKvpN3LKMNJJfKFkFcWmP5otVUnEZ9urDvFwCe/sFyfA88YZ3z4HfPB9I0En/kd8lFj4Fxbv7T13K5PNG94Om679rPsUoy3Q/s52nqZmnerujbN+a+69pmq17n1VPUHnkFYVU8PY/qyftyAkD0G7pcZ/Vmthw7XVTeqXYZmCx32+Tbm1HHEV2uaJldDxOXs3v1q47mf+Nr73/Hn3O6ZLPwuZ+7oGYK+w3nW9Wr3Ls6pxoA2Mk5xuHvXZFC7d2v219bn6A/xm4L+FqCrUhYKa21NLNtxq9Yej5VPyj0la/Tntep+7k0N2P6k1pSHKd2wkD2EmT4nhomgww8pGJ7pf67gxScWjPY5kO/XnDBd1hEhq/mI/gSPIN4VoVw3zKNPpL0iTJdtLEM2tX6NGGVr/wNBryeXjUGUXJaPGJTdptbTz+qQz1mCT6pN4l/jw+9S67xnER9Mh/2mtdRv4utqOO3trV++ruanod90HfWbMD+8lq3m/rDPwj7Q0uferGH0m6Fe5dyscTtg5swzocxl80zbqD/TjXkmztNAmOlbY3hR0Hkqmy9mHbS71ojp1XoT2hX77NSeV8vb46NTMtxGdtwu/9eUYH59ZArzjoqY15ZgHhiewtyRqBunhOn8uP7zO67/nD4GVf/teYjkrGiH2RfwGX4jzMxznfk0NT+g9DICPFiWpojjtlHxOUXwKQirnVzDwe2ieINcSnRrS0QrBG4RtMnZ30vpncoaYkczn2z5EzNzdJUXEz7K0i/ecZFheqNTfJod8mkKPimsiwWW0c8R9E1B72gaFr+C6G5KiMa47UxjBb0rMw0L/cQzPpddeYoqRxnHBEaRyFO/eMdFXQheis8lHfK5RPDhXsLbqJeA/Ct4y9ea9xuEl+z5a85Uvxb1ZUF5/rLd+ShXQ8TlzHqs+fDLfuWSk3ZuKCi9ycLvuEqqUeQlgr7D2adXqVkPvF8vBjUzpmY97J2a9ah5IearcvSH+GqWmmc9qs4gYNzamlg26zEI6VN1+Wj5jG7wSWGpmRCjN90MBr1SxD7J6H8VRk8/Q7MSSt9BvOsLM/3R5tbvmMAaLZFd8Tb8GJoivdF10SfOwXJCOfEd4jfCzDzX6Q2r+qH0YnlXM17qo298h1HVFYFex0LbHAkz7bco+TU+/I75YF0dJT7dOqWWY+d1+SBWzrea6vJRO3Y6bIMr33nGdoF+lPs06yCO9b8e4vhO3esg7oXwzKGf/kY9RH/8+ow71tSJKG6Xqp5GK4Q87U4Jf3pY81SnhLFt4tNo/wNmaR4bLs8jr0SOAh7LHgPP3Bn9X1OfHGcxK9hh8k7cp5KN17HjP6lpx9z3GhX5ULP6lg/lr0coDn3sKMVh+z1GcejLbgY69qf9hB0Dz4jOEbKrfhPX66r9JkxvdB32jSrbZkFxeP8q2ikHZWMm8xMffKhwHyXqlGVDHeX0u02GslUL9nNG/38SqxZqZfU24ovPyCMQRgzs+4z+/5LvqznOlL6P28TUqfqafGc/EzPNGjiun97xFyGupr/XinRBYPeHqZIbpfcTISsc08/EmMyzn4mZ6fVVuvj3i0QazxEP69EDa1RgddjLW5jrcXjfV816csTjqH0JmD/Oe1PIohY/5sEzxiEftZiRs5BSFyuG7bNYs1izWLNYxwArZ2SI7RSfjUQ/yKO3qgvVmN7oRkQ6bt9qtjdjue2b4TfCzDzXad9GiV+ZXjpsv0dT7Sli8qxuU8QZlu2XKrunytLyvrpNLSPytOs4YrTN2Kl+UE45I65aeUlt0Oim3ZfNQG4f0TzL7im0EfUA0X8UZiBvHdEyGw8Las8X2pBhcFo812FxVeprHMOcc+IUH9Sd5QF5KrtH+ttbv2rf6QDFpVbhyspoJ5VRAXGqjG5v/fKNvr8FZbS79azKIGffVyH4sQ0NCnrEYxva12KMq6pKvqESfmWz5qeX8DsI/K4Ee7B8huBqdwuV3WF9ZrtTM5Wq/qfaA/QJKb/EvAuBldqHbOkHgy4Dwxsg+peLMme7KzuzxuVq9D+VWa6my26UK+oqZ5eCOs+ZsgO1o0K1A2zH/QILy5rLtV1dNjyuW29IlKvyXygnl6vRvymzXLHfYzgo70TICrJcUVdcBqq9RvqcTZAsawxqRWYuxbFPxGflv9EOcspc6ZfL/N+JMue+v/ILufuX4/yanfFvzQxvPrh3/47W1HCgkJrKLUL59X4LRPpAaQt6t4DilPtMLYgY77KNSOw+jf5XhcpT7jeGnC3wWNzdWFywd15b4Nu5NZ7qS1UzdYzlGJpqDFeXiFGI9IGwCvEuBrUtHYuBe4HKuykTs2frXZT1CAyP9xa8P9FypHo4QciTmgFGeVIns1Lr6MwHWzQ0I27RjP5DmS2a8e5Gi4Y64hZNjaDVyT6jVydy1Wx3k+hR96pF41NyheCjeqfcG8O0amTVbqTHOCn9KPtSxzHUXozUKBj3x4TgOwrG/LAtpMo2BtZN6gZG1E2T6JWdYN1rEp+UX4ohZQs4ctxOI2KescJn5YfUypLaQ4J7rtDP/g34grLvIOeO+I3+c8K/pPJQiDzU9aXqdPPRXgE/2vsWMc8cuI1GPeTuW2R7MNwqNo+29GnaK4h+5kLiqbpY+I5tHtMbneLT7JBPU/BJYV0osFK+RPk4x2NpJuJJRHdTQjTGLegfvz+J3qnqjkEVU1Eidwh5xVQQf4WFW7c2Ag1fxoRN3rMJq+qkOabnLqnJMr9VT4cE/wru69HUtnrDrnn84VHUrwU18irbEo9yqaMYOUfQPvTu60cf+8hFR45Q5W61NHp1dOPZgr7DrcFvUt0qPmamFmbQdQaSQR1Bq7k99E05+kP8pqDnI2hVt71i3MaaWHYEDfXFC2Dd9jG8gLikVZexm3W0ZbHu0HIhS8qPYd3mBXQ1sa38Jeerqr8sMvlc1CGfiwSf1CJ+jv9TfJTM7RbkTh+dSoP2XdY9f3Hrlxc/vggXdpzZelYX6JWdti+Cnl3k+sqLM0zTKJHvHLBP3m7NecZ8KpkHgUcgjBh4u7XRX0Btb02fKrdb8xCgC8cgs2dEj9UxyGrbrXlSALWCqPiuCNNzj3HtJj6vor/rbLeu2Ut4kVnFi0QkD0RRN2ogiqXJQQ0MsVdRZbs1lsc1FIfrCdcCby7XIcHH5O8T9Hx9vzqAabpvx0/1cvjCB5Uu/n21SJPqcefUzBh47aDhiKW2bnc4SZL9GRHejlazniS3o6kDkzzxjGnVFhrulVW9bg6x5jtiDTthxbB9FmsWaxar57DU1gs+DIvtAX/uEX0Xz3ZUHVFi+tSE6vIO+SwXfEZEurptXzMhs+Un9WmOqhdcYHqevEf5cIT3ylHNU21Fi4FHeEb/FzDCe83odJnVCC8GNZrGcghBj/Y7XBAcVQuCqFfu+6tFCKS3rcKpLUDKFnLL6M1URqntgigP76H5Ayijn6NRONp2zmc6FT+uh7nbYo3+bTAKT22LnVPCr2xWYl0Jv38P/I7Cttj5yu7Qz+Rss1P+LOUv1B6fZpjpe3ibXdlYhMte6Ttnm11qy6zR/0dhD9wWsW2Uyaf05rzNbqhEjHGRPlDagt6Nl2AZTvwbJzlyttmpuyLYRfy2UHmqyGKY3Wb3Y7fN7qoSMQqRPhBWId7FoLbZIS7X2JSKlarqbtD+I2HSKQ+relhGr3oCas1B5X+E4tT8MPNRG8dj4BbN6P80s0Vz6knJFg11xPnKnTkx+nZbcbiqqS1pqZFNbjXkbSbKTlVPrd32lZyDLSxrCHr0MEpxPMsVgrYFe9eNXjXmJ+ewmdpaZvTttiCabtR2Gb7CFPPP299ULyrXFnD09MqStTPERVsoW3tGH4AYt7d+eR3pS8IHGOZQm7zl+Dvs5vAVXNjFYH+n1saVPRpdh/Y4ouwR858zyktdI9yurqYOofEVZJhH7ka2s5vUFjhcuzydRnzI55nEs+o1vs8U8is+zQ75NAWfFNYzBVaqnnd5C5yJuJzobkqIxrgF/eP3y+mdquYYVDENlMgdQl4xKXNWfIoO+RSZfM7vkM/5gs+MLS6thw6X0V+pJqQsnx0u9L4S9WVBjaYMf0Tw49vSMC5n69w3m1s+uufxd/5Gyu2muoTK7Z4v6E1XvGt2ImSFV6ROp6itcyMUh82LyaC2ztVc/HxFjv4QvynoeetcblkorLU1sWzrnLqd+mj5DN46N9Gqy2rrXLdl6fDWwwutzl4oIi2OtxJj3EVAX/XGTZO56o2bqFOWDXVkOk0dMDUZcm/cNPpnQpnzFjD8Xrthpm7cHAYezDeGsu+ePovakJp+Xm4B4+546tuNVb/zi+mNrsM8VLZj3jqJ2yp5kwx+/5i3ieNHhuZRHH7FZT7FPRfieLMYBlVvcBPU1TRtEwSW2uj0bIpD/2G6UFNPF8Azxpms/I7LHtOntsk2OuTTEHzUFBz2m7p4DCF7Zpq/dlPzqz5HZqZTd2Q8IVjrV/XdeNjJfTd7LiufCwSfqnJ14UNXZxJd2cdPCoFb0D9+fya9KxtO2d/K9Muu8Qkhz/TV0OxoVTGeVYgB16ZvHdM8y64owqYR6e8Ym0p3OzzbisK88NTTbY7OYriz9cs62w1dFp7pGwA5FOYmkkFVX9XkG73q3qtr2dTs30gGb9Ql1+fRirK2W0XgS/XVgd5cWTceZVkHhKwdNm0LrM4vEJEWtxCwuZu0COK4m7QY4rhbtgTi+MTCUogrKG4ZxPHUxXEQxz7teIjrpzjcGzYXnjmo7pzpPaZbvWoKl+kC5Un5lNyZXvQh7JPVhQaFwLX38wGrnzDis60eDxD96xP+SH0GOFUPFgp6vHvI5BkjGTDtmEhndURN7xhdNy6cwPzwysMiiOsX9KybxYJ+EdHE0Awz69x8ikP/ZjzVyhZ+9tk+Ha5WfIuSX5OV36WmlLaTPGOOfBBrG/HBIQT2dX6lpF5hPcFh16WtZ55e+jD0b36ddkxg+jFKb3Hvhno2uro8PQ/51erUWJhpB9ynUvlE+qtK8vlbIOd4S84urkA3Vb1D38f1TvkYpOd6l6qnqJNmmFkn+QyFWn1CmyybTi27Rpj71Ub/+1AGvIcO8zdOsg9VlF21J+1WyOfRpRzYxvD5FdWGqbJSl+yMl2D1Bb2T6FKiXwR8VXvI9GYTAyHtnweI/mNQVgtXa8xQIsNwicyDJfQLSQaj/4Swl5QfQPtfQJhG/ykxnZ6LeXkJ5qcTfQ1VT/GSpqrtKfcnUI+LKQ5l53ZxEfBn2iuJP8ahnTPfkJBXTfOk5OX2xuK+DO3V/6QpauxbVPDV/amyeo6QN7eshhP5YyxLNxBm2mOqjqA+/m5MY86piPkl0aarvsrNgP/ljH4++mr2y+gzsB7+CvVJ1K467pN8Q9RH1dbjGNVwLC7ffoovVD3D0U437BPaXepmPly1N8soTs1/ebelX5w3HXcsgRt/zyA52vXxbHmD/fAPEn5Y6TClczVGRL2aPMoPL6A4ZbNH2x4x/2yPqbyGUH08zPao2g9ljznnhHPtcQzy+ljLHtUY3HgqH121z13Qs/n4wRJ69vlGP7+1JqH6PUuEDKm5i6WCfgnRYP6xXeJ5LkuH9RJ1so7yY/RLIT8pf+w05yF3gqPe2P5TOoqBdXqcoEddmU6aRI/6Vb56CcUhX7YzVWdz64aljXr4TfLVjUxc9qtoE7i+wL7a6E8TNpHKW8pXt/NHfJNd7vxcyld301Z7dX5O2aOyL9yi8hayL9X3SZ1CyO37qLaWfTum47WUqmN6TD+e4NPokE9D8FHzSUXJr/Hhd8xHyazqC+dHlc/8zPzwesx8x/womdUcMc6pXtOcSsN+Um0b5PbO6F/SnEq3rvWs5j3ZbnJtl+dE54MOlM/eGKbyH8J0/Rluh35sjvJj6Mdz5juRvmrfi30V+jhe41XrxWh72HYaTQiufn9O1fnhlB+MIadNxDpheVN9dJ47Rntj36t0ibaX6ofg9uRd89rLr+4RybUPXn/Adn4RxanxirIFo+tGHwDzw7aQatNjYN2oMQO282wLOD5YQHFY/tyPUP025S+5jNG/Yrlc2nrmOcADib6jsoOU3bTrH/FYXs3hpcaVR7vv2Ct2w/O+6Huq2g37EPTn2EZb+638XR89q74k0veX4PDHFAp6Pw/eY7rnUZ65j8TYzyd6y+dgCb3hcV/kdYm5hAVtZHgBybCwjQy85mL0bxQypPQfQ6pPOBRm1sUK9WYA2yAL3KdE/EbQ9jERskLB+jN+yg5iUHuXuD5hHLfJygeqeq6wCkcs3n5fs7wqf4CCxxVrgX4Txa2DuG2AwaGf/sb8RLtesnoKl+lYViwvvhMUbWyBSLtAYB+r+rCgHr9kfVBjgKr1geeRn+71YQHF9Vp9wPIyuZWOYpgIeSGnvmDZVND/qtz6Yvhe9UXZnqovHa6HT0T/NC/M9FXnwDPqDvksJBk6LT81x3Wsym+8Hr9k+akxvGf5Yd2qUn5q7o/nUarO/WH6ozX3x3uwcSyIc3+fprk/NTbFtDz3Z/RfgLm/x2jur+r8Xhfn6/qP9Roxl1nu/FPOGnHuPnVcI76sZP6pANxLRVqu20i/UMhh9Lw2zDS8N8fovwRjKT4arGwW5bqUMI3+K4n5FDVnkJqnbTdnkJprW0Jxai1K1Qmj67BOrDrW68Zs97huzOu/XL9iWCewUrKOdyArlyOW1XGEhfvQ1Nzspa1n3of2/cx9A6bzbpR/aj5N6TQ1n9ZOpzymyd03wOOVdnPn7BPVuQtsE1VfoGwNCnmm+gLKp/M1NvNaBqr26qLvVusO60owRwEzZ49Y6tatdnvETB7V/i9IpMOyGhK8Juzhh+lgeDguY15lc3aLQU+vOUHLUrA8bUIX5/QmCsILobfm9Docs5yIfXq0I+zTq71lWF5qTIV94BPHp9KU1THsp57XeuY6dsr4VLrVJZghVF8vRHl+vjEd17t/mlqbz9kzlNqDn9su8t4poz8b6mbqLJPPOlPxz8d6nYnbRVxn4n6Osq9UPxzXVVQZ8DkEo78IyiB1lon3Ao5UlH1cyK7mkbFucD1Wa/RDAjdV71Fu26/N9f6yRNva7txv1X1fvJ6fO7bG7xwYdiC6bqzLHs2xNX+hNDW2xjMAPCeDfTTcq/EQ+V6ca071N43e/i4b+3Kds7jNYF8DVOdQ1mspHzjfbTZn7fE6kn0iZIXsK3cMv0GyVOR3pL+xjvhx/vBqm/wvDLInQq0gKr7jGoxx/fSO73y/jv6u84XB6+j9RMgKG8wqNohIi9sI2GMUdz3EVb2UzmSu+oVBLI+NFLce4q4H3lyu6wQfk79P0K8nrHUinem+Hb9+kW6MMFKtz7WCN7c+u8E7PLy6XA/XhnI92N8NISfr2+Jj6NAmt+Z6E8NvhJllX8ebXEf8OH/1vAnv8zIuNxKq0SAthhtBMqTnj51w6Q2LdBxMYwMk86tg7HKo9TwWZuaLz28qa8d3PP+B6Y1O8VnQIZ8Fgo8aB/K9E4sScThntZjiToZ0N1HcqRDH92mcBpg8Xl2TwLxGYMayO2n+FF78twXolKWbDVkZ3ADyYFr8ew7RxmDX2A4Q7b8Fu/oZsiusxWxX69vInbKr9aGcz4IO+SwQfFJ7CCzuOpFX1SJzOW+EOLad60W+LG5TAnOzwIzlc/z86XRc/jGYx78R3lfwwDfmenzDb5AsdT3+jcSP88fzVVvr8dtSUHrkh5gmj+l6m4gzLCu/wRIsvsrW6H+tVd+aRBcDf79ym5AX35l+op384vh02VG3Rcmv4fI7rl+Ydysf44P+Bufv/iON+9FP9YeZfs16nuyrnrF4Kt17yFdhei47VU/q5n+LyONYmKkbnm9X9n1jgs/8RH66VZ48zkY/i+X5QSrPrRDHPjo+n956HiD6pVCef0Dlqeqi0jO3S1X1vFjw6baeuX3Z5sgHsfiTGdsJi/Vs5WR6xvTbKd3NEId0OOpCH3az4K3wDaOdDf7ZuM5bmQ1a2gGi/8GiqXR/XtMGt1EcthXYLqIcqAekPz3ofA2W0Jfl66/EPDC3JagrLAv2v0b/N4l5VGVb2B7wXKGyh+0iX0qnN4f2vFHPa0t4D4a0LQ4Q/RcSc+tbRHpVj44nWW5qIzvXb0zP/UZM16kfUTK3q5NfrVgnz249s+1+Cerk16lOpmwEZeZxRFU9LxB8uq1nHiPc7MgHsbhduJWwWM9WTqZn/CTKrZTuxRCHdNgu3ArvXyx4K/zcduFfx3XeymyQx8VG/wmwQesYqfFqygZvpjjUKbcL7fzh2URvcg+GdHs7QPRzW3lR7YKqr+hruV0w+nmAye2C8cV8pdoFZYu3iHwpnd5KWDcILNQztwtKp5j/Gyj/Rj9f6FS1C5ZezUfcTHE4H7GV4jZAHPdZcYWA5zhwPoLnRvCu87L5CLYRno8YT+QH933wfB/O211HcSdD3AaKOxXiePUB5+2up7g1EMfnTK6BuM2QV5u347u9Tm2973DdTn6OJjUvWpT8hpDXHuDaM99Nvs6RD2JdRXzWO/JZn8jPBsHHygvrSzfWWQ2/EWbW3TrzZBuJH+ev3soIehvWCqLiuyJMzz3GdXOd1fheD3FKEzxzjnm6viQd6iKId32CfiNhbRTpTPb+RHrEwHRsMQW9L1uPNIwBon8BtFY/sXqKvowX6oNbTJO9bMcEy2D0V4AMfFpgI6RR+dpQgnnj/Cl9vHC+xgwCU+XresoXy7CRZDD6a0VPoJ9oWB71Lv6Na73Xl8inyollxVauLD9cTka/MVFO1wkZsE6ubSMD01xfIsMNQgbh3a7Yu+/BlncLFPhbRrxOy5rnddvrBE5ZMG1EKzSLVLsMNoh019HfDSFTzLn1pY58GmrPjoM7SvLOnnteCc++oAP3Ry1dDEOhozYtuw01/EbQljcRskLBXs74cf74fPdGIUtTxJXtJ2vHJ5ap7YVrlenmg3v3lxVpbuNaCLE4fSCsQryLwYoahwIVVH+DWiKywMs0mCc1Fc/dSJymRafGgfON+YnO5ScrHA1HnfIyGOqfh2dYVXhYlzt04+EZDt146hHLi69NxWXmfvGOu9iYfnOCz2kd8jlN8FFL42ybuATYDTdk+I3QUV044obU9ITSi6ofllZNM/BGNGsuvgMdpJfT0B23xbJeax4vvzBXr4bfIFnq6lVt6VZXbampCb4GGrcbvRToOK5fvOtLYB1wxHrAEWu/I9bdjliTjlieefQsR8887nLE8szjfY5YBx2x9jli7XbEOuyItdcRy9MmPOvjpCOWp0146useR6z7HbE8db/HEctT94ccsTz1ddARa6cjlqe+etUXeurL0+d42lev9pk8bcKz3fbSfXxe6IQVg6fde+r+XkcsT7v3zKOnn/DsA3jq62FHrEdav+q49GbiU/XzFZh+PANLzR+k8qjmcYZb/GM4MnV/x6G71u29K1DglYYrS0S8gOjWlohWCNyC/vH7C+hdv6BF7DitdEdryUJN9xqdTSvVPDFyXkF4IehpJcNvkCwV+R2ZVlIntTB/PK2kTkqo3eDPgmeMQz6pHewYd8AR6z5HrIOOWPscsXY7Yh12xNrriOVpE/sdsSYdsTxtwlNf9zhieeprjyOWp74ecMTytNW7HbGeDuV4yBHLU1+e7dBORyxPffVqO+SpL09/72lfnj7Hsz562oRnn8lL9/F5oRNWDJ5276n7ex2xPO3eM4+efqJX+18PO2LxNAmOq3maRI1htyT4YPotGVhqPJzKY5enSUzEc4lubYlohcAt6B+/P5fetZsm4V05O1r7WDvcYScPkPAuLZwOwt1mGBdC3kwdpl+U4LO0Qz7qcu8Rkc7y3aEeR1F/KCe+Q/xGmJnnOtNLapec0kuHu91GijCzqvYLTN55l3IrVn8GS7As7QDRP9Cyfd7FFgNfgJLruuI05IEF02VXuwZzyhlxlUvMsce6fBCLD5mibrkep8pV8cH0N5Rg2RGTGG4DGj6WgOUcBG++CMfoX90qrycOkJ705HPq8qUoz2sXpGXFtCjrANG/Z9FUute1MJWerdyVHdxAcYsEX4XJvrFq2S0VMqSwsLxOJnori8ESesPjsvs5KDs+UGzpy+znhhIZ0H7wSEmZ/fxCDft5+4K0rGw/JxNvo38j2M+/J/tBHafs52SKQ/sxHam2lXdaV21bMX2qDU9d2MZ2VPXCtpMFH2vj+JjTRMgKW9TFTxbU8sxpFIcnCtZQHF5Ecg3F4eF/bhuwPeNDznjIHPXBoZ/+Rh1F27+aPkYSBBYfvkVdpE4pWNnj4WnEwDiTld9x2WP6NSVYeAxQ1eUBov+t1jxArI8fon4AXspoOunQ1s7Pad8Rv0GyVORXsL8yfpw/Xo7cLGRRvuhMeMY45JM6vYFxex2x7nfE2uWIdcAR60FHrN2OWId6VK67HbEmHbEedsS6wxHrEUcsT33td8TyrI88rdkrdu/pCz3LcY8jlmc5evovT30ddMTa6YjlqS/POuTZn/DU1z5HLE/7mvWrx0b38XmhE1YMnnbvqft7HbE87d4zj55+4h5HLE99efZXX+KIxUub6gK7guKQz/UJPqnP0yCfDYCRcwtBzW3N/QXhmTz4DvG9biFQ6yqqfKpua+a1gU62duRcrKLmPlK2ofLouPRsIp5HdBtLROsTuAX94/fn0buypWfDtmqEU08sD6oxpVq1fHRNgs/JHfI5OZPP0g75LM3kc1qHfE7L5LO+Qz7rBR++BzMGXBq5cqHmiUsjOF1rLnKA6F++cCrd1Qun5xGXF/ibpnggZx3JjN/xYdeL94FWcIXZF8AYfiPMtMk6rvdU4sf5Q7eUf5cj1wDUCqLiuyLM9BoFSIbveJF7nNLVucvxNIhTmuC7HDFPp5WkQ10E8a5P0J9KWKeKdCZ7fyI9YmA6tpiC3pfd5WgYA0R/U6tWqbscFS/UBzeqJnvZ/Xwsg9HfCjLwHYGnQhqVL67Np9HfaFu3lPDfD15mcqHmHwR/zh96tbJ7Ek8lGYx+B+iA731cI9KHknfcMqyhuDUJ2rKv9qry53yh1y7LO5e/0e9JlP9SIUPqC6wsA9OMlciwT8jQ2R2R7OW4lLgklgqcsmDaiBZr1sva4drBfOxvZQGd3hG5qIRnX9CB7/G2dDEMhY7ayuy22fAbQVveRMgKBXtP48f542HRqUKWpogrq6Xt+HR4R2RZo62cBacPlLYQ72LAA8CzQ432fJ4OQw3GUkOIGO5s/bJjfzM4dv60xDUgh8LcRDKoWQC1M8no1czV9SKPpktsqDZn8EZdckPY7rOgOZvrcSaKdyGifDdWlHXjUZb1GiHr0d4hxru5cIcY7+bCHWJrKQ53iJ1McbhD7AaKwx1imykOP4/CQ3z8JMqpFIef6sG6woHbAtR7rJerV03hMh0+l/kUrLOsrzUibzhFMQTYyGciZIXTLH1fvfR3WPr+eunPtnxy9zMGw54D7yvY+EtQJxZU18nwGyRLRX5Huk5ziB/nj7tOg0KWJsXFsAPoOK5fvOtLYE06Yh10xNrpiHXIEeuwI9ZeRyxPfe1zxPK0r/2OWAccsTxtYrcTlqX3kut+RyxPm9jliOVpE/c5Ynn6Vc+67WWrMfSqX/W0CU//NemI5WkTnvq6xxHLU193O2J52qqnXJ76ejq025768uyvevpozz7AA45Ynv6rV23C00/0ajvkOYbxzONDjlizfvWp4b+8yrEIM+fcekVfvepzerVfuMcRy7M+era1nuXYi/3VIsycw+4V+/L0q/c6Ynn6iV6dZ/KUy1P3veonPPvkT4dxrWe7/WCPyuU5rvUsR8/66DmG8Zz39cTytAmuQ0Xrb1wn3QbPN0M80tvtQ2odu8La7Z0jkCYABmLXXIe+syC8EKb3NQLhj5Twi6Eh4gYyZPm9S2/d/b8mvnNCQelNFn6XMzZRa9qmq7kk+0TICneMAI9AvC0O1+fnUBzqxWSIv2tIvsGa8uXoD/Gbgp5v9ssti/lhui2gvasTgpspDvcYLSIZ2u1J2kD0tv9nsITe8AaI/udajHGj+BjRxOelJfxQPnyX2lu4tQSr7KazM0pkfzvIznvxtgn51DZWo79J0OO+KZNH6eamoHljfrA8b6P8GP0vifyo+mc2NQQ4Fleh7oxGPucAH9Yb1p92OoqBdbpd0KOuTCdNokf9WhzuD9xGcVh3+FJgtXdwA7zj/V1od3gD39szbmLspXr9u5n1emMJP5QvVa8xfZV6HcOLS2T/YMV6vVHI10v1+sOZ9dpsarZet6/X6jbR3HqNN7Pyra23Qpzh4j7ys1vPA0T/qYTNvjjMlBV1yPq9TdDj3li+/RL31N5GcZiOb+3Fm09vJhluDzP1gHLx/nij/0vQw/jqJ5+VrZtcHdr6ZcrWbwcCtvVJiOsX9FwWdwj6SaAxnTSJnssF/0Ys1CnvuTcdDQp6xBsg+i8I32/yYT29nWS/uaLs64Xs6jZPrFP/2jroYzaIvoHr+M0Jnpw2/rN954Ml9DxmNfp/FPpiX4f1APU0QphG/42EPzC+mK/UhwqU7m8R+VI6vZXiUHazBVU/ja7D+nm5qp+Yf66fqbzGwLpRvhVt18q/GWb6w+0Uh3XjFuKj2rxc+0cb+uq4xi1rb05vPbN9/TBhX6reqD5cyh7RTri9Qfu6heIw3Y0UhzrdRjKodhfpeQxo9HMXt35Dur1xsucFyp7RZtmeU/YZQ9W233TSDDPbA/aHymaxrLm9MR0NBl0GhjdA9AugDLi9wTNLt5Ls2yrKXqe+/Rm1N9i/5/ZmW4Inp0V/Udbe8O3wRr9C6KsgHlgPUE/c3hj9iYDJ/kD171PtTbv+vcmjdLqd4lB2vNXbsBmzw/q5UNVPzD/Xz1ReY2DdKN+KtsvtDfpDHvtg3eCxphqH59o/2tAHqb3hs5GIhXaRskesN8OtZ7bH8xL2mKpnMVQdw5s8qTG8mptJ2aPRdWiPNx7rsTh/CSQ1Fkd75Pa53ce12B7V13ZiXv9jyx5t3h/PglfQ6zXqBv1AMuBlIfMoDm9su4ri1kG6EXjm0E9/Y35iuf8k9UeCwDKeeN/BtRSHdyOwnnGOhK+mwjn39RSHdwrweeFTIW4DxfE1IzFYWdb8gkD2lRqG3yBZKvI7ci603dlfq2vVrrsqux2hIFR8V4SZFlaAZPhuHtGtp7/rXHeFVxApTfB1V5ina0vSoS6CeNcn6K8hrLJbJ/pL+KkSVdcXGYZKh60apsmpAdcS/kTICtl3bRq+Vw1oV+5mq+w1MW1TxM2DZ4xDPmsFH4WVc0FNWa3t4IKaefT3NSVi9In0gdJy1e4rwTIcrjo5t4Kpe5f4VrA9YuCRSh/DiHjHZl/TDLMdv+E3wkyTqGP26rNAmD82+2uELM2QdlFchik+jqYaw/oSMVSLEgirEO8wTpkq9m/WlvAeFPTKVI3+ocScwpBIH/uWyxrTeV8HdP2UVsm6gWRlmiGS1ehfAbIOkKxoqtzPwvUqrlIbSfaJkBWyq5ThN0iWulVqI/Hj/NXrS2FJs1YQFd+lrLhdzbmC/q7Sl7KS20TvJ0JW2Kzu8ragRlVDFFe2i4CDGrWYzNGCv79yCpfpWB71rU6Lw51PW4A3l+tGwcfk7xP0fDf6RpHOdN+OX79IN0QYBb3HmZDrBO8Bov8F8A4Pry7Xw3WhXA/298lCTta3xYfQsU1uy/Umht8IM8u+jjfZRPw4f/W8Ce91MS5bCdVokBbDVpAM6bnLyKV3qkjHwTQ2QDL/TsuKovX9Sut5LMy03vkkN8qQ8stNkZ73xiCfBR3yWSD4mCU3IN02ihsWebU49Fg3URyO8LZT3LUiX2qeiDHXJTDXi7hYdhcumU6H3qgo+Y2hX7wr24uFslrZoQfguzZVbduU4IPpjW5EpOs0P0rmdl/R/cPFU2mwNS3bW2r9zQGi/9uVU+n+K9U33LNkMio9c12squf5gk+39cx16gZHPojF6x1qXyTq2copNY/Pa91Mhz0CnOtWay0K3zDa2eCnF+u8ldlg2dfoPwI2+FhNG+SvNae+1J6a48cy4HwNltCX5euzibHdRpH+aH2pvJs2jzzb2c/fk/3g+omyH/wyMdL/JtjP/0f2o76k7pn/VL3GnhzPLKt6p/wHp8M6enyGDKkv/RwvZBgR6Tq1DSVzO9t4nGyj3dkJ3q965NwH2MZ3yTbQf/IeHpSZ+4BV9bxA8Om2nrl/t82RD2Jx+6bWaVHPVk6mZ0y/ndKpPXzcvuE6r9qzoPBz27ehJTpvZTbIX0Y3+gfBBoeXTM8/pk/ZYGovCu9lUPsOVBkUJPdgCX3Z/p4FrbzU2d/DvtzoFwNmzv4eNVpO2WLV/T0p3qjntSW8B4POf5mtrEjoVJ3LwPywTo3+xIROlY5SOm23L4jHY5hn3nuvziyhnnN0ivm/nvJv9KcKnap+C99/jn0H7kOqfhjSryF6VcdU34Tr2FkJ2VOzkji3cDPF4dwC32mOaxY8FsMloC0Uh3MLPM+B5cjtH+5B2Upxao8hzi0MUF6f03rf4drCtPFoICyl36LkN4S89rQBNLx/pxvzJorP9Y58EOuK1q8as/GZwarzBpg+NTYc7pDPsODDWOaTY0CfxPtYjX4t1OuC/Lz6/sUwvFubyCvX59QXU9H3dWPtzfC9vpiqfG7qi6lbhCxNEVdWpshnkeBTVS7Hr5yaiMuJbm2JaIXALegfv19O7/oFLWIfrap3LPks7pDPYsGn21Odi4lP2XBnBw132k0p81EVo78Lhjs7E8OdsmqHtpbacmH8yrYxjJTIdw+4Xv5u3ojI8xkJmTcDD+Ybw7YSGfZTV6WmK5ZdFZ4KxS5dg+Kw68FH8rGL0y/esc1tEHwYq6yZNL1yl+7Bis2kOhqt8spXGWDTxHqo+iH1DZl8lnTIZ4ngk2r26/oSJTMPJWJAX/Ia8iV4FF11aWwYMED0W8CX/EzCl/Bnv7irwf61rJ0s8yWbSuR7Y8KXqK7huoTMOARkvjFsK5HhUfIlvBQ0EfKC8iW8NIH+77gwXf6qbSGmP1pt4XHEp9vLfmq6n/2LWo7akuCjltTa1cdfXqJ5qvrI7RrSr4T6+GtUHz2W6srqRAh5y12bBZ8yHxRDqg0y+vck2qB2Xf/UUK1MPrxqDumXQZ7LsIJ4Z/TY/vH0xRaivSFBy3KjbZ/bejZfxEvKEyErbOXP/WHgJQ2USR2FxPrCgbcoocyxvOeeMIXLdCwP6mFbCaaq87cQLW7TYlxeLsJ6zPraXiIDl3EIM23PcD+5ZAr/j6mdwenyKpvt1JKUBS4/1h0HVX4mVyy/C2qWH2+BQr/KW7WUP476+stjpC8e82M4Fvri6ed2+rI4y2+fSMebUI3f98Fe/5rwhoEX23/Zcs+ASB9C+ZLY56CteAVdR4bt64nED7FV/5jbuRNL5FL5VEfTWW/fJVvl5daJkBUuszJm34PYN9fELggvBD3tyPaG/EyuhojLuc703u9Onj85+NDHC0pvsvC7nCtIThT0piu84qWCrp6njnobb5wXCWGmzmLA49pHriAJM68zvaWmfDn6Q/ymoOerm3LLoin4bHDEuqEmll2zqpZT2efGwO2QavufOC7U2o+l/NAJJGtVP4Tpq/gh7m8Y7eKWrB32H5+l+oHsh7bXxM71Q7xVWpVrQ8Tl+KGdP7hs30c2PbayCDP9bb94l7OMf4Kg77Cen5O6okj5oe0Uh37IZFB+qGabck6O/hC/KejZD+WWRVPw2eCIdUNNLPNDqg+u/BC3t1tFftAP8RjjxKVTNMcvnY6V0+8OYWZduyERd6PAjLyfAfcmo7+yK7WxbHiMprYV2d/4Dm09Nfdg9KeBbk4m+fjT8erKE9VXx3nJM5aW021N0OX27xsUp7ZN55YLtxXnUltR8/CXnPc0rMjLhhGtJdurdxzcvHNy/447N+94yf4dB3FEpVpBnsnEI4JlwSTh1dr19DcfvOLZzBsFTjueanZ9BTwzX7Xywl5phZD5WPJZ2SGflYKP8kpFya/x4Xepmd6VxAdn5XCm99KlU2nQJnCmF9PapiCe9Xz7iql0VyR6kCk9T4TpslTV88Qsn67yWdUhn1WCT7frwSrKD3r9iTA9P1VXpDD9pqPMp129fvFSzTO3Xhv9eqjXkxn1OpXH1Ka01E6PG9pgbSSs3NWjDRl8UqtHGzL55OQnxedY5sew1KojlsGmhFx8oeiNbbB4Y7Va0VA2yDJXnZ3A9MMJPls65LMlk8/Rys/mDvlszuQz0SGfCcFHjTA6bT+UzO387WvJ36rDrZh2XeuXD4FeAv72deRvcXbrqa7nrY58EItnSMvK861UnuowTao8jf4kKM+3ZZSn0s2NifzgDqGyslaHDQuBldpNwnpAetWmdHFGdX6OHSB+g2SpyO/IhvLUgcEYcOP2otZzaxbgsh0Hzj3voit/NAXw4L6DZbOr48gU5Gf6QH9zuijbANEMCx4xsP1sJToud3vP+DkytaNtF6983U0l+Qwhz9dh+uESrLIdQHzxu9H/Zque5+4AUofYUv0BrndM1y/yMK8k3WVBy4d5XpvIs9H/biLPW9rkmfvvqu/Ivonp+kUehoLerca7FDFudZgue1V7wvRHq+1cTXzK2rQPU5umdvXhrq/LW888Az8ObdofU5um+oLdzn/Zbl7M1+VAUza2GRCYMfDuDaP/hM/qo5xR5hWUhpD/iQ85UJmqvKfK1Oj7oEz/PKNMU/VD7UJP+YJNCXo1VlRzTKl+o5UPrijnl0/xhRwbRfwGyVLRHo70N9QhcvXBmqr9DcP9PGQI5W/X3+B0qf4G05bVPe4D3Ejv2/U3lExltJ30N7aW5DOEvPYB0xud2ecGkn8iZIUJk2UTyGGyqI86sq/oCzProqJXfQzEZz+Mu+6UbvhSA6P/e+hLvDKxK+6kEvlCyCsLTH+02qqTiE835r1jSF109xx4xjjjU+aTmyJ9at57a4d8tgo+ubZ+aeu5XZ/oOxXbT155N/rfXT6V7nvUfqqTp1XXxjj/VddeUvU6t56q/sAzCKvqqTRMX9aPGxCyx1B2WnJp6+hDh6clN6rdK1b/Ouzzbcyp44g/IviZXA0Rl7Mr7KuN537ia+9/x58XlN5k4Xc5c0fPEPSd9b/CerUrDHesxIA2wh8wwl1hJoPaFVazv7Y+R3+I3xT0/GHFqpeGYdzamli2k0uNsY+VTyqbezH/xH2Hla26n3sCWJ3yTJ0YZZ/GeWSfE8NE0OGHFAzP9D9X8Co7eXMy5Ps19A2LsjXCgZL8pE6HFaFcN8xDnQ67IkyXbUuGbGo+CDHK1i0jhlpDZLuteqJyk5BH8TmrQz5nCT6pNol/jQ+/S61HnkV8yvpNFy6bSoP+pGx95PbWL693/RL0m57TwlQn8HnNVd3+oPYXsO7LTmyzPzH650O94hPban74dsAss7PcU0JGfwX1Z7oxz8R5GggzfWsMLwo6T2XzxayDGwX9TQl6td6EdsU+O3URoeXtL4+fkuFasuN2+b+mBPNTx01hrq+IeW0J5ouXTWFuTNSNU8J0flVv4sD0vANXXVw2RHJWtMPsC6EMvxFm5rnOfJqaH1B6UZfb8fosxuXs0zhF8CkIq51cw8HtQigTcSnRrS0RrRC4Bf3j90vpnZqSQ+xo5pe3mgMzc7wn8GLCV19pw3ds5pje6BSfZod8moJPCutigWX0awV9U9A7moaJuILobkqIxrjtTGMFvSszDQv9xDM+850tXDQs45jAaCTy1C/epa5iXJvgc0mHfC4RfLiX8CrqJSD/Ct7ytXzVpmEgds2Z6tfmev6y3cEol/pEV86sx5oPv+xXLjlp54aC0pss/I6rpBpFXiLoO5x9epWa9cB7m2JQM2Nq1sNkULMeNa9ZfFWO/hBfzVLzrEfVGQSMW1sTy2Y9cCdMqi4fLZ/RDT4prNR9V6abwaBXitgnGf0bYfTEX9ZU+g7iXV+Y6Y/4njTEGi2RXfE2/BiaIr3RddEnzqnqExthZp7r9IZV/VB64TviMC3vAI6B78aouiLQ61hom3xltcWrX+PD75gP1r1R4tON1cJcO6/LB7F492037h2MwUb+HbbBW9RsmwW1IsN2oc42q/uoWP/Y1+a7GtGOXwjPHPrpb+4HvD7j7h61I4/bpaqnTNROpnb30f3BMs2z7D66srvZfg9maT68rDyPvBKpZu4wj2Uzd39yFGbunko2XseO/6SmHXPfS61EqJ36lg/lr/nacPSxWygO22/e4Y++jD+DofozWHapPuU6ikMZGhl8Uv2mhuDTYd+o8sd/efZS6SXXxkzmJz7+W+GeM9QpzwzyDCb6KpYRZci9Z9bo/yGxaqFWVm8DTLYD5BEIIwb2fUb/VfJ9NceZ0vdxm6juf+2Qb/YsteE3SJaK/I70y9utUuOU34LWc/uP/Jbt/SsIFd8VYWZtKUAyfMc142r6e61IFwR2jO/wZuIbudXCULXV4ltTMCivgWv3VT4ZjuXBt7GgF9kGvLlcNws+Jr+6FZHPk6gbeU337fipWQH2+ipd/PtFIo3niIf16IHVhT1hC3M9juE3Qkf15IjHUfuD1L4EVXfKziaiTygoDvmo/ewK61onrBi2z2LNYs1izWIdA6yckSG2U3w2Ev3gOpKv6kI1pk8tiJ/VIZ+zBJ8Rka5um9xMyKxG96y3qvvyMH3uFxUuOU7zLPvCiY3IeEbpnTCD9fzjpsusRvMxqD1DWA6GwWmHQAaLq9C/GIt94HNOnOLDesUVypx+yO2tX97zjHlXtpBbRtdQGfFXiDjt7a1f/grRz0IZrWs9qzLI2Tek9lByPRwU9Ig3QPTXt2TCVbmcLzxZ+rJZ19NL+G0BfleCPVg+Q3C1u4XK7tDPsN2pmS7lz1L+Ause7xVD38MzPGqvXmofq/09GHQZGN4A0d8uypztruzME5er0b8ks1xNl90oV9QVl6ta5VbnAVN2oFbkVTtwDWFdI7DUvtXcusz7To3+3kS5Kv+FcnK5Gv19meWK51cNx+I6LVfUFZer6n+o/ZIpO8D2wXSiZvTXUxz6RJ4pVf4b7SCnzLF8yvz3y0SZc9+R/UJO+4Iziwtbz62Zxc0H9+7f0ZpaDBRSU4Hx77LrxRaI9IHSFvRuAcUp95maUDfeZRtZ2H0a/auEylPuN4acLdRY3N2YnDZ8ry3U7dwaTxWlqhnG9YCpxnB1iRiFSB8IqxDvYlDbmlO9QOXdlIlxq1XWI+DTBUb/c4mWo90aY84tHapHpPLPNzpiug0lfLBFQzPiFs3o35HZouG6peFYXKctGuqIWzQ1s5A6eatOxajZ0ibRo+5Vi8angXJ7p9wb494Hj6xS9qLym9KPsi91L71ay0+NgnF/RQyeo2DMD9tCqmxjKLvNBemxvHk0gvsueOYJ6xLf3tDuBtiULeBsxyU0IsayamTwTM3MqBODvAfoQ+ALym5nyx3xG/1/Ef4llYdUbzU1C6JsHdsP3hN0tFZQuezVrTNq3w/vCcIZV17jL/tmEgduo1EPufve2B4Mt4rNoy39Ae01w27fhcRTdbHwHds8pjc6xafZIZ+m4JPCulBgGb3q43T5WJOJeBLR3ZQQjXEL+sfvT6J3/YIWgyqmRoncIeQVk5o0YCzc+rMRaPgyH2wOnk1YVRcBMD13SU2u/91yo0OCfwX39WhqW7Zh19w+/2hBeCHokVfZlmqUS23lzznC9KF3Xz/62EcuOnIEJ3erntGrrf/PFvQdbi19k+pWYXMQA3ar1lFc7hGmmtsL35SjP8RvCno+wlR12yTGbayJZUeYcLaDF/S67WN4yPVd0c062rJYs/+DRJev3WQiL8Ci7KlFU85XVX/ZyORzUYd8LhJ8ur04exHxKVuQaxw/lQbtu6x7/uLWLy9+fAQufBhpPasL2MpOa2NbjrOLXF95cYZpNpXIN78lk9quy3nGfCqZ1wGPQBgx8HZdo1/SkqFDnyq36/IQAH0Yt8s1+WbPiB6rY3TVtuuWbQQvCBXfFWF67jGu3cTnVfR3ne26NXsJlT9YzoMuHDRiaXJQA0PsVVTZrovlwYfacD1hO/Dmct0g+Jj8fYJ+E2GpA3ym+3b8VC9nLWGodPHvq0WaVI87p2bGwGsHmxyx1NbfDidJsj9Dwdc01qwnRzyOmlBKfYJDXRmpttDwaLHuFYTxeasj1mYnrBi2z2LNYs1i9RxWzmFKbA94pkptmygoDuVLjSgxfWpCdXmHfJYLPiMiXd22r5mQOefTDlUvSMD0PHmPI2oc4d15vOZZdo0kj/CM/v0wwrvr+OkyqxFeDGo0jeVgGJy2wwXBUbUgiHrlBUG1CIH0tlU4tQVI2UJuGe2nMkptF0R5eA/Nv4MyOkSjcJzt4Csg2+0FuY3oLY+522KN/iEYhae2xa4t4Vc2K7GuhN9PAL+jsC12vrI79DM52+yUP0v5C7XHhw+5x2feZoc65n5p7qYEzkfullmjf52wB26L2DbK5FN6c95mt6FEjHGRPlDagt6Nl2AZTnyHkxw52+zU6QR2EW8WKk8VWQyz2+x+7LbZXVUiRiHSB8IqxLsY1DY7dSVMjoqVqupu0P5lYdIpD5v6eJbqCag1h9THA1WvZ20JH7VxPAZu0Yz+3ZktmlNPSrZoqCNu0XJnToy+3VYcrmqpD7qqkU1uNeRZNmWnqqfWbvtKzsEWdb2KGj3wRfiYLtWrxo81xuDZq+7ksFnVLYi8rRJnwPgKTGyO+GJ71YvKtQUcPd1ZsnaGuGgLZWvP6AMQ4/bWL68jfUz4AMPc0CZvOf4Ouzkmj9o6zP5OrY0rezS6Du1xRNkj5j9nlIf0Vetq6hBa6rAkdyPb2U1qCxyuXTZoxId8nkk8lZ0oXTRFeqNTfJod8mkKPimsZwqsVD3v8hY4E3E50d2UEI1xC/rH75fTu35Bi0EV07UlcoeQV0zKnBWfRod8Gpl8zu+Qz/mCz4wtLj7L969UE1JWdh0u9L6yILwQ9GiKb4VUNzOqxbScrXPfbG756J7H3/kbKbeb6hKq3fnnC3rTVc1vzr9CNU3GW22du4HisHkxGdTWuZrfZHtFjv4Qvynoeetc1ZtEMW5tTSzbOqduNz5aPoO3zhUtJ6q2znVblg5vzau8maNBcduBHsuUA08RoMxVb2xUmzmKMFNHagsY253JkHtjo9GPQ5nzFjBLk3tjo/puJspc9t3MxS0ZOvTzcgsYd8dT3/6r+p1YTG90R3tTEm+dxEVS7iLjSRbeJo4+cYTiboU4viMQtwSiPji02wR1NU3bBIGlNjqV3eyNulBTTxfAM8aZrPyOyx7Tp7bJbuqQzybBR03BYb+pi8cQsmemDb9BslTkd2RmWm1Jx/yVbbzCtGqhsmzrLfK5QPCpKpfjcMpEPJPo1paIVgjcgv7x+zPpXdlwyv5Wpr+hRO4Q8kxfDc2OVhVrt0P8+cs1z7IrirBpRPqH4DOUl8Fz6uA+nwxAPteT/Go/R4ennLJdgOE3SJa6LiB3XbjajucReGatICq+S9UEXoPi5cFhSldlx7PxVXNj1wjM1JoLp0NdBPGuT9CnGqQRkr0/kR4xMB1bTEHvsbZdJ3jzzocboLP7E6un6Mt4oT7are4zDctg9NsSHW48n6jyxbWZG3i0rVtK+N8DXuaWEi8WBH/OH7YwgyXyll0BcjvoIPV5Jj4Ty++KoD8zUPY30g5RXvBvZYvXEf36Nnnn8jf6uxLlPyJkMLlCmKl/liGU5JFl2C1kEF7zir37HixZaee+BHs5LiUuiRGBUxZMG9FizXpZO1w7mI/9rbQTc76o9Xyka7Znx8GyXQbcIjRKePYFHUaCli2EY7dxZKQev+TGEcxf3Y0jZbW0HZ8ON46UNdrKWXD6QGkL8S6GaM6/3QJ6qnWfGatsi+KdrV9upF4JDooXc68FORQm50eN0NSsjtGrGVzVKKkF3hsyeKMu2aFvqShru40i60hWdWdLrqwbj7Ks1wpZO5y9qDy7xjNhOLvGM2E4u8Yzbzi7xodScXaNZ6Vxdo1Xp3Amloett0Mcb/GfhLj18MxBzdiZ3mO9XL1qCpfp8LnMp+Qu5qMP4WG3sim1acXotwKW2kxjGwQHiP7XEv5Ircyl6kG7e7P4Xjrc0HMTxWE6vG3asAPRdeNOMcwPby7BVZV+Qc+6uVnQY53jzU5Y57ZSHPoWniXG6RS82+/CZdPpPL7colYNt5M8Wxz5INY24oOzxDid9aGSeoX1BGfWL2098wriX8Hg8r/QFJbatMcrQX8E9Wx0dXl6XtVRG5BS39dL5RPpryrJ58dAzvGWnF3cZNiseq+j8jGpex1T9RR10gwz6yQfk1UbjMq+h4c6Ggy6DHjq1Oj/u5hEUEfC+EtBGyrKXmcT5HeWPvms7n7s9Iiy+goSY/UJ+bHecrn3B90eMr3ZBE5QKf88QPT/C8pq4WqNGUpk2Fwi82AJ/U0kg9H/nbCXlB9A++eVa6P/ktgxkYt5eQnmVxJ9DVVPU3d0tmtPuT+BeryZ4lB2bhe3A3+mvZL4Yxzf88gyl8mrVvJS8nJ7Y3E/hPbq27QLAfsWFXx1f6qsniPkzS2rzYn8MZalGwgz7TFVR1Af31+uMedUxPxX0aarvsrNgP/DjH4++mr2y+gzsB5+iPok6n5T7pPMWTElf+pwiWF11tYXX6h6TLedbjwPFCyjOLXE6d2W/tnS6bipe23j8xkkR7s+3nNbz+yHF4lyT+kwpfN292bzIRYsj20Up2z2aNvj0bxHmu1RtR/KHnPukc61R7xH+sPUt1N3XisfzfK063Pz7jrzj4Ml9Ozzjf4MsGPu99wiZEiNE24V9LcImcdIBkzLvLFeok7WUX6M/pmZ/thpzkMe9kO9sf2ndBQD6/TFgh51xVeV4JzgzRSH9n8Lxal5pFSdza0bljbq4a3kq73n59hXG/0LEr5a5S3lq7s1P5fy1d201V6dn0NbzZ2fe21GXyB10LTdGgT7L7VeotphXvep+v0ATL8lwWeiQz4Tgk835yCRp+rbTFB+qs6FYPobKT83OuZHycy7kWPAOdXJFVNpynwbpuX2zugfXjGV7s7Ws9rNnjoInbLdsjlRNYcUw0bIfwjd6HOGOce6z8n9SmwveX1ZnRpA28O202gCydgNfXkeQlf6xTphOmiGmbrk69TQ3vgQutJlbj8ET6u8eGl7+VOn7drZB18D10NrdMe8D8C2UHWNjv0l8lH+kssY/SuWy6Wt5wGi/zeJvqOyg5TdtBvT8Teh0Db4tIqa5++iD+lpu+HTnGreMddu2IegP8c22trv1BxZEaa3k2jPSF+2vrKFcAp6Pw/eY7rnUZ65j8TYzyd6y+dgCb3hcV/kVxJzCVvbyPACkmFbGxm2kgxG/04hQ0r/MaT6hB2eSB4oCM/kwXeI3wjaPiZCVihYf8ZP2UEMal8T1ye1VpLygaqeK6xhRyw+YVmzvG5Svs2C2ufF4wr0Y5soDud5UD4O/fQ35ifa9RLaUxAEFvfzUG7la7aKtFsF9rGqD1vr8UvWBzUGqFofeI396V4fyvY9htAb9QHLy+RWOophIuSFnPpS88aNVbn1xfC96ouyPVVfLH/b6/GbiHd6zgszfdU58KzWMbC8vMpPzXEdq/Kr+fmHZPmpMbxn+WHdqlJ+au5vBTxjHOYnNfeH6Y/W3N8K4oNjQZz7+wrN/amxKabluT+j/x7M/X2N5v6qzu91cb6u/1h/d5rXHXLnn7htV2c/cuef8PLSS0vmnwrAvVSk5bqN9NuEHEbPe+KYhvevHdmbA2MpPoyobBblupQwj8i3cgrzaO9fQz3zfrCyPr1hhzCzz2D5s7gq7YKqE5gfrhNqLR7pq67Fs93jmvI2wuL6FcM6gZWSdUsHsnI5YlnxvgH0s2pu9tLWM+/1WyDsUpW/6bwb5Z+aT1M6Tc2ntdMpj2lSewpS82nt5s7ZJ6pb2LBNVPObvAal2gflJ5RP53kjs8vVUP68Vxf396h15HUlmKckfJ3Kg7oVLbeNS51r2JZIh/VySPCasIcfpoPh4a1+zIvbGaM9G/T0mhO0LAXL0yZ0cUw2URBeCE+pMdmJHmMy1c9D3/zslVNpyuoY+p3zWs9cx563cirdxSWYIeh6mzpXiPL88pLpuN1aT1Z1N9WH4XVGtQffZMD92aq/xnunjP4qqJups0w+65PFP6t2EfuF3C6m+oAxcFmk+lGokybRc7mU2ReWNffDcU1DlQGfQzD6jVAGqU++cLt9Q0XZy/YlcF3EusH1uN3l/mVn2tXYNz7bfm2u9zcl2lY1V5BqW9vteefzhGodSs1h4KesDDsQXTfWZY/mXhi+0D11LhDPAPA8sfooSJT9NeR71bkBLNucj4agHKe3nvn84O6EfXnvK+SzO7lzNzifbtiB6Dq0rwXHeu7GyjZn7gZ9Ic/5qXOdUfYdZF+qncS0Z7eeuZ18JGEvNyfyGEPVNopvgsb+1y0Uh+nYltR40GS4VegB5bqz9TtA9K/K7C84jaMvU/aJY1+2z9R++hi4LG4T9LjHnvfR470b/ElSNb+FOmXfpc503CLw+UzHzyb6C9g+3Uqyb6sou/K7qr5hnRpq1Tc1zuc+67YET06Lbc9gCX3Z+PNtQl/sz8rmk9YQptH/u4Q/UG3q9fCu6r4xXkdBvfC+MTXu6F5/Plx+rPeNcfuR2m9Ydd9Yrv2jDT2++Mln1Z7zHUqpfiynRT5l9l+2b+u3E/bfblx+KmEa/fsrzn2l7L9dHyHVR0qtMfLXKbrQP7/qWPfP2f5T/XP0vznnI3PtH23o7xdPx1XnbzHtaa1nPn/70Yr21cn5W+5vpc7fYjqen1F9Vy7HsnaGxylG/6nM/pbTPuCFx9qf87qF6t+m/GdqnVT5T9Vesv/868z5mdT9FDmy59Y3rFOfpvYGx77c3rT7sB2f4bd6XdbeGB63DX+XaG/Up9ZRT9zeGP2XKo7XU+1Nu/E6zwep+yTUWD41Xne6C2rRsf7gJLc3qQ9OqvNpbAfIJ9f+0Yb+sGX/nen1gccKkMWw+wXlAP0azf9p2SfuCbHfnC+Effaj3/mrD1x73j38FZsYrIzimk0s/8dpThavUTZd4vXDfCF8P8mm0hUkA9P3CXrDHRFxA5CHujoa/egHN3zxe/tObaejuvjL/3DHp1/wuX/8XJUyGAkzy6Ao+Y2hP4HdFFg2H2BrfoOQvoLf6LP0c4n/RFbyUFg+5+BLkm2onmw/zNET4jdIlor8jqy3quukMX+83lrz++r/F9dbsU5gWaLukI+Vl2pThihuQGA88XWlk6bno69mPjq0wX8dCdP9RAzYL15OfYW5ENcfZvouy8cA0U+cMJXuBPqSHfuEGOZB/FwRb3+bvvsELT7z3yY76w3prbwGS/I6SHk1+lNb+VN7+IwG9Ydy9ZVgngGY3NeaF6ZCqs4Y/bCgnwc0Jo/61M0wpUPZcV8mv1PlUxAtyhDDLUKmsr8bAqdMhiGBw36eMZkn20MM3D/qF3ywTmGbNST4V6jHc1RbEEieQcoPxmHesF/IgftfKHPEmFvha4uqLnm23fZ+Drxnvv1EO0i03HdHGec4yNgUfAYJd25C/oJwBkS6kaDrm/rNlbcQ8qq2pFM+iIXzg8p3T4SssJz7wjFgm7cxo81TfQZu87ZAm7c5s82zOO63xYDjOvbp6uukqQ/VmI/M/VCN0W8XbZvyIfjB91tIn0MQl2pHBoj+IdDnbaRP1JfpU7VfZW3OHKKN4ZYSHdwFctx5QjkvHnupPEaMXQk93iLoGKNuu6b6V1x3c/pXXFcxneLB/ris7eZ9HmXx80TegnjXJ+iHSvIbBO9GG9y5Akf5dz4bU4g49j2YXzWPoMb36Lc2JupLEabnax7layiRr0Kk43qOss9NyK70h/6j7hzCa//uh3/9+oeP+2a35iie94uHf2bkgvf9Trfw3zv8F5f/l18cenG38D8992uPf/Jjd72pyhyL2dEg8bJnLE98j30b3htg9G+h/eg15zDk16fZL6XGfyg/jxdj2FQi/29C+/BWqndq/KPqZFn7PidTFqN/hxg3qnkLk6vDufABNReOfpP708qfI33VsavpRN1pyLznCCzUKfeZTEeDQc8fGB7bwzuhDHitSvl+i8O8s9/tF3zVXCWe9/kI1aua/ee5qp9iYSSUty/qjCbfATGPZMI4LEu0Tw5qjGp5jTL/ScYYVfkHrq9q3ibVH1X1zvB7rd6Z7TfDzHJhe8u14bL+ouKHesC+gNlw2Zw/1mkc032MxiCDEKfmzNifGv3fgm//OPl21DHbg/ITLEsI2g/lzBWMiHRWLmqdocrcEpYvyonvEL8ROvIvBftb48dlxGsBNfsJA9zGIj9VDuNB61StF/BYVM0npcZhKX+i6h/XTTVPodqQ1HjReOOcfE6/SdUtTMvt5Behbn030W8q6xuFoMcZTJ/yfSir0v08ilNzC/Y8nOCj5BoR9MMJudAnY1rm3S4PuW2VUx9R3o2KZcJ1ROkF6VmPo4J+BGi4joxCHJ+tyW3b5lGcauPbtW3fLWmjMB/o/3j8rOoYtn119ing3nrkMRj0XCjuxUD6H4o+MGPi/o7bBWYheIQwUy88rjyyn+LEKRluOunJ59R6w1CYqdcKdj6KtmNBtZuG3wgz81un3VTjGswft5s12+mRlJ2q/o6a5+G6bvWhbIyFY3KkH2+VbZPoYuBzFapfodqLKNsw+alurfmg30X/EQP2YxfT2u8AxKk1Sau/XBeOP3Eq3bLWs1qbMBnnhbTPUHsA2D7K1tHZZxj9CVBffyaj/45y3V6CuQoweR1d2YUqP7ZVpFd7FVSfieehlC9TbbDRddgGj6o2GPNfVi9NnrI6Y/SqT6bWtJpEr9pLlIXnz1K2GENqTR7rzmKoAyHM9GmWJoSZ84JMj3s4kP5ZUOcupLk49tn27ooEXVX/w3MmDUHfL+iN9zxBb3HY38TyQhrUF2I1SvhdTmWCNoj9LeaPdhZK5C7rPzJWv3iH7cMlJ07PQ939b53M3//D0Mar+n7v9SfW2SPJ610hdLy37o9z7BHxG0H7h4mQFYocnxMD93vm1eP3RwWlR35qLdL4Ddfj129lNSqwTRb0W0oWSztA9DdTGzAi0jQpLgbuU6kxGr7rO0ZYaiyoxnux3l7f0oWy//hvImSF89SYlutWTVvYmlu3DL8ROrL1I3Urte4SA8/jjwhZVHntALpOy/5wj2LtdsS6zxHroCOWp772OmLtd8S6xxFr0hHLM48HelSuXY5YnvXRsxzvdsTyrEP3O2J5lqOnrT7oiOVpX4ccsR5yxPK0+171OZ55fNgR6w5HrEccsTz15dk38bSvXu0Xetp9r/bldjpi7XPE8rT7Xu3L9arde/ZNPMvx6dCm9Wpfrld9oWdfztMXepajp748bdWz//USR6xe7X/tccTyrNuedchTX57tkGcd6lXde/ovz3m5Xp0b8rQvz75vr/YxPXXv1XbE54YTVgzWduTsRVVro40En0LI3C/44F7BkdY73nsaw1CYqYsK61DZ3zA1/AbJUpFfkSoftRfA8j4qZFH7TLmsUuuUyEdhDThi8b4ftb8mtfdW7T1U+hoOU3s3Dh3ctWfXwQev3HHHobvW7b0rUBigv68sEfFGottUIlq/wC3oH7/nzxf2C1rEVtu6BkvkDoCntmk2RfqBBJ+iQz6F4DMi0nHVrrn15Yzcqn2stsla3tURAd6+FsNdQFfH9WLcvY5Yex2x7nfEmnTE2uWIdcARa78j1mFHrEOOWDsdsTzL0VNfnrZ6tyOWp63udsTqVT/hWR89dd+rtvqAI5anTXjaqqe+Djpiefpozz7Ag45Ynm2HZx3qVft6OvivbrRD1pfHoyt4vOqRiek8+Wgipi2AJx93/MbEVLqXT0znXQBve+7wGtizCsILQY+hDL9BslTkd2QM1Uf8OH88huoXsjQpLoaXAh3H9Yt3KawDjlgPOGLtd8S62xFr0hHrQUesnY5Y+xyx9jpi9Wo5etqqZ330lGuXI9ZuR6z7HbE8bWKPI5anTRxyxPLUl6f/8pTrsCOWZzl6ytWrbYdnOXrq3rNue+bxYUesOxyxHnHE8tRXr7bbnnW7G22travheIyvNFRjn74EH3W954hIV7R+h0g+e54IWaGvIDyTE98hfiPMzHMFfkVK/0ovvKaIaZsUFwMf7VV8CsGnEFgpuRyXpk3EM4lubYlohcAt6B+/P5PeKVUgtrrlZUjwspBSbbMkfQzKtG+iOCUD3jKHRcjL51WrH6a3OMWn6JBPIfiwXtV0Ugx3tn4HiP5fJp78xVtr+gU/xMpxLTWX7LN34/CSfaeuRS3Zp1yLuoWK7SGGW4GO4/rFu5Rt9TtiOTUFlb8Ow3pEu9pEcXjDBn65k0M//Y35ifhLVk/hMh3LijZmcqu6zNtiqtZlTN9XgqVuW47hZohH+tWrnvztsEzXqDJle6l5s9ua3Ppddvusqvu8fWkipMP2qx557D+8+3+tqVqPjF7d5pW6Ba/m7TOnjwCPQLwtTm0Dszj0wSZDTL+G5Kt5e+/pOfpDfOUfueuVWxbzg25nQtC3EWHdZ1seJYyJkBWyu8GG3yBZ6rZVqVtInxCs9Ru7mwtaz63u5rq9k3deMbnvwKE9O7j1xv2srBVExXdFmOmRC5AsJOheSH+vFemCwI7xVnJNej8RssK4WcW4iLQ4vPNqmOIWQByWJgfVMpnM0Uq/D1bKdCwPlsd8ihuDuAXAm8t1VPAx3n2Cfoyw1B5k0307fv0iHe+hHhLpJuzhK69/x8ub73vLL02c+anvDF79s1+/7dvXzLnos5965Lg/+akffPVbP8cyByEzl6PaT55Tq2PgnsyoI1ZTYJluxuF9BZtfnOutDL8ROqpjR7zVOPHj/HHe5wtZmiKOfdB8wWe+4KOw+hyx+p2wYtg+izWLNYs1i/VjjmVx2N43KQ7bT5sJOFoj7y5Olo/ltrvHarK8w770aEHpkR9jxsB971SbOViCZWkHiP6RVU/+NokuBrZr1S/Bd6afOMI8vGq67Dy2Ub8hpPt6vEiE5XO07R7P3eGmxVet0jxxlhnT8p3wRv9/V02le+2q6TKXfWtBfdcGbSiE6bozug7vLx+r+g0RZfdIf3vrtxlm2jF/bwfzMw/y04H/WZRaLYl5eZTKWN373yfyw/f+fxnK+K2tZ2XHOB7D9KENP6Ov+52Qd7Rkwjv/lXzDJfzU9wCwXJjfLwK/1PcR0Q+HUNtuFyu7xfqU85029Q2sHDtXtox2nrPChnbAq5jqOw/Kn/E3GX5DlHmOnatyNfr3Zparkz+S5Yq6yvnmm5qdTtmBWrFphpllzt9MaLeKllOuKB9/99LoP5goV9VGqTaE26g/yCxXp+9kyHJFXeWUq2rvjV6tUqRWLcu+N1fmo9X3olLlqr5Jw+X6sUS51vXDH+8BP4z9xZxvxSI9l2vq213KD2OZNyiO51+RT1UfrdrllI82+r8UZc5jQvYLZfIpvcU8Lmw9t1ZBNh/cu39HaxkkUEgtW8TnsRIxFon0IYGFaVJZwqUBVrnxGgx6ep1VbvSfEypnFbI8OUPkmlUmeyHN8L2GyLn7trg7paqZamK4nNrxcTTVGF5YIkYh0oc2WPY37qHC4uZefaonwGnjP+st5vYEjP7rwpQZE2VI3TCTWqlAeVT+xykO0w2X8MntoRj9tyGvqZbMeHejJUMdcUumZgrVjIrRLxD0uJLCPRRcdeXqhzoeJz7tqjl/yUvZqRopK/tK9bTb2Rd/PbVP5EnZV2pWxMkWxo61LfBXUNEWUjNqbAuqiUWfwLYwT/DBmbEGxNtvzh6kS05547LlH79vpN2Xteriv/+Csy4e3XbqK7qFP2dg+dsm3nf7uipfBlO+ro9w47tBwEH6GDa3fnP2qNXc15S9B5W/Sl73C20F4Rk/zh93R4aELLxvOgae+VZfXFRfMztaWGovKJdlzT102V+YN/xG6Mh2ipRe1Fct1RVgllZdN8D67+Tqgl7EwvrPez8tXv0aH36X2gPNXw/u1hd45xKfuY581HUTav90p3zUXmw1G4krCy9YPYWLZaxmcGKwVd8Bor9r9VS6y1dPpzHZrwSaDa3nIeAdQuW63OC6iUH1D9husU/KtobDdLYPHEsNURzubrsF6Djw2A71EPndctIULtNZQF3mnO3B6QbmGQN/Pd3ob6DyqrnSFbgvglhPJVuoU96PZpS3KuPUGYg5FNcv8pE6e6J8ZZl/Q3zlk24m/HZTLmsTeba0+GXylO9i20f6u8EvPUD+UK28KB9s71NfykR51K3NlrbDL9QOq52zFpQ9cz1QNwKrXcxcD3C8yz4Rx3g8nsGg6ojpoYpPfKCkXTMeWBYx8JhyQMiL7WXdMdnPnDcw/403rX9Rt8Z8v/D4dRe8ctlJ/1Tna9Cz5y966fwFe8MYZs9fTKdjeZ4O5y+4pcHWrl/wHiD6t7U8WNTtw6vDtHzyWQu0v1tIRrUPI5S843zwyLoL3wyYn+t5jtU3A6p5Hu5nGJdxQjUapMUwDpKFEjpVoutEOg6Wjs/phjCzVGuOH0ZyS9XeeV11qPqqqm3t0GqHU1bEmCFoz8dLm+ahypagLe0A0b+v5R3U7m+eS8r96kT0Vr9B8wMW94fQD/8dGtOy/eNz1V22mJ49kTrPreaeeF50MBE3NxGXujsD+6w8bzRPYEb5hk6aTsf1XP2GkJ5fSpUxejYerykbY5ssw9pIWJiet3c022DxSQVMzycc+kW6EcGH/VnNE3+juf7sWJ34s/zNr8dvpKD0yE+dIlS9R14ftO0XgyVYlnaA6P+C/BmuZ7I/U2ud+A792adWT5cddVu3zvHpCCyfdrvFP0Nj3ybEKf/IJwKM/uyTptJ9lvyxOukxFnR54XPuiQ7lq9lGuqVn9sOFIx+Mu4l4KpvDOmnlZHpWNm/pFkIc1122Z6RHDIVvGO1s8Gurdd7KdnIbrwGiXwA2+M1EnyC196KguILygnTKPrHMbiN6dQpK2SyfgvoOjMJ4T5SlR12hXOsI0+i/B5i294jlxHypUUnKFpW/VjpdQFhqThTzw1smlU6xfg5T/o3+h0Knar8Jz1Rgn+9misN57xGKw/nyUYrDOfExiktdBYjzfuzvcT4YbcT6fHwKYrj1vsN1Fblmwz5SrSuouVSeF0bMsrVe1Av7HSwHVS6mM1wnSPmiGLg9NPrFLX2q+qX8p+pPGf0iQY8+m/cxYp1aRHGYjuslb1/G58Wtv1EPKNeLW78DRL8S9DAOfR/LSyC5OtzXNqL2tS0GAt7XtgTi+gU9l8VSQb8EaEwnTaJXvk75TdQp+zrVl10k8LkvezqUAfs69JWLSfaiouy5ezCxTn0t0Vfk9nZ+gienRT5le5DL+hHnCX0VxAPrAcrF7a3RX5DwB0qXqfZW+Y8FIl9KpwsprmxcZdiM2WH9HFX1E/PP9TOV1xjq+spmmFl/eHyPdYPtX80j5No/2tBnOlwj/Pn/dvaL/un6b5zQbg3Pyq3mPX992IcIYWpsEML0PhHfWYdr+nzSrlFPliN5nAc8+0k+xB8g+m0nTcfhvYj4LgYsuxi4j4q/yBfnUgOlzcUaIqy5HWDhaTGmn1sRayiBNUhYDYGl9g7GslvbKptO1rV/eteK//3+Sy94Q5V1bfOH6tO5VudNR+qOxhh4P5TR30F965p7X2XfGu2D5e9PyN8fZsq/qUT+h2Fc/dKTpvPjE8MYp8YuRqf236RkMfrdoh1V7ZXJ1WF7NaDaK7TdnFP4ytaNvt0eINOJOheTc/IUdcr9SdPRoKBHPLaH+xP9SbRNPp2Keec90f2CL990EoPVsUjzFqpXNdu2uWrtxUKVtRfMoxqH8zocliXaJ4d++hvzWnUvoNq3p+oyjymHhKyq3hl+r9U7s3116wHbW64N857I/gQ/Na+BNly2zwrrNM6ZvhX6MKh3dQYxBvanRv9e8O1vI9+u9nEqO8q52SB1jzmmzzkr0OF5oOwzJHweqKZ/qXweqMN+wgC3schPlcN40DpF/tyXVjaS8if9FKf8iap/XDfVXJ5qQ7huqvqHZ59z+k1l53stLbeTvwN1608T/aayvlEAfuqsUY7vQ1mV7vmMaoOw8Xk4wUfJldrdpORCn8z7S3nXVyoPuW2VUx9xTtUbxpReUufY2+364zqibkiu2rbx+VzVxrdr2/60pI3CfKhbZ9ScPrZv1vb9P3WEgjv8aQUA",
+      "debug_symbols": "tb3RjjW7ba37Lus6FyVKJKW8ysZG4GR7BwYMO3CcAxwEefc9RYkc7F6e6uo5+79xf/5X9xgqSWRVqViq//7t//zxX//r3//lT3/5v3/9z9/++X/992//+rc//fnPf/r3f/nzX//tD3//01//8vjX//7tmv9TSv3tn+s/PX623/6Z50/eP2X/1P2z759j/aRr/yz7J+2fdf/cerT1aOvR1qOtR1uvbr269erWq1uvbr269erWq1uvbr269drWa1uvbb229drWa1uvbb229drWa1uPtx5vPd56vPV46/HW463HW4+3Hm892Xqy9WTrydaTrSdbT7aebD3ZerL1dOvp1tOtp1tPt55uPX3o6fyp+2ffP8f62R965ZpQHMjhIVnmnOkPzWK/zA7ioA7dYWwYU7lPKA7kUB2aAzuIgzp0h7GArsthKo8J5FAdpjJPYAdxeCiTQXcYG8rlUBzIoTo0B3YQB1curlxcecYR6YTiQA7VoTmwgzioQ3cYG6orV1eurlxdubpydeXqytWVqytXV26u3Fy5uXJz5ebKzZVnhNEcghliC7rD2DCjbEFxIIfq0BzYwZXZldmV2ZXFlcWVxZXFlcWVxZXFlcWVxZXFldWV1ZXVldWV1ZXVldWV1ZXVldWVuyt3V+6u3F25u3J35e7K3ZW7K3dXHq48XHm48nDl4crDlYcrD1cerjy2cr0uh+JADtWhObDDQ7nSBHXoDmPDjMEFxYEcqkNzYAdXLq5cXHnGYH3EYJ0xuKA4PJTbNaE6NAd2EAd16A5jw4zBBcXBlasrV1euO2/UKg7q0B123qjtcigO5FAdmoMrN1durjxjsNUJY8OMwQXFgRyqQ3NgB3FQB1dmVxZXFleeMdjahOrQHNhBHNShO4wNMwYXFAdXVldWV54x2HSCOKjDPKuWCWPDjMEFxYEcqkNzYAdxUAdX7q48XHm48nDl4crDlYcrD1cerjxceWzldl0OxYEcqkNzYAdxUIfu4MrFlYsrF1curlxcubhyceXiysWViyuTK5MrkyuTK5MrkyuTK5MrkyuTK1dXrq5cXbm6cnXl6srVlasrV1eurtxcublyc+Xmys2Vmys3V26u3Fy5uTK7MrsyuzK7MrsyuzK7MrsyuzK7sriyuLK4sriyuLK4sriyuLK4sriyurK6srqyurK6srqyurK6ssdg8xhsHoPNY7BZDNYJ1aE5sIM4qEN3GBssBg2KgysPVx6uPFx5uPJw5eHKYyvzdTkUB3KoDs2BHcRBHbqDKxdXLq5cXLm4cnHl4srFlYsrF1curkyuTK5MrkyuTK5MrkyuTK5MrkyuXF25unJ15erK1ZWrK1dXrq5cXbm6cnPl5srNlZsrN1durtxcublyc+XmyuzK7MrsyuzK7MrsyuzK7MrsyuzK4sriyuLK4sriyuLK4sriyuLK4srqyurK6srqyurK6srqyurK6srqyt2Vuyt7DLLHIHsMsscgewyyxyB7DLLHIHsMsscgewyyxyB7DLLHIHsMsscgewyyx6B4DIrHoHgMisegeAyKx6B4DIrHoHgMisWgPMBi0KA4kEN1aA7sIA7q0B1cmVyZXJlcmVyZXJlcmVyZXJlcmVy5unJ15erK1ZUtBnUCO4jDVB4TusPYYDFoUBzIoTo0B3YQB1durtxcmV2ZXZldmV2ZXZldmV2ZXZldmV1ZXFlcWVxZXFlcWVxZXFlcWVxZXFldWV15xqBcE6pDc3goS5kgDurwUJY562YMGswYXPBQljleMwYXVIep3CewgzioQ3cYG2YMLigO5FAdXHm48nDlGYM62zxjcMFYoDMGFxQHcqgOzYEdxEEduoMrzxhUmlAcyKE6NAd2EAd16A5jA7kyuTK5MrkyuTK5MrkyuTK5MrlydeXqytWVqytXV66uXF25unJ15erKzZWbKzdXbq7cXLm5cnPl5srNlZsrsyuzK7MrsyuzK7MrsyuzK7MrsyuLK4sriyuLK4sriyuLK4sriyuLK6srqyurK6srqyurK6srqyurK6srd1furtxdubtyd+Xuyt2Vuyt3V+6uPFx5uPJw5eHKw5WHKw9XHq48XHls5X5dDsWBHKpDc2AHcZjKPKE7jA0WgwbFgRyqQ3NgB3Fw5eLKxZXJlcmVyZXJlcmVyZXJlcmVyZXJlasrV1eurlxdubpydeXqytWVqytXV26u3Fy5uXJz5ebKzZWbKzdXbq7cXJldmV2ZXZldmV2ZXZldmV2ZXZldWVxZXFlcWVxZXFlcWVxZXFlcWVxZXVldWV1ZXVldWV1ZXVldWV1ZXbm7cnfl7srdlbsrd1furtxdubtyd+XhysOVhysPVx6uPFx5uPJw5eHKYyuP63IoDuRQHZoDO4iDOnQHV/YYHB6Dw2NweAwOj8HhMTg8BofH4PAYHB6Dw2NweAwOj8HhMTg8BofH4PAYHB6Dw2NweAwOj8HhMTg8BofH4PAYHB6Dw2NweAwOj8HhMTg8BofH4PAYHB6Dw2NweAwOj8HhMTg8BofH4PAYHB6Dw2NweAwOj8HhMTg8BofH4PAYHB6Dw2NweAwOj8HhMTg8BofH4PAYHB6Dw2NweAwOj8HhMTg8BofFYJ/QHNhBHNShO4wNFoMGxYEcXLm7cndli8ExQR26w9hgMWhQHMihOjQHdnDl4crDlcdWLtd1BZUgCqpBLYiDJEiDelB4lPAo4VHCo4RHCY8SHiU8SniU8CjhQeFB4UHhQeFB4UHhQeFB4UHhQeFRw6OGRw2PGh41PGp41PCo4VHDo4ZHC48WHi08Wni08JgR24uRBGnQw6M3o+E0w3ZTCaKgGtSCOEiCNCg8ODwkPCQ8JDwkPCQ8JDwkPCQ8JDwkPDQ8NDw0PDQ8NDw0PDQ8NDw0PDQ8enj08Ojh0cOjh0cPjx4ePTx6ePTwGOExwmOExwiPER4jPEZ4jPAY4THco1xXUAmioBrUgjhIgjSoB4VHCY8SHiU8SniU8CjhUcKjhEcJjxIeFB4UHhQeFB4UHhQeFB4UHhQeFB41PGp41PCo4VHDo4ZHDY8aHjU8ani08Gjh0cKjhUcLjxYeLTxaeEScl4jzEnFeIs5LxHmJOC8R5yXivEScl4jzEnFeIs5LxHmJOC8R5yXivEScl4jzEnFeIs5LxHmJOC8R5yXivEScl4jzEnFeIs5LxHmJOC8R5yXivEScl4jzEnFeIs5LxHmJOC8R5yXivEScl4jzEnFeIs5LxHmJOC8R5yXivEScl4jzEnFeIs4p4pwizininCLOKeKcIs4p4pwizininCLOKeKcIs4p4pwizininCLOKeKcIs4p4pwizininCLOKeKcIs4p4pwizininCLOKeKcIs4p4pwizininCLOKeKcIs4p4pwizininCLOKeKcIs4p4pwizininCLOKeKcIs4p4pwizininCLOKeKcIs4p4pwizininCLOKeKcIs4p4pwizininCLOKeKcIs4p4pwizininCLOKeKcIs4p4pwizininCLOKeKcIs4p4pwizininCLOKeKcIs4p4pwizininCLOKeKcIs4p4pwizininCLOKeKcIs4p4pwizininCLOa8R5jTivEec14rxGnNeI8xpxXiPOa8R5jTivEec14twKjLoY1aAWxEESpEE9aDhZnC8qQeFB4UHhQeFB4UHhQeFB4VHDo4ZHDY8aHjU8anjU8KjhUcOjhkcLjxYeLTxaeLTwaOHRwqOFRwuPFh4cHhweHB4cHhweHB4cHhweHB4cHhIeEh4SHhIeEh4SHhIeEh4SHhIeGh4aHhoeGh4aHhoeGh4aHhoeGh49PHp49PDo4dHDo4dHD48eHj08eniM8BjhMcJjhMcIjxEeIzxGeIzwGO5hhUubShAFTQ81akEcJEEa1IOGk8X5ohJEQeFRwqOERwmPEh4lPEp4UHhQeFB4UHhQeFB4UHhQeFB4UHjU8KjhUcOjhkcNjxoeNTxqeNTwqOHRwqOFRwuPFh4tPFp4tPBo4dHCo4UHhweHB4cHhweHB4cHhweHB4cHh4eEh4SHhIeEh4SHhIeEh4SHhIeEh4aHhoeGh4aHhoeGh4aHhofF+TAaThbnix4eg4woqAa1IA6SIA3qQcNpxvmm8BjhMcJjhMcIjxEeIzxGeAz3sOKoTSWIgmpQC+IgCdKgHhQeJTxKeJTwKOFRwqOERwmPEh4lPEp4UHhQeFB4UHhQeFB4UHhQeFB4UHjU8KjhUcOjhkcNjxoeNTxqeNTwqOHRwqOFRwuPFh4tPFp4tPBo4dHCo4UHhweHB4cHhweHB4cHhweHB4cHh4eEh4SHhIeEh4SHhIeEh4SHhIeEh4aHhoeGh4aHhoeGh4aHhoeGh4ZHD4+Ic44454hzjjjniHOOOOeIc44454hzjjjniHOOOOeIc44454hzjjjniHOOOOeIc4k4l4hziTiXiHOJOJeIc4k4l4hziTiXiHOJOJeIc4k4l4hziTiXiHOJOJeIc4k4l4hziTiXiHOJOJeIc4k4l4hziTiXiHOJOJeIc4k4l4hziTiXiHOJOJeIc4k4l4hziTiXiHOJOJeIc4k4l4hziTiXiHOJOJeIc4k4l4hziTiXiHOJOJeIc4k4l4hziTiXiHOJOJeIc4k4l4hziTiXiHOJOJeIc4k4l4hziTiXiHOJOJeIc4k4l4hziTiXiHOJOJeIc4k4l4hziTiXiHOJOJeIc4k4l4hziTiXiHOJOJeIc4k4l4hziTiXiHOJOJeIc4k4l4hziTiXiHONONeIc40414hzjTjXiHONONeIc40414hzjTjXiHONONeIc40414hzjTjXiHONONeIc40414hzjTjXiHONONeIc40414hzjTjXiHONONeIc40414hzjTjXiHONONeIc40414hzjTjXiHONONeIc40414hzjTjXiHONONeIc40414hzjTjXiHONONeIc40414hzjTjXiHONONeIc40414hzjTjXiHONONeIc40414hzjTjXiHONONeIcysXG2zEQRKkQT1oOFmcLypBFFSDwqOHRw8Pi3Mx6kHDyeJ8UQmioBrUgjhIgsJjhMdwDysk21SCKKgGtSAOkiAN6kHhUcKjhEcJjxIeJTxKeJTwKOFRwqOEB4UHhQeFB4UHhQeFB4UHhQeFB4VHDY8aHjU8anjU8KjhUcOjhkcNjxoeLTxaeLTwaOHRwqOFRwuPFh4W591oOFmcLyrzBXB7A3wGumMFNiADBajADhyBM+Ad4SZwE7gJ3ARuAjeBm8BN4KZwU7gp3BRuCjeFm8JN4aZwU7h1uHW4dbh1uHW4dbh1uHW4dbh1uA24DbgNuA24DbgNuA24DbgNuI1ws+o2xwIkYAU2IAMFqMAOhFuBW4FbgVuBW4FbgVuBW4FbgVuBG8GN4EZwI7gR3AhuBDeCG8GN4FbhVuFW4VbhVuFW4VbhVuFW4Vbh1uDW4Nbg1uDW4Nbg1uDW4Nbg1uDGcEMuGcglA7lkIJcM5JKBXDKQSwZyyUAuGcglA7lkIJcM5JKBXDKQSwZyyUAuGcglA7lkIJcM5JKBXDKQSwZyyUAuGcglA7lkIJcM5JKBXDKQSwZyyUAuGcglA7lkIJcM5JKBXDKQSwZyyUAuGcglA7lkIJcM5JKBXDKQSwZyyYhcQlfkEroil9AVuYSuyCV0RS6hK3IJXZFL6IpcQlfkErouuBW4FbgVuBW4FbgVuBW4FbgVuBW4EdwIbgQ3ghvBjeBGcCO4EdwIbhVuFW4VbhVuFW4VbhVuFW4VbhVuDW4Nbg1uDW4Nbg1uDW4Nbg1uDW4MN4Ybw43hxnBjuDHcGG4MN4abwE3gJnATuAncBG4CN4GbwE3gpnBTuCncFG4KN4Wbwk3hpnBTuHW4dbh1uHW4dbh1uHW4dbh1uHW4DbgNuA24DbgNuA24DbgNuA24IZcU5JKCXFKQSwpySUEuKcglBbmkIJcU5JKCXFKQSwpySUEuKcglBbmkIJcU5JKCXFKQSwpySVm5pBoWIAErsAEZKEAFduAIrHCz+5lhREE1qAVxkARpUA8aTnY/syg8Wni08Gjh0cKjhUcLjxYeLTw4PDg8ODw4PDg8ODw4PDg8ODw4PCQ8JDwkPCQ8JDwkPCQ8JDwkPCQ8NDw0PDQ8NDw0PDQ8NDw0PDQ8NDx6ePTw6OHRw2OlhW7IQAEqsANH4EoLCwuQgBUItwG3ATdLC6UZduBwtDo62/LL6ujKRvvVtQPXCLR5v7EACViBDchAASoQbhVuDW4Nbg1uDW4Nbg1uDW4Nbg1uDW4MN4Ybw43hxnBjuDHcGG4MN4abwE3gJnATuAncBG4CN4GbwE3gpnBTuCncFG4KN4Wbwk3hpnBTuHW42TmULkMCVmADMlCA042KYQeOQAuWjQVIwApsQAYKEG4WLESGw9GK7x7nEsMCJGAFNiADBWhuYtiBI9DOodQNC5CA060WwwZkoAAV2IHTbW7zRVaQ51iABDQ3a5kljY0MtKMYhqY7J4EV3D3Oa4ZToVlPWn7YyEABKrADp26z7rP8sLEACViBDchAASqwA+Fm+WFumUVWg+dobnaYlh82NiADBahAc7PRtPyw0PLDxgIkYAU2IAMFqEC4WX5oNiyWHzZON74MCViBDTjd2PrB8sNGBXbgCLT8sNHcbHJZfthYgQ3IQAEqsANHoOWHjXCz/MA2aS0/bGxAc7MpZ/lhozpaKZ6jKajh/N25mQVZ5V2ZO1SQld45jkCLbmHDAiTg1BXTtejeOFsmw1CACpxuc1cIsiq8jRbdGwuQgBU4ddWOzeJYrb129tdmWIAErMDZXhVDBgpQgR1obnYUFt0bC9DcumEFNiADBajA6dZthCy6F1p0b6zAqdCtSyxiN1p7bSwsYhdaxG6c7e3WZxaxGytwtrfbGFvEbjQ36weL2I3WXmu6RWy3frCIHdZIi9hhvW4Ru7ECG5CBAlRgB063YS2ziB3WHIvYYYdpEWvXvFZZR3YnZqV1jgrswBFoO29uLEATs662TTY3KrADh6PV0TkWoIlVQ/uzZjgCbTfbjQVIE9mwAhuQgQJUYAeOQNvhdmMBwo3gRnAjuBHcCG4EN4JbhVuFW4VbhVuFW4VbhVuFW4WbbbR5iWEFNiADBajADhyBtvntxgKEG8ON4cZwY7gx3BhuDDeBm8BN4CZwE7gJ3ARuAjeBm21kW2wi2la21zCcbnYfZvVrZHdfVmZGdgVtdWaOApwWtoWzlZqRXZxardlCKzZzLEACVmADMlCACuxAuFkM2TWt1Z05ErACG5CBAlRgB45AghvBjeBm0ULN0BTY0BRm91l5mWMBErACG5CBAlRgB8Ktwa3BrcGtwa3BrcGtwc0Cxy7+reDMcQRa4GwsQAJWYAMyUIBwY7gx3Cxw9u7QBUjAqVsvw6lgdx1WWUbV5o7tGL2xAAlYgQ3IQAEqsAPh1uHW4WY7SVebO7aX9MYGZKAAFdiBI9DObxsLEG4DbgNuA24DbgNuFvN2T2Z1Zwut8MyxAAlYgaYrhqYwJ5eVldHcfpmsrsyRgBXYgAwUoAI7cAQS3AhuBDc7F9qNoxWZOTJQgArsgRbdduNoJWRkt3JWQ+YoQGtvM+zAEWhxvLEACViBDchAAcKtwc3iuNmwWBxvLEBz64YVaG52xBbHdntmhWVkdyhWWebYgdPNbsSsuMxxutldkpWXkd0PWX3Z4xxl2IAMFKACe6BFN1sjLY7tLsnqxx652VCACpwKdsNkNWQbLY43FiABTdcOyGLT7qisQozEDshic2MBErACG5CBAlSgudkRW2waWrGYo7kNQwJWYANON70MBajA6WZ3alY1ttHieON0s7s6KxxzrMAGZKAAza0aduAIXF9taIYFSMAKFKApzGHp6+sMC03BOmp9oWFhBVp7rXfWdxoWClCBHTgC1xcbFhYgASsQbg1uDW4Nbg1uDW4MN4Ybw43hxnBjuDHcGG4MN4abxbHdvFrNmCMBp1u3qWFxvJGB063bCFkcb5xu810sspqxjXbu3liABDQ3GzeL+Y3mZu1dX36wlq1vP9iUW19/WDgC1xcgbMqtb0AsJOB0szvWvr4EsZCBAlRgD1xfgBBDU7CjWN98sKavrz4sVGAHPtpb7T7W6sAcC5CAFdgmFkOe2AxlohjqxG7YA+3rD3YnYbVdtZiYfd2hmJh932HjCLRvPBQyLEACVmADMlCA5saGHTgCa4mWVQJWoFmoIQMFOC1o/W4HjsAZ0tXuRax0y3G62Wq+lW45NuB0s3sGK91yVGAHjkC+gAVIwApsQLgx3BhuDDeGm8BN4CZwE7gJ3ARuAjeBm8BNzM2mnF7AAjQ3m4hagQ1objZYKkAFdqC52fzt5mbzd4Z0tbsDK91yrMDpZtfrVrrlKEAFduAInKd8xwIkYAXCbcBtwG2Ym82+0YFjY7XSLccCJGAFNiADBajADjS3ah+YuYAFSMAKbEAGClCBHWhuzb5icwELsAFNQQxNQQ1HYL2ABWjt7YYV2IAMFKACO3AEWn7YWIBwa3BrcGtwa3BrcLP8MG81qpVjbbT80IphARJwus3bkmrlWI4MFKACO3AEWn7YaG42WJYfNlZgA5obGwpQgR04Ai0/sM0+yw8bCViBDcjA6WbfaLFyLMcOHIGWHzYWIAErsAEZCDfLD2wdZflh4wi0/MA2fy0/sM1Jyw8bzc1G3vLDRnOzkbf8sFGBHTgcrRzLsQAJWIENyEABKrAD4VbgVuBW4FbgVuBW4FbgVuBW4FbgRnAjuBHcCG4EN4IbwY3gRnAjuFW4VbhVuFW4VbhVuFW4WS6Z96bVqrIcR6Dlko3Tbd6mVqvMcqzABmSgABXYgSPQcslGuDHcGG4MN4Ybw43hxnBjuFnWmDfQ1Yqw6ryBrlaF5WgKbNiBI9Dyw8YCJGAFmq4YYjQ7+tdifiMBK9COWA0ZKEAFYu50uA3MnYG5MzB3BubOwNyxmF9tsJjfiLkzMHcs5q0NtkebYwGGGyHmCTFPiHlCzBNinhDztlnbMrbd2hwLkIA12lAakIFwQ8wTYp4Q84SYJ8Q8IeYJMW81Z7sNxEABKrAD7dhm0rVSNEc7NtO1mN9YgQ043ebKSLVSNEcFduAItJjfWIAEnG5zOaRaKZpjTHCrP6tz4aNa/ZnjCLRA34ipsQJ9IQaLMViMwWIBKhCDxRgswWAJBkswWILBEkxEwUQUTA0L/7l8U63SzLEAraOsHyz81VpmlwcbGShABXbgCLRUsbEA4zKU1o3CQgGarjXdksLGqTuf8FerKXMswHkU3YbbksLGBpxu3UbeksJGBXbgcLSaMscCJGAFNiADbUVgGI5AC/+NpsuGBKxA0+2GDBTgPIq5DlPXNyM3jkAL//l2cF1fjtxIwApsQAYKUIEdOAIr3CrcKtwq3CrcKtwq3CrcKtwq3BrcGtwa3BrcGtzslD9shCwTbFSgudkAWCZYaJlg1mBUqzRzJKC5qWEDmpsNt2WCjTo/qGkjZN+g3DgC7TuUlzXHvkS5kYAV2IAMNF1rmX1x8rKjsG9OzrWrur46ubEBGSgTbZ7Z1yc3duAI7BdwuhXr6nl54FiBDchAAU63YkcxM4HjCJyZwLEACViBDchAAcJtmJv12RiOtuWbo7mJobkNwwqcbnP1q9q+b47TbS5uVas/c+zAETjzg2MBErACG5CBcCtwK3ArcCO4EdwIbgQ3ghvBjeBGcCO4Edwq3CrcKtwq3CrcKtwq3CrcKtwq3BrcGtwa3BrcmrmRIQMFqEBzs/lgX6RdaN+k3ViABKzABmSgAE13RqzVqjWyKWcxv9EU1JCBAlRgB45A+x7tRtPthuhfxRFbzG8cgRbzG+2ILQIs5jdWYANiNDvcOkazYzQ7RnNgNAdGc2A0LeZXcwZGc2A0B0Zz4Ngs5m3hzsrWFlrZWpsrnNXK1hwJWIHTza5hrK7NUYAK7MARaDG/sQDNjQ0rkH2wrMSt2XKelbg5duAIXIE+DAuQgBXYgAwUYAwWI9AZgc4IdEagMwKdEeiMQGcEuhWzNVt+tE3gNlpIb7SOsn6wkLZFPqt2c2xABgpQgR04AtdnphdOXfsEttW1OTJQgFPXlhStrs1xBNrJfWOcmnmd3BdWYAMyUIAK7MARaJf5dlVhW785NqAdRTUUoALtKGwaWfgvtPDfOI/CFjttDzjHCrQ+s3Gz8N8oQHuQZtPeLv43jkC7+N9YgASswAZkoADhNuA2wk2uC1iABKzABmSgABXYgXArcLPwn+Uj1Qr1HCvQ3MSQgbMnbSHXCvUcO3COmy24WqGeYwESsAIbkIECNDcy7MARaJlgo7nZYVom2FiBDchAc7PDtFP+xg40tzmNrKjPsQAJWIENyEABKrAD4cZwY7gx3BhuDDeGG8ON4WZZw1axrahvo2WNjQVIwApsQAZON7Fxs6yxsQPNbSY8KwB0LMDpZiuRVgDo2IAa2PG7Hb/b8buWCTYKMClYy9hwBNqFwMbZMlvJsfI9xwpsQAYKUIEdOBytfM+xAAlobt2wARkoQAV24Ai0C4GNBUhAuBW4FbgVuFkmsOUmK+prttZmRX2OBKzAqTvrmKoV9TkKUIF9l2NU2z5uoxUObSxAAlZgAzJw9s4sdKpW6rfRontjARKwAq29ZGgKc0ZZ+V6z5Twr33MkoCmwYQNaP9hwW8RuVKC115puEbvQInZjARKwAhvQ3GwILWI3KrADR6BF7MayK7eqFfXtfrDz/Eb0jkWsrbVZUZ/jCLTz/MYCnEfRbRJYdG9sQAZON1uMsw3iHDtwunUbAIvujQVobnZAFt0bG9DcbOQtursNi0V3t0616LZFMysAXGgFgI6mOwwbkIECnLqzPqpaUd+aXFbU50jACmRg34WQddXsLbSavY1Wj8iGBKzABmSgABXYgSPQTsK2TGiVfI4NyMB58LZ+ZpV8jh04Aq2Szx4NrEq+jQSswAZkoAAV2APZK4jrqtnbaEdh/WvBu5GBArSjsK624N04Ai14NxYgAa3S18SkARkoQAV24Ai0mr2NBUhAOwobNwvejQrsQDuKGQFWnedYgAS0am41bEAGClCBHTgCV2X9QhuLhQ3IQAEqsAP9fYY6rgtYgASswAa0tyeGoQAV2IEjcL03s9COwsTsxDrWvyqwA60fZrRYJZ9jARKwAhuQgQJUYAfCrcKtwq3CrcKtwq3CrcJtxjHP6sdq5XuOBUjAOtH+bMaxIwMFqMAOHIF8Ac2NDAlYgQ1obtVQgArswBGDtaJ7YQESsAIbkIGYD4L5oHYUzbAACWhHwYZ2FGLIQAEq0I5CDUdgv4AFON2KjdCMbrZFdSvUc2SgABXYgSNwRrdjARIQbsPc7DAHAwWowA4cG5sV6jkWIAHNrRtOt7nU3qxQz1GACuzAEThj3rEACViBcCvmVg0FqMAOHIF0AQuQgBVobmLIQAEqsANHYL2ABWhuw7ACG5CBAlRgB47A9V6dNX29V7eQgBXYgAycutX61zLBTEzNCvUcTcEmwXpXbiEDBajADhyB6125hQU4+2GWlDYryeNqLZsx76jADhyBlgk2FqAdRTOswAZkoLlZcywTbOzAEWiZYGMBEtDcbOQtE8yzdLOSPEcBKrADR6BlgjUWAyM0MEKWCTY2IAMFqMDuuPZCm7cPbe2FtrECTXcYMnDqtqWgwA6cRzEvF5sV3zkW4DyK+d5Xs+I7xwZkoADNTQ07cARazG8sQAJWYAOa7sxya3+zbkdhEdvsiC1iNzJwtoytoyxiN86W8VIYgXae3zhbxtYPdp7fWIENyEABKtDcquEItPP8xgIkYAW2OGI7o7N1tZ3RN45AuYCmy4YErMAG5L2TRrOCOkcFduAItJ0eNhYgAa13xFCACuzAEWhxLDZYFscbCViBDcjA6SbWZxbHGztwBFocbyxAAlZgAzIQbhbHYiNvcbxxOFqZHc+VvWZldo4ENDc2NDcxNLduKEAFduAItOjeOHXnslCzgjpHBgpQgT3QTqxzhahZtdtGO7GqtdcCci7fNKtrc2SgABXYAy1w1NprgbNxBFrgbCxAAlZgAzJQgHBjuDHcBG4CN4GbnRbnWlCz7c3YsrIVnXG34bYT4MYCnArdhttOgBsbkIEC1EALkW4DYMHQbQAsGLq1zIJhowBNwbragmHjCLRg2FiABDQ3O2ILho3TbdjBWzBsVEcrJOO5itKsZIznIkmzkjFHa68YmkI1VGAHjkCb4HMpolkhmSMBzY0NG5CBcCtwK3ArcLPT18biY2GFZI4V2IAMFODwIbTisDWEVhy2BsuKwxwZKD4WVhzm2IExmlYc5liA5ONmxWGOLQarMVCAI4bQ4m2NG2M0Ld7WEFq8rY5i9C+jfxn9a/G2BkswmoLRtHhbgyUYTcFoCtwEbgI3gZtgNC0YhnWJBcPGEWjBMKx3LBg2ErACG5CBAlRgBz7cZN6YN6uwcixAAlZgA/JENRSgAjvQ3OY0sgorxwI0t2FYgQ043eZtdbMKK0cFduB0m291NqulknlT3KyWyrEBGWi6zdB02dB0xXAEzpOPYwGamx1xrcAGZKC52bHNGBKy9s4YErLmzBgSsubMGBKyP5sx5FiBDchAASrQ3KzX2whkc7PmcAESsAIbkIECVGAHjkCBm8BN4CZwE7gJ3ARuAjeBm8BtngvFbmltYzBHAlZgAzJQgFPX7pKsBMuxAAlYgQ3IQAEqsAPhNuA24DbgNuA24DbgNuA24DbgNsLNSrAcC5CAFdiADBSgAjsQbgVuBW4FbgVuBW4FbgVuBW4FbgVuBDeCG8GN4EZwI7gR3AhuBDeCW4VbhVuFW4VbhVuFW4VbhVuFW4Vbg1uDW4Nbg1uDW4Nbg1uDW4NbgxvDjeHGcGO4MdwYbgw3hhvDjeEmcBO4CdwEbgI3gZvATeAmcBO4KdwUbgo3hZvCTeGmcFO4KdyQSxi5hJFLGLmEkUsYuYSRSxi5hJFLGLmEkUsYuYSRSxi5hFcuqYYNyED1jMgrgSwcjnJdwAIkYAU2IAMFqMAOhFuBW4FbgVuBW4FbgVuBW4FbgVuBG8GN4EZwI7gR3AhuBDeCG8GN4FbhVuFW4VbhVuFW4VbhVuFW4Vbh1uDW4Nbg1uDW4Nbg1uDW4Nbg1uDGcGO4MdwYbgw3hhvDjeHGcGO4CdwEbgI3gZvATeAmcBO4CdwEbrjsEFx2CC47BJcdgssOwWWH4LJDFG4KN4Vbh1uHW4dbh1uHW4dbh1uHW4dbh9uA24DbgNuA24DbgNuAG3KJIJcIcokilyhyiSKX6MolYtiADDS3bqjADjS3eYGsK5csLEACVmADTjdb5rYyMEcFduAItFyysQAJWIENCDeCG8HNckmz3rFcstByycYCJGAFmls1ZKAAza0ZduAItFyy0XTZEAqWHzZ2oClYp1p+2FiA1l4bN8sPGxuQgeY2DBXYgSPQMoEt1lsZmNiyvJWBOSrQ5s76sxG4Yn5hARKwAhvQ3MhQgArswBFoMb+xAAlYgQ0Itw63DrcOtw63ATeLeXtKYGVgYiv/VgbmKEAFduBwtDIwxwIkYAU2IAMFqMAOhFuBW4FbgVuBW4FbgVuBW4FbgVuBG8GN4EZwI7gR3AhuBDeCG8GN4FbhVuFW4VbhVuFW4VbhVuFW4Vbh1uDW4Nbg1uDW4Nbg1uDW4Nbg1uDGcGO4MdwYbgw3hhvDjeHGcGO4CdwEbgI3gZvATeAmcBO4CdwEbgo3hZvCTeGmcFO4KdwUbgo3hVuHW4dbh1uHW4dbh1uHW4dbh1uH24DbgNuA24AbcklHLunIJR25pCOXdOSSgVwykEvGyiVsWIENyEABKrADR+DKJQsL0Ny6YQU2oLmJoQAV2IEjcOWShQVIwApsQLgR3CyX2DNLq2tzHIGWNTaawjAUoClY/1p+2DgCLT9sLEACzvbaQ0KrYHNkoADNzYwtP2wcgZYf1Npr+WEjAaebPVC0CjZHBgpwus0K7WYVbGJPHK1WTeyJo9WqOVZgA5quGpquHYVlAntWZ1vNiT1dt63mNlom2FiA082e4FkFm2MDMnC62dMdK1sTe7pjZWtij0isbE3skY6VrYk9WbGyNccKbEAGClCB080eyFjZ2kaL+TWNBmaUxfzGBmSgADFTB2bq8JnKVqvmWIAErMAGZKAdUDNUYAfaAfFEi/mNBUjACmxABgpQgR0IN4Kbxfx8PsRWq+ZYgQ3IQAEqsANHoF0/bIRbhVuFW4Wb5YdZ0MzXulKohiNwXSksLEACVmADMlCACoRbgxvDjeHGcGO4MdwYbgw3hhvDjeEmcBO4CdwEbgI3gZvATeAmcBO4KdwUbgo3hZvCTeGmcFO4KdwUbh1uHW4dbh1uHW4dbh1uHW4dbh1uA24DbgNuA24DbgNuA24DbgNuI9zKdQELkIAV2IAMFKACOxBuBW4FbgVuBW4FbgVuBW4FbgVuBW4EN4IbwY3gRnAjuBHcCG4EN4JbhVuFW4VbhVuFW4VbhVuFG3JJQS4pyCUFuaQglxTkkoJcUpBLCnJJQS4pyCUFuaQglxTkkoJcUpBLCnJJQS4pyCUFuaQglxTkkoJcUpBLCnJJQS4pyCUFuaQglxTkkoJcUpBLCnJJQS4pyCUFuaQglxTkkoJcUpBLCnJJQS4pyCUFuaQglxTkkoJcUpBLCnJJQS4pyCUFuaQglxTkkoJcUpBLCnJJQS4pyCUFuaQglxTkEkIuIeQSQi4h5BJCLiHkEkIuIeQSQi4h5BJCLiHkEkIuIeQSQi4h5BJCLiHkEkIuIeQSQi4h5BJCLiHkEkIuIeQSQi4h5BJCLiHkEkIuIeQSQi4h5BJCLiHkEkIuIeQSQi4h5BJCLiHkEtvCTuZrR2xb2Dk2IAMFqMAOHIGWSzYWINwYbgw3hhvDjeHGcGO4CdwEbrHCybRyyUJzG4YMFKACO3AEWi7Z+HDT+SoRW7mhYwW2iWTIQAHqRGvZzCWOI3DlEhNbuWQhASuwARkoQAV24Ai0rDGXrtmKEB3tKGzCDAYKUIEdOBytNNHR+owNCViB5iaGDBSguTXDDhyBljWauVnW2EjACmxABgpQgR04AsmOQg0rsAHtKLqhABVoRzEMR+DMDzqrvNj2uHMk4HSbtV9sZYyODBSgAjtwBDZzI8MCJGAFNiADZVcp8ipj7DYW7OWGbLvZORKwAhuQgQLUXY/Iu7hx4QhcxY0Ly6735FXcuLECG5CBAlRgB45AxcgrRl4x8oqRV4y8YuQVI68Y+Y6R7xj5jpHvGPmOke8Y+Y6R7xj5jpHvGPmBkR8Y+YGRHxj5gZEfGPmBkR8x8u2KkbdaS0cCVmADMlCAMfLt6sAY+VYuYIy81Vo6VmADMlCACuzAGHmrtdS5lR9braVjAzLQxsKOwmJ+YweOQCv0n4tmbLWWjgSswAZkoAAV2ANXdNtRrOheWIENyEABKrADRyBfQLgx3BhuDDc2t2EoQAV24AiUCzjdyHp9xrxjBTbgdCPr9RnzjgqcbvMVRrYCSyWzmGd/xwIkYAU2IAMFqMDpVm2ELBMstEwwy5TYyi4dCViB061a0y0TbBSgAjtwBFom2FiA5mYjZJlgo7lZ71gm2ChABXZHq7XUWUTAVmvpSMAKbMBpMR/Vs9VaOiqwA0fgTAqO022WC7DVWjpWYAMyUIAK7MARSBcQbpYq5ht/bLWWjg1obtVQgAo0NzY0N+tJuzxo1jt2ebCRgBXYgAzsc/MWo+G0Po5lVIIoqDpZBM+qA7ZiR0cGPg6FrM3r43NGPWg4rS/PGZUgUxyGsxvsyt1KF+v678NpfY7C6PHXNl/XNnSLalAL4iAJMhMbLQvDjbOv2YbIwnBjAc5m2n2UVSEqm5iF1sbZTvvvFllsDbXI2kjACmxA9i4Z0Z0junNEdw7vzvXh10XVO9GqC1cnWnWhzsdibNWFjnaoc2CtutDRWtoNHy2dxS28d4gzakEcJEHqZGHB1hALAHsOsTZ8M5u195ORBM2/tqbZZm+LhpNt9baoBFGQmRTDBpxTc74eyFYi6KiBdgE8Xw9kK/tTscbbyXDjbKd1rZ0LV8fYuXBjB45AOxeK/ZmdCzcSsEaHWyRtZCDcGG4MN4abwE3gJnATuAncBG4CN4GbwE3gZufCjWVPdSv6W9PXiv4cG5CBEmjnKbEmWDBt7MA5x20W2eYvi0oQBdWgFsRBEqRBPcg91sdUF5UgCqpBNj8WMlCA82Dmk1a2EjzH2YnzaS9bCZ5jARKwAhuQgdNtPrZlK8Fz7MDpNh/xspXgORbgdJsPc9lK8BwbcGbN9asSpEE9aDjZDu2LTFEMraVqaC219tsN6cYRaPG4cbbUrl5tDzbHCmxABs6mLppm3XreonTjCLQona8MstXeORLQzKwvLEo3mpkdmkXpRgXO7GVNWFuuT1o7rhuVIAqqQaZonWUx160vLOa6TS27/txIwAqcLR12gBZ0GwWowA6cTbWjtk2dFpWg2VQb2LXrslEL4iAJ0iAzWTgC7eS4sQKtmWZpl5IbZ4daK9e+6Q9ae6stmj1iN4FWU+dYgdYjashAs+qGCrTGDsOHV7f1OKup67a4ZzV13VacrKbOsQIbkIECVGAHmpu1l8xNDM3N2kvmZo0k07VGkgAV2IEjsF7AApxitsJgxXGOCuzAETgj1bEATcw6qtmfkeEI5AtYgPNetxrVoBbEQRKkQT1oONmK0KISFB4SHhIeEh4SHhIeEh4SHhoeGh4aHhoeGh4aHhoeGh4aHmuHJaMa1II4SII0qAcNp7WzklEJCo8RHiM8RniM8BjhMcJjuMe4rqASREE1qAVxkARpkHtYgVi3O30rEOu2bGAFYn3uksRWCtbJfrcaVkMGCnBOa7tUtpouuxBem5IZ2Wvdi0oQBdWgFsRBEqRB4dHCY871TgutjWpoq15GGtSDhtNa6zQqQRRUg1oQB4WHhIeEh4SHhoeGh4aHhoc9M7UhsEemiyRoLqHbqNjz0kXDqVsvdEPrBVOcM7rb2dsKrxw7cATOWe1YgASswAZkINwG3Abchrk92itWg+VYgASswAZkoAAV2IFwK3ArcCtwK3ArcFtvexlJkAb1oOG0XvQyMkUytJauf7XaNKMeNJzWw0yjEkRBNagFcZAduKGdP6opNgJWoB2iGjJQgArswBFop52NBUjACoQbw43NbRgqsAOnW7NxmEHqON2adesM096sW2ec9mYHPwPVkYHTrZnxjFXH6TZXWsRKpnoz41VSaVSCKKgGtSAOmopzkUCsAKqzNdqCk62l8wzk2ICzpXO5Q6wAylGBHTgCLTjZDtDCkG10LQzZDtDCcGMHDkcranIsQAJWYAOaWzcUoALNbRiOQAvDjQU43WaOEytqcmxAW9I2kiANsqc/RsPJbtAWlSAKqkG2tmzEQRI0j0fMxC4AN45AuwDcWIGzR8QU7PS40RSq4Qi0q76NtlBkREE1qAVxkARpUA8aTnZftig8ODw4PDg8ODw4PDg8ODw4PCQ8JDwkPCQ8JDwkPCQ8LDbnQpFYCZLjCFTrLzEsQALaONgc1Aac83VNl3lCdVRgB47AeefW11ywaN443dTGzKJZrWUWzesoLJo3CtDcrJEWzRtHoN3BWXNtdXMRBdWgFsRBpjhj0wqKuv2rFRT1uemTWEGRYwMycLZ03seLFRQ5duAItDjeaDeLRpaOjabXvOMXKyfq8zZfrJzI0Vo7aYbnLAQWKwUaJjRDcZMEWZPWL3bgCLRQ3FiABKxAa5Tp2lXtRgF2b9UM1UUzUjfNNlv/zkDdVIOm+Lz5Fiv7cRTgPJRhHWXn1o3zUIb1mZ1bNxbgw6vMu2exsh/HBmSgABXYgSNwBq5jAcJN4CZwE7gJ3ARuAjeBm8JN4aZwU7gp3BRuFr/DppHF78YOtJ60kbL43ViAc1IMm34WvxsbkIHmZgNr8btmY7djs2HpI3BcwDlFVntnBDtWYAMyUIAK7MDhaMVAjgVIwAq0niRDBgpQgR04AssFLEACViDcCtyKHVsxVGAHjkC6gAVIwApsQAaamxmTAntgLUBTaIamwIYCVGAHWnvnjLKyH8cCJGAFNiADBajADoQbw43hxnBjuDHc2NzUUIDmNgw7cATO/DCKTaOZHxwJWIENyEABKnC6FRusmR826gUsQHOrhhXYgAwUoLnZwWsHjsB+AQuQgOZmHdUbkIECVGAHjsBxAQuQgHCz/DB3yxYrEXIU4HQj60nLD2QdZfnB0AqHxtwYTKxwyHG6zaUbscIhxwZkoAAV2IEjsFzAAoRbgVuBW4FbgVuBW4FbgRvBjeBGcCO4EdwIbgQ3ghvBjeBW4VbhVuFW4VbhVuFW4VbhVuFW4dbg1uDW4NbgZrlk1tmIFRk5ClCBM6+XhSNw5hLHAiRgBTYgAwVoRzGToxUOjbkoJ1Y45GjtVUMGClCBHTgCLT9sNN1uiP5VHLHF/MYRaDG/0fp3GBKwAhsQo9nh1jGaHaPZMZoDozkwmhbzqw0W8xsxmgOjaTG/2rBifmEHhhtfF7AACViBDcjAmDt8KbADoyd5xfwwLEACwg0xz4h5RswzYp4R84yYZ8Q8r5i3NhABK7ABGTjd5kKkWF2Q43Sz5T6rC9poMb+xAKdbNTGL+Y0NyEABKrADR6DFvK3dWcGQY0xw23ht2NqdbbzmKEAFxtSwjdc2MgaLMViMweIKbEAMFmOwGIPFGCzGYAkGSzARBRNRMDUs/G1N0OqUHDvQOsr6wcLflgetVMmRgBXYgAwUoAJ7YI8LQ9tMzbECp64tRtpmao5T1xYjrYzJsQPnUTQbbksKGwtwutlqpdUxOTYgAwWowA4cjlbM5FiABOR9N24lTps0yO6sjIaT3f8vMsVuSMAKtPav32WgAG0uGfWg4bSi3qgEUVANakEcJEHhQeFB4VHDo4ZHDY8aHjU8anjU8KjhUcOjhkcLjxYedk63tWKrlXJswGnD63cFOI1sXdmKpRxHoIW6LRBbsZSjuYlhBZqbDbSF+kYBmptRDxpOFueLShAFmaJNAwtnW+610qdhC7tW+uRYgAScLbX1U6t9cmSgABVo6zfWBjvzL7Qz/8YCJGAFmpt1kQX5RgEqsANHoAX5xgIkYAXCzYJcrOstyDcq0NysJy3IbSHbKq0cp5utX1qtleN0s/VLq7ZyZKAAFdiBI9DO/BsLkIBwK3ArcCtwK3ArcCtwI7gR3AhuBDeCG8GN4EZwI7gR3CrcKtwq3CrcKtwq3CrcKtwq3CrcGtwsMdiystVnOVZgA9q6SjcUoAI7cATa1f7GAiRgBdpRNENr74wLK7tytPaKIQErsAEZKEANtExg69dWerW7RHHEFvMbBahA619rusX8Qov5jQWI0exw6xjNjtHsGM2O0ewYzY7RtJhfzRkYzYHRHBjNgWOzmLdFdKvXcpxu3ULaYn7jcLSKLUdbkq6GBKzABmSgABXYgeY2J4GVbDmSD5bVaQ1b1Lc6LUcGClB9AHrpwBisThewAAlYgTFYHYHeEegdgd4R6B2B3hHoHYHeEehWyDXsiYEVcjkq0DrK+sFCulvLLKQ3FiABK7ABGShADbTTul11WaWXIwEr0B6m2NSw0/pGASowTs19ndgN15l9YQESsAIbkIECHPshkRV5bSpBcz2+GNWgFmTtt9logb9RgVabZzScbOF/0Wy8PWKxMjDHCmz7sZUVgm2SIA3qQcPJSmYWlSAKqkHhMcJjhMcIjxEewz2sEGxTCaKgGtSCOEiCNGgOt12f2cZkGy26NxZ/emcbkzlaj6lhAzLQBqcbKrADR6AF+sYCJGAFmtswZKAAFbieORXjAa5X4pKYEq8HT2TcEnNie7JvpEE9aDitp/pGJYiCalAL4qDwaOHRwqOFB4cHhweHB4cHh8d+QGjDuZ8QLtbEPfEA76eEi0tiSrx60Lz2k8LFnHj52kzcDwsX98TL10Z/Py9cXBK3xLNw3tRnAljU7e+KjVoviSlxTdwSc2Jrb1mamrgnHuD1DNDW8K2KLpgSL19r+2iJOfHytVk9NHFPPJzVyukeD9ou4/WAjozXs7hqzIklsSZeT//YeD3+k8n7+V83Xvrmu58ALq6JW2Lzrda2Iok1cU+8Hqla+8m8qrWNzGuumKlV1z3Y2kbmVc2LOLEk1sQ98QCvLLHZfJu1Z2WJzTHv9NqZYbEk1sQ98QA382p2jK0kpsR2jM2OvbXEnFgSa+KeeIDXHcDmkpgSJ19Ovit/NJsbK39s1sQ98QCv/LG5JKbENXFLnHwl+UryleS78kezebIqC5rNk1VasLkl5sRLX401cU88wKtCyIa0FyABK7ABGShADVx5pC0uiSlxTdwSc+LV7jmn1zc6r7m0pOsjnddcL9L1lU7nlth05qKTlpUvNlu/zMJFLStfbB7glS/mypOWlS82U+KauCXmxJJ4+bJxTzzAdCUuiSmxnRvtUFaKWN2zUsTm1G0rRczlMl3f9HQuiSlxTbwOS405sSTWxOuwzHeli8UrXWw2X7EhWulic01svusYV7rYLImXbzc2X7GhW+lCrMtXuhDrtpUuNlPipW/Hu9LCZk3cEy99O94V/mtKrvDf3BJzYgVbKeAaUSsF3EhAK101T7ud2MhAASqwA0egBfrGAlz9bH24Lhs2S2JNvPrBxnFdNixe4b65JLajsSG1u4mNDchAASqwA4cjrbLfhVaozYYNaAczFxSVVuxv1sQ9sR2MmuKK/c0lMSWuiVtiKxAXQwEqsANHoL3IsrEACViBDbiOhox74gFeIb95HU01psQ1cUtsR7NQgArswBFotw8bC5CAa3SasSTWxD3xAK+Q3lzWyyW6NhVbVINaEAdJ0H4dRdd2YouGk20mtqgEUdBqv820deZWG4915l68rvw328tJw5CAFdiADBSgAjtwBFp8b4Rbh1uHW4dbh1uHW4dbh9sK7LluprTO45tr4pZ49VI3lsSauCcewXXdD2wuiSnx8h3GLTEnlsRrefky7okHeMX+5hIjuCsFN9fELTEnlsSauCfGbKnr/D5XjLSue4PNLfFaNCfjtWpejTVxTzzAKwvMFRStKwtspsQ18fJV4+VrfbhO/Js1cU88wOvEv7kkpsQ1cUucfFeWGHbsK0ts7okHeGWJzSUxJa6JW2LznYtJWtcFwbB+WBcEm3viAV73CZtLYkpcE7fEnDj52kWDVQ+rVR0GD7BlG+eSmBLXxC0xJ7ZqqMvmjGrinniA+5W4JKbENfHytTnfObEk1sQ98QCPK3FJ/PC1S9H1xdhFLYiDJEg3WcXhQ2fxanM3boktX65fEaACO3AEWsHBxgIkYAWurhjG1hWz4FStlDB4gO2WwbkkpsQ1sR3OLExVqygMlsSaePmS8QDXK3FJTIlr4pZ4+Vbj5duMNXFPPMDtSlwSE4appeFrafgaJ5bEmrgnHuBVari57h0KdG1dtpGB66DEWBOvg1oiAyxX4nVQNgGEEtfEdlBkA2R5w1kSa+Ke2HzJOm3ljc0lMSWuiVtiTiyJl/7Mn2uTsmHjvMLdluPaCvfNmng10+JghfviFe62fNdWuG+mxKuZ1j2jJebEklgT98QjmFdKsGU9q0gMpsQ1cUvMicW7wQoQH/88R8IqEINLYkq85Mm4JebEklj3LiG6NijbOALt3cKNBUjACmxA6y67fueVEjYP8EoJm9fxNGNKXBO3xLx3hVGODWKU1wYxCztwBK4NYhYWIAFXP7GxJNbE63jEeIBXyG9ex2Oaq7548zoe66NVYbyZEy9fm1IrG2zuiQd4ZYPNJTElXoXNNr1WNtjMiSWxJu6JZ1/aagmvTZtM3faPsfURq0N0ZKAAFdiBI3BtnGa9tTZOW0jACjQ3a5ntX7hRgArswBForyFuLEACTl1bG+OVD5oF2soHm3viESwrH2wuiSnxGhgybok5sSSeB2RLQnsztoUjcG3GtrAACViBDcjAdTjVeIDXpcPmdTjNmBLXxOtw2JgTr8MRY03cEy/fOciy8sTmkpgS18QtMSdevt1YE/fEA7wuHTaXxNaXdogtJoc0TA5pmrgnTpOD0+TgNDk4TQ5Ok4PT5OA0OThNDsbkYEwOxuQQTA7B5BBMDsHkEEwOweSw0zjZ5bOVIwZr4g5e52i7zJF1jl68ztGb7fCH9eg6R2+uiVtiTiyJNXFPPIJ1xeTmkpgSL505WXWddOerlKrrRLv/fbVNjVfbujEnlsSauCce4BVgm1fbhjElromb9fNlvMalGK9xIeM1LtW441hWgC2u6RhX8NgSiK7g2SyJNXFPPMAreDaXxJS4JjZfW0pZ9X7FljFWwZ+zJu6JzdeWOlbRn3NJTIlr4paYEwt4nWBtaUTXidSWPXSdPLvNh3Xy7NaH6+S5uSce4HXJvHnp2Fxal8abl47Nh3XrbMsbuq6Nh/XVujberInXWFv/7Lgz3nG3uEB/x93695q4JebEgn5Ycbe5Jx7B/cLx9nXOs2Ps65y3Gf1gJXGPOxD7W5v/NHduUiuKC26JObEktvlvt1NWA/dg068lMSWuiVvipd+NJbEm7okHuF2JS+LlO4xr4paYE0tiTdwTD7DNf7IyCaucC66JW2JOLIk1cU88wBYjzslXkq8s32LcEnNiSayJe+KBcdE0pprGVNOYrvORlYhYhdyDqzElrolb4tU2m0tdEmvinniAx5W4JKbEy9fm+WiJObEk1sQ98Qi20rl9vFY892Ax5sQSx2jlcsE98QCXdSxqXBJT4nUs3bgl5qSTfEvyLcm3JF+6EpfElLgmbomTLyWvFfu2dLeK4pxr4pZ4nVvtWFbsb9bEPbG139bkxor9zSUxJa6JW2JOLIk1cU+cfDn5cvLl5MvJl5Pvindb/1ulcGRre6v8jWxNbpW/ObfEnFgSa+KeeMWyjcuO5cUlMSWuaI+2xJxYEmvinniAezrGlR8m91UeRnNNpq/ysM0rFjaXxJS4Jm6JObEk1sTJtyRfSr6UfCn5UvKl5EvJl5Lvjoth3BMP8Dpvbi6JKXFN3BJzYkmcfGvyrcm3Jd+WfFvybcm3Jd+WfFvybcm3Jd+WfDn5cvLl5MvJl5MvJ19Ovpx8Ofly8pXkK8lXkq8kX0m+knwl+UryleQryVeTryZfTb6afDX5avLV5KvJV5OvJt+efHvy7cm3J9+efHvy7cm3J9+efHvyHcl3JN+RfEfyHcl3JN+RfEfyHcl3wNe2nwsuiSlxTdwSc2JJrIl74uRbkm9JviX5luRbkm9JviX5luRbkm9JvpR8KflS8qXkS8mXki8l35SvSspXJeWrkvJVSfmqpHxVUr4qKV+VlK9Kylcl5auS8lVJ+aqkfFVSviopX5WUr0rKVyXlq5LyVUn5qqR8VVK+KilflZSvSspXJeWrkvJVSfmqpHxVUr4qKV+VlK9Kylcl5auS8lVJ+aqkfFVSviopX5WUr0rKVyXlq5LyVUn5qqR8VVK+KilflZSvSspXJeWrkvJVSfmqpHxVUr4qKV+VlK9Kylcl5auS8lVJ+aqkfFVSviopX5WUr0rKVyXlq5LyVUn5qqR8VVK+KilflZSvKOUrSvmKUr6ilK8o5StK+YpSvqKUr2hfXxXjdZ1Dk/f11eKSmBLXxC0xJ5bEmrgnTr77+oqNS2JKvHyrcUvMiZevGmvinth850OVvorunEtiSlwTt8ScWBJr4p44+bbk25JvS74t+bbk25JvS74t+bbk25IvJ19Ovpx8Ofly8uXky8mXky8nX06+knwl+UryleQryVeSryRfSb6SfCX5avLV5KvJV5OvJl9Nvpp8Nflq8tXk25NvT749+fbk25NvT749+fbk25NvT74j+Y7kO5LvSL4j+Y7kO5LvSL4j+Q74rjJA55KYEtfELTEnlsSauCdOviX5luRbkm9JvgX5oe78I5N3/llcElPimrgl5sSSWBP3xMm3Jt+afGvyrcm3Jt+afGvyrcm3Jt+afFvybcm3Jd+WfFvybcm3Jd+WfFvybcmXky8nX06+nHw5+XLy5eTLyZeTLydfSb6SfCX5SvKV5CvJV5KvJF9JvpJ8Nflq8tXkq8lXk68mX02+mnw1+Wry7cm3J9+efHvy7cm3J9+efHvy7cm3J9+RfEfyHcl3JN+RfEfyHcl3JN+RfAd8V0mgc0lMiWvilpgTS2JN3BMn35J8S/ItyXfnn2LcEnNiSayJe+IBXvlqPuzvq5bQmRIvXzJuiTnxiHzYdi5aXBJT4pq4JV6adrz7WmixJl7H0o3Nl+1YVi7aXBJT4pq4JebEklgT98TJd+Uitr5auWgzJa6JW2JOLIk1cU+Mc1ZL10ItXQutEkJi66uViza3xJxYEmvinniAVy7aXBInX02+mnw1+Wry1eSryVeTb0++Pfmu/CN27Cv/bObEklgT98TmJTamK/9sLokpcU3cEnNiSayJe2L4rvpDmu+79VV/6EyJl28zbomXrxpL4uXbjXvi5Tvv41ZhonNJTIlr4paYE0tiTdwTJ19KvpR8KflS8qXkS8mXki8lX0q+lHxr8q3Jtybfmnxr8q3Jtybfmnxr8q3JtyXflnxb8m3JtyXflnxb8m3JtyXflnw5+XLy5eTLyZeT78pR87W5vgobnTVxT2y+anN15ajNJTElrolbYk4siTVxT5x8Nflq8tXkq8lXk68mX02+mnxXLpovzXVe+UctBlf+2bx02FgSa+KeeIBX/tlcEi9NMU5jvXKI9f+qWXQuiSnxarMat8ScWBJjjsnVE2OOScohknKIpBwiKYfIyiGrPYUTS2JN3NGelUMWrxyyOfmmHCIph0jKIZJyiKQcIimHrKLG3QZK/VxTP9fUzyuHrPbU1M819XPKIZJyiKQcIimHSMohknKIpBwiLY3vyiGbUz+31M8tje/KIZtTP6ccIimHSMohknKIpBwiKYesckfndLwph0jKIcKpnyX1s6R+3jmkG9fE63hNf+eQxZJYE5vvrBPrsnLI4pVDNpfElLgmbok5sfnO2rO+ayw3j4hlWflk1ll1Wdc2mylxTZzmUk8x29OY9jSmPY1pT7EzUuyMNKYjjelIYzrSmI40piON6UhzOOUoGZhLq1aTZt1d15WLNrfEqw/FePWhGmvinniAVy7aXBJT4pq4gXdBs7Vz1VvOutm+6y3nlhJ911tuLokpcU3cEnNiSayJe+Lku2oy55YVfddkbqbENXFLzIklsSbuiQeYky8nX06+qybT7ol2TeZmTiyJNXFPPMCrbnNzSUyJk68k31XDafdNu1aTbV6t15s2t8ScWBJr4p54gFdt5+aSeHnZvFqvQs79K/qu/9wsiTXx8rJ5uOo/F6/6z80lMSWuiVtiTiyJNXHyHfDt15W4JKbENbH52r3VrgvdbF52v9NXbbbd1/T1QtRmSmyac6+P3led9mZOLIk1cU88wKtOe3NJTImT1zp3D2v/OndvlsSauCce4HXuHnbs69y9mRLXxC0xJ5bEmrgnHmBOvuvcPaxv17l7c028fO3Y17l7syRevmy8fMV4+c45v2tKh82Hde7eTIlr4paYE0/fepmXxbVzTzzAdu52LokpcU3cEnPi5KvJV5NvX/p2vJ0SV/BY/96Na+Lla8c4OLEk1sQ98Qi2TRdLnfV+fdWOVqt/W7WjzjVxS8yJJbEm7okHuFyJk29JviX5luRbkm9JvmXpz3m4akTrrBvsq0Z09fmqEXXmxKvfmrEm7okHuF6JS+Llu7gmXu03r8qJJfFq/4yFVSNaZw1zXzWizqv9dlyNMXZNEmvinnjpz/mzakSdS2LC3OCauCVOvpx8Ofly8uUBXnFHiwd4xd3m9Ts2pjrA/UpsbSYb6xU7m2tiazNZX9l509naTDYudt507omXr43LuBKXxJS4Jm6JOfHytfFdsbm5Jx7OY2116FwSx9wY145BMhYfx3HtGFzcEw9wuRKXxJQ45sBYtazOnFgSq8fdWLWszgNMV+KSmBLXxC0xg9d141zDHKsOs8y3SMeqw3SWxJq4J17nd+vbdX0o1rfr+nBzS8yJJfHSt35b7/5sHuD1Gv3mkpgS18TL1/p2XWdulsSauCce4HWdubkkXu9hXcYtMSeWxJq4Jx7gdZ25uSSmxMl3JN91nTm3yBqrxtJZE/fEI3jVWDqXGJdVY+lcE2NMV51kmWt0Y9VDlrlGN1Y9pDMnlsSrbWzcEw/wum7cXBJT4pq4JV6+zVgSa+KeeIDX/ebmkrjiePd7f2KsiTuOcb/fZ7zf71tcEq9jsf7c7/ctbonXsXRjSaxJJ/m25MvJl5PvupfcnMaO09hxGjtOY8fJl7fX//zPP/3257/+2x/+/qe//uVf/v63P/7xt3/+7/iH//ztn//Xf//2H3/42x//8vff/vkv//XnP//Tb//fH/78X/ZL//kff/iL/fz7H/72+K+PGf3Hv/yfx8+H4P/905//OOl//gl/fT3/08eAzkUF+/PHgLYSEo9p/kGkPBdp86Vrk3g8qwsBO0D8PT3/+zpzq/394/k5GiB6/yjsoxzrKOojoT49ivZcZN40LIWCv2/17p8/DsKbUB/LYmgBlQ8ScpDooTDQBNW7fy/FZ8Jj/Tb+/nEW+yDQD/3YxBUeM78/lRinbpgXD7sbtD6VOPWkbTe5JB53EU97shymJNFcjzINqjXNh8YfNU7TskYzBrqzfBqP44EMKFz9+YEcNB5Pn3xIHggNoY8SfBrVeY+6R5XpqcRhZqn6oD5WGlKE8m2F3vwwHvfZzxXuHoY+P4xTZ+rlEfbA8UyCDqmGWvc8QZzS5WeJ8m5X0GFmkm0MtxpRLqTc9qkR9dCIed23GjH0eSNO+dJ2wjOJeS2GSK9y/0Bsz5p9IFyeHshhYhGS5vVU4BxhQ2JSpNT/eUT7+0nvpNHszeN1FiV5fv6o1zF/U4RI6g2ij8dSD7OT43rg8bA1KZT7E6OWmBhV+enEqIfp+VhQ8Pn5WENIGp8uCuqhHY/HcBElSilhfGNM1IP9cY2jz8fkMD9LZ7+6KY9lpKTxqTf0oMHUkfsa51NJ/6jSf2B2jHdnx/lY5JJoxuNB6tNjaafzu91T7MSRrhGI2kcNend+HGfpzRR41LgZLY3fj5Ymb/fGcWRHw+XjyNdMn0f2lEvtDn3l0qJ5ZD9pjNNJunrMUUvn2Nm/WYMPubQJYl/SDPuscWwHc4mLhXFox2GWCnLQ41KQn2ocR+ZxfvIr0TI/df50ZLidWhIzRB5LhM81DjO1lctHphWilzS4kPfIA9trx1Jr9Gorh/7opwuHNuLSXF7UUMUVqdJrGh1XtY+Hnc/PDccZolePGfK43H+qIvRLzw5a4uavzP3en7fjMLpzxyTczT8etj3JZsK/NB8+npBHPpzbYjw/Fv2lfTpLq70ds7T3eTtOuaxqjzvqkVvyMQ/p9W6fHlvRYo2DWruetuJ4RaaxNlAeZ86nV2RaT5m9jsjsH+L2k8ZhlrYedw2tf9DQ2xrcoh3c0qLR7zTk/etCfXuWnnu0x9wQKq+NilRoHEaln877V49RKR+uTvkb7YhFgvp4lPS8HYdc+lgKj4TcPszSj+3o9bSCFWfKWrs+1zi1o6WEXA4ap1xqT6d90URe6tPHg2/c6PfXovbx8HDEtWXT5+NyuosaFBPkwWM8yWLHdlgF1R6Xw1wfp1xqH7XYd0AfzpOf1moPd1EqcSiqH+4q72vMmuZYzuLyXKO+n4FG+5UZ6HFJqDEqqq/NsBp3YrXReD6y+uZjgGMjWtyHVcmL358bMU6PVHDHUGse1nZfY7SYoo8nw081ynWYX/NjmBFv1yXpLvvTDCvXIY3ZN7bXHXK6uK113A84jsvsx3nm+US3O5xDl8QZ6krZ9PMi9nXIpjUWf9v1fOnWvj/x/PFIiVVs0pb6Qz+JnK4rH6vQEbYPrk/XHcb5iq7jHvk0SU7LUo18pjGnhf3fPe4p1/tjc3rudHNsTo+dbo9NqT8xNuelcRbc4T592HG6xsXjq6bCh2d5p+eiV5xiHivq+jzyjiK20+ISoUoHkf7+o7Qy3n6WdpK4+TDt9pEcnqbd7tJWXxwX28p9ixyuH8rpkcPdB9f2EZB3n+KcD4clLjHleDh6miJx//DAdnh6fRLp5B079+w9iIz3J/zpqdTNCX+SuDnh6/vPTEt9+6FpOT2Uqvb1gZ3LOC/nXi+OyiF4z9NDYo718eIc62VgbPMN92eR43MpbnGnq1d9WmlxjrsRizqP9e3DOaJd78/205Opm7O9vV0gcP9IXk3vI25E2nXJoUt/oPikvV990t4vP2n8q7uUcX149dfOmO0qsUJ1tcO48Okx/926Inp/bLm+PbYnibulRfT+2J579N2LZb7iyfjjKe6hXuz0NEgobpel1UNK5sMJZhTGzcP1NCOfElC9Yj13LiCkhnwuLJXyfvVEOT2WurvgfxZh+8TAniNUnz93LKdHU5UGlv5Ke7J4eJaouMTMq7qfJU4ppEQrGpXnEuf+uFmTYq8YPH8khGXMx7Xu05b8QF1LOT2aurd8eJSQWGwXGi9KRCqTlNh/J3HsDb4qpik9741zl9JIc/3Qpfz+SvkX0+xuuVA5PZ+6Wy9krwm89/jy3A6Kx+yPvrwO7TiJcEwTeix3PRc5d6xqpFbu1/Mn7eX0eOhmPjtK3Mtnvf3ifPahP0o95LOjzN0iKPsK0eE2EU+quKUhflmk/4CI1FdF7hV1ldOTpseFjUQFgj6vhLJPvj1/uBKlYbWnHPt7kdPzXR3xPLOny/jvifQo/KOeypi+K4KWEP+ASL0OIqfRuVnrZpF6uIbucQ2t47UhbkiPjbW/Ok861hOu9mKf3KxDpNOTq4+FiO21jm1DfbK10fk1kbuliN84nMMQ384n/XlSotPzq7tvUVynatUaDwVrron8fUNOTwQ4igCV81LcJ43Tw6vaSjTkcTZMt2yfNE4Pr64rla205xqn89/j8WdcjT96lZ8ezblb4176w6P433frUWRgbMbhzHU8n0uJWfL4xcNlEh1foMJiqz5fe/6iIaExG9IPDemn5+BxYX/ladK/1ZS75cREx/ule/XEdHqZ6m5B8VHkbkXxuSWt+C3kA/uLLanRs/yxBuU7HXuzuJlO71XdrW4+i9wsbz6L3Kxv/uJwenSsdHlRBBUCPJhfvEN4LMvFK9fS2usyWH95jJW+KnO38Jvq29VXR4l7yydniZvLJ8e1wrsF6HR8pnWzAp1OL1vdfIHti3agBr2MtDr2SeT0PGqUWKQf5ekN+lkCuX7M8+8rN+hao9zgwTpenPCa1vqVy3MZOj0NurfucZa4te5BTX/tusfH/qA3uhVPcbm+mtUUN28Pluv56JyexdwcnaPEvdE5PZj6kdH50B96vT46mmTKqzJ332ghfvtlgaPEzZPFUeIHThbz43/eH/ODZ8/74/SQ694zkKPEI0PjokKFr9dENJ37VMqLImmOaH8t13fCfcr8AtCL8/X2m08k+stliOJ+lOqVb2r5RZFCL4rcfJeLtLx9dXJsx823uc4iHNsPEUt5TeQxHrHcd31YUPq8xUl5/zkznd7GuvtmGZ2eEN3ekOIkcvf9tKMI2+bU65bpsc78okiNiheupM9F+vvXBP39a4L+9jXBF70Ri5/cCh9643DxKVcsTT9OwuMgcry9j7NwuZ4u9J2bEU9SpHyoMfvOsZSoZXoskpVXReKRt5TOL4v0EDm8jnke35vvdNLp+cWPiNytrKD3X8w6Sty82htvLw2ce+NmZcUXXXqvsoLOL1bdq6z44kRz74Xbs8jNN13r9QOvutp+xM9z8713XY8i7YqXEdp1ePm3Xm8vDZwlbp1o6qXvn2iO793ce+X2LHLzrcqzyM03Gs8i2P2t6qsTvqLK8yHyvCW1nN93vfW6Si3tJ67xjqNz733VWt7dt/KocG/nylr6T/TpD+xeWU+PUR/rrHG3SC1fN38sz6qnB0E3+/TUjJtv8J5FJLawLF2uF0Vuvgdc6QeqCY8iY8S94hi5IONT6fwXIr2FSGrHd0XiYuK6UrXZt1TuvxxdT69X3Xs5+ijxeAyL48k9+1nki8ORdDg6Xu2VglLtR9/SyzIx0PNheT907q+XoYL3pEs9jdJJhGK98rGycb0oUiXCufaDyHmDXhTftHLITqe3nG5uH1rbT+yZeRS5eWvwRUvu3RrU1n4gTR4H5+Y7+fX0ytXdd/JrO+6hFZeg8xkGDuZzl7z/0nZtb7+0fZS495rS/SPRw5GcehRv9ZUxnm53W08PtnjE4hEPGS+249ZuC5Xf3gnDaskON7Ax1T+UI37abeEsoijI11ZeE3mc8GIdux32fTi3hCu2p5ZXRW7uQFGPi+G3d6D4Smakd9GGvCgzFxaiDqKleqbvykSp9JQ8bEx87OA6MNRFXhylhqeGufzn9yLH/Tjx6YZ6SErnMtqY/OXqLyWDDxc3qcb5s8bp3ambyUCPNypRfv54mJvrta/77bjZpeehjVLPxyjXFwOwXBUlSFd7NQALNisr85MtL8vgmrx82Pngs8wX1+SsuJjOcfz5Yvr0JtfNJbqjxL0lutNWgz8gcW+V76suTbduheVpl36xWHhvb73af+Lq9SRyczGpyw8sJvUfeQh73B7n3laBtZ8KCW/uFVhP+58px0lLpciLIjd3HDyK9BLrSb1+KNf+jghH3WtnqgeRt9/m/qIdcf/Z+bBxSR3yfjvk7WR0fMnoXjI69sbN3STb9atF7q4LtOvtDbGPEveefZ4lbj37PPfGzQWOL7r03gJHO+46ePsUcdyY/95eju302tbNtYlW3t9xqJW3dxw6Stxbm7h/JM/XJs49em9top0+E3VzbeKLdtxam7AXft67HWmnR1p31ybOIjfXJo4id9cmzi25uTZxFrm5NtHoR3bH/Erm5trEWeb22sRXMjfXJs4dfHNt4ixyc23iGEH3bqSPgXxzbeKscW9top02H7yZDE57D95dmzi242aXnof23trEF3P17trEFzJ31ya+krm5NnG+zIo3vuTDPhnfulKLGkRpTyW+qMi69w2Edvo01t2PIBxF7t2Ht/YD+7q29gP7up7Lyyi69bGaUp/2yFlEsdft+PAq+bdq1O6OzXj7yelR4/Yd0lHk7o3FuSU3byy4/sCNxfUDX8tozL9Y5O43N84iEt/AJZFXRTgS4yMjtYPI+IFMINf7meCLPombFNLr0CdfbBMVV9QPTlX88i0RVP88VufaU5F2FmlJpL8icm/l58uDudeO03MkxTebrw+7QXx6F+hYKn7rPP5Ftfmt8/j5tSbc/PGHHeu+826U4G0xGfVFkR4bDdC4+DWRx3AoRuZwOKcdBe++pXUUEWwpKl2fvuN4lEDwyiB9TSIuBWTwU4kvJnvDnf2rb899EGmvihBE6vNxae+/n9Xefz+rnT+Z9bbEzcr7c4fKP3wj+Jujkk5U49UMklvyskiPC5oHviyCRbmjyPGl73u5/fze+K3cft4NI+7DHwtRL26oEZWcD3z6AlB9/zxX3z/PnbcIim0QWdvLWwTFDQD3Wl4VGdhnaLy6RVBntERf3Tapx0ciHnovb1YUk4wHvd4nAyIvbq/VON5EaKz1J0Re3F7rcXcQe3QJv7rRl8SLc48FsPKiiGIbxM7PRfi0w52OuEbs+QsNnws3+LS++bjtis88SN7p8tPa11ctiUfyVzm0pJy/SYAtx9LDsHq/Hf2KV4H7dagO4nL+JoF36+MUygeRU2kAvvSQ+oM+1cif50jHsvE4bP3Cx50H786R41L83TnyRUtuzpHx9hw5teP2HKHyA3OE6JfOEb6u6I/r9FH20+ezmDo2achnvs8apxsajUdqj0We/kzji4MRfACj18PB6A8cTP/FB1NiQ+QHvnjWY6zifdr54jsihJYQ/4SIlFdFOjbyuK5XReJ1tYfeyx0bj3z45c1HueIjOrUdvghy/iRAwxNtzhfiH1+24fp2QetZ4tadL7frl0rc3DPt2KEVGwJVff55BG6nV1zubG1ybkbD7XfeM+r3zeD3k9npRaybyeyLT04QajeInx7MFyJpi3h53iOlH/eZv/nxi5PIvTXAs8StNcAvJO6sAZ4/GHPrHv6Lb87cuYf/4tNXik9f9Rc/n4XdGR74tG6L+Rhy8a2Yx+JJe67x/tuCzG+/LXiUuFeRd/9IlF7rUWzN8qEa6FsaTAj7+rSqj08PmOZ2y7EO8byq7wuNW5WBX8ywjjzYyvN26Nuz4yRxc3bI+xUAfEodhE0qrucKci7QuvMNBtbDXdS9r7LaCf1pDixRyislvxf/qbjqGyL8ogh2kZdWy0FE3h2X87GkfdnGq8dCsYz5ePBOr4rExu2Sbxm+J1KjTkxql+cip9P16PGx29E/FDXKN0SueJg68qcVvydSohhi5L3qvidCsaniyB9E/55IjdX78eGbTL8TOUzX0WKJavD1vPqO+/FB1Z3tSM/t0HiKMDTP19+147bIeFUk0uID+TWRuZsKypOvfpI5DnFsHT1a+lLsNydbw2TLrxh+T6TisRkfAvD+GfxpSTCPt7/mcr5ijlzyeAD2/Jro+LrVze8An0XqFR/LqvT8hTw5vdiTym5I29Ojkau8fd0tp+q7e1dWR4l7V1ZytbevaeS0AeC9axr7NObTxZibX5q/Pyp6GJXj7BBk5ucF9EeN+dXAOJihr2pcb2ukfdlqOn1/T0OwVtefa5T69v3QFxq37ofOx9IwyZr09zVenGOP9c8oL2v9+dgeX3ISSV9+OUXdqSHK2GRSnqfC0/eb7g7uWeMHBlfxTblT4J7fkdL0hga/2qkDH+08zDJ6e68gORVD3H0F59iOe6/gfHHOjmX2Vkd78cTfGhpS6qsiMUNaO1091POb1rdKu+X4htXN0u7z4Ywanx8tH7409rkl7ScOh3/x4XAJES7tdDj65rXuuRktputjyVMOzThVqZQI31w9/OkZhhx3C7x1h3huRdTb5+D9fStOde7XSF/kyhUZ8h2RjvfnHnd212siI85VD376uZdzjyhKVE7jIr9U4nGWSW/i9vK8U+UnOlV+oFO/ELk1R85hJ+kKoI/XErygiEGK9ldF4uJMPj4m/45IiwsJ+bCd5LdEKh7rfvwK1qdUxD+wOZCw/uIELxzlFCLldDjHN/DuvYp0bInWeC1fazu05PwdrHvLCMfXiG4uI0h9exnhJHFzGUH4/WUEkbeXEY4v7txdRrg9KodbvPPsuLeMcNK4u4zwhcb1tsbNu0S9e/vOr/Xp3eWMs8a95QyV9+94zxr37niPx9KimrI2Ks/bMX51O+4tq9zWeDHm7i6rnF6Hur2soj+w3qX1Fw/MzSWR05Oq20si54bcWxI57YJ1c0nktF/b7SWRPt5dEvnqIubWq9Ay6lnkzivIR5F7BYxfHsy9dpyq/iQ2FdJLDjf/fFjLiDuz9CZTq9+6kRlpn5eLX7obKqhxfzA9uxvS6+3S1KPEzZH94pb7Zn/QT/RHe/8W8yhyr0fOT7pHvAMxRvo+5Pcel+fPuvTDg/vjl9nuPy4/ydwrLT1L3Cot/ULiTmnpFzUzaf+e8moJUI3tXR4izwtvyumNDh2x947mg/n8JYkvROKyXcd4LqKnV4dubvmop3epbt6h6ulR1b071KPEvTtUPT1junmHqqdXKO7doerxLaqbd6j3R0UPo3J8PnRr+0ql97ev/KIdt7avVHp7+0qlH9g08tiOe9eGx+64uQngWePeJoD6/iaA+hObAOr7mwAek2kvsb9jL/kVrM8Z+VSOfe+lgWMCulfvr/X9en+tb9f7HyVupuPbR6Kvdei9cv+jxL1qf23vV/t/oXErkdLbGyufXqy9WzJ81LhZ7HvUuFnre8o9d6tj72uMFzXu1cYe8+jta/1jr96sjD0ezc0ZctS4WRd71PiJY7k5U8/Hcm+mnl6avDtT72uMFzXuzdTGPzFTz716r/z6fLK9VTit8m7hNB1rnmOqt+vDW+jlUyvefln6LHFvOUnfXk46dUYdUnBFKc87Q+n9p9l6us2/v8Xu25cv9fRC7a1vZRwVbn0qo/7Ep0B/4EMZqsePGNzcz/b4+c1YnXvcVD7/AvxR49ELVzqa59skaKe3g/YocS9o+9srnvX4PQb9h1v7ff5IztuzfLw9y/sPzPL+A7P8/ADq3ixvx28Rx6egHt7PtxRoP7AtwTlSVPHcp3/YIPxTpLz/UaqzxL1IOT1/uhkp97ujPN/p5fTN3EcPoOSD8wYHr2r09zU+7NXwSeP0tnSN/ZHow9uW+vGWtJ/ecKq94slxk4NIPWWxePxMPa2pfU+kx8uj1NN33L4rgpYQ/4BIvZ6K8OlbXxJrc4+lrfHa4DSkkQ+7HH5zhGODwjqu5/3Kp6tTwf6E0ttLPdJGVFu10Z8PzTlsUrVVfx42/fSm080HFf24n1+9UCpFcmjI4W5OWV1EOb+58Vnj9F4f3rl4YCqE1U8ax9244/Rdr/wFxc8a/fgYOh4zPFj4+dEcu5XjzqGmKoPfd+tRZKQytueT5Hi2kRKTpAgdTr799DDq1h3uF+0IidmOfmhHO649xKpBniT982Ynh/DFVhQPfN6OkwbXWL3getgOl4+F7LEDxAPlNQ08EpuLy081ziPTYsuUB7eXVWIHiAeP530ib38VUt7+KOTxyxGlpxKScT2rdej1uLodi+yPNUN9SYLivZ5B1F+6za2xL/CDdbw2sppWMJTLc5X+/lZ+/f2t/Pr7+/B9ozvo9U7tUKkvBp3iuurB8nznyd7evrM6S9wcml97Z/WxOw5bC381NJpUnu8Jenq/4GYm07dXM05H8rh6jMqNXg45uZ+ud+8t7RwlHtkQ5xiVp++gfSGi6QNS+vQdtK9EkN0f/FJe7YTLkF4PwXvaI6x0+/bQVslbaX5HhQifwqlXvtDk1zQKvabB2J2Upbykcfc7ONreX7I/aXBh7E7ac/zrfY1asCXwhx2OP92LnN6VupmYjxL3ErPou4n53Blxt8stvxrwu844re5escAj14cPBH4SOT2durX/7RfNSFvIffhO2neOpcQOy4/7ovKqSCw0S34u/V2ReP+0jPp8rp9eUWrYvL6dNN4+X+rb58vTcdxd/T9q3Fz9t3uMd1f/j59ruqJUul2H72n2959O9fefTvX3n04dH+RiF96qHz4a8w0NwZKOUn2q0Y8vSd18LN17f/8cN07Rcusrtn38wAYn9v2ht4/ldCWFXT0LfdgQpH1qyGl48cpoSmGq91sh2Kuhf7gV+7SD93FjspuRfxT58N5IOrt8/ojHFyK9hUhqx3dFsPXElR51/V7l+ApLg0o+nk9fFDn37IWvcDxYXzyix3/EY//HEdHLMtG9cyWzP5UZV/3lMh/KwKs87eCzCD7d9rhgv14UqfguX37r+nci59uZeCzSPmwf0T415FTPcG8f6aPG3S9Jn0VuXpR80ZJ7VyWj0A/kpnIdV1fuvGo0ynErqlu17eP4yOpWEfRR4l5t+/0jeV4cdu7Re6/njPL+y/3lND1I8GVfSRvzfH4v5iyiqDfRVl4TufuGzrklXFEXKieRY34eaQOnkXYJ+1zmepYpreHd+pY/7vVNmagHmJJ8kDn1TB3o3vzy47e6t2FRsX0oEP8scvqS3L1Xfsr5Zb87b1GdNe69RTXef4tq/MRbVOMH3qI6D2086X2Mcn0xcspV0yvladukb075wmlXCn05ANNVX/nwNuZnmS+u+lhxuXb4SN9o17t35eP9T1qNRr9U4uZXsb7o0nRzUPj59xd7f/dueLQf2D5ttB/YPu10R60c6fnxjOT5vpQnjV5avAhZqb2mwVF+2pme78Q6+O2vp5+bERfhnT+UanxuRn27Gfz2F9jHsXLlVricFjm6xFuMj6cGz/ezOxXR3lupPSrcWqk9b2lz86ao/sA9kfzIek17/55I6vv3RKfKl5v3RCeJm/dEt4/kcE907NGb90TS378nOn2s4PY90VHk7j3RJT9wT3Rsyd17okt/5J7oKHP/nugLmbv3RMeeuXtPdBS5e090vb0Re/niSx+37omOGjfviU4fxrl5T9TpB+6J+vu3meehvXlPdJ6rt++JzjK374m+kLl5T3S8Frj1pc/z1cSdD32eHrfevPof5Qeu/scPbPbfj1eqsalUpQ+f5+b7GhqPjuv4UDF+X6NdcV30CJ/nj5/HkPcX4Yf8wCL8+IHKgC9acu+C83Gq/onagNPb9y0V0hV9PsCnfZwFu1qLyGsaHNFPou2pxqNHfuDLFOsS6O3gO/YJvo2tl5yO5/iC4L2dy48bCjTBSw4fNrgvn1tyepJ2b+fyx7rL3Rfg+XA9X97es+asce/eZD7UPV4a3Xnlaq5Kne7C72wON1ezDtP15u5w3xib073WeZbc2sH8LHJzC/MvRa73Re5tYl6u0x5LN3cx/6Il97Yx/0rk1j7mj8N5f+eqr0Ru3lAfD+feVuaPlugvb8mtzcy/IfJqAN7czvxx93C6gr25n/lX8/7uRCm/enjubWlernrcpujenuZfNeXWpuaPpry9c+VDo79/N3xuyd3b4S+ucW5tbP64yy1nlTs7ip9V7j6F+up4brak3breqhfR0+vHYxn0rRvqcyH1nRvq88sgWPbknh8SfOOFEsFLKTLqaxo93kmlfCP7vZdSSDEmz4+ln95Kvftmy1Hk3hbcZ4lbW3B/IXFnC24531U03FVcr43sB432ogZBoz4flMdy69vvtX6hcevZ4ON+4/q1Gjc/BXC+F/iH7wp+b1zSXfR4MXvkdryq0eNa5oGvamDP6qPG2xld3s7oX7yNXrAZJ734QnsUCD/w2brVMffc6wl6tyeOWy5o7O7D+uFlg29s29BjJZB7LS9qxPnxgS9uH9EZ7Xh1G4sedzAPuVe3sSi4a6CX+2NA4zAup2dnHPdAjbX+gMZr24s8FjRj9U64vagRuyU9HjiV1zQUuyV1fq4xPyt6WLsbcTXY8xdZfv/CxOljKI1jvj+6px2eWX3RlihsusqxLedvkMZck7S6U7/Rkn7FK6D9OlQCluv0DpZqrO48zpp8Ujk9aI3tMPOza/r0zsVxpnTcno7DxguPdtSfmCmnB4L3Z8oXbbk5U07PfO7OlGPR1v2Z0n9kpoxfOVMYX3ni/JGn382UY9knU8cr+vns9zuR08WAfX9lXQ1o3gb2GxtB4aUyzjd2/+Bo2k8cDf/ao8FnkR/42vmPa9TTfNr44BsahHbknd9f1pDyokbHJg7X9aKGxrUN9Vf7NCotuB5i5qxRodGeX1Ocd5SNWmvKxQWfd4Oda6Vv3zGfNe7d7ZbjboE/oHHvjvnYpxUbp1S9Dn1K7+5rcWxGw0133ovmHzSDfiCRUX07kZ23LSYUKhI/PZqzBuOLL/K8R/R07r67f/JR5N7C31ni1sLfFxJ3Fv6O+3Pfun0/7/B95/b9uBP+vTaUd9tw/IDGzY9DnjXufRtSj1sd3v4Kx1Hm5vw8Stybn2eJO/Pz/Dmhm58TOS9yvf/Rmpvz46xxc37wz8wPfn9+8Pvzg9+eH8fXPFENVXIu/3T3c5aIRw4lZ4/vSOC5GF3jqUQpfLx/GriwfVUjqg4k3U9+51DyjhFpKfU7EhIXHB+fEn5DQmOntsdjoGNnyK9WKYJSRsmPT76ngmW7ooNeVRn4HHNeUP3WAMfhPJ4ZvBYx+NLuY7aU11qBp8CPR7ivSLSOmoeelnHKbYWCHd9Kaf2VRpSCSua839t3JPA5tAe+1gpOn71p+pqEoOqwj9cOBJOz0msHUuN88EjsLx2IxsM9bfKKQDpJ82sHccW90oe96n8f6qf9Gd+f3iMeWAx6rScE35TjN7vyNYFKKACn+vwDIkeJuNB54HhbIt2hfEsC6xp0+JzKsZgAH1Op7XpJokXpXOXrtb7Ad2FqTcWRL0u8NqiovKs5Z36rL1BD1Oprg9oqCkWrviZRUDrLLw6q4CMd8lIrimLHMh3tJQl8YKfkx+efJUo5vv9NyP+UPqf5aZnp2A58Rq4zv3Yo/R9+ie5bEtjXrr8WJaXHC58fPnjwvQNBaelFb0uUV1uhkHgp3B/XuuiLpm+34rVBvfueCV3vv2dC1w+8Z3K6eI5PAXO+gP+0YHZPgF4S4BgP+VAFelvg3p4XJ4FbW15c765bXu8uWx4/nYVHHVqer0odL/yR+yUniW9c8ErcZxep4yWJzvgqAr/WihGf8KPrKq9I0IVHFB9e5f5GK/BVpsdZ9bUDUXyGpJeXDmR+LyduS8drrcCHrkrLFRvfkGiR7B6LVvxU4vH46pfeCD1uJWNMPlyzfudQYuOkkl9xerVDX5RQvCuiml8C/3wKomMd7oV3A9MiktyPtCudS+VpM44SLb31Ul+S0HSZ9uE7Kp8747hB390Xlan+wBcujmvIUdfw4cuw/+BwjouVikUY0fJ076OvVGqHivBzldN2vb2lN2fq6YjGu0/zT+dIvXCOrOOVqdYwvE3baao1+omp1n7g++dfjjC26JPn3+15tIV/+TxhbIPEHyprf9e7erw6xwY5p1q6L1QIu1vIUeUwZ2/XKdLpu6g36xSPLbldp0inDzTdrlOk4257t+oUz9ngsWQfL5HMbaJSLF7X57acao5jkRgK7XaufiSiqGaldHlV2ufbOD5/1OzOFnMPkeMu4vd2ciAex/H1SXLayeGocXMnh/sHo6eDOXXrvX3mHutL9fQc9d7rzl+0BC8aXUUPLTnd7N97x5jkJ7a8O6vc3fPuqHJ707tzW+7uendWoYLayWNb9Ljd7UgPfAYdtgD7SufuJnxnnfu78H2lc3cbvnMv392H76xydyO+YzTdfE/+GNZ3t+I7i9zbi6/QaZO0u7mhH3dLvbn/wLEld/tVfmI/vi9m7e0N+b7Qub0j31c6N7fkO90ctksQQqfZ8hOXCv0HLhX6D1wq9PcvFY5VLHFj+SEtfUOBCdXI9XClMe7uwHMalfEDewHdb8lzkeM07Tgrt3JoRn9/hp00bs6wev3A4556eifq5uOeenolatR4tDpqrh34VL5a6ukrTo8FN2/K4OtwLq/HLWRvrR1+0bH3dpB8iJxOFtiG6zpJnPq1xzOs0Yee+vWkcrO4+KsxjiKw0Wp/VeWKqrpxjetVlRLrVCPXtH23XwoKt/Mn2b43azWKYocKnWbtbZXxsspAPdTgF1Xu129/1b/3CuNvp+vnF7L19JkqPO9SPSXJH6it/0rlXnX943D0Z4bnpHOvvv4LjVsF9l9pPK2w/9+P//OHf/vT3/7lz3/9tz/8/U9//ct/Pv7uf6bU3/70h3/98x/3//2///WXf0v/9e///3/4f/nXv/3pz3/+07//y3/87a//9sf/819/++NUmv/tt2v/z//S+cXKfl31f//Tb+Xx/8fc725crT/+f338/8cCCdP8b/bL8jhb6mNNef7D/O2uj0vnx//Q//6f2dz/Bw=="
     },
     {
       "name": "public_dispatch",
@@ -384,6 +384,11 @@
             "error_kind": "string",
             "string": "Block number mismatch."
           },
+          "4820051788501785972": {
+            "error_kind": "fmtstring",
+            "length": 17,
+            "item_types": []
+          },
           "6989792215391248978": {
             "error_kind": "string",
             "string": "Function check_timestamp can only be called statically"
@@ -416,16 +421,11 @@
                 "kind": "field"
               }
             ]
-          },
-          "17044658090447215604": {
-            "error_kind": "fmtstring",
-            "length": 17,
-            "item_types": []
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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"
+      "bytecode": "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",
+      "debug_symbols": "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"
     },
     {
       "name": "sync_private_state",
@@ -468,6 +468,11 @@
             "error_kind": "string",
             "string": "Input length must be a multiple of 32"
           },
+          "6504742485148360234": {
+            "error_kind": "fmtstring",
+            "length": 40,
+            "item_types": []
+          },
           "7564993426627941149": {
             "error_kind": "fmtstring",
             "length": 48,
@@ -504,11 +509,6 @@
             "error_kind": "string",
             "string": "Attempted to read past the length of a CapsuleArray"
           },
-          "9921926525851912681": {
-            "error_kind": "fmtstring",
-            "length": 98,
-            "item_types": []
-          },
           "10791800398362570014": {
             "error_kind": "string",
             "string": "extend_from_bounded_vec out of bounds"
@@ -525,6 +525,11 @@
             "error_kind": "string",
             "string": "push out of bounds"
           },
+          "13060541637244024094": {
+            "error_kind": "fmtstring",
+            "length": 98,
+            "item_types": []
+          },
           "13450089406971132036": {
             "error_kind": "fmtstring",
             "length": 144,
@@ -536,11 +541,6 @@
               }
             ]
           },
-          "13921208329385594075": {
-            "error_kind": "fmtstring",
-            "length": 40,
-            "item_types": []
-          },
           "14990209321349310352": {
             "error_kind": "string",
             "string": "attempt to add with overflow"
@@ -586,8 +586,8 @@
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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"
+      "bytecode": "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",
+      "debug_symbols": "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"
     }
   ],
   "outputs": {
@@ -779,63 +779,67 @@
     }
   },
   "file_map": {
-    "104": {
+    "100": {
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/aztec.nr",
+      "source": "use crate::macros::{\n    calls_generation::{\n        external_functions::{\n            generate_external_function_calls, generate_external_function_self_calls_structs,\n        },\n        internal_functions::generate_call_internal_struct,\n    },\n    dispatch::generate_public_dispatch,\n    functions::utils::check_each_fn_macroified,\n    internals_functions_generation::{create_fn_abi_exports, process_functions},\n    notes::NOTES,\n    storage::STORAGE_LAYOUT_NAME,\n    utils::{get_trait_impl_method, module_has_storage},\n};\n\n/// Marks a contract as an Aztec contract, generating the interfaces for its functions and notes, as well as injecting\n/// the `sync_private_state` utility function.\n/// Note: This is a module annotation, so the returned quote gets injected inside the module (contract) itself.\npub comptime fn aztec(m: Module) -> Quoted {\n    // Functions that don't have #[external(...)], #[contract_library_method], or #[test] are not allowed in contracts.\n    check_each_fn_macroified(m);\n\n    // We generate new functions prefixed with `__aztec_nr_internals__` and we replace the original functions' bodies\n    // with `static_assert(false, ...)` to prevent them from being called directly from within the contract.\n    let functions = process_functions(m);\n\n    // We generate structs and their implementations necessary for convenient functions calls.\n    let interface = generate_contract_interface(m);\n    let self_call_structs = generate_external_function_self_calls_structs(m);\n    let call_internal_struct = generate_call_internal_struct(m);\n\n    // We generate ABI exports for all the external functions in the contract.\n    let fn_abi_exports = create_fn_abi_exports(m);\n\n    // We generate `_compute_note_hash_and_nullifier`, `sync_private_state` and `process_message`\n    // functions only if they are not already implemented. If they are implemented we just insert empty\n    // quotes.\n    let contract_library_method_compute_note_hash_and_nullifier = if !m.functions().any(|f| {\n        f.name() == quote { _compute_note_hash_and_nullifier }\n    }) {\n        generate_contract_library_method_compute_note_hash_and_nullifier()\n    } else {\n        quote {}\n    };\n    let sync_private_state_fn_and_abi_export = if !m.functions().any(|f| {\n        f.name() == quote { sync_private_state }\n    }) {\n        generate_sync_private_state()\n    } else {\n        quote {}\n    };\n\n    let process_message_fn_and_abi_export = if !m.functions().any(|f| {\n        f.name() == quote { process_message }\n    }) {\n        generate_process_message()\n    } else {\n        quote {}\n    };\n    let public_dispatch = generate_public_dispatch(m);\n\n    quote {\n        $interface\n        $self_call_structs\n        $call_internal_struct\n        $functions\n        $fn_abi_exports\n        $contract_library_method_compute_note_hash_and_nullifier\n        $public_dispatch\n        $sync_private_state_fn_and_abi_export\n        $process_message_fn_and_abi_export\n    }\n}\n\ncomptime fn generate_contract_interface(m: Module) -> Quoted {\n    let calls = generate_external_function_calls(m);\n\n    let module_name = m.name();\n\n    let has_storage_layout = module_has_storage(m) & STORAGE_LAYOUT_NAME.get(m).is_some();\n    let storage_layout_getter = if has_storage_layout {\n        let storage_layout_name = STORAGE_LAYOUT_NAME.get(m).unwrap();\n        quote {\n            pub fn storage_layout() -> StorageLayoutFields {\n                $storage_layout_name.fields\n            }\n        }\n    } else {\n        quote {}\n    };\n\n    let library_storage_layout_getter = if has_storage_layout {\n        quote {\n            #[contract_library_method]\n            $storage_layout_getter\n        }\n    } else {\n        quote {}\n    };\n\n    quote {\n        pub struct $module_name {\n            pub target_contract: dep::aztec::protocol_types::address::AztecAddress\n        }\n\n        impl $module_name {\n            $calls\n\n            pub fn at(\n                addr: aztec::protocol_types::address::AztecAddress\n            ) -> Self {\n                Self { target_contract: addr }\n            }\n\n            pub fn interface() -> Self {\n                Self { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n            }\n\n            $storage_layout_getter\n        }\n\n        #[contract_library_method]\n        pub fn at(\n            addr: aztec::protocol_types::address::AztecAddress\n        ) -> $module_name {\n            $module_name { target_contract: addr }\n        }\n\n        #[contract_library_method]\n        pub fn interface() -> $module_name {\n            $module_name { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n        }\n\n        $library_storage_layout_getter\n\n    }\n}\n\n/// Generates a contract library method called `_compute_note_hash_and_nullifier` which is used for note\n/// discovery (to create the `aztec::messages::discovery::ComputeNoteHashAndNullifier` function) and to implement the\n/// `compute_note_hash_and_nullifier` unconstrained contract function.\ncomptime fn generate_contract_library_method_compute_note_hash_and_nullifier() -> Quoted {\n    if NOTES.len() > 0 {\n        // Contracts that do define notes produce an if-else chain where `note_type_id` is matched against the\n        // `get_note_type_id()` function of each note type that we know of, in order to identify the note type. Once we\n        // know it we call we correct `unpack` method from the `Packable` trait to obtain the underlying note type, and\n        // compute the note hash (non-siloed) and inner nullifier (also non-siloed).\n\n        let mut if_note_type_id_match_statements_list = &[];\n        for i in 0..NOTES.len() {\n            let typ = NOTES.get(i);\n\n            let get_note_type_id = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteType },\n                quote { get_id },\n            );\n            let unpack = get_trait_impl_method(\n                typ,\n                quote { crate::protocol_types::traits::Packable },\n                quote { unpack },\n            );\n\n            let compute_note_hash = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteHash },\n                quote { compute_note_hash },\n            );\n\n            let compute_nullifier_unconstrained = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteHash },\n                quote { compute_nullifier_unconstrained },\n            );\n\n            let if_or_else_if = if i == 0 {\n                quote { if }\n            } else {\n                quote { else if }\n            };\n\n            if_note_type_id_match_statements_list = if_note_type_id_match_statements_list.push_back(\n                quote {\n                    $if_or_else_if note_type_id == $get_note_type_id() {\n                        // As an extra safety check we make sure that the packed_note BoundedVec has the expected\n                        // length, since we're about to interpret its raw storage as a fixed-size array by calling the\n                        // unpack function on it.\n                        let expected_len = <$typ as $crate::protocol_types::traits::Packable>::N;\n                        let actual_len = packed_note.len();\n                        assert(\n                            actual_len == expected_len,\n                            f\"Expected packed note of length {expected_len} but got {actual_len} for note type id {note_type_id}\"\n                        );\n\n                        let note = $unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n\n                        let note_hash = $compute_note_hash(note, storage_slot);\n    \n                        // The message discovery process finds settled notes, that is, notes that were created in prior\n                        // transactions and are therefore already part of the note hash tree. We therefore compute the\n                        // nullification note hash by treating the note as a settled note with the provided note nonce.\n                        let note_hash_for_nullification = aztec::note::utils::compute_note_hash_for_nullification(\n                            aztec::note::retrieved_note::RetrievedNote{ \n                                note, \n                                contract_address, \n                                metadata: aztec::note::note_metadata::SettledNoteMetadata::new(note_nonce).into()\n                            }, \n                            storage_slot,\n                        );\n\n                        let inner_nullifier = $compute_nullifier_unconstrained(note, note_hash_for_nullification);\n\n                        Option::some(\n                            aztec::messages::discovery::NoteHashAndNullifier {\n                                note_hash, inner_nullifier\n                            }\n                        )\n                    }\n                },\n            );\n        }\n\n        let if_note_type_id_match_statements = if_note_type_id_match_statements_list.join(quote {});\n\n        quote {\n            /// Unpacks an array into a note corresponding to `note_type_id` and then computes its note hash\n            /// (non-siloed) and inner nullifier (non-siloed) assuming the note has been inserted into the note hash\n            /// tree with `note_nonce`.\n            ///\n            /// The signature of this function notably matches the `aztec::messages::discovery::ComputeNoteHashAndNullifier` type,\n            /// and so it can be used to call functions from that module such as `discover_new_messages`, \n            /// `do_process_message` and `attempt_note_discovery`.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_hash_and_nullifier(\n                packed_note: BoundedVec<Field, aztec::messages::discovery::private_notes::MAX_NOTE_PACKED_LEN>,\n                storage_slot: Field,\n                note_type_id: Field,\n                contract_address: aztec::protocol_types::address::AztecAddress,\n                note_nonce: Field,\n            ) -> Option<aztec::messages::discovery::NoteHashAndNullifier> {\n                $if_note_type_id_match_statements\n                else {\n                    Option::none()\n                }\n            }\n        }\n    } else {\n        // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n        // simply throws immediately.\n        quote {\n            /// This contract does not use private notes, so this function should never be called as it will\n            /// unconditionally fail.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_hash_and_nullifier(\n                _packed_note: BoundedVec<Field, aztec::messages::discovery::private_notes::MAX_NOTE_PACKED_LEN>,\n                _storage_slot: Field,\n                _note_type_id: Field,\n                _contract_address: aztec::protocol_types::address::AztecAddress,\n                _nonce: Field,\n            ) -> Option<aztec::messages::discovery::NoteHashAndNullifier> {\n                panic(f\"This contract does not use private notes\")\n            }\n        }\n    }\n}\n\ncomptime fn generate_sync_private_state() -> Quoted {\n    quote {\n        pub struct sync_private_state_parameters {}\n\n        #[abi(functions)]\n        pub struct sync_private_state_abi {\n            parameters: sync_private_state_parameters,\n        }\n\n        #[aztec::macros::internals_functions_generation::abi_attributes::abi_utility]\n        unconstrained fn sync_private_state() {\n            let address = aztec::context::utility_context::UtilityContext::new().this_address();\n            \n            aztec::messages::discovery::discover_new_messages(address, _compute_note_hash_and_nullifier);\n        }\n    }\n}\n\ncomptime fn generate_process_message() -> Quoted {\n    quote {\n        pub struct process_message_parameters {\n            pub message_ciphertext: BoundedVec<Field, aztec::messages::encoding::MESSAGE_CIPHERTEXT_LEN>,\n            pub message_context: aztec::messages::processing::message_context::MessageContext,\n        }\n\n        #[abi(functions)]\n        pub struct process_message_abi {\n            parameters: process_message_parameters,\n        }\n\n        #[aztec::macros::internals_functions_generation::abi_attributes::abi_utility]\n        unconstrained fn process_message(\n            message_ciphertext: BoundedVec<Field, aztec::messages::encoding::MESSAGE_CIPHERTEXT_LEN>,\n            message_context: aztec::messages::processing::message_context::MessageContext,\n        ) {\n            let address = aztec::context::utility_context::UtilityContext::new().this_address();\n\n            aztec::messages::discovery::discover_new_messages(address, _compute_note_hash_and_nullifier);     \n            aztec::messages::discovery::process_message::process_message_ciphertext(\n                address,\n                _compute_note_hash_and_nullifier,\n                message_ciphertext,\n                message_context,\n            );\n        }\n    }\n}\n"
+    },
+    "105": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/dispatch.nr",
       "source": "use crate::macros::internals_functions_generation::external_functions_registry::get_public_functions;\nuse super::utils::compute_fn_selector;\nuse poseidon::poseidon2::Poseidon2Hasher;\nuse protocol_types::meta::utils::get_params_len_quote;\nuse std::{collections::umap::UHashMap, hash::BuildHasherDefault, panic};\n\n/// Returns an `fn public_dispatch(...)` function for the given module that's assumed to be an Aztec contract.\npub comptime fn generate_public_dispatch(m: Module) -> Quoted {\n    let functions = get_public_functions(m);\n\n    let unit = get_type::<()>();\n\n    let seen_selectors =\n        &mut UHashMap::<Field, Quoted, BuildHasherDefault<Poseidon2Hasher>>::default();\n\n    let ifs = functions.map(|function: FunctionDefinition| {\n        let parameters = function.parameters();\n        let return_type = function.return_type();\n\n        let selector: Field = compute_fn_selector(function);\n        let fn_name = function.name();\n\n        // Since function selectors are computed as the first 4 bytes of the hash of the function signature,\n        // it's possible to have collisions. With the following check, we ensure it doesn't happen within\n        // the same contract.\n        if seen_selectors.contains_key(selector) {\n            let existing_fn = seen_selectors.get(selector).unwrap();\n            panic(\n                f\"Public function selector collision detected between functions '{fn_name}' and '{existing_fn}'\",\n            );\n        }\n        seen_selectors.insert(selector, fn_name);\n\n        let params_len_quote = get_params_len_quote(parameters);\n\n        let initial_read = if parameters.len() == 0 {\n            quote {}\n        } else {\n            // The initial calldata_copy offset is 1 to skip the Field selector\n            // The expected calldata is the serialization of\n            // - FunctionSelector: the selector of the function intended to dispatch\n            // - Parameters: the parameters of the function intended to dispatch\n            // That is, exactly what is expected for a call to the target function,\n            // but with a selector added at the beginning.\n            quote {\n                let input_calldata: [Field; $params_len_quote] = dep::aztec::context::public_context::calldata_copy(1, $params_len_quote);\n                let mut reader = dep::aztec::protocol_types::utils::reader::Reader::new(input_calldata);\n            }\n        };\n\n        let parameter_index: &mut u32 = &mut 0;\n        let reads = parameters.map(|param: (Quoted, Type)| {\n            let parameter_index_value = *parameter_index;\n            let param_name = f\"arg{parameter_index_value}\".quoted_contents();\n            let param_type = param.1;\n            let read = quote {\n                let $param_name: $param_type = reader.read_struct(dep::aztec::protocol_types::traits::Deserialize::deserialize);\n            };\n            *parameter_index += 1;\n            quote { $read }\n        });\n        let read = reads.join(quote { });\n\n        let mut args = &[];\n        for parameter_index in 0..parameters.len() {\n            let param_name = f\"arg{parameter_index}\".quoted_contents();\n            args = args.push_back(quote { $param_name });\n        }\n\n        // We call a function whose name is prefixed with `__aztec_nr_internals__`. This is necessary because the\n        // original function is intentionally made uncallable, preventing direct invocation within the contract.\n        // Instead, a new function with the same name, but prefixed by `__aztec_nr_internals__`, has been generated to\n        // be called here. For more details see the `process_functions` function.\n        let name = f\"__aztec_nr_internals__{fn_name}\".quoted_contents();\n        let args = args.join(quote { , });\n        let call = quote { $name($args) };\n\n        let return_code = if return_type == unit {\n            quote {\n                $call;\n                // Force early return.\n                dep::aztec::context::public_context::avm_return([]);\n            }\n        } else {\n            quote {\n                let return_value = dep::aztec::protocol_types::traits::Serialize::serialize($call);\n                dep::aztec::context::public_context::avm_return(return_value.as_slice());\n            }\n        };\n\n        let if_ = quote {\n            if selector == $selector {\n                $initial_read\n                $read\n                $return_code\n            }\n        };\n        if_\n    });\n\n    if ifs.len() == 0 {\n        // No dispatch function if there are no public functions\n        quote {}\n    } else {\n        let ifs = ifs.push_back(quote { panic(f\"Unknown selector {selector}\") });\n        let dispatch = ifs.join(quote {  });\n\n        let body = quote {\n            // We mark this as public because our whole system depends on public functions having this attribute.\n            #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n            pub unconstrained fn public_dispatch(selector: Field) {\n                $dispatch\n            }\n        };\n\n        body\n    }\n}\n\ncomptime fn get_type<T>() -> Type {\n    let t: T = std::mem::zeroed();\n    std::meta::type_of(t)\n}\n"
     },
-    "109": {
+    "110": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/functions/utils.nr",
       "source": "// TODO(benesjan): Move this whole file to `noir-projects/aztec-nr/aztec/src/macros/internals_functions_generation`.\n// Not done yet in order to not murder the PR diff.\nuse crate::macros::{\n    functions::auth_registry::AUTHORIZE_ONCE_REGISTRY,\n    notes::NOTES,\n    utils::{\n        fn_has_authorize_once, fn_has_noinitcheck, is_fn_contract_library_method, is_fn_external,\n        is_fn_initializer, is_fn_internal, is_fn_only_self, is_fn_test, is_fn_view,\n        module_has_initializer, module_has_storage,\n    },\n};\nuse dep::protocol_types::meta::utils::derive_serialization_quotes;\nuse std::meta::{ctstring::AsCtString, type_of};\n\n/// Gathers all attributes relevant to the function's ABI and returns a quote that can be applied to the newly generated\n/// function. We apply the abi marker attributes instead of the original ones (e.g. abi_view instead of view) to avoid\n/// the relevant attribute's functionality from getting triggered.\ncomptime fn get_abi_relevant_attributes(f: FunctionDefinition) -> Quoted {\n    let mut attributes = quote {};\n\n    if is_fn_view(f) {\n        attributes = quote { $attributes #[aztec::macros::internals_functions_generation::abi_attributes::abi_view] };\n    }\n\n    if is_fn_only_self(f) {\n        attributes = quote { $attributes #[aztec::macros::internals_functions_generation::abi_attributes::abi_only_self] };\n    }\n\n    if is_fn_initializer(f) {\n        attributes = quote { $attributes #[aztec::macros::internals_functions_generation::abi_attributes::abi_initializer] };\n    }\n\n    attributes\n}\n\npub(crate) comptime fn transform_private(f: FunctionDefinition) -> Quoted {\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Private functions undergo a lot of transformations from their Aztec.nr form into a circuit that can be fed to the\n    // Private Kernel Circuit.\n    // First we change the function signature so that it also receives `PrivateContextInputs`, which contain information\n    // about the execution context (e.g. the caller).\n    let original_params = f.parameters();\n\n    let original_params_quotes = original_params\n        .map(|(param_name, param_type)| quote { $param_name: $param_type })\n        .join(quote {, });\n\n    let params = quote { inputs: aztec::context::inputs::private_context_inputs::PrivateContextInputs, $original_params_quotes };\n\n    let mut body = f.body().as_block().unwrap();\n\n    // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received\n    // the correct values.\n    let (args_serialization, _, serialized_args_name) =\n        derive_serialization_quotes(original_params, false);\n\n    let storage_init = if module_has_storage {\n        // Contract has Storage defined so we initialize it.\n        quote {\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        // Contract does not have Storage defined, so we set storage to the unit type `()`. ContractSelf requires a\n        // storage struct in its constructor. Using an Option type would lead to worse developer experience and higher\n        // constraint counts so we use the unit type `()` instead.\n        quote {\n            let storage = ();\n        }\n    };\n\n    let contract_self_creation = quote {\n        #[allow(unused_variables)]\n        let mut self = {\n            $args_serialization\n            let args_hash = aztec::hash::hash_args_array($serialized_args_name);\n            let mut context = aztec::context::private_context::PrivateContext::new(inputs, args_hash);\n            $storage_init\n            let self_address = context.this_address();\n            let call_self: CallSelf<&mut aztec::context::private_context::PrivateContext> = CallSelf { address: self_address, context: &mut context };\n            let enqueue_self: EnqueueSelf<&mut aztec::context::private_context::PrivateContext> = EnqueueSelf { address: self_address, context: &mut context };\n            let call_self_static: CallSelfStatic<&mut aztec::context::private_context::PrivateContext> = CallSelfStatic { address: self_address, context: &mut context };\n            let enqueue_self_static: EnqueueSelfStatic<&mut aztec::context::private_context::PrivateContext> = EnqueueSelfStatic { address: self_address, context: &mut context };\n            let internal: CallInternal<&mut aztec::context::private_context::PrivateContext> = CallInternal { context: &mut context };\n            aztec::contract_self::ContractSelf::new_private(&mut context, storage, call_self, enqueue_self, call_self_static, enqueue_self_static, internal)\n        };\n    };\n\n    let original_function_name = f.name();\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_only_self(f) {\n        let assertion_message =\n            f\"Function {original_function_name} can only be called by the same contract\";\n        quote { assert(self.msg_sender().unwrap() == self.address, $assertion_message); }\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        let assertion_message = f\"Function {original_function_name} can only be called statically\"\n            .as_ctstring()\n            .as_quoted_str();\n        quote { assert(self.context.inputs.call_context.is_static_call, $assertion_message); }\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (\n            quote { aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_private(*self.context); },\n            quote { aztec::macros::functions::initialization_utils::mark_as_initialized_private(self.context); },\n        )\n    } else {\n        (quote {}, quote {})\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) {\n        quote { aztec::macros::functions::initialization_utils::assert_is_initialized_private(self.context); }\n    } else {\n        quote {}\n    };\n\n    // All private functions perform message discovery, since they may need to access notes. This is slightly\n    // inefficient and could be improved by only doing it once we actually attempt to read any. Note that the message\n    // discovery call syncs private events as well. We do not sync those here if there are no notes because we don't\n    // have an API that would access events from private functions.\n    let message_discovery_call = if NOTES.len() > 0 {\n        create_message_discovery_call()\n    } else {\n        quote {}\n    };\n\n    // Inject the authwit check if the function is marked with #[authorize_once].\n    let authorize_once_check = if fn_has_authorize_once(f) {\n        create_authorize_once_check(f, true)\n    } else {\n        quote {}\n    };\n\n    // Finally, we need to change the return type to be `PrivateCircuitPublicInputs`, which is what the Private Kernel\n    // circuit expects.\n    let return_value_var_name = quote { macro__returned__values };\n\n    let return_value_type = f.return_type();\n    let return_value = if body.len() == 0 {\n        quote {}\n    } else if return_value_type != type_of(()) {\n        // The original return value is serialized and hashed before being passed to the context.\n        let (body_without_return, last_body_expr) = body.pop_back();\n        let return_value = last_body_expr.quoted();\n        let return_value_assignment =\n            quote { let $return_value_var_name: $return_value_type = $return_value; };\n\n        let (return_serialization, _, serialized_return_name) =\n            derive_serialization_quotes([(return_value_var_name, return_value_type)], false);\n\n        body = body_without_return;\n\n        quote {\n            $return_value_assignment\n            $return_serialization\n            self.context.set_return_hash($serialized_return_name);\n        }\n    } else {\n        let (body_without_return, last_body_expr) = body.pop_back();\n        if !last_body_expr.has_semicolon()\n            & last_body_expr.as_for().is_none()\n            & last_body_expr.as_assert().is_none()\n            & last_body_expr.as_for_range().is_none()\n            & last_body_expr.as_assert_eq().is_none()\n            & last_body_expr.as_let().is_none() {\n            let unused_return_value_name = f\"_{return_value_var_name}\".quoted_contents();\n            body = body_without_return.push_back(\n                quote { let $unused_return_value_name = $last_body_expr; }.as_expr().unwrap(),\n            );\n        }\n        quote {}\n    };\n\n    let context_finish = quote { self.context.finish() };\n\n    // Preserve all attributes that are relevant to the function's ABI.\n    let abi_relevant_attributes = get_abi_relevant_attributes(f);\n\n    let fn_name = f\"__aztec_nr_internals__{original_function_name}\".quoted_contents();\n\n    let to_prepend = quote {\n        dep::aztec::oracle::version::assert_compatible_oracle_version();\n        $contract_self_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $message_discovery_call\n        $authorize_once_check\n    };\n\n    let body_quote = body.map(|expr| expr.quoted()).join(quote { });\n\n    let to_append = quote {\n        $return_value\n        $mark_as_initialized\n        $context_finish\n    };\n\n    quote {\n        #[aztec::macros::internals_functions_generation::abi_attributes::abi_private]\n        $abi_relevant_attributes\n        fn $fn_name($params) -> return_data aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs {\n            $to_prepend\n            $body_quote\n            $to_append\n        }\n    }\n}\n\npub(crate) comptime fn transform_public(f: FunctionDefinition) -> Quoted {\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Public functions undergo a lot of transformations from their Aztec.nr form.\n    let original_params = f.parameters();\n\n    let args_len_quote = if original_params.len() == 0 {\n        // If the function has no parameters, we set the args_len to 0.\n        quote { 0 }\n    } else {\n        // The following will give us <type_of_struct_member_1 as Serialize>::N + <type_of_struct_member_2 as Serialize>::N + ...\n        original_params\n            .map(|(_, param_type): (Quoted, Type)| {\n                quote {\n            <$param_type as $crate::protocol_types::traits::Serialize>::N\n        }\n            })\n            .join(quote {+})\n    };\n\n    let storage_init = if module_has_storage {\n        quote {\n            let storage = Storage::init(context);\n        }\n    } else {\n        // Contract does not have Storage defined, so we set storage to the unit type `()`. ContractSelf requires a\n        // storage struct in its constructor. Using an Option type would lead to worse developer experience and higher\n        // constraint counts so we use the unit type `()` instead.\n        quote {\n            let storage = ();\n        }\n    };\n\n    // Unlike in the private case, in public the `context` does not need to receive the hash of the original params.\n    let contract_self_creation = quote {\n        #[allow(unused_variables)]\n        let mut self = {\n            let context = dep::aztec::context::public_context::PublicContext::new(|| {\n            // We start from 1 because we skip the selector for the dispatch function.\n            let serialized_args : [Field; $args_len_quote] = dep::aztec::context::public_context::calldata_copy(1, $args_len_quote);\n            dep::aztec::hash::hash_args_array(serialized_args)\n            });\n            $storage_init\n            let self_address = context.this_address();\n            let call_self: CallSelf<aztec::context::public_context::PublicContext> = CallSelf { address: self_address, context };\n            let call_self_static: CallSelfStatic<aztec::context::public_context::PublicContext> = CallSelfStatic { address: self_address, context };\n            let internal: CallInternal<aztec::context::public_context::PublicContext> = CallInternal { context };\n            aztec::contract_self::ContractSelf::new_public(context, storage, call_self, call_self_static, internal)\n        };\n    };\n\n    let original_function_name = f.name();\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_only_self(f) {\n        let assertion_message =\n            f\"Function {original_function_name} can only be called by the same contract\";\n        quote { assert(self.msg_sender().unwrap() == self.address, $assertion_message); }\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        let assertion_message = f\"Function {original_function_name} can only be called statically\"\n            .as_ctstring()\n            .as_quoted_str();\n        quote { assert(self.context.is_static_call(), $assertion_message); }\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (\n            quote { aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_public(self.context); },\n            quote { aztec::macros::functions::initialization_utils::mark_as_initialized_public(self.context); },\n        )\n    } else {\n        (quote {}, quote {})\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {\n        quote { aztec::macros::functions::initialization_utils::assert_is_initialized_public(self.context); }\n    } else {\n        quote {}\n    };\n\n    // Inject the authwit check if the function is marked with #[authorize_once].\n    let authorize_once_check = if fn_has_authorize_once(f) {\n        create_authorize_once_check(f, false)\n    } else {\n        quote {}\n    };\n\n    let to_prepend = quote {\n        $contract_self_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $authorize_once_check\n    };\n\n    let to_append = quote {\n        $mark_as_initialized\n    };\n\n    let fn_name = f\"__aztec_nr_internals__{original_function_name}\".quoted_contents();\n    let body = f.body();\n    let return_type = f.return_type();\n\n    // New function parameters are the same as the original function's ones.\n    let params = original_params\n        .map(|(param_name, param_type)| quote { $param_name: $param_type })\n        .join(quote {, });\n\n    // Preserve all attributes that are relevant to the function's ABI.\n    let abi_relevant_attributes = get_abi_relevant_attributes(f);\n\n    // All public functions are automatically made unconstrained, even if they were not marked as such. This is because\n    // instead of compiling into a circuit, they will compile to bytecode that will be later transpiled into AVM\n    // bytecode.\n    quote {\n        #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n        $abi_relevant_attributes\n        unconstrained fn $fn_name($params) -> pub $return_type {\n            $to_prepend\n            $body\n            $to_append\n        }\n    }\n}\n\npub(crate) comptime fn transform_utility(f: FunctionDefinition) -> Quoted {\n    // Initialize Storage if module has storage\n    let storage_init = if module_has_storage(f.module()) {\n        quote {\n            let storage = Storage::init(context);\n        }\n    } else {\n        // Contract does not have Storage defined, so we set storage to the unit type `()`. ContractSelf requires a\n        // storage struct in its constructor. Using an Option type would lead to worse developer experience and higher\n        // constraint counts so we use the unit type `()` instead.\n        quote {\n            let storage = ();\n        }\n    };\n\n    // Create utility context\n    let contract_self_creation = quote {\n        #[allow(unused_variables)]\n        let mut self = {\n            let context = dep::aztec::context::utility_context::UtilityContext::new();\n            $storage_init\n            aztec::contract_self::ContractSelf::new_utility(context, storage)\n        };\n    };\n\n    // All utility functions perform message discovery, since they may need to access private notes that would be\n    // found during this process or they may be used to sync private events from TypeScript\n    // (`sync_private_state` function gets invoked by PXE::getPrivateEvents function).\n    let message_discovery_call = create_message_discovery_call();\n\n    // A quote to be injected at the beginning of the function body.\n    let to_prepend = quote {\n        dep::aztec::oracle::version::assert_compatible_oracle_version();\n        $contract_self_creation\n        $message_discovery_call\n    };\n\n    let original_function_name = f.name();\n    let fn_name = f\"__aztec_nr_internals__{original_function_name}\".quoted_contents();\n    let body = f.body();\n    let params = f\n        .parameters()\n        .map(|(param_name, param_type)| quote { $param_name: $param_type })\n        .join(quote {, });\n    let return_type = f.return_type();\n\n    quote {\n        #[aztec::macros::internals_functions_generation::abi_attributes::abi_utility]\n        unconstrained fn $fn_name($params) -> pub $return_type {\n            $to_prepend\n            $body\n        }\n    }\n}\n\n/// Injects a call to `aztec::messages::discovery::discover_new_messages`, causing for new notes to be added to PXE and made\n/// available for the current execution.\npub(crate) comptime fn create_message_discovery_call() -> Quoted {\n    quote {\n        /// Safety: message discovery returns nothing and is performed solely for its side-effects. It is therefore\n        /// always safe to call.\n        unsafe {\n            dep::aztec::messages::discovery::discover_new_messages(\n                self.address,\n                _compute_note_hash_and_nullifier,\n            );\n        };\n    }\n}\n\n/// Injects an authwit verification check of the form:\n/// ```\n///   if (!from.eq(context.msg_sender().unwrap())) {\n///         assert_current_call_valid_authwit::<N>(&mut context, from);\n///     } else {\n///         assert(authwit_nonce, \"Invalid authwit nonce. When 'from' and 'msg_sender' are the same, authwit_nonce must be zero\");\n///     }\n/// ```\n/// where `from` and `authwit_nonce` are the names of the parameters that are expected to be present in the function definition.\n/// This check is injected by the `#[authorize_once(\"from_arg_name\", \"nonce_arg_name\")]`, which allows the user to define\n/// which parameters to use.\n///\n/// # Arguments\n/// * `f` - The function definition to inject the authwit verification check into. The function must have parameters\n///         matching the names specified in the `#[authorize_once]` attribute.\n/// * `is_private` - Whether the function is a private function (`true`) or a public function (`false`). This determines\n///                  which authwit verification method to use: `assert_current_call_valid_authwit` for private functions\n///                  or `assert_current_call_valid_authwit_public` for public functions.\npub(crate) comptime fn create_authorize_once_check(\n    f: FunctionDefinition,\n    is_private: bool,\n) -> Quoted {\n    let maybe_authorize_once_args = AUTHORIZE_ONCE_REGISTRY.get(f);\n    let authorize_once_args = if maybe_authorize_once_args.is_some() {\n        maybe_authorize_once_args.unwrap()\n    } else {\n        // We need to for authorize_once to have already executed so that we can retrieve its params - this depends on\n        // the order in which the attributes are applied.\n        panic(\n            f\"Functions marked with #[authorize_once] must have the #[external(\\\"private\\\")] or #[external(\\\"public\\\")] attribute placed last\",\n        )\n    };\n\n    let (from_arg_name, nonce_arg_name) = authorize_once_args;\n    let name: Quoted = f.name();\n\n    let from_arg_candidates =\n        f.parameters().filter(|(name, _)| name == f\"{from_arg_name}\".quoted_contents());\n    let (from_arg_name_quoted, from_arg_type) = if from_arg_candidates.len() == 1 {\n        from_arg_candidates[0]\n    } else {\n        panic(\n            f\"Function {name} does not have a {from_arg_name} parameter. Please specify which one to use in #[authorize_once(\\\"...\\\", \\\"authwit_nonce\\\")]\",\n        )\n    };\n    if from_arg_type\n        != quote { dep::protocol_types::address::aztec_address::AztecAddress }.as_type() {\n        panic(\n            f\"Argument {from_arg_name_quoted} in function {name} must be of type AztecAddress, but is of type {from_arg_type}\",\n        )\n    }\n\n    let nonce_arg_candidates =\n        f.parameters().filter(|(name, _)| name == f\"{nonce_arg_name}\".quoted_contents());\n    let (nonce_arg_name_quoted, nonce_arg_type) = if nonce_arg_candidates.len() == 1 {\n        nonce_arg_candidates[0]\n    } else {\n        panic(\n            f\"Function {name} does not have a {nonce_arg_name}. Please specify which one to use in #[authorize_once(\\\"from\\\", \\\"...\\\")]\",\n        )\n    };\n    if nonce_arg_type != quote { Field }.as_type() {\n        panic(\n            f\"Argument {nonce_arg_name_quoted} in function {name} must be of type Field, but is of type {nonce_arg_type}\",\n        );\n    }\n\n    let nonce_check_quote = f\"{nonce_arg_name_quoted} == 0\".quoted_contents();\n\n    let fn_call = if is_private {\n        let args_len = f.parameters().len();\n        quote { dep::aztec::authwit::auth::assert_current_call_valid_authwit::<$args_len> }\n    } else {\n        quote { dep::aztec::authwit::auth::assert_current_call_valid_authwit_public }\n    };\n    let invalid_nonce_message = f\"Invalid authwit nonce. When '{from_arg_name}' and 'msg_sender' are the same, '{nonce_arg_name}' must be zero\"\n        .as_ctstring()\n        .as_quoted_str();\n    quote {         \n        if (!$from_arg_name_quoted.eq(self.msg_sender().unwrap())) {\n            $fn_call(self.context, $from_arg_name_quoted);\n        } else {\n            assert($nonce_check_quote, $invalid_nonce_message);\n        }\n    }\n}\n\n/// Checks if each function in the module is marked with either #[external(...)], #[contract_library_method], or #[test].\n/// Non-macroified functions are not allowed in contracts.\npub(crate) comptime fn check_each_fn_macroified(m: Module) {\n    for f in m.functions() {\n        let name = f.name();\n        if !is_fn_external(f)\n            & !is_fn_contract_library_method(f)\n            & !is_fn_internal(f)\n            & !is_fn_test(f) {\n            // We  don't suggest that #[contract_library_method] is allowed because we don't want to introduce another\n            // concept\n            panic(\n                f\"Function {name} must be marked as either #[external(...)], #[internal(...)], or #[test]\",\n            );\n        }\n    }\n}\n"
     },
-    "120": {
+    "121": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/discovery/mod.nr",
       "source": "use protocol_types::{address::AztecAddress, debug_log::{debug_log, debug_log_format}};\n\npub mod nonce_discovery;\npub mod partial_notes;\npub mod private_events;\npub mod private_notes;\npub mod process_message;\n\nuse crate::{\n    messages::{\n        discovery::{\n            private_notes::MAX_NOTE_PACKED_LEN, process_message::process_message_ciphertext,\n        },\n        processing::{\n            get_private_logs, pending_tagged_log::PendingTaggedLog,\n            validate_enqueued_notes_and_events,\n        },\n    },\n    utils::array,\n};\n\npub struct NoteHashAndNullifier {\n    /// The result of NoteHash::compute_note_hash\n    pub note_hash: Field,\n    /// The result of NoteHash::compute_nullifier_unconstrained (since all of message discovery is unconstrained)\n    pub inner_nullifier: Field,\n}\n\n/// A function which takes a note's packed content, address of the emitting contract, note nonce, storage slot and note\n/// type ID and attempts to compute its note hash (not hashed by note nonce nor siloed by address) and inner nullifier\n/// (not siloed by address).\n///\n/// This function must be user-provided as its implementation requires knowledge of how note type IDs are allocated in a\n/// contract. The `#[aztec]` macro automatically creates such a contract library method called\n/// `_compute_note_hash_and_nullifier`, which looks something like this:\n///\n/// ```\n/// |packed_note, contract_address, note_nonce, storage_slot, note_type_id| {\n///     if note_type_id == MyNoteType::get_id() {\n///         assert(packed_note.len() == MY_NOTE_TYPE_SERIALIZATION_LENGTH);\n///\n///         let note = MyNoteType::unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n///\n///         let note_hash = note.compute_note_hash(storage_slot);\n///         let note_hash_for_nullification = aztec::note::utils::compute_note_hash_for_nullification(\n///             RetrievedNote{ note, contract_address, metadata: SettledNoteMetadata::new(note_nonce).into() },\n///             storage_slot\n///         );\n///\n///         let inner_nullifier = note.compute_nullifier_unconstrained(note_hash_for_nullification);\n///\n///         Option::some(\n///             aztec::messages::discovery::NoteHashAndNullifier {\n///                 note_hash, inner_nullifier\n///             }\n///         )\n///     } else if note_type_id == MyOtherNoteType::get_id() {\n///           ... // Similar to above but calling MyOtherNoteType::unpack_content\n///     } else {\n///         Option::none() // Unknown note type ID\n///     };\n/// }\n/// ```\npub type ComputeNoteHashAndNullifier<Env> = unconstrained fn[Env](/* packed_note */BoundedVec<Field, MAX_NOTE_PACKED_LEN>, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress, /* note nonce */ Field) -> Option<NoteHashAndNullifier>;\n\n/// Performs the message discovery process, in which private logs are downloaded and inspected to find new private\n/// notes, partial notes and events, etc., and pending partial notes are processed to search for their completion logs.\n/// This is the mechanism via which a contract updates its knowledge of its private state.\n///\n/// Note that the state is synchronized up to the latest block synchronized by PXE. That should be close to the chain\n/// tip as block synchronization is performed before contract function simulation is done.\n///\n/// Receives the address of the contract on which discovery is performed along with its\n/// `compute_note_hash_and_nullifier` function.\npub unconstrained fn discover_new_messages<Env>(\n    contract_address: AztecAddress,\n    compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n) {\n    debug_log(\"Performing message discovery\");\n\n    // First we process all private logs, which can contain different kinds of messages e.g. private notes, partial\n    // notes, private events, etc.\n    let mut logs = get_private_logs(contract_address);\n    logs.for_each(|i, pending_tagged_log: PendingTaggedLog| {\n        debug_log_format(\n            \"Processing log with tag {0}\",\n            [pending_tagged_log.log.get(0)],\n        );\n\n        // We remove the tag from the pending tagged log and process the message ciphertext contained in it.\n        let message_ciphertext = array::subbvec(pending_tagged_log.log, 1);\n\n        process_message_ciphertext(\n            contract_address,\n            compute_note_hash_and_nullifier,\n            message_ciphertext,\n            pending_tagged_log.context,\n        );\n        logs.remove(i);\n    });\n\n    // Then we process all pending partial notes, regardless of whether they were found in the current or previous\n    // executions.\n    partial_notes::fetch_and_process_partial_note_completion_logs(\n        contract_address,\n        compute_note_hash_and_nullifier,\n    );\n\n    // Finally we validate all notes and events that were found as part of the previous processes, resulting in them\n    // being added to PXE's database and retrievable via oracles (get_notes) and our TS API (PXE::getPrivateEvents).\n    validate_enqueued_notes_and_events(contract_address);\n}\n"
     },
-    "121": {
+    "122": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/discovery/nonce_discovery.nr",
       "source": "use crate::messages::discovery::{ComputeNoteHashAndNullifier, private_notes::MAX_NOTE_PACKED_LEN};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    constants::MAX_NOTE_HASHES_PER_TX,\n    debug_log::debug_log_format,\n    hash::{compute_note_hash_nonce, compute_siloed_note_hash, compute_unique_note_hash},\n    traits::ToField,\n};\n\n/// A struct with the discovered information of a complete note, required for delivery to PXE. Note that this is *not*\n/// the complete note information, since it does not include content, storage slot, etc.\npub struct DiscoveredNoteInfo {\n    pub note_nonce: Field,\n    pub note_hash: Field,\n    pub inner_nullifier: Field,\n}\n\n/// Searches for note nonces that will result in a note that was emitted in a transaction. While rare, it is possible\n/// for multiple notes to have the exact same packed content and storage slot but different nonces, resulting in\n/// different unique note hashes. Because of this this function returns a *vector* of discovered notes, though in most\n/// cases it will contain a single element.\n///\n/// Due to how nonces are computed, this function requires knowledge of the transaction in which the note was created,\n/// more specifically the list of all unique note hashes in it plus the value of its first nullifier.\npub unconstrained fn attempt_note_nonce_discovery<Env>(\n    unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,\n    first_nullifier_in_tx: Field,\n    compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n    contract_address: AztecAddress,\n    storage_slot: Field,\n    note_type_id: Field,\n    packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n) -> BoundedVec<DiscoveredNoteInfo, MAX_NOTE_HASHES_PER_TX> {\n    let discovered_notes = &mut BoundedVec::new();\n\n    debug_log_format(\n        \"Attempting nonce discovery on {0} potential notes on contract {1} for storage slot {2}\",\n        [unique_note_hashes_in_tx.len() as Field, contract_address.to_field(), storage_slot],\n    );\n\n    // We need to find nonces (typically just one) that result in a note hash that, once siloed into a unique note hash,\n    // is one of the note hashes created by the transaction.\n    unique_note_hashes_in_tx.for_eachi(|i, expected_unique_note_hash| {\n        // Nonces are computed by hashing the first nullifier in the transaction with the index of the note in the\n        // new note hashes array. We therefore know for each note in every transaction what its nonce is.\n        let candidate_nonce = compute_note_hash_nonce(first_nullifier_in_tx, i);\n\n        // Given note nonce, note content and metadata, we can compute the note hash and silo it to check if it matches\n        // the note hash at the array index we're currently processing.\n        // TODO(#11157): handle failed note_hash_and_nullifier computation\n        let hashes = compute_note_hash_and_nullifier(\n            packed_note,\n            storage_slot,\n            note_type_id,\n            contract_address,\n            candidate_nonce,\n        )\n            .expect(f\"Failed to compute a note hash for note type {note_type_id}\");\n\n        let siloed_note_hash = compute_siloed_note_hash(contract_address, hashes.note_hash);\n        let unique_note_hash = compute_unique_note_hash(candidate_nonce, siloed_note_hash);\n\n        if unique_note_hash == expected_unique_note_hash {\n            // Note that while we did check that the note hash is the preimage of the expected unique note hash, we\n            // perform no validations on the nullifier - we fundamentally cannot, since only the application knows\n            // how to compute nullifiers. We simply trust it to have provided the correct one: if it hasn't, then\n            // PXE may fail to realize that a given note has been nullified already, and calls to the application\n            // could result in invalid transactions (with duplicate nullifiers). This is not a concern because an\n            // application already has more direct means of making a call to it fail the transaction.\n            discovered_notes.push(\n                DiscoveredNoteInfo {\n                    note_nonce: candidate_nonce,\n                    note_hash: hashes.note_hash,\n                    inner_nullifier: hashes.inner_nullifier,\n                },\n            );\n\n            // We don't exit the loop - it is possible (though rare) for the exact same note content to be present\n            // multiple times in the same transaction with different nonces. This typically doesn't happen due to\n            // notes containing random values in order to hide their contents.\n        }\n    });\n\n    debug_log_format(\n        \"Found valid nonces for a total of {0} notes\",\n        [discovered_notes.len() as Field],\n    );\n\n    *discovered_notes\n}\n\nmod test {\n    use crate::{\n        messages::discovery::{NoteHashAndNullifier, private_notes::MAX_NOTE_PACKED_LEN},\n        note::{\n            note_interface::{NoteHash, NoteType},\n            note_metadata::SettledNoteMetadata,\n            retrieved_note::RetrievedNote,\n            utils::compute_note_hash_for_nullification,\n        },\n        oracle::random::random,\n        test::mocks::mock_note::MockNote,\n        utils::array,\n    };\n\n    use dep::protocol_types::{\n        address::AztecAddress,\n        hash::{compute_note_hash_nonce, compute_siloed_note_hash, compute_unique_note_hash},\n        traits::{FromField, Packable},\n    };\n\n    use super::attempt_note_nonce_discovery;\n\n    // This implementation could be simpler, but this serves as a nice example of the expected flow in a real\n    // implementation, and as a sanity check that the interface is sufficient.\n    unconstrained fn compute_note_hash_and_nullifier(\n        packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n        storage_slot: Field,\n        note_type_id: Field,\n        contract_address: AztecAddress,\n        note_nonce: Field,\n    ) -> Option<NoteHashAndNullifier> {\n        if note_type_id == MockNote::get_id() {\n            let note = MockNote::unpack(array::subarray(packed_note.storage(), 0));\n            let note_hash = note.compute_note_hash(storage_slot);\n\n            let note_hash_for_nullification = compute_note_hash_for_nullification(\n                RetrievedNote {\n                    note,\n                    contract_address,\n                    metadata: SettledNoteMetadata::new(note_nonce).into(),\n                },\n                storage_slot,\n            );\n\n            let inner_nullifier = note.compute_nullifier_unconstrained(note_hash_for_nullification);\n\n            Option::some(NoteHashAndNullifier { note_hash, inner_nullifier })\n        } else {\n            Option::none()\n        }\n    }\n\n    global VALUE: Field = 7;\n    global FIRST_NULLIFIER_IN_TX: Field = 47;\n    global CONTRACT_ADDRESS: AztecAddress = AztecAddress::from_field(13);\n    global STORAGE_SLOT: Field = 99;\n\n    #[test]\n    unconstrained fn no_note_hashes() {\n        let unique_note_hashes_in_tx = BoundedVec::new();\n        let packed_note = BoundedVec::new();\n\n        let discovered_notes = attempt_note_nonce_discovery(\n            unique_note_hashes_in_tx,\n            FIRST_NULLIFIER_IN_TX,\n            compute_note_hash_and_nullifier,\n            CONTRACT_ADDRESS,\n            STORAGE_SLOT,\n            MockNote::get_id(),\n            packed_note,\n        );\n\n        assert_eq(discovered_notes.len(), 0);\n    }\n\n    #[test(should_fail_with = \"Failed to compute a note hash\")]\n    unconstrained fn failed_hash_computation() {\n        let unique_note_hashes_in_tx = BoundedVec::from_array([random()]);\n        let packed_note = BoundedVec::new();\n        let note_type_id = 0; // This note type id is unknown to compute_note_hash_and_nullifier\n\n        let discovered_notes = attempt_note_nonce_discovery(\n            unique_note_hashes_in_tx,\n            FIRST_NULLIFIER_IN_TX,\n            compute_note_hash_and_nullifier,\n            CONTRACT_ADDRESS,\n            STORAGE_SLOT,\n            note_type_id,\n            packed_note,\n        );\n\n        assert_eq(discovered_notes.len(), 0);\n    }\n\n    struct NoteAndData {\n        note: MockNote,\n        note_nonce: Field,\n        note_hash: Field,\n        unique_note_hash: Field,\n        inner_nullifier: Field,\n    }\n\n    unconstrained fn construct_note(value: Field, note_index_in_tx: u32) -> NoteAndData {\n        let note_nonce = compute_note_hash_nonce(FIRST_NULLIFIER_IN_TX, note_index_in_tx);\n\n        let retrieved_note = MockNote::new(value)\n            .contract_address(CONTRACT_ADDRESS)\n            .note_metadata(SettledNoteMetadata::new(note_nonce).into())\n            .build_retrieved_note();\n        let note = retrieved_note.note;\n\n        let note_hash = note.compute_note_hash(STORAGE_SLOT);\n        let unique_note_hash = compute_unique_note_hash(\n            note_nonce,\n            compute_siloed_note_hash(CONTRACT_ADDRESS, note_hash),\n        );\n        let inner_nullifier = note.compute_nullifier_unconstrained(\n            compute_note_hash_for_nullification(retrieved_note, STORAGE_SLOT),\n        );\n\n        NoteAndData { note, note_nonce, note_hash, unique_note_hash, inner_nullifier }\n    }\n\n    #[test]\n    unconstrained fn single_note() {\n        let note_index_in_tx = 2;\n        let note_and_data = construct_note(VALUE, note_index_in_tx);\n\n        let mut unique_note_hashes_in_tx = BoundedVec::from_array([\n            random(), random(), random(), random(), random(), random(), random(),\n        ]);\n        unique_note_hashes_in_tx.set(note_index_in_tx, note_and_data.unique_note_hash);\n\n        let discovered_notes = attempt_note_nonce_discovery(\n            unique_note_hashes_in_tx,\n            FIRST_NULLIFIER_IN_TX,\n            compute_note_hash_and_nullifier,\n            CONTRACT_ADDRESS,\n            STORAGE_SLOT,\n            MockNote::get_id(),\n            BoundedVec::from_array(note_and_data.note.pack()),\n        );\n\n        assert_eq(discovered_notes.len(), 1);\n        let discovered_note = discovered_notes.get(0);\n\n        assert_eq(discovered_note.note_nonce, note_and_data.note_nonce);\n        assert_eq(discovered_note.note_hash, note_and_data.note_hash);\n        assert_eq(discovered_note.inner_nullifier, note_and_data.inner_nullifier);\n    }\n\n    #[test]\n    unconstrained fn multiple_notes_same_preimage() {\n        let first_note_index_in_tx = 3;\n        let first_note_and_data = construct_note(VALUE, first_note_index_in_tx);\n\n        let second_note_index_in_tx = 5;\n        let second_note_and_data = construct_note(VALUE, second_note_index_in_tx);\n\n        // Both notes have the same preimage (and therefore packed representation), so both should be found in the same\n        // call.\n        assert_eq(first_note_and_data.note, second_note_and_data.note);\n        let packed_note = first_note_and_data.note.pack();\n\n        let mut unique_note_hashes_in_tx = BoundedVec::from_array([\n            random(), random(), random(), random(), random(), random(), random(),\n        ]);\n        unique_note_hashes_in_tx.set(first_note_index_in_tx, first_note_and_data.unique_note_hash);\n        unique_note_hashes_in_tx.set(second_note_index_in_tx, second_note_and_data.unique_note_hash);\n\n        let discovered_notes = attempt_note_nonce_discovery(\n            unique_note_hashes_in_tx,\n            FIRST_NULLIFIER_IN_TX,\n            compute_note_hash_and_nullifier,\n            CONTRACT_ADDRESS,\n            STORAGE_SLOT,\n            MockNote::get_id(),\n            BoundedVec::from_array(packed_note),\n        );\n\n        assert_eq(discovered_notes.len(), 2);\n\n        assert(discovered_notes.any(|discovered_note| {\n            (discovered_note.note_nonce == first_note_and_data.note_nonce)\n                & (discovered_note.note_hash == first_note_and_data.note_hash)\n                & (discovered_note.inner_nullifier == first_note_and_data.inner_nullifier)\n        }));\n\n        assert(discovered_notes.any(|discovered_note| {\n            (discovered_note.note_nonce == second_note_and_data.note_nonce)\n                & (discovered_note.note_hash == second_note_and_data.note_hash)\n                & (discovered_note.inner_nullifier == second_note_and_data.inner_nullifier)\n        }));\n    }\n}\n"
     },
-    "122": {
+    "123": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/discovery/partial_notes.nr",
       "source": "use crate::{\n    capsules::CapsuleArray,\n    messages::{\n        discovery::{ComputeNoteHashAndNullifier, nonce_discovery::attempt_note_nonce_discovery},\n        encoding::MAX_MESSAGE_CONTENT_LEN,\n        processing::{\n            enqueue_note_for_validation, get_pending_partial_notes_completion_logs,\n            log_retrieval_response::LogRetrievalResponse,\n        },\n    },\n    utils::array,\n};\n\nuse protocol_types::{\n    address::AztecAddress,\n    debug_log::debug_log_format,\n    hash::sha256_to_field,\n    traits::{Deserialize, Serialize},\n};\n\nglobal PARTIAL_NOTE_PRIVATE_MSG_CONTENT_NON_NOTE_FIELDS_LEN: u32 = 2;\n\n/// Partial notes have a maximum packed length of their private fields bound by extra content in their private message\n/// (e.g. the storage slot, note completion log tag, etc.).\npub global MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN: u32 =\n    MAX_MESSAGE_CONTENT_LEN - PARTIAL_NOTE_PRIVATE_MSG_CONTENT_NON_NOTE_FIELDS_LEN;\n\n/// The slot in the PXE capsules where we store a `CapsuleArray` of `DeliveredPendingPartialNote`.\npub global DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT\".as_bytes(),\n);\n\n/// A partial note that was delivered but is still pending completion. Contains the information necessary to find the\n/// log that will complete it and lead to a note being discovered and delivered.\n#[derive(Serialize, Deserialize)]\npub(crate) struct DeliveredPendingPartialNote {\n    pub(crate) note_completion_log_tag: Field,\n    pub(crate) storage_slot: Field,\n    pub(crate) note_type_id: Field,\n    pub(crate) packed_private_note_content: BoundedVec<Field, MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN>,\n    pub(crate) recipient: AztecAddress,\n}\n\npub unconstrained fn process_partial_note_private_msg(\n    contract_address: AztecAddress,\n    recipient: AztecAddress,\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n) {\n    let (note_type_id, storage_slot, note_completion_log_tag, packed_private_note_content) =\n        decode_partial_note_private_msg(msg_metadata, msg_content);\n\n    // We store the information of the partial note we found in a persistent capsule in PXE, so that we can later search\n    // for the public log that will complete it.\n    let pending = DeliveredPendingPartialNote {\n        note_completion_log_tag,\n        storage_slot,\n        note_type_id,\n        packed_private_note_content,\n        recipient,\n    };\n\n    CapsuleArray::at(\n        contract_address,\n        DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT,\n    )\n        .push(pending);\n}\n\n/// Searches for logs that would result in the completion of pending partial notes, ultimately resulting in the notes\n/// being delivered to PXE if completed.\npub unconstrained fn fetch_and_process_partial_note_completion_logs<Env>(\n    contract_address: AztecAddress,\n    compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n) {\n    let pending_partial_notes = CapsuleArray::at(\n        contract_address,\n        DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT,\n    );\n\n    debug_log_format(\n        \"{} pending partial notes\",\n        [pending_partial_notes.len() as Field],\n    );\n\n    // Each of the pending partial notes might get completed by a log containing its public values. For performance\n    // reasons, we fetch all of these logs concurrently and then process them one by one, minimizing the amount of time\n    // waiting for the node roundtrip.\n    let maybe_completion_logs =\n        get_pending_partial_notes_completion_logs(contract_address, pending_partial_notes);\n\n    // Each entry in the maybe completion logs array corresponds to the entry in the pending partial notes array at the\n    // same index. This means we can use the same index as we iterate through the responses to get both the partial note\n    // and the log that might complete it.\n    assert_eq(maybe_completion_logs.len(), pending_partial_notes.len());\n\n    maybe_completion_logs.for_each(|i, maybe_log: Option<LogRetrievalResponse>| {\n        // We clear the completion logs as we read them so that the array is empty by the time we next query it.\n        // TODO(#14943): use volatile arrays to avoid having to manually clear this.\n        maybe_completion_logs.remove(i);\n\n        let pending_partial_note = pending_partial_notes.get(i);\n\n        if maybe_log.is_none() {\n            debug_log_format(\n                \"Found no completion logs for partial note with tag {}\",\n                [pending_partial_note.note_completion_log_tag],\n            );\n\n            // Note that we're not removing the pending partial note from the capsule array, so we will continue\n            // searching for this tagged log when performing message discovery in the future until we either find it or\n            // the entry is somehow removed from the array.\n        } else {\n            debug_log_format(\n                \"Completion log found for partial note with tag {}\",\n                [pending_partial_note.note_completion_log_tag],\n            );\n            let log = maybe_log.unwrap();\n\n            // Public fields are assumed to all be placed at the end of the packed representation, so we combine the\n            // private and public packed fields (i.e. the contents of the private message and public log plaintext to get\n            // the complete packed content.\n            let complete_packed_note = array::append(\n                pending_partial_note.packed_private_note_content,\n                log.log_payload,\n            );\n\n            let discovered_notes = attempt_note_nonce_discovery(\n                log.unique_note_hashes_in_tx,\n                log.first_nullifier_in_tx,\n                compute_note_hash_and_nullifier,\n                contract_address,\n                pending_partial_note.storage_slot,\n                pending_partial_note.note_type_id,\n                complete_packed_note,\n            );\n\n            // TODO(#11627): is there anything reasonable we can do if we get a log but it doesn't result in a note\n            // being found?\n            if discovered_notes.len() == 0 {\n                panic(\n                    f\"A partial note's completion log did not result in any notes being found - this should never happen\",\n                );\n            }\n\n            debug_log_format(\n                \"Discovered {0} notes for partial note with tag {1}\",\n                [discovered_notes.len() as Field, pending_partial_note.note_completion_log_tag],\n            );\n\n            discovered_notes.for_each(|discovered_note| {\n                enqueue_note_for_validation(\n                    contract_address,\n                    pending_partial_note.storage_slot,\n                    discovered_note.note_nonce,\n                    complete_packed_note,\n                    discovered_note.note_hash,\n                    discovered_note.inner_nullifier,\n                    log.tx_hash,\n                    pending_partial_note.recipient,\n                );\n            });\n\n            // Because there is only a single log for a given tag, once we've processed the tagged log then we\n            // simply delete the pending work entry, regardless of whether it was actually completed or not.\n            pending_partial_notes.remove(i);\n        }\n    });\n}\n\nfn decode_partial_note_private_msg(\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n) -> (Field, Field, Field, BoundedVec<Field, MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN>) {\n    let note_type_id = msg_metadata as Field; // TODO: make note type id not be a full field\n\n    assert(\n        msg_content.len() > PARTIAL_NOTE_PRIVATE_MSG_CONTENT_NON_NOTE_FIELDS_LEN,\n        f\"Invalid private note message: all partial note private messages must have at least {PARTIAL_NOTE_PRIVATE_MSG_CONTENT_NON_NOTE_FIELDS_LEN} fields\",\n    );\n\n    // If PARTIAL_NOTE_PRIVATE_MSG_CONTENT_NON_NOTE_FIELDS_LEN is changed, causing the assertion below to fail, then the\n    // destructuring of the partial note private message encoding below must be updated as well.\n    std::static_assert(\n        PARTIAL_NOTE_PRIVATE_MSG_CONTENT_NON_NOTE_FIELDS_LEN == 2,\n        \"unexpected value for PARTIAL_NOTE_PRIVATE_MSG_CONTENT_NON_NOTE_FIELDS_LEN\",\n    );\n\n    // We currently have two fields that are not the partial note's packed representation, which are the storage slot\n    // and the note completion log tag.\n    let storage_slot = msg_content.get(0);\n    let note_completion_log_tag = msg_content.get(1);\n\n    let packed_private_note_content = array::subbvec(msg_content, 2);\n\n    (note_type_id, storage_slot, note_completion_log_tag, packed_private_note_content)\n}\n"
     },
-    "123": {
+    "124": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/discovery/private_events.nr",
       "source": "use crate::{\n    event::event_selector::EventSelector,\n    messages::{encoding::MAX_MESSAGE_CONTENT_LEN, processing::enqueue_event_for_validation},\n    utils::array,\n};\nuse protocol_types::{\n    address::AztecAddress, constants::GENERATOR_INDEX__EVENT_COMMITMENT,\n    hash::poseidon2_hash_with_separator_bounded_vec, traits::FromField,\n};\n\n/// The number of fields in a private event message content that are not the event's serialized representation\n/// (1 field for randomness).\nglobal PRIVATE_EVENT_MSG_CONTENT_NON_EVENT_FIELDS_LEN: u32 = 1;\n\n/// The maximum length of the packed representation of an event's contents. This is limited by private log size,\n/// encryption overhead and extra fields in the message (e.g. message type id, randomness, etc.).\npub global MAX_EVENT_SERIALIZED_LEN: u32 =\n    MAX_MESSAGE_CONTENT_LEN - PRIVATE_EVENT_MSG_CONTENT_NON_EVENT_FIELDS_LEN;\n\npub unconstrained fn process_private_event_msg(\n    contract_address: AztecAddress,\n    recipient: AztecAddress,\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n    tx_hash: Field,\n) {\n    // In the case of events, the msg metadata is the event selector.\n    let event_type_id = EventSelector::from_field(msg_metadata as Field);\n\n    assert(\n        msg_content.len() > PRIVATE_EVENT_MSG_CONTENT_NON_EVENT_FIELDS_LEN,\n        f\"Invalid private event message: all private event messages must have at least {PRIVATE_EVENT_MSG_CONTENT_NON_EVENT_FIELDS_LEN} fields\",\n    );\n\n    // If PRIVATE_EVENT_MSG_CONTENT_NON_EVENT_FIELDS_LEN is changed, causing the assertion below to fail, then the\n    // destructuring of the private event message encoding below must be updated as well.\n    std::static_assert(\n        PRIVATE_EVENT_MSG_CONTENT_NON_EVENT_FIELDS_LEN == 1,\n        \"unexpected value for PRIVATE_EVENT_MSG_CONTENT_NON_EVENT_FIELDS_LEN\",\n    );\n\n    let serialized_event_with_randomness = msg_content;\n\n    let event_commitment = poseidon2_hash_with_separator_bounded_vec(\n        serialized_event_with_randomness,\n        GENERATOR_INDEX__EVENT_COMMITMENT,\n    );\n\n    // Randomness was injected into the event payload in `emit_event_in_private` but we have already used it\n    // to compute the event commitment, so we can safely discard it now.\n    let serialized_event = array::subbvec(\n        serialized_event_with_randomness,\n        PRIVATE_EVENT_MSG_CONTENT_NON_EVENT_FIELDS_LEN,\n    );\n\n    enqueue_event_for_validation(\n        contract_address,\n        event_type_id,\n        serialized_event,\n        event_commitment,\n        tx_hash,\n        recipient,\n    );\n}\n"
     },
-    "124": {
+    "125": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/discovery/private_notes.nr",
       "source": "use crate::{\n    messages::{\n        discovery::{ComputeNoteHashAndNullifier, nonce_discovery::attempt_note_nonce_discovery},\n        encoding::MAX_MESSAGE_CONTENT_LEN,\n        processing::enqueue_note_for_validation,\n    },\n    utils::array,\n};\nuse protocol_types::{\n    address::AztecAddress, constants::MAX_NOTE_HASHES_PER_TX, debug_log::debug_log_format,\n};\n\n/// The number of fields in a private note message content that are not the note's packed representation.\n// See the call to `std::static_assert` below to see what's in these fields.\nglobal PRIVATE_NOTE_MSG_CONTENT_NON_NOTE_FIELDS_LEN: u32 = 1;\n\n/// The maximum length of the packed representation of a note's contents. This is limited by private log size,\n/// encryption overhead and extra fields in the message (e.g. message type id, storage slot, etc.).\npub global MAX_NOTE_PACKED_LEN: u32 =\n    MAX_MESSAGE_CONTENT_LEN - PRIVATE_NOTE_MSG_CONTENT_NON_NOTE_FIELDS_LEN;\n\npub unconstrained fn process_private_note_msg<Env>(\n    contract_address: AztecAddress,\n    tx_hash: Field,\n    unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,\n    first_nullifier_in_tx: Field,\n    recipient: AztecAddress,\n    compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n) {\n    let (note_type_id, storage_slot, packed_note) =\n        decode_private_note_msg(msg_metadata, msg_content);\n\n    attempt_note_discovery(\n        contract_address,\n        tx_hash,\n        unique_note_hashes_in_tx,\n        first_nullifier_in_tx,\n        recipient,\n        compute_note_hash_and_nullifier,\n        storage_slot,\n        note_type_id,\n        packed_note,\n    );\n}\n\n/// Attempts discovery of a note given information about its contents and the transaction in which it is\n/// suspected the note was created.\npub unconstrained fn attempt_note_discovery<Env>(\n    contract_address: AztecAddress,\n    tx_hash: Field,\n    unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,\n    first_nullifier_in_tx: Field,\n    recipient: AztecAddress,\n    compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n    storage_slot: Field,\n    note_type_id: Field,\n    packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n) {\n    let discovered_notes = attempt_note_nonce_discovery(\n        unique_note_hashes_in_tx,\n        first_nullifier_in_tx,\n        compute_note_hash_and_nullifier,\n        contract_address,\n        storage_slot,\n        note_type_id,\n        packed_note,\n    );\n\n    debug_log_format(\n        \"Discovered {0} notes from a private message\",\n        [discovered_notes.len() as Field],\n    );\n\n    discovered_notes.for_each(|discovered_note| {\n        enqueue_note_for_validation(\n            contract_address,\n            storage_slot,\n            discovered_note.note_nonce,\n            packed_note,\n            discovered_note.note_hash,\n            discovered_note.inner_nullifier,\n            tx_hash,\n            recipient,\n        );\n    });\n}\n\nfn decode_private_note_msg(\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n) -> (Field, Field, BoundedVec<Field, MAX_NOTE_PACKED_LEN>) {\n    let note_type_id = msg_metadata as Field; // TODO: make note type id not be a full field\n\n    assert(\n        msg_content.len() > PRIVATE_NOTE_MSG_CONTENT_NON_NOTE_FIELDS_LEN,\n        f\"Invalid private note message: all private note messages must have at least {PRIVATE_NOTE_MSG_CONTENT_NON_NOTE_FIELDS_LEN} fields\",\n    );\n\n    // If PRIVATE_NOTE_MSG_CONTENT_NON_NOTE_FIELDS_LEN is changed, causing the assertion below to fail, then the\n    // destructuring of the private note message encoding below must be updated as well.\n    std::static_assert(\n        PRIVATE_NOTE_MSG_CONTENT_NON_NOTE_FIELDS_LEN == 1,\n        \"unexpected value for PRIVATE_NOTE_MSG_CONTENT_NON_NOTE_FIELDS_LEN\",\n    );\n\n    // We currently have a single field that is not the note's packed representation, which is the storage slot.\n    let storage_slot = msg_content.get(0);\n    let packed_note = array::subbvec(msg_content, PRIVATE_NOTE_MSG_CONTENT_NON_NOTE_FIELDS_LEN);\n\n    (note_type_id, storage_slot, packed_note)\n}\n"
     },
-    "125": {
+    "126": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/discovery/process_message.nr",
       "source": "use crate::messages::{\n    discovery::{\n        ComputeNoteHashAndNullifier, partial_notes::process_partial_note_private_msg,\n        private_events::process_private_event_msg, private_notes::process_private_note_msg,\n    },\n    encoding::{decode_message, MESSAGE_CIPHERTEXT_LEN, MESSAGE_PLAINTEXT_LEN},\n    encryption::{aes128::AES128, message_encryption::MessageEncryption},\n    msg_type::{\n        PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID, PRIVATE_EVENT_MSG_TYPE_ID, PRIVATE_NOTE_MSG_TYPE_ID,\n    },\n    processing::message_context::MessageContext,\n};\n\nuse protocol_types::{address::AztecAddress, debug_log::{debug_log, debug_log_format}};\n\n/// Processes a message that can contain notes, partial notes, or events.\n///\n/// Notes result in nonce discovery being performed prior to delivery, which requires knowledge of the transaction hash\n/// in which the notes would've been created (typically the same transaction in which the log was emitted), along with\n/// the list of unique note hashes in said transaction and the `compute_note_hash_and_nullifier` function. Once\n/// discovered, the notes are enqueued for validation.\n///\n/// Partial notes result in a pending partial note entry being stored in a PXE capsule, which will later be retrieved to\n/// search for the note's completion public log.\n///\n/// Events are processed by computing an event commitment from the serialized event data and its randomness field, then\n/// enqueueing the event data and commitment for validation.\npub unconstrained fn process_message_ciphertext<Env>(\n    contract_address: AztecAddress,\n    compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n    message_ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n    message_context: MessageContext,\n) {\n    process_message_plaintext(\n        contract_address,\n        compute_note_hash_and_nullifier,\n        AES128::decrypt(message_ciphertext, message_context.recipient),\n        message_context,\n    );\n}\n\npub unconstrained fn process_message_plaintext<Env>(\n    contract_address: AztecAddress,\n    compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n    message_plaintext: BoundedVec<Field, MESSAGE_PLAINTEXT_LEN>,\n    message_context: MessageContext,\n) {\n    // The first thing to do after decrypting the message is to determine what type of message we're processing. We\n    // have 3 message types: private notes, partial notes and events.\n\n    // We decode the message to obtain the message type id, metadata and content.\n    let (msg_type_id, msg_metadata, msg_content) = decode_message(message_plaintext);\n\n    if msg_type_id == PRIVATE_NOTE_MSG_TYPE_ID {\n        debug_log(\"Processing private note msg\");\n\n        process_private_note_msg(\n            contract_address,\n            message_context.tx_hash,\n            message_context.unique_note_hashes_in_tx,\n            message_context.first_nullifier_in_tx,\n            message_context.recipient,\n            compute_note_hash_and_nullifier,\n            msg_metadata,\n            msg_content,\n        );\n    } else if msg_type_id == PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID {\n        debug_log(\"Processing partial note private msg\");\n\n        process_partial_note_private_msg(\n            contract_address,\n            message_context.recipient,\n            msg_metadata,\n            msg_content,\n        );\n    } else if msg_type_id == PRIVATE_EVENT_MSG_TYPE_ID {\n        debug_log(\"Processing private event msg\");\n\n        process_private_event_msg(\n            contract_address,\n            message_context.recipient,\n            msg_metadata,\n            msg_content,\n            message_context.tx_hash,\n        );\n    } else {\n        debug_log_format(\"Unknown msg type id {0}\", [msg_type_id as Field]);\n    }\n}\n"
     },
-    "126": {
+    "127": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/encoding.nr",
       "source": "// TODO(#12750): don't make these values assume we're using AES.\nuse crate::utils::array;\nuse protocol_types::constants::PRIVATE_LOG_CIPHERTEXT_LEN;\n\n// We reassign to the constant here to communicate the distinction between a log and a message. In Aztec.nr, unlike in\n// protocol circuits, we have a concept of a message that can be emitted either as a private log or as an offchain\n// message. Message is a piece of data that is to be eventually delivered to a contract via the `process_message(...)`\n// utility function function that is injected by the #[aztec] macro.\npub global MESSAGE_CIPHERTEXT_LEN: u32 = PRIVATE_LOG_CIPHERTEXT_LEN;\n\n// TODO(#12750): The global variables below should not be here as they are AES128 specific.\n// ciphertext_length (2) + 14 bytes pkcs#7 AES padding.\npub(crate) global HEADER_CIPHERTEXT_SIZE_IN_BYTES: u32 = 16;\n\npub global EPH_PK_X_SIZE_IN_FIELDS: u32 = 1;\npub global EPH_PK_SIGN_BYTE_SIZE_IN_BYTES: u32 = 1;\n\n// (17 - 1) * 31 - 16 - 1 = 479\nglobal MESSAGE_PLAINTEXT_SIZE_IN_BYTES: u32 = (MESSAGE_CIPHERTEXT_LEN - EPH_PK_X_SIZE_IN_FIELDS)\n    * 31\n    - HEADER_CIPHERTEXT_SIZE_IN_BYTES\n    - EPH_PK_SIGN_BYTE_SIZE_IN_BYTES;\n// Each field of the original note log was serialized to 32 bytes. Below we convert the bytes back to fields.\n// 479 / 32 = 15\npub global MESSAGE_PLAINTEXT_LEN: u32 = MESSAGE_PLAINTEXT_SIZE_IN_BYTES / 32;\n\nglobal MESSAGE_EXPANDED_METADATA_LEN: u32 = 1;\n\n// The standard message layout is composed of:\n//  - an initial field called the 'expanded metadata'\n//  - an arbitrary number of fields following that called the 'message content'\n//\n// ```\n// message: [ msg_expanded_metadata, ...msg_content ]\n// ```\n//\n// The expanded metadata itself is interpreted as a u128, of which:\n//  - the upper 64 bits are the message type id\n//  - the lower 64 bits are called the 'message metadata'\n//\n// ```\n// msg_expanded_metadata: [  msg_type_id    |  msg_metadata  ]\n//                        <---  64 bits --->|<--- 64 bits --->\n// ```\n//\n// The meaning of the message metadata and message content depend on the value of the message type id. Note that there\n// is nothing special about the message metadata, it _can_ be considered part of the content. It just has a different\n// name to make it distinct from the message content given that it is not a full field.\n\n/// The maximum length of a message's content, i.e. not including the expanded message metadata.\npub global MAX_MESSAGE_CONTENT_LEN: u32 = MESSAGE_PLAINTEXT_LEN - MESSAGE_EXPANDED_METADATA_LEN;\n\n/// Encodes a message following aztec-nr's standard message encoding. This message can later be decoded with\n/// `decode_message` to retrieve the original values.\n///\n/// - The `msg_type` is an identifier that groups types of messages that are all processed the same way, e.g. private\n/// notes or events. Possible values are defined in `aztec::messages::msg_type`.\n/// - The `msg_metadata` and `msg_content` are the values stored in the message, whose meaning depends on the\n///  `msg_type`. The only special thing about `msg_metadata` that separates it from `msg_content` is that it is a u64\n/// instead of a full Field (due to details of how messages are encoded), allowing applications that can fit values into\n/// this smaller variable to achieve higher data efficiency.\npub fn encode_message<let N: u32>(\n    msg_type: u64,\n    msg_metadata: u64,\n    msg_content: [Field; N],\n) -> [Field; (N + MESSAGE_EXPANDED_METADATA_LEN)] {\n    std::static_assert(\n        msg_content.len() <= MAX_MESSAGE_CONTENT_LEN,\n        \"Invalid message content: it must have a length of at most MAX_MESSAGE_CONTENT_LEN\",\n    );\n\n    // If MESSAGE_EXPANDED_METADATA_LEN is changed, causing the assertion below to fail, then the destructuring of\n    // the message encoding below must be updated as well.\n    std::static_assert(\n        MESSAGE_EXPANDED_METADATA_LEN == 1,\n        \"unexpected value for MESSAGE_EXPANDED_METADATA_LEN\",\n    );\n    let mut message: [Field; (N + MESSAGE_EXPANDED_METADATA_LEN)] = std::mem::zeroed();\n\n    message[0] = to_expanded_metadata(msg_type, msg_metadata);\n    for i in 0..msg_content.len() {\n        message[MESSAGE_EXPANDED_METADATA_LEN + i] = msg_content[i];\n    }\n\n    message\n}\n\n/// Decodes a standard aztec-nr message, i.e. one created via `encode_message`, returning the original encoded values.\n///\n/// Note that `encode_message` returns a fixed size array while this function takes a `BoundedVec`: this is because\n/// prior to decoding the message type is unknown, and consequentially not known at compile time. If working with\n/// fixed-size messages, consider using `BoundedVec::from_array` to convert them.\npub unconstrained fn decode_message(\n    message: BoundedVec<Field, MESSAGE_PLAINTEXT_LEN>,\n) -> (u64, u64, BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>) {\n    assert(\n        message.len() >= MESSAGE_EXPANDED_METADATA_LEN,\n        f\"Invalid message: it must have at least {MESSAGE_EXPANDED_METADATA_LEN} fields\",\n    );\n\n    // If MESSAGE_EXPANDED_METADATA_LEN is changed, causing the assertion below to fail, then the destructuring of\n    // the message encoding below must be updated as well.\n    std::static_assert(\n        MESSAGE_EXPANDED_METADATA_LEN == 1,\n        \"unexpected value for MESSAGE_EXPANDED_METADATA_LEN\",\n    );\n\n    let msg_expanded_metadata = message.get(0);\n    let (msg_type_id, msg_metadata) = from_expanded_metadata(msg_expanded_metadata);\n    let msg_content = array::subbvec(message, MESSAGE_EXPANDED_METADATA_LEN);\n\n    (msg_type_id, msg_metadata, msg_content)\n}\n\nglobal U64_SHIFT_MULTIPLIER: Field = 2.pow_32(64);\n\nfn to_expanded_metadata(msg_type: u64, msg_metadata: u64) -> Field {\n    // We use multiplication instead of bit shifting operations to shift the type bits as bit shift operations are\n    // expensive in circuits.\n    let type_field: Field = (msg_type as Field) * U64_SHIFT_MULTIPLIER;\n    let msg_metadata_field = msg_metadata as Field;\n\n    type_field + msg_metadata_field\n}\n\nfn from_expanded_metadata(input: Field) -> (u64, u64) {\n    input.assert_max_bit_size::<128>();\n    let msg_metadata = (input as u64);\n    let msg_type = ((input - (msg_metadata as Field)) / U64_SHIFT_MULTIPLIER) as u64;\n    // Use division instead of bit shift since bit shifts are expensive in circuits\n    (msg_type, msg_metadata)\n}\n\nmod tests {\n    use crate::utils::array::subarray::subarray;\n    use super::{\n        decode_message, encode_message, from_expanded_metadata, MAX_MESSAGE_CONTENT_LEN,\n        to_expanded_metadata,\n    };\n\n    global U64_MAX: u64 = (2.pow_32(64) - 1) as u64;\n    global U128_MAX: Field = (2.pow_32(128) - 1);\n\n    #[test]\n    unconstrained fn encode_decode_empty_message(msg_type: u64, msg_metadata: u64) {\n        let encoded = encode_message(msg_type, msg_metadata, []);\n        let (decoded_msg_type, decoded_msg_metadata, decoded_msg_content) =\n            decode_message(BoundedVec::from_array(encoded));\n\n        assert_eq(decoded_msg_type, msg_type);\n        assert_eq(decoded_msg_metadata, msg_metadata);\n        assert_eq(decoded_msg_content.len(), 0);\n    }\n\n    #[test]\n    unconstrained fn encode_decode_short_message(\n        msg_type: u64,\n        msg_metadata: u64,\n        msg_content: [Field; MAX_MESSAGE_CONTENT_LEN / 2],\n    ) {\n        let encoded = encode_message(msg_type, msg_metadata, msg_content);\n        let (decoded_msg_type, decoded_msg_metadata, decoded_msg_content) =\n            decode_message(BoundedVec::from_array(encoded));\n\n        assert_eq(decoded_msg_type, msg_type);\n        assert_eq(decoded_msg_metadata, msg_metadata);\n        assert_eq(decoded_msg_content.len(), msg_content.len());\n        assert_eq(subarray(decoded_msg_content.storage(), 0), msg_content);\n    }\n\n    #[test]\n    unconstrained fn encode_decode_full_message(\n        msg_type: u64,\n        msg_metadata: u64,\n        msg_content: [Field; MAX_MESSAGE_CONTENT_LEN],\n    ) {\n        let encoded = encode_message(msg_type, msg_metadata, msg_content);\n        let (decoded_msg_type, decoded_msg_metadata, decoded_msg_content) =\n            decode_message(BoundedVec::from_array(encoded));\n\n        assert_eq(decoded_msg_type, msg_type);\n        assert_eq(decoded_msg_metadata, msg_metadata);\n        assert_eq(decoded_msg_content.len(), msg_content.len());\n        assert_eq(subarray(decoded_msg_content.storage(), 0), msg_content);\n    }\n\n    #[test]\n    unconstrained fn to_expanded_metadata_packing() {\n        // Test case 1: All bits set\n        let packed = to_expanded_metadata(U64_MAX, U64_MAX);\n        let (msg_type, msg_metadata) = from_expanded_metadata(packed);\n        assert_eq(msg_type, U64_MAX);\n        assert_eq(msg_metadata, U64_MAX);\n\n        // Test case 2: Only log type bits set\n        let packed = to_expanded_metadata(U64_MAX, 0);\n        let (msg_type, msg_metadata) = from_expanded_metadata(packed);\n        assert_eq(msg_type, U64_MAX);\n        assert_eq(msg_metadata, 0);\n\n        // Test case 3: Only msg_metadata bits set\n        let packed = to_expanded_metadata(0, U64_MAX);\n        let (msg_type, msg_metadata) = from_expanded_metadata(packed);\n        assert_eq(msg_type, 0);\n        assert_eq(msg_metadata, U64_MAX);\n\n        // Test case 4: No bits set\n        let packed = to_expanded_metadata(0, 0);\n        let (msg_type, msg_metadata) = from_expanded_metadata(packed);\n        assert_eq(msg_type, 0);\n        assert_eq(msg_metadata, 0);\n    }\n\n    #[test]\n    unconstrained fn from_expanded_metadata_packing() {\n        // Test case 1: All bits set\n        let input = U128_MAX as Field;\n        let (msg_type, msg_metadata) = from_expanded_metadata(input);\n        assert_eq(msg_type, U64_MAX);\n        assert_eq(msg_metadata, U64_MAX);\n\n        // Test case 2: Only log type bits set\n        let input = (U128_MAX - U64_MAX as Field);\n        let (msg_type, msg_metadata) = from_expanded_metadata(input);\n        assert_eq(msg_type, U64_MAX);\n        assert_eq(msg_metadata, 0);\n\n        // Test case 3: Only msg_metadata bits set\n        let input = U64_MAX as Field;\n        let (msg_type, msg_metadata) = from_expanded_metadata(input);\n        assert_eq(msg_type, 0);\n        assert_eq(msg_metadata, U64_MAX);\n\n        // Test case 4: No bits set\n        let input = 0;\n        let (msg_type, msg_metadata) = from_expanded_metadata(input);\n        assert_eq(msg_type, 0);\n        assert_eq(msg_metadata, 0);\n    }\n\n    #[test]\n    unconstrained fn to_from_expanded_metadata(original_msg_type: u64, original_msg_metadata: u64) {\n        let packed = to_expanded_metadata(original_msg_type, original_msg_metadata);\n        let (unpacked_msg_type, unpacked_msg_metadata) = from_expanded_metadata(packed);\n\n        assert_eq(original_msg_type, unpacked_msg_type);\n        assert_eq(original_msg_metadata, unpacked_msg_metadata);\n    }\n}\n"
     },
-    "127": {
+    "128": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/encryption/aes128.nr",
       "source": "use dep::protocol_types::{\n    address::AztecAddress,\n    constants::{GENERATOR_INDEX__SYMMETRIC_KEY, GENERATOR_INDEX__SYMMETRIC_KEY_2},\n    hash::poseidon2_hash_with_separator,\n    point::Point,\n};\n\nuse crate::{\n    keys::{\n        ecdh_shared_secret::derive_ecdh_shared_secret_using_aztec_address,\n        ephemeral::generate_ephemeral_key_pair,\n    },\n    messages::{\n        encoding::{\n            EPH_PK_SIGN_BYTE_SIZE_IN_BYTES, EPH_PK_X_SIZE_IN_FIELDS,\n            HEADER_CIPHERTEXT_SIZE_IN_BYTES, MESSAGE_CIPHERTEXT_LEN, MESSAGE_PLAINTEXT_LEN,\n        },\n        encryption::message_encryption::MessageEncryption,\n        logs::arithmetic_generics_utils::{\n            get_arr_of_size__message_bytes__from_PT,\n            get_arr_of_size__message_bytes_padding__from_PT,\n        },\n    },\n    oracle::{aes128_decrypt::aes128_decrypt_oracle, shared_secret::get_shared_secret},\n    utils::{\n        array,\n        conversion::{\n            bytes_to_fields::{bytes_from_fields, bytes_to_fields},\n            fields_to_bytes::{fields_from_bytes, fields_to_bytes},\n        },\n        point::{get_sign_of_point, point_from_x_coord_and_sign},\n        random::get_random_bytes,\n    },\n};\n\nuse std::aes128::aes128_encrypt;\n\n/**\n * Computes N close-to-uniformly-random 256 bits from a given ECDH shared_secret.\n *\n * NEVER re-use the same iv and sym_key.\n * DO NOT call this function more than once with the same shared_secret.\n *\n * This function is only known to be safe if shared_secret is computed by combining a \n * random ephemeral key with an address point. See big comment within the body of the function.\n * See big comment within the body of the function.\n */\nfn extract_many_close_to_uniformly_random_256_bits_from_ecdh_shared_secret_using_poseidon2_unsafe<let N: u32>(\n    shared_secret: Point,\n) -> [[u8; 32]; N] {\n    /*\n     * Unsafe because of https://eprint.iacr.org/2010/264.pdf Page 13, Lemma 2 (and the * two paragraphs below it).\n     *\n     * If you call this function, you need to be careful and aware of how the arg\n     * `shared_secret` has been derived.\n     *\n     * The paper says that the way you derive aes keys and IVs should be fine with poseidon2\n     * (modelled as a RO), as long as you _don't_ use Poseidon2 as a PRG to generate the * two exponents x & y which multiply to the shared secret S:\n     *\n     * S = [x*y]*G.\n     *\n     * (Otherwise, you would have to \"key\" poseidon2, i.e. generate a uniformly string K\n     * which can be public and compute Hash(x) as poseidon(K,x)).\n     * In that lemma, k would be 2*254=508, and m would be the number of points on the * grumpkin curve (which is close to r according to the Hasse bound).\n     *\n     * Our shared secret S is [esk * address_sk] * G, and the question is: * Can we compute hash(S) using poseidon2 instead of sha256?\n     *\n     * Well, esk is random and not generated with poseidon2, so that's good.\n     * What about address_sk?\n     * Well, address_sk = poseidon2(stuff) + ivsk, so there was some\n     * discussion about whether address_sk is independent of poseidon2.\n     * Given that ivsk is random and independent of poseidon2, the address_sk is also\n     * independent of poseidon2.\n     *\n     * Tl;dr: we believe it's safe to hash S = [esk * address_sk] * G using poseidon2,\n     * in order to derive a symmetric key.\n     *\n     * If you're calling this function for a differently-derived `shared_secret`, be\n     * careful.\n     *\n     */\n\n    /* The output of this function needs to be 32 random bytes.\n     * A single field won't give us 32 bytes of entropy.\n     * So we compute two \"random\" fields, by poseidon-hashing with two different\n     * generators.\n     * We then extract the last 16 (big endian) bytes of each \"random\" field.\n     * Note: we use to_be_bytes because it's slightly more efficient. But we have to\n     * be careful not to take bytes from the \"big end\", because the \"big\" byte is\n     * not uniformly random over the byte: it only has < 6 bits of randomness, because\n     * it's the big end of a 254-bit field element.\n     */\n\n    let mut all_bytes: [[u8; 32]; N] = std::mem::zeroed();\n    // We restrict N to be < 2^8, because of how we compute the domain separator\n    // from k below (where k <= N must be 8 bits). In practice, it's extremely\n    // unlikely that an app will want to compute >= 256 ciphertexts.\n    std::static_assert(N < 256, \"N too large\");\n    for k in 0..N {\n        // We augment the domain separator with the loop index, so that we can\n        // generate N lots of randomness.\n        let k_shift = (k as u16 << 8);\n        let separator_1 = k_shift + GENERATOR_INDEX__SYMMETRIC_KEY as u16;\n        let separator_2 = k_shift + GENERATOR_INDEX__SYMMETRIC_KEY_2 as u16;\n\n        let rand1: Field =\n            poseidon2_hash_with_separator([shared_secret.x, shared_secret.y], separator_1);\n        let rand2: Field =\n            poseidon2_hash_with_separator([shared_secret.x, shared_secret.y], separator_2);\n\n        let rand1_bytes: [u8; 32] = rand1.to_be_bytes();\n        let rand2_bytes: [u8; 32] = rand2.to_be_bytes();\n\n        let mut bytes: [u8; 32] = [0; 32];\n        for i in 0..16 {\n            // We take bytes from the \"little end\" of the be-bytes arrays:\n            let j = 32 - i - 1;\n            bytes[i] = rand1_bytes[j];\n            bytes[16 + i] = rand2_bytes[j];\n        }\n\n        all_bytes[k] = bytes;\n    }\n\n    all_bytes\n}\n\nfn derive_aes_symmetric_key_and_iv_from_uniformly_random_256_bits<let N: u32>(\n    many_random_256_bits: [[u8; 32]; N],\n) -> [([u8; 16], [u8; 16]); N] {\n    // Many (sym_key, iv) pairs:\n    let mut many_pairs: [([u8; 16], [u8; 16]); N] = std::mem::zeroed();\n    for k in 0..N {\n        let random_256_bits = many_random_256_bits[k];\n        let mut sym_key = [0; 16];\n        let mut iv = [0; 16];\n        for i in 0..16 {\n            sym_key[i] = random_256_bits[i];\n            iv[i] = random_256_bits[i + 16];\n        }\n        many_pairs[k] = (sym_key, iv);\n    }\n\n    many_pairs\n}\n\npub fn derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_poseidon2_unsafe<let N: u32>(\n    shared_secret: Point,\n) -> [([u8; 16], [u8; 16]); N] {\n    let many_random_256_bits: [[u8; 32]; N] = extract_many_close_to_uniformly_random_256_bits_from_ecdh_shared_secret_using_poseidon2_unsafe(\n        shared_secret,\n    );\n\n    derive_aes_symmetric_key_and_iv_from_uniformly_random_256_bits(many_random_256_bits)\n}\n\npub struct AES128 {}\n\nimpl MessageEncryption for AES128 {\n    fn encrypt<let PlaintextLen: u32>(\n        plaintext: [Field; PlaintextLen],\n        recipient: AztecAddress,\n    ) -> [Field; MESSAGE_CIPHERTEXT_LEN] {\n        // AES 128 operates on bytes, not fields, so we need to convert the fields to bytes.\n        // (This process is then reversed when processing the message in `do_process_message`)\n        let plaintext_bytes = fields_to_bytes(plaintext);\n\n        // *****************************************************************************\n        // Compute the shared secret\n        // *****************************************************************************\n\n        let (eph_sk, eph_pk) = generate_ephemeral_key_pair();\n\n        let eph_pk_sign_byte: u8 = get_sign_of_point(eph_pk) as u8;\n\n        // (not to be confused with the tagging shared secret)\n        // TODO (#17158): Currently we unwrap the Option returned by derive_ecdh_shared_secret_using_aztec_address.\n        // We need to handle the case where the ephemeral public key is invalid to prevent potential DoS vectors.\n        let ciphertext_shared_secret =\n            derive_ecdh_shared_secret_using_aztec_address(eph_sk, recipient).unwrap();\n        // TODO: also use this shared secret for deriving note randomness.\n\n        // *****************************************************************************\n        // Convert the plaintext into whatever format the encryption function expects\n        // *****************************************************************************\n\n        // Already done for this strategy: AES expects bytes.\n\n        // *****************************************************************************\n        // Encrypt the plaintext\n        // *****************************************************************************\n\n        // It is safe to call the `unsafe` function here, because we know the `shared_secret`\n        // was derived using an AztecAddress (the recipient). See the block comment\n        // at the start of this unsafe target function for more info.\n        let pairs = derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_poseidon2_unsafe::<2>(\n            ciphertext_shared_secret,\n        );\n        let (body_sym_key, body_iv) = pairs[0];\n        let (header_sym_key, header_iv) = pairs[1];\n\n        let ciphertext_bytes = aes128_encrypt(plaintext_bytes, body_iv, body_sym_key);\n\n        // |full_pt| = |pt_length| + |pt|\n        // |pt_aes_padding| = 16 - (|full_pt| % 16)\n        // or... since a % b is the same as a - b * (a // b) (integer division), so:\n        // |pt_aes_padding| = 16 - (|full_pt| - 16 * (|full_pt| // 16))\n        // |ct| = |full_pt| + |pt_aes_padding|\n        //      = |full_pt| + 16 - (|full_pt| - 16 * (|full_pt| // 16))\n        //      = 16 + 16 * (|full_pt| // 16)\n        //      = 16 * (1 + |full_pt| // 16)\n        std::static_assert(\n            ciphertext_bytes.len() == 16 * (1 + (PlaintextLen * 32) / 16),\n            \"unexpected ciphertext length\",\n        );\n\n        // *****************************************************************************\n        // Compute the header ciphertext\n        // *****************************************************************************\n\n        // Header contains only the length of the ciphertext stored in 2 bytes.\n        let mut header_plaintext: [u8; 2] = [0 as u8; 2];\n        let ciphertext_bytes_length = ciphertext_bytes.len();\n        header_plaintext[0] = (ciphertext_bytes_length >> 8) as u8;\n        header_plaintext[1] = ciphertext_bytes_length as u8;\n\n        // Note: the aes128_encrypt builtin fn automatically appends bytes to the\n        // input, according to pkcs#7; hence why the output `header_ciphertext_bytes` is 16\n        // bytes larger than the input in this case.\n        let header_ciphertext_bytes = aes128_encrypt(header_plaintext, header_iv, header_sym_key);\n        // I recall that converting a slice to an array incurs constraints, so I'll check the length this way instead:\n        std::static_assert(\n            header_ciphertext_bytes.len() == HEADER_CIPHERTEXT_SIZE_IN_BYTES,\n            \"unexpected ciphertext header length\",\n        );\n\n        // *****************************************************************************\n        // Prepend / append more bytes of data to the ciphertext, before converting back\n        // to fields.\n        // *****************************************************************************\n\n        let mut message_bytes_padding_to_mult_31 =\n            get_arr_of_size__message_bytes_padding__from_PT::<PlaintextLen * 32>();\n        // Safety: this randomness won't be constrained to be random. It's in the\n        // interest of the executor of this fn to encrypt with random bytes.\n        message_bytes_padding_to_mult_31 = unsafe { get_random_bytes() };\n\n        let mut message_bytes = get_arr_of_size__message_bytes__from_PT::<PlaintextLen * 32>();\n\n        std::static_assert(\n            message_bytes.len() % 31 == 0,\n            \"Unexpected error: message_bytes.len() should be divisible by 31, by construction.\",\n        );\n\n        message_bytes[0] = eph_pk_sign_byte;\n        let mut offset = 1;\n        for i in 0..header_ciphertext_bytes.len() {\n            message_bytes[offset + i] = header_ciphertext_bytes[i];\n        }\n        offset += header_ciphertext_bytes.len();\n\n        for i in 0..ciphertext_bytes.len() {\n            message_bytes[offset + i] = ciphertext_bytes[i];\n        }\n        offset += ciphertext_bytes.len();\n\n        for i in 0..message_bytes_padding_to_mult_31.len() {\n            message_bytes[offset + i] = message_bytes_padding_to_mult_31[i];\n        }\n        offset += message_bytes_padding_to_mult_31.len();\n\n        // Ideally we would be able to have a static assert where we check that the offset would be such that we've\n        // written to the entire log_bytes array, but we cannot since Noir does not treat the offset as a comptime\n        // value (despite the values that it goes through being known at each stage). We instead check that the\n        // computation used to obtain the offset computes the expected value (which we _can_ do in a static check), and\n        // then add a cheap runtime check to also validate that the offset matches this.\n        std::static_assert(\n            1\n                + header_ciphertext_bytes.len()\n                + ciphertext_bytes.len()\n                + message_bytes_padding_to_mult_31.len()\n                == message_bytes.len(),\n            \"unexpected message length\",\n        );\n        assert(offset == message_bytes.len(), \"unexpected encrypted message length\");\n\n        // *****************************************************************************\n        // Convert bytes back to fields\n        // *****************************************************************************\n\n        // TODO(#12749): As Mike pointed out, we need to make messages produced by different encryption schemes\n        // indistinguishable from each other and for this reason the output here and in the last for-loop of this function\n        // should cover a full field.\n        let message_bytes_as_fields = bytes_to_fields(message_bytes);\n\n        // *****************************************************************************\n        // Prepend / append fields, to create the final message\n        // *****************************************************************************\n\n        let mut ciphertext: [Field; MESSAGE_CIPHERTEXT_LEN] = [0; MESSAGE_CIPHERTEXT_LEN];\n\n        ciphertext[0] = eph_pk.x;\n\n        let mut offset = 1;\n        for i in 0..message_bytes_as_fields.len() {\n            ciphertext[offset + i] = message_bytes_as_fields[i];\n        }\n        offset += message_bytes_as_fields.len();\n\n        for i in offset..MESSAGE_CIPHERTEXT_LEN {\n            // We need to get a random value that fits in 31 bytes to not leak information about the size of the message\n            // (all the \"real\" message fields contain at most 31 bytes because of the way we convert the bytes to fields).\n            // TODO(#12749): Long term, this is not a good solution.\n\n            // Safety: we assume that the sender wants for the message to be private - a malicious one could simply reveal its\n            // contents publicly. It is therefore fine to trust the sender to provide random padding.\n            let field_bytes = unsafe { get_random_bytes::<31>() };\n            ciphertext[i] = Field::from_be_bytes::<31>(field_bytes);\n        }\n\n        ciphertext\n    }\n\n    unconstrained fn decrypt(\n        ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n        recipient: AztecAddress,\n    ) -> BoundedVec<Field, MESSAGE_PLAINTEXT_LEN> {\n        let eph_pk_x = ciphertext.get(0);\n\n        let ciphertext_without_eph_pk_x_fields = array::subbvec::<Field, MESSAGE_CIPHERTEXT_LEN, MESSAGE_CIPHERTEXT_LEN - EPH_PK_X_SIZE_IN_FIELDS>(\n            ciphertext,\n            EPH_PK_X_SIZE_IN_FIELDS,\n        );\n\n        // Convert the ciphertext represented as fields to a byte representation (its original format)\n        let ciphertext_without_eph_pk_x = bytes_from_fields(ciphertext_without_eph_pk_x_fields);\n\n        // First byte of the ciphertext represents the ephemeral public key sign\n        let eph_pk_sign_bool = ciphertext_without_eph_pk_x.get(0) != 0;\n        // With the sign and the x-coordinate of the ephemeral public key, we can reconstruct the point\n        let eph_pk = point_from_x_coord_and_sign(eph_pk_x, eph_pk_sign_bool);\n\n        // Derive shared secret\n        // TODO(#17158): handle invalid ephemeral keys when decrypting to prevent DoS vectors\n        let ciphertext_shared_secret = get_shared_secret(recipient, eph_pk.unwrap());\n\n        // Derive symmetric keys:\n        let pairs = derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_poseidon2_unsafe::<2>(\n            ciphertext_shared_secret,\n        );\n        let (body_sym_key, body_iv) = pairs[0];\n        let (header_sym_key, header_iv) = pairs[1];\n\n        // Extract the header ciphertext\n        let header_start = EPH_PK_SIGN_BYTE_SIZE_IN_BYTES; // Skip eph_pk_sign byte\n        let header_ciphertext: [u8; HEADER_CIPHERTEXT_SIZE_IN_BYTES] =\n            array::subarray(ciphertext_without_eph_pk_x.storage(), header_start);\n        // We need to convert the array to a BoundedVec because the oracle expects a BoundedVec as it's designed to work\n        // with messages with unknown length at compile time. This would not be necessary here as the header ciphertext length\n        // is fixed. But we do it anyway to not have to have duplicate oracles.\n        let header_ciphertext_bvec =\n            BoundedVec::<u8, HEADER_CIPHERTEXT_SIZE_IN_BYTES>::from_array(header_ciphertext);\n\n        // Decrypt header\n        let header_plaintext =\n            aes128_decrypt_oracle(header_ciphertext_bvec, header_iv, header_sym_key);\n\n        // Extract ciphertext length from header (2 bytes, big-endian)\n        let ciphertext_length =\n            ((header_plaintext.get(0) as u32) << 8) | (header_plaintext.get(1) as u32);\n\n        // Extract and decrypt main ciphertext\n        let ciphertext_start = header_start + HEADER_CIPHERTEXT_SIZE_IN_BYTES;\n        let ciphertext_with_padding: [u8; (MESSAGE_CIPHERTEXT_LEN - EPH_PK_X_SIZE_IN_FIELDS) * 31 - HEADER_CIPHERTEXT_SIZE_IN_BYTES - EPH_PK_SIGN_BYTE_SIZE_IN_BYTES] =\n            array::subarray(ciphertext_without_eph_pk_x.storage(), ciphertext_start);\n        let ciphertext: BoundedVec<u8, (MESSAGE_CIPHERTEXT_LEN - EPH_PK_X_SIZE_IN_FIELDS) * 31 - HEADER_CIPHERTEXT_SIZE_IN_BYTES - EPH_PK_SIGN_BYTE_SIZE_IN_BYTES> =\n            BoundedVec::from_parts(ciphertext_with_padding, ciphertext_length);\n\n        // Decrypt main ciphertext and return it\n        let plaintext_bytes = aes128_decrypt_oracle(ciphertext, body_iv, body_sym_key);\n\n        // Each field of the original note message was serialized to 32 bytes so we convert the bytes back to fields.\n        fields_from_bytes(plaintext_bytes)\n    }\n}\n\nmod test {\n    use crate::{\n        keys::ecdh_shared_secret::derive_ecdh_shared_secret_using_aztec_address,\n        messages::{\n            encoding::MESSAGE_PLAINTEXT_LEN, encryption::message_encryption::MessageEncryption,\n        },\n        test::helpers::test_environment::TestEnvironment,\n    };\n    use super::AES128;\n    use protocol_types::{address::AztecAddress, traits::FromField};\n    use std::{embedded_curve_ops::EmbeddedCurveScalar, test::OracleMock};\n\n    #[test]\n    unconstrained fn encrypt_decrypt() {\n        let env = TestEnvironment::new();\n\n        // Message decryption requires oracles that are only available during private execution\n        env.private_context(|_| {\n            let plaintext = [1, 2, 3];\n\n            let recipient = AztecAddress::from_field(\n                0x25afb798ea6d0b8c1618e50fdeafa463059415013d3b7c75d46abf5e242be70c,\n            );\n\n            // Mock random values for deterministic test\n            let eph_sk = 0x1358d15019d4639393d62b97e1588c095957ce74a1c32d6ec7d62fe6705d9538;\n            let _ = OracleMock::mock(\"utilityGetRandomField\").returns(eph_sk).times(1);\n\n            let randomness = 0x0101010101010101010101010101010101010101010101010101010101010101;\n            let _ = OracleMock::mock(\"utilityGetRandomField\").returns(randomness).times(1000000);\n\n            let _ = OracleMock::mock(\"privateGetNextAppTagAsSender\").returns(42);\n\n            // Encrypt the message\n            let encrypted_message = BoundedVec::from_array(AES128::encrypt(plaintext, recipient));\n\n            // Mock shared secret for deterministic test\n            let shared_secret = derive_ecdh_shared_secret_using_aztec_address(\n                EmbeddedCurveScalar::from_field(eph_sk),\n                recipient,\n            );\n\n            let _ = OracleMock::mock(\"utilityGetSharedSecret\").returns(shared_secret.unwrap());\n\n            // Decrypt the message\n            let decrypted = AES128::decrypt(encrypted_message, recipient);\n\n            // The decryption function spits out a BoundedVec because it's designed to work with messages with unknown length\n            // at compile time. For this reason we need to convert the original input to a BoundedVec.\n            let plaintext_bvec = BoundedVec::<Field, MESSAGE_PLAINTEXT_LEN>::from_array(plaintext);\n\n            // Verify decryption matches original plaintext\n            assert_eq(\n                decrypted,\n                plaintext_bvec,\n                \"Decrypted bytes should match original plaintext\",\n            );\n\n            // The following is a workaround of \"struct is never constructed\" Noir compilation error (we only ever use\n            // static methods of the struct).\n            let _ = AES128 {};\n        });\n    }\n}\n"
     },
-    "144": {
+    "145": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/processing/mod.nr",
       "source": "pub(crate) mod event_validation_request;\npub mod message_context;\npub(crate) mod note_validation_request;\npub(crate) mod log_retrieval_request;\npub(crate) mod log_retrieval_response;\npub(crate) mod pending_tagged_log;\n\nuse crate::{\n    capsules::CapsuleArray,\n    event::event_selector::EventSelector,\n    messages::{\n        discovery::{\n            partial_notes::DeliveredPendingPartialNote, private_events::MAX_EVENT_SERIALIZED_LEN,\n            private_notes::MAX_NOTE_PACKED_LEN,\n        },\n        processing::{\n            log_retrieval_request::LogRetrievalRequest,\n            log_retrieval_response::LogRetrievalResponse,\n            note_validation_request::NoteValidationRequest, pending_tagged_log::PendingTaggedLog,\n        },\n    },\n    oracle,\n};\nuse event_validation_request::EventValidationRequest;\nuse protocol_types::{address::AztecAddress, hash::sha256_to_field};\n\n// Base slot for the pending tagged log array to which the fetch_tagged_logs oracle inserts found private logs.\nglobal PENDING_TAGGED_LOG_ARRAY_BASE_SLOT: Field =\n    sha256_to_field(\"AZTEC_NR::PENDING_TAGGED_LOG_ARRAY_BASE_SLOT\".as_bytes());\n\nglobal NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT\".as_bytes(),\n);\n\nglobal EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT\".as_bytes(),\n);\n\nglobal LOG_RETRIEVAL_REQUESTS_ARRAY_BASE_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::LOG_RETRIEVAL_REQUESTS_ARRAY_BASE_SLOT\".as_bytes(),\n);\n\nglobal LOG_RETRIEVAL_RESPONSES_ARRAY_BASE_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::LOG_RETRIEVAL_RESPONSES_ARRAY_BASE_SLOT\".as_bytes(),\n);\n\n/// Searches for private logs emitted by `contract_address` that might contain messages for one of the local accounts,\n/// and stores them in a `CapsuleArray` which is then returned.\npub(crate) unconstrained fn get_private_logs(\n    contract_address: AztecAddress,\n) -> CapsuleArray<PendingTaggedLog> {\n    // We will eventually perform log discovery via tagging here, but for now we simply call the `fetchTaggedLogs`\n    // oracle. This makes PXE synchronize tags, download logs and store the pending tagged logs in a capsule array.\n    oracle::message_processing::fetch_tagged_logs(PENDING_TAGGED_LOG_ARRAY_BASE_SLOT);\n\n    CapsuleArray::at(contract_address, PENDING_TAGGED_LOG_ARRAY_BASE_SLOT)\n}\n\n/// Enqueues a note for validation by PXE, so that it becomes aware of a note's existence allowing for later retrieval\n/// via `get_notes` oracle. The note will be scoped to `contract_address`, meaning other contracts will not be able to\n/// access it unless authorized.\n///\n/// In order for the note validation and insertion to occur, `validate_enqueued_notes_and_events` must be later called.\n/// For optimal performance, accumulate as many note validation requests as possible and then validate them all at the\n/// end (which results in PXE minimizing the number of network round-trips).\n///\n/// The `packed_note` is what `getNotes` will later return. PXE indexes notes by `storage_slot`, so this value\n/// is typically used to filter notes that correspond to different state variables. `note_hash` and `nullifier` are\n/// the inner hashes, i.e. the raw hashes returned by `NoteHash::compute_note_hash` and\n/// `NoteHash::compute_nullifier`. PXE will verify that the siloed unique note hash was inserted into the tree\n/// at `tx_hash`, and will store the nullifier to later check for nullification.\n///\n/// `recipient` is the account to which the note was sent to. Other accounts will not be able to access this note (e.g.\n/// other accounts will not be able to see one another's token balance notes, even in the same PXE) unless authorized.\npub(crate) unconstrained fn enqueue_note_for_validation(\n    contract_address: AztecAddress,\n    storage_slot: Field,\n    note_nonce: Field,\n    packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n    note_hash: Field,\n    nullifier: Field,\n    tx_hash: Field,\n    recipient: AztecAddress,\n) {\n    // We store requests in a `CapsuleArray`, which PXE will later read from and deserialize into its version of the\n    // Noir `NoteValidationRequest`\n    CapsuleArray::at(contract_address, NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).push(\n        NoteValidationRequest {\n            contract_address,\n            storage_slot,\n            note_nonce,\n            packed_note,\n            note_hash,\n            nullifier,\n            tx_hash,\n            recipient,\n        },\n    )\n}\n\n/// Enqueues an event for validation by PXE, so that it can be efficiently validated and then inserted into the event\n/// store.\n///\n/// In order for the event validation and insertion to occur, `validate_enqueued_notes_and_events` must be later\n/// called. For optimal performance, accumulate as many event validation requests as possible and then validate them\n/// all at the end (which results in PXE minimizing the number of network round-trips).\npub(crate) unconstrained fn enqueue_event_for_validation(\n    contract_address: AztecAddress,\n    event_type_id: EventSelector,\n    serialized_event: BoundedVec<Field, MAX_EVENT_SERIALIZED_LEN>,\n    event_commitment: Field,\n    tx_hash: Field,\n    recipient: AztecAddress,\n) {\n    // We store requests in a `CapsuleArray`, which PXE will later read from and deserialize into its version of the\n    // Noir `EventValidationRequest`\n    CapsuleArray::at(contract_address, EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).push(\n        EventValidationRequest {\n            contract_address,\n            event_type_id,\n            serialized_event,\n            event_commitment,\n            tx_hash,\n            recipient,\n        },\n    )\n}\n\n/// Validates all note and event validation requests enqueued via `enqueue_note_for_validation` and\n/// `enqueue_event_for_validation`, inserting them into the note database and event store respectively, making them\n/// queryable via `get_notes` oracle and our TS API (PXE::getPrivateEvents).\n///\n/// This automatically clears both validation request queues, so no further work needs to be done by the caller.\npub(crate) unconstrained fn validate_enqueued_notes_and_events(contract_address: AztecAddress) {\n    oracle::message_processing::validate_enqueued_notes_and_events(\n        contract_address,\n        NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT,\n        EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT,\n    );\n}\n\n/// Efficiently queries the node for logs that result in the completion of all `DeliveredPendingPartialNote`s stored in\n/// a `CapsuleArray` by performing all node communication concurrently. Returns a second `CapsuleArray` with Options for\n/// the responses that correspond to the pending partial notes at the same index.\n///\n/// For example, given an array with pending partial notes `[ p1, p2, p3 ]`, where `p1` and `p3` have corresponding\n/// completion logs but `p2` does not, the returned `CapsuleArray` will have contents\n/// `[some(p1_log), none(), some(p3_log)]`.\npub(crate) unconstrained fn get_pending_partial_notes_completion_logs(\n    contract_address: AztecAddress,\n    pending_partial_notes: CapsuleArray<DeliveredPendingPartialNote>,\n) -> CapsuleArray<Option<LogRetrievalResponse>> {\n    let log_retrieval_requests =\n        CapsuleArray::at(contract_address, LOG_RETRIEVAL_REQUESTS_ARRAY_BASE_SLOT);\n\n    // We create a LogRetrievalRequest for each PendingPartialNote in the CapsuleArray. Because we need the indices in\n    // the request array to match the indices in the partial note array, we can't use CapsuleArray::for_each, as that\n    // function has arbitrary iteration order. Instead, we manually iterate the array from the beginning and push into\n    // the requests array, which we expect to be empty.\n    let mut i = 0;\n    let pending_partial_notes_count = pending_partial_notes.len();\n    while i < pending_partial_notes_count {\n        let pending_partial_note = pending_partial_notes.get(i);\n        log_retrieval_requests.push(\n            LogRetrievalRequest {\n                contract_address,\n                unsiloed_tag: pending_partial_note.note_completion_log_tag,\n            },\n        );\n        i += 1;\n    }\n\n    oracle::message_processing::bulk_retrieve_logs(\n        contract_address,\n        LOG_RETRIEVAL_REQUESTS_ARRAY_BASE_SLOT,\n        LOG_RETRIEVAL_RESPONSES_ARRAY_BASE_SLOT,\n    );\n\n    CapsuleArray::at(contract_address, LOG_RETRIEVAL_RESPONSES_ARRAY_BASE_SLOT)\n}\n"
     },
-    "164": {
+    "165": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/capsules.nr",
       "source": "use protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `load`. If\n/// data was already stored at this slot, it is overwritten.\npub unconstrained fn store<T>(contract_address: AztecAddress, slot: Field, value: T)\nwhere\n    T: Serialize,\n{\n    let serialized = value.serialize();\n    store_oracle(contract_address, slot, serialized);\n}\n\n/// Returns data previously stored via `storeCapsule` in the per-contract non-volatile database. Returns Option::none() if\n/// nothing was stored at the given slot.\npub unconstrained fn load<T>(contract_address: AztecAddress, slot: Field) -> Option<T>\nwhere\n    T: Deserialize,\n{\n    let serialized_option = load_oracle(contract_address, slot, <T as Deserialize>::N);\n    serialized_option.map(|arr| Deserialize::deserialize(arr))\n}\n\n/// Deletes data in the per-contract non-volatile database. Does nothing if no data was present.\npub unconstrained fn delete(contract_address: AztecAddress, slot: Field) {\n    delete_oracle(contract_address, slot);\n}\n\n/// Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data\n/// structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`.\n/// Supports overlapping source and destination regions (which will result in the overlapped source values being\n/// overwritten). All copied slots must exist in the database (i.e. have been stored and not deleted)\npub unconstrained fn copy(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n) {\n    copy_oracle(contract_address, src_slot, dst_slot, num_entries);\n}\n\n#[oracle(utilityStoreCapsule)]\nunconstrained fn store_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    values: [Field; N],\n) {}\n\n/// We need to pass in `array_len` (the value of N) as a parameter to tell the oracle how many fields the response must\n/// have.\n///\n/// Note that the oracle returns an Option<[Field; N]> because we cannot return an Option<T> directly. That would\n/// require for the oracle resolver to know the shape of T (e.g. if T were a struct of 3 u32 values then the expected\n/// response shape would be 3 single items, whereas it were a struct containing `u32, [Field;10], u32` then the expected\n/// shape would be single, array, single.). Instead, we return the serialization and deserialize in Noir.\n#[oracle(utilityLoadCapsule)]\nunconstrained fn load_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    array_len: u32,\n) -> Option<[Field; N]> {}\n\n#[oracle(utilityDeleteCapsule)]\nunconstrained fn delete_oracle(contract_address: AztecAddress, slot: Field) {}\n\n#[oracle(utilityCopyCapsule)]\nunconstrained fn copy_oracle(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n) {}\n\nmod test {\n    // These tests are sort of redundant since we already test the oracle implementation directly in TypeScript, but\n    // they are cheap regardless and help ensure both that the TXE implementation works accordingly and that the Noir\n    // oracles are hooked up correctly.\n\n    use crate::{\n        oracle::capsules::{copy, delete, load, store},\n        test::{helpers::test_environment::TestEnvironment, mocks::mock_struct::MockStruct},\n    };\n    use protocol_types::{address::AztecAddress, traits::{FromField, ToField}};\n\n    global SLOT: Field = 1;\n\n    #[test]\n    unconstrained fn stores_and_loads() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n\n            assert_eq(load(contract_address, SLOT).unwrap(), value);\n        });\n    }\n\n    #[test]\n    unconstrained fn store_overwrites() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n\n            let new_value = MockStruct::new(7, 8);\n            store(contract_address, SLOT, new_value);\n\n            assert_eq(load(contract_address, SLOT).unwrap(), new_value);\n        });\n    }\n\n    #[test]\n    unconstrained fn loads_empty_slot() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_stored_value() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n            delete(contract_address, SLOT);\n\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_empty_slot() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            delete(contract_address, SLOT);\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_non_overlapping_values() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 5;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 10;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_src_ahead() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 1;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 2;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n            // src[1] and src[2] should have been overwritten since they are also dst[0] and dst[1]\n            assert_eq(load(contract_address, src).unwrap(), values[0]); // src[0] (unchanged)\n            assert_eq(load(contract_address, src + 1).unwrap(), values[0]); // dst[0]\n            assert_eq(load(contract_address, src + 2).unwrap(), values[1]); // dst[1]\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_dst_ahead() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 2;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 1;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n            // src[0] and src[1] should have been overwritten since they are also dst[1] and dst[2]\n            assert_eq(load(contract_address, src).unwrap(), values[1]); // dst[1]\n            assert_eq(load(contract_address, src + 1).unwrap(), values[2]); // dst[2]\n            assert_eq(load(contract_address, src + 2).unwrap(), values[2]); // src[2] (unchanged)\n        });\n    }\n\n    #[test(should_fail_with = \"copy empty slot\")]\n    unconstrained fn cannot_copy_empty_values() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            copy(contract_address, SLOT, SLOT, 1);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_store_other_contract() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            let value = MockStruct::new(5, 6);\n            store(other_contract_address, SLOT, value);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_load_other_contract() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            let _: Option<MockStruct> = load(other_contract_address, SLOT);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_delete_other_contract() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            delete(other_contract_address, SLOT);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_copy_other_contract() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            copy(other_contract_address, SLOT, SLOT, 0);\n        });\n    }\n}\n"
     },
-    "166": {
+    "167": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/execution.nr",
       "source": "use crate::context::utility_context::UtilityContext;\n\n#[oracle(utilityGetUtilityContext)]\nunconstrained fn get_utility_context_oracle() -> UtilityContext {}\n\n/// Returns a utility context built from the global variables of anchor block and the contract address of the function\n/// being executed.\npub unconstrained fn get_utility_context() -> UtilityContext {\n    get_utility_context_oracle()\n}\n"
     },
     "17": {
       "path": "std/field/bn254.nr",
-      "source": "use crate::field::field_less_than;\nuse crate::runtime::is_unconstrained;\n\n// The low and high decomposition of the field modulus\nglobal PLO: Field = 53438638232309528389504892708671455233;\nglobal PHI: Field = 64323764613183177041862057485226039389;\n\npub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;\n\n// Decomposes a single field into two 16 byte fields.\nfn compute_decomposition(x: Field) -> (Field, Field) {\n    // Here's we're taking advantage of truncating 128 bit limbs from the input field\n    // and then subtracting them from the input such the field division is equivalent to integer division.\n    let low = (x as u128) as Field;\n    let high = (x - low) / TWO_POW_128;\n\n    (low, high)\n}\n\npub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {\n    compute_decomposition(x)\n}\n\nunconstrained fn lte_hint(x: Field, y: Field) -> bool {\n    if x == y {\n        true\n    } else {\n        field_less_than(x, y)\n    }\n}\n\n// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)\nfn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {\n    let (alo, ahi) = a;\n    let (blo, bhi) = b;\n    // Safety: borrow is enforced to be boolean due to its type.\n    // if borrow is 0, it asserts that (alo > blo && ahi >= bhi)\n    // if borrow is 1, it asserts that (alo <= blo && ahi > bhi)\n    unsafe {\n        let borrow = lte_hint(alo, blo);\n\n        let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;\n        let rhi = ahi - bhi - (borrow as Field);\n\n        rlo.assert_max_bit_size::<128>();\n        rhi.assert_max_bit_size::<128>();\n    }\n}\n\n/// Decompose a single field into two 16 byte fields.\npub fn decompose(x: Field) -> (Field, Field) {\n    if is_unconstrained() {\n        compute_decomposition(x)\n    } else {\n        // Safety: decomposition is properly checked below\n        unsafe {\n            // Take hints of the decomposition\n            let (xlo, xhi) = decompose_hint(x);\n\n            // Range check the limbs\n            xlo.assert_max_bit_size::<128>();\n            xhi.assert_max_bit_size::<128>();\n\n            // Check that the decomposition is correct\n            assert_eq(x, xlo + TWO_POW_128 * xhi);\n\n            // Assert that the decomposition of P is greater than the decomposition of x\n            assert_gt_limbs((PLO, PHI), (xlo, xhi));\n            (xlo, xhi)\n        }\n    }\n}\n\npub fn assert_gt(a: Field, b: Field) {\n    if is_unconstrained() {\n        assert(\n            // Safety: already unconstrained\n            unsafe { field_less_than(b, a) },\n        );\n    } else {\n        // Decompose a and b\n        let a_limbs = decompose(a);\n        let b_limbs = decompose(b);\n\n        // Assert that a_limbs is greater than b_limbs\n        assert_gt_limbs(a_limbs, b_limbs)\n    }\n}\n\npub fn assert_lt(a: Field, b: Field) {\n    assert_gt(b, a);\n}\n\npub fn gt(a: Field, b: Field) -> bool {\n    if is_unconstrained() {\n        // Safety: unsafe in unconstrained\n        unsafe {\n            field_less_than(b, a)\n        }\n    } else if a == b {\n        false\n    } else {\n        // Safety: Take a hint of the comparison and verify it\n        unsafe {\n            if field_less_than(a, b) {\n                assert_gt(b, a);\n                false\n            } else {\n                assert_gt(a, b);\n                true\n            }\n        }\n    }\n}\n\npub fn lt(a: Field, b: Field) -> bool {\n    gt(b, a)\n}\n\nmod tests {\n    // TODO: Allow imports from \"super\"\n    use crate::field::bn254::{assert_gt, decompose, gt, lt, lte_hint, PHI, PLO, TWO_POW_128};\n\n    #[test]\n    fn check_decompose() {\n        assert_eq(decompose(TWO_POW_128), (0, 1));\n        assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n        assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n    }\n\n    #[test]\n    unconstrained fn check_lte_hint() {\n        assert(lte_hint(0, 1));\n        assert(lte_hint(0, 0x100));\n        assert(lte_hint(0x100, TWO_POW_128 - 1));\n        assert(!lte_hint(0 - 1, 0));\n\n        assert(lte_hint(0, 0));\n        assert(lte_hint(0x100, 0x100));\n        assert(lte_hint(0 - 1, 0 - 1));\n    }\n\n    #[test]\n    fn check_gt() {\n        assert(gt(1, 0));\n        assert(gt(0x100, 0));\n        assert(gt((0 - 1), (0 - 2)));\n        assert(gt(TWO_POW_128, 0));\n        assert(!gt(0, 0));\n        assert(!gt(0, 0x100));\n        assert(gt(0 - 1, 0 - 2));\n        assert(!gt(0 - 2, 0 - 1));\n        assert_gt(0 - 1, 0);\n    }\n\n    #[test]\n    fn check_plo_phi() {\n        assert_eq(PLO + PHI * TWO_POW_128, 0);\n        let p_bytes = crate::field::modulus_le_bytes();\n        let mut p_low: Field = 0;\n        let mut p_high: Field = 0;\n\n        let mut offset = 1;\n        for i in 0..16 {\n            p_low += (p_bytes[i] as Field) * offset;\n            p_high += (p_bytes[i + 16] as Field) * offset;\n            offset *= 256;\n        }\n        assert_eq(p_low, PLO);\n        assert_eq(p_high, PHI);\n    }\n\n    #[test]\n    fn check_decompose_edge_cases() {\n        assert_eq(decompose(0), (0, 0));\n        assert_eq(decompose(TWO_POW_128 - 1), (TWO_POW_128 - 1, 0));\n        assert_eq(decompose(TWO_POW_128 + 1), (1, 1));\n        assert_eq(decompose(TWO_POW_128 * 2), (0, 2));\n        assert_eq(decompose(TWO_POW_128 * 2 + 0x1234567890), (0x1234567890, 2));\n    }\n\n    #[test]\n    fn check_decompose_large_values() {\n        let large_field = 0xffffffffffffffff;\n        let (lo, hi) = decompose(large_field);\n        assert_eq(large_field, lo + TWO_POW_128 * hi);\n\n        let large_value = large_field - TWO_POW_128;\n        let (lo2, hi2) = decompose(large_value);\n        assert_eq(large_value, lo2 + TWO_POW_128 * hi2);\n    }\n\n    #[test]\n    fn check_lt_comprehensive() {\n        assert(lt(0, 1));\n        assert(!lt(1, 0));\n        assert(!lt(0, 0));\n        assert(!lt(42, 42));\n\n        assert(lt(TWO_POW_128 - 1, TWO_POW_128));\n        assert(!lt(TWO_POW_128, TWO_POW_128 - 1));\n    }\n}\n"
+      "source": "use crate::field::field_less_than;\nuse crate::runtime::is_unconstrained;\n\n// The low and high decomposition of the field modulus\npub(crate) global PLO: Field = 53438638232309528389504892708671455233;\npub(crate) global PHI: Field = 64323764613183177041862057485226039389;\n\npub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;\n\n// Decomposes a single field into two 16 byte fields.\nfn compute_decomposition(x: Field) -> (Field, Field) {\n    // Here's we're taking advantage of truncating 128 bit limbs from the input field\n    // and then subtracting them from the input such the field division is equivalent to integer division.\n    let low = (x as u128) as Field;\n    let high = (x - low) / TWO_POW_128;\n\n    (low, high)\n}\n\npub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {\n    compute_decomposition(x)\n}\n\nunconstrained fn lte_hint(x: Field, y: Field) -> bool {\n    if x == y {\n        true\n    } else {\n        field_less_than(x, y)\n    }\n}\n\n// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)\nfn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {\n    let (alo, ahi) = a;\n    let (blo, bhi) = b;\n    // Safety: borrow is enforced to be boolean due to its type.\n    // if borrow is 0, it asserts that (alo > blo && ahi >= bhi)\n    // if borrow is 1, it asserts that (alo <= blo && ahi > bhi)\n    unsafe {\n        let borrow = lte_hint(alo, blo);\n\n        let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;\n        let rhi = ahi - bhi - (borrow as Field);\n\n        rlo.assert_max_bit_size::<128>();\n        rhi.assert_max_bit_size::<128>();\n    }\n}\n\n/// Decompose a single field into two 16 byte fields.\npub fn decompose(x: Field) -> (Field, Field) {\n    if is_unconstrained() {\n        compute_decomposition(x)\n    } else {\n        // Safety: decomposition is properly checked below\n        unsafe {\n            // Take hints of the decomposition\n            let (xlo, xhi) = decompose_hint(x);\n\n            // Range check the limbs\n            xlo.assert_max_bit_size::<128>();\n            xhi.assert_max_bit_size::<128>();\n\n            // Check that the decomposition is correct\n            assert_eq(x, xlo + TWO_POW_128 * xhi);\n\n            // Assert that the decomposition of P is greater than the decomposition of x\n            assert_gt_limbs((PLO, PHI), (xlo, xhi));\n            (xlo, xhi)\n        }\n    }\n}\n\npub fn assert_gt(a: Field, b: Field) {\n    if is_unconstrained() {\n        assert(\n            // Safety: already unconstrained\n            unsafe { field_less_than(b, a) },\n        );\n    } else {\n        // Decompose a and b\n        let a_limbs = decompose(a);\n        let b_limbs = decompose(b);\n\n        // Assert that a_limbs is greater than b_limbs\n        assert_gt_limbs(a_limbs, b_limbs)\n    }\n}\n\npub fn assert_lt(a: Field, b: Field) {\n    assert_gt(b, a);\n}\n\npub fn gt(a: Field, b: Field) -> bool {\n    if is_unconstrained() {\n        // Safety: unsafe in unconstrained\n        unsafe {\n            field_less_than(b, a)\n        }\n    } else if a == b {\n        false\n    } else {\n        // Safety: Take a hint of the comparison and verify it\n        unsafe {\n            if field_less_than(a, b) {\n                assert_gt(b, a);\n                false\n            } else {\n                assert_gt(a, b);\n                true\n            }\n        }\n    }\n}\n\npub fn lt(a: Field, b: Field) -> bool {\n    gt(b, a)\n}\n\nmod tests {\n    // TODO: Allow imports from \"super\"\n    use crate::field::bn254::{assert_gt, decompose, gt, lt, lte_hint, PHI, PLO, TWO_POW_128};\n\n    #[test]\n    fn check_decompose() {\n        assert_eq(decompose(TWO_POW_128), (0, 1));\n        assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n        assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n    }\n\n    #[test]\n    unconstrained fn check_lte_hint() {\n        assert(lte_hint(0, 1));\n        assert(lte_hint(0, 0x100));\n        assert(lte_hint(0x100, TWO_POW_128 - 1));\n        assert(!lte_hint(0 - 1, 0));\n\n        assert(lte_hint(0, 0));\n        assert(lte_hint(0x100, 0x100));\n        assert(lte_hint(0 - 1, 0 - 1));\n    }\n\n    #[test]\n    fn check_gt() {\n        assert(gt(1, 0));\n        assert(gt(0x100, 0));\n        assert(gt((0 - 1), (0 - 2)));\n        assert(gt(TWO_POW_128, 0));\n        assert(!gt(0, 0));\n        assert(!gt(0, 0x100));\n        assert(gt(0 - 1, 0 - 2));\n        assert(!gt(0 - 2, 0 - 1));\n        assert_gt(0 - 1, 0);\n    }\n\n    #[test]\n    fn check_plo_phi() {\n        assert_eq(PLO + PHI * TWO_POW_128, 0);\n        let p_bytes = crate::field::modulus_le_bytes();\n        let mut p_low: Field = 0;\n        let mut p_high: Field = 0;\n\n        let mut offset = 1;\n        for i in 0..16 {\n            p_low += (p_bytes[i] as Field) * offset;\n            p_high += (p_bytes[i + 16] as Field) * offset;\n            offset *= 256;\n        }\n        assert_eq(p_low, PLO);\n        assert_eq(p_high, PHI);\n    }\n\n    #[test]\n    fn check_decompose_edge_cases() {\n        assert_eq(decompose(0), (0, 0));\n        assert_eq(decompose(TWO_POW_128 - 1), (TWO_POW_128 - 1, 0));\n        assert_eq(decompose(TWO_POW_128 + 1), (1, 1));\n        assert_eq(decompose(TWO_POW_128 * 2), (0, 2));\n        assert_eq(decompose(TWO_POW_128 * 2 + 0x1234567890), (0x1234567890, 2));\n    }\n\n    #[test]\n    fn check_decompose_large_values() {\n        let large_field = 0xffffffffffffffff;\n        let (lo, hi) = decompose(large_field);\n        assert_eq(large_field, lo + TWO_POW_128 * hi);\n\n        let large_value = large_field - TWO_POW_128;\n        let (lo2, hi2) = decompose(large_value);\n        assert_eq(large_value, lo2 + TWO_POW_128 * hi2);\n    }\n\n    #[test]\n    fn check_lt_comprehensive() {\n        assert(lt(0, 1));\n        assert(!lt(1, 0));\n        assert(!lt(0, 0));\n        assert(!lt(42, 42));\n\n        assert(lt(TWO_POW_128 - 1, TWO_POW_128));\n        assert(!lt(TWO_POW_128, TWO_POW_128 - 1));\n    }\n}\n"
     },
-    "176": {
+    "177": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/message_processing.nr",
       "source": "use protocol_types::address::AztecAddress;\n\n/// Finds new private logs that may have been sent to all registered accounts in PXE in the current contract and makes\n/// them available for later processing in Noir by storing them in a capsule array.\npub unconstrained fn fetch_tagged_logs(pending_tagged_log_array_base_slot: Field) {\n    fetch_tagged_logs_oracle(pending_tagged_log_array_base_slot);\n}\n\n#[oracle(utilityFetchTaggedLogs)]\nunconstrained fn fetch_tagged_logs_oracle(pending_tagged_log_array_base_slot: Field) {}\n\n// This must be a single oracle and not one for notes and one for events because the entire point is to validate\n// all notes and events in one go, minimizing node round-trips.\npub(crate) unconstrained fn validate_enqueued_notes_and_events(\n    contract_address: AztecAddress,\n    note_validation_requests_array_base_slot: Field,\n    event_validation_requests_array_base_slot: Field,\n) {\n    validate_enqueued_notes_and_events_oracle(\n        contract_address,\n        note_validation_requests_array_base_slot,\n        event_validation_requests_array_base_slot,\n    );\n}\n\n#[oracle(utilityValidateEnqueuedNotesAndEvents)]\nunconstrained fn validate_enqueued_notes_and_events_oracle(\n    contract_address: AztecAddress,\n    note_validation_requests_array_base_slot: Field,\n    event_validation_requests_array_base_slot: Field,\n) {}\n\npub(crate) unconstrained fn bulk_retrieve_logs(\n    contract_address: AztecAddress,\n    log_retrieval_requests_array_base_slot: Field,\n    log_retrieval_responses_array_base_slot: Field,\n) {\n    bulk_retrieve_logs_oracle(\n        contract_address,\n        log_retrieval_requests_array_base_slot,\n        log_retrieval_responses_array_base_slot,\n    );\n}\n\n#[oracle(utilityBulkRetrieveLogs)]\nunconstrained fn bulk_retrieve_logs_oracle(\n    contract_address: AztecAddress,\n    log_retrieval_requests_array_base_slot: Field,\n    log_retrieval_responses_array_base_slot: Field,\n) {}\n"
     },
@@ -843,43 +847,43 @@
       "path": "std/field/mod.nr",
       "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n    /// Asserts that `self` can be represented in `bit_size` bits.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n    // docs:start:assert_max_bit_size\n    pub fn assert_max_bit_size<let BIT_SIZE: u32>(self) {\n        // docs:end:assert_max_bit_size\n        static_assert(\n            BIT_SIZE < modulus_num_bits() as u32,\n            \"BIT_SIZE must be less than modulus_num_bits\",\n        );\n        __assert_max_bit_size(self, BIT_SIZE);\n    }\n\n    /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n    /// This slice will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n    // docs:start:to_le_bits\n    pub fn to_le_bits<let N: u32>(self: Self) -> [u1; N] {\n        // docs:end:to_le_bits\n        let bits = __to_le_bits(self);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[N - 1 - i] != p[N - 1 - i]) {\n                        assert(p[N - 1 - i] == 1);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\n\n    /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n    /// This array will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n    // docs:start:to_be_bits\n    pub fn to_be_bits<let N: u32>(self: Self) -> [u1; N] {\n        // docs:end:to_be_bits\n        let bits = __to_be_bits(self);\n\n        if !is_unconstrained() {\n            // Ensure that the decomposition does not overflow the modulus\n            let p = modulus_be_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[i] != p[i]) {\n                        assert(p[i] == 1);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\n\n    /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the 'self',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_le_bytes\n    pub fn to_le_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_le_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        // Compute the byte decomposition\n        let bytes = self.to_le_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[N - 1 - i] != p[N - 1 - i]) {\n                        assert(bytes[N - 1 - i] < p[N - 1 - i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the 'self',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_be_bytes\n    pub fn to_be_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_be_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        // Compute the byte decomposition\n        let bytes = self.to_be_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_be_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[i] != p[i]) {\n                        assert(bytes[i] < p[i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    fn to_le_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            static_assert(1 < radix, \"radix must be greater than 1\");\n            static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n            static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n        }\n        __to_le_radix(self, radix)\n    }\n\n    fn to_be_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            static_assert(1 < radix, \"radix must be greater than 1\");\n            static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n            static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n        }\n        __to_be_radix(self, radix)\n    }\n\n    // Returns self to the power of the given exponent value.\n    // Caution: we assume the exponent fits into 32 bits\n    // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n    pub fn pow_32(self, exponent: Field) -> Field {\n        let mut r: Field = 1;\n        let b: [u1; 32] = exponent.to_le_bits();\n\n        for i in 1..33 {\n            r *= r;\n            r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n        }\n        r\n    }\n\n    // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n    pub fn sgn0(self) -> u1 {\n        self as u1\n    }\n\n    pub fn lt(self, another: Field) -> bool {\n        if crate::compat::is_bn254() {\n            bn254_lt(self, another)\n        } else {\n            lt_fallback(self, another)\n        }\n    }\n\n    /// Convert a little endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    pub fn from_le_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n\n    /// Convert a big endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    pub fn from_be_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[N - 1 - i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n}\n\n#[builtin(apply_range_constraint)]\nfn __assert_max_bit_size(value: Field, bit_size: u32) {}\n\n// `_radix` must be less than 256\n#[builtin(to_le_radix)]\nfn __to_le_radix<let N: u32>(value: Field, radix: u32) -> [u8; N] {}\n\n// `_radix` must be less than 256\n#[builtin(to_be_radix)]\nfn __to_be_radix<let N: u32>(value: Field, radix: u32) -> [u8; N] {}\n\n/// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n/// This slice will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_le_bits)]\nfn __to_le_bits<let N: u32>(value: Field) -> [u1; N] {}\n\n/// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n/// This array will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_be_bits)]\nfn __to_be_bits<let N: u32>(value: Field) -> [u1; N] {}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n    __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(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..16 {\n        high = high + (bytes32[15 - i] as Field) * v;\n        low = low + (bytes32[16 + 15 - i] as Field) * v;\n        v = v * 256;\n    }\n    // Abuse that a % p + b % p = (a + b) % p and that low < p\n    low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n    if is_unconstrained() {\n        // Safety: unconstrained context\n        unsafe {\n            field_less_than(x, y)\n        }\n    } else {\n        let x_bytes: [u8; 32] = x.to_le_bytes();\n        let y_bytes: [u8; 32] = y.to_le_bytes();\n        let mut x_is_lt = false;\n        let mut done = false;\n        for i in 0..32 {\n            if (!done) {\n                let x_byte = x_bytes[32 - 1 - i] as u8;\n                let y_byte = y_bytes[32 - 1 - i] as u8;\n                let bytes_match = x_byte == y_byte;\n                if !bytes_match {\n                    x_is_lt = x_byte < y_byte;\n                    done = true;\n                }\n            }\n        }\n        x_is_lt\n    }\n}\n\nmod tests {\n    use crate::{panic::panic, runtime, static_assert};\n    use super::{\n        field_less_than, modulus_be_bits, modulus_be_bytes, modulus_le_bits, modulus_le_bytes,\n    };\n\n    #[test]\n    // docs:start:to_be_bits_example\n    fn test_to_be_bits() {\n        let field = 2;\n        let bits: [u1; 8] = field.to_be_bits();\n        assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n    }\n    // docs:end:to_be_bits_example\n\n    #[test]\n    // docs:start:to_le_bits_example\n    fn test_to_le_bits() {\n        let field = 2;\n        let bits: [u1; 8] = field.to_le_bits();\n        assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n    }\n    // docs:end:to_le_bits_example\n\n    #[test]\n    // docs:start:to_be_bytes_example\n    fn test_to_be_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_be_bytes();\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_bytes_example\n\n    #[test]\n    // docs:start:to_le_bytes_example\n    fn test_to_le_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_le_bytes();\n        assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_bytes_example\n\n    #[test]\n    // docs:start:to_be_radix_example\n    fn test_to_be_radix() {\n        // 259, in base 256, big endian, is [1, 3].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_be_radix(256);\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_radix_example\n\n    #[test]\n    // docs:start:to_le_radix_example\n    fn test_to_le_radix() {\n        // 259, in base 256, little endian, is [3, 1].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_le_radix(256);\n        assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_radix_example\n\n    #[test(should_fail_with = \"radix must be greater than 1\")]\n    fn test_to_le_radix_1() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(1);\n        } else {\n            panic(f\"radix must be greater than 1\");\n        }\n    }\n\n    // Updated test to account for Brillig restriction that radix must be greater than 2\n    #[test(should_fail_with = \"radix must be greater than 1\")]\n    fn test_to_le_radix_brillig_1() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 1;\n            let _: [u8; 8] = field.to_le_radix(1);\n        } else {\n            panic(f\"radix must be greater than 1\");\n        }\n    }\n\n    #[test(should_fail_with = \"radix must be a power of 2\")]\n    fn test_to_le_radix_3() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(3);\n        } else {\n            panic(f\"radix must be a power of 2\");\n        }\n    }\n\n    #[test]\n    fn test_to_le_radix_brillig_3() {\n        // this test should only fail in constrained mode\n        if runtime::is_unconstrained() {\n            let field = 1;\n            let out: [u8; 8] = field.to_le_radix(3);\n            let mut expected = [0; 8];\n            expected[0] = 1;\n            assert(out == expected, \"unexpected result\");\n        }\n    }\n\n    #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n    fn test_to_le_radix_512() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(512);\n        } else {\n            panic(f\"radix must be less than or equal to 256\")\n        }\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 16 limbs\")]\n    unconstrained fn not_enough_limbs_brillig() {\n        let _: [u8; 16] = 0x100000000000000000000000000000000.to_le_bytes();\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 16 limbs\")]\n    fn not_enough_limbs() {\n        let _: [u8; 16] = 0x100000000000000000000000000000000.to_le_bytes();\n    }\n\n    #[test]\n    unconstrained fn test_field_less_than() {\n        assert(field_less_than(0, 1));\n        assert(field_less_than(0, 0x100));\n        assert(field_less_than(0x100, 0 - 1));\n        assert(!field_less_than(0 - 1, 0));\n    }\n\n    #[test]\n    unconstrained fn test_large_field_values_unconstrained() {\n        let large_field = 0xffffffffffffffff;\n\n        let bits: [u1; 64] = large_field.to_le_bits();\n        assert_eq(bits[0], 1);\n\n        let bytes: [u8; 8] = large_field.to_le_bytes();\n        assert_eq(Field::from_le_bytes::<8>(bytes), large_field);\n\n        let radix_bytes: [u8; 8] = large_field.to_le_radix(256);\n        assert_eq(Field::from_le_bytes::<8>(radix_bytes), large_field);\n    }\n\n    #[test]\n    fn test_large_field_values() {\n        let large_val = 0xffffffffffffffff;\n\n        let bits: [u1; 64] = large_val.to_le_bits();\n        assert_eq(bits[0], 1);\n\n        let bytes: [u8; 8] = large_val.to_le_bytes();\n        assert_eq(Field::from_le_bytes::<8>(bytes), large_val);\n\n        let radix_bytes: [u8; 8] = large_val.to_le_radix(256);\n        assert_eq(Field::from_le_bytes::<8>(radix_bytes), large_val);\n    }\n\n    #[test]\n    fn test_decomposition_edge_cases() {\n        let zero_bits: [u1; 8] = 0.to_le_bits();\n        assert_eq(zero_bits, [0; 8]);\n\n        let zero_bytes: [u8; 8] = 0.to_le_bytes();\n        assert_eq(zero_bytes, [0; 8]);\n\n        let one_bits: [u1; 8] = 1.to_le_bits();\n        let expected: [u1; 8] = [1, 0, 0, 0, 0, 0, 0, 0];\n        assert_eq(one_bits, expected);\n\n        let pow2_bits: [u1; 8] = 4.to_le_bits();\n        let expected: [u1; 8] = [0, 0, 1, 0, 0, 0, 0, 0];\n        assert_eq(pow2_bits, expected);\n    }\n\n    #[test]\n    fn test_pow_32() {\n        assert_eq(2.pow_32(3), 8);\n        assert_eq(3.pow_32(2), 9);\n        assert_eq(5.pow_32(0), 1);\n        assert_eq(7.pow_32(1), 7);\n\n        assert_eq(2.pow_32(10), 1024);\n\n        assert_eq(0.pow_32(5), 0);\n        assert_eq(0.pow_32(0), 1);\n\n        assert_eq(1.pow_32(100), 1);\n    }\n\n    #[test]\n    fn test_sgn0() {\n        assert_eq(0.sgn0(), 0);\n        assert_eq(2.sgn0(), 0);\n        assert_eq(4.sgn0(), 0);\n        assert_eq(100.sgn0(), 0);\n\n        assert_eq(1.sgn0(), 1);\n        assert_eq(3.sgn0(), 1);\n        assert_eq(5.sgn0(), 1);\n        assert_eq(101.sgn0(), 1);\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 8 limbs\")]\n    fn test_bit_decomposition_overflow() {\n        // 8 bits can't represent large field values\n        let large_val = 0x1000000000000000;\n        let _: [u1; 8] = large_val.to_le_bits();\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 4 limbs\")]\n    fn test_byte_decomposition_overflow() {\n        // 4 bytes can't represent large field values\n        let large_val = 0x1000000000000000;\n        let _: [u8; 4] = large_val.to_le_bytes();\n    }\n\n    #[test]\n    fn test_to_from_be_bytes_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this byte produces the expected 32 BE bytes for (modulus - 1)\n            let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n            assert(p_minus_1_bytes[32 - 1] > 0);\n            p_minus_1_bytes[32 - 1] -= 1;\n\n            let p_minus_1 = Field::from_be_bytes::<32>(p_minus_1_bytes);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n            let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_be_bytes();\n            assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n            // checking that incrementing this byte produces 32 BE bytes for (modulus + 1)\n            let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n            assert(p_plus_1_bytes[32 - 1] < 255);\n            p_plus_1_bytes[32 - 1] += 1;\n\n            let p_plus_1 = Field::from_be_bytes::<32>(p_plus_1_bytes);\n            assert_eq(p_plus_1, 1);\n\n            // checking that converting p_plus_1 to 32 BE bytes produces the same\n            // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n            let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_be_bytes();\n            assert_eq(p_plus_1_converted_bytes[32 - 1], 1);\n            p_plus_1_converted_bytes[32 - 1] = 0;\n            assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n            // checking that Field::from_be_bytes::<32> on the Field modulus produces 0\n            assert_eq(modulus_be_bytes().len(), 32);\n            let p = Field::from_be_bytes::<32>(modulus_be_bytes().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 32 BE bytes produces 32 zeroes\n            let p_bytes: [u8; 32] = 0.to_be_bytes();\n            assert_eq(p_bytes, [0; 32]);\n        }\n    }\n\n    #[test]\n    fn test_to_from_le_bytes_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this byte produces the expected 32 LE bytes for (modulus - 1)\n            let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n            assert(p_minus_1_bytes[0] > 0);\n            p_minus_1_bytes[0] -= 1;\n\n            let p_minus_1 = Field::from_le_bytes::<32>(p_minus_1_bytes);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n            let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_le_bytes();\n            assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n            // checking that incrementing this byte produces 32 LE bytes for (modulus + 1)\n            let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n            assert(p_plus_1_bytes[0] < 255);\n            p_plus_1_bytes[0] += 1;\n\n            let p_plus_1 = Field::from_le_bytes::<32>(p_plus_1_bytes);\n            assert_eq(p_plus_1, 1);\n\n            // checking that converting p_plus_1 to 32 LE bytes produces the same\n            // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n            let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_le_bytes();\n            assert_eq(p_plus_1_converted_bytes[0], 1);\n            p_plus_1_converted_bytes[0] = 0;\n            assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n            // checking that Field::from_le_bytes::<32> on the Field modulus produces 0\n            assert_eq(modulus_le_bytes().len(), 32);\n            let p = Field::from_le_bytes::<32>(modulus_le_bytes().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 32 LE bytes produces 32 zeroes\n            let p_bytes: [u8; 32] = 0.to_le_bytes();\n            assert_eq(p_bytes, [0; 32]);\n        }\n    }\n\n    /// Convert a little endian bit array to a field element.\n    /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n    fn from_le_bits<let N: u32>(bits: [u1; N]) -> Field {\n        static_assert(\n            N <= modulus_le_bits().len(),\n            \"N must be less than or equal to modulus_le_bits().len()\",\n        );\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bits[i] as Field) * v;\n            v = v * 2;\n        }\n        result\n    }\n\n    /// Convert a big endian bit array to a field element.\n    /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n    fn from_be_bits<let N: u32>(bits: [u1; N]) -> Field {\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bits[N - 1 - i] as Field) * v;\n            v = v * 2;\n        }\n        result\n    }\n\n    #[test]\n    fn test_to_from_be_bits_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this bit produces the expected 254 BE bits for (modulus - 1)\n            let mut p_minus_1_bits: [u1; 254] = modulus_be_bits().as_array();\n            assert(p_minus_1_bits[254 - 1] > 0);\n            p_minus_1_bits[254 - 1] -= 1;\n\n            let p_minus_1 = from_be_bits::<254>(p_minus_1_bits);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 254 BE bits produces the same bits\n            let p_minus_1_converted_bits: [u1; 254] = p_minus_1.to_be_bits();\n            assert_eq(p_minus_1_converted_bits, p_minus_1_bits);\n\n            // checking that incrementing this bit produces 254 BE bits for (modulus + 4)\n            let mut p_plus_4_bits: [u1; 254] = modulus_be_bits().as_array();\n            assert(p_plus_4_bits[254 - 3] < 1);\n            p_plus_4_bits[254 - 3] += 1;\n\n            let p_plus_4 = from_be_bits::<254>(p_plus_4_bits);\n            assert_eq(p_plus_4, 4);\n\n            // checking that converting p_plus_4 to 254 BE bits produces the same\n            // bit set to 1 as p_plus_4_bits and otherwise zeroes\n            let mut p_plus_4_converted_bits: [u1; 254] = p_plus_4.to_be_bits();\n            assert_eq(p_plus_4_converted_bits[254 - 3], 1);\n            p_plus_4_converted_bits[254 - 3] = 0;\n            assert_eq(p_plus_4_converted_bits, [0; 254]);\n\n            // checking that Field::from_be_bits::<254> on the Field modulus produces 0\n            assert_eq(modulus_be_bits().len(), 254);\n            let p = from_be_bits::<254>(modulus_be_bits().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 254 BE bytes produces 254 zeroes\n            let p_bits: [u1; 254] = 0.to_be_bits();\n            assert_eq(p_bits, [0; 254]);\n        }\n    }\n\n    #[test]\n    fn test_to_from_le_bits_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this bit produces the expected 254 LE bits for (modulus - 1)\n            let mut p_minus_1_bits: [u1; 254] = modulus_le_bits().as_array();\n            assert(p_minus_1_bits[0] > 0);\n            p_minus_1_bits[0] -= 1;\n\n            let p_minus_1 = from_le_bits::<254>(p_minus_1_bits);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 254 BE bits produces the same bits\n            let p_minus_1_converted_bits: [u1; 254] = p_minus_1.to_le_bits();\n            assert_eq(p_minus_1_converted_bits, p_minus_1_bits);\n\n            // checking that incrementing this bit produces 254 LE bits for (modulus + 4)\n            let mut p_plus_4_bits: [u1; 254] = modulus_le_bits().as_array();\n            assert(p_plus_4_bits[2] < 1);\n            p_plus_4_bits[2] += 1;\n\n            let p_plus_4 = from_le_bits::<254>(p_plus_4_bits);\n            assert_eq(p_plus_4, 4);\n\n            // checking that converting p_plus_4 to 254 LE bits produces the same\n            // bit set to 1 as p_plus_4_bits and otherwise zeroes\n            let mut p_plus_4_converted_bits: [u1; 254] = p_plus_4.to_le_bits();\n            assert_eq(p_plus_4_converted_bits[2], 1);\n            p_plus_4_converted_bits[2] = 0;\n            assert_eq(p_plus_4_converted_bits, [0; 254]);\n\n            // checking that Field::from_le_bits::<254> on the Field modulus produces 0\n            assert_eq(modulus_le_bits().len(), 254);\n            let p = from_le_bits::<254>(modulus_le_bits().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 254 LE bytes produces 254 zeroes\n            let p_bits: [u1; 254] = 0.to_le_bits();\n            assert_eq(p_bits, [0; 254]);\n        }\n    }\n}\n"
     },
-    "181": {
+    "182": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/shared_secret.nr",
       "source": "use protocol_types::{address::aztec_address::AztecAddress, point::Point};\n\n// TODO(#12656): return an app-siloed secret + document this\n#[oracle(utilityGetSharedSecret)]\nunconstrained fn get_shared_secret_oracle(address: AztecAddress, ephPk: Point) -> Point {}\n\n/// Returns an app-siloed shared secret between `address` and someone who knows the secret key behind an\n/// ephemeral public key `ephPk`. The app-siloing means that contracts cannot retrieve secrets that belong to\n/// other contracts, and therefore cannot e.g. decrypt their messages. This is an important security consideration\n/// given that both the `address` and `ephPk` are public information.\n///\n/// The shared secret `S` is computed as:\n/// `let S =  (ivsk + h) * ephPk`\n/// where `ivsk + h` is the 'preaddress' i.e. the preimage of the address, also called the address secret.\n/// TODO(#12656): app-silo this secret\npub unconstrained fn get_shared_secret(address: AztecAddress, ephPk: Point) -> Point {\n    get_shared_secret_oracle(address, ephPk)\n}\n"
     },
     "19": {
       "path": "std/hash/mod.nr",
-      "source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n    EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n    #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n    pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n        super::keccakf1600(input)\n    }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n    if crate::runtime::is_unconstrained() {\n        // Temporary measure while Barretenberg is main proving system.\n        // Please open an issue if you're working on another proving system and running into problems due to this.\n        crate::static_assert(\n            N <= 1024,\n            \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n        );\n    }\n    __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3<let N: u32>(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint {\n    // docs:end:pedersen_commitment\n    pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator<let N: u32>(\n    input: [Field; N],\n    separator: u32,\n) -> EmbeddedCurvePoint {\n    let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n    for i in 0..N {\n        // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n        points[i] = from_field_unsafe(input[i]);\n    }\n    let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n    multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n    pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator<let N: u32>(input: [Field; N], separator: u32) -> Field {\n    let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n    let mut generators: [EmbeddedCurvePoint; N + 1] =\n        [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n    let domain_generators: [EmbeddedCurvePoint; N] =\n        derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n    for i in 0..N {\n        scalars[i] = from_field_unsafe(input[i]);\n        generators[i] = domain_generators[i];\n    }\n    scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n    let length_generator: [EmbeddedCurvePoint; 1] =\n        derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n    generators[N] = length_generator[0];\n    multi_scalar_mul_array_return(generators, scalars, true)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n    crate::assert_constant(domain_separator_bytes);\n    // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n    __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n    // Safety: xlo and xhi decomposition is checked below\n    let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n    // Check that the decomposition is correct\n    assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n    EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation<let N: u32>(input: [Field; N], state_len: u32) -> [Field; N] {\n    assert_eq(input.len(), state_len);\n    poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal<let N: u32>(input: [Field; N]) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n    let name = quote { $crate::hash::Hash };\n    let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n    let for_each_field = |name| quote { _self.$name.hash(_state); };\n    crate::meta::make_trait_impl(\n        s,\n        name,\n        signature,\n        for_each_field,\n        quote {},\n        |fields| fields,\n    )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n    fn finish(self) -> Field;\n\n    fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n    type H: Hasher;\n\n    fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault<H>;\n\nimpl<H> BuildHasher for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    type H = H;\n\n    fn build_hasher(_self: Self) -> H {\n        H::default()\n    }\n}\n\nimpl<H> Default for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    fn default() -> Self {\n        BuildHasherDefault {}\n    }\n}\n\nimpl Hash for Field {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self);\n    }\n}\n\nimpl Hash for u1 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u128 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u8 as Field);\n    }\n}\n\nimpl Hash for i16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u16 as Field);\n    }\n}\n\nimpl Hash for i32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u32 as Field);\n    }\n}\n\nimpl Hash for i64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u64 as Field);\n    }\n}\n\nimpl Hash for bool {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for () {\n    fn hash<H>(_self: Self, _state: &mut H)\n    where\n        H: Hasher,\n    {}\n}\n\nimpl<T, let N: u32> Hash for [T; N]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<T> Hash for [T]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.len().hash(state);\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<A, B> Hash for (A, B)\nwhere\n    A: Hash,\n    B: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n    }\n}\n\nimpl<A, B, C> Hash for (A, B, C)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n    }\n}\n\nimpl<A, B, C, D> Hash for (A, B, C, D)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E> Hash for (A, B, C, D, E)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n    }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n    assert_eq(\n        pedersen_hash_with_separator([1], 1),\n        0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1], 1),\n        EmbeddedCurvePoint {\n            x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n            y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n            is_infinite: false,\n        },\n    );\n\n    assert_eq(\n        pedersen_hash_with_separator([1, 2], 2),\n        0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2], 2),\n        EmbeddedCurvePoint {\n            x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n            y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3], 3),\n        0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3], 3),\n        EmbeddedCurvePoint {\n            x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n            y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4], 4),\n        0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n        EmbeddedCurvePoint {\n            x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n            y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n        0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n        EmbeddedCurvePoint {\n            x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n            y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n        0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n        EmbeddedCurvePoint {\n            x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n            y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        EmbeddedCurvePoint {\n            x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n            y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        EmbeddedCurvePoint {\n            x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n            y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        EmbeddedCurvePoint {\n            x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n            y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        EmbeddedCurvePoint {\n            x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n            y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n            is_infinite: false,\n        },\n    );\n}\n"
+      "source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n    EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n    #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n    pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n        super::keccakf1600(input)\n    }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n    if crate::runtime::is_unconstrained() {\n        // Temporary measure while Barretenberg is main proving system.\n        // Please open an issue if you're working on another proving system and running into problems due to this.\n        crate::static_assert(\n            N <= 1024,\n            \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n        );\n    }\n    __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3<let N: u32>(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint {\n    // docs:end:pedersen_commitment\n    pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator<let N: u32>(\n    input: [Field; N],\n    separator: u32,\n) -> EmbeddedCurvePoint {\n    let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n    for i in 0..N {\n        // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n        points[i] = from_field_unsafe(input[i]);\n    }\n    let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n    multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n    pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator<let N: u32>(input: [Field; N], separator: u32) -> Field {\n    let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n    let mut generators: [EmbeddedCurvePoint; N + 1] =\n        [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n    let domain_generators: [EmbeddedCurvePoint; N] =\n        derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n    for i in 0..N {\n        scalars[i] = from_field_unsafe(input[i]);\n        generators[i] = domain_generators[i];\n    }\n    scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n    let length_generator: [EmbeddedCurvePoint; 1] =\n        derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n    generators[N] = length_generator[0];\n    multi_scalar_mul_array_return(generators, scalars, true)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n    crate::assert_constant(domain_separator_bytes);\n    // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n    __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Decompose the input 'bn254 scalar' into two 128 bits limbs.\n// It is called 'unsafe' because it does not assert the limbs are 128 bits\n// Assuming the limbs are 128 bits:\n// Assert the decomposition does not overflow the field size.\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n    // Safety: xlo and xhi decomposition is checked below\n    let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n    // Check that the decomposition is correct\n    assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n    // Check that the decomposition does not overflow the field size\n    let (a, b) = if xhi == crate::field::bn254::PHI {\n        (xlo, crate::field::bn254::PLO)\n    } else {\n        (xhi, crate::field::bn254::PHI)\n    };\n    crate::field::bn254::assert_lt(a, b);\n\n    EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation<let N: u32>(input: [Field; N], state_len: u32) -> [Field; N] {\n    assert_eq(input.len(), state_len);\n    poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal<let N: u32>(input: [Field; N]) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n    let name = quote { $crate::hash::Hash };\n    let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n    let for_each_field = |name| quote { _self.$name.hash(_state); };\n    crate::meta::make_trait_impl(\n        s,\n        name,\n        signature,\n        for_each_field,\n        quote {},\n        |fields| fields,\n    )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n    fn finish(self) -> Field;\n\n    fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n    type H: Hasher;\n\n    fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault<H>;\n\nimpl<H> BuildHasher for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    type H = H;\n\n    fn build_hasher(_self: Self) -> H {\n        H::default()\n    }\n}\n\nimpl<H> Default for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    fn default() -> Self {\n        BuildHasherDefault {}\n    }\n}\n\nimpl Hash for Field {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self);\n    }\n}\n\nimpl Hash for u1 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u128 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u8 as Field);\n    }\n}\n\nimpl Hash for i16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u16 as Field);\n    }\n}\n\nimpl Hash for i32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u32 as Field);\n    }\n}\n\nimpl Hash for i64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u64 as Field);\n    }\n}\n\nimpl Hash for bool {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for () {\n    fn hash<H>(_self: Self, _state: &mut H)\n    where\n        H: Hasher,\n    {}\n}\n\nimpl<T, let N: u32> Hash for [T; N]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<T> Hash for [T]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.len().hash(state);\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<A, B> Hash for (A, B)\nwhere\n    A: Hash,\n    B: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n    }\n}\n\nimpl<A, B, C> Hash for (A, B, C)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n    }\n}\n\nimpl<A, B, C, D> Hash for (A, B, C, D)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E> Hash for (A, B, C, D, E)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n    }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n    assert_eq(\n        pedersen_hash_with_separator([1], 1),\n        0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1], 1),\n        EmbeddedCurvePoint {\n            x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n            y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n            is_infinite: false,\n        },\n    );\n\n    assert_eq(\n        pedersen_hash_with_separator([1, 2], 2),\n        0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2], 2),\n        EmbeddedCurvePoint {\n            x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n            y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3], 3),\n        0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3], 3),\n        EmbeddedCurvePoint {\n            x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n            y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4], 4),\n        0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n        EmbeddedCurvePoint {\n            x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n            y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n        0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n        EmbeddedCurvePoint {\n            x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n            y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n        0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n        EmbeddedCurvePoint {\n            x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n            y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        EmbeddedCurvePoint {\n            x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n            y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        EmbeddedCurvePoint {\n            x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n            y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        EmbeddedCurvePoint {\n            x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n            y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        EmbeddedCurvePoint {\n            x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n            y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n            is_infinite: false,\n        },\n    );\n}\n"
     },
-    "217": {
+    "218": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/append.nr",
       "source": "/// Appends the elements of the second `BoundedVec` to the end of the first one. The resulting `BoundedVec` can have any arbitrary maximum length, but it must be\n/// large enough to fit all of the elements of both the first and second vectors.\npub fn append<T, let ALen: u32, let BLen: u32, let DstLen: u32>(\n    a: BoundedVec<T, ALen>,\n    b: BoundedVec<T, BLen>,\n) -> BoundedVec<T, DstLen> {\n    let mut dst = BoundedVec::new();\n\n    dst.extend_from_bounded_vec(a);\n    dst.extend_from_bounded_vec(b);\n\n    dst\n}\n\nmod test {\n    use super::append;\n\n    #[test]\n    unconstrained fn append_empty_vecs() {\n        let a: BoundedVec<_, 3> = BoundedVec::new();\n        let b: BoundedVec<_, 14> = BoundedVec::new();\n\n        let result: BoundedVec<Field, 5> = append(a, b);\n\n        assert_eq(result.len(), 0);\n        assert_eq(result.storage(), std::mem::zeroed());\n    }\n\n    #[test]\n    unconstrained fn append_non_empty_vecs() {\n        let a: BoundedVec<_, 3> = BoundedVec::from_array([1, 2, 3]);\n        let b: BoundedVec<_, 14> = BoundedVec::from_array([4, 5, 6]);\n\n        let result: BoundedVec<Field, 8> = append(a, b);\n\n        assert_eq(result.len(), 6);\n        assert_eq(result.storage(), [1, 2, 3, 4, 5, 6, std::mem::zeroed(), std::mem::zeroed()]);\n    }\n\n    #[test(should_fail_with = \"out of bounds\")]\n    unconstrained fn append_non_empty_vecs_insufficient_max_len() {\n        let a: BoundedVec<_, 3> = BoundedVec::from_array([1, 2, 3]);\n        let b: BoundedVec<_, 14> = BoundedVec::from_array([4, 5, 6]);\n\n        let _: BoundedVec<Field, 5> = append(a, b);\n    }\n}\n"
     },
-    "220": {
+    "221": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/subarray.nr",
       "source": "/// Returns `DstLen` elements from a source array, starting at `offset`. `DstLen` must not be larger than the number\n/// of elements past `offset`.\n///\n/// Examples:\n/// ```\n/// let foo: [Field; 2] = subarray([1, 2, 3, 4, 5], 2);\n/// assert_eq(foo, [3, 4]);\n///\n/// let bar: [Field; 5] = subarray([1, 2, 3, 4, 5], 2); // fails - we can't return 5 elements since only 3 remain\n/// ```\npub fn subarray<T, let SrcLen: u32, let DstLen: u32>(src: [T; SrcLen], offset: u32) -> [T; DstLen] {\n    assert(offset + DstLen <= SrcLen, \"DstLen too large for offset\");\n\n    let mut dst: [T; DstLen] = std::mem::zeroed();\n    for i in 0..DstLen {\n        dst[i] = src[i + offset];\n    }\n\n    dst\n}\n\nmod test {\n    use super::subarray;\n\n    #[test]\n    unconstrained fn subarray_into_empty() {\n        // In all of these cases we're setting DstLen to be 0, so we always get back an empty array.\n        assert_eq(subarray::<Field, _, _>([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 2), []);\n    }\n\n    #[test]\n    unconstrained fn subarray_complete() {\n        assert_eq(subarray::<Field, _, _>([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), [1, 2, 3, 4, 5]);\n    }\n\n    #[test]\n    unconstrained fn subarray_different_end_sizes() {\n        // We implicitly select how many values to read in the size of the return array\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4, 5]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2]);\n    }\n\n    #[test(should_fail_with = \"DstLen too large for offset\")]\n    unconstrained fn subarray_offset_too_large() {\n        // With an offset of 1 we can only request up to 4 elements\n        let _: [_; 5] = subarray([1, 2, 3, 4, 5], 1);\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subarray_bad_return_value() {\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [3, 3, 4, 5]);\n    }\n}\n"
     },
-    "221": {
+    "222": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/subbvec.nr",
       "source": "use crate::utils::array;\n\n/// Returns `DstMaxLen` elements from a source BoundedVec, starting at `offset`. `offset` must not be larger than the\n/// original length, and `DstLen` must not be larger than the total number of elements past `offset` (including the\n/// zeroed elements past `len()`).\n///\n/// Only elements at the beginning of the vector can be removed: it is not possible to also remove elements at the end\n/// of the vector by passing a value for `DstLen` that is smaller than `len() - offset`.\n///\n/// Examples:\n/// ```\n/// let foo = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n/// assert_eq(subbvec(foo, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n///\n/// let bar: BoundedVec<_, 1> = subbvec(foo, 2); // fails - we can't return just 1 element since 3 remain\n/// let baz: BoundedVec<_, 10> = subbvec(foo, 3); // fails - we can't return 10 elements since only 7 remain\n/// ```\npub fn subbvec<T, let SrcMaxLen: u32, let DstMaxLen: u32>(\n    bvec: BoundedVec<T, SrcMaxLen>,\n    offset: u32,\n) -> BoundedVec<T, DstMaxLen> {\n    // from_parts_unchecked does not verify that the elements past len are zeroed, but that is not an issue in our case\n    // because we're constructing the new storage array as a subarray of the original one (which should have zeroed\n    // storage past len), guaranteeing correctness. This is because `subarray` does not allow extending arrays past\n    // their original length.\n    BoundedVec::from_parts_unchecked(array::subarray(bvec.storage(), offset), bvec.len() - offset)\n}\n\nmod test {\n    use super::subbvec;\n\n    #[test]\n    unconstrained fn subbvec_empty() {\n        let bvec = BoundedVec::<Field, 0>::from_array([]);\n        assert_eq(subbvec(bvec, 0), bvec);\n    }\n\n    #[test]\n    unconstrained fn subbvec_complete() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n        assert_eq(subbvec(bvec, 0), bvec);\n\n        let smaller_capacity = BoundedVec::<_, 5>::from_array([1, 2, 3, 4, 5]);\n        assert_eq(subbvec(bvec, 0), smaller_capacity);\n    }\n\n    #[test]\n    unconstrained fn subbvec_partial() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        assert_eq(subbvec(bvec, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n        assert_eq(subbvec(bvec, 2), BoundedVec::<_, 3>::from_array([3, 4, 5]));\n    }\n\n    #[test]\n    unconstrained fn subbvec_into_empty() {\n        let bvec: BoundedVec<_, 10> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n        assert_eq(subbvec(bvec, 5), BoundedVec::<_, 5>::from_array([]));\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subbvec_offset_past_len() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n        let _: BoundedVec<_, 1> = subbvec(bvec, 6);\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subbvec_insufficient_dst_len() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        // We're not providing enough space to hold all of the items inside the original BoundedVec. subbvec can cause\n        // for the capacity to reduce, but not the length (other than by len - offset).\n        let _: BoundedVec<_, 1> = subbvec(bvec, 2);\n    }\n\n    #[test(should_fail_with = \"DstLen too large for offset\")]\n    unconstrained fn subbvec_dst_len_causes_enlarge() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        // subbvec does not supprt capacity increases\n        let _: BoundedVec<_, 11> = subbvec(bvec, 0);\n    }\n\n    #[test(should_fail_with = \"DstLen too large for offset\")]\n    unconstrained fn subbvec_dst_len_too_large_for_offset() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        // This effectively requests a capacity increase, since there'd be just one element plus the 5 empty slots,\n        // which is less than 7.\n        let _: BoundedVec<_, 7> = subbvec(bvec, 4);\n    }\n}\n"
     },
-    "222": {
+    "223": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/comparison.nr",
       "source": "struct ComparatorEnum {\n    pub EQ: u8,\n    pub NEQ: u8,\n    pub LT: u8,\n    pub LTE: u8,\n    pub GT: u8,\n    pub GTE: u8,\n}\n\npub global Comparator: ComparatorEnum =\n    ComparatorEnum { EQ: 1, NEQ: 2, LT: 3, LTE: 4, GT: 5, GTE: 6 };\n\npub fn compare(lhs: Field, operation: u8, rhs: Field) -> bool {\n    // Values are computed ahead of time because circuits evaluate all branches\n    let is_equal = lhs == rhs;\n    let is_lt = lhs.lt(rhs);\n\n    if (operation == Comparator.EQ) {\n        is_equal\n    } else if (operation == Comparator.NEQ) {\n        !is_equal\n    } else if (operation == Comparator.LT) {\n        is_lt\n    } else if (operation == Comparator.LTE) {\n        is_lt | is_equal\n    } else if (operation == Comparator.GT) {\n        !is_lt & !is_equal\n    } else if (operation == Comparator.GTE) {\n        !is_lt\n    } else {\n        panic(f\"Invalid operation\")\n    }\n}\n\nmod test {\n    use super::Comparator;\n    use super::compare;\n\n    #[test]\n    unconstrained fn test_compare() {\n        let lhs = 10;\n        let rhs = 10;\n        assert(compare(lhs, Comparator.EQ, rhs), \"Expected lhs to be equal to rhs\");\n\n        let lhs = 10;\n        let rhs = 11;\n        assert(compare(lhs, Comparator.NEQ, rhs), \"Expected lhs to be not equal to rhs\");\n\n        let lhs = 10;\n        let rhs = 11;\n        assert(compare(lhs, Comparator.LT, rhs), \"Expected lhs to be less than rhs\");\n\n        let lhs = 10;\n        let rhs = 10;\n        assert(compare(lhs, Comparator.LTE, rhs), \"Expected lhs to be less than or equal to rhs\");\n\n        let lhs = 11;\n        let rhs = 10;\n        assert(compare(lhs, Comparator.GT, rhs), \"Expected lhs to be greater than rhs\");\n\n        let lhs = 10;\n        let rhs = 10;\n        assert(\n            compare(lhs, Comparator.GTE, rhs),\n            \"Expected lhs to be greater than or equal to rhs\",\n        );\n\n        let lhs = 11;\n        let rhs = 10;\n        assert(\n            compare(lhs, Comparator.GTE, rhs),\n            \"Expected lhs to be greater than or equal to rhs\",\n        );\n\n        let lhs = 10;\n        let rhs = 11;\n        assert(!compare(lhs, Comparator.EQ, rhs), \"Expected lhs to be not equal to rhs\");\n\n        let lhs = 10;\n        let rhs = 10;\n        assert(!compare(lhs, Comparator.NEQ, rhs), \"Expected lhs to not be not equal to rhs\");\n\n        let lhs = 11;\n        let rhs = 10;\n        assert(!compare(lhs, Comparator.LT, rhs), \"Expected lhs to not be less than rhs\");\n\n        let lhs = 11;\n        let rhs = 10;\n        assert(\n            !compare(lhs, Comparator.LTE, rhs),\n            \"Expected lhs to not be less than or equal to rhs\",\n        );\n\n        let lhs = 10;\n        let rhs = 10;\n        assert(!compare(lhs, Comparator.GT, rhs), \"Expected lhs to not be greater than rhs\");\n\n        let lhs = 10;\n        let rhs = 11;\n        assert(\n            !compare(lhs, Comparator.GTE, rhs),\n            \"Expected lhs to not be greater than or equal to rhs\",\n        );\n\n        let lhs = 10;\n        let rhs = 11;\n        assert(\n            !compare(lhs, Comparator.GTE, rhs),\n            \"Expected lhs to not be greater than or equal to rhs\",\n        );\n    }\n}\n"
     },
-    "223": {
+    "224": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/conversion/bytes_to_fields.nr",
       "source": "use std::static_assert;\n\n// These functions are used to facilitate the conversion of log ciphertext between byte and field representations.\n//\n// `bytes_to_fields` uses fixed-size arrays since encryption contexts have compile-time size information.\n// `bytes_from_fields` uses BoundedVec for flexibility in unconstrained contexts where sizes are dynamic.\n//\n// Together they provide bidirectional conversion between bytes and fields when processing encrypted logs.\n\n/// Converts the input bytes into an array of fields. A Field is ~254 bits meaning that each field can store 31 whole\n/// bytes. Use `bytes_from_fields` to obtain the original bytes array.\n///\n/// The input bytes are chunked into chunks of 31 bytes. Each 31-byte chunk is viewed as big-endian, and is converted\n/// into a Field.\n/// For example, [1, 10, 3, ..., 0] (31 bytes) is encoded as [1 * 256^30 + 10 * 256^29 + 3 * 256^28 + ... + 0]\n/// Note: N must be a multiple of 31 bytes\npub fn bytes_to_fields<let N: u32>(bytes: [u8; N]) -> [Field; N / 31] {\n    // Assert that N is a multiple of 31\n    static_assert(N % 31 == 0, \"N must be a multiple of 31\");\n\n    let mut fields = [0; N / 31];\n\n    // Since N is a multiple of 31, we can simply process all chunks fully\n    for i in 0..N / 31 {\n        let mut field = 0;\n        for j in 0..31 {\n            // Shift the existing value left by 8 bits and add the new byte\n            field = field * 256 + bytes[i * 31 + j] as Field;\n        }\n        fields[i] = field;\n    }\n\n    fields\n}\n\n/// Converts an input BoundedVec of fields into a BoundedVec of bytes in big-endian order. Arbitrary Field arrays\n/// are not allowed: this is assumed to be an array obtained via `bytes_to_fields`, i.e. one that actually represents\n/// bytes. To convert a Field array into bytes, use `fields_to_bytes`.\n///\n/// Each input field must contain at most 31 bytes (this is constrained to be so).\n/// Each field is converted into 31 big-endian bytes, and the resulting 31-byte chunks are concatenated\n/// back together in the order of the original fields.\npub fn bytes_from_fields<let N: u32>(fields: BoundedVec<Field, N>) -> BoundedVec<u8, N * 31> {\n    let mut bytes = BoundedVec::new();\n\n    for i in 0..fields.len() {\n        let field = fields.get(i);\n\n        // We expect that the field contains at most 31 bytes of information.\n        field.assert_max_bit_size::<248>();\n\n        // Now we can safely convert the field to 31 bytes.\n        let field_as_bytes: [u8; 31] = field.to_be_bytes();\n\n        for j in 0..31 {\n            bytes.push(field_as_bytes[j]);\n        }\n    }\n\n    bytes\n}\n\nmod tests {\n    use crate::utils::array::subarray;\n    use super::{bytes_from_fields, bytes_to_fields};\n\n    #[test]\n    unconstrained fn random_bytes_to_fields_and_back(input: [u8; 93]) {\n        let fields = bytes_to_fields(input);\n\n        // At this point in production, the log flies through the system and we get a BoundedVec on the other end.\n        // So we need to convert the field array to a BoundedVec to be able to feed it to the `bytes_from_fields`\n        // function.\n        let fields_as_bounded_vec = BoundedVec::<_, 6>::from_array(fields);\n\n        let bytes_back = bytes_from_fields(fields_as_bounded_vec);\n\n        // Compare the original input with the round-tripped result\n        assert_eq(bytes_back.len(), input.len());\n        assert_eq(subarray(bytes_back.storage(), 0), input);\n    }\n\n    #[test(should_fail_with = \"N must be a multiple of 31\")]\n    unconstrained fn bytes_to_fields_input_length_not_multiple_of_31() {\n        // Try to convert 32 bytes (not a multiple of 31) to fields\n        let _fields = bytes_to_fields([0; 32]);\n    }\n\n}\n"
     },
-    "224": {
+    "225": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/conversion/fields_to_bytes.nr",
       "source": "// These functions are used to facilitate the conversion of log plaintext represented as fields into bytes and back.\n//\n// `fields_to_bytes` uses fixed-size arrays since encryption contexts have compile-time size information.\n// `fields_from_bytes` uses BoundedVec for flexibility in unconstrained contexts where sizes are dynamic.\n//\n// Together they provide bidirectional conversion between fields and bytes.\n\n/// Converts an input array of fields into a single array of bytes. Use `fields_from_bytes` to obtain the original\n/// field array.\n/// Each field is converted to a 32-byte big-endian array.\n///\n/// For example, if you have a field array [123, 456], it will be converted to a 64-byte array:\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,0,0,123,  // First field (32 bytes)\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,0,1,200]  // Second field (32 bytes)\n///\n/// Since a field is ~254 bits, you'll end up with a subtle 2-bit \"gap\" at the big end, every 32 bytes. Be careful\n/// that such a gap doesn't leak information! This could happen if you for example expected the output to be\n/// indistinguishable from random bytes.\npub fn fields_to_bytes<let N: u32>(fields: [Field; N]) -> [u8; 32 * N] {\n    let mut bytes = [0; 32 * N];\n\n    for i in 0..N {\n        let field_as_bytes: [u8; 32] = fields[i].to_be_bytes();\n\n        for j in 0..32 {\n            bytes[i * 32 + j] = field_as_bytes[j];\n        }\n    }\n\n    bytes\n}\n\n/// Converts an input BoundedVec of bytes into a BoundedVec of fields. Arbitrary byte arrays are not allowed: this\n/// is assumed to be an array obtained via `fields_to_bytes`, i.e. one that actually represents fields. To convert\n/// a byte array into Fields, use `bytes_to_fields`.\n///\n/// The input bytes are chunked into chunks of 32 bytes. Each 32-byte chunk is viewed as big-endian, and is converted\n/// into a Field.\n/// For example, [1, 10, 3, ..., 0] (32 bytes) is encoded as [1 * 256^31 + 10 * 256^30 + 3 * 256^29 + ... + 0]\n/// Note 1: N must be a multiple of 32 bytes\n/// Note 2: The max value check code was taken from std::field::to_be_bytes function.\npub fn fields_from_bytes<let N: u32>(bytes: BoundedVec<u8, N>) -> BoundedVec<Field, N / 32> {\n    // Assert that input length is a multiple of 32\n    assert(bytes.len() % 32 == 0, \"Input length must be a multiple of 32\");\n\n    let mut fields = BoundedVec::new();\n\n    let p = std::field::modulus_be_bytes();\n\n    // Since input length is a multiple of 32, we can simply process all chunks fully\n    for i in 0..bytes.len() / 32 {\n        let mut field = 0;\n\n        // Process each byte in the 32-byte chunk\n        let mut ok = false;\n\n        for j in 0..32 {\n            let next_byte = bytes.get(i * 32 + j);\n            field = field * 256 + next_byte as Field;\n\n            if !ok {\n                if next_byte != p[j] {\n                    assert(next_byte < p[j], \"Value does not fit in field\");\n                    ok = true;\n                }\n            }\n        }\n        assert(ok, \"Value does not fit in field\");\n\n        fields.push(field);\n    }\n\n    fields\n}\n\nmod tests {\n    use crate::utils::array::subarray;\n    use super::{fields_from_bytes, fields_to_bytes};\n\n    #[test]\n    unconstrained fn random_fields_to_bytes_and_back(input: [Field; 3]) {\n        // Convert to bytes\n        let bytes = fields_to_bytes(input);\n\n        // At this point in production, the log flies through the system and we get a BoundedVec on the other end.\n        // So we need to convert the field array to a BoundedVec to be able to feed it to the `fields_from_bytes`\n        // function.\n        // 113 is an arbitrary max length that is larger than the input length of 96.\n        let bytes_as_bounded_vec = BoundedVec::<_, 113>::from_array(bytes);\n\n        // Convert back to fields\n        let fields_back = fields_from_bytes(bytes_as_bounded_vec);\n\n        // Compare the original input with the round-tripped result\n        assert_eq(fields_back.len(), input.len());\n        assert_eq(subarray(fields_back.storage(), 0), input);\n    }\n\n    #[test(should_fail_with = \"Input length must be a multiple of 32\")]\n    unconstrained fn to_fields_assert() {\n        // 143 is an arbitrary max length that is larger than 33\n        let input = BoundedVec::<_, 143>::from_array([\n            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,\n        ]);\n\n        // This should fail since 33 is not a multiple of 32\n        let _fields = fields_from_bytes(input);\n    }\n\n    #[test]\n    unconstrained fn fields_from_bytes_max_value() {\n        let max_field_as_bytes: [u8; 32] = (-1).to_be_bytes();\n        let input = BoundedVec::<_, 32>::from_array(max_field_as_bytes);\n\n        let fields = fields_from_bytes(input);\n\n        // The result should be a largest value storable in a field (-1 since we are modulo-ing)\n        assert_eq(fields.get(0), -1);\n    }\n\n    // In this test we verify that overflow check works by taking the max allowed value, bumping a random byte\n    // and then feeding it to `fields_from_bytes` as input.\n    #[test(should_fail_with = \"Value does not fit in field\")]\n    unconstrained fn fields_from_bytes_overflow(random_value: u8) {\n        let index_of_byte_to_bump = random_value % 32;\n\n        // Obtain the byte representation of the maximum field value\n        let max_field_value_as_bytes: [u8; 32] = (-1).to_be_bytes();\n\n        let byte_to_bump = max_field_value_as_bytes[index_of_byte_to_bump as u32];\n\n        // Skip test execution if the selected byte is already at maximum value (255).\n        // This is acceptable since we are using fuzz testing to generate many test cases.\n        if byte_to_bump != 255 {\n            let mut input = BoundedVec::<_, 32>::from_array(max_field_value_as_bytes);\n\n            // Increment the selected byte to exceed the field's maximum value\n            input.set(index_of_byte_to_bump as u32, byte_to_bump + 1);\n\n            // Attempt the conversion, which should fail due to the value exceeding the field's capacity\n            let _fields = fields_from_bytes(input);\n        }\n    }\n\n}\n"
     },
-    "227": {
+    "228": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/point.nr",
       "source": "use protocol_types::{point::Point, utils::field::sqrt};\n\n// I am storing the modulus minus 1 divided by 2 here because full modulus would throw \"String literal too large\" error\n// Full modulus is 21888242871839275222246405745257275088548364400416034343698204186575808495617\nglobal BN254_FR_MODULUS_DIV_2: Field =\n    10944121435919637611123202872628637544274182200208017171849102093287904247808;\n\n/// Converts a point to a byte array.\n///\n/// We don't serialize the point at infinity flag because this function is used in situations where we do not want\n/// to waste the extra byte (encrypted log).\npub fn point_to_bytes(p: Point) -> [u8; 32] {\n    // Note that there is 1 more free bit in the 32 bytes (254 bits currently occupied by the x coordinate, 1 bit for\n    // the \"sign\") so it's possible to use that last bit as an \"is_infinite\" flag if desired in the future.\n    assert(!p.is_infinite, \"Cannot serialize point at infinity as bytes.\");\n\n    let mut result: [u8; 32] = p.x.to_be_bytes();\n\n    if get_sign_of_point(p) {\n        // y is <= (modulus - 1) / 2 so we set the sign bit to 1\n        // Here we leverage that field fits into 254 bits (log2(Fr.MODULUS) < 254) and given that we serialize Fr to 32\n        // bytes and we use big-endian the 2 most significant bits are never populated. Hence we can use one of\n        // the bits as a sign bit.\n        result[0] += 128;\n    }\n\n    result\n}\n\n/**\n * Returns: true if p.y <= MOD_DIV_2, else false.\n */\npub fn get_sign_of_point(p: Point) -> bool {\n    // We store only a \"sign\" of the y coordinate because the rest can be derived from the x coordinate. To get\n    // the sign we check if the y coordinate is less or equal than the curve's order minus 1 divided by 2.\n    // Ideally we'd do `y <= MOD_DIV_2`, but there's no `lte` function, so instead we do `!(y > MOD_DIV_2)`, which is\n    // equivalent, and then rewrite that as `!(MOD_DIV_2 < y)`, since we also have no `gt` function.\n    !BN254_FR_MODULUS_DIV_2.lt(p.y)\n}\n\n/// Returns a `Point` in the Grumpkin curve given its x coordinate.\n///\n/// Because not all values in the field are valid x coordinates of points in the curve (i.e. there\n/// is no corresponding y value in the field that satisfies the curve equation), it may not be\n/// possible to reconstruct a `Point`. `Option::none()` is returned in such cases.\npub fn point_from_x_coord(x: Field) -> Option<Point> {\n    // y ^ 2 = x ^ 3 - 17\n    let rhs = x * x * x - 17;\n    sqrt(rhs).map(|y| Point { x, y, is_infinite: false })\n}\n\n/// Returns a `Point` in the Grumpkin curve given its x coordinate and sign for the y coordinate.\n///\n/// Because not all values in the field are valid x coordinates of points in the curve (i.e. there\n/// is no corresponding y value in the field that satisfies the curve equation), it may not be\n/// possible to reconstruct a `Point`. `Option::none()` is returned in such cases.\n///\n/// @param x - The x coordinate of the point\n/// @param sign - The \"sign\" of the y coordinate - determines whether y <= (Fr.MODULUS - 1) / 2\npub fn point_from_x_coord_and_sign(x: Field, sign: bool) -> Option<Point> {\n    // y ^ 2 = x ^ 3 - 17\n    let rhs = x * x * x - 17;\n\n    sqrt(rhs).map(|y| {\n        // If there is a square root, we need to ensure it has the correct \"sign\"\n        let y_is_positive = !BN254_FR_MODULUS_DIV_2.lt(y);\n        let final_y = if y_is_positive == sign { y } else { -y };\n        Point { x, y: final_y, is_infinite: false }\n    })\n}\n\nmod test {\n    use crate::utils::point::{point_from_x_coord, point_from_x_coord_and_sign, point_to_bytes};\n    use dep::protocol_types::point::Point;\n    use dep::protocol_types::utils::field::pow;\n\n    #[test]\n    unconstrained fn test_point_to_bytes_positive_sign() {\n        let p = Point {\n            x: 0x1af41f5de96446dc3776a1eb2d98bb956b7acd9979a67854bec6fa7c2973bd73,\n            y: 0x07fc22c7f2c7057571f137fe46ea9c95114282bc95d37d71ec4bfb88de457d4a,\n            is_infinite: false,\n        };\n\n        let compressed_point = point_to_bytes(p);\n\n        let expected_compressed_point_positive_sign = [\n            154, 244, 31, 93, 233, 100, 70, 220, 55, 118, 161, 235, 45, 152, 187, 149, 107, 122,\n            205, 153, 121, 166, 120, 84, 190, 198, 250, 124, 41, 115, 189, 115,\n        ];\n        assert_eq(expected_compressed_point_positive_sign, compressed_point);\n    }\n\n    #[test]\n    unconstrained fn test_point_to_bytes_negative_sign() {\n        let p = Point {\n            x: 0x247371652e55dd74c9af8dbe9fb44931ba29a9229994384bd7077796c14ee2b5,\n            y: 0x26441aec112e1ae4cee374f42556932001507ad46e255ffb27369c7e3766e5c0,\n            is_infinite: false,\n        };\n\n        let compressed_point = point_to_bytes(p);\n\n        let expected_compressed_point_negative_sign = [\n            36, 115, 113, 101, 46, 85, 221, 116, 201, 175, 141, 190, 159, 180, 73, 49, 186, 41, 169,\n            34, 153, 148, 56, 75, 215, 7, 119, 150, 193, 78, 226, 181,\n        ];\n\n        assert_eq(expected_compressed_point_negative_sign, compressed_point);\n    }\n\n    #[test]\n    unconstrained fn test_point_from_x_coord_and_sign() {\n        // Test positive y coordinate\n        let x = 0x1af41f5de96446dc3776a1eb2d98bb956b7acd9979a67854bec6fa7c2973bd73;\n        let sign = true;\n        let p = point_from_x_coord_and_sign(x, sign).unwrap();\n\n        assert_eq(p.x, x);\n        assert_eq(p.y, 0x07fc22c7f2c7057571f137fe46ea9c95114282bc95d37d71ec4bfb88de457d4a);\n        assert_eq(p.is_infinite, false);\n\n        // Test negative y coordinate\n        let x2 = 0x247371652e55dd74c9af8dbe9fb44931ba29a9229994384bd7077796c14ee2b5;\n        let sign2 = false;\n        let p2 = point_from_x_coord_and_sign(x2, sign2).unwrap();\n\n        assert_eq(p2.x, x2);\n        assert_eq(p2.y, 0x26441aec112e1ae4cee374f42556932001507ad46e255ffb27369c7e3766e5c0);\n        assert_eq(p2.is_infinite, false);\n    }\n\n    #[test]\n    unconstrained fn test_point_from_x_coord_valid() {\n        // x = 8 is a known quadratic residue - should give a valid point\n        let result = point_from_x_coord(Field::from(8));\n        assert(result.is_some());\n\n        let point = result.unwrap();\n        assert_eq(point.x, Field::from(8));\n        // Check curve equation y^2 = x^3 - 17\n        assert_eq(pow(point.y, 2), pow(point.x, 3) - 17);\n    }\n\n    #[test]\n    unconstrained fn test_point_from_x_coord_invalid() {\n        // x = 3 is a non-residue for this curve - should give None\n        let x = Field::from(3);\n        let maybe_point = point_from_x_coord(x);\n        assert(maybe_point.is_none());\n    }\n\n}\n"
     },
-    "238": {
+    "239": {
       "path": "/home/aztec-dev/nargo/github.com/noir-lang/poseidon/v0.1.1/src/poseidon2.nr",
       "source": "use std::default::Default;\nuse std::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::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"
     },
@@ -887,39 +891,39 @@
       "path": "std/array/mod.nr",
       "source": "use crate::cmp::{Eq, Ord};\nuse crate::convert::From;\nuse crate::runtime::is_unconstrained;\n\nmod check_shuffle;\nmod quicksort;\n\nimpl<T, let N: u32> [T; N] {\n    /// Returns the length of this array.\n    ///\n    /// ```noir\n    /// fn len(self) -> Field\n    /// ```\n    ///\n    /// example\n    ///\n    /// ```noir\n    /// fn main() {\n    ///     let array = [42, 42];\n    ///     assert(array.len() == 2);\n    /// }\n    /// ```\n    #[builtin(array_len)]\n    pub fn len(self) -> u32 {}\n\n    /// Returns this array as a slice.\n    ///\n    /// ```noir\n    /// let array = [1, 2];\n    /// let slice = array.as_slice();\n    /// assert_eq(slice, &[1, 2]);\n    /// ```\n    #[builtin(as_slice)]\n    pub fn as_slice(self) -> [T] {}\n\n    /// Applies a function to each element of this array, returning a new array containing the mapped elements.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// let a = [1, 2, 3];\n    /// let b = a.map(|a| a * 2);\n    /// assert_eq(b, [2, 4, 6]);\n    /// ```\n    pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> [U; N] {\n        let uninitialized = crate::mem::zeroed();\n        let mut ret = [uninitialized; N];\n\n        for i in 0..self.len() {\n            ret[i] = f(self[i]);\n        }\n\n        ret\n    }\n\n    /// Applies a function to each element of this array along with its index,\n    /// returning a new array containing the mapped elements.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// let a = [1, 2, 3];\n    /// let b = a.mapi(|i, a| i + a * 2);\n    /// assert_eq(b, [2, 5, 8]);\n    /// ```\n    pub fn mapi<U, Env>(self, f: fn[Env](u32, T) -> U) -> [U; N] {\n        let uninitialized = crate::mem::zeroed();\n        let mut ret = [uninitialized; N];\n\n        for i in 0..self.len() {\n            ret[i] = f(i, self[i]);\n        }\n\n        ret\n    }\n\n    /// Applies a function to each element of this array.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// let a = [1, 2, 3];\n    /// let mut b = [0; 3];\n    /// let mut i = 0;\n    /// a.for_each(|x| {\n    ///     b[i] = x;\n    ///     i += 1;\n    /// });\n    /// assert_eq(a, b);\n    /// ```\n    pub fn for_each<Env>(self, f: fn[Env](T) -> ()) {\n        for i in 0..self.len() {\n            f(self[i]);\n        }\n    }\n\n    /// Applies a function to each element of this array along with its index.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// let a = [1, 2, 3];\n    /// let mut b = [0; 3];\n    /// a.for_eachi(|i, x| {\n    ///     b[i] = x;\n    /// });\n    /// assert_eq(a, b);\n    /// ```\n    pub fn for_eachi<Env>(self, f: fn[Env](u32, T) -> ()) {\n        for i in 0..self.len() {\n            f(i, self[i]);\n        }\n    }\n\n    /// Applies a function to each element of the array, returning the final accumulated value. The first\n    /// parameter is the initial value.\n    ///\n    /// This is a left fold, so the given function will be applied to the accumulator and first element of\n    /// the array, then the second, and so on. For a given call the expected result would be equivalent to:\n    ///\n    /// ```rust\n    /// let a1 = [1];\n    /// let a2 = [1, 2];\n    /// let a3 = [1, 2, 3];\n    ///\n    /// let f = |a, b| a - b;\n    /// a1.fold(10, f); //=> f(10, 1)\n    /// a2.fold(10, f); //=> f(f(10, 1), 2)\n    /// a3.fold(10, f); //=> f(f(f(10, 1), 2), 3)\n    ///\n    /// assert_eq(a3.fold(10, f), 10 - 1 - 2 - 3);\n    /// ```\n    pub fn fold<U, Env>(self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U {\n        for elem in self {\n            accumulator = f(accumulator, elem);\n        }\n        accumulator\n    }\n\n    /// Same as fold, but uses the first element as the starting element.\n    ///\n    /// Requires the input array to be non-empty.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn main() {\n    ///     let arr = [1, 2, 3, 4];\n    ///     let reduced = arr.reduce(|a, b| a + b);\n    ///     assert(reduced == 10);\n    /// }\n    /// ```\n    pub fn reduce<Env>(self, f: fn[Env](T, T) -> T) -> T {\n        let mut accumulator = self[0];\n        for i in 1..self.len() {\n            accumulator = f(accumulator, self[i]);\n        }\n        accumulator\n    }\n\n    /// Returns true if all the elements in this array satisfy the given predicate.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn main() {\n    ///     let arr = [2, 2, 2, 2, 2];\n    ///     let all = arr.all(|a| a == 2);\n    ///     assert(all);\n    /// }\n    /// ```\n    pub fn all<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n        let mut ret = true;\n        for elem in self {\n            ret &= predicate(elem);\n        }\n        ret\n    }\n\n    /// Returns true if any of the elements in this array satisfy the given predicate.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn main() {\n    ///     let arr = [2, 2, 2, 2, 5];\n    ///     let any = arr.any(|a| a == 5);\n    ///     assert(any);\n    /// }\n    /// ```\n    pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n        let mut ret = false;\n        for elem in self {\n            ret |= predicate(elem);\n        }\n        ret\n    }\n\n    /// Concatenates this array with another array.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn main() {\n    ///     let arr1 = [1, 2, 3, 4];\n    ///     let arr2 = [6, 7, 8, 9, 10, 11];\n    ///     let concatenated_arr = arr1.concat(arr2);\n    ///     assert(concatenated_arr == [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n    /// }\n    /// ```\n    pub fn concat<let M: u32>(self, array2: [T; M]) -> [T; N + M] {\n        let mut result = [crate::mem::zeroed(); N + M];\n        for i in 0..N {\n            result[i] = self[i];\n        }\n        for i in 0..M {\n            result[i + N] = array2[i];\n        }\n        result\n    }\n}\n\nimpl<T, let N: u32> [T; N]\nwhere\n    T: Ord + Eq,\n{\n    /// Returns a new sorted array. The original array remains untouched. Notice that this function will\n    /// only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting\n    /// logic it uses internally is optimized specifically for these values. If you need a sort function to\n    /// sort any type, you should use the `sort_via` function.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// fn main() {\n    ///     let arr = [42, 32];\n    ///     let sorted = arr.sort();\n    ///     assert(sorted == [32, 42]);\n    /// }\n    /// ```\n    pub fn sort(self) -> Self {\n        self.sort_via(|a, b| a <= b)\n    }\n}\n\nimpl<T, let N: u32> [T; N]\nwhere\n    T: Eq,\n{\n    /// Returns a new sorted array by sorting it with a custom comparison function.\n    /// The original array remains untouched.\n    /// The ordering function must return true if the first argument should be sorted to be before the second argument or is equal to the second argument.\n    ///\n    /// Using this method with an operator like `<` that does not return `true` for equal values will result in an assertion failure for arrays with equal elements.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// fn main() {\n    ///     let arr = [42, 32]\n    ///     let sorted_ascending = arr.sort_via(|a, b| a <= b);\n    ///     assert(sorted_ascending == [32, 42]); // verifies\n    ///\n    ///     let sorted_descending = arr.sort_via(|a, b| a >= b);\n    ///     assert(sorted_descending == [32, 42]); // does not verify\n    /// }\n    /// ```\n    pub fn sort_via<Env>(self, ordering: fn[Env](T, T) -> bool) -> Self {\n        // Safety: `sorted` array is checked to be:\n        // a. a permutation of `input`'s elements\n        // b. satisfying the predicate `ordering`\n        let sorted = unsafe { quicksort::quicksort(self, ordering) };\n\n        if !is_unconstrained() {\n            for i in 0..N - 1 {\n                assert(\n                    ordering(sorted[i], sorted[i + 1]),\n                    \"Array has not been sorted correctly according to `ordering`.\",\n                );\n            }\n            check_shuffle::check_shuffle(self, sorted);\n        }\n        sorted\n    }\n}\n\nimpl<let N: u32> [u8; N] {\n    /// Converts a byte array of type `[u8; N]` to a string. Note that this performs no UTF-8 validation -\n    /// the given array is interpreted as-is as a string.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// fn main() {\n    ///     let hi = [104, 105].as_str_unchecked();\n    ///     assert_eq(hi, \"hi\");\n    /// }\n    /// ```\n    #[builtin(array_as_str_unchecked)]\n    pub fn as_str_unchecked(self) -> str<N> {}\n}\n\nimpl<let N: u32> From<str<N>> for [u8; N] {\n    /// Returns an array of the string bytes.\n    fn from(s: str<N>) -> Self {\n        s.as_bytes()\n    }\n}\n\nmod test {\n    #[test]\n    fn map_empty() {\n        assert_eq([].map(|x| x + 1), []);\n    }\n\n    global arr_with_100_values: [u32; 100] = [\n        42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2, 54,\n        89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41, 19, 98,\n        53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21, 43, 86, 35,\n        21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15, 127, 81, 30, 8,\n        125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n    ];\n    global expected_with_100_values: [u32; 100] = [\n        0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30, 32,\n        32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58, 61, 62,\n        62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82, 84, 84, 86,\n        86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114, 114, 116, 118,\n        119, 120, 121, 123, 123, 123, 125, 126, 127,\n    ];\n    fn sort_u32(a: u32, b: u32) -> bool {\n        a <= b\n    }\n\n    #[test]\n    fn test_sort() {\n        let mut arr: [u32; 7] = [3, 6, 8, 10, 1, 2, 1];\n\n        let sorted = arr.sort();\n\n        let expected: [u32; 7] = [1, 1, 2, 3, 6, 8, 10];\n        assert(sorted == expected);\n    }\n\n    #[test]\n    fn test_sort_100_values() {\n        let mut arr: [u32; 100] = [\n            42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2,\n            54, 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41,\n            19, 98, 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21,\n            43, 86, 35, 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15,\n            127, 81, 30, 8, 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n        ];\n\n        let sorted = arr.sort();\n\n        let expected: [u32; 100] = [\n            0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30,\n            32, 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58,\n            61, 62, 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82,\n            84, 84, 86, 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114,\n            114, 116, 118, 119, 120, 121, 123, 123, 123, 125, 126, 127,\n        ];\n        assert(sorted == expected);\n    }\n\n    #[test]\n    fn test_sort_100_values_comptime() {\n        let sorted = arr_with_100_values.sort();\n        assert(sorted == expected_with_100_values);\n    }\n\n    #[test]\n    fn test_sort_via() {\n        let mut arr: [u32; 7] = [3, 6, 8, 10, 1, 2, 1];\n\n        let sorted = arr.sort_via(sort_u32);\n\n        let expected: [u32; 7] = [1, 1, 2, 3, 6, 8, 10];\n        assert(sorted == expected);\n    }\n\n    #[test]\n    fn test_sort_via_100_values() {\n        let mut arr: [u32; 100] = [\n            42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2,\n            54, 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41,\n            19, 98, 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21,\n            43, 86, 35, 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15,\n            127, 81, 30, 8, 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n        ];\n\n        let sorted = arr.sort_via(sort_u32);\n\n        let expected: [u32; 100] = [\n            0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30,\n            32, 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58,\n            61, 62, 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82,\n            84, 84, 86, 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114,\n            114, 116, 118, 119, 120, 121, 123, 123, 123, 125, 126, 127,\n        ];\n        assert(sorted == expected);\n    }\n\n    #[test]\n    fn mapi_empty() {\n        assert_eq([].mapi(|i, x| i * x + 1), []);\n    }\n\n    #[test]\n    fn for_each_empty() {\n        let empty_array: [Field; 0] = [];\n        empty_array.for_each(|_x| assert(false));\n    }\n\n    #[test]\n    fn for_eachi_empty() {\n        let empty_array: [Field; 0] = [];\n        empty_array.for_eachi(|_i, _x| assert(false));\n    }\n\n    #[test]\n    fn map_example() {\n        let a = [1, 2, 3];\n        let b = a.map(|a| a * 2);\n        assert_eq(b, [2, 4, 6]);\n    }\n\n    #[test]\n    fn mapi_example() {\n        let a = [1, 2, 3];\n        let b = a.mapi(|i, a| i + a * 2);\n        assert_eq(b, [2, 5, 8]);\n    }\n\n    #[test]\n    fn for_each_example() {\n        let a = [1, 2, 3];\n        let mut b = [0, 0, 0];\n        let b_ref = &mut b;\n        let mut i = 0;\n        let i_ref = &mut i;\n        a.for_each(|x| {\n            b_ref[*i_ref] = x * 2;\n            *i_ref += 1;\n        });\n        assert_eq(b, [2, 4, 6]);\n        assert_eq(i, 3);\n    }\n\n    #[test]\n    fn for_eachi_example() {\n        let a = [1, 2, 3];\n        let mut b = [0, 0, 0];\n        let b_ref = &mut b;\n        a.for_eachi(|i, a| { b_ref[i] = i + a * 2; });\n        assert_eq(b, [2, 5, 8]);\n    }\n\n    #[test]\n    fn concat() {\n        let arr1 = [1, 2, 3, 4];\n        let arr2 = [6, 7, 8, 9, 10, 11];\n        let concatenated_arr = arr1.concat(arr2);\n        assert_eq(concatenated_arr, [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n    }\n\n    #[test]\n    fn concat_zero_length_with_something() {\n        let arr1 = [];\n        let arr2 = [1];\n        let concatenated_arr = arr1.concat(arr2);\n        assert_eq(concatenated_arr, [1]);\n    }\n\n    #[test]\n    fn concat_something_with_zero_length() {\n        let arr1 = [1];\n        let arr2 = [];\n        let concatenated_arr = arr1.concat(arr2);\n        assert_eq(concatenated_arr, [1]);\n    }\n\n    #[test]\n    fn concat_zero_lengths() {\n        let arr1: [Field; 0] = [];\n        let arr2: [Field; 0] = [];\n        let concatenated_arr = arr1.concat(arr2);\n        assert_eq(concatenated_arr, []);\n    }\n}\n"
     },
-    "312": {
+    "313": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr",
       "source": "// TODO: Expose other wrapped functions than debug (info, warn)\n// ['silent', 'fatal', 'error', 'warn', 'info', 'verbose', 'debug', 'trace']\n\npub global SILENT_LOG_LEVEL: u8 = 0;\npub global FATAL_LOG_LEVEL: u8 = 1;\npub global ERROR_LOG_LEVEL: u8 = 2;\npub global WARN_LOG_LEVEL: u8 = 3;\npub global INFO_LOG_LEVEL: u8 = 4;\npub global VERBOSE_LOG_LEVEL: u8 = 5;\npub global DEBUG_LOG_LEVEL: u8 = 6;\npub global TRACE_LOG_LEVEL: u8 = 7;\n\n/// 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/// Same as debug_log, but allows to customize the log level.\n/// Consider changing just to 'log'\npub fn debug_log_with_level<let N: u32>(log_level: u8, msg: str<N>) {\n    debug_log_format_with_level(log_level, 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    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call.\n    unsafe { debug_log_array_oracle_wrapper(DEBUG_LOG_LEVEL, msg, args) };\n}\n\n/// Same as debug_log_format, but allows to customize the log level.\n/// Consider changing just to 'log_format'\npub fn debug_log_format_with_level<let M: u32, let N: u32>(\n    log_level: u8,\n    msg: str<M>,\n    args: [Field; N],\n) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call.\n    unsafe { debug_log_array_oracle_wrapper(log_level, msg, args) };\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` slice.\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 slice: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format_slice<let M: u32>(log_level: u8, msg: str<M>, args: [Field]) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call.\n    unsafe { debug_log_slice_oracle_wrapper(log_level, msg, args) };\n}\n\n// We provide two versions of the debug log oracle: one that takes args as a slice and another one that takes args as an array.\n// We do this since conversion from array to slice generates overhead in public functions, since opcodes need to be emitted for the conversion.\n// By exposing the two flavors, we avoid conversions since the AVM is able to handle both arrays an slices in this oracle.\n\nunconstrained fn debug_log_slice_oracle_wrapper<let M: u32>(\n    log_level: u8,\n    msg: str<M>,\n    args: [Field],\n) {\n    debug_log_slice_oracle(log_level, msg, args);\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(utilityDebugLog)]\nunconstrained fn debug_log_slice_oracle<let M: u32>(log_level: u8, msg: str<M>, args: [Field]) {}\n\nunconstrained fn debug_log_array_oracle_wrapper<let M: u32, let N: u32>(\n    log_level: u8,\n    msg: str<M>,\n    args: [Field; N],\n) {\n    debug_log_array_oracle(log_level, msg, N, args);\n}\n\n#[oracle(utilityDebugLog)]\nunconstrained fn debug_log_array_oracle<let M: u32, let N: u32>(\n    log_level: u8,\n    msg: str<M>,\n    length: u32,\n    args: [Field; N],\n) {}\n"
     },
-    "322": {
+    "323": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
       "source": "mod poseidon2_chunks;\n\nuse crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        transaction::tx_request::TxRequest,\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE,\n        GENERATOR_INDEX__OUTER_NULLIFIER, GENERATOR_INDEX__SILOED_NOTE_HASH,\n        GENERATOR_INDEX__UNIQUE_NOTE_HASH, NULL_MSG_SENDER_CONTRACT_ADDRESS, TWO_POW_64,\n    },\n    merkle_tree::root_from_sibling_path,\n    messaging::l2_to_l1_message::L2ToL1Message,\n    poseidon2::Poseidon2Sponge,\n    side_effect::{Counted, Scoped},\n    traits::{FromField, Hash, ToField},\n    utils::field::{field_from_bytes, field_from_bytes_32_trunc},\n};\n\npub use poseidon2_chunks::poseidon2_absorb_in_chunks_existing_sponge;\nuse poseidon2_chunks::poseidon2_absorb_in_chunks;\nuse std::embedded_curve_ops::EmbeddedCurveScalar;\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = sha256::digest(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\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n    // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n    // unique).\n    poseidon2_hash_with_separator(\n        [first_nullifier_in_tx, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(note_nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [note_nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_nonce_and_unique_note_hash(\n    siloed_note_hash: Field,\n    first_nullifier: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    let note_nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n    compute_unique_note_hash(note_nonce, siloed_note_hash)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n    siloed_note_hash: Field,\n    first_nullifier: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    if siloed_note_hash == 0 {\n        0\n    } else {\n        compute_nonce_and_unique_note_hash(siloed_note_hash, first_nullifier, note_index_in_tx)\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: Scoped<Counted<NoteHash>>) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_note_hash(note_hash.contract_address, note_hash.innermost())\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: Scoped<Counted<Nullifier>>) -> Field {\n    let value = nullifier.innermost().value;\n    // Q: shouldn't we be checking whether the _whole_ nullifier is empty?\n    // A: We don't have to. The init and inner circuits add contract address to non-empty nullifiers.\n    // So we know we should silo it if the contract address is not empty.\n    if nullifier.contract_address.is_zero() {\n        value // Return `value` instead of 0 because an already-siloed nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, value)\n    }\n}\n\npub fn create_protocol_nullifier(tx_request: TxRequest) -> Scoped<Counted<Nullifier>> {\n    Nullifier { value: tx_request.hash(), note_hash: 0 }.count(1).scope(\n        NULL_MSG_SENDER_CONTRACT_ADDRESS,\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<Counted<PrivateLogData>>) -> PrivateLog {\n    let log = private_log.innermost().log;\n    if private_log.contract_address.is_zero() {\n        log\n    } else {\n        let mut fields = log.fields;\n        fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n        PrivateLog::new(fields, log.length)\n    }\n}\n\npub fn compute_contract_class_log_hash(log: [Field; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS]) -> Field {\n    poseidon2_hash(log)\n}\n\npub fn compute_app_secret_key(\n    master_secret_key: EmbeddedCurveScalar,\n    app_address: AztecAddress,\n    app_secret_generator: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [master_secret_key.hi, master_secret_key.lo, app_address.to_field()],\n        app_secret_generator,\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 contract_address_bytes: [u8; 32] = contract_address.to_field().to_be_bytes();\n    let recipient_bytes: [u8; 20] = recipient.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let rollup_version_id_bytes: [u8; 32] = rollup_version_id.to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n\n    let mut bytes: [u8; 148] = std::mem::zeroed();\n    for i in 0..32 {\n        bytes[i] = contract_address_bytes[i];\n        bytes[i + 32] = rollup_version_id_bytes[i];\n        // 64 - 84 are for recipient.\n        bytes[i + 84] = chain_id_bytes[i];\n        bytes[i + 116] = content_bytes[i];\n    }\n\n    for i in 0..20 {\n        bytes[64 + i] = recipient_bytes[i];\n    }\n\n    sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n    msg: Scoped<L2ToL1Message>,\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.inner.recipient,\n            msg.inner.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n/// Computes sha256 hash of 2 input fields.\n///\n/// @returns A truncated field (i.e., the first byte is always 0).\npub fn accumulate_sha256(v0: Field, v1: Field) -> Field {\n    // Concatenate two fields into 32 x 2 = 64 bytes\n    let v0_as_bytes: [u8; 32] = v0.to_be_bytes();\n    let v1_as_bytes: [u8; 32] = v1.to_be_bytes();\n    let hash_input_flattened = v0_as_bytes.concat(v1_as_bytes);\n\n    sha256_to_field(hash_input_flattened)\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    poseidon::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = [separator.to_field()].concat(inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n/// Computes a Poseidon2 hash over a dynamic-length subarray of the given input.\n/// Only the first `in_len` fields of `input` are absorbed; any remaining fields are ignored.\n/// The caller is responsible for ensuring that the input is padded with zeros if required.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_in_chunks(input, in_len);\n    sponge.squeeze()\n}\n\n// NB the below is the same as poseidon::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_in_chunks(input, in_len);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\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 iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::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// This function is  unconstrained because it is intended to be used in unconstrained context only as\n// in constrained contexts it would be too inefficient.\npub unconstrained fn poseidon2_hash_with_separator_bounded_vec<let N: u32, T>(\n    inputs: BoundedVec<Field, N>,\n    separator: T,\n) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs.get(i));\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n    let fixed_len_hash = poseidon::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n    let variable_len_hash = poseidon::poseidon2::Poseidon2::hash(input, in_len);\n    assert(variable_chunk_hash == variable_len_hash);\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 = sha256::digest(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 == 0x3b18c58c739716e76429634a61375c45b3b5cd470c22ab6d3e14cee23dd992);\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 == 0xaab2a5828156782b12a1dc6f336e2bc627eb1b9514b02d511f66296990c050);\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        L2ToL1Message { recipient: EthAddress::from_field(1), content: 2 }.scope(\n            AztecAddress::from_field(3),\n        ),\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `yarn-project/stdlib/src/hash/hash.test.ts`\n    let hash_from_typescript = 0x0081edf209e087ad31b3fd24263698723d57190bd1d6e9fe056fc0c0a68ee661;\n\n    assert_eq(hash, hash_from_typescript);\n}\n\n#[test]\nunconstrained fn poseidon2_hash_with_separator_bounded_vec_matches_non_bounded_vec_version() {\n    let inputs = BoundedVec::<Field, 4>::from_array([1, 2, 3]);\n    let separator = 42;\n\n    // Hash using bounded vec version\n    let bounded_result = poseidon2_hash_with_separator_bounded_vec(inputs, separator);\n\n    // Hash using regular version\n    let regular_result = poseidon2_hash_with_separator([1, 2, 3], separator);\n\n    // Results should match\n    assert_eq(bounded_result, regular_result);\n}\n"
     },
-    "335": {
+    "336": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/meta/mod.nr",
       "source": "use utils::derive_serialization_quotes;\n\npub mod utils;\n\n/// Generates the generic parameter declarations for a struct's trait implementation.\n///\n/// This function takes a struct type definition and generates the generic parameter declarations\n/// that go after the `impl` keyword. For example, given a struct with generics `N: u32` and `T`,\n/// it generates `<let N: u32, T>`.\n///\n/// # Parameters\n/// - `s`: The struct type definition to generate generic declarations for\n///\n/// # Returns\n/// A quoted code block containing the generic parameter declarations, or an empty quote if the struct\n/// has no generic parameters\n///\n/// # Example\n/// For a struct defined as:\n/// ```\n/// struct Container<T, let N: u32> {\n///     items: [T; N],\n///     count: u32\n/// }\n/// ```\n///\n/// This function generates:\n/// ```\n/// <let N: u32, T>\n/// ```\ncomptime fn get_generics_declarations(s: TypeDefinition) -> Quoted {\n    let generics = s.generics();\n\n    if generics.len() > 0 {\n        let generics_declarations_items = generics\n            .map(|(name, maybe_integer_typ)| {\n                // The second item in the generics tuple is an Option of an integer type that is Some only if\n                // the generic is numeric.\n                if maybe_integer_typ.is_some() {\n                    // The generic is numeric, so we return a quote defined as e.g. \"let N: u32\"\n                    let integer_type = maybe_integer_typ.unwrap();\n                    quote {let $name: $integer_type}\n                } else {\n                    // The generic is not numeric, so we return a quote containing the name of the generic (e.g. \"T\")\n                    quote {$name}\n                }\n            })\n            .join(quote {,});\n        quote {<$generics_declarations_items>}\n    } else {\n        // The struct doesn't have any generics defined, so we just return an empty quote.\n        quote {}\n    }\n}\n\n/// Generates the `where` clause for a trait implementation that constrains non-numeric generic type parameters.\n///\n/// This function takes a struct type definition and a trait name, and generates a `where` clause that\n/// requires all non-numeric generic type parameters to implement the specified trait.\n///\n/// # Parameters\n/// - `s`: The struct type definition to generate the where clause for\n/// - `trait_name`: The name of the trait that non-numeric generic parameters must implement\n///\n/// # Returns\n/// A quoted code block containing the where clause, or an empty quote if the struct has no non-numeric\n/// generic parameters\n///\n/// # Example\n/// For a struct defined as:\n/// ```\n/// struct Container<T, let N: u32> {\n///     items: [T; N],\n///     count: u32\n/// }\n/// ```\n///\n/// And trait name \"Serialize\", this function generates:\n/// ```\n/// where T: Serialize\n/// ```\ncomptime fn get_where_trait_clause(s: TypeDefinition, trait_name: Quoted) -> Quoted {\n    let generics = s.generics();\n\n    // The second item in the generics tuple is an Option of an integer type that is Some only if the generic is\n    // numeric.\n    let non_numeric_generics =\n        generics.filter(|(_, maybe_integer_typ)| maybe_integer_typ.is_none());\n\n    if non_numeric_generics.len() > 0 {\n        let non_numeric_generics_declarations =\n            non_numeric_generics.map(|(name, _)| quote {$name: $trait_name}).join(quote {,});\n        quote {where $non_numeric_generics_declarations}\n    } else {\n        // There are no non-numeric generics, so we return an empty quote.\n        quote {}\n    }\n}\n\n/// Generates a `Serialize` trait implementation for a struct type.\n///\n/// # Parameters\n/// - `s`: The struct type definition to generate the implementation for\n///\n/// # Returns\n/// A quoted code block containing the trait implementation\n///\n/// # Example\n/// For a struct defined as:\n/// ```\n/// struct Log<N> {\n///     fields: [Field; N],\n///     length: u32\n/// }\n/// ```\n///\n/// This function generates code equivalent to:\n/// ```\n/// impl<let N: u32> Serialize for Log<N> {\n///     let N: u32 = <[Field; N] as Serialize>::N + <u32 as Serialize>::N;\n///\n///     #[inline_always]\n///     fn serialize(self) -> [Field; Self::N] {\n///         let mut serialized_params = [0; _];\n///         let mut offset = 0;\n///\n///         let serialized_member = Serialize::serialize(self.fields);\n///         let serialized_member_len = <[Field; N] as Serialize>::N;\n///         for i in 0..serialized_member_len {\n///             serialized_params[i + offset] = serialized_member[i];\n///         }\n///         offset += serialized_member_len;\n///\n///         let serialized_member = Serialize::serialize(self.length);\n///         let serialized_member_len = <u32 as Serialize>::N;\n///         for i in 0..serialized_member_len {\n///             serialized_params[i + offset] = serialized_member[i];\n///         }\n///         offset += serialized_member_len;\n///\n///         serialized_params\n///     }\n/// }\n/// ```\npub comptime fn derive_serialize(s: TypeDefinition) -> Quoted {\n    let typ = s.as_type();\n    let nested_struct = typ.as_data_type().unwrap();\n\n    // We care only about the name and type so we drop the last item of the tuple\n    let params = nested_struct.0.fields(nested_struct.1).map(|(name, typ, _)| (name, typ));\n\n    // Generates the generic parameter declarations (to be placed after the `impl` keyword) and the `where` clause\n    // for the `Serialize` trait.\n    let generics_declarations = get_generics_declarations(s);\n    let where_serialize_clause = get_where_trait_clause(s, quote {Serialize});\n\n    let (function_body, params_len_quote, serialized_params_name) =\n        derive_serialization_quotes(params, true);\n\n    quote {\n        impl$generics_declarations $crate::traits::Serialize for $typ\n            $where_serialize_clause\n        {\n            let N: u32 = $params_len_quote;\n\n            #[inline_always]\n            fn serialize(self) -> [Field; Self::N] {\n                $function_body\n\n                $serialized_params_name\n            }\n        }\n    }\n}\n\n/// Generates a `Deserialize` trait implementation for a given struct `s`.\n///\n/// # Arguments\n/// * `s` - The struct type definition to generate the implementation for\n///\n/// # Returns\n/// A `Quoted` block containing the generated trait implementation\n///\n/// # Requirements\n/// Each struct member type must implement the `Deserialize` trait (it gets used in the generated code).\n///\n/// # Example\n/// For a struct like:\n/// ```\n/// struct MyStruct {\n///     x: AztecAddress,\n///     y: Field,\n/// }\n/// ```\n///\n/// This generates:\n/// ```\n/// impl Deserialize for MyStruct {\n///     let N: u32 = <AztecAddress as Deserialize>::N + <Field as Deserialize>::N;\n///\n///     fn deserialize(serialized: [Field; Self::N]) -> Self {\n///         let mut offset = 0;\n///         let mut member_fields = [0; <AztecAddress as Deserialize>::N];\n///         for i in 0..<AztecAddress as Deserialize>::N {\n///             member_fields[i] = serialized[i + offset];\n///         }\n///         let x = <AztecAddress as Deserialize>::deserialize(member_fields);\n///         offset += <AztecAddress as Deserialize>::N;\n///\n///         let mut member_fields = [0; <Field as Deserialize>::N];\n///         for i in 0..<Field as Deserialize>::N {\n///             member_fields[i] = serialized[i + offset];\n///         }\n///         let y = <Field as Deserialize>::deserialize(member_fields);\n///         offset += <Field as Deserialize>::N;\n///\n///         Self { x, y }\n///     }\n/// }\n/// ```\npub(crate) comptime fn derive_deserialize(s: TypeDefinition) -> Quoted {\n    let typ = s.as_type();\n    let nested_struct = typ.as_data_type().unwrap();\n    let params = nested_struct.0.fields(nested_struct.1);\n\n    // Generates the generic parameter declarations (to be placed after the `impl` keyword) and the `where` clause\n    // for the `Deserialize` trait.\n    let generics_declarations = get_generics_declarations(s);\n    let where_deserialize_clause = get_where_trait_clause(s, quote {Deserialize});\n\n    // The following will give us <type_of_struct_member_1 as Deserialize>::N + <type_of_struct_member_2 as Deserialize>::N + ...\n    let right_hand_side_of_definition_of_n = params\n        .map(|(_, param_type, _): (Quoted, Type, Quoted)| {\n            quote {\n            <$param_type as $crate::traits::Deserialize>::N\n        }\n        })\n        .join(quote {+});\n\n    // For structs containing a single member, we can enhance performance by directly deserializing the input array,\n    // bypassing the need for loop-based array construction. While this optimization yields significant benefits in\n    // Brillig where the loops are expected to not be optimized, it is not relevant in ACIR where the loops are\n    // expected to be optimized away.\n    let function_body = if params.len() > 1 {\n        // This generates deserialization code for each struct member and concatenates them together.\n        let deserialization_of_struct_members = params\n            .map(|(param_name, param_type, _): (Quoted, Type, Quoted)| {\n                quote {\n                    let mut member_fields = [0; <$param_type as Deserialize>::N];\n                    for i in 0..<$param_type as Deserialize>::N {\n                        member_fields[i] = serialized[i + offset];\n                    }\n                    let $param_name = <$param_type as Deserialize>::deserialize(member_fields);\n                    offset += <$param_type as Deserialize>::N;\n                }\n            })\n            .join(quote {});\n\n        // We join the struct member names with a comma to be used in the `Self { ... }` syntax\n        // This will give us e.g. `a, b, c` for a struct with three fields named `a`, `b`, and `c`.\n        let struct_members = params\n            .map(|(param_name, _, _): (Quoted, Type, Quoted)| quote { $param_name })\n            .join(quote {,});\n\n        quote {\n            let mut offset = 0;\n\n            $deserialization_of_struct_members\n\n            Self { $struct_members }\n        }\n    } else {\n        let param_name = params[0].0;\n        quote {\n            Self { $param_name: $crate::traits::Deserialize::deserialize(serialized) }\n        }\n    };\n\n    quote {\n        impl$generics_declarations $crate::traits::Deserialize for $typ\n            $where_deserialize_clause\n        {\n            let N: u32 = $right_hand_side_of_definition_of_n;\n\n            #[inline_always]\n            fn deserialize(serialized: [Field; Self::N]) -> Self {\n                $function_body\n            }\n        }\n    }\n}\n\n/// Generates a `Packable` trait implementation for a given struct `s`.\n///\n/// # Arguments\n/// * `s` - The struct type definition to generate the implementation for\n///\n/// # Returns\n/// A `Quoted` block containing the generated trait implementation\n///\n/// # Requirements\n/// Each struct member type must implement the `Packable` trait (it gets used in the generated code).\n///\n/// # Example\n/// For a struct like:\n/// ```\n/// struct MyStruct {\n///     x: AztecAddress,\n///     y: Field,\n/// }\n/// ```\n///\n/// This generates:\n/// ```\n/// impl Packable for MyStruct {\n///     let N: u32 = 2;\n///\n///     fn pack(self) -> [Field; 2] {\n///         let mut result: [Field; 2] = [0_Field; 2];\n///         let mut offset: u32 = 0_u32;\n///         let packed_member: [Field; 1] = self.x.pack();\n///         let packed_member_len: u32 = <Field as Packable>::N;\n///         for i in 0_u32..packed_member_len {\n///             {\n///                 result[i + offset] = packed_member[i];\n///             }\n///         }\n///         offset = offset + packed_member_len;\n///         let packed_member: [Field; 1] = self.y.pack();\n///         let packed_member_len: u32 = <Field as Packable>::N;\n///         for i in 0_u32..packed_member_len {\n///             {\n///                 result[i + offset] = packed_member[i];\n///             }\n///         }\n///         offset = offset + packed_member_len;\n///         result\n///     }\n///\n///     fn unpack(packed: [Field; 2]) -> Self {\n///         let mut offset: u32 = 0_u32;\n///         let mut member_fields: [Field; 1] = [0_Field; 1];\n///         for i in 0_u32..<AztecAddress as Packable>::N {\n///             member_fields[i] = packed[i + offset];\n///         }\n///         let x: AztecAddress = <AztecAddress as Packable>::unpack(member_fields);\n///         offset = offset + <AztecAddress as Packable>::N;\n///         let mut member_fields: [Field; 1] = [0_Field; 1];\n///         for i in 0_u32..<Field as Packable>::N {\n///             member_fields[i] = packed[i + offset];\n///         }\n///         let y: Field = <Field as Packable>::unpack(member_fields);\n///         offset = offset + <Field as Packable>::N;\n///         Self { x: x, y: y }\n///     }\n/// }\n/// ```\npub comptime fn derive_packable(s: TypeDefinition) -> Quoted {\n    let typ = s.as_type();\n    let nested_struct = typ.as_data_type().unwrap();\n    let params = nested_struct.0.fields(nested_struct.1);\n\n    // Generates the generic parameter declarations (to be placed after the `impl` keyword) and the `where` clause\n    // for the `Packable` trait.\n    let generics_declarations = get_generics_declarations(s);\n    let where_packable_clause = get_where_trait_clause(s, quote {Packable});\n\n    // The following will give us <type_of_struct_member_1 as Packable>::N + <type_of_struct_member_2 as Packable>::N + ...\n    let right_hand_side_of_definition_of_n = params\n        .map(|(_, param_type, _): (Quoted, Type, Quoted)| {\n            quote {\n            <$param_type as $crate::traits::Packable>::N\n        }\n        })\n        .join(quote {+});\n\n    // For structs containing a single member, we can enhance performance by directly returning the packed member,\n    // bypassing the need for loop-based array construction. While this optimization yields significant benefits in\n    // Brillig where the loops are expected to not be optimized, it is not relevant in ACIR where the loops are\n    // expected to be optimized away.\n    let pack_function_body = if params.len() > 1 {\n        // For multiple struct members, generate packing code that:\n        // 1. Packs each member\n        // 2. Copies the packed fields into the result array at the correct offset\n        // 3. Updates the offset for the next member\n        let packing_of_struct_members = params\n            .map(|(param_name, param_type, _): (Quoted, Type, Quoted)| {\n                quote {\n                    let packed_member = $crate::traits::Packable::pack(self.$param_name);\n                    let packed_member_len = <$param_type as $crate::traits::Packable>::N;\n                    for i in 0..packed_member_len {\n                        result[i + offset] = packed_member[i];\n                    }\n                    offset += packed_member_len;\n                }\n            })\n            .join(quote {});\n\n        quote {\n            let mut result = [0; Self::N];\n            let mut offset = 0;\n\n            $packing_of_struct_members\n\n            result\n        }\n    } else {\n        let param_name = params[0].0;\n        quote {\n            $crate::traits::Packable::pack(self.$param_name)\n        }\n    };\n\n    // For structs containing a single member, we can enhance performance by directly unpacking the input array,\n    // bypassing the need for loop-based array construction. While this optimization yields significant benefits in\n    // Brillig where the loops are expected to not be optimized, it is not relevant in ACIR where the loops are\n    // expected to be optimized away.\n    let unpack_function_body = if params.len() > 1 {\n        // For multiple struct members, generate unpacking code that:\n        // 1. Unpacks each member\n        // 2. Copies packed fields into member array at correct offset\n        // 3. Updates offset for next member\n        let unpacking_of_struct_members = params\n            .map(|(param_name, param_type, _): (Quoted, Type, Quoted)| {\n                quote {\n                    let mut member_fields = [0; <$param_type as $crate::traits::Packable>::N];\n                    for i in 0..<$param_type as $crate::traits::Packable>::N {\n                        member_fields[i] = packed[i + offset];\n                    }\n                    let $param_name = <$param_type as $crate::traits::Packable>::unpack(member_fields);\n                    offset += <$param_type as $crate::traits::Packable>::N;\n                }\n            })\n            .join(quote {});\n\n        // We join the struct member names with a comma to be used in the `Self { ... }` syntax\n        let struct_members = params\n            .map(|(param_name, _, _): (Quoted, Type, Quoted)| quote { $param_name })\n            .join(quote {,});\n\n        quote {\n            let mut offset = 0;\n            $unpacking_of_struct_members\n            Self { $struct_members }\n        }\n    } else {\n        let param_name = params[0].0;\n        quote {\n            Self { $param_name: $crate::traits::Packable::unpack(packed) }\n        }\n    };\n\n    quote {\n        impl$generics_declarations $crate::traits::Packable for $typ\n            $where_packable_clause\n        {\n            let N: u32 = $right_hand_side_of_definition_of_n;\n\n            #[inline_always]\n            fn pack(self) -> [Field; Self::N] {\n                $pack_function_body\n            }\n\n            #[inline_always]\n            fn unpack(packed: [Field; Self::N]) -> Self {\n                $unpack_function_body\n            }\n        }\n    }\n}\n\nmod test {\n    use crate::traits::{Deserialize, Packable, Serialize};\n\n    #[derive(Deserialize, Eq, Packable, Serialize)]\n    pub struct Smol {\n        a: Field,\n        b: Field,\n    }\n\n    #[derive(Deserialize, Eq, Serialize)]\n    pub struct HasArray {\n        a: [Field; 2],\n        b: bool,\n    }\n\n    #[derive(Deserialize, Eq, Serialize)]\n    pub struct Fancier {\n        a: Smol,\n        b: [Field; 2],\n        c: [u8; 3],\n        d: str<16>,\n    }\n\n    #[derive(Deserialize, Eq, Packable, Serialize)]\n    pub struct HasArrayWithGenerics<T, let N: u32> {\n        pub fields: [T; N],\n        pub length: u32,\n    }\n\n    #[test]\n    fn serde_on_smol() {\n        let smol = Smol { a: 1, b: 2 };\n        let serialized = smol.serialize();\n        assert(serialized == [1, 2], serialized);\n        let deserialized = Smol::deserialize(serialized);\n        assert(deserialized == smol);\n\n        // None of the struct members implements the `Packable` trait so the packed and serialized data should be the same\n        let packed = smol.pack();\n        assert_eq(packed, serialized, \"Packed does not match serialized\");\n    }\n\n    #[test]\n    fn serde_on_has_array() {\n        let has_array = HasArray { a: [1, 2], b: true };\n        let serialized = has_array.serialize();\n        assert(serialized == [1, 2, 1], serialized);\n        let deserialized = HasArray::deserialize(serialized);\n        assert(deserialized == has_array);\n    }\n\n    #[test]\n    fn serde_on_fancier() {\n        let fancier =\n            Fancier { a: Smol { a: 1, b: 2 }, b: [0, 1], c: [1, 2, 3], d: \"metaprogramming!\" };\n        let serialized = fancier.serialize();\n        assert(\n            serialized\n                == [\n                    1, 2, 0, 1, 1, 2, 3, 0x6d, 0x65, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x61,\n                    0x6d, 0x6d, 0x69, 0x6e, 0x67, 0x21,\n                ],\n            serialized,\n        );\n        let deserialized = Fancier::deserialize(serialized);\n        assert(deserialized == fancier);\n    }\n\n    #[test]\n    fn serde_on_contains_array_with_generics() {\n        let struct_with_array_of_generics = HasArrayWithGenerics { fields: [1, 2, 3], length: 3 };\n        let serialized = struct_with_array_of_generics.serialize();\n        assert(serialized == [1, 2, 3, 3], serialized);\n        let deserialized = HasArrayWithGenerics::deserialize(serialized);\n        assert(deserialized == struct_with_array_of_generics);\n    }\n\n    #[test]\n    fn packable_on_contains_array_with_generics() {\n        let struct_with_array_of_generics = HasArrayWithGenerics { fields: [1, 2, 3], length: 3 };\n        let packed = struct_with_array_of_generics.pack();\n        assert(packed == [1, 2, 3, 3], packed);\n\n        let unpacked = HasArrayWithGenerics::unpack(packed);\n        assert(unpacked == struct_with_array_of_generics);\n    }\n\n}\n"
     },
-    "336": {
+    "337": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/meta/utils.nr",
       "source": "/// Generates serialization code for a list of parameters and the total length of the serialized array\n///\n/// # Parameters\n/// - `params`: A list of (name, type) tuples to serialize\n/// - `use_self_prefix`: If true, parameters are accessed as `self.$param_name` (for struct members).\n///                      If false, parameters are accessed directly as `$param_name` (for function parameters).\n///\n/// # Returns\n/// A tuple containing:\n/// - Quoted code that serializes the parameters into an array named `serialized_params`\n/// - Quoted code that evaluates to the total length of the serialized array\n/// - Quoted code containing the name of the serialized array\npub comptime fn derive_serialization_quotes(\n    params: [(Quoted, Type)],\n    use_self_prefix: bool,\n) -> (Quoted, Quoted, Quoted) {\n    let prefix_quote = if use_self_prefix {\n        quote { self. }\n    } else {\n        quote {}\n    };\n\n    let params_len_quote = get_params_len_quote(params);\n    let serialized_params_name = quote { serialized_params };\n\n    let body = if params.len() == 0 {\n        quote {\n            let $serialized_params_name: [Field; 0] = [];\n        }\n    } else if params.len() == 1 {\n        // When we have only a single parameter on the input, we can enhance performance by directly returning\n        // the serialized member, bypassing the need for loop-based array construction. While this optimization yields\n        // significant benefits in Brillig where the loops are expected to not be optimized, it is not relevant in ACIR\n        // where the loops are expected to be optimized away.\n\n        let param_name = params[0].0;\n        quote {\n            let $serialized_params_name = $crate::traits::Serialize::serialize($prefix_quote$param_name);\n        }\n    } else {\n        // For multiple struct members, generate serialization code that:\n        // 1. Serializes each member\n        // 2. Copies the serialized fields into the serialize array at the correct offset\n        // 3. Updates the offset for the next member\n        let serialization_of_struct_members = params\n            .map(|(param_name, param_type): (Quoted, Type)| {\n                quote {\n                let serialized_member = $crate::traits::Serialize::serialize($prefix_quote$param_name);\n                let serialized_member_len = <$param_type as $crate::traits::Serialize>::N;\n                for i in 0..serialized_member_len {\n                    $serialized_params_name[i + offset] = serialized_member[i];\n                }\n                offset += serialized_member_len;\n            }\n            })\n            .join(quote {});\n\n        quote {\n            let mut $serialized_params_name = [0; $params_len_quote];\n            let mut offset = 0;\n\n            $serialization_of_struct_members\n        }\n    };\n\n    (body, params_len_quote, serialized_params_name)\n}\n\n/// Generates a quoted expression that computes the total serialized length of function parameters.\n///\n/// # Parameters\n/// * `params` - An array of tuples where each tuple contains a quoted parameter name and its Type. The type needs\n///              to implement the Serialize trait.\n///\n/// # Returns\n/// A quoted expression that evaluates to:\n/// * `0` if there are no parameters\n/// * `(<type1 as Serialize>::N + <type2 as Serialize>::N + ...)` for one or more parameters\npub comptime fn get_params_len_quote(params: [(Quoted, Type)]) -> Quoted {\n    if params.len() == 0 {\n        quote { 0 }\n    } else {\n        let params_quote_without_parentheses = params\n            .map(|(_, param_type): (Quoted, Type)| {\n                quote {\n                    <$param_type as $crate::traits::Serialize>::N\n                }\n            })\n            .join(quote {+});\n        quote { ($params_quote_without_parentheses) }\n    }\n}\n"
     },
-    "338": {
+    "339": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr",
       "source": "use crate::constants::TWO_POW_64;\nuse crate::traits::{Deserialize, Serialize};\nuse std::meta::derive;\n// NB: This is a clone of noir/noir-repo/noir_stdlib/src/hash/poseidon2.nr\n// It exists as we sometimes need to perform custom absorption, but the stdlib version\n// has a private absorb() method (it's also designed to just be a hasher)\n// Can be removed when standalone noir poseidon lib exists: See noir#6679\n\ncomptime global RATE: u32 = 3;\n\n#[derive(Deserialize, Eq, Serialize)]\npub struct Poseidon2Sponge {\n    pub cache: [Field; 3],\n    pub state: [Field; 4],\n    pub cache_size: u32,\n    pub squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2Sponge {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2Sponge::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2Sponge {\n        let mut result =\n            Poseidon2Sponge { 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 = std::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    pub 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    pub 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 iv: Field = (in_len as Field) * TWO_POW_64;\n        let mut sponge = Poseidon2Sponge::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"
     },
-    "366": {
+    "367": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/traits.nr",
       "source": "use crate::meta::{derive_deserialize, derive_packable, 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: Eq {\n    fn empty() -> Self;\n\n    fn is_empty(self) -> bool {\n        self.eq(Self::empty())\n    }\n\n    // Requires this Noir fix: https://github.com/noir-lang/noir/issues/9002\n    // fn assert_not_empty<let U: u32>(self, msg: str<U>) { // This msg version was failing with weird compiler errors.\n    //     // We provide a default impl but it's likely inefficient.\n    //     // The reason we include this function is because there's a lot of\n    //     // opportunity for optimisation on a per-struct basis.\n    //     // You only need to show one element is not empty to know that the whole thing\n    //     // is not empty.\n    //     // If you know an element of your struct which should always be nonempty,\n    //     // you can write an impl that solely checks that that element is nonempty.\n    //     assert(!self.is_empty(), msg);\n    // }\n\n    // This default impl is overwritten by types like arrays, because there's a much\n    // more efficient approach.\n    fn assert_empty<let S: u32>(self, msg: str<S>) {\n        assert(self.is_empty(), msg);\n    }\n}\n\nimpl Empty for Field {\n    #[inline_always]\n    fn empty() -> Self {\n        0\n    }\n}\n\nimpl Empty for u1 {\n    #[inline_always]\n    fn empty() -> Self {\n        0\n    }\n}\nimpl Empty for u8 {\n    #[inline_always]\n    fn empty() -> Self {\n        0\n    }\n}\nimpl Empty for u16 {\n    fn empty() -> Self {\n        0\n    }\n}\nimpl Empty for u32 {\n    #[inline_always]\n    fn empty() -> Self {\n        0\n    }\n}\nimpl Empty for u64 {\n    #[inline_always]\n    fn empty() -> Self {\n        0\n    }\n}\nimpl Empty for u128 {\n    #[inline_always]\n    fn empty() -> Self {\n        0\n    }\n}\n\nimpl<T, let N: u32> Empty for [T; N]\nwhere\n    T: Empty,\n{\n    #[inline_always]\n    fn empty() -> Self {\n        [T::empty(); N]\n    }\n\n    fn is_empty(self) -> bool {\n        self.all(|elem| elem.is_empty())\n    }\n\n    fn assert_empty<let S: u32>(self, msg: str<S>) -> () {\n        self.for_each(|elem| elem.assert_empty(msg))\n    }\n}\n\nimpl<T> Empty for [T]\nwhere\n    T: Empty,\n{\n    #[inline_always]\n    fn empty() -> Self {\n        [T::empty()]\n    }\n\n    fn is_empty(self) -> bool {\n        self.all(|elem| elem.is_empty())\n    }\n\n    fn assert_empty<let S: u32>(self, msg: str<S>) -> () {\n        self.for_each(|elem| elem.assert_empty(msg))\n    }\n}\nimpl<A, B> Empty for (A, B)\nwhere\n    A: Empty,\n    B: Empty,\n{\n    #[inline_always]\n    fn empty() -> Self {\n        (A::empty(), B::empty())\n    }\n}\n\nimpl<T> Empty for Option<T>\nwhere\n    T: Eq,\n{\n    #[inline_always]\n    fn empty() -> Self {\n        Option::none()\n    }\n}\n\n// pub fn is_empty<T>(item: T) -> bool\n// where\n//     T: Empty,\n// {\n//     item.eq(T::empty())\n// }\n\n// pub fn is_empty_array<T, let N: u32>(array: [T; N]) -> bool\n// where\n//     T: Empty,\n// {\n//     array.all(|elem| is_empty(elem))\n// }\n\n// pub fn assert_empty<T>(item: T) -> ()\n// where\n//     T: Empty,\n// {\n//     assert(item.eq(T::empty()))\n// }\n\n// pub fn assert_empty_array<T, let N: u32>(array: [T; N]) -> ()\n// where\n//     T: Empty,\n// {\n//     // A cheaper option than `is_empty_array` for if you don't need to gracefully\n//     // handle a bool result.\n//     // Avoids the `&` operator of `is_empty_array`'s `.all()` call.\n//     for i in 0..N {\n//         assert(is_empty(array[i]));\n//     }\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    #[inline_always]\n    fn to_field(self) -> Field {\n        self\n    }\n}\n\nimpl ToField for bool {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u1 {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u8 {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u16 {\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u32 {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u64 {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u128 {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl<let N: u32> ToField for str<N> {\n    #[inline_always]\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    #[inline_always]\n    fn from_field(value: Field) -> Self {\n        value\n    }\n}\n\nimpl FromField for bool {\n    #[inline_always]\n    fn from_field(value: Field) -> Self {\n        value != 0\n    }\n}\nimpl FromField for u1 {\n    #[inline_always]\n    fn from_field(value: Field) -> Self {\n        value as u1\n    }\n}\nimpl FromField for u8 {\n    #[inline_always]\n    fn from_field(value: Field) -> Self {\n        value as u8\n    }\n}\nimpl FromField for u16 {\n    fn from_field(value: Field) -> Self {\n        value as u16\n    }\n}\nimpl FromField for u32 {\n    #[inline_always]\n    fn from_field(value: Field) -> Self {\n        value as u32\n    }\n}\nimpl FromField for u64 {\n    #[inline_always]\n    fn from_field(value: Field) -> Self {\n        value as u64\n    }\n}\nimpl FromField for u128 {\n    #[inline_always]\n    fn from_field(value: Field) -> Self {\n        value as u128\n    }\n}\n\n// docs:start:serialize\n/// Trait for serializing Noir types into arrays of Fields.\n///\n/// An implementation of the Serialize trait has to follow Noir's intrinsic serialization (each member of a struct\n/// converted directly into one or more Fields without any packing or compression). This trait (and Deserialize) are\n/// typically used to communicate between Noir and TypeScript (via oracles and function arguments).\n///\n/// # On Following Noir's Intrinsic Serialization\n/// When calling a Noir function from TypeScript (TS), first the function arguments are serialized into an array\n/// of fields. This array is then included in the initial witness. Noir's intrinsic serialization is then used\n/// to deserialize the arguments from the witness. When the same Noir function is called from Noir this Serialize trait\n/// is used instead of the serialization in TS. For this reason we need to have a match between TS serialization,\n/// Noir's intrinsic serialization and the implementation of this trait. If there is a mismatch, the function calls\n/// fail with an arguments hash mismatch error message.\n///\n/// # Associated Constants\n/// * `N` - The length of the output Field array, known at compile time\n///\n/// # Example\n/// ```\n/// impl<let N: u32> Serialize for str<N> {\n///     let N: u32 = N;\n///\n///     fn serialize(self) -> [Field; Self::N] {\n///         let bytes = self.as_bytes();\n///         let mut fields = [0; Self::N];\n///         for i in 0..bytes.len() {\n///             fields[i] = bytes[i] as Field;  // Each byte gets its own Field\n///         }\n///         fields\n///     }\n/// }\n/// ```\n#[derive_via(derive_serialize)]\npub trait Serialize {\n    let N: u32;\n\n    fn serialize(self) -> [Field; N];\n}\n// docs:end:serialize\n\nimpl<let M: u32> Serialize for str<M> {\n    let N: u32 = M;\n\n    #[inline_always]\n    fn serialize(self) -> [Field; Self::N] {\n        let bytes = self.as_bytes();\n        let mut fields = [0; Self::N];\n        for i in 0..bytes.len() {\n            fields[i] = bytes[i] as Field;\n        }\n        fields\n    }\n}\n\n/// Implementation of Deserialize for BoundedVec.\n///\n/// This implementation deserializes a BoundedVec from an array of Fields. The array contains:\n/// 1. The serialized items, each taking up T::N Fields\n/// 2. The length of the BoundedVec as the last Field\n///\n/// # Type Parameters\n/// * `T` - The type of items stored in the BoundedVec, must implement Deserialize\n/// * `M` - The maximum length of the BoundedVec\n///\n/// # Fields Array Layout\n/// [item1_field1, item1_field2, ..., item2_field1, item2_field2, ..., length]\n/// Where:\n/// - itemN_fieldM: The M-th Field of the N-th item (T::N Fields per item)\n/// - length: The number of items in the BoundedVec (1 Field)\n///\n/// Total length N = T::N * M + 1, where:\n/// - T::N is the number of Fields needed to deserialize one item\n/// - M is the maximum length of the BoundedVec\n/// - +1 is for storing the length\n///\n/// # Note\n/// Not deriving this because it's not supported to call derive_deserialize on a \"remote\" struct (and it will never\n/// be supported).\nimpl<T, let M: u32> Deserialize for BoundedVec<T, M>\nwhere\n    T: Deserialize,\n{\n    let N: u32 = <T as Deserialize>::N * M + 1;\n\n    #[inline_always]\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut new_bounded_vec: BoundedVec<T, M> = BoundedVec::new();\n\n        // Length is stored in the last field as we need to match intrinsic Noir serialization and the `len` struct\n        // field is after `storage` struct field (see `bounded_vec.nr` in noir-stdlib)\n        let len = fields[<T as Deserialize>::N * M] as u32;\n\n        for i in 0..len {\n            let mut nested_fields = [0; <T as Deserialize>::N];\n            for j in 0..<T as Deserialize>::N {\n                nested_fields[j] = fields[i * <T as Deserialize>::N + j];\n            }\n\n            let item = T::deserialize(nested_fields);\n            new_bounded_vec.push(item);\n        }\n\n        new_bounded_vec\n    }\n}\n\n// This may cause issues if used as program input, because noir disallows empty arrays for program input.\n// I think this is okay because I don't foresee a unit type being used as input. But leaving this comment as a hint\n// if someone does run into this in the future.\nimpl Deserialize for () {\n    let N: u32 = 0;\n\n    fn deserialize(_fields: [Field; Self::N]) -> Self {\n        ()\n    }\n}\n\n// Note: Not deriving this because it's not supported to call derive_serialize on a \"remote\" struct (and it will never\n// be supported).\nimpl<T, let M: u32> Serialize for BoundedVec<T, M>\nwhere\n    T: Serialize,\n{\n    let N: u32 = <T as Serialize>::N * M + 1; // +1 for the length of the BoundedVec\n\n    #[inline_always]\n    fn serialize(self) -> [Field; Self::N] {\n        let mut fields = [0; Self::N];\n\n        let storage = self.storage();\n\n        for i in 0..M {\n            let serialized_item = storage[i].serialize();\n\n            for j in 0..<T as Serialize>::N {\n                fields[i * <T as Serialize>::N + j] = serialized_item[j];\n            }\n        }\n\n        // Length is stored in the last field as we need to match intrinsic Noir serialization and the `len` struct\n        // field is after `storage` struct field (see `bounded_vec.nr` in noir-stdlib)\n        fields[<T as Serialize>::N * M] = self.len() as Field;\n\n        fields\n    }\n}\n\n// docs:start:deserialize\n/// Trait for deserializing Noir types from arrays of Fields.\n///\n/// An implementation of the Deserialize trait has to follow Noir's intrinsic serialization (each member of a struct\n/// converted directly into one or more Fields without any packing or compression). This trait is typically used when\n/// deserializing return values from function calls in Noir. Since the same function could be called from TypeScript\n/// (TS), in which case the TS deserialization would get used, we need to have a match between the 2.\n///\n/// # Associated Constants\n/// * `N` - The length of the input Field array, known at compile time\n///\n/// # Example\n/// ```\n/// impl<let M: u32> Deserialize for str<M> {\n///     let N: u32 = M;\n///\n///     #[inline_always]\n///     fn deserialize(fields: [Field; Self::N]) -> Self {\n///         str::<Self::N>::from(fields.map(|value| value as u8))\n///     }\n/// }\n/// ```\n#[derive_via(derive_deserialize)]\npub trait Deserialize {\n    let N: u32;\n\n    fn deserialize(fields: [Field; N]) -> Self;\n}\n// docs:end:deserialize\n\nimpl<let M: u32> Deserialize for str<M> {\n    let N: u32 = M;\n\n    #[inline_always]\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        str::<Self::N>::from(fields.map(|value| value as u8))\n    }\n}\n\n/// Trait for efficiently packing and unpacking Noir types into and from arrays of Fields.\n///\n/// The `Packable` trait allows types to be serialized and deserialized with a focus on minimizing the size of\n/// the resulting Field array. This trait is used when storage efficiency is critical (e.g. when storing data\n/// in the contract's public storage).\n///\n/// # Associated Constants\n/// * `N` - The length of the Field array, known at compile time\n#[derive_via(derive_packable)]\npub trait Packable {\n    let N: u32;\n\n    /// Packs the current value into a compact array of `Field` elements.\n    fn pack(self) -> [Field; N];\n\n    /// Unpacks a compact array of `Field` elements into the original value.\n    fn unpack(fields: [Field; N]) -> Self;\n}\n\n#[test]\nunconstrained fn bounded_vec_serialization() {\n    // Test empty BoundedVec\n    let empty_vec: BoundedVec<Field, 3> = BoundedVec::from_array([]);\n    let serialized = empty_vec.serialize();\n    let deserialized = BoundedVec::<Field, 3>::deserialize(serialized);\n    assert_eq(empty_vec, deserialized);\n    assert_eq(deserialized.len(), 0);\n\n    // Test partially filled BoundedVec\n    let partial_vec: BoundedVec<[u32; 2], 3> = BoundedVec::from_array([[1, 2]]);\n    let serialized = partial_vec.serialize();\n    let deserialized = BoundedVec::<[u32; 2], 3>::deserialize(serialized);\n    assert_eq(partial_vec, deserialized);\n    assert_eq(deserialized.len(), 1);\n    assert_eq(deserialized.get(0), [1, 2]);\n\n    // Test full BoundedVec\n    let full_vec: BoundedVec<[u32; 2], 3> = BoundedVec::from_array([[1, 2], [3, 4], [5, 6]]);\n    let serialized = full_vec.serialize();\n    let deserialized = BoundedVec::<[u32; 2], 3>::deserialize(serialized);\n    assert_eq(full_vec, deserialized);\n    assert_eq(deserialized.len(), 3);\n    assert_eq(deserialized.get(0), [1, 2]);\n    assert_eq(deserialized.get(1), [3, 4]);\n    assert_eq(deserialized.get(2), [5, 6]);\n}\n"
     },
-    "369": {
+    "370": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/type_serialization.nr",
-      "source": "use crate::traits::{Deserialize, Serialize};\n\nglobal U1_SERIALIZED_LEN: u32 = 1;\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 for bool {\n    let N: u32 = BOOL_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn serialize(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize for bool {\n    let N: u32 = BOOL_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn deserialize(fields: [Field; Self::N]) -> bool {\n        fields[0] != 0\n    }\n}\n\nimpl Serialize for u1 {\n    let N: u32 = U1_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn serialize(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize for u1 {\n    let N: u32 = U1_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        fields[0] as u1\n    }\n}\n\nimpl Serialize for u8 {\n    let N: u32 = U8_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn serialize(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize for u8 {\n    let N: u32 = U8_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        fields[0] as u8\n    }\n}\n\nimpl Serialize for u16 {\n    let N: u32 = U16_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn serialize(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize for u16 {\n    let N: u32 = U16_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        fields[0] as u16\n    }\n}\n\nimpl Serialize for u32 {\n    let N: u32 = U32_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn serialize(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize for u32 {\n    let N: u32 = U32_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        fields[0] as u32\n    }\n}\n\nimpl Serialize for u64 {\n    let N: u32 = U64_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn serialize(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize for u64 {\n    let N: u32 = U64_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        fields[0] as u64\n    }\n}\n\nimpl Serialize for u128 {\n    let N: u32 = U128_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn serialize(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize for u128 {\n    let N: u32 = U128_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        fields[0] as u128\n    }\n}\n\nimpl Serialize for Field {\n    let N: u32 = FIELD_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn serialize(self) -> [Field; Self::N] {\n        [self]\n    }\n}\n\nimpl Deserialize for Field {\n    let N: u32 = FIELD_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        fields[0]\n    }\n}\n\nimpl Serialize for i8 {\n    let N: u32 = I8_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn serialize(self) -> [Field; Self::N] {\n        [self as u8 as Field]\n    }\n}\n\nimpl Deserialize for i8 {\n    let N: u32 = I8_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        fields[0] as u8 as i8\n    }\n}\n\nimpl Serialize for i16 {\n    let N: u32 = I16_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn serialize(self) -> [Field; Self::N] {\n        [self as u16 as Field]\n    }\n}\n\nimpl Deserialize for i16 {\n    let N: u32 = I16_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        fields[0] as u16 as i16\n    }\n}\n\nimpl Serialize for i32 {\n    let N: u32 = I32_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn serialize(self) -> [Field; Self::N] {\n        [self as u32 as Field]\n    }\n}\n\nimpl Deserialize for i32 {\n    let N: u32 = I32_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        fields[0] as u32 as i32\n    }\n}\n\nimpl Serialize for i64 {\n    let N: u32 = I64_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn serialize(self) -> [Field; Self::N] {\n        [self as u64 as Field]\n    }\n}\n\nimpl Deserialize for i64 {\n    let N: u32 = I64_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        fields[0] as u64 as i64\n    }\n}\n\nimpl<T, let M: u32> Serialize for [T; M]\nwhere\n    T: Serialize,\n{\n    let N: u32 = <T as Serialize>::N * M;\n\n    #[inline_always]\n    fn serialize(self) -> [Field; Self::N] {\n        let mut result: [Field; _] = std::mem::zeroed();\n        for i in 0..M {\n            let serialized_t = self[i].serialize();\n            for j in 0..<T as Serialize>::N {\n                result[i * <T as Serialize>::N + j] = serialized_t[j];\n            }\n        }\n        result\n    }\n}\n\nimpl<T, let M: u32> Deserialize for [T; M]\nwhere\n    T: Deserialize,\n{\n    let N: u32 = <T as Deserialize>::N * M;\n\n    #[inline_always]\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = crate::utils::reader::Reader::new(fields);\n        let mut result: [T; M] = std::mem::zeroed();\n        reader.read_struct_array::<T, <T as Deserialize>::N, M>(Deserialize::deserialize, result)\n    }\n}\n\nimpl<T> Serialize for Option<T>\nwhere\n    T: Serialize,\n{\n    let N: u32 = <T as Serialize>::N + 1;\n\n    #[inline_always]\n    fn serialize(self) -> [Field; Self::N] {\n        let mut result: [Field; Self::N] = std::mem::zeroed();\n\n        result[0] = if self.is_some() { 1 } else { 0 };\n\n        let value_serialized = self.unwrap_unchecked().serialize();\n        for i in 0..<T as Serialize>::N {\n            result[1 + i] = value_serialized[i];\n        }\n\n        result\n    }\n}\n\nimpl<T> Deserialize for Option<T>\nwhere\n    T: Deserialize,\n{\n    let N: u32 = <T as Deserialize>::N + 1;\n\n    #[inline_always]\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        if fields[0] == 1 {\n            let mut value_fields = [0; <T as Deserialize>::N];\n            for i in 0..<T as Deserialize>::N {\n                value_fields[i] = fields[1 + i];\n            }\n\n            Option::some(T::deserialize(value_fields))\n        } else {\n            Option::none()\n        }\n    }\n}\n\nmod test {\n    use crate::traits::{Deserialize, Serialize};\n\n    #[test]\n    fn u16_serialization() {\n        let a: u16 = 10;\n        assert_eq(a, u16::deserialize(a.serialize()));\n    }\n\n    #[test]\n    fn i8_serialization() {\n        let a: i8 = -10;\n        assert_eq(a, i8::deserialize(a.serialize()));\n    }\n\n    #[test]\n    fn i16_serialization() {\n        let a: i16 = -10;\n        assert_eq(a, i16::deserialize(a.serialize()));\n    }\n\n    #[test]\n    fn i32_serialization() {\n        let a: i32 = -10;\n        assert_eq(a, i32::deserialize(a.serialize()));\n    }\n\n    #[test]\n    fn i64_serialization() {\n        let a: i64 = -10;\n        assert_eq(a, i64::deserialize(a.serialize()));\n    }\n\n    #[test]\n    fn option_field_serialization() {\n        let opt_some = Option::some(5);\n        assert_eq(Option::<_>::deserialize(opt_some.serialize()), opt_some);\n\n        let opt_none = Option::none();\n        assert_eq(Option::<Field>::deserialize(opt_none.serialize()), opt_none);\n    }\n\n    #[test]\n    fn option_array_serialization() {\n        let opt_some = Option::some([2, 5]);\n        assert_eq(Option::<_>::deserialize(opt_some.serialize()), opt_some);\n\n        let opt_none = Option::none();\n        assert_eq(Option::<Field>::deserialize(opt_none.serialize()), opt_none);\n    }\n}\n"
+      "source": "use crate::traits::{Deserialize, Serialize};\n\nglobal U1_SERIALIZED_LEN: u32 = 1;\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 for bool {\n    let N: u32 = BOOL_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn serialize(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize for bool {\n    let N: u32 = BOOL_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn deserialize(fields: [Field; Self::N]) -> bool {\n        fields[0] != 0\n    }\n}\n\nimpl Serialize for u1 {\n    let N: u32 = U1_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn serialize(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize for u1 {\n    let N: u32 = U1_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        fields[0] as u1\n    }\n}\n\nimpl Serialize for u8 {\n    let N: u32 = U8_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn serialize(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize for u8 {\n    let N: u32 = U8_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        fields[0] as u8\n    }\n}\n\nimpl Serialize for u16 {\n    let N: u32 = U16_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn serialize(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize for u16 {\n    let N: u32 = U16_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        fields[0] as u16\n    }\n}\n\nimpl Serialize for u32 {\n    let N: u32 = U32_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn serialize(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize for u32 {\n    let N: u32 = U32_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        fields[0] as u32\n    }\n}\n\nimpl Serialize for u64 {\n    let N: u32 = U64_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn serialize(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize for u64 {\n    let N: u32 = U64_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        fields[0] as u64\n    }\n}\n\nimpl Serialize for u128 {\n    let N: u32 = U128_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn serialize(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize for u128 {\n    let N: u32 = U128_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        fields[0] as u128\n    }\n}\n\nimpl Serialize for Field {\n    let N: u32 = FIELD_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn serialize(self) -> [Field; Self::N] {\n        [self]\n    }\n}\n\nimpl Deserialize for Field {\n    let N: u32 = FIELD_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        fields[0]\n    }\n}\n\nimpl Serialize for i8 {\n    let N: u32 = I8_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn serialize(self) -> [Field; Self::N] {\n        [self as u8 as Field]\n    }\n}\n\nimpl Deserialize for i8 {\n    let N: u32 = I8_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        fields[0] as u8 as i8\n    }\n}\n\nimpl Serialize for i16 {\n    let N: u32 = I16_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn serialize(self) -> [Field; Self::N] {\n        [self as u16 as Field]\n    }\n}\n\nimpl Deserialize for i16 {\n    let N: u32 = I16_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        fields[0] as u16 as i16\n    }\n}\n\nimpl Serialize for i32 {\n    let N: u32 = I32_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn serialize(self) -> [Field; Self::N] {\n        [self as u32 as Field]\n    }\n}\n\nimpl Deserialize for i32 {\n    let N: u32 = I32_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        fields[0] as u32 as i32\n    }\n}\n\nimpl Serialize for i64 {\n    let N: u32 = I64_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn serialize(self) -> [Field; Self::N] {\n        [self as u64 as Field]\n    }\n}\n\nimpl Deserialize for i64 {\n    let N: u32 = I64_SERIALIZED_LEN;\n\n    #[inline_always]\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        fields[0] as u64 as i64\n    }\n}\n\nimpl<T, let M: u32> Serialize for [T; M]\nwhere\n    T: Serialize,\n{\n    let N: u32 = <T as Serialize>::N * M;\n    #[inline_always]\n    fn serialize(self) -> [Field; Self::N] {\n        let mut result: [Field; _] = std::mem::zeroed();\n        for i in 0..M {\n            let serialized_t = self[i].serialize();\n            let T_N = serialized_t.len();\n            for j in 0..T_N {\n                result[i * T_N + j] = serialized_t[j];\n            }\n        }\n        result\n    }\n}\n\nimpl<T, let M: u32> Deserialize for [T; M]\nwhere\n    T: Deserialize,\n{\n    let N: u32 = <T as Deserialize>::N * M;\n\n    #[inline_always]\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = crate::utils::reader::Reader::new(fields);\n        let mut result: [T; M] = std::mem::zeroed();\n        reader.read_struct_array::<T, <T as Deserialize>::N, M>(Deserialize::deserialize, result)\n    }\n}\n\nimpl<T> Serialize for Option<T>\nwhere\n    T: Serialize,\n{\n    let N: u32 = <T as Serialize>::N + 1;\n\n    #[inline_always]\n    fn serialize(self) -> [Field; Self::N] {\n        let mut result: [Field; Self::N] = std::mem::zeroed();\n\n        result[0] = if self.is_some() { 1 } else { 0 };\n\n        let value_serialized = self.unwrap_unchecked().serialize();\n        for i in 0..<T as Serialize>::N {\n            result[1 + i] = value_serialized[i];\n        }\n\n        result\n    }\n}\n\nimpl<T> Deserialize for Option<T>\nwhere\n    T: Deserialize,\n{\n    let N: u32 = <T as Deserialize>::N + 1;\n\n    #[inline_always]\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        if fields[0] == 1 {\n            let mut value_fields = [0; <T as Deserialize>::N];\n            for i in 0..<T as Deserialize>::N {\n                value_fields[i] = fields[1 + i];\n            }\n\n            Option::some(T::deserialize(value_fields))\n        } else {\n            Option::none()\n        }\n    }\n}\n\nmod test {\n    use crate::traits::{Deserialize, Serialize};\n\n    #[test]\n    fn u16_serialization() {\n        let a: u16 = 10;\n        assert_eq(a, u16::deserialize(a.serialize()));\n    }\n\n    #[test]\n    fn i8_serialization() {\n        let a: i8 = -10;\n        assert_eq(a, i8::deserialize(a.serialize()));\n    }\n\n    #[test]\n    fn i16_serialization() {\n        let a: i16 = -10;\n        assert_eq(a, i16::deserialize(a.serialize()));\n    }\n\n    #[test]\n    fn i32_serialization() {\n        let a: i32 = -10;\n        assert_eq(a, i32::deserialize(a.serialize()));\n    }\n\n    #[test]\n    fn i64_serialization() {\n        let a: i64 = -10;\n        assert_eq(a, i64::deserialize(a.serialize()));\n    }\n\n    #[test]\n    fn option_field_serialization() {\n        let opt_some = Option::some(5);\n        assert_eq(Option::<_>::deserialize(opt_some.serialize()), opt_some);\n\n        let opt_none = Option::none();\n        assert_eq(Option::<Field>::deserialize(opt_none.serialize()), opt_none);\n    }\n\n    #[test]\n    fn array_serialization() {\n        let array = [1, 2, 3, 4];\n\n        let serialized: [Field; 4] = array.serialize();\n        let deserialized: [Field; 4] = Deserialize::deserialize(serialized);\n        assert_eq(deserialized, array);\n    }\n\n    #[test]\n    fn nested_array_serialization() {\n        let nested_array = [[1, 2, 3, 4], [5, 6, 7, 8]];\n\n        let serialized: [Field; 8] = nested_array.serialize();\n        let deserialized: [[Field; 4]; 2] = Deserialize::deserialize(serialized);\n\n        assert_eq(deserialized, nested_array);\n    }\n\n    #[test]\n    fn option_array_serialization() {\n        let opt_some = Option::some([2, 5]);\n        assert_eq(Option::<_>::deserialize(opt_some.serialize()), opt_some);\n\n        let opt_none = Option::none();\n        assert_eq(Option::<Field>::deserialize(opt_none.serialize()), opt_none);\n    }\n}\n"
     },
-    "374": {
+    "375": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/utils/field.nr",
       "source": "global KNOWN_NON_RESIDUE: Field = 5; // This is a non-residue in Noir's native Field.\n\npub 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\npub fn min(f1: Field, f2: Field) -> Field {\n    if f1.lt(f2) {\n        f1\n    } else {\n        f2\n    }\n}\n\nglobal C1: u32 = 28;\nglobal C3: Field = 40770029410420498293352137776570907027550720424234931066070132305055;\nglobal C5: Field = 19103219067921713944291392827692070036145651957329286315305642004821462161904;\n\npub fn pow(x: Field, y: Field) -> Field {\n    let mut r = 1 as Field;\n    let b: [u1; 254] = y.to_le_bits();\n\n    for i in 0..254 {\n        r *= r;\n        r *= (b[254 - 1 - i] as Field) * x + (1 - b[254 - 1 - i] as Field);\n    }\n\n    r\n}\n\n/// Returns Option::some(sqrt) if there is a square root, and Option::none() if there isn't.\npub fn sqrt(x: Field) -> Option<Field> {\n    // Safety: if the hint returns the square root of x, then we simply square it\n    // check the result equals x. If x is not square, we return a value that\n    // enables us to prove that fact (see the `else` clause below).\n    let (is_sq, maybe_sqrt) = unsafe { __sqrt(x) };\n\n    if is_sq {\n        let sqrt = maybe_sqrt;\n        validate_sqrt_hint(x, sqrt);\n        Option::some(sqrt)\n    } else {\n        let not_sqrt_hint = maybe_sqrt;\n        validate_not_sqrt_hint(x, not_sqrt_hint);\n        Option::none()\n    }\n}\n\n// Boolean indicating whether Field element is a square, i.e. whether there exists a y in Field s.t. x = y*y.\nunconstrained fn is_square(x: Field) -> bool {\n    let v = pow(x, -1 / 2);\n    v * (v - 1) == 0\n}\n\n// Tonelli-Shanks algorithm for computing the square root of a Field element.\n// Requires C1 = max{c: 2^c divides (p-1)}, where p is the order of Field\n// as well as C3 = (C2 - 1)/2, where C2 = (p-1)/(2^c1),\n// and C5 = ZETA^C2, where ZETA is a non-square element of Field.\n// These are pre-computed above as globals.\nunconstrained fn tonelli_shanks_sqrt(x: Field) -> Field {\n    let mut z = pow(x, C3);\n    let mut t = z * z * x;\n    z *= x;\n    let mut b = t;\n    let mut c = C5;\n\n    for i in 0..(C1 - 1) {\n        for _j in 1..(C1 - i - 1) {\n            b *= b;\n        }\n\n        z *= if b == 1 { 1 } else { c };\n\n        c *= c;\n\n        t *= if b == 1 { 1 } else { c };\n\n        b = t;\n    }\n\n    z\n}\n\n// NB: this doesn't return an option, because in the case of there _not_ being a square root, we still want to return a field element that allows us to then assert in the _constrained_ sqrt function that there is no sqrt.\nunconstrained fn __sqrt(x: Field) -> (bool, Field) {\n    let is_sq = is_square(x);\n    if is_sq {\n        let sqrt = tonelli_shanks_sqrt(x);\n        (true, sqrt)\n    } else {\n        // Demonstrate that x is not a square (a.k.a. a \"quadratic non-residue\").\n        // Facts:\n        // The Legendre symbol (\"LS\") of x, is x^((p-1)/2) (mod p).\n        // - If x is a square, LS(x) = 1\n        // - If x is not a square, LS(x) = -1\n        // - If x = 0, LS(x) = 0.\n        //\n        // Hence:\n        // sq * sq = sq // 1 * 1 = 1\n        // non-sq * non-sq = sq // -1 * -1 = 1\n        // sq * non-sq = non-sq // -1 * 1 = -1\n        //\n        // See: https://en.wikipedia.org/wiki/Legendre_symbol\n        let demo_x_not_square = x * KNOWN_NON_RESIDUE;\n        let not_sqrt = tonelli_shanks_sqrt(demo_x_not_square);\n        (false, not_sqrt)\n    }\n}\n\nfn validate_sqrt_hint(x: Field, hint: Field) {\n    assert(hint * hint == x, f\"The claimed_sqrt {hint} is not the sqrt of x {x}\");\n}\n\nfn validate_not_sqrt_hint(x: Field, hint: Field) {\n    // We need this assertion, because x = 0 would pass the other assertions in this\n    // function, and we don't want people to be able to prove that 0 is not square!\n    assert(x != 0, \"0 has a square root; you cannot claim it is not square\");\n    // Demonstrate that x is not a square (a.k.a. a \"quadratic non-residue\").\n    //\n    // Facts:\n    // The Legendre symbol (\"LS\") of x, is x^((p-1)/2) (mod p).\n    // - If x is a square, LS(x) = 1\n    // - If x is not a square, LS(x) = -1\n    // - If x = 0, LS(x) = 0.\n    //\n    // Hence:\n    // 1. sq * sq = sq // 1 * 1 = 1\n    // 2. non-sq * non-sq = sq // -1 * -1 = 1\n    // 3. sq * non-sq = non-sq // -1 * 1 = -1\n    //\n    // See: https://en.wikipedia.org/wiki/Legendre_symbol\n    //\n    // We want to demonstrate that this below multiplication falls under bullet-point (2):\n    let demo_x_not_square = x * KNOWN_NON_RESIDUE;\n    // I.e. we want to demonstrate that `demo_x_not_square` has Legendre symbol 1\n    // (i.e. that it is a square), so we prove that it is square below.\n    // Why do we want to prove that it has LS 1?\n    // Well, since it was computed with a known-non-residue, its squareness implies we're\n    // in case 2 (something multiplied by a known-non-residue yielding a result which\n    // has a LS of 1), which implies that x must be a non-square. The unconstrained\n    // function gave us the sqrt of demo_x_not_square, so all we need to do is\n    // assert its squareness:\n    assert(\n        hint * hint == demo_x_not_square,\n        f\"The hint {hint} does not demonstrate that {x} is not a square\",\n    );\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\n#[test]\nunconstrained fn sqrt_valid_test() {\n    let x = 16; // examples: 16, 9, 25, 81\n    let result = sqrt(x);\n    assert(result.is_some());\n    assert_eq(result.unwrap() * result.unwrap(), x);\n}\n\n#[test]\nunconstrained fn sqrt_invalid_test() {\n    let x = KNOWN_NON_RESIDUE; // has no square root in the field\n    let result = sqrt(x);\n    assert(result.is_none());\n}\n"
     },
-    "378": {
+    "379": {
       "path": "/home/aztec-dev/aztec-packages/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_u64(&mut self) -> u64 {\n        self.read() as u64\n    }\n\n    pub fn read_bool(&mut self) -> bool {\n        self.read() != 0\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_eq(self.offset, self.data.len(), \"Reader did not read all data\");\n    }\n}\n"
     },
@@ -931,7 +935,7 @@
       "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"
     },
-    "50": {
+    "51": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/router_contract/src/main.nr",
       "source": "mod test;\npub mod utils;\n\nuse dep::aztec::macros::aztec;\n\n/// The purpose of this contract is to perform a check in public without revealing what contract enqueued the public\n/// call. This can be achieved by enqueueing an `incognito` public call.\n#[aztec]\npub contract Router {\n    use aztec::{macros::functions::{external, view}, utils::comparison::compare};\n\n    // docs:start:check_timestamp\n    /// Asserts that the current timestamp satisfies the `operation` with respect\n    /// to the `value.\n    #[external(\"public\")]\n    #[view]\n    fn check_timestamp(operation: u8, value: u64) {\n        let lhs_field = self.context.timestamp() as Field;\n        let rhs_field = value as Field;\n        assert(compare(lhs_field, operation, rhs_field), \"Timestamp mismatch.\");\n    }\n    // docs:end:check_timestamp\n\n    /// Asserts that the current block number satisfies the `operation` with respect\n    /// to the `value.\n    #[external(\"public\")]\n    #[view]\n    fn check_block_number(operation: u8, value: u32) {\n        assert(\n            compare(\n                self.context.block_number() as Field,\n                operation,\n                value as Field,\n            ),\n            \"Block number mismatch.\",\n        );\n    }\n}\n"
     },
@@ -939,29 +943,25 @@
       "path": "std/collections/bounded_vec.nr",
       "source": "use crate::{cmp::Eq, convert::From, runtime::is_unconstrained, static_assert};\n\n/// A `BoundedVec<T, MaxLen>` is a growable storage similar to a `Vec<T>` except that it\n/// is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented\n/// via slices and thus is not subject to the same restrictions slices are (notably, nested\n/// slices - and thus nested vectors as well - are disallowed).\n///\n/// Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by\n/// pushing an additional element is also more efficient - the length only needs to be increased\n/// by one.\n///\n/// For these reasons `BoundedVec<T, N>` should generally be preferred over `Vec<T>` when there\n/// is a reasonable maximum bound that can be placed on the vector.\n///\n/// Example:\n///\n/// ```noir\n/// let mut vector: BoundedVec<Field, 10> = BoundedVec::new();\n/// for i in 0..5 {\n///     vector.push(i);\n/// }\n/// assert(vector.len() == 5);\n/// assert(vector.max_len() == 10);\n/// ```\npub struct BoundedVec<T, let MaxLen: u32> {\n    storage: [T; MaxLen],\n    len: u32,\n}\n\nimpl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {\n    /// Creates a new, empty vector of length zero.\n    ///\n    /// Since this container is backed by an array internally, it still needs an initial value\n    /// to give each element. To resolve this, each element is zeroed internally. This value\n    /// is guaranteed to be inaccessible unless `get_unchecked` is used.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let empty_vector: BoundedVec<Field, 10> = BoundedVec::new();\n    /// assert(empty_vector.len() == 0);\n    /// ```\n    ///\n    /// Note that whenever calling `new` the maximum length of the vector should always be specified\n    /// via a type signature:\n    ///\n    /// ```noir\n    /// fn good() -> BoundedVec<Field, 10> {\n    ///     // Ok! MaxLen is specified with a type annotation\n    ///     let v1: BoundedVec<Field, 3> = BoundedVec::new();\n    ///     let v2 = BoundedVec::new();\n    ///\n    ///     // Ok! MaxLen is known from the type of `good`'s return value\n    ///     v2\n    /// }\n    ///\n    /// fn bad() {\n    ///     // Error: Type annotation needed\n    ///     // The compiler can't infer `MaxLen` from the following code:\n    ///     let mut v3 = BoundedVec::new();\n    ///     v3.push(5);\n    /// }\n    /// ```\n    ///\n    /// This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions\n    /// but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a\n    /// constraint failure at runtime when the vec is pushed to.\n    pub fn new() -> Self {\n        let zeroed = crate::mem::zeroed();\n        BoundedVec { storage: [zeroed; MaxLen], len: 0 }\n    }\n\n    /// Retrieves an element from the vector at the given index, starting from zero.\n    ///\n    /// If the given index is equal to or greater than the length of the vector, this\n    /// will issue a constraint failure.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn foo<let N: u32>(v: BoundedVec<u32, N>) {\n    ///     let first = v.get(0);\n    ///     let last = v.get(v.len() - 1);\n    ///     assert(first != last);\n    /// }\n    /// ```\n    pub fn get(self, index: u32) -> T {\n        assert(index < self.len, \"Attempted to read past end of BoundedVec\");\n        self.get_unchecked(index)\n    }\n\n    /// Retrieves an element from the vector at the given index, starting from zero, without\n    /// performing a bounds check.\n    ///\n    /// Since this function does not perform a bounds check on length before accessing the element,\n    /// it is unsafe! Use at your own risk!\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn sum_of_first_three<let N: u32>(v: BoundedVec<u32, N>) -> u32 {\n    ///     // Always ensure the length is larger than the largest\n    ///     // index passed to get_unchecked\n    ///     assert(v.len() > 2);\n    ///     let first = v.get_unchecked(0);\n    ///     let second = v.get_unchecked(1);\n    ///     let third = v.get_unchecked(2);\n    ///     first + second + third\n    /// }\n    /// ```\n    pub fn get_unchecked(self, index: u32) -> T {\n        self.storage[index]\n    }\n\n    /// Writes an element to the vector at the given index, starting from zero.\n    ///\n    /// If the given index is equal to or greater than the length of the vector, this will issue a constraint failure.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn foo<let N: u32>(v: BoundedVec<u32, N>) {\n    ///     let first = v.get(0);\n    ///     assert(first != 42);\n    ///     v.set(0, 42);\n    ///     let new_first = v.get(0);\n    ///     assert(new_first == 42);\n    /// }\n    /// ```\n    pub fn set(&mut self, index: u32, value: T) {\n        assert(index < self.len, \"Attempted to write past end of BoundedVec\");\n        self.set_unchecked(index, value)\n    }\n\n    /// Writes an element to the vector at the given index, starting from zero, without performing a bounds check.\n    ///\n    /// Since this function does not perform a bounds check on length before accessing the element, it is unsafe! Use at your own risk!\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn set_unchecked_example() {\n    ///     let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n    ///     vec.extend_from_array([1, 2]);\n    ///\n    ///     // Here we're safely writing within the valid range of `vec`\n    ///     // `vec` now has the value [42, 2]\n    ///     vec.set_unchecked(0, 42);\n    ///\n    ///     // We can then safely read this value back out of `vec`.\n    ///     // Notice that we use the checked version of `get` which would prevent reading unsafe values.\n    ///     assert_eq(vec.get(0), 42);\n    ///\n    ///     // We've now written past the end of `vec`.\n    ///     // As this index is still within the maximum potential length of `v`,\n    ///     // it won't cause a constraint failure.\n    ///     vec.set_unchecked(2, 42);\n    ///     println(vec);\n    ///\n    ///     // This will write past the end of the maximum potential length of `vec`,\n    ///     // it will then trigger a constraint failure.\n    ///     vec.set_unchecked(5, 42);\n    ///     println(vec);\n    /// }\n    /// ```\n    pub fn set_unchecked(&mut self, index: u32, value: T) {\n        self.storage[index] = value;\n    }\n\n    /// Pushes an element to the end of the vector. This increases the length\n    /// of the vector by one.\n    ///\n    /// Panics if the new length of the vector will be greater than the max length.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 2> = BoundedVec::new();\n    ///\n    /// v.push(1);\n    /// v.push(2);\n    ///\n    /// // Panics with failed assertion \"push out of bounds\"\n    /// v.push(3);\n    /// ```\n    pub fn push(&mut self, elem: T) {\n        assert(self.len < MaxLen, \"push out of bounds\");\n\n        self.storage[self.len] = elem;\n        self.len += 1;\n    }\n\n    /// Returns the current length of this vector\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 4> = BoundedVec::new();\n    /// assert(v.len() == 0);\n    ///\n    /// v.push(100);\n    /// assert(v.len() == 1);\n    ///\n    /// v.push(200);\n    /// v.push(300);\n    /// v.push(400);\n    /// assert(v.len() == 4);\n    ///\n    /// let _ = v.pop();\n    /// let _ = v.pop();\n    /// assert(v.len() == 2);\n    /// ```\n    pub fn len(self) -> u32 {\n        self.len\n    }\n\n    /// Returns the maximum length of this vector. This is always\n    /// equal to the `MaxLen` parameter this vector was initialized with.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 5> = BoundedVec::new();\n    ///\n    /// assert(v.max_len() == 5);\n    /// v.push(10);\n    /// assert(v.max_len() == 5);\n    /// ```\n    pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u32 {\n        MaxLen\n    }\n\n    /// Returns the internal array within this vector.\n    ///\n    /// Since arrays in Noir are immutable, mutating the returned storage array will not mutate\n    /// the storage held internally by this vector.\n    ///\n    /// Note that uninitialized elements may be zeroed out!\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 5> = BoundedVec::new();\n    ///\n    /// assert(v.storage() == [0, 0, 0, 0, 0]);\n    ///\n    /// v.push(57);\n    /// assert(v.storage() == [57, 0, 0, 0, 0]);\n    /// ```\n    pub fn storage(self) -> [T; MaxLen] {\n        self.storage\n    }\n\n    /// Pushes each element from the given array to this vector.\n    ///\n    /// Panics if pushing each element would cause the length of this vector\n    /// to exceed the maximum length.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut vec: BoundedVec<Field, 3> = BoundedVec::new();\n    /// vec.extend_from_array([2, 4]);\n    ///\n    /// assert(vec.len == 2);\n    /// assert(vec.get(0) == 2);\n    /// assert(vec.get(1) == 4);\n    /// ```\n    pub fn extend_from_array<let Len: u32>(&mut self, array: [T; Len]) {\n        let new_len = self.len + array.len();\n        assert(new_len <= MaxLen, \"extend_from_array out of bounds\");\n        for i in 0..array.len() {\n            self.storage[self.len + i] = array[i];\n        }\n        self.len = new_len;\n    }\n\n    /// Pushes each element from the given slice to this vector.\n    ///\n    /// Panics if pushing each element would cause the length of this vector\n    /// to exceed the maximum length.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut vec: BoundedVec<Field, 3> = BoundedVec::new();\n    /// vec.extend_from_slice(&[2, 4]);\n    ///\n    /// assert(vec.len == 2);\n    /// assert(vec.get(0) == 2);\n    /// assert(vec.get(1) == 4);\n    /// ```\n    pub fn extend_from_slice(&mut self, slice: [T]) {\n        let new_len = self.len + slice.len();\n        assert(new_len <= MaxLen, \"extend_from_slice out of bounds\");\n        for i in 0..slice.len() {\n            self.storage[self.len + i] = slice[i];\n        }\n        self.len = new_len;\n    }\n\n    /// Pushes each element from the other vector to this vector. The length of\n    /// the other vector is left unchanged.\n    ///\n    /// Panics if pushing each element would cause the length of this vector\n    /// to exceed the maximum length.\n    ///\n    /// ```noir\n    /// let mut v1: BoundedVec<Field, 5> = BoundedVec::new();\n    /// let mut v2: BoundedVec<Field, 7> = BoundedVec::new();\n    ///\n    /// v2.extend_from_array([1, 2, 3]);\n    /// v1.extend_from_bounded_vec(v2);\n    ///\n    /// assert(v1.storage() == [1, 2, 3, 0, 0]);\n    /// assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);\n    /// ```\n    pub fn extend_from_bounded_vec<let Len: u32>(&mut self, vec: BoundedVec<T, Len>) {\n        let append_len = vec.len();\n        let new_len = self.len + append_len;\n        assert(new_len <= MaxLen, \"extend_from_bounded_vec out of bounds\");\n\n        if is_unconstrained() {\n            for i in 0..append_len {\n                self.storage[self.len + i] = vec.get_unchecked(i);\n            }\n        } else {\n            let mut exceeded_len = false;\n            for i in 0..Len {\n                exceeded_len |= i == append_len;\n                if !exceeded_len {\n                    self.storage[self.len + i] = vec.get_unchecked(i);\n                }\n            }\n        }\n        self.len = new_len;\n    }\n\n    /// Creates a new vector, populating it with values derived from an array input.\n    /// The maximum length of the vector is determined based on the type signature.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array([1, 2, 3])\n    /// ```\n    pub fn from_array<let Len: u32>(array: [T; Len]) -> Self {\n        static_assert(Len <= MaxLen, \"from array out of bounds\");\n        let mut vec: BoundedVec<T, MaxLen> = BoundedVec::new();\n        vec.extend_from_array(array);\n        vec\n    }\n\n    /// Pops the element at the end of the vector. This will decrease the length\n    /// of the vector by one.\n    ///\n    /// Panics if the vector is empty.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 2> = BoundedVec::new();\n    /// v.push(1);\n    /// v.push(2);\n    ///\n    /// let two = v.pop();\n    /// let one = v.pop();\n    ///\n    /// assert(two == 2);\n    /// assert(one == 1);\n    ///\n    /// // error: cannot pop from an empty vector\n    /// let _ = v.pop();\n    /// ```\n    pub fn pop(&mut self) -> T {\n        assert(self.len > 0, \"cannot pop from an empty vector\");\n        self.len -= 1;\n\n        let elem = self.storage[self.len];\n        self.storage[self.len] = crate::mem::zeroed();\n        elem\n    }\n\n    /// Returns true if the given predicate returns true for any element\n    /// in this vector.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<u32, 3> = BoundedVec::new();\n    /// v.extend_from_array([2, 4, 6]);\n    ///\n    /// let all_even = !v.any(|elem: u32| elem % 2 != 0);\n    /// assert(all_even);\n    /// ```\n    pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n        let mut ret = false;\n        if is_unconstrained() {\n            for i in 0..self.len {\n                ret |= predicate(self.storage[i]);\n            }\n        } else {\n            let mut exceeded_len = false;\n            for i in 0..MaxLen {\n                exceeded_len |= i == self.len;\n                if !exceeded_len {\n                    ret |= predicate(self.storage[i]);\n                }\n            }\n        }\n        ret\n    }\n\n    /// Creates a new vector of equal size by calling a closure on each element in this vector.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n    /// let result = vec.map(|value| value * 2);\n    ///\n    /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n    /// assert_eq(result, expected);\n    /// ```\n    pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> BoundedVec<U, MaxLen> {\n        let mut ret = BoundedVec::new();\n        ret.len = self.len();\n\n        if is_unconstrained() {\n            for i in 0..self.len() {\n                ret.storage[i] = f(self.get_unchecked(i));\n            }\n        } else {\n            for i in 0..MaxLen {\n                if i < self.len() {\n                    ret.storage[i] = f(self.get_unchecked(i));\n                }\n            }\n        }\n\n        ret\n    }\n\n    /// Creates a new vector of equal size by calling a closure on each element\n    /// in this vector, along with its index.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n    /// let result = vec.mapi(|i, value| i + value * 2);\n    ///\n    /// let expected = BoundedVec::from_array([2, 5, 8, 11]);\n    /// assert_eq(result, expected);\n    /// ```\n    pub fn mapi<U, Env>(self, f: fn[Env](u32, T) -> U) -> BoundedVec<U, MaxLen> {\n        let mut ret = BoundedVec::new();\n        ret.len = self.len();\n\n        if is_unconstrained() {\n            for i in 0..self.len() {\n                ret.storage[i] = f(i, self.get_unchecked(i));\n            }\n        } else {\n            for i in 0..MaxLen {\n                if i < self.len() {\n                    ret.storage[i] = f(i, self.get_unchecked(i));\n                }\n            }\n        }\n\n        ret\n    }\n\n    /// Calls a closure on each element in this vector.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n    /// let mut result = BoundedVec::<u32, 4>::new();\n    /// vec.for_each(|value| result.push(value * 2));\n    ///\n    /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n    /// assert_eq(result, expected);\n    /// ```\n    pub fn for_each<Env>(self, f: fn[Env](T) -> ()) {\n        if is_unconstrained() {\n            for i in 0..self.len() {\n                f(self.get_unchecked(i));\n            }\n        } else {\n            for i in 0..MaxLen {\n                if i < self.len() {\n                    f(self.get_unchecked(i));\n                }\n            }\n        }\n    }\n\n    /// Calls a closure on each element in this vector, along with its index.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n    /// let mut result = BoundedVec::<u32, 4>::new();\n    /// vec.for_eachi(|i, value| result.push(i + value * 2));\n    ///\n    /// let expected = BoundedVec::from_array([2, 5, 8, 11]);\n    /// assert_eq(result, expected);\n    /// ```\n    pub fn for_eachi<Env>(self, f: fn[Env](u32, T) -> ()) {\n        if is_unconstrained() {\n            for i in 0..self.len() {\n                f(i, self.get_unchecked(i));\n            }\n        } else {\n            for i in 0..MaxLen {\n                if i < self.len() {\n                    f(i, self.get_unchecked(i));\n                }\n            }\n        }\n    }\n\n    /// Creates a new BoundedVec from the given array and length.\n    /// The given length must be less than or equal to the length of the array.\n    ///\n    /// This function will zero out any elements at or past index `len` of `array`.\n    /// This incurs an extra runtime cost of O(MaxLen). If you are sure your array is\n    /// zeroed after that index, you can use `from_parts_unchecked` to remove the extra loop.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 0], 3);\n    /// assert_eq(vec.len(), 3);\n    /// ```\n    pub fn from_parts(mut array: [T; MaxLen], len: u32) -> Self {\n        assert(len <= MaxLen);\n        let zeroed = crate::mem::zeroed();\n\n        if is_unconstrained() {\n            for i in len..MaxLen {\n                array[i] = zeroed;\n            }\n        } else {\n            for i in 0..MaxLen {\n                if i >= len {\n                    array[i] = zeroed;\n                }\n            }\n        }\n\n        BoundedVec { storage: array, len }\n    }\n\n    /// Creates a new BoundedVec from the given array and length.\n    /// The given length must be less than or equal to the length of the array.\n    ///\n    /// This function is unsafe because it expects all elements past the `len` index\n    /// of `array` to be zeroed, but does not check for this internally. Use `from_parts`\n    /// for a safe version of this function which does zero out any indices past the\n    /// given length. Invalidating this assumption can notably cause `BoundedVec::eq`\n    /// to give incorrect results since it will check even elements past `len`.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n    /// assert_eq(vec.len(), 3);\n    ///\n    /// // invalid use!\n    /// let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n    /// let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n    ///\n    /// // both vecs have length 3 so we'd expect them to be equal, but this\n    /// // fails because elements past the length are still checked in eq\n    /// assert_eq(vec1, vec2); // fails\n    /// ```\n    pub fn from_parts_unchecked(array: [T; MaxLen], len: u32) -> Self {\n        assert(len <= MaxLen);\n        BoundedVec { storage: array, len }\n    }\n}\n\nimpl<T, let MaxLen: u32> Eq for BoundedVec<T, MaxLen>\nwhere\n    T: Eq,\n{\n    fn eq(self, other: BoundedVec<T, MaxLen>) -> bool {\n        // TODO: https://github.com/noir-lang/noir/issues/4837\n        //\n        // We make the assumption that the user has used the proper interface for working with `BoundedVec`s\n        // rather than directly manipulating the internal fields as this can result in an inconsistent internal state.\n        if self.len == other.len {\n            self.storage == other.storage\n        } else {\n            false\n        }\n    }\n}\n\nimpl<T, let MaxLen: u32, let Len: u32> From<[T; Len]> for BoundedVec<T, MaxLen> {\n    fn from(array: [T; Len]) -> BoundedVec<T, MaxLen> {\n        BoundedVec::from_array(array)\n    }\n}\n\nmod bounded_vec_tests {\n\n    mod get {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test(should_fail_with = \"Attempted to read past end of BoundedVec\")]\n        fn panics_when_reading_elements_past_end_of_vec() {\n            let vec: BoundedVec<Field, 5> = BoundedVec::new();\n\n            let _ = vec.get(0);\n        }\n\n        #[test(should_fail_with = \"Attempted to read past end of BoundedVec\")]\n        fn panics_when_reading_beyond_length() {\n            let vec: BoundedVec<u32, 5> = BoundedVec::from_array([1, 2, 3]);\n            let _ = vec.get(3);\n        }\n\n        #[test]\n        fn get_works_within_bounds() {\n            let vec: BoundedVec<u32, 5> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n            assert_eq(vec.get(0), 1);\n            assert_eq(vec.get(2), 3);\n            assert_eq(vec.get(4), 5);\n        }\n\n        #[test]\n        fn get_unchecked_works() {\n            let vec: BoundedVec<u32, 5> = BoundedVec::from_array([1, 2, 3]);\n            assert_eq(vec.get_unchecked(0), 1);\n            assert_eq(vec.get_unchecked(2), 3);\n        }\n\n        #[test]\n        fn get_unchecked_works_past_len() {\n            let vec: BoundedVec<u32, 5> = BoundedVec::from_array([1, 2, 3]);\n            assert_eq(vec.get_unchecked(4), 0);\n        }\n    }\n\n    mod set {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn set_updates_values_properly() {\n            let mut vec = BoundedVec::from_array([0, 0, 0, 0, 0]);\n\n            vec.set(0, 42);\n            assert_eq(vec.storage, [42, 0, 0, 0, 0]);\n\n            vec.set(1, 43);\n            assert_eq(vec.storage, [42, 43, 0, 0, 0]);\n\n            vec.set(2, 44);\n            assert_eq(vec.storage, [42, 43, 44, 0, 0]);\n\n            vec.set(1, 10);\n            assert_eq(vec.storage, [42, 10, 44, 0, 0]);\n\n            vec.set(0, 0);\n            assert_eq(vec.storage, [0, 10, 44, 0, 0]);\n        }\n\n        #[test(should_fail_with = \"Attempted to write past end of BoundedVec\")]\n        fn panics_when_writing_elements_past_end_of_vec() {\n            let mut vec: BoundedVec<Field, 5> = BoundedVec::new();\n            vec.set(0, 42);\n        }\n\n        #[test(should_fail_with = \"Attempted to write past end of BoundedVec\")]\n        fn panics_when_setting_beyond_length() {\n            let mut vec: BoundedVec<u32, 5> = BoundedVec::from_array([1, 2, 3]);\n            vec.set(3, 4);\n        }\n\n        #[test]\n        fn set_unchecked_operations() {\n            let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n            vec.push(1);\n            vec.push(2);\n\n            vec.set_unchecked(0, 10);\n            assert_eq(vec.get(0), 10);\n        }\n\n        #[test(should_fail_with = \"Attempted to read past end of BoundedVec\")]\n        fn set_unchecked_operations_past_len() {\n            let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n            vec.push(1);\n            vec.push(2);\n\n            vec.set_unchecked(3, 40);\n            assert_eq(vec.get(3), 40);\n        }\n\n        #[test]\n        fn set_preserves_other_elements() {\n            let mut vec: BoundedVec<u32, 5> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n\n            vec.set(2, 30);\n            assert_eq(vec.get(0), 1);\n            assert_eq(vec.get(1), 2);\n            assert_eq(vec.get(2), 30);\n            assert_eq(vec.get(3), 4);\n            assert_eq(vec.get(4), 5);\n        }\n    }\n\n    mod any {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn returns_false_if_predicate_not_satisfied() {\n            let vec: BoundedVec<bool, 4> = BoundedVec::from_array([false, false, false, false]);\n            let result = vec.any(|value| value);\n\n            assert(!result);\n        }\n\n        #[test]\n        fn returns_true_if_predicate_satisfied() {\n            let vec: BoundedVec<bool, 4> = BoundedVec::from_array([false, false, true, true]);\n            let result = vec.any(|value| value);\n\n            assert(result);\n        }\n\n        #[test]\n        fn returns_false_on_empty_boundedvec() {\n            let vec: BoundedVec<bool, 0> = BoundedVec::new();\n            let result = vec.any(|value| value);\n\n            assert(!result);\n        }\n\n        #[test]\n        fn any_with_complex_predicates() {\n            let vec: BoundedVec<u32, 5> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n\n            assert(vec.any(|x| x > 3));\n            assert(!vec.any(|x| x > 10));\n            assert(vec.any(|x| x % 2 == 0)); // has a even number\n            assert(vec.any(|x| x == 3)); // has a specific value\n        }\n\n        #[test]\n        fn any_with_partial_vector() {\n            let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n            vec.push(1);\n            vec.push(2);\n\n            assert(vec.any(|x| x == 1));\n            assert(vec.any(|x| x == 2));\n            assert(!vec.any(|x| x == 3));\n        }\n    }\n\n    mod map {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn applies_function_correctly() {\n            // docs:start:bounded-vec-map-example\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = vec.map(|value| value * 2);\n            // docs:end:bounded-vec-map-example\n            let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn applies_function_that_changes_return_type() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = vec.map(|value| (value * 2) as Field);\n            let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 4, 6, 8]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn does_not_apply_function_past_len() {\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n            let result = vec.map(|value| if value == 0 { 5 } else { value });\n            let expected = BoundedVec::from_array([5, 1]);\n\n            assert_eq(result, expected);\n            assert_eq(result.get_unchecked(2), 0);\n        }\n\n        #[test]\n        fn map_with_conditional_logic() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n\n            let result = vec.map(|x| if x % 2 == 0 { x * 2 } else { x });\n            let expected = BoundedVec::from_array([1, 4, 3, 8]);\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn map_preserves_length() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = vec.map(|x| x * 2);\n\n            assert_eq(result.len(), vec.len());\n            assert_eq(result.max_len(), vec.max_len());\n        }\n\n        #[test]\n        fn map_on_empty_vector() {\n            let vec: BoundedVec<u32, 5> = BoundedVec::new();\n            let result = vec.map(|x| x * 2);\n            assert_eq(result, vec);\n            assert_eq(result.len(), 0);\n            assert_eq(result.max_len(), 5);\n        }\n    }\n\n    mod mapi {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn applies_function_correctly() {\n            // docs:start:bounded-vec-mapi-example\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = vec.mapi(|i, value| i + value * 2);\n            // docs:end:bounded-vec-mapi-example\n            let expected = BoundedVec::from_array([2, 5, 8, 11]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn applies_function_that_changes_return_type() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = vec.mapi(|i, value| (i + value * 2) as Field);\n            let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 5, 8, 11]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn does_not_apply_function_past_len() {\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n            let result = vec.mapi(|_, value| if value == 0 { 5 } else { value });\n            let expected = BoundedVec::from_array([5, 1]);\n\n            assert_eq(result, expected);\n            assert_eq(result.get_unchecked(2), 0);\n        }\n\n        #[test]\n        fn mapi_with_index_branching_logic() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n\n            let result = vec.mapi(|i, x| if i % 2 == 0 { x * 2 } else { x });\n            let expected = BoundedVec::from_array([2, 2, 6, 4]);\n            assert_eq(result, expected);\n        }\n    }\n\n    mod for_each {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        // map in terms of for_each\n        fn for_each_map<T, U, Env, let MaxLen: u32>(\n            input: BoundedVec<T, MaxLen>,\n            f: fn[Env](T) -> U,\n        ) -> BoundedVec<U, MaxLen> {\n            let mut output = BoundedVec::<U, MaxLen>::new();\n            let output_ref = &mut output;\n            input.for_each(|x| output_ref.push(f(x)));\n            output\n        }\n\n        #[test]\n        fn smoke_test() {\n            let mut acc = 0;\n            let acc_ref = &mut acc;\n            // docs:start:bounded-vec-for-each-example\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([1, 2, 3]);\n            vec.for_each(|value| { *acc_ref += value; });\n            // docs:end:bounded-vec-for-each-example\n            assert_eq(acc, 6);\n        }\n\n        #[test]\n        fn applies_function_correctly() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = for_each_map(vec, |value| value * 2);\n            let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn applies_function_that_changes_return_type() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = for_each_map(vec, |value| (value * 2) as Field);\n            let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 4, 6, 8]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn does_not_apply_function_past_len() {\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n            let result = for_each_map(vec, |value| if value == 0 { 5 } else { value });\n            let expected = BoundedVec::from_array([5, 1]);\n\n            assert_eq(result, expected);\n            assert_eq(result.get_unchecked(2), 0);\n        }\n\n        #[test]\n        fn for_each_on_empty_vector() {\n            let vec: BoundedVec<u32, 5> = BoundedVec::new();\n            let mut count = 0;\n            let count_ref = &mut count;\n            vec.for_each(|_| { *count_ref += 1; });\n            assert_eq(count, 0);\n        }\n\n        #[test]\n        fn for_each_with_side_effects() {\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([1, 2, 3]);\n            let mut seen = BoundedVec::<u32, 3>::new();\n            let seen_ref = &mut seen;\n            vec.for_each(|x| seen_ref.push(x));\n            assert_eq(seen, vec);\n        }\n    }\n\n    mod for_eachi {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        // mapi in terms of for_eachi\n        fn for_eachi_mapi<T, U, Env, let MaxLen: u32>(\n            input: BoundedVec<T, MaxLen>,\n            f: fn[Env](u32, T) -> U,\n        ) -> BoundedVec<U, MaxLen> {\n            let mut output = BoundedVec::<U, MaxLen>::new();\n            let output_ref = &mut output;\n            input.for_eachi(|i, x| output_ref.push(f(i, x)));\n            output\n        }\n\n        #[test]\n        fn smoke_test() {\n            let mut acc = 0;\n            let acc_ref = &mut acc;\n            // docs:start:bounded-vec-for-eachi-example\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([1, 2, 3]);\n            vec.for_eachi(|i, value| { *acc_ref += i * value; });\n            // docs:end:bounded-vec-for-eachi-example\n\n            // 0 * 1 + 1 * 2 + 2 * 3\n            assert_eq(acc, 8);\n        }\n\n        #[test]\n        fn applies_function_correctly() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = for_eachi_mapi(vec, |i, value| i + value * 2);\n            let expected = BoundedVec::from_array([2, 5, 8, 11]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn applies_function_that_changes_return_type() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = for_eachi_mapi(vec, |i, value| (i + value * 2) as Field);\n            let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 5, 8, 11]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn does_not_apply_function_past_len() {\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n            let result = for_eachi_mapi(vec, |_, value| if value == 0 { 5 } else { value });\n            let expected = BoundedVec::from_array([5, 1]);\n\n            assert_eq(result, expected);\n            assert_eq(result.get_unchecked(2), 0);\n        }\n\n        #[test]\n        fn for_eachi_on_empty_vector() {\n            let vec: BoundedVec<u32, 5> = BoundedVec::new();\n            let mut count = 0;\n            let count_ref = &mut count;\n            vec.for_eachi(|_, _| { *count_ref += 1; });\n            assert_eq(count, 0);\n        }\n\n        #[test]\n        fn for_eachi_with_index_tracking() {\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([10, 20, 30]);\n            let mut indices = BoundedVec::<u32, 3>::new();\n            let indices_ref = &mut indices;\n            vec.for_eachi(|i, _| indices_ref.push(i));\n\n            let expected = BoundedVec::from_array([0, 1, 2]);\n            assert_eq(indices, expected);\n        }\n\n    }\n\n    mod from_array {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn empty() {\n            let empty_array: [Field; 0] = [];\n            let bounded_vec = BoundedVec::from_array([]);\n\n            assert_eq(bounded_vec.max_len(), 0);\n            assert_eq(bounded_vec.len(), 0);\n            assert_eq(bounded_vec.storage(), empty_array);\n        }\n\n        #[test]\n        fn equal_len() {\n            let array = [1, 2, 3];\n            let bounded_vec = BoundedVec::from_array(array);\n\n            assert_eq(bounded_vec.max_len(), 3);\n            assert_eq(bounded_vec.len(), 3);\n            assert_eq(bounded_vec.storage(), array);\n        }\n\n        #[test]\n        fn max_len_greater_then_array_len() {\n            let array = [1, 2, 3];\n            let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array(array);\n\n            assert_eq(bounded_vec.max_len(), 10);\n            assert_eq(bounded_vec.len(), 3);\n            assert_eq(bounded_vec.get(0), 1);\n            assert_eq(bounded_vec.get(1), 2);\n            assert_eq(bounded_vec.get(2), 3);\n        }\n\n        #[test(should_fail_with = \"from array out of bounds\")]\n        fn max_len_lower_then_array_len() {\n            let _: BoundedVec<Field, 2> = BoundedVec::from_array([0; 3]);\n        }\n\n        #[test]\n        fn from_array_preserves_order() {\n            let array = [5, 3, 1, 4, 2];\n            let vec: BoundedVec<u32, 5> = BoundedVec::from_array(array);\n            for i in 0..array.len() {\n                assert_eq(vec.get(i), array[i]);\n            }\n        }\n\n        #[test]\n        fn from_array_with_different_types() {\n            let bool_array = [true, false, true];\n            let bool_vec: BoundedVec<bool, 3> = BoundedVec::from_array(bool_array);\n            assert_eq(bool_vec.len(), 3);\n            assert_eq(bool_vec.get(0), true);\n            assert_eq(bool_vec.get(1), false);\n        }\n    }\n\n    mod trait_from {\n        use crate::collections::bounded_vec::BoundedVec;\n        use crate::convert::From;\n\n        #[test]\n        fn simple() {\n            let array = [1, 2];\n            let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from(array);\n\n            assert_eq(bounded_vec.max_len(), 10);\n            assert_eq(bounded_vec.len(), 2);\n            assert_eq(bounded_vec.get(0), 1);\n            assert_eq(bounded_vec.get(1), 2);\n        }\n    }\n\n    mod trait_eq {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn empty_equality() {\n            let mut bounded_vec1: BoundedVec<Field, 3> = BoundedVec::new();\n            let mut bounded_vec2: BoundedVec<Field, 3> = BoundedVec::new();\n\n            assert_eq(bounded_vec1, bounded_vec2);\n        }\n\n        #[test]\n        fn inequality() {\n            let mut bounded_vec1: BoundedVec<Field, 3> = BoundedVec::new();\n            let mut bounded_vec2: BoundedVec<Field, 3> = BoundedVec::new();\n            bounded_vec1.push(1);\n            bounded_vec2.push(2);\n\n            assert(bounded_vec1 != bounded_vec2);\n        }\n    }\n\n    mod from_parts {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn from_parts() {\n            // docs:start:from-parts\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 0], 3);\n            assert_eq(vec.len(), 3);\n\n            // Any elements past the given length are zeroed out, so these\n            // two BoundedVecs will be completely equal\n            let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 1], 3);\n            let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 2], 3);\n            assert_eq(vec1, vec2);\n            // docs:end:from-parts\n        }\n\n        #[test]\n        fn from_parts_unchecked() {\n            // docs:start:from-parts-unchecked\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n            assert_eq(vec.len(), 3);\n\n            // invalid use!\n            let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n            let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n\n            // both vecs have length 3 so we'd expect them to be equal, but this\n            // fails because elements past the length are still checked in eq\n            assert(vec1 != vec2);\n            // docs:end:from-parts-unchecked\n        }\n    }\n\n    mod push_pop {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn push_and_pop_operations() {\n            let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n\n            assert_eq(vec.len(), 0);\n\n            vec.push(1);\n            assert_eq(vec.len(), 1);\n            assert_eq(vec.get(0), 1);\n\n            vec.push(2);\n            assert_eq(vec.len(), 2);\n            assert_eq(vec.get(1), 2);\n\n            let popped = vec.pop();\n            assert_eq(popped, 2);\n            assert_eq(vec.len(), 1);\n\n            let popped2 = vec.pop();\n            assert_eq(popped2, 1);\n            assert_eq(vec.len(), 0);\n        }\n\n        #[test(should_fail_with = \"push out of bounds\")]\n        fn push_to_full_vector() {\n            let mut vec: BoundedVec<u32, 2> = BoundedVec::new();\n            vec.push(1);\n            vec.push(2);\n            vec.push(3); // should panic\n        }\n\n        #[test(should_fail_with = \"cannot pop from an empty vector\")]\n        fn pop_from_empty_vector() {\n            let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n            let _ = vec.pop(); // should panic\n        }\n\n        #[test]\n        fn push_pop_cycle() {\n            let mut vec: BoundedVec<u32, 3> = BoundedVec::new();\n\n            // push to full\n            vec.push(1);\n            vec.push(2);\n            vec.push(3);\n            assert_eq(vec.len(), 3);\n\n            // pop all\n            assert_eq(vec.pop(), 3);\n            assert_eq(vec.pop(), 2);\n            assert_eq(vec.pop(), 1);\n            assert_eq(vec.len(), 0);\n\n            // push again\n            vec.push(4);\n            assert_eq(vec.len(), 1);\n            assert_eq(vec.get(0), 4);\n        }\n    }\n\n    mod extend {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn extend_from_array() {\n            let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n            vec.push(1);\n            vec.extend_from_array([2, 3]);\n\n            assert_eq(vec.len(), 3);\n            assert_eq(vec.get(0), 1);\n            assert_eq(vec.get(1), 2);\n            assert_eq(vec.get(2), 3);\n        }\n\n        #[test]\n        fn extend_from_slice() {\n            let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n            vec.push(1);\n            vec.extend_from_slice(&[2, 3]);\n\n            assert_eq(vec.len(), 3);\n            assert_eq(vec.get(0), 1);\n            assert_eq(vec.get(1), 2);\n            assert_eq(vec.get(2), 3);\n        }\n\n        #[test]\n        fn extend_from_bounded_vec() {\n            let mut vec1: BoundedVec<u32, 5> = BoundedVec::new();\n            let mut vec2: BoundedVec<u32, 3> = BoundedVec::new();\n\n            vec1.push(1);\n            vec2.push(2);\n            vec2.push(3);\n\n            vec1.extend_from_bounded_vec(vec2);\n\n            assert_eq(vec1.len(), 3);\n            assert_eq(vec1.get(0), 1);\n            assert_eq(vec1.get(1), 2);\n            assert_eq(vec1.get(2), 3);\n        }\n\n        #[test(should_fail_with = \"extend_from_array out of bounds\")]\n        fn extend_array_beyond_max_len() {\n            let mut vec: BoundedVec<u32, 3> = BoundedVec::new();\n            vec.push(1);\n            vec.extend_from_array([2, 3, 4]); // should panic\n        }\n\n        #[test(should_fail_with = \"extend_from_slice out of bounds\")]\n        fn extend_slice_beyond_max_len() {\n            let mut vec: BoundedVec<u32, 3> = BoundedVec::new();\n            vec.push(1);\n            vec.extend_from_slice(&[2, 3, 4]); // S]should panic\n        }\n\n        #[test(should_fail_with = \"extend_from_bounded_vec out of bounds\")]\n        fn extend_bounded_vec_beyond_max_len() {\n            let mut vec: BoundedVec<u32, 3> = BoundedVec::new();\n            let other: BoundedVec<u32, 5> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n            vec.extend_from_bounded_vec(other); // should panic\n        }\n\n        #[test]\n        fn extend_with_empty_collections() {\n            let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n            let original_len = vec.len();\n\n            vec.extend_from_array([]);\n            assert_eq(vec.len(), original_len);\n\n            vec.extend_from_slice(&[]);\n            assert_eq(vec.len(), original_len);\n\n            let empty: BoundedVec<u32, 3> = BoundedVec::new();\n            vec.extend_from_bounded_vec(empty);\n            assert_eq(vec.len(), original_len);\n        }\n    }\n\n    mod storage {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn storage_consistency() {\n            let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n\n            // test initial storage state\n            assert_eq(vec.storage(), [0, 0, 0, 0, 0]);\n\n            vec.push(1);\n            vec.push(2);\n\n            // test storage after modifications\n            assert_eq(vec.storage(), [1, 2, 0, 0, 0]);\n\n            // storage doesn't change length\n            assert_eq(vec.len(), 2);\n            assert_eq(vec.max_len(), 5);\n        }\n\n        #[test]\n        fn storage_after_pop() {\n            let mut vec: BoundedVec<u32, 3> = BoundedVec::from_array([1, 2, 3]);\n\n            let _ = vec.pop();\n            // after pop, the last element should be zeroed\n            assert_eq(vec.storage(), [1, 2, 0]);\n            assert_eq(vec.len(), 2);\n        }\n\n        #[test]\n        fn vector_immutable() {\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([1, 2, 3]);\n            let storage = vec.storage();\n\n            assert_eq(storage, [1, 2, 3]);\n\n            // Verify that the original vector is unchanged\n            assert_eq(vec.len(), 3);\n            assert_eq(vec.get(0), 1);\n            assert_eq(vec.get(1), 2);\n            assert_eq(vec.get(2), 3);\n        }\n    }\n}\n"
     },
-    "61": {
+    "62": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/capsules/mod.nr",
       "source": "use crate::oracle::capsules;\nuse protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// A dynamically sized array backed by PXE's non-volatile database (called capsules). Values are persisted until\n/// deleted, so they can be e.g. stored during simulation of a transaction and later retrieved during witness\n/// generation. All values are scoped per contract address, so external contracts cannot access them.\npub struct CapsuleArray<T> {\n    contract_address: AztecAddress,\n    /// The base slot is where the array length is stored in capsules. Array elements are stored in consecutive slots\n    /// after the base slot. For example, with base slot 5: the length is at slot 5, the first element (index 0) is at\n    /// slot 6, the second element (index 1) is at slot 7, and so on.\n    base_slot: Field,\n}\n\nimpl<T> CapsuleArray<T> {\n    /// Returns a CapsuleArray connected to a contract's capsules at a base slot. Array elements are stored in\n    /// contiguous slots following the base slot, so there should be sufficient space between array base slots to\n    /// accommodate elements. A reasonable strategy is to make the base slot a hash of a unique value.\n    pub unconstrained fn at(contract_address: AztecAddress, base_slot: Field) -> Self {\n        Self { contract_address, base_slot }\n    }\n\n    /// Returns the number of elements stored in the array.\n    pub unconstrained fn len(self) -> u32 {\n        // An uninitialized array defaults to a length of 0.\n        capsules::load(self.contract_address, self.base_slot).unwrap_or(0) as u32\n    }\n\n    /// Stores a value at the end of the array.\n    pub unconstrained fn push(self, value: T)\n    where\n        T: Serialize,\n    {\n        let current_length = self.len();\n\n        // The slot corresponding to the index `current_length` is the first slot immediately after the end of the\n        // array, which is where we want to place the new value.\n        capsules::store(self.contract_address, self.slot_at(current_length), value);\n\n        // Then we simply update the length.\n        let new_length = current_length + 1;\n        capsules::store(self.contract_address, self.base_slot, new_length);\n    }\n\n    /// Retrieves the value stored in the array at `index`. Throws if the index is out of bounds.\n    pub unconstrained fn get(self, index: u32) -> T\n    where\n        T: Deserialize,\n    {\n        assert(index < self.len(), \"Attempted to read past the length of a CapsuleArray\");\n\n        capsules::load(self.contract_address, self.slot_at(index)).unwrap()\n    }\n\n    /// Deletes the value stored in the array at `index`. Throws if the index is out of bounds.\n    pub unconstrained fn remove(self, index: u32) {\n        let current_length = self.len();\n        assert(index < current_length, \"Attempted to delete past the length of a CapsuleArray\");\n\n        // In order to be able to remove elements at arbitrary indices, we need to shift the entire contents of the\n        // array past the removed element one slot backward so that we don't end up with a gap and preserve the\n        // contiguous slots. We can skip this when deleting the last element however.\n        if index != current_length - 1 {\n            // The source and destination regions overlap, but `copy` supports this.\n            capsules::copy(\n                self.contract_address,\n                self.slot_at(index + 1),\n                self.slot_at(index),\n                current_length - index - 1,\n            );\n        }\n\n        // We can now delete the last element (which has either been copied to the slot immediately before it, or was\n        // the element we meant to delete in the first place) and update the length.\n        capsules::delete(self.contract_address, self.slot_at(current_length - 1));\n        capsules::store(self.contract_address, self.base_slot, current_length - 1);\n    }\n\n    /// Iterates over the entire array, calling the callback with all values and their array index. The order in which\n    /// values are processed is arbitrary.\n    ///\n    /// It is safe to delete the current element (and only the current element) from inside the callback via `remove`:\n    /// ```noir\n    /// array.for_each(|index, value| {\n    ///   if some_condition(value) {\n    ///     array.remove(index); // safe only for this index\n    ///   }\n    /// }\n    /// ```\n    ///\n    /// If all elements in the array need to iterated over and then removed, then using `for_each` results in optimal\n    /// efficiency.\n    ///\n    /// It is **not** safe to push new elements into the array from inside the callback.\n    pub unconstrained fn for_each<Env>(self, f: unconstrained fn[Env](u32, T) -> ())\n    where\n        T: Deserialize,\n    {\n        // Iterating over all elements is simple, but we want to do it in such a way that a) deleting the current\n        // element is safe to do, and b) deleting *all* elements is optimally efficient. This is because CapsuleArrays\n        // are typically used to hold pending tasks, so iterating them while clearing completed tasks (sometimes\n        // unconditionally, resulting in a full clear) is a very common access pattern.\n        //\n        // The way we achieve this is by iterating backwards: each element can always be deleted since it won't change\n        // any preceding (lower) indices, and if every element is deleted then every element will (in turn) be the last\n        // element. This results in an optimal full clear since `remove` will be able to skip the `capsules::copy` call\n        // to shift any elements past the deleted one (because there will be none).\n        let mut i = self.len();\n        while i > 0 {\n            i -= 1;\n            f(i, self.get(i));\n        }\n    }\n\n    unconstrained fn slot_at(self, index: u32) -> Field {\n        // Elements are stored immediately after the base slot, so we add 1 to it to compute the slot for the first\n        // element.\n        self.base_slot + 1 + index as Field\n    }\n}\n\nmod test {\n    use crate::test::helpers::test_environment::TestEnvironment;\n    use super::CapsuleArray;\n\n    global SLOT: Field = 1230;\n\n    #[test]\n    unconstrained fn empty_array() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array: CapsuleArray<Field> = CapsuleArray::at(contract_address, SLOT);\n            assert_eq(array.len(), 0);\n        });\n    }\n\n    #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n    unconstrained fn empty_array_read() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array = CapsuleArray::at(contract_address, SLOT);\n            let _: Field = array.get(0);\n        });\n    }\n\n    #[test]\n    unconstrained fn array_push() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array = CapsuleArray::at(contract_address, SLOT);\n            array.push(5);\n\n            assert_eq(array.len(), 1);\n            assert_eq(array.get(0), 5);\n        });\n    }\n\n    #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n    unconstrained fn read_past_len() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array = CapsuleArray::at(contract_address, SLOT);\n            array.push(5);\n\n            let _ = array.get(1);\n        });\n    }\n\n    #[test]\n    unconstrained fn array_remove_last() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array = CapsuleArray::at(contract_address, SLOT);\n\n            array.push(5);\n            array.remove(0);\n\n            assert_eq(array.len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn array_remove_some() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array = CapsuleArray::at(contract_address, SLOT);\n\n            array.push(7);\n            array.push(8);\n            array.push(9);\n\n            assert_eq(array.len(), 3);\n            assert_eq(array.get(0), 7);\n            assert_eq(array.get(1), 8);\n            assert_eq(array.get(2), 9);\n\n            array.remove(1);\n\n            assert_eq(array.len(), 2);\n            assert_eq(array.get(0), 7);\n            assert_eq(array.get(1), 9);\n        });\n    }\n\n    #[test]\n    unconstrained fn array_remove_all() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array = CapsuleArray::at(contract_address, SLOT);\n\n            array.push(7);\n            array.push(8);\n            array.push(9);\n\n            array.remove(1);\n            array.remove(1);\n            array.remove(0);\n\n            assert_eq(array.len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn for_each_called_with_all_elements() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let array = CapsuleArray::at(contract_address, SLOT);\n\n            array.push(4);\n            array.push(5);\n            array.push(6);\n\n            // We store all values that we were called with and check that all (value, index) tuples are present. Note that\n            // we do not care about the order in which each tuple was passed to the closure.\n            let called_with = &mut BoundedVec::<(u32, Field), 3>::new();\n            array.for_each(|index, value| { called_with.push((index, value)); });\n\n            assert_eq(called_with.len(), 3);\n            assert(called_with.any(|(index, value)| (index == 0) & (value == 4)));\n            assert(called_with.any(|(index, value)| (index == 1) & (value == 5)));\n            assert(called_with.any(|(index, value)| (index == 2) & (value == 6)));\n        });\n    }\n\n    #[test]\n    unconstrained fn for_each_remove_some() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let array = CapsuleArray::at(contract_address, SLOT);\n\n            array.push(4);\n            array.push(5);\n            array.push(6);\n\n            array.for_each(|index, _| {\n                if index == 1 {\n                    array.remove(index);\n                }\n            });\n\n            assert_eq(array.len(), 2);\n            assert_eq(array.get(0), 4);\n            assert_eq(array.get(1), 6);\n        });\n    }\n\n    #[test]\n    unconstrained fn for_each_remove_all() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let array = CapsuleArray::at(contract_address, SLOT);\n\n            array.push(4);\n            array.push(5);\n            array.push(6);\n\n            array.for_each(|index, _| { array.remove(index); });\n\n            assert_eq(array.len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn for_each_remove_all_no_copy() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let array = CapsuleArray::at(contract_address, SLOT);\n\n            array.push(4);\n            array.push(5);\n            array.push(6);\n\n            // We test that the utilityCopyCapsule was never called, which is the expensive operation we want to avoid.\n            let mock = std::test::OracleMock::mock(\"utilityCopyCapsule\");\n\n            array.for_each(|index, _| { array.remove(index); });\n\n            assert_eq(mock.times_called(), 0);\n        });\n    }\n}\n"
     },
-    "70": {
+    "71": {
       "path": "/home/aztec-dev/aztec-packages/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_U32_VALUE, NULL_MSG_SENDER_CONTRACT_ADDRESS};\nuse dep::protocol_types::traits::{Empty, FromField, Packable, Serialize, ToField};\n\n/// # PublicContext\n///\n/// The **main interface** between an #[external(\"public\")] function and the Aztec blockchain.\n///\n/// An instance of the PublicContext is initialized automatically at the outset\n/// of every public function, within the #[external(\"public\")] macro, so you'll never\n/// need to consciously instantiate this yourself.\n///\n/// The instance is always named `context`, and it will always be available\n/// within the body of every #[external(\"public\")] function in your smart contract.\n///\n/// Typical usage for a smart contract developer will be to call getter\n/// methods of the PublicContext.\n///\n/// _Pushing_ data and requests to the context is mostly handled within\n/// aztec-nr's own functions, so typically a smart contract developer won't\n/// need to call any setter methods directly.\n///\n/// ## Responsibilities\n/// - Exposes contextual data to a public function:\n///   - Data relating to how this public function was called:\n///     - msg_sender, this_address\n///   - Data relating to the current blockchain state:\n///     - timestamp, block_number, chain_id, version\n///   - Gas and fee information\n/// - Provides state access:\n///   - Read/write public storage (key-value mapping)\n///   - Check existence of notes and nullifiers\n///     (Some patterns use notes & nullifiers to store public (not private)\n///     information)\n///   - Enables consumption of L1->L2 messages.\n/// - Enables calls to other public smart contract functions:\n/// - Writes data to the blockchain:\n///   - Updates to public state variables\n///   - New public logs (for events)\n///   - New L2->L1 messages\n///   - New notes & nullifiers\n///     (E.g. pushing public info to notes/nullifiers, or for completing\n///     \"partial notes\")\n///\n/// ## Key Differences from Private Execution\n///\n/// Unlike private functions -- which are executed on the user's device and which\n/// can only reference historic state -- public functions are executed by a block\n/// proposer and are executed \"live\" on the _current_ tip of the chain.\n/// This means public functions can:\n/// - Read and write _current_ public state\n/// - Immediately see the effects of earlier transactions in the same block\n///\n/// Also, public functions are executed within a zkVM (the \"AVM\"), so that they\n/// can _revert_ whilst still ensuring payment to the proposer and prover.\n/// (Private functions cannot revert: they either succeed, or they cannot be\n/// included).\n///\n/// ## Optimising Public Functions\n///\n/// Using the AVM to execute public functions means they compile down to \"AVM\n/// bytecode\" instead of the ACIR that private functions (standalone circuits)\n/// compile to. Therefore the approach to optimising a public function is\n/// fundamentally different from optimising a public function.\n///\npub struct PublicContext {\n    pub args_hash: Option<Field>,\n    pub compute_args_hash: fn() -> Field,\n}\n\nimpl Eq for PublicContext {\n    fn eq(self, other: Self) -> bool {\n        (self.args_hash == other.args_hash)\n        // Can't compare the function compute_args_hash\n    }\n}\n\nimpl PublicContext {\n    /// Creates a new PublicContext instance.\n    ///\n    /// Low-level function: This is called automatically by the #[external(\"public\")]\n    /// macro, so you shouldn't need to be called directly by smart contract\n    /// developers.\n    ///\n    /// # Arguments\n    /// * `compute_args_hash` - Function to compute the args_hash\n    ///\n    /// # Returns\n    /// * A new PublicContext instance\n    ///\n    pub fn new(compute_args_hash: fn() -> Field) -> Self {\n        PublicContext { args_hash: Option::none(), compute_args_hash }\n    }\n\n    /// Emits a _public_ log that will be visible onchain to everyone.\n    ///\n    /// # Arguments\n    /// * `log` - The data to log, must implement Serialize trait\n    ///\n    pub fn emit_public_log<T>(_self: Self, log: T)\n    where\n        T: Serialize,\n    {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { emit_public_log(Serialize::serialize(log).as_slice()) };\n    }\n\n    /// Checks if a given note hash exists in the note hash tree at a particular\n    /// leaf_index.\n    ///\n    /// # Arguments\n    /// * `note_hash` - The note hash to check for existence\n    /// * `leaf_index` - The index where the note hash should be located\n    ///\n    /// # Returns\n    /// * `bool` - True if the note hash exists at the specified index\n    ///\n    pub fn note_hash_exists(_self: Self, note_hash: Field, leaf_index: u64) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { note_hash_exists(note_hash, leaf_index) } == 1\n    }\n\n    /// Checks if a specific L1-to-L2 message exists in the L1-to-L2 message\n    /// tree at a particular leaf index.\n    ///\n    /// Common use cases include token bridging, cross-chain governance, and\n    /// triggering L2 actions based on L1 events.\n    ///\n    /// This function should be called before attempting to consume an L1-to-L2\n    /// message.\n    ///\n    /// # Arguments\n    /// * `msg_hash` - Hash of the L1-to-L2 message to check\n    /// * `msg_leaf_index` - The index where the message should be located\n    ///\n    /// # Returns\n    /// * `bool` - True if the message exists at the specified index\n    ///\n    /// # Advanced\n    /// * Uses the AVM l1_to_l2_msg_exists opcode for tree lookup\n    /// * Messages are copied from L1 Inbox to L2 by block proposers\n    ///\n    pub fn l1_to_l2_msg_exists(_self: Self, msg_hash: Field, msg_leaf_index: Field) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        // TODO(alvaro): Make l1l2msg leaf index a u64 upstream\n        unsafe { l1_to_l2_msg_exists(msg_hash, msg_leaf_index as u64) } == 1\n    }\n\n    /// Checks if a specific nullifier has been emitted by a given contract.\n    ///\n    /// Whilst nullifiers are primarily intended as a _privacy-preserving_\n    /// record of a one-time action, they can also be used to efficiently\n    /// record _public_ one-time actions too. An example is to check\n    /// whether a contract has been published: we emit a nullifier that is\n    /// deterministic, but whose preimage is _not_ private. This is more\n    /// efficient than using mutable storage, and can be done directly\n    /// from a private function.\n    ///\n    /// Nullifiers can be tested for non-existence in public, which is not the\n    /// case in private. Because private functions do not have access to\n    /// the tip of the blockchain (but only the anchor block they are built\n    /// at) they can only prove nullifier non-existence in the past. But between\n    /// an anchor block and the block in which a tx is included, the nullifier\n    /// might have been inserted into the nullifier tree by some other\n    /// transaction.\n    /// Public functions _do_ have access to the tip of the state, and so\n    /// this pattern is safe.\n    ///\n    /// # Arguments\n    /// * `unsiloed_nullifier` - The raw nullifier value (before siloing with\n    ///                          the contract address that emitted it).\n    /// * `address` - The claimed contract address that emitted the nullifier\n    ///\n    /// # Returns\n    /// * `bool` - True if the nullifier has been emitted by the specified contract\n    ///\n    pub fn nullifier_exists(_self: Self, unsiloed_nullifier: Field, address: AztecAddress) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { nullifier_exists(unsiloed_nullifier, address.to_field()) } == 1\n    }\n\n    /// Consumes a message sent from Ethereum (L1) to Aztec (L2) -- effectively\n    /// marking it as \"read\".\n    ///\n    /// Use this function if you only want the message to ever be \"referred to\"\n    /// once. Once consumed using this method, the message cannot be consumed\n    /// again, because a nullifier is emitted.\n    /// If your use case wants for the message to be read unlimited times, then\n    /// you can always read any historic message from the L1-to-L2 messages tree,\n    /// using the `l1_to_l2_msg_exists` method. Messages never technically get\n    /// deleted from that tree.\n    ///\n    /// The message will first be inserted into an Aztec \"Inbox\" smart contract\n    /// on L1. It will not be available for consumption immediately. Messages\n    /// get copied-over from the L1 Inbox to L2 by the next Proposer in batches.\n    /// So you will need to wait until the messages are copied before you can\n    /// consume them.\n    ///\n    /// # Arguments\n    /// * `content` - The message content that was sent from L1\n    /// * `secret` - Secret value used for message privacy (if needed)\n    /// * `sender` - Ethereum address that sent the message\n    /// * `leaf_index` - Index of the message in the L1-to-L2 message tree\n    ///\n    /// # Advanced\n    /// * Validates message existence in the L1-to-L2 message tree\n    /// * Prevents double-consumption by emitting a nullifier\n    /// * Message hash is computed from all parameters + chain context\n    /// * Will revert if message doesn't exist or was already consumed\n    ///\n    pub fn consume_l1_to_l2_message(\n        self: 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    /// Sends an \"L2 -> L1 message\" from this function (Aztec, L2) to a smart\n    /// contract on Ethereum (L1). L1 contracts which are designed to\n    /// send/receive messages to/from Aztec are called \"Portal Contracts\".\n    ///\n    /// Common use cases include withdrawals, cross-chain asset transfers, and\n    /// triggering L1 actions based on L2 state changes.\n    ///\n    /// The message will be inserted into an Aztec \"Outbox\" contract on L1,\n    /// when this transaction's block is proposed to L1.\n    /// Sending the message will not result in any immediate state changes in\n    /// the target portal contract. The message will need to be manually\n    /// consumed from the Outbox through a separate Ethereum transaction: a user\n    /// will need to call a function of the portal contract -- a function\n    /// specifically designed to make a call to the Outbox to consume the\n    /// message.\n    /// The message will only be available for consumption once the _epoch_\n    /// proof has been submitted. Given that there are multiple Aztec blocks\n    /// within an epoch, it might take some time for this epoch proof to be\n    /// submitted -- especially if the block was near the start of an epoch.\n    ///\n    /// # Arguments\n    /// * `recipient` - Ethereum address that will receive the message\n    /// * `content` - Message content (32 bytes as a Field element)\n    ///\n    pub fn message_portal(_self: Self, recipient: EthAddress, content: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { send_l2_to_l1_msg(recipient, content) };\n    }\n\n    /// Calls a public function on another contract.\n    ///\n    /// Will revert if the called function reverts or runs out of gas.\n    ///\n    /// # Arguments\n    /// * `contract_address` - Address of the contract to call\n    /// * `function_selector` - Function to call on the target contract\n    /// * `args` - Arguments to pass to the function\n    /// * `gas_opts` - An optional allocation of gas to the called function.\n    ///\n    /// # Returns\n    /// * `[Field]` - Return data from the called function\n    ///\n    pub unconstrained fn call_public_function(\n        _self: Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let calldata = args.push_front(function_selector.to_field());\n\n        call(\n            gas_opts.l2_gas.unwrap_or(MAX_U32_VALUE),\n            gas_opts.da_gas.unwrap_or(MAX_U32_VALUE),\n            contract_address,\n            calldata,\n        );\n        // Use success_copy to determine whether the call succeeded\n        let success = success_copy();\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    /// Makes a read-only call to a public function on another contract.\n    ///\n    /// This is similar to Solidity's `staticcall`. The called function\n    /// cannot modify state or emit events. Any nested calls are constrained to\n    /// also be staticcalls.\n    ///\n    /// Useful for querying data from other contracts safely.\n    ///\n    /// Will revert if the called function reverts or runs out of gas.\n    ///\n    /// # Arguments\n    /// * `contract_address` - Address of the contract to call\n    /// * `function_selector` - Function to call on the target contract\n    /// * `args` - Array of arguments to pass to the called function\n    /// * `gas_opts` - An optional allocation of gas to the called function.\n    ///\n    /// # Returns\n    /// * `[Field]` - Return data from the called function\n    ///\n    pub unconstrained fn static_call_public_function(\n        _self: Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let calldata = args.push_front(function_selector.to_field());\n\n        call_static(\n            gas_opts.l2_gas.unwrap_or(MAX_U32_VALUE),\n            gas_opts.da_gas.unwrap_or(MAX_U32_VALUE),\n            contract_address,\n            calldata,\n        );\n        // Use success_copy to determine whether the call succeeded\n        let success = success_copy();\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    /// Adds a new note hash to the Aztec blockchain's global Note Hash Tree.\n    ///\n    /// Notes are ordinarily constructed and emitted by _private_ functions, to\n    /// ensure that both the content of the note, and the contract that emitted\n    /// the note, stay private.\n    ///\n    /// There are however some useful patterns whereby a note needs to contain\n    /// _public_ data. The ability to push a new note_hash from a _public_\n    /// function means that notes can be injected with public data immediately\n    /// -- as soon as the public value is known. The slower alternative would\n    /// be to submit a follow-up transaction so that a private function can\n    /// inject the data. Both are possible on Aztec.\n    ///\n    /// Search \"Partial Note\" for a very common pattern which enables a note\n    /// to be \"partially\" populated with some data in a _private_ function, and\n    /// then later \"completed\" with some data in a public function.\n    ///\n    /// # Arguments\n    /// * `note_hash` - The hash of the note to add to the tree\n    ///\n    /// # Advanced\n    /// * The note hash will be siloed with the contract address by the protocol\n    ///\n    pub fn push_note_hash(_self: Self, note_hash: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { emit_note_hash(note_hash) };\n    }\n\n    /// Adds a new nullifier to the Aztec blockchain's global Nullifier Tree.\n    ///\n    /// Whilst nullifiers are primarily intended as a _privacy-preserving_\n    /// record of a one-time action, they can also be used to efficiently\n    /// record _public_ one-time actions too. Hence why you're seeing this\n    /// function within the PublicContext.\n    /// An example is to check whether a contract has been published: we emit\n    /// a nullifier that is deterministic, but whose preimage is _not_ private.\n    ///\n    /// # Arguments\n    /// * `nullifier` - A unique field element that represents the consumed\n    ///   state\n    ///\n    /// # Advanced\n    /// * Nullifier is immediately added to the global nullifier tree\n    /// * Emitted nullifiers are immediately visible to all\n    ///   subsequent transactions in the same block\n    /// * Automatically siloed with the contract address by the protocol\n    /// * Used for preventing double-spending and ensuring one-time actions\n    ///\n    pub fn push_nullifier(_self: Self, nullifier: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { emit_nullifier(nullifier) };\n    }\n\n    /// Returns the address of the current contract being executed.\n    ///\n    /// This is equivalent to `address(this)` in Solidity (hence the name).\n    /// Use this to identify the current contract's address, commonly needed for\n    /// access control or when interacting with other contracts.\n    ///\n    /// # Returns\n    /// * `AztecAddress` - The contract address of the current function being\n    ///                    executed.\n    ///\n    pub fn this_address(_self: Self) -> AztecAddress {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            address()\n        }\n    }\n\n    /// Returns the contract address that initiated this function call.\n    ///\n    /// This is similar to `msg.sender` in Solidity (hence the name).\n    ///\n    /// Important Note: If the calling function is a _private_ function, then\n    /// it had the option of hiding its address when enqueuing this public\n    /// function call. In such cases, this `context.msg_sender()` method will\n    /// return `Option<AztecAddress>::none`.\n    /// If the calling function is a _public_ function, it will always return\n    /// an `Option<AztecAddress>::some` (i.e. a non-null value).\n    ///\n    /// # Returns\n    /// * `Option<AztecAddress>` - The address of the smart contract that called\n    ///   this function (be it an app contract or a user's account contract).\n    ///\n    /// # Advanced\n    /// * Value is provided by the AVM sender opcode\n    /// * In nested calls, this is the immediate caller, not the original\n    ///   transaction sender\n    ///\n    pub fn msg_sender(_self: Self) -> Option<AztecAddress> {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        let maybe_msg_sender = unsafe { sender() };\n        if maybe_msg_sender == NULL_MSG_SENDER_CONTRACT_ADDRESS {\n            Option::none()\n        } else {\n            Option::some(maybe_msg_sender)\n        }\n    }\n\n    /// \"Unsafe\" versus calling `context.msg_sender()`, because it doesn't\n    /// translate `NULL_MSG_SENDER_CONTRACT_ADDRESS` as\n    /// `Option<AztecAddress>::none`.\n    /// Used by some internal aztecnr functions.\n    pub fn msg_sender_unsafe(_self: Self) -> AztecAddress {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            sender()\n        }\n    }\n\n    /// Returns the function selector of the currently-executing function.\n    ///\n    /// This is similar to `msg.sig` in Solidity, returning the first 4\n    /// bytes of the function signature.\n    ///\n    /// # Returns\n    /// * `FunctionSelector` - The 4-byte function identifier\n    ///\n    /// # Advanced\n    /// * Extracted from the first element of calldata\n    /// * Used internally for function dispatch in the AVM\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        // Safety: 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\n    /// Returns the hash of the arguments passed to the current function.\n    ///\n    /// Very low-level function: The #[external(\"public\")] macro uses this internally.\n    /// Smart contract developers typically won't need to access this\n    /// directly as arguments are automatically made available.\n    ///\n    /// # Returns\n    /// * `Field` - Hash of the function arguments\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\n    /// Returns the \"transaction fee\" for the current transaction.\n    /// This is the final tx fee that will be deducted from the fee_payer's\n    /// \"fee-juice\" balance (in the protocol's Base Rollup circuit).\n    ///\n    /// # Returns\n    /// * `Field` - The actual, final cost of the transaction, taking into account:\n    ///             the actual gas used during the setup and app-logic phases,\n    ///             and the fixed amount of gas that's been allocated by the user\n    ///             for the teardown phase.\n    ///             I.e. effectiveL2FeePerGas * l2GasUsed + effectiveDAFeePerGas * daGasUsed\n    ///\n    /// This will return `0` during the \"setup\" and \"app-logic\" phases of\n    /// tx execution (because the final tx fee is not known at that time).\n    /// This will only return a nonzero value during the \"teardown\" phase of\n    /// execution, where the final tx fee can actually be computed.\n    ///\n    /// Regardless of _when_ this function is called during the teardown phase,\n    /// it will always return the same final tx fee value. The teardown phase\n    /// does not consume a variable amount of gas: it always consumes a\n    /// pre-allocated amount of gas, as specified by the user when they generate\n    /// their tx.\n    ///\n    pub fn transaction_fee(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            transaction_fee()\n        }\n    }\n\n    /// Returns the chain ID of the current network.\n    ///\n    /// This is similar to `block.chainid` in Solidity. Returns the unique\n    /// identifier for the blockchain network this transaction is executing on.\n    ///\n    /// Helps prevent cross-chain replay attacks. Useful if implementing\n    /// multi-chain contract logic.\n    ///\n    /// # Returns\n    /// * `Field` - The chain ID as a field element\n    ///\n    pub fn chain_id(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            chain_id()\n        }\n    }\n\n    /// Returns the Aztec protocol version that this transaction is executing\n    /// under. Different versions may have different rules, opcodes, or\n    /// cryptographic primitives.\n    ///\n    /// This is similar to how Ethereum has different EVM versions.\n    ///\n    /// Useful for forward/backward compatibility checks\n    ///\n    /// Not to be confused with contract versions; this is the protocol version.\n    ///\n    /// # Returns\n    /// * `Field` - The protocol version as a field element\n    ///\n    pub fn version(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            version()\n        }\n    }\n    /// Returns the current block number.\n    ///\n    /// This is similar to `block.number` in Solidity.\n    ///\n    /// Note: the current block number is only available within a public function\n    /// (as opposed to a private function).\n    ///\n    /// Note: the time intervals between blocks should not be relied upon as\n    /// being consistent:\n    /// - Timestamps of blocks fall within a range, rather than at exact regular\n    ///   intervals.\n    /// - Slots can be missed.\n    /// - Protocol upgrades can completely change the intervals between blocks\n    ///   (and indeed the current roadmap plans to reduce the time between\n    ///   blocks, eventually).\n    /// Use `context.timestamp()` for more-reliable time-based logic.\n    ///\n    /// # Returns\n    /// * `u32` - The current block number\n    ///\n    pub fn block_number(_self: Self) -> u32 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            block_number()\n        }\n    }\n\n    /// Returns the timestamp of the current block.\n    ///\n    /// This is similar to `block.timestamp` in Solidity.\n    ///\n    /// All functions of all transactions in a block share the exact same\n    /// timestamp (even though technically each transaction is executed\n    /// one-after-the-other).\n    ///\n    /// Important note: Timestamps of Aztec blocks are not at reliably-fixed\n    /// intervals. The proposer of the block has some flexibility to choose a\n    /// timestamp which is in a valid _range_: Obviously the timestamp of this\n    /// block must be strictly greater than that of the previous block, and must\n    /// must be less than the timestamp of whichever ethereum block the aztec\n    /// block is proposed to. Furthermore, if the timestamp is not deemed close\n    /// enough to the actual current time, the committee of validators will not\n    /// attest to the block.\n    ///\n    /// # Returns\n    /// * `u64` - Unix timestamp in seconds\n    ///\n    pub fn timestamp(_self: Self) -> u64 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            timestamp()\n        }\n    }\n\n    /// Returns the fee per unit of L2 gas for this transaction (aka the \"L2 gas\n    /// price\"), as chosen by the user.\n    ///\n    /// L2 gas covers the cost of executing public functions and handling\n    /// side-effects within the AVM.\n    ///\n    /// # Returns\n    /// * `u128` - Fee per unit of L2 gas\n    ///\n    /// Wallet developers should be mindful that the choice of gas price (which\n    /// is publicly visible) can leak information about the user, e.g.:\n    /// - which wallet software the user is using;\n    /// - the amount of time which has elapsed from the time the user's wallet\n    ///   chose a gas price (at the going rate), to the time of tx submission.\n    ///   This can give clues about the proving time, and hence the nature of\n    ///   the tx.\n    /// - the urgency of the transaction (which is kind of unavoidable, if the\n    ///   tx is indeed urgent).\n    /// - the wealth of the user.\n    /// - the exact user (if the gas price is explicitly chosen by the user to\n    ///   be some unique number like 0.123456789, or their favourite number).\n    /// Wallet devs might wish to consider fuzzing the choice of gas price.\n    ///\n    pub fn base_fee_per_l2_gas(_self: Self) -> u128 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            base_fee_per_l2_gas()\n        }\n    }\n\n    /// Returns the fee per unit of DA (Data Availability) gas (aka the \"DA gas\n    /// price\").\n    ///\n    /// DA gas covers the cost of making transaction data available on L1.\n    ///\n    /// See the warning in `fee_pre_l2_gas` for how gas prices can be leaky.\n    ///\n    /// # Returns\n    /// * `u128` - Fee per unit of DA gas\n    ///\n    pub fn base_fee_per_da_gas(_self: Self) -> u128 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            base_fee_per_da_gas()\n        }\n    }\n\n    /// Returns the remaining L2 gas available for this transaction.\n    ///\n    /// Different AVM opcodes consume different amounts of gas.\n    ///\n    /// # Returns\n    /// * `u32` - Remaining L2 gas units\n    ///\n    pub fn l2_gas_left(_self: Self) -> u32 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            l2_gas_left()\n        }\n    }\n\n    /// Returns the remaining DA (Data Availability) gas available for this\n    /// transaction.\n    ///\n    /// DA gas is consumed when emitting data that needs to be made available\n    /// on L1, such as public logs or state updates.\n    /// All of the side-effects from the private part of the tx also consume\n    /// DA gas before execution of any public functions even begins.\n    ///\n    /// # Returns\n    /// * `u32` - Remaining DA gas units\n    ///\n    pub fn da_gas_left(_self: Self) -> u32 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            da_gas_left()\n        }\n    }\n\n    /// Checks if the current execution is within a staticcall context, where\n    /// no state changes or logs are allowed to be emitted (by this function\n    /// or any nested function calls).\n    ///\n    /// # Returns\n    /// * `bool` - True if in staticcall context, false otherwise\n    ///\n    pub fn is_static_call(_self: Self) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { is_static_call() } == 1\n    }\n\n    /// Reads raw field values from public storage.\n    /// Reads N consecutive storage slots starting from the given slot.\n    ///\n    /// Very low-level function. Users should typically use the public state\n    /// variable abstractions to perform reads: PublicMutable & PublicImmutable.\n    ///\n    /// # Arguments\n    /// * `storage_slot` - The starting storage slot to read from\n    ///\n    /// # Returns\n    /// * `[Field; N]` - Array of N field values from consecutive storage slots\n    ///\n    /// # Generic Parameters\n    /// * `N` - the number of consecutive slots to return, starting from the\n    ///         `storage_slot`.\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            // Safety: 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    /// Reads a typed value from public storage.\n    ///\n    /// Low-level function. Users should typically use the public state\n    /// variable abstractions to perform reads: PublicMutable & PublicImmutable.\n    ///\n    /// # Arguments\n    /// * `storage_slot` - The storage slot to read from\n    ///\n    /// # Returns\n    /// * `T` - The deserialized value from storage\n    ///\n    /// # Generic Parameters\n    /// * `T` - The type that the caller expects to read from the `storage_slot`.\n    ///\n    pub fn storage_read<T>(self, storage_slot: Field) -> T\n    where\n        T: Packable,\n    {\n        T::unpack(self.raw_storage_read(storage_slot))\n    }\n\n    /// Writes raw field values to public storage.\n    /// Writes to N consecutive storage slots starting from the given slot.\n    ///\n    /// Very low-level function. Users should typically use the public state\n    /// variable abstractions to perform writes: PublicMutable & PublicImmutable.\n    ///\n    /// Public storage writes take effect immediately.\n    ///\n    /// # Arguments\n    /// * `storage_slot` - The starting storage slot to write to\n    /// * `values` - Array of N Fields to write to storage\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            // Safety: AVM opcodes are constrained by the AVM itself\n            unsafe { storage_write(storage_slot + i as Field, values[i]) };\n        }\n    }\n\n    /// Writes a typed value to public storage.\n    ///\n    /// Low-level function. Users should typically use the public state\n    /// variable abstractions to perform writes: PublicMutable & PublicImmutable.\n    ///\n    /// # Arguments\n    /// * `storage_slot` - The storage slot to write to\n    /// * `value` - The typed value to write to storage\n    ///\n    /// # Generic Parameters\n    /// * `T` - The type to write to storage.\n    ///\n    pub fn storage_write<T>(self, storage_slot: Field, value: T)\n    where\n        T: Packable,\n    {\n        self.raw_storage_write(storage_slot, value.pack());\n    }\n}\n\n// TODO: consider putting this oracle code in its own file.\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() -> u32 {\n    block_number_opcode()\n}\nunconstrained fn timestamp() -> u64 {\n    timestamp_opcode()\n}\nunconstrained fn base_fee_per_l2_gas() -> u128 {\n    base_fee_per_l2_gas_opcode()\n}\nunconstrained fn base_fee_per_da_gas() -> u128 {\n    base_fee_per_da_gas_opcode()\n}\nunconstrained fn l2_gas_left() -> u32 {\n    l2_gas_left_opcode()\n}\nunconstrained fn da_gas_left() -> u32 {\n    da_gas_left_opcode()\n}\nunconstrained fn is_static_call() -> u1 {\n    is_static_call_opcode()\n}\nunconstrained fn note_hash_exists(note_hash: Field, leaf_index: u64) -> 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_public_log(message: [Field]) {\n    emit_public_log_opcode(message)\n}\nunconstrained fn l1_to_l2_msg_exists(msg_hash: Field, msg_leaf_index: u64) -> 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}\n\nunconstrained fn call(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    args: [Field],\n) {\n    call_opcode(l2_gas_allocation, da_gas_allocation, address, args)\n}\n\nunconstrained fn call_static(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    args: [Field],\n) {\n    call_static_opcode(l2_gas_allocation, da_gas_allocation, 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\n// `success_copy` is placed immediately after the CALL opcode to get the success value\nunconstrained fn success_copy() -> bool {\n    success_copy_opcode()\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// TODO: consider putting this oracle code in its own file.\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() -> u32 {}\n\n#[oracle(avmOpcodeTimestamp)]\nunconstrained fn timestamp_opcode() -> u64 {}\n\n#[oracle(avmOpcodeBaseFeePerL2Gas)]\nunconstrained fn base_fee_per_l2_gas_opcode() -> u128 {}\n\n#[oracle(avmOpcodeBaseFeePerDaGas)]\nunconstrained fn base_fee_per_da_gas_opcode() -> u128 {}\n\n#[oracle(avmOpcodeL2GasLeft)]\nunconstrained fn l2_gas_left_opcode() -> u32 {}\n\n#[oracle(avmOpcodeDaGasLeft)]\nunconstrained fn da_gas_left_opcode() -> u32 {}\n\n#[oracle(avmOpcodeIsStaticCall)]\nunconstrained fn is_static_call_opcode() -> u1 {}\n\n#[oracle(avmOpcodeNoteHashExists)]\nunconstrained fn note_hash_exists_opcode(note_hash: Field, leaf_index: u64) -> 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// TODO(#11124): rename unencrypted to public in avm\n#[oracle(avmOpcodeEmitUnencryptedLog)]\nunconstrained fn emit_public_log_opcode(message: [Field]) {}\n\n#[oracle(avmOpcodeL1ToL2MsgExists)]\nunconstrained fn l1_to_l2_msg_exists_opcode(msg_hash: Field, msg_leaf_index: u64) -> 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    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    args: [Field],\n) {}\n\n#[oracle(avmOpcodeStaticCall)]\nunconstrained fn call_static_opcode(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    args: [Field],\n) {}\n\n#[oracle(avmOpcodeSuccessCopy)]\nunconstrained fn success_copy_opcode() -> 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"
     },
-    "72": {
+    "73": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/utility_context.nr",
       "source": "use crate::oracle::{execution::get_utility_context, storage::storage_read};\nuse protocol_types::{address::AztecAddress, traits::Packable};\n\n// If you'll modify this struct don't forget to update utility_context.ts as well.\npub struct UtilityContext {\n    block_number: u32,\n    timestamp: u64,\n    contract_address: AztecAddress,\n    version: Field,\n    chain_id: Field,\n}\n\nimpl UtilityContext {\n    pub unconstrained fn new() -> Self {\n        get_utility_context()\n    }\n\n    pub unconstrained fn at(contract_address: AztecAddress) -> Self {\n        // We get a context with default contract address, and then we construct the final context with the provided\n        // contract address.\n        let default_context = get_utility_context();\n\n        Self {\n            block_number: default_context.block_number,\n            timestamp: default_context.timestamp,\n            contract_address,\n            version: default_context.version,\n            chain_id: default_context.chain_id,\n        }\n    }\n\n    pub unconstrained fn at_historical(contract_address: AztecAddress, block_number: u32) -> Self {\n        // We get a context with default contract address and block number, and then we construct the final context\n        // with the provided contract address and block number.\n        let default_context = get_utility_context();\n\n        Self {\n            block_number,\n            timestamp: default_context.timestamp,\n            contract_address,\n            version: default_context.version,\n            chain_id: default_context.chain_id,\n        }\n    }\n\n    pub fn block_number(self) -> u32 {\n        self.block_number\n    }\n\n    pub fn timestamp(self) -> u64 {\n        self.timestamp\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.contract_address\n    }\n\n    pub fn version(self) -> Field {\n        self.version\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.chain_id\n    }\n\n    pub unconstrained fn raw_storage_read<let N: u32>(\n        self: Self,\n        storage_slot: Field,\n    ) -> [Field; N] {\n        storage_read(self.this_address(), storage_slot, self.block_number())\n    }\n\n    pub unconstrained fn storage_read<T>(self, storage_slot: Field) -> T\n    where\n        T: Packable,\n    {\n        T::unpack(self.raw_storage_read(storage_slot))\n    }\n}\n"
     },
-    "73": {
+    "74": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/contract_self.nr",
       "source": "use crate::{\n    context::{\n        call_interfaces::{\n            PrivateCallInterface, PrivateStaticCallInterface, PublicCallInterface,\n            PublicStaticCallInterface,\n        },\n        private_context::PrivateContext,\n        public_context::PublicContext,\n    },\n    event::{event_emission::emit_event_in_private, event_interface::EventInterface},\n};\nuse super::{context::utility_context::UtilityContext, event::event_emission::emit_event_in_public};\nuse protocol_types::{\n    address::AztecAddress,\n    constants::NULL_MSG_SENDER_CONTRACT_ADDRESS,\n    traits::{Deserialize, Serialize},\n};\n\n/// `ContractSelf` is the core interface for interacting with an Aztec contract's own state and context.\n///\n/// This struct is automatically injected into every #[external(...)] contract function by the Aztec macro system and is\n/// accessible through the `self` variable.\n///\n/// # Usage in Contract Functions\n///\n/// Once injected, you can use `self` to:\n/// - Access storage: `self.storage.balances.at(owner).read()`\n/// - Call contracts: `self.call(Token::at(address).transfer(recipient, amount))`\n/// - Emit events: `self.emit(event, recipient, delivery_mode)` (private) or `self.emit(event)` (public)\n/// - Get the contract address: `self.address`\n/// - Get the caller: `self.msg_sender()`\n/// - Access low-level Aztec.nr APIs through the context: `self.context`\n///\n/// # Example\n///\n/// ```noir\n/// #[external(\"private\")]\n/// fn withdraw(amount: u128, recipient: AztecAddress) {\n///     // Get the caller of this function\n///     let sender = self.msg_sender().unwrap();\n///\n///     // Access storage\n///     let token = self.storage.donation_token.get_note().get_address();\n///\n///     // Call contracts\n///     self.call(Token::at(token).transfer(recipient, amount));\n/// }\n/// ```\n///\n/// # Type Parameters\n///\n/// - `Context`: The execution context type - either `&mut PrivateContext`, `PublicContext`, or `UtilityContext`\n/// - `Storage`: The contract's storage struct (defined with `#[storage]`), or `()` if the contract has no storage\n/// - `CallSelf`: Macro-generated type for calling contract's own non-view functions\n/// - `EnqueueSelf`: Macro-generated type for enqueuing calls to the contract's own non-view functions\n/// - `CallSelfStatic`: Macro-generated type for calling contract's own view functions\n/// - `EnqueueSelfStatic`: Macro-generated type for enqueuing calls to the contract's own view functions\npub struct ContractSelf<Context, Storage, CallSelf, EnqueueSelf, CallSelfStatic, EnqueueSelfStatic, CallInternal> {\n    /// The address of this contract\n    pub address: AztecAddress,\n    /// The contract's storage instance, representing the struct to which the `#[storage]` macro was applied in your\n    /// contract. If the contract has no storage, the type of this will be `()`.\n    ///\n    /// This storage instance is specialized for the current execution context (private, public, or utility) and\n    /// provides access to the contract's state variables. Each state variable accepts the context as a generic\n    /// parameter, which determines its available functionality. For example, a PublicImmutable variable can be read\n    /// from any context (public, private, or utility) but can only be written to from public contexts.\n    ///\n    /// # Developer Note\n    /// If you've arrived here while trying to access your contract's storage while the `Storage` generic type is set to\n    /// unit type `()`, it means you haven't yet defined a Storage struct using the #[storage] macro in your contract.\n    /// For guidance on setting this up, please refer to our docs:\n    /// https://docs.aztec.network/developers/docs/guides/smart_contracts/storage\n    pub storage: Storage,\n    /// The execution context whose type is determined by the #[external(...)] attribute of the contract function based\n    /// on the external function type (private, public, or utility).\n    pub context: Context,\n\n    /// Provides type-safe methods for calling this contract's own non-view functions.\n    ///\n    /// In private and public contexts this will be a struct with appropriate methods;\n    /// in utility context it will be the unit type `()`.\n    ///\n    /// Example API:\n    /// ```noir\n    /// self.call_self.some_private_function(args)\n    /// ```\n    pub call_self: CallSelf,\n    /// Provides type-safe methods for enqueuing calls to this contract's own non-view functions.\n    ///\n    /// In private context this will be a struct with appropriate methods;\n    /// in public and utility contexts it will be the unit type `()`.\n    ///\n    /// Example API:\n    /// ```noir\n    /// self.enqueue_self.some_public_function(args)\n    /// ```\n    pub enqueue_self: EnqueueSelf,\n    /// Provides type-safe methods for calling this contract's own view functions.\n    ///\n    /// In private and public contexts this will be a struct with appropriate methods;\n    /// in utility context it will be the unit type `()`.\n    ///\n    /// Example API:\n    /// ```noir\n    /// self.call_self_static.some_view_function(args)\n    /// ```\n    pub call_self_static: CallSelfStatic,\n    /// Provides type-safe methods for enqueuing calls to this contract's own view functions.\n    ///\n    /// In private context this will be a struct with appropriate methods;\n    /// in public and utility contexts it will be the unit type `()`.\n    ///\n    /// Example API:\n    /// ```noir\n    /// self.enqueue_self_static.some_public_view_function(args)\n    /// ```\n    pub enqueue_self_static: EnqueueSelfStatic,\n    /// Provides type-safe methods for calling internal functions.\n    ///\n    /// In private and public contexts this will be a struct with appropriate methods;\n    /// in utility context it will be the unit type `()`.\n    ///\n    /// Example API:\n    /// ```noir\n    /// self.internal.some_internal_function(args)\n    /// ```\n    pub internal: CallInternal,\n}\n\n/// Implementation for `ContractSelf` in private execution contexts.\n///\n/// This implementation is used when a contract function is marked with `#[external(\"private\")]`.\n/// Private functions execute client-side and generate zero-knowledge proofs of their execution.\nimpl<Storage, CallSelf, EnqueueSelf, CallSelfStatic, EnqueueSelfStatic, CallInternal> ContractSelf<&mut PrivateContext, Storage, CallSelf, EnqueueSelf, CallSelfStatic, EnqueueSelfStatic, CallInternal> {\n    /// Creates a new `ContractSelf` instance for a private function.\n    ///\n    /// This constructor is called automatically by the macro system and should not be called directly.\n    pub fn new_private(\n        context: &mut PrivateContext,\n        storage: Storage,\n        call_self: CallSelf,\n        enqueue_self: EnqueueSelf,\n        call_self_static: CallSelfStatic,\n        enqueue_self_static: EnqueueSelfStatic,\n        internal: CallInternal,\n    ) -> Self {\n        Self {\n            context,\n            storage,\n            address: context.this_address(),\n            call_self,\n            enqueue_self,\n            call_self_static,\n            enqueue_self_static,\n            internal,\n        }\n    }\n\n    /// Returns the contract address that initiated this function call. This is similar to `msg.sender` in Solidity.\n    ///\n    /// Important Note: Since Aztec doesn't have a concept of an EoA ( Externally-owned Account), the msg_sender is\n    /// \"null\" for the first function call of every transaction. The first function call of a tx is likely to be a call\n    /// to the user's account contract, so this quirk will most often be handled by account contract developers.\n    ///\n    /// # Returns\n    /// * `Option<AztecAddress>` - The address of the smart contract that called this function (be it an app contract or\n    ///   a user's account contract). Returns `Option<AztecAddress>::none` for the first function call of the tx. No\n    ///   other _private_ function calls in the tx will have a `none` msg_sender, but _public_ function calls might (see\n    ///   the PublicContext).\n    ///\n    pub fn msg_sender(self) -> Option<AztecAddress> {\n        let maybe_msg_sender = self.context.msg_sender_unsafe();\n        if maybe_msg_sender == NULL_MSG_SENDER_CONTRACT_ADDRESS {\n            Option::none()\n        } else {\n            Option::some(maybe_msg_sender)\n        }\n    }\n\n    /// Emits an event from a private function. Private events can be delivered either via private logs or offchain\n    /// messages, with configurable encryption and tagging constraints.\n    ///\n    /// Events in private functions are encrypted and sent to a specific recipient. This ensures that only the intended\n    /// recipient can read the event data.\n    ///\n    /// # Parameters\n    /// - `event`: The event to emit (must implement `EventInterface` and `Serialize`)\n    /// - `recipient`: The address that should be able to decrypt and read this event\n    /// - `delivery_mode`: The delivery mode for the event (e.g., `MessageDelivery.CONSTRAINED_ONCHAIN`)\n    ///\n    /// # Example\n    /// ```noir\n    /// #[external(\"private\")]\n    /// fn transfer(amount: u128, to: AztecAddress) {\n    ///     // ... transfer logic ...\n    ///     self.emit(\n    ///         TransferEvent { from: sender, to, amount },\n    ///         to,\n    ///         MessageDelivery.CONSTRAINED_ONCHAIN\n    ///     );\n    /// }\n    /// ```\n    pub fn emit<Event>(&mut self, event: Event, recipient: AztecAddress, delivery_mode: u8)\n    where\n        Event: EventInterface + Serialize,\n    {\n        emit_event_in_private(event, self.context, recipient, delivery_mode);\n    }\n\n    /// Makes a call to the private function defined by the `call` parameter.\n    ///\n    /// # Arguments\n    /// * `call` - The object representing the private function to invoke.\n    ///\n    /// # Returns\n    /// * `T` - Whatever data the called function has returned.\n    ///\n    /// # Example\n    /// ```noir\n    /// self.call(Token::at(address).transfer_in_private(recipient, amount));\n    /// ```\n    ///\n    /// This enables contracts to interact with each other while maintaining\n    /// privacy. This \"composability\" of private contract functions is a key\n    /// feature of the Aztec network.\n    ///\n    /// If a user's transaction includes multiple private function calls, then\n    /// by the design of Aztec, the following information will remain private[1]:\n    /// - The function selectors and contract addresses of all private function\n    ///   calls will remain private, so an observer of the public mempool will\n    ///   not be able to look at a tx and deduce which private functions have\n    ///   been executed.\n    /// - The arguments and return values of all private function calls will\n    ///   remain private.\n    /// - The person who initiated the tx will remain private.\n    /// - The notes and nullifiers and private logs that are emitted by all\n    ///   private function calls will (if designed well) not leak any user\n    ///   secrets, nor leak which functions have been executed.\n    ///\n    /// [1] Caveats: Some of these privacy guarantees depend on how app\n    /// developers design their smart contracts. Some actions _can_ leak\n    /// information, such as:\n    /// - Calling an internal public function.\n    /// - Calling a public function and not setting msg_sender to Option::none\n    ///   (see https://github.com/AztecProtocol/aztec-packages/pull/16433)\n    /// - Calling any public function will always leak details about the nature\n    ///   of the transaction, so devs should be careful in their contract\n    ///   designs. If it can be done in a private function, then that will give\n    ///   the best privacy.\n    /// - Not padding the side-effects of a tx to some standardized, uniform\n    ///   size. The kernel circuits can take hints to pad side-effects, so a\n    ///   wallet should be able to request for a particular amount of padding.\n    ///   Wallets should ideally agree on some standard.\n    ///   - Padding should include:\n    ///     - Padding the lengths of note & nullifier arrays\n    ///     - Padding private logs with random fields, up to some standardized\n    ///       size.\n    /// See also: https://docs.aztec.network/developers/resources/considerations/privacy_considerations\n    ///\n    /// # Advanced\n    /// * The call is added to the private call stack and executed by kernel\n    ///   circuits after this function completes\n    /// * The called function can modify its own contract's private state\n    /// * Side effects from the called function are included in this transaction\n    /// * The call inherits the current transaction's context and gas limits\n    ///\n    pub fn call<let M: u32, T>(&mut self, call: PrivateCallInterface<M, T>) -> T\n    where\n        T: Deserialize,\n    {\n        call.call(self.context)\n    }\n\n    /// Makes a read-only call to the private function defined by the `call` parameter.\n    ///\n    /// This is similar to Solidity's `staticcall`. The called function\n    /// cannot modify state, emit L2->L1 messages, nor emit events. Any nested\n    /// calls are constrained to also be static calls.\n    ///\n    /// # Arguments\n    /// * `call` - The object representing the read-only private function to invoke.\n    ///\n    /// # Returns\n    /// * `T` - Whatever data the called function has returned.\n    ///\n    /// # Example\n    /// ```noir\n    /// self.view(Token::at(address).balance_of_private(recipient));\n    /// ```\n    pub fn view<let M: u32, T>(&mut self, call: PrivateStaticCallInterface<M, T>) -> T\n    where\n        T: Deserialize,\n    {\n        call.view(self.context)\n    }\n\n    /// Enqueues a call to the public function defined by the `call` parameter,\n    /// to be executed later.\n    ///\n    /// Unlike private functions which execute immediately on the user's device,\n    /// public function calls are \"enqueued\" and executed some time later by a\n    /// block proposer.\n    ///\n    /// This means a public function cannot return any values back to a private\n    /// function, because by the time the public function is being executed,\n    /// the private function which called it has already completed execution.\n    /// (In fact, the private function has been executed and proven, along with\n    /// all other private function calls of the user's tx. A single proof of the\n    /// tx has been submitted to the Aztec network, and some time later a\n    /// proposer has picked the tx up from the mempool and begun executing all\n    /// of the enqueued public functions).\n    ///\n    /// # Privacy warning\n    /// Enqueueing a public function call is an inherently leaky action.\n    /// Many interesting applications will require some interaction with public\n    /// state, but smart contract developers should try to use public function\n    /// calls sparingly, and carefully.\n    /// _Internal_ public function calls are especially leaky, because they\n    /// completely leak which private contract made the call.\n    /// See also: https://docs.aztec.network/developers/resources/considerations/privacy_considerations\n    ///\n    /// # Arguments\n    /// * `call` - The interface representing the public function to enqueue.\n    ///\n    /// TODO(F-131): We should drop T from here because it is strange as there\n    /// is no return value. The PublicCallInterface type seems to be defined\n    /// incorrectly.\n    pub fn enqueue<let M: u32, T>(&mut self, call: PublicCallInterface<M, T>)\n    where\n        T: Deserialize,\n    {\n        call.enqueue(self.context)\n    }\n\n    /// Enqueues a read-only call to the public function defined by the `call` parameter.\n    ///\n    /// This is similar to Solidity's `staticcall`. The called function\n    /// cannot modify state, emit L2->L1 messages, nor emit events. Any nested\n    /// calls are constrained to also be static calls.\n    ///\n    /// # Arguments\n    /// * `call` - The object representing the read-only public function to enqueue.\n    ///\n    /// # Example\n    /// ```noir\n    /// self.enqueue_view(MyContract::at(address).assert_timestamp_less_than(timestamp));\n    /// ```\n    ///\n    /// TODO(F-131): We should drop T from here because it is strange as there\n    /// is no return value. The PublicCallInterface type seems to be defined\n    /// incorrectly.\n    pub fn enqueue_view<let M: u32, T>(&mut self, call: PublicStaticCallInterface<M, T>)\n    where\n        T: Deserialize,\n    {\n        call.enqueue_view(self.context)\n    }\n\n    /// Enqueues a call to the public function defined by the `call` parameter,\n    /// to be executed later.\n    ///\n    /// As per `enqueue`, but hides this calling contract's address from the\n    /// target public function.\n    /// This means the origin of the call (msg_sender) will not be publicly\n    /// visible to any blockchain observers, nor to the target public function.\n    /// When the target public function reads `context.msg_sender()` it will\n    /// receive an `Option<AztecAddress>::none`.\n    ///\n    /// NOTES:\n    /// - Not all public functions will accept a msg_sender of \"none\". Many\n    ///   public functions will require that msg_sender is \"some\" and will\n    ///   revert otherwise. Therefore, if using `enqueue_incognito`, you must\n    ///   understand whether the function you're calling will accept a\n    ///   msg_sender of \"none\".\n    ///   Lots of public bookkeeping patterns rely on knowing which address made\n    ///   the call, so as to ascribe state against the caller's address.\n    ///   (There are patterns whereby bookkeeping could instead be done in\n    ///   private-land).\n    /// - If you are enqueueing a call to an _internal_ public function (i.e.\n    ///   a public function that will only accept calls from other functions\n    ///   of its own contract), then by definition a call to it cannot possibly\n    ///   be \"incognito\": the msg_sender must be its own address, and indeed the\n    ///   called public function will assert this. Tl;dr this is not usable for\n    ///   enqueued internal public calls.\n    ///\n    /// # Arguments\n    /// * `call` - The object representing the public function to enqueue.\n    ///\n    /// # Example\n    /// ```noir\n    /// self.enqueue_incognito(Token::at(address).increase_total_supply_by(amount));\n    /// ```\n    ///\n    /// Advanced:\n    /// - The kernel circuits will permit _any_ private function to set the\n    ///   msg_sender field of any enqueued public function call to\n    ///   NULL_MSG_SENDER_CONTRACT_ADDRESS.\n    /// - When the called public function calls `PublicContext::msg_sender()`,\n    ///   aztec-nr will translate NULL_MSG_SENDER_CONTRACT_ADDRESS into\n    ///   `Option<AztecAddress>::none` for familiarity to devs.\n    ///\n    /// TODO(F-131): We should drop T from here because it is strange as there\n    /// is no return value. The PublicCallInterface type seems to be defined\n    /// incorrectly.\n    pub fn enqueue_incognito<let M: u32, T>(&mut self, call: PublicCallInterface<M, T>)\n    where\n        T: Deserialize,\n    {\n        call.enqueue_incognito(self.context)\n    }\n\n    /// Enqueues a read-only call to the public function defined by the `call` parameter.\n    ///\n    /// As per `enqueue_view`, but hides this calling contract's address from\n    /// the target public function.\n    ///\n    /// See `enqueue_incognito` for more details relating to hiding msg_sender.\n    ///\n    /// # Arguments\n    /// * `call` - The object representing the read-only public function to enqueue.\n    ///\n    /// # Example\n    /// ```noir\n    /// self.enqueue_view_incognito(MyContract::at(address).assert_timestamp_less_than(timestamp));\n    /// ```\n    ///\n    /// TODO(F-131): We should drop T from here because it is strange as there\n    /// is no return value. The PublicCallInterface type seems to be defined\n    /// incorrectly.\n    pub fn enqueue_view_incognito<let M: u32, T>(&mut self, call: PublicStaticCallInterface<M, T>)\n    where\n        T: Deserialize,\n    {\n        call.enqueue_view_incognito(self.context)\n    }\n\n    /// Enqueues a call to the public function defined by the `call` parameter,\n    /// and designates it to be the teardown function for this tx. Only one teardown\n    /// function call can be made by a tx.\n    ///\n    /// Niche function: Only wallet developers and paymaster contract developers\n    /// (aka Fee-payment contracts) will need to make use of this function.\n    ///\n    /// Aztec supports a three-phase execution model: setup, app logic, teardown.\n    /// The phases exist to enable a fee payer to take on the risk of paying\n    /// a transaction fee, safe in the knowledge that their payment (in whatever\n    /// token or method the user chooses) will succeed, regardless of whether\n    /// the app logic will succeed. The \"setup\" phase ensures the fee payer\n    /// has sufficient balance to pay the proposer their fees.\n    /// The teardown phase is primarily intended to: calculate exactly\n    /// how much the user owes, based on gas consumption, and refund the user\n    /// any change.\n    ///\n    /// Note: in some cases, the cost of refunding the user (i.e. DA costs of\n    /// tx side-effects) might exceed the refund amount. For app logic with\n    /// fairly stable and predictable gas consumption, a material refund amount\n    /// is unlikely. For app logic with unpredictable gas consumption, a\n    /// refund might be important to the user (e.g. if a hefty function reverts\n    /// very early). Wallet/FPC/Paymaster developers should be mindful of this.\n    ///\n    /// See `enqueue` for more information about enqueuing public function calls.\n    ///\n    /// # Arguments\n    /// * `call` - The object representing the public function to designate as teardown.\n    ///\n    /// TODO(F-131): We should drop T from here because it is strange as there\n    /// is no return value. The PublicCallInterface type seems to be defined\n    /// incorrectly.\n    pub fn set_as_teardown<let M: u32, T>(&mut self, call: PublicCallInterface<M, T>)\n    where\n        T: Deserialize,\n    {\n        call.set_as_teardown(self.context)\n    }\n\n    /// Enqueues a call to the public function defined by the `call` parameter,\n    /// and designates it to be the teardown function for this tx. Only one teardown\n    /// function call can be made by a tx.\n    ///\n    /// As per `set_as_teardown`, but hides this calling contract's address from\n    /// the target public function.\n    ///\n    /// See `enqueue_incognito` for more details relating to hiding msg_sender.\n    ///\n    /// TODO(F-131): We should drop T from here because it is strange as there\n    /// is no return value. The PublicCallInterface type seems to be defined\n    /// incorrectly.\n    pub fn set_as_teardown_incognito<let M: u32, T>(&mut self, call: PublicCallInterface<M, T>)\n    where\n        T: Deserialize,\n    {\n        call.set_as_teardown_incognito(self.context)\n    }\n}\n\n/// Implementation for `ContractSelf` in public execution contexts.\n///\n/// This implementation is used when a contract function is marked with `#[external(\"public\")]`.\n/// Public functions are executed by the sequencer in the Aztec Virtual Machine (AVM) and can work only with public\n/// state.\nimpl<Storage, CallSelf, CallSelfStatic, CallInternal> ContractSelf<PublicContext, Storage, CallSelf, (), CallSelfStatic, (), CallInternal> {\n    /// Creates a new `ContractSelf` instance for a public function.\n    ///\n    /// This constructor is called automatically by the macro system and should not be called directly.\n    pub fn new_public(\n        context: PublicContext,\n        storage: Storage,\n        call_self: CallSelf,\n        call_self_static: CallSelfStatic,\n        internal: CallInternal,\n    ) -> Self {\n        Self {\n            context,\n            storage,\n            address: context.this_address(),\n            call_self,\n            enqueue_self: (),\n            call_self_static,\n            enqueue_self_static: (),\n            internal,\n        }\n    }\n\n    /// Returns the contract address that initiated this function call.\n    ///\n    /// This is similar to `msg.sender` in Solidity (hence the name).\n    ///\n    /// Important Note: If the calling function is a _private_ function, then it had the option of hiding its address\n    /// when enqueuing this public function call. In such cases, this `context.msg_sender()` method will return\n    /// `Option<AztecAddress>::none`. If the calling function is a _public_ function, it will always return an\n    /// `Option<AztecAddress>::some` (i.e. a non-null value).\n    ///\n    /// # Returns\n    /// * `Option<AztecAddress>` - The address of the smart contract that called this function (be it an app contract or\n    ///   a user's account contract).\n    ///\n    /// # Advanced\n    /// * Value is provided by the AVM sender opcode\n    /// * In nested calls, this is the immediate caller, not the original transaction sender\n    ///\n    pub fn msg_sender(self: Self) -> Option<AztecAddress> {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        let maybe_msg_sender = self.context.msg_sender_unsafe();\n        if maybe_msg_sender == NULL_MSG_SENDER_CONTRACT_ADDRESS {\n            Option::none()\n        } else {\n            Option::some(maybe_msg_sender)\n        }\n    }\n\n    /// Emits an event from a public function.\n    ///\n    /// Events in public functions are emitted in plaintext and are visible to everyone.\n    /// Unlike private events, they don't require a recipient parameter.\n    ///\n    /// # Parameters\n    /// - `event`: The event to emit (must implement `EventInterface` and `Serialize`)\n    ///\n    /// # Example\n    /// ```noir\n    /// #[external(\"public\")]\n    /// fn publish_update(value: Field) {\n    ///     // ... update logic ...\n    ///     self.emit(UpdateEvent { value });\n    /// }\n    /// ```\n    pub fn emit<Event>(&mut self, event: Event)\n    where\n        Event: EventInterface + Serialize,\n    {\n        emit_event_in_public(event, self.context);\n    }\n\n    /// Makes the call to the public function defined by the `call` parameter.\n    ///\n    /// Will revert if the called function reverts or runs out of gas.\n    ///\n    /// # Arguments\n    /// * `call` - The object representing the public function to invoke.\n    ///\n    /// # Returns\n    /// * `T` - Whatever data the called function has returned.\n    ///\n    /// # Example\n    /// ```noir\n    /// self.call(Token::at(address).transfer_in_public(recipient, amount));\n    /// ```\n    ///\n    pub unconstrained fn call<let M: u32, T>(self, call: PublicCallInterface<M, T>) -> T\n    where\n        T: Deserialize,\n    {\n        call.call(self.context)\n    }\n\n    /// Makes the read-only call to the public function defined by the `call` parameter.\n    ///\n    /// This is similar to Solidity's `staticcall`. The called function\n    /// cannot modify state or emit events. Any nested calls are constrained to\n    /// also be static calls.\n    ///\n    /// Will revert if the called function reverts or runs out of gas.\n    ///\n    /// # Arguments\n    /// * `call` - The object representing the read-only public function to invoke.\n    ///\n    /// # Returns\n    /// * `T` - Whatever data the called function has returned.\n    ///\n    /// # Example\n    /// ```noir\n    /// self.view(Token::at(address).balance_of_public(recipient));\n    /// ```\n    ///\n    pub unconstrained fn view<let M: u32, T>(self, call: PublicStaticCallInterface<M, T>) -> T\n    where\n        T: Deserialize,\n    {\n        call.view(self.context)\n    }\n}\n\n/// Implementation for `ContractSelf` in utility execution contexts.\n///\n/// This implementation is used when a contract function is marked with `#[external(\"utility\")]`.\n/// Utility functions are unconstrained functions that can read private state for offchain queries.\n/// They are typically used for view functions that need to access private notes (e.g. a Token's balance_of function).\nimpl<Storage> ContractSelf<UtilityContext, Storage, (), (), (), (), ()> {\n    /// Creates a new `ContractSelf` instance for a utility function.\n    ///\n    /// This constructor is called automatically by the macro system and should not be called directly.\n    pub fn new_utility(context: UtilityContext, storage: Storage) -> Self {\n        Self {\n            context,\n            storage,\n            address: context.this_address(),\n            call_self: (),\n            enqueue_self: (),\n            call_self_static: (),\n            enqueue_self_static: (),\n            internal: (),\n        }\n    }\n}\n"
     },
-    "76": {
+    "77": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/event/event_selector.nr",
       "source": "use dep::protocol_types::{\n    hash::poseidon2_hash_bytes,\n    traits::{Deserialize, Empty, FromField, Serialize, ToField},\n};\n\n#[derive(Deserialize, Eq, Serialize)]\npub struct EventSelector {\n    // 1st 4-bytes (big-endian leftmost) of abi-encoding of an event.\n    inner: u32,\n}\n\nimpl FromField for EventSelector {\n    fn from_field(field: Field) -> Self {\n        Self { inner: field as u32 }\n    }\n}\n\nimpl ToField for EventSelector {\n    fn to_field(self) -> Field {\n        self.inner as Field\n    }\n}\n\nimpl Empty for EventSelector {\n    fn empty() -> Self {\n        Self { inner: 0 as u32 }\n    }\n}\n\nimpl EventSelector {\n    pub fn from_u32(value: u32) -> Self {\n        Self { inner: value }\n    }\n\n    pub fn from_signature<let N: u32>(signature: str<N>) -> Self {\n        let bytes = signature.as_bytes();\n        let hash = poseidon2_hash_bytes(bytes);\n\n        // `hash` is automatically truncated to fit within 32 bits.\n        EventSelector::from_field(hash)\n    }\n\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n}\n"
-    },
-    "99": {
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/aztec.nr",
-      "source": "use crate::macros::{\n    calls_generation::{\n        external_functions::{\n            generate_external_function_calls, generate_external_function_self_calls_structs,\n        },\n        internal_functions::generate_call_internal_struct,\n    },\n    dispatch::generate_public_dispatch,\n    functions::utils::check_each_fn_macroified,\n    internals_functions_generation::{create_fn_abi_exports, process_functions},\n    notes::NOTES,\n    storage::STORAGE_LAYOUT_NAME,\n    utils::{get_trait_impl_method, module_has_storage},\n};\n\n/// Marks a contract as an Aztec contract, generating the interfaces for its functions and notes, as well as injecting\n/// the `sync_private_state` utility function.\n/// Note: This is a module annotation, so the returned quote gets injected inside the module (contract) itself.\npub comptime fn aztec(m: Module) -> Quoted {\n    // Functions that don't have #[external(...)], #[contract_library_method], or #[test] are not allowed in contracts.\n    check_each_fn_macroified(m);\n\n    // We generate new functions prefixed with `__aztec_nr_internals__` and we replace the original functions' bodies\n    // with `static_assert(false, ...)` to prevent them from being called directly from within the contract.\n    let functions = process_functions(m);\n\n    // We generate structs and their implementations necessary for convenient functions calls.\n    let interface = generate_contract_interface(m);\n    let self_call_structs = generate_external_function_self_calls_structs(m);\n    let call_internal_struct = generate_call_internal_struct(m);\n\n    // We generate ABI exports for all the external functions in the contract.\n    let fn_abi_exports = create_fn_abi_exports(m);\n\n    // We generate `_compute_note_hash_and_nullifier`, `sync_private_state` and `process_message`\n    // functions only if they are not already implemented. If they are implemented we just insert empty\n    // quotes.\n    let contract_library_method_compute_note_hash_and_nullifier = if !m.functions().any(|f| {\n        f.name() == quote { _compute_note_hash_and_nullifier }\n    }) {\n        generate_contract_library_method_compute_note_hash_and_nullifier()\n    } else {\n        quote {}\n    };\n    let sync_private_state_fn_and_abi_export = if !m.functions().any(|f| {\n        f.name() == quote { sync_private_state }\n    }) {\n        generate_sync_private_state()\n    } else {\n        quote {}\n    };\n\n    let process_message_fn_and_abi_export = if !m.functions().any(|f| {\n        f.name() == quote { process_message }\n    }) {\n        generate_process_message()\n    } else {\n        quote {}\n    };\n    let public_dispatch = generate_public_dispatch(m);\n\n    quote {\n        $interface\n        $self_call_structs\n        $call_internal_struct\n        $functions\n        $fn_abi_exports\n        $contract_library_method_compute_note_hash_and_nullifier\n        $public_dispatch\n        $sync_private_state_fn_and_abi_export\n        $process_message_fn_and_abi_export\n    }\n}\n\ncomptime fn generate_contract_interface(m: Module) -> Quoted {\n    let calls = generate_external_function_calls(m);\n\n    let module_name = m.name();\n\n    let has_storage_layout = module_has_storage(m) & STORAGE_LAYOUT_NAME.get(m).is_some();\n    let storage_layout_getter = if has_storage_layout {\n        let storage_layout_name = STORAGE_LAYOUT_NAME.get(m).unwrap();\n        quote {\n            pub fn storage_layout() -> StorageLayoutFields {\n                $storage_layout_name.fields\n            }\n        }\n    } else {\n        quote {}\n    };\n\n    let library_storage_layout_getter = if has_storage_layout {\n        quote {\n            #[contract_library_method]\n            $storage_layout_getter\n        }\n    } else {\n        quote {}\n    };\n\n    quote {\n        pub struct $module_name {\n            pub target_contract: dep::aztec::protocol_types::address::AztecAddress\n        }\n\n        impl $module_name {\n            $calls\n\n            pub fn at(\n                addr: aztec::protocol_types::address::AztecAddress\n            ) -> Self {\n                Self { target_contract: addr }\n            }\n\n            pub fn interface() -> Self {\n                Self { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n            }\n\n            $storage_layout_getter\n        }\n\n        #[contract_library_method]\n        pub fn at(\n            addr: aztec::protocol_types::address::AztecAddress\n        ) -> $module_name {\n            $module_name { target_contract: addr }\n        }\n\n        #[contract_library_method]\n        pub fn interface() -> $module_name {\n            $module_name { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n        }\n\n        $library_storage_layout_getter\n\n    }\n}\n\n/// Generates a contract library method called `_compute_note_hash_and_nullifier` which is used for note\n/// discovery (to create the `aztec::messages::discovery::ComputeNoteHashAndNullifier` function) and to implement the\n/// `compute_note_hash_and_nullifier` unconstrained contract function.\ncomptime fn generate_contract_library_method_compute_note_hash_and_nullifier() -> Quoted {\n    if NOTES.len() > 0 {\n        // Contracts that do define notes produce an if-else chain where `note_type_id` is matched against the\n        // `get_note_type_id()` function of each note type that we know of, in order to identify the note type. Once we\n        // know it we call we correct `unpack` method from the `Packable` trait to obtain the underlying note type, and\n        // compute the note hash (non-siloed) and inner nullifier (also non-siloed).\n\n        let mut if_note_type_id_match_statements_list = &[];\n        for i in 0..NOTES.len() {\n            let typ = NOTES.get(i);\n\n            let get_note_type_id = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteType },\n                quote { get_id },\n            );\n            let unpack = get_trait_impl_method(\n                typ,\n                quote { crate::protocol_types::traits::Packable },\n                quote { unpack },\n            );\n\n            let compute_note_hash = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteHash },\n                quote { compute_note_hash },\n            );\n\n            let compute_nullifier_unconstrained = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteHash },\n                quote { compute_nullifier_unconstrained },\n            );\n\n            let if_or_else_if = if i == 0 {\n                quote { if }\n            } else {\n                quote { else if }\n            };\n\n            if_note_type_id_match_statements_list = if_note_type_id_match_statements_list.push_back(\n                quote {\n                    $if_or_else_if note_type_id == $get_note_type_id() {\n                        // As an extra safety check we make sure that the packed_note BoundedVec has the expected\n                        // length, since we're about to interpret its raw storage as a fixed-size array by calling the\n                        // unpack function on it.\n                        let expected_len = <$typ as $crate::protocol_types::traits::Packable>::N;\n                        let actual_len = packed_note.len();\n                        assert(\n                            actual_len == expected_len,\n                            f\"Expected packed note of length {expected_len} but got {actual_len} for note type id {note_type_id}\"\n                        );\n\n                        let note = $unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n\n                        let note_hash = $compute_note_hash(note, storage_slot);\n    \n                        // The message discovery process finds settled notes, that is, notes that were created in prior\n                        // transactions and are therefore already part of the note hash tree. We therefore compute the\n                        // nullification note hash by treating the note as a settled note with the provided note nonce.\n                        let note_hash_for_nullification = aztec::note::utils::compute_note_hash_for_nullification(\n                            aztec::note::retrieved_note::RetrievedNote{ \n                                note, \n                                contract_address, \n                                metadata: aztec::note::note_metadata::SettledNoteMetadata::new(note_nonce).into()\n                            }, \n                            storage_slot,\n                        );\n\n                        let inner_nullifier = $compute_nullifier_unconstrained(note, note_hash_for_nullification);\n\n                        Option::some(\n                            aztec::messages::discovery::NoteHashAndNullifier {\n                                note_hash, inner_nullifier\n                            }\n                        )\n                    }\n                },\n            );\n        }\n\n        let if_note_type_id_match_statements = if_note_type_id_match_statements_list.join(quote {});\n\n        quote {\n            /// Unpacks an array into a note corresponding to `note_type_id` and then computes its note hash\n            /// (non-siloed) and inner nullifier (non-siloed) assuming the note has been inserted into the note hash\n            /// tree with `note_nonce`.\n            ///\n            /// The signature of this function notably matches the `aztec::messages::discovery::ComputeNoteHashAndNullifier` type,\n            /// and so it can be used to call functions from that module such as `discover_new_messages`, \n            /// `do_process_message` and `attempt_note_discovery`.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_hash_and_nullifier(\n                packed_note: BoundedVec<Field, aztec::messages::discovery::private_notes::MAX_NOTE_PACKED_LEN>,\n                storage_slot: Field,\n                note_type_id: Field,\n                contract_address: aztec::protocol_types::address::AztecAddress,\n                note_nonce: Field,\n            ) -> Option<aztec::messages::discovery::NoteHashAndNullifier> {\n                $if_note_type_id_match_statements\n                else {\n                    Option::none()\n                }\n            }\n        }\n    } else {\n        // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n        // simply throws immediately.\n        quote {\n            /// This contract does not use private notes, so this function should never be called as it will\n            /// unconditionally fail.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_hash_and_nullifier(\n                _packed_note: BoundedVec<Field, aztec::messages::discovery::private_notes::MAX_NOTE_PACKED_LEN>,\n                _storage_slot: Field,\n                _note_type_id: Field,\n                _contract_address: aztec::protocol_types::address::AztecAddress,\n                _nonce: Field,\n            ) -> Option<aztec::messages::discovery::NoteHashAndNullifier> {\n                panic(f\"This contract does not use private notes\")\n            }\n        }\n    }\n}\n\ncomptime fn generate_sync_private_state() -> Quoted {\n    quote {\n        pub struct sync_private_state_parameters {}\n\n        #[abi(functions)]\n        pub struct sync_private_state_abi {\n            parameters: sync_private_state_parameters,\n        }\n\n        #[aztec::macros::internals_functions_generation::abi_attributes::abi_utility]\n        unconstrained fn sync_private_state() {\n            let address = aztec::context::utility_context::UtilityContext::new().this_address();\n            \n            aztec::messages::discovery::discover_new_messages(address, _compute_note_hash_and_nullifier);\n        }\n    }\n}\n\ncomptime fn generate_process_message() -> Quoted {\n    quote {\n        pub struct process_message_parameters {\n            pub message_ciphertext: BoundedVec<Field, aztec::messages::encoding::MESSAGE_CIPHERTEXT_LEN>,\n            pub message_context: aztec::messages::processing::message_context::MessageContext,\n        }\n\n        #[abi(functions)]\n        pub struct process_message_abi {\n            parameters: process_message_parameters,\n        }\n\n        #[aztec::macros::internals_functions_generation::abi_attributes::abi_utility]\n        unconstrained fn process_message(\n            message_ciphertext: BoundedVec<Field, aztec::messages::encoding::MESSAGE_CIPHERTEXT_LEN>,\n            message_context: aztec::messages::processing::message_context::MessageContext,\n        ) {\n            let address = aztec::context::utility_context::UtilityContext::new().this_address();\n\n            aztec::messages::discovery::discover_new_messages(address, _compute_note_hash_and_nullifier);     \n            aztec::messages::discovery::process_message::process_message_ciphertext(\n                address,\n                _compute_note_hash_and_nullifier,\n                message_ciphertext,\n                message_context,\n            );\n        }\n    }\n}\n"
     }
   }
 }