CULTURAL INDUSTRY BASIC CHAIN

pragma solidity ^0.4.16; 
/*** @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) { 
		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 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) { 
		uint256 c = a + b; assert(c >= a); return c; 
	} 
}

contract owned { //认证 
	address public owner; 
	function owned() public { 
		owner = msg.sender; 
	}
	
	modifier onlyOwner { 
		require(msg.sender == owner); _; 
	}
	
	function transferOwnership(address newOwner) onlyOwner public { 
		owner = newOwner;
	} 
}

interface tokenRecipient { 
	function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; 
} 

contract TokenERC20 { 
	using SafeMath for uint256; 
	
	// Public variables of the token 
	string public name; 
	string public symbol; 
	uint8 public decimals = 18; 
	
	// 18 decimals is the strongly suggested default, avoid changing it 
	uint256 public totalSupply; 
	
	// This creates an array with all balances 
	mapping (address => uint256) public balanceOf; 
	mapping (address => mapping (address => uint256)) public allowance; 
	
	// This generates a public event on the blockchain that will notify clients 
	event Transfer(address indexed from, address indexed to, uint256 value); 
	
	// This notifies clients about the amount burnt 
	event Burn(address indexed from, uint256 value); 
	
	/*** Constrctor function 
	** Initializes contract with initial supply tokens to the creator of the contract 
	*/ 
	function TokenERC20( //初始化代币 
		uint256 initialSupply, 
		string tokenName, 
		string tokenSymbol 
	) public { 
		totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount 
		balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens 
		name = tokenName; // Set the name for display purposes 
		symbol = tokenSymbol; // Set the symbol for display purposes 
	}
	
	/*** Internal transfer, only can be called by this contract 
	*/ 
	function _transfer(address _from, address _to, uint _value) internal { 
		// Prevent transfer to 0x0 address. Use burn() instead 
		require(_to != 0x0);
		// Check if the sender has enough 
		require(balanceOf[_from] >= _value); 
		// Check for overflows 
		require(balanceOf[_to].add(_value) > balanceOf[_to]); 
		// Save this for an assertion in the future 
		uint previousBalances = balanceOf[_from].add(balanceOf[_to]); 
		// Subtract from the sender 
		balanceOf[_from] = balanceOf[_from].sub(_value); 
		// Add the same to the recipient 
		balanceOf[_to] = balanceOf[_to].add(_value); 
		emit Transfer(_from, _to, _value); 
		// Asserts are used to use static analysis to find bugs in your code. They should never fail 
		assert(balanceOf[_from] + balanceOf[_to] == previousBalances); 
	}
	
	/*** Transfer tokens 
	** Send `_value` tokens to `_to` from your account 
	** @param _to The address of the recipient 
	* @param _value the amount to send 
	*/
	function transfer(address _to, uint256 _value) public { //公开的交易 
		_transfer(msg.sender, _to, _value); 
	}
	
	/*** Transfer tokens from other address 
	** Send `_value` tokens to `_to` in behalf of `_from` 
	** @param _from The address of the sender 
	* @param _to The address of the recipient 
	* @param _value the amount to send 
	*/ 
	function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) { //代转 
		require(_value <= allowance[_from][msg.sender]); 
		// Check allowance 
		allowance[_from][msg.sender ] = allowance[_from][msg.sender].sub(_value); 
		_transfer(_from, _to, _value); return true; 
	}
	
	/*** Set allowance for other address 
	** Allows `_spender` to spend no more than `_value` tokens in your behalf 
	** @param _spender The address authorized to spend 
	* @param _value the max amount they can spend 
	*/ 
	function approve(address _spender, uint256 _value) public returns (bool success) { 
		require(_value == 0 || (allowance[msg.sender][_spender] == 0));
		allowance[msg.sender][_spender] = _value;
		return true; 
	}
	
	/*** Set allowance for other address and notify 
	** Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it 
	** @param _spender The address authorized to spend 
	* @param _value the max amount they can spend 
	* @param _extraData some extra information to send to the approved contract 
	*/ 
	function approveAndCall(address _spender, uint256 _value, bytes _extraData ) public returns (bool success) { 
		tokenRecipient spender = tokenRecipient(_spender); 
		if (approve(_spender, _value)) { 
			spender.receiveApproval(msg.sender, _value, this, _extraData); return true; 
		} 
	}
	
	/*** Destroy tokens ** Remove `_value` tokens from the system irreversibly 
	** @param _value the amount of money to burn 
	*/ 
	function burn(uint256 _value) public returns (bool success) { //销毁 
		require(balanceOf[msg.sender] >= _value); 
		// Check if the sender has enough 
		balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value); 
		// Subtract from the sender 
		totalSupply = totalSupply.sub(_value); 
		// Updates totalSupply 
		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 sender 
	* @param _value the amount of money to burn 
	*/ 
	function burnFrom(address _from, uint256 _value) public returns (bool success) { //销毁他人的代币 
		require(balanceOf[_from] >= _value); 
		// Check if the targeted balance is enough 
		require(_value <= allowance[_from][msg.sender]); 
		// Check allowance 
		balanceOf[_from] = balanceOf[_from].sub(_value); 
		// Subtract from the targeted balance 
		allowance[_from][msg.sender ] = allowance[_from][msg.sender].sub(_value); 
		// Subtract from the sender's allowance 
		totalSupply = totalSupply.sub(_value); 
		// Update totalSupply 
		emit Burn(_from, _value); 
		return true; 
	} 
	
	/*** Batch Transfer tokens 
	** Send `_value` tokens to `_receivers` from your account 
	** @param _receivers The address of the recipient 
	* @param _value the amount to send 
	*/
	function batchTransfer(address[] _receivers, uint256 _value) public returns (bool success) {
		uint receiverCount = _receivers.length;
		uint256 amount = _value.mul(uint256(receiverCount));
		require(receiverCount > 0);
		require(_value > 0 && balanceOf[msg.sender] >= amount);

		balanceOf[msg.sender] = balanceOf[msg.sender].sub(amount);
		for (uint i = 0; i < receiverCount; i++) {
			balanceOf[_receivers[i]] = balanceOf[_receivers[i]].add(_value);
			Transfer(msg.sender, _receivers[i], _value);
		}
		return true;
	}
}
/******************************************/ 
/* ADVANCED TOKEN STARTS HERE */
/******************************************/ 
contract MyAdvancedToken is owned, TokenERC20 { 
	using SafeMath for uint256; 
	uint256 public sellPrice ; 
	uint256 public buyPrice; 
	
	mapping (address => bool) public frozenAccount; 
	
	/* This generates a public event on the blockchain that will notify clients */ 
	event FrozenFunds(address target, bool frozen); 
	
	/* Initializes contract with initial supply tokens to the creator of the contract */ 
	function MyAdvancedToken( 
		uint256 initialSupply, 
		string tokenName, 
		string tokenSymbol 
	) TokenERC20(initialSupply, tokenName, tokenSymbol) public {} 
	
	/* Internal transfer, only can be called by this contract */ 
	function _transfer(address _from, address _to, uint _value) internal { 
		require (_to != 0x0); 
		
		// Prevent transfer to 0x0 address. Use burn() instead 
		require (balanceOf[_from] >= _value); 
		
		// Check if the sender has enough 
		require (balanceOf[_to].add (_value) >= balanceOf[_to]); 
		
		// Check for overflows 
		require(!frozenAccount[_from]); 
		
		// Check if sender is frozen 
		require(!frozenAccount[_to]); 
		
		// Check if recipient is frozen 
		balanceOf[_from] = balanceOf[_from].sub(_value); 
		
		// Subtract from the sender 
		balanceOf[_to] = balanceOf[_to ].add (_value); 
		
		// Add the same to the recipient 
		emit Transfer(_from, _to, _value); 
	}
	
	/// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens 
	/// @param target Address to be frozen 
	/// @param freeze either to freeze it or not 
	function freezeAccount(address target, bool freeze) onlyOwner public { // 冻结账户 
		frozenAccount[target] = freeze; emit FrozenFunds(target, freeze); 
	}
	
	/// @notice Allow users to buy tokens for `newBuyPrice` eth and sell tokens for `newSellPrice` eth 
	/// @param newSellPrice Price the users can sell to the contract 
	/// @param newBuyPrice Price users can buy from the contract 
	function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public { //代币买卖价格 
		sellPrice = newSellPrice; 
		buyPrice = newBuyPrice; 
	}
	
	/// @notice Buy tokens from contract by sending ether 
	function buy() payable public { //买代币 
		uint amount = msg.value.div(buyPrice); // calculates the amount
		_transfer(this, msg.sender, amount); // makes the transfers 
	}
	
	/// @notice Sell `amount` tokens to contract 
	/// @param amount amount of tokens to be sold 
	function sell(uint256 amount) public { //卖代币 
		require(address(this).balance >= amount.mul(sellPrice)); // checks if the contract has enough ether to buy 
		_transfer(msg.sender, this, amount); // makes the transfers 
		msg.sender.transfer(amount.mul(sellPrice)); // sends ether to the seller. It's important to do this last to avoid recursion attacks 
	} 
}

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