# Contract Diff Checker

Contract Name:
MATIC20ONSTON

Contract Source Code:

File 1 of 1 : MATIC20ONSTON

```pragma solidity =0.6.6;

library SafeMath {

function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");

return c;
}

function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}

function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;

return c;
}

function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}

uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");

return c;
}

function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}

function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold

return c;
}

function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}

function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}

interface IERC20 {

function totalSupply() external view returns (uint256);

function balanceOf(address account) external view returns (uint256);

function transfer(address recipient, uint256 amount) external returns (bool);

function approve(address spender, uint256 amount) external returns (bool);

}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}

function _msgData() internal view virtual returns (bytes memory) {
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
}
}

abstract contract Pausable is Context {

bool private _paused;

constructor () internal {
_paused = false;
}

function paused() public view returns (bool) {
return _paused;
}

modifier whenNotPaused() {
require(!_paused, "Pausable: paused");
_;
}

modifier whenPaused() {
require(_paused, "Pausable: not paused");
_;
}

function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}

function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;

mapping (address => uint256) private _balances;

uint256 private _totalSupply;

string private _name;
string private _symbol;
uint8 private _decimals;

constructor (string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
_decimals = 18;
}

function name() public view returns (string memory) {
return _name;
}

function symbol() public view returns (string memory) {
return _symbol;
}

function decimals() public view returns (uint8) {
return _decimals;
}

function totalSupply() public view override returns (uint256) {
return _totalSupply;
}

function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}

function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}

function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}

function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}

function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}

return true;
}

function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}

_beforeTokenTransfer(sender, recipient, amount);

_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
emit Transfer(sender, recipient, amount);
}

function _mint(address account, uint256 amount) internal virtual {

}

function _burn(address account, uint256 amount) internal virtual {

_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
}

_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}

function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}

}
abstract contract ERC20Pausable is ERC20, Pausable {
super._beforeTokenTransfer(from, to, amount);

require(!paused(), "ERC20Pausable: token transfer while paused");
}
}
contract MATIC20ONSTON is ERC20Pausable {
constructor(address operator,address pauser,string memory name, string memory symbol,uint8 decimal) public ERC20(name,symbol) {
_operator = operator;
_pauser=pauser;
_setupDecimals(decimal);
factory=msg.sender;
}

modifier onlyFactory(){
require(msg.sender==factory,"only Factory");
_;
}
modifier onlyOperator(){
require(msg.sender == _operator,"not allowed");
_;
}
modifier onlyPauser(){
require(msg.sender == _pauser,"not allowed");
_;
}

function pause() public  onlyPauser{
_pause();
}

function unpause() public  onlyPauser{
_unpause();
}