KANRO

{{
  "language": "Solidity",
  "sources": {
    "contracts/Kanro.sol": {
      "content": "// SPDX-License-Identifier: MIT\r
\r
pragma solidity 0.8.11;\r
\r
abstract contract Context {\r
    function _msgSender() internal view virtual returns (address) {\r
        return msg.sender;\r
    }\r
\r
    function _msgData() internal view virtual returns (bytes calldata) {\r
        return msg.data;\r
    }\r
}\r
\r
interface IUniswapV2Pair {\r
    event Approval(address indexed owner, address indexed spender, uint value);\r
    event Transfer(address indexed from, address indexed to, uint value);\r
\r
    function name() external pure returns (string memory);\r
    function symbol() external pure returns (string memory);\r
    function decimals() external pure returns (uint8);\r
    function totalSupply() external view returns (uint);\r
    function balanceOf(address owner) external view returns (uint);\r
    function allowance(address owner, address spender) external view returns (uint);\r
\r
    function approve(address spender, uint value) external returns (bool);\r
    function transfer(address to, uint value) external returns (bool);\r
    function transferFrom(address from, address to, uint value) external returns (bool);\r
\r
    event Swap(\r
        address indexed sender,\r
        uint amount0In,\r
        uint amount1In,\r
        uint amount0Out,\r
        uint amount1Out,\r
        address indexed to\r
    );\r
    event Sync(uint112 reserve0, uint112 reserve1);\r
\r
    function factory() external view returns (address);\r
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;\r
}\r
\r
interface IUniswapV2Factory {\r
    function createPair(address tokenA, address tokenB) external returns (address pair);\r
}\r
\r
interface IERC20 {\r
    function totalSupply() external view returns (uint256);\r
    function balanceOf(address account) external view returns (uint256);\r
    function transfer(address recipient, uint256 amount) external returns (bool);\r
    function allowance(address owner, address spender) external view returns (uint256);\r
    function approve(address spender, uint256 amount) external returns (bool);\r
    function transferFrom(\r
        address sender,\r
        address recipient,\r
        uint256 amount\r
    ) external returns (bool);\r
    \r
    event Transfer(address indexed from, address indexed to, uint256 value);\r
    event Approval(address indexed owner, address indexed spender, uint256 value);\r
}\r
\r
interface IERC20Metadata is IERC20 {\r
    function name() external view returns (string memory);\r
    function symbol() external view returns (string memory);\r
    function decimals() external view returns (uint8);\r
}\r
\r
\r
contract ERC20 is Context, IERC20, IERC20Metadata {\r
    mapping(address => uint256) private _balances;\r
\r
    mapping(address => mapping(address => uint256)) private _allowances;\r
\r
    uint256 private _totalSupply;\r
\r
    string private _name;\r
    string private _symbol;\r
\r
    constructor(string memory name_, string memory symbol_) {\r
        _name = name_;\r
        _symbol = symbol_;\r
    }\r
\r
    function name() public view virtual override returns (string memory) {\r
        return _name;\r
    }\r
\r
    function symbol() public view virtual override returns (string memory) {\r
        return _symbol;\r
    }\r
\r
    function decimals() public view virtual override returns (uint8) {\r
        return 18;\r
    }\r
\r
    function totalSupply() public view virtual override returns (uint256) {\r
        return _totalSupply;\r
    }\r
\r
    function balanceOf(address account) public view virtual override returns (uint256) {\r
        return _balances[account];\r
    }\r
\r
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\r
        _transfer(_msgSender(), recipient, amount);\r
        return true;\r
    }\r
\r
    function allowance(address owner, address spender) public view virtual override returns (uint256) {\r
        return _allowances[owner][spender];\r
    }\r
\r
    function approve(address spender, uint256 amount) public virtual override returns (bool) {\r
        _approve(_msgSender(), spender, amount);\r
        return true;\r
    }\r
\r
    function transferFrom(\r
        address sender,\r
        address recipient,\r
        uint256 amount\r
    ) public virtual override returns (bool) {\r
        uint256 currentAllowance = _allowances[sender][_msgSender()];\r
        if (currentAllowance != type(uint256).max) {\r
            require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");\r
            unchecked {\r
                _approve(sender, _msgSender(), currentAllowance - amount);\r
            }\r
        }\r
\r
        _transfer(sender, recipient, amount);\r
\r
        return true;\r
    }\r
\r
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\r
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\r
        return true;\r
    }\r
\r
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\r
        uint256 currentAllowance = _allowances[_msgSender()][spender];\r
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");\r
        unchecked {\r
            _approve(_msgSender(), spender, currentAllowance - subtractedValue);\r
        }\r
\r
        return true;\r
    }\r
\r
    function _transfer(\r
        address sender,\r
        address recipient,\r
        uint256 amount\r
    ) internal virtual {\r
        require(sender != address(0), "ERC20: transfer from the zero address");\r
        require(recipient != address(0), "ERC20: transfer to the zero address");\r
\r
        _beforeTokenTransfer(sender, recipient, amount);\r
\r
        uint256 senderBalance = _balances[sender];\r
        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");\r
        unchecked {\r
            _balances[sender] = senderBalance - amount;\r
        }\r
        _balances[recipient] += amount;\r
\r
        emit Transfer(sender, recipient, amount);\r
\r
        _afterTokenTransfer(sender, recipient, amount);\r
    }\r
\r
    function _mint(address account, uint256 amount) internal virtual {\r
        require(account != address(0), "ERC20: mint to the zero address");\r
\r
        _beforeTokenTransfer(address(0), account, amount);\r
\r
        _totalSupply += amount;\r
        _balances[account] += amount;\r
        emit Transfer(address(0), account, amount);\r
\r
        _afterTokenTransfer(address(0), account, amount);\r
    }\r
\r
    function _burn(address account, uint256 amount) internal virtual {\r
        require(account != address(0), "ERC20: burn from the zero address");\r
\r
        _beforeTokenTransfer(account, address(0), amount);\r
\r
        uint256 accountBalance = _balances[account];\r
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");\r
        unchecked {\r
            _balances[account] = accountBalance - amount;\r
        }\r
        _totalSupply -= amount;\r
\r
        emit Transfer(account, address(0), amount);\r
\r
        _afterTokenTransfer(account, address(0), amount);\r
    }\r
\r
    function _approve(\r
        address owner,\r
        address spender,\r
        uint256 amount\r
    ) internal virtual {\r
        require(owner != address(0), "ERC20: approve from the zero address");\r
        require(spender != address(0), "ERC20: approve to the zero address");\r
\r
        _allowances[owner][spender] = amount;\r
        emit Approval(owner, spender, amount);\r
    }\r
\r
    function _beforeTokenTransfer(\r
        address from,\r
        address to,\r
        uint256 amount\r
    ) internal virtual {}\r
\r
    function _afterTokenTransfer(\r
        address from,\r
        address to,\r
        uint256 amount\r
    ) internal virtual {}\r
}\r
library SafeMath {\r
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\r
        unchecked {\r
            uint256 c = a + b;\r
            if (c < a) return (false, 0);\r
            return (true, c);\r
        }\r
    }\r
\r
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\r
        unchecked {\r
            if (b > a) return (false, 0);\r
            return (true, a - b);\r
        }\r
    }\r
\r
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\r
        unchecked {\r
            if (a == 0) return (true, 0);\r
            uint256 c = a * b;\r
            if (c / a != b) return (false, 0);\r
            return (true, c);\r
        }\r
    }\r
\r
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\r
        unchecked {\r
            if (b == 0) return (false, 0);\r
            return (true, a / b);\r
        }\r
    }\r
\r
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\r
        unchecked {\r
            if (b == 0) return (false, 0);\r
            return (true, a % b);\r
        }\r
    }\r
\r
    function add(uint256 a, uint256 b) internal pure returns (uint256) {\r
        return a + b;\r
    }\r
\r
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {\r
        return a - b;\r
    }\r
\r
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {\r
        return a * b;\r
    }\r
\r
    function div(uint256 a, uint256 b) internal pure returns (uint256) {\r
        return a / b;\r
    }\r
\r
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {\r
        return a % b;\r
    }\r
\r
    function sub(uint256 a,uint256 b,string memory errorMessage) internal pure returns (uint256) {\r
        unchecked {\r
            require(b <= a, errorMessage);\r
            return a - b;\r
        }\r
    }\r
\r
    function div(uint256 a,uint256 b,string memory errorMessage) internal pure returns (uint256) {\r
        unchecked {\r
            require(b > 0, errorMessage);\r
            return a / b;\r
        }\r
    }\r
\r
    function mod(uint256 a,uint256 b,string memory errorMessage) internal pure returns (uint256) {\r
        unchecked {\r
            require(b > 0, errorMessage);\r
            return a % b;\r
        }\r
    }\r
}\r
\r
abstract contract Ownable is Context {\r
    address private _owner;\r
\r
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\r
\r
    constructor() {\r
        _transferOwnership(_msgSender());\r
    }\r
\r
    function owner() public view virtual returns (address) {\r
        return _owner;\r
    }\r
\r
    modifier onlyOwner() {\r
        require(owner() == _msgSender(), "Ownable: caller is not the owner");\r
        _;\r
    }\r
\r
    function renounceOwnership() public virtual onlyOwner {\r
        _transferOwnership(address(0));\r
    }\r
\r
    function transferOwnership(address newOwner) public virtual onlyOwner {\r
        require(newOwner != address(0), "Ownable: new owner is the zero address");\r
        _transferOwnership(newOwner);\r
    }\r
\r
    function _transferOwnership(address newOwner) internal virtual {\r
        address oldOwner = _owner;\r
        _owner = newOwner;\r
        emit OwnershipTransferred(oldOwner, newOwner);\r
    }\r
}\r
\r
interface IUniswapV2Router01 {\r
    function factory() external pure returns (address);\r
    function WETH() external pure returns (address);\r
    function addLiquidityETH(\r
        address token,\r
        uint amountTokenDesired,\r
        uint amountTokenMin,\r
        uint amountETHMin,\r
        address to,\r
        uint deadline\r
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);\r
}\r
\r
interface IUniswapV2Router02 is IUniswapV2Router01 {\r
    function swapExactTokensForETHSupportingFeeOnTransferTokens(\r
        uint amountIn, \r
        uint amountOutMin, \r
        address[] calldata path, \r
        address to, \r
        uint deadline\r
    ) external;\r
}\r
\r
contract KANRO is ERC20, Ownable {\r
    using SafeMath for uint256;\r
\r
    IUniswapV2Router02 public immutable uniswapV2Router;\r
    address public immutable uniswapV2Pair;\r
\r
    mapping (address => bool) public isBot;\r
    bool private _swapping;\r
    uint256 private _launchTime;\r
\r
    address private devWallet;\r
    \r
    uint256 public maxTransactionAmount;\r
    uint256 public swapTokensAtAmount;\r
    uint256 public maxWallet;\r
        \r
    bool public limitsInEffect = true;\r
    bool public tradingActive = false;\r
    \r
    // Anti-bot and anti-whale mappings and variables\r
    mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch\r
    bool public transferDelayEnabled = true;\r
    \r
    uint256 public buyTotalFees;\r
    uint256 public buyDevFee;\r
 \r
    uint256 public sellTotalFees;\r
    uint256 public sellDevFee;\r
 \r
    uint256 public tokensForDev;\r
    \r
    /******************/\r
\r
    // exlcude from fees and max transaction amount\r
    mapping (address => bool) private _isExcludedFromFees;\r
    mapping (address => bool) public _isExcludedMaxTransactionAmount;\r
\r
    // store addresses that a automatic market maker pairs. Any transfer *to* these addresses\r
    // could be subject to a maximum transfer amount\r
    mapping (address => bool) public automatedMarketMakerPairs;\r
\r
    event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);\r
    \r
    event marketingWalletUpdated(address indexed newWallet, address indexed oldWallet);\r
 \r
    event devWalletUpdated(address indexed newWallet, address indexed oldWallet);\r
\r
    constructor() ERC20("Kanro Fund", "KANRO") {\r
        IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);\r
        \r
        excludeFromMaxTransaction(address(_uniswapV2Router), true);\r
        uniswapV2Router = _uniswapV2Router;\r
        \r
        uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());\r
        excludeFromMaxTransaction(address(uniswapV2Pair), true);\r
        _setAutomatedMarketMakerPair(address(uniswapV2Pair), true);\r
\r
\r
\r
        uint256 _buyDevFee = 5;\r
 \r
        uint256 _sellDevFee = 5;\r
        \r
        uint256 totalSupply = 1 * 1e6 * 1e18;\r
        \r
        maxTransactionAmount = totalSupply * 15 / 1000; // 1.5% maxTransactionAmountTxn\r
        maxWallet = totalSupply * 15 / 1000; // 1.5% maxWallet\r
        swapTokensAtAmount = totalSupply * 5 / 10000; // 0.05% swap wallet\r
\r
        // Set Fees\r
        buyDevFee = _buyDevFee;\r
        buyTotalFees =  buyDevFee;\r
\r
        sellDevFee = _sellDevFee;\r
        sellTotalFees = sellDevFee;\r
\r
        // Set Fee Wallet\r
        devWallet = address(0xB36082ba6c35490D1E167CC6Dd5ad20884A21Afb); // set as dev wallet\r
\r
\r
        // exclude from paying fees or having max transaction amount\r
        excludeFromFees(owner(), true);\r
        excludeFromFees(address(this), true);\r
        excludeFromFees(address(0xdead), true);\r
        \r
        excludeFromMaxTransaction(owner(), true);\r
        excludeFromMaxTransaction(address(this), true);\r
        excludeFromMaxTransaction(address(0xdead), true);\r
        \r
        /*\r
            _mint is an internal function in ERC20.sol that is only called here,\r
            and CANNOT be called ever again\r
        */\r
        _mint(msg.sender, totalSupply);\r
    }\r
\r
        receive() external payable {\r
 \r
    }\r
 \r
\r
    // once enabled, can never be turned off\r
    function enableTrading() external onlyOwner {\r
        tradingActive = true;\r
        _launchTime = block.timestamp;\r
    }\r
   \r
    // remove limits after token is stable\r
    function removeLimits() external onlyOwner returns (bool) {\r
        limitsInEffect = false;\r
        return true;\r
    }\r
    \r
    // disable Transfer delay - cannot be reenabled\r
    function disableTransferDelay() external onlyOwner returns (bool) {\r
        transferDelayEnabled = false;\r
        return true;\r
    }\r
    \r
     // change the minimum amount of tokens to sell from fees\r
    function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner returns (bool) {\r
  	    require(newAmount >= totalSupply() * 1 / 100000, "Swap amount cannot be lower than 0.001% total supply.");\r
  	    require(newAmount <= totalSupply() * 5 / 1000, "Swap amount cannot be higher than 0.5% total supply.");\r
  	    swapTokensAtAmount = newAmount;\r
  	    return true;\r
  	}\r
    \r
    function updateMaxTxnAmount(uint256 newNum) external onlyOwner {\r
        require(newNum >= (totalSupply() * 1 / 1000) / 1e18, "Cannot set maxTransactionAmount lower than 0.1%");\r
        maxTransactionAmount = newNum * 1e18;\r
    }\r
\r
    function updateMaxWalletAmount(uint256 newNum) external onlyOwner {\r
        require(newNum >= (totalSupply() * 5 / 1000)/1e18, "Cannot set maxWallet lower than 0.5%");\r
        maxWallet = newNum * 1e18;\r
    }\r
    \r
    function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {\r
        _isExcludedMaxTransactionAmount[updAds] = isEx;\r
    }\r
    \r
    function updateBuyFees(uint256 _devFee) external onlyOwner {\r
        buyDevFee = _devFee;\r
        buyTotalFees = buyDevFee;\r
        require(buyTotalFees <= 10, "Must keep fees at 10% or less");\r
    }\r
 \r
    function updateSellFees(uint256 _devFee) external onlyOwner {\r
        sellDevFee = _devFee;\r
        sellTotalFees = sellDevFee;\r
        require(sellTotalFees <= 25, "Must keep fees at 15% or less");\r
    }\r
\r
    function excludeFromFees(address account, bool excluded) public onlyOwner {\r
        _isExcludedFromFees[account] = excluded;\r
    }\r
\r
    function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {\r
        require(pair != uniswapV2Pair, "The pair cannot be removed from automatedMarketMakerPairs");\r
\r
        _setAutomatedMarketMakerPair(pair, value);\r
    }\r
\r
    function _setAutomatedMarketMakerPair(address pair, bool value) private {\r
        automatedMarketMakerPairs[pair] = value;\r
    }\r
    \r
\r
    function updateDevWallet(address newWallet) external onlyOwner {\r
        emit devWalletUpdated(newWallet, devWallet);\r
        devWallet = newWallet;\r
    }\r
 \r
\r
    function isExcludedFromFees(address account) public view returns(bool) {\r
        return _isExcludedFromFees[account];\r
    }\r
    \r
    function addBots(address[] memory bots) public onlyOwner() {\r
        for (uint i = 0; i < bots.length; i++) {\r
            if (bots[i] != uniswapV2Pair && bots[i] != address(uniswapV2Router)) {\r
                isBot[bots[i]] = true;\r
            }\r
        }\r
    }\r
    \r
    function removeBots(address[] memory bots) public onlyOwner() {\r
        for (uint i = 0; i < bots.length; i++) {\r
            isBot[bots[i]] = false;\r
        }\r
    }\r
\r
    function _transfer(\r
        address from,\r
        address to,\r
        uint256 amount\r
    ) internal override {\r
        require(from != address(0), "ERC20: transfer from the zero address");\r
        require(to != address(0), "ERC20: transfer to the zero address");\r
        require(!isBot[from], "Your address has been marked as a bot/sniper, you are unable to transfer or swap.");\r
        \r
         if (amount == 0) {\r
            super._transfer(from, to, 0);\r
            return;\r
        }\r
        \r
        if (limitsInEffect) {\r
            if (\r
                from != owner() &&\r
                to != owner() &&\r
                to != address(0) &&\r
                to != address(0xdead) &&\r
                !_swapping\r
            ) {\r
                if (!tradingActive) {\r
                    require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");\r
                }\r
\r
                // at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.  \r
                if (transferDelayEnabled){\r
                    if (to != owner() && to != address(uniswapV2Router) && to != address(uniswapV2Pair)){\r
                        require(_holderLastTransferTimestamp[tx.origin] < block.number, "_transfer:: Transfer Delay enabled.  Only one purchase per block allowed.");\r
                        _holderLastTransferTimestamp[tx.origin] = block.number;\r
                    }\r
                }\r
                 \r
                // On buy\r
                if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {\r
                    require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");\r
                    require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");\r
                }\r
                \r
                // On sell\r
                else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {\r
                    require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");\r
                }\r
                else if (!_isExcludedMaxTransactionAmount[to]){\r
                    require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");\r
                }\r
            }\r
        }\r
        \r
		uint256 contractTokenBalance = balanceOf(address(this));\r
        bool canSwap = contractTokenBalance >= swapTokensAtAmount;\r
\r
        if (\r
            canSwap &&\r
            !_swapping &&\r
            !automatedMarketMakerPairs[from] &&\r
            !_isExcludedFromFees[from] &&\r
            !_isExcludedFromFees[to]\r
        ) {\r
            _swapping = true;\r
            swapBack();\r
            _swapping = false;\r
        }\r
\r
        bool takeFee = !_swapping;\r
\r
        // if any account belongs to _isExcludedFromFee account then remove the fee\r
        if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) takeFee = false;\r
        \r
        \r
        uint256 fees = 0;\r
        // Only take fees on buys/sells, do not take on wallet transfers\r
        if (takeFee) {\r
            // On sell\r
            if (automatedMarketMakerPairs[to] && sellTotalFees > 0){\r
                fees = amount.mul(sellTotalFees).div(100);\r
                tokensForDev += fees * sellDevFee / sellTotalFees;\r
            }\r
            // on buy\r
            else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {\r
                fees = amount.mul(buyTotalFees).div(100);\r
                tokensForDev += fees * buyDevFee / buyTotalFees;\r
            }\r
\r
            if (fees > 0) {\r
                super._transfer(from, address(this), fees);\r
            }\r
        	\r
        	amount -= fees;\r
        }\r
\r
        super._transfer(from, to, amount);\r
    }\r
\r
    function _swapTokensForEth(uint256 tokenAmount) private {\r
        // generate the uniswap pair path of token -> weth\r
        address[] memory path = new address[](2);\r
        path[0] = address(this);\r
        path[1] = uniswapV2Router.WETH();\r
\r
        _approve(address(this), address(uniswapV2Router), tokenAmount);\r
\r
        // make the swap\r
        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(\r
            tokenAmount,\r
            0, // accept any amount of ETH\r
            path,\r
            address(this),\r
            block.timestamp\r
        );\r
    }\r
    \r
    function _addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {\r
        // approve token transfer to cover all possible scenarios\r
        _approve(address(this), address(uniswapV2Router), tokenAmount);\r
\r
        // add the liquidity\r
        uniswapV2Router.addLiquidityETH{value: ethAmount}(\r
            address(this),\r
            tokenAmount,\r
            0, // slippage is unavoidable\r
            0, // slippage is unavoidable\r
            owner(),\r
            block.timestamp\r
        );\r
    }\r
\r
    function swapBack() private {\r
        uint256 contractBalance = balanceOf(address(this));\r
        uint256 totalTokensToSwap = tokensForDev;\r
        bool success;\r
 \r
        if(contractBalance == 0 || totalTokensToSwap == 0) {return;}\r
 \r
        if(contractBalance > swapTokensAtAmount * 20){\r
          contractBalance = swapTokensAtAmount * 20;\r
        }\r
 \r
 \r
        _swapTokensForEth(totalTokensToSwap); \r
 \r
        uint256 ethBalance = address(this).balance;\r
 \r
 \r
        tokensForDev = 0;\r
 \r
        (success,) = address(devWallet).call{value: ethBalance}("");\r
 \r
\r
    }\r
}"
    }
  },
  "settings": {
    "optimizer": {
      "enabled": false,
      "runs": 200
    },
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    },
    "remappings": []
  }
}}