ERC-20
Overview
Max Total Supply
1,200,000,000 BOP
Holders
68
Market
Price
$0.00 @ 0.000000 MATIC
Onchain Market Cap
$0.00
Circulating Supply Market Cap
-
Other Info
Token Contract (WITH 18 Decimals)
Loading...
Loading
Loading...
Loading
Loading...
Loading
Contract Name:
BopToken
Compiler Version
v0.8.7+commit.e28d00a7
Contract Source Code (Solidity)
/** *Submitted for verification at polygonscan.com on 2022-11-09 */ // SPDX-License-Identifier: MIT // File: @openzeppelin/contracts/utils/math/SafeCast.sol // OpenZeppelin Contracts (last updated v4.7.0) (utils/math/SafeCast.sol) pragma solidity ^0.8.0; /** * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow * checks. * * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can * easily result in undesired exploitation or bugs, since developers usually * assume that overflows raise errors. `SafeCast` restores this intuition by * reverting the transaction when such an operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. * * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing * all math on `uint256` and `int256` and then downcasting. */ library SafeCast { /** * @dev Returns the downcasted uint248 from uint256, reverting on * overflow (when the input is greater than largest uint248). * * Counterpart to Solidity's `uint248` operator. * * Requirements: * * - input must fit into 248 bits * * _Available since v4.7._ */ function toUint248(uint256 value) internal pure returns (uint248) { require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits"); return uint248(value); } /** * @dev Returns the downcasted uint240 from uint256, reverting on * overflow (when the input is greater than largest uint240). * * Counterpart to Solidity's `uint240` operator. * * Requirements: * * - input must fit into 240 bits * * _Available since v4.7._ */ function toUint240(uint256 value) internal pure returns (uint240) { require(value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits"); return uint240(value); } /** * @dev Returns the downcasted uint232 from uint256, reverting on * overflow (when the input is greater than largest uint232). * * Counterpart to Solidity's `uint232` operator. * * Requirements: * * - input must fit into 232 bits * * _Available since v4.7._ */ function toUint232(uint256 value) internal pure returns (uint232) { require(value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits"); return uint232(value); } /** * @dev Returns the downcasted uint224 from uint256, reverting on * overflow (when the input is greater than largest uint224). * * Counterpart to Solidity's `uint224` operator. * * Requirements: * * - input must fit into 224 bits * * _Available since v4.2._ */ function toUint224(uint256 value) internal pure returns (uint224) { require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits"); return uint224(value); } /** * @dev Returns the downcasted uint216 from uint256, reverting on * overflow (when the input is greater than largest uint216). * * Counterpart to Solidity's `uint216` operator. * * Requirements: * * - input must fit into 216 bits * * _Available since v4.7._ */ function toUint216(uint256 value) internal pure returns (uint216) { require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits"); return uint216(value); } /** * @dev Returns the downcasted uint208 from uint256, reverting on * overflow (when the input is greater than largest uint208). * * Counterpart to Solidity's `uint208` operator. * * Requirements: * * - input must fit into 208 bits * * _Available since v4.7._ */ function toUint208(uint256 value) internal pure returns (uint208) { require(value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits"); return uint208(value); } /** * @dev Returns the downcasted uint200 from uint256, reverting on * overflow (when the input is greater than largest uint200). * * Counterpart to Solidity's `uint200` operator. * * Requirements: * * - input must fit into 200 bits * * _Available since v4.7._ */ function toUint200(uint256 value) internal pure returns (uint200) { require(value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits"); return uint200(value); } /** * @dev Returns the downcasted uint192 from uint256, reverting on * overflow (when the input is greater than largest uint192). * * Counterpart to Solidity's `uint192` operator. * * Requirements: * * - input must fit into 192 bits * * _Available since v4.7._ */ function toUint192(uint256 value) internal pure returns (uint192) { require(value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits"); return uint192(value); } /** * @dev Returns the downcasted uint184 from uint256, reverting on * overflow (when the input is greater than largest uint184). * * Counterpart to Solidity's `uint184` operator. * * Requirements: * * - input must fit into 184 bits * * _Available since v4.7._ */ function toUint184(uint256 value) internal pure returns (uint184) { require(value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits"); return uint184(value); } /** * @dev Returns the downcasted uint176 from uint256, reverting on * overflow (when the input is greater than largest uint176). * * Counterpart to Solidity's `uint176` operator. * * Requirements: * * - input must fit into 176 bits * * _Available since v4.7._ */ function toUint176(uint256 value) internal pure returns (uint176) { require(value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits"); return uint176(value); } /** * @dev Returns the downcasted uint168 from uint256, reverting on * overflow (when the input is greater than largest uint168). * * Counterpart to Solidity's `uint168` operator. * * Requirements: * * - input must fit into 168 bits * * _Available since v4.7._ */ function toUint168(uint256 value) internal pure returns (uint168) { require(value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits"); return uint168(value); } /** * @dev Returns the downcasted uint160 from uint256, reverting on * overflow (when the input is greater than largest uint160). * * Counterpart to Solidity's `uint160` operator. * * Requirements: * * - input must fit into 160 bits * * _Available since v4.7._ */ function toUint160(uint256 value) internal pure returns (uint160) { require(value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits"); return uint160(value); } /** * @dev Returns the downcasted uint152 from uint256, reverting on * overflow (when the input is greater than largest uint152). * * Counterpart to Solidity's `uint152` operator. * * Requirements: * * - input must fit into 152 bits * * _Available since v4.7._ */ function toUint152(uint256 value) internal pure returns (uint152) { require(value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits"); return uint152(value); } /** * @dev Returns the downcasted uint144 from uint256, reverting on * overflow (when the input is greater than largest uint144). * * Counterpart to Solidity's `uint144` operator. * * Requirements: * * - input must fit into 144 bits * * _Available since v4.7._ */ function toUint144(uint256 value) internal pure returns (uint144) { require(value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits"); return uint144(value); } /** * @dev Returns the downcasted uint136 from uint256, reverting on * overflow (when the input is greater than largest uint136). * * Counterpart to Solidity's `uint136` operator. * * Requirements: * * - input must fit into 136 bits * * _Available since v4.7._ */ function toUint136(uint256 value) internal pure returns (uint136) { require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits"); return uint136(value); } /** * @dev Returns the downcasted uint128 from uint256, reverting on * overflow (when the input is greater than largest uint128). * * Counterpart to Solidity's `uint128` operator. * * Requirements: * * - input must fit into 128 bits * * _Available since v2.5._ */ function toUint128(uint256 value) internal pure returns (uint128) { require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits"); return uint128(value); } /** * @dev Returns the downcasted uint120 from uint256, reverting on * overflow (when the input is greater than largest uint120). * * Counterpart to Solidity's `uint120` operator. * * Requirements: * * - input must fit into 120 bits * * _Available since v4.7._ */ function toUint120(uint256 value) internal pure returns (uint120) { require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits"); return uint120(value); } /** * @dev Returns the downcasted uint112 from uint256, reverting on * overflow (when the input is greater than largest uint112). * * Counterpart to Solidity's `uint112` operator. * * Requirements: * * - input must fit into 112 bits * * _Available since v4.7._ */ function toUint112(uint256 value) internal pure returns (uint112) { require(value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits"); return uint112(value); } /** * @dev Returns the downcasted uint104 from uint256, reverting on * overflow (when the input is greater than largest uint104). * * Counterpart to Solidity's `uint104` operator. * * Requirements: * * - input must fit into 104 bits * * _Available since v4.7._ */ function toUint104(uint256 value) internal pure returns (uint104) { require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits"); return uint104(value); } /** * @dev Returns the downcasted uint96 from uint256, reverting on * overflow (when the input is greater than largest uint96). * * Counterpart to Solidity's `uint96` operator. * * Requirements: * * - input must fit into 96 bits * * _Available since v4.2._ */ function toUint96(uint256 value) internal pure returns (uint96) { require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits"); return uint96(value); } /** * @dev Returns the downcasted uint88 from uint256, reverting on * overflow (when the input is greater than largest uint88). * * Counterpart to Solidity's `uint88` operator. * * Requirements: * * - input must fit into 88 bits * * _Available since v4.7._ */ function toUint88(uint256 value) internal pure returns (uint88) { require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits"); return uint88(value); } /** * @dev Returns the downcasted uint80 from uint256, reverting on * overflow (when the input is greater than largest uint80). * * Counterpart to Solidity's `uint80` operator. * * Requirements: * * - input must fit into 80 bits * * _Available since v4.7._ */ function toUint80(uint256 value) internal pure returns (uint80) { require(value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits"); return uint80(value); } /** * @dev Returns the downcasted uint72 from uint256, reverting on * overflow (when the input is greater than largest uint72). * * Counterpart to Solidity's `uint72` operator. * * Requirements: * * - input must fit into 72 bits * * _Available since v4.7._ */ function toUint72(uint256 value) internal pure returns (uint72) { require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits"); return uint72(value); } /** * @dev Returns the downcasted uint64 from uint256, reverting on * overflow (when the input is greater than largest uint64). * * Counterpart to Solidity's `uint64` operator. * * Requirements: * * - input must fit into 64 bits * * _Available since v2.5._ */ function toUint64(uint256 value) internal pure returns (uint64) { require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits"); return uint64(value); } /** * @dev Returns the downcasted uint56 from uint256, reverting on * overflow (when the input is greater than largest uint56). * * Counterpart to Solidity's `uint56` operator. * * Requirements: * * - input must fit into 56 bits * * _Available since v4.7._ */ function toUint56(uint256 value) internal pure returns (uint56) { require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits"); return uint56(value); } /** * @dev Returns the downcasted uint48 from uint256, reverting on * overflow (when the input is greater than largest uint48). * * Counterpart to Solidity's `uint48` operator. * * Requirements: * * - input must fit into 48 bits * * _Available since v4.7._ */ function toUint48(uint256 value) internal pure returns (uint48) { require(value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits"); return uint48(value); } /** * @dev Returns the downcasted uint40 from uint256, reverting on * overflow (when the input is greater than largest uint40). * * Counterpart to Solidity's `uint40` operator. * * Requirements: * * - input must fit into 40 bits * * _Available since v4.7._ */ function toUint40(uint256 value) internal pure returns (uint40) { require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits"); return uint40(value); } /** * @dev Returns the downcasted uint32 from uint256, reverting on * overflow (when the input is greater than largest uint32). * * Counterpart to Solidity's `uint32` operator. * * Requirements: * * - input must fit into 32 bits * * _Available since v2.5._ */ function toUint32(uint256 value) internal pure returns (uint32) { require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits"); return uint32(value); } /** * @dev Returns the downcasted uint24 from uint256, reverting on * overflow (when the input is greater than largest uint24). * * Counterpart to Solidity's `uint24` operator. * * Requirements: * * - input must fit into 24 bits * * _Available since v4.7._ */ function toUint24(uint256 value) internal pure returns (uint24) { require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits"); return uint24(value); } /** * @dev Returns the downcasted uint16 from uint256, reverting on * overflow (when the input is greater than largest uint16). * * Counterpart to Solidity's `uint16` operator. * * Requirements: * * - input must fit into 16 bits * * _Available since v2.5._ */ function toUint16(uint256 value) internal pure returns (uint16) { require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits"); return uint16(value); } /** * @dev Returns the downcasted uint8 from uint256, reverting on * overflow (when the input is greater than largest uint8). * * Counterpart to Solidity's `uint8` operator. * * Requirements: * * - input must fit into 8 bits * * _Available since v2.5._ */ function toUint8(uint256 value) internal pure returns (uint8) { require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits"); return uint8(value); } /** * @dev Converts a signed int256 into an unsigned uint256. * * Requirements: * * - input must be greater than or equal to 0. * * _Available since v3.0._ */ function toUint256(int256 value) internal pure returns (uint256) { require(value >= 0, "SafeCast: value must be positive"); return uint256(value); } /** * @dev Returns the downcasted int248 from int256, reverting on * overflow (when the input is less than smallest int248 or * greater than largest int248). * * Counterpart to Solidity's `int248` operator. * * Requirements: * * - input must fit into 248 bits * * _Available since v4.7._ */ function toInt248(int256 value) internal pure returns (int248) { require(value >= type(int248).min && value <= type(int248).max, "SafeCast: value doesn't fit in 248 bits"); return int248(value); } /** * @dev Returns the downcasted int240 from int256, reverting on * overflow (when the input is less than smallest int240 or * greater than largest int240). * * Counterpart to Solidity's `int240` operator. * * Requirements: * * - input must fit into 240 bits * * _Available since v4.7._ */ function toInt240(int256 value) internal pure returns (int240) { require(value >= type(int240).min && value <= type(int240).max, "SafeCast: value doesn't fit in 240 bits"); return int240(value); } /** * @dev Returns the downcasted int232 from int256, reverting on * overflow (when the input is less than smallest int232 or * greater than largest int232). * * Counterpart to Solidity's `int232` operator. * * Requirements: * * - input must fit into 232 bits * * _Available since v4.7._ */ function toInt232(int256 value) internal pure returns (int232) { require(value >= type(int232).min && value <= type(int232).max, "SafeCast: value doesn't fit in 232 bits"); return int232(value); } /** * @dev Returns the downcasted int224 from int256, reverting on * overflow (when the input is less than smallest int224 or * greater than largest int224). * * Counterpart to Solidity's `int224` operator. * * Requirements: * * - input must fit into 224 bits * * _Available since v4.7._ */ function toInt224(int256 value) internal pure returns (int224) { require(value >= type(int224).min && value <= type(int224).max, "SafeCast: value doesn't fit in 224 bits"); return int224(value); } /** * @dev Returns the downcasted int216 from int256, reverting on * overflow (when the input is less than smallest int216 or * greater than largest int216). * * Counterpart to Solidity's `int216` operator. * * Requirements: * * - input must fit into 216 bits * * _Available since v4.7._ */ function toInt216(int256 value) internal pure returns (int216) { require(value >= type(int216).min && value <= type(int216).max, "SafeCast: value doesn't fit in 216 bits"); return int216(value); } /** * @dev Returns the downcasted int208 from int256, reverting on * overflow (when the input is less than smallest int208 or * greater than largest int208). * * Counterpart to Solidity's `int208` operator. * * Requirements: * * - input must fit into 208 bits * * _Available since v4.7._ */ function toInt208(int256 value) internal pure returns (int208) { require(value >= type(int208).min && value <= type(int208).max, "SafeCast: value doesn't fit in 208 bits"); return int208(value); } /** * @dev Returns the downcasted int200 from int256, reverting on * overflow (when the input is less than smallest int200 or * greater than largest int200). * * Counterpart to Solidity's `int200` operator. * * Requirements: * * - input must fit into 200 bits * * _Available since v4.7._ */ function toInt200(int256 value) internal pure returns (int200) { require(value >= type(int200).min && value <= type(int200).max, "SafeCast: value doesn't fit in 200 bits"); return int200(value); } /** * @dev Returns the downcasted int192 from int256, reverting on * overflow (when the input is less than smallest int192 or * greater than largest int192). * * Counterpart to Solidity's `int192` operator. * * Requirements: * * - input must fit into 192 bits * * _Available since v4.7._ */ function toInt192(int256 value) internal pure returns (int192) { require(value >= type(int192).min && value <= type(int192).max, "SafeCast: value doesn't fit in 192 bits"); return int192(value); } /** * @dev Returns the downcasted int184 from int256, reverting on * overflow (when the input is less than smallest int184 or * greater than largest int184). * * Counterpart to Solidity's `int184` operator. * * Requirements: * * - input must fit into 184 bits * * _Available since v4.7._ */ function toInt184(int256 value) internal pure returns (int184) { require(value >= type(int184).min && value <= type(int184).max, "SafeCast: value doesn't fit in 184 bits"); return int184(value); } /** * @dev Returns the downcasted int176 from int256, reverting on * overflow (when the input is less than smallest int176 or * greater than largest int176). * * Counterpart to Solidity's `int176` operator. * * Requirements: * * - input must fit into 176 bits * * _Available since v4.7._ */ function toInt176(int256 value) internal pure returns (int176) { require(value >= type(int176).min && value <= type(int176).max, "SafeCast: value doesn't fit in 176 bits"); return int176(value); } /** * @dev Returns the downcasted int168 from int256, reverting on * overflow (when the input is less than smallest int168 or * greater than largest int168). * * Counterpart to Solidity's `int168` operator. * * Requirements: * * - input must fit into 168 bits * * _Available since v4.7._ */ function toInt168(int256 value) internal pure returns (int168) { require(value >= type(int168).min && value <= type(int168).max, "SafeCast: value doesn't fit in 168 bits"); return int168(value); } /** * @dev Returns the downcasted int160 from int256, reverting on * overflow (when the input is less than smallest int160 or * greater than largest int160). * * Counterpart to Solidity's `int160` operator. * * Requirements: * * - input must fit into 160 bits * * _Available since v4.7._ */ function toInt160(int256 value) internal pure returns (int160) { require(value >= type(int160).min && value <= type(int160).max, "SafeCast: value doesn't fit in 160 bits"); return int160(value); } /** * @dev Returns the downcasted int152 from int256, reverting on * overflow (when the input is less than smallest int152 or * greater than largest int152). * * Counterpart to Solidity's `int152` operator. * * Requirements: * * - input must fit into 152 bits * * _Available since v4.7._ */ function toInt152(int256 value) internal pure returns (int152) { require(value >= type(int152).min && value <= type(int152).max, "SafeCast: value doesn't fit in 152 bits"); return int152(value); } /** * @dev Returns the downcasted int144 from int256, reverting on * overflow (when the input is less than smallest int144 or * greater than largest int144). * * Counterpart to Solidity's `int144` operator. * * Requirements: * * - input must fit into 144 bits * * _Available since v4.7._ */ function toInt144(int256 value) internal pure returns (int144) { require(value >= type(int144).min && value <= type(int144).max, "SafeCast: value doesn't fit in 144 bits"); return int144(value); } /** * @dev Returns the downcasted int136 from int256, reverting on * overflow (when the input is less than smallest int136 or * greater than largest int136). * * Counterpart to Solidity's `int136` operator. * * Requirements: * * - input must fit into 136 bits * * _Available since v4.7._ */ function toInt136(int256 value) internal pure returns (int136) { require(value >= type(int136).min && value <= type(int136).max, "SafeCast: value doesn't fit in 136 bits"); return int136(value); } /** * @dev Returns the downcasted int128 from int256, reverting on * overflow (when the input is less than smallest int128 or * greater than largest int128). * * Counterpart to Solidity's `int128` operator. * * Requirements: * * - input must fit into 128 bits * * _Available since v3.1._ */ function toInt128(int256 value) internal pure returns (int128) { require(value >= type(int128).min && value <= type(int128).max, "SafeCast: value doesn't fit in 128 bits"); return int128(value); } /** * @dev Returns the downcasted int120 from int256, reverting on * overflow (when the input is less than smallest int120 or * greater than largest int120). * * Counterpart to Solidity's `int120` operator. * * Requirements: * * - input must fit into 120 bits * * _Available since v4.7._ */ function toInt120(int256 value) internal pure returns (int120) { require(value >= type(int120).min && value <= type(int120).max, "SafeCast: value doesn't fit in 120 bits"); return int120(value); } /** * @dev Returns the downcasted int112 from int256, reverting on * overflow (when the input is less than smallest int112 or * greater than largest int112). * * Counterpart to Solidity's `int112` operator. * * Requirements: * * - input must fit into 112 bits * * _Available since v4.7._ */ function toInt112(int256 value) internal pure returns (int112) { require(value >= type(int112).min && value <= type(int112).max, "SafeCast: value doesn't fit in 112 bits"); return int112(value); } /** * @dev Returns the downcasted int104 from int256, reverting on * overflow (when the input is less than smallest int104 or * greater than largest int104). * * Counterpart to Solidity's `int104` operator. * * Requirements: * * - input must fit into 104 bits * * _Available since v4.7._ */ function toInt104(int256 value) internal pure returns (int104) { require(value >= type(int104).min && value <= type(int104).max, "SafeCast: value doesn't fit in 104 bits"); return int104(value); } /** * @dev Returns the downcasted int96 from int256, reverting on * overflow (when the input is less than smallest int96 or * greater than largest int96). * * Counterpart to Solidity's `int96` operator. * * Requirements: * * - input must fit into 96 bits * * _Available since v4.7._ */ function toInt96(int256 value) internal pure returns (int96) { require(value >= type(int96).min && value <= type(int96).max, "SafeCast: value doesn't fit in 96 bits"); return int96(value); } /** * @dev Returns the downcasted int88 from int256, reverting on * overflow (when the input is less than smallest int88 or * greater than largest int88). * * Counterpart to Solidity's `int88` operator. * * Requirements: * * - input must fit into 88 bits * * _Available since v4.7._ */ function toInt88(int256 value) internal pure returns (int88) { require(value >= type(int88).min && value <= type(int88).max, "SafeCast: value doesn't fit in 88 bits"); return int88(value); } /** * @dev Returns the downcasted int80 from int256, reverting on * overflow (when the input is less than smallest int80 or * greater than largest int80). * * Counterpart to Solidity's `int80` operator. * * Requirements: * * - input must fit into 80 bits * * _Available since v4.7._ */ function toInt80(int256 value) internal pure returns (int80) { require(value >= type(int80).min && value <= type(int80).max, "SafeCast: value doesn't fit in 80 bits"); return int80(value); } /** * @dev Returns the downcasted int72 from int256, reverting on * overflow (when the input is less than smallest int72 or * greater than largest int72). * * Counterpart to Solidity's `int72` operator. * * Requirements: * * - input must fit into 72 bits * * _Available since v4.7._ */ function toInt72(int256 value) internal pure returns (int72) { require(value >= type(int72).min && value <= type(int72).max, "SafeCast: value doesn't fit in 72 bits"); return int72(value); } /** * @dev Returns the downcasted int64 from int256, reverting on * overflow (when the input is less than smallest int64 or * greater than largest int64). * * Counterpart to Solidity's `int64` operator. * * Requirements: * * - input must fit into 64 bits * * _Available since v3.1._ */ function toInt64(int256 value) internal pure returns (int64) { require(value >= type(int64).min && value <= type(int64).max, "SafeCast: value doesn't fit in 64 bits"); return int64(value); } /** * @dev Returns the downcasted int56 from int256, reverting on * overflow (when the input is less than smallest int56 or * greater than largest int56). * * Counterpart to Solidity's `int56` operator. * * Requirements: * * - input must fit into 56 bits * * _Available since v4.7._ */ function toInt56(int256 value) internal pure returns (int56) { require(value >= type(int56).min && value <= type(int56).max, "SafeCast: value doesn't fit in 56 bits"); return int56(value); } /** * @dev Returns the downcasted int48 from int256, reverting on * overflow (when the input is less than smallest int48 or * greater than largest int48). * * Counterpart to Solidity's `int48` operator. * * Requirements: * * - input must fit into 48 bits * * _Available since v4.7._ */ function toInt48(int256 value) internal pure returns (int48) { require(value >= type(int48).min && value <= type(int48).max, "SafeCast: value doesn't fit in 48 bits"); return int48(value); } /** * @dev Returns the downcasted int40 from int256, reverting on * overflow (when the input is less than smallest int40 or * greater than largest int40). * * Counterpart to Solidity's `int40` operator. * * Requirements: * * - input must fit into 40 bits * * _Available since v4.7._ */ function toInt40(int256 value) internal pure returns (int40) { require(value >= type(int40).min && value <= type(int40).max, "SafeCast: value doesn't fit in 40 bits"); return int40(value); } /** * @dev Returns the downcasted int32 from int256, reverting on * overflow (when the input is less than smallest int32 or * greater than largest int32). * * Counterpart to Solidity's `int32` operator. * * Requirements: * * - input must fit into 32 bits * * _Available since v3.1._ */ function toInt32(int256 value) internal pure returns (int32) { require(value >= type(int32).min && value <= type(int32).max, "SafeCast: value doesn't fit in 32 bits"); return int32(value); } /** * @dev Returns the downcasted int24 from int256, reverting on * overflow (when the input is less than smallest int24 or * greater than largest int24). * * Counterpart to Solidity's `int24` operator. * * Requirements: * * - input must fit into 24 bits * * _Available since v4.7._ */ function toInt24(int256 value) internal pure returns (int24) { require(value >= type(int24).min && value <= type(int24).max, "SafeCast: value doesn't fit in 24 bits"); return int24(value); } /** * @dev Returns the downcasted int16 from int256, reverting on * overflow (when the input is less than smallest int16 or * greater than largest int16). * * Counterpart to Solidity's `int16` operator. * * Requirements: * * - input must fit into 16 bits * * _Available since v3.1._ */ function toInt16(int256 value) internal pure returns (int16) { require(value >= type(int16).min && value <= type(int16).max, "SafeCast: value doesn't fit in 16 bits"); return int16(value); } /** * @dev Returns the downcasted int8 from int256, reverting on * overflow (when the input is less than smallest int8 or * greater than largest int8). * * Counterpart to Solidity's `int8` operator. * * Requirements: * * - input must fit into 8 bits * * _Available since v3.1._ */ function toInt8(int256 value) internal pure returns (int8) { require(value >= type(int8).min && value <= type(int8).max, "SafeCast: value doesn't fit in 8 bits"); return int8(value); } /** * @dev Converts an unsigned uint256 into a signed int256. * * Requirements: * * - input must be less than or equal to maxInt256. * * _Available since v3.0._ */ function toInt256(uint256 value) internal pure returns (int256) { // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256"); return int256(value); } } // File: @openzeppelin/contracts/governance/utils/IVotes.sol // OpenZeppelin Contracts (last updated v4.5.0) (governance/utils/IVotes.sol) pragma solidity ^0.8.0; /** * @dev Common interface for {ERC20Votes}, {ERC721Votes}, and other {Votes}-enabled contracts. * * _Available since v4.5._ */ interface IVotes { /** * @dev Emitted when an account changes their delegate. */ event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate); /** * @dev Emitted when a token transfer or delegate change results in changes to a delegate's number of votes. */ event DelegateVotesChanged(address indexed delegate, uint256 previousBalance, uint256 newBalance); /** * @dev Returns the current amount of votes that `account` has. */ function getVotes(address account) external view returns (uint256); /** * @dev Returns the amount of votes that `account` had at the end of a past block (`blockNumber`). */ function getPastVotes(address account, uint256 blockNumber) external view returns (uint256); /** * @dev Returns the total supply of votes available at the end of a past block (`blockNumber`). * * NOTE: This value is the sum of all available votes, which is not necessarily the sum of all delegated votes. * Votes that have not been delegated are still part of total supply, even though they would not participate in a * vote. */ function getPastTotalSupply(uint256 blockNumber) external view returns (uint256); /** * @dev Returns the delegate that `account` has chosen. */ function delegates(address account) external view returns (address); /** * @dev Delegates votes from the sender to `delegatee`. */ function delegate(address delegatee) external; /** * @dev Delegates votes from signer to `delegatee`. */ function delegateBySig( address delegatee, uint256 nonce, uint256 expiry, uint8 v, bytes32 r, bytes32 s ) external; } // File: @openzeppelin/contracts/utils/math/Math.sol // OpenZeppelin Contracts (last updated v4.7.0) (utils/math/Math.sol) pragma solidity ^0.8.0; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { enum Rounding { Down, // Toward negative infinity Up, // Toward infinity Zero // Toward zero } /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a >= b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow. return (a & b) + (a ^ b) / 2; } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds up instead * of rounding down. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b - 1) / b can overflow on addition, so we distribute. return a == 0 ? 0 : (a - 1) / b + 1; } /** * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0 * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) * with further edits by Uniswap Labs also under MIT license. */ function mulDiv( uint256 x, uint256 y, uint256 denominator ) internal pure returns (uint256 result) { unchecked { // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 // variables such that product = prod1 * 2^256 + prod0. uint256 prod0; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(x, y, not(0)) prod0 := mul(x, y) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Handle non-overflow cases, 256 by 256 division. if (prod1 == 0) { return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. require(denominator > prod1); /////////////////////////////////////////////// // 512 by 256 division. /////////////////////////////////////////////// // Make division exact by subtracting the remainder from [prod1 prod0]. uint256 remainder; assembly { // Compute remainder using mulmod. remainder := mulmod(x, y, denominator) // Subtract 256 bit number from 512 bit number. prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) } // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1. // See https://cs.stackexchange.com/q/138556/92363. // Does not overflow because the denominator cannot be zero at this stage in the function. uint256 twos = denominator & (~denominator + 1); assembly { // Divide denominator by twos. denominator := div(denominator, twos) // Divide [prod1 prod0] by twos. prod0 := div(prod0, twos) // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one. twos := add(div(sub(0, twos), twos), 1) } // Shift in bits from prod1 into prod0. prod0 |= prod1 * twos; // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for // four bits. That is, denominator * inv = 1 mod 2^4. uint256 inverse = (3 * denominator) ^ 2; // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works // in modular arithmetic, doubling the correct bits in each step. inverse *= 2 - denominator * inverse; // inverse mod 2^8 inverse *= 2 - denominator * inverse; // inverse mod 2^16 inverse *= 2 - denominator * inverse; // inverse mod 2^32 inverse *= 2 - denominator * inverse; // inverse mod 2^64 inverse *= 2 - denominator * inverse; // inverse mod 2^128 inverse *= 2 - denominator * inverse; // inverse mod 2^256 // Because the division is now exact we can divide by multiplying with the modular inverse of denominator. // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1 // is no longer required. result = prod0 * inverse; return result; } } /** * @notice Calculates x * y / denominator with full precision, following the selected rounding direction. */ function mulDiv( uint256 x, uint256 y, uint256 denominator, Rounding rounding ) internal pure returns (uint256) { uint256 result = mulDiv(x, y, denominator); if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) { result += 1; } return result; } /** * @dev Returns the square root of a number. It 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)`. // We also know that `k`, the position of the most significant bit, is such that `msb(a) = 2**k`. // This gives `2**k < a <= 2**(k+1)` → `2**(k/2) <= sqrt(a) < 2 ** (k/2+1)`. // Using an algorithm similar to the msb conmputation, we are able to compute `result = 2**(k/2)` which is a // good first aproximation of `sqrt(a)` with at least 1 correct bit. uint256 result = 1; uint256 x = a; if (x >> 128 > 0) { x >>= 128; result <<= 64; } if (x >> 64 > 0) { x >>= 64; result <<= 32; } if (x >> 32 > 0) { x >>= 32; result <<= 16; } if (x >> 16 > 0) { x >>= 16; result <<= 8; } if (x >> 8 > 0) { x >>= 8; result <<= 4; } if (x >> 4 > 0) { x >>= 4; result <<= 2; } if (x >> 2 > 0) { result <<= 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) { uint256 result = sqrt(a); if (rounding == Rounding.Up && result * result < a) { result += 1; } return result; } } // File: @openzeppelin/contracts/utils/Counters.sol // OpenZeppelin Contracts v4.4.1 (utils/Counters.sol) pragma solidity ^0.8.0; /** * @title Counters * @author Matt Condon (@shrugs) * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number * of elements in a mapping, issuing ERC721 ids, or counting request ids. * * Include with `using Counters for Counters.Counter;` */ library Counters { struct Counter { // This variable should never be directly accessed by users of the library: interactions must be restricted to // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add // this feature: see https://github.com/ethereum/solidity/issues/4637 uint256 _value; // default: 0 } function current(Counter storage counter) internal view returns (uint256) { return counter._value; } function increment(Counter storage counter) internal { unchecked { counter._value += 1; } } function decrement(Counter storage counter) internal { uint256 value = counter._value; require(value > 0, "Counter: decrement overflow"); unchecked { counter._value = value - 1; } } function reset(Counter storage counter) internal { counter._value = 0; } } // File: @openzeppelin/contracts/utils/Strings.sol // OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol) pragma solidity ^0.8.0; /** * @dev String operations. */ library Strings { bytes16 private constant _HEX_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) { // Inspired by OraclizeAPI's implementation - MIT licence // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol if (value == 0) { return "0"; } uint256 temp = value; uint256 digits; while (temp != 0) { digits++; temp /= 10; } bytes memory buffer = new bytes(digits); while (value != 0) { digits -= 1; buffer[digits] = bytes1(uint8(48 + uint256(value % 10))); value /= 10; } return string(buffer); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { if (value == 0) { return "0x00"; } uint256 temp = value; uint256 length = 0; while (temp != 0) { length++; temp >>= 8; } return toHexString(value, length); } /** * @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] = _HEX_SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH); } } // File: @openzeppelin/contracts/utils/cryptography/ECDSA.sol // OpenZeppelin Contracts (last updated v4.7.3) (utils/cryptography/ECDSA.sol) pragma solidity ^0.8.0; /** * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations. * * These functions can be used to verify that a message was signed by the holder * of the private keys of a given address. */ library ECDSA { enum RecoverError { NoError, InvalidSignature, InvalidSignatureLength, InvalidSignatureS, InvalidSignatureV } function _throwError(RecoverError error) private pure { if (error == RecoverError.NoError) { return; // no error: do nothing } else if (error == RecoverError.InvalidSignature) { revert("ECDSA: invalid signature"); } else if (error == RecoverError.InvalidSignatureLength) { revert("ECDSA: invalid signature length"); } else if (error == RecoverError.InvalidSignatureS) { revert("ECDSA: invalid signature 's' value"); } else if (error == RecoverError.InvalidSignatureV) { revert("ECDSA: invalid signature 'v' value"); } } /** * @dev Returns the address that signed a hashed message (`hash`) with * `signature` or error string. This address can then be used for verification purposes. * * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures: * this function rejects them by requiring the `s` value to be in the lower * half order, and the `v` value to be either 27 or 28. * * IMPORTANT: `hash` _must_ be the result of a hash operation for the * verification to be secure: it is possible to craft signatures that * recover to arbitrary addresses for non-hashed data. A safe way to ensure * this is by receiving a hash of the original message (which may otherwise * be too long), and then calling {toEthSignedMessageHash} on it. * * Documentation for signature generation: * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js] * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers] * * _Available since v4.3._ */ function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) { if (signature.length == 65) { bytes32 r; bytes32 s; uint8 v; // ecrecover takes the signature parameters, and the only way to get them // currently is to use assembly. /// @solidity memory-safe-assembly assembly { r := mload(add(signature, 0x20)) s := mload(add(signature, 0x40)) v := byte(0, mload(add(signature, 0x60))) } return tryRecover(hash, v, r, s); } else { return (address(0), RecoverError.InvalidSignatureLength); } } /** * @dev Returns the address that signed a hashed message (`hash`) with * `signature`. This address can then be used for verification purposes. * * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures: * this function rejects them by requiring the `s` value to be in the lower * half order, and the `v` value to be either 27 or 28. * * IMPORTANT: `hash` _must_ be the result of a hash operation for the * verification to be secure: it is possible to craft signatures that * recover to arbitrary addresses for non-hashed data. A safe way to ensure * this is by receiving a hash of the original message (which may otherwise * be too long), and then calling {toEthSignedMessageHash} on it. */ function recover(bytes32 hash, bytes memory signature) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, signature); _throwError(error); return recovered; } /** * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately. * * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures] * * _Available since v4.3._ */ function tryRecover( bytes32 hash, bytes32 r, bytes32 vs ) internal pure returns (address, RecoverError) { bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); uint8 v = uint8((uint256(vs) >> 255) + 27); return tryRecover(hash, v, r, s); } /** * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately. * * _Available since v4.2._ */ function recover( bytes32 hash, bytes32 r, bytes32 vs ) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, r, vs); _throwError(error); return recovered; } /** * @dev Overload of {ECDSA-tryRecover} that receives the `v`, * `r` and `s` signature fields separately. * * _Available since v4.3._ */ function tryRecover( bytes32 hash, uint8 v, bytes32 r, bytes32 s ) internal pure returns (address, RecoverError) { // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most // signatures from current libraries generate a unique signature with an s-value in the lower half order. // // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept // these malleable signatures as well. if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) { return (address(0), RecoverError.InvalidSignatureS); } if (v != 27 && v != 28) { return (address(0), RecoverError.InvalidSignatureV); } // If the signature is valid (and not malleable), return the signer address address signer = ecrecover(hash, v, r, s); if (signer == address(0)) { return (address(0), RecoverError.InvalidSignature); } return (signer, RecoverError.NoError); } /** * @dev Overload of {ECDSA-recover} that receives the `v`, * `r` and `s` signature fields separately. */ function recover( bytes32 hash, uint8 v, bytes32 r, bytes32 s ) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, v, r, s); _throwError(error); return recovered; } /** * @dev Returns an Ethereum Signed Message, created from a `hash`. This * produces hash corresponding to the one signed with the * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] * JSON-RPC method as part of EIP-191. * * See {recover}. */ function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) { // 32 is the length in bytes of hash, // enforced by the type signature above return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)); } /** * @dev Returns an Ethereum Signed Message, created from `s`. This * produces hash corresponding to the one signed with the * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] * JSON-RPC method as part of EIP-191. * * See {recover}. */ function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) { return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s)); } /** * @dev Returns an Ethereum Signed Typed Data, created from a * `domainSeparator` and a `structHash`. This produces hash corresponding * to the one signed with the * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] * JSON-RPC method as part of EIP-712. * * See {recover}. */ function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) { return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash)); } } // File: @openzeppelin/contracts/utils/cryptography/draft-EIP712.sol // OpenZeppelin Contracts v4.4.1 (utils/cryptography/draft-EIP712.sol) pragma solidity ^0.8.0; /** * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data. * * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible, * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding * they need in their contracts using a combination of `abi.encode` and `keccak256`. * * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA * ({_hashTypedDataV4}). * * The implementation of the domain separator was designed to be as efficient as possible while still properly updating * the chain id to protect against replay attacks on an eventual fork of the chain. * * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask]. * * _Available since v3.4._ */ abstract contract EIP712 { /* solhint-disable var-name-mixedcase */ // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to // invalidate the cached domain separator if the chain id changes. bytes32 private immutable _CACHED_DOMAIN_SEPARATOR; uint256 private immutable _CACHED_CHAIN_ID; address private immutable _CACHED_THIS; bytes32 private immutable _HASHED_NAME; bytes32 private immutable _HASHED_VERSION; bytes32 private immutable _TYPE_HASH; /* solhint-enable var-name-mixedcase */ /** * @dev Initializes the domain separator and parameter caches. * * The meaning of `name` and `version` is specified in * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]: * * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol. * - `version`: the current major version of the signing domain. * * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart * contract upgrade]. */ constructor(string memory name, string memory version) { bytes32 hashedName = keccak256(bytes(name)); bytes32 hashedVersion = keccak256(bytes(version)); bytes32 typeHash = keccak256( "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)" ); _HASHED_NAME = hashedName; _HASHED_VERSION = hashedVersion; _CACHED_CHAIN_ID = block.chainid; _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion); _CACHED_THIS = address(this); _TYPE_HASH = typeHash; } /** * @dev Returns the domain separator for the current chain. */ function _domainSeparatorV4() internal view returns (bytes32) { if (address(this) == _CACHED_THIS && block.chainid == _CACHED_CHAIN_ID) { return _CACHED_DOMAIN_SEPARATOR; } else { return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION); } } function _buildDomainSeparator( bytes32 typeHash, bytes32 nameHash, bytes32 versionHash ) private view returns (bytes32) { return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this))); } /** * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this * function returns the hash of the fully encoded EIP712 message for this domain. * * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example: * * ```solidity * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode( * keccak256("Mail(address to,string contents)"), * mailTo, * keccak256(bytes(mailContents)) * ))); * address signer = ECDSA.recover(digest, signature); * ``` */ function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) { return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash); } } // File: @openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612]. * * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't * need to send a transaction, and thus is not required to hold Ether at all. */ interface IERC20Permit { /** * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens, * given ``owner``'s signed approval. * * IMPORTANT: The same issues {IERC20-approve} has related to transaction * ordering also apply here. * * Emits an {Approval} event. * * Requirements: * * - `spender` cannot be the zero address. * - `deadline` must be a timestamp in the future. * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner` * over the EIP712-formatted function arguments. * - the signature must use ``owner``'s current nonce (see {nonces}). * * For more information on the signature format, see the * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP * section]. */ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external; /** * @dev Returns the current nonce for `owner`. This value must be * included whenever a signature is generated for {permit}. * * Every successful call to {permit} increases ``owner``'s nonce by one. This * prevents a signature from being used multiple times. */ function nonces(address owner) external view returns (uint256); /** * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}. */ // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view returns (bytes32); } // File: @openzeppelin/contracts/utils/Context.sol // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } // File: @openzeppelin/contracts/access/Ownable.sol // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) pragma solidity ^0.8.0; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { require(owner() == _msgSender(), "Ownable: caller is not the owner"); } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } // File: @openzeppelin/contracts/token/ERC20/IERC20.sol // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `to`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address to, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * 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.7.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.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin Contracts guidelines: functions revert * instead returning `false` on failure. This behavior is nonetheless * conventional and does not conflict with the expectations of ERC20 * applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. */ contract ERC20 is Context, IERC20, IERC20Metadata { mapping(address => uint256) private _balances; mapping(address => mapping(address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; /** * @dev Sets the values for {name} and {symbol}. * * The default value of {decimals} is 18. To select a different value for * {decimals} you should overload it. * * All two of these values are immutable: they can only be set once during * construction. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev Returns the name of the token. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev Returns the number of decimals used to get its user representation. * For example, if `decimals` equals `2`, a balance of `505` tokens should * be displayed to a user as `5.05` (`505 / 10 ** 2`). * * Tokens usually opt for a value of 18, imitating the relationship between * Ether and Wei. This is the value {ERC20} uses, unless this function is * overridden; * * NOTE: This information is only used for _display_ purposes: it in * no way affects any of the arithmetic of the contract, including * {IERC20-balanceOf} and {IERC20-transfer}. */ function decimals() public view virtual override returns (uint8) { return 18; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view virtual override returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `to` cannot be the zero address. * - the caller must have a balance of at least `amount`. */ function transfer(address to, uint256 amount) public virtual override returns (bool) { address owner = _msgSender(); _transfer(owner, to, amount); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on * `transferFrom`. This is semantically equivalent to an infinite approval. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 amount) public virtual override returns (bool) { address owner = _msgSender(); _approve(owner, spender, amount); return true; } /** * @dev See {IERC20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {ERC20}. * * NOTE: Does not update the allowance if the current allowance * is the maximum `uint256`. * * Requirements: * * - `from` and `to` cannot be the zero address. * - `from` must have a balance of at least `amount`. * - the caller must have allowance for ``from``'s tokens of at least * `amount`. */ function transferFrom( address from, address to, uint256 amount ) public virtual override returns (bool) { address spender = _msgSender(); _spendAllowance(from, spender, amount); _transfer(from, to, amount); return true; } /** * @dev Atomically increases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. */ function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { address owner = _msgSender(); _approve(owner, spender, allowance(owner, spender) + addedValue); return true; } /** * @dev Atomically decreases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. * - `spender` must have allowance for the caller of at least * `subtractedValue`. */ function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { address owner = _msgSender(); uint256 currentAllowance = allowance(owner, spender); require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero"); unchecked { _approve(owner, spender, currentAllowance - subtractedValue); } return true; } /** * @dev Moves `amount` of tokens from `from` to `to`. * * This internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `from` must have a balance of at least `amount`. */ function _transfer( address from, address to, uint256 amount ) internal virtual { require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(from, to, amount); uint256 fromBalance = _balances[from]; require(fromBalance >= amount, "ERC20: transfer amount exceeds balance"); unchecked { _balances[from] = fromBalance - amount; } _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; _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; } _totalSupply -= amount; emit Transfer(account, address(0), amount); _afterTokenTransfer(account, address(0), amount); } /** * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens. * * This internal function is equivalent to `approve`, and can be used to * e.g. set automatic allowances for certain subsystems, etc. * * Emits an {Approval} event. * * Requirements: * * - `owner` cannot be the zero address. * - `spender` cannot be the zero address. */ function _approve( address owner, address spender, uint256 amount ) internal virtual { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } /** * @dev Updates `owner` s allowance for `spender` based on spent `amount`. * * Does not update the allowance amount in case of infinite allowance. * Revert if not enough allowance is available. * * Might emit an {Approval} event. */ function _spendAllowance( address owner, address spender, uint256 amount ) internal virtual { uint256 currentAllowance = allowance(owner, spender); if (currentAllowance != type(uint256).max) { require(currentAllowance >= amount, "ERC20: insufficient allowance"); unchecked { _approve(owner, spender, currentAllowance - amount); } } } /** * @dev Hook that is called before any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * will be transferred to `to`. * - when `from` is zero, `amount` tokens will be minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens will be burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer( address from, address to, uint256 amount ) internal virtual {} /** * @dev Hook that is called after any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * has been transferred to `to`. * - when `from` is zero, `amount` tokens have been minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens have been burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _afterTokenTransfer( address from, address to, uint256 amount ) internal virtual {} } // File: @openzeppelin/contracts/token/ERC20/extensions/draft-ERC20Permit.sol // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/extensions/draft-ERC20Permit.sol) pragma solidity ^0.8.0; /** * @dev Implementation of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612]. * * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't * need to send a transaction, and thus is not required to hold Ether at all. * * _Available since v3.4._ */ abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 { using Counters for Counters.Counter; mapping(address => Counters.Counter) private _nonces; // solhint-disable-next-line var-name-mixedcase bytes32 private constant _PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"); /** * @dev In previous versions `_PERMIT_TYPEHASH` was declared as `immutable`. * However, to ensure consistency with the upgradeable transpiler, we will continue * to reserve a slot. * @custom:oz-renamed-from _PERMIT_TYPEHASH */ // solhint-disable-next-line var-name-mixedcase bytes32 private _PERMIT_TYPEHASH_DEPRECATED_SLOT; /** * @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `"1"`. * * It's a good idea to use the same `name` that is defined as the ERC20 token name. */ constructor(string memory name) EIP712(name, "1") {} /** * @dev See {IERC20Permit-permit}. */ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) public virtual override { require(block.timestamp <= deadline, "ERC20Permit: expired deadline"); bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline)); bytes32 hash = _hashTypedDataV4(structHash); address signer = ECDSA.recover(hash, v, r, s); require(signer == owner, "ERC20Permit: invalid signature"); _approve(owner, spender, value); } /** * @dev See {IERC20Permit-nonces}. */ function nonces(address owner) public view virtual override returns (uint256) { return _nonces[owner].current(); } /** * @dev See {IERC20Permit-DOMAIN_SEPARATOR}. */ // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view override returns (bytes32) { return _domainSeparatorV4(); } /** * @dev "Consume a nonce": return the current value and increment. * * _Available since v4.1._ */ function _useNonce(address owner) internal virtual returns (uint256 current) { Counters.Counter storage nonce = _nonces[owner]; current = nonce.current(); nonce.increment(); } } // File: @openzeppelin/contracts/token/ERC20/extensions/ERC20Votes.sol // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/extensions/ERC20Votes.sol) pragma solidity ^0.8.0; /** * @dev Extension of ERC20 to support Compound-like voting and delegation. This version is more generic than Compound's, * and supports token supply up to 2^224^ - 1, while COMP is limited to 2^96^ - 1. * * NOTE: If exact COMP compatibility is required, use the {ERC20VotesComp} variant of this module. * * This extension keeps a history (checkpoints) of each account's vote power. Vote power can be delegated either * by calling the {delegate} function directly, or by providing a signature to be used with {delegateBySig}. Voting * power can be queried through the public accessors {getVotes} and {getPastVotes}. * * By default, token balance does not account for voting power. This makes transfers cheaper. The downside is that it * requires users to delegate to themselves in order to activate checkpoints and have their voting power tracked. * * _Available since v4.2._ */ abstract contract ERC20Votes is IVotes, ERC20Permit { struct Checkpoint { uint32 fromBlock; uint224 votes; } bytes32 private constant _DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)"); mapping(address => address) private _delegates; mapping(address => Checkpoint[]) private _checkpoints; Checkpoint[] private _totalSupplyCheckpoints; /** * @dev Get the `pos`-th checkpoint for `account`. */ function checkpoints(address account, uint32 pos) public view virtual returns (Checkpoint memory) { return _checkpoints[account][pos]; } /** * @dev Get number of checkpoints for `account`. */ function numCheckpoints(address account) public view virtual returns (uint32) { return SafeCast.toUint32(_checkpoints[account].length); } /** * @dev Get the address `account` is currently delegating to. */ function delegates(address account) public view virtual override returns (address) { return _delegates[account]; } /** * @dev Gets the current votes balance for `account` */ function getVotes(address account) public view virtual override returns (uint256) { uint256 pos = _checkpoints[account].length; return pos == 0 ? 0 : _checkpoints[account][pos - 1].votes; } /** * @dev Retrieve the number of votes for `account` at the end of `blockNumber`. * * Requirements: * * - `blockNumber` must have been already mined */ function getPastVotes(address account, uint256 blockNumber) public view virtual override returns (uint256) { require(blockNumber < block.number, "ERC20Votes: block not yet mined"); return _checkpointsLookup(_checkpoints[account], blockNumber); } /** * @dev Retrieve the `totalSupply` at the end of `blockNumber`. Note, this value is the sum of all balances. * It is but NOT the sum of all the delegated votes! * * Requirements: * * - `blockNumber` must have been already mined */ function getPastTotalSupply(uint256 blockNumber) public view virtual override returns (uint256) { require(blockNumber < block.number, "ERC20Votes: block not yet mined"); return _checkpointsLookup(_totalSupplyCheckpoints, blockNumber); } /** * @dev Lookup a value in a list of (sorted) checkpoints. */ function _checkpointsLookup(Checkpoint[] storage ckpts, uint256 blockNumber) private view returns (uint256) { // We run a binary search to look for the earliest checkpoint taken after `blockNumber`. // // During the loop, the index of the wanted checkpoint remains in the range [low-1, high). // With each iteration, either `low` or `high` is moved towards the middle of the range to maintain the invariant. // - If the middle checkpoint is after `blockNumber`, we look in [low, mid) // - If the middle checkpoint is before or equal to `blockNumber`, we look in [mid+1, high) // Once we reach a single value (when low == high), we've found the right checkpoint at the index high-1, if not // out of bounds (in which case we're looking too far in the past and the result is 0). // Note that if the latest checkpoint available is exactly for `blockNumber`, we end up with an index that is // past the end of the array, so we technically don't find a checkpoint after `blockNumber`, but it works out // the same. uint256 high = ckpts.length; uint256 low = 0; while (low < high) { uint256 mid = Math.average(low, high); if (ckpts[mid].fromBlock > blockNumber) { high = mid; } else { low = mid + 1; } } return high == 0 ? 0 : ckpts[high - 1].votes; } /** * @dev Delegate votes from the sender to `delegatee`. */ function delegate(address delegatee) public virtual override { _delegate(_msgSender(), delegatee); } /** * @dev Delegates votes from signer to `delegatee` */ function delegateBySig( address delegatee, uint256 nonce, uint256 expiry, uint8 v, bytes32 r, bytes32 s ) public virtual override { require(block.timestamp <= expiry, "ERC20Votes: signature expired"); address signer = ECDSA.recover( _hashTypedDataV4(keccak256(abi.encode(_DELEGATION_TYPEHASH, delegatee, nonce, expiry))), v, r, s ); require(nonce == _useNonce(signer), "ERC20Votes: invalid nonce"); _delegate(signer, delegatee); } /** * @dev Maximum token supply. Defaults to `type(uint224).max` (2^224^ - 1). */ function _maxSupply() internal view virtual returns (uint224) { return type(uint224).max; } /** * @dev Snapshots the totalSupply after it has been increased. */ function _mint(address account, uint256 amount) internal virtual override { super._mint(account, amount); require(totalSupply() <= _maxSupply(), "ERC20Votes: total supply risks overflowing votes"); _writeCheckpoint(_totalSupplyCheckpoints, _add, amount); } /** * @dev Snapshots the totalSupply after it has been decreased. */ function _burn(address account, uint256 amount) internal virtual override { super._burn(account, amount); _writeCheckpoint(_totalSupplyCheckpoints, _subtract, amount); } /** * @dev Move voting power when tokens are transferred. * * Emits a {DelegateVotesChanged} event. */ function _afterTokenTransfer( address from, address to, uint256 amount ) internal virtual override { super._afterTokenTransfer(from, to, amount); _moveVotingPower(delegates(from), delegates(to), amount); } /** * @dev Change delegation for `delegator` to `delegatee`. * * Emits events {DelegateChanged} and {DelegateVotesChanged}. */ function _delegate(address delegator, address delegatee) internal virtual { address currentDelegate = delegates(delegator); uint256 delegatorBalance = balanceOf(delegator); _delegates[delegator] = delegatee; emit DelegateChanged(delegator, currentDelegate, delegatee); _moveVotingPower(currentDelegate, delegatee, delegatorBalance); } function _moveVotingPower( address src, address dst, uint256 amount ) private { if (src != dst && amount > 0) { if (src != address(0)) { (uint256 oldWeight, uint256 newWeight) = _writeCheckpoint(_checkpoints[src], _subtract, amount); emit DelegateVotesChanged(src, oldWeight, newWeight); } if (dst != address(0)) { (uint256 oldWeight, uint256 newWeight) = _writeCheckpoint(_checkpoints[dst], _add, amount); emit DelegateVotesChanged(dst, oldWeight, newWeight); } } } function _writeCheckpoint( Checkpoint[] storage ckpts, function(uint256, uint256) view returns (uint256) op, uint256 delta ) private returns (uint256 oldWeight, uint256 newWeight) { uint256 pos = ckpts.length; oldWeight = pos == 0 ? 0 : ckpts[pos - 1].votes; newWeight = op(oldWeight, delta); if (pos > 0 && ckpts[pos - 1].fromBlock == block.number) { ckpts[pos - 1].votes = SafeCast.toUint224(newWeight); } else { ckpts.push(Checkpoint({fromBlock: SafeCast.toUint32(block.number), votes: SafeCast.toUint224(newWeight)})); } } function _add(uint256 a, uint256 b) private pure returns (uint256) { return a + b; } function _subtract(uint256 a, uint256 b) private pure returns (uint256) { return a - b; } } // File: @openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/extensions/ERC20Burnable.sol) pragma solidity ^0.8.0; /** * @dev Extension of {ERC20} that allows token holders to destroy both their own * tokens and those that they have an allowance for, in a way that can be * recognized off-chain (via event analysis). */ abstract contract ERC20Burnable is Context, ERC20 { /** * @dev Destroys `amount` tokens from the caller. * * See {ERC20-_burn}. */ function burn(uint256 amount) public virtual { _burn(_msgSender(), amount); } /** * @dev Destroys `amount` tokens from `account`, deducting from the caller's * allowance. * * See {ERC20-_burn} and {ERC20-allowance}. * * Requirements: * * - the caller must have allowance for ``accounts``'s tokens of at least * `amount`. */ function burnFrom(address account, uint256 amount) public virtual { _spendAllowance(account, _msgSender(), amount); _burn(account, amount); } } // File: contracts/BopToken.sol pragma solidity ^0.8.4; /// @custom:security-contact [email protected] contract BopToken is ERC20, ERC20Burnable, ERC20Permit, ERC20Votes, Ownable { constructor() ERC20("BOP by MHGN", "BOP") ERC20Permit("BOP by MHGN") { _mint(msg.sender, 1200000000 * 10 ** decimals()); } // The following functions are overrides required by Solidity. function _afterTokenTransfer(address from, address to, uint256 amount) internal override(ERC20, ERC20Votes) { super._afterTokenTransfer(from, to, amount); } function _mint(address to, uint256 amount) internal override(ERC20, ERC20Votes) { super._mint(to, amount); } function _burn(address account, uint256 amount) internal override(ERC20, ERC20Votes) { super._burn(account, amount); } }
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":"delegator","type":"address"},{"indexed":true,"internalType":"address","name":"fromDelegate","type":"address"},{"indexed":true,"internalType":"address","name":"toDelegate","type":"address"}],"name":"DelegateChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegate","type":"address"},{"indexed":false,"internalType":"uint256","name":"previousBalance","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newBalance","type":"uint256"}],"name":"DelegateVotesChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","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":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint32","name":"pos","type":"uint32"}],"name":"checkpoints","outputs":[{"components":[{"internalType":"uint32","name":"fromBlock","type":"uint32"},{"internalType":"uint224","name":"votes","type":"uint224"}],"internalType":"struct ERC20Votes.Checkpoint","name":"","type":"tuple"}],"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":"delegatee","type":"address"}],"name":"delegate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"delegatee","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"delegateBySig","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"delegates","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"blockNumber","type":"uint256"}],"name":"getPastTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"blockNumber","type":"uint256"}],"name":"getPastVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"numCheckpoints","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Deployed Bytecode Sourcemap
101993:809:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;77251:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;79602:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;78371:108;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;80383:295;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;78213:93;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;90856:115;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;81087:238;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;94058:268;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;101267:91;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;93432:128;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;96531:114;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;93188:151;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;78542:127;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70674:103;;;:::i;:::-;;101677:164;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;90598:128;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70026:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;94615:259;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;77470:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;93644:212;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;81828:436;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;78875:193;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;96727:591;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;89887:645;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;79131:151;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;92958:150;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70932:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;77251:100;77305:13;77338:5;77331:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;77251:100;:::o;79602:201::-;79685:4;79702:13;79718:12;:10;:12::i;:::-;79702:28;;79741:32;79750:5;79757:7;79766:6;79741:8;:32::i;:::-;79791:4;79784:11;;;79602:201;;;;:::o;78371:108::-;78432:7;78459:12;;78452:19;;78371:108;:::o;80383:295::-;80514:4;80531:15;80549:12;:10;:12::i;:::-;80531:30;;80572:38;80588:4;80594:7;80603:6;80572:15;:38::i;:::-;80621:27;80631:4;80637:2;80641:6;80621:9;:27::i;:::-;80666:4;80659:11;;;80383:295;;;;;:::o;78213:93::-;78271:5;78296:2;78289:9;;78213:93;:::o;90856:115::-;90916:7;90943:20;:18;:20::i;:::-;90936:27;;90856:115;:::o;81087:238::-;81175:4;81192:13;81208:12;:10;:12::i;:::-;81192:28;;81231:64;81240:5;81247:7;81284:10;81256:25;81266:5;81273:7;81256:9;:25::i;:::-;:38;;;;:::i;:::-;81231:8;:64::i;:::-;81313:4;81306:11;;;81087:238;;;;:::o;94058:268::-;94156:7;94198:12;94184:11;:26;94176:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;94264:54;94283:12;:21;94296:7;94283:21;;;;;;;;;;;;;;;94306:11;94264:18;:54::i;:::-;94257:61;;94058:268;;;;:::o;101267:91::-;101323:27;101329:12;:10;:12::i;:::-;101343:6;101323:5;:27::i;:::-;101267:91;:::o;93432:128::-;93506:7;93533:10;:19;93544:7;93533:19;;;;;;;;;;;;;;;;;;;;;;;;;93526:26;;93432:128;;;:::o;96531:114::-;96603:34;96613:12;:10;:12::i;:::-;96627:9;96603;:34::i;:::-;96531:114;:::o;93188:151::-;93258:6;93284:47;93302:12;:21;93315:7;93302:21;;;;;;;;;;;;;;;:28;;;;93284:17;:47::i;:::-;93277:54;;93188:151;;;:::o;78542:127::-;78616:7;78643:9;:18;78653:7;78643:18;;;;;;;;;;;;;;;;78636:25;;78542:127;;;:::o;70674:103::-;69912:13;:11;:13::i;:::-;70739:30:::1;70766:1;70739:18;:30::i;:::-;70674:103::o:0;101677:164::-;101754:46;101770:7;101779:12;:10;:12::i;:::-;101793:6;101754:15;:46::i;:::-;101811:22;101817:7;101826:6;101811:5;:22::i;:::-;101677:164;;:::o;90598:128::-;90667:7;90694:24;:7;:14;90702:5;90694:14;;;;;;;;;;;;;;;:22;:24::i;:::-;90687:31;;90598:128;;;:::o;70026:87::-;70072:7;70099:6;;;;;;;;;;;70092:13;;70026:87;:::o;94615:259::-;94702:7;94744:12;94730:11;:26;94722:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;94810:56;94829:23;94854:11;94810:18;:56::i;:::-;94803:63;;94615:259;;;:::o;77470:104::-;77526:13;77559:7;77552:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;77470:104;:::o;93644:212::-;93717:7;93737:11;93751:12;:21;93764:7;93751:21;;;;;;;;;;;;;;;:28;;;;93737:42;;93804:1;93797:3;:8;:51;;93812:12;:21;93825:7;93812:21;;;;;;;;;;;;;;;93840:1;93834:3;:7;;;;:::i;:::-;93812:30;;;;;;;;:::i;:::-;;;;;;;;;:36;;;;;;;;;;;;93797:51;;;93808:1;93797:51;93790:58;;;;;93644:212;;;:::o;81828:436::-;81921:4;81938:13;81954:12;:10;:12::i;:::-;81938:28;;81977:24;82004:25;82014:5;82021:7;82004:9;:25::i;:::-;81977:52;;82068:15;82048:16;:35;;82040:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;82161:60;82170:5;82177:7;82205:15;82186:16;:34;82161:8;:60::i;:::-;82252:4;82245:11;;;;81828:436;;;;:::o;78875:193::-;78954:4;78971:13;78987:12;:10;:12::i;:::-;78971:28;;79010;79020:5;79027:2;79031:6;79010:9;:28::i;:::-;79056:4;79049:11;;;78875:193;;;;:::o;96727:591::-;96954:6;96935:15;:25;;96927:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;97005:14;97022:174;97050:87;92638:71;97110:9;97121:5;97128:6;97077:58;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;97067:69;;;;;;97050:16;:87::i;:::-;97152:1;97168;97184;97022:13;:174::i;:::-;97005:191;;97224:17;97234:6;97224:9;:17::i;:::-;97215:5;:26;97207:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;97282:28;97292:6;97300:9;97282;:28::i;:::-;96916:402;96727:591;;;;;;:::o;89887:645::-;90131:8;90112:15;:27;;90104:69;;;;;;;;;;;;:::i;:::-;;;;;;;;;90186:18;89062:95;90246:5;90253:7;90262:5;90269:16;90279:5;90269:9;:16::i;:::-;90287:8;90217:79;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;90207:90;;;;;;90186:111;;90310:12;90325:28;90342:10;90325:16;:28::i;:::-;90310:43;;90366:14;90383:28;90397:4;90403:1;90406;90409;90383:13;:28::i;:::-;90366:45;;90440:5;90430:15;;:6;:15;;;90422:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;90493:31;90502:5;90509:7;90518:5;90493:8;:31::i;:::-;90093:439;;;89887:645;;;;;;;:::o;79131:151::-;79220:7;79247:11;:18;79259:5;79247:18;;;;;;;;;;;;;;;:27;79266:7;79247:27;;;;;;;;;;;;;;;;79240:34;;79131:151;;;;:::o;92958:150::-;93037:17;;:::i;:::-;93074:12;:21;93087:7;93074:21;;;;;;;;;;;;;;;93096:3;93074:26;;;;;;;;;;:::i;:::-;;;;;;;;;93067:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92958:150;;;;:::o;70932:201::-;69912:13;:11;:13::i;:::-;71041:1:::1;71021:22;;:8;:22;;;;71013:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;71097:28;71116:8;71097:18;:28::i;:::-;70932:201:::0;:::o;97624:290::-;97709:28;97721:7;97730:6;97709:11;:28::i;:::-;97773:12;:10;:12::i;:::-;97756:29;;:13;:11;:13::i;:::-;:29;;97748:90;;;;;;;;;;;;:::i;:::-;;;;;;;;;97851:55;97868:23;97893:4;97899:6;97851:16;:55::i;:::-;;;97624:290;;:::o;83692:399::-;83795:1;83776:21;;:7;:21;;;;83768:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;83846:49;83875:1;83879:7;83888:6;83846:20;:49::i;:::-;83924:6;83908:12;;:22;;;;;;;:::i;:::-;;;;;;;;83963:6;83941:9;:18;83951:7;83941:18;;;;;;;;;;;;;;;;:28;;;;;;;:::i;:::-;;;;;;;;84006:7;83985:37;;84002:1;83985:37;;;84015:6;83985:37;;;;;;:::i;:::-;;;;;;;;84035:48;84063:1;84067:7;84076:6;84035:19;:48::i;:::-;83692:399;;:::o;100468:98::-;100526:7;100557:1;100553;:5;;;;:::i;:::-;100546:12;;100468:98;;;;:::o;2897:195::-;2954:7;2991:17;2982:26;;:5;:26;;2974:78;;;;;;;;;;;;:::i;:::-;;;;;;;;;3078:5;3063:21;;2897:195;;;:::o;15733:190::-;15789:6;15825:16;15816:25;;:5;:25;;15808:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;15909:5;15895:20;;15733:190;;;:::o;98342:262::-;98484:43;98510:4;98516:2;98520:6;98484:25;:43::i;:::-;98540:56;98557:15;98567:4;98557:9;:15::i;:::-;98574:13;98584:2;98574:9;:13::i;:::-;98589:6;98540:16;:56::i;:::-;98342:262;;;:::o;87906:124::-;;;;:::o;100574:103::-;100637:7;100668:1;100664;:5;;;;:::i;:::-;100657:12;;100574:103;;;;:::o;68577:98::-;68630:7;68657:10;68650:17;;68577:98;:::o;85453:380::-;85606:1;85589:19;;:5;:19;;;;85581:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;85687:1;85668:21;;:7;:21;;;;85660:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;85771:6;85741:11;:18;85753:5;85741:18;;;;;;;;;;;;;;;:27;85760:7;85741:27;;;;;;;;;;;;;;;:36;;;;85809:7;85793:32;;85802:5;85793:32;;;85818:6;85793:32;;;;;;:::i;:::-;;;;;;;;85453:380;;;:::o;86124:453::-;86259:24;86286:25;86296:5;86303:7;86286:9;:25::i;:::-;86259:52;;86346:17;86326:16;:37;86322:248;;86408:6;86388:16;:26;;86380:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;86492:51;86501:5;86508:7;86536:6;86517:16;:25;86492:8;:51::i;:::-;86322:248;86248:329;86124:453;;;:::o;82734:671::-;82881:1;82865:18;;:4;:18;;;;82857:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;82958:1;82944:16;;:2;:16;;;;82936:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;83013:38;83034:4;83040:2;83044:6;83013:20;:38::i;:::-;83064:19;83086:9;:15;83096:4;83086:15;;;;;;;;;;;;;;;;83064:37;;83135:6;83120:11;:21;;83112:72;;;;;;;;;;;;:::i;:::-;;;;;;;;;83252:6;83238:11;:20;83220:9;:15;83230:4;83220:15;;;;;;;;;;;;;;;:38;;;;83297:6;83280:9;:13;83290:2;83280:13;;;;;;;;;;;;;;;;:23;;;;;;;:::i;:::-;;;;;;;;83336:2;83321:26;;83330:4;83321:26;;;83340:6;83321:26;;;;;;:::i;:::-;;;;;;;;83360:37;83380:4;83386:2;83390:6;83360:19;:37::i;:::-;82846:559;82734:671;;;:::o;64132:314::-;64185:7;64226:12;64209:29;;64217:4;64209:29;;;:66;;;;;64259:16;64242:13;:33;64209:66;64205:234;;;64299:24;64292:31;;;;64205:234;64363:64;64385:10;64397:12;64411:15;64363:21;:64::i;:::-;64356:71;;64132:314;;:::o;94963:1482::-;95062:7;96081:12;96096:5;:12;;;;96081:27;;96119:11;96145:236;96158:4;96152:3;:10;96145:236;;;96179:11;96193:23;96206:3;96211:4;96193:12;:23::i;:::-;96179:37;;96258:11;96235:5;96241:3;96235:10;;;;;;;;:::i;:::-;;;;;;;;;:20;;;;;;;;;;;;:34;;;96231:139;;;96297:3;96290:10;;96231:139;;;96353:1;96347:3;:7;;;;:::i;:::-;96341:13;;96231:139;96164:217;96145:236;;;96408:1;96400:4;:9;:37;;96416:5;96429:1;96422:4;:8;;;;:::i;:::-;96416:15;;;;;;;;:::i;:::-;;;;;;;;;:21;;;;;;;;;;;;96400:37;;;96412:1;96400:37;96393:44;;;;;;94963:1482;;;;:::o;102644:155::-;102763:28;102775:7;102784:6;102763:11;:28::i;:::-;102644:155;;:::o;98768:388::-;98853:23;98879:20;98889:9;98879;:20::i;:::-;98853:46;;98910:24;98937:20;98947:9;98937;:20::i;:::-;98910:47;;98992:9;98968:10;:21;98979:9;98968:21;;;;;;;;;;;;;;;;:33;;;;;;;;;;;;;;;;;;99063:9;99019:54;;99046:15;99019:54;;99035:9;99019:54;;;;;;;;;;;;99086:62;99103:15;99120:9;99131:16;99086;:62::i;:::-;98842:314;;98768:388;;:::o;70191:132::-;70266:12;:10;:12::i;:::-;70255:23;;:7;:5;:7::i;:::-;:23;;;70247:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;70191:132::o;71293:191::-;71367:16;71386:6;;;;;;;;;;;71367:25;;71412:8;71403:6;;:17;;;;;;;;;;;;;;;;;;71467:8;71436:40;;71457:8;71436:40;;;;;;;;;;;;71356:128;71293:191;:::o;48839:114::-;48904:7;48931;:14;;;48924:21;;48839:114;;;:::o;65359:167::-;65436:7;65463:55;65485:20;:18;:20::i;:::-;65507:10;65463:21;:55::i;:::-;65456:62;;65359:167;;;:::o;59008:279::-;59136:7;59157:17;59176:18;59198:25;59209:4;59215:1;59218;59221;59198:10;:25::i;:::-;59156:67;;;;59234:18;59246:5;59234:11;:18::i;:::-;59270:9;59263:16;;;;59008:279;;;;;;:::o;91109:207::-;91169:15;91197:30;91230:7;:14;91238:5;91230:14;;;;;;;;;;;;;;;91197:47;;91265:15;:5;:13;:15::i;:::-;91255:25;;91291:17;:5;:15;:17::i;:::-;91186:130;91109:207;;;:::o;97425:105::-;97478:7;97505:17;97498:24;;97425:105;:::o;99815:645::-;99989:17;100008;100038:11;100052:5;:12;;;;100038:26;;100094:1;100087:3;:8;:35;;100102:5;100114:1;100108:3;:7;;;;:::i;:::-;100102:14;;;;;;;;:::i;:::-;;;;;;;;;:20;;;;;;;;;;;;100087:35;;;100098:1;100087:35;100075:47;;;;100145:20;100148:9;100159:5;100145:2;:20;;:::i;:::-;100133:32;;100188:1;100182:3;:7;:51;;;;;100221:12;100193:5;100205:1;100199:3;:7;;;;:::i;:::-;100193:14;;;;;;;;:::i;:::-;;;;;;;;;:24;;;;;;;;;;;;:40;;;100182:51;100178:275;;;100273:29;100292:9;100273:18;:29::i;:::-;100250:5;100262:1;100256:3;:7;;;;:::i;:::-;100250:14;;;;;;;;:::i;:::-;;;;;;;;;:20;;;:52;;;;;;;;;;;;;;;;;;100178:275;;;100335:5;100346:94;;;;;;;;100369:31;100387:12;100369:17;:31::i;:::-;100346:94;;;;;;100409:29;100428:9;100409:18;:29::i;:::-;100346:94;;;;;100335:106;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;100178:275;100027:433;99815:645;;;;;;:::o;87177:125::-;;;;:::o;102290:193::-;102432:43;102458:4;102464:2;102468:6;102432:25;:43::i;:::-;102290:193;;;:::o;99164:643::-;99296:3;99289:10;;:3;:10;;;;:24;;;;;99312:1;99303:6;:10;99289:24;99285:515;;;99349:1;99334:17;;:3;:17;;;99330:224;;99373:17;99392;99413:54;99430:12;:17;99443:3;99430:17;;;;;;;;;;;;;;;99449:9;99460:6;99413:16;:54::i;:::-;99372:95;;;;99512:3;99491:47;;;99517:9;99528;99491:47;;;;;;;:::i;:::-;;;;;;;;99353:201;;99330:224;99589:1;99574:17;;:3;:17;;;99570:219;;99613:17;99632;99653:49;99670:12;:17;99683:3;99670:17;;;;;;;;;;;;;;;99689:4;99695:6;99653:16;:49::i;:::-;99612:90;;;;99747:3;99726:47;;;99752:9;99763;99726:47;;;;;;;:::i;:::-;;;;;;;;99593:196;;99570:219;99285:515;99164:643;;;:::o;64454:263::-;64598:7;64646:8;64656;64666:11;64679:13;64702:4;64635:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;64625:84;;;;;;64618:91;;64454:263;;;;;:::o;39751:156::-;39813:7;39898:1;39893;39889;:5;39888:11;;;;:::i;:::-;39883:1;39879;:5;39878:21;;;;:::i;:::-;39871:28;;39751:156;;;;:::o;98008:194::-;98093:28;98105:7;98114:6;98093:11;:28::i;:::-;98134:60;98151:23;98176:9;98187:6;98134:16;:60::i;:::-;;;98008:194;;:::o;60699:196::-;60792:7;60858:15;60875:10;60829:57;;;;;;;;;:::i;:::-;;;;;;;;;;;;;60819:68;;;;;;60812:75;;60699:196;;;;:::o;57237:1632::-;57368:7;57377:12;58302:66;58297:1;58289:10;;:79;58285:163;;;58401:1;58405:30;58385:51;;;;;;58285:163;58467:2;58462:1;:7;;;;:18;;;;;58478:2;58473:1;:7;;;;58462:18;58458:102;;;58513:1;58517:30;58497:51;;;;;;58458:102;58657:14;58674:24;58684:4;58690:1;58693;58696;58674:24;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58657:41;;58731:1;58713:20;;:6;:20;;;58709:103;;;58766:1;58770:29;58750:50;;;;;;;58709:103;58832:6;58840:20;58824:37;;;;;57237:1632;;;;;;;;:::o;52507:643::-;52585:20;52576:29;;;;;;;;:::i;:::-;;:5;:29;;;;;;;;:::i;:::-;;;52572:571;;;52622:7;;52572:571;52683:29;52674:38;;;;;;;;:::i;:::-;;:5;:38;;;;;;;;:::i;:::-;;;52670:473;;;52729:34;;;;;;;;;;:::i;:::-;;;;;;;;52670:473;52794:35;52785:44;;;;;;;;:::i;:::-;;:5;:44;;;;;;;;:::i;:::-;;;52781:362;;;52846:41;;;;;;;;;;:::i;:::-;;;;;;;;52781:362;52918:30;52909:39;;;;;;;;:::i;:::-;;:5;:39;;;;;;;;:::i;:::-;;;52905:238;;;52965:44;;;;;;;;;;:::i;:::-;;;;;;;;52905:238;53040:30;53031:39;;;;;;;;:::i;:::-;;:5;:39;;;;;;;;:::i;:::-;;;53027:116;;;53087:44;;;;;;;;;;:::i;:::-;;;;;;;;53027:116;52507:643;;:::o;48961:127::-;49068:1;49050:7;:14;;;:19;;;;;;;;;;;48961:127;:::o;84424:591::-;84527:1;84508:21;;:7;:21;;;;84500:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;84580:49;84601:7;84618:1;84622:6;84580:20;:49::i;:::-;84642:22;84667:9;:18;84677:7;84667:18;;;;;;;;;;;;;;;;84642:43;;84722:6;84704:14;:24;;84696:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;84841:6;84824:14;:23;84803:9;:18;84813:7;84803:18;;;;;;;;;;;;;;;:44;;;;84885:6;84869:12;;:22;;;;;;;:::i;:::-;;;;;;;;84935:1;84909:37;;84918:7;84909:37;;;84939:6;84909:37;;;;;;:::i;:::-;;;;;;;;84959:48;84979:7;84996:1;85000:6;84959:19;:48::i;:::-;84489:526;84424:591;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;:::o;7:139:1:-;53:5;91:6;78:20;69:29;;107:33;134:5;107:33;:::i;:::-;7:139;;;;:::o;152:::-;198:5;236:6;223:20;214:29;;252:33;279:5;252:33;:::i;:::-;152:139;;;;:::o;297:::-;343:5;381:6;368:20;359:29;;397:33;424:5;397:33;:::i;:::-;297:139;;;;:::o;442:137::-;487:5;525:6;512:20;503:29;;541:32;567:5;541:32;:::i;:::-;442:137;;;;:::o;585:135::-;629:5;667:6;654:20;645:29;;683:31;708:5;683:31;:::i;:::-;585:135;;;;:::o;726:329::-;785:6;834:2;822:9;813:7;809:23;805:32;802:119;;;840:79;;:::i;:::-;802:119;960:1;985:53;1030:7;1021:6;1010:9;1006:22;985:53;:::i;:::-;975:63;;931:117;726:329;;;;:::o;1061:474::-;1129:6;1137;1186:2;1174:9;1165:7;1161:23;1157:32;1154:119;;;1192:79;;:::i;:::-;1154:119;1312:1;1337:53;1382:7;1373:6;1362:9;1358:22;1337:53;:::i;:::-;1327:63;;1283:117;1439:2;1465:53;1510:7;1501:6;1490:9;1486:22;1465:53;:::i;:::-;1455:63;;1410:118;1061:474;;;;;:::o;1541:619::-;1618:6;1626;1634;1683:2;1671:9;1662:7;1658:23;1654:32;1651:119;;;1689:79;;:::i;:::-;1651:119;1809:1;1834:53;1879:7;1870:6;1859:9;1855:22;1834:53;:::i;:::-;1824:63;;1780:117;1936:2;1962:53;2007:7;1998:6;1987:9;1983:22;1962:53;:::i;:::-;1952:63;;1907:118;2064:2;2090:53;2135:7;2126:6;2115:9;2111:22;2090:53;:::i;:::-;2080:63;;2035:118;1541:619;;;;;:::o;2166:1199::-;2277:6;2285;2293;2301;2309;2317;2325;2374:3;2362:9;2353:7;2349:23;2345:33;2342:120;;;2381:79;;:::i;:::-;2342:120;2501:1;2526:53;2571:7;2562:6;2551:9;2547:22;2526:53;:::i;:::-;2516:63;;2472:117;2628:2;2654:53;2699:7;2690:6;2679:9;2675:22;2654:53;:::i;:::-;2644:63;;2599:118;2756:2;2782:53;2827:7;2818:6;2807:9;2803:22;2782:53;:::i;:::-;2772:63;;2727:118;2884:2;2910:53;2955:7;2946:6;2935:9;2931:22;2910:53;:::i;:::-;2900:63;;2855:118;3012:3;3039:51;3082:7;3073:6;3062:9;3058:22;3039:51;:::i;:::-;3029:61;;2983:117;3139:3;3166:53;3211:7;3202:6;3191:9;3187:22;3166:53;:::i;:::-;3156:63;;3110:119;3268:3;3295:53;3340:7;3331:6;3320:9;3316:22;3295:53;:::i;:::-;3285:63;;3239:119;2166:1199;;;;;;;;;;:::o;3371:474::-;3439:6;3447;3496:2;3484:9;3475:7;3471:23;3467:32;3464:119;;;3502:79;;:::i;:::-;3464:119;3622:1;3647:53;3692:7;3683:6;3672:9;3668:22;3647:53;:::i;:::-;3637:63;;3593:117;3749:2;3775:53;3820:7;3811:6;3800:9;3796:22;3775:53;:::i;:::-;3765:63;;3720:118;3371:474;;;;;:::o;3851:1053::-;3953:6;3961;3969;3977;3985;3993;4042:3;4030:9;4021:7;4017:23;4013:33;4010:120;;;4049:79;;:::i;:::-;4010:120;4169:1;4194:53;4239:7;4230:6;4219:9;4215:22;4194:53;:::i;:::-;4184:63;;4140:117;4296:2;4322:53;4367:7;4358:6;4347:9;4343:22;4322:53;:::i;:::-;4312:63;;4267:118;4424:2;4450:53;4495:7;4486:6;4475:9;4471:22;4450:53;:::i;:::-;4440:63;;4395:118;4552:2;4578:51;4621:7;4612:6;4601:9;4597:22;4578:51;:::i;:::-;4568:61;;4523:116;4678:3;4705:53;4750:7;4741:6;4730:9;4726:22;4705:53;:::i;:::-;4695:63;;4649:119;4807:3;4834:53;4879:7;4870:6;4859:9;4855:22;4834:53;:::i;:::-;4824:63;;4778:119;3851:1053;;;;;;;;:::o;4910:472::-;4977:6;4985;5034:2;5022:9;5013:7;5009:23;5005:32;5002:119;;;5040:79;;:::i;:::-;5002:119;5160:1;5185:53;5230:7;5221:6;5210:9;5206:22;5185:53;:::i;:::-;5175:63;;5131:117;5287:2;5313:52;5357:7;5348:6;5337:9;5333:22;5313:52;:::i;:::-;5303:62;;5258:117;4910:472;;;;;:::o;5388:329::-;5447:6;5496:2;5484:9;5475:7;5471:23;5467:32;5464:119;;;5502:79;;:::i;:::-;5464:119;5622:1;5647:53;5692:7;5683:6;5672:9;5668:22;5647:53;:::i;:::-;5637:63;;5593:117;5388:329;;;;:::o;5723:118::-;5810:24;5828:5;5810:24;:::i;:::-;5805:3;5798:37;5723:118;;:::o;5847:109::-;5928:21;5943:5;5928:21;:::i;:::-;5923:3;5916:34;5847:109;;:::o;5962:118::-;6049:24;6067:5;6049:24;:::i;:::-;6044:3;6037:37;5962:118;;:::o;6086:157::-;6191:45;6211:24;6229:5;6211:24;:::i;:::-;6191:45;:::i;:::-;6186:3;6179:58;6086:157;;:::o;6249:364::-;6337:3;6365:39;6398:5;6365:39;:::i;:::-;6420:71;6484:6;6479:3;6420:71;:::i;:::-;6413:78;;6500:52;6545:6;6540:3;6533:4;6526:5;6522:16;6500:52;:::i;:::-;6577:29;6599:6;6577:29;:::i;:::-;6572:3;6568:39;6561:46;;6341:272;6249:364;;;;:::o;6619:366::-;6761:3;6782:67;6846:2;6841:3;6782:67;:::i;:::-;6775:74;;6858:93;6947:3;6858:93;:::i;:::-;6976:2;6971:3;6967:12;6960:19;;6619:366;;;:::o;6991:::-;7133:3;7154:67;7218:2;7213:3;7154:67;:::i;:::-;7147:74;;7230:93;7319:3;7230:93;:::i;:::-;7348:2;7343:3;7339:12;7332:19;;6991:366;;;:::o;7363:::-;7505:3;7526:67;7590:2;7585:3;7526:67;:::i;:::-;7519:74;;7602:93;7691:3;7602:93;:::i;:::-;7720:2;7715:3;7711:12;7704:19;;7363:366;;;:::o;7735:::-;7877:3;7898:67;7962:2;7957:3;7898:67;:::i;:::-;7891:74;;7974:93;8063:3;7974:93;:::i;:::-;8092:2;8087:3;8083:12;8076:19;;7735:366;;;:::o;8107:::-;8249:3;8270:67;8334:2;8329:3;8270:67;:::i;:::-;8263:74;;8346:93;8435:3;8346:93;:::i;:::-;8464:2;8459:3;8455:12;8448:19;;8107:366;;;:::o;8479:::-;8621:3;8642:67;8706:2;8701:3;8642:67;:::i;:::-;8635:74;;8718:93;8807:3;8718:93;:::i;:::-;8836:2;8831:3;8827:12;8820:19;;8479:366;;;:::o;8851:::-;8993:3;9014:67;9078:2;9073:3;9014:67;:::i;:::-;9007:74;;9090:93;9179:3;9090:93;:::i;:::-;9208:2;9203:3;9199:12;9192:19;;8851:366;;;:::o;9223:::-;9365:3;9386:67;9450:2;9445:3;9386:67;:::i;:::-;9379:74;;9462:93;9551:3;9462:93;:::i;:::-;9580:2;9575:3;9571:12;9564:19;;9223:366;;;:::o;9595:::-;9737:3;9758:67;9822:2;9817:3;9758:67;:::i;:::-;9751:74;;9834:93;9923:3;9834:93;:::i;:::-;9952:2;9947:3;9943:12;9936:19;;9595:366;;;:::o;9967:400::-;10127:3;10148:84;10230:1;10225:3;10148:84;:::i;:::-;10141:91;;10241:93;10330:3;10241:93;:::i;:::-;10359:1;10354:3;10350:11;10343:18;;9967:400;;;:::o;10373:366::-;10515:3;10536:67;10600:2;10595:3;10536:67;:::i;:::-;10529:74;;10612:93;10701:3;10612:93;:::i;:::-;10730:2;10725:3;10721:12;10714:19;;10373:366;;;:::o;10745:::-;10887:3;10908:67;10972:2;10967:3;10908:67;:::i;:::-;10901:74;;10984:93;11073:3;10984:93;:::i;:::-;11102:2;11097:3;11093:12;11086:19;;10745:366;;;:::o;11117:::-;11259:3;11280:67;11344:2;11339:3;11280:67;:::i;:::-;11273:74;;11356:93;11445:3;11356:93;:::i;:::-;11474:2;11469:3;11465:12;11458:19;;11117:366;;;:::o;11489:::-;11631:3;11652:67;11716:2;11711:3;11652:67;:::i;:::-;11645:74;;11728:93;11817:3;11728:93;:::i;:::-;11846:2;11841:3;11837:12;11830:19;;11489:366;;;:::o;11861:::-;12003:3;12024:67;12088:2;12083:3;12024:67;:::i;:::-;12017:74;;12100:93;12189:3;12100:93;:::i;:::-;12218:2;12213:3;12209:12;12202:19;;11861:366;;;:::o;12233:::-;12375:3;12396:67;12460:2;12455:3;12396:67;:::i;:::-;12389:74;;12472:93;12561:3;12472:93;:::i;:::-;12590:2;12585:3;12581:12;12574:19;;12233:366;;;:::o;12605:::-;12747:3;12768:67;12832:2;12827:3;12768:67;:::i;:::-;12761:74;;12844:93;12933:3;12844:93;:::i;:::-;12962:2;12957:3;12953:12;12946:19;;12605:366;;;:::o;12977:::-;13119:3;13140:67;13204:2;13199:3;13140:67;:::i;:::-;13133:74;;13216:93;13305:3;13216:93;:::i;:::-;13334:2;13329:3;13325:12;13318:19;;12977:366;;;:::o;13349:::-;13491:3;13512:67;13576:2;13571:3;13512:67;:::i;:::-;13505:74;;13588:93;13677:3;13588:93;:::i;:::-;13706:2;13701:3;13697:12;13690:19;;13349:366;;;:::o;13721:::-;13863:3;13884:67;13948:2;13943:3;13884:67;:::i;:::-;13877:74;;13960:93;14049:3;13960:93;:::i;:::-;14078:2;14073:3;14069:12;14062:19;;13721:366;;;:::o;14093:::-;14235:3;14256:67;14320:2;14315:3;14256:67;:::i;:::-;14249:74;;14332:93;14421:3;14332:93;:::i;:::-;14450:2;14445:3;14441:12;14434:19;;14093:366;;;:::o;14465:::-;14607:3;14628:67;14692:2;14687:3;14628:67;:::i;:::-;14621:74;;14704:93;14793:3;14704:93;:::i;:::-;14822:2;14817:3;14813:12;14806:19;;14465:366;;;:::o;14837:::-;14979:3;15000:67;15064:2;15059:3;15000:67;:::i;:::-;14993:74;;15076:93;15165:3;15076:93;:::i;:::-;15194:2;15189:3;15185:12;15178:19;;14837:366;;;:::o;15209:::-;15351:3;15372:67;15436:2;15431:3;15372:67;:::i;:::-;15365:74;;15448:93;15537:3;15448:93;:::i;:::-;15566:2;15561:3;15557:12;15550:19;;15209:366;;;:::o;15581:::-;15723:3;15744:67;15808:2;15803:3;15744:67;:::i;:::-;15737:74;;15820:93;15909:3;15820:93;:::i;:::-;15938:2;15933:3;15929:12;15922:19;;15581:366;;;:::o;16021:517::-;16174:4;16169:3;16165:14;16266:4;16259:5;16255:16;16249:23;16285:61;16340:4;16335:3;16331:14;16317:12;16285:61;:::i;:::-;16189:167;16439:4;16432:5;16428:16;16422:23;16458:63;16515:4;16510:3;16506:14;16492:12;16458:63;:::i;:::-;16366:165;16143:395;16021:517;;:::o;16544:108::-;16621:24;16639:5;16621:24;:::i;:::-;16616:3;16609:37;16544:108;;:::o;16658:118::-;16745:24;16763:5;16745:24;:::i;:::-;16740:3;16733:37;16658:118;;:::o;16782:105::-;16857:23;16874:5;16857:23;:::i;:::-;16852:3;16845:36;16782:105;;:::o;16893:115::-;16978:23;16995:5;16978:23;:::i;:::-;16973:3;16966:36;16893:115;;:::o;17014:112::-;17097:22;17113:5;17097:22;:::i;:::-;17092:3;17085:35;17014:112;;:::o;17132:663::-;17373:3;17395:148;17539:3;17395:148;:::i;:::-;17388:155;;17553:75;17624:3;17615:6;17553:75;:::i;:::-;17653:2;17648:3;17644:12;17637:19;;17666:75;17737:3;17728:6;17666:75;:::i;:::-;17766:2;17761:3;17757:12;17750:19;;17786:3;17779:10;;17132:663;;;;;:::o;17801:222::-;17894:4;17932:2;17921:9;17917:18;17909:26;;17945:71;18013:1;18002:9;17998:17;17989:6;17945:71;:::i;:::-;17801:222;;;;:::o;18029:210::-;18116:4;18154:2;18143:9;18139:18;18131:26;;18167:65;18229:1;18218:9;18214:17;18205:6;18167:65;:::i;:::-;18029:210;;;;:::o;18245:222::-;18338:4;18376:2;18365:9;18361:18;18353:26;;18389:71;18457:1;18446:9;18442:17;18433:6;18389:71;:::i;:::-;18245:222;;;;:::o;18473:775::-;18706:4;18744:3;18733:9;18729:19;18721:27;;18758:71;18826:1;18815:9;18811:17;18802:6;18758:71;:::i;:::-;18839:72;18907:2;18896:9;18892:18;18883:6;18839:72;:::i;:::-;18921;18989:2;18978:9;18974:18;18965:6;18921:72;:::i;:::-;19003;19071:2;19060:9;19056:18;19047:6;19003:72;:::i;:::-;19085:73;19153:3;19142:9;19138:19;19129:6;19085:73;:::i;:::-;19168;19236:3;19225:9;19221:19;19212:6;19168:73;:::i;:::-;18473:775;;;;;;;;;:::o;19254:553::-;19431:4;19469:3;19458:9;19454:19;19446:27;;19483:71;19551:1;19540:9;19536:17;19527:6;19483:71;:::i;:::-;19564:72;19632:2;19621:9;19617:18;19608:6;19564:72;:::i;:::-;19646;19714:2;19703:9;19699:18;19690:6;19646:72;:::i;:::-;19728;19796:2;19785:9;19781:18;19772:6;19728:72;:::i;:::-;19254:553;;;;;;;:::o;19813:664::-;20018:4;20056:3;20045:9;20041:19;20033:27;;20070:71;20138:1;20127:9;20123:17;20114:6;20070:71;:::i;:::-;20151:72;20219:2;20208:9;20204:18;20195:6;20151:72;:::i;:::-;20233;20301:2;20290:9;20286:18;20277:6;20233:72;:::i;:::-;20315;20383:2;20372:9;20368:18;20359:6;20315:72;:::i;:::-;20397:73;20465:3;20454:9;20450:19;20441:6;20397:73;:::i;:::-;19813:664;;;;;;;;:::o;20483:545::-;20656:4;20694:3;20683:9;20679:19;20671:27;;20708:71;20776:1;20765:9;20761:17;20752:6;20708:71;:::i;:::-;20789:68;20853:2;20842:9;20838:18;20829:6;20789:68;:::i;:::-;20867:72;20935:2;20924:9;20920:18;20911:6;20867:72;:::i;:::-;20949;21017:2;21006:9;21002:18;20993:6;20949:72;:::i;:::-;20483:545;;;;;;;:::o;21034:313::-;21147:4;21185:2;21174:9;21170:18;21162:26;;21234:9;21228:4;21224:20;21220:1;21209:9;21205:17;21198:47;21262:78;21335:4;21326:6;21262:78;:::i;:::-;21254:86;;21034:313;;;;:::o;21353:419::-;21519:4;21557:2;21546:9;21542:18;21534:26;;21606:9;21600:4;21596:20;21592:1;21581:9;21577:17;21570:47;21634:131;21760:4;21634:131;:::i;:::-;21626:139;;21353:419;;;:::o;21778:::-;21944:4;21982:2;21971:9;21967:18;21959:26;;22031:9;22025:4;22021:20;22017:1;22006:9;22002:17;21995:47;22059:131;22185:4;22059:131;:::i;:::-;22051:139;;21778:419;;;:::o;22203:::-;22369:4;22407:2;22396:9;22392:18;22384:26;;22456:9;22450:4;22446:20;22442:1;22431:9;22427:17;22420:47;22484:131;22610:4;22484:131;:::i;:::-;22476:139;;22203:419;;;:::o;22628:::-;22794:4;22832:2;22821:9;22817:18;22809:26;;22881:9;22875:4;22871:20;22867:1;22856:9;22852:17;22845:47;22909:131;23035:4;22909:131;:::i;:::-;22901:139;;22628:419;;;:::o;23053:::-;23219:4;23257:2;23246:9;23242:18;23234:26;;23306:9;23300:4;23296:20;23292:1;23281:9;23277:17;23270:47;23334:131;23460:4;23334:131;:::i;:::-;23326:139;;23053:419;;;:::o;23478:::-;23644:4;23682:2;23671:9;23667:18;23659:26;;23731:9;23725:4;23721:20;23717:1;23706:9;23702:17;23695:47;23759:131;23885:4;23759:131;:::i;:::-;23751:139;;23478:419;;;:::o;23903:::-;24069:4;24107:2;24096:9;24092:18;24084:26;;24156:9;24150:4;24146:20;24142:1;24131:9;24127:17;24120:47;24184:131;24310:4;24184:131;:::i;:::-;24176:139;;23903:419;;;:::o;24328:::-;24494:4;24532:2;24521:9;24517:18;24509:26;;24581:9;24575:4;24571:20;24567:1;24556:9;24552:17;24545:47;24609:131;24735:4;24609:131;:::i;:::-;24601:139;;24328:419;;;:::o;24753:::-;24919:4;24957:2;24946:9;24942:18;24934:26;;25006:9;25000:4;24996:20;24992:1;24981:9;24977:17;24970:47;25034:131;25160:4;25034:131;:::i;:::-;25026:139;;24753:419;;;:::o;25178:::-;25344:4;25382:2;25371:9;25367:18;25359:26;;25431:9;25425:4;25421:20;25417:1;25406:9;25402:17;25395:47;25459:131;25585:4;25459:131;:::i;:::-;25451:139;;25178:419;;;:::o;25603:::-;25769:4;25807:2;25796:9;25792:18;25784:26;;25856:9;25850:4;25846:20;25842:1;25831:9;25827:17;25820:47;25884:131;26010:4;25884:131;:::i;:::-;25876:139;;25603:419;;;:::o;26028:::-;26194:4;26232:2;26221:9;26217:18;26209:26;;26281:9;26275:4;26271:20;26267:1;26256:9;26252:17;26245:47;26309:131;26435:4;26309:131;:::i;:::-;26301:139;;26028:419;;;:::o;26453:::-;26619:4;26657:2;26646:9;26642:18;26634:26;;26706:9;26700:4;26696:20;26692:1;26681:9;26677:17;26670:47;26734:131;26860:4;26734:131;:::i;:::-;26726:139;;26453:419;;;:::o;26878:::-;27044:4;27082:2;27071:9;27067:18;27059:26;;27131:9;27125:4;27121:20;27117:1;27106:9;27102:17;27095:47;27159:131;27285:4;27159:131;:::i;:::-;27151:139;;26878:419;;;:::o;27303:::-;27469:4;27507:2;27496:9;27492:18;27484:26;;27556:9;27550:4;27546:20;27542:1;27531:9;27527:17;27520:47;27584:131;27710:4;27584:131;:::i;:::-;27576:139;;27303:419;;;:::o;27728:::-;27894:4;27932:2;27921:9;27917:18;27909:26;;27981:9;27975:4;27971:20;27967:1;27956:9;27952:17;27945:47;28009:131;28135:4;28009:131;:::i;:::-;28001:139;;27728:419;;;:::o;28153:::-;28319:4;28357:2;28346:9;28342:18;28334:26;;28406:9;28400:4;28396:20;28392:1;28381:9;28377:17;28370:47;28434:131;28560:4;28434:131;:::i;:::-;28426:139;;28153:419;;;:::o;28578:::-;28744:4;28782:2;28771:9;28767:18;28759:26;;28831:9;28825:4;28821:20;28817:1;28806:9;28802:17;28795:47;28859:131;28985:4;28859:131;:::i;:::-;28851:139;;28578:419;;;:::o;29003:::-;29169:4;29207:2;29196:9;29192:18;29184:26;;29256:9;29250:4;29246:20;29242:1;29231:9;29227:17;29220:47;29284:131;29410:4;29284:131;:::i;:::-;29276:139;;29003:419;;;:::o;29428:::-;29594:4;29632:2;29621:9;29617:18;29609:26;;29681:9;29675:4;29671:20;29667:1;29656:9;29652:17;29645:47;29709:131;29835:4;29709:131;:::i;:::-;29701:139;;29428:419;;;:::o;29853:::-;30019:4;30057:2;30046:9;30042:18;30034:26;;30106:9;30100:4;30096:20;30092:1;30081:9;30077:17;30070:47;30134:131;30260:4;30134:131;:::i;:::-;30126:139;;29853:419;;;:::o;30278:::-;30444:4;30482:2;30471:9;30467:18;30459:26;;30531:9;30525:4;30521:20;30517:1;30506:9;30502:17;30495:47;30559:131;30685:4;30559:131;:::i;:::-;30551:139;;30278:419;;;:::o;30703:::-;30869:4;30907:2;30896:9;30892:18;30884:26;;30956:9;30950:4;30946:20;30942:1;30931:9;30927:17;30920:47;30984:131;31110:4;30984:131;:::i;:::-;30976:139;;30703:419;;;:::o;31128:::-;31294:4;31332:2;31321:9;31317:18;31309:26;;31381:9;31375:4;31371:20;31367:1;31356:9;31352:17;31345:47;31409:131;31535:4;31409:131;:::i;:::-;31401:139;;31128:419;;;:::o;31553:334::-;31702:4;31740:2;31729:9;31725:18;31717:26;;31753:127;31877:1;31866:9;31862:17;31853:6;31753:127;:::i;:::-;31553:334;;;;:::o;31893:222::-;31986:4;32024:2;32013:9;32009:18;32001:26;;32037:71;32105:1;32094:9;32090:17;32081:6;32037:71;:::i;:::-;31893:222;;;;:::o;32121:332::-;32242:4;32280:2;32269:9;32265:18;32257:26;;32293:71;32361:1;32350:9;32346:17;32337:6;32293:71;:::i;:::-;32374:72;32442:2;32431:9;32427:18;32418:6;32374:72;:::i;:::-;32121:332;;;;;:::o;32459:218::-;32550:4;32588:2;32577:9;32573:18;32565:26;;32601:69;32667:1;32656:9;32652:17;32643:6;32601:69;:::i;:::-;32459:218;;;;:::o;32683:214::-;32772:4;32810:2;32799:9;32795:18;32787:26;;32823:67;32887:1;32876:9;32872:17;32863:6;32823:67;:::i;:::-;32683:214;;;;:::o;32984:99::-;33036:6;33070:5;33064:12;33054:22;;32984:99;;;:::o;33089:169::-;33173:11;33207:6;33202:3;33195:19;33247:4;33242:3;33238:14;33223:29;;33089:169;;;;:::o;33264:148::-;33366:11;33403:3;33388:18;;33264:148;;;;:::o;33418:305::-;33458:3;33477:20;33495:1;33477:20;:::i;:::-;33472:25;;33511:20;33529:1;33511:20;:::i;:::-;33506:25;;33665:1;33597:66;33593:74;33590:1;33587:81;33584:107;;;33671:18;;:::i;:::-;33584:107;33715:1;33712;33708:9;33701:16;;33418:305;;;;:::o;33729:185::-;33769:1;33786:20;33804:1;33786:20;:::i;:::-;33781:25;;33820:20;33838:1;33820:20;:::i;:::-;33815:25;;33859:1;33849:35;;33864:18;;:::i;:::-;33849:35;33906:1;33903;33899:9;33894:14;;33729:185;;;;:::o;33920:191::-;33960:4;33980:20;33998:1;33980:20;:::i;:::-;33975:25;;34014:20;34032:1;34014:20;:::i;:::-;34009:25;;34053:1;34050;34047:8;34044:34;;;34058:18;;:::i;:::-;34044:34;34103:1;34100;34096:9;34088:17;;33920:191;;;;:::o;34117:96::-;34154:7;34183:24;34201:5;34183:24;:::i;:::-;34172:35;;34117:96;;;:::o;34219:90::-;34253:7;34296:5;34289:13;34282:21;34271:32;;34219:90;;;:::o;34315:77::-;34352:7;34381:5;34370:16;;34315:77;;;:::o;34398:126::-;34435:7;34475:42;34468:5;34464:54;34453:65;;34398:126;;;:::o;34530:142::-;34567:7;34607:58;34600:5;34596:70;34585:81;;34530:142;;;:::o;34678:77::-;34715:7;34744:5;34733:16;;34678:77;;;:::o;34761:93::-;34797:7;34837:10;34830:5;34826:22;34815:33;;34761:93;;;:::o;34860:86::-;34895:7;34935:4;34928:5;34924:16;34913:27;;34860:86;;;:::o;34952:307::-;35020:1;35030:113;35044:6;35041:1;35038:13;35030:113;;;35129:1;35124:3;35120:11;35114:18;35110:1;35105:3;35101:11;35094:39;35066:2;35063:1;35059:10;35054:15;;35030:113;;;35161:6;35158:1;35155:13;35152:101;;;35241:1;35232:6;35227:3;35223:16;35216:27;35152:101;35001:258;34952:307;;;:::o;35265:320::-;35309:6;35346:1;35340:4;35336:12;35326:22;;35393:1;35387:4;35383:12;35414:18;35404:81;;35470:4;35462:6;35458:17;35448:27;;35404:81;35532:2;35524:6;35521:14;35501:18;35498:38;35495:84;;;35551:18;;:::i;:::-;35495:84;35316:269;35265:320;;;:::o;35591:79::-;35630:7;35659:5;35648:16;;35591:79;;;:::o;35676:180::-;35724:77;35721:1;35714:88;35821:4;35818:1;35811:15;35845:4;35842:1;35835:15;35862:180;35910:77;35907:1;35900:88;36007:4;36004:1;35997:15;36031:4;36028:1;36021:15;36048:180;36096:77;36093:1;36086:88;36193:4;36190:1;36183:15;36217:4;36214:1;36207:15;36234:180;36282:77;36279:1;36272:88;36379:4;36376:1;36369:15;36403:4;36400:1;36393:15;36420:180;36468:77;36465:1;36458:88;36565:4;36562:1;36555:15;36589:4;36586:1;36579:15;36729:117;36838:1;36835;36828:12;36852:102;36893:6;36944:2;36940:7;36935:2;36928:5;36924:14;36920:28;36910:38;;36852:102;;;:::o;36960:174::-;37100:26;37096:1;37088:6;37084:14;37077:50;36960:174;:::o;37140:222::-;37280:34;37276:1;37268:6;37264:14;37257:58;37349:5;37344:2;37336:6;37332:15;37325:30;37140:222;:::o;37368:181::-;37508:33;37504:1;37496:6;37492:14;37485:57;37368:181;:::o;37555:179::-;37695:31;37691:1;37683:6;37679:14;37672:55;37555:179;:::o;37740:221::-;37880:34;37876:1;37868:6;37864:14;37857:58;37949:4;37944:2;37936:6;37932:15;37925:29;37740:221;:::o;37967:181::-;38107:33;38103:1;38095:6;38091:14;38084:57;37967:181;:::o;38154:175::-;38294:27;38290:1;38282:6;38278:14;38271:51;38154:175;:::o;38335:225::-;38475:34;38471:1;38463:6;38459:14;38452:58;38544:8;38539:2;38531:6;38527:15;38520:33;38335:225;:::o;38566:221::-;38706:34;38702:1;38694:6;38690:14;38683:58;38775:4;38770:2;38762:6;38758:15;38751:29;38566:221;:::o;38793:214::-;38933:66;38929:1;38921:6;38917:14;38910:90;38793:214;:::o;39013:179::-;39153:31;39149:1;39141:6;39137:14;39130:55;39013:179;:::o;39198:::-;39338:31;39334:1;39326:6;39322:14;39315:55;39198:179;:::o;39383:225::-;39523:34;39519:1;39511:6;39507:14;39500:58;39592:8;39587:2;39579:6;39575:15;39568:33;39383:225;:::o;39614:221::-;39754:34;39750:1;39742:6;39738:14;39731:58;39823:4;39818:2;39810:6;39806:15;39799:29;39614:221;:::o;39841:::-;39981:34;39977:1;39969:6;39965:14;39958:58;40050:4;40045:2;40037:6;40033:15;40026:29;39841:221;:::o;40068:180::-;40208:32;40204:1;40196:6;40192:14;40185:56;40068:180;:::o;40254:235::-;40394:34;40390:1;40382:6;40378:14;40371:58;40463:18;40458:2;40450:6;40446:15;40439:43;40254:235;:::o;40495:182::-;40635:34;40631:1;40623:6;40619:14;40612:58;40495:182;:::o;40683:226::-;40823:34;40819:1;40811:6;40807:14;40800:58;40892:9;40887:2;40879:6;40875:15;40868:34;40683:226;:::o;40915:220::-;41055:34;41051:1;41043:6;41039:14;41032:58;41124:3;41119:2;41111:6;41107:15;41100:28;40915:220;:::o;41141:224::-;41281:34;41277:1;41269:6;41265:14;41258:58;41350:7;41345:2;41337:6;41333:15;41326:32;41141:224;:::o;41371:225::-;41511:34;41507:1;41499:6;41495:14;41488:58;41580:8;41575:2;41567:6;41563:15;41556:33;41371:225;:::o;41602:223::-;41742:34;41738:1;41730:6;41726:14;41719:58;41811:6;41806:2;41798:6;41794:15;41787:31;41602:223;:::o;41831:224::-;41971:34;41967:1;41959:6;41955:14;41948:58;42040:7;42035:2;42027:6;42023:15;42016:32;41831:224;:::o;42061:181::-;42201:33;42197:1;42189:6;42185:14;42178:57;42061:181;:::o;42248:122::-;42321:24;42339:5;42321:24;:::i;:::-;42314:5;42311:35;42301:63;;42360:1;42357;42350:12;42301:63;42248:122;:::o;42376:::-;42449:24;42467:5;42449:24;:::i;:::-;42442:5;42439:35;42429:63;;42488:1;42485;42478:12;42429:63;42376:122;:::o;42504:::-;42577:24;42595:5;42577:24;:::i;:::-;42570:5;42567:35;42557:63;;42616:1;42613;42606:12;42557:63;42504:122;:::o;42632:120::-;42704:23;42721:5;42704:23;:::i;:::-;42697:5;42694:34;42684:62;;42742:1;42739;42732:12;42684:62;42632:120;:::o;42758:118::-;42829:22;42845:5;42829:22;:::i;:::-;42822:5;42819:33;42809:61;;42866:1;42863;42856:12;42809:61;42758:118;:::o
Swarm Source
ipfs://78fbfdeb9cd9d997df1f19d2b305d41aab2bb94fc023d0f78c927fdd03b403ec
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.