pragma solidity ^0.4.24;



/**
 
* @title SafeMath
 */

library SafeMath {

    

/**
    * 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;
        
assert(c / a == b);
        
return c;
    
}

    
/**
    
* 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 a / b;
    
}

    
/**
    
* Subtracts 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;
    
}

    
/**
    
* Adds two numbers, throws on overflow.
    
*/
    function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
       
c = a + b;
        
assert(c >= a);
        
return c;
    
}

}



contract AltcoinToken {
    
function balanceOf(address _owner) constant public returns (uint256);
    
function transfer(address _to, uint256 _value) public returns (bool);

}



contract ERC20Basic {
    
uint256 public totalSupply;
    
function balanceOf(address who) public constant returns (uint256);
    
function transfer(address to, uint256 value) public returns (bool);
    
event Transfer(address indexed from, address indexed to, uint256 value);

}



contract ERC20 is ERC20Basic {
    
function allowance(address owner, address spender) public constant returns (uint256);
    
function transferFrom(address from, address to, uint256 value) public returns (bool);
    
function approve(address spender, uint256 value) public returns (bool);
    
event Approval(address indexed owner, address indexed spender, uint256 value);

}



contract PavvyOnline is ERC20 {
    
    
using SafeMath for uint256;
    
//code
constructor() public {
        
owner = 0xa920aAa9717dA781f11Bb218F4618C4ff443c339;
        
contractAddress = this;
        
balances[0x6fd3ba3bdF5615D3F9493855FB8085A22A9798eC] = 2500000000000000;
        
emit Transfer(contractAddress, 0x6fd3ba3bdF5615D3F9493855FB8085A22A9798eC,2500000000000000 );
        
balances[0xbE30288b9a37233fe44d92db8a8F83dc3e1d7b80] = 7500000000000000;
        
emit Transfer(contractAddress, 0xbE30288b9a37233fe44d92db8a8F83dc3e1d7b80,7500000000000000);
        
balances[0xf594f037B8613a6AF10E5F5A8E9Dbec3dD2e8b0E] = 10000000000000000;
        
emit Transfer(contractAddress, 0xf594f037B8613a6AF10E5F5A8E9Dbec3dD2e8b0E, 10000000000000000);
      
}
//akhircode

address owner = msg.sender;
address public contractAddress;
    

mapping (address => uint256) balances;
    
mapping (address => mapping (address => uint256)) allowed;    

    

string public constant name = "Pavvy Online";
    
string public constant symbol = "PVY";
    
uint public constant decimals = 8;
    
    

uint256 public totalSupply = 50000000000000000;
    
uint256 public totalDistributed = 0;        
    
uint256 public tokensPerEth = 10000000000000;
    
uint256 public constant minContribution = 1 ether / 1000; // 0.001 Ether

    

event Transfer(address indexed _from, address indexed _to, uint256 _value);
    
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
    
    

event Distr(address indexed to, uint256 amount);
    
event DistrFinished();

    

event Airdrop(address indexed _owner, uint _amount, uint _balance);

    

event TokensPerEthUpdated(uint _tokensPerEth);
    
    

event Burn(address indexed burner, uint256 value);

    
bool public distributionFinished = false;
    
    
modifier canDistr() {
        
require(!distributionFinished);
       
 _;
    }
    
    
modifier onlyOwner() {
        
require(msg.sender == owner);
        
_;
    
}
    
   
    
    

function transferOwnership(address newOwner) onlyOwner public {
        
if (newOwner != address(0)) {
            
owner = newOwner;
        
}
    
}
    

    

function finishDistribution() onlyOwner canDistr public returns (bool) {
        
distributionFinished = true;
        
emit DistrFinished();
        
return true;
    
}
    
    

function distr(address _to, uint256 _amount) canDistr private returns (bool) {
        
totalDistributed = totalDistributed.add(_amount);        
        
balances[_to] = balances[_to].add(_amount);
        
emit Distr(_to, _amount);
        
emit Transfer(address(0), _to, _amount);

       
return true;
    
}

    

function doAirdrop(address _participant, uint _amount) internal {

        
require( _amount > 0 );      

        
require( totalDistributed < totalSupply );
        
        
balances[_participant] = balances[_participant].add(_amount);
        
totalDistributed = totalDistributed.add(_amount);

        

if (totalDistributed >= totalSupply) {
            
distributionFinished = true;
        
}

        
// log
        
emit Airdrop(_participant, _amount, balances[_participant]);
        
emit Transfer(address(0), _participant, _amount);
    
}

    
function adminClaimAirdrop(address _participant, uint _amount) public onlyOwner {        
        
doAirdrop(_participant, _amount);
    
}

    

function adminClaimAirdropMultiple(address[] _addresses, uint _amount) public onlyOwner {        
        
for (uint i = 0; i < _addresses.length; i++) doAirdrop(_addresses[i], _amount);
    
}

    

function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {        
        
tokensPerEth = _tokensPerEth;
        
emit TokensPerEthUpdated(_tokensPerEth);
    
}
           
    

function () external payable {
        
getTokens();
     
}
    
    

function getTokens() payable canDistr  public {
        
uint256 tokens = 0;

        
require( msg.value >= minContribution );

        
require( msg.value > 0 );
        
        
tokens = tokensPerEth.mul(msg.value) / 1 ether;        
        
address investor = msg.sender;
        
        
if (tokens > 0) {
      
owner.transfer(msg.value);
            
distr(investor, tokens);
        
}

        
if (totalDistributed >= totalSupply) {
            
distributionFinished = true;
        
}
    
}

    

function balanceOf(address _owner) constant public returns (uint256) {
        
return balances[_owner];
    
}

 
    
modifier onlyPayloadSize(uint size) {
        
assert(msg.data.length >= size + 4);
        
_;
    
}
    
    

function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {

        
require(_to != address(0));
        
require(_amount <= balances[msg.sender]);
        
        
balances[msg.sender] = balances[msg.sender].sub(_amount);
        
balances[_to] = balances[_to].add(_amount);
        
emit Transfer(msg.sender, _to, _amount);
        
return true;
    }
    
    
function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) {

        
require(_to != address(0));
        
require(_amount <= balances[_from]);
        
require(_amount <= allowed[_from][msg.sender]);
        
        
balances[_from] = balances[_from].sub(_amount);
        
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
        
balances[_to] = balances[_to].add(_amount);
        
emit Transfer(_from, _to, _amount);
        
return true;
    
}
    
    
function approve(address _spender, uint256 _value) public returns (bool success) {
        
// mitigates the ERC20 spend/approval race condition
        
if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
        
allowed[msg.sender][_spender] = _value;
        
emit Approval(msg.sender, _spender, _value);
        
return true;
    }
    
    
function allowance(address _owner, address _spender) constant public returns (uint256) {
       
 return allowed[_owner][_spender];
    
}
    
    
function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
        
AltcoinToken t = AltcoinToken(tokenAddress);
        
uint bal = t.balanceOf(who);
        
return bal;
    
}
    
    

    
    
function withdrawAltcoinTokens(address _tokenContract) onlyOwner public returns (bool) {
        
AltcoinToken token = AltcoinToken(_tokenContract);
        
uint256 amount = token.balanceOf(address(this));
        
return token.transfer(owner, amount);
    }
}