Contract 0x4cb4c9c8cc67b171ce86eb947cf558afdbcab17e

Txn Hash
Block
From
To
Value [Txn Fee]
0x7ac78c8df9d96ace6c2f3e7f7c9374cb48b9538242bc7c3a9a682c9835af764255536512021-06-13 3:24:3714 secs ago0xeb989dab09c270642037d5f4fdcce6d0c0fe6d5d IN  0x4cb4c9c8cc67b171ce86eb947cf558afdbcab17e0 HT0.000132897
0xfdccbd190fc5a6ca5e689c00099ca9102f1d549e8732478b6047d64e7446ac3355536462021-06-13 3:24:2229 secs ago0xde8589960da34eefb00ca879d8cc12b11f52cb12 IN  0x4cb4c9c8cc67b171ce86eb947cf558afdbcab17e0 HT0.000448809
0xaaac770ef04e7da89733e94d25820f3669fa53cef3381b718ee9e118bd6a1a7355536412021-06-13 3:24:0744 secs ago0x5d2ecf419cc2bb3875ed4a1da69fa597469eabc3 IN  0x4cb4c9c8cc67b171ce86eb947cf558afdbcab17e0 HT0.000040598
0xa1fbf05034885323f81a184688638f9f44486d9833ff11353e24daf118b5c33f55536412021-06-13 3:24:0744 secs ago0x5d2ecf419cc2bb3875ed4a1da69fa597469eabc3 IN  0x4cb4c9c8cc67b171ce86eb947cf558afdbcab17e0 HT0.000179138
0xee4204a1e03b079fc35427dce70c35079d9f0d3663c3e615c8ee433c88f3ff5955536332021-06-13 3:23:431 min ago0x5d2ecf419cc2bb3875ed4a1da69fa597469eabc3 IN  0x4cb4c9c8cc67b171ce86eb947cf558afdbcab17e0 HT0.000142328
0x851727309c0c07b465e95c65de0b3e6f5719526ff8ddf041a283cac8d03dbd2c55536302021-06-13 3:23:341 min ago0x5d2ecf419cc2bb3875ed4a1da69fa597469eabc3 IN  0x4cb4c9c8cc67b171ce86eb947cf558afdbcab17e0 HT0.000132897
0x9a7447116b3a4a241ad2b3792e9283092444d101fbee09a45d31e4fac7aa082455536302021-06-13 3:23:341 min ago0x5d2ecf419cc2bb3875ed4a1da69fa597469eabc3 IN  0x4cb4c9c8cc67b171ce86eb947cf558afdbcab17e0 HT0.000132897
0xc8e8634a056a21c5140fa7175ffecf1443a3988164cd662bde30bdad2750cc6e55536292021-06-13 3:23:311 min ago0x615632476ee4b74c344f1ef988149d6693f3426b IN  0x4cb4c9c8cc67b171ce86eb947cf558afdbcab17e0 HT0.000132078
0x85543baae48341e301f915ea3e11a1c0fc8b76fe0ea614c0aab37c8484d7d61155536222021-06-13 3:23:101 min ago0x74809682c8aeaf56ebb6384e86a5a6fc972e72df IN  0x4cb4c9c8cc67b171ce86eb947cf558afdbcab17e0 HT0.000147897
0x223bce05dce2a1a359972c703fc4b3ef5ed07824f99f71b0bd3cbea668a0207d55535832021-06-13 3:21:133 mins ago0xef9ecc5ff42a66be50399a6396e69a5c15bec946 IN  0x4cb4c9c8cc67b171ce86eb947cf558afdbcab17e0 HT0.000132897
0x5baf684b21166070a70f0db0dfc137488022d707e95f420ed9ebcb86b7c9764555535662021-06-13 3:20:224 mins ago0xad890e44bacc46d7d14b604bbb8367f4b79b33be IN  0x4cb4c9c8cc67b171ce86eb947cf558afdbcab17e0 HT0.000179138
0x960d3286871c02ed85892a25b9614af8d2f8c22e57a4f1dad483cffdd288219255535572021-06-13 3:19:554 mins ago0x7c67539c3ffed589a31c410b270a492f60c27d27 IN  0x4cb4c9c8cc67b171ce86eb947cf558afdbcab17e0 HT0.000132897
0x81070a354daf1ced643551498ebef1af227f0ddc001a3192613a63f9875c3b9755535552021-06-13 3:19:495 mins ago0xad890e44bacc46d7d14b604bbb8367f4b79b33be IN  0x4cb4c9c8cc67b171ce86eb947cf558afdbcab17e0 HT0.000132897
0xaf8819384f302a85430e2559ab86fa202e778a3ab683a5bb497739582dd4c0f055535502021-06-13 3:19:345 mins ago0x74cbf9b1291a06d15d155fb5536feb1ce8e7e4e9 IN  0x4cb4c9c8cc67b171ce86eb947cf558afdbcab17e0 HT0.000157212
0xf8dce77a0f7ccea1c4b39e5181179738ef80f4ba94acff6bde86fe2757b2cc2055535502021-06-13 3:19:345 mins ago0x7c67539c3ffed589a31c410b270a492f60c27d27 IN  0x4cb4c9c8cc67b171ce86eb947cf558afdbcab17e0 HT0.000179126
0x30171678cb6e9ea0458f778e7db8a39839127f2a57b3726b638cfc77931dadd155535492021-06-13 3:19:315 mins ago0xde8589960da34eefb00ca879d8cc12b11f52cb12 IN  0x4cb4c9c8cc67b171ce86eb947cf558afdbcab17e0 HT0.000426672
0xd28438310cad097a954fe0347c0f90257b2a0317aa5d44a34e55c9a26268e4ff55535452021-06-13 3:19:195 mins ago0xad890e44bacc46d7d14b604bbb8367f4b79b33be IN  0x4cb4c9c8cc67b171ce86eb947cf558afdbcab17e0 HT0.000142328
0x989ad650f83d4662867c847fe4a3a4a4922040f07873553be249b2b18a84e42355535332021-06-13 3:18:436 mins ago0xde8589960da34eefb00ca879d8cc12b11f52cb12 IN  0x4cb4c9c8cc67b171ce86eb947cf558afdbcab17e0 HT0.000448845
0x0ed519a7e6939b4c3d4ee763759e11307ff0280c511d0334a4346e6ab232c0de55535192021-06-13 3:18:016 mins ago0xbf132199dee064fef7b6c9b70ad7fb791815cba2 IN  0x4cb4c9c8cc67b171ce86eb947cf558afdbcab17e0 HT0.00014324
0x41cea1c3a347ce75d9454d6470cda3b695042281942c3dc43d759d7c6c59e52255535082021-06-13 3:17:287 mins ago0xde8589960da34eefb00ca879d8cc12b11f52cb12 IN  0x4cb4c9c8cc67b171ce86eb947cf558afdbcab17e0 HT0.000426672
0x5af837be02b6150da75b09a4faf0e79a1b40eb71d86aacbb6b5df47c0bd81a7b55535062021-06-13 3:17:227 mins ago0x7e9f2b5d400546f27d4e8898187816e84e791e1b IN  0x4cb4c9c8cc67b171ce86eb947cf558afdbcab17e0 HT0.000157236
0x5632caff0383aef04c7c1091fd0f7587ff6a4c496ed0fdce786ad1ddbd01fe2d55534962021-06-13 3:16:527 mins ago0x974db2ed7d4062d41c10a7a77ec692076ac64fca IN  0x4cb4c9c8cc67b171ce86eb947cf558afdbcab17e0 HT0.000179138
0xb541e8a0fc2509bb064ffd904695c74cfe6c7dc9e40c7d8ed14da8e9defcb95355534922021-06-13 3:16:408 mins ago0x474c005546fe5a8fbf76cf09d5fe8119c13e5760 IN  0x4cb4c9c8cc67b171ce86eb947cf558afdbcab17e0 HT0.000143264
0x94ba9ddb328a45f183d7f5f09758b77f8d24fdf3bb417fcb17d5c88b271c91da55534912021-06-13 3:16:378 mins ago0x974db2ed7d4062d41c10a7a77ec692076ac64fca IN  0x4cb4c9c8cc67b171ce86eb947cf558afdbcab17e0 HT0.000179126
0x3bee370597c331f25f9aeced366249a7ffb1e7232fec74406b9324af95546f6b55534862021-06-13 3:16:228 mins ago0x474c005546fe5a8fbf76cf09d5fe8119c13e5760 IN  0x4cb4c9c8cc67b171ce86eb947cf558afdbcab17e0 HT0.000132897
[ Download CSV Export 
Parent Txn Hash Block From To Value
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
MasterChef

Compiler Version
v0.6.12+commit.27d51765

Optimization Enabled:
No with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at hecoinfo.com on 2021-05-29
*/

// SPDX-License-Identifier: MIT

pragma solidity >=0.5.0 <0.8.0;

// File: maki-swap-lib/contracts/math/SafeMath.sol

/**
 * @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: maki-swap-lib/contracts/token/HRC20/IHRC20.sol

pragma solidity >=0.4.0;

interface IHRC20 {
    /**
     * @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 HIP 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: maki-swap-lib/contracts/utils/Address.sol

pragma solidity ^0.6.2;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // 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 HT 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: maki-swap-lib/contracts/token/HRC20/SafeHRC20.sol

pragma solidity >=0.6.0;

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

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

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

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

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

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

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

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

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

pragma solidity >=0.6.0 <0.8.0;

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

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

// File: @openzeppelin/contracts/access/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: @openzeppelin/contracts/utils/ReentrancyGuard.sol

pragma solidity >=0.6.0 <0.8.0;

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

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

    uint256 private _status;

    constructor () internal {
        _status = _NOT_ENTERED;
    }

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

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

        _;

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

// File: maki-swap-lib/contracts/token/HRC20/HRC20.sol

pragma solidity >=0.4.0;

/**
 * @dev Implementation of the {IHRC20} 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 {HRC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-HRC20-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 HRC20 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 {IHRC20-approve}.
 */
contract HRC20 is Context, IHRC20, 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 HRC token owner.
     */
    function getOwner() external view override 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 {HRC20-totalSupply}.
     */
    function totalSupply() public override view returns (uint256) {
        return _totalSupply;
    }

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

    /**
     * @dev See {HRC20-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 override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

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

    /**
     * @dev See {HRC20-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 {HRC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {HRC20};
     *
     * Requirements:
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for `sender`'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(
            sender,
            _msgSender(),
            _allowances[sender][_msgSender()].sub(amount, 'HRC20: 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 {HRC20-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 {HRC20-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, 'HRC20: 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 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), 'HRC20: transfer from the zero address');
        require(recipient != address(0), 'HRC20: transfer to the zero address');

        _balances[sender] = _balances[sender].sub(amount, 'HRC20: 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), 'HRC20: 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), 'HRC20: burn from the zero address');

        _balances[account] = _balances[account].sub(amount, 'HRC20: 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), 'HRC20: approve from the zero address');
        require(spender != address(0), 'HRC20: 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, 'HRC20: burn amount exceeds allowance')
        );
    }
}

// File: contracts/farm/MakiToken.sol

pragma solidity ^0.6.12;

// MakiToken with Governance.
contract MakiToken is HRC20('MakiSwap', 'MAKI') {
    /// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
    function mint(address _to, uint256 _amount) public onlyOwner {
        _mint(_to, _amount);
        _moveDelegates(address(0), _delegates[_to], _amount);
    }

    // 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

    // record of each accounts delegate
    mapping (address => address) internal _delegates;

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

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

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

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

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

    /// @notice A record of states for signing / validating signatures
    mapping (address => 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);

    /// @notice An event thats emitted when a delegate account's vote balance changes
    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), "MAKI::delegateBySig: invalid signature");
        require(nonce == nonces[signatory]++, "MAKI::delegateBySig: invalid nonce");
        require(now <= expiry, "MAKI::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, "MAKI::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 MAKIs (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, "MAKI::_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: contracts/farm/SoyBar.sol

pragma solidity ^0.6.12;

// SoyBar with Governance.
contract SoyBar is HRC20("SoyBar Token", "SOY") {
    /// @dev Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
    function mint(address _to, uint256 _amount) public onlyOwner {
        _mint(_to, _amount);
        _moveDelegates(address(0), _delegates[_to], _amount);
    }

    function burn(address _from, uint256 _amount) public onlyOwner {
        _burn(_from, _amount);
        _moveDelegates(_delegates[_from], address(0), _amount);
    }

    // The MAKI TOKEN!
    MakiToken public maki;

    constructor(MakiToken _maki) public {
        maki = _maki;
    }

    // Safe maki transfer function, just in case if rounding error causes pool to not have enough MAKI.
    function safeMakiTransfer(address _to, uint256 _amount) public onlyOwner {
        uint256 makiBal = maki.balanceOf(address(this));
        if (_amount > makiBal) {
            maki.transfer(_to, makiBal);
        } else {
            maki.transfer(_to, _amount);
        }
    }

    // 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

    /// @dev A record of each accounts delegate
    mapping(address => address) internal _delegates;

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

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

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

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

    /// @dev 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)");

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

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

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

    /**
     * @dev 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];
    }

    /**
     * @dev 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);
    }

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

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

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

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

    /**
     * @dev 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;
    }

    /**
     * @dev Determine the prior number of votes for an account as of a block number
     * @dev Block number must be a finalized block or else this function will revert to prevent misinformation.
     * @param account The address of the account to check
     * @param blockNumber The block number to get the vote balance at
     * @return The number of votes the account had as of the given block
     */
    function getPriorVotes(address account, uint256 blockNumber)
        external
        view
        returns (uint256)
    {
        require(
            blockNumber < block.number,
            "MAKI::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 MAKI (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,
                "MAKI::_writeCheckpoint: block number exceeds 32 bits"
            );

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

        emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
    }

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

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

// File: contracts/farm/MasterChef.sol

pragma solidity ^0.6.12;

interface IMigratorChef {
    // Perform LP token migration from legacy MakiSwap.
    // Take the current LP token address and return the new LP token address.
    // Migrator should have full access to the caller's LP token.
    // Return the new LP token address.
    //
    // XXX Migrator must have allowance access to MakiSwap LP tokens.
    // MakiSwap must mint EXACTLY the same amount of Maki LP tokens or
    // else something bad will happen. Traditional MakiSwap does not
    // do that so be careful!
    function migrate(IHRC20 token) external returns (IHRC20);
}

// MasterChef is the master of Maki. She can make Maki and she is a fair lady.
//
// Note that it's ownable and the owner wields tremendous power. The ownership
// will be transferred to a governance smart contract once MAKI is sufficiently
// distributed and the community can show to govern itself.

contract MasterChef is Ownable, ReentrancyGuard {
    using SafeMath for uint256;
    using SafeHRC20 for IHRC20;

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

    // Info of each pool.
    struct PoolInfo {
        IHRC20 lpToken; // Address of LP token contract.
        uint256 allocPoint; // How many allocation points assigned to this pool. MAKIs to distribute per block.
        uint256 lastRewardBlock; // Last block number that MAKIs distribution occurs.
        uint256 accMakiPerShare; // Accumulated MAKIs per share, times 1e12. See below.
    }

    //** ADDRESSES **//

    // The MAKI TOKEN!
    MakiToken public maki;
    // The SOY TOKEN!
    SoyBar public soy;
    // Team address, which recieves 1.5 MAKI per block (mutable by team)
    address public team = msg.sender;
    // Treasury address, which recieves 1.5 MAKI per block (mutable by team and treasury)
    address public treasury = msg.sender;
    // The migrator contract. It has a lot of power. Can only be set through governance (owner).
    IMigratorChef public migrator;

    // ** GLOBAL VARIABLES ** //

    // MAKI tokens created per block.
    uint256 public makiPerBlock = 16e18; // 16 MAKI per block minted
    // Bonus muliplier for early maki makers.
    uint256 public bonusMultiplier = 1;
    // The block number when MAKI mining starts.
    uint256 public startBlock = block.number;
    // Total allocation points. Must be the sum of all allocation points in all pools.
    uint256 public totalAllocPoint = 0;

    // ** POOL VARIABLES ** //

    // Info of each pool.
    PoolInfo[] public poolInfo;
    // Info of each user that stakes LP tokens.
    mapping(uint256 => mapping(address => UserInfo)) public userInfo;


    event Team(address team);
    event Treasury(address treasury);
    event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
    event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);

    constructor(
        MakiToken _maki,
        SoyBar _soy
    ) public {
        maki = _maki;
        soy = _soy;
        // staking pool
        poolInfo.push(
            PoolInfo({
                lpToken: _maki,
                allocPoint: 1000,
                lastRewardBlock: startBlock,
                accMakiPerShare: 0
            })
        );

        totalAllocPoint = 1000;
    }

    modifier validatePoolByPid(uint256 _pid) {
        require(_pid < poolInfo.length, "pool does not exist");
        _;
    }

    // VALIDATION -- ELIMINATES POOL DUPLICATION RISK -- NONE
    function checkPoolDuplicate(IHRC20 _token
    ) internal view {
        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            require(poolInfo[pid].lpToken != _token, "add: existing pool");
        }
    }

    function updateMultiplier(uint256 multiplierNumber) public {
        require(msg.sender == treasury, "updateMultiplier: only treasury may update");
        bonusMultiplier = multiplierNumber;
    }

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

    // ADD -- NEW LP TOKEN POOL -- OWNER
    function add(uint256 _allocPoint, IHRC20 _lpToken, bool _withUpdate) public onlyOwner {
        checkPoolDuplicate(_lpToken);
        addPool(_allocPoint, _lpToken, _withUpdate);
    }

    function addPool(uint256 _allocPoint, IHRC20 _lpToken, bool _withUpdate) internal {
        if (_withUpdate) {
            massUpdatePools();
        }
        uint256 lastRewardBlock =
            block.number > startBlock ? block.number : startBlock;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        poolInfo.push(
            PoolInfo({
                lpToken: _lpToken,
                allocPoint: _allocPoint,
                lastRewardBlock: lastRewardBlock,
                accMakiPerShare: 0
            })
        );
        updateStakingPool();
    }

    // UPDATE -- ALLOCATION POINT -- OWNER
    function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner validatePoolByPid(_pid) {
        require(_pid < poolInfo.length, "set: pool does not exist");
        if (_withUpdate) {
            massUpdatePools();
        }
        uint256 prevAllocPoint = poolInfo[_pid].allocPoint;
        poolInfo[_pid].allocPoint = _allocPoint;
        if (prevAllocPoint != _allocPoint) {
            totalAllocPoint = totalAllocPoint.sub(prevAllocPoint).add(
                _allocPoint
            );
            updateStakingPool();
        }
    }

    // UPDATE -- STAKING POOL -- INTERNAL
    function updateStakingPool() internal {
        uint256 length = poolInfo.length;
        uint256 points = 0;
        for (uint256 pid = 1; pid < length; ++pid) {
            points = points.add(poolInfo[pid].allocPoint);
        }
        if (points != 0) {
            points = points.div(3);
            totalAllocPoint = totalAllocPoint.sub(poolInfo[0].allocPoint).add(
                points
            );
            poolInfo[0].allocPoint = points;
        }
    }

    // SET -- MIGRATOR CONTRACT -- OWNER
    function setMigrator(IMigratorChef _migrator) public {
        require(msg.sender == treasury, "setMigrator: must be from treasury");
        migrator = _migrator;
    }

    // MIGRATE -- LP TOKENS TO ANOTHER CONTRACT -- MIGRATOR
    function migrate(uint256 _pid) public validatePoolByPid(_pid) {
        require(address(migrator) != address(0), "migrate: no migrator");
        PoolInfo storage pool = poolInfo[_pid];
        IHRC20 lpToken = pool.lpToken;
        uint256 bal = lpToken.balanceOf(address(this));
        lpToken.safeApprove(address(migrator), bal);
        IHRC20 newLpToken = migrator.migrate(lpToken);
        require(bal == newLpToken.balanceOf(address(this)), "migrate: bad");
        pool.lpToken = newLpToken;
    }

    // VIEW -- BONUS MULTIPLIER -- PUBLIC
    function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) {
        return _to.sub(_from).mul(bonusMultiplier);
    }

    // VIEW -- PENDING MAKI
    function pendingMaki(uint256 _pid, address _user) external view returns (uint256) {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accMakiPerShare = pool.accMakiPerShare;
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (block.number > pool.lastRewardBlock && lpSupply != 0) {
            uint256 multiplier =
                getMultiplier(pool.lastRewardBlock, block.number);
            uint256 makiReward =
                multiplier.mul(makiPerBlock).mul(pool.allocPoint).div(
                    totalAllocPoint
                );
            accMakiPerShare = accMakiPerShare.add(
                makiReward.mul(1e12).div(lpSupply)
            );
        }
        return user.amount.mul(accMakiPerShare).div(1e12).sub(user.rewardDebt);
    }

    // UPDATE -- REWARD VARIABLES FOR ALL POOLS (HIGH GAS POSSIBLE) -- PUBLIC
    function massUpdatePools() public {
        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            updatePool(pid);
        }
    }

    // UPDATE -- REWARD VARIABLES (POOL) -- PUBLIC
    function updatePool(uint256 _pid) public validatePoolByPid(_pid) {
        PoolInfo storage pool = poolInfo[_pid];
        if (block.number <= pool.lastRewardBlock) {
            return;
        }
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (lpSupply == 0) {
            pool.lastRewardBlock = block.number;
            return;
        }
        uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
        uint256 makiReward =
            multiplier.mul(makiPerBlock).mul(pool.allocPoint).div(
                totalAllocPoint
            );
        uint256 adminFee = makiReward.mul(1000).div(10650);
        uint256 netReward = makiReward.sub(adminFee.mul(2));

        maki.mint(team, adminFee); // 1.50 MAKI per block to team (9.375%)
        maki.mint(treasury, adminFee); // 1.50 MAKI per block to treasury (9.375%)

        maki.mint(address(soy), netReward);

        pool.accMakiPerShare = pool.accMakiPerShare.add(
            netReward.mul(1e12).div(lpSupply)
        );

        pool.lastRewardBlock = block.number;
    }

    // DEPOSIT -- LP TOKENS -- LP OWNERS
    function deposit(uint256 _pid, uint256 _amount) public nonReentrant validatePoolByPid(_pid) {
        require(_pid != 0, "deposit MAKI by staking");

        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        updatePool(_pid);

        if (user.amount > 0) {
            // already deposited assets
            uint256 pending =
                user.amount.mul(pool.accMakiPerShare).div(1e12).sub(
                    user.rewardDebt
                );
            if (pending > 0) {
                // sends pending rewards, if applicable
                safeMakiTransfer(msg.sender, pending);
            }
        }

        if (_amount > 0) {
            // if adding more
            pool.lpToken.safeTransferFrom(
                address(msg.sender),
                address(this),
                _amount
            );
            user.amount = user.amount.add(_amount);
        }
        user.rewardDebt = user.amount.mul(pool.accMakiPerShare).div(1e12);
        emit Deposit(msg.sender, _pid, _amount);
    }

    // WITHDRAW -- LP TOKENS -- STAKERS
    function withdraw(uint256 _pid, uint256 _amount) public nonReentrant validatePoolByPid(_pid) {
        require(_pid != 0, "withdraw MAKI by unstaking");
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        require(user.amount >= _amount, "withdraw: not good");

        updatePool(_pid);
        uint256 pending =
            user.amount.mul(pool.accMakiPerShare).div(1e12).sub(
                user.rewardDebt
            );
        if (pending > 0) {
            safeMakiTransfer(msg.sender, pending);
        }
        if (_amount > 0) {
            user.amount = user.amount.sub(_amount);
            pool.lpToken.safeTransfer(address(msg.sender), _amount);
        }
        user.rewardDebt = user.amount.mul(pool.accMakiPerShare).div(1e12);
        emit Withdraw(msg.sender, _pid, _amount);
    }

    // STAKE -- MAKI TO MASTERCHEF -- PUBLIC MAKI HOLDERS
    function enterStaking(uint256 _amount) public nonReentrant {
        PoolInfo storage pool = poolInfo[0];
        UserInfo storage user = userInfo[0][msg.sender];
        updatePool(0);
        if (user.amount > 0) {
            uint256 pending =
                user.amount.mul(pool.accMakiPerShare).div(1e12).sub(
                    user.rewardDebt
                );
            if (pending > 0) {
                safeMakiTransfer(msg.sender, pending);
            }
        }
        if (_amount > 0) {
            pool.lpToken.safeTransferFrom(
                address(msg.sender),
                address(this),
                _amount
            );
            user.amount = user.amount.add(_amount);
        }
        user.rewardDebt = user.amount.mul(pool.accMakiPerShare).div(1e12);

        soy.mint(msg.sender, _amount);
        emit Deposit(msg.sender, 0, _amount);
    }

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

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

    // TRANSFER -- TRANSFERS SOY -- INTERNAL
    function safeMakiTransfer(address _to, uint256 _amount) internal {
        soy.safeMakiTransfer(_to, _amount);
    }

    // UPDATE -- TREASURY ADDRESS -- TREASURY || TEAM
    function newTreasury(address _treasury) public {
        require(
            msg.sender == treasury || msg.sender == team,
            "treasury: invalid permissions"
        );
        treasury = _treasury;
        emit Treasury(_treasury);
    }

    // UPDATE -- TEAM ADDRESS -- TEAM
    function newTeam(address _team) public {
        require(msg.sender == team, "team: le who are you?");
        team = _team;
        emit Team(_team);
    }
}

Contract ABI

[{"inputs":[{"internalType":"contract MakiToken","name":"_maki","type":"address"},{"internalType":"contract SoyBar","name":"_soy","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"team","type":"address"}],"name":"Team","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"treasury","type":"address"}],"name":"Treasury","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IHRC20","name":"_lpToken","type":"address"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"bonusMultiplier","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"enterStaking","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_from","type":"uint256"},{"internalType":"uint256","name":"_to","type":"uint256"}],"name":"getMultiplier","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"leaveStaking","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maki","outputs":[{"internalType":"contract MakiToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"makiPerBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"migrate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"migrator","outputs":[{"internalType":"contract IMigratorChef","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_team","type":"address"}],"name":"newTeam","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_treasury","type":"address"}],"name":"newTreasury","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingMaki","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"contract IHRC20","name":"lpToken","type":"address"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardBlock","type":"uint256"},{"internalType":"uint256","name":"accMakiPerShare","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":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IMigratorChef","name":"_migrator","type":"address"}],"name":"setMigrator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"soy","outputs":[{"internalType":"contract SoyBar","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"startBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"team","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":[],"name":"treasury","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"multiplierNumber","type":"uint256"}],"name":"updateMultiplier","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

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

0000000000000000000000005fad6fbba4bba686ba9b8052cf0bd51699f38b93000000000000000000000000fb4c85b31b888e4f84ac131667865e029d6486f7

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000005fad6fbba4bba686ba9b8052cf0bd51699f38b93
Arg [1] : 000000000000000000000000fb4c85b31b888e4f84ac131667865e029d6486f7


Deployed ByteCode Sourcemap

55946:13942:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59807:95;;;:::i;:::-;;;;;;;;;;;;;;;;;;;68368:820;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;58330:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58226:34;;;:::i;:::-;;;;;;;;;;;;;;;;;;;59952:187;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;61956:172;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;57401:17;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;67403:911;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;66451:885;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;62197:515;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;58091:40;;;:::i;:::-;;;;;;;;;;;;;;;;;;;64134:1113;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;59599:200;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;57629:36;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;63894:180;;;:::i;:::-;;60795:575;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;62942:865;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;22403:148;;;:::i;:::-;;57350:21;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;57770:29;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;57499:32;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;21752:87;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;62763:142;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;58412:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;69423:255;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;58000:34;;;:::i;:::-;;;;;;;;;;;;;;;;;;;69725:160;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;65297:1105;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;57883:35;;;:::i;:::-;;;;;;;;;;;;;;;;;;;22706:244;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;59807:95;59852:7;59879:8;:15;;;;59872:22;;59807:95;:::o;68368:820::-;24705:1;25311:7;;:19;;25303:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24705:1;25444:7;:18;;;;68438:21:::1;68462:8;68471:1;68462:11;;;;;;;;;;;;;;;;;;68438:35;;68484:21;68508:8;:11;68517:1:::0;68508:11:::1;;;;;;;;;;;:23;68520:10;68508:23;;;;;;;;;;;;;;;68484:47;;68565:7;68550:4;:11;;;:22;;68542:53;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;68606:13;68617:1;68606:10;:13::i;:::-;68630:15;68661:100;68731:4;:15;;;68661:47;68703:4;68661:37;68677:4;:20;;;68661:4;:11;;;:15;;:37;;;;:::i;:::-;:41;;:47;;;;:::i;:::-;:51;;:100;;;;:::i;:::-;68630:131;;68786:1;68776:7;:11;68772:81;;;68804:37;68821:10;68833:7;68804:16;:37::i;:::-;68772:81;68877:1;68867:7;:11;68863:152;;;68909:24;68925:7;68909:4;:11;;;:15;;:24;;;;:::i;:::-;68895:4;:11;;:38;;;;68948:55;68982:10;68995:7;68948:4;:12;;;;;;;;;;;;:25;;;;:55;;;;;:::i;:::-;68863:152;69043:47;69085:4;69043:37;69059:4;:20;;;69043:4;:11;;;:15;;:37;;;;:::i;:::-;:41;;:47;;;;:::i;:::-;69025:4;:15;;:65;;;;69103:3;;;;;;;;;;;:8;;;69112:10;69124:7;69103:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;69169:1;69157:10;69148:32;;;69172:7;69148:32;;;;;;;;;;;;;;;;;;25475:1;;;24661::::0;25623:7;:22;;;;68368:820;:::o;58330:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;58226:34::-;;;;:::o;59952:187::-;21983:12;:10;:12::i;:::-;21972:23;;:7;:5;:7::i;:::-;:23;;;21964:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60049:28:::1;60068:8;60049:18;:28::i;:::-;60088:43;60096:11;60109:8;60119:11;60088:7;:43::i;:::-;59952:187:::0;;;:::o;61956:172::-;62042:8;;;;;;;;;;;62028:22;;:10;:22;;;62020:69;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62111:9;62100:8;;:20;;;;;;;;;;;;;;;;;;61956:172;:::o;57401:17::-;;;;;;;;;;;;;:::o;67403:911::-;24705:1;25311:7;;:19;;25303:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24705:1;25444:7;:18;;;;67473:21:::1;67497:8;67506:1;67497:11;;;;;;;;;;;;;;;;;;67473:35;;67519:21;67543:8;:11;67552:1:::0;67543:11:::1;;;;;;;;;;;:23;67555:10;67543:23;;;;;;;;;;;;;;;67519:47;;67577:13;67588:1;67577:10;:13::i;:::-;67619:1;67605:4;:11;;;:15;67601:294;;;67637:15;67672:108;67746:4;:15;;;67672:47;67714:4;67672:37;67688:4;:20;;;67672:4;:11;;;:15;;:37;;;;:::i;:::-;:41;;:47;;;;:::i;:::-;:51;;:108;;;;:::i;:::-;67637:143;;67809:1;67799:7;:11;67795:89;;;67831:37;67848:10;67860:7;67831:16;:37::i;:::-;67795:89;67601:294;;67919:1;67909:7;:11;67905:237;;;67937:140;67993:10;68031:4;68055:7;67937:4;:12;;;;;;;;;;;;:29;;;;:140;;;;;;:::i;:::-;68106:24;68122:7;68106:4;:11;;;:15;;:24;;;;:::i;:::-;68092:4;:11;;:38;;;;67905:237;68170:47;68212:4;68170:37;68186:4;:20;;;68170:4;:11;;;:15;;:37;;;;:::i;:::-;:41;;:47;;;;:::i;:::-;68152:4;:15;;:65;;;;68230:3;;;;;;;;;;;:8;;;68239:10;68251:7;68230:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;68295:1;68283:10;68275:31;;;68298:7;68275:31;;;;;;;;;;;;;;;;;;25475:1;;24661::::0;25623:7;:22;;;;67403:911;:::o;66451:885::-;24705:1;25311:7;;:19;;25303:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24705:1;25444:7;:18;;;;66538:4:::1;59205:8;:15;;;;59198:4;:22;59190:54;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;66571:1:::2;66563:4;:9;;66555:48;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;66614:21;66638:8;66647:4;66638:14;;;;;;;;;;;;;;;;;;66614:38;;66663:21;66687:8;:14;66696:4;66687:14;;;;;;;;;;;:26;66702:10;66687:26;;;;;;;;;;;;;;;66663:50;;66747:7;66732:4;:11;;;:22;;66724:53;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;66790:16;66801:4;66790:10;:16::i;:::-;66817:15;66848:100;66918:4;:15;;;66848:47;66890:4;66848:37;66864:4;:20;;;66848:4;:11;;;:15;;:37;;;;:::i;:::-;:41;;:47;;;;:::i;:::-;:51;;:100;;;;:::i;:::-;66817:131;;66973:1;66963:7;:11;66959:81;;;66991:37;67008:10;67020:7;66991:16;:37::i;:::-;66959:81;67064:1;67054:7;:11;67050:152;;;67096:24;67112:7;67096:4;:11;;;:15;;:24;;;;:::i;:::-;67082:4;:11;;:38;;;;67135:55;67169:10;67182:7;67135:4;:12;;;;;;;;;;;;:25;;;;:55;;;;;:::i;:::-;67050:152;67230:47;67272:4;67230:37;67246:4;:20;;;67230:4;:11;;;:15;;:37;;;;:::i;:::-;:41;;:47;;;;:::i;:::-;67212:4;:15;;:65;;;;67314:4;67302:10;67293:35;;;67320:7;67293:35;;;;;;;;;;;;;;;;;;59255:1;;;25475::::1;24661::::0;25623:7;:22;;;;66451:885;;:::o;62197:515::-;62253:4;59205:8;:15;;;;59198:4;:22;59190:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62307:1:::1;62278:31;;62286:8;;;;;;;;;;;62278:31;;;;62270:64;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;62345:21;62369:8;62378:4;62369:14;;;;;;;;;;;;;;;;;;62345:38;;62394:14;62411:4;:12;;;;;;;;;;;;62394:29;;62434:11;62448:7;:17;;;62474:4;62448:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;62434:46;;62491:43;62519:8;;;;;;;;;;;62530:3;62491:7;:19;;;;:43;;;;;:::i;:::-;62545:17;62565:8;;;;;;;;;;;:16;;;62582:7;62565:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;62545:45;;62616:10;:20;;;62645:4;62616:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;62609:3;:42;62601:67;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;62694:10;62679:4;:12;;;:25;;;;;;;;;;;;;;;;;;59255:1;;;;62197:515:::0;;:::o;58091:40::-;;;;:::o;64134:1113::-;64193:4;59205:8;:15;;;;59198:4;:22;59190:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64210:21:::1;64234:8;64243:4;64234:14;;;;;;;;;;;;;;;;;;64210:38;;64279:4;:20;;;64263:12;:36;64259:75;;64316:7;;;64259:75;64344:16;64363:4;:12;;;;;;;;;;;;:22;;;64394:4;64363:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;64344:56;;64427:1;64415:8;:13;64411:102;;;64468:12;64445:4;:20;;:35;;;;64495:7;;;;64411:102;64523:18;64544:49;64558:4;:20;;;64580:12;64544:13;:49::i;:::-;64523:70;;64604:18;64638:102;64710:15;;64638:49;64671:4;:15;;;64638:28;64653:12;;64638:10;:14;;:28;;;;:::i;:::-;:32;;:49;;;;:::i;:::-;:53;;:102;;;;:::i;:::-;64604:136;;64751:16;64770:31;64795:5;64770:20;64785:4;64770:10;:14;;:20;;;;:::i;:::-;:24;;:31;;;;:::i;:::-;64751:50;;64812:17;64832:31;64847:15;64860:1;64847:8;:12;;:15;;;;:::i;:::-;64832:10;:14;;:31;;;;:::i;:::-;64812:51;;64876:4;;;;;;;;;;;:9;;;64886:4;;;;;;;;;;;64892:8;64876:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;64952:4;;;;;;;;;;;:9;;;64962:8;;;;;;;;;;;64972;64952:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;65038:4;;;;;;;;;;;:9;;;65056:3;;;;;;;;;;;65062:9;65038:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;65108:83;65147:33;65171:8;65147:19;65161:4;65147:9;:13;;:19;;;;:::i;:::-;:23;;:33;;;;:::i;:::-;65108:4;:20;;;:24;;:83;;;;:::i;:::-;65085:4;:20;;:106;;;;65227:12;65204:4;:20;;:35;;;;59255:1;;;;;;;64134:1113:::0;;:::o;59599:200::-;59691:8;;;;;;;;;;;59677:22;;:10;:22;;;59669:77;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59775:16;59757:15;:34;;;;59599:200;:::o;57629:36::-;;;;;;;;;;;;;:::o;63894:180::-;63939:14;63956:8;:15;;;;63939:32;;63987:11;63982:85;64010:6;64004:3;:12;63982:85;;;64040:15;64051:3;64040:10;:15::i;:::-;64018:5;;;;;63982:85;;;;63894:180;:::o;60795:575::-;21983:12;:10;:12::i;:::-;21972:23;;:7;:5;:7::i;:::-;:23;;;21964:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60896:4:::1;59205:8;:15;;;;59198:4;:22;59190:54;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;60928:8:::2;:15;;;;60921:4;:22;60913:59;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;60987:11;60983:61;;;61015:17;:15;:17::i;:::-;60983:61;61054:22;61079:8;61088:4;61079:14;;;;;;;;;;;;;;;;;;:25;;;61054:50;;61143:11;61115:8;61124:4;61115:14;;;;;;;;;;;;;;;;;;:25;;:39;;;;61187:11;61169:14;:29;61165:198;;61233:84;61291:11;61233:35;61253:14;61233:15;;:19;;:35;;;;:::i;:::-;:39;;:84;;;;:::i;:::-;61215:15;:102;;;;61332:19;:17;:19::i;:::-;61165:198;59255:1;22043::::1;60795:575:::0;;;:::o;62942:865::-;63015:7;63035:21;63059:8;63068:4;63059:14;;;;;;;;;;;;;;;;;;63035:38;;63084:21;63108:8;:14;63117:4;63108:14;;;;;;;;;;;:21;63123:5;63108:21;;;;;;;;;;;;;;;63084:45;;63140:23;63166:4;:20;;;63140:46;;63197:16;63216:4;:12;;;;;;;;;;;;:22;;;63247:4;63216:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63197:56;;63283:4;:20;;;63268:12;:35;:52;;;;;63319:1;63307:8;:13;;63268:52;63264:455;;;63337:18;63375:49;63389:4;:20;;;63411:12;63375:13;:49::i;:::-;63337:87;;63439:18;63477:110;63553:15;;63477:49;63510:4;:15;;;63477:28;63492:12;;63477:10;:14;;:28;;;;:::i;:::-;:32;;:49;;;;:::i;:::-;:53;;:110;;;;:::i;:::-;63439:148;;63620:87;63658:34;63683:8;63658:20;63673:4;63658:10;:14;;:20;;;;:::i;:::-;:24;;:34;;;;:::i;:::-;63620:15;:19;;:87;;;;:::i;:::-;63602:105;;63264:455;;;63736:63;63783:4;:15;;;63736:42;63773:4;63736:32;63752:15;63736:4;:11;;;:15;;:32;;;;:::i;:::-;:36;;:42;;;;:::i;:::-;:46;;:63;;;;:::i;:::-;63729:70;;;;;;62942:865;;;;:::o;22403:148::-;21983:12;:10;:12::i;:::-;21972:23;;:7;:5;:7::i;:::-;:23;;;21964:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22510:1:::1;22473:40;;22494:6;::::0;::::1;;;;;;;;22473:40;;;;;;;;;;;;22541:1;22524:6:::0;::::1;:19;;;;;;;;;;;;;;;;;;22403:148::o:0;57350:21::-;;;;;;;;;;;;;:::o;57770:29::-;;;;;;;;;;;;;:::o;57499:32::-;;;;;;;;;;;;;:::o;21752:87::-;21798:7;21825:6;;;;;;;;;;;21818:13;;21752:87;:::o;62763:142::-;62835:7;62862:35;62881:15;;62862:14;62870:5;62862:3;:7;;:14;;;;:::i;:::-;:18;;:35;;;;:::i;:::-;62855:42;;62763:142;;;;:::o;58412:64::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;69423:255::-;69517:8;;;;;;;;;;;69503:22;;:10;:22;;;:44;;;;69543:4;;;;;;;;;;;69529:18;;:10;:18;;;69503:44;69481:123;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69626:9;69615:8;;:20;;;;;;;;;;;;;;;;;;69651:19;69660:9;69651:19;;;;;;;;;;;;;;;;;;;;69423:255;:::o;58000:34::-;;;;:::o;69725:160::-;69797:4;;;;;;;;;;;69783:18;;:10;:18;;;69775:52;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69845:5;69838:4;;:12;;;;;;;;;;;;;;;;;;69866:11;69871:5;69866:11;;;;;;;;;;;;;;;;;;;;69725:160;:::o;65297:1105::-;24705:1;25311:7;;:19;;25303:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24705:1;25444:7;:18;;;;65383:4:::1;59205:8;:15;;;;59198:4;:22;59190:54;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;65416:1:::2;65408:4;:9;;65400:45;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;65458:21;65482:8;65491:4;65482:14;;;;;;;;;;;;;;;;;;65458:38;;65507:21;65531:8;:14;65540:4;65531:14;;;;;;;;;;;:26;65546:10;65531:26;;;;;;;;;;;;;;;65507:50;;65568:16;65579:4;65568:10;:16::i;:::-;65615:1;65601:4;:11;;;:15;65597:392;;;65674:15;65709:108;65783:4;:15;;;65709:47;65751:4;65709:37;65725:4;:20;;;65709:4;:11;;;:15;;:37;;;;:::i;:::-;:41;;:47;;;;:::i;:::-;:51;;:108;;;;:::i;:::-;65674:143;;65846:1;65836:7;:11;65832:146;;;65925:37;65942:10;65954:7;65925:16;:37::i;:::-;65832:146;65597:392;;66015:1;66005:7;:11;66001:268;;;66064:140;66120:10;66158:4;66182:7;66064:4;:12;;;;;;;;;;;;:29;;;;:140;;;;;;:::i;:::-;66233:24;66249:7;66233:4;:11;;;:15;;:24;;;;:::i;:::-;66219:4;:11;;:38;;;;66001:268;66297:47;66339:4;66297:37;66313:4;:20;;;66297:4;:11;;;:15;;:37;;;;:::i;:::-;:41;;:47;;;;:::i;:::-;66279:4;:15;;:65;;;;66380:4;66368:10;66360:34;;;66386:7;66360:34;;;;;;;;;;;;;;;;;;59255:1;;25475::::1;24661::::0;25623:7;:22;;;;65297:1105;;:::o;57883:35::-;;;;:::o;22706:244::-;21983:12;:10;:12::i;:::-;21972:23;;:7;:5;:7::i;:::-;:23;;;21964:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22815:1:::1;22795:22;;:8;:22;;;;22787:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22905:8;22876:38;;22897:6;::::0;::::1;;;;;;;;22876:38;;;;;;;;;;;;22934:8;22925:6;::::0;:17:::1;;;;;;;;;;;;;;;;;;22706:244:::0;:::o;2352:471::-;2410:7;2660:1;2655;:6;2651:47;;;2685:1;2678:8;;;;2651:47;2710:9;2726:1;2722;:5;2710:17;;2755:1;2750;2746;:5;;;;;;:10;2738:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2814:1;2807:8;;;2352:471;;;;;:::o;3299:132::-;3357:7;3384:39;3388:1;3391;3384:39;;;;;;;;;;;;;;;;;:3;:39::i;:::-;3377:46;;3299:132;;;;:::o;1428:136::-;1486:7;1513:43;1517:1;1520;1513:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;1506:50;;1428:136;;;;:::o;69242:118::-;69318:3;;;;;;;;;;;:20;;;69339:3;69344:7;69318:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69242:118;;:::o;16367:211::-;16484:86;16504:5;16534:23;;;16559:2;16563:5;16511:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16484:19;:86::i;:::-;16367:211;;;:::o;20291:106::-;20344:15;20379:10;20372:17;;20291:106;:::o;59335:256::-;59409:14;59426:8;:15;;;;59409:32;;59457:11;59452:132;59480:6;59474:3;:12;59452:132;;;59543:6;59518:31;;:8;59527:3;59518:13;;;;;;;;;;;;;;;;;;:21;;;;;;;;;;;;:31;;;;59510:62;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59488:5;;;;;59452:132;;;;59335:256;;:::o;60147:596::-;60244:11;60240:61;;;60272:17;:15;:17::i;:::-;60240:61;60311:23;60365:10;;60350:12;:25;:53;;60393:10;;60350:53;;;60378:12;60350:53;60311:92;;60432:32;60452:11;60432:15;;:19;;:32;;;;:::i;:::-;60414:15;:50;;;;60475:8;60503:191;;;;;;;;60540:8;60503:191;;;;;;60579:11;60503:191;;;;60626:15;60503:191;;;;60677:1;60503:191;;;60475:230;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60716:19;:17;:19::i;:::-;60147:596;;;;:::o;16586:248::-;16730:96;16750:5;16780:27;;;16809:4;16815:2;16819:5;16757:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16730:19;:96::i;:::-;16586:248;;;;:::o;964:181::-;1022:7;1042:9;1058:1;1054;:5;1042:17;;1083:1;1078;:6;;1070:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1136:1;1129:8;;;964:181;;;;:::o;17103:670::-;17530:1;17521:5;:10;17520:62;;;;17580:1;17537:5;:15;;;17561:4;17568:7;17537:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:44;17520:62;17498:166;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17675:90;17695:5;17725:22;;;17749:7;17758:5;17702:62;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17675:19;:90::i;:::-;17103:670;;;:::o;61421:485::-;61470:14;61487:8;:15;;;;61470:32;;61513:14;61547:11;61561:1;61547:15;;61542:115;61570:6;61564:3;:12;61542:115;;;61609:36;61620:8;61629:3;61620:13;;;;;;;;;;;;;;;;;;:24;;;61609:6;:10;;:36;;;;:::i;:::-;61600:45;;61578:5;;;;;61542:115;;;;61681:1;61671:6;:11;61667:232;;61708:13;61719:1;61708:6;:10;;:13;;;;:::i;:::-;61699:22;;61754:87;61820:6;61754:43;61774:8;61783:1;61774:11;;;;;;;;;;;;;;;;;;:22;;;61754:15;;:19;;:43;;;;:::i;:::-;:47;;:87;;;;:::i;:::-;61736:15;:105;;;;61881:6;61856:8;61865:1;61856:11;;;;;;;;;;;;;;;;;;:22;;:31;;;;61667:232;61421:485;;:::o;3927:312::-;4047:7;4079:1;4075;:5;4082:12;4067:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4106:9;4122:1;4118;:5;;;;;;4106:17;;4230:1;4223:8;;;3927:312;;;;;:::o;1867:226::-;1987:7;2020:1;2015;:6;;2023:12;2007:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2047:9;2063:1;2059;:5;2047:17;;2084:1;2077:8;;;1867:226;;;;;:::o;18878:774::-;19302:23;19328:69;19356:4;19328:69;;;;;;;;;;;;;;;;;19336:5;19328:27;;;;:69;;;;;:::i;:::-;19302:95;;19432:1;19412:10;:17;:21;19408:237;;;19567:10;19556:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19548:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19408:237;18878:774;;;:::o;13204:230::-;13341:12;13373:53;13396:6;13404:4;13410:1;13413:12;13373:22;:53::i;:::-;13366:60;;13204:230;;;;;:::o;14691:1020::-;14864:12;14897:18;14908:6;14897:10;:18::i;:::-;14889:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15023:12;15037:23;15064:6;:11;;15083:8;15093:4;15064:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15022:76;;;;15113:7;15109:595;;;15144:10;15137:17;;;;;;15109:595;15278:1;15258:10;:17;:21;15254:439;;;15521:10;15515:17;15582:15;15569:10;15565:2;15561:19;15554:44;15469:148;15664:12;15657:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14691:1020;;;;;;;:::o;10067:641::-;10127:4;10389:16;10416:19;10438:66;10416:88;;;;10620:7;10608:20;10596:32;;10669:11;10657:8;:23;;:42;;;;;10696:3;10684:15;;:8;:15;;10657:42;10649:51;;;;10067:641;;;:::o

Swarm Source

ipfs://434439277c7d52ad1c93b46106f92fc1c3ddee3c023d4cdf4754d7094a13b800
Block Transaction Gas Used Reward
Age Block Fee Address Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading
Loading