constructors[_index];
            return;
        }

        if (mc.passed == false && mc.timeSince < block.number) {
             mc.passed = true;
             numMC = numMC.add(1);
             emit MCAdded(mc.playerAddress);
             return;
        }
    }

    
    function updateWeiAmountShare()
        public {
        if (numMC == 0) {
            return;
        }
        if (nextShareTime < block.number) {
            weiAmountShare = address(this).balance.div(numMC);

            
            uint256 timeGap = block.number.sub(nextShareTime);
            uint256 gap = timeGap.div(shareTimeGap).add(1);
            nextShareTime = nextShareTime.add(shareTimeGap.mul(gap));
        }
    }

    
    function claimShare(uint256 _index)
        public {

        
        updateMCs();

        MC storage mc = constructors[_index];

        
        if (mc.playerAddress == 0) {
            return;
        }

        if (mc.passed == false) {
            return;
        }

        if (mc.nextSharedSentTime < block.number) {
            
            updateWeiAmountShare();
            mc.nextSharedSentTime = nextShareTime;
            
            mc.playerAddress.transfer(weiAmountShare);
            emit ShareSent(mc.playerAddress, weiAmountShare);
        }
    }

    
    function upgradeEvilMorty(address _address)
        external
        onlyOwner {

        uint256 codeLength;

        assembly {
            codeLength := extcodesize(_address)
        }

        if (codeLength == 0) {
            return;
        }

        EvilMortyInstance = EvilMortyTokenInterface(_address);
    }

    
    function updateValidMCAmount(uint256 _amount)
        external
        onlyOwner {
        emit SystemChangeValidMCAmount(validMCAmount, _amount);
        validMCAmount = _amount;
    }

    
    function updateMaxNumMC(uint256 _num)
        external
        onlyOwner {
        emit SystemChangeMaxNumMC(maxNumMC, _num);
        maxNumMC = _num;
    }

    
    function updateShareTimeGap(uint256 _height)
        external
        onlyOwner {
        emit SystemChangeShareTimeGap(shareTimeGap, _height);
        shareTimeGap = _height;
    }

    
    function updateVettingTime(uint256 _height)
        external
        onlyOwner {
        emit SystemChangeVettingTime(vettingTime, _height);
        vettingTime = _height;
    }
}