Contract 0x388fbcdca97c4bad5de501079440a36b946361a0 1

Contract Overview

Balance:
0 BNB
Txn Hash Method
Block
From
To
Value [Txn Fee]
0x67477d26fa41a30b92ed103616b5a57b13f0669810972b26e385f4950953264a0x6080604021065382020-09-21 11:38:06440 days 18 hrs ago0x9957887a260c7db1d4cb1fa67c0ce43d9b1d72c5 IN  Contract Creation0 BNB0.0061964
[ Download CSV Export 
Latest 2 internal transactions
Parent Txn Hash Block From To Value
0x89cf1c0db90c9625d99438b5e0c679fd6a198d5b50b6b2e6e831d7835483c88921248532020-09-22 2:54:12440 days 3 hrs ago 0x8a74f0a9372bb34fc6d1506a0b2ef915312034fc 0x388fbcdca97c4bad5de501079440a36b946361a00 BNB
0xa597e7b8365c7445c96d9f4a07769025f2b9849c56eace25d0c605f506d4af9f21065632020-09-21 11:39:21440 days 18 hrs ago 0x8a74f0a9372bb34fc6d1506a0b2ef915312034fc 0x388fbcdca97c4bad5de501079440a36b946361a00 BNB
[ Download CSV Export 
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
Airdrop

Compiler Version
v0.6.4+commit.1dca32f3

Optimization Enabled:
Yes with 200 runs

Other Settings:
constantinople EvmVersion, None license

Contract Source Code (Solidity)

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

pragma experimental ABIEncoderV2;
pragma solidity 0.6.4;


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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
/**
 * @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 a, uint256 b) internal pure returns (uint256) {
        return a <= b ? a : b;
    }

    function abs(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a < b) {
            return b - a;
        }
        return a - b;
    }
}

// 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) {
        // This method relies in extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

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

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

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

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

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

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

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(
            address(this).balance >= value,
            "Address: insufficient balance for call"
        );
        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 SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

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

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

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

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

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

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

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

/**
 * @title Initializable
 *
 * @dev Helper contract to support initializer functions. To use it, replace
 * the constructor with a function that has the `initializer` modifier.
 * WARNING: Unlike constructors, initializer functions must be manually
 * invoked. This applies both to deploying an Initializable contract, as well
 * as extending an Initializable contract via inheritance.
 * WARNING: When used with inheritance, manual care must be taken to not invoke
 * a parent initializer twice, or ensure that all initializers are idempotent,
 * because this is not dealt with automatically as with constructors.
 */
contract Initializable {

  /**
   * @dev Indicates that the contract has been initialized.
   */
  bool private initialized;

  /**
   * @dev Indicates that the contract is in the process of being initialized.
   */
  bool private initializing;

  /**
   * @dev Modifier to use in the initializer function of a contract.
   */
  modifier initializer() {
    require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");

    bool isTopLevelCall = !initializing;
    if (isTopLevelCall) {
      initializing = true;
      initialized = true;
    }

    _;

    if (isTopLevelCall) {
      initializing = false;
    }
  }

  /// @dev Returns true if and only if the function is running in the constructor
  function isConstructor() private view returns (bool) {
    // extcodesize checks the size of the code stored in an address, and
    // address returns the current address. Since the code is still not
    // deployed when running a constructor, any checks on its code size will
    // yield zero, making it an effective way to detect if a contract is
    // under construction or not.
    address self = address(this);
    uint256 cs;
    assembly { cs := extcodesize(self) }
    return cs == 0;
  }

  // Reserved storage space to allow for layout changes in the future.
  uint256[50] private ______gap;
}

contract Airdrop is Initializable {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    address public admin;
    address public token;

    event Multisended(uint256 total, address tokenAddress);

    event ClaimedTokens(address token, address owner, uint256 balance);

    fallback() external payable {}

    receive() external payable {}

    function initialize(address _token) public initializer {
        admin = msg.sender;
        token = _token;
    }

    modifier onlyAdmin {
        require(msg.sender == admin, "require admin");
        _;
    }

    function setToken(address _token) public onlyAdmin {
        token = _token;
    }

    function claimTokens(address _token) public onlyAdmin {
        address payable o = address(uint160(admin));
        if (_token == address(0x0)) {
            o.transfer(address(this).balance);
            return;
        }
        IERC20 erc20token = IERC20(_token);
        uint256 balance = erc20token.balanceOf(address(this));
        erc20token.safeTransfer(o, balance);
        emit ClaimedTokens(_token, o, balance);
    }

    function multisendToken(
        address[] calldata _contributors,
        uint256[] calldata _balances
    ) external {
        require(_contributors.length == _balances.length, "length not match");
        uint256 n = _contributors.length;
        uint256 total = 0;
        for (uint256 i = 0; i < n; i++) {
            IERC20(token).safeTransferFrom(
                msg.sender,
                _contributors[i],
                _balances[i]
            );
            total = total.add(_balances[i]);
        }

        emit Multisended(total, token);
    }
}

Contract ABI

[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"balance","type":"uint256"}],"name":"ClaimedTokens","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"total","type":"uint256"},{"indexed":false,"internalType":"address","name":"tokenAddress","type":"address"}],"name":"Multisended","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[],"name":"admin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"claimTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_contributors","type":"address[]"},{"internalType":"uint256[]","name":"_balances","type":"uint256[]"}],"name":"multisendToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"setToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

Deployed ByteCode Sourcemap

21493:1727:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22099:84;;5:9:-1;2:2;;;27:1;24;17:12;2:2;-1:-1;22099:84:0;;;;;;;;:::i;21871:117::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;-1:-1;21871:117:0;;;;;;;;:::i;22638:579::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;-1:-1;22638:579:0;;;;;;;;:::i;22191:439::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;-1:-1;22191:439:0;;;;;;;;:::i;21602:20::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;21602:20:0;;;:::i;:::-;;;;;;;;;;;;;;;;21629;;5:9:-1;2:2;;;27:1;24;17:12;2:2;21629:20:0;;;:::i;22099:84::-;22048:5;;-1:-1:-1;;;;;22048:5:0;22034:10;:19;22026:45;;;;-1:-1:-1;;;22026:45:0;;;;;;;;;;;;;;;;;22161:5:::1;:14:::0;;-1:-1:-1;;;;;;22161:14:0::1;-1:-1:-1::0;;;;;22161:14:0;;;::::1;::::0;;;::::1;::::0;;22099:84::o;21871:117::-;20469:12;;;;;;;;:31;;;20485:15;:13;:15::i;:::-;20469:47;;;-1:-1:-1;20505:11:0;;;;20504:12;20469:47;20461:106;;;;-1:-1:-1;;;20461:106:0;;;;;;;;;20576:19;20599:12;;;;;;20598:13;20618:83;;;;20647:12;:19;;-1:-1:-1;;;;20647:19:0;;;;;20675:18;20662:4;20675:18;;;20618:83;21937:5:::1;:18:::0;;21945:10:::1;-1:-1:-1::0;;;;;;21937:18:0;;::::1;;::::0;;;21966:5:::1;:14:::0;;;;::::1;-1:-1:-1::0;;;;;21966:14:0;::::1;;::::0;;20719:57;;;;20763:5;20748:20;;-1:-1:-1;;20748:20:0;;;20719:57;21871:117;;:::o;22638:579::-;22779:40;;;22771:69;;;;-1:-1:-1;;;22771:69:0;;;;;;;;;22863:13;22851:9;;22922:245;22946:1;22942;:5;22922:245;;;22969:140;23018:10;23047:13;;23061:1;23047:16;;;;;;;;;;;;;;;;;;;;;;23082:9;;23092:1;23082:12;;;;;;;22976:5;;-1:-1:-1;;;;;22976:5:0;;22969:140;;23082:12;;;;;;;-1:-1:-1;22969:140:0;:30;:140;:::i;:::-;23132:23;23142:9;;23152:1;23142:12;;;;;;;;;;;;;23132:5;:9;;:23;;;;:::i;:::-;23124:31;-1:-1:-1;22949:3:0;;22922:245;;;-1:-1:-1;23203:5:0;;23184:25;;;;;;23196:5;;-1:-1:-1;;;;;23203:5:0;;23184:25;;;;;;;;;;22638:579;;;;;;:::o;22191:439::-;22048:5;;-1:-1:-1;;;;;22048:5:0;22034:10;:19;22026:45;;;;-1:-1:-1;;;22026:45:0;;;;;;;;;22292:5:::1;::::0;-1:-1:-1;;;;;22292:5:0;;::::1;::::0;22314:22;::::1;22310:109;;22353:33;::::0;-1:-1:-1;;;;;22353:10:0;::::1;::::0;22372:4:::1;22364:21;22353:33:::0;::::1;;;::::0;::::1;::::0;;;22364:21;22353:10;:33;::::1;;;;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;22353:33:0;22401:7;;;22310:109;22492:35;::::0;-1:-1:-1;;;22492:35:0;;22456:6;;22429:17:::1;::::0;-1:-1:-1;;;;;22492:20:0;::::1;::::0;::::1;::::0;:35:::1;::::0;22521:4:::1;::::0;22492:35:::1;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24::::0;17:12:::1;2:2;22492:35:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;22492:35:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;22492:35:0;;;;;;;;;22474:53:::0;-1:-1:-1;22538:35:0::1;-1:-1:-1::0;;;;;22538:23:0;::::1;22562:1:::0;22474:53;22538:35:::1;:23;:35;:::i;:::-;22589:33;22603:6;22611:1;22614:7;22589:33;;;;;;;;;;;;;;;;;22082:1;;;;22191:439:::0;:::o;21602:20::-;;;-1:-1:-1;;;;;21602:20:0;;:::o;21629:::-;;;-1:-1:-1;;;;;21629:20:0;;:::o;20870:508::-;21287:4;21333:17;21365:7;20870:508;:::o;15965:285::-;16109:133;16143:5;16186:27;;;16215:4;16221:2;16225:5;16163:68;;;;;;;;;;;;;;;-1:-1:-1;;26:21;;;22:32;6:49;;16163:68:0;;;49:4:-1;25:18;;61:17;;-1:-1;;;;;182:15;-1:-1;;;;;;16163:68:0;;;179:29:-1;;;;160:49;;;16109:19:0;:133::i;:::-;15965:285;;;;:::o;3851:181::-;3909:7;3941:5;;;3965:6;;;;3957:46;;;;-1:-1:-1;;;3957:46:0;;;;;;;;;4023:1;3851:181;-1:-1:-1;;;3851:181:0:o;15709:248::-;15826:123;15860:5;15903:23;;;15928:2;15932:5;15880:58;;;;;;;;;;15826:123;15709:248;;;:::o;18585:860::-;19009:23;19035:106;19077:4;19035:106;;;;;;;;;;;;;;;;;19043:5;-1:-1:-1;;;;;19035:27:0;;;:106;;;;;:::i;:::-;19156:17;;19009:132;;-1:-1:-1;19156:21:0;19152:286;;19329:10;19318:30;;;;;;;;;;;;;;19292:134;;;;-1:-1:-1;;;19292:134:0;;;;;;;;12445:230;12582:12;12614:53;12637:6;12645:4;12651:1;12654:12;12614:22;:53::i;:::-;12607:60;12445:230;-1:-1:-1;;;;12445:230:0:o;14066:1044::-;14239:12;14272:18;14283:6;14272:10;:18::i;:::-;14264:60;;;;-1:-1:-1;;;14264:60:0;;;;;;;;;14398:12;14412:23;14439:6;-1:-1:-1;;;;;14439:11:0;14458:8;14482:4;14439:58;;;;;;;;;;;;;;;;;;;;;;;;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;;14397:100:0;;;;14512:7;14508:595;;;14543:10;-1:-1:-1;14536:17:0;;-1:-1:-1;14536:17:0;14508:595;14657:17;;:21;14653:439;;14920:10;14914:17;14981:15;14968:10;14964:2;14960:19;14953:44;14868:148;15063:12;15056:20;;-1:-1:-1;;;15056:20:0;;;;;;;;;9408:444;9788:20;9836:8;;;9408:444::o;160:352:-1:-;;;290:3;283:4;275:6;271:17;267:27;257:2;;-1:-1;;298:12;257:2;-1:-1;328:20;;368:18;357:30;;354:2;;;-1:-1;;390:12;354:2;434:4;426:6;422:17;410:29;;485:3;434:4;;469:6;465:17;426:6;451:32;;448:41;445:2;;;502:1;;492:12;445:2;250:262;;;;;;1174:241;;1278:2;1266:9;1257:7;1253:23;1249:32;1246:2;;;-1:-1;;1284:12;1246:2;72:20;;-1:-1;;;;;11761:54;;12726:35;;12716:2;;-1:-1;;12765:12;1422:678;;;;;1613:2;1601:9;1592:7;1588:23;1584:32;1581:2;;;-1:-1;;1619:12;1581:2;1677:17;1664:31;1715:18;;1707:6;1704:30;1701:2;;;-1:-1;;1737:12;1701:2;1775:80;1847:7;1838:6;1827:9;1823:22;1775:80;;;1765:90;;-1:-1;1765:90;-1:-1;1920:2;1905:18;;1892:32;;-1:-1;1933:30;;;1930:2;;;-1:-1;;1966:12;1930:2;;2004:80;2076:7;2067:6;2056:9;2052:22;2004:80;;;1575:525;;;;-1:-1;1994:90;-1:-1;;;;1575:525;2107:257;;2219:2;2207:9;2198:7;2194:23;2190:32;2187:2;;;-1:-1;;2225:12;2187:2;979:6;973:13;12872:5;11673:13;11666:21;12850:5;12847:32;12837:2;;-1:-1;;12883:12;2371:263;;2486:2;2474:9;2465:7;2461:23;2457:32;2454:2;;;-1:-1;;2492:12;2454:2;-1:-1;1111:13;;2448:186;-1:-1;2448:186;5848:262;;3070:5;11014:12;3181:52;3226:6;3221:3;3214:4;3207:5;3203:16;3181:52;;;3245:16;;;;;5973:137;-1:-1;;5973:137;6117:213;-1:-1;;;;;11761:54;;;;2861:37;;6235:2;6220:18;;6206:124;6573:451;-1:-1;;;;;11761:54;;;2861:37;;11761:54;;;;6927:2;6912:18;;2720:58;7010:2;6995:18;;5799:37;;;;6755:2;6740:18;;6726:298;7473:324;-1:-1;;;;;11761:54;;;;2861:37;;7783:2;7768:18;;5799:37;7619:2;7604:18;;7590:207;7804:301;;7942:2;7963:17;7956:47;3418:5;11014:12;11453:6;7942:2;7931:9;7927:18;11441:19;3512:52;3557:6;11481:14;7931:9;11481:14;7942:2;3538:5;3534:16;3512:52;;;12646:7;12630:14;-1:-1;;12626:28;3576:39;;;;11481:14;3576:39;;7913:192;-1:-1;;7913:192;8112:407;8303:2;8317:47;;;3852:2;8288:18;;;11441:19;3888:29;11481:14;;;3868:50;3937:12;;;8274:245;8526:407;8717:2;8731:47;;;4188:2;8702:18;;;11441:19;4224:34;11481:14;;;4204:55;-1:-1;;;4279:12;;;4272:38;4329:12;;;8688:245;8940:407;9131:2;9145:47;;;4580:2;9116:18;;;11441:19;-1:-1;;;11481:14;;;4596:36;4651:12;;;9102:245;9354:407;9545:2;9559:47;;;4902:2;9530:18;;;11441:19;-1:-1;;;11481:14;;;4918:39;4976:12;;;9516:245;9768:407;9959:2;9973:47;;;5227:2;9944:18;;;11441:19;5263:31;11481:14;;;5243:52;5314:12;;;9930:245;10182:407;10373:2;10387:47;;;5565:2;10358:18;;;11441:19;5601:34;11481:14;;;5581:55;-1:-1;;;5656:12;;;5649:34;5702:12;;;10344:245;10596:324;5799:37;;;-1:-1;;;;;11761:54;10906:2;10891:18;;2861:37;10742:2;10727:18;;10713:207;12286:268;12351:1;12358:101;12372:6;12369:1;12366:13;12358:101;;;12439:11;;;12433:18;12420:11;;;12413:39;12394:2;12387:10;12358:101;;;12474:6;12471:1;12468:13;12465:2;;;-1:-1;;12351:1;12521:16;;12514:27;12335:219

Swarm Source

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