npm - @aztec/accounts - Versions diffs - 0.21.0 → 0.23.0 - Mend

@aztec/accounts 0.21.0 → 0.23.0

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

Files changed (13) hide show

package/dest/artifacts/EcdsaAccount.json +658 -397
package/dest/artifacts/SchnorrAccount.json +652 -390
package/dest/artifacts/SchnorrSingleKeyAccount.json +580 -327
package/dest/ecdsa/index.d.ts +4 -4
package/dest/ecdsa/index.d.ts.map +1 -1
package/dest/ecdsa/index.js +5 -5
package/dest/schnorr/index.d.ts +3 -3
package/dest/schnorr/index.d.ts.map +1 -1
package/dest/schnorr/index.js +4 -4
package/dest/single_key/index.d.ts +4 -5
package/dest/single_key/index.d.ts.map +1 -1
package/dest/single_key/index.js +5 -6
package/package.json +7 -7

package/dest/artifacts/SchnorrSingleKeyAccount.json CHANGED Viewed

@@ -1,10 +1,10 @@
 {
-    "noir_version": "0.23.0+ea6aebcc4e190d9dbadaf1dd0f70950651eed615",
+    "noir_version": "0.23.0+9a70040211d205f472aa31924649c2fef999eb49",
     "name": "SchnorrSingleKeyAccount",
     "functions": [
         {
-            "name": "is_valid_public",
-            "function_type": "Open",
+            "name": "entrypoint",
+            "function_type": "Secret",
             "is_internal": false,
             "abi": {
                 "parameters": [
@@ -12,7 +12,7 @@
                         "name": "inputs",
                         "type": {
                             "kind": "struct",
-                            "path": "authwit::aztec::abi::PublicContextInputs",
+                            "path": "authwit::aztec::abi::PrivateContextInputs",
                             "fields": [
                                 {
                                     "name": "call_context",
@@ -182,7 +182,23 @@
                                                         { "name": "chain_id", "type": { "kind": "field" } },
                                                         { "name": "version", "type": { "kind": "field" } },
                                                         { "name": "block_number", "type": { "kind": "field" } },
-                                                        { "name": "timestamp", "type": { "kind": "field" } }
+                                                        { "name": "timestamp", "type": { "kind": "field" } },
+                                                        {
+                                                            "name": "coinbase",
+                                                            "type": {
+                                                                "kind": "struct",
+                                                                "path": "authwit::aztec::protocol_types::address::EthAddress",
+                                                                "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                                                            }
+                                                        },
+                                                        {
+                                                            "name": "fee_recipient",
+                                                            "type": {
+                                                                "kind": "struct",
+                                                                "path": "authwit::aztec::protocol_types::address::AztecAddress",
+                                                                "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                                                            }
+                                                        }
                                                     ]
                                                 }
                                             }
@@ -190,15 +206,51 @@
                                     }
                                 },
                                 {
-                                    "name": "public_global_variables",
+                                    "name": "contract_deployment_data",
                                     "type": {
                                         "kind": "struct",
-                                        "path": "authwit::aztec::abi::PublicGlobalVariables",
+                                        "path": "authwit::aztec::protocol_types::contrakt::deployment_data::ContractDeploymentData",
+                                        "fields": [
+                                            {
+                                                "name": "public_key",
+                                                "type": {
+                                                    "kind": "struct",
+                                                    "path": "authwit::aztec::protocol_types::grumpkin_point::GrumpkinPoint",
+                                                    "fields": [
+                                                        { "name": "x", "type": { "kind": "field" } },
+                                                        { "name": "y", "type": { "kind": "field" } }
+                                                    ]
+                                                }
+                                            },
+                                            { "name": "initialization_hash", "type": { "kind": "field" } },
+                                            {
+                                                "name": "contract_class_id",
+                                                "type": {
+                                                    "kind": "struct",
+                                                    "path": "authwit::aztec::protocol_types::contract_class::ContractClassId",
+                                                    "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                                                }
+                                            },
+                                            { "name": "contract_address_salt", "type": { "kind": "field" } },
+                                            {
+                                                "name": "portal_contract_address",
+                                                "type": {
+                                                    "kind": "struct",
+                                                    "path": "authwit::aztec::protocol_types::address::EthAddress",
+                                                    "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                                                }
+                                            }
+                                        ]
+                                    }
+                                },
+                                {
+                                    "name": "private_global_variables",
+                                    "type": {
+                                        "kind": "struct",
+                                        "path": "authwit::aztec::abi::PrivateGlobalVariables",
                                         "fields": [
                                             { "name": "chain_id", "type": { "kind": "field" } },
-                                            { "name": "version", "type": { "kind": "field" } },
-                                            { "name": "block_number", "type": { "kind": "field" } },
-                                            { "name": "timestamp", "type": { "kind": "field" } }
+                                            { "name": "version", "type": { "kind": "field" } }
                                         ]
                                     }
                                 }
@@ -206,13 +258,56 @@
                         },
                         "visibility": "private"
                     },
-                    { "name": "message_hash", "type": { "kind": "field" }, "visibility": "private" }
+                    {
+                        "name": "payload",
+                        "type": {
+                            "kind": "struct",
+                            "path": "authwit::entrypoint::EntrypointPayload",
+                            "fields": [
+                                {
+                                    "name": "function_calls",
+                                    "type": {
+                                        "kind": "array",
+                                        "length": 4,
+                                        "type": {
+                                            "kind": "struct",
+                                            "path": "authwit::entrypoint::FunctionCall",
+                                            "fields": [
+                                                { "name": "args_hash", "type": { "kind": "field" } },
+                                                {
+                                                    "name": "function_selector",
+                                                    "type": {
+                                                        "kind": "struct",
+                                                        "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector",
+                                                        "fields": [
+                                                            { "name": "inner", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } }
+                                                        ]
+                                                    }
+                                                },
+                                                {
+                                                    "name": "target_address",
+                                                    "type": {
+                                                        "kind": "struct",
+                                                        "path": "authwit::aztec::protocol_types::address::AztecAddress",
+                                                        "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                                                    }
+                                                },
+                                                { "name": "is_public", "type": { "kind": "boolean" } }
+                                            ]
+                                        }
+                                    }
+                                },
+                                { "name": "nonce", "type": { "kind": "field" } }
+                            ]
+                        },
+                        "visibility": "public"
+                    }
                 ],
-                "param_witnesses": { "inputs": [{ "start": 0, "end": 30 }], "message_hash": [{ "start": 30, "end": 31 }] },
+                "param_witnesses": { "inputs": [{ "start": 0, "end": 36 }], "payload": [{ "start": 36, "end": 53 }] },
                 "return_type": {
                     "abi_type": {
                         "kind": "struct",
-                        "path": "authwit::aztec::protocol_types::abis::public_circuit_public_inputs::PublicCircuitPublicInputs",
+                        "path": "authwit::aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs",
                         "fields": [
                             {
                                 "name": "call_context",
@@ -264,41 +359,57 @@
                             },
                             { "name": "args_hash", "type": { "kind": "field" } },
                             { "name": "return_values", "type": { "kind": "array", "length": 4, "type": { "kind": "field" } } },
+                            { "name": "meta_hwm", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } },
                             {
-                                "name": "contract_storage_update_requests",
+                                "name": "read_requests",
                                 "type": {
                                     "kind": "array",
-                                    "length": 16,
+                                    "length": 32,
                                     "type": {
                                         "kind": "struct",
-                                        "path": "authwit::aztec::protocol_types::contrakt::storage_update_request::StorageUpdateRequest",
+                                        "path": "authwit::aztec::protocol_types::abis::side_effect::SideEffect",
                                         "fields": [
-                                            { "name": "storage_slot", "type": { "kind": "field" } },
-                                            { "name": "old_value", "type": { "kind": "field" } },
-                                            { "name": "new_value", "type": { "kind": "field" } }
+                                            { "name": "value", "type": { "kind": "field" } },
+                                            { "name": "counter", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } }
                                         ]
                                     }
                                 }
                             },
                             {
-                                "name": "contract_storage_reads",
+                                "name": "nullifier_key_validation_requests",
                                 "type": {
                                     "kind": "array",
-                                    "length": 16,
+                                    "length": 1,
                                     "type": {
                                         "kind": "struct",
-                                        "path": "authwit::aztec::protocol_types::contrakt::storage_read::StorageRead",
+                                        "path": "authwit::aztec::protocol_types::abis::nullifier_key_validation_request::NullifierKeyValidationRequest",
                                         "fields": [
-                                            { "name": "storage_slot", "type": { "kind": "field" } },
-                                            { "name": "current_value", "type": { "kind": "field" } }
+                                            {
+                                                "name": "public_key",
+                                                "type": {
+                                                    "kind": "struct",
+                                                    "path": "authwit::aztec::protocol_types::grumpkin_point::GrumpkinPoint",
+                                                    "fields": [
+                                                        { "name": "x", "type": { "kind": "field" } },
+                                                        { "name": "y", "type": { "kind": "field" } }
+                                                    ]
+                                                }
+                                            },
+                                            {
+                                                "name": "secret_key",
+                                                "type": {
+                                                    "kind": "struct",
+                                                    "path": "authwit::aztec::protocol_types::grumpkin_private_key::GrumpkinPrivateKey",
+                                                    "fields": [
+                                                        { "name": "high", "type": { "kind": "field" } },
+                                                        { "name": "low", "type": { "kind": "field" } }
+                                                    ]
+                                                }
+                                            }
                                         ]
                                     }
                                 }
                             },
-                            {
-                                "name": "public_call_stack_hashes",
-                                "type": { "kind": "array", "length": 4, "type": { "kind": "field" } }
-                            },
                             {
                                 "name": "new_commitments",
                                 "type": {
@@ -330,11 +441,22 @@
                                     }
                                 }
                             },
+                            {
+                                "name": "private_call_stack_hashes",
+                                "type": { "kind": "array", "length": 4, "type": { "kind": "field" } }
+                            },
+                            {
+                                "name": "public_call_stack_hashes",
+                                "type": { "kind": "array", "length": 4, "type": { "kind": "field" } }
+                            },
                             { "name": "new_l2_to_l1_msgs", "type": { "kind": "array", "length": 2, "type": { "kind": "field" } } },
+                            { "name": "end_side_effect_counter", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } },
+                            { "name": "encrypted_logs_hash", "type": { "kind": "array", "length": 2, "type": { "kind": "field" } } },
                             {
                                 "name": "unencrypted_logs_hash",
                                 "type": { "kind": "array", "length": 2, "type": { "kind": "field" } }
                             },
+                            { "name": "encrypted_log_preimages_length", "type": { "kind": "field" } },
                             { "name": "unencrypted_log_preimages_length", "type": { "kind": "field" } },
                             {
                                 "name": "historical_header",
@@ -454,7 +576,23 @@
                                                     { "name": "chain_id", "type": { "kind": "field" } },
                                                     { "name": "version", "type": { "kind": "field" } },
                                                     { "name": "block_number", "type": { "kind": "field" } },
-                                                    { "name": "timestamp", "type": { "kind": "field" } }
+                                                    { "name": "timestamp", "type": { "kind": "field" } },
+                                                    {
+                                                        "name": "coinbase",
+                                                        "type": {
+                                                            "kind": "struct",
+                                                            "path": "authwit::aztec::protocol_types::address::EthAddress",
+                                                            "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                                                        }
+                                                    },
+                                                    {
+                                                        "name": "fee_recipient",
+                                                        "type": {
+                                                            "kind": "struct",
+                                                            "path": "authwit::aztec::protocol_types::address::AztecAddress",
+                                                            "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                                                        }
+                                                    }
                                                 ]
                                             }
                                         }
@@ -462,31 +600,66 @@
                                 }
                             },
                             {
-                                "name": "prover_address",
+                                "name": "contract_deployment_data",
                                 "type": {
                                     "kind": "struct",
-                                    "path": "authwit::aztec::protocol_types::address::AztecAddress",
-                                    "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                                    "path": "authwit::aztec::protocol_types::contrakt::deployment_data::ContractDeploymentData",
+                                    "fields": [
+                                        {
+                                            "name": "public_key",
+                                            "type": {
+                                                "kind": "struct",
+                                                "path": "authwit::aztec::protocol_types::grumpkin_point::GrumpkinPoint",
+                                                "fields": [
+                                                    { "name": "x", "type": { "kind": "field" } },
+                                                    { "name": "y", "type": { "kind": "field" } }
+                                                ]
+                                            }
+                                        },
+                                        { "name": "initialization_hash", "type": { "kind": "field" } },
+                                        {
+                                            "name": "contract_class_id",
+                                            "type": {
+                                                "kind": "struct",
+                                                "path": "authwit::aztec::protocol_types::contract_class::ContractClassId",
+                                                "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                                            }
+                                        },
+                                        { "name": "contract_address_salt", "type": { "kind": "field" } },
+                                        {
+                                            "name": "portal_contract_address",
+                                            "type": {
+                                                "kind": "struct",
+                                                "path": "authwit::aztec::protocol_types::address::EthAddress",
+                                                "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                                            }
+                                        }
+                                    ]
                                 }
-                            }
+                            },
+                            { "name": "chain_id", "type": { "kind": "field" } },
+                            { "name": "version", "type": { "kind": "field" } }
                         ]
                     },
                     "visibility": "public"
                 },
                 "return_witnesses": [
-                    31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
-                    58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
-                    85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
-                    110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
-                    132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153,
-                    154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
-                    176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197,
-                    198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219,
-                    220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231
+                    1523, 1524, 1525, 1526, 1527, 1528, 1529, 1530, 1531, 1532, 1533, 1534, 1535, 1536, 1537, 1538, 1539, 1540,
+                    1541, 1542, 1543, 1544, 1545, 1546, 1547, 1548, 1549, 1550, 1551, 1552, 1553, 1554, 1555, 1556, 1557, 1558,
+                    1559, 1560, 1561, 1562, 1563, 1564, 1565, 1566, 1567, 1568, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576,
+                    1577, 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, 1594,
+                    1595, 1596, 1597, 1598, 1599, 1600, 1601, 1602, 1603, 1604, 1605, 1606, 1607, 1608, 1609, 1610, 1611, 1612,
+                    1613, 1614, 1615, 1616, 1617, 1618, 1619, 1620, 1621, 1622, 1623, 1624, 1625, 1626, 1627, 1628, 1629, 1630,
+                    1631, 1632, 1633, 1634, 1635, 1636, 1637, 1638, 1639, 1640, 1641, 1642, 1643, 1644, 1645, 1646, 1647, 1648,
+                    1649, 1650, 1651, 1652, 1653, 1654, 1655, 1656, 1657, 1658, 1659, 1660, 1661, 1662, 1663, 1664, 1665, 1666,
+                    1667, 1668, 1669, 1670, 1671, 1672, 1673, 1674, 1675, 1676, 1677, 1678, 1679, 1680, 1681, 1682, 1683, 1684,
+                    1685, 1686, 1687, 1688, 1689, 1690, 1691, 1692, 1693, 1694, 1695, 1696, 1697, 1698, 1699, 1700, 1701, 1702,
+                    1703, 1704, 1705, 1706, 1707, 1708, 1709, 1710, 1711, 1712, 1713, 1714, 1715, 1716, 1717, 1718, 1719, 1720,
+                    1721, 1722, 1723, 1724, 1725, 1726, 1727, 1728, 1729
                 ]
             },
-            "bytecode": "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",
-            "debug_symbols": "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"
+            "bytecode": "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",
+            "debug_symbols": "7P3djvNK0qQL3ksdNxqMYPz2rQzmoDGzB9jARu/BdJ816t5HVWuJUlaGMiJfepBuYX701QfoTbk9Kyk3Y1IW//sf/9f//f/67//r//y//8f//Md/+9//cPUf/+3/8b//8T//v//9f/zr//2f/+u////+1z/+2/Zf/vF//I//9+P//vO//OP/83/+X//HP/6b9/s//8u317ma898vdbXW49UhNF7s9+L/frEP++vFbiutH+1CCs+f7aIvX17///wv//Ab7OTuusmjS8/JY06nJ/etyXPc//5HuXSn32t9vkNw++sN/qWkAT7VA3yMb6/+s/H30+NH//xNcDG5zvguxeM/VSr5y8/+1zhB1zhR1zhJ1zhZ1zhF1zhV1Tj7pmscp2scr2scXZ/Ku65P5V3Xp/Ku61N51/WpvOv6VN51fSoHXZ/KQdenctD1qRx0fSoHXZ/KQdenctD1qRx0fSoHXZ/KQdenctT1qRx1fSpHXZ/KUdenctT1qRx1fSpHXZ/KUdenctT1qRx1fSonXZ/KSdenctL1qZx0fSonXZ/KSdenctL1qZx0fSonXZ/KSdenctb1qZx1fSpnXZ/KWdenctb1qZx1fSpnXZ/KWdenctb1qZx1fSoXXZ/KRdenctH1qVx0fSoXXZ/KRdenctH1qVx0fSqXqz+V83Y83pSD7/xsfzwL5ev7a2PjtbUcD2Vt/n2M1hRhi88Xh7cpHi/+F5NqTP6TSd2MyTcmzph8Y+KNyTcmuzH5xiQYk29MojH5xiQZk29MsjH5xsR87Hcm5mO/MXGbGdkGFHOyDShmZRtQzMs2oASD8h2KudkGFLOzDSjmZxtQzNA2oJij/Q7FmaNtQDFH24BijrYBxRxtA0owKN+hmKNtQDFH24BijrYBxRxtA4o52u9QvDnaBhRztA0o5mgbUMzRNqAEg/IdijnaBhRztA0o5mgbUMzRNqCYo/0OZTdH24BijrYBxRxtA4o52gaUYFC+QzFH24BijrYBxRxtA4o52gYUc7TfoQRztA0o5mgbUMzRNqCYo21ACQblOxRztA0o5mgbUMzRNqCYo21AMUf7HUo0R9uAYo62AUW1o93ds/Dl/Zyvf0H59+yqjWeIzx8dsv8+e9A8e3Tu7xfHUDu/jCnE5y9Yivn1atd8dfdQMBdVm8RQngfDxVI6ZFzdnr++fov5PJk7nWKqX372v+cRMGmpPN8hbakzz77n54/ew/b+UdY6fs479/zZ/vFXly/0/z19gZ6+Ik8v0V/9q+lDOKaPee9M/7j3dbz88b/cm9pt+2t+r3v+vLtj/vzlnMmt9Qnun6OkFF6v3dt2wm3Hj45vk8SWynqMXd+Pi3y8y78p7kZRgGIwigIUo1EUoJiMogDFbBQFKBajKECxGsXzFCUOKjCKWXlqAKFo2UWCInF2OW6BPf7O4L5Q/DeZYGQ+kCHOGB0yxLmhQ4Y4C3TIEPv7Dhliz/4zmULswztkiL11hwyxX+6Q4fXA0R8n0cRQvpMJRuYDGV4P3CPD64F7ZHg9cI8MrwfukeH1wB0yldcD98jweuAeGV4P3CND7IHzMXes9TuZYGQ+kCH2wB0yxB64Q4bYA3fIEHvgDhliD/wjGb8Re+AOGWIP3CFD7IE7ZJR74JJeT/PXLQuS2bf0/O7T/q9v6bzItCb58YkSvwWjKEBRubcGoajch4NQVO7ZQSgq9/cgFJVnAQyKTnluAKGoPGOAUFSeR0AoWnaRoBhoKbqwHRTfGxVi+YsMbx7pkeHNGD0yvLmhR4Y3C/TI8Pr7DhnP69l7ZHh9eI8Mr7fukeH1yz0ygZdMff7paffvbUlPMsQeuEOG2AN3yBB74A4ZYg/cIUPsgX8msxN74A4ZYg/cIUPsgTtkiD1wh0ygJePjkQ58/p4Odl4P3CPD64F7ZHg9cI8MrwfukeH1wB0ygdcD98jweuAeGV4P3CPD64F7ZAItmd09T5fY9/17Ogi8HrhHhtcD98jweuAeGV4P3CPD64E7ZCKvB+6R4fXAPTK8HrhHhtcD98gEI/OBjG4PHOvrtMhYw1cy/55ft1Ptz6/bT/bn1+36+vPr9maxHl+KePxwF77Nn3Q7qP78un1Of37dbiRtPh0/3Pnt+/y6PUN/ft2bvT+/7v2b/MuZJF/d9/l179/+/Lr3b39+3fs37dtxNHjaY+P3X/f+7c6v/CSt/vy692/Kb/u3eP99fuX7txwP6T/+d43f51e+f6t7ff7U/2hx+vf8yvdvra8jw7fa+P1Xvn+78yvfv935de/f7Lbjh2dXGtev7v3bn1/3/s1+98f8jz/yf5n/++vr9nTbdX/zSiG0P5sPa55Dfbsz1lTpQjp+k130b/0E21930pSf5fNbkuG5d2veOiTj7p8/Oobt/dXpz0jq9iS/JFm2owdxc+kLyn+LvdoAJPf8td/z+w2xtlhXtsPAuJr2bx8glx8tIz1/BJ8/gc+fwecv4PNX7PkvPz5Een4HPr8Hnx98/15+rIX0/OD7t4Lv3wq+fyv4/q3Y+3ffsPfvvmHv333D3r/7hr1/9w17/+4b9v7dN+z9u2/Y+3ffsPfvvoHvXwe+fx34/nXg+9eB79/Lq56l5wffvw58/zrw/evA968D378efP968P3rwfevB9+/l9fMSs8Pvn89+P714PvXg+9fD75/d/D9u4Pv3x18/+7g+/fyikvp+cH37w6+f3fw/buD798dfP8G8P0bwPdvAN+/AXz/Xl6vJz0/+P4N4Ps3gO/fAL5/A/j+jeD7N4Lv3wi+fyP4/r282kt6fvD9G8H3bwTfvxF8/0bw/ZvA928C378JfP8m8P17eQGX9PzK92/Nx5fl/ZbK9/mV79/u/Mr3b3d+5fu3O7/u/evdq8DTu/itAG3Puvdvf37d+7c/v+796106CtC8d435de/f/vy6929/ft3713v/Nn/+/vmZde/f/vy6929/ft379zF+PuZ//LH6+/zK929v/qJ8/3bnV75/X5M4X9z2fX7l+7cchxU8/nf5nr+U91/5+qrv8jWF7/Mr37+1HGVl+9b4/FTef9WfX/n+7c6ve//uWz1aEneXG9ev7v3bn1/3/t0fpvmY3+9fC5C/v96HYxYf9ze1oX13oFPFuFfl9dadevS9Kq+37s6vvN66O7/u7X731RV4ik73y4u+Hrd2nmLD5jtiH7cmjv+07v0/rY9/TZ+gp8/Q0ys/P9MdL3/8L/ftjIKwKT/lMu/HhRvyf3T8f3/9b06fe7A5/voW4tskzY7teoxd41tTeQp/UVR+IiYIReWnZ4JQVH7SJgjFYBQFKCo/xR6EovIT70Eo6j7NBYWi7jNlUCgqTw0YFJ1lFwmKxNmlHBTj5r5Q/DcZ4jzSIUOcMTpkgpH5QIY4C3TIEPv7Dhliz94hQ+zDO2SIvfXPZDyxX+6Q4fXA0R/PIMZQvpPh9cA9MrweuEcmGJkPZHg9cI8MrwfukeH1wD0yvB64R4bXA3fI7LweuEeG2APnY+74r1n/kwyxB+6QIfbAHTLByHwgQ+yBO2SIPXCHDLEH7pAh9sAdMsQe+GcygdgDd8go98Dl9ZWmULcsSGbf0rNLZf/XV4BeZFqT/PxESVDul0EoKvfWIBSDURSgqNyzg1BU7u9BKCrPAiAUlecGEIrKMwYGxag8j4BQtOwiQZE3u7iwHRST+0Lx32R480iPTDAyH8jw5oYeGd4s0CPD6+97ZHg9e48Mrw/vkEm83rpHhtcv98gQe+D6/NPT7t/bkp5kiD1wh0wwMh/IEHvgDhliD9whQ+yBO2SIPXCHDLEH/plMJvbAHTLEHrhDhtcD+3ikA5+/p4PM64F7ZIKR+UCG1wP3yPB64B4ZXg/cI8PrgXtkeD1wh0zh9cA9MrweuEeG1wPv7nm6xL7v39NB4fXAPTLByHwgw+uBe2R4PXCPDK8H7pHh9cA9MrweuENG+YFxd5Lh9cA9MuaBP5HR7YFj3Z4PhT/+d/hK5t/zB/D5dfvJ/vy6XV9/ft3eLNbjSxGPH+7C9/l1O6j+/Lp9Tm/+qPzkvbT543Di5Pz2fX7lx9d251d+fG13ft37tz+/7v3bn1/3/u3Pr3v/9o5vjsrP8+rPr3v/9ufXvX/TvtXjh+/x+++/8tOj+vMr37/d+ZXv3/zm34r33+dXvn/L8SWPx/+u8fv8yvdvda/Pn/ofLWD/nl/5/q01PH943mrj91/5/u3Or3z/dufXvX+z244fnl1pXL+69293fuWn0WS/+2N+H/Yv839/fd2ebrvub14phPZn82HNc6ivVzdPb3QupOM32UX/1m+xlb9I6nYCvyUZnnu35q1DMu7++aNj2N5fnf6MpG5P8kuSZTt6NDeXvqD8t1jdBia7mt/Eho7YdPzapPSae/9LaaBRqtsUSSrVbZ8kleo2WpJKtVsyOaXazZuYUuUHrkgqVW7DBJUqt0mCSmk8kvIDSySVruqR3m6S/a10VY/0XemqHum70lU90nelq3qkb0qVH8ghqXQpj/S4H/Oc++2m399Kl/JIPypdyiP9qDTQKF3KI/2odCmP9KPSpTzSj0qX8kg/Kl3KI/2kVPkhAZJKr3YOyT3/HLnn9wfd20pd2Y4HS1xNX/8I9e/5d/D5A/j8EXz+BD5/Bp+/gM9fsee/vLJben4HPj/4/k3g+/fyKmnp+cH3bwLfvwl8/ybw/ZvA928G378ZfP9m8P2bwffv5TW20vOD798Mvn8z+P7N4Ps3g+/fAr5/C/j+LeD7t4Dv38srNKXnB9+/BXz/FvD9W8D3bwHfvxV8/1bw/VvB928F37+XFwNKzw++fyv4/q3g+7eC79+KvX/Thr1/04a9f9OGvX/Thr1/04a9f9OGvX/Thr1/04a9f9OGvX/TBr5/Hfj+deD714HvXwe+fy8vBpSeH3z/OvD968D3rwPfvw58/3rw/evB968H378efP9e3lYnPT/4/vXg+9eD718Pvn89+P7dwffvDr5/d/D9u4Pv38ub0H45f81HibHfUvk+v/L9251f+f7tzq98/3bn171/vXsdzOdddN/n171/u/MH3fu3P7/u/etdOg6m8d415te9f/vz696//fl171/v/dv8+fvnZ9C9f/vz696//fl179/H+EdTkN/3xvzK9293fuX7tzd/VL5/X5M4X9z2fX7l+7cch5A//nf5nr+U91/5+jpWxdcUvs+vfP/Wchwis2+Nz0/l/Vf9+ZXv3+78uvfvvtXj9Krd5cb1q3v/9ufXvX/3h2k+5vf714Mpv7/eh2MWH/c3taF9d6BzRFZS3q61uxLf6OwdOj+cE5CU93BJKtXtGCSV6vYWkkp1uxBJpYFGqW5nI6lUuQcSVKrcLQkqVe6rBJXSeCTlXWmSSlf1SP95RktS3r8mqXRVj/RdaaBRuqpH+q50VY/0XelSHumHsx+S8u45SaVLeaSflCrvs5NUupRH+lHpUh7pR6VLeaQflQYapUt5pB+VLuWRflJadZ/CmDZ//NUtOf/tqYW8rXW+V3g+o5ST//pfKm+6z0BNPh3PlyRf3ff/UrpPNu3Pr/xK6c3vdF8p3SvdKf/9786v/Pe/O/9aZ0b+8EnraXaKX+tc7Z+UXn317flQGjbfUeqdO562ce9+zse/pt+hpw/Q0+s+6Tm44+WP/+X8t89tr/v85vDIJMf8+e0e7of7vcdTwOn9Gdq9ttkcX9kM8W2S2FJZj7FrjK/XPt7l3xR1nw2NQlG3hwChuOv2JygUdXsfFIq6Uw0KRd33FlAoBqMoQDEaRQGKylMDCEXLLhIUibNLOSjGzX2h+G8yxHnkZzKBOGN0yBDnhg4Z4izQIUPs7ztkgpH5QIbYh3fIEHvrDhliv9whw+uBoz/+iBpD+U6G1wN3yEReD9wjw+uBe2R4PXCPDK8H7pEJRuYDGV4P3CPD64F7ZHg9cI8MsQfOx9zxX7P+JxliD/wzmUTsgTtkiD1whwyxB+6QIfbAHTLByHwgQ+yBO2SIPXCHDLEH7pBR7oHL61t8oW5ZkMy+peeXhvd/tbK+yLQm+fmJkqTcL2NQzMq9NQhF5T4chKJyzw5CUbm/B6EYjKIAReW5AYSi8owBQlF5HgGhaNlFgiJvdnFhOygm94Xiv8gU3jzSI8ObMXpkeHNDjwxvFuiRCUbmAxlez94jw+vDe2R4vXWPDK9f7pEh9sD1+aen3b+3Jf1NphJ74A4ZYg/cIUPsgTtkiD1wh0wwMh/IEHvgDhliD9whQ+yBO2SIPXCHDK8H9vFIBz5/SwdFeaf+nWR4PXCPDK8H7pHh9cA9MsHIfCDD64F7ZHg9cI8MrwfukeH1wD0yvB54d/45yb5/SwdF+Wk5d5Lh9cA9MrweuEeG1wP3yAQj84EMrwfukeH1wD0yvB64R4bXA/fImAf+QEb5OXixbscpuLGGr2T+Pb9up9qfX7ef7M+v2/X15w/K5z++FPH44S58n1+3g+rPr9vn9OfX7UZ6J74W5Wfe9efXvdm78ys/560/P/aJzUX52Wb9+bFPLC/Kz/Pqz697//bn171/077V44fvsfH7r3z/dudXvn+78yvfv/nNvz3C1rf5lZ+BlMrxJY/H/67x+/zK9291r8+f+h8tYP+eX/n+rTU8f3je6vfff+Wn/vTnV75/u/Pr3r/ZbccPz640rl/d+7c/v+79m/3uj/l92L/M//31dXu67bq/eaUQ2p/NhzXPob5e3Ty90bmQjt9kF/1bv8X2151Y5afX/JZkeO7dmrcOybj754+OYXt/dfozkro9yS9Jlu3o0dxc+oLyX2KVH2CTXc1vYkNHbDp+bVJ6zb3/pVS31ZFUqtsUSSrVbZ8klQYapdotmZxS7eZNTqlymyeoVLkNE1Sq3CbJKVV+wImkUhqPpPwAEkmlNB5J+QEhf6707cbn30pX9Ujfla7qkb4rXdUjfVe6qkf6rnRVj/RNqfKDKn6p9HGP7Tn3243cv5Uu5ZF+VLqUR/pR6VIe6UelgUbpUh7pR6VLeaQflS7lkX5UupRH+lHpUh7pJ6XKy/MlldJ4JOXl9pJKaTyS8vJ5SaVXO4fkng+97Pn961Rtpa5sx+OLrqavjzr8e/4MPn8Bn79iz395lbf0/A58fg8+/w4+fwCfP4LPD75/K/j+reD7t2Lv37ph79+6Ye/fumHv37ph79+6Ye/fumHv37ph79+6Ye/fumHv37qB718Hvn8d+P514PvXge/fy6s1pecH378OfP868P3rwPevA9+/Hnz/evD968H3rwffv5fXJ0rPD75/Pfj+9eD714PvXw++f3fw/buD798dfP/u4Pv38vpE6fnB9+8Ovn938P27g+/fHXz/BvD9G8D3bwDfvwF8/15enyg9P/j+DeD7N4Dv3wC+fwP4/o3g+zeC798Ivn8j+P69vFVPen7w/RvB928E378RfP9G8P2bwPdvAt+/CXz/JvD9e3ljm/T84Ps3ge/fBL5/k/L9W/NRle+3VL7Pr3z/9ubPyvdvd37l+7c7v+79693r+Ffvovs+v+79259f9/7tz697/3qXjuPPvHeN+XXv3/78uvdvf37d+9d7/zZ/bnx+6t6/3fmL7v3bn1/3/n2MfzQF+X1vzK98/3bnV75/u/Mr37+vSZwvbvs+v/L9W3x5zV++5y/l/Ve+vg7v8o+bJd/nV75/Hx8wzx++b63PT+X7tzu/8v3bm195/9W+1eOMxN3l79ev8v6r/vy69+/+MM3H/H7/evzx99f7cMzi4/6mNrTvDnQOYqzK27V2V+Ibnb1D54eTS6ryHi5Jpbodg6RS3d5CUqluFyKpVLdfkVSq29nIKX38A+UmSFKqcr8kKVW5tZKUyuKTHv8g8EhlcUqPf8BilR7/YFWv9J8ngj3+wapmqSF1Vbf0XaryyjhRqau6pYbUVd1SQ+pSbumH0z0eUgOP1KXc0s9Sl3JLP0tdyi39LHUpt/Sz1KXc0o9SlRf8iUpdyi39LHUpt/SzVB63pLyMUFQqj1tSXnEoKpXHLV1eXPa7IxrT49fu+OHOf3twzm1hrRNSw/M52Zz8f/63CrqPSE0+HQ85Jl9d47+V7pNPBwQov1q6AqLuc7/7l3vUfZz3gADdp3T3BeS1Dmr+6QM3r3VS849SdX+yiUq92rPv+ZAaNt+R6p07nv10797Ox7/HT9jjZ+zxdX98B3e8/PG/nP/+8X35N8V+KeCRUQ4B+e2PTh/+QHV8LyW9f6tjr204R4lAiG+TxJbKeoxdY3y99vEuf2HUHTtgMOo2EzAYdRsVGIzBMEpgjIZRAmMyjBIYdd/ygMGo+8YLDEbl+QEEY7UUI4KROMWUA2Pc3BeMf6EhTiY9NMRpo4cmGJpPaIhTQQ8NsdPvoSF27z00xI68h4bYZf+Mxm3EzrmHhtcNR3/8eTWG0kDD64a7aHjdcBdNMDSf0PC64S4aXjfcRcPrhrtoeN1wFw2vG+6hcbxuuIuG2A3nY+74r1m/oSF2wz00xG64hyYYmk9oiN1wDw2xG+6hIXbDPTTEbriHhtgNd9B4YjfcQ6PcDZfXN/9C3bIgmn1Lz28b7/8qFH+haU3y8wMnzit3zigYlbtsFIzBMEpgVO7eUTAqd/ooGJWnAhSMyhMECkblaQME4648maBgtBQjgpE3xbiwHRiT+4LxLzS8yaSLJhiaT2h4E0QXDW8q6KLhdfpdNLzuvYuG15H30ARel91Fw+ucu2iI3XB9/kFq9+9lSwcaYjfcQxMMzSc0xG64h4bYDffQELvhHhpiN9xDQ+yGO2gisRvuoSF2wz00vG7YxyMo+NwICpHXDXfRBEPzCQ2vG+6i4XXDXTS8briLhtcNd9HwuuEemsTrhrtoeN1wFw2vG96df06y742gkHjdcBdNMDSf0PC64S4aXjfcRcPrhrtoeN1wFw2vG+6hybxuuIuG1w130Zgb/ohGtxuOdTuO3I01fEXzl4CALkC3sxwQoNv/DQjQ7dJiPb5C8fjhLjQE6PZSAwJ0O56+AOWn+3VPl3XKz9UbEKD8kO6+AOWHdPcF6N7EAwJ0b+IBAbo3cfeYdKf8zLABAcqPSe8LUH5M+r7V44fvsXENKD+hakCA8k3cF6B8E+c3M1e8bwhQvonL8cWQx/+usSFA+Sau7vUpVP+jT+wvAco3ca3h+cPzVlvXgPJN3BegfBP3BejexNltxw/PD+fZEKB7E3cFeOUn3mS/+0OAD/sXAd9fX7en+a77m28Kof0RfTj1HOrr1c2zIv/17Zrjl9lF/1aSsZW/Uer2BL9FGZ4LuOatgzLu/vmjY9jeX53+EKVud/JLlGU7mjk3l76w/EutbiuTH3vmTW3oqE3HL05Kr7n3v6UGHqm67ZGoVN1GSlSqbsslKlW7OROUqt3GyUlVfqiLqFTlhkxSqnLDJCmVxy0pPxRFVCqPW1J+aImo1FXd0tv90KfUVd1SQ+qqbum7VOWHfohKXdUtNaSu6pYaUpdyS48bb8+53+7vPqUGHqlLuaWfpS7lln6WupRb+lnqUm7pZ6lLuaUfpSo/iEBU6lJu6WepS7mln6XyuCXlhfuiUnnckvJCfFGpPG5JeWG9qFQet6S8UF5UKo9bUl74LiqVxy1d3jqe3PPhxD2/fx22LdWV7Xja3NX09YG0vwQkdAEZXUBBF1DBBVzeWS0uwKEL8OgCdnQBAV0A+iaO6Js4om/iiL6JI/omTuibOKFv4oS+iRP6Jr68x1VcAPomTuibOKFv4oS+iRP6Js7omzijb+KMvokz+ia+vJ1SXAD6Js7omzijb+KMvokz+iYu6Ju4oG/igr6JC/omvrydUlwA+iYu6Ju4oG/igr6JC/omruibuKJv4oq+iSv6Jr68nVJcAPomruibuKJv4oq+iSv4Jt438E28b+CbeN/AN/G+gW/ifQPfxPsGvon3DXwT7xv4Jt438E28b+ib2KFvYoe+iR36Jnbom/jyOj5xAeib2KFvYoe+iR36Jnbom9ijb2KPvok9+ib26Jv48qo3cQHom9ijb2KvfBPXfJyR4rdUGgKUb+K+AOWbuCtgV76J+wJ0b2LvXoeCexddQ4DuTTwgQPcmHhCgexN7l46DML13LQG6N/GAAN2beECA7k3svX8TkFsfo7o38YAA3Zu4LyDo3sSP+Y8mIv/4dWkIUL6J+wKUb+K+AOWb+DXJv5603xoClG/i4stLQGkkMuUdW76+jnH0NYWGAOWbuJbj1MrHn4Rb14DyTdwXoHwT9wXo3sSPv2MfZ+Y+/pbRuIiVd2wNCNC9iR83n49Pocd9XP9FwPfX+3DM4uP+Jje0bxn0TubdlTd4Pf4+Fd/w7B08Px1etSvv+hKVGnik6nYZolJ1+xFRqbqdi6hU3R5HVKpyNyQoVXkjmqhU5Q5LUiqPW1LexyYqNfBI5XFLytvg/lzqt0Mhd+W9caJSV3VLDamruqXvUpW31olKXdUtNaQu5ZZ+Ok9kV96ZJyo18Ehdyi39LHUpt/Sz1KXc0s9Sl3JLP0tdyi39KFV5s6Co1KXc0s9SedyS8l5DUamBRyqPW1LeqigqlcctKW9qFJXK45aUtz+KSuVxS8obJQWlhk33cffJp+NJ5uTr9y+EhE33IfYDAnQfTd8T4Pf/+uEr7sf3MPLbu3gfnv9q/6N/Ff7oX8U/+lfpj/5V/qN/Vf7oX9U/+Vcfvora+1fuj/7VH/1u7H/0u7H/0e/G/ke/G/sf/W7sf/S7sf/R78b+R78b4Y9+N8If/W6EP/rdCH/0uxH+6Hcj/NHvRvij343wR78b4Y9+N8If/W7EP/rdiH/0uxH/6Hfjw1PY+fmvivNf/lVzOz6XY4itdwjT3yFOf4c0/R3y9Hco09+hzn6HD49xSr6Dm/4Ofvo7TL+m0/RrOk2/ptP0azpNv6bT9Gs6Tb+m8/RrOk+/pvP0azpPv6bz9Gs6T7+m8/RrOk+/pvP0azpPv6bL9Gu6TL+my/Rruky/psv0a7pMv6bL9Gu6TL+my/Rruky/puv0a7pOv6br9Gu6Tr+m6/Rruk6/puv0a7pOv6br9Gu6Tr+m3bbNfws3/y38/LfY579FmP8Wcf5bpPlvkee/RZn/FvOvbjf/6nbzr243/+p2869uN//qdvOvbjf/6nbzr243/+p2869uP//q9vOvbj//6vbzr24//+r2869uP//q9vOvbj//6vbzr+59/tW9z7+69/lX9z7/6t7nX937/Kt7n3917/Ov7n3+1b3Pv7rD/Ks7zL+6w/yrO8y/usP8qzvMv7rD/Ks7zL+6w/yrO8y/uuP8qzvOv7rj/Kt7/tNnbv7jZ27+82du/gNobv4TaG7+I2hu/jNobv5DaG7+U2hu/mNobv5zaG7+g2hu/pNobv6jaG7+s2hu/sNobv7TaG7+42hu/vNobv4DaW7+E2lu/iNpbv4zaW7+Q2lu/lNpbv5jaW7+c2lu/oNpbv6TaW7+o2lu/rNpbv7DaW7+02lu/uNpbv7zaW7+A2pu/hNqbv4jam7+M2pu/kNqbv5Tam7+Y2pu/nNqbv6Dam7+k2pu/qNqbv6zan7+s2p+/rNqfv6zan7+s2p+C/PfIs5/izT/LfL8tyjz32L+1T3/WTU//1k1P/9ZNT//WTU//1k1P/9ZNT//WTU//1k1P/9ZNT//WTU//1k1P/9ZNT//WTU//1k1P/9ZNT//WTU//1k1P/9ZNT//WTU//1k1P/9ZNT//WTU//1k1P/9ZNT//WTU//1k1P/9ZNT//WTU//1k1P/9ZNT//WTU//1k1P/9ZNT//WTU//1k1P/9ZNT//WTU//1k1P/9ZNT//WTU//1k1P/9ZNT//WTU//1k1P/9ZNT//WTU//1k1P/9ZNT//WTU//1k1P/9ZNT//WTU//1k1P/9ZNT//WTU//1k1P/9ZNT//WTU//1k1P/9ZNT//WTU//1k1P/9ZNT//WTU//1k1P/9ZNT//WTU//1k1P/9ZNT//WTU//1k1P/9ZNT//WTU//1k1P/9ZNT//WTU//1k1P/9ZNT//WTU//1k1P/9ZNT//WTU//1k1P/9ZNT//WTU//1k1P/9ZNT//WTU//1k1P/9ZtX3+s2r7/GfV9vnPqu3zn1XbtzD/LeL8t0jz3yLPf4sy/y3mX93zn1Xb5z+rts9/Vm2f/6zaPv9ZtX3+s2r7/GfV9vnPqu3zn1Xb5z+rts9/Vm2f/6zaPv9ZtV3gEazsn2+RQ/Mt8vS3OP/wUijPwwRDzc23cPPfws9/i33+W4T5bxHnv0Wa/xanr4tQn6+NW2m+RZn/FnX6W5x/eKn/Fm7+W/j5b7HPf4vzV3d6vUVtvkWc/xZp/lvk+W9R5r9Fnf4W5x9e6r/F6as71u3v16Zta76Fn/8W+/y3CPPfIs5/izT/LfL0txB49qBnmwWePei+hZv/Fn7+W+zz3+L8YnXuaThdar5FnP8Waf5b5PlvUea/RZ3+FuefPQhbON6iGWHOP3vQfws//y32+W8R5r9FnP8WSfAtfPvQ9zz/Lcr8tzi/u48gFtr2QODZg+5buPlv4ee/xT7/LcL8t4jz3yLNf4s8/y3K/LeYfnWHbZv/Fm7+W/j5b7HPf4sw/y3i/LdI898iz3+LMv8t5l/dbv7V7eZf3W7+1e3mX91u/tXt5l/dbv7V7eZf3W7+1e3mX91+/tXt51/dfv7V7edf3X7+1d1+vMHl519/vXt78GLzxz8rf/bP6h/9s/YDEv1/5n79z1xy/7X9u1O29Pc/q+H1t8Xijn+1/9G/Cn/0r+If/av023/ly+eKwi0/fwnf/1l5/bP8Z/+s/Nk/q3/0zz5Yme4/c3/2z/yf/bP9z/5Z+LN/1v7divH5z2p6/2f/Zfylxzuk6e+QT76D344nzx6//6+7iS6U5l9wn0xDed1Qc3t9DVS0DVQnDvR8k7aVkH4Td8Wb+CveZL/iTcIVbxKveJN0xZvkK96kXPEmV1zx+xVX/H7FFb9fccXvV1zx+xVX/H7FFb+fvuKdT4f3z66zRVN8btEUS3OL7lnbQOXagcLxFFD66jMar/XleG1oD1+Bhw8b8vAOeXiPPPyOPHxAHj4iD5+Qh8/IwyNv2IC8YSPyho3IGzYib9iIvGEj8oaNej/n97r//dq9fhhe7+d8f/ik99Pm8bf+563pt6d0vwyv99NmYHi9nzYDw+v9tBkYXq+fHxher58fGF7v53z/D2FJ7+f8wPB6/Xx/+KzXzw8Mr3jD9odXvGH7wyvesP3hFW/Y/vCKN2x/eMUbtj888obNyBs2I2/YomXDHgNp2ZrHQBdvwo/3TL6/1rn8/MnOldeDqs7H1/g79vgBe/yIPX7CHj9jj1+wx5+5F59vUrcr3uT0TvLbc814/1ZT+afP8FSvbaD92oFE/whRA/LwEXn4hDx8Rh6+IA9fcYf/cOgCyvAOeXiPPDzwhv1wuAXK8MAb9sOBHCjDA2/YD4eIoAyPvGEd8oZ1yBvWIW9Yh7xhHfKGdcgb1iFvWIe8YR3yhnXIG9Yjb1iPvGG93s/57jPHu9f7OT8wvN5Pm+7zl7vX+2nTH37X+2kzMLzeT5uB4fX6+YHh9fr5geH1fs53Hyrad72f8wPD6/XzA8Pr9fMDwyvesP3hFW/Y7vBB8YbtD694w/aHV7xh+8Mr3rD94ZE3bEDesAF5wwYtG/YYSMvWPAa6eBP+5rHFsD+7jl2Ir2JkF/dj/Lhhj++wx/fY4+/Y4wfs8SP2+Enx+G57jb9/Gf/7q2t43kyt8W2KFF5SM4/UwiNV8+YvL6l1b15/SfPmHxhf8+YfGF/z5h8YX/PmHxg/YI+vefMPjK9587/Gj5trj695mw+Mr3lDD4yveOtGn4/xw9YcPyveuiPjK966I+Mr3roj4yveuiPjK966I+Mr3roj4yveul/GL+3xFW/dkfEVb92R8TVv3eP4Ohdr2zQUzVt3YHzNW3dgfM1bd2B8zVt3YHzNW3dgfM1bd2B8zVv3ffzaHl/z1h0YX/PWHRh/5tZ9vkndrniT8xssH6dh7fve+w/Rq3DZBTplhAfarx1I9HsaAp0yNw4fkYdPyMNn5OEL8vAVd/gg0Clz4/AOeXiPPDzwhg0b8IYNG/CGDRvwhg0b8IYNG/CGDRvyhnXIG9Yhb1iHvGEd8oYV6JS5cXjkDeuQN6xD3rAOecM65A3rkTesR96wHnnDeuQNK9Dmc+PwyBvWI29Yj7xhPfKG9cgbdkfesDvyht2RN+yOvGEFepRuHB55w+7IG3ZH3rA78obdkTdsQN6wAXnDBuQNG5A3rECP0o3DI2/YgLxhA/KGDcgbNiBv2Ii8YSPyho3IGzYib1iBVqYbh0fesBF5w0bkDRuRN2xE3rAJecMm5A2bkDdsQt6wAu1HNw6PvGET8oZNyBs2IW/YhLxhM/KGzcgbNiNv2Iy8YQWajm4cHnnDZuQNm5E3bEbesBl5wxbkDVuQN2xB3rAFecMKtBrdODzyhi3IG7Ygb9iCvGEL8oatyBu2Im/YirxhkTudAnKnU0DudArInU4BudMpIHc6BeROp4jc6RSRO50icqdTRO50ihvwho3InU4RudMpInc6ReROp4jc6RSRO50icqdTRO50isidThG50ykidzpF5E6niNzpFJE7nSJyp1NE7nSKyJ1OEbnTKSJ3OkXkTqeI3OkUkTudInKnU0TudIrInU4RudMpInc6ReROp4jc6RSRO50icqdTRO50isidThG50ykidzpF5E6niNzpFJE7nSJyp1NE7nSKyJ1OEbnTKSJ3OkXkTqeI3OkUkTudInKnU0TudIrInU4RudMpInc6ReROp4jc6RSRO50icqdTRO50isidThG50ykidzpF5E6niNzpFJE7nSJyp1NE7nSKyJ1OEbnTKSJ3OkXkTqeI3OkUkTudInKnU0TudIrInU4RudMpInc6ReROp4jc6RSRO50icqdTRO50isidThG50ykidzpF5E6niNzpFJE7nSJyp1NE7nSKyJ1OEbnTKSJ3OkXkTqeI3OkUkTudInKnU0LudErInU4JudMpIXc6pQ14wybkTqeE3OmUkDudEnKnU0LudErInU4JudMpIXc6JeROp4Tc6ZSQO50ScqdTQu50SsidTgm50ykhdzol5E6nhNzplJA7nRJyp1NC7nRKyJ1OCbnTKSF3OiXkTqeE3OmUkDudEnKnU0LudErInU4JudMpIXc6JeROp4Tc6ZSQO50ScqdTQu50SsidTgm50ykhdzol5E6nhNzplJA7nRJyp1NC7nRKyJ1OCbnTKSF3OiXkTqeE3OmUkDudEnKnU0LudErInU4JudMpIXc6JeROp4Tc6ZSQO50ScqdTQu50SsidTgm50ykhdzol5E6nhNzplJA7nRJyp1NC7nRKyJ1OCbnTKSF3OiXkTqeE3OmUkDudEnKnU0LudErInU4JudMpIXc6JeROp4Tc6ZSQO50ScqdTQu50SsidTgm50ykhdzol5E6nhNzplJA7nRJyp1NC7nRKyJ1OCbnTKSN3OmXkTqeM3OmUkTud8ga8YTNyp1NG7nTKyJ1OGbnTKSN3OmXkTqeM3OmUkTudMnKnU0budMrInU4ZudMpI3c6ZeROp4zc6ZSRO50ycqdTRu50ysidThm50ykjdzpl5E6njNzplJE7nTJyp1NG7nTKyJ1OGbnTKSN3OmXkTqeM3OmUkTudMnKnU0budMrInU4ZudMpI3c6ZeROp4zc6ZSRO50ycqdTRu50ysidThm50ykjdzpl5E6njNzplJE7nTJyp1NG7nTKyJ1OGbnTKSN3OmXkTqeM3OmUkTudMnKnU0budMrInU4ZudMpI3c6ZeROp4zc6ZSRO50ycqdTRu50ysidThm50ykjdzpl5E6njNzplJE7nTJyp1NG7nTKyJ1OGbnTKSN3OmXkTqeM3OmUkTudMnKnU0budMrInU4ZudMpI3c6ZeROp4zc6ZSRO50ycqdTRu50ysidThm50ykjdzpl5E6njNzpVJA7nQpyp1NB7nQqyJ1OZQPesAW506kgdzoV5E6ngtzpVJA7nQpyp1NB7nQqyJ1OBbnTqSB3OhXkTqeC3OlUkDudCnKnU0HudCrInU4FudOpIHc6FeROp4Lc6VSQO50KcqdTQe50KsidTgW506kgdzoV5E6ngtzpVJA7nQpyp1NB7nQqyJ1OBbnTqSB3OhXkTqeC3OlUkDudCnKnU0HudCrInU4FudOpIHc6FeROp4Lc6VSQO50KcqdTQe50KsidTgW506kgdzoV5E6ngtzpVJA7nQpyp1NB7nQqyJ1OBbnTqSB3OhXkTqeC3OlUkDudCnKnU0HudCrInU4FudOpIHc6FeROp4Lc6VSQO50KcqdTQe50KsidTgW506kgdzoV5E6ngtzpVJA7nQpyp1NB7nQqyJ1OBbnTqSB3OhXkTqeC3OlUkDudCnKnU0HudCrInU4FudOpIHc6FeROp4Lc6VSQO50KcqdTQe50qsidThW506kidzpV5E6nugFv2Irc6VSRO50qcqdTRe50qsidThW506kidzpV5E6nitzpVJE7nSpyp1NF7nSqyJ1OFbnTqSJ3OlXkTqeK3OlUkTudKnKnU0XudKrInU4VudOpInc6VeROp4rc6VSRO50qcqdTRe50qsidThW506kidzpV5E6nitzpVJE7nSpyp1NF7nSqyJ1OFbnTqSJ3OlXkTqeK3OlUkTudKnKnU0XudKrInU4VudOpInc6VeROp4rc6VSRO50qcqdTRe50qsidThW506kidzpV5E6nitzpVJE7nSpyp1NF7nSqyJ1OFbnTqSJ3OlXkTqeK3OlUkTudKnKnU0XudKrInU4VudOpInc6VeROp4rc6VSRO50qcqdTRe50qsidThW506kidzpV5E6nitzpVJE7nSpyp1NF7nSqyJ1OFbnTqSJ3OlXkTqeK3OlUkTudKnKnU0XudKrInU4VudOpInc6uQ251OkxPfCOfUwPvGQf0wNv2cf0wGv2MT3wnn1MD7xoH9MDb9rH9MCr9jE99K5Frnd6TA+9a5ELnh7TQ+9a5Iqnx/TQuxa55OkxPfSuRa55ekwPvWuRi54e00PvWuSqp8f00LsWuezpMT30rkWue3pMD71rkQufHtND71rkyqfH9NC7Frn06TE99K5Frn16TA+9a5GLnx7TQ+9a5Oqnx/TQuxa5/OkxPfSuRa5/ekwPvWuRC6Ae00PvWuQKqMf00LsWuQTqMT30rkWugXpMD71rkYugHtND71rkKqjH9NC7FrkM6jE99K5FroN6TA+9a5ELoR7TQ+9a5Eqox/TQuxa5FOoxPfSuRa6FekwPvWuRi6Ee00PvWuRqqMf00LsWuRzqMT30rkWuh3pMD71rkQuiHtND71rkiqjH9NC7Frkk6jE99K5Frol6TA+9a5GLoh7TQ+9a5Kqox/TQuxa5LOoxPfSuRa6LekwPvWuRC6Me00PvWuTKqMf00LsWuTTqMT30rkWujXpMj7xrHXRvlIPujXLQvVEOujfKbci71kH3Rjno3igH3RvloHujHHRvlIPujXLQvVEOujfKQfdGOejeKAfdG+Wge6McdG+Ug+6NctC9UQ66N8pB90Y56N4oB90b5aB7oxx0b5SD7o1y0L1RDro3ykH3Rjno3igH3RvloHujHHRvlIPujXLQvVEOujfKQfdGOejeKAfdG+Wge6McdG+Ug+6NctC9UQ66N8pB90Y56N4oB90b5aB7oxx0b5SD7o1y0L1RDro3ykH3Rjno3igH3RvloHujHHRvlIPujXLQvVEOujfKQfdGOejeKAfdG+Wge6McdG+Ug+6NctC9UQ66N8pB90Y56N4oB90b5aB7oxx0b5SD7o1y0L1RDro3ykH3Rjno3igH3RvloHujHHRvlIPujXLQvVEOujfKQfdGOejeKAfdG+Wge6McdG+Ug+6NctC9UQ66N8pB90Y56N4oB90b5aB7oxx0b5SD7o1y0L1RHro3ykP3Rnno3igP3RvlN+Rd66F7ozx0b5SH7o3y0L1RHro3ykP3Rnno3igP3RvloXujPHRvlIfujfLQvVEeujfKQ/dGeejeKA/dG+Whe6M8dG+Uh+6N8tC9UR66N8pD90Z56N4oD90b5aF7ozx0b5SH7o3y0L1RHro3yivuLtrr/vdr9/pper2f9wPTK+7PCS79/drg8ofp9X7mjEyv9zNnZHq9nzkj0wfo6fX6+5Hp9X7eh5Sf05f9w/R6P+9Hptfr70em1+vvB6ZX3J8zMr3iXTswveJdOzC94l07ML3iXTswveJdOzA99K5V3J8zMj30rlXTn3NMpKYT5zXRxTvx472U76+txxC1xA/Te+jpd7XTpy0/Q1Daan29Om5/di1e3Ypzq9YIqfU1fwKfP4PPX8Dnr9jzX92mIz6/3p0+Nr/erT42P+Zef82Puatf84Pv3wy+fzP4/s3g+zeD798Cvn8L+P4tivevO6ZIrpvVUnxmtRRLO6sVxbtaXKvivf47rbJP7xTFfuFWLop9yK1cFPubW7ko9k23clHsx+7kUhX7vFu5KPaPt3JZxpcKc1nGwwpzCcalycX8bpuL+d02F/O7bS7md9tczO+2uOyb+d02F/O7bS7md9tczO+2uQTj0uRifrfNxfxum4v53TYX87ttLuZ3m1yc+d02F/O7bS7md9tczO+2uQTj0uRifrfNxfxum4v53TYX87ttLuZ3m1y8+d02F/O7bS7md9tczO+2uQTj0uRifrfNxfxum4v53TYX87tNLjujf+k3b+47o38Z4cK4j/qtifvOuI9GuDDuoxEujPtohAvj/ZcBLoHx/ssIF0b/0u9p2gOjfxnhwnj/ZYRLMC5NLpR+d4ALpd8d4ELpdwe4rO93X1rX97CH1riML/3FT/YlPW+U+JLT208ub2SWcabiZJbxpuJklnGn4mSCkflAZhmHKk5mGY8qTmYZl/obMjX458w1xg9klvGp4mSWcbXSZBKlBx4iQ+mBh8hQeuAhMpQeeIhMICSzb+754n3b3QcyjB54jAyjBx4jw+iBx8gweuAxMoweeIiM5nNFbibD6IH3rT5n3t2WP5Bh9MBjZBg98BiZYGQ+kOH0wCNkOD3wCBlODzxChtMDp/giU76Q+f7qGp5/aPhyx+LxLi+KnH5ZmKLmM4OAKFL6cHc8wrO7uLc/69Y5E0mcDKUPHyITjMwHMpQ+fIgMpQ8fIkPpw4fIUPrwdzLpw33FdU5ekiazztlL4mQ4PXB1TzJ+Cx/IcHrgETKcHniETDAyH8hweuARMpweeIQMpwceIcPpgd/IOP+BDKcH7pMJ65zHJE6G0gP7eKQDn/YPZCg98BAZSg88RCYYmQ9kKD3wEBlKDzxEhtIDD5Gh9MDvZLL7QIbSA4+QWeeMJnEylB54d8/vWO0PSh/IUHrgITKUHniITDAyH8hQeuAhMpQeeIgMpQceIkPpgd/J7B/u6a1zapM0mXXObRIng+mBX/NjOtXX/Ir9pPfPn5z8nju/md4/R/ah3VIdNJ9uJK5VsecT16rYxYlrVezLxLUqdlriWhV7p99pjc8WYp/bbbVhV+yGxLUq9jfiWhV7IXGty/imAa2BSOsyvmlAq2bfVI7s4ktqZxfNp1oNza/Z36TnoT9pd1vnd62E54vLJ3+j+UQpaa2aT4kS16rZ30hr1exvpLVq9jfSWgORVs3+RlqrZn8jrVWzF5LWSuSbNJ9iJK1V8ylG4lqJfJPmk4bEtRL5Js2nAYlrJfJNmk/sEddK5Js0n6ojrpXIN2k++UZcK5Fv0nw6jbhWIt+k+QQZca1EvknzKS/iWlfZr3t9dtbuNbS1aj5VQ1zrKp/DwT1fHNyH32HNpxiIa13lc3hE6yqfwyNaV8mvI1pXya8jWlfZryE9n0MK5cNzSJqb9cW1rpJfR7Sukl9HtC7jmwa0BiKty/imAa2Yvuk1P6YXes2P6W9e82N6lmN+zY3l+348+70Hge8bae4gF9eq2IeIa1XsQ8S1BiKtin2IuFbFPuR3WvvfwdHcty2uVbG/Edeq2AsJa42aW67FtS7jmwa0LuObBrQu45sGtAYMrTE0c1rU3Ok8ND+Iv/k4v2LPEl7zhy+n2b3Pr9iHDM2v2VuU/Zi/7J3PKue258zO+beW3OBfajX3B09Qq9lfyKvV7DDk1Wr2GPJqA5VazZ5EXq1mByOvVvM9Gnm1mu/SyKul8lKae2gnqKXyUpqbaCeopfJSmptrJ6il8lKa22snqKXyUpobbCeopfJSmltsJ6il8lKam2wnqKXyUprbbCeopfJSmhttJ6il8lKa23InqKXyUpobcyeopfJSmltzJ6il8lKam3MnqKXyUprbcyeopfJSmht0J6il8lKaW3QnqKXyUpqbdCeopfJSmtt0J6il8lKaG3UnqKXyUppbdSeopfJSmpt1J6il8lKa23UnqKXyUpobdieopfJSmlt2J6il8lKJyktp7lCWV6u5RXmCWiovlam8lOaO7AlqA5VaKi+luSl7gloqL6W5LXuCWiovpbkxe4JaKi+luTV7gloqL6W5OXuCWiovpbk9e4JaKi+luZl7gloqL6W69VteLZWXUt38La+Wykupbv+WV0vlpVQ3gMurpfJSqlvA5dUyeamkuglcXi2Tl0qq28Dl1TJ5qbQFKrVMXiqpbhuXV8vkpZLmJvMJaqm8FFXveaLqPU9UveeJqvc8UfWeJ6re80TVe56oes8TVe95ouo9T1S954mq9zxR9Z4nqt7zRNV7nqh6zxNV73mi6j1PVL3niar3PFH1nieq3vNE1XueqHrPE1XveaLqPU9UveeJqvc8UfWeJ6re80TVe56oes8TVe95ouo9T1S954mq9zxR9Z4nqt7zRNV7nqh6zxNV73mi6j1PVL3niar3PFH1nieq3vNE1XueqHrPE1XveaLqPU9UveeJqvc8UfWeJ6re80TVe56oes8TVe95ouo9T1S954mq9zxR9Z4nqt7zRNV7nqh6zxNV73mi6j1PVL3niar3PFH1nieq3vNE1XueqHrPE1XveaLqPU9UveeJqvc8UfWeJ6re80TVe56oes8TVe95ouo9T1S954mq9zxR9Z4nqt7zRNV7nqh6zxNV73mi6j3PVL3nmar3PFP1nmeq3vO8BSq1TF4qU/WeZ6re80zVe56pes8zVe95puo9z1S955mq9zxT9Z5nqt7zTNV7nql6zzNV73mm6j3PVL3nmar3PFP1nmeq3vNM1XueqXrPM1XveabqPc9UveeZqvc8U/WeZ6re80zVe56pes8zVe95puo9z1S955mq9zxT9Z5nqt7zTNV7nql6zzNV73mm6j3PVL3nmar3PFP1nmeq3vNM1XueqXrPM1XveabqPc9UveeZqvc8U/WeZ6re80zVe56pes8zVe95puo9z1S955mq9zxT9Z5nqt7zTNV7nql6zzNV73mm6j3PVL3nmar3PFP1nmeq3vNM1XueqXrPM1XveabqPc9UveeZqvc8U/WeZ6re87xMW3TxzxcX//Unv7Susn9GtK7yCVVCeo4c8getq3w+jWhd5dNpQOsyPcIjWldJeSNaMTPea37MnfmaX/EejLs/Xly3nsOJvj4dTsxvPzu8/7YpzmET1CrOYRPUKnY5E9Qq9jkT1Cp2OuJqi+ae3wlqFbudCWoV+50JahW7owlqA5VaJi9VNPf8TlDL5KWK5p7fCWqpvJTmnt8Jaqm8lOae3wlqqbyU5p7fCWqpvJTmnt8Jaqm8lOae3wlqqbyU5p7fCWqpvJTmnt8Jaqm8lOZ21F+p7T/rUjR3o0pr1dye+Tut3ecEiubuTHGtq3w6jWgNRFpXSXkjWjEz3mt+zJ35ml/xHszePV/82HKd37WQ8t8v/vIM05ffNcUpTFqr5k5Lca2K/Y24VsX+RlyrYn8jrjUQaVXsb8S1KvY34loVeyFxrUS+SXODpbRWzf2V4lqJfJPm7kpxrUS+SXNvpbhWIt+kubNSXCuRb9LcVymulcg3ae6qFNdK5Js091SKayXyTZo7KsW1Evkmzf2U4lqJfJPmbkpxrUS+SXMvpbhWIt+kuZNSXCuRb9LcRymulcg3ae6iFNdK5Js091CKayXyTYXINxUi31SIfJPmHlVxrYFIK5FvKkS+SXM/rrhWIt+kuR9XWqvmflxxrUS+SXM/rrhWIt+kuXdXXCuRb9LcuSuulcg3ae7bFdfK45uq5q5dca08vqlq7tkV18rjm+oWiLTy+KaquV9XXCuPb6qau3XFtRL5Js29uuJaiXyT5k5dca1Evklzn664ViLfpLlLV1wrkW/S3KMrrpXIN2nu0BXXSuSbNPfnimsl8k0+EGkl8k2eyDdp7n8W10rkmzyRb9qJfJPmXm9xrUS+SXOvt7jWQKSVyDdp7vUW10rkm4j6witRX3gl6guvRH3hlagvvBL1hVeivvBK1BdeifrCK1FfeCXqC69EfeGVqC+8EvWFV6K+8ErUF16J+sIrUV94JeoLr0R94ZWoL7wS9YVXor7wStQXXon6witRX3gl6guvRH3hlagvvBL1hVeivvBK1BdeifrCK1FfeCXqC69EfeGVqC+8EvWFV6K+8ErUF16J+sIrUV94JeoLr8t0LT9e8RzZhw9aV9k5I1pX+WwqIT1HDvmD1lU+mwa0LtPJO6J1lUw3onWVTDeiFTPTvebH3Jmv+RXvwRKfqy3Vkjq/a37P+zFHqW9z+De1itPXBLWK89cEtYpdzgS1in2OtFq/aW7RnaBWsdeZoFax25mgVrHfmaA2UKkl8lIPtURe6qGWyEs91BJ5qYdaKi+luVl3gloqL6W5XXeCWiovpblhd4JaKi+luWV3gloqL6W5aXeCWiovpbltd4JaKi+luXF3gloqL6W5dXeCWiovpbl5d4JaKi+luX13gloqL6W5gXeCWiovpbmFd4JaKi+luYl3gloqL6W5jXeCWiovpbmRd4JaKi+luZV3gloqL6W5mXeCWiovpbmdd4JaKi+luaF3gloqL6W5pXeCWiovpbmpd4JaKi+lua13gloqL6W5sXeCWiovpbm1d4JaKi+lubl3gloqL6W5vXeCWiovpbnBd4JaKi+lucV3gloqL6W5yXeCWiovpbnNd4JaKi+ludF3gloqL6W51XeCWiovpbnZd4JaKi+lud13gloqL6W54XeCWiovpbnld4JaKi9VqLxUofJSmhurJ6il8lKFyksVKi+luZF8gloqL6W5lXyCWiovpbmZfIJaKi+lucl8gloqL8XUe/5QS+WlmHrPH2qZvJSj6j13VL3njqr33FH1nrstUKll8lKOqvfcUfWeO6rec0fVe+6oes8dVe+5o+o9d1S9546q99xR9Z47qt5zR9V77qh6zx1V77mj6j13VL3njqr33FH1njuq3nNH1XvuqHrPHVXvuaPqPXdUveeOqvfcUfWeO6rec0fVe+6oes8dVe+5o+o9d1S9546q99xR9Z47qt5zR9V77qh6zx1V77mj6j13VL3njqr33FH1njuq3nNH1XvuqHrPHVXvuaPqPXdUveeOqvfcUfWeO6rec0fVe+6oes8dVe+5o+o9d1S9546q99xR9Z47qt5zR9V77qh6zx1V77mj6j13VL3njqr33FH1njuq3nNH1XvuqHrPHVXvuaPqPXdUveeOqvfcUfWeO6rec0fVe+6oes8dVe+5o+o9d1S9546q99xR9Z47qt5zR9V77qh6zx1V77mj6j13VL3njqr33FH1njuq3nNH1XvuqHrPHVXvuafqPfdUved+mbbo4p8vLv7rT35pXWX/jGhd5ROqhPQcOeS21mW6hEe0rvLpNKJ1lZw3onWVlDeiNUBqfc2PuTNf8+vdg3nz+e8X5+3ds/zx75reFCavVW8Gk9eq19+Ia1Xc7yuvVa+/kdeq19/Ia9Xrb+S1BiKter2QvFYi36S40VdeK5FvUtzmK65VcZevvFYi36S4x1deK5FvUtzhK6+VyDcp7u+V10rkmxR398prJfJNint75bUS+SbFnb3yWol8k+K+XnmtRL5JcZ/r77Tu9flHyb1+eF5FcZuruFbFfZ+/0xrc83c4uA+/w4rbPuW1rvI5PKJ1lc/hEa2r5NcRravk1xGtq+zXkJ4vDmX/oHWV/TqgVXG/p7zWVfLriNZlfNOA1mV804DWQKR1Gd80oHUZ3zSgdRnfNKCVyDcpbvMU16q4y1NeK6Zves2P6YVe8yv2N48f8ZzfhU/zB/D5FfsQ5+sxf93+efo+uuI+THmtin2IuFbFPkRcq2IfIq1VcQ+mvFbFPkRcq2LPIq5Vs7+R1hqItBL5JsXdl/JaiXyT4t5Lea1Evklx56W8ViLfpLjvUl4rkW9S3HUpr5XINynuuZTXSuSbFHdcymvl8U274n5Lea08vmnfeHzTvvH4pn0LRFpX2a/970Xs2yr7dUCr4h7P32ntP2e9K+7xlNe6yufwiNZVPodHtK6SX0e0rpJfR7Susl/7z7ztmvtBxbWukl8HtGruBxXXuoxvGtC6jG8a0LqMbxrQGoi0LuObBrQu45sGtBL5Js39oOJaiXyT5n7QH7S+5sf0Qq/5FfsbH/xzfh/2D/Mr9ixD8wfF8x9HXGWfs8C1rtiHiGtV7EPEtSr2IeJaFfsQca2KfYi0Vs19m+JaFXsWca2a/Y20Vs1eSFprINJK5JsCkW8KRL5Jc4+quFYi3xSJfFMk8k2a+3HFtRL5Js39uOJaiXyT5h7VX2kdeG5Tc4+qtFbNfZu/+x3uPwemuW9TXOsyn8MDWpf5HB7Qukx+HdC6TH4d0EqUXzX3bUpr1dy3Ka6VKL9q7uYU10qUXzV3foprxfRNr/kxvdBrfkx/85of07O85lfsQ/bDMubd97qwvX+O7D99x1hz36a4VsU+RFyrYh8irlWxDxHXGoi0KvYhv9Man57L5w+eS3PfprhWxf5GXKtiLySudRnf1NequW9TXOsyvmlA6zK+aUAriG/aUzunae7QHJofxN98nF+zZ6nbMX91H+bX7ENG5tfsLbJ7zv/4K9c/T9+T1NxJKaw1aO6kFNeq2VtIa9XsLaS1avYW0loDkVbNnkVaq2Z/I61VsxeS1srjm8JG5JsckW/S3CErrpXIN2nukBXXGoi0EvkmzR2y4lqJfJPmDllxrUS+SXPX6K+09r/XFDR3jYprXeZzuPs9iaC5k1Jc6zKfwwNal/kc7mvV3EkprnWZ/DqglSi/au7FFNcaiLQS5VfNHZriWonyq+YOTXGtRPlVc4emuFai+/6aOzTFtRL5Js0dmuJaMX3Ta35ML/SaX7G/Cfno6Q/vz2h/mV+xZxmaX7EPCfH4LnCo5fy1rrmTUlyrYh8irlWxDxHXqtiHiGsNRFoV+xBxrYo9i7hWzf5GWqtmLyStlcg3JSLflIh8k+YOWXGtRL5Jc4esuFYi36S5Q1ZcK5Fv0twhK66VyDdp7pAV17rKfh14blNz16i41mU+h/vPgWnuxRTXuszncF+r5g5Nca3L5NcBrcvk1wGtRPlVc4emuFai/Kq5Q1NcK1F+1dyhKa6VKL9q7tD8Qetrfkwv9Jof09+85sf0LK/5g975Y3j+5Bxj70yRfpd30Nx1Ka5VsQ8R16rYh4hrVexDxLUq9iHCWqPmvs3fae12PkfNfZviWhX7mx+0vuZX7G+G5g9650/bc4qcXBH4DFHsb8S1KvY34loV+xtxrYr9jbhWxf5GWqvmXszfae3vfM29mOJaFfsbca2KvZC41kCkdRnfNKB1Gd80oBXTN73mx/RCr/k1+5t4fG871a3zu5aO37UUS/t3zWv2N9JaNfubX2kN2/GT985P/jzFi4tmL3QnF82+6U4uwbg0uWj2Y3dy0ezd7uSi2efdyUWzf7yTyzK+VJaL5u7fW7mY321zMb/b5mJ+t80lGJcmF/O7bS7md9tczO+2uZjfbXMxv9vkormz+VYu5nfbXMzvtrmY321zCcalycX8bpuL+d02F/O7bS7md9tczO82uWjuBr+Vi/ndNhfzu20u5nfbXIJxaXIxv9vmYn63zcX8bpuL+d02F/O7TS6aO91v5WJ+t83F/G6bi/ndNpdgXJpczO+2uZjfbXMxv9vmYn63zcX8bpOL5i7+W7mY321zMb/b5mJ+t80lGJcmF/O7bS7md9tczO+2uZjfbXMxv9vkovnMk1u5mN9tczG/2+ZifrfNJRiXJhfzu20u5nfbXMzvtrmY321zMb/b5KL5rJpbuZjfbXMxv9vmYn63zSUYlyYX87ttLuZ321zM77a5mN9tczG/2+KSNJ+JdCsX87ttLuZ321zM77a5BOPS5GJ+t83F/G6bi/ndNhfzu20u5nebXFSfkXUnF/O7bS7md9tczO+2uQTj0uTC6F/2uv/92r1+4sLoXwa4UJ5/FFz6+7XB5Q9cGPfRCBfGfTTChXEfjXBhvP8ywoXx/ssIF0b/EtLznMJQ9g9cGP3LCBfG+y8DXCjPPxrhQul3B7hQ+t0BLpR+d4BLMC5NLpR+d4ALpd8d4GJ+t83F/G6bi/ndJheC849eWtf3sC+ty/jSX/xkl7L/+8WP//k285bfyCzjTMXJBCPzgcwy7lSczDL+VJzMMg71N2Ty/nzx43/WD2SW8ajiZJZxqb8i47aDTPl6NX1/dazPnxzrG0W3vSiuc8bRrRSXccu3UqT04eIUKT27OMVgFAUoUmYBcYqUuUGcImfGkKbImUekKVp2EaC4znlVt1K07CJB0bKLBEXLLhIUg1EUoGjZRYKiZRcJipZdJChadpGgaNlFgOI6Z0nNo3gIjO+v/ULR/KIERdvREle07WgJirajJSjajhaguM55SbdStPuLH556W+d8JXEy5us+kQmMZMp2PENawicylPfrhshQ+vshMpSevRxL+/E/Pzxdu85ZS+JkKL11ycduqrv/52lXuM7ZTLdSpPTW4hQpfbg4RUrPLk4xGEUBipxZQJoiZ26QpsiZMaQpcuYRaYqWXc5TzOucs3UrRcsuEhQtu0hQtOwiQTEYRQGKll0kKFp2kaBo2UWComUXCYqWXQQornNm2q0UzS92KXafO87rnK91K0Xb0RJXtO1oCYq2owUoetvREhTt/qIERbu/+JXii4x5wE9kgpH5QIby3l49frKrxX0gQ3m/bogMpb8fIsPo2f221+fMW9g+kGH04UNk1jmz7ldknDvI5PDP065wnRPubqXI6K3lKTL6cHmKwSgKUGT09/IUGbOAPEXG3CBPkTNjSFPkzCPCFNc5f/BWipZdJChadpGgaNlFgmIwigIULbtIULTsIkHRsosERcsuEhQtuwhQpDxnUp6iZRcJipZdJChadpGgGIyiAEXLLhIULbtIULTsIkHRsosERcsuAhQpz5mUp2jZRYKiZRcJipZdJCgGoyhA0bKLBEXLLhIULbtIULTsIkHRsosAxWzZRYKiZRcJipZdJChadpGgGIyiAEXLLhIULbtIULTsIkHRsosERcsuAhQpz9+Vp2jZRYKiZRcJipZdJCiaX+xS7PemUp79Kk6R8hxP8Sua8hxPeYq2oyUo2o6WoBiMogBFu7/4leKLjHnAT2TM130iw3lvr+7PmZ3/RIbzfl2fTKE863KMDKVnd29k6icylD58iAylt3bpqc97X//ZcYXHGDG/9T7H8EYxGEUBipTeWpwipQ8Xp0jp2cUpUvp7cYqUWUCaIuU5k/IUOTOGNEXOPCJN0bKLBMVgFAUoWnaRoGjZRYKiZRcJipZdJChadhGgSHn+rjxFyy4SFC27SFC07CJBMRhFAYqWXSQoWnaRoGjZRYKiZRcJipZdBChynm8sTtGyiwRFyy4SFC27SFAMRlGAomUXCYqWXSQoWnaRoGjZRYKiZRcBipznG4tTNL/YpdjtNSicZ8qKU7Qd3aXY/RZ04TzHU5yi7WgBipzneIpTtPuLEhTt/uJXii8y5gE/kQlG5gMZu7f3iQzl/Tqf42tm1/m0DjU9P6232s6lnOdiilOkzALiFCmzgDRFznMxxSlSZgFxipRZQJwiZW74FcW3O/DvP/kLxWAUBShS5hFxipZdJChadpGgaNlFgqJlFwGKnOdi/inFT88acJ6LKU7RsosERcsuXym+yAQj84GMZYxPZCw3fCJDmQX2F5ngUufT2r04Pv7n+6vfP68p08AEjpR5QJ4j52mTEzhSZoLfcdzj9uS4R/eBI2UqmMCRMhf8kqP3B8cav3BsZLH+k3klGPPLmVNmmZuZU6akm5lb/rqeuWW165lbrrucOedpxjczt7x4PXPLltcztxx6PfNgzC9nbjn0euaWQ69nbjn0euaWQ69nbjn0auaV89Ttm5lbDr2eueXQ65lbDr2euflzYebd7rHKeab0vcw5T/2997OF84zgm5mbb7meufmW65kHY345c7t/fob5i6N5bhmO5qNlONq96y7H4J4KXYifONr9aBGOnKccT+Bo+avLMbrje0PRpQ8cLVPJcLSc1L+uSz44xvKFY+Nnu/z8lpH3Kb+9en+jHoz6DdQtK91B3ZLVHdQth91B3VLbHdQt491AnfPs6NupW368g7qlzTuoWza9g3ow6jdQt2x6B3XLpndQt2x6B3XLpndQt2x6A3XOs8Fvp27Z9A7qlk3voG7Z9A7qwajfQN2y6R3ULZveQd2y6R3ULZveQd2y6Q3Uo2XTO6hbNr2DumXTO6hbNr2DejDqN1C3bHoHdcumd1C3bHoHdcumd1C3bHoD9WTZ9A7qlk3voG7Z9A7qlk3voB6M+g3ULZveQd2y6R3ULZveQd2y6Q3Us/l1WeoDXbHZ3Pr1zM2/CDPv9zlmcy/XMzfvcj1zcy7XM7d76pczL3ZH/QzzF0fz3DIczUfLcLT72DIcg3HscUz+OYdLJXV2UqjpuZO2t50U35lbrrueueW665lbrrueueW665lbrrucebVcdz1zy4CyzOMxdHyf4wtzy4vXM7dseT3zYMwvZ2459HrmlkOvZ2459HrmlkOnMc/uA3PLoRcz37fNcuj1zC2HnmH+4mjZUoaj5cUux7zVJ8cca+czwJVwnNBavpzkuL9RD0b9BuqWGe+gbqnxDuqWG++gbsnxDuqWHaWpx+Ppq5K3NnVn6fEO6pYf76BuafMO6pZN76AejPoN1C2bClPPpRzUy1fn+Ed3bp3lWO3/hSzzav8vZPlY+L9QTcera/Efdovl4xuoe8vHd1C3fHwHdcvHd1C3fHwH9WDUb6Bu+ViaegkH9Zo/ULfMewd1y7F3ULdsegd1y6Y3UN8tm95B3bLpHdQtm0pTd8fPfvxl/Av1P7orvFuO1f5fKNh/IeX/hSwfy/4X8ls9frbbyofdYvn4DuqWj++gbvn4DuqWj2+gHiwf30Hd8vEd1C0fC1N37jgHxvn9A3XLvHdQD0b9BuqWTe+gbtn0DuqWTe+gbtn0DuqWTaX9enAH9f2rX/+ju8LRcqz2/0KWebX/F7J8LPxfyPuDx+N92rslWj6+g3ow6jdQt3x8B3XLx3dQt3x8B3XLx3dQt3wsTX2vB/X44ZtCyTLvHdQtx95B3bLpHdQtm95BPRj1G6hbNr2DumVT6b9n5ePvWT599et/dFc4WY7V/l/IMq/2/0KWj7/+FzrIZMuwn8hQ5swQni/2cXO9q3pzR2vftr9fe/GNI2VynMCRMgtO4BiMowhHyrw2gSNlApvAkTIn/ZJjPFostndf/YUjZZqZwJEyc8hzLJQJZQJHyzMyHC3PyHC0PNPneHyr1n35Vu0XjsE4inC0PCPD0fKMDEfLMzIcLc/IcLQ80+Xo9v3gGFKbY7U8I8PR8owMR8szMhwtz8hwDMZRhKPlmT7HenD02yeOlmdkOFqekeFoeUaGo+UZCY5uszwjw9HyTJejT+7gmMMHjpZnZDhanpHhGIyjCEfLMzIcLc/IcFw/z7y0rp85Xloxc8Exv8P046/5FfvgvD+/l5Rzib3ftbAdP3nv/OSB30un2NfeykWxT72VSzAuTS6KfeStXBT7wlu5KPZ5t3JR7Alv5aLYP97JxSv2pbdyMb/b5mJ+t83F/G6bSzAuTS7md9tczO+2uZjfbXMxv9vmYn63yWU3v9vmYn63zcX8bpuL+d02l2BcmlzM77a5mN9tczG/2+ZifrfNxfxuk4vmk+xv5WJ+t83F/G6bi/ndNpdgXJpczO+2uZjfbXMxv9vkovkE42lc9uOLSXv9xIXRv4xwYdxHwaW/Xxtc/sCFcR+NcGHcRyNcGPfRCBfG+y8jXBjvvwxw0Xwa5TwuKT+5lP0DF0b/MsKF8f7LCBfG+y8jXIJxaXKh9LsDXCj97gCX9f3uS+v6HvaldRlf+ouf7Mqria68N9Ht7kVG8xlzN5NZxpuKk1nGnYqTWcafipMJRuYDmWU8qjiZZVzqr8gcNtWVsn0gs4xPFSezjKsVJ8PpgQfIaD7F7GYynB54hAynBx4hQ+mB6/GTXQ37BzLByHwgQ+mBh8hQeuAhMpQeeIgMpQceIkPpgUfIaD75ahoZv23HzNuXZzfeyTB64DEyjB54jAyjBx4jE4zMBzKMHniMDKMHHiPD6IH9dujzWyofyDB64DEyjB54hIzXfFrSzWQ4PfAIGU4PPEKG0wOPkAmMZNzxk737cBfCaz5H6GYylB54iAylBx4iQ+mBh8hQeuARMppPKLqZDKYHfs2P6VRf8yv2k2Wrz/mL953fTO8Pixja3xf1ms8HEteq2POJa1Xs4sS1KvZl4loVOy1xrYq90++0xufDbD63vzfmNZ+L84PW1/yKPcvQ/Io9SwnxmD+W89eV5rNjxLUGIq2a/Y20Vs3+RlqrZn8jrVWzv/mV1oGdr9nfCGvVfA6KuFbNXkha6zK+aUDrMr5pQGsg0orpm17zY3qh1/yY/uY1P6Znec2P6UOO+TWfOTE0P6ZfeM2P6QFe82Pu9df8mLv6NT/4/tV8xsDQ/OD7N4Dv3wC+fzWfmTA0P/j+jeD7N4LvX81nQAzND75/NZ+pMDQ/+P7VfEbB0Pya9285nlcrtfck4k+vPtRqPiFgglrNu/03ausxcn1/bvH9PqbmLn9xrZo9g7TWQKRVixd5TaTFXbwm0uIXXhNpcQCvibTs9GMiNf3nr4m07MbXRFo22GsiLXvmNZGWbfCaSN1ntpo+59dE6j6z1fQXvyZS95mtpq/3NZG6z2w1/bSvidR9ZqvpY31NpO4zW03/6GuimZ/Zr3cpl7xLveJdpnY7vt7FXfIu/pJ32S95l3DJu8RL3iVd8i6XXPv1kmu/XnHt79t2ybu4S97FX/Iu+yXvEi55l3jJu6RL3iVf8i7lkne55Np3l1z77pJr311y7btLrn13ybXvLrn23SXXvrvk2neXXPvukmvfX3Lt+0uufX/Jte8vufb9Jde+v+Ta95dc+/6Sa99fcu37S679/ZJrf7/k2j//Tcb9eK3f8/bPn+8/9f8Wvp//vqH4REHdRFHZRGGdE8B/ceL9Xp+HrO61fTc1rHP+tzCXZRqvhbks03ctzGWZtmthLsG4NLks03QtzGWZnmthLsu0XAtzWabjWpiL+d0ml3XO+v4Fl7C7v18bQvrAhdHvBv/ikj9wYfS7I1wY/e4Il2BcmlwY/e4IF0a/O8KF0e8Gl55c3CcujH53hAuj3x3gss653sJcKP3uABdKvzvAhdLvDnAJxqXJhdLvDnCh9LsDXMzvtrmY321zMb/b4hLXOcNbmIv53TYX87ttLuZ321yCcWlyMb/b5mJ+t83F/G6bi/ndNhfzu00u65zXLczF/G6bi/ndNhfzu20uwbg0uZjfbXMxv9vmYn63zcX8bpuL+d0mF80nst/Kxfxum4v53TYXxf4lxefjgTnVrcflFz/Z7/n4VvGD0evVW268+qHkeUipi++nVGyh8ep44IjljYbb3pgr9kbLMlfsu5ZlrtjTLctcsV9clfmu2ItCMk/b88Xp3bd8Ya7Y54Iy3w/m5QNzxR56WeaK70cvyzwY88uZWw69nrnl0OuZWw4V9uf1OUes9QNzy6HXM7ccejnzYDn0euaWQ69nbjn0euaWQ69nHoz55cwth17P3HLo9cwth17P3HLo9cwth17OPFoOvZ655dDrmVsOvZ655dDrmQdjfjlzy6HXM7ccej1zy6HXM7ccej1zy6GXM0+WQ69nbjn0euaWQ69nbjn0eubBmF/O3HLo9cwth17P3HLo9cwth17P3HLo5cw1n629LHPLodcztxx6PXPz513mu/dP5nuNPeb97/trPpt6Webmz69nbv78eubmzy9nrvkscEjmA9+D1nzO+LLMzZ9fz9z+TnQ982DML2duOfR65pZDhb1i/36L5vPol2VuOfR65pZDL2deLYdez9xy6PXMLYdez9xy6PXMgzG/nLnl0OuZWw69nrnl0OuZWw69nrnl0KuZp81y6PXMLYdez9xy6PXMLYdezzwY88uZWw69nrnl0OuZWw69nrnl0OuZWw69nLmzHHo9c8uh1zO3HHo9c8uh1zMPxvxy5pZDr2duOfR65pZDr2duOfR65pZDL2fuLYdez9xy6PXMAyNzlw7m3tcO8/63yZOndNziFCk9tDhFSlcsTpHS54pTpHSuv6L4+Gvq8ye73Ka4U3rRX1LsfXM67ZTuUpwi5d8txClS/iVCnGIwigIULbtIULTs0vWL/bsRu2UXCYqWXSQoWnYRoBgsu0hQtOwiQdGyiwRFyy4SFINRFKBo2UWComUXCYqWXSQoWnaRoGjZRYBitOwiQdGyiwRFyy4SFC27SFAMRlGAomUXCYqWXSQoWnaRoGjZRYKiZRcBismyiwRFyy4SFC27SFC07CJBMRhFAYqWXSQoWnaRoGjZRYKiZRcJipZdBChmyy4SFC27SFAMjBQ39/zJfsuhR7H/PcBM6RfFKVL6RXGKlH5RnCKlXxSnSOkXf0Vx4PvRhdIv/pJi9xtshdIvilOkvNctTpHyXrc4xWAUBShadpGgaNml6xf7dyOKZRcJipZdJChadhGgWC27SFC07CJB0bKLBEXLLhIUg1EUoGjZRYKiZRcJipZdJChadpGgaNnlPMXMeWa8OEXLLhIULbtIULTsIkExGEUBipZdJChadpGgaNlFgqJlFwmKll0EKHKeMy5O0bKLBEXLLhIULbtIUAxGUYCiZRcJipZdJChadpGgaNlFgqJlFwGKnGdTi1O07CJBMRBSdCVvf7/Y1d33KHa/B5gpz4+Wp8joF+UpMvpFeYqMflGeIqNf/B3F/vejM+X50b+l2PsGW6Y8P1qeIuO9bnmKjPe65SkGoyhA0bKLBEXLLl2/2L8bQXl+tDxFyy4SFC27CFCkPD9anqJlFwmKll0kKFp2kaAYjKIARcsuEhQtu0hQtOwiQdGyiwRFyy4CFCnPj5anaNlFgqJlFwmKll0kKAajKEDRsosERcsuEhQtu0hQtOwiQdGyiwBFyvOj5SladpGgaNlFgqJlFwmKwSgKULTsIkHRsosERcsuEhQtu0hQtOwiQJHy/Gh5ipZdJCgGRorZHRTz+3f7/vR7gJTnR8tTpPSL4hQp/aI4RUq/KE6R0i/+iuLAd68oz4+Wp0jpF8UpUt7rFqdIea9bnGIwigIULbt0nU4/R1OeHy1P0bKLBEXLLhIULbsIUKQ8P1qeomUXCYqWXSQoWnaRoBiMogBFyy4SFC27SFC07CJB0bKLBEXLLucpFsrzo+UpWnaRoGjZRYKiZRcJisEoClC07CJB0bKLBEXLLhIULbtIULTsIkCR8vxoeYqWXSQoWnaRoGjZRYJiMIoCFC27SFC07CJB0bKLBEXLLhIULbsIUKQ8P1qe4jJ+MWzHT947P3mvz+fd9/p1iheXYFyaXJbxdMJclnFpwlyW8V3CXJZxUsJclvFGslzWOf1YmMsy916FuSxzN1WYi/ndNpdAyCXszx8cQvrAhdHvBv/ikj9wYfS7I1wY/e4IF0a/O8KF0e8OcFnnxFxhLox+N7j05OI+cWH0uyNcGP3uCJdgXJpcKP3uABdKvzvAhdLvDnCh9LsDXCj9bp/LOqesCnMxv9vmYn63zcX8bptLMC5NLuZ321zM77a5mN9tczG/2+ZifrfJZZ2TOYW5mN9tczG/2+ZifrfNJRiXJhfzu20u5nfbXMzvtrmY321zMb/b5LLOaY7CXMzvtrmY321zMb/b5hKMS5OL+d02F/O7bS6K/UuIz8f4c6ilw2XgmX/NJwaKa1XsM8S1KvYO4loV+wFxrYFIq+K9La5V8S4W16r4fpK4VsX3iMS1EvkmzaeV/UrrwPcfNZ8p9jut/e/WaD75S1zrKr5pRGsg0rqKbxrRuopvGtG6im8auAej+XQnca2r+Ka+1qr5pCRxrcv4pgGty/imAa3L+KYBrYFI6zK+aUDrMr5pQCuPb6qaT5YR10rkmzSf0iKulcg3aT7xRFwrkW/SfHqIuFYi36T5JA5xrUS+SfOpFuJaiXyT5hMixLUS+SZP5Js0n88hrjUQaSXyTZrPxhDXSuSbNJ9hIa6VyDdpPmtCXCuRb9J8JoS4VsX7dc/H91seSjpa+88jVs1d/OJaFe9Xca2K96u4VsX7VVqr5m57ca2K96u4VsX7VVyr4vsS4loDkVYi36S50/1XWvvf46iae9p/p7X7rHTV3L0urnUV3zSgVXNHurjWVXzTiNZVfNOI1lV808A9GM2d4+JaV/FNI1qX8U0DWpfxTQNal/FNA1qX8U19rZq7tsW1LuObBrQu45sGtBL5Js3d1eJaiXyT5o5pca1EvklzF7S4ViLfpLmzWVwrkW/S3K0srpXIN2nuQBbXSuSbNHcVi2sl8k2ZyDdp7pWW1qq5V1pcK5Fv0twrLa6VyDdp7pUW10rkmzT3SotrJfJNmnulpbVq7h/2/vjOis+5o3XgeUTN/cPiWhXvV3GtiveruFbF+1Vcq+L9Kq5V8X4V16p4v4prVXxfQlZr2DT3D4trpfFND62r+Kbu9zgeWlfxTd1npR9aA5HWVXzTiNZVfNOI1lV804jWVXzTiNZVfFP3HkzYNPcPi2tdxTeNaF3GNw1oXcY3DWgNRFqX8U0DWpfxTQNal/FNA1qX8U0DWol8k+b+YXGtRL5Jc/+wuFYi36S5f1hcK5Fv0tw/LK6VyDdp7h8W10rkmzT3D4trJfJNmvuHxbUS+aY9EGkl8k2ae6XFtRL5Js290uJaiXyT5l5pca1Evklzr7S4ViLfpLlXWlyr4v3qfH1qdXXraB14HlFz/7C4VsX7VVqr5v5hca2K96u4VsX7VVyr4v0qrlXxfhXXqvi+hLhWxfclxLUS+SbN/cO/0jrwPQ7N/cO/09p/Vlpz/7C41lV804jWVXzTiNZVfNOI1kCkdRXfNHAPRnP/sLjWVXzTiNZlfNOA1mV8U1+r5v5hca3L+KYBrcv4pgGty/imAa2BSCuRb9LcPyyulcg3ae4fFtdK5Js09w+LayXyTZr7h8W1Evkmzf3D4lqJfJPm/mFxrUS+SXP/sLhWIt9UiXyT5l5pca1Evklzr7S41kCklcg3ae6VFtdK5Js090qLa+XxTU5zr7S4VsX7dfP5qfXh2zta+88juk3xfhXXqni/imtVvF/FtSrer+JaFe9Xca2K96u0Vs39w+JaFd+XENeq+L6EuFYi36S5f/hXWvvf43Ca+4d/p7X7rLTT3D8srnUV3zSidRXfNKJ1Fd80oFVz/7C41lV808A9GM39w+JaV/FNI1oDkdZlfNOA1mV804DWZXzTgNZlfNOA1mV8U1+r5v5hca1Evklz/7C4ViLfpLl/WFwrkW/S3D8srpXIN2nuHxbXSuSbNPcPi2sl8k2a+4fFtRL5Js39w+JaiXxTIPJNmnulxbUS+SbNvdLSWjX3SotrJfJNmnulxbUS+SbNvdLiWol8k+ZeaXGtevdrKvH5iGGqJXW0luOgkuI/PI+ouH9YXqve/SqvVe9+ldeqd7/Ka9W7X3+pNT6fWytl6/3ksB1T7L3Xfpz4xVDv3sZhqNcP4DDUe38Gh6He+z44DJfxu/cxVNxHjcNwGX9+I8NlfP+NDJfJEzcyDMbwNEPLKecZWk45z9ByynmGllPOM7Sccpqh4v53HIaWU84ztJxynqHllPMMgzE8zdByynmGllPOM7Sccp6h5ZTzDC2nnGaouJdfB8OBrjnFff84DG0v//zagecpFffY4zC0vXyeoe3lswy94j5/HIZ2//A8Q/OHHYbp+aWIUPYPDM0fnmcYjOFphnb/8DxDyynnGVpOOc/Qcsp5hpZTTjNUfC4KDkPLKecZWk45z9ByynmGwRieZmg5pc3FskebC2We+MUUft/yoc+9TRH8G0XKRCFOkTJTSFNUfGoQEkXKXCFOkTJZiFOkzBbiFINR7FAM7tAXtw8UKfOFOEXKNCJO0bKLBEXLLhIULbsIUFR8chcSRcsuPYp5P/QV/4GiZRcJipZdJCgGoyhA0bKLBEXLLhIULbtIULTs8huK9QNFyy4CFBWfnodEcZnsEp7fDynhw/dDFJ/LJ691mRwwoDUQaV3GUw9oXcb5Dmhdxp8OaF3GRQ5oXcbr9bUqPpdPXiuRb1J8Lp+8ViLfpPhcPnmtRL5J8bl88lqJfFMk8k3rnLfY17rOeYsDWol80zrnLQ5oJfJN65y3OKCVyDetc37hgFYi37TOeYADWol80zrn6w1oJfJN65xXN6CVyDetc/7bgFYi37TOeWoDWol80zrnkw1oJfJN65z3NaCVyDetc37WgFYi37TOeVQDWol80zrnOw1oJfJN65yXNKCVyDdVIt9UiXzTOudKDWgl8k01EGkl8k3rnL81oJXIN61zntWAVh7ftK9zPtSAVh7ftK9z3tKAVh7ftG+BSCuPb9rXOQ9oQCuPb9rXOV9nQCuRb1rnvJoBrUS+aZ3zXwa0Evmmdc5TGdBK5JvWOctkQCuRb1rnFJEBrUS+aZ0TOQa0EvmmdU63GNBK5JvWOSliQCuRb1rn1IUBrUS+aZ0TDAa0EvmmdU4DGNBK5JvWadYf0Erkm9ZpqR/QSuSb1ml8H9BK2YX9izOo9/ocYq+hzZCzCVuYIeUZPsIMKU/wEWZIeX6PMMNgDE8zpDy7R5gh5ck9wgwpz+0RZkh5ao8wQ8sppxmu0w8/ieHjz/R/vzaE9IGh5ZQOQ/9i+OGewzp99jcytJxynmEwhqcZWk45z9ByynmGllM6DN3zbwHBfWJoOeU8Q8sppxmucx7DjQwtp5xnaDnlPEPLKecZBmN4mqHllPMMLaecZ2g55TxDyynnGVpOOc1wnfNPbmRoOeU8Q8sp5xlaTjnPMBjD0wwtp5xnaDnlPEPLKecZWk45z9ByymmG65w3dCNDyynnGVpOOc/Qcsp5hsEYnmZoOeU8Q8sp5xlaTjnP0HLKeYaWU04zXOd8rxsZWk45z9ByynmGiv1hPh4nT8XvPYb+Cbz4D9+r03welrhWxX5LXKtiXySuVbF/EdYaNJ+H9Tutsz7fU35+vpf9A0PFPgOGoWKfAcNQ8f1QGIbBGJ5muIzfvZHhMj76RobL+PMbGS7j+29kuEyeuI+h5vPnYBhaTjnP0HLKeYaWU84zDMbwNEPLKecZWk45z9ByynmGllPOM7Sccpqh5vMeYRhaTjnPMBjDH1/b7wgOms9HhGFoe7lzLXefHwqaz/1DYaj5PEEYhraXzzO0+4fnGdr9w/MMgzE867E1nwMJw9DuH55naPcPzzO0nHKeoeWU0ww1n58Kw9ByynmGllPOM7Sccp5hMIanGVpOOc/Qcsp5hpZT2lwse7S5UOaJX0zhtvz8A5zbin/T518UNZ90CkSRMlOIU6RMFeIUKXOFOMVgFAUoUmYLcYqU6eI3FN32ZOGcCx8oUuYLcYqUaUScomUXAYqaTz8FomjZRYKiZRcJipZdfkHRuw8Ug1EUoGjZRYLiMtklPJ+aLOHDU5OaTywV17pMDhjQuoxb72vVfFKnuNZlnO+A1mX86YDWZVzkgNZApHUZRzaglcg3aT5BUVwrkW/SfCKhtFbNJweKayXyTZpP4hPXSuSbNJ9sJ66VyDdpPilOXCuRb9J88pq4ViLfpPkkM3GtRL5J88lg4lqJfFMNRFqJfNM6J7MNaCXyTeuczDaglcc3xXVOZhvQyuOb4jonnQ1o5fFNcQtEWnl8U1znJK4BrTy+Ka5zstWAViLftM5JUQNaiXzTOicvDWgl8k3rnGQ0oJXIN61zMtCAViLftM5JOwNaiXzTOifXDGgl8k2eyDd5It+0zgk/A1qJfJMn8k2eyDetcxLSgFYi37TOyUIDWol8k52Q0nlt//S3aCekCDC05uHzDK15+DxDayk+z9BOSDnN0E5IEWBoJ6ScZ2gnpJxnaCeknGcYjOFphpZTfn5t2J8/N4T0gaHllA5D/2L44Z6DnZAiwNByynmGllNOM+Q8d0WYoeWU8wwtp3QYdk9Lj5wnrggzDMbwNEPLKecZWk45z9ByynmGllPOM7Sccpoh5xkrwgwtp5xnaDnlPEPLKecZBmN4mqHllPMMLaecZ2g55TxDyynnGVpOOc1wnXNrbmRoOeU8Q8sp5xlaTjnPMBjD0wwtp5xnaDnlPEPLKecZWk45z9ByymmG65wTdSNDyynnGVpOOc/Qcsp5hsEYnmZoOeU8Q8sp5xlaTjnNUPN5WHH3x4vr1mPon9+rK/7D9+o0n4clrlWx3xLXqtgXiWsNRFoV+4zfaZ30+T7QG6X5nC0Yhop9BgxDxfdDYRgqvh8KwjBpPscMhuEyPvpGhsv48xsZLuP7b2QYjOFphpZTzjO0nHKeoeWU8wwtp5xnaDnlNEPN5wbCMLSccp6h5ZTzDC2nnGcYjOFphpZTzjO0nHKeoeWU8wwtp5xnaDnlNEPN53TCMLSccp6h5ZTzDC2nnGcYjOFphuYPf35t/wyJpPl8TxSGms+XVMGw/3x52m0vn2doe/k8Q9vL5xna/cPzDO3+4XmG5g87DFN+Miz7B4bmD88ztPuHpxlqPj8VhqHllPMMLaecZ2g55TzDYAxPM7Sccp6h5ZTzDC2nnGdoOeU8Q8sppxlqPj/1BoYvLpY92lwo88QvpnjoeE7hQnVv+t4pUiYKcYrBKApQpEwV4hQpc4U4RcpkIU6RMluIU6RMF7+ieDxq9Hhj36ao+dxTIIqUaUScomUXCYqWXSQoBqMoQNGyiwRFyy4dijG+KKZPFC27SFC07CJB0bKLAEXNZ6ECUbTsIkHRsosERcsuPYopHBTz/oFiMIoCFC27SFC07CJB0bKLBEXLLhIULbsIUNR8PurvKPZ7FTSfYyqudZkcMKB1Gbc+oDUQaV3G+Q5oXcafDmhdxkUOaF3G6w1oXcaR9bWuc27ogFYi37TOuaEDWol80zrnhg5oJfJN65zvOaCVyDetc17mgFYe35TXOX9yQCuPb8rrnOc4oJXHN+UtEGnl8U15nfMGB7Ty+Ka8zvl9A1qJfNM65+ENaCXyTeucLzeglcg3rXNe24BWIt+0zvlnA1qJfNM654kNaCXyTeuczzWglcg3rXPe1YBWIt+0zvlRA1qJfJMn8k3rnN81oJXIN3ki37QT+aZ1zjkb0Erkm9Y5N2xAayDSSuSb1jkva0ArkW9a5/ypAa1Evmmd85wGtBL5pnXORxrQSuSb1jlvaEArkW9a5/yeAa1Evmmd83AGtBL5pnXOlxnQSuSb1jkHZkArkW9a50yVAa1Evmmd80kGtBL5pnXO+hjQSuSb1jk3Y0ArkW9a5wyKAa1Evmmd8xwGtBL5pnXORhjQSuSb1jlnYEArkW9ap7N/QCuRb1qn/35AK5FvWqdLfkArkW9ap5d9QCuRb1qn43xAK5FvIuoLz0R94ZmoLzwT9YVnor7wTNQXnon6wjNRX3gm6gvPRH3hmagvPBP1hWeivvBM1BeeifrCM1FfeCbqC89EfeGZqC88E/WFF6K+8ELUF16I+sILUV942QKRVh7fVNbplf7NaathO37w3nntXp/Hyu81fGBIeWKtLMN1erBvZLiMz7iR4TL+5UaGy/iiGxkGY3ia4TI+7kaGy9xXu5HhMvfrbmRoOeU8Q8spP7827M+fG0JqM1ynd34WQ/9i+OGewzp99jcytJxynqHllPMMgzE8zdByynmGllM6DN3zbwHBfWJoOeU8Q8sp5xlaTjnNcJ1zHm5kaDnlPEPLKecZWk45zzAYw9MMLaecZ2g55TxDyynnGVpOOc/Qcspphuucq3IjQ8sp5xlaTjnP0HLKeYbBGJ5maDnlPEPLKecZWk45z9ByynmGllNOM1znHKMbGVpOOc/Qcsp5hpZTzjMMxvA0Q8sp5xlaTjnP0HLKeYaWU84ztJxymuE654bdyNByynmGQS/DvTy/Kpcef8TtMfTPFxf/4Xt1ms/DEteq2G+Ja1Xsi8S1KvYv4loV+4zfaZ31+Z7y8/O97G2Gms/ZgmGo2GfAMFR8PxSGoeL7oTAMgzE8zXAZH30jw2X8+Y0Ml/H9NzJcJk/cyNByymmGms+1g2FoOeU8Q8sp5xlaTjnPMBjD0wwtp5xnaDnlPEPLKecZWk45z9ByymmGms+RhGFo/vDn1w50BGs+HxGGoe3lzrXcf35I87l/MAxtL59lWDWfUwjD0O4fnmdo9w/PMzR/eNZj1y0Yw9MM7f7heYZ2//A8Q8sp5xlaTjnP0HLKaYaaz0+FYWg55TxDyynnGVpOOc8wGMPTDC2nnGdoOaXNxbJHmwtlnvjFFG7LzyncVvybPv9GkTJRSFPUfNYpEEXKVCFOkTJXiFOkTBbiFINRFKBImS5+Q9FtTxbOufCBImW+EKdImUbEKVp2kaBo2UWAoubzT4EoWnaRoGjZ5RcUvftA0bKLBMVgFAUoLpNdwvOpyRI+PDWp+cRSca3L5IABrcu49QGty3jqvlbNJ2qKa13Gnw5oXcZFDmhdxusNaA1EWol8k+YTFMW1EvkmzScSimsl8k2aT/gT10rkmzSfmCeulcg3aT6BTlwrkW/SfKKbuFYi36T5hDRxrUS+SfOJY+JaiXxTIvJNicg3rXMy24BWIt+0zslsA1qJfNM6J7MNaCXyTeucoDaglcg3rXMi2YBWIt+0zglfA1qJfNM6J2YNaCXyTeucQDWglcg3rXOi04BWIt+0zglJA1qJfNM6Jw4NaCXyTeuc4DOglcg3rXMizoBWIt+0zgkzA1qJfFMl8k3rnPAzoDUQaSXyTZXIN61zEtKAViLftM7JQj2tcVvnBKABrdY8/PNru6e/PRgus7dvZGjNw+cZWvPweYbWUnyeoZ2Qcp6hnZBymqGdkCLA0E5IOc/QTkg5z9ByynmGwRj++NqwP39uCOkDQ8spHYb+xfDDPQc7IUWAoeWU8wwtp5xnaDnlNEPOU1eEGVpO6TDsnZb+YGg55TxDyynnGQZjeJqh5ZTzDC2nnGdoOeU8Q8sp5xlaTjnNkPOEFWGGllPOM7Sccp6h5ZTzDIMxPM3Qcsp5hpZTzjO0nHKeoeWU8wwtp5xmuM55ODcytJxynqHllPMMLaecZxiM4WmGllPOM7Sccp6h5ZTzDC2nnGdoOeU0w3XOn7qRoeWU8wwtp5xnaDnlPMNgDE8ztJxynqHllPMMFftDn57jp91tHYYD36vTfB6WuFbFfktcq2JfJK5VsX8R1xqItCr2A+JaFe9tca2K7wOKa1V8v05cK5Fv0nwe1q+0DvQGaD4P63da+9/F1HwelrjWVXzTiNZApHUV3zSidRXfNKJ1Fd80cA9G83lY4lpX8U0DWjWfhyWudRnfNKB1Gd80oHUZ3zSgNRBpXcY3DWhdxjcNaCXyTZrPwxLXSuSbNJ+HJa6VyDdpPg9LXCuRb9J8Hpa4ViLfpPk8LHGtRL5J83lY4lp5fJPTfB6WuFYe3+Q2Ht/kNJ9zJq41EGnl8U1O8/le4lp5fJPTfF6WuFYi36T5/ClxrUS+SfN5TuJaFe9Xd0yRXK0drbJnKTnNZ9jcykXx3r6Vi+IdfysXxX7gTi6az4S5lYtin3ErF8We5FYuiu/73MolGJcmF/O7bS6Mfrf/vR6n+XyTeVy6z9k7zWeW3MqF0e8OcNF8tsitXBj97ggXRr87woXR7w7cx9R8VsetXBj97ggXSr87wIXS7w5wofS7A1wo/W6fi+YzKm7lQul3B7hQ+t0BLuZ321yCcWlyMb/b5mJ+t83F/G6bi/ndNhfzu00ums86uJWL+d02F/O7bS7md9tcgnFpcjG/2+ZifrfNxfxum4v53TYX87tNLprPhLiVi/ndNhfzu20u5nfbXIJxaXIxv9vmYn63zcX8bpuL+d0ml6vPcZB9iv/qkxmEp9+hpw/Q00fo6RP09Bl6+gI9fUWe/uqTAoSnh961Re+uHfheW9G7awe+BXF1477w9Hp37cj0enftyPR6d+3I9Hp37cj0enftQDKsenftyPR6d+3I9Ip37cD0inftwPSKd+3A9Ip37cD0inftwPSKd+3A9Ip37cD0yLvWb8i71m/Iu9ZvyLvWb8i71m/Iu9ZvyLvWb8i71m/Iu9ZvyLvWb9C71kHvWge9ax30rnXQu9ZB71oHvWsd9K510LvWQe9aB71rPfSu9dC71kPvWg+9a69uIxae/vzn/fYc6IEiCk7ff07BCzS13jl9RZ5eoPX0zukd9PQeevodevoAPX2Enj5BTw+9a3e9u7b/TKDf9e7a/tNFPujdtSPT6921I9Pr3bUj0+vdtSPT6921I9Pr3bUDyTDo3bUj0+vdtSPTK961A9Mr3rX96aPiXTswveJdOzC94l07ML3iXTswveJdOzA99K6N0Ls2Qu/aCL1rI/SuTdC7NkHv2gS9axP0rhVoQLpzeuhdm6B3bYLetQl61yboXZuhd22G3rUZetdm6F0r0F105/TQuzZD79oMvWsz9K7N0Lu2QO/a8/05zj/fxLvsBKcfeE7hfH/OrdNH6OkT9PQZevoCPX1Fnv58f86t0zvo6T309NC79nx/zrTpB54JrHp37cDTRVXvrh2ZXu+uHZle764dmV7vru1Pv296d+3I9Hp3bT8Z7pveXTsyvd5dOzK94l07ML3iXTswveJdOzC94l07ML3iXTswveJd25/eKd61A9ND71oHvWsd9K49359z6/TQu9ZB71oHvWsd9K510LvWQ+9aD71rPfSu9dC79nx/zq3TQ+9aD71rPfSu9dC71kPv2h161+7Qu3aH3rU79K4931106/TQu3YH3bV7rf/1gz/env+s/muE5+zu+Ff7H/2r8Ef/Kv7Rv0q//Vcx+v/6oU4/b/n5n/L9n5XXP8t/9s/Kn/2z+kf/rH3Lt//P3J/9M/9n/2z/s38W/uyfnf3c+fjS4x3S9Hc47ZW3cLSUbil3Pn1CejINZf/PT5S/BiraBqoTB3q+yfmbPCNv4q54E3/Fm+xXvEm44k3iFW+SrniTfMWblCve5Iorfr/iit+vuOL3K674/Yorfr/iit+vuOKvDhXxuUVTLM0tumdtA+m9zZZ8OV4b2sPrvcvWHz7ovck2MLzee2wDw+u9xTYwvN47bAPDB+Th9d5fGxhe7+21geH1/iVrYHjkDRuQN2xE3rARecNG5A0bkTfs+ZrSO4cH/Yb5X8ODfsH838Mn0L+Z/zU86J/M/xoe9C/mfw2v99NmYHjQv5f/NTzon8v/Gl7xk2ndP4QlxQ+m9YdX/Fxad/is+LG0/vCKN2x/eMUbtj+84g3bH17xhu0Pr3jD9odXvGH7wyNv2Iy8YTPyhi1aNuwxkJateQx08Sb8eM/k+2udy8+f7Fx5K8X08TX+jj1+wB4/Yo+fsMfP2OMX7PFn7sXnm0wtmjze5OKu/e4zPNVrG0hvI37/jxDnSxvvHF5vH/7A8Hrr8AeG19uGPzC83jL8geH1duF3hxeoa7xzeL2nzgwMr/fQmYHhgTesQFXjncMDb1iBosY7hwfesAI1jXcOj7xhHfKGdcgb1iFvWIe8Yc8XNN45PPKGdcgb1iFvWIe8YR3yhvXIG9Yjb1iv93O++8yxQDfgncODHh/51/Cgp0f+e/gd9PDIv4YHPaf5r+FBj2n+a3jQU5r/Gl7v53z3oSKBXro7h1d8RHN/eMUnNPeHV7xh+8Mr3rDd4YPiDdsfXvGG7Q+veMP2h1e8YfvDI2/YgLxhA/KGDVo27DGQlq15DHTxJvzNY4thr3+/2IXoX6+O+zF+3LDHd9jje+zxd+zxA/b4EXv8pHh8t73G37+M//3VNTxvptb4NsXjXQ6pmUdq4ZGqefOXl9S6N6+/pHnzD4yvefMPjK958w+Mr3nzD4wfsMfXvPkHxte8+V/jx821x9e8zQfG17yhB8ZXvHWjz8f4YWuOnxVv3ZHxFW/dkfEVb92R8RVv3ZHxFW/dkfEVb92R8RVv3S/jl/b4irfuyPiKt+7I+Jq3bi7H+LVtGormrTswvuatOzC+5q07ML7mrTswvuatOzC+5q07ML7mrfs+fm2Pr3nrDoyveesOjD9z6z7fpG5XvMn5DZaP07D2fe/9h+hVuOwCnTLCA+3XDiT6PQ2BTpkbh4/Iwyfk4TPy8AV5+Io7fBDolLlxeIc8vEceHnjDhg14w4YNeMOGDXjDhg14w4YNeMOGDXnDOuQN65A3rEPesA55wwp0ytw4PPKGdcgb1iFvWIe8YR3yhvXIG9Yjb1iPvGE98oYVaPO5cXjkDeuRN6xH3rAeecN65A27I2/YHXnD7sgbdkfesAI9SjcOj7xhd+QNuyNv2B15w+7IGzYgb9iAvGED8oYNyBtWoEfpxuGRN2xA3rABecMG5A0bkDdsRN6wEXnDRuQNG5E3rEAr043DI2/YiLxhI/KGjcgbNiJv2IS8YRPyhk3IGzYhb1iB9qMbh0fesAl5wybkDZuQN2xC3rAZecNm5A2bkTdsRt6wAk1HNw6PvGEz8obNyBs2I2/YjLxhC/KGLcgbtiBv2IK8YQVajW4cHnnDFuQNW5A3bEHesAV5w1bkDVuRN2xF3rDInU4BudMpIHc6BeROp4Dc6RSQO50CcqdTRO50isidThG50ykidzrFDXjDRuROp4jc6RSRO50icqdTRO50isidThG50ykidzpF5E6niNzpFJE7nSJyp1NE7nSKyJ1OEbnTKSJ3OkXkTqeI3OkUkTudInKnU0TudIrInU4RudMpInc6ReROp4jc6RSRO50icqdTRO50isidThG50ykidzpF5E6niNzpFJE7nSJyp1NE7nSKyJ1OEbnTKSJ3OkXkTqeI3OkUkTudInKnU0TudIrInU4RudMpInc6ReROp4jc6RSRO50icqdTRO50isidThG50ykidzpF5E6niNzpFJE7nSJyp1NE7nSKyJ1OEbnTKSJ3OkXkTqeI3OkUkTudInKnU0TudIrInU4RudMpInc6ReROp4jc6RSRO50icqdTRO50isidThG50ykidzpF5E6niNzpFJE7nSJyp1NE7nSKyJ1OEbnTKSJ3OkXkTqeI3OkUkTudInKnU0TudIrInU4RudMpIXc6JeROp4Tc6ZSQO53SBrxhE3KnU0LudErInU4JudMpIXc6JeROp4Tc6ZSQO50ScqdTQu50SsidTgm50ykhdzol5E6nhNzplJA7nRJyp1NC7nRKyJ1OCbnTKSF3OiXkTqeE3OmUkDudEnKnU0LudErInU4JudMpIXc6JeROp4Tc6ZSQO50ScqdTQu50SsidTgm50ykhdzol5E6nhNzplJA7nRJyp1NC7nRKyJ1OCbnTKSF3OiXkTqeE3OmUkDudEnKnU0LudErInU4JudMpIXc6JeROp4Tc6ZSQO50ScqdTQu50SsidTgm50ykhdzol5E6nhNzplJA7nRJyp1NC7nRKyJ1OCbnTKSF3OiXkTqeE3OmUkDudEnKnU0LudErInU4JudMpIXc6JeROp4Tc6ZSQO50ScqdTQu50SsidTgm50ykhdzol5E6nhNzplJA7nRJyp1NC7nRKyJ1OCbnTKSF3OiXkTqeE3OmUkTudMnKnU0budMrInU55A96wGbnTKSN3OmXkTqeM3OmUkTudMnKnU0budMrInU4ZudMpI3c6ZeROp4zc6ZSRO50ycqdTRu50ysidThm50ykjdzpl5E6njNzplJE7nTJyp1NG7nTKyJ1OGbnTKSN3OmXkTqeM3OmUkTudMnKnU0budMrInU4ZudMpI3c6ZeROp4zc6ZSRO50ycqdTRu50ysidThm50ykjdzpl5E6njNzplJE7nTJyp1NG7nTKyJ1OGbnTKSN3OmXkTqeM3OmUkTudMnKnU0budMrInU4ZudMpI3c6ZeROp4zc6ZSRO50ycqdTRu50ysidThm50ykjdzpl5E6njNzplJE7nTJyp1NG7nTKyJ1OGbnTKSN3OmXkTqeM3OmUkTudMnKnU0budMrInU4ZudMpI3c6ZeROp4zc6ZSRO50ycqdTRu50ysidThm50ykjdzpl5E6njNzplJE7nTJyp1NG7nQqyJ1OBbnTqSB3OhXkTqeyAW/YgtzpVJA7nQpyp1NB7nQqyJ1OBbnTqSB3OhXkTqeC3OlUkDudCnKnU0HudCrInU4FudOpIHc6FeROp4Lc6VSQO50KcqdTQe50KsidTgW506kgdzoV5E6ngtzpVJA7nQpyp1NB7nQqyJ1OBbnTqSB3OhXkTqeC3OlUkDudCnKnU0HudCrInU4FudOpIHc6FeROp4Lc6VSQO50KcqdTQe50KsidTgW506kgdzoV5E6ngtzpVJA7nQpyp1NB7nQqyJ1OBbnTqSB3OhXkTqeC3OlUkDudCnKnU0HudCrInU4FudOpIHc6FeROp4Lc6VSQO50KcqdTQe50KsidTgW506kgdzoV5E6ngtzpVJA7nQpyp1NB7nQqyJ1OBbnTqSB3OhXkTqeC3OlUkDudCnKnU0HudCrInU4FudOpIHc6FeROp4Lc6VSQO50KcqdTQe50KsidTgW506kgdzpV5E6nitzpVJE7nSpyp1PdgDdsRe50qsidThW506kidzpV5E6nitzpVJE7nSpyp1NF7nSqyJ1OFbnTqSJ3OlXkTqeK3OlUkTudKnKnU0XudKrInU4VudOpInc6VeROp4rc6VSRO50qcqdTRe50qsidThW506kidzpV5E6nitzpVJE7nSpyp1NF7nSqyJ1OFbnTqSJ3OlXkTqeK3OlUkTudKnKnU0XudKrInU4VudOpInc6VeROp4rc6VSRO50qcqdTRe50qsidThW506kidzpV5E6nitzpVJE7nSpyp1NF7nSqyJ1OFbnTqSJ3OlXkTqeK3OlUkTudKnKnU0XudKrInU4VudOpInc6VeROp4rc6VSRO50qcqdTRe50qsidThW506kidzpV5E6nitzpVJE7nSpyp1NF7nSqyJ1OFbnTqSJ3OlXkTqeK3OlUkTudKnKnU0XudKrInU4VudOpInc6VeROp4rc6VSRO53chlzq9JgeeMc+pgdeso/pgbfsY3rgNfuYHnjPPqYHXrSP6YE37WN64FX7mB561yLXOz2mh961yAVPj+mhdy1yxdNjeuhdi1zy9Jgeetci1zw9pofetchFT4/poXctctXTY3roXYtc9vSYHnrXItc9PaaH3rXIhU+P6aF3LXLl02N66F2LXPr0mB561yLXPj2mh961yMVPj+mhdy1y9dNjeuhdi1z+9Jgeetci1z89pofetcgFUI/poXctcgXUY3roXYtcAvWYHnrXItdAPaaH3rXIRVCP6aF3LXIV1GN66F2LXAb1mB561yLXQT2mh961yIVQj+mhdy1yJdRjeuhdi1wK9Zgeetci10I9pofetcjFUI/poXctcjXUY3roXYtcDvWYHnrXItdDPaaH3rXIBVGP6aF3LXJF1GN66F2LXBL1mB561yLXRD2mh961yEVRj+mhdy1yVdRjeuhdi1wW9Zgeetci10U9pofetciFUY/poXctcmXUY3roXYtcGvWYHnrXItdGPaZH3rUOujfKQfdGOejeKAfdG+U25F3roHujHHRvlIPujXLQvVEOujfKQfdGOejeKAfdG+Wge6McdG+Ug+6NctC9UQ66N8pB90Y56N4oB90b5aB7oxx0b5SD7o1y0L1RDro3ykH3Rjno3igH3RvloHujHHRvlIPujXLQvVEOujfKQfdGOejeKAfdG+Wge6McdG+Ug+6NctC9UQ66N8pB90Y56N4oB90b5aB7oxx0b5SD7o1y0L1RDro3ykH3Rjno3igH3RvloHujHHRvlIPujXLQvVEOujfKQfdGOejeKAfdG+Wge6McdG+Ug+6NctC9UQ66N8pB90Y56N4oB90b5aB7oxx0b5SD7o1y0L1RDro3ykH3Rjno3igH3RvloHujHHRvlIPujXLQvVEOujfKQfdGOejeKAfdG+Wge6McdG+Ug+6NctC9UQ66N8pB90Y56N4oB90b5aB7oxx0b5SD7o1y0L1RDro3ykH3Rjno3igP3RvloXujPHRvlIfujfIb8q710L1RHro3ykP3Rnno3igP3RvloXujPHRvlIfujfLQvVEeujfKQ/dGeejeKA/dG+Whe6M8dG+Uh+6N8tC9UR66N8pD90Z56N4oD90b5aF7ozx0b5SH7o3y0L1RHro3ykP3Rnno3igP3RvlFXcX7XX/+7V7/TS93s/7gekV9+cEl/5+bXD5w/R6P3NGptf7mTMyvd7PnJHpA/T0ev39yPR6P+9Dys/py/5her2f9yPT6/X3I9Pr9fcD0yvuzxmZXvGuHZhe8a4dmF7xrh2YXvGuHZhe8a4dmB561yruzxmZHnrXqunPOSZS04nzmujinfjxXsr319ZjiFrih+k99PS72unTlp8hKG21vl4dtz+7Fq9uxblVa4TU+po/gc+fwecv4PNX7PmvbtMRn1/vTh+bX+9WH5sfc6+/5sfc1a/5wfdvBt+/GXz/ZvD9m8H3bwHfvwV8/xbF+9cdUyTXzWopPrNaiqWd1YriXS2uVfFe/51W2ad3imK/cCsXxT7kVi6K/c2tXBT7plu5KPZjd3Kpin3erVwU+8dbuSzjS4W5LONhhbkE49LkYn63zcX8bpuL+d02F/O7bS7md1tc9s38bpuL+d02F/O7bS7md9tcgnFpcjG/2+ZifrfNxfxum4v53TYX87tNLs78bpuL+d02F/O7bS7md9tcgnFpcjG/2+ZifrfNxfxum4v53TYX87tNLt78bpuL+d02F/O7bS7md9tcgnFpcjG/2+ZifrfNxfxum4v53SaXndG/9Js3953Rv4xwYdxH/dbEfWfcRyNcGPfRCBfGfTTChfH+ywCXwHj/ZYQLo3/p9zTtgdG/jHBhvP8ywiUYlyYXSr87wIXS7w5wofS7A1zW97svret72ENrXMaX/uIn+5KeN0p8yentJ5c3Mss4U3Eyy3hTcTLLuFNxMsHIfCCzjEMVJ7OMRxUns4xL/Q2ZGvxz5hrjBzLL+FRxMsu4WmkyidIDD5Gh9MBDZCg98BAZSg88RCYQktk393zxvu3uAxlGDzxGhtEDj5Fh9MBjZBg98BgZRg88REbzuSI3k2H0wPtWnzPvbssfyDB64DEyjB54jEwwMh/IcHrgETKcHniEDKcHHiHD6YFTfJEpX8h8f3UNzz80fLlj8XiXF0VOvyxMUfOZQUAUKX24Ox7h2V3c259165yJJE6G0ocPkQlG5gMZSh8+RIbShw+RofThQ2Qoffg7mfThvuI6Jy9Jk1nn7CVxMpweuLonGb+FD2Q4PfAIGU4PPEImGJkPZDg98AgZTg88QobTA4+Q4fTAb2Sc/0CG0wP3yYR1zmMSJ0PpgX080oFP+wcylB54iAylBx4iE4zMBzKUHniIDKUHHiJD6YGHyFB64Hcy2X0gQ+mBR8isc0aTOBlKD7y753es9gelD2QoPfAQGUoPPEQmGJkPZCg98BAZSg88RIbSAw+RofTA72T2D/f01jm1SZrMOuc2iZPB9MCv+TGd6mt+xX7S++dPTn7Pnd9M758j+9BuqQ6aTzcS16rY84lrVezixLUq9mXiWhU7LXGtir3T77TGZwuxz+222rArdkPiWhX7G3Gtir2QuNZlfNOA1kCkdRnfNKBVs28qR3bxJbWzi+ZTrYbm1+xv0vPQn7S7rfO7VsLzxeWTv9F8opS0Vs2nRIlr1exvpLVq9jfSWjX7G2mtgUirZn8jrVWzv5HWqtkLSWsl8k2aTzGS1qr5FCNxrUS+SfNJQ+JaiXyT5tOAxLUS+SbNJ/aIayXyTZpP1RHXSuSbNJ98I66VyDdpPp1GXCuRb9J8goy4ViLfpPmUF3Gtq+zXvT47a/ca2lo1n6ohrnWVz+Hgni8O7sPvsOZTDMS1rvI5PKJ1lc/hEa2r5NcRravk1xGtq+zXkJ7PIYXy4Tkkzc364lpXya8jWlfJryNal/FNA1oDkdZlfNOAVkzf9Jof0wu95sf0N6/5MT3LMb/mxvJ9P5793oPA9400d5CLa1XsQ8S1KvYh4loDkVbFPkRcq2If8jut/e/gaO7bFteq2N+Ia1XshYS1Rs0t1+Jal/FNA1qX8U0DWpfxTQNaA4bWGJo5LWrudB6aH8TffJxfsWcJr/nDl9Ps3udX7EOG5tfsLcp+zF/2zmeVc9tzZuf8W0tu8C+1mvuDJ6jV7C/k1Wp2GPJqNXsMebWBSq1mTyKvVrODkVer+R6NvFrNd2nk1VJ5Kc09tBPUUnkpzU20E9RSeSnNzbUT1FJ5Kc3ttRPUUnkpzQ22E9RSeSnNLbYT1FJ5Kc1NthPUUnkpzW22E9RSeSnNjbYT1FJ5Kc1tuRPUUnkpzY25E9RSeSnNrbkT1FJ5Kc3NuRPUUnkpze25E9RSeSnNDboT1FJ5Kc0tuhPUUnkpzU26E9RSeSnNbboT1FJ5Kc2NuhPUUnkpza26E9RSeSnNzboT1FJ5Kc3tuhPUUnkpzQ27E9RSeSnNLbsT1FJ5qUTlpTR3KMur1dyiPEEtlZfKVF5Kc0f2BLWBSi2Vl9LclD1BLZWX0tyWPUEtlZfS3Jg9QS2Vl9Lcmj1BLZWX0tycPUEtlZfS3J49QS2Vl9LczD1BLZWXUt36La+Wykupbv6WV0vlpVS3f8urpfJSqhvA5dVSeSnVLeDyapm8VFLdBC6vlslLJdVt4PJqmbxU2gKVWiYvlVS3jcurZfJSSXOT+QS1VF6Kqvc8UfWeJ6re80TVe56oes8TVe95ouo9T1S954mq9zxR9Z4nqt7zRNV7nqh6zxNV73mi6j1PVL3niar3PFH1nieq3vNE1XueqHrPE1XveaLqPU9UveeJqvc8UfWeJ6re80TVe56oes8TVe95ouo9T1S954mq9zxR9Z4nqt7zRNV7nqh6zxNV73mi6j1PVL3niar3PFH1nieq3vNE1XueqHrPE1XveaLqPU9UveeJqvc8UfWeJ6re80TVe56oes8TVe95ouo9T1S954mq9zxR9Z4nqt7zRNV7nqh6zxNV73mi6j1PVL3niar3PFH1nieq3vNE1XueqHrPE1XveaLqPU9UveeJqvc8UfWeJ6re80TVe56oes8TVe95ouo9T1S954mq9zxR9Z4nqt7zRNV7nqh6zxNV73mi6j1PVL3niar3PFH1nmeq3vNM1XueqXrPM1Xved4ClVomL5Wpes8zVe95puo9z1S955mq9zxT9Z5nqt7zTNV7nql6zzNV73mm6j3PVL3nmar3PFP1nmeq3vNM1XueqXrPM1XveabqPc9UveeZqvc8U/WeZ6re80zVe56pes8zVe95puo9z1S955mq9zxT9Z5nqt7zTNV7nql6zzNV73mm6j3PVL3nmar3PFP1nmeq3vNM1XueqXrPM1XveabqPc9UveeZqvc8U/WeZ6re80zVe56pes8zVe95puo9z1S955mq9zxT9Z5nqt7zTNV7nql6zzNV73mm6j3PVL3nmar3PFP1nmeq3vNM1XueqXrPM1XveabqPc9UveeZqvc8U/WeZ6re80zVe56pes8zVe95XqYtuvjni4v/+pNfWlfZPyNaV/mEKiE9Rw75g9ZVPp9GtK7y6TSgdZke4RGtq6S8Ea2YGe81P+bOfM2veA/G3R8vrlvP4URfnw4n5refHd5/2xTnsAlqFeewCWoVu5wJahX7nAlqFTsdcbVFc8/vBLWK3c4EtYr9zgS1it3RBLWBSi2Tlyqae34nqGXyUkVzz+8EtVReSnPP7wS1VF5Kc8/vBLVUXkpzz+8EtVReSnPP7wS1VF5Kc8/vBLVUXkpzz+8EtVReSnPP7wS1VF5Kczvqr9T2n3UpmrtRpbVqbs/8ndbucwJFc3emuNZVPp1GtAYiraukvBGtmBnvNT/mznzNr3gPZu+eL35suc7vWkj57xd/eYbpy++a4hQmrVVzp6W4VsX+RlyrYn8jrlWxvxHXGoi0KvY34loV+xtxrYq9kLhWIt+kucFSWqvm/kpxrUS+SXN3pbhWIt+kubdSXCuRb9LcWSmulcg3ae6rFNdK5Js0d1WKayXyTZp7KsW1EvkmzR2V4lqJfJPmfkpxrUS+SXM3pbhWIt+kuZdSXCuRb9LcSSmulcg3ae6jFNdK5Js0d1GKayXyTZp7KMW1EvmmQuSbCpFvKkS+SXOPqrjWQKSVyDcVIt+kuR9XXCuRb9LcjyutVXM/rrhWIt+kuR9XXCuRb9Lcuyuulcg3ae7cFddK5Js09+2Ka+XxTVVz1664Vh7fVDX37Ipr5fFNdQtEWnl8U9Xcryuulcc3Vc3duuJaiXyT5l5dca1Evklzp664ViLfpLlPV1wrkW/S3KUrrpXIN2nu0RXXSuSbNHfoimsl8k2a+3PFtRL5Jh+ItBL5Jk/kmzT3P4trJfJNnsg37US+SXOvt7hWIt+kuddbXGsg0krkmzT3eotrJfJNRH3hlagvvBL1hVeivvBK1BdeifrCK1FfeCXqC69EfeGVqC+8EvWFV6K+8ErUF16J+sIrUV94JeoLr0R94ZWoL7wS9YVXor7wStQXXon6witRX3gl6guvRH3hlagvvBL1hVeivvBK1BdeifrCK1FfeCXqC69EfeGVqC+8EvWFV6K+8ErUF16J+sIrUV94JeoLr0R94ZWoL7wS9YXXZbqWH694juzDB62r7JwRrat8NpWQniOH/EHrKp9NA1qX6eQd0bpKphvRukqmG9GKmele82PuzNf8ivdgic/VlmpJnd81v+f9mKPUtzn8m1rF6WuCWsX5a4JaxS5nglrFPkdard80t+hOUKvY60xQq9jtTFCr2O9MUBuo1BJ5qYdaIi/1UEvkpR5qibzUQy2Vl9LcrDtBLZWX0tyuO0EtlZfS3LA7QS2Vl9LcsjtBLZWX0ty0O0EtlZfS3LY7QS2Vl9LcuDtBLZWX0ty6O0EtlZfS3Lw7QS2Vl9LcvjtBLZWX0tzAO0EtlZfS3MI7QS2Vl9LcxDtBLZWX0tzGO0EtlZfS3Mg7QS2Vl9LcyjtBLZWX0tzMO0EtlZfS3M47QS2Vl9Lc0DtBLZWX0tzSO0EtlZfS3NQ7QS2Vl9Lc1jtBLZWX0tzYO0EtlZfS3No7QS2Vl9Lc3DtBLZWX0tzeO0EtlZfS3OA7QS2Vl9Lc4jtBLZWX0tzkO0EtlZfS3OY7QS2Vl9Lc6DtBLZWX0tzqO0EtlZfS3Ow7QS2Vl9Lc7jtBLZWX0tzwO0EtlZfS3PI7QS2VlypUXqpQeSnNjdUT1FJ5qULlpQqVl9LcSD5BLZWX0txKPkEtlZfS3Ew+QS2Vl9LcZD5BLZWXYuo9f6il8lJMvecPtUxeylH1njuq3nNH1XvuqHrP3Rao1DJ5KUfVe+6oes8dVe+5o+o9d1S9546q99xR9Z47qt5zR9V77qh6zx1V77mj6j13VL3njqr33FH1njuq3nNH1XvuqHrPHVXvuaPqPXdUveeOqvfcUfWeO6rec0fVe+6oes8dVe+5o+o9d1S9546q99xR9Z47qt5zR9V77qh6zx1V77mj6j13VL3njqr33FH1njuq3nNH1XvuqHrPHVXvuaPqPXdUveeOqvfcUfWeO6rec0fVe+6oes8dVe+5o+o9d1S9546q99xR9Z47qt5zR9V77qh6zx1V77mj6j13VL3njqr33FH1njuq3nNH1XvuqHrPHVXvuaPqPXdUveeOqvfcUfWeO6rec0fVe+6oes8dVe+5o+o9d1S9546q99xR9Z47qt5zR9V77qh6zx1V77mj6j13VL3njqr33FH1njuq3nNH1XvuqHrPHVXvuaPqPXdUveeOqvfcU/Wee6rec79MW3TxzxcX//Unv7Susn9GtK7yCVVCeo4cclvrMl3CI1pX+XQa0bpKzhvRukrKG9EaILW+5sfcma/59e7BvPn894vz9u5Z/vh3TW8Kk9eqN4PJa9Xrb8S1Ku73ldeq19/Ia9Xrb+S16vU38loDkVa9XkheK5FvUtzoK6+VyDcpbvMV16q4y1deK5FvUtzjK6+VyDcp7vCV10rkmxT398prJfJNirt75bUS+SbFvb3yWol8k+LOXnmtRL5JcV+vvFYi36S4z/V3Wvf6/KPkXj88r6K4zVVcq+K+z99pDe75Oxzch99hxW2f8lpX+Rwe0brK5/CI1lXy64jWVfLriNZV9mtIzxeHsn/Qusp+HdCquN9TXusq+XVE6zK+aUDrMr5pQGsg0rqMbxrQuoxvGtC6jG8a0ErkmxS3eYprVdzlKa8V0ze95sf0Qq/5Ffubx494zu/Cp/kD+PyKfYjz9Zi/bv88fR9dcR+mvFbFPkRcq2IfIq5VsQ+R1qq4B1Neq2IfIq5VsWcR16rZ30hrDURaiXyT4u5Lea1Evklx76W8ViLfpLjzUl4rkW9S3Hcpr5XINynuupTXSuSbFPdcymsl8k2KOy7ltfL4pl1xv6W8Vh7ftG88vmnfeHzTvgUiravs1/73IvZtlf06oFVxj+fvtPafs94V93jKa13lc3hE6yqfwyNaV8mvI1pXya8jWlfZr/1n3nbN/aDiWlfJrwNaNfeDimtdxjcNaF3GNw1oXcY3DWgNRFqX8U0DWpfxTQNaiXyT5n5Qca1EvklzP+gPWl/zY3qh1/yK/Y0P/jm/D/uH+RV7lqH5g+L5jyOuss9Z4FpX7EPEtSr2IeJaFfsQca2KfYi4VsU+RFqr5r5Nca2KPYu4Vs3+RlqrZi8krTUQaSXyTYHINwUi36S5R1VcK5FvikS+KRL5Js39uOJaiXyT5n5cca1Evklzj+qvtA48t6m5R1Vaq+a+zd/9DvefA9PctymudZnP4QGty3wOD2hdJr8OaF0mvw5oJcqvmvs2pbVq7tsU10qUXzV3c4prJcqvmjs/xbVi+qbX/Jhe6DU/pr95zY/pWV7zK/Yh+2EZ8+57XdjeP0f2n75jrLlvU1yrYh8irlWxDxHXqtiHiGsNRFoV+5DfaY1Pz+XzB8+luW9TXKtifyOuVbEXEte6jG/qa9XctymudRnfNKB1Gd80oBXEN+2pndM0d2gOzQ/ibz7Or9mz1O2Yv7oP82v2ISPza/YW2T3nf/yV65+n70lq7qQU1ho0d1KKa9XsLaS1avYW0lo1ewtprYFIq2bPIq1Vs7+R1qrZC0lr5fFNYSPyTY7IN2nukBXXSuSbNHfIimsNRFqJfJPmDllxrUS+SXOHrLhWIt+kuWv0V1r732sKmrtGxbUu8znc/Z5E0NxJKa51mc/hAa3LfA73tWrupBTXukx+HdBKlF8192KKaw1EWonyq+YOTXGtRPlVc4emuFai/Kq5Q1NcK9F9f80dmuJaiXyT5g5Nca2Yvuk1P6YXes2v2N+EfPT0h/dntL/Mr9izDM2v2IeEeHwXONRy/lrX3EkprlWxDxHXqtiHiGtV7EPEtQYirYp9iLhWxZ5FXKtmfyOtVbMXktZK5JsSkW9KRL5Jc4esuFYi36S5Q1ZcK5Fv0twhK66VyDdp7pAV10rkmzR3yIprXWW/Djy3qblrVFzrMp/D/efANPdiimtd5nO4r1Vzh6a41mXy64DWZfLrgFai/Kq5Q1NcK1F+1dyhKa6VKL9q7tAU10qUXzV3aP6g9TU/phd6zY/pb17zY3qW1/xB7/wxPH9yjrF3pki/yzto7roU16rYh4hrVexDxLUq9iHiWhX7EGGtUXPf5u+0djufo+a+TXGtiv3ND1pf8yv2N0PzB73zp+05RU6uCHyGKPY34loV+xtxrYr9jbhWxf5GXKtifyOtVXMv5u+09ne+5l5Mca2K/Y24VsVeSFxrINK6jG8a0LqMbxrQiumbXvNjeqHX/Jr9TTy+t53q1vldS8fvWoql/bvmNfsbaa2a/c2vtIbt+Ml75yd/nuLFRbMXupOLZt90J5dgXJpcNPuxO7lo9m53ctHs8+7kotk/3sllGV8qy0Vz9++tXMzvtrmY321zMb/b5hKMS5OL+d02F/O7bS7md9tczO+2uZjfbXLR3Nl8Kxfzu20u5nfbXMzvtrkE49LkYn63zcX8bpuL+d02F/O7bS7md5tcNHeD38rF/G6bi/ndNhfzu20uwbg0uZjfbXMxv9vmYn63zcX8bpuL+d0mF82d7rdyMb/b5mJ+t83F/G6bSzAuTS7md9tczO+2uZjfbXMxv9vmYn63yUVzF/+tXMzvtrmY321zMb/b5hKMS5OL+d02F/O7bS7md9tczO+2uZjfbXLRfObJrVzM77a5mN9tczG/2+YSjEuTi/ndNhfzu20u5nfbXMzvtrmY321y0XxWza1czO+2uZjfbXMxv9vmEoxLk4v53TYX87ttLuZ321zM77a5mN9tcUmaz0S6lYv53TYX87ttLuZ321yCcWlyMb/b5mJ+t83F/G6bi/ndNhfzu00uqs/IupOL+d02F/O7bS7md9tcgnFpcmH0L3vd/37tXj9xYfQvA1wozz8KLv392uDyBy6M+2iEC+M+GuHCuI9GuDDefxnhwnj/ZYQLo38J6XlOYSj7By6M/mWEC+P9lwEulOcfjXCh9LsDXCj97gAXSr87wCUYlyYXSr87wIXS7w5wMb/b5mJ+t83F/G6TC8H5Ry+t63vYl9ZlfOkvfrJL2f/94sf/fJt5y29klnGm4mSCkflAZhl3Kk5mGX8qTmYZh/obMnl/vvjxP+sHMst4VHEyy7jUX5Fx20GmfL2avr861udPjvWNotteFNc54+hWisu45VspUvpwcYqUnl2cYjCKAhQps4A4RcrcIE6RM2NIU+TMI9IULbsIUFznvKpbKVp2kaBo2UWComUXCYrBKApQtOwiQdGyiwRFyy4SFC27SFC07CJAcZ2zpOZRPATG99d+oWh+UYKi7WiJK9p2tARF29ESFG1HC1Bc57ykWyna/cUPT72tc76SOBnzdZ/IBEYyZTueIS3hExnK+3VDZCj9/RAZSs9ejqX9+J8fnq5d56wlcTKU3rrkYzfV3f/ztCtc52ymWylSemtxipQ+XJwipWcXpxiMogBFziwgTZEzN0hT5MwY0hQ584g0Rcsu5ynmdc7ZupWiZRcJipZdJChadpGgGIyiAEXLLhIULbtIULTsIkHRsosERcsuAhTXOTPtVormF7sUu88d53XO17qVou1oiSvadrQERdvRAhS97WgJinZ/UYKi3V/8SvFFxjzgJzLByHwgQ3lvrx4/2dXiPpChvF83RIbS3w+RYfTsftvrc+YtbB/IMPrwITLrnFn3KzLOHWRy+OdpV7jOCXe3UmT01vIUGX24PMVgFAUoMvp7eYqMWUCeImNukKfImTGkKXLmEWGK65w/eCtFyy4SFC27SFC07CJBMRhFAYqWXSQoWnaRoGjZRYKiZRcJipZdBChSnjMpT9GyiwRFyy4SFC27SFAMRlGAomUXCYqWXSQoWnaRoGjZRYKiZRcBipTnTMpTtOwiQdGyiwRFyy4SFINRFKBo2UWComUXCYqWXSQoWnaRoGjZRYBituwiQdGyiwRFyy4SFC27SFAMRlGAomUXCYqWXSQoWnaRoGjZRYKiZRcBipTn78pTtOwiQdGyiwRFyy4SFM0vdin2e1Mpz34Vp0h5jqf4FU15jqc8RdvREhRtR0tQDEZRgKLdX/xK8UXGPOAnMubrPpHhvLdX9+fMzn8iw3m/rk+mUJ51OUaG0rO7NzL1ExlKHz5EhtJbu/TU572v/+y4wmOMmN96n2N4oxiMogBFSm8tTpHSh4tTpPTs4hQp/b04RcosIE2R8pxJeYqcGUOaImcekaZo2UWCYjCKAhQtu0hQtOwiQdGyiwRFyy4SFC27CFCkPH9XnqJlFwmKll0kKFp2kaAYjKIARcsuEhQtu0hQtOwiQdGyiwRFyy4CFDnPNxanaNlFgqJlFwmKll0kKAajKEDRsosERcsuEhQtu0hQtOwiQdGyiwBFzvONxSmaX+xS7PYaFM4zZcUp2o7uUux+C7pwnuMpTtF2tABFznM8xSna/UUJinZ/8SvFFxnzgJ/IBCPzgYzd2/tEhvJ+nc/xNbPrfFqHmp6f1ltt51LOczHFKVJmAXGKlFlAmiLnuZjiFCmzgDhFyiwgTpEyN/yK4tsd+Pef/IViMIoCFCnziDhFyy4SFC27SFC07CJB0bKLAEXOczH/lOKnZw04z8UUp2jZRYKiZZevFF9kgpH5QMYyxicylhs+kaHMAvuLTHCp82ntXhwf//P91e+f15RpYAJHyjwgz5HztMkJHCkzwe847nF7ctyj+8CRMhVM4EiZC37J0fuDY41fODayWP/JvBKM+eXMKbPMzcwpU9LNzC1/Xc/cstr1zC3XXc6c8zTjm5lbXryeuWXL65lbDr2eeTDmlzO3HHo9c8uh1zO3HHo9c8uh1zO3HHo188p56vbNzC2HXs/ccuj1zC2HXs/c/Lkw8273WOU8U/pe5pyn/t772cJ5RvDNzM23XM/cfMv1zIMxv5y53T8/w/zF0Ty3DEfz0TIc7d51l2NwT4UuxE8c7X60CEfOU44ncLT81eUY3fG9oejSB46WqWQ4Wk7qX9clHxxj+cKx8bNdfn7LyPuU3169v1EPRv0G6paV7qBuyeoO6pbD7qBuqe0O6pbxbqDOeXb07dQtP95B3dLmHdQtm95BPRj1G6hbNr2DumXTO6hbNr2DumXTO6hbNr2BOufZ4LdTt2x6B3XLpndQt2x6B/Vg1G+gbtn0DuqWTe+gbtn0DuqWTe+gbtn0BurRsukd1C2b3kHdsukd1C2b3kE9GPUbqFs2vYO6ZdM7qFs2vYO6ZdM7qFs2vYF6smx6B3XLpndQt2x6B3XLpndQD0b9BuqWTe+gbtn0DuqWTe+gbtn0BurZ/Los9YGu2Gxu/Xrm5l+Emff7HLO5l+uZm3e5nrk5l+uZ2z31y5kXu6N+hvmLo3luGY7mo2U42n1sGY7BOPY4Jv+cw6WSOjsp1PTcSdvbTorvzC3XXc/cct31zC3XXc/cct31zC3XXc68Wq67nrllQFnm8Rg6vs/xhbnlxeuZW7a8nnkw5pcztxx6PXPLodcztxx6PXPLodOYZ/eBueXQi5nv22Y59HrmlkPPMH9xtGwpw9HyYpdj3uqTY4618xngSjhOaC1fTnLc36gHo34DdcuMd1C31HgHdcuNd1C35HgHdcuO0tTj8fRVyVuburP0eAd1y493ULe0eQd1y6Z3UA9G/Qbqlk2FqedSDurlq3P8ozu3znKs9v9Clnm1/xeyfCz8X6im49W1+A+7xfLxDdS95eM7qFs+voO65eM7qFs+voN6MOo3ULd8LE29hIN6zR+oW+a9g7rl2DuoWza9g7pl0xuo75ZN76Bu2fQO6pZNpam742c//jL+hfof3RXeLcdq/y8U7L+Q8v9Clo9l/wv5rR4/223lw26xfHwHdcvHd1C3fHwHdcvHN1APlo/voG75+A7qlo+FqTt3nAPj/P6BumXeO6gHo34Ddcumd1C3bHoHdcumd1C3bHoHdcum0n49uIP6/tWv/9Fd4Wg5Vvt/Icu82v8LWT4W/i/k/cHj8T7t3RItH99BPRj1G6hbPr6DuuXjO6hbPr6DuuXjO6hbPpamvteDevzwTaFkmfcO6pZj76Bu2fQO6pZN76AejPoN1C2b3kHdsqn037Py8fcsn7769T+6K5wsx2r/L2SZV/t/IcvHX/8LHWSyZdhPZChzZgjPF/u4ud5VvbmjtW/b36+9+MaRMjlO4EiZBSdwDMZRhCNlXpvAkTKBTeBImZN+yTEeLRbbu6/+wpEyzUzgSJk55DkWyoQygaPlGRmOlmdkOFqe6XM8vlXrvnyr9gvHYBxFOFqekeFoeUaGo+UZGY6WZ2Q4Wp7pcnT7fnAMqc2xWp6R4Wh5Roaj5RkZjpZnZDgG4yjC0fJMn2M9OPrtE0fLMzIcLc/IcLQ8I8PR8owER7dZnpHhaHmmy9End3DM4QNHyzMyHC3PyHAMxlGEo+UZGY6WZ2Q4rp9nXlrXzxwvrZi54JjfYfrx1/yKfXDen99LyrnE3u9a2I6fvHd+8sDvpVPsa2/lotin3solGJcmF8U+8lYuin3hrVwU+7xbuSj2hLdyUewf7+TiFfvSW7mY321zMb/b5mJ+t80lGJcmF/O7bS7md9tczO+2uZjfbXMxv9vkspvfbXMxv9vmYn63zcX8bptLMC5NLuZ321zM77a5mN9tczG/2+ZifrfJRfNJ9rdyMb/b5mJ+t83F/G6bSzAuTS7md9tczO+2uZjfbXLRfILxNC778cWkvX7iwuhfRrgw7qPg0t+vDS5/4MK4j0a4MO6jES6M+2iEC+P9lxEujPdfBrhoPo1yHpeUn1zK/oELo38Z4cJ4/2WEC+P9lxEuwbg0uVD63QEulH53gMv6fveldX0P+9K6jC/9xU925dVEV96b6Hb3IqP5jLmbySzjTcXJLONOxcks40/FyQQj84HMMh5VnMwyLvVXZA6b6krZPpBZxqeKk1nG1YqT4fTAA2Q0n2J2MxlODzxChtMDj5Ch9MD1+Mmuhv0DmWBkPpCh9MBDZCg98BAZSg88RIbSAw+RofTAI2Q0n3w1jYzftmPm7cuzG+9kGD3wGBlGDzxGhtEDj5EJRuYDGUYPPEaG0QOPkWH0wH479PktlQ9kGD3wGBlGDzxCxms+LelmMpweeIQMpwceIcPpgUfIBEYy7vjJ3n24C+E1nyN0MxlKDzxEhtIDD5Gh9MBDZCg98AgZzScU3UwG0wO/5sd0qq/5FfvJstXn/MX7zm+m94dFDO3vi3rN5wOJa1Xs+cS1KnZx4loV+zJxrYqdlrhWxd7pd1rj82E2n9vfG/Oaz8X5QetrfsWeZWh+xZ6lhHjMH8v560rz2THiWgORVs3+RlqrZn8jrVWzv5HWqtnf/ErrwM7X7G+EtWo+B0Vcq2YvJK11Gd80oHUZ3zSgNRBpxfRNr/kxvdBrfkx/85of07O85sf0Icf8ms+cGJof0y+85sf0AK/5Mff6a37MXf2aH3z/aj5jYGh+8P0bwPdvAN+/ms9MGJoffP9G8P0bwfev5jMghuYH37+az1QYmh98/2o+o2Bofs37txzPq5XaexLxp1cfajWfEDBBrebd/hu19Ri5vj+3+H4fU3OXv7hWzZ5BWmsg0qrFi7wm0uIuXhNp8QuvibQ4gNdEWnb6MZGa/vPXRFp242siLRvsNZGWPfOaSMs2eE2k7jNbTZ/zayJ1n9lq+otfE6n7zFbT1/uaSN1ntpp+2tdE6j6z1fSxviZS95mtpn/0NdHMz+zXu5RL3qVe8S5Tux1f7+IueRd/ybvsl7xLuORd4iXvki55l0uu/XrJtV+vuPb3bbvkXdwl7+IveZf9kncJl7xLvORd0iXvki95l3LJu1xy7btLrn13ybXvLrn23SXXvrvk2neXXPvukmvfXXLtu0uufXfJte8vufb9Jde+v+Ta95dc+/6Sa99fcu37S659f8m17y+59v0l1/5+ybW/X3Ltn/8m43681u95++fP95/6fwvfz3/fUHyioG6iqGyisM4J4L848X6vz0NW99q+mxrWOf9bmMsyjdfCXJbpuxbmskzbtTCXYFyaXJZpuhbmskzPtTCXZVquhbks03EtzMX8bpPLOmd9/4JL2N3frw0hfeDC6HeDf3HJH7gw+t0RLox+d4RLMC5NLox+d4QLo98d4cLod4NLTy7uExdGvzvChdHvDnBZ51xvYS6UfneAC6XfHeBC6XcHuATj0uRC6XcHuFD63QEu5nfbXMzvtrmY321xieuc4S3Mxfxum4v53TYX87ttLsG4NLmY321zMb/b5mJ+t83F/G6bi/ndJpd1zusW5mJ+t83F/G6bi/ndNpdgXJpczO+2uZjfbXMxv9vmYn63zcX8bpOL5hPZb+VifrfNxfxum4ti/5Li8/HAnOrW4/KLn+z3fHyr+MHo9eotN179UPI8pNTF91MqttB4dTxwxPJGw21vzBV7o2WZK/ZdyzJX7OmWZa7YL67KfFfsRSGZp+354vTuW74wV+xzQZnvB/PygbliD70sc8X3o5dlHoz55cwth17P3HLo9cwthwr78/qcI9b6gbnl0OuZWw69nHmwHHo9c8uh1zO3HHo9c8uh1zMPxvxy5pZDr2duOfR65pZDr2duOfR65pZDL2ceLYdez9xy6PXMLYdez9xy6PXMgzG/nLnl0OuZWw69nrnl0OuZWw69nrnl0MuZJ8uh1zO3HHo9c8uh1zO3HHo982DML2duOfR65pZDr2duOfR65pZDr2duOfRy5prP1l6WueXQ65lbDr2eufnzLvPd+yfzvcYe8/73/TWfTb0sc/Pn1zM3f349c/PnlzPXfBY4JPOB70FrPmd8Webmz69nbn8nup55MOaXM7ccej1zy6HCXrF/v0XzefTLMrccej1zy6GXM6+WQ69nbjn0euaWQ69nbjn0eubBmF/O3HLo9cwth17P3HLo9cwth17P3HLo1czTZjn0euaWQ69nbjn0euaWQ69nHoz55cwth17P3HLo9cwth17P3HLo9cwth17O3FkOvZ655dDrmVsOvZ655dDrmQdjfjlzy6HXM7ccej1zy6HXM7ccej1zy6GXM/eWQ69nbjn0euaBkblLB3Pva4d5/9vkyVM6bnGKlB5anCKlKxanSOlzxSlSOtdfUXz8NfX5k11uU9wpvegvKfa+OZ12SncpTpHy7xbiFCn/EiFOMRhFAYqWXSQoWnbp+sX+3YjdsosERcsuEhQtuwhQDJZdJChadpGgaNlFgqJlFwmKwSgKULTsIkHRsosERcsuEhQtu0hQtOwiQDFadpGgaNlFgqJlFwmKll0kKAajKEDRsosERcsuEhQtu0hQtOwiQdGyiwDFZNlFgqJlFwmKll0kKFp2kaAYjKIARcsuEhQtu0hQtOwiQdGyiwRFyy4CFLNlFwmKll0kKAZGipt7/mS/5dCj2P8eYKb0i+IUKf2iOEVKvyhOkdIvilOk9Iu/ojjw/ehC6Rd/SbH7DbZC6RfFKVLe6xanSHmvW5xiMIoCFC27SFC07NL1i/27EcWyiwRFyy4SFC27CFCsll0kKFp2kaBo2UWComUXCYrBKApQtOwiQdGyiwRFyy4SFC27SFC07HKeYuY8M16comUXCYqWXSQoWnaRoBiMogBFyy4SFC27SFC07CJB0bKLBEXLLgIUOc8ZF6do2UWComUXCYqWXSQoBqMoQNGyiwRFyy4SFC27SFC07CJB0bKLAEXOs6nFKVp2kaAYCCm6kre/X+zq7nsUu98DzJTnR8tTZPSL8hQZ/aI8RUa/KE+R0S/+jmL/+9GZ8vzo31LsfYMtU54fLU+R8V63PEXGe93yFINRFKBo2UWComWXrl/s342gPD9anqJlFwmKll0EKFKeHy1P0bKLBEXLLhIULbtIUAxGUYCiZRcJipZdJChadpGgaNlFgqJlFwGKlOdHy1O07CJB0bKLBEXLLhIUg1EUoGjZRYKiZRcJipZdJChadpGgaNlFgCLl+dHyFC27SFC07CJB0bKLBMVgFAUoWnaRoGjZRYKiZRcJipZdJChadhGgSHl+tDxFyy4SFAMjxewOivn9u31/+j1AyvOj5SlS+kVxipR+UZwipV8Up0jpF39FceC7V5TnR8tTpPSL4hQp73WLU6S81y1OMRhFAYqWXbpOp5+jKc+Plqdo2UWComUXCYqWXQQoUp4fLU/RsosERcsuEhQtu0hQDEZRgKJlFwmKll0kKFp2kaBo2UWComWX8xQL5fnR8hQtu0hQtOwiQdGyiwTFYBQFKFp2kaBo2UWComUXCYqWXSQoWnYRoEh5frQ8RcsuEhQtu0hQtOwiQTEYRQGKll0kKFp2kaBo2UWComUXCYqWXQQoUp4fLU9xGb8YtuMn752fvNfn8+57/TrFi0swLk0uy3g6YS7LuDRhLsv4LmEuyzgpYS7LeCNZLuucfizMZZl7r8JclrmbKszF/G6bSyDkEvbnDw4hfeDC6HeDf3HJH7gw+t0RLox+d4QLo98d4cLodwe4rHNirjAXRr8bXHpycZ+4MPrdES6MfneESzAuTS6UfneAC6XfHeBC6XcHuFD63QEulH63z2WdU1aFuZjfbXMxv9vmYn63zSUYlyYX87ttLuZ321zM77a5mN9tczG/2+SyzsmcwlzM77a5mN9tczG/2+YSjEuTi/ndNhfzu20u5nfbXMzvtrmY321yWec0R2Eu5nfbXMzvtrmY321zCcalycX8bpuL+d02F8X+JcTnY/w51NLhMvDMv+YTA8W1KvYZ4loVewdxrYr9gLjWQKRV8d4W16p4F4trVXw/SVyr4ntE4lqJfJPm08p+pXXg+4+azxT7ndb+d2s0n/wlrnUV3zSiNRBpXcU3jWhdxTeNaF3FNw3cg9F8upO41lV8U19r1XxSkrjWZXzTgNZlfNOA1mV804DWQKR1Gd80oHUZ3zSglcc3Vc0ny4hrJfJNmk9pEddK5Js0n3girpXIN2k+PURcK5Fv0nwSh7hWIt+k+VQLca1EvknzCRHiWol8kyfyTZrP5xDXGoi0EvkmzWdjiGsl8k2az7AQ10rkmzSfNSGulcg3aT4TQlyr4v265+P7LQ8lHa395xGr5i5+ca2K96u4VsX7VVyr4v0qrVVzt724VsX7VVyr4v0qrlXxfQlxrYFIK5Fv0tzp/iut/e9xVM097b/T2n1WumruXhfXuopvGtCquSNdXOsqvmlE6yq+aUTrKr5p4B6M5s5xca2r+KYRrcv4pgGty/imAa3L+KYBrcv4pr5WzV3b4lqX8U0DWpfxTQNaiXyT5u5qca1Evklzx7S4ViLfpLkLWlwrkW/S3NksrpXIN2nuVhbXSuSbNHcgi2sl8k2au4rFtRL5pkzkmzT3Sktr1dwrLa6VyDdp7pUW10rkmzT3SotrJfJNmnulxbUS+SbNvdLSWjX3D3t/fGfF59zROvA8oub+YXGtiveruFbF+1Vcq+L9Kq5V8X4V16p4v4prVbxfxbUqvi8hqzVsmvuHxbXS+KaH1lV8U/d7HA+tq/im7rPSD62BSOsqvmlE6yq+aUTrKr5pROsqvmlE6yq+qXsPJmya+4fFta7im0a0LuObBrQu45sGtAYircv4pgGty/imAa3L+KYBrcv4pgGtRL5Jc/+wuFYi36S5f1hcK5Fv0tw/LK6VyDdp7h8W10rkmzT3D4trJfJNmvuHxbUS+SbN/cPiWol80x6ItBL5Js290uJaiXyT5l5pca1Evklzr7S4ViLfpLlXWlwrkW/S3CstrlXxfnW+PrW6unW0DjyPqLl/WFyr4v0qrVVz/7C4VsX7VVyr4v0qrlXxfhXXqni/imtVfF9CXKvi+xLiWol8k+b+4V9pHfgeh+b+4d9p7T8rrbl/WFzrKr5pROsqvmlE6yq+aURrINK6im8auAejuX9YXOsqvmlE6zK+aUDrMr6pr1Vz/7C41mV804DWZXzTgNZlfNOA1kCklcg3ae4fFtdK5Js09w+LayXyTZr7h8W1Evkmzf3D4lqJfJPm/mFxrUS+SXP/sLhWIt+kuX9YXCuRb6pEvklzr7S4ViLfpLlXWlxrINJK5Js090qLayXyTZp7pcW18vgmp7lXWlyr4v26+fzU+vDtHa395xHdpni/imtVvF/FtSrer+JaFe9Xca2K96u4VsX7VVqr5v5hca2K70uIa1V8X0JcK5Fv0tw//Cut/e9xOM39w7/T2n1W2mnuHxbXuopvGtG6im8a0bqKbxrQqrl/WFzrKr5p4B6M5v5hca2r+KYRrYFI6zK+aUDrMr5pQOsyvmlA6zK+aUDrMr6pr1Vz/7C4ViLfpLl/WFwrkW/S3D8srpXIN2nuHxbXSuSbNPcPi2sl8k2a+4fFtRL5Js39w+JaiXyT5v5hca1EvikQ+SbNvdLiWol8k+ZeaWmtmnulxbUS+SbNvdLiWol8k+ZeaXGtRL5Jc6+0uFa9+zWV+HzEMNWSOlrLcVBJ8R+eR1TcPyyvVe9+ldeqd7/Ka9W7X+W16t2vv9Qan8+tlbL1fnLYjin23ms/TvxiqHdv4zDU6wdwGOq9P4PDUO99HxyGy/jd+xgq7qPGYbiMP7+R4TK+/0aGy+SJGxkGY3iaoeWU8wwtp5xnaDnlPEPLKecZWk45zVBx/zsOQ8sp5xlaTjnP0HLKeYbBGJ5maDnlPEPLKecZWk45z9ByynmGllNOM1Tcy6+D4UDXnOK+fxyGtpd/fu3A85SKe+xxGNpePs/Q9vJZhl5xnz8OQ7t/eJ6h+cMOw/T8UkQo+weG5g/PMwzG8DRDu394nqHllPMMLaecZ2g55TxDyymnGSo+FwWHoeWU8wwtp5xnaDnlPMNgDE8ztJzS5mLZo82FMk/8Ygq/b/nQ596mCP6NImWiEKdImSmkKSo+NQiJImWuEKdImSzEKVJmC3GKwSh2KAZ36IvbB4qU+UKcImUaEado2UWComUXCYqWXQQoKj65C4miZZcexbwf+or/QNGyiwRFyy4SFINRFKBo2UWComUXCYqWXSQoWnb5DcX6gaJlFwGKik/PQ6K4THYJz++HlPDh+yGKz+WT17pMDhjQGoi0LuOpB7Qu43wHtC7jTwe0LuMiB7Qu4/X6WhWfyyevlcg3KT6XT14rkW9SfC6fvFYi36T4XD55rUS+KRL5pnXOW+xrXee8xQGtRL5pnfMWB7QS+aZ1zlsc0Erkm9Y5v3BAK5FvWuc8wAGtRL5pnfP1BrQS+aZ1zqsb0Erkm9Y5/21AK5FvWuc8tQGtRL5pnfPJBrQS+aZ1zvsa0Erkm9Y5P2tAK5FvWuc8qgGtRL5pnfOdBrQS+aZ1zksa0ErkmyqRb6pEvmmdc6UGtBL5phqItBL5pnXO3xrQSuSb1jnPakArj2/a1zkfakArj2/a1zlvaUArj2/at0Cklcc37eucBzSglcc37eucrzOglcg3rXNezYBWIt+0zvkvA1qJfNM656kMaCXyTeucZTKglcg3rXOKyIBWIt+0zokcA1qJfNM6p1sMaCXyTeucFDGglcg3rXPqwoBWIt+0zgkGA1qJfNM6pwEMaCXyTes06w9oJfJN67TUD2gl8k3rNL4PaKXswv7FGdR7fQ6x19BmyNmELcyQ8gwfYYaUJ/gIM6Q8v0eYYTCGpxlSnt0jzJDy5B5hhpTn9ggzpDy1R5ih5ZTTDNfph5/E8PFn+r9fG0L6wNBySoehfzH8cM9hnT77GxlaTjnPMBjD0wwtp5xnaDnlPEPLKR2G7vm3gOA+MbSccp6h5ZTTDNc5j+FGhpZTzjO0nHKeoeWU8wyDMTzN0HLKeYaWU84ztJxynqHllPMMLaecZrjO+Sc3MrSccp6h5ZTzDC2nnGcYjOFphpZTzjO0nHKeoeWU8wwtp5xnaDnlNMN1zhu6kaHllPMMLaecZ2g55TzDYAxPM7Sccp6h5ZTzDC2nnGdoOeU8Q8sppxmuc77XjQwtp5xnaDnlPEPF/jAfj5On4vceQ/8EXvyH79VpPg9LXKtivyWuVbEvEteq2L8Iaw2az8P6ndZZn+8pPz/fy/6BoWKfAcNQsc+AYaj4figMw2AMTzNcxu/eyHAZH30jw2X8+Y0Ml/H9NzJcJk/cx1Dz+XMwDC2nnGdoOeU8Q8sp5xkGY3iaoeWU8wwtp5xnaDnlPEPLKecZWk45zVDzeY8wDC2nnGcYjOGPr+13BAfN5yPCMLS93LmWu88PBc3n/qEw1HyeIAxD28vnGdr9w/MM7f7heYbBGJ712JrPgYRhaPcPzzO0+4fnGVpOOc/QcspphprPT4VhaDnlPEPLKecZWk45zzAYw9MMLaecZ2g55TxDyyltLpY92lwo88QvpnBbfv4Bzm3Fv+nzL4qaTzoFokiZKcQpUqYKcYqUuUKcYjCKAhQps4U4Rcp08RuKbnuycM6FDxQp84U4Rco0Ik7RsosARc2nnwJRtOwiQdGyiwRFyy6/oOjdB4rBKApQtOwiQXGZ7BKeT02W8OGpSc0nloprXSYHDGhdxq33tWo+qVNc6zLOd0DrMv50QOsyLnJAayDSuowjG9BK5Js0n6AorpXIN2k+kVBaq+aTA8W1EvkmzSfxiWsl8k2aT7YT10rkmzSfFCeulcg3aT557f/f3rulOY4rsboz2p8oUaQ0uDX3471X+1JnSa1wMWQGCLz1Q1Zm4O9KB6CyEe5aiXxT5Etm7lqJfFPky2DuWol8056JtBL5pnEusxm0EvmmcS6zGbTy+KZ1nMtsBq08vmkd59KZQSuPb1qnTKSVxzet41ziMmjl8U3rOJetDFqJfNM4l6IMWol80ziXlwxaiXzTOJeMDFqJfNM4l4EMWol80ziXdgxaiXzTOJdrDFqJfNNM5JtmIt80zoUfg1Yi3zQT+aaZyDeNcwnJoJXIN41zWciglcg36ULKxddeX39bdSHFgaGah9sZqnm4naFaitsZ6kJKM0NdSHFgqAsp7Qx1IaWdoS6ktDPMYtjMUDnl3782L8/vm3M5YaiccsFwfjM8eeagCykODJVT2hkqpzQz5Ly74sxQOaWdoXLKBcPLa+kr58UVZ4ZZDJsZKqe0M1ROaWeonNLOUDmlnaFySjNDzhsrzgyVU9oZKqe0M1ROaWeYxbCZoXJKO0PllHaGyintDJVT2hkqpzQzHOduTUeGyintDJVT2hkqp7QzzGLYzFA5pZ2hcko7Q+WUdobKKe0MlVOaGY5zJ6ojQ+WUdobKKe0MlVPaGWYxbGaonNLOUDmlnaFySjPDyPew1mV+ffE+XTGcn5+r2+aTz9VFvoflrjWw33LXGtgXuWvNRFoD+4zvtN70+m7ojYp8ZwuGYWCfAcMw8PNQGIaBn4eCMCyR75jBMBzGR3dkOIw/78hwGN/fkWEWw2aGyintDJVT2hkqp7QzVE5pZ6ic0sww8t1AGIbKKe0MlVPaGSqntDPMYtjMUDmlnaFySjtD5ZR2hsop7QyVU5oZRr7TCcNQOaWdoXJKO0PllHaGWQybGcof/vvXXt+QKJHve6IwjHxfMgTD6/eXl0V7uZ2h9nI7Q+3ldoZ6ftjOUM8P2xnKH14wLPXJcFtOGMoftjPU88NmhpHvp8IwVE5pZ6ic0s5QOaWdYRbDZobKKe0MlVPaGSqntDNUTmlnqJzSzDDy/dQODN9clD2OuVDmiS+meOh4TpHynj70fVKkTBTuFLMoOlCkTBXuFClzhTtFymThTpEyW7hTpEwXX1F8vdXo8YPnY4qR754CUaRMI+4UlV08KCq7eFDMouhAUdnFg6KyywXFdX1TLGcUlV08KCq7eFBUdnGgGPkWKhBFZRcPisouHhSVXa4olvyiWJcTilkUHSgqu3hQVHbxoKjs4kFR2cWDorKLA8XI91G/o3jdqxD5jqm71mFygEHrMG7doDUTaR3G+Rq0DuNPDVqHcZEGrcN4PYPWYRzZtdZx7oYatBL5pnHuhhq0Evmmce6GGrQS+aZx7nsatBL5pnHuZRq08vimOs79SYNWHt9Ux7nnaNDK45vqlIm08vimOs69QYNWHt9Ux7nfZ9BK5JvGuYdn0Erkm8a5L2fQSuSbxrnXZtBK5JvGuX9m0Erkm8a5J2bQSuSbxrnPZdBK5JvGuXdl0Erkm8a5H2XQSuSbZiLfNM79LoNWIt80E/mmhcg3jXPnzKCVyDeNczfMoDUTaSXyTePcyzJoJfJN49yfMmgl8k3j3HMyaCXyTePcRzJoJfJN49wbMmgl8k3j3O8xaCXyTePcwzFoJfJN49yXMWgl8k3j3IExaCXyTePcVDFoJfJN49wnMWgl8k3j3PowaCXyTePczTBoJfJN49ygMGgl8k3j3HMwaCXyTePcRjBoJfJN49wZMGgl8k3jdPYbtBL5pnH67w1aiXzTOF3yBq1EvmmcXnaDViLfNE7HuUErkW8i6guvRH3hlagvvBL1hVeivvBK1BdeifrCK1FfeCXqC69EfeGVqC+8EvWFV6K+8ErUF16J+sIrUV94JeoLr0R94ZWoL7wS9YVvRH3hG1Ff+EbUF74R9YVvUybSyuObtnF6pb+5tpqn1zdeLr522Z9n5Zc9nzCkvFjry3CcHuyODIfxGR0ZDuNfOjIcxhd1ZJjFsJnhMD6uI8Nhnqt1ZDjM87qODJVT2hkqp/z71+bl+X1zLscMx+mdv4vh/GZ48sxhnD77jgyVU9oZKqe0M8xi2MxQOaWdoXLKBcP0/LeAnM4YKqe0M1ROaWeonNLMcJw7Dx0ZKqe0M1ROaWeonNLOMIthM0PllHaGyintDJVT2hkqp7QzVE5pZjjOXZWODJVT2hkqp7QzVE5pZ5jFsJmhcko7Q+WUdobKKe0MlVPaGSqnNDMc545RR4bKKe0MlVPaGSqntDPMYtjMUDmlnaFySjtD5ZR2hsop7QyVU5oZjnM3rCND5ZR2hjkuw2V7flSuPP4R94rh/PzibT75XF3ke1juWgP7LXetgX2Ru9bA/sVda2Cf8Z3Wu17fS32+vm/LMcPId7ZgGAb2GTAMAz8PhWEY+HkoDMMshs0Mh/HRHRkO4887MhzG93dkOEye6MhQOaWZYeS7djAMlVPaGSqntDNUTmlnmMWwmaFySjtD5ZR2hsop7QyVU9oZKqc0M4x8RxKGofzhv3+toSM48n1EGIbayxe/y9fvH4p89w+GofZyK8M98p1CGIZ6ftjOUM8P2xnKH7Z67H3KYtjMUM8P2xnq+WE7Q+WUdobKKe0MlVOaGUa+nwrDUDmlnaFySjtD5ZR2hlkMmxkqp7QzVE455qLsccyFMk98MUWa6nOKNG3zh775gyJlovCmGPnWKRBFylThTpEyV7hTpEwW7hSzKDpQpEwX31BM05NFSimfUKTMF+4UKdOIO0VlFw+Kyi4OFCPfPwWiqOziQVHZ5QuKczqhqOziQTGLogPFYbJLfr5rcssn75qMfLHUXeswOcCgdRi3btA6jKe+1hr5oqa71mH8qUHrMC7SoHUYr2fQmom0EvmmyBcU3bUS+abIFwndtRL5psgX/ty1EvmmyBfz3LUS+abIF+jctRL5psgX3dy1EvmmyBfS3LUS+abIF8fctRL5pkLkmwqRbxrnMptBK5FvGucym0ErkW8a5zKbQSuRbxrngppBK5FvGucimUErkW8a58KXQSuRbxrnYpZBK5FvGucClUErkW8a56KTQSuRbxrnQpJBK5FvGufikEErkW8a54KPQSuRbxrnIo5BK5FvGufCjEErkW/aiXzTOBd+DFozkVYi37QT+aZxLiEZtBL5pnEuC11pXadxLgAZtKp5+N+/9vL624PhMHu7I0M1D7czVPNwO0O1FLcz1IWUdoa6kNLMUBdSHBjqQko7Q11IaWeonNLOMIvhv35tXp7fN+dywlA55YLh/GZ48sxBF1IcGCqntDNUTmlnqJzSzJDz6oozQ+WUC4ZX19IfDJVT2hkqp7QzzGLYzFA5pZ2hcko7Q+WUdobKKe0MlVOaGXJeWHFmqJzSzlA5pZ2hcko7wyyGzQyVU9oZKqe0M1ROaWeonNLOUDmlmeE493A6MlROaWeonNLOUDmlnWEWw2aGyintDJVT2hkqp7QzVE5pZ6ic0sxwnPtTHRkqp7QzVE5pZ6ic0s4wi2EzQ+WUdobKKe0MA/vDuTzHL0uaLhgaPlcX+R6Wu9bAfstda2Bf5K41sH9x15qJtAb2A+5aA+9td62BnwO6aw38vM5dK5FvinwP6yutht6AyPewvtN6/VnMyPew3LWO4pssWjOR1lF8k0XrKL7JonUU32R4BhP5Hpa71lF8k0Fr5HtY7lqH8U0GrcP4JoPWYXyTQWsm0jqMbzJoHcY3GbQS+abI97DctRL5psj3sNy1EvmmyPew3LUS+abI97DctRL5psj3sNy1EvmmyPew3LXy+KYU+R6Wu1Ye35QmHt+UIt85c9eaibTy+KYU+b6Xu1Ye35Qi38ty10rkmyLfn3LXSuSbIt9zctcaeL+m1xQl7fuFVt9bSinyDZuuXALv7a5cAu/4rlwC+4GeXCLfhOnKJbDP6MolsCfpyiXwc5+uXLK4HHKR3z3mwuh3rz/XkyLfN7mPy+X77FPkmyVduTD6XQOXyLdFunJh9LsWLox+18KF0e8anmNGvtXRlQuj37VwofS7Bi6UftfAhdLvGrhQ+t1rLpFvVHTlQul3DVwo/a6Bi/zuMZcsLodc5HePucjvHnOR3z3mIr97zEV+95BL5FsHXbnI7x5zkd895iK/e8wli8shF/ndYy7yu8dc5HePucjvHnOR3z3kEvkmRFcu8rvHXOR3j7nI7x5zyeJyyEV+95iL/O4xF/ndYy7yu4dcfn3Hwfdd/L++zOA8/QI9fYaefoWevkBPX6Gn36Cn35Gn//WlAOfpoXftFnfXGj7XtsXdtYZPQfy6cd95+ri71jJ93F1rmT7urrVMH3fXWqaPu2sNyXCPu2st08fdtZbpA+9aw/SBd61h+sC71jB94F1rmD7wrjVMH3jXGqYPvGsN0yPv2nlC3rXzhLxr5wl5184T8q6dJ+RdO0/Iu3aekHftPCHv2nlC3rXzBL1rE/SuTdC7NkHv2gS9axP0rk3QuzZB79oEvWsT9K5N0Lt2ht61M/SunaF37Qy9a3/dRuw8ffvr/fQc6IFidZz++n0Ks0NTa8/pd+TpHVpPe06foKefoadfoKfP0NOv0NMX6Omhd+0Sd9devydwXuLu2ut3F8057q61TB9311qmj7trLdPH3bWW6ePuWsv0cXetIRnmuLvWMn3cXWuZPvCuNUwfeNdeT78G3rWG6QPvWsP0gXetYfrAu9YwfeBda5geeteu0Lt2hd61K/SuXaF3bYHetQV61xboXVugd61DA1LP6aF3bYHetQV61xboXVugd22F3rUVetdW6F1boXetQ3dRz+mhd22F3rUVetdW6F1boXftBr1r2/tz0vz8IXOqyXF6w/sU2vtzuk6/Qk9foKev0NNv0NPvyNO39+d0nT5BTz9DTw+9a9v7c26b3vCewD3urjW8u2iPu2st08fdtZbp4+5ay/Rxd+319MsUd9dapo+7a6+T4TLF3bWW6ePuWsv0gXetYfrAu9YwfeBda5g+8K41TB941xqmD7xrr6dPgXetYXroXZugd22C3rXt/Tldp4fetQl61yboXZugd22C3rUz9K6doXftDL1rZ+hd296f03V66F07Q+/aGXrXztC7dobetQv0rl2gd+0CvWsX6F3b3l3UdXroXbuA7to6l/9z4o+n5x/b/+8Iz9nT608tf/Wn8l/9qfWv/lT59k9t2+NPHf9zQJ3q83/l5x/b3n+s/t0f2/7uj+1/9ceOH/le/7H0d39s/rs/tvzdH8t/98daX3dOv/T1E8rtP6HZK0/51VI6lXrx6pPLk2nelv//K8p/B9qiDbTfONDzh7Q/5LH8kPSLHzL/4ocsv/gh+Rc/ZP3FDym/+CH1Fz9k+8UP+cVv/PKL3/jlF7/xyy9+45df/MYvv/iNX37xG//rULE+t2hZt8MtutRoA8V9zFbm7fW1+Xj4uE/ZrofPcR+yGYaP+4zNMHzcR2yG4eM+YTMMn5GHj/t8zTB83MdrhuHj/kuWYXjkDZuRN+yKvGFX5A27Im/YFXnDtteU9hwe9BPm/x0e9APm/2/4Avpv5v8dHvSfzP87POi/mP93+LivNobhQf+9/L/Dg/5z+X+HD/zOtMt/CCuB35h2PXzg96VdDl8Dvy3tevjAG/Z6+MAb9nr4wBv2evjAG/Z6+MAb9nr4wBv2enjkDVuRN2xF3rBblA37GijK1nwN9ONNePrM5H+/NqX6/M4pbR+lmPP6Hn/BHj9jj79ij1+wx6/Y42/Y49+5F58/5NaiydcP+XHX/uV7ePY52kBxG/Gv/xGivbSx5/Bx+/ANw8etwzcMH7cN3zB83DJ8w/Bxu/Avh3eoa+w5fNyrM4bh4x6dMQwPvGEdqhp7Dg+8YR2KGnsOD7xhHWoaew6PvGET8oZNyBs2IW/YhLxh2wsaew6PvGET8oZNyBs2IW/YhLxhZ+QNOyNv2Dnu6/zle44dugF7Dg96PvK/w4Nej/x/wy+gxyP/Ozzoneb/Dg96pvm/w4Neaf7v8HFf5y/fVOTQS9dz+MAnmq+HD3yh+Xr4wBv2evjAG/Zy+Bx4w14PH3jDXg8feMNeDx94w14Pj7xhM/KGzcgbNkfZsK+BomzN10A/3oTfvG0xL/s/X5zyOr+/el1e468T9vgJe/wZe/wFe/yMPf6KPX4JPH6a3uMvf4z/v1+95+fD1H39mOLxU15SK4/UjUdq5M2/vaXuy+HvX4m8+Q3jR978hvEjb37D+JE3v2H8jD1+5M1vGD/y5n+Pv07pePzI29wwfuQNbRg/8NZd5/oaP0+H49fAW9cyfuCtaxk/8Na1jB9461rGD7x1LeMH3rqW8QNv3T/G347HD7x1LeMH3rqW8SNv3bq9xt+PTcMWeesaxo+8dQ3jR966hvEjb13D+JG3rmH8yFvXMH7krfs5/n48fuStaxg/8tY1jH/n1n3+kH36xQ9p32D1dQ1rWZar/xFXFS6LQ6eM80DLbwdy/ZyGQ6dMx+FX5OEL8vAVefgNefgdd/js0CnTcfiEPPyMPDzwhs0T8IbNE/CGzRPwhs0T8IbNE/CGzRPyhk3IGzYhb9iEvGET8oZ16JTpODzyhk3IGzYhb9iEvGET8oadkTfsjLxhZ+QNOyNvWIc2n47DI2/YGXnDzsgbdkbesDPyhl2QN+yCvGEX5A27IG9Yhx6ljsMjb9gFecMuyBt2Qd6wC/KGzcgbNiNv2Iy8YTPyhnXoUeo4PPKGzcgbNiNv2Iy8YTPyhl2RN+yKvGFX5A27Im9Yh1amjsMjb9gVecOuyBt2Rd6wK/KGLcgbtiBv2IK8YQvyhnVoP+o4PPKGLcgbtiBv2IK8YQvyhq3IG7Yib9iKvGEr8oZ1aDrqODzyhq3IG7Yib9iKvGEr8obdkDfshrxhN+QNuyFvWIdWo47DI2/YDXnDbsgbdkPesBvyht2RN+yOvGF35A2L3OmUkTudMnKnU0budMrInU4ZudMpI3c6rcidTityp9OK3Om0Inc6rRPwhl2RO51W5E6nFbnTaUXudFqRO51W5E6nFbnTaUXudFqRO51W5E6nFbnTaUXudFqRO51W5E6nFbnTaUXudFqRO51W5E6nFbnTaUXudFqRO51W5E6nFbnTaUXudFqRO51W5E6nFbnTaUXudFqRO51W5E6nFbnTaUXudFqRO51W5E6nFbnTaUXudFqRO51W5E6nFbnTaUXudFqRO51W5E6nFbnTaUXudFqRO51W5E6nFbnTaUXudFqRO51W5E6nFbnTaUXudFqRO51W5E6nFbnTaUXudFqRO51W5E6nFbnTaUXudFqRO51W5E6nFbnTaUXudFqRO51W5E6nFbnTaUXudFqRO51W5E6nFbnTaUXudFqRO51W5E6nFbnTaUXudFqRO51W5E6nFbnTaUXudFqRO51W5E6nFbnTaUXudFqRO51W5E6nFbnTaUXudFqRO51W5E6nFbnTaUXudFqRO51W5E6nFbnTqSB3OhXkTqeC3OlUkDudygS8YQtyp1NB7nQqyJ1OBbnTqSB3OhXkTqeC3OlUkDudCnKnU0HudCrInU4FudOpIHc6FeROp4Lc6VSQO50KcqdTQe50KsidTgW506kgdzoV5E6ngtzpVJA7nQpyp1NB7nQqyJ1OBbnTqSB3OhXkTqeC3OlUkDudCnKnU0HudCrInU4FudOpIHc6FeROp4Lc6VSQO50KcqdTQe50KsidTgW506kgdzoV5E6ngtzpVJA7nQpyp1NB7nQqyJ1OBbnTqSB3OhXkTqeC3OlUkDudCnKnU0HudCrInU4FudOpIHc6FeROp4Lc6VSQO50KcqdTQe50KsidTgW506kgdzoV5E6ngtzpVJA7nQpyp1NB7nQqyJ1OBbnTqSB3OhXkTqeC3OlUkDudCnKnU0HudCrInU4FudOpIHc6FeROp4Lc6VSQO50KcqdTQe50KsidTgW506kgdzoV5E6ngtzpVJE7nSpyp1NF7nSqyJ1OdQLesBW506kidzpV5E6nitzpVJE7nSpyp1NF7nSqyJ1OFbnTqSJ3OlXkTqeK3OlUkTudKnKnU0XudKrInU4VudOpInc6VeROp4rc6VSRO50qcqdTRe50qsidThW506kidzpV5E6nitzpVJE7nSpyp1NF7nSqyJ1OFbnTqSJ3OlXkTqeK3OlUkTudKnKnU0XudKrInU4VudOpInc6VeROp4rc6VSRO50qcqdTRe50qsidThW506kidzpV5E6nitzpVJE7nSpyp1NF7nSqyJ1OFbnTqSJ3OlXkTqeK3OlUkTudKnKnU0XudKrInU4VudOpInc6VeROp4rc6VSRO50qcqdTRe50qsidThW506kidzpV5E6nitzpVJE7nSpyp1NF7nSqyJ1OFbnTqSJ3OlXkTqeK3OlUkTudKnKnU0XudKrInU4VudOpInc6VeROp4rc6VSRO50qcqdTRe502pA7nTbkTqcNudNpQ+502ibgDbshdzptyJ1OG3Kn04bc6bQhdzptyJ1OG3Kn04bc6bQhdzptyJ1OG3Kn04bc6bQhdzptyJ1OG3Kn04bc6bQhdzptyJ1OG3Kn04bc6bQhdzptyJ1OG3Kn04bc6bQhdzptyJ1OG3Kn04bc6bQhdzptyJ1OG3Kn04bc6bQhdzptyJ1OG3Kn04bc6bQhdzptyJ1OG3Kn04bc6bQhdzptyJ1OG3Kn04bc6bQhdzptyJ1OG3Kn04bc6bQhdzptyJ1OG3Kn04bc6bQhdzptyJ1OG3Kn04bc6bQhdzptyJ1OG3Kn04bc6bQhdzptyJ1OG3Kn04bc6bQhdzptyJ1OG3Kn04bc6bQhdzptyJ1OG3Kn04bc6bQhdzptyJ1OG3Kn04bc6bQhdzptyJ1OG3Kn04bc6bQhdzptyJ1OG3Kn04bc6bQhdzptyJ1OG3Kn04bc6bQhdzptyJ1OG3Kn04bc6bQhdzptyJ1OG3Kn047c6bQjdzrtyJ1OO3Kn0z4Bb9gdudNpR+502pE7nXbkTqcdudNpR+502pE7nXbkTqcdudNpR+502pE7nXbkTqcdudNpR+502pE7nXbkTqcdudNpR+502pE7nXbkTqcdudNpR+502pE7nXbkTqcdudNpR+502pE7nXbkTqcdudNpR+502pE7nXbkTqcdudNpR+502pE7nXbkTqcdudNpR+502pE7nXbkTqcdudNpR+502pE7nXbkTqcdudNpR+502pE7nXbkTqcdudNpR+502pE7nXbkTqcdudNpR+502pE7nXbkTqcdudNpR+502pE7nXbkTqcdudNpR+502pE7nXbkTqcdudNpR+502pE7nXbkTqcdudNpR+502pE7nXbkTqcdudNpR+502pE7nXbkTqcdudNpR+502pE7nXbkTqcdudNpR+502pE7nXbkTqcdudNpR+502pE7nXbkTqcdudNpR+502pE7nXbkTqcdudNpR+502pE7ndKEXOr0mB54xz6mB16yj+mBt+xjeuA1+5geeM8+pgdetI/pgTftY3rgVfuYHnrXItc7PaaH3rXIBU+P6aF3LXLF02N66F2LXPL0mB561yLXPD2mh961yEVPj+mhdy1y1dNjeuhdi1z29Jgeetci1z09pofetciFT4/poXctcuXTY3roXYtc+vSYHnrXItc+PaaH3rXIxU+P6aF3LXL102N66F2LXP70mB561yLXPz2mh961yAVQj+mhdy1yBdRjeuhdi1wC9Zgeetci10A9pofetchFUI/poXctchXUY3roXYtcBvWYHnrXItdBPaaH3rXIhVCP6aF3LXIl1GN66F2LXAr1mB561yLXQj2mh961yMVQj+mhdy1yNdRjeuhdi1wO9Zgeetci10M9pofetcgFUY/poXctckXUY3roXYtcEvWYHnrXItdEPaaH3rXIRVGP6aF3LXJV1GN66F2LXBb1mB561yLXRT2mh961yIVRj+mhdy1yZdRjeuhdi1wa9Zgeetci10Y9pkfetQm6NypB90Yl6N6oBN0blSbkXZuge6MSdG9Ugu6NStC9UQm6NypB90Yl6N6oBN0blaB7oxJ0b1SC7o1K0L1RCbo3KkH3RiXo3qgE3RuVoHujEnRvVILujUrQvVEJujcqQfdGJejeqATdG5Wge6MSdG9Ugu6NStC9UQm6NypB90Yl6N6oBN0blaB7oxJ0b1SC7o1K0L1RCbo3KkH3RiXo3qgE3RuVoHujEnRvVILujUrQvVEJujcqQfdGJejeqATdG5Wge6MSdG9Ugu6NStC9UQm6NypB90Yl6N6oBN0blaB7oxJ0b1SC7o1K0L1RCbo3KkH3RiXo3qgE3RuVoHujEnRvVILujUrQvVEJujcqQfdGJejeqATdG5Wge6MSdG9Ugu6NStC9UQm6NypB90Yl6N6oBN0blaB7oxJ0b1SC7o1K0L1RCbo3KkH3RiXo3qgE3RuVoHujEnRvVILujUrQvVEJujcqQfdGJejeqBm6N2qG7o2aoXujZujeqHlC3rUzdG/UDN0bNUP3Rs3QvVEzdG/UDN0bNUP3Rs3QvVEzdG/UDN0bNUP3Rs3QvVEzdG/UDN0bNUP3Rs3QvVEzdG/UDN0bNUP3Rs3QvVEzdG/UDN0bNUP3Rs3QvVEzdG/UDN0bNUP3Rs3QvVEzdG/UHLi7aNmXf7522c+mj/t6b5g+cH9OTuWfr82pnkwf9zXHMn3c1xzL9HFfcyzTZ+jp4/p7y/RxX+9zqc/pt+Vk+riv95bp4/p7y/Rx/b1h+sD9OZbpA+9aw/SBd61h+sC71jB94F1rmD7wrjVMD71rA/fnWKaH3rVh+nNeE4XpxHlP9OOdePos5X+/dn8NsW/ryfQz9PRL2OnLVJ8hqEz7/v7qdfq738Vft+J01bpCan3PX8Dnr+Dzb+Dz79jz/7pNx33+uDvdNn/crW6bH3Ovv+fH3NXv+cH3bwXfvxV8/1bw/VvB9+8Gvn838P27Bd6/6TVFSZdZrazPrFbW7TirbYF3tbvWwHv9O62+797ZAvuFrlwC+5CuXAL7m65cAvumrlwC+7GeXPbAPq8rl8D+sSuXYXypM5dhPKwzlywuh1zkd4+5yO8ec5HfPeYiv3vMRX73iMsyye8ec5HfPeYiv3vMRX73mEsWl0Mu8rvHXOR3j7nI7x5zkd895iK/e8glye8ec5HfPeYiv3vMRX73mEsWl0Mu8rvHXOR3j7nI7x5zkd895iK/e8hllt895iK/e8xFfveYi/zuMZcsLodc5HePucjvHnOR3z3mIr97yGVh9C/XzZvLwuhfLFwY99F1a+KyMO4jCxfGfWThwriPLFwYn78YuGTG5y8WLoz+5bqnacmM/sXChfH5i4VLFpdDLpR+18CF0u8auFD6XQOX8f3uW+v4HvaldR3Gl37xneetPB+UzFstH995+yAzjDN1JzOMN3UnM4w7dSeTReaEzDAO1Z3MMB7VncwwLvUbMnuenzPv63pCZhif6k5mGFfrTaZQemATGUoPbCJD6YFNZCg9sIlMJiSzTOn5xcu0pBMyjB7YRobRA9vIMHpgGxlGD2wjw+iBTWQi3xXpTIbRAy/T/px5SVM9IcPogW1kGD2wjUwWmRMynB7YQobTA1vIcHpgCxlOD1zWN5ntDzL/+9V7fv5Dwx9PLB4/5U2R0y87U4x8MwiIIqUPT6+38CxpXY5f68a5ieROhtKHm8hkkTkhQ+nDTWQofbiJDKUPN5Gh9OGfZMrJc8VxLi95kxnn9pI7GU4PvKcnmXnKJ2Q4PbCFDKcHtpDJInNChtMDW8hwemALGU4PbCHD6YE/yKT5hAynB74mk8e5x+ROhtIDz+srHcxlOSFD6YFNZCg9sIlMFpkTMpQe2ESG0gObyFB6YBMZSg/8SaamEzKUHthCZpwbTe5kKD3wkp6fsVoelE7IUHpgExlKD2wik0XmhAylBzaRofTAJjKUHthEhtIDf5JZTp7pjXO1yZvMOHeb3MlgeuD3/JhO9T1/YD85z8/vXOalXvzNnOfnyHM+bqnOka8buWsN7PnctQZ2ce5aA/syd62BnZa71sDe6Tut67OFeK7HbbV5CeyG3LUG9jfuWgN7IXetw/gmg9ZMpHUY32TQGtk3ba/sMm/lOLtEvmplmj+yvynPoz9lSdPF37UtP794O/M3kS9KeWuNfCXKXWtkf+OtNbK/8dYa2d94a81EWiP7G2+tkf2Nt9bIXshbK5FvinzFyFtr5CtG7lqJfFPkS0PuWol8U+RrQO5aiXxT5Is97lqJfFPkqzruWol8U+TLN+5aiXxT5Os07lqJfFPkCzLuWol8U+QrL+5aR9mvy/7srF32fKw18lUNd62jvA7n9PzinE7+Dke+YuCudZTXYYvWUV6HLVpHya8WraPkV4vWUfZrLs/3IeXt5H1IkZv13bWOkl8tWkfJrxatw/gmg9ZMpHUY32TQiumb3vNjeqH3/Jj+5j0/pmd5zR+5sXxZXu/9XrLD540id5C7aw3sQ9y1BvYh7lozkdbAPsRda2Af8p3W68/gRO7bdtca2N+4aw3shZy1rpFbrt21DuObDFqH8U0GrcP4JoPWjKF1zYc5bY3c6WyaH8TfnM4f2LPk9/z5j2t2n/MH9iGm+SN7i215zb8tF69VKU3PmVOaP1py8/xWG7k/+Aa1kf2Fv9rIDsNfbWSP4a82U6mN7En81UZ2MP5qIz+j8Vcb+SmNv1oqLxW5h/YGtVReKnIT7Q1qqbxU5ObaG9RSeanI7bU3qKXyUpEbbG9QS+WlIrfY3qCWyktFbrK9QS2Vl4rcZnuDWiovFbnR9ga1VF4qclvuDWqpvFTkxtwb1FJ5qcituTeopfJSkZtzb1BL5aUit+feoJbKS0Vu0L1BLZWXityie4NaKi8VuUn3BrVUXipym+4Naqm8VORG3RvUUnmpyK26N6il8lKRm3VvUEvlpSK3696glspLRW7YvUEtlZeK3LJ7g1oqL1WovFTkDmV/tZFblG9QS+WlKpWXityRfYPaTKWWyktFbsq+QS2Vl4rcln2DWiovFbkx+wa1VF4qcmv2DWqpvFTk5uwb1FJ5qcjt2TeopfJSkZu5b1BL5aVCt377q6XyUqGbv/3VUnmp0O3f/mqpvFToBnB/tVReKnQLuL9aJi9VQjeB+6tl8lIldBu4v1omL1WmTKWWyUuV0G3j/mqZvFSJ3GR+g1oqL0XVe16oes8LVe95oeo9L1S954Wq97xQ9Z4Xqt7zQtV7Xqh6zwtV73mh6j0vVL3nhar3vFD1nheq3vNC1XteqHrPC1XveaHqPS9UveeFqve8UPWeF6re80LVe16oes8LVe95oeo9L1S954Wq97xQ9Z4Xqt7zQtV7Xqh6zwtV73mh6j0vVL3nhar3vFD1nheq3vNC1XteqHrPC1XveaHqPS9UveeFqve8UPWeF6re80LVe16oes8LVe95oeo9L1S954Wq97xQ9Z4Xqt7zQtV7Xqh6zwtV73mh6j0vVL3nhar3vFD1nheq3vNC1XteqHrPC1XveaHqPS9UveeFqve8UPWeF6re80LVe16oes8LVe95oeo9L1S954Wq97xQ9Z4Xqt7zQtV7Xqh6zwtV73mh6j0vVL3nhar3vFD1nheq3vNC1XteqHrPK1XveaXqPa9UveeVqve8TplKLZOXqlS955Wq97xS9Z5Xqt7zStV7Xql6zytV73ml6j2vVL3nlar3vFL1nleq3vNK1XteqXrPK1XveaXqPa9UveeVqve8UvWeV6re80rVe16pes8rVe95peo9r1S955Wq97xS9Z5Xqt7zStV7Xql6zytV73ml6j2vVL3nlar3vFL1nleq3vNK1XteqXrPK1XveaXqPa9UveeVqve8UvWeV6re80rVe16pes8rVe95peo9r1S955Wq97xS9Z5Xqt7zStV7Xql6zytV73ml6j2vVL3nlar3vFL1nleq3vNK1XteqXrPK1XveaXqPa9UveeVqve8UvWeV6re80rVe16pes8rVe95peo9r1S955Wq97wO0xa9zc8v3uY/v/Nb6yj7x6J1lFeoLZfnyLmeaB3l9cmidZRXJ4PWYXqELVpHSXkWrZgZ7z0/5s58zx94D67L/PrifbpyOOu8Px3OWj++d/782xY4h92gNnAOu0FtYJdzg9rAPucGtYGdjrvaLXLP7w1qA7udG9QG9js3qA3sjm5Qm6nUMnmpLXLP7w1qmbzUFrnn9wa1VF4qcs/vDWqpvFTknt8b1FJ5qcg9vzeopfJSkXt+b1BL5aUi9/zeoJbKS0Xu+b1BLZWXitzze4NaKi8VuR31K7XX73XZInejemuN3J75ndbL9wlskbsz3bWO8upk0ZqJtI6S8ixaMTPee37MnfmeP/AerHN6fvFjy138Xcul/vPFf7yH6Y+/a4FTmLfWyJ2W7loD+xt3rYH9jbvWwP7GXWsm0hrY37hrDexv3LUG9kLuWol8U+QGS2+tkfsr3bUS+abI3ZXuWol8U+TeSnetRL4pcmelu1Yi3xS5r9JdK5FvitxV6a6VyDdF7ql010rkmyJ3VLprJfJNkfsp3bUS+abI3ZTuWol8U+ReSnetRL4pcielu1Yi3xS5j9JdK5FvitxF6a6VyDdF7qF010rkmzYi37QR+aaNyDdF7lF115qJtBL5po3IN0Xux3XXSuSbIvfjemuN3I/rrpXIN0Xux3XXSuSbIvfuumsl8k2RO3fdtRL5psh9u+5aeXzTHrlr110rj2/aI/fsumvl8U37lIm08vimPXK/rrtWHt+0R+7WdddK5Jsi9+q6ayXyTZE7dd21EvmmyH267lqJfFPkLl13rUS+KXKPrrtWIt8UuUPXXSuRb4rcn+uulcg3zZlIK5Fvmol8U+T+Z3etRL5pJvJNC5Fvitzr7a6VyDdF7vV215qJtBL5psi93u5aiXwTUV/4TtQXvhP1he9EfeE7UV/4TtQXvhP1he9EfeE7UV/4TtQXvhP1he9EfeE7UV/4TtQXvhP1he9EfeE7UV/4TtQXvhP1he9EfeE7UV/4TtQXvhP1he9EfeE7UV/4TtQXvhP1he9EfeE7UV/4TtQXvhP1he9EfeE7UV/4TtQXvhP1he9EfeE7UV/4TtQXvhP1he9EfeE7UV/4TtQXvhP1he/DdC0/vuI58pxPtI6ycyxaR3lt2nJ5jpzridZRXpsMWofp5LVoHSXTWbSOkuksWjEz3Xt+zJ35nj/wHtzW52or+1Yu/q7NS11ec2z7xxzzh9rA6esGtYHz1w1qA7ucG9QG9jneaucpcovuDWoDe50b1AZ2OzeoDex3blCbqdQSeamHWiIv9VBL5KUeaom81EMtlZeK3Kx7g1oqLxW5XfcGtVReKnLD7g1qqbxU5JbdG9RSeanITbs3qKXyUpHbdm9QS+WlIjfu3qCWyktFbt29QS2Vl4rcvHuDWiovFbl99wa1VF4qcgPvDWqpvFTkFt4b1FJ5qchNvDeopfJSkdt4b1BL5aUiN/LeoJbKS0Vu5b1BLZWXitzMe4NaKi8VuZ33BrVUXipyQ+8Naqm8VOSW3hvUUnmpyE29N6il8lKR23pvUEvlpSI39t6glspLRW7tvUEtlZeK3Nx7g1oqLxW5vfcGtVReKnKD7w1qqbxU5BbfG9RSeanITb43qKXyUpHbfG9QS+WlIjf63qCWyktFbvW9QS2Vl4rc7HuDWiovFbnd9wa1VF4qcsPvDWqpvFTklt8b1FJ5qY3KS21UXipyY/UNaqm81EblpTYqLxW5kfwGtVReKnIr+Q1qqbxU5GbyG9RSeanITeY3qKXyUky95w+1VF6Kqff8oZbJSyWq3vNE1XueqHrPE1XveZoylVomL5Woes8TVe95ouo9T1S954mq9zxR9Z4nqt7zRNV7nqh6zxNV73mi6j1PVL3niar3PFH1nieq3vNE1XueqHrPE1XveaLqPU9UveeJqvc8UfWeJ6re80TVe56oes8TVe95ouo9T1S954mq9zxR9Z4nqt7zRNV7nqh6zxNV73mi6j1PVL3niar3PFH1nieq3vNE1XueqHrPE1XveaLqPU9UveeJqvc8UfWeJ6re80TVe56oes8TVe95ouo9T1S954mq9zxR9Z4nqt7zRNV7nqh6zxNV73mi6j1PVL3niar3PFH1nieq3vNE1XueqHrPE1XveaLqPU9UveeJqvc8UfWeJ6re80TVe56oes8TVe95ouo9T1S954mq9zxR9Z4nqt7zRNV7nqh6zxNV73mi6j1PVL3niar3PFH1nieq3vNE1XueqHrPE1XveaLqPU9UveeJqvc8UfWez1S95zNV7/k8TFv0Nj+/eJv//M5vraPsH4vWUV6htlyeI+d6rHWYLmGL1lFenSxaR8l5Fq2jpDyL1gyp9T0/5s58zx93D9Zprv98cZ0+Pctf/12Lm8L8tcbNYP5a4/obd62B+339tcb1N/5a4/obf61x/Y2/1kykNa4X8tdK5JsCN/r6ayXyTYHbfN21Bu7y9ddK5JsC9/j6ayXyTYE7fP21EvmmwP29/lqJfFPg7l5/rUS+KXBvr79WIt8UuLPXXyuRbwrc1+uvlcg3Be5z/U7rsj//UXLZT96vErjN1V1r4L7P77Tm9Pw7nNPJ3+HAbZ/+Wkd5HbZoHeV12KJ1lPxq0TpKfrVoHWW/5vL84rwtJ1pH2a8GrYH7Pf21jpJfLVqH8U0GrcP4JoPWTKR1GN9k0DqMbzJoHcY3GbQS+abAbZ7uWgN3efprxfRN7/kxvdB7/sD+5vEtnvOnfDZ/Bp8/sA9J8/6af5/+0/wcPXAfpr/WwD7EXWtgH+KuNbAP8dYauAfTX2tgH+KuNbBncdca2d94a81EWol8U+DuS3+tRL4pcO+lv1Yi3xS489JfK5FvCtx36a+VyDcF7rr010rkmwL3XPprJfJNgTsu/bXy+KYlcL+lv1Ye37RMPL5pmXh80zJlIq2j7Nfrz0Us0yj71aA1cI/nd1qv32e9BO7x9Nc6yuuwResor8MWraPkV4vWUfKrReso+/X6PW9L5H5Qd62j5FeD1sj9oO5ah/FNBq3D+CaD1mF8k0FrJtI6jG8yaB3GNxm0EvmmyP2g7lqJfFPkftB/0fqeH9MLvecP7G/mPD/nn/NyMn9gz2KaPwee/3Xiqs61OvyuB/Yh7loD+xB3rYF9iLvWwD7EXWtgH+KtNXLfprvWwJ7FXWtkf+OtNbIX8taaibQS+aZM5JsykW+K3KPqrpXIN61Evmkl8k2R+3HdtRL5psj9uO5aiXxT5B7Vr7Qa3rcZuUfVW2vkvs3v/g5fvw8sct+mu9ZhXocNWod5HTZoHSa/GrQOk18NWonya+S+TW+tkfs23bUS5dfI3ZzuWonya+TOT3etmL7pPT+mF3rPj+lv3vNjepb3/IF9yPKyjHWZr7qw5/k58nz2GePIfZvuWgP7EHetgX2Iu9bAPsRdaybSGtiHfKd1fXquuZ54rsh9m+5aA/sbd62BvZC71mF807XWyH2b7lqH8U0GrcP4JoNWEN+0lOOcFrlD0zQ/iL85nT+yZ9mn1/x7Opk/sg+xzB/ZW9T0nP/xr1z/aX4mGbmT0llrjtxJ6a41srfw1hrZW3hrjewtvLVmIq2RPYu31sj+xltrZC/krZXHN+WJyDclIt8UuUPWXSuRb4rcIeuuNRNpJfJNkTtk3bUS+abIHbLuWol8U+Su0a+0Xn+uKUfuGnXXOszr8OXnJHLkTkp3rcO8Dhu0DvM6fK01cielu9Zh8qtBK1F+jdyL6a41E2klyq+ROzTdtRLl18gdmu5aifJr5A5Nd61Ez/0jd2i6ayXyTZE7NN21Yvqm9/yYXug9f2B/k+urpz9/vkf7j/kDexbT/IF9SF5fnwXO+9b+ux65k9Jda2Af4q41sA9x1xrYh7hrzURaA/sQd62BPYu71sj+xltrZC/krZXINxUi31SIfFPkDll3rUS+KXKHrLtWIt8UuUPWXSuRb4rcIeuulcg3Re6Qddc6yn41vG8zcteou9ZhXoev3wcWuRfTXeswr8PXWiN3aLprHSa/GrQOk18NWonya+QOTXetRPk1coemu1ai/Bq5Q9NdK1F+jdyh+S9a3/NjeqH3/Jj+5j0/pmd5z5/jzr/m53eu63p1U+S6yztH7rp01xrYh7hrDexD3LUG9iHuWgP7EGeta+S+ze+0XnY+r5H7Nt21BvY3/6L1PX9gf2OaP8edv0zPKWpJm8NrSGB/4641sL9x1xrY37hrDexv3LUG9jfeWiP3Yn6n9XrnR+7FdNca2N+4aw3shdy1ZiKtw/gmg9ZhfJNBK6Zves+P6YXe80f2N+vrc9tlny7+rpXX37Wybsd/1+bI/sZba2R/85XWPL2+83Lxnc+neHOJ7IV6consm3pyyeJyyCWyH+vJJbJ368klss/rySWyf+zJZRhf6sslcvdvVy7yu8dc5HePucjvHnPJ4nLIRX73mIv87jEX+d1jLvK7x1zkdw+5RO5s7spFfveYi/zuMRf53WMuWVwOucjvHnOR3z3mIr97zEV+95iL/O4hl8jd4F25yO8ec5HfPeYiv3vMJYvLIRf53WMu8rvHXOR3j7nI7x5zkd895BK5070rF/ndYy7yu8dc5HePuWRxOeQiv3vMRX73mIv87jEX+d1jLvK7h1wid/F35SK/e8xFfveYi/zuMZcsLodc5HePucjvHnOR3z3mIr97zEV+95BL5JsnXbnI7x5zkd895iK/e8wli8shF/ndYy7yu8dc5HePucjvHnOR3z3kEvlWTVcu8rvHXOR3j7nI7x5zyeJyyEV+95iL/O4xF/ndYy7yu8dc5HePuJTIN5G6cpHfPeYiv3vMRX73mEsWl0Mu8rvHXOR3j7nI7x5zkd895iK/e8gl9I2snlzkd4+5yO8ec5HfPeaSxeWQC6N/Wfbln69d9jMujP7FwIXy/lFO5Z+vzamecGHcRxYujPvIwoVxH1m4MD5/sXBhfP5i4cLoX3J53inM23LChdG/WLgwPn8xcKG8f2ThQul3DVwo/a6BC6XfNXDJ4nLIhdLvGrhQ+l0DF/ndYy7yu8dc5HcPuRDcP3prHd/DvrUO40u/+M6p1PmfL37858fMU/0gM4wzdSeTReaEzDDu1J3MMP7UncwwDvUbMnV5fvHjP/cTMsN4VHcyw7jUr8ik6UVm+/O36X+/et2f33ndPyim6U1xnBtHXSkO45a7UqT04e4UKT27O8Usig4UKbOAO0XK3OBOkTNjeFPkzCPeFJVdHCiOc6+qK0VlFw+Kyi4eFJVdPChmUXSgqOziQVHZxYOisosHRWUXD4rKLg4Ux7kldR/Fl8D182v/oCi/6EFRO9rjN1o72oOidrQHRe1oB4rj3EvqSlHPF0/e9TbOfSV3MvJ1Z2QyI5lter2HdMtnZCif15nIUPp7ExlKz769lvbjP0/eXTvOrSV3MpTeequv3bQv83+aXeE4t5m6UqT01u4UKX24O0VKz+5OMYuiA0XOLOBNkTM3eFPkzBjeFDnziDdFZZd2inWcO1tdKSq7eFBUdvGgqOziQTGLogNFZRcPisouHhSVXTwoKrt4UFR2caA4zs20rhTlFy8pXr7vuI5zX6srRe1oj99o7WgPitrRDhRn7WgPinq+6EFRzxf/pPgmIw94RiaLzAkZymd7++s7p31LJ2Qon9eZyFD6exMZRs8+T8v+nHnK0wkZRh9uIjPOzbqvyKT0IlPzf5pd4TgX7rpSZPTW/hQZfbg/xSyKDhQZ/b0/RcYs4E+RMTf4U+TMGN4UOfOIM8Vx7g92pajs4kFR2cWDorKLB8Usig4UlV08KCq7eFBUdvGgqOziQVHZxYEi5Z1Jf4rKLh4UlV08KCq7eFDMouhAUdnFg6KyiwdFZRcPisouHhSVXRwoUt6Z9Keo7OJBUdnFg6KyiwfFLIoOFJVdPCgqu3hQVHbxoKjs4kFR2cWBYlV28aCo7OJBUdnFg6KyiwfFLIoOFJVdPCgqu3hQVHbxoKjs4kFR2cWBIuX9XX+Kyi4eFJVdPCgqu3hQlF+8pHjdm0p5+9WdIuUdT/ffaMo7nv4UtaM9KGpHe1DMouhAUc8X/6T4JiMPeEZGvu6MDOezvX15zpzmMzKcz+uuyWyUty5tZCg9e/ogs5+RofThJjKU3jqVp755nvf/XLjC1xhr/eh9XvMHxSyKDhQpvbU7RUof7k6R0rO7U6T09+4UKbOAN0XKO5P+FDkzhjdFzjziTVHZxYNiFkUHisouHhSVXTwoKrt4UFR28aCo7OJAkfL+rj9FZRcPisouHhSVXTwoZlF0oKjs4kFR2cWDorKLB0VlFw+Kyi4OFDnvG7tTVHbxoKjs4kFR2cWDYhZFB4rKLh4UlV08KCq7eFBUdvGgqOziQJHzvrE7RfnFS4qXvQYb501Zd4ra0ZcULz8FvXHe8XSnqB3tQJHzjqc7RT1f9KCo54t/UnyTkQc8I5NF5oSMnu2dkaF8XjfX9T1zuni1znt5vlpP+3Eu5byL6U6RMgu4U6TMAt4UOe9iulOkzALuFCmzgDtFytzwFcWPJ/Cf3/kPilkUHShS5hF3isouHhSVXTwoKrt4UFR2caDIeRfzbymevdeA8y6mO0VlFw+Kyi5/UnyTySJzQkYZ44yMcsMZGcossLzJ5FQuXq3Tm+PjPz+/+vP1mjIN3MCRMg/4c+S8NnkDR8pM8B3HZZ2eHJc1nXCkTAU3cKTMBV9ynOcXx339g+NBFrt+Z96WxfznzCmzTGfmlCmpM3Plr98zV1b7PXPlup8z57xm3Jm58uLvmStb/p65cujvmWcx/zlz5dDfM1cO/T1z5dDfM1cO/T1z5dBfM985r253Zq4c+nvmyqG/Z64c+nvm8ufOzC+7x3bOm9J9mXNe/e372sJ5I7gzc/mW3zOXb/k98yzmP2eu5+ctzN8c5bl9OMpH+3DUs+tLjjk9Faa8nnHU82gXjpxXjm/gqPx1yXFNr88NramccFSm8uGonHT9e73VF8d1+4PjwfdO9fkpo3ku9eOrlw/qWdQ7UFdW6kFdyaoHdeWwHtSV2npQV8brQJ3zdnR36sqPPagrbfagrmzag3oW9Q7UlU17UFc27UFd2bQHdWXTHtSVTTtQ57wN3p26smkP6sqmPagrm/agnkW9A3Vl0x7UlU17UFc27UFd2bQHdWXTDtRXZdMe1JVNe1BXNu1BXdm0B/Us6h2oK5v2oK5s2oO6smkP6sqmPagrm3agXpRNe1BXNu1BXdm0B3Vl0x7Us6h3oK5s2oO6smkP6sqmPagrm3agXuXXfakbumKr3Prvmcu/ODO/7nOsci+/Zy7v8nvmci6/Z65n6j9nvumJegvzN0d5bh+O8tE+HPUc24djFscrjmV+zpHKVi52Ut7LcydNHztp/WSuXPd75sp1v2euXPd75sp1v2euXPdz5rty3e+ZKwP6Ml9fQ6+fc/zBXHnx98yVLX/PPIv5z5krh/6euXLo75krh/6euXLobcxrOmGuHPpj5ss0KYf+nrlyaAvzN0dlSx+OyouXHOu0PznWdb94DUhbfl1o3f645Lh8UM+i3oG6MmMP6kqNPagrN/agruTYg7qyozf19fXuq61Ox9ST0mMP6sqPPagrbfagrmzag3oW9Q7UlU2dqddte1Hf/nSOf/XkNinHRv8/pMwb/f+Q8rHz/6G9vL563+aT3aJ83IH6rHzcg7rycQ/qysc9qCsf96CeRb0DdeVjb+pbflHf6wl1Zd4e1JVje1BXNu1BXdm0A/VF2bQHdWXTHtSVTb2pp9f3fvzL+B/U/+qp8KIcG/3/UNb/oeD/h5SPff8PzdP++t5p2k52i/JxD+rKxz2oKx/3oK583IF6Vj7uQV35uAd15WNn6im97sCkeTmhrszbg3oW9Q7UlU17UFc27UFd2bQHdWXTHtSVTb39ek4v6suffv2vngqvyrHR/w8p80b/P6R87Px/aJ5fPB4/53i3rMrHPahnUe9AXfm4B3Xl4x7UlY97UFc+7kFd+dib+rK/qK8nnxQqyrw9qCvH9qCubNqDurJpD+pZ1DtQVzbtQV3Z1Pvfs+rr37Pm8qdf/6unwkU5Nvr/IWXe6P+HlI///D/0IlOVYc/IUObMnJ9fPK9TuvqtntKrtW9aPn/31g+OlMnxBo6UWfAGjlkcXThS5rUbOFImsBs4UuakLzmurxaL6dNX/8GRMs3cwJEyc/hz3CgTyg0clWd8OCrP+HBUnrnm+PpUbfrjU7V/cMzi6MJRecaHo/KMD0flGR+OyjM+HJVnLjmmZXlxzOWY464848NRecaHo/KMD0flGR+OWRxdOCrPXHPcXxzn6Yyj8owPR+UZH47KMz4clWc8OKZJecaHo/LMJce5pBfHmk84Ks/4cFSe8eGYxdGFo/KMD0flGR+O4+eZt9bxM8dbK2YueM2fMP34e/7APrguz88l1bqtV3/X8vT6zsvFdzb8vUyBfW1XLoF9alcuWVwOuQT2kV25BPaFXbkE9nlduQT2hF25BPaPPbnMgX1pVy7yu8dc5HePucjvHnPJ4nLIRX73mIv87jEX+d1jLvK7x1zkdw+5LPK7x1zkd4+5yO8ec5HfPeaSxeWQi/zuMRf53WMu8rvHXOR3j7nI7x5yiXzJvisX+d1jLvK7x1zkd4+5ZHE55CK/e8xFfveYi/zuIZfIF4xv47K8Ppi07GdcGP2LhQvjPsqp/PO1OdUTLoz7yMKFcR9ZuDDuIwsXxucvFi6Mz18MXCJfo7yPS6lPLttywoXRv1i4MD5/sXBhfP5i4ZLF5ZALpd81cKH0uwYu4/vdt9bxPexb6zC+9IvvnLZ3E9322US3pDeZyDfmOpMZxpu6kxnGnbqTGcafupPJInNCZhiP6k5mGJf6FZmXTU3bNp2QGcanupMZxtW6k+H0wAYyka+YdSbD6YEtZDg9sIUMpQfeX9857Xk5IZNF5oQMpQc2kaH0wCYylB7YRIbSA5vIUHpgC5nIl69uIzNP02vm6Y/3bnySYfTANjKMHthGhtED28hkkTkhw+iBbWQYPbCNDKMHnqeXvnkq2wkZRg9sI8PogS1k5sjXkjqT4fTAFjKcHthChtMDW8hkRjLp9Z3ndPIUYo58R6gzGUoPbCJD6YFNZCg9sIkMpQe2kIl8oagzGUwP/J4f06m+5w/sJ7dpf86/zfPF38x5flnEfPx50TnyfSB3rYE9n7vWwC7OXWtgX+auNbDTctca2Dt9p3V9vpltrsefG5sj38X5F63v+QN7FtP8gT3LltfX/OvW/nsV+XaMu9ZMpDWyv/HWGtnfeGuN7G+8tUb2N19pNez8yP7GWWvkOyjuWiN7IW+tw/gmg9ZhfJNBaybSiumb3vNjeqH3/Jj+5j0/pmd5z4/pQ17zR745YZof0y+858f0AO/5Mff6e37MXf2eH3z/Rr4xYJoffP9m8P2bwfdv5JsJpvnB9+8Kvn9X8P0b+QaEaX7w/Rv5poJpfvD9G/lGgWn+yPt3e71fbduv3on4b1/9Uhv5QsANaiPv9m/U7q+R98/3LX4+x4zc5e+uNbJn8NaaibRG8SLviaK4i/dEUfzCe6IoDuA9UZSd/pooTP/5e6Iou/E9UZQN9p4oyp55TxRlG7wnCveaHabP+T1RuNfsMP3F74nCvWaH6et9TxTuNTtMP+17onCv2WH6WN8ThXvNDtM/+p7oztfs90/ZfvJT9l/8lFu7Hd8/Jf3kp8w/+SnLT35K/slPWX/yU8pPfspPfvf3n/zu77/43V+m6Sc/Jf3kp8w/+SnLT35K/slPWX/yU8pPfkr9yU/ZfvJTfvK7n37yu59+8ruffvK7n37yu59+8ruffvK7n37yu59+8ruffvK7n37yuz//5Hd//snv/vyT3/35J7/7809+9+ef/O7PP/ndn3/yuz//5Hd//snv/vKT3/3lJ7/77Z9kXF5fOy91+s+/P3+6/rfwpf3zhu4T5XATrcEmyuNcAP/i4v2yP4+sLvvx09Q8zv1vZy7DNF47cxmm79qZyzBt185csrgcchmm6dqZyzA9185chmm5duYyTMe1Mxf53UMu49z6/oJLXtI/X5tzOeHC6Hfz/OZST7gw+l0LF0a/a+GSxeWQC6PftXBh9LsWLox+N6fy5JLOuDD6XQsXRr9r4DLOXW9nLpR+18CF0u8auFD6XQOXLC6HXCj9roELpd81cJHfPeYiv3vMRX73iMs6zg1vZy7yu8dc5HePucjvHnPJ4nLIRX73mIv87jEX+d1jLvK7x1zkdw+5jHOv25mL/O4xF/ndYy7yu8dcsrgccpHfPeYiv3vMRX73mIv87jEX+d1DLpEvsnflIr97zEV+95hLYP9S1ufbA2vZpysuX3zneamvTxU/GL2/eqoHX/1Q8jxSmtbPKxVTPvjq9YVj3T5opOmDeWBvNCzzwL5rWOaBPd2wzAP7xVGZL4G9KCTzMj2/uHz6lj+YB/a5oMyXF/PthHlgDz0s88DPo4dlnsX858yVQ3/PXDn098yVQ539+f6cY933E+bKob9nrhz6c+ZZOfT3zJVDf89cOfT3zJVDf888i/nPmSuH/p65cujvmSuH/p65cujvmSuH/pz5qhz6e+bKob9nrhz6e+bKob9nnsX858yVQ3/PXDn098yVQ3/PXDn098yVQ3/OvCiH/p65cujvmSuH/p65cujvmWcx/zlz5dDfM1cO/T1z5dDfM1cO/T1z5dCfM498W3tY5sqhv2euHPp75vLnl8yXeX4yX/b1ivn15/0j36Yelrn8+e+Zy5//nrn8+c+ZR74FDsnc8DnoyHfGh2Uuf/575vp3ot8zz2L+c+bKob9nrhzq7BWvn7dEvkc/LHPl0N8zVw79OfNdOfT3zJVDf89cOfT3zJVDf888i/nPmSuH/p65cujvmSuH/p65cujvmSuH/pp5mZRDf89cOfT3zJVDf89cOfT3zLOY/5y5cujvmSuH/p65cujvmSuH/p65cujPmSfl0N8zVw79PXPl0N8zVw79PfMs5j9nrhz6e+bKob9nrhz6e+bKob9nrhz6c+azcujvmSuH/p55ZmSeyov5PO8XzK8/TV5mSsftTpHSQ7tTpHTF7hQpfa47RUrn+hXFx7+mPr9zqscUF0ov+iXFq09Ol4XSXbpTpPx3C3eKlP8S4U4xi6IDRWUXD4rKLpd+8fppxKLs4kFR2cWDorKLA8Ws7OJBUdnFg6KyiwdFZRcPilkUHSgqu3hQVHbxoKjs4kFR2cWDorKLA8VV2cWDorKLB0VlFw+Kyi4eFLMoOlBUdvGgqOziQVHZxYOisosHRWUXB4pF2cWDorKLB0VlFw+Kyi4eFLMoOlBUdvGgqOziQVHZxYOisosHRWUXB4pV2cWDorKLB8XMSHFKz+88TzVfUbz+HGCl9IvuFCn9ojtFSr/oTpHSL7pTpPSLX1E0fD56o/SLX1K8/ATbRukX3SlSPut2p0j5rNudYhZFB4rKLh4UlV0u/eL104hN2cWDorKLB0VlFweKu7KLB0VlFw+Kyi4eFJVdPChmUXSgqOziQVHZxYOisosHRWUXD4rKLu0UK+fNeHeKyi4eFJVdPCgqu3hQzKLoQFHZxYOisosHRWUXD4rKLh4UlV0cKHLeGXenqOziQVHZxYOisosHxSyKDhSVXTwoKrt4UFR28aCo7OJBUdnFgSLnbWp3isouHhQzIcW01emfL077Ml9RvPwcYKW8H+1PkdEv+lNk9Iv+FBn9oj9FRr/4HcXrz0dXyvvR31K8+gRbpbwf7U+R8Vm3P0XGZ93+FLMoOlBUdvGgqOxy6Revn0ZQ3o/2p6js4kFR2cWBIuX9aH+Kyi4eFJVdPCgqu3hQzKLoQFHZxYOisosHRWUXD4rKLh4UlV0cKFLej/anqOziQVHZxYOisosHxSyKDhSVXTwoKrt4UFR28aCo7OJBUdnFgSLl/Wh/isouHhSVXTwoKrt4UMyi6EBR2cWDorKLB0VlFw+Kyi4eFJVdHChS3o/2p6js4kExM1Ks6UWxfn62728/B0h5P9qfIqVfdKdI6RfdKVL6RXeKlH7xK4qGz15R3o/2p0jpF90pUj7rdqdI+azbnWIWRQeKyi6XTuc6R1Pej/anqOziQVHZxYOisosDRcr70f4UlV08KCq7eFBUdvGgmEXRgaKyiwdFZRcPisouHhSVXTwoKru0U9wo70f7U1R28aCo7OJBUdnFg2IWRQeKyi4eFJVdPCgqu3hQVHbxoKjs4kCR8n60P0VlFw+Kyi4eFJVdPChmUXSgqOziQVHZxYOisosHRWUXD4rKLg4UKe9H+1Mcxi/m6fWdl4vvvOzP97sv+59TvLlkcTnkMoync+YyjEtz5jKM73LmMoyTcuYyjDfy5TLO9WNnLsM8e3XmMszTVGcu8rvHXDIhl7w8v3HO5YQLo9/N85tLPeHC6HctXBj9roULo9+1cGH0uwYu41zMdebC6HdzKk8u6YwLo9+1cGH0uxYuWVwOuVD6XQMXSr9r4ELpdw1cKP2ugQul373mMs6VVWcu8rvHXOR3j7nI7x5zyeJyyEV+95iL/O4xF/ndYy7yu8dc5HcPuYxzmdOZi/zuMRf53WMu8rvHXLK4HHKR3z3mIr97zEV+95iL/O4xF/ndQy7jXHN05iK/e8xFfveYi/zuMZcsLodc5HePucjvHnMJ7F/y+nwbf837dsHF8J7/yBcD3bUG9hnuWgN7B3etgf2Au9ZMpDXw3nbXGngXu2sN/DzJXWvgZ0TuWol8U+RrZV9pNXz+MfJNse+0Xn+2JvLlL3eto/gmi9ZMpHUU32TROopvsmgdxTcZnsFEvu7krnUU33StdY98Kcld6zC+yaB1GN9k0DqMbzJozURah/FNBq3D+CaDVh7ftEe+LOOulcg3Rb7S4q6VyDdFvnjirpXIN0W+HuKulcg3Rb7E4a6VyDdFvmrhrpXIN0W+EOGulcg3zUS+KfJ9DnetmUgrkW+KfBvDXSuRb4p8w8JdK5Fvinxrwl0rkW+KfBPCXWvg/brU1+dbHkoutF6/H3GP3MXvrjXwfnXXGni/umsNvF+9tUbutnfXGni/umsNvF/dtQZ+LuGuNRNpJfJNkTvdv9J6/TmOPXJP+3daL98rvUfuXnfXOopvMmiN3JHurnUU32TROopvsmgdxTcZnsFE7hx31zqKb7JoHcY3GbQO45sMWofxTQatw/ima62Ru7bdtQ7jmwxah/FNBq1Evilyd7W7ViLfFLlj2l0rkW+K3AXtrpXIN0XubHbXSuSbIncru2sl8k2RO5DdtRL5pshdxe5aiXxTJfJNkXulvbVG7pV210rkmyL3SrtrJfJNkXul3bUS+abIvdLuWol8U+ReaW+tkfuH5/n1mZW51guthvcjRu4fdtcaeL+6aw28X921Bt6v7loD71d3rYH3q7vWwPvVXWvg5xK+WvMUuX/YXSuNb3poHcU3XX6O46F1FN90+V7ph9ZMpHUU32TROopvsmgdxTdZtI7imyxaR/FNl89g8hS5f9hd6yi+yaJ1GN9k0DqMbzJozURah/FNBq3D+CaD1mF8k0HrML7JoJXIN0XuH3bXSuSbIvcPu2sl8k2R+4fdtRL5psj9w+5aiXxT5P5hd61Evily/7C7ViLfFLl/2F0rkW9aMpFWIt8UuVfaXSuRb4rcK+2ulcg3Re6VdtdK5Jsi90q7ayXyTZF7pd21Bt6vad6fWtM+XWg1vB8xcv+wu9bA+9Vba+T+YXetgferu9bA+9Vda+D96q418H511xr4uYS71sDPJdy1EvmmyP3DX2k1fI4jcv/wd1qv3ysduX/YXesovsmidRTfZNE6im+yaM1EWkfxTYZnMJH7h921juKbLFqH8U0GrcP4pmutkfuH3bUO45sMWofxTQatw/gmg9ZMpJXIN0XuH3bXSuSbIvcPu2sl8k2R+4fdtRL5psj9w+5aiXxT5P5hd61Evily/7C7ViLfFLl/2F0rkW/aiXxT5F5pd61Evilyr7S71kyklcg3Re6VdtdK5Jsi90q7a+XxTSlyr7S71sD7dZrrU+vDt19ovX4/YpoC71d3rYH3q7vWwPvVXWvg/equNfB+ddcaeL96a43cP+yuNfBzCXetgZ9LuGsl8k2R+4e/0nr9OY4UuX/4O62X75VOkfuH3bWO4pssWkfxTRato/gmg9bI/cPuWkfxTYZnMJH7h921juKbLFozkdZhfJNB6zC+yaB1GN9k0DqMbzJoHcY3XWuN3D/srpXIN0XuH3bXSuSbIvcPu2sl8k2R+4fdtRL5psj9w+5aiXxT5P5hd61Evily/7C7ViLfFLl/2F0rkW/KRL4pcq+0u1Yi3xS5V9pba+ReaXetRL4pcq+0u1Yi3xS5V9pdK5Fvitwr7a417n4t2/p8i2HZt3KhdXsdKtnmk/cjBu4f9tcad7/6a427X/21xt2v/lrj7tcvta7P961t23T1nfP0mmK5+trTid8M4+5tHIZx/QAOw7jPZ3AYxn3ug8NwGL/bj2HgPmochsP4844Mh/H9HRkOkyc6Msxi2MxQOaWdoXJKO0PllHaGyintDJVTmhkG7n/HYaic0s5QOaWdoXJKO8Mshs0MlVPaGSqntDNUTmlnqJzSzlA5pZlh4F7+GAwNXXOB+/5xGGov//vXGt5PGbjHHoeh9nI7Q+3lVoZz4D5/HIZ6ftjOUP7wgmF5figib8sJQ/nDdoZZDJsZ6vlhO0PllHaGyintDJVT2hkqpzQzDHwXBYehcko7Q+WUdobKKe0Msxg2M1ROOeai7HHMhTJPfDHFvEz1pS99TJHnD4qUicKdImWm8KYY+GoQEkXKXOFOkTJZuFOkzBbuFLMoXlDM6aVvnU4oUuYLd4qUacSdorKLB0VlFw+Kyi4OFANf7kKiqOxyRbEuL33bfEJR2cWDorKLB8Usig4UlV08KCq7eFBUdvGgqOzyDcX9hKKyiwPFwNfzkCgOk13y8/MhWz75fEjgu3z+WofJAQatmUjrMJ7aoHUY52vQOow/NWgdxkUatA7j9a61Br7L56+VyDcFvsvnr5XINwW+y+evlcg3Bb7L56+VyDetRL5pnHuL11rHubdo0Erkm8a5t2jQSuSbxrm3aNBK5JvGuV9o0Erkm8a5B2jQSuSbxrmvZ9BK5JvGuVdn0Erkm8a5/2bQSuSbxrmnZtBK5JvGuU9m0Erkm8a592XQSuSbxrmfZdBK5JvGuUdl0Erkm8a572TQSuSbxrmXZNBK5Jt2It+0E/mmce5KGbQS+aY9E2kl8k3j3N8yaCXyTePcszJo5fFNyzj3oQxaeXzTMs69JYNWHt+0TJlIK49vWsa5B2TQyuOblnHu6xi0Evmmce7VGLQS+aZx7r8YtBL5pnHuqRi0EvmmcW6ZGLQS+aZxrogYtBL5pnEuchi0Evmmca5bGLQS+aZxLkUYtBL5pnGuLhi0EvmmcS4YGLQS+aZxrgEYtBL5pnGa9Q1aiXzTOC31Bq1EvmmcxneDVsou7C9uUC/7c4hlz8cMOZuwnRlS3vBxZkh5wceZIeX9HmeGWQybGVLe7nFmSHm5x5kh5d0eZ4aUV3ucGSqnNDMcpx/+JoaPf6b/52tzLicMlVMuGM5vhifPHMbps+/IUDmlnWEWw2aGyintDJVT2hkqp1wwTM9/C8jpjKFySjtD5ZRmhuPcY+jIUDmlnaFySjtD5ZR2hlkMmxkqp7QzVE5pZ6ic0s5QOaWdoXJKM8Nx7p90ZKic0s5QOaWdoXJKO8Mshs0MlVPaGSqntDNUTmlnqJzSzlA5pZnhOPeGOjJUTmlnqJzSzlA5pZ1hFsNmhsop7QyVU9oZKqe0M1ROaWeonNLMcJz7Xh0ZKqe0M1ROaWcY2B/W19vJyzYvVwznJ/BtPvlcXeR7WO5aA/std62BfZG71sD+xVlrjnwP6zutd72+l/p8fd+WE4aBfQYMw8A+A4Zh4OehMAyzGDYzHMbvdmQ4jI/uyHAYf96R4TC+vyPDYfJEP4aR78/BMFROaWeonNLOUDmlnWEWw2aGyintDJVT2hkqp7QzVE5pZ6ic0sww8r1HGIbKKe0Msxj+69dedwTnyPcRYRhqL1/8Ll++fyhHvvuHwjDyPUEYhtrL7Qz1/LCdoZ4ftjPMYtjqsSPfgYRhqOeH7Qz1/LCdoXJKO0PllGaGke+nwjBUTmlnqJzSzlA5pZ1hFsNmhsop7QyVU9oZKqccc1H2OOZCmSe+mCJN9fkPcGna5g9985ti5EunQBQpM4U7RcpU4U6RMle4U8yi6ECRMlu4U6RMF99QTNOTRUopn1CkzBfuFCnTiDtFZRcHipGvnwJRVHbxoKjs4kFR2eULinM6oZhF0YGisosHxWGyS36+a3LLJ++ajHyx1F3rMDnAoHUYt36tNfKlTnetwzhfg9Zh/KlB6zAu0qA1E2kdxpEZtBL5psgXFN21EvmmyBcJvbVGvhzorpXIN0W+xOeulcg3Rb5s566VyDdFvhTnrpXIN0W+vOaulcg3Rb5k5q6VyDdFvgzmrpXIN+2ZSCuRbxrnMptBK5FvGucym0Erj29ax7nMZtDK45vWcS6dGbTy+KZ1ykRaeXzTOs4lLoNWHt+0jnPZyqCVyDeNcynKoJXIN41zecmglcg3jXPJyKCVyDeNcxnIoJXIN41zaceglcg3jXO5xqCVyDfNRL5pJvJN41z4MWgl8k0zkW+aiXzTOJeQDFqJfNM4l4UMWol8ky6kXHzt9fW3VRdSHBiqebidoZqH2xmqpbidoS6kNDPUhRQHhrqQ0s5QF1LaGepCSjvDLIbNDJVT/v1r8/L8vjmXE4bKKRcM5zfDk2cOupDiwFA5pZ2hckozQ867K84MlVPaGSqnXDC8vJa+cl5ccWaYxbCZoXJKO0PllHaGyintDJVT2hkqpzQz5Lyx4sxQOaWdoXJKO0PllHaGWQybGSqntDNUTmlnqJzSzlA5pZ2hckozw3Hu1nRkqJzSzlA5pZ2hcko7wyyGzQyVU9oZKqe0M1ROaWeonNLOUDmlmeE4d6I6MlROaWeonNLOUDmlnWEWw2aGyintDJVT2hkqpzQzjHwPa13m1xfv0xXD+fm5um0++Vxd5HtY7loD+y13rYF9kbvWTKQ1sM/4TutNr++G3qjId7ZgGAb2GTAMAz8PhWEY+HkoCMMS+Y4ZDMNhfHRHhsP4844Mh/H9HRlmMWxmqJzSzlA5pZ2hcko7Q+WUdobKKc0MI98NhGGonNLOUDmlnaFySjvDLIbNDJVT2hkqp7QzVE5pZ6ic0s5QOaWZYeQ7nTAMlVPaGSqntDNUTmlnmMWwmaH84b9/7fUNiRL5vicKw8j3JUMwvH5/eVm0l9sZai+3M9Rebmeo54ftDPX8sJ2h/OEFw1KfDLflhKH8YTtDPT9sZhj5fioMQ+WUdobKKe0MlVPaGWYxbGaonNLOUDmlnaFySjtD5ZR2hsopzQwj30/twPDNRdnjmAtlnvhiioeO5xQp7+lD3ydFykThTjGLogNFylThTpEyV7hTpEwW7hQps4U7Rcp08RXF11uNHj94PqYY+e4pEEXKNOJOUdnFg6KyiwfFLIoOFJVdPCgqu1xQXNc3xXJGUdnFg6KyiwdFZRcHipFvoQJRVHbxoKjs4kFR2eWKYskvinU5oZhF0YGisosHRWUXD4rKLh4UlV08KCq7OFCMfB/1O4rXvQqR75i6ax0mBxi0DuPWDVozkdZhnK9B6zD+1KB1GBdp0DqM1zNoHcaRXWsd526oQSuRbxrnbqhBK5FvGuduqEErkW8a576nQSuRbxrnXqZBK49vquPcnzRo5fFNdZx7jgatPL6pTplIK49vquPcGzRo5fFNdZz7fQatRL5pnHt4Bq1Evmmc+3IGrUS+aZx7bQatRL5pnPtnBq1Evmmce2IGrUS+aZz7XAatRL5pnHtXBq1Evmmc+1EGrUS+aSbyTePc7zJoJfJNM5FvWoh80zh3zgxaiXzTOHfDDFozkVYi3zTOvSyDViLfNM79KYNWIt80zj0ng1Yi3zTOfSSDViLfNM69IYNWIt80zv0eg1Yi3zTOPRyDViLfNM59GYNWIt80zh0Yg1Yi3zTOTRWDViLfNM59EoNWIt80zq0Pg1Yi3zTO3QyDViLfNM4NCoNWIt80zj0Hg1Yi3zTObQSDViLfNM6dAYNWIt80Tme/QSuRbxqn/96glcg3jdMlb9BK5JvG6WU3aCXyTeN0nBu0Evkmor7wStQXXon6witRX3gl6guvRH3hlagvvBL1hVeivvBK1BdeifrCK1FfeCXqC69EfeGVqC+8EvWFV6K+8ErUF16J+sIrUV/4RtQXvhH1hW9EfeEbUV/4NmUirTy+aRunV/qba6t5en3j5eJrl/15Vn7Z8wlDyou1vgzH6cHuyHAYn9GR4TD+pSPDYXxRR4ZZDJsZDuPjOjIc5rlaR4bDPK/ryFA5pZ2hcsq/f21ent8353LMcJze+bsYzm+GJ88cxumz78hQOaWdoXJKO8Mshs0MlVPaGSqnXDBMz38LyOmMoXJKO0PllHaGyinNDMe589CRoXJKO0PllHaGyintDLMYNjNUTmlnqJzSzlA5pZ2hcko7Q+WUZobj3FXpyFA5pZ2hcko7Q+WUdoZZDJsZKqe0M1ROaWeonNLOUDmlnaFySjPDce4YdWSonNLOUDmlnaFySjvDLIbNDJVT2hkqp7QzVE5pZ6ic0s5QOaWZ4Th3wzoyVE5pZ5jjMly250flyuMfca8Yzs8v3uaTz9VFvoflrjWw33LXGtgXuWsN7F/ctQb2Gd9pvev1vdTn6/u2HDOMfGcLhmFgnwHDMPDzUBiGgZ+HwjDMYtjMcBgf3ZHhMP68I8NhfH9HhsPkiY4MlVOaGUa+awfDUDmlnaFySjtD5ZR2hlkMmxkqp7QzVE5pZ6ic0s5QOaWdoXJKM8PIdyRhGMof/vvXGjqCI99HhGGovXzxu3z9/qHId/9gGGovtzLcI98phGGo54ftDPX8sJ2h/GGrx96nLIbNDPX8sJ2hnh+2M1ROaWeonNLOUDmlmWHk+6kwDJVT2hkqp7QzVE5pZ5jFsJmhcko7Q+WUYy7KHsdcKPPEF1OkqT6nSNM2f+ibPyhSJgpvipFvnQJRpEwV7hQpc4U7Rcpk4U4xi6IDRcp08Q3FND1ZpJTyCUXKfOFOkTKNuFNUdvGgqOziQDHy/VMgisouHhSVXb6gOKcTisouHhSzKDpQHCa75Oe7Jrd88q7JyBdL3bUOkwMMWodx6watw3jqa62RL2q6ax3Gnxq0DuMiDVqH8XoGrZlIK5FvinxB0V0rkW+KfJHQXSuRb4p84c9dK5Fvinwxz10rkW+KfIHOXSuRb4p80c1dK5FvinwhzV0rkW+KfHHMXSuRbypEvqkQ+aZxLrMZtBL5pnEusxm0EvmmcS6zGbQS+aZxLqgZtBL5pnEukhm0EvmmcS58GbQS+aZxLmYZtBL5pnEuUBm0EvmmcS46GbQS+aZxLiQZtBL5pnEuDhm0EvmmcS74GLQS+aZxLuIYtBL5pnEuzBi0Evmmncg3jXPhx6A1E2kl8k07kW8a5xKSQSuRbxrnstCV1nUa5wKQQauah//9ay+vvz0YDrO3OzJU83A7QzUPtzNUS3E7Q11IaWeoCynNDHUhxYGhLqS0M9SFlHaGyintDLMY/uvX5uX5fXMuJwyVUy4Yzm+GJ88cdCHFgaFySjtD5ZR2hsopzQw5r644M1ROuWB4dS39wVA5pZ2hcko7wyyGzQyVU9oZKqe0M1ROaWeonNLOUDmlmSHnhRVnhsop7QyVU9oZKqe0M8xi2MxQOaWdoXJKO0PllHaGyintDJVTmhmOcw+nI0PllHaGyintDJVT2hlmMWxmqJzSzlA5pZ2hcko7Q+WUdobKKc0Mx7k/1ZGhcko7Q+WUdobKKe0Msxg2M1ROaWeonNLOMLA/nMtz/LKk6YKh4XN1ke9huWsN7LfctQb2Re5aA/sXd62ZSGtgP+CuNfDedtca+Dmgu9bAz+vctRL5psj3sL7SaugNiHwP6zut15/FjHwPy13rKL7JojUTaR3FN1m0juKbLFpH8U2GZzCR72G5ax3FNxm0Rr6H5a51GN9k0DqMbzJoHcY3GbRmIq3D+CaD1mF8k0ErkW+KfA/LXSuRb4p8D8tdK5FvinwPy10rkW+KfA/LXSuRb4p8D8tdK5FvinwPy10rj29Kke9huWvl8U1p4vFNKfKdM3etmUgrj29Kke97uWvl8U0p8r0sd61Eviny/Sl3rUS+KfI9J3etgfdrek1R0r5faPW9pZQi37DpyiXw3u7KJfCO78olsB/oySXyTZiuXAL7jK5cAnuSrlwCP/fpyiWLyyEX+d1jLox+9/pzPSnyfZP7uFy+zz5FvlnSlQuj3zVwiXxbpCsXRr9r4cLody1cGP2u4Tlm5FsdXbkw+l0LF0q/a+BC6XcNXCj9roELpd+95hL5RkVXLpR+18CF0u8auMjvHnPJ4nLIRX73mIv87jEX+d1jLvK7x1zkdw+5RL510JWL/O4xF/ndYy7yu8dcsrgccpHfPeYiv3vMRX73mIv87jEX+d1DLpFvQnTlIr97zEV+95iL/O4xlywuh1zkd4+5yO8ec5HfPeYiv3vI5dd3HHzfxf/rywzO0y/Q02fo6Vfo6Qv09BV6+g16+h15+l9fCnCeHnrXbnF3reFzbVvcXWv4FMSvG/edp4+7ay3Tx921lunj7lrL9HF3rWX6uLvWkAz3uLvWMn3cXWuZPvCuNUwfeNcapg+8aw3TB961hukD71rD9IF3rWH6wLvWMD3yrp0n5F07T8i7dp6Qd+08Ie/aeULetfOEvGvnCXnXzhPyrp0n5F07T9C7NkHv2gS9axP0rk3QuzZB79oEvWsT9K5N0Ls2Qe/aBL1rZ+hdO0Pv2hl6187Qu/bXbcTO07e/3k/PgR4oVsfpr9+nMDs0tfacfkee3qH1tOf0CXr6GXr6BXr6DD39Cj19gZ4eetcucXft9XsC5yXurr1+d9Gc4+5ay/Rxd61l+ri71jJ93F1rmT7urrVMH3fXGpJhjrtrLdPH3bWW6QPvWsP0gXft9fRr4F1rmD7wrjVMH3jXGqYPvGsN0wfetYbpoXftCr1rV+hdu0Lv2hV61xboXVugd22B3rUFetc6NCD1nB561xboXVugd22B3rUFetdW6F1boXdthd61FXrXOnQX9ZweetdW6F1boXdthd61FXrXbtC7tr0/J83PHzKnmhynN7xPob0/p+v0K/T0BXr6Cj39Bj39jjx9e39O1+kT9PQz9PTQu7a9P+e26Q3vCdzj7lrDu4v2uLvWMn3cXWuZPu6utUwfd9deT79McXetZfq4u/Y6GS5T3F1rmT7urrVMH3jXGqYPvGsN0wfetYbpA+9aw/SBd61h+sC79nr6FHjXGqaH3rUJetcm6F3b3p/TdXroXZugd22C3rUJetcm6F07Q+/aGXrXztC7dobete39OV2nh961M/SunaF37Qy9a2foXbtA79oFetcu0Lt2gd617d1FXaeH3rUL6K5NU93/z4lBnp5/bv+/MzyHT+8/tvzdH8t/98fWv/tj5es/Nuf1/5yU6tepPv+Hfv657ePP1b/8c9tf/rn97/7c8cNfw59Lf/nn5r/8c8tf/rn8l3+u9WXo9EvfP6Lc/yOazfOUX7WlU6kXL0e5PLHmbfmfl5j/TrSFm2i/caLXT2l/8GP6KeknP2X+yU9ZfvJT8k9+yvqTn1J+8lPqT37K9pOf8pPf/eUnv/vLT373l5/87i8/+d1ffvK7v/zkd//XwWN97tWybsd7danhJor7MK7M2+tr88n0cR/GGabPcR/GWaaP+zDOMn3ch3GW6eM+jLNMn6Gnj/swzjJ93Idxlunj/sOXZXroXZuhd+0KvWtX6F27Qu/aFXrXtpebdp0e9IPp/0wP+sH0/05fQP+x/Z/pQf+x/Z/pQf+x/Z/p477mWKYH/cf2f6ZH/cf2/04f+I1t1/9qVgK/sc0wfeA3tl1PXwO/sc0wfeBda5g+8K41TB941xqmD7xrDdMH3rWG6QPvWsP00Lu2Qu/aCr1rtyi79j1RlP35nujHO/H0Wcr/fm1K9fmdU9o+Kjbn9WP+BXz+DD7/Cj5/AZ+/gs+/gc9/54Z8/ZRb6yvfP+XHFf7X7/rZ53ATxa3aN/w7RXsdZNfp41btW6aPW7VvmT5u1b5l+rhV+5bp41btX0/vUAfZdfq4Z20s08c9a2OZHnnXOtRBdp0eedc61EF2nR551zrUQXadHnrXJuhdm6B3bYLetQl617bXQXadHnrXJuhdm6B3bYLetQl6187Qu3aG3rVz3Nf763csO1QSdp0e9GzlP9ODnq387/QL6NnKf6YHPRH9z/SgJ6L/mR70RPQ/08d9vb9+H5JDLV7X6QOfiDZMH/hEtGH6wLvWMH3gXXs9fQ68aw3TB961hukD71rD9IF3rWF66F2boXdtht61OcqufU8UZX++J/rxTvzm/Y552f/54pTX+f3V6/Kef53A50/g88/g8y/g82fw+Vfw+Uvg+dP0nn/5Y/7//eo9P5+07uvHFI+f8tZaibRuRFoje4DtrXVfjn8HS2QPYJk/sgewzB/ZA1jmj+wBLPNn8PkjewDL/JE9wHv+dUon80fe65b5I+9qy/yB9+8619f8eTqevwbev6b5A+9f0/yB969p/sD71zR/4P1rmj/w/jXNH3j//jH/djJ/4P1rmj/w/jXNH3n/1u01/37iH7bI+9cyf+T9a5k/8v61zB95/1rmj7x/LfNH3r+W+SPv38/595P5I+9fy/yR969l/jv37+un7NNPfkr7LquvC13Lslz9v7hsiFkcOmu8J1p+O5HvZz0cOmt6Tr9CT1+gp6/Q02/Q0+/A02eHzpqe0yfo6Wfo6ZF3bZ6Qd22ekHdtnpB3bZ6Qd22ekHdtnqB3bYLetQl61yboXZugd61DZ03P6aF3bYLetQl61yboXZugd+0MvWtn6F07Q+/aGXrXOvQF9ZweetfO0Lt2ht61M/SunaF37QK9axfoXbtA79oFetc6dDX1nB561y7Qu3aB3rUL9K5doHdtht61GXrXZuhdm6F3rUNXU8/poXdtht61GXrXZuhdm6F37Qq9a1foXbtC79oVetc6ND/1nB56167Qu3aF3rUr9K5doXdtgd61BXrXFuhdW6B3rUPDUs/poXdtgd61BXrXFuhdW6B3bYXetRV611boXVuhd61Dm1LP6aF3bYXetRV611boXVuhd+0GvWs36F27Qe/aDXrXOjQn9Zweetdu0Lt2g961G/Su3aB37Q69a3foXbtD71ro3qgM3RuVoXujMnRvVIbujcrQvVEZujdqhe6NWqF7o1bo3qgVujdqnZB37QrdG7VC90at0L1RK3Rv1ArdG7VC90at0L1RK3Rv1ArdG7VC90at0L1RK3Rv1ArdG7VC90at0L1RK3Rv1ArdG7VC90at0L1RK3Rv1ArdG7VC90at0L1RK3Rv1ArdG7VC90at0L1RK3Rv1ArdG7VC90at0L1RK3Rv1ArdG7VC90at0L1RK3Rv1ArdG7VC90at0L1RK3Rv1ArdG7VC90at0L1RK3Rv1ArdG7VC90at0L1RK3Rv1ArdG7VC90at0L1RK3Rv1ArdG7VC90at0L1RK3Rv1ArdG7VC90at0L1RK3Rv1ArdG7VC90at0L1RK3Rv1ArdG7VC90at0L1RK3Rv1ArdG7VC90at0L1RK3Rv1ArdG7VC90at0L1RK3Rv1ArdG7VC90at0L1RK3Rv1ArdG7VC90at0L1RK3Rv1ArdG7VC90at0L1RK3Rv1ArdG7VC90at0L1RK3Rv1ArdG7VC90at0L1RBbo3qkD3RhXo3qgC3RtVJuRdW6B7owp0b1SB7o0q0L1RBbo3qkD3RhXo3qgC3RtVoHujCnRvVIHujSrQvVEFujeqQPdGFejeqALdG1Wge6MKdG9Uge6NKtC9UQW6N6pA90YV6N6oAt0bVaB7owp0b1SB7o0q0L1RBbo3qkD3RhXo3qgC3RtVoHujCnRvVIHujSrQvVEFujeqQPdGFejeqALdG1Wge6MKdG9Uge6NKtC9UQW6N6pA90YV6N6oAt0bVaB7owp0b1SB7o0q0L1RBbo3qkD3RhXo3qgC3RtVoHujCnRvVIHujSrQvVEFujeqQPdGFejeqALdG1Wge6MKdG9Uge6NKtC9UQW6N6pA90YV6N6oAt0bVaB7owp0b1SB7o0q0L1RBbo3qkD3RhXo3qgC3RtVoHujCnRvVIHujSrQvVEFujeqQPdGFejeqALdG1Wge6MKdG9Uge6NKtC9UQW6N6pA90YV6N6oCt0bVaF7oyp0b1SF7o2qE/KurdC9URW6N6pC90ZV6N6oCt0bVaF7oyp0b1SF7o2q0L1RFbo3qkL3RlXo3qgK3RtVoXujKnRvVIXujarQvVEVujeqQvdGVejeqArdG1Whe6MqdG9Uhe6NqtC9URW6N6pC90ZV6N6oCt0bVaF7oyp0b1SF7o2q0L1RFbo3qkL3RlXo3qgK3RtVoXujKnRvVIXujarQvVEVujeqQvdGVejeqArdG1Whe6MqdG9Uhe6NqtC9URW6N6pC90ZV6N6oCt0bVaF7oyp0b1SF7o2q0L1RFbo3qkL3RlXo3qgK3RtVoXujKnRvVIXujarQvVEVujeqQvdGVejeqArdG1Whe6MqdG9Uhe6NqtC9URW6N6pC90ZV6N6oCt0bVaF7oyp0b1SF7o2q0L1RFbo3qkL3RlXo3qgK3RtVoXujKnRvVIXujarQvVEVujeqQvdGVejeqArdG1Whe6MqdG/UBt0btUH3Rm3QvVEbdG/UNiHv2g26N2qD7o3aoHujNujeqA26N2qD7o3aoHujNujeqA26N2qD7o3aoHujNujeqA26N2qD7o3aoHujNujeqA26N2qD7o3aoHujNujeqA26N2qD7o3aoHujNujeqA26N2qD7o3aoHujNujeqA26N2qD7o3aoHujNujeqA26N2qD7o3aoHujNujeqA26N2qD7o3aoHujNujeqA26N2qD7o3aoHujNujeqA26N2qD7o3aoHujNujeqA26N2qD7o3aoHujNujeqA26N2qD7o3aoHujNujeqA26N2qD7o3aoHujNujeqA26N2qD7o3aoHujNujeqA26N2qD7o3aoHujNujeqA26N2qD7o3aoHujNujeqA26N2qD7o3aoHujNujeqA26N2qD7o3aoHujNujeqA26N2qD7o3aoHujNujeqA26N2qD7o3aoHujNujeqA26N2qD7o3aoHujNujeqA26N2qD7o3aoHujdujeqB26N2qH7o3aoXuj9gl51+7QvVE7dG/UDt0btUP3Ru3QvVE7dG/UDt0btUP3Ru3QvVE7dG/UDt0btUP3Ru3QvVE7dG/UDt0btUP3Ru3QvVE7dG/UDt0btUP3Ru3QvVE7dG/UDt0btUP3Ru3QvVE7dG/UDt0btUP3Ru3QvVE7dG/UDt0btUP3Ru3QvVE7dG/UDt0btUP3Ru3QvVE7dG/UDt0btUP3Ru3QvVE7dG/UDt0btUP3Ru3QvVE7dG/UDt0btUP3Ru3QvVE7dG/UDt0btUP3Ru3QvVE7dG/UDt0btUP3Ru3QvVE7dG/UDt0btUP3Ru3QvVE7dG/UDt0btUP3Ru3QvVE7dG/UDt0btUP3Ru3QvVE7dG/UDt0btUP3Ru3QvVE7dG/UDt0btUP3Ru3QvVE7dG/UDt0btUP3Ru3QvVE7dG/UDt0btUP3Ru3QvVE7dG/UDt0btUP3Ru3QvVE7dG/UDt0btUP3Ru3QvVE7dG/UDt0blSbo4qjH+Mjb9jE+8rp9jI+8bx/jIy/cx/jIG/cxPvLKfYyPvHMf4yMv3cf42FsXukLqMT721oUukXqMj711oWukHuNjb13oIqnH+NhbF7pK6jE+9taFLpN6jI+9daHrpB7jY29d6EKpx/jYWxe6UuoxPvbWhS6VeoyPvXWha6Ue42NvXehiqcf42FsXulrqMT721oUul3qMj711oeulHuNjb13ogqnH+NhbF7pi6jE+9taFLpl6jI+9daFrph7jY29d6KKpx/jYWxe6auoxPvbWhS6beoyPvXWh66Ye42NvXejCqcf42FsXunLqMT721oUunXqMj711oWunHuNjb13o4qnH+NhbF7p66jE+9taFLp96jI+9daHrpx7jY29d6AKqx/jYWxe6guoxPvbWhS6heoyPvXWha6ge42NvXegiqsf42FsXuorqMT721oUuo3qMj711oeuoHuNjb13oQqrH+NhbF7qS6jE+9taFLqV6jI+9daFrqR7jY29d6GKqx/jYWxe6muoxPvTWTdjdVAm7myphd1Ml7G6qNEFv3YTdTZWwu6kSdjdVwu6mStjdVAm7myphd1Ml7G6qhN1NlbC7qRJ2N1XC7qZK2N1UCbubKmF3UyXsbqqE3U2VsLupEnY3VcLupkrY3VQJu5sqYXdTJexuqoTdTZWwu6kSdjdVwu6mStjdVAm7myphd1Ml7G6qhN1NlbC7qRJ2N1XC7qZK2N1UCbubKmF3UyXsbqqE3U2VsLupEnY3VcLupkrY3VQJu5sqYXdTJexuqoTdTZWwu6kSdjdVwu6mStjdVAm7myphd1Ml7G6qhN1NlbC7qRJ2N1XC7qZK2N1UCbubKmF3UyXsbqqE3U2VsLupEnY3VcLupkrY3VQJu5sqYXdTJexuqoTdTZWwu6kSdjdVwu6mStjdVAm7myphd1Ml7G6qhN1NlbC7qRJ2N1XC7qZK2N1UCbubKmF3UyXsbqqE3U2VsLupEnY3VcLupkrY3VQJu5sqYXdTzdjdVDN2N9WM3U01Y3dTzRP01p2xu6lm7G6qGbubasbuppqxu6lm7G6qGbubasbuppqxu6lm7G6qGbubasbuppqxu6lm7G6qGbubasbuppqxu6lm7G6qGbubasbuppqxu6lm7G6qGbubasbuppqxu6lm7G6qGbubasbuppqxu6nmwO1Iy77887XLfjp+3Nd9y/iB+3lyKv98bU71bPy4rzym8eO+8pjGj/vKYxo/Y48f1++bxo/7up9LfY6/LWfjx33dN40f1++bxo/r9y3jB+7nMY0feOtaxg+8dS3jB966lvEDb13L+IG3rmV87K0buJ/HND721g3Tz/MeKUznzsdIP96Op89Y/vdr99cQ+7aejT9jj7+EHb9M9RmLyrTv769ep7/8hfx1605fsSuk2A8BBV1ARRewoQvYwQX8uq3HX0Dc7W4UEHe/GwVgbvgPAZhb+0MA+iau6Ju4om/iir6JK/om3tA38Ya+ibfAmzi9pijpMr2V9ZneyrqdpLct8Nb2Fxt4w38n1vnNPltg59AXTGBH0hdMYKfTF0xgB9UXTGBn1hXMHtjx9QUT2En2BTOMQ/UGM4yb9QaTBeYYjJzvCRg53xMwcr4nYOR8T8DI+R6CWSY53xMwcr4nYOR8T8DI+Z6AyQJzDEbO9wSMnO8JGDnfEzByvidg5HyPwSQ53xMwcr4nYOR8T8DI+Z6AyQJzDEbO9wSMnO8JGDnfEzByvidg5HyPwcxyvidg5HxPwMj5noCR8z0BkwXmGIyc7wkYOd8TMHK+J2DkfI/BLIw+xtDpuSyMPsYEhnErGboYl4VxK5nAMG4lExjGrWQCw/g8xgImMz6PMYFh9DGGwqclM/oYExjG5zEmMFlgjsFQOl8LGErnawFD6XwtYMZ3vh9ix3ezb7HrMA71i+88b+X54GTeavn4ztsnmmE8qj+aYVyqP5phfKo/miw0Z2iG8ar+aIZxq/5ohvGr36DZ8/yceV/XMzTDOFZ/NMP4W3c0hdIN29BQumEbGko3bEND6YZtaDIhmmVKzy9epiWdoWF0w0Y0jG7YiIbRDRvRMLphIxpGN2xDE/luSW80jG54mfbnzEua6hkaRjdsRMPoho1ostCcoeF0wyY0nG7YhIbTDZvQcLrhsr7RbH+g+d+v3vPznx/+eIDx+CkfGDmdszfGyDeJkDBSOvL0eovPktbl5PVunJtL/mgoHbkNTRaaMzSUjtyGhtKR29BQOnIbGkpH/ommnD1pHOeykzuacW47+aPhdMN7eqKZp3yGhtMNm9BwumETmiw0Z2g43bAJDacbNqHhdMMmNJxu+ANNms/QcLphA5o8zr0nfzSUbnheX0FhLssZGko3bEND6YZtaLLQnKGhdMM2NJRu2IaG0g3b0FC64U80NZ2hoXTDJjTj3IDyR0Pphpf0/EzW8sB0hobSDdvQULphG5osNGdoKN2wDQ2lG7ahoXTDNjSUbvgTzXL2lG+cq1DuaMa5C+WPBtMNfwjA9KwfAgI7y3l+fucyL/XiL+c8P0ee80nxdY58PclfbGD35y82sJ/zFxvYofmLDey5/MUGdlHfiV2fvcZzPWm/zUtgX+QvNrDT8Rcb2BX5ix3GQVnEZiaxwzgoi9jIDmp7JZl5KydJJvLlLJuAyE6nPM8KlSVNF3/dtvz84u3U6US+WuUuNvIlKn+xkZ2Ou9jITsddbGSn4y42M4mN7HTcxUZ2Ou5iI7sid7FMDirypSR3sZEvJfmLZXJQka8Z+YtlclCRLw75i2VyUJGvAvmLZXJQkS/3+ItlclCRr+v4i2VyUJEv4PiLZXJQka/U+ItlclCRL8n4ix1lzy77swp32fOJ2Mh3O/zFjvJqnNPzi3M6+2sc+UqCv9hRXo1NYkd5NTaJHSXPmsSOkmdNYkfZs7k836+Ut7P3K0Vu7vcXO0qeNYkdJc+axA7joCxiM5PYYRyURSymg/oQgOmKPgRgOp0PAZju5S0gciP6srzeLr5kj08qRe449xcb2JH4iw3sSPzFZiaxgR2Jv9jAjuQ7sYYP70Tu8/YXG9jp+IsN7Iq8xa6RW7T9xQ7joCxih3FQFrHDOCiL2Iwhds3HsW2N3BltEwDidM4FBHYv+S0g/3FB7w8BgR2JTUBkl7EtLwHbcvGKldL0nDml+aOEN88fciP3E98hN7LTuEFuZK9xg9zIbuMGuZlLbmR3coPcyF7mBrmRn9vcIDfyk5sb5HK5qsg9t3fI5XJVkZtu75DL5aoiN+PeIZfLVUVux71DLperityQe4dcLlcVuSX3DrlcripyU+4dcrlcVeS23DvkcrmqyI25d8jlclWR23jvkMvlqiI38t4hl8tVRW7lvUMul6uK3Mx7h1wuVxW5nfcOuVyuKnJD7x1yuVxV5JbeO+RyuarITb13yOVyVZHbeu+Qy+WqIjf23iGXy1VFbu29Qy6Xq4rc3HuHXC5XFbm99w65XK4qcoPvHXK5XFXkFt875HK5qsLlqiK3NN8gN3JP8x1yuVxV5XJVkXu475CbueRyuarIbdx3yOVyVZEbue+Qy+WqIrdy3yGXy1VFbua+Qy6Xq4rczn2HXC5XFbmh+w65XK4qcvv3HXK5XFXoZvEb5HK5qtDt4jfI5XJVoRvGb5DL5apCt4zfIJfLVYVuGr9BLpWrKqHbxm+QS+WqSujG8RvkUrmqMmUuuVSuqoRuNL9BLpWrKpHb0u+Qy+WquLrVC1e3euHqVi9c3eqFq1u9cHWrF65u9cLVrV64utULV7d64epWL1zd6oWrW71wdasXrm71wtWtXri61QtXt3rh6lYvXN3qhatbvXB1qxeubvXC1a1euLrVC1e3euHqVi9c3eqFq1u9cHWrF65u9cLVrV64utULV7d64epWL1zd6oWrW71wdasXrm71wtWtXri61QtXt3rh6lYvXN3qhatbvXB1qxeubvXC1a1euLrVC1e3euHqVi9c3eqFq1u9cHWrF65u9cLVrV64utULV7d64epWL1zd6oWrW71wdasXrm71wtWtXri61QtXt3rh6lYvXN3qhatbvXB1qxeubvXC1a1euLrVC1e3euHqVi9c3eqFq1u9cHWrF65u9cLVrV64utULV7d64epWL1zd6oWrW71wdasXrm71wtWtXri61QtXt3rl6lavXN3qlatbvXJ1q9cpc8mlclWVq1u9cnWrV65u9crVrV65utUrV7d65epWr1zd6pWrW71ydatXrm71ytWtXrm61StXt3rl6lavXN3qlatbvXJ1q1eubvXK1a1eubrVK1e3euXqVq9c3eqVq1u9cnWrV65u9crVrV65utUrV7d65epWr1zd6pWrW71ydatXrm71ytWtXrm61StXt3rl6lavXN3qlatbvXJ1q1eubvXK1a1eubrVK1e3euXqVq9c3eqVq1u9cnWrV65u9crVrV65utUrV7d65epWr1zd6pWrW71ydatXrm71ytWtXrm61StXt3rl6lavXN3qlatbvXJ1q1eubvXK1a1eubrVK1e3euXqVq9c3eqVq1u9cnWr12HqqLf5+cXb/Od3/hA7yhoyiR3lZWrL5TlyrmdiR3mRMokd5SXKInaYmmKT2FFCn0ksZuT7EIC5Oz8EBN6H6zK/vnifrrzOOu9Pr7PWj++d//gLFziW3SE3cCy7Q25gv3OH3MCO5w65gT2Pv9wtco3wHXID+5475AZ2PnfIDeyT7pCbueRSuaotco3wHXKpXNUWuUb4DrlcripyjfAdcrlcVeQa4TvkcrmqyDXCd8jlclWRa4TvkMvlqiLXCN8hl8tVRa4RvkMul6uKXCN8h1wuVxW5efUruYZ3xGyRe1fdxUbu5fxO7PVbCbbIrZz+Ykd5iTKJzUxiRwl9JrGYke9DAObu/BAQeB/WOT2/+LHtLv665VL/+eI/3uv051+3wKHMXWzktkx/sYGdjr/YwE7HX2xgp+MvNjOJDex0/MUGdjr+YgO7In+xTA4qcjemu9jIzZj+YpkcVORWTH+xTA4qciOmv1gmBxW5DdNfLJODityE6S+WyUFFbsH0F8vkoCI3YPqLZXJQkdsv/cUyOajIzZf+YpkcVOTWS3+xTA4qcuOlv1gmBxW57dJfLJODitx06S+WyUFFbrn0F8vkoCI3XPqLZXJQG5OD2pgc1MbkoCKXtPqLzUximRzUxuSgItfv+otlclCR63fdxUau3/UXy+SgItfv+otlclCRa339xTI5qMiVvv5imRxU5Dpff7FEDmqPXOXrL5bIQe2Ra3z9xRI5qH3KTGKJHNQeub7XXyyRg9ojV/f6i2VyUJFre/3FMjmoyJW9/mKZHFTkul5/sUwOKnJVr79YJgcVuabXXyyTg4pc0esvlslBRa7n9RfL5KDmzCSWyUHNTA4qcsO0v1gmBzUzOaiFyUFF7g73F8vkoCJ3h/uLzUximRxU5O5wf7FMDoqpk3xn6iTfmTrJd6ZO8p2pk3xn6iTfmTrJd6ZO8p2pk3xn6iTfmTrJd6ZO8p2pk3xn6iTfmTrJd6ZO8p2pk3xn6iTfmTrJd6ZO8p2pk3xn6iTfmTrJd6ZO8p2pk3xn6iTfmTrJd6ZO8p2pk3xn6iTfmTrJd6ZO8p2pk3xn6iTfmTrJd6ZO8p2pk3xn6iTfmTrJd6ZO8p2pk3xn6iTfmTrJ92HKnB9f8Rx5zmdiR1k9JrGjvEBtuTxHzvVM7CgvUBaxw1T+msSOEvFMYkeJeCaxmBHvQwDm7vwQEHgfbutzxZV9Kxd/3ealLq85tv1jjvlTbuAwdofcwHHsDrmB/c4dcgM7Hne58xS5pPcOuYFdzx1yA/ueO+QGdj53yM1ccplc1UMuk6t6yGVyVQ+5TK7qIZfLVUUu7r1DLperilzee4dcLlcVucD3Drlcripyie8dcrlcVeQi3zvkcrmqyGW+d8jlclWRC33vkMvlqiKX+t4hl8tVRS72vUMul6uKXO57h1wuVxW54PcOuVyuKnLJ7x1yuVxV5KLfO+RyuarIZb93yOVyVZELf++Qy+WqIpf+3iGXy1VFLv69Qy6Xq4pc/nuHXC5XFbkA+A65XK4qcgnwHXK5XFXkIuA75HK5qshlwHfI5XJVkQuB75DL5aoilwLfIZfLVUUuBr5DLperilwOfIdcLlcVuSD4DrlcripySfAdcrlcVeSi4DvkcrmqyGXBd8jlclWRC4PvkMvlqiKXBt8hl8tVRS4OvkMul6uKXB58h1wuVxW5QPgOuVyuKnKJ8B1yuVzVxuWqNi5XFbkT+w65XK5q43JVG5eritx6fodcLlcVufn8Drlcripy+/kdcrlcVeS29Dvkcrkqqm71h1wuV0XVrf6QS+WqEle3euLqVk9c3eqJq1s9TZlLLpWrSlzd6omrWz1xdasnrm71xNWtnri61RNXt3ri6lZPXN3qiatbPXF1qyeubvXE1a2euLrVE1e3euLqVk9c3eqJq1s9cXWrJ65u9cTVrZ64utUTV7d64upWT1zd6omrWz1xdasnrm71xNWtnri61RNXt3ri6lZPXN3qiatbPXF1qyeubvXE1a2euLrVE1e3euLqVk9c3eqJq1s9cXWrJ65u9cTVrZ64utUTV7d64upWT1zd6omrWz1xdasnrm71xNWtnri61RNXt3ri6lZPXN3qiatbPXF1qyeubvXE1a2euLrVE1e3euLqVk9c3eqJq1s9cXWrJ65u9cTVrZ64utUTV7d64upWT1zd6omrWz1xdasnrm71xNWtnri61RNXt3ri6lZPXN3qiatbPXF1qyeubvXE1a2euLrVE1e3euLqVk9c3eqJq1s9cXWrJ65u9cTVrZ64utVnrm71matbfR6mjnqbn1+8zX9+5w+xo6whk9hRXqa2XJ4j53oidpiqYpPYUV6iTGJHiX0msaOEPpPYDCn2QwDm7vwQEHcf1mmu/3xxnT7dy9//dYsbym4QGzeS3SA2rtPxFxu4PvgGsXGdzg1i4zqdG8TGdTo3iM1MYuO6ohvEMjmowIXBN4hlclCBy4L9xQauCr5BLJODClwTfINYJgcVuCL4BrFMDipwPfANYpkcVOBq4BvEMjmowLXAN4hlclCBK4FvEMvkoALXAd8glslBBS6L/U7ssj//zXLZz97VErgq1l9s4CrR78Tm9PxrnNPZX+PARaI3iB3l1dgkdpRXY5PYUfKsSewoedYkdpQ9m8vzi/O2nIkdZc9axAauDr1B7Ch51iR2GAdlETuMg7KIzUxih3FQFrHDOCiL2GEclEUsk4MKXBTqLzZwTegNYjEd1IcATFf0ISCw03l8i6eAlE8FZHQBgR1JmveXgH36T/sT9sBVmzeIDexI/MUGdiT+YgM7EnexgSs2bxAb2JH4iw3sXvzFRnY67mIzk1gmBxW4VvMGsUwOKnCl5g1imRxU4DrNG8QyOajAVZo3iGVyUIFrNG8Qy+SgAldo3iCWyUEFrs+8QSyRg1oCV2feIJbIQS0TkYNaJiIHtUyZSewoe9bwaYplGmXPWsQG7gj9TqzhndlL4I7QG8SO8mpsEjvKq7FJ7Ch51iR2lDxrEjvKnjW8PW6J3D3qL3aUPGsRG7l71F/sMA7KInYYB2URO4yDsojNTGKHcVAWscM4KItYJgcVuXvUXyyTg4rcPfovYj8EYLqiDwGBnc6c56eAOS9nAgK7F5uAHFjA67BWnWv1+IUP7Ej8xQZ2JP5iAzsSf7GBHYm/2MCOxF1s5C5Pf7GB3Yu/2MhOx11sZFfkLjYziWVyUJnJQWUmBxW5pdVfLJODWpkc1MrkoCL37/qLZXJQkft3/cUyOajILa1fibW8yzNyS6u72Mhdnt/9NTa8Yyxyl6e/2GFejS1ih3k1togdJs9axA6TZy1imfJs5C5Pd7GRuzz9xTLl2ci9n/5imfJs5D5Rf7GYDupDAKYr+hCA6XQ+BGC6lw8BgR3J8rKPdZmvCrfn+TnyfPox5chdnv5iAzsSf7GBHYm/2MCOxF9sZhIb2JF8J3Z92q+5ntmvyF2e/mIDOx1/sYFdkb/YYRyUQWzkLk9/scM4KIvYYRyURSyIg1rKSWyL3M9pEwDidM4FRHYv+/QSsKczAZEdiUlAZJdR01PA4x/B/tP+rDJy36W32By579JfbGSX4S42sstwFxvZZbiLzUxiI7sXd7GRnY672MiuyF0skYPKE5ODSkwOKnJHrb9YJgcVuaPWX2xmEsvkoCJ31PqLZXJQkTtq/cUyOajITaZfiTV8JCpHbjL1FzvMq/H1xyty5L5Lf7HDvBpbxA7zamwQG7nv0l/sMHnWIpYpz0bu3PQXm5nEMuXZyP2c/mKZ8mzkfk5/sUx5NnI/p79Ypn8RiNzP6S+WyUFF7uf0F4vpoD4EYLqiDwGBnU6ur4sA+fNt3X8KCOxebAICO5K8vj5OnPfN4Rc+ct+lv9jAjsRfbGBH4i82sCPxF5uZxAZ2JP5iA7sXf7GRnY672MiuyF0sk4MqTA6qMDmoyB21/mKZHFTkjlp/sUwOKnJHrb9YJgcVuaPWXyyTg4rcUesvdpQ9a3mXZ+QmU3+xw7waG94xFrlz01/sMK/GBrGR+zn9xQ6TZy1ih8mzFrFMeTZyP6e/WKY8G7mf018sU56N3M/pL5Ypz0bu5/wXsR8CMF3RhwBMp/MhANO9fAjIcQWs+fmd67pe3TAxNIbnyD2a/mIDOxJ/sYEdib/YwI7EX2xgR+Itdo3c5fmd2Ote6TVyl6e/2MBO51/EfggI7HRsAnJcAWV6TlFL2jxeSAI7HX+xgZ2Ov9jATsdfbGCn4y82sNNxFxu5c/M7sYblH7lz019sYKfjLzawK/IXm5nEDuOgLGKHcVAWsZgO6kMApiv6EBDZ6ayvD3+Xfbr461Zef93Kup38dZsjOx13sZGdzldi8/T6zsvFdz6f4gNMZFfUFUxkB9UVTBaYYzCRnVlXMJFdXFcwkR1fVzCRnWRXMMM4VGcwkbuF+4KR8z0BI+d7AkbO9wRMFphjMHK+J2DkfE/AyPmegJHzPQEj53sMJnIndF8wcr4nYOR8T8DI+Z6AyQJzDEbO9wSMnO8JGDnfEzByvidg5HyPwUTuHu8LRs73BIyc7wkYOd8TMFlgjsHI+Z6AkfM9ASPnewJGzvcEjJzvMZjInfF9wcj5noCR8z0BI+d7AiYLzDEYOd8TMHK+J2DkfE/AyPmegJHzPQYTueu/Lxg53xMwcr4nYOR8T8BkgTkGI+d7AkbO9wSMnO8JGDnfEzByvsdgIt9V6QtGzvcEjJzvCRg53xMwWWCOwcj5noCR8z0BI+d7AkbO9wSMnO8xmMj3cPqCkfM9ASPnewJGzvcETBaYYzByvidg5HxPwMj5noCR8z0BI+d7CKZEvrvUF4yc7wkYOd8TMHK+J2CywByDkfM9ASPnewJGzvcEjJzvCRg532Mwoe9wdQUj53sCRs73BIyc7wmYLDDHYBh9zLIv/3ztsp+CYfQxFjCU95VyKv98bU71DAzjVjKBYdxKJjCMW8kEhvF5jAkM4/MYExhGH5PL8xxi3pYzMIw+xgSG8XmMBQzlfSUTGErnawFD6XwtYCidrwVMFphjMJTO1wKG0vlawMj5noCR8z0BI+d7DIbgvtKH2PHd7IfYYRzqF985lTr/88WP//yYeaqfaIbxqP5ostCcoRnGp/qjGcap+qMZxqt+g6Yuzy9+/Od+hmYYt+qPZhi/+hWaNL3QbH/+Qv3vV6/78zuv+wfGNH1gHOeGUl+Mw/jmvhgpHbk/Rkr37o8xC6MHRspU4I+RMkH4Y+RMG+4YOZOJO0alGA+M49zD6otRKcYFo1KMC0alGBeMWRg9MCrFuGBUinHBqBTjglEpxgWjUowHxnEuVd2H8SVw/fzaPzHKN7pg1KZ2+aXWpnbBqE3tglGb2gPjOLeY+mLU88azN8WNc7vJH4383SmazIhmm17vMt3yKRrK53c2NJRO34aG0r1vr939+M+zN+COc8fJHw2ly97qa0Pty/yfdns4zt2nvhgpXbY/RkpH7o+R0r37Y8zC6IGRMxW4Y+RMEO4YOdOGO0bOZOKOUSnGAWMd54ZXX4xKMS4YlWJcMCrFuGDMwuiBUSnGBaNSjAtGpRgXjEoxLhiVYjwwjnOPrS9G+cZLjNfvTa7jXO7qi1Gb2uWXWpvaBaM2tQfGWZvaBaOeN7pg1PPGPzF+oJEXPEWTheYMDeWzvv31ndO+pTM0lM/vbGgonb4NDaN7n6dlf8485ekMDaMjt6EZ5x7eV2hSeqGp+T/t9nCc63l9MTK67BswMjryGzBmYfTAyOj0b8DImApuwMiYIG7AyJk23DFyJhNvjOPcNuyLUSnGBaNSjAtGpRgXjFkYPTAqxbhgVIpxwagU44JRKcYFo1KMB0bKG5Y3YFSKccGoFOOCUSnGBWMWRg+MSjEuGJViXDAqxbhgVIpxwagU44GR8oblDRiVYlwwKsW4YFSKccGYhdEDo1KMC0alGBeMSjEuGJViXDAqxXhgrEoxLhiVYlwwKsW4YFSKccGYhdEDo1KMC0alGBeMSjEuGJViXDAqxXhgpLzvewNGpRgXjEoxLhiVYlwwyjdeYjR0r1JelvXHSHkj1P+XmvJG6A0YtaldMGpTu2DMwuiBUc8b/8T4gUZe8BSN/N0pGs5nffvynPnB4QwN5/M7A5qN8o6mEQ2le08faPZTNJSO3IaG0mWn8tQ3z/P+nwt7+BpjrR/90Wv+xJiF0QMjpcv2x0jpyP0xUrp3f4yUTt8fI2UqcMdIecPyBoycacMdI2cycceoFOOCMQujB0alGBeMSjEuGJViXDAqxbhgVIrxwEh53/cGjEoxLhiVYlwwKsW4YMzC6IFRKcYFo1KMC0alGBeMSjEuGJViPDBy3k/2x6gU44JRKcYFo1KMC8YsjB4YlWJcMCrFuGBUinHBqBTjglEpxgMj5/1kf4zyjZcYr7sQNs6Ltf4YtakvMV5/bHrjvBHqj1Gb2gMj541Qf4x63uiCUc8b/8T4gUZe8BRNFpozNHrWd4qG8vndXNf3zOniJTvv5fmSPe0nGZXz5qY/RspU4I+RMhW4Y+S8uemPkTIV+GOkTAX+GCkTxFcYPx7Kf37nPzFmYfTASJlM/DEqxbhgVIpxwagU44JRKcYDI+fNzb/FePouBM6bm/4YlWJcMCrF/InxA00WmjM0ShunaJQgTtFQpoLljSancvGSnd4gH//5+dV/vGhT5oI7QFImgxtAcl6yvAMkZTr4DuSyTk+Qy5rOQFLmgztAUiaEL0HO8wvkvv4B8iCWGd65t2VB/z10ylTTGzplXuoNXUmsA3Sltg7QlfB+D53zWnJv6EqOHaArZXaArkTaAXoW9N9DVyLtAF2JtAN0JdIO0JVIO0BXIv059J3zqndv6EqkHaArkXaArkTaAbp8ujP069aynfNidWfonBeFO7+8cN4f7g1d7qUDdLmXDtCzoP8eup6nt0D/ACnv7QRSftoJpJ5lX4LM6akw5fUUpJ5P+4DkvKB8B0glsUuQa3p9uGhN5Qyk0pUTSCWm61/trb5ArtsfIA++d6rPjyLNc6kfX718Ys/C3gO7UlMX7MpYXbArkXXBrvzWBbvSXg/snHep+2NXkuyCXbmzC3al1C7Ys7D3wK6U2gW7UmoX7EqpXbArpXbBrpTaAzvn3fH+2JVSu2BXSu2CXSm1C/Ys7D2wK6V2wa6U2gW7UmoX7EqpXbArpfbAviqldsGulNoFu1JqF+xKqV2wZ2HvgV0ptQt2pdQu2JVSu2BXSu2CXSm1B/ailNoFu1JqF+xKqV2wK6V2wZ6FvQd2pdQu2JVSu2BXSu2CXSm1B/Yq3+6L3dIzW+XaO0CXi3GGbiiCrPIwHaDLwXSALv/SAbqesf8e+qYn7C3QP0DKezuBlJ92Aqnn2k4gs0BegSzzc45UtnKxmPJenotp+lhM6x/QlfA6QFfC6wBdCa8DdCW8DtCV8H4PfVfC6wBdadAX+voaev2c40/oSo4doCtldoCeBf330JVIO0BXIu0AXYm0A3Ql0tug13QGXYn019CXaVIi7QBdibQF+gdIpUwnkEqOlyDrtD9B1nW/eBlIW37dfN3+OAy5fGLPwt4Du9JjF+zKj12wK0F2wa4M2QW7UqQ39vX1vqytTifYk3JkF+xKkl2wK3d2wa6U2gV7FvYe2JVSnbHXbXth3/40kH/3IDcp0Yb/X6T0G/5/kZKy8/+ivby+et/ms/2ipNwD+6yk3AW7knIX7ErKXbArKXfBnoW9B3YlZW/sW35h3+sZdqXfLtiVaLtgV0rtgl0ptQf2RSm1C3al1C7YlVK9safX9378a/kf2P/uIfGiRBv+f1HW/6Lo/4uUlH3/F83T/vreadrO9ouSchfsSspdsCspd8GupNwDe1ZS7oJdSbkLdiVlZ+wpva7JpHk5w6702wV7FvYe2JVSu2BXSu2CXSm1C3al1C7YlVK9fXtOL+zLn7797x4Sr0q04f8XKf2G/1+kpOz8v2ieXzweP+dkv6xKyl2wZ2HvgV1JuQt2JeUu2JWUu2BXUu6CXUnZG/uyv7CvZx8mKkq/XbAr0XbBrpTaBbtSahfsWdh7YFdK7YJdKdX7X7jq61+45vKnb/+7h8RFiTb8/yKl3/D/i5SU//xf9EZTlWZP0VAmzpyfXzyvU7r6xZ7Sq+tvWj5//dZPkJQZ8g6QlKnwDpBZIH1AUia3O0BSZrE7QFImpi9Brq/Oi+nTYP8JkjLX3AGSMn3cAHKjzCp3gFSycQKpZOMEUsnmGuTr87fpj8/f/gkyC6QPSCUbJ5BKNk4glWycQCrZOIFUsrkEmZblBTKXE5C7ko0TSCUbJ5BKNk4glWycQGaB9AGpZHMNcn+BnKdTkEo2TiCVbJxAKtk4gVSycQGZJiUbJ5BKNpcg55JeIGs+A6lk4wRSycYJZBZIH5BKNk4glWycQI6fbD7Ejp8+PsRiJoS3gITpzD8EBHbEdXl+hKnWbb3665an13deLr6z5a9mCuxw+4IJ7Fj7gskCcwwmsKPsCyawQ+wLJrDj6wsmsDvsCyawk+wKZg7sUPuCkfM9ASPnewJGzvcETBaYYzByvidg5HxPwMj5noCR8z0BI+d7DGaR8z0BI+d7AkbO9wSMnO8JmCwwx2DkfE/AyPmegJHzPQEj53sCRs73GEyW8z0BI+d7AkbO9wSMnO8JmCwwx2DkfE/AyPmegJHzPQYT+UbybWCW1weZlv0UDKOPMYFh3Eo5lX++Nqd6BoZxK5nAMG4lExjGrWQCw/g8xgSG8XmMBUzka5f3gSn1CWZbzsAw+hgTGMbnMSYwjM9jTGCywByDoXS+FjCUztcCZnzn+yF2fDf7IXYYh/rFd07bu9Bu+yy0W9IHmsg37HqjGcal+qMZxqf6oxnGqfqjyUJzhmYYt+qPZhi/+hWal2FN2zadoRnGsfqjGcbf+qPhdMMWNJGvpPVGw+mGTWg43bAJDaUb3l/fOe15OUOTheYMDaUbtqGhdMM2NJRu2IaG0g3b0FC6YROayJe1bkMzT9Nr5umPt3b8gYbRDRvRMLphIxpGN2xEk4XmDA2jGzaiYXTDRjSMbnieXvrmqWxnaBjdsBENoxs2oZkjX2PqjYbTDZvQcLphExpON2xCkxnRpNd3ntPZQ4k58p2i3mgo3bANDaUbtqGhdMM2NJRu2IQm8gWk3mgw3fCHAEzP+iEgsLPcpv0pYJvni7+c8/wyi/nkU6Zz5PtD/mIDuz9/sYH9nL/YwA7NX2xgz+UvNrCL+k7s+nzH21xPPmo2R7678y9iPwQEdi82AYHdy5bXl4B1c/jdinybxl9sZhIb2em4i43sdNzFRnY67mIjO52vxFqWf2Sn4y028p0Vf7GRXZG72GEclEXsMA7KIjYzicV0UB8CMF3RhwBMp/MhANO9fAjAdCRvAZFvWtgEYDqHDwGYbuBDAOaG/xCAubU/BKBv4sg3DGwC0DdxRt/EGX0TR77KYBOAvolX9E28om/iyHcmbALQN3Hkuw02AeibOPIdBJuAyJt4e729bduv3rr4b1/9lhv5CsEdciNv+W/k7q+R9883Ov7xiDPyvQB/sZHdg7vYzCQ2iiv5GCmKz/gYKYpz+Bgpihf4GCnKdn+PFKZj/WOkKFvyY6Qou+xjpCgb52OkKHvhY6R4r95hOqM/Ror36h2mI/ljpHiv3mE6gT9GivfqHaYD92OkeK/eYTpfP0aK9+odpuP0Y6Q7X70/fsz2mx+z/+TH3Nof+fFj0m9+zPybH7P85sfk3/yY9Tc/pvzmx/zmVWD/zavA/pNXgWWafvNj0m9+zPybH7P85sfk3/yY9Tc/pvzmx9Tf/JjtNz/mN68C6TevAuk3rwLpN68C6TevAuk3rwLpN68C6TevAuk3rwLpN68C6TevAvNvXgXm37wKzL95FZh/8yow/+ZVYP7Nq8D8m1eB+TevAvNvXgXm37wKLL95FVh+8yrQ/mnJ5fW181Kn//z70yrDv6cv7Z9p9B8pxxtpjTZSHudQ+elV9v/92mV/XoFd9pPnr3mcM+XeYIap3vYGM0zxtjeYYWq3vcFkgTkGM0zltjeYYQq3vcEMU7ftDWaYsm1vMHK+x2DGOUn+BZi8pH++NudyBobR+eb5DaaegWF0viYwjM7XBCYLzDEYRudrAsPofE1gGJ1vTuUJJp2CYXS+JjCMztcCZpzz495gKJ2vBQyl87WAoXS+FjBZYI7BUDpfCxhK52sBI+d7AkbO9wSMnO8hmHWcU+PeYOR8T8DI+Z6AkfM9AZMF5hiMnO8JGDnfEzByvidg5HxPwMj5HoMZ56y4Nxg53xMwcr4nYOR8T8BkgTkGI+d7AkbO9wSMnO8JGDnfEzByvsdgIh+O7wtGzvcEjJzvCZjAPqasz/cQ1rJPV2C++M7zUl8fRn5Aen/1VA+++qHkeUA1rZ+XMqZ88NXrC8e6fdBI0yf0wB5pXOiB/de40AN7u3GhB/aNw0JfAntSSOhlen5x+XQvf0IP7HdBoS8v6NsZ9MBeelzogZ9Qjws9C/rvoSuRdoCuRNoBuhKps0/fn3Os+34GXYm0A3Ql0t9Dz0qkHaArkXaArkTaAboSaQfoWdB/D12JtAN0JdIO0JVIO0BXIu0AXYn099BXJdIO0JVIO0BXIu0AXYm0A/Qs6L+HrkTaAboSaQfoSqQdoCuRdoCuRPp76EWJtAN0JdIO0JVIO0BXIu0APQv676ErkXaArkTaAboSaQfoSqQdoCuR/h565Ovd40JXIu0AXYm0A3T59Evoyzw/oS/7egXd0A0Q+fb1uNDl0ztAl0/vAF0+/ffQI98ah4Ru+cR05Dvm40KXT+8AXf9y1AF6FvTfQ1ci7QBdidTZMhqevUS+dz8udCXSDtCVSH8PfVci7QBdibQDdCXSDtCVSDtAz4L+e+hKpB2gK5F2gK5E2gG6EmkH6EqkP4deJiXSDtCVSDtAVyLtAF2JtAP0LOi/h65E2gG6EmkH6EqkHaArkXaArkT6e+hJibQDdCXSDtCVSDtAVyLtAD0L+u+hK5F2gK5E2gG6EmkH6EqkHaArkf4e+qxE2gG6EmkH6JkReiov6PO8X0A3fPC8zJTO2x8jpZf2x0jpjv0xUvpdf4yUDvYrjI9/YX1+51RPMC6UnvRLjJcfsi4Lpcv0x0j5Lxn+GCn/bcIfYxZGD4xKMS4YlWIufaPh0cSiFOOCUSnGBaNSjAfGrBTjglEpxgWjUowLRqUYF4xZGD0wKsW4YFSKccGoFOOCUSnGBaNSjAfGVSnGBaNSjAtGpRgXjEoxLhizMHpgVIpxwagU44JRKcYFo1KMC0alGA+MRSnGBaNSjAtGpRgXjEoxLhizMHpgVIpxwagU44JRKcYFo1KMC0alGA+MVSnGBaNSjAvGzIhxSs/vPE81X2E0fGawUvpGf4yUvtEfI6Vv9MdI6Rv9MVL6xq8wWj5PvVH6xi8xXn/YbaP0jf4YKZ9++2OkfPrtjzELowdGpRgXjEoxl77R8GhiU4pxwagU44JRKcYD464U44JRKcYFo1KMC0alGBeMWRg9MCrFuGBUinHBqBTjglEpxgWjUowDxsp5k94fo1KMC0alGBeMSjEuGLMwemBUinHBqBTjglEpxgWjUowLRqUYD4ycd8z9MSrFuGBUinHBqBTjgjELowdGpRgXjEoxLhiVYlwwKsW4YFSK8cDIefvaH6NSjAvGTIgxbXX654vTvsxXGK8/M1gp71PfgJHRN96AkdE33oCR0TfegJHRN36H0fB56kp5n/pbjJcfdquU96lvwMj49PsGjIxPv2/AmIXRA6NSjAtGpZhL32h4NEF5n/oGjEoxLhiVYjwwUt6nvgGjUowLRqUYF4xKMS4YszB6YFSKccGoFOOCUSnGBaNSjAtGpRgPjJT3qW/AqBTjglEpxgWjUowLxiyMHhiVYlwwKsW4YFSKccGoFOOCUSnGAyPlfeobMCrFuGBUinHBqBTjgjELowdGpRgXjEoxLhiVYlwwKsW4YFSK8cBIeZ/6BoxKMS4YMyPGml4Y6+fnAP/6M4OU96lvwEjpG/0xUvpGf4yUvtEfI6Vv/Aqj5VNalPepb8BI6Rv9MVI+/fbHSPn02x9jFkYPjEoxl4bHkKkp71PfgFEpxgWjUowLRqUYD4yU96lvwKgU44JRKcYFo1KMC8YsjB4YlWJcMCrFuGBUinHBqBTjglEpxgHjRnmf+gaMSjEuGJViXDAqxbhgzMLogVEpxgWjUowLRqUYF4xKMS4YlWI8MFLep74Bo1KMC0alGBeMSjEuGLMwemBUinHBqBTjglEpxgWjUowLRqUYD4yU96lvwDiMb8zT6zsvF9952Z9vil/2P6f4AJMF5hjMMN7OG8wwbs0bzDD+yxvMMI7KG8wwHskZzDjXlb3BDPM01hvMMM9XvcHI+Z6AyYRg8vL8xjmXMzCMzjfPbzD1DAyj8zWBYXS+JjCMztcEhtH5WsCMc5HXGwyj882pPMGkUzCMztcEhtH5msBkgTkGQ+l8LWAona8FDKXztYChdL4WMJTO1wBmnCuu3mDkfE/AyPmegJHzPQGTBeYYjJzvCRg53xMwcr4nYOR8T8DI+R6DGefypzcYOd8TMHK+J2DkfE/AZIE5BiPnewJGzvcEjJzvCRg53xMwcr7HYMa5FukNRs73BIyc7wkYOd8TMFlgjsHI+Z6AkfM9ARPYx+T1+Zb/mvftAozl8wGRLxL6iw3sN/zFBvYQ/mID+wJ/sZlJbOD97S828E72Fxv4CZO/2MBPjfzFMjmoyNfQvhJr+dRk5Jtl34k1fBgn8mUxf7GjOCiT2MwkdhQHZRI7ioMyiR3FQVkey0S+HuUvdhQHZRC7R77E5C92GAdlETuMg7KIHcZBWcRmJrHDOCiL2GEclEUskYPaI1+u8RfL5KAiX4HxF8vkoCJfVPEXy+SgIl8n8RfL5KAiX/rwF8vkoCJfzfAXy+SgIl+g8BfL5KBmJgcV+QKIv9jMJJbJQUW+vuEvlslBRb6S4S+WyUFFvmbhL5bJQUW+OuEvNvCeXerrYzEPKRdiDe9d3CN3/fuLDbxn/cUG3rP+YgPvWXexkbvz/cUG3rP+YgPvWX+xgZ9U+IvNTGKZHFTkzvivxBo+/bFH7oH/Tuz1m6v3yN3u/mJHcVAWsZE72P3FjuKgTGJHcVAmsaM4KMtjmcid5v5iR3FQJrHDOCiL2GEclEXsMA7KInYYB2UQG7nL21/sMA7KInYYB2URy+SgIndj+4tlclCRO6z9xTI5qMhd0/5imRxU5E5of7FMDipyd7O/WCYHFblj2V8sk4OK3IXsL5bJQVUmBxW5udpdbOTman+xTA4qcnO1v1gmBxW5udpfLJODitxc7S+WyUFFbq52Fxu533ieXx91mWu9EGt572LkfmN/sYH3rL/YwHvWX2zgPesvNvCe9RcbeM/6iw28Z/3FBn5S4Sw2T5H7jf3F8jioh9hRHNT1pz8eYkdxUNdvrn6IzUxiR3FQJrGjOCiT2FEclEnsKA7KJHYUB3X9WCZPkfuN/cWO4qBMYodxUBaxwzgoi9jMJHYYB2URO4yDsogdxkFZxA7joCximRxU5H5jf7FMDipyv7G/WCYHFbnf2F8sk4OK3G/sL5bJQUXuN/YXy+SgIvcb+4tlclCR+439xTI5qCUziWVyUJGbq/3FMjmoyM3V/mKZHFTk5mp/sUwOKnJztb9YJgcVubnaX2zgPZvm/Sk27dOFWMt7FyP3G/uLDbxn3cVG7jf2Fxt4z/qLDbxn/cUG3rP+YgPvWX+xgZ9U+IsN/KTCXyyTg4rcb/yVWMunPyL3G38n1vDm6sj9xv5iR3FQJrGjOCiT2FEclElsZhI7ioOyPJaJ3G/sL3YUB2USO4yDsogdxkEZxEbuN/YXO4yDsogdxkFZxA7joCxiM5NYJgcVud/YXyyTg4rcb+wvlslBRe439hfL5KAi9xv7i2VyUJH7jf3FMjmoyP3G/mKZHFTkfmN/sUwOamdyUJGbq/3FMjmoyM3V/mIzk1gmBxW5udpfLJODitxc7S+WyEGlyM3V/mID79lprk+xDw9/Idbw3sU0Bd6z/mID71l/sYH3rL/YwHvWX2zgPesvNvCedRcbud/YX2zgJxX+YgM/qfAXy+SgIvcbfyXW8OmPFLnf+Dux12+uTpH7jf3FjuKgTGJHcVAmsaM4KIvYyP3G/mJHcVCWxzKR+439xY7ioExiM5PYYRyURewwDsoidhgHZRE7jIOyiB3GQRnERu439hfL5KAi9xv7i2VyUJH7jf3FMjmoyP3G/mKZHFTkfmN/sUwOKnK/sb9YJgcVud/YXyyTg4rcb+wvlslBZSYHFbm52l8sk4OK3FztLjZyc7W/WCYHFbm52l8sk4OK3FztL5bJQUVurvYXG3fPlm19vh2x7Fu5ELu9rqJs89l7FwP3G98gNu6evUFs3D17g9i4e/YGsXH37Jdi1+c73LZtuvrOeXpNsVx97enEHxDj7m8giHF9ARDEuE9sgCDGfRIEBHEY59sRYuC+ayCIwzj1nhCHSQA9IQ6TLHpCzILYDlGJxQGiEosDRCUWB4hKLA4QlVjaIQbulweCqMTiAFGJxQGiEosDxCyI7RCVWBwgKrE4QFRicYCoxOIAUYmlHWLg1v8YEC21dYGvCQBB1Hb+96+1vOMycEc+EERtZweI2s7NEOfAtwKAIOp5ogNE+cQLiOX54Ym8LWcQ5RMdIGZBbIeo54kOEJVYHCAqsThAVGJxgKjE0g4x8NUVIIhKLA4QlVgcICqxOEDMgtgOUYnlBIxSyAkYymTxxRTzMtWXvvQxRZ4/MVJmC3+MlOnCHWPgm0RQGCkThj9Gyozhj5EyZfhjzMJ4gTGnl751OsNImTT8MVLmEn+MSjEuGJViXDAqxXhgDHwXDAqjUswVxrq89G3zGUalGBeMSjEuGLMwemBUinHBqBTjglEpxgWjUsw3GPczjEoxHhgD3+aDwjhMisnPz5Fs+exzJIGv/t0gdphEYBGbmcQO464tYofxwBaxwzhVi9hh/KRF7DCuzyA28NW/G8QyOajAV/9uEMvkoAJf/btBLJODCnz17waxTA5qZXJQ49xzNIgd556jRSyTgxrnnqNFLJODGueeo0Usk4Ma5z6iRSyTgxrn3qBFLJODGud+n0Usk4Ma5x6eRSyTgxrnvpxFLJODGudem0Usk4Ma5/6ZRSyTgxrnnphFLJODGuc+l0Usk4Ma596VRSyTgxrnfpRFLJODGucek0Usk4PamRzUzuSgxrlcZRHL5KD2zCSWyUGNc+PLIpbJQY1zM8silshBLePcoLKIJXJQyzg3nSxiiRzUMmUmsUQOahnn5pBFLJGDWsa54WMRy+SgxrmJYxHL5KDGuTFjEcvkoMa52WIRy+SgxrmXYhHL5KDGuVRiEcvkoMa5+mERy+SgxrmgYRHL5KDGuUZhEcvkoMa57GARy+SgxrmSYBHL5KDGuThgEcvkoMZp77eIZXJQ4zThW8QyOahxWuUtYinbtr84f73szyGWPZ9A5Oza9oZIeS/IGyLltSBviJS3grwhZkFsh0h5J8gbIuWVIG+IlDeCvCFSXgjyhqjE0g5xnAb6myA+/g3/n6/NuZxBVGK5gDi/IZ49gBinMb8nRCUWB4hZENshKrE4QFRicYCoxHIBMT3/eSCnU4hKLA4QlVjaIY5z8aEnRCUWB4hKLA4QlVgcIGZBbIeoxOIAUYnFAaISiwNEJRYHiEos7RDHubDSE6ISiwNEJRYHiEosDhCzILZDVGJxgKjE4gBRicUBohKLA0QllnaI41w06glRicUBohKLA0QlFgeIWRDbISqxOEBUYnGAqMTiAFGJxQGiEks7xHEuiPWEqMTiAFGJxQFiYJ9YX+85L9u8XEGcn8S3+ewzeJHvbfmLDey7/MUG9kf+YgP7GG+xOfK9re/E3vUqX+rzVX5bziAG9hs4EAP7DRyIgZ+Q4kDMgtgOcRjn2xPiMI66J8RhnHpPiMMkgJ4Qh0kWHSFGvm+HA1GJxQGiEosDRCUWB4hZENshKrE4QFRicYCoxOIAUYnFAaISSzvEyPckcSAqsThAzIL4r19rqBrOka8v4kDUdr74db5+d1GOfFMQBmLkW4U4ELWdHSDqeaIDRD1PdICYBbHZbEe+MYkDUc8THSDqeaIDRCUWB4hKLO0QI19nxYGoxOIAUYnFAaISiwPELIjtEJVYHCAqsThAVGI5AaMUcgKGMll8MUWa6vOf5dK0zR/65g+Mke+oImGkTBf+GCnzhT9GyoThjzELowdGypThj5EyZ3yDMU1PFimlfIaRMmn4Y6TMJf4YlWI8MEa+rYqEUSnGBaNSjAtGpZgvMM7pDGMWRg+MSjEuGIdJMfn5tsotn72tMvI9VH+xwyQCi9hhfLtBbOQ7oP5ih/HAFrHDOFWL2GH8pEVsZhI7jDeziGVyUJHvM/qLZXJQke8duouNfJfQXyyTg4p8589fLJODinw3z18sk4OKfIfOXyyTg4p8181fLJODinwnzV8sk4OKfHfMXyyTg9ozk1gmBzXO5TeLWCYHNc7lN4tYIge1jnP5zSKWyEGt41xSs4glclDrlJnEEjmodZxLXxaxRA5qHedylkUsk4Ma5xKVRSyTgxrnspNFLJODGudSkkUsk4Ma5/KQRSyTgxrnko9FLJODGucyjkUsk4OamRzUzOSgxrkhZBHL5KBmJgc1Mzmoca4tWcQyOahxrhdZxDI5KN1gufhaw5m5VTdYPCCq0dgBohqNHSCq/dgBom6wtEPUDRYPiLrB4gBRN1gcIOoGiwPELIjtEJVY/v1r8/L8vjmXM4hKLBcQ5zfEswcQusHiAVGJxQGiEks7RM7LLt4QlVgcICqxXEC8PtG+ct508YaYBbEdohKLA0QlFgeISiwOEJVYHCAqsbRD5Lzi4g1RicUBohKLA0QlFgeIWRDbISqxOEBUYnGAqMTiAFGJxQGiEks7xHEu4/SEqMTiAFGJxQGiEosDxCyI7RCVWBwgKrE4QFRicYCoxOIAUYmlHeI4l6h6QlRicYCoxOIAUYnFAWIWxHaISiwOEJVYHCAqsbRDjHxva13m1xfv0xXE+fkZvG0++wxe5Htb/mID+y5/sYH9kb/YzCQ2sN/4TuxNr/KWzqnId7xwIAb2GzgQAz8hxYEY+AkpCsQS+U4aDsRhHHVPiMM49Z4Qh0kAPSFmQWyHqMTiAFGJxQGiEosDRCUWB4hKLO0QI98lxIGoxOIAUYnFAaISiwPELIjtEJVYHCAqsThAVGJxgKjE4gBRiaUdYuQ7oDgQlVgcICqxOEBUYnGAmAWxHaJ84r9/reEkRYl8PRQGYuTblSEgGt6FXhZtZweI2s4OELWdHSDqeaIDRD1PdIAon3gBsdQnxG05gyif6ABRzxPbIUa+zooDUYnFAaISiwNEJRYHiFkQ2yEqsThAVGJxgKjE4gBRicUBohJLO8TI11k7QPwAoxRyAoYyWXwxxUPHc4qU9/Sh7w+MlNnCH2MWRg+MlPnCHyNlwvDHSJkx/DFSpgx/jJQ54yuMr/chPX7wfIIx8lVVJIyUucQfo1KMC0alGBeMWRg9MCrFuGBUirnAuK5vjOUUo1KMC0alGBeMSjEeGCNfWkXCqBTjglEpxgWjUswVxpJfGOtyhjELowdGpRgXjEoxLhiVYlwwKsW4YFSK8cAY+frqdxgNXQyRr6T6ix0mEVjEDuPbLWIzk9hhPLBF7DBO1SJ2GD9pETuM67OIHcabGcSOc5fUIpbJQY1zl9QilslBjXOX1CKWyUGNcz/UIpbJQY1zj9MilshB1XHuW1rEEjmoOs69SItYIgdVp8wklshB1XHuGVrEEjmoOs59QItYJgc1zr09i1gmBzXO/TqLWCYHNc49OItYJgc1zn01i1gmBzXOvTKLWCYHNc79L4tYJgc1zj0ti1gmBzXOfSqLWCYHNTM5qHEuhFnEMjmomclBLUwOapxbahaxTA5qnNtkFrGZSSyTgxrnJpdFLJODGufGlUUsk4Ma52aURSyTgxrnBpNFLJODGuemkUUsk4Ma50aQRSyTgxrn5o5FLJODGueGjUUsk4Ma59aMRSyTgxrnbotFLJODGucGikUsk4Ma556IRSyTgxrnNodFLJODGufOhUUsk4Ma52aERSyTgxrn/oJFLJODGueWgUUsk4Ma5y6ARSyTgxqnY98ilslBjdNXbxHL5KDG6X63iGVyUOP0qFvEMjkopk7yytRJXpk6yStTJ3ll6iSvTJ3klamTvDJ1klemTvLK1ElemTrJK1MneWXqJK9MneSVqZO8MnWSV6ZO8srUSV6ZOskrUyf5xtRJvjF1km9MneQbUyf5NmUmsUQOahunufqbY695en3j5eJrl/153H7Z8xlEyou5zhDHadruCXEYv9ET4jA+pifEYfxRT4hZENshDuPnekIc5klbT4jDPMHrCVGJxQGiEsu/f21ent8353ICcZxm+7sgzm+IZw8gxmnM7wlRicUBohKLA8QsiO0QlVgcICqxXEBMz38eyOkUohKLA0QlFgeISiztEMe5JNETohKLA0QlFgeISiwOELMgtkNUYnGAqMTiAFGJxQGiEosDRCWWdojjXG7pCVGJxQGiEosDRCUWB4hZENshKrE4QFRicYCoxOIAUYnFAaISSzvEcS4l9YSoxOIAUYnFAaISiwPELIjtEJVYHCAqsThAVGJxgKjE4gBRiaUd4jiXyXpCVGJxgJjjQly258fqyuPfdq8gzs8v3uazz+BFvrflLzaw7/IXG9gf+YsN7GP8xQb2G9+JvetVvtTnq/y2nECMfMcLB2Jgv4EDMfATUhyIgZ+Q4kDMgtgOcRhH3RPiME69J8RhEkBPiMMki54QlVjaIUa+m4cDUYnFAaISiwNEJRYHiFkQ2yEqsThAVGJxgKjE4gBRicUBohJLO8TIdypxIMon/vvXWqqGI19fxIGo7Xzx62x4d1Hkm4I4ELWdmyHukW8g4kDU80QHiHqe6ABRPrHZbO9TFsR2iHqe6ABRzxMdICqxOEBUYnGAqMTSDjHydVYciEosDhCVWBwgKrE4QMyC2A5RicUBohLLCRilkBMwlMniiynSVJ9TpGmbP/TNnxgps4U7xsiXVJEwUuYLf4yUCcMfI2XG8MeYhdEDI2XO+AZjmp4sUkr5DCNl0vDHSJlL/DEqxbhgVIrxwBj5uioSRqUYF4xKMV9gnNMZRqUYF4xZGD0wDpNi8vNtlVs+e1tl5Huo/mKHSQQWscP4dovYYdy1QWzke53+Yodxqhaxw/hJi9hhXJ9FbGYSy+SgIt9n9BfL5KAi3zv0F8vkoCLfD/QXy+SgIt/j8xfL5KAi37fzF8vkoCLfi/MXy+SgIt9f8xfL5KAi3zPzF8vkoAqTgypMDmqcy28WsUwOapzLbxaxTA5qnMtvFrFMDmqcC20WsUwOapyLZxaxTA5qnAtiFrFMDmqci1wWsUwOapwLVxaxTA5qnItRFrFMDmqcC0wWsUwOapyLRhaxTA5qnAtBFrFMDmqcizsWsUwOapwLNhaxTA5qZ3JQ49wQsojNTGKZHNTO5KDGubZkEcvkoMa5XnQpdp3GuTJkEatG43//2uszcw+Iw+zvnhDVaOwAUY3GDhDVfuwAUTdYHCDqBks7RN1g8YCoGywOEHWDxQGiEosDxCyI//q1eXl+35zLGUQllguI8xvi2QMI3WDxgKjE4gBRicUBohJLO0TOuy7eEJVYLiBenmh/QFRicYCoxOIAMQtiO0QlFgeISiwOEJVYHCAqsThAVGJph8h5w8UbohKLA0QlFgeISiwOELMgtkNUYnGAqMTiAFGJxQGiEosDRCWWdojjXNzpCVGJxQGiEosDRCUWB4hZENshKrE4QFRicYCoxOIAUYnFAaISSzvEcS5c9YSoxOIAUYnFAaISiwPELIjtEJVYHCAqsThADOwT5/KcvyxpuoBo+Qxe5Htb/mID+y5/sYH9kb/YwD7GX2xmEhvYF/iLDby//cUGfjLoLzbwEzx/sUwOKvK9ra/EWtoGIt/b+k6s4cObke9t+YsdxUGZxGYmsaM4KJPYURyUSewoDsryWCbyvS1/saM4KIvYyPe2/MUO46AsYodxUBaxwzgoi9jMJHYYB2URO4yDsohlclCR7235i2VyUJHvbfmLZXJQke9t+YtlclCR7235i2VyUJHvbfmLZXJQke9t+YslclAp8r0tf7FEDipNRA4qRb6k5i82M4klclAp8gUxf7FEDipFvsjlL5bJQUW+cOUvlslBRb4Y5S828J5NrylK2vcLsc7XmlLkGzl9wQTe333BBN71fcEE9gVdwUS+OdMXTGC/0RdMYG/SF0zgJ0F9wWSBOQYj53sChtH5Gj4NlCLfT7kPzPUb81Pkmyh9wTA6XwuYyLdL+oJhdL4mMIzO1wSG0flaHm1GvgXSFwyj8zWBoXS+FjCUztcChtL5WsBQOl8DmMg3MPqCoXS+FjCUztcCRs73BEwWmGMwcr4nYOR8T8DI+Z6AkfM9ASPnewwm8i2FvmDkfE/AyPmegJHzPQGTBeYYjJzvCRg53xMwcr4nYOR8T8DI+R6DiXx1oi8YOd8TMHK+J2DkfE/AZIE5BiPnewJGzvcEjJzvCRg532Mwv74T4fyO/19ffvAef8EeP2OPv2KPX7DHr9jjb9jj79Dj//oSgff42Ft3i7t1LZ+G2+JuXcvHJn7d6O89ftytaxo/7tY1jR9365rGj7t1TePH3bqWsLjH3bqm8eNuXdP4gbeuZfzAW9cyfuCtaxk/8Na1jB9461rGD7x1LeMH3rqW8aG37jxBb915gt668wS9decJeuvOE/TWnSforTtP0Ft3nqC37jxBb915wt66CXvrJuytm7C3bsLeugl76ybsrZuwt27C3roJe+sm7K07Y2/dGXvrzthbd8beur/uO/Yev/11f3pO9GCxOo5veE/D7NAE23X8HXp8h1bVruMn7PFn7PEX7PEz9vgr9vgFe3zsrbvE3bqGdxLOS9yta3g70pzjbl3T+HG3rmn8uFvXNH7crWsaP+7WNY0fd+tawmKOu3VN48fduqbxA29dy/iBt65h/DXw1rWMH3jrWsYPvHUt4wfeupbxA29dy/jYW3fF3ror9tZdsbfuir11C/bWLdhbt2Bv3YK9dR0alrqOj711C/bWLdhbt2Bv3YK9dSv21q3YW7dib92KvXUd2pG6jo+9dSv21q3YW7dib92KvXU37K3b3s+T5udPmVNNjuNb3tPQ3s/Td/wVe/yCPX7FHn/DHn+HHr+9n6fv+Al7/Bl7fOyt297Pc9v4lncS7nG3ruXtSHvcrWsaP+7WNY0fd+uaxo+7dQ3jL1PcrWsaP+7WNYTFZYq7dU3jx926pvEDb13L+IG3rmX8wFvXMn7grWsZP/DWtYwfeOsaxk+Bt65lfOytm7C3bsLeuu39PH3Hx966CXvrJuytm7C3bsLeujP21p2xt+6MvXVn7K3b3s/Td3zsrTtjb90Ze+vO2Ft3xt66C/bWXbC37oK9dRfsrdvejtR3fOytu0Bu3f/85/8D"
         },
         {
             "name": "set_is_valid_storage",
@@ -668,7 +841,23 @@
                                                         { "name": "chain_id", "type": { "kind": "field" } },
                                                         { "name": "version", "type": { "kind": "field" } },
                                                         { "name": "block_number", "type": { "kind": "field" } },
-                                                        { "name": "timestamp", "type": { "kind": "field" } }
+                                                        { "name": "timestamp", "type": { "kind": "field" } },
+                                                        {
+                                                            "name": "coinbase",
+                                                            "type": {
+                                                                "kind": "struct",
+                                                                "path": "authwit::aztec::protocol_types::address::EthAddress",
+                                                                "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                                                            }
+                                                        },
+                                                        {
+                                                            "name": "fee_recipient",
+                                                            "type": {
+                                                                "kind": "struct",
+                                                                "path": "authwit::aztec::protocol_types::address::AztecAddress",
+                                                                "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                                                            }
+                                                        }
                                                     ]
                                                 }
                                             }
@@ -684,7 +873,23 @@
                                             { "name": "chain_id", "type": { "kind": "field" } },
                                             { "name": "version", "type": { "kind": "field" } },
                                             { "name": "block_number", "type": { "kind": "field" } },
-                                            { "name": "timestamp", "type": { "kind": "field" } }
+                                            { "name": "timestamp", "type": { "kind": "field" } },
+                                            {
+                                                "name": "coinbase",
+                                                "type": {
+                                                    "kind": "struct",
+                                                    "path": "authwit::aztec::protocol_types::address::EthAddress",
+                                                    "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                                                }
+                                            },
+                                            {
+                                                "name": "fee_recipient",
+                                                "type": {
+                                                    "kind": "struct",
+                                                    "path": "authwit::aztec::protocol_types::address::AztecAddress",
+                                                    "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                                                }
+                                            }
                                         ]
                                     }
                                 }
@@ -696,9 +901,9 @@
                     { "name": "value", "type": { "kind": "boolean" }, "visibility": "private" }
                 ],
                 "param_witnesses": {
-                    "inputs": [{ "start": 0, "end": 30 }],
-                    "message_hash": [{ "start": 30, "end": 31 }],
-                    "value": [{ "start": 31, "end": 32 }]
+                    "inputs": [{ "start": 0, "end": 34 }],
+                    "message_hash": [{ "start": 34, "end": 35 }],
+                    "value": [{ "start": 35, "end": 36 }]
                 },
                 "return_type": {
                     "abi_type": {
@@ -945,7 +1150,23 @@
                                                     { "name": "chain_id", "type": { "kind": "field" } },
                                                     { "name": "version", "type": { "kind": "field" } },
                                                     { "name": "block_number", "type": { "kind": "field" } },
-                                                    { "name": "timestamp", "type": { "kind": "field" } }
+                                                    { "name": "timestamp", "type": { "kind": "field" } },
+                                                    {
+                                                        "name": "coinbase",
+                                                        "type": {
+                                                            "kind": "struct",
+                                                            "path": "authwit::aztec::protocol_types::address::EthAddress",
+                                                            "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                                                        }
+                                                    },
+                                                    {
+                                                        "name": "fee_recipient",
+                                                        "type": {
+                                                            "kind": "struct",
+                                                            "path": "authwit::aztec::protocol_types::address::AztecAddress",
+                                                            "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                                                        }
+                                                    }
                                                 ]
                                             }
                                         }
@@ -965,22 +1186,22 @@
                     "visibility": "public"
                 },
                 "return_witnesses": [
-                    32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
-                    59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
-                    86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110,
-                    111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
-                    133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154,
-                    155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176,
-                    177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198,
-                    199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220,
-                    221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232
+                    36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62,
+                    63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
+                    90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113,
+                    114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
+                    136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157,
+                    158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179,
+                    180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201,
+                    202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223,
+                    224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238
                 ]
             },
-            "bytecode": "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",
-            "debug_symbols": "5Z3LjlzZcUX/heOGcSNOPPUrhgeCH4AAQTIszQT9u68MZhUbKpq9q1nJvdEjEYU8eeMoMnewFxmLf/v0xz//++//+oc//+kvn373t0/Xv9gVn373r3/79Jf//v2f/vGTv/z19//z10+/u3769J9/+o/7f//+06f/+sMf//PT79zO3//tp/87kfCJgk80fGLgE4uesAs+Yb/8xE//9DrrtM8vte59eXW8vL1/7Nufj337+Ni3z499+/rYt++Pffv52LffD317vz727T/2W+sf+631j/3W+sd+a/1jv7X+sd9a/9hvrX/st9Y/9lt7PvZbez72W3s+9lt7PvZbez72W3t+3bd29/FSv8y/fPu3aonzUkvEy4vv3wE+iimmYpqpmGEqZomKiYupGGMqxpmKOUzFBFMxTAkcTAkcTAkcTAkcTAmcTAmcTAmcTAmcTAmcTAmcTAmcTAmcTAmcTAmcTAlcTAlcTAlcTAlcTAlcTAlcTAlcTAlcTAlcTAlcTAncTAncTAncTAncTAncTAncTAncTAncTAncTAncTAk8TAk8TAk8TAk8TAk8TAk8TAk8TAk8TAk8TAk8TAm8TAm8TAm8TAm8TAm8TAm8TAm8TAm8TAm8TAm8RAnsF1EC32/BVAxRAvtFlMB+ESWwX0QJ7BdRAvtFlMB+ESWwX0wJbEwJbEwJbEwJbM/8ar+8+MZC9lYxTVSMP+8D7PHSpvuXb7XJjakYZyrmMBUTTMU877cQE9d8fvGEXV8U449iiqmYfmKb+lGM55mftQl79efSR7f0JS3dru18DAO7zr5R/LmUizfl4oFM/Xwi4RO/Kp3ugZiPW9y/ntcw7uvxgP7oB/yqXLg/3uflAfev640H7Ac/INDNdEd2TD6fcPjEgU/An9eAP69R8ImGTwx8ArUReMI9T7jnCfc84Z4n3POEe55wzxPuecI9T7jnBfe84J4X3POCe15wzwvuecE9L7jnBfe84J433POGe95wzxvuecM9b7jnDfe84Z433POGez5wzwfu+cA9H7jnA/d84J4P3POBez5wzwfu+cI9X7jnC/d84Z4v3POFe75wzxfu+cI9X7Tn57rgEwafcPjEgU8EfCLhEwWfaPjEwCfgnsMWsWNwzw3uucE9N7jnBvfc4J4b3HODe25wzx3uucM9d7jnDvfc4Z473HOHe+5wzx3uucM9P3DPD9zzA/f8wD2HGeKBGeI5cM8P3PMD9/zAPYc53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE53IE5XMAcLmAOFzCHC5jDBczhAuZwAXO4gDlcwBwuYA4XMIcLmMMFzOEC5nABc7iAOVzAHC5gDhcwhwuYwwXM4QLmcAFzuIA5XMAcLmAOFzCHC5jDBczhAuZwAXO4gDlcwBwuYA4XMIcLmMMFzOEC5nABc7iAOVzAHC5gDhcwhwuYwwXM4QLmcAFzuIA5XMAcLmAOFzCHC5jDBczhAuZwAXO4gDlcwBwuYA4XMIcLmMMFzOEC5nABc7iAOVzAHC5gDhcwhwuYwwXM4QLmcAFzuIA5XMAcLmAOFzCHC5jDBczhAuZwAXO4gDlcwBwuYA4XMIcLmMMFzOEC5nABc7iAOVzAHC5gDhcwhwuYwwXM4QLmcAFzuIA5XMAcLmAOFzCHC5jDJczhEuZwCXO4hDlcwhwuYQ6XMIdLmMMlzOES5nAJc7iEOVzCHC5hDpcwh0uYwyXM4RLmcAlzuIQ5XMIcLmEOlzCHS5jDJczhEuZwCXO4hDlcwhwuYQ6XMIdLmMMlzOES5nAJc7iEOVzCHC5hDpcwh0uYwyXM4RLmcAlzuIQ5XMIcLmEOlzCHS5jDJczhEuZwCXO4hDlcwhwuYQ6XMIdLmMMlzOES5nAJc7iEOVzCHC5hDpcwh0uYwyXM4RLmcAlzuIQ5XMIcLmEOlzCHS5jDJczhEuZwCXO4hDlcwhwuYQ6XMIdLmMMlzOES5nAJc7iEOVzCHC5hDpcwh0uYwyXM4RLmcAlzuIQ5XMIcLmEOlzCHS5jDJczhEuZwCXO4hDlcwRyuYA5XMIcrmMMVzOEK5nAFc7iCOVzBHK5gDlcwhyuYwxXM4QrmcAVzuII5XMEcrmAOVzCHK5jDFczhCuZwBXO4gjlcwRyuYA5XMIcrmMMVzOEK5nAFc7iCOVzBHK5gDlcwhyuYwxXM4QrmcAVzuII5XMEcrmAOVzCHK5jDFczhCuZwBXO4gjlcwRyuYA5XMIcrmMMVzOEK5nAFc7iCOVzBHK5gDlcwhyuYwxXM4QrmcAVzuII5XMEcrmAOVzCHK5jDFczhCuZwBXO4gjlcwRyuYA5XMIcrmMMVzOEK5nAFc7iCOVzBHK5gDlcwhyuYwxXM4QrmcAVzuII5XMEcrmAOVzCHK5jDFczhCuZwBXO4gjlcwRyuYA5XMIcrmMM1zOEa5nANc7iGOVzDHK5hDtcwh2uYwzXM4RrmcA1zuIY5XMMcrmEO1zCHa5jDNczhGuZwDXO4hjlcwxyuYQ7XMIdrmMM1zOEa5nANc7iGOVzDHK5hDtcwh2uYwzXM4RrmcA1zuIY5XMMcrmEO1zCHa5jDNczhGuZwDXO4hjlcwxyuYQ7XMIdrmMM1zOEa5nANc7iGOVzDHK5hDtcwh2uYwzXM4RrmcA1zuIY5XMMcrmEO1zCHa5jDNczhGuZwDXO4hjlcwxyuYQ7XMIdrmMM1zOEa5nANc7iGOVzDHK5hDtcwh2uYwzXM4RrmcA1zuIY5XMMcrmEO1zCHa5jDNczhGuZwDXO4hjlcwxyuYQ7XMIdrmMM1zOEa5nANc7iGOdzAHG5gDjcwhxuYww3M4QbmcANzuIE53MAcbmAONzCHG5jDDczhBuZwA3O4gTncwBxuYA43MIcbmMMNzOEG5nADc7iBOdzAHG5gDjcwhxuYww3M4QbmcANzuIE53MAcbmAONzCHG5jDDczhBuZwA3O4gTncwBxuYA43MIcbmMMNzOEG5nADc7iBOdzAHG5gDjcwhxuYww3M4QbmcANzuIE53MAcbmAONzCHG5jDDczhBuZwA3O4gTncwBxuYA43MIcbmMMNzOEG5nADc7iBOdzAHG5gDjcwhxuYww3M4QbmcANzuIE53MAcbmAONzCHG5jDDczhBuZwA3O4gTncwBxuYA43MIcbmMMNzOEG5nADc7iBOdzAHG5gDjcwhxuYwy3M4RbmcAtzuIU53MIcbmEOtzCHW5jDLczhFuZwC3O4hTncwhxuYQ63MIdbmMMtzOEW5nALc7iFOdzCHG5hDrcwh1uYwy3M4RbmcAtzuIU53MIcbmEOtzCHW5jDLczhFuZwC3O4hTncwhxuYQ63MIdbmMMtzOEW5nALc7iFOdzCHG5hDrcwh1uYwy3M4RbmcAtzuIU53MIcbmEOtzCHW5jDLczhFuZwC3O4hTncwhxuYQ63MIdbmMMtzOEW5nALc7iFOdzCHG5hDrcwh1uYwy3M4RbmcAtzuIU53MIcbmEOtzCHW5jDLczhFuZwC3O4hTncwhxuYQ63MIdbmMMtzOEW5nALc7iFOdzCHG5hDrcwh1uYwy3M4RbmcAtzuIU5nF0wiLuPGH7E8SMHPxL4kcSPFH6k8SODH8G7b3j3De++4d03vPuGd9/w7hvefcO7b3j3De++4913vPuOd9/x7jvefce773j3He++4913vPsH7/7Bu3/w7h+8+wfv/sG7f/DuH7z7B+/+wbsfePcD737g3Q+8+4F3P/DuB979wLsfePcD737i3U+8+4l3P/HuJ979xLufePcT737i3U+8+4V3v/DuF979wrtfePcL737h3S+8+4V3v/DuN979xrvfePcb737j3W+8+413v/HuN979xrs/ePcH7/7g3R+8+4N3f/DuD979wbs/ePcH7/7i3V+8+4t3f/HuL979xbu/ePcX7/7i3cdZn+Gsz3DWZzjrM5z13b/rxY8kfqTwI40fGfwI3n2c9RnO+gxnfYazPsNZn+Gsz3DWZzjrM5z1Gc76DGd9hrM+w1mf4azPcNZnOOsznPUZzvoMZ32Gsz7DWZ/hrM9w1mc46zOc9RnO+gxnfYazPsNZn+Gsz3DWZzjrM5z1Gc76DGd9hrM+w1mf4azPcNZnOOsznPUZzvoMZ32Gsz7DWZ/hrM9w1mc46zOc9RnO+gxnfYazPsNZn+Gsz3DWZzjrM5z1Gc76DGd9hrM+w1mf4azPcNZnOOsznPUZzvoMZ32Gsz7DWZ/hrM9w1mc46zOc9RnO+gxnfYazPsNZn+Gsz3DWZzjrM5z1Gc76DGd9hrM+w1mf4azPcNZnOOsznPUZzvocZ32Osz7HWZ/jrM9x1uc463Oc9TnO+hxnfY6zPsdZn+Osz3HW5zjrc5z1Oc76HGd9jrM+x1mf46zPcdbnOOtznPU5zvocZ32Osz7HWZ/jrM9x1uc463Oc9TnO+hxnfY6zPsdZn+Osz3HW5zjrc5z1Oc76HGd9jrM+x1mf46zPcdbnOOtznPU5zvocZ32Osz7HWZ/jrM9x1uc463Oc9TnO+hxnfY6zPsdZn+Osz3HW5zjrc5z1Oc76HGd9jrM+x1mf46zPcdbnOOtznPU5zvocZ32Osz7HWZ/jrM9x1uc46/O3WV9c8/lQXPvmsX3XsbeZ37eP2fuOvflpuP/w1D6fu/+8zn928Kd/fnU/HnL/d9vLa2+w9PKQ84yHxDMeks94SH2Hh5w+j1ef7dfHzL756vTX9z4/e/WjqGYsahiLWsKi3mbJH1nU/V3JR6zev257eX1fb34r+vHi6zWFz/VyAVO/gKtf4KhfIKgu8KgqKasqyqqasqr5AVVtvFRV1/zKL8ZqX+Bcl/oFTP0Crn6Bo36BUL9Aql+g1C/Q6hcQn8TnUp/Epj6JTX0Sm/okNvVJbOqT2NQnsalPYlOfxKY+iU19Erv6JHb1Sezqk9jVJ7GrT2JXn8SuPoldfRK7+iR29Ul81CfxUZ/ER30SH/VJfNQn8VGfxEd9Eh/1SXzUJ/FRn8ShPolDfRKH+iQO9Ukc6pM41CdxqE/iUJ/EoT6JQ30Sp/okTvVJnOqTONUncapP4lSfxKk+iVN9Eqf6JE71SVzqk7jUJ3GpT+JSn8SlPolLfRKX+iQu9Ulc6pO41Cdxq0/iVp/ErT6JW30St/okbvVJ3OqTuNUncatP4lafxKM+iUd9Eo/6JB71SfxdfEo/9ALqk3jUJ/GoT+JRn8SjPolXfRKv+iRe9Um86pP4h3irvusF1Cfxqk/iVZ/E6o6to+7YCnXHVqg7tkLdsRXqjq24xCdxqDu2Qt2xFeqOrVB3bIW6YyvUHVuh7tgKdcdWqDu2Qt2xFeqOrVB3bIW6YyvUHVuh7tgKdcdWqDu2Qt2xFeqOrVB3bIW6YyvUHVuh7tgKdcdWqDu2Qt2xFeqOrVB3bIW6YyvUHVuh7tgKdcdWqDu2Qt2xFeqOrVB3bIW6YyvUHVuh7tgKdcdWqDu2Qt2xFeqOrVB3bIW6YyvUHVuh7tgKdcdWqDu2Qt2xFeqOrVB3bIW6YyvUHVuh7tgKdcdWqDu2Qt2xFeqOrVB3bIW6YyvUHVuh7tgKdcdWqDu2Qt2xFeqOrVB3bIW6YyvUHVuh7tgKdcdWqDu2Qt2xFeqOrVB3bIW6YyvUHVuh7tgKdcdWqDu2Qt2xFeqOrVB3bIW6YyvUHVuh7tgKdcdWqDu2Qt2xFeqOrVB3bIW6YyvUHVuh7thKdcdWqju2Ut2xleqOrbzEJ3GqO7ZS3bGV6o6tVHdspbpjK9UdW6nu2Ep1x1aqO7ZS3bGV6o6tVHdspbpjK9UdW6nu2Ep1x1aqO7ZS3bGV6o6tVHdspbpjK9UdW6nu2Ep1x1aqO7ZS3bGV6o6tVHdspbpjK9UdW6nu2Ep1x1aqO7ZS3bGV6o6tVHdspbpjK9UdW6nu2Ep1x1aqO7ZS3bGV6o6tVHdspbpjK9UdW6nu2Ep1x1aqO7ZS3bGV6o6tVHdspbpjK9UdW6nu2Ep1x1aqO7ZS3bGV6o6tVHdspbpjK9UdW6nu2Ep1x1aqO7ZS3bGV6o6tVHdspbpjK9UdW6nu2Ep1x1aqO7ZS3bGV6o6tVHdspbpjK9UdW6nu2Ep1x1aqO7ZS3bGV6o6tVHdspbpjK9UdW6nu2Ep1x1aqO7ZS3bGV6o6tVHdspbpjK9UdW6nu2Cp1x1apO7ZK3bFV6o6tusQncak7tkrdsVXqjq1Sd2yVumOr1B1bpe7YKnXHVqk7tkrdsVXqjq1Sd2yVumOr1B1bpe7YKnXHVqk7tkrdsVXqjq1Sd2yVumOr1B1bpe7YKnXHVqk7tkrdsVXqjq1Sd2yVumOr1B1bpe7YKnXHVqk7tkrdsVXqjq1Sd2yVumOr1B1bpe7YKnXHVqk7tkrdsVXqjq1Sd2yVumOr1B1bpe7YKnXHVqk7tkrdsVXqjq1Sd2yVumOr1B1bpe7YKnXHVqk7tkrdsVXqjq1Sd2yVumOr1B1bpe7YKnXHVqk7tkrdsVXqjq1Sd2yVumOr1B1bpe7YKnXHVqk7tkrdsVXqjq1Sd2yVumOr1B1bpe7YKnXHVqk7tkrdsVXqjq1Sd2yVumOr1B1bpe7YKnXHVqk7tkrdsVXqjq1Sd2yVumOr1B1bpe7YanXHVqs7tlrdsdXqjq2+xCdxqzu2Wt2x1eqOrVZ3bLW6Y6vVHVut7thqdcdWqzu2Wt2x1eqOrVZ3bLW6Y6vVHVut7thqdcdWqzu2Wt2x1eqOrVZ3bLW6Y6vVHVut7thqdcdWqzu2Wt2x1eqOrVZ3bLW6Y6vVHVut7thqdcdWqzu2Wt2x1eqOrVZ3bLW6Y6vVHVut7thqdcdWqzu2Wt2x1eqOrVZ3bLW6Y6vVHVut7thqdcdWqzu2Wt2x1eqOrVZ3bLW6Y6vVHVut7thqdcdWqzu2Wt2x1eqOrVZ3bLW6Y6vVHVut7thqdcdWqzu2Wt2x1eqOrVZ3bLW6Y6vVHVut7thqdcdWqzu2Wt2x1eqOrVZ3bLW6Y6vVHVut7thqdcdWqzu2Wt2x1eqOrVZ3bLW6Y6vVHVut7thqdcdWqzu2Wt2x1eqOrVZ3bLW6Y6vVHVut7tgadcfWqDu2Rt2xNeqOrbnEJ/GoO7ZG3bE16o6tUXdsjbpja9QdW6Pu2Bp1x9aoO7ZG3bE16o6tUXdsjbpja9QdW6Pu2Bp1x9aoO7ZG3bE16o6tUXdsjbpja9QdW6Pu2Bp1x9aoO7ZG3bE16o6tUXdsjbpja9QdW6Pu2Bp1x9aoO7ZG3bE16o6tUXdsjbpja9QdW6Pu2Bp1x9aoO7ZG3bE16o6tUXdsjbpja9QdW6Pu2Bp1x9aoO7ZG3bE16o6tUXdsjbpja9QdW6Pu2Bp1x9aoO7ZG3bE16o6tUXdsjbpja9QdW6Pu2Bp1x9aoO7ZG3bE16o6tUXdsjbpja9QdW6Pu2Bp1x9aoO7ZG3bE16o6tUXdsjbpja9QdW6Pu2Bp1x9aoO7ZG3bE16o6tUXdsjbpja9QdW6Pu2Bp1x9aoO7ZG3bE16o6tUXdsjbpja9QdW6Pu2Fp1x9aqO7ZW3bG16o6tvcQn8ao7tlbdsbXqjq1Vd2ytumNr1R1bq+7YWnXH1qo7tlbdsbXqjq1Vd2ytumNr1R1bq+7YWnXH1qo7tlbdsbXqjq1Vd2ytumNr1R1bq+7YWnXH1qo7tlbdsbXqjq1Vd2ytumNr1R1bq+7YWnXH1qo7tlbdsbXqjq1Vd2ytumNr1R1bq+7YWnXH1qo7tlbdsbXqjq1Vd2ytumNr1R1bq+7YWnXH1qo7tlbdsbXqjq1Vd2ytumNr1R1bq+7YWnXH1qo7tlbdsbXqjq1Vd2ytumNr1R1bq+7YWnXH1qo7tlbdsbXqjq1Vd2ytumNr1R1bq+7YWnXH1qo7tlbdsbXqjq1Vd2ytumNr1R1bq+7YWnXH1qo7tlbdsbXqjq1Vd2ytumNr1R1bq+7YWnXH1qo7tlbdsbXqjq1Vd2ytumNr1R1bK+7Yun+mPYnvn2lP4vtn2pP4/pn2JL5/pj2J759pT+L7Z9qT+P6Z9iS+f6Y9ie+fqU9iccfWfQH1SSzu2LovoD6JxR1b9wXUJ7G4Y+u+gPokFnds3RdQn8Tijq37AuqTWNyxdV9AfRKLO7buC6hPYnHH1n0B9Uks7ti6L6A+icUdW/cF1CexuGPrvoD6JBZ3bN0XUJ/E4o6t+wLqk1jcsXVfQH0Sizu27guoT2Jxx9Z9AfVJLO7Yui+gPonFHVv3BdQnsbhj676A+iQWd2zdF1CfxOKOrfsC6pNY3LF1X0B9Eos7tu4LqE9iccfWfQH1SSzu2LovoD6JxR1b9wXUJ7G4Y+u+gPokFnds3RdQn8Tijq37AuqTWNyxdV9AfRKLO7buC6hPYnHH1n0B9Uks7ti6L6A+icUdW/cF1CexuGPrvoD6JBZ3bN0XUJ/E4o6t+wLqk1jcsXVfQH0Sizu27guoT2Jxx9Z9AfVJLO7Yui+gPonFHVv3BdQnsbhj676A+iQWd2zdFxCfxKbu2DJ1x5apO7ZM3bFll/gkNnXHlqk7tkzdsWXqji1Td2yZumPL1B1bpu7YMnXHlqk7tkzdsWXqji1Td2yZumPL1B1bpu7YMnXHlqk7tkzdsWXqji1Td2yZumPL1B1bpu7YMnXHlqk7tkzdsWXqji1Td2yZumPL1B1bpu7YMnXHlqk7tkzdsWXqji1Td2yZumPL1B1bpu7YMnXHlqk7tkzdsWXqji1Td2yZumPL1B1bpu7YMnXHlqk7tkzdsWXqji1Td2yZumPL1B1bpu7YMnXHlqk7tkzdsWXqji1Td2yZumPL1B1bpu7YMnXHlqk7tkzdsWXqji1Td2yZumPL1B1bpu7YMnXHlqk7tkzdsWXqji1Td2yZumPL1B1bpu7YMnXHlqk7tkzdsWXqji1Td2yZumPL1B1bpu7YMnXHlqk7tkzdsWXqji1Td2yZumPL1B1bru7YcnXHlqs7tlzdseWX+CR2dceWqzu2XN2x5eqOLVd3bLm6Y8vVHVuu7thydceWqzu2XN2x5eqOLVd3bLm6Y8vVHVuu7thydceWqzu2XN2x5eqOLVd3bLm6Y8vVHVuu7thydceWqzu2XN2x5eqOLVd3bLm6Y8vVHVuu7thydceWqzu2XN2x5eqOLVd3bLm6Y8vVHVuu7thydceWqzu2XN2x5eqOLVd3bLm6Y8vVHVuu7thydceWqzu2XN2x5eqOLVd3bLm6Y8vVHVuu7thydceWqzu2XN2x5eqOLVd3bLm6Y8vVHVuu7thydceWqzu2XN2x5eqOLVd3bLm6Y8vVHVuu7thydceWqzu2XN2x5eqOLVd3bLm6Y8vVHVuu7thydceWqzu2XN2x5eqOLVd3bLm6Y8vVHVuu7thydceWqzu2XN2x5eqOLVd3bLm6Y8vVHVtH3bF11B1bR92xddQdW+cSn8RH3bF11B1bR92xddQdW0fdsXXUHVtH3bF11B1bR92xddQdW0fdsXXUHVtH3bF11B1bR92xddQdW0fdsXXUHVtH3bF11B1bR92xddQdW0fdsXXUHVtH3bF11B1bR92xddQdW0fdsXXUHVtH3bF11B1bR92xddQdW0fdsXXUHVtH3bF11B1bR92xddQdW0fdsXXUHVtH3bF11B1b56MdW58f89EmrMdj7DmP8ec85rtMiPTXV59vfLi+9Wn5PjKn71pR0lVUdBU1XUVDV9GyVfR9lEXftSJ7dkVd1+cX7/nWYEyfz6/NyJfXRr1U79LVH+nqQ7r65Kn+UVLxldR8JQ1fSfCc+XwQ9+Y8Dtp7D/p7D573Hoz3Hsz3Hqz3Huz3Hpz3HnzvJ2fe+8mZ935y5r2fnHnvJ2fe+8n5yv58vH7p065vRITf752P3zndv64v/5P88Zx60nP6Sc+ZJz1nv8NzzvV49T/+6OEbEb7+EuHtX/5u4I3ZcG0/LmB2ffnWN5f5fIOvLHcr3cDkb+DyNzjyNwj5G6T8DUr+Bi1/g5G/gfpMjkt9JselPpPjUp/JcanP5LjUZ3JcPDP5URHPjH1UxDMzHxXxzMBHRU+faXZFv3664///LnyLK4Zd4vWbeP0uXv+hrn9eQN7afOON5zxeO/H62vtPdh5Xjd/OVfO3c9X67Vy1fztXnd/OVbl/B/I9r+rcv1n5rlf94N/XPB7jz3nMec5j4jmP+d7TMf1bH8OKfbx3VX75eXnjrevx11J8Xt84z0v59fzyX/+DvC3f+rg3YU1DWNPy1XQuwpqMsCYnrOkQ1hSENSVhTYQ5fghz/BDm+CHM8SDM8SDM8SDM8SDM8SDM8SDM8SDM8SDM8SDM8SDM8STM8STM8STM8STM8STM8STM8STM8STM8STM8STM8SLM8SLM8SLM8SLM8SLM8SLM8SLM8SLM8SLM8SLM8SbM8SbM8SbM8SbM8SbM8SbM8SbM8SbM8SbM8SbM8SHM8SHM8SHM8SHM8SHM8SHM8SHM8SHM8SHM8SHM8SXM8SXM8SXM8SXM8SXM8SXM8SXM8SXM8SXM8eXL8bz4cjwvvhzPiy/H8+LL8bz4cjwvvhzPiy/H8+LL8bz4cjwvwhw3whw3whw3whw3whw3whw3whw3whw3whw3whw3whx3whx3whx3whx3whx3whx3whwn3OdMwn3OJNznTMJ9ziTc50zCfc4k3OdMwn3OJNznTMJ9ziTc50zCfc4k3OdMwn3OJNznTMJ9ziTc50zCfc4k3OdMwn3OJNznTMJ9ziTc50zCfc4k3OdMwn3OJNznTMJ9ziTc50zCfc4k3OdMwn3OJNznTMJ9ziTc50zCfc4k3OdMwn3OJNznTMJ9ziTc50zCfc4k3OdMwn3OJNznTMJ9ziTc50zCfc4k3OdMwn3OJNznTMJ9ziTc50zCfc4k3OdMwn3OJNznTMJ9ziTc50zCfc4k3OdMwn3OJNznTMJ9ziTc50zCfc4k3OdMwn3OJNznTMJ9ziTc50zCfc4k3OdMwn3OItznLMJ9ziLc5yzCfc66+HK8CPc5i3Cfswj3OYtwn7MI9zmLcJ+zCPc5i3Cfswj3OYtwn7MI9zmLcJ+zCPc5i3Cfswj3OYtwn7MI9zmLcJ+zCPc5i3Cfswj3OYtwn7MI9zmLcJ+zCPc5i3Cfswj3OYtwn7MI9zmLcJ+zCPc5C9/nfBzs9x6c9x7cdx58e8fw+nzqm/+PR/jj/8R//LpeXt/XyxPsw5/gH/6E87FPOF/5d1R+6RNs9/FSv+z1kx9vvniiH5+KL//tervmpZqiqqapqhmqapapmr6eWM3Uo5r94sVfVmNU1ThVNYeqmqCqJqmqeWIWr+9LNfX2N7yZqpnn5Y1f176++HqzGqOqxqmqOVTVBFU1SVVNUVXTVNUMVTXLVM1SZfFSZfFSZfFSZfFSZfFSZfFSZfFSZfFSZfEyZfFX/mWNH1YNUxZ/5V/T+GHVMGXxV/4FjR9WDVMWf+Vfzfhh1TBl8Vf+pYwfVg1VFhtVFhtVFhtVFhtVFhtVFhtVFhtVFhtVFhtVFhtVFjtVFjtVFjtVFjtVFjtVFjtVFjtVFjtVFjtVFjtVFh+qLD5UWXyosvhQZfGhyuJDlcWHKosPVRYfqiw+VFkcVFkcVFkcVFkcVFkcVFkcVFkcVFkcVFkcVFkcVFmcVFmcVFmcVFmcVFmcVFmcVFmcVFmcVFmcVFmcVFlcVFlcVFlcVFlcVFlcVFlcVFlcVFlcVFlcVFlcVFncVFncVFncVFncVFncVFncVFncVFncVFncVFncVFlMtXeXVHt3SbV3l1R7d0m1d5dUe3dJtXeXVHt3SbV3l1R7d0m1d5dUe3dJtXeXVHt3SbV3l1R7d0m1d5dUe3dJtXeXVHt3RbV3V1R7d0W1d1dUe3df+ZcOflg1TFlcVHt3RbV3V1R7d0W1d1dUe3dFtXdXVHt3RbV3V1R7d0W1d1dUe3dFtXdXVHt3RbV3V1R7d0W1d1dP3eaqFw/tNf1mNUVVzRM/xf7iSr5/ed6q5pkbS7+gGqOqxqmqOVTVxNOqmbjm84snfpY3/lJNUlXzxLw5EY8Xx2U/69Qbb33tqx/errNvdralqx/p6le5+mduXH1A9UZR/aOaQ1VNUFWTVNVwpP2jGo70flTDkcaPap6YrhHnpZqIt6p55k7UL6jGqKpxqmoOVTVBVU1SVVNU1TRVNUNVDVUWF1UWF1UWF1UWF1UWF1UWF1UWF1UWF1UWF1UWF1UWN1UWN1UWN1UWN1UWN1UWN1UWN1UWN1UWN1UWN1UWD1UWD1UWD1UWD1UWD1UWP3Pvx/zx74m6vf0np8/c+/kF1SxTNc/c+/kF1RhVNU5VzflB1bz5d2qeuffzC6pJqmqKqpqmquaZWTyvf6fG3pxTz9z7+WY1/czdll9QzaGqJqiqSapqiqqaJ+aN50veeJ83qxmqapapGruoqjGqapyqmkNVTVBVk1TVFFU1VFlsVFlsVFnsVFnsVFnsVFnsVFnsVFnsVFnsVFnsVFnsVFnsVFl8qLKYakOrqTa0mmpDq09QVZNU1RRVNU1VzVBVw7Qt28G0LdtBlcVBlcVBlcVBlcVBlcVBlcVBlcVBlcVBlcVJlcVJlcVJlcVJlcVJlcVJlcVJlcVJlcVJlcVJlcVFlcVFlcVFlcVFlcVFlcVFlX5FlX5vb+VYvXo17j/6fH1Kvpyzd55781tT9aizr9e/7rH9cuq861S861S+61Rhp/7+9/8F"
+            "bytecode": "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",
+            "debug_symbols": "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"
         },
         {
-            "name": "constructor",
+            "name": "is_valid",
             "function_type": "Secret",
             "is_internal": false,
             "abi": {
@@ -1159,7 +1380,23 @@
                                                         { "name": "chain_id", "type": { "kind": "field" } },
                                                         { "name": "version", "type": { "kind": "field" } },
                                                         { "name": "block_number", "type": { "kind": "field" } },
-                                                        { "name": "timestamp", "type": { "kind": "field" } }
+                                                        { "name": "timestamp", "type": { "kind": "field" } },
+                                                        {
+                                                            "name": "coinbase",
+                                                            "type": {
+                                                                "kind": "struct",
+                                                                "path": "authwit::aztec::protocol_types::address::EthAddress",
+                                                                "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                                                            }
+                                                        },
+                                                        {
+                                                            "name": "fee_recipient",
+                                                            "type": {
+                                                                "kind": "struct",
+                                                                "path": "authwit::aztec::protocol_types::address::AztecAddress",
+                                                                "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                                                            }
+                                                        }
                                                     ]
                                                 }
                                             }
@@ -1173,7 +1410,7 @@
                                         "path": "authwit::aztec::protocol_types::contrakt::deployment_data::ContractDeploymentData",
                                         "fields": [
                                             {
-                                                "name": "deployer_public_key",
+                                                "name": "public_key",
                                                 "type": {
                                                     "kind": "struct",
                                                     "path": "authwit::aztec::protocol_types::grumpkin_point::GrumpkinPoint",
@@ -1183,11 +1420,18 @@
                                                     ]
                                                 }
                                             },
-                                            { "name": "constructor_vk_hash", "type": { "kind": "field" } },
-                                            { "name": "function_tree_root", "type": { "kind": "field" } },
-                                            { "name": "contract_address_salt", "type": { "kind": "field" } },
+                                            { "name": "initialization_hash", "type": { "kind": "field" } },
                                             {
-                                                "name": "portal_contract_address",
+                                                "name": "contract_class_id",
+                                                "type": {
+                                                    "kind": "struct",
+                                                    "path": "authwit::aztec::protocol_types::contract_class::ContractClassId",
+                                                    "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                                                }
+                                            },
+                                            { "name": "contract_address_salt", "type": { "kind": "field" } },
+                                            {
+                                                "name": "portal_contract_address",
                                                 "type": {
                                                     "kind": "struct",
                                                     "path": "authwit::aztec::protocol_types::address::EthAddress",
@@ -1211,9 +1455,10 @@
                             ]
                         },
                         "visibility": "private"
-                    }
+                    },
+                    { "name": "message_hash", "type": { "kind": "field" }, "visibility": "private" }
                 ],
-                "param_witnesses": { "inputs": [{ "start": 0, "end": 34 }] },
+                "param_witnesses": { "inputs": [{ "start": 0, "end": 36 }], "message_hash": [{ "start": 36, "end": 37 }] },
                 "return_type": {
                     "abi_type": {
                         "kind": "struct",
@@ -1269,6 +1514,7 @@
                             },
                             { "name": "args_hash", "type": { "kind": "field" } },
                             { "name": "return_values", "type": { "kind": "array", "length": 4, "type": { "kind": "field" } } },
+                            { "name": "meta_hwm", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } },
                             {
                                 "name": "read_requests",
                                 "type": {
@@ -1485,7 +1731,23 @@
                                                     { "name": "chain_id", "type": { "kind": "field" } },
                                                     { "name": "version", "type": { "kind": "field" } },
                                                     { "name": "block_number", "type": { "kind": "field" } },
-                                                    { "name": "timestamp", "type": { "kind": "field" } }
+                                                    { "name": "timestamp", "type": { "kind": "field" } },
+                                                    {
+                                                        "name": "coinbase",
+                                                        "type": {
+                                                            "kind": "struct",
+                                                            "path": "authwit::aztec::protocol_types::address::EthAddress",
+                                                            "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                                                        }
+                                                    },
+                                                    {
+                                                        "name": "fee_recipient",
+                                                        "type": {
+                                                            "kind": "struct",
+                                                            "path": "authwit::aztec::protocol_types::address::AztecAddress",
+                                                            "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                                                        }
+                                                    }
                                                 ]
                                             }
                                         }
@@ -1499,7 +1761,7 @@
                                     "path": "authwit::aztec::protocol_types::contrakt::deployment_data::ContractDeploymentData",
                                     "fields": [
                                         {
-                                            "name": "deployer_public_key",
+                                            "name": "public_key",
                                             "type": {
                                                 "kind": "struct",
                                                 "path": "authwit::aztec::protocol_types::grumpkin_point::GrumpkinPoint",
@@ -1509,8 +1771,15 @@
                                                 ]
                                             }
                                         },
-                                        { "name": "constructor_vk_hash", "type": { "kind": "field" } },
-                                        { "name": "function_tree_root", "type": { "kind": "field" } },
+                                        { "name": "initialization_hash", "type": { "kind": "field" } },
+                                        {
+                                            "name": "contract_class_id",
+                                            "type": {
+                                                "kind": "struct",
+                                                "path": "authwit::aztec::protocol_types::contract_class::ContractClassId",
+                                                "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                                            }
+                                        },
                                         { "name": "contract_address_salt", "type": { "kind": "field" } },
                                         {
                                             "name": "portal_contract_address",
@@ -1530,23 +1799,24 @@
                     "visibility": "public"
                 },
                 "return_witnesses": [
-                    35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
-                    62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
-                    89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,
-                    113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
-                    135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156,
-                    157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178,
-                    179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200,
-                    201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222,
-                    223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238
+                    245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266,
+                    267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288,
+                    289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310,
+                    311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332,
+                    333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
+                    355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376,
+                    377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398,
+                    399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420,
+                    421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442,
+                    443, 444, 445, 446, 447, 448, 449, 450, 451
                 ]
             },
-            "bytecode": "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",
-            "debug_symbols": "q1bKyU9OLMnMzytWsqqurQUA"
+            "bytecode": "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",
+            "debug_symbols": "7Z3dilxHEoTfZa6FORmV9adXWfbC7HrBYOxl7Tujd1/JqEcSk3ZrqydCuZBXxnCqoxRU5MQwX9f5/emnX/7x/W8//vLzr09vf38ye3r7t9+ffv339z9/+N9ff/v+P789vb3ePP3w8z/f//fdm6d//fjTD09vgfbuzYvnbM/58VHbez8/7R48jLbw8WF4+/SwXSv6aPPht8+2jvXF839/82T4v9150+2827jtvM/x8M492vme7bboutq97U+329Nz+yeFD/+Ul0+P/vyPHWt+8dkf9tOT7Wck289Mtp+VbD87135wJduPJdsPku2nJdtPsvmMZPMZyeYzks1nJJvPSDafW7L53JLN55ZsPrdk87klm88t2XxuyeZzSzafW7L53JLNZ082nz3ZfPZk89mTzWdPNp892Xz2ZPPZk81nTzafPdl87snmc082n3uy+dyTzeeebD73ZPO5J5vPPdl87snmc082n0ey+TySzeeRbD6PZPN5JJvPI9l8Hsnm80g2n0ey+TySzeeZbD7PZPN5JpvPM9l8nsnm80w2n2ey+TyTzeeZbD5P+Xye1zMgNR13PhvPNBX258/24Nm99vOmYZ9tI9qFX/32sH+2i/cPvzdlXWXKS1OsTHlpCsqUl6a0MuWlKV6mvDSllykvTRllyktTZpny0pRVprw0pRrtS1N2NdrAlGq0gSnVaANTqtEGpniZ8tKUarSBKdVoA1Oq0QamVKMNTKlG+9KU9//ociVwpTpt5EqV2siVarWRK16uBK5Ur41cqWIbuVLNNnKlqm3kSnXbwBWrbhu5Ut02cqW6beRKddvIFS9XAleq20auVLeNXKluG7lS3TZypbpt4Aqq20auVLeNXKluG7lS3TZyxcuVwJXqtpEr1W0jV6rbRq5Ut41cqW4buNKq20auVLeNXKluG7lS3TZyxcuVwJXqtpEr1W0jV6rbRq5Ut41cqW4buOLVbSNXqttGrlS3jVzJ3W2b3S6K+fwNXR9c+WPznnrz3m/vF/OJl5vP3RS73T66+75zHof32xkbfX562sKnv+J9ZLnroq/bW936WnessX3dTjCuPh+35pt2xrG/+Ow/NpTt5V/Zbse2bNdjW7b7sS3bBdmW7YZsy3ZFtmW7I9uyXZJt2W7JtmzXZFu2e7It20XZlu2mbMt2VbZluyvbsl2Wbdluy7Zs12VbtvuyLduF2ZbtxmzLdmW2Zbsz27Jdmm3Zbs22bNdmW7Z7sy3bxdmW7eZsy3Z1ts1sk3plm9Qr26Re2Sb1yjapV7ZJvbJN6pVtUq9sk3plm9Qr26Te2Sb1zjapd7ZJvbNN6p1tUu9sk3pnm9Q726Te2Sb1TjapcSWb1LiSTWpcySY1rmSTGleySY0r2aTGlWxS40o2qXElm9S4sk1qyzapLduktmyTum5pCjhR1C1NoSv1bZ/Ilfq2T+RKfdsncqW+7RO5Ut/2CVypW5pCV+rbPpEr9W2fyJXqtpErXq4ErlS3jVypbhu5Ut02cqW6beRKddvAlbqlKXSlum3kSnXbyJXqtpErXq4ErlS3jVypbhu5Ut02cqW6beRKddvAlbqlKXSlum3kSnXbyJXqtpErXq4ErlS3jVypbhu5Ut02cqW6beRKddvAlV7dNnKlum3kSnXbyJXqtpErXq4ErlS3jVypbhu5Ut02cqW6beRKddvAlVHdNnKlum3kSnXbyJXqtpErXq4ErlS3jVypbhu5Ut02cqW6beRKddvAlVndNnKlum3kSnXbyJXqtpErXq4ErlS3jVypbhu5krvb/uUb6TBzV9C/fCMdZu6m+A3fSIeVuy5+wzfSYX3Tzhi9ke67+Mv/E7cZNefnO/Lbqna0yo9W9aNV42jVPFq1jlbtk1Xxlx/vrrKjVUdnox2djXZ0NtrR2WhHZ6MdnY12dDba0dnwo7PhR2fDj86GH50NPzobfnQ2/Ohs+NHZ8KOz4Udnox+djX50NvrR2Yjhpjlvq5bhi1VB3/TbD7vmPVJwukKnKwy6wqQrLLrCZivEf/B/VQWjK4CuQM/0oGd60DM96Jke9EwPeqYHPdOTnulJz/SkZ3rSMz3pmZ70TE96pic905Oe6UnP9KJnetEzveiZXvRML3qmFz3Ti57pRc/0omd60TO96Zne9ExveqY3PdObnulNz/SmZ3rTM73pmd70TNt18SWMLwG+RONLOF+i8yUGX2LyJRZfgp9u46fb+Ok2frqNn27jp9v46TZ+uo2fbuOn2/jpBj/d4Kcb/HSDn27w0w1+usFPN/jpBj/d4Ke78dPd+Olu/HQ3frobP92Nn+7GT3fjp7vx09346XZ+up2fbuen2/npdn66nZ9u56fb+el2frqdn+7OT3fnp7vz082nz4yPnxmfPzM+gGZ8As34CJrxGTTjQ2jGp9CMj6EZn0MzPohmfBLN+Cia8Vk048NoxqfRjI+jGZ9HMz6QZnwizfhImvGZNONDacan0oyPpRmfSzM+mGZ8Ms34aJrx2TTjw2nGp9OMj6cZn08zPqBmfELN+Iia8Rk140NqxqfUjI+pGZ9TMz6oZnxSzfiomvFZNfBZNfBZNfBZNfBZNVzOl+h8icGXmHyJxZfgp5vPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqoHPqjU+q9b4rFrjs2qNz6q1y/kSnS8x+BKTL7H4Evx081m1xmfVGp9Va3xWrfFZtcZn1RqfVWt8Vq3xWbXGZ9Uan1VrfFat8Vm19goI1ry97rFNDyUmXeJxeMnX+vis7xlKGF8CfInGl3C+ROdLDL7Ew7nwfXu2XyuUWHyJTZd4HF66L2F8CfAlGl/i8XSPTxI7lOh8icGXmHyJxZfYdInH4aX7Eg+nu+/bu4/HdYUS4Es0voTzJTpfYvAlJl3iFdiDe7X5FdiDuxLGlwBfovElHv/B+vzqercRSnS+xOBLTL7E4ktsusTj7IFf/iwR/grzOHtwXwJ8icaXcL5E50uMV5RA/NL3yZdYfInHf3Y//yLmcT14BfbgroTxJcCXaHwJ50t0vsTgS0y+xOJL0NPt18WXML4E+BKNL+F8ic6XGHyJyZdYfAl+uo2fbuOn2/jpNn66jZ9u46fb+Ok2frqNn27jpxv8dIOfbvDTDX66wU93jDfYvP31F/YZeHHhedk6W7aPlsWAxP1ldrBsffcnZwc3J+cMfmt+v6ydLfOzZf1s2ThbNs+WrbNl+2jZn2A0d5fZ2bKzU9LOTkk7OyXt7JS0s1PSzk5JOzsl7eyU+Nkp8bNT4menxM9OiZ+dEj87JX52SvzslPjZKfGzU9LPTkk/OyX97JTQ7wN5L+F8ic6XGHyJyZdYfIlNl6DfB/JewvgS4Evw0z346R78dA9+ugc/3YOf7sFP9+Sne/LTPfnpnvx0T366Jz/dk5/uyU/35Kd78tO9+Ole/HQvfroXP92Ln+7FT/fip3vx07346V78dG9+ujc/3Zuf7s1P9+ane/PTvfnp3vx0b366Nz/ddl0CDRNoQKDRBBou0OgCjSHQmAKNJdAQ5NwEOTdBzk2QcxPk3AQ5N0HOTZBzE+TcBDk3Qc4hyDkEOYcg5xDkHIKcQ5BzCHIOQc4hyDkEOW+CnDdBzpsg502Q8ybIeRPkvAly3gQ5b4KcN0HOXZBzF+TcBTl3Qc5dkHMX5NwFOXdBzl2QcxfkvAty3gU574KcCwg3EyBuJmDcTAC5mYByMwHmZgLOzQSgmwlINxOgbiZg3UwAu5mAdjMB7mYC3s0EwJsJiDcTIG8mYN5MAL2ZgHozAfZmAu7NBOCbCcg3E6BvJmDfTAC/mYB+MwH+ZgL+zQQAnAkIOBMgcCZg4EwAwZmAgjMBBmcCDs4EIJwJSDgToHAmYOFMAMOZgIYzAQ5nAh4OAh4OAh4OAh4OAh4Olws0ukBjCDSmQGMJNAQ5F/BwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwEPBwTcDDNQEP1wQ8XBPwcO1ygUYXaAyBxhRoLIGGIOcCHq4JeLgm4OGagIdrAh6uCXi4JuDhmoCHawIergl4uCbg4ZqAh2sCHq69AuM1cdOYHmtMvsbjbJSv29sRfc9YwwQaEGg0gYYLNLpAYwg0Hs6HP7/stF8r1lgCjc3XeJyN+goNE2hAoNEEGo/nfHzS2LFGF2gMgcYUaCyBxuZrPM5GfYXGwznv+/r47IheMv1BAwKNJtBwgUYXaAyBxuRrvALPcLdTvwLPcF/DBBoQaDSBxuM/a81uXdRGrNEFGkOgMQUaS6Cx+RqP8wx++bNG/DvO4zzDV2hAoNEEGi7Q6AKN8YoaaLHGFGgsgcbjP8+ff1fzP+kMr8Az3NcwgQYEGk2g4QKNLtAYAo0p0FgCDX7O/boEGibQgECjCTRcoNEFGkOgMQUaS6AhyLkJcm6CnJsg5ybIuQlyboKcmyDnJsi5CXJugpxDkHMIcg5BziHIOQQ5j5kJm7e/JcM+4zkufFq3Dtfts3Uxd/EV6+x/XPfu3X8B"
         },
         {
-            "name": "is_valid",
-            "function_type": "Secret",
+            "name": "is_valid_public",
+            "function_type": "Open",
             "is_internal": false,
             "abi": {
                 "parameters": [
@@ -1554,7 +1824,7 @@
                         "name": "inputs",
                         "type": {
                             "kind": "struct",
-                            "path": "authwit::aztec::abi::PrivateContextInputs",
+                            "path": "authwit::aztec::abi::PublicContextInputs",
                             "fields": [
                                 {
                                     "name": "call_context",
@@ -1724,7 +1994,23 @@
                                                         { "name": "chain_id", "type": { "kind": "field" } },
                                                         { "name": "version", "type": { "kind": "field" } },
                                                         { "name": "block_number", "type": { "kind": "field" } },
-                                                        { "name": "timestamp", "type": { "kind": "field" } }
+                                                        { "name": "timestamp", "type": { "kind": "field" } },
+                                                        {
+                                                            "name": "coinbase",
+                                                            "type": {
+                                                                "kind": "struct",
+                                                                "path": "authwit::aztec::protocol_types::address::EthAddress",
+                                                                "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                                                            }
+                                                        },
+                                                        {
+                                                            "name": "fee_recipient",
+                                                            "type": {
+                                                                "kind": "struct",
+                                                                "path": "authwit::aztec::protocol_types::address::AztecAddress",
+                                                                "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                                                            }
+                                                        }
                                                     ]
                                                 }
                                             }
@@ -1732,46 +2018,33 @@
                                     }
                                 },
                                 {
-                                    "name": "contract_deployment_data",
+                                    "name": "public_global_variables",
                                     "type": {
                                         "kind": "struct",
-                                        "path": "authwit::aztec::protocol_types::contrakt::deployment_data::ContractDeploymentData",
+                                        "path": "authwit::aztec::abi::PublicGlobalVariables",
                                         "fields": [
+                                            { "name": "chain_id", "type": { "kind": "field" } },
+                                            { "name": "version", "type": { "kind": "field" } },
+                                            { "name": "block_number", "type": { "kind": "field" } },
+                                            { "name": "timestamp", "type": { "kind": "field" } },
                                             {
-                                                "name": "deployer_public_key",
+                                                "name": "coinbase",
                                                 "type": {
                                                     "kind": "struct",
-                                                    "path": "authwit::aztec::protocol_types::grumpkin_point::GrumpkinPoint",
-                                                    "fields": [
-                                                        { "name": "x", "type": { "kind": "field" } },
-                                                        { "name": "y", "type": { "kind": "field" } }
-                                                    ]
+                                                    "path": "authwit::aztec::protocol_types::address::EthAddress",
+                                                    "fields": [{ "name": "inner", "type": { "kind": "field" } }]
                                                 }
                                             },
-                                            { "name": "constructor_vk_hash", "type": { "kind": "field" } },
-                                            { "name": "function_tree_root", "type": { "kind": "field" } },
-                                            { "name": "contract_address_salt", "type": { "kind": "field" } },
                                             {
-                                                "name": "portal_contract_address",
+                                                "name": "fee_recipient",
                                                 "type": {
                                                     "kind": "struct",
-                                                    "path": "authwit::aztec::protocol_types::address::EthAddress",
+                                                    "path": "authwit::aztec::protocol_types::address::AztecAddress",
                                                     "fields": [{ "name": "inner", "type": { "kind": "field" } }]
                                                 }
                                             }
                                         ]
                                     }
-                                },
-                                {
-                                    "name": "private_global_variables",
-                                    "type": {
-                                        "kind": "struct",
-                                        "path": "authwit::aztec::abi::PrivateGlobalVariables",
-                                        "fields": [
-                                            { "name": "chain_id", "type": { "kind": "field" } },
-                                            { "name": "version", "type": { "kind": "field" } }
-                                        ]
-                                    }
                                 }
                             ]
                         },
@@ -1783,7 +2056,7 @@
                 "return_type": {
                     "abi_type": {
                         "kind": "struct",
-                        "path": "authwit::aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs",
+                        "path": "authwit::aztec::protocol_types::abis::public_circuit_public_inputs::PublicCircuitPublicInputs",
                         "fields": [
                             {
                                 "name": "call_context",
@@ -1836,55 +2109,40 @@
                             { "name": "args_hash", "type": { "kind": "field" } },
                             { "name": "return_values", "type": { "kind": "array", "length": 4, "type": { "kind": "field" } } },
                             {
-                                "name": "read_requests",
+                                "name": "contract_storage_update_requests",
                                 "type": {
                                     "kind": "array",
-                                    "length": 32,
+                                    "length": 16,
                                     "type": {
                                         "kind": "struct",
-                                        "path": "authwit::aztec::protocol_types::abis::side_effect::SideEffect",
+                                        "path": "authwit::aztec::protocol_types::contrakt::storage_update_request::StorageUpdateRequest",
                                         "fields": [
-                                            { "name": "value", "type": { "kind": "field" } },
-                                            { "name": "counter", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } }
+                                            { "name": "storage_slot", "type": { "kind": "field" } },
+                                            { "name": "old_value", "type": { "kind": "field" } },
+                                            { "name": "new_value", "type": { "kind": "field" } }
                                         ]
                                     }
                                 }
                             },
                             {
-                                "name": "nullifier_key_validation_requests",
+                                "name": "contract_storage_reads",
                                 "type": {
                                     "kind": "array",
-                                    "length": 1,
+                                    "length": 16,
                                     "type": {
                                         "kind": "struct",
-                                        "path": "authwit::aztec::protocol_types::abis::nullifier_key_validation_request::NullifierKeyValidationRequest",
+                                        "path": "authwit::aztec::protocol_types::contrakt::storage_read::StorageRead",
                                         "fields": [
-                                            {
-                                                "name": "public_key",
-                                                "type": {
-                                                    "kind": "struct",
-                                                    "path": "authwit::aztec::protocol_types::grumpkin_point::GrumpkinPoint",
-                                                    "fields": [
-                                                        { "name": "x", "type": { "kind": "field" } },
-                                                        { "name": "y", "type": { "kind": "field" } }
-                                                    ]
-                                                }
-                                            },
-                                            {
-                                                "name": "secret_key",
-                                                "type": {
-                                                    "kind": "struct",
-                                                    "path": "authwit::aztec::protocol_types::grumpkin_private_key::GrumpkinPrivateKey",
-                                                    "fields": [
-                                                        { "name": "high", "type": { "kind": "field" } },
-                                                        { "name": "low", "type": { "kind": "field" } }
-                                                    ]
-                                                }
-                                            }
+                                            { "name": "storage_slot", "type": { "kind": "field" } },
+                                            { "name": "current_value", "type": { "kind": "field" } }
                                         ]
                                     }
                                 }
                             },
+                            {
+                                "name": "public_call_stack_hashes",
+                                "type": { "kind": "array", "length": 4, "type": { "kind": "field" } }
+                            },
                             {
                                 "name": "new_commitments",
                                 "type": {
@@ -1916,22 +2174,11 @@
                                     }
                                 }
                             },
-                            {
-                                "name": "private_call_stack_hashes",
-                                "type": { "kind": "array", "length": 4, "type": { "kind": "field" } }
-                            },
-                            {
-                                "name": "public_call_stack_hashes",
-                                "type": { "kind": "array", "length": 4, "type": { "kind": "field" } }
-                            },
                             { "name": "new_l2_to_l1_msgs", "type": { "kind": "array", "length": 2, "type": { "kind": "field" } } },
-                            { "name": "end_side_effect_counter", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } },
-                            { "name": "encrypted_logs_hash", "type": { "kind": "array", "length": 2, "type": { "kind": "field" } } },
                             {
                                 "name": "unencrypted_logs_hash",
                                 "type": { "kind": "array", "length": 2, "type": { "kind": "field" } }
                             },
-                            { "name": "encrypted_log_preimages_length", "type": { "kind": "field" } },
                             { "name": "unencrypted_log_preimages_length", "type": { "kind": "field" } },
                             {
                                 "name": "historical_header",
@@ -2051,7 +2298,23 @@
                                                     { "name": "chain_id", "type": { "kind": "field" } },
                                                     { "name": "version", "type": { "kind": "field" } },
                                                     { "name": "block_number", "type": { "kind": "field" } },
-                                                    { "name": "timestamp", "type": { "kind": "field" } }
+                                                    { "name": "timestamp", "type": { "kind": "field" } },
+                                                    {
+                                                        "name": "coinbase",
+                                                        "type": {
+                                                            "kind": "struct",
+                                                            "path": "authwit::aztec::protocol_types::address::EthAddress",
+                                                            "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                                                        }
+                                                    },
+                                                    {
+                                                        "name": "fee_recipient",
+                                                        "type": {
+                                                            "kind": "struct",
+                                                            "path": "authwit::aztec::protocol_types::address::AztecAddress",
+                                                            "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                                                        }
+                                                    }
                                                 ]
                                             }
                                         }
@@ -2059,60 +2322,34 @@
                                 }
                             },
                             {
-                                "name": "contract_deployment_data",
+                                "name": "prover_address",
                                 "type": {
                                     "kind": "struct",
-                                    "path": "authwit::aztec::protocol_types::contrakt::deployment_data::ContractDeploymentData",
-                                    "fields": [
-                                        {
-                                            "name": "deployer_public_key",
-                                            "type": {
-                                                "kind": "struct",
-                                                "path": "authwit::aztec::protocol_types::grumpkin_point::GrumpkinPoint",
-                                                "fields": [
-                                                    { "name": "x", "type": { "kind": "field" } },
-                                                    { "name": "y", "type": { "kind": "field" } }
-                                                ]
-                                            }
-                                        },
-                                        { "name": "constructor_vk_hash", "type": { "kind": "field" } },
-                                        { "name": "function_tree_root", "type": { "kind": "field" } },
-                                        { "name": "contract_address_salt", "type": { "kind": "field" } },
-                                        {
-                                            "name": "portal_contract_address",
-                                            "type": {
-                                                "kind": "struct",
-                                                "path": "authwit::aztec::protocol_types::address::EthAddress",
-                                                "fields": [{ "name": "inner", "type": { "kind": "field" } }]
-                                            }
-                                        }
-                                    ]
+                                    "path": "authwit::aztec::protocol_types::address::AztecAddress",
+                                    "fields": [{ "name": "inner", "type": { "kind": "field" } }]
                                 }
-                            },
-                            { "name": "chain_id", "type": { "kind": "field" } },
-                            { "name": "version", "type": { "kind": "field" } }
+                            }
                         ]
                     },
                     "visibility": "public"
                 },
                 "return_witnesses": [
-                    241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262,
-                    263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
-                    285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306,
-                    307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328,
-                    329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350,
-                    351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372,
-                    373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394,
-                    395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416,
-                    417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438,
-                    439, 440, 441, 442, 443, 444
+                    35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
+                    62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
+                    89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,
+                    113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
+                    135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156,
+                    157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178,
+                    179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200,
+                    201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222,
+                    223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237
                 ]
             },
-            "bytecode": "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",
-            "debug_symbols": "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"
+            "bytecode": "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",
+            "debug_symbols": "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"
         },
         {
-            "name": "entrypoint",
+            "name": "constructor",
             "function_type": "Secret",
             "is_internal": false,
             "abi": {
@@ -2291,7 +2528,23 @@
                                                         { "name": "chain_id", "type": { "kind": "field" } },
                                                         { "name": "version", "type": { "kind": "field" } },
                                                         { "name": "block_number", "type": { "kind": "field" } },
-                                                        { "name": "timestamp", "type": { "kind": "field" } }
+                                                        { "name": "timestamp", "type": { "kind": "field" } },
+                                                        {
+                                                            "name": "coinbase",
+                                                            "type": {
+                                                                "kind": "struct",
+                                                                "path": "authwit::aztec::protocol_types::address::EthAddress",
+                                                                "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                                                            }
+                                                        },
+                                                        {
+                                                            "name": "fee_recipient",
+                                                            "type": {
+                                                                "kind": "struct",
+                                                                "path": "authwit::aztec::protocol_types::address::AztecAddress",
+                                                                "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                                                            }
+                                                        }
                                                     ]
                                                 }
                                             }
@@ -2305,7 +2558,7 @@
                                         "path": "authwit::aztec::protocol_types::contrakt::deployment_data::ContractDeploymentData",
                                         "fields": [
                                             {
-                                                "name": "deployer_public_key",
+                                                "name": "public_key",
                                                 "type": {
                                                     "kind": "struct",
                                                     "path": "authwit::aztec::protocol_types::grumpkin_point::GrumpkinPoint",
@@ -2315,8 +2568,15 @@
                                                     ]
                                                 }
                                             },
-                                            { "name": "constructor_vk_hash", "type": { "kind": "field" } },
-                                            { "name": "function_tree_root", "type": { "kind": "field" } },
+                                            { "name": "initialization_hash", "type": { "kind": "field" } },
+                                            {
+                                                "name": "contract_class_id",
+                                                "type": {
+                                                    "kind": "struct",
+                                                    "path": "authwit::aztec::protocol_types::contract_class::ContractClassId",
+                                                    "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                                                }
+                                            },
                                             { "name": "contract_address_salt", "type": { "kind": "field" } },
                                             {
                                                 "name": "portal_contract_address",
@@ -2343,53 +2603,9 @@
                             ]
                         },
                         "visibility": "private"
-                    },
-                    {
-                        "name": "payload",
-                        "type": {
-                            "kind": "struct",
-                            "path": "authwit::entrypoint::EntrypointPayload",
-                            "fields": [
-                                {
-                                    "name": "function_calls",
-                                    "type": {
-                                        "kind": "array",
-                                        "length": 4,
-                                        "type": {
-                                            "kind": "struct",
-                                            "path": "authwit::entrypoint::FunctionCall",
-                                            "fields": [
-                                                { "name": "args_hash", "type": { "kind": "field" } },
-                                                {
-                                                    "name": "function_selector",
-                                                    "type": {
-                                                        "kind": "struct",
-                                                        "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector",
-                                                        "fields": [
-                                                            { "name": "inner", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } }
-                                                        ]
-                                                    }
-                                                },
-                                                {
-                                                    "name": "target_address",
-                                                    "type": {
-                                                        "kind": "struct",
-                                                        "path": "authwit::aztec::protocol_types::address::AztecAddress",
-                                                        "fields": [{ "name": "inner", "type": { "kind": "field" } }]
-                                                    }
-                                                },
-                                                { "name": "is_public", "type": { "kind": "boolean" } }
-                                            ]
-                                        }
-                                    }
-                                },
-                                { "name": "nonce", "type": { "kind": "field" } }
-                            ]
-                        },
-                        "visibility": "public"
                     }
                 ],
-                "param_witnesses": { "inputs": [{ "start": 0, "end": 34 }], "payload": [{ "start": 34, "end": 51 }] },
+                "param_witnesses": { "inputs": [{ "start": 0, "end": 36 }] },
                 "return_type": {
                     "abi_type": {
                         "kind": "struct",
@@ -2445,6 +2661,7 @@
                             },
                             { "name": "args_hash", "type": { "kind": "field" } },
                             { "name": "return_values", "type": { "kind": "array", "length": 4, "type": { "kind": "field" } } },
+                            { "name": "meta_hwm", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } },
                             {
                                 "name": "read_requests",
                                 "type": {
@@ -2661,7 +2878,23 @@
                                                     { "name": "chain_id", "type": { "kind": "field" } },
                                                     { "name": "version", "type": { "kind": "field" } },
                                                     { "name": "block_number", "type": { "kind": "field" } },
-                                                    { "name": "timestamp", "type": { "kind": "field" } }
+                                                    { "name": "timestamp", "type": { "kind": "field" } },
+                                                    {
+                                                        "name": "coinbase",
+                                                        "type": {
+                                                            "kind": "struct",
+                                                            "path": "authwit::aztec::protocol_types::address::EthAddress",
+                                                            "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                                                        }
+                                                    },
+                                                    {
+                                                        "name": "fee_recipient",
+                                                        "type": {
+                                                            "kind": "struct",
+                                                            "path": "authwit::aztec::protocol_types::address::AztecAddress",
+                                                            "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                                                        }
+                                                    }
                                                 ]
                                             }
                                         }
@@ -2675,7 +2908,7 @@
                                     "path": "authwit::aztec::protocol_types::contrakt::deployment_data::ContractDeploymentData",
                                     "fields": [
                                         {
-                                            "name": "deployer_public_key",
+                                            "name": "public_key",
                                             "type": {
                                                 "kind": "struct",
                                                 "path": "authwit::aztec::protocol_types::grumpkin_point::GrumpkinPoint",
@@ -2685,8 +2918,15 @@
                                                 ]
                                             }
                                         },
-                                        { "name": "constructor_vk_hash", "type": { "kind": "field" } },
-                                        { "name": "function_tree_root", "type": { "kind": "field" } },
+                                        { "name": "initialization_hash", "type": { "kind": "field" } },
+                                        {
+                                            "name": "contract_class_id",
+                                            "type": {
+                                                "kind": "struct",
+                                                "path": "authwit::aztec::protocol_types::contract_class::ContractClassId",
+                                                "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                                            }
+                                        },
                                         { "name": "contract_address_salt", "type": { "kind": "field" } },
                                         {
                                             "name": "portal_contract_address",
@@ -2706,164 +2946,177 @@
                     "visibility": "public"
                 },
                 "return_witnesses": [
-                    3732, 3733, 3734, 3735, 3736, 3737, 3738, 3739, 3740, 3741, 3742, 3743, 3744, 3745, 3746, 3747, 3748, 3749,
-                    3750, 3751, 3752, 3753, 3754, 3755, 3756, 3757, 3758, 3759, 3760, 3761, 3762, 3763, 3764, 3765, 3766, 3767,
-                    3768, 3769, 3770, 3771, 3772, 3773, 3774, 3775, 3776, 3777, 3778, 3779, 3780, 3781, 3782, 3783, 3784, 3785,
-                    3786, 3787, 3788, 3789, 3790, 3791, 3792, 3793, 3794, 3795, 3796, 3797, 3798, 3799, 3800, 3801, 3802, 3803,
-                    3804, 3805, 3806, 3807, 3808, 3809, 3810, 3811, 3812, 3813, 3814, 3815, 3816, 3817, 3818, 3819, 3820, 3821,
-                    3822, 3823, 3824, 3825, 3826, 3827, 3828, 3829, 3830, 3831, 3832, 3833, 3834, 3835, 3836, 3837, 3838, 3839,
-                    3840, 3841, 3842, 3843, 3844, 3845, 3846, 3847, 3848, 3849, 3850, 3851, 3852, 3853, 3854, 3855, 3856, 3857,
-                    3858, 3859, 3860, 3861, 3862, 3863, 3864, 3865, 3866, 3867, 3868, 3869, 3870, 3871, 3872, 3873, 3874, 3875,
-                    3876, 3877, 3878, 3879, 3880, 3881, 3882, 3883, 3884, 3885, 3886, 3887, 3888, 3889, 3890, 3891, 3892, 3893,
-                    3894, 3895, 3896, 3897, 3898, 3899, 3900, 3901, 3902, 3903, 3904, 3905, 3906, 3907, 3908, 3909, 3910, 3911,
-                    3912, 3913, 3914, 3915, 3916, 3917, 3918, 3919, 3920, 3921, 3922, 3923, 3924, 3925, 3926, 3927, 3928, 3929,
-                    3930, 3931, 3932, 3933, 3934, 3935
+                    37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
+                    64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
+                    91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
+                    115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136,
+                    137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158,
+                    159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180,
+                    181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202,
+                    203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224,
+                    225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243
                 ]
             },
-            "bytecode": "H4sIAAAAAAAA/+2dC5xN5ff/jzFmxm1cc0tyv1/OnhkzQ5FbyiVJQiWZa8g9hBBCkiT33JI7SZIkSZIkSZIkSSpJkiRJQv/nqXVq2833+5v5zmc9/71ee5/Xa72eec48s2Z9nrXWPu+zzz7nvFQkEPhKmb7lUBamLKeysoF/7tO3RjQGs3ezwpWP8Az8xgbj4+LSEmLSrFgrKRhTLzmxbjCubnJ8opVo1U2smxqTGBublhiXmFAvuV5CsJ4VF5tmpdetF5tOjsNxMQY5dOdSPnIx6M7lct0RykcEg+4IoO5Q3UdS3YfmuR3z/I55Ace8kGNexDG/yjGvEODrs0rKRyWGfa/EsO9VGPehmvJRjWEfqjHsQw3GfailfNRi2IdaDPtQh3EfLOXDYtgHC7gPAdsNHWcsOF9RtlyVV3Y58NdxTY8VaaxEY2Uaq9BYlcZqNFansQaNNWmsRWNtGuvQGKTRojGGxtj/T6OON45ypvelIO1LnAviqmuLq5DL8qXjiA/8xZ2herff0MeAeJyvP7kzdEugMZFiDv2PesrqK7tO2fXKGihrqOwGWtNYWRNlTZU1U3ajsubKblJ2s7IWyloqa6WstbJblLVRdquytspuU9ZO2e3K2iu7Q1kHZR2VdVJ2p7K7lN2trLOye5R1UXavsq7KkpQlK0tRlqosTVm6svuUdVPWXVkPZfcr66msl7Leyvoo66usn7L+yh5QNkDZQGWDlD2obDDtwRBlKyiRmqvCAlfeImw/N6IxmM1bRtwZzObNHnto1AyeJ/CPtoDj97ltceQM/HsPwm335XTsR7SyvBn4jLD9XSOMNsvZe41sP4f+lz2WnC6KJcf/51jsOQ7Y7gv93l4Lzrzr+nnG1hsRGfxNJP2cMwPfEbb7ctHPkRn8rX2PIhxagtm7/blH9v/TyDYP/a88thgiXRBLThfFEmYollB9hPzmcsTy//P/RmH/b4y9lwK2HAQcsYRuUbZY8kJjifvzcSN3FmLJa4slDzSWv87J5MP6/POxNj/Yp/YRbduT0P7ls+1R6Pf5bfsVDd6vHLb/GfIbmtvj82P1Y/Vj9WP1Y/Vj9WP1Y/Vj9WP1Y/Vj9WP1Y/Vj9WP1Y/Vj9WP1Y/Vj9WP1Y/Vj9WP1Y/Vj9WP1Y/Vj9WP1Y/Vj9WP1Y/Vj9WP1Y/Vj9WP1Y/V2rHkDV17bHxrz2eL6/x1f6L48tljyYWMJ2t8XE/Kt3/tQP8c//xN77Xhc0H7dfui95qEYQv8rp21NWo5/4mrIFtdf11nnxmqNzeHIXyNb3LltWkNrmpK+UH+E7g/pt+9RHtse2f8HVsNf17SDr9mPtfdAaF9Ccee17UtoTUvHvuTLYF9y2/Yij2NdnsC/ezt34MrjUGjk6Pf8tngb2ebRtvhCuu0xga/7/zOWvI5YMvq/2D2Ii9E+C2B9/llDBW0xN7LFHfpfOW1rOjlqKHS/voVnkA/nuty2n+3vAStg+5vQfaH3Aeez3VeYfs5ru48+Hubv/2V/D5v9/+Z06LK/R62Q7b7Qe38K2+4L1XYRW+z2Y4e9H3I77uN4j0yOwJXv12kUuLJ3Q6PzOMkQS0xGseR0xAI4/lnOO5zHv8aB/37862urXTwH/NVL9v5vFPg3v+W0rRng6CX78S2j43FGxxg0yziPs1G2/2vvw3wZxFIQu59/xlLIsZ+huipo28/QmuGO/BYCx4PX+OfHcvx9nAkP/NOvdn2h34+2MdwY2/txQ8fbSJufqRn8PnTL4Zg3sv1s3++iWK1/5vMqm/9Gtv9h/7/FsP/Xsv/fHGSh/xG6P6ft5ym2DSr2z49/728oZt2TRTJYZ/852vE3eW2/L8Ksuagtjka2eeh/6Tp51FZTU23PC7Cc8VedF8lgX3La9iX0e/sxHd1vWmLhwJX74jym2J/XhuK084j9cb0IQ3yFHPGF5kVs8YXus7NMSIf9eGJ/DpoLGmtcrP1/hm7/7dhif081+jMQ9HEzlKv70gY0HjigW8fuA3qnPfBADltkoWibZhBtmG0nQxm2f5qB/egaui/Mpih0n/Nd+5GBDD41phFIdpjDL/jjRKAfRVOW/AxV9pCyYcqGKxuh7GFlI5WNUjZa2SPKxigbq2ycskeVjVf2mLIJyh5XNlHZE8omKXtS2WRlTymbomyqsmnKpiuboWymslnKnqZNykHJ07FEBf6ZP+SYD3PMhzvmIxzzhx3zkY75KMd8tGP+iGM+xjEf65iPc8wfdczHO+aPOeYTHPPHHfOJjvkTjvkkx/xJx3yyY/6UYz7FMZ/qmE9zzKc75jMc85mO+SzH/OnAP4gVuoUathGNwezdruiZ7H4c2lCgr64FcL383/bvf40zLV3fgtZDIF86F8OA+5fk+v3707U1PPu+YkizNQK4f8lu3r+4v+O0Hs6er6BNszUSuH8pbt2/mCvitEb9776CDs3WaOD+pbpw/+LT/xWn9cj/5isxA83WGOD+pblt/xIzjNMam3VfCf9BszUOuH/pbtq/hP8Yp/Vo1nzF/BfN1njg/t3nlv1L+K9xWo9l3lfK/6HZmgDcv25u2L+E/zNO6/HM+QpmQrM1Ebh/3f9/718wU3FaT/zfvupmUrM1Cbh/Pf5/7l9cpuO0nvyvvuLSs6DZmgzcv/v/f+1fQpbitJ76z74Ss6jZmgLcv57/H/avXnqW47SmZuwr+D9otqYB96+X6f0L/k9xWtP/7cv6HzVbM4D719vk/qX+z3FaM6/0FZsNzdYs4P71MbR/MenZitN6OoA7l2g/Z5fd/etraP+C2btZwPNsVjJw//oJ2T/geSIrFbh//YXsH/A8h5UO3L8HhOwf8Hm61Q24fwOE7B/weabVA7h/A4XsH/B5ktUTuH+DhOwfkPOt3sD9e1DI/gE51eoL3L/BQvYPyFlWf+D+DRGyf0BOsAYA92+okP0DPs5Zg4D795CQ/QMep63BwP0bJmT/gMcZayhw/4YL2T9gn1jAmrGQ+6evZ9MXneqv9NNfUZhIY8i//ko/fZ1bfRqvo/F6GhvQ2JDGG2hsRGNjGpvQ2JTGZjTeSGNzGm+i8WYaW9DYksZWNLam8RYa29B4K41tabyNxnY03k5jexrvoLEDjR1p7ETjnTTeRePdNHam8R4au9B4L41daUyiMZnGFBpTaUyjMZ3G+2jsRmN3GnvQeD+NPWnsRWNvGvvQ2JfGfjT2p/EBGgfQOJDGQTQ+SOPgwJVfeRq63jF0HWTo+sjQdZOh6ylD11mGrr8MXZcZul4zdB3nkzSGrvsMXQ8auk40dP1o6LrS0PWm42kMXZ8aum41dD1r6DrX0PWvo2kMXS87ksbQ9bWh625D1+OGrtMNXb8buq53duDKG/r66NkB3PE1B8UcOh46e3sIjfqS/zkOXWEOXYhYUHs0B+craOorWCsGsMfq0G1u4N9fuRgIXPlVlWgtAcf/ce5fdIDxDQpcyZnL4HdeANdAXLrn4XN0BYyhDyTIPZ0P3EvdCPbvRg7d3Hwg4YyzgpA4ywuJMzKAfwDRY+g9bs8oW6DsWWULlS1StljZEmVLlS1TtlzZCmUrlT2nbJWy4vT39s8+CNjuy+XYj8x+32+EzU8jkG6GB8NgRt9vbH/XXq4M9icig/2JtK23f+5EwLFX0QGWz9lJs+cldPtv772MsmmJxMby53svS5KvtN79BqYNTGs7MLln95TmA3unDOjep3fTpJ497UXsfHNteAYbp2/2N5fa19iT5PywDT0PfeiE/QNG7MUbGp0fUvHnWzXRRwL9qFXJFjzI758obN+s0A0d/4IAzxEXtB9/fyqIfS+ep3F14Mojmr3z/8hgz3LYfg6jNWH/ZU2O/+DnPx0J2DA7JE4LP2wTqzegrON/os+3LQhkG/H+fr/Z89n39Tcurg7wFG4YeP+Qml/IwFdyMCW1rpUcn5pgpSXVTUxJqRdrWTFJ8UnxyTGJ6WnJda3EuonKZ0pSTKL6dzFJKVZaMCk+zdRz7RcCeFTStzUB/7k2JDlrGPy+GHD3c22t+0V8jjKMFXGge5HB71yXv+ATihNZS2sDuBqaC37BRx/EdHzlaA9N0N+zAZ4aCGDjjLHvxUs0rgt4jP608EuOYFD/Yx1tKPogsy7g7oMM3a5ohOx9wkV6+ksC9g9NuUjNL9t8WYmxMTEJsXpdYmrQiktNiUmMiUlNjgumBJNSYtLqxVn10uNi4mJTUlOSlc8kKz2YnpRSLz3xr7hMUe7LAeyDQei2PuBTLiQ56xn8vhJwN+Vq3a/gc8RCuesoVrTfDQFsY+om3ECjKUpbGOB5EADXxRWU9iqNGwMeozQtnIvSNtKGoptkY4CnwNCUthCgOURprwrYPzSlITW/FpBHaa8FsA8GodumgE9pkORsYvD7esDdlKZ1v47PEQulbaRY0X43B7CNqZtwc8AspS0K8DwIgOviCkp7g8YtAY9RmhbORWlbaEPRTbIlwFNgaEpbBNAcorQ3BOwfmtKQmt8MyKO0NwPYB4PQbWvApzRIcrYy+H0r4G5K07rfwueIhdK2UKxov9sC2MbUTbgtYJbSlgV4HgRAdZHh9W5v07g94DFK08Lt17vpDSjr+J9oerEXSHavd3s7gGu+7QGewkXTC1LzOxn4cvv1bu8EsAfJ0G1HwKcXSHJ2MPh9N+BuetG638XniIVetlOsaL/zhVzvhqylnQFcDc1nuN5Nx1cuYI7+lgd4aiCAjfOKc3Tv0bgr4DH608K5ztHtog1FH2R2Bdx9kKHbFY2Q3XN07wnYPzTlIjW/H5B3ju79APbBIHTbHfApF5Kc3Qx+Pwi4m3K17g/wOWKh3F0UK9rvngC2MXUT7gmYPUe3IsDzIACuiyso7UMa9wY8RmlaOBel7aUNRTfJ3gBPgaEpbQVAc4jSPhSwf2hKQ2r+KCCP0j4KYB8MQrd9AZ/SIMnZx+D344C7KU3r/hifIxZK20uxov3uD2AbUzfh/oBZSlsZ4HkQANfFFZT2CY0HAh6jNC2ci9IO0Iaim+RAgKfA0JS2EqA5RGmfCNg/NKUhNX8akEdpnwawDwah28GAT2mQ5Bxk8PtZwN2UpnV/hs8RC6UdoFjRfg8FsI2pm/BQwCylPRfgeRAA1UWG17t9TqO+9MtTlPZ54Mrr3fTPZR3/E00v9gLJ7vVunwdwzXc4wFO4aHpBav4iA19uv97tiwD2IBm6HQn49AJJzhEGv18G3E0vWveX+Byx0MthihXtd4GQ692QtfRVAFdDCxiud9PxlSOf6JrXn0I8n6GOvg7w9k8we7c/P4P/awbdCwu4+7jxDJPuRQVkgBcwP9Yil+e6AlOulxZwd2+vZtK9TEiNA/NjLXN5jUcy5Xqly2v8MJPu54TUODA/lhTNkcA8HwXGxVHfuraPMtT3N7gY/+Zz7bMs+UTvQ/kAT5+vdvlxfRWT7heE9DowP9YLLn8s20W5DmD9ssS6V1CsBwzGivhyUY5+X+vy2l/MpPslIcc5YH6sl1ye6yVMuV5vKNcuOjdmrQefZ9XfVxd64UifP9BfqryOxo00bqFRfzXcMcpjVOCf79FbTL9fQuNSGrfTuIvGvTQeoPEwjYWUfWvzGzpnHku/d476FefjWVz/XRbXn8ji+u+zuP5kFtf/kMX1p7K4/scsrj+dxfU/ZXH9mSyu/zmL689mcf0vWVx/Lovrf7WtD/sP6/Xvzmdy3W+ZXHchk+t+z+S6i5lcdymT6y5nct0fmVynF2VmXY5MrgvL5LqcmVwXnsl1uTK5LiKT6yIzse4a/ftMrsudyXV5MrkubybX5cvkuvyZXBedyXUFMrmuYCbXFcrkusKZXFckk+uKZnLdVZlcVyyT64rnyPzxUq8vkcX1JbO4vlQW11+dxfWls7j+miyuL5PF9ddmcX3ZLK4vl8X15bO4vkIW11fM4vpKWVxfOYvrq9jWJ9P6b+n3q/7D3znH4zR+R+MJGr+n8SSNP9B4isYfaTxN4080nqHxZxrP0vgLjedo/JXG8zT+RuMFGn+n8SKNl2gM2R806g3QYw4aw2jMSWM4jblojKAxMkfm9ieK1uWmMQ+NeWnMR2N+GqNpLEBjQRoL0ViYxiI0FqXxKhqL0VicxhI0lqSxFI1X01iaxmtoLEPjtTSWpbEcjeVprEBjRRor0ViZxiqZ3B+3jzWUVc2gr56h3x+jsWooP8qq5QhccUM/t68E9FU9B+48gd6b8MC/bzkc+oPZu/15PRHIV5AzzgpC4iwvJM5IYJw5bDHupZ9rqElNZbWU1VZWR5leqK/+j1EWqyxOWV1l8coSlCUqq6esvrLrlF2vrIGyhspu0L2lrLGyJsqaKmum7EZlzZXdpOxmZS2UtVTWSllrZbcoa6PsVmVtld2mrJ2y25W1V3aHsg7KOirrpOxOZXcpu1tZZ2X3KOui7F5lXZUlKUtWlqIsVVmasnRl9ynrpqy7sh7K7lfWU1kvZb2V9VHWV1k/Zf2VPaBsgLKBygYpe1DZYGVDlA1V9pCyYcqGKxuh7GFlI5WNUjZa2SPKxigbq2ycskeVjVf2mLIJyh5XNlHZE8omKXtS2WRlTymbomyqsmnKpiuboWymslnKnlY2W9kcZXOVzVM2X9kzyhYoe1bZQmWLlC1WtkTZUmXLlC1XtkLZSmXPKVul7Hllq5W9oGyNsheVrVX2krJ1yl5Wtl7ZK8o2KHtV2UZlrynbpOx1ZZuVvaFsi7I3lW1V9paybcreVrZd2TvKdih7V9lOZe8p26XsfWW7lX2gbI+yD5XtVfaRsn3KPla2X9knyg4o+1TZQWWfKTuk7HNlh5V9oeyIsi+VfaXsa2VHlX2j7Jiyb5UdV/adshPKvld2UtkPyk4p+1HZaWU/KTuj7GdlZ5X9ouycsl+VnVf2m7ILyn5XdlFZceonfY7J+Xig78vlOD7o+yLo5zDbfZH0s/0NBQHsMSXI8CaFYO7Ale+ECukJ6ciVwf5EZLA/kbb1+W2/Dzj2Kpr+PgqqIzXGnpfQLYdj3sj2c5RNSyQ0lqClfRchXylJPXu27d99UNKAtOYDe6cM6N6ndw5beKGQQ4f18Ay2TN9y2n62r7GnJ7dNUui+PPRzpO0+e9mGxpB/+/oc4Fqz5isf1W1JAfkNmnr3o368RcWcQbjZ9Z3hux8v0SZczuGxdz9q4YdtYvUGlHX8T/S7H+0Fkt13P17Kvq+/nzhdZipc9Iv+SM1/ZODL7e9+/AOYpxyORPnvfsymzz/oSIL2myMMV/RcunOEwXPEcrXYZYoV7XeDkHc/ImspLAxXQxsY3v2o4ysXMPfZF7XcTX+h2xWfUJaTJuFhHqM/LZzrE8r0ZoYzHGTCw9x9kKHbFY2Q3U8oyxnm/v1DUy5Scy6bLymfUJYrDPtgELpF+JSLSU4EA+VGupxyte5IIZQbTrGi/UaBG1Nvp/b55wNywAyl1RZIablpksdrlJabkdL0ZuZhaJI8QiitNpDScoe5f//QlIbUnFcgpeVlorR8PqVhkpOPgdLyu5zStO78QigtD8WK9hvNQGnRhimtjkBKK0CTgl6jtAKMlKY3syBDkxQUQml1gJRWIMz9+4emNKTmQgIprRATpRX2KQ2TnMIMlFbE5ZSmdRcRQmkFKVa036IMlFbUMKXFCrze7SqaFPMapWnh9uvd9AaUdfxPNL3EAq93uwp4UCsmhF6Qmotn4Mvt17sVZ6KXEj69YJJTgoFeSrqcXrTukkLopRjFiva7Ucj1bshaKoU7GFkbGa530/GVC5ijvziB5+iupklpr9Hf1Yzn6PRmlmY4yJQWco4uDniO7uow9+8fmnKRmq8ReI7uGibKLeNTLiY5ZRgo91qXU67Wfa0Qyi1NsaL9lmU4R1fW8Dm6ugIprRxNynuN0soxUprezPIMTVJeCKXVBVJauTD37x+a0pCaKwiktApMlFbRpzRMcioyUFoll1Oa1l1JCKWVp1jRfiszUFplw5QWL5DSqtCkqtcorQojpenNrMrQJFWFUFo8kNKqhLl//9CUhtRcTSClVWOitOo+pWGSU52B0mq4nNK07hpCKK0qxYr2W5OB0moaprQEgde71aJJba9RmhZuv95Nb0BZx/9E00sC8Hq3WsCDWm0h9ILUXCcDX26/3q0OE70EfXrBJCfIQC+Wy+lF67aE0EttihXtd5OQ692QtRSDOxhZmxiud9PxlQuYo7+GAukvliZxXqO/WAf9xRmgv4ZA+osFNnKcEPpDaq4rkP7qMtFfvE9/mOTEM9BfgsvpT+tOEEJ/cRQr2u9mIfSHrKVEIP1tZqC/RMP010gg/dWjSX2v0V89B/3VN0B/jYD0Vw/YyPWF0B9S83UC6e86Jvq73qc/THKuZ6C/Bi6nP627gRD6q0+xov1uEUJ/yFpqCKS/LQz019Aw/TURSH830KSR1+jvBgf9NTJAf02A9HcDsJEbCaE/pObGAumvMRP9NfHpD5OcJgz019Tl9Kd1NxVCf40oVrTfrULoD1lLzYD0t5WB/poZpr9mAunvRpo09xr93eigv+YG6K8ZkP5uBDZycyH0h9R8k0D6u4mJ/m726Q+TnJsZ6K+Fy+lP624hhP6aU6xov9uE0B+ylloC6W8bA/21NEx/zQXSXyuatPYa/bVy0F9rA/TXHEh/rYCN3FoI/SE13yKQ/m5hor82Pv1hktOGgf5udTn9ad23CqG/1hQr2u92IfSHrKW2QPrbzkB/bQ3T380C6e82mrTzGv3d5qC/dgbo72Yg/d0GbOR2QugPqfl2gfR3OxP9tffpD5Oc9gz0d4fL6U/rvkMI/bWjWNF+dwihP2QtdQDS3w4G+utgmP5aCqS/jjTp5DX66+igv04G6K8lkP46Ahu5kxD6Q2q+UyD93clEf3f59IdJzl0M9He3y+lP675bCP11oljRfncKoT9kLXUG0t9OBvrrbJj+Wgukv3to0sVr9HePg/66GKC/1kD6uwfYyF2E0B9S870C6e9eJvrr6tMfJjldGegvyeX0p3UnCaG/LhQr2u8uIfSHrKVkIP3tYqC/ZMP010Yg/aXQJNVr9JfioL9UA/TXBkh/KcBGThVCf0jNaQLpL42J/tJ9+sMkJ52B/u5zOf1p3fcJob9UihXtd7cQ+kPWUjcg/e1moL9uhumvrUD6606THl6jv+4O+uthgP7aAumvO7CRewihP6Tm+wXS3/1M9NfTpz9Mcnoy0F8vl9Of1t1LCP31oFjRfvcIoT9kLfUG0t8eBvrrbZj+2gmkvz406es1+uvjoL++BuivHZD++gAbua8Q+kNq7ieQ/vox0V9/n/4wyenPQH8PuJz+tO4HhNBfX4oV7XevEPpD1tIAIP3tZaC/AYbpr71A+htIk0Feo7+BDvobZID+2gPpbyCwkQcJoT+k5gcF0t+DTPQ32Kc/THIGM9DfEJfTn9Y9RAj9DaJY0X73CaE/ZC0NBdLfPgb6G2qY/joIpL+HaDLMa/T3kIP+hhmgvw5A+nsI2MjDhNAfUvNwgfQ3nIn+Rvj0h0nOCAb6e9jl9Kd1PyyE/oZRrGi/+4XQH7KWRgLpbz8D/Y00TH+dBNLfKJqM9hr9jXLQ32gD9NcJSH+jgI08Wgj9ITU/IpD+HmGivzE+/WGSM4aB/sa6nP607rFC6G80xYr2e0AI/SFraRyQ/g4w0N84w/R3l0D6e5Qm471Gf4866G+8Afq7C0h/jwIbebwQ+kNqfkwg/T3GRH8TfPrDJGcCA/097nL607ofF0J/4ylWtN+DQugPWUsTgfR3kIH+Jhqmv84C6e8JmkzyGv094aC/SQborzOQ/p4ANvIkIfSH1PykQPp7kon+Jvv0h0nOZAb6e8rl9Kd1PyWE/iZRrGi/h4TQH7KWpgDp7xAD/U0xTH9dBNLfVJpM8xr9TXXQ3zQD9NcFSH9TgY08TQj9ITVPF0h/05nob4ZPf5jkzGCgv5kupz+te6YQ+ptGsaL9HhZCf8hamgWkv8MM9DfLMP11FUh/T9Nkttfo72kH/c02QH9dgfT3NLCRZwuhP6TmOQLpbw4T/c316Q+TnLkM9DfP5fSndc8TQn+zKVa03yNC6A9ZS/OB9HeEgf7mG6a/ZIH09wxNFniN/p5x0N8CA/SXDKS/Z4CNvEAI/SE1PyuQ/p5lor+FPv1hkrOQgf4WuZz+tO5FQuhvAcWK9vuVEPpD1tJiIP19xUB/iw3TX6pA+ltCk6Veo78lDvpbaoD+UoH0twTYyEuF0B9S8zKB9LeMif6W+/SHSc5yBvpb4XL607pXCKG/pRQr2u9RIfSHrKWVQPo7ykB/Kw3TX7pA+nuOJqu8Rn/POehvlQH6SwfS33PARl4lhP6Qmp8XSH/PM9Hfap/+MMlZzUB/L7ic/rTuF4TQ3yqKFe33mBD6Q9bSGiD9HWOgvzWG6a+bQPp7kSZrvUZ/Lzrob60B+usGpL8XgY28Vgj9ITW/JJD+XmKiv3U+/WGSs46B/l52Of1p3S8Lob+1FCva73Eh9IespfVA+jvOQH/rDdNfD4H09wpNNniN/l5x0N8GA/TXA0h/rwAbeYMQ+kNqflUg/b3KRH8bffrDJGcjA/295nL607pfE0J/GyhWtN8TQugPWUubgPR3goH+Nhmmv54C6e91mmz2Gv297qC/zQboryeQ/l4HNvJmIfSH1PyGQPp7g4n+tvj0h0nOFgb6e9Pl9Kd1vymE/jZTrGi/J4XQH7KWtgLp7yQD/W01TH+9BdLfWzTZ5jX6e8tBf9sM0F9vIP29BWzkbULoD6n5bYH09zYT/W336Q+TnO0M9PeOy+lP635HCP1to1jRfk8JoT9kLe0A0t8pBvrbYZj++gqkv3dpstNr9Peug/52GqC/vkD6exfYyDuF0B9S83sC6e89Jvrb5dMfJjm7GOjvfZfTn9b9vhD620mxov2eFkJ/yFraDaS/0wz0t9sw/fUXSH8f0GSP1+jvAwf97TFAf/2B9PcBsJH3CKE/pOYPBdLfh0z0t9enP0xy9jLQ30cupz+t+yMh9LeHYkX7PSOE/pC1tA9If2cY6G+fYfobIJD+PqbJfq/R38cO+ttvgP4GAOnvY2Aj7xdCf0jNnwikv0+Y6O+AT3+Y5BxgoL9PXU5/WvenQuhvP8WK9ntWCP0ha+kgkP7OMtDfQcP0N0gg/X1Gk0Neo7/PHPR3yAD9DQLS32fARj4khP6Qmj8XSH+fM9HfYZ/+MMk5zEB/X7ic/rTuL4TQ3yGKFe33nBD6Q9bSESD9nWOgvyOG6W+wQPr7kiZfeY3+vnTQ31cG6G8wkP6+BDbyV0LoD6n5a4H09zUT/R316Q+TnKMM9PeNy+lP6/5GCP19RbGi/Z4XQn/IWjoGpL/zDPR3zDD9DRVIf9/S5LjX6O9bB/0dN0B/Q4H09y2wkY8LoT+k5u8E0t93TPR3wqc/THJOMNDf9y6nP637eyH0d5xiRfu9IIT+kLV0Ekh/Fxjo76Rh+hsmkP5+oMkpr9HfDw76O2WA/oYB6e8HYCOfEkJ/SM0/CqS/H5no77RPf5jknGagv59cTn9a909C6O8UxYr2e1EI/SFr6QyQ/i4y0N8Zw/Q3WiD9/UyTs16jv58d9HfWAP2NBtLfz8BGPiuE/pCafxFIf78w0d85n/4wyTnHQH+/upz+tO5fhdDfWYoV7feyEPpD1tJ5IP1dZqC/84bpb4xA+vuNJhe8Rn+/OejvggH6GwOkv9+AjXxBCP0hNf8ukP5+Z6K/iz79YZJzkYH+Lrmc/rTuS0Lo7wLFivYbKCiD/pC1dBlIf8j9Cz2gXzZMf+ME0t8fYf8Umqfo7w8H/ekNKOv4n2j6Gwekvz+QDwo5ZdAfUnOOnPLoL0dO7EHy7zzl9OkPkhy9kWi/OXO6m/607pw54Tliob8AxYr2GyaE/pC1FI47GFlhDPSn4zNJf+MF0l8uKrAIr9GfFm6nvwgD9DceSH+5gI0cIYT+kJojBdJfJBP9Rfn0h0lOFAP95XY5/WnduYXQXwTFivYbLoT+kLWUB0h/4Qz0l8cw/U0QSH95qcDyeY3+8jroL58B+psApL+8wEbOJ4T+kJrzC6S//Ez0F+3THyY50Qz0V8Dl9Kd1FxBCf/koVjhVCqE/ZC0VBNJfBAP9FTRMfxMF0l8hKrDCXqO/Qg76K2yA/iYC6a8QsJELC6E/pOYiAumvCBP9FfXpD5Ocogz0d5XL6U/rvkoI/RWmWNF+o4TQH7KWigHpL4qB/ooZpr9JAumvOBVYCa/RX3EH/ZUwQH+TgPRXHNjIJYTQH1JzSYH0V5KJ/kr59IdJTikG+rva5fSndV8thP5KUKxov3mE0B+ylkoD6S8PA/2VNkx/kwXS3zVUYGW8Rn/XOOivjAH6mwykv2uAjVxGCP0hNV8rkP6uZaK/sj79YZJTloH+yrmc/rTuckLorwzFCn9FWQj9IWupPJD+8jHQX3nD9DdFIP1VoAKr6DX6q+Cgv4oG6G8KkP4qABu5ohD6Q2quJJD+KjHRX2Wf/jDJqcxAf1VcTn9adxUh9FeRYkX7jRZCf8haqgqkv2gG+qtqmP6mCaS/alRg1b1Gf9Uc9FfdAP1NA9JfNWAjVxdCf0jNNQTSXw0m+qvp0x8mOTUZ6K+Wy+lP664lhP6qU6xovwWF0B+ylmoD6a8gA/3VNkx/MwTSXx0qsKDX6K+Og/6CBuhvBpD+6gAbOSiE/pCaLYH0ZzHRX4xPf5jkxDDQX6zL6U/rjhVCf0GKFe23sBD6Q9ZSHJD+CjPQX5xh+pslkP7qUoHFe43+6jroL94A/c0C0l9dYCPHC6E/pOYEgfSXwER/iT79YZKTyEB/9VxOf1p3PSH0F0+xov0WFUJ/yFqqD6S/ogz0V98w/c0WSH/XUYFd7zX6u85Bf9cboL/ZQPq7DtjI1wuhP6TmBgLprwET/TX06Q+TnIYM9HeDy+lP675BCP1dT7Gi/RYTQn/IWmoEpL9iDPTXyDD9zRVIf42pwJp4jf4aO+iviQH6mwukv8bARm4ihP6QmpsKpL+mTPTXzKc/THKaMdDfjS6nP637RiH014RiRfstIYT+kLXUHEh/JRjor7lh+psvkP5uogK72Wv0d5OD/m42QH/zgfR3E7CRbxZCf0jNLQTSXwsm+mvp0x8mOS0Z6K+Vy+lP624lhP5upljRfksJoT9kLbUG0l8pBvprbZj+Fgikv1uowNp4jf5ucdBfGwP0twBIf7cAG7mNEPpDar5VIP3dykR/bX36wySnLQP93eZy+tO6bxNCf20oVrTf0kLoD1lL7YD0V5qB/toZpr9FAunvdiqw9l6jv9sd9NfeAP0tAtLf7cBGbi+E/pCa7xBIf3cw0V8Hn/4wyenAQH8dXU5/WndHIfTXnmJF+y0jhP6QtdQJSH9lGOivk2H6WyqQ/u6kArvLa/R3p4P+7jJAf0uB9HcnsJHvEkJ/SM13C6S/u5nor7NPf5jkdGagv3tcTn9a9z1C6O8uihXtt6wQ+kPWUhcg/ZVloL8uhulvhUD6u5cKrKvX6O9eB/11NUB/K4D0dy+wkbsKoT+k5iSB9JfERH/JPv1hkpPMQH8pLqc/rTtFCP11pVjRfssLoT9kLaUC6a88A/2lGqa/VQLpL40KLN1r9JfmoL90A/S3Ckh/acBGThdCf0jN9wmkv/uY6K+bT3+Y5HRjoL/uLqc/rbu7EPpLp1jRfisKoT9kLfUA0l9FBvrrYZj+XhBIf/dTgfX0Gv3d76C/ngbo7wUg/d0PbOSeQugPqbmXQPrrxUR/vX36wySnNwP99XE5/WndfYTQX0+KFe23shD6Q9ZSXyD9VWagv76G6W+tQPrrRwXW32v0189Bf/0N0N9aIP31AzZyfyH0h9T8gED6e4CJ/gb49IdJzgAG+hvocvrTugcKob/+FCvab1Uh9IespUFA+qvKQH+DDNPfywLp70EqsMFeo78HHfQ32AD9vQykvweBjTxYCP0hNQ8RSH9DmOhvqE9/mOQMZaC/h1xOf1r3Q0LobzDFivZbXQj9IWtpGJD+qjPQ3zDD9LdBIP0NpwIb4TX6G+6gvxEG6G8DkP6GAxt5hBD6Q2p+WCD9PcxEfyN9+sMkZyQD/Y1yOf1p3aOE0N8IihXtt6YQ+kPW0mgg/dVkoL/RhunvNYH09wgV2Biv0d8jDvobY4D+XgPS3yPARh4jhP6QmscKpL+xTPQ3zqc/THLGMdDfoy6nP637USH0N4ZiRfutLYT+kLU0Hkh/tRnob7xh+tsskP4eowKb4DX6e8xBfxMM0N9mIP09BmzkCULoD6n5cYH09zgT/U306Q+TnIkM9PeEy+lP635CCP1NoFjRfoNC6A9ZS5OA9BdkoL9JhunvTYH09yQV2GSv0d+TDvqbbID+3gTS35PARp4shP6Qmp8SSH9PMdHfFJ/+MMmZwkB/U11Of1r3VCH0N5liRfuNEUJ/yFqaBqS/GAb6m2aY/rYJpL/pVGAzvEZ/0x30N8MA/W0D0t90YCPPEEJ/SM0zBdLfTCb6m+XTHyY5sxjo72mX05/W/bQQ+ptBsaL9xgmhP2QtzQbSXxwD/c02TH/vCKS/OVRgc71Gf3Mc9DfXAP29A6S/OcBGniuE/pCa5wmkv3lM9Dffpz9McuYz0N8zLqc/rfsZIfQ3l2JF+40XQn/IWloApL94BvpbYJj+dgqkv2epwBZ6jf6eddDfQgP0txNIf88CG3mhEPpDal4kkP4WMdHfYp/+MMlZzEB/S1xOf1r3EiH0t5BiRftNFEJ/yFpaCqS/RAb6W2qY/t4XSH/LqMCWe43+ljnob7kB+nsfSH/LgI28XAj9ITWvEEh/K5job6VPf5jkrGSgv+dcTn9a93NC6G85xYr2W18I/SFraRWQ/uoz0N8qw/S3RyD9PU8Fttpr9Pe8g/5WG6C/PUD6ex7YyKuF0B9S8wsC6e8FJvpb49MfJjlrGOjvRZfTn9b9ohD6W02xov1eL4T+kLW0Fkh/1zPQ31rD9PeZQPp7iQpsndfo7yUH/a0zQH+fAenvJWAjrxNCf0jNLwukv5eZ6G+9T3+Y5KxnoL9XXE5/WvcrQuhvHcWK9ttQCP0ha2kDkP4aMtDfBsP097VA+nuVCmyj1+jvVQf9bTRAf18D6e9VYCNvFEJ/SM2vCaS/15job5NPf5jkbGKgv9ddTn9a9+tC6G8jxYr220gI/SFraTOQ/hox0N9mw/T3rUD6e4MKbIvX6O8NB/1tMUB/3wLp7w1gI28RQn9IzW8KpL83mehvq09/mORsZaC/t1xOf1r3W0LobwvFivbbRAj9IWtpG5D+mjDQ3zbD9PedQPp7mwpsu9fo720H/W03QH/fAenvbWAjbxdCf0jN7wikv3eY6G+HT3+Y5OxgoL93XU5/Wve7QuhvO8WK9ttMCP0ha2knkP6aMdDfTsP0971A+nuPCmyX1+jvPQf97TJAf98D6e89YCPvEkJ/SM3vC6S/95nob7dPf5jk7Gagvw9cTn9a9wdC6G8XxYr221wI/SFraQ+Q/poz0N8ew/T3g0D6+5AKbK/X6O9DB/3tNUB/PwDp70NgI+8VQn9IzR8JpL+PmOhvn09/mOTsY6C/j11Of1r3x0Loby/FivZ7sxD6Q9bSfiD93cxAf/sN09+PAunvEyqwA16jv08c9HfAAP39CKS/T4CNfEAI/SE1fyqQ/j5lor+DPv1hknOQgf4+czn9ad2fCaG/AxQr2m9LIfSHrKVDQPpryUB/hwzT30V301/oFmPfi8+pwA57jf608EuOYFD/Q2/mYYaDzOGc7j7I0O2KRvhfNael/3X7PKf79w9NuUjNX9h8WYmxMTEJsXpdYmrQiktNiUmMiUlNjgumBJNSYtLqxVn10uNi4mJTUlOSlc8kKz2YnpRSLz3xr7hMUe4XTJR7xKdcTHKOMFDuly6nXK37SyGUe5hiRfv9CtyYugm1Tyc5oHI2X/mongO/D1/ndHf+I5WPrxny37ogr+5g9m5W7TAe3bcUlAEOwPxYUjSvAz5uHM3p7sdeXdtHGer7G4bj+je20+nofagY4OnztgXdfVyvkYNH921Ceh2YH+s2l+e6AlONt3f5Y/hlphq/Q0iNA/Nj3eHyXJdnqvFOLu/tRKYav1NIjQPzY93p8hrXz8W/NnTeIJi9m1U6TE6s5QXFWtVgrNk9hmh/HMemzi7v0yDTMfkeIcdkYH6se1yea4sp110N5dpFz3MtpGadj6jAPy/S6OcCl/U87K8xD40FQ3NlxyiPUWR/xkF/Z9EYQ2Mx+rvSNJansSqNtWkspOxbm98I8nuW/PxC4zkaf6XxPI2/0ZhP2XGbn03kR/vWv0+kdfVorE/jdTReT2MDGuMovhtC62nemOaNaN6U5s1pfiPNW9P8Jpq3o3kLmneieSuad6H5LTRPpfmtNO9B89to3pfmt9N8EM3voPkwmnek+Wia30nz8TS/m+aTaH4PzafR/F6az6Z5Es0X0DyF5ktpnkbzVTS/j+Zrad6d5htofj/NN9O8F8230bwPzXfSvB/N99D8AZrvp/lAmh+i+YM0/4rmQ2h+nOYP0fwUzUfR/CzNH6H5BZqPpXmA6upRmkfQ/LFQPdL8cZoXpvkTNC9B8ydpXobmT9G8Is2n0rw6zafTPEjzmTSPp/nToXqm+RyaN6H5PJrfTPNnaN6G5s/SfCGN7en+xTRfQuNddP8ymi+nsSvdv5Lmz9GYTvc/T/PVNPak+9fQ/EUa+9P9L9F8HY2D6f71NH+FxhF0/6s030jjGLp/E81fp3EC3f8GzbfQOJnu30rzt2icQfe/TfPtNM6l+3fQ/N3Q/tH979F8V2if6P7dNP8gtB90/4c030vjRzTuo/HjUL3T+AmNB2j8lMaDoX0jv4do/jmNh2n8gsYjNH4Z6pfQPtLfH6X5NzQeC+0b/f54aF9ofiKkm+YnQ7pofioUN81P0/wnGs/Q+HOoX2ndBZr/HuoLZd/Zjvsh9K8RipP+7jsaC+vYaFEOWtuIxmD2blYlvU8BPOsku5zx9Ou+HK+VpBi60jO7cX4PfC0LmGsrRUDdnGCom5M53a1bHyeq5cDr/gGo29QFaFUD2Oc0odsp/wI0THJOMVyA9qPLL0DTun9kOokYuqFPNCD39DTwAU1vY3jg3zc3H0g446wiJM7K4DjRJ1HnKR+RQH/zlY/vGXo+hy0/0fTzT+r/nFH2s7Kzyn5Rdk7Zr8rOK/tN2QVlvyu7qN89oZ+8KCtOf6/fyuHsKX2f/W0loftCJ9TCbPdF0s/2B0O0boYH2GDuwJVvlwnpCenIlcH+RGSwP5G29fltvw849iqa/j4KqyPNnpfQzQkGjWw/R9m0RGJjsbTvkuQrrXe/gWkD09oOTO7ZPaX5wN4pA7r36d00qWdPexFH2DZH38Iz2Dh9s/XSFWvsScptExa6Lw/9HGm7z168oTHk374+B/ooqB8Jq9mCB/n9E6/tmxW6oeM/k5Pn0Qa0Hxl+TMIfocyGe+yNclr4YbvYcP6PSTiTfWz8+2MS/kBifbiM13KRmnOE/9uX2z8mIUc4HpX+zFO4//wdkhy9kWi/OcPd/fxd684ZDs8Ry0VAAYoV7TddyMckIGspHHcwstLBF1vog5iOr1zA3Mck/Oxu+gvdrviYhFzUtxFeoz8tnOtjEvRmRjAcZCLC3X2QodsVjZDdj0nIFe7+/UNTLlJzpM2XlI9JiGSi3CifcjHJiWKg3Nwup1ytO7cQyo2gWNF+84AbUzeh9hkWMEdpZwVSWl6qu3xeo7S8jJSmNzMfQ5PkE0JpZ4GUljfc/fuHpjSk5vwCKS0/E6VF+5SGSU40A6UVcDmlad0FhFBaPooV7bcgA6UVNExpvwiktEJUd4W9RmmFGClNb2ZhhiYpLITSfgFSWqFw9+8fmtKQmosIpLQiTJRW1Kc0THKKMlDaVS6nNK37KiGUVphiRfstxkBpxQxT2m8Cr3crTnVXwmuUpoXbr3crYeB6t9+A17sVBx7USgihF6TmkgKvdyvJRC+lfHrBJKcUA71c7XJ60bqvFkIvJShWtN9uQq53Q9ZSaeD1bt0Yrncrbfh6twsCz9FdQ31bxmv0dw3jOTq9mWUYDjJlhJyjuwA8R3dNuPv3D025SM3XCjxHdy0T5Zb1KReTnLIMlFvO5ZSrdZcTQrllKFa03/IM5+jKGz5H97tASqtAdVfRa5RWgZHS9GZWZGiSikIo7XcgpVUId//+oSkNqbmSQEqrxERplX1KwySnMgOlVXE5pWndVYRQWkWKFe23KgOlVTVMaRcFUlo1qrvqXqO0aoyUpjezOkOTVBdCaReBlFYt3P37h6Y0pOYaAimtBhOl1fQpDZOcmgyUVsvllKZ11xJCadUpVrTf2gyUVtswpV0SeL1bHaq7oNcorY7jereggevdLgGvd6sDPKgFhdALUrMl8Ho3i4leYnx6wSQnhoFeYl1OL1p3rBB6CVKsaL89hFzvhqylOOD1bj0YrneLo+vdOGpefwrxaYYvS6kbzts/wezd/vxc/7oM/dPT5V9crT8jnkN3LyFfkgrMj9XL5bmuwlTjfV3+BVCaADl09xNS48D8WP1cnmv98fzzGHpngMt1h75XBK17oJAvx4sHMhsw19ZAl9dNkOnYONjlj4VaczyD7iFCHhOA+bGkaI4HPkdMAB5vMqrvYPZulq7vBIb6TmR4NSPRdoIavQ/6+8U4jm/DXH58u8z0vG64kF4H5sca7vLH8DL0GB7A+mWJtaKgWKsbjDXbX+oT4On3kS6v/XNMx7lRQo5zwPxYo1ye61+Zcj3GUK5ddC7ZQmrW+dDf7/j3oVL9cDnw11eB6DEfjYVp1F+lWI/yGBX453sndS/r3/9K43kaS9DflaGxIo3VaQzSWEhZfZvf0DmG2MBfv3eO+gqN67K4/vosrm+QxfUNs7j+hiyub5TF9Y2zuL5JFtc3zeL6Zllcf2MW1zfP4vqbsrj+5iyub5HF9S1t68P+w3r9u1aZXNc6k+tuyeS6Nplcd2sm17XN5LrbMrmuXSbX3Z7Jde0zue6OTK7rkMl1HTO5rlMm192ZyXV3ZWLdNcruzuS6zplcd08m13XJ5Lp7M7muaybXJWVyXXIm16Vkcl1qJtelZXJdeibX3ZfJdd0yua57Jtf1yMLxUq+/P4vre2Zxfa8sru+dxfV9sri+bxbX98vi+v5ZXP9AFtcPyOL6gVlcPyiL6x/M4vrBWVw/JIvrh9rWJ9P6+sTHl3Nm/HfO8Tpafz2NDWhsSOMNNDaisTGNTWhsSmMzGm+ksTmNN9F4M40taGxJYysaW9N4C41taLyVxrY03kZjOxpvp7E9jXfQ2IHGjjR2ovFOGu8Kz9z+3E3rOtN4D41daLyXxq40JtGYTGMKjak0ptGYTuN9NHajsTuNPWi8n8aeNPaisTeNfWjsS2M/GvvT+ACNA2gcSOMgGh+kcTCNQ2gcmsn9cftYQ9lDGfTVT9Qf9UjnQzQWVjYs/N/vtuB4Db+SzT/IL/IdF5bzDvt+DA//axwR7rF3XGjhm21i9QY0cgSH+p+6QOYH8CfBxrnzQo+gI05reDhOsz1PwezdrHFCThgj9+/h/+IrMSEtOT0hLjYpGJeerPzEp6fFJsXUs9ITY5X72DgrOSktmBqXnBAfF5+YnhA09U6Th3E5v+KdJiPD/XeaQJIzMhzvdxSw6Ll0jwqH54jllcYRFCva73iXvtPkX68MAmtpNPABaDz4FR19ENPxNQ6Ye59xdh6Q06+8pWQQLgv1PkJ9O+a/UG+TDPbMSb1NAv839Wbkxzj12v85yqfexEcYDiqPhOObYozNZ+iGfj/1iP/9IPMvYn4EeMAaw9SgYYx5z66vseHu7h19ScRYht5x+1v29LPgHxje8jAOqFs/IOi3pITYTvvWp6FCxrEvXGcIHnV5Peh6fZQDTIG6w6kenDfkvnLs7fhw98f4GEOMf97QD051gQ9OEwQ8OA1jaMoJLr9WURfjBAbdjwt5P97jwLoE5tpC7h/zwfzv03tePJg/LuVgXg3oayKwaXRDhwf+fUMnqmqAJ1HoOKsIibOykDjjwWdWQjHupZ+fUP4nKXtS2WRlTymbomyqsmnKpiuboWymslnKnlY2W9kcZXOVzVM2X9kzyhYoe1bZQmWLlC1WtkTZUmXLlC1XtkLZSmXPKVul7Hllq5W9oGyNsheVrVX2krJ1yl5Wtl7ZK8o2KHtV2UZlrynbpOx1/ZqwsjeUbVH2prKtyt5Stk3Z28q2K3tH2Q5l7yrbqew9ZbuUva9st7IPlO1R9qGyvco+UrZP2cfK9iv7RNkBZZ8qO6jsM2WHlH2u7LCyL5QdUfalsq+Ufa3sqLJvlB1T9q2y48q+U3ZC2ffKTir7QdkpZT8qO63sJ2VnlP2s7KyyX5SdU/arsvPKflN2Qdnvyi4qu6TssrI/9EFIPQ3OoSxMWU5l4cpyKYtQFqksSlluZXmU5VWWT1l+ZdHKCigrqKyQssLKiigrquwqZcWUFVdWQllJZaWUXa2stLJrlJVRdq2yssrKKSuvrIKyisoqKausrIqyqsqqKauurIaymspqKautrI4y/TTeUhajLFZZnLK6yuKVJShLVFZPWX1l1ym7XlkDZQ2V3aCskbLGypooa6qsmbIblTVXdpOym5W1UNZSWStlrZXdoqyNsluVtVV2m7J2ym5X1l7ZHco6KOuorJOyO5XdpexuZZ2V3aOsi94f6id9mtj5eJA7cOUp69B9EfRzmO2+EOjYX88MYI8pQYbXSIO5A1eeig/pCenIlcH+RGSwP5G29fltvw849iqa/j4KqiM1xp6X0M15ir+R7ecom5ZIaCxBS/suQr5Sknr2bNu/+6CkAWnNB/ZOGdC9T2/74TwUcuiwHp7BlulbTtvP9jX29OS2SQrdl4d+jrTdZy/b0Bjyb1+fA/2YqD84baItepDfoKmX3yZxQTcmzgw/5vdeqpCuuTx20ZkWftgmVm9AWcf/RL8sZS+Q7H7Mr44/m77+fuLUNRdP4aIvvkJqTsrAl9s/5jcJmCd7vMm5/IuvIMnRG4n2mwIsei7dKbngOWK5+KorxYr2O8mlF1+FbqE4kbWUmgv4wMhw8ZWOr1zA3MVXT7qb/kK3K76KK436Nt1r9KeFc30Vl97MdIaDTHoudx9k6HZFI2T3q7jScrl//9CUi9R8n82XlK/iuo+Jcrv5lItJTjcGyu3ucsrVursLodx0ihXttwe4MXUTap9hAXOUNlkgpd1PddfTa5R2PyOl6c3sydAkPYVQ2mQgpd2fy/37h6Y0pOZeAimtFxOl9fYpDZOc3gyU1sfllKZ19xFCaT0pVrTfvgyU1tcwpT0lkNL6Ud319xql9WOkNL2Z/RmapL8QSnsKSGn9crl//9CUhtT8gEBKe4CJ0gb4lIZJzgAGShvockrTugcKobT+FCva7yAGShtkmNKmC7ze7UGqu8Feo7QHHde7DTZwvdt04PVuDwIPaoOF0AtS8xCB17sNYaKXoT69YJIzlIFeHnI5vWjdDwmhl8EUK9rvZCHXuyFraRjwerfJDNe7DTN8vdsMgefohlPfjvAa/Q1nPEenN3MEw0FmhJBzdDOA5+iG53L//qEpF6n5YYHn6B5motyRPuVikjOSgXJHuZxyte5RQih3BMWK9jua4RzdaMPn6GYKpLRHqO7GeI3SHmGkNL2ZYxiaZIwQSpsJpLRHcrl//9CUhtQ8ViCljWWitHE+pWGSM46B0h51OaVp3Y8KobQxFCva73gGShtvmNJmCaS0x6juJniN0h5jpDS9mRMYmmSCEEqbBaS0x3K5f//QlIbU/LhASnucidIm+pSGSc5EBkp7wuWUpnU/IYTSJlCsaL+TGChtkmFKe1rg9W5PUt1N9hqlPem43m2ygevdngZe7/Yk8KA2WQi9IDU/JfB6t6eY6GWKTy+Y5ExhoJepLqcXrXuqEHqZTLGi/U4Rcr0bspamAa93m8Jwvds0w9e7LRBIf9Opb2d4jf6mO+hvhgH6WwCkv+nARp4hhP6QmmcKpL+ZTPQ3y6c/THJmMdDf0y6nP637aSH0N4NiRfudJoT+kLU0G0h/0xjob7Zh+lsokP7mUN/O9Rr9zXHQ31wD9LcQSH9zgI08Vwj9ITXPE0h/85job75Pf5jkzGegv2dcTn9a9zNC6G8uxQqnSiH0h6ylBUD6m8FAfwsM099igfT3LPXtQq/R37MO+ltogP4WA+nvWWAjLxRCf0jNiwTS3yIm+lvs0x8mOYsZ6G+Jy+lP614ihP4WUqxov7OE0B+ylpYC6W8WA/0tNUx/SwXS3zLq2+Veo79lDvpbboD+lgLpbxmwkZcLoT+k5hUC6W8FE/2t9OkPk5yVDPT3nMvpT+t+Tgj9LadY0X5nC6E/ZC2tAtLfbAb6W2WY/pYLpL/nqW9Xe43+nnfQ32oD9LccSH/PAxt5tRD6Q2p+QSD9vcBEf2t8+sMkZw0D/b3ocvrTul8UQn+rKVb4K8pC6A9ZS2uB9DeXgf7WGqa/lQLp7yXq23Veo7+XHPS3zgD9rQTS30vARl4nhP6Qml8WSH8vM9Hfep/+MMlZz0B/r7ic/rTuV4TQ3zqKFe13vhD6Q9bSBiD9zWegvw2G6W+VQPp7lfp2o9fo71UH/W00QH+rgPT3KrCRNwqhP6Tm1wTS32tM9LfJpz9McjYx0N/rLqc/rft1IfS3kWJF+10ghP6QtbQZSH8LGOhvs2H6Wy2Q/t6gvt3iNfp7w0F/WwzQ32og/b0BbOQtQugPqflNgfT3JhP9bfXpD5OcrQz095bL6U/rfksI/W2hWNF+FwqhP2QtbQPS30IG+ttmmP7WCKS/t6lvt3uN/t520N92A/S3Bkh/bwMbebsQ+kNqfkcg/b3DRH87fPrDJGcHA/2963L607rfFUJ/2ylWtN/FQugPWUs7gfS3mIH+dhqmv7UC6e896ttdXqO/9xz0t8sA/a0F0t97wEbeJYT+kJrfF0h/7zPR326f/jDJ2c1Afx+4nP607g+E0N8uihXtd6kQ+kPW0h4g/S1loL89hulvnUD6+5D6dq/X6O9DB/3tNUB/64D09yGwkfcKoT+k5o8E0t9HTPS3z6c/THL2MdDfxy6nP637YyH0t5diRftdLoT+kLW0H0h/yxnob79h+lsvkP4+ob494DX6+8RBfwcM0N96IP19AmzkA0LoD6n5U4H09ykT/R306Q+TnIMM9PeZy+lP6/5MCP0doFjRflcKoT9kLR0C0t9KBvo7ZJj+Ngikv8+pbw97jf4+d9DfYQP0twFIf58DG/mwEPpDav5CIP19wUR/R3z6wyTnCAP9fely+tO6vxRCf4cpVrTfVULoD1lLXwHpbxUD/X1lmP42CqS/r6lvj3qN/r520N9RA/S3EUh/XwMb+agQ+kNq/kYg/X3DRH/HfPrDJOcYA/1963L607q/FUJ/RylWtN/VQugPWUvHgfS3moH+jhumv00C6e876tsTXqO/7xz0d8IA/W0C0t93wEY+IYT+kJq/F0h/3zPR30mf/jDJOclAfz+4nP607h+E0N8JihXtd40Q+kPW0ikg/a1hoL9Thulvs0D6+5H69rTX6O9HB/2dNkB/m4H09yOwkU8LoT+k5p8E0t9PTPR3xqc/THLOMNDfzy6nP637ZyH0d5piRftdK4T+kLV0Fkh/axno76xh+tsikP5+ob495zX6+8VBf+cM0N8WIP39Amzkc0LoD6n5V4H09ysT/Z336Q+TnPMM9Peby+lP6/5NCP2do1jRftcJoT9kLV0A0t86Bvq7YJj+tgqkv9+pby96jf5+d9DfRQP0txVIf78DG/miEPpDar4kkP4uMdHfZZ/+MMm5zEB/f7ic/rTuP4TQ30WKFe13vRD6g9ZSBK6G1jPQn47PJP1tE0h/OSL+GsMiPEZ/Wrid/vQGlHX8TzT9bQPSX44IXCOHRfAULpr+kJpzRsijv5wR2INk6BYe4dMfJDl6I9F+cwGLnkt3rgh4jljoL4xiRfvdIIT+kLUUAaS/DQz0F2GY/rYLpL9I6tsor9FfpIP+ogzQ33Yg/UUCGzlKCP0hNecWSH+5megvj09/mOTkYaC/vC6nP607rxD6i6JY0X43CqE/ZC3lA9LfRgb6y2eY/nYIpL/81LfRXqO//A76izZAfzuA9Jcf2MjRQugPqbmAQPorwER/BX36wySnIAP9FXI5/WndhYTQXzTFiva7SQj9IWupMJD+NjHQX2HD9LdTIP0Vob4t6jX6K+Kgv6IG6G8nkP6KABu5qBD6Q2q+SiD9XcVEf8V8+sMkpxgD/RV3Of1p3cWF0F9RihXtd7MQ+kPWUgkg/W1moL8Shulvl0D6K0l9W8pr9FfSQX+lDNDfLiD9lQQ2cikh9IfUfLVA+ruaif5K+/SHSU5pBvq7xuX0p3VfI4T+SlGsaL9bhNAfspbKAOlvCwP9lTFMf7sF0t+11LdlvUZ/1zror6wB+tsNpL9rgY1cVgj9ITWXE0h/5Zjor7xPf5jklGegvwoupz+tu4IQ+itLsaL9bhVCf8haqgikv60M9FfRMP3tEUh/lahvK3uN/io56K+yAfrbA6S/SsBGriyE/pCaqwikvypM9FfVpz9Mcqoy0F81l9Of1l1NCP1VpljRfrcJoT9kLVUH0t82Bvqrbpj+9gqkvxrUtzW9Rn81HPRX0wD97QXSXw1gI9cUQn9IzbUE0l8tJvqr7dMfJjm1GeivjsvpT+uuI4T+alKsaL/bhdAfspaCQPrbzkB/QcP0t08g/VnUtzFeoz/LQX8xBuhvH5D+LGAjxwihP6TmWIH0F8tEf3E+/WGSE8dAf3VdTn9ad10h9BdDsaL97hBCf8haigfS3w4G+os3TH/7BdJfAvVtotfoL8FBf4kG6G8/kP4SgI2cKIT+kJrrCaS/ekz0V9+nP0xy6jPQ33Uupz+t+zoh9JdIsaL97hRCf8hauh5IfzsZ6O96w/R3QCD9NaC+beg1+mvgoL+GBujvAJD+GgAbuaEQ+kNqvkEg/d3ARH+NfPoDJYeB/hq7nP607sZC6K8hxYr2u0sI/SFrqQmQ/nYx0F8Tw/R3UCD9NaW+beY1+mvqoL9mBujvIJD+mgIbuZkQ+kNqvlEg/d3IRH/NffrDJKc5A/3d5HL607pvEkJ/zShWtN/dQugPWUs3A+lvNwP93WyY/g4JpL8W1LctvUZ/LRz019IA/R0C0l8LYCO3FEJ/SM2tBNJfKyb6a+3THyY5rRno7xaX05/WfYsQ+mtJsaL97hFCf8haagOkvz0M9NfGMP0dFkh/t1LftvUa/d3qoL+2BujvMJD+bgU2clsh9IfUfJtA+ruNif7a+fSHSU47Bvq73eX0p3XfLoT+2lKsaL97hdAfspbaA+lvLwP9tTdMf0cF0t8d1LcdvEZ/dzjor4MB+jsKpL87gI3cQQj9ITV3FEh/HZnor5NPf5jkdGKgvztdTn9a951C6K8DxYr2u08I/SFr6S4g/e1joL+7DNPfMYH0dzf1bWev0d/dDvrrbID+jgHp725gI3cWQn9IzfcIpL97mOivi09/mOR0YaC/e11Of1r3vULorzPFiva7Xwj9IWupK5D+9jPQX1fD9HdcIP0lUd8me43+khz0l2yA/o4D6S8J2MjJQugPqTlFIP2lMNFfqk9/mOSkMtBfmsvpT+tOE0J/yRQr2u8BIfSHrKV0IP0dYKC/dMP0d0Ig/d1HfdvNa/R3n4P+uhmgvxNA+rsP2MjdhNAfUnN3gfTXnYn+evj0h0lODwb6u9/l9Kd13y+E/rpRrGi/B4XQH7KWegLp7yAD/fU0TH8nBdJfL+rb3l6jv14O+uttgP5OAumvF7CRewuhP6TmPgLprw8T/fX16Q+TnL4M9NfP5fSndfcTQn+9KVa030NC6A9ZS/2B9HeIgf76G6a/UwLp7wHq2wFeo78HHPQ3wAD9nQLS3wPARh4ghP6QmgcKpL+BTPQ3yKc/THIGMdDfgy6nP637QSH0N4BiRfs9LIT+kLU0GEh/hxnob7Bh+jstkP6GUN8O9Rr9DXHQ31AD9HcaSH9DgI08VAj9ITU/JJD+HmKiv2E+/WGSM4yB/oa7nP607uFC6G8oxYr2e0QI/SFraQSQ/o4w0N8Iw/R3RiD9PUx9O9Jr9Pewg/5GGqC/M0D6exjYyCOF0B9S8yiB9DeKif5G+/SHSc5oBvp7xOX0p3U/IoT+RlKsaL9fCaE/ZC2NAdLfVwz0N8Yw/Z0VSH9jqW/HeY3+xjrob5wB+jsLpL+xwEYeJ4T+kJofFUh/jzLR33if/jDJGc9Af4+5nP607seE0N84ihXt96gQ+kPW0gQg/R1loL8JhunvnED6e5z6dqLX6O9xB/1NNEB/54D09ziwkScKoT+k5icE0t8TTPQ3yac/THImMdDfky6nP637SSH0N5FiRfs9JoT+kLU0GUh/xxjob7Jh+jsvkP6eor6d4jX6e8pBf1MM0N95IP09BWzkKULoD6l5qkD6m8pEf9N8+sMkZxoD/U13Of1p3dOF0N8UihXt97gQ+kPW0gwg/R1noL8ZhunvgkD6m0l9O8tr9DfTQX+zDNDfBSD9zQQ28iwh9IfU/LRA+nuaif5m+/SHSc5sBvqb43L607rnCKG/WRQr2u8JIfSHrKW5QPo7wUB/cw3T30WB9DeP+na+1+hvnoP+5hugv4tA+psHbOT5QugPqfkZgfT3DBP9LfDpD5OcBQz096zL6U/rflYI/c2nWNF+TwqhP2QtLQTS30kG+ltomP4uC6S/RdS3i71Gf4sc9LfYAP1dBtLfImAjLxZCf0jNSwTS3xIm+lvq0x8mOUsZ6G+Zy+lP614mhP4WU6xov6eE0B+ylpYD6e8UA/0tN0x/Gp9QGjIIl4X+VlDfrvQa/a1w0N9KA/RnL5Ds0t8KYCOvFEJ/SM3PCaS/55job5VPf5jkrGKgv+ddTn9a9/NC6G8lxYr2e1oI/SFraTWQ/k4z0N9qw/QXJpD+XqC+XeM1+nvBQX9rDNBfGJD+XgA28hoh9IfU/KJA+nuRif7W+vSHSc5aBvp7yeX0p3W/JIT+1lCsaL9nhNAfspbWAenvDAP9rTNMf7kE0t/L1LfrvUZ/Lzvob70B+ssFpL+XgY28Xgj9ITW/IpD+XmGivw0+/WGSs4GB/l51Of1p3a8Kob/1FCva71kh9IespY1A+jvLQH8bDdNflED6e436dpPX6O81B/1tMkB/UUD6ew3YyJuE0B9S8+sC6e91Jvrb7NMfJjmbGejvDZfTn9b9hhD620Sxov2eE0J/yFraAqS/cwz0t8Uw/eUVSH9vUt9u9Rr9vemgv60G6C8vkP7eBDbyViH0h9T8lkD6e4uJ/rb59IdJzjYG+nvb5fSndb8thP62Uqxov+eF0B+ylrYD6e88A/1tN0x/0QLp7x3q2x1eo793HPS3wwD9RQPp7x1gI+8QQn9Ize8KpL93mehvp09/mOTsZKC/91xOf1r3e0LobwfFivZ7QQj9IWtpF5D+LjDQ3y7D9FdIIP29T32722v0976D/nYboL9CQPp7H9jIu4XQH1LzBwLp7wMm+tvj0x8mOXsY6O9Dl9Of1v2hEPrbTbGi/V4UQn/IWtoLpL+LDPS31zD9FRVIfx9R3+7zGv195KC/fQboryiQ/j4CNvI+IfSH1PyxQPr7mIn+9vv0h0nOfgb6+8Tl9Kd1fyKE/vZRrGi/l4XQH7KWDgDp7zID/R0wTH/FBdLfp9S3B71Gf5866O+gAforDqS/T4GNfFAI/SE1fyaQ/j5jor9DPv1hknOIgf4+dzn9ad2fC6G/gxQr2m+gkAz6Q9bSYSD9Ifcv9IB+2DD9lRJIf19Q3x7xGv194aC/IwborxSQ/r4ANvIRIfSH1PylQPr7kon+vvLpD5Ocrxjo72uX05/W/bUQ+jtCsaL9hgmhP2QtHQXSXxgD/R01TH/XCKS/b6hvj3mN/r5x0N8xA/R3DZD+vgE28jEh9IfU/K1A+vuWif6O+/SHSc5xBvr7zuX0p3V/J4T+jlGsaL/hQugPWUsngPQXzkB/JwzTX1mB9Pc99e1Jr9Hf9w76O2mA/soC6e97YCOfFEJ/SM0/CKS/H5jo75RPf5jknGKgvx9dTn9a949C6O8kxYr2GyGE/pC1dBpIfxEM9HfaMP1VEEh/P1HfnvEa/f3koL8zBuivApD+fgI28hkh9IfU/LNA+vuZif7O+vSHSc5ZBvr7xeX0p3X/IoT+zlCsaL9RQugPWUvngPQXxUB/5wzTX2WB9Pcr9e15r9Hfrw76O2+A/ioD6e9XYCOfF0J/SM2/CaS/35jo74JPf5jkXGCgv99dTn9a9+9C6O88xYr2m0cI/SFr6SKQ/vIw0N9Fw/RXTSD9XaK+vew1+rvkoL/LBuivGpD+LgEb+bIQ+kNq/kMg/f3BRH+BSJ/+IMnRG4n2myPS3fSndesYwTliob/LFCvabz4h9IespbBIXA3lY6A/HZ9J+qspkP5yUt+GR3qM/rRwO/3pDSjr+J9o+qsJpL+cwEYOj+QpXDT9ITXnipRHf7kisQfJ0C3Cpz9MciIY6C/S5fSndUcKob9wihXtN1oI/SFrKQpIf9EM9BdlmP7qCKS/3NS3ebxGf7kd9JfHAP3VAdJfbmAj5xFCf0jNeQXSX14m+svn0x8mOfkY6C+/y+lP684vhP7yUKxovwWF0B+ylqKB9FeQgf6iDdNfjED6K0B9W9Br9FfAQX8FDdBfDJD+CgAbuaAQ+kNqLiSQ/gox0V9hn/4wySnMQH9FXE5/WncRIfRXkGJF+y0shP6QtVQUSH+FGeivqGH6ayCQ/q6ivi3mNfq7ykF/xQzQXwMg/V0FbORiQugPqbm4QPorzkR/JXz6wySnBAP9lXQ5/WndJYXQXzGKFe23qBD6Q9ZSKSD9FWWgv1KG6e9GgfR3NfVtaa/R39UO+ittgP5uBNLf1cBGLi2E/pCarxFIf9cw0V8Zn/4wySnDQH/Xupz+tO5rhdBfaYoVTpVC6A9ZS2WB9FeMgf7KGqa/FgLprxz1bXmv0V85B/2VN0B/LYD0Vw7YyOWF0B9ScwWB9FeBif4q+vSHSU5FBvqr5HL607orCaG/8hQr2m8JIfSHrKXKQPorwUB/lQ3TXyuB9FeF+raq1+ivioP+qhqgv1ZA+qsCbOSqQugPqbmaQPqrxkR/1X36wySnOgP91XA5/WndNYTQX1WKFe23lBD6Q9ZSTSD9lWKgv5qG6e8WgfRXi/q2ttfor5aD/moboL9bgPRXC9jItYXQH1JzHYH0V4eJ/oI+/WGSE2SgP8vl9Kd1W0LorzbFCn9FWQj9IWspBkh/pRnoL8Yw/d0qkP5iqW/jvEZ/sQ76izNAf7cC6S8W2MhxQugPqbmuQPqry0R/8T79YZITz0B/CS6nP607QQj9xVGsaL9lhNAfspYSgfRXhoH+Eg3T320C6a8e9W19r9FfPQf91TdAf7cB6a8esJHrC6E/pObrBNLfdUz0d71Pf5jkXM9Afw1cTn9adwMh9FefYkX7LSuE/pC11BBIf2UZ6K+hYfrr4m76C91i7HtxA/VtI6/RnxZ+yREM6n/ozWzEcJBpFOnugwzdrmiE/1VzWvpftxsi3b9/aMpFam5s82UlxsbEJMTqdYmpQSsuNSUmMSYmNTkumBJMSolJqxdn1UuPi4mLTUlNSVY+k6z0YHpSSr30xL/iMkW5jZkot4lPuZjkNGGg3KYup1ytu6kQym1EsaL9NgM3pm5C7dNJDqicnVYdNzEcvw83Rro7//FK840M+S9fiFd3MHs3a3IuHt0VCskAB2B+LCmaiwEfN5pHuvuxV9d2c4b6vonhuH6T7XQ6eh+qBnj6vHIhdx/Xn2A6rlcR0uvA/FhVXJ7rKkw1Xt3lj+FdmR7DawipcWB+rBouz3Vlphqv7fLens10HK8jpMaB+bHquLzG9XPxGw2dNwhm72aNyCUn1jGCYp1gMNbsHkO0P45jU4zL+3QK0zE5VsgxGZgfK9bluZ7KlOt4Q7l20fNcKx78yn1U4J8XafRzgctqTKexJ439acyj7GbKYxSZvule1r+fSuM0GgfT342gcQyNE2icTKOSFGhh8xtBfjvQ7zvS2InGO2m8i8a7acynrKXNzybyo33r38+muObQOJfGeTTOp/EZGmeQ32dD62m+iOYLab6E5stpvozmq2m+gubraP4czTfS/Hmab6H5CzTfTvMXab6L5i/RfC/NX6b5AZq/QvPDNH+V5kdp/hrNT9D8dZqfpvkbND9H8zdpfpHmb9E8LOKv8W2aR9H8HZpH0/xdmhel+Xs0L0Xz92leluYf0LwyzT+keU2af0TzGJp/TPNEmn9C84Y0/5TmzWj+Gc1b0vxzmrel+dc070Dzb2jemebf0jyZ5t/RvBvNv6d5b5r/QPMBNP+R5kNp/hPNR9L8Z5qPo/kvNJ9I819pPoXmv9F8Fs1/D9UzzS/RfDHN/6D5SprnoLyuoXlOmofTuJ7uj6B5JI2b6P7coeMDjVvp/nw0z0/jDrq/AM0L0rib7i9M8yI07qP7r6J5MRoP0v0laF6SxiN0/9U0L03jMbq/DM2vpfEk3V+O5uVpPEP3V6R5JRrP0/1VaF6Vxst0f3Wa1wjtHx13atG8dmif6P4gza3QftD9sTSPo7EujfE0JtCYSGM9GuvTeB2N14f2jfw2pPkNNDaisTGNTWhsSmOz0D7S3zen+U003hzaN/p9y9C+0Lx1SDfN24R00bxtKG6at6P57TS2p/EOGlvSus40v4fG6spa2Y77oQsMnqA6v5n+rhWNhXVskf++Ug3NPfN1bLarDUB+kVerWc477PtxCz2HauO1q9W08M02sW1sL9hwFQkajhMNXSKbxTiDjjitW4AvKLYBvqCYKOSJJHL/bv0vvhIT0pLTE+Jik4Jx6cnKT3x6WmxSTD0rPTFWuY+Ns5KT0oKpcckJ8XHxiekJQVNXr93KdPVaW//qNUxy2jJcvXaby69e07pvE3IGsg3FCn/vh0vfo+GME1lL7YAPQPXBZ3r0QUzH1zhg7j0a2XlATr/ylpJBuCzUezv1bfv/Qr1NMtgzJ/U2Cfzf1JuRH+PUa//nKJ96E29nOKjcznDpVHubz9AN/R6NNv/7QeZfxHw78IDVnqlB0afQkZrvEHDZ4R0MvcN9GXUwe7c/nwmfzInX3QGoWz8g6AN06JmB9h0b+Me49oXjDEFHl9eDrteODH3QCag7PHDlA3YAuwd/gy96bztFuj/GOxli/POGfnC6EfjgdJeAB6fWDE15vcuvYdDFeBeD7gbuPE37rzjvBtYlMNcWcv+YD+Z/n97z4sH8bmSMUh91YwXE2NlP1F/vZHV7jPeYwqNg9m4x9s3M7sNQF5/drS4CDvf3CinOWGRxdvWL0+oqoDiThBSn1RH4xDIZCPC6OCMD8opTAn+loPlLYqIk8FeqF/krDfwQJ7E40wQ8xKV7kb/u84vTuk9AcXaTwl+PhuOKs7vLT+xXUz4SGD68q5HLT+zrDyzj+JCfxkJO7PcA1iUw11Zjl9eN7pcOHB/6J6BfOnNcnSKkX+4H9gsw19aNAurmHoa66enyq1i07nsZdPcSoDuJQXdvl+vWjwscVy3dLKC/kxl0txDyuNAH+LgAzLXVQgBHpTDUTWuX6x4XzvNhybcI6Ze+wH4B5tq6RUC/pDL0Sz8Bj6vpDLr7C9DdjUH3AwJ0d2fQ3dbl/f0o0+PCbUIeFwYAHxeAubaQ+2fqvfE1cb6ueG/8QP+98ZjkDGR4b/wgl783XusexPTe+NDN+UJQdvcBuacPAg9wuhHCA/++uflAwhlnDSFxVgfHiX7h80dVWPHh2Ot5ejD0vP299NH082D1f4YoG6rsIWXDlA1XNkLZw8pGKhulbLSyR5SNUTZWWXH6e/vbOwO2++yfBRC6L/RJlWG2+0Iy7Q+GaN0MD7DB3IErP+MgpCekI1cG+xORwf5E2tbnt/0+4NiraPr7KKyONHteQjcnGDSy/Rxl0xKJjcXSvkuSr7Te/QamDUxrOzC5Z/eU5gN7pwzo3qd306SePe1FHGHbHH0Lz2Dj9C2n7Wf7GnuSctuEhe7LQz9H2u6zF29oDPm3r8+BPgrqR8JatuBBfoOmPt1kCNd1LJg4//6UE/tejKPMP+q1z/TTwg/bxOoNKOv4n+hP/RiSfWyMCX3qxzgggj7KVLhoDEFqHp+Br+RgSmpdKzk+NcFKS6qbmJJSL9ayYpLik+KTYxLT05LrWol1E5XPlKSYRPXvYpJSrLRgUnyaqefv48GfdhO6PeY/f8ck5zGG5+8TXP78XeuewPT8HX3S81GKFe23vUs/2y50C8WJrKXHgectkPsXekDX8ZULmPtsu6Hupr/QLca+FxOpb5/wGv1p4ZccwaD+h97MJxgOMk9EuvsgQ7crGuF/1ZxGHyI3MdL9+4emXKTmSTZfVmJsTExCrF6XmBq04lJTYhJjYlKT44IpwaSUmLR6cVa99LiYuNiU1JRk5TPJSg+mJ6XUS0/8Ky5TlDuJiXKf9CkXk5wnGSh3ssspV+ueLIRyn6BY0X6fAjembkLtMyxgjtIeEkhpU6jupnqN0qYwUprezKkMTTJVCKU9BKS0KZHu3z80pSE1TxNIadOYKG26T2mY5ExnoLQZLqc0rXuGEEqbSrGi/c5koLSZhiltmEBKm0V197TXKG0WI6XpzXyaoUmeFkJpw4CUNivS/fuHpjSk5tkCKW02E6XN8SkNk5w5DJQ21+WUpnXPFUJpT1OsaL/zGChtnmFKGynwerf5VHfPeI3S5juud3vGwPVuI4HXu80HHtSeEUIvSM0LBF7vtoCJXp716QWTnGcZ6GWhy+lF614ohF6eoVjRfjsIud4NWUuLgNe7dWC43m2R4evdRgk8R7eY+naJ1+hvMeM5Or2ZSxgOMkuEnKMbBTxHtzjS/fuHplyk5qUCz9EtZaLcZT7lYpKzjIFyl7uccrXu5UIodwnFiva7guEc3QrD5+hGC6S0lVR3z3mN0lYyUprezOcYmuQ5IZQ2GkhpKyPdv39oSkNqXiWQ0lYxUdrzPqVhkvM8A6Wtdjmlad2rhVDacxQr2u8LDJT2gmFKe0Qgpa2hunvRa5S2hpHS9Ga+yNAkLwqhtEeAlLYm0v37h6Y0pOa1AiltLROlveRTGiY5LzFQ2jqXU5rWvU4Ipb1IsaL9vsxAaS8bprQxAq93W09194rXKG2943q3Vwxc7zYGeL3beuBB7RUh9ILUvEHg9W4bmOjlVZ9eMMl5lYFeNrqcXrTujULo5RWKFe23k5Dr3ZC19BrwerdODNe7vUbXu3HUvP4U4gcZ6mhTJG//BLN3+/Nz/Tcx6L6rkLuPG/oz4jl0311IBngB82Pd7fJc12Cq8S5u/yIpphq/V0iNA/Nj3evyXIe+rwOd62SX6w59rwhad4qQL0t7HchswFxbKS6vm1eYjo3pLn8s1JpfZ9B9n5DHBGB+LCmaXwc+R9wMPN5kVN/B7N0sXd+bGer7DYZXM96wnaBG74P+fjGO41sPlx/fxjId1+8X0uvA/Fj3u/wxfAnlOoD1yxLrc4JifdFgrNntS+2Po997u7z2hzMd5/oIOc4B82P1cXmuRzDlur+hXLvoXLLVH/y6hP5+x9ALrfp82+XAX18FosepND5No/4qxS2Ux6jAP987OZx+P4LGh2l8hsYlND5H44s0vkKjkhR40+Y3dI4hNvDX752jvkJjaxbXv5XF9duyuP7tLK7fnsX172Rx/Y4srn83i+t3ZnH9e1lcvyuL69/P4vrdWVz/QRbX78ni+g9t68P+w3r9u72ZXPdRJtfty+S6jzO5bn8m132SyXUHMrnu00yuO5jJdZ9lct2hTK77PJPrDmdy3ReZXHckk+u+zMS6a5R9lcl1X2dy3dFMrvsmk+uOZXLdt5lcdzyT677L5LoTmVz3fSbXnczkuh8yue5UJtf9mMl1pzO57qcsHC/1+jNZXP9zFtefzeL6X7K4/lwW1/+axfXns7j+tyyuv5DF9b9ncf3FLK6/lMX1l7O4/o8srtcLs7I+h219Mq1/k/h4bGTGf+cct9K6t2jcRuPbNG6n8R0ad9D4Lo07aXyPxl00vk/jbho/oHEPjR/SuJfGj2jcR+PHNO6n8RMaD9D4KY0HafyMxkM0fk7jYRq/oPEIjV9mcn++onVf03iUxm9oPEbjtzQep/E7Gk/Q+D2NJ2n8gcZTNP5I42kaf6LxDI0/03iWxl9oPEfjrzSep/E3Gi/Q+DuNF2m8RONlGv+gURfTZaqtzOyP20d9HUxYBn01mPRuoTGM9BbWa6L+/W4L9Lkcfe3Co+HYawIGRP4TL8gv8h0clvMO+/6G04mBXFEeeweHFr7ZJlZvQCNHcKj/GSo6p9/snqwaIOCCmQGReN0D3XnBTNARpxUehdOcC+hrkMsvOKebBaxvC1gz1iAhL1wg6y/iv/hKTEhLTk+Ii00KxqUnKz/x6WmxSTH1rPTEWOU+Ns5KTkoLpsYlJ8THxSemJwRNvePJHnMwmzd7vJFR/jueIMmJjML7jQIWPZfuqCh4jlhe8c5FsaL9DnXpA5AzTmQt5cYdjKyh4FcW9UFMx9c4YO797rmysR/pV95SMgiX5dlSHurbvP/l2VKTDPbM+WypSeD/fraUkR/jz5bs/xzlU29iHoaDSp4ofFPktfkM3dCUmw2y/9czjjzAA1ZepgYNY8x7dn3li3J37+hLc/Ix9I7b3zqqz6CMYziDMkzAGZS+DGdQhgt5y1F+YD8Cc20NF1A3/RjqJjrK/br7M+guIED3Awy6CwJ1a2DOG/jnzInubV1Pem8L2p4Q6xv6OFIIeBxx6VlJlrrSXFCIgTcKA+sqnOrKeUPuK8feFo5yf4xFGGL884Z+EmAH2Oz6KirgSUBOhqYc6fKDkS7Gogy6RwmB4auAdQnMtYXcP+aD+d8vo3jxYH6VlIN5LaCvYsCm0Q0dHvj3DZ2omgGeRKHjrCEkzupC4gR+wErQ/lLCXvq5uOqFEspKKiul7GplpZVdo6yMsmuVlVVWTll5ZRWUVVRWSVllZVWUVVVWTVl1ZTWU1VRWS1ltZXWUBZVZymKUxSqLU1ZXWbyyBGWJyuopq6/sOmXXK2ugrKGyG3Sv6pehlDVR1lRZM2U3Kmuu7CZlNytroaylslbKWiu7RVkbZbcqa6vsNmXtlN2urL2yO5R1UNZRWSdldyq7S9ndyjoru0dZF2X3KuuqLElZsrIUZanK0pSlK7tPWTdl3ZX1UHa/sp7KeinrrayPsr7K+inrr+wBZQOUDVQ2SNmDygYrG6JsqLKHlA1TNlzZCGUPKxupbJSy0coeUTZG2Vhl45Q9qmy8sseUTVD2uLKJyp5QNknZk8omK3tK2RRlU5VNUzZd2QxlM5XNUva0stnK5iibq2yesvnKnlG2QNmzyhYqW6RssbIlypYqW6ZsubIVylYqe07ZKmXPK1ut7AVla5S9qGytspeUrVP2srL1yl5RtkHZq8o2KntN2SZlryvbrOwNZVuUvalsq7K3lG1T9ray7creUbZD2bvKdip7T9kuZe8r263sA2V7lH2obK+yj5TtU/axsv3KPlF2QNmnyg4q+0zZIWWfKzus7AtlR5R9qewrZV8rO6rsG2XHlH2r7Liy4tRP+uU45+OBvi+X4/ig74ugn8Ns94WuG7VfNxLAHlOCDNeiBHMHrnzJM6QnpCNXBvsTkcH+RNrW57f9PuDYq2j6+yiojtQYe15CN+dLqY1sP0fZtERCYwnqQ2agCPlKSerZs23/7oOSBqQ1H9g7ZUD3Pr3th/NQyKHDengGW6ZvOW0/29fY05PbJil0Xx76OdJ2n71sQ2PIv319DvRjov6g1GJR/wQP8hs0dZmDfrxFxZxBuNn1neHH+n9H+30iymMXhWvhh21i9QaUdfxP9Mv/9gLJ7sf6f5d9X38/cTrBVLhh4P1Dav4+A19u/1j/74F5ssd7Msq/yBWSHL2RaL8/AIueS/cPDI/aGcWKOND9EIX3O0bIx/oja+kU7mBkjWG4yFXHVy5g7iLXku6mv9Dtiq/e/JH69rTX6E8L5/rqTb2ZpxkOMqej3H2QodsVjZDdr978Mcr9+4emXKTmn2y+pHz15k9MlHvGp1xMcs4wUO7PLqdcrftnIZR7mmJF+z0LbkzdhNpnWMAcpZUSSGm/UN2d8xql/cJIaXozzzE0yTkhlFYKSGm/RLl//9CUhtT8q0BK+5WJ0s77lIZJznkGSvvN5ZSmdf8mhNLOUaxovxcYKO2CYUq7WiCl/U51d9FrlPY7I6XpzbzI0CQXhVDa1UBK+z3K/fuHpjSk5ksCKe0SE6Vd9ikNk5zLDJT2h8spTev+QwilXaRY0X71wzVK99+UkdsspV0r8Hq3HIRJYbk9RmlauP16N70BZR3/E00v1wKvd8uRG9d8Ybl5ChdNL0jNOTPw5fbr3XKCD5KhW3hun14gydEbifabC1j0XLpz5YbniIVewihWtN9xQq53Q9ZSBO5gZI1juN5Nx1cuYI7+ygo8RxdJfRvlNfrTwrnO0enNjGI4yETldvdBhm5XNEJ2z9FF5nb//qEpF6k5d2555+hyM1FuHp9yMcnJw0C5eV1OuVp3XiGUG0Wxov3mYzhHl8/wObpyAiktP9VdtNcoLT8jpenNjGZokmghlFYOSGn5c7t//9CUhtRcQCClFWCitII+pWGSU5CB0gq5nNK07kJCKC2aYkX7LcxAaYUNU1p5gZRWhOquqNcorQgjpenNLMrQJEWFUFp5IKUVye3+/UNTGlLzVQIp7SomSivmUxomOcUYKK24yylN6y4uhNKKUqxovyUYKK2EYUqrIPB6t5JUd6W8RmklHde7lTJwvVsF4PVuJYEHtVJC6AWp+WqB17tdzUQvpX16wSSnNAO9XONyetG6rxFCL6UoVrTf8UKud0PWUhng9W7jGa53K2P4erfqAunvWurbsl6jv2sd9FfWAP1VB9LftcBGLiuE/pCaywmkv3JM9Ffepz9Mcsoz0F8Fl9Of1l1BCP2VpVjRficIoT9kLVUE0t8EBvqraJj+agqkv0rUt5W9Rn+VHPRX2QD91QTSXyVgI1cWQn9IzVUE0l8VJvqr6tMfJjlVGeivmsvpT+uuJoT+KlOsaL8ThdAfspaqA+lvIgP9VTdMf7UF0l8N6tuaXqO/Gg76q2mA/moD6a8GsJFrCqE/pOZaAumvFhP91fbpD5Oc2gz0V8fl9Kd11xFCfzUpVrTfSULoD1lLQSD9TWKgv6Bh+gsKpD+L+jbGa/RnOegvxgD9BYH0ZwEbOUYI/SE1xwqkv1gm+ovz6Q+TnDgG+qvrcvrTuusKob8YihXtd7IQ+kPWUjyQ/iYz0F+8YfqLEUh/CdS3iV6jvwQH/SUaoL8YIP0lABs5UQj9ITXXE0h/9Zjor75Pf5jk1Gegv+tcTn9a93VC6C+RYkX7nSKE/pC1dD2Q/qYw0N/1hukvTiD9NaC+beg1+mvgoL+GBugvDkh/DYCN3FAI/SE13yCQ/m5gor9GPv2BksNAf41dTn9ad2Mh9NeQYkX7nSaE/pC11ARIf9MY6K+JYfqLF0h/Talvm3mN/po66K+ZAfqLB9JfU2AjNxNCf0jNNwqkvxuZ6K+5T3+Y5DRnoL+bXE5/WvdNQuivGcWK9jtDCP0ha+lmIP3NYKC/mw3TX6JA+mtBfdvSa/TXwkF/LQ3QXyKQ/loAG7mlEPpDam4lkP5aMdFfa5/+MMlpzUB/t7ic/rTuW4TQX0uKFe13lhD6Q9ZSGyD9zWKgvzaG6a++QPq7lfq2rdfo71YH/bU1QH/1gfR3K7CR2wqhP6Tm2wTS321M9NfOpz9Mctox0N/tLqc/rft2IfTXlmJF+50thP6QtdQeSH+zGeivvWH6u14g/d1BfdvBa/R3h4P+Ohigv+uB9HcHsJE7CKE/pOaOAumvIxP9dfLpD5OcTgz0d6fL6U/rvlMI/XWgWNF+5wqhP2Qt3QWkv7kM9HeXYfprKJD+7qa+7ew1+rvbQX+dDdBfQyD93Q1s5M5C6A+p+R6B9HcPE/118ekPk5wuDPR3r8vpT+u+Vwj9daZY0X7nC6E/ZC11BdLffAb662qY/hoJpL8k6ttkr9FfkoP+kg3QXyMg/SUBGzlZCP0hNacIpL8UJvpL9ekPk5xUBvpLczn9ad1pQugvmWJF+10ghP6QtZQOpL8FDPSXbpj+mgikv/uob7t5jf7uc9BfNwP01wRIf/cBG7mbEPpDau4ukP66M9FfD5/+MMnpwUB/97uc/rTu+4XQXzeKFe13oRD6Q9ZSTyD9LWSgv56G6a+ZQPrrRX3b22v018tBf70N0F8zIP31AjZybyH0h9TcRyD99WGiv74+/WGS05eB/vq5nP607n5C6K83xYr2u1gI/SFrqT+Q/hYz0F9/w/TXXCD9PUB9O8Br9PeAg/4GGKC/5kD6ewDYyAOE0B9S80CB9DeQif4G+fSHSc4gBvp70OX0p3U/KIT+BlCsaL9LhdAfspYGA+lvKQP9DTZMfzcLpL8h1LdDvUZ/Qxz0N9QA/d0MpL8hwEYeKoT+kJofEkh/DzHR3zCf/jDJGcZAf8NdTn9a93Ah9DeUYkX7XS6E/pC1NAJIf8sZ6G+EYfprKZD+Hqa+Hek1+nvYQX8jDdBfSyD9PQxs5JFC6A+peZRA+hvFRH+jffrDJGc0A/094nL607ofEUJ/IylWtN+VQugPWUtjgPS3koH+xhimv9YC6W8s9e04r9HfWAf9jTNAf62B9DcW2MjjhNAfUvOjAunvUSb6G+/THyY54xno7zGX05/W/ZgQ+htHsaL9rhJCf8hamgCkv1UM9DfBMP21EUh/j1PfTvQa/T3uoL+JBuivDZD+Hgc28kQh9IfU/IRA+nuCif4m+fSHSc4kBvp70uX0p3U/KYT+JlKsaL+rhdAfspYmA+lvNQP9TTZMf20F0t9T1LdTvEZ/Tznob4oB+msLpL+ngI08RQj9ITVPFUh/U5nob5pPf5jkTGOgv+kupz+te7oQ+ptCsaL9rhFCf8hamgGkvzUM9DfDMP21E0h/M6lvZ3mN/mY66G+WAfprB6S/mcBGniWE/pCanxZIf08z0d9sn/4wyZnNQH9zXE5/WvccIfQ3i2JF+10rhP6QtTQXSH9rGehvrmH6ay+Q/uZR3873Gv3Nc9DffAP01x5If/OAjTxfCP0hNT8jkP6eYaK/BT79YZKzgIH+nnU5/Wndzwqhv/kUK9rvOiH0h6ylhUD6W8dAfwsN018HgfS3iPp2sdfob5GD/hYboL8OQPpbBGzkxULoD6l5iUD6W8JEf0t9+sMkZykD/S1zOf1p3cuE0N9iihXtd70Q+kPW0nIg/a1noL/lhumvk0D6W0F9u9Jr9LfCQX8rDdBfJyD9rQA28koh9IfU/JxA+nuOif5W+fSHSc4qBvp73uX0p3U/L4T+VlKsaL8bhNAfspZWA+lvAwP9rTZMf3cJpL8XqG/XeI3+XnDQ3xoD9HcXkP5eADbyGiH0h9T8okD6e5GJ/tb69IdJzloG+nvJ5fSndb8khP7WUKxovxuF0B+yltYB6W8jA/2tM0x/nQXS38vUt+u9Rn8vO+hvvQH66wykv5eBjbxeCP0hNb8ikP5eYaK/DT79YZKzgYH+XnU5/Wndrwqhv/UUK9rvJiH0h6yljUD628RAfxsN018XgfT3GvXtJq/R32sO+ttkgP66AOnvNWAjbxJCf0jNrwukv9eZ6G+zT3+Y5GxmoL83XE5/WvcbQuhvE8WK9rtZCP0ha2kLkP42M9DfFsP011Ug/b1JfbvVa/T3poP+thqgv65A+nsT2MhbhdAfUvNbAunvLSb62+bTHyY52xjo722X05/W/bYQ+ttKsaL9bhFCf8ha2g6kvy0M9LfdMP0lC6S/d6hvd3iN/t5x0N8OA/SXDKS/d4CNvEMI/SE1vyuQ/t5lor+dPv1hkrOTgf7eczn9ad3vCaG/HRQrnCqF0B+ylnYB6W8rA/3tMkx/qQLp733q291eo7/3HfS32wD9pQLp731gI+8WQn9IzR8IpL8PmOhvj09/mOTsYaC/D11Of1r3h0LobzfFiva7TQj9IWtpL5D+tjHQ317D9JcukP4+or7d5zX6+8hBf/sM0F86kP4+AjbyPiH0h9T8sUD6+5iJ/vb79IdJzn4G+vvE5fSndX8ihP72Uaxov9uF0B+ylg4A6W87A/0dMEx/3QTS36fUtwe9Rn+fOujvoAH66wakv0+BjXxQCP0hNX8mkP4+Y6K/Qz79YZJziIH+Pnc5/Wndnwuhv4MUK/wVZSH0h6ylw0D628FAf4cN019vgfT3BfXtEa/R3xcO+jtigP56A+nvC2AjHxFCf0jNXwqkvy+Z6O8rn/4wyfmKgf6+djn9ad1fC6G/IxQr2u9OIfSHrKWjQPrbyUB/Rw3TX1+B9PcN9e0xr9HfNw76O2aA/voC6e8bYCMfE0J/SM3fCqS/b5no77hPf5jkHGegv+9cTn9a93dC6O8YxYr2u0sI/SFr6QSQ/nYx0N8Jw/TXXyD9fU99e9Jr9Pe9g/5OGqC//kD6+x7YyCeF0B9S8w8C6e8HJvo75dMfJjmnGOjvR5fTn9b9oxD6O0mxov3uFkJ/yFo6DaS/3Qz0d9ow/Q0QSH8/Ud+e8Rr9/eSgvzMG6G8AkP5+AjbyGSH0h9T8s0D6+5mJ/s769IdJzlkG+vvF5fSndf8ihP7OUKxov3uE0B+yls4B6W8PA/2dM0x/gwTS36/Ut+e9Rn+/OujvvAH6GwSkv1+BjXxeCP0hNf8mkP5+Y6K/Cz79YZJzgYH+fnc5/Wndvwuhv/MUK9rvXiH0h6yli0D628tAfxcN099ggfR3ifr2stfo75KD/i4boL/BQPq7BGzky0LoD6n5D4H09wcT/QXy+PQHSY7eSLTfHHncTX9at44RnCMW+rtMsaL97hNCf8haCsuDq6F9DPSn4zNJf0MF0l9O6tvwPB6jPy3cTn96A8o6/iea/oYC6S8nsJHD8/AULpr+kJpz5ZFHf7nyYA+SoVuET3+Y5EQw0F+ky+lP644UQn/hFCva734h9IespSgg/e1noL8ow/Q3TCD95aa+zeM1+svtoL88BuhvGJD+cgMbOY8Q+kNqziuQ/vIy0V8+n/4wycnHQH/5XU5/Wnd+IfSXh2JF+z0ghP6QtRQNpL8DDPQXbZj+RgikvwLUtwW9Rn8FHPRX0AD9jQDSXwFgIxcUQn9IzYUE0l8hJvor7NMfJjmFGeiviMvpT+suIoT+ClKsaL8HhdAfspaKAunvIAP9FTVMfyMF0t9V1LfFvEZ/Vznor5gB+hsJpL+rgI1cTAj9ITUXF0h/xZnor4RPf5jklGCgv5Iupz+tu6QQ+itGsaL9HhJCf8haKgWkv0MM9FfKMP2NFkh/V1PflvYa/V3toL/SBuhvNJD+rgY2cmkh9IfUfI1A+ruGif7K+PSHSU4ZBvq71uX0p3VfK4T+SlOsaL+HhdAfspbKAunvMAP9lTVMf2ME0l856tvyXqO/cg76K2+A/sYA6a8csJHLC6E/pOYKAumvAhP9VfTpD5Ocigz0V8nl9Kd1VxJCf+UpVrTfI0LoD1lLlYH0d4SB/iobpr9xAumvCvVtVa/RXxUH/VU1QH/jgPRXBdjIVYXQH1JzNYH0V42J/qr79IdJTnUG+qvhcvrTumsIob+qFCva71dC6A9ZSzWB9PcVA/3VNEx/4wXSXy3q29peo79aDvqrbYD+xgPprxawkWsLoT+k5joC6a8OE/0FffrDJCfIQH+Wy+lP67aE0F9tihXt96gQ+kPWUgyQ/o4y0F+MYfqbIJD+Yqlv47xGf7EO+oszQH8TgPQXC2zkOCH0h9RcVyD91WWiv3if/jDJiWegvwSX05/WnSCE/uIoVrTfY0LoD1lLiUD6O8ZAf4mG6W+iQPqrR31b32v0V89Bf/UN0N9EIP3VAzZyfSH0h9R8nUD6u46J/q736Q+TnOsZ6K+By+lP624ghP7qU6xov8eF0B+ylhoC6e84A/01NEx/Twqkvxuobxt5jf5ucNBfIwP09ySQ/m4ANnIjIfSH1NxYIP01ZqK/Jj79YZLThIH+mrqc/rTupkLorxHFivZ7Qgj9IWupGZD+TjDQXzPD9DdFIP3dSH3b3Gv0d6OD/poboL8pQPq7EdjIzYXQH1LzTQLp7yYm+rvZpz9Mcm5moL8WLqc/rbuFEPprTrGi/Z4UQn/IWmoJpL+TDPTX0jD9TRdIf62ob1t7jf5aOeivtQH6mw6kv1bARm4thP6Qmm8RSH+3MNFfG5/+MMlpw0B/t7qc/rTuW4XQX2uKFe33lBD6Q9ZSWyD9nWKgv7aG6W+WQPq7jfq2ndfo7zYH/bUzQH+zgPR3G7CR2wmhP6Tm2wXS3+1M9Nfepz9Mctoz0N8dLqc/rfsOIfTXjmJF+z0thP6QtdQBSH+nGeivg2H6myOQ/jpS33byGv11dNBfJwP0NwdIfx2BjdxJCP0hNd8pkP7uZKK/u3z6wyTnLgb6u9vl9Kd13y2E/jpRrGi/Z4TQH7KWOgPp7wwD/XU2TH/zBdLfPdS3XbxGf/c46K+LAfqbD6S/e4CN3EUI/SE13yuQ/u5lor+uPv1hktOVgf6SXE5/WneSEPrrQrGi/Z4VQn/IWkoG0t9ZBvpLNkx/zwqkvxTq21Sv0V+Kg/5SDdDfs0D6SwE2cqoQ+kNqThNIf2lM9Jfu0x8mOekM9Hefy+lP675PCP2lUqxov+eE0B+ylroB6e8cA/11M0x/iwXSX3fq2x5eo7/uDvrrYYD+FgPprzuwkXsIoT+k5vsF0t/9TPTX06c/THJ6MtBfL5fTn9bdSwj99aBY0X7PC6E/ZC31BtLfeQb6622Y/pYJpL8+1Ld9vUZ/fRz019cA/S0D0l8fYCP3FUJ/SM39BNJfPyb66+/THyY5/Rno7wGX05/W/YAQ+utLsaL9XhBCf8haGgCkvwsM9DfAMP2tFEh/A6lvB3mN/gY66G+QAfpbCaS/gcBGHiSE/pCaHxRIfw8y0d9gn/4wyRnMQH9DXE5/WvcQIfQ3iGJF+70ohP6QtTQUSH8XGehvqGH6e14g/T1EfTvMa/T3kIP+hhmgv+eB9PcQsJGHCaE/pObhAulvOBP9jfDpD5OcEQz097DL6U/rflgI/Q2jWNF+LwuhP2QtjQTS32UG+htpmP7WCKS/UdS3o71Gf6Mc9DfaAP2tAdLfKGAjjxZCf0jNjwikv0eY6G+MT3+Y5IxhoL+xLqc/rXusEPobTbGi/QYKy6A/ZC2NA9Ifcv9CD+jjDNPfSwLp71Hq2/Feo79HHfQ33gD9vQSkv0eBjTxeCP0hNT8mkP4eY6K/CT79YZIzgYH+Hnc5/Wndjwuhv/EUK9pvmBD6Q9bSRCD9hTHQ30TD9LdeIP09QX07yWv094SD/iYZoL/1QPp7AtjIk4TQH1LzkwLp70km+pvs0x8mOZMZ6O8pl9Of1v2UEPqbRLGi/YYLoT9kLU0B0l84A/1NMUx/rwqkv6nUt9O8Rn9THfQ3zQD9vQqkv6nARp4mhP6QmqcLpL/pTPQ3w6c/THJmMNDfTJfTn9Y9Uwj9TaNY0X4jhNAfspZmAekvgoH+Zhmmv00C6e9p6tvZXqO/px30N9sA/W0C0t/TwEaeLYT+kJrnCKS/OUz0N9enP0xy5jLQ3zyX05/WPU8I/c2mWNF+o4TQH7KW5gPpL4qB/uYbpr93BNLfM9S3C7xGf8846G+BAfp7B0h/zwAbeYEQ+kNqflYg/T3LRH8LffrDJGchA/0tcjn9ad2LhNDfAooV7TePEPpD1tJiIP3lYaC/xYbp7wOB9LeE+nap1+hviYP+lhqgvw+A9LcE2MhLhdAfUvMygfS3jIn+lvv0h0nOcgb6W+Fy+tO6Vwihv6UUK9pvPiH0h6yllUD6y8dAfysN099HAunvOerbVV6jv+cc9LfKAP19BKS/54CNvEoI/SE1Py+Q/p5nor/VPv1hkrOagf5ecDn9ad0vCKG/VRQr2m+0EPpD1tIaIP1FM9DfGsP097FA+nuR+nat1+jvRQf9rTVAfx8D6e9FYCOvFUJ/SM0vCaS/l5job51Pf5jkrGOgv5ddTn9a98tC6G8txYr2W1AI/SFraT2Q/goy0N96w/T3iUD6e4X6doPX6O8VB/1tMEB/nwDp7xVgI28QQn9Iza8KpL9Xmehvo09/mORsZKC/11xOf1r3a0LobwPFivZbWAj9IWtpE5D+CjPQ3ybD9PepQPp7nfp2s9fo73UH/W02QH+fAunvdWAjbxZCf0jNbwikvzeY6G+LT3+Y5GxhoL83XU5/WvebQuhvM8WK9ltUCP0ha2krkP6KMtDfVsP095lA+nuL+nab1+jvLQf9bTNAf58B6e8tYCNvE0J/SM1vC6S/t5nob7tPf5jkbGegv3dcTn9a9ztC6G8bxYr2W0wI/SFraQeQ/oox0N8Ow/R33N30F7rF2PfiXerbnV6jPy38kiMY1P/Qm7mT4SCzM4+7DzJ0u6IR/lfNael/3d7N4/79Q1MuUvN7Nl9WYmxMTEKsXpeYGrTiUlNiEmNiUpPjginBpJSYtHpxVr30uJi42JTUlGTlM8lKD6YnpdRLT/wrLlOU+x4T5e7yKReTnF0MlPu+yylX635fCOXupFjRfneDG1M3ofbpJAdUzh6MDASKReH34YM87s7/60r3Bwz5L1GYV3cwezerVG4e3SULywAHYH4sKZoXAB839uRx92Ovru09DPX9IcNx/UPb6XT0PtQM8PR56cLuPq4Xj+LRfY2QXgfmx7rG5bmuwVTjZV3+GH6CqcbLCalxYH6sci7PdXWmGq/o8t6uyFTjlYTUODA/ViWX17h+Lv6BofMGwezdrKjccmKNFhRrUYOxZvcYov1xHJuqurxPSzMdk6sJOSYD82NVc3mur2HKdU1DuXbR81yrJviVe5Wav1+k0c8FLqvxNI3naLxIoz6k7qU8RpHpW2n6/TU0lqExLPdfYxSN0TQWpbEUjYWUfWTzG0F+j5CfL2n8isavaTxK4zc05lO2z+ZnE/nRvvXvK9K6SjRWprEKjVVprEZjWYqvRmg9zWvRvCbN69A8huYWzRNpHkvzhjSvS/NmNE+geUua16N5W5pfR/MONG9A8840v4HmyTRvTPNuNG9K8940v5HmA2h+E82H0rwFzUfSvBXNx9H8FppPpPmtNJ9C89toPovmt9N8Ps3voPlimnek+Uqa30nzNTS/m+braX4PzTfR/F6ab6V5Es130DyF5rtpnkbzfTS/j+YHad6L5kdo3ofmx2jej+Ynaf4Azc/QfCDNz9P8QZpfpvkQmodTXT4U6i+aD6d5QZo/TPNiNB9F89I0f4Tm5Wk+NlTPNH+U5rVp/hjN42j+OM3r0/wJmk+isRHdP5nmT9HYnO6fSvNpNLam+2fQfCaN7ej+p2k+m8ZOdP9cms+jsQvd/wzNF9CYSvcvpPkiGnvQ/UtovpTGvnT/cpqvoHEQ3f8czVfROIzuX03zF2gcTfe/SPO1NI6n+9fR/OXQ/tH9r9B8Q2if6P6NNH8ttB90/+s030zjGzRuofHNUL3T+BaN22h8m8btoX0jvzto/i6NO2l8j8ZdNL4f6pfQPtLf76H5hzTuDe0b/X5faF9ovj+km+YHQrpofjAUN80P0fxzGg/T+EWoX2ndMZp/S2N1ZR/bjvuhCwyKh+Kkv/uYxsI6tjz/vlINzXg/qn/QMRLn77Ty1yfyn3hBfpFXv1nOO+z7+wk9JzvgtavftPDNNrEHbC8AoWE7VHRo2K7t8icZoeZA665j6FLjLMYZdMRpfQJ8YfYA0FfQ5Zdq080C1rcFrBkrKOSEBrL+Pv0vvhIT0pLTE+Jik4Jx6cnKT3x6WmxSTD0rPTFWuY+Ns5KT0oKpcckJ8XHxiekJQVNXUX7KdBXlQf8qSkxyDjJcRfmZy6+i1Lo/E3Im/ADFivYb59IHIGecyFo6BLyyKo7hvUI6vsYBc+8VOpCN/Ui/8paSQbgsz5Y+p749/F+eLTXJYM+cz5aaBP7vZ0sZ+TH+bMn+z1E+9SZ+znBQ+ZzhEr7DNp+hG5pys0H2/3rG8TnwgHWYqUHRL+UgNX8h4PLXLxh6h/ty/mD2bn+eQenAcCYhXsAZlPsZdCe48wzKv+I8AuxHYK6tBAF105Ohbr50+XFC6+7FoPsrAbp7M+j+GqhbA3P+wD9nTnRv63rSe/u17QmxvqGPI0eBxxGXnpVkqSvNBUcZeOMbYF2FU105b8h95djbb/K4P8ZjDDH+eUM/CfgA+CTgWwFPAvYzNGV9lx+MdDF+y6D7OiEwfBxYl8BcW8j9Yz6Y//0yihcP5seRMUp91I0VEON3fqL++uQKt8d4whQeBbN3i7FvZnYfhr732d36XsDh/qSQ4oxFFucPfnFaPwgozlNCitM6Cnxi+SMQ4HVx5g3IK04J/HUazV8SEyWBv37yIn+dAT/ESSzOMwIe4n72In+d9YvTOiugOH+Rwl+FonDFec7lJ/ZrKR+bGV7FbejyE/v6A0o5PtTvBiEn9n8F1iUw19YNLq8b3S9HGOqmiYB++Y5Bd1Mh/XIe2C/AXFtNBfTLlwx101xAv5xg0H2TkH75DdgvwFxbNwnol68Y6qalgH45yaC7lZB+uQDsF2CurVYC+uVrhrppI6BfTjHovlVIv/wO7Bdgrq1bBfQLx9W17QT0y48Mum8X0i8Xgf0CzLV1u4B+Oc1QNx1crjt/FM+X+HQU0i+XgP0CzLXVUUC//MTQL3e5XHc0U7/cLaRfLgP7BZhr624B/fIzQ790cbnuAkz9cq+QfvkD2C/AXFv3CuiXXxj6Jdnlugsy9UuKkH7RV2Wg9hKYaytFQL+cY+iXdJfrLsTUL/cJ6ZccwH4B5tpC7p+pz3QM4nxd8ZmOYXn9z3SEJEdvJNpvzrzABy8m3TnzwnPE+g0oyD0NBx7gdCOEB/59c/OBhDPOOkLirA2OMwwc36DIQOB14Cf/66umf2X4HFf7Z0BG08+5VH9FKItUFqUst7I8yvIqy6csv7JoZQWUFVRWSFlhZcXp7/XnRjp7St9n/wzL0H2hb/oJs90X+oID+4MhWjfDA2wwd+DKz+YM6QnpyJXB/kRksD+RtvX5bb8POPYqmv4+CqsjzZ6X0M0JBo1sP0fZtERiY9FfpBQoSb7SevcbmDYwre3A5J7dU5oP7J0yoHuf3k2Teva0F3GEbXP0LTyDjdO3nLaf7WvsScptExa6L9SDkbb77MUbGkP+7etzoI+C+pHQznUgv0FTn8obkZfn0Qa0H39/Oq99L4oQeRXN67HvMNHCD9vE6g0o6/if6E+rjcg+NsaEPq22CBBBizIVLhpDkJqvysBXcjAlta6VHJ+aYKUl1U1MSakXa1kxSfFJ8ckxielpyXWtxLqJymdKUkyi+ncxSSlWWjApPs3U8/er8uJRSd+K+c/fMckpxvD8vbjLn79r3cWZnr+jT3oWpVjRfnu4/EuBQnEia6kE8LwFcv9CD+g6vnIBc9/JEOlu+gvdYux7UZL6tpTX6E8Lv+QIBvU/9GaWYjjIlMrr7oMM3a5ohP9Vcxp9+UHJvO7fPzTlIjVfbfNlJcbGxCTE6nWJqUErLjUlJjEmJjU5LpgSTEqJSasXZ9VLj4uJi01JTUlWPpOs9GB6Ukq99MS/4jJFuVczUW5pn3IxySnNQLnXuJxyte5rhFBuKYoV7bcMuDF1E2qfYQFzlBYlkNKupbor6zVKu5aR0vRmlmVokrJCKC0KSGnX5nX//qEpDam5nEBKK8dEaeV9SsMkpzwDpVVwOaVp3RWEUFpZihXttyIDpVU0TGm5BVJaJaq7yl6jtEqMlKY3szJDk1QWQmm5gZRWKa/79w9NaUjNVQRSWhUmSqvqUxomOVUZKK2ayylN664mhNIqU6xov9UZKK26YUrLL/B6txpUdzW9Rmk1HNe71TRwvVt+4PVuNYAHtZpC6AWpuZbA691qMdFLbZ9eMMmpzUAvdVxOL1p3HSH0UpNiRfvtKeR6N2QtBYHXu/VkuN4taPh6t2iB5+gs6tsYr9GfxXiOTm9mDMNBJkbIObpo4Dk6K6/79w9NuUjNsQLP0cUyUW6cT7mY5MQxUG5dl1Ou1l1XCOXGUKxov/EM5+jiDZ+jKyCQ0hKo7hK9RmkJjJSmNzORoUkShVBaASClJeR1//6hKQ2puZ5ASqvHRGn1fUrDJKc+A6Vd53JK07qvE0JpiRQr2u/1DJR2vWFKKyiQ0hpQ3TX0GqU1YKQ0vZkNGZqkoRBKKwiktAZ53b9/aEpDar5BIKXdwERpjXxKAyWHgdIau5zStO7GQiitIcWK9tuEgdKaGKa0QgKvd2tKddfMa5TW1HG9WzMD17sVAl7v1hR4UGsmhF6Qmm8UeL3bjUz00tynF0xymjPQy00upxet+yYh9NKMYkX77S3kejdkLd0MvN6tN8P1bjfT9W4cNa8PIOEMddQiL2//BLN3+/Nz/Vsw6O5b2N3HDf0Z8Ry6+xWWAV7A/Fj9XJ7rOkw1PsDlXyRVlKnGBwqpcWB+rIEuz3Xo+zrQuR7sct2h7xVB6x4i5MvSWgKZDZhra4jL66YZ07FxmMsfC7Xmlgy6hwt5TADmx5KiuSXwOWIr4PEmo/oOZu9m6fpuxVDfrRlezWhtO0GN3gf9/WIcx7eRLj++FWY6ro8S0uvA/FijXP4YHkO5DmD9ssSaKCjWhgZjzfaXBQd4+n2My2s/D9NxbqyQ4xwwP9ZYl+c6L1OuxxvKtYvOJVvjwa9L6O93DL3Qqs+3XQ789VUgeixLY2Ua9Vcp3kJ5jAr8872Teej3eWnMR2NNGmNoTKSxIY3NaCykrI3Nb+gcQ2zgr987R32Fxq1ZXN82i+tvy+L6dllcf3sW17fP4vo7sri+QxbXd8zi+k5ZXH9nFtfflcX1d2dxfecsrr8ni+u72NaH/Yf1+nf3ZnJd10yuS8rkuuRMrkvJ5LrUTK5Ly+S69Eyuuy+T67plcl33TK7rkcl192dyXc9MruuVyXW9M7HuGmV9MrmubybX9cvkuv6ZXPdAJtcNyOS6gZlcNyiT6x7M5LrBmVw3JJPrhmZy3UOZXDcsk+uGZ3LdiCwcL/X6h7O4fmQW14/K4vrRWVz/SBbXj8ni+rFZXD8ui+sfzeL68Vlc/1gW10/I4vrHs7h+YhbXP5HF9ZNs65NpfRvi48J5M/4753grrWtL4200tqPxdhrb03gHjR1o7EhjJxrvpPEuGu+msTON99DYhcZ7aexKYxKNyTSm0JhKYxqN6TTeR2M3GrvT2IPG+2nsSWMvGntncn/60Lq+NPajsT+ND9A4gMaBNA6i8UEaB9M4hMahND5E4zAah9M4gsaHaRxJ4ygaR9P4CI1jaBxL4zgaH6VxPI2P0TiBxsdpnEjjEzROyuT+uH2soezJDPoqF+m7hcYnQ32jbHLef7/bAn0uR1+7UCgKe01Ajrz/xAvyi3wHh+W8w76/T1HsU/J67B0cWvhmm1i9AY0cwaH+Z6jonH6ze7JqgoALZnLkxet+3J0XzAQdcVpP5cVpngL0NdHlF5zTzQLWtwWsGWuikBcukPU39b/4SkxIS05PiItNCsalJys/8elpsUkx9az0xFjlPjbOSk5KC6bGJSfEx8UnpicETb3jyR5zMJs3e7zT8vrveIIkZ1pevN/pwKLn0j2diRjRD7RTKFa038kufQByxomspRm4g5E1GfzKoj6I6fgaB8y9331KNvYj/cpbSgbhsjxbmkl9O+u/PFtqksGeOZ8tNQn838+WMvJj/NmS/Z+jfOpNnMlwUJmZF98Us2w+Qzc05WaD7P/1jGMm8IA1i6lBwxjznl1fT+d1d+/oS3OeZugdt791VJ9Byc9wBmWKgDMolxjecjRVyFuOZgP7EZhra6qAt+hFM/TLDAH9cpmhX2YK6Zc5wH4B5tqaKaBfCjD0y2wB/fIHQ7/MEdIvc4H9Asy1NUdAvxRk6Jf5AvolwMDfzwjpl3nAfgHm2kLunz6xUyDwzxl+zaD6cVUfK+blDQQ493c+cH9d+uoZS1/q56/zOfoS+Lw4nOrKeUPuK8fePpPX/TEuYIjxzxv6ZFUL4MmqZwWcrJrM0JQLXX4w0sX4LIPuRUIgYSGwLoG5tpD7x3ww//vlfi8ezBdKOZhbQF+LgE2jGzo88O8bOlHBAE+i0HHWERJnbSFxAj8ILGh/yXsv/bxY+V+ibKmyZcqWK1uhbKWy55StUva8stXKXlC2RtmLytYqe0nZOmUvK1uv7BVlG5S9qmyjsteUbVL2ur7+V9kbyrYoe1PZVmVvKdum7G1l25W9o2yHsneV7VT2nrJdyt5XtlvZB8r2KPtQ2V5lHynbp+xjZfuVfaLsgLJPlR1U9pmyQ8o+V3ZY2RfKjij7UtlXyr5WdlTZN8qOKftW2XFl3yk7oex7ZSeV/aDslLIflZ1W9pOyM8p+VnZW2S/Kzin7Vdl5Zb8pu6Dsd2UXlV1SdlnZH/oZbT61/8rClOVUFq4sl7IIZZHKopTlVpZHWV5l+ZTlVxatrICygsoKKSusrIiyosquUlZMWXFlJZSVVFZK2dXKSiu7RlkZZdcqK6usnLLyyiooq6iskrLKyqooq6qsmrLqymooq6mslrLayuooCyqzlMUoi1UWp6yusnhlCcoSldVTVl/ZdcquV9ZAWUNlNyhrpKyxsibKmiprpuxGZc2V3aTsZmUtlLVU1kpZa2W3KGuj7FZlbZXdpqydstuVtVd2h7IOyjoq66TsTmV3KbtbWWdl9yjrouxeZV2VJSlLVpaiLFVZmrJ0Zfcp66asu7Ieyu5X1lNZL2W9lfVR1ldZP2X9lT2gbICygXrvqZ/0ZSPOxwN9Xy7H8UHfF0E/h9nui6Sf7dc3BrDHlCDDNZPB3IErL80J6fn7zSgZ7E9EBvsTaVuf3/b7gGOvounvo6A6UmPseQndnJf8NLL9HGXTEgmNJWhp30XIV0pSz55t+3cflDQgrfnA3ikDuvfpbT+ch0IOHdbDM9gyfctp+9m+xp6e3DZJofvy0M+RtvvsZRsaQ/7t63OgHxP1B3ovsp0dBPkNmrocbwkXdGPizPDrZwbl+2t8MJ/H3rykhR+2idUbUNbxP9GXqS3J/pmrv79+RsefTV9/P3F6MB9P4YaB9w+peXAGvtz+9TODgXmyxzskn/9mDEhy9Eai/Q4FFj2X7qH54DlieTPGgxQr2u9SIV8/g6ylh3AHI2spw5sxdHzlAubejLHU3fQXul3xFdHDqG+He43+tHCur4jWmzmc4SAzPJ+7DzJ0u6IRsvsV0cPyuX//0JSL1DzC5kvKV0SPYKLch33KxSTnYQbKHelyytW6Rwqh3OEUK9rvKHBj6ibUPsMC5ihtmUBKG01194jXKG00I6XpzXyEoUkeEUJpy4CUNjqf+/cPTWlIzWMEUtoYJkob61MaJjljGShtnMspTeseJ4TSHqFY0X4fZaC0Rw1T2nKBlDae6u4xr1HaeEZK05v5GEOTPCaE0pYDKW18PvfvH5rSkJonCKS0CUyU9rhPaZjkPM5AaRNdTmla90QhlPYYxYr2+wQDpT1hmNJWCbzebRLV3ZNeo7RJjuvdnjRwvdsq4PVuk4AHtSeF0AtS82SB17tNZqKXp3x6wSTnKQZ6meJyetG6pwihlycpVrTf5UKud0PW0lTg9W7LGa53m2r4erfnBZ6jm0Z9O91r9DeN8Ryd3szpDAeZ6ULO0T0PPEc3LZ/79w9NuUjNMwSeo5vBRLkzfcrFJGcmA+XOcjnlat2zhFDudIoV7fdphnN0Txs+R7daIKXNprqb4zVKm81IaXoz5zA0yRwhlLYaSGmz87l//9CUhtQ8VyClzWWitHk+pWGSM4+B0ua7nNK07vlCKG0OxYr2+wwDpT1jmNJeEEhpC6junvUapS1gpDS9mc8yNMmzQijtBSClLcjn/v1DUxpS80KBlLaQidIW+ZSGSc4iBkpb7HJK07oXC6G0ZylWtN8lDJS2xDClrRF4vdtSqrtlXqO0pY7r3ZYZuN5tDfB6t6XAg9oyIfSC1Lxc4PVuy5noZYVPL5jkrGCgl5Uupxete6UQellGsaL9rhRyvRuylp4DXu+2kuF6t+cMX+/2ikD6W0V9+7zX6G+Vg/6eN0B/rwDpbxWwkZ8XQn9IzasF0t9qJvp7wac/THJeYKC/NS6nP617jRD6e55iRftdJYT+kLX0IpD+VjHQ34uG6e9VgfS3lvr2Ja/R31oH/b1kgP5eBdLfWmAjvySE/pCa1wmkv3VM9PeyT3+Y5LzMQH/rXU5/Wvd6IfT3EsWK9rtaCP0ha+kVIP2tZqC/VwzT32sC6W8D9e2rXqO/DQ76e9UA/b0GpL8NwEZ+VQj9ITVvFEh/G5no7zWf/jDJeY2B/ja5nP607k1C6O9VihXtd40Q+kPW0utA+lvDQH+vG6a/1wXS32bq2ze8Rn+bHfT3hgH6ex1If5uBjfyGEPpDat4ikP62MNHfmz79YZLzJgP9bXU5/WndW4XQ3xsUK9rvWiH0h6ylt4D0t5aB/t4yTH9vCKS/bdS3b3uN/rY56O9tA/T3BpD+tgEb+W0h9IfUvF0g/W1nor93fPrDJOcdBvrb4XL607p3CKG/tylWtN91QugPWUvvAulvHQP9vWuY/t4USH87qW/f8xr97XTQ33sG6O9NIP3tBDbye0LoD6l5l0D628VEf+/79IdJzvsM9Lfb5fSnde8WQn/vUaxov+uF0B+ylj4A0t96Bvr7wDD9vSWQ/vZQ337oNfrb46C/Dw3Q31tA+tsDbOQPhdAfUvNegfS3l4n+PvLpD5Ocjxjob5/L6U/r3ieE/j6kWNF+NwihP2QtfQykvw0M9PexYfp7WyD97ae+/cRr9LffQX+fGKC/t4H0tx/YyJ8IoT+k5gMC6e8AE/196tMfJjmfMtDfQZfTn9Z9UAj9fUKxov1uFEJ/yFr6DEh/Gxno7zPD9PeOQPo7RH37udfo75CD/j43QH/vAOnvELCRPxdCf0jNhwXS32Em+vvCpz9Mcr5goL8jLqc/rfuIEPr7nGJF+90khP6QtfQlkP42MdDfl4bp712B9PcV9e3XXqO/rxz097UB+nsXSH9fARv5ayH0h9R8VCD9HWWiv298+sMk5xsG+jvmcvrTuo8Job+vKVa0381C6A9ZS98C6W8zA/19a5j+3hNIf8epb7/zGv0dd9Dfdwbo7z0g/R0HNvJ3QugPqfmEQPo7wUR/3/v0h0nO9wz0d9Ll9Kd1nxRCf99RrGi/W4TQH7KWfgDS3xYG+vvBMP29L5D+TlHf/ug1+jvloL8fDdDf+0D6OwVs5B+F0B9S82mB9Heaif5+8ukPk5yfGOjvjMvpT+s+I4T+fqRY0X63CqE/ZC39DKS/rQz097Nh+vtAIP2dpb79xWv0d9ZBf78YoL8PgPR3FtjIvwihP6TmcwLp7xwT/f3q0x8mOb8y0N95l9Of1n1eCP39QrGi/W4TQn/IWvoNSH/bGOjvN8P096FA+rtAffu71+jvgoP+fjdAfx8C6e8CsJF/F0J/SM0XBdLfRSb6u+TTHyY5lxjo77LL6U/rviyE/n6nWNF+twuhP2Qt/QGkv+0M9PeHYfr7SCD9BfLTXuT3GP1p4Xb60xtQ1vE/0fT3EZD+dPzZ9PV3I+fIL4P+kJrD8sujv7D82IPk33We36c/SHL0RqL9hgOLnkt3eH54jljoLwfFiva7Qwj9IWspF+5gZO1goD8dn0n6+1gg/UVQ30Z6jf4iHPQXaYD+PgbSXwSwkSOF0B9Sc5RA+otior/cPv1hkpObgf7yuJz+tO48QugvkmJF+90phP6QtZQXSH87Gegvr2H6+0Qg/eWjvs3vNfrL56C//Abo7xMg/eUDNnJ+IfSH1BwtkP6imeivgE9/mOQUYKC/gi6nP627oBD6y0+xov3uEkJ/yFoqBKS/XQz0V8gw/X0qkP4KU98W8Rr9FXbQXxED9PcpkP4KAxu5iBD6Q2ouKpD+ijLR31U+/WGScxUD/RVzOf1p3cWE0F8RihXtd7cQ+kPWUnEg/e1moL/ihunvM4H0V4L6tqTX6K+Eg/5KGqC/z4D0VwLYyCWF0B9ScymB9FeKif6u9ukPk5yrGeivtMvpT+suLYT+SlKsaL97hNAfspauAdLfHgb6u8Yw/X0ukP7KUN9e6zX6K+Ogv2sN0N/nQPorA2zka4XQH1JzWYH0V5aJ/sr59IdJTjkG+ivvcvrTussLob9rKVa0371C6A9ZSxWA9LeXgf4qGKa/LwTSX0Xq20peo7+KDvqrZID+vgDSX0VgI1cSQn9IzZUF0l9lJvqr4tMfJjlVGOivqsvpT+uuKoT+KlGsaL/7hNAfspaqAelvHwP9VTNMf18KpL/q1Lc1vEZ/1R30V8MA/X0JpL/qwEauIYT+kJprCqS/mkz0V8unP0xyajHQX22X05/WXVsI/dWgWNF+9wuhP2Qt1QHS334G+qtjmP6+Fkh/Qepby2v0F3TQn2WA/r4G0l8Q2MiWEPpDao4RSH8xTPQX69MfJjmxDPQX53L607rjhNCfRbGi/R4QQn/IWqoLpL8DDPRX1zD9fSOQ/uKpbxO8Rn/xDvpLMEB/3wDpLx7YyAlC6A+pOVEg/SUy0V89n/4wyanHQH/1XU5/Wnd9IfSXQLGi/R4UQn/IWroOSH8HGejvOsP0961A+rue+raB1+jvegf9NTBAf98C6e96YCM3EEJ/SM0NBdJfQyb6u8GnP0xybmCgv0Yup78/i1II/TWgWNF+DwmhP2QtNQbS3yEG+mtsmP6+E0h/Tahvm3qN/po46K+pAfr7Dkh/TYCN3FQI/SE1N8svj/7sMQezebPHe2N+n/4gydEbifbbHFj0XLp1jOAcsdBfU4oV7fewEPpD1tJNuIORdZiB/nR8Junve4H0dzP1bYv8HqM/LdxOf3oDyjr+J5r+vgfS383ARm6Rn6dw0fSH1NxSIP21ZKK/Vj79YZLTioH+Wruc/rTu1kLorwXFivZ7RAj9IWvpFiD9HWGgv1sM098PAumvDfXtrV6jvzYO+rvVAP39AKS/NsBGvlUI/SE1txVIf22Z6O82n/4wybmNgf7auZz+tO52QujvVooV7fcrIfSHrKXbgfT3FQP93W6Y/n4USH/tqW/v8Br9tXfQ3x0G6O9HIP21BzbyHULoD6m5g0D668BEfx19+sMkpyMD/XVyOf1p3Z2E0N8dFCva71Eh9IespTuB9HeUgf7uNEx/Pwmkv7uob+/2Gv3d5aC/uw3Q309A+rsL2Mh3C6E/pObOAumvMxP93ePTHyY59zDQXxeX05/W3UUI/d1NsaL9HhNCf8hauhdIf8cY6O9ew/T3s0D660p9m+Q1+uvqoL8kA/T3M5D+ugIbOUkI/SE1Jwukv2Qm+kvx6Q+TnBQG+kt1Of1p3alC6C+JYkX7PS6E/pC1lAakv+MM9JdmmP5+EUh/6dS393mN/tId9HefAfr7BUh/6cBGvk8I/SE1dxNIf92Y6K+7T3+Y5HRnoL8eLqc/rbuHEPq7j2JF+z0hhP6QtXQ/kP5OMNDf/Ybp73eB9NeT+raX1+ivp4P+ehmgv9+B9NcT2Mi9hNAfUnNvgfTXm4n++vj0h0lOHwb66+ty+tO6+wqhv14UK9rvSSH0h6ylfkD6O8lAf/0M098lgfTXn/r2Aa/RX38H/T1ggP4uAemvP7CRHxBCf0jNAwTS3wAm+hvo0x8mOQMZ6G+Qy+lP6x4khP4eoFjRfk8JoT9kLT0IpL9TDPT3oGH6+0Mg/Q2mvh3iNfob7KC/IQbo7w8g/Q0GNvIQIfSH1DxUIP0NZaK/h3z6wyTnIQb6G+Zy+tO6hwmhvyEUK9rvaSH0h6yl4UD6O81Af8MN01+OfPLobwT17cNeo78RDvp72AD92Qsku/Q3AtjIDwuhP6TmkQLpbyQT/Y3y6Q+TnFEM9Dfa5fSndY8WQn8PU6xov2eE0B+ylh4B0t8ZBvp7xDD95RRIf2Oob8d6jf7GOOhvrAH6ywmkvzHARh4rhP6QmscJpL9xTPT3qE9/mOQ8ykB/411Of1r3eCH0N5ZiRfs9K4T+kLX0GJD+zjLQ32OG6S+XQPqbQH37uNfob4KD/h43QH+5gPQ3AdjIjwuhP6TmiQLpbyIT/T3h0x8mOU8w0N8kl9Of1j1JCP09TrGi/Z4TQn/IWnoSSH/nGOjvScP0FymQ/iZT3z7lNfqb7KC/pwzQXySQ/iYDG/kpIfSH1DxFIP1NYaK/qT79YZIzlYH+prmc/rTuaULo7ymKFe33vBD6Q9bSdCD9nWegv+mG6S+3QPqbQX0702v0N8NBfzMN0F9uIP3NADbyTCH0h9Q8SyD9zWKiv6d9+sMk52kG+pvtcvrTumcLob+ZFCva7wUh9IespTlA+rvAQH9zDNNfXoH0N5f6dp7X6G+ug/7mGaC/vED6mwts5HlC6A+peb5A+pvPRH/P+PSHSc4zDPS3wOX0p3UvEEJ/8yhWtN+LQugPWUvPAunvIgP9PWuY/vILpL+F1LeLvEZ/Cx30t8gA/eUH0t9CYCMvEkJ/SM2LBdLfYib6W+LTHyY5Sxjob6nL6U/rXiqE/hZRrGi/l4XQH7KWlgHp7zID/S0zTH8FBNLfcurbFV6jv+UO+lthgP4KAOlvObCRVwihP6TmlQLpbyUT/T3n0x8mOc8x0N8ql9Of1r1KCP2toFjRfgNFZNAfspaeB9Ifcv9CD+jPG6a/QgLpbzX17Qteo7/VDvp7wQD9FQLS32pgI78ghP6QmtcIpL81TPT3ok9/mOS8yEB/a11Of1r3WiH09wLFivYbJoT+kLX0EpD+whjo7yXD9FdEIP2to7592Wv0t85Bfy8boL8iQPpbB2zkl4XQH1LzeoH0t56J/l7x6Q+TnFcY6G+Dy+lP694ghP5epljRfsOF0B+yll4F0l84A/29apj+rhJIfxupb1/zGv1tdNDfawbo7yog/W0ENvJrQugPqXmTQPrbxER/r/v0h0nO6wz0t9nl9Kd1bxZCf69RrGi/EULoD1lLbwDpL4KB/t4wTH/FBdLfFurbN71Gf1sc9PemAforDqS/LcBGflMI/SE1bxVIf1uZ6O8tn/4wyXmLgf62uZz+tO5tQujvTYoV7TdKCP0ha+ltIP1FMdDf24bpr6RA+ttOffuO1+hvu4P+3jFAfyWB9Lcd2MjvCKE/pOYdAulvBxP9vevTHyY57zLQ306X05/WvVMI/b1DsaL95hFCf8haeg9If3kY6O89w/RXWiD97aK+fd9r9LfLQX/vG6C/0kD62wVs5PeF0B9S826B9Lebif4+8OkPk5wPGOhvj8vpT+veI4T+3qdY0X7zCaE/ZC19CKS/fAz096Fh+rtWIP3tpb79yGv0t9dBfx8ZoL9rgfS3F9jIHwmhP6TmfQLpbx8T/X3s0x8mOR8z0N9+l9Of1r1fCP19RLGi/UYLoT9kLX0CpL9oBvr7xDD9lRdIfweobz/1Gv0dcNDfpwborzyQ/g4AG/lTIfSH1HxQIP0dZKK/z3z6wyTnMwb6O+Ry+tO6Dwmhv08pVrTfgkLoD1lLnwPpryAD/X1umP4qCaS/w9S3X3iN/g476O8LA/RXCUh/h4GN/IUQ+kNqPiKQ/o4w0d+XPv1hkvMlA/195XL607q/EkJ/X1CsaL+FhdAfspa+BtJfYQb6+9ow/VUVSH9HqW+/8Rr9HXXQ3zcG6K8qkP6OAhv5GyH0h9R8TCD9HWOiv299+sMk51sG+jvucvrTuo8Lob9vKFa036JC6A9ZS98B6a8oA/19Z5j+agikvxPUt997jf5OOOjvewP0VwNIfyeAjfy9EPpDaj4pkP5OMtHfDz79YZLzAwP9nXI5/Wndp4TQ3/cUK9pvMSH0h6ylH4H0V4yB/n40TH+1BdLfaerbn7xGf6cd9PeTAfqrDaS/08BG/kkI/SE1nxFIf2eY6O9nn/4wyfmZgf7Oupz+tO6zQujvJ4oV7beEEPpD1tIvQPorwUB/vximP0sg/Z2jvv3Va/R3zkF/vxqgPwtIf+eAjfyrEPpDaj4vkP7OM9Hfbz79YZLzGwP9XXA5/WndF4TQ368UK9pvKSH0h6yl34H0V4qB/n43TH9xAunvIvXtJa/R30UH/V0yQH9xQPq7CGzkS0LoD6n5skD6u8xEf3/49IdJzh8M9Kd3IuTLjfSndf+ZLaxfFvq7RLGi/ZYWQn/IWsoRjauh0gz0p+MzSX8JAukvjPo2Z7TH6E8Lt9Of3oCyjv+Jpr8EIP2FARs5ZzRP4aLpD6k5PFoe/YVHYw+SoVuuaJ/+IMnJFY33G+Fy+tO6I4TQX06KFe23jBD6Q9ZSJJD+yjDQX6Rh+qsvkP6iqG9ze43+ohz0l9sA/dUH0l8UsJFzC6E/pOY8AukvDxP95fXpD5OcvAz0l8/l9Kd15xNCf7kpVrTfskLoD1lL+YH0V5aB/vIbpr8GAukvmvq2gNfoL9pBfwUM0F8DIP1FAxu5gBD6Q2ouKJD+CjLRXyGf/jDJKcRAf4VdTn9ad2Eh9FeAYkX7LS+E/pC1VARIf+UZ6K+IYfprJJD+ilLfXuU1+ivqoL+rDNBfIyD9FQU28lVC6A+puZhA+ivGRH/FffrDJKc4A/2VcDn9ad0lhNDfVRQr2m9FIfSHrKWSQPqryEB/JQ3TX1OB9FeK+vZqr9FfKQf9XW2A/poC6a8UsJGvFkJ/SM2lBdJfaSb6u8anP0xyrmGgvzIupz+tu4wQ+ruaYkX7rSyE/pC1dC2Q/ioz0N+1humvuUD6K0t9W85r9FfWQX/lDNBfcyD9lQU2cjkh9IfUXF4g/ZVnor8KPv1hklOBgf4qupz+tO6KQuivHMWK9ltVCP0ha6kSkP6qMtBfJcP010Ig/VWmvq3iNfqr7KC/KgborwWQ/ioDG7mKEPpDaq4qkP6qMtFfNZ/+MMmpxkB/1V1Of1p3dSH0V4ViRfutLoT+kLVUA0h/1Rnor4Zh+msvkP5qUt/W8hr91XTQXy0D9NceSH81gY1cSwj9ITXXFkh/tZnor45Pf5jk1GGgv6DL6U/rDgqhv1oUK9pvTSH0h6wlC0h/NRnozzJMf50F0l8M9W2s1+gvxkF/sQborzOQ/mKAjRwrhP6QmuME0l8cE/3V9ekPk5y6DPQX73L607rjhdBfLMWK9ltbCP0haykBSH+1GegvwTD9dRVIf4nUt/W8Rn+JDvqrZ4D+ugLpLxHYyPWE0B9Sc32B9Fefif6u8+kPk5zrGOjvepfTn9Z9vRD6q0exov0GhdAfspYaAOkvyEB/DQzTX7JA+mtIfXuD1+ivoYP+bjBAf8lA+msIbOQbhNAfUnMjgfTXiIn+Gvv0h0lOYwb6a+Jy+tO6mwihvxsoVrTfGCH0h6ylpkD6i2Ggv6aG6S9VIP01o7690Wv018xBfzcaoL9UIP01AzbyjULoD6m5uUD6a85Efzf59IdJzk0M9Hezy+lP675ZCP3dSLGi/cYJoT9kLbUA0l8cA/21MEx/6QLpryX1bSuv0V9LB/21MkB/6UD6awls5FZC6A+pubVA+mvNRH+3+PSHSc4tDPTXxuX0p3W3EUJ/rShWtN94IfSHrKVbgfQXz0B/txqmv24C6a8t9e1tXqO/tg76u80A/XUD0l9bYCPfJoT+kJrbCaS/dkz0d7tPf5jk3M5Af+1dTn9ad3sh9HcbxYr2myiE/pC1dAeQ/hIZ6O8Ow/Q30N30F7rF2PeiA/VtR6/RnxZ+yREM6n/ozezIcJDpGO3ugwzdrmiE/1VzWvpftw7R7t8/NOUiNXey+bISY2NiEmL1usRU9XpLakpMYkxManJcMCWYlBKTVi/OqpceFxMXm5Kakqx8JlnpwfSklHrpiX/FZYpyOzFR7p0+5WKScycD5d7lcsrVuu8SQrkdKVa037vBjambUPt0kgMqZ+F5A4FFefH70Dna3flvqTR3Zsh//SK8uoPZu1nL8vHovq6IDHAA5seSorkW8HHjnmh3P/bq2r6Hob67MBzXu9hOp6P3QRcUR583LOLu4/pipuP6DUJ6HZgf6waX57oOU403cflj+INMj+FNhdQ4MD9WU5fnujZTjTd3eW+/yHQcv0lIjQPzY93k8hrXz8U7GzpvEMzezZqeT06scwTF+qzBWLN7DNH+OI5NLV3epyuYjsmthByTgfmxWrk81yuZct3GUK5d9DzXagN+5T4q8M+LNPq5wGU1DqfxERofozGPsnspj1Fk+qZ7Wf9+JY3P0fgk/d10GufQ+CyNy2gspKyrzW8E+e1Fv+9NYx8a+9LYj8b+NKohkGTzs4n8aN/69y9SXGtpfInGdTS+TON6Gp8nvxtC62m+keav0nwTzd+g+Waav03zLTR/j+Zbaf4hzbfR/BOab6f55zTfQfOvab6T5t/RfBfNf6T5bpr/QvM9NP+d5ntpniP/X+M+mkfSfD/N89P8AM2L0PwgzUvS/BDNr6X5YZpXovkRmteg+Vc0t2h+lOYJND9G8wY0P07zpjQ/QfMWND9J81tpformd9D8NM3vpvkZmifR/CzN76P5BZr3ovlFmj9A88s0H0LzAO3rwzQPo/lYmofT/HGaR9D8KZpH0XwmzfPQfB7N89F8Ec2jab6C5gVp/gLNC9P8ZZoXpflrNC9G8zdpXoLm79C8FM2vpvF9uv8ampeh8SO6vyzNy9H4Kd1fgeYVafyC7q9M8yo0fkP3V6N5dRq/p/tr0rwWjT/R/XVoHqTxV7o/huaxNF6i++vSPJ7GnHRcSKR5PRpz0/3X0fx6GgvQ/Q1pfgONV9H9jWneJLR/dH8zmt8Y2ie6/yaa3xzaD7q/Jc1b0diaxltobEPjrTS2pfE2GtvReHto38jvHTTvQGNHGjvReCeNd9F4d2gf6e/voXkXGu8N7Rv9Pim0LzRPCemmeVpIF83vC8VN8+4070Hj/TT2pDGJ1j1A8wGhelGWbDvuhy4wWEx9ei/9XTKNhXVs0f++Ug3NeIMi1bEtD/BcnfJ3Mc8/8YL8Iq9+s5x32Pc3lZ6TpXnt6jctfLNNbJrtBSA0bIeKDg3bbd1+IpuaA34Js6FLjbMYZ9ARp5UKfGE2Dfm+D5dfqk03C1jfFrBmrHZCTmgg6y/9v/hKTEhLTk+Ii00KxqUnKz/x6WmxSTH1rPTEWOU+Ns5KTkoLpsYlJ8THxSemJwRNXUWZznQV5X3+VZSY5NzHcBVlN5dfRal1dxNyJjyNYkX77eDSByBnnMha6g68sqoDw3uFdHyNA+beK5SWjf1Iv/KWkkG4LM+WelDf3v9fni01yWDPnM+WmgT+72dLGfkx/mzJ/s9RPvUm9mA4qPRguITvfpvP0A1Nudkg+3894+gBPGDdz9Sg6JdykJp7Crj8tSdD73Bfzh/M3u3PMyhHGM4kdBJwBuU8g+473XkG5V9x9gL2IzDX1p0urxvdL18y1E1nAf3yG4Pue4T0S29gvwBzbd0joF++YqibrgL65QKD7iQh/dIH2C/AXFtJAvrla4a6SRXQL78z6E4T0i99gf0CzLWF3D99Ykdf/hY6w68ZVD+u6mNF3+hAgHN/+wH316WvnrH0pX7+2o/heXF/4PPicKor5w25rxx72z/a/TE+wBDjnzf0yarOwJNVAwScrEphaMpuLj8Y6WIcwKC7uxBIGAisS2CuLeT+MR/M/36534sH84HIGKU+6sYKiHGQn6i/PmHJ7TE+aAqPgtm7xdg3M7sPQ4N9drcGCzjcDxFSnLHI4hzqF6c1VEBxPoR+iCsQkJcoCSwyzE+UDBYZ7kUWGQE+3EsszhECDvcPe5FFRvrFaY0UUJyj0DGiA9RnrVoxfNhwT5ef8NUfsMzxoaS9hJzwHQ084QvMtdXL5XWj+6UXQ930FdAvgxh09xPSL48A+wWYa6ufgH7pzVA3AwT0y4MMugcK6ZcxwH4B5toaKKBf+jDUzWAB/TKEQfcQIf0yFtgvwFxbQwT0S1+GuhkmoF8eYtA9XEi/jAP2CzDX1nAB/TKMoW5Gulz3bKYvVRolpF8eBfYLMNfWKAH9MpyhX8a4XPccpn4ZK6RfxgP7BZhra6yAfnmYoV/Gu1z3XKZ+eUxIvzwG7Bdgrq3HBPTLKIZ+mehy3fOY+uUJIf0yAdgvwFxbT7i8bnLm5Xn9ZbLLdeuLBx5h0P2UkH55HNgvwFxbTwnoF47XX6YJ6JcxDLqnC+mXicB+Aebami6gXzhef5kloF/GMuh+Wki/PAHsF2CuracF9AvH6y9zBfTLOAbd84T0yyRgvwBzbc0T0C+zGZ73LhDQL48y9MuzQvrlSWC/AHNtPSugX+Yw9MtiAf0ynqFflgjpl8nAfgHm2loioF/mMvTLcgH98hhDv6wQ0i9PAfsFmGtrhYB+mcfQL6sE9MsEhn55Xki/TAH2CzDX1vMC+qUlQ7+sEdAvoxn65UUh/TIV2C/AXFtc+xcGrh9kLqZFy9CcA6h5uhDNYUDNM4RozgnUPFOI5nCg5llCNOcCan5aiOYIoObZQjRHAjXPEaK5LlDzXCGaY4Ga53lQ83wPan7Gg5oXeFDzsx7UvNCDmhd5UPNiD2pe4kHNSz2oeZkHNS/3oOYVHtS80oOan/Og5lUe1Py8BzWv9qDmFzyoeY0HNb/oQc1rPaj5JQ9qXudBzS97UPN6D2p+xYOaN3hQ86se1LzRg5pf86DmTR7U/LoHNW/2oOY3PKh5iwc1v+lBzVs9qPktD2re5kHNb3tQ83YPan7Hg5p3eFDzux7UvNODmt/zoOZdHtT8vgc17/ag5g88qHmPBzV/6EHNez2o+SMPat7nQc0fe1Dzfg9q/sSDmg94UPOnHtR80IOaP/Og5kMe1Py5BzUf9qDmLzyo+YgHNX/pQc1feVDz1x7UfNSDmr/xoOZjHtT8rQc1H/eg5u88qPmEBzV/70HNJz2o+QcPaj7lQc0/elDzaQ9q/smDms94UPPPHtR81oOaf/Gg5nMe1PyrBzWf96Dm3zyo+YIHNf/uQc0XPaj5kgc1X/ag5j88qDlQwHuac3hQc5gHNef0oOZwD2rO5UHNER7UHOlBzVEe1Jzbg5rzeFBzXg9qzudBzfk9qDnag5oLeFBzQQ9qLuRBzYU9qLmIBzUX9aDmqzyouZgHNRf3oOYSHtRc0oOaS3lQ89Ue1Fzag5qv8aDmMh7UfK0HNZf1oOZyHtRc3oOaK3hQc0UPaq7kQc2VPai5igc1V/Wg5moe1Fzdg5preFBzTQ9qruVBzbU9qLmOBzUHPajZ8qDmGA9qjvWg5jghmh+PxmmuK0TzRKDmeCGanwBqThCieRJQc6IQzU8CNdcTonkyUHN9IZqfAmq+TojmKUDN13uQSRp4UHNDIZqnAmv7Bg/muZEHNTf2oOYmHtTc1IOam3lQ841CNEcBNTcXojk3UPNNQjTnAWq+WYjmvEDNLYRozgfU3FKI5vxAza2EaI4Gam4tRHMBoOZbhGguCNTcRojmQkDNtwrRXBioua0QzUWAmm8TorkoUHM7IZqvAmq+XYjmYkDN7YVoLg7UfIcQzSWAmjsI0VwSqLmjEM2lgJo7CdF8NVDznUI0lwZqvkuI5muAmu8WorkMUHNnIZqvBWq+R4jmskDNXYRoLgfUfC9Qc3mb5hykO6eycGW5lEUoi1SmX5PQ5+j1OWt9Dlef09Tn+PQ5L30OSJ8T0ecI9HNm/RxSP6fSzzE0c2sG1UymGUU/ZuvHMH1M18c43fO6B8oqK0c+9E3HVUFZRWWVlFVWVkVZVWXVlFVXVkNZTWW1lNVWVkfvhzJLWYyyXeRrmgpyurIZymYqm6XsaWWzlc1RNlfZPGXzlT2jbIGyZ5UtVLZI2WJlS5QtVbZM2XJlK5StVPacslXKnle2WtkLytYoe1HZWmUvKVun7GVl65W9omyDsleVbVT2mrJNyl5XtlnZG8q2KHtT2VZlbynbpuxtZduVvaNsh7J3le1U9p6yXcreV7Zb2QfK9ij7UNleZR8p26fsY2X7lX2i7ICyT5UdVPaZskPK9HfH6+9S198trr9rW3/3tP4uZv3dxPq7evV31+rvctXfbaq/61N/96X+Lkj93Yj6uwL1d+fp75LT362mv2tMf/eW/i4q/d1M+ruK9Hf36O+y0d/tor/rRH/3h/4uDP3dEPq7EvR3B+jP0v+DCkp/9rj+LG792dT6s5r1Zxfrz/LVn22rP+tVf/ap/ixQ/dmY+rMi9Wcn6s8S1J+tpz9rTn/2mv4sMv3ZXPqzqvRnN+nPMtKf7aM/60Z/9ov+LBT92SD6szL0Z0foz1LQny2g32uv33uu34ut35us36ur37uq38up39uo3+un3/um3wum3xul3yuk3zuj30ui31uh32ugT4zqa9H1tdn6WmV97a6+llVf26mvddTX/ulr4fS1YfpaKX3tkL6W5s9rS5Tpaw/0a/H6tWn9Wq1+7VK/lqdf29Kv9ejXPvRrAfrcuD5XrM+d6nOJ+tyaPtekz73ocxH6ubl+rqqfu+nnMprtNetq9tMspNlAP1bqxw59LNXHlmjbMWEnjaVpTBowIK1X3wFlB/Qpm5SaWvbB7gO6le0zKK1/es8+D+rfzwjP2vqKubK2Pl/urK3fl8X1b+XP2vr50VlbP7Vw5tfr43FxWtckx19jSZo37t8/aUjZ7r1T0waX7TNwQNk+6WWT+wzsnfqA/Y9a/C9/1PF/+aM+Of43WQ/8L/9sWGb/6P8BXb1dOUItEgA=",
-            "debug_symbols": "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"
+            "bytecode": "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",
+            "debug_symbols": "q1bKyU9OLMnMzytWsqqurQUA"
         }
     ],
     "events": [],
     "file_map": {
-        "18": {
-            "source": "mod bn254;\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n    pub fn to_le_bits(self: Self, bit_size: u32) -> [u1] {\n        crate::assert_constant(bit_size);\n        self.__to_le_bits(bit_size)\n    }\n    \n    pub fn to_be_bits(self: Self, bit_size: u32) -> [u1] {\n        crate::assert_constant(bit_size);\n        self.__to_be_bits(bit_size)\n    }\n\n    #[builtin(to_le_bits)]\n    fn __to_le_bits(_self: Self, _bit_size: u32) -> [u1] {}\n    \n    #[builtin(to_be_bits)]\n    fn __to_be_bits(_self: Self, _bit_size: u32) -> [u1] {}\n\n    #[builtin(apply_range_constraint)]\n    fn __assert_max_bit_size(_self: Self, _bit_size: u32) {}\n\n    pub fn assert_max_bit_size(self: Self, bit_size: u32) {\n        crate::assert_constant(bit_size);\n        assert(bit_size < modulus_num_bits() as u32);\n        self.__assert_max_bit_size(bit_size);\n    }\n\n    pub fn to_le_bytes(self: Self, byte_size: u32) -> [u8] {\n        self.to_le_radix(256, byte_size)\n    }\n\n    pub fn to_be_bytes(self: Self, byte_size: u32) -> [u8] {\n        self.to_be_radix(256, byte_size)\n    }\n\n\n    pub fn to_le_radix(self: Self, radix: u32, result_len: u32) -> [u8] {\n        crate::assert_constant(radix);\n        crate::assert_constant(result_len);\n        self.__to_le_radix(radix, result_len)\n    }\n\n    pub fn to_be_radix(self: Self, radix: u32, result_len: u32) -> [u8] {\n        crate::assert_constant(radix);\n        crate::assert_constant(result_len);\n        self.__to_be_radix(radix, result_len)\n    }\n\n\n\n    // decompose `_self` into a `_result_len` vector over the `_radix` basis\n    // `_radix` must be less than 256\n    #[builtin(to_le_radix)]\n    fn __to_le_radix(_self: Self, _radix: u32, _result_len: u32) -> [u8] {}\n    \n    #[builtin(to_be_radix)]\n    fn __to_be_radix(_self: Self, _radix: u32, _result_len: u32) -> [u8] {}\n\n\n    // Returns self to the power of the given exponent value.\n    // Caution: we assume the exponent fits into 32 bits\n    // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n    pub fn pow_32(self, exponent: Field) -> Field {\n        let mut r: Field = 1;\n        let b = exponent.to_le_bits(32);\n\n        for i in 1..33 {\n            r *= r;\n            r = (b[32-i] as Field) * (r * self) + (1 - b[32-i] as Field) * r;\n        }\n        r\n    }\n\n    // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x ∈ {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n    pub fn sgn0(self) -> u1 {\n        self as u1\n    }\n\n    pub fn lt(self, another: Field) -> bool {\n        if crate::compat::is_bn254() {\n            bn254_lt(self, another)\n        } else {\n            lt_fallback(self, another)\n        }\n    }\n\n}\n\n#[builtin(modulus_num_bits)]\npub fn modulus_num_bits() -> Field {}\n\n#[builtin(modulus_be_bits)]\npub fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub fn modulus_le_bytes() -> [u8] {}\n// Convert a 32 byte array to a field element\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n    // Convert it to a field element\n    let mut v = 1;\n    let mut high = 0 as Field;\n    let mut low = 0 as Field;\n\n    for i in 0..16 {\n        high = high + (bytes32[15 - i] as Field) * v;\n        low = low + (bytes32[16 + 15 - i] as Field) * v;\n        v = v * 256;\n    }\n    // Abuse that a % p + b % p = (a + b) % p and that low < p\n    low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n    let num_bytes = (modulus_num_bits() as u32 + 7) / 8;\n    let x_bytes = x.to_le_bytes(num_bytes);\n    let y_bytes = y.to_le_bytes(num_bytes);\n    let mut x_is_lt = false;\n    let mut done = false;\n    for i in 0..num_bytes {\n        if (!done) {\n            let x_byte = x_bytes[num_bytes - 1 - i] as u8;\n            let y_byte = y_bytes[num_bytes - 1 - i] as u8;\n            let bytes_match = x_byte == y_byte;\n            if !bytes_match {\n                x_is_lt = x_byte < y_byte;\n                done = true;\n            }\n        }\n    }\n    x_is_lt\n}\n\n",
+        "3": {
+            "source": "struct BoundedVec<T, MaxLen> {\n    storage: [T; MaxLen],\n    // TODO: change this to return a u64 as Noir now\n    // uses u64 for indexing\n    len: Field,\n    empty_value: T,\n}\n\nimpl<T, MaxLen> BoundedVec<T, MaxLen> {\n    pub fn new(initial_value: T) -> Self {\n        BoundedVec { storage: [initial_value; MaxLen], len: 0, empty_value: initial_value }\n    }\n\n    pub fn get(mut self: Self, index: Field) -> T {\n        assert(index as u64 < self.len as u64);\n        self.storage[index]\n    }\n\n    pub fn get_unchecked(mut self: Self, index: Field) -> T {\n        self.storage[index]\n    }\n\n    pub fn push(&mut self, elem: T) {\n        assert(self.len as u64 < MaxLen as u64, \"push out of bounds\");\n\n        self.storage[self.len] = elem;\n        self.len += 1;\n    }\n\n    pub fn len(self) -> Field {\n        self.len\n    }\n\n    pub fn max_len(_self: BoundedVec<T, MaxLen>) -> Field {\n        MaxLen\n    }\n\n    // This is a intermediate method, while we don't have an\n    // .extend method\n    pub fn storage(self) -> [T; MaxLen] {\n        self.storage\n    }\n\n    pub fn extend_from_array<Len>(&mut self, array: [T; Len]) {\n        let new_len = self.len + array.len();\n        assert(new_len as u64 <= MaxLen as u64, \"extend_from_array out of bounds\");\n        for i in 0..array.len() {\n            self.storage[self.len + i] = array[i];\n        }\n        self.len = new_len;\n    }\n\n    pub fn extend_from_bounded_vec<Len>(&mut self, vec: BoundedVec<T, Len>) {\n        let append_len = vec.len();\n        let new_len = self.len + append_len;\n        assert(new_len as u64 <= MaxLen as u64, \"extend_from_bounded_vec out of bounds\");\n\n        let mut exceeded_len = false;\n        for i in 0..Len {\n            exceeded_len |= i == append_len;\n            if !exceeded_len {\n                self.storage[self.len + (i as Field)] = vec.get_unchecked(i as Field);\n            }\n        }\n        self.len = new_len;\n    }\n\n    pub fn pop(&mut self) -> T {\n        assert(self.len as u64 > 0);\n        self.len -= 1;\n\n        let elem = self.storage[self.len];\n        self.storage[self.len] = self.empty_value;\n        elem\n    }\n\n    pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n        let mut ret = false;\n        let mut exceeded_len = false;\n        for i in 0..MaxLen {\n            exceeded_len |= i == self.len;\n            if (!exceeded_len) {\n                ret |= predicate(self.storage[i]);\n            }\n        }\n        ret\n    }\n}",
+            "path": "std/collections/bounded_vec.nr"
+        },
+        "19": {
+            "source": "mod bn254;\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n    pub fn to_le_bits(self: Self, bit_size: u32) -> [u1] {\n        crate::assert_constant(bit_size);\n        self.__to_le_bits(bit_size)\n    }\n    \n    pub fn to_be_bits(self: Self, bit_size: u32) -> [u1] {\n        crate::assert_constant(bit_size);\n        self.__to_be_bits(bit_size)\n    }\n\n    #[builtin(to_le_bits)]\n    fn __to_le_bits(self, _bit_size: u32) -> [u1] {}\n    \n    #[builtin(to_be_bits)]\n    fn __to_be_bits(self, bit_size: u32) -> [u1] {}\n\n    #[builtin(apply_range_constraint)]\n    fn __assert_max_bit_size(self, bit_size: u32) {}\n\n    pub fn assert_max_bit_size(self: Self, bit_size: u32) {\n        crate::assert_constant(bit_size);\n        assert(bit_size < modulus_num_bits() as u32);\n        self.__assert_max_bit_size(bit_size);\n    }\n\n    pub fn to_le_bytes(self: Self, byte_size: u32) -> [u8] {\n        self.to_le_radix(256, byte_size)\n    }\n\n    pub fn to_be_bytes(self: Self, byte_size: u32) -> [u8] {\n        self.to_be_radix(256, byte_size)\n    }\n\n\n    pub fn to_le_radix(self: Self, radix: u32, result_len: u32) -> [u8] {\n        crate::assert_constant(radix);\n        crate::assert_constant(result_len);\n        self.__to_le_radix(radix, result_len)\n    }\n\n    pub fn to_be_radix(self: Self, radix: u32, result_len: u32) -> [u8] {\n        crate::assert_constant(radix);\n        crate::assert_constant(result_len);\n        self.__to_be_radix(radix, result_len)\n    }\n\n\n\n    // decompose `_self` into a `_result_len` vector over the `_radix` basis\n    // `_radix` must be less than 256\n    #[builtin(to_le_radix)]\n    fn __to_le_radix(self, radix: u32, result_len: u32) -> [u8] {}\n    \n    #[builtin(to_be_radix)]\n    fn __to_be_radix(self, radix: u32, result_len: u32) -> [u8] {}\n\n\n    // Returns self to the power of the given exponent value.\n    // Caution: we assume the exponent fits into 32 bits\n    // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n    pub fn pow_32(self, exponent: Field) -> Field {\n        let mut r: Field = 1;\n        let b = exponent.to_le_bits(32);\n\n        for i in 1..33 {\n            r *= r;\n            r = (b[32-i] as Field) * (r * self) + (1 - b[32-i] as Field) * r;\n        }\n        r\n    }\n\n    // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x ∈ {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n    pub fn sgn0(self) -> u1 {\n        self as u1\n    }\n\n    pub fn lt(self, another: Field) -> bool {\n        if crate::compat::is_bn254() {\n            bn254_lt(self, another)\n        } else {\n            lt_fallback(self, another)\n        }\n    }\n\n}\n\n#[builtin(modulus_num_bits)]\npub fn modulus_num_bits() -> Field {}\n\n#[builtin(modulus_be_bits)]\npub fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub fn modulus_le_bytes() -> [u8] {}\n// Convert a 32 byte array to a field element\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n    // Convert it to a field element\n    let mut v = 1;\n    let mut high = 0 as Field;\n    let mut low = 0 as Field;\n\n    for i in 0..16 {\n        high = high + (bytes32[15 - i] as Field) * v;\n        low = low + (bytes32[16 + 15 - i] as Field) * v;\n        v = v * 256;\n    }\n    // Abuse that a % p + b % p = (a + b) % p and that low < p\n    low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n    let num_bytes = (modulus_num_bits() as u32 + 7) / 8;\n    let x_bytes = x.to_le_bytes(num_bytes);\n    let y_bytes = y.to_le_bytes(num_bytes);\n    let mut x_is_lt = false;\n    let mut done = false;\n    for i in 0..num_bytes {\n        if (!done) {\n            let x_byte = x_bytes[num_bytes - 1 - i] as u8;\n            let y_byte = y_bytes[num_bytes - 1 - i] as u8;\n            let bytes_match = x_byte == y_byte;\n            if !bytes_match {\n                x_is_lt = x_byte < y_byte;\n                done = true;\n            }\n        }\n    }\n    x_is_lt\n}\n\n",
             "path": "std/field.nr"
         },
-        "30": {
+        "31": {
             "source": "struct Option<T> {\n    _is_some: bool,\n    _value: T,\n}\n\nimpl<T> Option<T> {\n    /// Constructs a None value\n    pub fn none() -> Self {\n        Self { _is_some: false, _value: crate::unsafe::zeroed() }\n    }\n\n    /// Constructs a Some wrapper around the given value\n    pub fn some(_value: T) -> Self {\n        Self { _is_some: true, _value }\n    }\n\n    /// True if this Option is None\n    pub fn is_none(self) -> bool {\n        !self._is_some\n    }\n\n    /// True if this Option is Some\n    pub fn is_some(self) -> bool {\n        self._is_some\n    }\n\n    /// Asserts `self.is_some()` and returns the wrapped value.\n    pub fn unwrap(self) -> T {\n        assert(self._is_some);\n        self._value\n    }\n\n    /// Returns the inner value without asserting `self.is_some()`\n    /// Note that if `self` is `None`, there is no guarantee what value will be returned,\n    /// only that it will be of type `T`.\n    pub fn unwrap_unchecked(self) -> T {\n        self._value\n    }\n\n    /// Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.\n    pub fn unwrap_or(self, default: T) -> T {\n        if self._is_some {\n            self._value\n        } else {\n            default\n        }\n    }\n\n    /// Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return\n    /// a default value.\n    pub fn unwrap_or_else<Env>(self, default: fn[Env]() -> T) -> T {\n        if self._is_some {\n            self._value\n        } else {\n            default()\n        }\n    }\n\n    /// If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.\n    pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> Option<U> {\n        if self._is_some {\n            Option::some(f(self._value))\n        } else {\n            Option::none()\n        }\n    }\n\n    /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.\n    pub fn map_or<U, Env>(self, default: U, f: fn[Env](T) -> U) -> U {\n        if self._is_some {\n            f(self._value)\n        } else {\n            default\n        }\n    }\n\n    /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.\n    pub fn map_or_else<U, Env1, Env2>(self, default: fn[Env1]() -> U, f: fn[Env2](T) -> U) -> U {\n        if self._is_some {\n            f(self._value)\n        } else {\n            default()\n        }\n    }\n\n    /// Returns None if self is None. Otherwise, this returns `other`.\n    pub fn and(self, other: Self) -> Self {\n        if self.is_none() {\n            Option::none()\n        } else {\n            other\n        }\n    }\n\n    /// If self is None, this returns None. Otherwise, this calls the given function\n    /// with the Some value contained within self, and returns the result of that call.\n    ///\n    /// In some languages this function is called `flat_map` or `bind`.\n    pub fn and_then<U, Env>(self, f: fn[Env](T) -> Option<U>) -> Option<U> {\n        if self._is_some {\n            f(self._value)\n        } else {\n            Option::none()\n        }\n    }\n\n    /// If self is Some, return self. Otherwise, return `other`.\n    pub fn or(self, other: Self) -> Self {\n        if self._is_some {\n            self\n        } else {\n            other\n        }\n    }\n\n    /// If self is Some, return self. Otherwise, return `default()`.\n    pub fn or_else<U, Env>(self, default: fn[Env]() -> Self) -> Self {\n        if self._is_some {\n            self\n        } else {\n            default()\n        }\n    }\n\n    // If only one of the two Options is Some, return that option.\n    // Otherwise, if both options are Some or both are None, None is returned.\n    pub fn xor(self, other: Self) -> Self {\n        if self._is_some {\n            if other._is_some {\n                Option::none()\n            } else {\n                self\n            }\n        } else if other._is_some {\n            other\n        } else {\n            Option::none()\n        }\n    }\n\n    /// Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true.\n    /// Otherwise, this returns `None`\n    pub fn filter<Env>(self, predicate: fn[Env](T) -> bool) -> Self {\n        if self._is_some {\n            if predicate(self._value) {\n                self\n            } else {\n                Option::none()\n            }\n        } else {\n            Option::none()\n        }\n    }\n\n    /// Flattens an Option<Option<T>> into a Option<T>.\n    /// This returns None if the outer Option is None. Otherwise, this returns the inner Option.\n    pub fn flatten(option: Option<Option<T>>) -> Option<T> {\n        if option._is_some {\n            option._value\n        } else {\n            Option::none()\n        }\n    }\n}\n",
             "path": "std/option.nr"
         },
-        "43": {
-            "source": "use dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        public_circuit_public_inputs::PublicCircuitPublicInputs,\n    },\n    contrakt::deployment_data::ContractDeploymentData,\n    hash::hash_args,\n    header::Header,\n};\n\n// docs:start:private-global-variables\nstruct PrivateGlobalVariables {\n    chain_id: Field,\n    version: Field,\n}\n// docs:end:private-global-variables\n\nimpl PrivateGlobalVariables {\n    fn serialize(self) -> [Field; 2] {\n        [self.chain_id, self.version]\n    }\n}\n\n// docs:start:public-global-variables\nstruct PublicGlobalVariables {\n    chain_id: Field,\n    version: Field,\n    block_number: Field,\n    timestamp: Field,\n}\n// docs:end:public-global-variables\n\nimpl PublicGlobalVariables {\n    fn serialize(self) -> [Field; 4] {\n        [self.chain_id, self.version, self.block_number, self.timestamp]\n    }\n}\n\n// PrivateContextInputs are expected to be provided to each private function\n// docs:start:private-context-inputs\nstruct PrivateContextInputs {\n    call_context : CallContext,\n    historical_header: Header,\n    contract_deployment_data: ContractDeploymentData,\n    private_global_variables: PrivateGlobalVariables,\n}\n// docs:end:private-context-inputs\n\n// PublicContextInputs are expected to be provided to each public function\n// docs:start:public-context-inputs\nstruct PublicContextInputs {\n    call_context: CallContext,\n    historical_header: Header,\n\n    public_global_variables: PublicGlobalVariables,\n}\n// docs:end:public-context-inputs\n\nstruct Hasher {\n    fields: [Field],\n}\n\nimpl Hasher {\n    pub fn new()-> Self {\n        Self { fields: [] }\n    }\n\n    pub fn add(&mut self, field: Field) {\n        self.fields = self.fields.push_back(field);\n    }\n\n    pub fn add_multiple<N>(&mut self, fields: [Field; N]) {\n        for i in 0..N {\n            self.fields = self.fields.push_back(fields[i]);\n        }\n    }\n\n    pub fn hash(self) -> Field {\n        hash_args(self.fields)\n    }\n}\n",
+        "44": {
+            "source": "use dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        public_circuit_public_inputs::PublicCircuitPublicInputs,\n    },\n    address::{AztecAddress, EthAddress},\n    contrakt::deployment_data::ContractDeploymentData,\n    hash::hash_args,\n    traits::{Hash, Serialize},\n    header::Header,\n};\n\n// docs:start:private-global-variables\nstruct PrivateGlobalVariables {\n    chain_id: Field,\n    version: Field,\n}\n// docs:end:private-global-variables\n\nimpl Serialize<2> for PrivateGlobalVariables {\n    fn serialize(self) -> [Field; 2] {\n        [self.chain_id, self.version]\n    }\n}\n\n// docs:start:public-global-variables\nstruct PublicGlobalVariables {\n    chain_id: Field,\n    version: Field,\n    block_number: Field,\n    timestamp: Field,\n    coinbase: EthAddress,\n    fee_recipient: AztecAddress,\n}\n// docs:end:public-global-variables\n\nimpl Serialize<6> for PublicGlobalVariables {\n    fn serialize(self) -> [Field; 6] {\n        [\n            self.chain_id,\n            self.version,\n            self.block_number,\n            self.timestamp,\n            self.coinbase.to_field(),\n            self.fee_recipient.to_field(),\n        ]\n    }\n}\n\n// PrivateContextInputs are expected to be provided to each private function\n// docs:start:private-context-inputs\nstruct PrivateContextInputs {\n    call_context : CallContext,\n    historical_header: Header,\n    contract_deployment_data: ContractDeploymentData,\n    private_global_variables: PrivateGlobalVariables,\n}\n// docs:end:private-context-inputs\n\n// PublicContextInputs are expected to be provided to each public function\n// docs:start:public-context-inputs\nstruct PublicContextInputs {\n    call_context: CallContext,\n    historical_header: Header,\n\n    public_global_variables: PublicGlobalVariables,\n}\n// docs:end:public-context-inputs\n\nstruct Hasher {\n    fields: [Field],\n}\n\nimpl Hash for Hasher {\n    fn hash(self) -> Field {\n        hash_args(self.fields)\n    }\n}\n\nimpl Hasher {\n    pub fn new()-> Self {\n        Self { fields: [] }\n    }\n\n    pub fn add(&mut self, field: Field) {\n        self.fields = self.fields.push_back(field);\n    }\n\n    pub fn add_multiple<N>(&mut self, fields: [Field; N]) {\n        for i in 0..N {\n            self.fields = self.fields.push_back(fields[i]);\n        }\n    }\n}\n",
             "path": "/usr/src/yarn-project/aztec-nr/aztec/src/abi.nr"
         },
-        "45": {
-            "source": "use crate::context::{Context};\nuse crate::oracle::storage::storage_read;\nuse crate::oracle::storage::storage_write;\nuse crate::types::type_serialization::TypeSerializationInterface;\nuse dep::std::option::Option;\n\n// docs:start:public_state_struct\nstruct PublicState<T, T_SERIALIZED_LEN> {\n    context: Context,\n    storage_slot: Field,\n    serialization_methods: TypeSerializationInterface<T, T_SERIALIZED_LEN>,\n}\n// docs:end:public_state_struct\n\nimpl<T, T_SERIALIZED_LEN> PublicState<T, T_SERIALIZED_LEN> {\n    // docs:start:public_state_struct_new\n    pub fn new(\n        // Note: Passing the contexts to new(...) just to have an interface compatible with a Map.\n        context: Context,\n        storage_slot: Field,\n        serialization_methods: TypeSerializationInterface<T, T_SERIALIZED_LEN>,\n    ) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        PublicState {\n            context,\n            storage_slot,\n            serialization_methods,\n        }\n    }\n    // docs:end:public_state_struct_new\n\n    // docs:start:public_state_struct_read\n    pub fn read(self) -> T {\n        assert(self.context.private.is_none(), \"Public state reads only supported in public functions\");\n        storage_read(self.storage_slot, self.serialization_methods.deserialize)\n    }\n    // docs:end:public_state_struct_read\n\n    // docs:start:public_state_struct_write\n    pub fn write(self, value: T) {\n        assert(self.context.private.is_none(), \"Public state writes only supported in public functions\");\n        let serialize = self.serialization_methods.serialize;\n        let fields = serialize(value);\n        storage_write(self.storage_slot, fields);\n    }\n    // docs:end:public_state_struct_write\n}\n",
+        "46": {
+            "source": "use crate::context::{Context};\nuse crate::oracle::storage::storage_read;\nuse crate::oracle::storage::storage_write;\nuse dep::std::option::Option;\nuse dep::protocol_types::traits::{Deserialize, Serialize};\nuse crate::state_vars::storage::Storage;\n\n// docs:start:public_state_struct\nstruct PublicState<T> {\n    context: Context,\n    storage_slot: Field,\n}\n// docs:end:public_state_struct\n\nimpl<T> Storage<T> for PublicState<T> {}\n\nimpl<T> PublicState<T> {\n    // docs:start:public_state_struct_new\n    pub fn new(\n        // Note: Passing the contexts to new(...) just to have an interface compatible with a Map.\n        context: Context,\n        storage_slot: Field,\n    ) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        PublicState {\n            context,\n            storage_slot,\n        }\n    }\n    // docs:end:public_state_struct_new\n\n    // docs:start:public_state_struct_read\n    pub fn read<T_SERIALIZED_LEN>(self) -> T where T: Deserialize<T_SERIALIZED_LEN> {\n        assert(self.context.private.is_none(), \"Public state writes only supported in public functions\");\n        let fields = storage_read(self.storage_slot);\n        T::deserialize(fields)\n    }\n    // docs:end:public_state_struct_read\n\n    // docs:start:public_state_struct_write\n    pub fn write<T_SERIALIZED_LEN>(self, value: T) where T: Serialize<T_SERIALIZED_LEN> {\n        assert(self.context.private.is_none(), \"Public state writes only supported in public functions\");\n        let fields = T::serialize(value);\n        storage_write(self.storage_slot, fields);\n    }\n    // docs:end:public_state_struct_write\n}\n",
             "path": "/usr/src/yarn-project/aztec-nr/aztec/src/state_vars/public_state.nr"
         },
-        "46": {
-            "source": "use crate::context::{PrivateContext, PublicContext, Context};\nuse dep::std::option::Option;\nuse dep::protocol_types::{\n    hash::pedersen_hash,\n    traits::{ToField}\n};\n\n// docs:start:map\nstruct Map<K, V> {\n    context: Context,\n    storage_slot: Field,\n    state_var_constructor: fn(Context, Field) -> V,\n}\n// docs:end:map\n\nimpl<K, V> Map<K, V> {\n    // docs:start:new\n    pub fn new(\n        context: Context,\n        storage_slot: Field,\n        state_var_constructor: fn(Context, Field) -> V,\n    ) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        Map {\n            context,\n            storage_slot,\n            state_var_constructor,\n        }\n    }\n    // docs:end:new\n\n    // docs:start:at\n    pub fn at(self, key: K) -> V where K: ToField {\n        // TODO(#1204): use a generator index for the storage slot\n        let derived_storage_slot = pedersen_hash([self.storage_slot, key.to_field()],0);\n\n        let state_var_constructor = self.state_var_constructor;\n        state_var_constructor(self.context, derived_storage_slot)\n    }\n    // docs:end:at\n}\n",
+        "48": {
+            "source": "use crate::context::{PrivateContext, PublicContext, Context};\nuse dep::std::option::Option;\nuse dep::protocol_types::{\n    hash::pedersen_hash,\n    traits::{ToField}\n};\nuse crate::state_vars::storage::Storage;\n\n// docs:start:map\nstruct Map<K, V> {\n    context: Context,\n    storage_slot: Field,\n    state_var_constructor: fn(Context, Field) -> V,\n}\n// docs:end:map\n\nimpl<K, T> Storage<T> for Map<K, T> {}\n\nimpl<K, V> Map<K, V> {\n    // docs:start:new\n    pub fn new(\n        context: Context,\n        storage_slot: Field,\n        state_var_constructor: fn(Context, Field) -> V,\n    ) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        Map {\n            context,\n            storage_slot,\n            state_var_constructor,\n        }\n    }\n    // docs:end:new\n\n    // docs:start:at\n    pub fn at(self, key: K) -> V where K: ToField {\n        // TODO(#1204): use a generator index for the storage slot\n        let derived_storage_slot = pedersen_hash([self.storage_slot, key.to_field()],0);\n\n        let state_var_constructor = self.state_var_constructor;\n        state_var_constructor(self.context, derived_storage_slot)\n    }\n    // docs:end:at\n}\n",
             "path": "/usr/src/yarn-project/aztec-nr/aztec/src/state_vars/map.nr"
         },
-        "53": {
-            "source": "use crate::types::type_serialization::TypeSerializationInterface;\n\nglobal BOOL_SERIALIZED_LEN: Field = 1;\n\nfn deserializeBool(fields: [Field; BOOL_SERIALIZED_LEN]) -> bool {\n    fields[0] as bool\n}\n\nfn serializeBool(value: bool) -> [Field; BOOL_SERIALIZED_LEN] {\n    [value as Field]\n}\n\nglobal BoolSerializationMethods = TypeSerializationInterface {\n    deserialize: deserializeBool,\n    serialize: serializeBool,\n};\n",
-            "path": "/usr/src/yarn-project/aztec-nr/aztec/src/types/type_serialization/bool_serialization.nr"
-        },
-        "55": {
-            "source": "struct BoundedVec<T, MaxLen> {\n    storage: [T; MaxLen],\n    len: Field,\n}\n\nimpl<T, MaxLen> BoundedVec<T, MaxLen> {\n    pub fn new(initial_value: T) -> Self {\n        BoundedVec { storage: [initial_value; MaxLen], len: 0 }\n    }\n\n    pub fn get(mut self: Self, index: Field) -> T {\n        assert(index as u64 < self.len as u64);\n        self.storage[index]\n    }\n\n    pub fn get_unchecked(mut self: Self, index: Field) -> T {\n        self.storage[index]\n    }\n\n    pub fn push(&mut self, elem: T) {\n        assert(self.len as u64 < MaxLen as u64);\n\n        self.storage[self.len] = elem;\n        self.len += 1;\n    }\n\n    pub fn push_array<Len>(&mut self, array: [T; Len]) {\n        let newLen = self.len + array.len();\n        assert(newLen as u64 <= MaxLen as u64);\n        for i in 0..array.len() {\n            self.storage[self.len + i] = array[i];\n        }\n        self.len = newLen;\n    }\n\n    pub fn pop(&mut self) -> T {\n        assert(self.len as u64 > 0);\n\n        let elem = self.storage[self.len - 1];\n        self.len -= 1;\n        elem\n    }\n\n    pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n        let mut ret = false;\n        let mut exceeded_len = false;\n        for i in 0..MaxLen {\n            exceeded_len |= i == self.len;\n            if (!exceeded_len) {\n                ret |= predicate(self.storage[i]);\n            }\n        }\n        ret\n    }\n}\n\n#[test]\nfn test_vec_push_pop() {\n    let mut vec: BoundedVec<Field, 3> = BoundedVec::new(0);\n    assert(vec.len == 0);\n    vec.push(2);\n    assert(vec.len == 1);\n    vec.push(4);\n    assert(vec.len == 2);\n    vec.push(6);\n    assert(vec.len == 3);\n    let x = vec.pop();\n    assert(x == 6);\n    assert(vec.len == 2);\n    assert(vec.get(0) == 2);\n    assert(vec.get(1) == 4);\n}\n\n#[test]\nfn test_vec_push_array() {\n    let mut vec: BoundedVec<Field, 3> = BoundedVec::new(0);\n    vec.push_array([2, 4]);\n    assert(vec.len == 2);\n    assert(vec.get(0) == 2);\n    assert(vec.get(1) == 4);\n}\n\n#[test(should_fail)]\nfn test_vec_get_out_of_bound() {\n    let mut vec: BoundedVec<Field, 2> = BoundedVec::new(0);\n    vec.push_array([2, 4]);\n    let _x = vec.get(2);\n}\n\n#[test(should_fail)]\nfn test_vec_get_not_declared() {\n    let mut vec: BoundedVec<Field, 2> = BoundedVec::new(0);\n    vec.push_array([2]);\n    let _x = vec.get(1);\n}\n\n#[test(should_fail)]\nfn test_vec_get_uninitialized() {\n    let mut vec: BoundedVec<Field, 2> = BoundedVec::new(0);\n    let _x = vec.get(0);\n}\n\n#[test(should_fail)]\nfn test_vec_push_overflow() {\n    let mut vec: BoundedVec<Field, 1> = BoundedVec::new(0);\n    vec.push(1);\n    vec.push(2);\n}\n\n#[test]\nfn test_vec_any() {\n    let mut vec: BoundedVec<Field, 3> = BoundedVec::new(0);\n    vec.push_array([2, 4, 6]);\n    assert(vec.any(|v| v == 2) == true);\n    assert(vec.any(|v| v == 4) == true);\n    assert(vec.any(|v| v == 6) == true);\n    assert(vec.any(|v| v == 3) == false);\n}\n\n#[test]\nfn test_vec_any_not_default() {\n    let default_value = 1;\n    let mut vec: BoundedVec<Field, 3> = BoundedVec::new(default_value);\n    vec.push_array([2, 4]);\n    assert(vec.any(|v| v == default_value) == false);\n}\n",
-            "path": "/usr/src/yarn-project/aztec-nr/aztec/src/types/vec.nr"
-        },
-        "68": {
-            "source": "pub fn arr_copy_slice<T, N, M>(src: [T; N], mut dst: [T; M], offset: Field) -> [T; M] {\n    for i in 0..dst.len() {\n        dst[i] = src[i + offset];\n    }\n    dst\n}\n\n// TODO(#3470): Copied over from https://github.com/AztecProtocol/aztec-packages/blob/a07c4bd47313be6aa604a63f37857eb0136b41ba/yarn-project/noir-protocol-circuits/src/crates/rollup-lib/src/base/base_rollup_inputs.nr#L599\n// move to a shared place?\n\n// TODO to radix returns u8, so we cannot use bigger radixes. It'd be ideal to use a radix of the maximum range-constrained integer noir supports\npub fn full_field_less_than(lhs: Field, rhs: Field) -> bool {\n    lhs.lt(rhs)\n}\n\npub fn full_field_greater_than(lhs: Field, rhs: Field) -> bool {\n    rhs.lt(lhs)\n}\n\nstruct Reader<N> {\n    data: [Field; N],\n    offset: Field,\n}\n\nimpl<N> Reader<N> {\n    pub fn new(data: [Field; N]) -> Self {\n        Self { data, offset: 0 }\n    }\n\n    pub fn read(&mut self) -> Field {\n        let result = self.data[self.offset];\n        self.offset += 1;\n        result\n    }\n\n    pub fn read_array<K>(&mut self, mut result: [Field; K]) -> [Field; K] {\n        for i in 0..K {\n            result[i] = self.data[self.offset + i];\n        }\n        self.offset += K;\n        result\n    }\n\n    pub fn read_struct<T, K>(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n        let result = deserialise(self.read_array([0; K]));\n        result\n    }\n\n    pub fn read_struct_array<T, K, C>(&mut self, deserialise: fn([Field; K]) -> T, mut result: [T; C]) -> [T; C] {\n        for i in 0..C {\n            result[i] = self.read_struct(deserialise);\n        }\n        result\n    }\n\n    pub fn finish(self) {\n        assert(self.offset == self.data.len(), \"Reader did not read all data\");\n    } \n}\n",
-            "path": "/usr/src/yarn-project/aztec-nr/aztec/src/utils.nr"
-        },
-        "70": {
-            "source": "use crate::{\n    abi::{\n        PrivateContextInputs,\n        PublicContextInputs,\n    },\n    key::nullifier_key::validate_nullifier_key_against_address,\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        arguments,\n        call_private_function::call_private_function_internal,\n        public_call::call_public_function_internal,\n        enqueue_public_function_call::enqueue_public_function_call_internal,\n        context::get_portal_address,\n        header::get_header_at,\n        nullifier_key::{get_nullifier_key_pair, NullifierKeyPair},\n    },\n    types::vec::BoundedVec,\n    utils::Reader,\n};\nuse dep::protocol_types::{\n    abis::{\n        append_only_tree_snapshot::AppendOnlyTreeSnapshot,\n        call_context::CallContext,\n        global_variables::GlobalVariables,\n        function_data::FunctionData,\n        function_selector::FunctionSelector,\n        nullifier_key_validation_request::NullifierKeyValidationRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        public_circuit_public_inputs::PublicCircuitPublicInputs,\n        call_stack_item::PrivateCallStackItem,\n        call_stack_item::PublicCallStackItem,\n        side_effect::{SideEffect, SideEffectLinkedToNoteHash},\n    },\n    address::{\n        AztecAddress,\n        EthAddress,\n    },\n    constants::{\n        MAX_NEW_COMMITMENTS_PER_CALL,\n        MAX_NEW_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NEW_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL,\n        MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,\n        MAX_PUBLIC_DATA_READS_PER_CALL,\n        MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,\n        MAX_READ_REQUESTS_PER_CALL,\n        MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_CALL,\n        NUM_FIELDS_PER_SHA256,\n        RETURN_VALUES_LENGTH,\n    },\n    contrakt::{\n        deployment_data::ContractDeploymentData,\n        storage_read::StorageRead,\n        storage_update_request::StorageUpdateRequest,\n    },\n    grumpkin_point::GrumpkinPoint,\n    grumpkin_private_key::GrumpkinPrivateKey,\n    hash::hash_args,\n    header::Header,\n    state_reference::StateReference,\n};\nuse dep::std::{\n    option::Option,\n};\n\n// TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n// use dep::std::collections::vec::Vec;\n\n// When finished, one can call .finish() to convert back to the abi\nstruct PrivateContext {\n    // docs:start:private-context\n    inputs: PrivateContextInputs,\n    side_effect_counter: u32,\n\n    args_hash : Field,\n    return_values : BoundedVec<Field, RETURN_VALUES_LENGTH>,\n\n    read_requests: BoundedVec<SideEffect, MAX_READ_REQUESTS_PER_CALL>,\n    nullifier_key_validation_requests: BoundedVec<NullifierKeyValidationRequest, MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    new_commitments: BoundedVec<SideEffect, MAX_NEW_COMMITMENTS_PER_CALL>,\n    new_nullifiers: BoundedVec<SideEffectLinkedToNoteHash, MAX_NEW_NULLIFIERS_PER_CALL>,\n\n    private_call_stack_hashes : BoundedVec<Field, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    public_call_stack_hashes : BoundedVec<Field, MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL>,\n    new_l2_to_l1_msgs : BoundedVec<Field, MAX_NEW_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    historical_header: Header,\n\n    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n    // encrypted_logs_preimages: Vec<Field>,\n    // unencrypted_logs_preimages: Vec<Field>,\n\n    nullifier_key: Option<NullifierKeyPair>,\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs: inputs,\n            side_effect_counter: inputs.call_context.start_side_effect_counter,\n\n            args_hash: args_hash,\n            return_values: BoundedVec::new(0),\n\n            read_requests: BoundedVec::new(SideEffect::empty()),\n            nullifier_key_validation_requests: BoundedVec::new(NullifierKeyValidationRequest::empty()),\n\n            new_commitments: BoundedVec::new(SideEffect::empty()),\n            new_nullifiers: BoundedVec::new(SideEffectLinkedToNoteHash::empty()),\n\n            historical_header: inputs.historical_header,\n\n            private_call_stack_hashes: BoundedVec::new(0),\n            public_call_stack_hashes: BoundedVec::new(0),\n            new_l2_to_l1_msgs: BoundedVec::new(0),\n\n            // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n            // encrypted_logs_preimages: Vec::new(),\n            // unencrypted_logs_preimages: Vec::new(),\n\n            nullifier_key: Option::none(),\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.storage_contract_address\n    }\n\n    pub fn this_portal_address(self) -> EthAddress {\n        self.inputs.call_context.portal_contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.private_global_variables.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.private_global_variables.version\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    // Returns the header of a block whose state is used during private execution\n    pub fn get_header(self) -> Header {\n        self.historical_header\n    }\n\n    pub fn get_header_at(self, block_number: u32) -> Header {\n        get_header_at(block_number, self)\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n        let encrypted_logs_hash = [0; NUM_FIELDS_PER_SHA256];\n        let unencrypted_logs_hash = [0; NUM_FIELDS_PER_SHA256];\n        let encrypted_log_preimages_length = 0;\n        let unencrypted_log_preimages_length = 0;\n\n        let priv_circuit_pub_inputs = PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            return_values: self.return_values.storage,\n            read_requests: self.read_requests.storage,\n            nullifier_key_validation_requests: self.nullifier_key_validation_requests.storage,\n            new_commitments: self.new_commitments.storage,\n            new_nullifiers: self.new_nullifiers.storage,\n            private_call_stack_hashes: self.private_call_stack_hashes.storage,\n            public_call_stack_hashes: self.public_call_stack_hashes.storage,\n            new_l2_to_l1_msgs: self.new_l2_to_l1_msgs.storage,\n            end_side_effect_counter: self.side_effect_counter,\n            encrypted_logs_hash: encrypted_logs_hash,\n            unencrypted_logs_hash: unencrypted_logs_hash,\n            encrypted_log_preimages_length: encrypted_log_preimages_length,\n            unencrypted_log_preimages_length: unencrypted_log_preimages_length,\n            historical_header: self.historical_header,\n            contract_deployment_data: self.inputs.contract_deployment_data,\n            chain_id: self.inputs.private_global_variables.chain_id,\n            version: self.inputs.private_global_variables.version,\n        };\n        priv_circuit_pub_inputs\n    }\n\n    pub fn push_read_request(&mut self, read_request: Field) {\n        let side_effect = SideEffect {\n            value: read_request,\n            counter: self.side_effect_counter,\n        };\n        self.read_requests.push(side_effect);\n        self.side_effect_counter = self.side_effect_counter + 1;\n    }\n\n    pub fn push_new_note_hash(&mut self, note_hash: Field) {\n        let side_effect = SideEffect {\n            value: note_hash,\n            counter: self.side_effect_counter,\n        };\n        self.new_commitments.push(side_effect);\n        self.side_effect_counter = self.side_effect_counter + 1;\n    }\n\n    pub fn push_new_nullifier(&mut self, nullifier: Field, nullified_commitment: Field) {\n        let side_effect = SideEffectLinkedToNoteHash {\n            value: nullifier,\n            note_hash: nullified_commitment,\n            counter: self.side_effect_counter,\n        };\n        self.new_nullifiers.push(side_effect);\n        self.side_effect_counter = self.side_effect_counter + 1;\n    }\n\n    pub fn request_nullifier_secret_key(&mut self, account: AztecAddress) -> GrumpkinPrivateKey {\n        let key_pair = if self.nullifier_key.is_none() {\n            let key_pair = get_nullifier_key_pair(account);\n            validate_nullifier_key_against_address(account, key_pair.public_key);\n            let request = NullifierKeyValidationRequest { public_key: key_pair.public_key, secret_key: key_pair.secret_key };\n            self.nullifier_key_validation_requests.push(request);\n            self.nullifier_key = Option::some(key_pair);\n            key_pair\n        } else {\n            let key_pair = self.nullifier_key.unwrap_unchecked();\n            // If MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_CALL is larger than 1, need to update the way the key pair is cached.\n            assert(MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_CALL == 1);\n            assert(key_pair.account == account, \"Cannot query nullifier key for more than one account per call\");\n            key_pair\n        };\n        key_pair.secret_key\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, content: Field) \n    // docs:end:context_message_portal\n    {\n        self.new_l2_to_l1_msgs.push(content);\n    }\n\n    // PrivateContextInputs must be temporarily passed in to prevent too many unknowns\n    // Note this returns self to get around an issue where mutable structs do not maintain mutations unless reassigned\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        msg_key: Field,\n        content: Field,\n        secret: Field\n    ) \n    // docs:end:context_consume_l1_to_l2_message\n    {\n        let nullifier = process_l1_to_l2_message(self.historical_header.state.l1_to_l2_message_tree.root, self.this_address(), self.this_portal_address(), self.chain_id(), self.version(), msg_key, content, secret);\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_new_nullifier(nullifier, 0)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    pub fn accumulate_encrypted_logs<N>(&mut self, log: [Field; N]) {\n        let _void1 = self.inputs;\n        let _void2 = log;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n    }\n\n    pub fn accumulate_unencrypted_logs<T>(&mut self, log: T) {\n        let _void1 = self.inputs;\n        let _void2 = log;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n    }\n\n    pub fn call_private_function<ARGS_COUNT>(\n        &mut self,\n        contract_address: AztecAddress, \n        function_selector: FunctionSelector, \n        args: [Field; ARGS_COUNT]\n    ) -> [Field; RETURN_VALUES_LENGTH] {\n        let args_hash = hash_args(args);\n        assert(args_hash == arguments::pack_arguments(args));\n        self.call_private_function_with_packed_args(contract_address, function_selector, args_hash)\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress, \n        function_selector: FunctionSelector, \n    ) -> [Field; RETURN_VALUES_LENGTH] {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0)\n    }\n\n    pub fn call_private_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field\n    ) -> [Field; RETURN_VALUES_LENGTH] {\n        let fields = call_private_function_internal(\n            contract_address,\n            function_selector, \n            args_hash,\n            self.side_effect_counter,\n        );\n        let mut reader = Reader::new(fields);\n\n        let item = PrivateCallStackItem {\n            contract_address: AztecAddress::from_field(reader.read()),\n            function_data: FunctionData {\n                selector: FunctionSelector::from_field(reader.read()),\n                is_internal: reader.read() as bool,\n                is_private: reader.read() as bool,\n                is_constructor: reader.read() as bool,\n            },\n            public_inputs: PrivateCircuitPublicInputs {\n                call_context: CallContext {\n                    msg_sender : AztecAddress::from_field(reader.read()),\n                    storage_contract_address : AztecAddress::from_field(reader.read()),\n                    portal_contract_address : EthAddress::from_field(reader.read()),\n                    function_selector: FunctionSelector::from_field(reader.read()), // practically same as fields[1]\n                    is_delegate_call : reader.read() as bool,\n                    is_static_call : reader.read() as bool,\n                    is_contract_deployment: reader.read() as bool,\n                    start_side_effect_counter: reader.read() as u32,\n                },\n                args_hash: reader.read(),\n                return_values: reader.read_array([0; RETURN_VALUES_LENGTH]), // +1\n                read_requests: reader.read_struct_array(SideEffect::deserialise, [SideEffect::empty(); MAX_READ_REQUESTS_PER_CALL]),\n                nullifier_key_validation_requests: reader.read_struct_array(NullifierKeyValidationRequest::deserialise, [NullifierKeyValidationRequest::empty(); MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_CALL]),\n                new_commitments: reader.read_struct_array(SideEffect::deserialise, [SideEffect::empty(); MAX_NEW_COMMITMENTS_PER_CALL]),\n                new_nullifiers: reader.read_struct_array(SideEffectLinkedToNoteHash::deserialise, [SideEffectLinkedToNoteHash::empty(); MAX_NEW_NULLIFIERS_PER_CALL]),\n                private_call_stack_hashes: reader.read_array([0; MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL]),\n                public_call_stack_hashes: reader.read_array([0; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL]),\n                new_l2_to_l1_msgs: reader.read_array([0; MAX_NEW_L2_TO_L1_MSGS_PER_CALL]),\n                end_side_effect_counter: reader.read() as u32,\n                encrypted_logs_hash: reader.read_array([0; NUM_FIELDS_PER_SHA256]),\n                unencrypted_logs_hash: reader.read_array([0; NUM_FIELDS_PER_SHA256]),\n                encrypted_log_preimages_length: reader.read(),\n                unencrypted_log_preimages_length: reader.read(),\n                historical_header: reader.read_struct(Header::deserialize),\n                contract_deployment_data: ContractDeploymentData {\n                    deployer_public_key: GrumpkinPoint {\n                      x: reader.read(), \n                      y: reader.read()\n                    },\n                    constructor_vk_hash : reader.read(),\n                    function_tree_root : reader.read(),\n                    contract_address_salt : reader.read(),\n                    portal_contract_address : EthAddress::from_field(reader.read()),\n                },\n                chain_id: reader.read(),\n                version: reader.read(),\n            },\n            is_execution_request: reader.read() as bool,\n        };\n\n        reader.finish();\n\n        assert_eq(item.public_inputs.call_context.start_side_effect_counter, self.side_effect_counter);\n        self.side_effect_counter = item.public_inputs.end_side_effect_counter + 1;\n        \n        assert(contract_address.eq(item.contract_address));\n        assert(function_selector.eq(item.function_data.selector));\n\n        assert(args_hash == item.public_inputs.args_hash);\n\n        assert(item.is_execution_request == false);\n\n        // Assert that the call context of the enqueued call generated by the oracle matches our request.\n        // We are issuing a regular call which is not delegate, static, or deployment. We also constrain\n        // the msg_sender in the nested call to be equal to our address, and the execution context address\n        // for the nested call to be equal to the address we actually called.\n        assert(item.public_inputs.call_context.is_delegate_call == false);\n        assert(item.public_inputs.call_context.is_static_call == false);\n        assert(item.public_inputs.call_context.is_contract_deployment == false);\n        assert(item.public_inputs.call_context.msg_sender.eq(self.inputs.call_context.storage_contract_address));\n        assert(item.public_inputs.call_context.storage_contract_address.eq(contract_address));\n\n        self.private_call_stack_hashes.push(item.hash());\n\n        item.public_inputs.return_values\n    }\n\n    pub fn call_public_function<ARGS_COUNT>(\n        &mut self,\n        contract_address: AztecAddress, \n        function_selector: FunctionSelector, \n        args: [Field; ARGS_COUNT]\n    ) {\n        let args_hash = hash_args(args);\n        assert(args_hash == arguments::pack_arguments(args));\n        self.call_public_function_with_packed_args(contract_address, function_selector, args_hash)\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress, \n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0)\n    }\n\n    pub fn call_public_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field\n    ) {\n        let fields = enqueue_public_function_call_internal(\n            contract_address, \n            function_selector, \n            args_hash,\n            self.side_effect_counter\n        );\n\n        let mut reader = Reader::new(fields);\n\n        let item = PublicCallStackItem {\n            contract_address:  AztecAddress::from_field(reader.read()),\n            function_data: FunctionData {\n                selector: FunctionSelector::from_field(reader.read()),\n                is_internal: reader.read() as bool,\n                is_private: reader.read() as bool,\n                is_constructor: reader.read() as bool,\n            },\n            public_inputs: PublicCircuitPublicInputs {\n                call_context: CallContext {\n                    msg_sender : AztecAddress::from_field(reader.read()),\n                    storage_contract_address : AztecAddress::from_field(reader.read()),\n                    portal_contract_address : EthAddress::from_field(reader.read()),\n                    function_selector: FunctionSelector::from_field(reader.read()), // practically same as fields[1]\n                    is_delegate_call : reader.read() as bool,\n                    is_static_call : reader.read() as bool,\n                    is_contract_deployment: reader.read() as bool,\n                    start_side_effect_counter: reader.read() as u32,\n                },\n                args_hash: reader.read(),\n                return_values: [0; RETURN_VALUES_LENGTH],\n                contract_storage_update_requests: [StorageUpdateRequest::empty(); MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL],\n                contract_storage_reads: [StorageRead::empty(); MAX_PUBLIC_DATA_READS_PER_CALL],\n                public_call_stack_hashes: [0; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL],\n                new_commitments: [SideEffect::empty(); MAX_NEW_COMMITMENTS_PER_CALL],\n                new_nullifiers: [SideEffectLinkedToNoteHash::empty(); MAX_NEW_NULLIFIERS_PER_CALL],\n                new_l2_to_l1_msgs:[0; MAX_NEW_L2_TO_L1_MSGS_PER_CALL],\n                unencrypted_logs_hash:[0; NUM_FIELDS_PER_SHA256],\n                unencrypted_log_preimages_length: 0,\n                historical_header: Header::empty(),\n                prover_address: AztecAddress::zero(),\n            },\n            is_execution_request: true,\n        };\n        reader.finish();\n\n        assert(contract_address.eq(item.contract_address));\n        assert(function_selector.eq(item.function_data.selector));\n\n        assert_eq(item.public_inputs.call_context.start_side_effect_counter, self.side_effect_counter);\n        // We increment the sideffect counter by one, to account for the call itself being a side effect.\n        self.side_effect_counter = self.side_effect_counter + 1;\n        \n        assert(args_hash == item.public_inputs.args_hash);\n\n        // Assert that the call context of the enqueued call generated by the oracle matches our request.\n        // We are issuing a regular call which is not delegate, static, or deployment. We also constrain\n        // the msg_sender in the nested call to be equal to our address, and the execution context address\n        // for the nested call to be equal to the address we actually called.\n        assert(item.public_inputs.call_context.is_delegate_call == false);\n        assert(item.public_inputs.call_context.is_static_call == false);\n        assert(item.public_inputs.call_context.is_contract_deployment == false);\n        assert(item.public_inputs.call_context.msg_sender.eq(self.inputs.call_context.storage_contract_address));\n        assert(item.public_inputs.call_context.storage_contract_address.eq(contract_address));\n\n        self.public_call_stack_hashes.push(item.hash());\n    }\n}\n\nstruct PublicContext {\n    inputs: PublicContextInputs,\n    side_effect_counter: u32,\n\n    args_hash : Field,\n    return_values : BoundedVec<Field, RETURN_VALUES_LENGTH>,\n\n    contract_storage_update_requests: BoundedVec<StorageUpdateRequest, MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL>,\n    contract_storage_reads: BoundedVec<StorageRead, MAX_PUBLIC_DATA_READS_PER_CALL>,\n    public_call_stack_hashes: BoundedVec<Field, MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL>,\n\n    new_commitments: BoundedVec<SideEffect, MAX_NEW_COMMITMENTS_PER_CALL>,\n    new_nullifiers: BoundedVec<SideEffectLinkedToNoteHash, MAX_NEW_NULLIFIERS_PER_CALL>,\n\n    new_l2_to_l1_msgs: BoundedVec<Field, MAX_NEW_L2_TO_L1_MSGS_PER_CALL>,\n\n    unencrypted_logs_hash: BoundedVec<Field, NUM_FIELDS_PER_SHA256>,\n    unencrypted_logs_preimages_length: Field,\n\n    historical_header: Header,\n    prover_address: AztecAddress,\n}\n\nimpl PublicContext {\n    pub fn new(inputs: PublicContextInputs, args_hash: Field) -> PublicContext {\n        let empty_storage_read = StorageRead::empty();\n        let empty_storage_update = StorageUpdateRequest::empty();\n        PublicContext {\n            inputs: inputs,\n            side_effect_counter: inputs.call_context.start_side_effect_counter,\n\n            args_hash: args_hash,\n            return_values: BoundedVec::new(0),\n\n            contract_storage_update_requests: BoundedVec::new(empty_storage_update),\n            contract_storage_reads: BoundedVec::new(empty_storage_read),\n            public_call_stack_hashes: BoundedVec::new(0),\n\n            new_commitments: BoundedVec::new(SideEffect::empty()),\n            new_nullifiers: BoundedVec::new(SideEffectLinkedToNoteHash::empty()),\n\n            new_l2_to_l1_msgs: BoundedVec::new(0),\n\n            \n            unencrypted_logs_hash: BoundedVec::new(0),\n            unencrypted_logs_preimages_length: 0,\n\n            historical_header: inputs.historical_header,\n            prover_address: AztecAddress::zero(),\n\n            // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n            // encrypted_logs_preimages: Vec::new(),\n            // unencrypted_logs_preimages: Vec::new(),\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.storage_contract_address\n    }\n\n    pub fn this_portal_address(self) -> EthAddress {\n        self.inputs.call_context.portal_contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.public_global_variables.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.public_global_variables.version\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn block_number(self) -> Field {\n        self.inputs.public_global_variables.block_number\n    }\n\n    pub fn timestamp(self) -> Field {\n        self.inputs.public_global_variables.timestamp\n    }\n\n    pub fn finish(self) -> PublicCircuitPublicInputs {\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n        let unencrypted_logs_hash = [0; NUM_FIELDS_PER_SHA256];\n        let unencrypted_log_preimages_length = 0;\n\n\n        // Compute the public call stack hashes\n        let pub_circuit_pub_inputs = PublicCircuitPublicInputs {\n            call_context: self.inputs.call_context, // Done\n            args_hash: self.args_hash, // Done\n            contract_storage_update_requests: self.contract_storage_update_requests.storage,\n            contract_storage_reads: self.contract_storage_reads.storage,\n            return_values: self.return_values.storage,\n            new_commitments: self.new_commitments.storage,\n            new_nullifiers: self.new_nullifiers.storage,\n            public_call_stack_hashes: self.public_call_stack_hashes.storage,\n            new_l2_to_l1_msgs: self.new_l2_to_l1_msgs.storage,\n            unencrypted_logs_hash: unencrypted_logs_hash,\n            unencrypted_log_preimages_length: unencrypted_log_preimages_length,\n            historical_header: self.inputs.historical_header,\n            prover_address: self.prover_address,\n        };\n        pub_circuit_pub_inputs\n    }\n\n    pub fn push_new_note_hash(&mut self, note_hash: Field) {\n        let side_effect = SideEffect {\n            value: note_hash,\n            counter: self.side_effect_counter\n        };\n        self.new_commitments.push(side_effect);\n        self.side_effect_counter = self.side_effect_counter + 1;\n    }\n\n    pub fn push_new_nullifier(&mut self, nullifier: Field, _nullified_commitment: Field) {\n        let side_effect = SideEffectLinkedToNoteHash {\n            value: nullifier,\n            note_hash: 0, // cannot nullify pending notes in public context\n            counter: self.side_effect_counter\n        };\n        self.new_nullifiers.push(side_effect);\n        self.side_effect_counter = self.side_effect_counter + 1;\n    }\n\n    pub fn message_portal(&mut self, content: Field) {\n        self.new_l2_to_l1_msgs.push(content);\n    }\n\n    // PrivateContextInputs must be temporarily passed in to prevent too many unknowns\n    // Note this returns self to get around an issue where mutable structs do not maintain mutations unless reassigned\n    pub fn consume_l1_to_l2_message(&mut self, msg_key: Field, content: Field, secret: Field) {\n        let this = (*self).this_address();\n        let nullifier = process_l1_to_l2_message(self.historical_header.state.l1_to_l2_message_tree.root, this, self.this_portal_address(), self.chain_id(), self.version(), msg_key, content, secret);\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_new_nullifier(nullifier, 0)\n    }\n\n    pub fn accumulate_encrypted_logs<N>(&mut self, log: [Field; N]) {\n        let _void1 = self;\n        let _void2 = log;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n    }\n\n    pub fn accumulate_unencrypted_logs<T>(&mut self, log: T) {\n        let _void1 = self;\n        let _void2 = log;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n    }\n\n    pub fn call_public_function<ARGS_COUNT>(\n        _self: Self,\n        contract_address: AztecAddress, \n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> [Field; RETURN_VALUES_LENGTH] {\n        let args_hash = hash_args(args);\n        assert(args_hash == arguments::pack_arguments(args));\n        call_public_function_internal(\n            contract_address, \n            function_selector, \n            args_hash,\n        )\n    }\n\n    pub fn call_public_function_no_args(\n        _self: Self,\n        contract_address: AztecAddress, \n        function_selector: FunctionSelector,\n    ) -> [Field; RETURN_VALUES_LENGTH] {\n        call_public_function_internal(\n            contract_address, \n            function_selector, \n            0,\n        )\n    }\n\n}\n\nstruct Context {\n    private: Option<&mut PrivateContext>,\n    public: Option<&mut PublicContext>,\n}\n\nimpl Context {\n    pub fn private(context: &mut PrivateContext) -> Context {\n        Context {\n            private: Option::some(context),\n            public: Option::none()\n        }\n    }\n\n    pub fn public(context: &mut PublicContext) -> Context {\n        Context {\n            public: Option::some(context),\n            private: Option::none()\n        }\n    }\n\n    pub fn none() -> Context {\n        Context {\n            public: Option::none(),\n            private: Option::none()\n        }\n    }\n}\n",
+        "65": {
+            "source": "mod private;\nmod public;\nmod avm;\n\nuse public::PublicContext;\nuse private::PrivateContext;\nuse avm::AVMContext;\n\nstruct Context {\n    private: Option<&mut PrivateContext>,\n    public: Option<&mut PublicContext>,\n}\n\nimpl Context {\n    pub fn private(context: &mut PrivateContext) -> Context {\n        Context {\n            private: Option::some(context),\n            public: Option::none()\n        }\n    }\n\n    pub fn public(context: &mut PublicContext) -> Context {\n        Context {\n            public: Option::some(context),\n            private: Option::none()\n        }\n    }\n\n    pub fn none() -> Context {\n        Context {\n            public: Option::none(),\n            private: Option::none()\n        }\n    }\n}\n",
             "path": "/usr/src/yarn-project/aztec-nr/aztec/src/context.nr"
         },
-        "84": {
+        "81": {
             "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector,\n    address::AztecAddress,\n};\n\n// contract_address + \n// args_hash +\n// crate::abi::FUNCTION_DATA_SIZE +\n// crate::abi::CALL_CONTEXT_SIZE\n// = 2 + 4 + 8\nglobal ENQUEUE_PUBLIC_FUNCTION_CALL_RETURN_SIZE: Field = 14;\n\n#[oracle(enqueuePublicFunctionCall)]\nfn enqueue_public_function_call_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _side_effect_counter: u32\n) -> [Field; ENQUEUE_PUBLIC_FUNCTION_CALL_RETURN_SIZE] {}\n\nunconstrained pub fn enqueue_public_function_call_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    side_effect_counter: u32\n) -> [Field; ENQUEUE_PUBLIC_FUNCTION_CALL_RETURN_SIZE] {\n    enqueue_public_function_call_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        side_effect_counter\n    )\n}\n",
             "path": "/usr/src/yarn-project/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr"
         },
-        "91": {
-            "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector,\n    address::AztecAddress,\n    constants::CALL_PRIVATE_FUNCTION_RETURN_SIZE,\n};\n\n#[oracle(callPrivateFunction)]\nfn call_private_function_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _start_side_effect_counter: u32\n) -> [Field; CALL_PRIVATE_FUNCTION_RETURN_SIZE] {}\n\nunconstrained pub fn call_private_function_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    start_side_effect_counter: u32\n) -> [Field; CALL_PRIVATE_FUNCTION_RETURN_SIZE] {\n    call_private_function_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        start_side_effect_counter\n    )\n}\n",
+        "88": {
+            "source": "use dep::protocol_types::{\n    abis::{\n        function_selector::FunctionSelector,\n        private_call_stack_item::PrivateCallStackItem,\n    },\n    address::AztecAddress,\n    constants::PRIVATE_CALL_STACK_ITEM_LENGTH,\n};\n\n#[oracle(callPrivateFunction)]\nfn call_private_function_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _start_side_effect_counter: u32\n) -> [Field; PRIVATE_CALL_STACK_ITEM_LENGTH] {}\n\nunconstrained pub fn call_private_function_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    start_side_effect_counter: u32\n) -> PrivateCallStackItem {\n    let fields = call_private_function_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        start_side_effect_counter\n    );\n\n    PrivateCallStackItem::deserialize(fields)\n}\n",
             "path": "/usr/src/yarn-project/aztec-nr/aztec/src/oracle/call_private_function.nr"
         },
-        "97": {
-            "source": "#[oracle(storageRead)]\nfn storage_read_oracle<N>(_storage_slot: Field, _number_of_elements: Field) -> [Field; N] {}\n\nunconstrained fn storage_read_oracle_wrapper<N>(_storage_slot: Field) -> [Field; N] {\n    storage_read_oracle(_storage_slot, N)\n}\n\npub fn storage_read<T, N>(storage_slot: Field, deserialize: fn([Field; N]) -> T) -> T {\n    let fields = storage_read_oracle_wrapper(storage_slot);\n    deserialize(fields)\n}\n\n#[oracle(storageWrite)]\nfn storage_write_oracle<N>(_storage_slot: Field, _values: [Field; N]) -> [Field; N] {}\n\n// TODO: Remove return value.\nunconstrained pub fn storage_write<N>(storage_slot: Field, fields: [Field; N]) {\n    let _hash = storage_write_oracle(storage_slot, fields);\n}\n",
+        "94": {
+            "source": "use dep::protocol_types::traits::{Deserialize, Serialize};\n\n#[oracle(storageRead)]\nfn storage_read_oracle<N>(_storage_slot: Field, _number_of_elements: Field) -> [Field; N] {}\n\nunconstrained fn storage_read_oracle_wrapper<N>(_storage_slot: Field) -> [Field; N] {\n    storage_read_oracle(_storage_slot, N)\n}\n\npub fn storage_read<N>(storage_slot: Field) -> [Field; N] {\n    storage_read_oracle_wrapper(storage_slot)\n}\n\n#[oracle(storageWrite)]\nfn storage_write_oracle<N>(_storage_slot: Field, _values: [Field; N]) -> [Field; N] {}\n\nunconstrained pub fn storage_write<N>(storage_slot: Field, fields: [Field; N]) {\n    let _hash = storage_write_oracle(storage_slot, fields);\n}\n",
             "path": "/usr/src/yarn-project/aztec-nr/aztec/src/oracle/storage.nr"
         },
+        "99": {
+            "source": "use crate::{\n    abi::PublicContextInputs,\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        arguments,\n        public_call::call_public_function_internal,\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        global_variables::GlobalVariables,\n        function_selector::FunctionSelector,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        public_call_stack_item::PublicCallStackItem,\n        public_circuit_public_inputs::PublicCircuitPublicInputs,\n        side_effect::{SideEffect, SideEffectLinkedToNoteHash},\n    },\n    address::{\n        AztecAddress,\n        EthAddress,\n    },\n    constants::{\n        MAX_NEW_COMMITMENTS_PER_CALL,\n        MAX_NEW_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NEW_NULLIFIERS_PER_CALL,\n        MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,\n        MAX_PUBLIC_DATA_READS_PER_CALL,\n        MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,\n        MAX_READ_REQUESTS_PER_CALL,\n        NUM_FIELDS_PER_SHA256,\n        RETURN_VALUES_LENGTH,\n    },\n    contrakt::{\n        storage_read::StorageRead,\n        storage_update_request::StorageUpdateRequest,\n    },\n    hash::hash_args,\n    header::Header,\n    utils::reader::Reader,\n};\n\nstruct PublicContext {\n    inputs: PublicContextInputs,\n    side_effect_counter: u32,\n\n    args_hash : Field,\n    return_values : BoundedVec<Field, RETURN_VALUES_LENGTH>,\n\n    contract_storage_update_requests: BoundedVec<StorageUpdateRequest, MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL>,\n    contract_storage_reads: BoundedVec<StorageRead, MAX_PUBLIC_DATA_READS_PER_CALL>,\n    public_call_stack_hashes: BoundedVec<Field, MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL>,\n\n    new_commitments: BoundedVec<SideEffect, MAX_NEW_COMMITMENTS_PER_CALL>,\n    new_nullifiers: BoundedVec<SideEffectLinkedToNoteHash, MAX_NEW_NULLIFIERS_PER_CALL>,\n\n    new_l2_to_l1_msgs: BoundedVec<Field, MAX_NEW_L2_TO_L1_MSGS_PER_CALL>,\n\n    unencrypted_logs_hash: BoundedVec<Field, NUM_FIELDS_PER_SHA256>,\n    unencrypted_logs_preimages_length: Field,\n\n    // Header of a block whose state is used during public execution. Set by sequencer to be a header of a block\n    // previous to the one in which the tx is included.\n    historical_header: Header,\n    prover_address: AztecAddress,\n}\n\nimpl PublicContext {\n    pub fn new(inputs: PublicContextInputs, args_hash: Field) -> PublicContext {\n        let empty_storage_read = StorageRead::empty();\n        let empty_storage_update = StorageUpdateRequest::empty();\n        PublicContext {\n            inputs: inputs,\n            side_effect_counter: inputs.call_context.start_side_effect_counter,\n\n            args_hash: args_hash,\n            return_values: BoundedVec::new(0),\n\n            contract_storage_update_requests: BoundedVec::new(empty_storage_update),\n            contract_storage_reads: BoundedVec::new(empty_storage_read),\n            public_call_stack_hashes: BoundedVec::new(0),\n\n            new_commitments: BoundedVec::new(SideEffect::empty()),\n            new_nullifiers: BoundedVec::new(SideEffectLinkedToNoteHash::empty()),\n\n            new_l2_to_l1_msgs: BoundedVec::new(0),\n\n\n            unencrypted_logs_hash: BoundedVec::new(0),\n            unencrypted_logs_preimages_length: 0,\n\n            historical_header: inputs.historical_header,\n            prover_address: AztecAddress::zero(),\n\n            // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n            // encrypted_logs_preimages: Vec::new(),\n            // unencrypted_logs_preimages: Vec::new(),\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.storage_contract_address\n    }\n\n    pub fn this_portal_address(self) -> EthAddress {\n        self.inputs.call_context.portal_contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.public_global_variables.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.public_global_variables.version\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn block_number(self) -> Field {\n        self.inputs.public_global_variables.block_number\n    }\n\n    pub fn timestamp(self) -> Field {\n        self.inputs.public_global_variables.timestamp\n    }\n\n    pub fn coinbase(self) -> EthAddress {\n        self.inputs.public_global_variables.coinbase\n    }\n\n    pub fn fee_recipient(self) -> AztecAddress {\n        self.inputs.public_global_variables.fee_recipient\n    }\n\n    pub fn finish(self) -> PublicCircuitPublicInputs {\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n        let unencrypted_logs_hash = [0; NUM_FIELDS_PER_SHA256];\n        let unencrypted_log_preimages_length = 0;\n\n\n        // Compute the public call stack hashes\n        let pub_circuit_pub_inputs = PublicCircuitPublicInputs {\n            call_context: self.inputs.call_context, // Done\n            args_hash: self.args_hash, // Done\n            contract_storage_update_requests: self.contract_storage_update_requests.storage,\n            contract_storage_reads: self.contract_storage_reads.storage,\n            return_values: self.return_values.storage,\n            new_commitments: self.new_commitments.storage,\n            new_nullifiers: self.new_nullifiers.storage,\n            public_call_stack_hashes: self.public_call_stack_hashes.storage,\n            new_l2_to_l1_msgs: self.new_l2_to_l1_msgs.storage,\n            unencrypted_logs_hash: unencrypted_logs_hash,\n            unencrypted_log_preimages_length: unencrypted_log_preimages_length,\n            historical_header: self.inputs.historical_header,\n            prover_address: self.prover_address,\n        };\n        pub_circuit_pub_inputs\n    }\n\n    pub fn push_new_note_hash(&mut self, note_hash: Field) {\n        let side_effect = SideEffect {\n            value: note_hash,\n            counter: self.side_effect_counter\n        };\n        self.new_commitments.push(side_effect);\n        self.side_effect_counter = self.side_effect_counter + 1;\n    }\n\n    pub fn push_new_nullifier(&mut self, nullifier: Field, _nullified_commitment: Field) {\n        let side_effect = SideEffectLinkedToNoteHash {\n            value: nullifier,\n            note_hash: 0, // cannot nullify pending notes in public context\n            counter: self.side_effect_counter\n        };\n        self.new_nullifiers.push(side_effect);\n        self.side_effect_counter = self.side_effect_counter + 1;\n    }\n\n    pub fn message_portal(&mut self, content: Field) {\n        self.new_l2_to_l1_msgs.push(content);\n    }\n\n    // PrivateContextInputs must be temporarily passed in to prevent too many unknowns\n    // Note this returns self to get around an issue where mutable structs do not maintain mutations unless reassigned\n    pub fn consume_l1_to_l2_message(&mut self, msg_key: Field, content: Field, secret: Field) {\n        let this = (*self).this_address();\n        let nullifier = process_l1_to_l2_message(self.historical_header.state.l1_to_l2_message_tree.root, this, self.this_portal_address(), self.chain_id(), self.version(), msg_key, content, secret);\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_new_nullifier(nullifier, 0)\n    }\n\n    pub fn accumulate_encrypted_logs<N>(&mut self, log: [Field; N]) {\n        let _void1 = self;\n        let _void2 = log;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n    }\n\n    pub fn accumulate_unencrypted_logs<T>(&mut self, log: T) {\n        let _void1 = self;\n        let _void2 = log;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n    }\n\n    pub fn call_public_function<ARGS_COUNT>(\n        _self: Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> [Field; RETURN_VALUES_LENGTH] {\n        let args_hash = hash_args(args);\n        assert(args_hash == arguments::pack_arguments(args));\n        call_public_function_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n        )\n    }\n\n    pub fn call_public_function_no_args(\n        _self: Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> [Field; RETURN_VALUES_LENGTH] {\n        call_public_function_internal(\n            contract_address,\n            function_selector,\n            0,\n        )\n    }\n\n}\n",
+            "path": "/usr/src/yarn-project/aztec-nr/aztec/src/context/public.nr"
+        },
+        "100": {
+            "source": "use crate::{\n    abi::PrivateContextInputs,\n    key::nullifier_key::validate_nullifier_key_against_address,\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        arguments,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::enqueue_public_function_call_internal,\n        context::get_portal_address,\n        header::get_header_at,\n        nullifier_key::{get_nullifier_key_pair, NullifierKeyPair},\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_data::FunctionData,\n        function_selector::FunctionSelector,\n        nullifier_key_validation_request::NullifierKeyValidationRequest,\n        private_call_stack_item::PrivateCallStackItem,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        public_call_stack_item::PublicCallStackItem,\n        public_circuit_public_inputs::PublicCircuitPublicInputs,\n        side_effect::{SideEffect, SideEffectLinkedToNoteHash},\n    },\n    address::{\n        AztecAddress,\n        EthAddress,\n    },\n    constants::{\n        MAX_NEW_COMMITMENTS_PER_CALL,\n        MAX_NEW_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NEW_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL,\n        MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,\n        MAX_PUBLIC_DATA_READS_PER_CALL,\n        MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,\n        MAX_READ_REQUESTS_PER_CALL,\n        MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_CALL,\n        NUM_FIELDS_PER_SHA256,\n        RETURN_VALUES_LENGTH,\n    },\n    contract_class::ContractClassId,\n    contrakt::{\n        deployment_data::ContractDeploymentData,\n        storage_read::StorageRead,\n        storage_update_request::StorageUpdateRequest,\n    },\n    grumpkin_private_key::GrumpkinPrivateKey,\n    hash::hash_args,\n    header::Header,\n    utils::reader::Reader,\n};\nuse dep::std::option::Option;\n\n// TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n// use dep::std::collections::vec::Vec;\n\n// When finished, one can call .finish() to convert back to the abi\nstruct PrivateContext {\n    // docs:start:private-context\n    inputs: PrivateContextInputs,\n    side_effect_counter: u32,\n\n    meta_hwm: u32,\n\n    args_hash : Field,\n    return_values : BoundedVec<Field, RETURN_VALUES_LENGTH>,\n\n    read_requests: BoundedVec<SideEffect, MAX_READ_REQUESTS_PER_CALL>,\n    nullifier_key_validation_requests: BoundedVec<NullifierKeyValidationRequest, MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    new_commitments: BoundedVec<SideEffect, MAX_NEW_COMMITMENTS_PER_CALL>,\n    new_nullifiers: BoundedVec<SideEffectLinkedToNoteHash, MAX_NEW_NULLIFIERS_PER_CALL>,\n\n    private_call_stack_hashes : BoundedVec<Field, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    public_call_stack_hashes : BoundedVec<Field, MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL>,\n    new_l2_to_l1_msgs : BoundedVec<Field, MAX_NEW_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    historical_header: Header,\n\n    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n    // encrypted_logs_preimages: Vec<Field>,\n    // unencrypted_logs_preimages: Vec<Field>,\n\n    nullifier_key: Option<NullifierKeyPair>,\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs: inputs,\n            side_effect_counter: inputs.call_context.start_side_effect_counter,\n            meta_hwm: 0,\n\n            args_hash: args_hash,\n            return_values: BoundedVec::new(0),\n\n            read_requests: BoundedVec::new(SideEffect::empty()),\n            nullifier_key_validation_requests: BoundedVec::new(NullifierKeyValidationRequest::empty()),\n\n            new_commitments: BoundedVec::new(SideEffect::empty()),\n            new_nullifiers: BoundedVec::new(SideEffectLinkedToNoteHash::empty()),\n\n            historical_header: inputs.historical_header,\n\n            private_call_stack_hashes: BoundedVec::new(0),\n            public_call_stack_hashes: BoundedVec::new(0),\n            new_l2_to_l1_msgs: BoundedVec::new(0),\n\n            // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n            // encrypted_logs_preimages: Vec::new(),\n            // unencrypted_logs_preimages: Vec::new(),\n\n            nullifier_key: Option::none(),\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.storage_contract_address\n    }\n\n    pub fn this_portal_address(self) -> EthAddress {\n        self.inputs.call_context.portal_contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.private_global_variables.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.private_global_variables.version\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_header(self) -> Header {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_header_at(self, block_number: u32) -> Header {\n        get_header_at(block_number, self)\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n        let encrypted_logs_hash = [0; NUM_FIELDS_PER_SHA256];\n        let unencrypted_logs_hash = [0; NUM_FIELDS_PER_SHA256];\n        let encrypted_log_preimages_length = 0;\n        let unencrypted_log_preimages_length = 0;\n\n        let priv_circuit_pub_inputs = PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            return_values: self.return_values.storage,\n            meta_hwm: self.meta_hwm,\n            read_requests: self.read_requests.storage,\n            nullifier_key_validation_requests: self.nullifier_key_validation_requests.storage,\n            new_commitments: self.new_commitments.storage,\n            new_nullifiers: self.new_nullifiers.storage,\n            private_call_stack_hashes: self.private_call_stack_hashes.storage,\n            public_call_stack_hashes: self.public_call_stack_hashes.storage,\n            new_l2_to_l1_msgs: self.new_l2_to_l1_msgs.storage,\n            end_side_effect_counter: self.side_effect_counter,\n            encrypted_logs_hash: encrypted_logs_hash,\n            unencrypted_logs_hash: unencrypted_logs_hash,\n            encrypted_log_preimages_length: encrypted_log_preimages_length,\n            unencrypted_log_preimages_length: unencrypted_log_preimages_length,\n            historical_header: self.historical_header,\n            contract_deployment_data: self.inputs.contract_deployment_data,\n            chain_id: self.inputs.private_global_variables.chain_id,\n            version: self.inputs.private_global_variables.version,\n        };\n        priv_circuit_pub_inputs\n    }\n\n    pub fn push_read_request(&mut self, read_request: Field) {\n        let side_effect = SideEffect {\n            value: read_request,\n            counter: self.side_effect_counter,\n        };\n        self.read_requests.push(side_effect);\n        self.side_effect_counter = self.side_effect_counter + 1;\n    }\n\n    pub fn push_new_note_hash(&mut self, note_hash: Field) {\n        let side_effect = SideEffect {\n            value: note_hash,\n            counter: self.side_effect_counter,\n        };\n        self.new_commitments.push(side_effect);\n        self.side_effect_counter = self.side_effect_counter + 1;\n    }\n\n    pub fn push_new_nullifier(&mut self, nullifier: Field, nullified_commitment: Field) {\n        let side_effect = SideEffectLinkedToNoteHash {\n            value: nullifier,\n            note_hash: nullified_commitment,\n            counter: self.side_effect_counter,\n        };\n        self.new_nullifiers.push(side_effect);\n        self.side_effect_counter = self.side_effect_counter + 1;\n    }\n\n    pub fn request_nullifier_secret_key(&mut self, account: AztecAddress) -> GrumpkinPrivateKey {\n        let key_pair = if self.nullifier_key.is_none() {\n            let key_pair = get_nullifier_key_pair(account);\n            validate_nullifier_key_against_address(account, key_pair.public_key);\n            let request = NullifierKeyValidationRequest { public_key: key_pair.public_key, secret_key: key_pair.secret_key };\n            self.nullifier_key_validation_requests.push(request);\n            self.nullifier_key = Option::some(key_pair);\n            key_pair\n        } else {\n            let key_pair = self.nullifier_key.unwrap_unchecked();\n            // If MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_CALL is larger than 1, need to update the way the key pair is cached.\n            assert(MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_CALL == 1);\n            assert(key_pair.account == account, \"Cannot query nullifier key for more than one account per call\");\n            key_pair\n        };\n        key_pair.secret_key\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, content: Field)\n    // docs:end:context_message_portal\n    {\n        self.new_l2_to_l1_msgs.push(content);\n    }\n\n    // PrivateContextInputs must be temporarily passed in to prevent too many unknowns\n    // Note this returns self to get around an issue where mutable structs do not maintain mutations unless reassigned\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        msg_key: Field,\n        content: Field,\n        secret: Field\n    )\n    // docs:end:context_consume_l1_to_l2_message\n    {\n        let nullifier = process_l1_to_l2_message(self.historical_header.state.l1_to_l2_message_tree.root, self.this_address(), self.this_portal_address(), self.chain_id(), self.version(), msg_key, content, secret);\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_new_nullifier(nullifier, 0)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    pub fn accumulate_encrypted_logs<N>(&mut self, log: [Field; N]) {\n        let _void1 = self.inputs;\n        let _void2 = log;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n    }\n\n    pub fn accumulate_unencrypted_logs<T>(&mut self, log: T) {\n        let _void1 = self.inputs;\n        let _void2 = log;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n    }\n\n    pub fn call_private_function<ARGS_COUNT>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT]\n    ) -> [Field; RETURN_VALUES_LENGTH] {\n        let args_hash = hash_args(args);\n        assert(args_hash == arguments::pack_arguments(args));\n        self.call_private_function_with_packed_args(contract_address, function_selector, args_hash)\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> [Field; RETURN_VALUES_LENGTH] {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0)\n    }\n\n    pub fn call_private_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field\n    ) -> [Field; RETURN_VALUES_LENGTH] {\n        let item = call_private_function_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            self.side_effect_counter,\n        );\n\n        assert_eq(item.public_inputs.call_context.start_side_effect_counter, self.side_effect_counter);\n        self.side_effect_counter = item.public_inputs.end_side_effect_counter + 1;\n\n        assert(contract_address.eq(item.contract_address));\n        assert(function_selector.eq(item.function_data.selector));\n\n        assert(args_hash == item.public_inputs.args_hash);\n\n        // Assert that the call context of the enqueued call generated by the oracle matches our request.\n        // We are issuing a regular call which is not delegate, static, or deployment. We also constrain\n        // the msg_sender in the nested call to be equal to our address, and the execution context address\n        // for the nested call to be equal to the address we actually called.\n        assert(item.public_inputs.call_context.is_delegate_call == false);\n        assert(item.public_inputs.call_context.is_static_call == false);\n        assert(item.public_inputs.call_context.is_contract_deployment == false);\n        assert(item.public_inputs.call_context.msg_sender.eq(self.inputs.call_context.storage_contract_address));\n        assert(item.public_inputs.call_context.storage_contract_address.eq(contract_address));\n\n        self.private_call_stack_hashes.push(item.hash());\n\n        item.public_inputs.return_values\n    }\n\n    pub fn call_public_function<ARGS_COUNT>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT]\n    ) {\n        let args_hash = hash_args(args);\n        assert(args_hash == arguments::pack_arguments(args));\n        self.call_public_function_with_packed_args(contract_address, function_selector, args_hash)\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0)\n    }\n\n    pub fn call_public_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field\n    ) {\n        let fields = enqueue_public_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            self.side_effect_counter\n        );\n\n        let mut reader = Reader::new(fields);\n\n        // Note: Not using PublicCirclePublicInputs::deserialize here, because everything below args_hash is 0 and\n        // there is no more data in fields because there is only ENQUEUE_PUBLIC_FUNCTION_CALL_RETURN_SIZE fields!\n        let item = PublicCallStackItem {\n            contract_address:  AztecAddress::from_field(reader.read()),\n            function_data: reader.read_struct(FunctionData::deserialize),\n            public_inputs: PublicCircuitPublicInputs {\n                call_context: reader.read_struct(CallContext::deserialize),\n                args_hash: reader.read(),\n                return_values: [0; RETURN_VALUES_LENGTH],\n                contract_storage_update_requests: [StorageUpdateRequest::empty(); MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL],\n                contract_storage_reads: [StorageRead::empty(); MAX_PUBLIC_DATA_READS_PER_CALL],\n                public_call_stack_hashes: [0; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL],\n                new_commitments: [SideEffect::empty(); MAX_NEW_COMMITMENTS_PER_CALL],\n                new_nullifiers: [SideEffectLinkedToNoteHash::empty(); MAX_NEW_NULLIFIERS_PER_CALL],\n                new_l2_to_l1_msgs:[0; MAX_NEW_L2_TO_L1_MSGS_PER_CALL],\n                unencrypted_logs_hash:[0; NUM_FIELDS_PER_SHA256],\n                unencrypted_log_preimages_length: 0,\n                historical_header: Header::empty(),\n                prover_address: AztecAddress::zero(),\n            },\n            is_execution_request: true,\n        };\n        reader.finish();\n\n        assert(contract_address.eq(item.contract_address));\n        assert(function_selector.eq(item.function_data.selector));\n\n        assert_eq(item.public_inputs.call_context.start_side_effect_counter, self.side_effect_counter);\n        // We increment the sideffect counter by one, to account for the call itself being a side effect.\n        self.side_effect_counter = self.side_effect_counter + 1;\n\n        assert(args_hash == item.public_inputs.args_hash);\n\n        // Assert that the call context of the enqueued call generated by the oracle matches our request.\n        // We are issuing a regular call which is not delegate, static, or deployment. We also constrain\n        // the msg_sender in the nested call to be equal to our address, and the execution context address\n        // for the nested call to be equal to the address we actually called.\n        assert(item.public_inputs.call_context.is_delegate_call == false);\n        assert(item.public_inputs.call_context.is_static_call == false);\n        assert(item.public_inputs.call_context.is_contract_deployment == false);\n        assert(item.public_inputs.call_context.msg_sender.eq(self.inputs.call_context.storage_contract_address));\n        assert(item.public_inputs.call_context.storage_contract_address.eq(contract_address));\n\n        self.public_call_stack_hashes.push(item.hash());\n    }\n}\n",
+            "path": "/usr/src/yarn-project/aztec-nr/aztec/src/context/private.nr"
+        },
         "102": {
-            "source": "global ARGS_LENGTH: Field = 16;\nglobal RETURN_VALUES_LENGTH: Field = 4;\n\n/**\n * Convention for constant array lengths are mainly divided in 2 classes:\n *  - FUNCTION CALL\n *  - TRANSACTION\n *\n * Agreed convention is to use MAX_XXX_PER_CALL resp. MAX_XXX_PER_TX, where XXX denotes a type of element such as\n * commitment, or nullifier, e.g.,:\n *  - MAX_NEW_NULLIFIERS_PER_CALL\n *  - MAX_NEW_COMMITMENTS_PER_TX\n *\n * In the kernel circuits, we accumulate elements such as commitments and the nullifiers from all functions calls in a\n * transaction. Therefore, we always must have:\n * MAX_XXX_PER_TX ≥ MAX_XXX_PER_CALL\n *\n * For instance:\n * MAX_NEW_COMMITMENTS_PER_TX ≥ MAX_NEW_COMMITMENTS_PER_CALL\n * MAX_NEW_NULLIFIERS_PER_TX ≥ MAX_NEW_NULLIFIERS_PER_CALL\n *\n */\n\n// docs:start:constants\n// \"PER CALL\" CONSTANTS\nglobal MAX_NEW_COMMITMENTS_PER_CALL: Field = 16;\nglobal MAX_NEW_NULLIFIERS_PER_CALL: Field = 16;\nglobal MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL: Field = 4;\nglobal MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL: Field = 4;\nglobal MAX_NEW_L2_TO_L1_MSGS_PER_CALL: Field = 2;\nglobal MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL: Field = 16;\nglobal MAX_PUBLIC_DATA_READS_PER_CALL: Field = 16;\nglobal MAX_READ_REQUESTS_PER_CALL: Field = 32;\nglobal MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_CALL: Field = 1;\n\n// \"PER TRANSACTION\" CONSTANTS\nglobal MAX_NEW_COMMITMENTS_PER_TX: Field = 64;\nglobal MAX_NEW_NULLIFIERS_PER_TX: Field = 64;\nglobal MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX: Field = 8;\nglobal MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX: Field = 8;\nglobal MAX_NEW_L2_TO_L1_MSGS_PER_TX: Field = 2;\nglobal MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX: Field = 16;\nglobal MAX_PUBLIC_DATA_READS_PER_TX: Field = 16;\nglobal MAX_NEW_CONTRACTS_PER_TX: Field = 1;\nglobal MAX_OPTIONALLY_REVEALED_DATA_LENGTH_PER_TX: Field = 4;\nglobal MAX_READ_REQUESTS_PER_TX: Field = 128;\nglobal MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_TX: Field = 4;\nglobal NUM_ENCRYPTED_LOGS_HASHES_PER_TX: Field = 1;\nglobal NUM_UNENCRYPTED_LOGS_HASHES_PER_TX: Field = 1;\n// docs:end:constants\n\n// ROLLUP CONTRACT CONSTANTS - constants used only in l1-contracts\nglobal NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP: Field = 16;\n\n// TREES RELATED CONSTANTS\nglobal VK_TREE_HEIGHT: Field = 3;\nglobal FUNCTION_TREE_HEIGHT: Field = 5;\nglobal CONTRACT_TREE_HEIGHT: Field = 16;\nglobal NOTE_HASH_TREE_HEIGHT: Field = 32;\nglobal PUBLIC_DATA_TREE_HEIGHT: Field = 40;\nglobal NULLIFIER_TREE_HEIGHT: Field = 20;\nglobal L1_TO_L2_MSG_TREE_HEIGHT: Field = 16;\nglobal ROLLUP_VK_TREE_HEIGHT: Field = 8;\n\n// SUB-TREES RELATED CONSTANTS\nglobal CONTRACT_SUBTREE_HEIGHT: Field = 0;\nglobal CONTRACT_SUBTREE_SIBLING_PATH_LENGTH: Field = 16;\nglobal NOTE_HASH_SUBTREE_HEIGHT: Field = 6;\nglobal NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH: Field = 26;\nglobal NULLIFIER_SUBTREE_HEIGHT: Field = 6;\nglobal PUBLIC_DATA_SUBTREE_HEIGHT: Field = 4;\nglobal ARCHIVE_HEIGHT: Field = 16;\nglobal NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH: Field = 14;\nglobal PUBLIC_DATA_SUBTREE_SIBLING_PATH_LENGTH: Field = 36;\nglobal L1_TO_L2_MSG_SUBTREE_HEIGHT: Field = 4;\nglobal L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH: Field = 12;\n\n// MISC CONSTANTS\nglobal FUNCTION_SELECTOR_NUM_BYTES: Field = 4;\nglobal MAPPING_SLOT_PEDERSEN_SEPARATOR: Field = 4;\n// sha256 hash is stored in two fields to accommodate all 256-bits of the hash\nglobal NUM_FIELDS_PER_SHA256: Field = 2;\nglobal ARGS_HASH_CHUNK_LENGTH: u32 = 32;\nglobal ARGS_HASH_CHUNK_COUNT: u32 = 16;\n\n// NOIR CONSTANTS - constants used only in yarn-packages/noir-contracts\n// Some are defined here because Noir doesn't yet support globals referencing other globals yet.\n// Move these constants to a noir file once the issue bellow is resolved:\n// https://github.com/noir-lang/noir/issues/1734\nglobal L1_TO_L2_MESSAGE_LENGTH: Field = 8;\nglobal L1_TO_L2_MESSAGE_ORACLE_CALL_LENGTH: Field = 25;\nglobal MAX_NOTE_FIELDS_LENGTH: Field = 20;\n// GET_NOTE_ORACLE_RETURN_LENGT = MAX_NOTE_FIELDS_LENGTH + 1 + 2\n// The plus 1 is 1 extra field for nonce.\n// + 2 for EXTRA_DATA: [number_of_return_notes, contract_address]\nglobal GET_NOTE_ORACLE_RETURN_LENGTH: Field = 23;\nglobal MAX_NOTES_PER_PAGE: Field = 10;\n// VIEW_NOTE_ORACLE_RETURN_LENGTH = MAX_NOTES_PER_PAGE * (MAX_NOTE_FIELDS_LENGTH + 1) + 2;\nglobal VIEW_NOTE_ORACLE_RETURN_LENGTH: Field = 212;\nglobal CALL_CONTEXT_LENGTH: Field = 8;\nglobal HEADER_LENGTH: Field = 18; // 2 for last_archive, 2 for body hash, 10 for state reference, 4 for global vars \nglobal FUNCTION_DATA_LENGTH: Field = 4;\nglobal CONTRACT_DEPLOYMENT_DATA_LENGTH: Field = 6;\n// Change this ONLY if you have changed the PrivateCircuitPublicInputs structure.\n// In other words, if the structure/size of the public inputs of a function call changes then we should change this\n// constant as well CALL_PRIVATE_FUNCTION_RETURN_SIZE and PRIVATE_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH\nglobal PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH: Field = 200;\nglobal CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH: Field = 3;\nglobal CONTRACT_STORAGE_READ_LENGTH: Field = 2;\n// Change this ONLY if you have changed the PublicCircuitPublicInputs structure.\nglobal PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH: Field = 190;\nglobal GET_NOTES_ORACLE_RETURN_LENGTH: Field = 674;\nglobal CALL_PRIVATE_FUNCTION_RETURN_SIZE: Field = 210;\nglobal PUBLIC_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH: Field = 98;\nglobal PRIVATE_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH: Field = 188;\nglobal COMMITMENTS_NUM_BYTES_PER_BASE_ROLLUP: Field = 2048;\nglobal NULLIFIERS_NUM_BYTES_PER_BASE_ROLLUP: Field = 2048;\nglobal PUBLIC_DATA_WRITES_NUM_BYTES_PER_BASE_ROLLUP: Field = 1024;\nglobal CONTRACTS_NUM_BYTES_PER_BASE_ROLLUP: Field = 32;\nglobal CONTRACT_DATA_NUM_BYTES_PER_BASE_ROLLUP: Field = 64;\nglobal CONTRACT_DATA_NUM_BYTES_PER_BASE_ROLLUP_UNPADDED: Field = 52;\nglobal L2_TO_L1_MSGS_NUM_BYTES_PER_BASE_ROLLUP: Field = 64;\nglobal LOGS_HASHES_NUM_BYTES_PER_BASE_ROLLUP: Field = 64;\n\n/**\n * Enumerate the hash_indices which are used for pedersen hashing.\n * We start from 1 to avoid the default generators. The generator indices are listed\n * based on the number of elements each index hashes. The following conditions must be met:\n *\n * +-----------+-------------------------------+----------------------+\n * | Hash size | Number of elements hashed (n) | Condition to use     |\n * |-----------+-------------------------------+----------------------|\n * | LOW       | n ≤ 8                         | 0 < hash_index ≤ 32  |\n * | MID       | 8 < n ≤ 16                    | 32 < hash_index ≤ 40 |\n * | HIGH      | 16 < n ≤ 48                   | 40 < hash_index ≤ 48 |\n * +-----------+-------------------------------+----------------------+\n *\n * Note: When modifying, modify `GeneratorIndexPacker` in packer.hpp accordingly.\n */\n// Indices with size ≤ 8\nglobal GENERATOR_INDEX__COMMITMENT = 1;\nglobal GENERATOR_INDEX__COMMITMENT_NONCE = 2;\nglobal GENERATOR_INDEX__UNIQUE_COMMITMENT = 3;\nglobal GENERATOR_INDEX__SILOED_COMMITMENT = 4;\nglobal GENERATOR_INDEX__NULLIFIER = 5;\nglobal GENERATOR_INDEX__INITIALIZATION_NULLIFIER = 6;\nglobal GENERATOR_INDEX__OUTER_NULLIFIER = 7;\nglobal GENERATOR_INDEX__PUBLIC_DATA_READ = 8;\nglobal GENERATOR_INDEX__PUBLIC_DATA_UPDATE_REQUEST = 9;\nglobal GENERATOR_INDEX__FUNCTION_DATA = 10;\nglobal GENERATOR_INDEX__FUNCTION_LEAF = 11;\nglobal GENERATOR_INDEX__CONTRACT_DEPLOYMENT_DATA = 12;\nglobal GENERATOR_INDEX__CONSTRUCTOR = 13;\nglobal GENERATOR_INDEX__CONSTRUCTOR_ARGS = 14;\nglobal GENERATOR_INDEX__CONTRACT_ADDRESS = 15;\nglobal GENERATOR_INDEX__CONTRACT_LEAF = 16;\nglobal GENERATOR_INDEX__CALL_CONTEXT = 17;\nglobal GENERATOR_INDEX__CALL_STACK_ITEM = 18;\nglobal GENERATOR_INDEX__CALL_STACK_ITEM_2 = 19;\nglobal GENERATOR_INDEX__L1_TO_L2_MESSAGE_SECRET = 20;\nglobal GENERATOR_INDEX__L2_TO_L1_MSG = 21;\nglobal GENERATOR_INDEX__TX_CONTEXT = 22;\nglobal GENERATOR_INDEX__PUBLIC_LEAF_INDEX = 23;\nglobal GENERATOR_INDEX__PUBLIC_DATA_LEAF = 24;\nglobal GENERATOR_INDEX__SIGNED_TX_REQUEST = 25;\nglobal GENERATOR_INDEX__GLOBAL_VARIABLES = 26;\nglobal GENERATOR_INDEX__PARTIAL_ADDRESS = 27;\nglobal GENERATOR_INDEX__BLOCK_HASH = 28;\nglobal GENERATOR_INDEX__SIDE_EFFECT = 29;\n// Indices with size ≤ 16\nglobal GENERATOR_INDEX__TX_REQUEST = 33;\nglobal GENERATOR_INDEX__SIGNATURE_PAYLOAD = 34;\n// Indices with size ≤ 44\nglobal GENERATOR_INDEX__VK = 41;\nglobal GENERATOR_INDEX__PRIVATE_CIRCUIT_PUBLIC_INPUTS = 42;\nglobal GENERATOR_INDEX__PUBLIC_CIRCUIT_PUBLIC_INPUTS = 43;\nglobal GENERATOR_INDEX__FUNCTION_ARGS = 44;\n",
+            "source": "global ARGS_LENGTH: Field = 16;\nglobal RETURN_VALUES_LENGTH: Field = 4;\n\n/**\n * Convention for constant array lengths are mainly divided in 2 classes:\n *  - FUNCTION CALL\n *  - TRANSACTION\n *\n * Agreed convention is to use MAX_XXX_PER_CALL resp. MAX_XXX_PER_TX, where XXX denotes a type of element such as\n * commitment, or nullifier, e.g.,:\n *  - MAX_NEW_NULLIFIERS_PER_CALL\n *  - MAX_NEW_COMMITMENTS_PER_TX\n *\n * In the kernel circuits, we accumulate elements such as commitments and the nullifiers from all functions calls in a\n * transaction. Therefore, we always must have:\n * MAX_XXX_PER_TX ≥ MAX_XXX_PER_CALL\n *\n * For instance:\n * MAX_NEW_COMMITMENTS_PER_TX ≥ MAX_NEW_COMMITMENTS_PER_CALL\n * MAX_NEW_NULLIFIERS_PER_TX ≥ MAX_NEW_NULLIFIERS_PER_CALL\n *\n */\n\n// docs:start:constants\n// \"PER CALL\" CONSTANTS\nglobal MAX_NEW_COMMITMENTS_PER_CALL: Field = 16;\nglobal MAX_NEW_NULLIFIERS_PER_CALL: Field = 16;\nglobal MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL: Field = 4;\nglobal MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL: Field = 4;\nglobal MAX_NEW_L2_TO_L1_MSGS_PER_CALL: Field = 2;\nglobal MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL: Field = 16;\nglobal MAX_PUBLIC_DATA_READS_PER_CALL: Field = 16;\nglobal MAX_READ_REQUESTS_PER_CALL: Field = 32;\nglobal MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_CALL: Field = 1;\n\n// \"PER TRANSACTION\" CONSTANTS\nglobal MAX_NEW_COMMITMENTS_PER_TX: Field = 64;\nglobal MAX_NEW_NULLIFIERS_PER_TX: Field = 64;\nglobal MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX: Field = 8;\nglobal MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX: Field = 8;\nglobal MAX_NEW_L2_TO_L1_MSGS_PER_TX: Field = 2;\nglobal MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX: Field = 16;\nglobal MAX_PUBLIC_DATA_READS_PER_TX: Field = 16;\nglobal MAX_NEW_CONTRACTS_PER_TX: Field = 1;\nglobal MAX_READ_REQUESTS_PER_TX: Field = 128;\nglobal MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_TX: Field = 4;\nglobal NUM_ENCRYPTED_LOGS_HASHES_PER_TX: Field = 1;\nglobal NUM_UNENCRYPTED_LOGS_HASHES_PER_TX: Field = 1;\n\nglobal MAX_NEW_COMMITMENTS_PER_TX_META: Field = 8;\nglobal MAX_NEW_NULLIFIERS_PER_TX_META: Field = 8;\nglobal MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX_META: Field = 2;\n// docs:end:constants\n\n// ROLLUP CONTRACT CONSTANTS - constants used only in l1-contracts\nglobal NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP: Field = 16;\n\n// TREES RELATED CONSTANTS\nglobal VK_TREE_HEIGHT: Field = 3;\nglobal FUNCTION_TREE_HEIGHT: Field = 5;\nglobal CONTRACT_TREE_HEIGHT: Field = 16;\nglobal NOTE_HASH_TREE_HEIGHT: Field = 32;\nglobal PUBLIC_DATA_TREE_HEIGHT: Field = 40;\nglobal NULLIFIER_TREE_HEIGHT: Field = 20;\nglobal L1_TO_L2_MSG_TREE_HEIGHT: Field = 16;\nglobal ROLLUP_VK_TREE_HEIGHT: Field = 8;\nglobal ARTIFACT_FUNCTION_TREE_MAX_HEIGHT = 5;\n\n// SUB-TREES RELATED CONSTANTS\nglobal CONTRACT_SUBTREE_HEIGHT: Field = 0;\nglobal CONTRACT_SUBTREE_SIBLING_PATH_LENGTH: Field = 16;\nglobal NOTE_HASH_SUBTREE_HEIGHT: Field = 6;\nglobal NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH: Field = 26;\nglobal NULLIFIER_SUBTREE_HEIGHT: Field = 6;\nglobal PUBLIC_DATA_SUBTREE_HEIGHT: Field = 4;\nglobal ARCHIVE_HEIGHT: Field = 16;\nglobal NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH: Field = 14;\nglobal PUBLIC_DATA_SUBTREE_SIBLING_PATH_LENGTH: Field = 36;\nglobal L1_TO_L2_MSG_SUBTREE_HEIGHT: Field = 4;\nglobal L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH: Field = 12;\n\n// MISC CONSTANTS\nglobal FUNCTION_SELECTOR_NUM_BYTES: Field = 4;\nglobal MAPPING_SLOT_PEDERSEN_SEPARATOR: Field = 4;\n// sha256 hash is stored in two fields to accommodate all 256-bits of the hash\nglobal NUM_FIELDS_PER_SHA256: Field = 2;\nglobal ARGS_HASH_CHUNK_LENGTH: u32 = 32;\nglobal ARGS_HASH_CHUNK_COUNT: u32 = 32;\n\n// CONTRACT CLASS CONSTANTS\n// This should be around 8192 (assuming 2**15 instructions packed at 8 bytes each), \n// but it's reduced to speed up build times, otherwise the ClassRegisterer takes over 5 mins to compile.\n// We are not using 1024 so we can squeeze in a few more args to methods that consume packed public bytecode,\n// such as the ClassRegisterer.register, and still land below the 32 * 32 max args limit for hashing.\nglobal MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS: Field = 1000;\n// Bytecode size for private functions is per function, not for the entire contract.\n// Note that private functions bytecode includes a mix of acir and brillig.\nglobal MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS: Field = 500;\n// Same for unconstrained functions: the size is per function.\nglobal MAX_PACKED_BYTECODE_SIZE_PER_UNCONSTRAINED_FUNCTION_IN_FIELDS: Field = 500;\n// Since we are not yet emitting selectors we'll use this magic value to identify events emitted by the ClassRegisterer.\n// This is just a stopgap until we implement proper selectors.\n// sha224sum 'struct ContractClassRegistered {contract_class_id: ContractClassId, version: Field, artifact_hash: Field, private_functions_root: Field, packed_public_bytecode: [Field; MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS] }'\nglobal REGISTERER_CONTRACT_CLASS_REGISTERED_MAGIC_VALUE = 0x6999d1e02b08a447a463563453cb36919c9dd7150336fc7c4d2b52f8;\n// sha224sum 'struct ClassPrivateFunctionBroadcasted'\nglobal REGISTERER_PRIVATE_FUNCTION_BROADCASTED_MAGIC_VALUE = 0x1b70e95fde0b70adc30496b90a327af6a5e383e028e7a43211a07bcd;\n// sha224sum 'struct ClassUnconstrainedFunctionBroadcasted'\nglobal REGISTERER_UNCONSTRAINED_FUNCTION_BROADCASTED_MAGIC_VALUE = 0xe7af816635466f128568edb04c9fa024f6c87fb9010fdbffa68b3d99;\n\n// CONTRACT INSTANCE CONSTANTS\n// sha224sum 'struct ContractInstanceDeployed'\nglobal DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_MAGIC_VALUE = 0x85864497636cf755ae7bde03f267ce01a520981c21c3682aaf82a631;\n\n// NOIR CONSTANTS - constants used only in yarn-packages/noir-contracts\n// Some are defined here because Noir doesn't yet support globals referencing other globals yet.\n// Move these constants to a noir file once the issue below is resolved:\n// https://github.com/noir-lang/noir/issues/1734\nglobal L1_TO_L2_MESSAGE_LENGTH: Field = 8;\nglobal L1_TO_L2_MESSAGE_ORACLE_CALL_LENGTH: Field = 25;\nglobal MAX_NOTE_FIELDS_LENGTH: Field = 20;\n// GET_NOTE_ORACLE_RETURN_LENGT = MAX_NOTE_FIELDS_LENGTH + 1 + 2\n// The plus 1 is 1 extra field for nonce.\n// + 2 for EXTRA_DATA: [number_of_return_notes, contract_address]\nglobal GET_NOTE_ORACLE_RETURN_LENGTH: Field = 23;\nglobal MAX_NOTES_PER_PAGE: Field = 10;\n// VIEW_NOTE_ORACLE_RETURN_LENGTH = MAX_NOTES_PER_PAGE * (MAX_NOTE_FIELDS_LENGTH + 1) + 2;\nglobal VIEW_NOTE_ORACLE_RETURN_LENGTH: Field = 212;\nglobal CALL_CONTEXT_LENGTH: Field = 8;\nglobal GLOBAL_VARIABLES_LENGTH: Field = 6;\nglobal PARTIAL_STATE_REFERENCE_LENGTH: Field = 8;\nglobal STATE_REFERENCE_LENGTH: Field = 10; // 2 for snap + 8 for partial\nglobal HEADER_LENGTH: Field = 20; // 2 for last_archive, 2 for body hash, 10 for state reference, 6 for global vars \nglobal FUNCTION_DATA_LENGTH: Field = 4;\nglobal CONTRACT_DEPLOYMENT_DATA_LENGTH: Field = 6;\n// Change this ONLY if you have changed the PrivateCircuitPublicInputs structure.\n// In other words, if the structure/size of the public inputs of a function call changes then we should change this\n// constant as well PRIVATE_CALL_STACK_ITEM_LENGTH\nglobal PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH: Field = 207;\nglobal PRIVATE_CALL_STACK_ITEM_LENGTH: Field = 212;\nglobal CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH: Field = 3;\nglobal CONTRACT_STORAGE_READ_LENGTH: Field = 2;\n// Change this ONLY if you have changed the PublicCircuitPublicInputs structure.\nglobal PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH: Field = 203;\nglobal GET_NOTES_ORACLE_RETURN_LENGTH: Field = 674;\nglobal COMMITMENTS_NUM_BYTES_PER_BASE_ROLLUP: Field = 2048;\nglobal NULLIFIERS_NUM_BYTES_PER_BASE_ROLLUP: Field = 2048;\nglobal PUBLIC_DATA_WRITES_NUM_BYTES_PER_BASE_ROLLUP: Field = 1024;\nglobal CONTRACTS_NUM_BYTES_PER_BASE_ROLLUP: Field = 32;\nglobal CONTRACT_DATA_NUM_BYTES_PER_BASE_ROLLUP: Field = 64;\nglobal CONTRACT_DATA_NUM_BYTES_PER_BASE_ROLLUP_UNPADDED: Field = 52;\nglobal L2_TO_L1_MSGS_NUM_BYTES_PER_BASE_ROLLUP: Field = 64;\nglobal LOGS_HASHES_NUM_BYTES_PER_BASE_ROLLUP: Field = 64;\n\n/**\n * Enumerate the hash_indices which are used for pedersen hashing.\n * We start from 1 to avoid the default generators. The generator indices are listed\n * based on the number of elements each index hashes. The following conditions must be met:\n *\n * +-----------+-------------------------------+----------------------+\n * | Hash size | Number of elements hashed (n) | Condition to use     |\n * |-----------+-------------------------------+----------------------|\n * | LOW       | n ≤ 8                         | 0 < hash_index ≤ 32  |\n * | MID       | 8 < n ≤ 16                    | 32 < hash_index ≤ 40 |\n * | HIGH      | 16 < n ≤ 48                   | 40 < hash_index ≤ 48 |\n * +-----------+-------------------------------+----------------------+\n *\n * Note: When modifying, modify `GeneratorIndexPacker` in packer.hpp accordingly.\n */\n// Indices with size ≤ 8\nglobal GENERATOR_INDEX__COMMITMENT = 1;\nglobal GENERATOR_INDEX__COMMITMENT_NONCE = 2;\nglobal GENERATOR_INDEX__UNIQUE_COMMITMENT = 3;\nglobal GENERATOR_INDEX__SILOED_COMMITMENT = 4;\nglobal GENERATOR_INDEX__NULLIFIER = 5;\nglobal GENERATOR_INDEX__INITIALIZATION_NULLIFIER = 6;\nglobal GENERATOR_INDEX__OUTER_NULLIFIER = 7;\nglobal GENERATOR_INDEX__PUBLIC_DATA_READ = 8;\nglobal GENERATOR_INDEX__PUBLIC_DATA_UPDATE_REQUEST = 9;\nglobal GENERATOR_INDEX__FUNCTION_DATA = 10;\nglobal GENERATOR_INDEX__FUNCTION_LEAF = 11;\nglobal GENERATOR_INDEX__CONTRACT_DEPLOYMENT_DATA = 12;\nglobal GENERATOR_INDEX__CONSTRUCTOR = 13;\nglobal GENERATOR_INDEX__CONSTRUCTOR_ARGS = 14;\nglobal GENERATOR_INDEX__CONTRACT_ADDRESS = 15;\nglobal GENERATOR_INDEX__CONTRACT_LEAF = 16;\nglobal GENERATOR_INDEX__CALL_CONTEXT = 17;\nglobal GENERATOR_INDEX__CALL_STACK_ITEM = 18;\nglobal GENERATOR_INDEX__CALL_STACK_ITEM_2 = 19;\nglobal GENERATOR_INDEX__L1_TO_L2_MESSAGE_SECRET = 20;\nglobal GENERATOR_INDEX__L2_TO_L1_MSG = 21;\nglobal GENERATOR_INDEX__TX_CONTEXT = 22;\nglobal GENERATOR_INDEX__PUBLIC_LEAF_INDEX = 23;\nglobal GENERATOR_INDEX__PUBLIC_DATA_LEAF = 24;\nglobal GENERATOR_INDEX__SIGNED_TX_REQUEST = 25;\nglobal GENERATOR_INDEX__GLOBAL_VARIABLES = 26;\nglobal GENERATOR_INDEX__PARTIAL_ADDRESS = 27;\nglobal GENERATOR_INDEX__BLOCK_HASH = 28;\nglobal GENERATOR_INDEX__SIDE_EFFECT = 29;\n// Indices with size ≤ 16\nglobal GENERATOR_INDEX__TX_REQUEST = 33;\nglobal GENERATOR_INDEX__SIGNATURE_PAYLOAD = 34;\n// Indices with size ≤ 44\nglobal GENERATOR_INDEX__VK = 41;\nglobal GENERATOR_INDEX__PRIVATE_CIRCUIT_PUBLIC_INPUTS = 42;\nglobal GENERATOR_INDEX__PUBLIC_CIRCUIT_PUBLIC_INPUTS = 43;\nglobal GENERATOR_INDEX__FUNCTION_ARGS = 44;\n",
             "path": "/usr/src/yarn-project/noir-protocol-circuits/src/crates/types/src/constants.nr"
         },
         "103": {
-            "source": "use crate::{\n    abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot,\n    traits::Empty,\n};\n\nstruct PartialStateReference {\n    note_hash_tree: AppendOnlyTreeSnapshot,\n    nullifier_tree: AppendOnlyTreeSnapshot,\n    contract_tree: AppendOnlyTreeSnapshot,\n    public_data_tree: AppendOnlyTreeSnapshot,\n}\n\nglobal PARTIAL_STATE_REFERENCE_LENGTH: Field = 8; // APPEND_ONLY_TREE_SNAPSHOT_LENGTH * 4;\n\nimpl PartialStateReference {\n    pub fn eq(self, other: PartialStateReference) -> bool {\n        self.note_hash_tree.eq(other.note_hash_tree) &\n        self.nullifier_tree.eq(other.nullifier_tree) &\n        self.contract_tree.eq(other.contract_tree) &\n        self.public_data_tree.eq(other.public_data_tree)\n    }\n\n    pub fn serialize(self) -> [Field; PARTIAL_STATE_REFERENCE_LENGTH] {\n        let serialized_note_hash_tree = self.note_hash_tree.serialize();\n        let serialized_nullifier_tree = self.nullifier_tree.serialize();\n        let serialized_contract_tree = self.contract_tree.serialize();\n        let serialized_public_data_tree = self.public_data_tree.serialize();\n\n        [\n            serialized_note_hash_tree[0],\n            serialized_note_hash_tree[1],\n            serialized_nullifier_tree[0],\n            serialized_nullifier_tree[1],\n            serialized_contract_tree[0],\n            serialized_contract_tree[1],\n            serialized_public_data_tree[0],\n            serialized_public_data_tree[1],\n        ]\n    }\n\n    pub fn deserialize(serialized: [Field; PARTIAL_STATE_REFERENCE_LENGTH]) -> PartialStateReference {\n        PartialStateReference {\n            note_hash_tree: AppendOnlyTreeSnapshot::deserialize(\n                [serialized[0], serialized[1]]\n            ),\n            nullifier_tree: AppendOnlyTreeSnapshot::deserialize(\n                [serialized[2], serialized[3]]\n            ),\n            contract_tree: AppendOnlyTreeSnapshot::deserialize(\n                [serialized[4], serialized[5]]\n            ),\n            public_data_tree: AppendOnlyTreeSnapshot::deserialize(\n                [serialized[6], serialized[7]]\n            ),\n        }\n    }\n}\n\nimpl Empty for PartialStateReference {\n    fn empty() -> Self {\n        Self {\n            note_hash_tree: AppendOnlyTreeSnapshot::zero(),\n            nullifier_tree: AppendOnlyTreeSnapshot::zero(),\n            contract_tree: AppendOnlyTreeSnapshot::zero(),\n            public_data_tree: AppendOnlyTreeSnapshot::zero(),\n        }\n    }\n}\n",
+            "source": "use crate::{\n    abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot,\n    constants::PARTIAL_STATE_REFERENCE_LENGTH,\n    traits::{\n        Deserialize,\n        Empty,\n        Hash,\n        Serialize,\n    },\n};\n\nstruct PartialStateReference {\n    note_hash_tree: AppendOnlyTreeSnapshot,\n    nullifier_tree: AppendOnlyTreeSnapshot,\n    contract_tree: AppendOnlyTreeSnapshot,\n    public_data_tree: AppendOnlyTreeSnapshot,\n}\n\nimpl Eq for PartialStateReference {\n    fn eq(self, other: PartialStateReference) -> bool {\n        self.note_hash_tree.eq(other.note_hash_tree) &\n        self.nullifier_tree.eq(other.nullifier_tree) &\n        self.contract_tree.eq(other.contract_tree) &\n        self.public_data_tree.eq(other.public_data_tree)\n    }\n}\n\nimpl Serialize<PARTIAL_STATE_REFERENCE_LENGTH> for PartialStateReference {\n    fn serialize(self) -> [Field; PARTIAL_STATE_REFERENCE_LENGTH] {\n        let serialized_note_hash_tree = self.note_hash_tree.serialize();\n        let serialized_nullifier_tree = self.nullifier_tree.serialize();\n        let serialized_contract_tree = self.contract_tree.serialize();\n        let serialized_public_data_tree = self.public_data_tree.serialize();\n\n        [\n            serialized_note_hash_tree[0],\n            serialized_note_hash_tree[1],\n            serialized_nullifier_tree[0],\n            serialized_nullifier_tree[1],\n            serialized_contract_tree[0],\n            serialized_contract_tree[1],\n            serialized_public_data_tree[0],\n            serialized_public_data_tree[1],\n        ]\n    }\n}\n\nimpl Deserialize<PARTIAL_STATE_REFERENCE_LENGTH> for PartialStateReference {\n    fn deserialize(serialized: [Field; PARTIAL_STATE_REFERENCE_LENGTH]) -> PartialStateReference {\n        PartialStateReference {\n            note_hash_tree: AppendOnlyTreeSnapshot::deserialize(\n                [serialized[0], serialized[1]]\n            ),\n            nullifier_tree: AppendOnlyTreeSnapshot::deserialize(\n                [serialized[2], serialized[3]]\n            ),\n            contract_tree: AppendOnlyTreeSnapshot::deserialize(\n                [serialized[4], serialized[5]]\n            ),\n            public_data_tree: AppendOnlyTreeSnapshot::deserialize(\n                [serialized[6], serialized[7]]\n            ),\n        }\n    }\n}\n\nimpl Empty for PartialStateReference {\n    fn empty() -> Self {\n        Self {\n            note_hash_tree: AppendOnlyTreeSnapshot::zero(),\n            nullifier_tree: AppendOnlyTreeSnapshot::zero(),\n            contract_tree: AppendOnlyTreeSnapshot::zero(),\n            public_data_tree: AppendOnlyTreeSnapshot::zero(),\n        }\n    }\n}\n\n#[test]\nfn serialization_of_empty() {\n    let partial: PartialStateReference = dep::std::unsafe::zeroed();\n    let _serialized = partial.serialize();\n    let _deserialized = PartialStateReference::deserialize(_serialized);\n}\n",
             "path": "/usr/src/yarn-project/noir-protocol-circuits/src/crates/types/src/partial_state_reference.nr"
         },
         "104": {
-            "source": "use crate::{\n    abis::append_only_tree_snapshot::{\n        AppendOnlyTreeSnapshot,\n        APPEND_ONLY_TREE_SNAPSHOT_LENGTH,\n    },\n    partial_state_reference::{\n        PartialStateReference,\n        PARTIAL_STATE_REFERENCE_LENGTH,\n    },\n    traits::Empty,\n    utils::{\n        arr_copy_slice,\n        bounded_vec::BoundedVec,\n    },\n};\n\nstruct StateReference {\n    l1_to_l2_message_tree: AppendOnlyTreeSnapshot,\n    partial: PartialStateReference,\n}\n\nglobal STATE_REFERENCE_LENGTH: Field = 10; // 2 for snap + 8 for partial\n\nimpl StateReference {\n    fn eq(self, other: StateReference) -> bool {\n        self.l1_to_l2_message_tree.eq(other.l1_to_l2_message_tree) &\n        self.partial.eq(other.partial)\n    }\n\n    fn serialize(self) -> [Field; STATE_REFERENCE_LENGTH] {\n        let mut fields: BoundedVec<Field, STATE_REFERENCE_LENGTH> = BoundedVec::new(0);\n\n        fields.push_array(self.l1_to_l2_message_tree.serialize());\n        fields.push_array(self.partial.serialize());\n\n        fields.storage\n    }\n\n    fn deserialize(serialized: [Field; STATE_REFERENCE_LENGTH]) -> StateReference {\n        let mut offset = 0;\n\n        let l1_to_l2_message_tree_fields = arr_copy_slice(serialized, [0; APPEND_ONLY_TREE_SNAPSHOT_LENGTH], offset);\n        offset = offset + APPEND_ONLY_TREE_SNAPSHOT_LENGTH;\n\n        let partial_fields = arr_copy_slice(serialized, [0; PARTIAL_STATE_REFERENCE_LENGTH], offset);\n\n        StateReference {\n            l1_to_l2_message_tree: AppendOnlyTreeSnapshot::deserialize(l1_to_l2_message_tree_fields),\n            partial: PartialStateReference::deserialize(partial_fields),\n        }\n    }\n}\n\nimpl Empty for StateReference {\n    fn empty() -> Self {\n        Self {\n            l1_to_l2_message_tree: AppendOnlyTreeSnapshot::zero(),\n            partial: PartialStateReference::empty(),\n        }\n    }\n}\n",
+            "source": "use crate::{\n    abis::append_only_tree_snapshot::{\n        AppendOnlyTreeSnapshot,\n        APPEND_ONLY_TREE_SNAPSHOT_LENGTH,\n    },\n    constants::{\n        PARTIAL_STATE_REFERENCE_LENGTH,\n        STATE_REFERENCE_LENGTH,\n    },\n    partial_state_reference::PartialStateReference,\n    traits::{\n        Deserialize,\n        Empty,\n        Hash,\n        Serialize,\n    },\n    utils::{\n        arr_copy_slice,\n    },\n};\n\nstruct StateReference {\n    l1_to_l2_message_tree: AppendOnlyTreeSnapshot,\n    partial: PartialStateReference,\n}\n\nimpl Eq for StateReference {\n    fn eq(self, other: StateReference) -> bool {\n        self.l1_to_l2_message_tree.eq(other.l1_to_l2_message_tree) &\n        self.partial.eq(other.partial)\n    }\n}\n\nimpl Serialize<STATE_REFERENCE_LENGTH> for StateReference {\n    fn serialize(self) -> [Field; STATE_REFERENCE_LENGTH] {\n        let mut fields: BoundedVec<Field, STATE_REFERENCE_LENGTH> = BoundedVec::new(0);\n\n        fields.extend_from_array(self.l1_to_l2_message_tree.serialize());\n        fields.extend_from_array(self.partial.serialize());\n\n        fields.storage\n    }\n}\n\nimpl Deserialize<STATE_REFERENCE_LENGTH> for StateReference {\n    fn deserialize(serialized: [Field; STATE_REFERENCE_LENGTH]) -> StateReference {\n        let mut offset = 0;\n\n        let l1_to_l2_message_tree_fields = arr_copy_slice(serialized, [0; APPEND_ONLY_TREE_SNAPSHOT_LENGTH], offset);\n        offset = offset + APPEND_ONLY_TREE_SNAPSHOT_LENGTH;\n\n        let partial_fields = arr_copy_slice(serialized, [0; PARTIAL_STATE_REFERENCE_LENGTH], offset);\n\n        StateReference {\n            l1_to_l2_message_tree: AppendOnlyTreeSnapshot::deserialize(l1_to_l2_message_tree_fields),\n            partial: PartialStateReference::deserialize(partial_fields),\n        }\n    }\n}\n\nimpl Empty for StateReference {\n    fn empty() -> Self {\n        Self {\n            l1_to_l2_message_tree: AppendOnlyTreeSnapshot::zero(),\n            partial: PartialStateReference::empty(),\n        }\n    }\n}\n\n#[test]\nfn serialization_of_empty() {\n    let state: StateReference = dep::std::unsafe::zeroed();\n    let _serialized = state.serialize();\n    let _deserialized = StateReference::deserialize(_serialized);\n}\n",
             "path": "/usr/src/yarn-project/noir-protocol-circuits/src/crates/types/src/state_reference.nr"
         },
         "107": {
-            "source": "use crate::{\n    abis::{\n        append_only_tree_snapshot::{\n            AppendOnlyTreeSnapshot,\n            APPEND_ONLY_TREE_SNAPSHOT_LENGTH,\n        },\n        global_variables::{\n            GlobalVariables,\n            GLOBAL_VARIABLES_LENGTH,\n        },\n    },\n    constants::{\n        GENERATOR_INDEX__BLOCK_HASH,\n        HEADER_LENGTH,\n        NUM_FIELDS_PER_SHA256,\n    },\n    hash::pedersen_hash,\n    state_reference::{\n        StateReference,\n        STATE_REFERENCE_LENGTH,\n    },\n    traits::Empty,\n    utils::{\n        arr_copy_slice,\n        bounded_vec::BoundedVec,\n    },\n};\n\n// docs:start:header\nstruct Header {\n    last_archive: AppendOnlyTreeSnapshot,\n    body_hash: [Field; NUM_FIELDS_PER_SHA256],\n    state: StateReference,\n    global_variables: GlobalVariables,\n}\n// docs:end:header\n\nimpl Header {\n\n    pub fn serialize(self) -> [Field; HEADER_LENGTH] {\n        let mut fields: BoundedVec<Field, HEADER_LENGTH> = BoundedVec::new(0);\n\n        fields.push_array(self.last_archive.serialize());\n        fields.push_array(self.body_hash);\n        fields.push_array(self.state.serialize());\n        fields.push_array(self.global_variables.serialize());\n\n        fields.storage\n    }\n\n    pub fn deserialize(serialized: [Field; HEADER_LENGTH]) -> Self {\n        let mut offset = 0;\n\n        let last_archive_fields = arr_copy_slice(serialized, [0; APPEND_ONLY_TREE_SNAPSHOT_LENGTH], offset);\n        offset = offset + APPEND_ONLY_TREE_SNAPSHOT_LENGTH;\n\n        let body_hash = arr_copy_slice(serialized, [0; NUM_FIELDS_PER_SHA256], offset);\n        offset = offset + NUM_FIELDS_PER_SHA256;\n\n        let state_fields = arr_copy_slice(serialized, [0; STATE_REFERENCE_LENGTH], offset);\n        offset = offset + STATE_REFERENCE_LENGTH;\n\n        let global_variables_fields = arr_copy_slice(serialized, [0; GLOBAL_VARIABLES_LENGTH], offset);\n\n        Header {\n            last_archive: AppendOnlyTreeSnapshot::deserialize(last_archive_fields),\n            body_hash,\n            state: StateReference::deserialize(state_fields),\n            global_variables: GlobalVariables::deserialize(global_variables_fields),\n        }\n    }\n\n    // TODO(#3941) Rename this as hash() and make it hash the whole header\n    pub fn block_hash(self) -> Field {\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/3595)\n        pedersen_hash([\n            self.global_variables.hash(),\n            self.state.partial.note_hash_tree.root,\n            self.state.partial.nullifier_tree.root,\n            self.state.partial.contract_tree.root,\n            self.state.l1_to_l2_message_tree.root,\n            self.state.partial.public_data_tree.root,\n        ], GENERATOR_INDEX__BLOCK_HASH)\n    }\n}\n\nimpl Empty for Header {\n    fn empty() -> Self {\n        Self {\n            last_archive: AppendOnlyTreeSnapshot::zero(),\n            body_hash: [0; NUM_FIELDS_PER_SHA256],\n            state: StateReference::empty(),\n            global_variables: GlobalVariables::empty(),\n        }\n    }\n}\n",
+            "source": "use crate::{\n    abis::{\n        append_only_tree_snapshot::{\n            AppendOnlyTreeSnapshot,\n            APPEND_ONLY_TREE_SNAPSHOT_LENGTH,\n        },\n        global_variables::{\n            GlobalVariables,\n            GLOBAL_VARIABLES_LENGTH,\n        },\n    },\n    constants::{\n        GENERATOR_INDEX__BLOCK_HASH,\n        HEADER_LENGTH,\n        NUM_FIELDS_PER_SHA256,\n        STATE_REFERENCE_LENGTH,\n    },\n    hash::pedersen_hash,\n    state_reference::StateReference,\n    traits::{\n        Deserialize,\n        Empty,\n        Hash,\n        Serialize,\n    },\n    utils::{\n        arr_copy_slice,\n    },\n};\n\n// docs:start:header\nstruct Header {\n    last_archive: AppendOnlyTreeSnapshot,\n    body_hash: [Field; NUM_FIELDS_PER_SHA256],\n    state: StateReference,\n    global_variables: GlobalVariables,\n}\n// docs:end:header\n\nimpl Eq for Header {\n    fn eq(self, other: Self) -> bool {\n        self.last_archive.eq(other.last_archive) &\n        (self.body_hash == other.body_hash) &\n        self.state.eq(other.state) &\n        self.global_variables.eq(other.global_variables)\n    }\n}\n\nimpl Serialize<HEADER_LENGTH> for Header {\n    fn serialize(self) -> [Field; HEADER_LENGTH] {\n        let mut fields: BoundedVec<Field, HEADER_LENGTH> = BoundedVec::new(0);\n\n        fields.extend_from_array(self.last_archive.serialize());\n        fields.extend_from_array(self.body_hash);\n        fields.extend_from_array(self.state.serialize());\n        fields.extend_from_array(self.global_variables.serialize());\n\n        fields.storage\n    }\n}\n\nimpl Deserialize<HEADER_LENGTH> for Header {\n    fn deserialize(serialized: [Field; HEADER_LENGTH]) -> Self {\n        let mut offset = 0;\n\n        let last_archive_fields = arr_copy_slice(serialized, [0; APPEND_ONLY_TREE_SNAPSHOT_LENGTH], offset);\n        offset = offset + APPEND_ONLY_TREE_SNAPSHOT_LENGTH;\n\n        let body_hash = arr_copy_slice(serialized, [0; NUM_FIELDS_PER_SHA256], offset);\n        offset = offset + NUM_FIELDS_PER_SHA256;\n\n        let state_fields = arr_copy_slice(serialized, [0; STATE_REFERENCE_LENGTH], offset);\n        offset = offset + STATE_REFERENCE_LENGTH;\n\n        let global_variables_fields = arr_copy_slice(serialized, [0; GLOBAL_VARIABLES_LENGTH], offset);\n\n        Header {\n            last_archive: AppendOnlyTreeSnapshot::deserialize(last_archive_fields),\n            body_hash,\n            state: StateReference::deserialize(state_fields),\n            global_variables: GlobalVariables::deserialize(global_variables_fields),\n        }\n    }\n}\n\nimpl Empty for Header {\n    fn empty() -> Self {\n        Self {\n            last_archive: AppendOnlyTreeSnapshot::zero(),\n            body_hash: [0; NUM_FIELDS_PER_SHA256],\n            state: StateReference::empty(),\n            global_variables: GlobalVariables::empty(),\n        }\n    }\n}\n\nimpl Hash for Header {\n    fn hash(self) -> Field {\n        pedersen_hash(self.serialize(), GENERATOR_INDEX__BLOCK_HASH)\n    }\n}\n\n#[test]\nfn serialization_of_empty() {\n    let header: Header = dep::std::unsafe::zeroed();\n    let serialized = header.serialize();\n    let deserialized = Header::deserialize(serialized);\n    assert(header.eq(deserialized));\n}\n\n#[test]\nfn hash_smoke() {\n    let header: Header = dep::std::unsafe::zeroed();\n    let _hashed = header.hash();\n}\n",
             "path": "/usr/src/yarn-project/noir-protocol-circuits/src/crates/types/src/header.nr"
         },
         "108": {
-            "source": "use crate::address::{AztecAddress, EthAddress};\nuse crate::mocked::VerificationKey;\nuse crate::abis::function_selector::FunctionSelector;\nuse crate::abis::function_leaf_preimage::FunctionLeafPreimage;\nuse crate::abis::new_contract_data::NewContractData as ContractLeafPreimage;\nuse crate::abis::function_data::FunctionData;\nuse crate::abis::side_effect::{SideEffect};\nuse crate::utils::uint256::U256;\nuse crate::utils::bounded_vec::BoundedVec;\nuse crate::constants::{\n        ARGS_HASH_CHUNK_COUNT,\n        ARGS_HASH_CHUNK_LENGTH,\n        CONTRACT_TREE_HEIGHT, \n        FUNCTION_TREE_HEIGHT, \n        NOTE_HASH_TREE_HEIGHT,\n        NUM_FIELDS_PER_SHA256,\n        GENERATOR_INDEX__SILOED_COMMITMENT,\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__VK,\n        GENERATOR_INDEX__CONSTRUCTOR,\n        GENERATOR_INDEX__PARTIAL_ADDRESS,\n        GENERATOR_INDEX__CONTRACT_ADDRESS,\n        GENERATOR_INDEX__COMMITMENT_NONCE,\n        GENERATOR_INDEX__UNIQUE_COMMITMENT,\n        GENERATOR_INDEX__FUNCTION_ARGS,\n};\n\nuse dep::std::hash::{pedersen_hash_with_separator, sha256};\n\npub fn sha256_to_field<N>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = sha256(bytes_to_hash);\n\n    // Convert it to a field element\n    let mut v = 1;\n    let mut high = 0 as Field;\n    let mut low = 0 as Field;\n\n    for i in 0..16 {\n        high = high + (sha256_hashed[15 - i] as Field) * v;\n        low = low + (sha256_hashed[16 + 15 - i] as Field) * v;\n        v = v * 256;\n    }\n\n    // Abuse that a % p + b % p = (a + b) % p and that low < p\n    let hash_in_a_field = low + high * v;\n\n    hash_in_a_field\n}\n\npub fn hash_args<N>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        let mut chunks_hashes = [0; ARGS_HASH_CHUNK_COUNT];\n        for i in 0..ARGS_HASH_CHUNK_COUNT {\n            let mut chunk_hash = 0;\n            let start_chunk_index = i * ARGS_HASH_CHUNK_LENGTH;\n            if start_chunk_index < (args.len() as u32) {\n                let mut chunk_args = [0; ARGS_HASH_CHUNK_LENGTH];\n                for j in 0..ARGS_HASH_CHUNK_LENGTH {\n                    let item_index = i * ARGS_HASH_CHUNK_LENGTH + j;\n                    if item_index < (args.len() as u32) {\n                        chunk_args[j] = args[item_index];\n                    }\n                }\n                chunk_hash = pedersen_hash(chunk_args, GENERATOR_INDEX__FUNCTION_ARGS);\n            }\n            chunks_hashes[i] = chunk_hash;\n        }\n        pedersen_hash(chunks_hashes, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\n// Checks that `value` is a member of a merkle tree with root `root` at position `index`\n// The witness being the `sibling_path`\npub fn assert_check_membership<N>(value: Field, index: Field, sibling_path: [Field; N], root: Field) {\n    let calculated_root = root_from_sibling_path(value, index, sibling_path);\n    assert(calculated_root == root, \"membership check failed\");\n}\n\n// Calculate the Merkle tree root from the sibling path and leaf.\n//\n// The leaf is hashed with its sibling, and then the result is hashed\n// with the next sibling etc in the path. The last hash is the root.\n//\n// TODO(David/Someone): The cpp code is using a uint256, whereas its\n// TODO a bit simpler in Noir to just have a bit array.\n// TODO: I'd generally like to avoid u256 for algorithms like \n// this because it means we never even need to consider cases where \n// the index is greater than p.\npub fn root_from_sibling_path<N>(leaf: Field, leaf_index: Field, sibling_path: [Field; N]) -> Field {\n    let mut node = leaf;\n    let indices = leaf_index.to_le_bits(N);\n\n    for i in 0..N {\n        let (hash_left, hash_right) = if indices[i] == 1 {\n            (sibling_path[i], node)\n        } else {\n            (node, sibling_path[i])\n        };\n        node = merkle_hash(hash_left, hash_right);\n    }\n    node\n}\n\n// Calculate the function tree root from the sibling path and leaf preimage.\n//\n// TODO: The cpp code passes in components of the FunctionLeafPreimage and then \n// builds it up. We should build it up and then pass the leaf preimage as a parameter.\n// We can then choose to have a general method that takes in anything hashable\n// and deduplicate the logic in `contract_tree_root_from_siblings`\npub fn function_tree_root_from_siblings(\n    selector: FunctionSelector,\n    is_internal: bool,\n    is_private: bool,\n    vk_hash: Field,\n    acir_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT]\n) -> Field {\n    let function_leaf_preimage = FunctionLeafPreimage { selector, is_internal, is_private, vk_hash, acir_hash };\n\n    let function_leaf = function_leaf_preimage.hash();\n\n    let function_tree_root = root_from_sibling_path(function_leaf, function_leaf_index, function_leaf_sibling_path);\n\n    function_tree_root\n}\n\n// Calculate the contract tree root from the sibling path and leaf preimage.\npub fn contract_tree_root_from_siblings(\n    function_tree_root: Field,\n    storage_contract_address: AztecAddress,\n    portal_contract_address: EthAddress,\n    contract_leaf_index: Field,\n    contract_leaf_sibling_path: [Field; CONTRACT_TREE_HEIGHT]\n) -> Field {\n    //TODO(Kev): if we use shorthand syntax here, we get an error as expected,\n    // since variable name is `storage_contract_address` but the span is incorrect.\n    let contract_leaf_preimage = ContractLeafPreimage { contract_address: storage_contract_address, portal_contract_address, function_tree_root };\n\n    let contract_leaf = contract_leaf_preimage.hash();\n\n    let computed_contract_tree_root = root_from_sibling_path(contract_leaf, contract_leaf_index, contract_leaf_sibling_path);\n\n    computed_contract_tree_root\n}\n\npub fn read_request_root_from_siblings(\n    read_request: Field,\n    leaf_index: Field,\n    sibling_path: [Field; NOTE_HASH_TREE_HEIGHT]\n) -> Field {\n    root_from_sibling_path(read_request, leaf_index, sibling_path)\n}\n\npub fn silo_commitment(address: AztecAddress, inner_commitment: Field) -> Field {\n    pedersen_hash(\n        [\n        address.to_field(),\n        inner_commitment\n    ],\n        GENERATOR_INDEX__SILOED_COMMITMENT\n    )\n}\n\npub fn silo_nullifier(address: AztecAddress, nullifier: Field) -> Field {\n    pedersen_hash(\n        [\n        address.to_field(),\n        nullifier\n    ],\n        GENERATOR_INDEX__OUTER_NULLIFIER\n    )\n}\n\nfn merkle_hash(left: Field, right: Field) -> Field {\n    pedersen_hash([left, right], 0)\n}\n\npub fn stdlib_recursion_verification_key_compress_native_vk(_vk: VerificationKey) -> Field {\n    // Original cpp code\n    // stdlib::recursion::verification_key<CT::bn254>::compress_native(private_call.vk, GeneratorIndex::VK);\n    // The above cpp method is only ever called on verification key, so it has been special cased here\n    let _hash_index = GENERATOR_INDEX__VK;\n    0\n}\n\n// TODO CPP uses blake2s for this\npub fn compute_new_contract_address_hash(new_contract_address: AztecAddress) -> Field {\n    dep::std::hash::pedersen_hash([new_contract_address.to_field()])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    rollup_version_id: Field,\n    portal_contract_address: EthAddress,\n    chain_id: Field,\n    content: Field\n) -> Field {\n    let mut bytes: BoundedVec<u8, 160> = BoundedVec::new(0);\n\n    let inputs = [\n        contract_address.to_field(), rollup_version_id, portal_contract_address.to_field(), chain_id, content\n    ];\n    for i in 0..inputs.len() {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes = inputs[i].to_be_bytes(32);\n        for j in 0..32 {\n            bytes.push(item_bytes[j]);\n        }\n    }\n\n    sha256_to_field(bytes.storage)\n}\n\npub fn compute_constructor_hash(\n    function_data: FunctionData,\n    args_hash: Field,\n    constructor_vk_hash: Field\n) -> Field {\n    let function_data_hash = function_data.hash();\n\n    pedersen_hash(\n        [\n        function_data_hash,\n        args_hash,\n        constructor_vk_hash\n    ],\n        GENERATOR_INDEX__CONSTRUCTOR\n    )\n}\n\n// Computes sha256 hash of 2 input hashes stored in 4 fields.\n// \n// This method is bn254 specific. Two fields is needed in order to \n// encode the sha256 output. It can be abstracted away with any 4-2 hash function.\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//\n// Returning a Field would be desirable because then this can be replaced with \n// poseidon without changing the rest of the code\n//\npub fn accumulate_sha256(input: [U128; 4]) -> [Field; NUM_FIELDS_PER_SHA256] {\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    //\n    // Concatenate 4 u128 bit integers into a byte array.\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..4 {\n        let input_as_bytes = input[offset].to_be_bytes();\n        for byte_index in 0..16 {\n            hash_input_flattened[offset * 16 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    let sha_digest = dep::std::hash::sha256(hash_input_flattened);\n\n    U256::from_bytes32(sha_digest).to_u128_limbs()\n}\n\npub fn compute_logs_hash(\n    previous_log_hash: [Field; 2],\n    current_log_hash: [Field; 2]\n) -> [Field; NUM_FIELDS_PER_SHA256] {\n    accumulate_sha256(\n        [\n        U128::from_integer(previous_log_hash[0]),\n        U128::from_integer(previous_log_hash[1]),\n        U128::from_integer(current_log_hash[0]),\n        U128::from_integer(current_log_hash[1])\n    ]\n    )\n}\n\npub fn compute_commitment_nonce(first_nullifier: Field, commitment_index: Field) -> Field {\n    pedersen_hash(\n        [\n        first_nullifier,\n        commitment_index\n    ],\n        GENERATOR_INDEX__COMMITMENT_NONCE\n    )\n}\n\npub fn compute_unique_siloed_commitment(nonce: Field, siloed_commitment: Field) -> Field {\n    pedersen_hash(\n        [\n        nonce,\n        siloed_commitment\n    ],\n        GENERATOR_INDEX__UNIQUE_COMMITMENT\n    )\n}\n\npub fn compute_unique_siloed_commitments<N>(\n    first_nullifier: Field,\n    siloed_commitments: [SideEffect; N]\n) -> [SideEffect; N] {\n    let mut unique_siloed_commitments = [SideEffect::empty(); N];\n    for i in 0..N {\n        let siloed_commitment = siloed_commitments[i];\n        if siloed_commitment.value != 0 {\n            let nonce = compute_commitment_nonce(first_nullifier, i);\n            unique_siloed_commitments[i] = SideEffect {\n                value: compute_unique_siloed_commitment(nonce, siloed_commitment.value),\n                counter: siloed_commitment.counter\n                };\n        }\n    }\n    unique_siloed_commitments\n}\n\npub fn pedersen_hash<N>(inputs: [Field; N], hash_index: u32) -> Field {\n    dep::std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n",
+            "source": "use crate::address::{AztecAddress, EthAddress};\nuse crate::mocked::VerificationKey;\nuse crate::abis::function_selector::FunctionSelector;\nuse crate::abis::function_leaf_preimage::{ContractClassFunctionLeafPreimage, FunctionLeafPreimage};\nuse crate::contract_class::ContractClassId;\nuse crate::abis::new_contract_data::NewContractData as ContractLeafPreimage;\nuse crate::abis::function_data::FunctionData;\nuse crate::abis::side_effect::{SideEffect};\nuse crate::utils::uint256::U256;\nuse crate::constants::{\n        ARGS_HASH_CHUNK_COUNT,\n        ARGS_HASH_CHUNK_LENGTH,\n        CONTRACT_TREE_HEIGHT, \n        FUNCTION_TREE_HEIGHT, \n        NOTE_HASH_TREE_HEIGHT,\n        NUM_FIELDS_PER_SHA256,\n        GENERATOR_INDEX__SILOED_COMMITMENT,\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__VK,\n        GENERATOR_INDEX__CONSTRUCTOR,\n        GENERATOR_INDEX__PARTIAL_ADDRESS,\n        GENERATOR_INDEX__CONTRACT_ADDRESS,\n        GENERATOR_INDEX__COMMITMENT_NONCE,\n        GENERATOR_INDEX__UNIQUE_COMMITMENT,\n        GENERATOR_INDEX__FUNCTION_ARGS,\n};\n\nuse dep::std::hash::{pedersen_hash_with_separator, sha256};\n\npub fn sha256_to_field<N>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = sha256(bytes_to_hash);\n\n    // Convert it to a field element\n    let mut v = 1;\n    let mut high = 0 as Field;\n    let mut low = 0 as Field;\n\n    for i in 0..16 {\n        high = high + (sha256_hashed[15 - i] as Field) * v;\n        low = low + (sha256_hashed[16 + 15 - i] as Field) * v;\n        v = v * 256;\n    }\n\n    // Abuse that a % p + b % p = (a + b) % p and that low < p\n    let hash_in_a_field = low + high * v;\n\n    hash_in_a_field\n}\n\npub fn hash_args<N>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        let mut chunks_hashes = [0; ARGS_HASH_CHUNK_COUNT];\n        for i in 0..ARGS_HASH_CHUNK_COUNT {\n            let mut chunk_hash = 0;\n            let start_chunk_index = i * ARGS_HASH_CHUNK_LENGTH;\n            if start_chunk_index < (args.len() as u32) {\n                let mut chunk_args = [0; ARGS_HASH_CHUNK_LENGTH];\n                for j in 0..ARGS_HASH_CHUNK_LENGTH {\n                    let item_index = i * ARGS_HASH_CHUNK_LENGTH + j;\n                    if item_index < (args.len() as u32) {\n                        chunk_args[j] = args[item_index];\n                    }\n                }\n                chunk_hash = pedersen_hash(chunk_args, GENERATOR_INDEX__FUNCTION_ARGS);\n            }\n            chunks_hashes[i] = chunk_hash;\n        }\n        pedersen_hash(chunks_hashes, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\n// Checks that `value` is a member of a merkle tree with root `root` at position `index`\n// The witness being the `sibling_path`\npub fn assert_check_membership<N>(value: Field, index: Field, sibling_path: [Field; N], root: Field) {\n    let calculated_root = root_from_sibling_path(value, index, sibling_path);\n    assert(calculated_root == root, \"membership check failed\");\n}\n\n// Calculate the Merkle tree root from the sibling path and leaf.\n//\n// The leaf is hashed with its sibling, and then the result is hashed\n// with the next sibling etc in the path. The last hash is the root.\n//\n// TODO(David/Someone): The cpp code is using a uint256, whereas its\n// TODO a bit simpler in Noir to just have a bit array.\n// TODO: I'd generally like to avoid u256 for algorithms like \n// this because it means we never even need to consider cases where \n// the index is greater than p.\npub fn root_from_sibling_path<N>(leaf: Field, leaf_index: Field, sibling_path: [Field; N]) -> Field {\n    let mut node = leaf;\n    let indices = leaf_index.to_le_bits(N);\n\n    for i in 0..N {\n        let (hash_left, hash_right) = if indices[i] == 1 {\n            (sibling_path[i], node)\n        } else {\n            (node, sibling_path[i])\n        };\n        node = merkle_hash(hash_left, hash_right);\n    }\n    node\n}\n\n// Calculate the function tree root from the sibling path and leaf preimage.\n//\n// TODO: The cpp code passes in components of the FunctionLeafPreimage and then \n// builds it up. We should build it up and then pass the leaf preimage as a parameter.\n// We can then choose to have a general method that takes in anything hashable\n// and deduplicate the logic in `contract_tree_root_from_siblings`\npub fn function_tree_root_from_siblings(\n    selector: FunctionSelector,\n    is_internal: bool,\n    is_private: bool,\n    vk_hash: Field,\n    acir_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT]\n) -> Field {\n    let function_leaf_preimage = FunctionLeafPreimage { selector, is_internal, is_private, vk_hash, acir_hash };\n\n    let function_leaf = function_leaf_preimage.hash();\n\n    let function_tree_root = root_from_sibling_path(function_leaf, function_leaf_index, function_leaf_sibling_path);\n\n    function_tree_root\n}\n\n// Calculate the contract tree root from the sibling path and leaf preimage.\npub fn contract_tree_root_from_siblings(\n    contract_class_id: ContractClassId,\n    storage_contract_address: AztecAddress,\n    portal_contract_address: EthAddress,\n    contract_leaf_index: Field,\n    contract_leaf_sibling_path: [Field; CONTRACT_TREE_HEIGHT]\n) -> Field {\n    //TODO(Kev): if we use shorthand syntax here, we get an error as expected,\n    // since variable name is `storage_contract_address` but the span is incorrect.\n    let contract_leaf_preimage = ContractLeafPreimage { contract_address: storage_contract_address, portal_contract_address, contract_class_id };\n\n    let contract_leaf = contract_leaf_preimage.hash();\n\n    let computed_contract_tree_root = root_from_sibling_path(contract_leaf, contract_leaf_index, contract_leaf_sibling_path);\n\n    computed_contract_tree_root\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(function_leaf, function_leaf_index, function_leaf_sibling_path)\n}\n\npub fn read_request_root_from_siblings(\n    read_request: Field,\n    leaf_index: Field,\n    sibling_path: [Field; NOTE_HASH_TREE_HEIGHT]\n) -> Field {\n    root_from_sibling_path(read_request, leaf_index, sibling_path)\n}\n\npub fn silo_commitment(address: AztecAddress, inner_commitment: Field) -> Field {\n    pedersen_hash(\n        [\n        address.to_field(),\n        inner_commitment\n    ],\n        GENERATOR_INDEX__SILOED_COMMITMENT\n    )\n}\n\npub fn silo_nullifier(address: AztecAddress, nullifier: Field) -> Field {\n    pedersen_hash(\n        [\n        address.to_field(),\n        nullifier\n    ],\n        GENERATOR_INDEX__OUTER_NULLIFIER\n    )\n}\n\nfn merkle_hash(left: Field, right: Field) -> Field {\n    pedersen_hash([left, right], 0)\n}\n\npub fn stdlib_recursion_verification_key_compress_native_vk(_vk: VerificationKey) -> Field {\n    // Original cpp code\n    // stdlib::recursion::verification_key<CT::bn254>::compress_native(private_call.vk, GeneratorIndex::VK);\n    // The above cpp method is only ever called on verification key, so it has been special cased here\n    let _hash_index = GENERATOR_INDEX__VK;\n    0\n}\n\n// TODO CPP uses blake2s for this\npub fn compute_new_contract_address_hash(new_contract_address: AztecAddress) -> Field {\n    dep::std::hash::pedersen_hash([new_contract_address.to_field()])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    rollup_version_id: Field,\n    portal_contract_address: EthAddress,\n    chain_id: Field,\n    content: Field\n) -> Field {\n    let mut bytes: BoundedVec<u8, 160> = BoundedVec::new(0);\n\n    let inputs = [\n        contract_address.to_field(), rollup_version_id, portal_contract_address.to_field(), chain_id, content\n    ];\n    for i in 0..inputs.len() {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes = inputs[i].to_be_bytes(32);\n        for j in 0..32 {\n            bytes.push(item_bytes[j]);\n        }\n    }\n\n    sha256_to_field(bytes.storage)\n}\n\npub fn compute_constructor_hash(\n    function_data: FunctionData,\n    args_hash: Field,\n    constructor_vk_hash: Field\n) -> Field {\n    let function_data_hash = function_data.hash();\n\n    pedersen_hash(\n        [\n        function_data_hash,\n        args_hash,\n        constructor_vk_hash\n    ],\n        GENERATOR_INDEX__CONSTRUCTOR\n    )\n}\n\n// Computes sha256 hash of 2 input hashes stored in 4 fields.\n// \n// This method is bn254 specific. Two fields is needed in order to \n// encode the sha256 output. It can be abstracted away with any 4-2 hash function.\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//\n// Returning a Field would be desirable because then this can be replaced with \n// poseidon without changing the rest of the code\n//\npub fn accumulate_sha256(input: [U128; 4]) -> [Field; NUM_FIELDS_PER_SHA256] {\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    //\n    // Concatenate 4 u128 bit integers into a byte array.\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..4 {\n        let input_as_bytes = input[offset].to_be_bytes();\n        for byte_index in 0..16 {\n            hash_input_flattened[offset * 16 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    let sha_digest = dep::std::hash::sha256(hash_input_flattened);\n\n    U256::from_bytes32(sha_digest).to_u128_limbs()\n}\n\npub fn compute_logs_hash(\n    previous_log_hash: [Field; 2],\n    current_log_hash: [Field; 2]\n) -> [Field; NUM_FIELDS_PER_SHA256] {\n    accumulate_sha256(\n        [\n        U128::from_integer(previous_log_hash[0]),\n        U128::from_integer(previous_log_hash[1]),\n        U128::from_integer(current_log_hash[0]),\n        U128::from_integer(current_log_hash[1])\n    ]\n    )\n}\n\npub fn compute_commitment_nonce(first_nullifier: Field, commitment_index: Field) -> Field {\n    pedersen_hash(\n        [\n        first_nullifier,\n        commitment_index\n    ],\n        GENERATOR_INDEX__COMMITMENT_NONCE\n    )\n}\n\npub fn compute_unique_siloed_commitment(nonce: Field, siloed_commitment: Field) -> Field {\n    pedersen_hash(\n        [\n        nonce,\n        siloed_commitment\n    ],\n        GENERATOR_INDEX__UNIQUE_COMMITMENT\n    )\n}\n\npub fn compute_unique_siloed_commitments<N>(\n    first_nullifier: Field,\n    siloed_commitments: [SideEffect; N]\n) -> [SideEffect; N] {\n    let mut unique_siloed_commitments = [SideEffect::empty(); N];\n    for i in 0..N {\n        let siloed_commitment = siloed_commitments[i];\n        if siloed_commitment.value != 0 {\n            let nonce = compute_commitment_nonce(first_nullifier, i);\n            unique_siloed_commitments[i] = SideEffect {\n                value: compute_unique_siloed_commitment(nonce, siloed_commitment.value),\n                counter: siloed_commitment.counter\n                };\n        }\n    }\n    unique_siloed_commitments\n}\n\npub fn pedersen_hash<N>(inputs: [Field; N], hash_index: u32) -> Field {\n    dep::std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n",
             "path": "/usr/src/yarn-project/noir-protocol-circuits/src/crates/types/src/hash.nr"
         },
+        "110": {
+            "source": "// general util packages/modules are usually bad practice\n// because there is no criteria for what we should not put in here.\n// Reducing the size of this package would be welcome.\n\nmod arrays;\nmod field;\nmod reader;\nmod uint256;\n\n// if predicate == true then return lhs, else return rhs\npub fn conditional_assign(predicate: bool, lhs: Field, rhs: Field) -> Field {\n    if predicate { lhs } else { rhs }\n}\n\n// Copied over from \"yarn-project/aztec-nr/aztec/src/utils.nr\"\npub fn arr_copy_slice<T, N, M>(src: [T; N], mut dst: [T; M], offset: Field) -> [T; M] {\n    for i in 0..dst.len() {\n        dst[i] = src[i + offset];\n    }\n    dst\n}\n",
+            "path": "/usr/src/yarn-project/noir-protocol-circuits/src/crates/types/src/utils.nr"
+        },
         "125": {
-            "source": "use crate::{\n    constants::{\n        GENERATOR_INDEX__CONTRACT_ADDRESS,\n        GENERATOR_INDEX__PARTIAL_ADDRESS,\n    },\n    hash::pedersen_hash,\n    utils,\n    grumpkin_point::GrumpkinPoint,\n};\nuse dep::std::cmp::Eq;\nuse crate::traits::{Empty, ToField};\n\n// Aztec address\nstruct AztecAddress {\n    inner : Field\n}\n\nimpl Eq for AztecAddress {\n    fn eq(self, other : Self) -> bool {\n        self.to_field() == other.to_field()\n    }\n}\n\nimpl Empty for AztecAddress {\n    fn empty() -> Self {\n        Self {\n            inner : 0\n        }\n    }\n}\n\nimpl ToField for AztecAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl AztecAddress {\n    pub fn zero() -> Self {\n        Self {\n            inner: 0\n        }\n    }\n\n    pub fn from_field(field : Field) -> Self {\n        Self {\n            inner : field\n        }\n    }\n\n    pub fn compute(pub_key: GrumpkinPoint, partial_address: PartialAddress) -> AztecAddress {\n        AztecAddress::from_field(\n            pedersen_hash(\n                [pub_key.x, pub_key.y, partial_address.to_field()],\n                GENERATOR_INDEX__CONTRACT_ADDRESS\n            )\n        )\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n    \n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n\n    pub fn conditional_assign(predicate: bool, lhs : Self, rhs : Self) -> Self{\n        let result = utils::conditional_assign(predicate, rhs.to_field(), lhs.to_field());\n        Self {\n            inner : result\n        }\n    }\n\n    pub fn serialize(self: Self) -> [Field; 1] {\n        [self.inner]\n    }\n\n    pub fn deserialize(fields: [Field; 1]) -> Self {\n        Self {\n            inner: fields[0]\n        }\n    }\n}\n\nstruct EthAddress{\n    inner : Field\n}\n\nimpl Eq for EthAddress {\n    fn eq(self, other : Self) -> bool {\n        self.to_field() == other.to_field()\n    }\n}\n\nimpl Empty for EthAddress {\n    fn empty() -> Self {\n        Self {\n            inner : 0\n        }\n    }\n}\n\nimpl ToField for EthAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl EthAddress{\n    pub fn zero() -> Self {\n        Self {\n            inner: 0\n        }\n    }\n\n    pub fn from_field(field : Field) -> Self {\n        Self {\n            inner : field\n        }\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n\n    pub fn conditional_assign(predicate: bool, lhs : Self, rhs : Self) -> Self{\n        let result = utils::conditional_assign(predicate, rhs.to_field(), lhs.to_field());\n        Self {\n            inner : result\n        }\n    }\n\n    pub fn serialize(self: Self) -> [Field; 1] {\n        [self.inner]\n    }\n\n    pub fn deserialize(fields: [Field; 1]) -> Self {\n        Self {\n            inner: fields[0]\n        }\n    }\n}\n\n// Partial address\nstruct PartialAddress {\n    inner : Field\n}\n\nimpl ToField for PartialAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl PartialAddress {\n    pub fn from_field(field : Field) -> Self {\n        Self {\n            inner : field\n        }\n    }\n\n    pub fn compute(contract_address_salt : Field, function_tree_root : Field, constructor_hash : Field) -> Self {\n        PartialAddress::from_field(\n            pedersen_hash([\n                // TODO why the zeroes?\n                0,\n                0,\n                contract_address_salt,\n                function_tree_root,\n                constructor_hash\n            ], GENERATOR_INDEX__PARTIAL_ADDRESS)\n        )\n    }\n\n    pub fn to_field(self) -> Field {\n        self.inner\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n",
+            "source": "use crate::{\n    constants::{\n        GENERATOR_INDEX__CONTRACT_ADDRESS,\n        GENERATOR_INDEX__PARTIAL_ADDRESS,\n        GENERATOR_INDEX__CONSTRUCTOR\n    },\n    hash::pedersen_hash,\n    contract_class::ContractClassId,\n    utils,\n    grumpkin_point::GrumpkinPoint,\n};\nuse dep::std::cmp::Eq;\nuse crate::traits::{Empty, ToField, Serialize, Deserialize};\nuse crate::type_serialization::{ETH_ADDRESS_SERIALIZED_LEN, AZTEC_ADDRESS_SERIALIZED_LEN};\n\n// Aztec address\nstruct AztecAddress {\n    inner : Field\n}\n\nimpl Eq for AztecAddress {\n    fn eq(self, other : Self) -> bool {\n        self.to_field() == other.to_field()\n    }\n}\n\nimpl Empty for AztecAddress {\n    fn empty() -> Self {\n        Self {\n            inner : 0\n        }\n    }\n}\n\nimpl ToField for AztecAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl Serialize<AZTEC_ADDRESS_SERIALIZED_LEN> for AztecAddress {\n    fn serialize(self: Self) -> [Field; AZTEC_ADDRESS_SERIALIZED_LEN] {\n        [self.to_field()]\n    }\n}\n\nimpl Deserialize<AZTEC_ADDRESS_SERIALIZED_LEN> for AztecAddress {\n    fn deserialize(fields: [Field; AZTEC_ADDRESS_SERIALIZED_LEN]) -> Self {\n        AztecAddress::from_field(fields[0])\n    }\n}\n\nimpl AztecAddress {\n    pub fn zero() -> Self {\n        Self {\n            inner: 0\n        }\n    }\n\n    pub fn from_field(field : Field) -> Self {\n        Self {\n            inner : field\n        }\n    }\n\n    pub fn compute_from_public_key(pub_key: GrumpkinPoint, contract_class_id: ContractClassId, salt: Field, initialization_hash: Field, portal_contract_address: EthAddress) -> AztecAddress {\n        AztecAddress::compute(PublicKeysHash::compute(pub_key), PartialAddress::compute(contract_class_id, salt, initialization_hash, portal_contract_address))\n    }\n\n    pub fn compute(pub_keys_hash: PublicKeysHash, partial_address: PartialAddress) -> AztecAddress {\n        AztecAddress::from_field(\n            pedersen_hash(\n                [pub_keys_hash.to_field(), partial_address.to_field()],\n                GENERATOR_INDEX__CONTRACT_ADDRESS\n            )\n        )\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n    \n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n\n    pub fn conditional_assign(predicate: bool, lhs : Self, rhs : Self) -> Self{\n        let result = utils::conditional_assign(predicate, rhs.to_field(), lhs.to_field());\n        Self {\n            inner : result\n        }\n    }\n}\n\nstruct EthAddress{\n    inner : Field\n}\n\nimpl Eq for EthAddress {\n    fn eq(self, other : Self) -> bool {\n        self.to_field() == other.to_field()\n    }\n}\n\nimpl Empty for EthAddress {\n    fn empty() -> Self {\n        Self {\n            inner : 0\n        }\n    }\n}\n\nimpl ToField for EthAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl Serialize<ETH_ADDRESS_SERIALIZED_LEN> for EthAddress {\n    fn serialize(self: Self) -> [Field; ETH_ADDRESS_SERIALIZED_LEN] {\n        [self.inner]\n    }\n}\n\nimpl Deserialize<ETH_ADDRESS_SERIALIZED_LEN> for EthAddress {\n    fn deserialize(fields: [Field; ETH_ADDRESS_SERIALIZED_LEN]) -> Self {\n        Self {\n            inner: fields[0]\n        }\n    }\n}\n\nimpl EthAddress{\n    pub fn zero() -> Self {\n        Self {\n            inner: 0\n        }\n    }\n\n    pub fn from_field(field : Field) -> Self {\n        Self {\n            inner : field\n        }\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n\n    pub fn conditional_assign(predicate: bool, lhs : Self, rhs : Self) -> Self{\n        let result = utils::conditional_assign(predicate, rhs.to_field(), lhs.to_field());\n        Self {\n            inner : result\n        }\n    }\n}\n\n// Partial address\nstruct PartialAddress {\n    inner : Field\n}\n\nimpl ToField for PartialAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl PartialAddress {\n    pub fn from_field(field : Field) -> Self {\n        Self {\n            inner : field\n        }\n    }\n\n    pub fn compute(contract_class_id: ContractClassId, salt: Field, initialization_hash: Field, portal_contract_address: EthAddress) -> Self {\n        PartialAddress::compute_from_salted_initialization_hash(contract_class_id, SaltedInitializationHash::compute(salt, initialization_hash, portal_contract_address))\n    }\n\n    pub fn compute_from_salted_initialization_hash(contract_class_id: ContractClassId, salted_initialization_hash: SaltedInitializationHash) -> Self {\n        PartialAddress::from_field(\n            pedersen_hash([\n                contract_class_id.to_field(),\n                salted_initialization_hash.to_field()\n            ], GENERATOR_INDEX__PARTIAL_ADDRESS)\n        )\n    }\n\n\n    pub fn to_field(self) -> Field {\n        self.inner\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n\n// Salted initialization hash. Used in the computation of a partial address.\nstruct SaltedInitializationHash {\n    inner: Field\n}\n\nimpl ToField for SaltedInitializationHash {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl SaltedInitializationHash {\n    pub fn from_field(field : Field) -> Self {\n        Self {\n            inner : field\n        }\n    }\n\n    pub fn compute(salt : Field, initialization_hash: Field, portal_contract_address: EthAddress) -> Self {\n        SaltedInitializationHash::from_field(\n            pedersen_hash([\n                salt,\n                initialization_hash,\n                portal_contract_address.to_field(),\n            ], GENERATOR_INDEX__PARTIAL_ADDRESS)\n        )\n    }\n\n    pub fn to_field(self) -> Field {\n        self.inner\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n\n// Public keys hash. Used in the computation of an address.\nstruct PublicKeysHash {\n    inner: Field\n}\n\nimpl ToField for PublicKeysHash {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl Serialize<1> for PublicKeysHash {\n    fn serialize(self: Self) -> [Field; 1] {\n        [self.to_field()]\n    }\n}\n\nimpl Deserialize<1> for PublicKeysHash {\n    fn deserialize(fields: [Field; 1]) -> Self {\n        PublicKeysHash::from_field(fields[0])\n    }\n}\n\nimpl PublicKeysHash {\n    pub fn from_field(field : Field) -> Self {\n        Self {\n            inner : field\n        }\n    }\n\n    pub fn compute(public_key: GrumpkinPoint) -> Self {\n        PublicKeysHash::from_field(\n            pedersen_hash([\n                public_key.x,\n                public_key.y,\n            ], GENERATOR_INDEX__PARTIAL_ADDRESS)\n        )\n    }\n\n    pub fn to_field(self) -> Field {\n        self.inner\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n\npub fn compute_initialization_hash(selector: Field, args_hash: Field) -> Field {\n    pedersen_hash(\n        [\n        selector,\n        args_hash\n    ],\n        GENERATOR_INDEX__CONSTRUCTOR\n    )\n}\n",
             "path": "/usr/src/yarn-project/noir-protocol-circuits/src/crates/types/src/address.nr"
         },
-        "130": {
-            "source": "use crate::address::EthAddress;\nuse crate::constants::{\n    CONTRACT_DEPLOYMENT_DATA_LENGTH,\n    GENERATOR_INDEX__CONTRACT_DEPLOYMENT_DATA,\n};\nuse crate::hash::pedersen_hash;\nuse crate::grumpkin_point::GrumpkinPoint;\nuse crate::traits::Hash;\n\n// docs:start:contract-deployment-data\nstruct ContractDeploymentData {\n    deployer_public_key : GrumpkinPoint,\n    constructor_vk_hash : Field,\n    function_tree_root : Field,\n    contract_address_salt : Field,\n    portal_contract_address : EthAddress,\n}\n// docs:end:contract-deployment-data\n\nimpl Hash for ContractDeploymentData {\n    fn hash(self) -> Field {\n        pedersen_hash(self.serialize(), GENERATOR_INDEX__CONTRACT_DEPLOYMENT_DATA)\n    }\n}\n\nimpl ContractDeploymentData {\n    fn serialize(self) -> [Field; CONTRACT_DEPLOYMENT_DATA_LENGTH] {\n        [\n            self.deployer_public_key.x,\n            self.deployer_public_key.y,\n            self.constructor_vk_hash,\n            self.function_tree_root,\n            self.contract_address_salt,\n            self.portal_contract_address.to_field(),\n        ]\n    }\n\n    fn assert_is_zero(self) {\n        self.deployer_public_key.assert_is_zero();\n        assert(self.constructor_vk_hash == 0);\n        assert(self.function_tree_root == 0);\n        assert(self.contract_address_salt == 0);\n        self.portal_contract_address.assert_is_zero();\n    }\n\n}\n",
-            "path": "/usr/src/yarn-project/noir-protocol-circuits/src/crates/types/src/contrakt/deployment_data.nr"
+        "127": {
+            "source": "use crate::traits::{Serialize, Deserialize};\n\nglobal BOOL_SERIALIZED_LEN: Field = 1;\nglobal U32_SERIALIZED_LEN: Field = 1;\nglobal U8_SERIALIZED_LEN: Field = 1;\nglobal FIELD_SERIALIZED_LEN: Field = 1;\nglobal AZTEC_ADDRESS_SERIALIZED_LEN = 1;\nglobal ETH_ADDRESS_SERIALIZED_LEN = 1;\n\nimpl Serialize<U32_SERIALIZED_LEN> for u32 {\n    fn serialize(self) -> [Field; U32_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U32_SERIALIZED_LEN> for u32 {\n    fn deserialize(fields: [Field; U32_SERIALIZED_LEN]) -> Self {\n        fields[0] as u32\n    }\n}\n\nimpl Serialize<U8_SERIALIZED_LEN> for u8 {\n    fn serialize(self) -> [Field; U32_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U8_SERIALIZED_LEN> for u8 {\n    fn deserialize(fields: [Field; U8_SERIALIZED_LEN]) -> Self {\n        fields[0] as u8\n    }\n}\n\nimpl Serialize<FIELD_SERIALIZED_LEN> for Field {\n    fn serialize(self) -> [Field; U32_SERIALIZED_LEN] {\n        [self]\n    }\n}\n\nimpl Deserialize<FIELD_SERIALIZED_LEN> for Field {\n    fn deserialize(fields: [Field; FIELD_SERIALIZED_LEN]) -> Self {\n        fields[0]\n    }\n}\n\nimpl Serialize<BOOL_SERIALIZED_LEN> for bool {\n    fn serialize(self) -> [Field; BOOL_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<BOOL_SERIALIZED_LEN> for bool {\n    fn deserialize(fields: [Field; BOOL_SERIALIZED_LEN]) -> bool {\n        fields[0] as bool\n    }\n}\n",
+            "path": "/usr/src/yarn-project/noir-protocol-circuits/src/crates/types/src/type_serialization.nr"
         },
         "131": {
-            "source": "use crate::{\n    constants::{\n        CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH,\n        GENERATOR_INDEX__PUBLIC_DATA_UPDATE_REQUEST,\n    },\n    hash::pedersen_hash,\n};\nuse dep::std::cmp::Eq;\nuse crate::traits::{Hash, Empty};\n\nstruct StorageUpdateRequest{\n    storage_slot : Field,\n    old_value : Field,\n    new_value : Field,\n}\n\nimpl Eq for StorageUpdateRequest {\n    fn eq(self, request: Self) -> bool {\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/3595)\n        (request.storage_slot == self.storage_slot)\n            & (request.old_value == self.old_value)\n            & (request.new_value == self.new_value)\n    }\n}\n\nimpl Empty for StorageUpdateRequest {\n    fn empty() -> Self {\n        StorageUpdateRequest {\n            storage_slot: 0,\n            old_value: 0,\n            new_value: 0,\n        }\n    }\n}\n\nimpl Hash for StorageUpdateRequest {\n    fn hash(self) -> Field {\n        pedersen_hash(self.serialize(), GENERATOR_INDEX__PUBLIC_DATA_UPDATE_REQUEST)\n    }\n}\n\nimpl StorageUpdateRequest {\n    pub fn serialize(self) -> [Field; CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH] {\n        [self.storage_slot, self.old_value, self.new_value]\n    }\n\n    pub fn is_empty(self) -> bool {\n        self.storage_slot == 0\n    }\n}\n",
-            "path": "/usr/src/yarn-project/noir-protocol-circuits/src/crates/types/src/contrakt/storage_update_request.nr"
+            "source": "use crate::{\n    address::EthAddress,\n    contract_class::ContractClassId,\n    constants::{\n        CONTRACT_DEPLOYMENT_DATA_LENGTH,\n        GENERATOR_INDEX__CONTRACT_DEPLOYMENT_DATA,\n    },\n    grumpkin_point::GrumpkinPoint,\n    hash::pedersen_hash,\n    traits::{\n        Deserialize,\n        Hash,\n        Serialize,\n    },\n};\n\n// docs:start:contract-deployment-data\nstruct ContractDeploymentData {\n    public_key : GrumpkinPoint,\n    initialization_hash : Field,\n    contract_class_id : ContractClassId,\n    contract_address_salt : Field,\n    portal_contract_address : EthAddress,\n}\n// docs:end:contract-deployment-data\n\nimpl Eq for ContractDeploymentData {\n    fn eq(self, other: Self) -> bool {\n        self.public_key.eq(other.public_key) &\n        self.initialization_hash.eq(other.initialization_hash) &\n        self.contract_class_id.eq(other.contract_class_id) &\n        self.contract_address_salt.eq(other.contract_address_salt) &\n        self.portal_contract_address.eq(other.portal_contract_address)\n    }\n}\n\nimpl Hash for ContractDeploymentData {\n    fn hash(self) -> Field {\n        pedersen_hash(self.serialize(), GENERATOR_INDEX__CONTRACT_DEPLOYMENT_DATA)\n    }\n}\n\nimpl Serialize<CONTRACT_DEPLOYMENT_DATA_LENGTH> for ContractDeploymentData {\n    fn serialize(self) -> [Field; CONTRACT_DEPLOYMENT_DATA_LENGTH] {\n        [\n            self.public_key.x,\n            self.public_key.y,\n            self.initialization_hash,\n            self.contract_class_id.to_field(),\n            self.contract_address_salt,\n            self.portal_contract_address.to_field(),\n        ]\n    }\n}\n\nimpl Deserialize<CONTRACT_DEPLOYMENT_DATA_LENGTH> for ContractDeploymentData {\n    fn deserialize(serialized: [Field; CONTRACT_DEPLOYMENT_DATA_LENGTH]) -> Self {\n        Self {\n            public_key: GrumpkinPoint {\n                x: serialized[0],\n                y: serialized[1],\n            },\n            initialization_hash: serialized[2],\n            contract_class_id: ContractClassId::from_field(serialized[3]),\n            contract_address_salt: serialized[4],\n            portal_contract_address: EthAddress::from_field(serialized[5]),\n        }\n    }\n}\n\nimpl ContractDeploymentData {\n    fn assert_is_zero(self) {\n        self.public_key.assert_is_zero();\n        assert(self.initialization_hash == 0);\n        self.contract_class_id.assert_is_zero();\n        assert(self.contract_address_salt == 0);\n        self.portal_contract_address.assert_is_zero();\n    }\n}\n\n#[test]\nfn serialization_of_empty() {\n    let data: ContractDeploymentData = dep::std::unsafe::zeroed();\n    let serialized = data.serialize();\n    let deserialized = ContractDeploymentData::deserialize(serialized);\n    assert(data.eq(deserialized));\n}\n",
+            "path": "/usr/src/yarn-project/noir-protocol-circuits/src/crates/types/src/contrakt/deployment_data.nr"
         },
-        "132": {
-            "source": "use crate::{\n    constants::{\n        CONTRACT_STORAGE_READ_LENGTH,\n        GENERATOR_INDEX__PUBLIC_DATA_READ,\n    },\n    hash::pedersen_hash,\n};\nuse crate::traits::Empty;\n\nstruct StorageRead {\n    storage_slot: Field,\n    current_value: Field,\n}\n\nimpl Empty for StorageRead {   \n    fn empty() -> Self {\n        Self {\n            storage_slot: 0,\n            current_value: 0,\n        }\n    }\n}\n\nimpl StorageRead {\n\n    pub fn serialize(self) -> [Field; CONTRACT_STORAGE_READ_LENGTH] {\n        [self.storage_slot, self.current_value]\n    }\n\n    pub fn hash(self) -> Field {\n        pedersen_hash(self.serialize(), GENERATOR_INDEX__PUBLIC_DATA_READ)\n    }\n\n    pub fn is_empty(self) -> bool {\n        self.storage_slot == 0\n    }\n}\n",
-            "path": "/usr/src/yarn-project/noir-protocol-circuits/src/crates/types/src/contrakt/storage_read.nr"
+        "139": {
+            "source": "struct Reader<N> {\n    data: [Field; N],\n    offset: Field,\n}\n\nimpl<N> Reader<N> {\n    pub fn new(data: [Field; N]) -> Self {\n        Self { data, offset: 0 }\n    }\n\n    pub fn read(&mut self) -> Field {\n        let result = self.data[self.offset];\n        self.offset += 1;\n        result\n    }\n\n    pub fn read_array<K>(&mut self, mut result: [Field; K]) -> [Field; K] {\n        for i in 0..K {\n            result[i] = self.data[self.offset + i];\n        }\n        self.offset += K;\n        result\n    }\n\n    // TODO(#4394)\n    pub fn read_struct<T, K>(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n        let result = deserialise(self.read_array([0; K]));\n        result\n    }\n\n    pub fn read_struct_array<T, K, C>(&mut self, deserialise: fn([Field; K]) -> T, mut result: [T; C]) -> [T; C] {\n        for i in 0..C {\n            result[i] = self.read_struct(deserialise);\n        }\n        result\n    }\n\n    pub fn finish(self) {\n        assert(self.offset == self.data.len(), \"Reader did not read all data\");\n    } \n}\n",
+            "path": "/usr/src/yarn-project/noir-protocol-circuits/src/crates/types/src/utils/reader.nr"
         },
-        "140": {
-            "source": "use crate::abis::{\n    function_data::FunctionData,\n    private_circuit_public_inputs::PrivateCircuitPublicInputs,\n    public_circuit_public_inputs::PublicCircuitPublicInputs,\n};\nuse crate::address::AztecAddress;\nuse crate::constants::{\n    GENERATOR_INDEX__CALL_STACK_ITEM,\n};\nuse crate::traits::Hash;\n\nstruct PrivateCallStackItem {\n    // This is the _actual_ contract address relating to where this function's code resides in the\n    // contract tree. Regardless of whether this is a call or delegatecall, this\n    // `contract_address` _does not change_. Amongst other things, it's used as a lookup for\n    // getting the correct code from the tree. There is a separate `storage_contract_address`\n    // within a CallStackItem which varies depending on whether this is a call or delegatecall.\n    contract_address: AztecAddress,\n    public_inputs: PrivateCircuitPublicInputs,\n    function_data: FunctionData,\n    // Not really needed for PrivateCallStackItem.\n    is_execution_request: bool,\n}\n\nimpl Hash for PrivateCallStackItem {\n    fn hash(self) -> Field {\n        dep::std::hash::pedersen_hash_with_separator([\n            self.contract_address.to_field(),\n            self.function_data.hash(),\n            self.public_inputs.hash(),\n        ], GENERATOR_INDEX__CALL_STACK_ITEM)\n    }\n}\n\nstruct PublicCallStackItem {\n    contract_address: AztecAddress,\n    public_inputs: PublicCircuitPublicInputs,\n    function_data: FunctionData,\n    // True if this call stack item represents a request to execute a function rather than a\n    // fulfilled execution. Used when enqueuing calls from private to public functions.\n    is_execution_request: bool,\n}\n\nimpl Hash for PublicCallStackItem {\n    fn hash(self) -> Field {\n        let item = if self.is_execution_request {\n            self.as_execution_request()\n        } else {\n            self\n        };\n\n        dep::std::hash::pedersen_hash_with_separator([\n            item.contract_address.to_field(),\n            item.function_data.hash(),\n            item.public_inputs.hash(),\n        ], GENERATOR_INDEX__CALL_STACK_ITEM)\n    }\n}\n\nimpl PublicCallStackItem {\n    fn as_execution_request(self) -> Self {\n        let public_inputs = self.public_inputs;\n        let mut request_public_inputs: PublicCircuitPublicInputs = dep::std::unsafe::zeroed();\n        request_public_inputs.call_context = public_inputs.call_context;\n        request_public_inputs.args_hash = public_inputs.args_hash;\n\n        let call_stack_item = PublicCallStackItem {\n            contract_address: self.contract_address,\n            function_data: self.function_data,\n            is_execution_request: true,\n            public_inputs: request_public_inputs,\n        };\n        call_stack_item\n    }\n}\n",
-            "path": "/usr/src/yarn-project/noir-protocol-circuits/src/crates/types/src/abis/call_stack_item.nr"
+        "142": {
+            "source": "use crate::constants::{GENERATOR_INDEX__SIDE_EFFECT};\nuse dep::std::cmp::Eq;\nuse crate::traits::{Empty, Hash, Serialize, Deserialize};\n\ntrait Ordered {\n    fn counter(self) -> u32;\n}\n\nstruct SideEffect{\n    value: Field,\n    counter: u32,\n}\n\nimpl Ordered for SideEffect {\n    fn counter(self) -> u32 {\n        self.counter\n    }\n}\n\nimpl Eq for SideEffect {\n    fn eq(self, side_effect: SideEffect) -> bool {\n        (self.value == side_effect.value)\n        & (self.counter == side_effect.counter)\n    }\n}\n\nimpl Empty for SideEffect {\n    fn empty() -> Self {\n        SideEffect {\n            value: 0,\n            counter: 0,\n        }\n    }\n}\n\nimpl Hash for SideEffect {\n    fn hash(self) -> Field {\n        dep::std::hash::pedersen_hash_with_separator(\n            self.serialize() , GENERATOR_INDEX__SIDE_EFFECT)\n    }\n}\n\nimpl Serialize<2> for SideEffect {\n    fn serialize(self) -> [Field; 2] {\n        [self.value, self.counter as Field]\n    }\n}\n\nimpl Deserialize<2> for SideEffect {\n    fn deserialize(values: [Field; 2]) -> Self {\n        Self {\n            value: values[0],\n            counter: values[1] as u32,\n        }\n    }\n}\n\nstruct SideEffectLinkedToNoteHash{\n    value: Field,\n    note_hash: Field,\n    counter: u32,\n}\n\nimpl Ordered for SideEffectLinkedToNoteHash {\n    fn counter(self) -> u32 {\n        self.counter\n    }\n}\n\nimpl Eq for SideEffectLinkedToNoteHash {\n    fn eq(self, side_effect: SideEffectLinkedToNoteHash) -> bool {\n        (self.value == side_effect.value)\n            & (self.note_hash == side_effect.note_hash) \n            & (self.counter == side_effect.counter)\n    }\n}\n\nimpl Empty for SideEffectLinkedToNoteHash {\n    fn empty() -> Self {\n        SideEffectLinkedToNoteHash {\n            value: 0,\n            note_hash: 0,\n            counter: 0,\n        }\n    }\n}\n\nimpl Hash for SideEffectLinkedToNoteHash {\n    fn hash(self) -> Field {\n        dep::std::hash::pedersen_hash_with_separator(\n            self.serialize(),\n        GENERATOR_INDEX__SIDE_EFFECT)\n    }\n}\n\nimpl Serialize<3> for SideEffectLinkedToNoteHash {\n    fn serialize(self) -> [Field; 3] {\n        [self.value, self.note_hash, self.counter as Field]\n    }\n}\n\nimpl Deserialize<3> for SideEffectLinkedToNoteHash {\n    fn deserialize(values: [Field; 3]) -> Self {\n        Self {\n            value: values[0],\n            note_hash: values[1],\n            counter: values[2] as u32,\n        }\n    }\n}\n\n",
+            "path": "/usr/src/yarn-project/noir-protocol-circuits/src/crates/types/src/abis/side_effect.nr"
         },
         "144": {
-            "source": "use crate::constants::{GENERATOR_INDEX__SIDE_EFFECT};\nuse dep::std::cmp::Eq;\nuse crate::traits::{Empty, Hash};\n\ntrait Ordered {\n    fn counter(self) -> u32;\n}\n\nstruct SideEffect{\n    value: Field,\n    counter: u32,\n}\n\nimpl Ordered for SideEffect {\n    fn counter(self) -> u32 {\n        self.counter\n    }\n}\n\nimpl Eq for SideEffect {\n    fn eq(self, side_effect: SideEffect) -> bool {\n        (self.value == side_effect.value)\n        & (self.counter == side_effect.counter)\n    }\n}\n\nimpl Empty for SideEffect {\n    fn empty() -> Self {\n        SideEffect {\n            value: 0,\n            counter: 0,\n        }\n    }\n}\n\nimpl Hash for SideEffect {\n    fn hash(self) -> Field {\n        dep::std::hash::pedersen_hash_with_separator(\n            self.serialize() , GENERATOR_INDEX__SIDE_EFFECT)\n    }\n}\n\nimpl SideEffect {\n    pub fn serialize(self) -> [Field; 2] {\n        [self.value, self.counter as Field]\n    }\n\n    pub fn deserialise(values: [Field; 2]) -> Self {\n        Self {\n            value: values[0],\n            counter: values[1] as u32,\n        }\n    }\n\n    pub fn is_empty(self) -> bool {\n        (self.value == 0)\n        & (self.counter == 0)\n    }\n}\n\nstruct SideEffectLinkedToNoteHash{\n    value: Field,\n    note_hash: Field,\n    counter: u32,\n}\n\nimpl Ordered for SideEffectLinkedToNoteHash {\n    fn counter(self) -> u32 {\n        self.counter\n    }\n}\n\nimpl Eq for SideEffectLinkedToNoteHash {\n    fn eq(self, side_effect: SideEffectLinkedToNoteHash) -> bool {\n        (self.value == side_effect.value)\n            & (self.note_hash == side_effect.note_hash) \n            & (self.counter == side_effect.counter)\n    }\n}\n\nimpl Empty for SideEffectLinkedToNoteHash {\n    fn empty() -> Self {\n        SideEffectLinkedToNoteHash {\n            value: 0,\n            note_hash: 0,\n            counter: 0,\n        }\n    }\n}\n\nimpl Hash for SideEffectLinkedToNoteHash {\n    fn hash(self) -> Field {\n        dep::std::hash::pedersen_hash_with_separator(\n            self.serialize(),\n        GENERATOR_INDEX__SIDE_EFFECT)\n    }\n}\n\nimpl SideEffectLinkedToNoteHash{\n    pub fn serialize(self) -> [Field; 3] {\n        [self.value, self.note_hash, self.counter as Field]\n    }\n\n    pub fn deserialise(values: [Field; 3]) -> Self {\n        Self {\n            value: values[0],\n            note_hash: values[1],\n            counter: values[2] as u32,\n        }\n    }\n\n    pub fn is_empty(self) -> bool {\n        (self.value == 0)\n        &  (self.note_hash == 0)\n        & (self.counter == 0)\n    }\n}\n\n",
-            "path": "/usr/src/yarn-project/noir-protocol-circuits/src/crates/types/src/abis/side_effect.nr"
+            "source": "use crate::abis::{\n    function_data::FunctionData,\n    public_circuit_public_inputs::PublicCircuitPublicInputs,\n};\nuse crate::address::AztecAddress;\nuse crate::constants::GENERATOR_INDEX__CALL_STACK_ITEM;\nuse crate::traits::Hash;\n\nstruct PublicCallStackItem {\n    contract_address: AztecAddress,\n    public_inputs: PublicCircuitPublicInputs,\n    function_data: FunctionData,\n    // True if this call stack item represents a request to execute a function rather than a\n    // fulfilled execution. Used when enqueuing calls from private to public functions.\n    is_execution_request: bool,\n}\n\nimpl Hash for PublicCallStackItem {\n    fn hash(self) -> Field {\n        let item = if self.is_execution_request {\n            self.as_execution_request()\n        } else {\n            self\n        };\n\n        dep::std::hash::pedersen_hash_with_separator([\n            item.contract_address.to_field(),\n            item.function_data.hash(),\n            item.public_inputs.hash(),\n        ], GENERATOR_INDEX__CALL_STACK_ITEM)\n    }\n}\n\nimpl PublicCallStackItem {\n    fn as_execution_request(self) -> Self {\n        let public_inputs = self.public_inputs;\n        let mut request_public_inputs: PublicCircuitPublicInputs = dep::std::unsafe::zeroed();\n        request_public_inputs.call_context = public_inputs.call_context;\n        request_public_inputs.args_hash = public_inputs.args_hash;\n\n        let call_stack_item = PublicCallStackItem {\n            contract_address: self.contract_address,\n            function_data: self.function_data,\n            is_execution_request: true,\n            public_inputs: request_public_inputs,\n        };\n        call_stack_item\n    }\n}\n",
+            "path": "/usr/src/yarn-project/noir-protocol-circuits/src/crates/types/src/abis/public_call_stack_item.nr"
         },
-        "147": {
-            "source": "use crate::constants::{\n    MAX_NEW_L2_TO_L1_MSGS_PER_CALL,\n    MAX_NEW_NULLIFIERS_PER_CALL,\n    MAX_NEW_COMMITMENTS_PER_CALL,\n    MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,\n    MAX_PUBLIC_DATA_READS_PER_CALL,\n    MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,\n    NUM_FIELDS_PER_SHA256,\n    RETURN_VALUES_LENGTH,\n    GENERATOR_INDEX__PUBLIC_CIRCUIT_PUBLIC_INPUTS,\n    PUBLIC_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH,\n    PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH,\n};\nuse crate::{\n    abis::{\n        call_context::CallContext,\n        side_effect::{SideEffect, SideEffectLinkedToNoteHash},\n    },\n    address::AztecAddress,\n    contrakt::{\n        storage_read::StorageRead,\n        storage_update_request::StorageUpdateRequest,\n    },\n    header::Header,\n    utils::bounded_vec::BoundedVec,\n};\n\nstruct PublicCircuitPublicInputs{\n    call_context: CallContext,\n\n    args_hash: Field,\n    return_values: [Field; RETURN_VALUES_LENGTH],\n\n    contract_storage_update_requests: [StorageUpdateRequest; MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL],\n    contract_storage_reads: [StorageRead; MAX_PUBLIC_DATA_READS_PER_CALL],\n\n    // todo: add sideeffect ranges for the input to these hashes\n    public_call_stack_hashes: [Field; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL],\n    new_commitments: [SideEffect; MAX_NEW_COMMITMENTS_PER_CALL],\n    new_nullifiers: [SideEffectLinkedToNoteHash; MAX_NEW_NULLIFIERS_PER_CALL],\n    new_l2_to_l1_msgs: [Field; MAX_NEW_L2_TO_L1_MSGS_PER_CALL],\n\n    unencrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256],\n\n    // Here so that the gas cost of this request can be measured by circuits, without actually needing to feed in the\n    // variable-length data.\n    unencrypted_log_preimages_length: Field,\n\n    historical_header: Header,\n\n    prover_address: AztecAddress,\n}\n\nimpl PublicCircuitPublicInputs{\n    fn hash(self) -> Field {      \n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/3595) have mercy por favor  \n        let mut inputs: BoundedVec<Field, PUBLIC_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH> = BoundedVec::new(0);\n        inputs.push(self.call_context.hash());\n        inputs.push(self.args_hash);\n        inputs.push_array(self.return_values);\n        for i in 0..MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL {\n            inputs.push(self.contract_storage_update_requests[i].hash());\n        }\n        for i in 0..MAX_PUBLIC_DATA_READS_PER_CALL {\n            inputs.push(self.contract_storage_reads[i].hash());\n        }\n        inputs.push_array(self.public_call_stack_hashes);\n\n        for i in 0..MAX_NEW_COMMITMENTS_PER_CALL{\n            inputs.push(self.new_commitments[i].hash());\n        }\n        for i in 0..MAX_NEW_NULLIFIERS_PER_CALL{\n            inputs.push(self.new_nullifiers[i].hash());\n        }\n        inputs.push_array(self.new_l2_to_l1_msgs);\n        inputs.push_array(self.unencrypted_logs_hash);\n        inputs.push(self.unencrypted_log_preimages_length);\n        inputs.push_array(self.historical_header.serialize());\n        inputs.push(self.prover_address.to_field());\n\n        assert_eq(inputs.len(), PUBLIC_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH, \"Incorrect number of input fields when hashing PublicCircuitPublicInputs\");\n\n        dep::std::hash::pedersen_hash_with_separator(inputs.storage, GENERATOR_INDEX__PUBLIC_CIRCUIT_PUBLIC_INPUTS)\n    }\n\n    pub fn serialize(self) -> [Field; PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH] {\n        let mut fields: BoundedVec<Field, PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH> = BoundedVec::new(0); \n        fields.push_array(self.call_context.serialize());   \n        fields.push(self.args_hash);\n        fields.push_array(self.return_values);\n        for i in 0..MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL {\n            fields.push_array(self.contract_storage_update_requests[i].serialize());\n        }\n        for i in 0..MAX_PUBLIC_DATA_READS_PER_CALL {\n            fields.push_array(self.contract_storage_reads[i].serialize());\n        }\n        fields.push_array(self.public_call_stack_hashes);\n\n        for i in 0..MAX_NEW_COMMITMENTS_PER_CALL{\n            fields.push_array(self.new_commitments[i].serialize());\n        }\n        for i in 0..MAX_NEW_NULLIFIERS_PER_CALL{\n            fields.push_array(self.new_nullifiers[i].serialize());\n        }\n        fields.push_array(self.new_l2_to_l1_msgs);\n        fields.push_array(self.unencrypted_logs_hash);\n        fields.push(self.unencrypted_log_preimages_length);\n        fields.push_array(self.historical_header.serialize());\n        fields.push(self.prover_address.to_field());\n        fields.storage\n    }\n}\n",
+        "146": {
+            "source": "use crate::{\n    abis::{\n        call_context::CallContext,\n        side_effect::{SideEffect, SideEffectLinkedToNoteHash},\n    },\n    address::AztecAddress,\n    constants::{\n        MAX_NEW_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NEW_NULLIFIERS_PER_CALL,\n        MAX_NEW_COMMITMENTS_PER_CALL,\n        MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,\n        MAX_PUBLIC_DATA_READS_PER_CALL,\n        MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,\n        NUM_FIELDS_PER_SHA256,\n        RETURN_VALUES_LENGTH,\n        GENERATOR_INDEX__PUBLIC_CIRCUIT_PUBLIC_INPUTS,\n        PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH,\n    },\n    contrakt::{\n        storage_read::StorageRead,\n        storage_update_request::StorageUpdateRequest,\n    },\n    hash::pedersen_hash,\n    header::Header,\n    traits::{\n        Hash,\n        Serialize,\n        Deserialize,\n    },\n    utils::reader::Reader,\n};\n\nstruct PublicCircuitPublicInputs{\n    call_context: CallContext,\n\n    args_hash: Field,\n    return_values: [Field; RETURN_VALUES_LENGTH],\n\n    contract_storage_update_requests: [StorageUpdateRequest; MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL],\n    contract_storage_reads: [StorageRead; MAX_PUBLIC_DATA_READS_PER_CALL],\n\n    // todo: add sideeffect ranges for the input to these hashes\n    public_call_stack_hashes: [Field; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL],\n    new_commitments: [SideEffect; MAX_NEW_COMMITMENTS_PER_CALL],\n    new_nullifiers: [SideEffectLinkedToNoteHash; MAX_NEW_NULLIFIERS_PER_CALL],\n    new_l2_to_l1_msgs: [Field; MAX_NEW_L2_TO_L1_MSGS_PER_CALL],\n\n    unencrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256],\n\n    // Here so that the gas cost of this request can be measured by circuits, without actually needing to feed in the\n    // variable-length data.\n    unencrypted_log_preimages_length: Field,\n\n    // Header of a block whose state is used during public execution. Set by sequencer to be a header of a block\n    // previous to the one in which the tx is included.\n    historical_header: Header,\n\n    prover_address: AztecAddress,\n}\n\nimpl Eq for PublicCircuitPublicInputs {\n    fn eq(self, other: Self) -> bool {\n        self.serialize() == other.serialize()\n    }\n}\n\nimpl Serialize<PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH> for PublicCircuitPublicInputs {\n    fn serialize(self) -> [Field; PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH] {\n        let mut fields: BoundedVec<Field, PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH> = BoundedVec::new(0); \n        fields.extend_from_array(self.call_context.serialize());   \n        fields.push(self.args_hash);\n        fields.extend_from_array(self.return_values);\n        for i in 0..MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL {\n            fields.extend_from_array(self.contract_storage_update_requests[i].serialize());\n        }\n        for i in 0..MAX_PUBLIC_DATA_READS_PER_CALL {\n            fields.extend_from_array(self.contract_storage_reads[i].serialize());\n        }\n        fields.extend_from_array(self.public_call_stack_hashes);\n\n        for i in 0..MAX_NEW_COMMITMENTS_PER_CALL{\n            fields.extend_from_array(self.new_commitments[i].serialize());\n        }\n        for i in 0..MAX_NEW_NULLIFIERS_PER_CALL{\n            fields.extend_from_array(self.new_nullifiers[i].serialize());\n        }\n        fields.extend_from_array(self.new_l2_to_l1_msgs);\n        fields.extend_from_array(self.unencrypted_logs_hash);\n        fields.push(self.unencrypted_log_preimages_length);\n        fields.extend_from_array(self.historical_header.serialize());\n        fields.push(self.prover_address.to_field());\n        fields.storage\n    }\n}\n\nimpl Deserialize<PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH> for PublicCircuitPublicInputs {\n    fn deserialize(serialized: [Field; PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH]) -> Self {\n        // TODO(#4390): This should accept a reader ^ to avoid copying data.\n        let mut reader = Reader::new(serialized);\n        let inputs = PublicCircuitPublicInputs {\n            call_context: reader.read_struct(CallContext::deserialize),\n            args_hash: reader.read(),\n            return_values: reader.read_array([0; RETURN_VALUES_LENGTH]),\n            contract_storage_update_requests: reader.read_struct_array(StorageUpdateRequest::deserialize, [StorageUpdateRequest::empty(); MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL]),\n            contract_storage_reads: reader.read_struct_array(StorageRead::deserialize, [StorageRead::empty(); MAX_PUBLIC_DATA_READS_PER_CALL]),\n            public_call_stack_hashes: reader.read_array([0; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL]),\n            new_commitments: reader.read_struct_array(SideEffect::deserialize, [SideEffect::empty(); MAX_NEW_COMMITMENTS_PER_CALL]),\n            new_nullifiers: reader.read_struct_array(SideEffectLinkedToNoteHash::deserialize, [SideEffectLinkedToNoteHash::empty(); MAX_NEW_NULLIFIERS_PER_CALL]),\n            new_l2_to_l1_msgs: reader.read_array([0; MAX_NEW_L2_TO_L1_MSGS_PER_CALL]),\n            unencrypted_logs_hash: reader.read_array([0; NUM_FIELDS_PER_SHA256]),\n            unencrypted_log_preimages_length: reader.read(),\n            historical_header: reader.read_struct(Header::deserialize),\n            prover_address: reader.read_struct(AztecAddress::deserialize),\n        };\n\n        reader.finish();\n        inputs\n    }\n}\n\nimpl Hash for PublicCircuitPublicInputs {\n    fn hash(self) -> Field {\n        pedersen_hash(self.serialize(), GENERATOR_INDEX__PUBLIC_CIRCUIT_PUBLIC_INPUTS)\n    }\n}\n\n#[test]\nfn serialization_of_empty() {\n    let pcpi: PublicCircuitPublicInputs = dep::std::unsafe::zeroed();\n    let serialized = pcpi.serialize();\n    let deserialized = PublicCircuitPublicInputs::deserialize(serialized);\n    assert(pcpi.eq(deserialized));\n}\n\n#[test]\nfn hash_smoke() {\n    let pcpi: PublicCircuitPublicInputs = dep::std::unsafe::zeroed();\n    let _hashed = pcpi.hash();\n}\n",
             "path": "/usr/src/yarn-project/noir-protocol-circuits/src/crates/types/src/abis/public_circuit_public_inputs.nr"
         },
+        "148": {
+            "source": "use crate::{\n    abis::{\n        function_data::FunctionData,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n    },\n    address::AztecAddress,\n    constants::{\n        GENERATOR_INDEX__CALL_STACK_ITEM,\n        PRIVATE_CALL_STACK_ITEM_LENGTH,\n    },\n    hash::pedersen_hash,\n    traits::{\n        Deserialize,\n        Hash,\n        Serialize,\n    },\n    utils::reader::Reader,\n};\n\nstruct PrivateCallStackItem {\n    // This is the _actual_ contract address relating to where this function's code resides in the\n    // contract tree. Regardless of whether this is a call or delegatecall, this\n    // `contract_address` _does not change_. Amongst other things, it's used as a lookup for\n    // getting the correct code from the tree. There is a separate `storage_contract_address`\n    // within a CallStackItem which varies depending on whether this is a call or delegatecall.\n    contract_address: AztecAddress,\n    function_data: FunctionData,\n    public_inputs: PrivateCircuitPublicInputs,\n}\n\nimpl Eq for PrivateCallStackItem {\n    fn eq(self, other: Self) -> bool {\n        self.contract_address.eq(other.contract_address) &\n        self.function_data.eq(other.function_data) &\n        self.public_inputs.eq(other.public_inputs)\n    }\n}\n\nimpl Serialize<PRIVATE_CALL_STACK_ITEM_LENGTH> for PrivateCallStackItem {\n    fn serialize(self) -> [Field; PRIVATE_CALL_STACK_ITEM_LENGTH] {\n        let mut fields: BoundedVec<Field, PRIVATE_CALL_STACK_ITEM_LENGTH> = BoundedVec::new(0); \n\n        fields.push(self.contract_address.to_field());\n        fields.extend_from_array(self.function_data.serialize());\n        fields.extend_from_array(self.public_inputs.serialize());\n\n        assert_eq(fields.len(), PRIVATE_CALL_STACK_ITEM_LENGTH);\n\n        fields.storage\n    }\n}\n\nimpl Deserialize<PRIVATE_CALL_STACK_ITEM_LENGTH> for PrivateCallStackItem {\n    fn deserialize(serialized: [Field; PRIVATE_CALL_STACK_ITEM_LENGTH]) -> Self {\n        // TODO(#4390): This should accept a reader ^ to avoid copying data.\n        let mut reader = Reader::new(serialized);\n\n        let item = Self {\n            contract_address: reader.read_struct(AztecAddress::deserialize),\n            function_data: reader.read_struct(FunctionData::deserialize),\n            public_inputs: reader.read_struct(PrivateCircuitPublicInputs::deserialize),\n        };\n\n        reader.finish();\n        item\n    }\n}\n\nimpl Hash for PrivateCallStackItem {\n    fn hash(self) -> Field {\n        pedersen_hash(self.serialize(), GENERATOR_INDEX__CALL_STACK_ITEM)\n    }\n}\n\n#[test]\nfn serialization_of_empty() {\n    let item: PrivateCallStackItem = dep::std::unsafe::zeroed();\n    let serialized = item.serialize();\n    let deserialized = PrivateCallStackItem::deserialize(serialized);\n    assert(item.eq(deserialized));\n}\n\n#[test]\nfn empty_hash() {\n    let mut item: PrivateCallStackItem = dep::std::unsafe::zeroed();\n    item.function_data.is_private = true;\n    let hash = item.hash();\n\n    // Value from private_call_stack_item.test.ts \"computes empty item hash\" test\n    assert_eq(hash, 0x2442dd521c59987a4291be0fd11198e5a4d87c8bc36cf3b65c5229f61fc37b30);\n}\n",
+            "path": "/usr/src/yarn-project/noir-protocol-circuits/src/crates/types/src/abis/private_call_stack_item.nr"
+        },
+        "149": {
+            "source": "use dep::std::cmp::Eq;\nuse crate::{\n    address::AztecAddress,\n    traits::{Empty, Serialize, Deserialize},\n    grumpkin_point::GrumpkinPoint,\n    grumpkin_private_key::GrumpkinPrivateKey,\n};\n\nglobal NULLIFIER_KEY_VALIDATION_REQUEST_SERIALIZED_LEN = 4;\nglobal NULLIFIER_KEY_VALIDATION_REQUEST_CONTEXT_SERIALIZED_LEN = 5;\n\nstruct NullifierKeyValidationRequest {\n    public_key: GrumpkinPoint,\n    secret_key: GrumpkinPrivateKey,\n}\n\nimpl Eq for NullifierKeyValidationRequest {\n    fn eq(self, request: NullifierKeyValidationRequest) -> bool {\n        (request.public_key.eq(self.public_key))\n            & (request.secret_key.eq(self.secret_key))\n    }\n}\n\nimpl Empty for NullifierKeyValidationRequest {\n    fn empty() -> Self {\n        NullifierKeyValidationRequest {\n            public_key: GrumpkinPoint::zero(),\n            secret_key: GrumpkinPrivateKey::zero(),\n        }\n    }\n}\n\nimpl Serialize<NULLIFIER_KEY_VALIDATION_REQUEST_SERIALIZED_LEN> for NullifierKeyValidationRequest {\n    fn serialize(self) -> [Field; NULLIFIER_KEY_VALIDATION_REQUEST_SERIALIZED_LEN] {\n        [\n            self.public_key.x,\n            self.public_key.y,\n            self.secret_key.high,\n            self.secret_key.low,\n        ]\n    }\n}\n\nimpl Deserialize<NULLIFIER_KEY_VALIDATION_REQUEST_SERIALIZED_LEN> for NullifierKeyValidationRequest {\n    fn deserialize(fields: [Field; NULLIFIER_KEY_VALIDATION_REQUEST_SERIALIZED_LEN]) -> Self {\n        Self {\n            public_key: GrumpkinPoint::new(fields[0], fields[1]),\n            secret_key: GrumpkinPrivateKey::new(fields[2], fields[3]),\n        }\n    }\n}\n\nimpl NullifierKeyValidationRequest {\n    pub fn to_context(self, contract_address: AztecAddress) -> NullifierKeyValidationRequestContext {\n        NullifierKeyValidationRequestContext {\n            public_key: self.public_key,\n            secret_key: self.secret_key,\n            contract_address,\n        }\n    }\n}\n\nstruct NullifierKeyValidationRequestContext {\n    public_key: GrumpkinPoint,\n    secret_key: GrumpkinPrivateKey,\n    contract_address: AztecAddress,\n}\n\nimpl Eq for NullifierKeyValidationRequestContext {\n    fn eq(self, request: NullifierKeyValidationRequestContext) -> bool {\n        (request.public_key.eq(self.public_key))\n            & (request.secret_key.eq(self.secret_key))\n            & (request.contract_address.eq(self.contract_address))\n    }\n}\n\nimpl Empty for NullifierKeyValidationRequestContext {\n    fn empty() -> Self {\n        NullifierKeyValidationRequestContext {\n            public_key: GrumpkinPoint::zero(),\n            secret_key: GrumpkinPrivateKey::zero(),\n            contract_address: AztecAddress::zero(),\n        }\n    }\n}\n\nimpl Serialize<NULLIFIER_KEY_VALIDATION_REQUEST_CONTEXT_SERIALIZED_LEN> for NullifierKeyValidationRequestContext {\n    fn serialize(self) -> [Field; NULLIFIER_KEY_VALIDATION_REQUEST_CONTEXT_SERIALIZED_LEN] {\n        [\n            self.public_key.x,\n            self.public_key.y,\n            self.secret_key.high,\n            self.secret_key.low,\n            self.contract_address.to_field(),\n        ]\n    }\n}\n\nimpl Deserialize<NULLIFIER_KEY_VALIDATION_REQUEST_CONTEXT_SERIALIZED_LEN> for NullifierKeyValidationRequestContext {\n    fn deserialize(fields: [Field; NULLIFIER_KEY_VALIDATION_REQUEST_CONTEXT_SERIALIZED_LEN]) -> Self {\n        Self {\n            public_key: GrumpkinPoint::new(fields[0], fields[1]),\n            secret_key: GrumpkinPrivateKey::new(fields[2], fields[3]),\n            contract_address: AztecAddress::from_field(fields[4]),\n        }\n    }\n}\n\n",
+            "path": "/usr/src/yarn-project/noir-protocol-circuits/src/crates/types/src/abis/nullifier_key_validation_request.nr"
+        },
         "150": {
-            "source": "use crate::{\n    abis::{\n        call_context::CallContext,\n        nullifier_key_validation_request::NullifierKeyValidationRequest,\n        side_effect::{SideEffect, SideEffectLinkedToNoteHash},\n    },\n    contrakt::deployment_data::ContractDeploymentData,\n    hash::{\n        pedersen_hash,\n    },\n    header::Header,\n    utils::bounded_vec::BoundedVec,\n};\nuse crate::constants::{\n        MAX_READ_REQUESTS_PER_CALL,\n        MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_CALL,\n        MAX_NEW_COMMITMENTS_PER_CALL,\n        MAX_NEW_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL,\n        MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,\n        MAX_NEW_L2_TO_L1_MSGS_PER_CALL,\n        NUM_FIELDS_PER_SHA256,\n        RETURN_VALUES_LENGTH,\n        PRIVATE_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH,\n        PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH,\n        GENERATOR_INDEX__PRIVATE_CIRCUIT_PUBLIC_INPUTS,\n};\nuse crate::traits::Hash;\n\nstruct PrivateCircuitPublicInputs {\n    call_context: CallContext,\n    \n    args_hash: Field,\n    return_values: [Field; RETURN_VALUES_LENGTH],\n\n    read_requests: [SideEffect; MAX_READ_REQUESTS_PER_CALL],\n    nullifier_key_validation_requests: [NullifierKeyValidationRequest; MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_CALL],\n\n    new_commitments: [SideEffect; MAX_NEW_COMMITMENTS_PER_CALL],\n    new_nullifiers: [SideEffectLinkedToNoteHash; MAX_NEW_NULLIFIERS_PER_CALL],\n    private_call_stack_hashes: [Field; MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL],\n    public_call_stack_hashes: [Field; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL],\n    new_l2_to_l1_msgs: [Field; MAX_NEW_L2_TO_L1_MSGS_PER_CALL],\n    end_side_effect_counter : u32,\n\n    encrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256],\n    unencrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256],\n\n    // Here so that the gas cost of this request can be measured by circuits, without actually needing to feed in the\n    // variable-length data.\n    encrypted_log_preimages_length: Field,\n    unencrypted_log_preimages_length: Field,\n\n    // Header of the block the transaction is executing against (not the block the transaction is included in).\n    historical_header: Header,\n\n    contract_deployment_data: ContractDeploymentData,\n\n    chain_id: Field,\n    version: Field,\n}\n\nimpl Hash for PrivateCircuitPublicInputs {\n        fn hash(self) -> Field {\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/3595)\n        let mut fields: BoundedVec<Field, PRIVATE_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH> = BoundedVec::new(0); \n        fields.push(self.call_context.hash());\n        fields.push(self.args_hash);\n        fields.push_array(self.return_values);\n\n        for i in 0..MAX_READ_REQUESTS_PER_CALL{\n            fields.push_array(self.read_requests[i].serialize());\n        }\n        for i in 0..MAX_NEW_COMMITMENTS_PER_CALL{\n            fields.push_array(self.new_commitments[i].serialize());\n        }\n        for i in 0..MAX_NEW_NULLIFIERS_PER_CALL{\n            fields.push_array(self.new_nullifiers[i].serialize());\n        }\n        fields.push_array(self.private_call_stack_hashes);\n        fields.push_array(self.public_call_stack_hashes);\n        fields.push_array(self.new_l2_to_l1_msgs);\n        fields.push(self.end_side_effect_counter as Field);\n        fields.push_array(self.encrypted_logs_hash);\n        fields.push_array(self.unencrypted_logs_hash);\n        fields.push(self.encrypted_log_preimages_length);\n        fields.push(self.unencrypted_log_preimages_length);\n        fields.push_array(self.historical_header.serialize());\n        fields.push(self.contract_deployment_data.hash());\n        fields.push(self.chain_id);\n        fields.push(self.version);\n\n        assert_eq(fields.len(), PRIVATE_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH, \"Incorrect number of input fields when hashing PrivateCircuitPublicInputs\");\n\n        pedersen_hash(fields.storage, GENERATOR_INDEX__PRIVATE_CIRCUIT_PUBLIC_INPUTS)\n    }\n}\n\nimpl PrivateCircuitPublicInputs {\n    fn serialize(self) -> [Field; PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH] {\n        let mut fields: BoundedVec<Field, PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH> = BoundedVec::new(0); \n        fields.push_array(self.call_context.serialize());\n        fields.push(self.args_hash);\n        fields.push_array(self.return_values);\n\n        for i in 0..MAX_READ_REQUESTS_PER_CALL{\n            fields.push_array(self.read_requests[i].serialize());\n        }\n        for i in 0..MAX_NEW_COMMITMENTS_PER_CALL{\n            fields.push_array(self.new_commitments[i].serialize());\n        }\n        for i in 0..MAX_NEW_NULLIFIERS_PER_CALL{\n            fields.push_array(self.new_nullifiers[i].serialize());\n        }\n        fields.push_array(self.private_call_stack_hashes);\n        fields.push_array(self.public_call_stack_hashes);\n        fields.push_array(self.new_l2_to_l1_msgs);\n        fields.push(self.end_side_effect_counter as Field);\n        fields.push_array(self.encrypted_logs_hash);\n        fields.push_array(self.unencrypted_logs_hash);\n        fields.push(self.encrypted_log_preimages_length);\n        fields.push(self.unencrypted_log_preimages_length);\n        fields.push_array(self.historical_header.serialize());\n        fields.push_array(self.contract_deployment_data.serialize());\n        fields.push(self.chain_id);\n        fields.push(self.version);\n\n        assert_eq(fields.len(), PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH);\n\n        fields.storage\n    }\n}\n\n#[test]\nfn serialization_smoke() {\n    let pcpi: PrivateCircuitPublicInputs = dep::std::unsafe::zeroed();\n    let _serialized = pcpi.serialize();\n}\n\n#[test]\nfn hash_smoke() {\n    let pcpi: PrivateCircuitPublicInputs = dep::std::unsafe::zeroed();\n    let _hashed = pcpi.hash();\n}\n",
+            "source": "use crate::{\n    abis::{\n        call_context::CallContext,\n        nullifier_key_validation_request::NullifierKeyValidationRequest,\n        side_effect::{\n            SideEffect,\n            SideEffectLinkedToNoteHash,\n        },\n    },\n    constants::{\n        MAX_READ_REQUESTS_PER_CALL,\n        MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_CALL,\n        MAX_NEW_COMMITMENTS_PER_CALL,\n        MAX_NEW_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL,\n        MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,\n        MAX_NEW_L2_TO_L1_MSGS_PER_CALL,\n        NUM_FIELDS_PER_SHA256,\n        RETURN_VALUES_LENGTH,\n        PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH,\n        GENERATOR_INDEX__PRIVATE_CIRCUIT_PUBLIC_INPUTS,\n    },\n    contrakt::deployment_data::ContractDeploymentData,\n    header::Header,\n    hash::pedersen_hash,\n    traits::{\n        Deserialize,\n        Hash,\n        Serialize,\n    },\n    utils::reader::Reader,\n};\n\nstruct PrivateCircuitPublicInputs {\n    call_context: CallContext,\n\n    args_hash: Field,\n    return_values: [Field; RETURN_VALUES_LENGTH],\n\n    meta_hwm: u32,\n\n    read_requests: [SideEffect; MAX_READ_REQUESTS_PER_CALL],\n    nullifier_key_validation_requests: [NullifierKeyValidationRequest; MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_CALL],\n\n    new_commitments: [SideEffect; MAX_NEW_COMMITMENTS_PER_CALL],\n    new_nullifiers: [SideEffectLinkedToNoteHash; MAX_NEW_NULLIFIERS_PER_CALL],\n    private_call_stack_hashes: [Field; MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL],\n    public_call_stack_hashes: [Field; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL],\n    new_l2_to_l1_msgs: [Field; MAX_NEW_L2_TO_L1_MSGS_PER_CALL],\n    end_side_effect_counter : u32,\n\n    encrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256],\n    unencrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256],\n\n    // Here so that the gas cost of this request can be measured by circuits, without actually needing to feed in the\n    // variable-length data.\n    encrypted_log_preimages_length: Field,\n    unencrypted_log_preimages_length: Field,\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    historical_header: Header,\n\n    contract_deployment_data: ContractDeploymentData,\n\n    // Note: The following 2 values are not redundant to the values in self.historical_header.global_variables because\n    // they can be different in case of a protocol upgrade. In such a situation we could be using header from a block\n    // before the upgrade took place but be using the updated protocol to execute and prove the transaction.\n    chain_id: Field,\n    version: Field,\n}\n\nimpl Eq for PrivateCircuitPublicInputs {\n    fn eq(self, other: Self) -> bool {\n        self.call_context.eq(other.call_context) &\n        self.args_hash.eq(other.args_hash) &\n        (self.return_values == other.return_values) &\n        (self.read_requests == other.read_requests) &\n        (self.nullifier_key_validation_requests == other.nullifier_key_validation_requests) &\n        (self.new_commitments == other.new_commitments) &\n        (self.new_nullifiers == other.new_nullifiers) &\n        (self.private_call_stack_hashes == other.private_call_stack_hashes) &\n        (self.public_call_stack_hashes == other.public_call_stack_hashes) &\n        (self.new_l2_to_l1_msgs == other.new_l2_to_l1_msgs) &\n        (self.end_side_effect_counter == other.end_side_effect_counter) &\n        (self.encrypted_logs_hash == other.encrypted_logs_hash) &\n        (self.unencrypted_logs_hash == other.unencrypted_logs_hash) &\n        (self.encrypted_log_preimages_length == other.encrypted_log_preimages_length) &\n        (self.unencrypted_log_preimages_length == other.unencrypted_log_preimages_length) &\n        self.historical_header.eq(other.historical_header) &\n        self.contract_deployment_data.eq(other.contract_deployment_data) &\n        self.chain_id.eq(other.chain_id) &\n        self.version.eq(other.version)\n    }\n}\n\nimpl Serialize<PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH> for PrivateCircuitPublicInputs {\n    fn serialize(self) -> [Field; PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH] {\n        let mut fields: BoundedVec<Field, PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH> = BoundedVec::new(0);\n        fields.extend_from_array(self.call_context.serialize());\n        fields.push(self.args_hash);\n        fields.extend_from_array(self.return_values);\n\n        fields.push(self.meta_hwm as Field);\n\n        for i in 0..MAX_READ_REQUESTS_PER_CALL{\n            fields.extend_from_array(self.read_requests[i].serialize());\n        }\n        for i in 0..MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_CALL{\n            fields.extend_from_array(self.nullifier_key_validation_requests[i].serialize());\n        }\n        for i in 0..MAX_NEW_COMMITMENTS_PER_CALL{\n            fields.extend_from_array(self.new_commitments[i].serialize());\n        }\n        for i in 0..MAX_NEW_NULLIFIERS_PER_CALL{\n            fields.extend_from_array(self.new_nullifiers[i].serialize());\n        }\n        fields.extend_from_array(self.private_call_stack_hashes);\n        fields.extend_from_array(self.public_call_stack_hashes);\n        fields.extend_from_array(self.new_l2_to_l1_msgs);\n        fields.push(self.end_side_effect_counter as Field);\n        fields.extend_from_array(self.encrypted_logs_hash);\n        fields.extend_from_array(self.unencrypted_logs_hash);\n        fields.push(self.encrypted_log_preimages_length);\n        fields.push(self.unencrypted_log_preimages_length);\n        fields.extend_from_array(self.historical_header.serialize());\n        fields.extend_from_array(self.contract_deployment_data.serialize());\n        fields.push(self.chain_id);\n        fields.push(self.version);\n\n        assert_eq(fields.len(), PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH);\n\n        fields.storage\n    }\n}\n\nimpl Deserialize<PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH> for PrivateCircuitPublicInputs {\n    fn deserialize(serialized: [Field; PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH]) -> Self {\n        // TODO(#4390): This should accept a reader ^ to avoid copying data.\n        let mut reader = Reader::new(serialized);\n        let inputs = Self {\n            call_context: reader.read_struct(CallContext::deserialize),\n            args_hash: reader.read(),\n            return_values: reader.read_array([0; RETURN_VALUES_LENGTH]),\n            meta_hwm: reader.read() as u32,\n            read_requests: reader.read_struct_array(SideEffect::deserialize, [SideEffect::empty(); MAX_READ_REQUESTS_PER_CALL]),\n            nullifier_key_validation_requests: reader.read_struct_array(NullifierKeyValidationRequest::deserialize, [NullifierKeyValidationRequest::empty(); MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_CALL]),\n            new_commitments: reader.read_struct_array(SideEffect::deserialize, [SideEffect::empty(); MAX_NEW_COMMITMENTS_PER_CALL]),\n            new_nullifiers: reader.read_struct_array(SideEffectLinkedToNoteHash::deserialize, [SideEffectLinkedToNoteHash::empty(); MAX_NEW_NULLIFIERS_PER_CALL]),\n            private_call_stack_hashes: reader.read_array([0; MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL]),\n            public_call_stack_hashes: reader.read_array([0; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL]),\n            new_l2_to_l1_msgs: reader.read_array([0; MAX_NEW_L2_TO_L1_MSGS_PER_CALL]),\n            end_side_effect_counter: reader.read() as u32,\n            encrypted_logs_hash: reader.read_array([0; NUM_FIELDS_PER_SHA256]),\n            unencrypted_logs_hash: reader.read_array([0; NUM_FIELDS_PER_SHA256]),\n            encrypted_log_preimages_length: reader.read(),\n            unencrypted_log_preimages_length: reader.read(),\n            historical_header: reader.read_struct(Header::deserialize),\n            contract_deployment_data: reader.read_struct(ContractDeploymentData::deserialize),\n            chain_id: reader.read(),\n            version: reader.read(),\n        };\n\n        reader.finish();\n        inputs\n    }\n}\n\nimpl Hash for PrivateCircuitPublicInputs {\n    fn hash(self) -> Field {\n        pedersen_hash(self.serialize(), GENERATOR_INDEX__PRIVATE_CIRCUIT_PUBLIC_INPUTS)\n    }\n}\n\n#[test]\nfn serialization_of_empty() {\n    let pcpi: PrivateCircuitPublicInputs = dep::std::unsafe::zeroed();\n    let serialized = pcpi.serialize();\n    let deserialized = PrivateCircuitPublicInputs::deserialize(serialized);\n    assert(pcpi.eq(deserialized));\n}\n\n#[test]\nfn empty_hash() {\n    let inputs: PrivateCircuitPublicInputs = dep::std::unsafe::zeroed();\n    let hash = inputs.hash();\n\n    // Value from private_circuit_public_inputs.test.ts \"computes empty item hash\" test\n    assert_eq(hash, 0x1304e6c42e3c53fc7c918cbf1ea70333b4f214726c0784cf9878cd641967dab1);\n}\n",
             "path": "/usr/src/yarn-project/noir-protocol-circuits/src/crates/types/src/abis/private_circuit_public_inputs.nr"
         },
         "153": {
-            "source": "use crate::abis::function_selector::FunctionSelector;\nuse crate::constants::GENERATOR_INDEX__FUNCTION_DATA;\n\nstruct FunctionData {\n    // First four bytes of the abi encoding \n    // of a function. \n    selector : FunctionSelector,\n    is_internal : bool,\n    is_private : bool,\n    is_constructor : bool,\n}\n\nimpl FunctionData {\n    // A field is ~256 bits\n    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/3057): Since, function data can fit into a Field,\n    // This method will simply return a bit packed Field instead of hashing\n    fn hash(self) -> Field {\n        dep::std::hash::pedersen_hash_with_separator([\n            self.selector.to_field(),\n            self.is_internal as Field,\n            self.is_private as Field,\n            self.is_constructor as Field,\n        ], GENERATOR_INDEX__FUNCTION_DATA)\n    }\n}\n",
+            "source": "use crate::{\n    abis::function_selector::FunctionSelector,\n    constants::{\n        GENERATOR_INDEX__FUNCTION_DATA,\n        FUNCTION_DATA_LENGTH,\n    },\n    hash::pedersen_hash,\n    traits::{\n        Serialize,\n        Hash,\n        Deserialize,\n    },\n};\n\nstruct FunctionData {\n    // First four bytes of the abi encoding \n    // of a function. \n    selector : FunctionSelector,\n    is_internal : bool,\n    is_private : bool,\n    is_constructor : bool,\n}\n\nimpl Eq for FunctionData {\n    fn eq(self, other: Self) -> bool {\n        self.selector.eq(other.selector) &\n        self.is_internal == other.is_internal &\n        self.is_private == other.is_private &\n        self.is_constructor == other.is_constructor\n    }\n}\n\nimpl Serialize<FUNCTION_DATA_LENGTH> for FunctionData {\n    // A field is ~256 bits\n    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/3057): Since, function data can fit into a Field,\n    // This method will simply return a bit packed Field instead of hashing\n    fn serialize(self) -> [Field; FUNCTION_DATA_LENGTH] {\n        [\n            self.selector.to_field(),\n            self.is_internal as Field,\n            self.is_private as Field,\n            self.is_constructor as Field,\n        ]\n    }\n}\n\nimpl Deserialize<FUNCTION_DATA_LENGTH> for FunctionData {\n    fn deserialize(serialized: [Field; FUNCTION_DATA_LENGTH]) -> Self {\n        Self {\n            selector: FunctionSelector::from_field(serialized[0]),\n            is_internal: serialized[1] as bool,\n            is_private: serialized[2] as bool,\n            is_constructor: serialized[3] as bool,\n        }\n    }\n}\n\nimpl Hash for FunctionData {\n    fn hash(self) -> Field {\n        pedersen_hash(self.serialize(), GENERATOR_INDEX__FUNCTION_DATA)\n    }\n}\n\n#[test]\nfn serialization_of_empty() {\n    let data: FunctionData = dep::std::unsafe::zeroed();\n    let serialized = data.serialize();\n    let deserialized = FunctionData::deserialize(serialized);\n    assert(data.eq(deserialized));\n}\n\n#[test]\nfn empty_hash() {\n    let data: FunctionData = dep::std::unsafe::zeroed();\n    let hash = data.hash();\n\n    // Value from function_data.test.ts \"computes empty item hash\" test\n    assert_eq(hash, 0x200569267c0f73ac89aaa414239398db9445dd4ad3a8cf37015cd55b8d4c5e8d);\n}\n",
             "path": "/usr/src/yarn-project/noir-protocol-circuits/src/crates/types/src/abis/function_data.nr"
         },
         "154": {
             "source": "use dep::std::cmp::Eq;\n\nstruct AppendOnlyTreeSnapshot {\n    root : Field,\n    next_available_leaf_index : u32\n}\n\nglobal APPEND_ONLY_TREE_SNAPSHOT_LENGTH: Field = 2;\n\nimpl AppendOnlyTreeSnapshot {\n    pub fn serialize(self) -> [Field; APPEND_ONLY_TREE_SNAPSHOT_LENGTH] {\n        [self.root, self.next_available_leaf_index as Field]\n    }\n\n    pub fn deserialize(serialized: [Field; APPEND_ONLY_TREE_SNAPSHOT_LENGTH]) -> AppendOnlyTreeSnapshot {\n        AppendOnlyTreeSnapshot {\n            root : serialized[0],\n            next_available_leaf_index : serialized[1] as u32\n        }\n    }\n\n    pub fn zero() -> Self {\n        Self {\n            root: 0,\n            next_available_leaf_index: 0,\n        }\n    }\n}\n\nimpl Eq for AppendOnlyTreeSnapshot {\n    fn eq(self, other : AppendOnlyTreeSnapshot) -> bool {\n        (self.root == other.root) & (self.next_available_leaf_index == other.next_available_leaf_index)\n    }\n}\n",
             "path": "/usr/src/yarn-project/noir-protocol-circuits/src/crates/types/src/abis/append_only_tree_snapshot.nr"
         },
+        "155": {
+            "source": "use dep::std::cmp::Eq;\nuse crate::{\n    address::{\n        AztecAddress,\n        EthAddress,\n    },\n    constants::{\n        GENERATOR_INDEX__GLOBAL_VARIABLES,\n        GLOBAL_VARIABLES_LENGTH,\n    },\n    traits::{\n        Deserialize,\n        Empty,\n        Hash,\n        Serialize,\n    },\n};\n\nstruct GlobalVariables {\n    chain_id : Field,\n    version : Field,\n    block_number : Field,\n    timestamp : Field,\n    coinbase : EthAddress,\n    fee_recipient : AztecAddress,\n}\n\nimpl Serialize<GLOBAL_VARIABLES_LENGTH> for GlobalVariables {\n    fn serialize(self) -> [Field; GLOBAL_VARIABLES_LENGTH] {\n        [\n            self.chain_id,\n            self.version,\n            self.block_number,\n            self.timestamp,\n            self.coinbase.to_field(),\n            self.fee_recipient.to_field(),\n        ]\n    }\n}\n\nimpl Deserialize<GLOBAL_VARIABLES_LENGTH> for GlobalVariables {\n    fn deserialize(serialized: [Field; GLOBAL_VARIABLES_LENGTH]) -> GlobalVariables {\n        GlobalVariables {\n            chain_id: serialized[0],\n            version: serialized[1],\n            block_number: serialized[2],\n            timestamp: serialized[3],\n            coinbase: EthAddress::from_field(serialized[4]),\n            fee_recipient: AztecAddress::from_field(serialized[5]),\n        }\n    }\n}\n\nimpl Eq for GlobalVariables {\n    fn eq(self, other : GlobalVariables) -> bool {\n        (self.chain_id == other.chain_id) &\n        (self.version == other.version) &\n        (self.block_number == other.block_number) &\n        (self.timestamp == other.timestamp) &\n        (self.coinbase == other.coinbase) &\n        (self.fee_recipient == other.fee_recipient)\n    }\n}\n\nimpl Empty for GlobalVariables {\n    fn empty() -> Self {\n        Self {\n            chain_id: 0,\n            version: 0,\n            block_number: 0,\n            timestamp: 0,\n            coinbase: EthAddress::empty(),\n            fee_recipient: AztecAddress::empty(),\n        }\n    }\n}\n\n#[test]\nfn serialization_of_empty() {\n    let vars: GlobalVariables = dep::std::unsafe::zeroed();\n    let _serialized = vars.serialize();\n    let _deserialized = GlobalVariables::deserialize(_serialized);\n}\n",
+            "path": "/usr/src/yarn-project/noir-protocol-circuits/src/crates/types/src/abis/global_variables.nr"
+        },
         "158": {
-            "source": "use crate::{\n    abis::function_selector::FunctionSelector,\n    address::{EthAddress,AztecAddress},\n    constants::{\n        CALL_CONTEXT_LENGTH,\n        GENERATOR_INDEX__CALL_CONTEXT,\n    },\n    hash::pedersen_hash,\n};\nuse dep::std::cmp::Eq;\nuse crate::traits::Hash;\n\n// docs:start:call-context\nstruct CallContext {\n    msg_sender : AztecAddress,\n    storage_contract_address : AztecAddress,\n    portal_contract_address : EthAddress,\n\n    function_selector : FunctionSelector,\n\n    is_delegate_call : bool,\n    is_static_call : bool,\n    is_contract_deployment : bool,\n\n    start_side_effect_counter : u32,\n}\n// docs:end:call-context\n\nimpl Eq for CallContext {\n    fn eq(self, call_context: CallContext) -> bool {\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/3595)\n        call_context.msg_sender.eq(self.msg_sender)\n            & call_context.storage_contract_address.eq(self.storage_contract_address)\n            & call_context.portal_contract_address.eq(self.portal_contract_address)\n            & call_context.function_selector.eq(self.function_selector)\n            & (call_context.is_delegate_call == self.is_delegate_call)\n            & (call_context.is_static_call == self.is_static_call)\n            & (call_context.is_contract_deployment == self.is_contract_deployment)\n            & (call_context.start_side_effect_counter == self.start_side_effect_counter)\n    }\n}\n\nimpl Hash for CallContext {\n    fn hash(self) -> Field {\n        pedersen_hash(self.serialize(), GENERATOR_INDEX__CALL_CONTEXT)\n    }\n}\n\nimpl CallContext {\n    fn serialize(self) -> [Field; CALL_CONTEXT_LENGTH] {\n        [\n            self.msg_sender.to_field(),\n            self.storage_contract_address.to_field(),\n            self.portal_contract_address.to_field(),\n            self.function_selector.to_field(),\n            self.is_delegate_call as Field,\n            self.is_static_call as Field,\n            self.is_contract_deployment as Field,\n            self.start_side_effect_counter as Field,\n        ]\n    }\n\n    fn assert_is_zero(self) {\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/3595)\n        assert(self.msg_sender.to_field() == 0);\n        assert(self.storage_contract_address.to_field() == 0);\n        assert(self.portal_contract_address.to_field() == 0);\n        assert(self.function_selector.to_field() == 0);\n        assert(self.is_delegate_call == false);\n        assert(self.is_static_call == false);\n        assert(self.is_contract_deployment == false);\n        assert(self.start_side_effect_counter == 0);\n    }\n}\n",
+            "source": "use crate::{\n    abis::function_selector::FunctionSelector,\n    address::{EthAddress,AztecAddress},\n    constants::{\n        CALL_CONTEXT_LENGTH,\n        GENERATOR_INDEX__CALL_CONTEXT,\n    },\n    hash::pedersen_hash,\n    traits::{\n        Deserialize,\n        Hash,\n        Serialize,\n    },\n};\n\n// docs:start:call-context\nstruct CallContext {\n    msg_sender : AztecAddress,\n    storage_contract_address : AztecAddress,\n    portal_contract_address : EthAddress,\n\n    function_selector : FunctionSelector,\n\n    is_delegate_call : bool,\n    is_static_call : bool,\n    is_contract_deployment : bool,\n\n    start_side_effect_counter : u32,\n}\n// docs:end:call-context\n\nimpl CallContext {\n    fn assert_is_zero(self) {\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/3595)\n        assert(self.msg_sender.to_field() == 0);\n        assert(self.storage_contract_address.to_field() == 0);\n        assert(self.portal_contract_address.to_field() == 0);\n        assert(self.function_selector.to_field() == 0);\n        assert(self.is_delegate_call == false);\n        assert(self.is_static_call == false);\n        assert(self.is_contract_deployment == false);\n        assert(self.start_side_effect_counter == 0);\n    }\n}\n\nimpl Eq for CallContext {\n    fn eq(self, call_context: CallContext) -> bool {\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/3595)\n        call_context.msg_sender.eq(self.msg_sender)\n            & call_context.storage_contract_address.eq(self.storage_contract_address)\n            & call_context.portal_contract_address.eq(self.portal_contract_address)\n            & call_context.function_selector.eq(self.function_selector)\n            & (call_context.is_delegate_call == self.is_delegate_call)\n            & (call_context.is_static_call == self.is_static_call)\n            & (call_context.is_contract_deployment == self.is_contract_deployment)\n            & (call_context.start_side_effect_counter == self.start_side_effect_counter)\n    }\n}\n\nimpl Hash for CallContext {\n    fn hash(self) -> Field {\n        pedersen_hash(self.serialize(), GENERATOR_INDEX__CALL_CONTEXT)\n    }\n}\n\nimpl Serialize<CALL_CONTEXT_LENGTH> for CallContext {\n    fn serialize(self) -> [Field; CALL_CONTEXT_LENGTH] {\n        [\n            self.msg_sender.to_field(),\n            self.storage_contract_address.to_field(),\n            self.portal_contract_address.to_field(),\n            self.function_selector.to_field(),\n            self.is_delegate_call as Field,\n            self.is_static_call as Field,\n            self.is_contract_deployment as Field,\n            self.start_side_effect_counter as Field,\n        ]\n    }\n}\n\nimpl Deserialize<CALL_CONTEXT_LENGTH> for CallContext {\n    fn deserialize(serialized: [Field; CALL_CONTEXT_LENGTH]) -> CallContext {\n        CallContext {\n            msg_sender: AztecAddress::from_field(serialized[0]),\n            storage_contract_address: AztecAddress::from_field(serialized[1]),\n            portal_contract_address: EthAddress::from_field(serialized[2]),\n            function_selector: FunctionSelector::from_field(serialized[3]),\n            is_delegate_call: serialized[4] as bool,\n            is_static_call: serialized[5] as bool,\n            is_contract_deployment: serialized[6] as bool,\n            start_side_effect_counter: serialized[7] as u32,\n        }\n    }\n}\n\n#[test]\nfn serialization_of_empty() {\n    let context: CallContext = dep::std::unsafe::zeroed();\n    let serialized = context.serialize();\n    let deserialized = CallContext::deserialize(serialized);\n    assert(context.eq(deserialized));\n}\n\n#[test]\nfn hash_smoke() {\n    let context: CallContext = dep::std::unsafe::zeroed();\n    let _hashed = context.hash();\n}\n",
             "path": "/usr/src/yarn-project/noir-protocol-circuits/src/crates/types/src/abis/call_context.nr"
         },
         "164": {
-            "source": "use crate::utils::field::field_from_bytes;\nuse dep::std::cmp::Eq;\n\nglobal SELECTOR_SIZE = 4;\n\nstruct FunctionSelector {\n    // 1st 4-bytes of abi-encoding of function.\n    inner: u32,\n}\n\nimpl Eq for FunctionSelector {\n    fn eq(self, function_selector: FunctionSelector) -> bool {\n        function_selector.inner == self.inner\n    }\n}\n\nimpl FunctionSelector {\n    fn to_field(self) -> Field {\n        self.inner as Field\n    }\n\n    pub fn from_u32(value: u32) -> Self {\n        Self {\n            inner : value,\n        }\n    }\n\n    pub fn from_field(value : Field) -> Self {\n        Self {\n            inner : value as u32,\n        }\n    }\n\n    pub fn from_signature<N>(signature: str<N>) -> Self {\n        let bytes = signature.as_bytes();\n        let hash = dep::std::hash::keccak256(bytes, bytes.len() as u32);\n\n        let mut selector_be_bytes = [0; SELECTOR_SIZE];\n        for i in 0..SELECTOR_SIZE {\n            selector_be_bytes[i] = hash[i];\n        }\n\n        FunctionSelector::from_field(field_from_bytes(selector_be_bytes, true))\n    }\n\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    pub fn serialize(self: Self) -> [Field; 1] {\n        [self.inner as Field]\n    }\n\n    pub fn deserialize(fields: [Field; 1]) -> Self {\n        Self {\n            inner: fields[0] as u32\n        }\n    }\n}\n",
+            "source": "use crate::utils::field::field_from_bytes;\nuse dep::std::cmp::Eq;\nuse crate::traits::{Serialize, Deserialize};\n\nglobal SELECTOR_SIZE = 4;\n\nstruct FunctionSelector {\n    // 1st 4-bytes of abi-encoding of function.\n    inner: u32,\n}\n\nimpl Eq for FunctionSelector {\n    fn eq(self, function_selector: FunctionSelector) -> bool {\n        function_selector.inner == self.inner\n    }\n}\n\nimpl Serialize<1> for FunctionSelector {\n    fn serialize(self: Self) -> [Field; 1] {\n        [self.inner as Field]\n    }\n}\n\nimpl Deserialize<1> for FunctionSelector {\n    fn deserialize(fields: [Field; 1]) -> Self {\n        Self {\n            inner: fields[0] as u32\n        }\n    }\n}\n\nimpl FunctionSelector {\n    fn to_field(self) -> Field {\n        self.inner as Field\n    }\n\n    pub fn from_u32(value: u32) -> Self {\n        Self {\n            inner : value,\n        }\n    }\n\n    pub fn from_field(value : Field) -> Self {\n        Self {\n            inner : value as u32,\n        }\n    }\n\n    pub fn from_signature<N>(signature: str<N>) -> Self {\n        let bytes = signature.as_bytes();\n        let hash = dep::std::hash::keccak256(bytes, bytes.len() as u32);\n\n        let mut selector_be_bytes = [0; SELECTOR_SIZE];\n        for i in 0..SELECTOR_SIZE {\n            selector_be_bytes[i] = hash[i];\n        }\n\n        FunctionSelector::from_field(field_from_bytes(selector_be_bytes, true))\n    }\n\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n}\n",
             "path": "/usr/src/yarn-project/noir-protocol-circuits/src/crates/types/src/abis/function_selector.nr"
         },
-        "188": {
-            "source": "use dep::aztec::abi;\nuse dep::aztec::types::vec::BoundedVec;\nuse dep::aztec::context::PrivateContext;\nuse dep::aztec::protocol_types::{\n  abis::{\n    call_stack_item::{\n      PrivateCallStackItem,\n      PublicCallStackItem,\n    },\n    function_selector::FunctionSelector,\n  },\n  address::AztecAddress,\n  constants::GENERATOR_INDEX__SIGNATURE_PAYLOAD,\n  hash::pedersen_hash,\n};\n\nglobal ACCOUNT_MAX_CALLS: Field = 4;\n// 1 (ARGS_HASH) + 1 (FUNCTION_SELECTOR) + 1 (TARGET_ADDRESS) + 1 (IS_PUBLIC)\nglobal FUNCTION_CALL_SIZE: Field = 4;\n// 3 * 32 + 1\nglobal FUNCTION_CALL_SIZE_IN_BYTES: Field = 97;\n\nstruct FunctionCall {\n  args_hash: Field,\n  function_selector: FunctionSelector,\n  target_address: AztecAddress,\n  is_public: bool,\n}\n\nimpl FunctionCall {\n  fn serialize(self) -> [Field; FUNCTION_CALL_SIZE] {\n    [self.args_hash, self.function_selector.to_field(), self.target_address.to_field(), self.is_public as Field]\n  }\n\n  fn to_be_bytes(self) -> [u8; FUNCTION_CALL_SIZE_IN_BYTES] {\n    let mut bytes: [u8; FUNCTION_CALL_SIZE_IN_BYTES] = [0; FUNCTION_CALL_SIZE_IN_BYTES];\n    let args_hash_bytes = self.args_hash.to_be_bytes(32);\n    for i in 0..32 { bytes[i] = args_hash_bytes[i]; }\n    let function_selector_bytes = self.function_selector.to_field().to_be_bytes(32);\n    for i in 0..32 { bytes[i + 32] = function_selector_bytes[i]; }\n    let target_address_bytes = self.target_address.to_field().to_be_bytes(32);\n    for i in 0..32 { bytes[i + 64] = target_address_bytes[i]; }\n    bytes[96] = self.is_public as u8;\n    bytes\n  }\n}\n\n// FUNCTION_CALL_SIZE * ACCOUNT_MAX_CALLS + 1\nglobal ENTRYPOINT_PAYLOAD_SIZE: Field = 17;\n// FUNCTION_CALL_SIZE_IN_BYTES * ACCOUNT_MAX_CALLS + 32\nglobal ENTRYPOINT_PAYLOAD_SIZE_IN_BYTES: Field = 420;\n\n// Note: If you change the following struct you have to update default_entrypoint.ts\n// docs:start:entrypoint-struct\nstruct EntrypointPayload {\n  function_calls: [FunctionCall; ACCOUNT_MAX_CALLS],\n  nonce: Field,\n}\n// docs:end:entrypoint-struct\n\nimpl EntrypointPayload {\n  fn hash(self) -> Field {\n    pedersen_hash(\n      self.serialize(), \n      GENERATOR_INDEX__SIGNATURE_PAYLOAD\n    )\n  }\n\n  // Serializes the entrypoint struct\n  fn serialize(self) -> [Field; ENTRYPOINT_PAYLOAD_SIZE] {\n    let mut fields: BoundedVec<Field, ENTRYPOINT_PAYLOAD_SIZE> = BoundedVec::new(0); \n    for call in self.function_calls {\n      fields.push_array(call.serialize());\n    }\n    fields.push(self.nonce);\n    fields.storage\n  }\n\n  // Serializes the payload as an array of bytes. Useful for hashing with sha256.\n  fn to_be_bytes(self) -> [u8; ENTRYPOINT_PAYLOAD_SIZE_IN_BYTES] {\n    let mut bytes: [u8; ENTRYPOINT_PAYLOAD_SIZE_IN_BYTES] = [0; ENTRYPOINT_PAYLOAD_SIZE_IN_BYTES];\n\n    for i in 0..ACCOUNT_MAX_CALLS {\n      let item_bytes = self.function_calls[i].to_be_bytes();\n      for j in 0..FUNCTION_CALL_SIZE_IN_BYTES { \n        bytes[i * FUNCTION_CALL_SIZE_IN_BYTES + j] = item_bytes[j];\n      }\n    }\n\n    let nonce_bytes = self.nonce.to_be_bytes(32);\n    let nonce_offset = FUNCTION_CALL_SIZE_IN_BYTES * ACCOUNT_MAX_CALLS;\n    for j in 0..32 {\n      bytes[nonce_offset + j] = nonce_bytes[j];\n    }\n    \n    bytes\n  }\n\n  // Executes all private and public calls \n  // docs:start:entrypoint-execute-calls\n  fn execute_calls(self, context: &mut PrivateContext) {\n    for call in self.function_calls {\n      if !call.target_address.is_zero() {\n        if call.is_public {\n          context.call_public_function_with_packed_args(\n            call.target_address, call.function_selector, call.args_hash\n          );\n        } else {\n          let _result = context.call_private_function_with_packed_args(\n            call.target_address, call.function_selector, call.args_hash\n          );\n        }\n      }\n    }\n  }\n  // docs:end:entrypoint-execute-calls\n}\n",
+        "198": {
+            "source": "use dep::aztec::context::PrivateContext;\nuse dep::aztec::protocol_types::{\n  abis::function_selector::FunctionSelector,\n  address::AztecAddress,\n  constants::GENERATOR_INDEX__SIGNATURE_PAYLOAD,\n  hash::pedersen_hash,\n  traits::{Hash, Serialize}\n};\n\nglobal ACCOUNT_MAX_CALLS: Field = 4;\n// 1 (ARGS_HASH) + 1 (FUNCTION_SELECTOR) + 1 (TARGET_ADDRESS) + 1 (IS_PUBLIC)\nglobal FUNCTION_CALL_SIZE: Field = 4;\n// 3 * 32 + 1\nglobal FUNCTION_CALL_SIZE_IN_BYTES: Field = 97;\n\nstruct FunctionCall {\n  args_hash: Field,\n  function_selector: FunctionSelector,\n  target_address: AztecAddress,\n  is_public: bool,\n}\n\nimpl Serialize<FUNCTION_CALL_SIZE> for FunctionCall {\n  fn serialize(self) -> [Field; FUNCTION_CALL_SIZE] {\n    [self.args_hash, self.function_selector.to_field(), self.target_address.to_field(), self.is_public as Field]\n  }\n}\n\nimpl FunctionCall {\n  fn to_be_bytes(self) -> [u8; FUNCTION_CALL_SIZE_IN_BYTES] {\n    let mut bytes: [u8; FUNCTION_CALL_SIZE_IN_BYTES] = [0; FUNCTION_CALL_SIZE_IN_BYTES];\n    let args_hash_bytes = self.args_hash.to_be_bytes(32);\n    for i in 0..32 { bytes[i] = args_hash_bytes[i]; }\n    let function_selector_bytes = self.function_selector.to_field().to_be_bytes(32);\n    for i in 0..32 { bytes[i + 32] = function_selector_bytes[i]; }\n    let target_address_bytes = self.target_address.to_field().to_be_bytes(32);\n    for i in 0..32 { bytes[i + 64] = target_address_bytes[i]; }\n    bytes[96] = self.is_public as u8;\n    bytes\n  }\n}\n\n// FUNCTION_CALL_SIZE * ACCOUNT_MAX_CALLS + 1\nglobal ENTRYPOINT_PAYLOAD_SIZE: Field = 17;\n// FUNCTION_CALL_SIZE_IN_BYTES * ACCOUNT_MAX_CALLS + 32\nglobal ENTRYPOINT_PAYLOAD_SIZE_IN_BYTES: Field = 420;\n\n// Note: If you change the following struct you have to update default_entrypoint.ts\n// docs:start:entrypoint-struct\nstruct EntrypointPayload {\n  function_calls: [FunctionCall; ACCOUNT_MAX_CALLS],\n  nonce: Field,\n}\n// docs:end:entrypoint-struct\n\nimpl Serialize<ENTRYPOINT_PAYLOAD_SIZE> for EntrypointPayload {\n  // Serializes the entrypoint struct\n  fn serialize(self) -> [Field; ENTRYPOINT_PAYLOAD_SIZE] {\n    let mut fields: BoundedVec<Field, ENTRYPOINT_PAYLOAD_SIZE> = BoundedVec::new(0); \n    for call in self.function_calls {\n      fields.extend_from_array(call.serialize());\n    }\n    fields.push(self.nonce);\n    fields.storage\n  }\n}\n\nimpl Hash for EntrypointPayload {\n  fn hash(self) -> Field {\n    pedersen_hash(\n      self.serialize(), \n      GENERATOR_INDEX__SIGNATURE_PAYLOAD\n    )\n  }\n}\n\nimpl EntrypointPayload {\n  // Serializes the payload as an array of bytes. Useful for hashing with sha256.\n  fn to_be_bytes(self) -> [u8; ENTRYPOINT_PAYLOAD_SIZE_IN_BYTES] {\n    let mut bytes: [u8; ENTRYPOINT_PAYLOAD_SIZE_IN_BYTES] = [0; ENTRYPOINT_PAYLOAD_SIZE_IN_BYTES];\n\n    for i in 0..ACCOUNT_MAX_CALLS {\n      let item_bytes = self.function_calls[i].to_be_bytes();\n      for j in 0..FUNCTION_CALL_SIZE_IN_BYTES { \n        bytes[i * FUNCTION_CALL_SIZE_IN_BYTES + j] = item_bytes[j];\n      }\n    }\n\n    let nonce_bytes = self.nonce.to_be_bytes(32);\n    let nonce_offset = FUNCTION_CALL_SIZE_IN_BYTES * ACCOUNT_MAX_CALLS;\n    for j in 0..32 {\n      bytes[nonce_offset + j] = nonce_bytes[j];\n    }\n    \n    bytes\n  }\n\n  // Executes all private and public calls \n  // docs:start:entrypoint-execute-calls\n  fn execute_calls(self, context: &mut PrivateContext) {\n    for call in self.function_calls {\n      if !call.target_address.is_zero() {\n        if call.is_public {\n          context.call_public_function_with_packed_args(\n            call.target_address, call.function_selector, call.args_hash\n          );\n        } else {\n          let _result = context.call_private_function_with_packed_args(\n            call.target_address, call.function_selector, call.args_hash\n          );\n        }\n      }\n    }\n  }\n  // docs:end:entrypoint-execute-calls\n}\n",
             "path": "/usr/src/yarn-project/aztec-nr/authwit/src/entrypoint.nr"
         },
-        "189": {
-            "source": "use dep::aztec::context::{PrivateContext, PublicContext, Context};\nuse dep::aztec::state_vars::{map::Map, public_state::PublicState};\nuse dep::aztec::types::type_serialization::bool_serialization::{BoolSerializationMethods,BOOL_SERIALIZED_LEN};\n\nuse crate::entrypoint::EntrypointPayload;\nuse crate::auth::IS_VALID_SELECTOR;\n\nstruct AccountActions {\n  context: Context,\n  is_valid_impl: fn(&mut PrivateContext, Field) -> bool,\n  approved_action: Map<Field, PublicState<bool, BOOL_SERIALIZED_LEN>>,\n}\n\nimpl AccountActions {\n  pub fn init(context: Context, approved_action_storage_slot: Field, is_valid_impl: fn(&mut PrivateContext, Field) -> bool) -> Self {\n    AccountActions {\n      context: context,\n      is_valid_impl: is_valid_impl,\n      approved_action: Map::new(\n        context,\n        approved_action_storage_slot,\n        |context, slot| {\n          PublicState::new(context, slot, BoolSerializationMethods)\n        },\n      ),\n    }\n  }\n\n  pub fn private(context: &mut PrivateContext, approved_action_storage_slot: Field, is_valid_impl: fn(&mut PrivateContext, Field) -> bool) -> Self {\n    AccountActions::init(Context::private(context), approved_action_storage_slot, is_valid_impl)\n  }\n\n  pub fn public(context: &mut PublicContext, approved_action_storage_slot: Field, is_valid_impl: fn(&mut PrivateContext, Field) -> bool) -> Self {\n    AccountActions::init(Context::public(context), approved_action_storage_slot, is_valid_impl)\n  }\n  \n  // docs:start:entrypoint\n  pub fn entrypoint(self, payload: EntrypointPayload) {\n    let message_hash = payload.hash();\n    let valid_fn = self.is_valid_impl;\n    let private_context = self.context.private.unwrap();\n    assert(valid_fn(private_context, message_hash));\n    payload.execute_calls(private_context);\n  }\n  // docs:end:entrypoint\n\n  pub fn is_valid(self, message_hash: Field) -> Field {\n    let valid_fn = self.is_valid_impl;\n    if (valid_fn(self.context.private.unwrap(), message_hash)) {\n        IS_VALID_SELECTOR\n    } else {\n        0\n    }\n  }\n\n  pub fn is_valid_public(self, message_hash: Field) -> Field {\n    let value = self.approved_action.at(message_hash).read();\n    if (value){\n        IS_VALID_SELECTOR\n    } else {\n        0\n    }\n  }\n\n  pub fn internal_set_is_valid_storage(self, message_hash: Field, value: bool) {\n    self.approved_action.at(message_hash).write(value);\n  }\n}\n",
+        "199": {
+            "source": "use dep::aztec::context::{PrivateContext, PublicContext, Context};\nuse dep::aztec::state_vars::{map::Map, public_state::PublicState};\n\nuse crate::entrypoint::EntrypointPayload;\nuse crate::auth::IS_VALID_SELECTOR;\n\nstruct AccountActions {\n  context: Context,\n  is_valid_impl: fn(&mut PrivateContext, Field) -> bool,\n  approved_action: Map<Field, PublicState<bool>>,\n}\n\nimpl AccountActions {\n  pub fn init(context: Context, approved_action_storage_slot: Field, is_valid_impl: fn(&mut PrivateContext, Field) -> bool) -> Self {\n    AccountActions {\n      context: context,\n      is_valid_impl: is_valid_impl,\n      approved_action: Map::new(\n        context,\n        approved_action_storage_slot,\n        |context, slot| {\n          PublicState::new(context, slot)\n        },\n      ),\n    }\n  }\n\n  pub fn private(context: &mut PrivateContext, approved_action_storage_slot: Field, is_valid_impl: fn(&mut PrivateContext, Field) -> bool) -> Self {\n    AccountActions::init(Context::private(context), approved_action_storage_slot, is_valid_impl)\n  }\n\n  pub fn public(context: &mut PublicContext, approved_action_storage_slot: Field, is_valid_impl: fn(&mut PrivateContext, Field) -> bool) -> Self {\n    AccountActions::init(Context::public(context), approved_action_storage_slot, is_valid_impl)\n  }\n  \n  // docs:start:entrypoint\n  pub fn entrypoint(self, payload: EntrypointPayload) {\n    let message_hash = payload.hash();\n    let valid_fn = self.is_valid_impl;\n    let private_context = self.context.private.unwrap();\n    assert(valid_fn(private_context, message_hash));\n    payload.execute_calls(private_context);\n  }\n  // docs:end:entrypoint\n\n  pub fn is_valid(self, message_hash: Field) -> Field {\n    let valid_fn = self.is_valid_impl;\n    if (valid_fn(self.context.private.unwrap(), message_hash)) {\n        IS_VALID_SELECTOR\n    } else {\n        0\n    }\n  }\n\n  pub fn is_valid_public(self, message_hash: Field) -> Field {\n    let value = self.approved_action.at(message_hash).read();\n    if (value){\n        IS_VALID_SELECTOR\n    } else {\n        0\n    }\n  }\n\n  pub fn internal_set_is_valid_storage(self, message_hash: Field, value: bool) {\n    self.approved_action.at(message_hash).write(value);\n  }\n}\n",
             "path": "/usr/src/yarn-project/aztec-nr/authwit/src/account.nr"
         },
-        "192": {
+        "202": {
             "source": "#[oracle(getAuthWitness)]\nfn get_auth_witness_oracle<N>(_message_hash: Field) -> [Field; N] {}\n\nunconstrained pub fn get_auth_witness<N>(message_hash: Field) -> [Field; N] {\n    get_auth_witness_oracle(message_hash)\n}\n",
             "path": "/usr/src/yarn-project/aztec-nr/authwit/src/auth_witness.nr"
         },
-        "213": {
+        "223": {
             "source": "mod util;\nmod auth_oracle;\n\ncontract SchnorrSingleKeyAccount {\n    use dep::std::{\n        option::Option,\n    };\n    use dep::aztec::context::{ PrivateContext, PublicContext, Context };\n\n    use dep::authwit::{\n        entrypoint::EntrypointPayload,\n        account::AccountActions,\n    };\n\n    use crate::{ util::recover_address, auth_oracle::get_auth_witness };\n\n    global ACCOUNT_ACTIONS_STORAGE_SLOT = 1;\n\n    #[aztec(private)]\n    fn constructor() {}\n\n    // Note: If you globally change the entrypoint signature don't forget to update default_entrypoint.ts\n    #[aztec(private)]\n    fn entrypoint(payload: pub EntrypointPayload) {\n        let actions = AccountActions::private(&mut context, ACCOUNT_ACTIONS_STORAGE_SLOT, is_valid_impl);\n        actions.entrypoint(payload);\n    }\n\n    #[aztec(private)]\n    fn is_valid(message_hash: Field) -> Field {\n        let actions = AccountActions::private(&mut context, ACCOUNT_ACTIONS_STORAGE_SLOT, is_valid_impl);\n        actions.is_valid(message_hash)\n    }\n\n    #[aztec(public)]\n    fn is_valid_public(message_hash: Field) -> Field {\n        let actions = AccountActions::public(&mut context, ACCOUNT_ACTIONS_STORAGE_SLOT, is_valid_impl);\n        actions.is_valid_public(message_hash)\n    }\n\n    #[aztec(public)]\n    internal fn set_is_valid_storage(message_hash: Field, value: bool) {\n        let actions = AccountActions::public(&mut context, ACCOUNT_ACTIONS_STORAGE_SLOT, is_valid_impl);\n        actions.internal_set_is_valid_storage(message_hash, value)\n    }\n\n    #[contract_library_method]\n    fn is_valid_impl(context: &mut PrivateContext, message_hash: Field) -> pub bool {\n        let witness = get_auth_witness(message_hash);\n        assert(recover_address(message_hash, witness).eq(context.this_address()));\n        true\n    }\n}\n",
             "path": "/usr/src/yarn-project/noir-contracts/contracts/schnorr_single_key_account_contract/src/main.nr"
         },
-        "214": {
+        "224": {
             "source": "use dep::authwit::auth_witness;\nuse dep::aztec::protocol_types::{\n    address::PartialAddress,\n    grumpkin_point::GrumpkinPoint,\n};\n\nstruct AuthWitness {\n    owner: GrumpkinPoint,\n    signature: [u8; 64],\n    partial_address: PartialAddress,\n}\n\nimpl AuthWitness {\n    fn deserialize(values: [Field; 67]) -> Self {\n        let mut signature = [0; 64];\n        for i in 0..64 {\n            signature[i] = values[i + 2] as u8;\n        }\n        Self {\n            owner: GrumpkinPoint::new(values[0], values[1]),\n            signature,\n            partial_address: PartialAddress::from_field(values[66]),\n        }\n    }\n}\n\nunconstrained pub fn get_auth_witness(message_hash: Field) -> AuthWitness {\n    let witness: [Field; 67] = auth_witness::get_auth_witness(message_hash);\n    AuthWitness::deserialize(witness)\n}\n",
             "path": "/usr/src/yarn-project/noir-contracts/contracts/schnorr_single_key_account_contract/src/auth_oracle.nr"
         },
-        "215": {
-            "source": "use dep::aztec::protocol_types::address::AztecAddress;\nuse dep::std::{schnorr::verify_signature};\nuse crate::auth_oracle::{AuthWitness};\n\npub fn recover_address(message_hash: Field, witness: AuthWitness) -> AztecAddress {\n    let message_bytes = message_hash.to_be_bytes(32);\n    let verification = verify_signature(\n        witness.owner.x,\n        witness.owner.y,\n        witness.signature,\n        message_bytes\n    );\n    assert(verification == true);\n\n    AztecAddress::compute(witness.owner, witness.partial_address)\n}\n",
+        "225": {
+            "source": "use dep::aztec::protocol_types::address::{AztecAddress, PublicKeysHash};\nuse dep::std::{schnorr::verify_signature};\nuse crate::auth_oracle::{AuthWitness};\n\npub fn recover_address(message_hash: Field, witness: AuthWitness) -> AztecAddress {\n    let message_bytes = message_hash.to_be_bytes(32);\n    let verification = verify_signature(\n        witness.owner.x,\n        witness.owner.y,\n        witness.signature,\n        message_bytes\n    );\n    assert(verification == true);\n\n    AztecAddress::compute(\n        PublicKeysHash::compute(witness.owner),\n        witness.partial_address\n    )\n}\n",
             "path": "/usr/src/yarn-project/noir-contracts/contracts/schnorr_single_key_account_contract/src/util.nr"
         }
     }