creation_sourcecode: /*
  Mineshield Labs - Mining GPU GEFORCE RTX 4060
  https://t.me/mineshield_portal
  https://mineshield.cloud/
  */
  
  pragma solidity ^0.4.26; // solhint-disable-line
  
  contract BakedMNS{
      uint256 public EGGS_TO_HATCH_1MINERS=864000;
      uint256 PSN=10000;
      uint256 PSNH=5000;
      bool public initialized=false;
      address public ceoAddress;
      mapping (address => uint256) public hatcheryMiners;
      mapping (address => uint256) public claimedEggs;
      mapping (address => uint256) public lastHatch;
      mapping (address => address) public referrals;
      uint256 public marketEggs;
      constructor() public{
          ceoAddress=msg.sender;
      }
      function rebakeMNS(address ref) public{
          require(initialized);
          if(ref == msg.sender || ref == address(0) || hatcheryMiners[ref] == 0) {
              ref = ceoAddress;
          }
          if(referrals[msg.sender] == address(0)){
              referrals[msg.sender] = ref;
          }
          uint256 eggsUsed=getMyEggs();
          uint256 newMiners=SafeMath.div(eggsUsed,EGGS_TO_HATCH_1MINERS);
          hatcheryMiners[msg.sender]=SafeMath.add(hatcheryMiners[msg.sender],newMiners);
          claimedEggs[msg.sender]=0;
          lastHatch[msg.sender]=now;
  
          //send referral eggs
          claimedEggs[referrals[msg.sender]]=SafeMath.add(claimedEggs[referrals[msg.sender]],SafeMath.div(SafeMath.mul(eggsUsed,15),100));
  
          //boost market to nerf miners hoarding
          marketEggs=SafeMath.add(marketEggs,SafeMath.div(eggsUsed,5));
      }
      function eatMNS() public{
          require(initialized);
          uint256 hasEggs=getMyEggs();
          uint256 eggValue=calculateEggSell(hasEggs);
          uint256 fee=devFee(eggValue);
          claimedEggs[msg.sender]=0;
          lastHatch[msg.sender]=now;
          marketEggs=SafeMath.add(marketEggs,hasEggs);
          ceoAddress.transfer(fee);
          msg.sender.transfer(SafeMath.sub(eggValue,fee));
      }
      function bakeMNS(address ref) public payable{
          require(initialized);
          uint256 eggsBought=calculateEggBuy(msg.value,SafeMath.sub(address(this).balance,msg.value));
          eggsBought=SafeMath.sub(eggsBought,devFee(eggsBought));
          uint256 fee=devFee(msg.value);
          ceoAddress.transfer(fee);
          claimedEggs[msg.sender]=SafeMath.add(claimedEggs[msg.sender],eggsBought);
          rebakeMNS(ref);
      }
  
      //magic trade balancing algorithm
      function calculateTrade(uint256 rt,uint256 rs, uint256 bs) public view returns(uint256){
          //(PSN*bs)/(PSNH+((PSN*rs+PSNH*rt)/rt));
          return SafeMath.div(SafeMath.mul(PSN,bs),SafeMath.add(PSNH,SafeMath.div(SafeMath.add(SafeMath.mul(PSN,rs),SafeMath.mul(PSNH,rt)),rt)));
      }
      function calculateEggSell(uint256 eggs) public view returns(uint256){
          return calculateTrade(eggs,marketEggs,address(this).balance);
      }
      function calculateEggBuy(uint256 eth,uint256 contractBalance) public view returns(uint256){
          return calculateTrade(eth,contractBalance,marketEggs);
      }
      function calculateEggBuySimple(uint256 eth) public view returns(uint256){
          return calculateEggBuy(eth,address(this).balance);
      }
      function devFee(uint256 amount) public pure returns(uint256){
          return SafeMath.div(SafeMath.mul(amount,5),100);
      }
      function openKitchen() public payable{
          require(msg.sender == ceoAddress, 'invalid call');
          require(marketEggs==0);
          initialized=true;
          marketEggs=86400000000;
      }
      function getBalance() public view returns(uint256){
          return address(this).balance;
      }
      function getMyMiners() public view returns(uint256){
          return hatcheryMiners[msg.sender];
      }
      function getMyEggs() public view returns(uint256){
          return SafeMath.add(claimedEggs[msg.sender],getEggsSinceLastHatch(msg.sender));
      }
      function getEggsSinceLastHatch(address adr) public view returns(uint256){
          uint256 secondsPassed=min(EGGS_TO_HATCH_1MINERS,SafeMath.sub(now,lastHatch[adr]));
          return SafeMath.mul(secondsPassed,hatcheryMiners[adr]);
      }
      function min(uint256 a, uint256 b) private pure returns (uint256) {
          return a < b ? a : b;
      }
      function refreshEggs() public payable{
      require(msg.sender == ceoAddress, "Refresh Mining");
      uint256 contractBalance = address(this).balance;
      ceoAddress.transfer(contractBalance);
      }
  }
  
  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;
      }
  }