{"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.20+commit.a1b79de6","compilerSettings":{"libraries":{},"optimizer":{"runs":200,"enabled":true},"evmVersion":"london"},"name":"TimelockController","fullyQualifiedName":"TimelockController.sol:TimelockController"},"sources":{"TimelockController.sol":{"content":"// SPDX-License-Identifier: MIT\r\npragma solidity ^0.8.0 ^0.8.1 ^0.8.16;\r\n\r\n// contracts/external/openzeppelin/contracts/utils/Address.sol\r\n\r\n// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)\r\n\r\n/**\r\n * @dev Collection of functions related to the address type\r\n */\r\nlibrary Address {\r\n  /**\r\n   * @dev Returns true if `account` is a contract.\r\n   *\r\n   * [IMPORTANT]\r\n   * ====\r\n   * It is unsafe to assume that an address for which this function returns\r\n   * false is an externally-owned account (EOA) and not a contract.\r\n   *\r\n   * Among others, `isContract` will return false for the following\r\n   * types of addresses:\r\n   *\r\n   *  - an externally-owned account\r\n   *  - a contract in construction\r\n   *  - an address where a contract will be created\r\n   *  - an address where a contract lived, but was destroyed\r\n   * ====\r\n   *\r\n   * [IMPORTANT]\r\n   * ====\r\n   * You shouldn't rely on `isContract` to protect against flash loan attacks!\r\n   *\r\n   * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\r\n   * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\r\n   * constructor.\r\n   * ====\r\n   */\r\n  function isContract(address account) internal view returns (bool) {\r\n    // This method relies on extcodesize/address.code.length, which returns 0\r\n    // for contracts in construction, since the code is only stored at the end\r\n    // of the constructor execution.\r\n\r\n    return account.code.length > 0;\r\n  }\r\n\r\n  /**\r\n   * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\r\n   * `recipient`, forwarding all available gas and reverting on errors.\r\n   *\r\n   * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\r\n   * of certain opcodes, possibly making contracts go over the 2300 gas limit\r\n   * imposed by `transfer`, making them unable to receive funds via\r\n   * `transfer`. {sendValue} removes this limitation.\r\n   *\r\n   * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\r\n   *\r\n   * IMPORTANT: because control is transferred to `recipient`, care must be\r\n   * taken to not create reentrancy vulnerabilities. Consider using\r\n   * {ReentrancyGuard} or the\r\n   * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\r\n   */\r\n  function sendValue(address payable recipient, uint256 amount) internal {\r\n    require(address(this).balance >= amount, \"Address: insufficient balance\");\r\n\r\n    (bool success, ) = recipient.call{value: amount}(\"\");\r\n    require(\r\n      success,\r\n      \"Address: unable to send value, recipient may have reverted\"\r\n    );\r\n  }\r\n\r\n  /**\r\n   * @dev Performs a Solidity function call using a low level `call`. A\r\n   * plain `call` is an unsafe replacement for a function call: use this\r\n   * function instead.\r\n   *\r\n   * If `target` reverts with a revert reason, it is bubbled up by this\r\n   * function (like regular Solidity function calls).\r\n   *\r\n   * Returns the raw returned data. To convert to the expected return value,\r\n   * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\r\n   *\r\n   * Requirements:\r\n   *\r\n   * - `target` must be a contract.\r\n   * - calling `target` with `data` must not revert.\r\n   *\r\n   * _Available since v3.1._\r\n   */\r\n  function functionCall(address target, bytes memory data)\r\n    internal\r\n    returns (bytes memory)\r\n  {\r\n    return functionCall(target, data, \"Address: low-level call failed\");\r\n  }\r\n\r\n  /**\r\n   * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\r\n   * `errorMessage` as a fallback revert reason when `target` reverts.\r\n   *\r\n   * _Available since v3.1._\r\n   */\r\n  function functionCall(\r\n    address target,\r\n    bytes memory data,\r\n    string memory errorMessage\r\n  ) internal returns (bytes memory) {\r\n    return functionCallWithValue(target, data, 0, errorMessage);\r\n  }\r\n\r\n  /**\r\n   * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\r\n   * but also transferring `value` wei to `target`.\r\n   *\r\n   * Requirements:\r\n   *\r\n   * - the calling contract must have an ETH balance of at least `value`.\r\n   * - the called Solidity function must be `payable`.\r\n   *\r\n   * _Available since v3.1._\r\n   */\r\n  function functionCallWithValue(\r\n    address target,\r\n    bytes memory data,\r\n    uint256 value\r\n  ) internal returns (bytes memory) {\r\n    return\r\n      functionCallWithValue(\r\n        target,\r\n        data,\r\n        value,\r\n        \"Address: low-level call with value failed\"\r\n      );\r\n  }\r\n\r\n  /**\r\n   * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\r\n   * with `errorMessage` as a fallback revert reason when `target` reverts.\r\n   *\r\n   * _Available since v3.1._\r\n   */\r\n  function functionCallWithValue(\r\n    address target,\r\n    bytes memory data,\r\n    uint256 value,\r\n    string memory errorMessage\r\n  ) internal returns (bytes memory) {\r\n    require(\r\n      address(this).balance >= value,\r\n      \"Address: insufficient balance for call\"\r\n    );\r\n    require(isContract(target), \"Address: call to non-contract\");\r\n\r\n    (bool success, bytes memory returndata) = target.call{value: value}(data);\r\n    return verifyCallResult(success, returndata, errorMessage);\r\n  }\r\n\r\n  /**\r\n   * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\r\n   * but performing a static call.\r\n   *\r\n   * _Available since v3.3._\r\n   */\r\n  function functionStaticCall(address target, bytes memory data)\r\n    internal\r\n    view\r\n    returns (bytes memory)\r\n  {\r\n    return\r\n      functionStaticCall(target, data, \"Address: low-level static call failed\");\r\n  }\r\n\r\n  /**\r\n   * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\r\n   * but performing a static call.\r\n   *\r\n   * _Available since v3.3._\r\n   */\r\n  function functionStaticCall(\r\n    address target,\r\n    bytes memory data,\r\n    string memory errorMessage\r\n  ) internal view returns (bytes memory) {\r\n    require(isContract(target), \"Address: static call to non-contract\");\r\n\r\n    (bool success, bytes memory returndata) = target.staticcall(data);\r\n    return verifyCallResult(success, returndata, errorMessage);\r\n  }\r\n\r\n  /**\r\n   * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\r\n   * but performing a delegate call.\r\n   *\r\n   * _Available since v3.4._\r\n   */\r\n  function functionDelegateCall(address target, bytes memory data)\r\n    internal\r\n    returns (bytes memory)\r\n  {\r\n    return\r\n      functionDelegateCall(\r\n        target,\r\n        data,\r\n        \"Address: low-level delegate call failed\"\r\n      );\r\n  }\r\n\r\n  /**\r\n   * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\r\n   * but performing a delegate call.\r\n   *\r\n   * _Available since v3.4._\r\n   */\r\n  function functionDelegateCall(\r\n    address target,\r\n    bytes memory data,\r\n    string memory errorMessage\r\n  ) internal returns (bytes memory) {\r\n    require(isContract(target), \"Address: delegate call to non-contract\");\r\n\r\n    (bool success, bytes memory returndata) = target.delegatecall(data);\r\n    return verifyCallResult(success, returndata, errorMessage);\r\n  }\r\n\r\n  /**\r\n   * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\r\n   * revert reason using the provided one.\r\n   *\r\n   * _Available since v4.3._\r\n   */\r\n  function verifyCallResult(\r\n    bool success,\r\n    bytes memory returndata,\r\n    string memory errorMessage\r\n  ) internal pure returns (bytes memory) {\r\n    if (success) {\r\n      return returndata;\r\n    } else {\r\n      // Look for revert reason and bubble it up if present\r\n      if (returndata.length > 0) {\r\n        // The easiest way to bubble the revert reason is using memory via assembly\r\n\r\n        assembly {\r\n          let returndata_size := mload(returndata)\r\n          revert(add(32, returndata), returndata_size)\r\n        }\r\n      } else {\r\n        revert(errorMessage);\r\n      }\r\n    }\r\n  }\r\n}\r\n\r\n// contracts/external/openzeppelin/contracts/utils/Context.sol\r\n\r\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\r\n\r\n/**\r\n * @dev Provides information about the current execution context, including the\r\n * sender of the transaction and its data. While these are generally available\r\n * via msg.sender and msg.data, they should not be accessed in such a direct\r\n * manner, since when dealing with meta-transactions the account sending and\r\n * paying for execution may not be the actual sender (as far as an application\r\n * is concerned).\r\n *\r\n * This contract is only required for intermediate, library-like contracts.\r\n */\r\nabstract contract Context {\r\n  function _msgSender() internal view virtual returns (address) {\r\n    return msg.sender;\r\n  }\r\n\r\n  function _msgData() internal view virtual returns (bytes calldata) {\r\n    return msg.data;\r\n  }\r\n}\r\n\r\n// contracts/external/openzeppelin/contracts/utils/EnumerableSet.sol\r\n\r\n// OpenZeppelin Contracts v4.4.1 (utils/structs/EnumerableSet.sol)\r\n\r\n/**\r\n * @dev Library for managing\r\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\r\n * types.\r\n *\r\n * Sets have the following properties:\r\n *\r\n * - Elements are added, removed, and checked for existence in constant time\r\n * (O(1)).\r\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\r\n *\r\n * ```\r\n * contract Example {\r\n *     // Add the library methods\r\n *     using EnumerableSet for EnumerableSet.AddressSet;\r\n *\r\n *     // Declare a set state variable\r\n *     EnumerableSet.AddressSet private mySet;\r\n * }\r\n * ```\r\n *\r\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\r\n * and `uint256` (`UintSet`) are supported.\r\n */\r\nlibrary EnumerableSet {\r\n  // To implement this library for multiple types with as little code\r\n  // repetition as possible, we write it in terms of a generic Set type with\r\n  // bytes32 values.\r\n  // The Set implementation uses private functions, and user-facing\r\n  // implementations (such as AddressSet) are just wrappers around the\r\n  // underlying Set.\r\n  // This means that we can only create new EnumerableSets for types that fit\r\n  // in bytes32.\r\n\r\n  struct Set {\r\n    // Storage of set values\r\n    bytes32[] _values;\r\n    // Position of the value in the `values` array, plus 1 because index 0\r\n    // means a value is not in the set.\r\n    mapping(bytes32 => uint256) _indexes;\r\n  }\r\n\r\n  /**\r\n   * @dev Add a value to a set. O(1).\r\n   *\r\n   * Returns true if the value was added to the set, that is if it was not\r\n   * already present.\r\n   */\r\n  function _add(Set storage set, bytes32 value) private returns (bool) {\r\n    if (!_contains(set, value)) {\r\n      set._values.push(value);\r\n      // The value is stored at length-1, but we add 1 to all indexes\r\n      // and use 0 as a sentinel value\r\n      set._indexes[value] = set._values.length;\r\n      return true;\r\n    } else {\r\n      return false;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * @dev Removes a value from a set. O(1).\r\n   *\r\n   * Returns true if the value was removed from the set, that is if it was\r\n   * present.\r\n   */\r\n  function _remove(Set storage set, bytes32 value) private returns (bool) {\r\n    // We read and store the value's index to prevent multiple reads from the same storage slot\r\n    uint256 valueIndex = set._indexes[value];\r\n\r\n    if (valueIndex != 0) {\r\n      // Equivalent to contains(set, value)\r\n      // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\r\n      // the array, and then remove the last element (sometimes called as 'swap and pop').\r\n      // This modifies the order of the array, as noted in {at}.\r\n\r\n      uint256 toDeleteIndex = valueIndex - 1;\r\n      uint256 lastIndex = set._values.length - 1;\r\n\r\n      if (lastIndex != toDeleteIndex) {\r\n        bytes32 lastvalue = set._values[lastIndex];\r\n\r\n        // Move the last value to the index where the value to delete is\r\n        set._values[toDeleteIndex] = lastvalue;\r\n        // Update the index for the moved value\r\n        set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\r\n      }\r\n\r\n      // Delete the slot where the moved value was stored\r\n      set._values.pop();\r\n\r\n      // Delete the index for the deleted slot\r\n      delete set._indexes[value];\r\n\r\n      return true;\r\n    } else {\r\n      return false;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * @dev Returns true if the value is in the set. O(1).\r\n   */\r\n  function _contains(Set storage set, bytes32 value)\r\n    private\r\n    view\r\n    returns (bool)\r\n  {\r\n    return set._indexes[value] != 0;\r\n  }\r\n\r\n  /**\r\n   * @dev Returns the number of values on the set. O(1).\r\n   */\r\n  function _length(Set storage set) private view returns (uint256) {\r\n    return set._values.length;\r\n  }\r\n\r\n  /**\r\n   * @dev Returns the value stored at position `index` in the set. O(1).\r\n   *\r\n   * Note that there are no guarantees on the ordering of values inside the\r\n   * array, and it may change when more values are added or removed.\r\n   *\r\n   * Requirements:\r\n   *\r\n   * - `index` must be strictly less than {length}.\r\n   */\r\n  function _at(Set storage set, uint256 index) private view returns (bytes32) {\r\n    return set._values[index];\r\n  }\r\n\r\n  /**\r\n   * @dev Return the entire set in an array\r\n   *\r\n   * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\r\n   * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\r\n   * this function has an unbounded cost, and using it as part of a state-changing function may render the function\r\n   * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\r\n   */\r\n  function _values(Set storage set) private view returns (bytes32[] memory) {\r\n    return set._values;\r\n  }\r\n\r\n  // Bytes32Set\r\n\r\n  struct Bytes32Set {\r\n    Set _inner;\r\n  }\r\n\r\n  /**\r\n   * @dev Add a value to a set. O(1).\r\n   *\r\n   * Returns true if the value was added to the set, that is if it was not\r\n   * already present.\r\n   */\r\n  function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\r\n    return _add(set._inner, value);\r\n  }\r\n\r\n  /**\r\n   * @dev Removes a value from a set. O(1).\r\n   *\r\n   * Returns true if the value was removed from the set, that is if it was\r\n   * present.\r\n   */\r\n  function remove(Bytes32Set storage set, bytes32 value)\r\n    internal\r\n    returns (bool)\r\n  {\r\n    return _remove(set._inner, value);\r\n  }\r\n\r\n  /**\r\n   * @dev Returns true if the value is in the set. O(1).\r\n   */\r\n  function contains(Bytes32Set storage set, bytes32 value)\r\n    internal\r\n    view\r\n    returns (bool)\r\n  {\r\n    return _contains(set._inner, value);\r\n  }\r\n\r\n  /**\r\n   * @dev Returns the number of values in the set. O(1).\r\n   */\r\n  function length(Bytes32Set storage set) internal view returns (uint256) {\r\n    return _length(set._inner);\r\n  }\r\n\r\n  /**\r\n   * @dev Returns the value stored at position `index` in the set. O(1).\r\n   *\r\n   * Note that there are no guarantees on the ordering of values inside the\r\n   * array, and it may change when more values are added or removed.\r\n   *\r\n   * Requirements:\r\n   *\r\n   * - `index` must be strictly less than {length}.\r\n   */\r\n  function at(Bytes32Set storage set, uint256 index)\r\n    internal\r\n    view\r\n    returns (bytes32)\r\n  {\r\n    return _at(set._inner, index);\r\n  }\r\n\r\n  /**\r\n   * @dev Return the entire set in an array\r\n   *\r\n   * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\r\n   * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\r\n   * this function has an unbounded cost, and using it as part of a state-changing function may render the function\r\n   * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\r\n   */\r\n  function values(Bytes32Set storage set)\r\n    internal\r\n    view\r\n    returns (bytes32[] memory)\r\n  {\r\n    return _values(set._inner);\r\n  }\r\n\r\n  // AddressSet\r\n\r\n  struct AddressSet {\r\n    Set _inner;\r\n  }\r\n\r\n  /**\r\n   * @dev Add a value to a set. O(1).\r\n   *\r\n   * Returns true if the value was added to the set, that is if it was not\r\n   * already present.\r\n   */\r\n  function add(AddressSet storage set, address value) internal returns (bool) {\r\n    return _add(set._inner, bytes32(uint256(uint160(value))));\r\n  }\r\n\r\n  /**\r\n   * @dev Removes a value from a set. O(1).\r\n   *\r\n   * Returns true if the value was removed from the set, that is if it was\r\n   * present.\r\n   */\r\n  function remove(AddressSet storage set, address value)\r\n    internal\r\n    returns (bool)\r\n  {\r\n    return _remove(set._inner, bytes32(uint256(uint160(value))));\r\n  }\r\n\r\n  /**\r\n   * @dev Returns true if the value is in the set. O(1).\r\n   */\r\n  function contains(AddressSet storage set, address value)\r\n    internal\r\n    view\r\n    returns (bool)\r\n  {\r\n    return _contains(set._inner, bytes32(uint256(uint160(value))));\r\n  }\r\n\r\n  /**\r\n   * @dev Returns the number of values in the set. O(1).\r\n   */\r\n  function length(AddressSet storage set) internal view returns (uint256) {\r\n    return _length(set._inner);\r\n  }\r\n\r\n  /**\r\n   * @dev Returns the value stored at position `index` in the set. O(1).\r\n   *\r\n   * Note that there are no guarantees on the ordering of values inside the\r\n   * array, and it may change when more values are added or removed.\r\n   *\r\n   * Requirements:\r\n   *\r\n   * - `index` must be strictly less than {length}.\r\n   */\r\n  function at(AddressSet storage set, uint256 index)\r\n    internal\r\n    view\r\n    returns (address)\r\n  {\r\n    return address(uint160(uint256(_at(set._inner, index))));\r\n  }\r\n\r\n  /**\r\n   * @dev Return the entire set in an array\r\n   *\r\n   * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\r\n   * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\r\n   * this function has an unbounded cost, and using it as part of a state-changing function may render the function\r\n   * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\r\n   */\r\n  function values(AddressSet storage set)\r\n    internal\r\n    view\r\n    returns (address[] memory)\r\n  {\r\n    bytes32[] memory store = _values(set._inner);\r\n    address[] memory result;\r\n\r\n    assembly {\r\n      result := store\r\n    }\r\n\r\n    return result;\r\n  }\r\n\r\n  // UintSet\r\n\r\n  struct UintSet {\r\n    Set _inner;\r\n  }\r\n\r\n  /**\r\n   * @dev Add a value to a set. O(1).\r\n   *\r\n   * Returns true if the value was added to the set, that is if it was not\r\n   * already present.\r\n   */\r\n  function add(UintSet storage set, uint256 value) internal returns (bool) {\r\n    return _add(set._inner, bytes32(value));\r\n  }\r\n\r\n  /**\r\n   * @dev Removes a value from a set. O(1).\r\n   *\r\n   * Returns true if the value was removed from the set, that is if it was\r\n   * present.\r\n   */\r\n  function remove(UintSet storage set, uint256 value) internal returns (bool) {\r\n    return _remove(set._inner, bytes32(value));\r\n  }\r\n\r\n  /**\r\n   * @dev Returns true if the value is in the set. O(1).\r\n   */\r\n  function contains(UintSet storage set, uint256 value)\r\n    internal\r\n    view\r\n    returns (bool)\r\n  {\r\n    return _contains(set._inner, bytes32(value));\r\n  }\r\n\r\n  /**\r\n   * @dev Returns the number of values on the set. O(1).\r\n   */\r\n  function length(UintSet storage set) internal view returns (uint256) {\r\n    return _length(set._inner);\r\n  }\r\n\r\n  /**\r\n   * @dev Returns the value stored at position `index` in the set. O(1).\r\n   *\r\n   * Note that there are no guarantees on the ordering of values inside the\r\n   * array, and it may change when more values are added or removed.\r\n   *\r\n   * Requirements:\r\n   *\r\n   * - `index` must be strictly less than {length}.\r\n   */\r\n  function at(UintSet storage set, uint256 index)\r\n    internal\r\n    view\r\n    returns (uint256)\r\n  {\r\n    return uint256(_at(set._inner, index));\r\n  }\r\n\r\n  /**\r\n   * @dev Return the entire set in an array\r\n   *\r\n   * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\r\n   * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\r\n   * this function has an unbounded cost, and using it as part of a state-changing function may render the function\r\n   * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\r\n   */\r\n  function values(UintSet storage set)\r\n    internal\r\n    view\r\n    returns (uint256[] memory)\r\n  {\r\n    bytes32[] memory store = _values(set._inner);\r\n    uint256[] memory result;\r\n\r\n    assembly {\r\n      result := store\r\n    }\r\n\r\n    return result;\r\n  }\r\n}\r\n\r\n// contracts/external/openzeppelin/contracts/access/IAccessControl.sol\r\n\r\n// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)\r\n\r\n/**\r\n * @dev External interface of AccessControl declared to support ERC165 detection.\r\n */\r\ninterface IAccessControl {\r\n  /**\r\n   * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\r\n   *\r\n   * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\r\n   * {RoleAdminChanged} not being emitted signaling this.\r\n   *\r\n   * _Available since v3.1._\r\n   */\r\n  event RoleAdminChanged(\r\n    bytes32 indexed role,\r\n    bytes32 indexed previousAdminRole,\r\n    bytes32 indexed newAdminRole\r\n  );\r\n\r\n  /**\r\n   * @dev Emitted when `account` is granted `role`.\r\n   *\r\n   * `sender` is the account that originated the contract call, an admin role\r\n   * bearer except when using {AccessControl-_setupRole}.\r\n   */\r\n  event RoleGranted(\r\n    bytes32 indexed role,\r\n    address indexed account,\r\n    address indexed sender\r\n  );\r\n\r\n  /**\r\n   * @dev Emitted when `account` is revoked `role`.\r\n   *\r\n   * `sender` is the account that originated the contract call:\r\n   *   - if using `revokeRole`, it is the admin role bearer\r\n   *   - if using `renounceRole`, it is the role bearer (i.e. `account`)\r\n   */\r\n  event RoleRevoked(\r\n    bytes32 indexed role,\r\n    address indexed account,\r\n    address indexed sender\r\n  );\r\n\r\n  /**\r\n   * @dev Returns `true` if `account` has been granted `role`.\r\n   */\r\n  function hasRole(bytes32 role, address account) external view returns (bool);\r\n\r\n  /**\r\n   * @dev Returns the admin role that controls `role`. See {grantRole} and\r\n   * {revokeRole}.\r\n   *\r\n   * To change a role's admin, use {AccessControl-_setRoleAdmin}.\r\n   */\r\n  function getRoleAdmin(bytes32 role) external view returns (bytes32);\r\n\r\n  /**\r\n   * @dev Grants `role` to `account`.\r\n   *\r\n   * If `account` had not been already granted `role`, emits a {RoleGranted}\r\n   * event.\r\n   *\r\n   * Requirements:\r\n   *\r\n   * - the caller must have ``role``'s admin role.\r\n   */\r\n  function grantRole(bytes32 role, address account) external;\r\n\r\n  /**\r\n   * @dev Revokes `role` from `account`.\r\n   *\r\n   * If `account` had been granted `role`, emits a {RoleRevoked} event.\r\n   *\r\n   * Requirements:\r\n   *\r\n   * - the caller must have ``role``'s admin role.\r\n   */\r\n  function revokeRole(bytes32 role, address account) external;\r\n\r\n  /**\r\n   * @dev Revokes `role` from the calling account.\r\n   *\r\n   * Roles are often managed via {grantRole} and {revokeRole}: this function's\r\n   * purpose is to provide a mechanism for accounts to lose their privileges\r\n   * if they are compromised (such as when a trusted device is misplaced).\r\n   *\r\n   * If the calling account had been granted `role`, emits a {RoleRevoked}\r\n   * event.\r\n   *\r\n   * Requirements:\r\n   *\r\n   * - the caller must be `account`.\r\n   */\r\n  function renounceRole(bytes32 role, address account) external;\r\n}\r\n\r\n// contracts/external/openzeppelin/contracts/utils/IERC165.sol\r\n\r\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\r\n\r\n/**\r\n * @dev Interface of the ERC165 standard, as defined in the\r\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\r\n *\r\n * Implementers can declare support of contract interfaces, which can then be\r\n * queried by others ({ERC165Checker}).\r\n *\r\n * For an implementation, see {ERC165}.\r\n */\r\ninterface IERC165 {\r\n  /**\r\n   * @dev Returns true if this contract implements the interface defined by\r\n   * `interfaceId`. See the corresponding\r\n   * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\r\n   * to learn more about how these ids are created.\r\n   *\r\n   * This function call must use less than 30 000 gas.\r\n   */\r\n  function supportsInterface(bytes4 interfaceId) external view returns (bool);\r\n}\r\n\r\n// contracts/external/openzeppelin/contracts/utils/Strings.sol\r\n\r\n// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)\r\n\r\n/**\r\n * @dev String operations.\r\n */\r\nlibrary Strings {\r\n  bytes16 private constant _HEX_SYMBOLS = \"0123456789abcdef\";\r\n\r\n  /**\r\n   * @dev Converts a `uint256` to its ASCII `string` decimal representation.\r\n   */\r\n  function toString(uint256 value) internal pure returns (string memory) {\r\n    // Inspired by OraclizeAPI's implementation - MIT licence\r\n    // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\r\n\r\n    if (value == 0) {\r\n      return \"0\";\r\n    }\r\n    uint256 temp = value;\r\n    uint256 digits;\r\n    while (temp != 0) {\r\n      digits++;\r\n      temp /= 10;\r\n    }\r\n    bytes memory buffer = new bytes(digits);\r\n    while (value != 0) {\r\n      digits -= 1;\r\n      buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\r\n      value /= 10;\r\n    }\r\n    return string(buffer);\r\n  }\r\n\r\n  /**\r\n   * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\r\n   */\r\n  function toHexString(uint256 value) internal pure returns (string memory) {\r\n    if (value == 0) {\r\n      return \"0x00\";\r\n    }\r\n    uint256 temp = value;\r\n    uint256 length = 0;\r\n    while (temp != 0) {\r\n      length++;\r\n      temp >>= 8;\r\n    }\r\n    return toHexString(value, length);\r\n  }\r\n\r\n  /**\r\n   * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\r\n   */\r\n  function toHexString(uint256 value, uint256 length)\r\n    internal\r\n    pure\r\n    returns (string memory)\r\n  {\r\n    bytes memory buffer = new bytes(2 * length + 2);\r\n    buffer[0] = \"0\";\r\n    buffer[1] = \"x\";\r\n    for (uint256 i = 2 * length + 1; i > 1; --i) {\r\n      buffer[i] = _HEX_SYMBOLS[value & 0xf];\r\n      value >>= 4;\r\n    }\r\n    require(value == 0, \"Strings: hex length insufficient\");\r\n    return string(buffer);\r\n  }\r\n}\r\n\r\n// contracts/external/openzeppelin/contracts/utils/ERC165.sol\r\n\r\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)\r\n\r\n/**\r\n * @dev Implementation of the {IERC165} interface.\r\n *\r\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\r\n * for the additional interface id that will be supported. For example:\r\n *\r\n * ```solidity\r\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\r\n *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\r\n * }\r\n * ```\r\n *\r\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\r\n */\r\nabstract contract ERC165 is IERC165 {\r\n  /**\r\n   * @dev See {IERC165-supportsInterface}.\r\n   */\r\n  function supportsInterface(bytes4 interfaceId)\r\n    public\r\n    view\r\n    virtual\r\n    override\r\n    returns (bool)\r\n  {\r\n    return interfaceId == type(IERC165).interfaceId;\r\n  }\r\n}\r\n\r\n// contracts/external/openzeppelin/contracts/access/IAccessControlEnumerable.sol\r\n\r\n// OpenZeppelin Contracts v4.4.1 (access/IAccessControlEnumerable.sol)\r\n\r\n/**\r\n * @dev External interface of AccessControlEnumerable declared to support ERC165 detection.\r\n */\r\ninterface IAccessControlEnumerable is IAccessControl {\r\n  /**\r\n   * @dev Returns one of the accounts that have `role`. `index` must be a\r\n   * value between 0 and {getRoleMemberCount}, non-inclusive.\r\n   *\r\n   * Role bearers are not sorted in any particular way, and their ordering may\r\n   * change at any point.\r\n   *\r\n   * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure\r\n   * you perform all queries on the same block. See the following\r\n   * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]\r\n   * for more information.\r\n   */\r\n  function getRoleMember(bytes32 role, uint256 index)\r\n    external\r\n    view\r\n    returns (address);\r\n\r\n  /**\r\n   * @dev Returns the number of accounts that have `role`. Can be used\r\n   * together with {getRoleMember} to enumerate all bearers of a role.\r\n   */\r\n  function getRoleMemberCount(bytes32 role) external view returns (uint256);\r\n}\r\n\r\n// contracts/external/openzeppelin/contracts/access/AccessControl.sol\r\n\r\n// OpenZeppelin Contracts (last updated v4.5.0) (access/AccessControl.sol)\r\n\r\n/**\r\n * @dev Contract module that allows children to implement role-based access\r\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\r\n * members except through off-chain means by accessing the contract event logs. Some\r\n * applications may benefit from on-chain enumerability, for those cases see\r\n * {AccessControlEnumerable}.\r\n *\r\n * Roles are referred to by their `bytes32` identifier. These should be exposed\r\n * in the external API and be unique. The best way to achieve this is by\r\n * using `public constant` hash digests:\r\n *\r\n * ```\r\n * bytes32 public constant MY_ROLE = keccak256(\"MY_ROLE\");\r\n * ```\r\n *\r\n * Roles can be used to represent a set of permissions. To restrict access to a\r\n * function call, use {hasRole}:\r\n *\r\n * ```\r\n * function foo() public {\r\n *     require(hasRole(MY_ROLE, msg.sender));\r\n *     ...\r\n * }\r\n * ```\r\n *\r\n * Roles can be granted and revoked dynamically via the {grantRole} and\r\n * {revokeRole} functions. Each role has an associated admin role, and only\r\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\r\n *\r\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\r\n * that only accounts with this role will be able to grant or revoke other\r\n * roles. More complex role relationships can be created by using\r\n * {_setRoleAdmin}.\r\n *\r\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\r\n * grant and revoke this role. Extra precautions should be taken to secure\r\n * accounts that have been granted it.\r\n */\r\nabstract contract AccessControl is Context, IAccessControl, ERC165 {\r\n  struct RoleData {\r\n    mapping(address => bool) members;\r\n    bytes32 adminRole;\r\n  }\r\n\r\n  mapping(bytes32 => RoleData) private _roles;\r\n\r\n  bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\r\n\r\n  /**\r\n   * @dev Modifier that checks that an account has a specific role. Reverts\r\n   * with a standardized message including the required role.\r\n   *\r\n   * The format of the revert reason is given by the following regular expression:\r\n   *\r\n   *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\r\n   *\r\n   * _Available since v4.1._\r\n   */\r\n  modifier onlyRole(bytes32 role) {\r\n    _checkRole(role, _msgSender());\r\n    _;\r\n  }\r\n\r\n  /**\r\n   * @dev See {IERC165-supportsInterface}.\r\n   */\r\n  function supportsInterface(bytes4 interfaceId)\r\n    public\r\n    view\r\n    virtual\r\n    override\r\n    returns (bool)\r\n  {\r\n    return\r\n      interfaceId == type(IAccessControl).interfaceId ||\r\n      super.supportsInterface(interfaceId);\r\n  }\r\n\r\n  /**\r\n   * @dev Returns `true` if `account` has been granted `role`.\r\n   */\r\n  function hasRole(bytes32 role, address account)\r\n    public\r\n    view\r\n    virtual\r\n    override\r\n    returns (bool)\r\n  {\r\n    return _roles[role].members[account];\r\n  }\r\n\r\n  /**\r\n   * @dev Revert with a standard message if `account` is missing `role`.\r\n   *\r\n   * The format of the revert reason is given by the following regular expression:\r\n   *\r\n   *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\r\n   */\r\n  function _checkRole(bytes32 role, address account) internal view virtual {\r\n    if (!hasRole(role, account)) {\r\n      revert(\r\n        string(\r\n          abi.encodePacked(\r\n            \"AccessControl: account \",\r\n            Strings.toHexString(uint160(account), 20),\r\n            \" is missing role \",\r\n            Strings.toHexString(uint256(role), 32)\r\n          )\r\n        )\r\n      );\r\n    }\r\n  }\r\n\r\n  /**\r\n   * @dev Returns the admin role that controls `role`. See {grantRole} and\r\n   * {revokeRole}.\r\n   *\r\n   * To change a role's admin, use {_setRoleAdmin}.\r\n   */\r\n  function getRoleAdmin(bytes32 role)\r\n    public\r\n    view\r\n    virtual\r\n    override\r\n    returns (bytes32)\r\n  {\r\n    return _roles[role].adminRole;\r\n  }\r\n\r\n  /**\r\n   * @dev Grants `role` to `account`.\r\n   *\r\n   * If `account` had not been already granted `role`, emits a {RoleGranted}\r\n   * event.\r\n   *\r\n   * Requirements:\r\n   *\r\n   * - the caller must have ``role``'s admin role.\r\n   */\r\n  function grantRole(bytes32 role, address account)\r\n    public\r\n    virtual\r\n    override\r\n    onlyRole(getRoleAdmin(role))\r\n  {\r\n    _grantRole(role, account);\r\n  }\r\n\r\n  /**\r\n   * @dev Revokes `role` from `account`.\r\n   *\r\n   * If `account` had been granted `role`, emits a {RoleRevoked} event.\r\n   *\r\n   * Requirements:\r\n   *\r\n   * - the caller must have ``role``'s admin role.\r\n   */\r\n  function revokeRole(bytes32 role, address account)\r\n    public\r\n    virtual\r\n    override\r\n    onlyRole(getRoleAdmin(role))\r\n  {\r\n    _revokeRole(role, account);\r\n  }\r\n\r\n  /**\r\n   * @dev Revokes `role` from the calling account.\r\n   *\r\n   * Roles are often managed via {grantRole} and {revokeRole}: this function's\r\n   * purpose is to provide a mechanism for accounts to lose their privileges\r\n   * if they are compromised (such as when a trusted device is misplaced).\r\n   *\r\n   * If the calling account had been revoked `role`, emits a {RoleRevoked}\r\n   * event.\r\n   *\r\n   * Requirements:\r\n   *\r\n   * - the caller must be `account`.\r\n   */\r\n  function renounceRole(bytes32 role, address account) public virtual override {\r\n    require(\r\n      account == _msgSender(),\r\n      \"AccessControl: can only renounce roles for self\"\r\n    );\r\n\r\n    _revokeRole(role, account);\r\n  }\r\n\r\n  /**\r\n   * @dev Grants `role` to `account`.\r\n   *\r\n   * If `account` had not been already granted `role`, emits a {RoleGranted}\r\n   * event. Note that unlike {grantRole}, this function doesn't perform any\r\n   * checks on the calling account.\r\n   *\r\n   * [WARNING]\r\n   * ====\r\n   * This function should only be called from the constructor when setting\r\n   * up the initial roles for the system.\r\n   *\r\n   * Using this function in any other way is effectively circumventing the admin\r\n   * system imposed by {AccessControl}.\r\n   * ====\r\n   *\r\n   * NOTE: This function is deprecated in favor of {_grantRole}.\r\n   */\r\n  function _setupRole(bytes32 role, address account) internal virtual {\r\n    _grantRole(role, account);\r\n  }\r\n\r\n  /**\r\n   * @dev Sets `adminRole` as ``role``'s admin role.\r\n   *\r\n   * Emits a {RoleAdminChanged} event.\r\n   */\r\n  function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\r\n    bytes32 previousAdminRole = getRoleAdmin(role);\r\n    _roles[role].adminRole = adminRole;\r\n    emit RoleAdminChanged(role, previousAdminRole, adminRole);\r\n  }\r\n\r\n  /**\r\n   * @dev Grants `role` to `account`.\r\n   *\r\n   * Internal function without access restriction.\r\n   */\r\n  function _grantRole(bytes32 role, address account) internal virtual {\r\n    if (!hasRole(role, account)) {\r\n      _roles[role].members[account] = true;\r\n      emit RoleGranted(role, account, _msgSender());\r\n    }\r\n  }\r\n\r\n  /**\r\n   * @dev Revokes `role` from `account`.\r\n   *\r\n   * Internal function without access restriction.\r\n   */\r\n  function _revokeRole(bytes32 role, address account) internal virtual {\r\n    if (hasRole(role, account)) {\r\n      _roles[role].members[account] = false;\r\n      emit RoleRevoked(role, account, _msgSender());\r\n    }\r\n  }\r\n}\r\n\r\n// contracts/external/openzeppelin/contracts/access/AccessControlEnumerable.sol\r\n\r\n// OpenZeppelin Contracts (last updated v4.5.0) (access/AccessControlEnumerable.sol)\r\n\r\n/**\r\n * @dev Extension of {AccessControl} that allows enumerating the members of each role.\r\n */\r\nabstract contract AccessControlEnumerable is\r\n  IAccessControlEnumerable,\r\n  AccessControl\r\n{\r\n  using EnumerableSet for EnumerableSet.AddressSet;\r\n\r\n  mapping(bytes32 => EnumerableSet.AddressSet) private _roleMembers;\r\n\r\n  /**\r\n   * @dev See {IERC165-supportsInterface}.\r\n   */\r\n  function supportsInterface(bytes4 interfaceId)\r\n    public\r\n    view\r\n    virtual\r\n    override\r\n    returns (bool)\r\n  {\r\n    return\r\n      interfaceId == type(IAccessControlEnumerable).interfaceId ||\r\n      super.supportsInterface(interfaceId);\r\n  }\r\n\r\n  /**\r\n   * @dev Returns one of the accounts that have `role`. `index` must be a\r\n   * value between 0 and {getRoleMemberCount}, non-inclusive.\r\n   *\r\n   * Role bearers are not sorted in any particular way, and their ordering may\r\n   * change at any point.\r\n   *\r\n   * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure\r\n   * you perform all queries on the same block. See the following\r\n   * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]\r\n   * for more information.\r\n   */\r\n  function getRoleMember(bytes32 role, uint256 index)\r\n    public\r\n    view\r\n    virtual\r\n    override\r\n    returns (address)\r\n  {\r\n    return _roleMembers[role].at(index);\r\n  }\r\n\r\n  /**\r\n   * @dev Returns the number of accounts that have `role`. Can be used\r\n   * together with {getRoleMember} to enumerate all bearers of a role.\r\n   */\r\n  function getRoleMemberCount(bytes32 role)\r\n    public\r\n    view\r\n    virtual\r\n    override\r\n    returns (uint256)\r\n  {\r\n    return _roleMembers[role].length();\r\n  }\r\n\r\n  /**\r\n   * @dev Overload {_grantRole} to track enumerable memberships\r\n   */\r\n  function _grantRole(bytes32 role, address account) internal virtual override {\r\n    super._grantRole(role, account);\r\n    _roleMembers[role].add(account);\r\n  }\r\n\r\n  /**\r\n   * @dev Overload {_revokeRole} to track enumerable memberships\r\n   */\r\n  function _revokeRole(bytes32 role, address account)\r\n    internal\r\n    virtual\r\n    override\r\n  {\r\n    super._revokeRole(role, account);\r\n    _roleMembers[role].remove(account);\r\n  }\r\n}\r\n\r\n// contracts/external/openzeppelin/contracts/security/TimelockController.sol\r\n// Copied from https://github.com/OpenZeppelin/openzeppelin-contracts/blob/d9933585b6c134589d6819909a932de4c1a0db7f/contracts/governance/TimelockController.sol\r\n// NOTE: Removed inheritance of `ERC721Holder` and `ERC1155Holder`, as our TimelockController\r\n//       is intended to be used for administrative tasks only. Also changed from using AccessControl\r\n//       to using AccessControlEnumerable, as this aligns better with our standards.\r\n\r\n// OpenZeppelin Contracts (last updated v5.0.0) (governance/TimelockController.sol)\r\n\r\n/**\r\n * @dev Contract module which acts as a timelocked controller. When set as the\r\n * owner of an `Ownable` smart contract, it enforces a timelock on all\r\n * `onlyOwner` maintenance operations. This gives time for users of the\r\n * controlled contract to exit before a potentially dangerous maintenance\r\n * operation is applied.\r\n *\r\n * By default, this contract is self administered, meaning administration tasks\r\n * have to go through the timelock process. The proposer (resp executor) role\r\n * is in charge of proposing (resp executing) operations. A common use case is\r\n * to position this {TimelockController} as the owner of a smart contract, with\r\n * a multisig or a DAO as the sole proposer.\r\n */\r\ncontract TimelockController is AccessControlEnumerable {\r\n    bytes32 public constant PROPOSER_ROLE = keccak256(\"PROPOSER_ROLE\");\r\n    bytes32 public constant EXECUTOR_ROLE = keccak256(\"EXECUTOR_ROLE\");\r\n    bytes32 public constant CANCELLER_ROLE = keccak256(\"CANCELLER_ROLE\");\r\n    uint256 internal constant _DONE_TIMESTAMP = uint256(1);\r\n\r\n    mapping(bytes32 => uint256) private _timestamps;\r\n    uint256 private _minDelay;\r\n\r\n    enum OperationState {\r\n        Unset,\r\n        Waiting,\r\n        Ready,\r\n        Done\r\n    }\r\n\r\n    /**\r\n     * @dev Mismatch between the parameters length for an operation call.\r\n     */\r\n    error TimelockInvalidOperationLength(uint256 targets, uint256 payloads, uint256 values);\r\n\r\n    /**\r\n     * @dev The schedule operation doesn't meet the minimum delay.\r\n     */\r\n    error TimelockInsufficientDelay(uint256 delay, uint256 minDelay);\r\n\r\n    /**\r\n     * @dev The current state of an operation is not as required.\r\n     * The `expectedStates` is a bitmap with the bits enabled for each OperationState enum position\r\n     * counting from right to left.\r\n     *\r\n     * See {_encodeStateBitmap}.\r\n     */\r\n    error TimelockUnexpectedOperationState(bytes32 operationId, bytes32 expectedStates);\r\n\r\n    /**\r\n     * @dev The predecessor to an operation not yet done.\r\n     */\r\n    error TimelockUnexecutedPredecessor(bytes32 predecessorId);\r\n\r\n    /**\r\n     * @dev The caller account is not authorized.\r\n     */\r\n    error TimelockUnauthorizedCaller(address caller);\r\n\r\n    /**\r\n     * @dev Emitted when a call is scheduled as part of operation `id`.\r\n     */\r\n    event CallScheduled(\r\n        bytes32 indexed id,\r\n        uint256 indexed index,\r\n        address target,\r\n        uint256 value,\r\n        bytes data,\r\n        bytes32 predecessor,\r\n        uint256 delay\r\n    );\r\n\r\n    /**\r\n     * @dev Emitted when a call is performed as part of operation `id`.\r\n     */\r\n    event CallExecuted(bytes32 indexed id, uint256 indexed index, address target, uint256 value, bytes data);\r\n\r\n    /**\r\n     * @dev Emitted when new proposal is scheduled with non-zero salt.\r\n     */\r\n    event CallSalt(bytes32 indexed id, bytes32 salt);\r\n\r\n    /**\r\n     * @dev Emitted when operation `id` is cancelled.\r\n     */\r\n    event Cancelled(bytes32 indexed id);\r\n\r\n    /**\r\n     * @dev Emitted when the minimum delay for future operations is modified.\r\n     */\r\n    event MinDelayChange(uint256 oldDuration, uint256 newDuration);\r\n\r\n    /**\r\n     * @dev Initializes the contract with the following parameters:\r\n     *\r\n     * - `minDelay`: initial minimum delay in seconds for operations\r\n     * - `proposers`: accounts to be granted proposer and canceller roles\r\n     * - `executors`: accounts to be granted executor role\r\n     * - `admin`: optional account to be granted admin role; disable with zero address\r\n     *\r\n     * IMPORTANT: The optional admin can aid with initial configuration of roles after deployment\r\n     * without being subject to delay, but this role should be subsequently renounced in favor of\r\n     * administration through timelocked proposals. Previous versions of this contract would assign\r\n     * this admin to the deployer automatically and should be renounced as well.\r\n     */\r\n    constructor(uint256 minDelay, address[] memory proposers, address[] memory executors, address admin) {\r\n        // self administration\r\n        _grantRole(DEFAULT_ADMIN_ROLE, address(this));\r\n\r\n        // optional admin\r\n        if (admin != address(0)) {\r\n            _grantRole(DEFAULT_ADMIN_ROLE, admin);\r\n        }\r\n\r\n        // register proposers and cancellers\r\n        for (uint256 i = 0; i < proposers.length; ++i) {\r\n            _grantRole(PROPOSER_ROLE, proposers[i]);\r\n            _grantRole(CANCELLER_ROLE, proposers[i]);\r\n        }\r\n\r\n        // register executors\r\n        for (uint256 i = 0; i < executors.length; ++i) {\r\n            _grantRole(EXECUTOR_ROLE, executors[i]);\r\n        }\r\n\r\n        _minDelay = minDelay;\r\n        emit MinDelayChange(0, minDelay);\r\n    }\r\n\r\n    /**\r\n     * @dev Modifier to make a function callable only by a certain role. In\r\n     * addition to checking the sender's role, `address(0)` 's role is also\r\n     * considered. Granting a role to `address(0)` is equivalent to enabling\r\n     * this role for everyone.\r\n     */\r\n    modifier onlyRoleOrOpenRole(bytes32 role) {\r\n        if (!hasRole(role, address(0))) {\r\n            _checkRole(role, _msgSender());\r\n        }\r\n        _;\r\n    }\r\n\r\n    /**\r\n     * @dev Contract might receive/hold ETH as part of the maintenance process.\r\n     */\r\n    receive() external payable virtual {}\r\n\r\n    /**\r\n     * @dev See {IERC165-supportsInterface}.\r\n     */\r\n    function supportsInterface(\r\n        bytes4 interfaceId\r\n    ) public view virtual override(AccessControlEnumerable) returns (bool) {\r\n        return super.supportsInterface(interfaceId);\r\n    }\r\n\r\n    /**\r\n     * @dev Returns whether an id corresponds to a registered operation. This\r\n     * includes both Waiting, Ready, and Done operations.\r\n     */\r\n    function isOperation(bytes32 id) public view returns (bool) {\r\n        return getOperationState(id) != OperationState.Unset;\r\n    }\r\n\r\n    /**\r\n     * @dev Returns whether an operation is pending or not. Note that a \"pending\" operation may also be \"ready\".\r\n     */\r\n    function isOperationPending(bytes32 id) public view returns (bool) {\r\n        OperationState state = getOperationState(id);\r\n        return state == OperationState.Waiting || state == OperationState.Ready;\r\n    }\r\n\r\n    /**\r\n     * @dev Returns whether an operation is ready for execution. Note that a \"ready\" operation is also \"pending\".\r\n     */\r\n    function isOperationReady(bytes32 id) public view returns (bool) {\r\n        return getOperationState(id) == OperationState.Ready;\r\n    }\r\n\r\n    /**\r\n     * @dev Returns whether an operation is done or not.\r\n     */\r\n    function isOperationDone(bytes32 id) public view returns (bool) {\r\n        return getOperationState(id) == OperationState.Done;\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the timestamp at which an operation becomes ready (0 for\r\n     * unset operations, 1 for done operations).\r\n     */\r\n    function getTimestamp(bytes32 id) public view virtual returns (uint256) {\r\n        return _timestamps[id];\r\n    }\r\n\r\n    /**\r\n     * @dev Returns operation state.\r\n     */\r\n    function getOperationState(bytes32 id) public view virtual returns (OperationState) {\r\n        uint256 timestamp = getTimestamp(id);\r\n        if (timestamp == 0) {\r\n            return OperationState.Unset;\r\n        } else if (timestamp == _DONE_TIMESTAMP) {\r\n            return OperationState.Done;\r\n        } else if (timestamp > block.timestamp) {\r\n            return OperationState.Waiting;\r\n        } else {\r\n            return OperationState.Ready;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the minimum delay in seconds for an operation to become valid.\r\n     *\r\n     * This value can be changed by executing an operation that calls `updateDelay`.\r\n     */\r\n    function getMinDelay() public view virtual returns (uint256) {\r\n        return _minDelay;\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the identifier of an operation containing a single\r\n     * transaction.\r\n     */\r\n    function hashOperation(\r\n        address target,\r\n        uint256 value,\r\n        bytes calldata data,\r\n        bytes32 predecessor,\r\n        bytes32 salt\r\n    ) public pure virtual returns (bytes32) {\r\n        return keccak256(abi.encode(target, value, data, predecessor, salt));\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the identifier of an operation containing a batch of\r\n     * transactions.\r\n     */\r\n    function hashOperationBatch(\r\n        address[] calldata targets,\r\n        uint256[] calldata values,\r\n        bytes[] calldata payloads,\r\n        bytes32 predecessor,\r\n        bytes32 salt\r\n    ) public pure virtual returns (bytes32) {\r\n        return keccak256(abi.encode(targets, values, payloads, predecessor, salt));\r\n    }\r\n\r\n    /**\r\n     * @dev Schedule an operation containing a single transaction.\r\n     *\r\n     * Emits {CallSalt} if salt is nonzero, and {CallScheduled}.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - the caller must have the 'proposer' role.\r\n     */\r\n    function schedule(\r\n        address target,\r\n        uint256 value,\r\n        bytes calldata data,\r\n        bytes32 predecessor,\r\n        bytes32 salt,\r\n        uint256 delay\r\n    ) public virtual onlyRole(PROPOSER_ROLE) {\r\n        bytes32 id = hashOperation(target, value, data, predecessor, salt);\r\n        _schedule(id, delay);\r\n        emit CallScheduled(id, 0, target, value, data, predecessor, delay);\r\n        if (salt != bytes32(0)) {\r\n            emit CallSalt(id, salt);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @dev Schedule an operation containing a batch of transactions.\r\n     *\r\n     * Emits {CallSalt} if salt is nonzero, and one {CallScheduled} event per transaction in the batch.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - the caller must have the 'proposer' role.\r\n     */\r\n    function scheduleBatch(\r\n        address[] calldata targets,\r\n        uint256[] calldata values,\r\n        bytes[] calldata payloads,\r\n        bytes32 predecessor,\r\n        bytes32 salt,\r\n        uint256 delay\r\n    ) public virtual onlyRole(PROPOSER_ROLE) {\r\n        if (targets.length != values.length || targets.length != payloads.length) {\r\n            revert TimelockInvalidOperationLength(targets.length, payloads.length, values.length);\r\n        }\r\n\r\n        bytes32 id = hashOperationBatch(targets, values, payloads, predecessor, salt);\r\n        _schedule(id, delay);\r\n        for (uint256 i = 0; i < targets.length; ++i) {\r\n            emit CallScheduled(id, i, targets[i], values[i], payloads[i], predecessor, delay);\r\n        }\r\n        if (salt != bytes32(0)) {\r\n            emit CallSalt(id, salt);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @dev Schedule an operation that is to become valid after a given delay.\r\n     */\r\n    function _schedule(bytes32 id, uint256 delay) private {\r\n        if (isOperation(id)) {\r\n            revert TimelockUnexpectedOperationState(id, _encodeStateBitmap(OperationState.Unset));\r\n        }\r\n        uint256 minDelay = getMinDelay();\r\n        if (delay < minDelay) {\r\n            revert TimelockInsufficientDelay(delay, minDelay);\r\n        }\r\n        _timestamps[id] = block.timestamp + delay;\r\n    }\r\n\r\n    /**\r\n     * @dev Cancel an operation.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - the caller must have the 'canceller' role.\r\n     */\r\n    function cancel(bytes32 id) public virtual onlyRole(CANCELLER_ROLE) {\r\n        if (!isOperationPending(id)) {\r\n            revert TimelockUnexpectedOperationState(\r\n                id,\r\n                _encodeStateBitmap(OperationState.Waiting) | _encodeStateBitmap(OperationState.Ready)\r\n            );\r\n        }\r\n        delete _timestamps[id];\r\n\r\n        emit Cancelled(id);\r\n    }\r\n\r\n    /**\r\n     * @dev Execute an (ready) operation containing a single transaction.\r\n     *\r\n     * Emits a {CallExecuted} event.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - the caller must have the 'executor' role.\r\n     */\r\n    // This function can reenter, but it doesn't pose a risk because _afterCall checks that the proposal is pending,\r\n    // thus any modifications to the operation during reentrancy should be caught.\r\n    // slither-disable-next-line reentrancy-eth\r\n    function execute(\r\n        address target,\r\n        uint256 value,\r\n        bytes calldata payload,\r\n        bytes32 predecessor,\r\n        bytes32 salt\r\n    ) public payable virtual onlyRoleOrOpenRole(EXECUTOR_ROLE) {\r\n        bytes32 id = hashOperation(target, value, payload, predecessor, salt);\r\n\r\n        _beforeCall(id, predecessor);\r\n        _execute(target, value, payload);\r\n        emit CallExecuted(id, 0, target, value, payload);\r\n        _afterCall(id);\r\n    }\r\n\r\n    /**\r\n     * @dev Execute an (ready) operation containing a batch of transactions.\r\n     *\r\n     * Emits one {CallExecuted} event per transaction in the batch.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - the caller must have the 'executor' role.\r\n     */\r\n    // This function can reenter, but it doesn't pose a risk because _afterCall checks that the proposal is pending,\r\n    // thus any modifications to the operation during reentrancy should be caught.\r\n    // slither-disable-next-line reentrancy-eth\r\n    function executeBatch(\r\n        address[] calldata targets,\r\n        uint256[] calldata values,\r\n        bytes[] calldata payloads,\r\n        bytes32 predecessor,\r\n        bytes32 salt\r\n    ) public payable virtual onlyRoleOrOpenRole(EXECUTOR_ROLE) {\r\n        if (targets.length != values.length || targets.length != payloads.length) {\r\n            revert TimelockInvalidOperationLength(targets.length, payloads.length, values.length);\r\n        }\r\n\r\n        bytes32 id = hashOperationBatch(targets, values, payloads, predecessor, salt);\r\n\r\n        _beforeCall(id, predecessor);\r\n        for (uint256 i = 0; i < targets.length; ++i) {\r\n            address target = targets[i];\r\n            uint256 value = values[i];\r\n            bytes calldata payload = payloads[i];\r\n            _execute(target, value, payload);\r\n            emit CallExecuted(id, i, target, value, payload);\r\n        }\r\n        _afterCall(id);\r\n    }\r\n\r\n    /**\r\n     * @dev Execute an operation's call.\r\n     */\r\n    function _execute(address target, uint256 value, bytes calldata data) internal virtual {\r\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\r\n        Address.verifyCallResult(success, returndata, \"Error: call failed\");\r\n    }\r\n\r\n    /**\r\n     * @dev Checks before execution of an operation's calls.\r\n     */\r\n    function _beforeCall(bytes32 id, bytes32 predecessor) private view {\r\n        if (!isOperationReady(id)) {\r\n            revert TimelockUnexpectedOperationState(id, _encodeStateBitmap(OperationState.Ready));\r\n        }\r\n        if (predecessor != bytes32(0) && !isOperationDone(predecessor)) {\r\n            revert TimelockUnexecutedPredecessor(predecessor);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @dev Checks after execution of an operation's calls.\r\n     */\r\n    function _afterCall(bytes32 id) private {\r\n        if (!isOperationReady(id)) {\r\n            revert TimelockUnexpectedOperationState(id, _encodeStateBitmap(OperationState.Ready));\r\n        }\r\n        _timestamps[id] = _DONE_TIMESTAMP;\r\n    }\r\n\r\n    /**\r\n     * @dev Changes the minimum timelock duration for future operations.\r\n     *\r\n     * Emits a {MinDelayChange} event.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - the caller must be the timelock itself. This can only be achieved by scheduling and later executing\r\n     * an operation where the timelock is the target and the data is the ABI-encoded call to this function.\r\n     */\r\n    function updateDelay(uint256 newDelay) external virtual {\r\n        address sender = _msgSender();\r\n        if (sender != address(this)) {\r\n            revert TimelockUnauthorizedCaller(sender);\r\n        }\r\n        emit MinDelayChange(_minDelay, newDelay);\r\n        _minDelay = newDelay;\r\n    }\r\n\r\n    /**\r\n     * @dev Encodes a `OperationState` into a `bytes32` representation where each bit enabled corresponds to\r\n     * the underlying position in the `OperationState` enum. For example:\r\n     *\r\n     * 0x000...1000\r\n     *   ^^^^^^----- ...\r\n     *         ^---- Done\r\n     *          ^--- Ready\r\n     *           ^-- Waiting\r\n     *            ^- Unset\r\n     */\r\n    function _encodeStateBitmap(OperationState operationState) internal pure returns (bytes32) {\r\n        return bytes32(1 << uint8(operationState));\r\n    }\r\n}"}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"40002:15656:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48237:497;;;;;;;;;;-1:-1:-1;48237:497:0;;;;;:::i;:::-;;:::i;:::-;;44685:194;;;;;;;;;;-1:-1:-1;44685:194:0;;;;;:::i;:::-;;:::i;:::-;;;1763:14:1;;1756:22;1738:41;;1726:2;1711:18;44685:194:0;;;;;;;;40137:66;;;;;;;;;;;;40177:26;40137:66;;;;;1936:25:1;;;1924:2;1909:18;40137:66:0;1790:177:1;51399:472:0;;;;;;:::i;:::-;;:::i;45667:136::-;;;;;;;;;;-1:-1:-1;45667:136:0;;;;;:::i;:::-;;:::i;32873:153::-;;;;;;;;;;-1:-1:-1;32873:153:0;;;;;:::i;:::-;32972:7;32998:12;;;;;;;;;;:22;;;;32873:153;45887:134;;;;;;;;;;-1:-1:-1;45887:134:0;;;;;:::i;:::-;;:::i;33266:164::-;;;;;;;;;;-1:-1:-1;33266:164:0;;;;;:::i;:::-;;:::i;45043:131::-;;;;;;;;;;-1:-1:-1;45043:131:0;;;;;:::i;:::-;;:::i;34298:229::-;;;;;;;;;;-1:-1:-1;34298:229:0;;;;;:::i;:::-;;:::i;45314:212::-;;;;;;;;;;-1:-1:-1;45314:212:0;;;;;:::i;:::-;;:::i;54831:293::-;;;;;;;;;;-1:-1:-1;54831:293:0;;;;;:::i;:::-;;:::i;46352:471::-;;;;;;;;;;-1:-1:-1;46352:471:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;47242:287::-;;;;;;;;;;-1:-1:-1;47242:287:0;;;;;:::i;:::-;;:::i;49034:827::-;;;;;;;;;;-1:-1:-1;49034:827:0;;;;;:::i;:::-;;:::i;40064:66::-;;;;;;;;;;;;40104:26;40064:66;;37662:175;;;;;;;;;;-1:-1:-1;37662:175:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;5879:32:1;;;5861:51;;5849:2;5834:18;37662:175:0;5715:203:1;31856:169:0;;;;;;;;;;-1:-1:-1;31856:169:0;;;;;:::i;:::-;;:::i;30959:49::-;;;;;;;;;;-1:-1:-1;30959:49:0;31004:4;30959:49;;40210:68;;;;;;;;;;;;40251:27;40210:68;;47651:328;;;;;;;;;;-1:-1:-1;47651:328:0;;;;;:::i;:::-;;:::i;50526:385::-;;;;;;;;;;-1:-1:-1;50526:385:0;;;;;:::i;:::-;;:::i;38001:164::-;;;;;;;;;;-1:-1:-1;38001:164:0;;;;;:::i;:::-;;:::i;46175:113::-;;;;;;;;;;-1:-1:-1;46175:113:0;;;;;:::i;:::-;46238:7;46265:15;;;:11;:15;;;;;;;46175:113;33655:166;;;;;;;;;;-1:-1:-1;33655:166:0;;;;;:::i;:::-;;:::i;52393:918::-;;;;;;:::i;:::-;;:::i;47027:96::-;;;;;;;;;;-1:-1:-1;47106:9:0;;47027:96;;48237:497;40104:26;31424:30;40104:26;8945:10;31424;:30::i;:::-;48468:10:::1;48481:53;48495:6;48503:5;48510:4;;48516:11;48529:4;48481:13;:53::i;:::-;48468:66;;48545:20;48555:2;48559:5;48545:9;:20::i;:::-;48599:1;48595:2;48581:61;48602:6;48610:5;48617:4;;48623:11;48636:5;48581:61;;;;;;;;;;;:::i;:::-;;;;;;;;48657:18:::0;;48653:74:::1;;48706:2;48697:18;48710:4;48697:18;;;;1936:25:1::0;;1924:2;1909:18;;1790:177;48697:18:0::1;;;;;;;;48653:74;48457:277;48237:497:::0;;;;;;;;:::o;44685:194::-;44811:4;44835:36;44859:11;44835:23;:36::i;:::-;44828:43;44685:194;-1:-1:-1;;44685:194:0:o;51399:472::-;40177:26;44366:25;44374:4;44388:1;44366:7;:25::i;:::-;44361:89;;44408:30;44419:4;8945:10;31424;:30::i;44408:::-;51626:10:::1;51639:56;51653:6;51661:5;51668:7;;51677:11;51690:4;51639:13;:56::i;:::-;51626:69;;51708:28;51720:2;51724:11;51708;:28::i;:::-;51747:32;51756:6;51764:5;51771:7;;51747:8;:32::i;:::-;51812:1;51808:2;51795:43;51815:6;51823:5;51830:7;;51795:43;;;;;;;;;:::i;:::-;;;;;;;;51849:14;51860:2;51849:10;:14::i;:::-;51615:256;51399:472:::0;;;;;;;:::o;45667:136::-;45726:4;45775:20;45750:45;:21;45768:2;45750:17;:21::i;:::-;:45;;;;;;;;:::i;:::-;;;45667:136;-1:-1:-1;;45667:136:0:o;45887:134::-;45945:4;45994:19;45969:44;;33266:164;32972:7;32998:12;;;;;;;;;;:22;;;31424:30;31435:4;8945:10;31424;:30::i;:::-;33399:25:::1;33410:4;33416:7;33399:10;:25::i;:::-;33266:164:::0;;;:::o;45043:131::-;45097:4;;45121:21;45139:2;45121:17;:21::i;:::-;:45;;;;;;;;:::i;:::-;;;;45043:131;-1:-1:-1;;45043:131:0:o;34298:229::-;-1:-1:-1;;;;;34398:23:0;;8945:10;34398:23;34382:104;;;;-1:-1:-1;;;34382:104:0;;8799:2:1;34382:104:0;;;8781:21:1;8838:2;8818:18;;;8811:30;8877:34;8857:18;;;8850:62;-1:-1:-1;;;8928:18:1;;;8921:45;8983:19;;34382:104:0;;;;;;;;;34495:26;34507:4;34513:7;34495:11;:26::i;:::-;34298:229;;:::o;45314:212::-;45375:4;45392:20;45415:21;45433:2;45415:17;:21::i;:::-;45392:44;-1:-1:-1;45463:22:0;45454:5;:31;;;;;;;;:::i;:::-;;:64;;;-1:-1:-1;45498:20:0;45489:5;:29;;;;;;;;:::i;:::-;;45454:64;45447:71;45314:212;-1:-1:-1;;;45314:212:0:o;54831:293::-;8945:10;54960:4;54942:23;;54938:97;;54989:34;;-1:-1:-1;;;54989:34:0;;-1:-1:-1;;;;;5879:32:1;;54989:34:0;;;5861:51:1;5834:18;;54989:34:0;5715:203:1;54938:97:0;55065:9;;55050:35;;;9187:25:1;;;9243:2;9228:18;;9221:34;;;55050:35:0;;9160:18:1;55050:35:0;;;;;;;-1:-1:-1;55096:9:0;:20;54831:293::o;46352:471::-;46420:14;46265:15;;;:11;:15;;;;;;46498:9;46511:1;46498:14;46494:322;;-1:-1:-1;46536:20:0;;46352:471;-1:-1:-1;;46352:471:0:o;46494:322::-;40337:1;46578:9;:28;46574:242;;-1:-1:-1;46630:19:0;;46352:471;-1:-1:-1;;46352:471:0:o;46574:242::-;46683:15;46671:9;:27;46667:149;;;-1:-1:-1;46722:22:0;;46352:471;-1:-1:-1;;46352:471:0:o;46667:149::-;-1:-1:-1;46784:20:0;;46352:471;-1:-1:-1;;46352:471:0:o;47242:287::-;47433:7;47481:6;47489:5;47496:4;;47502:11;47515:4;47470:50;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;47460:61;;;;;;47453:68;;47242:287;;;;;;;;:::o;49034:827::-;40104:26;31424:30;40104:26;8945:10;31424;:30::i;:::-;49304:31;;::::1;;::::0;:68:::1;;-1:-1:-1::0;49339:33:0;;::::1;;49304:68;49300:186;;;49396:78;::::0;-1:-1:-1;;;;;;49396:78:0;;::::1;::::0;::::1;10030:25:1::0;;;10071:18;;;10064:34;;;10114:18;;;10107:34;;;10003:18;;49396:78:0::1;9828:319:1::0;49300:186:0::1;49498:10;49511:64;49530:7;;49539:6;;49547:8;;49557:11;49570:4;49511:18;:64::i;:::-;49498:77;;49586:20;49596:2;49600:5;49586:9;:20::i;:::-;49622:9;49617:153;49637:18:::0;;::::1;49617:153;;;49700:1;49696:2;49682:76;49703:7;;49711:1;49703:10;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;49715:6;;49722:1;49715:9;;;;;;;:::i;:::-;;;;;;;49726:8;;49735:1;49726:11;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;49739;49752:5;49682:76;;;;;;;;;;;:::i;:::-;;;;;;;;49657:3;::::0;::::1;:::i;:::-;;;49617:153;;;-1:-1:-1::0;49784:18:0;;49780:74:::1;;49833:2;49824:18;49837:4;49824:18;;;;1936:25:1::0;;1924:2;1909:18;;1790:177;49824:18:0::1;;;;;;;;49780:74;49289:572;49034:827:::0;;;;;;;;;;:::o;37662:175::-;37777:7;37803:18;;;:12;:18;;;;;:28;;37825:5;37803:21;:28::i;31856:169::-;31967:4;31990:12;;;;;;;;;;;-1:-1:-1;;;;;31990:29:0;;;;;;;;;;;;;;;31856:169::o;47651:328::-;47877:7;47925;;47934:6;;47942:8;;47952:11;47965:4;47914:56;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;47904:67;;;;;;47897:74;;47651:328;;;;;;;;;;:::o;50526:385::-;40251:27;31424:30;40251:27;8945:10;31424;:30::i;:::-;50610:22:::1;50629:2;50610:18;:22::i;:::-;50605:235;;50707:2;50773:40;50792:20;50773:18;:40::i;:::-;50728:42;50747:22;50728:18;:42::i;:::-;50656:172;::::0;-1:-1:-1;;;50656:172:0;;::::1;::::0;::::1;9187:25:1::0;;;;50728:85:0::1;9228:18:1::0;;;9221:34;9160:18;;50656:172:0::1;9013:248:1::0;50605:235:0::1;50857:15;::::0;;;:11:::1;:15;::::0;;;;;50850:22;;;50890:13;50869:2;;50890:13:::1;::::0;::::1;50526:385:::0;;:::o;38001:164::-;38106:7;38132:18;;;:12;:18;;;;;:27;;:25;:27::i;33655:166::-;32972:7;32998:12;;;;;;;;;;:22;;;31424:30;31435:4;8945:10;31424;:30::i;:::-;33789:26:::1;33801:4;33807:7;33789:11;:26::i;52393:918::-:0;40177:26;44366:25;44374:4;44388:1;44366:7;:25::i;:::-;44361:89;;44408:30;44419:4;8945:10;31424;:30::i;44408:::-;52656:31;;::::1;;::::0;:68:::1;;-1:-1:-1::0;52691:33:0;;::::1;;52656:68;52652:186;;;52748:78;::::0;-1:-1:-1;;;;;;52748:78:0;;::::1;::::0;::::1;10030:25:1::0;;;10071:18;;;10064:34;;;10114:18;;;10107:34;;;10003:18;;52748:78:0::1;9828:319:1::0;52652:186:0::1;52850:10;52863:64;52882:7;;52891:6;;52899:8;;52909:11;52922:4;52863:18;:64::i;:::-;52850:77;;52940:28;52952:2;52956:11;52940;:28::i;:::-;52984:9;52979:300;52999:18:::0;;::::1;52979:300;;;53039:14;53056:7;;53064:1;53056:10;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;53039:27;;53081:13;53097:6;;53104:1;53097:9;;;;;;;:::i;:::-;;;;;;;53081:25;;53121:22;;53146:8;;53155:1;53146:11;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;53121:36;;;;53172:32;53181:6;53189:5;53196:7;;53172:8;:32::i;:::-;53241:1;53237:2;53224:43;53244:6;53252:5;53259:7;;53224:43;;;;;;;;;:::i;:::-;;;;;;;;53024:255;;;;53019:3;;;;:::i;:::-;;;52979:300;;;;53289:14;53300:2;53289:10;:14::i;:::-;52641:670;52393:918:::0;;;;;;;;;:::o;32299:399::-;32384:22;32392:4;32398:7;32384;:22::i;:::-;32379:314;;32524:41;32552:7;-1:-1:-1;;;;;32524:41:0;32562:2;32524:19;:41::i;:::-;32614:38;32642:4;32649:2;32614:19;:38::i;:::-;32453:212;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;32453:212:0;;;;;;;;;;-1:-1:-1;;;32417:268:0;;;;;;;:::i;49967:408::-;50036:15;50048:2;50036:11;:15::i;:::-;50032:133;;;50108:2;50112:40;50131:20;50112:18;:40::i;:::-;50075:78;;-1:-1:-1;;;50075:78:0;;;;;9187:25:1;;;;9228:18;;;9221:34;9160:18;;50075:78:0;9013:248:1;50032:133:0;50175:16;50194:13;47106:9;;;47027:96;50194:13;50175:32;;50230:8;50222:5;:16;50218:98;;;50262:42;;-1:-1:-1;;;50262:42:0;;;;;9187:25:1;;;9228:18;;;9221:34;;;9160:18;;50262:42:0;9013:248:1;50218:98:0;50344:23;50362:5;50344:15;:23;:::i;:::-;50326:15;;;;:11;:15;;;;;;:41;;;;-1:-1:-1;;49967:408:0:o;36839:250::-;36949:4;-1:-1:-1;;;;;;36979:57:0;;-1:-1:-1;;;36979:57:0;;:104;;;37047:36;37071:11;37047:23;:36::i;53724:374::-;53807:20;53824:2;53807:16;:20::i;:::-;53802:139;;53884:2;53888:40;53907:20;53888:18;:40::i;53802:139::-;53955:25;;;;;:58;;;53985:28;54001:11;53985:15;:28::i;:::-;53984:29;53955:58;53951:140;;;54037:42;;-1:-1:-1;;;54037:42:0;;;;;1936:25:1;;;1909:18;;54037:42:0;1790:177:1;53379:257:0;53478:12;53492:23;53519:6;-1:-1:-1;;;;;53519:11:0;53538:5;53545:4;;53519:31;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53477:73;;;;53561:67;53586:7;53595:10;53561:67;;;;;;;;;;;;;-1:-1:-1;;;53561:67:0;;;:24;:67::i;:::-;;53466:170;;53379:257;;;;:::o;54185:241::-;54241:20;54258:2;54241:16;:20::i;:::-;54236:139;;54318:2;54322:40;54341:20;54322:18;:40::i;54236:139::-;54385:15;;;;:11;:15;;;;;40337:1;54385:33;;54185:241::o;38250:159::-;38334:31;38351:4;38357:7;38334:16;:31::i;:::-;38372:18;;;;:12;:18;;;;;:31;;38395:7;38372:22;:31::i;38495:182::-;38598:32;38616:4;38622:7;38598:17;:32::i;:::-;38637:18;;;;:12;:18;;;;;:34;;38663:7;38637:25;:34::i;17754:170::-;17843:7;17893:22;17897:3;17909:5;17893:3;:22::i;55503:152::-;55585:7;55631:14;55625:21;;;;;;;;:::i;:::-;55620:1;:26;;;;;;;55503:152;-1:-1:-1;;55503:152:0:o;17311:111::-;17374:7;17397:19;17405:3;12953:18;;12874:103;26348:427;26438:13;26463:19;26495:10;26499:6;26495:1;:10;:::i;:::-;:14;;26508:1;26495:14;:::i;:::-;26485:25;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;26485:25:0;;26463:47;;-1:-1:-1;;;26517:6:0;26524:1;26517:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;26517:15:0;;;;;;;;;-1:-1:-1;;;26539:6:0;26546:1;26539:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;26539:15:0;;;;;;;;-1:-1:-1;26566:9:0;26578:10;26582:6;26578:1;:10;:::i;:::-;:14;;26591:1;26578:14;:::i;:::-;26566:26;;26561:119;26598:1;26594;:5;26561:119;;;-1:-1:-1;;;26640:5:0;26648:3;26640:11;26627:25;;;;;;;:::i;:::-;;;;26615:6;26622:1;26615:9;;;;;;;;:::i;:::-;;;;:37;-1:-1:-1;;;;;26615:37:0;;;;;;;;-1:-1:-1;26671:1:0;26661:11;;;;;26601:3;;;:::i;:::-;;;26561:119;;;-1:-1:-1;26694:10:0;;26686:55;;;;-1:-1:-1;;;26686:55:0;;16499:2:1;26686:55:0;;;16481:21:1;;;16518:18;;;16511:30;16577:34;16557:18;;;16550:62;16629:18;;26686:55:0;16297:356:1;31532:240:0;31642:4;-1:-1:-1;;;;;;31672:47:0;;-1:-1:-1;;;31672:47:0;;:94;;-1:-1:-1;;;;;;;;;;27739:40:0;;;31730:36;27606:179;7600:602;7736:12;7761:7;7757:440;;;-1:-1:-1;7786:10:0;7779:17;;7757:440;7884:17;;:21;7880:310;;8056:10;8050:17;8107:15;8094:10;8090:2;8086:19;8079:44;7880:310;8167:12;8160:20;;-1:-1:-1;;;8160:20:0;;;;;;;;:::i;35728:216::-;35808:22;35816:4;35822:7;35808;:22::i;:::-;35803:136;;35841:6;:12;;;;;;;;;;;-1:-1:-1;;;;;35841:29:0;;;;;;;;;:36;;-1:-1:-1;;35841:36:0;35873:4;35841:36;;;35918:12;8945:10;;8869:92;35918:12;-1:-1:-1;;;;;35891:40:0;35909:7;-1:-1:-1;;;;;35891:40:0;35903:4;35891:40;;;;;;;;;;35728:216;;:::o;16503:146::-;16573:4;16593:50;16598:3;-1:-1:-1;;;;;16618:23:0;;16593:4;:50::i;36064:217::-;36144:22;36152:4;36158:7;36144;:22::i;:::-;36140:136;;;36209:5;36177:12;;;;;;;;;;;-1:-1:-1;;;;;36177:29:0;;;;;;;;;;:37;;-1:-1:-1;;36177:37:0;;;36228:40;8945:10;;36177:12;;36228:40;;36209:5;36228:40;36064:217;;:::o;16811:165::-;16894:4;16917:53;16925:3;-1:-1:-1;;;;;16945:23:0;;16917:7;:53::i;13309:114::-;13376:7;13399:3;:11;;13411:5;13399:18;;;;;;;;:::i;:::-;;;;;;;;;13392:25;;13309:114;;;;:::o;10777:364::-;10840:4;12766:19;;;:12;;;:19;;;;;;10853:283;;-1:-1:-1;10890:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;11055:18;;11033:19;;;:12;;;:19;;;;;;:40;;;;11082:11;;10853:283;-1:-1:-1;11123:5:0;11116:12;;11303:1274;11369:4;11500:19;;;:12;;;:19;;;;;;11532:15;;11528:1044;;11877:21;11901:14;11914:1;11901:10;:14;:::i;:::-;11944:18;;11877:38;;-1:-1:-1;11924:17:0;;11944:22;;11965:1;;11944:22;:::i;:::-;11924:42;;11994:13;11981:9;:26;11977:359;;12020:17;12040:3;:11;;12052:9;12040:22;;;;;;;;:::i;:::-;;;;;;;;;12020:42;;12178:9;12149:3;:11;;12161:13;12149:26;;;;;;;;:::i;:::-;;;;;;;;;;;;:38;;;;12247:23;;;:12;;;:23;;;;;:36;;;11977:359;12405:17;;:3;;:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;12488:3;:12;;:19;12501:5;12488:19;;;;;;;;;;;12481:26;;;12525:4;12518:11;;;;;;;11528:1044;12559:5;12552:12;;;;;14:173:1;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:347::-;243:8;253:6;307:3;300:4;292:6;288:17;284:27;274:55;;325:1;322;315:12;274:55;-1:-1:-1;348:20:1;;391:18;380:30;;377:50;;;423:1;420;413:12;377:50;460:4;452:6;448:17;436:29;;512:3;505:4;496:6;488;484:19;480:30;477:39;474:59;;;529:1;526;519:12;474:59;192:347;;;;;:::o;544:758::-;659:6;667;675;683;691;699;707;760:3;748:9;739:7;735:23;731:33;728:53;;;777:1;774;767:12;728:53;800:29;819:9;800:29;:::i;:::-;790:39;;876:2;865:9;861:18;848:32;838:42;;931:2;920:9;916:18;903:32;958:18;950:6;947:30;944:50;;;990:1;987;980:12;944:50;1029:58;1079:7;1070:6;1059:9;1055:22;1029:58;:::i;:::-;544:758;;;;-1:-1:-1;1106:8:1;1188:2;1173:18;;1160:32;;1239:3;1224:19;;1211:33;;-1:-1:-1;1291:3:1;1276:19;;;1263:33;;-1:-1:-1;544:758:1;-1:-1:-1;;;;544:758:1:o;1307:286::-;1365:6;1418:2;1406:9;1397:7;1393:23;1389:32;1386:52;;;1434:1;1431;1424:12;1386:52;1460:23;;-1:-1:-1;;;;;;1512:32:1;;1502:43;;1492:71;;1559:1;1556;1549:12;1972:689;2078:6;2086;2094;2102;2110;2118;2171:3;2159:9;2150:7;2146:23;2142:33;2139:53;;;2188:1;2185;2178:12;2139:53;2211:29;2230:9;2211:29;:::i;:::-;2201:39;;2287:2;2276:9;2272:18;2259:32;2249:42;;2342:2;2331:9;2327:18;2314:32;2369:18;2361:6;2358:30;2355:50;;;2401:1;2398;2391:12;2355:50;2440:58;2490:7;2481:6;2470:9;2466:22;2440:58;:::i;:::-;1972:689;;;;-1:-1:-1;2517:8:1;2599:2;2584:18;;2571:32;;2650:3;2635:19;;;2622:33;;-1:-1:-1;1972:689:1;-1:-1:-1;;;;1972:689:1:o;2666:180::-;2725:6;2778:2;2766:9;2757:7;2753:23;2749:32;2746:52;;;2794:1;2791;2784:12;2746:52;-1:-1:-1;2817:23:1;;2666:180;-1:-1:-1;2666:180:1:o;2851:254::-;2919:6;2927;2980:2;2968:9;2959:7;2955:23;2951:32;2948:52;;;2996:1;2993;2986:12;2948:52;3032:9;3019:23;3009:33;;3061:38;3095:2;3084:9;3080:18;3061:38;:::i;:::-;3051:48;;2851:254;;;;;:::o;3295:127::-;3356:10;3351:3;3347:20;3344:1;3337:31;3387:4;3384:1;3377:15;3411:4;3408:1;3401:15;3427:347;3578:2;3563:18;;3611:1;3600:13;;3590:144;;3656:10;3651:3;3647:20;3644:1;3637:31;3691:4;3688:1;3681:15;3719:4;3716:1;3709:15;3590:144;3743:25;;;3427:347;:::o;3779:367::-;3842:8;3852:6;3906:3;3899:4;3891:6;3887:17;3883:27;3873:55;;3924:1;3921;3914:12;3873:55;-1:-1:-1;3947:20:1;;3990:18;3979:30;;3976:50;;;4022:1;4019;4012:12;3976:50;4059:4;4051:6;4047:17;4035:29;;4119:3;4112:4;4102:6;4099:1;4095:14;4087:6;4083:27;4079:38;4076:47;4073:67;;;4136:1;4133;4126:12;4151:1306;4347:6;4355;4363;4371;4379;4387;4395;4403;4411;4464:3;4452:9;4443:7;4439:23;4435:33;4432:53;;;4481:1;4478;4471:12;4432:53;4521:9;4508:23;4550:18;4591:2;4583:6;4580:14;4577:34;;;4607:1;4604;4597:12;4577:34;4646:70;4708:7;4699:6;4688:9;4684:22;4646:70;:::i;:::-;4735:8;;-1:-1:-1;4620:96:1;-1:-1:-1;4823:2:1;4808:18;;4795:32;;-1:-1:-1;4839:16:1;;;4836:36;;;4868:1;4865;4858:12;4836:36;4907:72;4971:7;4960:8;4949:9;4945:24;4907:72;:::i;:::-;4998:8;;-1:-1:-1;4881:98:1;-1:-1:-1;5086:2:1;5071:18;;5058:32;;-1:-1:-1;5102:16:1;;;5099:36;;;5131:1;5128;5121:12;5099:36;;5170:72;5234:7;5223:8;5212:9;5208:24;5170:72;:::i;:::-;4151:1306;;;;-1:-1:-1;4151:1306:1;;;;5261:8;;5343:2;5328:18;;5315:32;;5394:3;5379:19;;5366:33;;-1:-1:-1;5446:3:1;5431:19;5418:33;;-1:-1:-1;4151:1306:1;-1:-1:-1;;;;4151:1306:1:o;5462:248::-;5530:6;5538;5591:2;5579:9;5570:7;5566:23;5562:32;5559:52;;;5607:1;5604;5597:12;5559:52;-1:-1:-1;;5630:23:1;;;5700:2;5685:18;;;5672:32;;-1:-1:-1;5462:248:1:o;5923:1237::-;6110:6;6118;6126;6134;6142;6150;6158;6166;6219:3;6207:9;6198:7;6194:23;6190:33;6187:53;;;6236:1;6233;6226:12;6187:53;6276:9;6263:23;6305:18;6346:2;6338:6;6335:14;6332:34;;;6362:1;6359;6352:12;6332:34;6401:70;6463:7;6454:6;6443:9;6439:22;6401:70;:::i;:::-;6490:8;;-1:-1:-1;6375:96:1;-1:-1:-1;6578:2:1;6563:18;;6550:32;;-1:-1:-1;6594:16:1;;;6591:36;;;6623:1;6620;6613:12;6591:36;6662:72;6726:7;6715:8;6704:9;6700:24;6662:72;:::i;:::-;6753:8;;-1:-1:-1;6636:98:1;-1:-1:-1;6841:2:1;6826:18;;6813:32;;-1:-1:-1;6857:16:1;;;6854:36;;;6886:1;6883;6876:12;6854:36;;6925:72;6989:7;6978:8;6967:9;6963:24;6925:72;:::i;:::-;5923:1237;;;;-1:-1:-1;5923:1237:1;;;;7016:8;;7098:2;7083:18;;7070:32;;7149:3;7134:19;7121:33;;-1:-1:-1;5923:1237:1;-1:-1:-1;;;;5923:1237:1:o;7347:266::-;7435:6;7430:3;7423:19;7487:6;7480:5;7473:4;7468:3;7464:14;7451:43;-1:-1:-1;7539:1:1;7514:16;;;7532:4;7510:27;;;7503:38;;;;7595:2;7574:15;;;-1:-1:-1;;7570:29:1;7561:39;;;7557:50;;7347:266::o;7618:557::-;7916:1;7912;7907:3;7903:11;7899:19;7891:6;7887:32;7876:9;7869:51;7956:6;7951:2;7940:9;7936:18;7929:34;7999:3;7994:2;7983:9;7979:18;7972:31;7850:4;8020:62;8077:3;8066:9;8062:19;8054:6;8046;8020:62;:::i;:::-;8113:2;8098:18;;8091:34;;;;-1:-1:-1;8156:3:1;8141:19;8134:35;8012:70;7618:557;-1:-1:-1;;;;7618:557:1:o;8180:412::-;8422:1;8418;8413:3;8409:11;8405:19;8397:6;8393:32;8382:9;8375:51;8462:6;8457:2;8446:9;8442:18;8435:34;8505:2;8500;8489:9;8485:18;8478:30;8356:4;8525:61;8582:2;8571:9;8567:18;8559:6;8551;8525:61;:::i;:::-;8517:69;8180:412;-1:-1:-1;;;;;;8180:412:1:o;10152:127::-;10213:10;10208:3;10204:20;10201:1;10194:31;10244:4;10241:1;10234:15;10268:4;10265:1;10258:15;10284:186;10343:6;10396:2;10384:9;10375:7;10371:23;10367:32;10364:52;;;10412:1;10409;10402:12;10364:52;10435:29;10454:9;10435:29;:::i;10475:521::-;10552:4;10558:6;10618:11;10605:25;10712:2;10708:7;10697:8;10681:14;10677:29;10673:43;10653:18;10649:68;10639:96;;10731:1;10728;10721:12;10639:96;10758:33;;10810:20;;;-1:-1:-1;10853:18:1;10842:30;;10839:50;;;10885:1;10882;10875:12;10839:50;10918:4;10906:17;;-1:-1:-1;10949:14:1;10945:27;;;10935:38;;10932:58;;;10986:1;10983;10976:12;11001:127;11062:10;11057:3;11053:20;11050:1;11043:31;11093:4;11090:1;11083:15;11117:4;11114:1;11107:15;11133:135;11172:3;11193:17;;;11190:43;;11213:18;;:::i;:::-;-1:-1:-1;11260:1:1;11249:13;;11133:135::o;11273:1043::-;11350:3;11381;11405:6;11400:3;11393:19;11431:4;11460:2;11455:3;11451:12;11444:19;;11516:2;11506:6;11503:1;11499:14;11492:5;11488:26;11484:35;11542:5;11565:1;11575:715;11589:6;11586:1;11583:13;11575:715;;;11654:16;;;-1:-1:-1;;11650:30:1;11638:43;;11720:20;;11795:14;11791:26;;;-1:-1:-1;;11787:40:1;11763:65;;11753:93;;11842:1;11839;11832:12;11753:93;11874:30;;11982:16;;;;11933:21;12027:18;12014:32;;12011:52;;;12059:1;12056;12049:12;12011:52;12112:8;12096:14;12092:29;12083:7;12079:43;12076:63;;;12135:1;12132;12125:12;12076:63;12160:50;12205:4;12195:8;12186:7;12160:50;:::i;:::-;12268:12;;;;12152:58;-1:-1:-1;;;12233:15:1;;;;11611:1;11604:9;11575:715;;;-1:-1:-1;12306:4:1;;11273:1043;-1:-1:-1;;;;;;;11273:1043:1:o;12321:1393::-;12773:3;12786:22;;;12758:19;;12843:22;;;12725:4;12923:6;12896:3;12881:19;;12725:4;12957:235;12971:6;12968:1;12965:13;12957:235;;;-1:-1:-1;;;;;13036:26:1;13055:6;13036:26;:::i;:::-;13032:52;13020:65;;13108:4;13167:15;;;;13132:12;;;;12993:1;12986:9;12957:235;;;-1:-1:-1;13230:19:1;;;13223:4;13208:20;;13201:49;13259:19;;;-1:-1:-1;;;;;13290:31:1;;13287:51;;;13334:1;13331;13324:12;13287:51;13368:6;13365:1;13361:14;13347:28;;13421:6;13413;13406:4;13401:3;13397:14;13384:44;13447:16;13503:18;;;13523:4;13499:29;;;13494:2;13479:18;;13472:57;13546:75;;13607:13;;13599:6;13591;13546:75;:::i;:::-;13652:2;13637:18;;13630:34;;;;-1:-1:-1;;13695:3:1;13680:19;13673:35;13538:83;12321:1393;-1:-1:-1;;;;;;12321:1393:1:o;13972:250::-;14057:1;14067:113;14081:6;14078:1;14075:13;14067:113;;;14157:11;;;14151:18;14138:11;;;14131:39;14103:2;14096:10;14067:113;;;-1:-1:-1;;14214:1:1;14196:16;;14189:27;13972:250::o;14227:812::-;14638:25;14633:3;14626:38;14608:3;14693:6;14687:13;14709:75;14777:6;14772:2;14767:3;14763:12;14756:4;14748:6;14744:17;14709:75;:::i;:::-;-1:-1:-1;;;14843:2:1;14803:16;;;14835:11;;;14828:40;14893:13;;14915:76;14893:13;14977:2;14969:11;;14962:4;14950:17;;14915:76;:::i;:::-;15011:17;15030:2;15007:26;;14227:812;-1:-1:-1;;;;14227:812:1:o;15044:396::-;15193:2;15182:9;15175:21;15156:4;15225:6;15219:13;15268:6;15263:2;15252:9;15248:18;15241:34;15284:79;15356:6;15351:2;15340:9;15336:18;15331:2;15323:6;15319:15;15284:79;:::i;:::-;15424:2;15403:15;-1:-1:-1;;15399:29:1;15384:45;;;;15431:2;15380:54;;15044:396;-1:-1:-1;;15044:396:1:o;15445:125::-;15510:9;;;15531:10;;;15528:36;;;15544:18;;:::i;15575:271::-;15758:6;15750;15745:3;15732:33;15714:3;15784:16;;15809:13;;;15784:16;15575:271;-1:-1:-1;15575:271:1:o;15851:168::-;15924:9;;;15955;;15972:15;;;15966:22;;15952:37;15942:71;;15993:18;;:::i;16024:127::-;16085:10;16080:3;16076:20;16073:1;16066:31;16116:4;16113:1;16106:15;16140:4;16137:1;16130:15;16156:136;16195:3;16223:5;16213:39;;16232:18;;:::i;:::-;-1:-1:-1;;;16268:18:1;;16156:136::o;16658:128::-;16725:9;;;16746:11;;;16743:37;;;16760:18;;:::i;16791:127::-;16852:10;16847:3;16843:20;16840:1;16833:31;16883:4;16880:1;16873:15;16907:4;16904:1;16897:15","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa26469706673582212204c6b9898cbf76f4950dc5b642674505bf60f2851c53821fc24f7d3609faa0d0c64736f6c63430008140033","offset":7351}},"immutableReferences":{},"transformations":[{"id":"1","type":"replace","offset":7351,"reason":"cborAuxdata"}],"transformationValues":{"cborAuxdata":{"1":"0xa2646970667358221220e963fcc74604390174fd3b7fe7ab8832b5e974d6a1016339d12f66d187e4c50564736f6c63430008140033"}}},"matchId":"53370659","creationMatch":null,"runtimeMatch":"match","verifiedAt":"2026-09-27T10:16:57Z","match":"match","chainId":"56","address":"0x8860bbfc7A83E4788a981f4e9f30878331413b26"}