Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•  contract Context
•    - function _msgSender()
•    - function _msgData()
•  contract Ownable is Context
•    - function owner()
•    - function isOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b, st ...
•  contract ERC20 is Context, IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
•    - function increaseAllowance(address sp ...
•    - function decreaseAllowance(address sp ...
•    - function _transfer(address sender, ad ...
•    - function _mint(address account, uint2 ...
•    - function _burn(address account, uint2 ...
•    - function _approve(address owner, addr ...
•    - function _burnFrom(address account, u ...
•  contract RariMine is Ownable *
•    - function claim()
•    - function plus(Balance[] memory _balan ...
•    - function minus(Balance[] memory _bala ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-07-14
*/

pragma solidity ^0.5.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
contract Context {
    // Empty internal constructor, to prevent people from mistakenly deploying
    // an instance of this contract, which should be used via inheritance.
    constructor () internal { }
    // solhint-disable-previous-line no-empty-blocks

    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;
    }
}

/**
 * @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.
 *
 * 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(isOwner(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Returns true if the caller is the current owner.
     */
    function isOwner() public view returns (bool) {
        return _msgSender() == _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;
    }
}

/**
 * @dev Interface of the ERC20 standard as defined in the EIP. Does not include
 * the optional functions; to access them see {ERC20Detailed}.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

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

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

/**
 * @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.
     *
     * _Available since v2.4.0._
     */
    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.
     *
     * _Available since v2.4.0._
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        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.
     *
     * _Available since v2.4.0._
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

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

    mapping (address => uint256) private _balances;

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

    uint256 private _totalSupply;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev Destroys `amount` tokens from `account`.`amount` is then deducted
     * from the caller's allowance.
     *
     * See {_burn} and {_approve}.
     */
    function _burnFrom(address account, uint256 amount) internal {
        _burn(account, amount);
        _approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
    }
}

pragma experimental ABIEncoderV2;




contract RariMine is Ownable {
    using SafeMath for uint;

    event BalanceChange(address indexed owner, uint balance);

    struct Balance {
        address recipient;
        uint256 value;
    }

    ERC20 public token;
    address public tokenOwner;
    mapping(address => uint) public balances;

    constructor(ERC20 _token, address _tokenOwner) public {
        token = _token;
        tokenOwner = _tokenOwner;
    }

    function claim() public {
        uint balance = balances[msg.sender];
        require(balance > 0, "balance should be positive");
        balances[msg.sender] = 0;
        require(token.transferFrom(tokenOwner, msg.sender, balance), "transfer is not successful");
        emit BalanceChange(msg.sender, 0);
    }

    function plus(Balance[] memory _balances) public onlyOwner {
        for (uint i = 0; i < _balances.length; i++) {
            address recipient = _balances[i].recipient;
            uint value = _balances[i].value;
            require(recipient != address(0x0), "Recipient should be present");
            require(value != 0, "value should be positive");
            balances[recipient] = balances[recipient].add(_balances[i].value);
            emit BalanceChange(recipient, balances[recipient]);
        }
    }

    function minus(Balance[] memory _balances) public onlyOwner {
        for (uint i = 0; i < _balances.length; i++) {
            address recipient = _balances[i].recipient;
            uint value = _balances[i].value;
            require(recipient != address(0x0), "Recipient should be present");
            require(value != 0, "value should be positive");
            if (balances[recipient] > _balances[i].value) {
                balances[recipient] = balances[recipient] - _balances[i].value;
            } else {
                balances[recipient] = 0;
            }
            emit BalanceChange(recipient, balances[recipient]);
        }
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract ERC20","name":"_token","type":"address"},{"internalType":"address","name":"_tokenOwner","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"balance","type":"uint256"}],"name":"BalanceChange","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"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"balances","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"claim","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"components":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"internalType":"struct RariMine.Balance[]","name":"_balances","type":"tuple[]"}],"name":"minus","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"components":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"internalType":"struct RariMine.Balance[]","name":"_balances","type":"tuple[]"}],"name":"plus","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"renounceOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"token","outputs":[{"internalType":"contract ERC20","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"tokenOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000fca59cd816ab1ead66534d82bc21e7515ce441cf0000000000000000000000002baf03e3030f0c8685534a3b603c13a4828036c7

-----Decoded View---------------
Arg [0] : _token (address): 0xFca59Cd816aB1eaD66534D82bc21E7515cE441CF
Arg [1] : _tokenOwner (address): 0x2Baf03e3030f0c8685534a3b603C13a4828036c7

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000fca59cd816ab1ead66534d82bc21e7515ce441cf
Arg [1] : 0000000000000000000000002baf03e3030f0c8685534a3b603c13a4828036c7

20041:1980:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;20041:1980:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20314:40;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;20493:319;;;:::i;:::-;;2826:140;;;:::i;20820:523::-;;;;;;;;;:::i;2015:79::-;;;:::i;:::-;;;;;;;;2381:94;;;:::i;:::-;;;;;;;;20282:25;;;:::i;21351:665::-;;;;;;;;;:::i;3121:109::-;;;;;;;;;:::i;20257:18::-;;;:::i;:::-;;;;;;;;20314:40;;;;;;;;;;;;;:::o;20493:319::-;20552:10;20528:12;20543:20;;;:8;:20;;;;;;20582:11;20574:50;;;;-1:-1:-1;;;20574:50:0;;;;;;;;;;;;;;;;;20644:10;20658:1;20635:20;;;:8;:20;;;;;;:24;;;;20678:5;;20697:10;;20678:51;;-1:-1:-1;;;20678:51:0;;-1:-1:-1;;;;;20678:5:0;;;;:18;;:51;;20697:10;;20721:7;;20678:51;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;20678:51:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;20678:51: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;20678:51:0;;;;;;;;;20670:90;;;;-1:-1:-1;;;20670:90:0;;;;;;;;;20790:10;-1:-1:-1;;;;;20776:28:0;;20802:1;20776:28;;;;;;;;;;;;;;;20493:319;:::o;2826:140::-;2227:9;:7;:9::i;:::-;2219:54;;;;-1:-1:-1;;;2219:54:0;;;;;;;;;2925:1;2909:6;;2888:40;;-1:-1:-1;;;;;2909:6:0;;;;2888:40;;2925:1;;2888:40;2956:1;2939:19;;-1:-1:-1;;;;;;2939:19:0;;;2826:140::o;20820:523::-;2227:9;:7;:9::i;:::-;2219:54;;;;-1:-1:-1;;;2219:54:0;;;;;;;;;20895:6;20890:446;20911:9;:16;20907:1;:20;20890:446;;;20949:17;20969:9;20979:1;20969:12;;;;;;;;;;;;;;:22;;;20949:42;;21006:10;21019:9;21029:1;21019:12;;;;;;;;;;;;;;:18;;;21006:31;;21081:3;-1:-1:-1;;;;;21060:25:0;:9;-1:-1:-1;;;;;21060:25:0;;;21052:65;;;;-1:-1:-1;;;21052:65:0;;;;;;;;;21140:10;21132:47;;;;-1:-1:-1;;;21132:47:0;;;;;;;;;21216:43;21240:9;21250:1;21240:12;;;;;;;;;;;;;;:18;;;21216:8;:19;21225:9;-1:-1:-1;;;;;21216:19:0;-1:-1:-1;;;;;21216:19:0;;;;;;;;;;;;;:23;;:43;;;;:::i;:::-;-1:-1:-1;;;;;21194:19:0;;;;;;:8;:19;;;;;;;:65;;;21279:45;21194:19;;21279:45;;;;21194:65;21279:45;;;;;;;;;;-1:-1:-1;;20929:3:0;;20890:446;;;;20820:523;:::o;2015:79::-;2053:7;2080:6;-1:-1:-1;;;;;2080:6:0;2015:79;:::o;2381:94::-;2421:4;2461:6;;-1:-1:-1;;;;;2461:6:0;2445:12;:10;:12::i;:::-;-1:-1:-1;;;;;2445:22:0;;2438:29;;2381:94;:::o;20282:25::-;;;-1:-1:-1;;;;;20282:25:0;;:::o;21351:665::-;2227:9;:7;:9::i;:::-;2219:54;;;;-1:-1:-1;;;2219:54:0;;;;;;;;;21427:6;21422:587;21443:9;:16;21439:1;:20;21422:587;;;21481:17;21501:9;21511:1;21501:12;;;;;;;;;;;;;;:22;;;21481:42;;21538:10;21551:9;21561:1;21551:12;;;;;;;;;;;;;;:18;;;21538:31;;21613:3;-1:-1:-1;;;;;21592:25:0;:9;-1:-1:-1;;;;;21592:25:0;;;21584:65;;;;-1:-1:-1;;;21584:65:0;;;;;;;;;21672:10;21664:47;;;;-1:-1:-1;;;21664:47:0;;;;;;;;;21752:9;21762:1;21752:12;;;;;;;;;;;;;;:18;;;21730:8;:19;21739:9;-1:-1:-1;;;;;21730:19:0;-1:-1:-1;;;;;21730:19:0;;;;;;;;;;;;;:40;21726:207;;;21835:9;21845:1;21835:12;;;;;;;;;;;;;;;;;;;:18;;;-1:-1:-1;;;;;21813:19:0;;;;;;:8;:19;;;;;;;;;:40;;;;21791:62;;21726:207;;;-1:-1:-1;;;;;21894:19:0;;21916:1;21894:19;;;:8;:19;;;;;:23;21726:207;-1:-1:-1;;;;;21952:45:0;;21977:19;;;;:8;:19;;;;;;;;21952:45;;;;;;;;;;;;;;;;-1:-1:-1;;21461:3:0;;21422:587;;3121:109;2227:9;:7;:9::i;:::-;2219:54;;;;-1:-1:-1;;;2219:54:0;;;;;;;;;3194:28;3213:8;3194:18;:28::i;:::-;3121:109;:::o;20257:18::-;;;-1:-1:-1;;;;;20257:18:0;;:::o;7198:181::-;7256:7;7288:5;;;7312:6;;;;7304:46;;;;-1:-1:-1;;;7304:46:0;;;;;;;;;7370:1;-1:-1:-1;7198:181:0;;;;;:::o;806:98::-;886:10;806:98;:::o;3336:229::-;-1:-1:-1;;;;;3410:22:0;;3402:73;;;;-1:-1:-1;;;3402:73:0;;;;;;;;;3512:6;;;3491:38;;-1:-1:-1;;;;;3491:38:0;;;;3512:6;;;3491:38;;;3540:6;:17;;-1:-1:-1;;;;;;3540:17:0;-1:-1:-1;;;;;3540:17:0;;;;;;;;;;3336:229::o;5:130:-1:-;72:20;;97:33;72:20;97:33;;176:767;;313:3;306:4;298:6;294:17;290:27;280:2;;331:1;328;321:12;280:2;368:6;355:20;390:100;405:84;482:6;405:84;;;390:100;;;381:109;;507:5;532:6;525:5;518:21;562:4;554:6;550:17;540:27;;584:4;579:3;575:14;568:21;;637:6;684:3;676:4;668:6;664:17;659:3;655:27;652:36;649:2;;;701:1;698;691:12;649:2;726:1;711:226;736:6;733:1;730:13;711:226;;;794:3;816:57;869:3;857:10;816:57;;;804:70;;-1:-1;897:4;888:14;;;;925:4;916:14;;;;;758:1;751:9;711:226;;;715:14;273:670;;;;;;;;951:128;1026:13;;1044:30;1026:13;1044:30;;1116:468;;1225:4;1213:9;1208:3;1204:19;1200:30;1197:2;;;1243:1;1240;1233:12;1197:2;1261:20;1276:4;1261:20;;;1252:29;-1:-1;1336:1;1368:49;1413:3;1393:9;1368:49;;;1343:75;;-1:-1;1480:2;1513:49;1558:3;1534:22;;;1513:49;;;1506:4;1499:5;1495:16;1488:75;1439:135;1191:393;;;;;1591:130;1658:20;;1683:33;1658:20;1683:33;;1728:241;;1832:2;1820:9;1811:7;1807:23;1803:32;1800:2;;;1848:1;1845;1838:12;1800:2;1883:1;1900:53;1945:7;1925:9;1900:53;;;1890:63;1794:175;-1:-1;;;;1794:175;1976:417;;2125:2;2113:9;2104:7;2100:23;2096:32;2093:2;;;2141:1;2138;2131:12;2093:2;2176:31;;2227:18;2216:30;;2213:2;;;2259:1;2256;2249:12;2213:2;2279:98;2369:7;2360:6;2349:9;2345:22;2279:98;;2400:257;;2512:2;2500:9;2491:7;2487:23;2483:32;2480:2;;;2528:1;2525;2518:12;2480:2;2563:1;2580:61;2633:7;2613:9;2580:61;;2664:142;2755:45;2794:5;2755:45;;;2750:3;2743:58;2737:69;;;2813:113;2896:24;2914:5;2896:24;;2933:104;3010:21;3025:5;3010:21;;3044:152;3140:50;3184:5;3140:50;;3203:142;3294:45;3333:5;3294:45;;3353:324;;3513:67;3577:2;3572:3;3513:67;;;3613:26;3593:47;;3668:2;3659:12;;3499:178;-1:-1;;3499:178;3686:375;;3846:67;3910:2;3905:3;3846:67;;;3946:34;3926:55;;-1:-1;;;4010:2;4001:12;;3994:30;4052:2;4043:12;;3832:229;-1:-1;;3832:229;4070:327;;4230:67;4294:2;4289:3;4230:67;;;4330:29;4310:50;;4388:2;4379:12;;4216:181;-1:-1;;4216:181;4406:326;;4566:67;4630:2;4625:3;4566:67;;;4666:28;4646:49;;4723:2;4714:12;;4552:180;-1:-1;;4552:180;4741:332;;4901:67;4965:2;4960:3;4901:67;;;5001:34;4981:55;;5064:2;5055:12;;4887:186;-1:-1;;4887:186;5082:327;;5242:67;5306:2;5301:3;5242:67;;;5342:29;5322:50;;5400:2;5391:12;;5228:181;-1:-1;;5228:181;5418:326;;5578:67;5642:2;5637:3;5578:67;;;5678:28;5658:49;;5735:2;5726:12;;5564:180;-1:-1;;5564:180;5752:113;5835:24;5853:5;5835:24;;5872:213;5990:2;5975:18;;6004:71;5979:9;6048:6;6004:71;;6092:451;6274:2;6259:18;;6288:71;6263:9;6332:6;6288:71;;;6370:80;6446:2;6435:9;6431:18;6422:6;6370:80;;;6461:72;6529:2;6518:9;6514:18;6505:6;6461:72;;6550:201;6662:2;6647:18;;6676:65;6651:9;6714:6;6676:65;;6758:239;6889:2;6874:18;;6903:84;6878:9;6960:6;6903:84;;7004:229;7130:2;7115:18;;7144:79;7119:9;7196:6;7144:79;;7240:407;7431:2;7445:47;;;7416:18;;7506:131;7416:18;7506:131;;7654:407;7845:2;7859:47;;;7830:18;;7920:131;7830:18;7920:131;;8068:407;8259:2;8273:47;;;8244:18;;8334:131;8244:18;8334:131;;8482:407;8673:2;8687:47;;;8658:18;;8748:131;8658:18;8748:131;;8896:407;9087:2;9101:47;;;9072:18;;9162:131;9072:18;9162:131;;9310:407;9501:2;9515:47;;;9486:18;;9576:131;9486:18;9576:131;;9724:407;9915:2;9929:47;;;9900:18;;9990:131;9900:18;9990:131;;10138:213;10256:2;10241:18;;10270:71;10245:9;10314:6;10270:71;;10358:256;10420:2;10414:9;10446:17;;;10521:18;10506:34;;10542:22;;;10503:62;10500:2;;;10578:1;10575;10568:12;10500:2;10594;10587:22;10398:216;;-1:-1;10398:216;10621:324;;10800:18;10792:6;10789:30;10786:2;;;10832:1;10829;10822:12;10786:2;-1:-1;10867:4;10855:17;;;10920:15;;10723:222;10953:163;11056:19;;;11105:4;11096:14;;11049:67;11124:91;;11186:24;11204:5;11186:24;;11222:85;11288:13;11281:21;;11264:43;11314:121;-1:-1;;;;;11376:54;;11359:76;11442:72;11504:5;11487:27;11521:129;;11608:37;11639:5;11657:147;;11749:50;11793:5;11749:50;;11939:116;;12026:24;12044:5;12026:24;;12305:117;12374:24;12392:5;12374:24;;;12367:5;12364:35;12354:2;;12413:1;12410;12403:12;12429:111;12495:21;12510:5;12495:21;;12547:117;12616:24;12634:5;12616:24;

bzzr://6e4aa813199a57fbfbc60a46bdf24cd07a9588c63f4363a91f5e758c3a378a71