Update panoramix.py

[Herand19]

No description provided.

[Herand19]

Comit

[Herand19]

.d

[Dioliode]

DioX

[Dioliode]

DioX

[Herand19]

H

[Dioliode]

DioX

[Herand19]

.

[Dioliode]

DioX

[Herand19]

.

[Muaytie23]

/**
*Submitted for verification at optimistic.etherscan.io on 2023-03-19
*/

// File: @openzeppelin/contracts/utils/introspection/IERC165.sol

// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**

• @dev Interface of the ERC165 standard, as defined in the
• https://eips.ethereum.org/EIPS/eip-165[EIP].
• Implementers can declare support of contract interfaces, which can then be
• queried by others ({ERC165Checker}).
• For an implementation, see {ERC165}.
  /
  interface IERC165 {
  /*
  • @dev Returns true if this contract implements the interface defined by
  • interfaceId. See the corresponding
  • https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
  • to learn more about how these ids are created.
  • This function call must use less than 30 000 gas.
    */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
    }

// File: @openzeppelin/contracts/utils/introspection/ERC165.sol

// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;

/**

• @dev Implementation of the {IERC165} interface.
• Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
• for the additional interface id that will be supported. For example:
• function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {

• return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
  

• }
• Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
  /
  abstract contract ERC165 is IERC165 {
  /*
  • @dev See {IERC165-supportsInterface}.
    */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
    return interfaceId == type(IERC165).interfaceId;
    }
    }

// File: @openzeppelin/contracts/utils/math/Math.sol

// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**

• @dev Standard math utilities missing in the Solidity language.
  */
  library Math {
  enum Rounding {
  Down, // Toward negative infinity
  Up, // Toward infinity
  Zero // Toward zero
  }

  /**

  • @dev Returns the largest of two numbers.
    */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
    return a > b ? a : b;
    }

  /**

  • @dev Returns the smallest of two numbers.
    */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
    return a < b ? a : b;
    }

  /**

  • @dev Returns the average of two numbers. The result is rounded towards
  • zero.
    */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
    // (a + b) / 2 can overflow.
    return (a & b) + (a ^ b) / 2;
    }

  /**

  • @dev Returns the ceiling of the division of two numbers.
  • This differs from standard division with / in that it rounds up instead
  • of rounding down.
    */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
    // (a + b - 1) / b can overflow on addition, so we distribute.
    return a == 0 ? 0 : (a - 1) / b + 1;
    }

  /**

  • @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0

  • @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)

  • with further edits by Uniswap Labs also under MIT license.
    */
    function mulDiv(
    uint256 x,
    uint256 y,
    uint256 denominator
    ) internal pure returns (uint256 result) {
    unchecked {
    // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
    // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
    // variables such that product = prod1 * 2^256 + prod0.
    uint256 prod0; // Least significant 256 bits of the product
    uint256 prod1; // Most significant 256 bits of the product
    assembly {
    let mm := mulmod(x, y, not(0))
    prod0 := mul(x, y)
    prod1 := sub(sub(mm, prod0), lt(mm, prod0))
    }

     // Handle non-overflow cases, 256 by 256 division.
     if (prod1 == 0) {
         return prod0 / denominator;
     }
    
     // Make sure the result is less than 2^256. Also prevents denominator == 0.
     require(denominator > prod1);
    
     ///////////////////////////////////////////////
     // 512 by 256 division.
     ///////////////////////////////////////////////
    
     // Make division exact by subtracting the remainder from [prod1 prod0].
     uint256 remainder;
     assembly {
         // Compute remainder using mulmod.
         remainder := mulmod(x, y, denominator)
    
         // Subtract 256 bit number from 512 bit number.
         prod1 := sub(prod1, gt(remainder, prod0))
         prod0 := sub(prod0, remainder)
     }
    
     // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
     // See https://cs.stackexchange.com/q/138556/92363.
    
     // Does not overflow because the denominator cannot be zero at this stage in the function.
     uint256 twos = denominator & (~denominator + 1);
     assembly {
         // Divide denominator by twos.
         denominator := div(denominator, twos)
    
         // Divide [prod1 prod0] by twos.
         prod0 := div(prod0, twos)
    
         // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
         twos := add(div(sub(0, twos), twos), 1)
     }
    
     // Shift in bits from prod1 into prod0.
     prod0 |= prod1 * twos;
    
     // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
     // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
     // four bits. That is, denominator * inv = 1 mod 2^4.
     uint256 inverse = (3 * denominator) ^ 2;
    
     // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
     // in modular arithmetic, doubling the correct bits in each step.
     inverse *= 2 - denominator * inverse; // inverse mod 2^8
     inverse *= 2 - denominator * inverse; // inverse mod 2^16
     inverse *= 2 - denominator * inverse; // inverse mod 2^32
     inverse *= 2 - denominator * inverse; // inverse mod 2^64
     inverse *= 2 - denominator * inverse; // inverse mod 2^128
     inverse *= 2 - denominator * inverse; // inverse mod 2^256
    
     // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
     // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
     // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
     // is no longer required.
     result = prod0 * inverse;
     return result;
    

    }
    }

  /**

  • @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
    */
    function mulDiv(
    uint256 x,
    uint256 y,
    uint256 denominator,
    Rounding rounding
    ) internal pure returns (uint256) {
    uint256 result = mulDiv(x, y, denominator);
    if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
    result += 1;
    }
    return result;
    }

  /**

  • @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.

  • Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
    */
    function sqrt(uint256 a) internal pure returns (uint256) {
    if (a == 0) {
    return 0;
    }

    // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
    //
    // We know that the "msb" (most significant bit) of our target number a is a power of 2 such that we have
    // msb(a) <= a < 2*msb(a). This value can be written msb(a)=2**k with k=log2(a).
    //
    // This can be rewritten 2**log2(a) <= a < 2**(log2(a) + 1)
    // → sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))
    // → 2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)
    //
    // Consequently, 2**(log2(a) / 2) is a good first approximation of sqrt(a) with at least 1 correct bit.
    uint256 result = 1 << (log2(a) >> 1);

    // At this point result is an estimation with one bit of precision. We know the true value is a uint128,
    // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
    // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
    // into the expected uint128 result.
    unchecked {
    result = (result + a / result) >> 1;
    result = (result + a / result) >> 1;
    result = (result + a / result) >> 1;
    result = (result + a / result) >> 1;
    result = (result + a / result) >> 1;
    result = (result + a / result) >> 1;
    result = (result + a / result) >> 1;
    return min(result, a / result);
    }
    }

  /**

  • @notice Calculates sqrt(a), following the selected rounding direction.
    */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
    unchecked {
    uint256 result = sqrt(a);
    return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
    }
    }

  /**

  • @dev Return the log in base 2, rounded down, of a positive value.
  • Returns 0 if given 0.
    */
    function log2(uint256 value) internal pure returns (uint256) {
    uint256 result = 0;
    unchecked {
    if (value >> 128 > 0) {
    value >>= 128;
    result += 128;
    }
    if (value >> 64 > 0) {
    value >>= 64;
    result += 64;
    }
    if (value >> 32 > 0) {
    value >>= 32;
    result += 32;
    }
    if (value >> 16 > 0) {
    value >>= 16;
    result += 16;
    }
    if (value >> 8 > 0) {
    value >>= 8;
    result += 8;
    }
    if (value >> 4 > 0) {
    value >>= 4;
    result += 4;
    }
    if (value >> 2 > 0) {
    value >>= 2;
    result += 2;
    }
    if (value >> 1 > 0) {
    result += 1;
    }
    }
    return result;
    }

  /**

  • @dev Return the log in base 2, following the selected rounding direction, of a positive value.
  • Returns 0 if given 0.
    */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
    unchecked {
    uint256 result = log2(value);
    return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
    }
    }

  /**

  • @dev Return the log in base 10, rounded down, of a positive value.
  • Returns 0 if given 0.
    */
    function log10(uint256 value) internal pure returns (uint256) {
    uint256 result = 0;
    unchecked {
    if (value >= 1064) {
    value /= 1064;
    result += 64;
    }
    if (value >= 1032) {
    value /= 1032;
    result += 32;
    }
    if (value >= 1016) {
    value /= 1016;
    result += 16;
    }
    if (value >= 108) {
    value /= 108;
    result += 8;
    }
    if (value >= 104) {
    value /= 104;
    result += 4;
    }
    if (value >= 102) {
    value /= 102;
    result += 2;
    }
    if (value >= 10**1) {
    result += 1;
    }
    }
    return result;
    }

  /**

  • @dev Return the log in base 10, following the selected rounding direction, of a positive value.
  • Returns 0 if given 0.
    */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
    unchecked {
    uint256 result = log10(value);
    return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
    }
    }

  /**

  • @dev Return the log in base 256, rounded down, of a positive value.
  • Returns 0 if given 0.
  • Adding one to the result gives the number of pairs of hex symbols needed to represent value as a hex string.
    */
    function log256(uint256 value) internal pure returns (uint256) {
    uint256 result = 0;
    unchecked {
    if (value >> 128 > 0) {
    value >>= 128;
    result += 16;
    }
    if (value >> 64 > 0) {
    value >>= 64;
    result += 8;
    }
    if (value >> 32 > 0) {
    value >>= 32;
    result += 4;
    }
    if (value >> 16 > 0) {
    value >>= 16;
    result += 2;
    }
    if (value >> 8 > 0) {
    result += 1;
    }
    }
    return result;
    }

  /**

  • @dev Return the log in base 10, following the selected rounding direction, of a positive value.
  • Returns 0 if given 0.
    */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
    unchecked {
    uint256 result = log256(value);
    return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
    }
    }
    }

// File: @openzeppelin/contracts/utils/Strings.sol

// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

/**

• @dev String operations.
  */
  library Strings {
  bytes16 private constant _SYMBOLS = "0123456789abcdef";
  uint8 private constant _ADDRESS_LENGTH = 20;

  /**

  • @dev Converts a uint256 to its ASCII string decimal representation.
    */
    function toString(uint256 value) internal pure returns (string memory) {
    unchecked {
    uint256 length = Math.log10(value) + 1;
    string memory buffer = new string(length);
    uint256 ptr;
    /// @solidity memory-safe-assembly
    assembly {
    ptr := add(buffer, add(32, length))
    }
    while (true) {
    ptr--;
    /// @solidity memory-safe-assembly
    assembly {
    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
    }
    value /= 10;
    if (value == 0) break;
    }
    return buffer;
    }
    }

  /**

  • @dev Converts a uint256 to its ASCII string hexadecimal representation.
    */
    function toHexString(uint256 value) internal pure returns (string memory) {
    unchecked {
    return toHexString(value, Math.log256(value) + 1);
    }
    }

  /**

  • @dev Converts a uint256 to its ASCII string hexadecimal representation with fixed length.
    */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
    bytes memory buffer = new bytes(2 * length + 2);
    buffer[0] = "0";
    buffer[1] = "x";
    for (uint256 i = 2 * length + 1; i > 1; --i) {
    buffer[i] = _SYMBOLS[value & 0xf];
    value >>= 4;
    }
    require(value == 0, "Strings: hex length insufficient");
    return string(buffer);
    }

  /**

  • @dev Converts an address with fixed length of 20 bytes to its not checksummed ASCII string hexadecimal representation.
    */
    function toHexString(address addr) internal pure returns (string memory) {
    return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }
    }

// File: @openzeppelin/contracts/access/IAccessControl.sol

// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)

pragma solidity ^0.8.0;

/**

• @dev External interface of AccessControl declared to support ERC165 detection.
  /
  interface IAccessControl {
  /*

  • @dev Emitted when newAdminRole is set as role's admin role, replacing previousAdminRole
  • DEFAULT_ADMIN_ROLE is the starting admin for all roles, despite
  • {RoleAdminChanged} not being emitted signaling this.
  • Available since v3.1.
    */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

  /**

  • @dev Emitted when account is granted role.
  • sender is the account that originated the contract call, an admin role
  • bearer except when using {AccessControl-_setupRole}.
    */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

  /**

  • @dev Emitted when account is revoked role.
  • sender is the account that originated the contract call:
  • • if using revokeRole, it is the admin role bearer
  • • if using renounceRole, it is the role bearer (i.e. account)
      */
      event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

  /**

  • @dev Returns true if account has been granted role.
    */
    function hasRole(bytes32 role, address account) external view returns (bool);

  /**

  • @dev Returns the admin role that controls role. See {grantRole} and
  • {revokeRole}.
  • To change a role's admin, use {AccessControl-_setRoleAdmin}.
    */
    function getRoleAdmin(bytes32 role) external view returns (bytes32);

  /**

  • @dev Grants role to account.
  • If account had not been already granted role, emits a {RoleGranted}
  • event.
  • Requirements:
  • • the caller must have role's admin role.
      */
      function grantRole(bytes32 role, address account) external;

  /**

  • @dev Revokes role from account.
  • If account had been granted role, emits a {RoleRevoked} event.
  • Requirements:
  • • the caller must have role's admin role.
      */
      function revokeRole(bytes32 role, address account) external;

  /**

  • @dev Revokes role from the calling account.
  • Roles are often managed via {grantRole} and {revokeRole}: this function's
  • purpose is to provide a mechanism for accounts to lose their privileges
  • if they are compromised (such as when a trusted device is misplaced).
  • If the calling account had been granted role, emits a {RoleRevoked}
  • event.
  • Requirements:
  • • the caller must be account.
      */
      function renounceRole(bytes32 role, address account) external;
      }

// File: @openzeppelin/contracts/utils/Context.sol

// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

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 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 calldata) {
  return msg.data;
  }
  }

// File: @openzeppelin/contracts/access/Ownable.sol

// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

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() {
    _transferOwnership(_msgSender());
    }

  /**

  • @dev Throws if called by any account other than the owner.
    */
    modifier onlyOwner() {
    _checkOwner();
    _;
    }

  /**

  • @dev Returns the address of the current owner.
    */
    function owner() public view virtual returns (address) {
    return _owner;
    }

  /**

  • @dev Throws if the sender is not the owner.
    */
    function _checkOwner() internal view virtual {
    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 {
    _transferOwnership(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");
    _transferOwnership(newOwner);
    }

  /**

  • @dev Transfers ownership of the contract to a new account (newOwner).
  • Internal function without access restriction.
    */
    function _transferOwnership(address newOwner) internal virtual {
    address oldOwner = _owner;
    _owner = newOwner;
    emit OwnershipTransferred(oldOwner, newOwner);
    }
    }

// File: contracts/taxable.sol

pragma solidity ^0.8.0; // Must use solidity 0.8.0 or higher. Math isn't so safe otherwise...

abstract contract Taxable is Context {

/// @dev Events defined for any contract changes.

event TaxOn(address account); // Emits event "Tax On" when tax is enabled, returning the address of the Governor.
event TaxOff(address account); // Emits event "Tax Off" when tax is disabled, returning the address of the Governor.
event TaxChanged(address account); // Emits event "Tax Changed" when tax amount is updated, returning the address of the Governor.
event TaxDestinationChanged(address account); // Emits event "Tax Destination Changed" when tax destination is changed, returning the address of the President.

/// @dev Name and type of constants defined.

bool private _taxed; // Stores whether tax is enabled/disabled in a boolean.
uint private _thetax; // Stores tax amount as a uint256 integer.
uint private _maxtax; // Stores maximum tax amount as a uint256 integer.
uint private _mintax; // Stores minimum tax amount as a uint256 integer.
address private _taxdestination; // Stores tax destination as a blockchain address type.
address private _taxdestination2; // Stores tax destination as a blockchain address type.
address private _taxdestination3; // Stores tax destination as a blockchain address type.

/// @dev Constructor adds values to constants by passing arguments from token constructor.

constructor(bool __taxed, uint __thetax, uint __maxtax, uint __mintax, address __taxdestination, address __taxdestination2 ,address __taxdestination3) {
    _taxed = __taxed; // Recommended: false 
    _thetax = __thetax; // Recommended: 1000 ; 1000 = 10%
    _maxtax = __maxtax; // Recommended: 1500 ; 1500 = 15%
    _mintax = __mintax; // Recommended: 25 ; 25 = 0.25%
    _taxdestination = __taxdestination;
    _taxdestination2 = __taxdestination2;
    _taxdestination3 = __taxdestination3; // Recommend a fresh, dedicated secure treasury hot or cold wallet that is not the deployer.
}

/// @dev Modifiers throw errors if conditions are not met.

modifier whenNotTaxed() { // Modifier for requiring the tax be off in order for the caller function to work.
    _requireNotTaxed(); // Function requires tax be off.
    _;
}

modifier whenTaxed() { // Modifier for requiring the tax be on in order for the caller function to work.
    _requireTaxed(); // Function requires tax be on.
    _;
}

/// @dev Public view functions allow privately stored constants to be interfaced.

function taxed() public view virtual returns (bool) { // Function enables public interface for tax enabled/disabled boolean.
    return _taxed; // Returns true if tax is enabled, false if it is disabled.
}

function thetax() public view virtual returns (uint) { // Function enables public interface for tax amount in points.
    return _thetax; // Returns the current tax amount in points.
}

function taxdestination() public view virtual returns (address) { // Function enables public interface for tax destination address.
    return _taxdestination; // Returns the destination address for the tax.
}
    function taxdestination2() public view virtual returns (address) { // Function enables public interface for tax destination address.
    return _taxdestination2; // Returns the destination address for the tax.
}
    function taxdestination3() public view virtual returns (address) { // Function enables public interface for tax destination address.
    return _taxdestination3; // Returns the destination address for the tax.
}

/// @dev Internal view functions contain the require() statements for the modifiers to use.

function _requireNotTaxed() internal view virtual { // Function is used in the whenNotTaxed() modifier.
    require(!taxed(), "Taxable: taxed"); // Throws the call if the tax is disabled.
}

function _requireTaxed() internal view virtual { // Function is used in the whenTaxed() modifier.
    require(taxed(), "Taxable: not taxed"); // Throws the call if the tax is enabled.
}

/// @dev Internal virtual functions perform the requested contract updates and emit the events to the blockchain.

function _taxon() internal virtual whenNotTaxed { // Function turns on the tax if it was disabled and emits "Tax On" event.
    _taxed = true; // Sets the tax enabled boolean to true, enabling the tax.
    emit TaxOn(_msgSender()); // Emits the "Tax On" event to the blockchain.
}

function _taxoff() internal virtual whenTaxed { // Function turns off the tax if it was enabled and emits "Tax Off" event.
    _taxed = false; // Sets the tax enabled boolean to false, disabling the tax.
    emit TaxOff(_msgSender()); // Emits the "Tax Off" event to the blockchain.
}

function _updatetax(uint newtax) internal virtual { // Function updates the tax amount if in allowable range and emits "Tax Changed" event.
    require(newtax <= _maxtax, "Taxable: tax is too high"); // Throws the call if the new tax is above the maximum tax.
    require(newtax >= _mintax, "Taxable: tax is too low"); // Throws the call if the new tax is below the minimum tax.
    _thetax = newtax; // Sets the tax amount integer to the new value, updating the tax amount.
    emit TaxChanged(_msgSender());  // Emits the "Tax Changed" event to the blockchain.
}

function _updatetaxdestination(address newdestination, address newdestination2,address newdestination3) internal virtual { // Function updates the tax destination address and emits "Tax Destination Changed" event.
    _taxdestination = newdestination;
    _taxdestination2 = newdestination2; 
    _taxdestination3 = newdestination3;  // Sets the tax destination address to the new value, updating the tax destination address.
    emit TaxDestinationChanged(_msgSender());  // Emits the "Tax Destination Changed" event to the blockchain.
}

}
// File: @openzeppelin/contracts/access/AccessControl.sol

// OpenZeppelin Contracts (last updated v4.8.0) (access/AccessControl.sol)

pragma solidity ^0.8.0;

/**

• @dev Contract module that allows children to implement role-based access

• control mechanisms. This is a lightweight version that doesn't allow enumerating role

• members except through off-chain means by accessing the contract event logs. Some

• applications may benefit from on-chain enumerability, for those cases see

• {AccessControlEnumerable}.

• Roles are referred to by their bytes32 identifier. These should be exposed

• in the external API and be unique. The best way to achieve this is by

• using public constant hash digests:

• bytes32 public constant MY_ROLE = keccak256("MY_ROLE");

• Roles can be used to represent a set of permissions. To restrict access to a

• function call, use {hasRole}:

• function foo() public {

• require(hasRole(MY_ROLE, msg.sender));
  

• ...
  

• }

• Roles can be granted and revoked dynamically via the {grantRole} and

• {revokeRole} functions. Each role has an associated admin role, and only

• accounts that have a role's admin role can call {grantRole} and {revokeRole}.

• By default, the admin role for all roles is DEFAULT_ADMIN_ROLE, which means

• that only accounts with this role will be able to grant or revoke other

• roles. More complex role relationships can be created by using

• {_setRoleAdmin}.

• WARNING: The DEFAULT_ADMIN_ROLE is also its own admin: it has permission to

• grant and revoke this role. Extra precautions should be taken to secure

• accounts that have been granted it.
  */
  abstract contract AccessControl is Context, IAccessControl, ERC165 {
  struct RoleData {
  mapping(address => bool) members;
  bytes32 adminRole;
  }

  mapping(bytes32 => RoleData) private _roles;

  bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

  /**

  • @dev Modifier that checks that an account has a specific role. Reverts
  • with a standardized message including the required role.
  • The format of the revert reason is given by the following regular expression:
  • /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
  • Available since v4.1.
    */
    modifier onlyRole(bytes32 role) {
    _checkRole(role);
    _;
    }

  /**

  • @dev See {IERC165-supportsInterface}.
    */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
    return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
    }

  /**

  • @dev Returns true if account has been granted role.
    */
    function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
    return _roles[role].members[account];
    }

  /**

  • @dev Revert with a standard message if _msgSender() is missing role.
  • Overriding this function changes the behavior of the {onlyRole} modifier.
  • Format of the revert message is described in {_checkRole}.
  • Available since v4.6.
    */
    function _checkRole(bytes32 role) internal view virtual {
    _checkRole(role, _msgSender());
    }

  /**

  • @dev Revert with a standard message if account is missing role.
  • The format of the revert reason is given by the following regular expression:
  • /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
    */
    function _checkRole(bytes32 role, address account) internal view virtual {
    if (!hasRole(role, account)) {
    revert(
    string(
    abi.encodePacked(
    "AccessControl: account ",
    Strings.toHexString(account),
    " is missing role ",
    Strings.toHexString(uint256(role), 32)
    )
    )
    );
    }
    }

  /**

  • @dev Returns the admin role that controls role. See {grantRole} and
  • {revokeRole}.
  • To change a role's admin, use {_setRoleAdmin}.
    */
    function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
    return _roles[role].adminRole;
    }

  /**

  • @dev Grants role to account.
  • If account had not been already granted role, emits a {RoleGranted}
  • event.
  • Requirements:
  • • the caller must have role's admin role.
  • May emit a {RoleGranted} event.
    */
    function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
    _grantRole(role, account);
    }

  /**

  • @dev Revokes role from account.
  • If account had been granted role, emits a {RoleRevoked} event.
  • Requirements:
  • • the caller must have role's admin role.
  • May emit a {RoleRevoked} event.
    */
    function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
    _revokeRole(role, account);
    }

  /**

  • @dev Revokes role from the calling account.

  • Roles are often managed via {grantRole} and {revokeRole}: this function's

  • purpose is to provide a mechanism for accounts to lose their privileges

  • if they are compromised (such as when a trusted device is misplaced).

  • If the calling account had been revoked role, emits a {RoleRevoked}

  • event.

  • Requirements:

  • • the caller must be account.

  • May emit a {RoleRevoked} event.
    */
    function renounceRole(bytes32 role, address account) public virtual override {
    require(account == _msgSender(), "AccessControl: can only renounce roles for self");

    _revokeRole(role, account);
    }

  /**

  • @dev Grants role to account.
  • If account had not been already granted role, emits a {RoleGranted}
  • event. Note that unlike {grantRole}, this function doesn't perform any
  • checks on the calling account.
  • May emit a {RoleGranted} event.
  • [WARNING]
  • ====
  • This function should only be called from the constructor when setting
  • up the initial roles for the system.
  • Using this function in any other way is effectively circumventing the admin
  • system imposed by {AccessControl}.
  • ====
  • NOTE: This function is deprecated in favor of {_grantRole}.
    */
    function _setupRole(bytes32 role, address account) internal virtual {
    _grantRole(role, account);
    }

  /**

  • @dev Sets adminRole as role's admin role.
  • Emits a {RoleAdminChanged} event.
    */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
    bytes32 previousAdminRole = getRoleAdmin(role);
    _roles[role].adminRole = adminRole;
    emit RoleAdminChanged(role, previousAdminRole, adminRole);
    }

  /**

  • @dev Grants role to account.
  • Internal function without access restriction.
  • May emit a {RoleGranted} event.
    */
    function _grantRole(bytes32 role, address account) internal virtual {
    if (!hasRole(role, account)) {
    _roles[role].members[account] = true;
    emit RoleGranted(role, account, _msgSender());
    }
    }

  /**

  • @dev Revokes role from account.
  • Internal function without access restriction.
  • May emit a {RoleRevoked} event.
    */
    function _revokeRole(bytes32 role, address account) internal virtual {
    if (hasRole(role, account)) {
    _roles[role].members[account] = false;
    emit RoleRevoked(role, account, _msgSender());
    }
    }
    }

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol

// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**

• @dev Interface of the ERC20 standard as defined in the EIP.
  /
  interface IERC20 {
  /*

  • @dev Emitted when value tokens are moved from one account (from) to
  • another (to).
  • Note that value may be zero.
    */
    event Transfer(address indexed from, address indexed to, uint256 value);

  /**

  • @dev Emitted when the allowance of a spender for an owner is set by
  • a call to {approve}. value is the new allowance.
    */
    event Approval(address indexed owner, address indexed spender, uint256 value);

  /**

  • @dev Returns the amount of tokens in existence.
    */
    function totalSupply() external view returns (uint256);

  /**

  • @dev Returns the amount of tokens owned by account.
    */
    function balanceOf(address account) external view returns (uint256);

  /**

  • @dev Moves amount tokens from the caller's account to to.
  • Returns a boolean value indicating whether the operation succeeded.
  • Emits a {Transfer} event.
    */
    function transfer(address to, uint256 amount) external returns (bool);

  /**

  • @dev Returns the remaining number of tokens that spender will be
  • allowed to spend on behalf of owner through {transferFrom}. This is
  • zero by default.
  • This value changes when {approve} or {transferFrom} are called.
    */
    function allowance(address owner, address spender) external view returns (uint256);

  /**

  • @dev Sets amount as the allowance of spender over the caller's tokens.
  • Returns a boolean value indicating whether the operation succeeded.
  • IMPORTANT: Beware that changing an allowance with this method brings the risk
  • that someone may use both the old and the new allowance by unfortunate
  • transaction ordering. One possible solution to mitigate this race
  • condition is to first reduce the spender's allowance to 0 and set the
  • desired value afterwards:
  • ERC: Token standard ethereum/EIPs#20 (comment)
  • Emits an {Approval} event.
    */
    function approve(address spender, uint256 amount) external returns (bool);

  /**

  • @dev Moves amount tokens from from to to using the
  • allowance mechanism. amount is then deducted from the caller's
  • allowance.
  • Returns a boolean value indicating whether the operation succeeded.
  • Emits a {Transfer} event.
    */
    function transferFrom(
    address from,
    address to,
    uint256 amount
    ) external returns (bool);
    }

// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol

// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;

/**

• @dev Interface for the optional metadata functions from the ERC20 standard.

• Available since v4.1.
  /
  interface IERC20Metadata is IERC20 {
  /*

  • @dev Returns the name of the token.
    */
    function name() external view returns (string memory);

  /**

  • @dev Returns the symbol of the token.
    */
    function symbol() external view returns (string memory);

  /**

  • @dev Returns the decimals places of the token.
    */
    function decimals() external view returns (uint8);
    }

// File: @openzeppelin/contracts/token/ERC20/ERC20.sol

// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.0;

/**

• @dev Implementation of the {IERC20} interface.

• This implementation is agnostic to the way tokens are created. This means

• that a supply mechanism has to be added in a derived contract using {_mint}.

• For a generic mechanism see {ERC20PresetMinterPauser}.

• TIP: For a detailed writeup see our guide

• https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How

• to implement supply mechanisms].

• We have followed general OpenZeppelin Contracts guidelines: functions revert

• instead returning false on failure. This behavior is nonetheless

• conventional and does not conflict with the expectations of ERC20

• applications.

• Additionally, an {Approval} event is emitted on calls to {transferFrom}.

• This allows applications to reconstruct the allowance for all accounts just

• by listening to said events. Other implementations of the EIP may not emit

• these events, as it isn't required by the specification.

• Finally, the non-standard {decreaseAllowance} and {increaseAllowance}

• functions have been added to mitigate the well-known issues around setting

• allowances. See {IERC20-approve}.
  */
  contract ERC20 is Context, IERC20, IERC20Metadata {
  mapping(address => uint256) private _balances;

  mapping(address => mapping(address => uint256)) private _allowances;

  uint256 private _totalSupply;

  string private _name;
  string private _symbol;

  /**

  • @dev Sets the values for {name} and {symbol}.
  • The default value of {decimals} is 18. To select a different value for
  • {decimals} you should overload it.
  • All two of these values are immutable: they can only be set once during
  • construction.
    */
    constructor(string memory name_, string memory symbol_) {
    name = name;
    symbol = symbol;
    }

  /**

  • @dev Returns the name of the token.
    */
    function name() public view virtual override returns (string memory) {
    return _name;
    }

  /**

  • @dev Returns the symbol of the token, usually a shorter version of the
  • name.
    */
    function symbol() public view virtual override returns (string memory) {
    return _symbol;
    }

  /**

  • @dev Returns the number of decimals used to get its user representation.
  • For example, if decimals equals 2, a balance of 505 tokens should
  • be displayed to a user as 5.05 (505 / 10 ** 2).
  • Tokens usually opt for a value of 18, imitating the relationship between
  • Ether and Wei. This is the value {ERC20} uses, unless this function is
  • overridden;
  • NOTE: This information is only used for display purposes: it in
  • no way affects any of the arithmetic of the contract, including
  • {IERC20-balanceOf} and {IERC20-transfer}.
    */
    function decimals() public view virtual override returns (uint8) {
    return 18;
    }

  /**

  • @dev See {IERC20-totalSupply}.
    */
    function totalSupply() public view virtual override returns (uint256) {
    return _totalSupply;
    }

  /**

  • @dev See {IERC20-balanceOf}.
    */
    function balanceOf(address account) public view virtual override returns (uint256) {
    return _balances[account];
    }

  /**

  • @dev See {IERC20-transfer}.
  • Requirements:
  • • to cannot be the zero address.
  • • the caller must have a balance of at least amount.
      */
      function transfer(address to, uint256 amount) public virtual override returns (bool) {
      address owner = _msgSender();
      _transfer(owner, to, amount);
      return true;
      }

  /**

  • @dev See {IERC20-allowance}.
    */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
    return _allowances[owner][spender];
    }

  /**

  • @dev See {IERC20-approve}.
  • NOTE: If amount is the maximum uint256, the allowance is not updated on
  • transferFrom. This is semantically equivalent to an infinite approval.
  • Requirements:
  • • spender cannot be the zero address.
      */
      function approve(address spender, uint256 amount) public virtual override returns (bool) {
      address owner = _msgSender();
      _approve(owner, spender, amount);
      return true;
      }

  /**

  • @dev See {IERC20-transferFrom}.
  • Emits an {Approval} event indicating the updated allowance. This is not
  • required by the EIP. See the note at the beginning of {ERC20}.
  • NOTE: Does not update the allowance if the current allowance
  • is the maximum uint256.
  • Requirements:
  • • from and to cannot be the zero address.
  • • from must have a balance of at least amount.
  • • the caller must have allowance for from's tokens of at least
  • amount.
    */
    function transferFrom(
    address from,
    address to,
    uint256 amount
    ) public virtual override returns (bool) {
    address spender = _msgSender();
    _spendAllowance(from, spender, amount);
    _transfer(from, to, amount);
    return true;
    }

  /**

  • @dev Atomically increases the allowance granted to spender by the caller.
  • This is an alternative to {approve} that can be used as a mitigation for
  • problems described in {IERC20-approve}.
  • Emits an {Approval} event indicating the updated allowance.
  • Requirements:
  • • spender cannot be the zero address.
      */
      function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
      address owner = _msgSender();
      _approve(owner, spender, allowance(owner, spender) + addedValue);
      return true;
      }

  /**

  • @dev Atomically decreases the allowance granted to spender by the caller.

  • This is an alternative to {approve} that can be used as a mitigation for

  • problems described in {IERC20-approve}.

  • Emits an {Approval} event indicating the updated allowance.

  • Requirements:

  • • spender cannot be the zero address.
  • • spender must have allowance for the caller of at least

  • subtractedValue.
    */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
    address owner = _msgSender();
    uint256 currentAllowance = allowance(owner, spender);
    require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
    unchecked {
    _approve(owner, spender, currentAllowance - subtractedValue);
    }

    return true;
    }

  /**

  • @dev Moves amount of tokens from from to to.

  • This internal function is equivalent to {transfer}, and can be used to

  • e.g. implement automatic token fees, slashing mechanisms, etc.

  • Emits a {Transfer} event.

  • Requirements:

  • • from cannot be the zero address.
  • • to cannot be the zero address.
  • • from must have a balance of at least amount.
      */
      function _transfer(
      address from,
      address to,
      uint256 amount
      ) internal virtual {
      require(from != address(0), "ERC20: transfer from the zero address");
      require(to != address(0), "ERC20: transfer to the zero address");

    _beforeTokenTransfer(from, to, amount);

    uint256 fromBalance = _balances[from];
    require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
    unchecked {
    _balances[from] = fromBalance - amount;
    // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
    // decrementing then incrementing.
    _balances[to] += amount;
    }

    emit Transfer(from, to, amount);

    _afterTokenTransfer(from, to, amount);
    }

  /** @dev Creates amount tokens and assigns them to account, increasing

  • the total supply.

  • Emits a {Transfer} event with from set to the zero address.

  • Requirements:

  • • account cannot be the zero address.
      */
      function _mint(address account, uint256 amount) internal virtual {
      require(account != address(0), "ERC20: mint to the zero address");

    _beforeTokenTransfer(address(0), account, amount);

    _totalSupply += amount;
    unchecked {
    // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
    _balances[account] += amount;
    }
    emit Transfer(address(0), account, amount);

    _afterTokenTransfer(address(0), account, amount);
    }

  /**

  • @dev Destroys amount tokens from account, reducing the

  • total supply.

  • Emits a {Transfer} event with to set to the zero address.

  • Requirements:

  • • account cannot be the zero address.
  • • account must have at least amount tokens.
      */
      function _burn(address account, uint256 amount) internal virtual {
      require(account != address(0), "ERC20: burn from the zero address");

    _beforeTokenTransfer(account, address(0), amount);

    uint256 accountBalance = _balances[account];
    require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
    unchecked {
    _balances[account] = accountBalance - amount;
    // Overflow not possible: amount <= accountBalance <= totalSupply.
    _totalSupply -= amount;
    }

    emit Transfer(account, address(0), amount);

    _afterTokenTransfer(account, address(0), amount);
    }

  /**

  • @dev Sets amount as the allowance of spender over the owner s tokens.

  • This internal function is equivalent to approve, and can be used to

  • e.g. set automatic allowances for certain subsystems, etc.

  • Emits an {Approval} event.

  • Requirements:

  • • owner cannot be the zero address.
  • • spender cannot be the zero address.
      */
      function _approve(
      address owner,
      address spender,
      uint256 amount
      ) internal virtual {
      require(owner != address(0), "ERC20: approve from the zero address");
      require(spender != address(0), "ERC20: approve to the zero address");

    _allowances[owner][spender] = amount;
    emit Approval(owner, spender, amount);
    }

  /**

  • @dev Updates owner s allowance for spender based on spent amount.
  • Does not update the allowance amount in case of infinite allowance.
  • Revert if not enough allowance is available.
  • Might emit an {Approval} event.
    */
    function _spendAllowance(
    address owner,
    address spender,
    uint256 amount
    ) internal virtual {
    uint256 currentAllowance = allowance(owner, spender);
    if (currentAllowance != type(uint256).max) {
    require(currentAllowance >= amount, "ERC20: insufficient allowance");
    unchecked {
    _approve(owner, spender, currentAllowance - amount);
    }
    }
    }

  /**

  • @dev Hook that is called before any transfer of tokens. This includes
  • minting and burning.
  • Calling conditions:
  • • when from and to are both non-zero, amount of from's tokens
  • will be transferred to to.
  • • when from is zero, amount tokens will be minted for to.
  • • when to is zero, amount of from's tokens will be burned.
  • • from and to are never both zero.
  • To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
    */
    function _beforeTokenTransfer(
    address from,
    address to,
    uint256 amount
    ) internal virtual {}

  /**

  • @dev Hook that is called after any transfer of tokens. This includes
  • minting and burning.
  • Calling conditions:
  • • when from and to are both non-zero, amount of from's tokens
  • has been transferred to to.
  • • when from is zero, amount tokens have been minted for to.
  • • when to is zero, amount of from's tokens have been burned.
  • • from and to are never both zero.
  • To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
    */
    function _afterTokenTransfer(
    address from,
    address to,
    uint256 amount
    ) internal virtual {}
    }

// File: @openzeppelin/contracts/security/ReentrancyGuard.sol

// OpenZeppelin Contracts (last updated v4.8.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**

• @dev Contract module that helps prevent reentrant calls to a function.

• Inheriting from ReentrancyGuard will make the {nonReentrant} modifier

• available, which can be applied to functions to make sure there are no nested

• (reentrant) calls to them.

• Note that because there is a single nonReentrant guard, functions marked as

• nonReentrant may not call one another. This can be worked around by making

• those functions private, and then adding external nonReentrant entry

• points to them.

• TIP: If you would like to learn more about reentrancy and alternative ways

• to protect against it, check out our blog post

• https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
  */
  abstract contract ReentrancyGuard {
  // Booleans are more expensive than uint256 or any type that takes up a full
  // word because each write operation emits an extra SLOAD to first read the
  // slot's contents, replace the bits taken up by the boolean, and then write
  // back. This is the compiler's defense against contract upgrades and
  // pointer aliasing, and it cannot be disabled.

  // The values being non-zero value makes deployment a bit more expensive,
  // but in exchange the refund on every call to nonReentrant will be lower in
  // amount. Since refunds are capped to a percentage of the total
  // transaction's gas, it is best to keep them low in cases like this one, to
  // increase the likelihood of the full refund coming into effect.
  uint256 private constant _NOT_ENTERED = 1;
  uint256 private constant _ENTERED = 2;

  uint256 private _status;

  constructor() {
  _status = _NOT_ENTERED;
  }

  /**

  • @dev Prevents a contract from calling itself, directly or indirectly.
  • Calling a nonReentrant function from another nonReentrant
  • function is not supported. It is possible to prevent this from happening
  • by making the nonReentrant function external, and making it call a
  • private function that does the actual work.
    */
    modifier nonReentrant() {
    _nonReentrantBefore();
    _;
    _nonReentrantAfter();
    }

  function _nonReentrantBefore() private {
  // On the first call to nonReentrant, _status will be _NOT_ENTERED
  require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

   // Any calls to nonReentrant after this point will fail
   _status = _ENTERED;
  

  }

  function _nonReentrantAfter() private {
  // By storing the original value once again, a refund is triggered (see
  // https://eips.ethereum.org/EIPS/eip-2200)
  _status = _NOT_ENTERED;
  }
  }

// File: contracts/yfxmultichain.sol

pragma solidity ^0.8.4;

contract YFX is ReentrancyGuard, ERC20, AccessControl, Taxable, Ownable {

bytes32 public constant NOT_TAXED_FROM = keccak256("NOT_TAXED_FROM");
bytes32 public constant NOT_TAXED_TO = keccak256("NOT_TAXED_TO");
bytes32 public constant ALWAYS_TAXED_FROM = keccak256("ALWAYS_TAXED_FROM");
bytes32 public constant ALWAYS_TAXED_TO = keccak256("ALWAYS_TAXED_TO");
address public constant deadaddr = 0x000000000000000000000000000000000000dEaD;
address minter;

constructor(

    bool __taxed,
    uint __thetax,
    uint __maxtax,
    uint __mintax,
    address __owner,
    address __owner2,
    address __owner3
    )
    ERC20("YieldFarming Index", "YFX")
    Taxable(__taxed, __thetax, __maxtax, __mintax, __owner, __owner2, __owner3)
{
    _grantRole(DEFAULT_ADMIN_ROLE, __owner);
    _grantRole(NOT_TAXED_FROM, __owner);
    _grantRole(NOT_TAXED_TO, __owner);
    _grantRole(NOT_TAXED_FROM, __owner2);
    _grantRole(NOT_TAXED_TO, __owner2);
    _grantRole(NOT_TAXED_FROM, __owner3);
    _grantRole(NOT_TAXED_TO, __owner3);
    _grantRole(NOT_TAXED_FROM, address(this));
    _grantRole(NOT_TAXED_TO, address(this));
    _mint(__owner, 500000 * 10 ** decimals());
    minter = msg.sender;
}

function enableTax() public onlyRole(DEFAULT_ADMIN_ROLE) {
    _taxon();
}

function whitelisttax(address _user) external onlyOwner{
    _grantRole(NOT_TAXED_FROM, _user);
    _grantRole(NOT_TAXED_TO, _user);
}

function whitelisttaxTO(address _user) external onlyOwner{

    _grantRole(NOT_TAXED_TO, _user);
}

    function whitelisttaxFROM(address _user) external onlyOwner{
    _grantRole(NOT_TAXED_FROM, _user);

}

function disableTax() public onlyRole(DEFAULT_ADMIN_ROLE) {
    _taxoff();
}

function updateTax(uint newtax) public onlyRole(DEFAULT_ADMIN_ROLE) {
    _updatetax(newtax);
}

function updateTaxDestination(address newdestination, address newdestination2, address newdestination3) public onlyRole(DEFAULT_ADMIN_ROLE) {
    _updatetaxdestination(newdestination, newdestination2, newdestination3);
}

function _transfer(address from, address to, uint256 amount)
internal
virtual
override(ERC20)
nonReentrant
{
if (hasRole(DEFAULT_ADMIN_ROLE, msg.sender)) {
super._transfer(from, to, amount);
} else {
if((hasRole(NOT_TAXED_FROM, from) || hasRole(NOT_TAXED_TO, to) || !taxed())
&& !hasRole(ALWAYS_TAXED_FROM, from) && !hasRole(ALWAYS_TAXED_TO, to)) {
super._transfer(from, to, amount);
} else {
require(balanceOf(from) >= amount, "Error: transfer amount exceeds balance");
super._transfer(from, taxdestination(), amountthetax()3/200000);
super._transfer(from, taxdestination2(), amountthetax()6/200000);
super._transfer(from, taxdestination3(), amountthetax()/200000);
super._transfer(from, deadaddr, amountthetax()/20000);
super._transfer(from, to, amount*(10000-thetax())/10000);
}
}
}

function burn(address _from, uint256 _amount) external{
    require(msg.sender == minter);
    _burn(_from, _amount);
}

function mint(address recipient, uint256 _amount) external  {
    require(msg.sender == minter);
    _mint(recipient, _amount);

}

function updateMinter(address _minter) external onlyOwner  {
    minter = _minter;

}

}