Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•    - function _msgSender()
•    - function _msgData()
•  contract Ownable is Context
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b, st ...
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(address target, ...
•    - function functionCallWithValue(addres ...
•    - function functionCallWithValue(addres ...
•    - function _functionCallWithValue(addre ...
•  contract ERC20 is Context, IERC20
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
•    - function increaseAllowance(address sp ...
•    - function decreaseAllowance(address sp ...
•    - function _transfer(address sender, ad ...
•    - function _mint(address account, uint2 ...
•    - function _burn(address account, uint2 ...
•    - function _approve(address owner, addr ...
•    - function _setupDecimals(uint8 decimal ...
•    - function _beforeTokenTransfer(address ...
•    - function burn(uint256 amount)
•    - function burnFrom(address account, ui ...
•  contract DuckToken is ERC20Burnabl ...
•    - function mint(address to, uint256 amo ...
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeApprove(IERC20 token, ad ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function _callOptionalReturn(IERC20 t ...
•    - function removeLiquidity(
•  contract Pool *
•    - function addPeriod(uint startingBlock ...
•    - function updatePool()
•    - function deposit(uint256 amount)
•    - function withdraw(uint256 amount)
•    - function uniWithdraw(address receiver ...
•    - function emergencyWithdraw(uint256 pi ...
•    - function getUserPendingReward(address ...
•    - function getCurrentPeriodIndex()
•    - function calculateDuckTokensForMint()
•    - function safeDuckTransfer(address to, ...
•    - function addRevenue(address _tokenAdd ...
•    - function getUserLastRevenue(address u ...
•    - function claimRevenue(address userAdd ...
•    - function safeRevenueTransfer(address ...
•    - function max(uint a, uint b)
•  contract PoolController is Ownable *
•    - function newPool(address lpToken, uin ...
•    - function addPeriod(uint poolIndex, ui ...
•    - function addRevenue(uint poolIndex, a ...
•    - function mint(address to, uint value)

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-12-21
*/

/**
 *Submitted for verification at Etherscan.io on 2020-12-16
*/

// SPDX-License-Identifier: MIT
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;
    }
}

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: node_modules\@openzeppelin\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 tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

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

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

// File: node_modules\@openzeppelin\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: node_modules\@openzeppelin\contracts\utils\Address.sol

pragma solidity ^0.6.2;

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.6.0;





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

    mapping (address => uint256) private _balances;

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

    uint256 private _totalSupply;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _beforeTokenTransfer(sender, recipient, amount);

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.6.0;

/**
 * @dev Extension of {ERC20} that allows token holders to destroy both their own
 * tokens and those that they have an allowance for, in a way that can be
 * recognized off-chain (via event analysis).
 */
abstract contract ERC20Burnable is Context, ERC20 {
    /**
     * @dev Destroys `amount` tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 amount) public virtual {
        _burn(_msgSender(), amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, deducting from the caller's
     * allowance.
     *
     * See {ERC20-_burn} and {ERC20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for ``accounts``'s tokens of at least
     * `amount`.
     */
    function burnFrom(address account, uint256 amount) public virtual {
        uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance");

        _approve(account, _msgSender(), decreasedAllowance);
        _burn(account, amount);
    }
}

contract DuckToken is ERC20Burnable, Ownable {

	uint public constant PRESALE_SUPPLY		= 20000000e18;
	uint public constant TEAM_SUPPLY 		= 10000000e18;
	uint public constant MAX_FARMING_POOL 	= 70000000e18;

	uint public currentFarmingPool;

	constructor(address presaleWallet, address teamWallet) public ERC20("DuckToken", "DLC") {
		_mint(presaleWallet, PRESALE_SUPPLY);
		_mint(teamWallet, TEAM_SUPPLY);
	}

	function mint(address to, uint256 amount) public onlyOwner {
		require(currentFarmingPool.add(amount) <= MAX_FARMING_POOL, "exceed farming amount");
		currentFarmingPool += amount; 
        _mint(to, amount);
  }
}

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

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

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

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

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

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

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

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



abstract contract IUniswapPool {
	address public token0;
	address public token1;
}

abstract contract IUniswapRouter {
	function removeLiquidity(
	    address tokenA,
	    address tokenB,
	    uint liquidity,
	    uint amountAMin,
	    uint amountBMin,
	    address to,
	    uint deadline
	) virtual external returns (uint amountA, uint amountB);
}

contract Pool {

	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 SUSHIs
		// entitled to a user but is pending to be distributed is:
		//
		//   pending reward = (user.amount * pool.accSushiPerShare) - user.rewardDebt
		//
		// Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
		//   1. The pool's `accSushiPerShare` (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 period.
	struct Period {
		uint startingBlock;
		uint blocks;
		uint farmingSupply;
		uint tokensPerBlock;
	}

	// Info of each period.
	Period[] public periods;

	// Controller address
	PoolController public controller;

	// Last block number that DUCKs distribution occurs.
	uint public lastRewardBlock;

	// The DUCK TOKEN
	ERC20Burnable public duck;

	// Address of LP token contract.
	IERC20 public lpToken;

	// Accumulated DUCKs per share, times 1e18. See below.
	uint public accDuckPerShare;

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

	IUniswapRouter public uniswapRouter = IUniswapRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);

	//Revenue part
	struct Revenue {
		address tokenAddress;
		uint totalSupply;
		uint amount;
	}

	// Array of created revenues
	Revenue[] public revenues;

	// mapping of claimed user revenues
	mapping(address => mapping(uint => bool)) revenuesClaimed;

  	event Deposit(address indexed from, uint amount);
  	event Withdraw(address indexed to, uint amount);
  	event NewPeriod(uint indexed startingBlock, uint indexed blocks, uint farmingSupply);
  	event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);

	modifier onlyController() {
		require(msg.sender == address(controller), "onlyController"); 
		_;
	}
	
	constructor(address _lpToken, uint _startingBlock, uint[] memory _blocks, uint[] memory _farmingSupplies) public {
	    require(_blocks.length > 0, "emply data");
	    require(_blocks.length == _farmingSupplies.length, "invalid data");

	    controller = PoolController(msg.sender);
	    duck = ERC20Burnable(controller.duck());
	    lpToken = IERC20(_lpToken);

	    addPeriod(_startingBlock, _blocks[0], _farmingSupplies[0]);
	    uint _bufStartingBlock = _startingBlock.add(_blocks[0]);

	    for(uint i = 1; i < _blocks.length; i++) {
	        addPeriod(_bufStartingBlock, _blocks[i], _farmingSupplies[i]);
	        _bufStartingBlock = _bufStartingBlock.add(_blocks[i]);
	    }
	    
	    IERC20(_lpToken).approve(address(uniswapRouter), uint256(-1));
	    
	    lastRewardBlock = _startingBlock;
	}
	
  // Update a pool by adding NEW period. Can only be called by the controller.
	function addPeriod(uint startingBlock, uint blocks, uint farmingSupply) public onlyController {
	    require(startingBlock >= block.number, "startingBlock should be greater than now");
	    
	    if(periods.length > 0) {
	      require(startingBlock > periods[periods.length-1].startingBlock.add(periods[periods.length-1].blocks), "two periods in the same time");
	    }

		uint tokensPerBlock = farmingSupply.div(blocks);
		Period memory newPeriod = Period({
			startingBlock: startingBlock,
			blocks: blocks.sub(1),
			farmingSupply: farmingSupply,
			tokensPerBlock: tokensPerBlock
		});

		periods.push(newPeriod);
    	emit NewPeriod(startingBlock, blocks, farmingSupply);
	}

	// Update reward variables of the given pool to be up-to-date.
	function updatePool() public {
	    if (block.number <= lastRewardBlock) {
	    	return;
	    }

	    claimRevenue(msg.sender);
	 
	    uint256 lpSupply = lpToken.balanceOf(address(this));
	    if (lpSupply == 0) {
			lastRewardBlock = block.number;
			return;
	    }
	 
	    uint256 duckReward = calculateDuckTokensForMint();
	    if (duckReward > 0) {
			controller.mint(controller.devAddress(), duckReward.mul(7).div(100));
			controller.mint(address(this), duckReward.mul(93).div(100));

			accDuckPerShare = accDuckPerShare.add(duckReward.mul(1e18).mul(93).div(100).div(lpSupply));
	    }
	    
	    lastRewardBlock = block.number;
  	}
  
	// Deposit LP tokens to Pool for DUCK allocation.
	function deposit(uint256 amount) public {
	    require(amount > 0, "amount must be more than zero");
	    UserInfo storage user = userInfo[msg.sender];
	 
	    updatePool();
	 
	    if (user.amount > 0) {
			uint256 pending = user.amount.mul(accDuckPerShare).div(1e18).sub(user.rewardDebt);
			if(pending > 0) {
				safeDuckTransfer(msg.sender, pending);
			}
	    }
	    
	    user.amount = user.amount.add(amount);
	    lpToken.safeTransferFrom(msg.sender, address(this), amount);
	    
	    user.rewardDebt = user.amount.mul(accDuckPerShare).div(1e18);
	    
	    emit Deposit(msg.sender, amount);
	}

	// Withdraw LP tokens from the Pool.
	function withdraw(uint256 amount) public {

		UserInfo storage user = userInfo[msg.sender];

		require(user.amount >= amount, "withdraw: not good");

		updatePool();

		uint256 pending = user.amount.mul(accDuckPerShare).div(1e18).sub(user.rewardDebt);
		if(pending > 0) {
			safeDuckTransfer(msg.sender, pending);
		}

		if(amount > 0) {
			// lpToken.safeTransfer(address(msg.sender), amount);
			user.amount = user.amount.sub(amount);
			uniWithdraw(msg.sender, amount);
		}
		 
		user.rewardDebt = user.amount.mul(accDuckPerShare).div(1e18);
		emit Withdraw(msg.sender, amount);
	}

  	function uniWithdraw(address receiver, uint lpTokenAmount) internal {
		IUniswapPool uniswapPool = IUniswapPool(address(lpToken));

		address token0 = uniswapPool.token0();
		address token1 = uniswapPool.token1();

		(uint amountA, uint amountB) = uniswapRouter.removeLiquidity(token0, token1, lpTokenAmount, 1, 1, address(this), block.timestamp + 100);

		bool isDuckBurned;
		bool token0Sent;
		bool token1Sent;
	    if(token0 == address(duck)) {
	        duck.burn(amountA);
	        isDuckBurned = true;
	        token0Sent = true;
	    }

	    if(token1 == address(duck)) {
	        duck.burn(amountB);
	        isDuckBurned = true;
	        token1Sent = true;
	    }
	    
	    if(!token0Sent) {
	        if(token0 == controller.ddimTokenAddress() && !isDuckBurned) {
	            IERC20(controller.ddimTokenAddress()).transfer(address(0), amountA);
	        } else {
	            IERC20(token0).transfer(receiver, amountA);
	        }
	    }
	    
	    if(!token1Sent) {
	        if(token1 == controller.ddimTokenAddress() && !isDuckBurned) {
	            IERC20(controller.ddimTokenAddress()).transfer(address(0), amountB);
	        } else {
	            IERC20(token1).transfer(receiver, amountB);
	        }
	    }
	}
  

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

	// Get user pending reward. Frontend function..
	function getUserPendingReward(address userAddress) public view returns(uint) {
		UserInfo storage user = userInfo[userAddress];
		uint256 duckReward = calculateDuckTokensForMint();

		uint256 lpSupply = lpToken.balanceOf(address(this));
		if (lpSupply == 0) {
		  return 0;
		}

		uint _accDuckPerShare = accDuckPerShare.add(duckReward.mul(1e18).mul(93).div(100).div(lpSupply));

		return user.amount.mul(_accDuckPerShare).div(1e18).sub(user.rewardDebt);
	}

	// Get current period index.
	function getCurrentPeriodIndex() public view returns(uint) {
		for(uint i = 0; i < periods.length; i++) {
			if(block.number > periods[i].startingBlock && block.number < periods[i].startingBlock.add(periods[i].blocks)) {
				return i;
			}
		}
	}

	// Calculate DUCK Tokens for mint near current time.
	function calculateDuckTokensForMint() public view returns(uint) {
		uint totalTokens;
		bool overflown;

		for(uint i = 0; i < periods.length; i++) {
			if(block.number < periods[i].startingBlock) {
				break;
			}

			uint buf = periods[i].startingBlock.add(periods[i].blocks);

			if(lastRewardBlock > buf) {
				continue;
			}

			if(block.number > buf) {
			  	totalTokens += buf.sub(max(lastRewardBlock, periods[i].startingBlock-1)).mul(periods[i].tokensPerBlock);
				overflown = true;
			} else {
				if(overflown) {
					totalTokens += block.number.sub(periods[i].startingBlock-1).mul(periods[i].tokensPerBlock);
				} else {
	      			totalTokens += block.number.sub(max(lastRewardBlock, periods[i].startingBlock-1)).mul(periods[i].tokensPerBlock);
				}

				break;
			}
		}

		return totalTokens;
	}

	// Safe duck transfer function, just in case if rounding error causes pool to not have enough DUCKs.
	function safeDuckTransfer(address to, uint256 amount) internal {
		uint256 duckBal = duck.balanceOf(address(this));
		if (amount > duckBal) {
		  	duck.transfer(to, duckBal);
		} else {
			duck.transfer(to, amount);
		}
	}
    
	//--------------------------------------------------------------------------------------
	//---------------------------------REVENUE PART-----------------------------------------
	//--------------------------------------------------------------------------------------
  
	// Add new Revenue, can be called only by controller
	function addRevenue(address _tokenAddress, uint _amount, address _revenueSource) public onlyController {
		require(revenues.length < 50, "exceed revenue limit");

		uint revenueBefore = IERC20(_tokenAddress).balanceOf(address(this));
		IERC20(_tokenAddress).transferFrom(_revenueSource, address(this), _amount);
		uint revenueAfter = IERC20(_tokenAddress).balanceOf(address(this));
		_amount = revenueAfter.sub(revenueBefore);

		Revenue memory revenue = Revenue({
			tokenAddress: _tokenAddress,
			totalSupply: lpToken.balanceOf(address(this)),
			amount: _amount
		});

		revenues.push(revenue);
	}

	// Get user last revenue. Frontend function.
	function getUserLastRevenue(address userAddress) public view returns(address, uint) {
		UserInfo storage user = userInfo[userAddress];

		for(uint i = 0; i < revenues.length; i++) {
			if(!revenuesClaimed[userAddress][i]) {
				uint userRevenue = revenues[i].amount.mul(user.amount).div(revenues[i].totalSupply);
				return (revenues[i].tokenAddress, userRevenue);
			}
		}
	}
    
	// claimRevenue is private function, called on updatePool for transaction caller
	function claimRevenue(address userAddress) private {
		UserInfo storage user = userInfo[userAddress];

		for(uint i = 0; i < revenues.length; i++) {
			if(!revenuesClaimed[userAddress][i]) {
				revenuesClaimed[userAddress][i] = true;
				uint userRevenue = revenues[i].amount.mul(user.amount).div(revenues[i].totalSupply);

				safeRevenueTransfer(revenues[i].tokenAddress, userAddress, userRevenue);
			}
		}
	}
    
	// Safe revenue transfer for avoid misscalculations
	function safeRevenueTransfer(address tokenAddress, address to, uint amount) private {
		uint balance = IERC20(tokenAddress).balanceOf(address(this));
		if(balance == 0 || amount == 0) {
			return;
		}

		if(balance >= amount) {
			IERC20(tokenAddress).transfer(to, amount);
		} else {
		  	IERC20(tokenAddress).transfer(to, balance);
		}
	}

	function max(uint a, uint b) public pure returns(uint) {
		if(a > b) {
		  	return a;
		}
		return b;
	}
}

contract PoolController is Ownable {
	
	// DUCK TOKEN
	DuckToken public duck;
	// Array of pools
	Pool[] public pools;
	
	address public devAddress;
    address public ddimTokenAddress;

	// Mapping is address is pool
	mapping(address => bool) public canMint;

	event NewPool(address indexed poolAddress, address lpToken);

	constructor(address _duckTokenAddress, address _devAddress, address _ddimTokenAddress) public {
		duck = DuckToken(_duckTokenAddress);
		devAddress = _devAddress;
		ddimTokenAddress = _ddimTokenAddress;
	}

	// Add a new pool. Can only be called by the owner.
	function newPool(address lpToken, uint startingBlock, uint[] memory blocks, uint[] memory farmingSupplies) public onlyOwner {
		Pool pool = new Pool(lpToken, startingBlock, blocks, farmingSupplies);
		pools.push(pool);

		canMint[address(pool)] = true;
		emit NewPool(address(pool), lpToken);
	}

	// Update already created pool by adding NEW period. Can only be called by the owner.
	function addPeriod(uint poolIndex, uint startingBlock, uint blocks, uint farmingSupply) public onlyOwner {
		pools[poolIndex].addPeriod(startingBlock, blocks, farmingSupply);
	}
	
	// Add new revenue for a pool. Can only be called by the owner. 
	function addRevenue(uint poolIndex, address tokenAddress, uint amount, address _revenueSource) public onlyOwner {
	    pools[poolIndex].addRevenue(tokenAddress, amount, _revenueSource);
	}

	// Mint DUCK TOKEN. Can be called by pools only
	function mint(address to, uint value) public {
		require(canMint[msg.sender], "only pools");
		duck.mint(to, value);
	}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_lpToken","type":"address"},{"internalType":"uint256","name":"_startingBlock","type":"uint256"},{"internalType":"uint256[]","name":"_blocks","type":"uint256[]"},{"internalType":"uint256[]","name":"_farmingSupplies","type":"uint256[]"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"startingBlock","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"blocks","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"farmingSupply","type":"uint256"}],"name":"NewPeriod","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"accDuckPerShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"startingBlock","type":"uint256"},{"internalType":"uint256","name":"blocks","type":"uint256"},{"internalType":"uint256","name":"farmingSupply","type":"uint256"}],"name":"addPeriod","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_tokenAddress","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"address","name":"_revenueSource","type":"address"}],"name":"addRevenue","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"calculateDuckTokensForMint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"controller","outputs":[{"internalType":"contract PoolController","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"duck","outputs":[{"internalType":"contract ERC20Burnable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getCurrentPeriodIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"userAddress","type":"address"}],"name":"getUserLastRevenue","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"userAddress","type":"address"}],"name":"getUserPendingReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastRewardBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lpToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"uint256","name":"b","type":"uint256"}],"name":"max","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"periods","outputs":[{"internalType":"uint256","name":"startingBlock","type":"uint256"},{"internalType":"uint256","name":"blocks","type":"uint256"},{"internalType":"uint256","name":"farmingSupply","type":"uint256"},{"internalType":"uint256","name":"tokensPerBlock","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"revenues","outputs":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"uint256","name":"totalSupply","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"uniswapRouter","outputs":[{"internalType":"contract IUniswapRouter","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"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":"amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

33836:11994:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35254:44;;;;;;;;;;;;;;;;-1:-1:-1;35254:44:0;-1:-1:-1;;;;;35254:44:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;39133:605;;;;;;;;;;;;;;;;-1:-1:-1;39133:605:0;;:::i;:::-;;36977:698;;;;;;;;;;;;;;;;-1:-1:-1;36977:698:0;;;;;;;;;;;;:::i;41079:261::-;;;;;;;;;;;;;;;;-1:-1:-1;41079:261:0;;:::i;43730:616::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;43730:616:0;;;;;;;;;;;;;;;;;:::i;35091:21::-;;;:::i;:::-;;;;-1:-1:-1;;;;;35091:21:0;;;;;;;;;;;;;;44398:385;;;;;;;;;;;;;;;;-1:-1:-1;44398:385:0;-1:-1:-1;;;;;44398:385:0;;:::i;:::-;;;;-1:-1:-1;;;;;44398:385:0;;;;;;;;;;;;;;;;;;;;;;45718:109;;;;;;;;;;;;;;;;-1:-1:-1;45718:109:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;35304:96;;;:::i;42212:840::-;;;:::i;34972:27::-;;;:::i;41900:252::-;;;:::i;38467:622::-;;;;;;;;;;;;;;;;-1:-1:-1;38467:622:0;;:::i;41395:469::-;;;;;;;;;;;;;;;;-1:-1:-1;41395:469:0;-1:-1:-1;;;;;41395:469:0;;:::i;35025:25::-;;;:::i;35541:::-;;;;;;;;;;;;;;;;-1:-1:-1;35541:25:0;;:::i;:::-;;;;-1:-1:-1;;;;;35541:25:0;;;;;;;;;;;;;;;;;;;;;;;;;35175:27;;;:::i;37745:663::-;;;:::i;34826:23::-;;;;;;;;;;;;;;;;-1:-1:-1;34826:23:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34879:32;;;:::i;35254:44::-;;;;;;;;;;;;;;;;;;;:::o;39133:605::-;39214:10;39181:21;39205:20;;;:8;:20;;;;;39240:11;;:21;-1:-1:-1;39240:21:0;39232:52;;;;;-1:-1:-1;;;39232:52:0;;;;;;;;;;;;-1:-1:-1;;;39232:52:0;;;;;;;;;;;;;;;39291:12;:10;:12::i;:::-;39310:15;39328:63;39375:4;:15;;;39328:42;39365:4;39328:32;39344:15;;39328:4;:11;;;:15;;:32;;;;:::i;:::-;:36;;:42::i;:::-;:46;;:63::i;:::-;39310:81;-1:-1:-1;39399:11:0;;39396:65;;39418:37;39435:10;39447:7;39418:16;:37::i;:::-;39470:10;;39467:159;;39560:11;;:23;;39576:6;39560:15;:23::i;:::-;39546:37;;39589:31;39601:10;39613:6;39589:11;:31::i;:::-;39669:15;;39653:11;;:42;;39690:4;;39653:32;;:15;:32::i;:42::-;39635:15;;;:60;39705:28;;;;;;;;39714:10;;39705:28;;;;;;;;;;39133:605;;;:::o;36977:698::-;36021:10;;-1:-1:-1;;;;;36021:10:0;35999;:33;35991:60;;;;;-1:-1:-1;;;35991:60:0;;;;;;;;;;;;-1:-1:-1;;;35991:60:0;;;;;;;;;;;;;;;37104:12:::1;37087:13;:29;;37079:82;;;;-1:-1:-1::0;;;37079:82:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37196:1;37179:14:::0;:18;37176:176:::1;;37277:7;37285:14:::0;;37233:77:::1;::::0;37277:7;-1:-1:-1;;37285:16:0;;;37277:25;::::1;;;;;;;;;;;;;;;:32;;;37233:7;37256:1;37241:7;:14;;;;:16;37233:25;;;;;;;;;::::0;;;::::1;::::0;;;::::1;::::0;;::::1;;:39:::0;;:43:::1;:77::i;:::-;37217:13;:93;37209:134;;;::::0;;-1:-1:-1;;;37209:134:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;37358:19;37380:25;:13:::0;37398:6;37380:17:::1;:25::i;:::-;37358:47;;37410:23;;:::i;:::-;37436:144;::::0;;::::1;::::0;::::1;::::0;;;;;;::::1;::::0;::::1;37491:13;:6:::0;37502:1:::1;37491:10;:13::i;:::-;37436:144:::0;;::::1;::::0;;::::1;::::0;;;;;;;;;;-1:-1:-1;37587:23:0;;::::1;::::0;::::1;::::0;;;;;;;;::::1;::::0;;::::1;::::0;;::::1;::::0;;;::::1;::::0;;;;;;;::::1;::::0;;;;;::::1;::::0;::::1;::::0;;;;;;37623:47;;;;;;;37587:23;;-1:-1:-1;37648:6:0;;37633:13;;37623:47:::1;::::0;;;;;;;::::1;36057:1;;36977:698:::0;;;:::o;41079:261::-;41164:10;41131:21;41155:20;;;:8;:20;;;;;41222:11;;41180:7;;41155:20;;41180:54;;-1:-1:-1;;;;;41180:7:0;;:20;:54::i;:::-;41279:11;;41244:47;;;;;;;41274:3;;41262:10;;41244:47;;;;;;;;;41310:1;41296:15;;;41316;;;;:19;-1:-1:-1;41079:261:0:o;43730:616::-;36021:10;;-1:-1:-1;;;;;36021:10:0;35999;:33;35991:60;;;;;-1:-1:-1;;;35991:60:0;;;;;;;;;;;;-1:-1:-1;;;35991:60:0;;;;;;;;;;;;;;;43846:8:::1;:15:::0;43864:2:::1;-1:-1:-1::0;43838:53:0::1;;;::::0;;-1:-1:-1;;;43838:53:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;43838:53:0;;;;;;;;;;;;;::::1;;43919:46;::::0;;-1:-1:-1;;;43919:46:0;;43959:4:::1;43919:46;::::0;::::1;::::0;;;43898:18:::1;::::0;-1:-1:-1;;;;;43919:31:0;::::1;::::0;::::1;::::0;:46;;;;;::::1;::::0;;;;;;;;;:31;:46;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;43919:46:0;43970:74:::1;::::0;;-1:-1:-1;;;43970:74:0;;-1:-1:-1;;;;;43970:74:0;;::::1;;::::0;::::1;::::0;44029:4:::1;43970:74:::0;;;;;;;;;;;;43919:46;;-1:-1:-1;43970:34:0;;::::1;::::0;-1:-1:-1;;43970:74:0;;;;;43919:46:::1;::::0;43970:74;;;;;;;;-1:-1:-1;43970:34:0;:74;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;;44069:46:0::1;::::0;;-1:-1:-1;;;44069:46:0;;44109:4:::1;44069:46;::::0;::::1;::::0;;;-1:-1:-1;;;;;;;44069:31:0;::::1;::::0;-1:-1:-1;;44069:46:0;;;;;43970:74:::1;::::0;44069:46;;;;;;;;:31;:46;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;44069:46:0;;-1:-1:-1;44130:31:0::1;44069:46:::0;44147:13;44130:16:::1;:31::i;:::-;44120:41;;44168:22;;:::i;:::-;44193:119;::::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;;;;;44193:119:0;;::::1;::::0;;44253:7:::1;::::0;;:32;;-1:-1:-1;;;44253:32:0;;44279:4:::1;44253:32:::0;;::::1;::::0;;;;;;44193:119;;::::1;::::0;;::::1;::::0;44253:7;;;::::1;::::0;-1:-1:-1;;44253:32:0;;;;;;;;;;;:7;:32;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;44253:32:0;44193:119;;44253:32:::1;44193:119:::0;;::::1;::::0;;;;44319:8:::1;:22:::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;44319:22:0;;;;;;;::::1;::::0;;::::1;::::0;;::::1;::::0;;-1:-1:-1;;;;;;44319:22:0::1;-1:-1:-1::0;;;;;44319:22:0;;::::1;::::0;;;::::1;::::0;;;;::::1;::::0;;;;;::::1;;::::0;;;;;;;;;-1:-1:-1;;;;;43730:616:0:o;35091:21::-;;;-1:-1:-1;;;;;35091:21:0;;:::o;44398:385::-;-1:-1:-1;;;;;44511:21:0;;44467:7;44511:21;;;:8;:21;;;;;44467:7;;;44539:240;44559:8;:15;44555:19;;44539:240;;;-1:-1:-1;;;;;44591:28:0;;;;;;:15;:28;;;;;;;;:31;;;;;;;;;;;44587:187;;44631:16;44650:64;44690:8;44699:1;44690:11;;;;;;;;;;;;;;;;;;:23;;;44650:35;44673:4;:11;;;44650:8;44659:1;44650:11;;;;;;;;;;;;;;;;;;:18;;;:22;;:35;;;;:::i;:64::-;44631:83;;44729:8;44738:1;44729:11;;;;;;;;;;;;;;;;;;;;;:24;-1:-1:-1;;;;;44729:24:0;;-1:-1:-1;44755:11:0;-1:-1:-1;44721:46:0;;-1:-1:-1;;44721:46:0;44587:187;44576:3;;44539:240;;;;44398:385;;;;;:::o;45718:109::-;45767:4;45785:1;45781;:5;45778:32;;;-1:-1:-1;45803:1:0;45796:8;;45778:32;-1:-1:-1;45821:1:0;45718:109;;;;;:::o;35304:96::-;;;-1:-1:-1;;;;;35304:96:0;;:::o;42212:840::-;42270:4;;;;42323:700;42343:7;:14;42339:18;;42323:700;;;42388:7;42396:1;42388:10;;;;;;;;;;;;;;;;;;:24;;;42373:12;:39;42370:63;;;42421:5;;42370:63;42440:8;42451:47;42480:7;42488:1;42480:10;;;;;;;;;;;;;;;;;;:17;;;42451:7;42459:1;42451:10;;;;;;;:47;42440:58;;42527:3;42509:15;;:21;42506:48;;;42539:8;;;42506:48;42579:3;42564:12;:18;42561:457;;;42608:88;42670:7;42678:1;42670:10;;;;;;;;;;;;;;;;;;:25;;;42608:57;42616:48;42620:15;;42662:1;42637:7;42645:1;42637:10;;;;;;;;;;;;;;;;;;:24;;;:26;42616:3;:48::i;:::-;42608:3;;:7;:57::i;:::-;:61;;:88::i;:::-;42593:103;;;;42715:4;42703:16;;42561:457;;;42742:9;42739:259;;;42776:75;42825:7;42833:1;42825:10;;;;;;;;;;;;;;;;;;:25;;;42776:44;42818:1;42793:7;42801:1;42793:10;;;;;;;;;;;;;;;;;;:24;;;:26;42776:12;:16;;:44;;;;:::i;:75::-;42761:90;;;;42739:259;;;42893:97;42964:7;42972:1;42964:10;;;;;;;;;;;;;;;;;;:25;;;42893:66;42910:48;42914:15;;42956:1;42931:7;42939:1;42931:10;;;;;;;42910:48;42893:12;;:16;:66::i;:97::-;42878:112;;;;42739:259;43006:5;;;42561:457;42323:700;;42359:3;;42323:700;;;-1:-1:-1;43036:11:0;;-1:-1:-1;;42212:840:0;;:::o;34972:27::-;;;;:::o;41900:252::-;41953:4;;41964:184;41984:7;:14;41980:18;;41964:184;;;42029:7;42037:1;42029:10;;;;;;;;;;;;;;;;;;:24;;;42014:12;:39;:105;;;;;42072:47;42101:7;42109:1;42101:10;;;;;;;;;;;;;;;;;;:17;;;42072:7;42080:1;42072:10;;;;;;;:47;42057:12;:62;42014:105;42011:132;;;42135:1;-1:-1:-1;42128:8:0;;42011:132;42000:3;;41964:184;;;;41900:252;:::o;38467:622::-;38532:1;38523:6;:10;38515:52;;;;;-1:-1:-1;;;38515:52:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;38608:10;38575:21;38599:20;;;:8;:20;;;;;38631:12;:10;:12::i;:::-;38659:11;;:15;38655:189;;38682:15;38700:63;38747:4;:15;;;38700:42;38737:4;38700:32;38716:15;;38700:4;:11;;;:15;;:32;;;;:::i;:63::-;38682:81;-1:-1:-1;38772:11:0;;38769:67;;38792:37;38809:10;38821:7;38792:16;:37::i;:::-;38655:189;;38872:11;;:23;;38888:6;38872:15;:23::i;:::-;38858:37;;38903:7;;:59;;-1:-1:-1;;;;;38903:7:0;38928:10;38948:4;38955:6;38903:24;:59::i;:::-;39011:15;;38995:11;;:42;;39032:4;;38995:32;;:15;:32::i;:42::-;38977:15;;;:60;39057:27;;;;;;;;39065:10;;39057:27;;;;;;;;;;38467:622;;:::o;41395:469::-;-1:-1:-1;;;;;41501:21:0;;41466:4;41501:21;;;:8;:21;;;;;41466:4;41548:28;:26;:28::i;:::-;41602:7;;;:32;;;-1:-1:-1;;;41602:32:0;;41628:4;41602:32;;;;;;;;41527:49;;-1:-1:-1;;;;;;;;41602:7:0;;;;-1:-1:-1;;41602:32:0;;;;;;;;;;;;;;:7;:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;41602:32:0;;-1:-1:-1;41643:13:0;41639:40;;41672:1;41665:8;;;;;;;41639:40;41685:21;41709:72;41729:51;41771:8;41729:37;41762:3;41729:37;41754:2;41729:20;:10;41744:4;41729:14;:20::i;:51::-;41709:15;;;:19;:72::i;:::-;41685:96;;41795:64;41843:4;:15;;;41795:43;41833:4;41795:33;41811:16;41795:4;:11;;;:15;;:33;;;;:::i;:64::-;41788:71;;;;;;41395:469;;;;:::o;35025:25::-;;;-1:-1:-1;;;;;35025:25:0;;:::o;35541:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;35541:25:0;;;;-1:-1:-1;35541:25:0;:::o;35175:27::-;;;;:::o;37745:663::-;37802:15;;37786:12;:31;37782:61;;37828:7;;37782:61;37852:24;37865:10;37852:12;:24::i;:::-;37907:7;;;:32;;;-1:-1:-1;;;37907:32:0;;37933:4;37907:32;;;;;;;;-1:-1:-1;;;;;;;37907:7:0;;;;-1:-1:-1;;37907:32:0;;;;;;;;;;;;;;:7;:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;37907:32:0;;-1:-1:-1;37951:13:0;37947:76;;-1:-1:-1;37990:12:0;37972:15;:30;38008:7;;37947:76;38034:18;38055:28;:26;:28::i;:::-;38034:49;-1:-1:-1;38095:14:0;;38091:266;;38117:10;;38133:23;;;-1:-1:-1;;;38133:23:0;;;;-1:-1:-1;;;;;38117:10:0;;;;:15;;:10;;38133:21;;:23;;;;;;;;;;;;;;;38117:10;38133:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;38133:23:0;38158:26;38180:3;38158:17;:10;38173:1;38158:14;:17::i;:26::-;38117:68;;;;;;;;;;;;;-1:-1:-1;;;;;38117:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;38191:10:0;;-1:-1:-1;;;;;38191:10:0;;-1:-1:-1;38191:15:0;;-1:-1:-1;38215:4:0;38222:27;38245:3;38222:18;:10;38237:2;38222:14;:18::i;:27::-;38191:59;;;;;;;;;;;;;-1:-1:-1;;;;;38191:59:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38276:72;38296:51;38338:8;38296:37;38329:3;38296:28;38321:2;38296:20;38311:4;38296:10;:14;;:20;;;;:::i;38276:72::-;38258:15;:90;38091:266;-1:-1:-1;;38389:12:0;38371:15;:30;37745:663;:::o;34826:23::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;34826:23:0;;;:::o;34879:32::-;;;-1:-1:-1;;;;;34879:32:0;;:::o;6471:181::-;6529:7;6561:5;;;6585:6;;;;6577:46;;;;;-1:-1:-1;;;6577:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;6643:1;6471:181;-1:-1:-1;;;6471:181:0:o;8772:132::-;8830:7;8857:39;8861:1;8864;8857:39;;;;;;;;;;;;;;;;;:3;:39::i;6935:136::-;6993:7;7020:43;7024:1;7027;7020:43;;;;;;;;;;;;;;;;;:3;:43::i;7825:471::-;7883:7;8128:6;8124:47;;-1:-1:-1;8158:1:0;8151:8;;8124:47;8195:5;;;8199:1;8195;:5;:1;8219:5;;;;;:10;8211:56;;;;-1:-1:-1;;;8211:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43160:229;43246:4;;:29;;;-1:-1:-1;;;43246:29:0;;43269:4;43246:29;;;;;;-1:-1:-1;;;;;;;43246:4:0;;-1:-1:-1;;43246:29:0;;;;;;;;;;;;;;:4;:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;43246:29:0;;-1:-1:-1;43284:16:0;;;43280:105;;;43310:4;;:26;;;-1:-1:-1;;;43310:26:0;;-1:-1:-1;;;;;43310:26:0;;;;;;;;;;;;;;;:4;;;;;-1:-1:-1;;43310:26:0;;;;;;;;;;;;;;-1:-1:-1;43310:4:0;:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;43280:105:0;;-1:-1:-1;43280:105:0;;43354:4;;:25;;;-1:-1:-1;;;43354:25:0;;-1:-1:-1;;;;;43354:25:0;;;;;;;;;;;;;;;:4;;;;;-1:-1:-1;;43354:25:0;;;;;;;;;;;;;;-1:-1:-1;43354:4:0;:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;43280:105:0;43160:229;;;:::o;39745:1265::-;39866:7;;;39899:20;;;-1:-1:-1;;;39899:20:0;;;;-1:-1:-1;;;;;39866:7:0;;;;39818:24;;39866:7;;-1:-1:-1;;39899:20:0;;;;;;;;;;;;;;39866:7;39899:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;39899:20:0;39941;;;-1:-1:-1;;;39941:20:0;;;;39899;;-1:-1:-1;39924:14:0;;-1:-1:-1;;;;;39941:18:0;;;-1:-1:-1;;39941:20:0;;;;;39899;;39941;;;;;;;:18;:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;39941:20:0;39999:13;;:104;;;-1:-1:-1;;;39999:104:0;;-1:-1:-1;;;;;39999:104:0;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40099:3:0;39999:104;;;;;;;;;;;;;40074:4;39999:104;;;;40081:15;:21;39999:104;;;;;;39941:20;;-1:-1:-1;;;;;39999:13:0;;;;;:29;;:104;;;;;;;;;;;-1:-1:-1;39999:13:0;:104;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;39999:104:0;;;;;;;40196:4;;39999:104;;-1:-1:-1;39999:104:0;-1:-1:-1;40110:17:0;;;;;;-1:-1:-1;;;;;40178:23:0;;;40196:4;;40178:23;40175:127;;;40215:4;;:18;;;-1:-1:-1;;;40215:18:0;;;;;;;;;;-1:-1:-1;;;;;40215:4:0;;;;:9;;:18;;;;;-1:-1:-1;;40215:18:0;;;;;;;;-1:-1:-1;40215:4:0;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40260:4;40245:19;;40289:4;40276:17;;40175:127;40332:4;;-1:-1:-1;;;;;40314:23:0;;;40332:4;;40314:23;40311:127;;;40351:4;;:18;;;-1:-1:-1;;;40351:18:0;;;;;;;;;;-1:-1:-1;;;;;40351:4:0;;;;:9;;:18;;;;;-1:-1:-1;;40351:18:0;;;;;;;;-1:-1:-1;40351:4:0;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40396:4;40381:19;;40425:4;40412:17;;40311:127;40456:10;40452:270;;40493:10;;:29;;;-1:-1:-1;;;40493:29:0;;;;-1:-1:-1;;;;;40493:10:0;;;;:27;;:29;;;;;;;;;;;;;;;:10;:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40493:29:0;-1:-1:-1;;;;;40483:39:0;;;;;;:56;;;;;40527:12;40526:13;40483:56;40480:234;;;40564:10;;:29;;;-1:-1:-1;;;40564:29:0;;;;-1:-1:-1;;;;;40564:10:0;;;;:27;;:29;;;;;;;;;;;;;;;:10;:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40564:29:0;40557:67;;;-1:-1:-1;;;40557:67:0;;40612:1;40557:67;;;;;;;;;;;;;;-1:-1:-1;;;;;40557:46:0;;;;-1:-1:-1;;40557:67:0;;;;;40564:29;;40557:67;;;;;;;;;;;:46;:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40480:234:0;;-1:-1:-1;40480:234:0;;40659:42;;;-1:-1:-1;;;40659:42:0;;-1:-1:-1;;;;;40659:42:0;;;;;;;;;;;;;;;:23;;;;;;:42;;;;;;;;;;;;;;;-1:-1:-1;40659:23:0;:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;40480:234:0;40740:10;40736:270;;40777:10;;:29;;;-1:-1:-1;;;40777:29:0;;;;-1:-1:-1;;;;;40777:10:0;;;;:27;;:29;;;;;;;;;;;;;;;:10;:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40777:29:0;-1:-1:-1;;;;;40767:39:0;;;;;;:56;;;;;40811:12;40810:13;40767:56;40764:234;;;40848:10;;:29;;;-1:-1:-1;;;40848:29:0;;;;-1:-1:-1;;;;;40848:10:0;;;;:27;;:29;;;;;;;;;;;;;;;:10;:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40848:29:0;40841:67;;;-1:-1:-1;;;40841:67:0;;40896:1;40841:67;;;;;;;;;;;;;;-1:-1:-1;;;;;40841:46:0;;;;-1:-1:-1;;40841:67:0;;;;;40848:29;;40841:67;;;;;;;;;;;:46;:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40764:234:0;;-1:-1:-1;40764:234:0;;40943:42;;;-1:-1:-1;;;40943:42:0;;-1:-1:-1;;;;;40943:42:0;;;;;;;;;;;;;;;:23;;;;;;:42;;;;;;;;;;;;;;;-1:-1:-1;40943:23:0;:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;40764:234:0;39745:1265;;;;;;;;;;:::o;30392:177::-;30502:58;;;-1:-1:-1;;;;;30502:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;30502:58:0;-1:-1:-1;;;30502:58:0;;;30475:86;;30495:5;;30475:19;:86::i;30577:205::-;30705:68;;;-1:-1:-1;;;;;30705:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;30705:68:0;-1:-1:-1;;;30705:68:0;;;30678:96;;30698:5;;30678:19;:96::i;:::-;30577:205;;;;:::o;44875:424::-;-1:-1:-1;;;;;44955:21:0;;44931;44955;;;:8;:21;;;;;;44983:312;45003:8;:15;44999:19;;44983:312;;;-1:-1:-1;;;;;45035:28:0;;;;;;:15;:28;;;;;;;;:31;;;;;;;;;;;45031:259;;-1:-1:-1;;;;;45075:28:0;;;;;;:15;:28;;;;;;;;:31;;;;;;;;:38;;-1:-1:-1;;45075:38:0;-1:-1:-1;45075:38:0;;;45179:8;:11;;45139:64;;45179:8;45075:31;;45179:11;;;;;45139:64;45120:83;;45212:71;45232:8;45241:1;45232:11;;;;;;;;;;;;;;;;;;;;;:24;-1:-1:-1;;;;;45232:24:0;45258:11;45271;45212:19;:71::i;:::-;45031:259;;45020:3;;44983:312;;9400:278;9486:7;9521:12;9514:5;9506:28;;;;-1:-1:-1;;;9506:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9545:9;9561:1;9557;:5;;;;;;;9400:278;-1:-1:-1;;;;;9400:278:0:o;7374:192::-;7460:7;7496:12;7488:6;;;;7480:29;;;;-1:-1:-1;;;7480:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7480:29:0;;;;;;;;;;;;;;;;;-1:-1:-1;;;7532:5:0;;;7374:192::o;32697:761::-;33147:69;;;;;;;;;;;;;;;;;;33121:23;;33147:69;;-1:-1:-1;;;;;33147:27:0;;;33175:4;;33147:27;:69::i;:::-;33231:17;;33121:95;;-1:-1:-1;33231:21:0;33227:224;;33373:10;33362:30;;;;;;;;;;;;;;;-1:-1:-1;33362:30:0;33354:85;;;;-1:-1:-1;;;33354:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45362:351;45466:45;;;-1:-1:-1;;;45466:45:0;;45505:4;45466:45;;;;;;45451:12;;-1:-1:-1;;;;;45466:30:0;;;;;:45;;;;;;;;;;;;;;;:30;:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;45466:45:0;;-1:-1:-1;45519:12:0;;;:27;;-1:-1:-1;45535:11:0;;45519:27;45516:50;;;45554:7;;;45516:50;45586:6;45575:7;:17;45572:137;;45600:41;;;-1:-1:-1;;;45600:41:0;;-1:-1:-1;;;;;45600:41:0;;;;;;;;;;;;;;;:29;;;;;;:41;;;;;;;;;;;;;;;-1:-1:-1;45600:29:0;:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;45572:137:0;;-1:-1:-1;45572:137:0;;45661:42;;;-1:-1:-1;;;45661:42:0;;-1:-1:-1;;;;;45661:42:0;;;;;;;;;;;;;;;:29;;;;;;:42;;;;;;;;;;;;;;;-1:-1:-1;45661:29:0;:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;45362:351:0;;;;:::o;14624:196::-;14727:12;14759:53;14782:6;14790:4;14796:1;14799:12;14759:22;:53::i;:::-;14752:60;14624:196;-1:-1:-1;;;;14624:196:0:o;16001:979::-;16131:12;16164:18;16175:6;16164:10;:18::i;:::-;16156:60;;;;;-1:-1:-1;;;16156:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;16290:12;16304:23;16331:6;-1:-1:-1;;;;;16331:11:0;16351:8;16362:4;16331:36;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;16331:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16289:78;;;;16382:7;16378:595;;;16413:10;-1:-1:-1;16406:17:0;;-1:-1:-1;16406:17:0;16378:595;16527:17;;:21;16523:439;;16790:10;16784:17;16851:15;16838:10;16834:2;16830:19;16823:44;16738:148;16926:20;;-1:-1:-1;;;16926:20:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;16926:20:0;;;;;;;;;;;;;;;;11706:422;12073:20;12112:8;;;11706:422::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o

ipfs://a674f3126eea91b988f39151b48d1b491c2af3a90737b312e8d933ed92b64ad8