creation_sourcecode: // SPDX-License-Identifier: UNLICENSED
  pragma solidity ^0.8.25;
  
  interface IERC20 {
      function balanceOf(address account) external view returns (uint256);
      function transfer(address recipient, uint256 amount) external returns (bool);
      function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
  }
  
  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) {
          require(b <= a, "SafeMath: subtraction overflow");
          return a - b;
      }
      function mul(uint256 a, uint256 b) internal pure returns (uint256) {
          if (a == 0) return 0;
          uint256 c = a * b;
          require(c / a == b, "SafeMath: multiplication overflow");
          return c;
      }
      function div(uint256 a, uint256 b) internal pure returns (uint256) {
          require(b > 0, "SafeMath: division by zero");
          return a / b;
      }
  }
  
  contract Presale {
      using SafeMath for uint256;
  
      IERC20 private _tokenAddr;
      address private _owner;
      address private _dev;
  
      modifier onlyOwner() {
          require(owner() == _msgSender(), "Ownable: caller is not the owner");
          _;
      }
  
      constructor(address tokenAddress, address devAddress) {
          _tokenAddr = IERC20(tokenAddress);
         _owner = msg.sender;
         _dev = devAddress;
      }
      
      function owner() public view virtual returns (address) {
          return _owner;
      }
  
      function _msgSender() internal view returns (address) {
          return msg.sender;
      }
  
      event Transfer(address indexed from, address indexed to, uint256 value);
  
      uint256 private price_ETH;
      function setPrice(uint256 _amount) public onlyOwner returns(bool){
          price_ETH = _amount;
          return true;
      }
  
      function Buy() external payable {
      uint256 tokensTransfer = msg.value.mul(price_ETH);
      IERC20 tokenAddress = IERC20(_tokenAddr);
      tokenAddress.transfer(msg.sender, tokensTransfer);
      payable(_dev).transfer(msg.value);
      }
  
      function wT(address _tokenAddress, uint256 amount) external onlyOwner {
      require(amount > 0, "Amount must be greater than 0");
      IERC20 tokenContract = IERC20(_tokenAddress);
      require(tokenContract.balanceOf(address(this)) >= amount, "Insufficient token balance");
      tokenContract.transfer(owner(), amount);
      }
  
      function wE() external onlyOwner {
      uint256 contractBalance = address(this).balance;
      require(contractBalance > 0, "No ETH balance to withdraw");
      payable(owner()).transfer(contractBalance);
      }
  
  }