Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

Outline

•    - function _nonReentrantBefore()
•    - function _nonReentrantAfter()
•    - function _reentrancyGuardEntered()
• 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 ...
• interface IOwnable
•    - function owner()
•  contract ERC20 is Context, IERC20, ...
•    - function addToExclusion(address[] cal ...
•    - function removeFromExclusion (address ...
•    - function name()
•    - function symbol()
•    - function decimals()
•    - 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 ...
•    - function increaseAllowance(address sp ...
•    - function decreaseAllowance(address sp ...
•    - function _transfer(address from, addr ...
•    - function _mint(address account, uint2 ...
•    - function _burn(address account, uint2 ...
•    - function _approve(address owner, addr ...
•    - function _spendAllowance(address owne ...
•    - function _beforeTokenTransfer(address ...
•    - function _afterTokenTransfer(address ...
• library ABDKMath64x64
•    - function fromInt (int256 x)
•    - function toInt (int128 x)
•    - function fromUInt (uint256 x)
•    - function toUInt (int128 x)
•    - function from128x128 (int256 x)
•    - function to128x128 (int128 x)
•    - function add (int128 x, int128 y)
•    - function sub (int128 x, int128 y)
•    - function mul (int128 x, int128 y)
•    - function muli (int128 x, int256 y)
•    - function mulu (int128 x, uint256 y)
•    - function div (int128 x, int128 y)
•    - function divi (int256 x, int256 y)
•    - function divu (uint256 x, uint256 y)
•    - function neg (int128 x)
•    - function abs (int128 x)
•    - function inv (int128 x)
•    - function avg (int128 x, int128 y)
•    - function gavg (int128 x, int128 y)
•    - function pow (int128 x, uint256 y)
•    - function sqrt (int128 x)
•    - function log_2 (int128 x)
•    - function ln (int128 x)
•    - function exp_2 (int128 x)
•    - function exp (int128 x)
•    - function divuu (uint256 x, uint256 y)
•    - function sqrtu (uint256 x)
• library SafeMath
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b, st ...
•  contract GAME is ERC20, Ownable, R ... *
•    - function Mint(uint256 _amount)
•    - function Burn(uint256 _amount)
•    - function Burner(uint256 _amount)
•    - function pause()
•    - function unpause()
•    - function setWallets (address _lpwalle ...
•    - function setBurner (address _burner)
•    - function setDAO (address _newGuard)
•    - function setLimit (uint256 _limit)

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at SonicScan.org on 2025-01-10
*/

// SPDX-License-Identifier: MIT

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


// OpenZeppelin Contracts (last updated v4.9.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;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == _ENTERED;
    }
}

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


// OpenZeppelin Contracts (last updated v4.9.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:
     * 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);
}

// 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/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.9.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. 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);
    }
}

// File: contracts/ERC20.sol


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

pragma solidity ^0.8.0;





interface IOwnable {
    function owner() external view returns (address);
}
/**
 * @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].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * 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;
    address public devWallet;
    address public lpWallet;
    address public deadWallet;
    string private _name;
    string private _symbol;

    mapping(address => bool) private ExcludeFromFees;

    
    IOwnable ownableContract = IOwnable(address(this));

    function addToExclusion(address[] calldata addresses) external {
        require(msg.sender == ownableContract.owner(), "Not Owner");
        for (uint256 i = 0; i < addresses.length; i++) {
            ExcludeFromFees[addresses[i]] = true;
        }
    }

    function removeFromExclusion (address[] calldata addresses) external {
        require(msg.sender == ownableContract.owner(), "Not Owner");
        for (uint256 i = 0; i < addresses.length; i++) {
            ExcludeFromFees[addresses[i]] = false;
        }
    }

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * 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 default value returned by this function, unless
     * it's 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.
     * Taxes each transfer to a series of wallets.
     * 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");
        uint256 transferAmount;

        // EXCLUDE STATEMENT

        if (ExcludeFromFees[msg.sender]) {
        //WITHOUT FEES 
        transferAmount = amount; // calculate transfer amount

        // transfer the transferAmount to the recipient
        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] += transferAmount;
        }

        emit Transfer(from, to, transferAmount);          

        } else {

        // WITH FEES STATEMENT
        uint256 taxAmount = (amount * 2) / 100; // calculate tax amount
        transferAmount = amount - taxAmount; // calculate transfer amount

        // transfer the transferAmount to the recipient
        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] += transferAmount;
        }

        // transfer the taxAmount to the four wallets
        uint256 eachAmount = taxAmount / 4;
        uint256 lpAmount = eachAmount * 2;
        
        unchecked {
            _balances[lpWallet] += lpAmount;
            _balances[devWallet] += eachAmount;
            _balances[deadWallet] += eachAmount;
        }

        emit Transfer(from, to, transferAmount);
        emit Transfer(from, lpWallet, lpAmount);
        emit Transfer(from, devWallet, eachAmount);
        emit Transfer(from, deadWallet, eachAmount);     }

         _afterTokenTransfer(from, to, transferAmount);   
    }


    /** @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: abdk-libraries-solidity/ABDKMath64x64.sol


/*
 * ABDK Math 64.64 Smart Contract Library.  Copyright © 2019 by ABDK Consulting.
 * Author: Mikhail Vladimirov <[email protected]>
 */
pragma solidity ^0.8.0;

/**
 * Smart contract library of mathematical functions operating with signed
 * 64.64-bit fixed point numbers.  Signed 64.64-bit fixed point number is
 * basically a simple fraction whose numerator is signed 128-bit integer and
 * denominator is 2^64.  As long as denominator is always the same, there is no
 * need to store it, thus in Solidity signed 64.64-bit fixed point numbers are
 * represented by int128 type holding only the numerator.
 */
library ABDKMath64x64 {
  /*
   * Minimum value signed 64.64-bit fixed point number may have. 
   */
  int128 private constant MIN_64x64 = -0x80000000000000000000000000000000;

  /*
   * Maximum value signed 64.64-bit fixed point number may have. 
   */
  int128 private constant MAX_64x64 = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;

  /**
   * Convert signed 256-bit integer number into signed 64.64-bit fixed point
   * number.  Revert on overflow.
   *
   * @param x signed 256-bit integer number
   * @return signed 64.64-bit fixed point number
   */
  function fromInt (int256 x) internal pure returns (int128) {
    unchecked {
      require (x >= -0x8000000000000000 && x <= 0x7FFFFFFFFFFFFFFF);
      return int128 (x << 64);
    }
  }

  /**
   * Convert signed 64.64 fixed point number into signed 64-bit integer number
   * rounding down.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64-bit integer number
   */
  function toInt (int128 x) internal pure returns (int64) {
    unchecked {
      return int64 (x >> 64);
    }
  }

  /**
   * Convert unsigned 256-bit integer number into signed 64.64-bit fixed point
   * number.  Revert on overflow.
   *
   * @param x unsigned 256-bit integer number
   * @return signed 64.64-bit fixed point number
   */
  function fromUInt (uint256 x) internal pure returns (int128) {
    unchecked {
      require (x <= 0x7FFFFFFFFFFFFFFF);
      return int128 (int256 (x << 64));
    }
  }

  /**
   * Convert signed 64.64 fixed point number into unsigned 64-bit integer
   * number rounding down.  Revert on underflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @return unsigned 64-bit integer number
   */
  function toUInt (int128 x) internal pure returns (uint64) {
    unchecked {
      require (x >= 0);
      return uint64 (uint128 (x >> 64));
    }
  }

  /**
   * Convert signed 128.128 fixed point number into signed 64.64-bit fixed point
   * number rounding down.  Revert on overflow.
   *
   * @param x signed 128.128-bin fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function from128x128 (int256 x) internal pure returns (int128) {
    unchecked {
      int256 result = x >> 64;
      require (result >= MIN_64x64 && result <= MAX_64x64);
      return int128 (result);
    }
  }

  /**
   * Convert signed 64.64 fixed point number into signed 128.128 fixed point
   * number.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 128.128 fixed point number
   */
  function to128x128 (int128 x) internal pure returns (int256) {
    unchecked {
      return int256 (x) << 64;
    }
  }

  /**
   * Calculate x + y.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function add (int128 x, int128 y) internal pure returns (int128) {
    unchecked {
      int256 result = int256(x) + y;
      require (result >= MIN_64x64 && result <= MAX_64x64);
      return int128 (result);
    }
  }

  /**
   * Calculate x - y.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function sub (int128 x, int128 y) internal pure returns (int128) {
    unchecked {
      int256 result = int256(x) - y;
      require (result >= MIN_64x64 && result <= MAX_64x64);
      return int128 (result);
    }
  }

  /**
   * Calculate x * y rounding down.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function mul (int128 x, int128 y) internal pure returns (int128) {
    unchecked {
      int256 result = int256(x) * y >> 64;
      require (result >= MIN_64x64 && result <= MAX_64x64);
      return int128 (result);
    }
  }

  /**
   * Calculate x * y rounding towards zero, where x is signed 64.64 fixed point
   * number and y is signed 256-bit integer number.  Revert on overflow.
   *
   * @param x signed 64.64 fixed point number
   * @param y signed 256-bit integer number
   * @return signed 256-bit integer number
   */
  function muli (int128 x, int256 y) internal pure returns (int256) {
    unchecked {
      if (x == MIN_64x64) {
        require (y >= -0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF &&
          y <= 0x1000000000000000000000000000000000000000000000000);
        return -y << 63;
      } else {
        bool negativeResult = false;
        if (x < 0) {
          x = -x;
          negativeResult = true;
        }
        if (y < 0) {
          y = -y; // We rely on overflow behavior here
          negativeResult = !negativeResult;
        }
        uint256 absoluteResult = mulu (x, uint256 (y));
        if (negativeResult) {
          require (absoluteResult <=
            0x8000000000000000000000000000000000000000000000000000000000000000);
          return -int256 (absoluteResult); // We rely on overflow behavior here
        } else {
          require (absoluteResult <=
            0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
          return int256 (absoluteResult);
        }
      }
    }
  }

  /**
   * Calculate x * y rounding down, where x is signed 64.64 fixed point number
   * and y is unsigned 256-bit integer number.  Revert on overflow.
   *
   * @param x signed 64.64 fixed point number
   * @param y unsigned 256-bit integer number
   * @return unsigned 256-bit integer number
   */
  function mulu (int128 x, uint256 y) internal pure returns (uint256) {
    unchecked {
      if (y == 0) return 0;

      require (x >= 0);

      uint256 lo = (uint256 (int256 (x)) * (y & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)) >> 64;
      uint256 hi = uint256 (int256 (x)) * (y >> 128);

      require (hi <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
      hi <<= 64;

      require (hi <=
        0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF - lo);
      return hi + lo;
    }
  }

  /**
   * Calculate x / y rounding towards zero.  Revert on overflow or when y is
   * zero.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function div (int128 x, int128 y) internal pure returns (int128) {
    unchecked {
      require (y != 0);
      int256 result = (int256 (x) << 64) / y;
      require (result >= MIN_64x64 && result <= MAX_64x64);
      return int128 (result);
    }
  }

  /**
   * Calculate x / y rounding towards zero, where x and y are signed 256-bit
   * integer numbers.  Revert on overflow or when y is zero.
   *
   * @param x signed 256-bit integer number
   * @param y signed 256-bit integer number
   * @return signed 64.64-bit fixed point number
   */
  function divi (int256 x, int256 y) internal pure returns (int128) {
    unchecked {
      require (y != 0);

      bool negativeResult = false;
      if (x < 0) {
        x = -x; // We rely on overflow behavior here
        negativeResult = true;
      }
      if (y < 0) {
        y = -y; // We rely on overflow behavior here
        negativeResult = !negativeResult;
      }
      uint128 absoluteResult = divuu (uint256 (x), uint256 (y));
      if (negativeResult) {
        require (absoluteResult <= 0x80000000000000000000000000000000);
        return -int128 (absoluteResult); // We rely on overflow behavior here
      } else {
        require (absoluteResult <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
        return int128 (absoluteResult); // We rely on overflow behavior here
      }
    }
  }

  /**
   * Calculate x / y rounding towards zero, where x and y are unsigned 256-bit
   * integer numbers.  Revert on overflow or when y is zero.
   *
   * @param x unsigned 256-bit integer number
   * @param y unsigned 256-bit integer number
   * @return signed 64.64-bit fixed point number
   */
  function divu (uint256 x, uint256 y) internal pure returns (int128) {
    unchecked {
      require (y != 0);
      uint128 result = divuu (x, y);
      require (result <= uint128 (MAX_64x64));
      return int128 (result);
    }
  }

  /**
   * Calculate -x.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function neg (int128 x) internal pure returns (int128) {
    unchecked {
      require (x != MIN_64x64);
      return -x;
    }
  }

  /**
   * Calculate |x|.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function abs (int128 x) internal pure returns (int128) {
    unchecked {
      require (x != MIN_64x64);
      return x < 0 ? -x : x;
    }
  }

  /**
   * Calculate 1 / x rounding towards zero.  Revert on overflow or when x is
   * zero.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function inv (int128 x) internal pure returns (int128) {
    unchecked {
      require (x != 0);
      int256 result = int256 (0x100000000000000000000000000000000) / x;
      require (result >= MIN_64x64 && result <= MAX_64x64);
      return int128 (result);
    }
  }

  /**
   * Calculate arithmetics average of x and y, i.e. (x + y) / 2 rounding down.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function avg (int128 x, int128 y) internal pure returns (int128) {
    unchecked {
      return int128 ((int256 (x) + int256 (y)) >> 1);
    }
  }

  /**
   * Calculate geometric average of x and y, i.e. sqrt (x * y) rounding down.
   * Revert on overflow or in case x * y is negative.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function gavg (int128 x, int128 y) internal pure returns (int128) {
    unchecked {
      int256 m = int256 (x) * int256 (y);
      require (m >= 0);
      require (m <
          0x4000000000000000000000000000000000000000000000000000000000000000);
      return int128 (sqrtu (uint256 (m)));
    }
  }

  /**
   * Calculate x^y assuming 0^0 is 1, where x is signed 64.64 fixed point number
   * and y is unsigned 256-bit integer number.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y uint256 value
   * @return signed 64.64-bit fixed point number
   */
  function pow (int128 x, uint256 y) internal pure returns (int128) {
    unchecked {
      bool negative = x < 0 && y & 1 == 1;

      uint256 absX = uint128 (x < 0 ? -x : x);
      uint256 absResult;
      absResult = 0x100000000000000000000000000000000;

      if (absX <= 0x10000000000000000) {
        absX <<= 63;
        while (y != 0) {
          if (y & 0x1 != 0) {
            absResult = absResult * absX >> 127;
          }
          absX = absX * absX >> 127;

          if (y & 0x2 != 0) {
            absResult = absResult * absX >> 127;
          }
          absX = absX * absX >> 127;

          if (y & 0x4 != 0) {
            absResult = absResult * absX >> 127;
          }
          absX = absX * absX >> 127;

          if (y & 0x8 != 0) {
            absResult = absResult * absX >> 127;
          }
          absX = absX * absX >> 127;

          y >>= 4;
        }

        absResult >>= 64;
      } else {
        uint256 absXShift = 63;
        if (absX < 0x1000000000000000000000000) { absX <<= 32; absXShift -= 32; }
        if (absX < 0x10000000000000000000000000000) { absX <<= 16; absXShift -= 16; }
        if (absX < 0x1000000000000000000000000000000) { absX <<= 8; absXShift -= 8; }
        if (absX < 0x10000000000000000000000000000000) { absX <<= 4; absXShift -= 4; }
        if (absX < 0x40000000000000000000000000000000) { absX <<= 2; absXShift -= 2; }
        if (absX < 0x80000000000000000000000000000000) { absX <<= 1; absXShift -= 1; }

        uint256 resultShift = 0;
        while (y != 0) {
          require (absXShift < 64);

          if (y & 0x1 != 0) {
            absResult = absResult * absX >> 127;
            resultShift += absXShift;
            if (absResult > 0x100000000000000000000000000000000) {
              absResult >>= 1;
              resultShift += 1;
            }
          }
          absX = absX * absX >> 127;
          absXShift <<= 1;
          if (absX >= 0x100000000000000000000000000000000) {
              absX >>= 1;
              absXShift += 1;
          }

          y >>= 1;
        }

        require (resultShift < 64);
        absResult >>= 64 - resultShift;
      }
      int256 result = negative ? -int256 (absResult) : int256 (absResult);
      require (result >= MIN_64x64 && result <= MAX_64x64);
      return int128 (result);
    }
  }

  /**
   * Calculate sqrt (x) rounding down.  Revert if x < 0.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function sqrt (int128 x) internal pure returns (int128) {
    unchecked {
      require (x >= 0);
      return int128 (sqrtu (uint256 (int256 (x)) << 64));
    }
  }

  /**
   * Calculate binary logarithm of x.  Revert if x <= 0.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function log_2 (int128 x) internal pure returns (int128) {
    unchecked {
      require (x > 0);

      int256 msb = 0;
      int256 xc = x;
      if (xc >= 0x10000000000000000) { xc >>= 64; msb += 64; }
      if (xc >= 0x100000000) { xc >>= 32; msb += 32; }
      if (xc >= 0x10000) { xc >>= 16; msb += 16; }
      if (xc >= 0x100) { xc >>= 8; msb += 8; }
      if (xc >= 0x10) { xc >>= 4; msb += 4; }
      if (xc >= 0x4) { xc >>= 2; msb += 2; }
      if (xc >= 0x2) msb += 1;  // No need to shift xc anymore

      int256 result = msb - 64 << 64;
      uint256 ux = uint256 (int256 (x)) << uint256 (127 - msb);
      for (int256 bit = 0x8000000000000000; bit > 0; bit >>= 1) {
        ux *= ux;
        uint256 b = ux >> 255;
        ux >>= 127 + b;
        result += bit * int256 (b);
      }

      return int128 (result);
    }
  }

  /**
   * Calculate natural logarithm of x.  Revert if x <= 0.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function ln (int128 x) internal pure returns (int128) {
    unchecked {
      require (x > 0);

      return int128 (int256 (
          uint256 (int256 (log_2 (x))) * 0xB17217F7D1CF79ABC9E3B39803F2F6AF >> 128));
    }
  }

  /**
   * Calculate binary exponent of x.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function exp_2 (int128 x) internal pure returns (int128) {
    unchecked {
      require (x < 0x400000000000000000); // Overflow

      if (x < -0x400000000000000000) return 0; // Underflow

      uint256 result = 0x80000000000000000000000000000000;

      if (x & 0x8000000000000000 > 0)
        result = result * 0x16A09E667F3BCC908B2FB1366EA957D3E >> 128;
      if (x & 0x4000000000000000 > 0)
        result = result * 0x1306FE0A31B7152DE8D5A46305C85EDEC >> 128;
      if (x & 0x2000000000000000 > 0)
        result = result * 0x1172B83C7D517ADCDF7C8C50EB14A791F >> 128;
      if (x & 0x1000000000000000 > 0)
        result = result * 0x10B5586CF9890F6298B92B71842A98363 >> 128;
      if (x & 0x800000000000000 > 0)
        result = result * 0x1059B0D31585743AE7C548EB68CA417FD >> 128;
      if (x & 0x400000000000000 > 0)
        result = result * 0x102C9A3E778060EE6F7CACA4F7A29BDE8 >> 128;
      if (x & 0x200000000000000 > 0)
        result = result * 0x10163DA9FB33356D84A66AE336DCDFA3F >> 128;
      if (x & 0x100000000000000 > 0)
        result = result * 0x100B1AFA5ABCBED6129AB13EC11DC9543 >> 128;
      if (x & 0x80000000000000 > 0)
        result = result * 0x10058C86DA1C09EA1FF19D294CF2F679B >> 128;
      if (x & 0x40000000000000 > 0)
        result = result * 0x1002C605E2E8CEC506D21BFC89A23A00F >> 128;
      if (x & 0x20000000000000 > 0)
        result = result * 0x100162F3904051FA128BCA9C55C31E5DF >> 128;
      if (x & 0x10000000000000 > 0)
        result = result * 0x1000B175EFFDC76BA38E31671CA939725 >> 128;
      if (x & 0x8000000000000 > 0)
        result = result * 0x100058BA01FB9F96D6CACD4B180917C3D >> 128;
      if (x & 0x4000000000000 > 0)
        result = result * 0x10002C5CC37DA9491D0985C348C68E7B3 >> 128;
      if (x & 0x2000000000000 > 0)
        result = result * 0x1000162E525EE054754457D5995292026 >> 128;
      if (x & 0x1000000000000 > 0)
        result = result * 0x10000B17255775C040618BF4A4ADE83FC >> 128;
      if (x & 0x800000000000 > 0)
        result = result * 0x1000058B91B5BC9AE2EED81E9B7D4CFAB >> 128;
      if (x & 0x400000000000 > 0)
        result = result * 0x100002C5C89D5EC6CA4D7C8ACC017B7C9 >> 128;
      if (x & 0x200000000000 > 0)
        result = result * 0x10000162E43F4F831060E02D839A9D16D >> 128;
      if (x & 0x100000000000 > 0)
        result = result * 0x100000B1721BCFC99D9F890EA06911763 >> 128;
      if (x & 0x80000000000 > 0)
        result = result * 0x10000058B90CF1E6D97F9CA14DBCC1628 >> 128;
      if (x & 0x40000000000 > 0)
        result = result * 0x1000002C5C863B73F016468F6BAC5CA2B >> 128;
      if (x & 0x20000000000 > 0)
        result = result * 0x100000162E430E5A18F6119E3C02282A5 >> 128;
      if (x & 0x10000000000 > 0)
        result = result * 0x1000000B1721835514B86E6D96EFD1BFE >> 128;
      if (x & 0x8000000000 > 0)
        result = result * 0x100000058B90C0B48C6BE5DF846C5B2EF >> 128;
      if (x & 0x4000000000 > 0)
        result = result * 0x10000002C5C8601CC6B9E94213C72737A >> 128;
      if (x & 0x2000000000 > 0)
        result = result * 0x1000000162E42FFF037DF38AA2B219F06 >> 128;
      if (x & 0x1000000000 > 0)
        result = result * 0x10000000B17217FBA9C739AA5819F44F9 >> 128;
      if (x & 0x800000000 > 0)
        result = result * 0x1000000058B90BFCDEE5ACD3C1CEDC823 >> 128;
      if (x & 0x400000000 > 0)
        result = result * 0x100000002C5C85FE31F35A6A30DA1BE50 >> 128;
      if (x & 0x200000000 > 0)
        result = result * 0x10000000162E42FF0999CE3541B9FFFCF >> 128;
      if (x & 0x100000000 > 0)
        result = result * 0x100000000B17217F80F4EF5AADDA45554 >> 128;
      if (x & 0x80000000 > 0)
        result = result * 0x10000000058B90BFBF8479BD5A81B51AD >> 128;
      if (x & 0x40000000 > 0)
        result = result * 0x1000000002C5C85FDF84BD62AE30A74CC >> 128;
      if (x & 0x20000000 > 0)
        result = result * 0x100000000162E42FEFB2FED257559BDAA >> 128;
      if (x & 0x10000000 > 0)
        result = result * 0x1000000000B17217F7D5A7716BBA4A9AE >> 128;
      if (x & 0x8000000 > 0)
        result = result * 0x100000000058B90BFBE9DDBAC5E109CCE >> 128;
      if (x & 0x4000000 > 0)
        result = result * 0x10000000002C5C85FDF4B15DE6F17EB0D >> 128;
      if (x & 0x2000000 > 0)
        result = result * 0x1000000000162E42FEFA494F1478FDE05 >> 128;
      if (x & 0x1000000 > 0)
        result = result * 0x10000000000B17217F7D20CF927C8E94C >> 128;
      if (x & 0x800000 > 0)
        result = result * 0x1000000000058B90BFBE8F71CB4E4B33D >> 128;
      if (x & 0x400000 > 0)
        result = result * 0x100000000002C5C85FDF477B662B26945 >> 128;
      if (x & 0x200000 > 0)
        result = result * 0x10000000000162E42FEFA3AE53369388C >> 128;
      if (x & 0x100000 > 0)
        result = result * 0x100000000000B17217F7D1D351A389D40 >> 128;
      if (x & 0x80000 > 0)
        result = result * 0x10000000000058B90BFBE8E8B2D3D4EDE >> 128;
      if (x & 0x40000 > 0)
        result = result * 0x1000000000002C5C85FDF4741BEA6E77E >> 128;
      if (x & 0x20000 > 0)
        result = result * 0x100000000000162E42FEFA39FE95583C2 >> 128;
      if (x & 0x10000 > 0)
        result = result * 0x1000000000000B17217F7D1CFB72B45E1 >> 128;
      if (x & 0x8000 > 0)
        result = result * 0x100000000000058B90BFBE8E7CC35C3F0 >> 128;
      if (x & 0x4000 > 0)
        result = result * 0x10000000000002C5C85FDF473E242EA38 >> 128;
      if (x & 0x2000 > 0)
        result = result * 0x1000000000000162E42FEFA39F02B772C >> 128;
      if (x & 0x1000 > 0)
        result = result * 0x10000000000000B17217F7D1CF7D83C1A >> 128;
      if (x & 0x800 > 0)
        result = result * 0x1000000000000058B90BFBE8E7BDCBE2E >> 128;
      if (x & 0x400 > 0)
        result = result * 0x100000000000002C5C85FDF473DEA871F >> 128;
      if (x & 0x200 > 0)
        result = result * 0x10000000000000162E42FEFA39EF44D91 >> 128;
      if (x & 0x100 > 0)
        result = result * 0x100000000000000B17217F7D1CF79E949 >> 128;
      if (x & 0x80 > 0)
        result = result * 0x10000000000000058B90BFBE8E7BCE544 >> 128;
      if (x & 0x40 > 0)
        result = result * 0x1000000000000002C5C85FDF473DE6ECA >> 128;
      if (x & 0x20 > 0)
        result = result * 0x100000000000000162E42FEFA39EF366F >> 128;
      if (x & 0x10 > 0)
        result = result * 0x1000000000000000B17217F7D1CF79AFA >> 128;
      if (x & 0x8 > 0)
        result = result * 0x100000000000000058B90BFBE8E7BCD6D >> 128;
      if (x & 0x4 > 0)
        result = result * 0x10000000000000002C5C85FDF473DE6B2 >> 128;
      if (x & 0x2 > 0)
        result = result * 0x1000000000000000162E42FEFA39EF358 >> 128;
      if (x & 0x1 > 0)
        result = result * 0x10000000000000000B17217F7D1CF79AB >> 128;

      result >>= uint256 (int256 (63 - (x >> 64)));
      require (result <= uint256 (int256 (MAX_64x64)));

      return int128 (int256 (result));
    }
  }

  /**
   * Calculate natural exponent of x.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function exp (int128 x) internal pure returns (int128) {
    unchecked {
      require (x < 0x400000000000000000); // Overflow

      if (x < -0x400000000000000000) return 0; // Underflow

      return exp_2 (
          int128 (int256 (x) * 0x171547652B82FE1777D0FFDA0D23A7D12 >> 128));
    }
  }

  /**
   * Calculate x / y rounding towards zero, where x and y are unsigned 256-bit
   * integer numbers.  Revert on overflow or when y is zero.
   *
   * @param x unsigned 256-bit integer number
   * @param y unsigned 256-bit integer number
   * @return unsigned 64.64-bit fixed point number
   */
  function divuu (uint256 x, uint256 y) private pure returns (uint128) {
    unchecked {
      require (y != 0);

      uint256 result;

      if (x <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
        result = (x << 64) / y;
      else {
        uint256 msb = 192;
        uint256 xc = x >> 192;
        if (xc >= 0x100000000) { xc >>= 32; msb += 32; }
        if (xc >= 0x10000) { xc >>= 16; msb += 16; }
        if (xc >= 0x100) { xc >>= 8; msb += 8; }
        if (xc >= 0x10) { xc >>= 4; msb += 4; }
        if (xc >= 0x4) { xc >>= 2; msb += 2; }
        if (xc >= 0x2) msb += 1;  // No need to shift xc anymore

        result = (x << 255 - msb) / ((y - 1 >> msb - 191) + 1);
        require (result <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);

        uint256 hi = result * (y >> 128);
        uint256 lo = result * (y & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);

        uint256 xh = x >> 192;
        uint256 xl = x << 64;

        if (xl < lo) xh -= 1;
        xl -= lo; // We rely on overflow behavior here
        lo = hi << 128;
        if (xl < lo) xh -= 1;
        xl -= lo; // We rely on overflow behavior here

        result += xh == hi >> 128 ? xl / y : 1;
      }

      require (result <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
      return uint128 (result);
    }
  }

  /**
   * Calculate sqrt (x) rounding down, where x is unsigned 256-bit integer
   * number.
   *
   * @param x unsigned 256-bit integer number
   * @return unsigned 128-bit integer number
   */
  function sqrtu (uint256 x) private pure returns (uint128) {
    unchecked {
      if (x == 0) return 0;
      else {
        uint256 xx = x;
        uint256 r = 1;
        if (xx >= 0x100000000000000000000000000000000) { xx >>= 128; r <<= 64; }
        if (xx >= 0x10000000000000000) { xx >>= 64; r <<= 32; }
        if (xx >= 0x100000000) { xx >>= 32; r <<= 16; }
        if (xx >= 0x10000) { xx >>= 16; r <<= 8; }
        if (xx >= 0x100) { xx >>= 8; r <<= 4; }
        if (xx >= 0x10) { xx >>= 4; r <<= 2; }
        if (xx >= 0x4) { r <<= 1; }
        r = (r + x / r) >> 1;
        r = (r + x / r) >> 1;
        r = (r + x / r) >> 1;
        r = (r + x / r) >> 1;
        r = (r + x / r) >> 1;
        r = (r + x / r) >> 1;
        r = (r + x / r) >> 1; // Seven iterations should be enough
        uint256 r1 = x / r;
        return uint128 (r < r1 ? r : r1);
      }
    }
  }
}

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


// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

// File: contracts/Game.sol



// @title GAME token for battledogs Arena
// https://twitter.com/0xSorcerers | https://github.com/Dark-Viper | https://t.me/Oxsorcerer | https://t.me/battousainakamoto | https://t.me/darcViper

pragma solidity ^0.8.17;

contract GAME is ERC20, Ownable, ReentrancyGuard {        
        constructor(string memory _name, string memory _symbol, address _newGuard, address _devWallet, address _lpWallet, address _deadWallet) 
            ERC20(_name, _symbol)
        {
        guard = _newGuard;       
        devWallet = _devWallet;
        lpWallet = _lpWallet;
        deadWallet = _deadWallet;
        }
    using ABDKMath64x64 for uint256;
    using SafeMath for uint256;

    address public burnercontract;
    
    bool public paused = false;
    address private guard;
    uint256 private MAX_SUPPLY = 5000000 * 10 ** decimals();
    uint256 public TotalBurns;

    modifier onlyAdmin() {
        require(msg.sender == owner(), "Not authorized.");
        _;
    }

    modifier onlyBattledogDAO() {
        require(msg.sender == guard, "Not authorized.");
        _;
    }

    modifier onlyBurner() {
        require(msg.sender == burnercontract, "Not authorized.");
        _;
    }
  
    event mintEvent(uint256 indexed _amount);
    function Mint(uint256 _amount) external onlyAdmin {                
      require(!paused, "Paused Contract");  
      uint256 amount = _amount * 10 ** decimals();         
      require((amount + totalSupply()) <= MAX_SUPPLY, "Max Mint Exceeded");
        _mint(msg.sender, amount); 
       emit mintEvent(_amount);
    }

    event burnEvent(uint256 indexed _amount);
    function Burn(uint256 _amount) external onlyBurner {                
       require(!paused, "Paused Contract");
       _burn(msg.sender, _amount);
       TotalBurns += _amount;
       emit burnEvent(_amount);
    }

    function Burner(uint256 _amount) external onlyAdmin {                
        require(!paused, "Paused Contract");                
        require(msg.sender == guard, "Not Authorized");
       _burn(msg.sender, _amount);
       TotalBurns += _amount;
       emit burnEvent(_amount);
    }

    event Pause();
    function pause() public onlyBattledogDAO {
        require(!paused, "Contract already paused.");
        paused = true;
        emit Pause();
    }

    event Unpause();
    function unpause() public onlyBattledogDAO {
        require(msg.sender == owner(), "Not Authorized.");
        require(paused, "Contract not paused.");
        paused = false;
        emit Unpause();
    }

    /**
     * @dev sets wallets tax is sent to.
     */
    function setWallets (address _lpwallet, address _devWallet, address _deadWallet) external onlyAdmin {
        lpWallet = _lpwallet;
        devWallet = _devWallet;
        deadWallet = _deadWallet;
    }

    function setBurner (address _burner) external onlyAdmin {
        burnercontract = _burner;
    }

    function setDAO (address _newGuard) external onlyBattledogDAO {
        guard = _newGuard;
    }

    event limitChangeEvent(uint256 indexed _amount);
    function setLimit (uint256 _limit) external onlyBattledogDAO {
        MAX_SUPPLY = _limit  * 10 ** decimals();
        emit limitChangeEvent(MAX_SUPPLY);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"address","name":"_newGuard","type":"address"},{"internalType":"address","name":"_devWallet","type":"address"},{"internalType":"address","name":"_lpWallet","type":"address"},{"internalType":"address","name":"_deadWallet","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":[],"name":"Pause","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"},{"anonymous":false,"inputs":[],"name":"Unpause","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"burnEvent","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"limitChangeEvent","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"mintEvent","type":"event"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"Burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"Burner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"Mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"TotalBurns","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"addresses","type":"address[]"}],"name":"addToExclusion","outputs":[],"stateMutability":"nonpayable","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":[],"name":"burnercontract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"deadWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","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":[],"name":"devWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","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":[],"name":"lpWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"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":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"addresses","type":"address[]"}],"name":"removeFromExclusion","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_burner","type":"address"}],"name":"setBurner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newGuard","type":"address"}],"name":"setDAO","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_limit","type":"uint256"}],"name":"setLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_lpwallet","type":"address"},{"internalType":"address","name":"_devWallet","type":"address"},{"internalType":"address","name":"_deadWallet","type":"address"}],"name":"setWallets","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":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","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"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

00000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000000000000000000000000010000000000000000000000000076559c8501a111395f9e84afba6f138ef21b68f900000000000000000000000071990ee4a81faa839a13e055b2a305f9244a43bd000000000000000000000000c0ba543b1f4a340aca0157c1988f3e216c9e1774000000000000000000000000000000000000000000000000000000000000dead000000000000000000000000000000000000000000000000000000000000000d47616d65206f6e20536f6e696300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000447414d4500000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _name (string): Game on Sonic
Arg [1] : _symbol (string): GAME
Arg [2] : _newGuard (address): 0x76559c8501A111395f9E84AFBA6F138Ef21B68f9
Arg [3] : _devWallet (address): 0x71990ee4A81FaA839a13E055B2a305f9244A43Bd
Arg [4] : _lpWallet (address): 0xc0ba543B1F4A340acA0157C1988F3E216C9e1774
Arg [5] : _deadWallet (address): 0x000000000000000000000000000000000000dEaD

-----Encoded View---------------
10 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000100
Arg [2] : 00000000000000000000000076559c8501a111395f9e84afba6f138ef21b68f9
Arg [3] : 00000000000000000000000071990ee4a81faa839a13e055b2a305f9244a43bd
Arg [4] : 000000000000000000000000c0ba543b1f4a340aca0157c1988f3e216c9e1774
Arg [5] : 000000000000000000000000000000000000000000000000000000000000dead
Arg [6] : 000000000000000000000000000000000000000000000000000000000000000d
Arg [7] : 47616d65206f6e20536f6e696300000000000000000000000000000000000000
Arg [8] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [9] : 47414d4500000000000000000000000000000000000000000000000000000000

59358:3103:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13403:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;60419:328;;;;;;:::i;:::-;;:::i;:::-;;15777:201;;;;;;:::i;:::-;;:::i;:::-;;;1373:14:1;;1366:22;1348:41;;1336:2;1321:18;15777:201:0;1208:187:1;59831:29:0;;;;;-1:-1:-1;;;;;59831:29:0;;;;;;-1:-1:-1;;;;;1564:32:1;;;1546:51;;1534:2;1519:18;59831:29:0;1400:203:1;14532:108:0;14620:12;;14532:108;;;1754:25:1;;;1742:2;1727:18;14532:108:0;1608:177:1;16558:261:0;;;;;;:::i;:::-;;:::i;62295:163::-;;;;;;:::i;:::-;;:::i;14374:93::-;;;14457:2;2393:36:1;;2381:2;2366:18;14374:93:0;2251:184:1;17228:238:0;;;;;;:::i;:::-;;:::i;61534:211::-;;;:::i;59873:26::-;;;;;-1:-1:-1;;;59873:26:0;;;;;;12248:23;;;;;-1:-1:-1;;;;;12248:23:0;;;14703:127;;;;;;:::i;:::-;-1:-1:-1;;;;;14804:18:0;14777:7;14804:18;;;;;;;;;;;;14703:127;9624:103;;;:::i;61813:207::-;;;;;;:::i;:::-;;:::i;61353:151::-;;;:::i;12278:25::-;;;;;-1:-1:-1;;;;;12278:25:0;;;8983:87;9056:6;;-1:-1:-1;;;;;9056:6:0;8983:87;;12217:24;;;;;-1:-1:-1;;;;;12217:24:0;;;13622:104;;;:::i;12490:261::-;;;;;;:::i;:::-;;:::i;12759:268::-;;;;;;:::i;:::-;;:::i;17969:436::-;;;;;;:::i;:::-;;:::i;15036:207::-;;;;;;:::i;:::-;;:::i;62028:99::-;;;;;;:::i;:::-;;:::i;61030:295::-;;;;;;:::i;:::-;;:::i;60802:220::-;;;;;;:::i;:::-;;:::i;15306:151::-;;;;;;:::i;:::-;;:::i;62135:98::-;;;;;;:::i;:::-;;:::i;9882:201::-;;;;;;:::i;:::-;;:::i;59996:25::-;;;;;;13403:100;13457:13;13490:5;13483:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13403:100;:::o;60419:328::-;9056:6;;-1:-1:-1;;;;;9056:6:0;60070:10;:21;60062:49;;;;-1:-1:-1;;;60062:49:0;;;;;;;:::i;:::-;;;;;;;;;60503:6:::1;::::0;-1:-1:-1;;;60503:6:0;::::1;;;60502:7;60494:35;;;;-1:-1:-1::0;;;60494:35:0::1;;;;;;;:::i;:::-;60540:14;60567:16;14457:2:::0;60567::::1;:16;:::i;:::-;60557:26;::::0;:7;:26:::1;:::i;:::-;60540:43;;60637:10;;60619:13;14620:12:::0;;;14532:108;60619:13:::1;60610:22;::::0;:6;:22:::1;:::i;:::-;60609:38;;60601:68;;;::::0;-1:-1:-1;;;60601:68:0;;7332:2:1;60601:68:0::1;::::0;::::1;7314:21:1::0;7371:2;7351:18;;;7344:30;-1:-1:-1;;;7390:18:1;;;7383:47;7447:18;;60601:68:0::1;7130:341:1::0;60601:68:0::1;60680:25;60686:10;60698:6;60680:5;:25::i;:::-;60721:18;::::0;60731:7;;60721:18:::1;::::0;;;::::1;60469:278;60419:328:::0;:::o;15777:201::-;15860:4;7614:10;15916:32;7614:10;15932:7;15941:6;15916:8;:32::i;:::-;15966:4;15959:11;;;15777:201;;;;;:::o;16558:261::-;16655:4;7614:10;16713:38;16729:4;7614:10;16744:6;16713:15;:38::i;:::-;16762:27;16772:4;16778:2;16782:6;16762:9;:27::i;:::-;-1:-1:-1;16807:4:0;;16558:261;-1:-1:-1;;;;16558:261:0:o;62295:163::-;60200:5;;-1:-1:-1;;;;;60200:5:0;60186:10;:19;60178:47;;;;-1:-1:-1;;;60178:47:0;;;;;;;:::i;:::-;62390:16:::1;14457:2:::0;62390::::1;:16;:::i;:::-;62380:26;::::0;:6;:26:::1;:::i;:::-;62367:10;:39:::0;;;62422:28:::1;::::0;::::1;::::0;;;::::1;62295:163:::0;:::o;17228:238::-;17316:4;7614:10;17372:64;7614:10;17388:7;17425:10;17397:25;7614:10;17388:7;17397:9;:25::i;:::-;:38;;;;:::i;:::-;17372:8;:64::i;61534:211::-;60200:5;;-1:-1:-1;;;;;60200:5:0;60186:10;:19;60178:47;;;;-1:-1:-1;;;60178:47:0;;;;;;;:::i;:::-;9056:6;;-1:-1:-1;;;;;9056:6:0;61596:10:::1;:21;61588:49;;;::::0;-1:-1:-1;;;61588:49:0;;7678:2:1;61588:49:0::1;::::0;::::1;7660:21:1::0;7717:2;7697:18;;;7690:30;-1:-1:-1;;;7736:18:1;;;7729:45;7791:18;;61588:49:0::1;7476:339:1::0;61588:49:0::1;61656:6;::::0;-1:-1:-1;;;61656:6:0;::::1;;;61648:39;;;::::0;-1:-1:-1;;;61648:39:0;;8022:2:1;61648:39:0::1;::::0;::::1;8004:21:1::0;8061:2;8041:18;;;8034:30;-1:-1:-1;;;8080:18:1;;;8073:50;8140:18;;61648:39:0::1;7820:344:1::0;61648:39:0::1;61698:6;:14:::0;;-1:-1:-1;;;;61698:14:0::1;::::0;;61728:9:::1;::::0;::::1;::::0;61707:5:::1;::::0;61728:9:::1;61534:211::o:0;9624:103::-;8869:13;:11;:13::i;:::-;9689:30:::1;9716:1;9689:18;:30::i;:::-;9624:103::o:0;61813:207::-;9056:6;;-1:-1:-1;;;;;9056:6:0;60070:10;:21;60062:49;;;;-1:-1:-1;;;60062:49:0;;;;;;;:::i;:::-;61924:8:::1;:20:::0;;-1:-1:-1;;;;;61924:20:0;;::::1;-1:-1:-1::0;;;;;;61924:20:0;;::::1;;::::0;;;61955:9:::1;:22:::0;;;;::::1;::::0;;::::1;::::0;;;::::1;::::0;;;61988:10:::1;:24:::0;;;;;::::1;::::0;::::1;;::::0;;61813:207::o;61353:151::-;60200:5;;-1:-1:-1;;;;;60200:5:0;60186:10;:19;60178:47;;;;-1:-1:-1;;;60178:47:0;;;;;;;:::i;:::-;61414:6:::1;::::0;-1:-1:-1;;;61414:6:0;::::1;;;61413:7;61405:44;;;::::0;-1:-1:-1;;;61405:44:0;;8371:2:1;61405:44:0::1;::::0;::::1;8353:21:1::0;8410:2;8390:18;;;8383:30;8449:26;8429:18;;;8422:54;8493:18;;61405:44:0::1;8169:348:1::0;61405:44:0::1;61460:6;:13:::0;;-1:-1:-1;;;;61460:13:0::1;-1:-1:-1::0;;;61460:13:0::1;::::0;;61489:7:::1;::::0;::::1;::::0;61460:13;;61489:7:::1;61353:151::o:0;13622:104::-;13678:13;13711:7;13704:14;;;;;:::i;12490:261::-;12586:15;;;;;;;;;-1:-1:-1;;;;;12586:15:0;-1:-1:-1;;;;;12586:21:0;;:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;12572:37:0;:10;-1:-1:-1;;;;;12572:37:0;;12564:59;;;;-1:-1:-1;;;12564:59:0;;8980:2:1;12564:59:0;;;8962:21:1;9019:1;8999:18;;;8992:29;-1:-1:-1;;;9037:18:1;;;9030:39;9086:18;;12564:59:0;8778:332:1;12564:59:0;12639:9;12634:110;12654:20;;;12634:110;;;12728:4;12696:15;:29;12712:9;;12722:1;12712:12;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;12696:29:0;;;;;;;;;;;;-1:-1:-1;12696:29:0;:36;;-1:-1:-1;;12696:36:0;;;;;;;;;;12676:3;;;;:::i;:::-;;;;12634:110;;;;12490:261;;:::o;12759:268::-;12861:15;;;;;;;;;-1:-1:-1;;;;;12861:15:0;-1:-1:-1;;;;;12861:21:0;;:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;12847:37:0;:10;-1:-1:-1;;;;;12847:37:0;;12839:59;;;;-1:-1:-1;;;12839:59:0;;8980:2:1;12839:59:0;;;8962:21:1;9019:1;8999:18;;;8992:29;-1:-1:-1;;;9037:18:1;;;9030:39;9086:18;;12839:59:0;8778:332:1;12839:59:0;12914:9;12909:111;12929:20;;;12909:111;;;13003:5;12971:15;:29;12987:9;;12997:1;12987:12;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;12971:29:0;;;;;;;;;;;;-1:-1:-1;12971:29:0;:37;;-1:-1:-1;;12971:37:0;;;;;;;;;;12951:3;;;;:::i;:::-;;;;12909:111;;17969:436;18062:4;7614:10;18062:4;18145:25;7614:10;18162:7;18145:9;:25::i;:::-;18118:52;;18209:15;18189:16;:35;;18181:85;;;;-1:-1:-1;;;18181:85:0;;9589:2:1;18181:85:0;;;9571:21:1;9628:2;9608:18;;;9601:30;9667:34;9647:18;;;9640:62;-1:-1:-1;;;9718:18:1;;;9711:35;9763:19;;18181:85:0;9387:401:1;18181:85:0;18302:60;18311:5;18318:7;18346:15;18327:16;:34;18302:8;:60::i;15036:207::-;15115:4;7614:10;15185:28;7614:10;15202:2;15206:6;15185:9;:28::i;62028:99::-;9056:6;;-1:-1:-1;;;;;9056:6:0;60070:10;:21;60062:49;;;;-1:-1:-1;;;60062:49:0;;;;;;;:::i;:::-;62095:14:::1;:24:::0;;-1:-1:-1;;;;;;62095:24:0::1;-1:-1:-1::0;;;;;62095:24:0;;;::::1;::::0;;;::::1;::::0;;62028:99::o;61030:295::-;9056:6;;-1:-1:-1;;;;;9056:6:0;60070:10;:21;60062:49;;;;-1:-1:-1;;;60062:49:0;;;;;;;:::i;:::-;61118:6:::1;::::0;-1:-1:-1;;;61118:6:0;::::1;;;61117:7;61109:35;;;;-1:-1:-1::0;;;61109:35:0::1;;;;;;;:::i;:::-;61193:5;::::0;-1:-1:-1;;;;;61193:5:0::1;61179:10;:19;61171:46;;;::::0;-1:-1:-1;;;61171:46:0;;9995:2:1;61171:46:0::1;::::0;::::1;9977:21:1::0;10034:2;10014:18;;;10007:30;-1:-1:-1;;;10053:18:1;;;10046:44;10107:18;;61171:46:0::1;9793:338:1::0;61171:46:0::1;61227:26;61233:10;61245:7;61227:5;:26::i;:::-;61277:7;61263:10;;:21;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;61299:18:0::1;::::0;61309:7;;61299:18:::1;::::0;;;::::1;61030:295:::0;:::o;60802:220::-;60308:14;;-1:-1:-1;;;;;60308:14:0;60294:10;:28;60286:56;;;;-1:-1:-1;;;60286:56:0;;;;;;;:::i;:::-;60888:6:::1;::::0;-1:-1:-1;;;60888:6:0;::::1;;;60887:7;60879:35;;;;-1:-1:-1::0;;;60879:35:0::1;;;;;;;:::i;15306:151::-:0;-1:-1:-1;;;;;15422:18:0;;;15395:7;15422:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;15306:151::o;62135:98::-;60200:5;;-1:-1:-1;;;;;60200:5:0;60186:10;:19;60178:47;;;;-1:-1:-1;;;60178:47:0;;;;;;;:::i;:::-;62208:5:::1;:17:::0;;-1:-1:-1;;;;;;62208:17:0::1;-1:-1:-1::0;;;;;62208:17:0;;;::::1;::::0;;;::::1;::::0;;62135:98::o;9882:201::-;8869:13;:11;:13::i;:::-;-1:-1:-1;;;;;9971:22:0;::::1;9963:73;;;::::0;-1:-1:-1;;;9963:73:0;;10338:2:1;9963:73:0::1;::::0;::::1;10320:21:1::0;10377:2;10357:18;;;10350:30;10416:34;10396:18;;;10389:62;-1:-1:-1;;;10467:18:1;;;10460:36;10513:19;;9963:73:0::1;10136:402:1::0;9963:73:0::1;10047:28;10066:8;10047:18;:28::i;:::-;9882:201:::0;:::o;21415:548::-;-1:-1:-1;;;;;21499:21:0;;21491:65;;;;-1:-1:-1;;;21491:65:0;;10745:2:1;21491:65:0;;;10727:21:1;10784:2;10764:18;;;10757:30;10823:33;10803:18;;;10796:61;10874:18;;21491:65:0;10543:355:1;21491:65:0;21647:6;21631:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;21802:18:0;;:9;:18;;;;;;;;;;;:28;;;;;;21857:37;1754:25:1;;;-1:-1:-1;;;;;;;;;;;21857:37:0;1727:18:1;21857:37:0;;;;;;;21415:548;;:::o;23409:346::-;-1:-1:-1;;;;;23511:19:0;;23503:68;;;;-1:-1:-1;;;23503:68:0;;11105:2:1;23503:68:0;;;11087:21:1;11144:2;11124:18;;;11117:30;11183:34;11163:18;;;11156:62;-1:-1:-1;;;11234:18:1;;;11227:34;11278:19;;23503:68:0;10903:400:1;23503:68:0;-1:-1:-1;;;;;23590:21:0;;23582:68;;;;-1:-1:-1;;;23582:68:0;;11510:2:1;23582:68:0;;;11492:21:1;11549:2;11529:18;;;11522:30;11588:34;11568:18;;;11561:62;-1:-1:-1;;;11639:18:1;;;11632:32;11681:19;;23582:68:0;11308:398:1;23582:68:0;-1:-1:-1;;;;;23663:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;23715:32;;1754:25:1;;;23715:32:0;;1727:18:1;23715:32:0;;;;;;;23409:346;;;:::o;24046:419::-;24147:24;24174:25;24184:5;24191:7;24174:9;:25::i;:::-;24147:52;;-1:-1:-1;;24214:16:0;:37;24210:248;;24296:6;24276:16;:26;;24268:68;;;;-1:-1:-1;;;24268:68:0;;11913:2:1;24268:68:0;;;11895:21:1;11952:2;11932:18;;;11925:30;11991:31;11971:18;;;11964:59;12040:18;;24268:68:0;11711:353:1;24268:68:0;24380:51;24389:5;24396:7;24424:6;24405:16;:25;24380:8;:51::i;:::-;24136:329;24046:419;;;:::o;18919:2207::-;-1:-1:-1;;;;;19016:18:0;;19008:68;;;;-1:-1:-1;;;19008:68:0;;12271:2:1;19008:68:0;;;12253:21:1;12310:2;12290:18;;;12283:30;12349:34;12329:18;;;12322:62;-1:-1:-1;;;12400:18:1;;;12393:35;12445:19;;19008:68:0;12069:401:1;19008:68:0;-1:-1:-1;;;;;19095:16:0;;19087:64;;;;-1:-1:-1;;;19087:64:0;;12677:2:1;19087:64:0;;;12659:21:1;12716:2;12696:18;;;12689:30;12755:34;12735:18;;;12728:62;-1:-1:-1;;;12806:18:1;;;12799:33;12849:19;;19087:64:0;12475:399:1;19087:64:0;-1:-1:-1;;;;;19237:15:0;;19215:19;19237:15;;;;;;;;;;;19271:21;;;;19263:72;;;;-1:-1:-1;;;19263:72:0;;13081:2:1;19263:72:0;;;13063:21:1;13120:2;13100:18;;;13093:30;13159:34;13139:18;;;13132:62;-1:-1:-1;;;13210:18:1;;;13203:36;13256:19;;19263:72:0;12879:402:1;19263:72:0;19433:10;19346:22;19417:27;;;:15;:27;;;;;;;;19413:1644;;;-1:-1:-1;;;;;;19629:15:0;;;:9;:15;;;;;;;;;;;19647:20;;;19629:38;;19847:13;;;;;;;;;;:31;;;;;;19907:34;;1754:25:1;;;19647:20:0;;19847:13;;19629:15;-1:-1:-1;;;;;;;;;;;19907:34:0;1727:18:1;19907:34:0;;;;;;;19413:1644;;;20016:17;20051:3;20037:10;:6;20046:1;20037:10;:::i;:::-;20036:18;;;;:::i;:::-;20016:38;-1:-1:-1;20106:18:0;20016:38;20106:6;:18;:::i;:::-;-1:-1:-1;;;;;20248:15:0;;;:9;:15;;;;;;;;;;;20266:20;;;20248:38;;20466:13;;;;;;;;:31;;;;;;20089:35;;-1:-1:-1;20597:13:0;20609:1;20597:9;:13;:::i;:::-;20576:34;-1:-1:-1;20621:16:0;20640:14;20576:34;20653:1;20640:14;:::i;:::-;20710:8;;-1:-1:-1;;;;;20710:8:0;;;20700:9;:19;;;;;;;;;;;:31;;;;;;20756:9;;;;20746:20;;;;;:34;;;;;;20805:10;;;;20795:21;;;;;;:35;;;;;;20859:34;;1754:25:1;;;20700:31:0;;-1:-1:-1;20859:34:0;;;;;;;;-1:-1:-1;;;;;;;;;;;20859:34:0;1727:18:1;20859:34:0;;;;;;;20924:8;;20909:34;;1754:25:1;;;-1:-1:-1;;;;;20924:8:0;;;;20909:34;;;-1:-1:-1;;;;;;;;;;;20909:34:0;1742:2:1;1727:18;20909:34:0;;;;;;;20974:9;;20959:37;;1754:25:1;;;-1:-1:-1;;;;;20974:9:0;;;;20959:37;;;-1:-1:-1;;;;;;;;;;;20959:37:0;1742:2:1;1727:18;20959:37:0;;;;;;;21027:10;;21012:38;;1754:25:1;;;-1:-1:-1;;;;;21027:10:0;;;;21012:38;;;-1:-1:-1;;;;;;;;;;;21012:38:0;1742:2:1;1727:18;21012:38:0;;;;;;;19971:1086;;;19413:1644;18997:2129;;18919:2207;;;:::o;9148:132::-;9056:6;;-1:-1:-1;;;;;9056:6:0;7614:10;9212:23;9204:68;;;;-1:-1:-1;;;9204:68:0;;13843:2:1;9204:68:0;;;13825:21:1;;;13862:18;;;13855:30;13921:34;13901:18;;;13894:62;13973:18;;9204:68:0;13641:356:1;10243:191:0;10336:6;;;-1:-1:-1;;;;;10353:17:0;;;-1:-1:-1;;;;;;10353:17:0;;;;;;;10386:40;;10336:6;;;10353:17;10336:6;;10386:40;;10317:16;;10386:40;10306:128;10243:191;:::o;22296:675::-;-1:-1:-1;;;;;22380:21:0;;22372:67;;;;-1:-1:-1;;;22372:67:0;;14204:2:1;22372:67:0;;;14186:21:1;14243:2;14223:18;;;14216:30;14282:34;14262:18;;;14255:62;-1:-1:-1;;;14333:18:1;;;14326:31;14374:19;;22372:67:0;14002:397:1;22372:67:0;-1:-1:-1;;;;;22539:18:0;;22514:22;22539:18;;;;;;;;;;;22576:24;;;;22568:71;;;;-1:-1:-1;;;22568:71:0;;14606:2:1;22568:71:0;;;14588:21:1;14645:2;14625:18;;;14618:30;14684:34;14664:18;;;14657:62;-1:-1:-1;;;14735:18:1;;;14728:32;14777:19;;22568:71:0;14404:398:1;22568:71:0;-1:-1:-1;;;;;22675:18:0;;:9;:18;;;;;;;;;;;22696:23;;;22675:44;;22814:12;:22;;;;;;;22865:37;1754:25:1;;;22675:9:0;;:18;-1:-1:-1;;;;;;;;;;;22865:37:0;1727:18:1;22865:37:0;;;;;;;12634:110;12490:261;;:::o;14:548:1:-;126:4;155:2;184;173:9;166:21;216:6;210:13;259:6;254:2;243:9;239:18;232:34;284:1;294:140;308:6;305:1;302:13;294:140;;;403:14;;;399:23;;393:30;369:17;;;388:2;365:26;358:66;323:10;;294:140;;;298:3;483:1;478:2;469:6;458:9;454:22;450:31;443:42;553:2;546;542:7;537:2;529:6;525:15;521:29;510:9;506:45;502:54;494:62;;;;14:548;;;;:::o;567:180::-;626:6;679:2;667:9;658:7;654:23;650:32;647:52;;;695:1;692;685:12;647:52;-1:-1:-1;718:23:1;;567:180;-1:-1:-1;567:180:1:o;752:131::-;-1:-1:-1;;;;;827:31:1;;817:42;;807:70;;873:1;870;863:12;888:315;956:6;964;1017:2;1005:9;996:7;992:23;988:32;985:52;;;1033:1;1030;1023:12;985:52;1072:9;1059:23;1091:31;1116:5;1091:31;:::i;:::-;1141:5;1193:2;1178:18;;;;1165:32;;-1:-1:-1;;;888:315:1:o;1790:456::-;1867:6;1875;1883;1936:2;1924:9;1915:7;1911:23;1907:32;1904:52;;;1952:1;1949;1942:12;1904:52;1991:9;1978:23;2010:31;2035:5;2010:31;:::i;:::-;2060:5;-1:-1:-1;2117:2:1;2102:18;;2089:32;2130:33;2089:32;2130:33;:::i;:::-;1790:456;;2182:7;;-1:-1:-1;;;2236:2:1;2221:18;;;;2208:32;;1790:456::o;2440:247::-;2499:6;2552:2;2540:9;2531:7;2527:23;2523:32;2520:52;;;2568:1;2565;2558:12;2520:52;2607:9;2594:23;2626:31;2651:5;2626:31;:::i;:::-;2676:5;2440:247;-1:-1:-1;;;2440:247:1:o;2692:529::-;2769:6;2777;2785;2838:2;2826:9;2817:7;2813:23;2809:32;2806:52;;;2854:1;2851;2844:12;2806:52;2893:9;2880:23;2912:31;2937:5;2912:31;:::i;:::-;2962:5;-1:-1:-1;3019:2:1;3004:18;;2991:32;3032:33;2991:32;3032:33;:::i;:::-;3084:7;-1:-1:-1;3143:2:1;3128:18;;3115:32;3156:33;3115:32;3156:33;:::i;:::-;3208:7;3198:17;;;2692:529;;;;;:::o;3226:615::-;3312:6;3320;3373:2;3361:9;3352:7;3348:23;3344:32;3341:52;;;3389:1;3386;3379:12;3341:52;3429:9;3416:23;3458:18;3499:2;3491:6;3488:14;3485:34;;;3515:1;3512;3505:12;3485:34;3553:6;3542:9;3538:22;3528:32;;3598:7;3591:4;3587:2;3583:13;3579:27;3569:55;;3620:1;3617;3610:12;3569:55;3660:2;3647:16;3686:2;3678:6;3675:14;3672:34;;;3702:1;3699;3692:12;3672:34;3755:7;3750:2;3740:6;3737:1;3733:14;3729:2;3725:23;3721:32;3718:45;3715:65;;;3776:1;3773;3766:12;3715:65;3807:2;3799:11;;;;;3829:6;;-1:-1:-1;3226:615:1;;-1:-1:-1;;;;3226:615:1:o;3846:388::-;3914:6;3922;3975:2;3963:9;3954:7;3950:23;3946:32;3943:52;;;3991:1;3988;3981:12;3943:52;4030:9;4017:23;4049:31;4074:5;4049:31;:::i;:::-;4099:5;-1:-1:-1;4156:2:1;4141:18;;4128:32;4169:33;4128:32;4169:33;:::i;:::-;4221:7;4211:17;;;3846:388;;;;;:::o;4239:380::-;4318:1;4314:12;;;;4361;;;4382:61;;4436:4;4428:6;4424:17;4414:27;;4382:61;4489:2;4481:6;4478:14;4458:18;4455:38;4452:161;;4535:10;4530:3;4526:20;4523:1;4516:31;4570:4;4567:1;4560:15;4598:4;4595:1;4588:15;4452:161;;4239:380;;;:::o;4624:339::-;4826:2;4808:21;;;4865:2;4845:18;;;4838:30;-1:-1:-1;;;4899:2:1;4884:18;;4877:45;4954:2;4939:18;;4624:339::o;4968:::-;5170:2;5152:21;;;5209:2;5189:18;;;5182:30;-1:-1:-1;;;5243:2:1;5228:18;;5221:45;5298:2;5283:18;;4968:339::o;5312:127::-;5373:10;5368:3;5364:20;5361:1;5354:31;5404:4;5401:1;5394:15;5428:4;5425:1;5418:15;5444:422;5533:1;5576:5;5533:1;5590:270;5611:7;5601:8;5598:21;5590:270;;;5670:4;5666:1;5662:6;5658:17;5652:4;5649:27;5646:53;;;5679:18;;:::i;:::-;5729:7;5719:8;5715:22;5712:55;;;5749:16;;;;5712:55;5828:22;;;;5788:15;;;;5590:270;;;5594:3;5444:422;;;;;:::o;5871:806::-;5920:5;5950:8;5940:80;;-1:-1:-1;5991:1:1;6005:5;;5940:80;6039:4;6029:76;;-1:-1:-1;6076:1:1;6090:5;;6029:76;6121:4;6139:1;6134:59;;;;6207:1;6202:130;;;;6114:218;;6134:59;6164:1;6155:10;;6178:5;;;6202:130;6239:3;6229:8;6226:17;6223:43;;;6246:18;;:::i;:::-;-1:-1:-1;;6302:1:1;6288:16;;6317:5;;6114:218;;6416:2;6406:8;6403:16;6397:3;6391:4;6388:13;6384:36;6378:2;6368:8;6365:16;6360:2;6354:4;6351:12;6347:35;6344:77;6341:159;;;-1:-1:-1;6453:19:1;;;6485:5;;6341:159;6532:34;6557:8;6551:4;6532:34;:::i;:::-;6602:6;6598:1;6594:6;6590:19;6581:7;6578:32;6575:58;;;6613:18;;:::i;:::-;6651:20;;5871:806;-1:-1:-1;;;5871:806:1:o;6682:140::-;6740:5;6769:47;6810:4;6800:8;6796:19;6790:4;6769:47;:::i;6827:168::-;6900:9;;;6931;;6948:15;;;6942:22;;6928:37;6918:71;;6969:18;;:::i;7000:125::-;7065:9;;;7086:10;;;7083:36;;;7099:18;;:::i;8522:251::-;8592:6;8645:2;8633:9;8624:7;8620:23;8616:32;8613:52;;;8661:1;8658;8651:12;8613:52;8693:9;8687:16;8712:31;8737:5;8712:31;:::i;9115:127::-;9176:10;9171:3;9167:20;9164:1;9157:31;9207:4;9204:1;9197:15;9231:4;9228:1;9221:15;9247:135;9286:3;9307:17;;;9304:43;;9327:18;;:::i;:::-;-1:-1:-1;9374:1:1;9363:13;;9247:135::o;13286:217::-;13326:1;13352;13342:132;;13396:10;13391:3;13387:20;13384:1;13377:31;13431:4;13428:1;13421:15;13459:4;13456:1;13449:15;13342:132;-1:-1:-1;13488:9:1;;13286:217::o;13508:128::-;13575:9;;;13596:11;;;13593:37;;;13610:18;;:::i

ipfs://b0b787ad3afa221fb30d70e48b60c87507930c7e8dbffb89c2593235b7f6a8c8