Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import {EnumerableSet} from '@openzeppelin/contracts/utils/structs/EnumerableSet.sol';
import {AccessControl} from '@openzeppelin/contracts/access/AccessControl.sol';
import {ERC20} from './ERC20.sol';
import {IGhoToken} from './interfaces/IGhoToken.sol';

/**
 * @title GHO Token
 * @author Aave
 */
contract GhoToken is ERC20, AccessControl, IGhoToken {
  using EnumerableSet for EnumerableSet.AddressSet;

  mapping(address => Facilitator) internal _facilitators;
  EnumerableSet.AddressSet internal _facilitatorsList;

  /// @inheritdoc IGhoToken
  bytes32 public constant FACILITATOR_MANAGER_ROLE = keccak256('FACILITATOR_MANAGER_ROLE');

  /// @inheritdoc IGhoToken
  bytes32 public constant BUCKET_MANAGER_ROLE = keccak256('BUCKET_MANAGER_ROLE');

  /**
   * @dev Constructor
   * @param admin This is the initial holder of the default admin role
   */
  constructor(address admin) ERC20('Gho Token', 'GHO', 18) {
    _setupRole(DEFAULT_ADMIN_ROLE, admin);
  }

  /// @inheritdoc IGhoToken
  function mint(address account, uint256 amount) external {
    require(amount > 0, 'INVALID_MINT_AMOUNT');
    Facilitator storage f = _facilitators[msg.sender];

    uint256 currentBucketLevel = f.bucketLevel;
    uint256 newBucketLevel = currentBucketLevel + amount;
    require(f.bucketCapacity >= newBucketLevel, 'FACILITATOR_BUCKET_CAPACITY_EXCEEDED');
    f.bucketLevel = uint128(newBucketLevel);

    _mint(account, amount);

    emit FacilitatorBucketLevelUpdated(msg.sender, currentBucketLevel, newBucketLevel);
  }

  /// @inheritdoc IGhoToken
  function burn(uint256 amount) external {
    require(amount > 0, 'INVALID_BURN_AMOUNT');

    Facilitator storage f = _facilitators[msg.sender];
    uint256 currentBucketLevel = f.bucketLevel;
    uint256 newBucketLevel = currentBucketLevel - amount;
    f.bucketLevel = uint128(newBucketLevel);

    _burn(msg.sender, amount);

    emit FacilitatorBucketLevelUpdated(msg.sender, currentBucketLevel, newBucketLevel);
  }

  /// @inheritdoc IGhoToken
  function addFacilitator(
    address facilitatorAddress,
    string calldata facilitatorLabel,
    uint128 bucketCapacity
  ) external onlyRole(FACILITATOR_MANAGER_ROLE) {
    Facilitator storage facilitator = _facilitators[facilitatorAddress];
    require(bytes(facilitator.label).length == 0, 'FACILITATOR_ALREADY_EXISTS');
    require(bytes(facilitatorLabel).length > 0, 'INVALID_LABEL');

    facilitator.label = facilitatorLabel;
    facilitator.bucketCapacity = bucketCapacity;

    _facilitatorsList.add(facilitatorAddress);

    emit FacilitatorAdded(
      facilitatorAddress,
      keccak256(abi.encodePacked(facilitatorLabel)),
      bucketCapacity
    );
  }

  /// @inheritdoc IGhoToken
  function removeFacilitator(
    address facilitatorAddress
  ) external onlyRole(FACILITATOR_MANAGER_ROLE) {
    require(
      bytes(_facilitators[facilitatorAddress].label).length > 0,
      'FACILITATOR_DOES_NOT_EXIST'
    );
    require(
      _facilitators[facilitatorAddress].bucketLevel == 0,
      'FACILITATOR_BUCKET_LEVEL_NOT_ZERO'
    );

    delete _facilitators[facilitatorAddress];
    _facilitatorsList.remove(facilitatorAddress);

    emit FacilitatorRemoved(facilitatorAddress);
  }

  /// @inheritdoc IGhoToken
  function setFacilitatorBucketCapacity(
    address facilitator,
    uint128 newCapacity
  ) external onlyRole(BUCKET_MANAGER_ROLE) {
    require(bytes(_facilitators[facilitator].label).length > 0, 'FACILITATOR_DOES_NOT_EXIST');

    uint256 oldCapacity = _facilitators[facilitator].bucketCapacity;
    _facilitators[facilitator].bucketCapacity = newCapacity;

    emit FacilitatorBucketCapacityUpdated(facilitator, oldCapacity, newCapacity);
  }

  /// @inheritdoc IGhoToken
  function getFacilitator(address facilitator) external view returns (Facilitator memory) {
    return _facilitators[facilitator];
  }

  /// @inheritdoc IGhoToken
  function getFacilitatorBucket(address facilitator) external view returns (uint256, uint256) {
    return (_facilitators[facilitator].bucketCapacity, _facilitators[facilitator].bucketLevel);
  }

  /// @inheritdoc IGhoToken
  function getFacilitatorsList() external view returns (address[] memory) {
    return _facilitatorsList.values();
  }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.

pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableSet.
 * ====
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastValue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastValue;
                // Update the index for the moved value
                set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        bytes32[] memory store = _values(set._inner);
        bytes32[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (access/AccessControl.sol)

pragma solidity ^0.8.0;

import "./IAccessControl.sol";
import "../utils/Context.sol";
import "../utils/Strings.sol";
import "../utils/introspection/ERC165.sol";

/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms. This is a lightweight version that doesn't allow enumerating role
 * members except through off-chain means by accessing the contract event logs. Some
 * applications may benefit from on-chain enumerability, for those cases see
 * {AccessControlEnumerable}.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it.
 */
abstract contract AccessControl is Context, IAccessControl, ERC165 {
    struct RoleData {
        mapping(address => bool) members;
        bytes32 adminRole;
    }

    mapping(bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Modifier that checks that an account has a specific role. Reverts
     * with a standardized message including the required role.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     *
     * _Available since v4.1._
     */
    modifier onlyRole(bytes32 role) {
        _checkRole(role);
        _;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
    }

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
        return _roles[role].members[account];
    }

    /**
     * @dev Revert with a standard message if `_msgSender()` is missing `role`.
     * Overriding this function changes the behavior of the {onlyRole} modifier.
     *
     * Format of the revert message is described in {_checkRole}.
     *
     * _Available since v4.6._
     */
    function _checkRole(bytes32 role) internal view virtual {
        _checkRole(role, _msgSender());
    }

    /**
     * @dev Revert with a standard message if `account` is missing `role`.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     */
    function _checkRole(bytes32 role, address account) internal view virtual {
        if (!hasRole(role, account)) {
            revert(
                string(
                    abi.encodePacked(
                        "AccessControl: account ",
                        Strings.toHexString(account),
                        " is missing role ",
                        Strings.toHexString(uint256(role), 32)
                    )
                )
            );
        }
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleGranted} event.
     */
    function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleRevoked} event.
     */
    function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been revoked `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     *
     * May emit a {RoleRevoked} event.
     */
    function renounceRole(bytes32 role, address account) public virtual override {
        require(account == _msgSender(), "AccessControl: can only renounce roles for self");

        _revokeRole(role, account);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event. Note that unlike {grantRole}, this function doesn't perform any
     * checks on the calling account.
     *
     * May emit a {RoleGranted} event.
     *
     * [WARNING]
     * ====
     * This function should only be called from the constructor when setting
     * up the initial roles for the system.
     *
     * Using this function in any other way is effectively circumventing the admin
     * system imposed by {AccessControl}.
     * ====
     *
     * NOTE: This function is deprecated in favor of {_grantRole}.
     */
    function _setupRole(bytes32 role, address account) internal virtual {
        _grantRole(role, account);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        bytes32 previousAdminRole = getRoleAdmin(role);
        _roles[role].adminRole = adminRole;
        emit RoleAdminChanged(role, previousAdminRole, adminRole);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleGranted} event.
     */
    function _grantRole(bytes32 role, address account) internal virtual {
        if (!hasRole(role, account)) {
            _roles[role].members[account] = true;
            emit RoleGranted(role, account, _msgSender());
        }
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleRevoked} event.
     */
    function _revokeRole(bytes32 role, address account) internal virtual {
        if (hasRole(role, account)) {
            _roles[role].members[account] = false;
            emit RoleRevoked(role, account, _msgSender());
        }
    }
}

// SPDX-License-Identifier: MIT-only
pragma solidity ^0.8.0;

import {IERC20} from '@openzeppelin/contracts/token/ERC20/IERC20.sol';

/**
 * @title ERC20
 * @notice Gas Efficient ERC20 + EIP-2612 implementation
 * @dev Modified version of Solmate ERC20 (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC20.sol),
 * implementing the basic IERC20
 */
abstract contract ERC20 is IERC20 {
  /*///////////////////////////////////////////////////////////////
                             METADATA STORAGE
    //////////////////////////////////////////////////////////////*/

  string public name;

  string public symbol;

  uint8 public immutable decimals;

  /*///////////////////////////////////////////////////////////////
                              ERC20 STORAGE
    //////////////////////////////////////////////////////////////*/

  uint256 public totalSupply;

  mapping(address => uint256) public balanceOf;

  mapping(address => mapping(address => uint256)) public allowance;

  /*///////////////////////////////////////////////////////////////
                             EIP-2612 STORAGE
    //////////////////////////////////////////////////////////////*/

  bytes32 public constant PERMIT_TYPEHASH =
    keccak256('Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)');

  uint256 internal immutable INITIAL_CHAIN_ID;

  bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;

  mapping(address => uint256) public nonces;

  /*///////////////////////////////////////////////////////////////
                               CONSTRUCTOR
    //////////////////////////////////////////////////////////////*/

  constructor(string memory _name, string memory _symbol, uint8 _decimals) {
    name = _name;
    symbol = _symbol;
    decimals = _decimals;

    INITIAL_CHAIN_ID = block.chainid;
    INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();
  }

  /*///////////////////////////////////////////////////////////////
                              ERC20 LOGIC
    //////////////////////////////////////////////////////////////*/

  function approve(address spender, uint256 amount) public virtual returns (bool) {
    allowance[msg.sender][spender] = amount;

    emit Approval(msg.sender, spender, amount);

    return true;
  }

  function transfer(address to, uint256 amount) public virtual returns (bool) {
    balanceOf[msg.sender] -= amount;

    // Cannot overflow because the sum of all user
    // balances can't exceed the max uint256 value.
    unchecked {
      balanceOf[to] += amount;
    }

    emit Transfer(msg.sender, to, amount);

    return true;
  }

  function transferFrom(address from, address to, uint256 amount) public virtual returns (bool) {
    uint256 allowed = allowance[from][msg.sender]; // Saves gas for limited approvals.

    if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amount;

    balanceOf[from] -= amount;

    // Cannot overflow because the sum of all user
    // balances can't exceed the max uint256 value.
    unchecked {
      balanceOf[to] += amount;
    }

    emit Transfer(from, to, amount);

    return true;
  }

  /*///////////////////////////////////////////////////////////////
                              EIP-2612 LOGIC
    //////////////////////////////////////////////////////////////*/

  function permit(
    address owner,
    address spender,
    uint256 value,
    uint256 deadline,
    uint8 v,
    bytes32 r,
    bytes32 s
  ) public virtual {
    require(deadline >= block.timestamp, 'PERMIT_DEADLINE_EXPIRED');

    // Unchecked because the only math done is incrementing
    // the owner's nonce which cannot realistically overflow.
    unchecked {
      bytes32 digest = keccak256(
        abi.encodePacked(
          '\x19\x01',
          DOMAIN_SEPARATOR(),
          keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonces[owner]++, deadline))
        )
      );

      address recoveredAddress = ecrecover(digest, v, r, s);

      require(recoveredAddress != address(0) && recoveredAddress == owner, 'INVALID_SIGNER');

      allowance[recoveredAddress][spender] = value;
    }

    emit Approval(owner, spender, value);
  }

  function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
    return block.chainid == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator();
  }

  function computeDomainSeparator() internal view virtual returns (bytes32) {
    return
      keccak256(
        abi.encode(
          keccak256(
            'EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)'
          ),
          keccak256(bytes(name)),
          keccak256('1'),
          block.chainid,
          address(this)
        )
      );
  }

  /*///////////////////////////////////////////////////////////////
                       INTERNAL MINT/BURN LOGIC
    //////////////////////////////////////////////////////////////*/

  function _mint(address to, uint256 amount) internal virtual {
    totalSupply += amount;

    // Cannot overflow because the sum of all user
    // balances can't exceed the max uint256 value.
    unchecked {
      balanceOf[to] += amount;
    }

    emit Transfer(address(0), to, amount);
  }

  function _burn(address from, uint256 amount) internal virtual {
    balanceOf[from] -= amount;

    // Cannot underflow because a user's balance
    // will never be larger than the total supply.
    unchecked {
      totalSupply -= amount;
    }

    emit Transfer(from, address(0), amount);
  }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import {IERC20} from '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import {IAccessControl} from '@openzeppelin/contracts/access/IAccessControl.sol';

/**
 * @title IGhoToken
 * @author Aave
 */
interface IGhoToken is IERC20, IAccessControl {
  struct Facilitator {
    uint128 bucketCapacity;
    uint128 bucketLevel;
    string label;
  }

  /**
   * @dev Emitted when a new facilitator is added
   * @param facilitatorAddress The address of the new facilitator
   * @param label A hashed human readable identifier for the facilitator
   * @param bucketCapacity The initial capacity of the facilitator's bucket
   */
  event FacilitatorAdded(
    address indexed facilitatorAddress,
    bytes32 indexed label,
    uint256 bucketCapacity
  );

  /**
   * @dev Emitted when a facilitator is removed
   * @param facilitatorAddress The address of the removed facilitator
   */
  event FacilitatorRemoved(address indexed facilitatorAddress);

  /**
   * @dev Emitted when the bucket capacity of a facilitator is updated
   * @param facilitatorAddress The address of the facilitator whose bucket capacity is being changed
   * @param oldCapacity The old capacity of the bucket
   * @param newCapacity The new capacity of the bucket
   */
  event FacilitatorBucketCapacityUpdated(
    address indexed facilitatorAddress,
    uint256 oldCapacity,
    uint256 newCapacity
  );

  /**
   * @dev Emitted when the bucket level changed
   * @param facilitatorAddress The address of the facilitator whose bucket level is being changed
   * @param oldLevel The old level of the bucket
   * @param newLevel The new level of the bucket
   */
  event FacilitatorBucketLevelUpdated(
    address indexed facilitatorAddress,
    uint256 oldLevel,
    uint256 newLevel
  );

  /**
   * @notice Returns the identifier of the Facilitator Manager Role
   * @return The bytes32 id hash of the FacilitatorManager role
   */
  function FACILITATOR_MANAGER_ROLE() external pure returns (bytes32);

  /**
   * @notice Returns the identifier of the Bucket Manager Role
   * @return The bytes32 id hash of the BucketManager role
   */
  function BUCKET_MANAGER_ROLE() external pure returns (bytes32);

  /**
   * @notice Mints the requested amount of tokens to the account address.
   * @dev Only facilitators with enough bucket capacity available can mint.
   * @dev The bucket level is increased upon minting.
   * @param account The address receiving the GHO tokens
   * @param amount The amount to mint
   */
  function mint(address account, uint256 amount) external;

  /**
   * @notice Burns the requested amount of tokens from the account address.
   * @dev Only active facilitators (bucket level > 0) can burn.
   * @dev The bucket level is decreased upon burning.
   * @param amount The amount to burn
   */
  function burn(uint256 amount) external;

  /**
   * @notice Add the facilitator passed with the parameters to the facilitators list.
   * @dev Only accounts with `FACILITATOR_MANAGER_ROLE` role can call this function
   * @param facilitatorAddress The address of the facilitator to add
   * @param facilitatorLabel A human readable identifier for the facilitator
   * @param bucketCapacity The upward limit of GHO can be minted by the facilitator
   */
  function addFacilitator(
    address facilitatorAddress,
    string calldata facilitatorLabel,
    uint128 bucketCapacity
  ) external;

  /**
   * @notice Remove the facilitator from the facilitators list.
   * @dev Only accounts with `FACILITATOR_MANAGER_ROLE` role can call this function
   * @param facilitatorAddress The address of the facilitator to remove
   */
  function removeFacilitator(address facilitatorAddress) external;

  /**
   * @notice Set the bucket capacity of the facilitator.
   * @dev Only accounts with `BUCKET_MANAGER_ROLE` role can call this function
   * @param facilitator The address of the facilitator
   * @param newCapacity The new capacity of the bucket
   */
  function setFacilitatorBucketCapacity(address facilitator, uint128 newCapacity) external;

  /**
   * @notice Returns the facilitator data
   * @param facilitator The address of the facilitator
   * @return The facilitator configuration
   */
  function getFacilitator(address facilitator) external view returns (Facilitator memory);

  /**
   * @notice Returns the bucket configuration of the facilitator
   * @param facilitator The address of the facilitator
   * @return The capacity of the facilitator's bucket
   * @return The level of the facilitator's bucket
   */
  function getFacilitatorBucket(address facilitator) external view returns (uint256, uint256);

  /**
   * @notice Returns the list of the addresses of the active facilitator
   * @return The list of the facilitators addresses
   */
  function getFacilitatorsList() external view returns (address[] memory);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)

pragma solidity ^0.8.0;

/**
 * @dev External interface of AccessControl declared to support ERC165 detection.
 */
interface IAccessControl {
    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     *
     * _Available since v3.1._
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {AccessControl-_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) external view returns (bool);

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {AccessControl-_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) external view returns (bytes32);

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

import "./math/Math.sol";

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;

import "./IERC165.sol";

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator,
        Rounding rounding
    ) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10**64) {
                value /= 10**64;
                result += 64;
            }
            if (value >= 10**32) {
                value /= 10**32;
                result += 32;
            }
            if (value >= 10**16) {
                value /= 10**16;
                result += 16;
            }
            if (value >= 10**8) {
                value /= 10**8;
                result += 8;
            }
            if (value >= 10**4) {
                value /= 10**4;
                result += 4;
            }
            if (value >= 10**2) {
                value /= 10**2;
                result += 2;
            }
            if (value >= 10**1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

{
  "remappings": [
    "@aave/core-v3/=lib/aave-v3-core/",
    "@openzeppelin/=lib/openzeppelin-contracts/",
    "aave-address-book/=lib/aave-address-book/src/",
    "aave-helpers/=lib/aave-helpers/",
    "aave-stk-v1-5/=lib/aave-stk-v1-5/src/",
    "aave-v3-core/=lib/aave-v3-core/",
    "ds-test/=lib/forge-std/lib/ds-test/src/",
    "forge-std/=lib/forge-std/src/",
    "gho-core/=lib/gho-core/src/contracts/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/",
    "solidity-utils/=lib/solidity-utils/src/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs"
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "evmVersion": "london",
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"admin","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"facilitatorAddress","type":"address"},{"indexed":true,"internalType":"bytes32","name":"label","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"bucketCapacity","type":"uint256"}],"name":"FacilitatorAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"facilitatorAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"oldCapacity","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newCapacity","type":"uint256"}],"name":"FacilitatorBucketCapacityUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"facilitatorAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"oldLevel","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newLevel","type":"uint256"}],"name":"FacilitatorBucketLevelUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"facilitatorAddress","type":"address"}],"name":"FacilitatorRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"BUCKET_MANAGER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"FACILITATOR_MANAGER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERMIT_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"facilitatorAddress","type":"address"},{"internalType":"string","name":"facilitatorLabel","type":"string"},{"internalType":"uint128","name":"bucketCapacity","type":"uint128"}],"name":"addFacilitator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"facilitator","type":"address"}],"name":"getFacilitator","outputs":[{"components":[{"internalType":"uint128","name":"bucketCapacity","type":"uint128"},{"internalType":"uint128","name":"bucketLevel","type":"uint128"},{"internalType":"string","name":"label","type":"string"}],"internalType":"struct IGhoToken.Facilitator","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"facilitator","type":"address"}],"name":"getFacilitatorBucket","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getFacilitatorsList","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"facilitatorAddress","type":"address"}],"name":"removeFacilitator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"facilitator","type":"address"},{"internalType":"uint128","name":"newCapacity","type":"uint128"}],"name":"setFacilitatorBucketCapacity","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000ee56e2b3d491590b5b31738cc34d5232f378a8d5

-----Decoded View---------------
Arg [0] : admin (address): 0xEE56e2B3D491590B5b31738cC34d5232F378a8D5

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000ee56e2b3d491590b5b31738cc34d5232f378a8d5

358:3922:1:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2606:202:3;;;;;;:::i;:::-;;:::i;:::-;;;470:14:12;;463:22;445:41;;433:2;418:18;2606:202:3;;;;;;;;586:18:0;;;:::i;:::-;;;;;;;:::i;2086:197::-;;;;;;:::i;:::-;;:::i;852:26::-;;;;;;;;;1831:25:12;;;1819:2;1804:18;852:26:0;1685:177:12;4162:116:1;;;:::i;:::-;;;;;;;:::i;2628:518:0:-;;;;;;:::i;:::-;;:::i;4378:129:3:-;;;;;;:::i;:::-;4452:7;4478:12;;;:6;:12;;;;;:22;;;;4378:129;4803:145;;;;;;:::i;:::-;;:::i;:::-;;1185:141:0;;1231:95;1185:141;;634:31;;;;;;;;3661:4:12;3649:17;;;3631:36;;3619:2;3604:18;634:31:0;3489:184:12;4198:171:0;;;:::i;5912:214:3:-;;;;;;:::i;:::-;;:::i;1056:523:1:-;;;;;;:::i;:::-;;:::i;1611:420::-;;;;;;:::i;:::-;;:::i;610:88::-;;661:37;610:88;;731:78;;777:32;731:78;;883:44:0;;;;;;:::i;:::-;;;;;;;;;;;;;;1435:41;;;;;;:::i;:::-;;;;;;;;;;;;;;2063:670:1;;;;;;:::i;:::-;;:::i;2895:145:3:-;;;;;;:::i;:::-;;:::i;609:20:0:-;;;:::i;2765:499:1:-;;;;;;:::i;:::-;;:::i;2027:49:3:-;;2072:4;2027:49;;2287:337:0;;;;;;:::i;:::-;;:::i;3937:193:1:-;;;;;;:::i;:::-;-1:-1:-1;;;;;4043:26:1;4011:7;4043:26;;;:13;:26;;;;;:41;-1:-1:-1;;;;;4043:41:1;;;;-1:-1:-1;;;4086:38:1;;;;;3937:193;;;;;5166:25:12;;;5222:2;5207:18;;5200:34;;;;5139:18;3937:193:1;4992:248:12;3296:445:1;;;;;;:::i;:::-;;:::i;3773:132::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;3333:861:0:-;;;;;;:::i;:::-;;:::i;5228:147:3:-;;;;;;:::i;:::-;;:::i;932:64:0:-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;2606:202:3;2691:4;-1:-1:-1;;;;;;2714:47:3;;-1:-1:-1;;;2714:47:3;;:87;;-1:-1:-1;;;;;;;;;;937:40:8;;;2765:36:3;2707:94;2606:202;-1:-1:-1;;2606:202:3:o;586:18:0:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;2086:197::-;2182:10;2160:4;2172:21;;;:9;:21;;;;;;;;-1:-1:-1;;;;;2172:30:0;;;;;;;;;;:39;;;2223:37;2160:4;;2172:30;;2223:37;;;;2205:6;1831:25:12;;1819:2;1804:18;;1685:177;2223:37:0;;;;;;;;-1:-1:-1;2274:4:0;2086:197;;;;:::o;4162:116:1:-;4216:16;4247:26;:17;:24;:26::i;:::-;4240:33;;4162:116;:::o;2628:518:0:-;-1:-1:-1;;;;;2746:15:0;;2716:4;2746:15;;;:9;:15;;;;;;;;2762:10;2746:27;;;;;;;;-1:-1:-1;;2820:28:0;;2816:80;;2880:16;2890:6;2880:7;:16;:::i;:::-;-1:-1:-1;;;;;2850:15:0;;;;;;:9;:15;;;;;;;;2866:10;2850:27;;;;;;;:46;2816:80;-1:-1:-1;;;;;2903:15:0;;;;;;:9;:15;;;;;:25;;2922:6;;2903:15;:25;;2922:6;;2903:25;:::i;:::-;;;;-1:-1:-1;;;;;;;3056:13:0;;;;;;;:9;:13;;;;;;;:23;;;;;;3097:26;3056:13;;3097:26;;;-1:-1:-1;;;;;;;;;;;3097:26:0;;;3073:6;1831:25:12;;1819:2;1804:18;;1685:177;3097:26:0;;;;;;;;-1:-1:-1;3137:4:0;;2628:518;-1:-1:-1;;;;2628:518:0:o;4803:145:3:-;4452:7;4478:12;;;:6;:12;;;;;:22;;;2505:16;2516:4;2505:10;:16::i;:::-;4916:25:::1;4927:4;4933:7;4916:10;:25::i;:::-;4803:145:::0;;;:::o;4198:171:0:-;4255:7;4294:16;4277:13;:33;:87;;4340:24;:22;:24::i;4277:87::-;-1:-1:-1;4313:24:0;;4198:171::o;5912:214:3:-;-1:-1:-1;;;;;6007:23:3;;719:10:6;6007:23:3;5999:83;;;;-1:-1:-1;;;5999:83:3;;7864:2:12;5999:83:3;;;7846:21:12;7903:2;7883:18;;;7876:30;7942:34;7922:18;;;7915:62;-1:-1:-1;;;7993:18:12;;;7986:45;8048:19;;5999:83:3;;;;;;;;;6093:26;6105:4;6111:7;6093:11;:26::i;:::-;5912:214;;:::o;1056:523:1:-;1135:1;1126:6;:10;1118:42;;;;-1:-1:-1;;;1118:42:1;;8280:2:12;1118:42:1;;;8262:21:12;8319:2;8299:18;;;8292:30;-1:-1:-1;;;8338:18:12;;;8331:49;8397:18;;1118:42:1;8078:343:12;1118:42:1;1204:10;1166:21;1190:25;;;:13;:25;;;;;1251:13;;1190:25;;-1:-1:-1;;;1251:13:1;;;-1:-1:-1;;;;;1251:13:1;;1295:27;1316:6;1251:13;1295:27;:::i;:::-;1336:16;;1270:52;;-1:-1:-1;;;;;;1336:16:1;:34;-1:-1:-1;1336:34:1;1328:83;;;;-1:-1:-1;;;1328:83:1;;8761:2:12;1328:83:1;;;8743:21:12;8800:2;8780:18;;;8773:30;8839:34;8819:18;;;8812:62;-1:-1:-1;;;8890:18:12;;;8883:34;8934:19;;1328:83:1;8559:400:12;1328:83:1;1417:39;;-1:-1:-1;;;;;1417:39:1;;;-1:-1:-1;;;1417:39:1;;;;;;1463:22;1469:7;1478:6;1463:5;:22::i;:::-;1497:77;;;5166:25:12;;;5222:2;5207:18;;5200:34;;;1527:10:1;;1497:77;;5139:18:12;1497:77:1;;;;;;;1112:467;;;1056:523;;:::o;1611:420::-;1673:1;1664:6;:10;1656:42;;;;-1:-1:-1;;;1656:42:1;;9166:2:12;1656:42:1;;;9148:21:12;9205:2;9185:18;;;9178:30;-1:-1:-1;;;9224:18:12;;;9217:49;9283:18;;1656:42:1;8964:343:12;1656:42:1;1743:10;1705:21;1729:25;;;:13;:25;;;;;1789:13;;1729:25;;-1:-1:-1;;;1789:13:1;;;-1:-1:-1;;;;;1789:13:1;;1833:27;1854:6;1789:13;1833:27;:::i;:::-;1866:39;;-1:-1:-1;;;;;1866:39:1;;;-1:-1:-1;;;1866:39:1;;;;;;1808:52;-1:-1:-1;1912:25:1;1918:10;1930:6;1912:5;:25::i;:::-;1949:77;;;5166:25:12;;;5222:2;5207:18;;5200:34;;;1979:10:1;;1949:77;;5139:18:12;1949:77:1;;;;;;;;1650:381;;;1611:420;:::o;2063:670::-;661:37;2505:16:3;2516:4;2505:10;:16::i;:::-;-1:-1:-1;;;;;2273:33:1;::::1;2239:31;2273:33:::0;;;:13:::1;:33;::::0;;;;2326:17:::1;::::0;::::1;2320:31:::0;;::::1;::::0;::::1;:::i;:::-;:36:::0;;-1:-1:-1;2312:75:1::1;;;::::0;-1:-1:-1;;;2312:75:1;;9514:2:12;2312:75:1::1;::::0;::::1;9496:21:12::0;9553:2;9533:18;;;9526:30;9592:28;9572:18;;;9565:56;9638:18;;2312:75:1::1;9312:350:12::0;2312:75:1::1;2401:34:::0;2393:60:::1;;;::::0;-1:-1:-1;;;2393:60:1;;9869:2:12;2393:60:1::1;::::0;::::1;9851:21:12::0;9908:2;9888:18;;;9881:30;-1:-1:-1;;;9927:18:12;;;9920:43;9980:18;;2393:60:1::1;9667:337:12::0;2393:60:1::1;2460:36;:17;::::0;::::1;2480:16:::0;;2460:36:::1;:::i;:::-;-1:-1:-1::0;2502:43:1;;-1:-1:-1;;;;;;2502:43:1::1;-1:-1:-1::0;;;;;2502:43:1;::::1;;::::0;;2552:41:::1;:17;2574:18:::0;2552:21:::1;:41::i;:::-;;2682:16;;2665:34;;;;;;;;;:::i;:::-;;::::0;;-1:-1:-1;;2665:34:1;;::::1;::::0;;;;;;;2655:45;;2665:34:::1;2655:45:::0;;::::1;::::0;-1:-1:-1;;;;;10451:47:12;;10433:66;;2655:45:1;-1:-1:-1;;;;;2605:123:1;::::1;::::0;::::1;::::0;10406:18:12;2605:123:1::1;;;;;;;2233:500;2063:670:::0;;;;;:::o;2895:145:3:-;2981:4;3004:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;3004:29:3;;;;;;;;;;;;;;;2895:145::o;609:20:0:-;;;;;;;:::i;2765:499:1:-;661:37;2505:16:3;2516:4;2505:10;:16::i;:::-;-1:-1:-1;;;;;2899:33:1;::::1;2949:1;2899:33:::0;;;:13:::1;:33;::::0;;;;:39:::1;;2893:53:::0;;::::1;::::0;::::1;:::i;:::-;;;:57;2878:114;;;::::0;-1:-1:-1;;;2878:114:1;;10712:2:12;2878:114:1::1;::::0;::::1;10694:21:12::0;10751:2;10731:18;;;10724:30;10790:28;10770:18;;;10763:56;10836:18;;2878:114:1::1;10510:350:12::0;2878:114:1::1;-1:-1:-1::0;;;;;3013:33:1;::::1;;::::0;;;:13:::1;:33;::::0;;;;:45;-1:-1:-1;;;3013:45:1;::::1;-1:-1:-1::0;;;;;3013:45:1::1;:50:::0;2998:114:::1;;;::::0;-1:-1:-1;;;2998:114:1;;11067:2:12;2998:114:1::1;::::0;::::1;11049:21:12::0;11106:2;11086:18;;;11079:30;11145:34;11125:18;;;11118:62;-1:-1:-1;;;11196:18:12;;;11189:31;11237:19;;2998:114:1::1;10865:397:12::0;2998:114:1::1;-1:-1:-1::0;;;;;3126:33:1;::::1;;::::0;;;:13:::1;:33;::::0;;;;3119:40;;;3126:33;3119:40:::1;::::0;;::::1;3126:33:::0;3119:40:::1;:::i;:::-;-1:-1:-1::0;3165:44:1::1;::::0;-1:-1:-1;3165:17:1::1;3190:18:::0;3165:24:::1;:44::i;:::-;-1:-1:-1::0;3221:38:1::1;::::0;-1:-1:-1;;;;;3221:38:1;::::1;::::0;::::1;::::0;;;::::1;2765:499:::0;;:::o;2287:337:0:-;2379:10;2357:4;2369:21;;;:9;:21;;;;;:31;;2394:6;;2369:21;2357:4;;2369:31;;2394:6;;2369:31;:::i;:::-;;;;-1:-1:-1;;;;;;;2528:13:0;;;;;;:9;:13;;;;;;;:23;;;;;;2569:32;2578:10;;-1:-1:-1;;;;;;;;;;;2569:32:0;;;2545:6;1831:25:12;;1819:2;1804:18;;1685:177;3296:445:1;777:32;2505:16:3;2516:4;2505:10;:16::i;:::-;-1:-1:-1;;;;;3447:26:1;::::1;3490:1;3447:26:::0;;;:13:::1;:26;::::0;;;;:32:::1;;3441:46:::0;;::::1;::::0;::::1;:::i;:::-;;;:50;3433:89;;;::::0;-1:-1:-1;;;3433:89:1;;10712:2:12;3433:89:1::1;::::0;::::1;10694:21:12::0;10751:2;10731:18;;;10724:30;10790:28;10770:18;;;10763:56;10836:18;;3433:89:1::1;10510:350:12::0;3433:89:1::1;-1:-1:-1::0;;;;;3551:26:1;::::1;3529:19;3551:26:::0;;;:13:::1;:26;::::0;;;;;;;;:41;;-1:-1:-1;;;;;;3598:55:1;::::1;-1:-1:-1::0;;;;;3598:55:1;;::::1;::::0;;::::1;::::0;;;3665:71;;3551:41;;;::::1;11441:25:12::0;;;11482:18;;;11475:75;3551:41:1;;:26;3665:71:::1;::::0;11414:18:12;3665:71:1::1;11267:289:12::0;3773:132:1;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3874:26:1;;;;:13;:26;;;;;;3867:33;;;;;;;;;-1:-1:-1;;;;;3867:33:1;;;;;-1:-1:-1;;;3867:33:1;;;;;;;;;;;;;;;;-1:-1:-1;;3867:33:1;;3874:26;;3867:33;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3773:132;;;:::o;3333:861:0:-;3518:15;3506:8;:27;;3498:63;;;;-1:-1:-1;;;3498:63:0;;11763:2:12;3498:63:0;;;11745:21:12;11802:2;11782:18;;;11775:30;11841:25;11821:18;;;11814:53;11884:18;;3498:63:0;11561:347:12;3498:63:0;3708:14;3794:18;:16;:18::i;:::-;-1:-1:-1;;;;;3885:13:0;;;;;;;:6;:13;;;;;;;;;:15;;;;;;;;3834:77;;1231:95;3834:77;;;12200:25:12;12279:18;;;12272:43;;;;12351:15;;;12331:18;;;12324:43;12383:18;;;12376:34;;;12426:19;;;12419:35;;;;12470:19;;;;12463:35;;;3834:77:0;;;;;;;;;;12172:19:12;;;3834:77:0;;;3824:88;;;;;;;;-1:-1:-1;;;3744:178:0;;;12767:27:12;12810:11;;;12803:27;;;;12846:12;;;12839:28;;;;12883:12;;3744:178:0;;;-1:-1:-1;;3744:178:0;;;;;;;;;3725:205;;3744:178;3725:205;;;;3939:24;3966:26;;;;;;;;;13133:25:12;;;13206:4;13194:17;;13174:18;;;13167:45;;;;13228:18;;;13221:34;;;13271:18;;;13264:34;;;3725:205:0;;-1:-1:-1;3939:24:0;3966:26;;13105:19:12;;3966:26:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;3966:26:0;;-1:-1:-1;;3966:26:0;;;-1:-1:-1;;;;;;;4009:30:0;;;;;;:59;;;4063:5;-1:-1:-1;;;;;4043:25:0;:16;-1:-1:-1;;;;;4043:25:0;;4009:59;4001:86;;;;-1:-1:-1;;;4001:86:0;;13511:2:12;4001:86:0;;;13493:21:12;13550:2;13530:18;;;13523:30;-1:-1:-1;;;13569:18:12;;;13562:44;13623:18;;4001:86:0;13309:338:12;4001:86:0;-1:-1:-1;;;;;4096:27:0;;;;;;;:9;:27;;;;;;;;:36;;;;;;;;;;;;;:44;;;4158:31;1831:25:12;;;4096:36:0;;-1:-1:-1;4158:31:0;;;;;;1804:18:12;4158:31:0;;;;;;;3333:861;;;;;;;:::o;5228:147:3:-;4452:7;4478:12;;;:6;:12;;;;;:22;;;2505:16;2516:4;2505:10;:16::i;:::-;5342:26:::1;5354:4;5360:7;5342:11;:26::i;10251:300:11:-:0;10314:16;10342:22;10367:19;10375:3;10367:7;:19::i;:::-;10342:44;10251:300;-1:-1:-1;;;10251:300:11:o;3334:103:3:-;3400:30;3411:4;719:10:6;3400::3;:30::i;:::-;3334:103;:::o;7461:233::-;7544:22;7552:4;7558:7;7544;:22::i;:::-;7539:149;;7582:12;;;;:6;:12;;;;;;;;-1:-1:-1;;;;;7582:29:3;;;;;;;;;:36;;-1:-1:-1;;7582:36:3;7614:4;7582:36;;;7664:12;719:10:6;;640:96;7664:12:3;-1:-1:-1;;;;;7637:40:3;7655:7;-1:-1:-1;;;;;7637:40:3;7649:4;7637:40;;;;;;;;;;7461:233;;:::o;4373:386:0:-;4438:7;4507:119;4654:4;4638:22;;;;;;:::i;:::-;;;;;;;;;;4485:261;;;15149:25:12;;;;15190:18;;15183:34;;;;4672:14:0;15233:18:12;;;15226:34;4698:13:0;15276:18:12;;;15269:34;4731:4:0;15319:19:12;;;15312:61;15121:19;;4485:261:0;;;;;;;;;;;;4466:288;;;;;;4453:301;;4373:386;:::o;7865:234:3:-;7948:22;7956:4;7962:7;7948;:22::i;:::-;7944:149;;;8018:5;7986:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;7986:29:3;;;;;;;;;;:37;;-1:-1:-1;;7986:37:3;;;8042:40;719:10:6;;7986:12:3;;8042:40;;8018:5;8042:40;7865:234;;:::o;4949:293:0:-;5030:6;5015:11;;:21;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;5164:13:0;;;;;;:9;:13;;;;;;;;:23;;;;;;5205:32;1831:25:12;;;-1:-1:-1;;;;;;;;;;;5205:32:0;1804:18:12;5205:32:0;;;;;;;;4949:293;;:::o;5246:296::-;-1:-1:-1;;;;;5314:15:0;;;;;;:9;:15;;;;;:25;;5333:6;;5314:15;:25;;5333:6;;5314:25;:::i;:::-;;;;-1:-1:-1;;5464:11:0;:21;;;;;;;5503:34;;1831:25:12;;;-1:-1:-1;;;;;;;5503:34:0;;;-1:-1:-1;;;;;;;;;;;5503:34:0;1819:2:12;1804:18;5503:34:0;1685:177:12;8297:150:11;8367:4;8390:50;8395:3;-1:-1:-1;;;;;8415:23:11;;8390:4;:50::i;8615:156::-;8688:4;8711:53;8719:3;-1:-1:-1;;;;;8739:23:11;;8711:7;:53::i;5562:109::-;5618:16;5653:3;:11;;5646:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5562:109;;;:::o;3718:479:3:-;3806:22;3814:4;3820:7;3806;:22::i;:::-;3801:390;;3989:28;4009:7;3989:19;:28::i;:::-;4088:38;4116:4;4123:2;4088:19;:38::i;:::-;3896:252;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;3896:252:3;;;;;;;;;;-1:-1:-1;;;3844:336:3;;;;;;;:::i;2206:404:11:-;2269:4;4343:19;;;:12;;;:19;;;;;;2285:319;;-1:-1:-1;2327:23:11;;;;;;;;:11;:23;;;;;;;;;;;;;2507:18;;2485:19;;;:12;;;:19;;;;;;:40;;;;2539:11;;2285:319;-1:-1:-1;2588:5:11;2581:12;;2778:1388;2844:4;2981:19;;;:12;;;:19;;;;;;3015:15;;3011:1149;;3384:21;3408:14;3421:1;3408:10;:14;:::i;:::-;3456:18;;3384:38;;-1:-1:-1;3436:17:11;;3456:22;;3477:1;;3456:22;:::i;:::-;3436:42;;3510:13;3497:9;:26;3493:398;;3543:17;3563:3;:11;;3575:9;3563:22;;;;;;;;:::i;:::-;;;;;;;;;3543:42;;3714:9;3685:3;:11;;3697:13;3685:26;;;;;;;;:::i;:::-;;;;;;;;;;;;:38;;;;3797:23;;;:12;;;:23;;;;;:36;;;3493:398;3969:17;;:3;;:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;4061:3;:12;;:19;4074:5;4061:19;;;;;;;;;;;4054:26;;;4102:4;4095:11;;;;;;;3011:1149;4144:5;4137:12;;;;;2102:149:7;2160:13;2192:52;-1:-1:-1;;;;;2204:22:7;;311:2;1513:437;1588:13;1613:19;1645:10;1649:6;1645:1;:10;:::i;:::-;:14;;1658:1;1645:14;:::i;:::-;1635:25;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1635:25:7;;1613:47;;-1:-1:-1;;;1670:6:7;1677:1;1670:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;1670:15:7;;;;;;;;;-1:-1:-1;;;1695:6:7;1702:1;1695:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;1695:15:7;;;;;;;;-1:-1:-1;1725:9:7;1737:10;1741:6;1737:1;:10;:::i;:::-;:14;;1750:1;1737:14;:::i;:::-;1725:26;;1720:128;1757:1;1753;:5;1720:128;;;-1:-1:-1;;;1800:5:7;1808:3;1800:11;1791:21;;;;;;;:::i;:::-;;;;1779:6;1786:1;1779:9;;;;;;;;:::i;:::-;;;;:33;-1:-1:-1;;;;;1779:33:7;;;;;;;;-1:-1:-1;1836:1:7;1826:11;;;;;1760:3;;;:::i;:::-;;;1720:128;;;-1:-1:-1;1865:10:7;;1857:55;;;;-1:-1:-1;;;1857:55:7;;17087:2:12;1857:55:7;;;17069:21:12;;;17106:18;;;17099:30;17165:34;17145:18;;;17138:62;17217:18;;1857:55:7;16885:356:12;-1:-1:-1;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;:::i;:::-;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14:286:12;72:6;125:2;113:9;104:7;100:23;96:32;93:52;;;141:1;138;131:12;93:52;167:23;;-1:-1:-1;;;;;;219:32:12;;209:43;;199:71;;266:1;263;256:12;497:258;569:1;579:113;593:6;590:1;587:13;579:113;;;669:11;;;663:18;650:11;;;643:39;615:2;608:10;579:113;;;710:6;707:1;704:13;701:48;;;745:1;736:6;731:3;727:16;720:27;701:48;;497:258;;;:::o;760:::-;802:3;840:5;834:12;867:6;862:3;855:19;883:63;939:6;932:4;927:3;923:14;916:4;909:5;905:16;883:63;:::i;:::-;1000:2;979:15;-1:-1:-1;;975:29:12;966:39;;;;1007:4;962:50;;760:258;-1:-1:-1;;760:258:12:o;1023:220::-;1172:2;1161:9;1154:21;1135:4;1192:45;1233:2;1222:9;1218:18;1210:6;1192:45;:::i;1248:173::-;1316:20;;-1:-1:-1;;;;;1365:31:12;;1355:42;;1345:70;;1411:1;1408;1401:12;1345:70;1248:173;;;:::o;1426:254::-;1494:6;1502;1555:2;1543:9;1534:7;1530:23;1526:32;1523:52;;;1571:1;1568;1561:12;1523:52;1594:29;1613:9;1594:29;:::i;:::-;1584:39;1670:2;1655:18;;;;1642:32;;-1:-1:-1;;;1426:254:12:o;1867:658::-;2038:2;2090:21;;;2160:13;;2063:18;;;2182:22;;;2009:4;;2038:2;2261:15;;;;2235:2;2220:18;;;2009:4;2304:195;2318:6;2315:1;2312:13;2304:195;;;2383:13;;-1:-1:-1;;;;;2379:39:12;2367:52;;2474:15;;;;2439:12;;;;2415:1;2333:9;2304:195;;;-1:-1:-1;2516:3:12;;1867:658;-1:-1:-1;;;;;;1867:658:12:o;2530:328::-;2607:6;2615;2623;2676:2;2664:9;2655:7;2651:23;2647:32;2644:52;;;2692:1;2689;2682:12;2644:52;2715:29;2734:9;2715:29;:::i;:::-;2705:39;;2763:38;2797:2;2786:9;2782:18;2763:38;:::i;:::-;2753:48;;2848:2;2837:9;2833:18;2820:32;2810:42;;2530:328;;;;;:::o;2863:180::-;2922:6;2975:2;2963:9;2954:7;2950:23;2946:32;2943:52;;;2991:1;2988;2981:12;2943:52;-1:-1:-1;3014:23:12;;2863:180;-1:-1:-1;2863:180:12:o;3230:254::-;3298:6;3306;3359:2;3347:9;3338:7;3334:23;3330:32;3327:52;;;3375:1;3372;3365:12;3327:52;3411:9;3398:23;3388:33;;3440:38;3474:2;3463:9;3459:18;3440:38;:::i;:::-;3430:48;;3230:254;;;;;:::o;3863:186::-;3922:6;3975:2;3963:9;3954:7;3950:23;3946:32;3943:52;;;3991:1;3988;3981:12;3943:52;4014:29;4033:9;4014:29;:::i;4054:188::-;4122:20;;-1:-1:-1;;;;;4171:46:12;;4161:57;;4151:85;;4232:1;4229;4222:12;4247:740;4336:6;4344;4352;4360;4413:2;4401:9;4392:7;4388:23;4384:32;4381:52;;;4429:1;4426;4419:12;4381:52;4452:29;4471:9;4452:29;:::i;:::-;4442:39;;4532:2;4521:9;4517:18;4504:32;4555:18;4596:2;4588:6;4585:14;4582:34;;;4612:1;4609;4602:12;4582:34;4650:6;4639:9;4635:22;4625:32;;4695:7;4688:4;4684:2;4680:13;4676:27;4666:55;;4717:1;4714;4707:12;4666:55;4757:2;4744:16;4783:2;4775:6;4772:14;4769:34;;;4799:1;4796;4789:12;4769:34;4844:7;4839:2;4830:6;4826:2;4822:15;4818:24;4815:37;4812:57;;;4865:1;4862;4855:12;4812:57;4896:2;4892;4888:11;4878:21;;4918:6;4908:16;;;;;4943:38;4977:2;4966:9;4962:18;4943:38;:::i;:::-;4933:48;;4247:740;;;;;;;:::o;5245:260::-;5313:6;5321;5374:2;5362:9;5353:7;5349:23;5345:32;5342:52;;;5390:1;5387;5380:12;5342:52;5413:29;5432:9;5413:29;:::i;:::-;5403:39;;5461:38;5495:2;5484:9;5480:18;5461:38;:::i;5510:537::-;5695:2;5684:9;5677:21;5658:4;-1:-1:-1;;;;;5806:2:12;5797:6;5791:13;5787:22;5782:2;5771:9;5767:18;5760:50;5874:2;5868;5860:6;5856:15;5850:22;5846:31;5841:2;5830:9;5826:18;5819:59;;5925:2;5917:6;5913:15;5907:22;5967:4;5960;5949:9;5945:20;5938:34;5989:52;6036:3;6025:9;6021:19;6007:12;5989:52;:::i;:::-;5981:60;5510:537;-1:-1:-1;;;;5510:537:12:o;6052:693::-;6163:6;6171;6179;6187;6195;6203;6211;6264:3;6252:9;6243:7;6239:23;6235:33;6232:53;;;6281:1;6278;6271:12;6232:53;6304:29;6323:9;6304:29;:::i;:::-;6294:39;;6352:38;6386:2;6375:9;6371:18;6352:38;:::i;:::-;6342:48;;6437:2;6426:9;6422:18;6409:32;6399:42;;6488:2;6477:9;6473:18;6460:32;6450:42;;6542:3;6531:9;6527:19;6514:33;6587:4;6580:5;6576:16;6569:5;6566:27;6556:55;;6607:1;6604;6597:12;6556:55;6052:693;;;;-1:-1:-1;6052:693:12;;;;6630:5;6682:3;6667:19;;6654:33;;-1:-1:-1;6734:3:12;6719:19;;;6706:33;;6052:693;-1:-1:-1;;6052:693:12:o;6750:260::-;6818:6;6826;6879:2;6867:9;6858:7;6854:23;6850:32;6847:52;;;6895:1;6892;6885:12;6847:52;6918:29;6937:9;6918:29;:::i;:::-;6908:39;;6966:38;7000:2;6989:9;6985:18;6966:38;:::i;7015:380::-;7094:1;7090:12;;;;7137;;;7158:61;;7212:4;7204:6;7200:17;7190:27;;7158:61;7265:2;7257:6;7254:14;7234:18;7231:38;7228:161;;;7311:10;7306:3;7302:20;7299:1;7292:31;7346:4;7343:1;7336:15;7374:4;7371:1;7364:15;7228:161;;7015:380;;;:::o;7400:127::-;7461:10;7456:3;7452:20;7449:1;7442:31;7492:4;7489:1;7482:15;7516:4;7513:1;7506:15;7532:125;7572:4;7600:1;7597;7594:8;7591:34;;;7605:18;;:::i;:::-;-1:-1:-1;7642:9:12;;7532:125::o;8426:128::-;8466:3;8497:1;8493:6;8490:1;8487:13;8484:39;;;8503:18;;:::i;:::-;-1:-1:-1;8539:9:12;;8426:128::o;10009:273::-;10194:6;10186;10181:3;10168:33;10150:3;10220:16;;10245:13;;;10220:16;10009:273;-1:-1:-1;10009:273:12:o;13781:1104::-;13911:3;13940:1;13973:6;13967:13;14003:3;14025:1;14053:9;14049:2;14045:18;14035:28;;14113:2;14102:9;14098:18;14135;14125:61;;14179:4;14171:6;14167:17;14157:27;;14125:61;14205:2;14253;14245:6;14242:14;14222:18;14219:38;14216:165;;;-1:-1:-1;;;14280:33:12;;14336:4;14333:1;14326:15;14366:4;14287:3;14354:17;14216:165;14397:18;14424:104;;;;14542:1;14537:323;;;;14390:470;;14424:104;-1:-1:-1;;14457:24:12;;14445:37;;14502:16;;;;-1:-1:-1;14424:104:12;;14537:323;13728:1;13721:14;;;13765:4;13752:18;;14635:1;14649:165;14663:6;14660:1;14657:13;14649:165;;;14741:14;;14728:11;;;14721:35;14784:16;;;;14678:10;;14649:165;;;14653:3;;14843:6;14838:3;14834:16;14827:23;;14390:470;-1:-1:-1;14876:3:12;;13781:1104;-1:-1:-1;;;;;;;;13781:1104:12:o;15384:786::-;15795:25;15790:3;15783:38;15765:3;15850:6;15844:13;15866:62;15921:6;15916:2;15911:3;15907:12;15900:4;15892:6;15888:17;15866:62;:::i;:::-;-1:-1:-1;;;15987:2:12;15947:16;;;15979:11;;;15972:40;16037:13;;16059:63;16037:13;16108:2;16100:11;;16093:4;16081:17;;16059:63;:::i;:::-;16142:17;16161:2;16138:26;;15384:786;-1:-1:-1;;;;15384:786:12:o;16175:127::-;16236:10;16231:3;16227:20;16224:1;16217:31;16267:4;16264:1;16257:15;16291:4;16288:1;16281:15;16307:127;16368:10;16363:3;16359:20;16356:1;16349:31;16399:4;16396:1;16389:15;16423:4;16420:1;16413:15;16439:168;16479:7;16545:1;16541;16537:6;16533:14;16530:1;16527:21;16522:1;16515:9;16508:17;16504:45;16501:71;;;16552:18;;:::i;:::-;-1:-1:-1;16592:9:12;;16439:168::o;16612:127::-;16673:10;16668:3;16664:20;16661:1;16654:31;16704:4;16701:1;16694:15;16728:4;16725:1;16718:15;16744:136;16783:3;16811:5;16801:39;;16820:18;;:::i;:::-;-1:-1:-1;;;16856:18:12;;16744:136::o

ipfs://9563bae06a8378e42705a7745ae022ca532895a0d3b9c01ee9be6f64fe7fdcb5