Contract 0x7c36c64811219cf9b797c5d9b264d9e7cdade7a4

/**
 *Submitted for verification at FtmScan.com on 2021-10-12
*/

// SPDX-License-Identifier: MIT

//https://t.me/darkmatterdefi
//File: @openzeppelin/contracts/contracts/GSN/Context.sol

pragma solidity ^0.6.0;

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

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

pragma solidity ^0.6.0;

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

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

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

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

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

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

//File: @openzeppelin/contracts/contracts/token/ERC20/IERC20.sol
pragma solidity ^0.6.0;
/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of DarkMatters in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves `amount` DarkMatters 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 DarkMatters 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 DarkMatters.
     *
     * 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` DarkMatters 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` DarkMatters 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/contracts/math/SafeMath.sol

pragma solidity ^0.6.0;
/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

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

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

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

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

        return c;
    }

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

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

        return c;
    }

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

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

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

pragma solidity ^0.6.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) {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly {codehash := extcodehash(account)}
        return (codehash != accountHash && codehash != 0x0);
    }

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

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

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

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

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

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

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

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{value : weiValue}(data);
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}
//File: @openzeppelin/contracts/contracts/token/ERC20/ERC20.sol

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

    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20};
     *
     * Requirements:
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s DarkMatters 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 DarkMatters `amount` from `sender` to `recipient`.
     *
     * This is internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic DarkMatter 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");

        _beforeDarkMatterTransfer(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` DarkMatters 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");

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

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

    /**
     * @dev Destroys `amount` DarkMatters 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` DarkMatters.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeDarkMatterTransfer(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 DarkMatters.
     *
     * This is 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 DarkMatter contracts will not expect
     * {decimals} to ever change, and may work incorrectly if it does.
     */
    function _setupDecimals(uint8 decimals_) internal {
        _decimals = decimals_;
    }

    /**
     * @dev Hook that is called before any transfer of DarkMatters. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s DarkMatters
     * will be to transferred to `to`.
     * - when `from` is zero, `amount` DarkMatters will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s DarkMatters 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 _beforeDarkMatterTransfer(address from, address to, uint256 amount) internal virtual {}
}




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

pragma solidity ^0.6.0;

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

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

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

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

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

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

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

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

            bytes32 lastvalue = set._values[lastIndex];

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

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

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

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

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

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

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

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

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

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

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

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

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


    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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

//File: @openzeppelin/contracts/utils/ReentrancyGuard.sol
pragma solidity ^0.6.0;

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

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

    uint256 private _status;

    constructor () internal {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

        _;

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


//File: @openzeppelin/contracts/token/ERC20/SafeERC20.sol
pragma solidity ^0.6.0;
 

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the DarkMatter
 * contract returns false). DarkMatters 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 `DarkMatter.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

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

    function safeTransferFrom(IERC20 DarkMatter, address from, address to, uint256 value) internal {
        _callOptionalReturn(DarkMatter, abi.encodeWithSelector(DarkMatter.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 DarkMatter, 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) || (DarkMatter.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(DarkMatter, abi.encodeWithSelector(DarkMatter.approve.selector, spender, value));
    }

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

    function safeDecreaseAllowance(IERC20 DarkMatter, address spender, uint256 value) internal {
        uint256 newAllowance = DarkMatter.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
        _callOptionalReturn(DarkMatter, abi.encodeWithSelector(DarkMatter.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 DarkMatter The DarkMatter targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 DarkMatter, 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(DarkMatter).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

//File: @openzeppelin/contracts/utils/Pausable.sol
pragma solidity ^0.6.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.
 */
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 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: contracts/Token/DarkMatter.sol

pragma experimental ABIEncoderV2;

abstract contract DelegateERC20 is ERC20 {
    // @notice A record of each accounts delegate
    mapping(address => address) internal _delegates;

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

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

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

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

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

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

    // support delegates mint
    function _mint(address account, uint256 amount) internal virtual override {
        super._mint(account, amount);

        // add delegates to the minter
        _moveDelegates(address(0), _delegates[account], amount);
    }

    function _transfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal virtual override {
        super._transfer(sender, recipient, amount);
        _moveDelegates(_delegates[sender], _delegates[recipient], amount);
    }

    /**
     * @notice Delegate votes from `msg.sender` to `delegatee`
     * @param delegatee The address to delegate votes to
     */
    function delegate(address delegatee) external {
        return _delegate(msg.sender, delegatee);
    }

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

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

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

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

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

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

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

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

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

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

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

        _moveDelegates(currentDelegate, delegatee, delegatorBalance);

        emit DelegateChanged(delegator, currentDelegate, delegatee);
    }

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

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

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

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

        emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
    }

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

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

        return chainId;
    }

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

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

// deflationary mechanism
interface DeflationController {
    function checkDeflation(
        address origin,
        address caller,
        address from,
        address recipient,
        uint256 amount
    ) external view returns (uint256);
}

// 𝓓𝓪𝓻𝓴  𝓜𝓪𝓽𝓽𝓮𝓻

contract DarkMatter is DelegateERC20, Pausable, Ownable {
    uint256 private constant _initialSupply = 9350000 * 1e18; // initial supply  minted 10.000.000 DMD (650k is minted for presale.)
    uint256 private constant _maxSupply = 85000000 * 1e18; // the maxSupply is 85.000.000 DMD
    uint256 private _burnTotal;

    address public deflationController;
    address public MasterChef;
    address public lockliquidity;
    address public presale;

    event SetDeflationController(address indexed _address);
    event SetMarterChef(address indexed _address);
    event Setlockliquidity(address indexed _address);

    using EnumerableSet for EnumerableSet.AddressSet;
    EnumerableSet.AddressSet private _minters;

    constructor() public ERC20("DarkMatter", "DMD") {
        _pause();
        _mint(msg.sender, _initialSupply);
    }

    function mint(address _to, uint256 _amount)
        public
        onlyMinter
        returns (bool)
    {
        if (_amount.add(totalSupply()) > _maxSupply) {
            // mint with max supply ---> only 85.000.000 DMD
            return false;
        }
        _mint(_to, _amount);
        return true;
    }

    function getinitialSupply() external pure returns (uint256) {
        return _initialSupply;
    }

    function getMaxSupply() external pure returns (uint256) {
        return _maxSupply;
    }

    function burn(uint256 _amount) external {
        _burn(address(msg.sender), _amount);
        _burnTotal = _burnTotal + _amount;
    }

    function burnTotal() public view returns (uint256) {
        return _burnTotal;
    }

    function setMasterChef(address _address) public onlyOwner {
        //Masterchef contract address.

        MasterChef = _address;
    }

    function setlockliquidity(address _address) public onlyOwner {
        //address where liquidity will be locked.

        lockliquidity = _address;
    }

    function transfer(address recipient, uint256 amount)
        public
        override
        whenNotPaused
        returns (bool)
    {
        uint256 toBurn = 0;

        if (address(0) != deflationController && amount > 0)
            toBurn = DeflationController(deflationController).checkDeflation(
                tx.origin,
                _msgSender(),
                _msgSender(),
                recipient,
                amount
            );

        if (toBurn > 0 && toBurn < amount) {
            amount = amount.sub(toBurn);
            _burn(_msgSender(), toBurn);
        }

        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    function setDeflationController(address _address) external onlyOwner {
        // deflation controller contract address.

        deflationController = _address;
    }

    /**
     * @dev See {ERC20-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 override whenNotPaused returns (bool) {
        uint256 toBurn = 0;

        if (address(0) != deflationController && amount > 0)
            toBurn = DeflationController(deflationController).checkDeflation(
                tx.origin,
                _msgSender(),
                sender,
                recipient,
                amount
            );

        if (toBurn > 0 && toBurn < amount) {
            amount = amount.sub(toBurn);
            _burn(sender, toBurn);
        }

        _transfer(sender, recipient, amount);
        _approve(
            sender,
            _msgSender(),
            allowance(sender, _msgSender()).sub(
                amount,
                "ERC20: transfer amount exceeds allowance"
            )
        );
        return true;
    }

    function addMinter(address _addMinter) public onlyOwner returns (bool) {
        require(
            _addMinter != address(0),
            "DarkMatter: _addMinter is the zero address"
        );
        return EnumerableSet.add(_minters, _addMinter);
    }

    function removeMinter(address _removeMinter)
        public
        onlyOwner
        returns (bool)
    {
        require(
            _removeMinter != address(0),
            "DarkMatter: _removeMinter is the zero address"
        );
        return EnumerableSet.remove(_minters, _removeMinter);
    }

    function getMinterLength() public view returns (uint256) {
        return EnumerableSet.length(_minters);
    }

    function isMinter(address account) public view returns (bool) {
        return EnumerableSet.contains(_minters, account);
    }

    function getMinter(uint256 _index) public view onlyOwner returns (address) {
        require(
            _index <= getMinterLength() - 1,
            "DarkMatter: index out of bounds"
        );
        return EnumerableSet.at(_minters, _index);
    }

    modifier onlyMinter() {
        require(isMinter(msg.sender), "caller is not the minter");
        _;
    }

    //warning
    //The contract pause function will only be activated during the presale (why? "Some smart guy" could add the liquidity first than us giving a higher or lower price).
    // the owner of the token will be the Timelock and this function will not should be used at no time after the presale.

    function setPresale(address _presale) external onlyOwner {
        presale = _presale;
    }

    function unpause() external {
        require(msg.sender == presale, "DarkMatter: !presale");
        _unpause();
    }
}


pragma solidity ^0.6.12;

interface IMasterChef {
    function deposit(uint256 _pid, uint256 _amount) external;
    function withdraw(uint256 _pid, uint256 _amount) external;
    function enterStaking(uint256 _amount) external;
    function leaveStaking(uint256 _amount) external;
    function pendingDMD(uint256 _pid, address _user) external view returns (uint256);
    function userInfo(uint256 _pid, address _user) external view returns (uint256, uint256);
    function emergencyWithdraw(uint256 _pid) external;

}   

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

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

    // Info of each pool.
    struct PoolInfo {
        IERC20 lpToken;           // Address of LP token contract.
        uint256 allocPoint;       // How many allocation points assigned to this pool. DMDs to distribute per block.
        uint256 lastRewardTime;  // Last block number that DMDs distribution occurs.
        uint256 accDMDPerShare;   // Accumulated DMDs per share, times 1e12. See below.
        uint16 depositFeeBP;      // Deposit fee in basis points
    }

    // The DMD TOKEN!
    DarkMatter public DMD;
    // Dev address.
    address public dev_address;
    // DMD tokens created per block.
    uint256 public DMDPerSecond;
    // Bonus muliplier for early DMD makers.
    uint256 public constant BONUS_MULTIPLIER = 1;
    // Deposit Fee address
    address public feeAddress;
    // Info of each pool.
    PoolInfo[] public poolInfo;
    // Info of each user that stakes LP tokens.
    mapping(uint256 => mapping(address => UserInfo)) public userInfo;
    // Total allocation points. Must be the sum of all allocation points in all pools.
    uint256 public totalAllocPoint = 0;
    //a maximum of 2 per second is set.
    uint256 public constant maxDMDPerSecond = 2e18;
    // Timestamp startTime.
    uint256 public startTime;

    // events 
    event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
    event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
    event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
    event SetFeeAddress(address indexed user, address indexed newAddress);
    event Setdev_address(address indexed user, address indexed newAddress);
    

    constructor(
        DarkMatter _DMD,
        uint256 _DMDPerSecond,
        uint256 _startTime
    ) public {
        DMD = _DMD;
        dev_address = msg.sender;
        feeAddress = msg.sender;
        DMDPerSecond = _DMDPerSecond;
        startTime = _startTime;
   
        // staking pool
        poolInfo.push(PoolInfo({
            lpToken: _DMD,
            allocPoint: 1000,
            lastRewardTime: startTime,
            accDMDPerShare: 0,
            depositFeeBP: 0
        }));

        totalAllocPoint = 1000;

    }

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

    mapping(IERC20 => bool) public poolExistence;
    modifier nonDuplicated(IERC20 _lpToken) {
        require(poolExistence[_lpToken] == false, "nonDuplicated: duplicated");
        _;
    }

    // Add a new lp to the pool. Can only be called by the owner.
    function add(uint256 _allocPoint, IERC20 _lpToken, uint16 _depositFeeBP, bool _withUpdate) public onlyOwner nonDuplicated(_lpToken) {
        // deposit fee can't excess more than 10%
        require(_depositFeeBP <= 1000, "add: invalid deposit fee basis points");
        if (_withUpdate) {
            massUpdatePools();
        }
        uint256 lastRewardTime = block.timestamp > startTime ? block.timestamp : startTime;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        poolExistence[_lpToken] = true;
        poolInfo.push(PoolInfo({
        lpToken : _lpToken,
        allocPoint : _allocPoint,
        lastRewardTime : lastRewardTime,
        accDMDPerShare : 0,
        depositFeeBP : _depositFeeBP
        }));
         
    }

    // Update the given pool's DMD allocation point and deposit fee. Can only be called by the owner.
    function set(uint256 _pid, uint256 _allocPoint, uint16 _depositFeeBP, bool _withUpdate) public onlyOwner {
        require(_depositFeeBP <= 1000, "set: invalid deposit fee basis points"); // 1000 is 10% 
        if (_withUpdate) {
            massUpdatePools();
        }
        totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
        poolInfo[_pid].allocPoint = _allocPoint;
        poolInfo[_pid].depositFeeBP = _depositFeeBP;
   
    }
  
    // Return reward multiplier over the given _from to _to block.
    function getMultiplier(uint256 _from, uint256 _to) public pure returns (uint256) {
        return _to.sub(_from).mul(BONUS_MULTIPLIER);
    }

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

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

    // Update reward variables of the given pool to be up-to-date.
    function updatePool(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        if (block.timestamp <=  pool.lastRewardTime) {
            return;
        }
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (lpSupply == 0 || pool.allocPoint == 0) {
             pool.lastRewardTime = block.timestamp;
            return;
        }
        uint256 multiplier = getMultiplier( pool.lastRewardTime, block.timestamp);
        uint256 DMDReward = multiplier.mul(DMDPerSecond).mul(pool.allocPoint).div(totalAllocPoint);
        DMD.mint(dev_address, DMDReward.div(10));
        DMD.mint(address(this), DMDReward);
        pool.accDMDPerShare = pool.accDMDPerShare.add(DMDReward.mul(1e12).div(lpSupply));
         pool.lastRewardTime = block.timestamp;
    }

    // Deposit LP tokens to MasterChef for DMD allocation.
    function deposit(uint256 _pid, uint256 _amount) public nonReentrant {
        require (_pid != 0, 'deposit DMD by staking');
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        updatePool(_pid);
        if (user.amount > 0) {
            uint256 pending = user.amount.mul(pool.accDMDPerShare).div(1e12).sub(user.rewardDebt);
            if (pending > 0) {
                safeDMDTransfer(msg.sender, pending);
            }
        }
          if (_amount > 0) {
            uint256 balanceBefore = pool.lpToken.balanceOf(address(this));
            pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
            _amount = pool.lpToken.balanceOf(address(this)) - balanceBefore;
        
            if (pool.depositFeeBP > 0) {
                uint256 depositFee = _amount.mul(pool.depositFeeBP).div(10000);
                pool.lpToken.safeTransfer(feeAddress, depositFee);
                user.amount = user.amount.add(_amount).sub(depositFee);
            } else {
                user.amount = user.amount.add(_amount);
            }
        }
        user.rewardDebt = user.amount.mul(pool.accDMDPerShare).div(1e12);
        emit Deposit(msg.sender, _pid, _amount);
    }

    // Withdraw LP tokens from MasterChef.
    function withdraw(uint256 _pid, uint256 _amount) public nonReentrant {
        require (_pid != 0, 'withdraw DMD by unstaking');
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        require(user.amount >= _amount, "withdraw: not good");
        updatePool(_pid);
        uint256 pending = user.amount.mul(pool.accDMDPerShare).div(1e12).sub(user.rewardDebt);
        if (pending > 0) {
            safeDMDTransfer(msg.sender, pending);
        }
        if (_amount > 0) {
            user.amount = user.amount.sub(_amount);
            pool.lpToken.safeTransfer(address(msg.sender), _amount);
        }
        user.rewardDebt = user.amount.mul(pool.accDMDPerShare).div(1e12);
        emit Withdraw(msg.sender, _pid, _amount);
    }
    
     // Stake  DMD tokens to MasterChef
    
    function enterStaking(uint256 _amount) public nonReentrant  {
        PoolInfo storage pool = poolInfo[0];
        UserInfo storage user = userInfo[0][msg.sender];
        updatePool(0);
        if (user.amount > 0) {
            uint256 pending = user.amount.mul(pool.accDMDPerShare).div(1e12).sub(user.rewardDebt);
            if(pending > 0) {
                safeDMDTransfer(msg.sender, pending);
            }
        }
        if(_amount > 0) {
            pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
            user.amount = user.amount.add(_amount);
        }
        user.rewardDebt = user.amount.mul(pool.accDMDPerShare).div(1e12);
        emit Deposit(msg.sender, 0, _amount);
    }

    // Withdraw DMD tokens from STAKING.
    function leaveStaking(uint256 _amount) public nonReentrant  {
        PoolInfo storage pool = poolInfo[0];
        UserInfo storage user = userInfo[0][msg.sender];
        require(user.amount >= _amount, "withdraw: not good");
        updatePool(0);
        uint256 pending = user.amount.mul(pool.accDMDPerShare).div(1e12).sub(user.rewardDebt);
        if(pending > 0) {
            safeDMDTransfer(msg.sender, pending);
        }
        if(_amount > 0) {
            user.amount = user.amount.sub(_amount);
            pool.lpToken.safeTransfer(address(msg.sender), _amount);
        }
        user.rewardDebt = user.amount.mul(pool.accDMDPerShare).div(1e12);

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

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

    // Safe DMD transfer function, just in case if rounding error causes pool to not have enough DMDs.
    function safeDMDTransfer(address _to, uint256 _amount) internal {
        uint256 DMDBal = DMD.balanceOf(address(this));
        bool transferSuccess = false;
        if (_amount > DMDBal) {
            transferSuccess = DMD.transfer(_to, DMDBal);
        } else {
            transferSuccess = DMD.transfer(_to, _amount);
        }
        require(transferSuccess, "safeDMDTransfer: transfer failed");
    }

    // Update dev address by the previous dev.
    function dev(address _dev_address) public onlyOwner {
        require(msg.sender == dev_address, "setDev_Address: FORBIDDEN");
        require(_dev_address != address(0), "setDev_Address: ZERO");
        dev_address = _dev_address; 
        emit Setdev_address(msg.sender, _dev_address);
    }
      // Update fee address by the previous dev.
    function setFeeAddress(address _feeAddress) public onlyOwner {
        require(msg.sender == feeAddress, "setFeeAddress: FORBIDDEN");
        require(_feeAddress != address(0), "setFeeAddress: ZERO");
        feeAddress = _feeAddress;
        emit SetFeeAddress(msg.sender, _feeAddress);
    }

   // Update DMD per Second
    function setDMDPerSecond (uint256 _DMDPerSecond) public onlyOwner {
        require(_DMDPerSecond <= maxDMDPerSecond, "setDMDPerSecond: you are stupid? max 2!");
        massUpdatePools();
        DMDPerSecond = _DMDPerSecond;
    
    }
   
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract DarkMatter","name":"_DMD","type":"address"},{"internalType":"uint256","name":"_DMDPerSecond","type":"uint256"},{"internalType":"uint256","name":"_startTime","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"newAddress","type":"address"}],"name":"SetFeeAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"newAddress","type":"address"}],"name":"Setdev_address","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"BONUS_MULTIPLIER","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DMD","outputs":[{"internalType":"contract DarkMatter","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DMDPerSecond","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IERC20","name":"_lpToken","type":"address"},{"internalType":"uint16","name":"_depositFeeBP","type":"uint16"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_dev_address","type":"address"}],"name":"dev","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"dev_address","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"enterStaking","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_from","type":"uint256"},{"internalType":"uint256","name":"_to","type":"uint256"}],"name":"getMultiplier","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"leaveStaking","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxDMDPerSecond","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingDMD","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"name":"poolExistence","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"contract IERC20","name":"lpToken","type":"address"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardTime","type":"uint256"},{"internalType":"uint256","name":"accDMDPerShare","type":"uint256"},{"internalType":"uint16","name":"depositFeeBP","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"uint16","name":"_depositFeeBP","type":"uint16"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_DMDPerSecond","type":"uint256"}],"name":"setDMDPerSecond","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeAddress","type":"address"}],"name":"setFeeAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

00000000000000000000000090e892fed501ae00596448aecf998c88816e5c0f00000000000000000000000000000000000000000000000009935f581f0500000000000000000000000000000000000000000000000000000000000061659c4b

-----Decoded View---------------
Arg [0] : _DMD (address): 0x90e892fed501ae00596448aecf998c88816e5c0f
Arg [1] : _DMDPerSecond (uint256): 690000000000000000
Arg [2] : _startTime (uint256): 1634049099

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 00000000000000000000000090e892fed501ae00596448aecf998c88816e5c0f
Arg [1] : 00000000000000000000000000000000000000000000000009935f581f050000
Arg [2] : 0000000000000000000000000000000000000000000000000000000061659c4b

63645:12971:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66891:95;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;73892:731;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;65124:21;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65462:26;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;:::i;:::-;;;;;;;;65703:34;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;68910:757;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65403:25;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;73100:742;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;76366:242;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;72230:811;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;70006:813;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;74694:398;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;69750:180;;;:::i;:::-;;2799:148;;;:::i;:::-;;65867:24;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65173:26;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67261:771;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;76031:298;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;65324:44;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;75677:298;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2157:79;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;68704:143;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65544:64;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;65785:46;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66994:44;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;68143:483;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;70887:1291;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;3102:244;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;65244:27;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66891:95;66936:7;66963:8;:15;;;;66956:22;;66891:95;:::o;73892:731::-;40358:1;40964:7;;:19;;40956:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;40358:1;41097:7;:18;;;;73963:21:::1;73987:8;73996:1;73987:11;;;;;;;;;;;;;;;;;;73963:35;;74009:21;74033:8;:11;74042:1:::0;74033:11:::1;;;;;;;;;;;:23;74045:10;74033:23;;;;;;;;;;;;;;;74009:47;;74090:7;74075:4;:11;;;:22;;74067:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;74131:13;74142:1;74131:10;:13::i;:::-;74155:15;74173:67;74224:4;:15;;;74173:46;74214:4;74173:36;74189:4;:19;;;74173:4;:11;;;:15;;:36;;;;:::i;:::-;:40;;:46;;;;:::i;:::-;:50;;:67;;;;:::i;:::-;74155:85;;74264:1;74254:7;:11;74251:79;;;74282:36;74298:10;74310:7;74282:15;:36::i;:::-;74251:79;74353:1;74343:7;:11;74340:151;;;74385:24;74401:7;74385:4;:11;;;:15;;:24;;;;:::i;:::-;74371:4;:11;;:38;;;;74424:55;74458:10;74471:7;74424:4;:12;;;;;;;;;;;;:25;;;;:55;;;;;:::i;:::-;74340:151;74519:46;74560:4;74519:36;74535:4;:19;;;74519:4;:11;;;:15;;:36;;;;:::i;:::-;:40;;:46;;;;:::i;:::-;74501:4;:15;;:64;;;;74604:1;74592:10;74583:32;;;74607:7;74583:32;;;;;;:::i;:::-;;;;;;;;41128:1;;;40314::::0;41276:7;:22;;;;73892:731;:::o;65124:21::-;;;;;;;;;;;;;:::o;65462:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;65703:34::-;;;;:::o;68910:757::-;68982:7;69002:21;69026:8;69035:4;69026:14;;;;;;;;;;;;;;;;;;69002:38;;69051:21;69075:8;:14;69084:4;69075:14;;;;;;;;;;;:21;69090:5;69075:21;;;;;;;;;;;;;;;69051:45;;69107:22;69132:4;:19;;;69107:44;;69162:16;69181:4;:12;;;;;;;;;;;;:22;;;69212:4;69181:37;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;69162:56;;69252:4;:19;;;69233:15;:38;:55;;;;;69287:1;69275:8;:13;;69233:55;69229:351;;;69305:18;69326:52;69341:4;:19;;;69362:15;69326:13;:52::i;:::-;69305:73;;69393:17;69413:70;69467:15;;69413:49;69446:4;:15;;;69413:28;69428:12;;69413:10;:14;;:28;;;;:::i;:::-;:32;;:49;;;;:::i;:::-;:53;;:70;;;;:::i;:::-;69393:90;;69515:53;69534:33;69558:8;69534:19;69548:4;69534:9;:13;;:19;;;;:::i;:::-;:23;;:33;;;;:::i;:::-;69515:14;:18;;:53;;;;:::i;:::-;69498:70;;69229:351;;;69597:62;69643:4;:15;;;69597:41;69633:4;69597:31;69613:14;69597:4;:11;;;:15;;:31;;;;:::i;:::-;:35;;:41;;;;:::i;:::-;:45;;:62;;;;:::i;:::-;69590:69;;;;;;68910:757;;;;:::o;65403:25::-;;;;;;;;;;;;;:::o;73100:742::-;40358:1;40964:7;;:19;;40956:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;40358:1;41097:7;:18;;;;73171:21:::1;73195:8;73204:1;73195:11;;;;;;;;;;;;;;;;;;73171:35;;73217:21;73241:8;:11;73250:1:::0;73241:11:::1;;;;;;;;;;;:23;73253:10;73241:23;;;;;;;;;;;;;;;73217:47;;73275:13;73286:1;73275:10;:13::i;:::-;73317:1;73303:4;:11;;;:15;73299:234;;;73335:15;73353:67;73404:4;:15;;;73353:46;73394:4;73353:36;73369:4;:19;;;73353:4;:11;;;:15;;:36;;;;:::i;:::-;:40;;:46;;;;:::i;:::-;:50;;:67;;;;:::i;:::-;73335:85;;73448:1;73438:7;:11;73435:87;;;73470:36;73486:10;73498:7;73470:15;:36::i;:::-;73435:87;73299:234;;73556:1;73546:7;:11;73543:170;;;73574:74;73612:10;73633:4;73640:7;73574:4;:12;;;;;;;;;;;;:29;;;;:74;;;;;;:::i;:::-;73677:24;73693:7;73677:4;:11;;;:15;;:24;;;;:::i;:::-;73663:4;:11;;:38;;;;73543:170;73741:46;73782:4;73741:36;73757:4;:19;;;73741:4;:11;;;:15;;:36;;;;:::i;:::-;:40;;:46;;;;:::i;:::-;73723:4;:15;;:64;;;;73823:1;73811:10;73803:31;;;73826:7;73803:31;;;;;;:::i;:::-;;;;;;;;41128:1;;40314::::0;41276:7;:22;;;;73100:742;:::o;76366:242::-;2379:12;:10;:12::i;:::-;2369:22;;:6;;;;;;;;;;:22;;;2361:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;65827:4:::1;76451:13;:32;;76443:84;;;;;;;;;;;;:::i;:::-;;;;;;;;;76538:17;:15;:17::i;:::-;76581:13;76566:12;:28;;;;76366:242:::0;:::o;72230:811::-;40358:1;40964:7;;:19;;40956:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;40358:1;41097:7;:18;;;;72327:1:::1;72319:4;:9;;72310:48;;;;;;;;;;;;:::i;:::-;;;;;;;;;72369:21;72393:8;72402:4;72393:14;;;;;;;;;;;;;;;;;;72369:38;;72418:21;72442:8;:14;72451:4;72442:14;;;;;;;;;;;:26;72457:10;72442:26;;;;;;;;;;;;;;;72418:50;;72502:7;72487:4;:11;;;:22;;72479:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;72543:16;72554:4;72543:10;:16::i;:::-;72570:15;72588:67;72639:4;:15;;;72588:46;72629:4;72588:36;72604:4;:19;;;72588:4;:11;;;:15;;:36;;;;:::i;:::-;:40;;:46;;;;:::i;:::-;:50;;:67;;;;:::i;:::-;72570:85;;72680:1;72670:7;:11;72666:80;;;72698:36;72714:10;72726:7;72698:15;:36::i;:::-;72666:80;72770:1;72760:7;:11;72756:152;;;72802:24;72818:7;72802:4;:11;;;:15;;:24;;;;:::i;:::-;72788:4;:11;;:38;;;;72841:55;72875:10;72888:7;72841:4;:12;;;;;;;;;;;;:25;;;;:55;;;;;:::i;:::-;72756:152;72936:46;72977:4;72936:36;72952:4;:19;;;72936:4;:11;;;:15;;:36;;;;:::i;:::-;:40;;:46;;;;:::i;:::-;72918:4;:15;;:64;;;;73019:4;73007:10;72998:35;;;73025:7;72998:35;;;;;;:::i;:::-;;;;;;;;41128:1;;;40314::::0;41276:7;:22;;;;72230:811;;:::o;70006:813::-;70058:21;70082:8;70091:4;70082:14;;;;;;;;;;;;;;;;;;70058:38;;70131:4;:19;;;70111:15;:39;70107:78;;70167:7;;;70107:78;70195:16;70214:4;:12;;;;;;;;;;;;:22;;;70245:4;70214:37;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;70195:56;;70278:1;70266:8;:13;:37;;;;70302:1;70283:4;:15;;;:20;70266:37;70262:129;;;70343:15;70321:4;:19;;:37;;;;70373:7;;;;70262:129;70401:18;70422:52;70437:4;:19;;;70458:15;70422:13;:52::i;:::-;70401:73;;70485:17;70505:70;70559:15;;70505:49;70538:4;:15;;;70505:28;70520:12;;70505:10;:14;;:28;;;;:::i;:::-;:32;;:49;;;;:::i;:::-;:53;;:70;;;;:::i;:::-;70485:90;;70586:3;;;;;;;;;;;:8;;;70595:11;;;;;;;;;;;70608:17;70622:2;70608:9;:13;;:17;;;;:::i;:::-;70586:40;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;70637:3;;;;;;;;;;;:8;;;70654:4;70661:9;70637:34;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;70704:58;70728:33;70752:8;70728:19;70742:4;70728:9;:13;;:19;;;;:::i;:::-;:23;;:33;;;;:::i;:::-;70704:4;:19;;;:23;;:58;;;;:::i;:::-;70682:4;:19;;:80;;;;70796:15;70774:4;:19;;:37;;;;70006:813;;;;;;:::o;74694:398::-;40358:1;40964:7;;:19;;40956:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;40358:1;41097:7;:18;;;;74766:21:::1;74790:8;74799:4;74790:14;;;;;;;;;;;;;;;;;;74766:38;;74815:21;74839:8;:14;74848:4;74839:14;;;;;;;;;;;:26;74854:10;74839:26;;;;;;;;;;;;;;;74815:50;;74876:14;74893:4;:11;;;74876:28;;74929:1;74915:4;:11;;:15;;;;74959:1;74941:4;:15;;:19;;;;74971:54;75005:10;75018:6;74971:4;:12;;;;;;;;;;;;:25;;;;:54;;;;;:::i;:::-;75071:4;75059:10;75041:43;;;75077:6;75041:43;;;;;;:::i;:::-;;;;;;;;41128:1;;;40314::::0;41276:7;:22;;;;74694:398;:::o;69750:180::-;69795:14;69812:8;:15;;;;69795:32;;69843:11;69838:85;69866:6;69860:3;:12;69838:85;;;69896:15;69907:3;69896:10;:15::i;:::-;69874:5;;;;;69838:85;;;;69750:180;:::o;2799:148::-;2379:12;:10;:12::i;:::-;2369:22;;:6;;;;;;;;;;:22;;;2361:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;2906:1:::1;2869:40;;2890:6;::::0;::::1;;;;;;;;2869:40;;;;;;;;;;;;2937:1;2920:6:::0;::::1;:19;;;;;;;;;;;;;;;;;;2799:148::o:0;65867:24::-;;;;:::o;65173:26::-;;;;;;;;;;;;;:::o;67261:771::-;2379:12;:10;:12::i;:::-;2369:22;;:6;;;;;;;;;;:22;;;2361:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;67383:8:::1;67131:5;67104:32;;:13;:23;67118:8;67104:23;;;;;;;;;;;;;;;;;;;;;;;;;:32;;;67096:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;67480:4:::2;67463:13;:21;;;;67455:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;67541:11;67537:61;;;67569:17;:15;:17::i;:::-;67537:61;67608:22;67651:9;;67633:15;:27;:57;;67681:9;;67633:57;;;67663:15;67633:57;67608:82;;67719:32;67739:11;67719:15;;:19;;:32;;;;:::i;:::-;67701:15;:50;;;;67788:4;67762:13;:23;67776:8;67762:23;;;;;;;;;;;;;;;;:30;;;;;;;;;;;;;;;;;;67803:8;67817:195;;;;;;;;67847:8;67817:195;;;;;;67879:11;67817:195;;;;67918:14;67817:195;;;;67960:1;67817:195;;;;67987:13;67817:195;;;;::::0;67803:210:::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67177:1;2439::::1;67261:771:::0;;;;:::o;76031:298::-;2379:12;:10;:12::i;:::-;2369:22;;:6;;;;;;;;;;:22;;;2361:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;76125:10:::1;;;;;;;;;;;76111:24;;:10;:24;;;76103:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;76206:1;76183:25;;:11;:25;;;;76175:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;76256:11;76243:10;;:24;;;;;;;;;;;;;;;;;;76309:11;76283:38;;76297:10;76283:38;;;;;;;;;;;;76031:298:::0;:::o;65324:44::-;65367:1;65324:44;:::o;75677:298::-;2379:12;:10;:12::i;:::-;2369:22;;:6;;;;;;;;;;:22;;;2361:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;75762:11:::1;;;;;;;;;;;75748:25;;:10;:25;;;75740:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;75846:1;75822:26;;:12;:26;;;;75814:59;;;;;;;;;;;;:::i;:::-;;;;;;;;;75898:12;75884:11;;:26;;;;;;;;;;;;;;;;;;75954:12;75927:40;;75942:10;75927:40;;;;;;;;;;;;75677:298:::0;:::o;2157:79::-;2195:7;2222:6;;;;;;;;;;;2215:13;;2157:79;:::o;68704:143::-;68776:7;68803:36;65367:1;68803:14;68811:5;68803:3;:7;;:14;;;;:::i;:::-;:18;;:36;;;;:::i;:::-;68796:43;;68704:143;;;;:::o;65544:64::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;65785:46::-;65827:4;65785:46;:::o;66994:44::-;;;;;;;;;;;;;;;;;;;;;;:::o;68143:483::-;2379:12;:10;:12::i;:::-;2369:22;;:6;;;;;;;;;;:22;;;2361:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;68284:4:::1;68267:13;:21;;;;68259:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;68361:11;68357:61;;;68389:17;:15;:17::i;:::-;68357:61;68446:63;68497:11;68446:46;68466:8;68475:4;68466:14;;;;;;;;;;;;;;;;;;:25;;;68446:15;;:19;;:46;;;;:::i;:::-;:50;;:63;;;;:::i;:::-;68428:15;:81;;;;68548:11;68520:8;68529:4;68520:14;;;;;;;;;;;;;;;;;;:25;;:39;;;;68600:13;68570:8;68579:4;68570:14;;;;;;;;;;;;;;;;;;:27;;;:43;;;;;;;;;;;;;;;;;;68143:483:::0;;;;:::o;70887:1291::-;40358:1;40964:7;;:19;;40956:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;40358:1;41097:7;:18;;;;70983:1:::1;70975:4;:9;;70966:45;;;;;;;;;;;;:::i;:::-;;;;;;;;;71022:21;71046:8;71055:4;71046:14;;;;;;;;;;;;;;;;;;71022:38;;71071:21;71095:8;:14;71104:4;71095:14;;;;;;;;;;;:26;71110:10;71095:26;;;;;;;;;;;;;;;71071:50;;71132:16;71143:4;71132:10;:16::i;:::-;71177:1;71163:4;:11;;;:15;71159:235;;;71195:15;71213:67;71264:4;:15;;;71213:46;71254:4;71213:36;71229:4;:19;;;71213:4;:11;;;:15;;:36;;;;:::i;:::-;:40;;:46;;;;:::i;:::-;:50;;:67;;;;:::i;:::-;71195:85;;71309:1;71299:7;:11;71295:88;;;71331:36;71347:10;71359:7;71331:15;:36::i;:::-;71295:88;71159:235;;71420:1;71410:7;:11;71406:640;;;71438:21;71462:4;:12;;;;;;;;;;;;:22;;;71493:4;71462:37;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;71438:61;;71514:74;71552:10;71573:4;71580:7;71514:4;:12;;;;;;;;;;;;:29;;;;:74;;;;;;:::i;:::-;71653:13;71613:4;:12;;;;;;;;;;;;:22;;;71644:4;71613:37;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:53;71603:63;;71715:1;71695:4;:17;;;;;;;;;;;;:21;;;71691:344;;;71737:18;71758:41;71793:5;71758:30;71770:4;:17;;;;;;;;;;;;71758:30;;:7;:11;;:30;;;;:::i;:::-;:34;;:41;;;;:::i;:::-;71737:62;;71818:49;71844:10;;;;;;;;;;;71856;71818:4;:12;;;;;;;;;;;;:25;;;;:49;;;;;:::i;:::-;71900:40;71929:10;71900:24;71916:7;71900:4;:11;;;:15;;:24;;;;:::i;:::-;:28;;:40;;;;:::i;:::-;71886:4;:11;;:54;;;;71691:344;;;;71995:24;72011:7;71995:4;:11;;;:15;;:24;;;;:::i;:::-;71981:4;:11;;:38;;;;71691:344;71406:640;;72074:46;72115:4;72074:36;72090:4;:19;;;72074:4;:11;;;:15;;:36;;;;:::i;:::-;:40;;:46;;;;:::i;:::-;72056:4;:15;;:64;;;;72156:4;72144:10;72136:34;;;72162:7;72136:34;;;;;;:::i;:::-;;;;;;;;41128:1;;40314::::0;41276:7;:22;;;;70887:1291;;:::o;3102:244::-;2379:12;:10;:12::i;:::-;2369:22;;:6;;;;;;;;;;:22;;;2361:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;3211:1:::1;3191:22;;:8;:22;;;;3183:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;3301:8;3272:38;;3293:6;::::0;::::1;;;;;;;;3272:38;;;;;;;;;;;;3330:8;3321:6;::::0;:17:::1;;;;;;;;;;;;;;;;;;3102:244:::0;:::o;65244:27::-;;;;:::o;8474:471::-;8532:7;8782:1;8777;:6;8773:47;;;8807:1;8800:8;;;;8773:47;8832:9;8848:1;8844;:5;8832:17;;8877:1;8872;8868;:5;;;;;;:10;8860:56;;;;;;;;;;;;:::i;:::-;;;;;;;;;8936:1;8929:8;;;8474:471;;;;;:::o;9421:132::-;9479:7;9506:39;9510:1;9513;9506:39;;;;;;;;;;;;;;;;;:3;:39::i;:::-;9499:46;;9421:132;;;;:::o;7584:136::-;7642:7;7669:43;7673:1;7676;7669:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;7662:50;;7584:136;;;;:::o;75204:417::-;75279:14;75296:3;;;;;;;;;;;:13;;;75318:4;75296:28;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;75279:45;;75335:20;75388:6;75378:7;:16;75374:169;;;75429:3;;;;;;;;;;;:12;;;75442:3;75447:6;75429:25;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;75411:43;;75374:169;;;75505:3;;;;;;;;;;;:12;;;75518:3;75523:7;75505:26;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;75487:44;;75374:169;75561:15;75553:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;75204:417;;;;:::o;41978:192::-;42066:96;42086:10;42121:28;;;42151:2;42155:5;42098:63;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42066:19;:96::i;:::-;41978:192;;;:::o;7120:181::-;7178:7;7198:9;7214:1;7210;:5;7198:17;;7239:1;7234;:6;;7226:46;;;;;;;;;;;;:::i;:::-;;;;;;;;;7292:1;7285:8;;;7120:181;;;;:::o;42178:220::-;42284:106;42304:10;42339:32;;;42373:4;42379:2;42383:5;42316:73;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42284:19;:106::i;:::-;42178:220;;;;:::o;697:106::-;750:15;785:10;778:17;;697:106;:::o;10049:278::-;10135:7;10167:1;10163;:5;10170:12;10155:28;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;10194:9;10210:1;10206;:5;;;;;;10194:17;;10318:1;10311:8;;;10049:278;;;;;:::o;8023:192::-;8109:7;8142:1;8137;:6;;8145:12;8129:29;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;8169:9;8185:1;8181;:5;8169:17;;8206:1;8199:8;;;8023:192;;;;;:::o;44383:771::-;44812:23;44838:74;44871:4;44838:74;;;;;;;;;;;;;;;;;44846:10;44838:32;;;;:74;;;;;:::i;:::-;44812:100;;44947:1;44927:10;:17;:21;44923:224;;;45069:10;45058:30;;;;;;;;;;;;:::i;:::-;45050:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;44923:224;44383:771;;;:::o;15464:196::-;15567:12;15599:53;15622:6;15630:4;15636:1;15639:12;15599:22;:53::i;:::-;15592:60;;15464:196;;;;;:::o;16841:978::-;16971:12;17004:18;17015:6;17004:10;:18::i;:::-;16996:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;17130:12;17144:23;17171:6;:11;;17191:8;17201:4;17171:35;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17129:77;;;;17221:7;17217:595;;;17252:10;17245:17;;;;;;17217:595;17386:1;17366:10;:17;:21;17362:439;;;17629:10;17623:17;17690:15;17677:10;17673:2;17669:19;17662:44;17577:148;17772:12;17765:20;;;;;;;;;;;:::i;:::-;;;;;;;;16841:978;;;;;;;:::o;12351:617::-;12411:4;12673:16;12700:19;12722:66;12700:88;;;;12890:7;12878:20;12866:32;;12929:11;12917:8;:23;;:42;;;;;12956:3;12944:15;;:8;:15;;12917:42;12909:51;;;;12351:617;;;:::o;5:130:-1:-;;85:6;72:20;63:29;;97:33;124:5;97:33;:::i;:::-;57:78;;;;:::o;142:124::-;;219:6;206:20;197:29;;231:30;255:5;231:30;:::i;:::-;191:75;;;;:::o;273:128::-;;354:6;348:13;339:22;;366:30;390:5;366:30;:::i;:::-;333:68;;;;:::o;408:158::-;;502:6;489:20;480:29;;514:47;555:5;514:47;:::i;:::-;474:92;;;;:::o;573:128::-;;652:6;639:20;630:29;;664:32;690:5;664:32;:::i;:::-;624:77;;;;:::o;708:130::-;;788:6;775:20;766:29;;800:33;827:5;800:33;:::i;:::-;760:78;;;;:::o;845:134::-;;929:6;923:13;914:22;;941:33;968:5;941:33;:::i;:::-;908:71;;;;:::o;986:241::-;;1090:2;1078:9;1069:7;1065:23;1061:32;1058:2;;;1106:1;1103;1096:12;1058:2;1141:1;1158:53;1203:7;1194:6;1183:9;1179:22;1158:53;:::i;:::-;1148:63;;1120:97;1052:175;;;;:::o;1234:257::-;;1346:2;1334:9;1325:7;1321:23;1317:32;1314:2;;;1362:1;1359;1352:12;1314:2;1397:1;1414:61;1467:7;1458:6;1447:9;1443:22;1414:61;:::i;:::-;1404:71;;1376:105;1308:183;;;;:::o;1498:269::-;;1616:2;1604:9;1595:7;1591:23;1587:32;1584:2;;;1632:1;1629;1622:12;1584:2;1667:1;1684:67;1743:7;1734:6;1723:9;1719:22;1684:67;:::i;:::-;1674:77;;1646:111;1578:189;;;;:::o;1774:241::-;;1878:2;1866:9;1857:7;1853:23;1849:32;1846:2;;;1894:1;1891;1884:12;1846:2;1929:1;1946:53;1991:7;1982:6;1971:9;1967:22;1946:53;:::i;:::-;1936:63;;1908:97;1840:175;;;;:::o;2022:263::-;;2137:2;2125:9;2116:7;2112:23;2108:32;2105:2;;;2153:1;2150;2143:12;2105:2;2188:1;2205:64;2261:7;2252:6;2241:9;2237:22;2205:64;:::i;:::-;2195:74;;2167:108;2099:186;;;;:::o;2292:366::-;;;2413:2;2401:9;2392:7;2388:23;2384:32;2381:2;;;2429:1;2426;2419:12;2381:2;2464:1;2481:53;2526:7;2517:6;2506:9;2502:22;2481:53;:::i;:::-;2471:63;;2443:97;2571:2;2589:53;2634:7;2625:6;2614:9;2610:22;2589:53;:::i;:::-;2579:63;;2550:98;2375:283;;;;;:::o;2665:637::-;;;;;2830:3;2818:9;2809:7;2805:23;2801:33;2798:2;;;2847:1;2844;2837:12;2798:2;2882:1;2899:53;2944:7;2935:6;2924:9;2920:22;2899:53;:::i;:::-;2889:63;;2861:97;2989:2;3007:67;3066:7;3057:6;3046:9;3042:22;3007:67;:::i;:::-;2997:77;;2968:112;3111:2;3129:52;3173:7;3164:6;3153:9;3149:22;3129:52;:::i;:::-;3119:62;;3090:97;3218:2;3236:50;3278:7;3269:6;3258:9;3254:22;3236:50;:::i;:::-;3226:60;;3197:95;2792:510;;;;;;;:::o;3309:366::-;;;3430:2;3418:9;3409:7;3405:23;3401:32;3398:2;;;3446:1;3443;3436:12;3398:2;3481:1;3498:53;3543:7;3534:6;3523:9;3519:22;3498:53;:::i;:::-;3488:63;;3460:97;3588:2;3606:53;3651:7;3642:6;3631:9;3627:22;3606:53;:::i;:::-;3596:63;;3567:98;3392:283;;;;;:::o;3682:609::-;;;;;3833:3;3821:9;3812:7;3808:23;3804:33;3801:2;;;3850:1;3847;3840:12;3801:2;3885:1;3902:53;3947:7;3938:6;3927:9;3923:22;3902:53;:::i;:::-;3892:63;;3864:97;3992:2;4010:53;4055:7;4046:6;4035:9;4031:22;4010:53;:::i;:::-;4000:63;;3971:98;4100:2;4118:52;4162:7;4153:6;4142:9;4138:22;4118:52;:::i;:::-;4108:62;;4079:97;4207:2;4225:50;4267:7;4258:6;4247:9;4243:22;4225:50;:::i;:::-;4215:60;;4186:95;3795:496;;;;;;;:::o;4298:113::-;4381:24;4399:5;4381:24;:::i;:::-;4376:3;4369:37;4363:48;;:::o;4418:104::-;4495:21;4510:5;4495:21;:::i;:::-;4490:3;4483:34;4477:45;;:::o;4529:356::-;;4657:38;4689:5;4657:38;:::i;:::-;4707:88;4788:6;4783:3;4707:88;:::i;:::-;4700:95;;4800:52;4845:6;4840:3;4833:4;4826:5;4822:16;4800:52;:::i;:::-;4873:6;4868:3;4864:16;4857:23;;4637:248;;;;;:::o;4892:164::-;4994:56;5044:5;4994:56;:::i;:::-;4989:3;4982:69;4976:80;;:::o;5063:154::-;5160:51;5205:5;5160:51;:::i;:::-;5155:3;5148:64;5142:75;;:::o;5224:347::-;;5336:39;5369:5;5336:39;:::i;:::-;5387:71;5451:6;5446:3;5387:71;:::i;:::-;5380:78;;5463:52;5508:6;5503:3;5496:4;5489:5;5485:16;5463:52;:::i;:::-;5536:29;5558:6;5536:29;:::i;:::-;5531:3;5527:39;5520:46;;5316:255;;;;;:::o;5579:374::-;;5739:67;5803:2;5798:3;5739:67;:::i;:::-;5732:74;;5839:34;5835:1;5830:3;5826:11;5819:55;5908:7;5903:2;5898:3;5894:12;5887:29;5944:2;5939:3;5935:12;5928:19;;5725:228;;;:::o;5962:332::-;;6122:67;6186:2;6181:3;6122:67;:::i;:::-;6115:74;;6222:34;6218:1;6213:3;6209:11;6202:55;6285:2;6280:3;6276:12;6269:19;;6108:186;;;:::o;6303:375::-;;6463:67;6527:2;6522:3;6463:67;:::i;:::-;6456:74;;6563:34;6559:1;6554:3;6550:11;6543:55;6632:8;6627:2;6622:3;6618:12;6611:30;6669:2;6664:3;6660:12;6653:19;;6449:229;;;:::o;6687:327::-;;6847:67;6911:2;6906:3;6847:67;:::i;:::-;6840:74;;6947:29;6943:1;6938:3;6934:11;6927:50;7005:2;7000:3;6996:12;6989:19;;6833:181;;;:::o;7023:319::-;;7183:67;7247:2;7242:3;7183:67;:::i;:::-;7176:74;;7283:21;7279:1;7274:3;7270:11;7263:42;7333:2;7328:3;7324:12;7317:19;;7169:173;;;:::o;7351:325::-;;7511:67;7575:2;7570:3;7511:67;:::i;:::-;7504:74;;7611:27;7607:1;7602:3;7598:11;7591:48;7667:2;7662:3;7658:12;7651:19;;7497:179;;;:::o;7685:376::-;;7845:67;7909:2;7904:3;7845:67;:::i;:::-;7838:74;;7945:34;7941:1;7936:3;7932:11;7925:55;8014:9;8009:2;8004:3;8000:12;7993:31;8052:2;8047:3;8043:12;8036:19;;7831:230;;;:::o;8070:325::-;;8230:67;8294:2;8289:3;8230:67;:::i;:::-;8223:74;;8330:27;8326:1;8321:3;8317:11;8310:48;8386:2;8381:3;8377:12;8370:19;;8216:179;;;:::o;8404:322::-;;8564:67;8628:2;8623:3;8564:67;:::i;:::-;8557:74;;8664:24;8660:1;8655:3;8651:11;8644:45;8717:2;8712:3;8708:12;8701:19;;8550:176;;;:::o;8735:370::-;;8895:67;8959:2;8954:3;8895:67;:::i;:::-;8888:74;;8995:34;8991:1;8986:3;8982:11;8975:55;9064:3;9059:2;9054:3;9050:12;9043:25;9096:2;9091:3;9087:12;9080:19;;8881:224;;;:::o;9114:374::-;;9274:67;9338:2;9333:3;9274:67;:::i;:::-;9267:74;;9374:34;9370:1;9365:3;9361:11;9354:55;9443:7;9438:2;9433:3;9429:12;9422:29;9479:2;9474:3;9470:12;9463:19;;9260:228;;;:::o;9497:332::-;;9657:67;9721:2;9716:3;9657:67;:::i;:::-;9650:74;;9757:34;9753:1;9748:3;9744:11;9737:55;9820:2;9815:3;9811:12;9804:19;;9643:186;;;:::o;9838:320::-;;9998:67;10062:2;10057:3;9998:67;:::i;:::-;9991:74;;10098:22;10094:1;10089:3;10085:11;10078:43;10149:2;10144:3;10140:12;10133:19;;9984:174;;;:::o;10167:329::-;;10327:67;10391:2;10386:3;10327:67;:::i;:::-;10320:74;;10427:31;10423:1;10418:3;10414:11;10407:52;10487:2;10482:3;10478:12;10471:19;;10313:183;;;:::o;10505:318::-;;10665:67;10729:2;10724:3;10665:67;:::i;:::-;10658:74;;10765:20;10761:1;10756:3;10752:11;10745:41;10814:2;10809:3;10805:12;10798:19;;10651:172;;;:::o;10832:325::-;;10992:67;11056:2;11051:3;10992:67;:::i;:::-;10985:74;;11092:27;11088:1;11083:3;11079:11;11072:48;11148:2;11143:3;11139:12;11132:19;;10978:179;;;:::o;11166:324::-;;11326:67;11390:2;11385:3;11326:67;:::i;:::-;11319:74;;11426:26;11422:1;11417:3;11413:11;11406:47;11481:2;11476:3;11472:12;11465:19;;11312:178;;;:::o;11499:379::-;;11659:67;11723:2;11718:3;11659:67;:::i;:::-;11652:74;;11759:34;11755:1;11750:3;11746:11;11739:55;11828:12;11823:2;11818:3;11814:12;11807:34;11869:2;11864:3;11860:12;11853:19;;11645:233;;;:::o;11887:331::-;;12047:67;12111:2;12106:3;12047:67;:::i;:::-;12040:74;;12147:33;12143:1;12138:3;12134:11;12127:54;12209:2;12204:3;12200:12;12193:19;;12033:185;;;:::o;12226:110::-;12307:23;12324:5;12307:23;:::i;:::-;12302:3;12295:36;12289:47;;:::o;12343:113::-;12426:24;12444:5;12426:24;:::i;:::-;12421:3;12414:37;12408:48;;:::o;12463:271::-;;12616:93;12705:3;12696:6;12616:93;:::i;:::-;12609:100;;12726:3;12719:10;;12597:137;;;;:::o;12741:222::-;;12868:2;12857:9;12853:18;12845:26;;12882:71;12950:1;12939:9;12935:17;12926:6;12882:71;:::i;:::-;12839:124;;;;:::o;12970:444::-;;13153:2;13142:9;13138:18;13130:26;;13167:71;13235:1;13224:9;13220:17;13211:6;13167:71;:::i;:::-;13249:72;13317:2;13306:9;13302:18;13293:6;13249:72;:::i;:::-;13332;13400:2;13389:9;13385:18;13376:6;13332:72;:::i;:::-;13124:290;;;;;;:::o;13421:333::-;;13576:2;13565:9;13561:18;13553:26;;13590:71;13658:1;13647:9;13643:17;13634:6;13590:71;:::i;:::-;13672:72;13740:2;13729:9;13725:18;13716:6;13672:72;:::i;:::-;13547:207;;;;;:::o;13761:210::-;;13882:2;13871:9;13867:18;13859:26;;13896:65;13958:1;13947:9;13943:17;13934:6;13896:65;:::i;:::-;13853:118;;;;:::o;13978:260::-;;14124:2;14113:9;14109:18;14101:26;;14138:90;14225:1;14214:9;14210:17;14201:6;14138:90;:::i;:::-;14095:143;;;;:::o;14245:692::-;;14496:3;14485:9;14481:19;14473:27;;14511:85;14593:1;14582:9;14578:17;14569:6;14511:85;:::i;:::-;14607:72;14675:2;14664:9;14660:18;14651:6;14607:72;:::i;:::-;14690;14758:2;14747:9;14743:18;14734:6;14690:72;:::i;:::-;14773;14841:2;14830:9;14826:18;14817:6;14773:72;:::i;:::-;14856:71;14922:3;14911:9;14907:19;14898:6;14856:71;:::i;:::-;14467:470;;;;;;;;:::o;14944:310::-;;15091:2;15080:9;15076:18;15068:26;;15141:9;15135:4;15131:20;15127:1;15116:9;15112:17;15105:47;15166:78;15239:4;15230:6;15166:78;:::i;:::-;15158:86;;15062:192;;;;:::o;15261:416::-;;15461:2;15450:9;15446:18;15438:26;;15511:9;15505:4;15501:20;15497:1;15486:9;15482:17;15475:47;15536:131;15662:4;15536:131;:::i;:::-;15528:139;;15432:245;;;:::o;15684:416::-;;15884:2;15873:9;15869:18;15861:26;;15934:9;15928:4;15924:20;15920:1;15909:9;15905:17;15898:47;15959:131;16085:4;15959:131;:::i;:::-;15951:139;;15855:245;;;:::o;16107:416::-;;16307:2;16296:9;16292:18;16284:26;;16357:9;16351:4;16347:20;16343:1;16332:9;16328:17;16321:47;16382:131;16508:4;16382:131;:::i;:::-;16374:139;;16278:245;;;:::o;16530:416::-;;16730:2;16719:9;16715:18;16707:26;;16780:9;16774:4;16770:20;16766:1;16755:9;16751:17;16744:47;16805:131;16931:4;16805:131;:::i;:::-;16797:139;;16701:245;;;:::o;16953:416::-;;17153:2;17142:9;17138:18;17130:26;;17203:9;17197:4;17193:20;17189:1;17178:9;17174:17;17167:47;17228:131;17354:4;17228:131;:::i;:::-;17220:139;;17124:245;;;:::o;17376:416::-;;17576:2;17565:9;17561:18;17553:26;;17626:9;17620:4;17616:20;17612:1;17601:9;17597:17;17590:47;17651:131;17777:4;17651:131;:::i;:::-;17643:139;;17547:245;;;:::o;17799:416::-;;17999:2;17988:9;17984:18;17976:26;;18049:9;18043:4;18039:20;18035:1;18024:9;18020:17;18013:47;18074:131;18200:4;18074:131;:::i;:::-;18066:139;;17970:245;;;:::o;18222:416::-;;18422:2;18411:9;18407:18;18399:26;;18472:9;18466:4;18462:20;18458:1;18447:9;18443:17;18436:47;18497:131;18623:4;18497:131;:::i;:::-;18489:139;;18393:245;;;:::o;18645:416::-;;18845:2;18834:9;18830:18;18822:26;;18895:9;18889:4;18885:20;18881:1;18870:9;18866:17;18859:47;18920:131;19046:4;18920:131;:::i;:::-;18912:139;;18816:245;;;:::o;19068:416::-;;19268:2;19257:9;19253:18;19245:26;;19318:9;19312:4;19308:20;19304:1;19293:9;19289:17;19282:47;19343:131;19469:4;19343:131;:::i;:::-;19335:139;;19239:245;;;:::o;19491:416::-;;19691:2;19680:9;19676:18;19668:26;;19741:9;19735:4;19731:20;19727:1;19716:9;19712:17;19705:47;19766:131;19892:4;19766:131;:::i;:::-;19758:139;;19662:245;;;:::o;19914:416::-;;20114:2;20103:9;20099:18;20091:26;;20164:9;20158:4;20154:20;20150:1;20139:9;20135:17;20128:47;20189:131;20315:4;20189:131;:::i;:::-;20181:139;;20085:245;;;:::o;20337:416::-;;20537:2;20526:9;20522:18;20514:26;;20587:9;20581:4;20577:20;20573:1;20562:9;20558:17;20551:47;20612:131;20738:4;20612:131;:::i;:::-;20604:139;;20508:245;;;:::o;20760:416::-;;20960:2;20949:9;20945:18;20937:26;;21010:9;21004:4;21000:20;20996:1;20985:9;20981:17;20974:47;21035:131;21161:4;21035:131;:::i;:::-;21027:139;;20931:245;;;:::o;21183:416::-;;21383:2;21372:9;21368:18;21360:26;;21433:9;21427:4;21423:20;21419:1;21408:9;21404:17;21397:47;21458:131;21584:4;21458:131;:::i;:::-;21450:139;;21354:245;;;:::o;21606:416::-;;21806:2;21795:9;21791:18;21783:26;;21856:9;21850:4;21846:20;21842:1;21831:9;21827:17;21820:47;21881:131;22007:4;21881:131;:::i;:::-;21873:139;;21777:245;;;:::o;22029:416::-;;22229:2;22218:9;22214:18;22206:26;;22279:9;22273:4;22269:20;22265:1;22254:9;22250:17;22243:47;22304:131;22430:4;22304:131;:::i;:::-;22296:139;;22200:245;;;:::o;22452:416::-;;22652:2;22641:9;22637:18;22629:26;;22702:9;22696:4;22692:20;22688:1;22677:9;22673:17;22666:47;22727:131;22853:4;22727:131;:::i;:::-;22719:139;;22623:245;;;:::o;22875:416::-;;23075:2;23064:9;23060:18;23052:26;;23125:9;23119:4;23115:20;23111:1;23100:9;23096:17;23089:47;23150:131;23276:4;23150:131;:::i;:::-;23142:139;;23046:245;;;:::o;23298:222::-;;23425:2;23414:9;23410:18;23402:26;;23439:71;23507:1;23496:9;23492:17;23483:6;23439:71;:::i;:::-;23396:124;;;;:::o;23527:333::-;;23682:2;23671:9;23667:18;23659:26;;23696:71;23764:1;23753:9;23749:17;23740:6;23696:71;:::i;:::-;23778:72;23846:2;23835:9;23831:18;23822:6;23778:72;:::i;:::-;23653:207;;;;;:::o;23867:121::-;;23960:5;23954:12;23944:22;;23925:63;;;:::o;23995:122::-;;24089:5;24083:12;24073:22;;24054:63;;;:::o;24125:144::-;;24260:3;24245:18;;24238:31;;;;:::o;24278:163::-;;24393:6;24388:3;24381:19;24430:4;24425:3;24421:14;24406:29;;24374:67;;;;:::o;24449:91::-;;24511:24;24529:5;24511:24;:::i;:::-;24500:35;;24494:46;;;:::o;24547:85::-;;24620:5;24613:13;24606:21;24595:32;;24589:43;;;:::o;24639:105::-;;24715:24;24733:5;24715:24;:::i;:::-;24704:35;;24698:46;;;:::o;24751:84::-;;24823:6;24816:5;24812:18;24801:29;;24795:40;;;:::o;24842:121::-;;24915:42;24908:5;24904:54;24893:65;;24887:76;;;:::o;24970:72::-;;25032:5;25021:16;;25015:27;;;:::o;25049:159::-;;25147:56;25197:5;25147:56;:::i;:::-;25134:69;;25128:80;;;:::o;25215:127::-;;25313:24;25331:5;25313:24;:::i;:::-;25300:37;;25294:48;;;:::o;25349:149::-;;25442:51;25487:5;25442:51;:::i;:::-;25429:64;;25423:75;;;:::o;25505:122::-;;25598:24;25616:5;25598:24;:::i;:::-;25585:37;;25579:48;;;:::o;25635:268::-;25700:1;25707:101;25721:6;25718:1;25715:13;25707:101;;;25797:1;25792:3;25788:11;25782:18;25778:1;25773:3;25769:11;25762:39;25743:2;25740:1;25736:10;25731:15;;25707:101;;;25823:6;25820:1;25817:13;25814:2;;;25888:1;25879:6;25874:3;25870:16;25863:27;25814:2;25684:219;;;;:::o;25911:97::-;;25999:2;25995:7;25990:2;25983:5;25979:14;25975:28;25965:38;;25959:49;;;:::o;26016:117::-;26085:24;26103:5;26085:24;:::i;:::-;26078:5;26075:35;26065:2;;26124:1;26121;26114:12;26065:2;26059:74;:::o;26140:111::-;26206:21;26221:5;26206:21;:::i;:::-;26199:5;26196:32;26186:2;;26242:1;26239;26232:12;26186:2;26180:71;:::o;26258:145::-;26341:38;26373:5;26341:38;:::i;:::-;26334:5;26331:49;26321:2;;26394:1;26391;26384:12;26321:2;26315:88;:::o;26410:115::-;26478:23;26495:5;26478:23;:::i;:::-;26471:5;26468:34;26458:2;;26516:1;26513;26506:12;26458:2;26452:73;:::o;26532:117::-;26601:24;26619:5;26601:24;:::i;:::-;26594:5;26591:35;26581:2;;26640:1;26637;26630:12;26581:2;26575:74;:::o

ipfs://d184aaccb30072f00b03629a89231993493ef4ed8272c7651a333ac10d886d55