SUPERHOLDY

{{
  "language": "Solidity",
  "sources": {
    "contracts/holdy.sol": {
      "content": "// SPDX-License-Identifier: MIT\r
pragma solidity ^0.8.3;\r
\r
interface IERC20 {\r
    function totalSupply() external view returns (uint256);\r
\r
    function balanceOf(address account) external view returns (uint256);\r
\r
    function transfer(address recipient, uint256 amount) external returns (bool);\r
\r
    function allowance(address owner, address spender) external view returns (uint256);\r
\r
    function approve(address spender, uint256 amount) external returns (bool);\r
\r
    function transferFrom(address sender, address recipient, uint256 amount) 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
library SafeMath {\r
    function add(uint256 a, uint256 b) internal pure returns (uint256) {\r
        uint256 c = a + b;\r
        require(c >= a, "SafeMath: addition overflow");\r
\r
        return c;\r
    }\r
\r
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {\r
        return sub(a, b, "SafeMath: subtraction overflow");\r
    }\r
\r
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\r
        require(b <= a, errorMessage);\r
        uint256 c = a - b;\r
\r
        return c;\r
    }\r
\r
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {\r
        if (a == 0) {\r
            return 0;\r
        }\r
\r
        uint256 c = a * b;\r
        require(c / a == b, "SafeMath: multiplication overflow");\r
\r
        return c;\r
    }\r
\r
    function div(uint256 a, uint256 b) internal pure returns (uint256) {\r
        return div(a, b, "SafeMath: division by zero");\r
    }\r
\r
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\r
        require(b > 0, errorMessage);\r
        uint256 c = a / b;\r
\r
        return c;\r
    }\r
\r
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {\r
        return mod(a, b, "SafeMath: modulo by zero");\r
    }\r
\r
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\r
        require(b != 0, errorMessage);\r
        return a % b;\r
    }\r
}\r
\r
abstract contract Context {\r
    function _msgSender() internal view virtual returns (address payable) {\r
        return payable(msg.sender);\r
    }\r
\r
    function _msgData() internal view virtual returns (bytes memory) {\r
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\r
        return msg.data;\r
    }\r
}\r
\r
library Address {\r
    function isContract(address account) internal view returns (bool) {\r
        bytes32 codehash;\r
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;\r
        assembly {\r
            codehash := extcodehash(account)\r
        }\r
        return (codehash != accountHash && codehash != 0x0);\r
    }\r
\r
    function sendValue(address payable recipient, uint256 amount) internal {\r
        require(address(this).balance >= amount, "Address: insufficient balance");\r
\r
        (bool success, ) = recipient.call{value: amount}("");\r
        require(success, "Address: unable to send value, recipient may have reverted");\r
    }\r
\r
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\r
        return functionCall(target, data, "Address: low-level call failed");\r
    }\r
\r
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\r
        return _functionCallWithValue(target, data, 0, errorMessage);\r
    }\r
\r
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\r
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");\r
    }\r
\r
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\r
        require(address(this).balance >= value, "Address: insufficient balance for call");\r
        return _functionCallWithValue(target, data, value, errorMessage);\r
    }\r
\r
    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {\r
        require(isContract(target), "Address: call to non-contract");\r
\r
        (bool success, bytes memory returndata) = target.call{value: weiValue}(data);\r
        if (success) {\r
            return returndata;\r
        } else {\r
            if (returndata.length > 0) {\r
                assembly {\r
                    let returndata_size := mload(returndata)\r
                    revert(add(32, returndata), returndata_size)\r
                }\r
            } else {\r
                revert(errorMessage);\r
            }\r
        }\r
    }\r
}\r
\r
contract Ownable is Context {\r
    address private _owner;\r
    address private _previousOwner;\r
\r
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\r
\r
    constructor() {\r
        address msgSender = _msgSender();\r
        _owner = msgSender;\r
        emit OwnershipTransferred(address(0), msgSender);\r
    }\r
\r
    function owner() public view 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
        emit OwnershipTransferred(_owner, address(0));\r
        _owner = address(0);\r
    }\r
}\r
\r
interface IUniswapV2Factory {\r
    event PairCreated(address indexed token0, address indexed token1, address pair, uint256);\r
\r
    function feeTo() external view returns (address);\r
\r
    function feeToSetter() external view returns (address);\r
\r
    function getPair(address tokenA, address tokenB) external view returns (address pair);\r
\r
    function allPairs(uint256) external view returns (address pair);\r
\r
    function allPairsLength() external view returns (uint256);\r
\r
    function createPair(address tokenA, address tokenB) external returns (address pair);\r
\r
    function setFeeTo(address) external;\r
\r
    function setFeeToSetter(address) external;\r
}\r
\r
interface IUniswapV2Pair {\r
    event Approval(address indexed owner, address indexed spender, uint256 value);\r
    event Transfer(address indexed from, address indexed to, uint256 value);\r
\r
    function name() external pure returns (string memory);\r
\r
    function symbol() external pure returns (string memory);\r
\r
    function decimals() external pure returns (uint8);\r
\r
    function totalSupply() external view returns (uint256);\r
\r
    function balanceOf(address owner) external view returns (uint256);\r
\r
    function allowance(address owner, address spender) external view returns (uint256);\r
\r
    function approve(address spender, uint256 value) external returns (bool);\r
\r
    function transfer(address to, uint256 value) external returns (bool);\r
\r
    function transferFrom(address from, address to, uint256 value) external returns (bool);\r
\r
    function DOMAIN_SEPARATOR() external view returns (bytes32);\r
\r
    function PERMIT_TYPEHASH() external pure returns (bytes32);\r
\r
    function nonces(address owner) external view returns (uint256);\r
\r
    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;\r
\r
    event Mint(address indexed sender, uint256 amount0, uint256 amount1);\r
    event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);\r
    event Swap(address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to);\r
    event Sync(uint112 reserve0, uint112 reserve1);\r
\r
    function MINIMUM_LIQUIDITY() external pure returns (uint256);\r
\r
    function factory() external view returns (address);\r
\r
    function token0() external view returns (address);\r
\r
    function token1() external view returns (address);\r
\r
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);\r
\r
    function price0CumulativeLast() external view returns (uint256);\r
\r
    function price1CumulativeLast() external view returns (uint256);\r
\r
    function kLast() external view returns (uint256);\r
\r
    function mint(address to) external returns (uint256 liquidity);\r
\r
    function burn(address to) external returns (uint256 amount0, uint256 amount1);\r
\r
    function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes calldata data) external;\r
\r
    function skim(address to) external;\r
\r
    function sync() external;\r
\r
    function initialize(address, address) external;\r
}\r
\r
interface IUniswapV2Router01 {\r
    function factory() external pure returns (address);\r
\r
    function WETH() external pure returns (address);\r
\r
    function addLiquidity(\r
        address tokenA,\r
        address tokenB,\r
        uint256 amountADesired,\r
        uint256 amountBDesired,\r
        uint256 amountAMin,\r
        uint256 amountBMin,\r
        address to,\r
        uint256 deadline\r
    ) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);\r
\r
    function addLiquidityETH(\r
        address token,\r
        uint256 amountTokenDesired,\r
        uint256 amountTokenMin,\r
        uint256 amountETHMin,\r
        address to,\r
        uint256 deadline\r
    ) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);\r
\r
    function removeLiquidity(\r
        address tokenA,\r
        address tokenB,\r
        uint256 liquidity,\r
        uint256 amountAMin,\r
        uint256 amountBMin,\r
        address to,\r
        uint256 deadline\r
    ) external returns (uint256 amountA, uint256 amountB);\r
\r
    function removeLiquidityETH(\r
        address token,\r
        uint256 liquidity,\r
        uint256 amountTokenMin,\r
        uint256 amountETHMin,\r
        address to,\r
        uint256 deadline\r
    ) external returns (uint256 amountToken, uint256 amountETH);\r
\r
    function removeLiquidityWithPermit(\r
        address tokenA,\r
        address tokenB,\r
        uint256 liquidity,\r
        uint256 amountAMin,\r
        uint256 amountBMin,\r
        address to,\r
        uint256 deadline,\r
        bool approveMax,\r
        uint8 v,\r
        bytes32 r,\r
        bytes32 s\r
    ) external returns (uint256 amountA, uint256 amountB);\r
\r
    function removeLiquidityETHWithPermit(\r
        address token,\r
        uint256 liquidity,\r
        uint256 amountTokenMin,\r
        uint256 amountETHMin,\r
        address to,\r
        uint256 deadline,\r
        bool approveMax,\r
        uint8 v,\r
        bytes32 r,\r
        bytes32 s\r
    ) external returns (uint256 amountETH);\r
\r
    function swapExactTokensForTokens(\r
        uint256 amountIn,\r
        uint256 amountOutMin,\r
        address[] calldata path,\r
        address to,\r
        uint256 deadline\r
    ) external returns (uint256[] memory amounts);\r
\r
    function swapTokensForExactTokens(\r
        uint256 amountOut,\r
        uint256 amountInMax,\r
        address[] calldata path,\r
        address to,\r
        uint256 deadline\r
    ) external returns (uint256[] memory amounts);\r
\r
    function swapExactETHForTokens(uint256 amountOutMin, address[] calldata path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);\r
\r
    function swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] calldata path, address to, uint256 deadline) external returns (uint256[] memory amounts);\r
\r
    function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline) external returns (uint256[] memory amounts);\r
\r
    function swapETHForExactTokens(uint256 amountOut, address[] calldata path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);\r
\r
    function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);\r
\r
    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountOut);\r
\r
    function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountIn);\r
\r
    function getAmountsOut(uint256 amountIn, address[] calldata path) external view returns (uint256[] memory amounts);\r
\r
    function getAmountsIn(uint256 amountOut, address[] calldata path) external view returns (uint256[] memory amounts);\r
}\r
\r
interface IUniswapV2Router02 is IUniswapV2Router01 {\r
    function removeLiquidityETHSupportingFeeOnTransferTokens(\r
        address token,\r
        uint256 liquidity,\r
        uint256 amountTokenMin,\r
        uint256 amountETHMin,\r
        address to,\r
        uint256 deadline\r
    ) external returns (uint256 amountETH);\r
\r
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(\r
        address token,\r
        uint256 liquidity,\r
        uint256 amountTokenMin,\r
        uint256 amountETHMin,\r
        address to,\r
        uint256 deadline,\r
        bool approveMax,\r
        uint8 v,\r
        bytes32 r,\r
        bytes32 s\r
    ) external returns (uint256 amountETH);\r
\r
    function swapExactTokensForTokensSupportingFeeOnTransferTokens(\r
        uint256 amountIn,\r
        uint256 amountOutMin,\r
        address[] calldata path,\r
        address to,\r
        uint256 deadline\r
    ) external;\r
\r
    function swapExactETHForTokensSupportingFeeOnTransferTokens(\r
        uint256 amountOutMin,\r
        address[] calldata path,\r
        address to,\r
        uint256 deadline\r
    ) external payable;\r
\r
    function swapExactTokensForETHSupportingFeeOnTransferTokens(\r
        uint256 amountIn,\r
        uint256 amountOutMin,\r
        address[] calldata path,\r
        address to,\r
        uint256 deadline\r
    ) external;\r
}\r
\r
contract SUPERHOLDY is Context, IERC20, Ownable {\r
    using SafeMath for uint256;\r
    using Address for address;\r
\r
    mapping(address => uint256) private _rOwned;\r
    mapping(address => mapping(address => uint256)) private _allowances;\r
\r
    mapping(address => bool) private _isExcludedFromFee;\r
\r
    mapping(address => bool) private _isExcludedFromLimit;\r
\r
    uint256 private _tTotal = 10000000 * 10**18;\r
\r
    address payable private _marketingAddress = payable(address(0x9A5b398d154192931F5C9053c4CC651D963Ed0E8));\r
\r
    string private _name = unicode"SUPER HOLDY";\r
    string private _symbol = unicode"HOLDY";\r
    uint8 private _decimals = 18;\r
\r
    struct BuyFee {\r
        uint8 liquidity;\r
        uint8 marketing;\r
    }\r
\r
    struct SellFee {\r
        uint8 liquidity;\r
        uint8 marketing;\r
    }\r
\r
    BuyFee private buyFee;\r
    SellFee private sellFee;\r
\r
    uint8 private _liquidityFee;\r
    uint8 private _marketingFee;\r
\r
    IUniswapV2Router02 private immutable uniswapV2Router;\r
    address private immutable uniswapV2Pair;\r
\r
    bool inSwapAndLiquify;\r
    bool private swapAndLiquifyEnabled = true;\r
\r
    uint256 private _maxTxAmount = _tTotal.div(1000).mul(30); // 3%\r
    uint256 private numTokensSellToAddToLiquidity = _tTotal.div(1000).mul(3); //0.3%\r
    uint256 private _maxWalletSize = _tTotal.div(1000).mul(30); // 3%\r
\r
    event MinTokensBeforeSwapUpdated(uint256 minTokensBeforeSwap);\r
    event SwapAndLiquifyEnabledUpdated(bool enabled);\r
    event SwapAndLiquify(\r
        uint256 tokensSwapped,\r
        uint256 ethReceived,\r
        uint256 tokensIntoLiqudity\r
    );\r
\r
    modifier lockTheSwap() {\r
        inSwapAndLiquify = true;\r
        _;\r
        inSwapAndLiquify = false;\r
    }\r
\r
    bool private tradingOpen = false;\r
\r
    mapping (address => uint256) _lastTrade;\r
\r
    constructor() {\r
        _rOwned[_msgSender()] = _tTotal;\r
\r
        buyFee.liquidity = 1;\r
        buyFee.marketing = 1;\r
\r
        sellFee.liquidity = 1;\r
        sellFee.marketing = 1;\r
\r
        IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);\r
        uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());\r
\r
        uniswapV2Router = _uniswapV2Router;\r
\r
        _isExcludedFromFee[owner()] = true;\r
        _isExcludedFromFee[address(this)] = true;\r
        _isExcludedFromFee[_marketingAddress] = true;\r
\r
        _isExcludedFromLimit[_marketingAddress] = true;\r
        _isExcludedFromLimit[owner()] = true;\r
        _isExcludedFromLimit[address(this)] = true;\r
\r
        emit Transfer(address(0), _msgSender(), _tTotal);\r
    }\r
\r
    function name() public view returns (string memory) {\r
        return _name;\r
    }\r
\r
    function symbol() public view returns (string memory) {\r
        return _symbol;\r
    }\r
\r
    function decimals() public view returns (uint8) {\r
        return _decimals;\r
    }\r
\r
    function totalSupply() public view override returns (uint256) {\r
        return _tTotal;\r
    }\r
\r
    function balanceOf(address account) public view override returns (uint256) {\r
        return _rOwned[account];\r
    }\r
\r
    function transfer(address recipient, uint256 amount) public override returns (bool) {\r
        _transfer(_msgSender(), recipient, amount);\r
        return true;\r
    }\r
\r
    function allowance(address owner, address spender) public view override returns (uint256) {\r
        return _allowances[owner][spender];\r
    }\r
\r
    function approve(address spender, uint256 amount) public 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 override returns (bool) {\r
        _transfer(sender, recipient, amount);\r
        _approve(\r
            sender,\r
            _msgSender(),\r
            _allowances[sender][_msgSender()].sub(\r
                amount,\r
                "ERC20: transfer amount exceeds allowance"\r
            )\r
        );\r
        return true;\r
    }\r
\r
\r
    receive() external payable {}\r
\r
    function _getTValues(uint256 tAmount) private view returns (uint256, uint256, uint256) {\r
        uint256 tLiquidity = calculateLiquidityFee(tAmount);\r
        uint256 tWallet = calculateMarketingFee(tAmount);\r
        uint256 tTransferAmount = tAmount.sub(tLiquidity).sub(tWallet);\r
\r
        return (tTransferAmount, tLiquidity, tWallet);\r
    }\r
\r
    function _takeLiquidity(uint256 tLiquidity) private {\r
        _rOwned[address(this)] = _rOwned[address(this)].add(tLiquidity);\r
    }\r
\r
    function _takeWalletFee(uint256 tWallet) private {\r
        _rOwned[address(this)] = _rOwned[address(this)].add(tWallet);\r
    }\r
\r
    function calculateLiquidityFee(uint256 _amount) private view returns (uint256) {\r
        return _amount.mul(_liquidityFee).div(10**2);\r
    }\r
\r
    function calculateMarketingFee(uint256 _amount) private view returns (uint256) {\r
        return _amount.mul(_marketingFee).div(10**2);\r
    }\r
\r
    function removeAllFee() private {\r
        _liquidityFee = 0;\r
        _marketingFee = 0;\r
    }\r
\r
    function setBuy() private {\r
        _liquidityFee = buyFee.liquidity;\r
        _marketingFee = buyFee.marketing;\r
    }\r
\r
    function setSell() private {\r
        _liquidityFee = sellFee.liquidity;\r
        _marketingFee = sellFee.marketing;\r
    }\r
\r
    function _approve(address owner, address spender, uint256 amount) private {\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 _transfer(\r
        address from,\r
        address to,\r
        uint256 amount\r
    ) private {\r
        require(from != address(0), "ERC20: transfer from the zero address");\r
        require(to != address(0), "ERC20: transfer to the zero address");\r
        require(amount > 0, "Transfer amount must be greater than zero");\r
        \r
        if (from != owner() && to != owner()) require(tradingOpen, "Trading not yet enabled.");\r
\r
        uint256 contractTokenBalance = balanceOf(address(this));\r
\r
        if (contractTokenBalance >= _maxTxAmount) {\r
            contractTokenBalance = _maxTxAmount;\r
        }\r
\r
        bool overMinTokenBalance = contractTokenBalance >= numTokensSellToAddToLiquidity;\r
        if (overMinTokenBalance && !inSwapAndLiquify && from != uniswapV2Pair && swapAndLiquifyEnabled) {\r
            contractTokenBalance = numTokensSellToAddToLiquidity;\r
            swapAndLiquify(contractTokenBalance);\r
        }\r
\r
        bool takeFee = true;\r
\r
        if (_isExcludedFromFee[from] || _isExcludedFromFee[to]) {\r
            takeFee = false;\r
        }\r
        if (takeFee) {\r
            if (!_isExcludedFromLimit[from] && !_isExcludedFromLimit[to]) {\r
                require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");\r
                if (to != uniswapV2Pair) {\r
                    require(amount + balanceOf(to) <= _maxWalletSize, "Recipient exceeds max wallet size.");\r
                }\r
            }\r
        }\r
\r
        _tokenTransfer(from, to, amount, takeFee);\r
    }\r
\r
    function swapAndLiquify(uint256 tokens) private lockTheSwap {\r
        uint256 denominator = (buyFee.liquidity + sellFee.liquidity + buyFee.marketing + sellFee.marketing) * 2;\r
        uint256 tokensToAddLiquidityWith = (tokens * (buyFee.liquidity + sellFee.liquidity)) / denominator;\r
        uint256 toSwap = tokens - tokensToAddLiquidityWith;\r
\r
        uint256 initialBalance = address(this).balance;\r
\r
        swapTokensForEth(toSwap);\r
\r
        uint256 deltaBalance = address(this).balance - initialBalance;\r
        uint256 unitBalance = deltaBalance / (denominator - (buyFee.liquidity + sellFee.liquidity));\r
        uint256 ethToAddLiquidityWith = unitBalance * (buyFee.liquidity + sellFee.liquidity);\r
\r
        if (ethToAddLiquidityWith > 0) {\r
            addLiquidity(tokensToAddLiquidityWith, ethToAddLiquidityWith);\r
        }\r
\r
        uint256 marketingAmt = unitBalance * 2 * (buyFee.marketing + sellFee.marketing);\r
        if (marketingAmt > 0) {\r
            payable(_marketingAddress).transfer(marketingAmt);\r
        }\r
    }\r
\r
    function swapTokensForEth(uint256 tokenAmount) private {\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
        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(\r
            tokenAmount,\r
            0,\r
            path,\r
            address(this),\r
            block.timestamp\r
        );\r
    }\r
\r
    function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {\r
        _approve(address(this), address(uniswapV2Router), tokenAmount);\r
\r
        uniswapV2Router.addLiquidityETH{value: ethAmount}(\r
            address(this),\r
            tokenAmount,\r
            0,\r
            0,\r
            address(this),\r
            block.timestamp\r
        );\r
    }\r
\r
    function _tokenTransfer(\r
        address sender,\r
        address recipient,\r
        uint256 amount,\r
        bool takeFee\r
    ) private {\r
        if (takeFee) {\r
            removeAllFee();\r
            if (sender == uniswapV2Pair) {\r
                setBuy();\r
            }\r
            if (recipient == uniswapV2Pair) {\r
                setSell();\r
            }\r
        }\r
\r
        _transferStandard(sender, recipient, amount);\r
\r
        removeAllFee();\r
    }\r
\r
    function _transferStandard(\r
        address sender,\r
        address recipient,\r
        uint256 tAmount\r
    ) private {\r
        (\r
            uint256 tTransferAmount,\r
            uint256 tLiquidity,\r
            uint256 tWallet\r
        ) = _getTValues(tAmount);\r
\r
        _rOwned[sender] = _rOwned[sender].sub(tAmount);\r
        _rOwned[recipient] = _rOwned[recipient].add(tTransferAmount);\r
        _takeLiquidity(tLiquidity);\r
        _takeWalletFee(tWallet);\r
        emit Transfer(sender, recipient, tTransferAmount);\r
    }\r
\r
    function openTrading() external onlyOwner() {\r
        require(!tradingOpen, "Trading is already open.");\r
        tradingOpen = true;\r
    }\r
}"
    }
  },
  "settings": {
    "optimizer": {
      "enabled": true,
      "runs": 200
    },
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    },
    "remappings": []
  }
}}