creation_sourcecode: /**
   *Submitted for verification at BscScan.com on 2021-05-09
  */
  // SPDX-License-Identifier: MIT
  pragma solidity 0.8.0;
  /*
   * @dev Provides information about the current execution context, including the
   * sender of the transaction and its data. While these are generally available
   * via msg.sender and msg.data, they should not be accessed in such a direct
   * manner, since when dealing with GSN meta-transactions the account sending and
   * paying for execution may not be the actual sender (as far as an application
   * is concerned).
   *
   * This contract is only required for intermediate, library-like contracts.
   */
  abstract contract Context {
      function _msgSender() internal view virtual returns (address) {
          return msg.sender;
      }
      function _msgData() internal view virtual returns (bytes memory) {
          this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
          return msg.data;
      }
  }
  pragma solidity 0.8.0;
  /**
   * @dev Contract module which provides a basic access control mechanism, where
   * there is an account (an owner) that can be granted exclusive access to
   * specific functions.
   *
   * By default, the owner account will be the one that deploys the contract. This
   * can later be changed with {transferOwnership}.
   *
   * This module is used through inheritance. It will make available the modifier
   * `onlyOwner`, which can be applied to your functions to restrict their use to
   * the owner.
   */
  abstract contract Ownable is Context {
      address private _owner;
      event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
      /**
       * @dev Initializes the contract setting the deployer as the initial owner.
       */
      constructor () {
          address msgSender = _msgSender();
          _owner = msgSender;
          emit OwnershipTransferred(address(0), msgSender);
      }
      /**
       * @dev Returns the address of the current owner.
       */
      function owner() public view virtual returns (address) {
          return _owner;
      }
      /**
       * @dev Throws if called by any account other than the owner.
       */
      modifier onlyOwner() {
          require(owner() == _msgSender(), "Ownable: caller is not the owner");
          _;
      }
      /**
       * @dev Leaves the contract without owner. It will not be possible to call
       * `onlyOwner` functions anymore. Can only be called by the current owner.
       *
       * NOTE: Renouncing ownership will leave the contract without an owner,
       * thereby removing any functionality that is only available to the owner.
       */
      function renounceOwnership() public virtual onlyOwner {
          emit OwnershipTransferred(_owner, address(0));
          _owner = address(0);
      }
      /**
       * @dev Transfers ownership of the contract to a new account (`newOwner`).
       * Can only be called by the current owner.
       */
      function transferOwnership(address newOwner) public virtual onlyOwner {
          require(newOwner != address(0), "Ownable: new owner is the zero address");
          emit OwnershipTransferred(_owner, newOwner);
          _owner = newOwner;
      }
  }
  pragma solidity 0.8.0;
  /**
   * @dev Wrappers over Solidity's arithmetic operations with added overflow
   * checks.
   *
   * Arithmetic operations in Solidity wrap on overflow. This can easily result
   * in bugs, because programmers usually assume that an overflow raises an
   * error, which is the standard behavior in high level programming languages.
   * `SafeMath` restores this intuition by reverting the transaction when an
   * operation overflows.
   *
   * Using this library instead of the unchecked operations eliminates an entire
   * class of bugs, so it's recommended to use it always.
   */
  library SafeMath {
      /**
       * @dev Returns the addition of two unsigned integers, with an overflow flag.
       *
       * _Available since v3.4._
       */
      function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
          uint256 c = a + b;
          if (c < a) return (false, 0);
          return (true, c);
      }
      /**
       * @dev Returns the substraction of two unsigned integers, with an overflow flag.
       *
       * _Available since v3.4._
       */
      function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
          if (b > a) return (false, 0);
          return (true, a - b);
      }
      /**
       * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
       *
       * _Available since v3.4._
       */
      function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
          // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
          // benefit is lost if 'b' is also tested.
          // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
          if (a == 0) return (true, 0);
          uint256 c = a * b;
          if (c / a != b) return (false, 0);
          return (true, c);
      }
      /**
       * @dev Returns the division of two unsigned integers, with a division by zero flag.
       *
       * _Available since v3.4._
       */
      function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
          if (b == 0) return (false, 0);
          return (true, a / b);
      }
      /**
       * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
       *
       * _Available since v3.4._
       */
      function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
          if (b == 0) return (false, 0);
          return (true, a % b);
      }
      /**
       * @dev Returns the addition of two unsigned integers, reverting on
       * overflow.
       *
       * Counterpart to Solidity's `+` operator.
       *
       * Requirements:
       *
       * - Addition cannot overflow.
       */
      function add(uint256 a, uint256 b) internal pure returns (uint256) {
          uint256 c = a + b;
          require(c >= a, "SafeMath: addition overflow");
          return c;
      }
      /**
       * @dev Returns the subtraction of two unsigned integers, reverting on
       * overflow (when the result is negative).
       *
       * Counterpart to Solidity's `-` operator.
       *
       * Requirements:
       *
       * - Subtraction cannot overflow.
       */
      function sub(uint256 a, uint256 b) internal pure returns (uint256) {
          require(b <= a, "SafeMath: subtraction overflow");
          return a - b;
      }
      /**
       * @dev Returns the multiplication of two unsigned integers, reverting on
       * overflow.
       *
       * Counterpart to Solidity's `*` operator.
       *
       * Requirements:
       *
       * - Multiplication cannot overflow.
       */
      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;
      }
      /**
       * @dev Returns the integer division of two unsigned integers, reverting on
       * division by zero. The result is rounded towards zero.
       *
       * Counterpart to Solidity's `/` operator. Note: this function uses a
       * `revert` opcode (which leaves remaining gas untouched) while Solidity
       * uses an invalid opcode to revert (consuming all remaining gas).
       *
       * Requirements:
       *
       * - The divisor cannot be zero.
       */
      function div(uint256 a, uint256 b) internal pure returns (uint256) {
          require(b > 0, "SafeMath: division by zero");
          return a / b;
      }
      /**
       * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
       * reverting when dividing by zero.
       *
       * Counterpart to Solidity's `%` operator. This function uses a `revert`
       * opcode (which leaves remaining gas untouched) while Solidity uses an
       * invalid opcode to revert (consuming all remaining gas).
       *
       * Requirements:
       *
       * - The divisor cannot be zero.
       */
      function mod(uint256 a, uint256 b) internal pure returns (uint256) {
          require(b > 0, "SafeMath: modulo by zero");
          return a % b;
      }
      /**
       * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
       * overflow (when the result is negative).
       *
       * CAUTION: This function is deprecated because it requires allocating memory for the error
       * message unnecessarily. For custom revert reasons use {trySub}.
       *
       * Counterpart to Solidity's `-` operator.
       *
       * Requirements:
       *
       * - Subtraction cannot overflow.
       */
      function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
          require(b <= a, errorMessage);
          return a - b;
      }
      /**
       * @dev Returns the integer division of two unsigned integers, reverting with custom message on
       * division by zero. The result is rounded towards zero.
       *
       * CAUTION: This function is deprecated because it requires allocating memory for the error
       * message unnecessarily. For custom revert reasons use {tryDiv}.
       *
       * Counterpart to Solidity's `/` operator. Note: this function uses a
       * `revert` opcode (which leaves remaining gas untouched) while Solidity
       * uses an invalid opcode to revert (consuming all remaining gas).
       *
       * Requirements:
       *
       * - The divisor cannot be zero.
       */
      function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
          require(b > 0, errorMessage);
          return a / b;
      }
      /**
       * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
       * reverting with custom message when dividing by zero.
       *
       * CAUTION: This function is deprecated because it requires allocating memory for the error
       * message unnecessarily. For custom revert reasons use {tryMod}.
       *
       * Counterpart to Solidity's `%` operator. This function uses a `revert`
       * opcode (which leaves remaining gas untouched) while Solidity uses an
       * invalid opcode to revert (consuming all remaining gas).
       *
       * Requirements:
       *
       * - The divisor cannot be zero.
       */
      function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
          require(b > 0, errorMessage);
          return a % b;
      }
  }
  //--------------------------CROWD SALE------------------------
  pragma solidity 0.8.0;
  interface IERC20 {
      function totalSupply() external view returns (uint256);
      function balanceOf(address account) external view returns (uint256);
      function transfer(address recipient, uint256 amount) external returns (bool);
      function allowance(address owner, address spender) external view returns (uint256);
      function approve(address spender, uint256 amount) external returns (bool);
      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);
  }
  contract PreSale is Ownable {
      using SafeMath for uint256;
      
      IERC20 public token; // Token being sold in the presale.
      // Presale parameters
      uint256 public _TOTAL_SOLD_TOKEN; // Total amount of tokens sold.
      uint256 public _TOTAL_DEPOSIT_BNB; // Total BNB collected.
      uint256 public _RATE; // Rate of token per BNB.
      uint256 public _MAX_BNB_CONTRIBUTION; // Maximum BNB contribution per wallet.
      uint256 public _MIN_BNB_CONTRIBUTION; // Minimum BNB contribution.
      // Vesting parameters
      uint256 public initialReleasePercentage; // Percentage of tokens to be released initially.
      uint256 public fullReleaseTime; // Timestamp when full release completes.
      uint256 public _SOFTCAP; // Minimum amount of BNB to be raised for the presale to be considered successful.
      uint256 public _HARDCAP; // Maximum amount of BNB that can be raised.
      uint256 public _START_TIME; // Start time of the presale.
      uint256 public _END_TIME; // End time of the presale.
      uint256 public _RELEASE_TOKEN_TIME; // Time when tokens start to become available for withdrawal.
      bool public isPreSaleOpen; // Flag indicating if the presale is open.
      
      // Mapping to track blacklisted users and token purchase amounts.
      mapping(address => bool) public isBlacklisted;
      mapping(address => uint256) public totalPurchased;
      mapping(address => uint256) public withdrawnTokens;
      mapping(address => bool) public withdrawn; // Tracks whether a user has withdrawn their initial tokens.
      constructor() {}
      // Allows the owner to set the address of the token being sold.
      function setTokenAddress(address _tokenAddress) public onlyOwner {
          require(_tokenAddress != address(0), "Invalid token address");
          token = IERC20(_tokenAddress);
      }
      // Allows owner to set the vesting schedule.
      function setVestingSchedule(uint256 _initialReleasePercentage, uint256 _releaseTime, uint256 _fullReleaseTime) public onlyOwner {
          require(_initialReleasePercentage > 0 && _initialReleasePercentage <= 100, "Invalid release percentage");
          require(_releaseTime < _fullReleaseTime, "Release time must be before full release time");
          initialReleasePercentage = _initialReleasePercentage;
          fullReleaseTime = _fullReleaseTime;
      }
      // Fallback function to handle BNB deposits.
      receive() external payable {
          deposite();
      }
      // Allows the owner to withdraw collected BNB after the presale ends, provided the softcap is reached.
      function ownerWithdrawBNB() public onlyOwner {
          require(block.timestamp > _END_TIME, "Presale hasn't finished yet");
          require(_TOTAL_DEPOSIT_BNB >= _SOFTCAP, "Presale didn't hit softcap");
          payable(msg.sender).transfer(address(this).balance);
      }
      // Allows the owner to withdraw any unsold tokens after the presale.
      function ownerWithdrawToken() public onlyOwner {
          token.transfer(msg.sender, token.balanceOf(address(this)));
      }
      // Function to blacklist or unblacklist users.
      function addToBlacklist(address user) external onlyOwner { isBlacklisted[user] = true; }
      function removeFromBlacklist(address user) external onlyOwner { isBlacklisted[user] = false; }
      // Setup function for the presale parameters.
      function setupPresale(uint256 start, uint256 end, uint256 release, uint256 rate, uint256 softcap, uint256 hardcap, uint256 maxPerWallet, uint256 minPerWallet) public onlyOwner {
          _RATE = rate;
          _MAX_BNB_CONTRIBUTION = maxPerWallet;
          _MIN_BNB_CONTRIBUTION = minPerWallet;
          _SOFTCAP = softcap;
          _HARDCAP = hardcap;
          _START_TIME = start;
          _END_TIME = end;
          _RELEASE_TOKEN_TIME = release;
      }
      function setRate(uint256 rate) public onlyOwner {
          _RATE = rate;
      }
      // Opens or closes the presale.
      function openPresale(bool opened) public onlyOwner { isPreSaleOpen = opened; }
      // Function for users to deposit BNB and purchase tokens during the presale.
      function deposite() public payable {
          require(isPreSaleOpen, "Presale is not open");
          require(block.timestamp >= _START_TIME && block.timestamp <= _END_TIME, "Not in presale time");
          require(msg.value >= _MIN_BNB_CONTRIBUTION && msg.value <= _MAX_BNB_CONTRIBUTION, "Invalid BNB amount");
          require(!isBlacklisted[_msgSender()], "You are blacklisted");
          require(_TOTAL_DEPOSIT_BNB.add(msg.value) <= _HARDCAP, "Exceed HARD CAP");
          totalPurchased[msg.sender]=  totalPurchased[msg.sender].add(msg.value);
          _TOTAL_DEPOSIT_BNB = _TOTAL_DEPOSIT_BNB.add(msg.value);
      }
      // Allows users to withdraw their vested tokens.
      function withdrawTokens() public {
          require(block.timestamp > _RELEASE_TOKEN_TIME, "Vesting period not started");
          
          uint256 totalTokens = totalPurchased[msg.sender].mul(_RATE);
          uint256 tokensToRelease = totalTokens.mul(initialReleasePercentage).div(100);
          uint256 vestedTokens = 0;
          if (block.timestamp >= fullReleaseTime) {
              vestedTokens = totalTokens; // All tokens are vested
          } else {
              uint256 vestingDuration = fullReleaseTime - _RELEASE_TOKEN_TIME;
              uint256 timeSinceRelease = block.timestamp - _RELEASE_TOKEN_TIME;
              uint256 additionalTokensVested = totalTokens.sub(tokensToRelease).mul(timeSinceRelease).div(vestingDuration);
              vestedTokens = tokensToRelease.add(additionalTokensVested);
          }
          uint256 tokensToWithdraw = vestedTokens.sub(withdrawnTokens[msg.sender]);
          require(tokensToWithdraw > 0, "No vested tokens available for withdrawal");
          withdrawnTokens[msg.sender] = withdrawnTokens[msg.sender].add(tokensToWithdraw);
          withdrawn[msg.sender] = true;
          require(token.transfer(msg.sender, tokensToWithdraw), "Token transfer failed");
      }
  }