Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2025-08-09
*/

// SPDX-License-Identifier: MIT

/*

                                          https://64x64.club
                                        https://x.com/64x64Club
                                     https://t.me/portal64x64Club


                ▒▓███████▓▒  ▒▓█▓▒  ▒▓█▓▒    ▒▓█▓▒  ▒▓█▓▒     ▒▓███████▓▒  ▒▓█▓▒  ▒▓█▓▒ 
               ▒▓█▓▒         ▒▓█▓▒  ▒▓█▓░    ▒▓█▓▒  ▒▓█▓▒    ▒▓█▓▒         ▒▓█▓▒  ▒▓█▓▒ 
               ▒▓█▓▒         ▒▓█▓▒  ▒▓█▓▒    ▒▓█▓▒  ▒▓█▓▒    ▒▓█▓▒         ▒▓█▓▒  ▒▓█▓▒ 
               ▒▓███████▓▒   ▒▓████████▓▒     ▒▓██████▓▒     ▒▓███████▓▒   ▒▓████████▓▒ 
               ▒▓█▓▒  ▒▓█▓▒         ▒▓█▓▒    ▒▓█▓▒  ▒▓█▓▒    ▒▓█▓▒  ▒▓█▓▒         ▒▓█▓▒ 
               ▒▓█▓▒  ▒▓█▓▒         ▒▓█▓▒    ▒▓█▓▒  ▒▓█▓▒    ▒▓█▓▒  ▒▓█▓▒         ▒▓█▓▒ 
                ▒▓██████▓▒          ▒▓█▓▒    ▒▓█▓▒  ▒▓█▓▒     ▒▓██████▓▒          ▒▓█▓▒ 

              _____                     _____             _____                     _____          
             /\    \                   /\    \           /\    \                   /\    \         
            /::\    \                 /::\____\         /::\____\                 /::\    \        
           /::::\    \               /:::/    /        /:::/    /                /::::\    \       
          /::::::\    \             /:::/    /        /:::/    /                /::::::\    \      
         /:::/\:::\    \           /:::/    /        /:::/    /                /:::/\:::\    \     
        /:::/  \:::\    \         /:::/    /        /:::/    /                /:::/__\:::\    \    
       /:::/    \:::\    \       /:::/    /        /:::/    /                /::::\   \:::\    \   
      /:::/    / \:::\    \     /:::/    /        /:::/    /      _____     /::::::\   \:::\    \  
     /:::/    /   \:::\    \   /:::/    /        /:::/____/      /\    \   /:::/\:::\   \:::\ ___\ 
    /:::/____/     \:::\____\ /:::/____/        |:::|    /      /::\____\ /:::/__\:::\   \::|    |
    \:::\    \      \::/    / \:::\    \        |:::|____\     /:::/    / \:::\   \:::\  /::|____|
     \:::\    \      \/____/   \:::\    \        \:::\    \   /:::/    /   \:::\   \:::\/::/   / 
      \:::\    \                \:::\    \        \:::\    \ /:::/    /     \:::\   \:::::/   /  
       \:::\    \                \:::\    \        \:::\    /:::/    /       \:::\   \:::/   /   
        \:::\    \                \:::\    \        \:::\__/:::/    /         \:::\  /::|    |    
         \:::\    \                \:::\    \        \::::::::/    /           \:::\/:::|    |     
          \:::\    \                \:::\    \        \::::::/    /             \::::::/    /      
           \:::\____\                \:::\____\        \::::/    /               \::::/    /       
            \::/    /                 \::/    /         \::/    /                 \::/    /        
             \/____/                   \/____/           \/____/                   \/____/        

*/

pragma solidity ^0.8.30;

library Base64 {
    bytes internal constant TABLE =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

    function encode(bytes memory data) internal pure returns (string memory) {
        uint256 len = data.length;
        if (len == 0) return "";

        uint256 encodedLen = 4 * ((len + 2) / 3);
        bytes memory result = new bytes(encodedLen + 32);

        bytes memory table = TABLE;

        assembly {
            let tablePtr := add(table, 1)
            let resultPtr := add(result, 32)

            for {
                let i := 0
            } lt(i, len) {

            } {
                i := add(i, 3)
                let input := and(mload(add(data, i)), 0xffffff)

                let out := mload(add(tablePtr, and(shr(18, input), 0x3F)))
                out := shl(8, out)
                out := add(
                    out,
                    and(mload(add(tablePtr, and(shr(12, input), 0x3F))), 0xFF)
                )
                out := shl(8, out)
                out := add(
                    out,
                    and(mload(add(tablePtr, and(shr(6, input), 0x3F))), 0xFF)
                )
                out := shl(8, out)
                out := add(
                    out,
                    and(mload(add(tablePtr, and(input, 0x3F))), 0xFF)
                )
                out := shl(224, out)

                mstore(resultPtr, out)
                resultPtr := add(resultPtr, 4)
            }

            switch mod(len, 3)
            case 1 {
                mstore(sub(resultPtr, 2), shl(240, 0x3d3d))
            }
            case 2 {
                mstore(sub(resultPtr, 1), shl(248, 0x3d))
            }

            mstore(result, encodedLen)
        }

        return string(result);
    }
}

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

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

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

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

library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();

    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)
    {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     */
    function trySub(uint256 a, uint256 b)
        internal
        pure
        returns (bool, uint256)
    {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

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

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

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

    /**
     * @dev Returns the 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) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0 = 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 MathOverflowedMulDiv();
            }

            ///////////////////////////////////////////////
            // 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.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding)
        internal
        pure
        returns (uint256)
    {
        unchecked {
            uint256 result = sqrt(a);
            return
                result +
                (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;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding)
        internal
        pure
        returns (uint256)
    {
        unchecked {
            uint256 result = log2(value);
            return
                result +
                (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;
        unchecked {
            if (value >= 10**64) {
                value /= 10**64;
                result += 64;
            }
            if (value >= 10**32) {
                value /= 10**32;
                result += 32;
            }
            if (value >= 10**16) {
                value /= 10**16;
                result += 16;
            }
            if (value >= 10**8) {
                value /= 10**8;
                result += 8;
            }
            if (value >= 10**4) {
                value /= 10**4;
                result += 4;
            }
            if (value >= 10**2) {
                value /= 10**2;
                result += 2;
            }
            if (value >= 10**1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding)
        internal
        pure
        returns (uint256)
    {
        unchecked {
            uint256 result = log10(value);
            return
                result +
                (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;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding)
        internal
        pure
        returns (uint256)
    {
        unchecked {
            uint256 result = log256(value);
            return
                result +
                (
                    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;
    }
}

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

    /**
     * @dev The `value` string doesn't fit in the specified `length`.
     */
    error StringsInsufficientHexLength(uint256 value, uint256 length);

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

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

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

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length)
        internal
        pure
        returns (string memory)
    {
        uint256 localValue = value;
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = HEX_DIGITS[localValue & 0xf];
            localValue >>= 4;
        }
        if (localValue != 0) {
            revert StringsInsufficientHexLength(value, length);
        }
        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
            bytes(a).length == bytes(b).length &&
            keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

library LibBit {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                  BIT TWIDDLING OPERATIONS                  */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Find last set.
    /// Returns the index of the most significant bit of `x`,
    /// counting from the least significant bit position.
    /// If `x` is zero, returns 256.
    function fls(uint256 x) internal pure returns (uint256 r) {
        /// @solidity memory-safe-assembly
        assembly {
            r := or(
                shl(8, iszero(x)),
                shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
            )
            r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
            r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
            r := or(r, shl(4, lt(0xffff, shr(r, x))))
            r := or(r, shl(3, lt(0xff, shr(r, x))))
            // forgefmt: disable-next-item
            r := or(
                r,
                byte(
                    and(
                        0x1f,
                        shr(shr(r, x), 0x8421084210842108cc6318c6db6d54be)
                    ),
                    0x0706060506020504060203020504030106050205030304010505030400000000
                )
            )
        }
    }

    /// @dev Count leading zeros.
    /// Returns the number of zeros preceding the most significant one bit.
    /// If `x` is zero, returns 256.
    function clz(uint256 x) internal pure returns (uint256 r) {
        /// @solidity memory-safe-assembly
        assembly {
            r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
            r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
            r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
            r := or(r, shl(4, lt(0xffff, shr(r, x))))
            r := or(r, shl(3, lt(0xff, shr(r, x))))
            // forgefmt: disable-next-item
            r := add(
                xor(
                    r,
                    byte(
                        and(
                            0x1f,
                            shr(shr(r, x), 0x8421084210842108cc6318c6db6d54be)
                        ),
                        0xf8f9f9faf9fdfafbf9fdfcfdfafbfcfef9fafdfafcfcfbfefafafcfbffffffff
                    )
                ),
                iszero(x)
            )
        }
    }

    /// @dev Find first set.
    /// Returns the index of the least significant bit of `x`,
    /// counting from the least significant bit position.
    /// If `x` is zero, returns 256.
    /// Equivalent to `ctz` (count trailing zeros), which gives
    /// the number of zeros following the least significant one bit.
    function ffs(uint256 x) internal pure returns (uint256 r) {
        /// @solidity memory-safe-assembly
        assembly {
            // Isolate the least significant bit.
            let b := and(x, add(not(x), 1))

            r := or(
                shl(8, iszero(x)),
                shl(7, lt(0xffffffffffffffffffffffffffffffff, b))
            )
            r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, b))))
            r := or(r, shl(5, lt(0xffffffff, shr(r, b))))

            // For the remaining 32 bits, use a De Bruijn lookup.
            // forgefmt: disable-next-item
            r := or(
                r,
                byte(
                    and(div(0xd76453e0, shr(r, b)), 0x1f),
                    0x001f0d1e100c1d070f090b19131c1706010e11080a1a141802121b1503160405
                )
            )
        }
    }

    /// @dev Returns the number of set bits in `x`.
    function popCount(uint256 x) internal pure returns (uint256 c) {
        /// @solidity memory-safe-assembly
        assembly {
            let max := not(0)
            let isMax := eq(x, max)
            x := sub(x, and(shr(1, x), div(max, 3)))
            x := add(and(x, div(max, 5)), and(shr(2, x), div(max, 5)))
            x := and(add(x, shr(4, x)), div(max, 17))
            c := or(shl(8, isMax), shr(248, mul(x, div(max, 255))))
        }
    }

    /// @dev Returns whether `x` is a power of 2.
    function isPo2(uint256 x) internal pure returns (bool result) {
        /// @solidity memory-safe-assembly
        assembly {
            // Equivalent to `x && !(x & (x - 1))`.
            result := iszero(add(and(x, sub(x, 1)), iszero(x)))
        }
    }

    /// @dev Returns `x` reversed at the bit level.
    function reverseBits(uint256 x) internal pure returns (uint256 r) {
        uint256 m0 = 0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f;
        uint256 m1 = m0 ^ (m0 << 2);
        uint256 m2 = m1 ^ (m1 << 1);
        r = reverseBytes(x);
        r = (m2 & (r >> 1)) | ((m2 & r) << 1);
        r = (m1 & (r >> 2)) | ((m1 & r) << 2);
        r = (m0 & (r >> 4)) | ((m0 & r) << 4);
    }

    /// @dev Returns `x` reversed at the byte level.
    function reverseBytes(uint256 x) internal pure returns (uint256 r) {
        unchecked {
            // Computing masks on-the-fly reduces bytecode size by about 200 bytes.
            uint256 m0 = 0x100000000000000000000000000000001 *
                (~toUint(x == 0) >> 192);
            uint256 m1 = m0 ^ (m0 << 32);
            uint256 m2 = m1 ^ (m1 << 16);
            uint256 m3 = m2 ^ (m2 << 8);
            r = (m3 & (x >> 8)) | ((m3 & x) << 8);
            r = (m2 & (r >> 16)) | ((m2 & r) << 16);
            r = (m1 & (r >> 32)) | ((m1 & r) << 32);
            r = (m0 & (r >> 64)) | ((m0 & r) << 64);
            r = (r >> 128) | (r << 128);
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                     BOOLEAN OPERATIONS                     */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    // A Solidity bool on the stack or memory is represented as a 256-bit word.
    // Non-zero values are true, zero is false.
    // A clean bool is either 0 (false) or 1 (true) under the hood.
    // Usually, if not always, the bool result of a regular Solidity expression,
    // or the argument of a public/external function will be a clean bool.
    // You can usually use the raw variants for more performance.
    // If uncertain, test (best with exact compiler settings).
    // Or use the non-raw variants (compiler can sometimes optimize out the double `iszero`s).

    /// @dev Returns `x & y`. Inputs must be clean.
    function rawAnd(bool x, bool y) internal pure returns (bool z) {
        /// @solidity memory-safe-assembly
        assembly {
            z := and(x, y)
        }
    }

    /// @dev Returns `x & y`.
    function and(bool x, bool y) internal pure returns (bool z) {
        /// @solidity memory-safe-assembly
        assembly {
            z := and(iszero(iszero(x)), iszero(iszero(y)))
        }
    }

    /// @dev Returns `x | y`. Inputs must be clean.
    function rawOr(bool x, bool y) internal pure returns (bool z) {
        /// @solidity memory-safe-assembly
        assembly {
            z := or(x, y)
        }
    }

    /// @dev Returns `x | y`.
    function or(bool x, bool y) internal pure returns (bool z) {
        /// @solidity memory-safe-assembly
        assembly {
            z := or(iszero(iszero(x)), iszero(iszero(y)))
        }
    }

    /// @dev Returns 1 if `b` is true, else 0. Input must be clean.
    function rawToUint(bool b) internal pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            z := b
        }
    }

    /// @dev Returns 1 if `b` is true, else 0.
    function toUint(bool b) internal pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            z := iszero(iszero(b))
        }
    }
}

/// @author Modified from Solidity-Bits (https://github.com/estarriolvetch/solidity-bits/blob/main/contracts/BitMaps.sol)
library LibBitmap {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         CONSTANTS                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The constant returned when a bitmap scan does not find a result.
    uint256 internal constant NOT_FOUND = type(uint256).max;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          STRUCTS                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev A bitmap in storage.
    struct Bitmap {
        mapping(uint256 => uint256) map;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         OPERATIONS                         */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the boolean value of the bit at `index` in `bitmap`.
    function get(Bitmap storage bitmap, uint256 index)
        internal
        view
        returns (bool isSet)
    {
        // It is better to set `isSet` to either 0 or 1, than zero vs non-zero.
        // Both cost the same amount of gas, but the former allows the returned value
        // to be reused without cleaning the upper bits.
        uint256 b = (bitmap.map[index >> 8] >> (index & 0xff)) & 1;
        /// @solidity memory-safe-assembly
        assembly {
            isSet := b
        }
    }

    /// @dev Updates the bit at `index` in `bitmap` to true.
    function set(Bitmap storage bitmap, uint256 index) internal {
        bitmap.map[index >> 8] |= (1 << (index & 0xff));
    }

    /// @dev Updates the bit at `index` in `bitmap` to false.
    function unset(Bitmap storage bitmap, uint256 index) internal {
        bitmap.map[index >> 8] &= ~(1 << (index & 0xff));
    }

    /// @dev Flips the bit at `index` in `bitmap`.
    /// Returns the boolean result of the flipped bit.
    function toggle(Bitmap storage bitmap, uint256 index)
        internal
        returns (bool newIsSet)
    {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x20, bitmap.slot)
            mstore(0x00, shr(8, index))
            let storageSlot := keccak256(0x00, 0x40)
            let shift := and(index, 0xff)
            let storageValue := xor(sload(storageSlot), shl(shift, 1))
            // It makes sense to return the `newIsSet`,
            // as it allow us to skip an additional warm `sload`,
            // and it costs minimal gas (about 15),
            // which may be optimized away if the returned value is unused.
            newIsSet := and(1, shr(shift, storageValue))
            sstore(storageSlot, storageValue)
        }
    }

    /// @dev Updates the bit at `index` in `bitmap` to `shouldSet`.
    function setTo(
        Bitmap storage bitmap,
        uint256 index,
        bool shouldSet
    ) internal {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x20, bitmap.slot)
            mstore(0x00, shr(8, index))
            let storageSlot := keccak256(0x00, 0x40)
            let storageValue := sload(storageSlot)
            let shift := and(index, 0xff)
            sstore(
                storageSlot,
                // Unsets the bit at `shift` via `and`, then sets its new value via `or`.
                or(
                    and(storageValue, not(shl(shift, 1))),
                    shl(shift, iszero(iszero(shouldSet)))
                )
            )
        }
    }

    /// @dev Consecutively sets `amount` of bits starting from the bit at `start`.
    function setBatch(
        Bitmap storage bitmap,
        uint256 start,
        uint256 amount
    ) internal {
        /// @solidity memory-safe-assembly
        assembly {
            let max := not(0)
            let shift := and(start, 0xff)
            mstore(0x20, bitmap.slot)
            mstore(0x00, shr(8, start))
            if iszero(lt(add(shift, amount), 257)) {
                let storageSlot := keccak256(0x00, 0x40)
                sstore(storageSlot, or(sload(storageSlot), shl(shift, max)))
                let bucket := add(mload(0x00), 1)
                let bucketEnd := add(mload(0x00), shr(8, add(amount, shift)))
                amount := and(add(amount, shift), 0xff)
                shift := 0
                for {

                } iszero(eq(bucket, bucketEnd)) {
                    bucket := add(bucket, 1)
                } {
                    mstore(0x00, bucket)
                    sstore(keccak256(0x00, 0x40), max)
                }
                mstore(0x00, bucket)
            }
            let storageSlot := keccak256(0x00, 0x40)
            sstore(
                storageSlot,
                or(sload(storageSlot), shl(shift, shr(sub(256, amount), max)))
            )
        }
    }

    /// @dev Consecutively unsets `amount` of bits starting from the bit at `start`.
    function unsetBatch(
        Bitmap storage bitmap,
        uint256 start,
        uint256 amount
    ) internal {
        /// @solidity memory-safe-assembly
        assembly {
            let shift := and(start, 0xff)
            mstore(0x20, bitmap.slot)
            mstore(0x00, shr(8, start))
            if iszero(lt(add(shift, amount), 257)) {
                let storageSlot := keccak256(0x00, 0x40)
                sstore(
                    storageSlot,
                    and(sload(storageSlot), not(shl(shift, not(0))))
                )
                let bucket := add(mload(0x00), 1)
                let bucketEnd := add(mload(0x00), shr(8, add(amount, shift)))
                amount := and(add(amount, shift), 0xff)
                shift := 0
                for {

                } iszero(eq(bucket, bucketEnd)) {
                    bucket := add(bucket, 1)
                } {
                    mstore(0x00, bucket)
                    sstore(keccak256(0x00, 0x40), 0)
                }
                mstore(0x00, bucket)
            }
            let storageSlot := keccak256(0x00, 0x40)
            sstore(
                storageSlot,
                and(
                    sload(storageSlot),
                    not(shl(shift, shr(sub(256, amount), not(0))))
                )
            )
        }
    }

    /// @dev Returns number of set bits within a range by
    /// scanning `amount` of bits starting from the bit at `start`.
    function popCount(
        Bitmap storage bitmap,
        uint256 start,
        uint256 amount
    ) internal view returns (uint256 count) {
        unchecked {
            uint256 bucket = start >> 8;
            uint256 shift = start & 0xff;
            if (!(amount + shift < 257)) {
                count = LibBit.popCount(bitmap.map[bucket] >> shift);
                uint256 bucketEnd = bucket + ((amount + shift) >> 8);
                amount = (amount + shift) & 0xff;
                shift = 0;
                for (++bucket; bucket != bucketEnd; ++bucket) {
                    count += LibBit.popCount(bitmap.map[bucket]);
                }
            }
            count += LibBit.popCount(
                (bitmap.map[bucket] >> shift) << (256 - amount)
            );
        }
    }

    /// @dev Returns the index of the most significant set bit before the bit at `before`.
    /// If no set bit is found, returns `NOT_FOUND`.
    function findLastSet(Bitmap storage bitmap, uint256 before)
        internal
        view
        returns (uint256 setBitIndex)
    {
        uint256 bucket;
        uint256 bucketBits;
        /// @solidity memory-safe-assembly
        assembly {
            setBitIndex := not(0)
            bucket := shr(8, before)
            mstore(0x00, bucket)
            mstore(0x20, bitmap.slot)
            let offset := and(0xff, not(before)) // `256 - (255 & before) - 1`.
            bucketBits := shr(offset, shl(offset, sload(keccak256(0x00, 0x40))))
            if iszero(or(bucketBits, iszero(bucket))) {
                for {

                } 1 {

                } {
                    bucket := add(bucket, setBitIndex) // `sub(bucket, 1)`.
                    mstore(0x00, bucket)
                    bucketBits := sload(keccak256(0x00, 0x40))
                    if or(bucketBits, iszero(bucket)) {
                        break
                    }
                }
            }
        }
        if (bucketBits != 0) {
            setBitIndex = (bucket << 8) | LibBit.fls(bucketBits);
            /// @solidity memory-safe-assembly
            assembly {
                setBitIndex := or(setBitIndex, sub(0, gt(setBitIndex, before)))
            }
        }
    }
}

abstract contract Ownable {
    event OwnershipTransferred(address indexed user, address indexed newOwner);

    error Unauthorized();
    error InvalidOwner();

    address public owner;

    modifier onlyOwner() virtual {
        if (msg.sender != owner) revert Unauthorized();

        _;
    }

    constructor() {
        owner = msg.sender;

        emit OwnershipTransferred(address(0), msg.sender);
    }

    function transferOwnership(address _owner) public virtual onlyOwner {
        if (_owner == address(0)) revert InvalidOwner();

        owner = _owner;

        emit OwnershipTransferred(msg.sender, _owner);
    }

    function revokeOwnership() public virtual onlyOwner {
        owner = address(0);

        emit OwnershipTransferred(msg.sender, address(0));
    }
}

interface IERC20 {
    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

    function transfer(address recipient, uint256 amount)
        external
        returns (bool);

    function allowance(address owner, address spender)
        external
        view
        returns (uint256);

    function approve(address spender, uint256 amount) external returns (bool);

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint256 value);

    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
}

interface IERC20Metadata is IERC20 {
    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view returns (uint8);
}

interface IUniswapV2Factory {
    event PairCreated(
        address indexed token0,
        address indexed token1,
        address pair,
        uint256
    );

    function feeTo() external view returns (address);

    function feeToSetter() external view returns (address);

    function getPair(address tokenA, address tokenB)
        external
        view
        returns (address pair);

    function allPairs(uint256) external view returns (address pair);

    function allPairsLength() external view returns (uint256);

    function createPair(address tokenA, address tokenB)
        external
        returns (address pair);

    function setFeeTo(address) external;

    function setFeeToSetter(address) external;
}

interface IUniswapV2Pair {
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
    event Transfer(address indexed from, address indexed to, uint256 value);

    function name() external pure returns (string memory);

    function symbol() external pure returns (string memory);

    function decimals() external pure returns (uint8);

    function totalSupply() external view returns (uint256);

    function balanceOf(address owner) external view returns (uint256);

    function allowance(address owner, address spender)
        external
        view
        returns (uint256);

    function approve(address spender, uint256 value) external returns (bool);

    function transfer(address to, uint256 value) external returns (bool);

    function transferFrom(
        address from,
        address to,
        uint256 value
    ) external returns (bool);

    function DOMAIN_SEPARATOR() external view returns (bytes32);

    function PERMIT_TYPEHASH() external pure returns (bytes32);

    function nonces(address owner) external view returns (uint256);

    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    event Mint(address indexed sender, uint256 amount0, uint256 amount1);
    event Burn(
        address indexed sender,
        uint256 amount0,
        uint256 amount1,
        address indexed to
    );
    event Swap(
        address indexed sender,
        uint256 amount0In,
        uint256 amount1In,
        uint256 amount0Out,
        uint256 amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint256);

    function factory() external view returns (address);

    function token0() external view returns (address);

    function token1() external view returns (address);

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

    function price0CumulativeLast() external view returns (uint256);

    function price1CumulativeLast() external view returns (uint256);

    function kLast() external view returns (uint256);

    function mint(address to) external returns (uint256 liquidity);

    function burn(address to)
        external
        returns (uint256 amount0, uint256 amount1);

    function swap(
        uint256 amount0Out,
        uint256 amount1Out,
        address to,
        bytes calldata data
    ) external;

    function skim(address to) external;

    function sync() external;

    function initialize(address, address) external;
}

interface IUniswapV2Router02 {
    function factory() external pure returns (address);

    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint256 amountADesired,
        uint256 amountBDesired,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    )
        external
        returns (
            uint256 amountA,
            uint256 amountB,
            uint256 liquidity
        );

    function addLiquidityETH(
        address token,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    )
        external
        payable
        returns (
            uint256 amountToken,
            uint256 amountETH,
            uint256 liquidity
        );

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;

    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable;

    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;
}

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);
}

interface IERC1155 {
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external;

    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external;

    function balanceOf(address owner, uint256 id)
        external
        view
        returns (uint256);

    function balanceOfBatch(address[] calldata owners, uint256[] calldata ids)
        external
        view
        returns (uint256[] memory);

    function setApprovalForAll(address operator, bool approved) external;

    function isApprovedForAll(address owner, address operator)
        external
        view
        returns (bool);
}

interface IERC1155TokenReceiver {
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external returns (bytes4);

    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4);
}

abstract contract ERC1155Support is IERC1155, Ownable {
    using LibBitmap for LibBitmap.Bitmap;

    event ApprovalForAll(
        address indexed owner,
        address indexed operator,
        bool approved
    );

    event TransferSingle(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256 id,
        uint256 value
    );

    error TransferFromIncorrectOwnerOrInvalidAmount();
    error InputLengthMistmatch();
    error InsufficientBalance();

    string public dataURI;
    string public baseTokenURI;

    mapping(address => int256) internal _transferSign;
    mapping(address => LibBitmap.Bitmap) internal _owned;
    uint256 private _totalSupply;

    constructor(uint256 totalSupply) {
        _totalSupply = totalSupply;

        _owned[msg.sender].setBatch(1, 16);
        _owned[address(this)].setBatch(17, 1007);
        _owned[msg.sender].setBatch(1024, 140);
        _owned[address(this)].setBatch(1164, 2834);
        _owned[msg.sender].setBatch(3998, 99);

        for (uint256 i = 1; i <= 16; ++i) {
            emit TransferSingle(msg.sender, address(0), msg.sender, i, 1);
        }
        for (uint256 i = 17; i <= 1007 + 17 - 1; ++i) {
            emit TransferSingle(address(this), address(0), address(this), i, 1);
        }
        for (uint256 i = 1024; i <= 1024 + 140 - 1; ++i) {
            emit TransferSingle(msg.sender, address(0), msg.sender, i, 1);
        }
        for (uint256 i = 1164; i <= 1164 + 2834 - 1; ++i) {
            emit TransferSingle(address(this), address(0), address(this), i, 1);
        }
        for (uint256 i = 3998; i <= 3998 + 99 - 1; ++i) {
            emit TransferSingle(msg.sender, address(0), msg.sender, i, 1);
        }

        _transferByID(address(this), address(this), msg.sender, 64);
    }

    function isOwnerOf(address account, uint256 id) public view returns (bool) {
        return _owned[account].get(id);
    }

    function _getNextID(
        address owner,
        int256 sign,
        uint256 lastID
    ) private view returns (uint256) {
        if (sign > 0) {
            for (uint256 i = lastID; i <= _totalSupply; ++i) {
                if (_owned[owner].get(i)) {
                    return i;
                }
            }
        }

        for (uint256 i = lastID; i > 0; --i) {
            if (_owned[owner].get(i)) {
                return i;
            }
        }

        revert InsufficientBalance();
    }

    // this function does not perform balance checks but will revert if there's not enough tokens to transfer
    function _transferNFTs(
        address from,
        address to,
        uint256 amount
    ) internal {
        int256 sign = _transferSign[from];
        if (uint256(sign > 0 ? sign : -sign) != block.number) {
            if (sign == 0) {
                sign = -int256(block.number);
                _transferSign[from] = sign;
            } else {
                sign = sign > 0 ? -int256(block.number) : int256(block.number);
                _transferSign[from] = sign;
            }
        }

        uint256 id = sign > 0 ? 1 : _totalSupply;

        for (uint256 i = 0; i < amount; ++i) {
            id = _getNextID(from, sign, id);

            _owned[from].unset(id);
            _owned[to].set(id);

            emit TransferSingle(from, from, to, id, 1);
        }
    }

    function _transferByID(
        address operator,
        address from,
        address to,
        uint16 id
    ) internal {
        if (_owned[from].get(id)) {
            _owned[from].unset(id);
            _owned[to].set(id);

            if (operator == address(0)) {
                operator = from;
            }

            emit TransferSingle(operator, from, to, id, 1);

            return;
        }

        revert TransferFromIncorrectOwnerOrInvalidAmount();
    }

    function transferByID(address to, uint16 id) public virtual {}

    function tokenURI(uint256 id) public view virtual returns (string memory);
}

contract ERC20 is IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;
    uint8 private _decimals;

    constructor(
        string memory name_,
        string memory symbol_,
        uint8 decimals_
    ) {
        _name = name_;
        _symbol = symbol_;
        _decimals = decimals_;
    }

    function name() public view virtual override returns (string memory) {
        return _name;
    }

    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    function decimals() public view virtual override returns (uint8) {
        return _decimals;
    }

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

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

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

    function allowance(address owner, address spender)
        public
        view
        virtual
        override
        returns (uint256)
    {
        return _allowances[owner][spender];
    }

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

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);

        uint256 currentAllowance = _allowances[sender][msg.sender];
        require(
            currentAllowance >= amount,
            "ERC20: transfer amount exceeds allowance"
        );
        unchecked {
            _approve(sender, msg.sender, currentAllowance - amount);
        }

        return true;
    }

    function increaseAllowance(address spender, uint256 addedValue)
        public
        virtual
        returns (bool)
    {
        _approve(
            msg.sender,
            spender,
            _allowances[msg.sender][spender] + addedValue
        );
        return true;
    }

    function decreaseAllowance(address spender, uint256 subtractedValue)
        public
        virtual
        returns (bool)
    {
        uint256 currentAllowance = _allowances[msg.sender][spender];
        require(
            currentAllowance >= subtractedValue,
            "ERC20: decreased allowance below zero"
        );
        unchecked {
            _approve(msg.sender, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

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

        _beforeTokenTransfer(sender, recipient, amount);

        uint256 senderBalance = _balances[sender];
        require(
            senderBalance >= amount,
            "ERC20: transfer amount exceeds balance"
        );
        unchecked {
            _balances[sender] = senderBalance - amount;
        }
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, amount);

        _afterTokenTransfer(sender, recipient, amount);
    }

    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
        }
        _totalSupply -= amount;

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

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

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}

    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}

contract Club64x64 is ERC20, ERC1155Support {
    using Base64 for bytes;
    using LibBitmap for LibBitmap.Bitmap;

    IUniswapV2Router02 public immutable uniswapV2Router;
    address public uniswapV2Pair;
    address public constant deadAddress = address(0xdead);

    bool private isSwapping;

    address private treasuryWallet;

    uint256 public maxTransactionAmount;
    uint256 public swapTokensAtAmount;
    uint256 public maxSwapTokens;

    bool public limitsInEffect = true;
    bool public tradingActive = false;

    uint256 public buyTotalFees;
    uint256 public buyTreasuryFee;
    uint256 public buyBurnFee;

    uint256 public sellTotalFees;
    uint256 public sellTreasuryFee;
    uint256 public sellBurnFee;

    uint256 public sellCounter;

    mapping(address => bool) private _isExcludedFromFees;
    mapping(uint256 => uint256) private swapInBlock;
    mapping(address => bool) public _isExcludedMaxTransactionAmount;

    mapping(address => bool) public automatedMarketMakerPairs;

    mapping(address => mapping(address => bool)) private _isApprovedForAll;

    event AutoNukeLP();

    event ExcludeFromFees(address indexed account, bool isExcluded);

    event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);

    event MarketingWalletUpdated(
        address indexed newWallet,
        address indexed oldWallet
    );

    constructor() ERC20("64x64", "64x64", 0) ERC1155Support(4096) {
        IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(
            0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
        );

        excludeFromMaxTransaction(address(_uniswapV2Router), true);
        uniswapV2Router = _uniswapV2Router;

        uint256 _buyTreasuryFee = 60;
        uint256 _buyBurnFee = 120;

        uint256 _sellTreasuryFee = 160;
        uint256 _sellBurnFee = 160;

        buyTreasuryFee = _buyTreasuryFee;
        buyBurnFee = _buyBurnFee;
        buyTotalFees = buyTreasuryFee + buyBurnFee;

        sellTreasuryFee = _sellTreasuryFee;
        sellBurnFee = _sellBurnFee;
        sellTotalFees = sellTreasuryFee + sellBurnFee;

        uint256 totalSupply = 4096;

        maxTransactionAmount = 128;
        swapTokensAtAmount = 2;
        maxSwapTokens = 32;

        treasuryWallet = msg.sender;

        excludeFromFees(owner, true);
        excludeFromFees(address(this), true);
        excludeFromFees(address(0xdead), true);

        excludeFromMaxTransaction(owner, true);
        excludeFromMaxTransaction(address(this), true);
        excludeFromMaxTransaction(address(0xdead), true);

        _mint(msg.sender, 256);
        _mint(address(this), totalSupply - 256);

        baseTokenURI = "https://64x64.club/pics/";
        dataURI = "https://64x64.club/pics/";
    }

    receive() external payable {}

    function addLiquidity() external payable onlyOwner {
        uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(
            address(this),
            uniswapV2Router.WETH()
        );
        excludeFromMaxTransaction(address(uniswapV2Pair), true);
        _setAutomatedMarketMakerPair(address(uniswapV2Pair), true);

        _addLiquidity(balanceOf(address(this)), msg.value);
    }

    function _addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
        _approve(address(this), address(uniswapV2Router), tokenAmount);

        uniswapV2Router.addLiquidityETH{value: ethAmount}(
            address(this),
            tokenAmount,
            0,
            0,
            owner,
            block.timestamp
        );
    }

    function enableTrading() external onlyOwner {
        tradingActive = true;
    }

    function removeLimits() external onlyOwner returns (bool) {
        limitsInEffect = false;
        return true;
    }

    function wlContract(address _whitelist, bool isWL) public onlyOwner {
        _isExcludedMaxTransactionAmount[_whitelist] = isWL;
        _isExcludedFromFees[_whitelist] = isWL;
    }

    function excludeFromMaxTransaction(address excludedAddress, bool isExcluded)
        public
        onlyOwner
    {
        _isExcludedMaxTransactionAmount[excludedAddress] = isExcluded;
    }

    function updateSwapTokensAtAmount(uint256 newAmount)
        external
        onlyOwner
        returns (bool)
    {
        require(newAmount >= 1 && newAmount <= 256);
        swapTokensAtAmount = newAmount;
        return true;
    }

    function updateMaxSwapTokens(uint256 newAmount)
        external
        onlyOwner
        returns (bool)
    {
        require(newAmount >= 1 && newAmount <= 256);
        maxSwapTokens = newAmount;
        return true;
    }

    function updateBuyFees(uint256 _treasuryFee, uint256 _burnFee)
        external
        onlyOwner
    {
        buyTreasuryFee = _treasuryFee;
        buyBurnFee = _burnFee;
        buyTotalFees = buyTreasuryFee + buyBurnFee;
        require(buyTotalFees <= 2000);
    }

    function updateSellFees(uint256 _treasuryFee, uint256 _burnFee)
        external
        onlyOwner
    {
        sellTreasuryFee = _treasuryFee;
        sellBurnFee = _burnFee;
        sellTotalFees = sellTreasuryFee + sellBurnFee;
        require(sellTotalFees <= 3200);
    }

    function excludeFromFees(address account, bool excluded) public onlyOwner {
        _isExcludedFromFees[account] = excluded;
        emit ExcludeFromFees(account, excluded);
    }

    function setAutomatedMarketMakerPair(address pair, bool value)
        public
        onlyOwner
    {
        require(
            pair != uniswapV2Pair,
            "The pair cannot be removed from automatedMarketMakerPairs"
        );

        _setAutomatedMarketMakerPair(pair, value);
    }

    function _setAutomatedMarketMakerPair(address pair, bool value) private {
        automatedMarketMakerPairs[pair] = value;

        emit SetAutomatedMarketMakerPair(pair, value);
    }

    function updateMarketingWallet(address newMarketingWallet)
        external
        onlyOwner
    {
        emit MarketingWalletUpdated(newMarketingWallet, treasuryWallet);
        treasuryWallet = newMarketingWallet;
    }

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

        if (amount == 0) {
            super._transfer(from, to, 0);
            return;
        }

        if (automatedMarketMakerPairs[to] || automatedMarketMakerPairs[from]) {
            uint256 contractTokenBalance = balanceOf(address(this));
            bool canSwap = contractTokenBalance >= swapTokensAtAmount;

            uint256 blockNumber = block.number;

            if (
                canSwap &&
                !isSwapping &&
                (swapInBlock[blockNumber] < 2) &&
                !automatedMarketMakerPairs[from] &&
                !_isExcludedFromFees[from] &&
                !_isExcludedFromFees[to]
            ) {
                isSwapping = true;

                swapBack();

                ++swapInBlock[blockNumber];

                isSwapping = false;
            }

            bool takeFee = !isSwapping;

            if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
                takeFee = false;
            }

            // only take fees on buys/sells, do not take on wallet transfers
            // cause there are no decimals, fees won't be taken on small txs
            // with 4% sell burn tax, 1 token will be taken as a fee if the sell is at least 25 tokens
            if (takeFee) {
                uint256 fees = 0;
                uint256 toTreasury = 0;
                uint256 toBurn = 0;

                // on sell
                if (automatedMarketMakerPairs[to] && sellTotalFees > 0) {
                    fees = (amount * sellTotalFees) / 1000;
                    toBurn = (fees * sellBurnFee) / sellTotalFees;
                    toTreasury = fees - toBurn;

                    // on every 2/4/8/16 sells, if LP balance is > 2048/1024/256/64, take 1 token as burn tax no matter the amount being sold
                    // will be triggered only if burn amount from fees is 0 for the current trade and the trade is taxable
                    sellCounter++;
                    uint256 lpBalance = balanceOf(uniswapV2Pair);
                    if (toBurn == 0) {
                        if (
                            (lpBalance > 2048 && sellCounter >= 2) ||
                            (lpBalance > 1024 && sellCounter >= 4) ||
                            (lpBalance > 256 && sellCounter >= 8) ||
                            (lpBalance > 64 && sellCounter >= 16)
                        ) {
                            sellCounter = 0;
                            toBurn = 1;
                            fees += 1;
                        }
                    }
                }
                // on buy
                else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
                    fees = (amount * buyTotalFees) / 1000;
                    toBurn = (fees * buyBurnFee) / buyTotalFees;
                    toTreasury = fees - toBurn;
                }

                if (toTreasury > 0) {
                    super._transfer(from, address(this), toTreasury);
                    _transferNFTs(from, address(this), toTreasury);
                }

                if (toBurn > 0) {
                    super._transfer(from, address(0xdead), toBurn);
                    _transferNFTs(from, address(0xdead), toBurn);
                }

                amount -= fees;
            }

            if (limitsInEffect) {
                if (
                    from != owner &&
                    to != owner &&
                    to != address(0) &&
                    to != address(0xdead) &&
                    !isSwapping
                ) {
                    if (!tradingActive) {
                        require(
                            _isExcludedFromFees[from] ||
                                _isExcludedFromFees[to],
                            "Trading is not active."
                        );
                    }

                    if (
                        automatedMarketMakerPairs[from] &&
                        !_isExcludedMaxTransactionAmount[to]
                    ) {
                        require(
                            amount <= maxTransactionAmount,
                            "Buy transfer amount exceeds the maxTransactionAmount."
                        );
                    } else if (
                        automatedMarketMakerPairs[to] &&
                        !_isExcludedMaxTransactionAmount[from]
                    ) {
                        require(
                            amount <= maxTransactionAmount,
                            "Sell transfer amount exceeds the maxTransactionAmount."
                        );
                    }
                }
            }
        }

        super._transfer(from, to, amount);
        _transferNFTs(from, to, amount);
    }

    function swapBack() private {
        uint256 contractBalance = balanceOf(address(this));
        bool success;

        if (contractBalance == 0) {
            return;
        }

        if (contractBalance > maxSwapTokens) {
            contractBalance = maxSwapTokens;
        }

        uint256 amountToSwapForETH = contractBalance;

        swapTokensForEth(amountToSwapForETH);

        (success, ) = address(treasuryWallet).call{
            value: address(this).balance
        }("");
    }

    function swapTokensForEth(uint256 tokenAmount) private {
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = uniswapV2Router.WETH();

        _approve(address(this), address(uniswapV2Router), tokenAmount);

        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            0,
            path,
            address(this),
            block.timestamp
        );
    }

    function transferByID(address to, uint16 id) public override {
        super._transfer(msg.sender, to, 1);
        _transferByID(msg.sender, msg.sender, to, id);
    }

    function setDataURI(string memory _dataURI) public onlyOwner {
        dataURI = _dataURI;
        baseTokenURI = _dataURI;
    }

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

    function isPalindrome(uint256 num) private pure returns (bool) {
        bool isThreeDigit = num >= 100 && num <= 999;
        bool isFourDigit = num >= 1000 && num <= 9999;
        if (!isThreeDigit && !isFourDigit) {
            return false;
        }

        uint256 original = num;
        uint256 reversed = 0;
        while (num > 0) {
            uint256 digit = num % 10;
            reversed = reversed * 10 + digit;
            num = num / 10;
        }

        return original == reversed;
    }

    function tokenURI(uint256 id) public view override returns (string memory) {
        string memory image = string.concat(Strings.toString(id), ".jpg");
        string memory type_;

        if (id == 1) {
            type_ = "1";
        } else if (id == 4096) {
            type_ = "4096";
        } else if (
            id == 2**1 ||
            id == 2**2 ||
            id == 2**3 ||
            id == 2**4 ||
            id == 2**5 ||
            id == 2**6 ||
            id == 2**7 ||
            id == 2**8 ||
            id == 2**9 ||
            id == 2**10 ||
            id == 2**11
        ) {
            type_ = "Power of 2";
        } else if (id % 64 == 0) {
            type_ = "Multiple of 64";
        } else if (
            (id < 100 && id % 11 == 0) ||
            (id < 1000 && id % 111 == 0) ||
            (id % 1111 == 0)
        ) {
            type_ = "Single digit";
        } else if (isPalindrome(id)) {
            type_ = "Palindrome";
        } else if (id % 1000 == 0) {
            type_ = "Multiple of 1000";
        } else if (id % 100 == 0) {
            type_ = "Multiple of 100";
        } else if (id % 10 == 0) {
            type_ = "Multiple of 10";
        } else if (id % 2 == 0) {
            type_ = "Even";
        } else {
            type_ = "Odd";
        }

        string memory jsonPreImage = string.concat(
            string.concat(
                string.concat('{"name": "', Strings.toString(id)),
                '","description":"A collection of 64x64 = 4096 infrangible tokens combining ERC-20 with ERC-721. No decimals, deflation only.","external_url":"https://64x64.club","image":"'
            ),
            string.concat(dataURI, image)
        );
        string memory jsonPostImage = string.concat(
            '","attributes":[{"trait_type":"Class","value":"',
            type_
        );
        string memory jsonPostTraits = '"}]}';

        return
            string.concat(
                "data:application/json;base64,",
                Base64.encode(
                    bytes(
                        string.concat(
                            string.concat(jsonPreImage, jsonPostImage),
                            jsonPostTraits
                        )
                    )
                )
            );
    }

    function supportsInterface(bytes4 interfaceId)
        external
        pure
        returns (bool)
    {
        return interfaceId == type(IERC1155).interfaceId;
    }

    function balanceOf(address account, uint256 id)
        public
        view
        virtual
        returns (uint256)
    {
        if (_owned[account].get(id)) {
            return 1;
        }
        return 0;
    }

    function uri(uint256 id) external view returns (string memory) {
        return tokenURI(id);
    }

    function setApprovalForAll(address operator, bool approved) external {
        _isApprovedForAll[msg.sender][operator] = approved;
        emit ApprovalForAll(msg.sender, operator, approved);
    }

    function _isApprovedOrOwner(address owner, address operator)
        internal
        view
        returns (uint256)
    {
        if (operator == owner || _isApprovedForAll[owner][operator]) {
            return 1;
        } else if (allowance(owner, operator) > 0) {
            return 2;
        }

        return 0;
    }

    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) public {
        require(value == 1, "Unsupported value");

        uint256 approved = _isApprovedOrOwner(from, msg.sender);
        require(approved > 0, "Not approved");

        if (approved == 2) {
            uint256 currentAllowance = allowance(from, msg.sender);
            require(
                currentAllowance >= 1,
                "ERC20: transfer amount exceeds allowance"
            );
            unchecked {
                _approve(from, msg.sender, currentAllowance - 1);
            }
        }

        super._transfer(from, to, 1);
        _transferByID(msg.sender, from, to, uint16(id));

        if (to.code.length > 0) {
            require(
                IERC1155TokenReceiver(to).onERC1155Received(
                    msg.sender,
                    from,
                    id,
                    1,
                    data
                ) == IERC1155TokenReceiver.onERC1155Received.selector,
                "Unsafe transfer"
            );
        }
    }

    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external override {
        if (ids.length != values.length) {
            revert InputLengthMistmatch();
        }

        for (uint256 i = 0; i < ids.length; ++i) {
            safeTransferFrom(from, to, ids[i], values[i], data);
        }
    }

    function balanceOfBatch(address[] calldata owners, uint256[] calldata ids)
        external
        view
        override
        returns (uint256[] memory)
    {
        if (owners.length != ids.length) {
            revert InputLengthMistmatch();
        }

        uint256[] memory batchBalances = new uint256[](owners.length);

        for (uint256 i = 0; i < owners.length; ++i) {
            batchBalances[i] = balanceOf(owners[i], ids[i]);
        }

        return batchBalances;
    }

    function isApprovedForAll(address owner, address operator)
        external
        view
        override
        returns (bool)
    {
        return _isApprovedForAll[owner][operator];
    }

    // can be called by anyone but tokens are transferred to treasury
    function recoverERC20(address toRecover, uint256 amount) external {
        require(toRecover != address(this));
        IERC20 tokenToRecover = IERC20(toRecover);
        require(
            tokenToRecover.balanceOf(address(this)) >= amount,
            "Insufficient token balance in contract"
        );
        tokenToRecover.transfer(treasuryWallet, amount);
    }

    function _beforeTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids
    ) internal virtual {}

    function _afterTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids
    ) internal virtual {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"InputLengthMistmatch","type":"error"},{"inputs":[],"name":"InsufficientBalance","type":"error"},{"inputs":[],"name":"InvalidOwner","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwnerOrInvalidAmount","type":"error"},{"inputs":[],"name":"Unauthorized","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"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":[],"name":"AutoNukeLP","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"bool","name":"isExcluded","type":"bool"}],"name":"ExcludeFromFees","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newWallet","type":"address"},{"indexed":true,"internalType":"address","name":"oldWallet","type":"address"}],"name":"MarketingWalletUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pair","type":"address"},{"indexed":true,"internalType":"bool","name":"value","type":"bool"}],"name":"SetAutomatedMarketMakerPair","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TransferSingle","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"_isExcludedMaxTransactionAmount","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"addLiquidity","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"automatedMarketMakerPairs","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"balanceOf","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":"owners","type":"address[]"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"balanceOfBatch","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseTokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"buyBurnFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"buyTotalFees","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"buyTreasuryFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"dataURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"deadAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"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":[],"name":"enableTrading","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"excluded","type":"bool"}],"name":"excludeFromFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"excludedAddress","type":"address"},{"internalType":"bool","name":"isExcluded","type":"bool"}],"name":"excludeFromMaxTransaction","outputs":[],"stateMutability":"nonpayable","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":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"isOwnerOf","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"limitsInEffect","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSwapTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxTransactionAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"address","name":"toRecover","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"recoverERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"removeLimits","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"revokeOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"values","type":"uint256[]"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeBatchTransferFrom","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":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sellBurnFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sellCounter","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sellTotalFees","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sellTreasuryFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"},{"internalType":"bool","name":"value","type":"bool"}],"name":"setAutomatedMarketMakerPair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_dataURI","type":"string"}],"name":"setDataURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_tokenURI","type":"string"}],"name":"setTokenURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"swapTokensAtAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tradingActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint16","name":"id","type":"uint16"}],"name":"transferByID","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uniswapV2Pair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"uniswapV2Router","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_treasuryFee","type":"uint256"},{"internalType":"uint256","name":"_burnFee","type":"uint256"}],"name":"updateBuyFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newMarketingWallet","type":"address"}],"name":"updateMarketingWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newAmount","type":"uint256"}],"name":"updateMaxSwapTokens","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_treasuryFee","type":"uint256"},{"internalType":"uint256","name":"_burnFee","type":"uint256"}],"name":"updateSellFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newAmount","type":"uint256"}],"name":"updateSwapTokensAtAmount","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_whitelist","type":"address"},{"internalType":"bool","name":"isWL","type":"bool"}],"name":"wlContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

c3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62

-----Decoded View---------------

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : c3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62

61483:20047:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;77492:228;;;;;;;;;;-1:-1:-1;77492:228:0;;;;;:::i;:::-;;:::i;:::-;;;691:25:1;;;679:2;664:18;77492:228:0;;;;;;;;77309:175;;;;;;;;;;-1:-1:-1;77309:175:0;;;;;:::i;:::-;77435:41;;77450:26;77435:41;;77309:175;;;;1324:14:1;;1317:22;1299:41;;1287:2;1272:18;77309:175:0;1159:187:1;66567:285:0;;;;;;;;;;-1:-1:-1;66567:285:0;;;;;:::i;:::-;;:::i;:::-;;56451:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;57511:208::-;;;;;;;;;;-1:-1:-1;57511:208:0;;;;;:::i;:::-;;:::i;77728:101::-;;;;;;;;;;-1:-1:-1;77728:101:0;;;;;:::i;:::-;;:::i;62394:63::-;;;;;;;;;;-1:-1:-1;62394:63:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;61608:51;;;;;;;;;;;;;;;;;;2870:42:1;2858:55;;;2840:74;;2828:2;2813:18;61608:51:0;2667:253:1;56779:108:0;;;;;;;;;;-1:-1:-1;56867:12:0;;56779:108;;74146:132;;;;;;;;;;-1:-1:-1;74146:132:0;;;;;:::i;:::-;;:::i;57727:525::-;;;;;;;;;;-1:-1:-1;57727:525:0;;;;;:::i;:::-;;:::i;61701:53::-;;;;;;;;;;;;61747:6;61701:53;;43587:151;;;;;;;;;;;;;:::i;79578:437::-;;;;;;;;;;-1:-1:-1;79578:437:0;;;;;:::i;:::-;;:::i;56671:100::-;;;;;;;;;;-1:-1:-1;56754:9:0;;56671:100;;56754:9;;;;7146:36:1;;7134:2;7119:18;56671:100:0;7004:184:1;61916:28:0;;;;;;;;;;;;;;;;58260:293;;;;;;;;;;-1:-1:-1;58260:293:0;;;;;:::i;:::-;;:::i;61666:28::-;;;;;;;;;;-1:-1:-1;61666:28:0;;;;;;;;61953:33;;;;;;;;;;-1:-1:-1;61953:33:0;;;;;;;;80023:510;;;;;;;;;;-1:-1:-1;80023:510:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;62069:29::-;;;;;;;;;;;;;;;;66281:278;;;;;;;;;;-1:-1:-1;66281:278:0;;;;;:::i;:::-;;:::i;62139:28::-;;;;;;;;;;;;;;;;62174:30;;;;;;;;;;;;;;;;56895:177;;;;;;;;;;-1:-1:-1;56895:177:0;;;;;:::i;:::-;57046:18;;57014:7;57046:18;;;;;;;;;;;;56895:177;65259:121;;;;;;;;;;;;;:::i;65582:197::-;;;;;;;;;;-1:-1:-1;65582:197:0;;;;;:::i;:::-;;:::i;80818:378::-;;;;;;;;;;-1:-1:-1;80818:378:0;;;;;:::i;:::-;;:::i;65168:83::-;;;;;;;;;;;;;:::i;43094:20::-;;;;;;;;;;-1:-1:-1;43094:20:0;;;;;;;;;;;73968:170;;;;;;;;;;-1:-1:-1;73968:170:0;;;;;:::i;:::-;;:::i;56559:104::-;;;;;;;;;;;;;:::i;67050:304::-;;;;;;;;;;-1:-1:-1;67050:304:0;;;;;:::i;:::-;;:::i;66039:234::-;;;;;;;;;;-1:-1:-1;66039:234:0;;;;;:::i;:::-;;:::i;77837:200::-;;;;;;;;;;-1:-1:-1;77837:200:0;;;;;:::i;:::-;;:::i;58561:478::-;;;;;;;;;;-1:-1:-1;58561:478:0;;;;;:::i;:::-;;:::i;62246:26::-;;;;;;;;;;;;;;;;57080:214;;;;;;;;;;-1:-1:-1;57080:214:0;;;;;:::i;:::-;;:::i;67558:229::-;;;;;;;;;;-1:-1:-1;67558:229:0;;;;;:::i;:::-;;:::i;62211:26::-;;;;;;;;;;;;;;;;65388:186;;;;;;;;;;-1:-1:-1;65388:186:0;;;;;:::i;:::-;;:::i;62466:57::-;;;;;;;;;;-1:-1:-1;62466:57:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;61993:33;;;;;;;;;;-1:-1:-1;61993:33:0;;;;;;;;;;;66860:182;;;;;;;;;;-1:-1:-1;66860:182:0;;;;;:::i;:::-;;:::i;53688:124::-;;;;;;;;;;-1:-1:-1;53688:124:0;;;;;:::i;:::-;;:::i;74933:2368::-;;;;;;;;;;-1:-1:-1;74933:2368:0;;;;;:::i;:::-;;:::i;61834:35::-;;;;;;;;;;;;;;;;65787:244;;;;;;;;;;-1:-1:-1;65787:244:0;;;;;:::i;:::-;;:::i;52364:26::-;;;;;;;;;;;;;:::i;62035:27::-;;;;;;;;;;;;;;;;57302:201;;;;;;;;;;-1:-1:-1;57302:201:0;;;;;:::i;:::-;57468:18;;;;57436:7;57468:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;57302:201;74286:106;;;;;;;;;;-1:-1:-1;74286:106:0;;;;;:::i;:::-;;:::i;61876:33::-;;;;;;;;;;;;;;;;62105:25;;;;;;;;;;;;;;;;64376:415;;;:::i;80541:198::-;;;;;;;;;;-1:-1:-1;80541:198:0;;;;;:::i;:::-;80697:24;;;;80668:4;80697:24;;;:17;:24;;;;;;;;:34;;;;;;;;;;;;;;;80541:198;78390:1180;;;;;;;;;;-1:-1:-1;78390:1180:0;;;;;:::i;:::-;;:::i;52336:21::-;;;;;;;;;;;;;:::i;43360:219::-;;;;;;;;;;-1:-1:-1;43360:219:0;;;;;:::i;:::-;;:::i;77492:228::-;77634:15;;;77605:7;77634:15;;;:6;:15;;;;;;;;35392:1;35383:10;;;35372:22;;;;;;;;35407:4;35399:12;;35372:40;35416:1;35371:46;77630:64;;;-1:-1:-1;77681:1:0;77674:8;;77630:64;-1:-1:-1;77711:1:0;77492:228;;;;;:::o;66567:285::-;43181:5;;;;;;;43167:10;:19;43163:46;;43195:14;;;;;;;;;;;;;;43163:46;66684:15:::1;:30:::0;;;66725:11:::1;:22:::0;;;66774:29:::1;66739:8:::0;66702:12;66774:29:::1;:::i;:::-;66758:13;:45:::0;;;66839:4:::1;-1:-1:-1::0;66822:21:0::1;66814:30;;;;;;66567:285:::0;;:::o;56451:100::-;56505:13;56538:5;56531:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56451:100;:::o;57511:208::-;57630:4;57652:37;57661:10;57673:7;57682:6;57652:8;:37::i;:::-;-1:-1:-1;57707:4:0;57511:208;;;;:::o;77728:101::-;77776:13;77809:12;77818:2;77809:8;:12::i;74146:132::-;43181:5;;;;;;;43167:10;:19;43163:46;;43195:14;;;;;;;;;;;;;;43163:46;74218:7:::1;:18;74228:8:::0;74218:7;:18:::1;:::i;:::-;-1:-1:-1::0;74247:12:0::1;:23;74262:8:::0;74247:12;:23:::1;:::i;57727:525::-:0;57867:4;57884:36;57894:6;57902:9;57913:6;57884:9;:36::i;:::-;57960:19;;;57933:24;57960:19;;;:11;:19;;;;;;;;57980:10;57960:31;;;;;;;;58024:26;;;;58002:116;;;;;;;14103:2:1;58002:116:0;;;14085:21:1;14142:2;14122:18;;;14115:30;14181:34;14161:18;;;14154:62;14252:10;14232:18;;;14225:38;14280:19;;58002:116:0;;;;;;;;;58154:55;58163:6;58171:10;58202:6;58183:16;:25;58154:8;:55::i;:::-;58240:4;58233:11;;;57727:525;;;;;;:::o;43587:151::-;43181:5;;;;;;;43167:10;:19;43163:46;;43195:14;;;;;;;;;;;;;;43163:46;43650:5:::1;:18:::0;;;::::1;::::0;;43686:44:::1;::::0;43666:1:::1;::::0;43707:10:::1;::::0;43686:44:::1;::::0;43666:1;;43686:44:::1;43587:151::o:0;79578:437::-;79792:27;;;79788:89;;79843:22;;;;;;;;;;;;;;79788:89;79894:9;79889:119;79909:14;;;79889:119;;;79945:51;79962:4;79968:2;79972:3;;79976:1;79972:6;;;;;;;:::i;:::-;;;;;;;79980;;79987:1;79980:9;;;;;;;:::i;:::-;;;;;;;79991:4;;79945:16;:51::i;:::-;79925:3;;79889:119;;;;79578:437;;;;;;;;:::o;58260:293::-;58420:10;58375:4;58467:23;;;:11;:23;;;;;;;;;:32;;;;;;;;;;58375:4;;58397:126;;58445:7;;58467:45;;58502:10;;58467:45;:::i;:::-;58397:8;:126::i;80023:510::-;80166:16;80204:27;;;80200:89;;80255:22;;;;;;;;;;;;;;80200:89;80301:30;80348:6;80334:28;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;80334:28:0;-1:-1:-1;80301:61:0;-1:-1:-1;80380:9:0;80375:118;80395:17;;;80375:118;;;80453:28;80463:6;;80470:1;80463:9;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;80474:3;;80478:1;80474:6;;;;;;;:::i;:::-;;;;;;;80453:9;:28::i;:::-;80434:13;80448:1;80434:16;;;;;;;;:::i;:::-;;;;;;;;;;:47;80414:3;;80375:118;;;-1:-1:-1;80512:13:0;80023:510;-1:-1:-1;;;;;80023:510:0:o;66281:278::-;43181:5;;;;;;;43167:10;:19;43163:46;;43195:14;;;;;;;;;;;;;;43163:46;66397:14:::1;:29:::0;;;66437:10:::1;:21:::0;;;66484:27:::1;66450:8:::0;66414:12;66484:27:::1;:::i;:::-;66469:12;:42:::0;;;66546:4:::1;-1:-1:-1::0;66530:20:0::1;66522:29;;;;;65259:121:::0;43181:5;;65311:4;;43181:5;;;;;43167:10;:19;43163:46;;43195:14;;;;;;;;;;;;;;43163:46;-1:-1:-1;65328:14:0::1;:22:::0;;;::::1;::::0;;;65259:121;:::o;65582:197::-;43181:5;;;;;;;43167:10;:19;43163:46;;43195:14;;;;;;;;;;;;;;43163:46;65710:48:::1;::::0;;;::::1;;::::0;;;:31:::1;:48;::::0;;;;:61;;;::::1;::::0;::::1;;::::0;;;::::1;::::0;;65582:197::o;80818:378::-;80924:4;80903:26;;;;80895:35;;;;;;81015:39;;;;;81048:4;81015:39;;;2840:74:1;80972:9:0;;81058:6;;81015:24;;;;;;2813:18:1;;81015:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:49;;80993:137;;;;;;;14936:2:1;80993:137:0;;;14918:21:1;14975:2;14955:18;;;14948:30;15014:34;14994:18;;;14987:62;15085:8;15065:18;;;15058:36;15111:19;;80993:137:0;14734:402:1;80993:137:0;81165:14;;81141:47;;;;;:23;81165:14;;;81141:47;;;15315:74:1;15405:18;;;15398:34;;;81141:23:0;;;;;;15288:18:1;;81141:47:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;80884:312;80818:378;;:::o;65168:83::-;43181:5;;;;;;;43167:10;:19;43163:46;;43195:14;;;;;;;;;;;;;;43163:46;65223:13:::1;:20:::0;;;::::1;;;::::0;;65168:83::o;73968:170::-;74040:34;74056:10;74068:2;74072:1;74040:15;:34::i;:::-;74085:45;74099:10;74111;74123:2;74127;74085:13;:45::i;56559:104::-;56615:13;56648:7;56641:14;;;;;:::i;67050:304::-;43181:5;;;;;;;43167:10;:19;43163:46;;43195:14;;;;;;;;;;;;;;43163:46;67194:13:::1;::::0;::::1;::::0;;::::1;67186:21:::0;;::::1;::::0;67164:128:::1;;;::::0;::::1;::::0;;15895:2:1;67164:128:0::1;::::0;::::1;15877:21:1::0;15934:2;15914:18;;;15907:30;15973:34;15953:18;;;15946:62;16044:27;16024:18;;;16017:55;16089:19;;67164:128:0::1;15693:421:1::0;67164:128:0::1;67305:41;67334:4;67340:5;67305:28;:41::i;66039:234::-:0;43181:5;;66142:4;;43181:5;;;;;43167:10;:19;43163:46;;43195:14;;;;;;;;;;;;;;43163:46;66185:1:::1;66172:9;:14;;:34;;;;;66203:3;66190:9;:16;;66172:34;66164:43;;;;;;-1:-1:-1::0;66218:13:0::1;:25:::0;66261:4:::1;::::0;66039:234::o;77837:200::-;77935:10;77917:29;;;;:17;:29;;;;;;;;;:39;;;;;;;;;;;;:50;;;;;;;;;;;;;77983:46;;1299:41:1;;;77917:39:0;;77935:10;77983:46;;1272:18:1;77983:46:0;;;;;;;77837:200;;:::o;58561:478::-;58742:10;58681:4;58730:23;;;:11;:23;;;;;;;;;:32;;;;;;;;;;58795:35;;;;58773:122;;;;;;;16321:2:1;58773:122:0;;;16303:21:1;16360:2;16340:18;;;16333:30;16399:34;16379:18;;;16372:62;16470:7;16450:18;;;16443:35;16495:19;;58773:122:0;16119:401:1;58773:122:0;58931:65;58940:10;58952:7;58980:15;58961:16;:34;58931:8;:65::i;:::-;-1:-1:-1;59027:4:0;;58561:478;-1:-1:-1;;;58561:478:0:o;57080:214::-;57202:4;57224:40;57234:10;57246:9;57257:6;57224:9;:40::i;67558:229::-;43181:5;;;;;;;43167:10;:19;43163:46;;43195:14;;;;;;;;;;;;;;43163:46;67718:14:::1;::::0;67675:58:::1;::::0;67718:14:::1;::::0;;::::1;::::0;67675:58;::::1;::::0;::::1;::::0;67718:14:::1;::::0;67675:58:::1;67744:14;:35:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;67558:229::o;65388:186::-;43181:5;;;;;;;43167:10;:19;43163:46;;43195:14;;;;;;;;;;;;;;43163:46;65467:43:::1;::::0;;::::1;;::::0;;;:31:::1;:43;::::0;;;;;;;:50;;;::::1;;::::0;;;::::1;::::0;::::1;::::0;;;65528:19:::1;:31:::0;;;;;;:38;;;;::::1;;::::0;;65388:186::o;66860:182::-;43181:5;;;;;;;43167:10;:19;43163:46;;43195:14;;;;;;;;;;;;;;43163:46;66945:28:::1;::::0;::::1;;::::0;;;:19:::1;:28;::::0;;;;;;;;:39;;;::::1;::::0;::::1;;::::0;;::::1;::::0;;;67000:34;;1299:41:1;;;67000:34:0::1;::::0;1272:18:1;67000:34:0::1;;;;;;;66860:182:::0;;:::o;53688:124::-;53781:15;;;53757:4;53781:15;;;:6;:15;;;;;;;;35392:1;35383:10;;;35372:22;;;;;;;;35407:4;35399:12;;35372:40;35416:1;35371:46;53781:23;35004:520;74933:2368;74993:13;75019:19;75055:20;75072:2;75055:16;:20::i;:::-;75041:43;;;;;;;;:::i;:::-;;;;;;;;;;;;;75019:65;;75095:19;75131:2;75137:1;75131:7;75127:1159;;-1:-1:-1;75155:11:0;;;;;;;;;;;;;;;;;75127:1159;;;75188:2;75194:4;75188:10;75184:1102;;-1:-1:-1;75215:14:0;;;;;;;;;;;;;;;;;75184:1102;;;75265:2;75271:4;75265:10;:37;;;;75292:2;75298:4;75292:10;75265:37;:64;;;;75319:2;75325:4;75319:10;75265:64;:91;;;;75346:2;75352:4;75346:10;75265:91;:118;;;;75373:2;75379:4;75373:10;75265:118;:145;;;;75400:2;75406:4;75400:10;75265:145;:172;;;;75427:2;75433:4;75427:10;75265:172;:199;;;;75454:2;75460:4;75454:10;75265:199;:226;;;;75481:2;75487:4;75481:10;75265:226;:254;;;;75508:2;75514:5;75508:11;75265:254;:282;;;;75536:2;75542:5;75536:11;75265:282;75247:1039;;;-1:-1:-1;75574:20:0;;;;;;;;;;;;;;;;;75247:1039;;;75616:7;75621:2;75616;:7;:::i;:::-;75627:1;75616:12;75612:674;;-1:-1:-1;75645:24:0;;;;;;;;;;;;;;;;;75612:674;;;75711:3;75706:2;:8;:24;;;;-1:-1:-1;75718:7:0;75723:2;75718;:7;:::i;:::-;:12;75706:24;75705:71;;;;75754:4;75749:2;:9;:26;;;;-1:-1:-1;75762:8:0;75767:3;75762:2;:8;:::i;:::-;:13;75749:26;75705:104;;;-1:-1:-1;75794:9:0;75799:4;75794:2;:9;:::i;:::-;:14;75705:104;75687:599;;;-1:-1:-1;75836:22:0;;;;;;;;;;;;;;;;;75687:599;;;75880:16;75893:2;75880:12;:16::i;:::-;75876:410;;;-1:-1:-1;75913:20:0;;;;;;;;;;;;;;;;;75876:410;;;75955:9;75960:4;75955:2;:9;:::i;:::-;75968:1;75955:14;75951:335;;-1:-1:-1;75986:26:0;;;;;;;;;;;;;;;;;75951:335;;;76034:8;76039:3;76034:2;:8;:::i;:::-;76046:1;76034:13;76030:256;;-1:-1:-1;76064:25:0;;;;;;;;;;;;;;;;;76030:256;;;76111:7;76116:2;76111;:7;:::i;:::-;76122:1;76111:12;76107:179;;-1:-1:-1;76140:24:0;;;;;;;;;;;;;;;;;76107:179;;;76186:6;76191:1;76186:2;:6;:::i;:::-;76196:1;76186:11;76182:104;;-1:-1:-1;76214:14:0;;;;;;;;;;;;;;;;;76182:104;;;-1:-1:-1;76261:13:0;;;;;;;;;;;;;;;;;76182:104;76298:26;76415:20;76432:2;76415:16;:20::i;:::-;76387:49;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;76355:288;;76387:49;76355:288;;:::i;:::-;;;;;;;;;;;;;76672:7;76681:5;76658:29;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;76327:371;;;76658:29;76327:371;;:::i;:::-;;;;;;;;;;;;;76298:400;;76709:27;76831:5;76739:108;;;;;;;;:::i;:::-;;;;;;;;;;;76858:37;;;;;;;;;76739:108;76858:37;;;;;;;77122:42;;76739:108;;-1:-1:-1;77010:268:0;;77122:42;;77136:12;;76739:108;;77122:42;;:::i;:::-;;;;;;;;;;;;;;;77078:158;;77195:14;;77122:42;77078:158;;:::i;:::-;;;;;;;;;;;;;77010:13;:268::i;:::-;76928:365;;;;;;;;:::i;:::-;;;;;;;;;;;;;76908:385;;;;;;;74933:2368;;;:::o;65787:244::-;43181:5;;65895:4;;43181:5;;;;;43167:10;:19;43163:46;;43195:14;;;;;;;;;;;;;;43163:46;65938:1:::1;65925:9;:14;;:34;;;;;65956:3;65943:9;:16;;65925:34;65917:43;;;;;;-1:-1:-1::0;65971:18:0::1;:30:::0;66019:4:::1;::::0;65787:244::o;52364:26::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;74286:106::-;43181:5;;;;;;;43167:10;:19;43163:46;;43195:14;;;;;;;;;;;;;;43163:46;74360:12:::1;:24;74375:9:::0;74360:12;:24:::1;:::i;64376:415::-:0;43181:5;;;;;;;43167:10;:19;43163:46;;43195:14;;;;;;;;;;;;;;43163:46;64472:15:::1;:23;;;:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;64454:55;;;64532:4;64552:15;:20;;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;64454:131;::::0;;::::1;::::0;;;;;;21128:42:1;21116:55;;;64454:131:0::1;::::0;::::1;21098:74:1::0;21208:55;;21188:18;;;21181:83;21071:18;;64454:131:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;64438:13;:147:::0;;;::::1;;::::0;;;::::1;::::0;;::::1;::::0;;64596:55:::1;::::0;-1:-1:-1;64596:25:0::1;:55::i;:::-;64699:13;::::0;64662:58:::1;::::0;64699:13:::1;;::::0;64662:28:::1;:58::i;:::-;64765:4;57014:7:::0;57046:18;;;;;;;;;;;64733:50:::1;::::0;64773:9:::1;64733:13;:50::i;:::-;64376:415::o:0;78390:1180::-;78568:5;78577:1;78568:10;78560:40;;;;;;;21477:2:1;78560:40:0;;;21459:21:1;21516:2;21496:18;;;21489:30;21555:19;21535:18;;;21528:47;21592:18;;78560:40:0;21275:341:1;78560:40:0;78613:16;78632:36;78651:4;78657:10;78632:18;:36::i;:::-;78613:55;;78698:1;78687:8;:12;78679:37;;;;;;;21823:2:1;78679:37:0;;;21805:21:1;21862:2;21842:18;;;21835:30;21901:14;21881:18;;;21874:42;21933:18;;78679:37:0;21621:336:1;78679:37:0;78733:8;78745:1;78733:13;78729:345;;57468:18;;;78763:24;57468:18;;;:11;:18;;;;;;;;78806:10;57468:27;;;;;;;;;;78858:21;;;78832:123;;;;;;;14103:2:1;78832:123:0;;;14085:21:1;14142:2;14122:18;;;14115:30;14181:34;14161:18;;;14154:62;14252:10;14232:18;;;14225:38;14280:19;;78832:123:0;13901:404:1;78832:123:0;78999:48;79008:4;79014:10;79045:1;79026:16;:20;78999:8;:48::i;:::-;78748:326;78729:345;79086:28;79102:4;79108:2;79112:1;79086:15;:28::i;:::-;79125:47;79139:10;79151:4;79157:2;79168;79125:13;:47::i;:::-;79189:14;;;;:18;79185:378;;79250:198;;79452:48;79250:198;;;79452:48;79250:43;;;;79452:48;;79250:198;;79316:10;;79349:4;;79376:2;;79401:1;;79425:4;;;;79250:198;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:250;;;79224:327;;;;;;;23266:2:1;79224:327:0;;;23248:21:1;23305:2;23285:18;;;23278:30;23344:17;23324:18;;;23317:45;23379:18;;79224:327:0;23064:339:1;79224:327:0;78549:1021;78390:1180;;;;;;:::o;52336:21::-;;;;;;;:::i;43360:219::-;43181:5;;;;;;;43167:10;:19;43163:46;;43195:14;;;;;;;;;;;;;;43163:46;43443:20:::1;::::0;::::1;43439:47;;43472:14;;;;;;;;;;;;;;43439:47;43499:5;:14:::0;;;::::1;;;::::0;::::1;::::0;;::::1;::::0;;;::::1;::::0;;;43531:40:::1;::::0;43552:10:::1;::::0;43531:40:::1;::::0;-1:-1:-1;;43531:40:0::1;43360:219:::0;:::o;60831:380::-;60967:19;;;60959:68;;;;;;;23610:2:1;60959:68:0;;;23592:21:1;23649:2;23629:18;;;23622:30;23688:34;23668:18;;;23661:62;23759:6;23739:18;;;23732:34;23783:19;;60959:68:0;23408:400:1;60959:68:0;61046:21;;;61038:68;;;;;;;24015:2:1;61038:68:0;;;23997:21:1;24054:2;24034:18;;;24027:30;24093:34;24073:18;;;24066:62;24164:4;24144:18;;;24137:32;24186:19;;61038:68:0;23813:398:1;61038:68:0;61119:18;;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;61171:32;;691:25:1;;;61171:32:0;;664:18:1;61171:32:0;;;;;;;60831:380;;;:::o;67795:5157::-;67927:18;;;67919:68;;;;;;;24418:2:1;67919:68:0;;;24400:21:1;24457:2;24437:18;;;24430:30;24496:34;24476:18;;;24469:62;24567:7;24547:18;;;24540:35;24592:19;;67919:68:0;24216:401:1;67919:68:0;68006:16;;;67998:64;;;;;;;24824:2:1;67998:64:0;;;24806:21:1;24863:2;24843:18;;;24836:30;24902:34;24882:18;;;24875:62;24973:5;24953:18;;;24946:33;24996:19;;67998:64:0;24622:399:1;67998:64:0;68079:6;68089:1;68079:11;68075:93;;68107:28;68123:4;68129:2;68133:1;68107:15;:28::i;:::-;67795:5157;;;:::o;68075:93::-;68184:29;;;;;;;:25;:29;;;;;;;;;:64;;-1:-1:-1;68217:31:0;;;;;;;:25;:31;;;;;;;;68184:64;68180:4677;;;68314:4;68265:28;57046:18;;;;;;;;;;;68374;;68350:42;;;;;68431:12;;68350:42;;68482:39;;-1:-1:-1;68511:10:0;;;;;;;68510:11;68482:39;:90;;;;-1:-1:-1;68543:24:0;;;;:11;:24;;;;;;68570:1;-1:-1:-1;68482:90:0;:143;;;;-1:-1:-1;68594:31:0;;;;;;;:25;:31;;;;;;;;68593:32;68482:143;:190;;;;-1:-1:-1;68647:25:0;;;;;;;:19;:25;;;;;;;;68646:26;68482:190;:235;;;;-1:-1:-1;68694:23:0;;;;;;;:19;:23;;;;;;;;68693:24;68482:235;68460:442;;;68752:10;:17;;;;;;;;68790:10;:8;:10::i;:::-;68823:24;;;;:11;:24;;;;;68821:26;;68823:24;;;68821:26;;;:::i;:::-;;;;-1:-1:-1;68868:10:0;:18;;;;;;68460:442;68934:10;;68965:25;;;68918:12;68965:25;;;:19;:25;;;;;;68934:10;;;;;;;68933:11;;68965:25;;:52;;-1:-1:-1;68994:23:0;;;;;;;:19;:23;;;;;;;;68965:52;68961:108;;;-1:-1:-1;69048:5:0;68961:108;69349:7;69345:2100;;;69524:29;;;69377:12;69524:29;;;:25;:29;;;;;;69377:12;;;;69524:29;;:50;;;;;69573:1;69557:13;;:17;69524:50;69520:1483;;;69633:4;69616:13;;69607:6;:22;;;;:::i;:::-;69606:31;;;;:::i;:::-;69599:38;;69692:13;;69677:11;;69670:4;:18;;;;:::i;:::-;69669:36;;;;:::i;:::-;69660:45;-1:-1:-1;69741:13:0;69660:45;69741:4;:13;:::i;:::-;70046:11;:13;;69728:26;;-1:-1:-1;70046:11:0;:13;;;:::i;:::-;;;;-1:-1:-1;;70112:13:0;;;;70082:17;57046:18;;;;;;;;;;;;70153:11;;;70149:533;;70240:4;70228:9;:16;:36;;;;;70263:1;70248:11;;:16;;70228:36;70227:109;;;;70311:4;70299:9;:16;:36;;;;;70334:1;70319:11;;:16;;70299:36;70227:179;;;;70382:3;70370:9;:15;:35;;;;;70404:1;70389:11;;:16;;70370:35;70227:249;;;;70452:2;70440:9;:14;:35;;;;;70473:2;70458:11;;:17;;70440:35;70193:466;;;70549:1;70535:11;:15;70590:1;;-1:-1:-1;70622:9:0;70590:1;70622:9;;:::i;:::-;;;70193:466;69576:1125;69520:1483;;;70755:31;;;;;;;:25;:31;;;;;;;;:51;;;;;70805:1;70790:12;;:16;70755:51;70751:252;;;70864:4;70848:12;;70839:6;:21;;;;:::i;:::-;70838:30;;;;:::i;:::-;70831:37;;70922:12;;70908:10;;70901:4;:17;;;;:::i;:::-;70900:34;;;;:::i;:::-;70891:43;-1:-1:-1;70970:13:0;70891:43;70970:4;:13;:::i;:::-;70957:26;;70751:252;71027:14;;71023:180;;71066:48;71082:4;71096;71103:10;71066:15;:48::i;:::-;71137:46;71151:4;71165;71172:10;71137:13;:46::i;:::-;71227:10;;71223:172;;71262:46;71278:4;71292:6;71301;71262:15;:46::i;:::-;71331:44;71345:4;71359:6;71368;71331:13;:44::i;:::-;71415:14;71425:4;71415:14;;:::i;:::-;;;69358:2087;;;69345:2100;71465:14;;;;71461:1385;;;71534:5;;;71526:13;;;71534:5;;;;;71526:13;;;;:49;;-1:-1:-1;71570:5:0;;;71564:11;;;71570:5;;;;;71564:11;;71526:49;:90;;;;-1:-1:-1;71600:16:0;;;;;71526:90;:136;;;;-1:-1:-1;71641:21:0;;;71655:6;71641:21;;71526:136;:172;;;;-1:-1:-1;71688:10:0;;;;;;;71687:11;71526:172;71500:1331;;;71746:13;;;;;;;71741:276;;71826:25;;;;;;;:19;:25;;;;;;;;;:85;;-1:-1:-1;71888:23:0;;;;;;;:19;:23;;;;;;;;71826:85;71788:205;;;;;;;25859:2:1;71788:205:0;;;25841:21:1;25898:2;25878:18;;;25871:30;25937:24;25917:18;;;25910:52;25979:18;;71788:205:0;25657:346:1;71788:205:0;72071:31;;;;;;;:25;:31;;;;;;;;:96;;;;-1:-1:-1;72132:35:0;;;;;;;:31;:35;;;;;;;;72131:36;72071:96;72041:771;;;72266:20;;72256:6;:30;;72218:181;;;;;;;26210:2:1;72218:181:0;;;26192:21:1;26249:2;26229:18;;;26222:30;26288:34;26268:18;;;26261:62;26359:23;26339:18;;;26332:51;26400:19;;72218:181:0;26008:417:1;72218:181:0;72041:771;;;72459:29;;;;;;;:25;:29;;;;;;;;:96;;;;-1:-1:-1;72518:37:0;;;;;;;:31;:37;;;;;;;;72517:38;72459:96;72429:383;;;72654:20;;72644:6;:30;;72606:182;;;;;;;26632:2:1;72606:182:0;;;26614:21:1;26671:2;26651:18;;;26644:30;26710:34;26690:18;;;26683:62;26781:24;26761:18;;;26754:52;26823:19;;72606:182:0;26430:418:1;72606:182:0;68250:4607;;;;68180:4677;72869:33;72885:4;72891:2;72895:6;72869:15;:33::i;:::-;72913:31;72927:4;72933:2;72937:6;72913:13;:31::i;59047:770::-;59187:20;;;59179:70;;;;;;;24418:2:1;59179:70:0;;;24400:21:1;24457:2;24437:18;;;24430:30;24496:34;24476:18;;;24469:62;24567:7;24547:18;;;24540:35;24592:19;;59179:70:0;24216:401:1;59179:70:0;59268:23;;;59260:71;;;;;;;24824:2:1;59260:71:0;;;24806:21:1;24863:2;24843:18;;;24836:30;24902:34;24882:18;;;24875:62;24973:5;24953:18;;;24946:33;24996:19;;59260:71:0;24622:399:1;59260:71:0;59428:17;;;59404:21;59428:17;;;;;;;;;;;59478:23;;;;59456:111;;;;;;;27055:2:1;59456:111:0;;;27037:21:1;27094:2;27074:18;;;27067:30;27133:34;27113:18;;;27106:62;27204:8;27184:18;;;27177:36;27230:19;;59456:111:0;26853:402:1;59456:111:0;59603:17;;;;:9;:17;;;;;;;;;;;59623:22;;;59603:42;;59667:20;;;;;;;;:30;;59639:6;;59603:9;59667:30;;59639:6;;59667:30;:::i;:::-;;;;;;;;59732:9;59715:35;;59724:6;59715:35;;;59743:6;59715:35;;;;691:25:1;;679:2;664:18;;545:177;59715:35:0;;;;;;;;59763:46;67795:5157;55291:499;55436:12;;;;;;;:6;:12;;;;;;;;35383:10;35392:1;35383:10;;;;;35372:22;;;;;;;;35399:12;;;35372:40;35416:1;35371:46;55432:288;;;55473:12;;;;;;;;:6;:12;;;;;;;;35875:10;35884:1;35875:10;;;;;35864:22;;;;;;;;;:48;;35892:1;35898:12;;;35892:19;;;;35890:22;;35864:48;;;;;55510:10;;;;;;;;;;;35665:22;;;;;;;;;:47;;;;;;;55549:22;;55545:78;;55603:4;55592:15;;55545:78;55644:41;;;27471:6:1;27459:19;;27441:38;;55683:1:0;27510:2:1;27495:18;;27488:34;55644:41:0;;;;;;;;;;;;;;;27414:18:1;55644:41:0;;;;;;;55702:7;;55432:288;55739:43;;;;;;;;;;;;;;67362:188;67445:31;;;;;;;:25;:31;;;;;;:39;;;;;;;;;;;;;67502:40;;67445:39;;:31;67502:40;;;67362:188;;:::o;22889:718::-;22945:13;22996:14;23013:17;23024:5;23013:10;:17::i;:::-;23033:1;23013:21;22996:38;;23049:20;23083:6;23072:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;23072:18:0;-1:-1:-1;23049:41:0;-1:-1:-1;23214:28:0;;;23230:2;23214:28;23271:290;23303:5;;23445:10;23440:2;23429:14;;23424:32;23303:5;23411:46;23503:2;23494:11;;;-1:-1:-1;23524:21:0;23271:290;23524:21;-1:-1:-1;23582:6:0;22889:718;-1:-1:-1;;;22889:718:0:o;74400:525::-;74457:4;74474:17;74501:3;74494;:10;;:24;;;;;74515:3;74508;:10;;74494:24;74474:44;;74529:16;74555:4;74548:3;:11;;:26;;;;;74570:4;74563:3;:11;;74548:26;74529:45;;74590:12;74589:13;:29;;;;;74607:11;74606:12;74589:29;74585:74;;;-1:-1:-1;74642:5:0;;74400:525;-1:-1:-1;;;74400:525:0:o;74585:74::-;74690:3;74671:16;74735:143;74742:7;;74735:143;;74766:13;74782:8;74788:2;74782:3;:8;:::i;:::-;74766:24;-1:-1:-1;74766:24:0;74816:13;:8;74827:2;74816:13;:::i;:::-;:21;;;;:::i;:::-;74805:32;-1:-1:-1;74858:8:0;74864:2;74858:3;:8;:::i;:::-;74852:14;;74751:127;74735:143;;;74897:20;;74400:525;-1:-1:-1;;;;74400:525:0:o;3772:1702::-;3870:11;;3830:13;;3856:11;3896:8;;;3892:23;;-1:-1:-1;;3906:9:0;;;;;;;;;-1:-1:-1;3906:9:0;;;3772:1702;-1:-1:-1;3772:1702:0:o;3892:23::-;3928:18;3966:1;3955:7;:3;3961:1;3955:7;:::i;:::-;3954:13;;;;:::i;:::-;3949:19;;:1;:19;:::i;:::-;3928:40;-1:-1:-1;3979:19:0;4011:15;3928:40;4024:2;4011:15;:::i;:::-;4001:26;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4001:26:0;;3979:48;;4040:18;4061:5;;;;;;;;;;;;;;;;;4040:26;;4130:1;4123:5;4119:13;4175:2;4167:6;4163:15;4226:1;4194:958;4249:3;4246:1;4243:10;4194:958;;;4304:1;4347:12;;;;;4341:19;4442:4;4430:2;4426:14;;;;;4408:40;;4402:47;4594:2;4590:14;;;4586:25;;4572:40;;4566:47;4784:1;4780:13;;;4776:24;;4762:39;;4756:46;4965:16;;;;4951:31;;4945:38;4478:1;4474:11;;;4615:4;4562:58;;;4510:129;4664:11;;4752:57;;;4700:128;;;;4853:11;;4941:49;;4889:120;5038:3;5034:13;5067:22;;5135:1;5120:17;;;;4297:9;4194:958;;;4198:44;5184:1;5179:3;5175:11;5205:1;5200:84;;;;5303:1;5298:82;;;;5168:212;;5200:84;5252:16;5233:17;;;5226:43;5200:84;;5298:82;5350:14;5331:17;;;5324:41;5168:212;-1:-1:-1;;;5396:26:0;;;5403:6;3772:1702;-1:-1:-1;;;;3772:1702:0:o;64799:361::-;64881:62;64898:4;64913:15;64931:11;64881:8;:62::i;:::-;65106:5;;64956:196;;;;;65028:4;64956:196;;;27836:74:1;27926:18;;;27919:34;;;65074:1:0;27969:18:1;;;27962:34;;;28012:18;;;28005:34;65106:5:0;;;;64956:31;65106:5;;;28055:19:1;;;28048:84;65126:15:0;28148:19:1;;;28141:35;64956:15:0;:31;;;;64995:9;;27808:19:1;;64956:196:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;64799:361;;:::o;78045:337::-;78156:7;78197:5;78185:17;;:8;:17;;;:55;;;-1:-1:-1;78206:24:0;;;;;;;;:17;:24;;;;;;;;:34;;;;;;;;;;;;78185:55;78181:173;;;-1:-1:-1;78264:1:0;78257:8;;78181:173;57468:18;;;;78316:1;57468:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;78287:30;78283:71;;-1:-1:-1;78341:1:0;78334:8;;72960:517;73043:4;72999:23;57046:18;;;;;;;;;;;;73089:20;;;73085:59;;73126:7;;72960:517::o;73085:59::-;73178:13;;73160:15;:31;73156:95;;;73226:13;;73208:31;;73156:95;73292:15;73320:36;73292:15;73320:16;:36::i;:::-;73391:14;;73383:86;;73391:14;;;;;73433:21;;73383:86;;;;73433:21;73391:14;73383:86;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;72960:517:0:o;54471:812::-;54604:19;;;54590:11;54604:19;;;:13;:19;;;;;;;54674:12;;54646:8;;:23;;54664:5;54665:4;54664:5;:::i;:::-;54646:23;;;54657:4;54646:23;54638:48;54634:351;;54707:4;54715:1;54707:9;54703:271;;54744:21;54752:12;54744:21;:::i;:::-;54784:19;;;;;;;:13;:19;;;;;:26;;;54737:28;-1:-1:-1;54703:271:0;;;54865:1;54858:4;:8;:55;;54900:12;54858:55;;;54869:21;54877:12;54869:21;:::i;:::-;54932:19;;;;;;;:13;:19;;;;;:26;;;54851:62;-1:-1:-1;54703:271:0;54997:10;55017:1;55010:4;:8;:27;;55025:12;;55010:27;;;55021:1;55010:27;54997:40;-1:-1:-1;55055:9:0;55050:226;55074:6;55070:1;:10;55050:226;;;55107:26;55118:4;55124;55130:2;55107:10;:26::i;:::-;55150:12;;;;;;;:6;:12;;;;;;;;35884:1;35875:10;;;35864:22;;;;;;;:48;;35892:1;35906:4;35898:12;;35892:19;35890:22;35864:48;;;55102:31;-1:-1:-1;55187:10:0;;;;;;;:6;:10;;;;;;;;35685:1;35676:10;;;35665:22;;;;;;;:47;;35692:1;35706:4;35698:12;;35692:19;35665:47;;;55227:37;;;29236:25:1;;;55262:1:0;29292:2:1;29277:18;;29270:34;55227:37:0;;;;;;;;;;;;;29209:18:1;55227:37:0;;;;;;;55082:3;;55050:226;;19258:922;19311:7;;19398:6;19389:15;;19385:102;;19434:6;19425:15;;;-1:-1:-1;19469:2:0;19459:12;19385:102;19514:6;19505:5;:15;19501:102;;19550:6;19541:15;;;-1:-1:-1;19585:2:0;19575:12;19501:102;19630:6;19621:5;:15;19617:102;;19666:6;19657:15;;;-1:-1:-1;19701:2:0;19691:12;19617:102;19746:5;19737;:14;19733:99;;19781:5;19772:14;;;-1:-1:-1;19815:1:0;19805:11;19733:99;19859:5;19850;:14;19846:99;;19894:5;19885:14;;;-1:-1:-1;19928:1:0;19918:11;19846:99;19972:5;19963;:14;19959:99;;20007:5;19998:14;;;-1:-1:-1;20041:1:0;20031:11;19959:99;20085:5;20076;:14;20072:66;;20121:1;20111:11;20166:6;19258:922;-1:-1:-1;;19258:922:0:o;73485:475::-;73575:16;;;73589:1;73575:16;;;;;;;;73551:21;;73575:16;;;;;;;;;;-1:-1:-1;73575:16:0;73551:40;;73620:4;73602;73607:1;73602:7;;;;;;;;:::i;:::-;;;;;;:23;;;;;;;;;;;73646:15;:20;;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;73636:4;73641:1;73636:7;;;;;;;;:::i;:::-;;;;;;:32;;;;;;;;;;;73681:62;73698:4;73713:15;73731:11;73681:8;:62::i;:::-;73756:196;;;;;:66;:15;:66;;;;:196;;73837:11;;73863:1;;73879:4;;73906;;73926:15;;73756:196;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53820:532;53940:7;53971:1;53964:4;:8;53960:200;;;54006:6;53989:160;54019:12;;54014:1;:17;53989:160;;54061:13;;;;;;;:6;:13;;;;;;;;35392:1;35383:10;;;35372:22;;;;;;;;35407:4;35399:12;;35372:40;35416:1;35371:46;54057:77;;;54113:1;-1:-1:-1;54106:8:0;;54057:77;54033:3;;;:::i;:::-;;;53989:160;;;;53960:200;54189:6;54172:132;54197:5;;54172:132;;54228:13;;;;;;;:6;:13;;;;;;;;35392:1;35383:10;;;35372:22;;;;;;;;35407:4;35399:12;;35372:40;35416:1;35371:46;54224:69;;;54276:1;-1:-1:-1;54269:8:0;;54224:69;54204:3;;;:::i;:::-;;;54172:132;;;;54323:21;;;;;;;;;;;;;;14:154:1;100:42;93:5;89:54;82:5;79:65;69:93;;158:1;155;148:12;69:93;14:154;:::o;173:367::-;241:6;249;302:2;290:9;281:7;277:23;273:32;270:52;;;318:1;315;308:12;270:52;357:9;344:23;376:31;401:5;376:31;:::i;:::-;426:5;504:2;489:18;;;;476:32;;-1:-1:-1;;;173:367:1:o;727:177::-;812:66;805:5;801:78;794:5;791:89;781:117;;894:1;891;884:12;909:245;967:6;1020:2;1008:9;999:7;995:23;991:32;988:52;;;1036:1;1033;1026:12;988:52;1075:9;1062:23;1094:30;1118:5;1094:30;:::i;1351:346::-;1419:6;1427;1480:2;1468:9;1459:7;1455:23;1451:32;1448:52;;;1496:1;1493;1486:12;1448:52;-1:-1:-1;;1541:23:1;;;1661:2;1646:18;;;1633:32;;-1:-1:-1;1351:346:1:o;1702:477::-;1851:2;1840:9;1833:21;1814:4;1883:6;1877:13;1926:6;1921:2;1910:9;1906:18;1899:34;1985:6;1980:2;1972:6;1968:15;1963:2;1952:9;1948:18;1942:50;2041:1;2036:2;2027:6;2016:9;2012:22;2008:31;2001:42;2170:2;2100:66;2095:2;2087:6;2083:15;2079:88;2068:9;2064:104;2060:113;2052:121;;;1702:477;;;;:::o;2184:226::-;2243:6;2296:2;2284:9;2275:7;2271:23;2267:32;2264:52;;;2312:1;2309;2302:12;2264:52;-1:-1:-1;2357:23:1;;2184:226;-1:-1:-1;2184:226:1:o;2415:247::-;2474:6;2527:2;2515:9;2506:7;2502:23;2498:32;2495:52;;;2543:1;2540;2533:12;2495:52;2582:9;2569:23;2601:31;2626:5;2601:31;:::i;2925:184::-;2977:77;2974:1;2967:88;3074:4;3071:1;3064:15;3098:4;3095:1;3088:15;3114:1063;3183:6;3236:2;3224:9;3215:7;3211:23;3207:32;3204:52;;;3252:1;3249;3242:12;3204:52;3292:9;3279:23;3325:18;3317:6;3314:30;3311:50;;;3357:1;3354;3347:12;3311:50;3380:22;;3433:4;3425:13;;3421:27;-1:-1:-1;3411:55:1;;3462:1;3459;3452:12;3411:55;3502:2;3489:16;3528:18;3520:6;3517:30;3514:56;;;3550:18;;:::i;:::-;3599:2;3593:9;3746:66;3741:2;3672:66;3665:4;3657:6;3653:17;3649:90;3645:99;3641:172;3633:6;3629:185;3880:6;3868:10;3865:22;3844:18;3832:10;3829:34;3826:62;3823:88;;;3891:18;;:::i;:::-;3927:2;3920:22;3951;;;3992:15;;;4009:2;3988:24;3985:37;-1:-1:-1;3982:57:1;;;4035:1;4032;4025:12;3982:57;4091:6;4086:2;4082;4078:11;4073:2;4065:6;4061:15;4048:50;4144:1;4118:19;;;4139:2;4114:28;4107:39;;;;4122:6;3114:1063;-1:-1:-1;;;;3114:1063:1:o;4182:508::-;4259:6;4267;4275;4328:2;4316:9;4307:7;4303:23;4299:32;4296:52;;;4344:1;4341;4334:12;4296:52;4383:9;4370:23;4402:31;4427:5;4402:31;:::i;:::-;4452:5;-1:-1:-1;4509:2:1;4494:18;;4481:32;4522:33;4481:32;4522:33;:::i;:::-;4182:508;;4574:7;;-1:-1:-1;;;4654:2:1;4639:18;;;;4626:32;;4182:508::o;4926:367::-;4989:8;4999:6;5053:3;5046:4;5038:6;5034:17;5030:27;5020:55;;5071:1;5068;5061:12;5020:55;-1:-1:-1;5094:20:1;;5137:18;5126:30;;5123:50;;;5169:1;5166;5159:12;5123:50;5206:4;5198:6;5194:17;5182:29;;5266:3;5259:4;5249:6;5246:1;5242:14;5234:6;5230:27;5226:38;5223:47;5220:67;;;5283:1;5280;5273:12;5220:67;4926:367;;;;;:::o;5298:347::-;5349:8;5359:6;5413:3;5406:4;5398:6;5394:17;5390:27;5380:55;;5431:1;5428;5421:12;5380:55;-1:-1:-1;5454:20:1;;5497:18;5486:30;;5483:50;;;5529:1;5526;5519:12;5483:50;5566:4;5558:6;5554:17;5542:29;;5618:3;5611:4;5602:6;5594;5590:19;5586:30;5583:39;5580:59;;;5635:1;5632;5625:12;5650:1349;5810:6;5818;5826;5834;5842;5850;5858;5866;5919:3;5907:9;5898:7;5894:23;5890:33;5887:53;;;5936:1;5933;5926:12;5887:53;5975:9;5962:23;5994:31;6019:5;5994:31;:::i;:::-;6044:5;-1:-1:-1;6101:2:1;6086:18;;6073:32;6114:33;6073:32;6114:33;:::i;:::-;6166:7;-1:-1:-1;6224:2:1;6209:18;;6196:32;6251:18;6240:30;;6237:50;;;6283:1;6280;6273:12;6237:50;6322:70;6384:7;6375:6;6364:9;6360:22;6322:70;:::i;:::-;6411:8;;-1:-1:-1;6296:96:1;-1:-1:-1;;6499:2:1;6484:18;;6471:32;6528:18;6515:32;;6512:52;;;6560:1;6557;6550:12;6512:52;6599:72;6663:7;6652:8;6641:9;6637:24;6599:72;:::i;:::-;6690:8;;-1:-1:-1;6573:98:1;-1:-1:-1;;6778:3:1;6763:19;;6750:33;6808:18;6795:32;;6792:52;;;6840:1;6837;6830:12;6792:52;6879:60;6931:7;6920:8;6909:9;6905:24;6879:60;:::i;:::-;5650:1349;;;;-1:-1:-1;5650:1349:1;;-1:-1:-1;5650:1349:1;;;;;;6958:8;-1:-1:-1;;;5650:1349:1:o;7193:768::-;7315:6;7323;7331;7339;7392:2;7380:9;7371:7;7367:23;7363:32;7360:52;;;7408:1;7405;7398:12;7360:52;7448:9;7435:23;7481:18;7473:6;7470:30;7467:50;;;7513:1;7510;7503:12;7467:50;7552:70;7614:7;7605:6;7594:9;7590:22;7552:70;:::i;:::-;7641:8;;-1:-1:-1;7526:96:1;-1:-1:-1;;7729:2:1;7714:18;;7701:32;7758:18;7745:32;;7742:52;;;7790:1;7787;7780:12;7742:52;7829:72;7893:7;7882:8;7871:9;7867:24;7829:72;:::i;:::-;7193:768;;;;-1:-1:-1;7920:8:1;-1:-1:-1;;;;7193:768:1:o;7966:611::-;8156:2;8168:21;;;8238:13;;8141:18;;;8260:22;;;8108:4;;8339:15;;;8313:2;8298:18;;;8108:4;8382:169;8396:6;8393:1;8390:13;8382:169;;;8457:13;;8445:26;;8500:2;8526:15;;;;8491:12;;;;8418:1;8411:9;8382:169;;;-1:-1:-1;8568:3:1;;7966:611;-1:-1:-1;;;;;7966:611:1:o;8582:118::-;8668:5;8661:13;8654:21;8647:5;8644:32;8634:60;;8690:1;8687;8680:12;8705:382;8770:6;8778;8831:2;8819:9;8810:7;8806:23;8802:32;8799:52;;;8847:1;8844;8837:12;8799:52;8886:9;8873:23;8905:31;8930:5;8905:31;:::i;:::-;8955:5;-1:-1:-1;9012:2:1;8997:18;;8984:32;9025:30;8984:32;9025:30;:::i;:::-;9074:7;9064:17;;;8705:382;;;;;:::o;9092:415::-;9159:6;9167;9220:2;9208:9;9199:7;9195:23;9191:32;9188:52;;;9236:1;9233;9226:12;9188:52;9275:9;9262:23;9294:31;9319:5;9294:31;:::i;:::-;9344:5;-1:-1:-1;9401:2:1;9386:18;;9373:32;9449:6;9436:20;;9424:33;;9414:61;;9471:1;9468;9461:12;9512:388;9580:6;9588;9641:2;9629:9;9620:7;9616:23;9612:32;9609:52;;;9657:1;9654;9647:12;9609:52;9696:9;9683:23;9715:31;9740:5;9715:31;:::i;:::-;9765:5;-1:-1:-1;9822:2:1;9807:18;;9794:32;9835:33;9794:32;9835:33;:::i;9905:927::-;10011:6;10019;10027;10035;10043;10051;10104:3;10092:9;10083:7;10079:23;10075:33;10072:53;;;10121:1;10118;10111:12;10072:53;10160:9;10147:23;10179:31;10204:5;10179:31;:::i;:::-;10229:5;-1:-1:-1;10286:2:1;10271:18;;10258:32;10299:33;10258:32;10299:33;:::i;:::-;10351:7;-1:-1:-1;10431:2:1;10416:18;;10403:32;;-1:-1:-1;10534:2:1;10519:18;;10506:32;;-1:-1:-1;10615:3:1;10600:19;;10587:33;10643:18;10632:30;;10629:50;;;10675:1;10672;10665:12;10629:50;10714:58;10764:7;10755:6;10744:9;10740:22;10714:58;:::i;:::-;9905:927;;;;-1:-1:-1;9905:927:1;;-1:-1:-1;9905:927:1;;10791:8;;9905:927;-1:-1:-1;;;9905:927:1:o;10837:184::-;10889:77;10886:1;10879:88;10986:4;10983:1;10976:15;11010:4;11007:1;11000:15;11026:125;11091:9;;;11112:10;;;11109:36;;;11125:18;;:::i;11156:437::-;11235:1;11231:12;;;;11278;;;11299:61;;11353:4;11345:6;11341:17;11331:27;;11299:61;11406:2;11398:6;11395:14;11375:18;11372:38;11369:218;;11443:77;11440:1;11433:88;11544:4;11541:1;11534:15;11572:4;11569:1;11562:15;11369:218;;11156:437;;;:::o;11724:518::-;11826:2;11821:3;11818:11;11815:421;;;11862:5;11859:1;11852:16;11906:4;11903:1;11893:18;11976:2;11964:10;11960:19;11957:1;11953:27;11947:4;11943:38;12012:4;12000:10;11997:20;11994:47;;;-1:-1:-1;12035:4:1;11994:47;12090:2;12085:3;12081:12;12078:1;12074:20;12068:4;12064:31;12054:41;;12145:81;12163:2;12156:5;12153:13;12145:81;;;12222:1;12208:16;;12189:1;12178:13;12145:81;;12478:1418;12604:3;12598:10;12631:18;12623:6;12620:30;12617:56;;;12653:18;;:::i;:::-;12682:97;12772:6;12732:38;12764:4;12758:11;12732:38;:::i;:::-;12726:4;12682:97;:::i;:::-;12828:4;12859:2;12848:14;;12876:1;12871:768;;;;13683:1;13700:6;13697:89;;;-1:-1:-1;13752:19:1;;;13746:26;13697:89;12384:66;12375:1;12371:11;;;12367:84;12363:89;12353:100;12459:1;12455:11;;;12350:117;13799:81;;12841:1049;;12871:768;11671:1;11664:14;;;11708:4;11695:18;;12919:66;12907:79;;;13084:222;13098:7;13095:1;13092:14;13084:222;;;13180:19;;;13174:26;13159:42;;13287:4;13272:20;;;;13240:1;13228:14;;;;13114:12;13084:222;;;13088:3;13334:6;13325:7;13322:19;13319:261;;;13395:19;;;13389:26;13496:66;13478:1;13474:14;;;13490:3;13470:24;13466:97;13462:102;13447:118;13432:134;;13319:261;-1:-1:-1;;;;13626:1:1;13610:14;;;13606:22;13593:36;;-1:-1:-1;12478:1418:1:o;14310:184::-;14362:77;14359:1;14352:88;14459:4;14456:1;14449:15;14483:4;14480:1;14473:15;14499:230;14569:6;14622:2;14610:9;14601:7;14597:23;14593:32;14590:52;;;14638:1;14635;14628:12;14590:52;-1:-1:-1;14683:16:1;;14499:230;-1:-1:-1;14499:230:1:o;15443:245::-;15510:6;15563:2;15551:9;15542:7;15538:23;15534:32;15531:52;;;15579:1;15576;15569:12;15531:52;15611:9;15605:16;15630:28;15652:5;15630:28;:::i;16525:212::-;16567:3;16605:5;16599:12;16649:6;16642:4;16635:5;16631:16;16626:3;16620:36;16711:1;16675:16;;16700:13;;;-1:-1:-1;16675:16:1;;16525:212;-1:-1:-1;16525:212:1:o;16742:347::-;16963:3;16994:30;17020:3;17012:6;16994:30;:::i;:::-;17047:6;17033:21;;17081:1;17070:13;;16742:347;-1:-1:-1;;;16742:347:1:o;17094:184::-;17146:77;17143:1;17136:88;17243:4;17240:1;17233:15;17267:4;17264:1;17257:15;17283:112;17315:1;17341;17331:35;;17346:18;;:::i;:::-;-1:-1:-1;17380:9:1;;17283:112::o;17400:380::-;17652:66;17647:3;17640:79;17622:3;17735:39;17770:2;17765:3;17761:12;17753:6;17735:39;:::i;17785:829::-;18017:3;18045:30;18071:3;18063:6;18045:30;:::i;:::-;18095:66;18084:78;;18191:34;18186:2;18178:11;;18171:55;18255:34;18250:2;18242:11;;18235:55;18319:66;18314:2;18306:11;;18299:87;18416:66;18410:3;18402:12;;18395:88;18513:66;18507:3;18499:12;;18492:88;18604:3;18596:12;;17785:829;-1:-1:-1;;;17785:829:1:o;18619:930::-;18795:3;18824:1;18857:6;18851:13;18887:36;18913:9;18887:36;:::i;:::-;18954:1;18939:17;;18965:191;;;;19170:1;19165:332;;;;18932:565;;18965:191;19013:66;19002:9;18998:82;18993:3;18986:95;19136:6;19129:14;19122:22;19114:6;19110:35;19105:3;19101:45;19094:52;;18965:191;;19165:332;19196:6;19193:1;19186:17;19244:4;19241:1;19231:18;19271:1;19285:166;19299:6;19296:1;19293:13;19285:166;;;19379:14;;19366:11;;;19359:35;19435:1;19422:15;;;;19321:4;19314:12;19285:166;;;19289:3;;19480:6;19475:3;19471:16;19464:23;;18932:565;;;;19513:30;19539:3;19531:6;19513:30;:::i;:::-;19506:37;18619:930;-1:-1:-1;;;;;18619:930:1:o;19554:267::-;19733:3;19758:57;19784:30;19810:3;19802:6;19784:30;:::i;:::-;19776:6;19758:57;:::i;:::-;19751:64;19554:267;-1:-1:-1;;;;19554:267:1:o;19826:487::-;20088:66;20083:3;20076:79;20185:66;20180:2;20175:3;20171:12;20164:88;20058:3;20268:39;20303:2;20298:3;20294:12;20286:6;20268:39;:::i;20318:345::-;20570:31;20565:3;20558:44;20540:3;20618:39;20653:2;20648:3;20644:12;20636:6;20618:39;:::i;20668:251::-;20738:6;20791:2;20779:9;20770:7;20766:23;20762:32;20759:52;;;20807:1;20804;20797:12;20759:52;20839:9;20833:16;20858:31;20883:5;20858:31;:::i;21962:843::-;22251:42;22243:6;22239:55;22228:9;22221:74;22343:42;22335:6;22331:55;22326:2;22315:9;22311:18;22304:83;22423:6;22418:2;22407:9;22403:18;22396:34;22466:6;22461:2;22450:9;22446:18;22439:34;22510:3;22504;22493:9;22489:19;22482:32;22551:6;22545:3;22534:9;22530:19;22523:35;22609:6;22601;22595:3;22584:9;22580:19;22567:49;22666:1;22636:22;;;22660:3;22632:32;;;22625:43;;;;22720:2;22708:15;;;22725:66;22704:88;22689:104;22685:114;;21962:843;-1:-1:-1;;;;;21962:843:1:o;22810:249::-;22879:6;22932:2;22920:9;22911:7;22907:23;22903:32;22900:52;;;22948:1;22945;22938:12;22900:52;22980:9;22974:16;22999:30;23023:5;22999:30;:::i;25026:195::-;25065:3;25096:66;25089:5;25086:77;25083:103;;25166:18;;:::i;:::-;-1:-1:-1;25213:1:1;25202:13;;25026:195::o;25226:168::-;25299:9;;;25330;;25347:15;;;25341:22;;25327:37;25317:71;;25368:18;;:::i;25399:120::-;25439:1;25465;25455:35;;25470:18;;:::i;:::-;-1:-1:-1;25504:9:1;;25399:120::o;25524:128::-;25591:9;;;25612:11;;;25609:37;;;25626:18;;:::i;28187:456::-;28275:6;28283;28291;28344:2;28332:9;28323:7;28319:23;28315:32;28312:52;;;28360:1;28357;28350:12;28312:52;-1:-1:-1;;28405:16:1;;28511:2;28496:18;;28490:25;28607:2;28592:18;;;28586:25;28405:16;;28490:25;;-1:-1:-1;28586:25:1;28187:456;-1:-1:-1;28187:456:1:o;28858:191::-;28893:3;28924:66;28917:5;28914:77;28911:103;;28994:18;;:::i;:::-;-1:-1:-1;29034:1:1;29030:13;;28858:191::o;29315:1005::-;29577:4;29625:3;29614:9;29610:19;29656:6;29645:9;29638:25;29699:6;29694:2;29683:9;29679:18;29672:34;29742:3;29737:2;29726:9;29722:18;29715:31;29766:6;29801;29795:13;29832:6;29824;29817:22;29870:3;29859:9;29855:19;29848:26;;29909:2;29901:6;29897:15;29883:29;;29930:1;29940:218;29954:6;29951:1;29948:13;29940:218;;;30019:13;;30034:42;30015:62;30003:75;;30107:2;30133:15;;;;30098:12;;;;29976:1;29969:9;29940:218;;;-1:-1:-1;;30226:42:1;30214:55;;;;30209:2;30194:18;;30187:83;-1:-1:-1;;30301:3:1;30286:19;30279:35;30175:3;29315:1005;-1:-1:-1;;;29315:1005:1:o;30325:196::-;30364:3;30392:5;30382:39;;30401:18;;:::i;:::-;-1:-1:-1;30448:66:1;30437:78;;30325:196::o

ipfs://a7bd6c584209a90af8be28c15abe0d60fdd85d0ea06d4761feff6edc5ee08ccd