Token

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

   - function _msgSender()    - function _msgData() interface IERC20    - function totalSupply()    - function balanceOf(address account)    - function transfer(address recipient, ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom(address sender, ... library SafeMath    - function add(uint256 a, uint256 b)    - function sub(uint256 a, uint256 b)    - function sub(uint256 a, uint256 b, st ...    - function mul(uint256 a, uint256 b)    - function div(uint256 a, uint256 b)    - function div(uint256 a, uint256 b, st ...    - function mod(uint256 a, uint256 b)    - function mod(uint256 a, uint256 b, st ... library Address    - function isContract(address account)    - function sendValue(address payable re ...    - function functionCall(address target, ...    - function functionCall(address target, ...    - function functionCallWithValue(addres ...    - function functionCallWithValue(addres ...    - function _functionCallWithValue(addre ...  contract ERC20 is Context, IERC20    - function name()    - function symbol()    - function decimals()    - function totalSupply()    - function balanceOf(address account)    - function transfer(address recipient, ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom(address sender, ...    - function increaseAllowance(address sp ...    - function decreaseAllowance(address sp ...    - function _transfer(address sender, ad ...    - function _mint(address account, uint2 ...    - function _burn(address account, uint2 ...    - function _approve(address owner, addr ...    - function _setupDecimals(uint8 decimal ...    - function _beforeTokenTransfer(address ... interface IERC165    - function supportsInterface(bytes4 int ... interface IERC1155Receiver is IERC165    - function onERC1155Received(    - function onERC1155BatchReceived(  contract ERC165 is IERC165    - function supportsInterface(bytes4 int ...    - function _registerInterface(bytes4 in ... interface IERC1155 is IERC165    - function balanceOf(address account, u ...    - function balanceOfBatch(address[] cal ...    - function setApprovalForAll(address op ...    - function isApprovedForAll(address acc ...    - function safeTransferFrom(address fro ...    - function safeBatchTransferFrom(addres ... interface IShareToken is IERC1155    - function claimTradingProceeds(    - function getTokenId(address _market, ...    - function getMarket(uint256 _tokenId)  contract ERC20Wrapper is ERC20, ER ... *    - function wrapTokens(address _account, ...    - function unWrapTokens(address _accoun ...    - function claim(address _account)    - function onERC1155Received(    - function onERC1155BatchReceived(  contract AugurFoundry    - function newERC20Wrapper(    - function newERC20Wrappers(    - function wrapTokens(    - function unWrapTokens(uint256 _tokenI ...    - function wrapMultipleTokens(    - function unWrapMultipleTokens(

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-09-27
*/

// File: @openzeppelin/contracts/GSN/Context.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

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

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// File: @openzeppelin/contracts/math/SafeMath.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

/**
 * @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) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        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-contracts/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) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message 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, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @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) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message 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, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

// File: @openzeppelin/contracts/utils/Address.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.2;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(account) }
        return (codehash != accountHash && codehash != 0x0);
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
      return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return _functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// File: @openzeppelin/contracts/token/ERC20/ERC20.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;





/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of returning `false` on failure. This behavior is nonetheless conventional
 * and does not conflict with the expectations of ERC20 applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20 {
    using SafeMath for uint256;
    using Address for address;

    mapping (address => uint256) private _balances;

    mapping (address => mapping (address => uint256)) private _allowances;

    uint256 private _totalSupply;

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

    /**
     * @dev Sets the values for {name} and {symbol}, initializes {decimals} with
     * a default value of 18.
     *
     * To select a different value for {decimals}, use {_setupDecimals}.
     *
     * All three of these values are immutable: they can only be set once during
     * construction.
     */
    constructor (string memory name, string memory symbol) public {
        _name = name;
        _symbol = symbol;
        _decimals = 18;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5,05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is
     * called.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view returns (uint8) {
        return _decimals;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20};
     *
     * Requirements:
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(address sender, address recipient, uint256 amount) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

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

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements
     *
     * - `to` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

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

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
     *
     * This is internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

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

    /**
     * @dev Sets {decimals} to a value other than the default one of 18.
     *
     * WARNING: This function should only be called from the constructor. Most
     * applications that interact with token contracts will not expect
     * {decimals} to ever change, and may work incorrectly if it does.
     */
    function _setupDecimals(uint8 decimals_) internal {
        _decimals = decimals_;
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be to transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}

// File: @openzeppelin/contracts/introspection/IERC165.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// File: @openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;


/**
 * _Available since v3.1._
 */
interface IERC1155Receiver is IERC165 {

    /**
        @dev Handles the receipt of a single ERC1155 token type. This function is
        called at the end of a `safeTransferFrom` after the balance has been updated.
        To accept the transfer, this must return
        `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
        (i.e. 0xf23a6e61, or its own function selector).
        @param operator The address which initiated the transfer (i.e. msg.sender)
        @param from The address which previously owned the token
        @param id The ID of the token being transferred
        @param value The amount of tokens being transferred
        @param data Additional data with no specified format
        @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
    */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    )
        external
        returns(bytes4);

    /**
        @dev Handles the receipt of a multiple ERC1155 token types. This function
        is called at the end of a `safeBatchTransferFrom` after the balances have
        been updated. To accept the transfer(s), this must return
        `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
        (i.e. 0xbc197c81, or its own function selector).
        @param operator The address which initiated the batch transfer (i.e. msg.sender)
        @param from The address which previously owned the token
        @param ids An array containing ids of each token being transferred (order and length must match values array)
        @param values An array containing amounts of each token being transferred (order and length must match ids array)
        @param data Additional data with no specified format
        @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
    */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    )
        external
        returns(bytes4);
}

// File: @openzeppelin/contracts/introspection/ERC165.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;


/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts may inherit from this and call {_registerInterface} to declare
 * their support of an interface.
 */
contract ERC165 is IERC165 {
    /*
     * bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7
     */
    bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;

    /**
     * @dev Mapping of interface ids to whether or not it's supported.
     */
    mapping(bytes4 => bool) private _supportedInterfaces;

    constructor () internal {
        // Derived contracts need only register support for their own interfaces,
        // we register support for ERC165 itself here
        _registerInterface(_INTERFACE_ID_ERC165);
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     *
     * Time complexity O(1), guaranteed to always use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) public view override returns (bool) {
        return _supportedInterfaces[interfaceId];
    }

    /**
     * @dev Registers the contract as an implementer of the interface defined by
     * `interfaceId`. Support of the actual ERC165 interface is automatic and
     * registering its interface id is not required.
     *
     * See {IERC165-supportsInterface}.
     *
     * Requirements:
     *
     * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`).
     */
    function _registerInterface(bytes4 interfaceId) internal virtual {
        require(interfaceId != 0xffffffff, "ERC165: invalid interface id");
        _supportedInterfaces[interfaceId] = true;
    }
}

// File: @openzeppelin/contracts/token/ERC1155/ERC1155Receiver.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;



/**
 * @dev _Available since v3.1._
 */
abstract contract ERC1155Receiver is ERC165, IERC1155Receiver {
    constructor() public {
        _registerInterface(
            ERC1155Receiver(0).onERC1155Received.selector ^
            ERC1155Receiver(0).onERC1155BatchReceived.selector
        );
    }
}

// File: @openzeppelin/contracts/token/ERC1155/IERC1155.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.2;


/**
 * @dev Required interface of an ERC1155 compliant contract, as defined in the
 * https://eips.ethereum.org/EIPS/eip-1155[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155 is IERC165 {
    /**
     * @dev Emitted when `value` tokens of token type `id` are transfered from `from` to `to` by `operator`.
     */
    event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);

    /**
     * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
     * transfers.
     */
    event TransferBatch(address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values);

    /**
     * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
     * `approved`.
     */
    event ApprovalForAll(address indexed account, address indexed operator, bool approved);

    /**
     * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
     *
     * If an {URI} event was emitted for `id`, the standard
     * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
     * returned by {IERC1155MetadataURI-uri}.
     */
    event URI(string value, uint256 indexed id);

    /**
     * @dev Returns the amount of tokens of token type `id` owned by `account`.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) external view returns (uint256);

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids) external view returns (uint256[] memory);

    /**
     * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
     *
     * Emits an {ApprovalForAll} event.
     *
     * Requirements:
     *
     * - `operator` cannot be the caller.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
     *
     * See {setApprovalForAll}.
     */
    function isApprovedForAll(address account, address operator) external view returns (bool);

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If the caller is not `from`, it must be have been approved to spend ``from``'s tokens via {setApprovalForAll}.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external;

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function safeBatchTransferFrom(address from, address to, uint256[] calldata ids, uint256[] calldata amounts, bytes calldata data) external;
}

// File: contracts/IShareToken.sol

pragma solidity ^0.6.2;


interface IShareToken is IERC1155 {
    function claimTradingProceeds(
        address _market,
        address _shareHolder,
        bytes32 _fingerprint
    ) external returns (uint256[] memory _outcomeFees);

    function getTokenId(address _market, uint256 _outcome)
        external
        pure
        returns (uint256 _tokenId);

    function getMarket(uint256 _tokenId)
        external
        view
        returns (address _marketAddress);
}

// File: contracts/ERC20Wrapper.sol

pragma solidity ^0.6.2;




/**
 * @dev This is an Wrapper around ERC1155 shareTokens generated by Augur
 * @author yashnaman
 * as shares on a outcome of a market.
 * For every outcome there will be one wrapper.
 * The approch here is simple. It gets ERC1155 token and mints ERC20.
 * It burns ERC20s and gives back the ERC11555s.
 * AugurFoundry passed in the constructor has special permission to mint and burn.
 */
contract ERC20Wrapper is ERC20, ERC1155Receiver {
    uint256 public tokenId;
    IShareToken public shareToken;
    IERC20 public cash;
    address public augurFoundry;

    /**
     * @dev sets values for
     * @param _augurFoundry A trusted factory contract so that users can wrap multiple tokens in one
     * transaction without giving individual approvals
     * @param _shareToken address of shareToken for which this wrapper is for
     * @param _cash DAI
     * @param _tokenId id of market outcome this wrapper is for
     * @param _name a descriptive name mentioning market and outcome
     * @param _symbol symbol
     * @param _decimals decimals
     */
    constructor(
        address _augurFoundry,
        IShareToken _shareToken,
        IERC20 _cash,
        uint256 _tokenId,
        string memory _name,
        string memory _symbol,
        uint8 _decimals
    ) public ERC20(_name, _symbol) {
        _setupDecimals(_decimals);
        augurFoundry = _augurFoundry;
        tokenId = _tokenId;
        shareToken = _shareToken;
        cash = _cash;
    }

    /**@dev A function that gets ERC1155s and mints ERC20s
     * Requirements:
     *
     * - if the msg.sender is not augurFoundry then it needs to have given setApprovalForAll
     *  to this contract (if the msg.sender is augur foundry then we trust it and know that
     *  it would have transferred the ERC1155s to this contract before calling it)
     * @param _account account the newly minted ERC20s will go to
     * @param _amount amount of tokens to be wrapped
     */
    function wrapTokens(address _account, uint256 _amount) public {
        if (msg.sender != augurFoundry) {
            shareToken.safeTransferFrom(
                msg.sender,
                address(this),
                tokenId,
                _amount,
                ""
            );
        }
        _mint(_account, _amount);
    }

    /**@dev A function that burns ERC20s and gives back ERC1155s
     * Requirements:
     *
     * - if the msg.sender is not augurFoundry or _account then the caller must have allowance for ``_account``'s tokens of at least
     * `amount`.
     * - if the market has finalized then claim() function should be called.
     * @param _account account the newly minted ERC20s will go to
     * @param _amount amount of tokens to be unwrapped
     */
    function unWrapTokens(address _account, uint256 _amount) public {
        if (msg.sender != _account && msg.sender != augurFoundry) {
            uint256 decreasedAllowance = allowance(_account, msg.sender).sub(
                _amount,
                "ERC20: burn amount exceeds allowance"
            );
            _approve(_account, msg.sender, decreasedAllowance);
        }
        _burn(_account, _amount);

        shareToken.safeTransferFrom(
            address(this),
            _account,
            tokenId,
            _amount,
            ""
        );
    }

    /**@dev A function that burns ERC20s and gives back DAI
     * It will return _account DAI if the outcome for which this wrapper is for
     * is a winning outcome.
     * Requirements:
     *  - if msg.sender is not {_account} then {_account} should have given allowance to msg.sender
     * of at least balanceOf(_account)
     * This is to prevent cases where an unknowing contract has the balance and someone claims
     * winning for them.
     * - Not really a requirement but...
     *  it makes more sense to call it when the market has finalized.
     *
     * @param _account account for which DAI is being claimed
     */
    function claim(address _account) public {
        /**@notice checks if the proceeds were claimed before. If not then claims the proceeds */
        if (shareToken.balanceOf(address(this), tokenId) != 0) {
            shareToken.claimTradingProceeds(
                shareToken.getMarket(tokenId),
                address(this),
                ""
            );
        }
        uint256 cashBalance = cash.balanceOf(address(this));
        /**@notice If this is a winning outcome then give the user thier share of DAI */
        if (cashBalance != 0) {
            uint256 userShare = (cashBalance.mul(balanceOf(_account))).div(
                totalSupply()
            );
            if (msg.sender != _account) {
                uint256 decreasedAllowance = allowance(_account, msg.sender)
                    .sub(
                    balanceOf(_account),
                    "ERC20: burn amount exceeds allowance"
                );
                _approve(_account, msg.sender, decreasedAllowance);
            }
            _burn(_account, balanceOf(_account));
            require(cash.transfer(_account, userShare));
        }
    }

    /**
        @dev Handles the receipt of a single ERC1155 token type. This function is
        called at the end of a `safeTransferFrom` after the balance has been updated.
        To accept the transfer, this must return
        `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
        (i.e. 0xf23a6e61, or its own function selector).
        @param operator The address which initiated the transfer (i.e. msg.sender)
        @param from The address which previously owned the token
        @param id The ID of the token being transferred
        @param value The amount of tokens being transferred
        @param data Additional data with no specified format
        @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
    */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external override returns (bytes4) {
        /**@notice To make sure that no other tokenId other than what this ERC20 is a wrapper for is sent here*/
        require(id == tokenId, "Not acceptable");
        return (
            bytes4(
                keccak256(
                    "onERC1155Received(address,address,uint256,uint256,bytes)"
                )
            )
        );
    }

    /**
        @dev Handles the receipt of a multiple ERC1155 token types. This function
        is called at the end of a `safeBatchTransferFrom` after the balances have
        been updated. To accept the transfer(s), this must return
        `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
        (i.e. 0xbc197c81, or its own function selector).
        @param operator The address which initiated the batch transfer (i.e. msg.sender)
        @param from The address which previously owned the token
        @param ids An array containing ids of each token being transferred (order and length must match values array)
        @param values An array containing amounts of each token being transferred (order and length must match ids array)
        @param data Additional data with no specified format
        @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
    */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external override returns (bytes4) {
        /**@notice This is not allowed. Just transfer one predefined id here */
        return "";
    }
}

// File: contracts/AugurFoundry.sol

pragma solidity ^0.6.2;


pragma experimental ABIEncoderV2;

/**
 * @dev This is a factory that creates Wrappers around ERC1155 shareTokens generated by Augur
 * @author yashnaman
 * as shares on outcomes of a markets.
 * For every outcome there will be one wrapper.
 */
contract AugurFoundry {
    IShareToken public shareToken;
    IERC20 public cash;

    mapping(uint256 => address) public wrappers;

    event WrapperCreated(uint256 indexed tokenId, address tokenAddress);

    /**@dev sets value for {shareToken} and {cash}
     * @param _shareToken address of shareToken associated with a augur universe
     *@param _cash DAI
     */
    constructor(IShareToken _shareToken, IERC20 _cash) public {
        cash = _cash;
        shareToken = _shareToken;
    }

    /**@dev creates new ERC20 wrappers for a outcome of a market
     *@param _tokenId token id associated with a outcome of a market
     *@param _name a descriptive name mentioning market and outcome
     *@param _symbol symbol for the ERC20 wrapper
     *@param decimals decimals for the ERC20 wrapper
     */
    function newERC20Wrapper(
        uint256 _tokenId,
        string memory _name,
        string memory _symbol,
        uint8 _decimals
    ) public {
        require(wrappers[_tokenId] == address(0), "Wrapper already created");
        ERC20Wrapper erc20Wrapper = new ERC20Wrapper(
            address(this),
            shareToken,
            cash,
            _tokenId,
            _name,
            _symbol,
            _decimals
        );
        wrappers[_tokenId] = address(erc20Wrapper);
        emit WrapperCreated(_tokenId, address(erc20Wrapper));
    }

    /**@dev creates new ERC20 wrappers for multiple tokenIds*/
    function newERC20Wrappers(
        uint256[] memory _tokenIds,
        string[] memory _names,
        string[] memory _symbols,
        uint8[] memory _decimals
    ) public {
        require(
            _tokenIds.length == _names.length &&
                _tokenIds.length == _symbols.length
        );
        for (uint256 i = 0; i < _tokenIds.length; i++) {
            newERC20Wrapper(_tokenIds[i], _names[i], _symbols[i], _decimals[i]);
        }
    }

    /**@dev A function that wraps ERC1155s shareToken into ERC20s
     * Requirements:
     *
     * -  msg.sender has setApprovalForAll to this contract
     * @param _tokenId token id associated with a outcome of a market
     * @param _account account the newly minted ERC20s will go to
     * @param _amount  amount of tokens to be wrapped
     */
    function wrapTokens(
        uint256 _tokenId,
        address _account,
        uint256 _amount
    ) public {
        ERC20Wrapper erc20Wrapper = ERC20Wrapper(wrappers[_tokenId]);
        shareToken.safeTransferFrom(
            msg.sender,
            address(erc20Wrapper),
            _tokenId,
            _amount,
            ""
        );
        erc20Wrapper.wrapTokens(_account, _amount);
    }

    /**@dev A function that burns ERC20s and gives back ERC1155s
     * Requirements:
     *
     * - msg.sender has more than _amount of ERC20 tokens associated with _tokenId.
     * - if the market has finalized then it is  advised that you call claim() on ERC20Wrapper
     * contract associated with the winning outcome
     * @param _tokenId token id associated with a outcome of a market
     * @param _amount amount of tokens to be unwrapped
     */
    function unWrapTokens(uint256 _tokenId, uint256 _amount) public {
        ERC20Wrapper erc20Wrapper = ERC20Wrapper(wrappers[_tokenId]);
        erc20Wrapper.unWrapTokens(msg.sender, _amount);
    }

    /**@dev wraps multiple tokens */
    function wrapMultipleTokens(
        uint256[] memory _tokenIds,
        address _account,
        uint256[] memory _amounts
    ) public {
        for (uint256 i = 0; i < _tokenIds.length; i++) {
            wrapTokens(_tokenIds[i], _account, _amounts[i]);
        }
    }

    /**@dev unwraps multiple tokens */
    function unWrapMultipleTokens(
        uint256[] memory _tokenIds,
        uint256[] memory _amounts
    ) public {
        for (uint256 i = 0; i < _tokenIds.length; i++) {
            unWrapTokens(_tokenIds[i], _amounts[i]);
        }
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_augurFoundry","type":"address"},{"internalType":"contract IShareToken","name":"_shareToken","type":"address"},{"internalType":"contract IERC20","name":"_cash","type":"address"},{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"uint8","name":"_decimals","type":"uint8"}],"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":"value","type":"uint256"}],"name":"Approval","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":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"augurFoundry","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cash","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"values","type":"uint256[]"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"onERC1155BatchReceived","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"onERC1155Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"shareToken","outputs":[{"internalType":"contract IShareToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"unWrapTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"wrapTokens","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

37137:7585:0:-:0;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;37137:7585:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30963:142;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;17757:83;;;:::i;:::-;;;;;;;;19863:169;;;;;;;;;:::i;37192:22::-;;;:::i;:::-;;;;;;;;18832:100;;;:::i;40813:1169::-;;;;;;;;;:::i;:::-;;20506:321;;;;;;;;;:::i;18684:83::-;;;:::i;:::-;;;;;;;;21236:218;;;;;;;;;:::i;37221:29::-;;;:::i;:::-;;;;;;;;18995:119;;;;;;;;;:::i;37282:27::-;;;:::i;17959:87::-;;;:::i;37257:18::-;;;:::i;38747:350::-;;;;;;;;;:::i;21957:269::-;;;;;;;;;:::i;19327:175::-;;;;;;;;;:::i;44387:332::-;;;;;;;;;:::i;:::-;;;;;;;;19565:151;;;;;;;;;:::i;42824:560::-;;;;;;;;;:::i;39563:592::-;;;;;;;;;:::i;30963:142::-;-1:-1:-1;;;;;;31064:33:0;31040:4;31064:33;;;:20;:33;;;;;;;;;30963:142::o;17757:83::-;17827:5;17820:12;;;;;;;;;;;;;-1:-1:-1;;17820:12:0;;;;;;;;;;;;;;;;;;;;;;;;;;17794:13;;17820:12;;17827:5;;17820:12;;;17827:5;17820:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17757:83;:::o;19863:169::-;19946:4;19963:39;19972:12;:10;:12::i;:::-;19986:7;19995:6;19963:8;:39::i;:::-;-1:-1:-1;20020:4:0;19863:169;;;;;:::o;37192:22::-;;;;:::o;18832:100::-;18912:12;;18832:100;:::o;40813:1169::-;40967:10;;41003:7;;40967:44;;-1:-1:-1;;;40967:44:0;;-1:-1:-1;;;;;40967:10:0;;;;:20;;:44;;40996:4;;41003:7;40967:44;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;40967:44:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;40967:44:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;40967:44:0;;;;;;;;;:49;40963:229;;41033:10;;41104:7;;41083:29;;-1:-1:-1;;;41083:29:0;;-1:-1:-1;;;;;41033:10:0;;;;:31;;:10;;-1:-1:-1;;41083:29:0;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;41083:29:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;41083:29:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;41083:29:0;;;;;;;;;41139:4;41033:147;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;41033:147:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;41033:147:0;;;;;;39:16:-1;36:1;17:17;2:54;101:4;41033:147:0;80:15:-1;;;-1:-1;;76:31;65:43;;120:4;113:20;41033:147:0;;;;;;;;;;40963:229;41224:4;;:29;;-1:-1:-1;;;41224:29:0;;41202:19;;-1:-1:-1;;;;;41224:4:0;;-1:-1:-1;;41224:29:0;;41247:4;;41224:29;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;41224:29:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;41224:29:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;41224:29:0;;;;;;;;;41202:51;-1:-1:-1;41358:16:0;;41354:621;;41391:17;41411:89;41472:13;:11;:13::i;:::-;41412:36;41428:19;41438:8;41428:9;:19::i;:::-;41412:11;;:36;:15;:36;:::i;:::-;41411:42;:89;:42;:89;:::i;:::-;41391:109;-1:-1:-1;;;;;;41519:22:0;;:10;:22;41515:340;;41562:26;41591:179;41671:19;41681:8;41671:9;:19::i;:::-;41591:179;;;;;;;;;;;;;;;;;:31;41601:8;41611:10;41591:9;:31::i;:::-;:57;:179;;:57;:179;:::i;:::-;41562:208;;41789:50;41798:8;41808:10;41820:18;41789:8;:50::i;:::-;41515:340;;41869:36;41875:8;41885:19;41895:8;41885:9;:19::i;:::-;41869:5;:36::i;:::-;41928:4;;:34;;-1:-1:-1;;;41928:34:0;;-1:-1:-1;;;;;41928:4:0;;;;-1:-1:-1;;41928:34:0;;41942:8;;41952:9;;41928:34;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;41928:34:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;41928:34:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;41928:34:0;;;;;;;;;41920:43;;;;;;41354:621;;40813:1169;;:::o;20506:321::-;20612:4;20629:36;20639:6;20647:9;20658:6;20629:9;:36::i;:::-;20676:121;20685:6;20693:12;:10;:12::i;:::-;20707:89;20745:6;20707:89;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;20707:19:0;;;;;;-1:-1:-1;20707:19:0;;;;;;20727:12;:10;:12::i;:::-;-1:-1:-1;;;;;20707:33:0;;;;;;;;;;;;-1:-1:-1;20707:33:0;;;;:37;:89::i;:::-;20676:8;:121::i;:::-;-1:-1:-1;20815:4:0;20506:321;;;;;:::o;18684:83::-;18750:9;;;;18684:83;:::o;21236:218::-;21324:4;21341:83;21350:12;:10;:12::i;:::-;21364:7;21373:50;21412:10;21373:11;:25;21385:12;:10;:12::i;:::-;-1:-1:-1;;;;;21373:25:0;;;;;;;;;;;;;;;;;-1:-1:-1;21373:25:0;;;:34;;;;;;;;;;;:38;:50::i;37221:29::-;;;-1:-1:-1;;;;;37221:29:0;;:::o;18995:119::-;-1:-1:-1;;;;;19088:18:0;19061:7;19088:18;;;;;;;;;;;;18995:119::o;37282:27::-;;;-1:-1:-1;;;;;37282:27:0;;:::o;17959:87::-;18031:7;18024:14;;;;;;;;;;;;;-1:-1:-1;;18024:14:0;;;;;;;;;;;;;;;;;;;;;;;;;;17998:13;;18024:14;;18031:7;;18024:14;;;18031:7;18024:14;;;;;;;;;;;;;;;;;;;;;;;;37257:18;;;-1:-1:-1;;;;;37257:18:0;;:::o;38747:350::-;38838:12;;-1:-1:-1;;;;;38838:12:0;38824:10;:26;38820:235;;38867:10;;38974:7;;38867:176;;-1:-1:-1;;;38867:176:0;;-1:-1:-1;;;;;38867:10:0;;;;:27;;:176;;38913:10;;38950:4;;39000:7;;38867:176;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;38867:176:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;38867:176:0;;;;38820:235;39065:24;39071:8;39081:7;39065:5;:24::i;21957:269::-;22050:4;22067:129;22076:12;:10;:12::i;:::-;22090:7;22099:96;22138:15;22099:96;;;;;;;;;;;;;;;;;:11;:25;22111:12;:10;:12::i;:::-;-1:-1:-1;;;;;22099:25:0;;;;;;;;;;;;;;;;;-1:-1:-1;22099:25:0;;;:34;;;;;;;;;;;;:38;:96::i;19327:175::-;19413:4;19430:42;19440:12;:10;:12::i;:::-;19454:9;19465:6;19430:9;:42::i;44387:332::-;44602:6;44387:332;;;;;;;;;;:::o;19565:151::-;-1:-1:-1;;;;;19681:18:0;;;19654:7;19681:18;;;-1:-1:-1;19681:18:0;;;;;;;;:27;;;;;;;;;;;;;19565:151::o;42824:560::-;43010:6;43157:7;;43151:2;:13;43143:40;;;;-1:-1:-1;;;43143:40:0;;;;;;;;;;;;;;;;;43241:109;;;;;;;;;;;;;;43194:182;;42824:560;;;;;;;;:::o;39563:592::-;-1:-1:-1;;;;;39642:22:0;;:10;:22;;;;:52;;-1:-1:-1;39682:12:0;;-1:-1:-1;;;;;39682:12:0;39668:10;:26;;39642:52;39638:312;;;39711:26;39740:133;39794:7;39740:133;;;;;;;;;;;;;;;;;:31;39750:8;39760:10;39740:9;:31::i;:133::-;39711:162;;39888:50;39897:8;39907:10;39919:18;39888:8;:50::i;:::-;39638:312;;39960:24;39966:8;39976:7;39960:5;:24::i;:::-;39997:10;;40090:7;;39997:150;;-1:-1:-1;;;39997:150:0;;-1:-1:-1;;;;;39997:10:0;;;;:27;;:150;;40047:4;;40067:8;;40112:7;;39997:150;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;39997:150:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;39997:150:0;;;;39563:592;;:::o;657:106::-;745:10;657:106;:::o;25104:346::-;-1:-1:-1;;;;;25206:19:0;;25198:68;;;;-1:-1:-1;;;25198:68:0;;;;;;;;;-1:-1:-1;;;;;25285:21:0;;25277:68;;;;-1:-1:-1;;;25277:68:0;;;;;;;;;-1:-1:-1;;;;;25358:18:0;;;;;;;-1:-1:-1;25358:18:0;;;;;;;;:27;;;;;;;;;;;;;;:36;;;25410:32;;;;;25358:36;;25410:32;;;;;;;;;;25104:346;;;:::o;6155:471::-;6213:7;6458:6;6454:47;;-1:-1:-1;6488:1:0;6481:8;;6454:47;6525:5;;;6529:1;6525;:5;:1;6549:5;;;;;:10;6541:56;;;;-1:-1:-1;;;6541:56:0;;;;;;;;;6617:1;6155:471;-1:-1:-1;;;6155:471:0:o;7102:132::-;7160:7;7187:39;7191:1;7194;7187:39;;;;;;;;;;;;;;;;;:3;:39::i;5704:192::-;5790:7;5826:12;5818:6;;;;5810:29;;;;-1:-1:-1;;;5810:29:0;;;;;;;;;;-1:-1:-1;;;5862:5:0;;;5704:192::o;24246:418::-;-1:-1:-1;;;;;24330:21:0;;24322:67;;;;-1:-1:-1;;;24322:67:0;;;;;;;;;24402:49;24423:7;24440:1;24444:6;24402:20;:49::i;:::-;24485:68;24508:6;24485:68;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;24485:18:0;;:9;:18;;;;;;;;;;;;;:22;:68::i;:::-;-1:-1:-1;;;;;24464:18:0;;:9;:18;;;;;;;;;;:89;24579:12;;:24;;24596:6;24579:16;:24::i;:::-;24564:12;:39;24619:37;;24645:1;;-1:-1:-1;;;;;24619:37:0;;;;;;;24649:6;;24619:37;;;;;;;;;;24246:418;;:::o;22716:539::-;-1:-1:-1;;;;;22822:20:0;;22814:70;;;;-1:-1:-1;;;22814:70:0;;;;;;;;;-1:-1:-1;;;;;22903:23:0;;22895:71;;;;-1:-1:-1;;;22895:71:0;;;;;;;;;22979:47;23000:6;23008:9;23019:6;22979:20;:47::i;:::-;23059:71;23081:6;23059:71;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;23059:17:0;;:9;:17;;;;;;;;;;;;;:21;:71::i;:::-;-1:-1:-1;;;;;23039:17:0;;;:9;:17;;;;;;;;;;;:91;;;;23164:20;;;;;;;:32;;23189:6;23164:24;:32::i;:::-;-1:-1:-1;;;;;23141:20:0;;;:9;:20;;;;;;;;;;;;:55;;;;23212:35;;;;;;;;;;23240:6;;23212:35;;4801:181;4859:7;4891:5;;;4915:6;;;;4907:46;;;;-1:-1:-1;;;4907:46:0;;;;;;;;23536:378;-1:-1:-1;;;;;23620:21:0;;23612:65;;;;-1:-1:-1;;;23612:65:0;;;;;;;;;23690:49;23719:1;23723:7;23732:6;23690:20;:49::i;:::-;23767:12;;:24;;23784:6;23767:24;:16;:24;:::i;:::-;23752:12;:39;-1:-1:-1;;;;;23823:18:0;;:9;:18;;;;;;;;;;;:30;;23846:6;23823:22;:30::i;:::-;-1:-1:-1;;;;;23802:18:0;;:9;:18;;;;;;;;;;;:51;;;;23869:37;;23802:18;;:9;23869:37;;;;23899:6;;23869:37;;7730:278;7816:7;7851:12;7844:5;7836:28;;;;-1:-1:-1;;;7836:28:0;;;;;;;;;;;7875:9;7891:1;7887;:5;;;;;;;7730:278;-1:-1:-1;;;;;7730:278:0:o;5265:136::-;5323:7;5350:43;5354:1;5357;5350:43;;;;;;;;;;;;;;;;;:3;:43::i;301:352:-1:-;;;431:3;424:4;416:6;412:17;408:27;398:2;;-1:-1;;439:12;398:2;-1:-1;469:20;;509:18;498:30;;495:2;;;-1:-1;;531:12;495:2;575:4;567:6;563:17;551:29;;626:3;575:4;;610:6;606:17;567:6;592:32;;589:41;586:2;;;643:1;;633:12;586:2;391:262;;;;;;1693:336;;;1807:3;1800:4;1792:6;1788:17;1784:27;1774:2;;-1:-1;;1815:12;1774:2;-1:-1;1845:20;;1885:18;1874:30;;1871:2;;;-1:-1;;1907:12;1871:2;1951:4;1943:6;1939:17;1927:29;;2002:3;1951:4;1982:17;1943:6;1968:32;;1965:41;1962:2;;;2019:1;;2009:12;2315:241;;2419:2;2407:9;2398:7;2394:23;2390:32;2387:2;;;-1:-1;;2425:12;2387:2;85:6;72:20;97:33;124:5;97:33;;2563:263;;2678:2;2666:9;2657:7;2653:23;2649:32;2646:2;;;-1:-1;;2684:12;2646:2;226:6;220:13;238:33;265:5;238:33;;2833:366;;;2954:2;2942:9;2933:7;2929:23;2925:32;2922:2;;;-1:-1;;2960:12;2922:2;85:6;72:20;97:33;124:5;97:33;;;3012:63;-1:-1;3112:2;3151:22;;72:20;97:33;72:20;97:33;;;3120:63;;;;2916:283;;;;;;3206:1179;;;;;;;;;3467:3;3455:9;3446:7;3442:23;3438:33;3435:2;;;-1:-1;;3474:12;3435:2;85:6;72:20;97:33;124:5;97:33;;;3526:63;-1:-1;3626:2;3665:22;;72:20;97:33;72:20;97:33;;;3634:63;-1:-1;3762:2;3747:18;;3734:32;3786:18;3775:30;;;3772:2;;;-1:-1;;3808:12;3772:2;3846:80;3918:7;3909:6;3898:9;3894:22;3846:80;;;3836:90;;-1:-1;3836:90;-1:-1;3991:2;3976:18;;3963:32;;-1:-1;4004:30;;;4001:2;;;-1:-1;;4037:12;4001:2;4075:80;4147:7;4138:6;4127:9;4123:22;4075:80;;;4065:90;;-1:-1;4065:90;-1:-1;4220:3;4205:19;;4192:33;;-1:-1;4234:30;;;4231:2;;;-1:-1;;4267:12;4231:2;;4305:64;4361:7;4352:6;4341:9;4337:22;4305:64;;;3429:956;;;;-1:-1;3429:956;;-1:-1;3429:956;;;;;;4295:74;-1:-1;;;3429:956;4392:491;;;;4530:2;4518:9;4509:7;4505:23;4501:32;4498:2;;;-1:-1;;4536:12;4498:2;85:6;72:20;97:33;124:5;97:33;;;4588:63;-1:-1;4688:2;4727:22;;72:20;97:33;72:20;97:33;;;4492:391;;4696:63;;-1:-1;;;4796:2;4835:22;;;;2104:20;;4492:391;4890:867;;;;;;;5081:3;5069:9;5060:7;5056:23;5052:33;5049:2;;;-1:-1;;5088:12;5049:2;85:6;72:20;97:33;124:5;97:33;;;5140:63;-1:-1;5240:2;5279:22;;72:20;97:33;72:20;97:33;;;5248:63;-1:-1;5348:2;5387:22;;2104:20;;-1:-1;5456:2;5495:22;;2104:20;;-1:-1;5592:3;5577:19;;5564:33;5617:18;5606:30;;5603:2;;;-1:-1;;5639:12;5603:2;5677:64;5733:7;5724:6;5713:9;5709:22;5677:64;;;5043:714;;;;-1:-1;5043:714;;-1:-1;5043:714;;5667:74;;5043:714;-1:-1;;;5043:714;5764:366;;;5885:2;5873:9;5864:7;5860:23;5856:32;5853:2;;;-1:-1;;5891:12;5853:2;85:6;72:20;97:33;124:5;97:33;;;5943:63;6043:2;6082:22;;;;2104:20;;-1:-1;;;5847:283;6137:392;;6277:2;;6265:9;6256:7;6252:23;6248:32;6245:2;;;-1:-1;;6283:12;6245:2;6334:17;6328:24;6372:18;6364:6;6361:30;6358:2;;;-1:-1;;6394:12;6358:2;6496:6;6485:9;6481:22;807:3;800:4;792:6;788:17;784:27;774:2;;-1:-1;;815:12;774:2;855:6;849:13;835:27;;877:80;892:64;949:6;892:64;;;877:80;;;985:21;;;1042:14;;;;1017:17;;;1131;;;1122:27;;;;1119:36;-1:-1;1116:2;;;-1:-1;;1158:12;1116:2;-1:-1;1184:10;;1178:217;1203:6;1200:1;1197:13;1178:217;;;2252:13;;1271:61;;1225:1;1218:9;;;;;1346:14;;;;1374;;1178:217;;;-1:-1;6414:99;6239:290;-1:-1;;;;;;;6239:290;6536:257;;6648:2;6636:9;6627:7;6623:23;6619:32;6616:2;;;-1:-1;;6654:12;6616:2;1490:6;1484:13;24902:5;22879:13;22872:21;24880:5;24877:32;24867:2;;-1:-1;;24913:12;6800:239;;6903:2;6891:9;6882:7;6878:23;6874:32;6871:2;;;-1:-1;;6909:12;6871:2;1610:20;;-1:-1;;;;;;22966:78;;24997:34;;24987:2;;-1:-1;;25035:12;7046:263;;7161:2;7149:9;7140:7;7136:23;7132:32;7129:2;;;-1:-1;;7167:12;7129:2;-1:-1;2252:13;;7123:186;-1:-1;7123:186;12889:372;12174:34;12154:55;;12243:26;12238:2;12229:12;;12222:48;12138:2;12289:12;;13069:192;13268:213;-1:-1;;;;;23118:54;;;;7536:37;;13386:2;13371:18;;13357:124;13488:867;-1:-1;;;;;23118:54;;;7395:58;;23118:54;;;;13971:2;13956:18;;7536:37;14054:2;14039:18;;12726:37;14137:2;14122:18;;12726:37;;;;-1:-1;14174:3;14159:19;;14152:49;;;-1:-1;13783:19;;;22321;22361:14;;;13769:586;14362:561;-1:-1;;;;;23118:54;;;7536:37;;23118:54;;14763:2;14748:18;;7536:37;-1:-1;14909:2;14894:18;;11197:15;14599:2;14584:18;;14570:353;15788:324;-1:-1;;;;;23118:54;;;;7536:37;;16098:2;16083:18;;12726:37;15934:2;15919:18;;15905:207;16119:201;22879:13;;22872:21;7650:34;;16231:2;16216:18;;16202:118;16327:209;-1:-1;;;;;;22966:78;;;;7765:36;;16443:2;16428:18;;16414:122;17049:301;;17187:2;;17208:17;17201:47;8290:5;22177:12;22333:6;17187:2;17176:9;17172:18;22321:19;-1:-1;24388:101;24402:6;24399:1;24396:13;24388:101;;;24469:11;;;;;24463:18;24450:11;;;22361:14;24450:11;24443:39;24417:10;;24388:101;;;24504:6;24501:1;24498:13;24495:2;;;-1:-1;22361:14;24560:6;17176:9;24551:16;;24544:27;24495:2;-1:-1;24676:7;24660:14;-1:-1;;24656:28;8448:39;;;;22361:14;8448:39;;17158:192;-1:-1;;;17158:192;17357:407;17548:2;17562:47;;;8724:2;17533:18;;;22321:19;8760:34;22361:14;;;8740:55;-1:-1;;;8815:12;;;8808:27;8854:12;;;17519:245;17771:407;17962:2;17976:47;;;9105:2;17947:18;;;22321:19;9141:34;22361:14;;;9121:55;-1:-1;;;9196:12;;;9189:26;9234:12;;;17933:245;18185:407;18376:2;18390:47;;;9485:2;18361:18;;;22321:19;9521:29;22361:14;;;9501:50;9570:12;;;18347:245;18599:407;18790:2;18804:47;;;9821:2;18775:18;;;22321:19;-1:-1;;;22361:14;;;9837:37;9893:12;;;18761:245;19013:407;19204:2;19218:47;;;10144:2;19189:18;;;22321:19;10180:34;22361:14;;;10160:55;-1:-1;;;10235:12;;;10228:25;10272:12;;;19175:245;19427:407;19618:2;19632:47;;;10523:2;19603:18;;;22321:19;10559:34;22361:14;;;10539:55;-1:-1;;;10614:12;;;10607:25;10651:12;;;19589:245;19841:407;20032:2;20046:47;;;10902:2;20017:18;;;22321:19;10938:34;22361:14;;;10918:55;-1:-1;;;10993:12;;;10986:29;11034:12;;;20003:245;20255:407;20446:2;20460:47;;;11720:2;20431:18;;;22321:19;11756:34;22361:14;;;11736:55;-1:-1;;;11811:12;;;11804:28;11851:12;;;20417:245;20669:407;20860:2;20874:47;;;12540:2;20845:18;;;22321:19;12576:33;22361:14;;;12556:54;12629:12;;;20831:245;21083:213;12726:37;;;21201:2;21186:18;;21172:124;21303:205;23334:4;23323:16;;;;12842:35;;21417:2;21402:18;;21388:120;21515:256;21577:2;21571:9;21603:17;;;21678:18;21663:34;;21699:22;;;21660:62;21657:2;;;21735:1;;21725:12;21657:2;21577;21744:22;21555:216;;-1:-1;21555:216;21778:304;;21937:18;21929:6;21926:30;21923:2;;;-1:-1;;21959:12;21923:2;-1:-1;22004:4;21992:17;;;22057:15;;21860:222;24697:117;-1:-1;;;;;23118:54;;24756:35;;24746:2;;24805:1;;24795:12;24746:2;24740:74;

ipfs://15c554d673aca530460379f4d0cf4ca900755e36224d34c98ba1657e30609594