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 ...
•  contract Operator is Context, Owna ...
•    - function operator()
•    - function isOperator()
•    - function transferOperator(address new ...
•    - function _transferOperator(address ne ...
• 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 ...
•  contract Epoch is Operator
•    - function getCurrentEpoch()
•    - function getPeriod()
•    - function getStartTime()
•    - function nextEpochPoint()
•    - function setPeriod(uint256 _period)
•    - function setStarttime(uint256 _startt ...
• library Babylonian
•    - function sqrt(uint256 y)
• library FixedPoint
•    - function encode(uint112 x)
•    - function encode144(uint144 x)
•    - function div(uq112x112 memory self, u ...
•    - function mul(uq112x112 memory self, u ...
•    - function fraction(uint112 numerator, ...
•    - function decode(uq112x112 memory self ...
•    - function decode144(uq144x112 memory s ...
•    - function reciprocal(uq112x112 memory ...
•    - function sqrt(uq112x112 memory self)
• interface IUniswapV2Pair
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address owner)
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transfer(address to, uint256 ...
•    - function transferFrom(
•    - function DOMAIN_SEPARATOR()
•    - function PERMIT_TYPEHASH()
•    - function nonces(address owner)
•    - function permit(
•    - function MINIMUM_LIQUIDITY()
•    - function factory()
•    - function token0()
•    - function token1()
•    - function getReserves()
•    - function price0CumulativeLast()
•    - function price1CumulativeLast()
•    - function kLast()
•    - function mint(address to)
•    - function burn(address to)
•    - function swap(
•    - function skim(address to)
•    - function sync()
•    - function initialize(address, address)
• library UniswapV2Library
•    - function sortTokens(address tokenA, a ...
•    - function pairFor(
•    - function getReserves(
•    - function quote(
•    - function getAmountOut(
•    - function getAmountIn(
•    - function getAmountsOut(
•    - function getAmountsIn(
• library UniswapV2OracleLibrary
•    - function currentBlockTimestamp()
•    - function currentCumulativePrices(addr ...
• interface IUniswapV2Router01
•    - function factory()
•    - function WETH()
•    - function addLiquidity(
•    - function addLiquidityETH(
•    - function removeLiquidity(
•    - function removeLiquidityETH(
•    - function removeLiquidityWithPermit(
•    - function removeLiquidityETHWithPermit ...
•    - function swapExactTokensForTokens(
•    - function swapTokensForExactTokens(
•    - function swapExactETHForTokens(uint a ...
•    - function swapTokensForExactETH(uint a ...
•    - function swapExactTokensForETH(uint a ...
•    - function swapETHForExactTokens(uint a ...
•    - function quote(uint amountA, uint res ...
•    - function getAmountOut(uint amountIn, ...
•    - function getAmountIn(uint amountOut, ...
•    - function getAmountsOut(uint amountIn, ...
•    - function getAmountsIn(uint amountOut, ...
• interface IUniswapRouter is IUniswapV ...
•    - function removeLiquidityETHSupporting ...
•    - function removeLiquidityETHWithPermit ...
•    - function swapExactTokensForTokensSupp ...
•    - function swapExactETHForTokensSupport ...
•    - function swapExactTokensForETHSupport ...
• 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, ...
•  contract Oracle is Epoch *
•    - function update()
•    - function consult(address token, uint2 ...
•    - function pairFor(
•    - function rescueToken(IERC20 _token)

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-01-04
*/

// SPDX-License-Identifier: CC-BY-NC-SA-2.5
//@code0x2

pragma solidity ^0.6.12;

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");
        _;
    }

    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

contract Operator is Context, Ownable {
    address private _operator;

    event OperatorTransferred(
        address indexed previousOperator,
        address indexed newOperator
    );

    constructor() internal {
        _operator = _msgSender();
        emit OperatorTransferred(address(0), _operator);
    }

    function operator() public view returns (address) {
        return _operator;
    }

    modifier onlyOperator() {
        require(
            _operator == msg.sender,
            'operator: caller is not the operator'
        );
        _;
    }

    function isOperator() public view returns (bool) {
        return _msgSender() == _operator;
    }

    function transferOperator(address newOperator_) public onlyOwner {
        _transferOperator(newOperator_);
    }

    function _transferOperator(address newOperator_) internal {
        require(
            newOperator_ != address(0),
            'operator: zero address given for new operator'
        );
        emit OperatorTransferred(address(0), newOperator_);
        _operator = newOperator_;
    }
}

library SafeMath {

    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }
    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;
    }
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by 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;
    }
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

contract Epoch is Operator {
    using SafeMath for uint256;

    uint256 private period;
    uint256 private startTime;
    uint256 private epoch;

    /* ========== CONSTRUCTOR ========== */

    constructor(
        uint256 _period,
        uint256 _startTime,
        uint256 _startEpoch
    ) public {
        period = _period;
        startTime = _startTime;
        epoch = _startEpoch;
    }

    /* ========== Modifier ========== */

    modifier checkStartTime {
        require(now >= startTime, 'Epoch: not started yet');

        _;
    }

    modifier checkEpoch {
        require(now >= nextEpochPoint(), 'Epoch: not allowed');

        _;

        epoch = epoch.add(1);
    }

    /* ========== VIEW FUNCTIONS ========== */

    function getCurrentEpoch() public view returns (uint256) {
        return epoch;
    }

    function getPeriod() public view returns (uint256) {
        return period;
    }

    function getStartTime() public view returns (uint256) {
        return startTime;
    }

    function nextEpochPoint() public view returns (uint256) {
        return startTime.add(epoch.mul(period));
    }

    /* ========== GOVERNANCE ========== */

    function setPeriod(uint256 _period) external onlyOperator {
        period = _period;
    }

    /* ========== DEPLOYEMENT ========= */
    function setStarttime(uint256 _starttime) public onlyOwner {
        require(startTime > now, "already start");
        require(_starttime > now, "invalid param");
        startTime = _starttime;
    }
}

library Babylonian {
    function sqrt(uint256 y) internal pure returns (uint256 z) {
        if (y > 3) {
            z = y;
            uint256 x = y / 2 + 1;
            while (x < z) {
                z = x;
                x = (y / x + x) / 2;
            }
        } else if (y != 0) {
            z = 1;
        }
        // else z = 0
    }
}

library FixedPoint {
    // range: [0, 2**112 - 1]
    // resolution: 1 / 2**112
    struct uq112x112 {
        uint224 _x;
    }

    // range: [0, 2**144 - 1]
    // resolution: 1 / 2**112
    struct uq144x112 {
        uint256 _x;
    }

    uint8 private constant RESOLUTION = 112;
    uint256 private constant Q112 = uint256(1) << RESOLUTION;
    uint256 private constant Q224 = Q112 << RESOLUTION;

    // encode a uint112 as a UQ112x112
    function encode(uint112 x) internal pure returns (uq112x112 memory) {
        return uq112x112(uint224(x) << RESOLUTION);
    }

    // encodes a uint144 as a UQ144x112
    function encode144(uint144 x) internal pure returns (uq144x112 memory) {
        return uq144x112(uint256(x) << RESOLUTION);
    }

    // divide a UQ112x112 by a uint112, returning a UQ112x112
    function div(uq112x112 memory self, uint112 x)
        internal
        pure
        returns (uq112x112 memory)
    {
        require(x != 0, 'FixedPoint: DIV_BY_ZERO');
        return uq112x112(self._x / uint224(x));
    }

    // multiply a UQ112x112 by a uint, returning a UQ144x112
    // reverts on overflow
    function mul(uq112x112 memory self, uint256 y)
        internal
        pure
        returns (uq144x112 memory)
    {
        uint256 z;
        require(
            y == 0 || (z = uint256(self._x) * y) / y == uint256(self._x),
            'FixedPoint: MULTIPLICATION_OVERFLOW'
        );
        return uq144x112(z);
    }

    // returns a UQ112x112 which represents the ratio of the numerator to the denominator
    // equivalent to encode(numerator).div(denominator)
    function fraction(uint112 numerator, uint112 denominator)
        internal
        pure
        returns (uq112x112 memory)
    {
        require(denominator > 0, 'FixedPoint: DIV_BY_ZERO');
        return uq112x112((uint224(numerator) << RESOLUTION) / denominator);
    }

    // decode a UQ112x112 into a uint112 by truncating after the radix point
    function decode(uq112x112 memory self) internal pure returns (uint112) {
        return uint112(self._x >> RESOLUTION);
    }

    // decode a UQ144x112 into a uint144 by truncating after the radix point
    function decode144(uq144x112 memory self) internal pure returns (uint144) {
        return uint144(self._x >> RESOLUTION);
    }

    // take the reciprocal of a UQ112x112
    function reciprocal(uq112x112 memory self)
        internal
        pure
        returns (uq112x112 memory)
    {
        require(self._x != 0, 'FixedPoint: ZERO_RECIPROCAL');
        return uq112x112(uint224(Q224 / self._x));
    }

    // square root of a UQ112x112
    function sqrt(uq112x112 memory self)
        internal
        pure
        returns (uq112x112 memory)
    {
        return uq112x112(uint224(Babylonian.sqrt(uint256(self._x)) << 56));
    }
}

interface IUniswapV2Pair {
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
    event Transfer(address indexed from, address indexed to, uint256 value);

    function name() external pure returns (string memory);

    function symbol() external pure returns (string memory);

    function decimals() external pure returns (uint8);

    function totalSupply() external view returns (uint256);

    function balanceOf(address owner) external view returns (uint256);

    function allowance(address owner, address spender)
        external
        view
        returns (uint256);

    function approve(address spender, uint256 value) external returns (bool);

    function transfer(address to, uint256 value) external returns (bool);

    function transferFrom(
        address from,
        address to,
        uint256 value
    ) external returns (bool);

    function DOMAIN_SEPARATOR() external view returns (bytes32);

    function PERMIT_TYPEHASH() external pure returns (bytes32);

    function nonces(address owner) external view returns (uint256);

    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    event Mint(address indexed sender, uint256 amount0, uint256 amount1);
    event Burn(
        address indexed sender,
        uint256 amount0,
        uint256 amount1,
        address indexed to
    );
    event Swap(
        address indexed sender,
        uint256 amount0In,
        uint256 amount1In,
        uint256 amount0Out,
        uint256 amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint256);

    function factory() external view returns (address);

    function token0() external view returns (address);

    function token1() external view returns (address);

    function getReserves()
        external
        view
        returns (
            uint112 reserve0,
            uint112 reserve1,
            uint32 blockTimestampLast
        );

    function price0CumulativeLast() external view returns (uint256);

    function price1CumulativeLast() external view returns (uint256);

    function kLast() external view returns (uint256);

    function mint(address to) external returns (uint256 liquidity);

    function burn(address to)
        external
        returns (uint256 amount0, uint256 amount1);

    function swap(
        uint256 amount0Out,
        uint256 amount1Out,
        address to,
        bytes calldata data
    ) external;

    function skim(address to) external;

    function sync() external;

    function initialize(address, address) external;
}

library UniswapV2Library {
    using SafeMath for uint256;

    // returns sorted token addresses, used to handle return values from pairs sorted in this order
    function sortTokens(address tokenA, address tokenB)
        internal
        pure
        returns (address token0, address token1)
    {
        require(tokenA != tokenB, 'UniswapV2Library: IDENTICAL_ADDRESSES');
        (token0, token1) = tokenA < tokenB
            ? (tokenA, tokenB)
            : (tokenB, tokenA);
        require(token0 != address(0), 'UniswapV2Library: ZERO_ADDRESS');
    }

    // calculates the CREATE2 address for a pair without making any external calls
    function pairFor(
        address factory,
        address tokenA,
        address tokenB
    ) internal pure returns (address pair) {
        (address token0, address token1) = sortTokens(tokenA, tokenB);
        pair = address(
            uint256(
                keccak256(
                    abi.encodePacked(
                        hex'ff',
                        factory,
                        keccak256(abi.encodePacked(token0, token1)),
                        hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f' // init code hash
                    )
                )
            )
        );
    }

    // fetches and sorts the reserves for a pair
    function getReserves(
        address factory,
        address tokenA,
        address tokenB
    ) internal view returns (uint256 reserveA, uint256 reserveB) {
        (address token0, ) = sortTokens(tokenA, tokenB);
        (uint256 reserve0, uint256 reserve1, ) = IUniswapV2Pair(
            pairFor(factory, tokenA, tokenB)
        )
            .getReserves();
        (reserveA, reserveB) = tokenA == token0
            ? (reserve0, reserve1)
            : (reserve1, reserve0);
    }

    // given some amount of an asset and pair reserves, returns an equivalent amount of the other asset
    function quote(
        uint256 amountA,
        uint256 reserveA,
        uint256 reserveB
    ) internal pure returns (uint256 amountB) {
        require(amountA > 0, 'UniswapV2Library: INSUFFICIENT_AMOUNT');
        require(
            reserveA > 0 && reserveB > 0,
            'UniswapV2Library: INSUFFICIENT_LIQUIDITY'
        );
        amountB = amountA.mul(reserveB) / reserveA;
    }

    // given an input amount of an asset and pair reserves, returns the maximum output amount of the other asset
    function getAmountOut(
        uint256 amountIn,
        uint256 reserveIn,
        uint256 reserveOut
    ) internal pure returns (uint256 amountOut) {
        require(amountIn > 0, 'UniswapV2Library: INSUFFICIENT_INPUT_AMOUNT');
        require(
            reserveIn > 0 && reserveOut > 0,
            'UniswapV2Library: INSUFFICIENT_LIQUIDITY'
        );
        uint256 amountInWithFee = amountIn.mul(997);
        uint256 numerator = amountInWithFee.mul(reserveOut);
        uint256 denominator = reserveIn.mul(1000).add(amountInWithFee);
        amountOut = numerator / denominator;
    }

    // given an output amount of an asset and pair reserves, returns a required input amount of the other asset
    function getAmountIn(
        uint256 amountOut,
        uint256 reserveIn,
        uint256 reserveOut
    ) internal pure returns (uint256 amountIn) {
        require(amountOut > 0, 'UniswapV2Library: INSUFFICIENT_OUTPUT_AMOUNT');
        require(
            reserveIn > 0 && reserveOut > 0,
            'UniswapV2Library: INSUFFICIENT_LIQUIDITY'
        );
        uint256 numerator = reserveIn.mul(amountOut).mul(1000);
        uint256 denominator = reserveOut.sub(amountOut).mul(997);
        amountIn = (numerator / denominator).add(1);
    }

    // performs chained getAmountOut calculations on any number of pairs
    function getAmountsOut(
        address factory,
        uint256 amountIn,
        address[] memory path
    ) internal view returns (uint256[] memory amounts) {
        require(path.length >= 2, 'UniswapV2Library: INVALID_PATH');
        amounts = new uint256[](path.length);
        amounts[0] = amountIn;
        for (uint256 i; i < path.length - 1; i++) {
            (uint256 reserveIn, uint256 reserveOut) = getReserves(
                factory,
                path[i],
                path[i + 1]
            );
            amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut);
        }
    }

    // performs chained getAmountIn calculations on any number of pairs
    function getAmountsIn(
        address factory,
        uint256 amountOut,
        address[] memory path
    ) internal view returns (uint256[] memory amounts) {
        require(path.length >= 2, 'UniswapV2Library: INVALID_PATH');
        amounts = new uint256[](path.length);
        amounts[amounts.length - 1] = amountOut;
        for (uint256 i = path.length - 1; i > 0; i--) {
            (uint256 reserveIn, uint256 reserveOut) = getReserves(
                factory,
                path[i - 1],
                path[i]
            );
            amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut);
        }
    }
}

library UniswapV2OracleLibrary {
    using FixedPoint for *;

    // helper function that returns the current block timestamp within the range of uint32, i.e. [0, 2**32 - 1]
    function currentBlockTimestamp() internal view returns (uint32) {
        return uint32(block.timestamp % 2**32);
    }

    // produces the cumulative price using counterfactuals to save gas and avoid a call to sync.
    function currentCumulativePrices(address pair)
        internal
        view
        returns (
            uint256 price0Cumulative,
            uint256 price1Cumulative,
            uint32 blockTimestamp
        )
    {
        blockTimestamp = currentBlockTimestamp();
        price0Cumulative = IUniswapV2Pair(pair).price0CumulativeLast();
        price1Cumulative = IUniswapV2Pair(pair).price1CumulativeLast();

        // if time has elapsed since the last update on the pair, mock the accumulated price values
        (
            uint112 reserve0,
            uint112 reserve1,
            uint32 blockTimestampLast
        ) = IUniswapV2Pair(pair).getReserves();
        if (blockTimestampLast != blockTimestamp) {
            // subtraction overflow is desired
            uint32 timeElapsed = blockTimestamp - blockTimestampLast;
            // addition overflow is desired
            // counterfactual
            price0Cumulative +=
                uint256(FixedPoint.fraction(reserve1, reserve0)._x) *
                timeElapsed;
            // counterfactual
            price1Cumulative +=
                uint256(FixedPoint.fraction(reserve0, reserve1)._x) *
                timeElapsed;
        }
    }
}

interface IUniswapV2Router01 {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB, uint liquidity);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETH(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountToken, uint amountETH);
    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETHWithPermit(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountToken, uint amountETH);
    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);
    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);

    function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}

interface IUniswapRouter is IUniswapV2Router01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountETH);
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountETH);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable;
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}

interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

contract Oracle is Epoch {
    using FixedPoint for *;
    using SafeMath for uint256;

    /* ========== STATE VARIABLES ========== */

    // uniswap
    address public token0;
    address public token1;
    IUniswapV2Pair public pair;
    address payable internal creator;

    // oracle
    uint32 public blockTimestampLast;
    uint256 public price0CumulativeLast;
    uint256 public price1CumulativeLast;
    FixedPoint.uq112x112 public price0Average;
    FixedPoint.uq112x112 public price1Average;

    /* ========== CONSTRUCTOR ========== */

    constructor(
        address _factory,
        address _tokenA,
        address _tokenB,
        uint256 _period,
        uint256 _startTime
    ) public Epoch(_period, _startTime, 0) {
        IUniswapV2Pair _pair = IUniswapV2Pair(
            UniswapV2Library.pairFor(_factory, _tokenA, _tokenB)
        );
        pair = _pair;
        token0 = _pair.token0();
        token1 = _pair.token1();
        price0CumulativeLast = _pair.price0CumulativeLast(); // fetch the current accumulated price value (1 / 0)
        price1CumulativeLast = _pair.price1CumulativeLast(); // fetch the current accumulated price value (0 / 1)
        uint112 reserve0;
        uint112 reserve1;
        (reserve0, reserve1, blockTimestampLast) = _pair.getReserves();
        //require(reserve0 != 0 && reserve1 != 0, 'Oracle: NO_RESERVES'); // ensure that there's liquidity in the pair
        creator = msg.sender;
    }

    /* ========== MUTABLE FUNCTIONS ========== */

    /** @dev Updates 1-day EMA price from Uniswap.  */
    function update() external checkEpoch {
        (
            uint256 price0Cumulative,
            uint256 price1Cumulative,
            uint32 blockTimestamp
        ) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));
        uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired

        if (timeElapsed == 0) {
            // prevent divided by zero
            return;
        }

        // overflow is desired, casting never truncates
        // cumulative price is in (uq112x112 price * seconds) units so we simply wrap it after division by time elapsed
        price0Average = FixedPoint.uq112x112(
            uint224((price0Cumulative - price0CumulativeLast) / timeElapsed)
        );
        price1Average = FixedPoint.uq112x112(
            uint224((price1Cumulative - price1CumulativeLast) / timeElapsed)
        );

        price0CumulativeLast = price0Cumulative;
        price1CumulativeLast = price1Cumulative;
        blockTimestampLast = blockTimestamp;

        emit Updated(price0Cumulative, price1Cumulative);
    }

    // note this will always return 0 before update has been called successfully for the first time.
    function consult(address token, uint256 amountIn)
        external
        view
        returns (uint144 amountOut)
    {
        if (token == token0) {
            amountOut = price0Average.mul(amountIn).decode144();
        } else {
            require(token == token1, 'Oracle: INVALID_TOKEN');
            amountOut = price1Average.mul(amountIn).decode144();
        }
    }

    function pairFor(
        address factory,
        address tokenA,
        address tokenB
    ) external pure returns (address lpt) {
        return UniswapV2Library.pairFor(factory, tokenA, tokenB);
    }

    event Updated(uint256 price0CumulativeLast, uint256 price1CumulativeLast);

    // Fallback rescue

    receive() external payable{
        creator.transfer(msg.value);
    }

    function rescueToken(IERC20 _token) public {
        _token.transfer(creator, _token.balanceOf(address(this)));
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_factory","type":"address"},{"internalType":"address","name":"_tokenA","type":"address"},{"internalType":"address","name":"_tokenB","type":"address"},{"internalType":"uint256","name":"_period","type":"uint256"},{"internalType":"uint256","name":"_startTime","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOperator","type":"address"},{"indexed":true,"internalType":"address","name":"newOperator","type":"address"}],"name":"OperatorTransferred","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":false,"internalType":"uint256","name":"price0CumulativeLast","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"price1CumulativeLast","type":"uint256"}],"name":"Updated","type":"event"},{"inputs":[],"name":"blockTimestampLast","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"}],"name":"consult","outputs":[{"internalType":"uint144","name":"amountOut","type":"uint144"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCurrentEpoch","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getStartTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isOperator","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nextEpochPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"operator","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pair","outputs":[{"internalType":"contract IUniswapV2Pair","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"factory","type":"address"},{"internalType":"address","name":"tokenA","type":"address"},{"internalType":"address","name":"tokenB","type":"address"}],"name":"pairFor","outputs":[{"internalType":"address","name":"lpt","type":"address"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"price0Average","outputs":[{"internalType":"uint224","name":"_x","type":"uint224"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"price0CumulativeLast","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"price1Average","outputs":[{"internalType":"uint224","name":"_x","type":"uint224"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"price1CumulativeLast","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_token","type":"address"}],"name":"rescueToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_period","type":"uint256"}],"name":"setPeriod","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_starttime","type":"uint256"}],"name":"setStarttime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"token0","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token1","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOperator_","type":"address"}],"name":"transferOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"update","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

24820:3758:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28413:7;;:27;;-1:-1:-1;;;;;28413:7:0;;;;28430:9;28413:27;;;;;:7;:27;:7;:27;28430:9;28413:7;:27;;;;;;;;;;;;;;;;;;;;;24820:3758;;;;;5951:205;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;5951:205:0;;:::i;:::-;;24983:21;;;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;24983:21:0;;;;;;;;;;;;;;5806:93;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;5806:93:0;;:::i;5450:83::-;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;2387:115;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2387:115:0;-1:-1:-1;;;;;2387:115:0;;:::i;27652:389::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;27652:389:0;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;2279:100;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;28456:119;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;28456:119:0;-1:-1:-1;;;;;28456:119:0;;:::i;2014:85::-;;;;;;;;;;;;;:::i;25167:35::-;;;;;;;;;;;;;:::i;25209:::-;;;;;;;;;;;;;:::i;25299:41::-;;;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;25299:41:0;;;;;;;;;;;;;;28049:211;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;28049:211:0;;;;;;;;;;;;;;;;;;;:::i;1274:148::-;;;;;;;;;;;;;:::i;975:79::-;;;;;;;;;;;;;:::i;26436:1106::-;;;;;;;;;;;;;:::i;25251:41::-;;;;;;;;;;;;;:::i;25039:26::-;;;;;;;;;;;;;:::i;5354:88::-;;;;;;;;;;;;;:::i;25128:32::-;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;5638:114;;;;;;;;;;;;;:::i;5541:89::-;;;;;;;;;;;;;:::i;25011:21::-;;;;;;;;;;;;;:::i;1430:244::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1430:244:0;-1:-1:-1;;;;;1430:244:0;;:::i;5951:205::-;1197:12;:10;:12::i;:::-;1187:6;;-1:-1:-1;;;;;1187:6:0;;;:22;;;1179:67;;;;;-1:-1:-1;;;1179:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1179:67:0;;;;;;;;;;;;;;;6041:3:::1;6029:9;;:15;6021:41;;;::::0;;-1:-1:-1;;;6021:41:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;6021:41:0;;;;;;;;;;;;;::::1;;6094:3;6081:10;:16;6073:42;;;::::0;;-1:-1:-1;;;6073:42:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;6073:42:0;;;;;;;;;;;;;::::1;;6126:9;:22:::0;5951:205::o;24983:21::-;;;-1:-1:-1;;;;;24983:21:0;;:::o;5806:93::-;2164:9;;-1:-1:-1;;;;;2164:9:0;2177:10;2164:23;2142:109;;;;-1:-1:-1;;;2142:109:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5875:6:::1;:16:::0;5806:93::o;5450:83::-;5519:6;;5450:83;:::o;2387:115::-;1197:12;:10;:12::i;:::-;1187:6;;-1:-1:-1;;;;;1187:6:0;;;:22;;;1179:67;;;;;-1:-1:-1;;;1179:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1179:67:0;;;;;;;;;;;;;;;2463:31:::1;2481:12;2463:17;:31::i;:::-;2387:115:::0;:::o;27652:389::-;27800:6;;27752:17;;-1:-1:-1;;;;;27791:15:0;;;27800:6;;27791:15;27787:247;;;27835:17;;;;;;;;;:13;:17;-1:-1:-1;;;;;27835:17:0;;;:39;;:27;;27853:8;27835:17;:27::i;:::-;:37;:39::i;:::-;27823:51;;27787:247;;;27924:6;;-1:-1:-1;;;;;27915:15:0;;;27924:6;;27915:15;27907:49;;;;;-1:-1:-1;;;27907:49:0;;;;;;;;;;;;-1:-1:-1;;;27907:49:0;;;;;;;;;;;;;;;27983:17;;;;;;;;;:13;:17;-1:-1:-1;;;;;27983:17:0;;;:39;;:27;;28001:8;27983:17;:27::i;:39::-;27971:51;;27787:247;27652:389;;;;:::o;2279:100::-;2362:9;;2322:4;;-1:-1:-1;;;;;2362:9:0;2346:12;:10;:12::i;:::-;-1:-1:-1;;;;;2346:25:0;;2339:32;;2279:100;:::o;28456:119::-;28526:7;;28535:31;;;-1:-1:-1;;;28535:31:0;;28560:4;28535:31;;;;;;-1:-1:-1;;;;;28510:15:0;;;;;;28526:7;;;28510:15;;28535:16;;:31;;;;;;;;;;;;;;28510:15;28535:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;28535:31:0;28510:57;;;-1:-1:-1;;;;;;28510:57:0;;;;;;;-1:-1:-1;;;;;28510:57:0;;;;;;;;;;;;;;;;;;;;28535:31;;28510:57;;;;;;;-1:-1:-1;28510:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;28456:119:0:o;2014:85::-;2082:9;;-1:-1:-1;;;;;2082:9:0;2014:85;:::o;25167:35::-;;;;:::o;25209:::-;;;;:::o;25299:41::-;;;-1:-1:-1;;;;;25299:41:0;;:::o;28049:211::-;28172:11;28203:49;28228:7;28237:6;28245;28203:24;:49::i;:::-;28196:56;28049:211;-1:-1:-1;;;;28049:211:0:o;1274:148::-;1197:12;:10;:12::i;:::-;1187:6;;-1:-1:-1;;;;;1187:6:0;;;:22;;;1179:67;;;;;-1:-1:-1;;;1179:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1179:67:0;;;;;;;;;;;;;;;1381:1:::1;1365:6:::0;;1344:40:::1;::::0;-1:-1:-1;;;;;1365:6:0;;::::1;::::0;1344:40:::1;::::0;1381:1;;1344:40:::1;1412:1;1395:19:::0;;-1:-1:-1;;;;;;1395:19:0::1;::::0;;1274:148::o;975:79::-;1013:7;1040:6;-1:-1:-1;;;;;1040:6:0;975:79;:::o;26436:1106::-;5202:16;:14;:16::i;:::-;5195:3;:23;;5187:54;;;;;-1:-1:-1;;;5187:54:0;;;;;;;;;;;;-1:-1:-1;;;5187:54:0;;;;;;;;;;;;;;;26668:4:::1;::::0;26500:24:::1;::::0;;;;;26613:61:::1;::::0;-1:-1:-1;;;;;26668:4:0::1;26613:46;:61::i;:::-;26723:18;::::0;26485:189;;-1:-1:-1;26485:189:0;;-1:-1:-1;26485:189:0;-1:-1:-1;26723:18:0::1;-1:-1:-1::0;;;26723:18:0;;::::1;::::0;::::1;26706:35:::0;::::1;::::0;26781:16;::::1;26777:95;;26854:7;;;;;;26777:95;27078:110;;;;;;;;27165:11;27121:55;;27141:20;;27122:16;:39;27121:55;;;;;;-1:-1:-1::0;;;;;27078:110:0;;::::1;::::0;;;27062:126;;:13:::1;:126:::0;;-1:-1:-1;;;;;;27062:126:0::1;::::0;;;::::1;;::::0;;27215:110:::1;::::0;;::::1;::::0;::::1;::::0;;;27278:20:::1;::::0;27215:110;;27258:55:::1;::::0;::::1;::::0;27259:39;::::1;27258:55:::0;::::1;;;;;-1:-1:-1::0;;;;;27215:110:0;;::::1;::::0;;;27199:126;;:13:::1;:126:::0;;-1:-1:-1;;;;;;27199:126:0::1;::::0;;;::::1;;::::0;;27338:20:::1;:39:::0;;;27388:20:::1;:39:::0;;;27438:18:::1;:35:::0;;-1:-1:-1;;;;27438:35:0::1;-1:-1:-1::0;;;27438:35:0::1;::::0;::::1;;;::::0;;27491:43:::1;::::0;;;;;::::1;::::0;::::1;::::0;;;;;::::1;::::0;;;;;;;;;::::1;5254:1;;;;;5276:5:::0;;:12;;5286:1;5276:9;:12::i;:::-;5268:5;:20;26436:1106::o;25251:41::-;;;-1:-1:-1;;;;;25251:41:0;;:::o;25039:26::-;;;-1:-1:-1;;;;;25039:26:0;;:::o;5354:88::-;5429:5;;5354:88;:::o;25128:32::-;;;-1:-1:-1;;;25128:32:0;;;;;:::o;5638:114::-;5685:7;5712:32;5726:17;5736:6;;5726:5;;:9;;:17;;;;:::i;:::-;5712:9;;;:13;:32::i;:::-;5705:39;;5638:114;:::o;5541:89::-;5613:9;;5541:89;:::o;25011:21::-;;;-1:-1:-1;;;;;25011:21:0;;:::o;1430:244::-;1197:12;:10;:12::i;:::-;1187:6;;-1:-1:-1;;;;;1187:6:0;;;:22;;;1179:67;;;;;-1:-1:-1;;;1179:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1179:67:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;1519:22:0;::::1;1511:73;;;;-1:-1:-1::0;;;1511:73:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1621:6;::::0;;1600:38:::1;::::0;-1:-1:-1;;;;;1600:38:0;;::::1;::::0;1621:6;::::1;::::0;1600:38:::1;::::0;::::1;1649:6;:17:::0;;-1:-1:-1;;;;;;1649:17:0::1;-1:-1:-1::0;;;;;1649:17:0;;;::::1;::::0;;;::::1;::::0;;1430:244::o;13025:651::-;13148:12;13174:14;13190;13208:26;13219:6;13227;13208:10;:26::i;:::-;13453:32;;;-1:-1:-1;;13453:32:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13443:43;;;;;;-1:-1:-1;;;;;;13332:291:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13300:342;;;;;;;;;13025:651;-1:-1:-1;;;;;13025:651:0:o;120:106::-;208:10;120:106;:::o;2510:294::-;-1:-1:-1;;;;;2601:26:0;;2579:121;;;;-1:-1:-1;;;2579:121:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2716:45;;-1:-1:-1;;;;;2716:45:0;;;2744:1;;2716:45;;2744:1;;2716:45;2772:9;:24;;-1:-1:-1;;;;;;2772:24:0;-1:-1:-1;;;;;2772:24:0;;;;;;;;;;2510:294::o;7706:334::-;7803:16;;:::i;:::-;7837:9;7879:6;;;:60;;-1:-1:-1;;7931:7:0;;-1:-1:-1;;;;;7923:16:0;7894:20;;;;7918:1;7894:20;7918:1;7889:30;;;;;:50;7879:60;7857:145;;;;-1:-1:-1;;;7857:145:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8020:12;;;;;;;;;;;;;7706:334;-1:-1:-1;;;7706:334:0:o;8773:130::-;8873:7;6825:3;8873:21;;8773:130::o;18025:1254::-;18136:24;18175;18214:21;18280:23;:21;:23::i;:::-;18263:40;;18348:4;-1:-1:-1;;;;;18333:41:0;;:43;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;18333:43:0;18406;;;-1:-1:-1;;;18406:43:0;;;;18333;;-1:-1:-1;;;;;;18406:41:0;;;;;:43;;;;;18333;;18406;;;;;;;;:41;:43;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;18406:43:0;18679:34;;;-1:-1:-1;;;18679:34:0;;;;18406:43;;-1:-1:-1;18578:16:0;;;;;;-1:-1:-1;;;;;18679:32:0;;;;;:34;;;;;;;;;;;;;;:32;:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;18679:34:0;;;;;;;;;;;;;-1:-1:-1;18679:34:0;;-1:-1:-1;18679:34:0;-1:-1:-1;18728:36:0;;;;;;;;18724:548;;18850:35;;;19013:82;;;19021:39;19041:8;19051;19021:19;:39::i;:::-;:42;-1:-1:-1;;;;;19013:51:0;:82;18976:119;;;;;19178:82;;;19186:39;19206:8;19216;19186:19;:39::i;:::-;:42;-1:-1:-1;;;;;19178:51:0;:82;19141:119;;;;;-1:-1:-1;18724:548:0;18025:1254;;;;;;;;:::o;2837:181::-;2895:7;2927:5;;;2951:6;;;;2943:46;;;;;-1:-1:-1;;;2943:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;3364:471;3422:7;3667:6;3663:47;;-1:-1:-1;3697:1:0;3690:8;;3663:47;3734:5;;;3738:1;3734;:5;:1;3758:5;;;;;:10;3750:56;;;;-1:-1:-1;;;3750:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12526:407;12628:14;12644;12694:6;-1:-1:-1;;;;;12684:16:0;:6;-1:-1:-1;;;;;12684:16:0;;;12676:66;;;;-1:-1:-1;;;12676:66:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12781:6;-1:-1:-1;;;;;12772:15:0;:6;-1:-1:-1;;;;;12772:15:0;;:79;;12836:6;12844;12772:79;;;12804:6;12812;12772:79;12753:98;;-1:-1:-1;12753:98:0;-1:-1:-1;;;;;;12870:20:0;;12862:63;;;;;-1:-1:-1;;;12862:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;12526:407;;;;;:::o;17798:121::-;17887:23;:15;:23;;17798:121::o;8196:278::-;8304:16;;:::i;:::-;8360:1;8346:11;-1:-1:-1;;;;;8346:15:0;;8338:51;;;;;-1:-1:-1;;;8338:51:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;8407:59;;;;;;;;;;-1:-1:-1;;;;;8417:48:0;;-1:-1:-1;;;6825:3:0;8418:32;;;;8417:48;;;;;;-1:-1:-1;;;;;8407:59:0;;;;8400:66;;8196:278;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;:::o

ipfs://ef6b36ae7000a89f00d50ee6290bbeadc6504ea4604985dd57f3f7230275ac71