Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-06-18
*/

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol

// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;

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

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

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

// File: @openzeppelin/contracts/utils/Context.sol

// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

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

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

// File: @openzeppelin/contracts/token/ERC20/ERC20.sol

// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.0;



/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/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:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, 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}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, 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}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, 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) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, 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) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `from` to `to`.
     *
     * 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:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
            // decrementing then incrementing.
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, 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;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _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;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _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 Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

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

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

// File: @openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol

// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)

pragma solidity ^0.8.0;

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

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

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

// File: @openzeppelin/contracts/utils/Address.sol

// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @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
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 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 functionCallWithValue(target, data, 0, "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");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or 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 {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // 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
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

// File: @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol

// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;



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

    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

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

// File: @openzeppelin/contracts/access/Ownable.sol

// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// File: @openzeppelin/contracts/utils/structs/EnumerableSet.sol

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

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

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

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

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

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

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

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

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

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

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

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

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

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

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

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

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

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

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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

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

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

        return result;
    }
}

// File: contracts/interfaces/IUniswapV2Factory.sol


pragma solidity >=0.5.0;

interface IUniswapV2Factory {
    event PairCreated(
        address indexed token0,
        address indexed token1,
        address pair,
        uint256
    );

    function owner() external view returns (address);

    function feePercentOwner() external view returns (address);

    function setStableOwner() external view returns (address);

    function feeTo() external view returns (address);

    function ownerFeeShare() external view returns (uint256);

    function referrersFeeShare(address) external view returns (uint256);

    function getPair(
        address tokenA,
        address tokenB
    ) external view returns (address pair);

    function allPairs(uint256) external view returns (address pair);

    function allPairsLength() external view returns (uint256);

    function createPair(
        address tokenA,
        address tokenB
    ) external returns (address pair);

    function setFeeTo(address) external;

    function feeInfo()
        external
        view
        returns (uint _ownerFeeShare, address _feeTo);
}

// File: contracts/interfaces/IUniswapV2Router01.sol


pragma solidity >=0.6.2;

interface IUniswapV2Router01 {
    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;
}

// File: contracts/interfaces/IUniswapV2Router02.sol


pragma solidity >=0.6.2;

interface IUniswapV2Router02 is IUniswapV2Router01 {
    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}

// File: contracts/interfaces/IWETH.sol


pragma solidity >=0.5.0;

interface IWETH {
    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

    function allowance(address owner, address spender) external view returns (uint256);

    function approve(address spender, uint256 amount) external returns (bool);

    function deposit() external payable;

    function transfer(address to, uint256 value) external returns (bool);

    function withdraw(uint256) external;
}

// File: contracts/token/TREX.sol

pragma solidity =0.8.19;

contract TREX is ERC20, Ownable {
    using SafeERC20 for IERC20;
    using EnumerableSet for EnumerableSet.AddressSet;

    event SwapBack(uint256 tax, uint timestamp);

    event Trade(address user, address pair, uint256 amount, uint side, uint256 circulatingSupply, uint timestamp);

    bool public swapEnabled = true;

    bool public inSwap;

    modifier swapping() {
        inSwap = true;
        _;
        inSwap = false;
    }

    mapping(address => bool) public isFeeExempt;

    uint256 private totalFee = 200;

    uint256 private feeDenominator = 10000;

    // Fees receivers
    address private govWallet;

    IUniswapV2Factory private immutable factory;

    IUniswapV2Router02 private immutable swapRouter;

    IWETH private immutable WETH;

    IERC20 private backToken;

    address private constant DEAD = 0x000000000000000000000000000000000000dEaD;

    address private constant ZERO = 0x0000000000000000000000000000000000000000;

    EnumerableSet.AddressSet private _pairs;

    constructor(
        address _backToken,
        address _swapRouter,
        address _factory,
        address _weth
    ) ERC20("TREX", "TREX") {
        uint256 _totalSupply = 444_444_444 * 1e18;

        backToken = IERC20(_backToken);

        WETH = IWETH(_weth);

        swapRouter = IUniswapV2Router02(_swapRouter);
        
        factory = IUniswapV2Factory(_factory);

        isFeeExempt[msg.sender] = true;

        isFeeExempt[address(this)] = true;
        
        _mint(_msgSender(), _totalSupply);
    }

    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        return _internalTransfer(_msgSender(), to, amount);
    }

    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(sender, spender, amount);
        return _internalTransfer(sender, recipient, amount);
    }

    function _internalTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
        if (inSwap) {
            _transfer(sender, recipient, amount);
            return true;
        }

        bool shouldTakeFee = (!isFeeExempt[sender] && !isFeeExempt[recipient]);
        uint side = 0;
        address user_ = sender;
        address pair_ = recipient;

        if (isPair(sender)) {
            side = 1;
            user_ = recipient;
            pair_ = sender;
        } else if (isPair(recipient)) {
            side = 2;
        } else {
            shouldTakeFee = false;
        }

        if (shouldSwapBack()) {
            swapBack();
        }

        uint256 amountReceived = shouldTakeFee ? takeFee(sender, amount) : amount;
        
        _transfer(sender, recipient, amountReceived);

        if (side > 0) {
            emit Trade(user_, pair_, amount, side, getCirculatingSupply(), block.timestamp);
        }

        return true;
    }

    function shouldSwapBack() internal view returns (bool) {
        return !inSwap && swapEnabled && balanceOf(address(this)) > 0 && !isPair(_msgSender());
    }

    function swapBack() internal swapping {
        uint256 taxAmount = balanceOf(address(this));
        
        _approve(address(this), address(swapRouter), taxAmount);

        address[] memory path = new address[](3);   
        path[0] = address(this);
        path[1] = address(WETH);
        path[2] = address(backToken);

        bool success = false;

        try swapRouter.swapExactTokensForTokensSupportingFeeOnTransferTokens(taxAmount, 0, path, govWallet, block.timestamp) {
            success = true;
        } 
        catch {}

        if (!success) {
            return;
        }

        emit SwapBack(taxAmount, block.timestamp);
    }
    
    function takeFee(address sender, uint256 amount) internal returns (uint256) {
        uint256 feeAmount = (amount * totalFee) / feeDenominator;
        _transfer(sender, address(this), feeAmount);
        return amount - feeAmount;
    }

    function getCirculatingSupply() public view returns (uint256) {
        return totalSupply() - balanceOf(DEAD) - balanceOf(ZERO);
    }

    function isPair(address account) public view returns (bool) {
        return _pairs.contains(account);
    }

    /*** ADMIN FUNCTIONS ***/
    function initializePair() external onlyOwner {
        address pair = factory.createPair(address(WETH), address(this));
        _pairs.add(pair);
    }

    function clearStuckEthBalance() external onlyOwner {
        uint256 amountETH = address(this).balance;
        (bool success, ) = payable(_msgSender()).call{value: amountETH}(new bytes(0));
        require(success, "TREX: ETH_TRANSFER_FAILED");
    }

    function clearStuckBalance() external onlyOwner {
        _transfer(address(this), _msgSender(), balanceOf(address(this)));
    }

    function doSwapBack() public onlyOwner {
        swapBack();
    }

    function setReceivers(address _govWallet) external onlyOwner {
        govWallet = _govWallet;
    }

    function setWalletOnFee(address[] memory _a, bool[] calldata _b) external onlyOwner {
        require(_a.length > 0, "List wallets is empty");
        require(_b.length > 0, "List exempts is empty");
        for (uint256 i = 0; i < _a.length; i++) {
            isFeeExempt[_a[i]] = _b[i];
        }
    }

    function setSwapBackSettings(bool _enabled) external onlyOwner {
        swapEnabled = _enabled;
    }

    function addPair(address pair) public onlyOwner returns (bool) {
        require(pair != address(0), "TREX: pair is the zero address");
        return _pairs.add(pair);
    }

    function delPair(address pair) public onlyOwner returns (bool) {
        require(pair != address(0), "TREX: pair is the zero address");
        return _pairs.remove(pair);
    }

    receive() external payable {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_backToken","type":"address"},{"internalType":"address","name":"_swapRouter","type":"address"},{"internalType":"address","name":"_factory","type":"address"},{"internalType":"address","name":"_weth","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tax","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"SwapBack","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"address","name":"pair","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"side","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"circulatingSupply","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"Trade","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"pair","type":"address"}],"name":"addPair","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","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":"clearStuckBalance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"clearStuckEthBalance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"}],"name":"delPair","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"doSwapBack","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getCirculatingSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"inSwap","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":"initializePair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isFeeExempt","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isPair","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_govWallet","type":"address"}],"name":"setReceivers","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_enabled","type":"bool"}],"name":"setSwapBackSettings","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_a","type":"address[]"},{"internalType":"bool[]","name":"_b","type":"bool[]"}],"name":"setWalletOnFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"swapEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"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":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

60e06040526005805460ff60a01b1916600160a01b17905560c86007556127106008553480156200002f57600080fd5b506040516200202c3803806200202c833981016040819052620000529162000285565b6040805180820182526004808252630a8a48ab60e31b60208084018290528451808601909552918452908301529060036200008e838262000386565b5060046200009d828262000386565b505050620000ba620000b46200014760201b60201c565b6200014b565b600a80546001600160a01b0319166001600160a01b038681169190911790915581811660c05283811660a052821660805233600090815260066020526040808220805460ff19908116600190811790925530845291909220805490911690911790556b016fa2c59631aee7aaf000006200013c620001353390565b826200019d565b50505050506200047a565b3390565b600580546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b6001600160a01b038216620001f85760405162461bcd60e51b815260206004820152601f60248201527f45524332303a206d696e7420746f20746865207a65726f206164647265737300604482015260640160405180910390fd5b80600260008282546200020c919062000452565b90915550506001600160a01b038216600081815260208181526040808320805486019055518481527fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef910160405180910390a35050565b505050565b80516001600160a01b03811681146200028057600080fd5b919050565b600080600080608085870312156200029c57600080fd5b620002a78562000268565b9350620002b76020860162000268565b9250620002c76040860162000268565b9150620002d76060860162000268565b905092959194509250565b634e487b7160e01b600052604160045260246000fd5b600181811c908216806200030d57607f821691505b6020821081036200032e57634e487b7160e01b600052602260045260246000fd5b50919050565b601f8211156200026357600081815260208120601f850160051c810160208610156200035d5750805b601f850160051c820191505b818110156200037e5782815560010162000369565b505050505050565b81516001600160401b03811115620003a257620003a2620002e2565b620003ba81620003b38454620002f8565b8462000334565b602080601f831160018114620003f25760008415620003d95750858301515b600019600386901b1c1916600185901b1785556200037e565b600085815260208120601f198616915b82811015620004235788860151825594840194600190910190840162000402565b5085821015620004425787850151600019600388901b60f8161c191681555b5050505050600190811b01905550565b808201808211156200047457634e487b7160e01b600052601160045260246000fd5b92915050565b60805160a05160c051611b74620004b8600039600081816108b401526113790152600081816112fb0152611420015260006108e50152611b746000f3fe6080604052600436106101bb5760003560e01c8063715018a6116100ec578063b8c611301161008a578063d830678611610064578063d8306786146104c1578063dd62ed3e146104e2578063e5e31b1314610528578063f2fde38b1461054857600080fd5b8063b8c611301461046c578063bfa382b51461048c578063c2b7bbb6146104a157600080fd5b806395d89b41116100c657806395d89b41146103f7578063a457c2d71461040c578063a5bc50851461042c578063a9059cbb1461044c57600080fd5b8063715018a6146103a55780638da5cb5b146103ba5780638fbbd750146103e257600080fd5b8063364333f4116101595780633f4218e0116101335780633f4218e0146103095780634fab9e4c146103395780636ddd17131461034e57806370a082311461036f57600080fd5b8063364333f4146102b457806339509351146102c95780633a98a91f146102e957600080fd5b806318160ddd1161019557806318160ddd1461024457806323b872dd146102635780632b112e4914610283578063313ce5671461029857600080fd5b80630421cefd146101c757806306fdde03146101e9578063095ea7b31461021457600080fd5b366101c257005b600080fd5b3480156101d357600080fd5b506101e76101e236600461177a565b610568565b005b3480156101f557600080fd5b506101fe6106a6565b60405161020b9190611888565b60405180910390f35b34801561022057600080fd5b5061023461022f3660046118bb565b610738565b604051901515815260200161020b565b34801561025057600080fd5b506002545b60405190815260200161020b565b34801561026f57600080fd5b5061023461027e3660046118e7565b610752565b34801561028f57600080fd5b50610255610776565b3480156102a457600080fd5b506040516012815260200161020b565b3480156102c057600080fd5b506101e76107e2565b3480156102d557600080fd5b506102346102e43660046118bb565b610806565b3480156102f557600080fd5b506101e7610304366004611928565b610845565b34801561031557600080fd5b50610234610324366004611928565b60066020526000908152604090205460ff1681565b34801561034557600080fd5b506101e761087c565b34801561035a57600080fd5b5060055461023490600160a01b900460ff1681565b34801561037b57600080fd5b5061025561038a366004611928565b6001600160a01b031660009081526020819052604090205490565b3480156103b157600080fd5b506101e7610965565b3480156103c657600080fd5b506005546040516001600160a01b03909116815260200161020b565b3480156103ee57600080fd5b506101e7610977565b34801561040357600080fd5b506101fe610987565b34801561041857600080fd5b506102346104273660046118bb565b610996565b34801561043857600080fd5b50610234610447366004611928565b610a4b565b34801561045857600080fd5b506102346104673660046118bb565b610abe565b34801561047857600080fd5b506101e7610487366004611945565b610acb565b34801561049857600080fd5b506101e7610b0c565b3480156104ad57600080fd5b506102346104bc366004611928565b610bc9565b3480156104cd57600080fd5b5060055461023490600160a81b900460ff1681565b3480156104ee57600080fd5b506102556104fd366004611967565b6001600160a01b03918216600090815260016020908152604080832093909416825291909152205490565b34801561053457600080fd5b50610234610543366004611928565b610c34565b34801561055457600080fd5b506101e7610563366004611928565b610c41565b610570610cd1565b60008351116105c65760405162461bcd60e51b815260206004820152601560248201527f4c6973742077616c6c65747320697320656d707479000000000000000000000060448201526064015b60405180910390fd5b806106135760405162461bcd60e51b815260206004820152601560248201527f4c697374206578656d70747320697320656d707479000000000000000000000060448201526064016105bd565b60005b83518110156106a057828282818110610631576106316119a0565b90506020020160208101906106469190611945565b6006600086848151811061065c5761065c6119a0565b6020908102919091018101516001600160a01b03168252810191909152604001600020805460ff191691151591909117905580610698816119cc565b915050610616565b50505050565b6060600380546106b5906119e5565b80601f01602080910402602001604051908101604052809291908181526020018280546106e1906119e5565b801561072e5780601f106107035761010080835404028352916020019161072e565b820191906000526020600020905b81548152906001019060200180831161071157829003601f168201915b5050505050905090565b600033610746818585610d2b565b60019150505b92915050565b600033610760858285610e83565b61076b858585610f0f565b9150505b9392505050565b600060208190527fad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb55461dead82527f44ad89ba62b98ff34f51403ac22759b55759460c0bb5521eb4b6ee3cff49cf83546002546107d39190611a1f565b6107dd9190611a1f565b905090565b6107ea610cd1565b61080430333060009081526020819052604090205461106f565b565b3360008181526001602090815260408083206001600160a01b03871684529091528120549091906107469082908690610840908790611a32565b610d2b565b61084d610cd1565b6009805473ffffffffffffffffffffffffffffffffffffffff19166001600160a01b0392909216919091179055565b610884610cd1565b6040517fc9c653960000000000000000000000000000000000000000000000000000000081526001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000811660048301523060248301526000917f00000000000000000000000000000000000000000000000000000000000000009091169063c9c65396906044016020604051808303816000875af1158015610930573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906109549190611a45565b9050610961600b8261125c565b5050565b61096d610cd1565b6108046000611271565b61097f610cd1565b6108046112d0565b6060600480546106b5906119e5565b3360008181526001602090815260408083206001600160a01b038716845290915281205490919083811015610a335760405162461bcd60e51b815260206004820152602560248201527f45524332303a2064656372656173656420616c6c6f77616e63652062656c6f7760448201527f207a65726f00000000000000000000000000000000000000000000000000000060648201526084016105bd565b610a408286868403610d2b565b506001949350505050565b6000610a55610cd1565b6001600160a01b038216610aab5760405162461bcd60e51b815260206004820152601e60248201527f545245583a207061697220697320746865207a65726f2061646472657373000060448201526064016105bd565b610ab6600b836114ed565b90505b919050565b600061076f338484610f0f565b610ad3610cd1565b60058054911515600160a01b027fffffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffff909216919091179055565b610b14610cd1565b60408051600080825260208201928390524792909133918491610b3691611a62565b60006040518083038185875af1925050503d8060008114610b73576040519150601f19603f3d011682016040523d82523d6000602084013e610b78565b606091505b50509050806109615760405162461bcd60e51b815260206004820152601960248201527f545245583a204554485f5452414e534645525f4641494c45440000000000000060448201526064016105bd565b6000610bd3610cd1565b6001600160a01b038216610c295760405162461bcd60e51b815260206004820152601e60248201527f545245583a207061697220697320746865207a65726f2061646472657373000060448201526064016105bd565b610ab6600b8361125c565b6000610ab6600b83611502565b610c49610cd1565b6001600160a01b038116610cc55760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201527f646472657373000000000000000000000000000000000000000000000000000060648201526084016105bd565b610cce81611271565b50565b6005546001600160a01b031633146108045760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016105bd565b6001600160a01b038316610da65760405162461bcd60e51b8152602060048201526024808201527f45524332303a20617070726f76652066726f6d20746865207a65726f2061646460448201527f726573730000000000000000000000000000000000000000000000000000000060648201526084016105bd565b6001600160a01b038216610e225760405162461bcd60e51b815260206004820152602260248201527f45524332303a20617070726f766520746f20746865207a65726f20616464726560448201527f737300000000000000000000000000000000000000000000000000000000000060648201526084016105bd565b6001600160a01b0383811660008181526001602090815260408083209487168084529482529182902085905590518481527f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925910160405180910390a3505050565b6001600160a01b0383811660009081526001602090815260408083209386168352929052205460001981146106a05781811015610f025760405162461bcd60e51b815260206004820152601d60248201527f45524332303a20696e73756666696369656e7420616c6c6f77616e636500000060448201526064016105bd565b6106a08484848403610d2b565b600554600090600160a81b900460ff1615610f3757610f2f84848461106f565b50600161076f565b6001600160a01b03841660009081526006602052604081205460ff16158015610f7957506001600160a01b03841660009081526006602052604090205460ff16155b905060008585610f8882610c34565b15610f9b57506001915085905086610fb7565b610fa487610c34565b15610fb25760029250610fb7565b600093505b610fbf611524565b15610fcc57610fcc6112d0565b600084610fd95786610fe3565b610fe38988611579565b9050610ff089898361106f565b8315611060577fe6f814da7244d1ae6c61b54b5684858ba39cad7b9a91884be10060664987d75483838987611023610776565b604080516001600160a01b03968716815295909416602086015292840191909152606083015260808201524260a082015260c00160405180910390a15b50600198975050505050505050565b6001600160a01b0383166110eb5760405162461bcd60e51b815260206004820152602560248201527f45524332303a207472616e736665722066726f6d20746865207a65726f20616460448201527f647265737300000000000000000000000000000000000000000000000000000060648201526084016105bd565b6001600160a01b0382166111675760405162461bcd60e51b815260206004820152602360248201527f45524332303a207472616e7366657220746f20746865207a65726f206164647260448201527f657373000000000000000000000000000000000000000000000000000000000060648201526084016105bd565b6001600160a01b038316600090815260208190526040902054818110156111f65760405162461bcd60e51b815260206004820152602660248201527f45524332303a207472616e7366657220616d6f756e742065786365656473206260448201527f616c616e6365000000000000000000000000000000000000000000000000000060648201526084016105bd565b6001600160a01b03848116600081815260208181526040808320878703905593871680835291849020805487019055925185815290927fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef910160405180910390a36106a0565b600061076f836001600160a01b0384166115b6565b600580546001600160a01b0383811673ffffffffffffffffffffffffffffffffffffffff19831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b6005805460ff60a81b1916600160a81b179055306000908152602081905260408120549050611320307f000000000000000000000000000000000000000000000000000000000000000083610d2b565b60408051600380825260808201909252600091602082016060803683370190505090503081600081518110611357576113576119a0565b60200260200101906001600160a01b031690816001600160a01b0316815250507f0000000000000000000000000000000000000000000000000000000000000000816001815181106113ab576113ab6119a0565b6001600160a01b039283166020918202929092010152600a548251911690829060029081106113dc576113dc6119a0565b6001600160a01b0392831660209182029290920101526009546040517f5c11d7950000000000000000000000000000000000000000000000000000000081526000927f0000000000000000000000000000000000000000000000000000000000000000811692635c11d795926114619288928792899291909116904290600401611a7e565b600060405180830381600087803b15801561147b57600080fd5b505af192505050801561148c575060015b15611495575060015b806114a2575050506114de565b604080518481524260208201527f05ab84b321981d7d9a13402e494604c50821bcb5f2400d128fa06cd6451113d4910160405180910390a15050505b6005805460ff60a81b19169055565b600061076f836001600160a01b038416611605565b6001600160a01b0381166000908152600183016020526040812054151561076f565b600554600090600160a81b900460ff1615801561154a5750600554600160a01b900460ff165b8015611563575030600090815260208190526040812054115b80156107dd575061157333610c34565b15905090565b6000806008546007548461158d9190611aef565b6115979190611b06565b90506115a484308361106f565b6115ae8184611a1f565b949350505050565b60008181526001830160205260408120546115fd5750815460018181018455600084815260208082209093018490558454848252828601909352604090209190915561074c565b50600061074c565b600081815260018301602052604081205480156116ee576000611629600183611a1f565b855490915060009061163d90600190611a1f565b90508181146116a257600086600001828154811061165d5761165d6119a0565b9060005260206000200154905080876000018481548110611680576116806119a0565b6000918252602080832090910192909255918252600188019052604090208390555b85548690806116b3576116b3611b28565b60019003818190600052602060002001600090559055856001016000868152602001908152602001600020600090556001935050505061074c565b600091505061074c565b634e487b7160e01b600052604160045260246000fd5b6001600160a01b0381168114610cce57600080fd5b8035610ab98161170e565b60008083601f84011261174057600080fd5b50813567ffffffffffffffff81111561175857600080fd5b6020830191508360208260051b850101111561177357600080fd5b9250929050565b60008060006040848603121561178f57600080fd5b833567ffffffffffffffff808211156117a757600080fd5b818601915086601f8301126117bb57600080fd5b81356020828211156117cf576117cf6116f8565b8160051b604051601f19603f830116810181811086821117156117f4576117f46116f8565b6040529283528481018201928281018b85111561181057600080fd5b958301955b848710156118335761182687611723565b8152958301958301611815565b509750508701359250508082111561184a57600080fd5b506118578682870161172e565b9497909650939450505050565b60005b8381101561187f578181015183820152602001611867565b50506000910152565b60208152600082518060208401526118a7816040850160208701611864565b601f01601f19169190910160400192915050565b600080604083850312156118ce57600080fd5b82356118d98161170e565b946020939093013593505050565b6000806000606084860312156118fc57600080fd5b83356119078161170e565b925060208401356119178161170e565b929592945050506040919091013590565b60006020828403121561193a57600080fd5b813561076f8161170e565b60006020828403121561195757600080fd5b8135801515811461076f57600080fd5b6000806040838503121561197a57600080fd5b82356119858161170e565b915060208301356119958161170e565b809150509250929050565b634e487b7160e01b600052603260045260246000fd5b634e487b7160e01b600052601160045260246000fd5b6000600182016119de576119de6119b6565b5060010190565b600181811c908216806119f957607f821691505b602082108103611a1957634e487b7160e01b600052602260045260246000fd5b50919050565b8181038181111561074c5761074c6119b6565b8082018082111561074c5761074c6119b6565b600060208284031215611a5757600080fd5b815161076f8161170e565b60008251611a74818460208701611864565b9190910192915050565b600060a082018783526020878185015260a0604085015281875180845260c086019150828901935060005b81811015611ace5784516001600160a01b031683529383019391830191600101611aa9565b50506001600160a01b03969096166060850152505050608001529392505050565b808202811582820484141761074c5761074c6119b6565b600082611b2357634e487b7160e01b600052601260045260246000fd5b500490565b634e487b7160e01b600052603160045260246000fdfea2646970667358221220a5e1704390bd0a3508a3c56ead1d6659763434fb318d6db6370858ec1945c42b64736f6c63430008130033000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec70000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d0000000000000000000000005c69bee701ef814a2b6a3edd4b1652cb9cc5aa6f000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2

0x6080604052600436106101bb5760003560e01c8063715018a6116100ec578063b8c611301161008a578063d830678611610064578063d8306786146104c1578063dd62ed3e146104e2578063e5e31b1314610528578063f2fde38b1461054857600080fd5b8063b8c611301461046c578063bfa382b51461048c578063c2b7bbb6146104a157600080fd5b806395d89b41116100c657806395d89b41146103f7578063a457c2d71461040c578063a5bc50851461042c578063a9059cbb1461044c57600080fd5b8063715018a6146103a55780638da5cb5b146103ba5780638fbbd750146103e257600080fd5b8063364333f4116101595780633f4218e0116101335780633f4218e0146103095780634fab9e4c146103395780636ddd17131461034e57806370a082311461036f57600080fd5b8063364333f4146102b457806339509351146102c95780633a98a91f146102e957600080fd5b806318160ddd1161019557806318160ddd1461024457806323b872dd146102635780632b112e4914610283578063313ce5671461029857600080fd5b80630421cefd146101c757806306fdde03146101e9578063095ea7b31461021457600080fd5b366101c257005b600080fd5b3480156101d357600080fd5b506101e76101e236600461177a565b610568565b005b3480156101f557600080fd5b506101fe6106a6565b60405161020b9190611888565b60405180910390f35b34801561022057600080fd5b5061023461022f3660046118bb565b610738565b604051901515815260200161020b565b34801561025057600080fd5b506002545b60405190815260200161020b565b34801561026f57600080fd5b5061023461027e3660046118e7565b610752565b34801561028f57600080fd5b50610255610776565b3480156102a457600080fd5b506040516012815260200161020b565b3480156102c057600080fd5b506101e76107e2565b3480156102d557600080fd5b506102346102e43660046118bb565b610806565b3480156102f557600080fd5b506101e7610304366004611928565b610845565b34801561031557600080fd5b50610234610324366004611928565b60066020526000908152604090205460ff1681565b34801561034557600080fd5b506101e761087c565b34801561035a57600080fd5b5060055461023490600160a01b900460ff1681565b34801561037b57600080fd5b5061025561038a366004611928565b6001600160a01b031660009081526020819052604090205490565b3480156103b157600080fd5b506101e7610965565b3480156103c657600080fd5b506005546040516001600160a01b03909116815260200161020b565b3480156103ee57600080fd5b506101e7610977565b34801561040357600080fd5b506101fe610987565b34801561041857600080fd5b506102346104273660046118bb565b610996565b34801561043857600080fd5b50610234610447366004611928565b610a4b565b34801561045857600080fd5b506102346104673660046118bb565b610abe565b34801561047857600080fd5b506101e7610487366004611945565b610acb565b34801561049857600080fd5b506101e7610b0c565b3480156104ad57600080fd5b506102346104bc366004611928565b610bc9565b3480156104cd57600080fd5b5060055461023490600160a81b900460ff1681565b3480156104ee57600080fd5b506102556104fd366004611967565b6001600160a01b03918216600090815260016020908152604080832093909416825291909152205490565b34801561053457600080fd5b50610234610543366004611928565b610c34565b34801561055457600080fd5b506101e7610563366004611928565b610c41565b610570610cd1565b60008351116105c65760405162461bcd60e51b815260206004820152601560248201527f4c6973742077616c6c65747320697320656d707479000000000000000000000060448201526064015b60405180910390fd5b806106135760405162461bcd60e51b815260206004820152601560248201527f4c697374206578656d70747320697320656d707479000000000000000000000060448201526064016105bd565b60005b83518110156106a057828282818110610631576106316119a0565b90506020020160208101906106469190611945565b6006600086848151811061065c5761065c6119a0565b6020908102919091018101516001600160a01b03168252810191909152604001600020805460ff191691151591909117905580610698816119cc565b915050610616565b50505050565b6060600380546106b5906119e5565b80601f01602080910402602001604051908101604052809291908181526020018280546106e1906119e5565b801561072e5780601f106107035761010080835404028352916020019161072e565b820191906000526020600020905b81548152906001019060200180831161071157829003601f168201915b5050505050905090565b600033610746818585610d2b565b60019150505b92915050565b600033610760858285610e83565b61076b858585610f0f565b9150505b9392505050565b600060208190527fad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb55461dead82527f44ad89ba62b98ff34f51403ac22759b55759460c0bb5521eb4b6ee3cff49cf83546002546107d39190611a1f565b6107dd9190611a1f565b905090565b6107ea610cd1565b61080430333060009081526020819052604090205461106f565b565b3360008181526001602090815260408083206001600160a01b03871684529091528120549091906107469082908690610840908790611a32565b610d2b565b61084d610cd1565b6009805473ffffffffffffffffffffffffffffffffffffffff19166001600160a01b0392909216919091179055565b610884610cd1565b6040517fc9c653960000000000000000000000000000000000000000000000000000000081526001600160a01b037f000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2811660048301523060248301526000917f0000000000000000000000005c69bee701ef814a2b6a3edd4b1652cb9cc5aa6f9091169063c9c65396906044016020604051808303816000875af1158015610930573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906109549190611a45565b9050610961600b8261125c565b5050565b61096d610cd1565b6108046000611271565b61097f610cd1565b6108046112d0565b6060600480546106b5906119e5565b3360008181526001602090815260408083206001600160a01b038716845290915281205490919083811015610a335760405162461bcd60e51b815260206004820152602560248201527f45524332303a2064656372656173656420616c6c6f77616e63652062656c6f7760448201527f207a65726f00000000000000000000000000000000000000000000000000000060648201526084016105bd565b610a408286868403610d2b565b506001949350505050565b6000610a55610cd1565b6001600160a01b038216610aab5760405162461bcd60e51b815260206004820152601e60248201527f545245583a207061697220697320746865207a65726f2061646472657373000060448201526064016105bd565b610ab6600b836114ed565b90505b919050565b600061076f338484610f0f565b610ad3610cd1565b60058054911515600160a01b027fffffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffff909216919091179055565b610b14610cd1565b60408051600080825260208201928390524792909133918491610b3691611a62565b60006040518083038185875af1925050503d8060008114610b73576040519150601f19603f3d011682016040523d82523d6000602084013e610b78565b606091505b50509050806109615760405162461bcd60e51b815260206004820152601960248201527f545245583a204554485f5452414e534645525f4641494c45440000000000000060448201526064016105bd565b6000610bd3610cd1565b6001600160a01b038216610c295760405162461bcd60e51b815260206004820152601e60248201527f545245583a207061697220697320746865207a65726f2061646472657373000060448201526064016105bd565b610ab6600b8361125c565b6000610ab6600b83611502565b610c49610cd1565b6001600160a01b038116610cc55760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201527f646472657373000000000000000000000000000000000000000000000000000060648201526084016105bd565b610cce81611271565b50565b6005546001600160a01b031633146108045760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016105bd565b6001600160a01b038316610da65760405162461bcd60e51b8152602060048201526024808201527f45524332303a20617070726f76652066726f6d20746865207a65726f2061646460448201527f726573730000000000000000000000000000000000000000000000000000000060648201526084016105bd565b6001600160a01b038216610e225760405162461bcd60e51b815260206004820152602260248201527f45524332303a20617070726f766520746f20746865207a65726f20616464726560448201527f737300000000000000000000000000000000000000000000000000000000000060648201526084016105bd565b6001600160a01b0383811660008181526001602090815260408083209487168084529482529182902085905590518481527f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925910160405180910390a3505050565b6001600160a01b0383811660009081526001602090815260408083209386168352929052205460001981146106a05781811015610f025760405162461bcd60e51b815260206004820152601d60248201527f45524332303a20696e73756666696369656e7420616c6c6f77616e636500000060448201526064016105bd565b6106a08484848403610d2b565b600554600090600160a81b900460ff1615610f3757610f2f84848461106f565b50600161076f565b6001600160a01b03841660009081526006602052604081205460ff16158015610f7957506001600160a01b03841660009081526006602052604090205460ff16155b905060008585610f8882610c34565b15610f9b57506001915085905086610fb7565b610fa487610c34565b15610fb25760029250610fb7565b600093505b610fbf611524565b15610fcc57610fcc6112d0565b600084610fd95786610fe3565b610fe38988611579565b9050610ff089898361106f565b8315611060577fe6f814da7244d1ae6c61b54b5684858ba39cad7b9a91884be10060664987d75483838987611023610776565b604080516001600160a01b03968716815295909416602086015292840191909152606083015260808201524260a082015260c00160405180910390a15b50600198975050505050505050565b6001600160a01b0383166110eb5760405162461bcd60e51b815260206004820152602560248201527f45524332303a207472616e736665722066726f6d20746865207a65726f20616460448201527f647265737300000000000000000000000000000000000000000000000000000060648201526084016105bd565b6001600160a01b0382166111675760405162461bcd60e51b815260206004820152602360248201527f45524332303a207472616e7366657220746f20746865207a65726f206164647260448201527f657373000000000000000000000000000000000000000000000000000000000060648201526084016105bd565b6001600160a01b038316600090815260208190526040902054818110156111f65760405162461bcd60e51b815260206004820152602660248201527f45524332303a207472616e7366657220616d6f756e742065786365656473206260448201527f616c616e6365000000000000000000000000000000000000000000000000000060648201526084016105bd565b6001600160a01b03848116600081815260208181526040808320878703905593871680835291849020805487019055925185815290927fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef910160405180910390a36106a0565b600061076f836001600160a01b0384166115b6565b600580546001600160a01b0383811673ffffffffffffffffffffffffffffffffffffffff19831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b6005805460ff60a81b1916600160a81b179055306000908152602081905260408120549050611320307f0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d83610d2b565b60408051600380825260808201909252600091602082016060803683370190505090503081600081518110611357576113576119a0565b60200260200101906001600160a01b031690816001600160a01b0316815250507f000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2816001815181106113ab576113ab6119a0565b6001600160a01b039283166020918202929092010152600a548251911690829060029081106113dc576113dc6119a0565b6001600160a01b0392831660209182029290920101526009546040517f5c11d7950000000000000000000000000000000000000000000000000000000081526000927f0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d811692635c11d795926114619288928792899291909116904290600401611a7e565b600060405180830381600087803b15801561147b57600080fd5b505af192505050801561148c575060015b15611495575060015b806114a2575050506114de565b604080518481524260208201527f05ab84b321981d7d9a13402e494604c50821bcb5f2400d128fa06cd6451113d4910160405180910390a15050505b6005805460ff60a81b19169055565b600061076f836001600160a01b038416611605565b6001600160a01b0381166000908152600183016020526040812054151561076f565b600554600090600160a81b900460ff1615801561154a5750600554600160a01b900460ff165b8015611563575030600090815260208190526040812054115b80156107dd575061157333610c34565b15905090565b6000806008546007548461158d9190611aef565b6115979190611b06565b90506115a484308361106f565b6115ae8184611a1f565b949350505050565b60008181526001830160205260408120546115fd5750815460018181018455600084815260208082209093018490558454848252828601909352604090209190915561074c565b50600061074c565b600081815260018301602052604081205480156116ee576000611629600183611a1f565b855490915060009061163d90600190611a1f565b90508181146116a257600086600001828154811061165d5761165d6119a0565b9060005260206000200154905080876000018481548110611680576116806119a0565b6000918252602080832090910192909255918252600188019052604090208390555b85548690806116b3576116b3611b28565b60019003818190600052602060002001600090559055856001016000868152602001908152602001600020600090556001935050505061074c565b600091505061074c565b634e487b7160e01b600052604160045260246000fd5b6001600160a01b0381168114610cce57600080fd5b8035610ab98161170e565b60008083601f84011261174057600080fd5b50813567ffffffffffffffff81111561175857600080fd5b6020830191508360208260051b850101111561177357600080fd5b9250929050565b60008060006040848603121561178f57600080fd5b833567ffffffffffffffff808211156117a757600080fd5b818601915086601f8301126117bb57600080fd5b81356020828211156117cf576117cf6116f8565b8160051b604051601f19603f830116810181811086821117156117f4576117f46116f8565b6040529283528481018201928281018b85111561181057600080fd5b958301955b848710156118335761182687611723565b8152958301958301611815565b509750508701359250508082111561184a57600080fd5b506118578682870161172e565b9497909650939450505050565b60005b8381101561187f578181015183820152602001611867565b50506000910152565b60208152600082518060208401526118a7816040850160208701611864565b601f01601f19169190910160400192915050565b600080604083850312156118ce57600080fd5b82356118d98161170e565b946020939093013593505050565b6000806000606084860312156118fc57600080fd5b83356119078161170e565b925060208401356119178161170e565b929592945050506040919091013590565b60006020828403121561193a57600080fd5b813561076f8161170e565b60006020828403121561195757600080fd5b8135801515811461076f57600080fd5b6000806040838503121561197a57600080fd5b82356119858161170e565b915060208301356119958161170e565b809150509250929050565b634e487b7160e01b600052603260045260246000fd5b634e487b7160e01b600052601160045260246000fd5b6000600182016119de576119de6119b6565b5060010190565b600181811c908216806119f957607f821691505b602082108103611a1957634e487b7160e01b600052602260045260246000fd5b50919050565b8181038181111561074c5761074c6119b6565b8082018082111561074c5761074c6119b6565b600060208284031215611a5757600080fd5b815161076f8161170e565b60008251611a74818460208701611864565b9190910192915050565b600060a082018783526020878185015260a0604085015281875180845260c086019150828901935060005b81811015611ace5784516001600160a01b031683529383019391830191600101611aa9565b50506001600160a01b03969096166060850152505050608001529392505050565b808202811582820484141761074c5761074c6119b6565b600082611b2357634e487b7160e01b600052601260045260246000fd5b500490565b634e487b7160e01b600052603160045260246000fdfea2646970667358221220a5e1704390bd0a3508a3c56ead1d6659763434fb318d6db6370858ec1945c42b64736f6c63430008130033

000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec70000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d0000000000000000000000005c69bee701ef814a2b6a3edd4b1652cb9cc5aa6f000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2

-----Decoded View---------------
Arg [0] : _backToken (address): 0xdAC17F958D2ee523a2206206994597C13D831ec7
Arg [1] : _swapRouter (address): 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
Arg [2] : _factory (address): 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f
Arg [3] : _weth (address): 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec7
Arg [1] : 0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d
Arg [2] : 0000000000000000000000005c69bee701ef814a2b6a3edd4b1652cb9cc5aa6f
Arg [3] : 000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2

52663:6159:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57986:311;;;;;;;;;;-1:-1:-1;57986:311:0;;;;;:::i;:::-;;:::i;:::-;;6598:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8949:201;;;;;;;;;;-1:-1:-1;8949:201:0;;;;;:::i;:::-;;:::i;:::-;;;3448:14:1;;3441:22;3423:41;;3411:2;3396:18;8949:201:0;3283:187:1;7718:108:0;;;;;;;;;;-1:-1:-1;7806:12:0;;7718:108;;;3621:25:1;;;3609:2;3594:18;7718:108:0;3475:177:1;54527:274:0;;;;;;;;;;-1:-1:-1;54527:274:0;;;;;:::i;:::-;;:::i;56942:137::-;;;;;;;;;;;;;:::i;54264:93::-;;;;;;;;;;-1:-1:-1;54264:93:0;;54347:2;4260:36:1;;4248:2;4233:18;54264:93:0;4118:184:1;57661:131:0;;;;;;;;;;;;;:::i;10434:238::-;;;;;;;;;;-1:-1:-1;10434:238:0;;;;;:::i;:::-;;:::i;57876:102::-;;;;;;;;;;-1:-1:-1;57876:102:0;;;;;:::i;:::-;;:::i;53125:43::-;;;;;;;;;;-1:-1:-1;53125:43:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;57236:154;;;;;;;;;;;;;:::i;52962:30::-;;;;;;;;;;-1:-1:-1;52962:30:0;;;;-1:-1:-1;;;52962:30:0;;;;;;7889:127;;;;;;;;;;-1:-1:-1;7889:127:0;;;;;:::i;:::-;-1:-1:-1;;;;;7990:18:0;7963:7;7990:18;;;;;;;;;;;;7889:127;35954:103;;;;;;;;;;;;;:::i;35306:87::-;;;;;;;;;;-1:-1:-1;35379:6:0;;35306:87;;-1:-1:-1;;;;;35379:6:0;;;4705:74:1;;4693:2;4678:18;35306:87:0;4559:226:1;57800:68:0;;;;;;;;;;;;;:::i;6817:104::-;;;;;;;;;;;;;:::i;11175:436::-;;;;;;;;;;-1:-1:-1;11175:436:0;;;;;:::i;:::-;;:::i;58602:180::-;;;;;;;;;;-1:-1:-1;58602:180:0;;;;;:::i;:::-;;:::i;54365:154::-;;;;;;;;;;-1:-1:-1;54365:154:0;;;;;:::i;:::-;;:::i;58305:104::-;;;;;;;;;;-1:-1:-1;58305:104:0;;;;;:::i;:::-;;:::i;57398:255::-;;;;;;;;;;;;;:::i;58417:177::-;;;;;;;;;;-1:-1:-1;58417:177:0;;;;;:::i;:::-;;:::i;53001:18::-;;;;;;;;;;-1:-1:-1;53001:18:0;;;;-1:-1:-1;;;53001:18:0;;;;;;8478:151;;;;;;;;;;-1:-1:-1;8478:151:0;;;;;:::i;:::-;-1:-1:-1;;;;;8594:18:0;;;8567:7;8594:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;8478:151;57087:110;;;;;;;;;;-1:-1:-1;57087:110:0;;;;;:::i;:::-;;:::i;36212:201::-;;;;;;;;;;-1:-1:-1;36212:201:0;;;;;:::i;:::-;;:::i;57986:311::-;35192:13;:11;:13::i;:::-;58101:1:::1;58089:2;:9;:13;58081:47;;;::::0;-1:-1:-1;;;58081:47:0;;5663:2:1;58081:47:0::1;::::0;::::1;5645:21:1::0;5702:2;5682:18;;;5675:30;5741:23;5721:18;;;5714:51;5782:18;;58081:47:0::1;;;;;;;;;58147:13:::0;58139:47:::1;;;::::0;-1:-1:-1;;;58139:47:0;;6013:2:1;58139:47:0::1;::::0;::::1;5995:21:1::0;6052:2;6032:18;;;6025:30;6091:23;6071:18;;;6064:51;6132:18;;58139:47:0::1;5811:345:1::0;58139:47:0::1;58202:9;58197:93;58221:2;:9;58217:1;:13;58197:93;;;58273:2;;58276:1;58273:5;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;58252:11;:18;58264:2;58267:1;58264:5;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;;;-1:-1:-1;;;;;58252:18:0::1;::::0;;;::::1;::::0;;;;;;-1:-1:-1;58252:18:0;:26;;-1:-1:-1;;58252:26:0::1;::::0;::::1;;::::0;;;::::1;::::0;;58232:3;::::1;::::0;::::1;:::i;:::-;;;;58197:93;;;;57986:311:::0;;;:::o;6598:100::-;6652:13;6685:5;6678:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6598:100;:::o;8949:201::-;9032:4;4324:10;9088:32;4324:10;9104:7;9113:6;9088:8;:32::i;:::-;9138:4;9131:11;;;8949:201;;;;;:::o;54527:274::-;54633:4;4324:10;54691:40;54707:6;4324:10;54724:6;54691:15;:40::i;:::-;54749:44;54767:6;54775:9;54786:6;54749:17;:44::i;:::-;54742:51;;;54527:274;;;;;;:::o;56942:137::-;56995:7;7990:18;;;;;;53530:42;7990:18;;;;7806:12;;57022:31;;7990:18;57022:31;:::i;:::-;:49;;;;:::i;:::-;57015:56;;56942:137;:::o;57661:131::-;35192:13;:11;:13::i;:::-;57720:64:::1;57738:4;4324:10:::0;57777:4:::1;7963:7:::0;7990:18;;;;;;;;;;;57720:9:::1;:64::i;:::-;57661:131::o:0;10434:238::-;4324:10;10522:4;8594:18;;;:11;:18;;;;;;;;-1:-1:-1;;;;;8594:27:0;;;;;;;;;;10522:4;;4324:10;10578:64;;4324:10;;8594:27;;10603:38;;10631:10;;10603:38;:::i;:::-;10578:8;:64::i;57876:102::-;35192:13;:11;:13::i;:::-;57948:9:::1;:22:::0;;-1:-1:-1;;57948:22:0::1;-1:-1:-1::0;;;;;57948:22:0;;;::::1;::::0;;;::::1;::::0;;57876:102::o;57236:154::-;35192:13;:11;:13::i;:::-;57307:48:::1;::::0;;;;-1:-1:-1;;;;;57334:4:0::1;7637:15:1::0;;57307:48:0::1;::::0;::::1;7619:34:1::0;57349:4:0::1;7669:18:1::0;;;7662:43;-1:-1:-1;;57307:7:0::1;:18:::0;;::::1;::::0;::::1;::::0;7531::1;;57307:48:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57292:63:::0;-1:-1:-1;57366:16:0::1;:6;57292:63:::0;57366:10:::1;:16::i;:::-;;57281:109;57236:154::o:0;35954:103::-;35192:13;:11;:13::i;:::-;36019:30:::1;36046:1;36019:18;:30::i;57800:68::-:0;35192:13;:11;:13::i;:::-;57850:10:::1;:8;:10::i;6817:104::-:0;6873:13;6906:7;6899:14;;;;;:::i;11175:436::-;4324:10;11268:4;8594:18;;;:11;:18;;;;;;;;-1:-1:-1;;;;;8594:27:0;;;;;;;;;;11268:4;;4324:10;11415:15;11395:16;:35;;11387:85;;;;-1:-1:-1;;;11387:85:0;;8174:2:1;11387:85:0;;;8156:21:1;8213:2;8193:18;;;8186:30;8252:34;8232:18;;;8225:62;8323:7;8303:18;;;8296:35;8348:19;;11387:85:0;7972:401:1;11387:85:0;11508:60;11517:5;11524:7;11552:15;11533:16;:34;11508:8;:60::i;:::-;-1:-1:-1;11599:4:0;;11175:436;-1:-1:-1;;;;11175:436:0:o;58602:180::-;58659:4;35192:13;:11;:13::i;:::-;-1:-1:-1;;;;;58684:18:0;::::1;58676:61;;;::::0;-1:-1:-1;;;58676:61:0;;8580:2:1;58676:61:0::1;::::0;::::1;8562:21:1::0;8619:2;8599:18;;;8592:30;8658:32;8638:18;;;8631:60;8708:18;;58676:61:0::1;8378:354:1::0;58676:61:0::1;58755:19;:6;58769:4:::0;58755:13:::1;:19::i;:::-;58748:26;;35216:1;58602:180:::0;;;:::o;54365:154::-;54444:4;54468:43;4324:10;54500:2;54504:6;54468:17;:43::i;58305:104::-;35192:13;:11;:13::i;:::-;58379:11:::1;:22:::0;;;::::1;;-1:-1:-1::0;;;58379:22:0::1;::::0;;;::::1;::::0;;;::::1;::::0;;58305:104::o;57398:255::-;35192:13;:11;:13::i;:::-;57576:12:::1;::::0;;57460:17:::1;57576:12:::0;;;::::1;::::0;::::1;::::0;;;;57480:21:::1;::::0;57460:17;;4324:10;;57480:21;;57531:58:::1;::::0;::::1;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57512:77;;;57608:7;57600:45;;;::::0;-1:-1:-1;;;57600:45:0;;9231:2:1;57600:45:0::1;::::0;::::1;9213:21:1::0;9270:2;9250:18;;;9243:30;9309:27;9289:18;;;9282:55;9354:18;;57600:45:0::1;9029:349:1::0;58417:177:0;58474:4;35192:13;:11;:13::i;:::-;-1:-1:-1;;;;;58499:18:0;::::1;58491:61;;;::::0;-1:-1:-1;;;58491:61:0;;8580:2:1;58491:61:0::1;::::0;::::1;8562:21:1::0;8619:2;8599:18;;;8592:30;8658:32;8638:18;;;8631:60;8708:18;;58491:61:0::1;8378:354:1::0;58491:61:0::1;58570:16;:6;58581:4:::0;58570:10:::1;:16::i;57087:110::-:0;57141:4;57165:24;:6;57181:7;57165:15;:24::i;36212:201::-;35192:13;:11;:13::i;:::-;-1:-1:-1;;;;;36301:22:0;::::1;36293:73;;;::::0;-1:-1:-1;;;36293:73:0;;9585:2:1;36293:73:0::1;::::0;::::1;9567:21:1::0;9624:2;9604:18;;;9597:30;9663:34;9643:18;;;9636:62;9734:8;9714:18;;;9707:36;9760:19;;36293:73:0::1;9383:402:1::0;36293:73:0::1;36377:28;36396:8;36377:18;:28::i;:::-;36212:201:::0;:::o;35471:132::-;35379:6;;-1:-1:-1;;;;;35379:6:0;4324:10;35535:23;35527:68;;;;-1:-1:-1;;;35527:68:0;;9992:2:1;35527:68:0;;;9974:21:1;;;10011:18;;;10004:30;10070:34;10050:18;;;10043:62;10122:18;;35527:68:0;9790:356:1;15202:380:0;-1:-1:-1;;;;;15338:19:0;;15330:68;;;;-1:-1:-1;;;15330:68:0;;10353:2:1;15330:68:0;;;10335:21:1;10392:2;10372:18;;;10365:30;10431:34;10411:18;;;10404:62;10502:6;10482:18;;;10475:34;10526:19;;15330:68:0;10151:400:1;15330:68:0;-1:-1:-1;;;;;15417:21:0;;15409:68;;;;-1:-1:-1;;;15409:68:0;;10758:2:1;15409:68:0;;;10740:21:1;10797:2;10777:18;;;10770:30;10836:34;10816:18;;;10809:62;10907:4;10887:18;;;10880:32;10929:19;;15409:68:0;10556:398:1;15409:68:0;-1:-1:-1;;;;;15490:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;15542:32;;3621:25:1;;;15542:32:0;;3594:18:1;15542:32:0;;;;;;;15202:380;;;:::o;15873:453::-;-1:-1:-1;;;;;8594:18:0;;;16008:24;8594:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;-1:-1:-1;;16075:37:0;;16071:248;;16157:6;16137:16;:26;;16129:68;;;;-1:-1:-1;;;16129:68:0;;11161:2:1;16129:68:0;;;11143:21:1;11200:2;11180:18;;;11173:30;11239:31;11219:18;;;11212:59;11288:18;;16129:68:0;10959:353:1;16129:68:0;16241:51;16250:5;16257:7;16285:6;16266:16;:25;16241:8;:51::i;54809:1021::-;54926:6;;54905:4;;-1:-1:-1;;;54926:6:0;;;;54922:101;;;54949:36;54959:6;54967:9;54978:6;54949:9;:36::i;:::-;-1:-1:-1;55007:4:0;55000:11;;54922:101;-1:-1:-1;;;;;55058:19:0;;55035:18;55058:19;;;:11;:19;;;;;;;;55057:20;:47;;;;-1:-1:-1;;;;;;55082:22:0;;;;;;:11;:22;;;;;;;;55081:23;55057:47;55035:70;-1:-1:-1;55116:9:0;55156:6;55189:9;55215:14;55156:6;55215;:14::i;:::-;55211:234;;;-1:-1:-1;55253:1:0;;-1:-1:-1;55277:9:0;;-1:-1:-1;55309:6:0;55211:234;;;55337:17;55344:9;55337:6;:17::i;:::-;55333:112;;;55378:1;55371:8;;55333:112;;;55428:5;55412:21;;55333:112;55461:16;:14;:16::i;:::-;55457:59;;;55494:10;:8;:10::i;:::-;55528:22;55553:13;:48;;55595:6;55553:48;;;55569:23;55577:6;55585;55569:7;:23::i;:::-;55528:73;;55622:44;55632:6;55640:9;55651:14;55622:9;:44::i;:::-;55683:8;;55679:120;;55713:74;55719:5;55726;55733:6;55741:4;55747:22;:20;:22::i;:::-;55713:74;;;-1:-1:-1;;;;;11683:15:1;;;11665:34;;11735:15;;;;11730:2;11715:18;;11708:43;11767:18;;;11760:34;;;;11825:2;11810:18;;11803:34;11868:3;11853:19;;11846:35;55771:15:0;11912:3:1;11897:19;;11890:35;11591:3;11576:19;55713:74:0;;;;;;;55679:120;-1:-1:-1;55818:4:0;;54809:1021;-1:-1:-1;;;;;;;;54809:1021:0:o;12081:840::-;-1:-1:-1;;;;;12212:18:0;;12204:68;;;;-1:-1:-1;;;12204:68:0;;12138:2:1;12204:68:0;;;12120:21:1;12177:2;12157:18;;;12150:30;12216:34;12196:18;;;12189:62;12287:7;12267:18;;;12260:35;12312:19;;12204:68:0;11936:401:1;12204:68:0;-1:-1:-1;;;;;12291:16:0;;12283:64;;;;-1:-1:-1;;;12283:64:0;;12544:2:1;12283:64:0;;;12526:21:1;12583:2;12563:18;;;12556:30;12622:34;12602:18;;;12595:62;12693:5;12673:18;;;12666:33;12716:19;;12283:64:0;12342:399:1;12283:64:0;-1:-1:-1;;;;;12433:15:0;;12411:19;12433:15;;;;;;;;;;;12467:21;;;;12459:72;;;;-1:-1:-1;;;12459:72:0;;12948:2:1;12459:72:0;;;12930:21:1;12987:2;12967:18;;;12960:30;13026:34;13006:18;;;12999:62;13097:8;13077:18;;;13070:36;13123:19;;12459:72:0;12746:402:1;12459:72:0;-1:-1:-1;;;;;12567:15:0;;;:9;:15;;;;;;;;;;;12585:20;;;12567:38;;12785:13;;;;;;;;;;:23;;;;;;12837:26;;3621:25:1;;;12785:13:0;;12837:26;;3594:18:1;12837:26:0;;;;;;;12876:37;16926:125;45345:152;45415:4;45439:50;45444:3;-1:-1:-1;;;;;45464:23:0;;45439:4;:50::i;36573:191::-;36666:6;;;-1:-1:-1;;;;;36683:17:0;;;-1:-1:-1;;36683:17:0;;;;;;;36716:40;;36666:6;;;36683:17;36666:6;;36716:40;;36647:16;;36716:40;36636:128;36573:191;:::o;56006:675::-;53059:6;:13;;-1:-1:-1;;;;53059:13:0;-1:-1:-1;;;53059:13:0;;;56093:4:::1;-1:-1:-1::0;7990:18:0;;;;;;;;;;;56055:44:::1;;56120:55;56137:4;56152:10;56165:9;56120:8;:55::i;:::-;56212:16;::::0;;56226:1:::1;56212:16:::0;;;;;::::1;::::0;;;56188:21:::1;::::0;56212:16:::1;::::0;::::1;::::0;;::::1;::::0;::::1;;::::0;-1:-1:-1;56212:16:0::1;56188:40;;56260:4;56242;56247:1;56242:7;;;;;;;;:::i;:::-;;;;;;:23;-1:-1:-1::0;;;;;56242:23:0::1;;;-1:-1:-1::0;;;;;56242:23:0::1;;;::::0;::::1;56294:4;56276;56281:1;56276:7;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;56276:23:0;;::::1;:7;::::0;;::::1;::::0;;;;;:23;56328:9:::1;::::0;56310:7;;56328:9;::::1;::::0;56310:4;;56315:1:::1;::::0;56310:7;::::1;;;;;:::i;:::-;-1:-1:-1::0;;;;;56310:28:0;;::::1;:7;::::0;;::::1;::::0;;;;;:28;56473:9:::1;::::0;56388:112:::1;::::0;;;;56351:12:::1;::::0;56388:10:::1;:64:::0;::::1;::::0;::::1;::::0;:112:::1;::::0;56453:9;;56351:12;;56467:4;;56473:9;;;::::1;::::0;56484:15:::1;::::0;56388:112:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;56384:177:::0;::::1;;-1:-1:-1::0;56526:4:0::1;56384:177;56578:7;56573:47;;56602:7;;;;;56573:47;56637:36;::::0;;14358:25:1;;;56657:15:0::1;14414:2:1::0;14399:18;;14392:34;56637:36:0::1;::::0;14331:18:1;56637:36:0::1;;;;;;;56044:637;;;53083:1;53095:6:::0;:14;;-1:-1:-1;;;;53095:14:0;;;56006:675::o;45673:158::-;45746:4;45770:53;45778:3;-1:-1:-1;;;;;45798:23:0;;45770:7;:53::i;45917:167::-;-1:-1:-1;;;;;46051:23:0;;45997:4;41269:19;;;:12;;;:19;;;;;;:24;;46021:55;41172:129;55838:160;55912:6;;55887:4;;-1:-1:-1;;;55912:6:0;;;;55911:7;:22;;;;-1:-1:-1;55922:11:0;;-1:-1:-1;;;55922:11:0;;;;55911:22;:54;;;;-1:-1:-1;55955:4:0;55964:1;7990:18;;;;;;;;;;;55937:28;55911:54;:79;;;;-1:-1:-1;55970:20:0;4324:10;57087:110;:::i;55970:20::-;55969:21;55904:86;;55838:160;:::o;56693:241::-;56760:7;56780:17;56822:14;;56810:8;;56801:6;:17;;;;:::i;:::-;56800:36;;;;:::i;:::-;56780:56;;56847:43;56857:6;56873:4;56880:9;56847;:43::i;:::-;56908:18;56917:9;56908:6;:18;:::i;:::-;56901:25;56693:241;-1:-1:-1;;;;56693:241:0:o;39076:414::-;39139:4;41269:19;;;:12;;;:19;;;;;;39156:327;;-1:-1:-1;39199:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;39382:18;;39360:19;;;:12;;;:19;;;;;;:40;;;;39415:11;;39156:327;-1:-1:-1;39466:5:0;39459:12;;39666:1420;39732:4;39871:19;;;:12;;;:19;;;;;;39907:15;;39903:1176;;40282:21;40306:14;40319:1;40306:10;:14;:::i;:::-;40355:18;;40282:38;;-1:-1:-1;40335:17:0;;40355:22;;40376:1;;40355:22;:::i;:::-;40335:42;;40411:13;40398:9;:26;40394:405;;40445:17;40465:3;:11;;40477:9;40465:22;;;;;;;;:::i;:::-;;;;;;;;;40445:42;;40619:9;40590:3;:11;;40602:13;40590:26;;;;;;;;:::i;:::-;;;;;;;;;;;;:38;;;;40704:23;;;:12;;;:23;;;;;:36;;;40394:405;40880:17;;:3;;:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;40975:3;:12;;:19;40988:5;40975:19;;;;;;;;;;;40968:26;;;41018:4;41011:11;;;;;;;39903:1176;41062:5;41055:12;;;;;14:184:1;-1:-1:-1;;;63:1:1;56:88;163:4;160:1;153:15;187:4;184:1;177:15;203:154;-1:-1:-1;;;;;282:5:1;278:54;271:5;268:65;258:93;;347:1;344;337:12;362:134;430:20;;459:31;430:20;459:31;:::i;501:364::-;561:8;571:6;625:3;618:4;610:6;606:17;602:27;592:55;;643:1;640;633:12;592:55;-1:-1:-1;666:20:1;;709:18;698:30;;695:50;;;741:1;738;731:12;695:50;778:4;770:6;766:17;754:29;;838:3;831:4;821:6;818:1;814:14;806:6;802:27;798:38;795:47;792:67;;;855:1;852;845:12;792:67;501:364;;;;;:::o;870:1432::-;987:6;995;1003;1056:2;1044:9;1035:7;1031:23;1027:32;1024:52;;;1072:1;1069;1062:12;1024:52;1112:9;1099:23;1141:18;1182:2;1174:6;1171:14;1168:34;;;1198:1;1195;1188:12;1168:34;1236:6;1225:9;1221:22;1211:32;;1281:7;1274:4;1270:2;1266:13;1262:27;1252:55;;1303:1;1300;1293:12;1252:55;1339:2;1326:16;1361:4;1384:2;1380;1377:10;1374:36;;;1390:18;;:::i;:::-;1436:2;1433:1;1429:10;1468:2;1462:9;1531:2;1527:7;1522:2;1518;1514:11;1510:25;1502:6;1498:38;1586:6;1574:10;1571:22;1566:2;1554:10;1551:18;1548:46;1545:72;;;1597:18;;:::i;:::-;1633:2;1626:22;1683:18;;;1759:11;;;1755:20;;;1717:15;;;1787:19;;;1784:39;;;1819:1;1816;1809:12;1784:39;1843:11;;;;1863:148;1879:6;1874:3;1871:15;1863:148;;;1945:23;1964:3;1945:23;:::i;:::-;1933:36;;1896:12;;;;1989;;1863:148;;;-1:-1:-1;2030:6:1;-1:-1:-1;;2074:18:1;;2061:32;;-1:-1:-1;;2105:16:1;;;2102:36;;;2134:1;2131;2124:12;2102:36;;2173:69;2234:7;2223:8;2212:9;2208:24;2173:69;:::i;:::-;870:1432;;2261:8;;-1:-1:-1;2147:95:1;;-1:-1:-1;;;;870:1432:1:o;2307:250::-;2392:1;2402:113;2416:6;2413:1;2410:13;2402:113;;;2492:11;;;2486:18;2473:11;;;2466:39;2438:2;2431:10;2402:113;;;-1:-1:-1;;2549:1:1;2531:16;;2524:27;2307:250::o;2562:396::-;2711:2;2700:9;2693:21;2674:4;2743:6;2737:13;2786:6;2781:2;2770:9;2766:18;2759:34;2802:79;2874:6;2869:2;2858:9;2854:18;2849:2;2841:6;2837:15;2802:79;:::i;:::-;2942:2;2921:15;-1:-1:-1;;2917:29:1;2902:45;;;;2949:2;2898:54;;2562:396;-1:-1:-1;;2562:396:1:o;2963:315::-;3031:6;3039;3092:2;3080:9;3071:7;3067:23;3063:32;3060:52;;;3108:1;3105;3098:12;3060:52;3147:9;3134:23;3166:31;3191:5;3166:31;:::i;:::-;3216:5;3268:2;3253:18;;;;3240:32;;-1:-1:-1;;;2963:315:1:o;3657:456::-;3734:6;3742;3750;3803:2;3791:9;3782:7;3778:23;3774:32;3771:52;;;3819:1;3816;3809:12;3771:52;3858:9;3845:23;3877:31;3902:5;3877:31;:::i;:::-;3927:5;-1:-1:-1;3984:2:1;3969:18;;3956:32;3997:33;3956:32;3997:33;:::i;:::-;3657:456;;4049:7;;-1:-1:-1;;;4103:2:1;4088:18;;;;4075:32;;3657:456::o;4307:247::-;4366:6;4419:2;4407:9;4398:7;4394:23;4390:32;4387:52;;;4435:1;4432;4425:12;4387:52;4474:9;4461:23;4493:31;4518:5;4493:31;:::i;4790:273::-;4846:6;4899:2;4887:9;4878:7;4874:23;4870:32;4867:52;;;4915:1;4912;4905:12;4867:52;4954:9;4941:23;5007:5;5000:13;4993:21;4986:5;4983:32;4973:60;;5029:1;5026;5019:12;5068:388;5136:6;5144;5197:2;5185:9;5176:7;5172:23;5168:32;5165:52;;;5213:1;5210;5203:12;5165:52;5252:9;5239:23;5271:31;5296:5;5271:31;:::i;:::-;5321:5;-1:-1:-1;5378:2:1;5363:18;;5350:32;5391:33;5350:32;5391:33;:::i;:::-;5443:7;5433:17;;;5068:388;;;;;:::o;6161:184::-;-1:-1:-1;;;6210:1:1;6203:88;6310:4;6307:1;6300:15;6334:4;6331:1;6324:15;6350:184;-1:-1:-1;;;6399:1:1;6392:88;6499:4;6496:1;6489:15;6523:4;6520:1;6513:15;6539:135;6578:3;6599:17;;;6596:43;;6619:18;;:::i;:::-;-1:-1:-1;6666:1:1;6655:13;;6539:135::o;6679:437::-;6758:1;6754:12;;;;6801;;;6822:61;;6876:4;6868:6;6864:17;6854:27;;6822:61;6929:2;6921:6;6918:14;6898:18;6895:38;6892:218;;-1:-1:-1;;;6963:1:1;6956:88;7067:4;7064:1;7057:15;7095:4;7092:1;7085:15;6892:218;;6679:437;;;:::o;7121:128::-;7188:9;;;7209:11;;;7206:37;;;7223:18;;:::i;7254:125::-;7319:9;;;7340:10;;;7337:36;;;7353:18;;:::i;7716:251::-;7786:6;7839:2;7827:9;7818:7;7814:23;7810:32;7807:52;;;7855:1;7852;7845:12;7807:52;7887:9;7881:16;7906:31;7931:5;7906:31;:::i;8737:287::-;8866:3;8904:6;8898:13;8920:66;8979:6;8974:3;8967:4;8959:6;8955:17;8920:66;:::i;:::-;9002:16;;;;;8737:287;-1:-1:-1;;8737:287:1:o;13153:1026::-;13415:4;13463:3;13452:9;13448:19;13494:6;13483:9;13476:25;13520:2;13558:6;13553:2;13542:9;13538:18;13531:34;13601:3;13596:2;13585:9;13581:18;13574:31;13625:6;13660;13654:13;13691:6;13683;13676:22;13729:3;13718:9;13714:19;13707:26;;13768:2;13760:6;13756:15;13742:29;;13789:1;13799:218;13813:6;13810:1;13807:13;13799:218;;;13878:13;;-1:-1:-1;;;;;13874:62:1;13862:75;;13992:15;;;;13957:12;;;;13835:1;13828:9;13799:218;;;-1:-1:-1;;;;;;;14073:55:1;;;;14068:2;14053:18;;14046:83;-1:-1:-1;;;14160:3:1;14145:19;14138:35;14034:3;13153:1026;-1:-1:-1;;;13153:1026:1:o;14437:168::-;14510:9;;;14541;;14558:15;;;14552:22;;14538:37;14528:71;;14579:18;;:::i;14610:274::-;14650:1;14676;14666:189;;-1:-1:-1;;;14708:1:1;14701:88;14812:4;14809:1;14802:15;14840:4;14837:1;14830:15;14666:189;-1:-1:-1;14869:9:1;;14610:274::o;14889:184::-;-1:-1:-1;;;14938:1:1;14931:88;15038:4;15035:1;15028:15;15062:4;15059:1;15052:15

ipfs://a5e1704390bd0a3508a3c56ead1d6659763434fb318d6db6370858ec1945c42b