Contract 0x20ec291bb8459b6145317e7126532ce7ece5056f

Contract Overview

Balance:
0 BNB

Token:
Txn Hash
Block
From
To
Value [Txn Fee]
0x57921266f663e899faa162d0ccd93a5726ec90f0eba5b939ccce2a92d72b1385108714262021-07-24 12:50:1814 hrs 24 mins ago0xcf4bba40498a5edf6f6ed1d216efd98c1fad5209 IN  0x20ec291bb8459b6145317e7126532ce7ece5056f0 BNB0.0003216
0x05859b5024b9491cd6a28cd28a8363118179d4362ae33d7c7c789ce0ee26d93d108714222021-07-24 12:50:0614 hrs 24 mins ago0xcf4bba40498a5edf6f6ed1d216efd98c1fad5209 IN  0x20ec291bb8459b6145317e7126532ce7ece5056f0 BNB0.00074831
0xf9b6af63434a9f8a33345e3a43d9b4b39ace003b463f9946e4a26dd50dba3949108404642021-07-23 10:46:581 day 16 hrs ago0x0db5570f3bc313e99cdfa7fe77a6cb87e1f3e85e IN  0x20ec291bb8459b6145317e7126532ce7ece5056f0 BNB0.00131342
0x9515dee053a2675f5b6afe9761233c07e16aded3046295d40a4a23eccadcfc9d108404272021-07-23 10:45:071 day 16 hrs ago0x0db5570f3bc313e99cdfa7fe77a6cb87e1f3e85e IN  0x20ec291bb8459b6145317e7126532ce7ece5056f0 BNB0.00143847
0x70eaa40adc35afd8ecd46c6512580cf5e4cbd58dcbbcc9aca9ba8a5722bc4edf108143702021-07-22 12:59:442 days 14 hrs ago0xd84db4f55bd9fded72727aa7928b6ad7b41b3380 IN  0x20ec291bb8459b6145317e7126532ce7ece5056f0 BNB0.00056171
0xb6e4c4eed497804de4a0e848292be1adaf0119224183447aa521032dd969dfe7107857142021-07-21 12:59:043 days 14 hrs ago0x0db5570f3bc313e99cdfa7fe77a6cb87e1f3e85e IN  0x20ec291bb8459b6145317e7126532ce7ece5056f0 BNB0.00131342
0x2099d83ca5310854954e6cbb81c5e5cfd71a5c2954ba92e1526feeb100f769c5107857012021-07-21 12:58:253 days 14 hrs ago0x0db5570f3bc313e99cdfa7fe77a6cb87e1f3e85e IN  0x20ec291bb8459b6145317e7126532ce7ece5056f0 BNB0.00146342
0x102d2cf35a91ddd0c4a4aff7f7a2e81f8dcd3be38b8c339bdf538af145ecad9d107803002021-07-21 8:28:163 days 18 hrs ago0xc580509e50b6d64f814eddbf13599ca9ab3f1400 IN  0x20ec291bb8459b6145317e7126532ce7ece5056f0 BNB0.00074819
0x8f35c8b982437959f2021ed8785293bcc7f6bacef02a6f57e39727cf324145a5107797902021-07-21 8:02:463 days 19 hrs ago0xd84db4f55bd9fded72727aa7928b6ad7b41b3380 IN  0x20ec291bb8459b6145317e7126532ce7ece5056f0 BNB0.00074819
0xb1e3bc5d78336174f4f5fbf1a34304cf51cd231e763a715dbea0362af56365dc107445822021-07-20 2:41:515 days 32 mins ago0x3ce08e4702ebaa39f6db328e6a11f9f7cc5ac8d6 IN  0x20ec291bb8459b6145317e7126532ce7ece5056f0 BNB0.00128811
0x1195213910f638fb072d73a542e3de36614b1f5bf7eb81e555284768823e754a107245032021-07-19 9:57:155 days 17 hrs ago0x3ce08e4702ebaa39f6db328e6a11f9f7cc5ac8d6 IN  0x20ec291bb8459b6145317e7126532ce7ece5056f0 BNB0.0013133
0xccb94038d597d032fee4aaa8bdaabfbd6cb3b2e1ff72d8be5dbe7b4315226876107244902021-07-19 9:56:365 days 17 hrs ago0x3ce08e4702ebaa39f6db328e6a11f9f7cc5ac8d6 IN  0x20ec291bb8459b6145317e7126532ce7ece5056f0 BNB0.0013133
0xe761647ac95c6c0318a12c364ad04fb65cf2e5606b35d8fb893a8b5ec33158b4107233832021-07-19 9:01:155 days 18 hrs ago0x3ce08e4702ebaa39f6db328e6a11f9f7cc5ac8d6 IN  0x20ec291bb8459b6145317e7126532ce7ece5056f0 BNB0.00142218
0xc6c3bc09902545095396411eec0aef22c418b9ac76926be4b04be3e4f678dbf6107165932021-07-19 3:19:085 days 23 hrs ago0x8935df9aa4856205526955159ffca12dfb4ebb7f IN  0x20ec291bb8459b6145317e7126532ce7ece5056f0 BNB0.00144002
0x78ce1e315a99f127b915f0f150469004d8196f913a0c7b589309ec14930a6909107165252021-07-19 3:15:445 days 23 hrs ago0x8935df9aa4856205526955159ffca12dfb4ebb7f IN  0x20ec291bb8459b6145317e7126532ce7ece5056f0 BNB0.00153872
0xbc59bea0499fbc3dcdd55e7cd261abbea72b4824643ac7e7cee9d85641053a64107165172021-07-19 3:15:205 days 23 hrs ago0x8935df9aa4856205526955159ffca12dfb4ebb7f IN  0x20ec291bb8459b6145317e7126532ce7ece5056f0 BNB0.00113799
0x70e5e3e78511aa9fcd8e3484289f33d9462908a1caaa4e1d5e8073f2af262b53107165002021-07-19 3:14:296 days ago0x8935df9aa4856205526955159ffca12dfb4ebb7f IN  0x20ec291bb8459b6145317e7126532ce7ece5056f0 BNB0.0013133
0xf0d0d623c325a9739e1091094bfdc1ef22828db3c57aebb2ecf2e2feb2bb1938107164572021-07-19 3:12:206 days 2 mins ago0x8935df9aa4856205526955159ffca12dfb4ebb7f IN  0x20ec291bb8459b6145317e7126532ce7ece5056f0 BNB0.00158848
0x1adcde53f8bcece7e5f09181986b24a1b6107e375d2844b6453ada19b8873eb8107164422021-07-19 3:11:356 days 3 mins ago0x8935df9aa4856205526955159ffca12dfb4ebb7f IN  0x20ec291bb8459b6145317e7126532ce7ece5056f0 BNB0.0013133
0xcaf8393b929760d5c11b70832b3eb6a2e2023b643b5ed6ea90c44487c6f1419c107164312021-07-19 3:11:026 days 3 mins ago0x8935df9aa4856205526955159ffca12dfb4ebb7f IN  0x20ec291bb8459b6145317e7126532ce7ece5056f0 BNB0.00138872
0x71d4401792eb0dbef3a0e027386c22a742ec21296780ed4afde7e3431133d133107057682021-07-18 18:17:536 days 8 hrs ago0x0db5570f3bc313e99cdfa7fe77a6cb87e1f3e85e IN  0x20ec291bb8459b6145317e7126532ce7ece5056f0 BNB0.00142254
0x6764087ca65d658488add08793e9f86fab5b3970a80b71b524a019e715d32e81107057132021-07-18 18:15:086 days 8 hrs ago0x0db5570f3bc313e99cdfa7fe77a6cb87e1f3e85e IN  0x20ec291bb8459b6145317e7126532ce7ece5056f0 BNB0.00138908
0x82acfb79ed24a51b3de9798450c13cfb10e61af6211349c5907554923a6c6d9c107053182021-07-18 17:55:236 days 9 hrs ago0x0db5570f3bc313e99cdfa7fe77a6cb87e1f3e85e IN  0x20ec291bb8459b6145317e7126532ce7ece5056f0 BNB0.00143847
0x163494da6f8b8ae6a703e19f60ee9e5a19ac9eccb84d57d816bb84bbe9ada168107050922021-07-18 17:44:056 days 9 hrs ago0x0db5570f3bc313e99cdfa7fe77a6cb87e1f3e85e IN  0x20ec291bb8459b6145317e7126532ce7ece5056f0 BNB0.0013892
0xb65c32b74aa7578ea1c9d4b82a413d92a95636f1621dfe6c6966a906334f1e0c107050332021-07-18 17:41:086 days 9 hrs ago0x0db5570f3bc313e99cdfa7fe77a6cb87e1f3e85e IN  0x20ec291bb8459b6145317e7126532ce7ece5056f0 BNB0.00128847
[ Download CSV Export 
Latest 25 internal transaction
Parent Txn Hash Block From To Value
0x57921266f663e899faa162d0ccd93a5726ec90f0eba5b939ccce2a92d72b1385108714262021-07-24 12:50:1814 hrs 24 mins ago 0x20ec291bb8459b6145317e7126532ce7ece5056f 0xe02df9e3e622debdd69fb838bb799e3f168902c50 BNB
0x05859b5024b9491cd6a28cd28a8363118179d4362ae33d7c7c789ce0ee26d93d108714222021-07-24 12:50:0614 hrs 24 mins ago 0x20ec291bb8459b6145317e7126532ce7ece5056f 0xe02df9e3e622debdd69fb838bb799e3f168902c50 BNB
0xf9b6af63434a9f8a33345e3a43d9b4b39ace003b463f9946e4a26dd50dba3949108404642021-07-23 10:46:581 day 16 hrs ago 0x20ec291bb8459b6145317e7126532ce7ece5056f 0x6f469dae7f333edfc98c6057f12e2a7521a9861c0 BNB
0xf9b6af63434a9f8a33345e3a43d9b4b39ace003b463f9946e4a26dd50dba3949108404642021-07-23 10:46:581 day 16 hrs ago 0x20ec291bb8459b6145317e7126532ce7ece5056f 0xe02df9e3e622debdd69fb838bb799e3f168902c50 BNB
0xf9b6af63434a9f8a33345e3a43d9b4b39ace003b463f9946e4a26dd50dba3949108404642021-07-23 10:46:581 day 16 hrs ago 0x20ec291bb8459b6145317e7126532ce7ece5056f 0xe02df9e3e622debdd69fb838bb799e3f168902c50 BNB
0xf9b6af63434a9f8a33345e3a43d9b4b39ace003b463f9946e4a26dd50dba3949108404642021-07-23 10:46:581 day 16 hrs ago 0x20ec291bb8459b6145317e7126532ce7ece5056f 0xe02df9e3e622debdd69fb838bb799e3f168902c50 BNB
0xf9b6af63434a9f8a33345e3a43d9b4b39ace003b463f9946e4a26dd50dba3949108404642021-07-23 10:46:581 day 16 hrs ago 0x20ec291bb8459b6145317e7126532ce7ece5056f 0xe02df9e3e622debdd69fb838bb799e3f168902c50 BNB
0xf9b6af63434a9f8a33345e3a43d9b4b39ace003b463f9946e4a26dd50dba3949108404642021-07-23 10:46:581 day 16 hrs ago 0x20ec291bb8459b6145317e7126532ce7ece5056f 0x6f469dae7f333edfc98c6057f12e2a7521a9861c0 BNB
0x9515dee053a2675f5b6afe9761233c07e16aded3046295d40a4a23eccadcfc9d108404272021-07-23 10:45:071 day 16 hrs ago 0x20ec291bb8459b6145317e7126532ce7ece5056f 0x47d34fd4f095767e718f110afef030bb18e8c48f0 BNB
0x9515dee053a2675f5b6afe9761233c07e16aded3046295d40a4a23eccadcfc9d108404272021-07-23 10:45:071 day 16 hrs ago 0x20ec291bb8459b6145317e7126532ce7ece5056f 0xe02df9e3e622debdd69fb838bb799e3f168902c50 BNB
0x9515dee053a2675f5b6afe9761233c07e16aded3046295d40a4a23eccadcfc9d108404272021-07-23 10:45:071 day 16 hrs ago 0x20ec291bb8459b6145317e7126532ce7ece5056f 0xe02df9e3e622debdd69fb838bb799e3f168902c50 BNB
0x9515dee053a2675f5b6afe9761233c07e16aded3046295d40a4a23eccadcfc9d108404272021-07-23 10:45:071 day 16 hrs ago 0x20ec291bb8459b6145317e7126532ce7ece5056f 0xe02df9e3e622debdd69fb838bb799e3f168902c50 BNB
0x9515dee053a2675f5b6afe9761233c07e16aded3046295d40a4a23eccadcfc9d108404272021-07-23 10:45:071 day 16 hrs ago 0x20ec291bb8459b6145317e7126532ce7ece5056f 0xe02df9e3e622debdd69fb838bb799e3f168902c50 BNB
0x9515dee053a2675f5b6afe9761233c07e16aded3046295d40a4a23eccadcfc9d108404272021-07-23 10:45:071 day 16 hrs ago 0x20ec291bb8459b6145317e7126532ce7ece5056f 0x47d34fd4f095767e718f110afef030bb18e8c48f0 BNB
0x70eaa40adc35afd8ecd46c6512580cf5e4cbd58dcbbcc9aca9ba8a5722bc4edf108143702021-07-22 12:59:442 days 14 hrs ago 0x20ec291bb8459b6145317e7126532ce7ece5056f 0xe02df9e3e622debdd69fb838bb799e3f168902c50 BNB
0x133b28c61cb031be91c2abe917b6324c4858585a09ce08ff6cb71ce4382b963a108113102021-07-22 10:26:382 days 16 hrs ago 0x20ec291bb8459b6145317e7126532ce7ece5056f 0xa8861b47df63259f229bc0e72659df0df521f8ac0 BNB
0x133b28c61cb031be91c2abe917b6324c4858585a09ce08ff6cb71ce4382b963a108113102021-07-22 10:26:382 days 16 hrs ago 0xa8861b47df63259f229bc0e72659df0df521f8ac 0x20ec291bb8459b6145317e7126532ce7ece5056f0 BNB
0x133b28c61cb031be91c2abe917b6324c4858585a09ce08ff6cb71ce4382b963a108113102021-07-22 10:26:382 days 16 hrs ago 0xa8861b47df63259f229bc0e72659df0df521f8ac 0x20ec291bb8459b6145317e7126532ce7ece5056f0 BNB
0x133b28c61cb031be91c2abe917b6324c4858585a09ce08ff6cb71ce4382b963a108113102021-07-22 10:26:382 days 16 hrs ago 0x20ec291bb8459b6145317e7126532ce7ece5056f 0xa8861b47df63259f229bc0e72659df0df521f8ac0 BNB
0x133b28c61cb031be91c2abe917b6324c4858585a09ce08ff6cb71ce4382b963a108113102021-07-22 10:26:382 days 16 hrs ago 0x20ec291bb8459b6145317e7126532ce7ece5056f 0xe02df9e3e622debdd69fb838bb799e3f168902c50 BNB
0x133b28c61cb031be91c2abe917b6324c4858585a09ce08ff6cb71ce4382b963a108113102021-07-22 10:26:382 days 16 hrs ago 0x20ec291bb8459b6145317e7126532ce7ece5056f 0xe02df9e3e622debdd69fb838bb799e3f168902c50 BNB
0x133b28c61cb031be91c2abe917b6324c4858585a09ce08ff6cb71ce4382b963a108113102021-07-22 10:26:382 days 16 hrs ago 0x20ec291bb8459b6145317e7126532ce7ece5056f 0xe02df9e3e622debdd69fb838bb799e3f168902c50 BNB
0x133b28c61cb031be91c2abe917b6324c4858585a09ce08ff6cb71ce4382b963a108113102021-07-22 10:26:382 days 16 hrs ago 0x20ec291bb8459b6145317e7126532ce7ece5056f 0xe02df9e3e622debdd69fb838bb799e3f168902c50 BNB
0x133b28c61cb031be91c2abe917b6324c4858585a09ce08ff6cb71ce4382b963a108113102021-07-22 10:26:382 days 16 hrs ago 0x20ec291bb8459b6145317e7126532ce7ece5056f 0xa8861b47df63259f229bc0e72659df0df521f8ac0 BNB
0x133b28c61cb031be91c2abe917b6324c4858585a09ce08ff6cb71ce4382b963a108113102021-07-22 10:26:382 days 16 hrs ago 0xa8861b47df63259f229bc0e72659df0df521f8ac 0x20ec291bb8459b6145317e7126532ce7ece5056f0 BNB
[ Download CSV Export 
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
BakeryMaster

Compiler Version
v0.6.6+commit.6c089d02

Optimization Enabled:
Yes with 999999 runs

Other Settings:
istanbul EvmVersion, None license

Contract Source Code (Solidity)

/**
 *Submitted for verification at BscScan.com on 2020-09-28
*/

/**
 *Submitted for verification at BscScan.com on 2020-09-14
*/

// SPDX-License-Identifier: MIT
pragma solidity =0.6.6;


/**
 * @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;
        }
    }
}
// SPDX-License-Identifier: GPL-3.0-or-later

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT

/**
 * @title SafeBEP20
 * @dev Wrappers around BEP20 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 SafeBEP20 for IBEP20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeBEP20 {
    using SafeMath for uint256;
    using Address for address;

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

    function safeTransferFrom(
        IBEP20 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
     * {IBEP20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IBEP20 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),
            'SafeBEP20: approve from non-zero to non-zero allowance'
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(
        IBEP20 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(
        IBEP20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(
            value,
            'SafeBEP20: 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(IBEP20 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, 'SafeBEP20: low-level call failed');
        if (returndata.length > 0) {
            // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), 'SafeBEP20: BEP20 operation did not succeed');
        }
    }
}

// SPDX-License-Identifier: GPL-3.0-or-later

/*
 * @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.
 */
contract Context {
    // Empty internal constructor, to prevent people from mistakenly deploying
    // an instance of this contract, which should be used via inheritance.
    constructor() internal {}

    function _msgSender() internal view returns (address payable) {
        return msg.sender;
    }

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

/**
 * @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.
 */
contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(_owner == _msgSender(), 'Ownable: caller is not the owner');
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public 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 onlyOwner {
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     */
    function _transferOwnership(address newOwner) internal {
        require(newOwner != address(0), 'Ownable: new owner is the zero address');
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}
// SPDX-License-Identifier: MIT


/**
 * @dev Implementation of the {IBEP20} 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 {BEP20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-BEP20-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 BEP20 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 {IBEP20-approve}.
 */
contract BEP20 is Context, IBEP20, Ownable {
    using SafeMath for uint256;
    using Address for address;

    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

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

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

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

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

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

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

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

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

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

    /**
     * @dev See {BEP20-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 {BEP20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {BEP20};
     *
     * 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, 'BEP20: 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 {BEP20-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 {BEP20-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, 'BEP20: 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), 'BEP20: transfer from the zero address');
        require(recipient != address(0), 'BEP20: transfer to the zero address');

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

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

contract BakeryToken is BEP20('BakeryToken', 'BAKE') {
    /// @notice Creates `_amount` token to `_to`. Must only be called by the owner (BakerySwapRouter).
    function mintTo(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

    /// @notice A 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 => uint256) 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, uint256 previousBalance, uint256 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,
        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), 'BAKE::delegateBySig: invalid signature');
        require(nonce == nonces[signatory]++, 'BAKE::delegateBySig: invalid nonce');
        require(now <= expiry, 'BAKE::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, uint256 blockNumber) external view returns (uint256) {
        require(blockNumber < block.number, 'BAKE::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 BAKEs (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, 'BAKE::_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;
    }
}

contract BakeryMaster is Ownable {
    using SafeMath for uint256;
    using SafeBEP20 for IBEP20;
    // 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 BAKEs
        // entitled to a user but is pending to be distributed is:
        //
        //   pending reward = (userInfo.amount * pool.accBakePerShare) - userInfo.rewardDebt
        //
        // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
        //   1. The pool's `accBakePerShare` (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 {
        uint256 allocPoint; // How many allocation points assigned to this pool. BAKEs to distribute per block.
        uint256 lastRewardBlock; // Last block number that BAKEs distribution occurs.
        uint256 accBakePerShare; // Accumulated BAKEs per share, times 1e12. See below.
        bool exists; //
    }
    // BAKE tokens created first block.
    uint256 public bakeStartBlock;
    // Total allocation points. Must be the sum of all allocation points in all pools.
    uint256 public totalAllocPoint = 0;
    // The block number when BAKE mining starts.
    uint256 public startBlock;
    // Block number when bonus BAKE period ends.
    uint256 public bonusEndBlock;
    // how many block size will change the common difference before bonus end.
    uint256 public bonusBeforeBulkBlockSize;
    // how many block size will change the common difference after bonus end.
    uint256 public bonusEndBulkBlockSize;
    // BAKE tokens created at bonus end block.
    uint256 public bakeBonusEndBlock;
    // max reward block
    uint256 public maxRewardBlockNumber;
    // bonus before the common difference
    uint256 public bonusBeforeCommonDifference;
    // bonus after the common difference
    uint256 public bonusEndCommonDifference;
    // Accumulated BAKEs per share, times 1e12.
    uint256 public accBakePerShareMultiple = 1E12;
    // The BAKE TOKEN!
    BakeryToken public bake;
    // Dev address.
    address public devAddr;
    address[] public poolAddresses;
    // Info of each pool.
    mapping(address => PoolInfo) public poolInfoMap;
    // Info of each user that stakes LP tokens.
    mapping(address => mapping(address => UserInfo)) public poolUserInfoMap;

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

    constructor(
        BakeryToken _bake,
        address _devAddr,
        uint256 _bakeStartBlock,
        uint256 _startBlock,
        uint256 _bonusEndBlock,
        uint256 _bonusBeforeBulkBlockSize,
        uint256 _bonusBeforeCommonDifference,
        uint256 _bonusEndCommonDifference
    ) public {
        bake = _bake;
        devAddr = _devAddr;
        bakeStartBlock = _bakeStartBlock;
        startBlock = _startBlock;
        bonusEndBlock = _bonusEndBlock;
        bonusBeforeBulkBlockSize = _bonusBeforeBulkBlockSize;
        bonusBeforeCommonDifference = _bonusBeforeCommonDifference;
        bonusEndCommonDifference = _bonusEndCommonDifference;
        bonusEndBulkBlockSize = bonusEndBlock.sub(startBlock);
        // bake created when bonus end first block.
        // (bakeStartBlock - bonusBeforeCommonDifference * ((bonusEndBlock-startBlock)/bonusBeforeBulkBlockSize - 1)) * bonusBeforeBulkBlockSize*(bonusEndBulkBlockSize/bonusBeforeBulkBlockSize) * bonusEndBulkBlockSize
        bakeBonusEndBlock = bakeStartBlock
        .sub(bonusEndBlock.sub(startBlock).div(bonusBeforeBulkBlockSize).sub(1).mul(bonusBeforeCommonDifference))
        .mul(bonusBeforeBulkBlockSize)
        .mul(bonusEndBulkBlockSize.div(bonusBeforeBulkBlockSize))
        .div(bonusEndBulkBlockSize);
        // max mint block number, _bakeInitBlock - (MAX-1)*_commonDifference = 0
        // MAX = startBlock + bonusEndBulkBlockSize * (_bakeInitBlock/_commonDifference + 1)
        maxRewardBlockNumber = startBlock.add(
            bonusEndBulkBlockSize.mul(bakeBonusEndBlock.div(bonusEndCommonDifference).add(1))
        );
    }

    // *** POOL MANAGER ***
    function poolLength() external view returns (uint256) {
        return poolAddresses.length;
    }

    // Add a new 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,
        address _pair,
        bool _withUpdate
    ) public onlyOwner {
        if (_withUpdate) {
            massUpdatePools();
        }
        PoolInfo storage pool = poolInfoMap[_pair];
        require(!pool.exists, 'pool already exists');
        uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        pool.allocPoint = _allocPoint;
        pool.lastRewardBlock = lastRewardBlock;
        pool.accBakePerShare = 0;
        pool.exists = true;
        poolAddresses.push(_pair);
    }

    // Update the given pool's BAKE allocation point. Can only be called by the owner.
    function set(
        address _pair,
        uint256 _allocPoint,
        bool _withUpdate
    ) public onlyOwner {
        if (_withUpdate) {
            massUpdatePools();
        }
        PoolInfo storage pool = poolInfoMap[_pair];
        require(pool.exists, 'pool not exists');
        totalAllocPoint = totalAllocPoint.sub(pool.allocPoint).add(_allocPoint);
        pool.allocPoint = _allocPoint;
    }

    function existsPool(address _pair) external view returns (bool) {
        return poolInfoMap[_pair].exists;
    }

    // (_from,_to]
    function getTotalRewardInfoInSameCommonDifference(
        uint256 _from,
        uint256 _to,
        uint256 _bakeInitBlock,
        uint256 _bulkBlockSize,
        uint256 _commonDifference
    ) public view returns (uint256 totalReward) {
        if (_to <= startBlock || maxRewardBlockNumber <= _from) {
            return 0;
        }
        if (_from < startBlock) {
            _from = startBlock;
        }
        if (maxRewardBlockNumber < _to) {
            _to = maxRewardBlockNumber;
        }
        uint256 currentBulkNumber = _to.sub(startBlock).div(_bulkBlockSize).add(
            _to.sub(startBlock).mod(_bulkBlockSize) > 0 ? 1 : 0
        );
        if (currentBulkNumber < 1) {
            currentBulkNumber = 1;
        }
        uint256 fromBulkNumber = _from.sub(startBlock).div(_bulkBlockSize).add(
            _from.sub(startBlock).mod(_bulkBlockSize) > 0 ? 1 : 0
        );
        if (fromBulkNumber < 1) {
            fromBulkNumber = 1;
        }
        if (fromBulkNumber == currentBulkNumber) {
            return _to.sub(_from).mul(_bakeInitBlock.sub(currentBulkNumber.sub(1).mul(_commonDifference)));
        }
        uint256 lastRewardBulkLastBlock = startBlock.add(_bulkBlockSize.mul(fromBulkNumber));
        uint256 currentPreviousBulkLastBlock = startBlock.add(_bulkBlockSize.mul(currentBulkNumber.sub(1)));
        {
            uint256 tempFrom = _from;
            uint256 tempTo = _to;
            totalReward = tempTo
            .sub(tempFrom > currentPreviousBulkLastBlock ? tempFrom : currentPreviousBulkLastBlock)
            .mul(_bakeInitBlock.sub(currentBulkNumber.sub(1).mul(_commonDifference)));
            if (lastRewardBulkLastBlock > tempFrom && lastRewardBulkLastBlock <= tempTo) {
                totalReward = totalReward.add(
                    lastRewardBulkLastBlock.sub(tempFrom).mul(
                        _bakeInitBlock.sub(fromBulkNumber > 0 ? fromBulkNumber.sub(1).mul(_commonDifference) : 0)
                    )
                );
            }
        }
        {
            // avoids stack too deep errors
            uint256 tempBakeInitBlock = _bakeInitBlock;
            uint256 tempBulkBlockSize = _bulkBlockSize;
            uint256 tempCommonDifference = _commonDifference;
            if (currentPreviousBulkLastBlock > lastRewardBulkLastBlock) {
                uint256 tempCurrentPreviousBulkLastBlock = currentPreviousBulkLastBlock;
                // sum( [fromBulkNumber+1, currentBulkNumber] )
                // 1/2 * N *( a1 + aN)
                uint256 N = tempCurrentPreviousBulkLastBlock.sub(lastRewardBulkLastBlock).div(tempBulkBlockSize);
                if (N > 1) {
                    uint256 a1 = tempBulkBlockSize.mul(
                        tempBakeInitBlock.sub(
                            lastRewardBulkLastBlock.sub(startBlock).mul(tempCommonDifference).div(tempBulkBlockSize)
                        )
                    );
                    uint256 aN = tempBulkBlockSize.mul(
                        tempBakeInitBlock.sub(
                            tempCurrentPreviousBulkLastBlock.sub(startBlock).div(tempBulkBlockSize).sub(1).mul(
                                tempCommonDifference
                            )
                        )
                    );
                    totalReward = totalReward.add(N.mul(a1.add(aN)).div(2));
                } else {
                    totalReward = totalReward.add(
                        tempBulkBlockSize.mul(tempBakeInitBlock.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 <= bonusEndBlock) {
            totalReward = getTotalRewardInfoInSameCommonDifference(
                _from,
                _to,
                bakeStartBlock,
                bonusBeforeBulkBlockSize,
                bonusBeforeCommonDifference
            );
        } else if (_from >= bonusEndBlock) {
            totalReward = getTotalRewardInfoInSameCommonDifference(
                _from,
                _to,
                bakeBonusEndBlock,
                bonusEndBulkBlockSize,
                bonusEndCommonDifference
            );
        } else {
            totalReward = getTotalRewardInfoInSameCommonDifference(
                _from,
                bonusEndBlock,
                bakeStartBlock,
                bonusBeforeBulkBlockSize,
                bonusBeforeCommonDifference
            )
            .add(
                getTotalRewardInfoInSameCommonDifference(
                    bonusEndBlock,
                    _to,
                    bakeBonusEndBlock,
                    bonusEndBulkBlockSize,
                    bonusEndCommonDifference
                )
            );
        }
    }

    // View function to see pending BAKEs on frontend.
    function pendingBake(address _pair, address _user) external view returns (uint256) {
        PoolInfo memory pool = poolInfoMap[_pair];
        if (!pool.exists) {
            return 0;
        }
        UserInfo storage userInfo = poolUserInfoMap[_pair][_user];
        uint256 accBakePerShare = pool.accBakePerShare;
        uint256 lpSupply = IBEP20(_pair).balanceOf(address(this));
        if (block.number > pool.lastRewardBlock && lpSupply != 0 && pool.lastRewardBlock < maxRewardBlockNumber) {
            uint256 totalReward = getTotalRewardInfo(pool.lastRewardBlock, block.number);
            uint256 bakeReward = totalReward.mul(pool.allocPoint).div(totalAllocPoint);
            accBakePerShare = accBakePerShare.add(bakeReward.mul(accBakePerShareMultiple).div(lpSupply));
        }
        return userInfo.amount.mul(accBakePerShare).div(accBakePerShareMultiple).sub(userInfo.rewardDebt);
    }

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

    // Update reward variables of the given pool to be up-to-date.
    function updatePool(address _pair) public {
        PoolInfo storage pool = poolInfoMap[_pair];
        if (!pool.exists || block.number <= pool.lastRewardBlock) {
            return;
        }
        uint256 lpSupply = IBEP20(_pair).balanceOf(address(this));
        if (lpSupply == 0) {
            pool.lastRewardBlock = block.number;
            return;
        }
        if (pool.lastRewardBlock >= maxRewardBlockNumber) {
            return;
        }
        uint256 totalReward = getTotalRewardInfo(pool.lastRewardBlock, block.number);
        uint256 bakeReward = totalReward.mul(pool.allocPoint).div(totalAllocPoint);
        bake.mintTo(devAddr, bakeReward.div(100));
        bake.mintTo(address(this), bakeReward);
        pool.accBakePerShare = pool.accBakePerShare.add(bakeReward.mul(accBakePerShareMultiple).div(lpSupply));
        pool.lastRewardBlock = block.number;
    }

    // Deposit LP tokens to BakeryMaster for BAKE allocation.
    function deposit(address _pair, uint256 _amount) public {
        PoolInfo storage pool = poolInfoMap[_pair];
        UserInfo storage userInfo = poolUserInfoMap[_pair][msg.sender];
        updatePool(_pair);
        if (userInfo.amount > 0) {
            uint256 pending = userInfo.amount.mul(pool.accBakePerShare).div(accBakePerShareMultiple).sub(
                userInfo.rewardDebt
            );
            if (pending > 0) {
                safeBakeTransfer(msg.sender, pending);
            }
        }
        IBEP20(_pair).safeTransferFrom(address(msg.sender), address(this), _amount);
        userInfo.amount = userInfo.amount.add(_amount);
        userInfo.rewardDebt = userInfo.amount.mul(pool.accBakePerShare).div(accBakePerShareMultiple);
        emit Deposit(msg.sender, _pair, _amount);
    }

    // Withdraw LP tokens from BakeryMaster.
    function withdraw(address _pair, uint256 _amount) public {
        PoolInfo storage pool = poolInfoMap[_pair];
        UserInfo storage userInfo = poolUserInfoMap[_pair][msg.sender];
        require(userInfo.amount >= _amount, 'withdraw: not good');
        updatePool(_pair);
        uint256 pending = userInfo.amount.mul(pool.accBakePerShare).div(accBakePerShareMultiple).sub(
            userInfo.rewardDebt
        );
        if (pending > 0) {
            safeBakeTransfer(msg.sender, pending);
        }
        if (_amount > 0) {
            userInfo.amount = userInfo.amount.sub(_amount);
            IBEP20(_pair).safeTransfer(address(msg.sender), _amount);
        }
        userInfo.rewardDebt = userInfo.amount.mul(pool.accBakePerShare).div(accBakePerShareMultiple);
        emit Withdraw(msg.sender, _pair, _amount);
    }

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

    // Safe bake transfer function, just in case if rounding error causes pool to not have enough BAKEs.
    function safeBakeTransfer(address _to, uint256 _amount) internal {
        uint256 bakeBal = bake.balanceOf(address(this));
        if (_amount > bakeBal) {
            bake.transfer(_to, bakeBal);
        } else {
            bake.transfer(_to, _amount);
        }
    }

    // Update dev address by the previous dev.
    function dev(address _devAddr) public {
        require(msg.sender == devAddr, 'dev: wut?');
        devAddr = _devAddr;
    }
}

Contract ABI

[{"inputs":[{"internalType":"contract BakeryToken","name":"_bake","type":"address"},{"internalType":"address","name":"_devAddr","type":"address"},{"internalType":"uint256","name":"_bakeStartBlock","type":"uint256"},{"internalType":"uint256","name":"_startBlock","type":"uint256"},{"internalType":"uint256","name":"_bonusEndBlock","type":"uint256"},{"internalType":"uint256","name":"_bonusBeforeBulkBlockSize","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":"address","name":"poolAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"poolAddress","type":"address"},{"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":"address","name":"poolAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"accBakePerShareMultiple","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"address","name":"_pair","type":"address"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"bake","outputs":[{"internalType":"contract BakeryToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bakeBonusEndBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bakeStartBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bonusBeforeBulkBlockSize","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":"bonusEndBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bonusEndBulkBlockSize","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bonusEndCommonDifference","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_pair","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_devAddr","type":"address"}],"name":"dev","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"devAddr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_pair","type":"address"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_pair","type":"address"}],"name":"existsPool","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","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":"_bakeInitBlock","type":"uint256"},{"internalType":"uint256","name":"_bulkBlockSize","type":"uint256"},{"internalType":"uint256","name":"_commonDifference","type":"uint256"}],"name":"getTotalRewardInfoInSameCommonDifference","outputs":[{"internalType":"uint256","name":"totalReward","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxRewardBlockNumber","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":"address","name":"_pair","type":"address"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingBake","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolAddresses","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"poolInfoMap","outputs":[{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardBlock","type":"uint256"},{"internalType":"uint256","name":"accBakePerShare","type":"uint256"},{"internalType":"bool","name":"exists","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"poolUserInfoMap","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_pair","type":"address"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startBlock","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":"address","name":"_pair","type":"address"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_pair","type":"address"},{"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)

000000000000000000000000e02df9e3e622debdd69fb838bb799e3f168902c5000000000000000000000000dbd2e3c84143cf0293a4838956808ec9c8927f4b000000000000000000000000000000000000000000000015af1d78b58c4000000000000000000000000000000000000000000000000000000000000000214a2300000000000000000000000000000000000000000000000000000000002f05c300000000000000000000000000000000000000000000000000000000000075300000000000000000000000000000000000000000000000008ac7230489e800000000000000000000000000000000000000000000000000008ac7230489e80000

-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : 000000000000000000000000e02df9e3e622debdd69fb838bb799e3f168902c5
Arg [1] : 000000000000000000000000dbd2e3c84143cf0293a4838956808ec9c8927f4b
Arg [2] : 000000000000000000000000000000000000000000000015af1d78b58c400000
Arg [3] : 0000000000000000000000000000000000000000000000000000000000214a23
Arg [4] : 00000000000000000000000000000000000000000000000000000000002f05c3
Arg [5] : 0000000000000000000000000000000000000000000000000000000000007530
Arg [6] : 0000000000000000000000000000000000000000000000008ac7230489e80000
Arg [7] : 0000000000000000000000000000000000000000000000008ac7230489e80000


Deployed ByteCode Sourcemap

41853:16371:0:-:0;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;41853:16371:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12:1:-1;9;2:12;46540:100:0;;;:::i;:::-;;;;;;;;;;;;;;;;47550:422;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;47550:422:0;;;;;;;;;;;;;;;;:::i;:::-;;44073:39;;;:::i;44388:47::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;44388:47:0;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43329:34;;;:::i;43502:28::-;;;:::i;46809:645::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;46809:645:0;;;;;;;;;;;;;;;;:::i;43617:39::-;;;:::i;51903:1285::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;51903:1285:0;;;;;;;:::i;44491:71::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;44491:71:0;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;55504:825;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;55504:825:0;;;;;;;;;:::i;43420:25::-;;;:::i;47980:115::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;47980:115:0;;;;:::i;:::-;;;;;;;;;;;;;;;;;;54256:192;;;:::i;53252:921::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;53252:921:0;;;;;;;;;;;:::i;57306:338::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;57306:338:0;;;;:::i;22352:140::-;;;:::i;54524:909::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;54524:909:0;;;;:::i;58092:129::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;58092:129:0;;;;:::i;21710:79::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;43833:32;;;:::i;44168:45::-;;;:::i;48123:3709::-;;;;;;15:3:-1;10;7:12;4:2;;;32:1;29;22:12;4:2;-1:-1;48123:3709:0;;;;;;;;;;;;;;;;;;;;;;:::i;43897:35::-;;;:::i;44244:23::-;;;:::i;43982:42::-;;;:::i;43742:36::-;;;:::i;44295:22::-;;;:::i;43205:29::-;;;:::i;22647:109::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;22647:109:0;;;;:::i;56383:852::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;56383:852:0;;;;;;;;;:::i;44324:30::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;44324:30:0;;:::i;46540:100::-;46612:13;:20;46540:100;:::o;47550:422::-;21932:12;:10;:12::i;:::-;21922:6;;:22;:6;;;:22;;;21914:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47683:11:::1;47679:61;;;47711:17;:15;:17::i;:::-;47774:18;::::0;::::1;47750:21;47774:18:::0;;;:11:::1;:18;::::0;;;;47811:11:::1;::::0;::::1;::::0;::::1;;47803:39;;;::::0;;::::1;::::0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;47891:15:::0;;47871::::1;::::0;:53:::1;::::0;47912:11;;47871:36:::1;::::0;::::1;:19;:36;:::i;:::-;:40:::0;:53:::1;:40;:53;:::i;:::-;47853:15;:71:::0;47935:29;;;;-1:-1:-1;;47550:422:0:o;44073:39::-;;;;:::o;44388:47::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;43329:34::-;;;;:::o;43502:28::-;;;;:::o;46809:645::-;21932:12;:10;:12::i;:::-;21922:6;;:22;:6;;;:22;;;21914:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46942:11:::1;46938:61;;;46970:17;:15;:17::i;:::-;47033:18;::::0;::::1;47009:21;47033:18:::0;;;:11:::1;:18;::::0;;;;47071:11:::1;::::0;::::1;::::0;::::1;;47070:12;47062:44;;;::::0;;::::1;::::0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;47117:23;47158:10;;47143:12;:25;:53;;47186:10;;47143:53;;;47171:12;47143:53;47225:15;::::0;47117:79;;-1:-1:-1;47225:32:0::1;::::0;47245:11;47225:32:::1;:19;:32;:::i;:::-;47207:15;:50:::0;;;47268:29;;;47308:20:::1;::::0;;::::1;:38:::0;;;;-1:-1:-1;47357:20:0;;::::1;:24:::0;;;47392:11:::1;::::0;;::::1;:18:::0;;;::::1;::::0;::::1;::::0;;47421:13:::1;27:10:-1::0;;23:18;;::::1;45:23:::0;;47421:25:0;;;-1:-1:-1;47421:25:0;;;::::1;::::0;;;::::1;;::::0;;::::1;::::0;;;::::1;::::0;;46809:645::o;43617:39::-;;;;:::o;51903:1285::-;51980:19;52023:13;;52016:3;:20;52012:1169;;52067:223;52126:5;52150:3;52172:14;;52205:24;;52248:27;;52067:40;:223::i;:::-;52053:237;;52012:1169;;;52321:13;;52312:5;:22;52308:873;;52365:220;52424:5;52448:3;52470:17;;52506:21;;52546:24;;52365:40;:220::i;52308:873::-;52632:537;52902:252;52965:13;;53001:3;53027:17;;53067:21;;53111:24;;52902:40;:252::i;:::-;52632:233;52691:5;52715:13;;52747:14;;52780:24;;52823:27;;52632:40;:233::i;:537::-;52618:551;;52308:873;51903:1285;;;;:::o;44491:71::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;55504:825::-;55595:18;;;55571:21;55595:18;;;:11;:18;;;;;;;;55652:15;:22;;;;;55675:10;55652:34;;;;;;;;55697:17;55607:5;55697:10;:17::i;:::-;55729:15;;:19;55725:300;;55765:15;55783:127;55876:8;:19;;;55783:70;55829:23;;55783:41;55803:4;:20;;;55783:8;:15;;;:19;;:41;;;;:::i;:::-;:45;:70;:45;:70;:::i;:::-;:74;:127;:74;:127;:::i;:::-;55765:145;-1:-1:-1;55929:11:0;;55925:89;;55961:37;55978:10;55990:7;55961:16;:37::i;:::-;55725:300;;56035:75;:30;;;56074:10;56095:4;56102:7;56035:75;:30;:75;:::i;:::-;56139:15;;:28;;56159:7;56139:28;:19;:28;:::i;:::-;56121:46;;;56246:23;;56220:20;;;;56200:70;;:41;;;:19;:41;:::i;:70::-;56178:19;;;:92;56286:35;;;;;;;;;;;;56294:10;;56286:35;;;;;;;;;55504:825;;;;:::o;43420:25::-;;;;:::o;47980:115::-;48062:18;;48038:4;48062:18;;;:11;:18;;;;;:25;;;;;;47980:115::o;54256:192::-;54318:13;:20;54301:14;54349:92;54373:6;54369:1;:10;54349:92;;;54401:28;54412:13;54426:1;54412:16;;;;;;;;;;;;;;;;;;;;54401:10;:28::i;:::-;54381:3;;54349:92;;;;54256:192;:::o;53252:921::-;53326:7;53346:20;;:::i;:::-;-1:-1:-1;53369:18:0;;;;;;;:11;:18;;;;;;;;;53346:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53398:53;;53438:1;53431:8;;;;;53398:53;53489:22;;;;53461:25;53489:22;;;:15;:22;;;;;;;;:29;;;;;;;;;;;53555:20;;;;53605:38;;;;;53637:4;53605:38;;;;;;53489:29;;53555:20;;53489:22;53605:23;;:38;;;;;;;;;;53489:22;53605:38;;;2:2:-1;;;;27:1;24;17:12;2:2;53605:38:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;53605:38:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;53605:38:0;;53673:20;;;53605:38;;-1:-1:-1;53658:12:0;:35;:52;;;;-1:-1:-1;53697:13:0;;;53658:52;:99;;;;;53737:20;;53714:4;:20;;;:43;53658:99;53654:404;;;53774:19;53796:54;53815:4;:20;;;53837:12;53796:18;:54::i;:::-;53774:76;;53865:18;53886:53;53923:15;;53886:32;53902:4;:15;;;53886:11;:15;;:32;;;;:::i;:53::-;53865:74;;53972;53992:53;54036:8;53992:39;54007:23;;53992:10;:14;;:39;;;;:::i;:53::-;53972:15;;:74;:19;:74;:::i;:::-;53954:92;;53654:404;;;54145:19;;;;54116:23;;54075:15;;:90;;54145:19;54075:65;;:36;;54095:15;54075:36;:19;:36;:::i;:90::-;54068:97;53252:921;-1:-1:-1;;;;;;;53252:921:0:o;57306:338::-;57394:22;;;57366:25;57394:22;;;:15;:22;;;;;;;;57417:10;57394:34;;;;;;;;57487:15;;57394:34;;57439:64;;57394:22;;57439:64;:26;:64;:::i;:::-;57556:15;;57519:53;;;;;;;;;;;57537:10;;57519:53;;;;;;;;;57601:1;57583:19;;;57613;;;;:23;-1:-1:-1;57306:338:0:o;22352:140::-;21932:12;:10;:12::i;:::-;21922:6;;:22;:6;;;:22;;;21914:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22451:1:::1;22435:6:::0;;22414:40:::1;::::0;::::1;22435:6:::0;;::::1;::::0;22414:40:::1;::::0;22451:1;;22414:40:::1;22482:1;22465:19:::0;;;::::1;::::0;;22352:140::o;54524:909::-;54601:18;;;54577:21;54601:18;;;:11;:18;;;;;54635:11;;;;;;54634:12;;:52;;;54666:4;:20;;;54650:12;:36;;54634:52;54630:91;;;54703:7;;;54630:91;54750:38;;;;;;54782:4;54750:38;;;;;;54731:16;;54750:23;;;;;;:38;;;;;;;;;;;;;;;:23;:38;;;2:2:-1;;;;27:1;24;17:12;2:2;54750:38:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;54750:38:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;54750:38:0;;-1:-1:-1;54803:13:0;54799:102;;-1:-1:-1;54856:12:0;54833:20;;;;:35;54883:7;;54799:102;54939:20;;54915:4;:20;;;:44;54911:83;;54976:7;;;;54911:83;55004:19;55026:54;55045:4;:20;;;55067:12;55026:18;:54::i;:::-;55004:76;;55091:18;55112:53;55149:15;;55112:32;55128:4;:15;;;55112:11;:15;;:32;;;;:::i;:53::-;55176:4;;55188:7;;55091:74;;-1:-1:-1;55176:4:0;;;;;:11;;55188:7;55197:19;55091:74;55212:3;55197:19;:14;:19;:::i;:::-;55176:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;55176:41:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;55228:4:0;;:38;;;;;;55248:4;55228:38;;;;;;;;;;;;:4;;;;;-1:-1:-1;55228:11:0;;-1:-1:-1;55228:38:0;;;;;:4;;:38;;;;;;;;:4;;:38;;;2:2:-1;;;;27:1;24;17:12;2:2;55228:38:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;55228:38:0;;;;55300:79;55325:53;55369:8;55325:39;55340:23;;55325:10;:14;;:39;;;;:::i;:53::-;55300:20;;;;;:79;:24;:79;:::i;:::-;55277:20;;;:102;-1:-1:-1;;55413:12:0;55390:20;;;;:35;;;;-1:-1:-1;54524:909:0;;:::o;58092:129::-;58163:7;;;;58149:10;:21;58141:43;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58195:7;:18;;;;;;;;;;;;;;;58092:129::o;21710:79::-;21748:7;21775:6;;;21710:79;:::o;43833:32::-;;;;:::o;44168:45::-;;;;:::o;48123:3709::-;48349:19;48392:10;;48385:3;:17;;:50;;;;48430:5;48406:20;;:29;;48385:50;48381:91;;;-1:-1:-1;48459:1:0;48452:8;;48381:91;48494:10;;48486:5;:18;48482:69;;;48529:10;;48521:18;;48482:69;48588:3;48565:20;;:26;48561:85;;;48614:20;;48608:26;;48561:85;48656:25;48684:120;48784:1;48742:39;48766:14;48742:19;48750:10;;48742:3;:7;;:19;;;;:::i;:::-;:23;:39;:23;:39;:::i;:::-;:43;:51;;48792:1;48742:51;;;48788:1;48742:51;48684:120;;:39;48708:14;48684:19;48692:10;;48684:3;:7;;:19;;;;:::i;:120::-;48656:148;;48839:1;48819:17;:21;48815:75;;;-1:-1:-1;48877:1:0;48815:75;48900:22;48925:124;49029:1;48985:41;49011:14;48985:21;48995:10;;48985:5;:9;;:21;;;;:::i;:41::-;:45;:53;;49037:1;48985:53;;;49033:1;48985:53;48925:124;;:41;48951:14;48925:21;48935:10;;48925:5;:9;;:21;;;;:::i;:124::-;48900:149;;49081:1;49064:14;:18;49060:69;;;-1:-1:-1;49116:1:0;49060:69;49161:17;49143:14;:35;49139:162;;;49202:87;49221:67;49240:47;49269:17;49240:24;:17;49262:1;49240:24;:21;:24;:::i;:::-;:28;:47;:28;:47;:::i;:::-;49221:14;;:67;:18;:67;:::i;:::-;49202:14;:3;49210:5;49202:14;:7;:14;:::i;:87::-;49195:94;;;;;;49139:162;49311:31;49345:50;49360:34;:14;49379;49360:34;:18;:34;:::i;:::-;49345:10;;;:50;:14;:50;:::i;:::-;49311:84;-1:-1:-1;49406:36:0;49445:60;49460:44;49479:24;:17;49501:1;49479:24;:21;:24;:::i;:::-;49460:14;;:44;:18;:44;:::i;49445:60::-;49406:99;-1:-1:-1;49550:5:0;49587:3;49619:194;49745:67;49764:47;49793:17;49764:24;:17;49786:1;49764:24;:21;:24;:::i;:47::-;49745:14;;:67;:18;:67;:::i;:::-;49619:107;49655:28;49644:8;:39;:81;;49697:28;49644:81;;;49686:8;49644:81;49619:6;;:107;:24;:107;:::i;:194::-;49605:208;;49858:8;49832:23;:34;:71;;;;;49897:6;49870:23;:33;;49832:71;49828:363;;;49938:237;49976:180;50044:89;50080:1;50063:14;:18;:69;;50131:1;50063:69;;;50084:44;50110:17;50084:21;:14;50103:1;50084:21;:18;:21;:::i;:44::-;50044:14;;:89;:18;:89;:::i;:::-;49976:37;:23;50004:8;49976:37;:27;:37;:::i;:180::-;49938:11;;:237;:15;:237;:::i;:::-;49924:251;;49828:363;-1:-1:-1;50300:14:0;;-1:-1:-1;50357:14:0;50417:17;50453:54;;;50449:1365;;;50571:28;50528:40;50735:84;50801:17;50735:61;50571:28;50772:23;50735:61;:36;:61;:::i;:84::-;50723:96;;50846:1;50842;:5;50838:961;;;50872:10;50885:238;50933:167;50985:88;51055:17;50985:65;51029:20;50985:39;51013:10;;50985:23;:27;;:39;;;;:::i;50933:167::-;50885:17;;:238;:21;:238;:::i;:::-;50872:251;;51146:10;51159:318;51207:247;51259:168;51376:20;51259:78;51335:1;51259:71;51312:17;51259:48;51296:10;;51259:32;:36;;:48;;;;:::i;:168::-;51207:17;;:247;:21;:247;:::i;:::-;51159:17;;:318;:21;:318;:::i;:::-;51146:331;-1:-1:-1;51514:41:0;51530:24;51552:1;51530:17;51536:10;:2;51146:331;51536:10;:6;:10;:::i;51530:24::-;51514:11;;:41;:15;:41;:::i;:::-;51500:55;;50838:961;;;;;51618:161;51660:96;51682:73;51704:50;51733:20;51704:24;:17;51726:1;51704:24;:21;:24;:::i;51660:96::-;51618:11;;:161;:15;:161;:::i;:::-;51604:175;;50838:961;50449:1365;;;48123:3709;;;;;;;;;;;;;;;:::o;43897:35::-;;;;:::o;44244:23::-;;;;;;:::o;43982:42::-;;;;:::o;43742:36::-;;;;:::o;44295:22::-;;;;;;:::o;43205:29::-;;;;:::o;22647:109::-;21932:12;:10;:12::i;:::-;21922:6;;:22;:6;;;:22;;;21914:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22720:28:::1;22739:8;22720:18;:28::i;56383:852::-:0;56475:18;;;56451:21;56475:18;;;:11;:18;;;;;;;;56532:15;:22;;;;;56555:10;56532:34;;;;;;;;56585:15;;:26;-1:-1:-1;56585:26:0;56577:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56645:17;56656:5;56645:10;:17::i;:::-;56673:15;56691:119;56780:8;:19;;;56691:70;56737:23;;56691:41;56711:4;:20;;;56691:8;:15;;;:19;;:41;;;;:::i;:119::-;56673:137;-1:-1:-1;56825:11:0;;56821:81;;56853:37;56870:10;56882:7;56853:16;:37::i;:::-;56916:11;;56912:161;;56962:15;;:28;;56982:7;56962:28;:19;:28;:::i;:::-;56944:46;;57005:56;:26;;;57040:10;57053:7;57005:56;:26;:56;:::i;:::-;57151:23;;57125:20;;;;57105:15;;:70;;57151:23;57105:41;;:15;:41;:19;:41;:::i;:70::-;57083:19;;;:92;57191:36;;;;;;;;;;;;57200:10;;57191:36;;;;;;;;;56383:852;;;;;:::o;44324:30::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;44324:30:0;:::o;20319:98::-;20399:10;20319:98;:::o;1436:136::-;1494:7;1521:43;1525:1;1528;1521:43;;;;;;;;;;;;;;;;;:3;:43::i;972:181::-;1030:7;1062:5;;;1086:6;;;;1078:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2360:471;2418:7;2663:6;2659:47;;-1:-1:-1;2693:1:0;2686:8;;2659:47;2730:5;;;2734:1;2730;:5;:1;2754:5;;;;;:10;2746:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3307:132;3365:7;3392:39;3396:1;3399;3392:39;;;;;;;;;;;;;;;;;:3;:39::i;57758:278::-;57852:4;;:29;;;;;;57875:4;57852:29;;;;;;57834:15;;57852:4;;;:14;;:29;;;;;;;;;;;;;;:4;:29;;;2:2:-1;;;;27:1;24;17:12;2:2;57852:29:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;57852:29:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;57852:29:0;;-1:-1:-1;57896:17:0;;;57892:137;;;57930:4;;:27;;;;;;:4;:27;;;;;;;;;;;;;;;:4;;;;;:13;;:27;;;;;;;;;;;;;;:4;;:27;;;2:2:-1;;;;27:1;24;17:12;2:2;57930:27:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;57930:27:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;57892:137:0;;-1:-1:-1;57892:137:0;;57990:4;;:27;;;;;;:4;:27;;;;;;;;;;;;;;;:4;;;;;:13;;:27;;;;;;;;;;;;;;:4;;:27;;;2:2:-1;;;;27:1;24;17:12;2:2;57990:27:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;57990:27:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;57892:137:0;57758:278;;;:::o;16451:248::-;16622:68;;;;;;;;;;;;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;16622:68:0;;;;;;;;25:18:-1;;61:17;;16622:68:0;182:15:-1;16645:27:0;179:29:-1;160:49;;16595:96:0;;16615:5;;16595:19;:96::i;:::-;16451:248;;;;:::o;16232:211::-;16376:58;;;;;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;16376:58:0;;;;;;;;25:18:-1;;61:17;;16376:58:0;182:15:-1;16399:23:0;179:29:-1;160:49;;16349:86:0;;16369:5;;16349:19;:86::i;4712:130::-;4770:7;4797:37;4801:1;4804;4797:37;;;;;;;;;;;;;;;;;:3;:37::i;22862:229::-;22936:22;;;22928:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23038:6;;;23017:38;;;;;;;23038:6;;;23017:38;;;23066:6;:17;;;;;;;;;;;;;;;22862:229::o;1875:226::-;1995:7;2031:12;2023:6;;;;2015:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;2015:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;2067:5:0;;;1875:226::o;3935:312::-;4055:7;4090:12;4083:5;4075:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;4075:28:0;;4114:9;4130:1;4126;:5;;;;;;;3935:312;-1:-1:-1;;;;;3935:312:0:o;18767:774::-;19191:23;19217:69;19245:4;19217:69;;;;;;;;;;;;;;;;;19225:5;19217:27;;;;:69;;;;;:::i;:::-;19301:17;;19191:95;;-1:-1:-1;19301:21:0;19297:237;;19456:10;19445:30;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;19445:30:0;19437:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5327:200;5447:7;5483:12;5475:6;5467:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;5467:29:0;;5518:1;5514;:5;;;;;;;5327:200;-1:-1:-1;;;;5327:200:0:o;13123:230::-;13260:12;13292:53;13315:6;13323:4;13329:1;13332:12;13292:22;:53::i;:::-;13285:60;13123:230;-1:-1:-1;;;;13123:230:0:o;14611:1020::-;14784:12;14817:18;14828:6;14817:10;:18::i;:::-;14809:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14943:12;14957:23;14984:6;:11;;15003:8;15013:4;14984:34;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;176:10;;164:23;;139:12;;;;;98:2;89:12;;;;114;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;14984:34:0;;;;;;;;;;;;;;;;;;;;;;;;;12:1:-1;19;14:27;;;;67:4;61:11;56:16;;134:4;130:9;123:4;105:16;101:27;97:43;94:1;90:51;84:4;77:65;157:16;154:1;147:27;211:16;208:1;201:4;198:1;194:12;179:49;5:228;;14:27;32:4;27:9;;5:228;;14942:76:0;;;;15033:7;15029:595;;;15064:10;-1:-1:-1;15057:17:0;;-1:-1:-1;15057:17:0;15029:595;15178:17;;:21;15174:439;;15441:10;15435:17;15502:15;15489:10;15485:2;15481:19;15474:44;15389:148;15577:20;;;;;;;;;;;;;;;;;;;;15584:12;;15577:20;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;9986:641:0;10046:4;10527:20;;10357:66;10576:23;;;;;;:42;;-1:-1:-1;;10603:15:0;;;10568:51;-1:-1:-1;;9986:641:0:o;41853:16371::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o

Swarm Source

ipfs://e08d9a37a7ca07151a3b1121339f915992fd5c5c5433a3a3806098986b154aac
Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading