Created using remix-ide: Realtime Ethereum Contract Compiler and Runtime. Load this file by pasting this gists URL or ID at https://remix.ethereum.org/#version=soljson-v0.5.1+commit.c8a2cb62.js&optimize=false&gist=

ENS.sol

pragma solidity >=0.4.22 < 0.6.0;

contract Ownerable {
    // event for ownership of contract
    event OwnerLogger(address);
    address public owner;
    
    constructor() public{
        owner = msg.sender;
        emit OwnerLogger(msg.sender);
    }
    
    modifier onlyOwner{
        require(msg.sender == owner);
        _;
    }
    
}

contract NameServer is Ownerable{
    
    event RegisterLog(string, address);
    // WithdrawLog(owner of contract, amount)
    event WithdrawLog(address, uint);
    // KillLog(owner of contract)
    event KillLog(address);
    // ChangeDomainLog(new name, domain address)
    event ChangeDomainLog(string, address);
    // ChangeOwnershipLog(domain addres, new owner)
    event ChangeOwnershipLog(address, address);
    event QueryAddr(string);
    event QueryName(address);

    struct Domain{
        string name;
        address addr;
        address payable owner;
    }
    
    struct Found{
        string name;
        address addr;
    }
    
    // Should pay val ether
    modifier PayEther(uint val) {
        require(
            msg.value == val,
            "Not enough payment"
            );
        _;
    }
    // Should possess target address
    modifier OnlyHolder(address target) {
        require(
            checkAddress[target] 
            && msg.sender == address(addressMap[target].owner)
            );  
        
        _;
    }

    // From string to Domain
    mapping (string => Domain) private nameMap;
    mapping (string => bool) private checkName;
    // From address to domain 
    mapping (address => Domain) private addressMap;
    mapping (address => bool) private checkAddress;
    // From address to  Found (After payment, save the value at queryStorage for the query)
    mapping (address => Found) private queryStorage;
    
    
    function register(string memory name, address target) public PayEther(0.1 ether) payable{
        // target should not be registered before and value should be 0.1
        require(
            !checkName[name] 
            && !checkAddress[target]
            );
        
        Domain memory _domain = Domain(name, target, msg.sender);
        nameMap[name] = _domain;
        checkName[name] = true;
        
        addressMap[target] = _domain;
        checkAddress[target] = true;
        
        // record a log about target and domain
        emit RegisterLog(name, target);
    }
    
    function changeDomain(address target, string memory newName) public OnlyHolder(target) PayEther(0.1 ether) payable {
        
        // change Domain Name of the target address
        // there should be registered target address and should not be already registered name 
        require(
            !checkName[newName] 
            && checkAddress[target]
            );
            
        Domain storage _domain = addressMap[target];
        checkName[_domain.name] = false;
        _domain.name = newName; 
        checkName[newName] = true;
        nameMap[newName] = _domain;
        
        emit ChangeDomainLog(newName, target);
    }
    
    function changeOwner(address target, address payable nextOwner) public OnlyHolder(target) PayEther(0.1 ether) payable {
        
       addressMap[target].owner = nextOwner;
        
        emit ChangeOwnershipLog(target, nextOwner);
    }

    function queryWithAddr(address target) public PayEther(0.01 ether) payable returns(string memory) {
        
        // address should be exist and value should be more than 0.01
        require(checkAddress[target]);
        
        // initialization for new query return
        queryStorage[msg.sender].addr = address(0);
        queryStorage[msg.sender].name = 'null';
        
        // transfer fee to the name holder
        Domain memory _domain = addressMap[target];
        _domain.owner.transfer(0.005 ether);
        
        queryStorage[msg.sender].addr = _domain.addr;
        queryStorage[msg.sender].name = _domain.name;
        
        // For debuging
        emit QueryAddr(_domain.name);
        return _domain.name;
        
    }
    
    function queryWithName(string memory name) public PayEther(0.01 ether) payable returns(address){
        
        // address should be exist and value should be more than 0.01
        require(checkName[name]);
        
        // initialization for new query return
        queryStorage[msg.sender].addr = address(0);
        queryStorage[msg.sender].name = 'null';
        
        // transfer fee to the name holder
        Domain memory _domain = nameMap[name];
        _domain.owner.transfer(0.005 ether);
        
        queryStorage[msg.sender].addr = _domain.addr;
        queryStorage[msg.sender].name = _domain.name;
        
        // For debugging
        emit QueryName(_domain.addr);
        return _domain.addr;
        
    }
    
    function query() public view returns(address, string memory){
        return (queryStorage[msg.sender].addr, queryStorage[msg.sender].name);
    }
    
    function withdraw() public onlyOwner {
        
        // report the person who withdraw all the balance
        msg.sender.transfer(address(this).balance);
        emit WithdrawLog(msg.sender, address(this).balance);
    }
    
    function kill() public onlyOwner { 
        selfdestruct(msg.sender);  
    }
   
}

ERC165.sol

pragma solidity >=0.4.22 <0.6.0;

contract ERC165 {
    bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
    
    mapping(bytes4 => bool) private _supportedInterfaces;
    
    constructor () internal {
        _registerInterface(_INTERFACE_ID_ERC165);
    }
    
    function supportsInterface(bytes4 interfaceId) external view returns (bool) {
        return _supportedInterfaces[interfaceId];
    }
    
    function _registerInterface(bytes4 interfaceId) internal {
        require(interfaceId!= 0xffffffff, "ERC165: invalid interface id");
        _supportedInterfaces[interfaceId] = true;
    }
}

ERC20.sol

pragma solidity >=0.4.22 <0.6.0;
import "./IERC20.sol";
import "./SafeMath.sol";
import "./StringUtils.sol";

contract MyTokenERC20 is ERC20{
    
    using SafeMath for uint256;
    
    string public name = "ERC TOKEN";
    string public symbol = "ERC";
    uint8 public decimals = 5;
    
    mapping (address => uint256) private balances;
    mapping (address => mapping (address => uint256)) private allowed;
    uint256 private _totalSupply;
    
    modifier NotZeroAddr(address addr){
        require(addr != address(0)); 
        _;
    }
    
    constructor () public{
        _totalSupply = 1000;
        balances[msg.sender] = _totalSupply;
    }
    
    function totalSupply() external view returns (uint256){
        return _totalSupply;    
    }
    
    function balanceOf(address who) external view NotZeroAddr(who) returns (uint256){
        return balances[who];
    }
    
    function allowance(address owner, address spender) external view NotZeroAddr(spender) returns (uint256){
        return allowed[owner][spender];
    }
    
    function transfer(address to, uint256 value) external NotZeroAddr(to) returns (bool){
        // Underflow And overflow check 
        require(
            balances[msg.sender] >= value
            && balances[to] + value > balances[to]
        );
        
        _transfer(msg.sender, to, value);
        
        return true;
    }
    
    function _transfer(address _from, address to, uint256 value) private{
        
        balances[_from] -= value;
        balances[to] += value;
        emit Transfer(_from, to, value);
        
    }
    
    function approve(address spender, uint256 value) external NotZeroAddr(spender) returns (bool) {
        
        allowed[msg.sender][spender] = value;
        emit Approval(msg.sender, spender, value);
        
        return true;
        
    }
    
    // fund holder: addresss _from, 
    // sender who is approved from fund holder : msg.sender
    // receiver : address to
    function transferFrom(address _from, address to, uint256 value) external NotZeroAddr(_from) NotZeroAddr(to) returns (bool){
        
        require(allowed[_from][msg.sender] >= value);
        
        _transfer(_from, to, value);
        allowed[_from][msg.sender] -= value;
        
        return true;
    }
    
    
}
        

ERC721.sol

pragma solidity >=0.4.22 <0.6.0;

import "./IERC721.sol";
import "./SafeMath.sol";

contract IERC721Receiver {
    /**
     * @notice Handle the receipt of an NFT
     * @dev The ERC721 smart contract calls this function on the recipient
     * after a `safeTransfer`. This function MUST return the function selector,
     * otherwise the caller will revert the transaction. The selector to be
     * returned can be obtained as `this.onERC721Received.selector`. This
     * function MAY throw to revert and reject the transfer.
     * Note: the ERC721 contract address is always the message sender.
     * @param operator The address which called `safeTransferFrom` function
     * @param from The address which previously owned the token
     * @param tokenId The NFT identifier which is being transferred
     * @param data Additional data with no specified format
     * @return bytes4 `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
     */
    function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data)
    public returns (bytes4);
}

contract MyERC721 is IERC721, ERC165 {
    
    
    using SafeMath for uint256;
    
    bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
    bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;
    
    mapping (uint256 => address) private _tokenOwner;
    mapping (uint256 => address) private _tokenApprovals;
    mapping (address => mapping (address => bool)) private _operatorApprovals;
    mapping (address => uint256) private _ownedTokenCount;

    
    constructor () public {
        _registerInterface(_INTERFACE_ID_ERC721);
    }
    
    
    modifier NotZeroAddr(address addr){
        require(addr != address(0), "ERC721: Address is zero"); 
        _;
    }
    
    modifier ExistingToken(uint256 tokenId){
        address owner = _tokenOwner[tokenId];
        require(owner != address(0), "ERC721: Nonexistent token");
        _;
    }
    
    modifier NotExistingToken(uint256 tokenId){
        address owner = _tokenOwner[tokenId];
        require(owner == address(0), "ERC721: Already existing token");
        _;
    }
    
    modifier TokenAllowedTo(uint256 tokenId, address addr){
        address owner = _tokenOwner[tokenId];
        require(
            _isApprovedOrOwner(addr, tokenId), 
            "ERC721: No token allowance or Not owner"
            );
        _;
    }
    
    // Make new coin for the address to
    function _mint(address to, uint256 tokenId) internal NotZeroAddr(to) NotExistingToken(tokenId) {
        
        _tokenOwner[tokenId] = to;
        _ownedTokenCount[to] = _ownedTokenCount[to].incr();

        emit Transfer(address(0), to, tokenId);
    }
    
    // Remove ExistingToken 
    function _burn(address owner, uint256 tokenId) internal TokenAllowedTo(tokenId, owner){
        
        _clearApproval(tokenId);

        _ownedTokenCount[owner] = _ownedTokenCount[owner].decr();
        _tokenOwner[tokenId] = address(0);

        emit Transfer(owner, address(0), tokenId);
    }
    
    function _burn(uint256 tokenId) internal {
        _burn(_tokenOwner[tokenId], tokenId);
    }

    function balanceOf(address owner) external view NotZeroAddr(owner) returns (uint256){
        return _ownedTokenCount[owner];    
    }
    
    function ownerOf(uint256 tokenId) external view ExistingToken(tokenId) returns (address){
        address owner = _tokenOwner[tokenId];
        return owner;
    }
    
    function approve(address to, uint256 tokenId) 
        external NotZeroAddr(to) ExistingToken(tokenId) TokenAllowedTo(tokenId, msg.sender){
        // should be owner of the token or approved by the owner 
        
        address owner = this.ownerOf(tokenId);
        // target address should not be token owner 
        require(to != owner);

        _tokenApprovals[tokenId] = to;
        emit Approval(owner, to, tokenId);
    }
    
    function getApproved(uint256 tokenId) external view ExistingToken(tokenId) returns (address operator){
        return _tokenApprovals[tokenId];
    }
    
    // Set approve all the coins of msg.sender to operator
    function setApprovalForAll(address operator, bool _approved) NotZeroAddr(operator) external{
        
        // operator should not be msg.sender 
        require(operator != msg.sender);
    
        _operatorApprovals[msg.sender][operator] = _approved;
        emit ApprovalForAll(msg.sender, operator, _approved);
        
    }
    // Check approval of all the coins of msg.sender to operator
    function isApprovedForAll(address owner, address operator) 
        external view NotZeroAddr(owner) NotZeroAddr(operator) returns (bool){
        
        return _operatorApprovals[owner][operator];    
    }
    
    function _isApprovedOrOwner(address spender, uint256 tokenId) private ExistingToken(tokenId) view returns (bool) {
        address owner = this.ownerOf(tokenId);
        // should be owner of the token or approved token or approved user
        return (
            spender == owner 
            || this.getApproved(tokenId) == spender 
            || this.isApprovedForAll(owner, spender)
            );
    }
    
    function transferFrom(address _from, address to, uint256 tokenId) 
        external NotZeroAddr(_from) NotZeroAddr(to) ExistingToken(tokenId) TokenAllowedTo(tokenId, msg.sender){
        // addresses should not be zero
        // token should be ExistingToken and allowed to address _from
        
        // set token clear for the new owner
        _clearApproval(tokenId);

        // Using safeMath to increase or decrease uint256
        _ownedTokenCount[_from] = _ownedTokenCount[_from].decr();
        _ownedTokenCount[to] = _ownedTokenCount[to].incr();

        _tokenOwner[tokenId] = to;

        emit Transfer(_from, to, tokenId);
    
    }
    
    function _clearApproval(uint256 tokenId) private{
        _tokenApprovals[tokenId] = address(0);
    }
    
    function safeTransferFrom(address _from, address to, uint256 tokenId) public {
        safeTransferFrom(_from, to, tokenId, "");
    }

    function safeTransferFrom(address _from, address to, uint256 tokenId, bytes memory _data) public {
        require(_checkOnERC721Received(_from, to, tokenId, _data), 
            "ERC721: transfer to non ERC721Receiver contract");
        
        this.transferFrom(_from, to, tokenId);
    }
    
    function _checkOnERC721Received(address _from, address to, uint256 tokenId, bytes memory _data)
        internal returns (bool){
        // check whether contract or not
        if (!isContract(to)) {
            return true;
        }
        // check whether ERC721Receiver is implemented or not 
        bytes4 retval = IERC721Receiver(to).onERC721Received(msg.sender, _from, tokenId, _data);
        return (retval == _ERC721_RECEIVED);
    }
    
    function isContract(address account) internal view returns (bool) {
        uint256 size;
        // If there is a contract in an address
        // than to check the size of the code at that address.
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }
    
}

ICO.sol

pragma solidity >=0.4.22 <0.6.0;

contract Ownerable {
    // event
    event OwnerLogger(address);
    address public owner;
    
    constructor() public{
        owner = msg.sender;
        emit OwnerLogger(msg.sender);
    }
    
    modifier onlyOwner{
        require(msg.sender == owner);
        _;
    }
    
}

contract SimpleCrowdSale is Ownerable{
   
    uint256 public rate;
    MyTokenERC20 private myToken;
    event Test(uint256, uint256);
    constructor(address _myToken, uint256 _rate) public {
        myToken = MyTokenERC20(_myToken);
        rate = _rate;
    }
    
    function converter(uint256 value) private pure returns(uint256){
        require(value >= 1 ether);
        
        uint256 tmp = value / 1 ether;
        
        return tmp;
    }
    
    function buyToken() public payable {
        // There should be sufficient allowance
        uint256 recevied = converter(msg.value);
        uint256 tokens = recevied * rate;
        
        require(
            recevied <= tokens
            && myToken.allowance(owner, address(this)) >= tokens
            );
        
        
        myToken.transferFrom(owner, msg.sender, tokens);
        
    }
    
    function withdraw(uint256 value) public onlyOwner{
        
        require(address(this).balance >= value);
        msg.sender.transfer(value);
        
    }
    
}


interface IERC20 {
    
    function totalSupply() external view returns (uint256);
    function balanceOf(address who) external view returns (uint256);
    function allowance(address owner, address spender) external view returns (uint256);
    
    function transfer(address to, uint256 value) external returns (bool);
    function approve(address spender, uint256 value) external returns (bool);
    function transferFrom(address _from, address to, uint256 value) external returns (bool);
    
    event Transfer(address indexed _from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);

}

contract MyTokenERC20 is IERC20{
    
    string public name = "My Token";
    string public symbol = "MTK";
    uint8 public decimals = 0;
    
    mapping (address => uint256) private balances;
    mapping (address => mapping (address => uint256)) private allowed;
    uint256 private _totalSupply;
    
    modifier NotZeroAddr(address addr){
        require(addr != address(0)); 
        _;
    }
    
    constructor () public{
        _totalSupply = 1000;
        balances[msg.sender] = _totalSupply;
    }
    
    function totalSupply() external view returns (uint256){
        return _totalSupply;    
    }
    
    function balanceOf(address who) external view NotZeroAddr(who) returns (uint256){
        return balances[who];
    }
    
    function allowance(address owner, address spender) external view NotZeroAddr(spender) returns (uint256){
        return allowed[owner][spender];
    }
    
    function transfer(address to, uint256 value) external NotZeroAddr(to) returns (bool){
        // Underflow And overflow check 
        require(
            balances[msg.sender] >= value
            && balances[to] + value > balances[to]
        );
        
        _transfer(msg.sender, to, value);
        
        return true;
    }
    
    function _transfer(address _from, address to, uint256 value) private{
        
        balances[_from] -= value;
        balances[to] += value;
        emit Transfer(_from, to, value);
        
    }
    
    function approve(address spender, uint256 value) external NotZeroAddr(spender) returns (bool) {
        allowed[msg.sender][spender] = value;
        emit Approval(msg.sender, spender, value);
        
        return true;
        
    }
    
    function transferFrom(address _from, address to, uint256 value) external NotZeroAddr(_from) NotZeroAddr(to) returns (bool){
        
        require(allowed[_from][msg.sender] >= value);
        
        _transfer(_from, to, value);
        allowed[_from][msg.sender] -= value;
        
        return true;
    }
    
    
}

IERC20.sol

pragma solidity >=0.4.22 <0.6.0;

interface ERC20 {
    
    function totalSupply() external view returns (uint256);
    function balanceOf(address who) external view returns (uint256);
    function allowance(address owner, address spender) external view returns (uint256);
    
    function transfer(address to, uint256 value) external returns (bool);
    function approve(address spender, uint256 value) external returns (bool);
    function transferFrom(address _from, address to, uint256 value) external returns (bool);
    
    event Transfer(address indexed _from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);

}

IERC721.sol

pragma solidity ^0.5.0;

import "./ERC165.sol";

interface IERC721 {
    
    function balanceOf(address owner) external view returns (uint256 balance);
    function ownerOf(uint256 tokenId) external view returns (address owner);
    function approve(address to, uint256 tokenId) external;
    function getApproved(uint256 tokenId) external view returns (address operator);
    function setApprovalForAll(address operator, bool _approved) external;
    function isApprovedForAll(address owner, address operator) external view returns (bool);
    function transferFrom(address from, address to, uint256 tokenId) external;
    function safeTransferFrom(address from, address to, uint256 tokenId) external;
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata) external;
    
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
}

onReceiver.sol

pragma solidity ^0.5.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
contract IERC721Receiver {
    /**
     * @notice Handle the receipt of an NFT
     * @dev The ERC721 smart contract calls this function on the recipient
     * after a `safeTransfer`. This function MUST return the function selector,
     * otherwise the caller will revert the transaction. The selector to be
     * returned can be obtained as `this.onERC721Received.selector`. This
     * function MAY throw to revert and reject the transfer.
     * Note: the ERC721 contract address is always the message sender.
     * @param operator The address which called `safeTransferFrom` function
     * @param from The address which previously owned the token
     * @param tokenId The NFT identifier which is being transferred
     * @param data Additional data with no specified format
     * @return bytes4 `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
     */
    function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data)
    public returns (bytes4);
}

random.sol

//THIS CONTRACT IS CONSUMING A LOT OF GAS
//THIS CONTRACT IS ONLY FOR DEMONSTRATING HOW RANDOM NUMBER CAN BE GENERATED
//DO NOT USE THIS FOR PRODUCTION

pragma solidity >=0.4.22 <0.6.0;

contract Ownerable {
    // event
    event OwnerLogger(address);
    address public owner;
    
    constructor() public{
        owner = msg.sender;
        emit OwnerLogger(msg.sender);
    }
    
    modifier onlyOwner{
        require(msg.sender == owner);
        _;
    }
    
}

contract Lottery is Ownerable{
    
    mapping (uint8 => address payable[]) playersByNumber ;
    mapping (address => bytes32) playersHash;

    uint8[] public numbers;
    
    address owner;
    
   constructor() public {
        state = LotteryState.FirstRound;
    }
    
    enum LotteryState { FirstRound, SecondRound, Finished }
    
    LotteryState state; 

    function enterHash(bytes32 x) public payable {
        require(state == LotteryState.FirstRound);
        require(msg.value > .001 ether);
        playersHash[msg.sender] = x;
    }

    function runSecondRound() public {
        require(msg.sender == owner);
        require(state == LotteryState.FirstRound);
        state = LotteryState.SecondRound;
    }
    
    function enterNumber(uint8 number) public {
        require(number<=250);
        require(state == LotteryState.SecondRound);
        require(keccak256(abi.encodePacked(number, msg.sender)) == playersHash[msg.sender]);
        playersByNumber[number].push(msg.sender);
        numbers.push(number);
    }
    
    function determineWinner() public onlyOwner {
        require(msg.sender == owner);
        
        state = LotteryState.Finished;
        
        uint8 winningNumber = random();
        
        distributeFunds(winningNumber);

        selfdestruct(msg.sender);
    }
    
    function distributeFunds(uint8 winningNumber) private returns(uint256) {
        uint256 winnerCount = playersByNumber[winningNumber].length;
                require(winnerCount == 1);
        if (winnerCount > 0) {
            uint256 balanceToDistribute = address(this).balance/(2*winnerCount);
            for (uint i = 0; i<winnerCount; i++) {
                require(i==0);
                playersByNumber[winningNumber][i].transfer(balanceToDistribute);
            }
        }
        
        return address(this).balance;
    }
    
    function random() private view returns (uint8) {
        uint8 randomNumber = numbers[0];
        for (uint8 i = 1; i < numbers.length; ++i) {
            randomNumber ^= numbers[i];
        }
        return randomNumber;
    }
}

SafeMath.sol

pragma solidity >=0.4.22 <0.6.0;

library SafeMath {
    
    function incr(uint256 a) internal pure returns(uint256){
        return add(a, 1);
    } 
    
    function decr(uint256 a) internal pure returns(uint256){
        return sub(a, 1);
    }
    
    function mul(uint256 a, uint256 b) internal pure returns(uint256){
        
        if (a == 0 || b == 0)
            return 0;
            
        uint256 result = a * b;
    
        require(result / b == a, "SafeMath: overflow");
        return result;
    }
    
    function add(uint256 a, uint256 b) internal pure returns(uint256){
        
        uint256 result = a + b;
        
        require(result >= a && result >= b, "SafeMath: overflow");
        return result;
        
    }
    
    function sub(uint256 a, uint256 b) internal pure returns(uint256){
        
        uint256 result = a - b;
        
        require(result <= a, "SafeMath: underflow");
        return result;
    }
    
    function div(uint256 a, uint256 b) internal pure returns(uint256){
        
        require(b != 0, "Exception: Division by zero");
        
        uint256 result = a / b;
        
        require(a == result * b + (a % b), "SafeMath: overflow");
        return result;
    }
    
    function mod(uint256 a, uint256 b) internal pure returns(uint256){
        
        require(b != 0, "Exception: modulo by zero");
        
        uint256 result = a % b;
        return result;
    }
    
}

simpleBank.sol

pragma solidity >=0.4.22 < 0.6.0;

contract Ownerable {
    // event
    event OwnerLogger(address);
    address public owner;
    
    constructor() public{
        owner = msg.sender;
        emit OwnerLogger(msg.sender);
    }
    
    modifier onlyOwner{
        require(msg.sender == owner);
        _;
    }
    
}

contract SimpleBank is Ownerable{
    
    event EnrollLog(address);
    event DepositLog(address, uint);
    event WithdrawLog(address, uint, uint);
    event SendLog(address, address, uint, uint);
    //address public sender = msg.sender; // contract maker
    mapping (address => uint) private balance;
    mapping (address => bool) private accounts;
    
    address [] private account_list;
        
    constructor () public {
        account_list.push(owner);
        accounts[owner] = true;
    }
    
    modifier onlyUser{
        require(accounts[msg.sender]);
        _;
    }
    
    function enroll(address target) public onlyOwner{
        require(!accounts[target]);
        accounts[target] = true;
        account_list.push(target);
        emit EnrollLog(target);
    }
    
    function deposit() public onlyUser payable{
        
        balance[msg.sender] += msg.value;
        
        // Emit log and return balance
        emit DepositLog(msg.sender, msg.value);
        
    }
    
    function withdraw(uint amount) public onlyUser returns (uint){
        require(balance[msg.sender] >= amount);
        
        balance[msg.sender] -= amount;
        uint remains = balance[msg.sender];
        
        // Emit log and send balance 
        emit WithdrawLog(msg.sender, amount, remains);
        msg.sender.transfer(amount);
        
        return balance[msg.sender];
    }
    
    function send(address addr, uint amount) public onlyUser{
        require(accounts[addr]
                && balance[msg.sender] >= amount);
        
        // withdraw amount from sender and increase receiver's balance
        balance[msg.sender] -= amount;
        balance[addr] += amount;
        
        // emit log
        emit SendLog(msg.sender, addr, amount, balance[msg.sender]);
        
    }
    
    // return memory(volatile) type 
    function getAccounts() public view onlyOwner returns (address[] memory){
        return account_list;
    }
    
    function getBalance() public onlyUser view returns (uint){
        return balance[msg.sender];
    }
}

StringUtils.sol

pragma solidity >=0.4.22 < 0.6.0;

library StringUtils{
    
    using StringUtils for string;
    
    function length(string memory str) internal pure returns (uint256){
        return bytes(str).length;
    }
    
    function strcmp(string memory left, string memory right) public pure returns (int8){
        bytes memory leftTmp = bytes(left);
        bytes memory rightTmp = bytes(right);
        uint256 leftLen = left.length();
        uint256 rightLen = right.length();
        
        uint256 limit = leftLen;
        
        // check smaller string length for for statmement
        if(leftLen > rightLen)
            limit = rightLen;
        
        
        for(uint256 i = 0; i < limit; i++){
            if(leftTmp[i] < rightTmp[i])
                return -1;
            else if(leftTmp[i] > rightTmp[i])
                return 1;
        }
        
        
        if(leftLen == rightLen)
            return 0;
        else if(leftLen < rightLen)
            return -1;
        else
            return 1;
            
    }
    
}

Test.sol

pragma solidity 0.5.1;
import "./SafeMath.sol";
import "./StringUtils.sol";

contract Tmp {
    
    using SafeMath for uint256;
    event ABCD(uint256, uint256);
    mapping (address => uint256) _balance;
    
   
    function printf(string memory str) public pure returns(bytes1){
        bytes memory strTmp = bytes(str);
        return strTmp[4];
    } 
    
    function printf2(string memory str) public pure returns(bool){
        bytes memory strTmp = bytes(str);
        
        if(strTmp[0] == 0x48)
            return true;
        
        return false;
    } 
    

    function test(uint256 a) public returns(uint256){
        _balance[msg.sender] = _balance[msg.sender].add(a);
        return _balance[msg.sender];
    }
    
    function test2(uint256 a) public returns(uint256){
        _balance[msg.sender] = _balance[msg.sender].sub(a);
        return _balance[msg.sender];
    }

    
    function test4() public view returns(uint256){
        return now;
    }

    function test5() public view returns(uint256){
        return block.timestamp;
    }

    function test6() public view returns(uint256){
        return now - block.timestamp;
    }
    
    function test7() public {
        _balance[msg.sender] = _balance[msg.sender].incr();
    }
    
    function test8() public {
        _balance[msg.sender] = _balance[msg.sender].decr();
    }
    
    function test9() public view returns(uint256){
        return _balance[msg.sender];
    }
    
}

test.sol

pragma solidity >=0.4.22 <0.6.0;

contract Ownable {
    address public owner;
    constructor() public {
        owner = msg.sender;
    }
    modifier onlyOwner {
        require(owner == msg.sender);
        _;
    }
}
contract ENS is Ownable{
    mapping(address=> string) private map1; // access to domain structure by address
    mapping(string => address) private map2;  // access to domain structure by name
    mapping(address => string) private Nameholder; // mapping between address and nameholder(owner of mapping)
    mapping(address => bool) private checking; // checking before mapping
    mapping(string => bool) private checking2;
    
    
    function register(address addr1,string memory name1) public payable{
        //require( keccak256(abi.encodePacked('0')) == keccak256(abi.encodePacked(map1[addr1])));  //there should be no mapping before my map procedure
        //require( address(0) == map2[name1]); // there should be no mapping before my map procedure
        
        require(checking[addr1] == false); //in solidity, default value of boolean is false 
        require(checking2[name1]== false);
        
        require(msg.value == 0.1 ether); // user should pay 0.1 ether to ENS contract
        
        map1[addr1] = name1; // make mapping 1
        map2[name1] = addr1; // make mapping 2
        
        checking[addr1] = true;  // after mapping, change its value to true, not to make duplicate mapping
        checking2[name1] = true;
        
        
        Nameholder[msg.sender] = name1; // after register, mapping nameholder
        
    }
    function getAddressQuery(string memory name)public payable returns(address)  {
        require(msg.value == 0.01 ether); // user should pay 0.005 ether to ENS contract
        msg.sender.transfer(0.005 ether);
        
        return map2[name]; 
    }
    function getNameQuery(address add)public payable returns(string memory) {
        require(msg.value == 0.01 ether); // user should pay 0.005 ether to ENS contract
        msg.sender.transfer(0.005 ether);
        return map1[add];
    }
    function changeaddress(address user,string memory name) public payable{
        require(msg.value == 0.1 ether); // user should pay 0.1 ether to ENS contract
        map2[name] = user; //change address 
    } 
    function transferOwnership(address newOwner) public payable{
        require(msg.sender  ==  map2[Nameholder[msg.sender]] ); //only name holder can call this function
        require(newOwner != address(0));
        require(msg.value == 0.1 ether); // user should pay 0.1 ether to ENS contract
        Nameholder[newOwner] = Nameholder[msg.sender]; // change name holder
        Nameholder[msg.sender]='0';   
    
        owner = newOwner; // change owner
    } 
    function withdraw(uint amount) public onlyOwner{
        require(address(this).balance >=amount); //balance should be larger than required amount
        msg.sender.transfer(amount);
    }
    function () payable external{}  //
}