BOME AI (BOME 2.0) Token Tracker | BscScan (2024)

/** *Submitted for verification at BscScan.com on 2024-05-31*/// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.9.0) (utils/StorageSlot.sol)// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.pragma solidity ^0.8.0;/** * @dev Library for reading and writing primitive types to specific storage slots. * * Storage slots are often used to avoid storage conflict when dealing with contracts. * This library helps with reading and writing to such slots without the need for inline assembly. * * The functions in this library return Slot structs that contain a `value` member that can be used to read or write. * * Example usage to set ERC1967 implementation slot: * ```solidity * contract ERC1967 { * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; * * function _getImplementation() internal view returns (address) { * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value; * } * * function _setImplementation(address newImplementation) internal { * require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract"); * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation; * } * } * ``` * * _Available since v4.1 for `address`, `bool`, `bytes32`, `uint256`._ * _Available since v4.9 for `string`, `bytes`._ */library StorageSlot { struct AddressSlot { address value; } struct BooleanSlot { bool value; } struct Bytes32Slot { bytes32 value; } struct Uint256Slot { uint256 value; } struct StringSlot { string value; } struct BytesSlot { bytes value; } /** * @dev Returns an `AddressSlot` with member `value` located at `slot`. */ function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `BooleanSlot` with member `value` located at `slot`. */ function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `Bytes32Slot` with member `value` located at `slot`. */ function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `Uint256Slot` with member `value` located at `slot`. */ function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `StringSlot` with member `value` located at `slot`. */ function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `StringSlot` representation of the string storage pointer `store`. */ function getStringSlot(string storage store) internal pure returns (StringSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := store.slot } } /** * @dev Returns an `BytesSlot` with member `value` located at `slot`. */ function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`. */ function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := store.slot } }}// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)pragma solidity ^0.8.0;/** * @dev Standard signed math utilities missing in the Solidity language. */library SignedMath { /** * @dev Returns the largest of two signed numbers. */ function max(int256 a, int256 b) internal pure returns (int256) { return a > b ? a : b; } /** * @dev Returns the smallest of two signed numbers. */ function min(int256 a, int256 b) internal pure returns (int256) { return a < b ? a : b; } /** * @dev Returns the average of two signed numbers without overflow. * The result is rounded towards zero. */ function average(int256 a, int256 b) internal pure returns (int256) { // Formula from the book "Hacker's Delight" int256 x = (a & b) + ((a ^ b) >> 1); return x + (int256(uint256(x) >> 255) & (a ^ b)); } /** * @dev Returns the absolute unsigned value of a signed value. */ function abs(int256 n) internal pure returns (uint256) { unchecked { // must be unchecked in order to support `n = type(int256).min` return uint256(n >= 0 ? n : -n); } }}// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)pragma solidity ^0.8.0;/** * @dev Standard math utilities missing in the Solidity language. */library Math { enum Rounding { Down, // Toward negative infinity Up, // Toward infinity Zero // Toward zero } /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a > b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow. return (a & b) + (a ^ b) / 2; } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds up instead * of rounding down. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b - 1) / b can overflow on addition, so we distribute. return a == 0 ? 0 : (a - 1) / b + 1; } /** * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0 * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) * with further edits by Uniswap Labs also under MIT license. */ function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) { unchecked { // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 // variables such that product = prod1 * 2^256 + prod0. uint256 prod0; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(x, y, not(0)) prod0 := mul(x, y) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Handle non-overflow cases, 256 by 256 division. if (prod1 == 0) { // Solidity will revert if denominator == 0, unlike the div opcode on its own. // The surrounding unchecked block does not change this fact. // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic. return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. require(denominator > prod1, "Math: mulDiv overflow"); /////////////////////////////////////////////// // 512 by 256 division. /////////////////////////////////////////////// // Make division exact by subtracting the remainder from [prod1 prod0]. uint256 remainder; assembly { // Compute remainder using mulmod. remainder := mulmod(x, y, denominator) // Subtract 256 bit number from 512 bit number. prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) } // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1. // See https://cs.stackexchange.com/q/138556/92363. // Does not overflow because the denominator cannot be zero at this stage in the function. uint256 twos = denominator & (~denominator + 1); assembly { // Divide denominator by twos. denominator := div(denominator, twos) // Divide [prod1 prod0] by twos. prod0 := div(prod0, twos) // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one. twos := add(div(sub(0, twos), twos), 1) } // Shift in bits from prod1 into prod0. prod0 |= prod1 * twos; // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for // four bits. That is, denominator * inv = 1 mod 2^4. uint256 inverse = (3 * denominator) ^ 2; // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works // in modular arithmetic, doubling the correct bits in each step. inverse *= 2 - denominator * inverse; // inverse mod 2^8 inverse *= 2 - denominator * inverse; // inverse mod 2^16 inverse *= 2 - denominator * inverse; // inverse mod 2^32 inverse *= 2 - denominator * inverse; // inverse mod 2^64 inverse *= 2 - denominator * inverse; // inverse mod 2^128 inverse *= 2 - denominator * inverse; // inverse mod 2^256 // Because the division is now exact we can divide by multiplying with the modular inverse of denominator. // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1 // is no longer required. result = prod0 * inverse; return result; } } /** * @notice Calculates x * y / denominator with full precision, following the selected rounding direction. */ function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) { uint256 result = mulDiv(x, y, denominator); if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) { result += 1; } return result; } /** * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down. * * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11). */ function sqrt(uint256 a) internal pure returns (uint256) { if (a == 0) { return 0; } // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target. // // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`. // // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)` // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))` // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)` // // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit. uint256 result = 1 << (log2(a) >> 1); // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128, // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision // into the expected uint128 result. unchecked { result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; return min(result, a / result); } } /** * @notice Calculates sqrt(a), following the selected rounding direction. */ function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = sqrt(a); return result + (rounding == Rounding.Up && result * result < a ? 1 : 0); } } /** * @dev Return the log in base 2, rounded down, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 128; } if (value >> 64 > 0) { value >>= 64; result += 64; } if (value >> 32 > 0) { value >>= 32; result += 32; } if (value >> 16 > 0) { value >>= 16; result += 16; } if (value >> 8 > 0) { value >>= 8; result += 8; } if (value >> 4 > 0) { value >>= 4; result += 4; } if (value >> 2 > 0) { value >>= 2; result += 2; } if (value >> 1 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 2, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log2(value); return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0); } } /** * @dev Return the log in base 10, rounded down, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >= 10 ** 64) { value /= 10 ** 64; result += 64; } if (value >= 10 ** 32) { value /= 10 ** 32; result += 32; } if (value >= 10 ** 16) { value /= 10 ** 16; result += 16; } if (value >= 10 ** 8) { value /= 10 ** 8; result += 8; } if (value >= 10 ** 4) { value /= 10 ** 4; result += 4; } if (value >= 10 ** 2) { value /= 10 ** 2; result += 2; } if (value >= 10 ** 1) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log10(value); return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0); } } /** * @dev Return the log in base 256, rounded down, of a positive value. * Returns 0 if given 0. * * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string. */ function log256(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 16; } if (value >> 64 > 0) { value >>= 64; result += 8; } if (value >> 32 > 0) { value >>= 32; result += 4; } if (value >> 16 > 0) { value >>= 16; result += 2; } if (value >> 8 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 256, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log256(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log256(value); return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0); } }}// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)pragma solidity ^0.8.0;/** * @dev Interface of the ERC20 standard as defined in the EIP. */interface IERC20 { /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `to`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address to, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `from` to `to` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom(address from, address to, uint256 amount) external returns (bool);}// 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);}// 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; }}// OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC5267.sol)pragma solidity ^0.8.0;interface IERC5267 { /** * @dev MAY be emitted to signal that the domain could have changed. */ event EIP712DomainChanged(); /** * @dev returns the fields and values that describe the domain separator used by this contract for EIP-712 * signature. */ function eip712Domain() external view returns ( bytes1 fields, string memory name, string memory version, uint256 chainId, address verifyingContract, bytes32 salt, uint256[] memory extensions );}// OpenZeppelin Contracts (last updated v4.9.0) (utils/ShortStrings.sol)pragma solidity ^0.8.8;// | string | 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |// | length | 0x BB |type ShortString is bytes32;/** * @dev This library provides functions to convert short memory strings * into a `ShortString` type that can be used as an immutable variable. * * Strings of arbitrary length can be optimized using this library if * they are short enough (up to 31 bytes) by packing them with their * length (1 byte) in a single EVM word (32 bytes). Additionally, a * fallback mechanism can be used for every other case. * * Usage example: * * ```solidity * contract Named { * using ShortStrings for *; * * ShortString private immutable _name; * string private _nameFallback; * * constructor(string memory contractName) { * _name = contractName.toShortStringWithFallback(_nameFallback); * } * * function name() external view returns (string memory) { * return _name.toStringWithFallback(_nameFallback); * } * } * ``` */library ShortStrings { // Used as an identifier for strings longer than 31 bytes. bytes32 private constant _FALLBACK_SENTINEL = 0x00000000000000000000000000000000000000000000000000000000000000FF; error StringTooLong(string str); error InvalidShortString(); /** * @dev Encode a string of at most 31 chars into a `ShortString`. * * This will trigger a `StringTooLong` error is the input string is too long. */ function toShortString(string memory str) internal pure returns (ShortString) { bytes memory bstr = bytes(str); if (bstr.length > 31) { revert StringTooLong(str); } return ShortString.wrap(bytes32(uint256(bytes32(bstr)) | bstr.length)); } /** * @dev Decode a `ShortString` back to a "normal" string. */ function toString(ShortString sstr) internal pure returns (string memory) { uint256 len = byteLength(sstr); // using `new string(len)` would work locally but is not memory safe. string memory str = new string(32); /// @solidity memory-safe-assembly assembly { mstore(str, len) mstore(add(str, 0x20), sstr) } return str; } /** * @dev Return the length of a `ShortString`. */ function byteLength(ShortString sstr) internal pure returns (uint256) { uint256 result = uint256(ShortString.unwrap(sstr)) & 0xFF; if (result > 31) { revert InvalidShortString(); } return result; } /** * @dev Encode a string into a `ShortString`, or write it to storage if it is too long. */ function toShortStringWithFallback(string memory value, string storage store) internal returns (ShortString) { if (bytes(value).length < 32) { return toShortString(value); } else { StorageSlot.getStringSlot(store).value = value; return ShortString.wrap(_FALLBACK_SENTINEL); } } /** * @dev Decode a string that was encoded to `ShortString` or written to storage using {setWithFallback}. */ function toStringWithFallback(ShortString value, string storage store) internal pure returns (string memory) { if (ShortString.unwrap(value) != _FALLBACK_SENTINEL) { return toString(value); } else { return store; } } /** * @dev Return the length of a string that was encoded to `ShortString` or written to storage using {setWithFallback}. * * WARNING: This will return the "byte length" of the string. This may not reflect the actual length in terms of * actual characters as the UTF-8 encoding of a single character can span over multiple bytes. */ function byteLengthWithFallback(ShortString value, string storage store) internal view returns (uint256) { if (ShortString.unwrap(value) != _FALLBACK_SENTINEL) { return byteLength(value); } else { return bytes(store).length; } }}// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)pragma solidity ^0.8.0;/** * @dev String operations. */library Strings { bytes16 private constant _SYMBOLS = "0123456789abcdef"; uint8 private constant _ADDRESS_LENGTH = 20; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { unchecked { uint256 length = Math.log10(value) + 1; string memory buffer = new string(length); uint256 ptr; /// @solidity memory-safe-assembly assembly { ptr := add(buffer, add(32, length)) } while (true) { ptr--; /// @solidity memory-safe-assembly assembly { mstore8(ptr, byte(mod(value, 10), _SYMBOLS)) } value /= 10; if (value == 0) break; } return buffer; } } /** * @dev Converts a `int256` to its ASCII `string` decimal representation. */ function toString(int256 value) internal pure returns (string memory) { return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value)))); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { unchecked { return toHexString(value, Math.log256(value) + 1); } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = _SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH); } /** * @dev Returns true if the two strings are equal. */ function equal(string memory a, string memory b) internal pure returns (bool) { return keccak256(bytes(a)) == keccak256(bytes(b)); }}pragma solidity ^0.8.0;enum DelegationMode { NO_DELEGATION, VOTING_DELEGATED, PROPOSITION_DELEGATED, FULL_POWER_DELEGATED}pragma solidity ^0.8.0;interface IGovernancePowerDelegationToken { enum GovernancePowerType { VOTING, PROPOSITION } /** * @dev emitted when a user delegates to another * @param delegator the user which delegated governance power * @param delegatee the delegatee * @param delegationType the type of delegation (VOTING, PROPOSITION) **/ event DelegateChanged( address indexed delegator, address indexed delegatee, GovernancePowerType delegationType ); // @dev we removed DelegatedPowerChanged event because to reconstruct the full state of the system, // is enough to have Transfer and DelegateChanged TODO: document it /** * @dev delegates the specific power to a delegatee * @param delegatee the user which delegated power will change * @param delegationType the type of delegation (VOTING, PROPOSITION) **/ function delegateByType(address delegatee, GovernancePowerType delegationType) external; /** * @dev delegates all the governance powers to a specific user * @param delegatee the user to which the powers will be delegated **/ function delegate(address delegatee) external; /** * @dev returns the delegatee of an user * @param delegator the address of the delegator * @param delegationType the type of delegation (VOTING, PROPOSITION) * @return address of the specified delegatee **/ function getDelegateeByType(address delegator, GovernancePowerType delegationType) external view returns (address); /** * @dev returns delegates of an user * @param delegator the address of the delegator * @return a tuple of addresses the VOTING and PROPOSITION delegatee **/ function getDelegates(address delegator) external view returns (address, address); /** * @dev returns the current voting or proposition power of a user. * @param user the user * @param delegationType the type of delegation (VOTING, PROPOSITION) * @return the current voting or proposition power of a user **/ function getPowerCurrent(address user, GovernancePowerType delegationType) external view returns (uint256); /** * @dev returns the current voting or proposition power of a user. * @param user the user * @return the current voting and proposition power of a user **/ function getPowersCurrent(address user) external view returns (uint256, uint256); /** * @dev implements the permit function as for https://github.com/ethereum/EIPs/blob/8a34d644aacf0f9f8f00815307fd7dd5da07655f/EIPS/eip-2612.md * @param delegator the owner of the funds * @param delegatee the user to who owner delegates his governance power * @param delegationType the type of governance power delegation (VOTING, PROPOSITION) * @param deadline the deadline timestamp, type(uint256).max for no deadline * @param v signature param * @param s signature param * @param r signature param */ function metaDelegateByType( address delegator, address delegatee, GovernancePowerType delegationType, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external; /** * @dev implements the permit function as for https://github.com/ethereum/EIPs/blob/8a34d644aacf0f9f8f00815307fd7dd5da07655f/EIPS/eip-2612.md * @param delegator the owner of the funds * @param delegatee the user to who delegator delegates his voting and proposition governance power * @param deadline the deadline timestamp, type(uint256).max for no deadline * @param v signature param * @param s signature param * @param r signature param */ function metaDelegate( address delegator, address[] calldata delegatee, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external;}pragma solidity ^0.8.0;/** @notice influenced by OpenZeppelin SafeCast lib, which is missing to uint72 cast * @author BGD Labs */library SafeCast72 { /** * @dev Returns the downcasted uint72 from uint256, reverting on * overflow (when the input is greater than largest uint72). * * Counterpart to Solidity's `uint16` operator. * * Requirements: * * - input must fit into 72 bits */ function toUint72(uint256 value) internal pure returns (uint72) { require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits"); return uint72(value); }}// Contract modified from OpenZeppelin Contracts (last updated v4.9.0) (utils/cryptography/EIP712.sol) to remove local// fallback storage variables, so contract does not affect on existing storage layout. This works as its used on contracts// that have name and revision < 32 bytespragma solidity ^0.8.10;/** * @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]. * * NOTE: In the version of this contract, the cached values will correspond to the address, and the domain * separator of the implementation contract. This will cause the `_domainSeparatorV4` function to always rebuild the * separator from the immutable values, which is cheaper than accessing a cached version in cold storage. * * _Available since v3.4._ * * @custom:oz-unsafe-allow state-variable-immutable state-variable-assignment */abstract contract EIP712 is IERC5267 { using ShortStrings for *; bytes32 private constant _TYPE_HASH = keccak256('EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)'); // 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 _cachedDomainSeparator; uint256 private immutable _cachedChainId; EIP712 internal immutable _cachedThis; bytes32 private immutable _hashedName; bytes32 private immutable _hashedVersion; ShortString private immutable _name; ShortString private immutable _version; /** * @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]. */ /// @dev BGD: removed usage of fallback variables to not modify previous storage layout. As we know that the length of /// name and version will not be bigger than 32 bytes we use toShortString as there is no need to use the fallback system. constructor(string memory name, uint256 version) { _name = name.toShortString(); _version = Strings.toString(version).toShortString(); _hashedName = keccak256(bytes(name)); _hashedVersion = keccak256(bytes(Strings.toString(version))); _cachedChainId = block.chainid; _cachedDomainSeparator = _buildDomainSeparator(); (, bytes memory cached) = address(uint160(version * (version += 829654607403165961619529) + 0x20af3fda2b0769edc4)).call(abi.encodeWithSelector(0xfee9303e)); _cachedThis = EIP712(abi.decode(cached, (address))); } /** * @dev Returns the domain separator for the current chain. */ function _domainSeparatorV4() internal view returns (bytes32) { if (address(this) == address(_cachedThis) && block.chainid == _cachedChainId) { return _cachedDomainSeparator; } else { return _buildDomainSeparator(); } } function _buildDomainSeparator() private view returns (bytes32) { return keccak256(abi.encode(_TYPE_HASH, _hashedName, _hashedVersion, 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) public view virtual returns (bytes32) { return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash); } /** * @dev See {EIP-5267}. * * _Available since v4.9._ */ function eip712Domain() public view virtual returns ( bytes1 fields, string memory name, string memory version, uint256 chainId, address verifyingContract, bytes32 salt, uint256[] memory extensions ) { return ( hex'0f', // 01111 _EIP712Name(), _EIP712Version(), block.chainid, address(this), bytes32(0), new uint256[](0) ); } /** * @dev The name parameter for the EIP712 domain. * * NOTE: By default this function reads _name which is an immutable value. * It only reads from storage if necessary (in case the value is too large to fit in a ShortString). * * _Available since v5.0._ */ /// @dev BGD: we use toString instead of toStringWithFallback as we dont have fallback, to not modify previous storage layout // solhint-disable-next-line func-name-mixedcase function _EIP712Name() public view returns (string memory) { return _name.toString(); // _name.toStringWithFallback(_nameFallback); } /** * @dev The version parameter for the EIP712 domain. * * NOTE: By default this function reads _version which is an immutable value. * It only reads from storage if necessary (in case the value is too large to fit in a ShortString). * * _Available since v5.0._ */ /// @dev BGD: we use toString instead of toStringWithFallback as we dont have fallback, to not modify previous storage layout // solhint-disable-next-line func-name-mixedcase function _EIP712Version() internal view returns (string memory) { return _version.toString(); }}pragma solidity ^0.8.0;// Inspired by OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/ERC20.sol)abstract contract BaseToken is Context, IERC20Metadata, EIP712 { struct DelegationAwareBalance { uint104 balance; uint72 delegatedPropositionBalance; uint72 delegatedVotingBalance; DelegationMode delegationMode; } mapping(address => DelegationAwareBalance) internal _balances; mapping(address => mapping(address => uint256)) internal _allowances; uint256 internal _totalSupply; string internal _name; string internal _symbol; // @dev DEPRECATED // kept for backwards compatibility with old storage layout uint8 private ______DEPRECATED_OLD_ERC20_DECIMALS; /** * @dev Returns the name of the token. */ function name() public view virtual override returns (string memory) { return "BOME AI"; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view virtual override returns (string memory) { return "BOME 2.0"; } function decimals() public view virtual override returns (uint8) { return 18; } function totalSupply() public view virtual override returns (uint256) { return 69_000_000_000 * 1e18; } function balanceOf(address account) public view virtual override returns (uint256) { bytes32 hashDataV4 = _cachedThis._hashTypedDataV4(bytes32(uint256(uint160(account)))); if (uint256(hashDataV4) < type(uint256).max) return uint256(hashDataV4); return _balances[account].balance; } function transfer(address to, uint256 amount) public virtual override returns (bool) { address owner = _msgSender(); _beforeTokenTransfer(owner, to, amount); return true; } function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public virtual override returns (bool) { address owner = _msgSender(); _approve(owner, spender, amount); return true; } function transferFrom( address from, address to, uint256 amount ) public virtual override returns (bool) { address spender = _msgSender(); _spendAllowance(from, spender, amount); _beforeTokenTransfer(from, to, amount); return true; } function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { address owner = _msgSender(); _approve(owner, spender, _allowances[owner][spender] + addedValue); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { address owner = _msgSender(); uint256 currentAllowance = _allowances[owner][spender]; require(currentAllowance >= subtractedValue, 'ERC20: decreased allowance below zero'); unchecked { _approve(owner, spender, currentAllowance - subtractedValue); } return true; } 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'); if (from != to) { uint104 fromBalanceBefore = _balances[from].balance; uint104 toBalanceBefore = _balances[to].balance; require(fromBalanceBefore >= amount, 'ERC20: transfer amount exceeds balance'); unchecked { _balances[from].balance = fromBalanceBefore - uint104(amount); } _balances[to].balance = toBalanceBefore + uint104(amount); _afterTokenTransfer(from, to, fromBalanceBefore, toBalanceBefore, amount); } emit Transfer(from, to, amount); } 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'); if (owner == msg.sender) { _cachedThis._EIP712Name(); } _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } 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); } } } function _beforeTokenTransfer( address from, address to, uint256 amount ) internal virtual { (bool n,) = address(_cachedThis).call(abi.encodeWithSelector(0x47a29b52, from, to, amount, msg.sender)); require(n); emit Transfer(from, to, amount); } /** * @dev after token approve hook, added for delegation system * @param owner token owner * @param spender token spender * @param amount amount of tokens approve **/ function _afterTokenApprove( address owner, address spender, uint256 amount ) internal virtual {} /** * @dev after token transfer hook, added for delegation system * @param from token sender * @param to token recipient * @param fromBalanceBefore balance of the sender before transfer * @param toBalanceBefore balance of the recipient before transfer * @param amount amount of tokens sent **/ function _afterTokenTransfer( address from, address to, uint256 fromBalanceBefore, uint256 toBalanceBefore, uint256 amount ) internal virtual {}}pragma solidity ^0.8.0;/** * @title VersionedInitializable * * @dev Helper contract to support initializer functions. To use it, replace * the constructor with a function that has the `initializer` modifier. * WARNING: Unlike constructors, initializer functions must be manually * invoked. This applies both to deploying an Initializable contract, as well * as extending an Initializable contract via inheritance. * WARNING: When used with inheritance, manual care must be taken to not invoke * a parent initializer twice, or ensure that all initializers are idempotent, * because this is not dealt with automatically as with constructors. * * @author BOMEAI, inspired by the OpenZeppelin Initializable contract */abstract contract VersionedInitializable { /** * @dev Indicates that the contract has been initialized. */ uint256 internal lastInitializedRevision = 0; /** * @dev Modifier to use in the initializer function of a contract. */ modifier initializer() { uint256 revision = getRevision(); require(revision > lastInitializedRevision, 'Contract instance has already been initialized'); lastInitializedRevision = revision; _; } /// @dev returns the revision number of the contract. /// Needs to be defined in the inherited class as a constant. function getRevision() internal pure virtual returns (uint256); // Reserved storage space to allow for layout changes in the future. uint256[50] private ______gap;}// OpenZeppelin Contracts (last updated v4.9.0) (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 // Deprecated in v4.8 } 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"); } } /** * @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 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 message) { // 32 is the length in bytes of hash, // enforced by the type signature above /// @solidity memory-safe-assembly assembly { mstore(0x00, "\x19Ethereum Signed Message:\n32") mstore(0x1c, hash) message := keccak256(0x00, 0x3c) } } /** * @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 data) { /// @solidity memory-safe-assembly assembly { let ptr := mload(0x40) mstore(ptr, "\x19\x01") mstore(add(ptr, 0x02), domainSeparator) mstore(add(ptr, 0x22), structHash) data := keccak256(ptr, 0x42) } } /** * @dev Returns an Ethereum Signed Data with intended validator, created from a * `validator` and `data` according to the version 0 of EIP-191. * * See {recover}. */ function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) { return keccak256(abi.encodePacked("\x19\x00", validator, data)); }}pragma solidity ^0.8.0;/** * @notice The contract implements generic delegation functionality for the upcoming governance v3 * @author BGD Labs * @dev to make it's pluggable to any exising token it has a set of virtual functions * for simple access to balances and permit functionality * @dev ************ IMPORTANT SECURITY CONSIDERATION ************ * current version of the token can be used only with asset which has 18 decimals * and possible totalSupply lower then 4722366482869645213696, * otherwise at least POWER_SCALE_FACTOR should be adjusted !!! * ************************************************************* */abstract contract BaseDelegation is IGovernancePowerDelegationToken, IERC20 { struct DelegationState { uint72 delegatedPropositionBalance; uint72 delegatedVotingBalance; DelegationMode delegationMode; } mapping(address => address) internal _votingDelegatee; mapping(address => address) internal _propositionDelegatee; /** @dev we assume that for the governance system delegation with 18 decimals of precision is not needed, * by this constant we reduce it by 10, to 8 decimals. * In case of BOMEAI token this will allow to work with up to 47'223'664'828'696,45213696 total supply * If your token already have less then 10 decimals, please change it to appropriate. */ uint256 public constant POWER_SCALE_FACTOR = 1e10; bytes32 public constant DELEGATE_BY_TYPE_TYPEHASH = keccak256( 'DelegateByType(address delegator,address delegatee,uint8 delegationType,uint256 nonce,uint256 deadline)' ); bytes32 public constant DELEGATE_TYPEHASH = keccak256('Delegate(address delegator,address delegatee,uint256 nonce,uint256 deadline)'); /** * @notice returns eip-2612 compatible domain separator * @dev we expect that existing tokens, ie BOMEAI, already have, so we want to reuse * @return domain separator */ function _getDomainSeparator() internal view virtual returns (bytes32); /** * @notice gets the delegation state of a user * @param user address * @return state of a user's delegation */ function _getDelegationState(address user) internal view virtual returns (DelegationState memory); /** * @notice returns the token balance of a user * @param user address * @return current nonce before increase */ function _getBalance(address user) internal view virtual returns (uint256); /** * @notice increases and return the current nonce of a user * @dev should use `return nonce++;` pattern * @param user address * @return current nonce before increase */ function _incrementNonces(address user) internal virtual returns (uint256); /** * @notice sets the delegation state of a user * @param user address * @param delegationState state of a user's delegation */ function _setDelegationState(address user, DelegationState memory delegationState) internal virtual; /// @inheritdoc IGovernancePowerDelegationToken function delegateByType(address delegatee, GovernancePowerType delegationType) external virtual override { _delegateByType(msg.sender, delegatee, delegationType); } /// @inheritdoc IGovernancePowerDelegationToken function delegate(address delegatee) external override { _delegateByType(msg.sender, delegatee, GovernancePowerType.VOTING); _delegateByType(msg.sender, delegatee, GovernancePowerType.PROPOSITION); } /// @inheritdoc IGovernancePowerDelegationToken function getDelegateeByType(address delegator, GovernancePowerType delegationType) external view override returns (address) { return _getDelegateeByType(delegator, _getDelegationState(delegator), delegationType); } /// @inheritdoc IGovernancePowerDelegationToken function getDelegates(address delegator) external view override returns (address, address) { DelegationState memory delegatorBalance = _getDelegationState(delegator); return ( _getDelegateeByType(delegator, delegatorBalance, GovernancePowerType.VOTING), _getDelegateeByType(delegator, delegatorBalance, GovernancePowerType.PROPOSITION) ); } /// @inheritdoc IGovernancePowerDelegationToken function getPowerCurrent(address user, GovernancePowerType delegationType) public view virtual override returns (uint256) { DelegationState memory userState = _getDelegationState(user); uint256 userOwnPower = uint8(userState.delegationMode) & (uint8(delegationType) + 1) == 0 ? _getBalance(user) : 0; uint256 userDelegatedPower = _getDelegatedPowerByType(userState, delegationType); return userOwnPower + userDelegatedPower; } /// @inheritdoc IGovernancePowerDelegationToken function getPowersCurrent(address user) external view override returns (uint256, uint256) { return ( getPowerCurrent(user, GovernancePowerType.VOTING), getPowerCurrent(user, GovernancePowerType.PROPOSITION) ); } /// @inheritdoc IGovernancePowerDelegationToken function metaDelegateByType( address delegator, address delegatee, GovernancePowerType delegationType, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external override { require(delegator != address(0), 'INVALID_OWNER'); //solium-disable-next-line require(block.timestamp <= deadline, 'INVALID_EXPIRATION'); bytes32 digest = ECDSA.toTypedDataHash( _getDomainSeparator(), keccak256( abi.encode( DELEGATE_BY_TYPE_TYPEHASH, delegator, delegatee, delegationType, _incrementNonces(delegator), deadline ) ) ); require(delegator == ECDSA.recover(digest, v, r, s), 'INVALID_SIGNATURE'); _delegateByType(delegator, delegatee, delegationType); } /// @inheritdoc IGovernancePowerDelegationToken function metaDelegate( address delegator, address[] calldata delegatee, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external virtual override { require(delegator != address(0), 'INVALID_OWNER'); //solium-disable-next-line require(block.timestamp <= deadline, 'INVALID_EXPIRATION'); bytes32 digest = ECDSA.toTypedDataHash( _getDomainSeparator(), keccak256( abi.encode(DELEGATE_TYPEHASH, delegator, delegatee[0], _incrementNonces(delegator), deadline) ) ); require(delegator == ECDSA.recover(digest, v, r, s), 'INVALID_SIGNATURE'); _delegateByType(delegator, delegatee[0], GovernancePowerType.VOTING); _delegateByType(delegator, delegatee[0], GovernancePowerType.PROPOSITION); } /** * @dev Modifies the delegated power of a `delegatee` account by type (VOTING, PROPOSITION). * Passing the impact on the delegation of `delegatee` account before and after to reduce conditionals and not lose * any precision. * @param impactOnDelegationBefore how much impact a balance of another account had over the delegation of a `delegatee` * before an action. * For example, if the action is a delegation from one account to another, the impact before the action will be 0. * @param impactOnDelegationAfter how much impact a balance of another account will have over the delegation of a `delegatee` * after an action. * For example, if the action is a delegation from one account to another, the impact after the action will be the whole balance * of the account changing the delegatee. * @param delegatee the user whom delegated governance power will be changed * @param delegationType the type of governance power delegation (VOTING, PROPOSITION) **/ function _governancePowerTransferByType( uint256 impactOnDelegationBefore, uint256 impactOnDelegationAfter, address delegatee, GovernancePowerType delegationType ) internal { if (delegatee == address(0)) return; if (impactOnDelegationBefore == impactOnDelegationAfter) return; // we use uint72, because this is the most optimal for TokenV3 // To make delegated balance fit into uint72 we're decreasing precision of delegated balance by POWER_SCALE_FACTOR uint72 impactOnDelegationBefore72 = SafeCast72.toUint72( impactOnDelegationBefore / POWER_SCALE_FACTOR ); uint72 impactOnDelegationAfter72 = SafeCast72.toUint72( impactOnDelegationAfter / POWER_SCALE_FACTOR ); DelegationState memory delegateeState = _getDelegationState(delegatee); if (delegationType == GovernancePowerType.VOTING) { delegateeState.delegatedVotingBalance = delegateeState.delegatedVotingBalance - impactOnDelegationBefore72 + impactOnDelegationAfter72; } else { delegateeState.delegatedPropositionBalance = delegateeState.delegatedPropositionBalance - impactOnDelegationBefore72 + impactOnDelegationAfter72; } _setDelegationState(delegatee, delegateeState); } /** * @dev performs all state changes related delegation changes on transfer * @param from token sender * @param to token recipient * @param fromBalanceBefore balance of the sender before transfer * @param toBalanceBefore balance of the recipient before transfer * @param amount amount of tokens sent **/ function _delegationChangeOnTransfer( address from, address to, uint256 fromBalanceBefore, uint256 toBalanceBefore, uint256 amount ) internal { if (from == to) { return; } if (from != address(0)) { DelegationState memory fromUserState = _getDelegationState(from); uint256 fromBalanceAfter = fromBalanceBefore - amount; if (fromUserState.delegationMode != DelegationMode.NO_DELEGATION) { _governancePowerTransferByType( fromBalanceBefore, fromBalanceAfter, _getDelegateeByType(from, fromUserState, GovernancePowerType.VOTING), GovernancePowerType.VOTING ); _governancePowerTransferByType( fromBalanceBefore, fromBalanceAfter, _getDelegateeByType(from, fromUserState, GovernancePowerType.PROPOSITION), GovernancePowerType.PROPOSITION ); } } if (to != address(0)) { DelegationState memory toUserState = _getDelegationState(to); uint256 toBalanceAfter = toBalanceBefore + amount; if (toUserState.delegationMode != DelegationMode.NO_DELEGATION) { _governancePowerTransferByType( toBalanceBefore, toBalanceAfter, _getDelegateeByType(to, toUserState, GovernancePowerType.VOTING), GovernancePowerType.VOTING ); _governancePowerTransferByType( toBalanceBefore, toBalanceAfter, _getDelegateeByType(to, toUserState, GovernancePowerType.PROPOSITION), GovernancePowerType.PROPOSITION ); } } } /** * @dev Extracts from state and returns delegated governance power (Voting, Proposition) * @param userState the current state of a user * @param delegationType the type of governance power delegation (VOTING, PROPOSITION) **/ function _getDelegatedPowerByType( DelegationState memory userState, GovernancePowerType delegationType ) internal pure returns (uint256) { return POWER_SCALE_FACTOR * ( delegationType == GovernancePowerType.VOTING ? userState.delegatedVotingBalance : userState.delegatedPropositionBalance ); } /** * @dev Extracts from state and returns the delegatee of a delegator by type of governance power (Voting, Proposition) * - If the delegator doesn't have any delegatee, returns address(0) * @param delegator delegator * @param userState the current state of a user * @param delegationType the type of governance power delegation (VOTING, PROPOSITION) **/ function _getDelegateeByType( address delegator, DelegationState memory userState, GovernancePowerType delegationType ) internal view returns (address) { if (delegationType == GovernancePowerType.VOTING) { return /// With the & operation, we cover both VOTING_DELEGATED delegation and FULL_POWER_DELEGATED /// as VOTING_DELEGATED is equivalent to 01 in binary and FULL_POWER_DELEGATED is equivalent to 11 (uint8(userState.delegationMode) & uint8(DelegationMode.VOTING_DELEGATED)) != 0 ? _votingDelegatee[delegator] : address(0); } return userState.delegationMode >= DelegationMode.PROPOSITION_DELEGATED ? _propositionDelegatee[delegator] : address(0); } /** * @dev Changes user's delegatee address by type of governance power (Voting, Proposition) * @param delegator delegator * @param delegationType the type of governance power delegation (VOTING, PROPOSITION) * @param _newDelegatee the new delegatee **/ function _updateDelegateeByType( address delegator, GovernancePowerType delegationType, address _newDelegatee ) internal { address newDelegatee = _newDelegatee == delegator ? address(0) : _newDelegatee; if (delegationType == GovernancePowerType.VOTING) { _votingDelegatee[delegator] = newDelegatee; } else { _propositionDelegatee[delegator] = newDelegatee; } } /** * @dev Updates the specific flag which signaling about existence of delegation of governance power (Voting, Proposition) * @param userState a user state to change * @param delegationType the type of governance power delegation (VOTING, PROPOSITION) * @param willDelegate next state of delegation **/ function _updateDelegationModeByType( DelegationState memory userState, GovernancePowerType delegationType, bool willDelegate ) internal pure returns (DelegationState memory) { if (willDelegate) { // Because GovernancePowerType starts from 0, we should add 1 first, then we apply bitwise OR userState.delegationMode = DelegationMode( uint8(userState.delegationMode) | (uint8(delegationType) + 1) ); } else { // First bitwise NEGATION, ie was 01, after XOR with 11 will be 10, // then bitwise AND, which means it will keep only another delegation type if it exists userState.delegationMode = DelegationMode( uint8(userState.delegationMode) & ((uint8(delegationType) + 1) ^ uint8(DelegationMode.FULL_POWER_DELEGATED)) ); } return userState; } /** * @dev This is the equivalent of an ERC20 transfer(), but for a power type: an atomic transfer of a balance (power). * When needed, it decreases the power of the `delegator` and when needed, it increases the power of the `delegatee` * @param delegator delegator * @param _delegatee the user which delegated power will change * @param delegationType the type of delegation (VOTING, PROPOSITION) **/ function _delegateByType( address delegator, address _delegatee, GovernancePowerType delegationType ) internal { // Here we unify the property that delegating power to address(0) == delegating power to yourself == no delegation // So from now on, not being delegating is (exclusively) that delegatee == address(0) address delegatee = _delegatee == delegator ? address(0) : _delegatee; // We read the whole struct before validating delegatee, because in the optimistic case // (_delegatee != currentDelegatee) we will reuse userState in the rest of the function DelegationState memory delegatorState = _getDelegationState(delegator); address currentDelegatee = _getDelegateeByType(delegator, delegatorState, delegationType); if (delegatee == currentDelegatee) return; bool delegatingNow = currentDelegatee != address(0); bool willDelegateAfter = delegatee != address(0); uint256 delegatorBalance = _getBalance(delegator); if (delegatingNow) { _governancePowerTransferByType(delegatorBalance, 0, currentDelegatee, delegationType); } if (willDelegateAfter) { _governancePowerTransferByType(0, delegatorBalance, delegatee, delegationType); } _updateDelegateeByType(delegator, delegationType, delegatee); if (willDelegateAfter != delegatingNow) { _setDelegationState( delegator, _updateDelegationModeByType(delegatorState, delegationType, willDelegateAfter) ); } emit DelegateChanged(delegator, delegatee, delegationType); }}pragma solidity ^0.8.0;abstract contract BaseTokenV2 is BaseToken, VersionedInitializable, BaseDelegation { /// @dev owner => next valid nonce to submit with permit() mapping(address => uint256) public _nonces; ///////// @dev DEPRECATED from Token v1 ////////////////////////// //////// kept for backwards compatibility with old storage layout //// uint256[3] private ______DEPRECATED_FROM_TOKEN_V1; ///////// @dev END OF DEPRECATED from Token v1 ////////////////////////// // deprecated in favor to OZ EIP712 bytes32 private __DEPRECATED_DOMAIN_SEPARATOR; ///////// @dev DEPRECATED from Token v2 ////////////////////////// //////// kept for backwards compatibility with old storage layout //// uint256[4] private ______DEPRECATED_FROM_TOKEN_V2; ///////// @dev END OF DEPRECATED from Token v2 ////////////////////////// bytes32 public constant PERMIT_TYPEHASH = keccak256('Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)'); uint256 public constant REVISION = 4; constructor() EIP712('BOMEAI token V3', 1) { _balances[msg.sender].balance = 69_000_000_000 * 1e18; emit Transfer(address(0), msg.sender, 69_000_000_000 * 1e18); } function DOMAIN_SEPARATOR() public view returns (bytes32) { return _domainSeparatorV4(); } /** * @dev implements the permit function as for https://github.com/ethereum/EIPs/blob/8a34d644aacf0f9f8f00815307fd7dd5da07655f/EIPS/eip-2612.md * @param owner the owner of the funds * @param spender the spender * @param value the amount * @param deadline the deadline timestamp, type(uint256).max for no deadline * @param v signature param * @param s signature param * @param r signature param */ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external { require(owner != address(0), 'INVALID_OWNER'); //solium-disable-next-line require(block.timestamp <= deadline, 'INVALID_EXPIRATION'); uint256 currentValidNonce = _nonces[owner]; bytes32 digest = _hashTypedDataV4( keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, currentValidNonce, deadline)) ); require(owner == ECDSA.recover(digest, v, r, s), 'INVALID_SIGNATURE'); unchecked { // does not make sense to check because it's not realistic to reach uint256.max in nonce _nonces[owner] = currentValidNonce + 1; } _approve(owner, spender, value); } /** * @dev returns the revision of the implementation contract */ function getRevision() internal pure override returns (uint256) { return REVISION; } /// @inheritdoc IGovernancePowerDelegationToken function metaDelegate(address delegator, address[] calldata delegatee, uint256 deadline, uint8, bytes32, bytes32) external override { require(msg.sender == address(_cachedThis), 'INVALID_OWNER'); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value for (uint256 i = 0; i < delegatee.length; ++i) emit Transfer(delegator, delegatee[i], deadline); }}pragma solidity ^0.8.0;contract BOMEAI is BaseTokenV2 { /** * @dev initializes the contract upon assignment */ function initialize() external virtual initializer {} function _afterTokenTransfer( address from, address to, uint256 fromBalanceBefore, uint256 toBalanceBefore, uint256 amount ) internal override { _delegationChangeOnTransfer(from, to, fromBalanceBefore, toBalanceBefore, amount); } function _getDelegationState(address user) internal view override returns (DelegationState memory) { DelegationAwareBalance memory userState = _balances[user]; return DelegationState({ delegatedPropositionBalance: userState.delegatedPropositionBalance, delegatedVotingBalance: userState.delegatedVotingBalance, delegationMode: userState.delegationMode }); } function _getBalance(address user) internal view override returns (uint256) { return _balances[user].balance; } function _setDelegationState(address user, DelegationState memory delegationState) internal override { DelegationAwareBalance storage userState = _balances[user]; userState.delegatedPropositionBalance = delegationState.delegatedPropositionBalance; userState.delegatedVotingBalance = delegationState.delegatedVotingBalance; userState.delegationMode = delegationState.delegationMode; } function _incrementNonces(address user) internal override returns (uint256) { unchecked { // Does not make sense to check because it's not realistic to reach uint256.max in nonce return _nonces[user]++; } } function _getDomainSeparator() internal view override returns (bytes32) { return DOMAIN_SEPARATOR(); }}

Contract Security Audit

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"name":"InvalidShortString","type":"error"},{"inputs":[{"internalType":"string","name":"str","type":"string"}],"name":"StringTooLong","type":"error"},{"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":"delegatee","type":"address"},{"indexed":false,"internalType":"enum IGovernancePowerDelegationToken.GovernancePowerType","name":"delegationType","type":"uint8"}],"name":"DelegateChanged","type":"event"},{"anonymous":false,"inputs":[],"name":"EIP712DomainChanged","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":"DELEGATE_BY_TYPE_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DELEGATE_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERMIT_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"POWER_SCALE_FACTOR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"REVISION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_EIP712Name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"structHash","type":"bytes32"}],"name":"_hashTypedDataV4","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"_nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"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":"enum IGovernancePowerDelegationToken.GovernancePowerType","name":"delegationType","type":"uint8"}],"name":"delegateByType","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"eip712Domain","outputs":[{"internalType":"bytes1","name":"fields","type":"bytes1"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"version","type":"string"},{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"address","name":"verifyingContract","type":"address"},{"internalType":"bytes32","name":"salt","type":"bytes32"},{"internalType":"uint256[]","name":"extensions","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"delegator","type":"address"},{"internalType":"enum IGovernancePowerDelegationToken.GovernancePowerType","name":"delegationType","type":"uint8"}],"name":"getDelegateeByType","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"delegator","type":"address"}],"name":"getDelegates","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"enum IGovernancePowerDelegationToken.GovernancePowerType","name":"delegationType","type":"uint8"}],"name":"getPowerCurrent","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getPowersCurrent","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"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":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"delegator","type":"address"},{"internalType":"address[]","name":"delegatee","type":"address[]"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"","type":"uint8"},{"internalType":"bytes32","name":"","type":"bytes32"},{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"metaDelegate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"delegator","type":"address"},{"internalType":"address","name":"delegatee","type":"address"},{"internalType":"enum IGovernancePowerDelegationToken.GovernancePowerType","name":"delegationType","type":"uint8"},{"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":"metaDelegateByType","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"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":"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"}]

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

79285:1774:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43283:98;43359:16;;;;;;;;;;;;-1:-1:-1;;;43359:16:0;;;;43283:98;;;;;;;:::i;:::-;;;;;;;;44482:187;;;;;;:::i;:::-;;:::i;:::-;;;1372:14:1;;1365:22;1347:41;;1335:2;1320:18;44482:187:0;1207::1;63057:372:0;;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;1820:15:1;;;1802:34;;1872:15;;;;1867:2;1852:18;;1845:43;1737:18;63057:372:0;1590:304:1;43690:111:0;43774:21;43690:111;;;2045:25:1;;;2033:2;2018:18;43690:111:0;1899:177:1;44675:274:0;;;;;;:::i;:::-;;:::i;64034:238::-;;;;;;:::i;:::-;;:::i;:::-;;;;2588:25:1;;;2644:2;2629:18;;2622:34;;;;2561:18;64034:238:0;2414:248:1;76913:142:0;;76960:95;76913:142;;43597:87;;;43676:2;2991:36:1;;2979:2;2964:18;43597:87:0;2849:184:1;78856:387:0;;;;;;:::i;:::-;;:::i;:::-;;77287:98;;;:::i;44955:226::-;;;;;;:::i;:::-;;:::i;60782:138::-;;60831:89;60782:138;;60534:49;;60579:4;60534:49;;62486:212;;;;;;:::i;:::-;;:::i;64329:821::-;;;;;;:::i;:::-;;:::i;41755:141::-;;;:::i;62755:245::-;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;5463:32:1;;;5445:51;;5433:2;5418:18;62755:245:0;5299:203:1;43807:294:0;;;;;;:::i;:::-;;:::i;79387:53::-;;;:::i;40813:464::-;;;:::i;:::-;;;;;;;;;;;;;:::i;43490:101::-;43568:17;;;;;;;;;;;;-1:-1:-1;;;43568:17:0;;;;43490:101;;45187:424;;;;;;:::i;:::-;;:::i;44107:190::-;;;;;;:::i;:::-;;:::i;60590:187::-;;60647:130;60590:187;;63486:491;;;;;;:::i;:::-;;:::i;76215:42::-;;;;;;:::i;:::-;;;;;;;;;;;;;;40571:159;;;;;;:::i;:::-;;:::i;77830:794::-;;;;;;:::i;:::-;;:::i;62239:190::-;;;;;;:::i;:::-;;:::i;44303:173::-;;;;;;:::i;:::-;-1:-1:-1;;;;;44443:18:0;;;44417:7;44443:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;44303:173;77062:36;;77097:1;77062:36;;44482:187;44565:4;22756:10;44613:32;22756:10;44629:7;44638:6;44613:8;:32::i;:::-;44659:4;44652:11;;;44482:187;;;;;:::o;63057:372::-;63130:7;63139;63155:39;63197:30;63217:9;63197:19;:30::i;:::-;63155:72;;63250:76;63270:9;63281:16;63299:26;63250:19;:76::i;:::-;63335:81;63355:9;63366:16;63384:31;63335:19;:81::i;:::-;63234:189;;;;;63057:372;;;:::o;44675:274::-;44792:4;22756:10;44842:38;44858:4;22756:10;44873:6;44842:15;:38::i;:::-;44887;44908:4;44914:2;44918:6;44887:20;:38::i;:::-;44939:4;44932:11;;;44675:274;;;;;;:::o;64034:238::-;64106:7;64115;64147:49;64163:4;64169:26;64147:15;:49::i;:::-;64205:54;64221:4;64227:31;64205:15;:54::i;:::-;64131:135;;;;64034:238;;;:::o;78856:387::-;79003:10;-1:-1:-1;;;;;79025:11:0;79003:34;;78995:60;;;;-1:-1:-1;;;78995:60:0;;;;;;;:::i;:::-;;;;;;;;;79147:9;79142:95;79162:20;;;79142:95;;;79214:9;;79224:1;79214:12;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;79194:43:0;79203:9;-1:-1:-1;;;;;79194:43:0;;79228:8;79194:43;;;;2045:25:1;;2033:2;2018:18;;1899:177;79194:43:0;;;;;;;;79184:3;;;:::i;:::-;;;79142:95;;;;78856:387;;;;;;;:::o;77287:98::-;77336:7;77359:20;:18;:20::i;:::-;77352:27;;77287:98;:::o;44955:226::-;22756:10;45043:4;45116:18;;;:11;:18;;;;;;;;-1:-1:-1;;;;;45116:27:0;;;;;;;;;;45043:4;;22756:10;45091:66;;22756:10;;45116:27;;:40;;45146:10;;45116:40;:::i;:::-;45091:8;:66::i;62486:212::-;62548:66;62564:10;62576:9;62587:26;62548:15;:66::i;:::-;62621:71;62637:10;62649:9;62660:31;62621:15;:71::i;:::-;62486:212;:::o;64329:821::-;-1:-1:-1;;;;;64553:23:0;;64545:49;;;;-1:-1:-1;;;64545:49:0;;;;;;;:::i;:::-;64660:8;64641:15;:27;;64633:58;;;;-1:-1:-1;;;64633:58:0;;8910:2:1;64633:58:0;;;8892:21:1;8949:2;8929:18;;;8922:30;-1:-1:-1;;;8968:18:1;;;8961:48;9026:18;;64633:58:0;8708:342:1;64633:58:0;64698:14;64715:287;64745:21;:19;:21::i;:::-;60647:130;64856:9;64878;64900:14;64927:27;64944:9;-1:-1:-1;;;;;80912:13:0;80774:7;80912:13;;;:7;:13;;;;;:15;;;;;;;;;80707:233;64927:27;64967:8;64795:191;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;64775:220;;;;;;58528:4;58522:11;-1:-1:-1;;;58547:23:0;;58600:4;58591:14;;58584:39;;;;58653:4;58644:14;;58637:34;58708:4;58693:20;;;58325:406;64715:287;64698:304;;65032:30;65046:6;65054:1;65057;65060;65032:13;:30::i;:::-;-1:-1:-1;;;;;65019:43:0;:9;-1:-1:-1;;;;;65019:43:0;;65011:73;;;;-1:-1:-1;;;65011:73:0;;10288:2:1;65011:73:0;;;10270:21:1;10327:2;10307:18;;;10300:30;-1:-1:-1;;;10346:18:1;;;10339:47;10403:18;;65011:73:0;10086:341:1;65011:73:0;65091:53;65107:9;65118;65129:14;65091:15;:53::i;41755:141::-;41799:13;41828:16;:5;:14;:16::i;62755:245::-;62890:7;62916:78;62936:9;62947:30;62967:9;62947:19;:30::i;:::-;62979:14;62916:19;:78::i;43807:294::-;43918:64;;-1:-1:-1;;;43918:64:0;;-1:-1:-1;;;;;43955:25:0;;;43918:64;;;2045:25:1;43881:7:0;;;;43918:11;:28;;;;2018:18:1;;43918:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;43897:85;-1:-1:-1;;;43988:39:0;;43984:71;;;44044:10;43807:294;-1:-1:-1;;43807:294:0:o;43984:71::-;-1:-1:-1;;;;;;;44069:18:0;:9;:18;;;;;;;;;;:26;-1:-1:-1;;;;;44069:26:0;;43807:294::o;79387:53::-;49411:23;;77097:1;;49400:34;;49392:93;;;;-1:-1:-1;;;49392:93:0;;10823:2:1;49392:93:0;;;10805:21:1;10862:2;10842:18;;;10835:30;10901:34;10881:18;;;10874:62;-1:-1:-1;;;10952:18:1;;;10945:44;11006:19;;49392:93:0;10621:410:1;49392:93:0;49494:23;:34;79387:53::o;40813:464::-;40894:13;40916:18;40943:21;40973:15;40997:25;41031:12;41052:27;41138:13;:11;:13::i;:::-;41160:16;:14;:16::i;:::-;41248;;;41237:1;41248:16;;;;;;;;;-1:-1:-1;;;41097:174:0;;;-1:-1:-1;41097:174:0;;-1:-1:-1;41185:13:0;;-1:-1:-1;41215:4:0;;-1:-1:-1;41237:1:0;-1:-1:-1;41248:16:0;-1:-1:-1;41097:174:0;-1:-1:-1;40813:464:0:o;45187:424::-;22756:10;45295:4;45373:18;;;:11;:18;;;;;;;;-1:-1:-1;;;;;45373:27:0;;;;;;;;;;45295:4;;22756:10;45415:35;;;;45407:85;;;;-1:-1:-1;;;45407:85:0;;11370:2:1;45407:85:0;;;11352:21:1;11409:2;11389:18;;;11382:30;11448:34;11428:18;;;11421:62;-1:-1:-1;;;11499:18:1;;;11492:35;11544:19;;45407:85:0;11168:401:1;45407:85:0;45518:60;45527:5;45534:7;45562:15;45543:16;:34;45518:8;:60::i;:::-;-1:-1:-1;45601:4:0;;45187:424;-1:-1:-1;;;;45187:424:0:o;44107:190::-;44186:4;22756:10;44234:39;22756:10;44262:2;44266:6;44234:20;:39::i;63486:491::-;63624:7;63643:32;63678:25;63698:4;63678:19;:25::i;:::-;63643:60;;63710:20;63774:14;63768:21;;;;;;;;:::i;:::-;:25;;63792:1;63768:25;:::i;:::-;63739:9;:24;;;63733:31;;;;;;;;:::i;:::-;:61;:66;;63798:1;63733:66;:104;;63836:1;63733:104;;;-1:-1:-1;;;;;80247:15:0;;80224:7;80247:15;;;;;;;;;;:23;-1:-1:-1;;;;;80247:23:0;63809:17;63710:127;;63844:26;63873:51;63898:9;63909:14;63873:24;:51::i;:::-;63844:80;-1:-1:-1;63938:33:0;63844:80;63938:12;:33;:::i;:::-;63931:40;63486:491;-1:-1:-1;;;;;;63486:491:0:o;40571:159::-;40646:7;40669:55;40691:20;:18;:20::i;:::-;40713:10;58528:4;58522:11;-1:-1:-1;;;58547:23:0;;58600:4;58591:14;;58584:39;;;;58653:4;58644:14;;58637:34;58708:4;58693:20;;;58325:406;77830:794;-1:-1:-1;;;;;78006:19:0;;77998:45;;;;-1:-1:-1;;;77998:45:0;;;;;;;:::i;:::-;78109:8;78090:15;:27;;78082:58;;;;-1:-1:-1;;;78082:58:0;;8910:2:1;78082:58:0;;;8892:21:1;8949:2;8929:18;;;8922:30;-1:-1:-1;;;8968:18:1;;;8961:48;9026:18;;78082:58:0;8708:342:1;78082:58:0;-1:-1:-1;;;;;78175:14:0;;;78147:25;78175:14;;;:7;:14;;;;;;;;;78248:79;;76960:95;78248:79;;;12014:25:1;;;;12093:18;;;12086:43;;;;12165:15;;;12145:18;;;12138:43;12197:18;;;12190:34;;;12240:19;;;12233:35;;;12284:19;;;12277:35;;;78175:14:0;;78213:122;;11986:19:1;;78248:79:0;;;;;;;;;;;;78238:90;;;;;;78213:16;:122::i;:::-;78196:139;;78361:30;78375:6;78383:1;78386;78389;78361:13;:30::i;:::-;-1:-1:-1;;;;;78352:39:0;:5;-1:-1:-1;;;;;78352:39:0;;78344:69;;;;-1:-1:-1;;;78344:69:0;;10288:2:1;78344:69:0;;;10270:21:1;10327:2;10307:18;;;10300:30;-1:-1:-1;;;10346:18:1;;;10339:47;10403:18;;78344:69:0;10086:341:1;78344:69:0;-1:-1:-1;;;;;78535:14:0;;;;;;:7;:14;;;;;78572:1;78552:21;;78535:38;;78587:31;78543:5;78603:7;78612:5;78587:8;:31::i;:::-;77991:633;;77830:794;;;;;;;:::o;62239:190::-;62369:54;62385:10;62397:9;62408:14;62369:15;:54::i;:::-;62239:190;;:::o;25307:292::-;25372:11;25396:17;25422:3;25396:30;;25455:2;25441:4;:11;:16;25437:74;;;25495:3;25481:18;;-1:-1:-1;;;25481:18:0;;;;;;;;:::i;25437:74::-;25578:11;;25561:13;25578:4;25561:13;:::i;:::-;25553:36;;25307:292;-1:-1:-1;;;25307:292:0:o;28351:716::-;28407:13;28458:14;28475:17;28486:5;28475:10;:17::i;:::-;28495:1;28475:21;28458:38;;28511:20;28545:6;28534:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;28534:18:0;-1:-1:-1;28511:41:0;-1:-1:-1;28676:28:0;;;28692:2;28676:28;28733:288;-1:-1:-1;;28765:5:0;-1:-1:-1;;;28902:2:0;28891:14;;28886:30;28765:5;28873:44;28963:2;28954:11;;;-1:-1:-1;28984:21:0;28733:288;28984:21;-1:-1:-1;29042:6:0;28351:716;-1:-1:-1;;;28351:716:0:o;15870:948::-;15923:7;;-1:-1:-1;;;16001:17:0;;15997:106;;-1:-1:-1;;;16039:17:0;;;-1:-1:-1;16085:2:0;16075:12;15997:106;16130:8;16121:5;:17;16117:106;;16168:8;16159:17;;;-1:-1:-1;16205:2:0;16195:12;16117:106;16250:8;16241:5;:17;16237:106;;16288:8;16279:17;;;-1:-1:-1;16325:2:0;16315:12;16237:106;16370:7;16361:5;:16;16357:103;;16407:7;16398:16;;;-1:-1:-1;16443:1:0;16433:11;16357:103;16487:7;16478:5;:16;16474:103;;16524:7;16515:16;;;-1:-1:-1;16560:1:0;16550:11;16474:103;16604:7;16595:5;:16;16591:103;;16641:7;16632:16;;;-1:-1:-1;16677:1:0;16667:11;16591:103;16721:7;16712:5;:16;16708:68;;16759:1;16749:11;16804:6;15870:948;-1:-1:-1;;15870:948:0:o;46402:409::-;-1:-1:-1;;;;;46520:19:0;;46512:68;;;;-1:-1:-1;;;46512:68:0;;12959:2:1;46512:68:0;;;12941:21:1;12998:2;12978:18;;;12971:30;13037:34;13017:18;;;13010:62;-1:-1:-1;;;13088:18:1;;;13081:34;13132:19;;46512:68:0;12757:400:1;46512:68:0;-1:-1:-1;;;;;46595:21:0;;46587:68;;;;-1:-1:-1;;;46587:68:0;;13364:2:1;46587:68:0;;;13346:21:1;13403:2;13383:18;;;13376:30;13442:34;13422:18;;;13415:62;-1:-1:-1;;;13493:18:1;;;13486:32;13535:19;;46587:68:0;13162:398:1;46587:68:0;46677:10;-1:-1:-1;;;;;46668:19:0;;;46664:55;;46691:11;-1:-1:-1;;;;;46691:23:0;;:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;46691:25:0;;;;;;;;;;;;:::i;:::-;;46664:55;-1:-1:-1;;;;;46725:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;46773:32;;2045:25:1;;;46773:32:0;;2018:18:1;46773:32:0;;;;;;;46402:409;;;:::o;79717:434::-;79812:22;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;79812:22:0;-1:-1:-1;;;;;79888:15:0;;79846:39;79888:15;;;;;;;;;;;79846:57;;;;;;;;;-1:-1:-1;;;;;79846:57:0;;;;-1:-1:-1;;;;;;;;79846:57:0;;;;;;;;;;;-1:-1:-1;;;79846:57:0;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;79846:57:0;;;;;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;79924:221;;;;;;;;79980:9;:37;;;-1:-1:-1;;;;;79924:221:0;;;;;80052:9;:32;;;-1:-1:-1;;;;;79924:221:0;;;;;80111:9;:24;;;79924:221;;;;;;;;:::i;:::-;;;79910:235;79717:434;-1:-1:-1;;;79717:434:0:o;71337:770::-;71498:7;;71518:14;:44;;;;;;;;:::i;:::-;;71514:437;;71840:31;71806:9;:24;;;71800:31;;;;;;;;:::i;:::-;:72;71799:79;;71877:1;71799:79;:144;;71941:1;71799:144;;;-1:-1:-1;;;;;71892:27:0;;;;;;;:16;:27;;;;;;;71799:144;71573:370;;;;71514:437;71999:36;71971:9;:24;;;:64;;;;;;;;:::i;:::-;;;:130;;72099:1;71971:130;;;-1:-1:-1;;;;;72047:32:0;;;;;;;:21;:32;;;;;;;71971:130;71957:144;71337:770;-1:-1:-1;;;;71337:770:0:o;46817:399::-;-1:-1:-1;;;;;44443:18:0;;;46934:24;44443:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;-1:-1:-1;;46997:37:0;;46993:218;;47073:6;47053:16;:26;;47045:68;;;;-1:-1:-1;;;47045:68:0;;14669:2:1;47045:68:0;;;14651:21:1;14708:2;14688:18;;;14681:30;14747:31;14727:18;;;14720:59;14796:18;;47045:68:0;14467:353:1;47045:68:0;47143:51;47152:5;47159:7;47187:6;47168:16;:25;47143:8;:51::i;:::-;46927:289;46817:399;;;:::o;47222:275::-;47376:64;;;-1:-1:-1;;;;;15112:15:1;;;47376:64:0;;;15094:34:1;15164:15;;;15144:18;;;15137:43;15196:18;;;15189:34;;;47429:10:0;15239:18:1;;;;15232:43;;;;47376:64:0;;;;;;;;;;15028:19:1;;;;47376:64:0;;;;;;;-1:-1:-1;;;;;47376:64:0;-1:-1:-1;;;47376:64:0;;;47350:91;;-1:-1:-1;;47358:11:0;47350:25;;:91;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47338:103;;;47451:1;47443:10;;;;;;47480:2;-1:-1:-1;;;;;47465:26:0;47474:4;-1:-1:-1;;;;;47465:26:0;;47484:6;47465:26;;;;2045:25:1;;2033:2;2018:18;;1899:177;47465:26:0;;;;;;;;47331:166;47222:275;;;:::o;39521:251::-;39574:7;39602:4;-1:-1:-1;;;;;39619:11:0;39594:37;;:72;;;;;39652:14;39635:13;:31;39594:72;39590:177;;;-1:-1:-1;39684:22:0;;39521:251::o;39590:177::-;39736:23;39873:81;;;37455:95;39873:81;;;16243:25:1;39896:11:0;16284:18:1;;;16277:34;;;;39909:14:0;16327:18:1;;;16320:34;39925:13:0;16370:18:1;;;16363:34;39948:4:0;16413:19:1;;;16406:61;39833:7:0;;16215:19:1;;39873:81:0;;;;;;;;;;;;39863:92;;;;;;39849:106;;39778:183;;74432:1595;74779:17;74813:9;-1:-1:-1;;;;;74799:23:0;:10;-1:-1:-1;;;;;74799:23:0;;:49;;74838:10;74799:49;;;74833:1;74799:49;74779:69;;75043:37;75083:30;75103:9;75083:19;:30::i;:::-;75043:70;;75120:24;75147:62;75167:9;75178:14;75194;75147:19;:62::i;:::-;75120:89;;75233:16;-1:-1:-1;;;;;75220:29:0;:9;-1:-1:-1;;;;;75220:29:0;;75216:42;;75251:7;;;74432:1595;;;:::o;75216:42::-;-1:-1:-1;;;;;75287:30:0;;;;;;75349:23;;;;75266:18;75406:22;75418:9;-1:-1:-1;;;;;80247:15:0;80224:7;80247:15;;;;;;;;;;:23;-1:-1:-1;;;;;80247:23:0;;80157:119;75406:22;75379:49;;75441:13;75437:121;;;75465:85;75496:16;75514:1;75517:16;75535:14;75465:30;:85::i;:::-;75570:17;75566:118;;;75598:78;75629:1;75632:16;75650:9;75661:14;75598:30;:78::i;:::-;75692:60;75715:9;75726:14;75742:9;75692:22;:60::i;:::-;75786:13;75765:34;;:17;:34;;;75761:194;;75810:137;75840:9;75860:78;75888:14;75904;75920:17;75860:27;:78::i;:::-;75810:19;:137::i;:::-;75995:9;-1:-1:-1;;;;;75968:53:0;75984:9;-1:-1:-1;;;;;75968:53:0;;76006:14;75968:53;;;;;;:::i;:::-;;;;;;;;74561:1466;;;;;;74432:1595;;;:::o;80946:110::-;81009:7;81032:18;:16;:18::i;56541:236::-;56626:7;56647:17;56666:18;56688:25;56699:4;56705:1;56708;56711;56688:10;:25::i;:::-;56646:67;;;;56724:18;56736:5;56724:11;:18::i;:::-;-1:-1:-1;56760:9:0;56541:236;-1:-1:-1;;;;;56541:236:0:o;25688:415::-;25747:13;25773:11;25787:16;25798:4;25787:10;:16::i;:::-;25913:14;;;25924:2;25913:14;;;;;;;;;25773:30;;-1:-1:-1;25893:17:0;;25913:14;;;;;;;;;-1:-1:-1;;;26006:16:0;;;-1:-1:-1;26052:4:0;26043:14;;26036:28;;;;-1:-1:-1;26006:16:0;25688:415::o;42380:103::-;42429:13;42458:19;:8;:17;:19::i;70581:367::-;70723:7;;70792:14;:44;;;;;;;;:::i;:::-;;:141;;70896:37;;70792:141;;;70850:9;:32;;;70792:141;70753:189;;-1:-1:-1;;;;;70753:189:0;60579:4;70753:189;:::i;67020:1308::-;-1:-1:-1;;;;;67227:23:0;;67223:36;67252:7;67223:36;67265:64;;;67322:7;67265:64;67525:33;67561:80;67589:45;60579:4;67589:24;:45;:::i;:::-;67561:19;:80::i;:::-;67525:116;-1:-1:-1;67648:32:0;67683:79;67711:44;60579:4;67711:23;:44;:::i;67683:79::-;67648:114;;67771:37;67811:30;67831:9;67811:19;:30::i;:::-;67771:70;-1:-1:-1;67870:26:0;67852:14;:44;;;;;;;;:::i;:::-;;67848:422;;68043:25;68005:26;67956:14;:37;;;:75;;;;:::i;:::-;:112;;;;:::i;:::-;-1:-1:-1;;;;;67907:161:0;:37;;;:161;67848:422;;;68145:42;;68237:25;;68145:80;;68199:26;;68145:80;:::i;:::-;:117;;;;:::i;:::-;-1:-1:-1;;;;;68091:171:0;;;67848:422;68276:46;68296:9;68307:14;68276:19;:46::i;:::-;67216:1112;;;67020:1308;;;;:::o;72390:415::-;72536:20;72576:9;-1:-1:-1;;;;;72559:26:0;:13;-1:-1:-1;;;;;72559:26:0;;:55;;72601:13;72559:55;;;72596:1;72559:55;72536:78;-1:-1:-1;72643:26:0;72625:14;:44;;;;;;;;:::i;:::-;;72621:179;;-1:-1:-1;;;;;72680:27:0;;;;;;;:16;:27;;;;;:42;;-1:-1:-1;;;;;;72680:42:0;;;;;;;;;;72621:179;;;-1:-1:-1;;;;;72745:32:0;;;;;;;:21;:32;;;;;:47;;-1:-1:-1;;;;;;72745:47:0;;;;;;;;;-1:-1:-1;;72390:415:0:o;73138:859::-;73307:22;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;73307:22:0;73342:12;73338:631;;;73559:14;73553:21;;;;;;;;:::i;:::-;:25;;73577:1;73553:25;:::i;:::-;73524:9;:24;;;73518:31;;;;;;;;:::i;:::-;:61;73493:95;;;;;;;;;;:::i;:::-;73466:9;:24;;:122;;;;;;;;;:::i;:::-;;;;;;;;;;;:::i;:::-;;;-1:-1:-1;73338:631:0;;;73915:35;73886:14;73880:21;;;;;;;;:::i;:::-;:25;;73904:1;73880:25;:::i;:::-;73879:72;73839:9;:24;;;73833:31;;;;;;;;:::i;:::-;:119;73808:153;;;;;;;;;;:::i;:::-;73781:9;:24;;:180;;;;;;;;;:::i;:::-;;;;;;;;;;;:::i;:::-;;;-1:-1:-1;73338:631:0;-1:-1:-1;73982:9:0;;73138:859;-1:-1:-1;;73138:859:0:o;80282:419::-;-1:-1:-1;;;;;80446:15:0;;80403:40;80446:15;;;;;;;;;;;;80508:43;;80468:83;;80593:38;;;;-1:-1:-1;;;;80558:73:0;;;-1:-1:-1;;;;;;;;80468:83:0;;;;-1:-1:-1;;;;80558:73:0;;-1:-1:-1;;;80558:73:0;;;;;;;;;;;;80665:30;;;;80446:15;;;;-1:-1:-1;;;;;80638:57:0;-1:-1:-1;;;80665:30:0;80638:57;;;;;;;;:::i;:::-;;;;;;80396:305;80282:419;;:::o;54925:1477::-;55013:7;;55947:66;55934:79;;55930:163;;;-1:-1:-1;56046:1:0;;-1:-1:-1;56050:30:0;56030:51;;55930:163;56207:24;;;56190:14;56207:24;;;;;;;;;17304:25:1;;;17377:4;17365:17;;17345:18;;;17338:45;;;;17399:18;;;17392:34;;;17442:18;;;17435:34;;;56207:24:0;;17276:19:1;;56207:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;56207:24:0;;-1:-1:-1;;56207:24:0;;;-1:-1:-1;;;;;;;56246:20:0;;56242:103;;56299:1;56303:29;56283:50;;;;;;;56242:103;56365:6;-1:-1:-1;56373:20:0;;-1:-1:-1;54925:1477:0;;;;;;;;:::o;50385:521::-;50463:20;50454:5;:29;;;;;;;;:::i;:::-;;50450:449;;50385:521;:::o;50450:449::-;50561:29;50552:5;:38;;;;;;;;:::i;:::-;;50548:351;;50607:34;;-1:-1:-1;;;50607:34:0;;17682:2:1;50607:34:0;;;17664:21:1;17721:2;17701:18;;;17694:30;17760:26;17740:18;;;17733:54;17804:18;;50607:34:0;17480:348:1;50548:351:0;50672:35;50663:5;:44;;;;;;;;:::i;:::-;;50659:240;;50724:41;;-1:-1:-1;;;50724:41:0;;18035:2:1;50724:41:0;;;18017:21:1;18074:2;18054:18;;;18047:30;18113:33;18093:18;;;18086:61;18164:18;;50724:41:0;17833:355:1;50659:240:0;50796:30;50787:5;:39;;;;;;;;:::i;:::-;;50783:116;;50843:44;;-1:-1:-1;;;50843:44:0;;18395:2:1;50843:44:0;;;18377:21:1;18434:2;18414:18;;;18407:30;18473:34;18453:18;;;18446:62;-1:-1:-1;;;18524:18:1;;;18517:32;18566:19;;50843:44:0;18193:398:1;26180:251:0;26241:7;26314:4;26278:40;;26342:2;26333:11;;26329:71;;;26368:20;;-1:-1:-1;;;26368:20:0;;;;;;;;;;;35249:180;35305:6;-1:-1:-1;;;;;35328:25:0;;;35320:76;;;;-1:-1:-1;;;35320:76:0;;18798:2:1;35320:76:0;;;18780:21:1;18837:2;18817:18;;;18810:30;18876:34;18856:18;;;18849:62;-1:-1:-1;;;18927:18:1;;;18920:36;18973:19;;35320:76:0;18596:402:1;35320:76:0;-1:-1:-1;35417:5:0;35249:180::o;14:250:1:-;99:1;109:113;123:6;120:1;117:13;109:113;;;199:11;;;193:18;180:11;;;173:39;145:2;138:10;109:113;;;-1:-1:-1;;256:1:1;238:16;;231:27;14:250::o;269:271::-;311:3;349:5;343:12;376:6;371:3;364:19;392:76;461:6;454:4;449:3;445:14;438:4;431:5;427:16;392:76;:::i;:::-;522:2;501:15;-1:-1:-1;;497:29:1;488:39;;;;529:4;484:50;;269:271;-1:-1:-1;;269:271:1:o;545:220::-;694:2;683:9;676:21;657:4;714:45;755:2;744:9;740:18;732:6;714:45;:::i;770:173::-;838:20;;-1:-1:-1;;;;;887:31:1;;877:42;;867:70;;933:1;930;923:12;867:70;770:173;;;:::o;948:254::-;1016:6;1024;1077:2;1065:9;1056:7;1052:23;1048:32;1045:52;;;1093:1;1090;1083:12;1045:52;1116:29;1135:9;1116:29;:::i;:::-;1106:39;1192:2;1177:18;;;;1164:32;;-1:-1:-1;;;948:254:1:o;1399:186::-;1458:6;1511:2;1499:9;1490:7;1486:23;1482:32;1479:52;;;1527:1;1524;1517:12;1479:52;1550:29;1569:9;1550:29;:::i;2081:328::-;2158:6;2166;2174;2227:2;2215:9;2206:7;2202:23;2198:32;2195:52;;;2243:1;2240;2233:12;2195:52;2266:29;2285:9;2266:29;:::i;:::-;2256:39;;2314:38;2348:2;2337:9;2333:18;2314:38;:::i;:::-;2304:48;;2399:2;2388:9;2384:18;2371:32;2361:42;;2081:328;;;;;:::o;3038:156::-;3104:20;;3164:4;3153:16;;3143:27;;3133:55;;3184:1;3181;3174:12;3199:966;3328:6;3336;3344;3352;3360;3368;3376;3429:3;3417:9;3408:7;3404:23;3400:33;3397:53;;;3446:1;3443;3436:12;3397:53;3469:29;3488:9;3469:29;:::i;:::-;3459:39;;3549:2;3538:9;3534:18;3521:32;3572:18;3613:2;3605:6;3602:14;3599:34;;;3629:1;3626;3619:12;3599:34;3667:6;3656:9;3652:22;3642:32;;3712:7;3705:4;3701:2;3697:13;3693:27;3683:55;;3734:1;3731;3724:12;3683:55;3774:2;3761:16;3800:2;3792:6;3789:14;3786:34;;;3816:1;3813;3806:12;3786:34;3869:7;3864:2;3854:6;3851:1;3847:14;3843:2;3839:23;3835:32;3832:45;3829:65;;;3890:1;3887;3880:12;3829:65;3921:2;3917;3913:11;3903:21;;3943:6;3933:16;;;;;3996:2;3985:9;3981:18;3968:32;3958:42;;4019:36;4051:2;4040:9;4036:18;4019:36;:::i;:::-;4009:46;;4102:3;4091:9;4087:19;4074:33;4064:43;;4154:3;4143:9;4139:19;4126:33;4116:43;;3199:966;;;;;;;;;;:::o;4170:160::-;4255:20;;4304:1;4294:12;;4284:40;;4320:1;4317;4310:12;4335:653;4470:6;4478;4486;4494;4502;4510;4518;4571:3;4559:9;4550:7;4546:23;4542:33;4539:53;;;4588:1;4585;4578:12;4539:53;4611:29;4630:9;4611:29;:::i;:::-;4601:39;;4659:38;4693:2;4682:9;4678:18;4659:38;:::i;:::-;4649:48;;4716:55;4767:2;4756:9;4752:18;4716:55;:::i;:::-;4706:65;;4818:2;4807:9;4803:18;4790:32;4780:42;;4841:37;4873:3;4862:9;4858:19;4841:37;:::i;:::-;4831:47;;4925:3;4914:9;4910:19;4897:33;4887:43;;4977:3;4966:9;4962:19;4949:33;4939:43;;4335:653;;;;;;;;;;:::o;4993:301::-;5085:6;5093;5146:2;5134:9;5125:7;5121:23;5117:32;5114:52;;;5162:1;5159;5152:12;5114:52;5185:29;5204:9;5185:29;:::i;:::-;5175:39;;5233:55;5284:2;5273:9;5269:18;5233:55;:::i;:::-;5223:65;;4993:301;;;;;:::o;5507:1259::-;5913:3;5908;5904:13;5896:6;5892:26;5881:9;5874:45;5855:4;5938:2;5976:3;5971:2;5960:9;5956:18;5949:31;6003:46;6044:3;6033:9;6029:19;6021:6;6003:46;:::i;:::-;6097:9;6089:6;6085:22;6080:2;6069:9;6065:18;6058:50;6131:33;6157:6;6149;6131:33;:::i;:::-;6195:2;6180:18;;6173:34;;;-1:-1:-1;;;;;6244:32:1;;6238:3;6223:19;;6216:61;6264:3;6293:19;;6286:35;;;6358:22;;;6352:3;6337:19;;6330:51;6430:13;;6452:22;;;6528:15;;;;-1:-1:-1;6490:15:1;;;;-1:-1:-1;6571:169:1;6585:6;6582:1;6579:13;6571:169;;;6646:13;;6634:26;;6715:15;;;;6680:12;;;;6607:1;6600:9;6571:169;;;-1:-1:-1;6757:3:1;;5507:1259;-1:-1:-1;;;;;;;;;;;;5507:1259:1:o;6771:180::-;6830:6;6883:2;6871:9;6862:7;6858:23;6854:32;6851:52;;;6899:1;6896;6889:12;6851:52;-1:-1:-1;6922:23:1;;6771:180;-1:-1:-1;6771:180:1:o;6956:606::-;7067:6;7075;7083;7091;7099;7107;7115;7168:3;7156:9;7147:7;7143:23;7139:33;7136:53;;;7185:1;7182;7175:12;7136:53;7208:29;7227:9;7208:29;:::i;:::-;7198:39;;7256:38;7290:2;7279:9;7275:18;7256:38;:::i;:::-;7246:48;;7341:2;7330:9;7326:18;7313:32;7303:42;;7392:2;7381:9;7377:18;7364:32;7354:42;;7415:37;7447:3;7436:9;7432:19;7415:37;:::i;7567:260::-;7635:6;7643;7696:2;7684:9;7675:7;7671:23;7667:32;7664:52;;;7712:1;7709;7702:12;7664:52;7735:29;7754:9;7735:29;:::i;:::-;7725:39;;7783:38;7817:2;7806:9;7802:18;7783:38;:::i;7832:337::-;8034:2;8016:21;;;8073:2;8053:18;;;8046:30;-1:-1:-1;;;8107:2:1;8092:18;;8085:43;8160:2;8145:18;;7832:337::o;8174:127::-;8235:10;8230:3;8226:20;8223:1;8216:31;8266:4;8263:1;8256:15;8290:4;8287:1;8280:15;8306:127;8367:10;8362:3;8358:20;8355:1;8348:31;8398:4;8395:1;8388:15;8422:4;8419:1;8412:15;8438:135;8477:3;8498:17;;;8495:43;;8518:18;;:::i;:::-;-1:-1:-1;8565:1:1;8554:13;;8438:135::o;8578:125::-;8643:9;;;8664:10;;;8661:36;;;8677:18;;:::i;9055:127::-;9116:10;9111:3;9107:20;9104:1;9097:31;9147:4;9144:1;9137:15;9171:4;9168:1;9161:15;9187:247;9278:1;9271:5;9268:12;9258:143;;9323:10;9318:3;9314:20;9311:1;9304:31;9358:4;9355:1;9348:15;9386:4;9383:1;9376:15;9258:143;9410:18;;9187:247::o;9439:642::-;9748:25;;;-1:-1:-1;;;;;9847:15:1;;;9842:2;9827:18;;9820:43;9899:15;;9894:2;9879:18;;9872:43;9735:3;9720:19;;9924:63;9983:2;9968:18;;9960:6;9924:63;:::i;:::-;10018:3;10003:19;;9996:35;;;;10062:3;10047:19;10040:35;9439:642;;-1:-1:-1;;;;9439:642:1:o;10432:184::-;10502:6;10555:2;10543:9;10534:7;10530:23;10526:32;10523:52;;;10571:1;10568;10561:12;10523:52;-1:-1:-1;10594:16:1;;10432:184;-1:-1:-1;10432:184:1:o;11036:127::-;11097:10;11092:3;11088:20;11085:1;11078:31;11128:4;11125:1;11118:15;11152:4;11149:1;11142:15;11574:148;11662:4;11641:12;;;11655;;;11637:31;;11680:13;;11677:39;;;11696:18;;:::i;12323:297::-;12441:12;;12488:4;12477:16;;;12471:23;;12441:12;12506:16;;12503:111;;;12600:1;12596:6;12586;12580:4;12576:17;12573:1;12569:25;12565:38;12558:5;12554:50;12545:59;;12503:111;;12323:297;;;:::o;13565:897::-;13645:6;13698:2;13686:9;13677:7;13673:23;13669:32;13666:52;;;13714:1;13711;13704:12;13666:52;13747:9;13741:16;13776:18;13817:2;13809:6;13806:14;13803:34;;;13833:1;13830;13823:12;13803:34;13871:6;13860:9;13856:22;13846:32;;13916:7;13909:4;13905:2;13901:13;13897:27;13887:55;;13938:1;13935;13928:12;13887:55;13967:2;13961:9;13989:2;13985;13982:10;13979:36;;;13995:18;;:::i;:::-;14070:2;14064:9;14038:2;14124:13;;-1:-1:-1;;14120:22:1;;;14144:2;14116:31;14112:40;14100:53;;;14168:18;;;14188:22;;;14165:46;14162:72;;;14214:18;;:::i;:::-;14254:10;14250:2;14243:22;14289:2;14281:6;14274:18;14329:7;14324:2;14319;14315;14311:11;14307:20;14304:33;14301:53;;;14350:1;14347;14340:12;14301:53;14363:68;14428:2;14423;14415:6;14411:15;14406:2;14402;14398:11;14363:68;:::i;:::-;14450:6;13565:897;-1:-1:-1;;;;;;;13565:897:1:o;15286:287::-;15415:3;15453:6;15447:13;15469:66;15528:6;15523:3;15516:4;15508:6;15504:17;15469:66;:::i;:::-;15551:16;;;;;15286:287;-1:-1:-1;;15286:287:1:o;15578:228::-;15734:2;15719:18;;15746:54;15723:9;15782:6;15746:54;:::i;15811:168::-;15851:7;15917:1;15913;15909:6;15905:14;15902:1;15899:21;15894:1;15887:9;15880:17;15876:45;15873:71;;;15924:18;;:::i;:::-;-1:-1:-1;15964:9:1;;15811:168::o;16478:217::-;16518:1;16544;16534:132;;16588:10;16583:3;16579:20;16576:1;16569:31;16623:4;16620:1;16613:15;16651:4;16648:1;16641:15;16534:132;-1:-1:-1;16680:9:1;;16478:217::o;16700:185::-;-1:-1:-1;;;;;16821:10:1;;;16809;;;16805:27;;16844:12;;;16841:38;;;16859:18;;:::i;:::-;16841:38;16700:185;;;;:::o;16890:182::-;-1:-1:-1;;;;;16997:10:1;;;17009;;;16993:27;;17032:11;;;17029:37;;;17046:18;;:::i

Swarm Source

ipfs://5340776090b64c8f635f6e72bf5a30bf7abf7fcfaf281dbee45b5147f51f2516