Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-09-26
*/

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.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);
}



pragma solidity ^0.6.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;
    }
}


pragma solidity ^0.6.2;

/**
 * @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 in 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");
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
        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);
            }
        }
    }
}

pragma solidity ^0.6.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");
        }
    }
}


pragma solidity ^0.6.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.0.0, only sets of type `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];
    }

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

/**
 *Submitted for verification at Etherscan.io on 2020-09-26
*/


pragma solidity ^0.6.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;
    }
}


pragma solidity ^0.6.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.
 */
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;
    }
}



pragma solidity ^0.6.0;

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

    mapping (address => uint256) private _balances;

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

    uint256 private _totalSupply;

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

    /**
     * @dev Sets the values for {name} and {symbol}, initializes {decimals} with
     * a default value of 18.
     *
     * To select a different value for {decimals}, use {_setupDecimals}.
     *
     * All three of these values are immutable: they can only be set once during
     * construction.
     */
    constructor (string memory name, string memory symbol) public {
        _name = name;
        _symbol = symbol;
        _decimals = 18;
    }

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

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

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5,05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is
     * called.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view returns (uint8) {
        return _decimals;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20};
     *
     * Requirements:
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(address sender, address recipient, uint256 amount) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements
     *
     * - `to` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

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

        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

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

        _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

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

    /**
     * @dev Sets {decimals} to a value other than the default one of 18.
     *
     * WARNING: This function should only be called from the constructor. Most
     * applications that interact with token contracts will not expect
     * {decimals} to ever change, and may work incorrectly if it does.
     */
    function _setupDecimals(uint8 decimals_) internal {
        _decimals = decimals_;
    }

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



pragma solidity 0.6.12;


// JokerToken with Governance.
contract JokerToken is ERC20("JokerToken", "JOKER"), Ownable {
    /// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
    function mint(address _to, uint256 _amount) public onlyOwner {
        _mint(_to, _amount);
        _moveDelegates(address(0), _delegates[_to], _amount);
    }

    // Copied and modified from SUSHI code:
    // https://github.com/sushiswap/sushiswap/blob/master/contracts/SushiToken.sol
    // Which is copied and modified from YAM and COMPOUND:
    // https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
    // https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
    // https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol

    /// @dev A record of each accounts delegate
    mapping (address => address) internal _delegates;

    /// @notice A checkpoint for marking number of votes from a given block
    struct Checkpoint {
        uint32 fromBlock;
        uint256 votes;
    }

    /// @notice A record of votes checkpoints for each account, by index
    mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;

    /// @notice The number of checkpoints for each account
    mapping (address => uint32) public numCheckpoints;

    /// @notice The EIP-712 typehash for the contract's domain
    bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");

    /// @notice The EIP-712 typehash for the delegation struct used by the contract
    bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");

    /// @notice A record of states for signing / validating signatures
    mapping (address => uint) public nonces;

      /// @notice An event thats emitted when an account changes its delegate
    event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);

    /// @notice An event thats emitted when a delegate account's vote balance changes
    event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);

    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        _moveDelegates(_delegates[_msgSender()], _delegates[recipient], amount);
        return true;
    }

    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), allowance(sender, _msgSender()).sub(amount, "ERC20: transfer amount exceeds allowance"));
        _moveDelegates(_delegates[sender], _delegates[recipient], amount);
        return true;
    }

    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        require((amount == 0) || (allowance(_msgSender(), spender) == 0), "JOKER: use increaseAllowance or decreaseAllowance instead");
        return super.approve(spender, amount);
    }

    /**
     * @notice Delegate votes from `msg.sender` to `delegatee`
     * @param delegator The address to get delegatee for
     */
    function delegates(address delegator)
        external
        view
        returns (address)
    {
        return _delegates[delegator];
    }

   /**
    * @notice Delegate votes from `msg.sender` to `delegatee`
    * @param delegatee The address to delegate votes to
    */
    function delegate(address delegatee) external {
        require(delegatee != _delegates[msg.sender], "JOKER::delegate: delegatee not change");
        return _delegate(msg.sender, delegatee);
    }

    /**
     * @notice Delegates votes from signatory to `delegatee`
     * @param delegatee The address to delegate votes to
     * @param nonce The contract state required to match the signature
     * @param expiry The time at which to expire the signature
     * @param v The recovery byte of the signature
     * @param r Half of the ECDSA signature pair
     * @param s Half of the ECDSA signature pair
     */
    function delegateBySig(
        address delegatee,
        uint nonce,
        uint expiry,
        uint8 v,
        bytes32 r,
        bytes32 s
    )
        external
    {
        bytes32 domainSeparator = keccak256(
            abi.encode(
                DOMAIN_TYPEHASH,
                keccak256(bytes(name())),
                getChainId(),
                address(this)
            )
        );

        bytes32 structHash = keccak256(
            abi.encode(
                DELEGATION_TYPEHASH,
                delegatee,
                nonce,
                expiry
            )
        );

        bytes32 digest = keccak256(
            abi.encodePacked(
                "\x19\x01",
                domainSeparator,
                structHash
            )
        );

        address signatory = ecrecover(digest, v, r, s);
        require(signatory != address(0), "JOCKER::delegateBySig: invalid signature");
        require(nonce == nonces[signatory]++, "JOCKER::delegateBySig: invalid nonce");
        require(now <= expiry, "JOCKER::delegateBySig: signature expired");
        return _delegate(signatory, delegatee);
    }

    /**
     * @notice Gets the current votes balance for `account`
     * @param account The address to get votes balance
     * @return The number of current votes for `account`
     */
    function getCurrentVotes(address account)
        external
        view
        returns (uint256)
    {
        uint32 nCheckpoints = numCheckpoints[account];
        return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
    }

    /**
     * @notice Determine the prior number of votes for an account as of a block number
     * @dev Block number must be a finalized block or else this function will revert to prevent misinformation.
     * @param account The address of the account to check
     * @param blockNumber The block number to get the vote balance at
     * @return The number of votes the account had as of the given block
     */
    function getPriorVotes(address account, uint blockNumber)
        external
        view
        returns (uint256)
    {
        require(blockNumber < block.number, "JOCKER::getPriorVotes: not yet determined");

        uint32 nCheckpoints = numCheckpoints[account];
        if (nCheckpoints == 0) {
            return 0;
        }

        // First check most recent balance
        if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
            return checkpoints[account][nCheckpoints - 1].votes;
        }

        // Next check implicit zero balance
        if (checkpoints[account][0].fromBlock > blockNumber) {
            return 0;
        }

        uint32 lower = 0;
        uint32 upper = nCheckpoints - 1;
        while (upper > lower) {
            uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
            Checkpoint memory cp = checkpoints[account][center];
            if (cp.fromBlock == blockNumber) {
                return cp.votes;
            } else if (cp.fromBlock < blockNumber) {
                lower = center;
            } else {
                upper = center - 1;
            }
        }
        return checkpoints[account][lower].votes;
    }

    function _delegate(address delegator, address delegatee)
        internal
    {
        address currentDelegate = _delegates[delegator];
        uint256 delegatorBalance = balanceOf(delegator); // balance of underlying JOCKERs;
        _delegates[delegator] = delegatee;

        emit DelegateChanged(delegator, currentDelegate, delegatee);

        _moveDelegates(currentDelegate, delegatee, delegatorBalance);
    }

    function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
        if (srcRep != dstRep && amount > 0) {
            if (srcRep != address(0)) {
                // decrease old representative
                uint32 srcRepNum = numCheckpoints[srcRep];
                uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
                uint256 srcRepNew = srcRepOld.sub(amount);
                _writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
            }

            if (dstRep != address(0)) {
                // increase new representative
                uint32 dstRepNum = numCheckpoints[dstRep];
                uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
                uint256 dstRepNew = dstRepOld.add(amount);
                _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
            }
        }
    }

    function _writeCheckpoint(
        address delegatee,
        uint32 nCheckpoints,
        uint256 oldVotes,
        uint256 newVotes
    )
        internal
    {
        uint32 blockNumber = safe32(block.number, "JOCKER::_writeCheckpoint: block number exceeds 32 bits");

        if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
            checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
        } else {
            checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
            numCheckpoints[delegatee] = nCheckpoints + 1;
        }

        emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
    }

    function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
        require(n < 2**32, errorMessage);
        return uint32(n);
    }

    function getChainId() internal pure returns (uint) {
        uint256 chainId;
        assembly { chainId := chainid() }
        return chainId;
    }
}



interface IMigratorChef {
    // Perform LP token migration from legacy UniswapV2 to SushiSwap.
    // Take the current LP token address and return the new LP token address.
    // Migrator should have full access to the caller's LP token.
    // Return the new LP token address.
    //
    // XXX Migrator must have allowance access to UniswapV2 LP tokens.
    // SushiSwap must mint EXACTLY the same amount of SushiSwap LP tokens or
    // else something bad will happen. Traditional UniswapV2 does not
    // do that so be careful!
    function migrate(IERC20 token) external returns (IERC20);
}

// LordJoker is the master of Joker. He can make JOKER 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 JOCKER is sufficiently
// distributed and the community can show to govern itself.
//
// Have fun reading it. Hopefully it's bug-free. God bless.
contract LordJoker is Ownable {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    // 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 JOCKERs
        // entitled to a user but is pending to be distributed is:
        //
        //   pending reward = (user.amount * pool.accJockerPerShare) - user.rewardDebt
        //
        // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
        //   1. The pool's `accJockerPerShare` (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 {
        bool lendPool;              // Whether is lending pool.
        IERC20 lpToken;             // Address of LP token contract.
        uint256 allocPoint;         // How many allocation points assigned to this pool. JOCKERs to distribute per block.
        uint256 lastRewardBlock;    // Last block number that JOCKERs distribution occurs.
        uint256 accJockerPerShare;  // Accumulated JOCKERs per share, times 1e12. See below.
        uint256 totalDeposit;       // Accumulated deposit tokens.
        // uint256 totalLend;          // Accumulated lent tokens.
    }

    // The JOCKER TOKEN!
    JokerToken public jocker;
    // Dev address.
    address public devaddr;
    // Treasury address.
    address public treasury;
    // Block number when bonus JOCKER period ends.
    // uint256 public bonusEndBlock;
    // JOCKER tokens created per block.
    uint256 public jockerPerBlock = 80 * 1e18;
    // Min rewards per block.
    uint256 public constant MIN_JOCKERs = 5 * 1e18;
    // Max supply 100m
    uint256 public constant MAX_SUPPLY = 100000000 * 1e18;
    // Bonus muliplier for early jocker makers.
    // uint256 public constant BONUS_MULTIPLIER = 10;
    // Half ervry blocks
    uint256 public constant HALVE_NUM = 200000;
    // Block number when half happens
    uint256 public halveBlockNum;
    // The migrator contract. It has a lot of power. Can only be set through governance (owner).
    IMigratorChef public migrator;
    // The lender contract. It can modify lendPool derectly. Can only be set through governance (owner).
    address public lender;
    // The vaults contract. It can transfer token derectly. Can only be set through governance (owner).
    address public vaults;
    
    // Info of each pool.
    PoolInfo[] public poolInfo;
    // Info of each user that stakes LP tokens.
    mapping (uint256 => mapping (address => UserInfo)) public userInfo;
    // Total allocation poitns. Must be the sum of all allocation points in all pools.
    uint256 public totalAllocPoint = 0;
    // The block number when JOCKER mining starts.
    uint256 public startBlock;

    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);
    event ClaimRewards(address indexed user, uint256 indexed pid, uint256 amount);
    event HalveRewards(uint256 indexed before, uint256 afther);

    constructor(
        JokerToken _joker,
        address _devaddr,
        address _treasury,
        // uint256 _jockerPerBlock,
        uint256 _startBlock
        // uint256 _bonusEndBlock
    ) public {
        jocker = _joker;
        devaddr = _devaddr;
        treasury = _treasury;
        // jockerPerBlock = _jockerPerBlock;
        // bonusEndBlock = _bonusEndBlock;
        startBlock = _startBlock;
        halveBlockNum = _startBlock.add(HALVE_NUM);
    }

    modifier checkHalve() {
        if (block.number >= halveBlockNum && jockerPerBlock > MIN_JOCKERs) {
            uint256 before = jockerPerBlock;
            jockerPerBlock = jockerPerBlock.mul(50).div(100);
            halveBlockNum = halveBlockNum.add(HALVE_NUM);
            emit HalveRewards(before, jockerPerBlock);
        }
        _;
    }

    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, bool _lendPool) public onlyOwner {
        if (_lendPool) {
            require(address(0) != lender, "add: no lender");
        }
        if (_withUpdate) {
            massUpdatePools();
        }
        uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        poolInfo.push(PoolInfo({
            lendPool: _lendPool,
            lpToken: _lpToken,
            allocPoint: _allocPoint,
            lastRewardBlock: lastRewardBlock,
            accJockerPerShare: 0,
            totalDeposit: 0
            // totalLend: 0
        }));
    }

    // Update the given pool's JOCKER allocation point. Can only be called by the owner.
    function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner {
        // !!!When change pool weight without massUpdatePools, will mint more or less jockerReward
        if (_withUpdate) {
            massUpdatePools();
        }
        totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
        poolInfo[_pid].allocPoint = _allocPoint;
    }

    // Transfer token contract owner. Can only be called by the owner.
    function transferTokenOwner(address _owner) public onlyOwner {
        jocker.transferOwnership(_owner);
    }

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

    // Set the lender contract. Can only be called by the owner.
    function setLender(address _lender) public onlyOwner {
        lender = _lender;
    }

    // Set the vaults contract. Can only be called by the owner.
    function setVaults(address _vaults) public onlyOwner {
        vaults = _vaults;
    }

    // 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 pure returns (uint256) {
        // if (_to <= bonusEndBlock) {
        //     return _to.sub(_from).mul(BONUS_MULTIPLIER);
        // } else if (_from >= bonusEndBlock) {
        //     return _to.sub(_from);
        // } else {
        //     return bonusEndBlock.sub(_from).mul(BONUS_MULTIPLIER).add(
        //         _to.sub(bonusEndBlock)
        //     );
        // }
        return _to.sub(_from);
    }

    // View function to see pending JOCKERs on frontend.
    function pendingJocker(uint256 _pid, address _user) external view returns (uint256) {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accJockerPerShare = pool.accJockerPerShare;
        if (block.number > pool.lastRewardBlock && pool.totalDeposit != 0) {
            uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
            uint256 jockerReward = multiplier.mul(jockerPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
            uint256 devReward = jockerReward.div(10);
            uint256 treasuryReward = jockerReward.div(10);
            uint256 poolReward = jockerReward.sub(devReward).sub(treasuryReward);
            accJockerPerShare = accJockerPerShare.add(poolReward.mul(1e12).div(pool.totalDeposit));
        }
        return user.amount.mul(accJockerPerShare).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 checkHalve {
        uint256 totalSupply = jocker.totalSupply();
        if (totalSupply >= MAX_SUPPLY) {
            return;
        }
        PoolInfo storage pool = poolInfo[_pid];
        if (block.number <= pool.lastRewardBlock) {
            return;
        }
        if (pool.totalDeposit == 0) {
            pool.lastRewardBlock = block.number;
            return;
        }
        uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
        uint256 jockerReward = multiplier.mul(jockerPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
        // !!!When change pool weight without massUpdatePools, will mint more or less jockerReward
        uint256 devReward = jockerReward.div(10);
        uint256 treasuryReward = jockerReward.div(10);
        uint256 poolReward = jockerReward.sub(devReward).sub(treasuryReward);
        jocker.mint(devaddr, devReward);
        jocker.mint(treasury, treasuryReward);
        jocker.mint(address(this), poolReward);
        pool.accJockerPerShare = pool.accJockerPerShare.add(poolReward.mul(1e12).div(pool.totalDeposit));
        pool.lastRewardBlock = block.number;
    }

    // Deposit LP tokens to LordJoker for JOCKER allocation.
    function deposit(address _user, uint256 _pid, uint256 _amount) public {
        if(lender != address(0)) {
            require(msg.sender == lender, "deposit: caller must be lender");
        } else {
            require(msg.sender == _user, "deposit: caller must be _user");
        }
        PoolInfo storage pool = poolInfo[_pid];
        require(!pool.lendPool, "deposit: can not be lendPool");
        UserInfo storage user = userInfo[_pid][_user];
        updatePool(_pid);
        if (user.amount > 0) {
            uint256 pending = user.amount.mul(pool.accJockerPerShare).div(1e12).sub(user.rewardDebt);
            if(pending > 0) {
                safeJockerTransfer(_user, pending);
            }
        }
        if(_amount > 0) {
            pool.lpToken.safeTransferFrom(address(_user), address(this), _amount);
            user.amount = user.amount.add(_amount);
            pool.totalDeposit = pool.totalDeposit.add(_amount);
        }
        user.rewardDebt = user.amount.mul(pool.accJockerPerShare).div(1e12);
        emit Deposit(_user, _pid, _amount);
    }

    // Withdraw LP tokens from LordJoker.
    function withdraw(address _user, uint256 _pid, uint256 _amount) public {
        if(lender != address(0)) {
            require(msg.sender == lender, "withdraw: caller must be lender");
        } else {
            require(msg.sender == _user, "withdraw: caller must be _user");
        }
        PoolInfo storage pool = poolInfo[_pid];
        require(!pool.lendPool, "withdraw: can not be lendPool");
        UserInfo storage user = userInfo[_pid][_user];
        require(user.amount >= _amount, "withdraw: not good");
        updatePool(_pid);
        uint256 pending = user.amount.mul(pool.accJockerPerShare).div(1e12).sub(user.rewardDebt);
        if(pending > 0) {
            safeJockerTransfer(_user, pending);
        }
        if(_amount > 0) {
            user.amount = user.amount.sub(_amount);
            pool.totalDeposit = pool.totalDeposit.sub(_amount);
            pool.lpToken.safeTransfer(address(_user), _amount);
        }
        user.rewardDebt = user.amount.mul(pool.accJockerPerShare).div(1e12);
        emit Withdraw(_user, _pid, _amount);
    }

    // Withdraw without caring about rewards. EMERGENCY ONLY.
    function emergencyWithdraw(address _user, uint256 _pid) public {
        if(lender != address(0)) {
            require(msg.sender == lender, "emergencyWithdraw: caller must be lender");
        } else {
            require(msg.sender == _user, "emergencyWithdraw: caller must be _user");
        }
        PoolInfo storage pool = poolInfo[_pid];
        require(!pool.lendPool, "emergencyWithdraw: can not be lendPool");
        UserInfo storage user = userInfo[_pid][_user];
        uint256 amount = user.amount;
        user.amount = 0;
        user.rewardDebt = 0;
        pool.totalDeposit = pool.totalDeposit.sub(amount);
        pool.lpToken.safeTransfer(address(_user), amount);
        emit EmergencyWithdraw(_user, _pid, amount);
    }

    // Claim JOCKER allocation rewards.
    function claim(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        updatePool(_pid);
        uint256 pending = 0;
        if (user.amount > 0) {
            pending = user.amount.mul(pool.accJockerPerShare).div(1e12).sub(user.rewardDebt);
            if(pending > 0) {
                safeJockerTransfer(msg.sender, pending);
            }
        }
        user.rewardDebt = user.amount.mul(pool.accJockerPerShare).div(1e12);
        emit ClaimRewards(msg.sender, _pid, pending);
    }

    // Claim all JOCKER allocation rewards. Be careful of gas spending!
    function claimAll() public {
        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            UserInfo storage user = userInfo[pid][msg.sender];
            if (user.amount > 0) {
                claim(pid);
            }
        }
    }

    // Increase user lendPool deposit amount for JOCKER allocation.
    function depositLendPool(address _user, uint256 _pid, uint256 _amount) external {
        require(msg.sender == lender, "depositLendPool: caller must be lender");
        PoolInfo storage pool = poolInfo[_pid];
        require(pool.lendPool, "depositLendPool: must be lendPool");
        UserInfo storage user = userInfo[_pid][_user];
        updatePool(_pid);
        if (user.amount > 0) {
            uint256 pending = user.amount.mul(pool.accJockerPerShare).div(1e12).sub(user.rewardDebt);
            if(pending > 0) {
                safeJockerTransfer(_user, pending);
            }
        }
        if(_amount > 0) {
            user.amount = user.amount.add(_amount);
            pool.totalDeposit = pool.totalDeposit.add(_amount);
        }
        user.rewardDebt = user.amount.mul(pool.accJockerPerShare).div(1e12);
        emit Deposit(_user, _pid, _amount);
    }

    // Decrease user lendPool deposit amount for JOCKER allocation.
    function withdrawLendPool(address _user, uint256 _pid, uint256 _amount) external {
        require(msg.sender == lender, "withdrawLendPool: caller must be lender");
        PoolInfo storage pool = poolInfo[_pid];
        require(pool.lendPool, "withdrawLendPool: must be lendPool");
        UserInfo storage user = userInfo[_pid][_user];
        require(user.amount >= _amount, "withdrawLendPool: not good");
        updatePool(_pid);
        uint256 pending = user.amount.mul(pool.accJockerPerShare).div(1e12).sub(user.rewardDebt);
        if(pending > 0) {
            safeJockerTransfer(_user, pending);
        }
        if(_amount > 0) {
            user.amount = user.amount.sub(_amount);
            pool.totalDeposit = pool.totalDeposit.sub(_amount);
        }
        user.rewardDebt = user.amount.mul(pool.accJockerPerShare).div(1e12);
        emit Withdraw(_user, _pid, _amount);
    }

    // Lend token to user, only called by lender. Be careful of cashability!!
    function lendToken(address _user, uint256 _pid, uint256 _amount) external {
        require(address(0) != lender, "lendToken: no lender");
        require(msg.sender == lender, "lendToken: caller must be lender");
        require(address(0) != _user, "lendToken: can not lend to 0");
        if(_amount > 0) {
            PoolInfo storage pool = poolInfo[_pid];
            pool.lpToken.safeTransfer(address(_user), _amount);  // XXX Must make sure have enough balance.
            // pool.totalLend = pool.totalLend.add(_amount);
        }
    }

    // Vault token to other pool, only called by vaults.
    function transferTokenToVaults(uint256 _pid, uint256 _amount) external {
        require(address(0) != vaults, "transferTokenToVaults: no vaults");
        require(msg.sender == vaults, "transferTokenToVaults: caller must be vaults");
        if(_amount > 0) {
            PoolInfo storage pool = poolInfo[_pid];
            pool.lpToken.safeTransfer(address(vaults), _amount);  // XXX Must make sure have enough balance.
        }
    }

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

    // Update dev address by the previous dev.
    function updateDev(address _devaddr) public {
        require(msg.sender == devaddr, "updateDev: wut?");
        devaddr = _devaddr;
    }
    
    // Update treasury address by the previous treasury.
    function updateTreasury(address _treasury) public {
        require(msg.sender == treasury, "updateTreasury: wut?");
        treasury = _treasury;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract JokerToken","name":"_joker","type":"address"},{"internalType":"address","name":"_devaddr","type":"address"},{"internalType":"address","name":"_treasury","type":"address"},{"internalType":"uint256","name":"_startBlock","type":"uint256"}],"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":"ClaimRewards","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":"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":"uint256","name":"before","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"afther","type":"uint256"}],"name":"HalveRewards","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":"HALVE_NUM","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MIN_JOCKERs","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IERC20","name":"_lpToken","type":"address"},{"internalType":"bool","name":"_withUpdate","type":"bool"},{"internalType":"bool","name":"_lendPool","type":"bool"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"},{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"},{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"depositLendPool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"devaddr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"},{"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":"pure","type":"function"},{"inputs":[],"name":"halveBlockNum","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"jocker","outputs":[{"internalType":"contract JokerToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"jockerPerBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"},{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"lendToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"lender","outputs":[{"internalType":"address","name":"","type":"address"}],"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":"pendingJocker","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"bool","name":"lendPool","type":"bool"},{"internalType":"contract IERC20","name":"lpToken","type":"address"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardBlock","type":"uint256"},{"internalType":"uint256","name":"accJockerPerShare","type":"uint256"},{"internalType":"uint256","name":"totalDeposit","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":"address","name":"_lender","type":"address"}],"name":"setLender","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IMigratorChef","name":"_migrator","type":"address"}],"name":"setMigrator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_vaults","type":"address"}],"name":"setVaults","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAllocPoint","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":"address","name":"_owner","type":"address"}],"name":"transferTokenOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"transferTokenToVaults","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"treasury","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_devaddr","type":"address"}],"name":"updateDev","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_treasury","type":"address"}],"name":"updateTreasury","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":[],"name":"vaults","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"},{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"},{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdrawLendPool","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000005cc4d697c8dca18edc09d6b9c656a788e873c6c1000000000000000000000000205b965b54bbc1033d547333ab55d3cb7566e4f900000000000000000000000050b45f9369516016f0d4ffa84eb4a96cae9ec9ef0000000000000000000000000000000000000000000000000000000000a6e776

-----Decoded View---------------
Arg [0] : _joker (address): 0x5cC4D697C8dCA18EdC09d6B9c656a788E873c6C1
Arg [1] : _devaddr (address): 0x205b965B54bBC1033d547333Ab55D3cB7566e4f9
Arg [2] : _treasury (address): 0x50b45f9369516016F0d4FFa84eb4a96cAE9ec9eF
Arg [3] : _startBlock (uint256): 10938230

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 0000000000000000000000005cc4d697c8dca18edc09d6b9c656a788e873c6c1
Arg [1] : 000000000000000000000000205b965b54bbc1033d547333ab55d3cb7566e4f9
Arg [2] : 00000000000000000000000050b45f9369516016f0d4ffa84eb4a96cae9ec9ef
Arg [3] : 0000000000000000000000000000000000000000000000000000000000a6e776

51049:18393:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52923:41;;;:::i;:::-;;;;;;;;;;;;;;;;;;;55449:95;;;:::i;:::-;;;;;;;;;;;;;;;;;;;61410:1103;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;53826:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54069:34;;;:::i;:::-;;;;;;;;;;;;;;;;;;;57206:102;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;52655:24;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;53079:53;;;:::i;:::-;;;;;;;;;;;;;;;;;;;64538:586;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;57755:491;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;57382:88;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;54162:25;;;:::i;:::-;;;;;;;;;;;;;;;;;;;53357:28;;;:::i;:::-;;;;;;;;;;;;;;;;;;;60133:1207;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;67542:555;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;52762:23;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;59877:180;;;:::i;:::-;;56534:404;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;28431:148;;;:::i;:::-;;53490:29;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;69284:155;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;53765:21;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;57018:112;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;65569:896;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;27789:79;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;58322:482;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;69073:141;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;53908:66;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;63729:760;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;53002:46;;;:::i;:::-;;;;;;;;;;;;;;;;;;;58870:924;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;57544:88;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;62564:1094;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;53632:21;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;66542:913;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;55713:723;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;65205:287;;;:::i;:::-;;53269:42;;;:::i;:::-;;;;;;;;;;;;;;;;;;;68163:444;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;52707:22;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;28734:244;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;52923:41;;;;:::o;55449:95::-;55494:7;55521:8;:15;;;;55514:22;;55449:95;:::o;61410:1103::-;61512:1;61494:20;;:6;;;;;;;;;;;:20;;;61491:209;;61553:6;;;;;;;;;;;61539:20;;:10;:20;;;61531:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61491:209;;;61649:5;61635:19;;:10;:19;;;61627:61;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61491:209;61710:21;61734:8;61743:4;61734:14;;;;;;;;;;;;;;;;;;61710:38;;61768:4;:13;;;;;;;;;;;;61767:14;61759:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61825:21;61849:8;:14;61858:4;61849:14;;;;;;;;;;;:21;61864:5;61849:21;;;;;;;;;;;;;;;61825:45;;61881:16;61892:4;61881:10;:16::i;:::-;61926:1;61912:4;:11;;;:15;61908:235;;;61944:15;61962:70;62016:4;:15;;;61962:49;62006:4;61962:39;61978:4;:22;;;61962:4;:11;;;:15;;:39;;;;:::i;:::-;:43;;:49;;;;:::i;:::-;:53;;:70;;;;:::i;:::-;61944:88;;62060:1;62050:7;:11;62047:85;;;62082:34;62101:5;62108:7;62082:18;:34::i;:::-;62047:85;61908:235;;62166:1;62156:7;:11;62153:230;;;62184:69;62222:5;62238:4;62245:7;62184:4;:12;;;;;;;;;;;;:29;;;;:69;;;;;;:::i;:::-;62282:24;62298:7;62282:4;:11;;;:15;;:24;;;;:::i;:::-;62268:4;:11;;:38;;;;62341:30;62363:7;62341:4;:17;;;:21;;:30;;;;:::i;:::-;62321:4;:17;;:50;;;;62153:230;62411:49;62455:4;62411:39;62427:4;:22;;;62411:4;:11;;;:15;;:39;;;;:::i;:::-;:43;;:49;;;;:::i;:::-;62393:4;:15;;:67;;;;62491:4;62484:5;62476:29;;;62497:7;62476:29;;;;;;;;;;;;;;;;;;61410:1103;;;;;:::o;53826:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;54069:34::-;;;;:::o;57206:102::-;28011:12;:10;:12::i;:::-;28001:22;;:6;;;;;;;;;;:22;;;27993:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57291:9:::1;57280:8;;:20;;;;;;;;;;;;;;;;;;57206:102:::0;:::o;52655:24::-;;;;;;;;;;;;;:::o;53079:53::-;53116:16;53079:53;:::o;64538:586::-;64585:21;64609:8;64618:4;64609:14;;;;;;;;;;;;;;;;;;64585:38;;64634:21;64658:8;:14;64667:4;64658:14;;;;;;;;;;;:26;64673:10;64658:26;;;;;;;;;;;;;;;64634:50;;64695:16;64706:4;64695:10;:16::i;:::-;64722:15;64770:1;64756:4;:11;;;:15;64752:232;;;64798:70;64852:4;:15;;;64798:49;64842:4;64798:39;64814:4;:22;;;64798:4;:11;;;:15;;:39;;;;:::i;:::-;:43;;:49;;;;:::i;:::-;:53;;:70;;;;:::i;:::-;64788:80;;64896:1;64886:7;:11;64883:90;;;64918:39;64937:10;64949:7;64918:18;:39::i;:::-;64883:90;64752:232;65012:49;65056:4;65012:39;65028:4;:22;;;65012:4;:11;;;:15;;:39;;;;:::i;:::-;:43;;:49;;;;:::i;:::-;64994:4;:15;;:67;;;;65102:4;65090:10;65077:39;;;65108:7;65077:39;;;;;;;;;;;;;;;;;;64538:586;;;;:::o;57755:491::-;57841:1;57812:31;;57820:8;;;;;;;;;;;57812:31;;;;57804:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57879:21;57903:8;57912:4;57903:14;;;;;;;;;;;;;;;;;;57879:38;;57928:14;57945:4;:12;;;;;;;;;;;;57928:29;;57968:11;57982:7;:17;;;58008:4;57982:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57968:46;;58025:43;58053:8;;;;;;;;;;;58064:3;58025:7;:19;;;;:43;;;;;:::i;:::-;58079:17;58099:8;;;;;;;;;;;:16;;;58116:7;58099:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58079:45;;58150:10;:20;;;58179:4;58150:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58143:3;:42;58135:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58228:10;58213:4;:12;;;:25;;;;;;;;;;;;;;;;;;57755:491;;;;;:::o;57382:88::-;28011:12;:10;:12::i;:::-;28001:22;;:6;;;;;;;;;;:22;;;27993:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57455:7:::1;57446:6;;:16;;;;;;;;;;;;;;;;;;57382:88:::0;:::o;54162:25::-;;;;:::o;53357:28::-;;;;:::o;60133:1207::-;55139:13;;55123:12;:29;;:61;;;;;53040:8;55156:14;;:28;55123:61;55119:303;;;55201:14;55218;;55201:31;;55264;55291:3;55264:22;55283:2;55264:14;;:18;;:22;;;;:::i;:::-;:26;;:31;;;;:::i;:::-;55247:14;:48;;;;55326:28;53305:6;55326:13;;:17;;:28;;;;:::i;:::-;55310:13;:44;;;;55387:6;55374:36;55395:14;;55374:36;;;;;;;;;;;;;;;;;;55119:303;;60196:19:::1;60218:6;;;;;;;;;;;:18;;;:20;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;60196:42;;53116:16;60253:11;:25;60249:64;;60295:7;;;60249:64;60323:21;60347:8;60356:4;60347:14;;;;;;;;;;;;;;;;;;60323:38;;60392:4;:20;;;60376:12;:36;60372:75;;60429:7;;;;60372:75;60482:1;60461:4;:17;;;:22;60457:111;;;60523:12;60500:4;:20;;:35;;;;60550:7;;;;60457:111;60578:18;60599:49;60613:4;:20;;;60635:12;60599:13;:49::i;:::-;60578:70;;60659:20;60682:72;60738:15;;60682:51;60717:4;:15;;;60682:30;60697:14;;60682:10;:14;;:30;;;;:::i;:::-;:34;;:51;;;;:::i;:::-;:55;;:72;;;;:::i;:::-;60659:95;;60865:17;60885:20;60902:2;60885:12;:16;;:20;;;;:::i;:::-;60865:40;;60916:22;60941:20;60958:2;60941:12;:16;;:20;;;;:::i;:::-;60916:45;;60972:18;60993:47;61025:14;60993:27;61010:9;60993:12;:16;;:27;;;;:::i;:::-;:31;;:47;;;;:::i;:::-;60972:68;;61051:6;;;;;;;;;;;:11;;;61063:7;;;;;;;;;;;61072:9;61051:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;61093:6;;;;;;;;;;;:11;;;61105:8;;;;;;;;;;;61115:14;61093:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;61141:6;;;;;;;;;;;:11;;;61161:4;61168:10;61141:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;61215:71;61242:43;61267:4;:17;;;61242:20;61257:4;61242:10;:14;;:20;;;;:::i;:::-;:24;;:43;;;;:::i;:::-;61215:4;:22;;;:26;;:71;;;;:::i;:::-;61190:4;:22;;:96;;;;61320:12;61297:4;:20;;:35;;;;55432:1;;;;;;;;60133:1207:::0;:::o;67542:555::-;67649:6;;;;;;;;;;;67635:20;;67643:1;67635:20;;;;67627:53;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67713:6;;;;;;;;;;;67699:20;;:10;:20;;;67691:65;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67789:5;67775:19;;67783:1;67775:19;;;;67767:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67851:1;67841:7;:11;67838:252;;;67869:21;67893:8;67902:4;67893:14;;;;;;;;;;;;;;;;;;67869:38;;67922:50;67956:5;67964:7;67922:4;:12;;;;;;;;;;;;:25;;;;:50;;;;;:::i;:::-;67838:252;;67542:555;;;:::o;52762:23::-;;;;;;;;;;;;;:::o;59877:180::-;59922:14;59939:8;:15;;;;59922:32;;59970:11;59965:85;59993:6;59987:3;:12;59965:85;;;60023:15;60034:3;60023:10;:15::i;:::-;60001:5;;;;;59965:85;;;;59877:180;:::o;56534:404::-;28011:12;:10;:12::i;:::-;28001:22;;:6;;;;;;;;;;:22;;;27993:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56732:11:::1;56728:61;;;56760:17;:15;:17::i;:::-;56728:61;56817:63;56868:11;56817:46;56837:8;56846:4;56837:14;;;;;;;;;;;;;;;;;;:25;;;56817:15;;:19;;:46;;;;:::i;:::-;:50;;:63;;;;:::i;:::-;56799:15;:81;;;;56919:11;56891:8;56900:4;56891:14;;;;;;;;;;;;;;;;;;:25;;:39;;;;56534:404:::0;;;:::o;28431:148::-;28011:12;:10;:12::i;:::-;28001:22;;:6;;;;;;;;;;:22;;;27993:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28538:1:::1;28501:40;;28522:6;::::0;::::1;;;;;;;;28501:40;;;;;;;;;;;;28569:1;28552:6:::0;::::1;:19;;;;;;;;;;;;;;;;;;28431:148::o:0;53490:29::-;;;;;;;;;;;;;:::o;69284:155::-;69367:8;;;;;;;;;;;69353:22;;:10;:22;;;69345:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69422:9;69411:8;;:20;;;;;;;;;;;;;;;;;;69284:155;:::o;53765:21::-;;;;;;;;;;;;;:::o;57018:112::-;28011:12;:10;:12::i;:::-;28001:22;;:6;;;;;;;;;;:22;;;27993:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57090:6:::1;;;;;;;;;;;:24;;;57115:6;57090:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;57018:112:::0;:::o;65569:896::-;65682:6;;;;;;;;;;;65668:20;;:10;:20;;;65660:71;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65742:21;65766:8;65775:4;65766:14;;;;;;;;;;;;;;;;;;65742:38;;65799:4;:13;;;;;;;;;;;;65791:59;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65861:21;65885:8;:14;65894:4;65885:14;;;;;;;;;;;:21;65900:5;65885:21;;;;;;;;;;;;;;;65861:45;;65917:16;65928:4;65917:10;:16::i;:::-;65962:1;65948:4;:11;;;:15;65944:235;;;65980:15;65998:70;66052:4;:15;;;65998:49;66042:4;65998:39;66014:4;:22;;;65998:4;:11;;;:15;;:39;;;;:::i;:::-;:43;;:49;;;;:::i;:::-;:53;;:70;;;;:::i;:::-;65980:88;;66096:1;66086:7;:11;66083:85;;;66118:34;66137:5;66144:7;66118:18;:34::i;:::-;66083:85;65944:235;;66202:1;66192:7;:11;66189:146;;;66234:24;66250:7;66234:4;:11;;;:15;;:24;;;;:::i;:::-;66220:4;:11;;:38;;;;66293:30;66315:7;66293:4;:17;;;:21;;:30;;;;:::i;:::-;66273:4;:17;;:50;;;;66189:146;66363:49;66407:4;66363:39;66379:4;:22;;;66363:4;:11;;;:15;;:39;;;;:::i;:::-;:43;;:49;;;;:::i;:::-;66345:4;:15;;:67;;;;66443:4;66436:5;66428:29;;;66449:7;66428:29;;;;;;;;;;;;;;;;;;65569:896;;;;;:::o;27789:79::-;27827:7;27854:6;;;;;;;;;;;27847:13;;27789:79;:::o;58322:482::-;58394:7;58782:14;58790:5;58782:3;:7;;:14;;;;:::i;:::-;58775:21;;58322:482;;;;:::o;69073:141::-;69150:7;;;;;;;;;;;69136:21;;:10;:21;;;69128:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69198:8;69188:7;;:18;;;;;;;;;;;;;;;;;;69073:141;:::o;53908:66::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;63729:760::-;63824:1;63806:20;;:6;;;;;;;;;;;:20;;;63803:229;;63865:6;;;;;;;;;;;63851:20;;:10;:20;;;63843:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63803:229;;;63971:5;63957:19;;:10;:19;;;63949:71;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63803:229;64042:21;64066:8;64075:4;64066:14;;;;;;;;;;;;;;;;;;64042:38;;64100:4;:13;;;;;;;;;;;;64099:14;64091:65;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64167:21;64191:8;:14;64200:4;64191:14;;;;;;;;;;;:21;64206:5;64191:21;;;;;;;;;;;;;;;64167:45;;64223:14;64240:4;:11;;;64223:28;;64276:1;64262:4;:11;;:15;;;;64306:1;64288:4;:15;;:19;;;;64338:29;64360:6;64338:4;:17;;;:21;;:29;;;;:::i;:::-;64318:4;:17;;:49;;;;64378;64412:5;64420:6;64378:4;:12;;;;;;;;;;;;:25;;;;:49;;;;;:::i;:::-;64468:4;64461:5;64443:38;;;64474:6;64443:38;;;;;;;;;;;;;;;;;;63729:760;;;;;:::o;53002:46::-;53040:8;53002:46;:::o;58870:924::-;58945:7;58965:21;58989:8;58998:4;58989:14;;;;;;;;;;;;;;;;;;58965:38;;59014:21;59038:8;:14;59047:4;59038:14;;;;;;;;;;;:21;59053:5;59038:21;;;;;;;;;;;;;;;59014:45;;59070:25;59098:4;:22;;;59070:50;;59150:4;:20;;;59135:12;:35;:61;;;;;59195:1;59174:4;:17;;;:22;;59135:61;59131:573;;;59213:18;59234:49;59248:4;:20;;;59270:12;59234:13;:49::i;:::-;59213:70;;59298:20;59321:72;59377:15;;59321:51;59356:4;:15;;;59321:30;59336:14;;59321:10;:14;;:30;;;;:::i;:::-;:34;;:51;;;;:::i;:::-;:55;;:72;;;;:::i;:::-;59298:95;;59408:17;59428:20;59445:2;59428:12;:16;;:20;;;;:::i;:::-;59408:40;;59463:22;59488:20;59505:2;59488:12;:16;;:20;;;;:::i;:::-;59463:45;;59523:18;59544:47;59576:14;59544:27;59561:9;59544:12;:16;;:27;;;;:::i;:::-;:31;;:47;;;;:::i;:::-;59523:68;;59626:66;59648:43;59673:4;:17;;;59648:20;59663:4;59648:10;:14;;:20;;;;:::i;:::-;:24;;:43;;;;:::i;:::-;59626:17;:21;;:66;;;;:::i;:::-;59606:86;;59131:573;;;;;;59721:65;59770:4;:15;;;59721:44;59760:4;59721:34;59737:17;59721:4;:11;;;:15;;:34;;;;:::i;:::-;:38;;:44;;;;:::i;:::-;:48;;:65;;;;:::i;:::-;59714:72;;;;;58870:924;;;;:::o;57544:88::-;28011:12;:10;:12::i;:::-;28001:22;;:6;;;;;;;;;;:22;;;27993:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57617:7:::1;57608:6;;:16;;;;;;;;;;;;;;;;;;57544:88:::0;:::o;62564:1094::-;62667:1;62649:20;;:6;;;;;;;;;;;:20;;;62646:211;;62708:6;;;;;;;;;;;62694:20;;:10;:20;;;62686:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62646:211;;;62805:5;62791:19;;:10;:19;;;62783:62;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62646:211;62867:21;62891:8;62900:4;62891:14;;;;;;;;;;;;;;;;;;62867:38;;62925:4;:13;;;;;;;;;;;;62924:14;62916:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62983:21;63007:8;:14;63016:4;63007:14;;;;;;;;;;;:21;63022:5;63007:21;;;;;;;;;;;;;;;62983:45;;63062:7;63047:4;:11;;;:22;;63039:53;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63103:16;63114:4;63103:10;:16::i;:::-;63130:15;63148:70;63202:4;:15;;;63148:49;63192:4;63148:39;63164:4;:22;;;63148:4;:11;;;:15;;:39;;;;:::i;:::-;:43;;:49;;;;:::i;:::-;:53;;:70;;;;:::i;:::-;63130:88;;63242:1;63232:7;:11;63229:77;;;63260:34;63279:5;63286:7;63260:18;:34::i;:::-;63229:77;63329:1;63319:7;:11;63316:211;;;63361:24;63377:7;63361:4;:11;;;:15;;:24;;;;:::i;:::-;63347:4;:11;;:38;;;;63420:30;63442:7;63420:4;:17;;;:21;;:30;;;;:::i;:::-;63400:4;:17;;:50;;;;63465;63499:5;63507:7;63465:4;:12;;;;;;;;;;;;:25;;;;:50;;;;;:::i;:::-;63316:211;63555:49;63599:4;63555:39;63571:4;:22;;;63555:4;:11;;;:15;;:39;;;;:::i;:::-;:43;;:49;;;;:::i;:::-;63537:4;:15;;:67;;;;63636:4;63629:5;63620:30;;;63642:7;63620:30;;;;;;;;;;;;;;;;;;62564:1094;;;;;;:::o;53632:21::-;;;;;;;;;;;;;:::o;66542:913::-;66656:6;;;;;;;;;;;66642:20;;:10;:20;;;66634:72;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66717:21;66741:8;66750:4;66741:14;;;;;;;;;;;;;;;;;;66717:38;;66774:4;:13;;;;;;;;;;;;66766:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66837:21;66861:8;:14;66870:4;66861:14;;;;;;;;;;;:21;66876:5;66861:21;;;;;;;;;;;;;;;66837:45;;66916:7;66901:4;:11;;;:22;;66893:61;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66965:16;66976:4;66965:10;:16::i;:::-;66992:15;67010:70;67064:4;:15;;;67010:49;67054:4;67010:39;67026:4;:22;;;67010:4;:11;;;:15;;:39;;;;:::i;:::-;:43;;:49;;;;:::i;:::-;:53;;:70;;;;:::i;:::-;66992:88;;67104:1;67094:7;:11;67091:77;;;67122:34;67141:5;67148:7;67122:18;:34::i;:::-;67091:77;67191:1;67181:7;:11;67178:146;;;67223:24;67239:7;67223:4;:11;;;:15;;:24;;;;:::i;:::-;67209:4;:11;;:38;;;;67282:30;67304:7;67282:4;:17;;;:21;;:30;;;;:::i;:::-;67262:4;:17;;:50;;;;67178:146;67352:49;67396:4;67352:39;67368:4;:22;;;67352:4;:11;;;:15;;:39;;;;:::i;:::-;:43;;:49;;;;:::i;:::-;67334:4;:15;;:67;;;;67433:4;67426:5;67417:30;;;67439:7;67417:30;;;;;;;;;;;;;;;;;;66542:913;;;;;;:::o;55713:723::-;28011:12;:10;:12::i;:::-;28001:22;;:6;;;;;;;;;;:22;;;27993:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55830:9:::1;55826:89;;;55878:6;;;;;;;;;;;55864:20;;55872:1;55864:20;;;;55856:47;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;55826:89;55929:11;55925:61;;;55957:17;:15;:17::i;:::-;55925:61;55996:23;56037:10;;56022:12;:25;:53;;56065:10;;56022:53;;;56050:12;56022:53;55996:79;;56104:32;56124:11;56104:15;;:19;;:32;;;;:::i;:::-;56086:15;:50;;;;56147:8;56161:266;;;;;;;;56195:9;56161:266;;;;;;56228:8;56161:266;;;;;;56263:11;56161:266;;;;56306:15;56161:266;;;;56355:1;56161:266;;;;56385:1;56161:266;;::::0;56147:281:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28071:1;55713:723:::0;;;;:::o;65205:287::-;65243:14;65260:8;:15;;;;65243:32;;65291:11;65286:199;65314:6;65308:3;:12;65286:199;;;65344:21;65368:8;:13;65377:3;65368:13;;;;;;;;;;;:25;65382:10;65368:25;;;;;;;;;;;;;;;65344:49;;65426:1;65412:4;:11;;;:15;65408:66;;;65448:10;65454:3;65448:5;:10::i;:::-;65408:66;65286:199;65322:5;;;;;65286:199;;;;65205:287;:::o;53269:42::-;53305:6;53269:42;:::o;68163:444::-;68267:6;;;;;;;;;;;68253:20;;68261:1;68253:20;;;;68245:65;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68343:6;;;;;;;;;;;68329:20;;:10;:20;;;68321:77;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68422:1;68412:7;:11;68409:191;;;68440:21;68464:8;68473:4;68464:14;;;;;;;;;;;;;;;;;;68440:38;;68493:51;68527:6;;;;;;;;;;;68536:7;68493:4;:12;;;;;;;;;;;;:25;;;;:51;;;;;:::i;:::-;68409:191;;68163:444;;:::o;52707:22::-;;;;;;;;;;;;;:::o;28734:244::-;28011:12;:10;:12::i;:::-;28001:22;;:6;;;;;;;;;;:22;;;27993:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28843:1:::1;28823:22;;:8;:22;;;;28815:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28933:8;28904:38;;28925:6;::::0;::::1;;;;;;;;28904:38;;;;;;;;;;;;28962:8;28953:6;::::0;:17:::1;;;;;;;;;;;;;;;;;;28734:244:::0;:::o;3646:181::-;3704:7;3724:9;3740:1;3736;:5;3724:17;;3765:1;3760;:6;;3752:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3818:1;3811:8;;;3646:181;;;;:::o;5000:471::-;5058:7;5308:1;5303;:6;5299:47;;;5333:1;5326:8;;;;5299:47;5358:9;5374:1;5370;:5;5358:17;;5403:1;5398;5394;:5;;;;;;:10;5386:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5462:1;5455:8;;;5000:471;;;;;:::o;5947:132::-;6005:7;6032:39;6036:1;6039;6032:39;;;;;;;;;;;;;;;;;:3;:39::i;:::-;6025:46;;5947:132;;;;:::o;4110:136::-;4168:7;4195:43;4199:1;4202;4195:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;4188:50;;4110:136;;;;:::o;68725:292::-;68803:17;68823:6;;;;;;;;;;;:16;;;68848:4;68823:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68803:51;;68879:9;68869:7;:19;68865:145;;;68905:6;;;;;;;;;;;:15;;;68921:3;68926:9;68905:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68865:145;;;68969:6;;;;;;;;;;;:15;;;68985:3;68990:7;68969:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68865:145;68725:292;;;:::o;14868:205::-;14969:96;14989:5;15019:27;;;15048:4;15054:2;15058:5;14996:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14969:19;:96::i;:::-;14868:205;;;;:::o;26398:106::-;26451:15;26486:10;26479:17;;26398:106;:::o;15342:622::-;15721:1;15712:5;:10;15711:62;;;;15771:1;15728:5;:15;;;15752:4;15759:7;15728:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:44;15711:62;15703:152;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15866:90;15886:5;15916:22;;;15940:7;15949:5;15893:62;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15866:19;:90::i;:::-;15342:622;;;:::o;14683:177::-;14766:86;14786:5;14816:23;;;14841:2;14845:5;14793:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14766:19;:86::i;:::-;14683:177;;;:::o;6575:278::-;6661:7;6693:1;6689;:5;6696:12;6681:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6720:9;6736:1;6732;:5;;;;;;6720:17;;6844:1;6837:8;;;6575:278;;;;;:::o;4549:192::-;4635:7;4668:1;4663;:6;;4671:12;4655:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4695:9;4711:1;4707;:5;4695:17;;4732:1;4725:8;;;4549:192;;;;;:::o;16988:761::-;17412:23;17438:69;17466:4;17438:69;;;;;;;;;;;;;;;;;17446:5;17438:27;;;;:69;;;;;:::i;:::-;17412:95;;17542:1;17522:10;:17;:21;17518:224;;;17664:10;17653:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17645:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17518:224;16988:761;;;:::o;11734:196::-;11837:12;11869:53;11892:6;11900:4;11906:1;11909:12;11869:22;:53::i;:::-;11862:60;;11734:196;;;;;:::o;13111:979::-;13241:12;13274:18;13285:6;13274:10;:18::i;:::-;13266:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13400:12;13414:23;13441:6;:11;;13461:8;13472:4;13441:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13399:78;;;;13492:7;13488:595;;;13523:10;13516:17;;;;;;13488:595;13657:1;13637:10;:17;:21;13633:439;;;13900:10;13894:17;13961:15;13948:10;13944:2;13940:19;13933:44;13848:148;14043:12;14036:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13111:979;;;;;;;:::o;8816:422::-;8876:4;9084:12;9195:7;9183:20;9175:28;;9229:1;9222:4;:8;9215:15;;;8816:422;;;:::o

ipfs://3a3a866d13d7be80f3602681686e436a23a086b032cfe9965bcc8c0ad999c17f