Contract 0xd90a92bd23b30dc3a69403e00651ff6d08c00fe7

/**
 *Submitted for verification at moonriver.moonscan.io on 2022-03-09
*/

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



pragma solidity >=0.6.0 <0.8.0;

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

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

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

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

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

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

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

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

            bytes32 lastvalue = set._values[lastIndex];

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

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

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

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

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

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

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

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(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(uint160(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(uint160(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(uint160(uint256(_at(set._inner, index))));
    }


    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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

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



pragma solidity >=0.6.2 <0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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

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



pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

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

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

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

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

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        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) {
        require(b <= a, "SafeMath: subtraction overflow");
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        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, reverting 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) {
        require(b > 0, "SafeMath: division by zero");
        return a / b;
    }

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

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

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * 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);
        return a / b;
    }

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

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



pragma solidity >=0.6.0 <0.8.0;

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

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

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



pragma solidity >=0.6.0 <0.8.0;




/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it.
 */
abstract contract AccessControl is Context {
    using EnumerableSet for EnumerableSet.AddressSet;
    using Address for address;

    struct RoleData {
        EnumerableSet.AddressSet members;
        bytes32 adminRole;
    }

    mapping (bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     *
     * _Available since v3.1._
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view returns (bool) {
        return _roles[role].members.contains(account);
    }

    /**
     * @dev Returns the number of accounts that have `role`. Can be used
     * together with {getRoleMember} to enumerate all bearers of a role.
     */
    function getRoleMemberCount(bytes32 role) public view returns (uint256) {
        return _roles[role].members.length();
    }

    /**
     * @dev Returns one of the accounts that have `role`. `index` must be a
     * value between 0 and {getRoleMemberCount}, non-inclusive.
     *
     * Role bearers are not sorted in any particular way, and their ordering may
     * change at any point.
     *
     * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
     * you perform all queries on the same block. See the following
     * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
     * for more information.
     */
    function getRoleMember(bytes32 role, uint256 index) public view returns (address) {
        return _roles[role].members.at(index);
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) public virtual {
        require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to grant");

        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) public virtual {
        require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to revoke");

        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) public virtual {
        require(account == _msgSender(), "AccessControl: can only renounce roles for self");

        _revokeRole(role, account);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event. Note that unlike {grantRole}, this function doesn't perform any
     * checks on the calling account.
     *
     * [WARNING]
     * ====
     * This function should only be called from the constructor when setting
     * up the initial roles for the system.
     *
     * Using this function in any other way is effectively circumventing the admin
     * system imposed by {AccessControl}.
     * ====
     */
    function _setupRole(bytes32 role, address account) internal virtual {
        _grantRole(role, account);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        emit RoleAdminChanged(role, _roles[role].adminRole, adminRole);
        _roles[role].adminRole = adminRole;
    }

    function _grantRole(bytes32 role, address account) private {
        if (_roles[role].members.add(account)) {
            emit RoleGranted(role, account, _msgSender());
        }
    }

    function _revokeRole(bytes32 role, address account) private {
        if (_roles[role].members.remove(account)) {
            emit RoleRevoked(role, account, _msgSender());
        }
    }
}

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



pragma solidity >=0.6.0 <0.8.0;


/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor () internal {
        _paused = false;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        require(!paused(), "Pausable: paused");
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        require(paused(), "Pausable: not paused");
        _;
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

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



pragma solidity >=0.6.0 <0.8.0;

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

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

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

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

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

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

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

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

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



pragma solidity >=0.6.0 <0.8.0;




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

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

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

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

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

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

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

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

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



pragma solidity >=0.6.0 <0.8.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;

    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 virtual returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual 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 virtual returns (uint8) {
        return _decimals;
    }

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

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual 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 virtual {
        _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 { }
}

// File: contracts/TomVault.sol



pragma solidity 0.6.12;







interface ITOM is IERC20 {
    function deposit(uint256 _amount) external;
    function withdraw(uint256 _share) external;
    function finn() external view returns (address);
}

interface IFarm {
    function deposit(uint256 _pid, uint256 _amount) external;

    function withdraw(uint256 _pid, uint256 _amount) external;

    function pendingReward(uint256 _pid, address _user) external view returns (uint256);

    function userInfo(uint256 _pid, address _user) external view returns (uint256, uint256);

    function emergencyWithdraw(uint256 _pid) external;
}

contract TomVault is ERC20("mTOM Token", "mTOM"), Pausable, AccessControl {
    using SafeERC20 for IERC20;
    using SafeERC20 for ITOM;
    using SafeMath for uint256;

    bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR");

    uint256 public immutable poolID;
    ITOM public immutable tom; // Tom token
    IFarm public immutable farm;

    address public treasury;

    uint256 public constant MAX_PERFORMANCE_FEE = 500; // 5%
    uint256 public constant MAX_CALL_FEE = 100; // 1%
    uint256 public constant DENOMINATOR = 10000;

    uint256 public performanceFee;
    uint256 public callFee = 25; // 0.25%

    event Deposit(address indexed sender, uint256 amount, uint256 shares, uint256 lastDepositedTime);
    event Withdraw(address indexed sender, uint256 amount, uint256 shares);
    event Harvest(address indexed sender, uint256 amount, uint256 performanceFee, uint256 callFee);
    event Pause();
    event Unpause();

    /**
     * @notice Constructor
     * @param _poolID: pool ID
     * @param _token: Tom token contract
     * @param _farm: HuckleberryFarm contract
     * @param _admin: address of the admin
     * @param _operator: address of the operator
     * @param _treasury: address of the treasury (collects fees)
     */
    constructor(
        uint256 _poolID,
        ITOM _token,
        IFarm _farm,
        address _admin,
        address _operator,
        address _treasury
    ) public {
        poolID = _poolID;
        tom = _token;
        farm = _farm;
        treasury = _treasury;

        _setupRole(DEFAULT_ADMIN_ROLE, _admin);
        _setupRole(OPERATOR_ROLE, _operator);

        // Infinite approve
        IERC20(_token.finn()).safeApprove(address(_token), uint256(-1));
        _token.safeApprove(address(_farm), uint256(-1));
    }

    /**
     * @notice Checks if the msg.sender is the operator address
     */
    modifier onlyOperator() {
        require(hasRole(OPERATOR_ROLE, msg.sender), "not operator");
        _;
    }
    modifier onlyAdmin() {
        require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "not admin");
        _;
    }
    /**
     * @notice Checks if the msg.sender is a contract or a proxy
     */
    modifier notContract() {
        require(!Address.isContract(msg.sender), "contract not allowed");
        require(msg.sender == tx.origin, "proxy contract not allowed");
        _;
    }

    /**
     * @dev A helper function to call deposit() with all the sender's funds.
     */
    function depositAll() external {
        deposit(tom.balanceOf(msg.sender));
    }

    /**
     * @notice Deposits funds into the Tom Vault
     * @dev Only possible when contract not paused.
     * @param _amount: number of tokens to deposit (in TOM)
     */
    function deposit(uint256 _amount) public whenNotPaused notContract {
        require(_amount > 0, "nothing to deposit");

        uint256 _before = tom.balanceOf(address(this));
        tom.safeTransferFrom(msg.sender, address(this), _amount);
        uint256 _after = tom.balanceOf(address(this));
        _amount = _after.sub(_before); // Additional check for deflationary tokens

        uint256 currentShares;
        if (totalSupply() != 0) {
            _withdraw(0);
            currentShares = (_amount.mul(totalSupply())).div(totalBalance().sub(_amount));
        } else {
            currentShares = _amount;
        }
        _mint(msg.sender, currentShares);

        _earn();

        emit Deposit(msg.sender, _amount, currentShares, block.timestamp);
    }

    /**
     * @notice Withdraws all funds for a user
     */
    function withdrawAll() external {
        withdrawShares(balanceOf(msg.sender));
    }

    function withdrawShares(uint256 _shares) public notContract {
        _withdraw(0);

        uint256 currentAmount = (totalBalance().mul(_shares)).div(totalSupply());
        _burn(msg.sender, _shares);

        uint256 bal = available();
        if (bal < currentAmount) {
            _withdraw(currentAmount.sub(bal));
        }

        tom.safeTransfer(msg.sender, currentAmount);

        _earn();

        emit Withdraw(msg.sender, currentAmount, _shares);
    }

    /**
     * @notice Withdraws from funds from the Tom Vault
     * @param _amount: number of tokens to withdraw (in TOM)
     */
    function withdraw(uint256 _amount) public notContract {
        _withdraw(0);

        uint256 currentShares = (_amount.mul(totalSupply())).div(totalBalance());
        require(currentShares > 0, "too small shares");
        _burn(msg.sender, currentShares);

        uint256 bal = available();
        if (bal < _amount) {
            _withdraw(_amount.sub(bal));
        }

        tom.safeTransfer(msg.sender, _amount);

        _earn();

        emit Withdraw(msg.sender, _amount, currentShares);
    }

    /**
     * @notice Reinvests TOM tokens into HuckleberryFarm
     * @dev Only possible when contract not paused.
     */
    function harvest() external whenNotPaused returns (uint256 callerReward, uint256 performanceReward, uint256 totalPending) {
        _withdraw(0);

        totalPending = available();

        performanceReward = totalPending.mul(performanceFee).div(DENOMINATOR);
        if (performanceReward > 0) {
            tom.safeTransfer(treasury, performanceReward);
        }

        callerReward = totalPending.mul(callFee).div(DENOMINATOR);
        tom.safeTransfer(msg.sender, callerReward);

        _earn();

        emit Harvest(msg.sender, totalPending, performanceReward, callerReward);
    }

    /**
     * @notice Sets treasury address
     * @dev Only callable by the contract admin.
     */
    function setTreasury(address _treasury) external onlyAdmin {
        require(_treasury != address(0), "cannot be zero address");
        treasury = _treasury;
    }

    /**
     * @notice Sets performance fee
     * @dev Only callable by the contract operator.
     */
    function setPerformanceFee(uint256 _performanceFee) external onlyOperator {
        require(_performanceFee <= MAX_PERFORMANCE_FEE, "performanceFee cannot be more than MAX_PERFORMANCE_FEE");
        performanceFee = _performanceFee;
    }

    /**
     * @notice Sets call fee
     * @dev Only callable by the contract operator.
     */
    function setCallFee(uint256 _callFee) external onlyOperator {
        require(_callFee <= MAX_CALL_FEE, "callFee cannot be more than MAX_CALL_FEE");
        callFee = _callFee;
    }

    /**
     * @notice Withdraws from HuckleberryFarm to Vault without caring about rewards.
     * @dev EMERGENCY ONLY. Only callable by the contract operator.
     */
    function emergencyWithdraw() external onlyOperator {
        farm.emergencyWithdraw(poolID);
    }

    /**
     * @notice Withdraw unexpected tokens sent to the Tom Vault
     */
    function inCaseTokensGetStuck(address _token) external onlyAdmin {
        require(_token != address(tom), "token cannot be same as deposit token");
        require(_token != address(finn()), "token cannot be same as internal token of deposit token");

        uint256 amount = IERC20(_token).balanceOf(address(this));
        IERC20(_token).safeTransfer(msg.sender, amount);
    }

    /**
     * @notice Triggers stopped state
     * @dev Only possible when contract not paused.
     */
    function pause() public onlyOperator whenNotPaused {
        _pause();
        emit Pause();
    }

    /**
     * @notice Returns to normal state
     * @dev Only possible when contract is paused.
     */
    function unpause() external onlyOperator whenPaused {
        _unpause();
        emit Unpause();
    }

    /**
     * @notice Calculates the price per share
     */
    function getPricePerFullShare() external view returns (uint256) {
        return totalSupply() == 0 ? 1e18 : totalBalance().mul(1e18).div(totalSupply());
    }

    /**
     * @notice Custom logic for how much the vault allows to be borrowed
     * @dev The contract puts 100% of the tokens to work.
     */
    function available() public view returns (uint256) {
        return tom.balanceOf(address(this));
    }

    /**
     * @notice Calculates the total underlying tokens
     * @dev It includes tokens held by the contract and held in HuckleberryFarm
     */
    function totalBalance() public view returns (uint256) {
        (uint256 amount, ) = farm.userInfo(poolID, address(this));
        return tom.balanceOf(address(this)).add(amount);
    }

    function finn() public view returns (IERC20) {
        return IERC20(tom.finn());
    }

    function availableFinn() public view returns (uint256) {
        return finn().balanceOf(address(this));
    }

    function _finnToTom(uint256 _amount) internal {
        if (_amount > 0) {
            IERC20 finnToken = finn();
            ITOM tomToken = tom;
            if (finnToken.allowance(address(this), address(tomToken)) < _amount) {
                finnToken.safeApprove(address(tomToken), uint256(-1));
            }
            tomToken.deposit(_amount);
        }
    }

    function _withdraw(uint256 _amount) internal {
        farm.withdraw(poolID, _amount);
        _finnToTom(availableFinn());
    }

    /**
     * @notice Deposits tokens into HuckleberryFarm to earn staking rewards
     */
    function _earn() internal {
        uint256 bal = available();
        if (bal > 0) {
            ITOM tomToken = tom;
            IFarm farmInst = farm;
            if (tomToken.allowance(address(this), address(farmInst)) < bal) {
                tomToken.safeApprove(address(farmInst), uint256(-1));
            }

            farmInst.deposit(poolID, bal);
        }
    }
}

[{"inputs":[{"internalType":"uint256","name":"_poolID","type":"uint256"},{"internalType":"contract ITOM","name":"_token","type":"address"},{"internalType":"contract IFarm","name":"_farm","type":"address"},{"internalType":"address","name":"_admin","type":"address"},{"internalType":"address","name":"_operator","type":"address"},{"internalType":"address","name":"_treasury","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"lastDepositedTime","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"performanceFee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"callFee","type":"uint256"}],"name":"Harvest","type":"event"},{"anonymous":false,"inputs":[],"name":"Pause","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[],"name":"Unpause","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DENOMINATOR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_CALL_FEE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_PERFORMANCE_FEE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"OPERATOR_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"available","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"availableFinn","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"callFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"depositAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"farm","outputs":[{"internalType":"contract IFarm","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"finn","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPricePerFullShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getRoleMember","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleMemberCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"harvest","outputs":[{"internalType":"uint256","name":"callerReward","type":"uint256"},{"internalType":"uint256","name":"performanceReward","type":"uint256"},{"internalType":"uint256","name":"totalPending","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"inCaseTokensGetStuck","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"performanceFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolID","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_callFee","type":"uint256"}],"name":"setCallFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_performanceFee","type":"uint256"}],"name":"setPerformanceFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_treasury","type":"address"}],"name":"setTreasury","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tom","outputs":[{"internalType":"contract ITOM","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"treasury","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_shares","type":"uint256"}],"name":"withdrawShares","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000000000000000000000000000000000000000001400000000000000000000000037619cc85325afea778830e184cb60a3abc9210b0000000000000000000000001f4b7660b6adc3943b5038e3426b33c1c0e343e6000000000000000000000000b87a39c5d3f5c53395ba11b5058655a4a8ac82a5000000000000000000000000b87a39c5d3f5c53395ba11b5058655a4a8ac82a5000000000000000000000000cd7b3c2f6eb6dabbcfc4d131ce97fa02c099cab3

-----Decoded View---------------
Arg [0] : _poolID (uint256): 20
Arg [1] : _token (address): 0x37619cc85325afea778830e184cb60a3abc9210b
Arg [2] : _farm (address): 0x1f4b7660b6adc3943b5038e3426b33c1c0e343e6
Arg [3] : _admin (address): 0xb87a39c5d3f5c53395ba11b5058655a4a8ac82a5
Arg [4] : _operator (address): 0xb87a39c5d3f5c53395ba11b5058655a4a8ac82a5
Arg [5] : _treasury (address): 0xcd7b3c2f6eb6dabbcfc4d131ce97fa02c099cab3

-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000014
Arg [1] : 00000000000000000000000037619cc85325afea778830e184cb60a3abc9210b
Arg [2] : 0000000000000000000000001f4b7660b6adc3943b5038e3426b33c1c0e343e6
Arg [3] : 000000000000000000000000b87a39c5d3f5c53395ba11b5058655a4a8ac82a5
Arg [4] : 000000000000000000000000b87a39c5d3f5c53395ba11b5058655a4a8ac82a5
Arg [5] : 000000000000000000000000cd7b3c2f6eb6dabbcfc4d131ce97fa02c099cab3

54288:9910:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44753:91;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46899:169;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;45852:108;;;:::i;:::-;;;;;;;;;;;;;;;;;;;58083:484;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;47550:321;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;30537:114;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;60728:185;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;54751:42;;;:::i;:::-;;;;;;;;;;;;;;;;;;;58711:523;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;30913:227;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;45696:91;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;62971:89;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;32122:209;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;54621:27;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;48280:218;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;62009:106;;;:::i;:::-;;59371:610;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62508:105;;;:::i;:::-;;;;;;;;;;;;;;;;;;;34849:86;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;54657:23;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;60378:241;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;46023:127;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;62188:161;;;:::i;:::-;;;;;;;;;;;;;;;;;;;61790:101;;;:::i;:::-;;57987:88;;;:::i;:::-;;54858:29;;;:::i;:::-;;;;;;;;;;;;;;;;;;;54538:31;;;:::i;:::-;;;;;;;;;;;;;;;;;;;30210:138;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;54894:27;;;:::i;:::-;;;;;;;;;;;;;;;;;;;54806:43;;;:::i;:::-;;;;;;;;;;;;;;;;;;;29171:139;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;44963:95;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27916:49;;;:::i;:::-;;;;;;;;;;;;;;;;;;;49001:269;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;46363:175;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;62775:188;;;:::i;:::-;;;;;;;;;;;;;;;;;;;63068:112;;;:::i;:::-;;;;;;;;;;;;;;;;;;;57124:790;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;54689:49;;;:::i;:::-;;;;;;;;;;;;;;;;;;;29484:127;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;54576:25;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;31385:230;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;61094:100;;;:::i;:::-;;46601:151;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;56850:84;;;:::i;:::-;;61285:387;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;60095:167;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;54468:61;;;:::i;:::-;;;;;;;;;;;;;;;;;;;44753:91;44798:13;44831:5;44824:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44753:91;:::o;46899:169::-;46982:4;46999:39;47008:12;:10;:12::i;:::-;47022:7;47031:6;46999:8;:39::i;:::-;47056:4;47049:11;;46899:169;;;;:::o;45852:108::-;45913:7;45940:12;;45933:19;;45852:108;:::o;58083:484::-;56598:30;56617:10;56598:18;:30::i;:::-;56597:31;56589:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56686:9;56672:23;;:10;:23;;;56664:62;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58154:12:::1;58164:1;58154:9;:12::i;:::-;58179:21;58203:48;58237:13;:11;:13::i;:::-;58204:27;58223:7;58204:14;:12;:14::i;:::-;:18;;:27;;;;:::i;:::-;58203:33;;:48;;;;:::i;:::-;58179:72;;58262:26;58268:10;58280:7;58262:5;:26::i;:::-;58301:11;58315;:9;:11::i;:::-;58301:25;;58347:13;58341:3;:19;58337:85;;;58377:33;58387:22;58405:3;58387:13;:17;;:22;;;;:::i;:::-;58377:9;:33::i;:::-;58337:85;58434:43;58451:10;58463:13;58434:3;:16;;;;:43;;;;;:::i;:::-;58490:7;:5;:7::i;:::-;58524:10;58515:44;;;58536:13;58551:7;58515:44;;;;;;;;;;;;;;;;;;;;;;;;56737:1;;58083:484:::0;:::o;47550:321::-;47656:4;47673:36;47683:6;47691:9;47702:6;47673:9;:36::i;:::-;47720:121;47729:6;47737:12;:10;:12::i;:::-;47751:89;47789:6;47751:89;;;;;;;;;;;;;;;;;:11;:19;47763:6;47751:19;;;;;;;;;;;;;;;:33;47771:12;:10;:12::i;:::-;47751:33;;;;;;;;;;;;;;;;:37;;:89;;;;;:::i;:::-;47720:8;:121::i;:::-;47859:4;47852:11;;47550:321;;;;;:::o;30537:114::-;30594:7;30621:6;:12;30628:4;30621:12;;;;;;;;;;;:22;;;30614:29;;30537:114;;;:::o;60728:185::-;56275:34;54508:21;56298:10;56275:7;:34::i;:::-;56267:59;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54790:3:::1;60807:8;:24;;60799:77;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60897:8;60887:7;:18;;;;60728:185:::0;:::o;54751:42::-;54790:3;54751:42;:::o;58711:523::-;56598:30;56617:10;56598:18;:30::i;:::-;56597:31;56589:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56686:9;56672:23;;:10;:23;;;56664:62;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58776:12:::1;58786:1;58776:9;:12::i;:::-;58801:21;58825:48;58858:14;:12;:14::i;:::-;58826:26;58838:13;:11;:13::i;:::-;58826:7;:11;;:26;;;;:::i;:::-;58825:32;;:48;;;;:::i;:::-;58801:72;;58908:1;58892:13;:17;58884:46;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;58941:32;58947:10;58959:13;58941:5;:32::i;:::-;58986:11;59000;:9;:11::i;:::-;58986:25;;59032:7;59026:3;:13;59022:73;;;59056:27;59066:16;59078:3;59066:7;:11;;:16;;;;:::i;:::-;59056:9;:27::i;:::-;59022:73;59107:37;59124:10;59136:7;59107:3;:16;;;;:37;;;;;:::i;:::-;59157:7;:5;:7::i;:::-;59191:10;59182:44;;;59203:7;59212:13;59182:44;;;;;;;;;;;;;;;;;;;;;;;;56737:1;;58711:523:::0;:::o;30913:227::-;30997:45;31005:6;:12;31012:4;31005:12;;;;;;;;;;;:22;;;31029:12;:10;:12::i;:::-;30997:7;:45::i;:::-;30989:105;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31107:25;31118:4;31124:7;31107:10;:25::i;:::-;30913:227;;:::o;45696:91::-;45745:5;45770:9;;;;;;;;;;;45763:16;;45696:91;:::o;62971:89::-;63008:6;63041:3;:8;;;:10;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63027:25;;62971:89;:::o;32122:209::-;32220:12;:10;:12::i;:::-;32209:23;;:7;:23;;;32201:83;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32297:26;32309:4;32315:7;32297:11;:26::i;:::-;32122:209;;:::o;54621:27::-;;;:::o;48280:218::-;48368:4;48385:83;48394:12;:10;:12::i;:::-;48408:7;48417:50;48456:10;48417:11;:25;48429:12;:10;:12::i;:::-;48417:25;;;;;;;;;;;;;;;:34;48443:7;48417:34;;;;;;;;;;;;;;;;:38;;:50;;;;:::i;:::-;48385:8;:83::i;:::-;48486:4;48479:11;;48280:218;;;;:::o;62009:106::-;56275:34;54508:21;56298:10;56275:7;:34::i;:::-;56267:59;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35452:8:::1;:6;:8::i;:::-;35444:41;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;62072:10:::2;:8;:10::i;:::-;62098:9;;;;;;;;;;62009:106::o:0;59371:610::-;59422:20;59444:25;59471:20;35175:8;:6;:8::i;:::-;35174:9;35166:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59504:12:::1;59514:1;59504:9;:12::i;:::-;59544:11;:9;:11::i;:::-;59529:26;;59588:49;54844:5;59588:32;59605:14;;59588:12;:16;;:32;;;;:::i;:::-;:36;;:49;;;;:::i;:::-;59568:69;;59672:1;59652:17;:21;59648:99;;;59690:45;59707:8;;;;;;;;;;;59717:17;59690:3;:16;;;;:45;;;;;:::i;:::-;59648:99;59774:42;54844:5;59774:25;59791:7;;59774:12;:16;;:25;;;;:::i;:::-;:29;;:42;;;;:::i;:::-;59759:57;;59827:42;59844:10;59856:12;59827:3;:16;;;;:42;;;;;:::i;:::-;59882:7;:5;:7::i;:::-;59915:10;59907:66;;;59927:12;59941:17;59960:12;59907:66;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59371:610:::0;;;:::o;62508:105::-;62550:7;62577:3;:13;;;62599:4;62577:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62570:35;;62508:105;:::o;34849:86::-;34896:4;34920:7;;;;;;;;;;;34913:14;;34849:86;:::o;54657:23::-;;;;;;;;;;;;;:::o;60378:241::-;56275:34;54508:21;56298:10;56275:7;:34::i;:::-;56267:59;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54735:3:::1;60471:15;:38;;60463:105;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60596:15;60579:14;:32;;;;60378:241:::0;:::o;46023:127::-;46097:7;46124:9;:18;46134:7;46124:18;;;;;;;;;;;;;;;;46117:25;;46023:127;;;:::o;62188:161::-;62243:7;62287:1;62270:13;:11;:13::i;:::-;:18;:71;;62298:43;62327:13;:11;:13::i;:::-;62298:24;62317:4;62298:14;:12;:14::i;:::-;:18;;:24;;;;:::i;:::-;:28;;:43;;;;:::i;:::-;62270:71;;;62291:4;62270:71;62263:78;;62188:161;:::o;61790:101::-;56275:34;54508:21;56298:10;56275:7;:34::i;:::-;56267:59;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35175:8:::1;:6;:8::i;:::-;35174:9;35166:38;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;61852:8:::2;:6;:8::i;:::-;61876:7;;;;;;;;;;61790:101::o:0;57987:88::-;58030:37;58045:21;58055:10;58045:9;:21::i;:::-;58030:14;:37::i;:::-;57987:88::o;54858:29::-;;;;:::o;54538:31::-;;;:::o;30210:138::-;30283:7;30310:30;30334:5;30310:6;:12;30317:4;30310:12;;;;;;;;;;;:20;;:23;;:30;;;;:::i;:::-;30303:37;;30210:138;;;;:::o;54894:27::-;;;;:::o;54806:43::-;54844:5;54806:43;:::o;29171:139::-;29240:4;29264:38;29294:7;29264:6;:12;29271:4;29264:12;;;;;;;;;;;:20;;:29;;:38;;;;:::i;:::-;29257:45;;29171:139;;;;:::o;44963:95::-;45010:13;45043:7;45036:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44963:95;:::o;27916:49::-;27961:4;27916:49;;;:::o;49001:269::-;49094:4;49111:129;49120:12;:10;:12::i;:::-;49134:7;49143:96;49182:15;49143:96;;;;;;;;;;;;;;;;;:11;:25;49155:12;:10;:12::i;:::-;49143:25;;;;;;;;;;;;;;;:34;49169:7;49143:34;;;;;;;;;;;;;;;;:38;;:96;;;;;:::i;:::-;49111:8;:129::i;:::-;49258:4;49251:11;;49001:269;;;;:::o;46363:175::-;46449:4;46466:42;46476:12;:10;:12::i;:::-;46490:9;46501:6;46466:9;:42::i;:::-;46526:4;46519:11;;46363:175;;;;:::o;62775:188::-;62820:7;62841:14;62861:4;:13;;;62875:6;62891:4;62861:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62840:57;;;62915:40;62948:6;62915:3;:13;;;62937:4;62915:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:32;;:40;;;;:::i;:::-;62908:47;;;62775:188;:::o;63068:112::-;63114:7;63141:6;:4;:6::i;:::-;:16;;;63166:4;63141:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63134:38;;63068:112;:::o;57124:790::-;35175:8;:6;:8::i;:::-;35174:9;35166:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56598:30:::1;56617:10;56598:18;:30::i;:::-;56597:31;56589:64;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;56686:9;56672:23;;:10;:23;;;56664:62;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;57220:1:::2;57210:7;:11;57202:42;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;57257:15;57275:3;:13;;;57297:4;57275:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;57257:46;;57314:56;57335:10;57355:4;57362:7;57314:3;:20;;;;:56;;;;;;:::i;:::-;57381:14;57398:3;:13;;;57420:4;57398:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;57381:45;;57447:19;57458:7;57447:6;:10;;:19;;;;:::i;:::-;57437:29;;57523:21;57576:1:::0;57559:13:::2;:11;:13::i;:::-;:18;57555:211;;57594:12;57604:1;57594:9;:12::i;:::-;57637:61;57670:27;57689:7;57670:14;:12;:14::i;:::-;:18;;:27;;;;:::i;:::-;57638:26;57650:13;:11;:13::i;:::-;57638:7;:11;;:26;;;;:::i;:::-;57637:32;;:61;;;;:::i;:::-;57621:77;;57555:211;;;57747:7;57731:23;;57555:211;57776:32;57782:10;57794:13;57776:5;:32::i;:::-;57821:7;:5;:7::i;:::-;57854:10;57846:60;;;57866:7;57875:13;57890:15;57846:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56737:1;;;57124:790:::0;:::o;54689:49::-;54735:3;54689:49;:::o;29484:127::-;29547:7;29574:29;:6;:12;29581:4;29574:12;;;;;;;;;;;:20;;:27;:29::i;:::-;29567:36;;29484:127;;;:::o;54576:25::-;;;:::o;31385:230::-;31470:45;31478:6;:12;31485:4;31478:12;;;;;;;;;;;:22;;;31502:12;:10;:12::i;:::-;31470:7;:45::i;:::-;31462:106;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31581:26;31593:4;31599:7;31581:11;:26::i;:::-;31385:230;;:::o;61094:100::-;56275:34;54508:21;56298:10;56275:7;:34::i;:::-;56267:59;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61156:4:::1;:22;;;61179:6;61156:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;61094:100::o:0;46601:151::-;46690:7;46717:11;:18;46729:5;46717:18;;;;;;;;;;;;;;;:27;46736:7;46717:27;;;;;;;;;;;;;;;;46710:34;;46601:151;;;;:::o;56850:84::-;56892:34;56900:3;:13;;;56914:10;56900:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56892:7;:34::i;:::-;56850:84::o;61285:387::-;56392:39;27961:4;56400:18;;56420:10;56392:7;:39::i;:::-;56384:61;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61387:3:::1;61369:22;;:6;:22;;;;61361:72;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61470:6;:4;:6::i;:::-;61452:25;;:6;:25;;;;61444:93;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61550:14;61574:6;61567:24;;;61600:4;61567:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;61550:56;;61617:47;61645:10;61657:6;61624;61617:27;;;;:47;;;;;:::i;:::-;56456:1;61285:387:::0;:::o;60095:167::-;56392:39;27961:4;56400:18;;56420:10;56392:7;:39::i;:::-;56384:61;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60194:1:::1;60173:23;;:9;:23;;;;60165:58;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;60245:9;60234:8;;:20;;;;;;;;;;;;;;;;;;60095:167:::0;:::o;54468:61::-;54508:21;54468:61;:::o;40171:622::-;40550:1;40541:5;:10;40540:62;;;;40600:1;40557:5;:15;;;40581:4;40588:7;40557:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:44;40540:62;40532:152;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40695:90;40715:5;40745:22;;;40769:7;40778:5;40722:62;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40695:19;:90::i;:::-;40171:622;;;:::o;6658:152::-;6728:4;6752:50;6757:3;:10;;6793:5;6777:23;;6769:32;;6752:4;:50::i;:::-;6745:57;;6658:152;;;;:::o;13408:195::-;13511:12;13543:52;13565:6;13573:4;13579:1;13582:12;13543:21;:52::i;:::-;13536:59;;13408:195;;;;;:::o;25849:106::-;25902:15;25937:10;25930:17;;25849:106;:::o;52148:346::-;52267:1;52250:19;;:5;:19;;;;52242:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52348:1;52329:21;;:7;:21;;;;52321:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52432:6;52402:11;:18;52414:5;52402:18;;;;;;;;;;;;;;;:27;52421:7;52402:27;;;;;;;;;;;;;;;:36;;;;52470:7;52454:32;;52463:5;52454:32;;;52479:6;52454:32;;;;;;;;;;;;;;;;;;52148:346;;;:::o;10490:422::-;10550:4;10758:12;10869:7;10857:20;10849:28;;10903:1;10896:4;:8;10889:15;;;10490:422;;;:::o;63574:132::-;63630:4;:13;;;63644:6;63652:7;63630:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63671:27;63682:15;:13;:15::i;:::-;63671:10;:27::i;:::-;63574:132;:::o;21425:220::-;21483:7;21512:1;21507;:6;21503:20;;;21522:1;21515:8;;;;21503:20;21534:9;21550:1;21546;:5;21534:17;;21579:1;21574;21570;:5;;;;;;:10;21562:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21636:1;21629:8;;;21425:220;;;;;:::o;22123:153::-;22181:7;22213:1;22209;:5;22201:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22267:1;22263;:5;;;;;;22256:12;;22123:153;;;;:::o;51292:418::-;51395:1;51376:21;;:7;:21;;;;51368:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51448:49;51469:7;51486:1;51490:6;51448:20;:49::i;:::-;51531:68;51554:6;51531:68;;;;;;;;;;;;;;;;;:9;:18;51541:7;51531:18;;;;;;;;;;;;;;;;:22;;:68;;;;;:::i;:::-;51510:9;:18;51520:7;51510:18;;;;;;;;;;;;;;;:89;;;;51625:24;51642:6;51625:12;;:16;;:24;;;;:::i;:::-;51610:12;:39;;;;51691:1;51665:37;;51674:7;51665:37;;;51695:6;51665:37;;;;;;;;;;;;;;;;;;51292:418;;:::o;21008:158::-;21066:7;21099:1;21094;:6;;21086:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21157:1;21153;:5;21146:12;;21008:158;;;;:::o;39512:177::-;39595:86;39615:5;39645:23;;;39670:2;39674:5;39622:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39595:19;:86::i;:::-;39512:177;;;:::o;63809:386::-;63846:11;63860;:9;:11::i;:::-;63846:25;;63892:1;63886:3;:7;63882:306;;;63910:13;63926:3;63910:19;;63944:14;63961:4;63944:21;;64039:3;63984:8;:18;;;64011:4;64026:8;63984:52;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:58;63980:151;;;64063:52;64092:8;64111:2;64063:8;:20;;;;:52;;;;;:::i;:::-;63980:151;64147:8;:16;;;64164:6;64172:3;64147:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63882:306;;;63809:386;:::o;49760:539::-;49884:1;49866:20;;:6;:20;;;;49858:70;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49968:1;49947:23;;:9;:23;;;;49939:71;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50023:47;50044:6;50052:9;50063:6;50023:20;:47::i;:::-;50103:71;50125:6;50103:71;;;;;;;;;;;;;;;;;:9;:17;50113:6;50103:17;;;;;;;;;;;;;;;;:21;;:71;;;;;:::i;:::-;50083:9;:17;50093:6;50083:17;;;;;;;;;;;;;;;:91;;;;50208:32;50233:6;50208:9;:20;50218:9;50208:20;;;;;;;;;;;;;;;;:24;;:32;;;;:::i;:::-;50185:9;:20;50195:9;50185:20;;;;;;;;;;;;;;;:55;;;;50273:9;50256:35;;50265:6;50256:35;;;50284:6;50256:35;;;;;;;;;;;;;;;;;;49760:539;;;:::o;23373:166::-;23459:7;23492:1;23487;:6;;23495:12;23479:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23530:1;23526;:5;23519:12;;23373:166;;;;;:::o;33365:188::-;33439:33;33464:7;33439:6;:12;33446:4;33439:12;;;;;;;;;;;:20;;:24;;:33;;;;:::i;:::-;33435:111;;;33521:12;:10;:12::i;:::-;33494:40;;33512:7;33494:40;;33506:4;33494:40;;;;;;;;;;33435:111;33365:188;;:::o;33561:192::-;33636:36;33664:7;33636:6;:12;33643:4;33636:12;;;;;;;;;;;:20;;:27;;:36;;;;:::i;:::-;33632:114;;;33721:12;:10;:12::i;:::-;33694:40;;33712:7;33694:40;;33706:4;33694:40;;;;;;;;;;33632:114;33561:192;;:::o;20546:179::-;20604:7;20624:9;20640:1;20636;:5;20624:17;;20665:1;20660;:6;;20652:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20716:1;20709:8;;;20546:179;;;;:::o;35908:120::-;35452:8;:6;:8::i;:::-;35444:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35977:5:::1;35967:7;;:15;;;;;;;;;;;;;;;;;;35998:22;36007:12;:10;:12::i;:::-;35998:22;;;;;;;;;;;;;;;;;;;;35908:120::o:0;35649:118::-;35175:8;:6;:8::i;:::-;35174:9;35166:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35719:4:::1;35709:7;;:14;;;;;;;;;;;;;;;;;;35739:20;35746:12;:10;:12::i;:::-;35739:20;;;;;;;;;;;;;;;;;;;;35649:118::o:0;7944:158::-;8018:7;8069:22;8073:3;:10;;8085:5;8069:3;:22::i;:::-;8061:31;;8038:56;;7944:158;;;;:::o;7230:167::-;7310:4;7334:55;7344:3;:10;;7380:5;7364:23;;7356:32;;7334:9;:55::i;:::-;7327:62;;7230:167;;;;:::o;39697:205::-;39798:96;39818:5;39848:27;;;39877:4;39883:2;39887:5;39825:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39798:19;:96::i;:::-;39697:205;;;;:::o;50581:378::-;50684:1;50665:21;;:7;:21;;;;50657:65;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50735:49;50764:1;50768:7;50777:6;50735:20;:49::i;:::-;50812:24;50829:6;50812:12;;:16;;:24;;;;:::i;:::-;50797:12;:39;;;;50868:30;50891:6;50868:9;:18;50878:7;50868:18;;;;;;;;;;;;;;;;:22;;:30;;;;:::i;:::-;50847:9;:18;50857:7;50847:18;;;;;;;;;;;;;;;:51;;;;50935:7;50914:37;;50931:1;50914:37;;;50944:6;50914:37;;;;;;;;;;;;;;;;;;50581:378;;:::o;7483:117::-;7546:7;7573:19;7581:3;:10;;7573:7;:19::i;:::-;7566:26;;7483:117;;;:::o;41817:761::-;42241:23;42267:69;42295:4;42267:69;;;;;;;;;;;;;;;;;42275:5;42267:27;;;;:69;;;;;:::i;:::-;42241:95;;42371:1;42351:10;:17;:21;42347:224;;;42493:10;42482:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42474:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42347:224;41817:761;;;:::o;1722:414::-;1785:4;1807:21;1817:3;1822:5;1807:9;:21::i;:::-;1802:327;;1845:3;:11;;1862:5;1845:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2028:3;:11;;:18;;;;2006:3;:12;;:19;2019:5;2006:19;;;;;;;;;;;:40;;;;2068:4;2061:11;;;;1802:327;2112:5;2105:12;;1722:414;;;;;:::o;14460:530::-;14587:12;14645:5;14620:21;:30;;14612:81;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14712:18;14723:6;14712:10;:18::i;:::-;14704:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14838:12;14852:23;14879:6;:11;;14899:5;14907:4;14879:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14837:75;;;;14930:52;14948:7;14957:10;14969:12;14930:17;:52::i;:::-;14923:59;;;;14460:530;;;;;;:::o;63188:378::-;63259:1;63249:7;:11;63245:314;;;63277:16;63296:6;:4;:6::i;:::-;63277:25;;63317:13;63333:3;63317:19;;63411:7;63355:9;:19;;;63383:4;63398:8;63355:53;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:63;63351:157;;;63439:53;63469:8;63488:2;63439:9;:21;;;;:53;;;;;:::i;:::-;63351:157;63522:8;:16;;;63539:7;63522:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63245:314;;;63188:378;:::o;53527:92::-;;;;:::o;6986:158::-;7059:4;7083:53;7091:3;:10;;7127:5;7111:23;;7103:32;;7083:7;:53::i;:::-;7076:60;;6986:158;;;;:::o;4610:204::-;4677:7;4726:5;4705:3;:11;;:18;;;;:26;4697:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4788:3;:11;;4800:5;4788:18;;;;;;;;;;;;;;;;4781:25;;4610:204;;;;:::o;3942:129::-;4015:4;4062:1;4039:3;:12;;:19;4052:5;4039:19;;;;;;;;;;;;:24;;4032:31;;3942:129;;;;:::o;4157:109::-;4213:7;4240:3;:11;;:18;;;;4233:25;;4157:109;;;:::o;17000:742::-;17115:12;17144:7;17140:595;;;17175:10;17168:17;;;;17140:595;17309:1;17289:10;:17;:21;17285:439;;;17552:10;17546:17;17613:15;17600:10;17596:2;17592:19;17585:44;17500:148;17695:12;17688:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17000:742;;;;;;:::o;2312:1544::-;2378:4;2496:18;2517:3;:12;;:19;2530:5;2517:19;;;;;;;;;;;;2496:40;;2567:1;2553:10;:15;2549:1300;;2915:21;2952:1;2939:10;:14;2915:38;;2968:17;3009:1;2988:3;:11;;:18;;;;:22;2968:42;;3255:17;3275:3;:11;;3287:9;3275:22;;;;;;;;;;;;;;;;3255:42;;3421:9;3392:3;:11;;3404:13;3392:26;;;;;;;;;;;;;;;:38;;;;3540:1;3524:13;:17;3498:3;:12;;:23;3511:9;3498:23;;;;;;;;;;;:43;;;;3650:3;:11;;:17;;;;;;;;;;;;;;;;;;;;;;;;3745:3;:12;;:19;3758:5;3745:19;;;;;;;;;;;3738:26;;;3788:4;3781:11;;;;;;;;2549:1300;3832:5;3825:12;;;2312:1544;;;;;:::o

ipfs://57b3cf38bb34c64f617eb50414c111f46f4d3024665a3084c3466d92d0334bb9