Cryo Explorer Ethereum Mainnet

pragma solidity ^0.4.24;


library NameFilter {
    /**
     * @dev filters name strings
     * -converts uppercase to lower case.
     * -makes sure it does not start/end with a space
     * -makes sure it does not contain multiple spaces in a row
     * -cannot be only numbers
     * -cannot start with 0x
     * -restricts characters to A-Z, a-z, 0-9, and space.
     * @return reprocessed string in bytes32 format
     */
    function nameFilter(string _input)
        internal
        pure
        returns(bytes32)
    {
        bytes memory _temp = bytes(_input);
        uint256 _length = _temp.length;

        //sorry limited to 32 characters
        require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters");
        // make sure it doesnt start with or end with space
        require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space");
        // make sure first two characters are not 0x
        if (_temp[0] == 0x30)
        {
            require(_temp[1] != 0x78, "string cannot start with 0x");
            require(_temp[1] != 0x58, "string cannot start with 0X");
        }

        // create a bool to track if we have a non number character
        bool _hasNonNumber;

        // convert & check
        for (uint256 i = 0; i < _length; i++)
        {
            // if its uppercase A-Z
            if (_temp[i] > 0x40 && _temp[i] < 0x5b)
            {
                // convert to lower case a-z
                _temp[i] = byte(uint(_temp[i]) + 32);

                // we have a non number
                if (_hasNonNumber == false)
                    _hasNonNumber = true;
            } else {
                require
                (
                    // require character is a space
                    _temp[i] == 0x20 ||
                    // OR lowercase a-z
                    (_temp[i] > 0x60 && _temp[i] < 0x7b) ||
                    // or 0-9
                    (_temp[i] > 0x2f && _temp[i] < 0x3a),
                    "string contains invalid characters"
                );
                // make sure theres not 2x spaces in a row
                if (_temp[i] == 0x20)
                    require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces");

                // see if we have a character other than a number
                if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39))
                    _hasNonNumber = true;
            }
        }

        require(_hasNonNumber == true, "string cannot be only numbers");

        bytes32 _ret;
        assembly {
            _ret := mload(add(_temp, 32))
        }
        return (_ret);
    }
}

/**
 * @title SafeMath v0.1.9
 * @dev Math operations with safety checks that throw on error
 * change notes:  original SafeMath library from OpenZeppelin modified by Inventor
 * - added sqrt
 * - added sq
 * - added pwr
 * - changed asserts to requires with error log outputs
 * - removed div, its useless
 */
library SafeMath {

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

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

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

    /**
     * @dev gives square root of given x.
     */
    function sqrt(uint256 x)
        internal
        pure
        returns (uint256 y)
    {
        uint256 z = ((add(x,1)) / 2);
        y = x;
        while (z < y)
        {
            y = z;
            z = ((add((x / z),z)) / 2);
        }
    }

    /**
     * @dev gives square. multiplies x by x
     */
    function sq(uint256 x)
        internal
        pure
        returns (uint256)
    {
        return (mul(x,x));
    }

    /**
     * @dev x to the power of y
     */
    function pwr(uint256 x, uint256 y)
        internal
        pure
        returns (uint256)
    {
        if (x==0)
            return (0);
        else if (y==0)
            return (1);
        else
        {
            uint256 z = x;
            for (uint256 i=1; i < y; i++)
                z = mul(z,x);
            return (z);
        }
    }
}



//==============================================================================
//   __|_ _    __|_ _  .
//  _\ | | |_|(_ | _\  .
//==============================================================================
library F3Ddatasets {
    //compressedData key
    // [76-33][32][31][30][29][28-18][17][16-6][5-3][2][1][0]
        // 0 - new player (bool)
        // 1 - joined round (bool)
        // 2 - new  leader (bool)
        // 3-5 - air drop tracker (uint 0-999)
        // 6-16 - round end time
        // 17 - winnerTeam
        // 18 - 28 timestamp
        // 29 - team
        // 30 - 0 = reinvest (round), 1 = buy (round), 2 = buy (ico), 3 = reinvest (ico)
        // 31 - airdrop happened bool
        // 32 - airdrop tier
        // 33 - airdrop amount won
    //compressedIDs key
    // [77-52][51-26][25-0]
        // 0-25 - pID
        // 26-51 - winPID
        // 52-77 - rID
    struct EventReturns {
        uint256 compressedData;
        uint256 compressedIDs;
        address winnerAddr;         // winner address
        bytes32 winnerName;         // winner name
        uint256 amountWon;          // amount won
        uint256 newPot;             // amount in new pot
        uint256 P3DAmount;          // amount distributed to p3d
        uint256 genAmount;          // amount distributed to gen
        uint256 potAmount;          // amount added to pot
    }
    struct Player {
        address addr;   // player address
        bytes32 name;   // player name
        uint256 win;    // winnings vault
        uint256 gen;    // general vault
        uint256 aff;    // affiliate vault
        uint256 lrnd;   // last round played
        uint256 laff;   // last affiliate id used
    }
    struct PlayerRounds {
        uint256 eth;    // eth player has added to round (used for eth limiter)
        uint256 keys;   // keys
        uint256 mask;   // player mask
        uint256 ico;    // ICO phase investment
    }
    struct Round {
        uint256 plyr;   // pID of player in lead
        uint256 team;   // tID of team in lead
        uint256 end;    // time ends/ended
        bool ended;     // has round end function been ran
        uint256 strt;   // time round started
        uint256 keys;   // keys
        uint256 eth;    // total eth in
        uint256 pot;    // eth to pot (during round) / final amount paid to winner (after round ends)
        uint256 mask;   // global mask
        uint256 ico;    // total eth sent in during ICO phase
        uint256 icoGen; // total eth for gen during ICO phase
        uint256 icoAvg; // average key price for ICO phase
    }
    struct TeamFee {
        uint256 gen;    // % of buy in thats paid to key holders of current round
        uint256 p3d;    // % of buy in thats paid to p3d holders
    }
    struct PotSplit {
        uint256 gen;    // % of pot thats paid to key holders of current round
        uint256 p3d;    // % of pot thats paid to p3d holders
    }
}

//==============================================================================
//  |  _      _ _ | _  .
//  |<(/_\/  (_(_||(_  .
//=======/======================================================================
library F3DKeysCalcShort {
    using SafeMath for *;
    /**
     * @dev calculates number of keys received given X eth
     * @param _curEth current amount of eth in contract
     * @param _newEth eth being spent
     * @return amount of ticket purchased
     */
    function keysRec(uint256 _curEth, uint256 _newEth)
        internal
        pure
        returns (uint256)
    {
        return(keys((_curEth).add(_newEth)).sub(keys(_curEth)));
    }

    /**
     * @dev calculates amount of eth received if you sold X keys
     * @param _curKeys current amount of keys that exist
     * @param _sellKeys amount of keys you wish to sell
     * @return amount of eth received
     */
    function ethRec(uint256 _curKeys, uint256 _sellKeys)
        internal
        pure
        returns (uint256)
    {
        return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
    }

    /**
     * @dev calculates how many keys would exist with given an amount of eth
     * @param _eth eth "in contract"
     * @return number of keys that would exist
     */
    function keys(uint256 _eth)
        internal
        pure
        returns(uint256)
    {
        return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000);
    }

    /**
     * @dev calculates how much eth would be in contract given a number of keys
     * @param _keys number of keys "in contract"
     * @return eth that would exists
     */
    function eth(uint256 _keys)
        internal
        pure
        returns(uint256)
    {
        return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq());
    }
}

//==============================================================================
//  . _ _|_ _  _ |` _  _ _  _  .
//  || | | (/_| ~|~(_|(_(/__\  .
//==============================================================================


contract F3Devents {
    // fired whenever a player registers a name
    event onNewName
    (
        uint256 indexed playerID,
        address indexed playerAddress,
        bytes32 indexed playerName,
        bool isNewPlayer,
        uint256 affiliateID,
        address affiliateAddress,
        bytes32 affiliateName,
        uint256 amountPaid,
        uint256 timeStamp
    );

    // fired at end of buy or reload
    event onEndTx
    (
        uint256 compressedData,
        uint256 compressedIDs,
        bytes32 playerName,
        address playerAddress,
        uint256 ethIn,
        uint256 keysBought,
        address winnerAddr,
        bytes32 winnerName,
        uint256 amountWon,
        uint256 newPot,
        uint256 P3DAmount,
        uint256 genAmount,
        uint256 potAmount,
        uint256 airDropPot
    );

	// fired whenever theres a withdraw
    event onWithdraw
    (
        uint256 indexed playerID,
        address playerAddress,
        bytes32 playerName,
        uint256 ethOut,
        uint256 timeStamp
    );

    // fired whenever a withdraw forces end round to be ran
    event onWithdrawAndDistribute
    (
        address playerAddress,
        bytes32 playerName,
        uint256 ethOut,
        uint256 compressedData,
        uint256 compressedIDs,
        address winnerAddr,
        bytes32 winnerName,
        uint256 amountWon,
        uint256 newPot,
        uint256 P3DAmount,
        uint256 genAmount
    );

    // (fomo3d short only) fired whenever a player tries a buy after round timer
    // hit zero, and causes end round to be ran.
    event onBuyAndDistribute
    (
        address playerAddress,
        bytes32 playerName,
        uint256 ethIn,
        uint256 compressedData,
        uint256 compressedIDs,
        address winnerAddr,
        bytes32 winnerName,
        uint256 amountWon,
        uint256 newPot,
        uint256 P3DAmount,
        uint256 genAmount
    );

    // (fomo3d short only) fired whenever a player tries a reload after round timer
    // hit zero, and causes end round to be ran.
    event onReLoadAndDistribute
    (
        address playerAddress,
        bytes32 playerName,
        uint256 compressedData,
        uint256 compressedIDs,
        address winnerAddr,
        bytes32 winnerName,
        uint256 amountWon,
        uint256 newPot,
        uint256 P3DAmount,
        uint256 genAmount
    );

    // fired whenever an affiliate is paid
    event onAffiliatePayout
    (
        uint256 indexed affiliateID,
        address affiliateAddress,
        bytes32 affiliateName,
        uint256 indexed roundID,
        uint256 indexed buyerID,
        uint256 amount,
        uint256 timeStamp
    );

    // received pot swap deposit
    event onPotSwapDeposit
    (
        uint256 roundID,
        uint256 amountAddedToPot
    );
}


interface PlayerBookInterface {
    function getPlayerID(address _addr) external returns (uint256);
    function getPlayerName(uint256 _pID) external view returns (bytes32);
    function getPlayerLAff(uint256 _pID) external view returns (uint256);
    function getPlayerAddr(uint256 _pID) external view returns (address);
    function getNameFee() external view returns (uint256);
    function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256);
    function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256);
    function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256);
}



contract modularFast is F3Devents {}


contract FoMo3DFast is modularFast {
    using SafeMath for *;
    using NameFilter for string;
    using F3DKeysCalcShort for uint256;

    PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0x1c52efF9C47fE419E3b269f5759d98d2072cC91A);

    address private admin = msg.sender;
    string constant public name = "FOMO Fast";
    string constant public symbol = "FAST";
    uint256 private rndExtra_ = 1 minutes;     // length of the very first ICO
    uint256 private rndGap_ = 2 minutes;         // length of ICO phase, set to 1 year for EOS.
    uint256 constant private rndInit_ = 3 minutes;                // round timer starts at this
    uint256 constant private rndInc_ = 10 seconds;              // every full key purchased adds this much to the timer
    uint256 constant private rndMax_ = 5 minutes;                // max length a round timer can be
    uint256 public airDropPot_;             // person who gets the airdrop wins part of this pot
    uint256 public airDropTracker_ = 0;     // incremented each time a "qualified" tx occurs.  used to determine winning air drop
    uint256 public rID_;    // round id number / total rounds that have happened
  //****************
  // PLAYER DATA
  //****************
    mapping (address => uint256) public pIDxAddr_;          // (addr => pID) returns player id by address
    mapping (bytes32 => uint256) public pIDxName_;          // (name => pID) returns player id by name
    mapping (uint256 => F3Ddatasets.Player) public plyr_;   // (pID => data) player data
    // (pID => rID => data) player round data by player id & round id
    mapping (uint256 => mapping (uint256 => F3Ddatasets.PlayerRounds)) public plyrRnds_;
    mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_; // (pID => name => bool) list of names a player owns.  (used so you can change your display name amongst any name you own)
  //****************
  // ROUND DATA
  //****************
    mapping (uint256 => F3Ddatasets.Round) public round_;   // (rID => data) round data
    mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;      // (rID => tID => data) eth in per team, by round id and team id
  //****************
  // TEAM FEE DATA
  //****************
    mapping (uint256 => F3Ddatasets.TeamFee) public fees_;          // (team => fees) fee distribution by team
    mapping (uint256 => F3Ddatasets.PotSplit) public potSplit_;     // (team => fees) pot split distribution by team

    constructor()
        public
    {
    // Team allocation structures
        // 0 = whales
        // 1 = bears
        // 2 = sneks
        // 3 = bulls

    // Team allocation percentages
        // (F3D, P3D) + (Pot , Referrals, Community)  解读:TeamFee, PotSplit 第一个参数都是分给现在key holder的比例, 第二个是给Pow3D的比例
            // Referrals / Community rewards are mathematically designed to come from the winner's share of the pot.
        fees_[0] = F3Ddatasets.TeamFee(30,6);   //50% to pot, 10% to aff, 2% to com, 1% to pot swap, 1% to air drop pot
        fees_[1] = F3Ddatasets.TeamFee(43,0);   //43% to pot, 10% to aff, 2% to com, 1% to pot swap, 1% to air drop pot
        fees_[2] = F3Ddatasets.TeamFee(56,10);  //20% to pot, 10% to aff, 2% to com, 1% to pot swap, 1% to air drop pot
        fees_[3] = F3Ddatasets.TeamFee(43,8);   //35% to pot, 10% to aff, 2% to com, 1% to pot swap, 1% to air drop pot

        // how to split up the final pot based on which team was picked
        // (F3D, P3D)
        potSplit_[0] = F3Ddatasets.PotSplit(15,10);  //48% to winner, 25% to next round, 2% to com
        potSplit_[1] = F3Ddatasets.PotSplit(25,0);   //48% to winner, 25% to next round, 2% to com
        potSplit_[2] = F3Ddatasets.PotSplit(20,20);  //48% to winner, 10% to next round, 2% to com
        potSplit_[3] = F3Ddatasets.PotSplit(30,10);  //48% to winner, 10% to next round, 2% to com
  	}
  //==============================================================================
  //     _ _  _  _|. |`. _  _ _  .
  //    | | |(_)(_||~|~|(/_| _\  .  (these are safety checks)
  //==============================================================================
      /**
       * @dev used to make sure no one can interact with contract until it has
       * been activated.
       */
      modifier isActivated() {
          require(activated_ == true, "its not ready yet.  check ?eta in discord");
          _;
      }

      /**
       * @dev prevents contracts from interacting with fomo3d
       */
      modifier isHuman() {
          address _addr = msg.sender;
          uint256 _codeLength;

          assembly {_codeLength := extcodesize(_addr)}
          require(_codeLength == 0, "sorry humans only");
          _;
      }

      /**
       * @dev sets boundaries for incoming tx
       */
      modifier isWithinLimits(uint256 _eth) {
          require(_eth >= 1000000000, "pocket lint: not a valid currency");
          require(_eth <= 100000000000000000000000, "no vitalik, no");
          _;
      }

  //==============================================================================
  //     _    |_ |. _   |`    _  __|_. _  _  _  .
  //    |_)|_||_)||(_  ~|~|_|| |(_ | |(_)| |_\  .  (use these to interact with contract)
  //====|=========================================================================
      /**
       * @dev emergency buy uses last stored affiliate ID and team snek
       */
      function()
          isActivated()
          isHuman()
          isWithinLimits(msg.value)
          public
          payable
      {
          // set up our tx event data and determine if player is new or not
          F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);

          // fetch player id
          uint256 _pID = pIDxAddr_[msg.sender];

          // buy core
          buyCore(_pID, plyr_[_pID].laff, 2, _eventData_);
      }

      /**
       * @dev converts all incoming ethereum to keys.
       * -functionhash- 0x8f38f309 (using ID for affiliate)
       * -functionhash- 0x98a0871d (using address for affiliate)
       * -functionhash- 0xa65b37a1 (using name for affiliate)
       * @param _affCode the ID/address/name of the player who gets the affiliate fee
       * @param _team what team is the player playing for?
       */
      function buyXid(uint256 _affCode, uint256 _team)
          isActivated()
          isHuman()
          isWithinLimits(msg.value)
          public
          payable
      {
          // set up our tx event data and determine if player is new or not
          F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);

          // fetch player id
          uint256 _pID = pIDxAddr_[msg.sender];

          // manage affiliate residuals
          // if no affiliate code was given or player tried to use their own, lolz
          if (_affCode == 0 || _affCode == _pID)
          {
              // use last stored affiliate code
              _affCode = plyr_[_pID].laff;

          // if affiliate code was given & its not the same as previously stored
          } else if (_affCode != plyr_[_pID].laff) {
              // update last affiliate
              plyr_[_pID].laff = _affCode;
          }

          // verify a valid team was selected
          _team = verifyTeam(_team);

          // buy core
          buyCore(_pID, _affCode, _team, _eventData_);
      }

      function buyXaddr(address _affCode, uint256 _team)
          isActivated()
          isWithinLimits(msg.value)
          public
          payable
      {
          // set up our tx event data and determine if player is new or not
          F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);

          // fetch player id
          uint256 _pID = pIDxAddr_[msg.sender];

          // manage affiliate residuals
          uint256 _affID;
          // if no affiliate code was given or player tried to use their own, lolz
          if (_affCode == address(0) || _affCode == msg.sender)
          {
              // use last stored affiliate code
              _affID = plyr_[_pID].laff;

          // if affiliate code was given
          } else {
              // get affiliate ID from aff Code
              _affID = pIDxAddr_[_affCode];

              // if affID is not the same as previously stored
              if (_affID != plyr_[_pID].laff)
              {
                  // update last affiliate
                  plyr_[_pID].laff = _affID;
              }
          }

          // verify a valid team was selected
          _team = verifyTeam(_team);

          // buy core
          buyCore(_pID, _affID, _team, _eventData_);
      }

      function buyXname(bytes32 _affCode, uint256 _team)
          isActivated()
          isHuman()
          isWithinLimits(msg.value)
          public
          payable
      {
          // set up our tx event data and determine if player is new or not
          F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);

          // fetch player id
          uint256 _pID = pIDxAddr_[msg.sender];

          // manage affiliate residuals
          uint256 _affID;
          // if no affiliate code was given or player tried to use their own, lolz
          if (_affCode == '' || _affCode == plyr_[_pID].name)
          {
              // use last stored affiliate code
              _affID = plyr_[_pID].laff;

          // if affiliate code was given
          } else {
              // get affiliate ID from aff Code
              _affID = pIDxName_[_affCode];

              // if affID is not the same as previously stored
              if (_affID != plyr_[_pID].laff)
              {
                  // update last affiliate
                  plyr_[_pID].laff = _affID;
              }
          }

          // verify a valid team was selected
          _team = verifyTeam(_team);

          // buy core
          buyCore(_pID, _affID, _team, _eventData_);
      }


       function buyXnameQR(address _realSender,bytes32 _affCode, uint256 _team)
          isActivated()
          isWithinLimits(msg.value)
          public
          payable
      {
          // set up our tx event data and determine if player is new or not
          F3Ddatasets.EventReturns memory _eventData_ = determinePIDQR(_realSender,_eventData_);

          // fetch player id
          uint256 _pID = pIDxAddr_[_realSender];

          // manage affiliate residuals
          uint256 _affID;
          // if no affiliate code was given or player tried to use their own, lolz
          if (_affCode == '' || _affCode == plyr_[_pID].name)
          {
              // use last stored affiliate code
              _affID = plyr_[_pID].laff;

          // if affiliate code was given
          } else {
              // get affiliate ID from aff Code
              _affID = pIDxName_[_affCode];

              // if affID is not the same as previously stored
              if (_affID != plyr_[_pID].laff)
              {
                  // update last affiliate
                  plyr_[_pID].laff = _affID;
              }
          }

          // verify a valid team was selected
          _team = verifyTeam(_team);

          // buy core
          buyCoreQR(_realSender, _pID, _affID, _team, _eventData_);
      }

      /**
       * @dev essentially the same as buy, but instead of you sending ether
       * from your wallet, it uses your unwithdrawn earnings.
       * -functionhash- 0x349cdcac (using ID for affiliate)
       * -functionhash- 0x82bfc739 (using address for affiliate)
       * -functionhash- 0x079ce327 (using name for affiliate)
       * @param _affCode the ID/address/name of the player who gets the affiliate fee
       * @param _team what team is the player playing for?
       * @param _eth amount of earnings to use (remainder returned to gen vault)
       */
      function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth)
          isActivated()
          isHuman()
          isWithinLimits(_eth)
          public
      {
          // set up our tx event data
          F3Ddatasets.EventReturns memory _eventData_;

          // fetch player ID
          uint256 _pID = pIDxAddr_[msg.sender];

          // manage affiliate residuals
          // if no affiliate code was given or player tried to use their own, lolz
          if (_affCode == 0 || _affCode == _pID)
          {
              // use last stored affiliate code
              _affCode = plyr_[_pID].laff;

          // if affiliate code was given & its not the same as previously stored
          } else if (_affCode != plyr_[_pID].laff) {
              // update last affiliate
              plyr_[_pID].laff = _affCode;
          }

          // verify a valid team was selected
          _team = verifyTeam(_team);

          // reload core
          reLoadCore(_pID, _affCode, _team, _eth, _eventData_);
      }

      function reLoadXaddr(address _affCode, uint256 _team, uint256 _eth)
          isActivated()
          isHuman()
          isWithinLimits(_eth)
          public
      {
          // set up our tx event data
          F3Ddatasets.EventReturns memory _eventData_;

          // fetch player ID
          uint256 _pID = pIDxAddr_[msg.sender];

          // manage affiliate residuals
          uint256 _affID;
          // if no affiliate code was given or player tried to use their own, lolz
          if (_affCode == address(0) || _affCode == msg.sender)
          {
              // use last stored affiliate code
              _affID = plyr_[_pID].laff;

          // if affiliate code was given
          } else {
              // get affiliate ID from aff Code
              _affID = pIDxAddr_[_affCode];

              // if affID is not the same as previously stored
              if (_affID != plyr_[_pID].laff)
              {
                  // update last affiliate
                  plyr_[_pID].laff = _affID;
              }
          }

          // verify a valid team was selected
          _team = verifyTeam(_team);

          // reload core
          reLoadCore(_pID, _affID, _team, _eth, _eventData_);
      }

      function reLoadXname(bytes32 _affCode, uint256 _team, uint256 _eth)
          isActivated()
          isHuman()
          isWithinLimits(_eth)
          public
      {
          // set up our tx event data
          F3Ddatasets.EventReturns memory _eventData_;

          // fetch player ID
          uint256 _pID = pIDxAddr_[msg.sender];

          // manage affiliate residuals
          uint256 _affID;
          // if no affiliate code was given or player tried to use their own, lolz
          if (_affCode == '' || _affCode == plyr_[_pID].name)
          {
              // use last stored affiliate code
              _affID = plyr_[_pID].laff;

          // if affiliate code was given
          } else {
              // get affiliate ID from aff Code
              _affID = pIDxName_[_affCode];

              // if affID is not the same as previously stored
              if (_affID != plyr_[_pID].laff)
              {
                  // update last affiliate
                  plyr_[_pID].laff = _affID;
              }
          }

          // verify a valid team was selected
          _team = verifyTeam(_team);

          // reload core
          reLoadCore(_pID, _affID, _team, _eth, _eventData_);
      }

      /**
       * @dev withdraws all of your earnings.
       * -functionhash- 0x3ccfd60b
       */
      function withdraw()
          isActivated()
          isHuman()
          public
      {
          // setup local rID
          uint256 _rID = rID_;

          // grab time
          uint256 _now = now;

          // fetch player ID
          uint256 _pID = pIDxAddr_[msg.sender];

          // setup temp var for player eth
          uint256 _eth;

          // check to see if round has ended and no one has run round end yet
          if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
          {
              // set up our tx event data
              F3Ddatasets.EventReturns memory _eventData_;

              // end the round (distributes pot)
  			round_[_rID].ended = true;
              _eventData_ = endRound(_eventData_);

  			// get their earnings
              _eth = withdrawEarnings(_pID);

              // gib moni
              if (_eth > 0)
                  plyr_[_pID].addr.transfer(_eth);

              // build event data
              _eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
              _eventData_.compressedIDs = _eventData_.compressedIDs + _pID;

              // fire withdraw and distribute event
              emit F3Devents.onWithdrawAndDistribute
              (
                  msg.sender,
                  plyr_[_pID].name,
                  _eth,
                  _eventData_.compressedData,
                  _eventData_.compressedIDs,
                  _eventData_.winnerAddr,
                  _eventData_.winnerName,
                  _eventData_.amountWon,
                  _eventData_.newPot,
                  _eventData_.P3DAmount,
                  _eventData_.genAmount
              );

          // in any other situation
          } else {
              // get their earnings
              _eth = withdrawEarnings(_pID);

              // gib moni
              if (_eth > 0)
                  plyr_[_pID].addr.transfer(_eth);

              // fire withdraw event
              emit F3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
          }
      }

    /**
       * @dev withdraws all of your earnings.
       * -functionhash- 0x3ccfd60b
       */
      function withdrawQR(address _realSender)
          isActivated()
          payable
          public
      {
          // setup local rID
          uint256 _rID = rID_;

          // grab time
          uint256 _now = now;

          // fetch player ID
          uint256 _pID = pIDxAddr_[_realSender];

          // setup temp var for player eth
          uint256 _eth;

          // check to see if round has ended and no one has run round end yet
          if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
          {
              // set up our tx event data
              F3Ddatasets.EventReturns memory _eventData_;

              // end the round (distributes pot)
  			round_[_rID].ended = true;
              _eventData_ = endRound(_eventData_);

  			// get their earnings
              _eth = withdrawEarnings(_pID);

              // gib moni
              if (_eth > 0)
                  plyr_[_pID].addr.transfer(_eth);

              // build event data
              _eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
              _eventData_.compressedIDs = _eventData_.compressedIDs + _pID;

              // fire withdraw and distribute event
              emit F3Devents.onWithdrawAndDistribute
              (
                  _realSender,
                  plyr_[_pID].name,
                  _eth,
                  _eventData_.compressedData,
                  _eventData_.compressedIDs,
                  _eventData_.winnerAddr,
                  _eventData_.winnerName,
                  _eventData_.amountWon,
                  _eventData_.newPot,
                  _eventData_.P3DAmount,
                  _eventData_.genAmount
              );

          // in any other situation
          } else {
              // get their earnings
              _eth = withdrawEarnings(_pID);

              // gib moni
              if (_eth > 0)
                  plyr_[_pID].addr.transfer(_eth);

              // fire withdraw event
              emit F3Devents.onWithdraw(_pID, _realSender, plyr_[_pID].name, _eth, _now);
          }
      }

      /**
       * @dev use these to register names.  they are just wrappers that will send the
       * registration requests to the PlayerBook contract.  So registering here is the
       * same as registering there.  UI will always display the last name you registered.
       * but you will still own all previously registered names to use as affiliate
       * links.
       * - must pay a registration fee.
       * - name must be unique
       * - names will be converted to lowercase
       * - name cannot start or end with a space
       * - cannot have more than 1 space in a row
       * - cannot be only numbers
       * - cannot start with 0x
       * - name must be at least 1 char
       * - max length of 32 characters long
       * - allowed characters: a-z, 0-9, and space
       * -functionhash- 0x921dec21 (using ID for affiliate)
       * -functionhash- 0x3ddd4698 (using address for affiliate)
       * -functionhash- 0x685ffd83 (using name for affiliate)
       * @param _nameString players desired name
       * @param _affCode affiliate ID, address, or name of who referred you
       * @param _all set to true if you want this to push your info to all games
       * (this might cost a lot of gas)
       */

      function registerNameXID(string _nameString, uint256 _affCode, bool _all)
          isHuman()
          public
          payable
      {
          bytes32 _name = _nameString.nameFilter();
          address _addr = msg.sender;
          uint256 _paid = msg.value;
          (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all);

          uint256 _pID = pIDxAddr_[_addr];

          // fire event
          emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
      }

      function registerNameXaddr(string _nameString, address _affCode, bool _all)
          isHuman()
          public
          payable
      {
          bytes32 _name = _nameString.nameFilter();
          address _addr = msg.sender;
          uint256 _paid = msg.value;
          (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);

          uint256 _pID = pIDxAddr_[_addr];

          // fire event
          emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
      }

      function registerNameXname(string _nameString, bytes32 _affCode, bool _all)
          isHuman()
          public
          payable
      {
          bytes32 _name = _nameString.nameFilter();
          address _addr = msg.sender;
          uint256 _paid = msg.value;
          (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);

          uint256 _pID = pIDxAddr_[_addr];

          // fire event
          emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
      }


  //==============================================================================
  //     _  _ _|__|_ _  _ _  .
  //    (_|(/_ |  | (/_| _\  . (for UI & viewing things on etherscan)
  //=====_|=======================================================================
      /**
       * @dev return the price buyer will pay for next 1 individual key.
       * -functionhash- 0x018a25e8
       * @return price for next key bought (in wei format)
       */
      function getBuyPrice()
          public
          view
          returns(uint256)
      {
          // setup local rID
          uint256 _rID = rID_;

          // grab time
          uint256 _now = now;

          // are we in a round?
          if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
              return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) );
          else // rounds over.  need price for new round
              return ( 75000000000000 ); // init
      }

      /**
       * @dev returns time left.  dont spam this, you'll ddos yourself from your node
       * provider
       * -functionhash- 0xc7e284b8
       * @return time left in seconds
       */
      function getTimeLeft()
          public
          view
          returns(uint256)
      {
          // setup local rID
          uint256 _rID = rID_;

          // grab time
          uint256 _now = now;

          if (_now < round_[_rID].end)
              if (_now > round_[_rID].strt + rndGap_)
                  return( (round_[_rID].end).sub(_now) );
              else
                  return( (round_[_rID].strt + rndGap_).sub(_now) );
          else
              return(0);
      }

      /**
       * @dev returns player earnings per vaults
       * -functionhash- 0x63066434
       * @return winnings vault
       * @return general vault
       * @return affiliate vault
       */
      function getPlayerVaults(uint256 _pID)
          public
          view
          returns(uint256 ,uint256, uint256)
      {
          // setup local rID
          uint256 _rID = rID_;

          // if round has ended.  but round end has not been run (so contract has not distributed winnings)
          if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
          {
              // if player is winner
              if (round_[_rID].plyr == _pID)
              {
                  return
                  (
                      (plyr_[_pID].win).add( ((round_[_rID].pot).mul(48)) / 100 ),
                      (plyr_[_pID].gen).add(  getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask)   ),
                      plyr_[_pID].aff
                  );
              // if player is not the winner
              } else {
                  return
                  (
                      plyr_[_pID].win,
                      (plyr_[_pID].gen).add(  getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask)  ),
                      plyr_[_pID].aff
                  );
              }

          // if round is still going on, or round has ended and round end has been ran
          } else {
              return
              (
                  plyr_[_pID].win,
                  (plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
                  plyr_[_pID].aff
              );
          }
      }

      /**
       * solidity hates stack limits.  this lets us avoid that hate
       */
      function getPlayerVaultsHelper(uint256 _pID, uint256 _rID)
          private
          view
          returns(uint256)
      {
          return(  ((((round_[_rID].mask).add(((((round_[_rID].pot).mul(potSplit_[round_[_rID].team].gen)) / 100).mul(1000000000000000000)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1000000000000000000)  );
      }

      /**
       * @dev returns all current round info needed for front end
       * -functionhash- 0x747dff42
       * @return eth invested during ICO phase
       * @return round id
       * @return total keys for round
       * @return time round ends
       * @return time round started
       * @return current pot
       * @return current team ID & player ID in lead
       * @return current player in leads address
       * @return current player in leads name
       * @return whales eth in for round
       * @return bears eth in for round
       * @return sneks eth in for round
       * @return bulls eth in for round
       * @return airdrop tracker # & airdrop pot
       */
      function getCurrentRoundInfo()
          public
          view
          returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256, uint256)
      {
          // setup local rID
          uint256 _rID = rID_;

          return
          (
              round_[_rID].ico,               //0
              _rID,                           //1
              round_[_rID].keys,              //2
              round_[_rID].end,               //3
              round_[_rID].strt,              //4
              round_[_rID].pot,               //5
              (round_[_rID].team + (round_[_rID].plyr * 10)),     //6
              plyr_[round_[_rID].plyr].addr,  //7
              plyr_[round_[_rID].plyr].name,  //8
              rndTmEth_[_rID][0],             //9
              rndTmEth_[_rID][1],             //10
              rndTmEth_[_rID][2],             //11
              rndTmEth_[_rID][3],             //12
              airDropTracker_ + (airDropPot_ * 1000)              //13
          );
      }

      /**
       * @dev returns player info based on address.  if no address is given, it will
       * use msg.sender
       * -functionhash- 0xee0b5d8b
       * @param _addr address of the player you want to lookup
       * @return player ID
       * @return player name
       * @return keys owned (current round)
       * @return winnings vault
       * @return general vault
       * @return affiliate vault
  	 * @return player round eth
       */
      function getPlayerInfoByAddress(address _addr)
          public
          view
          returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256)
      {
          // setup local rID
          uint256 _rID = rID_;

          if (_addr == address(0))
          {
              _addr == msg.sender;
          }
          uint256 _pID = pIDxAddr_[_addr];

          return
          (
              _pID,                               //0
              plyr_[_pID].name,                   //1
              plyrRnds_[_pID][_rID].keys,         //2
              plyr_[_pID].win,                    //3
              (plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),       //4
              plyr_[_pID].aff,                    //5
              plyrRnds_[_pID][_rID].eth           //6
          );
      }

  //==============================================================================
  //     _ _  _ _   | _  _ . _  .
  //    (_(_)| (/_  |(_)(_||(_  . (this + tools + calcs + modules = our softwares engine)
  //=====================_|=======================================================
      /**
       * @dev logic runs whenever a buy order is executed.  determines how to handle
       * incoming eth depending on if we are in an active round or not
       */
      function buyCore(uint256 _pID, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
          private
      {
          // setup local rID
          uint256 _rID = rID_;

          // grab time
          uint256 _now = now;

          // if round is active
          if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
          {
              // call core
              core(address(0), _rID, _pID, msg.value, _affID, _team, _eventData_);

          // if round is not active
          } else {
              // check to see if end round needs to be ran
              if (_now > round_[_rID].end && round_[_rID].ended == false)
              {
                  // end the round (distributes pot) & start new round
  			    round_[_rID].ended = true;
                  _eventData_ = endRound(_eventData_);

                  // build event data
                  _eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
                  _eventData_.compressedIDs = _eventData_.compressedIDs + _pID;

                  // fire buy and distribute event
                  emit F3Devents.onBuyAndDistribute
                  (
                      msg.sender,
                      plyr_[_pID].name,
                      msg.value,
                      _eventData_.compressedData,
                      _eventData_.compressedIDs,
                      _eventData_.winnerAddr,
                      _eventData_.winnerName,
                      _eventData_.amountWon,
                      _eventData_.newPot,
                      _eventData_.P3DAmount,
                      _eventData_.genAmount
                  );
              }

              // put eth in players vault
              plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
          }
      }

       /**
       * @dev logic runs whenever a buy order is executed.  determines how to handle
       * incoming eth depending on if we are in an active round or not
       */
      function buyCoreQR(address _realSender,uint256 _pID, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
          private
      {
          // setup local rID
          uint256 _rID = rID_;

          // grab time
          uint256 _now = now;

          // if round is active
          if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
          {
              // call core
              core(_realSender,_rID, _pID, msg.value, _affID, _team, _eventData_);

          // if round is not active
          } else {
              // check to see if end round needs to be ran
              if (_now > round_[_rID].end && round_[_rID].ended == false)
              {
                  // end the round (distributes pot) & start new round
  			    round_[_rID].ended = true;
                  _eventData_ = endRound(_eventData_);

                  // build event data
                  _eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
                  _eventData_.compressedIDs = _eventData_.compressedIDs + _pID;

                  // fire buy and distribute event
                  emit F3Devents.onBuyAndDistribute
                  (
                      _realSender,
                      plyr_[_pID].name,
                      msg.value,
                      _eventData_.compressedData,
                      _eventData_.compressedIDs,
                      _eventData_.winnerAddr,
                      _eventData_.winnerName,
                      _eventData_.amountWon,
                      _eventData_.newPot,
                      _eventData_.P3DAmount,
                      _eventData_.genAmount
                  );
              }

              // put eth in players vault
              plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
          }
      }

      /**
       * @dev logic runs whenever a reload order is executed.  determines how to handle
       * incoming eth depending on if we are in an active round or not
       */
      function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, F3Ddatasets.EventReturns memory _eventData_)
          private
      {
          // setup local rID
          uint256 _rID = rID_;

          // grab time
          uint256 _now = now;

          // if round is active
          if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].e...

// [truncated — 83166 bytes total]