More Info
Private Name Tags
ContractCreator
TokenTracker
Latest 25 from a total of 1,070 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Approve | 20591371 | 6 days ago | IN | 0 ETH | 0.00005032 | ||||
Approve | 20555150 | 11 days ago | IN | 0 ETH | 0.00012801 | ||||
Approve | 20426897 | 29 days ago | IN | 0 ETH | 0.000735 | ||||
Approve | 20338770 | 41 days ago | IN | 0 ETH | 0.00023729 | ||||
Approve | 20294852 | 47 days ago | IN | 0 ETH | 0.00003429 | ||||
Approve | 20294843 | 47 days ago | IN | 0 ETH | 0.00005808 | ||||
Approve | 20288052 | 48 days ago | IN | 0 ETH | 0.00010646 | ||||
Approve | 20262391 | 52 days ago | IN | 0 ETH | 0.00049361 | ||||
Approve | 20199007 | 61 days ago | IN | 0 ETH | 0.00012194 | ||||
Approve | 20198998 | 61 days ago | IN | 0 ETH | 0.00012358 | ||||
Approve | 20198996 | 61 days ago | IN | 0 ETH | 0.00028658 | ||||
Approve | 20173415 | 64 days ago | IN | 0 ETH | 0.00009931 | ||||
Approve | 20148548 | 68 days ago | IN | 0 ETH | 0.00011027 | ||||
Approve | 20148548 | 68 days ago | IN | 0 ETH | 0.00011027 | ||||
Approve | 20148545 | 68 days ago | IN | 0 ETH | 0.00011198 | ||||
Approve | 20127058 | 71 days ago | IN | 0 ETH | 0.00070038 | ||||
Approve | 20088999 | 76 days ago | IN | 0 ETH | 0.00036528 | ||||
Approve | 20066573 | 79 days ago | IN | 0 ETH | 0.00044003 | ||||
Approve | 20052258 | 81 days ago | IN | 0 ETH | 0.0000913 | ||||
Approve | 20021298 | 86 days ago | IN | 0 ETH | 0.00024068 | ||||
Approve | 20021296 | 86 days ago | IN | 0 ETH | 0.00024728 | ||||
Approve | 19984982 | 91 days ago | IN | 0 ETH | 0.00064728 | ||||
Approve | 19956734 | 95 days ago | IN | 0 ETH | 0.00033242 | ||||
Approve | 19930111 | 98 days ago | IN | 0 ETH | 0.00020737 | ||||
Approve | 19915227 | 100 days ago | IN | 0 ETH | 0.0004801 |
Latest 2 internal transactions
Advanced mode:
Parent Transaction Hash | Block | From | To | |||
---|---|---|---|---|---|---|
19242991 | 195 days ago | 10 ETH | ||||
19242774 | 195 days ago | Contract Creation | 0 ETH |
Loading...
Loading
Contract Source Code Verified (Exact Match)
Contract Name:
YBOYZ
Compiler Version
v0.8.24+commit.e11b9ed9
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2024-02-16 */ /** Twitter: https://twitter.com/YardBoyzERCYB Telegram: https://t.me/YardBoyzPortal Website: https://yardboyz.xyz */ // SPDX-License-Identifier: MIT pragma solidity ^0.8.4; interface IUniswapV2Router02 { function factory() external pure returns (address); function WETH() external pure returns (address); function addLiquidity( address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline ) external returns ( uint256 amountA, uint256 amountB, uint256 liquidity ); function addLiquidityETH( address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline ) external payable returns ( uint256 amountToken, uint256 amountETH, uint256 liquidity ); function swapExactTokensForETHSupportingFeeOnTransferTokens( uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline ) external; } /// @notice Library for storage of packed unsigned integers. /// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibMap.sol) library LibMap { /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/ /* STRUCTS */ /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/ /// @dev A uint8 map in storage. struct Uint8Map { mapping(uint256 => uint256) map; } /// @dev A uint16 map in storage. struct Uint16Map { mapping(uint256 => uint256) map; } /// @dev A uint32 map in storage. struct Uint32Map { mapping(uint256 => uint256) map; } /// @dev A uint40 map in storage. Useful for storing timestamps up to 34841 A.D. struct Uint40Map { mapping(uint256 => uint256) map; } /// @dev A uint64 map in storage. struct Uint64Map { mapping(uint256 => uint256) map; } /// @dev A uint128 map in storage. struct Uint128Map { mapping(uint256 => uint256) map; } /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/ /* GETTERS / SETTERS */ /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/ /// @dev Returns the uint8 value at `index` in `map`. function get(Uint8Map storage map, uint256 index) internal view returns (uint8 result) { /// @solidity memory-safe-assembly assembly { mstore(0x20, map.slot) mstore(0x00, shr(5, index)) result := byte(and(31, not(index)), sload(keccak256(0x00, 0x40))) } } /// @dev Updates the uint8 value at `index` in `map`. function set(Uint8Map storage map, uint256 index, uint8 value) internal { /// @solidity memory-safe-assembly assembly { mstore(0x20, map.slot) mstore(0x00, shr(5, index)) let s := keccak256(0x00, 0x40) // Storage slot. mstore(0x00, sload(s)) mstore8(and(31, not(index)), value) sstore(s, mload(0x00)) } } /// @dev Returns the uint16 value at `index` in `map`. function get(Uint16Map storage map, uint256 index) internal view returns (uint16 result) { result = uint16(map.map[index >> 4] >> ((index & 15) << 4)); } /// @dev Updates the uint16 value at `index` in `map`. function set(Uint16Map storage map, uint256 index, uint16 value) internal { /// @solidity memory-safe-assembly assembly { mstore(0x20, map.slot) mstore(0x00, shr(4, index)) let s := keccak256(0x00, 0x40) // Storage slot. let o := shl(4, and(index, 15)) // Storage slot offset (bits). let v := sload(s) // Storage slot value. let m := 0xffff // Value mask. sstore(s, xor(v, shl(o, and(m, xor(shr(o, v), value))))) } } /// @dev Returns the uint32 value at `index` in `map`. function get(Uint32Map storage map, uint256 index) internal view returns (uint32 result) { result = uint32(map.map[index >> 3] >> ((index & 7) << 5)); } /// @dev Updates the uint32 value at `index` in `map`. function set(Uint32Map storage map, uint256 index, uint32 value) internal { /// @solidity memory-safe-assembly assembly { mstore(0x20, map.slot) mstore(0x00, shr(3, index)) let s := keccak256(0x00, 0x40) // Storage slot. let o := shl(5, and(index, 7)) // Storage slot offset (bits). let v := sload(s) // Storage slot value. let m := 0xffffffff // Value mask. sstore(s, xor(v, shl(o, and(m, xor(shr(o, v), value))))) } } /// @dev Returns the uint40 value at `index` in `map`. function get(Uint40Map storage map, uint256 index) internal view returns (uint40 result) { unchecked { result = uint40(map.map[index / 6] >> ((index % 6) * 40)); } } /// @dev Updates the uint40 value at `index` in `map`. function set(Uint40Map storage map, uint256 index, uint40 value) internal { /// @solidity memory-safe-assembly assembly { mstore(0x20, map.slot) mstore(0x00, div(index, 6)) let s := keccak256(0x00, 0x40) // Storage slot. let o := mul(40, mod(index, 6)) // Storage slot offset (bits). let v := sload(s) // Storage slot value. let m := 0xffffffffff // Value mask. sstore(s, xor(v, shl(o, and(m, xor(shr(o, v), value))))) } } /// @dev Returns the uint64 value at `index` in `map`. function get(Uint64Map storage map, uint256 index) internal view returns (uint64 result) { result = uint64(map.map[index >> 2] >> ((index & 3) << 6)); } /// @dev Updates the uint64 value at `index` in `map`. function set(Uint64Map storage map, uint256 index, uint64 value) internal { /// @solidity memory-safe-assembly assembly { mstore(0x20, map.slot) mstore(0x00, shr(2, index)) let s := keccak256(0x00, 0x40) // Storage slot. let o := shl(6, and(index, 3)) // Storage slot offset (bits). let v := sload(s) // Storage slot value. let m := 0xffffffffffffffff // Value mask. sstore(s, xor(v, shl(o, and(m, xor(shr(o, v), value))))) } } /// @dev Returns the uint128 value at `index` in `map`. function get(Uint128Map storage map, uint256 index) internal view returns (uint128 result) { result = uint128(map.map[index >> 1] >> ((index & 1) << 7)); } /// @dev Updates the uint128 value at `index` in `map`. function set(Uint128Map storage map, uint256 index, uint128 value) internal { /// @solidity memory-safe-assembly assembly { mstore(0x20, map.slot) mstore(0x00, shr(1, index)) let s := keccak256(0x00, 0x40) // Storage slot. let o := shl(7, and(index, 1)) // Storage slot offset (bits). let v := sload(s) // Storage slot value. let m := 0xffffffffffffffffffffffffffffffff // Value mask. sstore(s, xor(v, shl(o, and(m, xor(shr(o, v), value))))) } } /// @dev Returns the value at `index` in `map`. function get(mapping(uint256 => uint256) storage map, uint256 index, uint256 bitWidth) internal view returns (uint256 result) { unchecked { uint256 d = _rawDiv(256, bitWidth); // Bucket size. uint256 m = (1 << bitWidth) - 1; // Value mask. result = (map[_rawDiv(index, d)] >> (_rawMod(index, d) * bitWidth)) & m; } } /// @dev Updates the value at `index` in `map`. function set( mapping(uint256 => uint256) storage map, uint256 index, uint256 value, uint256 bitWidth ) internal { unchecked { uint256 d = _rawDiv(256, bitWidth); // Bucket size. uint256 m = (1 << bitWidth) - 1; // Value mask. uint256 o = _rawMod(index, d) * bitWidth; // Storage slot offset (bits). map[_rawDiv(index, d)] ^= (((map[_rawDiv(index, d)] >> o) ^ value) & m) << o; } } /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/ /* BINARY SEARCH */ /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/ // The following functions search in the range of [`start`, `end`) // (i.e. `start <= index < end`). // The range must be sorted in ascending order. // `index` precedence: equal to > nearest before > nearest after. // An invalid search range will simply return `(found = false, index = start)`. /// @dev Returns whether `map` contains `needle`, and the index of `needle`. function searchSorted(Uint8Map storage map, uint8 needle, uint256 start, uint256 end) internal view returns (bool found, uint256 index) { return searchSorted(map.map, needle, start, end, 8); } /// @dev Returns whether `map` contains `needle`, and the index of `needle`. function searchSorted(Uint16Map storage map, uint16 needle, uint256 start, uint256 end) internal view returns (bool found, uint256 index) { return searchSorted(map.map, needle, start, end, 16); } /// @dev Returns whether `map` contains `needle`, and the index of `needle`. function searchSorted(Uint32Map storage map, uint32 needle, uint256 start, uint256 end) internal view returns (bool found, uint256 index) { return searchSorted(map.map, needle, start, end, 32); } /// @dev Returns whether `map` contains `needle`, and the index of `needle`. function searchSorted(Uint40Map storage map, uint40 needle, uint256 start, uint256 end) internal view returns (bool found, uint256 index) { return searchSorted(map.map, needle, start, end, 40); } /// @dev Returns whether `map` contains `needle`, and the index of `needle`. function searchSorted(Uint64Map storage map, uint64 needle, uint256 start, uint256 end) internal view returns (bool found, uint256 index) { return searchSorted(map.map, needle, start, end, 64); } /// @dev Returns whether `map` contains `needle`, and the index of `needle`. function searchSorted(Uint128Map storage map, uint128 needle, uint256 start, uint256 end) internal view returns (bool found, uint256 index) { return searchSorted(map.map, needle, start, end, 128); } /// @dev Returns whether `map` contains `needle`, and the index of `needle`. function searchSorted( mapping(uint256 => uint256) storage map, uint256 needle, uint256 start, uint256 end, uint256 bitWidth ) internal view returns (bool found, uint256 index) { unchecked { if (start >= end) end = start; uint256 t; uint256 o = start - 1; // Offset to derive the actual index. uint256 l = 1; // Low. uint256 d = _rawDiv(256, bitWidth); // Bucket size. uint256 m = (1 << bitWidth) - 1; // Value mask. uint256 h = end - start; // High. while (true) { index = (l & h) + ((l ^ h) >> 1); if (l > h) break; t = (map[_rawDiv(index + o, d)] >> (_rawMod(index + o, d) * bitWidth)) & m; if (t == needle) break; if (needle <= t) h = index - 1; else l = index + 1; } /// @solidity memory-safe-assembly assembly { m := or(iszero(index), iszero(bitWidth)) found := iszero(or(xor(t, needle), m)) index := add(o, xor(index, mul(xor(index, 1), m))) } } } /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/ /* PRIVATE HELPERS */ /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/ /// @dev Returns `x / y`, returning 0 if `y` is zero. function _rawDiv(uint256 x, uint256 y) private pure returns (uint256 z) { /// @solidity memory-safe-assembly assembly { z := div(x, y) } } /// @dev Returns `x % y`, returning 0 if `y` is zero. function _rawMod(uint256 x, uint256 y) private pure returns (uint256 z) { /// @solidity memory-safe-assembly assembly { z := mod(x, y) } } } /// @notice Library for converting numbers into strings and other string operations. /// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibString.sol) /// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/LibString.sol) /// /// @dev Note: /// For performance and bytecode compactness, most of the string operations are restricted to /// byte strings (7-bit ASCII), except where otherwise specified. /// Usage of byte string operations on charsets with runes spanning two or more bytes /// can lead to undefined behavior. library LibString { /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/ /* CUSTOM ERRORS */ /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/ /// @dev The length of the output is too small to contain all the hex digits. error HexLengthInsufficient(); /// @dev The length of the string is more than 32 bytes. error TooBigForSmallString(); /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/ /* CONSTANTS */ /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/ /// @dev The constant returned when the `search` is not found in the string. uint256 internal constant NOT_FOUND = type(uint256).max; /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/ /* DECIMAL OPERATIONS */ /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/ /// @dev Returns the base 10 decimal representation of `value`. function toString(uint256 value) internal pure returns (string memory str) { /// @solidity memory-safe-assembly assembly { // The maximum value of a uint256 contains 78 digits (1 byte per digit), but // we allocate 0xa0 bytes to keep the free memory pointer 32-byte word aligned. // We will need 1 word for the trailing zeros padding, 1 word for the length, // and 3 words for a maximum of 78 digits. str := add(mload(0x40), 0x80) // Update the free memory pointer to allocate. mstore(0x40, add(str, 0x20)) // Zeroize the slot after the string. mstore(str, 0) // Cache the end of the memory to calculate the length later. let end := str let w := not(0) // Tsk. // We write the string from rightmost digit to leftmost digit. // The following is essentially a do-while loop that also handles the zero case. for { let temp := value } 1 {} { str := add(str, w) // `sub(str, 1)`. // Write the character to the pointer. // The ASCII index of the '0' character is 48. mstore8(str, add(48, mod(temp, 10))) // Keep dividing `temp` until zero. temp := div(temp, 10) if iszero(temp) { break } } let length := sub(end, str) // Move the pointer 32 bytes leftwards to make room for the length. str := sub(str, 0x20) // Store the length. mstore(str, length) } } /// @dev Returns the base 10 decimal representation of `value`. function toString(int256 value) internal pure returns (string memory str) { if (value >= 0) { return toString(uint256(value)); } unchecked { str = toString(~uint256(value) + 1); } /// @solidity memory-safe-assembly assembly { // We still have some spare memory space on the left, // as we have allocated 3 words (96 bytes) for up to 78 digits. let length := mload(str) // Load the string length. mstore(str, 0x2d) // Store the '-' character. str := sub(str, 1) // Move back the string pointer by a byte. mstore(str, add(length, 1)) // Update the string length. } } /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/ /* HEXADECIMAL OPERATIONS */ /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/ /// @dev Returns the hexadecimal representation of `value`, /// left-padded to an input length of `length` bytes. /// The output is prefixed with "0x" encoded using 2 hexadecimal digits per byte, /// giving a total length of `length * 2 + 2` bytes. /// Reverts if `length` is too small for the output to contain all the digits. function toHexString(uint256 value, uint256 length) internal pure returns (string memory str) { str = toHexStringNoPrefix(value, length); /// @solidity memory-safe-assembly assembly { let strLength := add(mload(str), 2) // Compute the length. mstore(str, 0x3078) // Write the "0x" prefix. str := sub(str, 2) // Move the pointer. mstore(str, strLength) // Write the length. } } /// @dev Returns the hexadecimal representation of `value`, /// left-padded to an input length of `length` bytes. /// The output is prefixed with "0x" encoded using 2 hexadecimal digits per byte, /// giving a total length of `length * 2` bytes. /// Reverts if `length` is too small for the output to contain all the digits. function toHexStringNoPrefix(uint256 value, uint256 length) internal pure returns (string memory str) { /// @solidity memory-safe-assembly assembly { // We need 0x20 bytes for the trailing zeros padding, `length * 2` bytes // for the digits, 0x02 bytes for the prefix, and 0x20 bytes for the length. // We add 0x20 to the total and round down to a multiple of 0x20. // (0x20 + 0x20 + 0x02 + 0x20) = 0x62. str := add(mload(0x40), and(add(shl(1, length), 0x42), not(0x1f))) // Allocate the memory. mstore(0x40, add(str, 0x20)) // Zeroize the slot after the string. mstore(str, 0) // Cache the end to calculate the length later. let end := str // Store "0123456789abcdef" in scratch space. mstore(0x0f, 0x30313233343536373839616263646566) let start := sub(str, add(length, length)) let w := not(1) // Tsk. let temp := value // We write the string from rightmost digit to leftmost digit. // The following is essentially a do-while loop that also handles the zero case. for {} 1 {} { str := add(str, w) // `sub(str, 2)`. mstore8(add(str, 1), mload(and(temp, 15))) mstore8(str, mload(and(shr(4, temp), 15))) temp := shr(8, temp) if iszero(xor(str, start)) { break } } if temp { mstore(0x00, 0x2194895a) // `HexLengthInsufficient()`. revert(0x1c, 0x04) } // Compute the string's length. let strLength := sub(end, str) // Move the pointer and write the length. str := sub(str, 0x20) mstore(str, strLength) } } /// @dev Returns the hexadecimal representation of `value`. /// The output is prefixed with "0x" and encoded using 2 hexadecimal digits per byte. /// As address are 20 bytes long, the output will left-padded to have /// a length of `20 * 2 + 2` bytes. function toHexString(uint256 value) internal pure returns (string memory str) { str = toHexStringNoPrefix(value); /// @solidity memory-safe-assembly assembly { let strLength := add(mload(str), 2) // Compute the length. mstore(str, 0x3078) // Write the "0x" prefix. str := sub(str, 2) // Move the pointer. mstore(str, strLength) // Write the length. } } /// @dev Returns the hexadecimal representation of `value`. /// The output is prefixed with "0x". /// The output excludes leading "0" from the `toHexString` output. /// `0x00: "0x0", 0x01: "0x1", 0x12: "0x12", 0x123: "0x123"`. function toMinimalHexString(uint256 value) internal pure returns (string memory str) { str = toHexStringNoPrefix(value); /// @solidity memory-safe-assembly assembly { let o := eq(byte(0, mload(add(str, 0x20))), 0x30) // Whether leading zero is present. let strLength := add(mload(str), 2) // Compute the length. mstore(add(str, o), 0x3078) // Write the "0x" prefix, accounting for leading zero. str := sub(add(str, o), 2) // Move the pointer, accounting for leading zero. mstore(str, sub(strLength, o)) // Write the length, accounting for leading zero. } } /// @dev Returns the hexadecimal representation of `value`. /// The output excludes leading "0" from the `toHexStringNoPrefix` output. /// `0x00: "0", 0x01: "1", 0x12: "12", 0x123: "123"`. function toMinimalHexStringNoPrefix(uint256 value) internal pure returns (string memory str) { str = toHexStringNoPrefix(value); /// @solidity memory-safe-assembly assembly { let o := eq(byte(0, mload(add(str, 0x20))), 0x30) // Whether leading zero is present. let strLength := mload(str) // Get the length. str := add(str, o) // Move the pointer, accounting for leading zero. mstore(str, sub(strLength, o)) // Write the length, accounting for leading zero. } } /// @dev Returns the hexadecimal representation of `value`. /// The output is encoded using 2 hexadecimal digits per byte. /// As address are 20 bytes long, the output will left-padded to have /// a length of `20 * 2` bytes. function toHexStringNoPrefix(uint256 value) internal pure returns (string memory str) { /// @solidity memory-safe-assembly assembly { // We need 0x20 bytes for the trailing zeros padding, 0x20 bytes for the length, // 0x02 bytes for the prefix, and 0x40 bytes for the digits. // The next multiple of 0x20 above (0x20 + 0x20 + 0x02 + 0x40) is 0xa0. str := add(mload(0x40), 0x80) // Allocate the memory. mstore(0x40, add(str, 0x20)) // Zeroize the slot after the string. mstore(str, 0) // Cache the end to calculate the length later. let end := str // Store "0123456789abcdef" in scratch space. mstore(0x0f, 0x30313233343536373839616263646566) let w := not(1) // Tsk. // We write the string from rightmost digit to leftmost digit. // The following is essentially a do-while loop that also handles the zero case. for { let temp := value } 1 {} { str := add(str, w) // `sub(str, 2)`. mstore8(add(str, 1), mload(and(temp, 15))) mstore8(str, mload(and(shr(4, temp), 15))) temp := shr(8, temp) if iszero(temp) { break } } // Compute the string's length. let strLength := sub(end, str) // Move the pointer and write the length. str := sub(str, 0x20) mstore(str, strLength) } } /// @dev Returns the hexadecimal representation of `value`. /// The output is prefixed with "0x", encoded using 2 hexadecimal digits per byte, /// and the alphabets are capitalized conditionally according to /// https://eips.ethereum.org/EIPS/eip-55 function toHexStringChecksummed(address value) internal pure returns (string memory str) { str = toHexString(value); /// @solidity memory-safe-assembly assembly { let mask := shl(6, div(not(0), 255)) // `0b010000000100000000 ...` let o := add(str, 0x22) let hashed := and(keccak256(o, 40), mul(34, mask)) // `0b10001000 ... ` let t := shl(240, 136) // `0b10001000 << 240` for { let i := 0 } 1 {} { mstore(add(i, i), mul(t, byte(i, hashed))) i := add(i, 1) if eq(i, 20) { break } } mstore(o, xor(mload(o), shr(1, and(mload(0x00), and(mload(o), mask))))) o := add(o, 0x20) mstore(o, xor(mload(o), shr(1, and(mload(0x20), and(mload(o), mask))))) } } /// @dev Returns the hexadecimal representation of `value`. /// The output is prefixed with "0x" and encoded using 2 hexadecimal digits per byte. function toHexString(address value) internal pure returns (string memory str) { str = toHexStringNoPrefix(value); /// @solidity memory-safe-assembly assembly { let strLength := add(mload(str), 2) // Compute the length. mstore(str, 0x3078) // Write the "0x" prefix. str := sub(str, 2) // Move the pointer. mstore(str, strLength) // Write the length. } } /// @dev Returns the hexadecimal representation of `value`. /// The output is encoded using 2 hexadecimal digits per byte. function toHexStringNoPrefix(address value) internal pure returns (string memory str) { /// @solidity memory-safe-assembly assembly { str := mload(0x40) // Allocate the memory. // We need 0x20 bytes for the trailing zeros padding, 0x20 bytes for the length, // 0x02 bytes for the prefix, and 0x28 bytes for the digits. // The next multiple of 0x20 above (0x20 + 0x20 + 0x02 + 0x28) is 0x80. mstore(0x40, add(str, 0x80)) // Store "0123456789abcdef" in scratch space. mstore(0x0f, 0x30313233343536373839616263646566) str := add(str, 2) mstore(str, 40) let o := add(str, 0x20) mstore(add(o, 40), 0) value := shl(96, value) // We write the string from rightmost digit to leftmost digit. // The following is essentially a do-while loop that also handles the zero case. for { let i := 0 } 1 {} { let p := add(o, add(i, i)) let temp := byte(i, value) mstore8(add(p, 1), mload(and(temp, 15))) mstore8(p, mload(shr(4, temp))) i := add(i, 1) if eq(i, 20) { break } } } } /// @dev Returns the hex encoded string from the raw bytes. /// The output is encoded using 2 hexadecimal digits per byte. function toHexString(bytes memory raw) internal pure returns (string memory str) { str = toHexStringNoPrefix(raw); /// @solidity memory-safe-assembly assembly { let strLength := add(mload(str), 2) // Compute the length. mstore(str, 0x3078) // Write the "0x" prefix. str := sub(str, 2) // Move the pointer. mstore(str, strLength) // Write the length. } } /// @dev Returns the hex encoded string from the raw bytes. /// The output is encoded using 2 hexadecimal digits per byte. function toHexStringNoPrefix(bytes memory raw) internal pure returns (string memory str) { /// @solidity memory-safe-assembly assembly { let length := mload(raw) str := add(mload(0x40), 2) // Skip 2 bytes for the optional prefix. mstore(str, add(length, length)) // Store the length of the output. // Store "0123456789abcdef" in scratch space. mstore(0x0f, 0x30313233343536373839616263646566) let o := add(str, 0x20) let end := add(raw, length) for {} iszero(eq(raw, end)) {} { raw := add(raw, 1) mstore8(add(o, 1), mload(and(mload(raw), 15))) mstore8(o, mload(and(shr(4, mload(raw)), 15))) o := add(o, 2) } mstore(o, 0) // Zeroize the slot after the string. mstore(0x40, add(o, 0x20)) // Allocate the memory. } } /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/ /* RUNE STRING OPERATIONS */ /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/ /// @dev Returns the number of UTF characters in the string. function runeCount(string memory s) internal pure returns (uint256 result) { /// @solidity memory-safe-assembly assembly { if mload(s) { mstore(0x00, div(not(0), 255)) mstore(0x20, 0x0202020202020202020202020202020202020202020202020303030304040506) let o := add(s, 0x20) let end := add(o, mload(s)) for { result := 1 } 1 { result := add(result, 1) } { o := add(o, byte(0, mload(shr(250, mload(o))))) if iszero(lt(o, end)) { break } } } } } /// @dev Returns if this string is a 7-bit ASCII string. /// (i.e. all characters codes are in [0..127]) function is7BitASCII(string memory s) internal pure returns (bool result) { /// @solidity memory-safe-assembly assembly { let mask := shl(7, div(not(0), 255)) result := 1 let n := mload(s) if n { let o := add(s, 0x20) let end := add(o, n) let last := mload(end) mstore(end, 0) for {} 1 {} { if and(mask, mload(o)) { result := 0 break } o := add(o, 0x20) if iszero(lt(o, end)) { break } } mstore(end, last) } } } /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/ /* BYTE STRING OPERATIONS */ /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/ // For performance and bytecode compactness, byte string operations are restricted // to 7-bit ASCII strings. All offsets are byte offsets, not UTF character offsets. // Usage of byte string operations on charsets with runes spanning two or more bytes // can lead to undefined behavior. /// @dev Returns `subject` all occurrences of `search` replaced with `replacement`. function replace(string memory subject, string memory search, string memory replacement) internal pure returns (string memory result) { /// @solidity memory-safe-assembly assembly { let subjectLength := mload(subject) let searchLength := mload(search) let replacementLength := mload(replacement) subject := add(subject, 0x20) search := add(search, 0x20) replacement := add(replacement, 0x20) result := add(mload(0x40), 0x20) let subjectEnd := add(subject, subjectLength) if iszero(gt(searchLength, subjectLength)) { let subjectSearchEnd := add(sub(subjectEnd, searchLength), 1) let h := 0 if iszero(lt(searchLength, 0x20)) { h := keccak256(search, searchLength) } let m := shl(3, sub(0x20, and(searchLength, 0x1f))) let s := mload(search) for {} 1 {} { let t := mload(subject) // Whether the first `searchLength % 32` bytes of // `subject` and `search` matches. if iszero(shr(m, xor(t, s))) { if h { if iszero(eq(keccak256(subject, searchLength), h)) { mstore(result, t) result := add(result, 1) subject := add(subject, 1) if iszero(lt(subject, subjectSearchEnd)) { break } continue } } // Copy the `replacement` one word at a time. for { let o := 0 } 1 {} { mstore(add(result, o), mload(add(replacement, o))) o := add(o, 0x20) if iszero(lt(o, replacementLength)) { break } } result := add(result, replacementLength) subject := add(subject, searchLength) if searchLength { if iszero(lt(subject, subjectSearchEnd)) { break } continue } } mstore(result, t) result := add(result, 1) subject := add(subject, 1) if iszero(lt(subject, subjectSearchEnd)) { break } } } let resultRemainder := result result := add(mload(0x40), 0x20) let k := add(sub(resultRemainder, result), sub(subjectEnd, subject)) // Copy the rest of the string one word at a time. for {} lt(subject, subjectEnd) {} { mstore(resultRemainder, mload(subject)) resultRemainder := add(resultRemainder, 0x20) subject := add(subject, 0x20) } result := sub(result, 0x20) let last := add(add(result, 0x20), k) // Zeroize the slot after the string. mstore(last, 0) mstore(0x40, add(last, 0x20)) // Allocate the memory. mstore(result, k) // Store the length. } } /// @dev Returns the byte index of the first location of `search` in `subject`, /// searching from left to right, starting from `from`. /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found. function indexOf(string memory subject, string memory search, uint256 from) internal pure returns (uint256 result) { /// @solidity memory-safe-assembly assembly { for { let subjectLength := mload(subject) } 1 {} { if iszero(mload(search)) { if iszero(gt(from, subjectLength)) { result := from break } result := subjectLength break } let searchLength := mload(search) let subjectStart := add(subject, 0x20) result := not(0) // Initialize to `NOT_FOUND`. subject := add(subjectStart, from) let end := add(sub(add(subjectStart, subjectLength), searchLength), 1) let m := shl(3, sub(0x20, and(searchLength, 0x1f))) let s := mload(add(search, 0x20)) if iszero(and(lt(subject, end), lt(from, subjectLength))) { break } if iszero(lt(searchLength, 0x20)) { for { let h := keccak256(add(search, 0x20), searchLength) } 1 {} { if iszero(shr(m, xor(mload(subject), s))) { if eq(keccak256(subject, searchLength), h) { result := sub(subject, subjectStart) break } } subject := add(subject, 1) if iszero(lt(subject, end)) { break } } break } for {} 1 {} { if iszero(shr(m, xor(mload(subject), s))) { result := sub(subject, subjectStart) break } subject := add(subject, 1) if iszero(lt(subject, end)) { break } } break } } } /// @dev Returns the byte index of the first location of `search` in `subject`, /// searching from left to right. /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found. function indexOf(string memory subject, string memory search) internal pure returns (uint256 result) { result = indexOf(subject, search, 0); } /// @dev Returns the byte index of the first location of `search` in `subject`, /// searching from right to left, starting from `from`. /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found. function lastIndexOf(string memory subject, string memory search, uint256 from) internal pure returns (uint256 result) { /// @solidity memory-safe-assembly assembly { for {} 1 {} { result := not(0) // Initialize to `NOT_FOUND`. let searchLength := mload(search) if gt(searchLength, mload(subject)) { break } let w := result let fromMax := sub(mload(subject), searchLength) if iszero(gt(fromMax, from)) { from := fromMax } let end := add(add(subject, 0x20), w) subject := add(add(subject, 0x20), from) if iszero(gt(subject, end)) { break } // As this function is not too often used, // we shall simply use keccak256 for smaller bytecode size. for { let h := keccak256(add(search, 0x20), searchLength) } 1 {} { if eq(keccak256(subject, searchLength), h) { result := sub(subject, add(end, 1)) break } subject := add(subject, w) // `sub(subject, 1)`. if iszero(gt(subject, end)) { break } } break } } } /// @dev Returns the byte index of the first location of `search` in `subject`, /// searching from right to left. /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found. function lastIndexOf(string memory subject, string memory search) internal pure returns (uint256 result) { result = lastIndexOf(subject, search, uint256(int256(-1))); } /// @dev Returns true if `search` is found in `subject`, false otherwise. function contains(string memory subject, string memory search) internal pure returns (bool) { return indexOf(subject, search) != NOT_FOUND; } /// @dev Returns whether `subject` starts with `search`. function startsWith(string memory subject, string memory search) internal pure returns (bool result) { /// @solidity memory-safe-assembly assembly { let searchLength := mload(search) // Just using keccak256 directly is actually cheaper. // forgefmt: disable-next-item result := and( iszero(gt(searchLength, mload(subject))), eq( keccak256(add(subject, 0x20), searchLength), keccak256(add(search, 0x20), searchLength) ) ) } } /// @dev Returns whether `subject` ends with `search`. function endsWith(string memory subject, string memory search) internal pure returns (bool result) { /// @solidity memory-safe-assembly assembly { let searchLength := mload(search) let subjectLength := mload(subject) // Whether `search` is not longer than `subject`. let withinRange := iszero(gt(searchLength, subjectLength)) // Just using keccak256 directly is actually cheaper. // forgefmt: disable-next-item result := and( withinRange, eq( keccak256( // `subject + 0x20 + max(subjectLength - searchLength, 0)`. add(add(subject, 0x20), mul(withinRange, sub(subjectLength, searchLength))), searchLength ), keccak256(add(search, 0x20), searchLength) ) ) } } /// @dev Returns `subject` repeated `times`. function repeat(string memory subject, uint256 times) internal pure returns (string memory result) { /// @solidity memory-safe-assembly assembly { let subjectLength := mload(subject) if iszero(or(iszero(times), iszero(subjectLength))) { subject := add(subject, 0x20) result := mload(0x40) let output := add(result, 0x20) for {} 1 {} { // Copy the `subject` one word at a time. for { let o := 0 } 1 {} { mstore(add(output, o), mload(add(subject, o))) o := add(o, 0x20) if iszero(lt(o, subjectLength)) { break } } output := add(output, subjectLength) times := sub(times, 1) if iszero(times) { break } } mstore(output, 0) // Zeroize the slot after the string. let resultLength := sub(output, add(result, 0x20)) mstore(result, resultLength) // Store the length. // Allocate the memory. mstore(0x40, add(result, add(resultLength, 0x20))) } } } /// @dev Returns a copy of `subject` sliced from `start` to `end` (exclusive). /// `start` and `end` are byte offsets. function slice(string memory subject, uint256 start, uint256 end) internal pure returns (string memory result) { /// @solidity memory-safe-assembly assembly { let subjectLength := mload(subject) if iszero(gt(subjectLength, end)) { end := subjectLength } if iszero(gt(subjectLength, start)) { start := subjectLength } if lt(start, end) { result := mload(0x40) let resultLength := sub(end, start) mstore(result, resultLength) subject := add(subject, start) let w := not(0x1f) // Copy the `subject` one word at a time, backwards. for { let o := and(add(resultLength, 0x1f), w) } 1 {} { mstore(add(result, o), mload(add(subject, o))) o := add(o, w) // `sub(o, 0x20)`. if iszero(o) { break } } // Zeroize the slot after the string. mstore(add(add(result, 0x20), resultLength), 0) // Allocate memory for the length and the bytes, // rounded up to a multiple of 32. mstore(0x40, add(result, and(add(resultLength, 0x3f), w))) } } } /// @dev Returns a copy of `subject` sliced from `start` to the end of the string. /// `start` is a byte offset. function slice(string memory subject, uint256 start) internal pure returns (string memory result) { result = slice(subject, start, uint256(int256(-1))); } /// @dev Returns all the indices of `search` in `subject`. /// The indices are byte offsets. function indicesOf(string memory subject, string memory search) internal pure returns (uint256[] memory result) { /// @solidity memory-safe-assembly assembly { let subjectLength := mload(subject) let searchLength := mload(search) if iszero(gt(searchLength, subjectLength)) { subject := add(subject, 0x20) search := add(search, 0x20) result := add(mload(0x40), 0x20) let subjectStart := subject let subjectSearchEnd := add(sub(add(subject, subjectLength), searchLength), 1) let h := 0 if iszero(lt(searchLength, 0x20)) { h := keccak256(search, searchLength) } let m := shl(3, sub(0x20, and(searchLength, 0x1f))) let s := mload(search) for {} 1 {} { let t := mload(subject) // Whether the first `searchLength % 32` bytes of // `subject` and `search` matches. if iszero(shr(m, xor(t, s))) { if h { if iszero(eq(keccak256(subject, searchLength), h)) { subject := add(subject, 1) if iszero(lt(subject, subjectSearchEnd)) { break } continue } } // Append to `result`. mstore(result, sub(subject, subjectStart)) result := add(result, 0x20) // Advance `subject` by `searchLength`. subject := add(subject, searchLength) if searchLength { if iszero(lt(subject, subjectSearchEnd)) { break } continue } } subject := add(subject, 1) if iszero(lt(subject, subjectSearchEnd)) { break } } let resultEnd := result // Assign `result` to the free memory pointer. result := mload(0x40) // Store the length of `result`. mstore(result, shr(5, sub(resultEnd, add(result, 0x20)))) // Allocate memory for result. // We allocate one more word, so this array can be recycled for {split}. mstore(0x40, add(resultEnd, 0x20)) } } } /// @dev Returns a arrays of strings based on the `delimiter` inside of the `subject` string. function split(string memory subject, string memory delimiter) internal pure returns (string[] memory result) { uint256[] memory indices = indicesOf(subject, delimiter); /// @solidity memory-safe-assembly assembly { let w := not(0x1f) let indexPtr := add(indices, 0x20) let indicesEnd := add(indexPtr, shl(5, add(mload(indices), 1))) mstore(add(indicesEnd, w), mload(subject)) mstore(indices, add(mload(indices), 1)) let prevIndex := 0 for {} 1 {} { let index := mload(indexPtr) mstore(indexPtr, 0x60) if iszero(eq(index, prevIndex)) { let element := mload(0x40) let elementLength := sub(index, prevIndex) mstore(element, elementLength) // Copy the `subject` one word at a time, backwards. for { let o := and(add(elementLength, 0x1f), w) } 1 {} { mstore(add(element, o), mload(add(add(subject, prevIndex), o))) o := add(o, w) // `sub(o, 0x20)`. if iszero(o) { break } } // Zeroize the slot after the string. mstore(add(add(element, 0x20), elementLength), 0) // Allocate memory for the length and the bytes, // rounded up to a multiple of 32. mstore(0x40, add(element, and(add(elementLength, 0x3f), w))) // Store the `element` into the array. mstore(indexPtr, element) } prevIndex := add(index, mload(delimiter)) indexPtr := add(indexPtr, 0x20) if iszero(lt(indexPtr, indicesEnd)) { break } } result := indices if iszero(mload(delimiter)) { result := add(indices, 0x20) mstore(result, sub(mload(indices), 2)) } } } /// @dev Returns a concatenated string of `a` and `b`. /// Cheaper than `string.concat()` and does not de-align the free memory pointer. function concat(string memory a, string memory b) internal pure returns (string memory result) { /// @solidity memory-safe-assembly assembly { let w := not(0x1f) result := mload(0x40) let aLength := mload(a) // Copy `a` one word at a time, backwards. for { let o := and(add(aLength, 0x20), w) } 1 {} { mstore(add(result, o), mload(add(a, o))) o := add(o, w) // `sub(o, 0x20)`. if iszero(o) { break } } let bLength := mload(b) let output := add(result, aLength) // Copy `b` one word at a time, backwards. for { let o := and(add(bLength, 0x20), w) } 1 {} { mstore(add(output, o), mload(add(b, o))) o := add(o, w) // `sub(o, 0x20)`. if iszero(o) { break } } let totalLength := add(aLength, bLength) let last := add(add(result, 0x20), totalLength) // Zeroize the slot after the string. mstore(last, 0) // Stores the length. mstore(result, totalLength) // Allocate memory for the length and the bytes, // rounded up to a multiple of 32. mstore(0x40, and(add(last, 0x1f), w)) } } /// @dev Returns a copy of the string in either lowercase or UPPERCASE. /// WARNING! This function is only compatible with 7-bit ASCII strings. function toCase(string memory subject, bool toUpper) internal pure returns (string memory result) { /// @solidity memory-safe-assembly assembly { let length := mload(subject) if length { result := add(mload(0x40), 0x20) subject := add(subject, 1) let flags := shl(add(70, shl(5, toUpper)), 0x3ffffff) let w := not(0) for { let o := length } 1 {} { o := add(o, w) let b := and(0xff, mload(add(subject, o))) mstore8(add(result, o), xor(b, and(shr(b, flags), 0x20))) if iszero(o) { break } } result := mload(0x40) mstore(result, length) // Store the length. let last := add(add(result, 0x20), length) mstore(last, 0) // Zeroize the slot after the string. mstore(0x40, add(last, 0x20)) // Allocate the memory. } } } /// @dev Returns a string from a small bytes32 string. /// `s` must be null-terminated, or behavior will be undefined. function fromSmallString(bytes32 s) internal pure returns (string memory result) { /// @solidity memory-safe-assembly assembly { result := mload(0x40) let n := 0 for {} byte(n, s) { n := add(n, 1) } {} // Scan for '\0'. mstore(result, n) let o := add(result, 0x20) mstore(o, s) mstore(add(o, n), 0) mstore(0x40, add(result, 0x40)) } } /// @dev Returns the small string, with all bytes after the first null byte zeroized. function normalizeSmallString(bytes32 s) internal pure returns (bytes32 result) { /// @solidity memory-safe-assembly assembly { for {} byte(result, s) { result := add(result, 1) } {} // Scan for '\0'. mstore(0x00, s) mstore(result, 0x00) result := mload(0x00) } } /// @dev Returns the string as a normalized null-terminated small string. function toSmallString(string memory s) internal pure returns (bytes32 result) { /// @solidity memory-safe-assembly assembly { result := mload(s) if iszero(lt(result, 33)) { mstore(0x00, 0xec92f9a3) // `TooBigForSmallString()`. revert(0x1c, 0x04) } result := shl(shl(3, sub(32, result)), mload(add(s, result))) } } /// @dev Returns a lowercased copy of the string. /// WARNING! This function is only compatible with 7-bit ASCII strings. function lower(string memory subject) internal pure returns (string memory result) { result = toCase(subject, false); } /// @dev Returns an UPPERCASED copy of the string. /// WARNING! This function is only compatible with 7-bit ASCII strings. function upper(string memory subject) internal pure returns (string memory result) { result = toCase(subject, true); } /// @dev Escapes the string to be used within HTML tags. function escapeHTML(string memory s) internal pure returns (string memory result) { /// @solidity memory-safe-assembly assembly { let end := add(s, mload(s)) result := add(mload(0x40), 0x20) // Store the bytes of the packed offsets and strides into the scratch space. // `packed = (stride << 5) | offset`. Max offset is 20. Max stride is 6. mstore(0x1f, 0x900094) mstore(0x08, 0xc0000000a6ab) // Store ""&'<>" into the scratch space. mstore(0x00, shl(64, 0x2671756f743b26616d703b262333393b266c743b2667743b)) for {} iszero(eq(s, end)) {} { s := add(s, 1) let c := and(mload(s), 0xff) // Not in `["\"","'","&","<",">"]`. if iszero(and(shl(c, 1), 0x500000c400000000)) { mstore8(result, c) result := add(result, 1) continue } let t := shr(248, mload(c)) mstore(result, mload(and(t, 0x1f))) result := add(result, shr(5, t)) } let last := result mstore(last, 0) // Zeroize the slot after the string. result := mload(0x40) mstore(result, sub(last, add(result, 0x20))) // Store the length. mstore(0x40, add(last, 0x20)) // Allocate the memory. } } /// @dev Escapes the string to be used within double-quotes in a JSON. /// If `addDoubleQuotes` is true, the result will be enclosed in double-quotes. function escapeJSON(string memory s, bool addDoubleQuotes) internal pure returns (string memory result) { /// @solidity memory-safe-assembly assembly { let end := add(s, mload(s)) result := add(mload(0x40), 0x20) if addDoubleQuotes { mstore8(result, 34) result := add(1, result) } // Store "\\u0000" in scratch space. // Store "0123456789abcdef" in scratch space. // Also, store `{0x08:"b", 0x09:"t", 0x0a:"n", 0x0c:"f", 0x0d:"r"}`. // into the scratch space. mstore(0x15, 0x5c75303030303031323334353637383961626364656662746e006672) // Bitmask for detecting `["\"","\\"]`. let e := or(shl(0x22, 1), shl(0x5c, 1)) for {} iszero(eq(s, end)) {} { s := add(s, 1) let c := and(mload(s), 0xff) if iszero(lt(c, 0x20)) { if iszero(and(shl(c, 1), e)) { // Not in `["\"","\\"]`. mstore8(result, c) result := add(result, 1) continue } mstore8(result, 0x5c) // "\\". mstore8(add(result, 1), c) result := add(result, 2) continue } if iszero(and(shl(c, 1), 0x3700)) { // Not in `["\b","\t","\n","\f","\d"]`. mstore8(0x1d, mload(shr(4, c))) // Hex value. mstore8(0x1e, mload(and(c, 15))) // Hex value. mstore(result, mload(0x19)) // "\\u00XX". result := add(result, 6) continue } mstore8(result, 0x5c) // "\\". mstore8(add(result, 1), mload(add(c, 8))) result := add(result, 2) } if addDoubleQuotes { mstore8(result, 34) result := add(1, result) } let last := result mstore(last, 0) // Zeroize the slot after the string. result := mload(0x40) mstore(result, sub(last, add(result, 0x20))) // Store the length. mstore(0x40, add(last, 0x20)) // Allocate the memory. } } /// @dev Escapes the string to be used within double-quotes in a JSON. function escapeJSON(string memory s) internal pure returns (string memory result) { result = escapeJSON(s, false); } /// @dev Returns whether `a` equals `b`. function eq(string memory a, string memory b) internal pure returns (bool result) { /// @solidity memory-safe-assembly assembly { result := eq(keccak256(add(a, 0x20), mload(a)), keccak256(add(b, 0x20), mload(b))) } } /// @dev Returns whether `a` equals `b`, where `b` is a null-terminated small string. function eqs(string memory a, bytes32 b) internal pure returns (bool result) { /// @solidity memory-safe-assembly assembly { // These should be evaluated on compile time, as far as possible. let m := not(shl(7, div(not(iszero(b)), 255))) // `0x7f7f ...`. let x := not(or(m, or(b, add(m, and(b, m))))) let r := shl(7, iszero(iszero(shr(128, x)))) r := or(r, shl(6, iszero(iszero(shr(64, shr(r, x)))))) r := or(r, shl(5, lt(0xffffffff, shr(r, x)))) r := or(r, shl(4, lt(0xffff, shr(r, x)))) r := or(r, shl(3, lt(0xff, shr(r, x)))) // forgefmt: disable-next-item result := gt(eq(mload(a), add(iszero(x), xor(31, shr(3, r)))), xor(shr(add(8, r), b), shr(add(8, r), mload(add(a, 0x20))))) } } /// @dev Packs a single string with its length into a single word. /// Returns `bytes32(0)` if the length is zero or greater than 31. function packOne(string memory a) internal pure returns (bytes32 result) { /// @solidity memory-safe-assembly assembly { // We don't need to zero right pad the string, // since this is our own custom non-standard packing scheme. result := mul( // Load the length and the bytes. mload(add(a, 0x1f)), // `length != 0 && length < 32`. Abuses underflow. // Assumes that the length is valid and within the block gas limit. lt(sub(mload(a), 1), 0x1f) ) } } /// @dev Unpacks a string packed using {packOne}. /// Returns the empty string if `packed` is `bytes32(0)`. /// If `packed` is not an output of {packOne}, the output behavior is undefined. function unpackOne(bytes32 packed) internal pure returns (string memory result) { /// @solidity memory-safe-assembly assembly { // Grab the free memory pointer. result := mload(0x40) // Allocate 2 words (1 for the length, 1 for the bytes). mstore(0x40, add(result, 0x40)) // Zeroize the length slot. mstore(result, 0) // Store the length and bytes. mstore(add(result, 0x1f), packed) // Right pad with zeroes. mstore(add(add(result, 0x20), mload(result)), 0) } } /// @dev Packs two strings with their lengths into a single word. /// Returns `bytes32(0)` if combined length is zero or greater than 30. function packTwo(string memory a, string memory b) internal pure returns (bytes32 result) { /// @solidity memory-safe-assembly assembly { let aLength := mload(a) // We don't need to zero right pad the strings, // since this is our own custom non-standard packing scheme. result := mul( // Load the length and the bytes of `a` and `b`. or( shl(shl(3, sub(0x1f, aLength)), mload(add(a, aLength))), mload(sub(add(b, 0x1e), aLength)) ), // `totalLength != 0 && totalLength < 31`. Abuses underflow. // Assumes that the lengths are valid and within the block gas limit. lt(sub(add(aLength, mload(b)), 1), 0x1e) ) } } /// @dev Unpacks strings packed using {packTwo}. /// Returns the empty strings if `packed` is `bytes32(0)`. /// If `packed` is not an output of {packTwo}, the output behavior is undefined. function unpackTwo(bytes32 packed) internal pure returns (string memory resultA, string memory resultB) { /// @solidity memory-safe-assembly assembly { // Grab the free memory pointer. resultA := mload(0x40) resultB := add(resultA, 0x40) // Allocate 2 words for each string (1 for the length, 1 for the byte). Total 4 words. mstore(0x40, add(resultB, 0x40)) // Zeroize the length slots. mstore(resultA, 0) mstore(resultB, 0) // Store the lengths and bytes. mstore(add(resultA, 0x1f), packed) mstore(add(resultB, 0x1f), mload(add(add(resultA, 0x20), mload(resultA)))) // Right pad with zeroes. mstore(add(add(resultA, 0x20), mload(resultA)), 0) mstore(add(add(resultB, 0x20), mload(resultB)), 0) } } /// @dev Directly returns `a` without copying. function directReturn(string memory a) internal pure { assembly { // Assumes that the string does not start from the scratch space. let retStart := sub(a, 0x20) let retSize := add(mload(a), 0x40) // Right pad with zeroes. Just in case the string is produced // by a method that doesn't zero right pad. mstore(add(retStart, retSize), 0) // Store the return offset. mstore(retStart, 0x20) // End the transaction, returning the string. return(retStart, retSize) } } } /// @notice Simple single owner authorization mixin. /// @author Solady (https://github.com/vectorized/solady/blob/main/src/auth/Ownable.sol) /// /// @dev Note: /// This implementation does NOT auto-initialize the owner to `msg.sender`. /// You MUST call the `_initializeOwner` in the constructor / initializer. /// /// While the ownable portion follows /// [EIP-173](https://eips.ethereum.org/EIPS/eip-173) for compatibility, /// the nomenclature for the 2-step ownership handover may be unique to this codebase. abstract contract Ownable { /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/ /* CUSTOM ERRORS */ /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/ /// @dev The caller is not authorized to call the function. error Unauthorized(); /// @dev The `newOwner` cannot be the zero address. error NewOwnerIsZeroAddress(); /// @dev The `pendingOwner` does not have a valid handover request. error NoHandoverRequest(); /// @dev Cannot double-initialize. error AlreadyInitialized(); /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/ /* EVENTS */ /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/ /// @dev The ownership is transferred from `oldOwner` to `newOwner`. /// This event is intentionally kept the same as OpenZeppelin's Ownable to be /// compatible with indexers and [EIP-173](https://eips.ethereum.org/EIPS/eip-173), /// despite it not being as lightweight as a single argument event. event OwnershipTransferred(address indexed oldOwner, address indexed newOwner); /// @dev An ownership handover to `pendingOwner` has been requested. event OwnershipHandoverRequested(address indexed pendingOwner); /// @dev The ownership handover to `pendingOwner` has been canceled. event OwnershipHandoverCanceled(address indexed pendingOwner); /// @dev `keccak256(bytes("OwnershipTransferred(address,address)"))`. uint256 private constant _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE = 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0; /// @dev `keccak256(bytes("OwnershipHandoverRequested(address)"))`. uint256 private constant _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE = 0xdbf36a107da19e49527a7176a1babf963b4b0ff8cde35ee35d6cd8f1f9ac7e1d; /// @dev `keccak256(bytes("OwnershipHandoverCanceled(address)"))`. uint256 private constant _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE = 0xfa7b8eab7da67f412cc9575ed43464468f9bfbae89d1675917346ca6d8fe3c92; /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/ /* STORAGE */ /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/ /// @dev The owner slot is given by: /// `bytes32(~uint256(uint32(bytes4(keccak256("_OWNER_SLOT_NOT")))))`. /// It is intentionally chosen to be a high value /// to avoid collision with lower slots. /// The choice of manual storage layout is to enable compatibility /// with both regular and upgradeable contracts. bytes32 internal constant _OWNER_SLOT = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927; /// The ownership handover slot of `newOwner` is given by: /// ``` /// mstore(0x00, or(shl(96, user), _HANDOVER_SLOT_SEED)) /// let handoverSlot := keccak256(0x00, 0x20) /// ``` /// It stores the expiry timestamp of the two-step ownership handover. uint256 private constant _HANDOVER_SLOT_SEED = 0x389a75e1; /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/ /* INTERNAL FUNCTIONS */ /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/ /// @dev Override to return true to make `_initializeOwner` prevent double-initialization. function _guardInitializeOwner() internal pure virtual returns (bool guard) {} /// @dev Initializes the owner directly without authorization guard. /// This function must be called upon initialization, /// regardless of whether the contract is upgradeable or not. /// This is to enable generalization to both regular and upgradeable contracts, /// and to save gas in case the initial owner is not the caller. /// For performance reasons, this function will not check if there /// is an existing owner. function _initializeOwner(address newOwner) internal virtual { if (_guardInitializeOwner()) { /// @solidity memory-safe-assembly assembly { let ownerSlot := _OWNER_SLOT if sload(ownerSlot) { mstore(0x00, 0x0dc149f0) // `AlreadyInitialized()`. revert(0x1c, 0x04) } // Clean the upper 96 bits. newOwner := shr(96, shl(96, newOwner)) // Store the new value. sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner)))) // Emit the {OwnershipTransferred} event. log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner) } } else { /// @solidity memory-safe-assembly assembly { // Clean the upper 96 bits. newOwner := shr(96, shl(96, newOwner)) // Store the new value. sstore(_OWNER_SLOT, newOwner) // Emit the {OwnershipTransferred} event. log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner) } } } /// @dev Sets the owner directly without authorization guard. function _setOwner(address newOwner) internal virtual { if (_guardInitializeOwner()) { /// @solidity memory-safe-assembly assembly { let ownerSlot := _OWNER_SLOT // Clean the upper 96 bits. newOwner := shr(96, shl(96, newOwner)) // Emit the {OwnershipTransferred} event. log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner) // Store the new value. sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner)))) } } else { /// @solidity memory-safe-assembly assembly { let ownerSlot := _OWNER_SLOT // Clean the upper 96 bits. newOwner := shr(96, shl(96, newOwner)) // Emit the {OwnershipTransferred} event. log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner) // Store the new value. sstore(ownerSlot, newOwner) } } } /// @dev Throws if the sender is not the owner. function _checkOwner() internal view virtual { /// @solidity memory-safe-assembly assembly { // If the caller is not the stored owner, revert. if iszero(eq(caller(), sload(_OWNER_SLOT))) { mstore(0x00, 0x82b42900) // `Unauthorized()`. revert(0x1c, 0x04) } } } /// @dev Returns how long a two-step ownership handover is valid for in seconds. /// Override to return a different value if needed. /// Made internal to conserve bytecode. Wrap it in a public function if needed. function _ownershipHandoverValidFor() internal view virtual returns (uint64) { return 48 * 3600; } /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/ /* PUBLIC UPDATE FUNCTIONS */ /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/ /// @dev Allows the owner to transfer the ownership to `newOwner`. function transferOwnership(address newOwner) public payable virtual onlyOwner { /// @solidity memory-safe-assembly assembly { if iszero(shl(96, newOwner)) { mstore(0x00, 0x7448fbae) // `NewOwnerIsZeroAddress()`. revert(0x1c, 0x04) } } _setOwner(newOwner); } /// @dev Allows the owner to renounce their ownership. function renounceOwnership() public payable virtual onlyOwner { _setOwner(address(0)); } /// @dev Request a two-step ownership handover to the caller. /// The request will automatically expire in 48 hours (172800 seconds) by default. function requestOwnershipHandover() public payable virtual { unchecked { uint256 expires = block.timestamp + _ownershipHandoverValidFor(); /// @solidity memory-safe-assembly assembly { // Compute and set the handover slot to `expires`. mstore(0x0c, _HANDOVER_SLOT_SEED) mstore(0x00, caller()) sstore(keccak256(0x0c, 0x20), expires) // Emit the {OwnershipHandoverRequested} event. log2(0, 0, _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE, caller()) } } } /// @dev Cancels the two-step ownership handover to the caller, if any. function cancelOwnershipHandover() public payable virtual { /// @solidity memory-safe-assembly assembly { // Compute and set the handover slot to 0. mstore(0x0c, _HANDOVER_SLOT_SEED) mstore(0x00, caller()) sstore(keccak256(0x0c, 0x20), 0) // Emit the {OwnershipHandoverCanceled} event. log2(0, 0, _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE, caller()) } } /// @dev Allows the owner to complete the two-step ownership handover to `pendingOwner`. /// Reverts if there is no existing ownership handover requested by `pendingOwner`. function completeOwnershipHandover(address pendingOwner) public payable virtual onlyOwner { /// @solidity memory-safe-assembly assembly { // Compute and set the handover slot to 0. mstore(0x0c, _HANDOVER_SLOT_SEED) mstore(0x00, pendingOwner) let handoverSlot := keccak256(0x0c, 0x20) // If the handover does not exist, or has expired. if gt(timestamp(), sload(handoverSlot)) { mstore(0x00, 0x6f5e8818) // `NoHandoverRequest()`. revert(0x1c, 0x04) } // Set the handover slot to 0. sstore(handoverSlot, 0) } _setOwner(pendingOwner); } /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/ /* PUBLIC READ FUNCTIONS */ /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/ /// @dev Returns the owner of the contract. function owner() public view virtual returns (address result) { /// @solidity memory-safe-assembly assembly { result := sload(_OWNER_SLOT) } } /// @dev Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`. function ownershipHandoverExpiresAt(address pendingOwner) public view virtual returns (uint256 result) { /// @solidity memory-safe-assembly assembly { // Compute the handover slot. mstore(0x0c, _HANDOVER_SLOT_SEED) mstore(0x00, pendingOwner) // Load the handover slot. result := sload(keccak256(0x0c, 0x20)) } } /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/ /* MODIFIERS */ /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/ /// @dev Marks a function as only callable by the owner. modifier onlyOwner() virtual { _checkOwner(); _; } } /// @title ERC_YB_NFT /// @notice ERC_YB_NFT provides an interface for interacting with the /// NFT tokens in a DN404 implementation. /// /// @author vectorized.eth (@optimizoor) /// @author Quit (@0xQuit) /// @author Michael Amadi (@AmadiMichaels) /// @author cygaar (@0xCygaar) /// @author Thomas (@0xjustadev) /// @author Harrison (@PopPunkOnChain) /// /// @dev Note: /// - The ERC721 data is stored in the base DN404 contract. contract ERC_YB_NFT { /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/ /* EVENTS */ /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/ /// @dev Emitted when token `id` is transferred from `from` to `to`. event Transfer(address indexed from, address indexed to, uint256 indexed id); /// @dev Emitted when `owner` enables `account` to manage the `id` token. event Approval(address indexed owner, address indexed account, uint256 indexed id); /// @dev Emitted when `owner` enables or disables `operator` to manage all of their tokens. event ApprovalForAll(address indexed owner, address indexed operator, bool isApproved); /// @dev The ownership is transferred from `oldOwner` to `newOwner`. /// This is for marketplace signaling purposes. This contract has a `pullOwner()` /// function that will sync the owner from the base contract. event OwnershipTransferred(address indexed oldOwner, address indexed newOwner); /// @dev `keccak256(bytes("Transfer(address,address,uint256)"))`. uint256 private constant _TRANSFER_EVENT_SIGNATURE = 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef; /// @dev `keccak256(bytes("Approval(address,address,uint256)"))`. uint256 private constant _APPROVAL_EVENT_SIGNATURE = 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925; /// @dev `keccak256(bytes("ApprovalForAll(address,address,bool)"))`. uint256 private constant _APPROVAL_FOR_ALL_EVENT_SIGNATURE = 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31; /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/ /* CUSTOM ERRORS */ /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/ /// @dev Thrown when a call for an NFT function did not originate /// from the base DN404 contract. error SenderNotBase(); /// @dev Thrown when a call for an NFT function did not originate from the deployer. error SenderNotDeployer(); /// @dev Thrown when transferring an NFT to a contract address that /// does not implement ERC721Receiver. error TransferToNonERC721ReceiverImplementer(); /// @dev Thrown when linking to the DN404 base contract and the /// DN404 supportsInterface check fails or the call reverts. error CannotLink(); /// @dev Thrown when a linkMirrorContract call is received and the /// NFT mirror contract has already been linked to a DN404 base contract. error AlreadyLinked(); /// @dev Thrown when retrieving the base DN404 address when a link has not /// been established. error NotLinked(); /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/ /* STORAGE */ /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/ /// @dev Struct contain the NFT mirror contract storage. struct DN404NFTStorage { address baseERC20; address deployer; address owner; } /// @dev Returns a storage pointer for DN404NFTStorage. function _getDN404NFTStorage() internal pure virtual returns (DN404NFTStorage storage $) { /// @solidity memory-safe-assembly assembly { // `uint72(bytes9(keccak256("DN404_MIRROR_STORAGE")))`. $.slot := 0x3602298b8c10b01230 // Truncate to 9 bytes to reduce bytecode size. } } /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/ /* CONSTRUCTOR */ /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/ constructor(address deployer) { // For non-proxies, we will store the deployer so that only the deployer can // link the base contract. _getDN404NFTStorage().deployer = deployer; } /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/ /* ERC721 OPERATIONS */ /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/ /// @dev Returns the token collection name from the base DN404 contract. function name() public view virtual returns (string memory result) { return _readString(0x06fdde03, 0); // `symbol()`. } /// @dev Returns the token collection symbol from the base DN404 contract. function symbol() public view virtual returns (string memory result) { return _readString(0x95d89b41, 0); // `symbol()`. } /// @dev Returns the Uniform Resource Identifier (URI) for token `id` from /// the base DN404 contract. function tokenURI(uint256 id) public view virtual returns (string memory result) { return _readString(0xc87b56dd, id); // `tokenURI()`. } /// @dev Returns the total NFT supply from the base DN404 contract. function totalSupply() public view virtual returns (uint256 result) { return _readWord(0xe2c79281, 0, 0); // `totalNFTSupply()`. } /// @dev Returns the number of NFT tokens owned by `nftOwner` from the base DN404 contract. /// /// Requirements: /// - `nftOwner` must not be the zero address. function balanceOf(address nftOwner) public view virtual returns (uint256 result) { return _readWord(0xf5b100ea, uint160(nftOwner), 0); // `balanceOfNFT(address)`. } /// @dev Returns the owner of token `id` from the base DN404 contract. /// /// Requirements: /// - Token `id` must exist. function ownerOf(uint256 id) public view virtual returns (address result) { return address(uint160(_readWord(0x6352211e, id, 0))); // `ownerOf(uint256)`. } /// @dev Returns the owner of token `id` from the base DN404 contract. /// Returns `address(0)` instead of reverting if the token does not exist. function ownerAt(uint256 id) public view virtual returns (address result) { return address(uint160(_readWord(0x24359879, id, 0))); // `ownerAt(uint256)`. } /// @dev Sets `spender` as the approved account to manage token `id` in /// the base DN404 contract. /// /// Requirements: /// - Token `id` must exist. /// - The caller must be the owner of the token, /// or an approved operator for the token owner. /// /// Emits an {Approval} event. function approve(address spender, uint256 id) public virtual { address base = baseERC20(); /// @solidity memory-safe-assembly assembly { spender := shr(96, shl(96, spender)) let m := mload(0x40) mstore(0x00, 0xd10b6e0c) // `approveNFT(address,uint256,address)`. mstore(0x20, spender) mstore(0x40, id) mstore(0x60, caller()) if iszero( and( gt(returndatasize(), 0x1f), call(gas(), base, callvalue(), 0x1c, 0x64, 0x00, 0x20) ) ) { returndatacopy(m, 0x00, returndatasize()) revert(m, returndatasize()) } mstore(0x40, m) // Restore the free memory pointer. mstore(0x60, 0) // Restore the zero pointer. // Emit the {Approval} event. log4(codesize(), 0x00, _APPROVAL_EVENT_SIGNATURE, shr(96, mload(0x0c)), spender, id) } } /// @dev Returns the account approved to manage token `id` from /// the base DN404 contract. /// /// Requirements: /// - Token `id` must exist. function getApproved(uint256 id) public view virtual returns (address) { return address(uint160(_readWord(0x081812fc, id, 0))); // `getApproved(uint256)`. } /// @dev Sets whether `operator` is approved to manage the tokens of the caller in /// the base DN404 contract. /// /// Emits an {ApprovalForAll} event. function setApprovalForAll(address operator, bool approved) public virtual { address base = baseERC20(); /// @solidity memory-safe-assembly assembly { operator := shr(96, shl(96, operator)) let m := mload(0x40) mstore(0x00, 0x813500fc) // `setApprovalForAll(address,bool,address)`. mstore(0x20, operator) mstore(0x40, iszero(iszero(approved))) mstore(0x60, caller()) if iszero( and(eq(mload(0x00), 1), call(gas(), base, callvalue(), 0x1c, 0x64, 0x00, 0x20)) ) { returndatacopy(m, 0x00, returndatasize()) revert(m, returndatasize()) } // Emit the {ApprovalForAll} event. // The `approved` value is already at 0x40. log3(0x40, 0x20, _APPROVAL_FOR_ALL_EVENT_SIGNATURE, caller(), operator) mstore(0x40, m) // Restore the free memory pointer. mstore(0x60, 0) // Restore the zero pointer. } } /// @dev Returns whether `operator` is approved to manage the tokens of `nftOwner` from /// the base DN404 contract. function isApprovedForAll(address nftOwner, address operator) public view virtual returns (bool result) { // `isApprovedForAll(address,address)`. return _readWord(0xe985e9c5, uint160(nftOwner), uint160(operator)) != 0; } /// @dev Transfers token `id` from `from` to `to`. /// /// Requirements: /// /// - Token `id` must exist. /// - `from` must be the owner of the token. /// - `to` cannot be the zero address. /// - The caller must be the owner of the token, or be approved to manage the token. /// /// Emits a {Transfer} event. function transferFrom(address from, address to, uint256 id) public virtual { address base = baseERC20(); /// @solidity memory-safe-assembly assembly { from := shr(96, shl(96, from)) to := shr(96, shl(96, to)) let m := mload(0x40) mstore(m, 0xe5eb36c8) // `transferFromNFT(address,address,uint256,address)`. mstore(add(m, 0x20), from) mstore(add(m, 0x40), to) mstore(add(m, 0x60), id) mstore(add(m, 0x80), caller()) if iszero( and(eq(mload(m), 1), call(gas(), base, callvalue(), add(m, 0x1c), 0x84, m, 0x20)) ) { returndatacopy(m, 0x00, returndatasize()) revert(m, returndatasize()) } // Emit the {Transfer} event. log4(codesize(), 0x00, _TRANSFER_EVENT_SIGNATURE, from, to, id) } } /// @dev Equivalent to `safeTransferFrom(from, to, id, "")`. function safeTransferFrom(address from, address to, uint256 id) public payable virtual { transferFrom(from, to, id); if (_hasCode(to)) _checkOnERC721Received(from, to, id, ""); } /// @dev Transfers token `id` from `from` to `to`. /// /// Requirements: /// /// - Token `id` must exist. /// - `from` must be the owner of the token. /// - `to` cannot be the zero address. /// - The caller must be the owner of the token, or be approved to manage the token. /// - If `to` refers to a smart contract, it must implement /// {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. /// /// Emits a {Transfer} event. function safeTransferFrom(address from, address to, uint256 id, bytes calldata data) public virtual { transferFrom(from, to, id); if (_hasCode(to)) _checkOnERC721Received(from, to, id, data); } /// @dev Returns true if this contract implements the interface defined by `interfaceId`. /// See: https://eips.ethereum.org/EIPS/eip-165 /// This function call must use less than 30000 gas. function supportsInterface(bytes4 interfaceId) public view virtual returns (bool result) { /// @solidity memory-safe-assembly assembly { let s := shr(224, interfaceId) // ERC165: 0x01ffc9a7, ERC721: 0x80ac58cd, ERC721Metadata: 0x5b5e139f. result := or(or(eq(s, 0x01ffc9a7), eq(s, 0x80ac58cd)), eq(s, 0x5b5e139f)) } } /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/ /* OWNER SYNCING OPERATIONS */ /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/ /// @dev Returns the `owner` of the contract, for marketplace signaling purposes. function owner() public view virtual returns (address) { return _getDN404NFTStorage().owner; } /// @dev Permissionless function to pull the owner from the base DN404 contract /// if it implements ownable, for marketplace signaling purposes. function pullOwner() public virtual { address newOwner; address base = baseERC20(); /// @solidity memory-safe-assembly assembly { mstore(0x00, 0x8da5cb5b) // `owner()`. if and(gt(returndatasize(), 0x1f), staticcall(gas(), base, 0x1c, 0x04, 0x00, 0x20)) { newOwner := shr(96, mload(0x0c)) } } DN404NFTStorage storage $ = _getDN404NFTStorage(); address oldOwner = $.owner; if (oldOwner != newOwner) { $.owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/ /* MIRROR OPERATIONS */ /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/ /// @dev Returns the address of the base DN404 contract. function baseERC20() public view virtual returns (address base) { base = _getDN404NFTStorage().baseERC20; if (base == address(0)) revert NotLinked(); } /// @dev Fallback modifier to execute calls from the base DN404 contract. modifier dn404NFTFallback() virtual { DN404NFTStorage storage $ = _getDN404NFTStorage(); uint256 fnSelector = _calldataload(0x00) >> 224; // `logTransfer(uint256[])`. if (fnSelector == 0x263c69d6) { if (msg.sender != $.baseERC20) revert SenderNotBase(); /// @solidity memory-safe-assembly assembly { // When returndatacopy copies 1 or more out-of-bounds bytes, it reverts. returndatacopy(0x00, returndatasize(), lt(calldatasize(), 0x20)) let o := add(0x24, calldataload(0x04)) // Packed logs offset. returndatacopy(0x00, returndatasize(), lt(calldatasize(), o)) let end := add(o, shl(5, calldataload(sub(o, 0x20)))) returndatacopy(0x00, returndatasize(), lt(calldatasize(), end)) for {} iszero(eq(o, end)) { o := add(0x20, o) } { let d := calldataload(o) // Entry in the packed logs. let a := shr(96, d) // The address. let b := and(1, d) // Whether it is a burn. log4( codesize(), 0x00, _TRANSFER_EVENT_SIGNATURE, mul(a, b), // `from`. mul(a, iszero(b)), // `to`. shr(168, shl(160, d)) // `id`. ) } mstore(0x00, 0x01) return(0x00, 0x20) } } // `linkMirrorContract(address)`. if (fnSelector == 0x0f4599e5) { if ($.deployer != address(0)) { if (address(uint160(_calldataload(0x04))) != $.deployer) { revert SenderNotDeployer(); } } if ($.baseERC20 != address(0)) revert AlreadyLinked(); $.baseERC20 = msg.sender; /// @solidity memory-safe-assembly assembly { mstore(0x00, 0x01) return(0x00, 0x20) } } _; } /// @dev Fallback function for calls from base DN404 contract. fallback() external payable virtual dn404NFTFallback {} receive() external payable virtual {} /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/ /* PRIVATE HELPERS */ /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/ /// @dev Helper to read a string from the base DN404 contract. function _readString(uint256 fnSelector, uint256 arg0) private view returns (string memory result) { address base = baseERC20(); /// @solidity memory-safe-assembly assembly { result := mload(0x40) mstore(0x00, fnSelector) mstore(0x20, arg0) if iszero(staticcall(gas(), base, 0x1c, 0x24, 0x00, 0x00)) { returndatacopy(result, 0x00, returndatasize()) revert(result, returndatasize()) } returndatacopy(0x00, 0x00, 0x20) // Copy the offset of the string in returndata. returndatacopy(result, mload(0x00), 0x20) // Copy the length of the string. returndatacopy(add(result, 0x20), add(mload(0x00), 0x20), mload(result)) // Copy the string. mstore(0x40, add(add(result, 0x20), mload(result))) // Allocate memory. } } /// @dev Helper to read a word from the base DN404 contract. function _readWord(uint256 fnSelector, uint256 arg0, uint256 arg1) private view returns (uint256 result) { address base = baseERC20(); /// @solidity memory-safe-assembly assembly { let m := mload(0x40) mstore(0x00, fnSelector) mstore(0x20, arg0) mstore(0x40, arg1) if iszero( and(gt(returndatasize(), 0x1f), staticcall(gas(), base, 0x1c, 0x44, 0x00, 0x20)) ) { returndatacopy(m, 0x00, returndatasize()) revert(m, returndatasize()) } mstore(0x40, m) // Restore the free memory pointer. result := mload(0x00) } } /// @dev Returns the calldata value at `offset`. function _calldataload(uint256 offset) private pure returns (uint256 value) { /// @solidity memory-safe-assembly assembly { value := calldataload(offset) } } /// @dev Returns if `a` has bytecode of non-zero length. function _hasCode(address a) private view returns (bool result) { /// @solidity memory-safe-assembly assembly { result := extcodesize(a) // Can handle dirty upper bits. } } /// @dev Perform a call to invoke {IERC721Receiver-onERC721Received} on `to`. /// Reverts if the target does not support the function correctly. function _checkOnERC721Received(address from, address to, uint256 id, bytes memory data) private { /// @solidity memory-safe-assembly assembly { // Prepare the calldata. let m := mload(0x40) let onERC721ReceivedSelector := 0x150b7a02 mstore(m, onERC721ReceivedSelector) mstore(add(m, 0x20), caller()) // The `operator`, which is always `msg.sender`. mstore(add(m, 0x40), shr(96, shl(96, from))) mstore(add(m, 0x60), id) mstore(add(m, 0x80), 0x80) let n := mload(data) mstore(add(m, 0xa0), n) if n { pop(staticcall(gas(), 4, add(data, 0x20), n, add(m, 0xc0), n)) } // Revert if the call reverts. if iszero(call(gas(), to, 0, add(m, 0x1c), add(n, 0xa4), m, 0x20)) { if returndatasize() { // Bubble up the revert if the call reverts. returndatacopy(m, 0x00, returndatasize()) revert(m, returndatasize()) } } // Load the returndata and compare it. if iszero(eq(mload(m), shl(224, onERC721ReceivedSelector))) { mstore(0x00, 0xd1a57ed6) // `TransferToNonERC721ReceiverImplementer()`. revert(0x1c, 0x04) } } } } /// @title DN404 /// @notice DN404 is a hybrid ERC20 and ERC721 implementation that mints /// and burns NFTs based on an account's ERC20 token balance. /// /// @author vectorized.eth (@optimizoor) /// @author Quit (@0xQuit) /// @author Michael Amadi (@AmadiMichaels) /// @author cygaar (@0xCygaar) /// @author Thomas (@0xjustadev) /// @author Harrison (@PopPunkOnChain) /// /// @dev Note: /// - The ERC721 data is stored in this base DN404 contract, however a /// ERC_YB_NFT contract ***MUST*** be deployed and linked during /// initialization. abstract contract ERC_YB { /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/ /* EVENTS */ /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/ /// @dev Emitted when `amount` tokens is transferred from `from` to `to`. event Transfer(address indexed from, address indexed to, uint256 amount); /// @dev Emitted when `amount` tokens is approved by `owner` to be used by `spender`. event Approval(address indexed owner, address indexed spender, uint256 amount); /// @dev Emitted when `target` sets their skipNFT flag to `status`. event SkipNFTSet(address indexed target, bool status); /// @dev `keccak256(bytes("Transfer(address,address,uint256)"))`. uint256 private constant _TRANSFER_EVENT_SIGNATURE = 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef; /// @dev `keccak256(bytes("Approval(address,address,uint256)"))`. uint256 private constant _APPROVAL_EVENT_SIGNATURE = 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925; /// @dev `keccak256(bytes("SkipNFTSet(address,bool)"))`. uint256 private constant _SKIP_NFT_SET_EVENT_SIGNATURE = 0xb5a1de456fff688115a4f75380060c23c8532d14ff85f687cc871456d6420393; /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/ /* CUSTOM ERRORS */ /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/ /// @dev Thrown when attempting to double-initialize the contract. error DNAlreadyInitialized(); /// @dev Thrown when attempting to transfer or burn more tokens than sender's balance. error InsufficientBalance(); /// @dev Thrown when a spender attempts to transfer tokens with an insufficient allowance. error InsufficientAllowance(); /// @dev Thrown when minting an amount of tokens that would overflow the max tokens. error TotalSupplyOverflow(); /// @dev The unit cannot be zero. error UnitIsZero(); /// @dev Thrown when the caller for a fallback NFT function is not the mirror contract. error SenderNotMirror(); /// @dev Thrown when attempting to transfer tokens to the zero address. error TransferToZeroAddress(); /// @dev Thrown when the mirror address provided for initialization is the zero address. error MirrorAddressIsZero(); /// @dev Thrown when the link call to the mirror contract reverts. error LinkMirrorContractFailed(); /// @dev Thrown when setting an NFT token approval /// and the caller is not the owner or an approved operator. error ApprovalCallerNotOwnerNorApproved(); /// @dev Thrown when transferring an NFT /// and the caller is not the owner or an approved operator. error TransferCallerNotOwnerNorApproved(); /// @dev Thrown when transferring an NFT and the from address is not the current owner. error TransferFromIncorrectOwner(); /// @dev Thrown when checking the owner or approved address for a non-existent NFT. error TokenDoesNotExist(); /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/ /* CONSTANTS */ /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/ /// @dev The flag to denote that the address data is initialized. uint8 internal constant _ADDRESS_DATA_INITIALIZED_FLAG = 1 << 0; /// @dev The flag to denote that the address should skip NFTs. uint8 internal constant _ADDRESS_DATA_SKIP_NFT_FLAG = 1 << 1; /// @dev The flag to denote that the address has overridden the default Permit2 allowance. uint8 internal constant _ADDRESS_DATA_OVERRIDE_PERMIT2_FLAG = 1 << 2; /// @dev The canonical Permit2 address. /// For signature-based allowance granting for single transaction ERC20 `transferFrom`. /// To enable, override `_givePermit2DefaultInfiniteAllowance()`. /// [Github](https://github.com/Uniswap/permit2) /// [Etherscan](https://etherscan.io/address/0x000000000022D473030F116dDEE9F6B43aC78BA3) address internal constant _PERMIT2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3; /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/ /* STORAGE */ /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/ /// @dev Struct containing an address's token data and settings. struct AddressData { // Auxiliary data. uint88 aux; // Flags for `initialized` and `skipNFT`. uint8 flags; // The alias for the address. Zero means absence of an alias. uint32 addressAlias; // The number of NFT tokens. uint32 ownedLength; // The token balance in wei. uint96 balance; } /// @dev A uint32 map in storage. struct Uint32Map { uint256 spacer; } /// @dev A bitmap in storage. struct Bitmap { uint256 spacer; } /// @dev A struct to wrap a uint256 in storage. struct Uint256Ref { uint256 value; } /// @dev A mapping of an address pair to a Uint256Ref. struct AddressPairToUint256RefMap { uint256 spacer; } /// @dev Struct containing the base token contract storage. struct DN404Storage { // Current number of address aliases assigned. uint32 numAliases; // Next token ID to assign for an NFT mint. uint32 nextTokenId; // Total number of IDs in the burned pool. uint32 burnedPoolSize; // Total supply of minted NFTs. uint32 totalNFTSupply; // Total supply of tokens. uint96 totalSupply; // Address of the NFT mirror contract. address mirrorERC721; // Mapping of a user alias number to their address. mapping(uint32 => address) aliasToAddress; // Mapping of user operator approvals for NFTs. AddressPairToUint256RefMap operatorApprovals; // Mapping of NFT token approvals to approved operators. mapping(uint256 => address) nftApprovals; // Bitmap of whether an non-zero NFT approval may exist. Bitmap mayHaveNFTApproval; // Mapping of user allowances for token spenders. AddressPairToUint256RefMap allowance; // Mapping of NFT IDs owned by an address. mapping(address => Uint32Map) owned; // The pool of burned NFT IDs. Uint32Map burnedPool; // Even indices: owner aliases. Odd indices: owned indices. Uint32Map oo; // Mapping of user account AddressData. mapping(address => AddressData) addressData; } /// @dev Returns a storage pointer for DN404Storage. function _getDN404Storage() internal pure virtual returns (DN404Storage storage $) { /// @solidity memory-safe-assembly assembly { // `uint72(bytes9(keccak256("DN404_STORAGE")))`. $.slot := 0xa20d6e21d0e5255308 // Truncate to 9 bytes to reduce bytecode size. } } /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/ /* INITIALIZER */ /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/ /// @dev Initializes the DN404 contract with an /// `initialTokenSupply`, `initialTokenOwner` and `mirror` NFT contract address. function _initializeDN404( uint256 initialTokenSupply, address initialSupplyOwner, address mirror ) internal virtual { DN404Storage storage $ = _getDN404Storage(); if ($.nextTokenId != 0) revert DNAlreadyInitialized(); if (mirror == address(0)) revert MirrorAddressIsZero(); /// @solidity memory-safe-assembly assembly { // Make the call to link the mirror contract. mstore(0x00, 0x0f4599e5) // `linkMirrorContract(address)`. mstore(0x20, caller()) if iszero(and(eq(mload(0x00), 1), call(gas(), mirror, 0, 0x1c, 0x24, 0x00, 0x20))) { mstore(0x00, 0xd125259c) // `LinkMirrorContractFailed()`. revert(0x1c, 0x04) } } $.nextTokenId = 1; $.mirrorERC721 = mirror; if (_unit() == 0) revert UnitIsZero(); if (initialTokenSupply != 0) { if (initialSupplyOwner == address(0)) revert TransferToZeroAddress(); if (_totalSupplyOverflows(initialTokenSupply)) revert TotalSupplyOverflow(); $.totalSupply = uint96(initialTokenSupply); AddressData storage initialOwnerAddressData = _addressData(initialSupplyOwner); initialOwnerAddressData.balance = uint96(initialTokenSupply); /// @solidity memory-safe-assembly assembly { // Emit the {Transfer} event. mstore(0x00, initialTokenSupply) log3(0x00, 0x20, _TRANSFER_EVENT_SIGNATURE, 0, shr(96, shl(96, initialSupplyOwner))) } _setSkipNFT(initialSupplyOwner, true); } } /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/ /* BASE UNIT FUNCTION TO OVERRIDE */ /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/ /// @dev Amount of token balance that is equal to one NFT. function _unit() internal view virtual returns (uint256) { return 10 ** 18; } /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/ /* METADATA FUNCTIONS TO OVERRIDE */ /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/ /// @dev Returns the name of the token. function name() public view virtual returns (string memory); /// @dev Returns the symbol of the token. function symbol() public view virtual returns (string memory); /// @dev Returns the Uniform Resource Identifier (URI) for token `id`. function tokenURI(uint256 id) public view virtual returns (string memory); /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/ /* ERC20 OPERATIONS */ /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/ /// @dev Returns the decimals places of the token. Always 18. function decimals() public pure returns (uint8) { return 18; } /// @dev Returns the amount of tokens in existence. function totalSupply() public view virtual returns (uint256) { return uint256(_getDN404Storage().totalSupply); } /// @dev Returns the amount of tokens owned by `owner`. function balanceOf(address owner) public view virtual returns (uint256) { return _getDN404Storage().addressData[owner].balance; } /// @dev Returns the amount of tokens that `spender` can spend on behalf of `owner`. function allowance(address owner, address spender) public view returns (uint256) { if (_givePermit2DefaultInfiniteAllowance() && spender == _PERMIT2) { uint8 flags = _getDN404Storage().addressData[owner].flags; if (flags & _ADDRESS_DATA_OVERRIDE_PERMIT2_FLAG == 0) return type(uint256).max; } return _ref(_getDN404Storage().allowance, owner, spender).value; } /// @dev Sets `amount` as the allowance of `spender` over the caller's tokens. /// /// Emits a {Approval} event. function approve(address spender, uint256 amount) public virtual returns (bool) { _approve(msg.sender, spender, amount); return true; } /// @dev Transfer `amount` tokens from the caller to `to`. /// /// Will burn sender NFTs if balance after transfer is less than /// the amount required to support the current NFT balance. /// /// Will mint NFTs to `to` if the recipient's new balance supports /// additional NFTs ***AND*** the `to` address's skipNFT flag is /// set to false. /// /// Requirements: /// - `from` must at least have `amount`. /// /// Emits a {Transfer} event. function transfer(address to, uint256 amount) public virtual returns (bool) { _transfer(msg.sender, to, amount); return true; } /// @dev Transfers `amount` tokens from `from` to `to`. /// /// Note: Does not update the allowance if it is the maximum uint256 value. /// /// Will burn sender NFTs if balance after transfer is less than /// the amount required to support the current NFT balance. /// /// Will mint NFTs to `to` if the recipient's new balance supports /// additional NFTs ***AND*** the `to` address's skipNFT flag is /// set to false. /// /// Requirements: /// - `from` must at least have `amount`. /// - The caller must have at least `amount` of allowance to transfer the tokens of `from`. /// /// Emits a {Transfer} event. function transferFrom(address from, address to, uint256 amount) public virtual returns (bool) { Uint256Ref storage a = _ref(_getDN404Storage().allowance, from, msg.sender); uint256 allowed = _givePermit2DefaultInfiniteAllowance() && msg.sender == _PERMIT2 && (_getDN404Storage().addressData[from].flags & _ADDRESS_DATA_OVERRIDE_PERMIT2_FLAG) == 0 ? type(uint256).max : a.value; if (allowed != type(uint256).max) { if (amount > allowed) revert InsufficientAllowance(); unchecked { a.value = allowed - amount; } } _transfer(from, to, amount); return true; } /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/ /* PERMIT2 */ /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/ /// @dev Whether Permit2 has infinite allowances by default for all owners. /// For signature-based allowance granting for single transaction ERC20 `transferFrom`. /// To enable, override this function to return true. function _givePermit2DefaultInfiniteAllowance() internal view virtual returns (bool) { return false; } /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/ /* INTERNAL MINT FUNCTIONS */ /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/ /// @dev Mints `amount` tokens to `to`, increasing the total supply. /// /// Will mint NFTs to `to` if the recipient's new balance supports /// additional NFTs ***AND*** the `to` address's skipNFT flag is /// set to false. /// /// Emits a {Transfer} event. function _mint(address to, uint256 amount) internal virtual { if (to == address(0)) revert TransferToZeroAddress(); DN404Storage storage $ = _getDN404Storage(); AddressData storage toAddressData = _addressData(to); unchecked { uint256 maxNFTId; { uint256 totalSupply_ = uint256($.totalSupply) + amount; $.totalSupply = uint96(totalSupply_); uint256 overflows = _toUint(_totalSupplyOverflows(totalSupply_)); if (overflows | _toUint(totalSupply_ < amount) != 0) revert TotalSupplyOverflow(); maxNFTId = totalSupply_ / _unit(); } uint256 toEnd; { uint256 toBalance = uint256(toAddressData.balance) + amount; toAddressData.balance = uint96(toBalance); toEnd = toBalance / _unit(); } if (toAddressData.flags & _ADDRESS_DATA_SKIP_NFT_FLAG == 0) { Uint32Map storage toOwned = $.owned[to]; Uint32Map storage oo = $.oo; uint256 toIndex = toAddressData.ownedLength; _PackedLogs memory packedLogs = _packedLogsMalloc(_zeroFloorSub(toEnd, toIndex)); if (packedLogs.logs.length != 0) { _packedLogsSet(packedLogs, to, 0); uint256 burnedPoolSize = $.burnedPoolSize; uint256 nextTokenId = $.nextTokenId; uint32 toAlias = _registerAndResolveAlias(toAddressData, to); $.totalNFTSupply += uint32(packedLogs.logs.length); toAddressData.ownedLength = uint32(toEnd); // Mint loop. do { uint256 id; if (burnedPoolSize != 0) { id = _get($.burnedPool, --burnedPoolSize); } else { id = nextTokenId; while (_get(oo, _ownershipIndex(id)) != 0) { id = _wrapNFTId(id + 1, maxNFTId); } nextTokenId = _wrapNFTId(id + 1, maxNFTId); } _set(toOwned, toIndex, uint32(id)); _setOwnerAliasAndOwnedIndex(oo, id, toAlias, uint32(toIndex++)); _packedLogsAppend(packedLogs, id); } while (toIndex != toEnd); // Leave some spacing between minted batches for better open addressing. $.nextTokenId = uint32(_wrapNFTId(nextTokenId + 7, maxNFTId)); $.burnedPoolSize = uint32(burnedPoolSize); _packedLogsSend(packedLogs, $.mirrorERC721); } } } /// @solidity memory-safe-assembly assembly { // Emit the {Transfer} event. mstore(0x00, amount) log3(0x00, 0x20, _TRANSFER_EVENT_SIGNATURE, 0, shr(96, shl(96, to))) } } /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/ /* INTERNAL BURN FUNCTIONS */ /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/ /// @dev Burns `amount` tokens from `from`, reducing the total supply. /// /// Will burn sender NFTs if balance after transfer is less than /// the amount required to support the current NFT balance. /// /// Emits a {Transfer} event. function _burn(address from, uint256 amount) internal virtual { DN404Storage storage $ = _getDN404Storage(); AddressData storage fromAddressData = _addressData(from); uint256 fromBalance = fromAddressData.balance; if (amount > fromBalance) revert InsufficientBalance(); unchecked { fromAddressData.balance = uint96(fromBalance -= amount); uint256 totalSupply_ = uint256($.totalSupply) - amount; $.totalSupply = uint96(totalSupply_); Uint32Map storage fromOwned = $.owned[from]; uint256 fromIndex = fromAddressData.ownedLength; uint256 numNFTBurns = _zeroFloorSub(fromIndex, fromBalance / _unit()); if (numNFTBurns != 0) { _PackedLogs memory packedLogs = _packedLogsMalloc(numNFTBurns); _packedLogsSet(packedLogs, from, 1); uint256 totalNFTSupply = uint256($.totalNFTSupply) - numNFTBurns; $.totalNFTSupply = uint32(totalNFTSupply); bool addToBurnedPool = _addToBurnedPool(totalNFTSupply, totalSupply_); Uint32Map storage oo = $.oo; uint256 fromEnd = fromIndex - numNFTBurns; fromAddressData.ownedLength = uint32(fromEnd); uint256 burnedPoolSize = $.burnedPoolSize; // Burn loop. do { uint256 id = _get(fromOwned, --fromIndex); _setOwnerAliasAndOwnedIndex(oo, id, 0, 0); _packedLogsAppend(packedLogs, id); if (addToBurnedPool) { _set($.burnedPool, burnedPoolSize++, uint32(id)); } if (_get($.mayHaveNFTApproval, id)) { _set($.mayHaveNFTApproval, id, false); delete $.nftApprovals[id]; } } while (fromIndex != fromEnd); $.burnedPoolSize = uint32(burnedPoolSize); _packedLogsSend(packedLogs, $.mirrorERC721); } } /// @solidity memory-safe-assembly assembly { // Emit the {Transfer} event. mstore(0x00, amount) log3(0x00, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, shl(96, from)), 0) } } /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/ /* INTERNAL TRANSFER FUNCTIONS */ /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/ /// @dev Moves `amount` of tokens from `from` to `to`. /// /// Will burn sender NFTs if balance after transfer is less than /// the amount required to support the current NFT balance. /// /// Will mint NFTs to `to` if the recipient's new balance supports /// additional NFTs ***AND*** the `to` address's skipNFT flag is /// set to false. /// /// Emits a {Transfer} event. function _transfer(address from, address to, uint256 amount) internal virtual { if (to == address(0)) revert TransferToZeroAddress(); DN404Storage storage $ = _getDN404Storage(); AddressData storage fromAddressData = _addressData(from); AddressData storage toAddressData = _addressData(to); _TransferTemps memory t; t.fromOwnedLength = fromAddressData.ownedLength; t.toOwnedLength = toAddressData.ownedLength; t.totalSupply = $.totalSupply; if (amount > (t.fromBalance = fromAddressData.balance)) revert InsufficientBalance(); unchecked { fromAddressData.balance = uint96(t.fromBalance -= amount); toAddressData.balance = uint96(t.toBalance = uint256(toAddressData.balance) + amount); t.numNFTBurns = _zeroFloorSub(t.fromOwnedLength, t.fromBalance / _unit()); if (toAddressData.flags & _ADDRESS_DATA_SKIP_NFT_FLAG == 0) { if (from == to) t.toOwnedLength = t.fromOwnedLength - t.numNFTBurns; t.numNFTMints = _zeroFloorSub(t.toBalance / _unit(), t.toOwnedLength); } t.totalNFTSupply = uint256($.totalNFTSupply) + t.numNFTMints - t.numNFTBurns; $.totalNFTSupply = uint32(t.totalNFTSupply); _PackedLogs memory packedLogs = _packedLogsMalloc(t.numNFTBurns + t.numNFTMints); Uint32Map storage oo = $.oo; uint256 burnedPoolSize = $.burnedPoolSize; if (t.numNFTBurns != 0) { _packedLogsSet(packedLogs, from, 1); bool addToBurnedPool = _addToBurnedPool(t.totalNFTSupply, t.totalSupply); Uint32Map storage fromOwned = $.owned[from]; uint256 fromIndex = t.fromOwnedLength; uint256 fromEnd = fromIndex - t.numNFTBurns; fromAddressData.ownedLength = uint32(fromEnd); // Burn loop. do { uint256 id = _get(fromOwned, --fromIndex); _setOwnerAliasAndOwnedIndex(oo, id, 0, 0); _packedLogsAppend(packedLogs, id); if (addToBurnedPool) { _set($.burnedPool, burnedPoolSize++, uint32(id)); } if (_get($.mayHaveNFTApproval, id)) { _set($.mayHaveNFTApproval, id, false); delete $.nftApprovals[id]; } } while (fromIndex != fromEnd); } if (t.numNFTMints != 0) { _packedLogsSet(packedLogs, to, 0); uint256 nextTokenId = $.nextTokenId; Uint32Map storage toOwned = $.owned[to]; uint256 toIndex = t.toOwnedLength; uint256 toEnd = toIndex + t.numNFTMints; uint32 toAlias = _registerAndResolveAlias(toAddressData, to); uint256 maxNFTId = t.totalSupply / _unit(); toAddressData.ownedLength = uint32(toEnd); // Mint loop. do { uint256 id; if (burnedPoolSize != 0) { id = _get($.burnedPool, --burnedPoolSize); } else { id = nextTokenId; while (_get(oo, _ownershipIndex(id)) != 0) { id = _wrapNFTId(id + 1, maxNFTId); } nextTokenId = _wrapNFTId(id + 1, maxNFTId); } _set(toOwned, toIndex, uint32(id)); _setOwnerAliasAndOwnedIndex(oo, id, toAlias, uint32(toIndex++)); _packedLogsAppend(packedLogs, id); } while (toIndex != toEnd); // Leave some spacing between minted batches for better open addressing. $.nextTokenId = uint32(_wrapNFTId(nextTokenId + 7, maxNFTId)); } if (packedLogs.logs.length != 0) { $.burnedPoolSize = uint32(burnedPoolSize); _packedLogsSend(packedLogs, $.mirrorERC721); } } /// @solidity memory-safe-assembly assembly { // Emit the {Transfer} event. mstore(0x00, amount) // forgefmt: disable-next-item log3(0x00, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, shl(96, from)), shr(96, shl(96, to))) } } /// @dev Returns if burns should be added to the burn pool. function _addToBurnedPool(uint256 totalNFTSupplyAfterBurn, uint256 totalSupplyAfterBurn) internal view virtual returns (bool) { // Add to burned pool if the load factor > 50%, and collection is not small. uint256 thres = (totalSupplyAfterBurn / _unit()) >> 1; return _toUint(totalNFTSupplyAfterBurn > thres) & _toUint(thres > 128) != 0; } /// @dev Transfers token `id` from `from` to `to`. /// /// Requirements: /// /// - Call must originate from the mirror contract. /// - Token `id` must exist. /// - `from` must be the owner of the token. /// - `to` cannot be the zero address. /// `msgSender` must be the owner of the token, or be approved to manage the token. /// /// Emits a {Transfer} event. function _transferFromNFT(address from, address to, uint256 id, address msgSender) internal virtual { DN404Storage storage $ = _getDN404Storage(); if (to == address(0)) revert TransferToZeroAddress(); Uint32Map storage oo = $.oo; if (from != $.aliasToAddress[_get(oo, _ownershipIndex(id))]) { revert TransferFromIncorrectOwner(); } if (msgSender != from) { if (_ref($.operatorApprovals, from, msgSender).value == 0) { if (msgSender != $.nftApprovals[id]) { revert TransferCallerNotOwnerNorApproved(); } } } AddressData storage fromAddressData = _addressData(from); AddressData storage toAddressData = _addressData(to); uint256 unit = _unit(); unchecked { { uint256 fromBalance = fromAddressData.balance; if (unit > fromBalance) revert InsufficientBalance(); fromAddressData.balance = uint96(fromBalance - unit); toAddressData.balance += uint96(unit); } mapping(address => Uint32Map) storage owned = $.owned; Uint32Map storage fromOwned = owned[from]; if (_get($.mayHaveNFTApproval, id)) { _set($.mayHaveNFTApproval, id, false); delete $.nftApprovals[id]; } { uint32 updatedId = _get(fromOwned, --fromAddressData.ownedLength); uint32 i = _get(oo, _ownedIndex(id)); _set(fromOwned, i, updatedId); _set(oo, _ownedIndex(updatedId), i); } uint32 n = toAddressData.ownedLength++; _set(owned[to], n, uint32(id)); _setOwnerAliasAndOwnedIndex(oo, id, _registerAndResolveAlias(toAddressData, to), n); } /// @solidity memory-safe-assembly assembly { // Emit the {Transfer} event. mstore(0x00, unit) // forgefmt: disable-next-item log3(0x00, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, shl(96, from)), shr(96, shl(96, to))) } } /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/ /* INTERNAL APPROVE FUNCTIONS */ /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/ /// @dev Sets `amount` as the allowance of `spender` over the tokens of `owner`. /// /// Emits a {Approval} event. function _approve(address owner, address spender, uint256 amount) internal virtual { if (_givePermit2DefaultInfiniteAllowance() && spender == _PERMIT2) { _getDN404Storage().addressData[owner].flags |= _ADDRESS_DATA_OVERRIDE_PERMIT2_FLAG; } _ref(_getDN404Storage().allowance, owner, spender).value = amount; /// @solidity memory-safe-assembly assembly { // Emit the {Approval} event. mstore(0x00, amount) // forgefmt: disable-next-item log3(0x00, 0x20, _APPROVAL_EVENT_SIGNATURE, shr(96, shl(96, owner)), shr(96, shl(96, spender))) } } /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/ /* DATA HITCHHIKING FUNCTIONS */ /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/ /// @dev Returns the auxiliary data for `owner`. /// Minting, transferring, burning the tokens of `owner` will not change the auxiliary data. /// Auxiliary data can be set for any address, even if it does not have any tokens. function _getAux(address owner) internal view virtual returns (uint88) { return _getDN404Storage().addressData[owner].aux; } /// @dev Set the auxiliary data for `owner` to `value`. /// Minting, transferring, burning the tokens of `owner` will not change the auxiliary data. /// Auxiliary data can be set for any address, even if it does not have any tokens. function _setAux(address owner, uint88 value) internal virtual { _getDN404Storage().addressData[owner].aux = value; } /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/ /* SKIP NFT FUNCTIONS */ /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/ /// @dev Returns true if minting and transferring ERC20s to `owner` will skip minting NFTs. /// Returns false otherwise. function getSkipNFT(address owner) public view virtual returns (bool) { AddressData storage d = _getDN404Storage().addressData[owner]; if (d.flags & _ADDRESS_DATA_INITIALIZED_FLAG == 0) return _hasCode(owner); return d.flags & _ADDRESS_DATA_SKIP_NFT_FLAG != 0; } /// @dev Sets the caller's skipNFT flag to `skipNFT`. Returns true. /// /// Emits a {SkipNFTSet} event. function setSkipNFT(bool skipNFT) public virtual returns (bool) { _setSkipNFT(msg.sender, skipNFT); return true; } /// @dev Internal function to set account `owner` skipNFT flag to `state` /// /// Initializes account `owner` AddressData if it is not currently initialized. /// /// Emits a {SkipNFTSet} event. function _setSkipNFT(address owner, bool state) internal virtual { AddressData storage d = _addressData(owner); if ((d.flags & _ADDRESS_DATA_SKIP_NFT_FLAG != 0) != state) { d.flags ^= _ADDRESS_DATA_SKIP_NFT_FLAG; } /// @solidity memory-safe-assembly assembly { mstore(0x00, iszero(iszero(state))) log2(0x00, 0x20, _SKIP_NFT_SET_EVENT_SIGNATURE, shr(96, shl(96, owner))) } } /// @dev Returns a storage data pointer for account `owner` AddressData /// /// Initializes account `owner` AddressData if it is not currently initialized. function _addressData(address owner) internal virtual returns (AddressData storage d) { d = _getDN404Storage().addressData[owner]; unchecked { if (d.flags & _ADDRESS_DATA_INITIALIZED_FLAG == 0) { uint256 skipNFT = (_toUint(_hasCode(owner)) * _ADDRESS_DATA_SKIP_NFT_FLAG); d.flags = uint8(skipNFT | _ADDRESS_DATA_INITIALIZED_FLAG); } } } /// @dev Returns the `addressAlias` of account `to`. /// /// Assigns and registers the next alias if `to` alias was not previously registered. function _registerAndResolveAlias(AddressData storage toAddressData, address to) internal virtual returns (uint32 addressAlias) { DN404Storage storage $ = _getDN404Storage(); addressAlias = toAddressData.addressAlias; if (addressAlias == 0) { unchecked { addressAlias = ++$.numAliases; } toAddressData.addressAlias = addressAlias; $.aliasToAddress[addressAlias] = to; if (addressAlias == 0) revert(); // Overflow. } } /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/ /* MIRROR OPERATIONS */ /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/ /// @dev Returns the address of the mirror NFT contract. function mirrorERC721() public view virtual returns (address) { return _getDN404Storage().mirrorERC721; } /// @dev Returns the total NFT supply. function _totalNFTSupply() internal view virtual returns (uint256) { return _getDN404Storage().totalNFTSupply; } /// @dev Returns `owner` NFT balance. function _balanceOfNFT(address owner) internal view virtual returns (uint256) { return _getDN404Storage().addressData[owner].ownedLength; } /// @dev Returns the owner of token `id`. /// Returns the zero address instead of reverting if the token does not exist. function _ownerAt(uint256 id) internal view virtual returns (address) { DN404Storage storage $ = _getDN404Storage(); return $.aliasToAddress[_get($.oo, _ownershipIndex(id))]; } /// @dev Returns the owner of token `id`. /// /// Requirements: /// - Token `id` must exist. function _ownerOf(uint256 id) internal view virtual returns (address) { if (!_exists(id)) revert TokenDoesNotExist(); return _ownerAt(id); } /// @dev Returns if token `id` exists. function _exists(uint256 id) internal view virtual returns (bool) { return _ownerAt(id) != address(0); } /// @dev Returns the account approved to manage token `id`. /// /// Requirements: /// - Token `id` must exist. function _getApproved(uint256 id) internal view virtual returns (address) { if (!_exists(id)) revert TokenDoesNotExist(); return _getDN404Storage().nftApprovals[id]; } /// @dev Sets `spender` as the approved account to manage token `id`, using `msgSender`. /// /// Requirements: /// - `msgSender` must be the owner or an approved operator for the token owner. function _approveNFT(address spender, uint256 id, address msgSender) internal virtual returns (address owner) { DN404Storage storage $ = _getDN404Storage(); owner = $.aliasToAddress[_get($.oo, _ownershipIndex(id))]; if (msgSender != owner) { if (_ref($.operatorApprovals, owner, msgSender).value == 0) { revert ApprovalCallerNotOwnerNorApproved(); } } $.nftApprovals[id] = spender; _set($.mayHaveNFTApproval, id, spender != address(0)); } /// @dev Approve or remove the `operator` as an operator for `msgSender`, /// without authorization checks. function _setApprovalForAll(address operator, bool approved, address msgSender) internal virtual { _ref(_getDN404Storage().operatorApprovals, msgSender, operator).value = _toUint(approved); } /// @dev Fallback modifier to dispatch calls from the mirror NFT contract /// to internal functions in this contract. modifier dn404Fallback() virtual { DN404Storage storage $ = _getDN404Storage(); uint256 fnSelector = _calldataload(0x00) >> 224; // `transferFromNFT(address,address,uint256,address)`. if (fnSelector == 0xe5eb36c8) { if (msg.sender != $.mirrorERC721) revert SenderNotMirror(); if (msg.data.length < 0x84) revert(); address from = address(uint160(_calldataload(0x04))); address to = address(uint160(_calldataload(0x24))); uint256 id = _calldataload(0x44); address msgSender = address(uint160(_calldataload(0x64))); _transferFromNFT(from, to, id, msgSender); _return(1); } // `setApprovalForAll(address,bool,address)`. if (fnSelector == 0x813500fc) { if (msg.sender != $.mirrorERC721) revert SenderNotMirror(); if (msg.data.length < 0x64) revert(); address spender = address(uint160(_calldataload(0x04))); bool status = _calldataload(0x24) != 0; address msgSender = address(uint160(_calldataload(0x44))); _setApprovalForAll(spender, status, msgSender); _return(1); } // `isApprovedForAll(address,address)`. if (fnSelector == 0xe985e9c5) { if (msg.sender != $.mirrorERC721) revert SenderNotMirror(); if (msg.data.length < 0x44) revert(); address owner = address(uint160(_calldataload(0x04))); address operator = address(uint160(_calldataload(0x24))); _return(_ref($.operatorApprovals, owner, operator).value); } // `ownerOf(uint256)`. if (fnSelector == 0x6352211e) { if (msg.sender != $.mirrorERC721) revert SenderNotMirror(); if (msg.data.length < 0x24) revert(); uint256 id = _calldataload(0x04); _return(uint160(_ownerOf(id))); } // `ownerAt(uint256)`. if (fnSelector == 0x24359879) { if (msg.sender != $.mirrorERC721) revert SenderNotMirror(); if (msg.data.length < 0x24) revert(); uint256 id = _calldataload(0x04); _return(uint160(_ownerAt(id))); } // `approveNFT(address,uint256,address)`. if (fnSelector == 0xd10b6e0c) { if (msg.sender != $.mirrorERC721) revert SenderNotMirror(); if (msg.data.length < 0x64) revert(); address spender = address(uint160(_calldataload(0x04))); uint256 id = _calldataload(0x24); address msgSender = address(uint160(_calldataload(0x44))); _return(uint160(_approveNFT(spender, id, msgSender))); } // `getApproved(uint256)`. if (fnSelector == 0x081812fc) { if (msg.sender != $.mirrorERC721) revert SenderNotMirror(); if (msg.data.length < 0x24) revert(); uint256 id = _calldataload(0x04); _return(uint160(_getApproved(id))); } // `balanceOfNFT(address)`. if (fnSelector == 0xf5b100ea) { if (msg.sender != $.mirrorERC721) revert SenderNotMirror(); if (msg.data.length < 0x24) revert(); address owner = address(uint160(_calldataload(0x04))); _return(_balanceOfNFT(owner)); } // `totalNFTSupply()`. if (fnSelector == 0xe2c79281) { if (msg.sender != $.mirrorERC721) revert SenderNotMirror(); if (msg.data.length < 0x04) revert(); _return(_totalNFTSupply()); } // `implementsDN404()`. if (fnSelector == 0xb7a94eb8) { _return(1); } _; } /// @dev Fallback function for calls from mirror NFT contract. fallback() external payable virtual dn404Fallback {} receive() external payable virtual {} /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/ /* INTERNAL / PRIVATE HELPERS */ /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/ /// @dev Returns `(i - 1) << 1`. function _ownershipIndex(uint256 i) internal pure returns (uint256) { unchecked { return (i - 1) << 1; // Minus 1 as token IDs start from 1. } } /// @dev Returns `((i - 1) << 1) + 1`. function _ownedIndex(uint256 i) internal pure returns (uint256) { unchecked { return ((i - 1) << 1) + 1; // Minus 1 as token IDs start from 1. } } /// @dev Returns the uint32 value at `index` in `map`. function _get(Uint32Map storage map, uint256 index) internal view returns (uint32 result) { /// @solidity memory-safe-assembly assembly { let s := add(shl(96, map.slot), shr(3, index)) // Storage slot. result := and(0xffffffff, shr(shl(5, and(index, 7)), sload(s))) } } /// @dev Updates the uint32 value at `index` in `map`. function _set(Uint32Map storage map, uint256 index, uint32 value) internal { /// @solidity memory-safe-assembly assembly { let s := add(shl(96, map.slot), shr(3, index)) // Storage slot. let o := shl(5, and(index, 7)) // Storage slot offset (bits). let v := sload(s) // Storage slot value. let m := 0xffffffff // Value mask. sstore(s, xor(v, shl(o, and(m, xor(shr(o, v), value))))) } } /// @dev Sets the owner alias and the owned index together. function _setOwnerAliasAndOwnedIndex( Uint32Map storage map, uint256 id, uint32 ownership, uint32 ownedIndex ) internal { /// @solidity memory-safe-assembly assembly { let i := sub(id, 1) // Index of the uint64 combined value. let s := add(shl(96, map.slot), shr(2, i)) // Storage slot. let o := shl(6, and(i, 3)) // Storage slot offset (bits). let v := sload(s) // Storage slot value. let m := 0xffffffffffffffff // Value mask. let combined := or(shl(32, ownedIndex), and(0xffffffff, ownership)) sstore(s, xor(v, shl(o, and(m, xor(shr(o, v), combined))))) } } /// @dev Returns the boolean value of the bit at `index` in `bitmap`. function _get(Bitmap storage bitmap, uint256 index) internal view returns (bool result) { /// @solidity memory-safe-assembly assembly { let s := add(shl(96, bitmap.slot), shr(8, index)) // Storage slot. result := and(1, shr(and(0xff, index), sload(s))) } } /// @dev Updates the bit at `index` in `bitmap` to `value`. function _set(Bitmap storage bitmap, uint256 index, bool value) internal { /// @solidity memory-safe-assembly assembly { let s := add(shl(96, bitmap.slot), shr(8, index)) // Storage slot. let o := and(0xff, index) // Storage slot offset (bits). sstore(s, or(and(sload(s), not(shl(o, 1))), shl(o, iszero(iszero(value))))) } } /// @dev Returns a storage reference to the value at (`a0`, `a1`) in `map`. function _ref(AddressPairToUint256RefMap storage map, address a0, address a1) internal pure returns (Uint256Ref storage ref) { /// @solidity memory-safe-assembly assembly { mstore(0x28, a1) mstore(0x14, a0) mstore(0x00, map.slot) ref.slot := keccak256(0x00, 0x48) // Clear the part of the free memory pointer that was overwritten. mstore(0x28, 0x00) } } /// @dev Wraps the NFT ID. function _wrapNFTId(uint256 id, uint256 maxNFTId) internal pure returns (uint256 result) { /// @solidity memory-safe-assembly assembly { result := or(mul(iszero(gt(id, maxNFTId)), id), gt(id, maxNFTId)) } } /// @dev Returns whether `amount` is a valid `totalSupply`. function _totalSupplyOverflows(uint256 amount) internal view returns (bool) { unchecked { return _toUint(amount > type(uint96).max) | _toUint(amount / _unit() > type(uint32).max - 1) != 0; } } /// @dev Returns `max(0, x - y)`. function _zeroFloorSub(uint256 x, uint256 y) internal pure returns (uint256 z) { /// @solidity memory-safe-assembly assembly { z := mul(gt(x, y), sub(x, y)) } } /// @dev Returns `b ? 1 : 0`. function _toUint(bool b) internal pure returns (uint256 result) { /// @solidity memory-safe-assembly assembly { result := iszero(iszero(b)) } } /// @dev Struct containing packed log data for {Transfer} events to be /// emitted by the mirror NFT contract. struct _PackedLogs { uint256 offset; uint256 addressAndBit; uint256[] logs; } /// @dev Initiates memory allocation for packed logs with `n` log items. function _packedLogsMalloc(uint256 n) private pure returns (_PackedLogs memory p) { /// @solidity memory-safe-assembly assembly { // Note that `p` implicitly allocates and advances the free memory pointer by // 3 words, which we can safely mutate in `_packedLogsSend`. let logs := mload(0x40) mstore(logs, n) // Store the length. let offset := add(0x20, logs) // Skip the word for `p.logs.length`. mstore(0x40, add(offset, shl(5, n))) // Allocate memory. mstore(add(0x40, p), logs) // Set `p.logs`. mstore(p, offset) // Set `p.offset`. } } /// @dev Set the current address and the burn bit. function _packedLogsSet(_PackedLogs memory p, address a, uint256 burnBit) private pure { /// @solidity memory-safe-assembly assembly { mstore(add(p, 0x20), or(shl(96, a), burnBit)) // Set `p.addressAndBit`. } } /// @dev Adds a packed log item to `p` with token `id`. function _packedLogsAppend(_PackedLogs memory p, uint256 id) private pure { /// @solidity memory-safe-assembly assembly { let offset := mload(p) mstore(offset, or(mload(add(p, 0x20)), shl(8, id))) // `p.addressAndBit | (id << 8)`. mstore(p, add(offset, 0x20)) } } /// @dev Calls the `mirror` NFT contract to emit {Transfer} events for packed logs `p`. function _packedLogsSend(_PackedLogs memory p, address mirror) private { /// @solidity memory-safe-assembly assembly { let logs := mload(add(p, 0x40)) let o := sub(logs, 0x40) // Start of calldata to send. mstore(o, 0x263c69d6) // `logTransfer(uint256[])`. mstore(add(o, 0x20), 0x20) // Offset of `logs` in the calldata to send. let n := add(0x44, shl(5, mload(logs))) // Length of calldata to send. if iszero(and(eq(mload(o), 1), call(gas(), mirror, 0, add(o, 0x1c), n, o, 0x20))) { revert(o, 0x00) } } } /// @dev Struct of temporary variables for transfers. struct _TransferTemps { uint256 numNFTBurns; uint256 numNFTMints; uint256 fromBalance; uint256 toBalance; uint256 fromOwnedLength; uint256 toOwnedLength; uint256 totalSupply; uint256 totalNFTSupply; } /// @dev Returns if `a` has bytecode of non-zero length. function _hasCode(address a) private view returns (bool result) { /// @solidity memory-safe-assembly assembly { result := extcodesize(a) // Can handle dirty upper bits. } } /// @dev Returns the calldata value at `offset`. function _calldataload(uint256 offset) private pure returns (uint256 value) { /// @solidity memory-safe-assembly assembly { value := calldataload(offset) } } /// @dev Executes a return opcode to return `x` and end the current call frame. function _return(uint256 x) private pure { /// @solidity memory-safe-assembly assembly { mstore(0x00, x) return(0x00, 0x20) } } } interface IERC20 { event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address to, uint256 value) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 value) external returns (bool); function transferFrom(address from, address to, uint256 value) external returns (bool); } /** * @dev String operations. */ library Strings { bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef"; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { // Inspired by OraclizeAPI's implementation - MIT licence // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol if (value == 0) { return "0"; } uint256 temp = value; uint256 digits; while (temp != 0) { digits++; temp /= 10; } bytes memory buffer = new bytes(digits); while (value != 0) { digits -= 1; buffer[digits] = bytes1(uint8(48 + uint256(value % 10))); value /= 10; } return string(buffer); } } interface IUniswapV2Factory { event PairCreated( address indexed token0, address indexed token1, address pair, uint256 ); function feeTo() external view returns (address); function feeToSetter() external view returns (address); function getPair(address tokenA, address tokenB) external view returns (address pair); function allPairs(uint256) external view returns (address pair); function allPairsLength() external view returns (uint256); function createPair(address tokenA, address tokenB) external returns (address pair); function setFeeTo(address) external; function setFeeToSetter(address) external; } contract YBOYZ is ERC_YB, Ownable { ERC_YB_NFT private _mirror; using Strings for uint256; error TransferFailed(); string public baseTokenURI = "https://jvwgtygk3tt6jgfavflntvhahksrk6pqzznp4ehau5yebjg3azja.arweave.net/TWxp4Mrc5-SYoKlW2dTgOqUVefDOWv4Q4KdwQKTbBlI/"; IUniswapV2Router02 public immutable _uniswapV2Router; address public immutable uniswapV2Pair; address private deployerWallet; address private marketingWallet; address private constant deadAddress = address(0xdead); bool private swapping; uint256 public initialNftSupply = 10000; uint256 public initialTotalSupply = initialNftSupply * 1e18; // swap fee for ETH at 0.1% supply uint256 public swapTokensAtAmount = (initialTotalSupply * 5)/1000; // a single wallet can hold up to 2.5% of the total supply uint256 public maxWallet = (initialTotalSupply * 25)/1000; uint256 public maxTransactionAmount = maxWallet; bool public tradingOpen = false; bool public swapEnabled = false; uint256 public buyFee = 0; uint256 public sellFee = 0; mapping(address => bool) private _isExcludedFromFees; mapping(address => bool) private _isExcludedMaxTransactionAmount; mapping(address => bool) private automatedMarketMakerPairs; mapping(address => uint256) private _holderLastTransferTimestamp; event ExcludeFromFees(address indexed account, bool isExcluded); event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value); uint8 private constant _decimals = 18; // uint256 private constant _totalTokens = 10_000; uint256 private constant _tokensPerNFT = 1; string private constant _name = "YBOYZ"; string private constant _symbol = "YardBoyz"; constructor() { _initializeOwner(msg.sender); _mirror = new ERC_YB_NFT(owner()); _initializeDN404(initialTotalSupply, msg.sender, address(_mirror)); _setSkipNFT(msg.sender, true); _setSkipNFT(address (this), true); // balanceOf(msg.sender) = initialTotalSupply; // _mintERC20(msg.sender, initialTotalSupply, false); // sepolia net 0x86dcd3293C53Cf8EFd7303B57beb2a3F671dDE98 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); marketingWallet = payable(msg.sender); deployerWallet = payable(msg.sender); // exclude router, contract, and dead address from maxTransactionAmount excludeFromMaxTransaction(address(_uniswapV2Router), true); excludeFromMaxTransaction(address(this), true); excludeFromMaxTransaction(address(0xdead), true); // exclude deployer and marketing wallet from maxTransactionAmount excludeFromMaxTransaction(address(msg.sender), true); excludeFromMaxTransaction(msg.sender, true); excludeFromMaxTransaction(marketingWallet, true); // exclude contract and dead address from fees excludeFromFees(address(this), true); excludeFromFees(address(0xdead), true); // exclude deployer and marketingWallet from fees excludeFromFees(address(msg.sender), true); excludeFromFees(msg.sender, true); excludeFromFees(marketingWallet, true); uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair( address(this), _uniswapV2Router.WETH() ); _setSkipNFT(uniswapV2Pair, true); } function name() public view override returns (string memory) { return _name; } function symbol() public view override returns (string memory) { return _symbol; } function setTokenURI(string memory _tokenURI) public onlyOwner { baseTokenURI = _tokenURI; } function tokenURI(uint256 id) public view override returns (string memory) { return string(abi.encodePacked(baseTokenURI, (id % initialNftSupply).toString(), ".json")); } // function setWhitelist(address account_, bool value_) external onlyOwner { // super.setWhitelist(account_, value_); // } // receive() external payable {} function openTrading() external onlyOwner() { require(!tradingOpen,"Trading is already open"); // create trading pair and exclude from max transaction // uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH()); excludeFromMaxTransaction(address(uniswapV2Pair), true); _setAutomatedMarketMakerPair(address(uniswapV2Pair), true); _approve(address(this), address(_uniswapV2Router), type(uint).max); // _approve(address(this), uniswapV2Pair, type(uint).max); IERC20(uniswapV2Pair).approve(address(_uniswapV2Router), type(uint).max); _uniswapV2Router.addLiquidityETH{value: address(this).balance}( address(this), balanceOf(address(this)), 0, 0, owner(), block.timestamp ); swapEnabled = true; tradingOpen = true; } function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner { _isExcludedMaxTransactionAmount[updAds] = isEx; } function excludeFromFees(address account, bool excluded) public onlyOwner { _isExcludedFromFees[account] = excluded; emit ExcludeFromFees(account, excluded); } function _setAutomatedMarketMakerPair(address pair, bool value) private { automatedMarketMakerPairs[pair] = value; emit SetAutomatedMarketMakerPair(pair, value); } function isExcludedFromFees(address account) public view returns (bool) { return _isExcludedFromFees[account]; } function _transfer(address from, address to, uint256 amount) internal override { require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); if (amount == 0) { return super._transfer(from, to, 0); } if (from != owner() && to != owner() && to != address(0) && to != address(0xdead) && !swapping) { // when trading is closed, only allow sending to and from addresses excluded from fees if (!tradingOpen) { require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active."); } // BUYING - apply max transaction limit if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) { require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount."); require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded"); } // SELLING - LP pair is excluded from maxWallet otherwise the liquidity would be extremely limited else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) { require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount."); } // excluded from max transaction limit else if (!_isExcludedMaxTransactionAmount[to]) { require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded"); } } // maybe swap contract tokens for eth uint256 contractTokenBalance = balanceOf(address(this)); bool canSwap = contractTokenBalance > swapTokensAtAmount; if (canSwap && swapEnabled && !swapping && !automatedMarketMakerPairs[from] && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]) { swapping = true; swapBack(); swapping = false; } // don't take fee if we are swapping, or if sender or receiver is excluded from fees bool takeFee = !swapping && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]; uint256 fees = 0; if (takeFee) { // sell (transfer tokens to LP) if (automatedMarketMakerPairs[to]) { fees = amount * sellFee / 100; } // buy (transfer tokens from LP) else if(automatedMarketMakerPairs[from]) { fees = amount * buyFee / 100; } if (fees > 0) { super._transfer(from, address(this), fees); } amount -= fees; } super._transfer(from, to, amount); } function swapTokensForEth(uint256 tokenAmount) private { address[] memory path = new address[](2); path[0] = address(this); path[1] = _uniswapV2Router.WETH(); _approve(address(this), address(_uniswapV2Router), tokenAmount); _uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens( tokenAmount, 0, path, marketingWallet, block.timestamp ); } function setLimits(uint256 _maxTransactionAmount, uint256 _maxWallet) external onlyOwner { maxTransactionAmount = _maxTransactionAmount * (10 ** 18); maxWallet = _maxWallet * (10 ** 18); } function retrieveStuckEth() external { require(address(this).balance > 0, "Token: no ETH to clear"); require(msg.sender == marketingWallet); payable(msg.sender).transfer(address(this).balance); } function removeStuckToken(address _address) public { require(msg.sender == marketingWallet); require(IERC20(_address).balanceOf(address(this)) > 0, "Can't withdraw 0"); IERC20(_address).transfer(msg.sender, IERC20(_address).balanceOf(address(this))); } function setSwapTokensAtAmount(uint256 _amount) external { require(msg.sender == marketingWallet); swapTokensAtAmount = _amount; } function manualSwap(uint256 percent) external { require(msg.sender == marketingWallet); uint256 contractBalance = balanceOf(address(this)); uint256 swapAmount = contractBalance * percent / 100; swapTokensForEth(swapAmount); } function setMarketingWallet(address _marketingWallet) external { require(msg.sender == marketingWallet); marketingWallet = _marketingWallet; } function setFee(uint256 _buyFee, uint256 _sellFee) external onlyOwner { buyFee = _buyFee; sellFee = _sellFee; } function swapBack() private { uint256 contractBalance = balanceOf(address(this)); if (contractBalance == 0) { // nothing to swap return; } uint256 tokensToSwap = contractBalance; if (tokensToSwap > swapTokensAtAmount) { tokensToSwap = swapTokensAtAmount; } swapTokensForEth(tokensToSwap); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadyInitialized","type":"error"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"DNAlreadyInitialized","type":"error"},{"inputs":[],"name":"InsufficientAllowance","type":"error"},{"inputs":[],"name":"InsufficientBalance","type":"error"},{"inputs":[],"name":"LinkMirrorContractFailed","type":"error"},{"inputs":[],"name":"MirrorAddressIsZero","type":"error"},{"inputs":[],"name":"NewOwnerIsZeroAddress","type":"error"},{"inputs":[],"name":"NoHandoverRequest","type":"error"},{"inputs":[],"name":"SenderNotMirror","type":"error"},{"inputs":[],"name":"TokenDoesNotExist","type":"error"},{"inputs":[],"name":"TotalSupplyOverflow","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFailed","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"inputs":[],"name":"Unauthorized","type":"error"},{"inputs":[],"name":"UnitIsZero","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":"amount","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"bool","name":"isExcluded","type":"bool"}],"name":"ExcludeFromFees","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pendingOwner","type":"address"}],"name":"OwnershipHandoverCanceled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pendingOwner","type":"address"}],"name":"OwnershipHandoverRequested","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pair","type":"address"},{"indexed":true,"internalType":"bool","name":"value","type":"bool"}],"name":"SetAutomatedMarketMakerPair","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"target","type":"address"},{"indexed":false,"internalType":"bool","name":"status","type":"bool"}],"name":"SkipNFTSet","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":"amount","type":"uint256"}],"name":"Transfer","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[],"name":"_uniswapV2Router","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"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":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseTokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"buyFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cancelOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"pendingOwner","type":"address"}],"name":"completeOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"excluded","type":"bool"}],"name":"excludeFromFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"updAds","type":"address"},{"internalType":"bool","name":"isEx","type":"bool"}],"name":"excludeFromMaxTransaction","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"getSkipNFT","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"initialNftSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"initialTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isExcludedFromFees","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"percent","type":"uint256"}],"name":"manualSwap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxTransactionAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxWallet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mirrorERC721","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"openTrading","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"result","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pendingOwner","type":"address"}],"name":"ownershipHandoverExpiresAt","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"removeStuckToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"requestOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"retrieveStuckEth","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sellFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_buyFee","type":"uint256"},{"internalType":"uint256","name":"_sellFee","type":"uint256"}],"name":"setFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxTransactionAmount","type":"uint256"},{"internalType":"uint256","name":"_maxWallet","type":"uint256"}],"name":"setLimits","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_marketingWallet","type":"address"}],"name":"setMarketingWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"skipNFT","type":"bool"}],"name":"setSkipNFT","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"setSwapTokensAtAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_tokenURI","type":"string"}],"name":"setTokenURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"swapEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"swapTokensAtAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tradingOpen","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"uniswapV2Pair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]
Contract Creation Code
610160604052607560c08181529062005c7e60e039600190620000239082620007e5565b5061271060048190556200004090670de0b6b3a7640000620008b1565b60058181556103e8916200005491620008b1565b620000609190620008db565b6006556103e86005546019620000779190620008b1565b620000839190620008db565b60078190556008556009805461ffff191690555f600a819055600b55348015620000ab575f80fd5b50620000b73362000391565b638b78c6d81954604051620000cc906200073c565b6001600160a01b039091168152602001604051809103905ff080158015620000f6573d5f803e3d5ffd5b505f80546001600160a01b0319166001600160a01b0392909216918217905560055462000125913390620003cc565b620001323360016200058b565b6200013f3060016200058b565b737a250d5630b4cf539739df2c5dacb4c659f2488d608081905260038054336001600160a01b031991821681179092556002805490911690911790556200018890600162000619565b6200019530600162000619565b620001a461dead600162000619565b620001b133600162000619565b620001be33600162000619565b600354620001d7906001600160a01b0316600162000619565b620001e43060016200064d565b620001f361dead60016200064d565b620002003360016200064d565b6200020d3360016200064d565b60035462000226906001600160a01b031660016200064d565b6080516001600160a01b031663c45a01556040518163ffffffff1660e01b8152600401602060405180830381865afa15801562000265573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906200028b9190620008fb565b6001600160a01b031663c9c65396306080516001600160a01b031663ad5c46486040518163ffffffff1660e01b8152600401602060405180830381865afa158015620002d9573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190620002ff9190620008fb565b6040516001600160e01b031960e085901b1681526001600160a01b039283166004820152911660248201526044016020604051808303815f875af11580156200034a573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190620003709190620008fb565b6001600160a01b031660a08190526200038b9060016200058b565b6200092a565b6001600160a01b0316638b78c6d819819055805f7f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e08180a350565b68a20d6e21d0e52553088054640100000000900463ffffffff16156200040557604051633ab534b960e21b815260040160405180910390fd5b6001600160a01b0382166200042d576040516339a84a7b60e01b815260040160405180910390fd5b630f4599e55f523360205260205f6024601c5f865af160015f5114166200045b5763d125259c5f526004601cfd5b805463ffffffff60201b19166401000000001781556001810180546001600160a01b0384166001600160a01b0319909116179055831562000585576001600160a01b038316620004be57604051633a954ecd60e21b815260040160405180910390fd5b6001600160601b03841163fffffffe670de0b6b3a76400008604111715620004f95760405163e5cfe95760e01b815260040160405180910390fd5b8054600160801b600160e01b031916600160801b6001600160601b038616021781555f6200052784620006b5565b80546001600160601b038716600160a01b026001600160a01b039182161782555f8781529192508516907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef602082a3620005838460016200058b565b505b50505050565b5f6200059783620006b5565b80549091506b0100000000000000000000009004600216151582151514620005e357805460ff6b01000000000000000000000080830482166002189091160260ff60581b199091161781555b8115155f528260601b60601c7fb5a1de456fff688115a4f75380060c23c8532d14ff85f687cc871456d642039360205fa2505050565b620006236200071f565b6001600160a01b03919091165f908152600d60205260409020805460ff1916911515919091179055565b620006576200071f565b6001600160a01b0382165f818152600c6020908152604091829020805460ff191685151590811790915591519182527f9d8f7706ea1113d1a167b526eca956215946dd36cc7df39eb16180222d8b5df7910160405180910390a25050565b6001600160a01b0381165f90815268a20d6e21d0e525531260205260408120805490916b01000000000000000000000090910460011690036200071a57805460ff60581b19166b01000000000000000000000060ff843b151560020260011716021781555b919050565b638b78c6d8195433146200073a576382b429005f526004601cfd5b565b610e318062004e4d83390190565b634e487b7160e01b5f52604160045260245ffd5b600181811c908216806200077357607f821691505b6020821081036200079257634e487b7160e01b5f52602260045260245ffd5b50919050565b601f821115620007e057805f5260205f20601f840160051c81016020851015620007bf5750805b601f840160051c820191505b8181101562000583575f8155600101620007cb565b505050565b81516001600160401b038111156200080157620008016200074a565b62000819816200081284546200075e565b8462000798565b602080601f8311600181146200084f575f8415620008375750858301515b5f19600386901b1c1916600185901b178555620008a9565b5f85815260208120601f198616915b828110156200087f578886015182559484019460019091019084016200085e565b50858210156200089d57878501515f19600388901b60f8161c191681555b505060018460011b0185555b505050505050565b8082028115828204841417620008d557634e487b7160e01b5f52601160045260245ffd5b92915050565b5f82620008f657634e487b7160e01b5f52601260045260245ffd5b500490565b5f602082840312156200090c575f80fd5b81516001600160a01b038116811462000923575f80fd5b9392505050565b60805160a0516144c26200098b5f395f81816109f801528181611c9701528181611cc20152611dbe01525f8181610b0101528181611cee01528181611d7001528181611e570152818161307e0152818161315c01526131c101526144c25ff3fe6080604052600436106102ea575f3560e01c8063715018a611610183578063c9567bf9116100d5578063e2f4560511610089578063f8b45b0511610063578063f8b45b0514610e30578063fee81cf414610e45578063ffb54a9914610e76576102f1565b8063e2f4560514610df5578063f04e283e14610e0a578063f2fde38b14610e1d576102f1565b8063dd62ed3e116100ba578063dd62ed3e14610d7a578063e083e92214610db7578063e0df5b6f14610dd6576102f1565b8063c9567bf914610d52578063d547cfb714610d66576102f1565b8063afa4f3b211610137578063c4590d3f11610111578063c4590d3f14610cff578063c87b56dd14610d1e578063c8c8ebe414610d3d576102f1565b8063afa4f3b214610ca2578063b70143c914610cc1578063c024666814610ce0576102f1565b80638da5cb5b116101685780638da5cb5b14610c0b57806395d89b4114610c3e578063a9059cbb14610c83576102f1565b8063715018a614610be45780637571336a14610bec576102f1565b806349bd5a5e1161023c57806354d1f13d116101f05780635d098b38116101ca5780635d098b3814610b385780636ddd171314610b5757806370a0823114610b75576102f1565b806354d1f13d14610ae8578063583e056814610af05780635a09712314610b23576102f1565b80634ef41efc116102215780634ef41efc14610a535780634fbee19314610a8557806352f7c98814610ac9576102f1565b806349bd5a5e146109e75780634d54557f14610a3f576102f1565b8063274e430b1161029e578063311028af11610278578063311028af146109a2578063313ce567146109b757806347062402146109d2576102f1565b8063274e430b1461094f5780632a6a935d1461096e5780632b14ca561461098d576102f1565b806318160ddd116102cf57806318160ddd146108e057806323b872dd146109285780632569296214610947576102f1565b806306fdde031461085a578063095ea7b3146108b1576102f1565b366102f157005b68a20d6e21d0e52553085f3560e01c63e5eb36c881900361039357600182015473ffffffffffffffffffffffffffffffffffffffff16331461035f576040517fce5a776b00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b608436101561036c575f80fd5b60043560243560443560643561038484848484610e8f565b61038e6001611454565b505050505b8063813500fc0361043957600182015473ffffffffffffffffffffffffffffffffffffffff1633146103f1576040517fce5a776b00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60643610156103fe575f80fd5b6004356028818152604435601481905268a20d6e21d0e525530b5f9081526048812092526024351515918290556104356001611454565b5050505b8063e985e9c5036104d357600182015473ffffffffffffffffffffffffffffffffffffffff163314610497576040517fce5a776b00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60443610156104a4575f80fd5b60243560288181526004356014819052600385015f90815260488120925290549091906104d090611454565b50505b80636352211e0361056a57600182015473ffffffffffffffffffffffffffffffffffffffff163314610531576040517fce5a776b00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b602436101561053e575f80fd5b60043561056861054d8261145c565b73ffffffffffffffffffffffffffffffffffffffff16611454565b505b806324359879036105e657600182015473ffffffffffffffffffffffffffffffffffffffff1633146105c8576040517fce5a776b00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60243610156105d5575f80fd5b6004356105e461054d826114ab565b505b8063d10b6e0c0361066c57600182015473ffffffffffffffffffffffffffffffffffffffff163314610644576040517fce5a776b00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6064361015610651575f80fd5b60043560243560443561066861054d84848461152c565b5050505b8063081812fc036106e857600182015473ffffffffffffffffffffffffffffffffffffffff1633146106ca576040517fce5a776b00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60243610156106d7575f80fd5b6004356106e661054d82611683565b505b8063f5b100ea036107ae57600182015473ffffffffffffffffffffffffffffffffffffffff163314610746576040517fce5a776b00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6024361015610753575f80fd5b6004356107ac6107a78273ffffffffffffffffffffffffffffffffffffffff165f90815268a20d6e21d0e5255312602052604090205463ffffffff7001000000000000000000000000000000009091041690565b611454565b505b8063e2c792810361084357600182015473ffffffffffffffffffffffffffffffffffffffff16331461080c576040517fce5a776b00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6004361015610819575f80fd5b68a20d6e21d0e525530854610843906c01000000000000000000000000900463ffffffff16611454565b8063b7a94eb803610858576108586001611454565b005b348015610865575f80fd5b5060408051808201909152600581527f59424f595a00000000000000000000000000000000000000000000000000000060208201525b6040516108a89190613d3f565b60405180910390f35b3480156108bc575f80fd5b506108d06108cb366004613db0565b6116f3565b60405190151581526020016108a8565b3480156108eb575f80fd5b5068a20d6e21d0e52553085470010000000000000000000000000000000090046bffffffffffffffffffffffff165b6040519081526020016108a8565b348015610933575f80fd5b506108d0610942366004613dda565b611708565b6108586117ac565b34801561095a575f80fd5b506108d0610969366004613e18565b6117f9565b348015610979575f80fd5b506108d0610988366004613e40565b611864565b348015610998575f80fd5b5061091a600b5481565b3480156109ad575f80fd5b5061091a60055481565b3480156109c2575f80fd5b50604051601281526020016108a8565b3480156109dd575f80fd5b5061091a600a5481565b3480156109f2575f80fd5b50610a1a7f000000000000000000000000000000000000000000000000000000000000000081565b60405173ffffffffffffffffffffffffffffffffffffffff90911681526020016108a8565b348015610a4a575f80fd5b50610858611877565b348015610a5e575f80fd5b5068a20d6e21d0e52553095473ffffffffffffffffffffffffffffffffffffffff16610a1a565b348015610a90575f80fd5b506108d0610a9f366004613e18565b73ffffffffffffffffffffffffffffffffffffffff165f908152600c602052604090205460ff1690565b348015610ad4575f80fd5b50610858610ae3366004613e5b565b611934565b610858611947565b348015610afb575f80fd5b50610a1a7f000000000000000000000000000000000000000000000000000000000000000081565b348015610b2e575f80fd5b5061091a60045481565b348015610b43575f80fd5b50610858610b52366004613e18565b611980565b348015610b62575f80fd5b506009546108d090610100900460ff1681565b348015610b80575f80fd5b5061091a610b8f366004613e18565b73ffffffffffffffffffffffffffffffffffffffff165f90815268a20d6e21d0e525531260205260409020547401000000000000000000000000000000000000000090046bffffffffffffffffffffffff1690565b6108586119ea565b348015610bf7575f80fd5b50610858610c06366004613e7b565b6119fd565b348015610c16575f80fd5b507fffffffffffffffffffffffffffffffffffffffffffffffffffffffff7487392754610a1a565b348015610c49575f80fd5b5060408051808201909152600881527f59617264426f797a000000000000000000000000000000000000000000000000602082015261089b565b348015610c8e575f80fd5b506108d0610c9d366004613db0565b611a5a565b348015610cad575f80fd5b50610858610cbc366004613eb2565b611a66565b348015610ccc575f80fd5b50610858610cdb366004613eb2565b611a8e565b348015610ceb575f80fd5b50610858610cfa366004613e7b565b611b15565b348015610d0a575f80fd5b50610858610d19366004613e5b565b611ba6565b348015610d29575f80fd5b5061089b610d38366004613eb2565b611bdc565b348015610d48575f80fd5b5061091a60085481565b348015610d5d575f80fd5b50610858611c1d565b348015610d71575f80fd5b5061089b611fb2565b348015610d85575f80fd5b5061091a610d94366004613ec9565b602890815260149190915268a20d6e21d0e525530e5f9081526048812091525490565b348015610dc2575f80fd5b50610858610dd1366004613e18565b61203e565b348015610de1575f80fd5b50610858610df0366004613f22565b612281565b348015610e00575f80fd5b5061091a60065481565b610858610e18366004613e18565b612295565b610858610e2b366004613e18565b6122cf565b348015610e3b575f80fd5b5061091a60075481565b348015610e50575f80fd5b5061091a610e5f366004613e18565b63389a75e1600c9081525f91909152602090205490565b348015610e81575f80fd5b506009546108d09060ff1681565b68a20d6e21d0e525530873ffffffffffffffffffffffffffffffffffffffff8416610ee6576040517fea553b3400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60098101600282015f610f3d837fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff880160011b5b5f8160031c8360601b0180546007841660051b1c63ffffffff1691505092915050565b63ffffffff16815260208101919091526040015f205473ffffffffffffffffffffffffffffffffffffffff878116911614610fa4576040517fa114810000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8573ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff16146110575760288381526014879052600383015f908152604881209152545f03611057575f84815260048301602052604090205473ffffffffffffffffffffffffffffffffffffffff848116911614611057576040517f59c896be00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f611061876122f5565b90505f61106d876122f5565b8254909150670de0b6b3a7640000907401000000000000000000000000000000000000000090046bffffffffffffffffffffffff16808211156110dc576040517ff4d678b800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b83546bffffffffffffffffffffffff9183900382167401000000000000000000000000000000000000000090810273ffffffffffffffffffffffffffffffffffffffff9283161786558454818104841685019093160291811691909117835589165f9081526007860160208190526040909120611170600588018a60609190911b600882901c0154600160ff9092161c1690565b156111c5576005870160601b60088a901c018054600160ff8c161b191690555f898152600488016020526040902080547fffffffffffffffffffffffff00000000000000000000000000000000000000001690555b84547fffffffffffffffffffffffff00000000ffffffffffffffffffffffffffffffff81167001000000000000000000000000000000009182900463ffffffff9081167fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01808216909302919091178755606083901b631fffffff600384901c1601545f9260e060059190911b161c1690505f61128a887fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8d01600190811b01610f1a565b606084901b631fffffff600383901c1601805460e0600584901b1681811c861863ffffffff16901b1890559050611318887fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff63ffffffff851601600190811b01838160031c8360601b016007831660051b815463ffffffff8482841c188116831b8218845550505050505050565b505083547fffffffffffffffffffffffff00000000ffffffffffffffffffffffffffffffff81167001000000000000000000000000000000009182900463ffffffff81811660018101821690940292909217875573ffffffffffffffffffffffffffffffffffffffff8d165f90815260208690526040902060601b631fffffff600383901c1601805460e060059390931b9290921682811c8e1890931690921b189055611410878b6113ca888f612386565b84600183038060021c8560601b016003821660061b9150805467ffffffffffffffff8563ffffffff168560201b178083861c188216851b83188455505050505050505050565b505050805f528760601b60601c8960601b60601c7fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef60205fa3505050505050505050565b805f5260205ff35b5f61146682612480565b61149c576040517fceea21b600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6114a5826114ab565b92915050565b5f68a20d6e21d0e525530868a20d6e21d0e525530a826114f968a20d6e21d0e52553117fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff870160011b610f1a565b63ffffffff16815260208101919091526040015f205473ffffffffffffffffffffffffffffffffffffffff169392505050565b5f68a20d6e21d0e525530868a20d6e21d0e525530a8261157a68a20d6e21d0e52553117fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff880160011b610f1a565b63ffffffff16815260208101919091526040015f205473ffffffffffffffffffffffffffffffffffffffff9081169250831682146116035760288381526014839052600382015f908152604881209152545f03611603576040517fcfb3b94200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f848152600482016020526040902080547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff87169081179091556005820160601b600886901c018054600160ff881690811b1991909116921515901b919091179055509392505050565b5f61168d82612480565b6116c3576040517fceea21b600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b505f90815268a20d6e21d0e525530c602052604090205473ffffffffffffffffffffffffffffffffffffffff1690565b5f6116ff3384846124a9565b50600192915050565b336028908152601484905268a20d6e21d0e525530e5f908152604881209181905281549091907fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8114611795578084111561178f576040517f13be252b00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b83810382555b6117a0868686612516565b50600195945050505050565b5f6202a30067ffffffffffffffff164201905063389a75e1600c52335f52806020600c2055337fdbf36a107da19e49527a7176a1babf963b4b0ff8cde35ee35d6cd8f1f9ac7e1d5f80a250565b73ffffffffffffffffffffffffffffffffffffffff81165f90815268a20d6e21d0e52553126020526040812080546b0100000000000000000000009004600116820361184957823b5b9392505050565b546b0100000000000000000000009004600216151592915050565b5f61186f3383612ecf565b506001919050565b5f47116118e5576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601660248201527f546f6b656e3a206e6f2045544820746f20636c6561720000000000000000000060448201526064015b60405180910390fd5b60035473ffffffffffffffffffffffffffffffffffffffff163314611908575f80fd5b60405133904780156108fc02915f818181858888f19350505050158015611931573d5f803e3d5ffd5b50565b61193c612f75565b600a91909155600b55565b63389a75e1600c52335f525f6020600c2055337ffa7b8eab7da67f412cc9575ed43464468f9bfbae89d1675917346ca6d8fe3c925f80a2565b60035473ffffffffffffffffffffffffffffffffffffffff1633146119a3575f80fd5b600380547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff92909216919091179055565b6119f2612f75565b6119fb5f612faa565b565b611a05612f75565b73ffffffffffffffffffffffffffffffffffffffff919091165f908152600d6020526040902080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0016911515919091179055565b5f6116ff338484612516565b60035473ffffffffffffffffffffffffffffffffffffffff163314611a89575f80fd5b600655565b60035473ffffffffffffffffffffffffffffffffffffffff163314611ab1575f80fd5b305f90815268a20d6e21d0e525531260205260408120547401000000000000000000000000000000000000000090046bffffffffffffffffffffffff16906064611afb8484614018565b611b05919061405c565b9050611b108161300f565b505050565b611b1d612f75565b73ffffffffffffffffffffffffffffffffffffffff82165f818152600c602090815260409182902080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff001685151590811790915591519182527f9d8f7706ea1113d1a167b526eca956215946dd36cc7df39eb16180222d8b5df7910160405180910390a25050565b611bae612f75565b611bc082670de0b6b3a7640000614018565b600855611bd581670de0b6b3a7640000614018565b6007555050565b60606001611bf660045484611bf1919061406f565b613233565b604051602001611c079291906140d3565b6040516020818303038152906040529050919050565b611c25612f75565b60095460ff1615611c92576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601760248201527f54726164696e6720697320616c7265616479206f70656e00000000000000000060448201526064016118dc565b611cbd7f000000000000000000000000000000000000000000000000000000000000000060016119fd565b611ce87f0000000000000000000000000000000000000000000000000000000000000000600161336c565b611d33307f00000000000000000000000000000000000000000000000000000000000000007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6124a9565b6040517f095ea7b300000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000000000000000000000000000000000000000000000811660048301527fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60248301527f0000000000000000000000000000000000000000000000000000000000000000169063095ea7b3906044016020604051808303815f875af1158015611e04573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190611e28919061419c565b50305f81815268a20d6e21d0e5255312602052604090205473ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000000000000000000000000000000000000000000000169163f305d719914791907401000000000000000000000000000000000000000090046bffffffffffffffffffffffff165f80611ed17fffffffffffffffffffffffffffffffffffffffffffffffffffffffff748739275490565b60405160e088901b7fffffffff0000000000000000000000000000000000000000000000000000000016815273ffffffffffffffffffffffffffffffffffffffff958616600482015260248101949094526044840192909252606483015290911660848201524260a482015260c40160606040518083038185885af1158015611f5c573d5f803e3d5ffd5b50505050506040513d601f19601f82011682018060405250810190611f8191906141b7565b5050600980547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661010117905550565b60018054611fbf90614082565b80601f0160208091040260200160405190810160405280929190818152602001828054611feb90614082565b80156120365780601f1061200d57610100808354040283529160200191612036565b820191905f5260205f20905b81548152906001019060200180831161201957829003601f168201915b505050505081565b60035473ffffffffffffffffffffffffffffffffffffffff163314612061575f80fd5b6040517f70a082310000000000000000000000000000000000000000000000000000000081523060048201525f9073ffffffffffffffffffffffffffffffffffffffff8316906370a0823190602401602060405180830381865afa1580156120cb573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906120ef91906141e2565b11612156576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601060248201527f43616e277420776974686472617720300000000000000000000000000000000060448201526064016118dc565b6040517f70a0823100000000000000000000000000000000000000000000000000000000815230600482015273ffffffffffffffffffffffffffffffffffffffff82169063a9059cbb90339083906370a0823190602401602060405180830381865afa1580156121c8573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906121ec91906141e2565b6040517fffffffff0000000000000000000000000000000000000000000000000000000060e085901b16815273ffffffffffffffffffffffffffffffffffffffff909216600483015260248201526044016020604051808303815f875af1158015612259573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061227d919061419c565b5050565b612289612f75565b600161227d8282614244565b61229d612f75565b63389a75e1600c52805f526020600c2080544211156122c357636f5e88185f526004601cfd5b5f905561193181612faa565b6122d7612f75565b8060601b6122ec57637448fbae5f526004601cfd5b61193181612faa565b73ffffffffffffffffffffffffffffffffffffffff81165f90815268a20d6e21d0e525531260205260408120805490916b01000000000000000000000090910460011690036123815780547fffffffffffffffffffffffffffffffffffffffff00ffffffffffffffffffffff166b01000000000000000000000060ff843b151560020260011716021781555b919050565b81546c01000000000000000000000000900463ffffffff1668a20d6e21d0e52553085f8290036124795780547fffffffffffffffffffffffffffffffffffffffffffffffffffffffff000000008116600163ffffffff92831601918216908117835585547fffffffffffffffffffffffffffffffff00000000ffffffffffffffffffffffff166c0100000000000000000000000082021786555f818152600284016020526040812080547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff88161790559193509003612479575f80fd5b5092915050565b5f8061248b836114ab565b73ffffffffffffffffffffffffffffffffffffffff16141592915050565b6028828152601484905268a20d6e21d0e525530e5f9081526048812091528190555f81815273ffffffffffffffffffffffffffffffffffffffff80841691908516907f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92590602090a3505050565b73ffffffffffffffffffffffffffffffffffffffff83166125b9576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602560248201527f45524332303a207472616e736665722066726f6d20746865207a65726f20616460448201527f647265737300000000000000000000000000000000000000000000000000000060648201526084016118dc565b73ffffffffffffffffffffffffffffffffffffffff821661265c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602360248201527f45524332303a207472616e7366657220746f20746865207a65726f206164647260448201527f657373000000000000000000000000000000000000000000000000000000000060648201526084016118dc565b805f0361266e57611b1083835f6133ea565b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffff748739275473ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161415801561271857507fffffffffffffffffffffffffffffffffffffffffffffffffffffffff748739275473ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1614155b8015612739575073ffffffffffffffffffffffffffffffffffffffff821615155b801561275d575073ffffffffffffffffffffffffffffffffffffffff821661dead14155b8015612784575060035474010000000000000000000000000000000000000000900460ff16155b15612bf15760095460ff166128505773ffffffffffffffffffffffffffffffffffffffff83165f908152600c602052604090205460ff16806127ea575073ffffffffffffffffffffffffffffffffffffffff82165f908152600c602052604090205460ff165b612850576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601660248201527f54726164696e67206973206e6f74206163746976652e0000000000000000000060448201526064016118dc565b73ffffffffffffffffffffffffffffffffffffffff83165f908152600e602052604090205460ff1680156128a9575073ffffffffffffffffffffffffffffffffffffffff82165f908152600d602052604090205460ff16155b15612a0d57600854811115612940576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152603560248201527f427579207472616e7366657220616d6f756e742065786365656473207468652060448201527f6d61785472616e73616374696f6e416d6f756e742e000000000000000000000060648201526084016118dc565b60075473ffffffffffffffffffffffffffffffffffffffff83165f90815268a20d6e21d0e525531260205260409020547401000000000000000000000000000000000000000090046bffffffffffffffffffffffff166129a0908361435c565b1115612a08576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601360248201527f4d61782077616c6c65742065786365656465640000000000000000000000000060448201526064016118dc565b612bf1565b73ffffffffffffffffffffffffffffffffffffffff82165f908152600e602052604090205460ff168015612a66575073ffffffffffffffffffffffffffffffffffffffff83165f908152600d602052604090205460ff16155b15612afd57600854811115612a08576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152603660248201527f53656c6c207472616e7366657220616d6f756e7420657863656564732074686560448201527f206d61785472616e73616374696f6e416d6f756e742e0000000000000000000060648201526084016118dc565b73ffffffffffffffffffffffffffffffffffffffff82165f908152600d602052604090205460ff16612bf15760075473ffffffffffffffffffffffffffffffffffffffff83165f90815268a20d6e21d0e525531260205260409020547401000000000000000000000000000000000000000090046bffffffffffffffffffffffff16612b89908361435c565b1115612bf1576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601360248201527f4d61782077616c6c65742065786365656465640000000000000000000000000060448201526064016118dc565b305f90815268a20d6e21d0e525531260205260408120547401000000000000000000000000000000000000000090046bffffffffffffffffffffffff166006549091508111808015612c4a5750600954610100900460ff165b8015612c71575060035474010000000000000000000000000000000000000000900460ff16155b8015612ca2575073ffffffffffffffffffffffffffffffffffffffff85165f908152600e602052604090205460ff16155b8015612cd3575073ffffffffffffffffffffffffffffffffffffffff85165f908152600c602052604090205460ff16155b8015612d04575073ffffffffffffffffffffffffffffffffffffffff84165f908152600c602052604090205460ff16155b15612d7957600380547fffffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffff1674010000000000000000000000000000000000000000179055612d50613c09565b600380547fffffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffff1690555b6003545f9074010000000000000000000000000000000000000000900460ff16158015612dcb575073ffffffffffffffffffffffffffffffffffffffff86165f908152600c602052604090205460ff16155b8015612dfc575073ffffffffffffffffffffffffffffffffffffffff85165f908152600c602052604090205460ff16155b90505f8115612ebb5773ffffffffffffffffffffffffffffffffffffffff86165f908152600e602052604090205460ff1615612e53576064600b5486612e429190614018565b612e4c919061405c565b9050612e9d565b73ffffffffffffffffffffffffffffffffffffffff87165f908152600e602052604090205460ff1615612e9d576064600a5486612e909190614018565b612e9a919061405c565b90505b8015612eae57612eae8730836133ea565b612eb8818661436f565b94505b612ec68787876133ea565b50505050505050565b5f612ed9836122f5565b80549091506b0100000000000000000000009004600216151582151514612f3f57805460ff6b0100000000000000000000008083048216600218909116027fffffffffffffffffffffffffffffffffffffffff00ffffffffffffffffffffff9091161781555b8115155f528260601b60601c7fb5a1de456fff688115a4f75380060c23c8532d14ff85f687cc871456d642039360205fa2505050565b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffff748739275433146119fb576382b429005f526004601cfd5b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927805473ffffffffffffffffffffffffffffffffffffffff9092169182907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e05f80a355565b6040805160028082526060820183525f9260208301908036833701905050905030815f8151811061304257613042614382565b602002602001019073ffffffffffffffffffffffffffffffffffffffff16908173ffffffffffffffffffffffffffffffffffffffff16815250507f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663ad5c46486040518163ffffffff1660e01b8152600401602060405180830381865afa1580156130e5573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061310991906143af565b8160018151811061311c5761311c614382565b602002602001019073ffffffffffffffffffffffffffffffffffffffff16908173ffffffffffffffffffffffffffffffffffffffff1681525050613181307f0000000000000000000000000000000000000000000000000000000000000000846124a9565b6003546040517f791ac94700000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff7f000000000000000000000000000000000000000000000000000000000000000081169263791ac947926132029287925f928892919091169042906004016143ca565b5f604051808303815f87803b158015613219575f80fd5b505af115801561322b573d5f803e3d5ffd5b505050505050565b6060815f0361327557505060408051808201909152600181527f3000000000000000000000000000000000000000000000000000000000000000602082015290565b815f5b811561329e578061328881614455565b91506132979050600a8361405c565b9150613278565b5f8167ffffffffffffffff8111156132b8576132b8613ef5565b6040519080825280601f01601f1916602001820160405280156132e2576020820181803683370190505b5090505b8415613364576132f760018361436f565b9150613304600a8661406f565b61330f90603061435c565b60f81b81838151811061332457613324614382565b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff191690815f1a90535061335d600a8661405c565b94506132e6565b949350505050565b73ffffffffffffffffffffffffffffffffffffffff82165f818152600e602052604080822080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff001685151590811790915590519092917fffa9187bf1f18bf477bd0ea1bcbb64e93b6a98132473929edfce215cd9b16fab91a35050565b73ffffffffffffffffffffffffffffffffffffffff8216613437576040517fea553b3400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b68a20d6e21d0e52553085f61344b856122f5565b90505f613457856122f5565b90506134996040518061010001604052805f81526020015f81526020015f81526020015f81526020015f81526020015f81526020015f81526020015f81525090565b825470010000000000000000000000000000000080820463ffffffff908116608085015284548290041660a08401528554046bffffffffffffffffffffffff90811660c084015274010000000000000000000000000000000000000000909104166040820181905285111561353a576040517ff4d678b800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6040810180518690039081905283546bffffffffffffffffffffffff9182167401000000000000000000000000000000000000000090810273ffffffffffffffffffffffffffffffffffffffff9283161786558454818104841689016060860181905290931602911617825560808101516135da906135be670de0b6b3a764000090565b8360400151816135d0576135d061402f565b0480821191030290565b815281546b01000000000000000000000090046002165f0361366a578573ffffffffffffffffffffffffffffffffffffffff168773ffffffffffffffffffffffffffffffffffffffff160361363757805160808201510360a08201525b613664670de0b6b3a76400008260600151816136555761365561402f565b048260a0015180821191030290565b60208201525b80516020820151855463ffffffff6c010000000000000000000000008083048216840185900360e08701819052909116027fffffffffffffffffffffffffffffffff00000000ffffffffffffffffffffffff9091161786555f916136ce9101613c6c565b8554835191925060098701916801000000000000000090910463ffffffff1690156138ea5760608a901b60011760208401525f6137138560e001518660c00151613cb1565b73ffffffffffffffffffffffffffffffffffffffff8c165f90815260078a0160205260409020608087015187518a5463ffffffff918303918216700100000000000000000000000000000000027fffffffffffffffffffffffff00000000ffffffffffffffffffffffffffffffff909116178b5592935090915b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff91909101600381901c606084901b01549091905f90600584901b60e0161c63ffffffff1663ffffffff167fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8101600281901c60608a901b01805467ffffffffffffffff60069390931b60c01681811c9390931690921b9091189055905087516020808a0151600884901b17825201885284156138725760088c0160601b600387901c01805460e0600589901b1681811c841863ffffffff16901b1890556001909501945b600881901c60058d0160601b015460ff82161c600116156138dd5760058c0160601b600882901c018054600160ff84161b191690555f81815260048d016020526040902080547fffffffffffffffffffffffff00000000000000000000000000000000000000001690555b5080820361378d57505050505b602084015115613b5d57606089901b6020840152865473ffffffffffffffffffffffffffffffffffffffff8a165f9081526007890160209081526040822060a08801519188015164010000000090940463ffffffff16939092908201906139518a8f612386565b90505f670de0b6b3a76400008a60c001518161396f5761396f61402f565b8c547fffffffffffffffffffffffff00000000ffffffffffffffffffffffffffffffff1670010000000000000000000000000000000063ffffffff871602178d550490505b5f8715613a0d577fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff97909701600381901c60088f0160601b0154909790600589901b60e0161c63ffffffff1663ffffffff169050613a6b565b50855b613a3f897fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff830160011b610f1a565b63ffffffff1615613a5b57600101818111801590910217613a10565b6001810182811180159091021796505b606086901b600386901c01805460e0600588901b1681811c841863ffffffff16901b1890557fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8101600281901c60608b901b01805467ffffffffffffffff63ffffffff871660208a901b1760069490941b60c01682811c949094181690921b909118905560019094019389516020808c0151600884901b178252018a52508284036139b457600786018181118015909102178d5463ffffffff91909116640100000000027fffffffffffffffffffffffffffffffffffffffffffffffff00000000ffffffff909116178d555050505050505b60408301515115613bc75786547fffffffffffffffffffffffffffffffffffffffff00000000ffffffffffffffff166801000000000000000063ffffffff8316021787556001870154613bc790849073ffffffffffffffffffffffffffffffffffffffff16613cdd565b505050845f528560601b60601c8760601b60601c7fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef60205fa350505050505050565b305f90815268a20d6e21d0e525531260205260408120547401000000000000000000000000000000000000000090046bffffffffffffffffffffffff169050805f03613c525750565b6006548190811115613c6357506006545b61227d8161300f565b613c8e60405180606001604052805f81526020015f8152602001606081525090565b604051828152806020018360051b81016040528183604001528083525050919050565b5f806001613cc7670de0b6b3a76400008561405c565b901c905060808111818511161515949350505050565b60408201516040810363263c69d68152602080820152815160051b604401915060208183601c84015f875af1600182511416613d17575f81fd5b50505050565b5f5b83811015613d37578181015183820152602001613d1f565b50505f910152565b602081525f8251806020840152613d5d816040850160208701613d1d565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169190910160400192915050565b73ffffffffffffffffffffffffffffffffffffffff81168114611931575f80fd5b5f8060408385031215613dc1575f80fd5b8235613dcc81613d8f565b946020939093013593505050565b5f805f60608486031215613dec575f80fd5b8335613df781613d8f565b92506020840135613e0781613d8f565b929592945050506040919091013590565b5f60208284031215613e28575f80fd5b813561184281613d8f565b8015158114611931575f80fd5b5f60208284031215613e50575f80fd5b813561184281613e33565b5f8060408385031215613e6c575f80fd5b50508035926020909101359150565b5f8060408385031215613e8c575f80fd5b8235613e9781613d8f565b91506020830135613ea781613e33565b809150509250929050565b5f60208284031215613ec2575f80fd5b5035919050565b5f8060408385031215613eda575f80fd5b8235613ee581613d8f565b91506020830135613ea781613d8f565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b5f60208284031215613f32575f80fd5b813567ffffffffffffffff80821115613f49575f80fd5b818401915084601f830112613f5c575f80fd5b813581811115613f6e57613f6e613ef5565b604051601f82017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0908116603f01168101908382118183101715613fb457613fb4613ef5565b81604052828152876020848701011115613fcc575f80fd5b826020860160208301375f928101602001929092525095945050505050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b80820281158282048414176114a5576114a5613feb565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601260045260245ffd5b5f8261406a5761406a61402f565b500490565b5f8261407d5761407d61402f565b500690565b600181811c9082168061409657607f821691505b6020821081036140cd577f4e487b71000000000000000000000000000000000000000000000000000000005f52602260045260245ffd5b50919050565b5f8084546140e081614082565b600182811680156140f8576001811461412b57614157565b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0084168752821515830287019450614157565b885f526020805f205f5b8581101561414e5781548a820152908401908201614135565b50505082870194505b50505050835161416b818360208801613d1d565b7f2e6a736f6e0000000000000000000000000000000000000000000000000000009101908152600501949350505050565b5f602082840312156141ac575f80fd5b815161184281613e33565b5f805f606084860312156141c9575f80fd5b8351925060208401519150604084015190509250925092565b5f602082840312156141f2575f80fd5b5051919050565b601f821115611b1057805f5260205f20601f840160051c8101602085101561421e5750805b601f840160051c820191505b8181101561423d575f815560010161422a565b5050505050565b815167ffffffffffffffff81111561425e5761425e613ef5565b6142728161426c8454614082565b846141f9565b602080601f8311600181146142c4575f841561428e5750858301515b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600386901b1c1916600185901b17855561322b565b5f858152602081207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe08616915b82811015614310578886015182559484019460019091019084016142f1565b508582101561434c57878501517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600388901b60f8161c191681555b5050505050600190811b01905550565b808201808211156114a5576114a5613feb565b818103818111156114a5576114a5613feb565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603260045260245ffd5b5f602082840312156143bf575f80fd5b815161184281613d8f565b5f60a08201878352602087602085015260a0604085015281875180845260c0860191506020890193505f5b8181101561442757845173ffffffffffffffffffffffffffffffffffffffff16835293830193918301916001016143f5565b505073ffffffffffffffffffffffffffffffffffffffff969096166060850152505050608001529392505050565b5f7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff820361448557614485613feb565b506001019056fea2646970667358221220506acea61063a36f900932e493527f79c4cbed6c154bd9a491fe918c7c7b63b964736f6c63430008180033608060405234801561000f575f80fd5b50604051610e31380380610e3183398101604081905261002e9161005b565b683602298b8c10b0123180546001600160a01b0319166001600160a01b0392909216919091179055610088565b5f6020828403121561006b575f80fd5b81516001600160a01b0381168114610081575f80fd5b9392505050565b610d9c806100955f395ff3fe60806040526004361061012c575f3560e01c80636cef16e6116100a457806397e5311c11610073578063b88d4fde11610058578063b88d4fde1461054b578063c87b56dd1461056a578063e985e9c51461058957610133565b806397e5311c14610518578063a22cb4651461052c57610133565b80636cef16e61461049f57806370a08231146104b35780638da5cb5b146104d257806395d89b411461050457610133565b806318160ddd116100fb57806324359879116100e0578063243598791461044e57806342842e0e1461046d5780636352211e1461048057610133565b806318160ddd1461040d57806323b872dd1461042f57610133565b806301ffc9a71461033857806306fdde0314610389578063081812fc146103aa578063095ea7b3146103ee57610133565b3661013357005b683602298b8c10b012305f3560e01c63263c69d681900361021e57815473ffffffffffffffffffffffffffffffffffffffff16331461019e576040517f363cb31200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b602036103d5f3e6004356024018036103d5f3e602081033560051b81018036103d5f3e5b8082146102135781358060601c816001168260a01b60a81c811583028284027fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef5f38a45050508160200191506101c2565b505060015f5260205ff35b80630f4599e50361033657600182015473ffffffffffffffffffffffffffffffffffffffff16156102b457600182015473ffffffffffffffffffffffffffffffffffffffff1660043573ffffffffffffffffffffffffffffffffffffffff16146102b4576040517fc59ec47a00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b815473ffffffffffffffffffffffffffffffffffffffff1615610303576040517fbf656a4600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b81547fffffffffffffffffffffffff0000000000000000000000000000000000000000163317825560015f908152602090f35b005b348015610343575f80fd5b50610374610352366004610b00565b6301ffc9a760e09190911c9081146380ac58cd821417635b5e139f9091141790565b60405190151581526020015b60405180910390f35b348015610394575f80fd5b5061039d6105a8565b6040516103809190610b46565b3480156103b5575f80fd5b506103c96103c4366004610bb0565b6105bd565b60405173ffffffffffffffffffffffffffffffffffffffff9091168152602001610380565b3480156103f9575f80fd5b50610336610408366004610bef565b6105d3565b348015610418575f80fd5b50610421610653565b604051908152602001610380565b34801561043a575f80fd5b50610336610449366004610c17565b610663565b348015610459575f80fd5b506103c9610468366004610bb0565b6106ef565b61033661047b366004610c17565b6106ff565b34801561048b575f80fd5b506103c961049a366004610bb0565b610730565b3480156104aa575f80fd5b50610336610740565b3480156104be575f80fd5b506104216104cd366004610c50565b610821565b3480156104dd575f80fd5b50683602298b8c10b012325473ffffffffffffffffffffffffffffffffffffffff166103c9565b34801561050f575f80fd5b5061039d610847565b348015610523575f80fd5b506103c9610857565b348015610537575f80fd5b50610336610546366004610c69565b6108b2565b348015610556575f80fd5b50610336610565366004610ca2565b61092f565b348015610575575f80fd5b5061039d610584366004610bb0565b610989565b348015610594575f80fd5b506103746105a3366004610d35565b610999565b60606105b86306fdde035f6109de565b905090565b5f6105cd63081812fc835f610a34565b92915050565b5f6105dc610857565b90508260601b60601c925060405163d10b6e0c5f5283602052826040523360605260205f6064601c34865af1601f3d1116610619573d5f823e3d81fd5b80604052505f6060528183600c5160601c7f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9255f38a4505050565b5f6105b863e2c792815f80610a34565b5f61066c610857565b90508360601b60601c93508260601b60601c925060405163e5eb36c881528460208201528360408201528260608201523360808201526020816084601c840134865af16001825114166106c1573d5f823e3d81fd5b508183857fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef5f38a450505050565b5f6105cd6324359879835f610a34565b61070a838383610663565b813b1561072b5761072b83838360405180602001604052805f815250610a77565b505050565b5f6105cd636352211e835f610a34565b5f8061074a610857565b9050638da5cb5b5f5260205f6004601c845afa601f3d11161561077057600c5160601c91505b683602298b8c10b0123254683602298b8c10b012309073ffffffffffffffffffffffffffffffffffffffff908116908416811461081b576002820180547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff86811691821790925560405190918316907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0905f90a35b50505050565b5f6105cd63f5b100ea8373ffffffffffffffffffffffffffffffffffffffff165f610a34565b60606105b86395d89b415f6109de565b683602298b8c10b012305473ffffffffffffffffffffffffffffffffffffffff16806108af576040517f5b2a47ae00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b90565b5f6108bb610857565b90508260601b60601c925060405163813500fc5f52836020528215156040523360605260205f6064601c34865af160015f5114166108fb573d5f823e3d81fd5b83337f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c3160206040a360405250505f60605250565b61093a858585610663565b833b156109825761098285858585858080601f0160208091040260200160405190810160405280939291908181526020018383808284375f92019190915250610a7792505050565b5050505050565b60606105cd63c87b56dd836109de565b5f6109d563e985e9c58473ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff16610a34565b15159392505050565b60605f6109e9610857565b90506040519150835f52826020525f806024601c845afa610a0c573d5f833e3d82fd5b60205f803e60205f51833e815160205f5101602084013e815160208301016040525092915050565b5f80610a3e610857565b9050604051855f52846020528360405260205f6044601c855afa601f3d1116610a69573d5f823e3d81fd5b60405250505f519392505050565b60405163150b7a028082523360208301528560601b60601c604083015283606083015260808083015282518060a08401528015610abe578060c08401826020870160045afa505b60208360a48301601c86015f8a5af1610adf573d15610adf573d5f843e3d83fd5b508060e01b825114610af85763d1a57ed65f526004601cfd5b505050505050565b5f60208284031215610b10575f80fd5b81357fffffffff0000000000000000000000000000000000000000000000000000000081168114610b3f575f80fd5b9392505050565b5f602080835283518060208501525f5b81811015610b7257858101830151858201604001528201610b56565b505f6040828601015260407fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f8301168501019250505092915050565b5f60208284031215610bc0575f80fd5b5035919050565b803573ffffffffffffffffffffffffffffffffffffffff81168114610bea575f80fd5b919050565b5f8060408385031215610c00575f80fd5b610c0983610bc7565b946020939093013593505050565b5f805f60608486031215610c29575f80fd5b610c3284610bc7565b9250610c4060208501610bc7565b9150604084013590509250925092565b5f60208284031215610c60575f80fd5b610b3f82610bc7565b5f8060408385031215610c7a575f80fd5b610c8383610bc7565b915060208301358015158114610c97575f80fd5b809150509250929050565b5f805f805f60808688031215610cb6575f80fd5b610cbf86610bc7565b9450610ccd60208701610bc7565b935060408601359250606086013567ffffffffffffffff80821115610cf0575f80fd5b818801915088601f830112610d03575f80fd5b813581811115610d11575f80fd5b896020828501011115610d22575f80fd5b9699959850939650602001949392505050565b5f8060408385031215610d46575f80fd5b610d4f83610bc7565b9150610d5d60208401610bc7565b9050925092905056fea26469706673582212203dddf96112529cdfe05c6f175c689882e66380e34b6df96ef55f110412660d2e64736f6c6343000818003368747470733a2f2f6a7677677479676b337474366a67666176666c6e74766861686b73726b3670717a7a6e703465686175357965626a6733617a6a612e617277656176652e6e65742f54577870344d7263352d53596f4b6c57326454674f7155566566444f57763451344b6477514b5462426c492f
Deployed Bytecode
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
Deployed Bytecode Sourcemap
154113:11076:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;108134:20;139198:22;151437:20;139298:3;139275:26;139396:10;139382:24;;;139378:502;;139441:14;;;;;;139427:10;:28;139423:58;;139464:17;;;;;;;;;;;;;;139423:58;139518:4;139500:8;:22;139496:36;;;139524:8;;;139496:36;139594:4;151437:20;139659:4;151437:20;139708:4;151437:20;139778:4;151437:20;139802:41;151437:20;;;;139802:16;:41::i;:::-;139858:10;139866:1;139858:7;:10::i;:::-;139408:472;;;;139378:502;139949:10;139963;139949:24;139945:451;;140008:14;;;;;;139994:10;:28;139990:58;;140031:17;;;;;;;;;;;;;;139990:58;140085:4;140067:8;:22;140063:36;;;140091:8;;;140063:36;140164:4;151437:20;146785:4;146778:16;;;140289:4;151437:20;146815:4;146808:16;;;138926:36;146670:22;146838;;;146902:4;146886:21;;146997:18;;140214:4;151437:20;140200:24;;138921:89;;;;140374:10;140382:1;140374:7;:10::i;:::-;139975:421;;;139945:451;140459:10;140473;140459:24;140455:381;;140518:14;;;;;;140504:10;:28;140500:58;;140541:17;;;;;;;;;;;;;;140500:58;140595:4;140577:8;:22;140573:36;;;140601:8;;;140573:36;140743:4;151437:20;146785:4;146778:16;;;140672:4;151437:20;146815:4;146808:16;;;140780:19;;;140626:13;146838:22;;;146902:4;146886:21;;146997:18;;140775:48;;151437:20;;;140767:57;;:7;:57::i;:::-;140485:351;;140455:381;140882:10;140896;140882:24;140878:262;;140941:14;;;;;;140927:10;:28;140923:58;;140964:17;;;;;;;;;;;;;;140923:58;141018:4;141000:8;:22;140996:36;;;141024:8;;;140996:36;141076:4;151437:20;141098:30;141114:12;151437:20;141114:8;:12::i;:::-;141098:30;;:7;:30::i;:::-;140908:232;140878:262;141186:10;141200;141186:24;141182:262;;141245:14;;;;;;141231:10;:28;141227:58;;141268:17;;;;;;;;;;;;;;141227:58;141322:4;141304:8;:22;141300:36;;;141328:8;;;141300:36;141380:4;151437:20;141402:30;141418:12;151437:20;141418:8;:12::i;141402:30::-;141212:232;141182:262;141509:10;141523;141509:24;141505:427;;141568:14;;;;;;141554:10;:28;141550:58;;141591:17;;;;;;;;;;;;;;141550:58;141645:4;141627:8;:22;141623:36;;;141651:8;;;141623:36;141724:4;151437:20;141773:4;151437:20;141843:4;151437:20;141867:53;141883:35;151437:20;;;141883:11;:35::i;141867:53::-;141535:397;;;141505:427;141982:10;141996;141982:24;141978:266;;142041:14;;;;;;142027:10;:28;142023:58;;142064:17;;;;;;;;;;;;;;142023:58;142118:4;142100:8;:22;142096:36;;;142124:8;;;142096:36;142176:4;151437:20;142198:34;142214:16;151437:20;142214:12;:16::i;142198:34::-;142008:236;141978:266;142295:10;142309;142295:24;142291:282;;142354:14;;;;;;142340:10;:28;142336:58;;142377:17;;;;;;;;;;;;;;142336:58;142431:4;142413:8;:22;142409:36;;;142437:8;;;142409:36;142508:4;151437:20;142532:29;142540:20;151437;136708:37;;136681:7;136708:37;;;:30;:37;;;;;:49;;;;;;;;136612:153;142540:20;142532:7;:29::i;:::-;142321:252;142291:282;142619:10;142633;142619:24;142615:209;;142678:14;;;;;;142664:10;:28;142660:58;;142701:17;;;;;;;;;;;;;;142660:58;142755:4;142737:8;:22;142733:36;;;142761:8;;;142733:36;108134:20;136520:33;142786:26;;136520:33;;;;;142532:7;:29::i;142786:26::-;142871:10;142885;142871:24;142867:67;;142912:10;142920:1;142912:7;:10::i;:::-;139187:3766;157648:92;;;;;;;;;;-1:-1:-1;157727:5:0;;;;;;;;;;;;;;;;;157648:92;;;;;;;:::i;:::-;;;;;;;;112924:158;;;;;;;;;;-1:-1:-1;112924:158:0;;;;;:::i;:::-;;:::i;:::-;;;1373:14:1;;1366:22;1348:41;;1336:2;1321:18;112924:158:0;1208:187:1;111935:126:0;;;;;;;;;;-1:-1:-1;108134:20:0;112022:30;;;;;;111935:126;;;1546:25:1;;;1534:2;1519:18;111935:126:0;1400:177:1;114442:709:0;;;;;;;;;;-1:-1:-1;114442:709:0;;;;;:::i;:::-;;:::i;74982:618::-;;;:::i;133333:294::-;;;;;;;;;;-1:-1:-1;133333:294:0;;;;;:::i;:::-;;:::i;133754:137::-;;;;;;;;;;-1:-1:-1;133754:137:0;;;;;:::i;:::-;;:::i;155205:26::-;;;;;;;;;;;;;;;;154731:59;;;;;;;;;;;;;;;;111794:76;;;;;;;;;;-1:-1:-1;111794:76:0;;111860:2;2806:36:1;;2794:2;2779:18;111794:76:0;2664:184:1;155173:25:0;;;;;;;;;;;;;;;;154472:38;;;;;;;;;;;;;;;;;;3029:42:1;3017:55;;;2999:74;;2987:2;2972:18;154472:38:0;2853:226:1;163508:227:0;;;;;;;;;;;;;:::i;136264:119::-;;;;;;;;;;-1:-1:-1;136344:31:0;;;;136264:119;;159841:126;;;;;;;;;;-1:-1:-1;159841:126:0;;;;;:::i;:::-;159931:28;;159907:4;159931:28;;;:19;:28;;;;;;;;;159841:126;164645:134;;;;;;;;;;-1:-1:-1;164645:134:0;;;;;:::i;:::-;;:::i;75685:458::-;;;:::i;154411:52::-;;;;;;;;;;;;;;;154685:39;;;;;;;;;;;;;;;;164472:165;;;;;;;;;;-1:-1:-1;164472:165:0;;;;;:::i;:::-;;:::i;155133:31::-;;;;;;;;;;-1:-1:-1;155133:31:0;;;;;;;;;;;112130:143;;;;;;;;;;-1:-1:-1;112130:143:0;;;;;:::i;:::-;112220:37;;112193:7;112220:37;;;:30;:37;;;;;:45;;;;;;;112130:143;74717:102;;;:::i;159305:144::-;;;;;;;;;;-1:-1:-1;159305:144:0;;;;;:::i;:::-;;:::i;77390:187::-;;;;;;;;;;-1:-1:-1;77547:11:0;77541:18;77390:187;;157748:96;;;;;;;;;;-1:-1:-1;157829:7:0;;;;;;;;;;;;;;;;;157748:96;;113595:150;;;;;;;;;;-1:-1:-1;113595:150:0;;;;;:::i;:::-;;:::i;164037:153::-;;;;;;;;;;-1:-1:-1;164037:153:0;;;;;:::i;:::-;;:::i;164198:266::-;;;;;;;;;;-1:-1:-1;164198:266:0;;;;;:::i;:::-;;:::i;159457:182::-;;;;;;;;;;-1:-1:-1;159457:182:0;;;;;:::i;:::-;;:::i;163289:211::-;;;;;;;;;;-1:-1:-1;163289:211:0;;;;;:::i;:::-;;:::i;157966:184::-;;;;;;;;;;-1:-1:-1;157966:184:0;;;;;:::i;:::-;;:::i;155039:47::-;;;;;;;;;;;;;;;;158338:959;;;;;;;;;;;;;:::i;154254:148::-;;;;;;;;;;;;;:::i;112371:417::-;;;;;;;;;;-1:-1:-1;112371:417:0;;;;;:::i;:::-;146785:4;146778:16;;;146815:4;146808:16;;;;112729:28;146670:22;146838;;;146902:4;146886:21;;146997:18;;112724:56;;112371:417;163743:286;;;;;;;;;;-1:-1:-1;163743:286:0;;;;;:::i;:::-;;:::i;157852:106::-;;;;;;;;;;-1:-1:-1;157852:106:0;;;;;:::i;:::-;;:::i;154837:65::-;;;;;;;;;;;;;;;;76334:712;;;;;;:::i;:::-;;:::i;74291:358::-;;;;;;:::i;:::-;;:::i;154975:57::-;;;;;;;;;;;;;;;;77683:425;;;;;;;;;;-1:-1:-1;77683:425:0;;;;;:::i;:::-;77942:19;77936:4;77929:33;;;77790:14;77976:26;;;;78084:4;78068:21;;78062:28;;77683:425;155095:31;;;;;;;;;;-1:-1:-1;155095:31:0;;;;;;;;128578:2238;108134:20;128764:16;;;128760:52;;128789:23;;;;;;;;;;;;;;128760:52;128848:4;;;128877:16;;;128825:20;128894:29;128848:4;143556:5;;;143566:1;143555:12;128903:19;144001:13;144134:5;144131:1;144127:13;144116:8;144112:2;144108:17;144104:37;144231:1;144225:8;144220:1;144213:5;144209:13;144206:1;144202:21;144198:36;144186:10;144182:53;144172:63;;;143926:327;;;;;128894:29;128877:47;;;;;;;;;;;;;-1:-1:-1;128877:47:0;;;128869:55;;;128877:47;;128869:55;128865:123;;128948:28;;;;;;;;;;;;;;128865:123;129017:4;129004:17;;:9;:17;;;129000:264;;146785:4;146778:16;;;146815:4;146808:16;;;129047:19;;;146670:22;146838;;;146902:4;146886:21;;146997:18;;129042:48;;:53;129038:215;;129133:18;;;;:14;;;:18;;;;;;;129120:31;;;129133:18;;129120:31;129116:122;;129183:35;;;;;;;;;;;;;;129116:122;129276:35;129314:18;129327:4;129314:12;:18::i;:::-;129276:56;;129343:33;129379:16;129392:2;129379:12;:16::i;:::-;129509:23;;129343:52;;-1:-1:-1;110771:8:0;;129509:23;;;;;129555:18;;;129551:52;;;129582:21;;;;;;;;;;;;;;129551:52;129622;;;129655:18;;;;129622:52;;;;;;;;;;;;;129693:37;;;;;;;;;;;;;;;;;;;;;;129858:11;;129622:23;129858:11;;;129806:7;;;129858:11;;;;;;;;129890:30;129895:20;;;129917:2;145867;145863:20;;;;145889:1;145885:13;;;145859:40;145969:8;145944:1;145955:4;145951:16;;;145947:31;145940:39;;145683:314;129890:30;129886:152;;;129946:20;;;146239:2;146235:20;146261:1;146257:13;;;146231:40;146389:8;;146430:13;146315:4;146311:16;;146403:9;146399:14;146385:29;146372:75;;130004:18;;;;:14;;;:18;;;;;129997:25;;;;;;129886:152;130108:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;144112:2;144108:17;;;144127:13;144131:1;144127:13;;;;144104:37;144225:8;-1:-1:-1;;144202:21:0;144206:1;144202:21;;;;;144198:36;144182:53;130073:65;-1:-1:-1;130157:8:0;130168:25;130173:2;143785:5;;;143795:1;143784:12;;;143783:18;130177:15;143676:182;130168:25;144492:2;144488:17;;;144507:13;144511:1;144507:13;;;;144484:37;144636:8;;144561:21;144565:1;144561:21;;;;144764:9;;;144760:21;;130212:29;144753;144746:37;;144739:45;144729:56;;130157:36;-1:-1:-1;130260:35:0;130265:2;143785:5;130269:22;;;143785:5;143795:1;143784:12;;;143783:18;130293:1;144514:5;144511:1;144507:13;144496:8;144492:2;144488:17;144484:37;144579:1;144572:5;144568:13;144565:1;144561:21;144642:1;144636:8;144690:10;144775:5;144771:1;144768;144764:9;144760:21;144757:1;144753:29;144750:1;144746:37;144743:1;144739:45;144736:1;144729:56;;;;;144321:482;;;;130260:35;-1:-1:-1;;130336:27:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;130383:9;;;-1:-1:-1;130383:9:0;;;;;;;;;;144492:2;144488:17;144507:13;144511:1;144507:13;;;;144484:37;144636:8;;144561:21;144565:1;144561:21;;;;;;;;144764:9;;;144760:21;;144753:29;;;144746:37;;;144739:45;144729:56;;130423:83;130451:2;130455;130459:43;130484:13;130499:2;130459:24;:43::i;:::-;130504:1;145133;145129:2;145125:10;145227:1;145224;145220:9;145209:8;145205:2;145201:17;145197:33;145284:1;145281;145277:9;145274:1;145270:17;145261:26;;145347:1;145341:8;145395:18;145498:9;145486:10;145482:26;145469:10;145465:2;145461:19;145458:51;145569:8;145565:1;145562;145558:9;145554:24;145551:1;145547:32;145544:1;145540:40;145537:1;145533:48;145530:1;145523:59;;;;;;144876:724;;;;;130423:83;129443:1075;;;130650:4;130644;130637:18;130793:2;130789;130785:11;130781:2;130777:20;130769:4;130765:2;130761:13;130757:2;130753:22;130726:25;130720:4;130714;130709:89;130583:226;;;;;128578:2238;;;;:::o;151568:185::-;151701:1;151695:4;151688:15;151730:4;151724;151717:18;137224:163;137285:7;137310:11;137318:2;137310:7;:11::i;:::-;137305:44;;137330:19;;;;;;;;;;;;;;137305:44;137367:12;137376:2;137367:8;:12::i;:::-;137360:19;137224:163;-1:-1:-1;;137224:163:0:o;136904:199::-;136965:7;108134:20;137046:16;136965:7;137063:31;137068:4;143556:5;;;143566:1;143555:12;137074:19;143444:180;137063:31;137046:49;;;;;;;;;;;;;-1:-1:-1;137046:49:0;;;;;136904:199;-1:-1:-1;;;136904:199:0:o;138106:566::-;138216:13;108134:20;138311:16;138216:13;138328:31;138333:4;143556:5;;;143566:1;143555:12;138339:19;143444:180;138328:31;138311:49;;;;;;;;;;;;;-1:-1:-1;138311:49:0;;;;;;;-1:-1:-1;138377:18:0;;;;138373:187;;146785:4;146778:16;;;146815:4;146808:16;;;138421:19;;;146670:22;146838;;;146902:4;146886:21;;146997:18;;138416:49;;:54;138412:137;;138498:35;;;;;;;;;;;;;;138412:137;138572:18;;;;:14;;;:18;;;;;:28;;;;;;;;;;;;;138616:20;;;146239:2;146235:20;146261:1;146257:13;;;146231:40;146389:8;;-1:-1:-1;146315:4:0;146311:16;;146403:9;;;146399:14;146385:29;;;;138642:21;;;146416:29;;146382:64;;;;146372:75;;138236:436;138106:566;;;;;:::o;137696:190::-;137761:7;137786:11;137794:2;137786:7;:11::i;:::-;137781:44;;137806:19;;;;;;;;;;;;;;137781:44;-1:-1:-1;137843:35:0;;;;:31;:35;;;;;;;;;137696:190::o;112924:158::-;112998:4;113015:37;113024:10;113036:7;113045:6;113015:8;:37::i;:::-;-1:-1:-1;113070:4:0;112924:158;;;;:::o;114442:709::-;114611:10;146785:4;146778:16;;;146815:4;146808:16;;;114575:28;114530:4;146838:22;;;146902:4;146886:21;;146997:18;;;;114866:7;;114530:4;;146886:21;114901:17;114890:28;;114886:198;;114948:7;114939:6;:16;114935:52;;;114964:23;;;;;;;;;;;;;;114935:52;115041:16;;;115031:26;;114886:198;115094:27;115104:4;115110:2;115114:6;115094:9;:27::i;:::-;-1:-1:-1;115139:4:0;;114442:709;-1:-1:-1;;;;;114442:709:0:o;74982:618::-;75077:15;73907:9;75095:46;;:15;:46;75077:64;;75305:19;75299:4;75292:33;75356:8;75350:4;75343:22;75413:7;75406:4;75400;75390:21;75383:38;75558:8;75511:45;75508:1;75505;75500:67;75209:373;74982:618::o;133333:294::-;133438:37;;;133397:4;133438:37;;;:30;:37;;;;;133490:7;;;;;104431:6;133490:40;:45;;133486:73;;151147:14;;133544:15;133537:22;133333:294;-1:-1:-1;;;133333:294:0:o;133486:73::-;133577:7;;;;104568:6;133577:37;:42;;;133333:294;-1:-1:-1;;133333:294:0:o;133754:137::-;133812:4;133829:32;133841:10;133853:7;133829:11;:32::i;:::-;-1:-1:-1;133879:4:0;;133754:137;-1:-1:-1;133754:137:0:o;163508:227::-;163588:1;163564:21;:25;163556:60;;;;;;;5935:2:1;163556:60:0;;;5917:21:1;5974:2;5954:18;;;5947:30;6013:24;5993:18;;;5986:52;6055:18;;163556:60:0;;;;;;;;;163649:15;;;;163635:10;:29;163627:38;;;;;;163676:51;;163684:10;;163705:21;163676:51;;;;;;;;;163705:21;163684:10;163676:51;;;;;;;;;;;;;;;;;;;;;163508:227::o;164645:134::-;78505:13;:11;:13::i;:::-;164726:6:::1;:16:::0;;;;164753:7:::1;:18:::0;164645:134::o;75685:458::-;75887:19;75881:4;75874:33;75934:8;75928:4;75921:22;75987:1;75980:4;75974;75964:21;75957:32;76116:8;76070:44;76067:1;76064;76059:66;75685:458::o;164472:165::-;164568:15;;;;164554:10;:29;164546:38;;;;;;164595:15;:34;;;;;;;;;;;;;;;164472:165::o;74717:102::-;78505:13;:11;:13::i;:::-;74790:21:::1;74808:1;74790:9;:21::i;:::-;74717:102::o:0;159305:144::-;78505:13;:11;:13::i;:::-;159395:39:::1;::::0;;;::::1;;::::0;;;:31:::1;:39;::::0;;;;:46;;;::::1;::::0;::::1;;::::0;;;::::1;::::0;;159305:144::o;113595:150::-;113665:4;113682:33;113692:10;113704:2;113708:6;113682:9;:33::i;164037:153::-;164127:15;;;;164113:10;:29;164105:38;;;;;;164154:18;:28;164037:153::o;164198:266::-;164277:15;;;;164263:10;:29;164255:38;;;;;;164348:4;164304:23;112220:37;;;:30;:37;;;;;:45;;;;;;;164414:3;164386:25;164404:7;112220:45;164386:25;:::i;:::-;:31;;;;:::i;:::-;164365:52;;164428:28;164445:10;164428:16;:28::i;:::-;164244:220;;164198:266;:::o;159457:182::-;78505:13;:11;:13::i;:::-;159542:28:::1;::::0;::::1;;::::0;;;:19:::1;:28;::::0;;;;;;;;:39;;;::::1;::::0;::::1;;::::0;;::::1;::::0;;;159597:34;;1348:41:1;;;159597:34:0::1;::::0;1321:18:1;159597:34:0::1;;;;;;;159457:182:::0;;:::o;163289:211::-;78505:13;:11;:13::i;:::-;163412:34:::1;:21:::0;163437:8:::1;163412:34;:::i;:::-;163389:20;:57:::0;163469:23:::1;:10:::0;163483:8:::1;163469:23;:::i;:::-;163457:9;:35:::0;-1:-1:-1;;163289:211:0:o;157966:184::-;158026:13;158083:12;158097:34;158103:16;;158098:2;:21;;;;:::i;:::-;158097:32;:34::i;:::-;158066:75;;;;;;;;;:::i;:::-;;;;;;;;;;;;;158052:90;;157966:184;;;:::o;158338:959::-;78505:13;:11;:13::i;:::-;158402:11:::1;::::0;::::1;;158401:12;158393:47;;;::::0;::::1;::::0;;8898:2:1;158393:47:0::1;::::0;::::1;8880:21:1::0;8937:2;8917:18;;;8910:30;8976:25;8956:18;;;8949:53;9019:18;;158393:47:0::1;8696:347:1::0;158393:47:0::1;158641:55;158675:13;158691:4;158641:25;:55::i;:::-;158707:58;158744:13;158760:4;158707:28;:58::i;:::-;158778:66;158795:4;158810:16;158829:14;158778:8;:66::i;:::-;158922:72;::::0;;;;:29:::1;158960:16;9240:55:1::0;;158922:72:0::1;::::0;::::1;9222:74:1::0;158979:14:0::1;9312:18:1::0;;;9305:34;158929:13:0::1;158922:29;::::0;::::1;::::0;9195:18:1;;158922:72:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;159092:4:0::1;112193:7:::0;112220:37;;;:30;:37;;;;;:45;159007:32:::1;:16;:32;::::0;::::1;::::0;159047:21:::1;::::0;159092:4;112220:45;;;;;159151:1:::1;159167::::0;159183:7:::1;77547:11:::0;77541:18;;77390:187;159183:7:::1;159007:224;::::0;::::1;::::0;;;;;;;9913:42:1;9982:15;;;159007:224:0::1;::::0;::::1;9964:34:1::0;10014:18;;;10007:34;;;;10057:18;;;10050:34;;;;10100:18;;;10093:34;10164:15;;;10143:19;;;10136:44;159205:15:0::1;10196:19:1::0;;;10189:35;9875:19;;159007:224:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;159242:11:0::1;:18:::0;;159271;;;;;;-1:-1:-1;158338:959:0:o;154254:148::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;163743:286::-;163827:15;;;;163813:10;:29;163805:38;;;;;;163862:41;;;;;163897:4;163862:41;;;2999:74:1;163906:1:0;;163862:26;;;;;;2972:18:1;;163862:41:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:45;163854:74;;;;;;;10937:2:1;163854:74:0;;;10919:21:1;10976:2;10956:18;;;10949:30;11015:18;10995;;;10988:46;11051:18;;163854:74:0;10735:340:1;163854:74:0;163979:41;;;;;164014:4;163979:41;;;2999:74:1;163941:25:0;;;;;;163967:10;;163941:25;;163979:26;;2972:18:1;;163979:41:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;163941:80;;;;;;;;;;9252:42:1;9240:55;;;163941:80:0;;;9222:74:1;9312:18;;;9305:34;9195:18;;163941:80:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;163743:286;:::o;157852:106::-;78505:13;:11;:13::i;:::-;157926:12:::1;:24;157941:9:::0;157926:12;:24:::1;:::i;76334:712::-:0;78505:13;:11;:13::i;:::-;76568:19:::1;76562:4;76555:33;76615:12;76609:4;76602:26;76678:4;76672;76662:21;76782:12;76776:19;76763:11;76760:36;76757:160;;;76829:10;76823:4;76816:24;76897:4;76891;76884:18;76757:160;76992:1;76971:23:::0;;77015::::1;77025:12:::0;77015:9:::1;:23::i;74291:358::-:0;78505:13;:11;:13::i;:::-;74466:8:::1;74462:2;74458:17;74448:153;;74509:10;74503:4;74496:24;74581:4;74575;74568:18;74448:153;74622:19;74632:8;74622:9;:19::i;134768:428::-:0;134869:37;;;134831:21;134869:37;;;:30;:37;;;;;134946:7;;134869:37;;134946:7;;;;104431:6;134946:40;:45;;134942:236;;135105:57;;;;;135121:40;151147:14;;148093:9;148086:17;104568:6;135031:54;104431:6;135121:40;135105:57;;;;;134942:236;134768:428;;;:::o;135362:560::-;135590:26;;;;;;;108134:20;135484:19;135631:17;;;135627:288;;135709:14;;;;;;;;;;;;;;;;;;;135753:41;;;;;;;;;;-1:-1:-1;135809:30:0;;;:16;;;:30;;;;;:35;;;;;;;;;;135709:14;;-1:-1:-1;135863:17:0;;135859:31;;135882:8;;;135859:31;135510:412;135362:560;;;;:::o;137439:118::-;137499:4;;137523:12;137532:2;137523:8;:12::i;:::-;:26;;;;;137439:118;-1:-1:-1;;137439:118:0:o;131226:650::-;146785:4;146778:16;;;146815:4;146808:16;;;131511:28;146670:22;146838;;;146902:4;146886:21;;146997:18;;131565:6;;131506:65;:56;131689:20;;;131832:25;;;;;131807:23;;;;131780:25;;131774:4;;131763:95;131226:650;;;:::o;159975:2822::-;160073:18;;;160065:68;;;;;;;13505:2:1;160065:68:0;;;13487:21:1;13544:2;13524:18;;;13517:30;13583:34;13563:18;;;13556:62;13654:7;13634:18;;;13627:35;13679:19;;160065:68:0;13303:401:1;160065:68:0;160152:16;;;160144:64;;;;;;;13911:2:1;160144:64:0;;;13893:21:1;13950:2;13930:18;;;13923:30;13989:34;13969:18;;;13962:62;14060:5;14040:18;;;14033:33;14083:19;;160144:64:0;13709:399:1;160144:64:0;160225:6;160235:1;160225:11;160221:79;;160260:28;160276:4;160282:2;160286:1;160260:15;:28::i;160221:79::-;77547:11;77541:18;160316:15;;:4;:15;;;;:32;;;;-1:-1:-1;77547:11:0;77541:18;160335:13;;:2;:13;;;;160316:32;:52;;;;-1:-1:-1;160352:16:0;;;;;160316:52;:77;;;;-1:-1:-1;160372:21:0;;;160386:6;160372:21;;160316:77;:90;;;;-1:-1:-1;160398:8:0;;;;;;;160397:9;160316:90;160312:1292;;;160528:11;;;;160523:140;;160568:25;;;;;;;:19;:25;;;;;;;;;:52;;-1:-1:-1;160597:23:0;;;;;;;:19;:23;;;;;;;;160568:52;160560:87;;;;;;;14315:2:1;160560:87:0;;;14297:21:1;14354:2;14334:18;;;14327:30;14393:24;14373:18;;;14366:52;14435:18;;160560:87:0;14113:346:1;160560:87:0;160736:31;;;;;;;:25;:31;;;;;;;;:71;;;;-1:-1:-1;160772:35:0;;;;;;;:31;:35;;;;;;;;160771:36;160736:71;160732:861;;;160846:20;;160836:6;:30;;160828:96;;;;;;;14666:2:1;160828:96:0;;;14648:21:1;14705:2;14685:18;;;14678:30;14744:34;14724:18;;;14717:62;14815:23;14795:18;;;14788:51;14856:19;;160828:96:0;14464:417:1;160828:96:0;160977:9;;112220:37;;;112193:7;112220:37;;;:30;:37;;;;;:45;;;;;;160951:22;;:6;:22;:::i;:::-;:35;;160943:67;;;;;;;15218:2:1;160943:67:0;;;15200:21:1;15257:2;15237:18;;;15230:30;15296:21;15276:18;;;15269:49;15335:18;;160943:67:0;15016:343:1;160943:67:0;160732:861;;;161167:29;;;;;;;:25;:29;;;;;;;;:71;;;;-1:-1:-1;161201:37:0;;;;;;;:31;:37;;;;;;;;161200:38;161167:71;161163:430;;;161277:20;;161267:6;:30;;161259:97;;;;;;;15566:2:1;161259:97:0;;;15548:21:1;15605:2;15585:18;;;15578:30;15644:34;15624:18;;;15617:62;15715:24;15695:18;;;15688:52;15757:19;;161259:97:0;15364:418:1;161163:430:0;161454:35;;;;;;;:31;:35;;;;;;;;161449:144;;161544:9;;112220:37;;;112193:7;112220:37;;;:30;:37;;;;;:45;;;;;;161518:22;;:6;:22;:::i;:::-;:35;;161510:67;;;;;;;15218:2:1;161510:67:0;;;15200:21:1;15257:2;15237:18;;;15230:30;15296:21;15276:18;;;15269:49;15335:18;;161510:67:0;15016:343:1;161510:67:0;161712:4;161663:28;112220:37;;;:30;:37;;;;;:45;;;;;;161767:18;;161663:55;;-1:-1:-1;161744:41:0;;;161800:22;;;;-1:-1:-1;161811:11:0;;;;;;;161800:22;:35;;;;-1:-1:-1;161827:8:0;;;;;;;161826:9;161800:35;:71;;;;-1:-1:-1;161840:31:0;;;;;;;:25;:31;;;;;;;;161839:32;161800:71;:101;;;;-1:-1:-1;161876:25:0;;;;;;;:19;:25;;;;;;;;161875:26;161800:101;:129;;;;-1:-1:-1;161906:23:0;;;;;;;:19;:23;;;;;;;;161905:24;161800:129;161796:233;;;161946:8;:15;;;;;;;;161976:10;:8;:10::i;:::-;162001:8;:16;;;;;;161796:233;162151:8;;162135:12;;162151:8;;;;;162150:9;:39;;;;-1:-1:-1;162164:25:0;;;;;;;:19;:25;;;;;;;;162163:26;162150:39;:67;;;;-1:-1:-1;162194:23:0;;;;;;;:19;:23;;;;;;;;162193:24;162150:67;162135:82;;162230:12;162261:7;162257:489;;;162334:29;;;;;;;:25;:29;;;;;;;;162330:267;;;162410:3;162400:7;;162391:6;:16;;;;:::i;:::-;:22;;;;:::i;:::-;162384:29;;162330:267;;;162501:31;;;;;;;:25;:31;;;;;;;;162498:99;;;162578:3;162569:6;;162560;:15;;;;:::i;:::-;:21;;;;:::i;:::-;162553:28;;162498:99;162619:8;;162615:91;;162648:42;162664:4;162678;162685;162648:15;:42::i;:::-;162720:14;162730:4;162720:14;;:::i;:::-;;;162257:489;162756:33;162772:4;162778:2;162782:6;162756:15;:33::i;:::-;160054:2743;;;;159975:2822;;;:::o;134118:471::-;134194:21;134218:19;134231:5;134218:12;:19::i;:::-;134253:7;;134194:43;;-1:-1:-1;134253:7:0;;;104568:6;134253:37;:42;;134252:53;;;;134248:124;;134322:38;;;;;;;;;104568:6;134322:38;;;;;;;;;;;;134248:124;134477:5;134470:13;134463:21;134457:4;134450:35;134563:5;134559:2;134555:14;134551:2;134547:23;134516:29;134510:4;134504;134499:72;134435:147;134118:471;;:::o;73216:360::-;73428:11;73422:18;73412:8;73409:32;73399:159;;73475:10;73469:4;73462:24;73538:4;73532;73525:18;72066:1089;72781:11;73013:16;;72863:26;;;;;;;72973:38;72970:1;;72962:78;73095:27;72066:1089::o;162805:476::-;162895:16;;;162909:1;162895:16;;;;;;;;162871:21;;162895:16;;;;;;;;;;-1:-1:-1;162895:16:0;162871:40;;162940:4;162922;162927:1;162922:7;;;;;;;;:::i;:::-;;;;;;:23;;;;;;;;;;;162966:16;:21;;;:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;162956:4;162961:1;162956:7;;;;;;;;:::i;:::-;;;;;;:33;;;;;;;;;;;163000:63;163017:4;163032:16;163051:11;163000:8;:63::i;:::-;163217:15;;163074:199;;;;;:67;:16;:67;;;;;:199;;163156:11;;163182:1;;163198:4;;163217:15;;;;;163247;;163074:199;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;162860:421;162805:476;:::o;152646:723::-;152702:13;152923:5;152932:1;152923:10;152919:53;;-1:-1:-1;;152950:10:0;;;;;;;;;;;;;;;;;;152646:723::o;152919:53::-;152997:5;152982:12;153038:78;153045:9;;153038:78;;153071:8;;;;:::i;:::-;;-1:-1:-1;153094:10:0;;-1:-1:-1;153102:2:0;153094:10;;:::i;:::-;;;153038:78;;;153126:19;153158:6;153148:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;153148:17:0;;153126:39;;153176:154;153183:10;;153176:154;;153210:11;153220:1;153210:11;;:::i;:::-;;-1:-1:-1;153279:10:0;153287:2;153279:5;:10;:::i;:::-;153266:24;;:2;:24;:::i;:::-;153253:39;;153236:6;153243;153236:14;;;;;;;;:::i;:::-;;;;:56;;;;;;;;;;-1:-1:-1;153307:11:0;153316:2;153307:11;;:::i;:::-;;;153176:154;;;153354:6;152646:723;-1:-1:-1;;;;152646:723:0:o;159647:186::-;159730:31;;;;;;;:25;:31;;;;;;:39;;;;;;;;;;;;;159785:40;;159730:39;;:31;159785:40;;;159647:186;;:::o;123132:4553::-;123225:16;;;123221:52;;123250:23;;;;;;;;;;;;;;123221:52;108134:20;123286:22;123380:18;123393:4;123380:12;:18::i;:::-;123342:56;;123409:33;123445:16;123458:2;123445:12;:16::i;:::-;123409:52;;123474:23;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;123474:23:0;123528:27;;;;;;;;;;123508:17;;;:47;123584:25;;;;;;123566:15;;;:43;123636:13;;;;;;;123620;;;:29;123692:23;;;;;123676:13;;;:39;;;123666:50;;123662:84;;;123725:21;;;;;;;;;;;;;;123662:84;123817:13;;;:23;;;;;;;;;123784:57;;;;;;;;;;;;;;;;;123909:21;;;;;;;123901:39;;123887:11;;;:53;;;123856:85;;;;;;;;;123988:17;;;;123974:57;;124023:7;110771:8;;110696:91;124023:7;124007:1;:13;;;:23;;;;;:::i;:::-;;147852:8;;;147862:9;;147848:24;;147685:205;123974:57;123958:73;;124052:19;;;;;104568:6;124052:49;123958:13;124052:54;124048:250;;124139:2;124131:10;;:4;:10;;;124127:67;;124181:13;;124161:17;;;;:33;124143:15;;;:51;124127:67;124229:53;110771:8;124243:1;:11;;;:21;;;;;:::i;:::-;;124266:1;:15;;;147852:8;;;147862:9;;147848:24;;147685:205;124229:53;124213:13;;;:69;124048:250;124377:13;;124361;;;;124341:16;;;;;;;;;124333:41;;:57;;;124314:16;;;:76;;;124405:43;;;;;;;;;;;124377:13;;124497:48;;124515:29;124497:17;:48::i;:::-;124629:16;;124664:13;;124465:80;;-1:-1:-1;124583:4:0;;;;124629:16;;;;;;;124664:18;124660:1055;;149370:2;149366:10;;;124736:1;149363:23;149356:4;149349:12;;149342:45;124757:20;124780:49;124797:1;:16;;;124815:1;:13;;;124780:16;:49::i;:::-;124878:13;;;124848:27;124878:13;;;:7;;;:13;;;;;124930:17;;;;124996:13;;125028:45;;;124984:25;;;125028:45;;;;;;;;;;;;124757:72;;-1:-1:-1;124878:13:0;;125123:577;125178:11;;;;;144131:1;144127:13;;;144112:2;144108:17;;;144104:37;144225:8;125178:11;;-1:-1:-1;125149:10:0;;144206:1;144202:21;;;;;144198:36;144186:10;144182:53;125149:41;;145125:10;;;145224:1;145220:9;;;145205:2;145201:17;;;145197:33;145341:8;;145395:18;145274:1;145270:17;;;;;;145558:9;;;145547:32;;;;145540:40;;;145533:48;;;145523:59;;125149:41;-1:-1:-1;149667:8:0;;149720:4;149713:12;;;149707:19;149732:1;149728:10;;;149704:35;149689:51;;149798:17;149788:28;;125337:15;125333:120;;;125386:12;;;144492:2;144488:17;144511:1;144507:13;;;144484:37;144636:8;;144561:21;144565:1;144561:21;;;;144764:9;;;144760:21;;144690:10;144753:29;144746:37;;144739:45;144729:56;;125400:16;;;;;125381:48;145889:1;145885:13;;;125484:20;;;145867:2;145863:20;145859:40;145969:8;145955:4;145951:16;;145947:31;145944:1;145940:39;125475:176;;;125543:20;;;146239:2;146235:20;146261:1;146257:13;;;146231:40;146389:8;;146430:13;146315:4;146311:16;;146403:9;146399:14;146385:29;146372:75;;125609:18;;;;:14;;;:18;;;;;125602:25;;;;;;125475:176;125126:544;125691:7;125678:9;:20;125123:577;;124684:1031;;;;124660:1055;125735:13;;;;:18;125731:1458;;149370:2;149366:10;;;149356:4;149349:12;;149342:45;125848:13;;125908:11;;;125826:19;125908:11;;;:7;;;:11;;;;;;;125956:15;;;;126016:13;;;;125848;;;;;;;125908:11;;126006:23;;;;126065:43;126090:13;125908:11;126065:24;:43::i;:::-;126048:60;-1:-1:-1;126127:16:0;110771:8;126146:1;:13;;;:23;;;;;:::i;:::-;126188:41;;;;;;;;;;;;126146:23;;-1:-1:-1;126279:723:0;126305:10;126342:19;;126338:420;;126414:16;;;;;144131:1;144127:13;;;126400:12;;;144112:2;144108:17;144104:37;144225:8;126414:16;;-1:-1:-1;144206:1:0;144202:21;;;;;144198:36;144186:10;144182:53;126390:41;;;;126338:420;;;-1:-1:-1;126493:11:0;126531:135;126538:29;126543:2;143556:5;;;143566:1;143555:12;126547:19;143444:180;126538:29;:34;;;126531:135;;126626:1;126621:6;147289:16;;;147258:24;;147254:33;;;147251:55;126531:135;;;126722:1;126717:6;;147289:16;;;147258:24;;147254:33;;;147251:55;126692:42;;126338:420;144492:2;144488:17;;;144511:1;144507:13;;;144484:37;144636:8;;144561:21;144565:1;144561:21;;;;144764:9;;;144760:21;;144690:10;144753:29;144746:37;;144739:45;144729:56;;145125:10;;;145224:1;145220:9;;;145205:2;145201:17;;;145197:33;145341:8;;145395:18;145486:10;145482:26;;145465:2;145461:19;;;145458:51;145274:1;145270:17;;;;;;145558:9;;;145554:24;;;;145547:32;145540:40;;;145533:48;;;145523:59;;-1:-1:-1;126889:9:0;;;;149667:8;;149720:4;149713:12;;;149707:19;149732:1;149728:10;;;149704:35;149689:51;;149798:17;149788:28;;126282:694;126995:5;126984:7;:16;126279:723;;127160:1;127146:15;;147289:16;;;147258:24;;147254:33;;;147251:55;127112:61;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;125731:1458:0;127209:15;;;;:22;:27;127205:171;;127257:41;;;;;;;;;;;;-1:-1:-1;127345:14:0;;;127317:43;;127333:10;;127345:14;;127317:15;:43::i;:::-;123759:3628;;;127517:6;127511:4;127504:20;127662:2;127658;127654:11;127650:2;127646:20;127638:4;127634:2;127630:13;127626:2;127622:22;127595:25;127589:4;127583;127578:89;127450:228;;;;123132:4553;;;:::o;164787:399::-;164870:4;164826:23;112220:37;;;:30;:37;;;;;:45;;;;;;164826:50;;164891:15;164910:1;164891:20;164887:91;;164960:7;164787:399::o;164887:91::-;165058:18;;165013:15;;165043:33;;165039:99;;;-1:-1:-1;165108:18:0;;165039:99;165148:30;165165:12;165148:16;:30::i;148445:667::-;148505:20;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;148505:20:0;148781:4;148775:11;148813:1;148807:4;148800:15;148874:4;148868;148864:15;148963:1;148960;148956:9;148948:6;148944:22;148938:4;148931:36;149022:4;149018:1;149012:4;149008:12;149001:26;149068:6;149065:1;149058:17;;;148445:667;;;:::o;127758:395::-;127898:4;;128058:1;128023:30;110771:8;128023:20;:30;:::i;:::-;128022:37;;;-1:-1:-1;128136:3:0;128128:11;;128085:31;;;128077:63;:68;;;127758:395;-1:-1:-1;;;;127758:395:0:o;149935:645::-;150110:4;150107:1;150103:12;150097:19;150149:4;150143;150139:15;150208:10;150205:1;150198:21;150283:4;150276;150273:1;150269:12;150262:26;150379:4;150373:11;150370:1;150366:19;150360:4;150356:30;150347:39;;150505:4;150502:1;150499;150492:4;150489:1;150485:12;150482:1;150474:6;150467:5;150462:48;150458:1;150454;150448:8;150445:15;150441:70;150431:131;;150542:4;150539:1;150532:15;150431:131;;;149935:645;;:::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:455::-;418:2;407:9;400:21;381:4;450:6;444:13;493:6;488:2;477:9;473:18;466:34;509:79;581:6;576:2;565:9;561:18;556:2;548:6;544:15;509:79;:::i;:::-;640:2;628:15;645:66;624:88;609:104;;;;715:2;605:113;;269:455;-1:-1:-1;;269:455:1:o;729:154::-;815:42;808:5;804:54;797:5;794:65;784:93;;873:1;870;863:12;888:315;956:6;964;1017:2;1005:9;996:7;992:23;988:32;985:52;;;1033:1;1030;1023:12;985:52;1072:9;1059:23;1091:31;1116:5;1091:31;:::i;:::-;1141:5;1193:2;1178:18;;;;1165:32;;-1:-1:-1;;;888:315:1:o;1582:456::-;1659:6;1667;1675;1728:2;1716:9;1707:7;1703:23;1699:32;1696:52;;;1744:1;1741;1734:12;1696:52;1783:9;1770:23;1802:31;1827:5;1802:31;:::i;:::-;1852:5;-1:-1:-1;1909:2:1;1894:18;;1881:32;1922:33;1881:32;1922:33;:::i;:::-;1582:456;;1974:7;;-1:-1:-1;;;2028:2:1;2013:18;;;;2000:32;;1582:456::o;2043:247::-;2102:6;2155:2;2143:9;2134:7;2130:23;2126:32;2123:52;;;2171:1;2168;2161:12;2123:52;2210:9;2197:23;2229:31;2254:5;2229:31;:::i;2295:118::-;2381:5;2374:13;2367:21;2360:5;2357:32;2347:60;;2403:1;2400;2393:12;2418:241;2474:6;2527:2;2515:9;2506:7;2502:23;2498:32;2495:52;;;2543:1;2540;2533:12;2495:52;2582:9;2569:23;2601:28;2623:5;2601:28;:::i;3084:248::-;3152:6;3160;3213:2;3201:9;3192:7;3188:23;3184:32;3181:52;;;3229:1;3226;3219:12;3181:52;-1:-1:-1;;3252:23:1;;;3322:2;3307:18;;;3294:32;;-1:-1:-1;3084:248:1:o;3593:382::-;3658:6;3666;3719:2;3707:9;3698:7;3694:23;3690:32;3687:52;;;3735:1;3732;3725:12;3687:52;3774:9;3761:23;3793:31;3818:5;3793:31;:::i;:::-;3843:5;-1:-1:-1;3900:2:1;3885:18;;3872:32;3913:30;3872:32;3913:30;:::i;:::-;3962:7;3952:17;;;3593:382;;;;;:::o;3980:180::-;4039:6;4092:2;4080:9;4071:7;4067:23;4063:32;4060:52;;;4108:1;4105;4098:12;4060:52;-1:-1:-1;4131:23:1;;3980:180;-1:-1:-1;3980:180:1:o;4165:388::-;4233:6;4241;4294:2;4282:9;4273:7;4269:23;4265:32;4262:52;;;4310:1;4307;4300:12;4262:52;4349:9;4336:23;4368:31;4393:5;4368:31;:::i;:::-;4418:5;-1:-1:-1;4475:2:1;4460:18;;4447:32;4488:33;4447:32;4488:33;:::i;4558:184::-;4610:77;4607:1;4600:88;4707:4;4704:1;4697:15;4731:4;4728:1;4721:15;4747:981;4816:6;4869:2;4857:9;4848:7;4844:23;4840:32;4837:52;;;4885:1;4882;4875:12;4837:52;4925:9;4912:23;4954:18;4995:2;4987:6;4984:14;4981:34;;;5011:1;5008;5001:12;4981:34;5049:6;5038:9;5034:22;5024:32;;5094:7;5087:4;5083:2;5079:13;5075:27;5065:55;;5116:1;5113;5106:12;5065:55;5152:2;5139:16;5174:2;5170;5167:10;5164:36;;;5180:18;;:::i;:::-;5314:2;5308:9;5376:4;5368:13;;5219:66;5364:22;;;5388:2;5360:31;5356:40;5344:53;;;5412:18;;;5432:22;;;5409:46;5406:72;;;5458:18;;:::i;:::-;5498:10;5494:2;5487:22;5533:2;5525:6;5518:18;5573:7;5568:2;5563;5559;5555:11;5551:20;5548:33;5545:53;;;5594:1;5591;5584:12;5545:53;5650:2;5645;5641;5637:11;5632:2;5624:6;5620:15;5607:46;5695:1;5673:15;;;5690:2;5669:24;5662:35;;;;-1:-1:-1;5677:6:1;4747:981;-1:-1:-1;;;;;4747:981:1:o;6084:184::-;6136:77;6133:1;6126:88;6233:4;6230:1;6223:15;6257:4;6254:1;6247:15;6273:168;6346:9;;;6377;;6394:15;;;6388:22;;6374:37;6364:71;;6415:18;;:::i;6446:184::-;6498:77;6495:1;6488:88;6595:4;6592:1;6585:15;6619:4;6616:1;6609:15;6635:120;6675:1;6701;6691:35;;6706:18;;:::i;:::-;-1:-1:-1;6740:9:1;;6635:120::o;6760:112::-;6792:1;6818;6808:35;;6823:18;;:::i;:::-;-1:-1:-1;6857:9:1;;6760:112::o;6877:437::-;6956:1;6952:12;;;;6999;;;7020:61;;7074:4;7066:6;7062:17;7052:27;;7020:61;7127:2;7119:6;7116:14;7096:18;7093:38;7090:218;;7164:77;7161:1;7154:88;7265:4;7262:1;7255:15;7293:4;7290:1;7283:15;7090:218;;6877:437;;;:::o;7445:1246::-;7722:3;7751:1;7784:6;7778:13;7814:36;7840:9;7814:36;:::i;:::-;7869:1;7886:17;;;7912:191;;;;8117:1;8112:358;;;;7879:591;;7912:191;7960:66;7949:9;7945:82;7940:3;7933:95;8083:6;8076:14;8069:22;8061:6;8057:35;8052:3;8048:45;8041:52;;7912:191;;8112:358;8143:6;8140:1;8133:17;8173:4;8218;8215:1;8205:18;8245:1;8259:165;8273:6;8270:1;8267:13;8259:165;;;8351:14;;8338:11;;;8331:35;8394:16;;;;8288:10;;8259:165;;;8263:3;;;8453:6;8448:3;8444:16;8437:23;;7879:591;;;;;8501:6;8495:13;8517:68;8576:8;8571:3;8564:4;8556:6;8552:17;8517:68;:::i;:::-;8648:7;8607:18;;8634:22;;;8683:1;8672:13;;7445:1246;-1:-1:-1;;;;7445:1246:1:o;9350:245::-;9417:6;9470:2;9458:9;9449:7;9445:23;9441:32;9438:52;;;9486:1;9483;9476:12;9438:52;9518:9;9512:16;9537:28;9559:5;9537:28;:::i;10235:306::-;10323:6;10331;10339;10392:2;10380:9;10371:7;10367:23;10363:32;10360:52;;;10408:1;10405;10398:12;10360:52;10437:9;10431:16;10421:26;;10487:2;10476:9;10472:18;10466:25;10456:35;;10531:2;10520:9;10516:18;10510:25;10500:35;;10235:306;;;;;:::o;10546:184::-;10616:6;10669:2;10657:9;10648:7;10644:23;10640:32;10637:52;;;10685:1;10682;10675:12;10637:52;-1:-1:-1;10708:16:1;;10546:184;-1:-1:-1;10546:184:1:o;11080:518::-;11182:2;11177:3;11174:11;11171:421;;;11218:5;11215:1;11208:16;11262:4;11259:1;11249:18;11332:2;11320:10;11316:19;11313:1;11309:27;11303:4;11299:38;11368:4;11356:10;11353:20;11350:47;;;-1:-1:-1;11391:4:1;11350:47;11446:2;11441:3;11437:12;11434:1;11430:20;11424:4;11420:31;11410:41;;11501:81;11519:2;11512:5;11509:13;11501:81;;;11578:1;11564:16;;11545:1;11534:13;11501:81;;;11505:3;;11080:518;;;:::o;11834:1464::-;11960:3;11954:10;11987:18;11979:6;11976:30;11973:56;;;12009:18;;:::i;:::-;12038:97;12128:6;12088:38;12120:4;12114:11;12088:38;:::i;:::-;12082:4;12038:97;:::i;:::-;12190:4;;12247:2;12236:14;;12264:1;12259:782;;;;13085:1;13102:6;13099:89;;;-1:-1:-1;13154:19:1;;;13148:26;13099:89;11740:66;11731:1;11727:11;;;11723:84;11719:89;11709:100;11815:1;11811:11;;;11706:117;13201:81;;12229:1063;;12259:782;7392:1;7385:14;;;7429:4;7416:18;;12307:66;12295:79;;;12472:236;12486:7;12483:1;12480:14;12472:236;;;12575:19;;;12569:26;12554:42;;12667:27;;;;12635:1;12623:14;;;;12502:19;;12472:236;;;12476:3;12736:6;12727:7;12724:19;12721:261;;;12797:19;;;12791:26;12898:66;12880:1;12876:14;;;12892:3;12872:24;12868:97;12864:102;12849:118;12834:134;;12721:261;-1:-1:-1;;;;;13028:1:1;13012:14;;;13008:22;12995:36;;-1:-1:-1;11834:1464:1:o;14886:125::-;14951:9;;;14972:10;;;14969:36;;;14985:18;;:::i;15787:128::-;15854:9;;;15875:11;;;15872:37;;;15889:18;;:::i;15920:184::-;15972:77;15969:1;15962:88;16069:4;16066:1;16059:15;16093:4;16090:1;16083:15;16109:251;16179:6;16232:2;16220:9;16211:7;16207:23;16203:32;16200:52;;;16248:1;16245;16238:12;16200:52;16280:9;16274:16;16299:31;16324:5;16299:31;:::i;16365:1026::-;16627:4;16675:3;16664:9;16660:19;16706:6;16695:9;16688:25;16732:2;16770:6;16765:2;16754:9;16750:18;16743:34;16813:3;16808:2;16797:9;16793:18;16786:31;16837:6;16872;16866:13;16903:6;16895;16888:22;16941:3;16930:9;16926:19;16919:26;;16980:2;16972:6;16968:15;16954:29;;17001:1;17011:218;17025:6;17022:1;17019:13;17011:218;;;17090:13;;17105:42;17086:62;17074:75;;17204:15;;;;17169:12;;;;17047:1;17040:9;17011:218;;;-1:-1:-1;;17297:42:1;17285:55;;;;17280:2;17265:18;;17258:83;-1:-1:-1;;;17372:3:1;17357:19;17350:35;17246:3;16365:1026;-1:-1:-1;;;16365:1026:1:o;17396:195::-;17435:3;17466:66;17459:5;17456:77;17453:103;;17536:18;;:::i;:::-;-1:-1:-1;17583:1:1;17572:13;;17396:195::o
Swarm Source
ipfs://3dddf96112529cdfe05c6f175c689882e66380e34b6df96ef55f110412660d2e
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 26 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.