Token

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

interface IUniswapV2Factory    - function feeTo()    - function feeToSetter()    - function getPair(address tokenA, addr ...    - function allPairs(uint)    - function allPairsLength()    - function createPair(address tokenA, a ...    - function setFeeTo(address)    - function setFeeToSetter(address) library SafeMath    - function add(uint256 a, uint256 b)    - function sub(uint256 a, uint256 b)    - function sub(uint256 a, uint256 b, st ...    - function mul(uint256 a, uint256 b)    - function div(uint256 a, uint256 b)    - function div(uint256 a, uint256 b, st ...    - function mod(uint256 a, uint256 b)    - function mod(uint256 a, uint256 b, st ... library Counters    - function current(Counter storage coun ...    - function increment(Counter storage co ...    - function decrement(Counter storage co ... library Math    - function max(uint256 a, uint256 b)    - function min(uint256 a, uint256 b)    - function average(uint256 a, uint256 b ... library Arrays    - function findUpperBound(uint256[] sto ...    - function _msgSender()    - function _msgData() interface IERC20    - function totalSupply()    - function balanceOf(address account)    - function transfer(address recipient, ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom(address sender, ... library Address    - function isContract(address account)    - function sendValue(address payable re ...    - function functionCall(address target, ...    - function functionCall(address target, ...    - function functionCallWithValue(addres ...    - function functionCallWithValue(addres ...    - function _functionCallWithValue(addre ...  contract ERC20 is Context, IERC20    - 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 _transfer(address sender, ad ...    - function _mint(address account, uint2 ...    - function _burn(address account, uint2 ...    - function _approve(address owner, addr ...    - function _setupDecimals(uint8 decimal ...    - function _beforeTokenTransfer(address ...    - function _snapshot()    - function balanceOfAt(address account, ...    - function totalSupplyAt(uint256 snapsh ...    - function _transfer(address from, addr ...    - function _mint(address account, uint2 ...    - function _burn(address account, uint2 ...    - function _valueAt(uint256 snapshotId, ...    - function _updateAccountSnapshot(addre ...    - function _updateTotalSupplySnapshot()    - function _updateSnapshot(Snapshots st ...    - function _lastSnapshotId(uint256[] st ...  contract Pausable is Context    - function paused()    - function _pause()    - function _unpause()    - function _beforeTokenTransfer(address ...  contract Ownable is Context    - function owner()    - function renounceOwnership()    - function transferOwnership(address ne ... interface IUniswapV2Router02    - function swapExactTokensForETHSupport ...    - function factory()    - function WETH()    - function addLiquidityETH(  contract ERC20teamToken is ERC20Sn ... *    - function manager()    - function setManager(address manager)    - function snapshot()    - function setPoolAddress(address pool)    - function pause()    - function unpause()    - function unpauseExceptSelling()    - function _beforeTokenTransfer(address ...    - function isPaused()    - function setMaxWalletSize(uint256 max ...    - function setMaxTxnAmount(uint256 maxT ...    - function setMaxTxnAmountAndMaxWallet( ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2022-12-09
*/

// SPDX-License-Identifier: UNLICENSED

// Sources flattened with hardhat v2.12.2 https://hardhat.org

// File contracts/interfaces/IUniswapV2Factory.sol

interface IUniswapV2Factory {
    event PairCreated(address indexed token0, address indexed token1, address pair, uint);

    function feeTo() external view returns (address);
    function feeToSetter() external view returns (address);

    function getPair(address tokenA, address tokenB) external view returns (address pair);
    function allPairs(uint) external view returns (address pair);
    function allPairsLength() external view returns (uint);

    function createPair(address tokenA, address tokenB) external returns (address pair);

    function setFeeTo(address) external;
    function setFeeToSetter(address) external;
}


// File @openzeppelin/contracts/math/[email protected]


pragma solidity ^0.6.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

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

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

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

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

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

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts 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) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts 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 mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message 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, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}


// File @openzeppelin/contracts/utils/[email protected]


pragma solidity ^0.6.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 * Since it is not possible to overflow a 256 bit integer with increments of one, `increment` can skip the {SafeMath}
 * overflow check, thereby saving gas. This does assume however correct usage, in that the underlying `_value` is never
 * directly accessed.
 */
library Counters {
    using SafeMath for uint256;

    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        // The {SafeMath} overflow check can be skipped here, see the comment at the top
        counter._value += 1;
    }

    function decrement(Counter storage counter) internal {
        counter._value = counter._value.sub(1);
    }
}


// File @openzeppelin/contracts/math/[email protected]


pragma solidity ^0.6.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

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

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


// File @openzeppelin/contracts/utils/[email protected]


pragma solidity ^0.6.0;

/**
 * @dev Collection of functions related to array types.
 */
library Arrays {
   /**
     * @dev Searches a sorted `array` and returns the first index that contains
     * a value greater or equal to `element`. If no such index exists (i.e. all
     * values in the array are strictly less than `element`), the array length is
     * returned. Time complexity O(log n).
     *
     * `array` is expected to be sorted in ascending order, and to contain no
     * repeated elements.
     */
    function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
        if (array.length == 0) {
            return 0;
        }

        uint256 low = 0;
        uint256 high = array.length;

        while (low < high) {
            uint256 mid = Math.average(low, high);

            // Note that mid will always be strictly less than high (i.e. it will be a valid array index)
            // because Math.average rounds down (it does integer division with truncation).
            if (array[mid] > element) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }

        // At this point `low` is the exclusive upper bound. We will return the inclusive upper bound.
        if (low > 0 && array[low - 1] == element) {
            return low - 1;
        } else {
            return low;
        }
    }
}


// File @openzeppelin/contracts/GSN/[email protected]


pragma solidity ^0.6.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}


// File @openzeppelin/contracts/token/ERC20/[email protected]


pragma solidity ^0.6.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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 `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, 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 `sender` to `recipient` 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 sender, address recipient, uint256 amount) external returns (bool);

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


// File @openzeppelin/contracts/utils/[email protected]


pragma solidity ^0.6.2;

/**
 * @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
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(account) }
        return (codehash != accountHash && codehash != 0x0);
    }

    /**
     * @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://diligence.consensys.net/posts/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.5.11/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");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (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 functionCall(target, data, "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");
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
        if (success) {
            return returndata;
        } else {
            // 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

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}


// File @openzeppelin/contracts/token/ERC20/[email protected]


pragma solidity ^0.6.0;




/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of 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 {
    using SafeMath for uint256;
    using Address for address;

    mapping (address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;
    uint8 private _decimals;

    /**
     * @dev Sets the values for {name} and {symbol}, initializes {decimals} with
     * a default value of 18.
     *
     * To select a different value for {decimals}, use {_setupDecimals}.
     *
     * All three of these values are immutable: they can only be set once during
     * construction.
     */
    constructor (string memory name, string memory symbol) public {
        _name = name;
        _symbol = symbol;
        _decimals = 18;
    }

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

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view 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 {_setupDecimals} is
     * called.
     *
     * 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 returns (uint8) {
        return _decimals;
    }

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

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view 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);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        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].add(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) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        return true;
    }

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

        _beforeTokenTransfer(sender, recipient, amount);

        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements
     *
     * - `to` 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 = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(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);

        _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
     *
     * This is 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 Sets {decimals} to a value other than the default one of 18.
     *
     * WARNING: This function should only be called from the constructor. Most
     * applications that interact with token contracts will not expect
     * {decimals} to ever change, and may work incorrectly if it does.
     */
    function _setupDecimals(uint8 decimals_) internal {
        _decimals = decimals_;
    }

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


// File @openzeppelin/contracts/token/ERC20/[email protected]


pragma solidity ^0.6.0;




/**
 * @dev This contract extends an ERC20 token with a snapshot mechanism. When a snapshot is created, the balances and
 * total supply at the time are recorded for later access.
 *
 * This can be used to safely create mechanisms based on token balances such as trustless dividends or weighted voting.
 * In naive implementations it's possible to perform a "double spend" attack by reusing the same balance from different
 * accounts. By using snapshots to calculate dividends or voting power, those attacks no longer apply. It can also be
 * used to create an efficient ERC20 forking mechanism.
 *
 * Snapshots are created by the internal {_snapshot} function, which will emit the {Snapshot} event and return a
 * snapshot id. To get the total supply at the time of a snapshot, call the function {totalSupplyAt} with the snapshot
 * id. To get the balance of an account at the time of a snapshot, call the {balanceOfAt} function with the snapshot id
 * and the account address.
 *
 * ==== Gas Costs
 *
 * Snapshots are efficient. Snapshot creation is _O(1)_. Retrieval of balances or total supply from a snapshot is _O(log
 * n)_ in the number of snapshots that have been created, although _n_ for a specific account will generally be much
 * smaller since identical balances in subsequent snapshots are stored as a single entry.
 *
 * There is a constant overhead for normal ERC20 transfers due to the additional snapshot bookkeeping. This overhead is
 * only significant for the first transfer that immediately follows a snapshot for a particular account. Subsequent
 * transfers will have normal cost until the next snapshot, and so on.
 */
abstract contract ERC20Snapshot is ERC20 {
    // Inspired by Jordi Baylina's MiniMeToken to record historical balances:
    // https://github.com/Giveth/minimd/blob/ea04d950eea153a04c51fa510b068b9dded390cb/contracts/MiniMeToken.sol

    using SafeMath for uint256;
    using Arrays for uint256[];
    using Counters for Counters.Counter;

    // Snapshotted values have arrays of ids and the value corresponding to that id. These could be an array of a
    // Snapshot struct, but that would impede usage of functions that work on an array.
    struct Snapshots {
        uint256[] ids;
        uint256[] values;
    }

    mapping (address => Snapshots) private _accountBalanceSnapshots;
    Snapshots private _totalSupplySnapshots;

    // Snapshot ids increase monotonically, with the first value being 1. An id of 0 is invalid.
    Counters.Counter private _currentSnapshotId;

    /**
     * @dev Emitted by {_snapshot} when a snapshot identified by `id` is created.
     */
    event Snapshot(uint256 id);

    /**
     * @dev Creates a new snapshot and returns its snapshot id.
     *
     * Emits a {Snapshot} event that contains the same id.
     *
     * {_snapshot} is `internal` and you have to decide how to expose it externally. Its usage may be restricted to a
     * set of accounts, for example using {AccessControl}, or it may be open to the public.
     *
     * [WARNING]
     * ====
     * While an open way of calling {_snapshot} is required for certain trust minimization mechanisms such as forking,
     * you must consider that it can potentially be used by attackers in two ways.
     *
     * First, it can be used to increase the cost of retrieval of values from snapshots, although it will grow
     * logarithmically thus rendering this attack ineffective in the long term. Second, it can be used to target
     * specific accounts and increase the cost of ERC20 transfers for them, in the ways specified in the Gas Costs
     * section above.
     *
     * We haven't measured the actual numbers; if this is something you're interested in please reach out to us.
     * ====
     */
    function _snapshot() internal virtual returns (uint256) {
        _currentSnapshotId.increment();

        uint256 currentId = _currentSnapshotId.current();
        emit Snapshot(currentId);
        return currentId;
    }

    /**
     * @dev Retrieves the balance of `account` at the time `snapshotId` was created.
     */
    function balanceOfAt(address account, uint256 snapshotId) public view returns (uint256) {
        (bool snapshotted, uint256 value) = _valueAt(snapshotId, _accountBalanceSnapshots[account]);

        return snapshotted ? value : balanceOf(account);
    }

    /**
     * @dev Retrieves the total supply at the time `snapshotId` was created.
     */
    function totalSupplyAt(uint256 snapshotId) public view returns(uint256) {
        (bool snapshotted, uint256 value) = _valueAt(snapshotId, _totalSupplySnapshots);

        return snapshotted ? value : totalSupply();
    }

    // _transfer, _mint and _burn are the only functions where the balances are modified, so it is there that the
    // snapshots are updated. Note that the update happens _before_ the balance change, with the pre-modified value.
    // The same is true for the total supply and _mint and _burn.
    function _transfer(address from, address to, uint256 value) internal virtual override {
        _updateAccountSnapshot(from);
        _updateAccountSnapshot(to);

        super._transfer(from, to, value);
    }

    function _mint(address account, uint256 value) internal virtual override {
        _updateAccountSnapshot(account);
        _updateTotalSupplySnapshot();

        super._mint(account, value);
    }

    function _burn(address account, uint256 value) internal virtual override {
        _updateAccountSnapshot(account);
        _updateTotalSupplySnapshot();

        super._burn(account, value);
    }

    function _valueAt(uint256 snapshotId, Snapshots storage snapshots)
        private view returns (bool, uint256)
    {
        require(snapshotId > 0, "ERC20Snapshot: id is 0");
        // solhint-disable-next-line max-line-length
        require(snapshotId <= _currentSnapshotId.current(), "ERC20Snapshot: nonexistent id");

        // When a valid snapshot is queried, there are three possibilities:
        //  a) The queried value was not modified after the snapshot was taken. Therefore, a snapshot entry was never
        //  created for this id, and all stored snapshot ids are smaller than the requested one. The value that corresponds
        //  to this id is the current one.
        //  b) The queried value was modified after the snapshot was taken. Therefore, there will be an entry with the
        //  requested id, and its value is the one to return.
        //  c) More snapshots were created after the requested one, and the queried value was later modified. There will be
        //  no entry for the requested id: the value that corresponds to it is that of the smallest snapshot id that is
        //  larger than the requested one.
        //
        // In summary, we need to find an element in an array, returning the index of the smallest value that is larger if
        // it is not found, unless said value doesn't exist (e.g. when all values are smaller). Arrays.findUpperBound does
        // exactly this.

        uint256 index = snapshots.ids.findUpperBound(snapshotId);

        if (index == snapshots.ids.length) {
            return (false, 0);
        } else {
            return (true, snapshots.values[index]);
        }
    }

    function _updateAccountSnapshot(address account) private {
        _updateSnapshot(_accountBalanceSnapshots[account], balanceOf(account));
    }

    function _updateTotalSupplySnapshot() private {
        _updateSnapshot(_totalSupplySnapshots, totalSupply());
    }

    function _updateSnapshot(Snapshots storage snapshots, uint256 currentValue) private {
        uint256 currentId = _currentSnapshotId.current();
        if (_lastSnapshotId(snapshots.ids) < currentId) {
            snapshots.ids.push(currentId);
            snapshots.values.push(currentValue);
        }
    }

    function _lastSnapshotId(uint256[] storage ids) private view returns (uint256) {
        if (ids.length == 0) {
            return 0;
        } else {
            return ids[ids.length - 1];
        }
    }
}


// File @openzeppelin/contracts/utils/[email protected]


pragma solidity ^0.6.0;

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor () internal {
        _paused = false;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view returns (bool) {
        return _paused;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        require(!_paused, "Pausable: paused");
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        require(_paused, "Pausable: not paused");
        _;
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}


// File @openzeppelin/contracts/token/ERC20/[email protected]


pragma solidity ^0.6.0;


/**
 * @dev ERC20 token with pausable token transfers, minting and burning.
 *
 * Useful for scenarios such as preventing trades until the end of an evaluation
 * period, or having an emergency switch for freezing all token transfers in the
 * event of a large bug.
 */
abstract contract ERC20Pausable is ERC20, Pausable {
    /**
     * @dev See {ERC20-_beforeTokenTransfer}.
     *
     * Requirements:
     *
     * - the contract must not be paused.
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {
        super._beforeTokenTransfer(from, to, amount);

        require(!paused(), "ERC20Pausable: token transfer while paused");
    }
}


// File @openzeppelin/contracts/access/[email protected]


pragma solidity ^0.6.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.
 */
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 () internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}


// File contracts/mocks/ERC20teamToken.sol

pragma solidity 0.6.12;





interface IUniswapV2Router02 {
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;

    function factory() external pure returns (address);

    function WETH() external pure returns (address);

    function addLiquidityETH(
        address token,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    )
    external
    payable
    returns (
        uint256 amountToken,
        uint256 amountETH,
        uint256 liquidity
    );
}

/// @notice Mock ERC20 contract for testing purposes
contract ERC20teamToken is ERC20Snapshot, Pausable, Ownable {

    address private _manager;
    address private _pool;
    IUniswapV2Router02 public uniswapV2Router;
    address public uniswapV2Pair;
    bool private _pauseExceptSelling = false;
    uint256 public _maxWalletSize = 15000 * 10**9; //1.5% max wallet size
    uint256 public _maxTxAmount = 15000 * 10**9; //1.5% max tx amount

    constructor(
        string memory name,
        string memory symbol,
        uint8 decimals,
        address manager,
        address uniswapRouter,
        address stableToken
    ) public payable ERC20(name, symbol) Ownable() {
        _setupDecimals(decimals);
        _mint(msg.sender, 1000000000000000); //mint 1 million tokens
        _manager = manager;
        IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(uniswapRouter);//
        uniswapV2Router = _uniswapV2Router;
        uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
        .createPair(address(this), stableToken);
    }

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyManager() {
        require(_manager == _msgSender(), "caller is not the manager");
        _;
    }

    function setManager(address manager) external onlyManager{
        _manager = manager;
    }

    function snapshot() external  onlyManager returns(uint256){
        uint256 snapshotId = _snapshot();
        return snapshotId;
    }

    function setPoolAddress(address pool) external onlyManager {
        _pool = pool;
    }

    function pause() external  onlyManager{
        _pause();
    }

    function unpause() external  onlyManager{
        _unpause();
    }

    function unpauseExceptSelling() external  onlyManager{
        _unpause();
        _pauseExceptSelling = true;
    }

    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {
        super._beforeTokenTransfer(from, to, amount);

        require(!paused(), "ERC20Pausable: token transfer while paused");
        if(_pauseExceptSelling){
            require(from == _pool,"can only  transfer from pool");
        }

        if (from != owner() && to != owner()) {
            require(amount <= _maxTxAmount, "TOKEN: Max Transaction Limit");
            if(to != uniswapV2Pair) {
                require(balanceOf(to) + amount < _maxWalletSize, "TOKEN: Balance exceeds wallet size!");
            }
        }

    }

    function isPaused() external view returns(bool){
        return paused() || _pauseExceptSelling;
    }

    function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
        _maxWalletSize = maxWalletSize;
    }

    //Set maximum transaction
    function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
        _maxTxAmount = maxTxAmount;
    }

    //Set maximum transaction
    function setMaxTxnAmountAndMaxWallet(uint256 maxTxAmount,uint256 maxWalletSize) public onlyOwner {
        _maxTxAmount = maxTxAmount;
        _maxWalletSize = maxWalletSize;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"address","name":"manager","type":"address"},{"internalType":"address","name":"uniswapRouter","type":"address"},{"internalType":"address","name":"stableToken","type":"address"}],"stateMutability":"payable","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":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"}],"name":"Snapshot","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":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"_maxTxAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_maxWalletSize","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":"address","name":"account","type":"address"},{"internalType":"uint256","name":"snapshotId","type":"uint256"}],"name":"balanceOfAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":[{"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":"isPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"manager","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":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"manager","type":"address"}],"name":"setManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"maxTxAmount","type":"uint256"}],"name":"setMaxTxnAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"maxTxAmount","type":"uint256"},{"internalType":"uint256","name":"maxWalletSize","type":"uint256"}],"name":"setMaxTxnAmountAndMaxWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"maxWalletSize","type":"uint256"}],"name":"setMaxWalletSize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"pool","type":"address"}],"name":"setPoolAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"snapshot","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"uint256","name":"snapshotId","type":"uint256"}],"name":"totalSupplyAt","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"},{"inputs":[],"name":"uniswapV2Pair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"uniswapV2Router","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpauseExceptSelling","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

00000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000015be6f89ebc1aca8e64b6492cff4d3d1ee1eafb0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48000000000000000000000000000000000000000000000000000000000000000a4252415a494c2d4b41490000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000034252410000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name (string): BRAZIL-KAI
Arg [1] : symbol (string): BRA
Arg [2] : decimals (uint8): 9
Arg [3] : manager (address): 0x015bE6f89EBc1acA8E64B6492cFF4D3d1EE1Eafb
Arg [4] : uniswapRouter (address): 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
Arg [5] : stableToken (address): 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48

-----Encoded View---------------
10 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000100
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000009
Arg [3] : 000000000000000000000000015be6f89ebc1aca8e64b6492cff4d3d1ee1eafb
Arg [4] : 0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d
Arg [5] : 000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48
Arg [6] : 000000000000000000000000000000000000000000000000000000000000000a
Arg [7] : 4252415a494c2d4b414900000000000000000000000000000000000000000000
Arg [8] : 0000000000000000000000000000000000000000000000000000000000000003
Arg [9] : 4252410000000000000000000000000000000000000000000000000000000000

45774:3298:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22375:83;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24481:169;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;24481:169:0;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;45902:41;;;:::i;:::-;;;;-1:-1:-1;;;;;45902:41:0;;;;;;;;;;;;;;23450:100;;;:::i;:::-;;;;;;;;;;;;;;;;25124:321;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;25124:321:0;;;;;;;;;;;;;;;;;:::i;23302:83::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;25854:218;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;25854:218:0;;;;;;;;:::i;47608:69::-;;;:::i;:::-;;46890:83;;;:::i;45950:28::-;;;:::i;35477:258::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;35477:258:0;;;;;;;;:::i;40613:78::-;;;:::i;23613:119::-;;;;;;;;;;;;;;;;-1:-1:-1;23613:119:0;-1:-1:-1;;;;;23613:119:0;;:::i;44362:148::-;;;:::i;48739:108::-;;;;;;;;;;;;;;;;-1:-1:-1;48739:108:0;;:::i;46107:43::-;;;:::i;47535:65::-;;;:::i;43720:79::-;;;:::i;46032:45::-;;;:::i;22577:87::-;;;:::i;47292:137::-;;;:::i;35839:225::-;;;;;;;;;;;;;;;;-1:-1:-1;35839:225:0;;:::i;47685:119::-;;;:::i;26575:269::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;26575:269:0;;;;;;;;:::i;23945:175::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;23945:175:0;;;;;;;;:::i;48473:104::-;;;:::i;48886:183::-;;;;;;;;;;;;;;;;-1:-1:-1;48886:183:0;;;;;;;:::i;47190:94::-;;;;;;;;;;;;;;;;-1:-1:-1;47190:94:0;-1:-1:-1;;;;;47190:94:0;;:::i;24183:151::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;24183:151:0;;;;;;;;;;:::i;47437:90::-;;;;;;;;;;;;;;;;-1:-1:-1;47437:90:0;-1:-1:-1;;;;;47437:90:0;;:::i;48585:115::-;;;;;;;;;;;;;;;;-1:-1:-1;48585:115:0;;:::i;44665:244::-;;;;;;;;;;;;;;;;-1:-1:-1;44665:244:0;-1:-1:-1;;;;;44665:244:0;;:::i;22375:83::-;22445:5;22438:12;;;;;;;;-1:-1:-1;;22438:12:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22412:13;;22438:12;;22445:5;;22438:12;;22445:5;22438:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22375:83;:::o;24481:169::-;24564:4;24581:39;24590:12;:10;:12::i;:::-;24604:7;24613:6;24581:8;:39::i;:::-;-1:-1:-1;24638:4:0;24481:169;;;;;:::o;45902:41::-;;;-1:-1:-1;;;;;45902:41:0;;:::o;23450:100::-;23530:12;;23450:100;:::o;25124:321::-;25230:4;25247:36;25257:6;25265:9;25276:6;25247:9;:36::i;:::-;25294:121;25303:6;25311:12;:10;:12::i;:::-;25325:89;25363:6;25325:89;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;25325:19:0;;;;;;:11;:19;;;;;;25345:12;:10;:12::i;:::-;-1:-1:-1;;;;;25325:33:0;;;;;;;;;;;;-1:-1:-1;25325:33:0;;;:89;:37;:89::i;:::-;25294:8;:121::i;:::-;-1:-1:-1;25433:4:0;25124:321;;;;;:::o;23302:83::-;23368:9;;;;23302:83;:::o;25854:218::-;25942:4;25959:83;25968:12;:10;:12::i;:::-;25982:7;25991:50;26030:10;25991:11;:25;26003:12;:10;:12::i;:::-;-1:-1:-1;;;;;25991:25:0;;;;;;;;;;;;;;;;;-1:-1:-1;25991:25:0;;;:34;;;;;;;;;;;:38;:50::i;47608:69::-;47120:12;:10;:12::i;:::-;47108:8;;-1:-1:-1;;;;;47108:8:0;;;:24;;;47100:62;;;;;-1:-1:-1;;;47100:62:0;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;47100:62:0;;;;;;;;;;;;;;;47659:10:::1;:8;:10::i;:::-;47608:69::o:0;46890:83::-;46957:8;;-1:-1:-1;;;;;46957:8:0;46890:83;:::o;45950:28::-;;;-1:-1:-1;;;;;45950:28:0;;:::o;35477:258::-;-1:-1:-1;;;;;35633:33:0;;35556:7;35633:33;;;:24;:33;;;;;35556:7;;;;35612:55;;35621:10;;35612:8;:55::i;:::-;35576:91;;;;35687:11;:40;;35709:18;35719:7;35709:9;:18::i;:::-;35687:40;;;35701:5;35687:40;35680:47;35477:258;-1:-1:-1;;;;;35477:258:0:o;40613:78::-;40676:7;;;;40613:78;:::o;23613:119::-;-1:-1:-1;;;;;23706:18:0;;23679:7;23706:18;;;;;;;;;;;23613:119;;;;:::o;44362:148::-;43942:12;:10;:12::i;:::-;43932:6;;;;;-1:-1:-1;;;;;43932:6:0;;;:22;;;43924:67;;;;;-1:-1:-1;;;43924:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;43924:67:0;;;;;;;;;;;;;;;44453:6:::1;::::0;44432:40:::1;::::0;44469:1:::1;::::0;44453:6:::1;::::0;::::1;-1:-1:-1::0;;;;;44453:6:0::1;::::0;44432:40:::1;::::0;44469:1;;44432:40:::1;44483:6;:19:::0;;-1:-1:-1;;;;;;44483:19:0::1;::::0;;44362:148::o;48739:108::-;43942:12;:10;:12::i;:::-;43932:6;;;;;-1:-1:-1;;;;;43932:6:0;;;:22;;;43924:67;;;;;-1:-1:-1;;;43924:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;43924:67:0;;;;;;;;;;;;;;;48813:12:::1;:26:::0;48739:108::o;46107:43::-;;;;:::o;47535:65::-;47120:12;:10;:12::i;:::-;47108:8;;-1:-1:-1;;;;;47108:8:0;;;:24;;;47100:62;;;;;-1:-1:-1;;;47100:62:0;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;47100:62:0;;;;;;;;;;;;;;;47584:8:::1;:6;:8::i;43720:79::-:0;43785:6;;;;;-1:-1:-1;;;;;43785:6:0;;43720:79::o;46032:45::-;;;;:::o;22577:87::-;22649:7;22642:14;;;;;;;;-1:-1:-1;;22642:14:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22616:13;;22642:14;;22649:7;;22642:14;;22649:7;22642:14;;;;;;;;;;;;;;;;;;;;;;;;47292:137;47342:7;47120:12;:10;:12::i;:::-;47108:8;;-1:-1:-1;;;;;47108:8:0;;;:24;;;47100:62;;;;;-1:-1:-1;;;47100:62:0;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;47100:62:0;;;;;;;;;;;;;;;47361:18:::1;47382:11;:9;:11::i;:::-;47361:32:::0;-1:-1:-1;;47292:137:0;:::o;35839:225::-;35902:7;35923:16;35941:13;35958:43;35967:10;35979:21;35958:8;:43::i;:::-;35922:79;;;;36021:11;:35;;36043:13;:11;:13::i;:::-;36021:35;;;36035:5;36021:35;36014:42;35839:225;-1:-1:-1;;;;35839:225:0:o;47685:119::-;47120:12;:10;:12::i;:::-;47108:8;;-1:-1:-1;;;;;47108:8:0;;;:24;;;47100:62;;;;;-1:-1:-1;;;47100:62:0;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;47100:62:0;;;;;;;;;;;;;;;47749:10:::1;:8;:10::i;:::-;47770:19;:26:::0;;-1:-1:-1;;;;47770:26:0::1;-1:-1:-1::0;;;47770:26:0::1;::::0;;47685:119::o;26575:269::-;26668:4;26685:129;26694:12;:10;:12::i;:::-;26708:7;26717:96;26756:15;26717:96;;;;;;;;;;;;;;;;;:11;:25;26729:12;:10;:12::i;:::-;-1:-1:-1;;;;;26717:25:0;;;;;;;;;;;;;;;;;-1:-1:-1;26717:25:0;;;:34;;;;;;;;;;;:96;:38;:96::i;23945:175::-;24031:4;24048:42;24058:12;:10;:12::i;:::-;24072:9;24083:6;24048:9;:42::i;48473:104::-;48515:4;48538:8;:6;:8::i;:::-;:31;;;-1:-1:-1;48550:19:0;;-1:-1:-1;;;48550:19:0;;;;48538:31;48531:38;;48473:104;:::o;48886:183::-;43942:12;:10;:12::i;:::-;43932:6;;;;;-1:-1:-1;;;;;43932:6:0;;;:22;;;43924:67;;;;;-1:-1:-1;;;43924:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;43924:67:0;;;;;;;;;;;;;;;48994:12:::1;:26:::0;;;;49031:14:::1;:30:::0;48886:183::o;47190:94::-;47120:12;:10;:12::i;:::-;47108:8;;-1:-1:-1;;;;;47108:8:0;;;:24;;;47100:62;;;;;-1:-1:-1;;;47100:62:0;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;47100:62:0;;;;;;;;;;;;;;;47258:8:::1;:18:::0;;-1:-1:-1;;;;;;47258:18:0::1;-1:-1:-1::0;;;;;47258:18:0;;;::::1;::::0;;;::::1;::::0;;47190:94::o;24183:151::-;-1:-1:-1;;;;;24299:18:0;;;24272:7;24299:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;24183:151::o;47437:90::-;47120:12;:10;:12::i;:::-;47108:8;;-1:-1:-1;;;;;47108:8:0;;;:24;;;47100:62;;;;;-1:-1:-1;;;47100:62:0;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;47100:62:0;;;;;;;;;;;;;;;47507:5:::1;:12:::0;;-1:-1:-1;;;;;;47507:12:0::1;-1:-1:-1::0;;;;;47507:12:0;;;::::1;::::0;;;::::1;::::0;;47437:90::o;48585:115::-;43942:12;:10;:12::i;:::-;43932:6;;;;;-1:-1:-1;;;;;43932:6:0;;;:22;;;43924:67;;;;;-1:-1:-1;;;43924:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;43924:67:0;;;;;;;;;;;;;;;48662:14:::1;:30:::0;48585:115::o;44665:244::-;43942:12;:10;:12::i;:::-;43932:6;;;;;-1:-1:-1;;;;;43932:6:0;;;:22;;;43924:67;;;;;-1:-1:-1;;;43924:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;43924:67:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;44754:22:0;::::1;44746:73;;;;-1:-1:-1::0;;;44746:73:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44856:6;::::0;44835:38:::1;::::0;-1:-1:-1;;;;;44835:38:0;;::::1;::::0;44856:6:::1;::::0;::::1;;::::0;44835:38:::1;::::0;;;::::1;44884:6;:17:::0;;-1:-1:-1;;;;;44884:17:0;;::::1;;;-1:-1:-1::0;;;;;;44884:17:0;;::::1;::::0;;;::::1;::::0;;44665:244::o;28154:378::-;-1:-1:-1;;;;;28238:21:0;;28230:65;;;;;-1:-1:-1;;;28230:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;28308:49;28337:1;28341:7;28350:6;28308:20;:49::i;:::-;28385:12;;:24;;28402:6;28385:16;:24::i;:::-;28370:12;:39;-1:-1:-1;;;;;28441:18:0;;:9;:18;;;;;;;;;;;:30;;28464:6;28441:22;:30::i;:::-;-1:-1:-1;;;;;28420:18:0;;:9;:18;;;;;;;;;;;:51;;;;28487:37;;;;;;;28420:18;;:9;;28487:37;;;;;;;;;;28154:378;;:::o;1744:181::-;1802:7;1834:5;;;1858:6;;;;1850:46;;;;;-1:-1:-1;;;1850:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;1916:1;1744:181;-1:-1:-1;;;1744:181:0:o;7325:114::-;7417:14;;7325:114::o;31093:92::-;;;;:::o;10768:106::-;10856:10;10768:106;:::o;29722:346::-;-1:-1:-1;;;;;29824:19:0;;29816:68;;;;-1:-1:-1;;;29816:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;29903:21:0;;29895:68;;;;-1:-1:-1;;;29895:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;29976:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;30028:32;;;;;;;;;;;;;;;;;29722:346;;;:::o;36372:215::-;36469:28;36492:4;36469:22;:28::i;:::-;36508:26;36531:2;36508:22;:26::i;:::-;36547:32;36563:4;36569:2;36573:5;36547:15;:32::i;2647:192::-;2733:7;2769:12;2761:6;;;;2753:29;;;;-1:-1:-1;;;2753:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;2805:5:0;;;2647:192::o;41662:120::-;41207:7;;;;41199:40;;;;;-1:-1:-1;;;41199:40:0;;;;;;;;;;;;-1:-1:-1;;;41199:40:0;;;;;;;;;;;;;;;41721:7:::1;:15:::0;;-1:-1:-1;;41721:15:0::1;::::0;;41752:22:::1;41761:12;:10;:12::i;:::-;41752:22;::::0;;-1:-1:-1;;;;;41752:22:0;;::::1;::::0;;;;;;;::::1;::::0;;::::1;41662:120::o:0;37015:1692::-;37113:4;37119:7;37165:1;37152:10;:14;37144:49;;;;;-1:-1:-1;;;37144:49:0;;;;;;;;;;;;-1:-1:-1;;;37144:49:0;;;;;;;;;;;;;;;37280:28;:18;:26;:28::i;:::-;37266:10;:42;;37258:84;;;;;-1:-1:-1;;;37258:84:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;38481:13;38497:40;:9;38526:10;38497:28;:40::i;:::-;38563:20;;38481:56;;-1:-1:-1;38554:29:0;;38550:150;;;38608:5;38615:1;38600:17;;;;;;;38550:150;38658:4;38664:9;:16;;38681:5;38664:23;;;;;;;;;;;;;;;;38650:38;;;;;37015:1692;;;;;;:::o;41403:118::-;40931:7;;;;40930:8;40922:37;;;;;-1:-1:-1;;;40922:37:0;;;;;;;;;;;;-1:-1:-1;;;40922:37:0;;;;;;;;;;;;;;;41463:7:::1;:14:::0;;-1:-1:-1;;41463:14:0::1;41473:4;41463:14;::::0;;41493:20:::1;41500:12;:10;:12::i;35137:228::-:0;35184:7;35204:30;:18;:28;:30::i;:::-;35247:17;35267:28;:18;:26;:28::i;:::-;35311:19;;;;;;;;35247:48;;-1:-1:-1;35311:19:0;;;;;;;;;;35348:9;-1:-1:-1;35137:228:0;:::o;47812:653::-;47921:44;47948:4;47954:2;47958:6;47921:26;:44::i;:::-;47987:8;:6;:8::i;:::-;47986:9;47978:64;;;;-1:-1:-1;;;47978:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48056:19;;-1:-1:-1;;;48056:19:0;;;;48053:103;;;48107:5;;-1:-1:-1;;;;;48099:13:0;;;48107:5;;48099:13;48091:53;;;;;-1:-1:-1;;;48091:53:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;48180:7;:5;:7::i;:::-;-1:-1:-1;;;;;48172:15:0;:4;-1:-1:-1;;;;;48172:15:0;;;:32;;;;;48197:7;:5;:7::i;:::-;-1:-1:-1;;;;;48191:13:0;:2;-1:-1:-1;;;;;48191:13:0;;;48172:32;48168:288;;;48239:12;;48229:6;:22;;48221:63;;;;;-1:-1:-1;;;48221:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;48308:13;;-1:-1:-1;;;;;48302:19:0;;;48308:13;;48302:19;48299:146;;48375:14;;48366:6;48350:13;48360:2;48350:9;:13::i;:::-;:22;:39;48342:87;;;;-1:-1:-1;;;48342:87:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38715:146;-1:-1:-1;;;;;38799:33:0;;;;;;:24;:33;;;;;38783:70;;38834:18;38824:7;38834:9;:18::i;:::-;38783:15;:70::i;:::-;38715:146;:::o;27334:539::-;-1:-1:-1;;;;;27440:20:0;;27432:70;;;;-1:-1:-1;;;27432:70:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;27521:23:0;;27513:71;;;;-1:-1:-1;;;27513:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27597:47;27618:6;27626:9;27637:6;27597:20;:47::i;:::-;27677:71;27699:6;27677:71;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;27677:17:0;;:9;:17;;;;;;;;;;;;:71;:21;:71::i;:::-;-1:-1:-1;;;;;27657:17:0;;;:9;:17;;;;;;;;;;;:91;;;;27782:20;;;;;;;:32;;27807:6;27782:24;:32::i;:::-;-1:-1:-1;;;;;27759:20:0;;;:9;:20;;;;;;;;;;;;:55;;;;27830:35;;;;;;;27759:20;;27830:35;;;;;;;;;;;;;27334:539;;;:::o;9211:918::-;9324:12;;9300:7;;9320:58;;-1:-1:-1;9365:1:0;9358:8;;9320:58;9431:12;;9390:11;;9456:424;9469:4;9463:3;:10;9456:424;;;9490:11;9504:23;9517:3;9522:4;9504:12;:23::i;:::-;9490:37;;9761:7;9748:5;9754:3;9748:10;;;;;;;;;;;;;;;;:20;9744:125;;;9796:3;9789:10;;9744:125;;;9846:3;9852:1;9846:7;9840:13;;9744:125;9456:424;;;;10006:1;10000:3;:7;:36;;;;;10029:7;10011:5;10023:1;10017:3;:7;10011:14;;;;;;;;;;;;;;;;:25;10000:36;9996:126;;;-1:-1:-1;;;10060:7:0;;-1:-1:-1;10053:14:0;;9996:126;-1:-1:-1;10107:3:0;-1:-1:-1;10100:10:0;;7447:181;7601:19;;7619:1;7601:19;;;7447:181::o;38995:315::-;39090:17;39110:28;:18;:26;:28::i;:::-;39090:48;-1:-1:-1;39090:48:0;39153:30;39169:9;39153:15;:30::i;:::-;:42;39149:154;;;39212:29;;;;;;;;-1:-1:-1;39212:29:0;;;;;;;;;;;;;;39256:16;;;:35;;;;;;;;;;;;;;;38995:315::o;8412:193::-;8474:7;8595:1;;8586;:5;8582:1;8578;:5;:13;8577:19;;;;;;8571:1;8567;:5;8561:1;8557;:5;8556:17;:41;;8412:193;-1:-1:-1;;;8412:193:0:o;39318:212::-;39412:10;;39388:7;;39408:115;;-1:-1:-1;39451:1:0;39444:8;;39408:115;39496:10;;39492:3;;-1:-1:-1;;39496:14:0;;;39492:19;;;;;;;;;;;;;;39485:26;;;

ipfs://3ee6e86a1a7942a763b2e95c90873c7fea40d10d21cbaf092ae7a34632ea656c