Contract 0xaef349e1736b8a4b1b243a369106293c3a0b9d09 3

Txn Hash
Block
From
To
Value [Txn Fee]
0x8148a20dc26b759018df2d0b87e998af01c21bd9da3cb8acd18358250d3d358d131972822021-07-28 23:39:0715 mins ago0xb0310e3b2e271632b0f94d402ed80c1796220dc1 IN  0xaef349e1736b8a4b1b243a369106293c3a0b9d090 FTM0.011187246664
0xaf7137dca5cb4060ebb69c86353f4caa4c2336795512bae48a84d3f569ce05c2131958492021-07-28 23:16:2437 mins ago0x46020205abd2cd506e135d8f36db5c48d1c0183e IN  0xaef349e1736b8a4b1b243a369106293c3a0b9d090 FTM0.024242512141
0xe5d5b5dafdfb3e83f623748f27bed59ae0cc7a250c62a11389bc0b73822b8046131934092021-07-28 22:43:091 hr 10 mins ago0x111269c8208d8595987f9e43fe38fce135bb91c6 IN  0xaef349e1736b8a4b1b243a369106293c3a0b9d090 FTM0.024240762801
0xe5d436cc9242a4609bf167690052044d549c20d67520933fa61a5257d44a638b131925052021-07-28 22:31:031 hr 23 mins ago0x131b5bec9c1eda71f30a746cd4cdbcf6b4a159de IN  0xaef349e1736b8a4b1b243a369106293c3a0b9d090 FTM0.026517449238
0xb42470850530068c3331fe0df54d7a6c62c94e002e89ee02806bd7d57d95acdc131924282021-07-28 22:30:021 hr 24 mins ago0x131b5bec9c1eda71f30a746cd4cdbcf6b4a159de IN  0xaef349e1736b8a4b1b243a369106293c3a0b9d090 FTM0.029026161766
0xa2a9f4b42c77f54cb3cc99b5268110ec6f565efbe8d8298e6cf64835e7ecace0131915172021-07-28 22:17:171 hr 36 mins ago0x0267c774380db18ed0c9ca3e41ed086e53750480 IN  0xaef349e1736b8a4b1b243a369106293c3a0b9d090 FTM0.022095594922
0xe983e7b72ec3a4f6e13fbf37e5e4bfed5d8830d75e77de2d3f7161cb0d17c0e6131915042021-07-28 22:17:031 hr 37 mins ago0x0267c774380db18ed0c9ca3e41ed086e53750480 IN  0xaef349e1736b8a4b1b243a369106293c3a0b9d090 FTM0.024242512141
0xeb1a4b88cb8cfc11a21b509d42b1b8a28e786a646749f8a13f00facf52c668dc131913822021-07-28 22:15:011 hr 39 mins ago0x508122b24cf1acf061f43bfed18417428520ba6f IN  0xaef349e1736b8a4b1b243a369106293c3a0b9d090 FTM0.024306760626
0xab69d1e825a8bd0f79d73d24a5c9a5a0146980cab2e28c17600c1c2d2194f6b4131910002021-07-28 22:09:351 hr 44 mins ago0x508122b24cf1acf061f43bfed18417428520ba6f IN  0xaef349e1736b8a4b1b243a369106293c3a0b9d090 FTM0.022065538081
0xc3f749a9c312581370ded97471b427855cd7c28173df79a7c9468eeb1b4b093d131909972021-07-28 22:09:331 hr 44 mins ago0x508122b24cf1acf061f43bfed18417428520ba6f IN  0xaef349e1736b8a4b1b243a369106293c3a0b9d090 FTM0.022065538081
0x4a9e4ebe323cf95655cf94ae1bafe30f51071943f19e347da96e3466d56cab71131909952021-07-28 22:09:311 hr 44 mins ago0x508122b24cf1acf061f43bfed18417428520ba6f IN  0xaef349e1736b8a4b1b243a369106293c3a0b9d090 FTM0.022065538081
0x4f2d2a0f2782d4f6278f8420062c45dce93ddbf6ed18cf08bb132704aa6aa022131909382021-07-28 22:08:461 hr 45 mins ago0x508122b24cf1acf061f43bfed18417428520ba6f IN  0xaef349e1736b8a4b1b243a369106293c3a0b9d090 FTM0.021799956469
0x0ad899fd3f107ded896c981560bac08f4916d88925c9fdfee2c0a1a9eaee5621131908092021-07-28 22:07:021 hr 47 mins ago0x508122b24cf1acf061f43bfed18417428520ba6f IN  0xaef349e1736b8a4b1b243a369106293c3a0b9d090 FTM0.022314784038
0x2412cff2f0911d873b227f5c063ae92bbcda8139d3d5fef857ccf4abaa5ed52f131885382021-07-28 21:36:182 hrs 17 mins ago0x78ce9fe8d59e2e39fc100a02d30109b16d2d7fd9 IN  0xaef349e1736b8a4b1b243a369106293c3a0b9d090 FTM0.029026161766
0x6ae01ee4f232ee770d1e15aa88d477748c99d46780bb0790fd49fda6184f0437131881752021-07-28 21:31:162 hrs 22 mins ago0xe5f008411335787f4d92213a1c3d854b08df3e4f IN  0xaef349e1736b8a4b1b243a369106293c3a0b9d090 FTM0.0076214
0xd7efe16d045c0d965fcfcac5f674a74d7ce6a88bd782d8895766fdc870bdf9f1131880892021-07-28 21:30:072 hrs 24 mins ago0xf0773108b4ebd43513c0e82e1ecc26efedd937f1 IN  0xaef349e1736b8a4b1b243a369106293c3a0b9d090 FTM0.022095594922
0x6ebac413c9512af6d04aeecaeb8ce7eec46e854556223adfced1e258b1bd5229131880862021-07-28 21:30:052 hrs 24 mins ago0xf0773108b4ebd43513c0e82e1ecc26efedd937f1 IN  0xaef349e1736b8a4b1b243a369106293c3a0b9d090 FTM0.024242512141
0xb2153e06450a20820fee9f820944465b4da18a92af174e0865721920799fec2d131880742021-07-28 21:29:452 hrs 24 mins ago0x78ce9fe8d59e2e39fc100a02d30109b16d2d7fd9 IN  0xaef349e1736b8a4b1b243a369106293c3a0b9d090 FTM0.023420004299
0x6868768575898364cfd4635695f465438041f58b4bc9fc662bb6d3e6642949ec131880652021-07-28 21:29:392 hrs 24 mins ago0x3f67b39d46eaf6369e0b4f1561c2101f455d11d9 IN  0xaef349e1736b8a4b1b243a369106293c3a0b9d090 FTM0.0076415
0x639bcd5bfb67c9fd198151910485760db0faebb4fe95e65cdda4436402d42eb6131879552021-07-28 21:28:132 hrs 25 mins ago0x3f67b39d46eaf6369e0b4f1561c2101f455d11d9 IN  0xaef349e1736b8a4b1b243a369106293c3a0b9d090 FTM0.0069464
0xb5e921c6719b4258e1e51a651864cdd0851b3080f11af5b7da839d10ee38481f131866342021-07-28 21:10:122 hrs 43 mins ago0xc1d7ffe1b3db8b5d8a2ac0720d7ed1920f33e9f9 IN  0xaef349e1736b8a4b1b243a369106293c3a0b9d090 FTM0.00762195
0x11036ccacbc29c5b48285741b2ffd16c050cf89303bf32cf14a85360658d5f48131863432021-07-28 21:05:332 hrs 48 mins ago0x6d0d97b09bd491ac392a634ad61b02108f4d9641 IN  0xaef349e1736b8a4b1b243a369106293c3a0b9d090 FTM0.021818868407
0x0b04b2d855ed02dec7fb674052adc88e801d2c5af4eb3c8e91fee970f642f6d8131862842021-07-28 21:04:362 hrs 49 mins ago0x5290f8e159c2c05a39fb05ac73338788531f7790 IN  0xaef349e1736b8a4b1b243a369106293c3a0b9d090 FTM0.00694695
0x0df07a6bee5323f8729c4e7efe3abebcb67a016d15757071c35db9fe9c004c34131862672021-07-28 21:04:232 hrs 49 mins ago0x5290f8e159c2c05a39fb05ac73338788531f7790 IN  0xaef349e1736b8a4b1b243a369106293c3a0b9d090 FTM0.00762195
0x0af146c2795150035b884ee0a2d861662f0d0ddfadddf117d9dbf91544bf2f67131861762021-07-28 21:03:042 hrs 51 mins ago0xdd33647d38954af6eb9f0290be6d2b36aa1199d8 IN  0xaef349e1736b8a4b1b243a369106293c3a0b9d090 FTM0.00694695
[ Download CSV Export 
Latest 1 internal transaction
Parent Txn Hash Block From To Value
0x91e01e9a1b58312754c242e073162d501fbb06c9fd2a5f3b31e8b4630a711ba571455682021-05-21 11:57:5268 days 11 hrs ago 0x948dfa10298fadc0863a7bfb2a1439a8a588895d  Contract Creation0 FTM
[ Download CSV Export 
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
WakaFarm

Compiler Version
v0.6.12+commit.27d51765

Optimization Enabled:
No with 200 runs

Other Settings:
default evmVersion, None license

Contract Source Code (Solidity)

/**
 *Submitted for verification at FtmScan.com on 2021-05-24
*/

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

// SPDX-License-Identifier: MIT

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/math/SafeMath.sol



// pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b > a) return (false, 0);
        return (true, a - b);
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, 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 (true, 0);
        uint256 c = a * b;
        if (c / a != b) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a / b);
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a % b);
    }

    /**
     * @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) {
        require(b <= a, "SafeMath: subtraction overflow");
        return a - b;
    }

    /**
     * @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) {
        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, reverting 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) {
        require(b > 0, "SafeMath: division by zero");
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting 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) {
        require(b > 0, "SafeMath: modulo by zero");
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * 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);
        return a - b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * 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);
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a % b;
    }
}

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol



// pragma solidity >=0.6.0 <0.8.0;

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

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

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

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

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

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

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

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

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



// pragma solidity >=0.6.0 <0.8.0;




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

    mapping (address => uint256) private _balances;

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

    uint256 private _totalSupply;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _beforeTokenTransfer(sender, recipient, amount);

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

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

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

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

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

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

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

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

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

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

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

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



// pragma solidity >=0.6.2 <0.8.0;

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

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

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

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

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

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

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

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

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: value }(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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

// File: @openzeppelin/contracts/token/ERC20/SafeERC20.sol



// pragma solidity >=0.6.0 <0.8.0;




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

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

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

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

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

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

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

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

// File: contracts/WakaToken.sol



// pragma solidity =0.6.12;



contract WakaToken is ERC20('Waka.Finance', 'WAKA'), Ownable {

    address public marketing; // ~2.5%
    address public ido; // 2.5%
    address public devFund; // 10%
    address public initialLPReward; // 5%
    address public ecosystemGrants; // 2.5%



    // pre-mints 25% of the token supply
    constructor (address _marketing, address _ido, address _devFund, address _initialLPReward, address _grants) public {

        marketing = _marketing;
        ido = _ido;
        devFund = _devFund;
        initialLPReward = _initialLPReward;
        ecosystemGrants = _grants;

        mintTo(marketing, 253696000000000000000000);
        mintTo(ido, 250000000000000000000000);
        mintTo(devFund, 1000000000000000000000000);
        mintTo(initialLPReward, 500000000000000000000000);
        mintTo(ecosystemGrants, 250000000000000000000000);

    }

    /// @notice Creates `_amount` token to `_to`. Must only be called by the owner.
    function mintTo(address _to, uint256 _amount) public onlyOwner {
        _mint(_to, _amount);
    }
}

// File: contracts/WakaFarm.sol



// pragma solidity =0.6.12;







contract WakaFarm is Ownable {

    using SafeMath for uint256;
    using SafeERC20 for IERC20;

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

    // Info of each pool.
    struct PoolInfo {
        IERC20 token; // Address of token or LP contract
        uint256 allocPoint; // How many allocation points assigned to this pool. Waka to distribute per block.
        uint256 lastRewardTime; // Last block time that Waka distribution occurs.
        uint256 accWakaPerShare; // Accumulated Waka per share, times 1e12. See below.
    }

    // Waka tokens created first block. -> x Waka per block to start
    uint256 public wakaStartTime;
    // Total allocation points. Must be the sum of all allocation points in all pools.
    uint256 public totalAllocPoint = 0;
    // The block time when Waka mining starts ->
    uint256 public startTime;
    // Time when bonus Waka period ends.
    uint256 public bonusEndTime;
    // how many time period will change the common difference before bonus end.
    uint256 public bonusBeforeBulkTimePeriod;
    // how many time period will change the common difference after bonus end.
    uint256 public bonusEndBulkTimePeriod;
    // Waka tokens created at bonus end block. ->
    uint256 public wakaBonusEndTime;
    // max reward block
    uint256 public maxRewardTimestamp;
    // bonus before the common difference
    uint256 public bonusBeforeCommonDifference;
    // bonus after the common difference
    uint256 public bonusEndCommonDifference;
    // Accumulated Waka per share, times 1e12.
    uint256 public accWakaPerShareMultiple = 1E12;
    // The WakaSwap token!
    WakaToken public waka;
    // Maintenance address.
    address public maintenance;
    // Info on each pool added
    PoolInfo[] public poolInfo;
    // Info of each user that stakes tokens.
    mapping(uint256 => mapping(address => UserInfo)) public userInfo;

    event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
    event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
    event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);

    constructor(
        WakaToken _waka,
        address _maintenanceAddr,
        uint256 _wakaStartTime,
        uint256 _startTime,
        uint256 _bonusEndTime,
        uint256 _bonusBeforeBulkTimePeriod,
        uint256 _bonusBeforeCommonDifference,
        uint256 _bonusEndCommonDifference
    ) public {
        waka = _waka;
        maintenance = _maintenanceAddr;
        wakaStartTime = _wakaStartTime;
        startTime = _startTime;
        bonusEndTime = _bonusEndTime;
        bonusBeforeBulkTimePeriod = _bonusBeforeBulkTimePeriod;
        bonusBeforeCommonDifference = _bonusBeforeCommonDifference;
        bonusEndCommonDifference = _bonusEndCommonDifference;
        bonusEndBulkTimePeriod = bonusEndTime.sub(startTime);
        // waka created when bonus end first block
        // (wakaStartTime - bonusBeforeCommonDifference * ((bonusEndTime-startTime)/bonusBeforeBulkTimePeriod - 1)) * bonusBeforeBulkTimePeriod*(bonusEndBulkTimePeriod/bonusBeforeBulkTimePeriod) * bonusEndBulkTimePeriod
        wakaBonusEndTime = wakaStartTime
        .sub(bonusEndTime.sub(startTime).div(bonusBeforeBulkTimePeriod).sub(1).mul(bonusBeforeCommonDifference))
        .mul(bonusBeforeBulkTimePeriod)
        .mul(bonusEndBulkTimePeriod.div(bonusBeforeBulkTimePeriod))
        .div(bonusEndBulkTimePeriod);
        // max mint block time, _wakaInitTime - (MAX-1)*_commonDifference = 0
        // MAX = startTime + bonusEndBulkTimePeriod * (_wakaInitTime/_commonDifference + 1)
        maxRewardTimestamp = startTime.add(
            bonusEndBulkTimePeriod.mul(wakaBonusEndTime.div(bonusEndCommonDifference).add(1))
        );
    }

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

    // Add a new token or LP to the pool. Can only be called by the owner.
    // XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do!
    function add(
        uint256 _allocPoint,
        IERC20 _token,
        bool _withUpdate
    ) public onlyOwner {
        if (_withUpdate) {
            massUpdatePools();
        }
        uint256 lastRewardTime = block.timestamp > startTime ? block.timestamp : startTime;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        poolInfo.push(PoolInfo({
          token: _token,
          allocPoint: _allocPoint,
          lastRewardTime: lastRewardTime,
          accWakaPerShare: 0
        }));
    }

    // Update the given pool's Waka allocation point. Can only be called by the owner.
    function set(
        uint256 _pid,
        uint256 _allocPoint,
        bool _withUpdate
    ) public onlyOwner {
        if (_withUpdate) {
            massUpdatePools();
        }
        totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
        poolInfo[_pid].allocPoint = _allocPoint;
    }

    // (_from,_to]
    function getTotalRewardInfoInSameCommonDifference(
        uint256 _from,
        uint256 _to,
        uint256 _wakaInitTime,
        uint256 _bulkTimePeriod,
        uint256 _commonDifference
    ) public view returns (uint256 totalReward) {
        if (_to <= startTime || maxRewardTimestamp <= _from) {
            return 0;
        }
        if (_from < startTime) {
            _from = startTime;
        }
        if (maxRewardTimestamp < _to) {
            _to = maxRewardTimestamp;
        }
        uint256 currentBulkNumber = _to.sub(startTime).div(_bulkTimePeriod).add(
            _to.sub(startTime).mod(_bulkTimePeriod) > 0 ? 1 : 0
        );
        if (currentBulkNumber < 1) {
            currentBulkNumber = 1;
        }
        uint256 fromBulkNumber = _from.sub(startTime).div(_bulkTimePeriod).add(
            _from.sub(startTime).mod(_bulkTimePeriod) > 0 ? 1 : 0
        );
        if (fromBulkNumber < 1) {
            fromBulkNumber = 1;
        }
        if (fromBulkNumber == currentBulkNumber) {
            return _to.sub(_from).mul(_wakaInitTime.sub(currentBulkNumber.sub(1).mul(_commonDifference)));
        }
        uint256 lastRewardBulkLastTime = startTime.add(_bulkTimePeriod.mul(fromBulkNumber));
        uint256 currentPreviousBulkLastTime = startTime.add(_bulkTimePeriod.mul(currentBulkNumber.sub(1)));
        {
            uint256 tempFrom = _from;
            uint256 tempTo = _to;
            totalReward = tempTo
            .sub(tempFrom > currentPreviousBulkLastTime ? tempFrom : currentPreviousBulkLastTime)
            .mul(_wakaInitTime.sub(currentBulkNumber.sub(1).mul(_commonDifference)));
            if (lastRewardBulkLastTime > tempFrom && lastRewardBulkLastTime <= tempTo) {
                totalReward = totalReward.add(
                    lastRewardBulkLastTime.sub(tempFrom).mul(
                        _wakaInitTime.sub(fromBulkNumber > 0 ? fromBulkNumber.sub(1).mul(_commonDifference) : 0)
                    )
                );
            }
        }
        {
            // avoids stack too deep errors
            uint256 tempWakaInitTime = _wakaInitTime;
            uint256 tempBulkTimePeriod = _bulkTimePeriod;
            uint256 tempCommonDifference = _commonDifference;
            if (currentPreviousBulkLastTime > lastRewardBulkLastTime) {
                uint256 tempCurrentPreviousBulkLastTime = currentPreviousBulkLastTime;
                // sum( [fromBulkNumber+1, currentBulkNumber] )
                // 1/2 * N *( a1 + aN)
                uint256 N = tempCurrentPreviousBulkLastTime.sub(lastRewardBulkLastTime).div(tempBulkTimePeriod);
                if (N > 1) {
                    uint256 a1 = tempBulkTimePeriod.mul(
                        tempWakaInitTime.sub(
                            lastRewardBulkLastTime.sub(startTime).mul(tempCommonDifference).div(tempBulkTimePeriod)
                        )
                    );
                    uint256 aN = tempBulkTimePeriod.mul(
                        tempWakaInitTime.sub(
                            tempCurrentPreviousBulkLastTime.sub(startTime).div(tempBulkTimePeriod).sub(1).mul(
                                tempCommonDifference
                            )
                        )
                    );
                    totalReward = totalReward.add(N.mul(a1.add(aN)).div(2));
                } else {
                    totalReward = totalReward.add(
                        tempBulkTimePeriod.mul(tempWakaInitTime.sub(currentBulkNumber.sub(2).mul(tempCommonDifference)))
                    );
                }
            }
        }
    }

    // Return total reward over the given _from to _to block.
    function getTotalRewardInfo(uint256 _from, uint256 _to) public view returns (uint256 totalReward) {
        if (_to <= bonusEndTime) {
            totalReward = getTotalRewardInfoInSameCommonDifference(
                _from,
                _to,
                wakaStartTime,
                bonusBeforeBulkTimePeriod,
                bonusBeforeCommonDifference
            );
        } else if (_from >= bonusEndTime) {
            totalReward = getTotalRewardInfoInSameCommonDifference(
                _from,
                _to,
                wakaBonusEndTime,
                bonusEndBulkTimePeriod,
                bonusEndCommonDifference
            );
        } else {
            totalReward = getTotalRewardInfoInSameCommonDifference(
                _from,
                bonusEndTime,
                wakaStartTime,
                bonusBeforeBulkTimePeriod,
                bonusBeforeCommonDifference
            )
            .add(
                getTotalRewardInfoInSameCommonDifference(
                    bonusEndTime,
                    _to,
                    wakaBonusEndTime,
                    bonusEndBulkTimePeriod,
                    bonusEndCommonDifference
                )
            );
        }
    }

    // View function to see pending Waka on frontend.
    function pendingWaka(uint256 _pid, address _user) external view returns (uint256) {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accWakaPerShare = pool.accWakaPerShare;
        uint256 lpSupply = pool.token.balanceOf(address(this));
        if (block.timestamp > pool.lastRewardTime && lpSupply != 0 && pool.lastRewardTime < maxRewardTimestamp) {
            uint256 totalReward = getTotalRewardInfo(pool.lastRewardTime, block.timestamp);
            uint256 wakaReward = totalReward.mul(pool.allocPoint).div(totalAllocPoint);
            accWakaPerShare = accWakaPerShare.add(wakaReward.mul(accWakaPerShareMultiple).div(lpSupply));
        }
        return user.amount.mul(accWakaPerShare).div(accWakaPerShareMultiple).sub(user.rewardDebt);
    }

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

    // Update reward variables of the given pool to be up-to-date.
    function updatePool(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        if (block.timestamp <= pool.lastRewardTime) {
            return;
        }
        uint256 lpSupply = pool.token.balanceOf(address(this));
        if (lpSupply == 0) {
            pool.lastRewardTime = block.timestamp;
            return;
        }
        if (pool.lastRewardTime >= maxRewardTimestamp) {
            return;
        }
        uint256 totalReward = getTotalRewardInfo(pool.lastRewardTime, block.timestamp);
        uint256 wakaReward = totalReward.mul(pool.allocPoint).div(totalAllocPoint);
        waka.mintTo(maintenance, wakaReward.div(10)); // 10% Waka sent to maintenance address
        waka.mintTo(address(this), wakaReward);
        pool.accWakaPerShare = pool.accWakaPerShare.add(wakaReward.mul(accWakaPerShareMultiple).div(lpSupply));
        pool.lastRewardTime = block.timestamp;
    }

    // Deposit tokens to WakaTimeFarm for Waka allocation.
    function deposit(uint256 _pid, uint256 _amount) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        updatePool(_pid);
        if (user.amount > 0) {
            uint256 pending = user.amount.mul(pool.accWakaPerShare).div(accWakaPerShareMultiple).sub(
                user.rewardDebt
            );
            if (pending > 0) {
                safeWakaTransfer(msg.sender, pending);
            }
        }
        pool.token.safeTransferFrom(address(msg.sender), address(this), _amount);
        user.amount = user.amount.add(_amount);
        user.rewardDebt = user.amount.mul(pool.accWakaPerShare).div(accWakaPerShareMultiple);
        emit Deposit(msg.sender, _pid, _amount);
    }

    // Withdraw tokens from WakaTimeFarm
    function withdraw(uint256 _pid, uint256 _amount) public {
        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.accWakaPerShare).div(accWakaPerShareMultiple).sub(
            user.rewardDebt
        );
        if (pending > 0) {
            safeWakaTransfer(msg.sender, pending);
        }
        if (_amount > 0) {
            user.amount = user.amount.sub(_amount);
            pool.token.safeTransfer(address(msg.sender), _amount);
        }
        user.rewardDebt = user.amount.mul(pool.accWakaPerShare).div(accWakaPerShareMultiple);
        emit Withdraw(msg.sender, _pid, _amount);
    }

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

    // Safe waka transfer function, just in case if rounding error causes pool to not have enough $Waka
    function safeWakaTransfer(address _to, uint256 _amount) internal {
        uint256 wakaBal = waka.balanceOf(address(this));
        if (_amount > wakaBal) {
            waka.transfer(_to, wakaBal);
        } else {
            waka.transfer(_to, _amount);
        }
    }

    // Update maintenance address by the previous dev or governance
    function changeMaintenanceAddr(address _maintenanceAddr) public {
        require(msg.sender == maintenance, 'nope');
        maintenance = _maintenanceAddr;
    }
}

Contract ABI

[{"inputs":[{"internalType":"contract WakaToken","name":"_waka","type":"address"},{"internalType":"address","name":"_maintenanceAddr","type":"address"},{"internalType":"uint256","name":"_wakaStartTime","type":"uint256"},{"internalType":"uint256","name":"_startTime","type":"uint256"},{"internalType":"uint256","name":"_bonusEndTime","type":"uint256"},{"internalType":"uint256","name":"_bonusBeforeBulkTimePeriod","type":"uint256"},{"internalType":"uint256","name":"_bonusBeforeCommonDifference","type":"uint256"},{"internalType":"uint256","name":"_bonusEndCommonDifference","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"accWakaPerShareMultiple","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IERC20","name":"_token","type":"address"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"bonusBeforeBulkTimePeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bonusBeforeCommonDifference","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bonusEndBulkTimePeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bonusEndCommonDifference","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bonusEndTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_maintenanceAddr","type":"address"}],"name":"changeMaintenanceAddr","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_from","type":"uint256"},{"internalType":"uint256","name":"_to","type":"uint256"}],"name":"getTotalRewardInfo","outputs":[{"internalType":"uint256","name":"totalReward","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_from","type":"uint256"},{"internalType":"uint256","name":"_to","type":"uint256"},{"internalType":"uint256","name":"_wakaInitTime","type":"uint256"},{"internalType":"uint256","name":"_bulkTimePeriod","type":"uint256"},{"internalType":"uint256","name":"_commonDifference","type":"uint256"}],"name":"getTotalRewardInfoInSameCommonDifference","outputs":[{"internalType":"uint256","name":"totalReward","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maintenance","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxRewardTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingWaka","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardTime","type":"uint256"},{"internalType":"uint256","name":"accWakaPerShare","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":[],"name":"startTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"waka","outputs":[{"internalType":"contract WakaToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"wakaBonusEndTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"wakaStartTime","outputs":[{"internalType":"uint256","name":"","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)

000000000000000000000000f61ccde1d4bb76ced1daa9d4c429cca83022b08b000000000000000000000000724bf2b94c9e4b5ce75a1be721144b0a8c4d7de1000000000000000000000000000000000000000000000000121c4a95f7e280000000000000000000000000000000000000000000000000000000000060a7f5200000000000000000000000000000000000000000000000000000000060cf82200000000000000000000000000000000000000000000000000000000000278d000000000000000000000000000000000000000000000000000077e772392b60000000000000000000000000000000000000000000000000000077e772392b6000

-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : 000000000000000000000000f61ccde1d4bb76ced1daa9d4c429cca83022b08b
Arg [1] : 000000000000000000000000724bf2b94c9e4b5ce75a1be721144b0a8c4d7de1
Arg [2] : 000000000000000000000000000000000000000000000000121c4a95f7e28000
Arg [3] : 0000000000000000000000000000000000000000000000000000000060a7f520
Arg [4] : 0000000000000000000000000000000000000000000000000000000060cf8220
Arg [5] : 0000000000000000000000000000000000000000000000000000000000278d00
Arg [6] : 0000000000000000000000000000000000000000000000000077e772392b6000
Arg [7] : 0000000000000000000000000000000000000000000000000077e772392b6000


Deployed ByteCode Sourcemap

37684:15887:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42343:95;;;:::i;:::-;;;;;;;;;;;;;;;;;;;39953:39;;;:::i;:::-;;;;;;;;;;;;;;;;;;;40249:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39494:40;;;:::i;:::-;;;;;;;;;;;;;;;;;;;39215:34;;;:::i;:::-;;;;;;;;;;;;;;;;;;;40047:45;;;:::i;:::-;;;;;;;;;;;;;;;;;;;42616:534;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;47366:1281;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;51707:802;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;49881:933;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;52580:354;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;39716:31;;;:::i;:::-;;;;;;;;;;;;;;;;;;;49625:180;;;:::i;:::-;;43246:338;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;40184:26;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;39779:33;;;:::i;:::-;;;;;;;;;;;;;;;;;;;2786:148;;;:::i;:::-;;48710:832;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;39306:24;;;:::i;:::-;;;;;;;;;;;;;;;;;;;2135:87;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;40328:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;43612:3683;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;39862:42;;;:::i;:::-;;;;;;;;;;;;;;;;;;;39092:28;;;:::i;:::-;;;;;;;;;;;;;;;;;;;39621:37;;;:::i;:::-;;;;;;;;;;;;;;;;;;;40127:21;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;50882:775;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;39379:27;;;:::i;:::-;;;;;;;;;;;;;;;;;;;53402:166;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;3089:244;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;42343:95;42388:7;42415:8;:15;;;;42408:22;;42343:95;:::o;39953:39::-;;;;:::o;40249:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;39494:40::-;;;;:::o;39215:34::-;;;;:::o;40047:45::-;;;;:::o;42616:534::-;2366:12;:10;:12::i;:::-;2355:23;;:7;:5;:7::i;:::-;:23;;;2347:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42749:11:::1;42745:61;;;42777:17;:15;:17::i;:::-;42745:61;42816:22;42859:9;;42841:15;:27;:57;;42889:9;;42841:57;;;42871:15;42841:57;42816:82;;42927:32;42947:11;42927:15;;:19;;:32;;;;:::i;:::-;42909:15;:50;;;;42970:8;42984:157;;;;;;;;43013:6;42984:157;;;;;;43044:11;42984:157;;;;43084:14;42984:157;;;;43128:1;42984:157;;::::0;42970:172:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2426:1;42616:534:::0;;;:::o;47366:1281::-;47443:19;47486:12;;47479:3;:19;47475:1165;;47529:223;47588:5;47612:3;47634:13;;47666:25;;47710:27;;47529:40;:223::i;:::-;47515:237;;47475:1165;;;47783:12;;47774:5;:21;47770:870;;47826:220;47885:5;47909:3;47931:16;;47966:22;;48007:24;;47826:40;:220::i;:::-;47812:234;;47770:870;;;48093:535;48362:251;48425:12;;48460:3;48486:16;;48525:22;;48570:24;;48362:40;:251::i;:::-;48093:232;48152:5;48176:12;;48207:13;;48239:25;;48283:27;;48093:40;:232::i;:::-;:250;;:535;;;;:::i;:::-;48079:549;;47770:870;47475:1165;47366:1281;;;;:::o;51707:802::-;51774:21;51798:8;51807:4;51798:14;;;;;;;;;;;;;;;;;;51774:38;;51823:21;51847:8;:14;51856:4;51847:14;;;;;;;;;;;:26;51862:10;51847:26;;;;;;;;;;;;;;;51823:50;;51907:7;51892:4;:11;;;:22;;51884:53;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51948:16;51959:4;51948:10;:16::i;:::-;51975:15;51993:111;52078:4;:15;;;51993:66;52035:23;;51993:37;52009:4;:20;;;51993:4;:11;;;:15;;:37;;;;:::i;:::-;:41;;:66;;;;:::i;:::-;:70;;:111;;;;:::i;:::-;51975:129;;52129:1;52119:7;:11;52115:81;;;52147:37;52164:10;52176:7;52147:16;:37::i;:::-;52115:81;52220:1;52210:7;:11;52206:150;;;52252:24;52268:7;52252:4;:11;;;:15;;:24;;;;:::i;:::-;52238:4;:11;;:38;;;;52291:53;52323:10;52336:7;52291:4;:10;;;;;;;;;;;;:23;;;;:53;;;;;:::i;:::-;52206:150;52384:66;52426:23;;52384:37;52400:4;:20;;;52384:4;:11;;;:15;;:37;;;;:::i;:::-;:41;;:66;;;;:::i;:::-;52366:4;:15;;:84;;;;52487:4;52475:10;52466:35;;;52493:7;52466:35;;;;;;;;;;;;;;;;;;51707:802;;;;;:::o;49881:933::-;49933:21;49957:8;49966:4;49957:14;;;;;;;;;;;;;;;;;;49933:38;;50005:4;:19;;;49986:15;:38;49982:77;;50041:7;;;49982:77;50069:16;50088:4;:10;;;;;;;;;;;;:20;;;50117:4;50088:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50069:54;;50150:1;50138:8;:13;50134:104;;;50190:15;50168:4;:19;;:37;;;;50220:7;;;;50134:104;50275:18;;50252:4;:19;;;:41;50248:80;;50310:7;;;;50248:80;50338:19;50360:56;50379:4;:19;;;50400:15;50360:18;:56::i;:::-;50338:78;;50427:18;50448:53;50485:15;;50448:32;50464:4;:15;;;50448:11;:15;;:32;;;;:::i;:::-;:36;;:53;;;;:::i;:::-;50427:74;;50512:4;;;;;;;;;;;:11;;;50524;;;;;;;;;;;50537:18;50552:2;50537:10;:14;;:18;;;;:::i;:::-;50512:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50607:4;;;;;;;;;;;:11;;;50627:4;50634:10;50607:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50679:79;50704:53;50748:8;50704:39;50719:23;;50704:10;:14;;:39;;;;:::i;:::-;:43;;:53;;;;:::i;:::-;50679:4;:20;;;:24;;:79;;;;:::i;:::-;50656:4;:20;;:102;;;;50791:15;50769:4;:19;;:37;;;;49881:933;;;;;;:::o;52580:354::-;52639:21;52663:8;52672:4;52663:14;;;;;;;;;;;;;;;;;;52639:38;;52688:21;52712:8;:14;52721:4;52712:14;;;;;;;;;;;:26;52727:10;52712:26;;;;;;;;;;;;;;;52688:50;;52749:57;52781:10;52794:4;:11;;;52749:4;:10;;;;;;;;;;;;:23;;;;:57;;;;;:::i;:::-;52852:4;52840:10;52822:48;;;52858:4;:11;;;52822:48;;;;;;;;;;;;;;;;;;52895:1;52881:4;:11;;:15;;;;52925:1;52907:4;:15;;:19;;;;52580:354;;;:::o;39716:31::-;;;;:::o;49625:180::-;49670:14;49687:8;:15;;;;49670:32;;49718:11;49713:85;49741:6;49735:3;:12;49713:85;;;49771:15;49782:3;49771:10;:15::i;:::-;49749:5;;;;;49713:85;;;;49625:180;:::o;43246:338::-;2366:12;:10;:12::i;:::-;2355:23;;:7;:5;:7::i;:::-;:23;;;2347:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43378:11:::1;43374:61;;;43406:17;:15;:17::i;:::-;43374:61;43463:63;43514:11;43463:46;43483:8;43492:4;43483:14;;;;;;;;;;;;;;;;;;:25;;;43463:15;;:19;;:46;;;;:::i;:::-;:50;;:63;;;;:::i;:::-;43445:15;:81;;;;43565:11;43537:8;43546:4;43537:14;;;;;;;;;;;;;;;;;;:25;;:39;;;;43246:338:::0;;;:::o;40184:26::-;;;;;;;;;;;;;:::o;39779:33::-;;;;:::o;2786:148::-;2366:12;:10;:12::i;:::-;2355:23;;:7;:5;:7::i;:::-;:23;;;2347:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2893:1:::1;2856:40;;2877:6;::::0;::::1;;;;;;;;2856:40;;;;;;;;;;;;2924:1;2907:6:::0;::::1;:19;;;;;;;;;;;;;;;;;;2786:148::o:0;48710:832::-;48783:7;48803:21;48827:8;48836:4;48827:14;;;;;;;;;;;;;;;;;;48803:38;;48852:21;48876:8;:14;48885:4;48876:14;;;;;;;;;;;:21;48891:5;48876:21;;;;;;;;;;;;;;;48852:45;;48908:23;48934:4;:20;;;48908:46;;48965:16;48984:4;:10;;;;;;;;;;;;:20;;;49013:4;48984:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48965:54;;49052:4;:19;;;49034:15;:37;:54;;;;;49087:1;49075:8;:13;;49034:54;:98;;;;;49114:18;;49092:4;:19;;;:40;49034:98;49030:405;;;49149:19;49171:56;49190:4;:19;;;49211:15;49171:18;:56::i;:::-;49149:78;;49242:18;49263:53;49300:15;;49263:32;49279:4;:15;;;49263:11;:15;;:32;;;;:::i;:::-;:36;;:53;;;;:::i;:::-;49242:74;;49349;49369:53;49413:8;49369:39;49384:23;;49369:10;:14;;:39;;;;:::i;:::-;:43;;:53;;;;:::i;:::-;49349:15;:19;;:74;;;;:::i;:::-;49331:92;;49030:405;;;49452:82;49518:4;:15;;;49452:61;49489:23;;49452:32;49468:15;49452:4;:11;;;:15;;:32;;;;:::i;:::-;:36;;:61;;;;:::i;:::-;:65;;:82;;;;:::i;:::-;49445:89;;;;;;48710:832;;;;:::o;39306:24::-;;;;:::o;2135:87::-;2181:7;2208:6;;;;;;;;;;;2201:13;;2135:87;:::o;40328:64::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;43612:3683::-;43838:19;43881:9;;43874:3;:16;;:47;;;;43916:5;43894:18;;:27;;43874:47;43870:88;;;43945:1;43938:8;;;;43870:88;43980:9;;43972:5;:17;43968:67;;;44014:9;;44006:17;;43968:67;44070:3;44049:18;;:24;44045:81;;;44096:18;;44090:24;;44045:81;44136:25;44164:120;44264:1;44222:39;44245:15;44222:18;44230:9;;44222:3;:7;;:18;;;;:::i;:::-;:22;;:39;;;;:::i;:::-;:43;:51;;44272:1;44222:51;;;44268:1;44222:51;44164:120;;:39;44187:15;44164:18;44172:9;;44164:3;:7;;:18;;;;:::i;:::-;:22;;:39;;;;:::i;:::-;:43;;:120;;;;:::i;:::-;44136:148;;44319:1;44299:17;:21;44295:75;;;44357:1;44337:21;;44295:75;44380:22;44405:124;44509:1;44465:41;44490:15;44465:20;44475:9;;44465:5;:9;;:20;;;;:::i;:::-;:24;;:41;;;;:::i;:::-;:45;:53;;44517:1;44465:53;;;44513:1;44465:53;44405:124;;:41;44430:15;44405:20;44415:9;;44405:5;:9;;:20;;;;:::i;:::-;:24;;:41;;;;:::i;:::-;:45;;:124;;;;:::i;:::-;44380:149;;44561:1;44544:14;:18;44540:69;;;44596:1;44579:18;;44540:69;44641:17;44623:14;:35;44619:161;;;44682:86;44701:66;44719:47;44748:17;44719:24;44741:1;44719:17;:21;;:24;;;;:::i;:::-;:28;;:47;;;;:::i;:::-;44701:13;:17;;:66;;;;:::i;:::-;44682:14;44690:5;44682:3;:7;;:14;;;;:::i;:::-;:18;;:86;;;;:::i;:::-;44675:93;;;;;;44619:161;44790:30;44823:50;44837:35;44857:14;44837:15;:19;;:35;;;;:::i;:::-;44823:9;;:13;;:50;;;;:::i;:::-;44790:83;;44884:35;44922:60;44936:45;44956:24;44978:1;44956:17;:21;;:24;;;;:::i;:::-;44936:15;:19;;:45;;;;:::i;:::-;44922:9;;:13;;:60;;;;:::i;:::-;44884:98;;45008:16;45027:5;45008:24;;45047:14;45064:3;45047:20;;45096:191;45220:66;45238:47;45267:17;45238:24;45260:1;45238:17;:21;;:24;;;;:::i;:::-;:28;;:47;;;;:::i;:::-;45220:13;:17;;:66;;;;:::i;:::-;45096:105;45132:27;45121:8;:38;:79;;45173:27;45121:79;;;45162:8;45121:79;45096:6;:24;;:105;;;;:::i;:::-;:123;;:191;;;;:::i;:::-;45082:205;;45331:8;45306:22;:33;:69;;;;;45369:6;45343:22;:32;;45306:69;45302:359;;;45410:235;45448:178;45515:88;45550:1;45533:14;:18;:69;;45601:1;45533:69;;;45554:44;45580:17;45554:21;45573:1;45554:14;:18;;:21;;;;:::i;:::-;:25;;:44;;;;:::i;:::-;45533:69;45515:13;:17;;:88;;;;:::i;:::-;45448:36;45475:8;45448:22;:26;;:36;;;;:::i;:::-;:40;;:178;;;;:::i;:::-;45410:11;:15;;:235;;;;:::i;:::-;45396:249;;45302:359;43612:3683;;45742:24;45769:13;45742:40;;45797:26;45826:15;45797:44;;45856:28;45887:17;45856:48;;45953:22;45923:27;:52;45919:1358;;;45996:39;46038:27;45996:69;;46189:9;46201:83;46265:18;46201:59;46237:22;46201:31;:35;;:59;;;;:::i;:::-;:63;;:83;;;;:::i;:::-;46189:95;;46311:1;46307;:5;46303:959;;;46337:10;46350:237;46399:165;46450:87;46518:18;46450:63;46492:20;46450:37;46477:9;;46450:22;:26;;:37;;;;:::i;:::-;:41;;:63;;;;:::i;:::-;:67;;:87;;;;:::i;:::-;46399:16;:20;;:165;;;;:::i;:::-;46350:18;:22;;:237;;;;:::i;:::-;46337:250;;46610:10;46623:317;46672:245;46723:167;46839:20;46723:77;46798:1;46723:70;46774:18;46723:46;46759:9;;46723:31;:35;;:46;;;;:::i;:::-;:50;;:70;;;;:::i;:::-;:74;;:77;;;;:::i;:::-;:81;;:167;;;;:::i;:::-;46672:16;:20;;:245;;;;:::i;:::-;46623:18;:22;;:317;;;;:::i;:::-;46610:330;;46977:41;46993:24;47015:1;46993:17;46999:10;47006:2;46999;:6;;:10;;;;:::i;:::-;46993:1;:5;;:17;;;;:::i;:::-;:21;;:24;;;;:::i;:::-;46977:11;:15;;:41;;;;:::i;:::-;46963:55;;46303:959;;;;;47081:161;47123:96;47146:72;47167:50;47196:20;47167:24;47189:1;47167:17;:21;;:24;;;;:::i;:::-;:28;;:50;;;;:::i;:::-;47146:16;:20;;:72;;;;:::i;:::-;47123:18;:22;;:96;;;;:::i;:::-;47081:11;:15;;:161;;;;:::i;:::-;47067:175;;46303:959;45919:1358;;;43612:3683;;;;;;;;;;;;;;;:::o;39862:42::-;;;;:::o;39092:28::-;;;;:::o;39621:37::-;;;;:::o;40127:21::-;;;;;;;;;;;;;:::o;50882:775::-;50948:21;50972:8;50981:4;50972:14;;;;;;;;;;;;;;;;;;50948:38;;50997:21;51021:8;:14;51030:4;51021:14;;;;;;;;;;;:26;51036:10;51021:26;;;;;;;;;;;;;;;50997:50;;51058:16;51069:4;51058:10;:16::i;:::-;51103:1;51089:4;:11;;;:15;51085:288;;;51121:15;51139:119;51228:4;:15;;;51139:66;51181:23;;51139:37;51155:4;:20;;;51139:4;:11;;;:15;;:37;;;;:::i;:::-;:41;;:66;;;;:::i;:::-;:70;;:119;;;;:::i;:::-;51121:137;;51287:1;51277:7;:11;51273:89;;;51309:37;51326:10;51338:7;51309:16;:37::i;:::-;51273:89;51085:288;;51383:72;51419:10;51440:4;51447:7;51383:4;:10;;;;;;;;;;;;:27;;;;:72;;;;;;:::i;:::-;51480:24;51496:7;51480:4;:11;;;:15;;:24;;;;:::i;:::-;51466:4;:11;;:38;;;;51533:66;51575:23;;51533:37;51549:4;:20;;;51533:4;:11;;;:15;;:37;;;;:::i;:::-;:41;;:66;;;;:::i;:::-;51515:4;:15;;:84;;;;51635:4;51623:10;51615:34;;;51641:7;51615:34;;;;;;;;;;;;;;;;;;50882:775;;;;:::o;39379:27::-;;;;:::o;53402:166::-;53499:11;;;;;;;;;;;53485:25;;:10;:25;;;53477:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53544:16;53530:11;;:30;;;;;;;;;;;;;;;;;;53402:166;:::o;3089:244::-;2366:12;:10;:12::i;:::-;2355:23;;:7;:5;:7::i;:::-;:23;;;2347:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3198:1:::1;3178:22;;:8;:22;;;;3170:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3288:8;3259:38;;3280:6;::::0;::::1;;;;;;;;3259:38;;;;;;;;;;;;3317:8;3308:6;::::0;:17:::1;;;;;;;;;;;;;;;;;;3089:244:::0;:::o;6602:158::-;6660:7;6693:1;6688;:6;;6680:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6751:1;6747;:5;6740:12;;6602:158;;;;:::o;7717:153::-;7775:7;7807:1;7803;:5;7795:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7861:1;7857;:5;;;;;;7850:12;;7717:153;;;;:::o;7019:220::-;7077:7;7106:1;7101;:6;7097:20;;;7116:1;7109:8;;;;7097:20;7128:9;7144:1;7140;:5;7128:17;;7173:1;7168;7164;:5;;;;;;:10;7156:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7230:1;7223:8;;;7019:220;;;;;:::o;6140:179::-;6198:7;6218:9;6234:1;6230;:5;6218:17;;6259:1;6254;:6;;6246:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6310:1;6303:8;;;6140:179;;;;:::o;667:106::-;720:15;755:10;748:17;;667:106;:::o;53047:278::-;53123:15;53141:4;;;;;;;;;;;:14;;;53164:4;53141:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53123:47;;53195:7;53185;:17;53181:137;;;53219:4;;;;;;;;;;;:13;;;53233:3;53238:7;53219:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53181:137;;;53279:4;;;;;;;;;;;:13;;;53293:3;53298:7;53279:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53181:137;53047:278;;;:::o;33370:177::-;33453:86;33473:5;33503:23;;;33528:2;33532:5;33480:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33453:19;:86::i;:::-;33370:177;;;:::o;8337:151::-;8395:7;8427:1;8423;:5;8415:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8479:1;8475;:5;;;;;;8468:12;;8337:151;;;;:::o;33555:205::-;33656:96;33676:5;33706:27;;;33735:4;33741:2;33745:5;33683:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33656:19;:96::i;:::-;33555:205;;;;:::o;35675:761::-;36099:23;36125:69;36153:4;36125:69;;;;;;;;;;;;;;;;;36133:5;36125:27;;;;:69;;;;;:::i;:::-;36099:95;;36229:1;36209:10;:17;:21;36205:224;;;36351:10;36340:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36332:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36205:224;35675:761;;;:::o;28360:195::-;28463:12;28495:52;28517:6;28525:4;28531:1;28534:12;28495:21;:52::i;:::-;28488:59;;28360:195;;;;;:::o;29412:530::-;29539:12;29597:5;29572:21;:30;;29564:81;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29664:18;29675:6;29664:10;:18::i;:::-;29656:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29790:12;29804:23;29831:6;:11;;29851:5;29859:4;29831:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29789:75;;;;29882:52;29900:7;29909:10;29921:12;29882:17;:52::i;:::-;29875:59;;;;29412:530;;;;;;:::o;25442:422::-;25502:4;25710:12;25821:7;25809:20;25801:28;;25855:1;25848:4;:8;25841:15;;;25442:422;;;:::o;31952:742::-;32067:12;32096:7;32092:595;;;32127:10;32120:17;;;;32092:595;32261:1;32241:10;:17;:21;32237:439;;;32504:10;32498:17;32565:15;32552:10;32548:2;32544:19;32537:44;32452:148;32647:12;32640:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31952:742;;;;;;:::o

Swarm Source

ipfs://3755e9325eaad175e3b9c9af41c79eb915ed5d7786c167c3a410eb43ad37a579
Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Validator ID :
0 FTM

Amount Staked
0

Amount Delegated
0

Staking Total
0

Staking Start Epoch
0

Staking Start Time
0

Proof of Importance
0

Origination Score
0

Validation Score
0

Active
0

Online
0

Downtime
0 s
Address Amount claimed Rewards Created On Epoch Created On
Block Uncle Number Difficulty Gas Used Reward
Loading
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.