Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library SafeMath
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b, st ...
• library Math
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function max(uint256 a, uint256 b)
•    - function min(uint256 a, uint256 b)
•    - function average(uint256 a, uint256 b ...
•    - function ceilDiv(uint256 a, uint256 b ...
•    - function mulDiv(uint256 x, uint256 y, ...
•    - function mulDiv(uint256 x, uint256 y, ...
•    - function sqrt(uint256 a)
•    - function sqrt(uint256 a, Rounding rou ...
•    - function log2(uint256 value)
•    - function log2(uint256 value, Rounding ...
•    - function log10(uint256 value)
•    - function log10(uint256 value, Roundin ...
•    - function log256(uint256 value)
•    - function log256(uint256 value, Roundi ...
•    - function unsignedRoundsUp(Rounding ro ...
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address from, a ...
• interface IERC20Permit
•    - function permit(
•    - function nonces(address owner)
•    - function DOMAIN_SEPARATOR()
• library Address
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCallWithValue(addres ...
•    - function functionStaticCall(address t ...
•    - function functionDelegateCall(address ...
•    - function verifyCallResultFromTarget(
•    - function verifyCallResult(bool succes ...
•    - function _revert(bytes memory returnd ...
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function forceApprove(IERC20 token, a ...
•    - function _callOptionalReturn(IERC20 t ...
•    - function _callOptionalReturnBool(IERC ...
•    - function _msgSender()
•    - function _msgData()
•    - function _contextSuffixLength()
•    - function owner()
•    - function _checkOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
•    - function _nonReentrantBefore()
•    - function _nonReentrantAfter()
•    - function _reentrancyGuardEntered()
•  contract MasterChef is Ownable, Re ... *
•    - function getClaimingContract()
•    - function setClaimingContract(address ...
•    - function poolLength()
•    - function stakeHoldersLength(uint256 _ ...
•    - function initializePools(IERC20 _lpto ...
•    - function add(IERC20 _lptoken, uint256 ...
•    - function set(uint256 _pid, uint256 _d ...
•    - function getMultiplier(uint256 _from, ...
•    - function pendingToken(uint256 _pid, a ...
•    - function massUpdatePools()
•    - function updatePool(uint256 _pid)
•    - function deposit(uint256 _pid, uint25 ...
•    - function deposit(uint256 _pid, uint25 ...
•    - function withdraw(uint256 _pid, uint2 ...
•    - function LockupPendingToken(uint256 _ ...
•    - function getRewards(uint256 _pid)
•    - function exit(uint256 _pid, uint256 _ ...
•    - function remainingRewardTokens()
•    - function withdrawAllowed(uint256 _pid ...
•    - function isStakeholder(address _addre ...
•    - function addStakeholder(address _stak ...
•    - function removeStakeholder(address _s ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2024-06-25
*/

// SPDX-License-Identifier: MIT

// File: @openzeppelin/contracts/utils/math/SafeMath.sol


// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    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.
     *
     * _Available since v3.4._
     */
    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.
     *
     * _Available since v3.4._
     */
    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.
     *
     * _Available since v3.4._
     */
    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.
     *
     * _Available since v3.4._
     */
    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 addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

// File: @openzeppelin/contracts/utils/math/Math.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
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;
    }
}

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     *
     * CAUTION: See Security Considerations above.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// File: @openzeppelin/contracts/utils/Address.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedInnerCall();

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert AddressInsufficientBalance(address(this));
        }

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {FailedInnerCall} error.
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
     * unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {FailedInnerCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
     */
    function _revert(bytes memory returndata) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert FailedInnerCall();
        }
    }
}

// File: @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.20;




/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    /**
     * @dev An operation with an ERC20 token failed.
     */
    error SafeERC20FailedOperation(address token);

    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        forceApprove(token, spender, oldAllowance + value);
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data);
        if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
    }
}

// File: @openzeppelin/contracts/utils/Context.sol


// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

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

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// File: @openzeppelin/contracts/access/Ownable.sol


// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;


/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is set to the address provided by the deployer. This can
 * later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// File: @openzeppelin/contracts/security/ReentrancyGuard.sol


// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == _ENTERED;
    }
}

// File: Staking.sol



pragma solidity ^0.8.9;







contract MasterChef is Ownable, ReentrancyGuard {
    using SafeMath for uint256;
    using SafeERC20  for IERC20;

    // Info of each user.
    struct UserInfo {
        uint256 amount;      
        uint256 rewardDebt; // userRewardPerTokenPaid
        uint256 rewardLockedUp; // rewards
        uint256 timestamp; //stake time
    }

    // Info of each pool.
    struct PoolInfo {
        IERC20 lpToken;
        uint256 duration; // total lock period in seconds
        uint256 apy;  // apy in basis point
        uint256 lastRewardTime;  // Last block time that reward distribution occurs.
        uint256 accTokenPerShare;   // Accumulated reward per share, rewardPerTokenStored
        uint256 totalSupply; // total supply in this pool
    }

    // The Reward TOKEN!
    IERC20 public rewardToken;
    
    // rewards durations
    uint256 public rewardDuration = 365 days;

    address private claimingContract;
    
    // Info of each pool.
    PoolInfo[] public poolInfo;

    // mapping of stakeholder address by pool id
    mapping(uint256 => address[]) public stakeHolders;

    // Info of each user that stakes LP tokens.
    mapping(uint256 => mapping(address => UserInfo)) public userInfo;

    // Total locked up rewards
    uint256 public totalLockedUpRewards;

    uint256 public totalClaimedRewards;

    event Deposit(address indexed user, uint256 indexed pid, uint256 amount, uint256 indexed timestamp);
    event Withdraw(address indexed user, uint256 indexed pid, uint256 amount, uint256 indexed timestamp);
    event Harvest(address indexed user, uint256 amount, uint256 indexed timestamp);

    constructor(
        address _rewardToken
    ) Ownable(msg.sender)  {
        rewardToken = IERC20(_rewardToken);
    }

    modifier onlyClaimingContract {
        require(msg.sender == claimingContract);
        _;
    }

    function getClaimingContract() external view returns (address) {
        return claimingContract;
    }

    function setClaimingContract(address _claimingContract) external onlyOwner {
        claimingContract = _claimingContract;
    }

    function poolLength() external view returns (uint256) {
        return poolInfo.length;
    }

    function stakeHoldersLength(uint256 _pid) external view returns (uint256) {
        return stakeHolders[_pid].length;
    }

    function initializePools(IERC20 _lptoken1) external onlyOwner {
        add(_lptoken1, 86400*30, 800, true);
        add(_lptoken1, 86400*30*3, 2000, true);
        add(_lptoken1, 86400*30*6, 3500, true);
        add(_lptoken1, 86400*30*9, 4000, true);
        add(_lptoken1, 86400*30*12, 5000, true);    

        add(_lptoken1, 86400*30, 1200, true);
        add(_lptoken1, 86400*30*3, 2500, true);
        add(_lptoken1, 86400*30*6, 4500, true);
        add(_lptoken1, 86400*30*9, 5500, true);
        add(_lptoken1, 86400*30*12, 7000, true);     
    }

    function add(IERC20 _lptoken, uint256 _duration, uint256 _apy, bool _withUpdate) public onlyOwner {
        
        if (_withUpdate) {
            massUpdatePools();
        }
        poolInfo.push(PoolInfo({
        lpToken: _lptoken,
        duration: _duration,
        apy: _apy,
        lastRewardTime: block.timestamp,
        accTokenPerShare: 0,
        totalSupply:0
        }));
    }

    function set(uint256 _pid, uint256 _duration, uint256 _apy, bool _withUpdate) public onlyOwner {
        if (_withUpdate) {
            massUpdatePools();
        }
        poolInfo[_pid].duration = _duration;
        poolInfo[_pid].apy = _apy;
    }

    // Return reward multiplier over the given _from to _to block.
    function getMultiplier(uint256 _from, uint256 _to) public pure returns (uint256) {
        return _to.sub(_from);
    }

    // View function to see pending 888 on frontend.
    function pendingToken(uint256 _pid, address _user) external view returns (uint256) {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accTokenPerShare = pool.accTokenPerShare;
        uint256 lpSupply = pool.totalSupply;
        if (block.timestamp > pool.lastRewardTime && lpSupply != 0) {
            uint256 multiplier = getMultiplier(pool.lastRewardTime, block.timestamp);
            // calculate Rewards (totalSupply x apy / 10000) / 1year
            uint256 tokenReward = lpSupply.mul(pool.apy).mul(multiplier).div(10000).div(rewardDuration);
            accTokenPerShare = accTokenPerShare.add(tokenReward.mul(1e18).div(lpSupply)); // tokenReward.mul(1e12).div(lpSupply)
        }
        uint256 pending = user.amount.mul(accTokenPerShare).div(1e18).sub(user.rewardDebt);
        return pending.add(user.rewardLockedUp);
    }

    // Update reward variables for all pools. Be careful of gas spending!
    function massUpdatePools() public {
        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            updatePool(pid);
        }
    }

    // Update reward variables of the given pool to be up-to-date.
    function updatePool(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        if (block.timestamp <= pool.lastRewardTime) {
            return;
        }
        uint256 lpSupply = pool.totalSupply;
        if (lpSupply == 0) {
            pool.lastRewardTime = block.timestamp;
            return;
        }
        uint256 multiplier = getMultiplier(pool.lastRewardTime, block.timestamp);
        uint256 tokenReward = lpSupply.mul(pool.apy).mul(multiplier).div(10000).div(rewardDuration);
        
        pool.accTokenPerShare = pool.accTokenPerShare.add(tokenReward.mul(1e18).div(lpSupply));
        pool.lastRewardTime = block.timestamp;
    }


    // Deposit LP tokens to MasterChef for 888 allocation.
    function deposit(uint256 _pid, uint256 _amount) public nonReentrant { 
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        updatePool(_pid);
        LockupPendingToken(_pid, msg.sender);
        if (_amount > 0) {
            if( user.amount == 0 ) {
                addStakeholder(msg.sender, _pid);
                user.timestamp = block.timestamp;
            }
            pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
            user.amount = user.amount.add(_amount);
            pool.totalSupply = pool.totalSupply.add(_amount);
            emit Deposit(msg.sender, _pid, user.amount, block.timestamp);
        }
        user.rewardDebt = user.amount.mul(pool.accTokenPerShare).div(1e18);
    }

    function deposit(uint256 _pid, uint256 _amount, address _owner, address _sender) external onlyClaimingContract nonReentrant { 
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_sender];
        updatePool(_pid);
        LockupPendingToken(_pid, _sender);
        if (_amount > 0) {
            if( user.amount == 0 ) {
                addStakeholder(_sender, _pid);
                user.timestamp = block.timestamp;
            }
            pool.lpToken.safeTransferFrom(address(_owner), address(this), _amount);
            user.amount = user.amount.add(_amount);
            pool.totalSupply = pool.totalSupply.add(_amount);
            emit Deposit(_sender, _pid, user.amount, block.timestamp);
        }
        user.rewardDebt = user.amount.mul(pool.accTokenPerShare).div(1e18);
    }


    // Withdraw LP tokens from MasterChef.
    function withdraw(uint256 _pid, uint256 _amount) internal nonReentrant {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        require(user.amount >= _amount, "withdraw: not good");
        require(block.timestamp >= user.timestamp.add(pool.duration), "Stake period is not expired..");
        updatePool(_pid);
        LockupPendingToken(_pid, msg.sender);
        if (_amount > 0) {
            user.amount = user.amount.sub(_amount);
            pool.totalSupply = pool.totalSupply.sub(_amount);
            pool.lpToken.safeTransfer(address(msg.sender), _amount);
        }
        if ( user.amount == 0 ) {
            removeStakeholder(msg.sender, _pid);
        }

        user.rewardDebt = user.amount.mul(pool.accTokenPerShare).div(1e18);
        emit Withdraw(msg.sender, _pid, _amount, block.timestamp);
    }

    // Pay or lockup pending 888s.
    function LockupPendingToken(uint256 _pid, address _msgSender) internal {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_msgSender];

        uint256 pending = user.amount.mul(pool.accTokenPerShare).div(1e18).sub(user.rewardDebt); 

        user.rewardLockedUp = user.rewardLockedUp.add(pending);
        totalLockedUpRewards = totalLockedUpRewards.add(pending);
        
    }

    function getRewards(uint256 _pid) public nonReentrant {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        require(block.timestamp >= user.timestamp.add(pool.duration + 7 days), "Stake period is not expired..");
        updatePool(_pid);
        LockupPendingToken(_pid, msg.sender);

        uint256 pending = user.amount.mul(pool.accTokenPerShare).div(1e18).sub(user.rewardDebt);

        if (pending > 0 || user.rewardLockedUp > 0) {
            uint256 totalRewards = pending.add(user.rewardLockedUp);
            totalClaimedRewards = totalClaimedRewards.add(totalRewards);    
            // reset lockup
            totalLockedUpRewards = totalLockedUpRewards.sub(user.rewardLockedUp);
            user.rewardLockedUp = 0;
            user.rewardDebt = user.amount.mul(pool.accTokenPerShare).div(1e18);
            // send rewards
            rewardToken.safeTransferFrom(owner(), msg.sender, totalRewards);
            
            emit Harvest(msg.sender, totalRewards, block.timestamp);
        }
    }

    function exit(uint256 _pid, uint256 _amount) external {
        withdraw(_pid, _amount);
    }

    function remainingRewardTokens() external view returns (uint256) {
        return Math.min(rewardToken.balanceOf(owner()), rewardToken.allowance(owner(), address(this)));
    }

    function withdrawAllowed(uint256 _pid, address _user) public view returns (bool) {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];

        return block.timestamp >= user.timestamp.add(pool.duration);
    }

    function isStakeholder(address _address, uint256 _pid)
        internal
        view
        returns(bool, uint256)
    {
        for (uint256 s = 0; s < stakeHolders[_pid].length; s += 1){
            if (_address == stakeHolders[_pid][s]) return (true, s);
        }
        return (false, 0);
    }

   
    function addStakeholder(address _stakeholder, uint256 _pid)
        internal
    {
        (bool _isStakeholder, ) = isStakeholder(_stakeholder, _pid);
        if(!_isStakeholder) stakeHolders[_pid].push(_stakeholder);
    }

    
    function removeStakeholder(address _stakeholder, uint _pid)
        internal
    {
        (bool _isStakeholder, uint256 s) = isStakeholder(_stakeholder, _pid);
        if(_isStakeholder){
            stakeHolders[_pid][s] = stakeHolders[_pid][stakeHolders[_pid].length - 1];
            stakeHolders[_pid].pop();
        } 
    }
 
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_rewardToken","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"Harvest","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[{"internalType":"contract IERC20","name":"_lptoken","type":"address"},{"internalType":"uint256","name":"_duration","type":"uint256"},{"internalType":"uint256","name":"_apy","type":"uint256"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_sender","type":"address"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"exit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getClaimingContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_from","type":"uint256"},{"internalType":"uint256","name":"_to","type":"uint256"}],"name":"getMultiplier","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"getRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_lptoken1","type":"address"}],"name":"initializePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"contract IERC20","name":"lpToken","type":"address"},{"internalType":"uint256","name":"duration","type":"uint256"},{"internalType":"uint256","name":"apy","type":"uint256"},{"internalType":"uint256","name":"lastRewardTime","type":"uint256"},{"internalType":"uint256","name":"accTokenPerShare","type":"uint256"},{"internalType":"uint256","name":"totalSupply","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"remainingRewardTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_duration","type":"uint256"},{"internalType":"uint256","name":"_apy","type":"uint256"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_claimingContract","type":"address"}],"name":"setClaimingContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"stakeHolders","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"stakeHoldersLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalClaimedRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalLockedUpRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"},{"internalType":"uint256","name":"rewardLockedUp","type":"uint256"},{"internalType":"uint256","name":"timestamp","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"withdrawAllowed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]

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

0x608060405234801561000f575f80fd5b50600436106101a7575f3560e01c80638da5cb5b116100f7578063e4a7631511610095578063f520e7e51161006f578063f520e7e514610497578063f70a29a0146104b5578063f7c618c1146104d1578063fb8f9920146104ef576101a7565b8063e4a7631514610441578063e6e034321461045d578063f2fde38b1461047b576101a7565b80639ce69679116100d15780639ce69679146103cf578063c0d8012c146103eb578063d578ceab14610407578063e2bbb15814610425576101a7565b80638da5cb5b1461034e5780638dbb1e3a1461036c57806393f1a40b1461039c576101a7565b806348e43af41161016457806367d792721161013e57806367d79272146102ee578063715018a61461030c57806384715b11146103165780638862445a14610332576101a7565b806348e43af41461029857806351eb05a6146102c8578063630b5ba1146102e4576101a7565b8063081e3eda146101ab5780631526fe27146101c95780632af9cc41146101fe5780633a5770831461021a5780633aadb1c71461024a578063474fa6301461027a575b5f80fd5b6101b361051f565b6040516101c091906120fd565b60405180910390f35b6101e360048036038101906101de9190612144565b61052b565b6040516101f5969594939291906121e9565b60405180910390f35b61021860048036038101906102139190612248565b610591565b005b610234600480360381019061022f9190612144565b61059f565b60405161024191906120fd565b60405180910390f35b610264600480360381019061025f91906122c1565b6105bc565b6040516102719190612319565b60405180910390f35b610282610657565b60405161028f91906120fd565b60405180910390f35b6102b260048036038101906102ad91906122c1565b61065d565b6040516102bf91906120fd565b60405180910390f35b6102e260048036038101906102dd9190612144565b61080e565b005b6102ec610922565b005b6102f661094d565b60405161030391906120fd565b60405180910390f35b610314610a9d565b005b610330600480360381019061032b9190612332565b610ab0565b005b61034c600480360381019061034791906123c0565b610ce6565b005b610356610d53565b6040516103639190612433565b60405180910390f35b61038660048036038101906103819190612248565b610d7a565b60405161039391906120fd565b60405180910390f35b6103b660048036038101906103b191906122c1565b610d96565b6040516103c6949392919061244c565b60405180910390f35b6103e960048036038101906103e4919061248f565b610dcd565b005b61040560048036038101906104009190612144565b610e18565b005b61040f6110c0565b60405161041c91906120fd565b60405180910390f35b61043f600480360381019061043a9190612248565b6110c6565b005b61045b600480360381019061045691906124f5565b6112a2565b005b6104656113a2565b6040516104729190612433565b60405180910390f35b6104956004803603810190610490919061248f565b6113ca565b005b61049f61144e565b6040516104ac91906120fd565b60405180910390f35b6104cf60048036038101906104ca9190612559565b611454565b005b6104d9611517565b6040516104e69190612584565b60405180910390f35b61050960048036038101906105049190612248565b61153c565b6040516105169190612433565b60405180910390f35b5f600580549050905090565b6005818154811061053a575f80fd5b905f5260205f2090600602015f91509050805f015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff16908060010154908060020154908060030154908060040154908060050154905086565b61059b8282611584565b5050565b5f60065f8381526020019081526020015f20805490509050919050565b5f80600584815481106105d2576105d161259d565b5b905f5260205f20906006020190505f60075f8681526020019081526020015f205f8573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20905061064a826001015482600301546117f590919063ffffffff16565b4210159250505092915050565b60085481565b5f80600584815481106106735761067261259d565b5b905f5260205f20906006020190505f60075f8681526020019081526020015f205f8573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f2090505f826004015490505f836005015490508360030154421180156106f357505f8114155b156107a1575f610707856003015442610d7a565b90505f61075b60035461074d61271061073f866107318c600201548a61180a90919063ffffffff16565b61180a90919063ffffffff16565b61181f90919063ffffffff16565b61181f90919063ffffffff16565b905061079c61078d8461077f670de0b6b3a76400008561180a90919063ffffffff16565b61181f90919063ffffffff16565b856117f590919063ffffffff16565b935050505b5f6107e884600101546107da670de0b6b3a76400006107cc87895f015461180a90919063ffffffff16565b61181f90919063ffffffff16565b61183490919063ffffffff16565b90506108018460020154826117f590919063ffffffff16565b9550505050505092915050565b5f600582815481106108235761082261259d565b5b905f5260205f209060060201905080600301544211610842575061091f565b5f816005015490505f810361086157428260030181905550505061091f565b5f610870836003015442610d7a565b90505f6108c46003546108b66127106108a88661089a8a600201548a61180a90919063ffffffff16565b61180a90919063ffffffff16565b61181f90919063ffffffff16565b61181f90919063ffffffff16565b90506109096108f6846108e8670de0b6b3a76400008561180a90919063ffffffff16565b61181f90919063ffffffff16565b85600401546117f590919063ffffffff16565b8460040181905550428460030181905550505050505b50565b5f60058054905090505f5b818110156109495761093e8161080e565b80600101905061092d565b5050565b5f610a9860025f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166370a08231610996610d53565b6040518263ffffffff1660e01b81526004016109b29190612433565b602060405180830381865afa1580156109cd573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906109f191906125de565b60025f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663dd62ed3e610a36610d53565b306040518363ffffffff1660e01b8152600401610a54929190612609565b602060405180830381865afa158015610a6f573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610a9391906125de565b611849565b905090565b610aa5611861565b610aae5f6118e8565b565b60045f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610b08575f80fd5b610b106119a9565b5f60058581548110610b2557610b2461259d565b5b905f5260205f20906006020190505f60075f8781526020019081526020015f205f8473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f209050610b8b8661080e565b610b9586846119f8565b5f851115610c9a575f815f015403610bbb57610bb18387611af8565b4281600301819055505b610c0a843087855f015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16611b80909392919063ffffffff16565b610c2085825f01546117f590919063ffffffff16565b815f0181905550610c3e8583600501546117f590919063ffffffff16565b826005018190555042868473ffffffffffffffffffffffffffffffffffffffff167f36af321ec8d3c75236829c5317affd40ddb308863a1236d2d277a4025cccee1e845f0154604051610c9191906120fd565b60405180910390a45b610cce670de0b6b3a7640000610cc08460040154845f015461180a90919063ffffffff16565b61181f90919063ffffffff16565b81600101819055505050610ce0611c02565b50505050565b610cee611861565b8015610cfd57610cfc610922565b5b8260058581548110610d1257610d1161259d565b5b905f5260205f209060060201600101819055508160058581548110610d3a57610d3961259d565b5b905f5260205f2090600602016002018190555050505050565b5f805f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b5f610d8e838361183490919063ffffffff16565b905092915050565b6007602052815f5260405f20602052805f5260405f205f9150915050805f0154908060010154908060020154908060030154905084565b610dd5611861565b8060045f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b610e206119a9565b5f60058281548110610e3557610e3461259d565b5b905f5260205f20906006020190505f60075f8481526020019081526020015f205f3373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f209050610ebb62093a808360010154610ea8919061265d565b82600301546117f590919063ffffffff16565b421015610efd576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610ef4906126ea565b60405180910390fd5b610f068361080e565b610f1083336119f8565b5f610f5b8260010154610f4d670de0b6b3a7640000610f3f8760040154875f015461180a90919063ffffffff16565b61181f90919063ffffffff16565b61183490919063ffffffff16565b90505f811180610f6e57505f8260020154115b156110b2575f610f8b8360020154836117f590919063ffffffff16565b9050610fa2816009546117f590919063ffffffff16565b600981905550610fc1836002015460085461183490919063ffffffff16565b6008819055505f8360020181905550611004670de0b6b3a7640000610ff68660040154865f015461180a90919063ffffffff16565b61181f90919063ffffffff16565b8360010181905550611061611017610d53565b338360025f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16611b80909392919063ffffffff16565b423373ffffffffffffffffffffffffffffffffffffffff167f71bab65ced2e5750775a0613be067df48ef06cf92a496ebf7663ae0660924954836040516110a891906120fd565b60405180910390a3505b5050506110bd611c02565b50565b60095481565b6110ce6119a9565b5f600583815481106110e3576110e261259d565b5b905f5260205f20906006020190505f60075f8581526020019081526020015f205f3373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f2090506111498461080e565b61115384336119f8565b5f831115611258575f815f0154036111795761116f3385611af8565b4281600301819055505b6111c8333085855f015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16611b80909392919063ffffffff16565b6111de83825f01546117f590919063ffffffff16565b815f01819055506111fc8383600501546117f590919063ffffffff16565b826005018190555042843373ffffffffffffffffffffffffffffffffffffffff167f36af321ec8d3c75236829c5317affd40ddb308863a1236d2d277a4025cccee1e845f015460405161124f91906120fd565b60405180910390a45b61128c670de0b6b3a764000061127e8460040154845f015461180a90919063ffffffff16565b61181f90919063ffffffff16565b8160010181905550505061129e611c02565b5050565b6112aa611861565b80156112b9576112b8610922565b5b60056040518060c001604052808673ffffffffffffffffffffffffffffffffffffffff1681526020018581526020018481526020014281526020015f81526020015f815250908060018154018082558091505060019003905f5260205f2090600602015f909190919091505f820151815f015f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506020820151816001015560408201518160020155606082015181600301556080820151816004015560a08201518160050155505050505050565b5f60045f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b6113d2611861565b5f73ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1603611442575f6040517f1e4fbdf70000000000000000000000000000000000000000000000000000000081526004016114399190612433565b60405180910390fd5b61144b816118e8565b50565b60035481565b61145c611861565b61146e8162278d0061032060016112a2565b611480816276a7006107d060016112a2565b6114928162ed4e00610dac60016112a2565b6114a581630163f500610fa060016112a2565b6114b8816301da9c0061138860016112a2565b6114ca8162278d006104b060016112a2565b6114dc816276a7006109c460016112a2565b6114ee8162ed4e0061119460016112a2565b61150181630163f50061157c60016112a2565b611514816301da9c00611b5860016112a2565b50565b60025f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6006602052815f5260405f208181548110611555575f80fd5b905f5260205f20015f915091509054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b61158c6119a9565b5f600583815481106115a1576115a061259d565b5b905f5260205f20906006020190505f60075f8581526020019081526020015f205f3373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20905082815f01541015611644576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161163b90612752565b60405180910390fd5b61165f826001015482600301546117f590919063ffffffff16565b4210156116a1576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611698906126ea565b60405180910390fd5b6116aa8461080e565b6116b484336119f8565b5f831115611746576116d283825f015461183490919063ffffffff16565b815f01819055506116f083836005015461183490919063ffffffff16565b82600501819055506117453384845f015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16611c0b9092919063ffffffff16565b5b5f815f01540361175b5761175a3385611c8a565b5b61178f670de0b6b3a76400006117818460040154845f015461180a90919063ffffffff16565b61181f90919063ffffffff16565b816001018190555042843373ffffffffffffffffffffffffffffffffffffffff167f02f25270a4d87bea75db541cdfe559334a275b4a233520ed6c0a2429667cca94866040516117df91906120fd565b60405180910390a450506117f1611c02565b5050565b5f8183611802919061265d565b905092915050565b5f81836118179190612770565b905092915050565b5f818361182c91906127de565b905092915050565b5f8183611841919061280e565b905092915050565b5f8183106118575781611859565b825b905092915050565b611869611dcd565b73ffffffffffffffffffffffffffffffffffffffff16611887610d53565b73ffffffffffffffffffffffffffffffffffffffff16146118e6576118aa611dcd565b6040517f118cdaa70000000000000000000000000000000000000000000000000000000081526004016118dd9190612433565b60405180910390fd5b565b5f805f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050815f806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b6002600154036119ee576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016119e59061288b565b60405180910390fd5b6002600181905550565b5f60058381548110611a0d57611a0c61259d565b5b905f5260205f20906006020190505f60075f8581526020019081526020015f205f8473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f2090505f611ab58260010154611aa7670de0b6b3a7640000611a998760040154875f015461180a90919063ffffffff16565b61181f90919063ffffffff16565b61183490919063ffffffff16565b9050611ace8183600201546117f590919063ffffffff16565b8260020181905550611aeb816008546117f590919063ffffffff16565b6008819055505050505050565b5f611b038383611dd4565b50905080611b7b5760065f8381526020019081526020015f2083908060018154018082558091505060019003905f5260205f20015f9091909190916101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055505b505050565b611bfc848573ffffffffffffffffffffffffffffffffffffffff166323b872dd868686604051602401611bb5939291906128a9565b604051602081830303815290604052915060e01b6020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050611ea1565b50505050565b60018081905550565b611c85838473ffffffffffffffffffffffffffffffffffffffff1663a9059cbb8585604051602401611c3e9291906128de565b604051602081830303815290604052915060e01b6020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050611ea1565b505050565b5f80611c968484611dd4565b915091508115611dc75760065f8481526020019081526020015f20600160065f8681526020019081526020015f2080549050611cd2919061280e565b81548110611ce357611ce261259d565b5b905f5260205f20015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1660065f8581526020019081526020015f208281548110611d2e57611d2d61259d565b5b905f5260205f20015f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555060065f8481526020019081526020015f20805480611d9457611d93612905565b5b600190038181905f5260205f20015f6101000a81549073ffffffffffffffffffffffffffffffffffffffff021916905590555b50505050565b5f33905090565b5f805f5b60065f8581526020019081526020015f2080549050811015611e925760065f8581526020019081526020015f208181548110611e1757611e1661259d565b5b905f5260205f20015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168573ffffffffffffffffffffffffffffffffffffffff1603611e7e576001819250925050611e9a565b600181611e8b919061265d565b9050611dd8565b505f80915091505b9250929050565b5f611ecb828473ffffffffffffffffffffffffffffffffffffffff16611f3690919063ffffffff16565b90505f815114158015611eef575080806020019051810190611eed9190612946565b155b15611f3157826040517f5274afe7000000000000000000000000000000000000000000000000000000008152600401611f289190612433565b60405180910390fd5b505050565b6060611f4383835f611f4b565b905092915050565b606081471015611f9257306040517fcd786059000000000000000000000000000000000000000000000000000000008152600401611f899190612433565b60405180910390fd5b5f808573ffffffffffffffffffffffffffffffffffffffff168486604051611fba91906129c3565b5f6040518083038185875af1925050503d805f8114611ff4576040519150601f19603f3d011682016040523d82523d5f602084013e611ff9565b606091505b5091509150612009868383612014565b925050509392505050565b60608261202957612024826120a1565b612099565b5f825114801561204f57505f8473ffffffffffffffffffffffffffffffffffffffff163b145b1561209157836040517f9996b3150000000000000000000000000000000000000000000000000000000081526004016120889190612433565b60405180910390fd5b81905061209a565b5b9392505050565b5f815111156120b35780518082602001fd5b6040517f1425ea4200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f819050919050565b6120f7816120e5565b82525050565b5f6020820190506121105f8301846120ee565b92915050565b5f80fd5b612123816120e5565b811461212d575f80fd5b50565b5f8135905061213e8161211a565b92915050565b5f6020828403121561215957612158612116565b5b5f61216684828501612130565b91505092915050565b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f819050919050565b5f6121b16121ac6121a78461216f565b61218e565b61216f565b9050919050565b5f6121c282612197565b9050919050565b5f6121d3826121b8565b9050919050565b6121e3816121c9565b82525050565b5f60c0820190506121fc5f8301896121da565b61220960208301886120ee565b61221660408301876120ee565b61222360608301866120ee565b61223060808301856120ee565b61223d60a08301846120ee565b979650505050505050565b5f806040838503121561225e5761225d612116565b5b5f61226b85828601612130565b925050602061227c85828601612130565b9150509250929050565b5f6122908261216f565b9050919050565b6122a081612286565b81146122aa575f80fd5b50565b5f813590506122bb81612297565b92915050565b5f80604083850312156122d7576122d6612116565b5b5f6122e485828601612130565b92505060206122f5858286016122ad565b9150509250929050565b5f8115159050919050565b612313816122ff565b82525050565b5f60208201905061232c5f83018461230a565b92915050565b5f805f806080858703121561234a57612349612116565b5b5f61235787828801612130565b945050602061236887828801612130565b9350506040612379878288016122ad565b925050606061238a878288016122ad565b91505092959194509250565b61239f816122ff565b81146123a9575f80fd5b50565b5f813590506123ba81612396565b92915050565b5f805f80608085870312156123d8576123d7612116565b5b5f6123e587828801612130565b94505060206123f687828801612130565b935050604061240787828801612130565b9250506060612418878288016123ac565b91505092959194509250565b61242d81612286565b82525050565b5f6020820190506124465f830184612424565b92915050565b5f60808201905061245f5f8301876120ee565b61246c60208301866120ee565b61247960408301856120ee565b61248660608301846120ee565b95945050505050565b5f602082840312156124a4576124a3612116565b5b5f6124b1848285016122ad565b91505092915050565b5f6124c482612286565b9050919050565b6124d4816124ba565b81146124de575f80fd5b50565b5f813590506124ef816124cb565b92915050565b5f805f806080858703121561250d5761250c612116565b5b5f61251a878288016124e1565b945050602061252b87828801612130565b935050604061253c87828801612130565b925050606061254d878288016123ac565b91505092959194509250565b5f6020828403121561256e5761256d612116565b5b5f61257b848285016124e1565b91505092915050565b5f6020820190506125975f8301846121da565b92915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603260045260245ffd5b5f815190506125d88161211a565b92915050565b5f602082840312156125f3576125f2612116565b5b5f612600848285016125ca565b91505092915050565b5f60408201905061261c5f830185612424565b6126296020830184612424565b9392505050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f612667826120e5565b9150612672836120e5565b925082820190508082111561268a57612689612630565b5b92915050565b5f82825260208201905092915050565b7f5374616b6520706572696f64206973206e6f7420657870697265642e2e0000005f82015250565b5f6126d4601d83612690565b91506126df826126a0565b602082019050919050565b5f6020820190508181035f830152612701816126c8565b9050919050565b7f77697468647261773a206e6f7420676f6f6400000000000000000000000000005f82015250565b5f61273c601283612690565b915061274782612708565b602082019050919050565b5f6020820190508181035f83015261276981612730565b9050919050565b5f61277a826120e5565b9150612785836120e5565b9250828202612793816120e5565b915082820484148315176127aa576127a9612630565b5b5092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601260045260245ffd5b5f6127e8826120e5565b91506127f3836120e5565b925082612803576128026127b1565b5b828204905092915050565b5f612818826120e5565b9150612823836120e5565b925082820390508181111561283b5761283a612630565b5b92915050565b7f5265656e7472616e637947756172643a207265656e7472616e742063616c6c005f82015250565b5f612875601f83612690565b915061288082612841565b602082019050919050565b5f6020820190508181035f8301526128a281612869565b9050919050565b5f6060820190506128bc5f830186612424565b6128c96020830185612424565b6128d660408301846120ee565b949350505050565b5f6040820190506128f15f830185612424565b6128fe60208301846120ee565b9392505050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603160045260245ffd5b5f8151905061294081612396565b92915050565b5f6020828403121561295b5761295a612116565b5b5f61296884828501612932565b91505092915050565b5f81519050919050565b5f81905092915050565b8281835e5f83830152505050565b5f61299d82612971565b6129a7818561297b565b93506129b7818560208601612985565b80840191505092915050565b5f6129ce8284612993565b91508190509291505056fea26469706673582212202cb73b3327bea952c65a927be7f0775b4e8620e067b1b1bf29ab1c749b5a846e64736f6c634300081a0033

000000000000000000000000b1c9d42fa4ba691efe21656a7e6953d999b990c4

-----Decoded View---------------
Arg [0] : _rewardToken (address): 0xB1c9D42FA4bA691eFe21656A7e6953d999B990c4

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

49089:11612:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51253:95;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50078:26;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;;:::i;:::-;;;;;;;;59227:96;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;51356:125;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59517:266;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50375:35;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52996:919;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54254:685;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53998:180;;;:::i;:::-;;59331:178;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44946:103;;;:::i;:::-;;55829:852;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;52481:256;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;44271:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52813:121;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50270:64;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;51115:130;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;58121:1098;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;50419:34;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55009:812;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;52065:408;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;51002:105;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45204:220;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;49957:40;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51489:568;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;49893:25;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50163:49;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51253:95;51298:7;51325:8;:15;;;;51318:22;;51253:95;:::o;50078:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;59227:96::-;59292:23;59301:4;59307:7;59292:8;:23::i;:::-;59227:96;;:::o;51356:125::-;51421:7;51448:12;:18;51461:4;51448:18;;;;;;;;;;;:25;;;;51441:32;;51356:125;;;:::o;59517:266::-;59592:4;59609:21;59633:8;59642:4;59633:14;;;;;;;;:::i;:::-;;;;;;;;;;;;59609:38;;59658:21;59682:8;:14;59691:4;59682:14;;;;;;;;;;;:21;59697:5;59682:21;;;;;;;;;;;;;;;59658:45;;59742:33;59761:4;:13;;;59742:4;:14;;;:18;;:33;;;;:::i;:::-;59723:15;:52;;59716:59;;;;59517:266;;;;:::o;50375:35::-;;;;:::o;52996:919::-;53070:7;53090:21;53114:8;53123:4;53114:14;;;;;;;;:::i;:::-;;;;;;;;;;;;53090:38;;53139:21;53163:8;:14;53172:4;53163:14;;;;;;;;;;;:21;53178:5;53163:21;;;;;;;;;;;;;;;53139:45;;53195:24;53222:4;:21;;;53195:48;;53254:16;53273:4;:16;;;53254:35;;53322:4;:19;;;53304:15;:37;:54;;;;;53357:1;53345:8;:13;;53304:54;53300:465;;;53375:18;53396:51;53410:4;:19;;;53431:15;53396:13;:51::i;:::-;53375:72;;53532:19;53554:69;53608:14;;53554:49;53597:5;53554:38;53581:10;53554:22;53567:4;:8;;;53554;:12;;:22;;;;:::i;:::-;:26;;:38;;;;:::i;:::-;:42;;:49;;;;:::i;:::-;:53;;:69;;;;:::i;:::-;53532:91;;53657:57;53678:35;53704:8;53678:21;53694:4;53678:11;:15;;:21;;;;:::i;:::-;:25;;:35;;;;:::i;:::-;53657:16;:20;;:57;;;;:::i;:::-;53638:76;;53360:405;;53300:465;53775:15;53793:64;53841:4;:15;;;53793:43;53831:4;53793:33;53809:16;53793:4;:11;;;:15;;:33;;;;:::i;:::-;:37;;:43;;;;:::i;:::-;:47;;:64;;;;:::i;:::-;53775:82;;53875:32;53887:4;:19;;;53875:7;:11;;:32;;;;:::i;:::-;53868:39;;;;;;;52996:919;;;;:::o;54254:685::-;54306:21;54330:8;54339:4;54330:14;;;;;;;;:::i;:::-;;;;;;;;;;;;54306:38;;54378:4;:19;;;54359:15;:38;54355:77;;54414:7;;;54355:77;54442:16;54461:4;:16;;;54442:35;;54504:1;54492:8;:13;54488:104;;54544:15;54522:4;:19;;:37;;;;54574:7;;;;54488:104;54602:18;54623:51;54637:4;:19;;;54658:15;54623:13;:51::i;:::-;54602:72;;54685:19;54707:69;54761:14;;54707:49;54750:5;54707:38;54734:10;54707:22;54720:4;:8;;;54707;:12;;:22;;;;:::i;:::-;:26;;:38;;;;:::i;:::-;:42;;:49;;;;:::i;:::-;:53;;:69;;;;:::i;:::-;54685:91;;54821:62;54847:35;54873:8;54847:21;54863:4;54847:11;:15;;:21;;;;:::i;:::-;:25;;:35;;;;:::i;:::-;54821:4;:21;;;:25;;:62;;;;:::i;:::-;54797:4;:21;;:86;;;;54916:15;54894:4;:19;;:37;;;;54295:644;;;;54254:685;;:::o;53998:180::-;54043:14;54060:8;:15;;;;54043:32;;54091:11;54086:85;54114:6;54108:3;:12;54086:85;;;54144:15;54155:3;54144:10;:15::i;:::-;54122:5;;;;;54086:85;;;;54032:146;53998:180::o;59331:178::-;59387:7;59414:87;59423:11;;;;;;;;;;;:21;;;59445:7;:5;:7::i;:::-;59423:30;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;59455:11;;;;;;;;;;;:21;;;59477:7;:5;:7::i;:::-;59494:4;59455:45;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;59414:8;:87::i;:::-;59407:94;;59331:178;:::o;44946:103::-;44157:13;:11;:13::i;:::-;45011:30:::1;45038:1;45011:18;:30::i;:::-;44946:103::o:0;55829:852::-;50957:16;;;;;;;;;;;50943:30;;:10;:30;;;50935:39;;;;;;48127:21:::1;:19;:21::i;:::-;55965::::2;55989:8;55998:4;55989:14;;;;;;;;:::i;:::-;;;;;;;;;;;;55965:38;;56014:21;56038:8;:14;56047:4;56038:14;;;;;;;;;;;:23;56053:7;56038:23;;;;;;;;;;;;;;;56014:47;;56072:16;56083:4;56072:10;:16::i;:::-;56099:33;56118:4;56124:7;56099:18;:33::i;:::-;56157:1;56147:7;:11;56143:454;;;56194:1;56179:4;:11;;;:16:::0;56175:138:::2;;56217:29;56232:7;56241:4;56217:14;:29::i;:::-;56282:15;56265:4;:14;;:32;;;;56175:138;56327:70;56365:6;56382:4;56389:7;56327:4;:12;;;;;;;;;;;;:29;;;;:70;;;;;;:::i;:::-;56426:24;56442:7;56426:4;:11;;;:15;;:24;;;;:::i;:::-;56412:4;:11;;:38;;;;56484:29;56505:7;56484:4;:16;;;:20;;:29;;;;:::i;:::-;56465:4;:16;;:48;;;;56569:15;56550:4;56541:7;56533:52;;;56556:4;:11;;;56533:52;;;;;;:::i;:::-;;;;;;;;56143:454;56625:48;56668:4;56625:38;56641:4;:21;;;56625:4;:11;;;:15;;:38;;;;:::i;:::-;:42;;:48;;;;:::i;:::-;56607:4;:15;;:66;;;;55953:728;;48171:20:::1;:18;:20::i;:::-;55829:852:::0;;;;:::o;52481:256::-;44157:13;:11;:13::i;:::-;52591:11:::1;52587:61;;;52619:17;:15;:17::i;:::-;52587:61;52684:9;52658:8;52667:4;52658:14;;;;;;;;:::i;:::-;;;;;;;;;;;;:23;;:35;;;;52725:4;52704:8;52713:4;52704:14;;;;;;;;:::i;:::-;;;;;;;;;;;;:18;;:25;;;;52481:256:::0;;;;:::o;44271:87::-;44317:7;44344:6;;;;;;;;;;;44337:13;;44271:87;:::o;52813:121::-;52885:7;52912:14;52920:5;52912:3;:7;;:14;;;;:::i;:::-;52905:21;;52813:121;;;;:::o;50270:64::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;51115:130::-;44157:13;:11;:13::i;:::-;51220:17:::1;51201:16;;:36;;;;;;;;;;;;;;;;;;51115:130:::0;:::o;58121:1098::-;48127:21;:19;:21::i;:::-;58186::::1;58210:8;58219:4;58210:14;;;;;;;;:::i;:::-;;;;;;;;;;;;58186:38;;58235:21;58259:8;:14;58268:4;58259:14;;;;;;;;;;;:26;58274:10;58259:26;;;;;;;;;;;;;;;58235:50;;58323:42;58358:6;58342:4;:13;;;:22;;;;:::i;:::-;58323:4;:14;;;:18;;:42;;;;:::i;:::-;58304:15;:61;;58296:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;58410:16;58421:4;58410:10;:16::i;:::-;58437:36;58456:4;58462:10;58437:18;:36::i;:::-;58486:15;58504:69;58557:4;:15;;;58504:48;58547:4;58504:38;58520:4;:21;;;58504:4;:11;;;:15;;:38;;;;:::i;:::-;:42;;:48;;;;:::i;:::-;:52;;:69;;;;:::i;:::-;58486:87;;58600:1;58590:7;:11;:38;;;;58627:1;58605:4;:19;;;:23;58590:38;58586:626;;;58645:20;58668:32;58680:4;:19;;;58668:7;:11;;:32;;;;:::i;:::-;58645:55;;58737:37;58761:12;58737:19;;:23;;:37;;;;:::i;:::-;58715:19;:59;;;;58845:45;58870:4;:19;;;58845:20;;:24;;:45;;;;:::i;:::-;58822:20;:68;;;;58927:1;58905:4;:19;;:23;;;;58961:48;59004:4;58961:38;58977:4;:21;;;58961:4;:11;;;:15;;:38;;;;:::i;:::-;:42;;:48;;;;:::i;:::-;58943:4;:15;;:66;;;;59053:63;59082:7;:5;:7::i;:::-;59091:10;59103:12;59053:11;;;;;;;;;;;:28;;;;:63;;;;;;:::i;:::-;59184:15;59158:10;59150:50;;;59170:12;59150:50;;;;;;:::i;:::-;;;;;;;;58630:582;58586:626;58175:1044;;;48171:20:::0;:18;:20::i;:::-;58121:1098;:::o;50419:34::-;;;;:::o;55009:812::-;48127:21;:19;:21::i;:::-;55089::::1;55113:8;55122:4;55113:14;;;;;;;;:::i;:::-;;;;;;;;;;;;55089:38;;55138:21;55162:8;:14;55171:4;55162:14;;;;;;;;;;;:26;55177:10;55162:26;;;;;;;;;;;;;;;55138:50;;55199:16;55210:4;55199:10;:16::i;:::-;55226:36;55245:4;55251:10;55226:18;:36::i;:::-;55287:1;55277:7;:11;55273:464;;;55324:1;55309:4;:11;;;:16:::0;55305:141:::1;;55347:32;55362:10;55374:4;55347:14;:32::i;:::-;55415:15;55398:4;:14;;:32;;;;55305:141;55460:74;55498:10;55519:4;55526:7;55460:4;:12;;;;;;;;;;;;:29;;;;:74;;;;;;:::i;:::-;55563:24;55579:7;55563:4;:11;;;:15;;:24;;;;:::i;:::-;55549:4;:11;;:38;;;;55621:29;55642:7;55621:4;:16;;;:20;;:29;;;;:::i;:::-;55602:4;:16;;:48;;;;55709:15;55690:4;55678:10;55670:55;;;55696:4;:11;;;55670:55;;;;;;:::i;:::-;;;;;;;;55273:464;55765:48;55808:4;55765:38;55781:4;:21;;;55765:4;:11;;;:15;;:38;;;;:::i;:::-;:42;;:48;;;;:::i;:::-;55747:4;:15;;:66;;;;55077:744;;48171:20:::0;:18;:20::i;:::-;55009:812;;:::o;52065:408::-;44157:13;:11;:13::i;:::-;52188:11:::1;52184:61;;;52216:17;:15;:17::i;:::-;52184:61;52255:8;52269:195;;;;;;;;52298:8;52269:195;;;;;;52327:9;52269:195;;;;52352:4;52269:195;;;;52383:15;52269:195;;;;52427:1;52269:195;;;;52451:1;52269:195;;::::0;52255:210:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52065:408:::0;;;;:::o;51002:105::-;51056:7;51083:16;;;;;;;;;;;51076:23;;51002:105;:::o;45204:220::-;44157:13;:11;:13::i;:::-;45309:1:::1;45289:22;;:8;:22;;::::0;45285:93:::1;;45363:1;45335:31;;;;;;;;;;;:::i;:::-;;;;;;;;45285:93;45388:28;45407:8;45388:18;:28::i;:::-;45204:220:::0;:::o;49957:40::-;;;;:::o;51489:568::-;44157:13;:11;:13::i;:::-;51562:35:::1;51566:9;51577:8;51587:3;51592:4;51562:3;:35::i;:::-;51608:38;51612:9;51623:10;51635:4;51641;51608:3;:38::i;:::-;51657;51661:9;51672:10;51684:4;51690;51657:3;:38::i;:::-;51706;51710:9;51721:10;51733:4;51739;51706:3;:38::i;:::-;51755:39;51759:9;51770:11;51783:4;51789;51755:3;:39::i;:::-;51811:36;51815:9;51826:8;51836:4;51842;51811:3;:36::i;:::-;51858:38;51862:9;51873:10;51885:4;51891;51858:3;:38::i;:::-;51907;51911:9;51922:10;51934:4;51940;51907:3;:38::i;:::-;51956;51960:9;51971:10;51983:4;51989;51956:3;:38::i;:::-;52005:39;52009:9;52020:11;52033:4;52039;52005:3;:39::i;:::-;51489:568:::0;:::o;49893:25::-;;;;;;;;;;;;;:::o;50163:49::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;56735:900::-;48127:21;:19;:21::i;:::-;56817::::1;56841:8;56850:4;56841:14;;;;;;;;:::i;:::-;;;;;;;;;;;;56817:38;;56866:21;56890:8;:14;56899:4;56890:14;;;;;;;;;;;:26;56905:10;56890:26;;;;;;;;;;;;;;;56866:50;;56950:7;56935:4;:11;;;:22;;56927:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;57018:33;57037:4;:13;;;57018:4;:14;;;:18;;:33;;;;:::i;:::-;56999:15;:52;;56991:94;;;;;;;;;;;;:::i;:::-;;;;;;;;;57096:16;57107:4;57096:10;:16::i;:::-;57123:36;57142:4;57148:10;57123:18;:36::i;:::-;57184:1;57174:7;:11;57170:215;;;57216:24;57232:7;57216:4;:11;;;:15;;:24;;;;:::i;:::-;57202:4;:11;;:38;;;;57274:29;57295:7;57274:4;:16;;;:20;;:29;;;;:::i;:::-;57255:4;:16;;:48;;;;57318:55;57352:10;57365:7;57318:4;:12;;;;;;;;;;;;:25;;;;:55;;;;;:::i;:::-;57170:215;57415:1;57400:4;:11;;;:16:::0;57395:86:::1;;57434:35;57452:10;57464:4;57434:17;:35::i;:::-;57395:86;57511:48;57554:4;57511:38;57527:4;:21;;;57511:4;:11;;;:15;;:38;;;;:::i;:::-;:42;;:48;;;;:::i;:::-;57493:4;:15;;:66;;;;57611:15;57596:4;57584:10;57575:52;;;57602:7;57575:52;;;;;;:::i;:::-;;;;;;;;56806:829;;48171:20:::0;:18;:20::i;:::-;56735:900;;:::o;2911:98::-;2969:7;3000:1;2996;:5;;;;:::i;:::-;2989:12;;2911:98;;;;:::o;3649:::-;3707:7;3738:1;3734;:5;;;;:::i;:::-;3727:12;;3649:98;;;;:::o;4048:::-;4106:7;4137:1;4133;:5;;;;:::i;:::-;4126:12;;4048:98;;;;:::o;3292:::-;3350:7;3381:1;3377;:5;;;;:::i;:::-;3370:12;;3292:98;;;;:::o;9643:106::-;9701:7;9732:1;9728;:5;:13;;9740:1;9728:13;;;9736:1;9728:13;9721:20;;9643:106;;;;:::o;44436:166::-;44507:12;:10;:12::i;:::-;44496:23;;:7;:5;:7::i;:::-;:23;;;44492:103;;44570:12;:10;:12::i;:::-;44543:40;;;;;;;;;;;:::i;:::-;;;;;;;;44492:103;44436:166::o;45584:191::-;45658:16;45677:6;;;;;;;;;;;45658:25;;45703:8;45694:6;;:17;;;;;;;;;;;;;;;;;;45758:8;45727:40;;45748:8;45727:40;;;;;;;;;;;;45647:128;45584:191;:::o;48207:293::-;47609:1;48341:7;;:19;48333:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;47609:1;48474:7;:18;;;;48207:293::o;57679:434::-;57761:21;57785:8;57794:4;57785:14;;;;;;;;:::i;:::-;;;;;;;;;;;;57761:38;;57810:21;57834:8;:14;57843:4;57834:14;;;;;;;;;;;:26;57849:10;57834:26;;;;;;;;;;;;;;;57810:50;;57873:15;57891:69;57944:4;:15;;;57891:48;57934:4;57891:38;57907:4;:21;;;57891:4;:11;;;:15;;:38;;;;:::i;:::-;:42;;:48;;;;:::i;:::-;:52;;:69;;;;:::i;:::-;57873:87;;57996:32;58020:7;57996:4;:19;;;:23;;:32;;;;:::i;:::-;57974:4;:19;;:54;;;;58062:33;58087:7;58062:20;;:24;;:33;;;;:::i;:::-;58039:20;:56;;;;57750:363;;;57679:434;;:::o;60114:229::-;60209:19;60234:33;60248:12;60262:4;60234:13;:33::i;:::-;60208:59;;;60282:14;60278:57;;60298:12;:18;60311:4;60298:18;;;;;;;;;;;60322:12;60298:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60278:57;60197:146;60114:229;;:::o;37440:190::-;37541:81;37561:5;37583;:18;;;37604:4;37610:2;37614:5;37568:53;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37541:19;:81::i;:::-;37440:190;;;;:::o;48508:213::-;47565:1;48691:7;:22;;;;48508:213::o;37033:162::-;37116:71;37136:5;37158;:14;;;37175:2;37179:5;37143:43;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37116:19;:71::i;:::-;37033:162;;;:::o;60357:338::-;60452:19;60473:9;60486:33;60500:12;60514:4;60486:13;:33::i;:::-;60451:68;;;;60533:14;60530:157;;;60587:12;:18;60600:4;60587:18;;;;;;;;;;;60634:1;60606:12;:18;60619:4;60606:18;;;;;;;;;;;:25;;;;:29;;;;:::i;:::-;60587:49;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;60563:12;:18;60576:4;60563:18;;;;;;;;;;;60582:1;60563:21;;;;;;;;:::i;:::-;;;;;;;;;;:73;;;;;;;;;;;;;;;;;;60651:12;:18;60664:4;60651:18;;;;;;;;;;;:24;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;60530:157;60440:255;;60357:338;;:::o;42280:98::-;42333:7;42360:10;42353:17;;42280:98;:::o;59791:310::-;59895:4;59901:7;59931:9;59926:140;59950:12;:18;59963:4;59950:18;;;;;;;;;;;:25;;;;59946:1;:29;59926:140;;;60015:12;:18;60028:4;60015:18;;;;;;;;;;;60034:1;60015:21;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;60003:33;;:8;:33;;;59999:55;;60046:4;60052:1;60038:16;;;;;;;59999:55;59982:1;59977:6;;;;;:::i;:::-;;;59926:140;;;;60084:5;60091:1;60076:17;;;;59791:310;;;;;;:::o;39844:638::-;40268:23;40294:33;40322:4;40302:5;40294:27;;;;:33;;;;:::i;:::-;40268:59;;40363:1;40342:10;:17;:22;;:57;;;;;40380:10;40369:30;;;;;;;;;;;;:::i;:::-;40368:31;40342:57;40338:137;;;40456:5;40423:40;;;;;;;;;;;:::i;:::-;;;;;;;;40338:137;39914:568;39844:638;;:::o;32159:153::-;32234:12;32266:38;32288:6;32296:4;32302:1;32266:21;:38::i;:::-;32259:45;;32159:153;;;;:::o;32647:398::-;32746:12;32799:5;32775:21;:29;32771:110;;;32863:4;32828:41;;;;;;;;;;;:::i;:::-;;;;;;;;32771:110;32892:12;32906:23;32933:6;:11;;32952:5;32959:4;32933:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32891:73;;;;32982:55;33009:6;33017:7;33026:10;32982:26;:55::i;:::-;32975:62;;;;32647:398;;;;;:::o;34123:597::-;34271:12;34301:7;34296:417;;34325:19;34333:10;34325:7;:19::i;:::-;34296:417;;;34574:1;34553:10;:17;:22;:49;;;;;34601:1;34579:6;:18;;;:23;34553:49;34549:121;;;34647:6;34630:24;;;;;;;;;;;:::i;:::-;;;;;;;;34549:121;34691:10;34684:17;;;;34296:417;34123:597;;;;;;:::o;35273:528::-;35426:1;35406:10;:17;:21;35402:392;;;35638:10;35632:17;35695:15;35682:10;35678:2;35674:19;35667:44;35402:392;35765:17;;;;;;;;;;;;;;7:77:1;44:7;73:5;62:16;;7:77;;;:::o;90:118::-;177:24;195:5;177:24;:::i;:::-;172:3;165:37;90:118;;:::o;214:222::-;307:4;345:2;334:9;330:18;322:26;;358:71;426:1;415:9;411:17;402:6;358:71;:::i;:::-;214:222;;;;:::o;523:117::-;632:1;629;622:12;769:122;842:24;860:5;842:24;:::i;:::-;835:5;832:35;822:63;;881:1;878;871:12;822:63;769:122;:::o;897:139::-;943:5;981:6;968:20;959:29;;997:33;1024:5;997:33;:::i;:::-;897:139;;;;:::o;1042:329::-;1101:6;1150:2;1138:9;1129:7;1125:23;1121:32;1118:119;;;1156:79;;:::i;:::-;1118:119;1276:1;1301:53;1346:7;1337:6;1326:9;1322:22;1301:53;:::i;:::-;1291:63;;1247:117;1042:329;;;;:::o;1377:126::-;1414:7;1454:42;1447:5;1443:54;1432:65;;1377:126;;;:::o;1509:60::-;1537:3;1558:5;1551:12;;1509:60;;;:::o;1575:142::-;1625:9;1658:53;1676:34;1685:24;1703:5;1685:24;:::i;:::-;1676:34;:::i;:::-;1658:53;:::i;:::-;1645:66;;1575:142;;;:::o;1723:126::-;1773:9;1806:37;1837:5;1806:37;:::i;:::-;1793:50;;1723:126;;;:::o;1855:141::-;1920:9;1953:37;1984:5;1953:37;:::i;:::-;1940:50;;1855:141;;;:::o;2002:161::-;2104:52;2150:5;2104:52;:::i;:::-;2099:3;2092:65;2002:161;;:::o;2169:805::-;2417:4;2455:3;2444:9;2440:19;2432:27;;2469:86;2552:1;2541:9;2537:17;2528:6;2469:86;:::i;:::-;2565:72;2633:2;2622:9;2618:18;2609:6;2565:72;:::i;:::-;2647;2715:2;2704:9;2700:18;2691:6;2647:72;:::i;:::-;2729;2797:2;2786:9;2782:18;2773:6;2729:72;:::i;:::-;2811:73;2879:3;2868:9;2864:19;2855:6;2811:73;:::i;:::-;2894;2962:3;2951:9;2947:19;2938:6;2894:73;:::i;:::-;2169:805;;;;;;;;;:::o;2980:474::-;3048:6;3056;3105:2;3093:9;3084:7;3080:23;3076:32;3073:119;;;3111:79;;:::i;:::-;3073:119;3231:1;3256:53;3301:7;3292:6;3281:9;3277:22;3256:53;:::i;:::-;3246:63;;3202:117;3358:2;3384:53;3429:7;3420:6;3409:9;3405:22;3384:53;:::i;:::-;3374:63;;3329:118;2980:474;;;;;:::o;3460:96::-;3497:7;3526:24;3544:5;3526:24;:::i;:::-;3515:35;;3460:96;;;:::o;3562:122::-;3635:24;3653:5;3635:24;:::i;:::-;3628:5;3625:35;3615:63;;3674:1;3671;3664:12;3615:63;3562:122;:::o;3690:139::-;3736:5;3774:6;3761:20;3752:29;;3790:33;3817:5;3790:33;:::i;:::-;3690:139;;;;:::o;3835:474::-;3903:6;3911;3960:2;3948:9;3939:7;3935:23;3931:32;3928:119;;;3966:79;;:::i;:::-;3928:119;4086:1;4111:53;4156:7;4147:6;4136:9;4132:22;4111:53;:::i;:::-;4101:63;;4057:117;4213:2;4239:53;4284:7;4275:6;4264:9;4260:22;4239:53;:::i;:::-;4229:63;;4184:118;3835:474;;;;;:::o;4315:90::-;4349:7;4392:5;4385:13;4378:21;4367:32;;4315:90;;;:::o;4411:109::-;4492:21;4507:5;4492:21;:::i;:::-;4487:3;4480:34;4411:109;;:::o;4526:210::-;4613:4;4651:2;4640:9;4636:18;4628:26;;4664:65;4726:1;4715:9;4711:17;4702:6;4664:65;:::i;:::-;4526:210;;;;:::o;4742:765::-;4828:6;4836;4844;4852;4901:3;4889:9;4880:7;4876:23;4872:33;4869:120;;;4908:79;;:::i;:::-;4869:120;5028:1;5053:53;5098:7;5089:6;5078:9;5074:22;5053:53;:::i;:::-;5043:63;;4999:117;5155:2;5181:53;5226:7;5217:6;5206:9;5202:22;5181:53;:::i;:::-;5171:63;;5126:118;5283:2;5309:53;5354:7;5345:6;5334:9;5330:22;5309:53;:::i;:::-;5299:63;;5254:118;5411:2;5437:53;5482:7;5473:6;5462:9;5458:22;5437:53;:::i;:::-;5427:63;;5382:118;4742:765;;;;;;;:::o;5513:116::-;5583:21;5598:5;5583:21;:::i;:::-;5576:5;5573:32;5563:60;;5619:1;5616;5609:12;5563:60;5513:116;:::o;5635:133::-;5678:5;5716:6;5703:20;5694:29;;5732:30;5756:5;5732:30;:::i;:::-;5635:133;;;;:::o;5774:759::-;5857:6;5865;5873;5881;5930:3;5918:9;5909:7;5905:23;5901:33;5898:120;;;5937:79;;:::i;:::-;5898:120;6057:1;6082:53;6127:7;6118:6;6107:9;6103:22;6082:53;:::i;:::-;6072:63;;6028:117;6184:2;6210:53;6255:7;6246:6;6235:9;6231:22;6210:53;:::i;:::-;6200:63;;6155:118;6312:2;6338:53;6383:7;6374:6;6363:9;6359:22;6338:53;:::i;:::-;6328:63;;6283:118;6440:2;6466:50;6508:7;6499:6;6488:9;6484:22;6466:50;:::i;:::-;6456:60;;6411:115;5774:759;;;;;;;:::o;6539:118::-;6626:24;6644:5;6626:24;:::i;:::-;6621:3;6614:37;6539:118;;:::o;6663:222::-;6756:4;6794:2;6783:9;6779:18;6771:26;;6807:71;6875:1;6864:9;6860:17;6851:6;6807:71;:::i;:::-;6663:222;;;;:::o;6891:553::-;7068:4;7106:3;7095:9;7091:19;7083:27;;7120:71;7188:1;7177:9;7173:17;7164:6;7120:71;:::i;:::-;7201:72;7269:2;7258:9;7254:18;7245:6;7201:72;:::i;:::-;7283;7351:2;7340:9;7336:18;7327:6;7283:72;:::i;:::-;7365;7433:2;7422:9;7418:18;7409:6;7365:72;:::i;:::-;6891:553;;;;;;;:::o;7450:329::-;7509:6;7558:2;7546:9;7537:7;7533:23;7529:32;7526:119;;;7564:79;;:::i;:::-;7526:119;7684:1;7709:53;7754:7;7745:6;7734:9;7730:22;7709:53;:::i;:::-;7699:63;;7655:117;7450:329;;;;:::o;7785:111::-;7837:7;7866:24;7884:5;7866:24;:::i;:::-;7855:35;;7785:111;;;:::o;7902:152::-;7990:39;8023:5;7990:39;:::i;:::-;7983:5;7980:50;7970:78;;8044:1;8041;8034:12;7970:78;7902:152;:::o;8060:169::-;8121:5;8159:6;8146:20;8137:29;;8175:48;8217:5;8175:48;:::i;:::-;8060:169;;;;:::o;8235:789::-;8333:6;8341;8349;8357;8406:3;8394:9;8385:7;8381:23;8377:33;8374:120;;;8413:79;;:::i;:::-;8374:120;8533:1;8558:68;8618:7;8609:6;8598:9;8594:22;8558:68;:::i;:::-;8548:78;;8504:132;8675:2;8701:53;8746:7;8737:6;8726:9;8722:22;8701:53;:::i;:::-;8691:63;;8646:118;8803:2;8829:53;8874:7;8865:6;8854:9;8850:22;8829:53;:::i;:::-;8819:63;;8774:118;8931:2;8957:50;8999:7;8990:6;8979:9;8975:22;8957:50;:::i;:::-;8947:60;;8902:115;8235:789;;;;;;;:::o;9030:359::-;9104:6;9153:2;9141:9;9132:7;9128:23;9124:32;9121:119;;;9159:79;;:::i;:::-;9121:119;9279:1;9304:68;9364:7;9355:6;9344:9;9340:22;9304:68;:::i;:::-;9294:78;;9250:132;9030:359;;;;:::o;9395:252::-;9503:4;9541:2;9530:9;9526:18;9518:26;;9554:86;9637:1;9626:9;9622:17;9613:6;9554:86;:::i;:::-;9395:252;;;;:::o;9653:180::-;9701:77;9698:1;9691:88;9798:4;9795:1;9788:15;9822:4;9819:1;9812:15;9839:143;9896:5;9927:6;9921:13;9912:22;;9943:33;9970:5;9943:33;:::i;:::-;9839:143;;;;:::o;9988:351::-;10058:6;10107:2;10095:9;10086:7;10082:23;10078:32;10075:119;;;10113:79;;:::i;:::-;10075:119;10233:1;10258:64;10314:7;10305:6;10294:9;10290:22;10258:64;:::i;:::-;10248:74;;10204:128;9988:351;;;;:::o;10345:332::-;10466:4;10504:2;10493:9;10489:18;10481:26;;10517:71;10585:1;10574:9;10570:17;10561:6;10517:71;:::i;:::-;10598:72;10666:2;10655:9;10651:18;10642:6;10598:72;:::i;:::-;10345:332;;;;;:::o;10683:180::-;10731:77;10728:1;10721:88;10828:4;10825:1;10818:15;10852:4;10849:1;10842:15;10869:191;10909:3;10928:20;10946:1;10928:20;:::i;:::-;10923:25;;10962:20;10980:1;10962:20;:::i;:::-;10957:25;;11005:1;11002;10998:9;10991:16;;11026:3;11023:1;11020:10;11017:36;;;11033:18;;:::i;:::-;11017:36;10869:191;;;;:::o;11066:169::-;11150:11;11184:6;11179:3;11172:19;11224:4;11219:3;11215:14;11200:29;;11066:169;;;;:::o;11241:179::-;11381:31;11377:1;11369:6;11365:14;11358:55;11241:179;:::o;11426:366::-;11568:3;11589:67;11653:2;11648:3;11589:67;:::i;:::-;11582:74;;11665:93;11754:3;11665:93;:::i;:::-;11783:2;11778:3;11774:12;11767:19;;11426:366;;;:::o;11798:419::-;11964:4;12002:2;11991:9;11987:18;11979:26;;12051:9;12045:4;12041:20;12037:1;12026:9;12022:17;12015:47;12079:131;12205:4;12079:131;:::i;:::-;12071:139;;11798:419;;;:::o;12223:168::-;12363:20;12359:1;12351:6;12347:14;12340:44;12223:168;:::o;12397:366::-;12539:3;12560:67;12624:2;12619:3;12560:67;:::i;:::-;12553:74;;12636:93;12725:3;12636:93;:::i;:::-;12754:2;12749:3;12745:12;12738:19;;12397:366;;;:::o;12769:419::-;12935:4;12973:2;12962:9;12958:18;12950:26;;13022:9;13016:4;13012:20;13008:1;12997:9;12993:17;12986:47;13050:131;13176:4;13050:131;:::i;:::-;13042:139;;12769:419;;;:::o;13194:410::-;13234:7;13257:20;13275:1;13257:20;:::i;:::-;13252:25;;13291:20;13309:1;13291:20;:::i;:::-;13286:25;;13346:1;13343;13339:9;13368:30;13386:11;13368:30;:::i;:::-;13357:41;;13547:1;13538:7;13534:15;13531:1;13528:22;13508:1;13501:9;13481:83;13458:139;;13577:18;;:::i;:::-;13458:139;13242:362;13194:410;;;;:::o;13610:180::-;13658:77;13655:1;13648:88;13755:4;13752:1;13745:15;13779:4;13776:1;13769:15;13796:185;13836:1;13853:20;13871:1;13853:20;:::i;:::-;13848:25;;13887:20;13905:1;13887:20;:::i;:::-;13882:25;;13926:1;13916:35;;13931:18;;:::i;:::-;13916:35;13973:1;13970;13966:9;13961:14;;13796:185;;;;:::o;13987:194::-;14027:4;14047:20;14065:1;14047:20;:::i;:::-;14042:25;;14081:20;14099:1;14081:20;:::i;:::-;14076:25;;14125:1;14122;14118:9;14110:17;;14149:1;14143:4;14140:11;14137:37;;;14154:18;;:::i;:::-;14137:37;13987:194;;;;:::o;14187:181::-;14327:33;14323:1;14315:6;14311:14;14304:57;14187:181;:::o;14374:366::-;14516:3;14537:67;14601:2;14596:3;14537:67;:::i;:::-;14530:74;;14613:93;14702:3;14613:93;:::i;:::-;14731:2;14726:3;14722:12;14715:19;;14374:366;;;:::o;14746:419::-;14912:4;14950:2;14939:9;14935:18;14927:26;;14999:9;14993:4;14989:20;14985:1;14974:9;14970:17;14963:47;15027:131;15153:4;15027:131;:::i;:::-;15019:139;;14746:419;;;:::o;15171:442::-;15320:4;15358:2;15347:9;15343:18;15335:26;;15371:71;15439:1;15428:9;15424:17;15415:6;15371:71;:::i;:::-;15452:72;15520:2;15509:9;15505:18;15496:6;15452:72;:::i;:::-;15534;15602:2;15591:9;15587:18;15578:6;15534:72;:::i;:::-;15171:442;;;;;;:::o;15619:332::-;15740:4;15778:2;15767:9;15763:18;15755:26;;15791:71;15859:1;15848:9;15844:17;15835:6;15791:71;:::i;:::-;15872:72;15940:2;15929:9;15925:18;15916:6;15872:72;:::i;:::-;15619:332;;;;;:::o;15957:180::-;16005:77;16002:1;15995:88;16102:4;16099:1;16092:15;16126:4;16123:1;16116:15;16143:137;16197:5;16228:6;16222:13;16213:22;;16244:30;16268:5;16244:30;:::i;:::-;16143:137;;;;:::o;16286:345::-;16353:6;16402:2;16390:9;16381:7;16377:23;16373:32;16370:119;;;16408:79;;:::i;:::-;16370:119;16528:1;16553:61;16606:7;16597:6;16586:9;16582:22;16553:61;:::i;:::-;16543:71;;16499:125;16286:345;;;;:::o;16637:98::-;16688:6;16722:5;16716:12;16706:22;;16637:98;;;:::o;16741:147::-;16842:11;16879:3;16864:18;;16741:147;;;;:::o;16894:139::-;16983:6;16978:3;16973;16967:23;17024:1;17015:6;17010:3;17006:16;16999:27;16894:139;;;:::o;17039:386::-;17143:3;17171:38;17203:5;17171:38;:::i;:::-;17225:88;17306:6;17301:3;17225:88;:::i;:::-;17218:95;;17322:65;17380:6;17375:3;17368:4;17361:5;17357:16;17322:65;:::i;:::-;17412:6;17407:3;17403:16;17396:23;;17147:278;17039:386;;;;:::o;17431:271::-;17561:3;17583:93;17672:3;17663:6;17583:93;:::i;:::-;17576:100;;17693:3;17686:10;;17431:271;;;;:::o

ipfs://2cb73b3327bea952c65a927be7f0775b4e8620e067b1b1bf29ab1c749b5a846e