Token OrcaDAO

/**
 *Submitted for verification at Etherscan.io on 2021-11-05
*/

// Sources flattened with hardhat v2.6.1 https://hardhat.org

// File @openzeppelin/contracts/token/ERC20/[email protected]

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
  /**
   * @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 `recipient`.
   *
   * Returns a boolean value indicating whether the operation succeeded.
   *
   * Emits a {Transfer} event.
   */
  function transfer(address recipient, 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 `sender` to `recipient` 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 sender,
    address recipient,
    uint256 amount
  ) external returns (bool);

  /**
   * @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);
}

// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]

pragma solidity ^0.8.0;

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
  /**
   * @dev Returns the name of the token.
   */
  function name() external view returns (string memory);

  /**
   * @dev Returns the symbol of the token.
   */
  function symbol() external view returns (string memory);

  /**
   * @dev Returns the decimals places of the token.
   */
  function decimals() external view returns (uint8);
}

// File @openzeppelin/contracts/utils/[email protected]

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;
  }
}

// File @openzeppelin/contracts/token/ERC20/[email protected]

pragma solidity ^0.8.0;

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of returning `false` on failure. This behavior is nonetheless conventional
 * and does not conflict with the expectations of ERC20 applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
  mapping(address => uint256) private _balances;

  mapping(address => mapping(address => uint256)) private _allowances;

  uint256 private _totalSupply;

  string private _name;
  string private _symbol;

  /**
   * @dev Sets the values for {name} and {symbol}.
   *
   * The default value of {decimals} is 18. To select a different value for
   * {decimals} you should overload it.
   *
   * All two of these values are immutable: they can only be set once during
   * construction.
   */
  constructor(string memory name_, string memory symbol_) {
    _name = name_;
    _symbol = symbol_;
  }

  /**
   * @dev Returns the name of the token.
   */
  function name() public view virtual override returns (string memory) {
    return _name;
  }

  /**
   * @dev Returns the symbol of the token, usually a shorter version of the
   * name.
   */
  function symbol() public view virtual override returns (string memory) {
    return _symbol;
  }

  /**
   * @dev Returns the number of decimals used to get its user representation.
   * For example, if `decimals` equals `2`, a balance of `505` tokens should
   * be displayed to a user as `5,05` (`505 / 10 ** 2`).
   *
   * Tokens usually opt for a value of 18, imitating the relationship between
   * Ether and Wei. This is the value {ERC20} uses, unless this function is
   * overridden;
   *
   * NOTE: This information is only used for _display_ purposes: it in
   * no way affects any of the arithmetic of the contract, including
   * {IERC20-balanceOf} and {IERC20-transfer}.
   */
  function decimals() public view virtual override returns (uint8) {
    return 18;
  }

  /**
   * @dev See {IERC20-totalSupply}.
   */
  function totalSupply() public view virtual override returns (uint256) {
    return _totalSupply;
  }

  /**
   * @dev See {IERC20-balanceOf}.
   */
  function balanceOf(address account)
    public
    view
    virtual
    override
    returns (uint256)
  {
    return _balances[account];
  }

  /**
   * @dev See {IERC20-transfer}.
   *
   * Requirements:
   *
   * - `recipient` cannot be the zero address.
   * - the caller must have a balance of at least `amount`.
   */
  function transfer(address recipient, uint256 amount)
    public
    virtual
    override
    returns (bool)
  {
    _transfer(_msgSender(), recipient, amount);
    return true;
  }

  /**
   * @dev See {IERC20-allowance}.
   */
  function allowance(address owner, address spender)
    public
    view
    virtual
    override
    returns (uint256)
  {
    return _allowances[owner][spender];
  }

  /**
   * @dev See {IERC20-approve}.
   *
   * Requirements:
   *
   * - `spender` cannot be the zero address.
   */
  function approve(address spender, uint256 amount)
    public
    virtual
    override
    returns (bool)
  {
    _approve(_msgSender(), spender, amount);
    return true;
  }

  /**
   * @dev See {IERC20-transferFrom}.
   *
   * Emits an {Approval} event indicating the updated allowance. This is not
   * required by the EIP. See the note at the beginning of {ERC20}.
   *
   * Requirements:
   *
   * - `sender` and `recipient` cannot be the zero address.
   * - `sender` must have a balance of at least `amount`.
   * - the caller must have allowance for ``sender``'s tokens of at least
   * `amount`.
   */
  function transferFrom(
    address sender,
    address recipient,
    uint256 amount
  ) public virtual override returns (bool) {
    _transfer(sender, recipient, amount);

    uint256 currentAllowance = _allowances[sender][_msgSender()];
    require(
      currentAllowance >= amount,
      'ERC20: transfer amount exceeds allowance'
    );
    unchecked {
      _approve(sender, _msgSender(), currentAllowance - amount);
    }

    return true;
  }

  /**
   * @dev Atomically increases the allowance granted to `spender` by the caller.
   *
   * This is an alternative to {approve} that can be used as a mitigation for
   * problems described in {IERC20-approve}.
   *
   * Emits an {Approval} event indicating the updated allowance.
   *
   * Requirements:
   *
   * - `spender` cannot be the zero address.
   */
  function increaseAllowance(address spender, uint256 addedValue)
    public
    virtual
    returns (bool)
  {
    _approve(
      _msgSender(),
      spender,
      _allowances[_msgSender()][spender] + addedValue
    );
    return true;
  }

  /**
   * @dev Atomically decreases the allowance granted to `spender` by the caller.
   *
   * This is an alternative to {approve} that can be used as a mitigation for
   * problems described in {IERC20-approve}.
   *
   * Emits an {Approval} event indicating the updated allowance.
   *
   * Requirements:
   *
   * - `spender` cannot be the zero address.
   * - `spender` must have allowance for the caller of at least
   * `subtractedValue`.
   */
  function decreaseAllowance(address spender, uint256 subtractedValue)
    public
    virtual
    returns (bool)
  {
    uint256 currentAllowance = _allowances[_msgSender()][spender];
    require(
      currentAllowance >= subtractedValue,
      'ERC20: decreased allowance below zero'
    );
    unchecked {
      _approve(_msgSender(), spender, currentAllowance - subtractedValue);
    }

    return true;
  }

  /**
   * @dev Moves `amount` of tokens from `sender` to `recipient`.
   *
   * This internal function is equivalent to {transfer}, and can be used to
   * e.g. implement automatic token fees, slashing mechanisms, etc.
   *
   * Emits a {Transfer} event.
   *
   * Requirements:
   *
   * - `sender` cannot be the zero address.
   * - `recipient` cannot be the zero address.
   * - `sender` must have a balance of at least `amount`.
   */
  function _transfer(
    address sender,
    address recipient,
    uint256 amount
  ) internal virtual {
    require(sender != address(0), 'ERC20: transfer from the zero address');
    require(recipient != address(0), 'ERC20: transfer to the zero address');

    _beforeTokenTransfer(sender, recipient, amount);

    uint256 senderBalance = _balances[sender];
    require(senderBalance >= amount, 'ERC20: transfer amount exceeds balance');
    unchecked {
      _balances[sender] = senderBalance - amount;
    }
    _balances[recipient] += amount;

    emit Transfer(sender, recipient, amount);

    _afterTokenTransfer(sender, recipient, amount);
  }

  /** @dev Creates `amount` tokens and assigns them to `account`, increasing
   * the total supply.
   *
   * Emits a {Transfer} event with `from` set to the zero address.
   *
   * Requirements:
   *
   * - `account` cannot be the zero address.
   */
  function _mint(address account, uint256 amount) internal virtual {
    require(account != address(0), 'ERC20: mint to the zero address');

    _beforeTokenTransfer(address(0), account, amount);

    _totalSupply += amount;
    _balances[account] += amount;
    emit Transfer(address(0), account, amount);

    _afterTokenTransfer(address(0), account, amount);
  }

  /**
   * @dev Destroys `amount` tokens from `account`, reducing the
   * total supply.
   *
   * Emits a {Transfer} event with `to` set to the zero address.
   *
   * Requirements:
   *
   * - `account` cannot be the zero address.
   * - `account` must have at least `amount` tokens.
   */
  function _burn(address account, uint256 amount) internal virtual {
    require(account != address(0), 'ERC20: burn from the zero address');

    _beforeTokenTransfer(account, address(0), amount);

    uint256 accountBalance = _balances[account];
    require(accountBalance >= amount, 'ERC20: burn amount exceeds balance');
    unchecked {
      _balances[account] = accountBalance - amount;
    }
    _totalSupply -= amount;

    emit Transfer(account, address(0), amount);

    _afterTokenTransfer(account, address(0), amount);
  }

  /**
   * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
   *
   * This internal function is equivalent to `approve`, and can be used to
   * e.g. set automatic allowances for certain subsystems, etc.
   *
   * Emits an {Approval} event.
   *
   * Requirements:
   *
   * - `owner` cannot be the zero address.
   * - `spender` cannot be the zero address.
   */
  function _approve(
    address owner,
    address spender,
    uint256 amount
  ) internal virtual {
    require(owner != address(0), 'ERC20: approve from the zero address');
    require(spender != address(0), 'ERC20: approve to the zero address');

    _allowances[owner][spender] = amount;
    emit Approval(owner, spender, amount);
  }

  /**
   * @dev Hook that is called before any transfer of tokens. This includes
   * minting and burning.
   *
   * Calling conditions:
   *
   * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
   * will be transferred to `to`.
   * - when `from` is zero, `amount` tokens will be minted for `to`.
   * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
   * - `from` and `to` are never both zero.
   *
   * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
   */
  function _beforeTokenTransfer(
    address from,
    address to,
    uint256 amount
  ) internal virtual {}

  /**
   * @dev Hook that is called after any transfer of tokens. This includes
   * minting and burning.
   *
   * Calling conditions:
   *
   * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
   * has been transferred to `to`.
   * - when `from` is zero, `amount` tokens have been minted for `to`.
   * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
   * - `from` and `to` are never both zero.
   *
   * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
   */
  function _afterTokenTransfer(
    address from,
    address to,
    uint256 amount
  ) internal virtual {}
}

// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
  /**
   * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
   * given ``owner``'s signed approval.
   *
   * IMPORTANT: The same issues {IERC20-approve} has related to transaction
   * ordering also apply here.
   *
   * Emits an {Approval} event.
   *
   * Requirements:
   *
   * - `spender` cannot be the zero address.
   * - `deadline` must be a timestamp in the future.
   * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
   * over the EIP712-formatted function arguments.
   * - the signature must use ``owner``'s current nonce (see {nonces}).
   *
   * For more information on the signature format, see the
   * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
   * section].
   */
  function permit(
    address owner,
    address spender,
    uint256 value,
    uint256 deadline,
    uint8 v,
    bytes32 r,
    bytes32 s
  ) external;

  /**
   * @dev Returns the current nonce for `owner`. This value must be
   * included whenever a signature is generated for {permit}.
   *
   * Every successful call to {permit} increases ``owner``'s nonce by one. This
   * prevents a signature from being used multiple times.
   */
  function nonces(address owner) external view returns (uint256);

  /**
   * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
   */
  // solhint-disable-next-line func-name-mixedcase
  function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// File @openzeppelin/contracts/utils/cryptography/[email protected]

pragma solidity ^0.8.0;

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
  /**
   * @dev Returns the address that signed a hashed message (`hash`) with
   * `signature`. This address can then be used for verification purposes.
   *
   * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
   * this function rejects them by requiring the `s` value to be in the lower
   * half order, and the `v` value to be either 27 or 28.
   *
   * IMPORTANT: `hash` _must_ be the result of a hash operation for the
   * verification to be secure: it is possible to craft signatures that
   * recover to arbitrary addresses for non-hashed data. A safe way to ensure
   * this is by receiving a hash of the original message (which may otherwise
   * be too long), and then calling {toEthSignedMessageHash} on it.
   *
   * Documentation for signature generation:
   * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
   * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
   */
  function recover(bytes32 hash, bytes memory signature)
    internal
    pure
    returns (address)
  {
    // Check the signature length
    // - case 65: r,s,v signature (standard)
    // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
    if (signature.length == 65) {
      bytes32 r;
      bytes32 s;
      uint8 v;
      // ecrecover takes the signature parameters, and the only way to get them
      // currently is to use assembly.
      assembly {
        r := mload(add(signature, 0x20))
        s := mload(add(signature, 0x40))
        v := byte(0, mload(add(signature, 0x60)))
      }
      return recover(hash, v, r, s);
    } else if (signature.length == 64) {
      bytes32 r;
      bytes32 vs;
      // ecrecover takes the signature parameters, and the only way to get them
      // currently is to use assembly.
      assembly {
        r := mload(add(signature, 0x20))
        vs := mload(add(signature, 0x40))
      }
      return recover(hash, r, vs);
    } else {
      revert('ECDSA: invalid signature length');
    }
  }

  /**
   * @dev Overload of {ECDSA-recover} that receives the `r` and `vs` short-signature fields separately.
   *
   * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
   *
   * _Available since v4.2._
   */
  function recover(
    bytes32 hash,
    bytes32 r,
    bytes32 vs
  ) internal pure returns (address) {
    bytes32 s;
    uint8 v;
    assembly {
      s := and(
        vs,
        0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
      )
      v := add(shr(255, vs), 27)
    }
    return recover(hash, v, r, s);
  }

  /**
   * @dev Overload of {ECDSA-recover} that receives the `v`, `r` and `s` signature fields separately.
   */
  function recover(
    bytes32 hash,
    uint8 v,
    bytes32 r,
    bytes32 s
  ) internal pure returns (address) {
    // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
    // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
    // the valid range for s in (281): 0 < s < secp256k1n ÷ 2 + 1, and for v in (282): v ∈ {27, 28}. Most
    // signatures from current libraries generate a unique signature with an s-value in the lower half order.
    //
    // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
    // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
    // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
    // these malleable signatures as well.
    require(
      uint256(s) <=
        0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0,
      "ECDSA: invalid signature 's' value"
    );
    require(v == 27 || v == 28, "ECDSA: invalid signature 'v' value");

    // If the signature is valid (and not malleable), return the signer address
    address signer = ecrecover(hash, v, r, s);
    require(signer != address(0), 'ECDSA: invalid signature');

    return signer;
  }

  /**
   * @dev Returns an Ethereum Signed Message, created from a `hash`. This
   * produces hash corresponding to the one signed with the
   * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
   * JSON-RPC method as part of EIP-191.
   *
   * See {recover}.
   */
  function toEthSignedMessageHash(bytes32 hash)
    internal
    pure
    returns (bytes32)
  {
    // 32 is the length in bytes of hash,
    // enforced by the type signature above
    return
      keccak256(abi.encodePacked('\x19Ethereum Signed Message:\n32', hash));
  }

  /**
   * @dev Returns an Ethereum Signed Typed Data, created from a
   * `domainSeparator` and a `structHash`. This produces hash corresponding
   * to the one signed with the
   * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
   * JSON-RPC method as part of EIP-712.
   *
   * See {recover}.
   */
  function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash)
    internal
    pure
    returns (bytes32)
  {
    return keccak256(abi.encodePacked('\x19\x01', domainSeparator, structHash));
  }
}

// File @openzeppelin/contracts/utils/cryptography/[email protected]

pragma solidity ^0.8.0;

/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,
 * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding
 * they need in their contracts using a combination of `abi.encode` and `keccak256`.
 *
 * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
 * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
 * ({_hashTypedDataV4}).
 *
 * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
 * the chain id to protect against replay attacks on an eventual fork of the chain.
 *
 * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
 * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
 *
 * _Available since v3.4._
 */
abstract contract EIP712 {
  /* solhint-disable var-name-mixedcase */
  // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
  // invalidate the cached domain separator if the chain id changes.
  bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
  uint256 private immutable _CACHED_CHAIN_ID;

  bytes32 private immutable _HASHED_NAME;
  bytes32 private immutable _HASHED_VERSION;
  bytes32 private immutable _TYPE_HASH;

  /* solhint-enable var-name-mixedcase */

  /**
   * @dev Initializes the domain separator and parameter caches.
   *
   * The meaning of `name` and `version` is specified in
   * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
   *
   * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
   * - `version`: the current major version of the signing domain.
   *
   * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
   * contract upgrade].
   */
  constructor(string memory name, string memory version) {
    bytes32 hashedName = keccak256(bytes(name));
    bytes32 hashedVersion = keccak256(bytes(version));
    bytes32 typeHash = keccak256(
      'EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)'
    );
    _HASHED_NAME = hashedName;
    _HASHED_VERSION = hashedVersion;
    _CACHED_CHAIN_ID = block.chainid;
    _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(
      typeHash,
      hashedName,
      hashedVersion
    );
    _TYPE_HASH = typeHash;
  }

  /**
   * @dev Returns the domain separator for the current chain.
   */
  function _domainSeparatorV4() internal view returns (bytes32) {
    if (block.chainid == _CACHED_CHAIN_ID) {
      return _CACHED_DOMAIN_SEPARATOR;
    } else {
      return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
    }
  }

  function _buildDomainSeparator(
    bytes32 typeHash,
    bytes32 nameHash,
    bytes32 versionHash
  ) private view returns (bytes32) {
    return
      keccak256(
        abi.encode(
          typeHash,
          nameHash,
          versionHash,
          block.chainid,
          address(this)
        )
      );
  }

  /**
   * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
   * function returns the hash of the fully encoded EIP712 message for this domain.
   *
   * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
   *
   * ```solidity
   * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
   *     keccak256("Mail(address to,string contents)"),
   *     mailTo,
   *     keccak256(bytes(mailContents))
   * )));
   * address signer = ECDSA.recover(digest, signature);
   * ```
   */
  function _hashTypedDataV4(bytes32 structHash)
    internal
    view
    virtual
    returns (bytes32)
  {
    return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
  }
}

// File @openzeppelin/contracts/utils/[email protected]

pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
  struct Counter {
    // This variable should never be directly accessed by users of the library: interactions must be restricted to
    // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
    // this feature: see https://github.com/ethereum/solidity/issues/4637
    uint256 _value; // default: 0
  }

  function current(Counter storage counter) internal view returns (uint256) {
    return counter._value;
  }

  function increment(Counter storage counter) internal {
    unchecked {
      counter._value += 1;
    }
  }

  function decrement(Counter storage counter) internal {
    uint256 value = counter._value;
    require(value > 0, 'Counter: decrement overflow');
    unchecked {
      counter._value = value - 1;
    }
  }

  function reset(Counter storage counter) internal {
    counter._value = 0;
  }
}

// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]

pragma solidity ^0.8.0;

/**
 * @dev Implementation of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * _Available since v3.4._
 */
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {
  using Counters for Counters.Counter;

  mapping(address => Counters.Counter) private _nonces;

  // solhint-disable-next-line var-name-mixedcase
  bytes32 private immutable _PERMIT_TYPEHASH =
    keccak256(
      'Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)'
    );

  /**
   * @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `"1"`.
   *
   * It's a good idea to use the same `name` that is defined as the ERC20 token name.
   */
  constructor(string memory name) EIP712(name, '1') {}

  /**
   * @dev See {IERC20Permit-permit}.
   */
  function permit(
    address owner,
    address spender,
    uint256 value,
    uint256 deadline,
    uint8 v,
    bytes32 r,
    bytes32 s
  ) public virtual override {
    require(block.timestamp <= deadline, 'ERC20Permit: expired deadline');

    bytes32 structHash = keccak256(
      abi.encode(
        _PERMIT_TYPEHASH,
        owner,
        spender,
        value,
        _useNonce(owner),
        deadline
      )
    );

    bytes32 hash = _hashTypedDataV4(structHash);

    address signer = ECDSA.recover(hash, v, r, s);
    require(signer == owner, 'ERC20Permit: invalid signature');

    _approve(owner, spender, value);
  }

  /**
   * @dev See {IERC20Permit-nonces}.
   */
  function nonces(address owner)
    public
    view
    virtual
    override
    returns (uint256)
  {
    return _nonces[owner].current();
  }

  /**
   * @dev See {IERC20Permit-DOMAIN_SEPARATOR}.
   */
  // solhint-disable-next-line func-name-mixedcase
  function DOMAIN_SEPARATOR() external view override returns (bytes32) {
    return _domainSeparatorV4();
  }

  /**
   * @dev "Consume a nonce": return the current value and increment.
   *
   * _Available since v4.1._
   */
  function _useNonce(address owner) internal virtual returns (uint256 current) {
    Counters.Counter storage nonce = _nonces[owner];
    current = nonce.current();
    nonce.increment();
  }
}

// File @openzeppelin/contracts/utils/math/[email protected]

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
  /**
   * @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, so we distribute.
    return (a / 2) + (b / 2) + (((a % 2) + (b % 2)) / 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 / b + (a % b == 0 ? 0 : 1);
  }
}

// File @openzeppelin/contracts/utils/math/[email protected]

pragma solidity ^0.8.0;

/**
 * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow
 * checks.
 *
 * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
 * easily result in undesired exploitation or bugs, since developers usually
 * assume that overflows raise errors. `SafeCast` restores this intuition by
 * reverting the transaction when such an operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 *
 * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing
 * all math on `uint256` and `int256` and then downcasting.
 */
library SafeCast {
  /**
   * @dev Returns the downcasted uint224 from uint256, reverting on
   * overflow (when the input is greater than largest uint224).
   *
   * Counterpart to Solidity's `uint224` operator.
   *
   * Requirements:
   *
   * - input must fit into 224 bits
   */
  function toUint224(uint256 value) internal pure returns (uint224) {
    require(
      value <= type(uint224).max,
      "SafeCast: value doesn't fit in 224 bits"
    );
    return uint224(value);
  }

  /**
   * @dev Returns the downcasted uint128 from uint256, reverting on
   * overflow (when the input is greater than largest uint128).
   *
   * Counterpart to Solidity's `uint128` operator.
   *
   * Requirements:
   *
   * - input must fit into 128 bits
   */
  function toUint128(uint256 value) internal pure returns (uint128) {
    require(
      value <= type(uint128).max,
      "SafeCast: value doesn't fit in 128 bits"
    );
    return uint128(value);
  }

  /**
   * @dev Returns the downcasted uint96 from uint256, reverting on
   * overflow (when the input is greater than largest uint96).
   *
   * Counterpart to Solidity's `uint96` operator.
   *
   * Requirements:
   *
   * - input must fit into 96 bits
   */
  function toUint96(uint256 value) internal pure returns (uint96) {
    require(
      value <= type(uint96).max,
      "SafeCast: value doesn't fit in 96 bits"
    );
    return uint96(value);
  }

  /**
   * @dev Returns the downcasted uint64 from uint256, reverting on
   * overflow (when the input is greater than largest uint64).
   *
   * Counterpart to Solidity's `uint64` operator.
   *
   * Requirements:
   *
   * - input must fit into 64 bits
   */
  function toUint64(uint256 value) internal pure returns (uint64) {
    require(
      value <= type(uint64).max,
      "SafeCast: value doesn't fit in 64 bits"
    );
    return uint64(value);
  }

  /**
   * @dev Returns the downcasted uint32 from uint256, reverting on
   * overflow (when the input is greater than largest uint32).
   *
   * Counterpart to Solidity's `uint32` operator.
   *
   * Requirements:
   *
   * - input must fit into 32 bits
   */
  function toUint32(uint256 value) internal pure returns (uint32) {
    require(
      value <= type(uint32).max,
      "SafeCast: value doesn't fit in 32 bits"
    );
    return uint32(value);
  }

  /**
   * @dev Returns the downcasted uint16 from uint256, reverting on
   * overflow (when the input is greater than largest uint16).
   *
   * Counterpart to Solidity's `uint16` operator.
   *
   * Requirements:
   *
   * - input must fit into 16 bits
   */
  function toUint16(uint256 value) internal pure returns (uint16) {
    require(
      value <= type(uint16).max,
      "SafeCast: value doesn't fit in 16 bits"
    );
    return uint16(value);
  }

  /**
   * @dev Returns the downcasted uint8 from uint256, reverting on
   * overflow (when the input is greater than largest uint8).
   *
   * Counterpart to Solidity's `uint8` operator.
   *
   * Requirements:
   *
   * - input must fit into 8 bits.
   */
  function toUint8(uint256 value) internal pure returns (uint8) {
    require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
    return uint8(value);
  }

  /**
   * @dev Converts a signed int256 into an unsigned uint256.
   *
   * Requirements:
   *
   * - input must be greater than or equal to 0.
   */
  function toUint256(int256 value) internal pure returns (uint256) {
    require(value >= 0, 'SafeCast: value must be positive');
    return uint256(value);
  }

  /**
   * @dev Returns the downcasted int128 from int256, reverting on
   * overflow (when the input is less than smallest int128 or
   * greater than largest int128).
   *
   * Counterpart to Solidity's `int128` operator.
   *
   * Requirements:
   *
   * - input must fit into 128 bits
   *
   * _Available since v3.1._
   */
  function toInt128(int256 value) internal pure returns (int128) {
    require(
      value >= type(int128).min && value <= type(int128).max,
      "SafeCast: value doesn't fit in 128 bits"
    );
    return int128(value);
  }

  /**
   * @dev Returns the downcasted int64 from int256, reverting on
   * overflow (when the input is less than smallest int64 or
   * greater than largest int64).
   *
   * Counterpart to Solidity's `int64` operator.
   *
   * Requirements:
   *
   * - input must fit into 64 bits
   *
   * _Available since v3.1._
   */
  function toInt64(int256 value) internal pure returns (int64) {
    require(
      value >= type(int64).min && value <= type(int64).max,
      "SafeCast: value doesn't fit in 64 bits"
    );
    return int64(value);
  }

  /**
   * @dev Returns the downcasted int32 from int256, reverting on
   * overflow (when the input is less than smallest int32 or
   * greater than largest int32).
   *
   * Counterpart to Solidity's `int32` operator.
   *
   * Requirements:
   *
   * - input must fit into 32 bits
   *
   * _Available since v3.1._
   */
  function toInt32(int256 value) internal pure returns (int32) {
    require(
      value >= type(int32).min && value <= type(int32).max,
      "SafeCast: value doesn't fit in 32 bits"
    );
    return int32(value);
  }

  /**
   * @dev Returns the downcasted int16 from int256, reverting on
   * overflow (when the input is less than smallest int16 or
   * greater than largest int16).
   *
   * Counterpart to Solidity's `int16` operator.
   *
   * Requirements:
   *
   * - input must fit into 16 bits
   *
   * _Available since v3.1._
   */
  function toInt16(int256 value) internal pure returns (int16) {
    require(
      value >= type(int16).min && value <= type(int16).max,
      "SafeCast: value doesn't fit in 16 bits"
    );
    return int16(value);
  }

  /**
   * @dev Returns the downcasted int8 from int256, reverting on
   * overflow (when the input is less than smallest int8 or
   * greater than largest int8).
   *
   * Counterpart to Solidity's `int8` operator.
   *
   * Requirements:
   *
   * - input must fit into 8 bits.
   *
   * _Available since v3.1._
   */
  function toInt8(int256 value) internal pure returns (int8) {
    require(
      value >= type(int8).min && value <= type(int8).max,
      "SafeCast: value doesn't fit in 8 bits"
    );
    return int8(value);
  }

  /**
   * @dev Converts an unsigned uint256 into a signed int256.
   *
   * Requirements:
   *
   * - input must be less than or equal to maxInt256.
   */
  function toInt256(uint256 value) internal pure returns (int256) {
    // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
    require(
      value <= uint256(type(int256).max),
      "SafeCast: value doesn't fit in an int256"
    );
    return int256(value);
  }
}

// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]

pragma solidity ^0.8.0;

/**
 * @dev Extension of ERC20 to support Compound-like voting and delegation. This version is more generic than Compound's,
 * and supports token supply up to 2^224^ - 1, while COMP is limited to 2^96^ - 1.
 *
 * NOTE: If exact COMP compatibility is required, use the {ERC20VotesComp} variant of this module.
 *
 * This extension keeps a history (checkpoints) of each account's vote power. Vote power can be delegated either
 * by calling the {delegate} function directly, or by providing a signature to be used with {delegateBySig}. Voting
 * power can be queried through the public accessors {getVotes} and {getPastVotes}.
 *
 * By default, token balance does not account for voting power. This makes transfers cheaper. The downside is that it
 * requires users to delegate to themselves in order to activate checkpoints and have their voting power tracked.
 * Enabling self-delegation can easily be done by overriding the {delegates} function. Keep in mind however that this
 * will significantly increase the base gas cost of transfers.
 *
 * _Available since v4.2._
 */
abstract contract ERC20Votes is ERC20Permit {
  struct Checkpoint {
    uint32 fromBlock;
    uint224 votes;
  }

  bytes32 private constant _DELEGATION_TYPEHASH =
    keccak256('Delegation(address delegatee,uint256 nonce,uint256 expiry)');

  mapping(address => address) private _delegates;
  mapping(address => Checkpoint[]) private _checkpoints;
  Checkpoint[] private _totalSupplyCheckpoints;

  /**
   * @dev Emitted when an account changes their delegate.
   */
  event DelegateChanged(
    address indexed delegator,
    address indexed fromDelegate,
    address indexed toDelegate
  );

  /**
   * @dev Emitted when a token transfer or delegate change results in changes to an account's voting power.
   */
  event DelegateVotesChanged(
    address indexed delegate,
    uint256 previousBalance,
    uint256 newBalance
  );

  /**
   * @dev Get the `pos`-th checkpoint for `account`.
   */
  function checkpoints(address account, uint32 pos)
    public
    view
    virtual
    returns (Checkpoint memory)
  {
    return _checkpoints[account][pos];
  }

  /**
   * @dev Get number of checkpoints for `account`.
   */
  function numCheckpoints(address account)
    public
    view
    virtual
    returns (uint32)
  {
    return SafeCast.toUint32(_checkpoints[account].length);
  }

  /**
   * @dev Get the address `account` is currently delegating to.
   */
  function delegates(address account) public view virtual returns (address) {
    return _delegates[account];
  }

  /**
   * @dev Gets the current votes balance for `account`
   */
  function getVotes(address account) public view returns (uint256) {
    uint256 pos = _checkpoints[account].length;
    return pos == 0 ? 0 : _checkpoints[account][pos - 1].votes;
  }

  /**
   * @dev Retrieve the number of votes for `account` at the end of `blockNumber`.
   *
   * Requirements:
   *
   * - `blockNumber` must have been already mined
   */
  function getPastVotes(address account, uint256 blockNumber)
    public
    view
    returns (uint256)
  {
    require(blockNumber < block.number, 'ERC20Votes: block not yet mined');
    return _checkpointsLookup(_checkpoints[account], blockNumber);
  }

  /**
   * @dev Retrieve the `totalSupply` at the end of `blockNumber`. Note, this value is the sum of all balances.
   * It is but NOT the sum of all the delegated votes!
   *
   * Requirements:
   *
   * - `blockNumber` must have been already mined
   */
  function getPastTotalSupply(uint256 blockNumber)
    public
    view
    returns (uint256)
  {
    require(blockNumber < block.number, 'ERC20Votes: block not yet mined');
    return _checkpointsLookup(_totalSupplyCheckpoints, blockNumber);
  }

  /**
   * @dev Lookup a value in a list of (sorted) checkpoints.
   */
  function _checkpointsLookup(Checkpoint[] storage ckpts, uint256 blockNumber)
    private
    view
    returns (uint256)
  {
    // We run a binary search to look for the earliest checkpoint taken after `blockNumber`.
    //
    // During the loop, the index of the wanted checkpoint remains in the range [low, high).
    // With each iteration, either `low` or `high` is moved towards the middle of the range to maintain the invariant.
    // - If the middle checkpoint is after `blockNumber`, we look in [low, mid)
    // - If the middle checkpoint is before `blockNumber`, we look in [mid+1, high)
    // Once we reach a single value (when low == high), we've found the right checkpoint at the index high-1, if not
    // out of bounds (in which case we're looking too far in the past and the result is 0).
    // Note that if the latest checkpoint available is exactly for `blockNumber`, we end up with an index that is
    // past the end of the array, so we technically don't find a checkpoint after `blockNumber`, but it works out
    // the same.
    uint256 high = ckpts.length;
    uint256 low = 0;
    while (low < high) {
      uint256 mid = Math.average(low, high);
      if (ckpts[mid].fromBlock > blockNumber) {
        high = mid;
      } else {
        low = mid + 1;
      }
    }

    return high == 0 ? 0 : ckpts[high - 1].votes;
  }

  /**
   * @dev Delegate votes from the sender to `delegatee`.
   */
  function delegate(address delegatee) public virtual {
    return _delegate(_msgSender(), delegatee);
  }

  /**
   * @dev Delegates votes from signer to `delegatee`
   */
  function delegateBySig(
    address delegatee,
    uint256 nonce,
    uint256 expiry,
    uint8 v,
    bytes32 r,
    bytes32 s
  ) public virtual {
    require(block.timestamp <= expiry, 'ERC20Votes: signature expired');
    address signer = ECDSA.recover(
      _hashTypedDataV4(
        keccak256(abi.encode(_DELEGATION_TYPEHASH, delegatee, nonce, expiry))
      ),
      v,
      r,
      s
    );
    require(nonce == _useNonce(signer), 'ERC20Votes: invalid nonce');
    return _delegate(signer, delegatee);
  }

  /**
   * @dev Maximum token supply. Defaults to `type(uint224).max` (2^224^ - 1).
   */
  function _maxSupply() internal view virtual returns (uint224) {
    return type(uint224).max;
  }

  /**
   * @dev Snapshots the totalSupply after it has been increased.
   */
  function _mint(address account, uint256 amount) internal virtual override {
    super._mint(account, amount);
    require(
      totalSupply() <= _maxSupply(),
      'ERC20Votes: total supply risks overflowing votes'
    );

    _writeCheckpoint(_totalSupplyCheckpoints, _add, amount);
  }

  /**
   * @dev Snapshots the totalSupply after it has been decreased.
   */
  function _burn(address account, uint256 amount) internal virtual override {
    super._burn(account, amount);

    _writeCheckpoint(_totalSupplyCheckpoints, _subtract, amount);
  }

  /**
   * @dev Move voting power when tokens are transferred.
   *
   * Emits a {DelegateVotesChanged} event.
   */
  function _afterTokenTransfer(
    address from,
    address to,
    uint256 amount
  ) internal virtual override {
    super._afterTokenTransfer(from, to, amount);

    _moveVotingPower(delegates(from), delegates(to), amount);
  }

  /**
   * @dev Change delegation for `delegator` to `delegatee`.
   *
   * Emits events {DelegateChanged} and {DelegateVotesChanged}.
   */
  function _delegate(address delegator, address delegatee) internal virtual {
    address currentDelegate = delegates(delegator);
    uint256 delegatorBalance = balanceOf(delegator);
    _delegates[delegator] = delegatee;

    emit DelegateChanged(delegator, currentDelegate, delegatee);

    _moveVotingPower(currentDelegate, delegatee, delegatorBalance);
  }

  function _moveVotingPower(
    address src,
    address dst,
    uint256 amount
  ) private {
    if (src != dst && amount > 0) {
      if (src != address(0)) {
        (uint256 oldWeight, uint256 newWeight) = _writeCheckpoint(
          _checkpoints[src],
          _subtract,
          amount
        );
        emit DelegateVotesChanged(src, oldWeight, newWeight);
      }

      if (dst != address(0)) {
        (uint256 oldWeight, uint256 newWeight) = _writeCheckpoint(
          _checkpoints[dst],
          _add,
          amount
        );
        emit DelegateVotesChanged(dst, oldWeight, newWeight);
      }
    }
  }

  function _writeCheckpoint(
    Checkpoint[] storage ckpts,
    function(uint256, uint256) view returns (uint256) op,
    uint256 delta
  ) private returns (uint256 oldWeight, uint256 newWeight) {
    uint256 pos = ckpts.length;
    oldWeight = pos == 0 ? 0 : ckpts[pos - 1].votes;
    newWeight = op(oldWeight, delta);

    if (pos > 0 && ckpts[pos - 1].fromBlock == block.number) {
      ckpts[pos - 1].votes = SafeCast.toUint224(newWeight);
    } else {
      ckpts.push(
        Checkpoint({
          fromBlock: SafeCast.toUint32(block.number),
          votes: SafeCast.toUint224(newWeight)
        })
      );
    }
  }

  function _add(uint256 a, uint256 b) private pure returns (uint256) {
    return a + b;
  }

  function _subtract(uint256 a, uint256 b) private pure returns (uint256) {
    return a - b;
  }
}

// File apps/avai/src/contracts/Orca.sol

pragma solidity ^0.8.0;

contract ORCA is ERC20, ERC20Permit, ERC20Votes {
  constructor() ERC20('OrcaDAO', 'ORCA') ERC20Permit('OrcaDAO') {
    _mint(msg.sender, 1.5e26); // 150 million to be ever minted
  }

  // The functions below are overrides required by Solidity.
  function _afterTokenTransfer(
    address from,
    address to,
    uint256 amount
  ) internal override(ERC20, ERC20Votes) {
    super._afterTokenTransfer(from, to, amount);
  }

  function _mint(address to, uint256 amount)
    internal
    override(ERC20, ERC20Votes)
  {
    super._mint(to, amount);
  }

  function _burn(address account, uint256 amount)
    internal
    override(ERC20, ERC20Votes)
  {
    super._burn(account, amount);
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"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":"delegator","type":"address"},{"indexed":true,"internalType":"address","name":"fromDelegate","type":"address"},{"indexed":true,"internalType":"address","name":"toDelegate","type":"address"}],"name":"DelegateChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegate","type":"address"},{"indexed":false,"internalType":"uint256","name":"previousBalance","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newBalance","type":"uint256"}],"name":"DelegateVotesChanged","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":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","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":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint32","name":"pos","type":"uint32"}],"name":"checkpoints","outputs":[{"components":[{"internalType":"uint32","name":"fromBlock","type":"uint32"},{"internalType":"uint224","name":"votes","type":"uint224"}],"internalType":"struct ERC20Votes.Checkpoint","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"delegatee","type":"address"}],"name":"delegate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"delegatee","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"delegateBySig","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"delegates","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"blockNumber","type":"uint256"}],"name":"getPastTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"blockNumber","type":"uint256"}],"name":"getPastVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"numCheckpoints","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"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":[],"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":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]

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

50722:721:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6284:94;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8388:182;;;;;;:::i;:::-;;:::i;:::-;;;4046:14:1;;4039:22;4021:41;;4009:2;3994:18;8388:182:0;3976:92:1;7340:102:0;7424:12;;7340:102;;;4219:25:1;;;4207:2;4192:18;7340:102:0;4174:76:1;9024:467:0;;;;;;:::i;:::-;;:::i;7196:87::-;;;7275:2;15391:36:1;;15379:2;15364:18;7196:87:0;15346::1;31734:109:0;;;:::i;9874:251::-;;;;;;:::i;:::-;;:::i;44367:259::-;;;;;;:::i;:::-;;:::i;43807:113::-;;;;;;:::i;:::-;-1:-1:-1;;;;;43895:19:0;;;43872:7;43895:19;;;:10;:19;;;;;;;;43807:113;;;;-1:-1:-1;;;;;3814:55:1;;;3796:74;;3784:2;3769:18;43807:113:0;3751:125:1;46686:106:0;;;;;;:::i;:::-;;:::i;:::-;;43554:168;;;;;;:::i;:::-;;:::i;:::-;;;15226:10:1;15214:23;;;15196:42;;15184:2;15169:18;43554:168:0;15151:93:1;7497:149:0;;;;;;:::i;:::-;-1:-1:-1;;;;;7622:18:0;7596:7;7622:18;;;;;;;;;;;;7497:149;31464:150;;;;;;:::i;:::-;;:::i;44897:250::-;;;;;;:::i;:::-;;:::i;6487:98::-;;;:::i;43996:185::-;;;;;;:::i;:::-;;:::i;10598:424::-;;;;;;:::i;:::-;;:::i;7841:188::-;;;;;;:::i;:::-;;:::i;46866:535::-;;;;;;:::i;:::-;;:::i;30740:666::-;;;;;;:::i;:::-;;:::i;8084:173::-;;;;;;:::i;:::-;-1:-1:-1;;;;;8224:18:0;;;8198:7;8224:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;8084:173;43315:167;;;;;;:::i;:::-;;:::i;:::-;;;;14451:13:1;;14466:10;14447:30;14429:49;;14538:4;14526:17;;;14520:24;-1:-1:-1;;;;;14516:89:1;14494:20;;;14487:119;;;;14402:18;43315:167:0;14384:228:1;6284:94:0;6338:13;6367:5;6360:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6284:94;:::o;8388:182::-;8491:4;8507:39;4150:10;8530:7;8539:6;8507:8;:39::i;:::-;-1:-1:-1;8560:4:0;8388:182;;;;:::o;9024:467::-;9150:4;9163:36;9173:6;9181:9;9192:6;9163:9;:36::i;:::-;-1:-1:-1;;;;;9235:19:0;;9208:24;9235:19;;;:11;:19;;;;;;;;4150:10;9235:33;;;;;;;;9291:26;;;;9275:100;;;;-1:-1:-1;;;9275:100:0;;11211:2:1;9275:100:0;;;11193:21:1;11250:2;11230:18;;;11223:30;11289:34;11269:18;;;11262:62;11360:10;11340:18;;;11333:38;11388:19;;9275:100:0;;;;;;;;;9401:57;9410:6;4150:10;9451:6;9432:16;:25;9401:8;:57::i;:::-;-1:-1:-1;9481:4:0;;9024:467;-1:-1:-1;;;;9024:467:0:o;31734:109::-;31794:7;31817:20;:18;:20::i;:::-;31810:27;;31734:109;:::o;9874:251::-;4150:10;9977:4;10047:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;10047:34:0;;;;;;;;;;9977:4;;9993:108;;10031:7;;10047:47;;10084:10;;10047:47;:::i;:::-;9993:8;:108::i;44367:259::-;44463:7;44504:12;44490:11;:26;44482:70;;;;-1:-1:-1;;;44482:70:0;;7806:2:1;44482:70:0;;;7788:21:1;7845:2;7825:18;;;7818:30;7884:33;7864:18;;;7857:61;7935:18;;44482:70:0;7778:181:1;44482:70:0;-1:-1:-1;;;;;44585:21:0;;;;;;:12;:21;;;;;44566:54;;44608:11;44566:18;:54::i;:::-;44559:61;44367:259;-1:-1:-1;;;44367:259:0:o;46686:106::-;46752:34;4150:10;46776:9;46752;:34::i;:::-;46686:106;:::o;43554:168::-;-1:-1:-1;;;;;43687:21:0;;43644:6;43687:21;;;:12;:21;;;;;:28;43669:47;;:17;:47::i;:::-;43662:54;43554:168;-1:-1:-1;;43554:168:0:o;31464:150::-;-1:-1:-1;;;;;31584:14:0;;31558:7;31584:14;;;:7;:14;;;;;28937;31584:24;28849:108;44897:250;44982:7;45023:12;45009:11;:26;45001:70;;;;-1:-1:-1;;;45001:70:0;;7806:2:1;45001:70:0;;;7788:21:1;7845:2;7825:18;;;7818:30;7884:33;7864:18;;;7857:61;7935:18;;45001:70:0;7778:181:1;45001:70:0;45085:56;45104:23;45129:11;45085:18;:56::i;6487:98::-;6543:13;6572:7;6565:14;;;;;:::i;43996:185::-;-1:-1:-1;;;;;44082:21:0;;44052:7;44082:21;;;:12;:21;;;;;:28;44124:8;;:51;;-1:-1:-1;;;;;44139:21:0;;;;;;:12;:21;;;;;44161:7;44167:1;44161:3;:7;:::i;:::-;44139:30;;;;;;-1:-1:-1;;;44139:30:0;;;;;;;;;;;;;;;;;;:36;;;;-1:-1:-1;;;;;44139:36:0;44124:51;;;44135:1;44124:51;-1:-1:-1;;;;;44117:58:0;;43996:185;-1:-1:-1;;;43996:185:0:o;10598:424::-;4150:10;10706:4;10749:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;10749:34:0;;;;;;;;;;10806:35;;;;10790:106;;;;-1:-1:-1;;;10790:106:0;;13663:2:1;10790:106:0;;;13645:21:1;13702:2;13682:18;;;13675:30;13741:34;13721:18;;;13714:62;13812:7;13792:18;;;13785:35;13837:19;;10790:106:0;13635:227:1;10790:106:0;10922:67;4150:10;10945:7;10973:15;10954:16;:34;10922:8;:67::i;:::-;-1:-1:-1;11012:4:0;;10598:424;-1:-1:-1;;;10598:424:0:o;7841:188::-;7947:4;7963:42;4150:10;7987:9;7998:6;7963:9;:42::i;46866:535::-;47054:6;47035:15;:25;;47027:67;;;;-1:-1:-1;;;47027:67:0;;8166:2:1;47027:67:0;;;8148:21:1;8205:2;8185:18;;;8178:30;8244:31;8224:18;;;8217:59;8293:18;;47027:67:0;8138:179:1;47027:67:0;47177:58;;;42556:71;47177:58;;;5105:25:1;-1:-1:-1;;;;;5166:55:1;;5146:18;;;5139:83;;;;5238:18;;;5231:34;;;5281:18;;;5274:34;;;47101:14:0;;47118:164;;47140:105;;5077:19:1;;47177:58:0;;;;;;;;;;;;47167:69;;;;;;47140:16;:105::i;:::-;47254:1;47264;47274;47118:13;:164::i;:::-;47101:181;;47306:17;47316:6;47306:9;:17::i;:::-;47297:5;:26;47289:64;;;;-1:-1:-1;;;47289:64:0;;8524:2:1;47289:64:0;;;8506:21:1;8563:2;8543:18;;;8536:30;8602:27;8582:18;;;8575:55;8647:18;;47289:64:0;8496:175:1;47289:64:0;47367:28;47377:6;47385:9;47367;:28::i;:::-;47360:35;46866:535;;;;;;:::o;30740:666::-;30950:8;30931:15;:27;;30923:69;;;;-1:-1:-1;;;30923:69:0;;9281:2:1;30923:69:0;;;9263:21:1;9320:2;9300:18;;;9293:30;9359:31;9339:18;;;9332:59;9408:18;;30923:69:0;9253:179:1;30923:69:0;31001:18;31061:16;31088:5;31104:7;31122:5;31138:16;31148:5;31138:9;:16::i;:::-;31040:142;;;;;;4542:25:1;;;;-1:-1:-1;;;;;4664:15:1;;;4644:18;;;4637:43;4716:15;;;;4696:18;;;4689:43;4748:18;;;4741:34;4791:19;;;4784:35;4835:19;;;4828:35;;;4514:19;;31040:142:0;;;;;;;;;;;;31022:167;;;;;;31001:188;;31198:12;31213:28;31230:10;31213:16;:28::i;:::-;31198:43;;31250:14;31267:28;31281:4;31287:1;31290;31293;31267:13;:28::i;:::-;31250:45;;31320:5;-1:-1:-1;;;;;31310:15:0;:6;-1:-1:-1;;;;;31310:15:0;;31302:58;;;;-1:-1:-1;;;31302:58:0;;10852:2:1;31302:58:0;;;10834:21:1;10891:2;10871:18;;;10864:30;10930:32;10910:18;;;10903:60;10980:18;;31302:58:0;10824:180:1;31302:58:0;31369:31;31378:5;31385:7;31394:5;31369:8;:31::i;:::-;30740:666;;;;;;;;;;:::o;43315:167::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;43450:21:0;;;;;;:12;:21;;;;;:26;;;;;;;;;;-1:-1:-1;;;43450:26:0;;;;;;;;;;;;;;;;;;43443:33;;;;;;;;;43450:26;;43443:33;;;;;;;;;-1:-1:-1;;;;;43443:33:0;;;;;;;;;43315:167;-1:-1:-1;;;43315:167:0:o;47685:297::-;47766:28;47778:7;47787:6;47766:11;:28::i;:::-;7424:12;;-1:-1:-1;;;;;;47817:29:0;47801:111;;;;-1:-1:-1;;;47801:111:0;;11620:2:1;47801:111:0;;;11602:21:1;11659:2;11639:18;;;11632:30;11698:34;11678:18;;;11671:62;11769:18;11749;;;11742:46;11805:19;;47801:111:0;11592:238:1;47801:111:0;47921:55;47938:23;47963:4;47969:6;47921:16;:55::i;:::-;;;47685:297;;:::o;12420:373::-;-1:-1:-1;;;;;12500:21:0;;12492:65;;;;-1:-1:-1;;;12492:65:0;;14069:2:1;12492:65:0;;;14051:21:1;14108:2;14088:18;;;14081:30;14147:33;14127:18;;;14120:61;14198:18;;12492:65:0;14041:181:1;12492:65:0;12640:6;12624:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;12653:18:0;;:9;:18;;;;;;;;;;:28;;12675:6;;12653:9;:28;;12675:6;;12653:28;:::i;:::-;;;;-1:-1:-1;;12693:37:0;;4219:25:1;;;-1:-1:-1;;;;;12693:37:0;;;12710:1;;12693:37;;4207:2:1;4192:18;12693:37:0;;;;;;;12739:48;12767:1;12771:7;12780:6;12739:19;:48::i;:::-;12420:373;;:::o;50449:92::-;50507:7;50530:5;50534:1;50530;:5;:::i;34482:206::-;34539:7;-1:-1:-1;;;;;34571:26:0;;;34555:99;;;;-1:-1:-1;;;34555:99:0;;12037:2:1;34555:99:0;;;12019:21:1;12076:2;12056:18;;;12049:30;12115:34;12095:18;;;12088:62;12186:9;12166:18;;;12159:37;12213:19;;34555:99:0;12009:229:1;34555:99:0;-1:-1:-1;34676:5:0;34482:206::o;36408:201::-;36464:6;36504:16;36495:25;;;36479:97;;;;-1:-1:-1;;;36479:97:0;;12851:2:1;36479:97:0;;;12833:21:1;12890:2;12870:18;;;12863:30;12929:34;12909:18;;;12902:62;13000:8;12980:18;;;12973:36;13026:19;;36479:97:0;12823:228:1;48380:238:0;-1:-1:-1;;;;;43895:19:0;;;43872:7;43895:19;;;:10;:19;;;;;;;;;;;;;;;48556:56;;43895:19;;;;;48605:6;48556:16;:56::i;:::-;48380:238;;;:::o;50547:97::-;50610:7;50633:5;50637:1;50633;:5;:::i;14059:348::-;-1:-1:-1;;;;;14177:19:0;;14169:68;;;;-1:-1:-1;;;14169:68:0;;13258:2:1;14169:68:0;;;13240:21:1;13297:2;13277:18;;;13270:30;13336:34;13316:18;;;13309:62;13407:6;13387:18;;;13380:34;13431:19;;14169:68:0;13230:226:1;14169:68:0;-1:-1:-1;;;;;14252:21:0;;14244:68;;;;-1:-1:-1;;;14244:68:0;;8878:2:1;14244:68:0;;;8860:21:1;8917:2;8897:18;;;8890:30;8956:34;8936:18;;;8929:62;9027:4;9007:18;;;9000:32;9049:19;;14244:68:0;8850:224:1;14244:68:0;-1:-1:-1;;;;;14321:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;14369:32;;4219:25:1;;;14369:32:0;;4192:18:1;14369:32:0;;;;;;;14059:348;;;:::o;11482:671::-;-1:-1:-1;;;;;11604:20:0;;11596:70;;;;-1:-1:-1;;;11596:70:0;;12445:2:1;11596:70:0;;;12427:21:1;12484:2;12464:18;;;12457:30;12523:34;12503:18;;;12496:62;12594:7;12574:18;;;12567:35;12619:19;;11596:70:0;12417:227:1;11596:70:0;-1:-1:-1;;;;;11681:23:0;;11673:71;;;;-1:-1:-1;;;11673:71:0;;7402:2:1;11673:71:0;;;7384:21:1;7441:2;7421:18;;;7414:30;7480:34;7460:18;;;7453:62;7551:5;7531:18;;;7524:33;7574:19;;11673:71:0;7374:225:1;11673:71:0;-1:-1:-1;;;;;11833:17:0;;11809:21;11833:17;;;;;;;;;;;11865:23;;;;11857:74;;;;-1:-1:-1;;;11857:74:0;;9639:2:1;11857:74:0;;;9621:21:1;9678:2;9658:18;;;9651:30;9717:34;9697:18;;;9690:62;9788:8;9768:18;;;9761:36;9814:19;;11857:74:0;9611:228:1;11857:74:0;-1:-1:-1;;;;;11957:17:0;;;:9;:17;;;;;;;;;;;11977:22;;;11957:42;;12013:20;;;;;;;;:30;;11993:6;;11957:9;12013:30;;11993:6;;12013:30;:::i;:::-;;;;;;;;12074:9;-1:-1:-1;;;;;12057:35:0;12066:6;-1:-1:-1;;;;;12057:35:0;;12085:6;12057:35;;;;4219:25:1;;4207:2;4192:18;;4174:76;12057:35:0;;;;;;;;12101:46;12121:6;12129:9;12140:6;12101:19;:46::i;26656:255::-;26709:7;26746:16;26729:13;:33;26725:181;;;-1:-1:-1;26780:24:0;;26656:255::o;26725:181::-;-1:-1:-1;27097:139:0;;;26856:10;27097:139;;;;5578:25:1;;;;26868:12:0;5619:18:1;;;5612:34;26882:15:0;5662:18:1;;;5655:34;27186:13:0;5705:18:1;;;5698:34;27220:4:0;5748:19:1;;;;5741:84;;;;27097:139:0;;;;;;;;;;5550:19:1;;;;27097:139:0;;;27077:168;;;;;;31734:109::o;45228:1380::-;46317:12;;45342:7;;;46358:192;46371:4;46365:3;:10;46358:192;;;46386:11;46400:23;46413:3;46418:4;46400:12;:23::i;:::-;46386:37;;46459:11;46436:5;46442:3;46436:10;;;;;;-1:-1:-1;;;46436:10:0;;;;;;;;;;;;;;;;;;:20;;;:34;46432:111;;;46490:3;46483:10;;46432:111;;;46526:7;:3;46532:1;46526:7;:::i;:::-;46520:13;;46432:111;46358:192;;;;46565:9;;:37;;46581:5;46587:8;46594:1;46587:4;:8;:::i;:::-;46581:15;;;;;;-1:-1:-1;;;46581:15:0;;;;;;;;;;;;;;;;;;:21;;;;-1:-1:-1;;;;;46581:21:0;46565:37;;;46577:1;46565:37;-1:-1:-1;;;;;46558:44:0;;45228:1380;-1:-1:-1;;;;;45228:1380:0:o;48770:366::-;-1:-1:-1;;;;;43895:19:0;;;48851:23;43895:19;;;:10;:19;;;;;;;;;;7622:18;;;;;;;48958:21;;;;:33;;;;;;;;;;;49005:54;;43895:19;;;;;7622:18;;48958:33;;43895:19;;;49005:54;;48851:23;49005:54;49068:62;49085:15;49102:9;49113:16;49068;:62::i;27861:184::-;27958:7;27984:55;28006:20;:18;:20::i;:::-;28028:10;23579:57;;3471:66:1;23579:57:0;;;3459:79:1;3554:11;;;3547:27;;;3590:12;;;3583:28;;;23543:7:0;;3627:12:1;;23579:57:0;;;;;;;;;;;;23569:68;;;;;;23562:75;;23435:208;;;;;21118:1425;21228:7;22130:66;22107:89;;;22091:157;;;;-1:-1:-1;;;22091:157:0;;10046:2:1;22091:157:0;;;10028:21:1;10085:2;10065:18;;;10058:30;10124:34;10104:18;;;10097:62;-1:-1:-1;;;10175:18:1;;;10168:32;10217:19;;22091:157:0;10018:224:1;22091:157:0;22263:1;:7;;22268:2;22263:7;:18;;;;22274:1;:7;;22279:2;22274:7;22263:18;22255:65;;;;-1:-1:-1;;;22255:65:0;;10449:2:1;22255:65:0;;;10431:21:1;10488:2;10468:18;;;10461:30;10527:34;10507:18;;;10500:62;-1:-1:-1;;;10578:18:1;;;10571:32;10620:19;;22255:65:0;10421:224:1;22255:65:0;22427:24;;;22410:14;22427:24;;;;;;;;;6063:25:1;;;6136:4;6124:17;;6104:18;;;6097:45;;;;6158:18;;;6151:34;;;6201:18;;;6194:34;;;22427:24:0;;6035:19:1;;22427:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;22427:24:0;;-1:-1:-1;;22427:24:0;;;-1:-1:-1;;;;;;;22466:20:0;;22458:57;;;;-1:-1:-1;;;22458:57:0;;7049:2:1;22458:57:0;;;7031:21:1;7088:2;7068:18;;;7061:30;7127:26;7107:18;;;7100:54;7171:18;;22458:57:0;7021:174:1;22458:57:0;22531:6;21118:1425;-1:-1:-1;;;;;21118:1425:0:o;31969:193::-;-1:-1:-1;;;;;32086:14:0;;32029:15;32086:14;;;:7;:14;;;;;28937;;29060:1;29042:19;;;;28937:14;32139:17;31969:193;;;;:::o;49799:644::-;50018:12;;49959:17;;;;50049:8;;:35;;50064:5;50070:7;50076:1;50070:3;:7;:::i;:::-;50064:14;;;;;;-1:-1:-1;;;50064:14:0;;;;;;;;;;;;;;;;;;:20;;;;-1:-1:-1;;;;;50064:20:0;50049:35;;;50060:1;50049:35;-1:-1:-1;;;;;50037:47:0;;;50103:20;50106:9;50117:5;50103:2;:20;;:::i;:::-;50091:32;;50142:1;50136:3;:7;:51;;;;-1:-1:-1;50175:12:0;50147:5;50153:7;50159:1;50153:3;:7;:::i;:::-;50147:14;;;;;;-1:-1:-1;;;50147:14:0;;;;;;;;;;;;;;;;;;:24;;;:40;50136:51;50132:306;;;50221:29;50240:9;50221:18;:29::i;:::-;50198:5;50204:7;50210:1;50204:3;:7;:::i;:::-;50198:14;;;;;;-1:-1:-1;;;50198:14:0;;;;;;;;;;;;;;;;:20;;;:52;;;;;-1:-1:-1;;;;;50198:52:0;;;;;-1:-1:-1;;;;;50198:52:0;;;;;;50132:306;;;50273:5;50294:127;;;;;;;;50329:31;50347:12;50329:17;:31::i;:::-;50294:127;;;;;;50380:29;50399:9;50380:18;:29::i;:::-;-1:-1:-1;;;;;50294:127:0;;;;;;50273:157;;;;;;;-1:-1:-1;50273:157:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50132:306;49799:644;;;;;;;:::o;50976:184::-;51111:43;51137:4;51143:2;51147:6;51111:25;:43::i;49142:651::-;49256:3;-1:-1:-1;;;;;49249:10:0;:3;-1:-1:-1;;;;;49249:10:0;;;:24;;;;;49272:1;49263:6;:10;49249:24;49245:543;;;-1:-1:-1;;;;;49288:17:0;;;49284:246;;-1:-1:-1;;;;;49388:17:0;;49319;49388;;;:12;:17;;;;;49319;;49359:98;;49418:9;49440:6;49359:16;:98::i;:::-;49318:139;;;;49494:3;-1:-1:-1;;;;;49473:47:0;;49499:9;49510;49473:47;;;;;;14973:25:1;;;15029:2;15014:18;;15007:34;14961:2;14946:18;;14928:119;49473:47:0;;;;;;;;49284:246;;;-1:-1:-1;;;;;49544:17:0;;;49540:241;;-1:-1:-1;;;;;49644:17:0;;49575;49644;;;:12;:17;;;;;49575;;49615:93;;49674:4;49691:6;49615:16;:93::i;:::-;49574:134;;;;49745:3;-1:-1:-1;;;;;49724:47:0;;49750:9;49761;49724:47;;;;;;14973:25:1;;;15029:2;15014:18;;15007:34;14961:2;14946:18;;14928:119;49724:47:0;;;;;;;;49540:241;;49142:651;;;:::o;32792:188::-;32854:7;32972:1;32962:5;32972:1;32962;:5;:::i;:::-;32952;32956:1;32952;:5;:::i;:::-;32951:17;;;;:::i;:::-;32950:23;;;;:::i;:::-;32940:5;32944:1;32940;:5;:::i;:::-;32930;32934:1;32930;:5;:::i;:::-;32929:17;;;;:::i;:::-;:45;;;;:::i;14:196:1:-;82:20;;-1:-1:-1;;;;;131:54:1;;121:65;;111:2;;200:1;197;190:12;111:2;63:147;;;:::o;215:156::-;281:20;;341:4;330:16;;320:27;;310:2;;361:1;358;351:12;376:196;435:6;488:2;476:9;467:7;463:23;459:32;456:2;;;509:6;501;494:22;456:2;537:29;556:9;537:29;:::i;577:270::-;645:6;653;706:2;694:9;685:7;681:23;677:32;674:2;;;727:6;719;712:22;674:2;755:29;774:9;755:29;:::i;:::-;745:39;;803:38;837:2;826:9;822:18;803:38;:::i;:::-;793:48;;664:183;;;;;:::o;852:338::-;929:6;937;945;998:2;986:9;977:7;973:23;969:32;966:2;;;1019:6;1011;1004:22;966:2;1047:29;1066:9;1047:29;:::i;:::-;1037:39;;1095:38;1129:2;1118:9;1114:18;1095:38;:::i;:::-;1085:48;;1180:2;1169:9;1165:18;1152:32;1142:42;;956:234;;;;;:::o;1195:616::-;1306:6;1314;1322;1330;1338;1346;1354;1407:3;1395:9;1386:7;1382:23;1378:33;1375:2;;;1429:6;1421;1414:22;1375:2;1457:29;1476:9;1457:29;:::i;:::-;1447:39;;1505:38;1539:2;1528:9;1524:18;1505:38;:::i;:::-;1495:48;;1590:2;1579:9;1575:18;1562:32;1552:42;;1641:2;1630:9;1626:18;1613:32;1603:42;;1664:37;1696:3;1685:9;1681:19;1664:37;:::i;:::-;1654:47;;1748:3;1737:9;1733:19;1720:33;1710:43;;1800:3;1789:9;1785:19;1772:33;1762:43;;1365:446;;;;;;;;;;:::o;1816:264::-;1884:6;1892;1945:2;1933:9;1924:7;1920:23;1916:32;1913:2;;;1966:6;1958;1951:22;1913:2;1994:29;2013:9;1994:29;:::i;:::-;1984:39;2070:2;2055:18;;;;2042:32;;-1:-1:-1;;;1903:177:1:o;2085:541::-;2187:6;2195;2203;2211;2219;2227;2280:3;2268:9;2259:7;2255:23;2251:33;2248:2;;;2302:6;2294;2287:22;2248:2;2330:29;2349:9;2330:29;:::i;:::-;2320:39;;2406:2;2395:9;2391:18;2378:32;2368:42;;2457:2;2446:9;2442:18;2429:32;2419:42;;2480:36;2512:2;2501:9;2497:18;2480:36;:::i;:::-;2470:46;;2563:3;2552:9;2548:19;2535:33;2525:43;;2615:3;2604:9;2600:19;2587:33;2577:43;;2238:388;;;;;;;;:::o;2631:370::-;2698:6;2706;2759:2;2747:9;2738:7;2734:23;2730:32;2727:2;;;2780:6;2772;2765:22;2727:2;2808:29;2827:9;2808:29;:::i;:::-;2798:39;;2887:2;2876:9;2872:18;2859:32;2931:10;2924:5;2920:22;2913:5;2910:33;2900:2;;2962:6;2954;2947:22;2900:2;2990:5;2980:15;;;2717:284;;;;;:::o;3006:190::-;3065:6;3118:2;3106:9;3097:7;3093:23;3089:32;3086:2;;;3139:6;3131;3124:22;3086:2;-1:-1:-1;3167:23:1;;3076:120;-1:-1:-1;3076:120:1:o;6239:603::-;6351:4;6380:2;6409;6398:9;6391:21;6441:6;6435:13;6484:6;6479:2;6468:9;6464:18;6457:34;6509:4;6522:140;6536:6;6533:1;6530:13;6522:140;;;6631:14;;;6627:23;;6621:30;6597:17;;;6616:2;6593:26;6586:66;6551:10;;6522:140;;;6680:6;6677:1;6674:13;6671:2;;;6750:4;6745:2;6736:6;6725:9;6721:22;6717:31;6710:45;6671:2;-1:-1:-1;6826:2:1;6805:15;-1:-1:-1;;6801:29:1;6786:45;;;;6833:2;6782:54;;6360:482;-1:-1:-1;;;6360:482:1:o;15438:128::-;15478:3;15509:1;15505:6;15502:1;15499:13;15496:2;;;15515:18;;:::i;:::-;-1:-1:-1;15551:9:1;;15486:80::o;15571:120::-;15611:1;15637;15627:2;;15642:18;;:::i;:::-;-1:-1:-1;15676:9:1;;15617:74::o;15696:125::-;15736:4;15764:1;15761;15758:8;15755:2;;;15769:18;;:::i;:::-;-1:-1:-1;15806:9:1;;15745:76::o;15826:437::-;15905:1;15901:12;;;;15948;;;15969:2;;16023:4;16015:6;16011:17;16001:27;;15969:2;16076;16068:6;16065:14;16045:18;16042:38;16039:2;;;-1:-1:-1;;;16110:1:1;16103:88;16214:4;16211:1;16204:15;16242:4;16239:1;16232:15;16268:112;16300:1;16326;16316:2;;16331:18;;:::i;:::-;-1:-1:-1;16365:9:1;;16306:74::o;16385:184::-;-1:-1:-1;;;16434:1:1;16427:88;16534:4;16531:1;16524:15;16558:4;16555:1;16548:15;16574:184;-1:-1:-1;;;16623:1:1;16616:88;16723:4;16720:1;16713:15;16747:4;16744:1;16737:15

ipfs://5b6b56bb0128cf73bd20bab0ecb6962547bc2b7763b3f709a9edb036b92c67e7