Token

Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.4;
import "./PRBMathUD60x18.sol";

contract VVV {
   address public owner;
   uint256 public balance;
   string public name ="Credits";
   string public symbol="VVV";
   uint256 public decimals=18;
   uint256 public totalSupply;
   uint256 public RegistryCount =0;
   uint256 public EntryFee=10000000000000000;
   
   mapping(address => uint256) public RankID;
   mapping(address => uint256) public CreditbalanceOf;
   mapping(address => uint256) public DebitbalanceOf;
   mapping(address => mapping(address => uint256)) public allowance;

   event Transfer(address indexed from, address indexed to, uint256 value);
   event Approval(address indexed owner, address indexed spender, uint256 value);
   event TransferReceived(address _from, uint _amount);
   event TransferSent(address _from, address _destAddr, uint _amount);

    constructor() {
        owner = msg.sender;
     }
     receive() payable external {
        Register();
    }   

   function Register() payable public {
        require(msg.value >= EntryFee,"Eth Sent must be greater than or equal to EntryFee.");
        if (RankID[msg.sender] == 0)
        {
            RegistryCount += 1;
            RankID[msg.sender] = RegistryCount;
            totalSupply = (RegistryCount * RegistryCount) * 1000000000000000000;
        }

        balance += msg.value;
   }

function balanceOf(address _to) public view returns (uint256) {
    uint256 TotalArea=1000000000000000000;
    uint256 RankArea=1000000000000000000;

    if (RankID[_to] > 1) 
    {
        RankArea = PRBMathUD60x18.ln(RankID[_to]*1000000000000000000) - PRBMathUD60x18.ln(RankID[_to]*1000000000000000000 - 1000000000000000000);
    }
    if (RankID[_to] == 0) 
    {
        RankArea=0;
    }
    TotalArea = PRBMathUD60x18.ln(RegistryCount*1000000000000000000) + 1000000000000000000;

    return PRBMathUD60x18.mul(PRBMathUD60x18.div(RankArea,TotalArea),totalSupply)+CreditbalanceOf[_to]-DebitbalanceOf[_to];
   }

 function transfer(address _to, uint256 _value) external returns (bool success) {
        require(balanceOf(msg.sender) >= _value);
        _transfer(msg.sender, _to, _value);
        return true;
    }

    function _transfer(address _from, address _to, uint256 _value) internal {
        require(_to != address(0));
 
        CreditbalanceOf[_to] = CreditbalanceOf[_to] + (_value);
        DebitbalanceOf[_from] = DebitbalanceOf[_from] + (_value);

        emit Transfer(_from, _to, _value);
    }

    function approve(address _spender, uint256 _value) external returns (bool) {
        require(_spender != address(0));
        allowance[msg.sender][_spender] = _value;
        emit Approval(msg.sender, _spender, _value);
        return true;
    }

    function transferFrom(address _from, address _to, uint256 _value) external returns (bool) {
        require(_value <= balanceOf(_from));
        require(_value <= allowance[_from][msg.sender]);
        allowance[_from][msg.sender] = allowance[_from][msg.sender] - (_value);
        _transfer(_from, _to, _value);
        return true;
    }

    function withdraw(uint amount, address payable destAddr) public {
        require(msg.sender == owner, "Only owner can withdraw funds"); 
        require(amount <= balance, "Insufficient funds");
        destAddr.transfer(amount);
        balance -= amount;
        emit TransferSent(msg.sender, destAddr, amount);
    }

    function updateFee(uint256 amount) public {
        require(msg.sender == owner, "Only owner can update EntryFee."); 
        EntryFee = amount;
    }
  
}

// SPDX-License-Identifier: Unlicense
pragma solidity >=0.8.4;

/// @notice Emitted when the result overflows uint256.
error PRBMath__MulDivFixedPointOverflow(uint256 prod1);

/// @notice Emitted when the result overflows uint256.
error PRBMath__MulDivOverflow(uint256 prod1, uint256 denominator);

/// @notice Emitted when one of the inputs is type(int256).min.
error PRBMath__MulDivSignedInputTooSmall();

/// @notice Emitted when the intermediary absolute result overflows int256.
error PRBMath__MulDivSignedOverflow(uint256 rAbs);

/// @notice Emitted when the input is MIN_SD59x18.
error PRBMathSD59x18__AbsInputTooSmall();

/// @notice Emitted when ceiling a number overflows SD59x18.
error PRBMathSD59x18__CeilOverflow(int256 x);

/// @notice Emitted when one of the inputs is MIN_SD59x18.
error PRBMathSD59x18__DivInputTooSmall();

/// @notice Emitted when one of the intermediary unsigned results overflows SD59x18.
error PRBMathSD59x18__DivOverflow(uint256 rAbs);

/// @notice Emitted when the input is greater than 133.084258667509499441.
error PRBMathSD59x18__ExpInputTooBig(int256 x);

/// @notice Emitted when the input is greater than 192.
error PRBMathSD59x18__Exp2InputTooBig(int256 x);

/// @notice Emitted when flooring a number underflows SD59x18.
error PRBMathSD59x18__FloorUnderflow(int256 x);

/// @notice Emitted when converting a basic integer to the fixed-point format overflows SD59x18.
error PRBMathSD59x18__FromIntOverflow(int256 x);

/// @notice Emitted when converting a basic integer to the fixed-point format underflows SD59x18.
error PRBMathSD59x18__FromIntUnderflow(int256 x);

/// @notice Emitted when the product of the inputs is negative.
error PRBMathSD59x18__GmNegativeProduct(int256 x, int256 y);

/// @notice Emitted when multiplying the inputs overflows SD59x18.
error PRBMathSD59x18__GmOverflow(int256 x, int256 y);

/// @notice Emitted when the input is less than or equal to zero.
error PRBMathSD59x18__LogInputTooSmall(int256 x);

/// @notice Emitted when one of the inputs is MIN_SD59x18.
error PRBMathSD59x18__MulInputTooSmall();

/// @notice Emitted when the intermediary absolute result overflows SD59x18.
error PRBMathSD59x18__MulOverflow(uint256 rAbs);

/// @notice Emitted when the intermediary absolute result overflows SD59x18.
error PRBMathSD59x18__PowuOverflow(uint256 rAbs);

/// @notice Emitted when the input is negative.
error PRBMathSD59x18__SqrtNegativeInput(int256 x);

/// @notice Emitted when the calculating the square root overflows SD59x18.
error PRBMathSD59x18__SqrtOverflow(int256 x);

/// @notice Emitted when addition overflows UD60x18.
error PRBMathUD60x18__AddOverflow(uint256 x, uint256 y);

/// @notice Emitted when ceiling a number overflows UD60x18.
error PRBMathUD60x18__CeilOverflow(uint256 x);

/// @notice Emitted when the input is greater than 133.084258667509499441.
error PRBMathUD60x18__ExpInputTooBig(uint256 x);

/// @notice Emitted when the input is greater than 192.
error PRBMathUD60x18__Exp2InputTooBig(uint256 x);

/// @notice Emitted when converting a basic integer to the fixed-point format format overflows UD60x18.
error PRBMathUD60x18__FromUintOverflow(uint256 x);

/// @notice Emitted when multiplying the inputs overflows UD60x18.
error PRBMathUD60x18__GmOverflow(uint256 x, uint256 y);

/// @notice Emitted when the input is less than 1.
error PRBMathUD60x18__LogInputTooSmall(uint256 x);

/// @notice Emitted when the calculating the square root overflows UD60x18.
error PRBMathUD60x18__SqrtOverflow(uint256 x);

/// @notice Emitted when subtraction underflows UD60x18.
error PRBMathUD60x18__SubUnderflow(uint256 x, uint256 y);

/// @dev Common mathematical functions used in both PRBMathSD59x18 and PRBMathUD60x18. Note that this shared library
/// does not always assume the signed 59.18-decimal fixed-point or the unsigned 60.18-decimal fixed-point
/// representation. When it does not, it is explicitly mentioned in the NatSpec documentation.
library PRBMath {
    /// STRUCTS ///

    struct SD59x18 {
        int256 value;
    }

    struct UD60x18 {
        uint256 value;
    }

    /// STORAGE ///

    /// @dev How many trailing decimals can be represented.
    uint256 internal constant SCALE = 1e18;

    /// @dev Largest power of two divisor of SCALE.
    uint256 internal constant SCALE_LPOTD = 262144;

    /// @dev SCALE inverted mod 2^256.
    uint256 internal constant SCALE_INVERSE =
        78156646155174841979727994598816262306175212592076161876661_508869554232690281;

    /// FUNCTIONS ///

    /// @notice Calculates the binary exponent of x using the binary fraction method.
    /// @dev Has to use 192.64-bit fixed-point numbers.
    /// See https://ethereum.stackexchange.com/a/96594/24693.
    /// @param x The exponent as an unsigned 192.64-bit fixed-point number.
    /// @return result The result as an unsigned 60.18-decimal fixed-point number.
    function exp2(uint256 x) internal pure returns (uint256 result) {
        unchecked {
            // Start from 0.5 in the 192.64-bit fixed-point format.
            result = 0x800000000000000000000000000000000000000000000000;

            // Multiply the result by root(2, 2^-i) when the bit at position i is 1. None of the intermediary results overflows
            // because the initial result is 2^191 and all magic factors are less than 2^65.
            if (x & 0x8000000000000000 > 0) {
                result = (result * 0x16A09E667F3BCC909) >> 64;
            }
            if (x & 0x4000000000000000 > 0) {
                result = (result * 0x1306FE0A31B7152DF) >> 64;
            }
            if (x & 0x2000000000000000 > 0) {
                result = (result * 0x1172B83C7D517ADCE) >> 64;
            }
            if (x & 0x1000000000000000 > 0) {
                result = (result * 0x10B5586CF9890F62A) >> 64;
            }
            if (x & 0x800000000000000 > 0) {
                result = (result * 0x1059B0D31585743AE) >> 64;
            }
            if (x & 0x400000000000000 > 0) {
                result = (result * 0x102C9A3E778060EE7) >> 64;
            }
            if (x & 0x200000000000000 > 0) {
                result = (result * 0x10163DA9FB33356D8) >> 64;
            }
            if (x & 0x100000000000000 > 0) {
                result = (result * 0x100B1AFA5ABCBED61) >> 64;
            }
            if (x & 0x80000000000000 > 0) {
                result = (result * 0x10058C86DA1C09EA2) >> 64;
            }
            if (x & 0x40000000000000 > 0) {
                result = (result * 0x1002C605E2E8CEC50) >> 64;
            }
            if (x & 0x20000000000000 > 0) {
                result = (result * 0x100162F3904051FA1) >> 64;
            }
            if (x & 0x10000000000000 > 0) {
                result = (result * 0x1000B175EFFDC76BA) >> 64;
            }
            if (x & 0x8000000000000 > 0) {
                result = (result * 0x100058BA01FB9F96D) >> 64;
            }
            if (x & 0x4000000000000 > 0) {
                result = (result * 0x10002C5CC37DA9492) >> 64;
            }
            if (x & 0x2000000000000 > 0) {
                result = (result * 0x1000162E525EE0547) >> 64;
            }
            if (x & 0x1000000000000 > 0) {
                result = (result * 0x10000B17255775C04) >> 64;
            }
            if (x & 0x800000000000 > 0) {
                result = (result * 0x1000058B91B5BC9AE) >> 64;
            }
            if (x & 0x400000000000 > 0) {
                result = (result * 0x100002C5C89D5EC6D) >> 64;
            }
            if (x & 0x200000000000 > 0) {
                result = (result * 0x10000162E43F4F831) >> 64;
            }
            if (x & 0x100000000000 > 0) {
                result = (result * 0x100000B1721BCFC9A) >> 64;
            }
            if (x & 0x80000000000 > 0) {
                result = (result * 0x10000058B90CF1E6E) >> 64;
            }
            if (x & 0x40000000000 > 0) {
                result = (result * 0x1000002C5C863B73F) >> 64;
            }
            if (x & 0x20000000000 > 0) {
                result = (result * 0x100000162E430E5A2) >> 64;
            }
            if (x & 0x10000000000 > 0) {
                result = (result * 0x1000000B172183551) >> 64;
            }
            if (x & 0x8000000000 > 0) {
                result = (result * 0x100000058B90C0B49) >> 64;
            }
            if (x & 0x4000000000 > 0) {
                result = (result * 0x10000002C5C8601CC) >> 64;
            }
            if (x & 0x2000000000 > 0) {
                result = (result * 0x1000000162E42FFF0) >> 64;
            }
            if (x & 0x1000000000 > 0) {
                result = (result * 0x10000000B17217FBB) >> 64;
            }
            if (x & 0x800000000 > 0) {
                result = (result * 0x1000000058B90BFCE) >> 64;
            }
            if (x & 0x400000000 > 0) {
                result = (result * 0x100000002C5C85FE3) >> 64;
            }
            if (x & 0x200000000 > 0) {
                result = (result * 0x10000000162E42FF1) >> 64;
            }
            if (x & 0x100000000 > 0) {
                result = (result * 0x100000000B17217F8) >> 64;
            }
            if (x & 0x80000000 > 0) {
                result = (result * 0x10000000058B90BFC) >> 64;
            }
            if (x & 0x40000000 > 0) {
                result = (result * 0x1000000002C5C85FE) >> 64;
            }
            if (x & 0x20000000 > 0) {
                result = (result * 0x100000000162E42FF) >> 64;
            }
            if (x & 0x10000000 > 0) {
                result = (result * 0x1000000000B17217F) >> 64;
            }
            if (x & 0x8000000 > 0) {
                result = (result * 0x100000000058B90C0) >> 64;
            }
            if (x & 0x4000000 > 0) {
                result = (result * 0x10000000002C5C860) >> 64;
            }
            if (x & 0x2000000 > 0) {
                result = (result * 0x1000000000162E430) >> 64;
            }
            if (x & 0x1000000 > 0) {
                result = (result * 0x10000000000B17218) >> 64;
            }
            if (x & 0x800000 > 0) {
                result = (result * 0x1000000000058B90C) >> 64;
            }
            if (x & 0x400000 > 0) {
                result = (result * 0x100000000002C5C86) >> 64;
            }
            if (x & 0x200000 > 0) {
                result = (result * 0x10000000000162E43) >> 64;
            }
            if (x & 0x100000 > 0) {
                result = (result * 0x100000000000B1721) >> 64;
            }
            if (x & 0x80000 > 0) {
                result = (result * 0x10000000000058B91) >> 64;
            }
            if (x & 0x40000 > 0) {
                result = (result * 0x1000000000002C5C8) >> 64;
            }
            if (x & 0x20000 > 0) {
                result = (result * 0x100000000000162E4) >> 64;
            }
            if (x & 0x10000 > 0) {
                result = (result * 0x1000000000000B172) >> 64;
            }
            if (x & 0x8000 > 0) {
                result = (result * 0x100000000000058B9) >> 64;
            }
            if (x & 0x4000 > 0) {
                result = (result * 0x10000000000002C5D) >> 64;
            }
            if (x & 0x2000 > 0) {
                result = (result * 0x1000000000000162E) >> 64;
            }
            if (x & 0x1000 > 0) {
                result = (result * 0x10000000000000B17) >> 64;
            }
            if (x & 0x800 > 0) {
                result = (result * 0x1000000000000058C) >> 64;
            }
            if (x & 0x400 > 0) {
                result = (result * 0x100000000000002C6) >> 64;
            }
            if (x & 0x200 > 0) {
                result = (result * 0x10000000000000163) >> 64;
            }
            if (x & 0x100 > 0) {
                result = (result * 0x100000000000000B1) >> 64;
            }
            if (x & 0x80 > 0) {
                result = (result * 0x10000000000000059) >> 64;
            }
            if (x & 0x40 > 0) {
                result = (result * 0x1000000000000002C) >> 64;
            }
            if (x & 0x20 > 0) {
                result = (result * 0x10000000000000016) >> 64;
            }
            if (x & 0x10 > 0) {
                result = (result * 0x1000000000000000B) >> 64;
            }
            if (x & 0x8 > 0) {
                result = (result * 0x10000000000000006) >> 64;
            }
            if (x & 0x4 > 0) {
                result = (result * 0x10000000000000003) >> 64;
            }
            if (x & 0x2 > 0) {
                result = (result * 0x10000000000000001) >> 64;
            }
            if (x & 0x1 > 0) {
                result = (result * 0x10000000000000001) >> 64;
            }

            // We're doing two things at the same time:
            //
            //   1. Multiply the result by 2^n + 1, where "2^n" is the integer part and the one is added to account for
            //      the fact that we initially set the result to 0.5. This is accomplished by subtracting from 191
            //      rather than 192.
            //   2. Convert the result to the unsigned 60.18-decimal fixed-point format.
            //
            // This works because 2^(191-ip) = 2^ip / 2^191, where "ip" is the integer part "2^n".
            result *= SCALE;
            result >>= (191 - (x >> 64));
        }
    }

    /// @notice Finds the zero-based index of the first one in the binary representation of x.
    /// @dev See the note on msb in the "Find First Set" Wikipedia article https://en.wikipedia.org/wiki/Find_first_set
    /// @param x The uint256 number for which to find the index of the most significant bit.
    /// @return msb The index of the most significant bit as an uint256.
    function mostSignificantBit(uint256 x) internal pure returns (uint256 msb) {
        if (x >= 2**128) {
            x >>= 128;
            msb += 128;
        }
        if (x >= 2**64) {
            x >>= 64;
            msb += 64;
        }
        if (x >= 2**32) {
            x >>= 32;
            msb += 32;
        }
        if (x >= 2**16) {
            x >>= 16;
            msb += 16;
        }
        if (x >= 2**8) {
            x >>= 8;
            msb += 8;
        }
        if (x >= 2**4) {
            x >>= 4;
            msb += 4;
        }
        if (x >= 2**2) {
            x >>= 2;
            msb += 2;
        }
        if (x >= 2**1) {
            // No need to shift x any more.
            msb += 1;
        }
    }

    /// @notice Calculates floor(x*y÷denominator) with full precision.
    ///
    /// @dev Credit to Remco Bloemen under MIT license https://xn--2-umb.com/21/muldiv.
    ///
    /// Requirements:
    /// - The denominator cannot be zero.
    /// - The result must fit within uint256.
    ///
    /// Caveats:
    /// - This function does not work with fixed-point numbers.
    ///
    /// @param x The multiplicand as an uint256.
    /// @param y The multiplier as an uint256.
    /// @param denominator The divisor as an uint256.
    /// @return result The result as an uint256.
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
        // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
        // variables such that product = prod1 * 2^256 + prod0.
        uint256 prod0; // Least significant 256 bits of the product
        uint256 prod1; // Most significant 256 bits of the product
        assembly {
            let mm := mulmod(x, y, not(0))
            prod0 := mul(x, y)
            prod1 := sub(sub(mm, prod0), lt(mm, prod0))
        }

        // Handle non-overflow cases, 256 by 256 division.
        if (prod1 == 0) {
            unchecked {
                result = prod0 / denominator;
            }
            return result;
        }

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

        ///////////////////////////////////////////////
        // 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.
        unchecked {
            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 lpotdod = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by lpotdod.
                denominator := div(denominator, lpotdod)

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

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

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

            // 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 floor(x*y÷1e18) with full precision.
    ///
    /// @dev Variant of "mulDiv" with constant folding, i.e. in which the denominator is always 1e18. Before returning the
    /// final result, we add 1 if (x * y) % SCALE >= HALF_SCALE. Without this, 6.6e-19 would be truncated to 0 instead of
    /// being rounded to 1e-18.  See "Listing 6" and text above it at https://accu.org/index.php/journals/1717.
    ///
    /// Requirements:
    /// - The result must fit within uint256.
    ///
    /// Caveats:
    /// - The body is purposely left uncommented; see the NatSpec comments in "PRBMath.mulDiv" to understand how this works.
    /// - It is assumed that the result can never be type(uint256).max when x and y solve the following two equations:
    ///     1. x * y = type(uint256).max * SCALE
    ///     2. (x * y) % SCALE >= SCALE / 2
    ///
    /// @param x The multiplicand as an unsigned 60.18-decimal fixed-point number.
    /// @param y The multiplier as an unsigned 60.18-decimal fixed-point number.
    /// @return result The result as an unsigned 60.18-decimal fixed-point number.
    function mulDivFixedPoint(uint256 x, uint256 y) internal pure returns (uint256 result) {
        uint256 prod0;
        uint256 prod1;
        assembly {
            let mm := mulmod(x, y, not(0))
            prod0 := mul(x, y)
            prod1 := sub(sub(mm, prod0), lt(mm, prod0))
        }

        if (prod1 >= SCALE) {
            revert PRBMath__MulDivFixedPointOverflow(prod1);
        }

        uint256 remainder;
        uint256 roundUpUnit;
        assembly {
            remainder := mulmod(x, y, SCALE)
            roundUpUnit := gt(remainder, 499999999999999999)
        }

        if (prod1 == 0) {
            unchecked {
                result = (prod0 / SCALE) + roundUpUnit;
                return result;
            }
        }

        assembly {
            result := add(
                mul(
                    or(
                        div(sub(prod0, remainder), SCALE_LPOTD),
                        mul(sub(prod1, gt(remainder, prod0)), add(div(sub(0, SCALE_LPOTD), SCALE_LPOTD), 1))
                    ),
                    SCALE_INVERSE
                ),
                roundUpUnit
            )
        }
    }

    /// @notice Calculates floor(x*y÷denominator) with full precision.
    ///
    /// @dev An extension of "mulDiv" for signed numbers. Works by computing the signs and the absolute values separately.
    ///
    /// Requirements:
    /// - None of the inputs can be type(int256).min.
    /// - The result must fit within int256.
    ///
    /// @param x The multiplicand as an int256.
    /// @param y The multiplier as an int256.
    /// @param denominator The divisor as an int256.
    /// @return result The result as an int256.
    function mulDivSigned(
        int256 x,
        int256 y,
        int256 denominator
    ) internal pure returns (int256 result) {
        if (x == type(int256).min || y == type(int256).min || denominator == type(int256).min) {
            revert PRBMath__MulDivSignedInputTooSmall();
        }

        // Get hold of the absolute values of x, y and the denominator.
        uint256 ax;
        uint256 ay;
        uint256 ad;
        unchecked {
            ax = x < 0 ? uint256(-x) : uint256(x);
            ay = y < 0 ? uint256(-y) : uint256(y);
            ad = denominator < 0 ? uint256(-denominator) : uint256(denominator);
        }

        // Compute the absolute value of (x*y)÷denominator. The result must fit within int256.
        uint256 rAbs = mulDiv(ax, ay, ad);
        if (rAbs > uint256(type(int256).max)) {
            revert PRBMath__MulDivSignedOverflow(rAbs);
        }

        // Get the signs of x, y and the denominator.
        uint256 sx;
        uint256 sy;
        uint256 sd;
        assembly {
            sx := sgt(x, sub(0, 1))
            sy := sgt(y, sub(0, 1))
            sd := sgt(denominator, sub(0, 1))
        }

        // XOR over sx, sy and sd. This is checking whether there are one or three negative signs in the inputs.
        // If yes, the result should be negative.
        result = sx ^ sy ^ sd == 0 ? -int256(rAbs) : int256(rAbs);
    }

    /// @notice Calculates the square root of x, rounding down.
    /// @dev Uses the Babylonian method https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method.
    ///
    /// Caveats:
    /// - This function does not work with fixed-point numbers.
    ///
    /// @param x The uint256 number for which to calculate the square root.
    /// @return result The result as an uint256.
    function sqrt(uint256 x) internal pure returns (uint256 result) {
        if (x == 0) {
            return 0;
        }

        // Set the initial guess to the least power of two that is greater than or equal to sqrt(x).
        uint256 xAux = uint256(x);
        result = 1;
        if (xAux >= 0x100000000000000000000000000000000) {
            xAux >>= 128;
            result <<= 64;
        }
        if (xAux >= 0x10000000000000000) {
            xAux >>= 64;
            result <<= 32;
        }
        if (xAux >= 0x100000000) {
            xAux >>= 32;
            result <<= 16;
        }
        if (xAux >= 0x10000) {
            xAux >>= 16;
            result <<= 8;
        }
        if (xAux >= 0x100) {
            xAux >>= 8;
            result <<= 4;
        }
        if (xAux >= 0x10) {
            xAux >>= 4;
            result <<= 2;
        }
        if (xAux >= 0x8) {
            result <<= 1;
        }

        // The operations can never overflow because the result is max 2^127 when it enters this block.
        unchecked {
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1; // Seven iterations should be enough
            uint256 roundedDownResult = x / result;
            return result >= roundedDownResult ? roundedDownResult : result;
        }
    }
}

// SPDX-License-Identifier: Unlicense
pragma solidity >=0.8.4;

import "./PRBMath.sol";

/// @title PRBMathUD60x18
/// @author Paul Razvan Berg
/// @notice Smart contract library for advanced fixed-point math that works with uint256 numbers considered to have 18
/// trailing decimals. We call this number representation unsigned 60.18-decimal fixed-point, since there can be up to 60
/// digits in the integer part and up to 18 decimals in the fractional part. The numbers are bound by the minimum and the
/// maximum values permitted by the Solidity type uint256.
library PRBMathUD60x18 {
    /// @dev Half the SCALE number.
    uint256 internal constant HALF_SCALE = 5e17;

    /// @dev log2(e) as an unsigned 60.18-decimal fixed-point number.
    uint256 internal constant LOG2_E = 1_442695040888963407;

    /// @dev The maximum value an unsigned 60.18-decimal fixed-point number can have.
    uint256 internal constant MAX_UD60x18 =
        115792089237316195423570985008687907853269984665640564039457_584007913129639935;

    /// @dev The maximum whole value an unsigned 60.18-decimal fixed-point number can have.
    uint256 internal constant MAX_WHOLE_UD60x18 =
        115792089237316195423570985008687907853269984665640564039457_000000000000000000;

    /// @dev How many trailing decimals can be represented.
    uint256 internal constant SCALE = 1e18;

    /// @notice Calculates the arithmetic average of x and y, rounding down.
    /// @param x The first operand as an unsigned 60.18-decimal fixed-point number.
    /// @param y The second operand as an unsigned 60.18-decimal fixed-point number.
    /// @return result The arithmetic average as an unsigned 60.18-decimal fixed-point number.
    function avg(uint256 x, uint256 y) internal pure returns (uint256 result) {
        // The operations can never overflow.
        unchecked {
            // The last operand checks if both x and y are odd and if that is the case, we add 1 to the result. We need
            // to do this because if both numbers are odd, the 0.5 remainder gets truncated twice.
            result = (x >> 1) + (y >> 1) + (x & y & 1);
        }
    }

    /// @notice Yields the least unsigned 60.18 decimal fixed-point number greater than or equal to x.
    ///
    /// @dev Optimized for fractional value inputs, because for every whole value there are (1e18 - 1) fractional counterparts.
    /// See https://en.wikipedia.org/wiki/Floor_and_ceiling_functions.
    ///
    /// Requirements:
    /// - x must be less than or equal to MAX_WHOLE_UD60x18.
    ///
    /// @param x The unsigned 60.18-decimal fixed-point number to ceil.
    /// @param result The least integer greater than or equal to x, as an unsigned 60.18-decimal fixed-point number.
    function ceil(uint256 x) internal pure returns (uint256 result) {
        if (x > MAX_WHOLE_UD60x18) {
            revert PRBMathUD60x18__CeilOverflow(x);
        }
        assembly {
            // Equivalent to "x % SCALE" but faster.
            let remainder := mod(x, SCALE)

            // Equivalent to "SCALE - remainder" but faster.
            let delta := sub(SCALE, remainder)

            // Equivalent to "x + delta * (remainder > 0 ? 1 : 0)" but faster.
            result := add(x, mul(delta, gt(remainder, 0)))
        }
    }

    /// @notice Divides two unsigned 60.18-decimal fixed-point numbers, returning a new unsigned 60.18-decimal fixed-point number.
    ///
    /// @dev Uses mulDiv to enable overflow-safe multiplication and division.
    ///
    /// Requirements:
    /// - The denominator cannot be zero.
    ///
    /// @param x The numerator as an unsigned 60.18-decimal fixed-point number.
    /// @param y The denominator as an unsigned 60.18-decimal fixed-point number.
    /// @param result The quotient as an unsigned 60.18-decimal fixed-point number.
    function div(uint256 x, uint256 y) internal pure returns (uint256 result) {
        result = PRBMath.mulDiv(x, SCALE, y);
    }

    /// @notice Returns Euler's number as an unsigned 60.18-decimal fixed-point number.
    /// @dev See https://en.wikipedia.org/wiki/E_(mathematical_constant).
    function e() internal pure returns (uint256 result) {
        result = 2_718281828459045235;
    }

    /// @notice Calculates the natural exponent of x.
    ///
    /// @dev Based on the insight that e^x = 2^(x * log2(e)).
    ///
    /// Requirements:
    /// - All from "log2".
    /// - x must be less than 133.084258667509499441.
    ///
    /// @param x The exponent as an unsigned 60.18-decimal fixed-point number.
    /// @return result The result as an unsigned 60.18-decimal fixed-point number.
    function exp(uint256 x) internal pure returns (uint256 result) {
        // Without this check, the value passed to "exp2" would be greater than 192.
        if (x >= 133_084258667509499441) {
            revert PRBMathUD60x18__ExpInputTooBig(x);
        }

        // Do the fixed-point multiplication inline to save gas.
        unchecked {
            uint256 doubleScaleProduct = x * LOG2_E;
            result = exp2((doubleScaleProduct + HALF_SCALE) / SCALE);
        }
    }

    /// @notice Calculates the binary exponent of x using the binary fraction method.
    ///
    /// @dev See https://ethereum.stackexchange.com/q/79903/24693.
    ///
    /// Requirements:
    /// - x must be 192 or less.
    /// - The result must fit within MAX_UD60x18.
    ///
    /// @param x The exponent as an unsigned 60.18-decimal fixed-point number.
    /// @return result The result as an unsigned 60.18-decimal fixed-point number.
    function exp2(uint256 x) internal pure returns (uint256 result) {
        // 2^192 doesn't fit within the 192.64-bit format used internally in this function.
        if (x >= 192e18) {
            revert PRBMathUD60x18__Exp2InputTooBig(x);
        }

        unchecked {
            // Convert x to the 192.64-bit fixed-point format.
            uint256 x192x64 = (x << 64) / SCALE;

            // Pass x to the PRBMath.exp2 function, which uses the 192.64-bit fixed-point number representation.
            result = PRBMath.exp2(x192x64);
        }
    }

    /// @notice Yields the greatest unsigned 60.18 decimal fixed-point number less than or equal to x.
    /// @dev Optimized for fractional value inputs, because for every whole value there are (1e18 - 1) fractional counterparts.
    /// See https://en.wikipedia.org/wiki/Floor_and_ceiling_functions.
    /// @param x The unsigned 60.18-decimal fixed-point number to floor.
    /// @param result The greatest integer less than or equal to x, as an unsigned 60.18-decimal fixed-point number.
    function floor(uint256 x) internal pure returns (uint256 result) {
        assembly {
            // Equivalent to "x % SCALE" but faster.
            let remainder := mod(x, SCALE)

            // Equivalent to "x - remainder * (remainder > 0 ? 1 : 0)" but faster.
            result := sub(x, mul(remainder, gt(remainder, 0)))
        }
    }

    /// @notice Yields the excess beyond the floor of x.
    /// @dev Based on the odd function definition https://en.wikipedia.org/wiki/Fractional_part.
    /// @param x The unsigned 60.18-decimal fixed-point number to get the fractional part of.
    /// @param result The fractional part of x as an unsigned 60.18-decimal fixed-point number.
    function frac(uint256 x) internal pure returns (uint256 result) {
        assembly {
            result := mod(x, SCALE)
        }
    }

    /// @notice Converts a number from basic integer form to unsigned 60.18-decimal fixed-point representation.
    ///
    /// @dev Requirements:
    /// - x must be less than or equal to MAX_UD60x18 divided by SCALE.
    ///
    /// @param x The basic integer to convert.
    /// @param result The same number in unsigned 60.18-decimal fixed-point representation.
    function fromUint(uint256 x) internal pure returns (uint256 result) {
        unchecked {
            if (x > MAX_UD60x18 / SCALE) {
                revert PRBMathUD60x18__FromUintOverflow(x);
            }
            result = x * SCALE;
        }
    }

    /// @notice Calculates geometric mean of x and y, i.e. sqrt(x * y), rounding down.
    ///
    /// @dev Requirements:
    /// - x * y must fit within MAX_UD60x18, lest it overflows.
    ///
    /// @param x The first operand as an unsigned 60.18-decimal fixed-point number.
    /// @param y The second operand as an unsigned 60.18-decimal fixed-point number.
    /// @return result The result as an unsigned 60.18-decimal fixed-point number.
    function gm(uint256 x, uint256 y) internal pure returns (uint256 result) {
        if (x == 0) {
            return 0;
        }

        unchecked {
            // Checking for overflow this way is faster than letting Solidity do it.
            uint256 xy = x * y;
            if (xy / x != y) {
                revert PRBMathUD60x18__GmOverflow(x, y);
            }

            // We don't need to multiply by the SCALE here because the x*y product had already picked up a factor of SCALE
            // during multiplication. See the comments within the "sqrt" function.
            result = PRBMath.sqrt(xy);
        }
    }

    /// @notice Calculates 1 / x, rounding toward zero.
    ///
    /// @dev Requirements:
    /// - x cannot be zero.
    ///
    /// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the inverse.
    /// @return result The inverse as an unsigned 60.18-decimal fixed-point number.
    function inv(uint256 x) internal pure returns (uint256 result) {
        unchecked {
            // 1e36 is SCALE * SCALE.
            result = 1e36 / x;
        }
    }

    /// @notice Calculates the natural logarithm of x.
    ///
    /// @dev Based on the insight that ln(x) = log2(x) / log2(e).
    ///
    /// Requirements:
    /// - All from "log2".
    ///
    /// Caveats:
    /// - All from "log2".
    /// - This doesn't return exactly 1 for 2.718281828459045235, for that we would need more fine-grained precision.
    ///
    /// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the natural logarithm.
    /// @return result The natural logarithm as an unsigned 60.18-decimal fixed-point number.
    function ln(uint256 x) internal pure returns (uint256 result) {
        // Do the fixed-point multiplication inline to save gas. This is overflow-safe because the maximum value that log2(x)
        // can return is 196205294292027477728.
        unchecked {
            result = (log2(x) * SCALE) / LOG2_E;
        }
    }

    /// @notice Calculates the common logarithm of x.
    ///
    /// @dev First checks if x is an exact power of ten and it stops if yes. If it's not, calculates the common
    /// logarithm based on the insight that log10(x) = log2(x) / log2(10).
    ///
    /// Requirements:
    /// - All from "log2".
    ///
    /// Caveats:
    /// - All from "log2".
    ///
    /// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the common logarithm.
    /// @return result The common logarithm as an unsigned 60.18-decimal fixed-point number.
    function log10(uint256 x) internal pure returns (uint256 result) {
        if (x < SCALE) {
            revert PRBMathUD60x18__LogInputTooSmall(x);
        }

        // Note that the "mul" in this block is the assembly multiplication operation, not the "mul" function defined
        // in this contract.
        // prettier-ignore
        assembly {
            switch x
            case 1 { result := mul(SCALE, sub(0, 18)) }
            case 10 { result := mul(SCALE, sub(1, 18)) }
            case 100 { result := mul(SCALE, sub(2, 18)) }
            case 1000 { result := mul(SCALE, sub(3, 18)) }
            case 10000 { result := mul(SCALE, sub(4, 18)) }
            case 100000 { result := mul(SCALE, sub(5, 18)) }
            case 1000000 { result := mul(SCALE, sub(6, 18)) }
            case 10000000 { result := mul(SCALE, sub(7, 18)) }
            case 100000000 { result := mul(SCALE, sub(8, 18)) }
            case 1000000000 { result := mul(SCALE, sub(9, 18)) }
            case 10000000000 { result := mul(SCALE, sub(10, 18)) }
            case 100000000000 { result := mul(SCALE, sub(11, 18)) }
            case 1000000000000 { result := mul(SCALE, sub(12, 18)) }
            case 10000000000000 { result := mul(SCALE, sub(13, 18)) }
            case 100000000000000 { result := mul(SCALE, sub(14, 18)) }
            case 1000000000000000 { result := mul(SCALE, sub(15, 18)) }
            case 10000000000000000 { result := mul(SCALE, sub(16, 18)) }
            case 100000000000000000 { result := mul(SCALE, sub(17, 18)) }
            case 1000000000000000000 { result := 0 }
            case 10000000000000000000 { result := SCALE }
            case 100000000000000000000 { result := mul(SCALE, 2) }
            case 1000000000000000000000 { result := mul(SCALE, 3) }
            case 10000000000000000000000 { result := mul(SCALE, 4) }
            case 100000000000000000000000 { result := mul(SCALE, 5) }
            case 1000000000000000000000000 { result := mul(SCALE, 6) }
            case 10000000000000000000000000 { result := mul(SCALE, 7) }
            case 100000000000000000000000000 { result := mul(SCALE, 8) }
            case 1000000000000000000000000000 { result := mul(SCALE, 9) }
            case 10000000000000000000000000000 { result := mul(SCALE, 10) }
            case 100000000000000000000000000000 { result := mul(SCALE, 11) }
            case 1000000000000000000000000000000 { result := mul(SCALE, 12) }
            case 10000000000000000000000000000000 { result := mul(SCALE, 13) }
            case 100000000000000000000000000000000 { result := mul(SCALE, 14) }
            case 1000000000000000000000000000000000 { result := mul(SCALE, 15) }
            case 10000000000000000000000000000000000 { result := mul(SCALE, 16) }
            case 100000000000000000000000000000000000 { result := mul(SCALE, 17) }
            case 1000000000000000000000000000000000000 { result := mul(SCALE, 18) }
            case 10000000000000000000000000000000000000 { result := mul(SCALE, 19) }
            case 100000000000000000000000000000000000000 { result := mul(SCALE, 20) }
            case 1000000000000000000000000000000000000000 { result := mul(SCALE, 21) }
            case 10000000000000000000000000000000000000000 { result := mul(SCALE, 22) }
            case 100000000000000000000000000000000000000000 { result := mul(SCALE, 23) }
            case 1000000000000000000000000000000000000000000 { result := mul(SCALE, 24) }
            case 10000000000000000000000000000000000000000000 { result := mul(SCALE, 25) }
            case 100000000000000000000000000000000000000000000 { result := mul(SCALE, 26) }
            case 1000000000000000000000000000000000000000000000 { result := mul(SCALE, 27) }
            case 10000000000000000000000000000000000000000000000 { result := mul(SCALE, 28) }
            case 100000000000000000000000000000000000000000000000 { result := mul(SCALE, 29) }
            case 1000000000000000000000000000000000000000000000000 { result := mul(SCALE, 30) }
            case 10000000000000000000000000000000000000000000000000 { result := mul(SCALE, 31) }
            case 100000000000000000000000000000000000000000000000000 { result := mul(SCALE, 32) }
            case 1000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 33) }
            case 10000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 34) }
            case 100000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 35) }
            case 1000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 36) }
            case 10000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 37) }
            case 100000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 38) }
            case 1000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 39) }
            case 10000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 40) }
            case 100000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 41) }
            case 1000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 42) }
            case 10000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 43) }
            case 100000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 44) }
            case 1000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 45) }
            case 10000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 46) }
            case 100000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 47) }
            case 1000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 48) }
            case 10000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 49) }
            case 100000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 50) }
            case 1000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 51) }
            case 10000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 52) }
            case 100000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 53) }
            case 1000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 54) }
            case 10000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 55) }
            case 100000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 56) }
            case 1000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 57) }
            case 10000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 58) }
            case 100000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 59) }
            default {
                result := MAX_UD60x18
            }
        }

        if (result == MAX_UD60x18) {
            // Do the fixed-point division inline to save gas. The denominator is log2(10).
            unchecked {
                result = (log2(x) * SCALE) / 3_321928094887362347;
            }
        }
    }

    /// @notice Calculates the binary logarithm of x.
    ///
    /// @dev Based on the iterative approximation algorithm.
    /// https://en.wikipedia.org/wiki/Binary_logarithm#Iterative_approximation
    ///
    /// Requirements:
    /// - x must be greater than or equal to SCALE, otherwise the result would be negative.
    ///
    /// Caveats:
    /// - The results are nor perfectly accurate to the last decimal, due to the lossy precision of the iterative approximation.
    ///
    /// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the binary logarithm.
    /// @return result The binary logarithm as an unsigned 60.18-decimal fixed-point number.
    function log2(uint256 x) internal pure returns (uint256 result) {
        if (x < SCALE) {
            revert PRBMathUD60x18__LogInputTooSmall(x);
        }
        unchecked {
            // Calculate the integer part of the logarithm and add it to the result and finally calculate y = x * 2^(-n).
            uint256 n = PRBMath.mostSignificantBit(x / SCALE);

            // The integer part of the logarithm as an unsigned 60.18-decimal fixed-point number. The operation can't overflow
            // because n is maximum 255 and SCALE is 1e18.
            result = n * SCALE;

            // This is y = x * 2^(-n).
            uint256 y = x >> n;

            // If y = 1, the fractional part is zero.
            if (y == SCALE) {
                return result;
            }

            // Calculate the fractional part via the iterative approximation.
            // The "delta >>= 1" part is equivalent to "delta /= 2", but shifting bits is faster.
            for (uint256 delta = HALF_SCALE; delta > 0; delta >>= 1) {
                y = (y * y) / SCALE;

                // Is y^2 > 2 and so in the range [2,4)?
                if (y >= 2 * SCALE) {
                    // Add the 2^(-m) factor to the logarithm.
                    result += delta;

                    // Corresponds to z/2 on Wikipedia.
                    y >>= 1;
                }
            }
        }
    }

    /// @notice Multiplies two unsigned 60.18-decimal fixed-point numbers together, returning a new unsigned 60.18-decimal
    /// fixed-point number.
    /// @dev See the documentation for the "PRBMath.mulDivFixedPoint" function.
    /// @param x The multiplicand as an unsigned 60.18-decimal fixed-point number.
    /// @param y The multiplier as an unsigned 60.18-decimal fixed-point number.
    /// @return result The product as an unsigned 60.18-decimal fixed-point number.
    function mul(uint256 x, uint256 y) internal pure returns (uint256 result) {
        result = PRBMath.mulDivFixedPoint(x, y);
    }

    /// @notice Returns PI as an unsigned 60.18-decimal fixed-point number.
    function pi() internal pure returns (uint256 result) {
        result = 3_141592653589793238;
    }

    /// @notice Raises x to the power of y.
    ///
    /// @dev Based on the insight that x^y = 2^(log2(x) * y).
    ///
    /// Requirements:
    /// - All from "exp2", "log2" and "mul".
    ///
    /// Caveats:
    /// - All from "exp2", "log2" and "mul".
    /// - Assumes 0^0 is 1.
    ///
    /// @param x Number to raise to given power y, as an unsigned 60.18-decimal fixed-point number.
    /// @param y Exponent to raise x to, as an unsigned 60.18-decimal fixed-point number.
    /// @return result x raised to power y, as an unsigned 60.18-decimal fixed-point number.
    function pow(uint256 x, uint256 y) internal pure returns (uint256 result) {
        if (x == 0) {
            result = y == 0 ? SCALE : uint256(0);
        } else {
            result = exp2(mul(log2(x), y));
        }
    }

    /// @notice Raises x (unsigned 60.18-decimal fixed-point number) to the power of y (basic unsigned integer) using the
    /// famous algorithm "exponentiation by squaring".
    ///
    /// @dev See https://en.wikipedia.org/wiki/Exponentiation_by_squaring
    ///
    /// Requirements:
    /// - The result must fit within MAX_UD60x18.
    ///
    /// Caveats:
    /// - All from "mul".
    /// - Assumes 0^0 is 1.
    ///
    /// @param x The base as an unsigned 60.18-decimal fixed-point number.
    /// @param y The exponent as an uint256.
    /// @return result The result as an unsigned 60.18-decimal fixed-point number.
    function powu(uint256 x, uint256 y) internal pure returns (uint256 result) {
        // Calculate the first iteration of the loop in advance.
        result = y & 1 > 0 ? x : SCALE;

        // Equivalent to "for(y /= 2; y > 0; y /= 2)" but faster.
        for (y >>= 1; y > 0; y >>= 1) {
            x = PRBMath.mulDivFixedPoint(x, x);

            // Equivalent to "y % 2 == 1" but faster.
            if (y & 1 > 0) {
                result = PRBMath.mulDivFixedPoint(result, x);
            }
        }
    }

    /// @notice Returns 1 as an unsigned 60.18-decimal fixed-point number.
    function scale() internal pure returns (uint256 result) {
        result = SCALE;
    }

    /// @notice Calculates the square root of x, rounding down.
    /// @dev Uses the Babylonian method https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method.
    ///
    /// Requirements:
    /// - x must be less than MAX_UD60x18 / SCALE.
    ///
    /// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the square root.
    /// @return result The result as an unsigned 60.18-decimal fixed-point .
    function sqrt(uint256 x) internal pure returns (uint256 result) {
        unchecked {
            if (x > MAX_UD60x18 / SCALE) {
                revert PRBMathUD60x18__SqrtOverflow(x);
            }
            // Multiply x by the SCALE to account for the factor of SCALE that is picked up when multiplying two unsigned
            // 60.18-decimal fixed-point numbers together (in this case, those two numbers are both the square root).
            result = PRBMath.sqrt(x * SCALE);
        }
    }

    /// @notice Converts a unsigned 60.18-decimal fixed-point number to basic integer form, rounding down in the process.
    /// @param x The unsigned 60.18-decimal fixed-point number to convert.
    /// @return result The same number in basic integer form.
    function toUint(uint256 x) internal pure returns (uint256 result) {
        unchecked {
            result = x / SCALE;
        }
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"uint256","name":"x","type":"uint256"}],"name":"PRBMathUD60x18__LogInputTooSmall","type":"error"},{"inputs":[{"internalType":"uint256","name":"prod1","type":"uint256"}],"name":"PRBMath__MulDivFixedPointOverflow","type":"error"},{"inputs":[{"internalType":"uint256","name":"prod1","type":"uint256"},{"internalType":"uint256","name":"denominator","type":"uint256"}],"name":"PRBMath__MulDivOverflow","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":"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":false,"internalType":"address","name":"_from","type":"address"},{"indexed":false,"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"TransferReceived","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_from","type":"address"},{"indexed":false,"internalType":"address","name":"_destAddr","type":"address"},{"indexed":false,"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"TransferSent","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"CreditbalanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"DebitbalanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"EntryFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"RankID","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"Register","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"RegistryCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_spender","type":"address"},{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"balance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","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":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"success","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"updateFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address payable","name":"destAddr","type":"address"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

98:3598:2:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1010:10;:8;:10::i;:::-;98:3598;;;;;3202:326;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;171:29;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2589:252;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;270:26;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1038:394;;;:::i;:::-;;391:41;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2849:345;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;238:26;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;339:41;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1436:629;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;117:20;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3536:153;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;206:26;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2070:205;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;143:22;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;494:49;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;549:64;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;438:50;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;302:31;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1038:394;1105:8;;1092:9;:21;;1084:84;;;;;;;;;;;;:::i;:::-;;;;;;;;;1205:1;1183:6;:18;1190:10;1183:18;;;;;;;;;;;;;;;;:23;1179:214;;;1249:1;1232:13;;:18;;;;;;;:::i;:::-;;;;;;;;1286:13;;1265:6;:18;1272:10;1265:18;;;;;;;;;;;;;;;:34;;;;1362:19;1345:13;;1329;;:29;;;;:::i;:::-;1328:53;;;;:::i;:::-;1314:11;:67;;;;1179:214;1416:9;1405:7;;:20;;;;;;;:::i;:::-;;;;;;;;1038:394::o;3202:326::-;3299:5;;;;;;;;;;3285:19;;:10;:19;;;3277:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;3368:7;;3358:6;:17;;3350:48;;;;;;;;;;;;:::i;:::-;;;;;;;;;3409:8;:17;;:25;3427:6;3409:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3456:6;3445:7;;:17;;;;;;;:::i;:::-;;;;;;;;3478:42;3491:10;3503:8;3513:6;3478:42;;;;;;;;:::i;:::-;;;;;;;;3202:326;;:::o;171:29::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;2589:252::-;2658:4;2703:1;2683:22;;:8;:22;;;;2675:31;;;;;;2751:6;2717:9;:21;2727:10;2717:21;;;;;;;;;;;;;;;:31;2739:8;2717:31;;;;;;;;;;;;;;;:40;;;;2794:8;2773:38;;2782:10;2773:38;;;2804:6;2773:38;;;;;;:::i;:::-;;;;;;;;2829:4;2822:11;;2589:252;;;;:::o;270:26::-;;;;:::o;391:41::-;;;;;;;;;;;;;;;;;:::o;2849:345::-;2933:4;2968:16;2978:5;2968:9;:16::i;:::-;2958:6;:26;;2950:35;;;;;;3014:9;:16;3024:5;3014:16;;;;;;;;;;;;;;;:28;3031:10;3014:28;;;;;;;;;;;;;;;;3004:6;:38;;2996:47;;;;;;3117:6;3085:9;:16;3095:5;3085:16;;;;;;;;;;;;;;;:28;3102:10;3085:28;;;;;;;;;;;;;;;;:39;;;;:::i;:::-;3054:9;:16;3064:5;3054:16;;;;;;;;;;;;;;;:28;3071:10;3054:28;;;;;;;;;;;;;;;:70;;;;3135:29;3145:5;3152:3;3157:6;3135:9;:29::i;:::-;3182:4;3175:11;;2849:345;;;;;:::o;238:26::-;;;;:::o;339:41::-;;;;:::o;1436:629::-;1489:7;1505:17;1523:19;1505:37;;1549:16;1566:19;1549:36;;1612:1;1598:6;:11;1605:3;1598:11;;;;;;;;;;;;;;;;:15;1594:182;;;1696:72;1748:19;1726;1714:6;:11;1721:3;1714:11;;;;;;;;;;;;;;;;:31;;;;:::i;:::-;:53;;;;:::i;:::-;1696:17;:72::i;:::-;1643:50;1673:19;1661:6;:11;1668:3;1661:11;;;;;;;;;;;;;;;;:31;;;;:::i;:::-;1643:17;:50::i;:::-;:125;;;;:::i;:::-;1632:136;;1594:182;1801:1;1786:6;:11;1793:3;1786:11;;;;;;;;;;;;;;;;:16;1782:57;;;1830:1;1821:10;;1782:57;1912:19;1857:52;1889:19;1875:13;;:33;;;;:::i;:::-;1857:17;:52::i;:::-;:74;;;;:::i;:::-;1845:86;;2039:14;:19;2054:3;2039:19;;;;;;;;;;;;;;;;2018:15;:20;2034:3;2018:20;;;;;;;;;;;;;;;;1947:70;1966:38;1985:8;1994:9;1966:18;:38::i;:::-;2005:11;;1947:18;:70::i;:::-;:91;;;;:::i;:::-;:111;;;;:::i;:::-;1940:118;;;;1436:629;;;:::o;117:20::-;;;;;;;;;;;;:::o;3536:153::-;3611:5;;;;;;;;;;3597:19;;:10;:19;;;3589:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;3675:6;3664:8;:17;;;;3536:153;:::o;206:26::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;2070:205::-;2135:12;2193:6;2168:21;2178:10;2168:9;:21::i;:::-;:31;;2160:40;;;;;;2211:34;2221:10;2233:3;2238:6;2211:9;:34::i;:::-;2263:4;2256:11;;2070:205;;;;:::o;143:22::-;;;;:::o;494:49::-;;;;;;;;;;;;;;;;;:::o;549:64::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;438:50::-;;;;;;;;;;;;;;;;;:::o;302:31::-;;;;:::o;2283:298::-;2389:1;2374:17;;:3;:17;;;;2366:26;;;;;;2453:6;2429:15;:20;2445:3;2429:20;;;;;;;;;;;;;;;;:31;;;;:::i;:::-;2406:15;:20;2422:3;2406:20;;;;;;;;;;;;;;;:54;;;;2520:6;2495:14;:21;2510:5;2495:21;;;;;;;;;;;;;;;;:32;;;;:::i;:::-;2471:14;:21;2486:5;2471:21;;;;;;;;;;;;;;;:56;;;;2561:3;2545:28;;2554:5;2545:28;;;2566:6;2545:28;;;;;;:::i;:::-;;;;;;;;2283:298;;;:::o;10454:328:1:-;10500:14;802:20;1386:4;10738:7;10743:1;10738:4;:7::i;:::-;:15;10737:26;;;;;:::i;:::-;;;10728:35;;10454:328;;;:::o;3917:129::-;3975:14;4011:27;4026:1;1386:4;4036:1;4011:14;:27::i;:::-;4002:36;;3917:129;;;;:::o;21678:132::-;21736:14;21772:30;21797:1;21800;21772:24;:30::i;:::-;21763:39;;21678:132;;;;:::o;19753:1432::-;19801:14;1386:4;19832:1;:9;19828:84;;;19898:1;19865:35;;;;;;;;;;;:::i;:::-;;;;;;;;19828:84;20070:9;20082:37;1386:4;20109:1;:9;;;;;:::i;:::-;;;20082:26;:37::i;:::-;20070:49;;1386:4;20333:1;:9;20324:18;;20399:9;20416:1;20411;:6;;20399:18;;1386:4;20493:1;:10;20489:64;;;20524:13;;;;20489:64;20752:13;683:4;20752:26;;20747:420;20788:1;20780:5;:9;20747:420;;;1386:4;20832:1;20828;:5;20827:15;;;;;:::i;:::-;;;20823:19;;1386:4;20930:1;:9;20925:1;:14;20921:231;;21038:5;21028:15;;;;21131:1;21125:7;;;;;20921:231;20801:1;20791:11;;;;;20747:420;;;;19922:1256;;19753:1432;;;;:::o;15472:4067:0:-;15588:14;15903:13;15972;16091:1;16087:6;16084:1;16081;16074:20;16124:1;16121;16117:9;16108:18;;16176:5;16172:2;16169:13;16161:5;16157:2;16153:14;16149:34;16140:43;;16049:145;16279:1;16270:5;:10;16266:143;;;16343:11;16335:5;:19;;;;;:::i;:::-;;;16326:28;;16384:13;;;;16266:143;16519:11;16510:5;:20;16506:103;;16578:5;16585:11;16554:43;;;;;;;;;;;;:::i;:::-;;;;;;;;16506:103;16851:17;16977:11;16974:1;16971;16964:25;16951:38;;17100:5;17089:9;17086:20;17079:5;17075:32;17066:41;;17141:9;17134:5;17130:21;17121:30;;17486:15;17534:1;17520:11;17519:12;:16;17504:11;:32;17486:50;;17662:7;17649:11;17645:25;17630:40;;17763:7;17756:5;17752:19;17743:28;;17944:1;17934:7;17924;17921:1;17917:15;17913:29;17909:37;17898:48;;18047:7;18039:5;:15;18030:24;;;;18377:15;18415:1;18400:11;18396:1;:15;18395:21;18377:39;;18666:7;18652:11;:21;18648:1;:25;18637:36;;;;18736:7;18722:11;:21;18718:1;:25;18707:36;;;;18807:7;18793:11;:21;18789:1;:25;18778:36;;;;18878:7;18864:11;:21;18860:1;:25;18849:36;;;;18949:7;18935:11;:21;18931:1;:25;18920:36;;;;19021:7;19007:11;:21;19003:1;:25;18992:36;;;;19485:7;19477:5;:15;19468:24;;19507:13;;;;;15472:4067;;;;;;:::o;20688:1188::-;20759:14;20786:13;20810;20885:1;20881:6;20878:1;20875;20868:20;20918:1;20915;20911:9;20902:18;;20970:5;20966:2;20963:13;20955:5;20951:2;20947:14;20943:34;20934:43;;20843:145;4320:4;21004:5;:14;21000:94;;21076:5;21042:40;;;;;;;;;;;:::i;:::-;;;;;;;;21000:94;21106:17;21134:19;21214:5;21211:1;21208;21201:19;21188:32;;21263:18;21252:9;21249:33;21234:48;;21318:1;21309:5;:10;21305:157;;;21392:11;4320:4;21375:5;:13;;;;;:::i;:::-;;;21374:29;21365:38;;21422:13;;;;;;21305:157;21832:11;21781:13;21732:1;21718:11;21704;21701:1;21697:19;21693:37;21689:45;21680:5;21669:9;21666:20;21659:5;21655:32;21651:84;21612:11;21600:9;21593:5;21589:21;21585:39;21556:202;21530:283;21508:350;21498:360;;21483:386;;;;20688:1188;;;;;:::o;14090:777::-;14152:11;14185:6;14180:1;:11;14176:78;;14214:3;14208:9;;;;;14239:3;14232:10;;;;;:::i;:::-;;;14176:78;14273:5;14268:1;:10;14264:75;;14301:2;14295:8;;;;;14325:2;14318:9;;;;;:::i;:::-;;;14264:75;14358:5;14353:1;:10;14349:75;;14386:2;14380:8;;;;;14410:2;14403:9;;;;;:::i;:::-;;;14349:75;14443:5;14438:1;:10;14434:75;;14471:2;14465:8;;;;;14495:2;14488:9;;;;;:::i;:::-;;;14434:75;14528:4;14523:1;:9;14519:72;;14555:1;14549:7;;;;;14578:1;14571:8;;;;;:::i;:::-;;;14519:72;14610:4;14605:1;:9;14601:72;;14637:1;14631:7;;;;;14660:1;14653:8;;;;;:::i;:::-;;;14601:72;14692:4;14687:1;:9;14683:72;;14719:1;14713:7;;;;;14742:1;14735:8;;;;;:::i;:::-;;;14683:72;14774:4;14769:1;:9;14765:95;;14847:1;14840:8;;;;;:::i;:::-;;;14765:95;14090:777;;;:::o;7:139:3:-;53:5;91:6;78:20;69:29;;107:33;134:5;107:33;:::i;:::-;7:139;;;;:::o;152:155::-;206:5;244:6;231:20;222:29;;260:41;295:5;260:41;:::i;:::-;152:155;;;;:::o;313:139::-;359:5;397:6;384:20;375:29;;413:33;440:5;413:33;:::i;:::-;313:139;;;;:::o;458:329::-;517:6;566:2;554:9;545:7;541:23;537:32;534:119;;;572:79;;:::i;:::-;534:119;692:1;717:53;762:7;753:6;742:9;738:22;717:53;:::i;:::-;707:63;;663:117;458:329;;;;:::o;793:474::-;861:6;869;918:2;906:9;897:7;893:23;889:32;886:119;;;924:79;;:::i;:::-;886:119;1044:1;1069:53;1114:7;1105:6;1094:9;1090:22;1069:53;:::i;:::-;1059:63;;1015:117;1171:2;1197:53;1242:7;1233:6;1222:9;1218:22;1197:53;:::i;:::-;1187:63;;1142:118;793:474;;;;;:::o;1273:619::-;1350:6;1358;1366;1415:2;1403:9;1394:7;1390:23;1386:32;1383:119;;;1421:79;;:::i;:::-;1383:119;1541:1;1566:53;1611:7;1602:6;1591:9;1587:22;1566:53;:::i;:::-;1556:63;;1512:117;1668:2;1694:53;1739:7;1730:6;1719:9;1715:22;1694:53;:::i;:::-;1684:63;;1639:118;1796:2;1822:53;1867:7;1858:6;1847:9;1843:22;1822:53;:::i;:::-;1812:63;;1767:118;1273:619;;;;;:::o;1898:474::-;1966:6;1974;2023:2;2011:9;2002:7;1998:23;1994:32;1991:119;;;2029:79;;:::i;:::-;1991:119;2149:1;2174:53;2219:7;2210:6;2199:9;2195:22;2174:53;:::i;:::-;2164:63;;2120:117;2276:2;2302:53;2347:7;2338:6;2327:9;2323:22;2302:53;:::i;:::-;2292:63;;2247:118;1898:474;;;;;:::o;2378:329::-;2437:6;2486:2;2474:9;2465:7;2461:23;2457:32;2454:119;;;2492:79;;:::i;:::-;2454:119;2612:1;2637:53;2682:7;2673:6;2662:9;2658:22;2637:53;:::i;:::-;2627:63;;2583:117;2378:329;;;;:::o;2713:490::-;2789:6;2797;2846:2;2834:9;2825:7;2821:23;2817:32;2814:119;;;2852:79;;:::i;:::-;2814:119;2972:1;2997:53;3042:7;3033:6;3022:9;3018:22;2997:53;:::i;:::-;2987:63;;2943:117;3099:2;3125:61;3178:7;3169:6;3158:9;3154:22;3125:61;:::i;:::-;3115:71;;3070:126;2713:490;;;;;:::o;3209:147::-;3304:45;3343:5;3304:45;:::i;:::-;3299:3;3292:58;3209:147;;:::o;3362:118::-;3449:24;3467:5;3449:24;:::i;:::-;3444:3;3437:37;3362:118;;:::o;3486:109::-;3567:21;3582:5;3567:21;:::i;:::-;3562:3;3555:34;3486:109;;:::o;3601:364::-;3689:3;3717:39;3750:5;3717:39;:::i;:::-;3772:71;3836:6;3831:3;3772:71;:::i;:::-;3765:78;;3852:52;3897:6;3892:3;3885:4;3878:5;3874:16;3852:52;:::i;:::-;3929:29;3951:6;3929:29;:::i;:::-;3924:3;3920:39;3913:46;;3693:272;3601:364;;;;:::o;3971:366::-;4113:3;4134:67;4198:2;4193:3;4134:67;:::i;:::-;4127:74;;4210:93;4299:3;4210:93;:::i;:::-;4328:2;4323:3;4319:12;4312:19;;3971:366;;;:::o;4343:::-;4485:3;4506:67;4570:2;4565:3;4506:67;:::i;:::-;4499:74;;4582:93;4671:3;4582:93;:::i;:::-;4700:2;4695:3;4691:12;4684:19;;4343:366;;;:::o;4715:::-;4857:3;4878:67;4942:2;4937:3;4878:67;:::i;:::-;4871:74;;4954:93;5043:3;4954:93;:::i;:::-;5072:2;5067:3;5063:12;5056:19;;4715:366;;;:::o;5087:::-;5229:3;5250:67;5314:2;5309:3;5250:67;:::i;:::-;5243:74;;5326:93;5415:3;5326:93;:::i;:::-;5444:2;5439:3;5435:12;5428:19;;5087:366;;;:::o;5459:118::-;5546:24;5564:5;5546:24;:::i;:::-;5541:3;5534:37;5459:118;;:::o;5583:222::-;5676:4;5714:2;5703:9;5699:18;5691:26;;5727:71;5795:1;5784:9;5780:17;5771:6;5727:71;:::i;:::-;5583:222;;;;:::o;5811:458::-;5968:4;6006:2;5995:9;5991:18;5983:26;;6019:71;6087:1;6076:9;6072:17;6063:6;6019:71;:::i;:::-;6100:80;6176:2;6165:9;6161:18;6152:6;6100:80;:::i;:::-;6190:72;6258:2;6247:9;6243:18;6234:6;6190:72;:::i;:::-;5811:458;;;;;;:::o;6275:210::-;6362:4;6400:2;6389:9;6385:18;6377:26;;6413:65;6475:1;6464:9;6460:17;6451:6;6413:65;:::i;:::-;6275:210;;;;:::o;6491:313::-;6604:4;6642:2;6631:9;6627:18;6619:26;;6691:9;6685:4;6681:20;6677:1;6666:9;6662:17;6655:47;6719:78;6792:4;6783:6;6719:78;:::i;:::-;6711:86;;6491:313;;;;:::o;6810:419::-;6976:4;7014:2;7003:9;6999:18;6991:26;;7063:9;7057:4;7053:20;7049:1;7038:9;7034:17;7027:47;7091:131;7217:4;7091:131;:::i;:::-;7083:139;;6810:419;;;:::o;7235:::-;7401:4;7439:2;7428:9;7424:18;7416:26;;7488:9;7482:4;7478:20;7474:1;7463:9;7459:17;7452:47;7516:131;7642:4;7516:131;:::i;:::-;7508:139;;7235:419;;;:::o;7660:::-;7826:4;7864:2;7853:9;7849:18;7841:26;;7913:9;7907:4;7903:20;7899:1;7888:9;7884:17;7877:47;7941:131;8067:4;7941:131;:::i;:::-;7933:139;;7660:419;;;:::o;8085:::-;8251:4;8289:2;8278:9;8274:18;8266:26;;8338:9;8332:4;8328:20;8324:1;8313:9;8309:17;8302:47;8366:131;8492:4;8366:131;:::i;:::-;8358:139;;8085:419;;;:::o;8510:222::-;8603:4;8641:2;8630:9;8626:18;8618:26;;8654:71;8722:1;8711:9;8707:17;8698:6;8654:71;:::i;:::-;8510:222;;;;:::o;8738:332::-;8859:4;8897:2;8886:9;8882:18;8874:26;;8910:71;8978:1;8967:9;8963:17;8954:6;8910:71;:::i;:::-;8991:72;9059:2;9048:9;9044:18;9035:6;8991:72;:::i;:::-;8738:332;;;;;:::o;9157:99::-;9209:6;9243:5;9237:12;9227:22;;9157:99;;;:::o;9262:169::-;9346:11;9380:6;9375:3;9368:19;9420:4;9415:3;9411:14;9396:29;;9262:169;;;;:::o;9437:305::-;9477:3;9496:20;9514:1;9496:20;:::i;:::-;9491:25;;9530:20;9548:1;9530:20;:::i;:::-;9525:25;;9684:1;9616:66;9612:74;9609:1;9606:81;9603:107;;;9690:18;;:::i;:::-;9603:107;9734:1;9731;9727:9;9720:16;;9437:305;;;;:::o;9748:348::-;9788:7;9811:20;9829:1;9811:20;:::i;:::-;9806:25;;9845:20;9863:1;9845:20;:::i;:::-;9840:25;;10033:1;9965:66;9961:74;9958:1;9955:81;9950:1;9943:9;9936:17;9932:105;9929:131;;;10040:18;;:::i;:::-;9929:131;10088:1;10085;10081:9;10070:20;;9748:348;;;;:::o;10102:191::-;10142:4;10162:20;10180:1;10162:20;:::i;:::-;10157:25;;10196:20;10214:1;10196:20;:::i;:::-;10191:25;;10235:1;10232;10229:8;10226:34;;;10240:18;;:::i;:::-;10226:34;10285:1;10282;10278:9;10270:17;;10102:191;;;;:::o;10299:96::-;10336:7;10365:24;10383:5;10365:24;:::i;:::-;10354:35;;10299:96;;;:::o;10401:104::-;10446:7;10475:24;10493:5;10475:24;:::i;:::-;10464:35;;10401:104;;;:::o;10511:90::-;10545:7;10588:5;10581:13;10574:21;10563:32;;10511:90;;;:::o;10607:126::-;10644:7;10684:42;10677:5;10673:54;10662:65;;10607:126;;;:::o;10739:77::-;10776:7;10805:5;10794:16;;10739:77;;;:::o;10822:134::-;10880:9;10913:37;10944:5;10913:37;:::i;:::-;10900:50;;10822:134;;;:::o;10962:126::-;11012:9;11045:37;11076:5;11045:37;:::i;:::-;11032:50;;10962:126;;;:::o;11094:113::-;11144:9;11177:24;11195:5;11177:24;:::i;:::-;11164:37;;11094:113;;;:::o;11213:307::-;11281:1;11291:113;11305:6;11302:1;11299:13;11291:113;;;11390:1;11385:3;11381:11;11375:18;11371:1;11366:3;11362:11;11355:39;11327:2;11324:1;11320:10;11315:15;;11291:113;;;11422:6;11419:1;11416:13;11413:101;;;11502:1;11493:6;11488:3;11484:16;11477:27;11413:101;11262:258;11213:307;;;:::o;11526:320::-;11570:6;11607:1;11601:4;11597:12;11587:22;;11654:1;11648:4;11644:12;11675:18;11665:81;;11731:4;11723:6;11719:17;11709:27;;11665:81;11793:2;11785:6;11782:14;11762:18;11759:38;11756:84;;;11812:18;;:::i;:::-;11756:84;11577:269;11526:320;;;:::o;11852:180::-;11900:77;11897:1;11890:88;11997:4;11994:1;11987:15;12021:4;12018:1;12011:15;12038:180;12086:77;12083:1;12076:88;12183:4;12180:1;12173:15;12207:4;12204:1;12197:15;12224:180;12272:77;12269:1;12262:88;12369:4;12366:1;12359:15;12393:4;12390:1;12383:15;12533:117;12642:1;12639;12632:12;12656:102;12697:6;12748:2;12744:7;12739:2;12732:5;12728:14;12724:28;12714:38;;12656:102;;;:::o;12764:181::-;12904:33;12900:1;12892:6;12888:14;12881:57;12764:181;:::o;12951:179::-;13091:31;13087:1;13079:6;13075:14;13068:55;12951:179;:::o;13136:168::-;13276:20;13272:1;13264:6;13260:14;13253:44;13136:168;:::o;13310:238::-;13450:34;13446:1;13438:6;13434:14;13427:58;13519:21;13514:2;13506:6;13502:15;13495:46;13310:238;:::o;13554:122::-;13627:24;13645:5;13627:24;:::i;:::-;13620:5;13617:35;13607:63;;13666:1;13663;13656:12;13607:63;13554:122;:::o;13682:138::-;13763:32;13789:5;13763:32;:::i;:::-;13756:5;13753:43;13743:71;;13810:1;13807;13800:12;13743:71;13682:138;:::o;13826:122::-;13899:24;13917:5;13899:24;:::i;:::-;13892:5;13889:35;13879:63;;13938:1;13935;13928:12;13879:63;13826:122;:::o

ipfs://146e2a15c27c1afe05f66545fbb148fabbfc4b2ce4a7e03e3a91868b8e23c224