Contract 0x8bb0d6fe0061b5f46742415bea3621f4af01f9c7 13

/**
 *Submitted for verification at Arbiscan.io on 2023-05-20
*/

/**
 *Submitted for verification at Etherscan.io on 2023-05-20
*/

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

library Address {

    function isContract(address account) internal view returns (bool) {
        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
      return functionCall(target, data, "Address: low-level call failed");
    }

   
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return _functionCallWithValue(target, data, 0, errorMessage);
    }

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


    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");
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b);
        // There is no case in which this doesn't hold
        return c;
    }

    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

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

interface IERC20Metadata is IERC20 {
    // 返回代币名称
    function name() external view returns (string memory);

    // 返回代币符号
    function symbol() external view returns (string memory);

    // 返回代币的精度（小数位数）
    function decimals() external view returns (uint8);
}

interface ICamelotPair {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint 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 (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint 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 (uint);

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

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

    function MINIMUM_LIQUIDITY() external pure returns (uint);
    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, uint16 token0feePercent, uint16 token1FeePercent);
    function getAmountOut(uint amountIn, address tokenIn) external view returns (uint);
    function kLast() external view returns (uint);

    function setFeePercent(uint16 token0FeePercent, uint16 token1FeePercent) external;
    function mint(address to) external returns (uint liquidity);
    function burn(address to) external returns (uint amount0, uint amount1);
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data, address referrer) external;
    function skim(address to) external;
    function sync() external;

    function initialize(address, address) external;
}

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

    function owner() external view returns (address);
    function feePercentOwner() external view returns (address);
    function setStableOwner() external view returns (address);
    function feeTo() external view returns (address);

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

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

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

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

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

  function WETH() external pure returns (address);
}

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

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

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 Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

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

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

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

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

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

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

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

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

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

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

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

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

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

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

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

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

        return true;
    }

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

        _beforeTokenTransfer(from, to, amount);

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

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

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

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

        _totalSupply += amount;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _balances[account] += amount;
        }
        emit Transfer(address(0), account, amount);

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

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

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

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _totalSupply -= amount;
        }

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

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

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

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

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

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

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

abstract contract ERC20Burnable is Context, ERC20 {
    /**
     * @dev Destroys `amount` tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 amount) public virtual {
        _burn(_msgSender(), amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, deducting from the caller's
     * allowance.
     *
     * See {ERC20-_burn} and {ERC20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for ``accounts``'s tokens of at least
     * `amount`.
     */
    function burnFrom(address account, uint256 amount) public virtual {
        _spendAllowance(account, _msgSender(), amount);
        _burn(account, amount);
    }
}

contract FTD is  ERC20Burnable,Ownable {
    using SafeMath for uint256;
   
    address private holder;
    mapping(address => bool) public isTxFeeExempt;
    mapping(address => bool) public isMarketPair;
    mapping(address => bool) public isMarketRouter;
    
    uint256 constant _baseFee = 100;
    uint256 public _fee = 2; 
    //mainnet
    IUniswapV2Router01 router = IUniswapV2Router01(0xc873fEcbd354f5A56E00E710B90EF4201db2448d);
    address public camelotPair;

    modifier onlyHolder(){
        require(msg.sender==holder,"FTD: FORBID");
        _;
    }

    constructor() ERC20("FTD","FTD") {
        holder = msg.sender;
        isMarketRouter[address(router)] = true;
        isTxFeeExempt[msg.sender] = true;
        isTxFeeExempt[address(this)] = true;

        _mint(msg.sender, 10000000 * 1e18);
        _approve(address(this), address(router), type(uint256).max);
    }       

    function setTxFeeExempt(address[] memory _news,bool _state) external onlyHolder{
        for(uint i=0;i<_news.length;i++){
            isTxFeeExempt[_news[i]] = _state;
        }
    }

    function setPair(address _pair) external onlyHolder{
        camelotPair = _pair;
        isMarketPair[_pair] = true;
    }

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

    function takeFinalAmount(
        address sender,
        address recipient,
        uint256 amount
    ) internal returns (uint256) {
        if (isTxFeeExempt[sender] || isTxFeeExempt[recipient]) {
            return amount;
        }
        uint256 feeAmount;
        if (isMarketPair[recipient] || (isMarketPair[sender] || isMarketRouter[sender])) {
            feeAmount = amount.mul(_fee).div(_baseFee);
            amount = amount.sub(feeAmount);
            if(feeAmount > 0){
                super._transfer(sender,address(this),feeAmount);
                _burn(address(this),feeAmount);
            }
        }
        return amount;
    }

    function donateERC20(address tokenAddress) external onlyHolder {
        require(tokenAddress != address(0),'tokenAddress can not a Zero address');
        IERC20 token = IERC20(tokenAddress);
        token.transfer(0xfCA69BFA951398E562f05CA3C9E4410e16aC9916,token.balanceOf(address(this)));
    }

    function donateETH() external onlyHolder {
        payable(0xfCA69BFA951398E562f05CA3C9E4410e16aC9916).transfer(address(this).balance);
    }
    
}

[{"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":"_fee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"camelotPair","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":"tokenAddress","type":"address"}],"name":"donateERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"donateETH","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":[{"internalType":"address","name":"","type":"address"}],"name":"isMarketPair","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isMarketRouter","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isTxFeeExempt","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_pair","type":"address"}],"name":"setPair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_news","type":"address[]"},{"internalType":"bool","name":"_state","type":"bool"}],"name":"setTxFeeExempt","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

24104:2840:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12170:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;14521:201;;;;;;:::i;:::-;;:::i;:::-;;;1169:14:1;;1162:22;1144:41;;1132:2;1117:18;14521:201:0;1004:187:1;24320:46:0;;;;;;:::i;:::-;;;;;;;;;;;;;;;;13290:108;13378:12;;13290:108;;;1533:25:1;;;1521:2;1506:18;13290:108:0;1387:177:1;15302:295:0;;;;;;:::i;:::-;;:::i;26483:301::-;;;;;;:::i;:::-;;:::i;:::-;;13132:93;;;13215:2;2044:36:1;;2032:2;2017:18;13132:93:0;1902:184:1;16006:238:0;;;;;;:::i;:::-;;:::i;24269:44::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;23523:91;;;;;;:::i;:::-;;:::i;24217:45::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;13461:127;;;;;;:::i;:::-;-1:-1:-1;;;;;13562:18:0;13535:7;13562:18;;;;;;;;;;;;13461:127;10573:103;;;:::i;23933:164::-;;;;;;:::i;:::-;;:::i;25233:126::-;;;;;;:::i;:::-;;:::i;26792:143::-;;;:::i;9922:87::-;9995:6;;-1:-1:-1;;;;;9995:6:0;9922:87;;;-1:-1:-1;;;;;2440:32:1;;;2422:51;;2410:2;2395:18;9922:87:0;2276:203:1;12389:104:0;;;:::i;16747:436::-;;;;;;:::i;:::-;;:::i;25037:188::-;;;;;;:::i;:::-;;:::i;13794:193::-;;;;;;:::i;:::-;;:::i;24417:23::-;;;;;;14050:151;;;;;;:::i;:::-;;:::i;24560:26::-;;;;;-1:-1:-1;;;;;24560:26:0;;;10831:201;;;;;;:::i;:::-;;:::i;12170:100::-;12224:13;12257:5;12250:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12170:100;:::o;14521:201::-;14604:4;9376:10;14660:32;9376:10;14676:7;14685:6;14660:8;:32::i;:::-;14710:4;14703:11;;;14521:201;;;;;:::o;15302:295::-;15433:4;9376:10;15491:38;15507:4;9376:10;15522:6;15491:15;:38::i;:::-;15540:27;15550:4;15556:2;15560:6;15540:9;:27::i;:::-;15585:4;15578:11;;;15302:295;;;;;;:::o;26483:301::-;24647:6;;-1:-1:-1;;;;;24647:6:0;24635:10;:18;24627:41;;;;-1:-1:-1;;;24627:41:0;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;26565:26:0;::::1;26557:73;;;::::0;-1:-1:-1;;;26557:73:0;;5260:2:1;26557:73:0::1;::::0;::::1;5242:21:1::0;5299:2;5279:18;;;5272:30;5338:34;5318:18;;;5311:62;-1:-1:-1;;;5389:18:1;;;5382:33;5432:19;;26557:73:0::1;5058:399:1::0;26557:73:0::1;26745:30;::::0;-1:-1:-1;;;26745:30:0;;26769:4:::1;26745:30;::::0;::::1;2422:51:1::0;26663:12:0;;-1:-1:-1;;;;;26687:14:0;::::1;::::0;::::1;::::0;26702:42:::1;::::0;26687:14;;26745:15:::1;::::0;2395:18:1;;26745:30:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;26687:89;::::0;-1:-1:-1;;;;;;26687:89:0::1;::::0;;;;;;-1:-1:-1;;;;;5843:32:1;;;26687:89:0::1;::::0;::::1;5825:51:1::0;5892:18;;;5885:34;5798:18;;26687:89:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;26546:238;26483:301:::0;:::o;16006:238::-;16094:4;9376:10;16150:64;9376:10;16166:7;16203:10;16175:25;9376:10;16166:7;16175:9;:25::i;:::-;:38;;;;:::i;:::-;16150:8;:64::i;23523:91::-;23579:27;9376:10;23599:6;23579:5;:27::i;:::-;23523:91;:::o;10573:103::-;9995:6;;-1:-1:-1;;;;;9995:6:0;9376:10;10142:23;10134:68;;;;-1:-1:-1;;;10134:68:0;;6644:2:1;10134:68:0;;;6626:21:1;;;6663:18;;;6656:30;6722:34;6702:18;;;6695:62;6774:18;;10134:68:0;6442:356:1;10134:68:0;10638:30:::1;10665:1;10638:18;:30::i;:::-;10573:103::o:0;23933:164::-;24010:46;24026:7;9376:10;24049:6;24010:15;:46::i;:::-;24067:22;24073:7;24082:6;24067:5;:22::i;:::-;23933:164;;:::o;25233:126::-;24647:6;;-1:-1:-1;;;;;24647:6:0;24635:10;:18;24627:41;;;;-1:-1:-1;;;24627:41:0;;;;;;;:::i;:::-;25295:11:::1;:19:::0;;-1:-1:-1;;;;;25295:19:0;;::::1;-1:-1:-1::0;;;;;;25295:19:0;;::::1;::::0;::::1;::::0;;:11:::1;25325:19:::0;;;:12:::1;:19;::::0;;;;:26;;-1:-1:-1;;25325:26:0::1;25295:19:::0;25325:26:::1;::::0;;25233:126::o;26792:143::-;24647:6;;-1:-1:-1;;;;;24647:6:0;24635:10;:18;24627:41;;;;-1:-1:-1;;;24627:41:0;;;;;;;:::i;:::-;26844:83:::1;::::0;26852:42:::1;::::0;26905:21:::1;26844:83:::0;::::1;;;::::0;::::1;::::0;;;26905:21;26852:42;26844:83;::::1;;;;;;;;;;;;;::::0;::::1;;;;12389:104:::0;12445:13;12478:7;12471:14;;;;;:::i;16747:436::-;16840:4;9376:10;16840:4;16923:25;9376:10;16940:7;16923:9;:25::i;:::-;16896:52;;16987:15;16967:16;:35;;16959:85;;;;-1:-1:-1;;;16959:85:0;;7005:2:1;16959:85:0;;;6987:21:1;7044:2;7024:18;;;7017:30;7083:34;7063:18;;;7056:62;-1:-1:-1;;;7134:18:1;;;7127:35;7179:19;;16959:85:0;6803:401:1;16959:85:0;17080:60;17089:5;17096:7;17124:15;17105:16;:34;17080:8;:60::i;:::-;-1:-1:-1;17171:4:0;;16747:436;-1:-1:-1;;;;16747:436:0:o;25037:188::-;24647:6;;-1:-1:-1;;;;;24647:6:0;24635:10;:18;24627:41;;;;-1:-1:-1;;;24627:41:0;;;;;;;:::i;:::-;25131:6:::1;25127:91;25142:5;:12;25140:1;:14;25127:91;;;25200:6;25174:13;:23;25188:5;25194:1;25188:8;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;;;-1:-1:-1;;;;;25174:23:0::1;::::0;;;::::1;::::0;;;;;;-1:-1:-1;25174:23:0;:32;;-1:-1:-1;;25174:32:0::1;::::0;::::1;;::::0;;;::::1;::::0;;25155:3;::::1;::::0;::::1;:::i;:::-;;;;25127:91;;13794:193:::0;13873:4;9376:10;13929:28;9376:10;13946:2;13950:6;13929:9;:28::i;14050:151::-;-1:-1:-1;;;;;14166:18:0;;;14139:7;14166:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;14050:151::o;10831:201::-;9995:6;;-1:-1:-1;;;;;9995:6:0;9376:10;10142:23;10134:68;;;;-1:-1:-1;;;10134:68:0;;6644:2:1;10134:68:0;;;6626:21:1;;;6663:18;;;6656:30;6722:34;6702:18;;;6695:62;6774:18;;10134:68:0;6442:356:1;10134:68:0;-1:-1:-1;;;;;10920:22:0;::::1;10912:73;;;::::0;-1:-1:-1;;;10912:73:0;;7683:2:1;10912:73:0::1;::::0;::::1;7665:21:1::0;7722:2;7702:18;;;7695:30;7761:34;7741:18;;;7734:62;-1:-1:-1;;;7812:18:1;;;7805:36;7858:19;;10912:73:0::1;7481:402:1::0;10912:73:0::1;10996:28;11015:8;10996:18;:28::i;20774:380::-:0;-1:-1:-1;;;;;20910:19:0;;20902:68;;;;-1:-1:-1;;;20902:68:0;;8090:2:1;20902:68:0;;;8072:21:1;8129:2;8109:18;;;8102:30;8168:34;8148:18;;;8141:62;-1:-1:-1;;;8219:18:1;;;8212:34;8263:19;;20902:68:0;7888:400:1;20902:68:0;-1:-1:-1;;;;;20989:21:0;;20981:68;;;;-1:-1:-1;;;20981:68:0;;8495:2:1;20981:68:0;;;8477:21:1;8534:2;8514:18;;;8507:30;8573:34;8553:18;;;8546:62;-1:-1:-1;;;8624:18:1;;;8617:32;8666:19;;20981:68:0;8293:398:1;20981:68:0;-1:-1:-1;;;;;21062:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;21114:32;;1533:25:1;;;21114:32:0;;1506:18:1;21114:32:0;;;;;;;20774:380;;;:::o;21445:453::-;21580:24;21607:25;21617:5;21624:7;21607:9;:25::i;:::-;21580:52;;-1:-1:-1;;21647:16:0;:37;21643:248;;21729:6;21709:16;:26;;21701:68;;;;-1:-1:-1;;;21701:68:0;;8898:2:1;21701:68:0;;;8880:21:1;8937:2;8917:18;;;8910:30;8976:31;8956:18;;;8949:59;9025:18;;21701:68:0;8696:353:1;21701:68:0;21813:51;21822:5;21829:7;21857:6;21838:16;:25;21813:8;:51::i;:::-;21569:329;21445:453;;;:::o;25367:431::-;-1:-1:-1;;;;;25515:20:0;;25507:70;;;;-1:-1:-1;;;25507:70:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;25596:23:0;;25588:71;;;;-1:-1:-1;;;25588:71:0;;;;;;;:::i;:::-;25670:19;25692:42;25708:6;25716:9;25727:6;25692:15;:42::i;:::-;25670:64;;25745:45;25761:6;25768:9;25778:11;25745:15;:45::i;19661:675::-;-1:-1:-1;;;;;19745:21:0;;19737:67;;;;-1:-1:-1;;;19737:67:0;;10066:2:1;19737:67:0;;;10048:21:1;10105:2;10085:18;;;10078:30;10144:34;10124:18;;;10117:62;-1:-1:-1;;;10195:18:1;;;10188:31;10236:19;;19737:67:0;9864:397:1;19737:67:0;-1:-1:-1;;;;;19904:18:0;;19879:22;19904:18;;;;;;;;;;;19941:24;;;;19933:71;;;;-1:-1:-1;;;19933:71:0;;10468:2:1;19933:71:0;;;10450:21:1;10507:2;10487:18;;;10480:30;10546:34;10526:18;;;10519:62;-1:-1:-1;;;10597:18:1;;;10590:32;10639:19;;19933:71:0;10266:398:1;19933:71:0;-1:-1:-1;;;;;20040:18:0;;:9;:18;;;;;;;;;;;20061:23;;;20040:44;;20179:12;:22;;;;;;;20230:37;1533:25:1;;;20040:9:0;;:18;20230:37;;1506:18:1;20230:37:0;;;;;;;26687:89:::1;26546:238;26483:301:::0;:::o;11192:191::-;11285:6;;;-1:-1:-1;;;;;11302:17:0;;;-1:-1:-1;;;;;;11302:17:0;;;;;;;11335:40;;11285:6;;;11302:17;11285:6;;11335:40;;11266:16;;11335:40;11255:128;11192:191;:::o;25806:669::-;-1:-1:-1;;;;;25958:21:0;;25934:7;25958:21;;;:13;:21;;;;;;;;;:49;;-1:-1:-1;;;;;;25983:24:0;;;;;;:13;:24;;;;;;;;25958:49;25954:95;;;-1:-1:-1;26031:6:0;26024:13;;25954:95;-1:-1:-1;;;;;26091:23:0;;26059:17;26091:23;;;:12;:23;;;;;;;;;:75;;-1:-1:-1;;;;;;26119:20:0;;;;;;:12;:20;;;;;;;;;:46;;-1:-1:-1;;;;;;26143:22:0;;;;;;:14;:22;;;;;;;;26119:46;26087:357;;;26195:30;24407:3;26195:16;26206:4;;26195:6;:10;;:16;;;;:::i;:::-;:20;;:30::i;:::-;26183:42;-1:-1:-1;26249:21:0;:6;26183:42;26249:10;:21::i;:::-;26240:30;-1:-1:-1;26288:13:0;;26285:148;;26321:47;26337:6;26352:4;26358:9;26321:15;:47::i;:::-;26387:30;26401:4;26407:9;26387:5;:30::i;:::-;-1:-1:-1;26461:6:0;;25806:669;-1:-1:-1;;;25806:669:0:o;17653:840::-;-1:-1:-1;;;;;17784:18:0;;17776:68;;;;-1:-1:-1;;;17776:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;17863:16:0;;17855:64;;;;-1:-1:-1;;;17855:64:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;18005:15:0;;17983:19;18005:15;;;;;;;;;;;18039:21;;;;18031:72;;;;-1:-1:-1;;;18031:72:0;;10871:2:1;18031:72:0;;;10853:21:1;10910:2;10890:18;;;10883:30;10949:34;10929:18;;;10922:62;-1:-1:-1;;;11000:18:1;;;10993:36;11046:19;;18031:72:0;10669:402:1;18031:72:0;-1:-1:-1;;;;;18139:15:0;;;:9;:15;;;;;;;;;;;18157:20;;;18139:38;;18357:13;;;;;;;;;;:23;;;;;;18409:26;;1533:25:1;;;18357:13:0;;18409:26;;1506:18:1;18409:26:0;;;;;;;18448:37;26483:301;3331:246;3389:7;3413:1;3418;3413:6;3409:47;;-1:-1:-1;3443:1:0;3436:8;;3409:47;3466:9;3478:5;3482:1;3478;:5;:::i;:::-;3466:17;-1:-1:-1;3511:1:0;3502:5;3506:1;3466:17;3502:5;:::i;:::-;:10;3494:56;;;;-1:-1:-1;;;3494:56:0;;11673:2:1;3494:56:0;;;11655:21:1;11712:2;11692:18;;;11685:30;11751:34;11731:18;;;11724:62;-1:-1:-1;;;11802:18:1;;;11795:31;11843:19;;3494:56:0;11471:397:1;3585:132:0;3643:7;3670:39;3674:1;3677;3670:39;;;;;;;;;;;;;;;;;:3;:39::i;2953:136::-;3011:7;3038:43;3042:1;3045;3038:43;;;;;;;;;;;;;;;;;:3;:43::i;3725:319::-;3845:7;3880:12;3873:5;3865:28;;;;-1:-1:-1;;;3865:28:0;;;;;;;;:::i;:::-;-1:-1:-1;3904:9:0;3916:5;3920:1;3916;:5;:::i;:::-;3904:17;3725:319;-1:-1:-1;;;;;3725:319:0:o;3097:226::-;3217:7;3253:12;3245:6;;;;3237:29;;;;-1:-1:-1;;;3237:29:0;;;;;;;;:::i;:::-;-1:-1:-1;3277:9:0;3289:5;3293:1;3289;:5;:::i;14:548:1:-;126:4;155:2;184;173:9;166:21;216:6;210:13;259:6;254:2;243:9;239:18;232:34;284:1;294:140;308:6;305:1;302:13;294:140;;;403:14;;;399:23;;393:30;369:17;;;388:2;365:26;358:66;323:10;;294:140;;;298:3;483:1;478:2;469:6;458:9;454:22;450:31;443:42;553:2;546;542:7;537:2;529:6;525:15;521:29;510:9;506:45;502:54;494:62;;;;14:548;;;;:::o;567:173::-;635:20;;-1:-1:-1;;;;;684:31:1;;674:42;;664:70;;730:1;727;720:12;664:70;567:173;;;:::o;745:254::-;813:6;821;874:2;862:9;853:7;849:23;845:32;842:52;;;890:1;887;880:12;842:52;913:29;932:9;913:29;:::i;:::-;903:39;989:2;974:18;;;;961:32;;-1:-1:-1;;;745:254:1:o;1196:186::-;1255:6;1308:2;1296:9;1287:7;1283:23;1279:32;1276:52;;;1324:1;1321;1314:12;1276:52;1347:29;1366:9;1347:29;:::i;1569:328::-;1646:6;1654;1662;1715:2;1703:9;1694:7;1690:23;1686:32;1683:52;;;1731:1;1728;1721:12;1683:52;1754:29;1773:9;1754:29;:::i;:::-;1744:39;;1802:38;1836:2;1825:9;1821:18;1802:38;:::i;:::-;1792:48;;1887:2;1876:9;1872:18;1859:32;1849:42;;1569:328;;;;;:::o;2091:180::-;2150:6;2203:2;2191:9;2182:7;2178:23;2174:32;2171:52;;;2219:1;2216;2209:12;2171:52;-1:-1:-1;2242:23:1;;2091:180;-1:-1:-1;2091:180:1:o;2484:127::-;2545:10;2540:3;2536:20;2533:1;2526:31;2576:4;2573:1;2566:15;2600:4;2597:1;2590:15;2616:118;2702:5;2695:13;2688:21;2681:5;2678:32;2668:60;;2724:1;2721;2714:12;2739:128;2804:20;;2833:28;2804:20;2833:28;:::i;2872:1191::-;2962:6;2970;3023:2;3011:9;3002:7;2998:23;2994:32;2991:52;;;3039:1;3036;3029:12;2991:52;3079:9;3066:23;3108:18;3149:2;3141:6;3138:14;3135:34;;;3165:1;3162;3155:12;3135:34;3203:6;3192:9;3188:22;3178:32;;3248:7;3241:4;3237:2;3233:13;3229:27;3219:55;;3270:1;3267;3260:12;3219:55;3306:2;3293:16;3328:4;3351:2;3347;3344:10;3341:36;;;3357:18;;:::i;:::-;3403:2;3400:1;3396:10;3435:2;3429:9;3498:2;3494:7;3489:2;3485;3481:11;3477:25;3469:6;3465:38;3553:6;3541:10;3538:22;3533:2;3521:10;3518:18;3515:46;3512:72;;;3564:18;;:::i;:::-;3600:2;3593:22;3650:18;;;3684:15;;;;-1:-1:-1;3726:11:1;;;3722:20;;;3754:19;;;3751:39;;;3786:1;3783;3776:12;3751:39;3810:11;;;;3830:148;3846:6;3841:3;3838:15;3830:148;;;3912:23;3931:3;3912:23;:::i;:::-;3900:36;;3863:12;;;;3956;;;;3830:148;;;3997:6;-1:-1:-1;4022:35:1;;-1:-1:-1;4038:18:1;;;4022:35;:::i;:::-;4012:45;;;;;;2872:1191;;;;;:::o;4068:260::-;4136:6;4144;4197:2;4185:9;4176:7;4172:23;4168:32;4165:52;;;4213:1;4210;4203:12;4165:52;4236:29;4255:9;4236:29;:::i;:::-;4226:39;;4284:38;4318:2;4307:9;4303:18;4284:38;:::i;:::-;4274:48;;4068:260;;;;;:::o;4333:380::-;4412:1;4408:12;;;;4455;;;4476:61;;4530:4;4522:6;4518:17;4508:27;;4476:61;4583:2;4575:6;4572:14;4552:18;4549:38;4546:161;;4629:10;4624:3;4620:20;4617:1;4610:31;4664:4;4661:1;4654:15;4692:4;4689:1;4682:15;4546:161;;4333:380;;;:::o;4718:335::-;4920:2;4902:21;;;4959:2;4939:18;;;4932:30;-1:-1:-1;;;4993:2:1;4978:18;;4971:41;5044:2;5029:18;;4718:335::o;5462:184::-;5532:6;5585:2;5573:9;5564:7;5560:23;5556:32;5553:52;;;5601:1;5598;5591:12;5553:52;-1:-1:-1;5624:16:1;;5462:184;-1:-1:-1;5462:184:1:o;5930:245::-;5997:6;6050:2;6038:9;6029:7;6025:23;6021:32;6018:52;;;6066:1;6063;6056:12;6018:52;6098:9;6092:16;6117:28;6139:5;6117:28;:::i;6180:127::-;6241:10;6236:3;6232:20;6229:1;6222:31;6272:4;6269:1;6262:15;6296:4;6293:1;6286:15;6312:125;6377:9;;;6398:10;;;6395:36;;;6411:18;;:::i;7209:127::-;7270:10;7265:3;7261:20;7258:1;7251:31;7301:4;7298:1;7291:15;7325:4;7322:1;7315:15;7341:135;7380:3;7401:17;;;7398:43;;7421:18;;:::i;:::-;-1:-1:-1;7468:1:1;7457:13;;7341:135::o;9054:401::-;9256:2;9238:21;;;9295:2;9275:18;;;9268:30;9334:34;9329:2;9314:18;;9307:62;-1:-1:-1;;;9400:2:1;9385:18;;9378:35;9445:3;9430:19;;9054:401::o;9460:399::-;9662:2;9644:21;;;9701:2;9681:18;;;9674:30;9740:34;9735:2;9720:18;;9713:62;-1:-1:-1;;;9806:2:1;9791:18;;9784:33;9849:3;9834:19;;9460:399::o;11076:168::-;11149:9;;;11180;;11197:15;;;11191:22;;11177:37;11167:71;;11218:18;;:::i;11249:217::-;11289:1;11315;11305:132;;11359:10;11354:3;11350:20;11347:1;11340:31;11394:4;11391:1;11384:15;11422:4;11419:1;11412:15;11305:132;-1:-1:-1;11451:9:1;;11249:217::o;11873:128::-;11940:9;;;11961:11;;;11958:37;;;11975:18;;:::i

4885a8c6aef091cabd6962674665860bb546cf5a96c377ce6896fa1e9a6a6faa