Contract 0xe3e43888fa7803cdc7bea478ab327cf1a0dc11a7 2

/**
 *Submitted for verification at moonbeam.moonscan.io on 2022-01-20
*/

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

// File contracts/flare/FlareToken.sol

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

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

/**
 * @dev Collection of functions related to the address type
 */
library Address {
/**
 * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.

uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}

/**
 * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");

(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}

/**
 * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}

/**
 * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}

/**
 * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}

/**
 * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");

(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}

/**
 * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}

/**
 * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");

(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}

/**
 * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}

/**
 * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");

(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}

/**
 * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly

assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}



/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
using Address for address;

function safeTransfer(
IERC20 token,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}

function safeTransferFrom(
IERC20 token,
address from,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}

/**
 * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
function safeApprove(
IERC20 token,
address spender,
uint256 value
) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}

function safeIncreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}

function safeDecreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}

/**
 * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
// the target address contains contract code and also asserts for success in the low-level call.

bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}


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



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



/**
 * @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 Contracts guidelines: functions revert
 * instead 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 {}
}



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



/**
 * @dev String operations.
 */
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

/**
 * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
// https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}

/**
 * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}

/**
 * @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] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}



/**
 * @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 {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV
}

function _throwError(RecoverError error) private pure {
if (error == RecoverError.NoError) {
return; // no error: do nothing
} else if (error == RecoverError.InvalidSignature) {
revert("ECDSA: invalid signature");
} else if (error == RecoverError.InvalidSignatureLength) {
revert("ECDSA: invalid signature length");
} else if (error == RecoverError.InvalidSignatureS) {
revert("ECDSA: invalid signature 's' value");
} else if (error == RecoverError.InvalidSignatureV) {
revert("ECDSA: invalid signature 'v' value");
}
}

/**
 * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. 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]
     *
     * _Available since v4.3._
     */
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
// 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 tryRecover(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 tryRecover(hash, r, vs);
} else {
return (address(0), RecoverError.InvalidSignatureLength);
}
}

/**
 * @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.
     */
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, signature);
_throwError(error);
return recovered;
}

/**
 * @dev Overload of {ECDSA-tryRecover} 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.3._
     */
function tryRecover(
bytes32 hash,
bytes32 r,
bytes32 vs
) internal pure returns (address, RecoverError) {
bytes32 s;
uint8 v;
assembly {
s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
v := add(shr(255, vs), 27)
}
return tryRecover(hash, v, r, s);
}

/**
 * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
function recover(
bytes32 hash,
bytes32 r,
bytes32 vs
) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, r, vs);
_throwError(error);
return recovered;
}

/**
 * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
function tryRecover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address, RecoverError) {
// 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 (301): 0 < s < secp256k1n ∟%V% 2 + 1, and for v in (302): 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.
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS);
}
if (v != 27 && v != 28) {
return (address(0), RecoverError.InvalidSignatureV);
}

// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature);
}

return (signer, RecoverError.NoError);
}

/**
 * @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) {
(address recovered, RecoverError error) = tryRecover(hash, v, r, s);
_throwError(error);
return recovered;
}

/**
 * @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 Message, created from `s`. 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(bytes memory s) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
}

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



/**
 * @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;
address private immutable _CACHED_THIS;

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);
_CACHED_THIS = address(this);
_TYPE_HASH = typeHash;
}

/**
 * @dev Returns the domain separator for the current chain.
     */
function _domainSeparatorV4() internal view returns (bytes32) {
if (address(this) == _CACHED_THIS && 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);
}
}



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






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


/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
/**
 * @dev Emitted when the pause is triggered by `account`.
     */
event Paused(address account);

/**
 * @dev Emitted when the pause is lifted by `account`.
     */
event Unpaused(address account);

bool private _paused;

/**
 * @dev Initializes the contract in unpaused state.
     */
constructor() {
_paused = false;
}

/**
 * @dev Returns true if the contract is paused, and false otherwise.
     */
function paused() public view virtual returns (bool) {
return _paused;
}

/**
 * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
modifier whenNotPaused() {
require(!paused(), "Pausable: paused");
_;
}

/**
 * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
modifier whenPaused() {
require(paused(), "Pausable: not paused");
_;
}

/**
 * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}

/**
 * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}



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



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



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






/**
 * @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, _msgSender());
_;
}

/**
 * @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 override returns (bool) {
return _roles[role].members[account];
}

/**
 * @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 {
if (!hasRole(role, account)) {
revert(
string(
abi.encodePacked(
"AccessControl: account ",
Strings.toHexString(uint160(account), 20),
" 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 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.
     */
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.
     */
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`.
     */
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.
     *
     * [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.
     */
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.
     */
function _revokeRole(bytes32 role, address account) internal virtual {
if (hasRole(role, account)) {
_roles[role].members[account] = false;
emit RoleRevoked(role, account, _msgSender());
}
}
}



// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
/**
 * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}

/**
 * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}

/**
 * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}

/**
 * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}

/**
 * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}

/**
 * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}

/**
 * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}

/**
 * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}

/**
 * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}

/**
 * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}

/**
 * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}

/**
 * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}

/**
 * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}


contract FlareToken is ERC20, ERC20Permit, Pausable, AccessControl {
using SafeERC20 for IERC20;

bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant RESCUER_ROLE = keccak256("RESCUER_ROLE");

uint256 private _maxSupply = 400000000 * 10**decimals(); // 400,000,000 is the max supply

event TokensRescued(
address indexed sender,
address indexed token,
uint256 value
);

constructor() ERC20("Flare Token", "FLARE") ERC20Permit("Flare Token") {
_setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
_setupRole(PAUSER_ROLE, _msgSender());
_setupRole(MINTER_ROLE, _msgSender());
_setupRole(RESCUER_ROLE, _msgSender());
}

/**
 * @dev Returns the maximum amount of tokens that can be minted.
     */
function maxSupply() public view returns (uint256) {
return _maxSupply;
}

function pause() public onlyRole(PAUSER_ROLE) {
_pause();
}

function unpause() public onlyRole(PAUSER_ROLE) {
_unpause();
}

function mint(address to, uint256 amount) public onlyRole(MINTER_ROLE) {
require(
totalSupply() + amount <= _maxSupply,
"ERC20: cannot mint more tokens, cap exceeded"
);
_mint(to, amount);
}

function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal override whenNotPaused {
super._beforeTokenTransfer(from, to, amount);
}

function rescueTokens(IERC20 token, uint256 value)
external
onlyRole(RESCUER_ROLE)
{
token.transfer(_msgSender(), value);

emit TokensRescued(_msgSender(), address(token), value);
}
}

[{"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":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","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":"sender","type":"address"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TokensRescued","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"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"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":"MINTER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PAUSER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"RESCUER_ROLE","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":[],"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":"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":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","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":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"rescueTokens","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":"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":"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"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"}]

6101606040527f6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c961014052620000386012600a620003f9565b62000048906317d78400620004c5565b6008553480156200005857600080fd5b506040518060400160405280600b81526020016a233630b932902a37b5b2b760a91b81525080604051806040016040528060018152602001603160f81b8152506040518060400160405280600b81526020016a233630b932902a37b5b2b760a91b81525060405180604001604052806005815260200164464c41524560d81b8152508160039080519060200190620000f29291906200030a565b508051620001089060049060208401906200030a565b5050825160208085019190912083518483012060e08290526101008190524660a0818152604080517f8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f81880181905281830187905260608201869052608082019490945230818401528151808203909301835260c0019052805194019390932091935091906080523060601b60c0526101205250506006805460ff1916905550620001b99150600090503362000243565b620001e57f65d7a28e3265b37a6474929f336521b332c1681b933f6cb9f3376673440d862a3362000243565b620002117f9f2df0fed2c77648de5860a4cc508cd0818c85b8b8a1ab4ceeef8d981c8956a63362000243565b6200023d7fcf6f9f892731e14b8859835f2ff35575f447fb501f46243c4eb8bac19e31a0503362000243565b6200053a565b6200024f828262000253565b5050565b6200025f8282620002dd565b6200024f5760008281526007602090815260408083206001600160a01b03851684529091529020805460ff19166001179055620002993390565b6001600160a01b0316816001600160a01b0316837f2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d60405160405180910390a45050565b60008281526007602090815260408083206001600160a01b038516845290915290205460ff165b92915050565b8280546200031890620004e7565b90600052602060002090601f0160209004810192826200033c576000855562000387565b82601f106200035757805160ff191683800117855562000387565b8280016001018555821562000387579182015b82811115620003875782518255916020019190600101906200036a565b506200039592915062000399565b5090565b5b808211156200039557600081556001016200039a565b600181815b80851115620003f1578160001904821115620003d557620003d562000524565b80851615620003e357918102915b93841c9390800290620003b5565b509250929050565b60006200040a60ff84168362000411565b9392505050565b600082620004225750600162000304565b81620004315750600062000304565b81600181146200044a5760028114620004555762000475565b600191505062000304565b60ff84111562000469576200046962000524565b50506001821b62000304565b5060208310610133831016604e8410600b84101617156200049a575081810a62000304565b620004a68383620003b0565b8060001904821115620004bd57620004bd62000524565b029392505050565b6000816000190483118215151615620004e257620004e262000524565b500290565b600181811c90821680620004fc57607f821691505b602082108114156200051e57634e487b7160e01b600052602260045260246000fd5b50919050565b634e487b7160e01b600052601160045260246000fd5b60805160a05160c05160601c60e051610100516101205161014051612443620005986000396000610c2b0152600061146a015260006114b901526000611494015260006113ed015260006114170152600061144101526124436000f3fe608060405234801561001057600080fd5b50600436106101da5760003560e01c806370a0823111610104578063a457c2d7116100a2578063d547741f11610071578063d547741f14610430578063d5abeb0114610443578063dd62ed3e1461044b578063e63ab1e91461049157600080fd5b8063a457c2d7146103d0578063a9059cbb146103e3578063d505accf146103f6578063d53913931461040957600080fd5b80638456cb59116100de5780638456cb591461037257806391d148541461037a57806395d89b41146103c0578063a217fddf146103c857600080fd5b806370a082311461030257806371372544146103385780637ecebe001461035f57600080fd5b8063313ce5671161017c5780633f4ba83a1161014b5780633f4ba83a146102c957806340c10f19146102d157806357376198146102e45780635c975abb146102f757600080fd5b8063313ce5671461028c5780633644e5151461029b57806336568abe146102a357806339509351146102b657600080fd5b806318160ddd116101b857806318160ddd1461022f57806323b872dd14610241578063248a9ca3146102545780632f2ff15d1461027757600080fd5b806301ffc9a7146101df57806306fdde0314610207578063095ea7b31461021c575b600080fd5b6101f26101ed366004612117565b6104b8565b60405190151581526020015b60405180910390f35b61020f610551565b6040516101fe91906121da565b6101f261022a36600461208b565b6105e3565b6002545b6040519081526020016101fe565b6101f261024f366004611fd3565b6105f9565b6102336102623660046120d9565b60009081526007602052604090206001015490565b61028a6102853660046120f2565b6106e4565b005b604051601281526020016101fe565b61023361070f565b61028a6102b13660046120f2565b61071e565b6101f26102c436600461208b565b6107d1565b61028a61081a565b61028a6102df36600461208b565b610850565b61028a6102f236600461208b565b61092a565b60065460ff166101f2565b610233610310366004611f7d565b73ffffffffffffffffffffffffffffffffffffffff1660009081526020819052604090205490565b6102337fcf6f9f892731e14b8859835f2ff35575f447fb501f46243c4eb8bac19e31a05081565b61023361036d366004611f7d565b610a6b565b61028a610a96565b6101f26103883660046120f2565b600091825260076020908152604080842073ffffffffffffffffffffffffffffffffffffffff93909316845291905290205460ff1690565b61020f610ac9565b610233600081565b6101f26103de36600461208b565b610ad8565b6101f26103f136600461208b565b610bb0565b61028a610404366004612014565b610bbd565b6102337f9f2df0fed2c77648de5860a4cc508cd0818c85b8b8a1ab4ceeef8d981c8956a681565b61028a61043e3660046120f2565b610d7c565b600854610233565b610233610459366004611f9a565b73ffffffffffffffffffffffffffffffffffffffff918216600090815260016020908152604080832093909416825291909152205490565b6102337f65d7a28e3265b37a6474929f336521b332c1681b933f6cb9f3376673440d862a81565b60007fffffffff0000000000000000000000000000000000000000000000000000000082167f7965db0b00000000000000000000000000000000000000000000000000000000148061054b57507f01ffc9a7000000000000000000000000000000000000000000000000000000007fffffffff000000000000000000000000000000000000000000000000000000008316145b92915050565b606060038054610560906122e1565b80601f016020809104026020016040519081016040528092919081815260200182805461058c906122e1565b80156105d95780601f106105ae576101008083540402835291602001916105d9565b820191906000526020600020905b8154815290600101906020018083116105bc57829003601f168201915b5050505050905090565b60006105f0338484610da2565b50600192915050565b6000610606848484610f4d565b73ffffffffffffffffffffffffffffffffffffffff84166000908152600160209081526040808320338452909152902054828110156106cc576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602860248201527f45524332303a207472616e7366657220616d6f756e742065786365656473206160448201527f6c6c6f77616e636500000000000000000000000000000000000000000000000060648201526084015b60405180910390fd5b6106d98533858403610da2565b506001949350505050565b600082815260076020526040902060010154610700813361120d565b61070a83836112df565b505050565b60006107196113d3565b905090565b73ffffffffffffffffffffffffffffffffffffffff811633146107c3576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602f60248201527f416363657373436f6e74726f6c3a2063616e206f6e6c792072656e6f756e636560448201527f20726f6c657320666f722073656c66000000000000000000000000000000000060648201526084016106c3565b6107cd8282611507565b5050565b33600081815260016020908152604080832073ffffffffffffffffffffffffffffffffffffffff8716845290915281205490916105f091859061081590869061222b565b610da2565b7f65d7a28e3265b37a6474929f336521b332c1681b933f6cb9f3376673440d862a610845813361120d565b61084d6115c2565b50565b7f9f2df0fed2c77648de5860a4cc508cd0818c85b8b8a1ab4ceeef8d981c8956a661087b813361120d565b6008548261088860025490565b610892919061222b565b1115610920576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602c60248201527f45524332303a2063616e6e6f74206d696e74206d6f726520746f6b656e732c2060448201527f636170206578636565646564000000000000000000000000000000000000000060648201526084016106c3565b61070a83836116a3565b7fcf6f9f892731e14b8859835f2ff35575f447fb501f46243c4eb8bac19e31a050610955813361120d565b73ffffffffffffffffffffffffffffffffffffffff831663a9059cbb336040517fffffffff0000000000000000000000000000000000000000000000000000000060e084901b16815273ffffffffffffffffffffffffffffffffffffffff909116600482015260248101859052604401602060405180830381600087803b1580156109df57600080fd5b505af11580156109f3573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610a1791906120b7565b5060405182815273ffffffffffffffffffffffffffffffffffffffff84169033907f77023e19c7343ad491fd706c36335ca0e738340a91f29b1fd81e2673d44896c4906020015b60405180910390a3505050565b73ffffffffffffffffffffffffffffffffffffffff811660009081526005602052604081205461054b565b7f65d7a28e3265b37a6474929f336521b332c1681b933f6cb9f3376673440d862a610ac1813361120d565b61084d6117cf565b606060048054610560906122e1565b33600090815260016020908152604080832073ffffffffffffffffffffffffffffffffffffffff8616845290915281205482811015610b99576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602560248201527f45524332303a2064656372656173656420616c6c6f77616e63652062656c6f7760448201527f207a65726f00000000000000000000000000000000000000000000000000000060648201526084016106c3565b610ba63385858403610da2565b5060019392505050565b60006105f0338484610f4d565b83421115610c27576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f45524332305065726d69743a206578706972656420646561646c696e6500000060448201526064016106c3565b60007f0000000000000000000000000000000000000000000000000000000000000000888888610c568c61188f565b60408051602081019690965273ffffffffffffffffffffffffffffffffffffffff94851690860152929091166060840152608083015260a082015260c0810186905260e0016040516020818303038152906040528051906020012090506000610cbe826118c4565b90506000610cce8287878761192d565b90508973ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614610d65576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601e60248201527f45524332305065726d69743a20696e76616c6964207369676e6174757265000060448201526064016106c3565b610d708a8a8a610da2565b50505050505050505050565b600082815260076020526040902060010154610d98813361120d565b61070a8383611507565b73ffffffffffffffffffffffffffffffffffffffff8316610e44576040517f08c379a0000000000000000000000000000000000000000000000000000000008152602060048201526024808201527f45524332303a20617070726f76652066726f6d20746865207a65726f2061646460448201527f726573730000000000000000000000000000000000000000000000000000000060648201526084016106c3565b73ffffffffffffffffffffffffffffffffffffffff8216610ee7576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602260248201527f45524332303a20617070726f766520746f20746865207a65726f20616464726560448201527f737300000000000000000000000000000000000000000000000000000000000060648201526084016106c3565b73ffffffffffffffffffffffffffffffffffffffff83811660008181526001602090815260408083209487168084529482529182902085905590518481527f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9259101610a5e565b73ffffffffffffffffffffffffffffffffffffffff8316610ff0576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602560248201527f45524332303a207472616e736665722066726f6d20746865207a65726f20616460448201527f647265737300000000000000000000000000000000000000000000000000000060648201526084016106c3565b73ffffffffffffffffffffffffffffffffffffffff8216611093576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602360248201527f45524332303a207472616e7366657220746f20746865207a65726f206164647260448201527f657373000000000000000000000000000000000000000000000000000000000060648201526084016106c3565b61109e838383611955565b73ffffffffffffffffffffffffffffffffffffffff831660009081526020819052604090205481811015611154576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f45524332303a207472616e7366657220616d6f756e742065786365656473206260448201527f616c616e6365000000000000000000000000000000000000000000000000000060648201526084016106c3565b73ffffffffffffffffffffffffffffffffffffffff80851660009081526020819052604080822085850390559185168152908120805484929061119890849061222b565b925050819055508273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef846040516111fe91815260200190565b60405180910390a35b50505050565b600082815260076020908152604080832073ffffffffffffffffffffffffffffffffffffffff8516845290915290205460ff166107cd576112658173ffffffffffffffffffffffffffffffffffffffff1660146119c2565b6112708360206119c2565b604051602001611281929190612159565b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0818403018152908290527f08c379a00000000000000000000000000000000000000000000000000000000082526106c3916004016121da565b600082815260076020908152604080832073ffffffffffffffffffffffffffffffffffffffff8516845290915290205460ff166107cd57600082815260076020908152604080832073ffffffffffffffffffffffffffffffffffffffff85168452909152902080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff001660011790556113753390565b73ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16837f2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d60405160405180910390a45050565b60003073ffffffffffffffffffffffffffffffffffffffff7f00000000000000000000000000000000000000000000000000000000000000001614801561143957507f000000000000000000000000000000000000000000000000000000000000000046145b1561146357507f000000000000000000000000000000000000000000000000000000000000000090565b50604080517f00000000000000000000000000000000000000000000000000000000000000006020808301919091527f0000000000000000000000000000000000000000000000000000000000000000828401527f000000000000000000000000000000000000000000000000000000000000000060608301524660808301523060a0808401919091528351808403909101815260c0909201909252805191012090565b600082815260076020908152604080832073ffffffffffffffffffffffffffffffffffffffff8516845290915290205460ff16156107cd57600082815260076020908152604080832073ffffffffffffffffffffffffffffffffffffffff8516808552925280832080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0016905551339285917ff6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b9190a45050565b60065460ff1661162e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601460248201527f5061757361626c653a206e6f742070617573656400000000000000000000000060448201526064016106c3565b600680547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff001690557f5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa335b60405173ffffffffffffffffffffffffffffffffffffffff909116815260200160405180910390a1565b73ffffffffffffffffffffffffffffffffffffffff8216611720576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601f60248201527f45524332303a206d696e7420746f20746865207a65726f20616464726573730060448201526064016106c3565b61172c60008383611955565b806002600082825461173e919061222b565b909155505073ffffffffffffffffffffffffffffffffffffffff82166000908152602081905260408120805483929061177890849061222b565b909155505060405181815273ffffffffffffffffffffffffffffffffffffffff8316906000907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef9060200160405180910390a35050565b60065460ff161561183c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601060248201527f5061757361626c653a207061757365640000000000000000000000000000000060448201526064016106c3565b600680547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff001660011790557f62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a2586116793390565b73ffffffffffffffffffffffffffffffffffffffff811660009081526005602052604090208054600181018255905b50919050565b600061054b6118d16113d3565b836040517f19010000000000000000000000000000000000000000000000000000000000006020820152602281018390526042810182905260009060620160405160208183030381529060405280519060200120905092915050565b600080600061193e87878787611c0c565b9150915061194b81611d24565b5095945050505050565b60065460ff161561070a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601060248201527f5061757361626c653a207061757365640000000000000000000000000000000060448201526064016106c3565b606060006119d1836002612243565b6119dc90600261222b565b67ffffffffffffffff8111156119f4576119f46123bc565b6040519080825280601f01601f191660200182016040528015611a1e576020820181803683370190505b5090507f300000000000000000000000000000000000000000000000000000000000000081600081518110611a5557611a5561238d565b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a9053507f780000000000000000000000000000000000000000000000000000000000000081600181518110611ab857611ab861238d565b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a9053506000611af4846002612243565b611aff90600161222b565b90505b6001811115611b9c577f303132333435363738396162636465660000000000000000000000000000000085600f1660108110611b4057611b4061238d565b1a60f81b828281518110611b5657611b5661238d565b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a90535060049490941c93611b95816122ac565b9050611b02565b508315611c05576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f537472696e67733a20686578206c656e67746820696e73756666696369656e7460448201526064016106c3565b9392505050565b6000807f7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0831115611c435750600090506003611d1b565b8460ff16601b14158015611c5b57508460ff16601c14155b15611c6c5750600090506004611d1b565b6040805160008082526020820180845289905260ff881692820192909252606081018690526080810185905260019060a0016020604051602081039080840390855afa158015611cc0573d6000803e3d6000fd5b50506040517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0015191505073ffffffffffffffffffffffffffffffffffffffff8116611d1457600060019250925050611d1b565b9150600090505b94509492505050565b6000816004811115611d3857611d3861235e565b1415611d415750565b6001816004811115611d5557611d5561235e565b1415611dbd576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601860248201527f45434453413a20696e76616c6964207369676e6174757265000000000000000060448201526064016106c3565b6002816004811115611dd157611dd161235e565b1415611e39576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601f60248201527f45434453413a20696e76616c6964207369676e6174757265206c656e6774680060448201526064016106c3565b6003816004811115611e4d57611e4d61235e565b1415611edb576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602260248201527f45434453413a20696e76616c6964207369676e6174757265202773272076616c60448201527f756500000000000000000000000000000000000000000000000000000000000060648201526084016106c3565b6004816004811115611eef57611eef61235e565b141561084d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602260248201527f45434453413a20696e76616c6964207369676e6174757265202776272076616c60448201527f756500000000000000000000000000000000000000000000000000000000000060648201526084016106c3565b600060208284031215611f8f57600080fd5b8135611c05816123eb565b60008060408385031215611fad57600080fd5b8235611fb8816123eb565b91506020830135611fc8816123eb565b809150509250929050565b600080600060608486031215611fe857600080fd5b8335611ff3816123eb565b92506020840135612003816123eb565b929592945050506040919091013590565b600080600080600080600060e0888a03121561202f57600080fd5b873561203a816123eb565b9650602088013561204a816123eb565b95506040880135945060608801359350608088013560ff8116811461206e57600080fd5b9699959850939692959460a0840135945060c09093013592915050565b6000806040838503121561209e57600080fd5b82356120a9816123eb565b946020939093013593505050565b6000602082840312156120c957600080fd5b81518015158114611c0557600080fd5b6000602082840312156120eb57600080fd5b5035919050565b6000806040838503121561210557600080fd5b823591506020830135611fc8816123eb565b60006020828403121561212957600080fd5b81357fffffffff0000000000000000000000000000000000000000000000000000000081168114611c0557600080fd5b7f416363657373436f6e74726f6c3a206163636f756e7420000000000000000000815260008351612191816017850160208801612280565b7f206973206d697373696e6720726f6c652000000000000000000000000000000060179184019182015283516121ce816028840160208801612280565b01602801949350505050565b60208152600082518060208401526121f9816040850160208701612280565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169190910160400192915050565b6000821982111561223e5761223e61232f565b500190565b6000817fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff048311821515161561227b5761227b61232f565b500290565b60005b8381101561229b578181015183820152602001612283565b838111156112075750506000910152565b6000816122bb576122bb61232f565b507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0190565b600181811c908216806122f557607f821691505b602082108114156118be577f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b73ffffffffffffffffffffffffffffffffffffffff8116811461084d57600080fdfea2646970667358221220e2a63ef9083352ea7d53547163443e2b12a11f2f81162a295384ab2d6096a05b64736f6c63430008070033

64789:1581:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54210:192;;;;;;:::i;:::-;;:::i;:::-;;;5669:14:1;;5662:22;5644:41;;5632:2;5617:18;54210:192:0;;;;;;;;16636:88;;;:::i;:::-;;;;;;;:::i;18627:149::-;;;;;;:::i;:::-;;:::i;17684:96::-;17764:12;;17684:96;;;5842:25:1;;;5830:2;5815:18;17684:96:0;5696:177:1;19246:400:0;;;;;;:::i;:::-;;:::i;55349:111::-;;;;;;:::i;:::-;55415:7;55434:12;;;:6;:12;;;;;:22;;;;55349:111;55710:135;;;;;;:::i;:::-;;:::i;:::-;;17550:81;;;17625:2;15508:36:1;;15496:2;15481:18;17550:81:0;15366:184:1;45101:103:0;;;:::i;56710:198::-;;;;;;:::i;:::-;;:::i;20043:195::-;;;;;;:::i;:::-;;:::i;65745:65::-;;;:::i;65814:196::-;;;;;;:::i;:::-;;:::i;66179:188::-;;;;;;:::i;:::-;;:::i;46437:74::-;46500:7;;;;46437:74;;17831:115;;;;;;:::i;:::-;17924:18;;17905:7;17924:18;;;;;;;;;;;;17831:115;65020:64;;65059:25;65020:64;;44871:116;;;;;;:::i;:::-;;:::i;65680:61::-;;;:::i;54482:127::-;;;;;;:::i;:::-;54560:4;54576:12;;;:6;:12;;;;;;;;:29;;;;;;;;;;;;;;;;54482:127;16831:92;;;:::i;53641:49::-;;53686:4;53641:49;;20729:357;;;;;;:::i;:::-;;:::i;18147:155::-;;;;;;:::i;:::-;;:::i;44284:533::-;;;;;;:::i;:::-;;:::i;64955:62::-;;64993:24;64955:62;;56078:137;;;;;;:::i;:::-;;:::i;65601:75::-;65662:10;;65601:75;;18353:139;;;;;;:::i;:::-;18461:18;;;;18442:7;18461:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;18353:139;64890:62;;64928:24;64890:62;;54210:192;54295:4;54311:47;;;54326:32;54311:47;;:87;;-1:-1:-1;51825:25:0;51810:40;;;;54362:36;54304:94;54210:192;-1:-1:-1;;54210:192:0:o;16636:88::-;16690:13;16715:5;16708:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16636:88;:::o;18627:149::-;18710:4;18719:39;14604:10;18742:7;18751:6;18719:8;:39::i;:::-;-1:-1:-1;18768:4:0;18627:149;;;;:::o;19246:400::-;19358:4;19367:36;19377:6;19385:9;19396:6;19367:9;:36::i;:::-;19435:19;;;19408:24;19435:19;;;:11;:19;;;;;;;;14604:10;19435:33;;;;;;;;19479:26;;;;19471:79;;;;;;;12571:2:1;19471:79:0;;;12553:21:1;12610:2;12590:18;;;12583:30;12649:34;12629:18;;;12622:62;12720:10;12700:18;;;12693:38;12748:19;;19471:79:0;;;;;;;;;19566:57;19575:6;14604:10;19616:6;19597:16;:25;19566:8;:57::i;:::-;-1:-1:-1;19638:4:0;;19246:400;-1:-1:-1;;;;19246:400:0:o;55710:135::-;55415:7;55434:12;;;:6;:12;;;;;:22;;;54112:30;54123:4;14604:10;54112;:30::i;:::-;55816:25:::1;55827:4;55833:7;55816:10;:25::i;:::-;55710:135:::0;;;:::o;45101:103::-;45161:7;45180:20;:18;:20::i;:::-;45173:27;;45101:103;:::o;56710:198::-;56798:23;;;14604:10;56798:23;56790:83;;;;;;;14610:2:1;56790:83:0;;;14592:21:1;14649:2;14629:18;;;14622:30;14688:34;14668:18;;;14661:62;14759:17;14739:18;;;14732:45;14794:19;;56790:83:0;14408:411:1;56790:83:0;56878:26;56890:4;56896:7;56878:11;:26::i;:::-;56710:198;;:::o;20043:195::-;14604:10;20131:4;20172:25;;;:11;:25;;;;;;;;;:34;;;;;;;;;;20131:4;;20140:80;;20163:7;;20172:47;;20209:10;;20172:47;:::i;:::-;20140:8;:80::i;65745:65::-;64928:24;54112:30;64928:24;14604:10;54112;:30::i;:::-;65796:10:::1;:8;:10::i;:::-;65745:65:::0;:::o;65814:196::-;64993:24;54112:30;64993:24;14604:10;54112;:30::i;:::-;65924:10:::1;;65914:6;65898:13;17764:12:::0;;;17684:96;65898:13:::1;:22;;;;:::i;:::-;:36;;65888:98;;;::::0;::::1;::::0;;13386:2:1;65888:98:0::1;::::0;::::1;13368:21:1::0;13425:2;13405:18;;;13398:30;13464:34;13444:18;;;13437:62;13535:14;13515:18;;;13508:42;13567:19;;65888:98:0::1;13184:408:1::0;65888:98:0::1;65989:17;65995:2;65999:6;65989:5;:17::i;66179:188::-:0;65059:25;54112:30;65059:25;14604:10;54112;:30::i;:::-;66268:14:::1;::::0;::::1;;14604:10:::0;66268:35:::1;::::0;;::::1;::::0;;;;;;5406:42:1;5394:55;;;66268:35:0::1;::::0;::::1;5376:74:1::0;5466:18;;;5459:34;;;5349:18;;66268:35:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;66313:50:0::1;::::0;5842:25:1;;;66313:50:0::1;::::0;::::1;::::0;14604:10;;66313:50:::1;::::0;5830:2:1;5815:18;66313:50:0::1;;;;;;;;66179:188:::0;;;:::o;44871:116::-;44959:14;;;44940:7;44959:14;;;:7;:14;;;;;42669;44959:24;42585:102;65680:61;64928:24;54112:30;64928:24;14604:10;54112;:30::i;:::-;65729:8:::1;:6;:8::i;16831:92::-:0;16887:13;16912:7;16905:14;;;;;:::i;20729:357::-;14604:10;20822:4;20858:25;;;:11;:25;;;;;;;;;:34;;;;;;;;;;20903:35;;;;20895:85;;;;;;;14204:2:1;20895:85:0;;;14186:21:1;14243:2;14223:18;;;14216:30;14282:34;14262:18;;;14255:62;14353:7;14333:18;;;14326:35;14378:19;;20895:85:0;14002:401:1;20895:85:0;20996:67;14604:10;21019:7;21047:15;21028:16;:34;20996:8;:67::i;:::-;-1:-1:-1;21078:4:0;;20729:357;-1:-1:-1;;;20729:357:0:o;18147:155::-;18233:4;18242:42;14604:10;18266:9;18277:6;18242:9;:42::i;44284:533::-;44460:8;44441:15;:27;;44433:69;;;;;;;10296:2:1;44433:69:0;;;10278:21:1;10335:2;10315:18;;;10308:30;10374:31;10354:18;;;10347:59;10423:18;;44433:69:0;10094:353:1;44433:69:0;44507:18;44549:16;44567:5;44574:7;44583:5;44590:16;44600:5;44590:9;:16::i;:::-;44538:79;;;;;;6165:25:1;;;;6209:42;6287:15;;;6267:18;;;6260:43;6339:15;;;;6319:18;;;6312:43;6371:18;;;6364:34;6414:19;;;6407:35;6458:19;;;6451:35;;;6137:19;;44538:79:0;;;;;;;;;;;;44528:90;;;;;;44507:111;;44623:12;44638:28;44655:10;44638:16;:28::i;:::-;44623:43;;44671:14;44688:28;44702:4;44708:1;44711;44714;44688:13;:28::i;:::-;44671:45;;44737:5;44727:15;;:6;:15;;;44719:58;;;;;;;12212:2:1;44719:58:0;;;12194:21:1;12251:2;12231:18;;;12224:30;12290:32;12270:18;;;12263:60;12340:18;;44719:58:0;12010:354:1;44719:58:0;44782:31;44791:5;44798:7;44807:5;44782:8;:31::i;:::-;44430:387;;;44284:533;;;;;;;:::o;56078:137::-;55415:7;55434:12;;;:6;:12;;;;;:22;;;54112:30;54123:4;14604:10;54112;:30::i;:::-;56185:26:::1;56197:4;56203:7;56185:11;:26::i;24049:316::-:0;24149:19;;;24141:68;;;;;;;13799:2:1;24141:68:0;;;13781:21:1;13838:2;13818:18;;;13811:30;13877:34;13857:18;;;13850:62;13948:6;13928:18;;;13921:34;13972:19;;24141:68:0;13597:400:1;24141:68:0;24220:21;;;24212:68;;;;;;;9893:2:1;24212:68:0;;;9875:21:1;9932:2;9912:18;;;9905:30;9971:34;9951:18;;;9944:62;10042:4;10022:18;;;10015:32;10064:19;;24212:68:0;9691:398:1;24212:68:0;24285:18;;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;24329:32;;5842:25:1;;;24329:32:0;;5815:18:1;24329:32:0;5696:177:1;21564:609:0;21668:20;;;21660:70;;;;;;;12980:2:1;21660:70:0;;;12962:21:1;13019:2;12999:18;;;12992:30;13058:34;13038:18;;;13031:62;13129:7;13109:18;;;13102:35;13154:19;;21660:70:0;12778:401:1;21660:70:0;21741:23;;;21733:71;;;;;;;8780:2:1;21733:71:0;;;8762:21:1;8819:2;8799:18;;;8792:30;8858:34;8838:18;;;8831:62;8929:5;8909:18;;;8902:33;8952:19;;21733:71:0;8578:399:1;21733:71:0;21809:47;21830:6;21838:9;21849:6;21809:20;:47::i;:::-;21885:17;;;21861:21;21885:17;;;;;;;;;;;21913:23;;;;21905:74;;;;;;;10654:2:1;21905:74:0;;;10636:21:1;10693:2;10673:18;;;10666:30;10732:34;10712:18;;;10705:62;10803:8;10783:18;;;10776:36;10829:19;;21905:74:0;10452:402:1;21905:74:0;21995:17;;;;:9;:17;;;;;;;;;;;22015:22;;;21995:42;;22043:20;;;;;;;;:30;;22031:6;;21995:9;22043:30;;22031:6;;22043:30;:::i;:::-;;;;;;;;22100:9;22083:35;;22092:6;22083:35;;;22111:6;22083:35;;;;5842:25:1;;5830:2;5815:18;;5696:177;22083:35:0;;;;;;;;22123:46;21657:516;21564:609;;;:::o;54887:285::-;54560:4;54576:12;;;:6;:12;;;;;;;;:29;;;;;;;;;;;;;54955:214;;55052:41;55080:7;55052:41;;55090:2;55052:19;:41::i;:::-;55118:38;55146:4;55153:2;55118:19;:38::i;:::-;55005:154;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;54987:178;;;;;;;;:::i;58115:194::-;54560:4;54576:12;;;:6;:12;;;;;;;;:29;;;;;;;;;;;;;58186:120;;58218:12;;;;:6;:12;;;;;;;;:29;;;;;;;;;;:36;;;;58250:4;58218:36;;;58289:12;14604:10;;14532:86;58289:12;58262:40;;58280:7;58262:40;;58274:4;58262:40;;;;;;;;;;58115:194;;:::o;40613:262::-;40666:7;40690:4;40682:29;40699:12;40682:29;;:66;;;;;40732:16;40715:13;:33;40682:66;40678:194;;;-1:-1:-1;40760:24:0;;40613:262::o;40678:194::-;-1:-1:-1;41024:73:0;;;40826:10;41024:73;;;;6756:25:1;;;;40838:12:0;6797:18:1;;;6790:34;40852:15:0;6840:18:1;;;6833:34;41068:13:0;6883:18:1;;;6876:34;41091:4:0;6926:19:1;;;;6919:84;;;;41024:73:0;;;;;;;;;;6728:19:1;;;;41024:73:0;;;41014:84;;;;;;45101:103::o;58429:195::-;54560:4;54576:12;;;:6;:12;;;;;;;;:29;;;;;;;;;;;;;58501:120;;;58564:5;58532:12;;;:6;:12;;;;;;;;:29;;;;;;;;;;;:37;;;;;;58577:40;14604:10;;58532:12;;58577:40;;58564:5;58577:40;58429:195;;:::o;47376:100::-;46500:7;;;;46968:41;;;;;;;9184:2:1;46968:41:0;;;9166:21:1;9223:2;9203:18;;;9196:30;9262:22;9242:18;;;9235:50;9302:18;;46968:41:0;8982:344:1;46968:41:0;47427:7:::1;:15:::0;;;::::1;::::0;;47450:22:::1;14604:10:::0;47459:12:::1;47450:22;::::0;5147:42:1;5135:55;;;5117:74;;5105:2;5090:18;47450:22:0::1;;;;;;;47376:100::o:0;22452:347::-;22528:21;;;22520:65;;;;;;;15026:2:1;22520:65:0;;;15008:21:1;15065:2;15045:18;;;15038:30;15104:33;15084:18;;;15077:61;15155:18;;22520:65:0;14824:355:1;22520:65:0;22590:49;22619:1;22623:7;22632:6;22590:20;:49::i;:::-;22660:6;22644:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;22669:18:0;;;:9;:18;;;;;;;;;;:28;;22691:6;;22669:9;:28;;22691:6;;22669:28;:::i;:::-;;;;-1:-1:-1;;22705:37:0;;5842:25:1;;;22705:37:0;;;;22722:1;;22705:37;;5830:2:1;5815:18;22705:37:0;;;;;;;56710:198;;:::o;47149:98::-;46500:7;;;;46730:9;46722:38;;;;;;;11464:2:1;46722:38:0;;;11446:21:1;11503:2;11483:18;;;11476:30;11542:18;11522;;;11515:46;11578:18;;46722:38:0;11262:340:1;46722:38:0;47201:7:::1;:14:::0;;;::::1;47211:4;47201:14;::::0;;47223:20:::1;47230:12;14604:10:::0;;14532:86;45330:179;45443:14;;;45390:15;45443:14;;;:7;:14;;;;;42669;;42778:1;42760:19;;;;42669:14;45488:17;45407:102;45330:179;;;:::o;41732:155::-;41809:7;41828:55;41850:20;:18;:20::i;:::-;41872:10;37647:57;;4001:66:1;37647:57:0;;;3989:79:1;4084:11;;;4077:27;;;4120:12;;;4113:28;;;37618:7:0;;4157:12:1;;37647:57:0;;;;;;;;;;;;37637:68;;;;;;37630:75;;37525:184;;;;;35974:215;36066:7;36079:17;36098:18;36120:25;36131:4;36137:1;36140;36143;36120:10;:25::i;:::-;36078:67;;;;36148:18;36160:5;36148:11;:18::i;:::-;-1:-1:-1;36176:9:0;35974:215;-1:-1:-1;;;;;35974:215:0:o;66014:161::-;46500:7;;;;46730:9;46722:38;;;;;;;11464:2:1;46722:38:0;;;11446:21:1;11503:2;11483:18;;;11476:30;11542:18;11522;;;11515:46;11578:18;;46722:38:0;11262:340:1;29042:367:0;29117:13;29135:19;29167:10;29171:6;29167:1;:10;:::i;:::-;:14;;29180:1;29167:14;:::i;:::-;29157:25;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;29157:25:0;;29135:47;;29185:15;:6;29192:1;29185:9;;;;;;;;:::i;:::-;;;;:15;;;;;;;;;;;29203;:6;29210:1;29203:9;;;;;;;;:::i;:::-;;;;:15;;;;;;;;;;-1:-1:-1;29226:9:0;29238:10;29242:6;29238:1;:10;:::i;:::-;:14;;29251:1;29238:14;:::i;:::-;29226:26;;29221:103;29258:1;29254;:5;29221:103;;;29281:12;29294:5;29302:3;29294:11;29281:25;;;;;;;:::i;:::-;;;;29269:6;29276:1;29269:9;;;;;;;;:::i;:::-;;;;:37;;;;;;;;;;-1:-1:-1;29319:1:0;29309:11;;;;;29261:3;;;:::i;:::-;;;29221:103;;;-1:-1:-1;29334:10:0;;29326:55;;;;;;;8419:2:1;29326:55:0;;;8401:21:1;;;8438:18;;;8431:30;8497:34;8477:18;;;8470:62;8549:18;;29326:55:0;8217:356:1;29326:55:0;29398:6;29042:367;-1:-1:-1;;;29042:367:0:o;34422:1425::-;34517:7;;35384:66;35371:79;;35367:143;;;-1:-1:-1;35471:1:0;;-1:-1:-1;35475:30:0;35455:51;;35367:143;35516:1;:7;;35521:2;35516:7;;:18;;;;;35527:1;:7;;35532:2;35527:7;;35516:18;35512:82;;;-1:-1:-1;35555:1:0;;-1:-1:-1;35559:30:0;35539:51;;35512:82;35692:24;;;35675:14;35692:24;;;;;;;;;7241:25:1;;;7314:4;7302:17;;7282:18;;;7275:45;;;;7336:18;;;7329:34;;;7379:18;;;7372:34;;;35692:24:0;;7213:19:1;;35692:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;35692:24:0;;;;;;-1:-1:-1;;35723:20:0;;;35719:83;;35764:1;35768:29;35748:50;;;;;;;35719:83;35814:6;-1:-1:-1;35822:20:0;;-1:-1:-1;34422:1425:0;;;;;;;;:::o;29768:531::-;29838:20;29829:5;:29;;;;;;;;:::i;:::-;;29825:471;;;29768:531;:::o;29825:471::-;29916:29;29907:5;:38;;;;;;;;:::i;:::-;;29903:393;;;29950:34;;;;;8066:2:1;29950:34:0;;;8048:21:1;8105:2;8085:18;;;8078:30;8144:26;8124:18;;;8117:54;8188:18;;29950:34:0;7864:348:1;29903:393:0;30007:35;29998:5;:44;;;;;;;;:::i;:::-;;29994:302;;;30047:41;;;;;9533:2:1;30047:41:0;;;9515:21:1;9572:2;9552:18;;;9545:30;9611:33;9591:18;;;9584:61;9662:18;;30047:41:0;9331:355:1;29994:302:0;30111:30;30102:5;:39;;;;;;;;:::i;:::-;;30098:198;;;30146:44;;;;;11061:2:1;30146:44:0;;;11043:21:1;11100:2;11080:18;;;11073:30;11139:34;11119:18;;;11112:62;11210:4;11190:18;;;11183:32;11232:19;;30146:44:0;10859:398:1;30098:198:0;30213:30;30204:5;:39;;;;;;;;:::i;:::-;;30200:96;;;30248:44;;;;;11809:2:1;30248:44:0;;;11791:21:1;11848:2;11828:18;;;11821:30;11887:34;11867:18;;;11860:62;11958:4;11938:18;;;11931:32;11980:19;;30248:44:0;11607:398:1;14:247;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;181:9;168:23;200:31;225:5;200:31;:::i;266:388::-;334:6;342;395:2;383:9;374:7;370:23;366:32;363:52;;;411:1;408;401:12;363:52;450:9;437:23;469:31;494:5;469:31;:::i;:::-;519:5;-1:-1:-1;576:2:1;561:18;;548:32;589:33;548:32;589:33;:::i;:::-;641:7;631:17;;;266:388;;;;;:::o;659:456::-;736:6;744;752;805:2;793:9;784:7;780:23;776:32;773:52;;;821:1;818;811:12;773:52;860:9;847:23;879:31;904:5;879:31;:::i;:::-;929:5;-1:-1:-1;986:2:1;971:18;;958:32;999:33;958:32;999:33;:::i;:::-;659:456;;1051:7;;-1:-1:-1;;;1105:2:1;1090:18;;;;1077:32;;659:456::o;1120:829::-;1231:6;1239;1247;1255;1263;1271;1279;1332:3;1320:9;1311:7;1307:23;1303:33;1300:53;;;1349:1;1346;1339:12;1300:53;1388:9;1375:23;1407:31;1432:5;1407:31;:::i;:::-;1457:5;-1:-1:-1;1514:2:1;1499:18;;1486:32;1527:33;1486:32;1527:33;:::i;:::-;1579:7;-1:-1:-1;1633:2:1;1618:18;;1605:32;;-1:-1:-1;1684:2:1;1669:18;;1656:32;;-1:-1:-1;1740:3:1;1725:19;;1712:33;1789:4;1776:18;;1764:31;;1754:59;;1809:1;1806;1799:12;1754:59;1120:829;;;;-1:-1:-1;1120:829:1;;;;1832:7;1886:3;1871:19;;1858:33;;-1:-1:-1;1938:3:1;1923:19;;;1910:33;;1120:829;-1:-1:-1;;1120:829:1:o;1954:315::-;2022:6;2030;2083:2;2071:9;2062:7;2058:23;2054:32;2051:52;;;2099:1;2096;2089:12;2051:52;2138:9;2125:23;2157:31;2182:5;2157:31;:::i;:::-;2207:5;2259:2;2244:18;;;;2231:32;;-1:-1:-1;;;1954:315:1:o;2274:277::-;2341:6;2394:2;2382:9;2373:7;2369:23;2365:32;2362:52;;;2410:1;2407;2400:12;2362:52;2442:9;2436:16;2495:5;2488:13;2481:21;2474:5;2471:32;2461:60;;2517:1;2514;2507:12;2556:180;2615:6;2668:2;2656:9;2647:7;2643:23;2639:32;2636:52;;;2684:1;2681;2674:12;2636:52;-1:-1:-1;2707:23:1;;2556:180;-1:-1:-1;2556:180:1:o;2741:315::-;2809:6;2817;2870:2;2858:9;2849:7;2845:23;2841:32;2838:52;;;2886:1;2883;2876:12;2838:52;2922:9;2909:23;2899:33;;2982:2;2971:9;2967:18;2954:32;2995:31;3020:5;2995:31;:::i;3061:332::-;3119:6;3172:2;3160:9;3151:7;3147:23;3143:32;3140:52;;;3188:1;3185;3178:12;3140:52;3227:9;3214:23;3277:66;3270:5;3266:78;3259:5;3256:89;3246:117;;3359:1;3356;3349:12;4180:786;4591:25;4586:3;4579:38;4561:3;4646:6;4640:13;4662:62;4717:6;4712:2;4707:3;4703:12;4696:4;4688:6;4684:17;4662:62;:::i;:::-;4788:19;4783:2;4743:16;;;4775:11;;;4768:40;4833:13;;4855:63;4833:13;4904:2;4896:11;;4889:4;4877:17;;4855:63;:::i;:::-;4938:17;4957:2;4934:26;;4180:786;-1:-1:-1;;;;4180:786:1:o;7417:442::-;7566:2;7555:9;7548:21;7529:4;7598:6;7592:13;7641:6;7636:2;7625:9;7621:18;7614:34;7657:66;7716:6;7711:2;7700:9;7696:18;7691:2;7683:6;7679:15;7657:66;:::i;:::-;7775:2;7763:15;7780:66;7759:88;7744:104;;;;7850:2;7740:113;;7417:442;-1:-1:-1;;7417:442:1:o;15555:128::-;15595:3;15626:1;15622:6;15619:1;15616:13;15613:39;;;15632:18;;:::i;:::-;-1:-1:-1;15668:9:1;;15555:128::o;15688:228::-;15728:7;15854:1;15786:66;15782:74;15779:1;15776:81;15771:1;15764:9;15757:17;15753:105;15750:131;;;15861:18;;:::i;:::-;-1:-1:-1;15901:9:1;;15688:228::o;15921:258::-;15993:1;16003:113;16017:6;16014:1;16011:13;16003:113;;;16093:11;;;16087:18;16074:11;;;16067:39;16039:2;16032:10;16003:113;;;16134:6;16131:1;16128:13;16125:48;;;-1:-1:-1;;16169:1:1;16151:16;;16144:27;15921:258::o;16184:196::-;16223:3;16251:5;16241:39;;16260:18;;:::i;:::-;-1:-1:-1;16307:66:1;16296:78;;16184:196::o;16385:437::-;16464:1;16460:12;;;;16507;;;16528:61;;16582:4;16574:6;16570:17;16560:27;;16528:61;16635:2;16627:6;16624:14;16604:18;16601:38;16598:218;;;16672:77;16669:1;16662:88;16773:4;16770:1;16763:15;16801:4;16798:1;16791:15;16827:184;16879:77;16876:1;16869:88;16976:4;16973:1;16966:15;17000:4;16997:1;16990:15;17016:184;17068:77;17065:1;17058:88;17165:4;17162:1;17155:15;17189:4;17186:1;17179:15;17205:184;17257:77;17254:1;17247:88;17354:4;17351:1;17344:15;17378:4;17375:1;17368:15;17394:184;17446:77;17443:1;17436:88;17543:4;17540:1;17533:15;17567:4;17564:1;17557:15;17583:154;17669:42;17662:5;17658:54;17651:5;17648:65;17638:93;;17727:1;17724;17717:12

ipfs://e2a63ef9083352ea7d53547163443e2b12a11f2f81162a295384ab2d6096a05b