creation_sourcecode: pragma solidity ^0.4.18;
  
  contract DelegateERC20 {
    function delegateTotalSupply() public view returns (uint256);
    function delegateBalanceOf(address who) public view returns (uint256);
    function delegateTransfer(address to, uint256 value, address origSender) public returns (bool);
    function delegateAllowance(address owner, address spender) public view returns (uint256);
    function delegateTransferFrom(address from, address to, uint256 value, address origSender) public returns (bool);
    function delegateApprove(address spender, uint256 value, address origSender) public returns (bool);
    function delegateIncreaseApproval(address spender, uint addedValue, address origSender) public returns (bool);
    function delegateDecreaseApproval(address spender, uint subtractedValue, address origSender) public returns (bool);
  }
  
  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 &gt; 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&#39;t hold
      return c;
    }
  
    /**
    * @dev Substracts 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 Ownable {
    address public owner;
  
  
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
  
  
    /**
     * @dev The Ownable constructor sets the original `owner` of the contract to the sender
     * account.
     */
    function Ownable() public {
      owner = msg.sender;
    }
  
    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
      require(msg.sender == owner);
      _;
    }
  
    /**
     * @dev Allows the current owner to transfer control of the contract to a newOwner.
     * @param newOwner The address to transfer ownership to.
     */
    function transferOwnership(address newOwner) public onlyOwner {
      require(newOwner != address(0));
      OwnershipTransferred(owner, newOwner);
      owner = newOwner;
    }
  
  }
  
  contract Pausable is Ownable {
    event Pause();
    event Unpause();
  
    bool public paused = false;
  
  
    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     */
    modifier whenNotPaused() {
      require(!paused);
      _;
    }
  
    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     */
    modifier whenPaused() {
      require(paused);
      _;
    }
  
    /**
     * @dev called by the owner to pause, triggers stopped state
     */
    function pause() onlyOwner whenNotPaused public {
      paused = true;
      Pause();
    }
  
    /**
     * @dev called by the owner to unpause, returns to normal state
     */
    function unpause() onlyOwner whenPaused public {
      paused = false;
      Unpause();
    }
  }
  
  contract CanReclaimToken is Ownable {
    using SafeERC20 for ERC20Basic;
  
    /**
     * @dev Reclaim all ERC20Basic compatible tokens
     * @param token ERC20Basic The address of the token contract
     */
    function reclaimToken(ERC20Basic token) external onlyOwner {
      uint256 balance = token.balanceOf(this);
      token.safeTransfer(owner, balance);
    }
  
  }
  
  contract Claimable is Ownable {
    address public pendingOwner;
  
    /**
     * @dev Modifier throws if called by any account other than the pendingOwner.
     */
    modifier onlyPendingOwner() {
      require(msg.sender == pendingOwner);
      _;
    }
  
    /**
     * @dev Allows the current owner to set the pendingOwner address.
     * @param newOwner The address to transfer ownership to.
     */
    function transferOwnership(address newOwner) onlyOwner public {
      pendingOwner = newOwner;
    }
  
    /**
     * @dev Allows the pendingOwner address to finalize the transfer.
     */
    function claimOwnership() onlyPendingOwner public {
      OwnershipTransferred(owner, pendingOwner);
      owner = pendingOwner;
      pendingOwner = address(0);
    }
  }
  
  contract AddressList is Claimable {
      string public name;
      mapping (address => bool) public onList;
  
      function AddressList(string _name, bool nullValue) public {
          name = _name;
          onList[0x0] = nullValue;
      }
      event ChangeWhiteList(address indexed to, bool onList);
  
      // Set whether _to is on the list or not. Whether 0x0 is on the list
      // or not cannot be set here - it is set once and for all by the constructor.
      function changeList(address _to, bool _onList) onlyOwner public {
          require(_to != 0x0);
          if (onList[_to] != _onList) {
              onList[_to] = _onList;
              ChangeWhiteList(_to, _onList);
          }
      }
  }
  
  contract HasNoContracts is Ownable {
  
    /**
     * @dev Reclaim ownership of Ownable contracts
     * @param contractAddr The address of the Ownable to be reclaimed.
     */
    function reclaimContract(address contractAddr) external onlyOwner {
      Ownable contractInst = Ownable(contractAddr);
      contractInst.transferOwnership(owner);
    }
  }
  
  contract HasNoEther is Ownable {
  
    /**
    * @dev Constructor that rejects incoming Ether
    * @dev The `payable` flag is added so we can access `msg.value` without compiler warning. If we
    * leave out payable, then Solidity will allow inheriting contracts to implement a payable
    * constructor. By doing it this way we prevent a payable constructor from working. Alternatively
    * we could use assembly to access msg.value.
    */
    function HasNoEther() public payable {
      require(msg.value == 0);
    }
  
    /**
     * @dev Disallows direct send by settings a default function without the `payable` flag.
     */
    function() external {
    }
  
    /**
     * @dev Transfer all Ether held by the contract to the owner.
     */
    function reclaimEther() external onlyOwner {
      assert(owner.send(this.balance));
    }
  }
  
  contract HasNoTokens is CanReclaimToken {
  
   /**
    * @dev Reject all ERC223 compatible tokens
    * @param from_ address The address that is transferring the tokens
    * @param value_ uint256 the amount of the specified token
    * @param data_ Bytes The data passed from the caller.
    */
    function tokenFallback(address from_, uint256 value_, bytes data_) external {
      from_;
      value_;
      data_;
      revert();
    }
  
  }
  
  contract NoOwner is HasNoEther, HasNoTokens, HasNoContracts {
  }
  
  contract AllowanceSheet is Claimable {
      using SafeMath for uint256;
  
      mapping (address => mapping (address => uint256)) public allowanceOf;
  
      function addAllowance(address tokenHolder, address spender, uint256 value) public onlyOwner {
          allowanceOf[tokenHolder][spender] = allowanceOf[tokenHolder][spender].add(value);
      }
  
      function subAllowance(address tokenHolder, address spender, uint256 value) public onlyOwner {
          allowanceOf[tokenHolder][spender] = allowanceOf[tokenHolder][spender].sub(value);
      }
  
      function setAllowance(address tokenHolder, address spender, uint256 value) public onlyOwner {
          allowanceOf[tokenHolder][spender] = value;
      }
  }
  
  contract BalanceSheet is Claimable {
      using SafeMath for uint256;
  
      mapping (address => uint256) public balanceOf;
  
      function addBalance(address addr, uint256 value) public onlyOwner {
          balanceOf[addr] = balanceOf[addr].add(value);
      }
  
      function subBalance(address addr, uint256 value) public onlyOwner {
          balanceOf[addr] = balanceOf[addr].sub(value);
      }
  
      function setBalance(address addr, uint256 value) public onlyOwner {
          balanceOf[addr] = value;
      }
  }
  
  contract ERC20Basic {
    function totalSupply() public view returns (uint256);
    function balanceOf(address who) public view returns (uint256);
    function transfer(address to, uint256 value) public returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
  }
  
  contract BasicToken is ERC20Basic, Claimable {
    using SafeMath for uint256;
  
    BalanceSheet public balances;
  
    uint256 totalSupply_;
  
    function setBalanceSheet(address sheet) external onlyOwner {
      balances = BalanceSheet(sheet);
      balances.claimOwnership();
    }
  
    /**
    * @dev total number of tokens in existence
    */
    function totalSupply() public view returns (uint256) {
      return totalSupply_;
    }
  
    /**
    * @dev transfer token for a specified address
    * @param _to The address to transfer to.
    * @param _value The amount to be transferred.
    */
    function transfer(address _to, uint256 _value) public returns (bool) {
      transferAllArgsNoAllowance(msg.sender, _to, _value);
      return true;
    }
  
    function transferAllArgsNoAllowance(address _from, address _to, uint256 _value) internal {
      require(_to != address(0));
      require(_from != address(0));
      require(_value <= balances.balanceOf(_from));
  
      // SafeMath.sub will throw if there is not enough balance.
      balances.subBalance(_from, _value);
      balances.addBalance(_to, _value);
      Transfer(_from, _to, _value);
    }
  
    /**
    * @dev Gets the balance of the specified address.
    * @param _owner The address to query the the balance of.
    * @return An uint256 representing the amount owned by the passed address.
    */
    function balanceOf(address _owner) public view returns (uint256 balance) {
      return balances.balanceOf(_owner);
    }
  }
  
  contract BurnableToken is BasicToken {
  
    event Burn(address indexed burner, uint256 value);
  
    /**
     * @dev Burns a specific amount of tokens.
     * @param _value The amount of token to be burned.
     */
    function burn(uint256 _value) public {
      require(_value <= balances.balanceOf(msg.sender));
      // no need to require value &lt;= totalSupply, since that would imply the
      // sender&#39;s balance is greater than the totalSupply, which *should* be an assertion failure
  
      address burner = msg.sender;
      balances.subBalance(burner, _value);
      totalSupply_ = totalSupply_.sub(_value);
      Burn(burner, _value);
      Transfer(burner, address(0), _value);
    }
  }
  
  contract ERC20 is ERC20Basic {
    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);
  }
  
  library SafeERC20 {
    function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
      assert(token.transfer(to, value));
    }
  
    function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
      assert(token.transferFrom(from, to, value));
    }
  
    function safeApprove(ERC20 token, address spender, uint256 value) internal {
      assert(token.approve(spender, value));
    }
  }
  
  contract StandardToken is ERC20, BasicToken {
  
    AllowanceSheet public allowances;
  
    function setAllowanceSheet(address sheet) external onlyOwner {
      allowances = AllowanceSheet(sheet);
      allowances.claimOwnership();
    }
  
    /**
     * @dev Transfer tokens from one address to another
     * @param _from address The address which you want to send tokens from
     * @param _to address The address which you want to transfer to
     * @param _value uint256 the amount of tokens to be transferred
     */
    function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
      transferAllArgsYesAllowance(_from, _to, _value, msg.sender);
      return true;
    }
  
    function transferAllArgsYesAllowance(address _from, address _to, uint256 _value, address spender) internal {
      require(_value <= allowances.allowanceOf(_from, spender));
  
      allowances.subAllowance(_from, spender, _value);
      transferAllArgsNoAllowance(_from, _to, _value);
    }
  
    /**
     * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
     *
     * Beware that changing an allowance with this method brings the risk that someone may use both the old
     * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
     * race condition is to first reduce the spender&#39;s allowance to 0 and set the desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     * @param _spender The address which will spend the funds.
     * @param _value The amount of tokens to be spent.
     */
    function approve(address _spender, uint256 _value) public returns (bool) {
      approveAllArgs(_spender, _value, msg.sender);
      return true;
    }
  
    function approveAllArgs(address _spender, uint256 _value, address _tokenHolder) internal {
      allowances.setAllowance(_tokenHolder, _spender, _value);
      Approval(_tokenHolder, _spender, _value);
    }
  
    /**
     * @dev Function to check the amount of tokens that an owner allowed to a spender.
     * @param _owner address The address which owns the funds.
     * @param _spender address The address which will spend the funds.
     * @return A uint256 specifying the amount of tokens still available for the spender.
     */
    function allowance(address _owner, address _spender) public view returns (uint256) {
      return allowances.allowanceOf(_owner, _spender);
    }
  
    /**
     * @dev Increase the amount of tokens that an owner allowed to a spender.
     *
     * approve should be called when allowed[_spender] == 0. To increment
     * allowed value is better to use this function to avoid 2 calls (and wait until
     * the first transaction is mined)
     * From MonolithDAO Token.sol
     * @param _spender The address which will spend the funds.
     * @param _addedValue The amount of tokens to increase the allowance by.
     */
    function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
      increaseApprovalAllArgs(_spender, _addedValue, msg.sender);
      return true;
    }
  
    function increaseApprovalAllArgs(address _spender, uint _addedValue, address tokenHolder) internal {
      allowances.addAllowance(tokenHolder, _spender, _addedValue);
      Approval(tokenHolder, _spender, allowances.allowanceOf(tokenHolder, _spender));
    }
  
    /**
     * @dev Decrease the amount of tokens that an owner allowed to a spender.
     *
     * approve should be called when allowed[_spender] == 0. To decrement
     * allowed value is better to use this function to avoid 2 calls (and wait until
     * the first transaction is mined)
     * From MonolithDAO Token.sol
     * @param _spender The address which will spend the funds.
     * @param _subtractedValue The amount of tokens to decrease the allowance by.
     */
    function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
      decreaseApprovalAllArgs(_spender, _subtractedValue, msg.sender);
      return true;
    }
  
    function decreaseApprovalAllArgs(address _spender, uint _subtractedValue, address tokenHolder) internal {
      uint oldValue = allowances.allowanceOf(tokenHolder, _spender);
      if (_subtractedValue > oldValue) {
        allowances.setAllowance(tokenHolder, _spender, 0);
      } else {
        allowances.subAllowance(tokenHolder, _spender, _subtractedValue);
      }
      Approval(tokenHolder, _spender, allowances.allowanceOf(tokenHolder, _spender));
    }
  
  }
  
  contract CanDelegate is StandardToken {
      // If this contract needs to be upgraded, the new contract will be stored
      // in &#39;delegate&#39; and any ERC20 calls to this contract will be delegated to that one.
      DelegateERC20 public delegate;
  
      event DelegatedTo(address indexed newContract);
  
      // Can undelegate by passing in newContract = address(0)
      function delegateToNewContract(DelegateERC20 newContract) public onlyOwner {
          delegate = newContract;
          DelegatedTo(delegate);
      }
  
      // If a delegate has been designated, all ERC20 calls are forwarded to it
      function transfer(address to, uint256 value) public returns (bool) {
          if (delegate == address(0)) {
              return super.transfer(to, value);
          } else {
              return delegate.delegateTransfer(to, value, msg.sender);
          }
      }
  
      function transferFrom(address from, address to, uint256 value) public returns (bool) {
          if (delegate == address(0)) {
              return super.transferFrom(from, to, value);
          } else {
              return delegate.delegateTransferFrom(from, to, value, msg.sender);
          }
      }
  
      function balanceOf(address who) public view returns (uint256) {
          if (delegate == address(0)) {
              return super.balanceOf(who);
          } else {
              return delegate.delegateBalanceOf(who);
          }
      }
  
      function approve(address spender, uint256 value) public returns (bool) {
          if (delegate == address(0)) {
              return super.approve(spender, value);
          } else {
              return delegate.delegateApprove(spender, value, msg.sender);
          }
      }
  
      function allowance(address _owner, address spender) public view returns (uint256) {
          if (delegate == address(0)) {
              return super.allowance(_owner, spender);
          } else {
              return delegate.delegateAllowance(_owner, spender);
          }
      }
  
      function totalSupply() public view returns (uint256) {
          if (delegate == address(0)) {
              return super.totalSupply();
          } else {
              return delegate.delegateTotalSupply();
          }
      }
  
      function increaseApproval(address spender, uint addedValue) public returns (bool) {
          if (delegate == address(0)) {
              return super.increaseApproval(spender, addedValue);
          } else {
              return delegate.delegateIncreaseApproval(spender, addedValue, msg.sender);
          }
      }
  
      function decreaseApproval(address spender, uint subtractedValue) public returns (bool) {
          if (delegate == address(0)) {
              return super.decreaseApproval(spender, subtractedValue);
          } else {
              return delegate.delegateDecreaseApproval(spender, subtractedValue, msg.sender);
          }
      }
  }
  
  contract StandardDelegate is StandardToken, DelegateERC20 {
      address public delegatedFrom;
  
      modifier onlySender(address source) {
          require(msg.sender == source);
          _;
      }
  
      function setDelegatedFrom(address addr) onlyOwner public {
          delegatedFrom = addr;
      }
  
      // All delegate ERC20 functions are forwarded to corresponding normal functions
      function delegateTotalSupply() public view returns (uint256) {
          return totalSupply();
      }
  
      function delegateBalanceOf(address who) public view returns (uint256) {
          return balanceOf(who);
      }
  
      function delegateTransfer(address to, uint256 value, address origSender) onlySender(delegatedFrom) public returns (bool) {
          transferAllArgsNoAllowance(origSender, to, value);
          return true;
      }
  
      function delegateAllowance(address owner, address spender) public view returns (uint256) {
          return allowance(owner, spender);
      }
  
      function delegateTransferFrom(address from, address to, uint256 value, address origSender) onlySender(delegatedFrom) public returns (bool) {
          transferAllArgsYesAllowance(from, to, value, origSender);
          return true;
      }
  
      function delegateApprove(address spender, uint256 value, address origSender) onlySender(delegatedFrom) public returns (bool) {
          approveAllArgs(spender, value, origSender);
          return true;
      }
  
      function delegateIncreaseApproval(address spender, uint addedValue, address origSender) onlySender(delegatedFrom) public returns (bool) {
          increaseApprovalAllArgs(spender, addedValue, origSender);
          return true;
      }
  
      function delegateDecreaseApproval(address spender, uint subtractedValue, address origSender) onlySender(delegatedFrom) public returns (bool) {
          decreaseApprovalAllArgs(spender, subtractedValue, origSender);
          return true;
      }
  }
  
  contract PausableToken is StandardToken, Pausable {
  
    function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
      return super.transfer(_to, _value);
    }
  
    function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
      return super.transferFrom(_from, _to, _value);
    }
  
    function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
      return super.approve(_spender, _value);
    }
  
    function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
      return super.increaseApproval(_spender, _addedValue);
    }
  
    function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
      return super.decreaseApproval(_spender, _subtractedValue);
    }
  }
  
  contract TrueUSD is StandardDelegate, PausableToken, BurnableToken, NoOwner, CanDelegate {
      string public name = "Tether USD";
      string public symbol = "USDT";
      uint8 public constant decimals = 18;
  
      AddressList public canReceiveMintWhiteList;
      AddressList public canBurnWhiteList;
      AddressList public blackList;
      AddressList public noFeesList;
      uint256 public burnMin = 10000 * 10**uint256(decimals);
      uint256 public burnMax = 20000000 * 10**uint256(decimals);
  
      uint80 public transferFeeNumerator = 7;
      uint80 public transferFeeDenominator = 10000;
      uint80 public mintFeeNumerator = 0;
      uint80 public mintFeeDenominator = 10000;
      uint256 public mintFeeFlat = 0;
      uint80 public burnFeeNumerator = 0;
      uint80 public burnFeeDenominator = 10000;
      uint256 public burnFeeFlat = 0;
      address public staker;
  
      event ChangeBurnBoundsEvent(uint256 newMin, uint256 newMax);
      event Mint(address indexed to, uint256 amount);
      event WipedAccount(address indexed account, uint256 balance);
  
      function TrueUSD() public {
          totalSupply_ = 0;
          staker = msg.sender;
      }
  
      function setLists(AddressList _canReceiveMintWhiteList, AddressList _canBurnWhiteList, AddressList _blackList, AddressList _noFeesList) onlyOwner public {
          canReceiveMintWhiteList = _canReceiveMintWhiteList;
          canBurnWhiteList = _canBurnWhiteList;
          blackList = _blackList;
          noFeesList = _noFeesList;
      }
  
      function changeName(string _name, string _symbol) onlyOwner public {
          name = _name;
          symbol = _symbol;
      }
  
      //Burning functions as withdrawing money from the system. The platform will keep track of who burns coins,
      //and will send them back the equivalent amount of money (rounded down to the nearest cent).
      function burn(uint256 _value) public {
          require(canBurnWhiteList.onList(msg.sender));
          require(_value >= burnMin);
          require(_value <= burnMax);
          uint256 fee = payStakingFee(msg.sender, _value, burnFeeNumerator, burnFeeDenominator, burnFeeFlat, 0x0);
          uint256 remaining = _value.sub(fee);
          super.burn(remaining);
      }
  
      //Create _amount new tokens and transfer them to _to.
      //Based on code by OpenZeppelin: https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/token/MintableToken.sol
      function mint(address _to, uint256 _amount) onlyOwner public {
          require(canReceiveMintWhiteList.onList(_to));
          totalSupply_ = totalSupply_.add(_amount);
          balances.addBalance(_to, _amount);
          Mint(_to, _amount);
          Transfer(address(0), _to, _amount);
          payStakingFee(_to, _amount, mintFeeNumerator, mintFeeDenominator, mintFeeFlat, 0x0);
      }
  
      //Change the minimum and maximum amount that can be burned at once. Burning
      //may be disabled by setting both to 0 (this will not be done under normal
      //operation, but we can&#39;t add checks to disallow it without losing a lot of
      //flexibility since burning could also be as good as disabled
      //by setting the minimum extremely high, and we don&#39;t want to lock
      //in any particular cap for the minimum)
      function changeBurnBounds(uint newMin, uint newMax) onlyOwner public {
          require(newMin <= newMax);
          burnMin = newMin;
          burnMax = newMax;
          ChangeBurnBoundsEvent(newMin, newMax);
      }
  
      // transfer and transferFrom are both dispatched to this function, so we
      // check blacklist and pay staking fee here.
      function transferAllArgsNoAllowance(address _from, address _to, uint256 _value) internal {
          require(!blackList.onList(_from));
          require(!blackList.onList(_to));
          super.transferAllArgsNoAllowance(_from, _to, _value);
          payStakingFee(_to, _value, transferFeeNumerator, transferFeeDenominator, 0, _from);
      }
  
      function wipeBlacklistedAccount(address account) public onlyOwner {
          require(blackList.onList(account));
          uint256 oldValue = balanceOf(account);
          balances.setBalance(account, 0);
          totalSupply_ = totalSupply_.sub(oldValue);
          WipedAccount(account, oldValue);
      }
  
      function payStakingFee(address payer, uint256 value, uint80 numerator, uint80 denominator, uint256 flatRate, address otherParticipant) private returns (uint256) {
          if (noFeesList.onList(payer) || noFeesList.onList(otherParticipant)) {
              return 0;
          }
          uint256 stakingFee = value.mul(numerator).div(denominator).add(flatRate);
          if (stakingFee > 0) {
              super.transferAllArgsNoAllowance(payer, staker, stakingFee);
          }
          return stakingFee;
      }
  
      function changeStakingFees(uint80 _transferFeeNumerator,
                                   uint80 _transferFeeDenominator,
                                   uint80 _mintFeeNumerator,
                                   uint80 _mintFeeDenominator,
                                   uint256 _mintFeeFlat,
                                   uint80 _burnFeeNumerator,
                                   uint80 _burnFeeDenominator,
                                   uint256 _burnFeeFlat) public onlyOwner {
          require(_transferFeeDenominator != 0);
          require(_mintFeeDenominator != 0);
          require(_burnFeeDenominator != 0);
          transferFeeNumerator = _transferFeeNumerator;
          transferFeeDenominator = _transferFeeDenominator;
          mintFeeNumerator = _mintFeeNumerator;
          mintFeeDenominator = _mintFeeDenominator;
          mintFeeFlat = _mintFeeFlat;
          burnFeeNumerator = _burnFeeNumerator;
          burnFeeDenominator = _burnFeeDenominator;
          burnFeeFlat = _burnFeeFlat;
      }
  
      function changeStaker(address newStaker) public onlyOwner {
          require(newStaker != address(0));
          staker = newStaker;
      }
  }