Contract 0x274b23d3b6d122CB47ECc11F73b1973eB60E4e0f

Txn Hash Method
Block
From
To
Value [Txn Fee]
0x259bc1cac4ec0c4e16aab25caae32da3c496e56fa790c35b390505a38172470cTaker Withdraw119408892022-03-10 17:45:11199 days 21 hrs agoHakuSwap: Deployer IN  0x274b23d3b6d122cb47ecc11f73b1973eb60e4e0f0 AVAX0.002321900304 28.005744978
0x4225ee9decec86bee378122513d075f0afba8265fe9f0549e2b25de7ead76d49Taker Withdraw118778732022-03-09 6:19:47201 days 9 hrs ago0xd14c826ed68fc8ffe67527394f90204d00660982 IN  0x274b23d3b6d122cb47ecc11f73b1973eb60e4e0f0 AVAX0.001554013 26.5
0x03076d33c3661a7d881d3551cfac368ece0baef18f6f77bff61367b844122c9aTaker Withdraw116770072022-03-04 13:53:11206 days 1 hr ago0x04a86c3a0dfd761f447cc5fd5590ea9fd253e48e IN  0x274b23d3b6d122cb47ecc11f73b1973eb60e4e0f0 AVAX0.00262511136 44.765038028
0x02662c7f5ef06ad7a8eb122ae57f77b18a798e4947d13d9fe59b4fd861fb6169Taker Withdraw116768862022-03-04 13:49:09206 days 1 hr ago0x04a86c3a0dfd761f447cc5fd5590ea9fd253e48e IN  0x274b23d3b6d122cb47ecc11f73b1973eb60e4e0f0 AVAX0.002747291411 46.848528561
0x896aec900db5d868cfb246d495725437806102e660efda93d06be236692dcafdTaker Withdraw116147552022-03-03 3:12:43207 days 12 hrs ago0xb976d74fcf48704602e7a2b28a674629c1bc36a2 IN  0x274b23d3b6d122cb47ecc11f73b1973eb60e4e0f0 AVAX0.001918058274 32.707927336
0xf65330741dc5bfead344487acfc399fb504eea91b6fceaa2d2911c9f7581fdbbTaker Withdraw115782772022-03-02 6:46:58208 days 8 hrs ago0xa01d539e7b8c25bdc97a8f243e33f55f5a6c7558 IN  0x274b23d3b6d122cb47ecc11f73b1973eb60e4e0f0 AVAX0.001600382401 27.290719982
0x11e075b4850f7ce57181e242fdd9e7ad3e9df4563743de19b8b0861ed61a8821Taker Withdraw115063782022-02-28 13:44:28210 days 1 hr ago0xf1a3eda0f7867a9aa4efbd3b7e318a25b5522d3e IN  0x274b23d3b6d122cb47ecc11f73b1973eb60e4e0f0 AVAX0.00255273425343.530818411
0xa4e8bf643593f61c0fbd7864eb15de8c8f4e573ea18f69b1480640dea6a9ce3fTaker Withdraw113387152022-02-24 14:48:21214 days 35 mins ago0x9a456152e0da127c30a49357a461f4c3f80bd630 IN  0x274b23d3b6d122cb47ecc11f73b1973eb60e4e0f0 AVAX0.002637614737 44.978253429
0xa1b37e3bb6f12157d4461efba376adc488ac961cb2d968e2b94ce2157a00b3aaTaker Withdraw112411142022-02-22 7:27:04216 days 7 hrs ago0x2f6b67a9e7ca9f025b786e455261efe3c65ff7e8 IN  0x274b23d3b6d122cb47ecc11f73b1973eb60e4e0f0 AVAX0.0014660525
0x5a7a3f410f3b6b5a280d9990216b6b43a9a3f7d5ac5dd9489b4f2a6a598ce19bTaker Withdraw111775772022-02-20 19:26:36217 days 19 hrs ago0xe4b5d02e53b064c29b8e507d5926cbaa79a08cda IN  0x274b23d3b6d122cb47ecc11f73b1973eb60e4e0f0 AVAX0.004231416457 72.15675553
0xd8aa1d7b5697dd04177cd94a4c86dde03fbab760a8225353677ed19357ef5408Taker Withdraw111761042022-02-20 18:35:26217 days 20 hrs ago0x27df6a45a1f5a4955194ae025c110054f8b74bc5 IN  0x274b23d3b6d122cb47ecc11f73b1973eb60e4e0f0 AVAX0.003144257061 53.617834684
0x57dbff6627973016facdec7bdbf81bb8c94d9cef8ef499c7789dad85c28ee895Taker Withdraw111470492022-02-20 2:19:31218 days 13 hrs ago0x27df6a45a1f5a4955194ae025c110054f8b74bc5 IN  0x274b23d3b6d122cb47ecc11f73b1973eb60e4e0f0 AVAX0.001559593703 26.595165648
0x51f6626b400747652a43ae56fc5dda396a9d6eea613dd6e505b83709cf286918Taker Withdraw111258772022-02-19 14:19:46219 days 1 hr ago0xbf0fdffb623f54c52a5e2079d931ee5a14c516e1 IN  0x274b23d3b6d122cb47ecc11f73b1973eb60e4e0f0 AVAX0.002610928827 44.523188634
0x4a9387a10ba70b2bdd3f1fbe3951bc3e96d8611c60fa36abd8d17006b322e2d1Owner Withdraw110790532022-02-18 12:03:43220 days 3 hrs agoHakuSwap: Deployer IN  0x274b23d3b6d122cb47ecc11f73b1973eb60e4e0f0 AVAX0.001527134392 25.259008464
0x3ba1f49078e10349c4d7b15494783c9dc4acc312510d5dce72499d1e89a48fd7Taker Withdraw110734732022-02-18 8:55:45220 days 6 hrs ago0x0f81a489248e180be6ad9cecadd5686443527410 IN  0x274b23d3b6d122cb47ecc11f73b1973eb60e4e0f0 AVAX0.001554013 26.5
0xaadea1e105562ca26a37e4cf86f697dda15936c9d18e4f7f920c4e0bdcb4e09fTaker Withdraw109768362022-02-16 2:00:10222 days 13 hrs ago0xb51130b6a0244fa111916d51dec83c2533f24b09 IN  0x274b23d3b6d122cb47ecc11f73b1973eb60e4e0f0 AVAX0.001694167088 28.889995022
0x71e629729c16c5d1791f5cb9a6a641f94febd3b59f468fcaa913156b6ad689bcTaker Withdraw109497482022-02-15 10:33:26223 days 4 hrs ago0xd227acd2a47766767a195020e926317ac65abba0 IN  0x274b23d3b6d122cb47ecc11f73b1973eb60e4e0f0 AVAX0.001554013 26.5
0xbb7689c111f785717ee8a5ad2ebebd31c06bf91f34c531121e42513e1d17a1e0Taker Withdraw108952622022-02-14 4:11:14224 days 11 hrs ago0x1c8bf1d0c78653ec49d621a83716d11deff355ba IN  0x274b23d3b6d122cb47ecc11f73b1973eb60e4e0f0 AVAX0.001554013 26.5
0xac37347eab256fe9d7f30f989376b1fe794ff4edf2ab0e1b2c08bb92f0c066a4Taker Withdraw108702812022-02-13 14:05:54225 days 1 hr ago0xb203f3321d6d621af67ee93333747ae602eb3326 IN  0x274b23d3b6d122cb47ecc11f73b1973eb60e4e0f0 AVAX0.001530556226.1
0x63e9fe4d35ae34616a4b03d0953b99ca423bc1b9a9dac16de36e42323269a93dTaker Withdraw108438012022-02-12 23:28:58225 days 15 hrs ago0x06eda89c6511ecba01e925b51a3c8f99693e3700 IN  0x274b23d3b6d122cb47ecc11f73b1973eb60e4e0f0 AVAX0.001530556226.1
0x8eccd896894ff755539abac04a0c02dac2d7eb8b10a3ab35e3b5bf32549f7123Taker Withdraw108399462022-02-12 21:18:03225 days 18 hrs ago0xaec4a7621bea9f03b9a893d61e6e6ea91b33c395 IN  0x274b23d3b6d122cb47ecc11f73b1973eb60e4e0f0 AVAX0.001554013 26.5
0xdd7ba1937a9a11c446526792882bc5f1c37464c63a2e1c57b07342abfc2538c4Taker Withdraw108322742022-02-12 17:08:57225 days 22 hrs ago0x1ac747cc76d9b1f00bc5eec5482fc0a75acb7551 IN  0x274b23d3b6d122cb47ecc11f73b1973eb60e4e0f0 AVAX0.0043981575
0x82458c01257a6d8fc8ca74282d18b7232063fd88f5c3099fceec37b4d63e76f5Taker Withdraw108188622022-02-12 10:02:37226 days 5 hrs ago0xd6e1cc48edbf11571ce7738dc5612636aee83086 IN  0x274b23d3b6d122cb47ecc11f73b1973eb60e4e0f0 AVAX0.001530556226.1
0xe849bc6c28d62b4c8a2826128ad6320e4a52503ea3f3f2fceca8f2c9264d0fedTaker Withdraw108164042022-02-12 8:44:54226 days 6 hrs ago0x4aade9ef175a61e008473ee8965eb6754f41c213 IN  0x274b23d3b6d122cb47ecc11f73b1973eb60e4e0f0 AVAX0.001554013 26.5
0x55c4afdd728afb94d9c5e0e58a5087ca273564f0646c0cba016f7db18e936651Taker Withdraw108117112022-02-12 6:17:12226 days 9 hrs ago0x7dadc62b3af80601df0c59444c851743c50bd782 IN  0x274b23d3b6d122cb47ecc11f73b1973eb60e4e0f0 AVAX0.001554013 26.5
[ Download CSV Export 
Parent Txn Hash Block From To Value
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
SwapMining

Compiler Version
v0.6.12+commit.27d51765

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at snowtrace.io on 2022-01-14
*/

// File: contracts/libraries/EnumerableSet.sol

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

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

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

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

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

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

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

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

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

            bytes32 lastvalue = set._values[lastIndex];

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

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

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

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

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

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

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

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

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

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

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

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

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


    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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

// File: contracts/libraries/SafeMath.sol


pragma solidity >=0.4.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;
    }

    function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
        z = x < y ? x : y;
    }

    // babylonian method (https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method)
    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;
        }
    }
}

// File: contracts/interfaces/IHakuswapFactory.sol


pragma solidity >=0.5.0;

interface IHakuswapFactory {
    event PairCreated(address indexed token0, address indexed token1, address pair, uint);

    function feeTo() external view returns (address);
    function feeToSetter() external view returns (address);

    function getPair(address tokenA, address tokenB) external view returns (address pair);
    function expectPairFor(address token0, address token1) external view returns (address);
    function allPairs(uint) external view returns (address pair);
    function allPairsLength() external view returns (uint);

    function createPair(address tokenA, address tokenB) external returns (address pair);

    function setFeeTo(address) external;
    function setFeeToSetter(address) external;
}

// File: contracts/interfaces/IHakuswapPair.sol


pragma solidity >=0.5.0;

interface IHakuswapPair {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint 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 (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint 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 (uint);

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

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

    function MINIMUM_LIQUIDITY() external pure returns (uint);
    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 (uint);
    function price1CumulativeLast() external view returns (uint);
    function kLast() external view returns (uint);

    function mint(address to) external returns (uint liquidity);
    function burn(address to) external returns (uint amount0, uint amount1);
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
    function skim(address to) external;
    function sync() external;

    function initialize(address, address) external;
}

// File: contracts/libraries/HakuswapLibrary.sol


pragma solidity >=0.5.0;




library HakuswapLibrary {
    using SafeMath for uint;

    // 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, 'HakuswapLibrary: IDENTICAL_ADDRESSES');
        (token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
        require(token0 != address(0), 'HakuswapLibrary: 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(uint(keccak256(abi.encodePacked(
                hex'ff',
                factory,
                keccak256(abi.encodePacked(token0, token1)),
                hex'f0a389c88c385a3fa20755278000aabbe86028f1b77659475569f3575b2aebe3' // init code hash
            ))));
    }

    // fetches and sorts the reserves for a pair
    function getReserves(address factory, address tokenA, address tokenB) internal view returns (uint reserveA, uint reserveB) {
        (address token0,) = sortTokens(tokenA, tokenB);
        pairFor(factory, tokenA, tokenB);
        (uint reserve0, uint reserve1,) = IHakuswapPair(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(uint amountA, uint reserveA, uint reserveB) internal pure returns (uint amountB) {
        require(amountA > 0, 'HakuswapLibrary: INSUFFICIENT_AMOUNT');
        require(reserveA > 0 && reserveB > 0, 'HakuswapLibrary: 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(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut) {
        require(amountIn > 0, 'HakuswapLibrary: INSUFFICIENT_INPUT_AMOUNT');
        require(reserveIn > 0 && reserveOut > 0, 'HakuswapLibrary: INSUFFICIENT_LIQUIDITY');
        uint amountInWithFee = amountIn.mul(998);
        uint numerator = amountInWithFee.mul(reserveOut);
        uint 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(uint amountOut, uint reserveIn, uint reserveOut) internal pure returns (uint amountIn) {
        require(amountOut > 0, 'HakuswapLibrary: INSUFFICIENT_OUTPUT_AMOUNT');
        require(reserveIn > 0 && reserveOut > 0, 'HakuswapLibrary: INSUFFICIENT_LIQUIDITY');
        uint numerator = reserveIn.mul(amountOut).mul(1000);
        uint denominator = reserveOut.sub(amountOut).mul(998);
        amountIn = (numerator / denominator).add(2);
    }

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

// File: contracts/interfaces/IERC20.sol


pragma solidity >=0.4.0;

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

    /**
     * @dev Returns the token decimals.
     */
    function decimals() external view returns (uint8);

    /**
     * @dev Returns the token symbol.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the token name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the bep token owner.
     */
    function getOwner() external view returns (address);

    /**
     * @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: contracts/libraries/Context.sol


pragma solidity >=0.6.0 <0.8.0;

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

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

// File: contracts/libraries/Ownable.sol


pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract 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 virtual 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: contracts/libraries/Address.sol


pragma solidity >=0.6.6;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly {
            codehash := extcodehash(account)
        }
        return (codehash != accountHash && codehash != 0x0);
    }

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

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

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

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

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

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

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

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

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

// File: contracts/token/ERC20.sol


pragma solidity >=0.4.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, Ownable {
    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 bep token owner.
     */
    function getOwner() external override view returns (address) {
        return owner();
    }

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

    /**
     * @dev Returns the token decimals.
     */
    function decimals() public override view returns (uint8) {
        return _decimals;
    }

    /**
     * @dev Returns the token symbol.
     */
    function symbol() public override view returns (string memory) {
        return _symbol;
    }

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

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

    /**
     * @dev See {ERC20-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 {ERC20-allowance}.
     */
    function allowance(address owner, address spender) public override view returns (uint256) {
        return _allowances[owner][spender];
    }

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

    /**
     * @dev See {ERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20};
     *
     * Requirements:
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for `sender`'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public 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 {ERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public 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 {ERC20-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 returns (bool) {
        _approve(
            _msgSender(),
            spender,
            _allowances[_msgSender()][spender].sub(subtractedValue, 'ERC20: decreased allowance below zero')
        );
        return true;
    }

    /**
     * @dev Creates `amount` tokens and assigns them to `msg.sender`, increasing
     * the total supply.
     *
     * Requirements
     *
     * - `msg.sender` must be the token owner
     */
    function mint(uint256 amount) public virtual onlyOwner returns (bool) {
        _mint(_msgSender(), amount);
        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 {
        require(sender != address(0), 'ERC20: transfer from the zero address');
        require(recipient != address(0), 'ERC20: transfer to the zero address');

        _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 {
        require(account != address(0), 'ERC20: mint to the zero address');

        _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 {
        require(account != address(0), 'ERC20: burn from the zero address');

        _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 is internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal {
        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 Destroys `amount` tokens from `account`.`amount` is then deducted
     * from the caller's allowance.
     *
     * See {_burn} and {_approve}.
     */
    function _burnFrom(address account, uint256 amount) internal {
        _burn(account, amount);
        _approve(
            account,
            _msgSender(),
            _allowances[account][_msgSender()].sub(amount, 'ERC20: burn amount exceeds allowance')
        );
    }
}

// File: contracts/token/HakuToken.sol


pragma solidity >0.6.6;


// HakuToken with Governance.
contract HakuToken is ERC20('HakuSwap Token', 'HAKU') {
    using SafeMath for uint256;
    /// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
    function mintFor(address _to, uint256 _amount) public onlyOwner {
        _mint(_to, _amount);
        _moveDelegates(address(0), _delegates[_to], _amount);
    }

    function mint(uint256 amount) public override onlyOwner returns (bool) {
        _mint(_msgSender(), amount);
        return true;
    }

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

    mapping (address => address) internal _delegates;

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

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

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

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

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

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

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

    event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);

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

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

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

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

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

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

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

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

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

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

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

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

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

        emit DelegateChanged(delegator, currentDelegate, delegatee);

        _moveDelegates(currentDelegate, delegatee, delegatorBalance);
    }

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

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

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

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

        emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
    }

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

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

// File: hardhat/console.sol

pragma solidity >= 0.4.22 <0.9.0;

library console {
	address constant CONSOLE_ADDRESS = address(0x000000000000000000636F6e736F6c652e6c6f67);

	function _sendLogPayload(bytes memory payload) private view {
		uint256 payloadLength = payload.length;
		address consoleAddress = CONSOLE_ADDRESS;
		assembly {
			let payloadStart := add(payload, 32)
			let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)
		}
	}

	function log() internal view {
		_sendLogPayload(abi.encodeWithSignature("log()"));
	}

	function logInt(int p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(int)", p0));
	}

	function logUint(uint p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint)", p0));
	}

	function logString(string memory p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string)", p0));
	}

	function logBool(bool p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
	}

	function logAddress(address p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address)", p0));
	}

	function logBytes(bytes memory p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes)", p0));
	}

	function logBytes1(bytes1 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes1)", p0));
	}

	function logBytes2(bytes2 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes2)", p0));
	}

	function logBytes3(bytes3 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes3)", p0));
	}

	function logBytes4(bytes4 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes4)", p0));
	}

	function logBytes5(bytes5 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes5)", p0));
	}

	function logBytes6(bytes6 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes6)", p0));
	}

	function logBytes7(bytes7 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes7)", p0));
	}

	function logBytes8(bytes8 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes8)", p0));
	}

	function logBytes9(bytes9 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes9)", p0));
	}

	function logBytes10(bytes10 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes10)", p0));
	}

	function logBytes11(bytes11 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes11)", p0));
	}

	function logBytes12(bytes12 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes12)", p0));
	}

	function logBytes13(bytes13 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes13)", p0));
	}

	function logBytes14(bytes14 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes14)", p0));
	}

	function logBytes15(bytes15 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes15)", p0));
	}

	function logBytes16(bytes16 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes16)", p0));
	}

	function logBytes17(bytes17 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes17)", p0));
	}

	function logBytes18(bytes18 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes18)", p0));
	}

	function logBytes19(bytes19 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes19)", p0));
	}

	function logBytes20(bytes20 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes20)", p0));
	}

	function logBytes21(bytes21 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes21)", p0));
	}

	function logBytes22(bytes22 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes22)", p0));
	}

	function logBytes23(bytes23 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes23)", p0));
	}

	function logBytes24(bytes24 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes24)", p0));
	}

	function logBytes25(bytes25 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes25)", p0));
	}

	function logBytes26(bytes26 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes26)", p0));
	}

	function logBytes27(bytes27 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes27)", p0));
	}

	function logBytes28(bytes28 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes28)", p0));
	}

	function logBytes29(bytes29 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes29)", p0));
	}

	function logBytes30(bytes30 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes30)", p0));
	}

	function logBytes31(bytes31 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes31)", p0));
	}

	function logBytes32(bytes32 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0));
	}

	function log(uint p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint)", p0));
	}

	function log(string memory p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string)", p0));
	}

	function log(bool p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
	}

	function log(address p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address)", p0));
	}

	function log(uint p0, uint p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint)", p0, p1));
	}

	function log(uint p0, string memory p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string)", p0, p1));
	}

	function log(uint p0, bool p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool)", p0, p1));
	}

	function log(uint p0, address p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address)", p0, p1));
	}

	function log(string memory p0, uint p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint)", p0, p1));
	}

	function log(string memory p0, string memory p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1));
	}

	function log(string memory p0, bool p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool)", p0, p1));
	}

	function log(string memory p0, address p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address)", p0, p1));
	}

	function log(bool p0, uint p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint)", p0, p1));
	}

	function log(bool p0, string memory p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string)", p0, p1));
	}

	function log(bool p0, bool p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool)", p0, p1));
	}

	function log(bool p0, address p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address)", p0, p1));
	}

	function log(address p0, uint p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint)", p0, p1));
	}

	function log(address p0, string memory p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string)", p0, p1));
	}

	function log(address p0, bool p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool)", p0, p1));
	}

	function log(address p0, address p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address)", p0, p1));
	}

	function log(uint p0, uint p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint)", p0, p1, p2));
	}

	function log(uint p0, uint p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string)", p0, p1, p2));
	}

	function log(uint p0, uint p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool)", p0, p1, p2));
	}

	function log(uint p0, uint p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address)", p0, p1, p2));
	}

	function log(uint p0, string memory p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint)", p0, p1, p2));
	}

	function log(uint p0, string memory p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,string)", p0, p1, p2));
	}

	function log(uint p0, string memory p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool)", p0, p1, p2));
	}

	function log(uint p0, string memory p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,address)", p0, p1, p2));
	}

	function log(uint p0, bool p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint)", p0, p1, p2));
	}

	function log(uint p0, bool p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string)", p0, p1, p2));
	}

	function log(uint p0, bool p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool)", p0, p1, p2));
	}

	function log(uint p0, bool p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address)", p0, p1, p2));
	}

	function log(uint p0, address p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint)", p0, p1, p2));
	}

	function log(uint p0, address p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,string)", p0, p1, p2));
	}

	function log(uint p0, address p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool)", p0, p1, p2));
	}

	function log(uint p0, address p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,address)", p0, p1, p2));
	}

	function log(string memory p0, uint p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint)", p0, p1, p2));
	}

	function log(string memory p0, uint p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,string)", p0, p1, p2));
	}

	function log(string memory p0, uint p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool)", p0, p1, p2));
	}

	function log(string memory p0, uint p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,address)", p0, p1, p2));
	}

	function log(string memory p0, string memory p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint)", p0, p1, p2));
	}

	function log(string memory p0, string memory p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string)", p0, p1, p2));
	}

	function log(string memory p0, string memory p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2));
	}

	function log(string memory p0, string memory p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address)", p0, p1, p2));
	}

	function log(string memory p0, bool p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint)", p0, p1, p2));
	}

	function log(string memory p0, bool p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2));
	}

	function log(string memory p0, bool p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2));
	}

	function log(string memory p0, bool p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2));
	}

	function log(string memory p0, address p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint)", p0, p1, p2));
	}

	function log(string memory p0, address p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string)", p0, p1, p2));
	}

	function log(string memory p0, address p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2));
	}

	function log(string memory p0, address p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address)", p0, p1, p2));
	}

	function log(bool p0, uint p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint)", p0, p1, p2));
	}

	function log(bool p0, uint p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string)", p0, p1, p2));
	}

	function log(bool p0, uint p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool)", p0, p1, p2));
	}

	function log(bool p0, uint p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address)", p0, p1, p2));
	}

	function log(bool p0, string memory p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint)", p0, p1, p2));
	}

	function log(bool p0, string memory p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2));
	}

	function log(bool p0, string memory p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2));
	}

	function log(bool p0, string memory p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2));
	}

	function log(bool p0, bool p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint)", p0, p1, p2));
	}

	function log(bool p0, bool p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2));
	}

	function log(bool p0, bool p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2));
	}

	function log(bool p0, bool p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2));
	}

	function log(bool p0, address p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint)", p0, p1, p2));
	}

	function log(bool p0, address p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2));
	}

	function log(bool p0, address p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2));
	}

	function log(bool p0, address p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2));
	}

	function log(address p0, uint p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint)", p0, p1, p2));
	}

	function log(address p0, uint p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,string)", p0, p1, p2));
	}

	function log(address p0, uint p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool)", p0, p1, p2));
	}

	function log(address p0, uint p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,address)", p0, p1, p2));
	}

	function log(address p0, string memory p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint)", p0, p1, p2));
	}

	function log(address p0, string memory p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string)", p0, p1, p2));
	}

	function log(address p0, string memory p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2));
	}

	function log(address p0, string memory p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address)", p0, p1, p2));
	}

	function log(address p0, bool p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint)", p0, p1, p2));
	}

	function log(address p0, bool p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2));
	}

	function log(address p0, bool p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2));
	}

	function log(address p0, bool p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2));
	}

	function log(address p0, address p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint)", p0, p1, p2));
	}

	function log(address p0, address p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string)", p0, p1, p2));
	}

	function log(address p0, address p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2));
	}

	function log(address p0, address p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address)", p0, p1, p2));
	}

	function log(uint p0, uint p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,string)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,address)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,string)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,address)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,string)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,address)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,string)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,address)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,string)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,address)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,string)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,address)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,string)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,address)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,string)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,address)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,string)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,address)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,string)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,address)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,string)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,address)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,string)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,address)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,string)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,address)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,string)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,address)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,string)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,address)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,string)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address,address)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,string)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,address)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,string)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,address)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,string)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,address)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,string)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,address)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,string)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,address)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,string)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,string)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,address)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,string)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,address)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,string)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,address)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,string)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,address)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,string)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,address)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,string)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,address)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,string)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,address)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,string)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,address)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,string)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,address)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,string)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,address)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,uint)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,string)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,bool)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,address)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,uint)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,string)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,bool)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,address)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,uint)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,string)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,bool)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,address)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,uint)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,string)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,bool)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,address)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,uint)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,string)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,bool)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,address)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string,uint)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string,string)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string,bool)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,uint)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,string)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,bool)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,address)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address,uint)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address,string)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address,bool)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address,address)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,uint)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,string)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,bool)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,address)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,uint)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,string)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,bool)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,address)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,uint)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,string)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,bool)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,address)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,uint)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,string)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,bool)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,address)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,uint)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,string)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,bool)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,address)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string,uint)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string,string)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string,bool)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string,address)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,uint)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,string)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,bool)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,address)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address,uint)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address,string)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address,bool)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address,address)", p0, p1, p2, p3));
	}

}

// File: contracts/farm/SwapMining.sol


pragma solidity >=0.6.0 <0.8.0;









interface IOracle {
    function update(address tokenA, address tokenB) external;

    function consult(address tokenIn, uint amountIn, address tokenOut) external view returns (uint amountOut);
}

contract SwapMining is Ownable {
    using SafeMath for uint256;
    using EnumerableSet for EnumerableSet.AddressSet;
    EnumerableSet.AddressSet private _whitelist;

    // MDX tokens created per second
    uint256 public hakuPerSecond;
    // The block time when MDX mining starts.
    uint256 public startTime;
    // How many seconds are halved
    uint256 public halvingPeriod = 0;
    // Total allocation points
    uint256 public totalAllocPoint = 0;
    IOracle public oracle;
    // router address
    address public router;
    // factory address
    IHakuswapFactory public factory;
    // hakutoken address
    HakuToken public hakuToken;
    // Calculate price based on BUSD
    address public targetToken;
    // pair corresponding pid
    mapping(address => uint256) public pairOfPid;

    constructor(
        HakuToken _hakuToken,
        IHakuswapFactory _factory,
        IOracle _oracle,
        address _router,
        address _targetToken,
        uint256 _hakuPerSecond,
        uint256 _startTime
    ) public {
        require(address(_hakuToken) != address(0), "illegal address");
        hakuToken = _hakuToken;
        require(address(_factory) != address(0), "illegal address");
        factory = _factory;
        require(address(_oracle) != address(0), "illegal address");
        oracle = _oracle;
        require(_router != address(0), "illegal address");
        router = _router;
        targetToken = _targetToken;
        hakuPerSecond = _hakuPerSecond;
        startTime = _startTime;
    }

    struct UserInfo {
        uint256 quantity;       // How many LP tokens the user has provided
        uint256 blockTimestamp;    // Last transaction time
    }

    struct PoolInfo {
        address pair;           // Trading pairs that can be mined
        uint256 quantity;       // Current amount of LPs
        uint256 totalQuantity;  // All quantity
        uint256 allocPoint;     // How many allocation points assigned to this pool
        uint256 allocHakuAmount; // How many HAKUs
        uint256 lastRewardTime;// Last transaction time
    }

    PoolInfo[] public poolInfo;
    mapping(uint256 => mapping(address => UserInfo)) public userInfo;


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


    function addPair(uint256 _allocPoint, address _pair, bool _withUpdate) public onlyOwner {
        require(_pair != address(0), "_pair is the zero address");
        if (_withUpdate) {
            massMintPools();
        }
        uint256 lastRewardTime = block.timestamp > startTime ? block.timestamp : startTime;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        poolInfo.push(PoolInfo({
        pair : _pair,
        quantity : 0,
        totalQuantity : 0,
        allocPoint : _allocPoint,
        allocHakuAmount : 0,
        lastRewardTime : lastRewardTime
        }));
        pairOfPid[_pair] = poolLength() - 1;
    }

    // Update the allocPoint of the pool
    function setPair(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner {
        if (_withUpdate) {
            massMintPools();
        }
        totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
        poolInfo[_pid].allocPoint = _allocPoint;
    }

    // Set the number of haku produced by each second
    function setHakuswapPerSecond(uint256 _newPerSecond) public onlyOwner {
        massMintPools();
        hakuPerSecond = _newPerSecond;
    }

    // Only tokens in the whitelist can be mined MDX
    function addWhitelist(address _addToken) public onlyOwner returns (bool) {
        require(_addToken != address(0), "SwapMining: token is the zero address");
        return EnumerableSet.add(_whitelist, _addToken);
    }

    function delWhitelist(address _delToken) public onlyOwner returns (bool) {
        require(_delToken != address(0), "SwapMining: token is the zero address");
        return EnumerableSet.remove(_whitelist, _delToken);
    }

    function getWhitelistLength() public view returns (uint256) {
        return EnumerableSet.length(_whitelist);
    }

    function isWhitelist(address _token) public view returns (bool) {
        return EnumerableSet.contains(_whitelist, _token);
    }

    function getWhitelist(uint256 _index) public view returns (address){
        require(_index <= getWhitelistLength() - 1, "SwapMining: index out of bounds");
        return EnumerableSet.at(_whitelist, _index);
    }

    function setHalvingPeriod(uint256 _period) public onlyOwner {
        halvingPeriod = _period;
    }

    function setRouter(address newRouter) public onlyOwner {
        require(newRouter != address(0), "SwapMining: new router is the zero address");
        router = newRouter;
    }

    function setOracle(IOracle _oracle) public onlyOwner {
        require(address(_oracle) != address(0), "SwapMining: new oracle is the zero address");
        oracle = _oracle;
    }

    // At what phase
    function phase(uint256 blockTimestamp) public view returns (uint256) {
        if (halvingPeriod == 0) {
            return 0;
        }
        if (blockTimestamp > startTime) {
            return (blockTimestamp.sub(startTime).sub(1)).div(halvingPeriod);
        }
        return 0;
    }

    function phase() public view returns (uint256) {
        return phase(block.timestamp);
    }

    function reward(uint256 blockTimestamp) public view returns (uint256) {
        uint256 _phase = phase(blockTimestamp);
        return hakuPerSecond.div(2 ** _phase);
    }

    function reward() public view returns (uint256) {
        return reward(block.timestamp);
    }

    // Rewards for the current block
    function getHakuReward(uint256 _lastRewardTime) public view returns (uint256) {
        require(_lastRewardTime <= block.timestamp, "SwapMining: must little than the current block timestamp");
        uint256 blockReward = 0;
        uint256 n = phase(_lastRewardTime);
        uint256 m = phase(block.timestamp);
        // If it crosses the cycle
        while (n < m) {
            n++;
            // Get the last timestamp of the previous cycle
            uint256 r = n.mul(halvingPeriod).add(startTime);
            // Get rewards from previous periods
            blockReward = blockReward.add((r.sub(_lastRewardTime)).mul(reward(r)));
            _lastRewardTime = r;
        }
        blockReward = blockReward.add((block.timestamp.sub(_lastRewardTime)).mul(reward(block.timestamp)));
        return blockReward;
    }

    // Update all pools Called when updating allocPoint and setting new seconds
    function massMintPools() public {
        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            mint(pid);
        }
    }

    function mint(uint256 _pid) public returns (bool) {
        PoolInfo storage pool = poolInfo[_pid];
        if (block.timestamp <= pool.lastRewardTime) {
            return false;
        }
        uint256 blockReward = getHakuReward(pool.lastRewardTime);
        if (blockReward <= 0) {
            return false;
        }
        // Calculate the rewards obtained by the pool based on the allocPoint
        uint256 hakuReward = blockReward.mul(pool.allocPoint).div(totalAllocPoint);
        // Increase the number of tokens in the current pool
        pool.allocHakuAmount = pool.allocHakuAmount.add(hakuReward);
        pool.lastRewardTime = block.timestamp;
        return true;
    }

    modifier onlyRouter() {
        require(msg.sender == router, "SwapMining: caller is not the router");
        _;
    }

    // swapMining only router
    function swap(address account, address input, address output, uint256 amount) public onlyRouter returns (bool) {
        require(account != address(0), "SwapMining: taker swap account is the zero address");
        require(input != address(0), "SwapMining: taker swap input is the zero address");
        require(output != address(0), "SwapMining: taker swap output is the zero address");

        if (poolLength() <= 0) {
            return false;
        }

        if (!isWhitelist(input) || !isWhitelist(output)) {
            return false;
        }

        address pair = HakuswapLibrary.pairFor(address(factory), input, output);
        PoolInfo storage pool = poolInfo[pairOfPid[pair]];
        // If it does not exist or the allocPoint is 0 then return
        if (pool.pair != pair || pool.allocPoint <= 0) {
            return false;
        }

        uint256 quantity = getQuantity(output, amount, targetToken);
        if (quantity <= 0) {
            return false;
        }

        mint(pairOfPid[pair]);

        pool.quantity = pool.quantity.add(quantity);
        pool.totalQuantity = pool.totalQuantity.add(quantity);
        UserInfo storage user = userInfo[pairOfPid[pair]][account];
        user.quantity = user.quantity.add(quantity);
        user.blockTimestamp = block.timestamp;
        return true;
    }

    function getQuantity(address outputToken, uint256 outputAmount, address anchorToken) public view returns (uint256) {
        uint256 quantity = 0;
        if (outputToken == anchorToken) {
            quantity = outputAmount;
        } else if (IHakuswapFactory(factory).getPair(outputToken, anchorToken) != address(0)) {
            quantity = IOracle(oracle).consult(outputToken, outputAmount, anchorToken);
        } else {
            uint256 length = getWhitelistLength();
            for (uint256 index = 0; index < length; index++) {
                address intermediate = getWhitelist(index);
                if (factory.getPair(outputToken, intermediate) != address(0) && factory.getPair(intermediate, anchorToken) != address(0)) {
                    uint256 interQuantity = IOracle(oracle).consult(outputToken, outputAmount, intermediate);
                    quantity = IOracle(oracle).consult(intermediate, interQuantity, anchorToken);
                    break;
                }
            }
        }
        return quantity;
    }

    // The user withdraws all the transaction rewards of the pool
    function takerWithdraw() public {
        uint256 userSub;
        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            PoolInfo storage pool = poolInfo[pid];
            UserInfo storage user = userInfo[pid][msg.sender];
            if (user.quantity > 0) {
                mint(pid);
                // The reward held by the user in this pool
                uint256 userReward = pool.allocHakuAmount.mul(user.quantity).div(pool.quantity);
                pool.quantity = pool.quantity.sub(user.quantity);
                pool.allocHakuAmount = pool.allocHakuAmount.sub(userReward);
                user.quantity = 0;
                user.blockTimestamp = block.timestamp;
                userSub = userSub.add(userReward);
            }
        }
        if (userSub <= 0) {
            return;
        }
        console.log(userSub);
        hakuToken.transfer(msg.sender, userSub);
    }

    // Get rewards from users in the current pool
    function getUserReward(uint256 _pid, address _user) public view returns (uint256, uint256){
        require(_pid <= poolInfo.length - 1, "SwapMining: Not find this pool");
        uint256 userSub;
        PoolInfo memory pool = poolInfo[_pid];
        UserInfo memory user = userInfo[_pid][_user];
        if (user.quantity > 0) {
            uint256 blockReward = getHakuReward(pool.lastRewardTime);
            uint256 hakuReward = blockReward.mul(pool.allocPoint).div(totalAllocPoint);
            userSub = userSub.add((pool.allocHakuAmount.add(hakuReward)).mul(user.quantity).div(pool.quantity));
        }
        //Haku available to users, User transaction amount
        return (userSub, user.quantity);
    }

    // Get rewards from users in all pool
    function getTotalUserReward(address _user) public view returns (uint256, uint256){
        uint256 length = poolInfo.length;
        uint256 totalUserReward;
        uint256 totalUserQuantity;

        for (uint256 pid = 0; pid < length; ++pid) {
            PoolInfo memory pool = poolInfo[pid];
            UserInfo memory user = userInfo[pid][_user];
            uint256 userSub;
            if (user.quantity > 0) {
                uint256 blockReward = getHakuReward(pool.lastRewardTime);
                uint256 hakuReward = blockReward.mul(pool.allocPoint).div(totalAllocPoint);
                userSub = userSub.add((pool.allocHakuAmount.add(hakuReward)).mul(user.quantity).div(pool.quantity));
            }
            totalUserReward = totalUserReward.add(userSub);
            totalUserQuantity = totalUserQuantity.add(user.quantity);
        }
        //Total Haku available to users, User transaction amount
        return (totalUserReward, totalUserQuantity);
    }

    // Get details of the pool
    function getPoolInfo(uint256 _pid) public view returns (address, address, uint256, uint256, uint256, uint256){
        require(_pid <= poolInfo.length - 1, "SwapMining: Not find this pool");
        PoolInfo memory pool = poolInfo[_pid];
        address token0 = IHakuswapPair(pool.pair).token0();
        address token1 = IHakuswapPair(pool.pair).token1();
        uint256 hakuAmount = pool.allocHakuAmount;
        uint256 blockReward = getHakuReward(pool.lastRewardTime);
        uint256 hakuReward = blockReward.mul(pool.allocPoint).div(totalAllocPoint);
        hakuAmount = hakuAmount.add(hakuReward);
        //token0,token1,Pool remaining reward,Total /Current transaction volume of the pool
        return (token0, token1, hakuAmount, pool.totalQuantity, pool.quantity, pool.allocPoint);
    }

    function ownerWithdraw(address _to, uint256 _amount) public onlyOwner {
        safeHakuTransfer(_to, _amount);
    }

    function safeHakuTransfer(address _to, uint256 _amount) internal {
        uint256 balance = hakuToken.balanceOf(address(this));
        if (_amount > balance) {
            _amount = balance;
        }
        hakuToken.transfer(_to, _amount);
    }
}

Contract ABI

[{"inputs":[{"internalType":"contract HakuToken","name":"_hakuToken","type":"address"},{"internalType":"contract IHakuswapFactory","name":"_factory","type":"address"},{"internalType":"contract IOracle","name":"_oracle","type":"address"},{"internalType":"address","name":"_router","type":"address"},{"internalType":"address","name":"_targetToken","type":"address"},{"internalType":"uint256","name":"_hakuPerSecond","type":"uint256"},{"internalType":"uint256","name":"_startTime","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"address","name":"_pair","type":"address"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"addPair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_addToken","type":"address"}],"name":"addWhitelist","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_delToken","type":"address"}],"name":"delWhitelist","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"factory","outputs":[{"internalType":"contract IHakuswapFactory","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_lastRewardTime","type":"uint256"}],"name":"getHakuReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"getPoolInfo","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"outputToken","type":"address"},{"internalType":"uint256","name":"outputAmount","type":"uint256"},{"internalType":"address","name":"anchorToken","type":"address"}],"name":"getQuantity","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"getTotalUserReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"getUserReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_index","type":"uint256"}],"name":"getWhitelist","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getWhitelistLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hakuPerSecond","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hakuToken","outputs":[{"internalType":"contract HakuToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"halvingPeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"isWhitelist","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"massMintPools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"mint","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"oracle","outputs":[{"internalType":"contract IOracle","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"ownerWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"pairOfPid","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"blockTimestamp","type":"uint256"}],"name":"phase","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"phase","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"address","name":"pair","type":"address"},{"internalType":"uint256","name":"quantity","type":"uint256"},{"internalType":"uint256","name":"totalQuantity","type":"uint256"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"allocHakuAmount","type":"uint256"},{"internalType":"uint256","name":"lastRewardTime","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"reward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"blockTimestamp","type":"uint256"}],"name":"reward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"router","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newPerSecond","type":"uint256"}],"name":"setHakuswapPerSecond","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_period","type":"uint256"}],"name":"setHalvingPeriod","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IOracle","name":"_oracle","type":"address"}],"name":"setOracle","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"setPair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newRouter","type":"address"}],"name":"setRouter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"input","type":"address"},{"internalType":"address","name":"output","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"swap","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"takerWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"targetToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"quantity","type":"uint256"},{"internalType":"uint256","name":"blockTimestamp","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000695fa794d59106cebd40ab5f5ca19f458c7238290000000000000000000000002db46feb38c57a6621bca4d97820e1fc1de40f41000000000000000000000000734fce17e8a6ccb4a86666214cb040632f92e8660000000000000000000000005f1fdca239362c5b8a8ada26a256ac5626cc33e0000000000000000000000000c7198437980c041c805a1edcba50c1ce5db9511800000000000000000000000000000000000000000000000001aa535d3d0c00000000000000000000000000000000000000000000000000000000000061e6f210

-----Decoded View---------------
Arg [0] : _hakuToken (address): 0x695fa794d59106cebd40ab5f5ca19f458c723829
Arg [1] : _factory (address): 0x2db46feb38c57a6621bca4d97820e1fc1de40f41
Arg [2] : _oracle (address): 0x734fce17e8a6ccb4a86666214cb040632f92e866
Arg [3] : _router (address): 0x5f1fdca239362c5b8a8ada26a256ac5626cc33e0
Arg [4] : _targetToken (address): 0xc7198437980c041c805a1edcba50c1ce5db95118
Arg [5] : _hakuPerSecond (uint256): 120000000000000000
Arg [6] : _startTime (uint256): 1642525200

-----Encoded View---------------
7 Constructor Arguments found :
Arg [0] : 000000000000000000000000695fa794d59106cebd40ab5f5ca19f458c723829
Arg [1] : 0000000000000000000000002db46feb38c57a6621bca4d97820e1fc1de40f41
Arg [2] : 000000000000000000000000734fce17e8a6ccb4a86666214cb040632f92e866
Arg [3] : 0000000000000000000000005f1fdca239362c5b8a8ada26a256ac5626cc33e0
Arg [4] : 000000000000000000000000c7198437980c041c805a1edcba50c1ce5db95118
Arg [5] : 00000000000000000000000000000000000000000000000001aa535d3d0c0000
Arg [6] : 0000000000000000000000000000000000000000000000000000000061e6f210


Deployed ByteCode Sourcemap

119720:14405:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;120499:44;;;;;;;;;;;;;;;;-1:-1:-1;120499:44:0;-1:-1:-1;;;;;120499:44:0;;:::i;:::-;;;;;;;;;;;;;;;;121983:93;;;:::i;124842:298::-;;;;;;;;;;;;;;;;-1:-1:-1;124842:298:0;;:::i;121875:26::-;;;;;;;;;;;;;;;;-1:-1:-1;121875:26:0;;:::i;:::-;;;;-1:-1:-1;;;;;121875:26:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;120156:34;;;:::i;122797:306::-;;;;;;;;;;;;;;;;-1:-1:-1;122797:306:0;;;;;;;;;;;;;;:::i;:::-;;131099:729;;;;;;;;;;;;;;;;-1:-1:-1;131099:729:0;;;;;;-1:-1:-1;;;;;131099:729:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;125434:97;;;:::i;131879:999::-;;;;;;;;;;;;;;;;-1:-1:-1;131879:999:0;-1:-1:-1;;;;;131879:999:0;;:::i;132918:813::-;;;;;;;;;;;;;;;;-1:-1:-1;132918:813:0;;:::i;:::-;;;;-1:-1:-1;;;;;132918:813:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;119936:28;;;:::i;120435:26::-;;;:::i;:::-;;;;-1:-1:-1;;;;;120435:26:0;;;;;;;;;;;;;;120085:32;;;:::i;29596:148::-;;;:::i;120018:24::-;;;:::i;124628:184::-;;;;;;;;;;;;;;;;-1:-1:-1;124628:184:0;-1:-1:-1;;;;;124628:184:0;;:::i;120197:21::-;;;:::i;28945:87::-;;;:::i;121908:64::-;;;;;;;;;;;;;;;;-1:-1:-1;121908:64:0;;;;;;-1:-1:-1;;;;;121908:64:0;;:::i;124103:218::-;;;;;;;;;;;;;;;;-1:-1:-1;124103:218:0;;:::i;123603:226::-;;;;;;;;;;;;;;;;-1:-1:-1;123603:226:0;-1:-1:-1;;;;;123603:226:0;;:::i;:::-;;;;;;;;;;;;;;;;;;126510:172;;;:::i;126690:704::-;;;;;;;;;;;;;;;;-1:-1:-1;126690:704:0;;:::i;123837:118::-;;;:::i;128938:1066::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;128938:1066:0;;;;;;;;;;;;;;;;;:::i;127563:1367::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;127563:1367:0;;;;;;;;;;;;;;;;;;;;;;:::i;125251:175::-;;;;;;;;;;;;;;;;-1:-1:-1;125251:175:0;;:::i;123166:144::-;;;;;;;;;;;;;;;;-1:-1:-1;123166:144:0;;:::i;125148:95::-;;;:::i;124329:102::-;;;;;;;;;;;;;;;;-1:-1:-1;124329:102:0;;:::i;130079:961::-;;;:::i;124439:181::-;;;;;;;;;;;;;;;;-1:-1:-1;124439:181:0;-1:-1:-1;;;;;124439:181:0;;:::i;120300:31::-;;;:::i;123963:132::-;;;;;;;;;;;;;;;;-1:-1:-1;123963:132:0;-1:-1:-1;;;;;123963:132:0;;:::i;133739:119::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;133739:119:0;;;;;;;;:::i;125577:844::-;;;;;;;;;;;;;;;;-1:-1:-1;125577:844:0;;:::i;29899:244::-;;;;;;;;;;;;;;;;-1:-1:-1;29899:244:0;-1:-1:-1;;;;;29899:244:0;;:::i;123372:223::-;;;;;;;;;;;;;;;;-1:-1:-1;123372:223:0;-1:-1:-1;;;;;123372:223:0;;:::i;120248:21::-;;;:::i;120364:26::-;;;:::i;122086:661::-;;;;;;;;;;;;;;;;-1:-1:-1;122086:661:0;;;-1:-1:-1;;;;;122086:661:0;;;;;;;;;;;;:::i;120499:44::-;;;;;;;;;;;;;:::o;121983:93::-;122053:8;:15;121983:93;:::o;124842:298::-;124902:7;124926:13;;124943:1;124926:18;124922:59;;;-1:-1:-1;124968:1:0;124961:8;;124922:59;125012:9;;124995:14;:26;124991:123;;;125045:57;125088:13;;125046:36;125080:1;125046:29;125065:9;;125046:14;:18;;:29;;;;:::i;:::-;:33;;:36::i;:::-;125045:42;;:57::i;:::-;125038:64;;;;124991:123;-1:-1:-1;125131:1:0;124842:298;;;;:::o;121875:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;121875:26:0;;;;-1:-1:-1;121875:26:0;;;;;:::o;120156:34::-;;;;:::o;122797:306::-;29176:12;:10;:12::i;:::-;-1:-1:-1;;;;;29165:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;29165:23:0;;29157:68;;;;;-1:-1:-1;;;29157:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;29157:68:0;;;;;;;;;;;;;;;122899:11:::1;122895:59;;;122927:15;:13;:15::i;:::-;122982:63;123033:11;122982:46;123002:8;123011:4;123002:14;;;;;;;;;;;;;;;;;;:25;;;122982:15;;:19;;:46;;;;:::i;:::-;:50:::0;::::1;:63::i;:::-;122964:15;:81;;;;123084:11;123056:8;123065:4;123056:14;;;;;;;;;;;;;;;;;;:25;;:39;;;;122797:306:::0;;;:::o;131099:729::-;131216:8;:15;131172:7;;;;-1:-1:-1;;131216:19:0;131208:27;;;131200:70;;;;;-1:-1:-1;;;131200:70:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;131281:15;131307:20;;:::i;:::-;131330:8;131339:4;131330:14;;;;;;;;;;;;;;;;;131307:37;;;;;;;;131330:14;;;;;;;131307:37;;-1:-1:-1;;;;;131307:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;131355:20:0;;:::i;:::-;-1:-1:-1;131378:14:0;;;;:8;:14;;;;;;;;-1:-1:-1;;;;;131378:21:0;;;;;;;;;;131355:44;;;;;;;;;;;;;;;;;;;;;;;;;131414:17;131410:309;;131448:19;131470:34;131484:4;:19;;;131470:13;:34::i;:::-;131448:56;;131519:18;131540:53;131577:15;;131540:32;131556:4;:15;;;131540:11;:15;;:32;;;;:::i;:53::-;131519:74;;131618:89;131630:76;131692:4;:13;;;131630:57;131673:4;:13;;;131631:36;131656:10;131631:4;:20;;;:24;;:36;;;;:::i;:::-;131630:42;;:57::i;:76::-;131618:7;;:11;:89::i;:::-;131608:99;;131410:309;;;131806:13;131797:7;;-1:-1:-1;131806:13:0;;-1:-1:-1;;131099:729:0;;;;;;:::o;125434:97::-;125473:7;125500:23;125507:15;125500:6;:23::i;:::-;125493:30;;125434:97;:::o;131879:999::-;131988:8;:15;131943:7;;;;;;;132086:665;132114:6;132108:3;:12;132086:665;;;132144:20;;:::i;:::-;132167:8;132176:3;132167:13;;;;;;;;;;;;;;;;;132144:36;;;;;;;;132167:13;;;;;;;132144:36;;-1:-1:-1;;;;;132144:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;132195:20:0;;:::i;:::-;-1:-1:-1;132218:13:0;;;;:8;:13;;;;;;;;-1:-1:-1;;;;;132218:20:0;;;;;;;;;132195:43;;;;;;;;;;;;;;;;;;;;;;;;;;132218:13;132287:17;132283:325;;132325:19;132347:34;132361:4;:19;;;132347:13;:34::i;:::-;132325:56;;132400:18;132421:53;132458:15;;132421:32;132437:4;:15;;;132421:11;:15;;:32;;;;:::i;:53::-;132400:74;;132503:89;132515:76;132577:4;:13;;;132515:57;132558:4;:13;;;132516:36;132541:10;132516:4;:20;;;:24;;:36;;;;:::i;132515:76::-;132503:7;;:11;:89::i;:::-;132493:99;;132283:325;;;132640:28;:15;132660:7;132640:19;:28::i;:::-;132725:13;;132622:46;;-1:-1:-1;132703:36:0;;:17;;:21;:36::i;:::-;132683:56;;132086:665;;;132122:5;;;;;132086:665;;;-1:-1:-1;132835:15:0;;-1:-1:-1;132852:17:0;-1:-1:-1;;131879:999:0;;;:::o;132918:813::-;132974:7;132983;132992;133001;133010;133019;133072:1;133054:8;:15;;;;:19;133046:4;:27;;133038:70;;;;;-1:-1:-1;;;133038:70:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;133119:20;;:::i;:::-;133142:8;133151:4;133142:14;;;;;;;;;;;;;;;;133119:37;;;;;;;;133142:14;;;;;;;133119:37;;-1:-1:-1;;;;;133119:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;133184:33;;-1:-1:-1;;;133184:33:0;;;;133119:37;;-1:-1:-1;133119:37:0;133184:31;;:33;;;;133142:14;;133184:33;;;;;;133119:37;133184:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;133184:33:0;133259:9;;133245:33;;;-1:-1:-1;;;133245:33:0;;;;133184;;-1:-1:-1;133228:14:0;;-1:-1:-1;;;;;133245:31:0;;;;;;:33;;;;;133184;;133245;;;;;;;;:31;:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;133245:33:0;133310:20;;;;133377:19;;;;133245:33;;-1:-1:-1;133310:20:0;133289:18;;133363:34;;:13;:34::i;:::-;133341:56;;133408:18;133429:53;133466:15;;133429:32;133445:4;:15;;;133429:11;:15;;:32;;;;:::i;:53::-;133408:74;-1:-1:-1;133506:26:0;:10;133408:74;133506:14;:26::i;:::-;133672:18;;;;133692:13;;;;133707:15;;;;;133644:6;;133652;;-1:-1:-1;133493:39:0;;-1:-1:-1;133672:18:0;-1:-1:-1;133692:13:0;;-1:-1:-1;133707:15:0;;-1:-1:-1;132918:813:0;;-1:-1:-1;;;;;132918:813:0:o;119936:28::-;;;;:::o;120435:26::-;;;-1:-1:-1;;;;;120435:26:0;;:::o;120085:32::-;;;;:::o;29596:148::-;29176:12;:10;:12::i;:::-;-1:-1:-1;;;;;29165:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;29165:23:0;;29157:68;;;;;-1:-1:-1;;;29157:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;29157:68:0;;;;;;;;;;;;;;;29703:1:::1;29687:6:::0;;29666:40:::1;::::0;-1:-1:-1;;;;;29687:6:0;;::::1;::::0;29666:40:::1;::::0;29703:1;;29666:40:::1;29734:1;29717:19:::0;;-1:-1:-1;;;;;;29717:19:0::1;::::0;;29596:148::o;120018:24::-;;;;:::o;124628:184::-;29176:12;:10;:12::i;:::-;-1:-1:-1;;;;;29165:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;29165:23:0;;29157:68;;;;;-1:-1:-1;;;29157:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;29157:68:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;124700:30:0;::::1;124692:85;;;;-1:-1:-1::0;;;124692:85:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;124788:6;:16:::0;;-1:-1:-1;;;;;;124788:16:0::1;-1:-1:-1::0;;;;;124788:16:0;;;::::1;::::0;;;::::1;::::0;;124628:184::o;120197:21::-;;;-1:-1:-1;;;;;120197:21:0;;:::o;28945:87::-;28991:7;29018:6;-1:-1:-1;;;;;29018:6:0;28945:87;:::o;121908:64::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;124103:218::-;124162:7;124222:1;124199:20;:18;:20::i;:::-;:24;124189:6;:34;;124181:78;;;;;-1:-1:-1;;;124181:78:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;124277:36;124294:10;124306:6;124277:16;:36::i;:::-;124270:43;124103:218;-1:-1:-1;;124103:218:0:o;123603:226::-;123670:4;29176:12;:10;:12::i;:::-;-1:-1:-1;;;;;29165:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;29165:23:0;;29157:68;;;;;-1:-1:-1;;;29157:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;29157:68:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;123695:23:0;::::1;123687:73;;;;-1:-1:-1::0;;;123687:73:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;123778:43;123799:10;123811:9;123778:20;:43::i;126510:172::-:0;126570:8;:15;126553:14;126596:79;126624:6;126618:3;:12;126596:79;;;126654:9;126659:3;126654:4;:9::i;:::-;-1:-1:-1;126632:5:0;;126596:79;;;;126510:172;:::o;126690:704::-;126734:4;126751:21;126775:8;126784:4;126775:14;;;;;;;;;;;;;;;;;;126751:38;;126823:4;:19;;;126804:15;:38;126800:83;;126866:5;126859:12;;;;;126800:83;126893:19;126915:34;126929:4;:19;;;126915:13;:34::i;:::-;126893:56;;126979:1;126964:11;:16;126960:61;;127004:5;126997:12;;;;;;126960:61;127110:18;127131:53;127168:15;;127131:32;127147:4;:15;;;127131:11;:15;;:32;;;;:::i;:53::-;127280:20;;;;127110:74;;-1:-1:-1;127280:36:0;;127110:74;127280:24;:36::i;:::-;127257:20;;;:59;-1:-1:-1;;127349:15:0;127327:19;;;;:37;-1:-1:-1;127382:4:0;126690:704;;;:::o;123837:118::-;123888:7;123915:32;123936:10;123915:20;:32::i;128938:1066::-;129044:7;;-1:-1:-1;;;;;129099:26:0;;;;;;;129095:876;;;-1:-1:-1;129153:12:0;129095:876;;;129204:7;;129187:59;;;-1:-1:-1;;;129187:59:0;;-1:-1:-1;;;;;129187:59:0;;;;;;;;;;;;;;;;129258:1;;129204:7;;;;129187:33;;:59;;;;;;;;;;;;;;;129204:7;129187:59;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;129187:59:0;-1:-1:-1;;;;;129187:73:0;;129183:788;;129296:6;;129288:63;;;-1:-1:-1;;;129288:63:0;;-1:-1:-1;;;;;129288:63:0;;;;;;;;;;;;;;;;;;;;;;129296:6;;;;;129288:23;;:63;;;;;;;;;;;;;;129296:6;129288:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;129288:63:0;;-1:-1:-1;129183:788:0;;;129384:14;129401:20;:18;:20::i;:::-;129384:37;;129441:13;129436:524;129468:6;129460:5;:14;129436:524;;;129504:20;129527:19;129540:5;129527:12;:19::i;:::-;129569:7;;:42;;;-1:-1:-1;;;129569:42:0;;-1:-1:-1;;;;;129569:42:0;;;;;;;;;;;;;;;;;;-1:-1:-1;;;129569:7:0;;;;;:15;;:42;;;;;;;;;;;;;;:7;:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;129569:42:0;-1:-1:-1;;;;;129569:56:0;;;;;:116;;-1:-1:-1;129629:7:0;;:42;;;-1:-1:-1;;;129629:42:0;;-1:-1:-1;;;;;129629:42:0;;;;;;;;;;;;;;;;129683:1;;129629:7;;;;:15;;:42;;;;;;;;;;;;;;;:7;:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;129629:42:0;-1:-1:-1;;;;;129629:56:0;;;129569:116;129565:380;;;129742:6;;129734:64;;;-1:-1:-1;;;129734:64:0;;-1:-1:-1;;;;;129734:64:0;;;;;;;;;;;;;;;;;;;;;;129710:21;;129742:6;;;;;129734:23;;:64;;;;;;;;;;;;;;;129742:6;129734:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;129734:64:0;129840:6;;129832:65;;;-1:-1:-1;;;129832:65:0;;-1:-1:-1;;;;;129832:65:0;;;;;;;;;;;;;;;;;;;;;;129734:64;;-1:-1:-1;129840:6:0;;;129832:23;;:65;;;;;129734:64;;129832:65;;;;;;;;129840:6;129832:65;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;129832:65:0;;-1:-1:-1;129920:5:0;;-1:-1:-1;;129920:5:0;129565:380;-1:-1:-1;129476:7:0;;129436:524;;;;129183:788;;129988:8;128938:1066;-1:-1:-1;;;;128938:1066:0:o;127563:1367::-;127457:6;;127668:4;;-1:-1:-1;;;;;127457:6:0;127443:10;:20;127435:69;;;;-1:-1:-1;;;127435:69:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;127693:21:0;::::1;127685:84;;;;-1:-1:-1::0;;;127685:84:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;;;;127788:19:0;::::1;127780:80;;;;-1:-1:-1::0;;;127780:80:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;;;;127879:20:0;::::1;127871:82;;;;-1:-1:-1::0;;;127871:82:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;127986:1;127970:12;:10;:12::i;:::-;:17;127966:62;;-1:-1:-1::0;128011:5:0::1;128004:12;;127966:62;128045:18;128057:5;128045:11;:18::i;:::-;128044:19;:43;;;;128068:19;128080:6;128068:11;:19::i;:::-;128067:20;128044:43;128040:88;;;-1:-1:-1::0;128111:5:0::1;128104:12;;128040:88;128187:7;::::0;128140:12:::1;::::0;128155:56:::1;::::0;-1:-1:-1;;;;;128187:7:0::1;128197:5:::0;128204:6;128155:23:::1;:56::i;:::-;-1:-1:-1::0;;;;;128255:15:0;::::1;128222:21;128255:15:::0;;;:9:::1;:15;::::0;;;;;128246:8:::1;:25:::0;;128140:71;;-1:-1:-1;128222:21:0;;128246:25;::::1;;;;;;::::0;;;::::1;::::0;;;::::1;::::0;;::::1;;128354:9:::0;;128246:25;;-1:-1:-1;;;;;;128354:17:0;;::::1;:9:::0;::::1;:17;;::::0;:41:::1;;-1:-1:-1::0;128375:15:0::1;::::0;::::1;::::0;:20;128354:41:::1;128350:86;;;128419:5;128412:12;;;;;;128350:86;128495:11;::::0;128448:16:::1;::::0;128467:40:::1;::::0;128479:6;;128487;;-1:-1:-1;;;;;128495:11:0::1;128467;:40::i;:::-;128448:59;;128534:1;128522:8;:13;128518:58;;128559:5;128552:12;;;;;;;128518:58;-1:-1:-1::0;;;;;128593:15:0;::::1;;::::0;;;:9:::1;:15;::::0;;;;;128588:21:::1;::::0;:4:::1;:21::i;:::-;-1:-1:-1::0;128638:13:0::1;::::0;::::1;::::0;:27:::1;::::0;128656:8;128638:17:::1;:27::i;:::-;128622:13;::::0;::::1;:43:::0;128697:18:::1;::::0;::::1;::::0;:32:::1;::::0;128720:8;128697:22:::1;:32::i;:::-;128676:18;::::0;::::1;:53:::0;-1:-1:-1;;;;;128773:15:0;;::::1;128740:21;128773:15:::0;;;:9:::1;:15;::::0;;;;;;;;128764:25;;:8:::1;:25:::0;;;;;:34;;::::1;::::0;;;;;;128825:13;;:27:::1;::::0;128843:8;128825:17:::1;:27::i;:::-;128809:43:::0;;128885:15:::1;128863:19;::::0;;::::1;:37:::0;:19;127563:1367;-1:-1:-1;;;;;;;;127563:1367:0:o;125251:175::-;125312:7;125332:14;125349:21;125355:14;125349:5;:21::i;:::-;125332:38;;125388:30;125411:6;125406:1;:11;125388:13;;:17;;:30;;;;:::i;:::-;125381:37;125251:175;-1:-1:-1;;;125251:175:0:o;123166:144::-;29176:12;:10;:12::i;:::-;-1:-1:-1;;;;;29165:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;29165:23:0;;29157:68;;;;;-1:-1:-1;;;29157:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;29157:68:0;;;;;;;;;;;;;;;123247:15:::1;:13;:15::i;:::-;123273:13;:29:::0;123166:144::o;125148:95::-;125186:7;125213:22;125219:15;125213:5;:22::i;124329:102::-;29176:12;:10;:12::i;:::-;-1:-1:-1;;;;;29165:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;29165:23:0;;29157:68;;;;;-1:-1:-1;;;29157:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;29157:68:0;;;;;;;;;;;;;;;124400:13:::1;:23:::0;124329:102::o;130079:961::-;130165:8;:15;130122;;;130191:700;130219:6;130213:3;:12;130191:700;;;130249:21;130273:8;130282:3;130273:13;;;;;;;;;;;;;;;;130325;;;:8;:13;;;;;;130339:10;130325:25;;;;;;;130369:13;;130273;;;;;;;;-1:-1:-1;130369:17:0;130365:515;;130407:9;130412:3;130407:4;:9::i;:::-;;130496:18;130517:58;130561:4;:13;;;130517:39;130542:4;:13;;;130517:4;:20;;;:24;;:39;;;;:::i;:58::-;130628:13;;130610;;;;130496:79;;-1:-1:-1;130610:32:0;;:13;:17;:32::i;:::-;130594:13;;;:48;130684:20;;;;:36;;130709:10;130684:24;:36::i;:::-;130661:20;;;:59;130755:1;130739:17;;130797:15;130775:19;;;:37;130841:23;:7;130853:10;130841:11;:23::i;:::-;130831:33;;130365:515;;-1:-1:-1;;130227:5:0;;130191:700;;;;130916:1;130905:7;:12;130901:51;;130934:7;;;;130901:51;130962:20;130974:7;130962:11;:20::i;:::-;130993:9;;:39;;;-1:-1:-1;;;130993:39:0;;131012:10;130993:39;;;;;;;;;;;;-1:-1:-1;;;;;130993:9:0;;;;:18;;:39;;;;;;;;;;;;;;;:9;;:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;130079:961:0;:::o;124439:181::-;29176:12;:10;:12::i;:::-;-1:-1:-1;;;;;29165:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;29165:23:0;;29157:68;;;;;-1:-1:-1;;;29157:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;29157:68:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;124513:23:0;::::1;124505:78;;;;-1:-1:-1::0;;;124505:78:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;124594:6;:18:::0;;-1:-1:-1;;;;;;124594:18:0::1;-1:-1:-1::0;;;;;124594:18:0;;;::::1;::::0;;;::::1;::::0;;124439:181::o;120300:31::-;;;-1:-1:-1;;;;;120300:31:0;;:::o;123963:132::-;124021:4;124045:42;124068:10;124080:6;124045:22;:42::i;133739:119::-;29176:12;:10;:12::i;:::-;-1:-1:-1;;;;;29165:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;29165:23:0;;29157:68;;;;;-1:-1:-1;;;29157:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;29157:68:0;;;;;;;;;;;;;;;133820:30:::1;133837:3;133842:7;133820:16;:30::i;125577:844::-:0;125646:7;125693:15;125674;:34;;125666:103;;;;-1:-1:-1;;;125666:103:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;125780:19;125814:9;125826:22;125832:15;125826:5;:22::i;:::-;125814:34;;125859:9;125871:22;125877:15;125871:5;:22::i;:::-;125859:34;;125940:336;125951:1;125947;:5;125940:336;;;126085:9;;126066:13;;125969:3;;;;;126048:9;;126060:35;;:20;;125969:3;;126060:5;:20::i;:35::-;126048:47;;126174:56;126190:39;126219:9;126226:1;126219:6;:9::i;:::-;126191:22;:1;126197:15;126191:5;:22::i;126190:39::-;126174:11;;:15;:56::i;:::-;126263:1;;-1:-1:-1;126160:70:0;-1:-1:-1;125940:336:0;;;126300:84;126316:67;126359:23;126366:15;126359:6;:23::i;:::-;126317:36;:15;126337;126317:19;:36::i;126300:84::-;126286:98;125577:844;-1:-1:-1;;;;;125577:844:0:o;29899:244::-;29176:12;:10;:12::i;:::-;-1:-1:-1;;;;;29165:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;29165:23:0;;29157:68;;;;;-1:-1:-1;;;29157:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;29157:68:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;29988:22:0;::::1;29980:73;;;;-1:-1:-1::0;;;29980:73:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30090:6;::::0;;30069:38:::1;::::0;-1:-1:-1;;;;;30069:38:0;;::::1;::::0;30090:6;::::1;::::0;30069:38:::1;::::0;::::1;30118:6;:17:::0;;-1:-1:-1;;;;;;30118:17:0::1;-1:-1:-1::0;;;;;30118:17:0;;;::::1;::::0;;;::::1;::::0;;29899:244::o;123372:223::-;123439:4;29176:12;:10;:12::i;:::-;-1:-1:-1;;;;;29165:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;29165:23:0;;29157:68;;;;;-1:-1:-1;;;29157:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;29157:68:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;123464:23:0;::::1;123456:73;;;;-1:-1:-1::0;;;123456:73:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;123547:40;123565:10;123577:9;123547:17;:40::i;120248:21::-:0;;;-1:-1:-1;;;;;120248:21:0;;:::o;120364:26::-;;;-1:-1:-1;;;;;120364:26:0;;:::o;122086:661::-;29176:12;:10;:12::i;:::-;-1:-1:-1;;;;;29165:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;29165:23:0;;29157:68;;;;;-1:-1:-1;;;29157:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;29157:68:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;122193:19:0;::::1;122185:57;;;::::0;;-1:-1:-1;;;122185:57:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;122257:11;122253:59;;;122285:15;:13;:15::i;:::-;122322:22;122365:9;;122347:15;:27;:57;;122395:9;;122347:57;;;122377:15;122347:57;122433:15;::::0;122322:82;;-1:-1:-1;122433:32:0::1;::::0;122453:11;122433:19:::1;:32::i;:::-;122415:15;:50:::0;;;122490:202:::1;::::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;;;;;122490:202:0;;::::1;::::0;;-1:-1:-1;122490:202:0::1;::::0;::::1;::::0;;;;;;;;;;;;;;;;;;;;;;;;;;;122476:8:::1;:217:::0;;::::1;::::0;;::::1;::::0;;;;;;;;;;;;::::1;::::0;;::::1;::::0;;-1:-1:-1;;;;;;122476:217:0::1;::::0;;;::::1;::::0;;;::::1;::::0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;122723:12:::1;:10;:12::i;:::-;-1:-1:-1::0;;;;;122704:16:0;;::::1;;::::0;;;:9:::1;:16;::::0;;;;122723;::::1;122704:35:::0;;;-1:-1:-1;;;122086:661:0:o;11116:136::-;11174:7;11201:43;11205:1;11208;11201:43;;;;;;;;;;;;;;;;;:3;:43::i;12987:132::-;13045:7;13072:39;13076:1;13079;13072:39;;;;;;;;;;;;;;;;;:3;:39::i;27493:106::-;27581:10;27493:106;:::o;10652:181::-;10710:7;10742:5;;;10766:6;;;;10758:46;;;;;-1:-1:-1;;;10758:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;12040:471;12098:7;12343:6;12339:47;;-1:-1:-1;12373:1:0;12366:8;;12339:47;12410:5;;;12414:1;12410;:5;:1;12434:5;;;;;:10;12426:56;;;;-1:-1:-1;;;12426:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7965:158;8039:7;8090:22;8094:3;8106:5;8090:3;:22::i;7007:158::-;7080:4;7104:53;7112:3;-1:-1:-1;;;;;7132:23:0;;7104:7;:53::i;7504:117::-;7567:7;7594:19;7602:3;7594:7;:19::i;19806:478::-;19895:12;19921:14;19937;19955:26;19966:6;19974;19955:10;:26::i;:::-;20119:32;;;-1:-1:-1;;20119:32:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20109:43;;;;;;-1:-1:-1;;;;;;20022:251:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20012:262;;;;;;;;;19806:478;-1:-1:-1;;;;;19806:478:0:o;60961:103::-;61018:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;61018:40:0;-1:-1:-1;;;61018:40:0;;;61002:57;;:15;:57::i;:::-;60961:103;:::o;7251:167::-;7331:4;7355:55;7365:3;-1:-1:-1;;;;;7385:23:0;;7355:9;:55::i;133866:256::-;133960:9;;:34;;;-1:-1:-1;;;133960:34:0;;133988:4;133960:34;;;;;;133942:15;;-1:-1:-1;;;;;133960:9:0;;:19;;:34;;;;;;;;;;;;;;:9;:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;133960:34:0;;-1:-1:-1;134009:17:0;;;134005:67;;;134053:7;134043:17;;134005:67;134082:9;;:32;;;-1:-1:-1;;;134082:32:0;;-1:-1:-1;;;;;134082:32:0;;;;;;;;;;;;;;;:9;;;;;:18;;:32;;;;;;;;;;;;;;:9;;:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;133866:256:0:o;6679:152::-;6749:4;6773:50;6778:3;-1:-1:-1;;;;;6798:23:0;;6773:4;:50::i;11555:226::-;11675:7;11711:12;11703:6;;;;11695:29;;;;-1:-1:-1;;;11695:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;11747:5:0;;;11555:226::o;13615:312::-;13735:7;13770:12;13763:5;13755:28;;;;-1:-1:-1;;;13755:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13794:9;13810:1;13806;:5;;;;;;;13615:312;-1:-1:-1;;;;;13615:312:0:o;4631:204::-;4726:18;;4698:7;;4726:26;-1:-1:-1;4718:73:0;;;;-1:-1:-1;;;4718:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4809:3;:11;;4821:5;4809:18;;;;;;;;;;;;;;;;4802:25;;4631:204;;;;:::o;2333:1544::-;2399:4;2538:19;;;:12;;;:19;;;;;;2574:15;;2570:1300;;3009:18;;-1:-1:-1;;2960:14:0;;;;3009:22;;;;2936:21;;3009:3;;:22;;3296;;;;;;;;;;;;;;3276:42;;3442:9;3413:3;:11;;3425:13;3413:26;;;;;;;;;;;;;;;;;;;:38;;;;3519:23;;;3561:1;3519:12;;;:23;;;;;;3545:17;;;3519:43;;3671:17;;3519:3;;3671:17;;;;;;;;;;;;;;;;;;;;;;3766:3;:12;;:19;3779:5;3766:19;;;;;;;;;;;3759:26;;;3809:4;3802:11;;;;;;;;2570:1300;3853:5;3846:12;;;;;4178:109;4261:18;;4178:109::o;19367:347::-;19442:14;19458;19503:6;-1:-1:-1;;;;;19493:16:0;:6;-1:-1:-1;;;;;19493:16:0;;;19485:65;;;;-1:-1:-1;;;19485:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19589:6;-1:-1:-1;;;;;19580:15:0;:6;-1:-1:-1;;;;;19580:15:0;;:53;;19618:6;19626;19580:53;;;19599:6;19607;19580:53;19561:72;;-1:-1:-1;19561:72:0;-1:-1:-1;;;;;;19652:20:0;;19644:62;;;;;-1:-1:-1;;;19644:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;;56022:295;56111:14;;55973:42;56223:2;56210:16;;56087:21;;56111:14;56210:16;55973:42;56251:5;56240:68;56231:77;;56184:129;;;:::o;3963:::-;4036:4;4060:19;;;:12;;;;;:19;;;;;;:24;;;3963:129::o;1743:414::-;1806:4;1828:21;1838:3;1843:5;1828:9;:21::i;:::-;1823:327;;-1:-1:-1;1866:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;2049:18;;2027:19;;;:12;;;:19;;;;;;:40;;;;2082:11;;1823:327;-1:-1:-1;2133:5:0;2126:12;;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;:::o

Swarm Source

ipfs://2a7ad071ff9b306626baac88881e1cf59303470b72d9c06ad101f2bdbb248017
Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.