ETH Price: $3,840.58 (+2.54%)
Gas: 3 Gwei

Token

XBullion Silver (SILV)
 

Overview

Max Total Supply

26,192.53883755 SILV

Holders

9

Total Transfers

-

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

-

Other Info

Token Contract (WITH 8 Decimals)

Loading...
Loading
Loading...
Loading
Loading...
Loading

Click here to update the token information / general information
# Exchange Pair Price  24H Volume % Volume

Contract Source Code Verified (Exact Match)

Contract Name:
XBullionToken

Compiler Version
v0.5.17+commit.d19bba13

Optimization Enabled:
Yes with 999999 runs

Other Settings:
default evmVersion, Unlicense license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2021-02-22
*/

/**
 *Submitted for verification at Etherscan.io on 2020-06-30
*/

pragma solidity ^0.5.13;
pragma experimental ABIEncoderV2;





contract ERC20Interface {
    event Approval(address indexed owner, address indexed spender, uint256 amount);
    event Burn(address indexed from, uint256 amount);
    event Mint(address indexed to, uint256 amount);
    event Transfer(address indexed from, address indexed to, uint256 amount);

    function allowance(address _owner, address _spender) public view returns (uint256 remaining);
    function approve(address _spender, uint256 _amount) public returns (bool success);
    function balanceOf(address _owner) public view returns (uint256 balance);
    function transfer(address _to, uint256 _amount) public returns (bool success);
    function transferFrom(address _from, address _to, uint256 _amount) public returns (bool success);

    function decimals() public view returns (uint8);
    function name() public view returns (string memory);
    function symbol() public view returns (string memory);
    function totalSupply() public view returns (uint256);
}

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SafeMath: subtraction overflow");
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     * - Multiplication cannot overflow.
     */
    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-solidity/pull/522
        if (a == 0) {
            return 0;
        }

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

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, "SafeMath: division by zero");
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b != 0, "SafeMath: modulo by zero");
        return a % b;
    }
}

contract ERC20 is ERC20Interface {
    using SafeMath for uint256;

    string  internal tokenName;
    string  internal tokenSymbol;
    uint8   internal tokenDecimals;
    uint256 internal tokenTotalSupply;

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

    constructor(string memory _name, string memory _symbol, uint8 _decimals, uint256 _totalSupply)
        internal
    {
        tokenName = _name;
        tokenSymbol = _symbol;
        tokenDecimals = _decimals;
        _mint(msg.sender, _totalSupply);
    }

    function approve(address _spender, uint256 _amount)
        public
        returns (bool success)
    {
        _approve(msg.sender, _spender, _amount);
        return true;
    }

    function decreaseAllowance(address _spender, uint256 _delta)
        public
        returns (bool success)
    {
        _approve(msg.sender, _spender, allowed[msg.sender][_spender].sub(_delta));
        return true;
    }

    function increaseAllowance(address _spender, uint256 _delta)
        public
        returns (bool success)
    {
        _approve(msg.sender, _spender, allowed[msg.sender][_spender].add(_delta));
        return true;
    }

    function transfer(address _to, uint256 _amount)
        public
        returns (bool success)
    {
        _transfer(msg.sender, _to, _amount);
        return true;
    }

    function transferFrom(address _from, address _to, uint256 _amount)
        public
        returns (bool success)
    {
        _transfer(_from, _to, _amount);
        _approve(_from, msg.sender, allowed[_from][msg.sender].sub(_amount));
        return true;
    }

    function allowance(address _owner, address _spender)
        public
        view
        returns (uint256 remaining)
    {
        return allowed[_owner][_spender];
    }

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

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

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

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

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

    function _approve(address _owner, address _spender, uint256 _amount)
        internal
    {
        allowed[_owner][_spender] = _amount;
        emit Approval(_owner, _spender, _amount);
    }

    function _burn(address _from, uint256 _amount)
        internal
    {
        balances[_from] = balances[_from].sub(_amount);
        tokenTotalSupply = tokenTotalSupply.sub(_amount);

        emit Transfer(_from, address(0), _amount);
        emit Burn(_from, _amount);
    }

    function _mint(address _to, uint256 _amount)
        internal
    {
        require(_to != address(0), "ERC20: mint to the zero address");
        require(_to != address(this), "ERC20: mint to token contract");

        tokenTotalSupply = tokenTotalSupply.add(_amount);
        balances[_to] = balances[_to].add(_amount);

        emit Transfer(address(0), _to, _amount);
        emit Mint(_to, _amount);
    }

    function _transfer(address _from, address _to, uint256 _amount)
        internal
    {
        require(_to != address(0), "ERC20: transfer to the zero address");
        require(_to != address(this), "ERC20: transfer to token contract");

        balances[_from] = balances[_from].sub(_amount);
        balances[_to] = balances[_to].add(_amount);
        emit Transfer(_from, _to, _amount);
    }
}

library AddressSet
{
    struct addrset
    {
        mapping(address => uint) index;
        address[] elements;
    }

    function insert(addrset storage self, address e)
        internal
        returns (bool success)
    {
        if (self.index[e] > 0) {
            return false;
        } else {
            self.index[e] = self.elements.push(e);
            return true;
        }
    }

    function remove(addrset storage self, address e)
        internal
        returns (bool success)
    {
        uint index = self.index[e];
        if (index == 0) {
            return false;
        } else {
            address e0 = self.elements[self.elements.length - 1];
            self.elements[index - 1] = e0;
            self.elements.pop();
            self.index[e0] = index;
            delete self.index[e];
            return true;
        }
    }

    function has(addrset storage self, address e)
        internal
        view
        returns (bool)
    {
        return self.index[e] > 0;
    }
}

/**
 * Smart contract library of mathematical functions operating with signed
 * 64.64-bit fixed point numbers.
 */
library Math64x64 {
  /**
   * Minimum value signed 64.64-bit fixed point number may have. 
   */
  int128 private constant MIN_64x64 = -0x80000000000000000000000000000000;

  /**
   * Maximum value signed 64.64-bit fixed point number may have. 
   */
  int128 private constant MAX_64x64 = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;

  /**
   * Convert signed 256-bit integer number into signed 64.64-bit fixed point
   * number.  Revert on overflow.
   *
   * @param x signed 256-bit integer number
   * @return signed 64.64-bit fixed point number
   */
  function fromInt (int256 x) internal pure returns (int128) {
    require (x >= -0x8000000000000000 && x <= 0x7FFFFFFFFFFFFFFF);
    return int128 (x << 64);
  }

  /**
   * Convert signed 64.64 fixed point number into signed 64-bit integer number
   * rounding down.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64-bit integer number
   */
  function toInt (int128 x) internal pure returns (int64) {
    return int64 (x >> 64);
  }

  /**
   * Convert unsigned 256-bit integer number into signed 64.64-bit fixed point
   * number.  Revert on overflow.
   *
   * @param x unsigned 256-bit integer number
   * @return signed 64.64-bit fixed point number
   */
  function fromUInt (uint256 x) internal pure returns (int128) {
    require (x <= 0x7FFFFFFFFFFFFFFF);
    return int128 (x << 64);
  }

  /**
   * Convert signed 64.64 fixed point number into unsigned 64-bit integer
   * number rounding down.  Revert on underflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @return unsigned 64-bit integer number
   */
  function toUInt (int128 x) internal pure returns (uint64) {
    require (x >= 0);
    return uint64 (x >> 64);
  }

  /**
   * Convert signed 128.128 fixed point number into signed 64.64-bit fixed point
   * number rounding down.  Revert on overflow.
   *
   * @param x signed 128.128-bin fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function from128x128 (int256 x) internal pure returns (int128) {
    int256 result = x >> 64;
    require (result >= MIN_64x64 && result <= MAX_64x64);
    return int128 (result);
  }

  /**
   * Convert signed 64.64 fixed point number into signed 128.128 fixed point
   * number.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 128.128 fixed point number
   */
  function to128x128 (int128 x) internal pure returns (int256) {
    return int256 (x) << 64;
  }

  /**
   * Calculate x + y.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function add (int128 x, int128 y) internal pure returns (int128) {
    int256 result = int256(x) + y;
    require (result >= MIN_64x64 && result <= MAX_64x64);
    return int128 (result);
  }

  /**
   * Calculate x - y.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function sub (int128 x, int128 y) internal pure returns (int128) {
    int256 result = int256(x) - y;
    require (result >= MIN_64x64 && result <= MAX_64x64);
    return int128 (result);
  }

  /**
   * Calculate x * y rounding down.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function mul (int128 x, int128 y) internal pure returns (int128) {
    int256 result = int256(x) * y >> 64;
    require (result >= MIN_64x64 && result <= MAX_64x64);
    return int128 (result);
  }

  /**
   * Calculate x * y rounding towards zero, where x is signed 64.64 fixed point
   * number and y is signed 256-bit integer number.  Revert on overflow.
   *
   * @param x signed 64.64 fixed point number
   * @param y signed 256-bit integer number
   * @return signed 256-bit integer number
   */
  function muli (int128 x, int256 y) internal pure returns (int256) {
    if (x == MIN_64x64) {
      require (y >= -0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF &&
        y <= 0x1000000000000000000000000000000000000000000000000);
      return -y << 63;
    } else {
      bool negativeResult = false;
      if (x < 0) {
        x = -x;
        negativeResult = true;
      }
      if (y < 0) {
        y = -y; // We rely on overflow behavior here
        negativeResult = !negativeResult;
      }
      uint256 absoluteResult = mulu (x, uint256 (y));
      if (negativeResult) {
        require (absoluteResult <=
          0x8000000000000000000000000000000000000000000000000000000000000000);
        return -int256 (absoluteResult); // We rely on overflow behavior here
      } else {
        require (absoluteResult <=
          0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
        return int256 (absoluteResult);
      }
    }
  }

  /**
   * Calculate x * y rounding down, where x is signed 64.64 fixed point number
   * and y is unsigned 256-bit integer number.  Revert on overflow.
   *
   * @param x signed 64.64 fixed point number
   * @param y unsigned 256-bit integer number
   * @return unsigned 256-bit integer number
   */
  function mulu (int128 x, uint256 y) internal pure returns (uint256) {
    if (y == 0) return 0;

    require (x >= 0);

    uint256 lo = (uint256 (x) * (y & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)) >> 64;
    uint256 hi = uint256 (x) * (y >> 128);

    require (hi <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
    hi <<= 64;

    require (hi <=
      0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF - lo);
    return hi + lo;
  }

  /**
   * Calculate x / y rounding towards zero.  Revert on overflow or when y is
   * zero.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function div (int128 x, int128 y) internal pure returns (int128) {
    require (y != 0);
    int256 result = (int256 (x) << 64) / y;
    require (result >= MIN_64x64 && result <= MAX_64x64);
    return int128 (result);
  }

  /**
   * Calculate x / y rounding towards zero, where x and y are signed 256-bit
   * integer numbers.  Revert on overflow or when y is zero.
   *
   * @param x signed 256-bit integer number
   * @param y signed 256-bit integer number
   * @return signed 64.64-bit fixed point number
   */
  function divi (int256 x, int256 y) internal pure returns (int128) {
    require (y != 0);

    bool negativeResult = false;
    if (x < 0) {
      x = -x; // We rely on overflow behavior here
      negativeResult = true;
    }
    if (y < 0) {
      y = -y; // We rely on overflow behavior here
      negativeResult = !negativeResult;
    }
    uint128 absoluteResult = divuu (uint256 (x), uint256 (y));
    if (negativeResult) {
      require (absoluteResult <= 0x80000000000000000000000000000000);
      return -int128 (absoluteResult); // We rely on overflow behavior here
    } else {
      require (absoluteResult <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
      return int128 (absoluteResult); // We rely on overflow behavior here
    }
  }

  /**
   * Calculate x / y rounding towards zero, where x and y are unsigned 256-bit
   * integer numbers.  Revert on overflow or when y is zero.
   *
   * @param x unsigned 256-bit integer number
   * @param y unsigned 256-bit integer number
   * @return signed 64.64-bit fixed point number
   */
  function divu (uint256 x, uint256 y) internal pure returns (int128) {
    require (y != 0);
    uint128 result = divuu (x, y);
    require (result <= uint128 (MAX_64x64));
    return int128 (result);
  }

  /**
   * Calculate -x.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function neg (int128 x) internal pure returns (int128) {
    require (x != MIN_64x64);
    return -x;
  }

  /**
   * Calculate |x|.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function abs (int128 x) internal pure returns (int128) {
    require (x != MIN_64x64);
    return x < 0 ? -x : x;
  }

  /**
   * Calculate 1 / x rounding towards zero.  Revert on overflow or when x is
   * zero.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function inv (int128 x) internal pure returns (int128) {
    require (x != 0);
    int256 result = int256 (0x100000000000000000000000000000000) / x;
    require (result >= MIN_64x64 && result <= MAX_64x64);
    return int128 (result);
  }

  /**
   * Calculate arithmetics average of x and y, i.e. (x + y) / 2 rounding down.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function avg (int128 x, int128 y) internal pure returns (int128) {
    return int128 ((int256 (x) + int256 (y)) >> 1);
  }

  /**
   * Calculate geometric average of x and y, i.e. sqrt (x * y) rounding down.
   * Revert on overflow or in case x * y is negative.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function gavg (int128 x, int128 y) internal pure returns (int128) {
    int256 m = int256 (x) * int256 (y);
    require (m >= 0);
    require (m <
        0x4000000000000000000000000000000000000000000000000000000000000000);
    return int128 (sqrtu (uint256 (m), uint256 (x) + uint256 (y) >> 1));
  }

  /**
   * Calculate x^y assuming 0^0 is 1, where x is signed 64.64 fixed point number
   * and y is unsigned 256-bit integer number.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y uint256 value
   * @return signed 64.64-bit fixed point number
   */
  function pow (int128 x, uint256 y) internal pure returns (int128) {
    uint256 absoluteResult;
    bool negativeResult = false;
    if (x >= 0) {
      absoluteResult = powu (uint256 (x) << 63, y);
    } else {
      // We rely on overflow behavior here
      absoluteResult = powu (uint256 (uint128 (-x)) << 63, y);
      negativeResult = y & 1 > 0;
    }

    absoluteResult >>= 63;

    if (negativeResult) {
      require (absoluteResult <= 0x80000000000000000000000000000000);
      return -int128 (absoluteResult); // We rely on overflow behavior here
    } else {
      require (absoluteResult <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
      return int128 (absoluteResult); // We rely on overflow behavior here
    }
  }

  /**
   * Calculate sqrt (x) rounding down.  Revert if x < 0.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function sqrt (int128 x) internal pure returns (int128) {
    require (x >= 0);
    return int128 (sqrtu (uint256 (x) << 64, 0x10000000000000000));
  }

  /**
   * Calculate binary logarithm of x.  Revert if x <= 0.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function log_2 (int128 x) internal pure returns (int128) {
    require (x > 0);

    int256 msb = 0;
    int256 xc = x;
    if (xc >= 0x10000000000000000) { xc >>= 64; msb += 64; }
    if (xc >= 0x100000000) { xc >>= 32; msb += 32; }
    if (xc >= 0x10000) { xc >>= 16; msb += 16; }
    if (xc >= 0x100) { xc >>= 8; msb += 8; }
    if (xc >= 0x10) { xc >>= 4; msb += 4; }
    if (xc >= 0x4) { xc >>= 2; msb += 2; }
    if (xc >= 0x2) msb += 1;  // No need to shift xc anymore

    int256 result = msb - 64 << 64;
    uint256 ux = uint256 (x) << 127 - msb;
    for (int256 bit = 0x8000000000000000; bit > 0; bit >>= 1) {
      ux *= ux;
      uint256 b = ux >> 255;
      ux >>= 127 + b;
      result += bit * int256 (b);
    }

    return int128 (result);
  }

  /**
   * Calculate natural logarithm of x.  Revert if x <= 0.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function ln (int128 x) internal pure returns (int128) {
    require (x > 0);

    return int128 (
        uint256 (log_2 (x)) * 0xB17217F7D1CF79ABC9E3B39803F2F6AF >> 128);
  }

  /**
   * Calculate binary exponent of x.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function exp_2 (int128 x) internal pure returns (int128) {
    require (x < 0x400000000000000000); // Overflow

    if (x < -0x400000000000000000) return 0; // Underflow

    uint256 result = 0x80000000000000000000000000000000;

    if (x & 0x8000000000000000 > 0)
      result = result * 0x16A09E667F3BCC908B2FB1366EA957D3E >> 128;
    if (x & 0x4000000000000000 > 0)
      result = result * 0x1306FE0A31B7152DE8D5A46305C85EDEC >> 128;
    if (x & 0x2000000000000000 > 0)
      result = result * 0x1172B83C7D517ADCDF7C8C50EB14A791F >> 128;
    if (x & 0x1000000000000000 > 0)
      result = result * 0x10B5586CF9890F6298B92B71842A98363 >> 128;
    if (x & 0x800000000000000 > 0)
      result = result * 0x1059B0D31585743AE7C548EB68CA417FD >> 128;
    if (x & 0x400000000000000 > 0)
      result = result * 0x102C9A3E778060EE6F7CACA4F7A29BDE8 >> 128;
    if (x & 0x200000000000000 > 0)
      result = result * 0x10163DA9FB33356D84A66AE336DCDFA3F >> 128;
    if (x & 0x100000000000000 > 0)
      result = result * 0x100B1AFA5ABCBED6129AB13EC11DC9543 >> 128;
    if (x & 0x80000000000000 > 0)
      result = result * 0x10058C86DA1C09EA1FF19D294CF2F679B >> 128;
    if (x & 0x40000000000000 > 0)
      result = result * 0x1002C605E2E8CEC506D21BFC89A23A00F >> 128;
    if (x & 0x20000000000000 > 0)
      result = result * 0x100162F3904051FA128BCA9C55C31E5DF >> 128;
    if (x & 0x10000000000000 > 0)
      result = result * 0x1000B175EFFDC76BA38E31671CA939725 >> 128;
    if (x & 0x8000000000000 > 0)
      result = result * 0x100058BA01FB9F96D6CACD4B180917C3D >> 128;
    if (x & 0x4000000000000 > 0)
      result = result * 0x10002C5CC37DA9491D0985C348C68E7B3 >> 128;
    if (x & 0x2000000000000 > 0)
      result = result * 0x1000162E525EE054754457D5995292026 >> 128;
    if (x & 0x1000000000000 > 0)
      result = result * 0x10000B17255775C040618BF4A4ADE83FC >> 128;
    if (x & 0x800000000000 > 0)
      result = result * 0x1000058B91B5BC9AE2EED81E9B7D4CFAB >> 128;
    if (x & 0x400000000000 > 0)
      result = result * 0x100002C5C89D5EC6CA4D7C8ACC017B7C9 >> 128;
    if (x & 0x200000000000 > 0)
      result = result * 0x10000162E43F4F831060E02D839A9D16D >> 128;
    if (x & 0x100000000000 > 0)
      result = result * 0x100000B1721BCFC99D9F890EA06911763 >> 128;
    if (x & 0x80000000000 > 0)
      result = result * 0x10000058B90CF1E6D97F9CA14DBCC1628 >> 128;
    if (x & 0x40000000000 > 0)
      result = result * 0x1000002C5C863B73F016468F6BAC5CA2B >> 128;
    if (x & 0x20000000000 > 0)
      result = result * 0x100000162E430E5A18F6119E3C02282A5 >> 128;
    if (x & 0x10000000000 > 0)
      result = result * 0x1000000B1721835514B86E6D96EFD1BFE >> 128;
    if (x & 0x8000000000 > 0)
      result = result * 0x100000058B90C0B48C6BE5DF846C5B2EF >> 128;
    if (x & 0x4000000000 > 0)
      result = result * 0x10000002C5C8601CC6B9E94213C72737A >> 128;
    if (x & 0x2000000000 > 0)
      result = result * 0x1000000162E42FFF037DF38AA2B219F06 >> 128;
    if (x & 0x1000000000 > 0)
      result = result * 0x10000000B17217FBA9C739AA5819F44F9 >> 128;
    if (x & 0x800000000 > 0)
      result = result * 0x1000000058B90BFCDEE5ACD3C1CEDC823 >> 128;
    if (x & 0x400000000 > 0)
      result = result * 0x100000002C5C85FE31F35A6A30DA1BE50 >> 128;
    if (x & 0x200000000 > 0)
      result = result * 0x10000000162E42FF0999CE3541B9FFFCF >> 128;
    if (x & 0x100000000 > 0)
      result = result * 0x100000000B17217F80F4EF5AADDA45554 >> 128;
    if (x & 0x80000000 > 0)
      result = result * 0x10000000058B90BFBF8479BD5A81B51AD >> 128;
    if (x & 0x40000000 > 0)
      result = result * 0x1000000002C5C85FDF84BD62AE30A74CC >> 128;
    if (x & 0x20000000 > 0)
      result = result * 0x100000000162E42FEFB2FED257559BDAA >> 128;
    if (x & 0x10000000 > 0)
      result = result * 0x1000000000B17217F7D5A7716BBA4A9AE >> 128;
    if (x & 0x8000000 > 0)
      result = result * 0x100000000058B90BFBE9DDBAC5E109CCE >> 128;
    if (x & 0x4000000 > 0)
      result = result * 0x10000000002C5C85FDF4B15DE6F17EB0D >> 128;
    if (x & 0x2000000 > 0)
      result = result * 0x1000000000162E42FEFA494F1478FDE05 >> 128;
    if (x & 0x1000000 > 0)
      result = result * 0x10000000000B17217F7D20CF927C8E94C >> 128;
    if (x & 0x800000 > 0)
      result = result * 0x1000000000058B90BFBE8F71CB4E4B33D >> 128;
    if (x & 0x400000 > 0)
      result = result * 0x100000000002C5C85FDF477B662B26945 >> 128;
    if (x & 0x200000 > 0)
      result = result * 0x10000000000162E42FEFA3AE53369388C >> 128;
    if (x & 0x100000 > 0)
      result = result * 0x100000000000B17217F7D1D351A389D40 >> 128;
    if (x & 0x80000 > 0)
      result = result * 0x10000000000058B90BFBE8E8B2D3D4EDE >> 128;
    if (x & 0x40000 > 0)
      result = result * 0x1000000000002C5C85FDF4741BEA6E77E >> 128;
    if (x & 0x20000 > 0)
      result = result * 0x100000000000162E42FEFA39FE95583C2 >> 128;
    if (x & 0x10000 > 0)
      result = result * 0x1000000000000B17217F7D1CFB72B45E1 >> 128;
    if (x & 0x8000 > 0)
      result = result * 0x100000000000058B90BFBE8E7CC35C3F0 >> 128;
    if (x & 0x4000 > 0)
      result = result * 0x10000000000002C5C85FDF473E242EA38 >> 128;
    if (x & 0x2000 > 0)
      result = result * 0x1000000000000162E42FEFA39F02B772C >> 128;
    if (x & 0x1000 > 0)
      result = result * 0x10000000000000B17217F7D1CF7D83C1A >> 128;
    if (x & 0x800 > 0)
      result = result * 0x1000000000000058B90BFBE8E7BDCBE2E >> 128;
    if (x & 0x400 > 0)
      result = result * 0x100000000000002C5C85FDF473DEA871F >> 128;
    if (x & 0x200 > 0)
      result = result * 0x10000000000000162E42FEFA39EF44D91 >> 128;
    if (x & 0x100 > 0)
      result = result * 0x100000000000000B17217F7D1CF79E949 >> 128;
    if (x & 0x80 > 0)
      result = result * 0x10000000000000058B90BFBE8E7BCE544 >> 128;
    if (x & 0x40 > 0)
      result = result * 0x1000000000000002C5C85FDF473DE6ECA >> 128;
    if (x & 0x20 > 0)
      result = result * 0x100000000000000162E42FEFA39EF366F >> 128;
    if (x & 0x10 > 0)
      result = result * 0x1000000000000000B17217F7D1CF79AFA >> 128;
    if (x & 0x8 > 0)
      result = result * 0x100000000000000058B90BFBE8E7BCD6D >> 128;
    if (x & 0x4 > 0)
      result = result * 0x10000000000000002C5C85FDF473DE6B2 >> 128;
    if (x & 0x2 > 0)
      result = result * 0x1000000000000000162E42FEFA39EF358 >> 128;
    if (x & 0x1 > 0)
      result = result * 0x10000000000000000B17217F7D1CF79AB >> 128;

    result >>= 63 - (x >> 64);
    require (result <= uint256 (MAX_64x64));

    return int128 (result);
  }

  /**
   * Calculate natural exponent of x.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function exp (int128 x) internal pure returns (int128) {
    require (x < 0x400000000000000000); // Overflow

    if (x < -0x400000000000000000) return 0; // Underflow

    return exp_2 (
        int128 (int256 (x) * 0x171547652B82FE1777D0FFDA0D23A7D12 >> 128));
  }

  /**
   * Calculate x / y rounding towards zero, where x and y are unsigned 256-bit
   * integer numbers.  Revert on overflow or when y is zero.
   *
   * @param x unsigned 256-bit integer number
   * @param y unsigned 256-bit integer number
   * @return unsigned 64.64-bit fixed point number
   */
  function divuu (uint256 x, uint256 y) private pure returns (uint128) {
    require (y != 0);

    uint256 result;

    if (x <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
      result = (x << 64) / y;
    else {
      uint256 a = 192;
      uint256 b = 255;
      while (a < b) {
        uint256 m = a + b >> 1;
        uint256 t = x >> m;
        if (t == 0) b = m - 1;
        else if (t > 1) a = m + 1;
        else {
          a = m;
          break;
        }
      }

      result = (x << 255 - a) / ((y - 1 >> a - 191) + 1);
      require (result <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);

      uint256 hi = result * (y >> 128);
      uint256 lo = result * (y & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);

      uint256 xh = x >> 192;
      uint256 xl = x << 64;

      if (xl < lo) xh -= 1;
      xl -= lo; // We rely on overflow behavior here
      lo = hi << 128;
      if (xl < lo) xh -= 1;
      xl -= lo; // We rely on overflow behavior here

      assert (xh == hi >> 128);

      result += xl / y;
    }

    require (result <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
    return uint128 (result);
  }

  /**
   * Calculate x^y assuming 0^0 is 1, where x is unsigned 129.127 fixed point
   * number and y is unsigned 256-bit integer number.  Revert on overflow.
   *
   * @param x unsigned 129.127-bit fixed point number
   * @param y uint256 value
   * @return unsigned 129.127-bit fixed point number
   */
  function powu (uint256 x, uint256 y) private pure returns (uint256) {
    if (y == 0) return 0x80000000000000000000000000000000;
    else if (x == 0) return 0;
    else {
      uint256 a = 0;
      uint256 b = 255;
      while (a < b) {
        uint256 m = a + b >> 1;
        uint256 t = x >> m;
        if (t == 0) b = m - 1;
        else if (t > 1) a = m + 1;
        else {
          a = m;
          break;
        }
      }

      int256 xe = int256 (a) - 127;
      if (xe > 0) x >>= xe;
      else x <<= -xe;

      uint256 result = 0x80000000000000000000000000000000;
      int256 re = 0;

      while (y > 0) {
        if (y & 1 > 0) {
          result = result * x;
          y -= 1;
          re += xe;
          if (result >=
            0x8000000000000000000000000000000000000000000000000000000000000000) {
            result >>= 128;
            re += 1;
          } else result >>= 127;
          if (re < -127) return 0; // Underflow
          require (re < 128); // Overflow
        } else {
          x = x * x;
          y >>= 1;
          xe <<= 1;
          if (x >=
            0x8000000000000000000000000000000000000000000000000000000000000000) {
            x >>= 128;
            xe += 1;
          } else x >>= 127;
          if (xe < -127) return 0; // Underflow
          require (xe < 128); // Overflow
        }
      }

      if (re > 0) result <<= re;
      else if (re < 0) result >>= -re;

      return result;
    }
  }

  /**
   * Calculate sqrt (x) rounding down, where x is unsigned 256-bit integer
   * number.
   *
   * @param x unsigned 256-bit integer number
   * @return unsigned 128-bit integer number
   */
  function sqrtu (uint256 x, uint256 r) private pure returns (uint128) {
    if (x == 0) return 0;
    else {
      require (r > 0);
      while (true) {
        uint256 rr = x / r;
        if (r == rr || r + 1 == rr) return uint128 (r);
        else if (r == rr + 1) return uint128 (rr);
        r = r + rr + 1 >> 1;
      }
    }
  }
}



contract OwnerRole {
    using AddressSet for AddressSet.addrset;

    AddressSet.addrset private owners;

    event OwnerAddition(address indexed addr);
    event OwnerRemoval(address indexed addr);

    modifier ifOwner(address _addr) {
        require(isOwner(_addr),
            "OwnerRole: specified account does not have the Owner role");
        _;
    }

    modifier onlyOwner() {
        require(isOwner(msg.sender),
            "OwnerRole: caller does not have the Owner role");
        _;
    }

    function getOwners()
        public
        view
        returns (address[] memory)
    {
        return owners.elements;
    }

    function isOwner(address _addr)
        public
        view
        returns (bool)
    {
        return owners.has(_addr);
    }

    function numOwners()
        public
        view
        returns (uint)
    {
        return owners.elements.length;
    }

    function _addOwner(address _addr)
        internal
    {
        require(owners.insert(_addr),
            "OwnerRole: duplicate bearer");
        emit OwnerAddition(_addr);
    }

    function _removeOwner(address _addr)
        internal
    {
        require(owners.remove(_addr),
            "OwnerRole: not a bearer");
        emit OwnerRemoval(_addr);
    }
}

contract MultiOwned is OwnerRole {
    uint constant public MAX_OWNER_COUNT = 50;

    struct Transaction {
        bytes data;
        bool executed;
    }

    mapping(bytes32 => Transaction) public transactions;
    mapping(bytes32 => mapping(address => bool)) internal confirmations;
    uint public required;

    event Confirmation(address indexed sender, bytes32 indexed transactionId);
    event Revocation(address indexed sender, bytes32 indexed transactionId);
    event Submission(bytes32 indexed transactionId);
    event Execution(bytes32 indexed transactionId);
    event ExecutionFailure(bytes32 indexed transactionId);
    event Requirement(uint required);

    modifier confirmed(bytes32 _transactionId, address _owner) {
        require(confirmations[_transactionId][_owner]);
        _;
    }

    modifier notConfirmed(bytes32 _transactionId, address _owner) {
        require(!confirmations[_transactionId][_owner]);
        _;
    }

    modifier notExecuted(bytes32 _transactionId) {
        require(!transactions[_transactionId].executed);
        _;
    }

    modifier onlySelf() {
        require(msg.sender == address(this));
        _;
    }

    modifier transactionExists(bytes32 _transactionId) {
        require(transactions[_transactionId].data.length != 0);
        _;
    }

    modifier validRequirement(uint _ownerCount, uint _required) {
        require(0 < _ownerCount
            && 0 < _required
            && _required <= _ownerCount
            && _ownerCount <= MAX_OWNER_COUNT);
        _;
    }

    constructor(address[] memory _owners, uint _required)
        public
        validRequirement(_owners.length, _required)
    {
        for (uint i = 0; i < _owners.length; ++i) {
            _addOwner(_owners[i]);
        }
        required = _required;
    }

    function addOwner(address _owner)
        public
        onlySelf
        validRequirement(numOwners() + 1, required)
    {
        _addOwner(_owner);
    }

    function addTransaction(bytes memory _data, uint _nonce)
        internal
        returns (bytes32 transactionId)
    {
        if (_nonce == 0) _nonce = block.number;
        transactionId = makeTransactionId(_data, _nonce);
        if (transactions[transactionId].data.length == 0) {
            transactions[transactionId] = Transaction({
                data: _data,
                executed: false
            });
            emit Submission(transactionId);
        }
    }

    function confirmTransaction(bytes32 _transactionId)
        public
        onlyOwner
        transactionExists(_transactionId)
        notConfirmed(_transactionId, msg.sender)
    {
        confirmations[_transactionId][msg.sender] = true;
        emit Confirmation(msg.sender, _transactionId);
        executeTransaction(_transactionId);
    }

    function executeTransaction(bytes32 _transactionId)
        public
        onlyOwner
        confirmed(_transactionId, msg.sender)
        notExecuted(_transactionId)
    {
        if (isConfirmed(_transactionId)) {
            Transaction storage txn = transactions[_transactionId];
            txn.executed = true;
            (bool success,) = address(this).call(txn.data);
            if (success) {
                emit Execution(_transactionId);
            } else {
                emit ExecutionFailure(_transactionId);
                txn.executed = false;
            }
        }
    }

    function removeOwner(address _owner)
        public
        onlySelf
    {
        _removeOwner(_owner);
        if (required > numOwners()) {
            setRequirement(numOwners());
        }
    }

    function renounceOwner()
        public
        validRequirement(numOwners() - 1, required)
    {
        _removeOwner(msg.sender);
    }

    function replaceOwner(address _owner, address _newOwner)
        public
        onlySelf
    {
        _removeOwner(_owner);
        _addOwner(_newOwner);
    }

    function revokeConfirmation(bytes32 _transactionId)
        public
        onlyOwner
        confirmed(_transactionId, msg.sender)
        notExecuted(_transactionId)
    {
        confirmations[_transactionId][msg.sender] = false;
        emit Revocation(msg.sender, _transactionId);
    }

    function setRequirement(uint _required)
        public
        onlySelf
        validRequirement(numOwners(), _required)
    {
        required = _required;
        emit Requirement(_required);
    }

    function submitTransaction(bytes memory _data, uint _nonce)
        public
        returns (bytes32 transactionId)
    {
        transactionId = addTransaction(_data, _nonce);
        confirmTransaction(transactionId);
    }

    function getConfirmationCount(bytes32 _transactionId)
        public
        view
        returns (uint count)
    {
        address[] memory owners = getOwners();
        for (uint i = 0; i < numOwners(); ++i) {
            if (confirmations[_transactionId][owners[i]]) ++count;
        }
    }

    function getConfirmations(bytes32 _transactionId)
        public
        view
        returns (address[] memory _confirmations)
    {
        address[] memory confirmationsTmp = new address[](numOwners());
        uint count = 0;
        uint i;
        address[] memory owners = getOwners();
        for (i = 0; i < numOwners(); ++i) {
            if (confirmations[_transactionId][owners[i]]) {
                confirmationsTmp[count] = owners[i];
                ++count;
            }
        }
        _confirmations = new address[](count);
        for (i = 0; i < count; ++i) {
            _confirmations[i] = confirmationsTmp[i];
        }
    }

    function isConfirmed(bytes32 _transactionId)
        public
        view
        returns (bool)
    {
        address[] memory owners = getOwners();
        uint count = 0;
        for (uint i = 0; i < numOwners(); ++i) {
            if (confirmations[_transactionId][owners[i]]) ++count;
            if (count == required) return true;
        }
    }

    function makeTransactionId(bytes memory _data, uint _nonce)
        public
        pure
        returns (bytes32 transactionId)
    {
        transactionId = keccak256(abi.encode(_data, _nonce));
    }
}


contract TrusteeRole {
    using AddressSet for AddressSet.addrset;

    AddressSet.addrset private trustees;

    event TrusteeAddition(address indexed addr);
    event TrusteeRemoval(address indexed addr);

    modifier ifTrustee(address _addr) {
        require(isTrustee(_addr),
            "TrusteeRole: specified account does not have the Trustee role");
        _;
    }

    modifier onlyTrustee() {
        require(isTrustee(msg.sender),
            "TrusteeRole: caller does not have the Trustee role");
        _;
    }

    function getTrustees()
        public
        view
        returns (address[] memory)
    {
        return trustees.elements;
    }

    function isTrustee(address _addr)
        public
        view
        returns (bool)
    {
        return trustees.has(_addr);
    }

    function numTrustees()
        public
        view
        returns (uint)
    {
        return trustees.elements.length;
    }

    function _addTrustee(address _addr)
        internal
    {
        require(trustees.insert(_addr),
            "TrusteeRole: duplicate bearer");
        emit TrusteeAddition(_addr);
    }

    function _removeTrustee(address _addr)
        internal
    {
        require(trustees.remove(_addr),
            "TrusteeRole: not a bearer");
        emit TrusteeRemoval(_addr);
    }
}

contract ERC20WithFees is MultiOwned, ERC20, TrusteeRole {
    using Math64x64 for int128;
    using SafeMath for uint256;
    using AddressSet for AddressSet.addrset;

    AddressSet.addrset internal holders;
    int128 txFee; // Transfer fee ratio; positive 64.64 fixed point number

    event TransferFeeChanged(int128 txFee);
    event TransferFeeCollected(address indexed addr, uint256 amount);

    constructor(int128 _txFee)
        public
    {
        _setTxFee(_txFee);
    }

    function addTrustee(address _addr)
        public
        onlySelf
    {
        _addTrustee(_addr);
    }

    function removeTrustee(address _addr)
        public
        onlySelf
    {
        _removeTrustee(_addr);
    }

    function setTxFee(int128 _txFee)
        public
        onlySelf
    {
        _setTxFee(_txFee);
    }

    function holderCount()
        public
        view
        returns (uint)
    {
        return holders.elements.length;
    }

    function _collectTxFee(address _from, uint256 _amount)
        internal
        returns (uint256 txFeeAmount)
    {
        if (isTrustee(_from)) {
            txFeeAmount = 0;
        } else {
            txFeeAmount = _computeTxFee(_amount);
        }
        if (txFeeAmount != 0) {
            balances[_from] = balances[_from].sub(txFeeAmount);
            tokenTotalSupply = tokenTotalSupply.sub(txFeeAmount);
            emit Transfer(_from, address(0), txFeeAmount);
            emit TransferFeeCollected(_from, txFeeAmount);
        }
    }

    function _setTxFee(int128 _txFee)
        internal
    {
        require(Math64x64.fromUInt(0) <= _txFee
            && _txFee <= Math64x64.fromUInt(1),
            "ERC20WithFees: invalid transfer fee value");
        txFee = _txFee;
        emit TransferFeeChanged(_txFee);
    }

    function _transfer(address _from, address _to, uint256 _amount)
        internal
    {
        require(_to != address(0), "ERC20: transfer to the zero address");
        require(_to != address(this), "ERC20: transfer to token contract");

        // Execute transfer
        super._transfer(_from, _to, _amount);

        // Collect transfer fee
        _collectTxFee(_to, _amount);

        // Update set of holders
        if (balances[_from] == 0) holders.remove(_from);
        if (balances[_to] > 0) holders.insert(_to);
    }

    function _computeTxFee(uint256 _amount)
        internal
        view
        returns (uint)
    {
        return txFee.mulu(_amount);
    }
}


contract BurnerRole {
    using AddressSet for AddressSet.addrset;

    AddressSet.addrset private burners;

    event BurnerAddition(address indexed addr);
    event BurnerRemoval(address indexed addr);

    modifier ifBurner(address _addr) {
        require(isBurner(_addr),
            "BurnerRole: specified account does not have the Burner role");
        _;
    }

    modifier onlyBurner() {
        require(isBurner(msg.sender),
            "BurnerRole: caller does not have the Burner role");
        _;
    }

    function getBurners()
        public
        view
        returns (address[] memory)
    {
        return burners.elements;
    }

    function isBurner(address _addr)
        public
        view
        returns (bool)
    {
        return burners.has(_addr);
    }

    function numBurners()
        public
        view
        returns (uint)
    {
        return burners.elements.length;
    }

    function _addBurner(address _addr)
        internal
    {
        require(burners.insert(_addr),
            "BurnerRole: duplicate bearer");
        emit BurnerAddition(_addr);
    }

    function _removeBurner(address _addr)
        internal
    {
        require(burners.remove(_addr),
            "BurnerRole: not a bearer");
        emit BurnerRemoval(_addr);
    }
}

contract ERC20Burnable is ERC20WithFees, BurnerRole {
    function addBurner(address _addr)
        public
        onlySelf
    {
        _addBurner(_addr);
    }

    function burn(uint256 _amount)
        public
        onlyBurner
        returns (bool success)
    {
        _burn(msg.sender, _amount);
        return true;
    }

    function burnFrom(address _from, uint256 _amount)
        public
        ifBurner(_from)
        returns (bool success)
    {
        _burn(_from, _amount);
        _approve(_from, msg.sender, allowed[_from][msg.sender].sub(_amount));
        return true;
    }

    function removeBurner(address _addr)
        public
        onlySelf
    {
        _removeBurner(_addr);
    }

    function _burn(address _from, uint256 _amount)
        internal
    {
        balances[_from] = balances[_from].sub(_amount);
        if (balances[_from] == 0) holders.remove(_from);
        tokenTotalSupply = tokenTotalSupply.sub(_amount);

        emit Transfer(_from, address(0), _amount);
        emit Burn(_from, _amount);
    }
}



contract XBullionTokenConfig {
    using Math64x64 for int128;

    string internal constant TOKEN_SYMBOL = "SILV";
    string internal constant TOKEN_NAME = "XBullion Silver";
    uint8 internal constant TOKEN_DECIMALS = 8;

    uint256 private constant DECIMALS_FACTOR = 10**uint256(TOKEN_DECIMALS);
    uint256 internal constant TOKEN_INITIALSUPPLY = 0;

    uint256 internal constant TOKEN_MINTCAPACITY = 100 * DECIMALS_FACTOR;
    uint internal constant TOKEN_MINTPERIOD = 24 hours;

    function initialTxFee()
        internal
        pure
        returns (int128)
    {
        return txFeeFromBPs(19);
    }

    function makeAddressSingleton(address _addr)
        internal
        pure
        returns (address[] memory addrs)
    {
        addrs = new address[](1);
        addrs[0] = _addr;
    }

    function txFeeFromBPs(uint _bps)
        internal
        pure
        returns (int128)
    {
        return Math64x64.fromUInt(_bps)
            .div(Math64x64.fromUInt(10000));
    }
}


contract MinterRole {
    using AddressSet for AddressSet.addrset;

    AddressSet.addrset private minters;

    event MinterAddition(address indexed addr);
    event MinterRemoval(address indexed addr);

    modifier ifMinter(address _addr) {
        require(isMinter(_addr),
            "MinterRole: specified account does not have the Minter role");
        _;
    }

    modifier onlyMinter() {
        require(isMinter(msg.sender),
            "MinterRole: caller does not have the Minter role");
        _;
    }

    function getMinters()
        public
        view
        returns (address[] memory)
    {
        return minters.elements;
    }

    function isMinter(address _addr)
        public
        view
        returns (bool)
    {
        return minters.has(_addr);
    }

    function numMinters()
        public
        view
        returns (uint)
    {
        return minters.elements.length;
    }

    function _addMinter(address _addr)
        internal
    {
        require(minters.insert(_addr),
            "MinterRole: duplicate bearer");
        emit MinterAddition(_addr);
    }

    function _removeMinter(address _addr)
        internal
    {
        require(minters.remove(_addr),
            "MinterRole: not a bearer");
        emit MinterRemoval(_addr);
    }
}

contract ERC20Mintable is XBullionTokenConfig, ERC20WithFees, MinterRole {
    uint256 public mintCapacity;
    uint256 public amountMinted;
    uint public mintPeriod;
    uint public mintPeriodStart;

    event MintCapacity(uint256 amount);
    event MintPeriod(uint duration);

    constructor(uint256 _mintCapacity, uint _mintPeriod)
        public
    {
        _setMintCapacity(_mintCapacity);
        _setMintPeriod(_mintPeriod);
    }

    function addMinter(address _addr)
        public
        onlySelf
    {
        _addMinter(_addr);
    }

    function mint(address _to, uint256 _amount)
        public
    {
        if (msg.sender != address(this)) {
            require(isMinter(msg.sender), "MinterRole: caller does not have the Minter role");
            require(isUnderMintLimit(_amount), "ERC20: exceeds minting capacity");
        }
        _mint(_to, _amount);
    }

    function removeMinter(address _addr)
        public
        onlySelf
    {
        _removeMinter(_addr);
    }

    function renounceMinter()
        public
        returns (bool)
    {
        _removeMinter(msg.sender);
        return true;
    }

    function setMintCapacity(uint256 _amount)
        public
        onlySelf
    {
        _setMintCapacity(_amount);
    }

    function setMintPeriod(uint _duration)
        public
        onlySelf
    {
        _setMintPeriod(_duration);
    }

    function _mint(address _to, uint256 _amount)
        internal
    {
        require(_to != address(0), "ERC20: mint to the zero address");
        require(_to != address(this), "ERC20: mint to token contract");

        if (now > mintPeriodStart + mintPeriod) {
            amountMinted = 0;
            mintPeriodStart = now;
        }
        amountMinted = amountMinted.add(_amount);
        tokenTotalSupply = tokenTotalSupply.add(_amount);
        balances[_to] = balances[_to].add(_amount);
        if (balances[_to] > 0) holders.insert(_to);

        emit Transfer(address(0), _to, _amount);
        emit Mint(_to, _amount);
    }

    function _setMintCapacity(uint256 _amount)
        internal
    {
        mintCapacity = _amount;
        emit MintCapacity(_amount);
    }

    function _setMintPeriod(uint _duration)
        internal
    {
        require(_duration < (1 << 64),
                "ERC20: mint period must be less than 2^64 seconds");
        mintPeriod = _duration;
        emit MintPeriod(_duration);
    }

    function isUnderMintLimit(uint256 _amount)
        internal
        view
        returns (bool)
    {
        uint256 effAmountMinted = (now > mintPeriodStart + mintPeriod) ? 0 : amountMinted;
        if (effAmountMinted + _amount > mintCapacity
            || effAmountMinted + _amount < effAmountMinted) {
            return false;
        }
        return true;
    }

    function remainingMintCapacity()
        public
        view
        returns (uint256)
    {
        if (now > mintPeriodStart + mintPeriod)
            return mintCapacity;
        if (mintCapacity < amountMinted)
            return 0;
        return mintCapacity - amountMinted;
    }
}

contract XBullionToken is XBullionTokenConfig, ERC20Burnable, ERC20Mintable {
    constructor()
        MultiOwned(
            makeAddressSingleton(msg.sender),
            1)
        ERC20(
            TOKEN_NAME,
            TOKEN_SYMBOL,
            TOKEN_DECIMALS,
            TOKEN_INITIALSUPPLY)
        ERC20WithFees(
            initialTxFee())
        ERC20Mintable(
            TOKEN_MINTCAPACITY,
            TOKEN_MINTPERIOD)
        public
    {}
}

Contract Security Audit

Contract ABI

[{"inputs":[],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Burn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"addr","type":"address"}],"name":"BurnerAddition","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"addr","type":"address"}],"name":"BurnerRemoval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"bytes32","name":"transactionId","type":"bytes32"}],"name":"Confirmation","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"transactionId","type":"bytes32"}],"name":"Execution","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"transactionId","type":"bytes32"}],"name":"ExecutionFailure","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Mint","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"MintCapacity","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"duration","type":"uint256"}],"name":"MintPeriod","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"addr","type":"address"}],"name":"MinterAddition","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"addr","type":"address"}],"name":"MinterRemoval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"addr","type":"address"}],"name":"OwnerAddition","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"addr","type":"address"}],"name":"OwnerRemoval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"required","type":"uint256"}],"name":"Requirement","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"bytes32","name":"transactionId","type":"bytes32"}],"name":"Revocation","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"transactionId","type":"bytes32"}],"name":"Submission","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"int128","name":"txFee","type":"int128"}],"name":"TransferFeeChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"addr","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TransferFeeCollected","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"addr","type":"address"}],"name":"TrusteeAddition","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"addr","type":"address"}],"name":"TrusteeRemoval","type":"event"},{"constant":true,"inputs":[],"name":"MAX_OWNER_COUNT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"addBurner","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"addMinter","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"addOwner","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"addTrustee","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"remaining","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"amountMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_spender","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"success","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"balance","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"burn","outputs":[{"internalType":"bool","name":"success","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"burnFrom","outputs":[{"internalType":"bool","name":"success","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"bytes32","name":"_transactionId","type":"bytes32"}],"name":"confirmTransaction","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_spender","type":"address"},{"internalType":"uint256","name":"_delta","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"success","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"bytes32","name":"_transactionId","type":"bytes32"}],"name":"executeTransaction","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"getBurners","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"bytes32","name":"_transactionId","type":"bytes32"}],"name":"getConfirmationCount","outputs":[{"internalType":"uint256","name":"count","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"bytes32","name":"_transactionId","type":"bytes32"}],"name":"getConfirmations","outputs":[{"internalType":"address[]","name":"_confirmations","type":"address[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"getMinters","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"getOwners","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"getTrustees","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"holderCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_spender","type":"address"},{"internalType":"uint256","name":"_delta","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"success","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"isBurner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"bytes32","name":"_transactionId","type":"bytes32"}],"name":"isConfirmed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"isMinter","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"isTrustee","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"bytes","name":"_data","type":"bytes"},{"internalType":"uint256","name":"_nonce","type":"uint256"}],"name":"makeTransactionId","outputs":[{"internalType":"bytes32","name":"transactionId","type":"bytes32"}],"payable":false,"stateMutability":"pure","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"mint","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"mintCapacity","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"mintPeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"mintPeriodStart","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"numBurners","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"numMinters","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"numOwners","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"numTrustees","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"remainingMintCapacity","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"removeBurner","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"removeMinter","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"removeOwner","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"removeTrustee","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"renounceMinter","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"renounceOwner","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_newOwner","type":"address"}],"name":"replaceOwner","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"required","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"bytes32","name":"_transactionId","type":"bytes32"}],"name":"revokeConfirmation","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"setMintCapacity","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"_duration","type":"uint256"}],"name":"setMintPeriod","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"_required","type":"uint256"}],"name":"setRequirement","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"int128","name":"_txFee","type":"int128"}],"name":"setTxFee","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"bytes","name":"_data","type":"bytes"},{"internalType":"uint256","name":"_nonce","type":"uint256"}],"name":"submitTransaction","outputs":[{"internalType":"bytes32","name":"transactionId","type":"bytes32"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"transactions","outputs":[{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"bool","name":"executed","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"success","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"success","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"}]

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

53573:479:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;53573:479:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47468:115;;;;;;;;;:::i;:::-;;43518:117;;;;;;;;;:::i;6957:119::-;;;:::i;:::-;;;;;;;;;;;;;;;;5363:185;;;;;;;;;:::i;:::-;;;;;;;;39927:304;;;;;;;;;:::i;:::-;;;;;;;;38630:207;;;;;;;;;:::i;7215:127::-;;;:::i;43759:131::-;;;:::i;6213:270::-;;;;;;;;;:::i;38845:142::-;;;:::i;53270:296::-;;;:::i;34444:134::-;;;;;;;;;:::i;51276:115::-;;;;;;;;;:::i;6830:119::-;;;:::i;:::-;;;;;;;;5792:228;;;;;;;;;:::i;51544:125::-;;;;;;;;;:::i;50930:338::-;;;;;;;;;:::i;47012:171::-;;;;;;;;;:::i;46163:136::-;;;;;;;;;:::i;50429:27::-;;;:::i;42352:132::-;;;:::i;50497:22::-;;;:::i;35275:51::-;;;;;;;;;:::i;:::-;;;;;;;;;40918:363;;;;;;;;;:::i;49533:135::-;;;:::i;:::-;;;;;;;;36980:162;;;;;;;;;:::i;6675:147::-;;;;;;;;;:::i;37649:353::-;;;;;;;;;:::i;47191:269::-;;;;;;;;;:::i;50463:27::-;;;:::i;46020:135::-;;;:::i;34586:128::-;;;:::i;39475:206::-;;;;;;;;;:::i;41289:207::-;;;;;;;;;:::i;7084:123::-;;;:::i;40239:671::-;;;;;;;;;:::i;50813:109::-;;;;;;;;;:::i;51399:137::-;;;:::i;34303:133::-;;;:::i;5556:228::-;;;;;;;;;:::i;51677:122::-;;;;;;;;;:::i;6028:177::-;;;;;;;;;:::i;49676:136::-;;;;;;;;;:::i;46307:130::-;;;:::i;42061:137::-;;;:::i;38010:612::-;;;;;;;;;:::i;42206:138::-;;;;;;;;;:::i;39689:230::-;;;;;;;;;:::i;35145:41::-;;;:::i;50526:27::-;;;:::i;43399:111::-;;;;;;;;;:::i;35407:20::-;;;:::i;6491:176::-;;;;;;;;;:::i;43643:108::-;;;;;;;;;:::i;38995:166::-;;;;;;;;;:::i;49820:130::-;;;:::i;39169:298::-;;;;;;;;;:::i;46895:109::-;;;;;;;;;:::i;47468:115::-;36264:10;36286:4;36264:27;36256:36;;;;;;47555:20;47569:5;47555:13;:20::i;:::-;47468:115;:::o;43518:117::-;36264:10;36286:4;36264:27;36256:36;;;;;;43606:21;43621:5;43606:14;:21::i;6957:119::-;7059:9;7052:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7021:13;;7052:16;;7059:9;;7052:16;;7059:9;7052:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6957:119;;:::o;5363:185::-;5449:12;5479:39;5488:10;5500:8;5510:7;5479:8;:39::i;:::-;-1:-1:-1;5536:4:0;5363:185;;;;;:::o;39927:304::-;40029:10;40057:23;40083:11;:9;:11::i;:::-;40057:37;-1:-1:-1;40110:6:0;40105:119;40126:11;:9;:11::i;:::-;40122:1;:15;40105:119;;;40163:13;:29;40177:14;40163:29;;;;;;;;;;;:40;40193:6;40200:1;40193:9;;;;;;;;;;;;;;;;;;;40163:40;;;;;;;;;;;;-1:-1:-1;40163:40:0;;;;40159:53;;;40205:7;;;;;40159:53;40139:3;;40105:119;;;;39927:304;;;;:::o;38630:207::-;36264:10;36286:4;36264:27;36256:36;;;;;;38717:20;38730:6;38717:12;:20::i;:::-;38763:11;:9;:11::i;:::-;38752:8;;:22;38748:82;;;38791:27;38806:11;:9;:11::i;7215:127::-;7318:16;;7215:127;:::o;43759:131::-;43859:16;:23;43759:131;:::o;6213:270::-;6314:12;6344:30;6354:5;6361:3;6366:7;6344:9;:30::i;:::-;6413:14;;;;;;;:7;:14;;;;;;;;6401:10;6413:26;;;;;;;;;6385:68;;6394:5;;6413:39;;6444:7;6413:39;:30;:39;:::i;:::-;6385:8;:68::i;:::-;-1:-1:-1;6471:4:0;6213:270;;;;;;:::o;38845:142::-;38926:1;38912:11;:9;:11::i;:::-;:15;38929:8;;36547:11;36543:1;:15;:45;;;;;36579:9;36575:1;:13;36543:45;:86;;;;;36618:11;36605:9;:24;;36543:86;:133;;;;;35184:2;36646:11;:30;;36543:133;36535:142;;;;;;38955:24;38968:10;38955:12;:24::i;:::-;38845:142;;:::o;53270:296::-;53351:7;53404:10;;53386:15;;:28;53380:3;:34;53376:72;;;-1:-1:-1;53436:12:0;;53429:19;;53376:72;53478:12;;53463;;:27;53459:54;;;-1:-1:-1;53512:1:0;53505:8;;53459:54;-1:-1:-1;53546:12:0;;53531;;:27;53270:296;:::o;34444:134::-;34524:4;34553:17;34524:4;34564:5;34553:17;:10;:17;:::i;:::-;34546:24;;34444:134;;;;:::o;51276:115::-;36264:10;36286:4;36264:27;36256:36;;;;;;51363:20;51377:5;51363:13;:20::i;6830:119::-;6928:13;;;;6830:119;:::o;5792:228::-;5926:10;5887:12;5948:19;;;:7;:19;;;;;;;;;:29;;;;;;;;;;5887:12;;5917:73;;5938:8;;5948:41;;5982:6;5948:41;:33;:41;:::i;51544:125::-;36264:10;36286:4;36264:27;36256:36;;;;;;51636:25;51653:7;51636:16;:25::i;50930:338::-;51010:10;51032:4;51010:27;51006:225;;51062:20;51071:10;51062:8;:20::i;:::-;51054:81;;;;;;;;;;;;;;;;;;;;;;51158:25;51175:7;51158:16;:25::i;:::-;51150:69;;;;;;;;;;;;;;51241:19;51247:3;51252:7;51241:5;:19::i;47012:171::-;47097:12;45906:20;45915:10;45906:8;:20::i;:::-;45898:94;;;;;;;;;;;;;;47127:26;47133:10;47145:7;47127:5;:26::i;:::-;-1:-1:-1;47171:4:0;47012:171;;;:::o;46163:136::-;46244:4;46273:18;:7;46285:5;46273:18;:11;:18;:::i;50429:27::-;;;;:::o;42352:132::-;42452:17;:24;42352:132;:::o;50497:22::-;;;;:::o;35275:51::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;35275:51:0;;;;;;;-1:-1:-1;;35275:51:0;;;:::o;40918:363::-;41011:4;41033:23;41059:11;:9;:11::i;:::-;41033:37;-1:-1:-1;41081:10:0;;41106:168;41127:11;:9;:11::i;:::-;41123:1;:15;41106:168;;;41164:13;:29;41178:14;41164:29;;;;;;;;;;;:40;41194:6;41201:1;41194:9;;;;;;;;;;;;;;;;;;;41164:40;;;;;;;;;;;;-1:-1:-1;41164:40:0;;;;41160:53;;;41206:7;;;;;41160:53;41241:8;;41232:5;:17;41228:34;;;41258:4;41251:11;;;;;;;41228:34;41140:3;;41106:168;;;;40918:363;;;;;:::o;49533:135::-;49603:16;49644:7;:16;;49637:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49533:135;:::o;36980:162::-;36264:10;36286:4;36264:27;36256:36;;;;;;37074:11;:9;:11::i;:::-;37088:1;37074:15;37091:8;;36547:11;36543:1;:15;:45;;;;;36579:9;36575:1;:13;36543:45;:86;;;;;36618:11;36605:9;:24;;36543:86;:133;;;;;35184:2;36646:11;:30;;36543:133;36535:142;;;;;;37117:17;37127:6;37117:9;:17::i;:::-;36303:1;;36980:162;:::o;6675:147::-;6798:16;;6758:15;6798:16;;;:8;:16;;;;;;;6675:147::o;37649:353::-;34192:19;34200:10;34192:7;:19::i;:::-;34184:91;;;;;;;;;;;;;;36390:28;;;;:12;:28;;;;;;;;:40;37763:14;;36390:40;;;;;;;;;;;;36382:54;;;;;;36028:29;;;;:13;:29;;;;;;;;37817:10;36028:37;;;;;;;;;37801:14;;37817:10;36028:37;;36027:38;36019:47;;;;;;37845:29;;;;:13;:29;;;;;;;;37875:10;37845:41;;;;;;;;:48;;;;37889:4;37845:48;;;37909:40;37859:14;;37909:40;;;37960:34;37979:14;37960:18;:34::i;:::-;36447:1;;34286;37649:353;:::o;47191:269::-;47300:12;47275:5;45745:15;45754:5;45745:8;:15::i;:::-;45737:100;;;;;;;;;;;;;;47330:21;47336:5;47343:7;47330:5;:21::i;:::-;47390:14;;;;;;;:7;:14;;;;;;;;47378:10;47390:26;;;;;;;;;47362:68;;47371:5;;47390:39;;47421:7;47390:39;:30;:39;:::i;50463:27::-;;;;:::o;46020:135::-;46090:16;46131:7;:16;;46124:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46020:135;:::o;34586:128::-;34684:15;:22;34586:128;:::o;39475:206::-;36264:10;36286:4;36264:27;36256:36;;;;;;39575:11;:9;:11::i;:::-;39588:9;36547:11;36543:1;:15;:45;;;;;36579:9;36575:1;:13;36543:45;:86;;;;;36618:11;36605:9;:24;;36543:86;:133;;;;;35184:2;36646:11;:30;;36543:133;36535:142;;;;;;39615:8;:20;;;39651:22;;;;;;39626:9;;39651:22;;;;;;;;;;36303:1;;39475:206;:::o;41289:207::-;41397:21;41473:5;41480:6;41462:25;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;41462:25:0;;;41452:36;;;;;;41436:52;;41289:207;;;;:::o;7084:123::-;7188:11;7181:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7150:13;;7181:18;;7188:11;;7181:18;;7188:11;7181:18;;;;;;;;;;;;;;;;;;;;;;;;40239:671;40337:31;40386:33;40436:11;:9;:11::i;:::-;40422:26;;;;;;;;;;;;;;;;;;;;;;29:2:-1;21:6;17:15;117:4;105:10;97:6;88:34;136:17;;-1:-1;40422:26:0;-1:-1:-1;40386:62:0;-1:-1:-1;40459:10:0;;40501:23;40527:11;:9;:11::i;:::-;40501:37;;40558:1;40554:5;;40549:202;40565:11;:9;:11::i;:::-;40561:1;:15;40549:202;;;40602:13;:29;40616:14;40602:29;;;;;;;;;;;:40;40632:6;40639:1;40632:9;;;;;;;;;;;;;;;;;;;40602:40;;;;;;;;;;;;-1:-1:-1;40602:40:0;;;;40598:142;;;40689:6;40696:1;40689:9;;;;;;;;;;;;;;40663:16;40680:5;40663:23;;;;;;;;;;;;;:35;;;;;;;;;;;40717:7;;;;;40598:142;40578:3;;;;;40549:202;;;40792:5;40778:20;;;;;;;;;;;;;;;;;;;;;;29:2:-1;21:6;17:15;117:4;105:10;97:6;88:34;136:17;;-1:-1;40778:20:0;;40761:37;;40818:1;40814:5;;40809:94;40825:5;40821:1;:9;40809:94;;;40872:16;40889:1;40872:19;;;;;;;;;;;;;;40852:14;40867:1;40852:17;;;;;;;;;;;;;:39;;;;;;;;;;;40832:3;;;;;40809:94;;;40239:671;;;;;;;:::o;50813:109::-;36264:10;36286:4;36264:27;36256:36;;;;;;50897:17;50908:5;50897:10;:17::i;51399:137::-;51459:4;51481:25;51495:10;51481:13;:25::i;:::-;-1:-1:-1;51524:4:0;51399:137;:::o;34303:133::-;34372:16;34413:6;:15;;34406:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34303:133;:::o;5556:228::-;5690:10;5651:12;5712:19;;;:7;:19;;;;;;;;;:29;;;;;;;;;;5651:12;;5681:73;;5702:8;;5712:41;;5746:6;5712:41;:33;:41;:::i;51677:122::-;36264:10;36286:4;36264:27;36256:36;;;;;;51766:25;51781:9;51766:14;:25::i;6028:177::-;6110:12;6140:35;6150:10;6162:3;6167:7;6140:9;:35::i;49676:136::-;49757:4;49786:18;:7;49798:5;49786:18;:11;:18;:::i;46307:130::-;46406:16;:23;46307:130;:::o;42061:137::-;42132:16;42173:8;:17;;42166:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42061:137;:::o;38010:612::-;34192:19;34200:10;34192:7;:19::i;:::-;34184:91;;;;;;;;;;;;;;35880:29;;;;:13;:29;;;;;;;;38132:10;35880:37;;;;;;;;;38116:14;;38132:10;35880:37;;35872:46;;;;;;36159:28;;;;:12;:28;;;;;:37;;;38165:14;;36159:37;;36158:38;36150:47;;;;;;38201:27;38213:14;38201:11;:27::i;:::-;38197:418;;;38245:23;38271:28;;;:12;:28;;;;;;38329:4;38314:12;;;:19;;;;;;;;;38366:28;;38271;;38245:23;38374:4;;38366:28;;38271;;38366;;;;;;;;;;;;;;;;;;14:1:-1;21;16:31;;;;75:4;69:11;64:16;;144:4;140:9;133:4;115:16;111:27;107:43;104:1;100:51;94:4;87:65;169:16;166:1;159:27;225:16;222:1;215:4;212:1;208:12;193:49;7:242;;16:31;36:4;31:9;;7:242;;38348:46:0;;;38413:7;38409:195;;;38446:25;;38456:14;;38446:25;;;;;38409:195;;;38517:32;;38534:14;;38517:32;;;;;38568:12;;;:20;;;;;;38409:195;38197:418;;35929:1;34286;;38010:612;:::o;42206:138::-;42288:4;42317:19;:8;42330:5;42317:19;:12;:19;:::i;39689:230::-;39783:21;39838:29;39853:5;39860:6;39838:14;:29::i;:::-;39822:45;;39878:33;39897:13;39878:18;:33::i;35145:41::-;35184:2;35145:41;:::o;50526:27::-;;;;:::o;43399:111::-;36264:10;36286:4;36264:27;36256:36;;;;;;43484:18;43496:5;43484:11;:18::i;35407:20::-;;;;:::o;6491:176::-;6634:15;;;;6592:17;6634:15;;;:7;:15;;;;;;;;:25;;;;;;;;;;;;;6491:176::o;43643:108::-;36264:10;36286:4;36264:27;36256:36;;;;;;43726:17;43736:6;43726:9;:17::i;38995:166::-;36264:10;36286:4;36264:27;36256:36;;;;;;39102:20;39115:6;39102:12;:20::i;:::-;39133;39143:9;39133;:20::i;49820:130::-;49919:16;:23;49820:130;:::o;39169:298::-;34192:19;34200:10;34192:7;:19::i;:::-;34184:91;;;;;;;;;;;;;;35880:29;;;;:13;:29;;;;;;;;39291:10;35880:37;;;;;;;;;39275:14;;39291:10;35880:37;;35872:46;;;;;;36159:28;;;;:12;:28;;;;;:37;;;39324:14;;36159:37;;36158:38;36150:47;;;;;;39400:5;39356:29;;;:13;:29;;;;;;;;39386:10;39356:41;;;;;;;;:49;;;;;;39421:38;39370:14;;39421:38;;;35929:1;34286;;39169:298;:::o;46895:109::-;36264:10;36286:4;36264:27;36256:36;;;;;;46979:17;46990:5;46979:10;:17::i;46642:187::-;46722:21;:7;46737:5;46722:21;:14;:21;:::i;:::-;46714:71;;;;;;;;;;;;;;46801:20;;;;;;;;;;;46642:187;:::o;42693:191::-;42774:22;:8;42790:5;42774:22;:15;:22;:::i;:::-;42766:73;;;;;;;;;;;;;;42855:21;;;;;;;;;;;42693:191;:::o;7350:197::-;7453:15;;;;;;;;:7;:15;;;;;;;;:25;;;;;;;;;;;;;;:35;;;7504;;;;;7481:7;;7504:35;;;;;;;;;;7350:197;;;:::o;34915:183::-;34994:20;:6;35008:5;34994:20;:13;:20;:::i;:::-;34986:69;;;;;;;;;;;;;;35071:19;;;;;;;;;;;34915:183;:::o;44767:546::-;44873:17;;;44865:65;;;;;;;;;;;;;;44949:20;;;44964:4;44949:20;;44941:66;;;;;;;;;;;;;;45049:36;45065:5;45072:3;45077:7;45049:15;:36::i;:::-;45131:27;45145:3;45150:7;45131:13;:27::i;:::-;-1:-1:-1;45209:15:0;;;;;;;:8;:15;;;;;;45205:47;;45231:21;:7;45246:5;45231:21;:14;:21;:::i;:::-;;45205:47;45267:13;;;45283:1;45267:13;;;:8;:13;;;;;;:17;45263:42;;45286:19;:7;45301:3;45286:19;:14;:19;:::i;2422:184::-;2480:7;2513:1;2508;:6;;2500:49;;;;;;;;;;;;;;-1:-1:-1;2572:5:0;;;2422:184::o;9592:150::-;9717:13;;9688:4;9717:13;;;;;;;;;;;;:17;;;9592:150::o;50155:187::-;50235:21;:7;50250:5;50235:21;:14;:21;:::i;:::-;50227:71;;;;;;;;;;;;;;50314:20;;;;;;;;;;;50155:187;:::o;1966:181::-;2024:7;2056:5;;;2080:6;;;;2072:46;;;;;;;;;;;;;52469:144;52546:12;:22;;;52584:21;;;;;;52561:7;;52584:21;;;;;;;;;;52469:144;:::o;52881:381::-;52974:4;52996:23;53047:10;;53029:15;;:28;53023:3;:34;53022:55;;53065:12;;53022:55;;;53061:1;53022:55;52996:81;;53120:12;;53110:7;53092:15;:25;:40;:100;;;;53177:15;53167:7;53149:15;:25;:43;53092:100;53088:145;;;53216:5;53209:12;;;;;51807:654;51894:17;;;51886:61;;;;;;;;;;;;;;51966:20;;;51981:4;51966:20;;51958:62;;;;;;;;;;;;;;52061:10;;52043:15;;:28;52037:3;:34;52033:119;;;52103:1;52088:12;:16;52137:3;52119:15;:21;52033:119;52177:12;;:25;;52194:7;52177:25;:16;:25;:::i;:::-;52162:12;:40;52232:16;;:29;;52253:7;52232:29;:20;:29;:::i;:::-;52213:16;:48;52288:13;;;;;;;:8;:13;;;;;;:26;;52306:7;52288:26;:17;:26;:::i;:::-;52272:13;;;;;;;:8;:13;;;;;:42;;;52329:17;52325:42;;52348:19;:7;52363:3;52348:19;:14;:19;:::i;:::-;;52325:42;52406:3;52385:34;;52402:1;52385:34;;;52411:7;52385:34;;;;;;;;;;;;;;;52440:3;52435:18;;;52445:7;52435:18;;;;;;;;;;;;;;;51807:654;;:::o;47591:342::-;47690:15;;;;;;;:8;:15;;;;;;:28;;47710:7;47690:28;:19;:28;:::i;:::-;47672:15;;;;;;;:8;:15;;;;;:46;;;47729:47;;47755:21;:7;47770:5;47755:21;:14;:21;:::i;:::-;;47729:47;47806:16;;:29;;47827:7;47806:29;:20;:29;:::i;:::-;47787:16;:48;47853:36;;47877:1;;47853:36;;;;;;;;47881:7;;47853:36;;;;;;;;;;47910:5;47905:20;;;47917:7;47905:20;;;;;;;34722:185;34798:20;:6;34812:5;34798:20;:13;:20;:::i;:::-;34790:73;;;;;;;;;;;;;;34879:20;;;;;;;;;;;34722:185;:::o;49958:189::-;50035:21;:7;50050:5;50035:21;:14;:21;:::i;:::-;50027:75;;;;;;;;;;;;;;50118:21;;;;;;;;;;;49958:189;:::o;52621:252::-;52716:7;52703:9;:21;52695:100;;;;;;;;;;;;;;52806:10;:22;;;52844:21;;;;;;52819:9;;52844:21;;37150:491;37243:21;37286:11;37282:38;;37308:12;37299:21;;37282:38;37347:32;37365:5;37372:6;37347:17;:32::i;:::-;37394:27;;;;:12;:27;;;;;;;;:39;37331:48;;-1:-1:-1;37394:39:0;;;;;;;;;;;;37390:244;;37485:92;;;;;;;;;;;-1:-1:-1;37485:92:0;;;;;;;37455:27;;;:12;:27;;;;;:122;;;;37485:92;;37455:27;;:122;;:27;;:122;;;:::i;:::-;-1:-1:-1;37455:122:0;;;;;;;;;;;;;;;;;;;;;;;37597:25;;37608:13;;37597:25;;-1:-1:-1;;37597:25:0;37150:491;;;;:::o;42492:193::-;42570:22;:8;42586:5;42570:22;:15;:22;:::i;:::-;42562:77;;;;;;;;;;;;;;42655:22;;;;;;;;;;;42492:193;:::o;44470:289::-;44571:6;44546:31;;:21;44565:1;44546:18;:21::i;:::-;:31;;;;:79;;;;;44604:21;44623:1;44604:18;:21::i;:::-;44594:31;;:6;:31;;;;44546:79;44538:146;;;;;;;;;;;;;;44695:5;:14;;;;;;;;;;;;44725:26;;;;;;44695:14;;44725:26;;46445:189;46522:21;:7;46537:5;46522:21;:14;:21;:::i;:::-;46514:75;;;;;;;;;;;;;;46605:21;;;;;;;;;;;46445:189;:::o;9109:475::-;9237:13;;;9194:12;9237:13;;;;;;;;;;;9265:10;9261:316;;9299:5;9292:12;;;;;9261:316;9350:13;;;9364:20;;9337:10;;9350:13;9364:24;;;;9350:39;;;;;;;;;;;;;;;;;9404:13;;:24;;9350:39;;;;;-1:-1:-1;9350:39:0;;9418:9;;;;9404:24;;;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;9448:4;:13;;:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9482:14;;;;;;;;;;;;:22;;;;9526:13;;;;;;;;9519:20;-1:-1:-1;9448:19:0;9554:11;;8276:405;8382:17;;;8374:65;;;;;;;;;;;;;;8458:20;;;8473:4;8458:20;;8450:66;;;;;;;;;;;;;;8547:15;;;;;;;:8;:15;;;;;;:28;;8567:7;8547:28;:19;:28;:::i;:::-;8529:15;;;;;;;;:8;:15;;;;;;:46;;;;8602:13;;;;;;;:26;;8620:7;8602:26;:17;:26;:::i;:::-;8586:13;;;;;;;;:8;:13;;;;;;;:42;;;;8644:29;;;;;;;;;;8665:7;;8644:29;;43898:564;43989:19;44030:16;44040:5;44030:9;:16::i;:::-;44026:133;;;-1:-1:-1;44077:1:0;44026:133;;;44125:22;44139:7;44125:13;:22::i;:::-;44111:36;;44026:133;44173:16;;44169:286;;44224:15;;;;;;;:8;:15;;;;;;:32;;44244:11;44224:32;:19;:32;:::i;:::-;44206:15;;;;;;;:8;:15;;;;;:50;44290:16;;:33;;44311:11;44290:33;:20;:33;:::i;:::-;44271:16;:52;44343:40;;44367:1;;44343:40;;;;;;;;44371:11;;44343:40;;;;;;;;;;44424:5;44403:40;;;44431:11;44403:40;;;;;;;;;;;;;;;43898:564;;;;:::o;8821:280::-;8940:13;;;8906:12;8940:13;;;;;;;;;;;:17;8936:158;;-1:-1:-1;8981:5:0;8974:12;;8936:158;-1:-1:-1;9035:13:0;;;;27:10:-1;;23:18;;;45:23;;;-1:-1;9035:21:0;;;;;;;;;;;;;;;;;;;;;;;9019:13;;;;;;;;;;:37;9071:11;;11150:137;11203:6;11232:18;11227:1;:23;;11218:33;;;;;;-1:-1:-1;11278:2:0;11273:7;;11150:137::o;45321:146::-;45440:5;;;45411:4;;45440:19;;:5;;:10;;45451:7;45440:19;:10;:19;:::i;15304:469::-;15363:7;15383:6;15379:20;;-1:-1:-1;15398:1:0;15391:8;;15379:20;15422:1;15417;:6;;;;15408:16;;;;;;15447:11;;;;15466:34;15462:38;;15447:54;;15506:2;15446:62;;15548:3;15543:8;;;15528:24;15576:50;15570:56;;;15561:66;;;;;;15641:2;15634:9;15674:71;;15661:84;;;15652:94;;;;;;15760:7;;15304:469;-1:-1:-1;;;15304:469:0:o;53573:479::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;53573:479:0;;;-1:-1:-1;53573:479:0;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;5:130:-1;72:20;;97:33;72:20;97:33;;142:130;209:20;;234:33;209:20;234:33;;280:440;;381:3;374:4;366:6;362:17;358:27;348:2;;399:1;396;389:12;348:2;436:6;423:20;458:64;473:48;514:6;473:48;;;458:64;;;449:73;;542:6;535:5;528:21;578:4;570:6;566:17;611:4;604:5;600:16;646:3;637:6;632:3;628:16;625:25;622:2;;;663:1;660;653:12;622:2;673:41;707:6;702:3;697;673:41;;;341:379;;;;;;;;728:128;794:20;;819:32;794:20;819:32;;1000:241;;1104:2;1092:9;1083:7;1079:23;1075:32;1072:2;;;1120:1;1117;1110:12;1072:2;1155:1;1172:53;1217:7;1197:9;1172:53;;;1162:63;1066:175;-1:-1;;;;1066:175;1248:366;;;1369:2;1357:9;1348:7;1344:23;1340:32;1337:2;;;1385:1;1382;1375:12;1337:2;1420:1;1437:53;1482:7;1462:9;1437:53;;;1427:63;;1399:97;1527:2;1545:53;1590:7;1581:6;1570:9;1566:22;1545:53;;;1535:63;;1506:98;1331:283;;;;;;1621:491;;;;1759:2;1747:9;1738:7;1734:23;1730:32;1727:2;;;1775:1;1772;1765:12;1727:2;1810:1;1827:53;1872:7;1852:9;1827:53;;;1817:63;;1789:97;1917:2;1935:53;1980:7;1971:6;1960:9;1956:22;1935:53;;;1925:63;;1896:98;2025:2;2043:53;2088:7;2079:6;2068:9;2064:22;2043:53;;;2033:63;;2004:98;1721:391;;;;;;2119:366;;;2240:2;2228:9;2219:7;2215:23;2211:32;2208:2;;;2256:1;2253;2246:12;2208:2;2291:1;2308:53;2353:7;2333:9;2308:53;;;2298:63;;2270:97;2398:2;2416:53;2461:7;2452:6;2441:9;2437:22;2416:53;;2492:241;;2596:2;2584:9;2575:7;2571:23;2567:32;2564:2;;;2612:1;2609;2602:12;2564:2;2647:1;2664:53;2709:7;2689:9;2664:53;;2740:470;;;2870:2;2858:9;2849:7;2845:23;2841:32;2838:2;;;2886:1;2883;2876:12;2838:2;2921:31;;2972:18;2961:30;;2958:2;;;3004:1;3001;2994:12;2958:2;3024:62;3078:7;3069:6;3058:9;3054:22;3024:62;;3217:239;;3320:2;3308:9;3299:7;3295:23;3291:32;3288:2;;;3336:1;3333;3326:12;3288:2;3371:1;3388:52;3432:7;3412:9;3388:52;;3712:173;;3799:46;3841:3;3833:6;3799:46;;;-1:-1;;3874:4;3865:14;;3792:93;3893:103;3966:24;3984:5;3966:24;;;3961:3;3954:37;3948:48;;;4034:690;;4179:54;4227:5;4179:54;;;4246:86;4325:6;4320:3;4246:86;;;4239:93;;4353:56;4403:5;4353:56;;;4429:7;4457:1;4442:260;4467:6;4464:1;4461:13;4442:260;;;4534:6;4528:13;4555:63;4614:3;4599:13;4555:63;;;4548:70;;4635:60;4688:6;4635:60;;;4625:70;-1:-1;;4489:1;4482:9;4442:260;;;-1:-1;4715:3;;4158:566;-1:-1;;;;;4158:566;4732:104;4809:21;4824:5;4809:21;;4843:113;4926:24;4944:5;4926:24;;4963:343;;5073:38;5105:5;5073:38;;;5123:70;5186:6;5181:3;5123:70;;;5116:77;;5198:52;5243:6;5238:3;5231:4;5224:5;5220:16;5198:52;;;5271:29;5293:6;5271:29;;;5262:39;;;;5053:253;-1:-1;;;5053:253;5678:879;;5813:5;5807:12;5847:1;5836:9;5832:17;5860:1;5855:267;;;;6133:1;6128:423;;;;5825:726;;5855:267;5933:4;5929:1;5918:9;5914:17;5910:28;5952:88;6033:6;6028:3;5952:88;;;6074:9;6059:25;;6047:38;;5945:95;-1:-1;6099:16;;;-1:-1;5855:267;;6128:423;6197:1;6186:9;6182:17;6213:88;6294:6;6289:3;6213:88;;;6206:95;;6323:37;6354:5;6323:37;;;6376:1;6384:130;6398:6;6395:1;6392:13;6384:130;;;6457:14;;6444:11;;;6437:35;6504:1;6491:15;;;;6420:4;6413:12;6384:130;;;-1:-1;;6528:16;;;-1:-1;5825:726;;5783:774;;;;;;6565:110;6646:23;6663:5;6646:23;;7037:372;;7197:67;7261:2;7256:3;7197:67;;;7297:34;7277:55;;7366:5;7361:2;7352:12;;7345:27;7400:2;7391:12;;7183:226;-1:-1;;7183:226;7418:324;;7578:67;7642:2;7637:3;7578:67;;;7678:26;7658:47;;7733:2;7724:12;;7564:178;-1:-1;;7564:178;7751:370;;7911:67;7975:2;7970:3;7911:67;;;8011:34;7991:55;;8080:3;8075:2;8066:12;;8059:25;8112:2;8103:12;;7897:224;-1:-1;;7897:224;8130:329;;8290:67;8354:2;8349:3;8290:67;;;8390:31;8370:52;;8450:2;8441:12;;8276:183;-1:-1;;8276:183;8468:324;;8628:67;8692:2;8687:3;8628:67;;;8728:26;8708:47;;8783:2;8774:12;;8614:178;-1:-1;;8614:178;8801:327;;8961:67;9025:2;9020:3;8961:67;;;9061:29;9041:50;;9119:2;9110:12;;8947:181;-1:-1;;8947:181;9137:385;;9297:67;9361:2;9356:3;9297:67;;;9397:34;9377:55;;9466:18;9461:2;9452:12;;9445:40;9513:2;9504:12;;9283:239;-1:-1;;9283:239;9531:386;;9691:67;9755:2;9750:3;9691:67;;;9791:34;9771:55;;9860:19;9855:2;9846:12;;9839:41;9908:2;9899:12;;9677:240;-1:-1;;9677:240;9926:330;;10086:67;10150:2;10145:3;10086:67;;;10186:32;10166:53;;10247:2;10238:12;;10072:184;-1:-1;;10072:184;10265:323;;10425:67;10489:2;10484:3;10425:67;;;10525:25;10505:46;;10579:2;10570:12;;10411:177;-1:-1;;10411:177;10597:385;;10757:67;10821:2;10816:3;10757:67;;;10857:34;10837:55;;10926:18;10921:2;10912:12;;10905:40;10973:2;10964:12;;10743:239;-1:-1;;10743:239;10991:383;;11151:67;11215:2;11210:3;11151:67;;;11251:34;11231:55;;11320:16;11315:2;11306:12;;11299:38;11365:2;11356:12;;11137:237;-1:-1;;11137:237;11383:328;;11543:67;11607:2;11602:3;11543:67;;;11643:30;11623:51;;11702:2;11693:12;;11529:182;-1:-1;;11529:182;11720:378;;11880:67;11944:2;11939:3;11880:67;;;11980:34;11960:55;;12049:11;12044:2;12035:12;;12028:33;12089:2;12080:12;;11866:232;-1:-1;;11866:232;12107:328;;12267:67;12331:2;12326:3;12267:67;;;12367:30;12347:51;;12426:2;12417:12;;12253:182;-1:-1;;12253:182;12444:396;;12604:67;12668:2;12663:3;12604:67;;;12704:34;12684:55;;12773:29;12768:2;12759:12;;12752:51;12831:2;12822:12;;12590:250;-1:-1;;12590:250;12849:329;;13009:67;13073:2;13068:3;13009:67;;;13109:31;13089:52;;13169:2;13160:12;;12995:183;-1:-1;;12995:183;13187:327;;13347:67;13411:2;13406:3;13347:67;;;13447:29;13427:50;;13505:2;13496:12;;13333:181;-1:-1;;13333:181;13523:325;;13683:67;13747:2;13742:3;13683:67;;;13783:27;13763:48;;13839:2;13830:12;;13669:179;-1:-1;;13669:179;13857:331;;14017:67;14081:2;14076:3;14017:67;;;14117:33;14097:54;;14179:2;14170:12;;14003:185;-1:-1;;14003:185;14197:331;;14357:67;14421:2;14416:3;14357:67;;;14457:33;14437:54;;14519:2;14510:12;;14343:185;-1:-1;;14343:185;14656:107;14735:22;14751:5;14735:22;;14770:256;;14911:90;14997:3;14988:6;14911:90;;15033:361;15201:2;15215:47;;;15186:18;;15276:108;15186:18;15370:6;15276:108;;15401:201;15513:2;15498:18;;15527:65;15502:9;15565:6;15527:65;;15609:213;15727:2;15712:18;;15741:71;15716:9;15785:6;15741:71;;15829:408;15993:2;16007:47;;;15978:18;;16068:76;15978:18;16130:6;16068:76;;;16060:84;;16155:72;16223:2;16212:9;16208:18;16199:6;16155:72;;16244:388;16398:2;16412:47;;;16383:18;;16473:72;16383:18;16531:6;16473:72;;;16465:80;;16556:66;16618:2;16607:9;16603:18;16594:6;16556:66;;16639:209;16755:2;16740:18;;16769:69;16744:9;16811:6;16769:69;;16855:301;16993:2;17007:47;;;16978:18;;17068:78;16978:18;17132:6;17068:78;;17163:407;17354:2;17368:47;;;17339:18;;17429:131;17339:18;17429:131;;17577:407;17768:2;17782:47;;;17753:18;;17843:131;17753:18;17843:131;;17991:407;18182:2;18196:47;;;18167:18;;18257:131;18167:18;18257:131;;18405:407;18596:2;18610:47;;;18581:18;;18671:131;18581:18;18671:131;;18819:407;19010:2;19024:47;;;18995:18;;19085:131;18995:18;19085:131;;19233:407;19424:2;19438:47;;;19409:18;;19499:131;19409:18;19499:131;;19647:407;19838:2;19852:47;;;19823:18;;19913:131;19823:18;19913:131;;20061:407;20252:2;20266:47;;;20237:18;;20327:131;20237:18;20327:131;;20475:407;20666:2;20680:47;;;20651:18;;20741:131;20651:18;20741:131;;20889:407;21080:2;21094:47;;;21065:18;;21155:131;21065:18;21155:131;;21303:407;21494:2;21508:47;;;21479:18;;21569:131;21479:18;21569:131;;21717:407;21908:2;21922:47;;;21893:18;;21983:131;21893:18;21983:131;;22131:407;22322:2;22336:47;;;22307:18;;22397:131;22307:18;22397:131;;22545:407;22736:2;22750:47;;;22721:18;;22811:131;22721:18;22811:131;;22959:407;23150:2;23164:47;;;23135:18;;23225:131;23135:18;23225:131;;23373:407;23564:2;23578:47;;;23549:18;;23639:131;23549:18;23639:131;;23787:407;23978:2;23992:47;;;23963:18;;24053:131;23963:18;24053:131;;24201:407;24392:2;24406:47;;;24377:18;;24467:131;24377:18;24467:131;;24615:407;24806:2;24820:47;;;24791:18;;24881:131;24791:18;24881:131;;25029:407;25220:2;25234:47;;;25205:18;;25295:131;25205:18;25295:131;;25443:407;25634:2;25648:47;;;25619:18;;25709:131;25619:18;25709:131;;26077:205;26191:2;26176:18;;26205:67;26180:9;26245:6;26205:67;;26289:256;26351:2;26345:9;26377:17;;;26452:18;26437:34;;26473:22;;;26434:62;26431:2;;;26509:1;26506;26499:12;26431:2;26525;26518:22;26329:216;;-1:-1;26329:216;26552:321;;26695:18;26687:6;26684:30;26681:2;;;26727:1;26724;26717:12;26681:2;-1:-1;26858:4;26794;26771:17;;;;26790:9;26767:33;26848:15;;26618:255;26880:151;27004:4;26995:14;;26952:79;27038:157;;27132:14;;;27174:4;27161:18;;;27091:104;27202:137;27305:12;;27276:63;27843:178;27961:19;;;28010:4;28001:14;;27954:67;28525:91;;28587:24;28605:5;28587:24;;28623:85;28689:13;28682:21;;28665:43;28794:87;28866:2;28855:21;;28838:43;28888:121;28961:42;28950:54;;28933:76;29095:81;29166:4;29155:16;;29138:38;29184:145;29265:6;29260:3;29255;29242:30;-1:-1;29321:1;29303:16;;29296:27;29235:94;29338:268;29403:1;29410:101;29424:6;29421:1;29418:13;29410:101;;;29491:11;;;29485:18;29472:11;;;29465:39;29446:2;29439:10;29410:101;;;29526:6;29523:1;29520:13;29517:2;;;-1:-1;;29591:1;29573:16;;29566:27;29387:219;29614:97;29702:2;29682:14;29698:7;29678:28;;29662:49;29719:117;29788:24;29806:5;29788:24;;;29781:5;29778:35;29768:2;;29827:1;29824;29817:12;29843:117;29912:24;29930:5;29912:24;;29967:115;30035:23;30052:5;30035:23;;30132:74;16098:6:0;16122:1;:6;;16127:1;16122:6;;16113:16;;;;;;16136:13;16173:1;16152:22;;16167:2;16161:1;16153:10;;:16;;16152:22;;;;;;;-1:-1:-1;10009:35:0;16190:19;;;;;:42;;-1:-1:-1;10168:34:0;16213:19;;;16190:42;16181:52;;;;

Swarm Source

bzzr://133fc9be3465d4279ff5ef05e04f5a92f4ab2dfcc1a2513bee26a4b92b5c9374
Loading...
Loading
[ Download: CSV Export  ]
[ Download: CSV Export  ]

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.