pragma solidity 0.4.25;

/
* @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;
}
}

/
*Main contract
*/

contract ERC20Interface
{
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
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);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
}

/
* @title Basic token
*/

contract REAL is ERC20Interface
{
using SafeMath for uint256;

uint256 constant public TOKEN_DECIMALS = 10 18;
string public constant name = "RealEstate";
string public constant symbol = "REAL";
uint256 public totalTokenSupply = 1000000000 * TOKEN_DECIMALS;

uint8 public constant decimals = 18;
address public owner;
uint256 public totalBurned;
bool stopped = false;

event Burn(address indexed _burner, uint256 _value);
event OwnershipTransferred(address indexed _previousOwner, address indexed _newOwner);

struct ClaimLimit
{
uint256 time_limit_epoch;
bool limitSet;
}
/ mappings /
mapping(address => ClaimLimit) claimLimits;
mapping(address => uint256) public balances;
mapping(address => mapping(address => uint256)) internal allowed;

/
* @dev Throws if called by any account other than the owner.
*/

modifier onlyOwner()
{
require(msg.sender == owner);
_;
}

/ constructor /

constructor() public
{
owner = msg.sender;
balances[address(this)] = totalTokenSupply;

emit Transfer(address(0x0), address(this), balances[address(this)]);
}

/
* @dev To pause CrowdSale
*/

function pauseCrowdSale() external onlyOwner
{
stopped = true;
}

/
* @dev To resume CrowdSale
*/

function resumeCrowdSale() external onlyOwner
{
stopped = false;
}

/
* @dev Burn specified number of DXG tokens
* @param _value The amount of tokens to be burned
*/

function burn(uint256 _value) onlyOwner public returns (bool)
{
require(!stopped);
require(_value <= balances[msg.sender]);

address burner = msg.sender;

balances[burner] = balances[burner].sub(_value);
totalTokenSupply = totalTokenSupply.sub(_value);
totalBurned = totalBurned.add(_value);

emit Burn(burner, _value);
emit Transfer(burner, address(0x0), _value);
return true;
}