@aztec/protocol-contracts 0.85.0 → 0.86.0

package/artifacts/MultiCallEntrypoint.json

@@ -3,6 +3,28 @@
   "noir_version": "1.0.0-beta.4+0000000000000000000000000000000000000000",
   "name": "MultiCallEntrypoint",
   "functions": [
+    {
+      "name": "sync_notes",
+      "is_unconstrained": true,
+      "custom_attributes": [
+        "aztec::macros::functions::utility"
+      ],
+      "abi": {
+        "parameters": [],
+        "return_type": null,
+        "error_types": {
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        }
+      },
+      "bytecode": "H4sIAAAAAAAA/7WTPQ+CMBCGi2KUjzjgoD+jBAyM+LG4OLpXCkpUSAB3frqQXENtwKjAJU17FJ5736OVUB0SzDLqEAyyglmBecTtj8vhQY67hakIdfvku9i2lQZ/Peq3FGBKw/Ax4w/UfzwFzr6o+bwXVndWDo1b66g+H0P5Z/9vSP+LD5418GpAXnmew/oS5Nt74t+Oz8c5SNnXTR1EgnIxdK5CSd0lcZ4SP99QmgZZJhJGDWTUQlU56pVE8YG26fmRdgrSLEpikSZ/Sav6yu6lXLyr8eA57hCOizHTMAb+BDV3X+b2+feXkKuCJ+bT+1Nn6BAztEhI1oRS2yeGwK+CP38vlizs4eEFAAA=",
+      "debug_symbols": "rZLdCoMgGIbvxWMP/P/ZrYwxrGwIYmE1GNG9z8JYrNFOOhE/fXh50HcElS2Gx92FuunA5ToC35Smd01I0zhBUETnvXvct8cAzQumC9+1Jsxj15vYgwtGDFMIbKiWvSQpo3beLtMEd7xUItNqvs+sxD9QTnhGOUefWCamGwSYnWGjqFxtuD62YVRnlAm1s+Gn2Ci22mh1bCPQ+jaCiJ2NOMNGE5JpTfkfG4UyKtHXT01pfJroTOFtrlg9hHLTuP7V2q/ytbEpbTVEO9dw08C0XrGChKbYFP0G",
+      "brillig_names": [
+        "sync_notes"
+      ]
+    },
     {
       "name": "entrypoint",
       "is_unconstrained": false,
@@ -1663,37 +1685,15 @@
           }
         }
       },
-      "bytecode": "H4sIAAAAAAAA/+19C5xN1fv+mTkz45aElEuFVG5hrbmeISVyySX3+3WGGddIUZHkliRJkiQJSZIkSe4kSZIkJUkIiZLu98v/fTnna3cc/X7/77xvv/NMa38+z2eOmbHmeZ/nXetde++1147xnTri8vp8xfOc+hxD8Ae/xhLKhH0v9NX7OT7C7xWI8L2CEb5XKML3Ckf43gWEWmHfKx3h98pE+F7ZCN+7NML3ykf4XsUI36scQYMrI3yvaoT/ayL8no3wvaQI/zclwu+lRvheIML/rR7h92oEv3qP0L9rBb8mmdTk5Ky0xCybZDNMYnpmIMUkp2SmBmzApgRSeiQGkpKyAsmBtPTM9DSTbpOTsmx2SnpStjl1FPafbsvk6EjsrsmzyH/N06aGf4e5FSHEebiyDn8EP1fwnf5c0fO5SPB3Qv+vKP37fEIxwgX+098PHf4wDUzODltJsK2ifjlvLhTLIWM09ass2Nb5gvoVB9HvSsG2ignqV0JQv0hjw4WesaG453MJz+cLwsaGkvTvUoSLCBf/A2NDFcG2Sgp6cwlIblcVbKuUoH6lQfSrJtjWRYL6lVEeGy7xjAGlPZ/LeD5fHDY2lKV/X0ooR7jsHxgbjGBbZQW9uRwkt61gW5cK6ncFiH6Jgm2VE9SvvPLYcLlnDLjC87m85/NlYWNDBfp3RUIlQuV/YGxIEmyrgqA3V4LkdrJgWxUF9asCol+KYFuVBPWrqjw2XOkZA6p4Plf1fK4cNjZUo38bgiUk/gNjQ6pgW9UEvUkCye00wbaMoH7JIPoFBNuygvqlKI8NSZ4xINnzOcXzOTFsbEilf6cRAoT0f2BsSBdsK1XQm+oguV1dsK00Qf1qgOhXQ7CtgKB+VymPDdU9Y0ANz+erPJ/Tw8aGmvTvqwnXMLd/YGy4SrCtmoLeXKvszbUeD672fL7G87lWmDe16d91CNcR6kbwJlbYm/I+OT3ryelpvfc9ud0yQY1ifWfeA/X5zry/aHJ2SN5bM16+9f2KhLlx6XYbCHY4rbgb+E8LLNTuX4qVdKerJ6jp9YKdLpI/OeVXOeiPtIaVBTk2FJ7kSOc4e9zQL+9NI+ECGBqwG3kGbJ/vzCKmoZHkgK3JswIIz3rKfSLHF4SD+SY9rvgF2xJcIGHCfRY3vGGUG87GhExHMDyn8TYW9CPOd3rlZ/jxbx2IK4Lw/LcWDC2ekv0q1sOzSXBguoEnahpnYTzjDa92ErNzqbYaKJ3+NwnOJr2HdNVvInhG1lT5jMzk7LChMzI/SC7ltK1mUe4H50szhbO75kpnd83/F/1R0rOcttVC2H/pWOsFz+6lOIauFkTzVauWUX7FhdvTuOLSKsrjrqQUd+soj5tjbqwQd5soj7uCkt9tozzuekpXVNsJn7T/U7e7BJfr/+V2V3u/IuH2Cre7OkT57S6Ou4PS7S6Uie23CdEdN084WyrE/Z1w3KFD+kSwo+BkVtBrK6ifyq1SE+zb0hN3I8ixU5QXds69Tgp9r7PSyXTnf+BkupNgTesifDIdOqTHoK65fwwy/+TtdckJoibPKiA8uyqPozntP9w5o/32uuBzmPq31zsJnxl6zdHg2yJ4huwTajf71PGXTiXUtg198OrRLcg9I1RpQ1+7+c/cWSfDU4U1Li218ItV9cRgD7XdBKt6hl/WYOnRiDtPN5CzXva6lcIMNDPKZ94cd2uFuLsDxN1GIe4eAHG3VYg7CyDudgpxZ/9D62dyyrOnIE8e0vMTmgXb4zGO+zvnPucBa9LT4X+Ns3lucnakhOYw0rnUK8r7Os87einE3Vsw7thgHwo/JHXV0La3P/o59pHmKH06zQFLXt7jtvr45Xn2EeTYF6fz2H9z5+krzRGlqvXzyyaQRlXrpxD3ja6q2RsBOmb/aK9qfLNBuqr1V6hq/QU5DnBVDaLzDPi3VrWb5AJP1DCGO/lNCnEPdFXNDgTomDdrd0yJB1hDt1UlA/cLtmUF471F2BChG2h/mRUIJs3JAegWhVnGzYKzjEFulgExmA36t84yBssFnqRhDHfywQpx3+pmGfZWgI55W7SfO/MCOOlz59sUqtptghxvd1UNovPc/m+takPkAk/WMIY7+RCFuIe6qmaHAnTMO6K9qnGCdhWuancoVLU7BDkOc1UNovMMi/KqZrWq2p0A9znvVIh7uKDh3lXo3G4Z36lBCbHS9QTorHcpcIxINKdJNkKwc6Em1AiAhBqJklCjBO/foSbUKICEGo2SUGMEL9WiJtQYgIS6GyWhxgpeJUFNqLEACXUPSkKNkyOagppQ4wAS6l6UhBovRzQVNaHGAyTUfSgJNUGOaBpqQk0ASKj7URJqohzRAGpCTQRIqAdQEmqSHNF01ISaBJBQD6Ik1GQ5ohmoCTUZIKEeQkmoKXJEM1ETagpAQj2MklBT5Yh2R02oqQAJ9QhKQk2TI9oDNaGmASTUoygJNV2OaBZqQk0HSKjHUBJqhhzRbNSEmgGQUI+jJNRMMaIWduXvTICEegIloWbJJRTseqhZAAk1GyWh5sglFOx6qDkACfUkSkLNlUso2PVQcwES6imUhJonl1Cw66HmASTU0ygJNV8uoWDXQ80HSKhnUBJqgVxCwa6HWgCQUM+iJNRCuYSCXQ+1ECChnkNJqEVyCQW7HmoRQEI9j5JQi+USCnY91GKAhHoBJaGWyCUU7HqoJQAJ9SJKQi2VSyjY9VBLARLqJZSEWiaXULDroZYBJNTLKAm1XC6hYNdDLQdIqBUoCbVSLqFg10OtBEioVSgJtVouoWDXQ60GSKg1KAm1VoxoIux6qLUACbUOJaHWyyUU7Hqo9QAJ9QpKQm2QSyjY9VAbABLqVZSE2iiXULDroTYCJNRrKAm1SS6hYNdDbQJIqNdREmqzXELBrofaDJBQb6Ak1Ba5hIJdD7UFIKHeREmorXIJBbseaitAQr2FklDb5BIKdj3UNoCEehslobbLJRTseqjtAAn1DkpC7ZBLKNj1UDsAEupdlITaKZdQsOuhdgIk1HuSHFGNKgxg1PsoPX+XXM+HXWe0CyChPkBJqN1yCQW7zmg3QEJ9iJJQe+QSCnad0R6AhPoIJaH2ihFNgl1ntBcgoT5GSah9cgkFu85oH0BC7UdJqANyCQW7zugAQEJ9gpJQB+USCnad0UGAhDqEklCH5RIKdp3RYYCE+hQloY7IJRTsOqMjAAn1GUpCHZVLKNh1RkcBEuoYSkJ9LpdQsOuMPgdIqC9QEuq4XELBrjM6DpBQX6Ik1Am5hIJdZ3QCIKG+Qkmor+USCnad0dcACfUNSkJ9K5dQsOuMvgVIqO9QEup7uYSC3Xfpe4CE+gEloX6USyjY9VA/AiTUTygJ9bNcQsGuh/oZIKF+QUmoX+USCnY91K8ACfUbSkL9LkY0GXY91O8ACfUHSkL9KZdQsOuh/gRIKF8cSELFiBFNhl0PFRMX/RxjURLKL5dQsOuh/AAJFYeSUPFyCQW7HioeIKESUBIqj1xCwa6HygOQUHlREiqfXELBrofKB5BQ+VESqoBcQsGuhyoAkFDnoCRUQbmEgl0PVRAgoc5FSahCcgkFux6qEEBCnYeSUIXlEgp2PVRhgIQqgpJQReUSCnY9VFGAhDofJaGKySUU7HqoYgAJdQFKQl0ol1Cw66EuBEio4igJVUIuoWDXQ5UASKiSKAlVSi6hYNdDlQJIqIukOUoTbOj3+Vr45RP0YsHA44Jxx/vOPKT1qObTGQGkeVYF4VlFmGesML9OlPsd5ZYt2S7UVlf/aT0RPLpFcNlWrIfnJXGnvpamrzHSpDsQaRMhIXI6cBnBtjoIJhbr5w+az8KWoa9xwe95RdfoIM2EO0gzwQ6SferI9EU4cti2DX3w6lsmmNRlQ1UpZAr/ICbse2WDRvl88r2WReykULn/TJAdtTTi7qIQty+PzmgdJ8MzMcjTlomTi7ms3CzNCuaNlfAi0sAgXSwkvbhU0AuNfsdJzQXNL6yhVsHNaVvlotwPzpdycfLjYLm46B7/ub1mCuP/ZVEedyWluC+P8rgrKsV9RZTH3divE3f5KI+7gpLfFaI87huU/K4Y5XHXU4q7UpTH3UQp7sqCcfNcrwChQrA9rpFcL3js5HGE+xTnF2vNf7en//8W4Yf0XPVKOW0DgudLAelzV+lc5znllQpz1SqCuR4bzPXwQ1JXDW2rxEU/x6rSHGOFCXLA5QRP5rktDlqaZ1VBjtVwOo/9N3eeagocTx7iV3Jyf3VUuZLDg4VRqI7WVUdrATp4YrRXR14UIV0dExWqY6IgxyRXHSE6TxJKdUzO/dUxUcNgHiySFapjiquONgWgg6dGe3XkpXjS1TFVoTqmCnJMc9URovOkoVTHQO6vjkkaBvNgEVCojumuOtp0gA5ePdqrIy8ulq6O1RWqY3VBjjVcdYToPDVQquNVub86JmsYzIPFVQrVsaarjrYmQAe/OtqrIz8eJV0dr1aojlcLcrzGVUeIznMNSnWslfurY4qGwScHHoXqeK2rjvZagA5eO9qrY+k4+epYW6E61hbkWMdVR4jOUwelOl6X+6tjqobBPFhcp1Ad67rqaOsCdPB60V4dOwYfAJdqL7R1hXTC1xcWMlaYH3d0QbNPDhz1FWYZ9QRnGQ3cLANiEGqAMsu4PvfPMtI0DObB4nqFWUZDN8uwDQE6eKNon2VconAO3kihOjYS5NjYVUeIztMYpTo2EZxeRts+O/9py6dTHZsoVMcbBBPHu98Xt1tGKdlDA7H0wCk5uDdV0rVpUFfUmUhPgBfjNpMcTFGNGgFgVHNnlLGjAIxq4YwydgyAUS2dUcaOBTCqlTPK2HEARrV2Rhk7HsCoNs4oYycAGNXWGWXsRACj2jmjjJ0EYFR7Z5SxkwGM6uCMMnYKgFEdnVHGTgUwqpMzythpAEZ1dkYZOx3AqC7OKGNnABjV1Rll7EwAo7o5o4ydBWBUhjPK2DkARmU6o4ydC2BUd2eUsfMAjOrhjDJ2PoBRWc4oYxcAGJXtjDJ2IYBRPZ1Rxi4CMKqXM8rYxQBG9XZGGbsEwKg+zihjlwIY1dcZZewyAKP6OaOMXQ5g1I3OKGNXAhjV3xll7GoAowY4o4xdC2DUTc4oY9cDGDXQGWXsBgCjbnZGGbsRwKhbnFHGbgIwapAzytjNAEYNdkYZuwXAqFudUcZuBTDqNq29YGLDiEpsgCTV1u2C+8p4Y5be/2ZI7t//JuLWlCZnh+XtPe8U3uLzYoX9dIYKdr64oI4xvjMP6UEjWa4t4+V7R5wi4Tvi5NsdJjgoacU9LO60wELtRuQqMcDz/q9+YQ3KCQ6i9QX9LpZH1w+Ts+OsG2flNO47Bf0oprwRW45flhzsf9IFLkWQ4/C46M5DzpfhCsX3LqVN1+7ybGYXOqT70HDBcWhEnG4fMjk71MahkdE5DqlMiEMbQkq1xydQQxT65CjhCTEfnunPf45onhBr8kwE4TlSuSblNE/5zSk83kv3U79gW6kKXsdoGT5cuON7zfH5dAbUocID6lDBE7XsU8dfL8nJtG1DH7z6jg5yHxMXTI7QbGh0sEp4vzdGcbvfkDHSPb54lJ+t3a4Ud4k8OhUjToZnYpCnHS04Ix4j2LEF88ZKeOEdGKRzhQfx0UpXmzQuEd8lfIk4U+EtUHfHRb+OI4V17K6g41gAHUcL69hDQcd7AHS8W1jHLAUdxwHoeI+wjtkKOt4b5VcvWcd7FeIeDxD3fQpx3wcQ9/0KcU8AiPsBhbjvB4j7QYW4JwLE/ZBC3A8AxP2wQtyTAOJ+RCHuBwHiflQh7skAcT+mEPdDAHE/rhD3FIC4n1CI+2GAuGcrxD0VIO4nFeJ+BCDupxTingYQ99MKcT8KEPczCnFPB4j7WYW4HwOI+zmFuGcAxP28QtyPA8T9gkLcMwHiflEh7icA4n5JIe5ZAHG/rBD3bIC4VyjEPQcg7lUKcT8JEPcahbjnAsS9TiHupwDifkUh7nkAcb+qEPfTAHG/phD3fIC4X1eI+xmAuN9QiHsBQNxvKsT9LEDcbynEvRAg7rcV4n4OIO53FOJeBBD3uwpxPw8Q93sKcS8GiPt9hbhfAIj7A4W4lwDE/aFC3C8CxP2RQtxLAeL+WCHulwDi3q8Q9zKAuD9RiPtlgLgPKcS9HCDuTxXiXgEQ92cKca8EiPuYQtyrAOL+QiHu1QBxf6kQ9xqAuL9SiHstQNzfKMS9DiDu7xTiXg8Q9w8Kcb8CEPdPCnFvAIj7F4W4XwWI+zeFuDcCxP2HQtyvAcTtU9i3YxNA3LEKcb8OEHecQtybAeJOUIj7DYC48yrEvQUg7vwKcb8JEPc5CnFvBYj7XIW43wKI+zyFuLcBxF1EIe63AeI+XyHu7QBxX6AQ9zsAcRdXiHsHQNwlFeJ+FyDuixTi3ikYN58ynkNoFmyP94jj/c14by7eV4r3ROL9gXivHN43hvdQ4f1EeG8N3meC91zg/Qf4WXx+Lp2f0ebnlfnZXX6OlZ/p5Ocb+Vk/fu6NnwHj56H42SB+ToafGeHnJ/hZAl5Xz2vMeb01rz3mdbi8JpXXZ/JaRV63x2vYeD0Xr23idT685oXXf/BaCF4XwPfI+X4x3zvl+4h8T43vL/G9Fr7vwNfg+Xo0X5vl65R8zY6vX/G1HL6uwef4fL7L5358HsTnBDw/5rkiz5t4DsH1lGsLj7M85nD/41xkX8IPv7D378l5nyK4n2RKiSjf05T3k3xPoS++L9gXY4N9MfyQ1FVDW0kNtDjukuYYK0yQA5Z8FQO3xUFL89wlyPEDnM5j/82d5wMFjicP6eq4O/dXR5X3ovBgsVuhOn7oqqP9EKCD74n26sgvRZGujnsUquMeQY4fueoI0Xk+QqmOe3N/dUzUMJgHi70K1fFjVx3txwAdfJ80R+lE4oEi9BopycD9gm2lCsa7X9iQWGE/eMAQTJqTA9B+hdnKPsHZygE3W4EYzA6gzFY+yf2zlSQNg3mw+ERhtnLQzVbsQYAOfijaz+V5ji59Ln9IoToeEuR42FVHiM5zGKU6fpr7q2OyhsE8WHyqUB2PuOpojwB08M+ivTpygo4Uro6fKVTHzwQ5HnXVEaLzHEWpjscEL75E21t3Q21pGMyDxTGF6vi5YOLE+E6//ZvbLeM7NbghVsye/ujn+IVkp0c1agSAUcedUcaOAjDqS2eUsWMAjDrhjDJ2LIBRXzmjjB0HYNTXzihjxwMY9Y0zytgJAEZ964wydiKAUd85o4ydBGDU984oYycDGPWDM8rYKQBG/eiMMnYqgFE/OaOMnQZg1M/OKGOnAxj1izPK2BkARv3qjDJ2JoBRvzmjjJ0FYNTvzihj5wAY9Yczyti5AEb96Ywydh6AUb54Z5SdD2BUjDPK2AUARsU6o4xdCGCU3xll7CIAo+KcUcYuBjAq3hll7BIAoxKcUcYuBTAqjzPK2GUARuV1Rhm7HMCofM4oY1cCGJXfGWXsagCjCjijjF0LYNQ5zihj1wMYVdAZZewGAKPOdUYZuxHAqELOKGM3ARh1njPK2M0ARhV2Rhm7BcCoIs4oY7cCGFXUGWXsNgCjzndGGbsdwKhizihjdwAYdYEzytidAEZd6IyiqS+AUcWdUcbuAjCqhDPK2N0ARpV0Rhm7B8CoUs4oY/cCGHWRM8rYfQBGXeyMMvYAgFGXOKOMPQhgVGlnlLGHAYwq44wy9giAUWWdUcYeBTDqUmeUsZ8DGFXOGWXscQCjLnNGGXsCwKjLnVHGfg1g1BXOKGO/BTCqvDPK2O8BjKrgjDL2RwCjKjqjjP0ZwKhKzihjfwUwqrIzytjfAYy60hll7J8ARlVxRhkbA/AaxqrOKGP9AEZVc0YZGw9glHFGGZsHwCjrjDI2H4BRic4oYwsAGJXkjDK2IIBRyc4oYwsBGJXijDK2MIBRqc4oY4sCGJXmjDK2GIBRAWeUsRcCGJXujDK2BIBR1Z1RxpYCMKpGvDzHk4c/jGiSSU1OzkpLzLJJNsMkpmcGUkxySmZqwAZsSiClR2IgKSkrkBxIS89MTzPpNjkpy2anpCdlBxu/So6oLZ5HsDfKtWXiggbH+848xM/LfDrGi5/og/BMFOYZK8xvOCXXnXIDkh1BbY2MO60ngkf7BQfkWA/PmsEOezV9jZEmPYxIp0RIiJwOqCmCbQ0TTCzWzx80n4UtQ1/jgt/ziq7RQUYJd5BRgh0k+9SR6Ytw5LBtG/rg1feaYFLXig+aETKFfxAT9r1aQaN8PvleGzImvN2cJm3VPLKjlnTcI5TirpZHZ7SOk+GZGORpr4mXi7mW4OxRMG+shBeRBgbpYiHpxbWCXmj0Oy6MXNCkz2C0Cm5O26od5X5wvtSOlx8Hawuf+kr3uXLk8WWCExJur1mc/MTpMsFcrAPgyeXCnjRX8ORyQU+uA/DkCmFPWih4coWgJ3UBPCkv7ElLBU/KC3pSD8CTCsKetFLwpIKgJ/UBPKko7ElrBU8qCnrSAMCTSsKetFHwpJKgJ9cDeFJZ2JO2Cp5UFvSkobAn4luCUKztFK5PNQKIu71C3I0B4u6gEHcTgLg7KsR9A0DcnRTibgoQd2eFuJsBxN1FIe7mAHF3VYi7BUDc3RTibgkQd4ZC3K0A4s5UiLs1QNzdFeJuAxB3D4W42wLEnaUQdzuAuLMV4m4PEHdPhbg7AMTdSyHujgBx91aIuxNA3H0U4u4MEHdfhbi7AMTdTyHurgBx36gQdzeAuPsrxJ0BEPcAhbgzAeK+SSHu7gBxD1SIuwdA3DcrxJ0FEPctCnFnA8Q9SCHungBxD1aIuxdA3LcqxN0bIO7bFOLuIxg3r+UuSKgQbI/XmfK6Rl5Hx+u2eJ0Qr0vhdRB8353vQfP9WL43yffp+J4V37/hexl8XZ+vcfP1Xr72ydcB+ZoYXx/iayV83YDPofl8ks+t+DyD59w8/+S5GM9LuEZzveKxm8cx7tOc3+x1nwiPf0qvRe8rp21A8HmIQLUofyaH14z3VViL3k8w12ODuR5+SOqqoa2kBlocb5TmGCtMkAOuLfiwDrfFQUvzvFGQY3+czmP/zZ2nvwLHk4d0dRyQ+6ujypNaPFgMUKiON7nqaG8C6OADo7068qYn0tVxoEJ1HCjI8WZXHSE6z80o1fGW3F8dEzUM5sHiFoXqOMhVRzsIoIMPjvbqyFttSVfHwQrVcbAgx1tddYToPLeiVMfbcn91TNIwmAeL2xSq4+2uOtrbATr4kGivjrx5oHR1HKJQHYcIchzqqiNE5xmKUh3vyP3VMVnDYB4s7lCojsNcdbTDADr4ndFeHfmKiXR1vFOhOt4pyHG4q44QnWc4SnW8K/dXxxQNg3mwuEuhOo5w1dGOAOjgI6O9OvLG8NLVcaRCdRwpyHGUq44QnWcUSnUcnfurY6qGwTxYjFaojmNcdbRjADr43dFeHfm1NMMVXk0jnfBjhYWMFebHHV3Q7JMDx1iFWcbdgrOMe9wsA2IQugdlljEu988y0jQM5sFinMIs4143y7D3AnTw8dE+y6ipcA4+XqE6jhfkeJ+rjhCd5z6U6jhBcHoZbe/RCrWlYTAPFhMUquP9gonjfZ8ft1tGKdlDA7H0wCk5uE9U0nViUFfUmUhPf/RzfEByMIW9bQNg1CRnFF1+BzDqQWcUXWUBMGqyM8rYsQBGPeSMMnYcgFFTnFF0SQLAqIedUcZOADBqqjPK2IkARj3ijKJzFACjpjmjaOoLYNSjziiaUQEYNd0ZRYUawKjHnFE0/gMYNcMZRcMKgFGPO6MoWwGMmumMIhEAjHrCGWXsLACjZjmjjJ0DYNRsZ5SxcwGMmuOMMnYegFFPOqOMnQ9g1FxnlLELAIx6yhll7EIAo+Y5o4xdBGDU084oYxcDGDXfGWXsEgCjnnFGGbsUwKgFzihjlwEY9awzytjlAEYtdEYZuxLAqOecUcauBjBqkTPK2LUARj3vjDJ2PYBRi51Rxm4AMOoFZ5SxGwGMWuKMMnYTgFEvOqOM3Qxg1FJnlLFbAIx6yRll7FYAo5Zp7QUTG0ZUYgMkqbZeFtxXxhuz9P43y3P//jcRt6Y0OTssb+95THiLz6sU9tNZIdj54oI6xvjOPKQHjXS5toyX78p4RcIr4+XbXSU4KGnFvSr+tMBC7UbkKjHA8/6vfmENagsOomMF/W6VR9cPk7PjrBtn5TTu1YJ+tFLeiC2nsVYP9j/pAlddkOOa+OjOQ86XNQrFd63SpmtrPZvZhQ7pPrRGcBxaF6/bh0zODrVxaH10jkMqE+LQhpBS7fEJ1HKFPvmK8ISYj9BX7xHNE2JNnmkgPNcr16Sc5mkN36nxXrqf+gXbqqHgdYyW4WuEO77XHJ9PZ0BdITygrhA8Ucs+dfz1kpxM2zb0wavvhiD3V+ODyRGaDW0IVgnv915V3O43ZIx0j28b5WdrLyvF3S6PTsWIk+GZGORpNwjOiF8V7NiCeWMlvPAODNK5woP4BqWrTRqXiL8QvkR8t8JboDbGR7+Ox4V1HKug42sAOn4prOM9CjpuAtDxhLCO4xR0fB1Ax6+EdbxXQcfNADp+LazjeAUd3wDQ8RthHe9T0HELgI7fCus4QUHHNwF0/E5Yx/sVdNwKoOP3wjpOVNDxLQAdfxDW8QEFHbcB6PijsI6TFHR8G0DHn4R1fFBBx+0AOv4srONkBR3fAdDxF2EdH1LQcQeAjr8K6zhFQcd3AXT8TVjHhxV03Amg4+/COk5V0PE9AB3/ENbxEQUd3wfQ8U9hHacp6LgLQEdfvKyOjyro+AGAjjHCOk5X0HE3gI6xwjo+pqDjhwA6+oV1nKGg4x4AHeOEdXxcQcePAHSMF9ZxpoKOewF0TBDW8QkFHT8G0DGPsI6zFHTcB6BjXmEdZyvouB9Ax3zCOs5R0PEAgI75hXV8UkHHTwB0LCCs41wFHQ8C6HiOsI5PKeh4CEDHgsI6zlPQ8TCAjucK6/i0go6fAuhYSFjH+Qo6HgHQ8TxhHZ9R0PEzAB0LC+u4QEHHowA6FhHW8VkFHY8B6FhUWMeFCjp+DqDj+cI6Pqeg4xcAOhYT1nGRgo7HAXS8QFjH5xV0/BJAxwuFdVysoOMJAB2LC+v4goKOXwHoWEJYxyUKOn4NoGNJYR1fVNDxGwAdSwnruFRBx28BdLxIWMeXFHT8DkDHi4V1XKag4/cAOl4irOPLCjr+AKBjaWEdlyvo+COAjmWEdVyhoONPADqWFdZxpYKOPwPoeKmwjqsUdPwFQMdywjquVtDxVwAdLxPWcY2Cjr8B6Hi5sI5rFXT8HUDHK4R1XKeg4x8AOpYX1nG9go5/AuhYQVjHVxR09CVEv44VhXXcoKBjDICOlYR1fFVBx1gAHSsL67hRQUc/gI5XCuv4moKOcQA6VhHWcZOCjvEAOlYV1vF1BR0TAHSsJqzjZgUd8wDoaIR1fENBx7wAOlphHbco6JgPQMdEYR3fVNAxP4COScI6blXQsQCAjsnCOr6loOM5ADqmCOu4TUHHggA6pgrr+LaCjucC6JgmrON2BR0LAegYENbxHQUdzwPQMV1Yxx0KOhYG0LG6sI7vKuhYBEDHGsI67lTQsaigjvzeqnMJzYLt8TtZ+H0i/C4Mfo8Dv4OA98/fQuB9y3nPbd4vmvc65n16eY9Z3h+V9/bkfSl5T0XeD5D3suN92HgPMd7/ivdu4n2HeM8c3u+F9yrhfTZ4jwje34CfzefnyvmZaH6el59F5eco+RlAfn7tGIGfG+JnXvh5DX7WgNfJ8xpvXp/Ma2t5XSivaeT1eLyWjNdB8RoeXn/Cayf4vj/fs+b7rXyvkO9z8T0avr/A18b5ui5fk+TraXwtiK9j8Dk4nz/yuQ/P23nOyfMlrvVcp3iM5fGBc5t9CT/8wt6fL+d9iuD7m1LaRfk7xPj9TayddF8sJtgXY4N9MfyQ1FVD22IJ0c/xAmmO0sWHA5Z89TG3xUFL8/QKmVOOF+J0Hvtv7jwXKnA8eUhXx+K5vzqqvIecB4viCtWxhKuOtgRABy8Z7dWRX0IuXR1LKlTHkoLVsZSrjhCdpxRKdbwo91fHRA2DebC4SKE6Xuyqo70YoINfIs1RfEEitVHDd+aAYXJ2WL9gWzUE4y2tfCFZYnYhmDQnB6DSCrOVSwRnK2XcbAViMCuDMlspm/tnK0kaBvNgUVZhtnKpm63YSwE6eLloP5dP88mfy5dTqI7lBKvjZa46QnSey1Cq4+W5vzomaxjMg8XlCtXxClcd7RUAHbx8tFdHTtD1wtWxvEJ1LC9YHSu46gjReSR98qGOcj390c+xojPK2BEARlVyRhk7CsCoys4oY8cAGHWlM8rYsQBGVXFGGTsOwKiqzihjxwMYVc0ZZewEAKOMM8rYiQBGWWeUsZMAjEp0Rhk7GcCoJGeUsVMAjEp2Rhk7FcCoFGeUsdMAjEp1Rhk7HcCoNGeUsTMAjAo4o4ydCWBUujPK2FkARlV3Rhk7B8CoGs4oY+cCGHWVM8rYeQBG1XRGGTsfwKirnVHGLgAw6hpnlLELAYyq5YwydhGAUdc6o4xdDGBUbWeUsUsAjKrjjDJ2KYBR1zmjjF0GYFRdZ5SxywGMqueMMnYlgFH1nVHGrgYwqoEzyti1AEZd74wydj2AUQ2dUcZuADCqkTPK2I0ARjV2Rhm7CcCoJs4oYzcDGHWDM8rYLQBGNXVGGbsVwKhmzihjtwEY1dwZZex2AKNaOKOM3QFgVEtnlLE7AYxq5YwytjCAUa2dUcbuAjCqjTPK2N0ARrV1Rhm7B8Cods4oY/cCGNXeGWXsPgCjOjijjD0AYFRHZ5SxBwGM6uSMMvYwgFGdnVHGHgEwqoszytijAEZ1dUYZ+zmAUd2cUcYeBzAqwxll7AkAozKdUcZ+DWBUd2eUsd8CGNXDGWXs9wBGZTmjjP0RwKhsZ5SxPwMY1dMZZeyvAEb1ckYZ+zuAUb2dUcb+CWBUH2eUsTFx0c+xrzPKWD+AUf2cUcbGAxh1ozPK2DwARvV3RhmbD8CoAc4oYwsAGHWTM8rYggBGDXRGGVsIwKibnVHGFgYw6hZnlLFFAYwa5IwythiAUYOdUcZeCGDUrc4oY0sAGHWbM8rYUgBG3S5pVFyQYPyZXokTT/fJi6vBMwDCM02YZ6wwvzWUVKvj5dpbR22t9yQqgkelBTtrrIfnkIRTX4fS1xhp0qtI5OoREiLJpCYnZ6UlZtkkm2ES0zMDKSY5JTM1YAM2JZDSIzGQlJQVSA6kpWemp5l0m5yUZbNT0pOygw1XF2xrlWBisX7+oPksbBn6Ghf8nld0jQ7yinAHeUWwg2SfOjJ9EY4ctm1DH7z63hFM6mEJQTNCpvAPYsK+NyxolM8n32tDxoS3m9Ok9eeVHbWk416nFHdcXp3ROk6GZ2KQp70jQS7mYXIjvxXMGyvhRaSBQbpYSHpxp6AXGv2OCyMXNL+whloFN6dtDY9yPzhfhifIj4PDE2THQek+V5s8riM4IeH2HoiXnzjVEczFuwA8uU7Yk0kKnlwn6MkIAE/qCnvyoIIndQU9GQngST1hTyYreFJP0JNRAJ7UF/bkIQVP6gt6MhrAkwbCnkxR8KSBoCdjADy5XtiThxU8uV7Qk7sBPGko7MlUBU8aCnoyFsCTRsKePKLgSSNBT+4B8KSxsCfTFDxpLOjJOABPmgh78qiCJ00EPbkXwJMbhD2ZruDJDYKejAfwpKmwJ48peNJU0JP7ADxpJuzJDAVPmgl6MgHAk+bCnjyu4ElzQU/uB/CkhbAnMxU8aSHoyUQAT1oKe/KEgictBT15AMCTVsKezFLwpJWgJ5MAPGkt7MlsBU9aC3ryIIAnbYQ9maPgSRtBTyYDeNJW2JMnFTxpK+jJQwCetBP2ZK6CJ+0EPZkC4El7YU+eUvCkvaAnDwN40kHYk3kKnnQQ9GQqgCcdhT15WsGTjoKePALgSSdhT+YreNJJ0JNpAJ50FvbkGQVPOgt68iiAJ12EPVmg4EkXQU+mA3jSVdiTZxU86SroyWMAnnQT9mShgifdBD2ZAeBJhrAnzyl4kiHoyeMAnmQKe7JIwZNMQU9mAnjSXdiT5xU86S7oyRMAnvQQ9mSxgic9BD2ZBeBJlrAnLyh4kiXoyWwAT7KFPVmi4Em2oCdzADzpKezJiwqe9BT05EkAT3oJe7JUwZNegp7MBfCkt7AnLyl40lvQk6cAPOkj7MkyBU/6CHoyT9AT3kuhEKFCsD1+zpufK+bnWPm5SX5Oj58L4+eQ+LkXfs6C1/XzOnJet8zrZHldJq8D5HVnvM6J19XwOg5eN8D3qfm+KN+H4/s+fJ+Br2vzdVS+bsfXifi6BJ8H83kXz/N5XsnzGK6bPE7zuMB5OC+48Y33kN4L4mk5bQOC+5EE4qJ8Txzes+Fphb0g5gvvDFbozBQS1VVDW0kNtDg+I81RegDmgIcLbpbDbXHQ0jyfEeS4AKfz2H9z51mgwPHkIV0dn8391VFlpyQeLJ5VqI4LXXW0CwE6+HPRXh1502Hp6vicQnV8TpDjIlcdITrPIpTq+Hzur46JGgbzYPG8QnVc7KqjXQzQwV+I9urIW91LV8cXFKrjC4Icl7jqCNF5lqBUxxdzf3VM0jCYB4sXFarjUlcd7VKADv5StFfH0gny1fElher4kiDHZa46QnSeZSjV8eXcXx2TNQzmweJlheq43FVHuxygg6+I9urIrx+Tro4rFKrjCkGOK111hOg8K1Gq46rcXx1TNAzmwWKVQnVc7aqjXQ3QwddEe3UcqnDuuEahOq4R5LjWVUeIzrMWpTquy/3VMVXDYB4s1ilUx/WuOtr1AB38lWivjvxa6DWCDzeEXg0tnfAbhIWMFebHHV3Q7JMDxwaFWcYrgrOMV90sA2IQehVllrEx988y0jQM5sFio8Is4zU3y7CvAXTwTdE+yxiicA6+SaE6bhLk+LqrjhCd53VpjtIEQ51HOtklO+RmQRFZP39QR263jO9U7IjVo6c/+jm+IdkBUI0aAWDUFmeUsaMAjHrTGWXsGACjtjqjjB0LYNRbzihjxwEYtc0ZZex4AKPedkYZOwHAqO3OKGMnAhj1jjPK2EkARu1wRhk7GcCod51Rxk4BMGqnM8rYqQBGveeMMnYagFHvO6OMnQ5g1C5nlLEzAIz6wBll7EwAo3Y7o4ydBWDUh84oY+cAGLXHGWXsXACjPnJGGTsPwKi9zihj5wMY9bEzytgFAEbtc0YZuxDAqP3OKGMXARh1wBll7GIAoz5xRhm7BMCog84oY5cCGHXIGWXsMgCjDjujjF0OYNSnzihjVwIYdcQZZexqAKM+c0YZuxbAqKPOKGPXAxh1zBll7AYAoz53Rhm7EcCoL5xRxm4CMOq4M8rYzQBGfemMMnYLgFEnnFHGbgUw6iut3a1iw4jmdI8MyaBr+nSClo45RjDmq0FijhWM+RqQmP2CMdf6h2I2OTvstYL61fbrxCw92Nb2YfCsA8LzOhCedUF41gPhWR+EZwMQnteD8GwIwrMRCM/GIDybgPC8AYRnUxCezUB4Ngfh2QKEZ0sQnq1AeLYG4dkGhGdbEJ7tQHi2B+HZAYRnRxCenUB4dgbh2QWEZ1cQnt1AeGaA8MwE4dkdhGcPEJ5ZIDyzQXj2BOHZC4RnbxCefUB49gXh2Q+E540gPPuD8BwAwvMmEJ4DQXjeDMLzFhCeg0B4DgbheSsIz9tAeN4OwnMICM+hIDzvAOE5DITnnSA8h4PwvAuE5wgQniNBeI4C4TkahOcYEJ53g/AcC8LzHhCe40B43gvCczwIz/tAeE4A4Xk/CM+JIDwfAOE5CYTngyA8J4PwfAiE5xQQng+D8JwKwvMREJ7TQHg+CsJzOgjPx0B4zgDh+TgIz5kgPJ8A4TkLhOdsEJ5zQHg+CcJzLgjPp0B4zgPh+TQIz/kgPJ8B4bkAhOezIDwXgvB8DoTnIhCez4PwXAzC8wUQnktAeL4IwnMpCM+XQHguA+H5MgjP5SA8V4DwXAnCcxUIz9UgPNeA8FwLwnMdCM/1IDxfAeG5AYTnqyA8N4LwfA2E5yYQnq+D8NwMwvMNEJ5bQHi+CcJzKwjPt0B4bgPh+TYIz+0gPN8B4bkDhOe7IDx3gvB8D4Tn+yA8d4Hw/ACE524Qnh+C8NwDwvMjEJ57QXh+DMJzHwjP/SA8D4Dw/ASE50EQnodAeB4G4fkpCM8jIDw/A+F5FITnMRCen4Pw/AKE53EQnl+C8DwBwvMrEJ5fg/D8BoTntyA8vwPh+T0Izx9AeP4IwvMnEJ4/g/D8BYTnryA8fwPh+TsIzz9AeP4JwpMbROAZA8IzFoSnH4RnHAjPeBCeCSA884DwzAvCMx8Iz/wgPAuA8DwHhGdBEJ7ngvAsBMLzPBCehUF4FgHhWRSE5/kgPIuB8LwAhOeFIDyLg/AsAcKzJAjPUiA8LwLheTEIz0tAeJYG4VkGhGdZEJ6XgvAsB8LzMhCel4PwvEKYZ6wwv+EJPt9dCafbSzKpyclZaYlZNslmmMT0zECKSU7JTA3YgE0JpPRIDCQlZQWSA2npmelpJt0mJ2XZ7JT0pOxgg9zeGwnyPMvHyHH0xmtyeGh5MkLYky0KnlQQ9GQEgCcjhT15U8GTioKejATwZJSwJ1sVPKkk6MkoAE9GC3vyloInlQU9GQ3gyRhhT7YpeHKloCdjADy5W9iTtxU8qSLoyd0AnowV9mS7gidVBT0ZC+DJPcKevKPgSTVBT+4B8GScsCc7FDwxgp6MA/DkXmFP3lXwxAp6ci+AJ+OFPdmp4EmioCfjATy5T9iT9xQ8SRL05D4ATyYIe/K+gifJgp5MAPDkfmFPdil4kiLoyf0AnkwU9uQDBU9SBT2ZCODJA8Ke7FbwJE3QkwcAPJkk7MmHCp4EBD2ZBODJg8Ke7FHwJF3QkwcBPJks7MlHCp5UF/RkMoAnDwl7slfBkxqCnjwE4MkUYU8+VvDkKkFPpgB48rCwJ/sUPKkp6MnDAJ5MFfZkv4InVwt6MhXAk0eEPTmg4Mk1gp48AuDJNGFPPlHwpJagJ9MAPHlU2JODCp5cK+jJowCeTBf25JCCJ7UFPZkO4Mljwp4cVvCkjqAnjwF4MkPYk08VPLlO0JMZAJ48LuzJEQVP6gp68jiAJzOFPflMwZN6gp7MBPDkCWFPjip4Ul/QkycAPJkl7MkxBU8aCHoyC8CT2cKefK7gyfWCnswG8GSOsCdfKHjSUNCTOQCePCnsyXEFTxoJevIkgCdzhT35UsGTxoKezAXw5ClhT04oeNJE0JOnADyZJ+zJVwqe3CDoyTxlT3LKb028z1dR0JN11N7GePl9BprGRL+OlYR1fE1Bx2YAOlYW1nGTgo7NAXS8UljH1xV0bAGgYxVhHTcr6NgSQMeqwjq+oaBjKwAdqwnruEVBx9YAOhphHd9U0LENgI5WWMetCjq2BdAxUVjHtxR0bAegY5KwjtsUdGwPoGOysI5vK+jYAUDHFGEdtyvo2BFAx1RhHd9R0LETgI5pwjruUNCxM4COAWEd31XQsQuAjunCOu5U0LErgI7VhXV8T0HHbgA61hDW8X0FHTMAdLxKWMddCjpmAuhYU1jHDxR07A6g49XCOu5W0LEHgI7XCOv4oYKOWQA61hLWcY+CjtkAOl4rrONHCjr2BNCxtrCOexV07AWgYx1hHT9W0LE3gI7XCeu4T0HHPgA61hXWcb+Cjn0BdKwnrOMBBR37AehYX1jHTxR0vBFAxwbCOh5U0LE/gI7XC+t4SEHHAQA6NhTW8bCCjjcB6NhIWMdPFXQcCKBjY2EdjyjoeDOAjk2EdfxMQcdbAHS8QVjHowo6DgLQsamwjscUdBwMoGMzYR0/V9DxVgAdmwvr+IWCjrcB6NhCWMfjCjreDqBjS2Edv1TQcQiAjq2EdTyhoONQAB1bC+v4lYKOdwDo2EZYx68VdBwGoGNbYR2/UdDxTgAd2wnr+K2CjsMBdGwvrON3CjreBaBjB2Edv1fQcQSAjh2FdfxBQceRADp2EtbxRwUdRwHo2FlYx58UdBwNoGMXYR1/VtBxDICOXYV1/EVBx7sBdOwmrOOvCjqOBdAxQ1jH3xR0vAdAx0xhHX9X0HEcgI7dhXX8Q0HHewF07CGs458KOo4H0DFLWEdfgryO9wHomC2sY4yCjhMAdOwprGOsgo73A+jYS1hHv4KOEwF07C2sY5yCjg8A6NhHWMd4BR0nAejYV1jHBAUdHwTQsZ+wjnkUdJwMoOONwjrmVdDxIQAd+wvrmE9BxykAOg4Q1jG/go4PA+h4k7COBRR0nAqg40BhHc9R0PERAB1vFtaxoIKO0wB0vEVYx3MVdHwUQMdBwjoWUtBxOoCOg4V1PE9Bx8cAdLxVWMfCCjrOANDxNmEdiyjo+DiAjrcL61hUQceZwjqGDmmeT4DwnAXCczYIzzkgPJ8E4TkXhOdTIDzngfB8GoTnfBCez4DwXADC81kQngtBeD4HwnMRCM/nQXguBuH5AgjPJSA8XwThuRSE50sgPJeB8HwZhOdyEJ4rQHiuBOG5CoTnahCea0B4rgXhuQ6E53oQnq+A8NwAwvNVEJ4bQXi+BsJzEwjP10F4bgbh+QYIzy0gPN8E4bkVhOdbIDy3gfB8G4TndhCe74Dw3AHC810QnjtBeL4HwvN9EJ67QHh+AMJzNwjPD0F47gHh+REIz70gPD8G4bkPhOd+EJ4HQHh+AsLzIAjPQyA8D4Pw/BSE5xEQnp+B8DwKwvMYCM/PQXh+AcLzOAjPL0F4ngDh+RUIz69BeH4DwvNbEJ7fgfD8HoTnDyA8fwTh+RMIz59BeP4CwvNXEJ6/gfD8HYTnHyA8/wTh6YvF4BkDwjMWhKcfhGccCM94EJ4JIDzzgPDMC8IzHwjP/CA8C4DwPAeEZ0EQnueC8CwEwvM8EJ6FQXgWAeFZFITn+SA8i4HwvACE54UgPIuD8CwBwrMkCM9SIDwvAuF5MQjPS0B4lgbhWQaEZ1kQnpeC8CwHwvMyEJ6Xg/C8AoRneRCeFUB4VgThWQmEZ2UQnleC8KwCwrMqCM9qIDwNCE8LwjMRhGcSCM9kEJ4pIDxTQXimgfAMgPBMB+FZHYRnDRCeV4HwrAnC82oQnteA8KwFwvNaEJ61QXjWAeF5HQjPuiA864HwrA/CswEIz+tBeDYE4dkIhGdjEJ5NQHjeAMKzKQjPZiA8m4PwbAHCsyUIz1YgPFuD8GwDwrMtCM92IDzbg/DsAMKzIwjPTiA8O4Pw7ALCsysIz24gPDNAeGaC8OwOwrMHCM8sEJ7ZIDx7gvDsBcKzNwjPPiA8+4Lw7AfC80YQnv1BeA4A4XkTCM+BIDxvBuF5CwjPQSA8B4PwvBWE520gPG8H4TkEhOdQEJ53gPAcBsLzThCew0F43gXCcwQIz5EgPEeB8BwNwnMMCM+7QXiOBeF5DwjPcSA87wXhOR6E530gPCeA8LwfhOdEEJ4PgPCcBMLzQRCek0F4PgTCcwoIz4dBeE4F4fkICM9pIDwfBeE5HYTnYyA8Z4DwfByE50wQnk+A8JwFwnM2CM85IDyfBOE5F4TnUyA854HwfBqE53wQns+A8FwAwvNZEJ4LQXg+B8JzEQjP50F4Lgbh+QIIzyUgPF8E4bkUhOdLIDyXgfB8GYTnchCeK0B4rgThuQqE52oQnmtAeK4F4bkOhOd6EJ6vgPDcAMLzVRCeG0F4vgbCcxMIz9dBeG4G4fkGCM8tIDzfBOG5FYTnWyA8t4HwfBuE53YQnu+A8NwBwvNdEJ47QXi+B8LzfRCeu0B4fgDCczcIzw9BeO4B4fkRCM+9IDw/BuG5D4TnfhCeB0B4fgLC8yAIz0MgPA+D8PwUhOcREJ6fgfA8CsLzGAjPz5V4xobxTDKpyclZaYlZNslmmMT0zECKSU7JTA3YgE0JpPRIDCQlZQWSA2npmelpJt0mJ2XZ7JT0pOxg2+UFY/5COGbpWIck+HzDE+Ti5bY2EPzCuXM8Vi5mb7w5bWtDAkZOxwl68SVIP44XjPkESMwJgjF/BRJzHsGYvwaJOa9gzN+AxJxPMOZvQWLOLxjzdyAxFxCM+XuQmM8RjPkHkJgLCsb8I0jM5wrG/BNIzIUEY/4ZJObzBGP+BSTmwoIx/woScxHBmH8DibmoYMy/g8R8vmDMf4DEXEww5j9BYr5AMGa+CIYQ84WCMceAxFxcMOZYkJhLCMbsB4m5pGDMcSAxlxKMOR4k5osEY04AifliwZjzgMR8iWDMeUFiLi0Ycz6QmMsIxpwfJOaygjEXAIn5UsGYzwGJuZxgzAVBYr5MMOZzQWK+XDDmQiAxXyEY83mCMfuDse4MBlyTcDXhmiDfawm1CXUI1xHqEuoR6hMaEK4nNCQ0IjQmNCHcQGhKaEZoTmhBaEloRWhNaENoS2hHaE/oQOhI6EToTOhC6EroRsggZBK6E3oQsgjZhJ6EXoTehD6EvoR+hBsJ/QkDCDcRBhJuJtxCGEQYTLiVcBvhdsIQwlDCHYRhhDsJwwl3EUYQRhJGEUYTxhDuJowl3EMYR7iXMJ5wH2EC4X7CRMIDhEmEBwmTCQ8RphAeJkwlPEKYRniUMJ3wGGEG4XHCTMIThFmE2YQ5hCcJcwlPEeYRnibMJzxDWEB4lrCQ8BxhEeF5wmLCC4QlhBcJSwkvEZYRXiYsJ6wgrCSsIqwmrCGsJawjrCe8QthAeJWwkfAaYRPhdcJmwhuELYQ3CVsJbxG2Ed4mbCe8Q9hBeJewk/Ae4X3CLsIHhN2EDwl7CB8R9hI+Juwj7CccIHxCOEg4RDhM+JRwhPAZ4SjhGOFzwheE44QvCScIXxG+JnxD+JbwHeF7wg+EHwk/EX4m/EL4lfAb4XfCH4Q/CbzQL4YQS/AT4gjxhARCHkJeQj5CfkIBwjmEgoRzCYUI5xEKE4oQihLOJxQjXEC4kFCcUIJQklCKcBHhYsIlhNKEMoSyhEsJ5QiXES4nXEEoT6hAqEioRKhMuJJQhVCVUI1gCJaQSEgiJBNSCKmENEKAkE6oTqhBuIpQk3A14RpCLcK1hNqEOoTrCHUJ9Qj1CQ0I1xMaEhoRGhOaEG4gNCU0IzQntCC0JLQitCa0IbQltCO0J3QgdCR0InQmdCF0JXQjZBAyCd0JPQhZhGxCT0IvQm9CH0JfQj/CjYT+hAGEmwgDCTcTbiEMIgwm3Eq4jXA7YQhhKOEOwjDCnYThhLsIIwgjCaMIowljCHcTxhLuIYwj3EsYT7iPMIFwP2Ei4QHCJMKDhMmEhwhTCA8TphIeIUwjPEqYTniMMIPwOGEm4QnCLMJswhzCk4S5hKcI8whPE+YTniEsIDxLWEh4jrCI8DxhMeEFwhLCi4SlhJcIywgvE5YTVhBWElYRVhPWENYS1hHWE14hbCC8SthIeI2wifA6YTPhDcIWwpuErYS3CNsIbxO2E94h7CC8S9hJeI/wPmEX4QPCbsKHhD2Ejwh7CR8T9hH2Ew4QPiEcJBwiHCZ8SjhC+IxwlHCM8DnhC8JxwpeEE4SvCF8TviF8S/iO8D3hB8KPhJ8IPxN+IfxK+I3wO+EPwp8ELowxhFiCnxBHiCckEPIQ8hLyEfITChDOIRQknEsoRDiPUJhQhFCUcD6hGOECwoWE4oQShJKEUoSLCBcTLiGUJpQhlCVcSihHuIxwOeEKQnlCBUJFQiVCZcKVhCqEqoRqBEOwhERCEiGZkEJIJaQRAoR0QnVCDcJVhJqEqwnXEGoRriXUJtQhXEeoS6hHqE9oQLie0JDQiNCY0IRwA6EpoRmhOaEFoSWhFaE1oQ2hLaEdoT2hA6EjoROhM6ELoSuhGyGDkEnoTuhByCJkE3oSehF6E/oQ+hL6EW4k9CfwO+v5ffD8rnV+jzm/I5zfv83vtub3RvM7mfl9x/wuYX5PL78Dl98vy+9u5fei8jtHRxD4XZn8Hkp+xyO/P5HfTcjv/eN36vH76vhdcPyeNX6HGb8fjN+9xe+14ndG8fuY+F1H/B4hfkcPv/+G3y3D723hd6Lw+0b4XR78ngx+BwW/34HfncDvJeA9/2cReK963gee91jn/ct5b3Ded5v3tOb9onkvZt7nmPcQ5v15ee9b3leW92zl/VB5r1Hex5P3yOT9J3lvR943kfck5P3+eC893qeO94Dj/dV47zLeF4z33FpP4L2ieB8m3uOI9w/ivXl43xveU4b3a+G9UHifEd7Dg/fH4L0neF8H3jOB9yPgZ/35OXp+Rp3nmPxsNT+3zM8E8/O2/CwrPyfKz2Dy84387CA/l8fPvO0n8LNa/BwUP2PEz+/wszH83Ak/08HPS/CzCLzOn9fQ85pyXg/N63B5XSqv0+R1i7yOj9e18TovXvfE64B4XQyvE+F1E7yOgO+r831mvu/K9yH5vhzfp+L7Nnwfg6/r83Vuvu7L10H5uiBfJ+PrRnwdha8r8Hk2n3fyeRifl/A8PfbUNMLH64z5qOk7fQSHmJNrwvnnvC6X16nyuk1ex8jr+nidG6/74nVQvC6I18nwuhFeR8HrCvg+O9935vuwfF+S79PxfSu+j8P3Nfg6P1/35uvAfF2UrxPydbMyhLKESwl83s3noXxexucpvM6/AqEioRKhMuFKQhVCVUI1Ap8sWUIiIYmQTEghpBLSCAFCOqE6oQbhKt+ZR1HP57Tg12KHri0xcMvTdb2/d/Xf/Kze3/yszd/8rEvw64ef7Gxx04ChTb0/G/U3/4/nWGf7fxkxZ/9/3f/mZ1P/5mez/+bvcY052//rG3v2/7f+b/7fhr/52fd/87PQgw2R/t6mv/lZybjIbYb6S6ng13zBr0EKJ/sON1sr+G+Ts8Pm87Qr3X7AJAfy+f56CPNPyhdsM16n/eRQ+wk67Z9cq87HdSNOt++NJfR3Q8/P1BtxWst6I/7KKfQ79T2/U9/zO3wUDH6OOf0r//nboZ/Fen5WN+xnft+Zfz/0szjfmX+Xx/PCvtOfiwQ/5wvjoZF33likfSsagX/obxUIxlos+G+uYWWCn/sPGNQ7e0jd/gMHZw3O6tFscGa/3t3rDe7ffVDvAf3rZPTr5ws7vJqG+xbuVbg/Xk/ifGc/vP8vxhNDqO/Gjfjr79UKft/k4EgLGBP6W/5g+/G+v/L3hf39+LDfLxn8d/4w7qG4a/2XPLPTMmx2UkZ2RkpGjx7J3TOKhLXPh9frzsHP4GN15j81ViuNpSmh9vPotB9xrPbGEvp5KIdDY6f38/92rPb+TgPP7zTw/A4f//R4HvpZvO9MTt4xjz9f4OHIx/UjTnOPCftZQ8/PQnzz+c4cmwTzPT1fWJzC+ZJYNAL/0N8K1Yiavr/qGsqn0O97dVDK66SYsL/n851ZD7x/P79PtR/bmLC/F+ITrk8oT7i+hs6pulMNbXZz71szBmWFyqo3BG+zsRFC9Erg/R1vuuekDIf+HR+h3bP9//Dvhf52Id+ZU5CEMI7hloZ/L8T7vLP8fz4iDTExZ/ka+ju+/+HvROIcabj6b/+O5tDBx3m+yNNL799WGlZSIg3BvjAN/85H7zAS3gd8EfT1eX4nFBMPXXU87Yb/Xjgfrw/eUxpvHJH88vvO1DI+jOPZhtjQ95VPEVMjDd3h8Xs1D/cjr+dn/79+hGL6//XDq1GesJ95+5o/7Gdeft5SFu2nCrWD//6/PlXwlvxCvjNzN3xs9/oUPrYp5XNiiEcon0Nan60fRuLjk+Nj48P4NAp+ZS3bhmnn7YPhY4PP99f89ea+9/e9Y2co3kIRYswTFv//xXTI60f4mB8aVxLO8vuh9uLDfr9l8Cv/u0Pwc6S67Q/7WWyEtiONKSENuT9I98fuKamZ3ZNTMkyW5X8m/k/9Ufrv059O656RZm16ss1Ktin/098PjZuhr8XC9P1veYQd/7l0cL5O+8abm76wWLx/N/wSiU+QQ6i9UF5Gmh+Fz+dDv5s3jF+MPD8bziXS/DV0hE5nzvd8z3tq7eXqzWHJOhBqv4BO+xFzJr/nc4Gwn4W8i3QpM+Ys/44N+/p3vxvzN+0WjPCzUJshr7x8Q3H8P3y2aYdT9QcA",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "notify_enqueued_public_function_call_wrapper",
         "call_private_function_internal",
         "directive_invert",
         "directive_integer_quotient"
       ],
-      "verification_key": "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"
-    },
-    {
-      "name": "sync_notes",
-      "is_unconstrained": true,
-      "custom_attributes": [
-        "aztec::macros::functions::utility"
-      ],
-      "abi": {
-        "parameters": [],
-        "return_type": null,
-        "error_types": {
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        }
-      },
-      "bytecode": "H4sIAAAAAAAA/7WTPQ+CMBCGi2KUjzjgoD+jBAyM+LG4OLpXCkpUSAB3frqQXENtwKjAJU17FJ5736OVUB0SzDLqEAyyglmBecTtj8vhQY67hakIdfvku9i2lQZ/Peq3FGBKw/Ax4w/UfzwFzr6o+bwXVndWDo1b66g+H0P5Z/9vSP+LD5418GpAXnmew/oS5Nt74t+Oz8c5SNnXTR1EgnIxdK5CSd0lcZ4SP99QmgZZJhJGDWTUQlU56pVE8YG26fmRdgrSLEpikSZ/Sav6yu6lXLyr8eA57hCOizHTMAb+BDV3X+b2+feXkKuCJ+bT+1Nn6BAztEhI1oRS2yeGwK+CP38vlizs4eEFAAA=",
-      "debug_symbols": "rZLdCoMgGIbvxeMO/P/ZrYwxrCwEsbAajOjeZ2EsarSTTj789OHjUd8RlCYf6qf1VdOB230Eril0bxsfu3HKQB6sc7Z+brcBnAsiC9+12s9t1+vQgxuCFMkMGF8uayHijMo6s3RTduCF5ImW83liBfqBMswSyhj8jqV8emQA0StsJBGrDVPnNpSohFIuDzbsEhtJVxslz204XN+GY36w4VfYKIwTrQj7YyNhQgXc/dQU25cOVufOpIhVgy82ievfrdmFrw1NYcohmDmGmwTGeo93wCSOjaM/",
-      "brillig_names": [
-        "sync_notes"
-      ]
+      "verification_key": "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"
     },
     {
       "name": "public_dispatch",
@@ -1829,7 +1829,7 @@
   "file_map": {
     "104": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/functions/utils.nr",
-      "source": "use crate::macros::{\n    functions::{abi_export::create_fn_abi_export, call_interface_stubs::stub_fn, stub_registry},\n    notes::NOTES,\n    utils::{\n        add_to_hasher, fn_has_noinitcheck, get_fn_visibility, is_fn_contract_library_method,\n        is_fn_initializer, is_fn_internal, is_fn_private, is_fn_public, is_fn_test, is_fn_utility,\n        is_fn_view, modify_fn_body, module_has_initializer, module_has_storage,\n    },\n};\nuse protocol_types::meta::generate_serialize_to_fields;\nuse std::meta::type_of;\n\npub(crate) comptime fn transform_private(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[private] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Private functions undergo a lot of transformations from their Aztec.nr form into a circuit that can be fed to the\n    // Private Kernel Circuit.\n    // First we change the function signature so that it also receives `PrivateContextInputs`, which contain information\n    // about the execution context (e.g. the caller).\n    let original_params = f.parameters();\n    f.set_parameters(&[(\n        quote { inputs },\n        quote { crate::context::inputs::private_context_inputs::PrivateContextInputs }.as_type(),\n    )]\n        .append(original_params));\n\n    let mut body = f.body().as_block().unwrap();\n\n    // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received\n    // the correct values.\n    // TODO: Optimize args_hasher for small number of arguments\n    let args_hasher_name = quote { args_hasher };\n    let args_hasher = original_params.fold(\n        quote {\n            let mut $args_hasher_name = dep::aztec::hash::ArgsHasher::new();\n        },\n        |args_hasher, param: (Quoted, Type)| {\n            let (name, typ) = param;\n            let appended_arg = add_to_hasher(args_hasher_name, name, typ);\n            quote {\n                $args_hasher\n                $appended_arg\n            }\n        },\n    );\n\n    let context_creation = quote {\n        let mut context = dep::aztec::context::private_context::PrivateContext::new(inputs, dep::aztec::protocol_types::traits::Hash::hash($args_hasher_name));\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    // All private functions perform 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.\n    let message_discovery_call = if NOTES.len() > 0 {\n        create_message_discovery_call()\n    } else {\n        quote {}\n    };\n\n    // Finally, we need to change the return type to be `PrivateCircuitPublicInputs`, which is what the Private Kernel\n    // circuit expects.\n    let return_value_var_name = quote { macro__returned__values };\n\n    let return_value_type = f.return_type();\n    let return_value = if body.len() == 0 {\n        quote {}\n    } else if return_value_type != type_of(()) {\n        // The original return value is passed to a second args hasher which the context receives.\n        let (body_without_return, last_body_expr) = body.pop_back();\n        let return_value = last_body_expr.quoted();\n        let return_value_assignment =\n            quote { let $return_value_var_name: $return_value_type = $return_value; };\n        let return_hasher_name = quote { return_hasher };\n        let return_value_into_hasher =\n            add_to_hasher(return_hasher_name, return_value_var_name, return_value_type);\n\n        body = body_without_return;\n\n        quote {\n            let mut $return_hasher_name = dep::aztec::hash::ArgsHasher::new();\n            $return_value_assignment\n            $return_value_into_hasher\n            context.set_return_hash($return_hasher_name);\n        }\n    } else {\n        let (body_without_return, last_body_expr) = body.pop_back();\n        if !last_body_expr.has_semicolon()\n            & last_body_expr.as_for().is_none()\n            & last_body_expr.as_assert().is_none()\n            & last_body_expr.as_for_range().is_none()\n            & last_body_expr.as_assert_eq().is_none()\n            & last_body_expr.as_let().is_none() {\n            let unused_return_value_name = f\"_{return_value_var_name}\".quoted_contents();\n            body = body_without_return.push_back(\n                quote { let $unused_return_value_name = $last_body_expr; }.as_expr().unwrap(),\n            );\n        }\n        quote {}\n    };\n\n    let context_finish = quote { context.finish() };\n\n    let to_prepend = quote {\n        $args_hasher\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n        $message_discovery_call\n    };\n\n    let to_append = quote {\n        $return_value\n        $mark_as_initialized\n        $context_finish\n    };\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n    f.set_return_type(\n        quote { dep::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs }\n            .as_type(),\n    );\n    f.set_return_data();\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_public(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[public] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Public functions undergo a lot of transformations from their Aztec.nr form.\n    let original_params = f.parameters();\n    let args_len = original_params\n        .map(|(name, typ): (Quoted, Type)| {\n            generate_serialize_to_fields(name, typ, &[], false).0.len()\n        })\n        .fold(0, |acc: u32, val: u32| acc + val);\n\n    // Unlike in the private case, in public the `context` does not need to receive the hash of the original params.\n    let context_creation = quote {\n        let mut context = dep::aztec::context::public_context::PublicContext::new(|| {\n        // We start from 1 because we skip the selector for the dispatch function.\n        let serialized_args : [Field; $args_len] = dep::aztec::context::public_context::calldata_copy(1, $args_len);\n        dep::aztec::hash::hash_args_array(serialized_args)\n        });\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n        // referenced. We instead ignore 'unused variable' warnings for it.\n        quote {\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    let to_prepend = quote {\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n    };\n\n    let to_append = quote {\n        $mark_as_initialized\n    };\n\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n\n    // All public functions are automatically made unconstrained, even if they were not marked as such. This is because\n    // instead of compiling into a circuit, they will compile to bytecode that will be later transpiled into AVM\n    // bytecode.\n    f.set_unconstrained(true);\n    f.set_return_public(true);\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_utility(f: FunctionDefinition) {\n    // Check if function is marked as unconstrained\n    if !f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[utility] but not marked as unconstrained, add unconstrained keyword\",\n        );\n    }\n\n    // Create utility context\n    let context_creation =\n        quote { let mut context = dep::aztec::context::utility_context::UtilityContext::new(); };\n    let module_has_storage = module_has_storage(f.module());\n\n    // Initialize Storage if module has storage\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(context);\n        }\n    } else {\n        quote {}\n    };\n\n    // All utility functions perform message discovery, since they may need to access private notes that would be\n    // found during this process. This is slightly inefficient and could be improved by only doing it once we actually\n    // attempt to read any.\n    let message_discovery_call = if NOTES.len() > 0 {\n        create_message_discovery_call()\n    } else {\n        quote {}\n    };\n\n    // Inject context creation, storage initialization, and message discovery call at the beginning of the function\n    // body.\n    let to_prepend = quote {\n        $context_creation\n        $storage_init\n        $message_discovery_call\n    };\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, quote {});\n    f.set_body(modified_body);\n\n    f.set_return_public(true);\n}\n\ncomptime fn create_internal_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called internally\";\n    quote { assert(context.msg_sender() == context.this_address(), $assertion_message); }\n}\n\ncomptime fn create_view_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called statically\";\n    if is_fn_private(f) {\n        // Here `context` is of type context::PrivateContext\n        quote { assert(context.inputs.call_context.is_static_call == true, $assertion_message); }\n    } else {\n        // Here `context` is of type context::PublicContext\n        quote { assert(context.is_static_call(), $assertion_message); }\n    }\n}\n\ncomptime fn create_assert_correct_initializer_args(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_{fn_visibility}(context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_mark_as_initialized(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::mark_as_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_init_check(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_is_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\n/// Injects a call to `aztec::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                context.this_address(),\n                _compute_note_hash_and_nullifier,\n            );\n        };\n    }\n}\n\n/// Checks if each function in the module is marked with either #[private], #[public], #[utility],\n/// #[contract_library_method], or #[test]. 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_private(f)\n            & !is_fn_public(f)\n            & !is_fn_utility(f)\n            & !is_fn_contract_library_method(f)\n            & !is_fn_test(f) {\n            panic(\n                f\"Function {name} must be marked as either #[private], #[public], #[utility], #[contract_library_method], or #[test]\",\n            );\n        }\n    }\n}\n"
+      "source": "use crate::macros::{\n    functions::{abi_export::create_fn_abi_export, call_interface_stubs::stub_fn, stub_registry},\n    notes::NOTES,\n    utils::{\n        add_to_hasher, fn_has_noinitcheck, get_fn_visibility, is_fn_contract_library_method,\n        is_fn_initializer, is_fn_internal, is_fn_private, is_fn_public, is_fn_test, is_fn_utility,\n        is_fn_view, modify_fn_body, module_has_initializer, module_has_storage,\n    },\n};\nuse protocol_types::meta::generate_serialize_to_fields;\nuse std::meta::type_of;\n\npub(crate) comptime fn transform_private(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[private] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Private functions undergo a lot of transformations from their Aztec.nr form into a circuit that can be fed to the\n    // Private Kernel Circuit.\n    // First we change the function signature so that it also receives `PrivateContextInputs`, which contain information\n    // about the execution context (e.g. the caller).\n    let original_params = f.parameters();\n    f.set_parameters(&[(\n        quote { inputs },\n        quote { crate::context::inputs::private_context_inputs::PrivateContextInputs }.as_type(),\n    )]\n        .append(original_params));\n\n    let mut body = f.body().as_block().unwrap();\n\n    // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received\n    // the correct values.\n    // TODO: Optimize args_hasher for small number of arguments\n    let args_hasher_name = quote { args_hasher };\n    let args_hasher = original_params.fold(\n        quote {\n            let mut $args_hasher_name = dep::aztec::hash::ArgsHasher::new();\n        },\n        |args_hasher, param: (Quoted, Type)| {\n            let (name, typ) = param;\n            let appended_arg = add_to_hasher(args_hasher_name, name, typ);\n            quote {\n                $args_hasher\n                $appended_arg\n            }\n        },\n    );\n\n    let context_creation = quote {\n        let mut context = dep::aztec::context::private_context::PrivateContext::new(inputs, dep::aztec::protocol_types::traits::Hash::hash($args_hasher_name));\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    // All private functions perform 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.\n    let message_discovery_call = if NOTES.len() > 0 {\n        create_message_discovery_call()\n    } else {\n        quote {}\n    };\n\n    // Finally, we need to change the return type to be `PrivateCircuitPublicInputs`, which is what the Private Kernel\n    // circuit expects.\n    let return_value_var_name = quote { macro__returned__values };\n\n    let return_value_type = f.return_type();\n    let return_value = if body.len() == 0 {\n        quote {}\n    } else if return_value_type != type_of(()) {\n        // The original return value is passed to a second args hasher which the context receives.\n        let (body_without_return, last_body_expr) = body.pop_back();\n        let return_value = last_body_expr.quoted();\n        let return_value_assignment =\n            quote { let $return_value_var_name: $return_value_type = $return_value; };\n        let return_hasher_name = quote { return_hasher };\n        let return_value_into_hasher =\n            add_to_hasher(return_hasher_name, return_value_var_name, return_value_type);\n\n        body = body_without_return;\n\n        quote {\n            let mut $return_hasher_name = dep::aztec::hash::ArgsHasher::new();\n            $return_value_assignment\n            $return_value_into_hasher\n            context.set_return_hash($return_hasher_name);\n        }\n    } else {\n        let (body_without_return, last_body_expr) = body.pop_back();\n        if !last_body_expr.has_semicolon()\n            & last_body_expr.as_for().is_none()\n            & last_body_expr.as_assert().is_none()\n            & last_body_expr.as_for_range().is_none()\n            & last_body_expr.as_assert_eq().is_none()\n            & last_body_expr.as_let().is_none() {\n            let unused_return_value_name = f\"_{return_value_var_name}\".quoted_contents();\n            body = body_without_return.push_back(\n                quote { let $unused_return_value_name = $last_body_expr; }.as_expr().unwrap(),\n            );\n        }\n        quote {}\n    };\n\n    let context_finish = quote { context.finish() };\n\n    let to_prepend = quote {\n        $args_hasher\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n        $message_discovery_call\n    };\n\n    let to_append = quote {\n        $return_value\n        $mark_as_initialized\n        $context_finish\n    };\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n    f.set_return_type(\n        quote { dep::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs }\n            .as_type(),\n    );\n    f.set_return_data();\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_public(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[public] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Public functions undergo a lot of transformations from their Aztec.nr form.\n    let original_params = f.parameters();\n    let args_len = original_params\n        .map(|(name, typ): (Quoted, Type)| {\n            generate_serialize_to_fields(name, typ, false).0.len()\n        })\n        .fold(0, |acc: u32, val: u32| acc + val);\n\n    // Unlike in the private case, in public the `context` does not need to receive the hash of the original params.\n    let context_creation = quote {\n        let mut context = dep::aztec::context::public_context::PublicContext::new(|| {\n        // We start from 1 because we skip the selector for the dispatch function.\n        let serialized_args : [Field; $args_len] = dep::aztec::context::public_context::calldata_copy(1, $args_len);\n        dep::aztec::hash::hash_args_array(serialized_args)\n        });\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n        // referenced. We instead ignore 'unused variable' warnings for it.\n        quote {\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    let to_prepend = quote {\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n    };\n\n    let to_append = quote {\n        $mark_as_initialized\n    };\n\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n\n    // All public functions are automatically made unconstrained, even if they were not marked as such. This is because\n    // instead of compiling into a circuit, they will compile to bytecode that will be later transpiled into AVM\n    // bytecode.\n    f.set_unconstrained(true);\n    f.set_return_public(true);\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_utility(f: FunctionDefinition) {\n    // Check if function is marked as unconstrained\n    if !f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[utility] but not marked as unconstrained, add unconstrained keyword\",\n        );\n    }\n\n    // Create utility context\n    let context_creation =\n        quote { let mut context = dep::aztec::context::utility_context::UtilityContext::new(); };\n    let module_has_storage = module_has_storage(f.module());\n\n    // Initialize Storage if module has storage\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(context);\n        }\n    } else {\n        quote {}\n    };\n\n    // All utility functions perform message discovery, since they may need to access private notes that would be\n    // found during this process. This is slightly inefficient and could be improved by only doing it once we actually\n    // attempt to read any.\n    let message_discovery_call = if NOTES.len() > 0 {\n        create_message_discovery_call()\n    } else {\n        quote {}\n    };\n\n    // Inject context creation, storage initialization, and message discovery call at the beginning of the function\n    // body.\n    let to_prepend = quote {\n        $context_creation\n        $storage_init\n        $message_discovery_call\n    };\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, quote {});\n    f.set_body(modified_body);\n\n    f.set_return_public(true);\n}\n\ncomptime fn create_internal_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called internally\";\n    quote { assert(context.msg_sender() == context.this_address(), $assertion_message); }\n}\n\ncomptime fn create_view_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called statically\";\n    if is_fn_private(f) {\n        // Here `context` is of type context::PrivateContext\n        quote { assert(context.inputs.call_context.is_static_call == true, $assertion_message); }\n    } else {\n        // Here `context` is of type context::PublicContext\n        quote { assert(context.is_static_call(), $assertion_message); }\n    }\n}\n\ncomptime fn create_assert_correct_initializer_args(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_{fn_visibility}(context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_mark_as_initialized(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::mark_as_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_init_check(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_is_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\n/// Injects a call to `aztec::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                context.this_address(),\n                _compute_note_hash_and_nullifier,\n            );\n        };\n    }\n}\n\n/// Checks if each function in the module is marked with either #[private], #[public], #[utility],\n/// #[contract_library_method], or #[test]. 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_private(f)\n            & !is_fn_public(f)\n            & !is_fn_utility(f)\n            & !is_fn_contract_library_method(f)\n            & !is_fn_test(f) {\n            panic(\n                f\"Function {name} must be marked as either #[private], #[public], #[utility], #[contract_library_method], or #[test]\",\n            );\n        }\n    }\n}\n"
     },
     "143": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/call_private_function.nr",
@@ -1849,7 +1849,7 @@
     },
     "288": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
-      "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        contract_class_log::ContractClassLog,\n        function_selector::FunctionSelector,\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::{OrderedValue, scoped::Scoped},\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH, TWO_POW_64,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    poseidon2::Poseidon2Sponge,\n    traits::{FromField, Hash, ToField},\n    utils::{\n        arrays::{array_concat, unsafe_padded_array_length},\n        field::{field_from_bytes, field_from_bytes_32_trunc},\n    },\n};\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(nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n    siloed_note_hash: Field,\n    first_nullifier: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    if siloed_note_hash == 0 {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n        compute_unique_note_hash(nonce, siloed_note_hash)\n    }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n    poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped<PrivateLogData>) -> PrivateLog {\n    if private_log.contract_address.is_zero() {\n        private_log.inner.log\n    } else {\n        let mut fields = private_log.inner.log.fields;\n        fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n        PrivateLog { fields }\n    }\n}\n\nfn compute_siloed_contract_class_log_field(\n    contract_address: AztecAddress,\n    first_field: Field,\n) -> Field {\n    poseidon2_hash([contract_address.to_field(), first_field])\n}\n\npub fn silo_contract_class_log(contract_class_log: ContractClassLog) -> ContractClassLog {\n    if contract_class_log.contract_address.is_zero() {\n        contract_class_log\n    } else {\n        let mut log = contract_class_log;\n        log.log.fields[0] = compute_siloed_contract_class_log_field(\n            contract_class_log.contract_address,\n            log.log.fields[0],\n        );\n        log\n    }\n}\n\npub fn compute_contract_class_log_hash(contract_class_log: ContractClassLog) -> Field {\n    let array = contract_class_log.log.fields;\n    // Safety: The below length is constrained in the base rollup.\n    let length = unsafe { unsafe_padded_array_length(array) };\n    if length == 0 {\n        0\n    } else {\n        poseidon2_hash(array)\n    }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: [u8; 160] = std::mem::zeroed();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..5 {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes[32 * i + j] = item_bytes[j];\n        }\n    }\n\n    sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a u128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n    sponge.squeeze()\n}\n\n// NB the below is the same as std::hash::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n//  - absorb normally up to 2 times to set cache_size to 1\n//  - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n//  - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n) -> Poseidon2Sponge {\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n    // since we cannot isolate computation branches. The below is just to avoid that.\n    let shift = if in_len == 0 { 0 } else { 1 };\n    if in_len != 0 {\n        // cache_size = 0, init absorb\n        sponge.cache[0] = input[0];\n        sponge.cache_size = 1;\n        // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n        // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n        // max_remainder = (N - 1) % 3;\n        // max_chunks = (N - 1 - max_remainder) / 3;\n        sponge = poseidon2_absorb_chunks_loop::<N, (N - 1 - (N - 1) % 3) / 3>(\n            sponge,\n            input,\n            in_len,\n            variable,\n            shift,\n        );\n    }\n    sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge<let N: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> Poseidon2Sponge {\n    let mut sponge = in_sponge;\n    // 'shift' is to account for already added inputs\n    let mut shift = 0;\n    // 'stop' is to avoid an underflow when inputting in_len = 0\n    let mut stop = false;\n    for i in 0..3 {\n        if shift == in_len {\n            stop = true;\n        }\n        if (sponge.cache_size != 1) & (!stop) {\n            sponge.absorb(input[i]);\n            shift += 1;\n        }\n    }\n    sponge = if stop {\n        sponge\n    } else {\n        // max_chunks = (N - (N % 3)) / 3;\n        poseidon2_absorb_chunks_loop::<N, (N - (N % 3)) / 3>(\n            sponge,\n            input,\n            in_len,\n            skip_0_check,\n            shift,\n        )\n    };\n    sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop<let N: u32, let M: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> Poseidon2Sponge {\n    assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n    // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n    // The below avoids an overflow\n    let skip_last = 3 * M == N;\n    // Writing in_sponge: &mut does not compile\n    let mut sponge = in_sponge;\n    let mut should_add = true;\n    // The num of things left over after absorbing in 3s\n    let remainder = (in_len - shift) % 3;\n    // The num of chunks of 3 to absorb (maximum M)\n    let chunks = (in_len - shift - remainder) / 3;\n    for i in 0..M {\n        // Now we loop through cache size = 1 -> 3\n        should_add &= i != chunks;\n        // This is the index at the start of the chunk (for readability)\n        let k = 3 * i + shift;\n        if should_add {\n            // cache_size = 1, 2 => just assign\n            sponge.cache[1] = input[k];\n            sponge.cache[2] = input[k + 1];\n            // cache_size = 3 => duplex + perm\n            for j in 0..3 {\n                sponge.state[j] += sponge.cache[j];\n            }\n            sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n            sponge.cache[0] = input[k + 2];\n            // cache_size is now 1 again, repeat loop\n        } else if (!variable) & (i != chunks) {\n            // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n            // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n            let last_0 = if (i == M - 1) & (skip_last) {\n                0\n            } else {\n                input[k + 2]\n            };\n            let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n            assert(all_0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    // we have 'remainder' num of items left to absorb\n    should_add = true;\n    // below is to avoid overflows (i.e. if inlen is close to N)\n    let mut should_check = !variable;\n    for i in 0..3 {\n        should_add &= i != remainder;\n        should_check &= in_len - remainder + i != N;\n        if should_add {\n            // we want to absorb the final 'remainder' items\n            sponge.absorb(input[in_len - remainder + i]);\n        } else if should_check {\n            assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    sponge\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let 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#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n    let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n    let variable_len_hash = std::hash::poseidon2::Poseidon2::hash(input, in_len);\n    assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    // absorb 250 of the 501 things\n    let empty_sponge = Poseidon2Sponge::new((in_len as Field) * TWO_POW_64);\n    let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n    // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n    let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n    let fixed_len_hash = Poseidon2Sponge::hash(fixed_input, fixed_input.len());\n    assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n    let in_len = 0;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut constructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(constructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == constructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = 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 == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
+      "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        contract_class_log::ContractClassLog,\n        function_selector::FunctionSelector,\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::{OrderedValue, scoped::Scoped},\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH, TWO_POW_64,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    poseidon2::Poseidon2Sponge,\n    traits::{FromField, Hash, ToField},\n    utils::{\n        arrays::{array_concat, unsafe_padded_array_length},\n        field::{field_from_bytes, field_from_bytes_32_trunc},\n    },\n};\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(nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n    siloed_note_hash: Field,\n    first_nullifier: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    if siloed_note_hash == 0 {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n        compute_unique_note_hash(nonce, siloed_note_hash)\n    }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n    poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped<PrivateLogData>) -> PrivateLog {\n    if private_log.contract_address.is_zero() {\n        private_log.inner.log\n    } else {\n        let mut fields = private_log.inner.log.fields;\n        fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n        PrivateLog { fields }\n    }\n}\n\nfn compute_siloed_contract_class_log_field(\n    contract_address: AztecAddress,\n    first_field: Field,\n) -> Field {\n    poseidon2_hash([contract_address.to_field(), first_field])\n}\n\npub fn silo_contract_class_log(contract_class_log: ContractClassLog) -> ContractClassLog {\n    if contract_class_log.contract_address.is_zero() {\n        contract_class_log\n    } else {\n        let mut log = contract_class_log;\n        log.log.fields[0] = compute_siloed_contract_class_log_field(\n            contract_class_log.contract_address,\n            log.log.fields[0],\n        );\n        log\n    }\n}\n\npub fn compute_contract_class_log_hash(contract_class_log: ContractClassLog) -> Field {\n    let array = contract_class_log.log.fields;\n    // Safety: The below length is constrained in the base rollup.\n    let length = unsafe { unsafe_padded_array_length(array) };\n    if length == 0 {\n        0\n    } else {\n        poseidon2_hash(array)\n    }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: [u8; 160] = std::mem::zeroed();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..5 {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes[32 * i + j] = item_bytes[j];\n        }\n    }\n\n    sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a u128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    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 = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n    sponge.squeeze()\n}\n\n// NB the below is the same as 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_chunks(input, in_len, true);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n//  - absorb normally up to 2 times to set cache_size to 1\n//  - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n//  - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n) -> Poseidon2Sponge {\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n    // since we cannot isolate computation branches. The below is just to avoid that.\n    let shift = if in_len == 0 { 0 } else { 1 };\n    if in_len != 0 {\n        // cache_size = 0, init absorb\n        sponge.cache[0] = input[0];\n        sponge.cache_size = 1;\n        // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n        // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n        // max_remainder = (N - 1) % 3;\n        // max_chunks = (N - 1 - max_remainder) / 3;\n        sponge = poseidon2_absorb_chunks_loop::<N, (N - 1 - (N - 1) % 3) / 3>(\n            sponge,\n            input,\n            in_len,\n            variable,\n            shift,\n        );\n    }\n    sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge<let N: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> Poseidon2Sponge {\n    let mut sponge = in_sponge;\n    // 'shift' is to account for already added inputs\n    let mut shift = 0;\n    // 'stop' is to avoid an underflow when inputting in_len = 0\n    let mut stop = false;\n    for i in 0..3 {\n        if shift == in_len {\n            stop = true;\n        }\n        if (sponge.cache_size != 1) & (!stop) {\n            sponge.absorb(input[i]);\n            shift += 1;\n        }\n    }\n    sponge = if stop {\n        sponge\n    } else {\n        // max_chunks = (N - (N % 3)) / 3;\n        poseidon2_absorb_chunks_loop::<N, (N - (N % 3)) / 3>(\n            sponge,\n            input,\n            in_len,\n            skip_0_check,\n            shift,\n        )\n    };\n    sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop<let N: u32, let M: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> Poseidon2Sponge {\n    assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n    // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n    // The below avoids an overflow\n    let skip_last = 3 * M == N;\n    // Writing in_sponge: &mut does not compile\n    let mut sponge = in_sponge;\n    let mut should_add = true;\n    // The num of things left over after absorbing in 3s\n    let remainder = (in_len - shift) % 3;\n    // The num of chunks of 3 to absorb (maximum M)\n    let chunks = (in_len - shift - remainder) / 3;\n    for i in 0..M {\n        // Now we loop through cache size = 1 -> 3\n        should_add &= i != chunks;\n        // This is the index at the start of the chunk (for readability)\n        let k = 3 * i + shift;\n        if should_add {\n            // cache_size = 1, 2 => just assign\n            sponge.cache[1] = input[k];\n            sponge.cache[2] = input[k + 1];\n            // cache_size = 3 => duplex + perm\n            for j in 0..3 {\n                sponge.state[j] += sponge.cache[j];\n            }\n            sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n            sponge.cache[0] = input[k + 2];\n            // cache_size is now 1 again, repeat loop\n        } else if (!variable) & (i != chunks) {\n            // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n            // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n            let last_0 = if (i == M - 1) & (skip_last) {\n                0\n            } else {\n                input[k + 2]\n            };\n            let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n            assert(all_0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    // we have 'remainder' num of items left to absorb\n    should_add = true;\n    // below is to avoid overflows (i.e. if inlen is close to N)\n    let mut should_check = !variable;\n    for i in 0..3 {\n        should_add &= i != remainder;\n        should_check &= in_len - remainder + i != N;\n        if should_add {\n            // we want to absorb the final 'remainder' items\n            sponge.absorb(input[in_len - remainder + i]);\n        } else if should_check {\n            assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    sponge\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let 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#[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 existing_sponge_poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    // absorb 250 of the 501 things\n    let empty_sponge = Poseidon2Sponge::new((in_len as Field) * TWO_POW_64);\n    let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n    // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n    let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n    let fixed_len_hash = Poseidon2Sponge::hash(fixed_input, fixed_input.len());\n    assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n    let in_len = 0;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut constructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(constructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == constructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = 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 == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
     },
     "305": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr",