Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b, st ...
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(address target, ...
•    - function functionCallWithValue(addres ...
•    - function functionCallWithValue(addres ...
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(address t ...
•    - function _verifyCallResult(bool succe ...
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeApprove(IERC20 token, ad ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function _callOptionalReturn(IERC20 t ...
• library EnumerableSet
•    - function _add(Set storage set, bytes3 ...
•    - function _remove(Set storage set, byt ...
•    - function _contains(Set storage set, b ...
•    - function _length(Set storage set)
•    - function _at(Set storage set, uint256 ...
•    - function add(Bytes32Set storage set, ...
•    - function remove(Bytes32Set storage se ...
•    - function contains(Bytes32Set storage ...
•    - function length(Bytes32Set storage se ...
•    - function at(Bytes32Set storage set, u ...
•    - function add(AddressSet storage set, ...
•    - function remove(AddressSet storage se ...
•    - function contains(AddressSet storage ...
•    - function length(AddressSet storage se ...
•    - function at(AddressSet storage set, u ...
•    - function add(UintSet storage set, uin ...
•    - function remove(UintSet storage set, ...
•    - function contains(UintSet storage set ...
•    - function length(UintSet storage set)
•    - function at(UintSet storage set, uint ...
•    - function _msgSender()
•    - function _msgData()
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
• interface IAccessControl
•    - function hasRole(bytes32 role, addres ...
• interface IMigratorChef
•    - function migrate(IERC20 token)
• interface ITokenIssue
•    - function transByContract(address to, ...
•    - function issueInfo(uint256 monthIndex ...
•    - function startIssueTime()
•    - function issueInfoLength()
•    - function TOTAL_AMOUNT()
•    - function DAY_SECONDS()
•    - function MONTH_SECONDS()
•    - function INIT_MINE_SUPPLY()
•  contract MasterChef is Ownable *
•    - function poolLength()
•    - function add(uint256 _allocPoint, IER ...
•    - function set(uint256 _pid, uint256 _a ...
•    - function setMigrator(IMigratorChef _m ...
•    - function setTokenIssue(ITokenIssue _t ...
•    - function setTotalIssueRate(uint256 _t ...
•    - function migrate(uint256 _pid)
•    - function getMultiplier(uint256 _from, ...
•    - function getIssue(uint256 _from, uint ...
•    - function pendingSumma(uint256 _pid, a ...
•    - function massUpdatePools()
•    - function updatePool(uint256 _pid)
•    - function deposit(uint256 _pid, uint25 ...
•    - function withdraw(uint256 _pid, uint2 ...
•    - function emergencyWithdraw(uint256 _p ...
•    - function safeSummaTransfer(address _t ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-03-15
*/

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



pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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



pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @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) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @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 sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @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) {
        // 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 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts 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) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts 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) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts 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 mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message 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, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

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



pragma solidity >=0.6.2 <0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

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

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: value }(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            // 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

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

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



pragma solidity >=0.6.0 <0.8.0;




/**
 * @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 SafeMath for uint256;
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    /**
     * @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, "SafeERC20: low-level call failed");
        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

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



pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;

        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping (bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) { // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            bytes32 lastvalue = set._values[lastIndex];

            // Move the last value to the index where the value to delete is
            set._values[toDeleteIndex] = lastvalue;
            // Update the index for the moved value
            set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        require(set._values.length > index, "EnumerableSet: index out of bounds");
        return set._values[index];
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(value)));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(value)));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(value)));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint256(_at(set._inner, index)));
    }


    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }
}

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



pragma solidity >=0.6.0 <0.8.0;

/*
 * @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 GSN 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 payable) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

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



pragma solidity >=0.6.0 <0.8.0;

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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = 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 {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// File: contracts/interfaces/IAccessControl.sol

pragma solidity ^0.6.0;

interface IAccessControl {
    function hasRole(bytes32 role, address account) external view returns (bool);
}

// File: contracts/MasterChef.sol

pragma solidity >=0.6.6;







interface IMigratorChef {
    function migrate(IERC20 token) external returns (IERC20);
}

interface ITokenIssue {
    function transByContract(address to, uint256 amount) external;

    function issueInfo(uint256 monthIndex) external view returns (uint256);

    function startIssueTime() external view returns (uint256);

    function issueInfoLength() external view returns (uint256);

    function TOTAL_AMOUNT() external view returns (uint256);

    function DAY_SECONDS() external view returns (uint256);

    function MONTH_SECONDS() external view returns (uint256);

    function INIT_MINE_SUPPLY() external view returns (uint256);
}

// MasterChef is the master of Summa. He can make Summa and he is a fair guy.
//
// Note that it's ownable and the owner wields tremendous power. The ownership
// will be transferred to a governance smart contract once SUMMA is sufficiently
// distributed and the community can show to govern itself.
//
// Have fun reading it. Hopefully it's bug-free. God bless.
contract MasterChef is Ownable {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    bytes32 public constant PUBLIC_ROLE = keccak256("PUBLIC_ROLE");

    // Info of each user.
    struct UserInfo {
        uint256 amount;     // How many LP tokens the user has provided.
        uint256 rewardDebt; // Reward debt. See explanation below.
        //
        // We do some fancy math here. Basically, any point in time, the amount of SUMMAs
        // entitled to a user but is pending to be distributed is:
        //
        //   pending reward = (user.amount * pool.accSUMMAPerShare) - user.rewardDebt
        //
        // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
        //   1. The pool's `accSUMMAPerShare` (and `lastRewardBlock`) gets updated.
        //   2. User receives the pending reward sent to his/her address.
        //   3. User's `amount` gets updated.
        //   4. User's `rewardDebt` gets updated.
    }

    // Info of each pool.
    struct PoolInfo {
        IERC20 lpToken;           // Address of LP token contract.
        uint256 allocPoint;       // How many allocation points assigned to this pool. SUMMAs to distribute per block.
        uint256 lastRewardTime;  // Last seconds that SUMMAs distribution occurs.
        uint256 accSummaPerShare; // Accumulated SUMMAs per share, times 1e12. See below.
    }

    // The SUMMA TOKEN!
    IERC20 public summa;
    // Block number when bonus SUMMA period ends.
    uint256 public bonusEndTime;
    // Bonus muliplier for early summa makers.
    uint256 public constant BONUS_MULTIPLIER = 1;
    // The migrator contract. It has a lot of power. Can only be set through governance (owner).
    IMigratorChef public migrator;

    IAccessControl public accessContract;

    ITokenIssue public tokenIssue;

    uint256 public totalIssueRate = 0.2 * 10000;
    // Info of each pool.
    PoolInfo[] public poolInfo;
    // Info of each user that stakes LP tokens.
    mapping(uint256 => mapping(address => UserInfo)) public userInfo;
    // Total allocation points. Must be the sum of all allocation points in all pools.
    uint256 public totalAllocPoint = 0;
    // The block number when SUMMA mining starts.
    uint256 public startTime;

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

    constructor(
        IERC20 _summa,
        uint256 _startTime,
        uint256 _bonusEndTime,
        IAccessControl _accessContract
    ) public {
        summa = _summa;
        bonusEndTime = _bonusEndTime;
        startTime = _startTime;
        accessContract = _accessContract;
    }

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

    // Add a new lp to the pool. Can only be called by the owner.
    // XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do.
    function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner {
        // avoid to add not erc20
        _lpToken.totalSupply();

        if (_withUpdate) {
            massUpdatePools();
        }
        uint256 lastRewardTime = block.number > startTime ? block.number : startTime;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        poolInfo.push(PoolInfo({
        lpToken : _lpToken,
        allocPoint : _allocPoint,
        lastRewardTime : lastRewardTime,
        accSummaPerShare : 0
        }));
    }

    // Update the given pool's SUMMA allocation point. Can only be called by the owner.
    function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner {
        if (_withUpdate) {
            massUpdatePools();
        }
        totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
        poolInfo[_pid].allocPoint = _allocPoint;
    }

    // Set the migrator contract. Can only be called by the owner.
    function setMigrator(IMigratorChef _migrator) public onlyOwner {
        migrator = _migrator;
    }

    function setTokenIssue(ITokenIssue _tokenIssue) public onlyOwner {
        tokenIssue = _tokenIssue;
    }

    function setTotalIssueRate(uint256 _totalIssueRate) public onlyOwner {
        totalIssueRate = _totalIssueRate;
    }

    // Migrate lp token to another lp contract. Can be called by anyone. We trust that migrator contract is good.
    function migrate(uint256 _pid) public {
        require(address(migrator) != address(0), "migrate: no migrator");
        PoolInfo storage pool = poolInfo[_pid];
        IERC20 lpToken = pool.lpToken;
        uint256 bal = lpToken.balanceOf(address(this));
        lpToken.safeApprove(address(migrator), bal);
        IERC20 newLpToken = migrator.migrate(lpToken);
//        require(bal == newLpToken.balanceOf(address(this)), "migrate: bad");
        pool.lpToken = newLpToken;
    }

    // Return reward multiplier over the given _from to _to block.
    function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) {
        uint256 issueTime = tokenIssue.startIssueTime();
        if (_to <= bonusEndTime) {
            if (_to < issueTime) {
                return 0;
            }
            if (_from < issueTime) {
                return getIssue(issueTime, _to).mul(totalIssueRate).div(10000).mul(BONUS_MULTIPLIER);
            }
            return getIssue(issueTime, _to).sub(getIssue(issueTime, _from)).mul(totalIssueRate).div(10000).mul(BONUS_MULTIPLIER);
        } else if (_from >= bonusEndTime) {
            if (_to < issueTime) {
                return 0;
            }
            if (_from < issueTime) {
                return getIssue(issueTime, _to).mul(totalIssueRate).div(10000);
            }
            return getIssue(issueTime, _to).sub(getIssue(issueTime, _from)).mul(totalIssueRate).div(10000);
        } else {
            if (_to < issueTime) {
                return 0;
            }
            if (_from < issueTime) {
                if(issueTime < bonusEndTime){
                    return getIssue(issueTime,bonusEndTime).mul(BONUS_MULTIPLIER).add(
                        getIssue(issueTime, _to).sub(getIssue(issueTime, bonusEndTime))
                    ).mul(totalIssueRate).div(10000);
                }
                return getIssue(issueTime, _to);
            }
            return getIssue(issueTime, bonusEndTime).sub(getIssue(issueTime, _from)).mul(BONUS_MULTIPLIER).add(
                getIssue(issueTime,_to).sub(getIssue(issueTime,bonusEndTime))
            ).mul(totalIssueRate).div(10000);

        }
    }

    function getIssue(uint256 _from, uint256 _to) private view returns (uint256){
        if (_to <= _from || _from <= 0) {
            return 0;
        }
        uint256 timeInterval = _to - _from;
        uint256 monthIndex = timeInterval.div(tokenIssue.MONTH_SECONDS());
        if (monthIndex < 1) {
            return timeInterval.mul(tokenIssue.issueInfo(monthIndex).div(tokenIssue.MONTH_SECONDS()));
        } else if (monthIndex < tokenIssue.issueInfoLength()) {
            uint256 tempTotal = 0;
            for (uint256 j = 0; j < monthIndex; j++) {
                tempTotal = tempTotal.add(tokenIssue.issueInfo(j));
            }
            uint256 calcAmount = timeInterval.sub(monthIndex.mul(tokenIssue.MONTH_SECONDS())).mul(tokenIssue.issueInfo(monthIndex).div(tokenIssue.MONTH_SECONDS())).add(tempTotal);
            if (calcAmount > tokenIssue.TOTAL_AMOUNT().sub(tokenIssue.INIT_MINE_SUPPLY())) {
                return tokenIssue.TOTAL_AMOUNT().sub(tokenIssue.INIT_MINE_SUPPLY());
            }
            return calcAmount;
        } else {
            return 0;
        }
    }

    // View function to see pending SUMMAs on frontend.
    function pendingSumma(uint256 _pid, address _user) external view returns (uint256) {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accSummaPerShare = pool.accSummaPerShare;
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (block.number > pool.lastRewardTime && lpSupply != 0) {
            uint256 multiplier = getMultiplier(pool.lastRewardTime, block.number);
            uint256 summaReward = multiplier.mul(pool.allocPoint).div(totalAllocPoint);
            accSummaPerShare = accSummaPerShare.add(summaReward.mul(1e12).div(lpSupply));
        }
        return user.amount.mul(accSummaPerShare).div(1e12).sub(user.rewardDebt);
    }

    // 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.number <= pool.lastRewardTime) {
            return;
        }
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (lpSupply == 0) {
            pool.lastRewardTime = block.number;
            return;
        }
        uint256 multiplier = getMultiplier(pool.lastRewardTime, block.number);
        uint256 summaReward = multiplier.mul(pool.allocPoint).div(totalAllocPoint);
        tokenIssue.transByContract(address(this), summaReward);
        pool.accSummaPerShare = pool.accSummaPerShare.add(summaReward.mul(1e12).div(lpSupply));
        pool.lastRewardTime = block.number;
    }

    // Deposit LP tokens to MasterChef for SUMMA allocation.
    function deposit(uint256 _pid, uint256 _amount) public {
//        require(accessContract.hasRole(PUBLIC_ROLE,address(msg.sender)),"not permit");
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        updatePool(_pid);
        if (user.amount > 0) {
            uint256 pending = user.amount.mul(pool.accSummaPerShare).div(1e12).sub(user.rewardDebt);
            if (pending > 0) {
                safeSummaTransfer(msg.sender, pending);
            }
        }
        if (_amount > 0) {
            pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
            user.amount = user.amount.add(_amount);
        }
        user.rewardDebt = user.amount.mul(pool.accSummaPerShare).div(1e12);
        emit Deposit(msg.sender, _pid, _amount);
    }

    // Withdraw LP tokens from MasterChef.
    function withdraw(uint256 _pid, uint256 _amount) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        require(user.amount >= _amount, "withdraw: not good");
        updatePool(_pid);
        uint256 pending = user.amount.mul(pool.accSummaPerShare).div(1e12).sub(user.rewardDebt);
        if (pending > 0) {
            safeSummaTransfer(msg.sender, pending);
        }
        if (_amount > 0) {
            if(_amount < pool.lpToken.balanceOf(address(this))){
                user.amount = user.amount.sub(_amount);
                pool.lpToken.safeTransfer(address(msg.sender), _amount);
            }else{
                user.amount = 0;
                pool.lpToken.safeTransfer(address(msg.sender), pool.lpToken.balanceOf(address(this)));
            }
        }
        user.rewardDebt = user.amount.mul(pool.accSummaPerShare).div(1e12);
        emit Withdraw(msg.sender, _pid, _amount);
    }

    // Withdraw without caring about rewards. EMERGENCY ONLY.
    function emergencyWithdraw(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        uint256 amount = user.amount;
        user.amount = 0;
        user.rewardDebt = 0;
        if(pool.lpToken.balanceOf(address(this)) < user.amount){
            amount = pool.lpToken.balanceOf(address(this));
        }
        pool.lpToken.safeTransfer(address(msg.sender), amount);
        emit EmergencyWithdraw(msg.sender, _pid, amount);
    }

    // Safe summa transfer function, just in case if rounding error causes pool to not have enough SUMMAs.
    function safeSummaTransfer(address _to, uint256 _amount) internal {
        uint256 summaBal = summa.balanceOf(address(this));
        if (_amount > summaBal) {
            summa.transfer(_to, summaBal);
        } else {
            summa.transfer(_to, _amount);
        }
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IERC20","name":"_summa","type":"address"},{"internalType":"uint256","name":"_startTime","type":"uint256"},{"internalType":"uint256","name":"_bonusEndTime","type":"uint256"},{"internalType":"contract IAccessControl","name":"_accessContract","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"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"}],"name":"Deposit","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"}],"name":"EmergencyWithdraw","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"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"BONUS_MULTIPLIER","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PUBLIC_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"accessContract","outputs":[{"internalType":"contract IAccessControl","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IERC20","name":"_lpToken","type":"address"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"bonusEndTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_from","type":"uint256"},{"internalType":"uint256","name":"_to","type":"uint256"}],"name":"getMultiplier","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"migrate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"migrator","outputs":[{"internalType":"contract IMigratorChef","name":"","type":"address"}],"stateMutability":"view","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":"pendingSumma","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":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardTime","type":"uint256"},{"internalType":"uint256","name":"accSummaPerShare","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IMigratorChef","name":"_migrator","type":"address"}],"name":"setMigrator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract ITokenIssue","name":"_tokenIssue","type":"address"}],"name":"setTokenIssue","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_totalIssueRate","type":"uint256"}],"name":"setTotalIssueRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"summa","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenIssue","outputs":[{"internalType":"contract ITokenIssue","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalIssueRate","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"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

60806040526107d0600655600060095534801561001b57600080fd5b5060405162002718380380620027188339818101604052608081101561004057600080fd5b508051602082015160408301516060909301519192909160006100616100e8565b600080546001600160a01b0319166001600160a01b0383169081178255604051929350917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908290a350600180546001600160a01b039586166001600160a01b031991821617909155600292909255600a92909255600480549290931691161790556100ec565b3390565b61261c80620000fc6000396000f3fe608060405234801561001057600080fd5b50600436106101cf5760003560e01c80636f2fe11c1161010457806393f1a40b116100a2578063e2bbb15811610071578063e2bbb15814610472578063ea2d8a0514610495578063ee1a6295146104b2578063f2fde38b146104ba576101cf565b806393f1a40b146103f7578063a64c5f4e1461043c578063b1bba4ac14610444578063b7c408d11461046a576101cf565b80637cd07e47116100de5780637cd07e47146103bc5780638aa28550146103c45780638da5cb5b146103cc5780638dbb1e3a146103d4576101cf565b80636f2fe11c14610380578063715018a6146103ac57806378e97925146103b4576101cf565b8063454b060811610171578063607feec21161014b578063607feec214610321578063630b5ba11461032957806364482f79146103315780636aa1f07b1461035c576101cf565b8063454b0608146102ca57806351eb05a6146102e75780635312ea8e14610304576101cf565b80631eaaa045116101ad5780631eaaa0451461024357806323cf3118146102795780633ca7c02a1461029f578063441a3e70146102a7576101cf565b8063081e3eda146101d45780631526fe27146101ee57806317caf6f11461023b575b600080fd5b6101dc6104e0565b60408051918252519081900360200190f35b61020b6004803603602081101561020457600080fd5b50356104e6565b604080516001600160a01b0390951685526020850193909352838301919091526060830152519081900360800190f35b6101dc610527565b6102776004803603606081101561025957600080fd5b508035906001600160a01b036020820135169060400135151561052d565b005b6102776004803603602081101561028f57600080fd5b50356001600160a01b031661070d565b6101dc610787565b610277600480360360408110156102bd57600080fd5b50803590602001356107ab565b610277600480360360208110156102e057600080fd5b5035610a1e565b610277600480360360208110156102fd57600080fd5b5035610bc2565b6102776004803603602081101561031a57600080fd5b5035610d5b565b6101dc610ee9565b610277610eef565b6102776004803603606081101561034757600080fd5b50803590602081013590604001351515610f12565b610364610fe3565b604080516001600160a01b039092168252519081900360200190f35b6101dc6004803603604081101561039657600080fd5b50803590602001356001600160a01b0316610ff2565b610277611150565b6101dc6111f2565b6103646111f8565b6101dc611207565b61036461120c565b6101dc600480360360408110156103ea57600080fd5b508035906020013561121b565b6104236004803603604081101561040d57600080fd5b50803590602001356001600160a01b031661140e565b6040805192835260208301919091528051918290030190f35b610364611432565b6102776004803603602081101561045a57600080fd5b50356001600160a01b0316611441565b6103646114bb565b6102776004803603604081101561048857600080fd5b50803590602001356114ca565b610277600480360360208110156104ab57600080fd5b50356115dc565b6101dc611639565b610277600480360360208110156104d057600080fd5b50356001600160a01b031661163f565b60075490565b600781815481106104f357fe5b600091825260209091206004909102018054600182015460028301546003909301546001600160a01b039092169350919084565b60095481565b610535611737565b6000546001600160a01b03908116911614610585576040805162461bcd60e51b81526020600482018190526024820152600080516020612567833981519152604482015290519081900360640190fd5b816001600160a01b03166318160ddd6040518163ffffffff1660e01b815260040160206040518083038186803b1580156105be57600080fd5b505afa1580156105d2573d6000803e3d6000fd5b505050506040513d60208110156105e857600080fd5b505080156105f8576105f8610eef565b6000600a54431161060b57600a5461060d565b435b60095490915061061d908561173b565b600955604080516080810182526001600160a01b0394851681526020810195865290810191825260006060820181815260078054600181018255925291517fa66cc928b5edb82af9bd49922954155ab7b0942694bea4ce44661d9a8736c688600490920291820180546001600160a01b031916919096161790945593517fa66cc928b5edb82af9bd49922954155ab7b0942694bea4ce44661d9a8736c689840155517fa66cc928b5edb82af9bd49922954155ab7b0942694bea4ce44661d9a8736c68a8301555090517fa66cc928b5edb82af9bd49922954155ab7b0942694bea4ce44661d9a8736c68b90910155565b610715611737565b6000546001600160a01b03908116911614610765576040805162461bcd60e51b81526020600482018190526024820152600080516020612567833981519152604482015290519081900360640190fd5b600380546001600160a01b0319166001600160a01b0392909216919091179055565b7fee244ef9da0b2f89a74b208ea9fe1a639ebdf634027d9e1f092b58c39954fa3781565b6000600783815481106107ba57fe5b60009182526020808320868452600882526040808520338652909252922080546004909202909201925083111561082d576040805162461bcd60e51b81526020600482015260126024820152711dda5d1a191c985dce881b9bdd0819dbdbd960721b604482015290519081900360640190fd5b61083684610bc2565b6000610870826001015461086a64e8d4a510006108648760030154876000015461179c90919063ffffffff16565b906117f5565b90611837565b90508015610882576108823382611879565b83156109c0578254604080516370a0823160e01b815230600482015290516001600160a01b03909216916370a0823191602480820192602092909190829003018186803b1580156108d257600080fd5b505afa1580156108e6573d6000803e3d6000fd5b505050506040513d60208110156108fc57600080fd5b505184101561092e5781546109119085611837565b82558254610929906001600160a01b03163386611a0a565b6109c0565b600082558254604080516370a0823160e01b815230600482015290516109c09233926001600160a01b03909116916370a0823191602480820192602092909190829003018186803b15801561098257600080fd5b505afa158015610996573d6000803e3d6000fd5b505050506040513d60208110156109ac57600080fd5b505185546001600160a01b03169190611a0a565b600383015482546109db9164e8d4a51000916108649161179c565b6001830155604080518581529051869133917ff279e6a1f5e320cca91135676d9cb6e44ca8a08c0b88342bcdb1144f6511b5689181900360200190a35050505050565b6003546001600160a01b0316610a72576040805162461bcd60e51b815260206004820152601460248201527336b4b3b930ba329d1037379036b4b3b930ba37b960611b604482015290519081900360640190fd5b600060078281548110610a8157fe5b600091825260208083206004928302018054604080516370a0823160e01b81523095810195909552519195506001600160a01b0316939284926370a0823192602480840193829003018186803b158015610ada57600080fd5b505afa158015610aee573d6000803e3d6000fd5b505050506040513d6020811015610b0457600080fd5b5051600354909150610b23906001600160a01b03848116911683611a5c565b6003546040805163ce5494bb60e01b81526001600160a01b0385811660048301529151600093929092169163ce5494bb9160248082019260209290919082900301818787803b158015610b7557600080fd5b505af1158015610b89573d6000803e3d6000fd5b505050506040513d6020811015610b9f57600080fd5b505184546001600160a01b0319166001600160a01b039091161790935550505050565b600060078281548110610bd157fe5b9060005260206000209060040201905080600201544311610bf25750610d58565b8054604080516370a0823160e01b815230600482015290516000926001600160a01b0316916370a08231916024808301926020929190829003018186803b158015610c3c57600080fd5b505afa158015610c50573d6000803e3d6000fd5b505050506040513d6020811015610c6657600080fd5b5051905080610c7c575043600290910155610d58565b6000610c8c83600201544361121b565b90506000610cad60095461086486600101548561179c90919063ffffffff16565b600554604080516317f2f1d360e11b81523060048201526024810184905290519293506001600160a01b0390911691632fe5e3a69160448082019260009290919082900301818387803b158015610d0357600080fd5b505af1158015610d17573d6000803e3d6000fd5b50505050610d45610d3a8461086464e8d4a510008561179c90919063ffffffff16565b60038601549061173b565b6003850155505043600290920191909155505b50565b600060078281548110610d6a57fe5b6000918252602080832085845260088252604080852033865283528085208054868255600182018790556004958602909301805483516370a0823160e01b8152309781019790975292519097509095929492936001600160a01b03909216926370a08231926024808301939192829003018186803b158015610deb57600080fd5b505afa158015610dff573d6000803e3d6000fd5b505050506040513d6020811015610e1557600080fd5b50511015610e96578254604080516370a0823160e01b815230600482015290516001600160a01b03909216916370a0823191602480820192602092909190829003018186803b158015610e6757600080fd5b505afa158015610e7b573d6000803e3d6000fd5b505050506040513d6020811015610e9157600080fd5b505190505b8254610eac906001600160a01b03163383611a0a565b604080518281529051859133917fbb757047c2b5f3974fe26b7c10f732e7bce710b0952a71082702781e62ae05959181900360200190a350505050565b60065481565b60075460005b81811015610f0e57610f0681610bc2565b600101610ef5565b5050565b610f1a611737565b6000546001600160a01b03908116911614610f6a576040805162461bcd60e51b81526020600482018190526024820152600080516020612567833981519152604482015290519081900360640190fd5b8015610f7857610f78610eef565b610fb582610faf60078681548110610f8c57fe5b90600052602060002090600402016001015460095461183790919063ffffffff16565b9061173b565b6009819055508160078481548110610fc957fe5b906000526020600020906004020160010181905550505050565b6005546001600160a01b031681565b6000806007848154811061100257fe5b600091825260208083208784526008825260408085206001600160a01b03898116875290845281862060049586029093016003810154815484516370a0823160e01b81523098810198909852935191985093969395939492909116926370a08231926024808301939192829003018186803b15801561108057600080fd5b505afa158015611094573d6000803e3d6000fd5b505050506040513d60208110156110aa57600080fd5b50516002850154909150431180156110c157508015155b1561111b5760006110d685600201544361121b565b905060006110f760095461086488600101548561179c90919063ffffffff16565b905061111661110f846108648464e8d4a5100061179c565b859061173b565b935050505b611143836001015461086a64e8d4a5100061086486886000015461179c90919063ffffffff16565b9450505050505b92915050565b611158611737565b6000546001600160a01b039081169116146111a8576040805162461bcd60e51b81526020600482018190526024820152600080516020612567833981519152604482015290519081900360640190fd5b600080546040516001600160a01b03909116907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908390a3600080546001600160a01b0319169055565b600a5481565b6003546001600160a01b031681565b600181565b6000546001600160a01b031690565b600080600560009054906101000a90046001600160a01b03166001600160a01b0316637d24af666040518163ffffffff1660e01b815260040160206040518083038186803b15801561126c57600080fd5b505afa158015611280573d6000803e3d6000fd5b505050506040513d602081101561129657600080fd5b5051600254909150831161130f57808310156112b657600091505061114a565b808410156112e7576112df60016112d96127106108646006546112d9878a611b6f565b9061179c565b91505061114a565b6112df60016112d96127106108646006546112d9611305888c611b6f565b61086a898c611b6f565b600254841061136b578083101561132a57600091505061114a565b80841015611348576112df6127106108646006546112d98588611b6f565b6112df6127106108646006546112d9611361868a611b6f565b61086a878a611b6f565b8083101561137d57600091505061114a565b808410156113d2576002548110156113c8576112df6127106108646006546112d96113b76113ad87600254611b6f565b61086a888b611b6f565b610faf60016112d989600254611b6f565b6112df8184611b6f565b6112df6127106108646006546112d96113f06113ad87600254611b6f565b610faf60016112d96114028a8e611b6f565b61086a8b600254611b6f565b60086020908152600092835260408084209091529082529020805460019091015482565b6004546001600160a01b031681565b611449611737565b6000546001600160a01b03908116911614611499576040805162461bcd60e51b81526020600482018190526024820152600080516020612567833981519152604482015290519081900360640190fd5b600580546001600160a01b0319166001600160a01b0392909216919091179055565b6001546001600160a01b031681565b6000600783815481106114d957fe5b6000918252602080832086845260088252604080852033865290925292206004909102909101915061150a84610bc2565b80541561155357600061153f826001015461086a64e8d4a510006108648760030154876000015461179c90919063ffffffff16565b90508015611551576115513382611879565b505b821561157f578154611570906001600160a01b031633308661210d565b805461157c908461173b565b81555b6003820154815461159a9164e8d4a51000916108649161179c565b6001820155604080518481529051859133917f90890809c654f11d6e72a28fa60149770a0d11ec6c92319d6ceb2bb0a4ea1a159181900360200190a350505050565b6115e4611737565b6000546001600160a01b03908116911614611634576040805162461bcd60e51b81526020600482018190526024820152600080516020612567833981519152604482015290519081900360640190fd5b600655565b60025481565b611647611737565b6000546001600160a01b03908116911614611697576040805162461bcd60e51b81526020600482018190526024820152600080516020612567833981519152604482015290519081900360640190fd5b6001600160a01b0381166116dc5760405162461bcd60e51b81526004018080602001828103825260268152602001806124fa6026913960400191505060405180910390fd5b600080546040516001600160a01b03808516939216917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e091a3600080546001600160a01b0319166001600160a01b0392909216919091179055565b3390565b600082820183811015611795576040805162461bcd60e51b815260206004820152601b60248201527f536166654d6174683a206164646974696f6e206f766572666c6f770000000000604482015290519081900360640190fd5b9392505050565b6000826117ab5750600061114a565b828202828482816117b857fe5b04146117955760405162461bcd60e51b81526004018080602001828103825260218152602001806125466021913960400191505060405180910390fd5b600061179583836040518060400160405280601a81526020017f536166654d6174683a206469766973696f6e206279207a65726f00000000000081525061216d565b600061179583836040518060400160405280601e81526020017f536166654d6174683a207375627472616374696f6e206f766572666c6f77000081525061220f565b600154604080516370a0823160e01b815230600482015290516000926001600160a01b0316916370a08231916024808301926020929190829003018186803b1580156118c457600080fd5b505afa1580156118d8573d6000803e3d6000fd5b505050506040513d60208110156118ee57600080fd5b5051905080821115611982576001546040805163a9059cbb60e01b81526001600160a01b038681166004830152602482018590529151919092169163a9059cbb9160448083019260209291908290030181600087803b15801561195057600080fd5b505af1158015611964573d6000803e3d6000fd5b505050506040513d602081101561197a57600080fd5b50611a059050565b6001546040805163a9059cbb60e01b81526001600160a01b038681166004830152602482018690529151919092169163a9059cbb9160448083019260209291908290030181600087803b1580156119d857600080fd5b505af11580156119ec573d6000803e3d6000fd5b505050506040513d6020811015611a0257600080fd5b50505b505050565b604080516001600160a01b038416602482015260448082018490528251808303909101815260649091019091526020810180516001600160e01b031663a9059cbb60e01b179052611a05908490612269565b801580611ae2575060408051636eb1769f60e11b81523060048201526001600160a01b03848116602483015291519185169163dd62ed3e91604480820192602092909190829003018186803b158015611ab457600080fd5b505afa158015611ac8573d6000803e3d6000fd5b505050506040513d6020811015611ade57600080fd5b5051155b611b1d5760405162461bcd60e51b81526004018080602001828103825260368152602001806125b16036913960400191505060405180910390fd5b604080516001600160a01b038416602482015260448082018490528251808303909101815260649091019091526020810180516001600160e01b031663095ea7b360e01b179052611a05908490612269565b60008282111580611b7e575082155b15611b8b5750600061114a565b600083830390506000611c18600560009054906101000a90046001600160a01b03166001600160a01b031663f4a814fd6040518163ffffffff1660e01b815260040160206040518083038186803b158015611be557600080fd5b505afa158015611bf9573d6000803e3d6000fd5b505050506040513d6020811015611c0f57600080fd5b505183906117f5565b90506001811015611d3157611d28611d21600560009054906101000a90046001600160a01b03166001600160a01b031663f4a814fd6040518163ffffffff1660e01b815260040160206040518083038186803b158015611c7757600080fd5b505afa158015611c8b573d6000803e3d6000fd5b505050506040513d6020811015611ca157600080fd5b50516005546040805163b626975760e01b81526004810187905290516001600160a01b039092169163b626975791602480820192602092909190829003018186803b158015611cef57600080fd5b505afa158015611d03573d6000803e3d6000fd5b505050506040513d6020811015611d1957600080fd5b5051906117f5565b839061179c565b9250505061114a565b600560009054906101000a90046001600160a01b03166001600160a01b0316635a2d34906040518163ffffffff1660e01b815260040160206040518083038186803b158015611d7f57600080fd5b505afa158015611d93573d6000803e3d6000fd5b505050506040513d6020811015611da957600080fd5b5051811015612102576000805b82811015611e48576005546040805163b626975760e01b8152600481018490529051611e3e926001600160a01b03169163b6269757916024808301926020929190829003018186803b158015611e0b57600080fd5b505afa158015611e1f573d6000803e3d6000fd5b505050506040513d6020811015611e3557600080fd5b5051839061173b565b9150600101611db6565b506000611fa982610faf611f1b600560009054906101000a90046001600160a01b03166001600160a01b031663f4a814fd6040518163ffffffff1660e01b815260040160206040518083038186803b158015611ea357600080fd5b505afa158015611eb7573d6000803e3d6000fd5b505050506040513d6020811015611ecd57600080fd5b50516005546040805163b626975760e01b8152600481018b905290516001600160a01b039092169163b626975791602480820192602092909190829003018186803b158015611cef57600080fd5b6112d9611fa2600560009054906101000a90046001600160a01b03166001600160a01b031663f4a814fd6040518163ffffffff1660e01b815260040160206040518083038186803b158015611f6f57600080fd5b505afa158015611f83573d6000803e3d6000fd5b505050506040513d6020811015611f9957600080fd5b5051899061179c565b8990611837565b905061209f600560009054906101000a90046001600160a01b03166001600160a01b03166345138eb86040518163ffffffff1660e01b815260040160206040518083038186803b158015611ffc57600080fd5b505afa158015612010573d6000803e3d6000fd5b505050506040513d602081101561202657600080fd5b50516005546040805163a2d7f5e360e01b815290516001600160a01b039092169163a2d7f5e391600480820192602092909190829003018186803b15801561206d57600080fd5b505afa158015612081573d6000803e3d6000fd5b505050506040513d602081101561209757600080fd5b505190611837565b8111156120f757600554604080516308a271d760e31b815290516120ec926001600160a01b0316916345138eb8916004808301926020929190829003018186803b158015611ffc57600080fd5b94505050505061114a565b935061114a92505050565b60009250505061114a565b604080516001600160a01b0380861660248301528416604482015260648082018490528251808303909101815260849091019091526020810180516001600160e01b03166323b872dd60e01b179052612167908590612269565b50505050565b600081836121f95760405162461bcd60e51b81526004018080602001828103825283818151815260200191508051906020019080838360005b838110156121be5781810151838201526020016121a6565b50505050905090810190601f1680156121eb5780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b50600083858161220557fe5b0495945050505050565b600081848411156122615760405162461bcd60e51b81526020600482018181528351602484015283519092839260449091019190850190808383600083156121be5781810151838201526020016121a6565b505050900390565b60606122be826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b031661231a9092919063ffffffff16565b805190915015611a05578080602001905160208110156122dd57600080fd5b5051611a055760405162461bcd60e51b815260040180806020018281038252602a815260200180612587602a913960400191505060405180910390fd5b60606123298484600085612331565b949350505050565b6060824710156123725760405162461bcd60e51b81526004018080602001828103825260268152602001806125206026913960400191505060405180910390fd5b61237b8561248d565b6123cc576040805162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604482015290519081900360640190fd5b60006060866001600160a01b031685876040518082805190602001908083835b6020831061240b5780518252601f1990920191602091820191016123ec565b6001836020036101000a03801982511681845116808217855250505050505090500191505060006040518083038185875af1925050503d806000811461246d576040519150601f19603f3d011682016040523d82523d6000602084013e612472565b606091505b5091509150612482828286612493565b979650505050505050565b3b151590565b606083156124a2575081611795565b8251156124b25782518084602001fd5b60405162461bcd60e51b81526020600482018181528451602484015284518593919283926044019190850190808383600083156121be5781810151838201526020016121a656fe4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061646472657373416464726573733a20696e73756666696369656e742062616c616e636520666f722063616c6c536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f774f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65725361666545524332303a204552433230206f7065726174696f6e20646964206e6f7420737563636565645361666545524332303a20617070726f76652066726f6d206e6f6e2d7a65726f20746f206e6f6e2d7a65726f20616c6c6f77616e6365a264697066735822122016651e44e677e71a3d4668440e92f5d3f77846ff61ee25c3504d0745900f4b6b64736f6c634300060c0033000000000000000000000000043c308bb8a5ae96d0093444be7f56459f1340b100000000000000000000000000000000000000000000000000000000000a179800000000000000000000000000000000000000000000000000000000000a36d80000000000000000000000006631dc49eb860eafd61777b92e42fe2bef84596b

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

000000000000000000000000043c308bb8a5ae96d0093444be7f56459f1340b100000000000000000000000000000000000000000000000000000000000a179800000000000000000000000000000000000000000000000000000000000a36d80000000000000000000000006631dc49eb860eafd61777b92e42fe2bef84596b

-----Decoded View---------------
Arg [0] : _summa (address): 0x043C308BB8a5aE96D0093444be7f56459F1340b1
Arg [1] : _startTime (uint256): 661400
Arg [2] : _bonusEndTime (uint256): 669400
Arg [3] : _accessContract (address): 0x6631DC49EB860eaFd61777b92e42fe2bEf84596B

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 000000000000000000000000043c308bb8a5ae96d0093444be7f56459f1340b1
Arg [1] : 00000000000000000000000000000000000000000000000000000000000a1798
Arg [2] : 00000000000000000000000000000000000000000000000000000000000a36d8
Arg [3] : 0000000000000000000000006631dc49eb860eafd61777b92e42fe2bef84596b

33255:12863:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36141:95;;;:::i;:::-;;;;;;;;;;;;;;;;35217:26;;;;;;;;;;;;;;;;-1:-1:-1;35217:26:0;;:::i;:::-;;;;-1:-1:-1;;;;;35217:26:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35458:34;;;:::i;36405:567::-;;;;;;;;;;;;;;;;-1:-1:-1;36405:567:0;;;-1:-1:-1;;;;;36405:567:0;;;;;;;;;;;;:::i;:::-;;37449:102;;;;;;;;;;;;;;;;-1:-1:-1;37449:102:0;-1:-1:-1;;;;;37449:102:0;;:::i;33361:62::-;;;:::i;44128:992::-;;;;;;;;;;;;;;;;-1:-1:-1;44128:992:0;;;;;;;:::i;37918:493::-;;;;;;;;;;;;;;;;-1:-1:-1;37918:493:0;;:::i;42427:732::-;;;;;;;;;;;;;;;;-1:-1:-1;42427:732:0;;:::i;45191:523::-;;;;;;;;;;;;;;;;-1:-1:-1;45191:523:0;;:::i;35140:43::-;;;:::i;42171:180::-;;;:::i;37069:304::-;;;;;;;;;;;;;;;;-1:-1:-1;37069:304:0;;;;;;;;;;;;;;:::i;35102:29::-;;;:::i;:::-;;;;-1:-1:-1;;;;;35102:29:0;;;;;;;;;;;;;;41341:747;;;;;;;;;;;;;;;;-1:-1:-1;41341:747:0;;;;;;-1:-1:-1;;;;;41341:747:0;;:::i;31393:148::-;;;:::i;35550:24::-;;;:::i;35019:29::-;;;:::i;34870:44::-;;;:::i;30751:79::-;;;:::i;38487:1663::-;;;;;;;;;;;;;;;;-1:-1:-1;38487:1663:0;;;;;;;:::i;35299:64::-;;;;;;;;;;;;;;;;-1:-1:-1;35299:64:0;;;;;;-1:-1:-1;;;;;35299:64:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;35057:36;;;:::i;37559:108::-;;;;;;;;;;;;;;;;-1:-1:-1;37559:108:0;-1:-1:-1;;;;;37559:108:0;;:::i;34711:19::-;;;:::i;43229:847::-;;;;;;;;;;;;;;;;-1:-1:-1;43229:847:0;;;;;;;:::i;37675:120::-;;;;;;;;;;;;;;;;-1:-1:-1;37675:120:0;;:::i;34788:27::-;;;:::i;31696:244::-;;;;;;;;;;;;;;;;-1:-1:-1;31696:244:0;-1:-1:-1;;;;;31696:244:0;;:::i;36141:95::-;36213:8;:15;36141:95;:::o;35217:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;35217:26:0;;;;-1:-1:-1;35217:26:0;;;:::o;35458:34::-;;;;:::o;36405:567::-;30973:12;:10;:12::i;:::-;30963:6;;-1:-1:-1;;;;;30963:6:0;;;:22;;;30955:67;;;;;-1:-1:-1;;;30955:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;30955:67:0;;;;;;;;;;;;;;;36537:8:::1;-1:-1:-1::0;;;;;36537:20:0::1;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;;36572:61:0;::::1;;;36604:17;:15;:17::i;:::-;36643:22;36683:9;;36668:12;:24;:51;;36710:9;;36668:51;;;36695:12;36668:51;36748:15;::::0;36643:76;;-1:-1:-1;36748:32:0::1;::::0;36768:11;36748:19:::1;:32::i;:::-;36730:15;:50:::0;36805:158:::1;::::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;;;;;36805:158:0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;;-1:-1:-1;36805:158:0;;;;;;36791:8:::1;:173:::0;;::::1;::::0;::::1;::::0;;;;;;;::::1;::::0;;::::1;::::0;;::::1;::::0;;-1:-1:-1;;;;;;36791:173:0::1;::::0;;;::::1;;::::0;;;;;;;;;;;;;;-1:-1:-1;36791:173:0;;;;;;;36405:567::o;37449:102::-;30973:12;:10;:12::i;:::-;30963:6;;-1:-1:-1;;;;;30963:6:0;;;:22;;;30955:67;;;;;-1:-1:-1;;;30955:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;30955:67:0;;;;;;;;;;;;;;;37523:8:::1;:20:::0;;-1:-1:-1;;;;;;37523:20:0::1;-1:-1:-1::0;;;;;37523:20:0;;;::::1;::::0;;;::::1;::::0;;37449:102::o;33361:62::-;33399:24;33361:62;:::o;44128:992::-;44195:21;44219:8;44228:4;44219:14;;;;;;;;;;;;;;;;44268;;;:8;:14;;;;;;44283:10;44268:26;;;;;;;44313:11;;44219:14;;;;;;;;-1:-1:-1;44313:22:0;-1:-1:-1;44313:22:0;44305:53;;;;;-1:-1:-1;;;44305:53:0;;;;;;;;;;;;-1:-1:-1;;;44305:53:0;;;;;;;;;;;;;;;44369:16;44380:4;44369:10;:16::i;:::-;44396:15;44414:69;44467:4;:15;;;44414:48;44457:4;44414:38;44430:4;:21;;;44414:4;:11;;;:15;;:38;;;;:::i;:::-;:42;;:48::i;:::-;:52;;:69::i;:::-;44396:87;-1:-1:-1;44498:11:0;;44494:82;;44526:38;44544:10;44556:7;44526:17;:38::i;:::-;44590:11;;44586:399;;44631:12;;:37;;;-1:-1:-1;;;44631:37:0;;44662:4;44631:37;;;;;;-1:-1:-1;;;;;44631:12:0;;;;:22;;:37;;;;;;;;;;;;;;;:12;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;44631:37:0;44621:47;;44618:356;;;44702:11;;:24;;44718:7;44702:15;:24::i;:::-;44688:38;;44745:12;;:55;;-1:-1:-1;;;;;44745:12:0;44779:10;44792:7;44745:25;:55::i;:::-;44618:356;;;44853:1;44839:15;;44920:12;;:37;;;-1:-1:-1;;;44920:37:0;;44951:4;44920:37;;;;;;44873:85;;44907:10;;-1:-1:-1;;;;;44920:12:0;;;;:22;;:37;;;;;;;;;;;;;;;:12;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;44920:37:0;44873:12;;-1:-1:-1;;;;;44873:12:0;;:85;:25;:85::i;:::-;45029:21;;;;45013:11;;:48;;45056:4;;45013:38;;:15;:38::i;:48::-;44995:15;;;:66;45077:35;;;;;;;;45098:4;;45086:10;;45077:35;;;;;;;;;44128:992;;;;;:::o;37918:493::-;37983:8;;-1:-1:-1;;;;;37983:8:0;37967:64;;;;;-1:-1:-1;;;37967:64:0;;;;;;;;;;;;-1:-1:-1;;;37967:64:0;;;;;;;;;;;;;;;38042:21;38066:8;38075:4;38066:14;;;;;;;;;;;;;;;;;;;;;38108:12;;38145:32;;;-1:-1:-1;;;38145:32:0;;38171:4;38145:32;;;;;;;;38066:14;;-1:-1:-1;;;;;;38108:12:0;;38066:14;38108:12;;38145:17;;:32;;;;;;;;;;38108:12;38145:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;38145:32:0;38216:8;;38145:32;;-1:-1:-1;38188:43:0;;-1:-1:-1;;;;;38188:19:0;;;;38216:8;38145:32;38188:19;:43::i;:::-;38262:8;;:25;;;-1:-1:-1;;;38262:25:0;;-1:-1:-1;;;;;38262:25:0;;;;;;;;;38242:17;;38262:8;;;;;:16;;:25;;;;;;;;;;;;;;;38242:17;38262:8;:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;38262:25:0;38378;;-1:-1:-1;;;;;;38378:25:0;-1:-1:-1;;;;;38378:25:0;;;;;;;-1:-1:-1;;;;37918:493:0:o;42427:732::-;42479:21;42503:8;42512:4;42503:14;;;;;;;;;;;;;;;;;;42479:38;;42548:4;:19;;;42532:12;:35;42528:74;;42584:7;;;42528:74;42631:12;;:37;;;-1:-1:-1;;;42631:37:0;;42662:4;42631:37;;;;;;42612:16;;-1:-1:-1;;;;;42631:12:0;;:22;;:37;;;;;;;;;;;;;;:12;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;42631:37:0;;-1:-1:-1;42683:13:0;42679:101;;-1:-1:-1;42735:12:0;42713:19;;;;:34;42762:7;;42679:101;42790:18;42811:48;42825:4;:19;;;42846:12;42811:13;:48::i;:::-;42790:69;;42870:19;42892:52;42928:15;;42892:31;42907:4;:15;;;42892:10;:14;;:31;;;;:::i;:52::-;42955:10;;:54;;;-1:-1:-1;;;42955:54:0;;42990:4;42955:54;;;;;;;;;;;;42870:74;;-1:-1:-1;;;;;;42955:10:0;;;;:26;;:54;;;;;:10;;:54;;;;;;;;:10;;:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43044:62;43070:35;43096:8;43070:21;43086:4;43070:11;:15;;:21;;;;:::i;:35::-;43044:21;;;;;:25;:62::i;:::-;43020:21;;;:86;-1:-1:-1;;43139:12:0;43117:19;;;;:34;;;;-1:-1:-1;42427:732:0;;:::o;45191:523::-;45250:21;45274:8;45283:4;45274:14;;;;;;;;;;;;;;;;45323;;;:8;:14;;;;;;45338:10;45323:26;;;;;;;45377:11;;45399:15;;;-1:-1:-1;45425:15:0;;:19;;;45274:14;;;;;;;45458:12;;:37;;-1:-1:-1;;;45458:37:0;;45489:4;45458:37;;;;;;;;;45274:14;;-1:-1:-1;45323:26:0;;45377:11;;45274:14;;-1:-1:-1;;;;;45458:12:0;;;;:22;;:37;;;;;45274:14;;45458:37;;;;;:12;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;45458:37:0;:51;45455:128;;;45534:12;;:37;;;-1:-1:-1;;;45534:37:0;;45565:4;45534:37;;;;;;-1:-1:-1;;;;;45534:12:0;;;;:22;;:37;;;;;;;;;;;;;;;:12;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;45534:37:0;;-1:-1:-1;45455:128:0;45593:12;;:54;;-1:-1:-1;;;;;45593:12:0;45627:10;45640:6;45593:25;:54::i;:::-;45663:43;;;;;;;;45693:4;;45681:10;;45663:43;;;;;;;;;45191:523;;;;:::o;35140:43::-;;;;:::o;42171:180::-;42233:8;:15;42216:14;42259:85;42287:6;42281:3;:12;42259:85;;;42317:15;42328:3;42317:10;:15::i;:::-;42295:5;;42259:85;;;;42171:180;:::o;37069:304::-;30973:12;:10;:12::i;:::-;30963:6;;-1:-1:-1;;;;;30963:6:0;;;:22;;;30955:67;;;;;-1:-1:-1;;;30955:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;30955:67:0;;;;;;;;;;;;;;;37167:11:::1;37163:61;;;37195:17;:15;:17::i;:::-;37252:63;37303:11;37252:46;37272:8;37281:4;37272:14;;;;;;;;;;;;;;;;;;:25;;;37252:15;;:19;;:46;;;;:::i;:::-;:50:::0;::::1;:63::i;:::-;37234:15;:81;;;;37354:11;37326:8;37335:4;37326:14;;;;;;;;;;;;;;;;;;:25;;:39;;;;37069:304:::0;;;:::o;35102:29::-;;;-1:-1:-1;;;;;35102:29:0;;:::o;41341:747::-;41415:7;41435:21;41459:8;41468:4;41459:14;;;;;;;;;;;;;;;;41508;;;:8;:14;;;;;;-1:-1:-1;;;;;41508:21:0;;;;;;;;;;;41459:14;;;;;;;41567:21;;;;41618:12;;:37;;-1:-1:-1;;;41618:37:0;;41649:4;41618:37;;;;;;;;;41459:14;;-1:-1:-1;41508:21:0;;41567;;41459:14;;41618:12;;;;;:22;;:37;;;;;41459:14;;41618:37;;;;;:12;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;41618:37:0;41685:19;;;;41618:37;;-1:-1:-1;41670:12:0;:34;:51;;;;-1:-1:-1;41708:13:0;;;41670:51;41666:333;;;41738:18;41759:48;41773:4;:19;;;41794:12;41759:13;:48::i;:::-;41738:69;;41822:19;41844:52;41880:15;;41844:31;41859:4;:15;;;41844:10;:14;;:31;;;;:::i;:52::-;41822:74;-1:-1:-1;41930:57:0;41951:35;41977:8;41951:21;41822:74;41967:4;41951:15;:21::i;:35::-;41930:16;;:20;:57::i;:::-;41911:76;;41666:333;;;42016:64;42064:4;:15;;;42016:43;42054:4;42016:33;42032:16;42016:4;:11;;;:15;;:33;;;;:::i;:64::-;42009:71;;;;;;41341:747;;;;;:::o;31393:148::-;30973:12;:10;:12::i;:::-;30963:6;;-1:-1:-1;;;;;30963:6:0;;;:22;;;30955:67;;;;;-1:-1:-1;;;30955:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;30955:67:0;;;;;;;;;;;;;;;31500:1:::1;31484:6:::0;;31463:40:::1;::::0;-1:-1:-1;;;;;31484:6:0;;::::1;::::0;31463:40:::1;::::0;31500:1;;31463:40:::1;31531:1;31514:19:::0;;-1:-1:-1;;;;;;31514:19:0::1;::::0;;31393:148::o;35550:24::-;;;;:::o;35019:29::-;;;-1:-1:-1;;;;;35019:29:0;;:::o;34870:44::-;34913:1;34870:44;:::o;30751:79::-;30789:7;30816:6;-1:-1:-1;;;;;30816:6:0;30751:79;:::o;38487:1663::-;38559:7;38579:17;38599:10;;;;;;;;;-1:-1:-1;;;;;38599:10:0;-1:-1:-1;;;;;38599:25:0;;:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;38599:27:0;38648:12;;38599:27;;-1:-1:-1;38641:19:0;;38637:1506;;38687:9;38681:3;:15;38677:64;;;38724:1;38717:8;;;;;38677:64;38767:9;38759:5;:17;38755:142;;;38804:77;34913:1;38804:55;38853:5;38804:44;38833:14;;38804:24;38813:9;38824:3;38804:8;:24::i;:::-;:28;;:44::i;:77::-;38797:84;;;;;38755:142;38918:109;34913:1;38918:87;38999:5;38918:76;38979:14;;38918:56;38947:26;38956:9;38967:5;38947:8;:26::i;:::-;38918:24;38927:9;38938:3;38918:8;:24::i;38637:1506::-;39058:12;;39049:5;:21;39045:1098;;39097:9;39091:3;:15;39087:64;;;39134:1;39127:8;;;;;39087:64;39177:9;39169:5;:17;39165:120;;;39214:55;39263:5;39214:44;39243:14;;39214:24;39223:9;39234:3;39214:8;:24::i;39165:120::-;39306:87;39387:5;39306:76;39367:14;;39306:56;39335:26;39344:9;39355:5;39335:8;:26::i;:::-;39306:24;39315:9;39326:3;39306:8;:24::i;39045:1098::-;39436:9;39430:3;:15;39426:64;;;39473:1;39466:8;;;;;39426:64;39516:9;39508:5;:17;39504:387;;;39561:12;;39549:9;:24;39546:280;;;39604:202;39800:5;39604:191;39780:14;;39604:171;39689:63;39718:33;39727:9;39738:12;;39718:8;:33::i;:::-;39689:24;39698:9;39709:3;39689:8;:24::i;:63::-;39604:54;34913:1;39604:32;39613:9;39623:12;;39604:8;:32::i;39546:280::-;39851:24;39860:9;39871:3;39851:8;:24::i;39504:387::-;39912:217;40123:5;39912:206;40103:14;;39912:186;40022:61;40050:32;40059:9;40069:12;;40050:8;:32::i;40022:61::-;39912:87;34913:1;39912:65;39950:26;39959:9;39970:5;39950:8;:26::i;:::-;39912:33;39921:9;39932:12;;39912:8;:33::i;35299:64::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;35057:36::-;;;-1:-1:-1;;;;;35057:36:0;;:::o;37559:108::-;30973:12;:10;:12::i;:::-;30963:6;;-1:-1:-1;;;;;30963:6:0;;;:22;;;30955:67;;;;;-1:-1:-1;;;30955:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;30955:67:0;;;;;;;;;;;;;;;37635:10:::1;:24:::0;;-1:-1:-1;;;;;;37635:24:0::1;-1:-1:-1::0;;;;;37635:24:0;;;::::1;::::0;;;::::1;::::0;;37559:108::o;34711:19::-;;;-1:-1:-1;;;;;34711:19:0;;:::o;43229:847::-;43385:21;43409:8;43418:4;43409:14;;;;;;;;;;;;;;;;43458;;;:8;:14;;;;;;43473:10;43458:26;;;;;;;43409:14;;;;;;;;-1:-1:-1;43495:16:0;43467:4;43495:10;:16::i;:::-;43526:11;;:15;43522:239;;43558:15;43576:69;43629:4;:15;;;43576:48;43619:4;43576:38;43592:4;:21;;;43576:4;:11;;;:15;;:38;;;;:::i;:69::-;43558:87;-1:-1:-1;43664:11:0;;43660:90;;43696:38;43714:10;43726:7;43696:17;:38::i;:::-;43522:239;;43775:11;;43771:171;;43803:12;;:74;;-1:-1:-1;;;;;43803:12:0;43841:10;43862:4;43869:7;43803:29;:74::i;:::-;43906:11;;:24;;43922:7;43906:15;:24::i;:::-;43892:38;;43771:171;43986:21;;;;43970:11;;:48;;44013:4;;43970:38;;:15;:38::i;:48::-;43952:15;;;:66;44034:34;;;;;;;;44054:4;;44042:10;;44034:34;;;;;;;;;43229:847;;;;:::o;37675:120::-;30973:12;:10;:12::i;:::-;30963:6;;-1:-1:-1;;;;;30963:6:0;;;:22;;;30955:67;;;;;-1:-1:-1;;;30955:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;30955:67:0;;;;;;;;;;;;;;;37755:14:::1;:32:::0;37675:120::o;34788:27::-;;;;:::o;31696:244::-;30973:12;:10;:12::i;:::-;30963:6;;-1:-1:-1;;;;;30963:6:0;;;:22;;;30955:67;;;;;-1:-1:-1;;;30955:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;30955:67:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;31785:22:0;::::1;31777:73;;;;-1:-1:-1::0;;;31777:73:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31887:6;::::0;;31866:38:::1;::::0;-1:-1:-1;;;;;31866:38:0;;::::1;::::0;31887:6;::::1;::::0;31866:38:::1;::::0;::::1;31915:6;:17:::0;;-1:-1:-1;;;;;;31915:17:0::1;-1:-1:-1::0;;;;;31915:17:0;;;::::1;::::0;;;::::1;::::0;;31696:244::o;29286:106::-;29374:10;29286:106;:::o;3744:181::-;3802:7;3834:5;;;3858:6;;;;3850:46;;;;;-1:-1:-1;;;3850:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;3916:1;3744:181;-1:-1:-1;;;3744:181:0:o;5098:471::-;5156:7;5401:6;5397:47;;-1:-1:-1;5431:1:0;5424:8;;5397:47;5468:5;;;5472:1;5468;:5;:1;5492:5;;;;;:10;5484:56;;;;-1:-1:-1;;;5484:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6045:132;6103:7;6130:39;6134:1;6137;6130:39;;;;;;;;;;;;;;;;;:3;:39::i;4208:136::-;4266:7;4293:43;4297:1;4300;4293:43;;;;;;;;;;;;;;;;;:3;:43::i;45830:285::-;45926:5;;:30;;;-1:-1:-1;;;45926:30:0;;45950:4;45926:30;;;;;;45907:16;;-1:-1:-1;;;;;45926:5:0;;:15;;:30;;;;;;;;;;;;;;:5;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;45926:30:0;;-1:-1:-1;45971:18:0;;;45967:141;;;46006:5;;:29;;;-1:-1:-1;;;46006:29:0;;-1:-1:-1;;;;;46006:29:0;;;;;;;;;;;;;;;:5;;;;;:14;;:29;;;;;;;;;;;;;;:5;;:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;45967:141:0;;-1:-1:-1;45967:141:0;;46068:5;;:28;;;-1:-1:-1;;;46068:28:0;;-1:-1:-1;;;;;46068:28:0;;;;;;;;;;;;;;;:5;;;;;:14;;:28;;;;;;;;;;;;;;:5;;:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;45967:141:0;45830:285;;;:::o;15899:177::-;16009:58;;;-1:-1:-1;;;;;16009:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;16009:58:0;-1:-1:-1;;;16009:58:0;;;15982:86;;16002:5;;15982:19;:86::i;16558:622::-;16928:10;;;16927:62;;-1:-1:-1;16944:39:0;;;-1:-1:-1;;;16944:39:0;;16968:4;16944:39;;;;-1:-1:-1;;;;;16944:39:0;;;;;;;;;:15;;;;;;:39;;;;;;;;;;;;;;;:15;:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;16944:39:0;:44;16927:62;16919:152;;;;-1:-1:-1;;;16919:152:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17109:62;;;-1:-1:-1;;;;;17109:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;17109:62:0;-1:-1:-1;;;17109:62:0;;;17082:90;;17102:5;;17082:19;:90::i;40158:1118::-;40226:7;40256:5;40249:3;:12;;:26;;;-1:-1:-1;40265:10:0;;40249:26;40245:67;;;-1:-1:-1;40299:1:0;40292:8;;40245:67;40322:20;40351:5;40345:3;:11;40322:34;;40367:18;40388:44;40405:10;;;;;;;;;-1:-1:-1;;;;;40405:10:0;-1:-1:-1;;;;;40405:24:0;;:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40405:26:0;40388:12;;:16;:44::i;:::-;40367:65;;40460:1;40447:10;:14;40443:826;;;40485:82;40502:64;40539:10;;;;;;;;;-1:-1:-1;;;;;40539:10:0;-1:-1:-1;;;;;40539:24:0;;:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40539:26:0;40502:10;;:32;;;-1:-1:-1;;;40502:32:0;;;;;;;;;;-1:-1:-1;;;;;40502:10:0;;;;:20;;:32;;;;;40539:26;;40502:32;;;;;;;;:10;:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40502:32:0;;:36;:64::i;:::-;40485:12;;:16;:82::i;:::-;40478:89;;;;;;40443:826;40602:10;;;;;;;;;-1:-1:-1;;;;;40602:10:0;-1:-1:-1;;;;;40602:26:0;;:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40602:28:0;40589:41;;40585:684;;;40647:17;40688:9;40683:126;40707:10;40703:1;:14;40683:126;;;40769:10;;:23;;;-1:-1:-1;;;40769:23:0;;;;;;;;;;40755:38;;-1:-1:-1;;;;;40769:10:0;;:20;;:23;;;;;;;;;;;;;;:10;:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40769:23:0;40755:9;;:13;:38::i;:::-;40743:50;-1:-1:-1;40719:3:0;;40683:126;;;;40823:18;40844:145;40979:9;40844:130;40909:64;40946:10;;;;;;;;;-1:-1:-1;;;;;40946:10:0;-1:-1:-1;;;;;40946:24:0;;:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40946:26:0;40909:10;;:32;;;-1:-1:-1;;;40909:32:0;;;;;;;;;;-1:-1:-1;;;;;40909:10:0;;;;:20;;:32;;;;;40946:26;;40909:32;;;;;;;;:10;:32;;;;;;;;;;:64;40844:60;40861:42;40876:10;;;;;;;;;-1:-1:-1;;;;;40876:10:0;-1:-1:-1;;;;;40876:24:0;;:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40876:26:0;40861:10;;:14;:42::i;:::-;40844:12;;:16;:60::i;:145::-;40823:166;;41021:60;41051:10;;;;;;;;;-1:-1:-1;;;;;41051:10:0;-1:-1:-1;;;;;41051:27:0;;:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;41051:29:0;41021:10;;:25;;;-1:-1:-1;;;41021:25:0;;;;-1:-1:-1;;;;;41021:10:0;;;;:23;;:25;;;;;41051:29;;41021:25;;;;;;;;:10;:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;41021:25:0;;:29;:60::i;:::-;41008:10;:73;41004:181;;;41139:10;;:29;;;-1:-1:-1;;;41139:29:0;;;;41109:60;;-1:-1:-1;;;;;41139:10:0;;:27;;:29;;;;;;;;;;;;;;:10;:29;;;;;;;;;;41109:60;41102:67;;;;;;;;41004:181;41206:10;-1:-1:-1;41199:17:0;;-1:-1:-1;;;41199:17:0;40585:684;41256:1;41249:8;;;;;;16084:205;16212:68;;;-1:-1:-1;;;;;16212:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;16212:68:0;-1:-1:-1;;;16212:68:0;;;16185:96;;16205:5;;16185:19;:96::i;:::-;16084:205;;;;:::o;6673:278::-;6759:7;6794:12;6787:5;6779:28;;;;-1:-1:-1;;;6779:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6818:9;6834:1;6830;:5;;;;;;;6673:278;-1:-1:-1;;;;;6673:278:0:o;4647:192::-;4733:7;4769:12;4761:6;;;;4753:29;;;;-1:-1:-1;;;4753:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;4805:5:0;;;4647:192::o;18204:761::-;18628:23;18654:69;18682:4;18654:69;;;;;;;;;;;;;;;;;18662:5;-1:-1:-1;;;;;18654:27:0;;;:69;;;;;:::i;:::-;18738:17;;18628:95;;-1:-1:-1;18738:21:0;18734:224;;18880:10;18869:30;;;;;;;;;;;;;;;-1:-1:-1;18869:30:0;18861:85;;;;-1:-1:-1;;;18861:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11896:195;11999:12;12031:52;12053:6;12061:4;12067:1;12070:12;12031:21;:52::i;:::-;12024:59;11896:195;-1:-1:-1;;;;11896:195:0:o;12948:530::-;13075:12;13133:5;13108:21;:30;;13100:81;;;;-1:-1:-1;;;13100:81:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13200:18;13211:6;13200:10;:18::i;:::-;13192:60;;;;;-1:-1:-1;;;13192:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;13326:12;13340:23;13367:6;-1:-1:-1;;;;;13367:11:0;13387:5;13395:4;13367:33;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;13367:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13325:75;;;;13418:52;13436:7;13445:10;13457:12;13418:17;:52::i;:::-;13411:59;12948:530;-1:-1:-1;;;;;;;12948:530:0:o;8978:422::-;9345:20;9384:8;;;8978:422::o;14484:742::-;14599:12;14628:7;14624:595;;;-1:-1:-1;14659:10:0;14652:17;;14624:595;14773:17;;:21;14769:439;;15036:10;15030:17;15097:15;15084:10;15080:2;15076:19;15069:44;14984:148;15172:20;;-1:-1:-1;;;15172:20:0;;;;;;;;;;;;;;;;;15179:12;;15172:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

ipfs://16651e44e677e71a3d4668440e92f5d3f77846ff61ee25c3504d0745900f4b6b