Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•  contract BigBrainCoin *
•    - function buy(address _referredBy)
•    - function()
•    - function reinvest()
•    - function exit()
•    - function withdraw()
•    - function sell(uint256 _amountOfTokens ...
•    - function transfer(address _toAddress, ...
•    - function totalEthereumBalance()
•    - function totalSupply()
•    - function myTokens()
•    - function myDividends(bool _includeRef ...
•    - function balanceOf(address _customerA ...
•    - function dividendsOf(address _custome ...
•    - function sellPrice()
•    - function buyPrice()
•    - function calculateTokensReceived(uint ...
•    - function calculateEthereumReceived(ui ...
•    - function purchaseTokens(uint256 _inco ...
•    - function ethereumToTokens_(uint256 _e ...
•    - function tokensToEthereum_(uint256 _t ...
•    - function sqrt(uint256 x)
• library SafeMath
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function add(uint256 a, uint256 b)

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-05-09
*/

pragma solidity ^0.4.20;

/*
* PAPA presents...
* BBC
* BigBrainCoin
*
* https://shutr.bz/3dwpXS1
* 
* A small premine pyramid shitclone, enter at your own risk, many people have made money on these things, many people have lost money as well. Good luck to everyone. 
*
* -> What?
* Incorporated the strong points of different POW{x}, best config:
* [✓] 10% dividends for token purchase, shared among all token holders.
* [✓] 10% dividends for token transfer, shared among all token holders.
* [✓] 15% dividends for token selling.
* [✓] 7% dividends is given to referrer.
* [✓] 50 tokens to activate Masternodes.
*
*/

contract BigBrainCoin {


    /*=================================
    =            MODIFIERS            =
    =================================*/

    /// @dev Only people with tokens
    modifier onlyBagholders {
        require(myTokens() > 0);
        _;
    }

    /// @dev Only people with profits
    modifier onlyStronghands {
        require(myDividends(true) > 0);
        _;
    }


    /*==============================
    =            EVENTS            =
    ==============================*/

    event onTokenPurchase(
        address indexed customerAddress,
        uint256 incomingEthereum,
        uint256 tokensMinted,
        address indexed referredBy,
        uint timestamp,
        uint256 price
    );

    event onTokenSell(
        address indexed customerAddress,
        uint256 tokensBurned,
        uint256 ethereumEarned,
        uint timestamp,
        uint256 price
    );

    event onReinvestment(
        address indexed customerAddress,
        uint256 ethereumReinvested,
        uint256 tokensMinted
    );

    event onWithdraw(
        address indexed customerAddress,
        uint256 ethereumWithdrawn
    );

    // ERC20
    event Transfer(
        address indexed from,
        address indexed to,
        uint256 tokens
    );


    /*=====================================
    =            CONFIGURABLES            =
    =====================================*/

    string public name = "BigBrainCoin";
    string public symbol = "BBC";
    uint8 constant public decimals = 18;

    /// @dev 10% dividends for token purchase
    uint8 constant internal entryFee_ = 10;

    /// @dev 10% dividends for token transfer
    uint8 constant internal transferFee_ = 10;

    /// @dev 15% dividends for token selling
    uint8 constant internal exitFee_ = 15;

    /// @dev 35% of entryFee_ (i.e. 7% dividends) is given to referrer
    uint8 constant internal refferalFee_ = 35;

    uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
    uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
    uint256 constant internal magnitude = 2 ** 64;

    /// @dev proof of stake (defaults at 50 tokens)
    uint256 public stakingRequirement = 50e18;


   /*=================================
    =            DATASETS            =
    ================================*/

    // amount of shares for each address (scaled number)
    mapping(address => uint256) internal tokenBalanceLedger_;
    mapping(address => uint256) internal referralBalance_;
    mapping(address => int256) internal payoutsTo_;
    uint256 internal tokenSupply_;
    uint256 internal profitPerShare_;


    /*=======================================
    =            PUBLIC FUNCTIONS           =
    =======================================*/

    /// @dev Converts all incoming ethereum to tokens for the caller, and passes down the referral addy (if any)
    function buy(address _referredBy) public payable returns (uint256) {
        purchaseTokens(msg.value, _referredBy);
    }

    /**
     * @dev Fallback function to handle ethereum that was send straight to the contract
     *  Unfortunately we cannot use a referral address this way.
     */
    function() payable public {
        purchaseTokens(msg.value, 0x0);
    }

    /// @dev Converts all of caller's dividends to tokens.
    function reinvest() onlyStronghands public {
        // fetch dividends
        uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code

        // pay out the dividends virtually
        address _customerAddress = msg.sender;
        payoutsTo_[_customerAddress] +=  (int256) (_dividends * magnitude);

        // retrieve ref. bonus
        _dividends += referralBalance_[_customerAddress];
        referralBalance_[_customerAddress] = 0;

        // dispatch a buy order with the virtualized "withdrawn dividends"
        uint256 _tokens = purchaseTokens(_dividends, 0x0);

        // fire event
        onReinvestment(_customerAddress, _dividends, _tokens);
    }

    /// @dev Alias of sell() and withdraw().
    function exit() public {
        // get token count for caller & sell them all
        address _customerAddress = msg.sender;
        uint256 _tokens = tokenBalanceLedger_[_customerAddress];
        if (_tokens > 0) sell(_tokens);

        // lambo delivery service
        withdraw();
    }

    /// @dev Withdraws all of the callers earnings.
    function withdraw() onlyStronghands public {
        // setup data
        address _customerAddress = msg.sender;
        uint256 _dividends = myDividends(false); // get ref. bonus later in the code

        // update dividend tracker
        payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);

        // add ref. bonus
        _dividends += referralBalance_[_customerAddress];
        referralBalance_[_customerAddress] = 0;

        // lambo delivery service
        _customerAddress.transfer(_dividends);

        // fire event
        onWithdraw(_customerAddress, _dividends);
    }

    /// @dev Liquifies tokens to ethereum.
    function sell(uint256 _amountOfTokens) onlyBagholders public {
        // setup data
        address _customerAddress = msg.sender;
        // russian hackers BTFO
        require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
        uint256 _tokens = _amountOfTokens;
        uint256 _ethereum = tokensToEthereum_(_tokens);
        uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
        uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);

        // burn the sold tokens
        tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
        tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);

        // update dividends tracker
        int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
        payoutsTo_[_customerAddress] -= _updatedPayouts;

        // dividing by zero is a bad idea
        if (tokenSupply_ > 0) {
            // update the amount of dividends per token
            profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
        }

        // fire event
        onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
    }


    /**
     * @dev Transfer tokens from the caller to a new holder.
     *  Remember, there's a 10% fee here as well.
     */
    function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
        // setup
        address _customerAddress = msg.sender;

        // make sure we have the requested tokens
        require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);

        // withdraw all outstanding dividends first
        if (myDividends(true) > 0) {
            withdraw();
        }

        // liquify 10% of the tokens that are transfered
        // these are dispersed to shareholders
        uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
        uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
        uint256 _dividends = tokensToEthereum_(_tokenFee);

        // burn the fee tokens
        tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);

        // exchange tokens
        tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
        tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);

        // update dividend trackers
        payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
        payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);

        // disperse dividends among holders
        profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);

        // fire event
        Transfer(_customerAddress, _toAddress, _taxedTokens);

        // ERC20
        return true;
    }


    /*=====================================
    =      HELPERS AND CALCULATORS        =
    =====================================*/

    /**
     * @dev Method to view the current Ethereum stored in the contract
     *  Example: totalEthereumBalance()
     */
    function totalEthereumBalance() public view returns (uint256) {
        return this.balance;
    }

    /// @dev Retrieve the total token supply.
    function totalSupply() public view returns (uint256) {
        return tokenSupply_;
    }

    /// @dev Retrieve the tokens owned by the caller.
    function myTokens() public view returns (uint256) {
        address _customerAddress = msg.sender;
        return balanceOf(_customerAddress);
    }

    /**
     * @dev Retrieve the dividends owned by the caller.
     *  If `_includeReferralBonus` is to to 1/true, the referral bonus will be included in the calculations.
     *  The reason for this, is that in the frontend, we will want to get the total divs (global + ref)
     *  But in the internal calculations, we want them separate.
     */
    function myDividends(bool _includeReferralBonus) public view returns (uint256) {
        address _customerAddress = msg.sender;
        return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
    }

    /// @dev Retrieve the token balance of any single address.
    function balanceOf(address _customerAddress) public view returns (uint256) {
        return tokenBalanceLedger_[_customerAddress];
    }

    /// @dev Retrieve the dividend balance of any single address.
    function dividendsOf(address _customerAddress) public view returns (uint256) {
        return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
    }

    /// @dev Return the sell price of 1 individual token.
    function sellPrice() public view returns (uint256) {
        // our calculation relies on the token supply, so we need supply. Doh.
        if (tokenSupply_ == 0) {
            return tokenPriceInitial_ - tokenPriceIncremental_;
        } else {
            uint256 _ethereum = tokensToEthereum_(1e18);
            uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
            uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);

            return _taxedEthereum;
        }
    }

    /// @dev Return the buy price of 1 individual token.
    function buyPrice() public view returns (uint256) {
        // our calculation relies on the token supply, so we need supply. Doh.
        if (tokenSupply_ == 0) {
            return tokenPriceInitial_ + tokenPriceIncremental_;
        } else {
            uint256 _ethereum = tokensToEthereum_(1e18);
            uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
            uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);

            return _taxedEthereum;
        }
    }

    /// @dev Function for the frontend to dynamically retrieve the price scaling of buy orders.
    function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
        uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
        uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
        uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);

        return _amountOfTokens;
    }

    /// @dev Function for the frontend to dynamically retrieve the price scaling of sell orders.
    function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
        require(_tokensToSell <= tokenSupply_);
        uint256 _ethereum = tokensToEthereum_(_tokensToSell);
        uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
        uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
        return _taxedEthereum;
    }


    /*==========================================
    =            INTERNAL FUNCTIONS            =
    ==========================================*/

    /// @dev Internal function to actually purchase the tokens.
    function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
        // data setup
        address _customerAddress = msg.sender;
        uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
        uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
        uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
        uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
        uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
        uint256 _fee = _dividends * magnitude;

        // no point in continuing execution if OP is a poorfag russian hacker
        // prevents overflow in the case that the pyramid somehow magically starts being used by everyone in the world
        // (or hackers)
        // and yes we know that the safemath function automatically rules out the "greater then" equasion.
        require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);

        // is the user referred by a masternode?
        if (
            // is this a referred purchase?
            _referredBy != 0x0000000000000000000000000000000000000000 &&

            // no cheating!
            _referredBy != _customerAddress &&

            // does the referrer have at least X whole tokens?
            // i.e is the referrer a godly chad masternode
            tokenBalanceLedger_[_referredBy] >= stakingRequirement
        ) {
            // wealth redistribution
            referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
        } else {
            // no ref purchase
            // add the referral bonus back to the global dividends cake
            _dividends = SafeMath.add(_dividends, _referralBonus);
            _fee = _dividends * magnitude;
        }

        // we can't give people infinite ethereum
        if (tokenSupply_ > 0) {
            // add tokens to the pool
            tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);

            // take the amount of dividends gained through this transaction, and allocates them evenly to each shareholder
            profitPerShare_ += (_dividends * magnitude / tokenSupply_);

            // calculate the amount of tokens the customer receives over his purchase
            _fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
        } else {
            // add tokens to the pool
            tokenSupply_ = _amountOfTokens;
        }

        // update circulating supply & the ledger address for the customer
        tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);

        // Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them;
        // really i know you think you do but you don't
        int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
        payoutsTo_[_customerAddress] += _updatedPayouts;

        // fire event
        onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());

        return _amountOfTokens;
    }

    /**
     * @dev Calculate Token price based on an amount of incoming ethereum
     *  It's an algorithm, hopefully we gave you the whitepaper with it in scientific notation;
     *  Some conversions occurred to prevent decimal errors or underflows / overflows in solidity code.
     */
    function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
        uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
        uint256 _tokensReceived =
         (
            (
                // underflow attempts BTFO
                SafeMath.sub(
                    (sqrt
                        (
                            (_tokenPriceInitial ** 2)
                            +
                            (2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
                            +
                            ((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
                            +
                            (2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_)
                        )
                    ), _tokenPriceInitial
                )
            ) / (tokenPriceIncremental_)
        ) - (tokenSupply_);

        return _tokensReceived;
    }

    /**
     * @dev Calculate token sell value.
     *  It's an algorithm, hopefully we gave you the whitepaper with it in scientific notation;
     *  Some conversions occurred to prevent decimal errors or underflows / overflows in solidity code.
     */
    function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
        uint256 tokens_ = (_tokens + 1e18);
        uint256 _tokenSupply = (tokenSupply_ + 1e18);
        uint256 _etherReceived =
        (
            // underflow attempts BTFO
            SafeMath.sub(
                (
                    (
                        (
                            tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))
                        ) - tokenPriceIncremental_
                    ) * (tokens_ - 1e18)
                ), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2
            )
        / 1e18);

        return _etherReceived;
    }

    /// @dev This is where all your gas goes.
    function sqrt(uint256 x) internal pure returns (uint256 y) {
        uint256 z = (x + 1) / 2;
        y = x;

        while (z < y) {
            y = z;
            z = (x / z + z) / 2;
        }
    }


}

/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
library SafeMath {

    /**
    * @dev Multiplies two numbers, throws on overflow.
    */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }
        uint256 c = a * b;
        assert(c / a == b);
        return c;
    }

    /**
    * @dev Integer division of two numbers, truncating the quotient.
    */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        // assert(b > 0); // Solidity automatically throws when dividing by 0
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold
        return c;
    }

    /**
    * @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
    */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        assert(b <= a);
        return a - b;
    }

    /**
    * @dev Adds two numbers, throws on overflow.
    */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        assert(c >= a);
        return c;
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"constant":true,"inputs":[{"name":"_customerAddress","type":"address"}],"name":"dividendsOf","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"name","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_ethereumToSpend","type":"uint256"}],"name":"calculateTokensReceived","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_tokensToSell","type":"uint256"}],"name":"calculateEthereumReceived","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"withdraw","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"sellPrice","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"stakingRequirement","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_includeReferralBonus","type":"bool"}],"name":"myDividends","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalEthereumBalance","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_customerAddress","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"buyPrice","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"myTokens","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_toAddress","type":"address"},{"name":"_amountOfTokens","type":"uint256"}],"name":"transfer","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_amountOfTokens","type":"uint256"}],"name":"sell","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"exit","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_referredBy","type":"address"}],"name":"buy","outputs":[{"name":"","type":"uint256"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[],"name":"reinvest","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"anonymous":false,"inputs":[{"indexed":true,"name":"customerAddress","type":"address"},{"indexed":false,"name":"incomingEthereum","type":"uint256"},{"indexed":false,"name":"tokensMinted","type":"uint256"},{"indexed":true,"name":"referredBy","type":"address"},{"indexed":false,"name":"timestamp","type":"uint256"},{"indexed":false,"name":"price","type":"uint256"}],"name":"onTokenPurchase","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"customerAddress","type":"address"},{"indexed":false,"name":"tokensBurned","type":"uint256"},{"indexed":false,"name":"ethereumEarned","type":"uint256"},{"indexed":false,"name":"timestamp","type":"uint256"},{"indexed":false,"name":"price","type":"uint256"}],"name":"onTokenSell","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"customerAddress","type":"address"},{"indexed":false,"name":"ethereumReinvested","type":"uint256"},{"indexed":false,"name":"tokensMinted","type":"uint256"}],"name":"onReinvestment","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"customerAddress","type":"address"},{"indexed":false,"name":"ethereumWithdrawn","type":"uint256"}],"name":"onWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"from","type":"address"},{"indexed":true,"name":"to","type":"address"},{"indexed":false,"name":"tokens","type":"uint256"}],"name":"Transfer","type":"event"}]

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

650:18367:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3988:30;4003:9;4014:3;3988:14;:30::i;:::-;;650:18367;10559:224;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2126:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;2126:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12073:372;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9329:91;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12551:395;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2203:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5218:620;;;;;;;;;;;;;;10850:526;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2902:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9998:276;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9174:100;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10346:138;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11442:526;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9483:151;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2168:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;2168:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7299:1597;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5890:1268;;;;;;;;;;;;;;;;;;;;;;;;;;4858:299;;;;;;;;;;;;;;3646:124;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4094:710;;;;;;;;;;;;;;13173:3343;13263:7;13306:24;13354:27;13456:22;13558:18;13639:22;13727:23;13797:12;16204:22;13333:10;13306:37;;13384:61;13397:42;13410:17;2330:2;13397:42;;:12;:42::i;:::-;13441:3;13384:12;:61::i;:::-;13354:91;;13481:66;13494:47;13507:19;2641:2;13494:47;;:12;:47::i;:::-;13543:3;13481:12;:66::i;:::-;13456:91;;13579:49;13592:19;13613:14;13579:12;:49::i;:::-;13558:70;;13664:52;13677:17;13696:19;13664:12;:52::i;:::-;13639:77;;13753:33;13771:14;13753:17;:33::i;:::-;13727:59;;2833:7;13812:10;:22;13797:37;;14205:1;14187:15;:19;:81;;;;;14256:12;;14210:43;14223:15;14240:12;;14210;:43::i;:::-;:58;14187:81;14179:90;;;;;;;;14410:42;14395:57;;:11;:57;;;;:136;;;;;14515:16;14500:31;;:11;:31;;;;14395:136;:333;;;;;14710:18;;14674:19;:32;14694:11;14674:32;;;;;;;;;;;;;;;;:54;;14395:333;14332:799;;;14825:59;14838:16;:29;14855:11;14838:29;;;;;;;;;;;;;;;;14869:14;14825:12;:59::i;:::-;14793:16;:29;14810:11;14793:29;;;;;;;;;;;;;;;:91;;;;14332:799;;;15035:40;15048:10;15060:14;15035:12;:40::i;:::-;15022:53;;2833:7;15097:10;:22;15090:29;;14332:799;15213:1;15198:12;;:16;15194:633;;;15285:43;15298:12;;15312:15;15285:12;:43::i;:::-;15270:12;:58;;;;15514:12;;2833:7;15489:10;:22;:37;;;;;;;;15469:15;;:58;;;;;;;;;;;15698:12;;2833:7;15673:10;:22;:37;;;;;;;;15654:15;:57;15646:4;:66;15638:4;:75;15631:82;;15194:633;;;15800:15;15785:12;:30;;;;15194:633;15955:68;15968:19;:37;15988:16;15968:37;;;;;;;;;;;;;;;;16007:15;15955:12;:68::i;:::-;15915:19;:37;15935:16;15915:37;;;;;;;;;;;;;;;:108;;;;16275:4;16257:15;16239;;:33;:40;16204:76;;16323:15;16291:10;:28;16302:16;16291:28;;;;;;;;;;;;;;;;:47;;;;;;;;;;;16444:11;16374:99;;16390:16;16374:99;;;16408:17;16427:15;16457:3;16462:10;:8;:10::i;:::-;16374:99;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16493:15;16486:22;;13173:3343;;;;;;;;;;;;:::o;10559:224::-;10627:7;2833;10734:10;:28;10745:16;10734:28;;;;;;;;;;;;;;;;10693:19;:37;10713:16;10693:37;;;;;;;;;;;;;;;;10675:15;;:55;10665:97;10654:121;;;;;;;;10647:128;;10559:224;;;:::o;2126:35::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;12073:372::-;12153:7;12173:18;12265:22;12343:23;12194:60;12207:41;12220:16;2330:2;12207:41;;:12;:41::i;:::-;12250:3;12194:12;:60::i;:::-;12173:81;;12290:42;12303:16;12321:10;12290:12;:42::i;:::-;12265:67;;12369:33;12387:14;12369:17;:33::i;:::-;12343:59;;12422:15;12415:22;;12073:372;;;;;;:::o;9329:91::-;9373:7;9400:12;;9393:19;;9329:91;:::o;12551:395::-;12630:7;12699:17;12762:18;12846:22;12675:12;;12658:13;:29;;12650:38;;;;;;;;12719:32;12737:13;12719:17;:32::i;:::-;12699:52;;12783;12796:33;12809:9;2519:2;12796:33;;:12;:33::i;:::-;12831:3;12783:12;:52::i;:::-;12762:73;;12871:35;12884:9;12895:10;12871:12;:35::i;:::-;12846:60;;12924:14;12917:21;;12551:395;;;;;;:::o;2203:35::-;2236:2;2203:35;:::o;5218:620::-;5295:24;5343:18;1035:1;1015:17;1027:4;1015:11;:17::i;:::-;:21;1007:30;;;;;;;;5322:10;5295:37;;5364:18;5376:5;5364:11;:18::i;:::-;5343:39;;2833:7;5509:10;:22;5467:10;:28;5478:16;5467:28;;;;;;;;;;;;;;;;:65;;;;;;;;;;;5586:16;:34;5603:16;5586:34;;;;;;;;;;;;;;;;5572:48;;;;5668:1;5631:16;:34;5648:16;5631:34;;;;;;;;;;;;;;;:38;;;;5717:16;:25;;:37;5743:10;5717:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5801:16;5790:40;;;5819:10;5790:40;;;;;;;;;;;;;;;;;;5218:620;;:::o;10850:526::-;10892:7;11113:17;11171:18;11259:22;11012:1;10996:12;;:17;10992:377;;;2772:16;2699:15;11037:43;11030:50;;;;10992:377;11133:23;11151:4;11133:17;:23::i;:::-;11113:43;;11192:52;11205:33;11218:9;2519:2;11205:33;;:12;:33::i;:::-;11240:3;11192:12;:52::i;:::-;11171:73;;11284:35;11297:9;11308:10;11284:12;:35::i;:::-;11259:60;;11343:14;11336:21;;10850:526;;;;;:::o;2902:41::-;;;;:::o;9998:276::-;10068:7;10088:24;10115:10;10088:37;;10143:21;:122;;10236:29;10248:16;10236:11;:29::i;:::-;10143:122;;;10199:16;:34;10216:16;10199:34;;;;;;;;;;;;;;;;10167:29;10179:16;10167:11;:29::i;:::-;:66;10143:122;10136:129;;9998:276;;;;:::o;9174:100::-;9227:7;9254:4;:12;;;9247:19;;9174:100;:::o;10346:138::-;10412:7;10439:19;:37;10459:16;10439:37;;;;;;;;;;;;;;;;10432:44;;10346:138;;;:::o;11442:526::-;11483:7;11704:17;11762:18;11851:22;11603:1;11587:12;;:17;11583:378;;;2772:16;2699:15;11628:43;11621:50;;;;11583:378;11724:23;11742:4;11724:17;:23::i;:::-;11704:43;;11783:53;11796:34;11809:9;2330:2;11796:34;;:12;:34::i;:::-;11832:3;11783:12;:53::i;:::-;11762:74;;11876:35;11889:9;11900:10;11876:12;:35::i;:::-;11851:60;;11935:14;11928:21;;11442:526;;;;;:::o;9483:151::-;9524:7;9544:24;9571:10;9544:37;;9599:27;9609:16;9599:9;:27::i;:::-;9592:34;;9483:151;;:::o;2168:28::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;7299:1597::-;7393:4;7428:24;7842:17;7935:20;8009:18;902:1;889:10;:8;:10::i;:::-;:14;881:23;;;;;;;;7455:10;7428:37;;7556:19;:37;7576:16;7556:37;;;;;;;;;;;;;;;;7537:15;:56;;7529:65;;;;;;;;7684:1;7664:17;7676:4;7664:11;:17::i;:::-;:21;7660:64;;;7702:10;:8;:10::i;:::-;7660:64;7862:62;7875:43;7888:15;2427:2;7875:43;;:12;:43::i;:::-;7920:3;7862:12;:62::i;:::-;7842:82;;7958:40;7971:15;7988:9;7958:12;:40::i;:::-;7935:63;;8030:28;8048:9;8030:17;:28::i;:::-;8009:49;;8118:37;8131:12;;8145:9;8118:12;:37::i;:::-;8103:12;:52;;;;8236:68;8249:19;:37;8269:16;8249:37;;;;;;;;;;;;;;;;8288:15;8236:12;:68::i;:::-;8196:19;:37;8216:16;8196:37;;;;;;;;;;;;;;;:108;;;;8349:59;8362:19;:31;8382:10;8362:31;;;;;;;;;;;;;;;;8395:12;8349;:59::i;:::-;8315:19;:31;8335:10;8315:31;;;;;;;;;;;;;;;:93;;;;8518:15;8500;;:33;8458:10;:28;8469:16;8458:28;;;;;;;;;;;;;;;;:76;;;;;;;;;;;8599:12;8581:15;;:30;8545:10;:22;8556:10;8545:22;;;;;;;;;;;;;;;;:67;;;;;;;;;;;8688:70;8701:15;;8745:12;;2833:7;8719:10;:22;8718:39;;;;;;;;8688:12;:70::i;:::-;8670:15;:88;;;;8821:10;8794:52;;8803:16;8794:52;;;8833:12;8794:52;;;;;;;;;;;;;;;;;;8884:4;8877:11;;7299:1597;;;;;;;;:::o;5890:1268::-;5985:24;6142:15;6186:17;6243:18;6327:22;6644;902:1;889:10;:8;:10::i;:::-;:14;881:23;;;;;;;;6012:10;5985:37;;6093:19;:37;6113:16;6093:37;;;;;;;;;;;;;;;;6074:15;:56;;6066:65;;;;;;;;6160:15;6142:33;;6206:26;6224:7;6206:17;:26::i;:::-;6186:46;;6264:52;6277:33;6290:9;2519:2;6277:33;;:12;:33::i;:::-;6312:3;6264:12;:52::i;:::-;6243:73;;6352:35;6365:9;6376:10;6352:12;:35::i;:::-;6327:60;;6448:35;6461:12;;6475:7;6448:12;:35::i;:::-;6433:12;:50;;;;6534:60;6547:19;:37;6567:16;6547:37;;;;;;;;;;;;;;;;6586:7;6534:12;:60::i;:::-;6494:19;:37;6514:16;6494:37;;;;;;;;;;;;;;;:100;;;;2833:7;6708:14;:26;6697:7;6679:15;;:25;:56;6644:92;;6779:15;6747:10;:28;6758:16;6747:28;;;;;;;;;;;;;;;;:47;;;;;;;;;;;6869:1;6854:12;;:16;6850:194;;;6962:70;6975:15;;7019:12;;2833:7;6993:10;:22;6992:39;;;;;;;;6962:12;:70::i;:::-;6944:15;:88;;;;6850:194;7091:16;7079:71;;;7109:7;7118:14;7134:3;7139:10;:8;:10::i;:::-;7079:71;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5890:1268;;;;;;;:::o;4858:299::-;4947:24;4995:15;4974:10;4947:37;;5013:19;:37;5033:16;5013:37;;;;;;;;;;;;;;;;4995:55;;5075:1;5065:7;:11;5061:30;;;5078:13;5083:7;5078:4;:13::i;:::-;5061:30;5139:10;:8;:10::i;:::-;4858:299;;:::o;3646:124::-;3704:7;3724:38;3739:9;3750:11;3724:14;:38::i;:::-;;3646:124;;;:::o;4094:710::-;4176:18;4313:24;4658:15;1035:1;1015:17;1027:4;1015:11;:17::i;:::-;:21;1007:30;;;;;;;;4197:18;4209:5;4197:11;:18::i;:::-;4176:39;;4340:10;4313:37;;2833:7;4404:10;:22;4361:10;:28;4372:16;4361:28;;;;;;;;;;;;;;;;:66;;;;;;;;;;;4486:16;:34;4503:16;4486:34;;;;;;;;;;;;;;;;4472:48;;;;4568:1;4531:16;:34;4548:16;4531:34;;;;;;;;;;;;;;;:38;;;;4676:31;4691:10;4703:3;4676:14;:31::i;:::-;4658:49;;4758:16;4743:53;;;4776:10;4788:7;4743:53;;;;;;;;;;;;;;;;;;;;;;;;4094:710;;;:::o;19214:208::-;19272:7;19349:9;19301:1;19296;:6;19292:47;;;19326:1;19319:8;;;;19292:47;19365:1;19361;:5;19349:17;;19393:1;19388;19384;:5;;;;;;;;:10;19377:18;;;;;;19413:1;19406:8;;19214:208;;;;;;:::o;19517:288::-;19575:7;19674:9;19690:1;19686;:5;;;;;;;;19674:17;;19796:1;19789:8;;19517:288;;;;;:::o;19931:123::-;19989:7;20021:1;20016;:6;;20009:14;;;;;;20045:1;20041;:5;20034:12;;19931:123;;;;:::o;16819:948::-;16888:7;16908:26;16973:23;16958:4;2699:15;16937:25;16908:54;;17711:12;;2772:16;17087:567;17123:469;17552:12;;17533:18;2772:16;17504:1;:26;:47;:60;17439:1;17423:12;;:17;17417:1;2772:16;17391:27;17390:51;17322:4;17310:9;:16;17301:4;2772:16;17276:29;17271:1;:35;:56;17207:1;17185:18;:23;17184:144;:258;:381;17123:4;:469::i;:::-;17617:18;17087:12;:567::i;:::-;17024:672;;;;;;;;17009:715;16973:751;;17744:15;17737:22;;16819:948;;;;;:::o;20129:147::-;20187:7;20207:9;20223:1;20219;:5;20207:17;;20247:1;20242;:6;;20235:14;;;;;;20267:1;20260:8;;20129:147;;;;;:::o;18036:710::-;18103:7;18123:15;18168:20;18223:22;18152:4;18142:7;:14;18123:34;;18207:4;18192:12;;:19;18168:44;;18699:4;18312:375;18582:4;18572:7;:14;2772:16;18487:4;18472:12;:19;;;;;;;;2772:16;18446:46;2699:15;18424:69;18393:152;18366:221;18671:1;18662:4;18651:7;18647:1;18636:7;:12;:22;18635:31;;;;;;;;2772:16;18609:58;18608:64;;;;;;;;18312:12;:375::i;:::-;:391;;;;;;;;18223:481;;18724:14;18717:21;;18036:710;;;;;;:::o;18801:209::-;18849:9;18871;18893:1;18888;18884;:5;18883:11;;;;;;;;18871:23;;18909:1;18905:5;;18923:80;18934:1;18930;:5;18923:80;;;18956:1;18952:5;;18990:1;18985;18981;18977;:5;;;;;;;;:9;18976:15;;;;;;;;18972:19;;18923:80;;;18801:209;;;;:::o

bzzr://bbf6b11a2ccf6b95a3a75b58fbb0f112000f31fcf76e77b89acd12deff2250fe