Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address from, a ...
• interface IERC20Metadata is IERC20
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function _msgSender()
•    - function _msgData()
•    - function owner()
•    - function _checkOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(
•    - function functionCallWithValue(addres ...
•    - function functionCallWithValue(
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(
•    - function verifyCallResultFromTarget(
•    - function verifyCallResult(
•    - function _revert(bytes memory returnd ...
•  contract DxBurnToken is Context, I ... *
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
•    - function increaseAllowance(address sp ...
•    - function decreaseAllowance(address sp ...
•    - function isExcludedFromFee(address ac ...
•    - function excludeFromFee(address accou ...
•    - function includeInFee(address account ...
•    - function setDevWalletAddress(address ...
•    - function replaceDevWalletAddress(addr ...
•    - function setDevFeePercent(uint8 devFe ...
•    - function setBurnFeePercent(uint8 burn ...
•    - function burn(uint256 _value)
•    - function _transfer(address sender, ad ...
•    - function _mint(address account, uint2 ...
•    - function _burn(address account, uint2 ...
•    - function _approve(address owner, addr ...
•    - function _beforeTokenTransfer(address ...
•    - function transferOwnership(address ne ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-07-11
*/

/*
// Official DxBurn Token
// To Mint your own token visit https://dx.app
// DxMint verified tokens are unruggable through code
// To view the audit certificate for this token search it in https://dx.app/dxmint
// Please ensure one wallet doesn't hold too much supply of tokens!
*/

// SPDX-License-Identifier: MIT

pragma solidity 0.8.7;
pragma experimental ABIEncoderV2;


/**
 * @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:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * 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);
}


/**
 * @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);
}


/**
 * @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;
    }
}


/**
 * @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. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling 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);
    }
}


/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

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

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}


contract DxBurnToken is Context, IERC20, IERC20Metadata,Ownable {
    bool public mintedByDxsale = true;
    uint256 private _totalSupply;
    bool public mintingFinishedPermanent = false;
    string private _name;
    string private _symbol;
    uint8 private _decimals;
    address public _creator;
    uint8 public _burnFee;
    uint8 public _devFee;
    uint256 public _maxBurnFee;
    uint256 public _maxDevFee;
    address public _devWalletAddress;

    mapping (address => uint256) private _balances;
    mapping (address => mapping (address => uint256)) private _allowances;
    mapping (address => bool) private _isExcludedFromFee;
    mapping (address => bool) private _isdevWallet;

    constructor (address creator_,string memory name_, string memory symbol_,uint8 decimals_, uint256 tokenSupply_, uint8 burnFee_, uint8 devFee_, uint256 maxBurnFee_, uint256 maxDevFee_, address devWalletAddress_) {
        _name = name_;
        _symbol = symbol_;
        _decimals = decimals_;
        _creator = creator_;
        _burnFee = burnFee_;
        _devFee = devFee_;
        _maxBurnFee = maxBurnFee_;
        _maxDevFee = maxDevFee_;
        _devWalletAddress = devWalletAddress_;

        //excluded addresses from fees
        _isExcludedFromFee[creator_] = true;
        _isExcludedFromFee[address(this)] = true;
        _isExcludedFromFee[_devWalletAddress] = true;
    
        //set wallet provided to true
        _isdevWallet[_devWalletAddress] = true;

        
        _mint(_creator,tokenSupply_);
        mintingFinishedPermanent = true;
    }

    /**
     * @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 _decimals;
    }

    /**
     * @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:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, 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}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), 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}.
     *
     * Requirements:
     *
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);

        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
        _approve(sender, _msgSender(), currentAllowance - 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) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][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) {
        uint256 currentAllowance = _allowances[_msgSender()][spender];
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        _approve(_msgSender(), spender, currentAllowance - subtractedValue);

        return true;
    }

    function isExcludedFromFee(address account) public view returns (bool) {
        return _isExcludedFromFee[account];
    }

    function excludeFromFee(address account) public onlyOwner {
        require(!_isExcludedFromFee[account], "Account is already excluded");
        _isExcludedFromFee[account] = true;
    }
    
    function includeInFee(address account) public onlyOwner {
        require(_isExcludedFromFee[account], "Account is already included");
        _isExcludedFromFee[account] = false;
    }
        
    function setDevWalletAddress(address _addr) internal virtual {
        if (!_isExcludedFromFee[_addr]) {
            excludeFromFee(_addr);
        }
        _isdevWallet[_addr] = true;
        _devWalletAddress = _addr;
    }

    function replaceDevWalletAddress(address _addr, address _newAddr) public onlyOwner {
        require(_isdevWallet[_addr], "Wallet address not set previously");
        require(!_isdevWallet[_newAddr], "Wallet address already set");
        if (_isExcludedFromFee[_addr]) {
            includeInFee(_addr);
        }
        _isdevWallet[_addr] = false;
        setDevWalletAddress(_newAddr);
    }

    function setDevFeePercent(uint8 devFee) external onlyOwner() {
        require(devFee >= 0 && devFee <= _maxDevFee,"teamFee out of range");
        _devFee = devFee;
    }      

    function setBurnFeePercent(uint8 burnFee) external onlyOwner() {
        require(burnFee >= 0 && burnFee <= _maxBurnFee,"teamFee out of range");
        _burnFee = burnFee;
    } 
    
    function burn(uint256 _value) public {
        _burn(msg.sender, _value);
    } 

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is 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:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(address sender, address recipient, uint256 amount) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");
 
        uint256 senderBalance = _balances[sender];
        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");

        if(_isExcludedFromFee[sender] || _isExcludedFromFee[recipient]){
            _balances[sender] = senderBalance - amount;
            _balances[recipient] += amount;
            emit Transfer(sender, recipient, amount);
        }

        if(!_isExcludedFromFee[sender] && !_isExcludedFromFee[recipient]){
            uint256 amountForBurn = (amount * _burnFee) / 100;
            uint256 amountForDev = (amount * _devFee) / 100;

            uint256 amountToSend = amount - amountForBurn - amountForDev;

            _balances[sender] = senderBalance - amountForDev - amountToSend;
            _burn(sender, amountForBurn);

            _balances[_devWalletAddress] += amountForDev;
            emit Transfer(sender, _devWalletAddress, amountForDev);

            _balances[recipient] += amountToSend;
            emit Transfer(sender, recipient, amountToSend);
        }
    }

    /** @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(!mintingFinishedPermanent,"cant be minted anymore!");
        require(account != address(0), "ERC20: mint to the zero address");

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

        _totalSupply += amount;
        _balances[account] += amount;
        emit Transfer(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");
        _balances[account] = accountBalance - amount;
        _totalSupply -= amount;

        emit Transfer(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 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 to 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 { }

    //exclude new owner from fees
    function transferOwnership(address newOwner) public virtual override onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
        _isExcludedFromFee[newOwner] = true;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"creator_","type":"address"},{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"uint8","name":"decimals_","type":"uint8"},{"internalType":"uint256","name":"tokenSupply_","type":"uint256"},{"internalType":"uint8","name":"burnFee_","type":"uint8"},{"internalType":"uint8","name":"devFee_","type":"uint8"},{"internalType":"uint256","name":"maxBurnFee_","type":"uint256"},{"internalType":"uint256","name":"maxDevFee_","type":"uint256"},{"internalType":"address","name":"devWalletAddress_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"_burnFee","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_creator","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_devFee","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_devWalletAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_maxBurnFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_maxDevFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"excludeFromFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"includeInFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isExcludedFromFee","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintedByDxsale","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintingFinishedPermanent","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"},{"internalType":"address","name":"_newAddr","type":"address"}],"name":"replaceDevWalletAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint8","name":"burnFee","type":"uint8"}],"name":"setBurnFeePercent","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint8","name":"devFee","type":"uint8"}],"name":"setDevFeePercent","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

16395:13187:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18072:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;20246:169;;;;;;:::i;:::-;;:::i;:::-;;;2072:14:1;;2065:22;2047:41;;2035:2;2020:18;20246:169:0;1907:187:1;19199:108:0;19287:12;;19199:108;;;9078:25:1;;;9066:2;9051:18;19199:108:0;8932:177:1;20897:422:0;;;;;;:::i;:::-;;:::i;19034:100::-;19117:9;;;;19034:100;;;9286:4:1;9274:17;;;9256:36;;9244:2;9229:18;19034:100:0;9114:184:1;21728:215:0;;;;;;:::i;:::-;;:::i;24404:81::-;;;;;;:::i;:::-;;:::i;:::-;;22963:190;;;;;;:::i;:::-;;:::i;16763:26::-;;;;;;22831:124;;;;;;:::i;:::-;-1:-1:-1;;;;;22920:27:0;22896:4;22920:27;;;:18;:27;;;;;;;;;22831:124;16466:33;;;;;-1:-1:-1;;;16466:33:0;;;;;;19370:127;;;;;;:::i;:::-;-1:-1:-1;;;;;19471:18:0;19444:7;19471:18;;;:9;:18;;;;;;;19370:127;6095:103;;;:::i;24210:181::-;;;;;;:::i;:::-;;:::i;5454:87::-;5500:7;5527:6;-1:-1:-1;;;;;5527:6:0;5454:87;;;-1:-1:-1;;;;;1863:32:1;;;1845:51;;1833:2;1818:18;5454:87:0;1699:203:1;18291:104:0;;;:::i;22446:377::-;;;;;;:::i;:::-;;:::i;19710:175::-;;;;;;:::i;:::-;;:::i;16736:20::-;;;;;-1:-1:-1;;;16736:20:0;;;;;;16828:32;;;;;-1:-1:-1;;;;;16828:32:0;;;24022:174;;;;;;:::i;:::-;;:::i;16678:23::-;;;;;;;;-1:-1:-1;;;;;16678:23:0;;;16708:21;;;;;-1:-1:-1;;;16708:21:0;;;;;;23609:405;;;;;;:::i;:::-;;:::i;19948:151::-;;;;;;:::i;:::-;-1:-1:-1;;;;;20064:18:0;;;20037:7;20064:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;19948:151;23165:188;;;;;;:::i;:::-;;:::i;29323:256::-;;;;;;:::i;:::-;;:::i;16796:25::-;;;;;;16541:44;;;;;;;;;18072:100;18126:13;18159:5;18152:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18072:100;:::o;20246:169::-;20329:4;20346:39;4241:10;20369:7;20378:6;20346:8;:39::i;:::-;-1:-1:-1;20403:4:0;20246:169;;;;:::o;20897:422::-;21003:4;21020:36;21030:6;21038:9;21049:6;21020:9;:36::i;:::-;-1:-1:-1;;;;;21096:19:0;;21069:24;21096:19;;;:11;:19;;;;;;;;4241:10;21096:33;;;;;;;;21148:26;;;;21140:79;;;;-1:-1:-1;;;21140:79:0;;5639:2:1;21140:79:0;;;5621:21:1;5678:2;5658:18;;;5651:30;5717:34;5697:18;;;5690:62;-1:-1:-1;;;5768:18:1;;;5761:38;5816:19;;21140:79:0;;;;;;;;;21230:57;21239:6;4241:10;21261:25;21280:6;21261:16;:25;:::i;:::-;21230:8;:57::i;:::-;-1:-1:-1;21307:4:0;;20897:422;-1:-1:-1;;;;20897:422:0:o;21728:215::-;4241:10;21816:4;21865:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;21865:34:0;;;;;;;;;;21816:4;;21833:80;;21856:7;;21865:47;;21902:10;;21865:47;:::i;24404:81::-;24452:25;24458:10;24470:6;24452:5;:25::i;:::-;24404:81;:::o;22963:190::-;5340:13;:11;:13::i;:::-;-1:-1:-1;;;;;23041:27:0;::::1;;::::0;;;:18:::1;:27;::::0;;;;;::::1;;23040:28;23032:68;;;::::0;-1:-1:-1;;;23032:68:0;;4520:2:1;23032:68:0::1;::::0;::::1;4502:21:1::0;4559:2;4539:18;;;4532:30;4598:29;4578:18;;;4571:57;4645:18;;23032:68:0::1;4318:351:1::0;23032:68:0::1;-1:-1:-1::0;;;;;23111:27:0::1;;::::0;;;:18:::1;:27;::::0;;;;:34;;-1:-1:-1;;23111:34:0::1;23141:4;23111:34;::::0;;22963:190::o;6095:103::-;5340:13;:11;:13::i;:::-;6160:30:::1;6187:1;6160:18;:30::i;:::-;6095:103::o:0;24210:181::-;5340:13;:11;:13::i;:::-;24319:11:::1;;24308:7;:22;;;;24284:70;;;::::0;-1:-1:-1;;;24284:70:0;;6409:2:1;24284:70:0::1;::::0;::::1;6391:21:1::0;6448:2;6428:18;;;6421:30;-1:-1:-1;;;6467:18:1;;;6460:50;6527:18;;24284:70:0::1;6207:344:1::0;24284:70:0::1;24365:8;:18:::0;;::::1;::::0;;::::1;-1:-1:-1::0;;;24365:18:0::1;-1:-1:-1::0;;;;24365:18:0;;::::1;::::0;;;::::1;::::0;;24210:181::o;18291:104::-;18347:13;18380:7;18373:14;;;;;:::i;22446:377::-;4241:10;22539:4;22583:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;22583:34:0;;;;;;;;;;22636:35;;;;22628:85;;;;-1:-1:-1;;;22628:85:0;;8728:2:1;22628:85:0;;;8710:21:1;8767:2;8747:18;;;8740:30;8806:34;8786:18;;;8779:62;-1:-1:-1;;;8857:18:1;;;8850:35;8902:19;;22628:85:0;8526:401:1;22628:85:0;22724:67;4241:10;22747:7;22756:34;22775:15;22756:16;:34;:::i;22724:67::-;-1:-1:-1;22811:4:0;;22446:377;-1:-1:-1;;;22446:377:0:o;19710:175::-;19796:4;19813:42;4241:10;19837:9;19848:6;19813:9;:42::i;24022:174::-;5340:13;:11;:13::i;:::-;24127:10:::1;;24117:6;:20;;;;24094:67;;;::::0;-1:-1:-1;;;24094:67:0;;6409:2:1;24094:67:0::1;::::0;::::1;6391:21:1::0;6448:2;6428:18;;;6421:30;-1:-1:-1;;;6467:18:1;;;6460:50;6527:18;;24094:67:0::1;6207:344:1::0;24094:67:0::1;24172:7;:16:::0;;::::1;::::0;;::::1;-1:-1:-1::0;;;24172:16:0::1;-1:-1:-1::0;;;;24172:16:0;;::::1;::::0;;;::::1;::::0;;24022:174::o;23609:405::-;5340:13;:11;:13::i;:::-;-1:-1:-1;;;;;23711:19:0;::::1;;::::0;;;:12:::1;:19;::::0;;;;;::::1;;23703:65;;;::::0;-1:-1:-1;;;23703:65:0;;7160:2:1;23703:65:0::1;::::0;::::1;7142:21:1::0;7199:2;7179:18;;;7172:30;7238:34;7218:18;;;7211:62;-1:-1:-1;;;7289:18:1;;;7282:31;7330:19;;23703:65:0::1;6958:397:1::0;23703:65:0::1;-1:-1:-1::0;;;;;23788:22:0;::::1;;::::0;;;:12:::1;:22;::::0;;;;;::::1;;23787:23;23779:62;;;::::0;-1:-1:-1;;;23779:62:0;;7968:2:1;23779:62:0::1;::::0;::::1;7950:21:1::0;8007:2;7987:18;;;7980:30;8046:28;8026:18;;;8019:56;8092:18;;23779:62:0::1;7766:350:1::0;23779:62:0::1;-1:-1:-1::0;;;;;23856:25:0;::::1;;::::0;;;:18:::1;:25;::::0;;;;;::::1;;23852:77;;;23898:19;23911:5;23898:12;:19::i;:::-;-1:-1:-1::0;;;;;23939:19:0;::::1;23961:5;23939:19:::0;;;:12:::1;:19;::::0;;;;:27;;-1:-1:-1;;23939:27:0::1;::::0;;23977:29:::1;23997:8:::0;23977:19:::1;:29::i;:::-;23609:405:::0;;:::o;23165:188::-;5340:13;:11;:13::i;:::-;-1:-1:-1;;;;;23240:27:0;::::1;;::::0;;;:18:::1;:27;::::0;;;;;::::1;;23232:67;;;::::0;-1:-1:-1;;;23232:67:0;;5283:2:1;23232:67:0::1;::::0;::::1;5265:21:1::0;5322:2;5302:18;;;5295:30;5361:29;5341:18;;;5334:57;5408:18;;23232:67:0::1;5081:351:1::0;23232:67:0::1;-1:-1:-1::0;;;;;23310:27:0::1;23340:5;23310:27:::0;;;:18:::1;:27;::::0;;;;:35;;-1:-1:-1;;23310:35:0::1;::::0;;23165:188::o;29323:256::-;5340:13;:11;:13::i;:::-;-1:-1:-1;;;;;29421:22:0;::::1;29413:73;;;::::0;-1:-1:-1;;;29413:73:0;;3710:2:1;29413:73:0::1;::::0;::::1;3692:21:1::0;3749:2;3729:18;;;3722:30;3788:34;3768:18;;;3761:62;-1:-1:-1;;;3839:18:1;;;3832:36;3885:19;;29413:73:0::1;3508:402:1::0;29413:73:0::1;29497:28;29516:8;29497:18;:28::i;28239:346::-:0;-1:-1:-1;;;;;28341:19:0;;28333:68;;;;-1:-1:-1;;;28333:68:0;;8323:2:1;28333:68:0;;;8305:21:1;8362:2;8342:18;;;8335:30;8401:34;8381:18;;;8374:62;-1:-1:-1;;;8452:18:1;;;8445:34;8496:19;;28333:68:0;8121:400:1;28333:68:0;-1:-1:-1;;;;;28420:21:0;;28412:68;;;;-1:-1:-1;;;28412:68:0;;4117:2:1;28412:68:0;;;4099:21:1;4156:2;4136:18;;;4129:30;4195:34;4175:18;;;4168:62;-1:-1:-1;;;4246:18:1;;;4239:32;4288:19;;28412:68:0;3915:398:1;28412:68:0;-1:-1:-1;;;;;28493:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;28545:32;;9078:25:1;;;28545:32:0;;9051:18:1;28545:32:0;;;;;;;;28239:346;;;:::o;24976:1301::-;-1:-1:-1;;;;;25082:20:0;;25074:70;;;;-1:-1:-1;;;25074:70:0;;7562:2:1;25074:70:0;;;7544:21:1;7601:2;7581:18;;;7574:30;7640:34;7620:18;;;7613:62;-1:-1:-1;;;7691:18:1;;;7684:35;7736:19;;25074:70:0;7360:401:1;25074:70:0;-1:-1:-1;;;;;25163:23:0;;25155:71;;;;-1:-1:-1;;;25155:71:0;;2903:2:1;25155:71:0;;;2885:21:1;2942:2;2922:18;;;2915:30;2981:34;2961:18;;;2954:62;-1:-1:-1;;;3032:18:1;;;3025:33;3075:19;;25155:71:0;2701:399:1;25155:71:0;-1:-1:-1;;;;;25264:17:0;;25240:21;25264:17;;;:9;:17;;;;;;25300:23;;;;25292:74;;;;-1:-1:-1;;;25292:74:0;;4876:2:1;25292:74:0;;;4858:21:1;4915:2;4895:18;;;4888:30;4954:34;4934:18;;;4927:62;-1:-1:-1;;;5005:18:1;;;4998:36;5051:19;;25292:74:0;4674:402:1;25292:74:0;-1:-1:-1;;;;;25382:26:0;;;;;;:18;:26;;;;;;;;;:59;;-1:-1:-1;;;;;;25412:29:0;;;;;;:18;:29;;;;;;;;25382:59;25379:232;;;25477:22;25493:6;25477:13;:22;:::i;:::-;-1:-1:-1;;;;;25457:17:0;;;;;;;:9;:17;;;;;;:42;;;;25514:20;;;;;;;;:30;;25538:6;;25457:17;25514:30;;25538:6;;25514:30;:::i;:::-;;;;;;;;25581:9;-1:-1:-1;;;;;25564:35:0;25573:6;-1:-1:-1;;;;;25564:35:0;-1:-1:-1;;;;;;;;;;;25592:6:0;25564:35;;;;9078:25:1;;9066:2;9051:18;;8932:177;25564:35:0;;;;;;;;25379:232;-1:-1:-1;;;;;25627:26:0;;;;;;:18;:26;;;;;;;;25626:27;:61;;;;-1:-1:-1;;;;;;25658:29:0;;;;;;:18;:29;;;;;;;;25657:30;25626:61;25623:647;;;25737:8;;25703:21;;25749:3;;25728:17;;-1:-1:-1;;;25737:8:0;;;;25728:6;:17;:::i;:::-;25727:25;;;;:::i;:::-;25800:7;;25703:49;;-1:-1:-1;25767:20:0;;25811:3;;25791:16;;-1:-1:-1;;;25800:7:0;;;;25791:6;:16;:::i;:::-;25790:24;;;;:::i;:::-;25767:47;-1:-1:-1;25831:20:0;25767:47;25854:22;25863:13;25854:6;:22;:::i;:::-;:37;;;;:::i;:::-;25831:60;-1:-1:-1;25831:60:0;25928:28;25944:12;25928:13;:28;:::i;:::-;:43;;;;:::i;:::-;-1:-1:-1;;;;;25908:17:0;;;;;;:9;:17;;;;;:63;25986:28;25918:6;26000:13;25986:5;:28::i;:::-;26041:17;;-1:-1:-1;;;;;26041:17:0;26031:28;;;;:9;:28;;;;;:44;;26063:12;;26031:28;:44;;26063:12;;26031:44;:::i;:::-;;;;-1:-1:-1;;26112:17:0;;26095:49;;9078:25:1;;;-1:-1:-1;;;;;26112:17:0;;;;26095:49;;;-1:-1:-1;;;;;;;;;;;26095:49:0;9066:2:1;9051:18;26095:49:0;;;;;;;-1:-1:-1;;;;;26161:20:0;;;;;;:9;:20;;;;;:36;;26185:12;;26161:20;:36;;26185:12;;26161:36;:::i;:::-;;;;;;;;26234:9;-1:-1:-1;;;;;26217:41:0;26226:6;-1:-1:-1;;;;;26217:41:0;-1:-1:-1;;;;;;;;;;;26245:12:0;26217:41;;;;9078:25:1;;9066:2;9051:18;;8932:177;26217:41:0;;;;;;;;25688:582;;;25623:647;25063:1214;24976:1301;;;:::o;27307:494::-;-1:-1:-1;;;;;27391:21:0;;27383:67;;;;-1:-1:-1;;;27383:67:0;;6758:2:1;27383:67:0;;;6740:21:1;6797:2;6777:18;;;6770:30;6836:34;6816:18;;;6809:62;-1:-1:-1;;;6887:18:1;;;6880:31;6928:19;;27383:67:0;6556:397:1;27383:67:0;-1:-1:-1;;;;;27550:18:0;;27525:22;27550:18;;;:9;:18;;;;;;27587:24;;;;27579:71;;;;-1:-1:-1;;;27579:71:0;;3307:2:1;27579:71:0;;;3289:21:1;3346:2;3326:18;;;3319:30;3385:34;3365:18;;;3358:62;-1:-1:-1;;;3436:18:1;;;3429:32;3478:19;;27579:71:0;3105:398:1;27579:71:0;27682:23;27699:6;27682:14;:23;:::i;:::-;-1:-1:-1;;;;;27661:18:0;;;;;;:9;:18;;;;;:44;;;;27716:12;:22;;27732:6;;27661:18;27716:22;;27732:6;;27716:22;:::i;:::-;;;;-1:-1:-1;;27756:37:0;;9078:25:1;;;27782:1:0;;-1:-1:-1;;;;;27756:37:0;;;-1:-1:-1;;;;;;;;;;;27756:37:0;9066:2:1;9051:18;27756:37:0;8932:177:1;5619:132:0;5500:7;5527:6;-1:-1:-1;;;;;5527:6:0;4241:10;5683:23;5675:68;;;;-1:-1:-1;;;5675:68:0;;6048:2:1;5675:68:0;;;6030:21:1;;;6067:18;;;6060:30;6126:34;6106:18;;;6099:62;6178:18;;5675:68:0;5846:356:1;6714:191:0;6788:16;6807:6;;-1:-1:-1;;;;;6824:17:0;;;-1:-1:-1;;;;;;6824:17:0;;;;;;6857:40;;6807:6;;;;;;;6857:40;;6788:16;6857:40;6777:128;6714:191;:::o;23369:232::-;-1:-1:-1;;;;;23446:25:0;;;;;;:18;:25;;;;;;;;23441:80;;23488:21;23503:5;23488:14;:21::i;:::-;-1:-1:-1;;;;;23531:19:0;;;;;:12;:19;;;;;:26;;-1:-1:-1;;23531:26:0;23553:4;23531:26;;;23568:17;:25;;-1:-1:-1;;;;;;23568:25:0;;;;;;23369:232::o;14:173:1:-;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:186::-;251:6;304:2;292:9;283:7;279:23;275:32;272:52;;;320:1;317;310:12;272:52;343:29;362:9;343:29;:::i;:::-;333:39;192:186;-1:-1:-1;;;192:186:1:o;383:260::-;451:6;459;512:2;500:9;491:7;487:23;483:32;480:52;;;528:1;525;518:12;480:52;551:29;570:9;551:29;:::i;:::-;541:39;;599:38;633:2;622:9;618:18;599:38;:::i;:::-;589:48;;383:260;;;;;:::o;648:328::-;725:6;733;741;794:2;782:9;773:7;769:23;765:32;762:52;;;810:1;807;800:12;762:52;833:29;852:9;833:29;:::i;:::-;823:39;;881:38;915:2;904:9;900:18;881:38;:::i;:::-;871:48;;966:2;955:9;951:18;938:32;928:42;;648:328;;;;;:::o;981:254::-;1049:6;1057;1110:2;1098:9;1089:7;1085:23;1081:32;1078:52;;;1126:1;1123;1116:12;1078:52;1149:29;1168:9;1149:29;:::i;:::-;1139:39;1225:2;1210:18;;;;1197:32;;-1:-1:-1;;;981:254:1:o;1240:180::-;1299:6;1352:2;1340:9;1331:7;1327:23;1323:32;1320:52;;;1368:1;1365;1358:12;1320:52;-1:-1:-1;1391:23:1;;1240:180;-1:-1:-1;1240:180:1:o;1425:269::-;1482:6;1535:2;1523:9;1514:7;1510:23;1506:32;1503:52;;;1551:1;1548;1541:12;1503:52;1590:9;1577:23;1640:4;1633:5;1629:16;1622:5;1619:27;1609:55;;1660:1;1657;1650:12;2099:597;2211:4;2240:2;2269;2258:9;2251:21;2301:6;2295:13;2344:6;2339:2;2328:9;2324:18;2317:34;2369:1;2379:140;2393:6;2390:1;2387:13;2379:140;;;2488:14;;;2484:23;;2478:30;2454:17;;;2473:2;2450:26;2443:66;2408:10;;2379:140;;;2537:6;2534:1;2531:13;2528:91;;;2607:1;2602:2;2593:6;2582:9;2578:22;2574:31;2567:42;2528:91;-1:-1:-1;2680:2:1;2659:15;-1:-1:-1;;2655:29:1;2640:45;;;;2687:2;2636:54;;2099:597;-1:-1:-1;;;2099:597:1:o;9303:128::-;9343:3;9374:1;9370:6;9367:1;9364:13;9361:39;;;9380:18;;:::i;:::-;-1:-1:-1;9416:9:1;;9303:128::o;9436:217::-;9476:1;9502;9492:132;;9546:10;9541:3;9537:20;9534:1;9527:31;9581:4;9578:1;9571:15;9609:4;9606:1;9599:15;9492:132;-1:-1:-1;9638:9:1;;9436:217::o;9658:168::-;9698:7;9764:1;9760;9756:6;9752:14;9749:1;9746:21;9741:1;9734:9;9727:17;9723:45;9720:71;;;9771:18;;:::i;:::-;-1:-1:-1;9811:9:1;;9658:168::o;9831:125::-;9871:4;9899:1;9896;9893:8;9890:34;;;9904:18;;:::i;:::-;-1:-1:-1;9941:9:1;;9831:125::o;9961:380::-;10040:1;10036:12;;;;10083;;;10104:61;;10158:4;10150:6;10146:17;10136:27;;10104:61;10211:2;10203:6;10200:14;10180:18;10177:38;10174:161;;;10257:10;10252:3;10248:20;10245:1;10238:31;10292:4;10289:1;10282:15;10320:4;10317:1;10310:15;10174:161;;9961:380;;;:::o;10346:127::-;10407:10;10402:3;10398:20;10395:1;10388:31;10438:4;10435:1;10428:15;10462:4;10459:1;10452:15

ipfs://a160e76660962f682cada701404f37f35e6114a957267a0da3fbf53aa0e38eab