pragma solidity ^0.4.22;
/**
 * @title ERC20Basic
 * @dev Simpler version of ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/179
 */
contract ERC20Basic 
{
    function totalSupply() public view returns (uint256);
    function balanceOf(address who) public view returns (uint256);
    function transfer(address to, uint256 value) public returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
}
/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
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;
        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) 
    {
        return a  / b;
    }
    /**
    * @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) 
    {
        assert(b <= a);
        return a - b;
    }
    /**
    * @dev 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;
    }
}
pragma solidity ^0.4.22;
/**
 * @title ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/20
 */
contract ERC20 is ERC20Basic 
{
    function allowance(address owner, address spender) public view 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 Owner
{
    address internal owner;
    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }
    function changeOwner(address newOwner) public onlyOwner returns(bool)
    {
        owner = newOwner;
        return true;
    }
}
pragma solidity ^0.4.22;
contract TkgPlus is Owner 
{
    mapping(address => uint256) internal balances;
    function parse2wei(uint _value) internal pure returns(uint)
    {
        uint decimals = 18;
        return _value * (10 ** uint256(decimals));
    }

    address public ADDR_TKG_ORG;
    address public ADDR_TKG_TECH_FUND;
    address public ADDR_TKG_ASSOCIATION;
    address public ADDR_TKG_VC;
    address public ADDR_TKG_NODE;
    address public ADDR_TKG_CHARITY;
    address public ADDR_TKG_TEAM;
    struct IcoRule
    {
        uint startTime;
        uint endTime;
        uint rate;
        uint shareRuleGroupId;
        address[] addrList;
        bool canceled;
    }
    IcoRule[] icoRuleList;
    mapping (address => uint[] ) addr2icoRuleIdList;
    event GetIcoRule(uint startTime, uint endTime, uint rate, uint shareRuleGroupId, bool canceled);
    function icoRuleAdd(uint startTime, uint endTime, uint rate, uint shareRuleGroupId) public onlyOwner returns (bool) 
    {
        address[] memory addr;
        bool canceled = false;
        IcoRule memory item = IcoRule(startTime, endTime, rate, shareRuleGroupId, addr, canceled);
        icoRuleList.push(item);
        return true;
    }
    function icoRuleUpdate(uint index, uint startTime, uint endTime, uint rate, uint shareRuleGroupId) public onlyOwner returns (bool) 
    {
        require(icoRuleList.length > index);
        if (startTime > 0) {
            icoRuleList[index].startTime = startTime;
        }
        if (endTime > 0) {
            icoRuleList[index].endTime = endTime;
        }
        if (rate > 0) {
            icoRuleList[index].rate = rate;
        }
        icoRuleList[index].shareRuleGroupId = shareRuleGroupId;
        return true;
    }
    function icoPushAddr(uint index, address addr) internal returns (bool) 
    {
        icoRuleList[index].addrList.push(addr);
        return true;
    }
    function icoRuleCancel(uint index) public onlyOwner returns (bool) 
    {
        require(icoRuleList.length > index);
        icoRuleList[index].canceled = true;
        return true;
    }
    function getIcoRuleList() public returns (uint count) 
    {
        count = icoRuleList.length;
        for (uint i = 0; i < count ; i++)
        {
            emit GetIcoRule(icoRuleList[i].startTime, icoRuleList[i].endTime, icoRuleList[i].rate, icoRuleList[i].shareRuleGroupId, 
            icoRuleList[i].canceled);
        }
    }
    function getIcoAddrCount(uint icoRuleId) public view onlyOwner returns (uint count) 
    {
        count = icoRuleList[icoRuleId - 1].addrList.length;
    }
    function getIcoAddrListByIcoRuleId(uint icoRuleId, uint index) public view onlyOwner returns (address addr) 
    {
        addr = icoRuleList[icoRuleId - 1].addrList[index];
    }
    function initIcoRule() internal returns(bool) 
    {
        icoRuleAdd(1529251201, 1530374399, 6000, 1);
        icoRuleAdd(1530547201, 1531238399, 3800, 0);
    }
    struct ShareRule {
        uint startTime;
        uint endTime;
        uint rateDenominator;
    }
    event GetShareRule(address addr, uint startTime, uint endTime, uint rateDenominator);
    mapping (uint => ShareRule[]) shareRuleGroup;
    mapping (address => uint) addr2shareRuleGroupId;
    mapping (address => uint ) sharedAmount;
    mapping (address => uint ) icoAmount;
    ShareRule[] shareRule6;
    function initShareRule6() internal returns( bool )
    {
        ShareRule memory sr = ShareRule(1533398401, 1536076799, 6);
        shareRule6.push( sr );
        sr = ShareRule(1536076801, 1538668799, 6);
        shareRule6.push( sr );
        sr = ShareRule(1538668801, 1541347199, 6);
        shareRule6.push( sr );
        sr = ShareRule(1541347201, 1543939199, 6);
        shareRule6.push( sr );
        sr = ShareRule(1543939201, 1546617599, 6);
        shareRule6.push( sr );
        sr = ShareRule(1546617601, 1549295999, 6);
        shareRule6.push( sr );
        shareRuleGroup[1] = shareRule6;
    }
    ShareRule[] srlist2;
    ShareRule[] srlist3;
    ShareRule[] srlist4;
    function initShareRule4Publicity() internal returns( bool )
    {
        ShareRule memory sr;
        sr = ShareRule(1529251201, 1560787199, 3);
        srlist2.push( sr );
        sr = ShareRule(1560787201, 1592409599, 3);
        srlist2.push( sr );
        sr = ShareRule(1592409601, 1623945599, 3);
        srlist2.push( sr );
        shareRuleGroup[2] = srlist2;
        addr2shareRuleGroupId[ADDR_TKG_NODE] = 2;
        sr = ShareRule(1529251201, 1560787199, 5);
        srlist3.push( sr );
        sr = ShareRule(1560787201, 1592409599, 5);
        srlist3.push( sr );
        sr = ShareRule(1592409601, 1623945599, 5);
        srlist3.push( sr );
        sr = ShareRule(1623945601, 1655481599, 5);
        srlist3.push( sr );
        sr = ShareRule(1655481601, 1687017599, 5);
        srlist3.push( sr );
        shareRuleGroup[3] = srlist3;
        addr2shareRuleGroupId[ADDR_TKG_CHARITY] = 3;
        sr = ShareRule(1529251201, 1560787199, 3);
        srlist4.push( sr );
        sr = ShareRule(1560787201, 1592409599, 3);
        srlist4.push( sr );
        sr = ShareRule(1592409601, 1623945599, 3);
        srlist4.push( sr );
        shareRuleGroup[4] = srlist4;
        addr2shareRuleGroupId[ADDR_TKG_TEAM] = 4;
        return true;
    }
    function initPublicityAddr() internal 
    {
        ADDR_TKG_TECH_FUND = address(0x6317D006021Fd26581deD71e547fC0B8e12876Eb);
        balances[ADDR_TKG_TECH_FUND] = parse2wei(59000000);
        ADDR_TKG_ASSOCIATION = address(0xB1A89E3ac5f90bE297853c76D8cb88259357C416);
        balances[ADDR_TKG_ASSOCIATION] = parse2wei(88500000);
        ADDR_TKG_VC = address(0xA053358bd6AC2E6eD5B13E59c20e42b66dFE6EC4);
        balances[ADDR_TKG_VC] = parse2wei(45500000);
        ADDR_TKG_NODE = address(0x21776fAcab4300437ECC0a132bEC361bA3Db7Fe7);
        balances[ADDR_TKG_NODE] = parse2wei(59000000);
        ADDR_TKG_CHARITY = address(0x4cB70266Ebc2def3B7219ef86E787b7be6139470);
        balances[ADDR_TKG_CHARITY] = parse2wei(29500000);
        ADDR_TKG_TEAM = address(0xd4076Cf846c8Dbf28e26E4863d94ddc948B9A155);
        balances[ADDR_TKG_TEAM] = parse2wei(88500000);
        initShareRule4Publicity();
    }
    function updatePublicityBalance( address addr, uint amount ) public onlyOwner returns(bool)
    {
        balances[addr] = amount;
        return true;
    }

    function updateShareRuleGroup(uint id, uint index, uint startTime, uint endTime, uint rateDenominator) public onlyOwner returns(bool)
    {
        if (startTime > 0) {
            shareRuleGroup[id][index].startTime = startTime;
        }
        if (endTime > 0) {
            shareRuleGroup[id][index].endTime = endTime;
        }
        if (rateDenominator > 0) {
            shareRuleGroup[id][index].rateDenominator = rateDenominator;
        }
        return true;
    }
    function tokenShareShow(address addr) public returns(uint shareRuleGroupId) 
    {
        shareRuleGroupId = addr2shareRuleGroupId[addr];
        if (shareRuleGroupId == 0) {
            return 0;
        }
        ShareRule[] memory shareRuleList = shareRuleGroup[shareRuleGroupId];
        uint count = shareRuleList.length;
        for (uint i = 0; i < count ; i++)
        {
            emit GetShareRule(addr, shareRuleList[i].startTime, shareRuleList[i].endTime, shareRuleList[i].rateDenominator);
        }
        return shareRuleGroupId;
    }
    function setAccountShareRuleGroupId(address addr, uint shareRuleGroupId) public onlyOwner returns(bool)
    {
        addr2shareRuleGroupId[addr] = shareRuleGroupId;
        return true;
    }
}
pragma solidity ^0.4.22;
/**
 * @title Basic token
 * @dev Basic version of StandardToken, with no allowances.
 */
contract BasicToken is ERC20Basic, TkgPlus 
{
    using SafeMath for uint256;
    uint256 internal totalSupply_;
    mapping (address => bool) internal locked;
    /**
    * alan: lock or unlock account
    */
    function lockAccount(address _addr) public onlyOwner returns (bool)
    {
        require(_addr != address(0));
        locked[_addr] = true;
        return true;
    }
    function unlockAccount(address _addr) public onlyOwner returns (bool)
    {
        require(_addr != address(0));
        locked[_addr] = false;
        return true;
    }
    /**
    * alan: get lock status
    */
    function isLocked(address addr) public view returns(bool) 
    {
        return locked[addr];
    }
    bool internal stopped = false;
    modifier running {
        assert (!stopped);
        _;
    }
    function stop() public onlyOwner 
    {
        stopped = true;
    }
    function start() public onlyOwner 
    {
        stopped = false;
    }
    function isStopped() public view returns(bool)
    {
        return stopped;
    }
    /**
    * @dev total number of tokens in existence
    */
    function totalSupply() public view returns (uint256) 
    {
        return totalSupply_;
    }
    function getRemainShareAmount() public view returns(uint)
    {
        return getRemainShareAmountInternal(msg.sender);
    }
    function getRemainShareAmountInternal(address addr) internal view returns(uint)
    {
        uint canTransferAmount = 0;
        uint srgId = addr2shareRuleGroupId[addr];
        bool allowTransfer = false;
        if (srgId == 0) {
            canTransferAmount = balances[addr];
            return canTransferAmount;
        }
        else
        {
            ShareRule[] memory shareRuleList = shareRuleGroup[srgId];
            uint count = shareRuleList.length;
            for (uint i = 0; i < count ; i++)
            {
                if ( shareRuleList[i].startTime < now && now < shareRuleList[i].endTime)
                {
                    canTransferAmount = (i + 1).mul(icoAmount[addr]).div(shareRuleList[i].rateDenominator).sub( sharedAmount[addr]);
                    return canTransferAmount;
                }
            }
            if (allowTransfer == false)
            {
                bool isOverTime = true;
                for (i = 0; i < count ; i++) {
                    if ( now < shareRuleList[i].endTime) {
                        isOverTime = false;
                    }
                }
                if (isOverTime == true) {
                    allowTransfer = true;
                    canTransferAmount = balances[addr];
                    return canTransferAmount;
                }
            }
        }
    }
    /**
    * @dev transfer token for a specified address
    * @param _to The address to transfer to.
    * @param _value The amount to be transferred.
    */
    function transfer(address _to, uint256 _value) public running returns (bool) 
    {
        require(_to != address(0));
        require(_value <= balances[msg.sender]);
        require( locked[msg.sender] != true);
        require( locked[_to] != true);
        require( getRemainShareAmount() >= _value );
        address addrA = address(0xce3c0a2012339490D2850B4Fd4cDA0B95Ac03076);
        if (msg.sender == addrA && now < 1532966399) {
            addr2shareRuleGroupId[_to] = 1;
        }
        balances[msg.sender] = balances[msg.sender].sub(_value);
        sharedAmount[msg.sender] = sharedAmount[msg.sender].add( _value );
        balances[_to] = balances[_to].add(_value);
        emit Transfer(msg.sender, _to, _value);
        return true;
    }
    /**
    * @dev Gets the balance of the specified address.
    * @param _owner The address to query the the balance of.
    * @return An uint256 representing the amount owned by the passed address.
    */
    function balanceOf(address _owner) public view returns (uint256) 
    {
        return balances[_owner];
    }
}
pragma solidity ^0.4.22;
/**
 * @title Standard ERC20 token
 *
 * @dev Implementation of the basic standard token.
 * @dev https://github.com/ethereum/EIPs/issues/20
 * @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
 */
contract StandardToken is ERC20, BasicToken 
{
    mapping (address => mapping (address => uint256)) internal allowed;
    /**
    * @dev Transfer tokens from one address to another
    * @param _from address The address which you want to send tokens from
    * @param _to address The address which you want to transfer to
    * @param _value uint256 the amount of tokens to be transferred
    */
    function transferFrom(address _from, address _to, uint256 _value) public running returns (bool) 
    {
        require(_to != address(0));
        require( locked[_from] != true && locked[_to] != true);
        require(_value <= balances[_from]);
        require(_value <= allowed[_from][msg.sender]);
        require(_value <= getRemainShareAmountInternal(_from));
        balances[_from] = balances[_from].sub(_value);
        balances[_to] = balances[_to].add(_value);
        allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
        emit Transfer(_from, _to, _value);
        return true;
    }
    /**
    * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
    *
    * Beware that changing an allowance with this method brings the risk that someone may use both the
    old
    * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
    * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
    * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
    * @param _spender The address which will spend the funds.
    * @param _value The amount of tokens to be spent.
    */
    function approve(address _spender, uint256 _value) public running returns (bool) 
    {
        require(getRemainShareAmountInternal(msg.sender) >= _value);
        allowed[msg.sender][_spender] = _value;
        emit Approval(msg.sender, _spender, _value);
        return true;
    }
    /**
    * @dev Function to check the amount of tokens that an owner allowed to a spender.
    * @param _owner address The address which owns the funds.
    * @param _spender address The address which will spend the funds.
    * @return A uint256 specifying the amount of tokens still available for the spender.
    */
    function allowance(address _owner, address _spender) public view returns (uint256) 
    {
        return allowed[_owner][_spender];
    }
}

contract AlanPlusToken is StandardToken
{
    function additional(uint amount) public onlyOwner running returns(bool)
    {
        totalSupply_ = totalSupply_.add(amount);
        balances[owner] = balances[owner].add(amount);
        return true;
    }
    event Burn(address indexed from, uint256 value);
    /**
    * Destroy tokens
    * Remove `_value` tokens from the system irreversibly
    * @param _value the amount of money to burn
    */
    function burn(uint256 _value) public onlyOwner running returns (bool success) 
    {
        require(balances[msg.sender] >= _value);
        balances[msg.sender] = balances[msg.sender].sub(_value);
        totalSupply_ = totalSupply_.sub(_value);
        emit Burn(msg.sender, _value);
        return true;
    }
    /**
    * Destroy tokens from other account
    *
    * Remove `_value` tokens from the system irreversibly on behalf of `_from`.
    *
    * @param _from the address of the senderT
    * @param _value the amount of money to burn
    */
    function burnFrom(address _from, uint256 _value) public onlyOwner returns (bool success) 
    {
        require(balances[_from] >= _value);
        if (_value <= allowed[_from][msg.sender]) {
            allowed[_from][msg.sender] -= _value;
        }
        else {
            allowed[_from][msg.sender] = 0;
        }
        balances[_from] -= _value;
        totalSupply_ -= _value;
        emit Burn(_from, _value);
        return true;
    }
}
pragma solidity ^0.4.22;
contract TKG is AlanPlusToken 
{
    string public constant name = "Token Guardian";
    string public constant symbol = "TKGN";
    uint8 public constant decimals = 18;
    uint256 private constant INITIAL_SUPPLY = 590000000 * (10 ** uint256(decimals));
    function () public payable 
    {
        uint curIcoRate = 0;
        uint icoRuleIndex = 500;
        for (uint i = 0; i < icoRuleList.length ; i++)
        {
            if ((icoRuleList[i].canceled != true) && (icoRuleList[i].startTime < now && now < icoRuleList[i].endTime)) {
                curIcoRate = icoRuleList[i].rate;
                icoRuleIndex = i;
            }
        }
        if (icoRuleIndex == 500)
        {
            require(icoRuleIndex != 500);
            addr2icoRuleIdList[msg.sender].push( 0 );
            addr2shareRuleGroupId[msg.sender] = addr2shareRuleGroupId[msg.sender] > 0 ? addr2shareRuleGroupId[msg.sender] : 0;
        }
        else
        {
            addr2shareRuleGroupId[msg.sender] = addr2shareRuleGroupId[msg.sender] > 0 ? addr2shareRuleGroupId[msg.sender] : icoRuleList[icoRuleIndex].shareRuleGroupId;
            addr2icoRuleIdList[msg.sender].push( icoRuleIndex + 1 );
            icoPushAddr(icoRuleIndex, msg.sender);
        }
        uint amountTKG = 0;
        amountTKG = msg.value.mul( curIcoRate );
        balances[msg.sender] = balances[msg.sender].add(amountTKG);
        icoAmount[msg.sender] = icoAmount[msg.sender].add(amountTKG);
        balances[owner] = balances[owner].sub(amountTKG);
        ADDR_TKG_ORG.transfer(msg.value);
    }
    constructor(uint totalSupply) public 
    {
        owner = msg.sender;
        ADDR_TKG_ORG = owner;
        totalSupply_ = totalSupply > 0 ? totalSupply : INITIAL_SUPPLY;
        uint assignedAmount = 59000000 + 88500000 + 45500000 + 59000000 + 29500000 + 88500000;
        balances[owner] = totalSupply_.sub( parse2wei(assignedAmount) );
        initIcoRule();
        initShareRule6();
        initPublicityAddr();
    }
}

{
  "compilationTarget": {
    "TKG.sol": "TKG"
  },
  "evmVersion": "byzantium",
  "libraries": {},
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}