Feature Tip: Add private address tag to any address under My Name Tag !
ERC-20
Overview
Max Total Supply
10,000,000,000 BEE
Holders
114
Market
Onchain Market Cap
$0.00
Circulating Supply Market Cap
-
Other Info
Token Contract (WITH 9 Decimals)
Loading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
Contract Name:
Token
Compiler Version
v0.8.7+commit.e28d00a7
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2023-06-06 */ // File: IPancakePair.sol pragma solidity ^0.8.4; interface IPancakePair { event Approval(address indexed owner, address indexed spender, uint value); event Transfer(address indexed from, address indexed to, uint value); function name() external pure returns (string memory); function symbol() external pure returns (string memory); function decimals() external pure returns (uint8); function totalSupply() external view returns (uint); function balanceOf(address owner) external view returns (uint); function allowance(address owner, address spender) external view returns (uint); function approve(address spender, uint value) external returns (bool); function transfer(address to, uint value) external returns (bool); function transferFrom(address from, address to, uint value) external returns (bool); function DOMAIN_SEPARATOR() external view returns (bytes32); function PERMIT_TYPEHASH() external pure returns (bytes32); function nonces(address owner) external view returns (uint); function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external; event Mint(address indexed sender, uint amount0, uint amount1); event Burn(address indexed sender, uint amount0, uint amount1, address indexed to); event Swap( address indexed sender, uint amount0In, uint amount1In, uint amount0Out, uint amount1Out, address indexed to ); event Sync(uint112 reserve0, uint112 reserve1); function MINIMUM_LIQUIDITY() external pure returns (uint); function factory() external view returns (address); function token0() external view returns (address); function token1() external view returns (address); function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast); function price0CumulativeLast() external view returns (uint); function price1CumulativeLast() external view returns (uint); function kLast() external view returns (uint); function mint(address to) external returns (uint liquidity); function burn(address to) external returns (uint amount0, uint amount1); function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external; function skim(address to) external; function sync() external; function initialize(address, address) external; } // File: ISwapFactory.sol pragma solidity ^0.8.4; interface ISwapFactory { function createPair(address tokenA, address tokenB) external returns (address pair); function getPair(address tokenA, address tokenB) external returns (address pair); } // File: ISwapRouter.sol pragma solidity ^0.8.4; interface ISwapRouter { function factoryV2() external pure returns (address); function factory() external pure returns (address); function WETH() external pure returns (address); function swapExactTokensForTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to ) external; function swapExactTokensForTokensSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; function swapExactTokensForETHSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; function addLiquidity( address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB, uint liquidity); function addLiquidityETH( address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external payable returns (uint amountToken, uint amountETH, uint liquidity); function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB); function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut); function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn); function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts); function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts); } // File: @openzeppelin/contracts/utils/introspection/IERC165.sol // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); } // File: @openzeppelin/contracts/utils/introspection/ERC165.sol // OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol) pragma solidity ^0.8.0; /** * @dev Implementation of the {IERC165} interface. * * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check * for the additional interface id that will be supported. For example: * * ```solidity * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); * } * ``` * * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation. */ abstract contract ERC165 is IERC165 { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165).interfaceId; } } // File: @openzeppelin/contracts/utils/math/SignedMath.sol // OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol) pragma solidity ^0.8.0; /** * @dev Standard signed math utilities missing in the Solidity language. */ library SignedMath { /** * @dev Returns the largest of two signed numbers. */ function max(int256 a, int256 b) internal pure returns (int256) { return a > b ? a : b; } /** * @dev Returns the smallest of two signed numbers. */ function min(int256 a, int256 b) internal pure returns (int256) { return a < b ? a : b; } /** * @dev Returns the average of two signed numbers without overflow. * The result is rounded towards zero. */ function average(int256 a, int256 b) internal pure returns (int256) { // Formula from the book "Hacker's Delight" int256 x = (a & b) + ((a ^ b) >> 1); return x + (int256(uint256(x) >> 255) & (a ^ b)); } /** * @dev Returns the absolute unsigned value of a signed value. */ function abs(int256 n) internal pure returns (uint256) { unchecked { // must be unchecked in order to support `n = type(int256).min` return uint256(n >= 0 ? n : -n); } } } // File: @openzeppelin/contracts/utils/math/Math.sol // OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol) pragma solidity ^0.8.0; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { enum Rounding { Down, // Toward negative infinity Up, // Toward infinity Zero // Toward zero } /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a > b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow. return (a & b) + (a ^ b) / 2; } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds up instead * of rounding down. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b - 1) / b can overflow on addition, so we distribute. return a == 0 ? 0 : (a - 1) / b + 1; } /** * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0 * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) * with further edits by Uniswap Labs also under MIT license. */ function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) { unchecked { // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 // variables such that product = prod1 * 2^256 + prod0. uint256 prod0; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(x, y, not(0)) prod0 := mul(x, y) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Handle non-overflow cases, 256 by 256 division. if (prod1 == 0) { // Solidity will revert if denominator == 0, unlike the div opcode on its own. // The surrounding unchecked block does not change this fact. // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic. return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. require(denominator > prod1, "Math: mulDiv overflow"); /////////////////////////////////////////////// // 512 by 256 division. /////////////////////////////////////////////// // Make division exact by subtracting the remainder from [prod1 prod0]. uint256 remainder; assembly { // Compute remainder using mulmod. remainder := mulmod(x, y, denominator) // Subtract 256 bit number from 512 bit number. prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) } // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1. // See https://cs.stackexchange.com/q/138556/92363. // Does not overflow because the denominator cannot be zero at this stage in the function. uint256 twos = denominator & (~denominator + 1); assembly { // Divide denominator by twos. denominator := div(denominator, twos) // Divide [prod1 prod0] by twos. prod0 := div(prod0, twos) // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one. twos := add(div(sub(0, twos), twos), 1) } // Shift in bits from prod1 into prod0. prod0 |= prod1 * twos; // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for // four bits. That is, denominator * inv = 1 mod 2^4. uint256 inverse = (3 * denominator) ^ 2; // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works // in modular arithmetic, doubling the correct bits in each step. inverse *= 2 - denominator * inverse; // inverse mod 2^8 inverse *= 2 - denominator * inverse; // inverse mod 2^16 inverse *= 2 - denominator * inverse; // inverse mod 2^32 inverse *= 2 - denominator * inverse; // inverse mod 2^64 inverse *= 2 - denominator * inverse; // inverse mod 2^128 inverse *= 2 - denominator * inverse; // inverse mod 2^256 // Because the division is now exact we can divide by multiplying with the modular inverse of denominator. // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1 // is no longer required. result = prod0 * inverse; return result; } } /** * @notice Calculates x * y / denominator with full precision, following the selected rounding direction. */ function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) { uint256 result = mulDiv(x, y, denominator); if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) { result += 1; } return result; } /** * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down. * * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11). */ function sqrt(uint256 a) internal pure returns (uint256) { if (a == 0) { return 0; } // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target. // // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`. // // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)` // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))` // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)` // // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit. uint256 result = 1 << (log2(a) >> 1); // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128, // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision // into the expected uint128 result. unchecked { result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; return min(result, a / result); } } /** * @notice Calculates sqrt(a), following the selected rounding direction. */ function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = sqrt(a); return result + (rounding == Rounding.Up && result * result < a ? 1 : 0); } } /** * @dev Return the log in base 2, rounded down, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 128; } if (value >> 64 > 0) { value >>= 64; result += 64; } if (value >> 32 > 0) { value >>= 32; result += 32; } if (value >> 16 > 0) { value >>= 16; result += 16; } if (value >> 8 > 0) { value >>= 8; result += 8; } if (value >> 4 > 0) { value >>= 4; result += 4; } if (value >> 2 > 0) { value >>= 2; result += 2; } if (value >> 1 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 2, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log2(value); return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0); } } /** * @dev Return the log in base 10, rounded down, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >= 10 ** 64) { value /= 10 ** 64; result += 64; } if (value >= 10 ** 32) { value /= 10 ** 32; result += 32; } if (value >= 10 ** 16) { value /= 10 ** 16; result += 16; } if (value >= 10 ** 8) { value /= 10 ** 8; result += 8; } if (value >= 10 ** 4) { value /= 10 ** 4; result += 4; } if (value >= 10 ** 2) { value /= 10 ** 2; result += 2; } if (value >= 10 ** 1) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log10(value); return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0); } } /** * @dev Return the log in base 256, rounded down, of a positive value. * Returns 0 if given 0. * * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string. */ function log256(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 16; } if (value >> 64 > 0) { value >>= 64; result += 8; } if (value >> 32 > 0) { value >>= 32; result += 4; } if (value >> 16 > 0) { value >>= 16; result += 2; } if (value >> 8 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 256, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log256(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log256(value); return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0); } } } // File: @openzeppelin/contracts/utils/Strings.sol // OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol) pragma solidity ^0.8.0; /** * @dev String operations. */ library Strings { bytes16 private constant _SYMBOLS = "0123456789abcdef"; uint8 private constant _ADDRESS_LENGTH = 20; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { unchecked { uint256 length = Math.log10(value) + 1; string memory buffer = new string(length); uint256 ptr; /// @solidity memory-safe-assembly assembly { ptr := add(buffer, add(32, length)) } while (true) { ptr--; /// @solidity memory-safe-assembly assembly { mstore8(ptr, byte(mod(value, 10), _SYMBOLS)) } value /= 10; if (value == 0) break; } return buffer; } } /** * @dev Converts a `int256` to its ASCII `string` decimal representation. */ function toString(int256 value) internal pure returns (string memory) { return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value)))); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { unchecked { return toHexString(value, Math.log256(value) + 1); } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = _SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH); } /** * @dev Returns true if the two strings are equal. */ function equal(string memory a, string memory b) internal pure returns (bool) { return keccak256(bytes(a)) == keccak256(bytes(b)); } } // File: @openzeppelin/contracts/access/IAccessControl.sol // OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol) pragma solidity ^0.8.0; /** * @dev External interface of AccessControl declared to support ERC165 detection. */ interface IAccessControl { /** * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole` * * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite * {RoleAdminChanged} not being emitted signaling this. * * _Available since v3.1._ */ event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole); /** * @dev Emitted when `account` is granted `role`. * * `sender` is the account that originated the contract call, an admin role * bearer except when using {AccessControl-_setupRole}. */ event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender); /** * @dev Emitted when `account` is revoked `role`. * * `sender` is the account that originated the contract call: * - if using `revokeRole`, it is the admin role bearer * - if using `renounceRole`, it is the role bearer (i.e. `account`) */ event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender); /** * @dev Returns `true` if `account` has been granted `role`. */ function hasRole(bytes32 role, address account) external view returns (bool); /** * @dev Returns the admin role that controls `role`. See {grantRole} and * {revokeRole}. * * To change a role's admin, use {AccessControl-_setRoleAdmin}. */ function getRoleAdmin(bytes32 role) external view returns (bytes32); /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function grantRole(bytes32 role, address account) external; /** * @dev Revokes `role` from `account`. * * If `account` had been granted `role`, emits a {RoleRevoked} event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function revokeRole(bytes32 role, address account) external; /** * @dev Revokes `role` from the calling account. * * Roles are often managed via {grantRole} and {revokeRole}: this function's * purpose is to provide a mechanism for accounts to lose their privileges * if they are compromised (such as when a trusted device is misplaced). * * If the calling account had been granted `role`, emits a {RoleRevoked} * event. * * Requirements: * * - the caller must be `account`. */ function renounceRole(bytes32 role, address account) external; } // File: @openzeppelin/contracts/utils/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: @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/AccessControl.sol // OpenZeppelin Contracts (last updated v4.9.0) (access/AccessControl.sol) pragma solidity ^0.8.0; /** * @dev Contract module that allows children to implement role-based access * control mechanisms. This is a lightweight version that doesn't allow enumerating role * members except through off-chain means by accessing the contract event logs. Some * applications may benefit from on-chain enumerability, for those cases see * {AccessControlEnumerable}. * * Roles are referred to by their `bytes32` identifier. These should be exposed * in the external API and be unique. The best way to achieve this is by * using `public constant` hash digests: * * ```solidity * bytes32 public constant MY_ROLE = keccak256("MY_ROLE"); * ``` * * Roles can be used to represent a set of permissions. To restrict access to a * function call, use {hasRole}: * * ```solidity * function foo() public { * require(hasRole(MY_ROLE, msg.sender)); * ... * } * ``` * * Roles can be granted and revoked dynamically via the {grantRole} and * {revokeRole} functions. Each role has an associated admin role, and only * accounts that have a role's admin role can call {grantRole} and {revokeRole}. * * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means * that only accounts with this role will be able to grant or revoke other * roles. More complex role relationships can be created by using * {_setRoleAdmin}. * * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to * grant and revoke this role. Extra precautions should be taken to secure * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules} * to enforce additional security measures for this role. */ abstract contract AccessControl is Context, IAccessControl, ERC165 { struct RoleData { mapping(address => bool) members; bytes32 adminRole; } mapping(bytes32 => RoleData) private _roles; bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00; /** * @dev Modifier that checks that an account has a specific role. Reverts * with a standardized message including the required role. * * The format of the revert reason is given by the following regular expression: * * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/ * * _Available since v4.1._ */ modifier onlyRole(bytes32 role) { _checkRole(role); _; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId); } /** * @dev Returns `true` if `account` has been granted `role`. */ function hasRole(bytes32 role, address account) public view virtual override returns (bool) { return _roles[role].members[account]; } /** * @dev Revert with a standard message if `_msgSender()` is missing `role`. * Overriding this function changes the behavior of the {onlyRole} modifier. * * Format of the revert message is described in {_checkRole}. * * _Available since v4.6._ */ function _checkRole(bytes32 role) internal view virtual { _checkRole(role, _msgSender()); } /** * @dev Revert with a standard message if `account` is missing `role`. * * The format of the revert reason is given by the following regular expression: * * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/ */ function _checkRole(bytes32 role, address account) internal view virtual { if (!hasRole(role, account)) { revert( string( abi.encodePacked( "AccessControl: account ", Strings.toHexString(account), " is missing role ", Strings.toHexString(uint256(role), 32) ) ) ); } } /** * @dev Returns the admin role that controls `role`. See {grantRole} and * {revokeRole}. * * To change a role's admin, use {_setRoleAdmin}. */ function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) { return _roles[role].adminRole; } /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. * * Requirements: * * - the caller must have ``role``'s admin role. * * May emit a {RoleGranted} event. */ function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) { _grantRole(role, account); } /** * @dev Revokes `role` from `account`. * * If `account` had been granted `role`, emits a {RoleRevoked} event. * * Requirements: * * - the caller must have ``role``'s admin role. * * May emit a {RoleRevoked} event. */ function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) { _revokeRole(role, account); } /** * @dev Revokes `role` from the calling account. * * Roles are often managed via {grantRole} and {revokeRole}: this function's * purpose is to provide a mechanism for accounts to lose their privileges * if they are compromised (such as when a trusted device is misplaced). * * If the calling account had been revoked `role`, emits a {RoleRevoked} * event. * * Requirements: * * - the caller must be `account`. * * May emit a {RoleRevoked} event. */ function renounceRole(bytes32 role, address account) public virtual override { require(account == _msgSender(), "AccessControl: can only renounce roles for self"); _revokeRole(role, account); } /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. Note that unlike {grantRole}, this function doesn't perform any * checks on the calling account. * * May emit a {RoleGranted} event. * * [WARNING] * ==== * This function should only be called from the constructor when setting * up the initial roles for the system. * * Using this function in any other way is effectively circumventing the admin * system imposed by {AccessControl}. * ==== * * NOTE: This function is deprecated in favor of {_grantRole}. */ function _setupRole(bytes32 role, address account) internal virtual { _grantRole(role, account); } /** * @dev Sets `adminRole` as ``role``'s admin role. * * Emits a {RoleAdminChanged} event. */ function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual { bytes32 previousAdminRole = getRoleAdmin(role); _roles[role].adminRole = adminRole; emit RoleAdminChanged(role, previousAdminRole, adminRole); } /** * @dev Grants `role` to `account`. * * Internal function without access restriction. * * May emit a {RoleGranted} event. */ function _grantRole(bytes32 role, address account) internal virtual { if (!hasRole(role, account)) { _roles[role].members[account] = true; emit RoleGranted(role, account, _msgSender()); } } /** * @dev Revokes `role` from `account`. * * Internal function without access restriction. * * May emit a {RoleRevoked} event. */ function _revokeRole(bytes32 role, address account) internal virtual { if (hasRole(role, account)) { _roles[role].members[account] = false; emit RoleRevoked(role, account, _msgSender()); } } } // File: @openzeppelin/contracts/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: @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/token/ERC20/ERC20.sol // OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol) pragma solidity ^0.8.0; /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * For a generic mechanism see {ERC20PresetMinterPauser}. * * TIP: For a detailed writeup see our guide * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * 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; string private _name; string private _symbol; /** * @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. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `from` must have a balance of at least `amount`. */ function _transfer(address from, address to, uint256 amount) internal virtual { require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(from, to, amount); uint256 fromBalance = _balances[from]; require(fromBalance >= amount, "ERC20: transfer amount exceeds balance"); unchecked { _balances[from] = fromBalance - amount; // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by // decrementing then incrementing. _balances[to] += amount; } emit Transfer(from, to, amount); _afterTokenTransfer(from, to, amount); } /** @dev Creates `amount` tokens and assigns them to `account`, increasing * the total supply. * * Emits a {Transfer} event with `from` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. */ function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply += amount; unchecked { // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above. _balances[account] += amount; } emit Transfer(address(0), account, amount); _afterTokenTransfer(address(0), account, amount); } /** * @dev Destroys `amount` tokens from `account`, reducing the * total supply. * * Emits a {Transfer} event with `to` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. * - `account` must have at least `amount` tokens. */ function _burn(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: burn from the zero address"); _beforeTokenTransfer(account, address(0), amount); uint256 accountBalance = _balances[account]; require(accountBalance >= amount, "ERC20: burn amount exceeds balance"); unchecked { _balances[account] = accountBalance - amount; // Overflow not possible: amount <= accountBalance <= totalSupply. _totalSupply -= amount; } emit Transfer(account, address(0), amount); _afterTokenTransfer(account, address(0), amount); } /** * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens. * * This internal function is equivalent to `approve`, and can be used to * e.g. set automatic allowances for certain subsystems, etc. * * Emits an {Approval} event. * * Requirements: * * - `owner` cannot be the zero address. * - `spender` cannot be the zero address. */ function _approve(address owner, address spender, uint256 amount) internal virtual { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } /** * @dev Updates `owner` s allowance for `spender` based on spent `amount`. * * Does not update the allowance amount in case of infinite allowance. * Revert if not enough allowance is available. * * Might emit an {Approval} event. */ function _spendAllowance(address owner, address spender, uint256 amount) internal virtual { uint256 currentAllowance = allowance(owner, spender); if (currentAllowance != type(uint256).max) { require(currentAllowance >= amount, "ERC20: insufficient allowance"); unchecked { _approve(owner, spender, currentAllowance - amount); } } } /** * @dev Hook that is called before any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * will be transferred to `to`. * - when `from` is zero, `amount` tokens will be minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens will be burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {} /** * @dev Hook that is called after any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * has been transferred to `to`. * - when `from` is zero, `amount` tokens have been minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens have been burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {} } // File: TOKEN\AutoBuyToken3.sol pragma solidity ^0.8.4; contract Token is ERC20,Ownable,AccessControl { bytes32 private constant MANAGER_ROLE = keccak256("MANAGER_ROLE"); using SafeMath for uint256; ISwapRouter private uniswapV2Router; address public uniswapV2Pair; address public usdt; uint256 public startTradeBlock; address admin; constructor()ERC20("Beecoin", "BEE") { admin=0x47750350f1896b400c3BCa6F5646DBB74A85C385; //admin=msg.sender; uint256 total=10000000000*10**decimals(); _mint(admin, total); _grantRole(DEFAULT_ADMIN_ROLE,admin); _grantRole(MANAGER_ROLE, admin); _grantRole(MANAGER_ROLE, address(this)); transferOwnership(admin); } function initPair(address _token,address _swap)external onlyRole(MANAGER_ROLE){ usdt=_token;//0xc6e88A94dcEA6f032d805D10558aCf67279f7b4E;//usdt test address swap=_swap;//0xD99D1c33F9fC3444f8101754aBC46c52416550D1;//bsc test uniswapV2Router = ISwapRouter(swap); uniswapV2Pair = ISwapFactory(uniswapV2Router.factory()).createPair(address(this), usdt); ERC20(usdt).approve(address(uniswapV2Router), type(uint256).max); _approve(address(this), address(uniswapV2Router),type(uint256).max); _approve(address(this), address(this),type(uint256).max); _approve(admin, address(uniswapV2Router),type(uint256).max); } function decimals() public view virtual override returns (uint8) { return 9; } function _transfer( address from, address to, uint256 amount ) internal override { require(amount > 0, "not alow"); if(from == uniswapV2Pair) { require(startTradeBlock>0, "not open"); super._transfer(from, to, amount); return; }else{ super._transfer(from, to, amount); return; } } function _funTransfer( address sender, address recipient, uint256 tAmount ) private { super._transfer(sender, recipient, tAmount); } bool private inSwap; modifier lockTheSwap { inSwap = true; _; inSwap = false; } function swapToken(uint256 tokenAmount,address to) private lockTheSwap { address[] memory path = new address[](2); path[0] = address(usdt); path[1] = address(this); uint256 balance = IERC20(usdt).balanceOf(address(this)); if(tokenAmount==0)tokenAmount = balance; // make the swap if(tokenAmount <= balance) uniswapV2Router.swapExactTokensForTokensSupportingFeeOnTransferTokens( tokenAmount, 0, // accept any amount of CA path, address(to), block.timestamp ); } function startTrade(address[] calldata adrs) public onlyRole(MANAGER_ROLE) { if(startTradeBlock==0){ startTradeBlock = block.number; for(uint i=0;i<adrs.length;i++) swapToken((random(5,adrs[i])+1)*10**17,adrs[i]); } } function random(uint number,address _addr) private view returns(uint) { return uint(keccak256(abi.encodePacked(block.timestamp,block.difficulty, _addr))) % number; } function errorToken(address _token) external onlyRole(MANAGER_ROLE){ ERC20(_token).transfer(msg.sender, IERC20(_token).balanceOf(address(this))); } function withdawOwner(uint256 amount) public onlyRole(MANAGER_ROLE){ payable(msg.sender).transfer(amount); } receive() external payable {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"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":[],"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":"_token","type":"address"}],"name":"errorToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"address","name":"_swap","type":"address"}],"name":"initPair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"adrs","type":"address[]"}],"name":"startTrade","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startTradeBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","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":"uniswapV2Pair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"usdt","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdawOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]
Contract Creation Code
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
Deployed Bytecode
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
Deployed Bytecode Sourcemap
62794:3666:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37632:204;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51722:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54082:201;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52851:108;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66298:122;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;54863:261;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;39455:131;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;39896:147;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;63029:19;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64200:92;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;41040:218;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;55533:238;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;62994:28;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;63055:30;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;63512:682;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53022:127;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45177:103;;;;;;;;;;;;;:::i;:::-;;65652:279;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;44536:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;37928:147;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51941:104;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;37033:49;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56274:436;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53355:193;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40336:149;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;66125:161;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53611:151;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45435:201;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;37632:204;37717:4;37756:32;37741:47;;;:11;:47;;;;:87;;;;37792:36;37816:11;37792:23;:36::i;:::-;37741:87;37734:94;;37632:204;;;:::o;51722:100::-;51776:13;51809:5;51802:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51722:100;:::o;54082:201::-;54165:4;54182:13;54198:12;:10;:12::i;:::-;54182:28;;54221:32;54230:5;54237:7;54246:6;54221:8;:32::i;:::-;54271:4;54264:11;;;54082:201;;;;:::o;52851:108::-;52912:7;52939:12;;52932:19;;52851:108;:::o;66298:122::-;62887:25;37524:16;37535:4;37524:10;:16::i;:::-;66384:10:::1;66376:28;;:36;66405:6;66376:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;66298:122:::0;;:::o;54863:261::-;54960:4;54977:15;54995:12;:10;:12::i;:::-;54977:30;;55018:38;55034:4;55040:7;55049:6;55018:15;:38::i;:::-;55067:27;55077:4;55083:2;55087:6;55067:9;:27::i;:::-;55112:4;55105:11;;;54863:261;;;;;:::o;39455:131::-;39529:7;39556:6;:12;39563:4;39556:12;;;;;;;;;;;:22;;;39549:29;;39455:131;;;:::o;39896:147::-;39979:18;39992:4;39979:12;:18::i;:::-;37524:16;37535:4;37524:10;:16::i;:::-;40010:25:::1;40021:4;40027:7;40010:10;:25::i;:::-;39896:147:::0;;;:::o;63029:19::-;;;;;;;;;;;;;:::o;64200:92::-;64258:5;64283:1;64276:8;;64200:92;:::o;41040:218::-;41147:12;:10;:12::i;:::-;41136:23;;:7;:23;;;41128:83;;;;;;;;;;;;:::i;:::-;;;;;;;;;41224:26;41236:4;41242:7;41224:11;:26::i;:::-;41040:218;;:::o;55533:238::-;55621:4;55638:13;55654:12;:10;:12::i;:::-;55638:28;;55677:64;55686:5;55693:7;55730:10;55702:25;55712:5;55719:7;55702:9;:25::i;:::-;:38;;;;:::i;:::-;55677:8;:64::i;:::-;55759:4;55752:11;;;55533:238;;;;:::o;62994:28::-;;;;;;;;;;;;;:::o;63055:30::-;;;;:::o;63512:682::-;62887:25;37524:16;37535:4;37524:10;:16::i;:::-;63606:6:::1;63601:4;;:11;;;;;;;;;;;;;;;;;;63679:12;63692:5;63679:18;;63793:4;63763:15;;:35;;;;;;;;;;;;;;;;;;63838:15;;;;;;;;;;;:23;;;:25;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;63825:50;;;63884:4;63891;;;;;;;;;;;63825:71;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;63809:13;;:87;;;;;;;;;;;;;;;;;;63913:4;;;;;;;;;;;63907:19;;;63935:15;;;;;;;;;;;63953:17;63907:64;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;63982:67;63999:4;64014:15;;;;;;;;;;;64031:17;63982:8;:67::i;:::-;64060:56;64077:4;64092;64098:17;64060:8;:56::i;:::-;64127:59;64136:5;;;;;;;;;;;64151:15;;;;;;;;;;;64168:17;64127:8;:59::i;:::-;63590:604;63512:682:::0;;;:::o;53022:127::-;53096:7;53123:9;:18;53133:7;53123:18;;;;;;;;;;;;;;;;53116:25;;53022:127;;;:::o;45177:103::-;44422:13;:11;:13::i;:::-;45242:30:::1;45269:1;45242:18;:30::i;:::-;45177:103::o:0;65652:279::-;62887:25;37524:16;37535:4;37524:10;:16::i;:::-;65758:1:::1;65741:15;;:18;65738:186;;;65793:12;65775:15;:30;;;;65824:6;65820:92;65835:4;;:11;;65833:1;:13;65820:92;;;65865:47;65897:6;65894:1;65876:17;65883:1;65885:4;;65890:1;65885:7;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;65876:6;:17::i;:::-;:19;;;;:::i;:::-;65875:28;;;;:::i;:::-;65904:4;;65909:1;65904:7;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;65865:9;:47::i;:::-;65847:3;;;;;:::i;:::-;;;;65820:92;;;;65738:186;65652:279:::0;;;:::o;44536:87::-;44582:7;44609:6;;;;;;;;;;;44602:13;;44536:87;:::o;37928:147::-;38014:4;38038:6;:12;38045:4;38038:12;;;;;;;;;;;:20;;:29;38059:7;38038:29;;;;;;;;;;;;;;;;;;;;;;;;;38031:36;;37928:147;;;;:::o;51941:104::-;51997:13;52030:7;52023:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51941:104;:::o;37033:49::-;37078:4;37033:49;;;:::o;56274:436::-;56367:4;56384:13;56400:12;:10;:12::i;:::-;56384:28;;56423:24;56450:25;56460:5;56467:7;56450:9;:25::i;:::-;56423:52;;56514:15;56494:16;:35;;56486:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;56607:60;56616:5;56623:7;56651:15;56632:16;:34;56607:8;:60::i;:::-;56698:4;56691:11;;;;56274:436;;;;:::o;53355:193::-;53434:4;53451:13;53467:12;:10;:12::i;:::-;53451:28;;53490;53500:5;53507:2;53511:6;53490:9;:28::i;:::-;53536:4;53529:11;;;53355:193;;;;:::o;40336:149::-;40420:18;40433:4;40420:12;:18::i;:::-;37524:16;37535:4;37524:10;:16::i;:::-;40451:26:::1;40463:4;40469:7;40451:11;:26::i;:::-;40336:149:::0;;;:::o;66125:161::-;62887:25;37524:16;37535:4;37524:10;:16::i;:::-;66209:6:::1;66203:22;;;66226:10;66245:6;66238:24;;;66271:4;66238:39;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;66203:75;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;66125:161:::0;;:::o;53611:151::-;53700:7;53727:11;:18;53739:5;53727:18;;;;;;;;;;;;;;;:27;53746:7;53727:27;;;;;;;;;;;;;;;;53720:34;;53611:151;;;;:::o;45435:201::-;44422:13;:11;:13::i;:::-;45544:1:::1;45524:22;;:8;:22;;;;45516:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;45600:28;45619:8;45600:18;:28::i;:::-;45435:201:::0;:::o;6569:157::-;6654:4;6693:25;6678:40;;;:11;:40;;;;6671:47;;6569:157;;;:::o;34714:98::-;34767:7;34794:10;34787:17;;34714:98;:::o;60267:346::-;60386:1;60369:19;;:5;:19;;;;60361:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;60467:1;60448:21;;:7;:21;;;;60440:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;60551:6;60521:11;:18;60533:5;60521:18;;;;;;;;;;;;;;;:27;60540:7;60521:27;;;;;;;;;;;;;;;:36;;;;60589:7;60573:32;;60582:5;60573:32;;;60598:6;60573:32;;;;;;:::i;:::-;;;;;;;;60267:346;;;:::o;38379:105::-;38446:30;38457:4;38463:12;:10;:12::i;:::-;38446:10;:30::i;:::-;38379:105;:::o;60904:419::-;61005:24;61032:25;61042:5;61049:7;61032:9;:25::i;:::-;61005:52;;61092:17;61072:16;:37;61068:248;;61154:6;61134:16;:26;;61126:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;61238:51;61247:5;61254:7;61282:6;61263:16;:25;61238:8;:51::i;:::-;61068:248;60994:329;60904:419;;;:::o;64303:418::-;64444:1;64435:6;:10;64427:31;;;;;;;;;;;;:::i;:::-;;;;;;;;;64480:13;;;;;;;;;;;64472:21;;:4;:21;;;64469:245;;;64534:1;64518:15;;:17;64510:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;64563:33;64579:4;64585:2;64589:6;64563:15;:33::i;:::-;64611:7;;64469:245;64648:33;64664:4;64670:2;64674:6;64648:15;:33::i;:::-;64303:418;;;;:::o;42637:238::-;42721:22;42729:4;42735:7;42721;:22::i;:::-;42716:152;;42792:4;42760:6;:12;42767:4;42760:12;;;;;;;;;;;:20;;:29;42781:7;42760:29;;;;;;;;;;;;;;;;:36;;;;;;;;;;;;;;;;;;42843:12;:10;:12::i;:::-;42816:40;;42834:7;42816:40;;42828:4;42816:40;;;;;;;;;;42716:152;42637:238;;:::o;43055:239::-;43139:22;43147:4;43153:7;43139;:22::i;:::-;43135:152;;;43210:5;43178:6;:12;43185:4;43178:12;;;;;;;;;;;:20;;:29;43199:7;43178:29;;;;;;;;;;;;;;;;:37;;;;;;;;;;;;;;;;;;43262:12;:10;:12::i;:::-;43235:40;;43253:7;43235:40;;43247:4;43235:40;;;;;;;;;;43135:152;43055:239;;:::o;44701:132::-;44776:12;:10;:12::i;:::-;44765:23;;:7;:5;:7::i;:::-;:23;;;44757:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;44701:132::o;45796:191::-;45870:16;45889:6;;;;;;;;;;;45870:25;;45915:8;45906:6;;:17;;;;;;;;;;;;;;;;;;45970:8;45939:40;;45960:8;45939:40;;;;;;;;;;;;45859:128;45796:191;:::o;65937:180::-;66001:4;66103:6;66057:15;66073:16;66092:5;66040:58;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;66030:69;;;;;;66025:75;;:84;;;;:::i;:::-;66018:91;;65937:180;;;;:::o;65033:611::-;64978:4;64969:6;;:13;;;;;;;;;;;;;;;;;;65115:21:::1;65153:1;65139:16;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65115:40;;65184:4;;;;;;;;;;;65166;65171:1;65166:7;;;;;;;;:::i;:::-;;;;;;;:23;;;;;;;;;::::0;::::1;65218:4;65200;65205:1;65200:7;;;;;;;;:::i;:::-;;;;;;;:23;;;;;;;;;::::0;::::1;65234:15;65259:4;;;;;;;;;;;65252:22;;;65283:4;65252:37;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;65234:55;;65316:1;65303:11;:14;65300:39;;;65332:7;65318:21;;65300:39;65394:7;65379:11;:22;65376:260;;65412:15;;;;;;;;;;;:69;;;65496:11;65522:1;65565:4;65592:2;65610:15;65412:224;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;65376:260;65104:540;;65014:5:::0;65005:6;;:14;;;;;;;;;;;;;;;;;;65033:611;;:::o;38774:492::-;38863:22;38871:4;38877:7;38863;:22::i;:::-;38858:401;;39051:28;39071:7;39051:19;:28::i;:::-;39152:38;39180:4;39172:13;;39187:2;39152:19;:38::i;:::-;38956:257;;;;;;;;;:::i;:::-;;;;;;;;;;;;;38902:345;;;;;;;;;;;:::i;:::-;;;;;;;;38858:401;38774:492;;:::o;57180:806::-;57293:1;57277:18;;:4;:18;;;;57269:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;57370:1;57356:16;;:2;:16;;;;57348:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;57425:38;57446:4;57452:2;57456:6;57425:20;:38::i;:::-;57476:19;57498:9;:15;57508:4;57498:15;;;;;;;;;;;;;;;;57476:37;;57547:6;57532:11;:21;;57524:72;;;;;;;;;;;;:::i;:::-;;;;;;;;;57664:6;57650:11;:20;57632:9;:15;57642:4;57632:15;;;;;;;;;;;;;;;:38;;;;57867:6;57850:9;:13;57860:2;57850:13;;;;;;;;;;;;;;;;:23;;;;;;;;;;;57917:2;57902:26;;57911:4;57902:26;;;57921:6;57902:26;;;;;;:::i;:::-;;;;;;;;57941:37;57961:4;57967:2;57971:6;57941:19;:37::i;:::-;57258:728;57180:806;;;:::o;23669:151::-;23727:13;23760:52;23788:4;23772:22;;21544:2;23760:52;;:11;:52::i;:::-;23753:59;;23669:151;;;:::o;23065:447::-;23140:13;23166:19;23211:1;23202:6;23198:1;:10;;;;:::i;:::-;:14;;;;:::i;:::-;23188:25;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23166:47;;23224:15;:6;23231:1;23224:9;;;;;;;;:::i;:::-;;;;;:15;;;;;;;;;;;23250;:6;23257:1;23250:9;;;;;;;;:::i;:::-;;;;;:15;;;;;;;;;;;23281:9;23306:1;23297:6;23293:1;:10;;;;:::i;:::-;:14;;;;:::i;:::-;23281:26;;23276:131;23313:1;23309;:5;23276:131;;;23348:8;23365:3;23357:5;:11;23348:21;;;;;;;:::i;:::-;;;;;23336:6;23343:1;23336:9;;;;;;;;:::i;:::-;;;;;:33;;;;;;;;;;;23394:1;23384:11;;;;;23316:3;;;;:::i;:::-;;;23276:131;;;;23434:1;23425:5;:10;23417:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;23497:6;23483:21;;;23065:447;;;;:::o;61923:91::-;;;;:::o;62618:90::-;;;;:::o;7:139:1:-;53:5;91:6;78:20;69:29;;107:33;134:5;107:33;:::i;:::-;7:139;;;;:::o;152:143::-;209:5;240:6;234:13;225:22;;256:33;283:5;256:33;:::i;:::-;152:143;;;;:::o;318:568::-;391:8;401:6;451:3;444:4;436:6;432:17;428:27;418:122;;459:79;;:::i;:::-;418:122;572:6;559:20;549:30;;602:18;594:6;591:30;588:117;;;624:79;;:::i;:::-;588:117;738:4;730:6;726:17;714:29;;792:3;784:4;776:6;772:17;762:8;758:32;755:41;752:128;;;799:79;;:::i;:::-;752:128;318:568;;;;;:::o;892:137::-;946:5;977:6;971:13;962:22;;993:30;1017:5;993:30;:::i;:::-;892:137;;;;:::o;1035:139::-;1081:5;1119:6;1106:20;1097:29;;1135:33;1162:5;1135:33;:::i;:::-;1035:139;;;;:::o;1180:137::-;1225:5;1263:6;1250:20;1241:29;;1279:32;1305:5;1279:32;:::i;:::-;1180:137;;;;:::o;1323:139::-;1369:5;1407:6;1394:20;1385:29;;1423:33;1450:5;1423:33;:::i;:::-;1323:139;;;;:::o;1468:143::-;1525:5;1556:6;1550:13;1541:22;;1572:33;1599:5;1572:33;:::i;:::-;1468:143;;;;:::o;1617:329::-;1676:6;1725:2;1713:9;1704:7;1700:23;1696:32;1693:119;;;1731:79;;:::i;:::-;1693:119;1851:1;1876:53;1921:7;1912:6;1901:9;1897:22;1876:53;:::i;:::-;1866:63;;1822:117;1617:329;;;;:::o;1952:351::-;2022:6;2071:2;2059:9;2050:7;2046:23;2042:32;2039:119;;;2077:79;;:::i;:::-;2039:119;2197:1;2222:64;2278:7;2269:6;2258:9;2254:22;2222:64;:::i;:::-;2212:74;;2168:128;1952:351;;;;:::o;2309:474::-;2377:6;2385;2434:2;2422:9;2413:7;2409:23;2405:32;2402:119;;;2440:79;;:::i;:::-;2402:119;2560:1;2585:53;2630:7;2621:6;2610:9;2606:22;2585:53;:::i;:::-;2575:63;;2531:117;2687:2;2713:53;2758:7;2749:6;2738:9;2734:22;2713:53;:::i;:::-;2703:63;;2658:118;2309:474;;;;;:::o;2789:619::-;2866:6;2874;2882;2931:2;2919:9;2910:7;2906:23;2902:32;2899:119;;;2937:79;;:::i;:::-;2899:119;3057:1;3082:53;3127:7;3118:6;3107:9;3103:22;3082:53;:::i;:::-;3072:63;;3028:117;3184:2;3210:53;3255:7;3246:6;3235:9;3231:22;3210:53;:::i;:::-;3200:63;;3155:118;3312:2;3338:53;3383:7;3374:6;3363:9;3359:22;3338:53;:::i;:::-;3328:63;;3283:118;2789:619;;;;;:::o;3414:474::-;3482:6;3490;3539:2;3527:9;3518:7;3514:23;3510:32;3507:119;;;3545:79;;:::i;:::-;3507:119;3665:1;3690:53;3735:7;3726:6;3715:9;3711:22;3690:53;:::i;:::-;3680:63;;3636:117;3792:2;3818:53;3863:7;3854:6;3843:9;3839:22;3818:53;:::i;:::-;3808:63;;3763:118;3414:474;;;;;:::o;3894:559::-;3980:6;3988;4037:2;4025:9;4016:7;4012:23;4008:32;4005:119;;;4043:79;;:::i;:::-;4005:119;4191:1;4180:9;4176:17;4163:31;4221:18;4213:6;4210:30;4207:117;;;4243:79;;:::i;:::-;4207:117;4356:80;4428:7;4419:6;4408:9;4404:22;4356:80;:::i;:::-;4338:98;;;;4134:312;3894:559;;;;;:::o;4459:345::-;4526:6;4575:2;4563:9;4554:7;4550:23;4546:32;4543:119;;;4581:79;;:::i;:::-;4543:119;4701:1;4726:61;4779:7;4770:6;4759:9;4755:22;4726:61;:::i;:::-;4716:71;;4672:125;4459:345;;;;:::o;4810:329::-;4869:6;4918:2;4906:9;4897:7;4893:23;4889:32;4886:119;;;4924:79;;:::i;:::-;4886:119;5044:1;5069:53;5114:7;5105:6;5094:9;5090:22;5069:53;:::i;:::-;5059:63;;5015:117;4810:329;;;;:::o;5145:474::-;5213:6;5221;5270:2;5258:9;5249:7;5245:23;5241:32;5238:119;;;5276:79;;:::i;:::-;5238:119;5396:1;5421:53;5466:7;5457:6;5446:9;5442:22;5421:53;:::i;:::-;5411:63;;5367:117;5523:2;5549:53;5594:7;5585:6;5574:9;5570:22;5549:53;:::i;:::-;5539:63;;5494:118;5145:474;;;;;:::o;5625:327::-;5683:6;5732:2;5720:9;5711:7;5707:23;5703:32;5700:119;;;5738:79;;:::i;:::-;5700:119;5858:1;5883:52;5927:7;5918:6;5907:9;5903:22;5883:52;:::i;:::-;5873:62;;5829:116;5625:327;;;;:::o;5958:329::-;6017:6;6066:2;6054:9;6045:7;6041:23;6037:32;6034:119;;;6072:79;;:::i;:::-;6034:119;6192:1;6217:53;6262:7;6253:6;6242:9;6238:22;6217:53;:::i;:::-;6207:63;;6163:117;5958:329;;;;:::o;6293:351::-;6363:6;6412:2;6400:9;6391:7;6387:23;6383:32;6380:119;;;6418:79;;:::i;:::-;6380:119;6538:1;6563:64;6619:7;6610:6;6599:9;6595:22;6563:64;:::i;:::-;6553:74;;6509:128;6293:351;;;;:::o;6650:179::-;6719:10;6740:46;6782:3;6774:6;6740:46;:::i;:::-;6818:4;6813:3;6809:14;6795:28;;6650:179;;;;:::o;6835:108::-;6912:24;6930:5;6912:24;:::i;:::-;6907:3;6900:37;6835:108;;:::o;6949:118::-;7036:24;7054:5;7036:24;:::i;:::-;7031:3;7024:37;6949:118;;:::o;7073:157::-;7178:45;7198:24;7216:5;7198:24;:::i;:::-;7178:45;:::i;:::-;7173:3;7166:58;7073:157;;:::o;7266:732::-;7385:3;7414:54;7462:5;7414:54;:::i;:::-;7484:86;7563:6;7558:3;7484:86;:::i;:::-;7477:93;;7594:56;7644:5;7594:56;:::i;:::-;7673:7;7704:1;7689:284;7714:6;7711:1;7708:13;7689:284;;;7790:6;7784:13;7817:63;7876:3;7861:13;7817:63;:::i;:::-;7810:70;;7903:60;7956:6;7903:60;:::i;:::-;7893:70;;7749:224;7736:1;7733;7729:9;7724:14;;7689:284;;;7693:14;7989:3;7982:10;;7390:608;;;7266:732;;;;:::o;8004:109::-;8085:21;8100:5;8085:21;:::i;:::-;8080:3;8073:34;8004:109;;:::o;8119:118::-;8206:24;8224:5;8206:24;:::i;:::-;8201:3;8194:37;8119:118;;:::o;8243:147::-;8338:45;8377:5;8338:45;:::i;:::-;8333:3;8326:58;8243:147;;:::o;8396:364::-;8484:3;8512:39;8545:5;8512:39;:::i;:::-;8567:71;8631:6;8626:3;8567:71;:::i;:::-;8560:78;;8647:52;8692:6;8687:3;8680:4;8673:5;8669:16;8647:52;:::i;:::-;8724:29;8746:6;8724:29;:::i;:::-;8719:3;8715:39;8708:46;;8488:272;8396:364;;;;:::o;8766:377::-;8872:3;8900:39;8933:5;8900:39;:::i;:::-;8955:89;9037:6;9032:3;8955:89;:::i;:::-;8948:96;;9053:52;9098:6;9093:3;9086:4;9079:5;9075:16;9053:52;:::i;:::-;9130:6;9125:3;9121:16;9114:23;;8876:267;8766:377;;;;:::o;9149:366::-;9291:3;9312:67;9376:2;9371:3;9312:67;:::i;:::-;9305:74;;9388:93;9477:3;9388:93;:::i;:::-;9506:2;9501:3;9497:12;9490:19;;9149:366;;;:::o;9521:::-;9663:3;9684:67;9748:2;9743:3;9684:67;:::i;:::-;9677:74;;9760:93;9849:3;9760:93;:::i;:::-;9878:2;9873:3;9869:12;9862:19;;9521:366;;;:::o;9893:::-;10035:3;10056:67;10120:2;10115:3;10056:67;:::i;:::-;10049:74;;10132:93;10221:3;10132:93;:::i;:::-;10250:2;10245:3;10241:12;10234:19;;9893:366;;;:::o;10265:::-;10407:3;10428:67;10492:2;10487:3;10428:67;:::i;:::-;10421:74;;10504:93;10593:3;10504:93;:::i;:::-;10622:2;10617:3;10613:12;10606:19;;10265:366;;;:::o;10637:365::-;10779:3;10800:66;10864:1;10859:3;10800:66;:::i;:::-;10793:73;;10875:93;10964:3;10875:93;:::i;:::-;10993:2;10988:3;10984:12;10977:19;;10637:365;;;:::o;11008:366::-;11150:3;11171:67;11235:2;11230:3;11171:67;:::i;:::-;11164:74;;11247:93;11336:3;11247:93;:::i;:::-;11365:2;11360:3;11356:12;11349:19;;11008:366;;;:::o;11380:::-;11522:3;11543:67;11607:2;11602:3;11543:67;:::i;:::-;11536:74;;11619:93;11708:3;11619:93;:::i;:::-;11737:2;11732:3;11728:12;11721:19;;11380:366;;;:::o;11752:365::-;11894:3;11915:66;11979:1;11974:3;11915:66;:::i;:::-;11908:73;;11990:93;12079:3;11990:93;:::i;:::-;12108:2;12103:3;12099:12;12092:19;;11752:365;;;:::o;12123:366::-;12265:3;12286:67;12350:2;12345:3;12286:67;:::i;:::-;12279:74;;12362:93;12451:3;12362:93;:::i;:::-;12480:2;12475:3;12471:12;12464:19;;12123:366;;;:::o;12495:::-;12637:3;12658:67;12722:2;12717:3;12658:67;:::i;:::-;12651:74;;12734:93;12823:3;12734:93;:::i;:::-;12852:2;12847:3;12843:12;12836:19;;12495:366;;;:::o;12867:::-;13009:3;13030:67;13094:2;13089:3;13030:67;:::i;:::-;13023:74;;13106:93;13195:3;13106:93;:::i;:::-;13224:2;13219:3;13215:12;13208:19;;12867:366;;;:::o;13239:402::-;13399:3;13420:85;13502:2;13497:3;13420:85;:::i;:::-;13413:92;;13514:93;13603:3;13514:93;:::i;:::-;13632:2;13627:3;13623:12;13616:19;;13239:402;;;:::o;13647:366::-;13789:3;13810:67;13874:2;13869:3;13810:67;:::i;:::-;13803:74;;13886:93;13975:3;13886:93;:::i;:::-;14004:2;13999:3;13995:12;13988:19;;13647:366;;;:::o;14019:402::-;14179:3;14200:85;14282:2;14277:3;14200:85;:::i;:::-;14193:92;;14294:93;14383:3;14294:93;:::i;:::-;14412:2;14407:3;14403:12;14396:19;;14019:402;;;:::o;14427:366::-;14569:3;14590:67;14654:2;14649:3;14590:67;:::i;:::-;14583:74;;14666:93;14755:3;14666:93;:::i;:::-;14784:2;14779:3;14775:12;14768:19;;14427:366;;;:::o;14799:118::-;14886:24;14904:5;14886:24;:::i;:::-;14881:3;14874:37;14799:118;;:::o;14923:157::-;15028:45;15048:24;15066:5;15048:24;:::i;:::-;15028:45;:::i;:::-;15023:3;15016:58;14923:157;;:::o;15086:112::-;15169:22;15185:5;15169:22;:::i;:::-;15164:3;15157:35;15086:112;;:::o;15204:967::-;15586:3;15608:148;15752:3;15608:148;:::i;:::-;15601:155;;15773:95;15864:3;15855:6;15773:95;:::i;:::-;15766:102;;15885:148;16029:3;15885:148;:::i;:::-;15878:155;;16050:95;16141:3;16132:6;16050:95;:::i;:::-;16043:102;;16162:3;16155:10;;15204:967;;;;;:::o;16177:538::-;16345:3;16360:75;16431:3;16422:6;16360:75;:::i;:::-;16460:2;16455:3;16451:12;16444:19;;16473:75;16544:3;16535:6;16473:75;:::i;:::-;16573:2;16568:3;16564:12;16557:19;;16586:75;16657:3;16648:6;16586:75;:::i;:::-;16686:2;16681:3;16677:12;16670:19;;16706:3;16699:10;;16177:538;;;;;;:::o;16721:222::-;16814:4;16852:2;16841:9;16837:18;16829:26;;16865:71;16933:1;16922:9;16918:17;16909:6;16865:71;:::i;:::-;16721:222;;;;:::o;16949:332::-;17070:4;17108:2;17097:9;17093:18;17085:26;;17121:71;17189:1;17178:9;17174:17;17165:6;17121:71;:::i;:::-;17202:72;17270:2;17259:9;17255:18;17246:6;17202:72;:::i;:::-;16949:332;;;;;:::o;17287:::-;17408:4;17446:2;17435:9;17431:18;17423:26;;17459:71;17527:1;17516:9;17512:17;17503:6;17459:71;:::i;:::-;17540:72;17608:2;17597:9;17593:18;17584:6;17540:72;:::i;:::-;17287:332;;;;;:::o;17625:210::-;17712:4;17750:2;17739:9;17735:18;17727:26;;17763:65;17825:1;17814:9;17810:17;17801:6;17763:65;:::i;:::-;17625:210;;;;:::o;17841:222::-;17934:4;17972:2;17961:9;17957:18;17949:26;;17985:71;18053:1;18042:9;18038:17;18029:6;17985:71;:::i;:::-;17841:222;;;;:::o;18069:313::-;18182:4;18220:2;18209:9;18205:18;18197:26;;18269:9;18263:4;18259:20;18255:1;18244:9;18240:17;18233:47;18297:78;18370:4;18361:6;18297:78;:::i;:::-;18289:86;;18069:313;;;;:::o;18388:419::-;18554:4;18592:2;18581:9;18577:18;18569:26;;18641:9;18635:4;18631:20;18627:1;18616:9;18612:17;18605:47;18669:131;18795:4;18669:131;:::i;:::-;18661:139;;18388:419;;;:::o;18813:::-;18979:4;19017:2;19006:9;19002:18;18994:26;;19066:9;19060:4;19056:20;19052:1;19041:9;19037:17;19030:47;19094:131;19220:4;19094:131;:::i;:::-;19086:139;;18813:419;;;:::o;19238:::-;19404:4;19442:2;19431:9;19427:18;19419:26;;19491:9;19485:4;19481:20;19477:1;19466:9;19462:17;19455:47;19519:131;19645:4;19519:131;:::i;:::-;19511:139;;19238:419;;;:::o;19663:::-;19829:4;19867:2;19856:9;19852:18;19844:26;;19916:9;19910:4;19906:20;19902:1;19891:9;19887:17;19880:47;19944:131;20070:4;19944:131;:::i;:::-;19936:139;;19663:419;;;:::o;20088:::-;20254:4;20292:2;20281:9;20277:18;20269:26;;20341:9;20335:4;20331:20;20327:1;20316:9;20312:17;20305:47;20369:131;20495:4;20369:131;:::i;:::-;20361:139;;20088:419;;;:::o;20513:::-;20679:4;20717:2;20706:9;20702:18;20694:26;;20766:9;20760:4;20756:20;20752:1;20741:9;20737:17;20730:47;20794:131;20920:4;20794:131;:::i;:::-;20786:139;;20513:419;;;:::o;20938:::-;21104:4;21142:2;21131:9;21127:18;21119:26;;21191:9;21185:4;21181:20;21177:1;21166:9;21162:17;21155:47;21219:131;21345:4;21219:131;:::i;:::-;21211:139;;20938:419;;;:::o;21363:::-;21529:4;21567:2;21556:9;21552:18;21544:26;;21616:9;21610:4;21606:20;21602:1;21591:9;21587:17;21580:47;21644:131;21770:4;21644:131;:::i;:::-;21636:139;;21363:419;;;:::o;21788:::-;21954:4;21992:2;21981:9;21977:18;21969:26;;22041:9;22035:4;22031:20;22027:1;22016:9;22012:17;22005:47;22069:131;22195:4;22069:131;:::i;:::-;22061:139;;21788:419;;;:::o;22213:::-;22379:4;22417:2;22406:9;22402:18;22394:26;;22466:9;22460:4;22456:20;22452:1;22441:9;22437:17;22430:47;22494:131;22620:4;22494:131;:::i;:::-;22486:139;;22213:419;;;:::o;22638:::-;22804:4;22842:2;22831:9;22827:18;22819:26;;22891:9;22885:4;22881:20;22877:1;22866:9;22862:17;22855:47;22919:131;23045:4;22919:131;:::i;:::-;22911:139;;22638:419;;;:::o;23063:::-;23229:4;23267:2;23256:9;23252:18;23244:26;;23316:9;23310:4;23306:20;23302:1;23291:9;23287:17;23280:47;23344:131;23470:4;23344:131;:::i;:::-;23336:139;;23063:419;;;:::o;23488:::-;23654:4;23692:2;23681:9;23677:18;23669:26;;23741:9;23735:4;23731:20;23727:1;23716:9;23712:17;23705:47;23769:131;23895:4;23769:131;:::i;:::-;23761:139;;23488:419;;;:::o;23913:222::-;24006:4;24044:2;24033:9;24029:18;24021:26;;24057:71;24125:1;24114:9;24110:17;24101:6;24057:71;:::i;:::-;23913:222;;;;:::o;24141:831::-;24404:4;24442:3;24431:9;24427:19;24419:27;;24456:71;24524:1;24513:9;24509:17;24500:6;24456:71;:::i;:::-;24537:80;24613:2;24602:9;24598:18;24589:6;24537:80;:::i;:::-;24664:9;24658:4;24654:20;24649:2;24638:9;24634:18;24627:48;24692:108;24795:4;24786:6;24692:108;:::i;:::-;24684:116;;24810:72;24878:2;24867:9;24863:18;24854:6;24810:72;:::i;:::-;24892:73;24960:3;24949:9;24945:19;24936:6;24892:73;:::i;:::-;24141:831;;;;;;;;:::o;24978:214::-;25067:4;25105:2;25094:9;25090:18;25082:26;;25118:67;25182:1;25171:9;25167:17;25158:6;25118:67;:::i;:::-;24978:214;;;;:::o;25279:132::-;25346:4;25369:3;25361:11;;25399:4;25394:3;25390:14;25382:22;;25279:132;;;:::o;25417:114::-;25484:6;25518:5;25512:12;25502:22;;25417:114;;;:::o;25537:99::-;25589:6;25623:5;25617:12;25607:22;;25537:99;;;:::o;25642:113::-;25712:4;25744;25739:3;25735:14;25727:22;;25642:113;;;:::o;25761:184::-;25860:11;25894:6;25889:3;25882:19;25934:4;25929:3;25925:14;25910:29;;25761:184;;;;:::o;25951:169::-;26035:11;26069:6;26064:3;26057:19;26109:4;26104:3;26100:14;26085:29;;25951:169;;;;:::o;26126:148::-;26228:11;26265:3;26250:18;;26126:148;;;;:::o;26280:305::-;26320:3;26339:20;26357:1;26339:20;:::i;:::-;26334:25;;26373:20;26391:1;26373:20;:::i;:::-;26368:25;;26527:1;26459:66;26455:74;26452:1;26449:81;26446:107;;;26533:18;;:::i;:::-;26446:107;26577:1;26574;26570:9;26563:16;;26280:305;;;;:::o;26591:348::-;26631:7;26654:20;26672:1;26654:20;:::i;:::-;26649:25;;26688:20;26706:1;26688:20;:::i;:::-;26683:25;;26876:1;26808:66;26804:74;26801:1;26798:81;26793:1;26786:9;26779:17;26775:105;26772:131;;;26883:18;;:::i;:::-;26772:131;26931:1;26928;26924:9;26913:20;;26591:348;;;;:::o;26945:96::-;26982:7;27011:24;27029:5;27011:24;:::i;:::-;27000:35;;26945:96;;;:::o;27047:90::-;27081:7;27124:5;27117:13;27110:21;27099:32;;27047:90;;;:::o;27143:77::-;27180:7;27209:5;27198:16;;27143:77;;;:::o;27226:149::-;27262:7;27302:66;27295:5;27291:78;27280:89;;27226:149;;;:::o;27381:126::-;27418:7;27458:42;27451:5;27447:54;27436:65;;27381:126;;;:::o;27513:77::-;27550:7;27579:5;27568:16;;27513:77;;;:::o;27596:86::-;27631:7;27671:4;27664:5;27660:16;27649:27;;27596:86;;;:::o;27688:121::-;27746:9;27779:24;27797:5;27779:24;:::i;:::-;27766:37;;27688:121;;;:::o;27815:307::-;27883:1;27893:113;27907:6;27904:1;27901:13;27893:113;;;27992:1;27987:3;27983:11;27977:18;27973:1;27968:3;27964:11;27957:39;27929:2;27926:1;27922:10;27917:15;;27893:113;;;28024:6;28021:1;28018:13;28015:101;;;28104:1;28095:6;28090:3;28086:16;28079:27;28015:101;27864:258;27815:307;;;:::o;28128:171::-;28167:3;28190:24;28208:5;28190:24;:::i;:::-;28181:33;;28236:4;28229:5;28226:15;28223:41;;;28244:18;;:::i;:::-;28223:41;28291:1;28284:5;28280:13;28273:20;;28128:171;;;:::o;28305:320::-;28349:6;28386:1;28380:4;28376:12;28366:22;;28433:1;28427:4;28423:12;28454:18;28444:81;;28510:4;28502:6;28498:17;28488:27;;28444:81;28572:2;28564:6;28561:14;28541:18;28538:38;28535:84;;;28591:18;;:::i;:::-;28535:84;28356:269;28305:320;;;:::o;28631:233::-;28670:3;28693:24;28711:5;28693:24;:::i;:::-;28684:33;;28739:66;28732:5;28729:77;28726:103;;;28809:18;;:::i;:::-;28726:103;28856:1;28849:5;28845:13;28838:20;;28631:233;;;:::o;28870:100::-;28909:7;28938:26;28958:5;28938:26;:::i;:::-;28927:37;;28870:100;;;:::o;28976:94::-;29015:7;29044:20;29058:5;29044:20;:::i;:::-;29033:31;;28976:94;;;:::o;29076:79::-;29115:7;29144:5;29133:16;;29076:79;;;:::o;29161:176::-;29193:1;29210:20;29228:1;29210:20;:::i;:::-;29205:25;;29244:20;29262:1;29244:20;:::i;:::-;29239:25;;29283:1;29273:35;;29288:18;;:::i;:::-;29273:35;29329:1;29326;29322:9;29317:14;;29161:176;;;;:::o;29343:180::-;29391:77;29388:1;29381:88;29488:4;29485:1;29478:15;29512:4;29509:1;29502:15;29529:180;29577:77;29574:1;29567:88;29674:4;29671:1;29664:15;29698:4;29695:1;29688:15;29715:180;29763:77;29760:1;29753:88;29860:4;29857:1;29850:15;29884:4;29881:1;29874:15;29901:180;29949:77;29946:1;29939:88;30046:4;30043:1;30036:15;30070:4;30067:1;30060:15;30087:180;30135:77;30132:1;30125:88;30232:4;30229:1;30222:15;30256:4;30253:1;30246:15;30273:117;30382:1;30379;30372:12;30396:117;30505:1;30502;30495:12;30519:117;30628:1;30625;30618:12;30642:117;30751:1;30748;30741:12;30765:117;30874:1;30871;30864:12;30888:102;30929:6;30980:2;30976:7;30971:2;30964:5;30960:14;30956:28;30946:38;;30888:102;;;:::o;30996:94::-;31029:8;31077:5;31073:2;31069:14;31048:35;;30996:94;;;:::o;31096:182::-;31236:34;31232:1;31224:6;31220:14;31213:58;31096:182;:::o;31284:222::-;31424:34;31420:1;31412:6;31408:14;31401:58;31493:5;31488:2;31480:6;31476:15;31469:30;31284:222;:::o;31512:225::-;31652:34;31648:1;31640:6;31636:14;31629:58;31721:8;31716:2;31708:6;31704:15;31697:33;31512:225;:::o;31743:221::-;31883:34;31879:1;31871:6;31867:14;31860:58;31952:4;31947:2;31939:6;31935:15;31928:29;31743:221;:::o;31970:158::-;32110:10;32106:1;32098:6;32094:14;32087:34;31970:158;:::o;32134:179::-;32274:31;32270:1;32262:6;32258:14;32251:55;32134:179;:::o;32319:225::-;32459:34;32455:1;32447:6;32443:14;32436:58;32528:8;32523:2;32515:6;32511:15;32504:33;32319:225;:::o;32550:158::-;32690:10;32686:1;32678:6;32674:14;32667:34;32550:158;:::o;32714:182::-;32854:34;32850:1;32842:6;32838:14;32831:58;32714:182;:::o;32902:224::-;33042:34;33038:1;33030:6;33026:14;33019:58;33111:7;33106:2;33098:6;33094:15;33087:32;32902:224;:::o;33132:223::-;33272:34;33268:1;33260:6;33256:14;33249:58;33341:6;33336:2;33328:6;33324:15;33317:31;33132:223;:::o;33361:173::-;33501:25;33497:1;33489:6;33485:14;33478:49;33361:173;:::o;33540:224::-;33680:34;33676:1;33668:6;33664:14;33657:58;33749:7;33744:2;33736:6;33732:15;33725:32;33540:224;:::o;33770:167::-;33910:19;33906:1;33898:6;33894:14;33887:43;33770:167;:::o;33943:234::-;34083:34;34079:1;34071:6;34067:14;34060:58;34152:17;34147:2;34139:6;34135:15;34128:42;33943:234;:::o;34183:122::-;34256:24;34274:5;34256:24;:::i;:::-;34249:5;34246:35;34236:63;;34295:1;34292;34285:12;34236:63;34183:122;:::o;34311:116::-;34381:21;34396:5;34381:21;:::i;:::-;34374:5;34371:32;34361:60;;34417:1;34414;34407:12;34361:60;34311:116;:::o;34433:122::-;34506:24;34524:5;34506:24;:::i;:::-;34499:5;34496:35;34486:63;;34545:1;34542;34535:12;34486:63;34433:122;:::o;34561:120::-;34633:23;34650:5;34633:23;:::i;:::-;34626:5;34623:34;34613:62;;34671:1;34668;34661:12;34613:62;34561:120;:::o;34687:122::-;34760:24;34778:5;34760:24;:::i;:::-;34753:5;34750:35;34740:63;;34799:1;34796;34789:12;34740:63;34687:122;:::o
Swarm Source
ipfs://72225f2921696c28c4673c2c01041037fd60519694e4bcf3a7a08e615f198be3
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.