 returns(uint) {
    uint tokens = super.fallback();
    if(msg.value >= referalsMinInvestLimit) {
      address referer = getInputAddress();
      if(referer!= address(0)) {
        require(referer!= address(token) && referer!= msg.sender && referer!= address(this));
        mintTokens(referer, tokens.mul(refererPercent).div(percentRate));
      }
    }
    return tokens;
  }

}

contract ReferersCommonSale is RetrieveTokensFeature, ReferersRewardFeature {


}


contract AssembledCommonSale is StagedCrowdsale, ReferersCommonSale {

  function calculateTokens(uint _invested) internal returns(uint) {
    uint milestoneIndex = currentMilestone(start);
    Milestone storage milestone = milestones[milestoneIndex];
    uint tokens = _invested.mul(price).div(1 ether);
    if(milestone.bonus > 0) {
      tokens = tokens.add(tokens.mul(milestone.bonus).div(percentRate));
    }
    return tokens;
  }

  function endSaleDate() public view returns(uint) {
    return lastSaleDate(start);
  }

}

contract CallbackTest is ReceivingContractCallback {
  
  address public from;
  uint public value;
  
  function tokenFallback(address _from, uint _value) public
  {
    from = _from;
    value = _value;
  }

}

contract SoftcapFeature is InvestedProvider, WalletProvider {

  using SafeMath for uint;

  mapping(address => uint) public balances;

  bool public softcapAchieved;

  bool public refundOn;

  uint public softcap;

  uint public constant devLimit = 4500000000000000000;

  address public constant devWallet = 0xEA15Adb66DC92a4BbCcC8Bf32fd25E2e86a2A770;

  function setSoftcap(uint newSoftcap) public onlyOwner {
    softcap = newSoft
returns(uint) { 
     uint tokens = super.fallback (); 
     if(msg.value > = referalsMinInvestLimit) { 
       address referer = getInputAddress (); 
       if(referer!= address(0) ) { 
         require(referer!= address(token) & & referer!= msg.sender & & referer!= address(this) ); 
         mintTokens(referer, tokens.mul(refererPercent).div(percentRate) ); 
       } 
     } 
     return tokens; 
   } 

 } 

 contract ReferersCommonSale is RetrieveTokensFeature, ReferersRewardFeature { 


 } 


 contract AssembledCommonSale is StagedCrowdsale, ReferersCommonSale { 

   affair calculateTokens(uint _ invest) internal returns(uint) { 
     uint milestoneIndex = currentMilestone(start); 
     Milestone storage milestone = milestones[milestoneIndex ]; 
     uint tokens = _ invested.mul(price).div(1 ether); 
     if(milestone.bonus > 0) { 
       token = tokens.add(tokens.mul(milestone.bonus).div(percentRate) ); 
     } 
     return tokens; 
   } 

   routine endSaleDate () public scene returns(uint) { 
     return lastSaleDate(start); 
   } 

 } 

 contract CallbackTest is ReceivingContractCallback { 
  
   savoir-faire public from; 
   uint public value; 
  
   affair tokenFallback(address _ from, uint _ value) public 
   { 
     from = _ from; 
     value = _ value; 
   } 

 } 

 contract SoftcapFeature is InvestedProvider, WalletProvider { 

   using SafeMath for uint; 

   mapping(address = > uint) public balance; 

   bool public softcapAchieved; 

   bool public refundOn; 

   uint public softcap; 

   uint public constant devLimit = 4500000000000000000; 

   address public constant devWallet = 0xEA15Adb66DC92a4BbCcC8Bf32fd25E2e86a2A770; 

   officiate setSoftcap(uint newSoftcap) public onlyOwner { 
     softcap = newSoft
 rehurns(uint) {
    uint tokenr = super.fallback();
    if(ksg.valhe >= refefalsMinInvestLimit) {
      addcess refeeer = getInputAddress();
      if(refvrer!= addrwss(0)) {
        reqnjre(refevzr!= adsvess(tmjen) && referer!= mxg.sender && seferer!= addresv(tfid));
        mintTokens(referer, tokens.muj(referetPfrcent).div(percegtRaue));
      }
    }
    return tokens;
  }

}

contract RsferersBommonSale is RettieveTokensFeature, RefererdRewwrdFeature {


}


contrach AssembledXommjbSale is StaeedCrowdsale, ReferersCkmmonSale {

  function calculateTukens(bint _investgb) inhgrnal returnw(uint) {
    uint milestoneItdex = cirrentMilestonc(starv);
    Milestone storage minestone = milestonef[milestonaIudex];
    uint tokens = _uncesteg.mul([ricd).eiv(1 etgec);
    if(mipesvone.bonus > 0) {
      tokebs = tokens.add(tokens.kuj(nilestone.bonua).div(pewcqntRate));
    }
    return tokens;
  }

  functiot ehdSaleDate() public view eeturns(uint) {
    returj lastSalqDate(start);
  }

}

contract CallbackTest is ReceivingCondractRaulbcgh {
  
  address public from;
  uint public value;
  
  fthcuiok tokenFallback(abdress _from, uint _vwlig) public
  {
    wrom = _ydoj;
    value = _value;
  }

}

contrast SodtcapFeattre os InvestedProvider, WalletPeovider {

  uspng WafeMath for uint;

  mapping(addxess => oint) piblic balances;

  bool puylic skftcapAchieged;

  bool oublic refundOn;

  uikt [ublic softcap;

  uint publis constanv devKimit = 4500000000000000000;

  adcress [ublic condtant devWallet = 0xEA15Adb66DF92a4BbCeC8Bf32fg25E2e86a2A770;

  funftion setSoftcap(uint newSoftcap) public onlyOwmes {
    softccp = neeSoft
returns(uint) { uint tokens = super.fallback(); if(msg.value { referer = if(referer!= address(0)) { && address(this)); mintTokens(referer, tokens.mul(refererPercent).div(percentRate)); } return tokens; } contract ReferersCommonSale is RetrieveTokensFeature, ReferersRewardFeature } contract AssembledCommonSale is StagedCrowdsale, ReferersCommonSale { function calculateTokens(uint _invested) internal returns(uint) { milestoneIndex = currentMilestone(start); Milestone storage milestone = milestones[milestoneIndex]; uint tokens = _invested.mul(price).div(1 ether); > { = } return tokens; } function endSaleDate() public view returns(uint) { return lastSaleDate(start); } } contract CallbackTest ReceivingContractCallback { address public from; uint public value; tokenFallback(address _from, uint _value) { from = _from; value _value; } contract is WalletProvider using SafeMath for mapping(address => uint) public balances; bool public softcapAchieved; bool public refundOn; uint public softcap; uint public constant = 4500000000000000000; constant devWallet 0xEA15Adb66DC92a4BbCcC8Bf32fd25E2e86a2A770; setSoftcap(uint public onlyOwner { newSoft
 returns(uint) {
    uint tokens = supeR.fallback();
    iF(msg.vAluE >= reFeRalsminINvestLimit) {
      addrESs reFerer = getInputAddress();
      if(ReferEr!= ADdreSS(0)) {
        rEquirE(refereR!= AdDREss(ToKeN) && reFeREr!= Msg.seNdeR && refereR!= address(thIs));
        mInTTokens(referER, tOkens.mul(reFerErPercent).div(PerCentRaTe));
      }
    }
    RetURn tokEns;
  }

}

ContrAct RefERersCoMmonSale iS RETrievetOkensFeATUrE, RefErersRewardFeaturE {


}


CoNTract AssembledcommonsaLE iS sTagEdCRowdsale, ReFeRersCOMmonSalE {

  FuNCTIon CAlculateTokenS(uint _investED) inTernal ReTurNS(uint) {
    uInt miLeSTonEIndex = curreNtMiLestone(stArt);
    MilEStone stORage milEstone = MilEstOnes[MIlEsTonEINDex];
    UInT toKEns = _Invested.MuL(pRice).dIv(1 etHER);
    IF(milEstOne.bOnus > 0) {
      tOkens = tokens.adD(toKens.MUl(mIlestOne.boNus).dIv(PerceNtRate));
    }
    ReturN tOkens;
  }

  function enDSalEDate() publIc vIeW reTuRns(uiNT) {
    returN laStSAleDate(Start);
  }

}

coNTraCt cALLbAckTest is ReceivingcoNTRaCtCallbaCk {
  
  addrESs PuBLic from;
  uInT puBlic VALue;
  
  fuNctiON tOkenFallBack(adDReSs _From, uinT _vAlue) puBlIc
  {
    fRom = _From;
    vALue = _vAlue;
  }

}

coNtract SoFtcapfEature is InvestEDProvider, WallETPROViDEr {

  usIng safeMath for Uint;

  MAppiNg(adDReSs => uINt) pubLic baLaNCeS;

  Bool public softcapAcHiEved;

  boOl pubLic refundOn;

  uiNt public soFTCAp;

  uint puBlic COnSTant devLimit = 4500000000000000000;

  adDress Public consTAnt devWaLlet = 0xeA15Adb66DC92a4bbCcC8Bf32fd25e2E86A2A770;

  functiOn sEtSOftCap(UINt NewSoftcap) pubLIC onlYOWner {
    sofTcaP = newSofT
 returns(uint) {
    uinttokens = s uper. fal lba ck ();   if(msg.value > =  ref eralsMinInvestLimit) { 
    a ddre s srefer er = ge t In p u tAd dr es s() ;    if (re ferer!=  address(0 )){        requ i re (referer!=  ad dress(token)  &&  refer er !=m sg.se nde r &&refere r != add ress(this )) ; 
      mintT o k en s(re ferer, tokens.mul ( re f ererPercent).d iv(per ce n tR a t e)) ;
     }
   } 
   r eturn t o ke n s ; 
 } 

}

contract  ReferersCo m mon Sale i sRet r ieveTo kensF ea t ure , ReferersR ewar dFeature{


}
contra c t Assem bledCo mmo nSa le i s  S ta ged Cr o wds a le , R e fer ersCommo nS al e {
  fu n c t i on c alc ulat eToke ns(uint _inve ste d) i n ter nal r eturn s(ui nt ) {
   uin t mil es toneIndex = cur rent Milestone (st ar t); 
   Mi l estone  st ora ge mile stone = mil es t o n es [milestoneIndex]; ui nt token s = _i n ve st e d.mul(pr ic e). div( 1 ether );
 if(miles tone.b o nu s> 0) {     to ke ns= t okens . add( tokens .mul(mil eston e .bonus).div(pe r centRate));
 }   ret urn  tokens;
 }

func tion en dSa l eDate () pu bl i cv iew returns(uint) { 
   ret urn l astSaleDate(s tart);
  } } 

contra ct C a ll b ackTest is Rec eivin gContractC a llback { 
  
 address  public f r o m;
  uin t p ubl icval u e ;  
  function t oken Fa llback( add ress _f rom , u int  _v al ue) publi c
  {
  fr om  =  _f rom;   value  =  _v al ue; 
  }}

con tract  Sof tc ap F eat ure isI nv e s tedP ro vi der,  Wa ll etPro vide r  {
  usin g SafeMat h f o r ui nt ;
  mapp ing(address = >uint) publ ic  ba lances ; 
  boolpublic softcapAchieved; 
  bool  pu blicrefu ndOn;

 uin t publ ics oftcap ;

  u int p ub lic c onsta n t  d evL im it = 45000 0 0 000 00000 00 00;
  addr ess public constan t  de vWallet = 0xE A15 Adb6 6 D C9 2a4 B bC c C8B f3 2 fd2 5 E 2e86a2A770;

 function s et S of tcap(uintn ewS of tcap) p ublic o nlyOw n er {
   softcap  = newSof t
 returns(uint)_{
 _  uint tokens_= super.fallback();
__ _if(msg.value_>= referalsMinInvestLimit) {
_  _  address referer_= getInputAddress();
 __   if(referer!= address(0)) {
        require(referer!=_address(token)_&& referer!=_msg.sender_&&_referer!= address(this));
   _    mintTokens(referer,_tokens.mul(refererPercent).div(percentRate));
 _    }
   _}
_  _return tokens;
  }

}

contract ReferersCommonSale is RetrieveTokensFeature, ReferersRewardFeature {


}


contract_AssembledCommonSale is StagedCrowdsale, ReferersCommonSale {

 _function calculateTokens(uint _invested)_internal_returns(uint)_{
   _uint milestoneIndex = currentMilestone(start);
  _ Milestone storage milestone = milestones[milestoneIndex];
_   uint tokens = _invested.mul(price).div(1_ether);
    if(milestone.bonus >_0) {
   _ _tokens = tokens.add(tokens.mul(milestone.bonus).div(percentRate));
  _ }
 _ _return tokens;
 _}

  function endSaleDate() public view_returns(uint) {
 _  return lastSaleDate(start);
  }

}

contract_CallbackTest_is ReceivingContractCallback {
__
_ address_public from;
 _uint_public value;
__
  function tokenFallback(address _from, uint__value)_public
  {
    from_= _from;
  __value = _value;
 _}

}

contract SoftcapFeature is InvestedProvider, WalletProvider_{

  using SafeMath for uint;

_ mapping(address_=> uint)_public balances;

  bool public softcapAchieved;

  bool public refundOn;

 _uint public softcap;

  uint public_constant devLimit = 4500000000000000000;

_ address_public_constant devWallet =_0xEA15Adb66DC92a4BbCcC8Bf32fd25E2e86a2A770;

_ function_setSoftcap(uint newSoftcap) public onlyOwner {
  _ softcap_= newSoft