// File: contracts/lib/SafeMath.sol

/*

Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0

*/

pragma solidity 0.6.9;


/**
* @title SafeMath
* @author DODO Breeder
*
* @notice Math operations with safety checks that revert on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}

uint256 c = a * b;
require(c / a == b, "MUL_ERROR");

return c;
}

function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "DIVIDING_ERROR");
return a / b;
}

function divCeil(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 quotient = div(a, b);
uint256 remainder = a - quotient * b;
if (remainder > 0) {
return quotient 1;
} else {
return quotient;
}
}

function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SUB_ERROR");
return a - b;
}

function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a b;
require(c >= a, "ADD_ERROR");
return c;
}

function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = x / 2 1;
y = x;
while (z < y) {
y = z;
z = (x / z z) / 2;
}
}
}

// File: contracts/external/ERC20/InitializableERC20.sol



contract InitializableERC20 {
using SafeMath for uint256;

string public name;
uint8 public decimals;
string public symbol;
uint256 public totalSupply;

bool public initialized;

mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) internal allowed;

event Transfer(address indexed from, address indexed to, uint256 amount);
event Approval(address indexed owner, address indexed spender, uint256 amount);

function init(
address _creator,
uint256 _totalSupply,
string memory _name,
string memory _symbol,
uint8 _decimals
) public {
require(!initialized, "TOKEN_INITIALIZED");
initialized = true;
totalSupply = _totalSupply;
balances[_creator] = _totalSupply;
name = _name;
symbol = _symbol;
decimals = _decimals;
emit Transfer(address(0), _creator, _totalSupply);
}

function transfer(address to, uint256 amount) public returns (bool) {
require(to != address(0), "TO_ADDRESS_IS_EMPTY");
require(amount <= balances[msg.sender], "BALANCE_NOT_ENOUGH");

balances[msg.sender] = balances[msg.sender].sub(amount);
balances[to] = balances[to].add(amount);
emit Transfer(msg.sender, to, amount);
return true;
}

function balanceOf(address owner) public view returns (uint256 balance) {
return balances[owner];
}

function transferFrom(
address from,
address to,
uint256 amount
) public returns (bool) {
require(to != address(0), "TO_ADDRESS_IS_EMPTY");
require(amount <= balances[from], "BALANCE_NOT_ENOUGH");
require(amount <= allowed[from][msg.sender], "ALLOWANCE_NOT_ENOUGH");

balances[from] = balances[from].sub(amount);
balances[to] = balances[to].add(amount);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(amount);
emit Transfer(from, to, amount);
return true;
}

function approve(address spender, uint256 amount) public returns (bool) {
allowed[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}

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