Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•  contract Initializable
•    - function isConstructor()
•  contract IRelayRecipient
•    - function getHubAddr()
•    - function acceptRelayedCall(
•    - function preRelayedCall(bytes calldat ...
•    - function postRelayedCall(bytes callda ...
•  contract IRelayHub
•    - function stake(address relayaddr, uin ...
•    - function registerRelay(uint256 transa ...
•    - function removeRelayByOwner(address r ...
•    - function unstake(address relay)
•    - function getRelay(address relay)
•    - function depositFor(address target)
•    - function balanceOf(address target)
•    - function withdraw(uint256 amount, add ...
•    - function canRelay(
•    - function relayCall(
•    - function requiredGas(uint256 relayedC ...
•    - function maxPossibleCharge(uint256 re ...
•    - function penalizeRepeatedNonce(bytes ...
•    - function penalizeIllegalTransaction(b ...
•    - function getNonce(address from)
•  contract Context is Initializable
•    - function _msgSender()
•    - function _msgData()
•  contract GSNRecipient is Initializ ...
•    - function initialize()
•    - function setDefaultRelayHub()
•    - function getHubAddr()
•    - function _upgradeRelayHub(address new ...
•    - function relayHubVersion()
•    - function _withdrawDeposits(uint256 am ...
•    - function _msgSender()
•    - function _msgData()
•    - function preRelayedCall(bytes calldat ...
•    - function _preRelayedCall(bytes memory ...
•    - function postRelayedCall(bytes callda ...
•    - function _postRelayedCall(bytes memor ...
•    - function _approveRelayedCall()
•    - function _approveRelayedCall(bytes me ...
•    - function _rejectRelayedCall(uint256 e ...
•    - function _computeCharge(uint256 gas, ...
•    - function _getRelayedCallSender()
•    - function _getRelayedCallData()
• 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 ...
•  contract Secondary is Initializabl ...
•    - function initialize(address sender)
•    - function primary()
•    - function transferPrimary(address reci ...
• 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 Address
•    - function isContract(address account)
•    - function toPayable(address account)
•    - function sendValue(address payable re ...
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeApprove(IERC20 token, ad ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function callOptionalReturn(IERC20 to ...
•  contract ERC20 is Initializable, C ...
•    - 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 _burnFrom(address account, u ...
•  contract ERC20Detailed is Initiali ...
•    - function initialize(string memory nam ...
•    - function name()
•    - function symbol()
•    - function decimals()
•  contract GSNRecipientERC20Fee is I ...
•    - function initialize(string memory nam ...
•    - function token()
•    - function _mint(address account, uint2 ...
•    - function acceptRelayedCall(
•    - function _preRelayedCall(bytes memory ...
•    - function _postRelayedCall(bytes memor ...
•  contract __unstable__ERC20PrimaryA ...
•    - function initialize(string memory nam ...
•    - function mint(address account, uint25 ...
•    - function allowance(address owner, add ...
•    - function _approve(address owner, addr ...
•    - function transferFrom(address sender, ...
• library Roles
•    - function add(Role storage role, addre ...
•    - function remove(Role storage role, ad ...
•    - function has(Role storage role, addre ...
•  contract MinterRole is Initializab ...
•    - function initialize(address sender)
•    - function isMinter(address account)
•    - function addMinter(address account)
•    - function renounceMinter()
•    - function _addMinter(address account)
•    - function _removeMinter(address accoun ...
•  contract Ownable is Initializable, ...
•    - function initialize(address sender)
•    - function owner()
•    - function isOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
•  contract GSNMultiSigWallet is GSNR ...
•    - function initialize(address[] memory ...
•    - function addOwner(address owner)
•    - function removeOwner(address owner)
•    - function replaceOwner(address owner, ...
•    - function changeRequirement(uint _requ ...
•    - function submitTransaction(address de ...
•    - function confirmTransaction(uint tran ...
•    - function revokeConfirmation(uint tran ...
•    - function executeTransaction(uint tran ...
•    - function external_call(address destin ...
•    - function isConfirmed(uint transaction ...
•    - function addTransaction(address desti ...
•    - function getConfirmationCount(uint tr ...
•    - function getTransactionCount(bool pen ...
•    - function getOwners()
•    - function getConfirmations(uint transa ...
•    - function getTransactionIds(uint from, ...
•    - function acceptRelayedCall(
•    - function _preRelayedCall(bytes memory ...
•    - function _postRelayedCall(bytes memor ...
•  contract GSNMultiSigWalletWithDail ... *
•    - function initialize(address[] memory ...
•    - function changeDailyLimit(uint _daily ...
•    - function executeTransaction(uint tran ...
•    - function isUnderLimit(uint amount)
•    - function calcMaxWithdraw()
•  contract GSNMultisigFactory is GSN ...
•    - function initialize(string memory nam ...
•    - function mint(address account, uint25 ...
•    - function removeMinter(address account ...
•    - function getDeployedWalletsCount(addr ...
•    - function create(address[] memory _own ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-05-01
*/

// File: @openzeppelin/upgrades/contracts/Initializable.sol

pragma solidity >=0.4.24 <0.6.0;


/**
 * @title Initializable
 *
 * @dev Helper contract to support initializer functions. To use it, replace
 * the constructor with a function that has the `initializer` modifier.
 * WARNING: Unlike constructors, initializer functions must be manually
 * invoked. This applies both to deploying an Initializable contract, as well
 * as extending an Initializable contract via inheritance.
 * WARNING: When used with inheritance, manual care must be taken to not invoke
 * a parent initializer twice, or ensure that all initializers are idempotent,
 * because this is not dealt with automatically as with constructors.
 */
contract Initializable {

  /**
   * @dev Indicates that the contract has been initialized.
   */
  bool private initialized;

  /**
   * @dev Indicates that the contract is in the process of being initialized.
   */
  bool private initializing;

  /**
   * @dev Modifier to use in the initializer function of a contract.
   */
  modifier initializer() {
    require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");

    bool isTopLevelCall = !initializing;
    if (isTopLevelCall) {
      initializing = true;
      initialized = true;
    }

    _;

    if (isTopLevelCall) {
      initializing = false;
    }
  }

  /// @dev Returns true if and only if the function is running in the constructor
  function isConstructor() private view returns (bool) {
    // extcodesize checks the size of the code stored in an address, and
    // address returns the current address. Since the code is still not
    // deployed when running a constructor, any checks on its code size will
    // yield zero, making it an effective way to detect if a contract is
    // under construction or not.
    uint256 cs;
    assembly { cs := extcodesize(address) }
    return cs == 0;
  }

  // Reserved storage space to allow for layout changes in the future.
  uint256[50] private ______gap;
}

// File: @openzeppelin/contracts-ethereum-package/contracts/GSN/IRelayRecipient.sol

pragma solidity ^0.5.0;

/**
 * @dev Base interface for a contract that will be called via the GSN from {IRelayHub}.
 *
 * TIP: You don't need to write an implementation yourself! Inherit from {GSNRecipient} instead.
 */
contract IRelayRecipient {
    /**
     * @dev Returns the address of the {IRelayHub} instance this recipient interacts with.
     */
    function getHubAddr() public view returns (address);

    /**
     * @dev Called by {IRelayHub} to validate if this recipient accepts being charged for a relayed call. Note that the
     * recipient will be charged regardless of the execution result of the relayed call (i.e. if it reverts or not).
     *
     * The relay request was originated by `from` and will be served by `relay`. `encodedFunction` is the relayed call
     * calldata, so its first four bytes are the function selector. The relayed call will be forwarded `gasLimit` gas,
     * and the transaction executed with a gas price of at least `gasPrice`. `relay`'s fee is `transactionFee`, and the
     * recipient will be charged at most `maxPossibleCharge` (in wei). `nonce` is the sender's (`from`) nonce for
     * replay attack protection in {IRelayHub}, and `approvalData` is a optional parameter that can be used to hold a signature
     * over all or some of the previous values.
     *
     * Returns a tuple, where the first value is used to indicate approval (0) or rejection (custom non-zero error code,
     * values 1 to 10 are reserved) and the second one is data to be passed to the other {IRelayRecipient} functions.
     *
     * {acceptRelayedCall} is called with 50k gas: if it runs out during execution, the request will be considered
     * rejected. A regular revert will also trigger a rejection.
     */
    function acceptRelayedCall(
        address relay,
        address from,
        bytes calldata encodedFunction,
        uint256 transactionFee,
        uint256 gasPrice,
        uint256 gasLimit,
        uint256 nonce,
        bytes calldata approvalData,
        uint256 maxPossibleCharge
    )
        external
        view
        returns (uint256, bytes memory);

    /**
     * @dev Called by {IRelayHub} on approved relay call requests, before the relayed call is executed. This allows to e.g.
     * pre-charge the sender of the transaction.
     *
     * `context` is the second value returned in the tuple by {acceptRelayedCall}.
     *
     * Returns a value to be passed to {postRelayedCall}.
     *
     * {preRelayedCall} is called with 100k gas: if it runs out during exection or otherwise reverts, the relayed call
     * will not be executed, but the recipient will still be charged for the transaction's cost.
     */
    function preRelayedCall(bytes calldata context) external returns (bytes32);

    /**
     * @dev Called by {IRelayHub} on approved relay call requests, after the relayed call is executed. This allows to e.g.
     * charge the user for the relayed call costs, return any overcharges from {preRelayedCall}, or perform
     * contract-specific bookkeeping.
     *
     * `context` is the second value returned in the tuple by {acceptRelayedCall}. `success` is the execution status of
     * the relayed call. `actualCharge` is an estimate of how much the recipient will be charged for the transaction,
     * not including any gas used by {postRelayedCall} itself. `preRetVal` is {preRelayedCall}'s return value.
     *
     *
     * {postRelayedCall} is called with 100k gas: if it runs out during execution or otherwise reverts, the relayed call
     * and the call to {preRelayedCall} will be reverted retroactively, but the recipient will still be charged for the
     * transaction's cost.
     */
    function postRelayedCall(bytes calldata context, bool success, uint256 actualCharge, bytes32 preRetVal) external;
}

// File: @openzeppelin/contracts-ethereum-package/contracts/GSN/IRelayHub.sol

pragma solidity ^0.5.0;

/**
 * @dev Interface for `RelayHub`, the core contract of the GSN. Users should not need to interact with this contract
 * directly.
 *
 * See the https://github.com/OpenZeppelin/openzeppelin-gsn-helpers[OpenZeppelin GSN helpers] for more information on
 * how to deploy an instance of `RelayHub` on your local test network.
 */
contract IRelayHub {
    // Relay management

    /**
     * @dev Adds stake to a relay and sets its `unstakeDelay`. If the relay does not exist, it is created, and the caller
     * of this function becomes its owner. If the relay already exists, only the owner can call this function. A relay
     * cannot be its own owner.
     *
     * All Ether in this function call will be added to the relay's stake.
     * Its unstake delay will be assigned to `unstakeDelay`, but the new value must be greater or equal to the current one.
     *
     * Emits a {Staked} event.
     */
    function stake(address relayaddr, uint256 unstakeDelay) external payable;

    /**
     * @dev Emitted when a relay's stake or unstakeDelay are increased
     */
    event Staked(address indexed relay, uint256 stake, uint256 unstakeDelay);

    /**
     * @dev Registers the caller as a relay.
     * The relay must be staked for, and not be a contract (i.e. this function must be called directly from an EOA).
     *
     * This function can be called multiple times, emitting new {RelayAdded} events. Note that the received
     * `transactionFee` is not enforced by {relayCall}.
     *
     * Emits a {RelayAdded} event.
     */
    function registerRelay(uint256 transactionFee, string memory url) public;

    /**
     * @dev Emitted when a relay is registered or re-registerd. Looking at these events (and filtering out
     * {RelayRemoved} events) lets a client discover the list of available relays.
     */
    event RelayAdded(address indexed relay, address indexed owner, uint256 transactionFee, uint256 stake, uint256 unstakeDelay, string url);

    /**
     * @dev Removes (deregisters) a relay. Unregistered (but staked for) relays can also be removed.
     *
     * Can only be called by the owner of the relay. After the relay's `unstakeDelay` has elapsed, {unstake} will be
     * callable.
     *
     * Emits a {RelayRemoved} event.
     */
    function removeRelayByOwner(address relay) public;

    /**
     * @dev Emitted when a relay is removed (deregistered). `unstakeTime` is the time when unstake will be callable.
     */
    event RelayRemoved(address indexed relay, uint256 unstakeTime);

    /** Deletes the relay from the system, and gives back its stake to the owner.
     *
     * Can only be called by the relay owner, after `unstakeDelay` has elapsed since {removeRelayByOwner} was called.
     *
     * Emits an {Unstaked} event.
     */
    function unstake(address relay) public;

    /**
     * @dev Emitted when a relay is unstaked for, including the returned stake.
     */
    event Unstaked(address indexed relay, uint256 stake);

    // States a relay can be in
    enum RelayState {
        Unknown, // The relay is unknown to the system: it has never been staked for
        Staked, // The relay has been staked for, but it is not yet active
        Registered, // The relay has registered itself, and is active (can relay calls)
        Removed    // The relay has been removed by its owner and can no longer relay calls. It must wait for its unstakeDelay to elapse before it can unstake
    }

    /**
     * @dev Returns a relay's status. Note that relays can be deleted when unstaked or penalized, causing this function
     * to return an empty entry.
     */
    function getRelay(address relay) external view returns (uint256 totalStake, uint256 unstakeDelay, uint256 unstakeTime, address payable owner, RelayState state);

    // Balance management

    /**
     * @dev Deposits Ether for a contract, so that it can receive (and pay for) relayed transactions.
     *
     * Unused balance can only be withdrawn by the contract itself, by calling {withdraw}.
     *
     * Emits a {Deposited} event.
     */
    function depositFor(address target) public payable;

    /**
     * @dev Emitted when {depositFor} is called, including the amount and account that was funded.
     */
    event Deposited(address indexed recipient, address indexed from, uint256 amount);

    /**
     * @dev Returns an account's deposits. These can be either a contracts's funds, or a relay owner's revenue.
     */
    function balanceOf(address target) external view returns (uint256);

    /**
     * Withdraws from an account's balance, sending it back to it. Relay owners call this to retrieve their revenue, and
     * contracts can use it to reduce their funding.
     *
     * Emits a {Withdrawn} event.
     */
    function withdraw(uint256 amount, address payable dest) public;

    /**
     * @dev Emitted when an account withdraws funds from `RelayHub`.
     */
    event Withdrawn(address indexed account, address indexed dest, uint256 amount);

    // Relaying

    /**
     * @dev Checks if the `RelayHub` will accept a relayed operation.
     * Multiple things must be true for this to happen:
     *  - all arguments must be signed for by the sender (`from`)
     *  - the sender's nonce must be the current one
     *  - the recipient must accept this transaction (via {acceptRelayedCall})
     *
     * Returns a `PreconditionCheck` value (`OK` when the transaction can be relayed), or a recipient-specific error
     * code if it returns one in {acceptRelayedCall}.
     */
    function canRelay(
        address relay,
        address from,
        address to,
        bytes memory encodedFunction,
        uint256 transactionFee,
        uint256 gasPrice,
        uint256 gasLimit,
        uint256 nonce,
        bytes memory signature,
        bytes memory approvalData
    ) public view returns (uint256 status, bytes memory recipientContext);

    // Preconditions for relaying, checked by canRelay and returned as the corresponding numeric values.
    enum PreconditionCheck {
        OK,                         // All checks passed, the call can be relayed
        WrongSignature,             // The transaction to relay is not signed by requested sender
        WrongNonce,                 // The provided nonce has already been used by the sender
        AcceptRelayedCallReverted,  // The recipient rejected this call via acceptRelayedCall
        InvalidRecipientStatusCode  // The recipient returned an invalid (reserved) status code
    }

    /**
     * @dev Relays a transaction.
     *
     * For this to succeed, multiple conditions must be met:
     *  - {canRelay} must `return PreconditionCheck.OK`
     *  - the sender must be a registered relay
     *  - the transaction's gas price must be larger or equal to the one that was requested by the sender
     *  - the transaction must have enough gas to not run out of gas if all internal transactions (calls to the
     * recipient) use all gas available to them
     *  - the recipient must have enough balance to pay the relay for the worst-case scenario (i.e. when all gas is
     * spent)
     *
     * If all conditions are met, the call will be relayed and the recipient charged. {preRelayedCall}, the encoded
     * function and {postRelayedCall} will be called in that order.
     *
     * Parameters:
     *  - `from`: the client originating the request
     *  - `to`: the target {IRelayRecipient} contract
     *  - `encodedFunction`: the function call to relay, including data
     *  - `transactionFee`: fee (%) the relay takes over actual gas cost
     *  - `gasPrice`: gas price the client is willing to pay
     *  - `gasLimit`: gas to forward when calling the encoded function
     *  - `nonce`: client's nonce
     *  - `signature`: client's signature over all previous params, plus the relay and RelayHub addresses
     *  - `approvalData`: dapp-specific data forwared to {acceptRelayedCall}. This value is *not* verified by the
     * `RelayHub`, but it still can be used for e.g. a signature.
     *
     * Emits a {TransactionRelayed} event.
     */
    function relayCall(
        address from,
        address to,
        bytes memory encodedFunction,
        uint256 transactionFee,
        uint256 gasPrice,
        uint256 gasLimit,
        uint256 nonce,
        bytes memory signature,
        bytes memory approvalData
    ) public;

    /**
     * @dev Emitted when an attempt to relay a call failed.
     *
     * This can happen due to incorrect {relayCall} arguments, or the recipient not accepting the relayed call. The
     * actual relayed call was not executed, and the recipient not charged.
     *
     * The `reason` parameter contains an error code: values 1-10 correspond to `PreconditionCheck` entries, and values
     * over 10 are custom recipient error codes returned from {acceptRelayedCall}.
     */
    event CanRelayFailed(address indexed relay, address indexed from, address indexed to, bytes4 selector, uint256 reason);

    /**
     * @dev Emitted when a transaction is relayed. 
     * Useful when monitoring a relay's operation and relayed calls to a contract
     *
     * Note that the actual encoded function might be reverted: this is indicated in the `status` parameter.
     *
     * `charge` is the Ether value deducted from the recipient's balance, paid to the relay's owner.
     */
    event TransactionRelayed(address indexed relay, address indexed from, address indexed to, bytes4 selector, RelayCallStatus status, uint256 charge);

    // Reason error codes for the TransactionRelayed event
    enum RelayCallStatus {
        OK,                      // The transaction was successfully relayed and execution successful - never included in the event
        RelayedCallFailed,       // The transaction was relayed, but the relayed call failed
        PreRelayedFailed,        // The transaction was not relayed due to preRelatedCall reverting
        PostRelayedFailed,       // The transaction was relayed and reverted due to postRelatedCall reverting
        RecipientBalanceChanged  // The transaction was relayed and reverted due to the recipient's balance changing
    }

    /**
     * @dev Returns how much gas should be forwarded to a call to {relayCall}, in order to relay a transaction that will
     * spend up to `relayedCallStipend` gas.
     */
    function requiredGas(uint256 relayedCallStipend) public view returns (uint256);

    /**
     * @dev Returns the maximum recipient charge, given the amount of gas forwarded, gas price and relay fee.
     */
    function maxPossibleCharge(uint256 relayedCallStipend, uint256 gasPrice, uint256 transactionFee) public view returns (uint256);

     // Relay penalization. 
     // Any account can penalize relays, removing them from the system immediately, and rewarding the
    // reporter with half of the relay's stake. The other half is burned so that, even if the relay penalizes itself, it
    // still loses half of its stake.

    /**
     * @dev Penalize a relay that signed two transactions using the same nonce (making only the first one valid) and
     * different data (gas price, gas limit, etc. may be different).
     *
     * The (unsigned) transaction data and signature for both transactions must be provided.
     */
    function penalizeRepeatedNonce(bytes memory unsignedTx1, bytes memory signature1, bytes memory unsignedTx2, bytes memory signature2) public;

    /**
     * @dev Penalize a relay that sent a transaction that didn't target `RelayHub`'s {registerRelay} or {relayCall}.
     */
    function penalizeIllegalTransaction(bytes memory unsignedTx, bytes memory signature) public;

    /**
     * @dev Emitted when a relay is penalized.
     */
    event Penalized(address indexed relay, address sender, uint256 amount);

    /**
     * @dev Returns an account's nonce in `RelayHub`.
     */
    function getNonce(address from) external view returns (uint256);
}

// File: @openzeppelin/contracts-ethereum-package/contracts/GSN/Context.sol

pragma solidity ^0.5.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.
 */
contract Context is Initializable {
    // Empty internal constructor, to prevent people from mistakenly deploying
    // an instance of this contract, which should be used via inheritance.
    constructor () internal { }
    // solhint-disable-previous-line no-empty-blocks

    function _msgSender() internal view returns (address payable) {
        return msg.sender;
    }

    function _msgData() internal view 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-ethereum-package/contracts/GSN/GSNRecipient.sol

pragma solidity ^0.5.0;





/**
 * @dev Base GSN recipient contract: includes the {IRelayRecipient} interface
 * and enables GSN support on all contracts in the inheritance tree.
 *
 * TIP: This contract is abstract. The functions {acceptRelayedCall},
 *  {_preRelayedCall}, and {_postRelayedCall} are not implemented and must be
 * provided by derived contracts. See the
 * xref:ROOT:gsn-strategies.adoc#gsn-strategies[GSN strategies] for more
 * information on how to use the pre-built {GSNRecipientSignature} and
 * {GSNRecipientERC20Fee}, or how to write your own.
 */
contract GSNRecipient is Initializable, IRelayRecipient, Context {
    function initialize() public initializer {
        if (_relayHub == address(0)) {
            setDefaultRelayHub();
        }
    }

    function setDefaultRelayHub() public {
        _upgradeRelayHub(0xD216153c06E857cD7f72665E0aF1d7D82172F494);
    }

    // Default RelayHub address, deployed on mainnet and all testnets at the same address
    address private _relayHub;

    uint256 constant private RELAYED_CALL_ACCEPTED = 0;
    uint256 constant private RELAYED_CALL_REJECTED = 11;

    // How much gas is forwarded to postRelayedCall
    uint256 constant internal POST_RELAYED_CALL_MAX_GAS = 100000;

    /**
     * @dev Emitted when a contract changes its {IRelayHub} contract to a new one.
     */
    event RelayHubChanged(address indexed oldRelayHub, address indexed newRelayHub);

    /**
     * @dev Returns the address of the {IRelayHub} contract for this recipient.
     */
    function getHubAddr() public view returns (address) {
        return _relayHub;
    }

    /**
     * @dev Switches to a new {IRelayHub} instance. This method is added for future-proofing: there's no reason to not
     * use the default instance.
     *
     * IMPORTANT: After upgrading, the {GSNRecipient} will no longer be able to receive relayed calls from the old
     * {IRelayHub} instance. Additionally, all funds should be previously withdrawn via {_withdrawDeposits}.
     */
    function _upgradeRelayHub(address newRelayHub) internal {
        address currentRelayHub = _relayHub;
        require(newRelayHub != address(0), "GSNRecipient: new RelayHub is the zero address");
        require(newRelayHub != currentRelayHub, "GSNRecipient: new RelayHub is the current one");

        emit RelayHubChanged(currentRelayHub, newRelayHub);

        _relayHub = newRelayHub;
    }

    /**
     * @dev Returns the version string of the {IRelayHub} for which this recipient implementation was built. If
     * {_upgradeRelayHub} is used, the new {IRelayHub} instance should be compatible with this version.
     */
    // This function is view for future-proofing, it may require reading from
    // storage in the future.
    function relayHubVersion() public view returns (string memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return "1.0.0";
    }

    /**
     * @dev Withdraws the recipient's deposits in `RelayHub`.
     *
     * Derived contracts should expose this in an external interface with proper access control.
     */
    function _withdrawDeposits(uint256 amount, address payable payee) internal {
        IRelayHub(_relayHub).withdraw(amount, payee);
    }

    // Overrides for Context's functions: when called from RelayHub, sender and
    // data require some pre-processing: the actual sender is stored at the end
    // of the call data, which in turns means it needs to be removed from it
    // when handling said data.

    /**
     * @dev Replacement for msg.sender. Returns the actual sender of a transaction: msg.sender for regular transactions,
     * and the end-user for GSN relayed calls (where msg.sender is actually `RelayHub`).
     *
     * IMPORTANT: Contracts derived from {GSNRecipient} should never use `msg.sender`, and use {_msgSender} instead.
     */
    function _msgSender() internal view returns (address payable) {
        if (msg.sender != _relayHub) {
            return msg.sender;
        } else {
            return _getRelayedCallSender();
        }
    }

    /**
     * @dev Replacement for msg.data. Returns the actual calldata of a transaction: msg.data for regular transactions,
     * and a reduced version for GSN relayed calls (where msg.data contains additional information).
     *
     * IMPORTANT: Contracts derived from {GSNRecipient} should never use `msg.data`, and use {_msgData} instead.
     */
    function _msgData() internal view returns (bytes memory) {
        if (msg.sender != _relayHub) {
            return msg.data;
        } else {
            return _getRelayedCallData();
        }
    }

    // Base implementations for pre and post relayedCall: only RelayHub can invoke them, and data is forwarded to the
    // internal hook.

    /**
     * @dev See `IRelayRecipient.preRelayedCall`.
     *
     * This function should not be overriden directly, use `_preRelayedCall` instead.
     *
     * * Requirements:
     *
     * - the caller must be the `RelayHub` contract.
     */
    function preRelayedCall(bytes calldata context) external returns (bytes32) {
        require(msg.sender == getHubAddr(), "GSNRecipient: caller is not RelayHub");
        return _preRelayedCall(context);
    }

    /**
     * @dev See `IRelayRecipient.preRelayedCall`.
     *
     * Called by `GSNRecipient.preRelayedCall`, which asserts the caller is the `RelayHub` contract. Derived contracts
     * must implement this function with any relayed-call preprocessing they may wish to do.
     *
     */
    function _preRelayedCall(bytes memory context) internal returns (bytes32);

    /**
     * @dev See `IRelayRecipient.postRelayedCall`.
     *
     * This function should not be overriden directly, use `_postRelayedCall` instead.
     *
     * * Requirements:
     *
     * - the caller must be the `RelayHub` contract.
     */
    function postRelayedCall(bytes calldata context, bool success, uint256 actualCharge, bytes32 preRetVal) external {
        require(msg.sender == getHubAddr(), "GSNRecipient: caller is not RelayHub");
        _postRelayedCall(context, success, actualCharge, preRetVal);
    }

    /**
     * @dev See `IRelayRecipient.postRelayedCall`.
     *
     * Called by `GSNRecipient.postRelayedCall`, which asserts the caller is the `RelayHub` contract. Derived contracts
     * must implement this function with any relayed-call postprocessing they may wish to do.
     *
     */
    function _postRelayedCall(bytes memory context, bool success, uint256 actualCharge, bytes32 preRetVal) internal;

    /**
     * @dev Return this in acceptRelayedCall to proceed with the execution of a relayed call. Note that this contract
     * will be charged a fee by RelayHub
     */
    function _approveRelayedCall() internal pure returns (uint256, bytes memory) {
        return _approveRelayedCall("");
    }

    /**
     * @dev See `GSNRecipient._approveRelayedCall`.
     *
     * This overload forwards `context` to _preRelayedCall and _postRelayedCall.
     */
    function _approveRelayedCall(bytes memory context) internal pure returns (uint256, bytes memory) {
        return (RELAYED_CALL_ACCEPTED, context);
    }

    /**
     * @dev Return this in acceptRelayedCall to impede execution of a relayed call. No fees will be charged.
     */
    function _rejectRelayedCall(uint256 errorCode) internal pure returns (uint256, bytes memory) {
        return (RELAYED_CALL_REJECTED + errorCode, "");
    }

    /*
     * @dev Calculates how much RelayHub will charge a recipient for using `gas` at a `gasPrice`, given a relayer's
     * `serviceFee`.
     */
    function _computeCharge(uint256 gas, uint256 gasPrice, uint256 serviceFee) internal pure returns (uint256) {
        // The fee is expressed as a percentage. E.g. a value of 40 stands for a 40% fee, so the recipient will be
        // charged for 1.4 times the spent amount.
        return (gas * gasPrice * (100 + serviceFee)) / 100;
    }

    function _getRelayedCallSender() private pure returns (address payable result) {
        // We need to read 20 bytes (an address) located at array index msg.data.length - 20. In memory, the array
        // is prefixed with a 32-byte length value, so we first add 32 to get the memory read index. However, doing
        // so would leave the address in the upper 20 bytes of the 32-byte word, which is inconvenient and would
        // require bit shifting. We therefore subtract 12 from the read index so the address lands on the lower 20
        // bytes. This can always be done due to the 32-byte prefix.

        // The final memory read index is msg.data.length - 20 + 32 - 12 = msg.data.length. Using inline assembly is the
        // easiest/most-efficient way to perform this operation.

        // These fields are not accessible from assembly
        bytes memory array = msg.data;
        uint256 index = msg.data.length;

        // solhint-disable-next-line no-inline-assembly
        assembly {
            // Load the 32 bytes word from memory with the address on the lower 20 bytes, and mask those.
            result := and(mload(add(array, index)), 0xffffffffffffffffffffffffffffffffffffffff)
        }
        return result;
    }

    function _getRelayedCallData() private pure returns (bytes memory) {
        // RelayHub appends the sender address at the end of the calldata, so in order to retrieve the actual msg.data,
        // we must strip the last 20 bytes (length of an address type) from it.

        uint256 actualDataLength = msg.data.length - 20;
        bytes memory actualData = new bytes(actualDataLength);

        for (uint256 i = 0; i < actualDataLength; ++i) {
            actualData[i] = msg.data[i];
        }

        return actualData;
    }
}

// File: @openzeppelin/contracts-ethereum-package/contracts/math/SafeMath.sol

pragma solidity ^0.5.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.
     *
     * _Available since v2.4.0._
     */
    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.
     *
     * _Available since v2.4.0._
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        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.
     *
     * _Available since v2.4.0._
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

// File: @openzeppelin/contracts-ethereum-package/contracts/ownership/Secondary.sol

pragma solidity ^0.5.0;



/**
 * @dev A Secondary contract can only be used by its primary account (the one that created it).
 */
contract Secondary is Initializable, Context {
    address private _primary;

    /**
     * @dev Emitted when the primary contract changes.
     */
    event PrimaryTransferred(
        address recipient
    );

    /**
     * @dev Sets the primary account to the one that is creating the Secondary contract.
     */
    function initialize(address sender) public initializer {
        _primary = sender;
        emit PrimaryTransferred(_primary);
    }

    /**
     * @dev Reverts if called from any account other than the primary.
     */
    modifier onlyPrimary() {
        require(_msgSender() == _primary, "Secondary: caller is not the primary account");
        _;
    }

    /**
     * @return the address of the primary.
     */
    function primary() public view returns (address) {
        return _primary;
    }

    /**
     * @dev Transfers contract to a new primary.
     * @param recipient The address of new primary.
     */
    function transferPrimary(address recipient) public onlyPrimary {
        require(recipient != address(0), "Secondary: new primary is the zero address");
        _primary = recipient;
        emit PrimaryTransferred(_primary);
    }

    uint256[50] private ______gap;
}

// File: @openzeppelin/contracts-ethereum-package/contracts/token/ERC20/IERC20.sol

pragma solidity ^0.5.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP. Does not include
 * the optional functions; to access them see {ERC20Detailed}.
 */
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-ethereum-package/contracts/utils/Address.sol

pragma solidity ^0.5.5;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * This test is non-exhaustive, and there may be false-negatives: during the
     * execution of a contract's constructor, its address will be reported as
     * not containing 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.
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies in extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        // 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 != 0x0 && codehash != accountHash);
    }

    /**
     * @dev Converts an `address` into `address payable`. Note that this is
     * simply a type cast: the actual underlying value is not changed.
     *
     * _Available since v2.4.0._
     */
    function toPayable(address account) internal pure returns (address payable) {
        return address(uint160(account));
    }

    /**
     * @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].
     *
     * _Available since v2.4.0._
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

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

// File: @openzeppelin/contracts-ethereum-package/contracts/token/ERC20/SafeERC20.sol

pragma solidity ^0.5.0;




/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for ERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves.

        // A Solidity high level call has three parts:
        //  1. The target address is checked to verify it contains contract code
        //  2. The call itself is made, and success asserted
        //  3. The return value is decoded, which in turn checks the size of the returned data.
        // solhint-disable-next-line max-line-length
        require(address(token).isContract(), "SafeERC20: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = address(token).call(data);
        require(success, "SafeERC20: low-level call failed");

        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// File: @openzeppelin/contracts-ethereum-package/contracts/token/ERC20/ERC20.sol

pragma solidity ^0.5.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 {ERC20Mintable}.
 *
 * 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 Initializable, Context, IERC20 {
    using SafeMath for uint256;

    mapping (address => uint256) private _balances;

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

    uint256 private _totalSupply;

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

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view 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 returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

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

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public 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 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 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 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 {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _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 {
        require(account != address(0), "ERC20: mint to the zero address");

        _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 {
        require(account != address(0), "ERC20: burn from the zero address");

        _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 {
        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 Destroys `amount` tokens from `account`.`amount` is then deducted
     * from the caller's allowance.
     *
     * See {_burn} and {_approve}.
     */
    function _burnFrom(address account, uint256 amount) internal {
        _burn(account, amount);
        _approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
    }

    uint256[50] private ______gap;
}

// File: @openzeppelin/contracts-ethereum-package/contracts/token/ERC20/ERC20Detailed.sol

pragma solidity ^0.5.0;



/**
 * @dev Optional functions from the ERC20 standard.
 */
contract ERC20Detailed is Initializable, IERC20 {
    string private _name;
    string private _symbol;
    uint8 private _decimals;

    /**
     * @dev Sets the values for `name`, `symbol`, and `decimals`. All three of
     * these values are immutable: they can only be set once during
     * construction.
     */
    function initialize(string memory name, string memory symbol, uint8 decimals) public initializer {
        _name = name;
        _symbol = symbol;
        _decimals = decimals;
    }

    /**
     * @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.
     *
     * 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;
    }

    uint256[50] private ______gap;
}

// File: @openzeppelin/contracts-ethereum-package/contracts/GSN/GSNRecipientERC20Fee.sol

pragma solidity ^0.5.0;








/**
 * @dev A xref:ROOT:gsn-strategies.adoc#gsn-strategies[GSN strategy] that charges transaction fees in a special purpose ERC20
 * token, which we refer to as the gas payment token. The amount charged is exactly the amount of Ether charged to the
 * recipient. This means that the token is essentially pegged to the value of Ether.
 *
 * The distribution strategy of the gas payment token to users is not defined by this contract. It's a mintable token
 * whose only minter is the recipient, so the strategy must be implemented in a derived contract, making use of the
 * internal {_mint} function.
 */
contract GSNRecipientERC20Fee is Initializable, GSNRecipient {
    using SafeERC20 for __unstable__ERC20PrimaryAdmin;
    using SafeMath for uint256;

    enum GSNRecipientERC20FeeErrorCodes {
        INSUFFICIENT_BALANCE
    }

    __unstable__ERC20PrimaryAdmin private _token;

    /**
     * @dev The arguments to the constructor are the details that the gas payment token will have: `name` and `symbol`. `decimals` is hard-coded to 18.
     */
    function initialize(string memory name, string memory symbol) public initializer {
        if (_token == __unstable__ERC20PrimaryAdmin(0)) {
            _token = new __unstable__ERC20PrimaryAdmin();
            _token.initialize(name, symbol, 18, address(this));
        }

        GSNRecipient.initialize();
    }

    /**
     * @dev Returns the gas payment token.
     */
    function token() public view returns (IERC20) {
        return IERC20(_token);
    }

    /**
     * @dev Internal function that mints the gas payment token. Derived contracts should expose this function in their public API, with proper access control mechanisms.
     */
    function _mint(address account, uint256 amount) internal {
        _token.mint(account, amount);
    }

    /**
     * @dev Ensures that only users with enough gas payment token balance can have transactions relayed through the GSN.
     */
    function acceptRelayedCall(
        address,
        address from,
        bytes calldata,
        uint256 transactionFee,
        uint256 gasPrice,
        uint256,
        uint256,
        bytes calldata,
        uint256 maxPossibleCharge
    )
        external
        view
        returns (uint256, bytes memory)
    {
        if (_token.balanceOf(from) < maxPossibleCharge) {
            return _rejectRelayedCall(uint256(GSNRecipientERC20FeeErrorCodes.INSUFFICIENT_BALANCE));
        }

        return _approveRelayedCall(abi.encode(from, maxPossibleCharge, transactionFee, gasPrice));
    }

    /**
     * @dev Implements the precharge to the user. The maximum possible charge (depending on gas limit, gas price, and
     * fee) will be deducted from the user balance of gas payment token. Note that this is an overestimation of the
     * actual charge, necessary because we cannot predict how much gas the execution will actually need. The remainder
     * is returned to the user in {_postRelayedCall}.
     */
    function _preRelayedCall(bytes memory context) internal returns (bytes32) {
        (address from, uint256 maxPossibleCharge) = abi.decode(context, (address, uint256));

        // The maximum token charge is pre-charged from the user
        _token.safeTransferFrom(from, address(this), maxPossibleCharge);
    }

    /**
     * @dev Returns to the user the extra amount that was previously charged, once the actual execution cost is known.
     */
    function _postRelayedCall(bytes memory context, bool, uint256 actualCharge, bytes32) internal {
        (address from, uint256 maxPossibleCharge, uint256 transactionFee, uint256 gasPrice) =
            abi.decode(context, (address, uint256, uint256, uint256));

        // actualCharge is an _estimated_ charge, which assumes postRelayedCall will use all available gas.
        // This implementation's gas cost can be roughly estimated as 10k gas, for the two SSTORE operations in an
        // ERC20 transfer.
        uint256 overestimation = _computeCharge(POST_RELAYED_CALL_MAX_GAS.sub(10000), gasPrice, transactionFee);
        actualCharge = actualCharge.sub(overestimation);

        // After the relayed call has been executed and the actual charge estimated, the excess pre-charge is returned
        _token.safeTransfer(from, maxPossibleCharge.sub(actualCharge));
    }
}

/**
 * @title __unstable__ERC20PrimaryAdmin
 * @dev An ERC20 token owned by another contract, which has minting permissions and can use transferFrom to receive
 * anyone's tokens. This contract is an internal helper for GSNRecipientERC20Fee, and should not be used
 * outside of this context.
 */
// solhint-disable-next-line contract-name-camelcase
contract __unstable__ERC20PrimaryAdmin is Initializable, ERC20, ERC20Detailed, Secondary {
    uint256 private constant UINT256_MAX = 2**256 - 1;

    function initialize(string memory name, string memory symbol, uint8 decimals, address sender) public initializer {
        ERC20Detailed.initialize(name, symbol, decimals);
        Secondary.initialize(sender);
    }

    // The primary account (GSNRecipientERC20Fee) can mint tokens
    function mint(address account, uint256 amount) public onlyPrimary {
        _mint(account, amount);
    }

    // The primary account has 'infinite' allowance for all token holders
    function allowance(address owner, address spender) public view returns (uint256) {
        if (spender == primary()) {
            return UINT256_MAX;
        } else {
            return super.allowance(owner, spender);
        }
    }

    // Allowance for the primary account cannot be changed (it is always 'infinite')
    function _approve(address owner, address spender, uint256 value) internal {
        if (spender == primary()) {
            return;
        } else {
            super._approve(owner, spender, value);
        }
    }

    function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
        if (recipient == primary()) {
            _transfer(sender, recipient, amount);
            return true;
        } else {
            return super.transferFrom(sender, recipient, amount);
        }
    }
}

// File: @openzeppelin/contracts-ethereum-package/contracts/access/Roles.sol

pragma solidity ^0.5.0;

/**
 * @title Roles
 * @dev Library for managing addresses assigned to a Role.
 */
library Roles {
    struct Role {
        mapping (address => bool) bearer;
    }

    /**
     * @dev Give an account access to this role.
     */
    function add(Role storage role, address account) internal {
        require(!has(role, account), "Roles: account already has role");
        role.bearer[account] = true;
    }

    /**
     * @dev Remove an account's access to this role.
     */
    function remove(Role storage role, address account) internal {
        require(has(role, account), "Roles: account does not have role");
        role.bearer[account] = false;
    }

    /**
     * @dev Check if an account has this role.
     * @return bool
     */
    function has(Role storage role, address account) internal view returns (bool) {
        require(account != address(0), "Roles: account is the zero address");
        return role.bearer[account];
    }
}

// File: @openzeppelin/contracts-ethereum-package/contracts/access/roles/MinterRole.sol

pragma solidity ^0.5.0;




contract MinterRole is Initializable, Context {
    using Roles for Roles.Role;

    event MinterAdded(address indexed account);
    event MinterRemoved(address indexed account);

    Roles.Role private _minters;

    function initialize(address sender) public initializer {
        if (!isMinter(sender)) {
            _addMinter(sender);
        }
    }

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

    function isMinter(address account) public view returns (bool) {
        return _minters.has(account);
    }

    function addMinter(address account) public onlyMinter {
        _addMinter(account);
    }

    function renounceMinter() public {
        _removeMinter(_msgSender());
    }

    function _addMinter(address account) internal {
        _minters.add(account);
        emit MinterAdded(account);
    }

    function _removeMinter(address account) internal {
        _minters.remove(account);
        emit MinterRemoved(account);
    }

    uint256[50] private ______gap;
}

// File: @openzeppelin/contracts-ethereum-package/contracts/ownership/Ownable.sol

pragma solidity ^0.5.0;



/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be aplied to your functions to restrict their use to
 * the owner.
 */
contract Ownable is Initializable, Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    function initialize(address sender) public initializer {
        _owner = sender;
        emit OwnershipTransferred(address(0), _owner);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(isOwner(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Returns true if the caller is the current owner.
     */
    function isOwner() public view returns (bool) {
        return _msgSender() == _owner;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * > Note: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public onlyOwner {
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     */
    function _transferOwnership(address newOwner) internal {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }

    uint256[50] private ______gap;
}

// File: contracts/GSNMultiSigWallet.sol

pragma solidity 0.5.13;


/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution.
/// @author Stefan George - <[email protected]>
contract GSNMultiSigWallet is GSNRecipient {

    /*
     *  Events
     */
    event Confirmation(address indexed sender, uint indexed transactionId);
    event Revocation(address indexed sender, uint indexed transactionId);
    event Submission(uint indexed transactionId);
    event Execution(uint indexed transactionId);
    event ExecutionFailure(uint indexed transactionId);
    event Deposit(address indexed sender, uint value);
    event OwnerAddition(address indexed owner);
    event OwnerRemoval(address indexed owner);
    event RequirementChange(uint required);

    /*
     *  Constants
     */
    uint constant public MAX_OWNER_COUNT = 50;

    /*
     *  Storage
     */
    mapping (uint => Transaction) public transactions;
    mapping (uint => mapping (address => bool)) public confirmations;
    mapping (address => bool) public isOwner;
    address[] public owners;
    uint public required;
    uint public transactionCount;

    struct Transaction {
        address destination;
        uint value;
        bytes data;
        bool executed;
    }

    /*
     *  Modifiers
     */
    modifier onlyWallet() {
        require(_msgSender() == address(this));
        _;
    }

    modifier ownerDoesNotExist(address owner) {
        require(!isOwner[owner]);
        _;
    }

    modifier ownerExists(address owner) {
        require(isOwner[owner]);
        _;
    }

    modifier transactionExists(uint transactionId) {
        require(transactions[transactionId].destination != address(0));
        _;
    }

    modifier confirmed(uint transactionId, address owner) {
        require(confirmations[transactionId][owner]);
        _;
    }

    modifier notConfirmed(uint transactionId, address owner) {
        require(!confirmations[transactionId][owner]);
        _;
    }

    modifier notExecuted(uint transactionId) {
        require(!transactions[transactionId].executed);
        _;
    }

    modifier notNull(address _address) {
        require(_address != address(0));
        _;
    }

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

    /// @dev Fallback function allows to deposit ether.
    function()
        external
        payable
    {
        if (msg.value > 0)
            // msg.sender safe to use instead of _msgSender()
            // because fallback never called by RelayHub directly
            emit Deposit(msg.sender, msg.value);
    }

    /*
     * Public functions
     */
    /// @dev Contract constructor sets initial owners and required number of confirmations.
    /// @param _owners List of initial owners.
    /// @param _required Number of required confirmations.
    function initialize(address[] memory _owners, uint _required) public initializer
    validRequirement(_owners.length, _required)
    {
        GSNRecipient.initialize();
        for (uint i=0; i<_owners.length; i++) {
            require(!isOwner[_owners[i]] && _owners[i] != address(0));
            isOwner[_owners[i]] = true;
        }
        owners = _owners;
        required = _required;
    }

    /// @dev Allows to add a new owner. Transaction has to be sent by wallet.
    /// @param owner Address of new owner.
    function addOwner(address owner)
        public
        onlyWallet
        ownerDoesNotExist(owner)
        notNull(owner)
        validRequirement(owners.length + 1, required)
    {
        isOwner[owner] = true;
        owners.push(owner);
        emit OwnerAddition(owner);
    }

    /// @dev Allows to remove an owner. Transaction has to be sent by wallet.
    /// @param owner Address of owner.
    function removeOwner(address owner)
        public
        onlyWallet
        ownerExists(owner)
    {
        isOwner[owner] = false;
        for (uint i=0; i<owners.length - 1; i++)
            if (owners[i] == owner) {
                owners[i] = owners[owners.length - 1];
                break;
            }
        owners.length -= 1;
        if (required > owners.length)
            changeRequirement(owners.length);
        emit OwnerRemoval(owner);
    }

    /// @dev Allows to replace an owner with a new owner. Transaction has to be sent by wallet.
    /// @param owner Address of owner to be replaced.
    /// @param newOwner Address of new owner.
    function replaceOwner(address owner, address newOwner)
        public
        onlyWallet
        ownerExists(owner)
        ownerDoesNotExist(newOwner)
    {
        for (uint i=0; i<owners.length; i++)
            if (owners[i] == owner) {
                owners[i] = newOwner;
                break;
            }
        isOwner[owner] = false;
        isOwner[newOwner] = true;
        emit OwnerRemoval(owner);
        emit OwnerAddition(newOwner);
    }

    /// @dev Allows to change the number of required confirmations. Transaction has to be sent by wallet.
    /// @param _required Number of required confirmations.
    function changeRequirement(uint _required)
        public
        onlyWallet
        validRequirement(owners.length, _required)
    {
        required = _required;
        emit RequirementChange(_required);
    }

    /// @dev Allows an owner to submit and confirm a transaction.
    /// @param destination Transaction target address.
    /// @param value Transaction ether value.
    /// @param data Transaction data payload.
    /// @return Returns transaction ID.
    function submitTransaction(address destination, uint value, bytes memory data)
        public
        returns (uint transactionId)
    {
        transactionId = addTransaction(destination, value, data);
        confirmTransaction(transactionId);
    }

    /// @dev Allows an owner to confirm a transaction.
    /// @param transactionId Transaction ID.
    function confirmTransaction(uint transactionId)
        public
        ownerExists(_msgSender())
        transactionExists(transactionId)
        notConfirmed(transactionId, _msgSender())
    {
        confirmations[transactionId][_msgSender()] = true;
        emit Confirmation(_msgSender(), transactionId);
        executeTransaction(transactionId);
    }

    /// @dev Allows an owner to revoke a confirmation for a transaction.
    /// @param transactionId Transaction ID.
    function revokeConfirmation(uint transactionId)
        public
        ownerExists(_msgSender())
        confirmed(transactionId, _msgSender())
        notExecuted(transactionId)
    {
        confirmations[transactionId][_msgSender()] = false;
        emit Revocation(_msgSender(), transactionId);
    }

    /// @dev Allows anyone to execute a confirmed transaction.
    /// @param transactionId Transaction ID.
    function executeTransaction(uint transactionId)
        public
        ownerExists(_msgSender())
        confirmed(transactionId, _msgSender())
        notExecuted(transactionId)
    {
        if (isConfirmed(transactionId)) {
            Transaction storage txn = transactions[transactionId];
            txn.executed = true;
            if (external_call(txn.destination, txn.value, txn.data.length, txn.data))
                emit Execution(transactionId);
            else {
                emit ExecutionFailure(transactionId);
                txn.executed = false;
            }
        }
    }

    // call has been separated into its own function in order to take advantage
    // of the Solidity's code generator to produce a loop that copies tx.data into memory.
    function external_call(address destination, uint value, uint dataLength, bytes memory data) internal returns (bool) {
        bool result;
        assembly {
            let x := mload(0x40)   // "Allocate" memory for output (0x40 is where "free memory" pointer is stored by convention)
            let d := add(data, 32) // First 32 bytes are the padded length of data, so exclude that
            result := call(
                sub(gas, 34710),   // 34710 is the value that solidity is currently emitting
                                   // It includes callGas (700) + callVeryLow (3, to pay for SUB) + callValueTransferGas (9000) +
                                   // callNewAccountGas (25000, in case the destination address does not exist and needs creating)
                destination,
                value,
                d,
                dataLength,        // Size of the input (in bytes) - this is what fixes the padding problem
                x,
                0                  // Output is ignored, therefore the output size is zero
            )
        }
        return result;
    }

    /// @dev Returns the confirmation status of a transaction.
    /// @param transactionId Transaction ID.
    /// @return Confirmation status.
    function isConfirmed(uint transactionId)
        public
        view
        returns (bool)
    {
        uint count = 0;
        for (uint i=0; i<owners.length; i++) {
            if (confirmations[transactionId][owners[i]])
                count += 1;
            if (count == required)
                return true;
        }
    }

    /*
     * Internal functions
     */
    /// @dev Adds a new transaction to the transaction mapping, if transaction does not exist yet.
    /// @param destination Transaction target address.
    /// @param value Transaction ether value.
    /// @param data Transaction data payload.
    /// @return Returns transaction ID.
    function addTransaction(address destination, uint value, bytes memory data)
        internal
        notNull(destination)
        returns (uint transactionId)
    {
        transactionId = transactionCount;
        transactions[transactionId] = Transaction({
            destination: destination,
            value: value,
            data: data,
            executed: false
        });
        transactionCount += 1;
        emit Submission(transactionId);
    }

    /*
     * Web3 call functions
     */
    /// @dev Returns number of confirmations of a transaction.
    /// @param transactionId Transaction ID.
    /// @return Number of confirmations.
    function getConfirmationCount(uint transactionId)
        public
        view
        returns (uint count)
    {
        for (uint i=0; i<owners.length; i++)
            if (confirmations[transactionId][owners[i]])
                count += 1;
    }

    /// @dev Returns total number of transactions after filers are applied.
    /// @param pending Include pending transactions.
    /// @param executed Include executed transactions.
    /// @return Total number of transactions after filters are applied.
    function getTransactionCount(bool pending, bool executed)
        public
        view
        returns (uint count)
    {
        for (uint i=0; i<transactionCount; i++)
            if (   pending && !transactions[i].executed
                || executed && transactions[i].executed)
                count += 1;
    }

    /// @dev Returns list of owners.
    /// @return List of owner addresses.
    function getOwners()
        public
        view
        returns (address[] memory)
    {
        return owners;
    }

    /// @dev Returns array with owner addresses, which confirmed transaction.
    /// @param transactionId Transaction ID.
    /// @return Returns array of owner addresses.
    function getConfirmations(uint transactionId)
        public
        view
        returns (address[] memory _confirmations)
    {
        address[] memory confirmationsTemp = new address[](owners.length);
        uint count = 0;
        uint i;
        for (i=0; i<owners.length; i++)
            if (confirmations[transactionId][owners[i]]) {
                confirmationsTemp[count] = owners[i];
                count += 1;
            }
        _confirmations = new address[](count);
        for (i=0; i<count; i++)
            _confirmations[i] = confirmationsTemp[i];
    }

    /// @dev Returns list of transaction IDs in defined range.
    /// @param from Index start position of transaction array.
    /// @param to Index end position of transaction array.
    /// @param pending Include pending transactions.
    /// @param executed Include executed transactions.
    /// @return Returns array of transaction IDs.
    function getTransactionIds(uint from, uint to, bool pending, bool executed)
        public
        view
        returns (uint[] memory _transactionIds)
    {
        uint[] memory transactionIdsTemp = new uint[](transactionCount);
        uint count = 0;
        uint i;
        for (i=0; i<transactionCount; i++)
            if (   pending && !transactions[i].executed
                || executed && transactions[i].executed)
            {
                transactionIdsTemp[count] = i;
                count += 1;
            }
        _transactionIds = new uint[](to - from);
        for (i=from; i<to; i++)
            _transactionIds[i - from] = transactionIdsTemp[i];
    }

    // accept all requests
    function acceptRelayedCall(
        address,
        address from,
        bytes calldata,
        uint256 transactionFee,
        uint256 gasPrice,
        uint256,
        uint256,
        bytes calldata,
        uint256 maxPossibleCharge
        ) external view returns (uint256, bytes memory) {
        return _approveRelayedCall(abi.encode(from, maxPossibleCharge, transactionFee, gasPrice));
    }

    function _preRelayedCall(bytes memory context) internal returns (bytes32) {
        return "";
    }

    function _postRelayedCall(bytes memory context, bool, uint256 actualCharge, bytes32) internal {
    }
}

// File: contracts/GSNMultiSigWalletWithDailyLimit.sol

pragma solidity 0.5.13;



/// @title Multisignature wallet with daily limit - Allows an owner to withdraw a daily limit without multisig.
/// @author Stefan George - <[email protected]>
contract GSNMultiSigWalletWithDailyLimit is GSNMultiSigWallet {

    /*
     *  Events
     */
    event DailyLimitChange(uint dailyLimit);

    /*
     *  Storage
     */
    uint public dailyLimit;
    uint public lastDay;
    uint public spentToday;

    /*
     * Public functions
     */
    /// @dev Contract constructor sets initial owners, required number of confirmations and daily withdraw limit.
    /// @param _owners List of initial owners.
    /// @param _required Number of required confirmations.
    /// @param _dailyLimit Amount in wei, which can be withdrawn without confirmations on a daily basis.
    function initialize(address[] memory _owners, uint _required, uint _dailyLimit)
        public initializer
    {
        GSNMultiSigWallet.initialize(_owners, _required);
        dailyLimit = _dailyLimit;
    }

    /// @dev Allows to change the daily limit. Transaction has to be sent by wallet.
    /// @param _dailyLimit Amount in wei.
    function changeDailyLimit(uint _dailyLimit)
        public
        onlyWallet
    {
        dailyLimit = _dailyLimit;
        emit DailyLimitChange(_dailyLimit);
    }

    /// @dev Allows anyone to execute a confirmed transaction or ether withdraws until daily limit is reached.
    /// @param transactionId Transaction ID.
    function executeTransaction(uint transactionId)
        public
        ownerExists(_msgSender())
        confirmed(transactionId, _msgSender())
        notExecuted(transactionId)
    {
        Transaction storage txn = transactions[transactionId];
        bool _confirmed = isConfirmed(transactionId);
        if (_confirmed || txn.data.length == 0 && isUnderLimit(txn.value)) {
            txn.executed = true;
            if (!_confirmed)
                spentToday += txn.value;
            if (external_call(txn.destination, txn.value, txn.data.length, txn.data))
                emit Execution(transactionId);
            else {
                emit ExecutionFailure(transactionId);
                txn.executed = false;
                if (!_confirmed)
                    spentToday -= txn.value;
            }
        }
    }

    /*
     * Internal functions
     */
    /// @dev Returns if amount is within daily limit and resets spentToday after one day.
    /// @param amount Amount to withdraw.
    /// @return Returns if amount is under daily limit.
    function isUnderLimit(uint amount)
        internal
        returns (bool)
    {
        if (now > lastDay + 24 hours) {
            lastDay = now;
            spentToday = 0;
        }
        if (spentToday + amount > dailyLimit || spentToday + amount < spentToday)
            return false;
        return true;
    }

    /*
     * Web3 call functions
     */
    /// @dev Returns maximum withdraw amount.
    /// @return Returns amount.
    function calcMaxWithdraw()
        public
        view
        returns (uint)
    {
        if (now > lastDay + 24 hours)
            return dailyLimit;
        if (dailyLimit < spentToday)
            return 0;
        return dailyLimit - spentToday;
    }
}

// File: contracts/GSNMultisigFactory.sol

pragma solidity 0.5.13;





contract GSNMultisigFactory is GSNRecipientERC20Fee, MinterRole, Ownable {
    mapping(address => address[]) public deployedWallets;
    mapping(address => bool) public isMULTISigWallet;

    event ContractInstantiation(address sender, address instantiation);

    function initialize(string memory name, string memory symbol) initializer public 
    {
        GSNRecipientERC20Fee.initialize(name, symbol);
        MinterRole.initialize(_msgSender());
        Ownable.initialize(_msgSender());
    }

    function mint(address account, uint256 amount) public onlyMinter {
        _mint(account, amount);
    }

    function removeMinter(address account) public onlyOwner {
        _removeMinter(account);
    }

    /*
     * Public functions
     */
    /// @dev Returns number of instantiations by creator.
    /// @param creator Contract creator.
    /// @return Returns number of instantiations by creator.
    function getDeployedWalletsCount(address creator) public view returns(uint) {
        return deployedWallets[creator].length;
    }

    function create(address[] memory _owners, uint _required, uint _dailyLimit) public returns (address wallet)
    {
        GSNMultiSigWalletWithDailyLimit multisig = new GSNMultiSigWalletWithDailyLimit();
        multisig.initialize(_owners, _required, _dailyLimit);
        wallet = address(multisig);
        isMULTISigWallet[wallet] = true;
        deployedWallets[_msgSender()].push(wallet);

        emit ContractInstantiation(_msgSender(), wallet);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"uint256","name":"transactionId","type":"uint256"}],"name":"Confirmation","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"dailyLimit","type":"uint256"}],"name":"DailyLimitChange","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"transactionId","type":"uint256"}],"name":"Execution","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"transactionId","type":"uint256"}],"name":"ExecutionFailure","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"}],"name":"OwnerAddition","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"}],"name":"OwnerRemoval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldRelayHub","type":"address"},{"indexed":true,"internalType":"address","name":"newRelayHub","type":"address"}],"name":"RelayHubChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"required","type":"uint256"}],"name":"RequirementChange","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"uint256","name":"transactionId","type":"uint256"}],"name":"Revocation","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"transactionId","type":"uint256"}],"name":"Submission","type":"event"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"constant":true,"inputs":[],"name":"MAX_OWNER_COUNT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"bytes","name":"","type":"bytes"},{"internalType":"uint256","name":"transactionFee","type":"uint256"},{"internalType":"uint256","name":"gasPrice","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"},{"internalType":"uint256","name":"maxPossibleCharge","type":"uint256"}],"name":"acceptRelayedCall","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"addOwner","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"calcMaxWithdraw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"_dailyLimit","type":"uint256"}],"name":"changeDailyLimit","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"_required","type":"uint256"}],"name":"changeRequirement","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"transactionId","type":"uint256"}],"name":"confirmTransaction","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"confirmations","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"dailyLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"transactionId","type":"uint256"}],"name":"executeTransaction","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"transactionId","type":"uint256"}],"name":"getConfirmationCount","outputs":[{"internalType":"uint256","name":"count","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"transactionId","type":"uint256"}],"name":"getConfirmations","outputs":[{"internalType":"address[]","name":"_confirmations","type":"address[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"getHubAddr","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":[{"internalType":"bool","name":"pending","type":"bool"},{"internalType":"bool","name":"executed","type":"bool"}],"name":"getTransactionCount","outputs":[{"internalType":"uint256","name":"count","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"from","type":"uint256"},{"internalType":"uint256","name":"to","type":"uint256"},{"internalType":"bool","name":"pending","type":"bool"},{"internalType":"bool","name":"executed","type":"bool"}],"name":"getTransactionIds","outputs":[{"internalType":"uint256[]","name":"_transactionIds","type":"uint256[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address[]","name":"_owners","type":"address[]"},{"internalType":"uint256","name":"_required","type":"uint256"},{"internalType":"uint256","name":"_dailyLimit","type":"uint256"}],"name":"initialize","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address[]","name":"_owners","type":"address[]"},{"internalType":"uint256","name":"_required","type":"uint256"}],"name":"initialize","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"initialize","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"transactionId","type":"uint256"}],"name":"isConfirmed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"lastDay","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"owners","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"bytes","name":"context","type":"bytes"},{"internalType":"bool","name":"success","type":"bool"},{"internalType":"uint256","name":"actualCharge","type":"uint256"},{"internalType":"bytes32","name":"preRetVal","type":"bytes32"}],"name":"postRelayedCall","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"bytes","name":"context","type":"bytes"}],"name":"preRelayedCall","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"relayHubVersion","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","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":"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":"uint256","name":"transactionId","type":"uint256"}],"name":"revokeConfirmation","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"setDefaultRelayHub","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"spentToday","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"destination","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"submitTransaction","outputs":[{"internalType":"uint256","name":"transactionId","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"transactionCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"transactions","outputs":[{"internalType":"address","name":"destination","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"bool","name":"executed","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"}]

0x6080604052600436106102045760003560e01c806383947ea011610118578063c01a8c84116100a0578063dc8452cd1161006f578063dc8452cd14610b9d578063e06e0e2214610bb2578063e20056e614610c3b578063ee22610b14610c76578063f059cf2b14610ca057610204565b8063c01a8c8414610a6e578063c642747414610a98578063cea0862114610b5e578063d74f8edd14610b8857610204565b8063a8abe69a116100e7578063a8abe69a1461093b578063ad61ccd51461097b578063b5dc40c314610a05578063b77bf60014610a2f578063ba51a6df14610a4457610204565b806383947ea0146106655780638b51d13f146107df5780639ace38c214610809578063a0e67e2b146108d657610204565b80635eae79591161019b5780637065cb481161016a5780637065cb481461056357806374e861d614610596578063784547a7146105ab57806380274db7146105d55780638129fc1c1461065057610204565b80635eae7959146103d657806360b5bb3f1461048957806367eeba0c146105395780636b0c932d1461054e57610204565b80632f54bf6e116101d75780632f54bf6e146102fb5780633411c81c146103425780634bc9fdc21461037b57806354741525146103a257610204565b8063025e7c27146102435780631220e2ff14610289578063173825d91461029e57806320ea8d86146102d1575b34156102415760408051348152905133917fe1fffcc4923d04b559f4d29a8bfc6cda04eb5b0d3c460751c2402c5c5cc9109c919081900360200190a25b005b34801561024f57600080fd5b5061026d6004803603602081101561026657600080fd5b5035610cb5565b604080516001600160a01b039092168252519081900360200190f35b34801561029557600080fd5b50610241610cdc565b3480156102aa57600080fd5b50610241600480360360208110156102c157600080fd5b50356001600160a01b0316610cfb565b3480156102dd57600080fd5b50610241600480360360208110156102f457600080fd5b5035610e77565b34801561030757600080fd5b5061032e6004803603602081101561031e57600080fd5b50356001600160a01b0316610f81565b604080519115158252519081900360200190f35b34801561034e57600080fd5b5061032e6004803603604081101561036557600080fd5b50803590602001356001600160a01b0316610f96565b34801561038757600080fd5b50610390610fb6565b60408051918252519081900360200190f35b3480156103ae57600080fd5b50610390600480360360408110156103c557600080fd5b508035151590602001351515610ff0565b3480156103e257600080fd5b50610241600480360360608110156103f957600080fd5b810190602081018135600160201b81111561041357600080fd5b82018360208201111561042557600080fd5b803590602001918460208302840111600160201b8311171561044657600080fd5b919080806020026020016040519081016040528093929190818152602001838360200280828437600092019190915250929550508235935050506020013561105c565b34801561049557600080fd5b50610241600480360360408110156104ac57600080fd5b810190602081018135600160201b8111156104c657600080fd5b8201836020820111156104d857600080fd5b803590602001918460208302840111600160201b831117156104f957600080fd5b9190808060200260200160405190810160405280939291908181526020018383602002808284376000920191909152509295505091359250611110915050565b34801561054557600080fd5b506103906112d6565b34801561055a57600080fd5b506103906112dc565b34801561056f57600080fd5b506102416004803603602081101561058657600080fd5b50356001600160a01b03166112e2565b3480156105a257600080fd5b5061026d611406565b3480156105b757600080fd5b5061032e600480360360208110156105ce57600080fd5b5035611415565b3480156105e157600080fd5b50610390600480360360208110156105f857600080fd5b810190602081018135600160201b81111561061257600080fd5b82018360208201111561062457600080fd5b803590602001918460018302840111600160201b8311171561064557600080fd5b50909250905061149c565b34801561065c57600080fd5b5061024161153b565b34801561067157600080fd5b50610760600480360361012081101561068957600080fd5b6001600160a01b038235811692602081013590911691810190606081016040820135600160201b8111156106bc57600080fd5b8201836020820111156106ce57600080fd5b803590602001918460018302840111600160201b831117156106ef57600080fd5b9193909282359260208101359260408201359260608301359260a081019060800135600160201b81111561072257600080fd5b82018360208201111561073457600080fd5b803590602001918460018302840111600160201b8311171561075557600080fd5b9193509150356115f5565b6040518083815260200180602001828103825283818151815260200191508051906020019080838360005b838110156107a357818101518382015260200161078b565b50505050905090810190601f1680156107d05780820380516001836020036101000a031916815260200191505b50935050505060405180910390f35b3480156107eb57600080fd5b506103906004803603602081101561080257600080fd5b5035611651565b34801561081557600080fd5b506108336004803603602081101561082c57600080fd5b50356116c0565b60405180856001600160a01b03166001600160a01b031681526020018481526020018060200183151515158152602001828103825284818151815260200191508051906020019080838360005b83811015610898578181015183820152602001610880565b50505050905090810190601f1680156108c55780820380516001836020036101000a031916815260200191505b509550505050505060405180910390f35b3480156108e257600080fd5b506108eb61177f565b60408051602080825283518183015283519192839290830191858101910280838360005b8381101561092757818101518382015260200161090f565b505050509050019250505060405180910390f35b34801561094757600080fd5b506108eb6004803603608081101561095e57600080fd5b5080359060208101359060408101351515906060013515156117e1565b34801561098757600080fd5b5061099061190c565b6040805160208082528351818301528351919283929083019185019080838360005b838110156109ca5781810151838201526020016109b2565b50505050905090810190601f1680156109f75780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b348015610a1157600080fd5b506108eb60048036036020811015610a2857600080fd5b503561192b565b348015610a3b57600080fd5b50610390611aa2565b348015610a5057600080fd5b5061024160048036036020811015610a6757600080fd5b5035611aa8565b348015610a7a57600080fd5b5061024160048036036020811015610a9157600080fd5b5035611b35565b348015610aa457600080fd5b5061039060048036036060811015610abb57600080fd5b6001600160a01b0382351691602081013591810190606081016040820135600160201b811115610aea57600080fd5b820183602082011115610afc57600080fd5b803590602001918460018302840111600160201b83111715610b1d57600080fd5b91908080601f016020809104026020016040519081016040528093929190818152602001838380828437600092019190915250929550611c4d945050505050565b348015610b6a57600080fd5b5061024160048036036020811015610b8157600080fd5b5035611c65565b348015610b9457600080fd5b50610390611cbc565b348015610ba957600080fd5b50610390611cc1565b348015610bbe57600080fd5b5061024160048036036080811015610bd557600080fd5b810190602081018135600160201b811115610bef57600080fd5b820183602082011115610c0157600080fd5b803590602001918460018302840111600160201b83111715610c2257600080fd5b9193509150803515159060208101359060400135611cc7565b348015610c4757600080fd5b5061024160048036036040811015610c5e57600080fd5b506001600160a01b0381358116916020013516611d62565b348015610c8257600080fd5b5061024160048036036020811015610c9957600080fd5b5035611eef565b348015610cac57600080fd5b5061039061211e565b60378181548110610cc257fe5b6000918252602090912001546001600160a01b0316905081565b610cf973d216153c06e857cd7f72665e0af1d7d82172f494612124565b565b30610d04612224565b6001600160a01b031614610d1757600080fd5b6001600160a01b038116600090815260366020526040902054819060ff16610d3e57600080fd5b6001600160a01b0382166000908152603660205260408120805460ff191690555b60375460001901811015610e1257826001600160a01b031660378281548110610d8457fe5b6000918252602090912001546001600160a01b03161415610e0a57603780546000198101908110610db157fe5b600091825260209091200154603780546001600160a01b039092169183908110610dd757fe5b9060005260206000200160006101000a8154816001600160a01b0302191690836001600160a01b03160217905550610e12565b600101610d5f565b50603780546000190190610e2690826123f9565b506037546038541115610e3f57603754610e3f90611aa8565b6040516001600160a01b038316907f8001553a916ef2f495d26a907cc54d96ed840d7bda71e73194bf5a9df7a76b9090600090a25050565b610e7f612224565b6001600160a01b03811660009081526036602052604090205460ff16610ea457600080fd5b81610ead612224565b60008281526035602090815260408083206001600160a01b038516845290915290205460ff16610edc57600080fd5b600084815260346020526040902060030154849060ff1615610efd57600080fd5b600085815260356020526040812081610f14612224565b6001600160a01b031681526020810191909152604001600020805460ff191691151591909117905584610f45612224565b6001600160a01b03167ff6a317157440607f36269043eb55f1287a5a19ba2216afeab88cd46cbcfb88e960405160405180910390a35050505050565b60366020526000908152604090205460ff1681565b603560209081526000928352604080842090915290825290205460ff1681565b6000603b546201518001421115610fd05750603a54610fed565b603c54603a541015610fe457506000610fed565b50603c54603a54035b90565b6000805b6039548110156110555783801561101d575060008181526034602052604090206003015460ff16155b806110415750828015611041575060008181526034602052604090206003015460ff165b1561104d576001820191505b600101610ff4565b5092915050565b600054610100900460ff1680611075575061107561224f565b80611083575060005460ff16155b6110be5760405162461bcd60e51b815260040180806020018281038252602e815260200180612565602e913960400191505060405180910390fd5b600054610100900460ff161580156110e9576000805460ff1961ff0019909116610100171660011790555b6110f38484611110565b603a829055801561110a576000805461ff00191690555b50505050565b600054610100900460ff1680611129575061112961224f565b80611137575060005460ff16155b6111725760405162461bcd60e51b815260040180806020018281038252602e815260200180612565602e913960400191505060405180910390fd5b600054610100900460ff1615801561119d576000805460ff1961ff0019909116610100171660011790555b825182603282111580156111b15750818111155b80156111bc57508015155b80156111c757508115155b6111d057600080fd5b6111d861153b565b60005b85518110156112a357603660008783815181106111f457fe5b6020908102919091018101516001600160a01b031682528101919091526040016000205460ff1615801561124e575060006001600160a01b031686828151811061123a57fe5b60200260200101516001600160a01b031614155b61125757600080fd5b60016036600088848151811061126957fe5b6020908102919091018101516001600160a01b03168252810191909152604001600020805460ff19169115159190911790556001016111db565b5084516112b790603790602088019061241d565b505050603882905580156112d1576000805461ff00191690555b505050565b603a5481565b603b5481565b306112eb612224565b6001600160a01b0316146112fe57600080fd5b6001600160a01b038116600090815260366020526040902054819060ff161561132657600080fd5b816001600160a01b03811661133a57600080fd5b603780549050600101603854603282111580156113575750818111155b801561136257508015155b801561136d57508115155b61137657600080fd5b6001600160a01b038516600081815260366020526040808220805460ff1916600190811790915560378054918201815583527f42a7b7dd785cd69714a189dffb3fd7d7174edc9ece837694ce50f7078f7c31ae0180546001600160a01b03191684179055517ff39e6e1eb0edcf53c221607b54b00cd28f3196fed0a24994dc308b8f611b682d9190a25050505050565b6033546001600160a01b031690565b600080805b603754811015611494576000848152603560205260408120603780549192918490811061144357fe5b60009182526020808320909101546001600160a01b0316835282019290925260400190205460ff1615611477576001820191505b60385482141561148c57600192505050611497565b60010161141a565b50505b919050565b60006114a6611406565b6001600160a01b0316336001600160a01b0316146114f55760405162461bcd60e51b81526004018080602001828103825260248152602001806125c06024913960400191505060405180910390fd5b61153483838080601f01602080910402602001604051908101604052809392919081815260200183838082843760009201919091525061225592505050565b9392505050565b600054610100900460ff1680611554575061155461224f565b80611562575060005460ff16155b61159d5760405162461bcd60e51b815260040180806020018281038252602e815260200180612565602e913960400191505060405180910390fd5b600054610100900460ff161580156115c8576000805460ff1961ff0019909116610100171660011790555b6033546001600160a01b03166115e0576115e0610cdc565b80156115f2576000805461ff00191690555b50565b604080516001600160a01b038c16602082015280820183905260608181018a905260808083018a90528351808403909101815260a09092019092526000919061163d9061225b565b915091509b509b9950505050505050505050565b6000805b6037548110156116ba576000838152603560205260408120603780549192918490811061167e57fe5b60009182526020808320909101546001600160a01b0316835282019290925260400190205460ff16156116b2576001820191505b600101611655565b50919050565b60346020908152600091825260409182902080546001808301546002808501805488516101009582161595909502600019011691909104601f81018790048702840187019097528683526001600160a01b0390931695909491929183018282801561176c5780601f106117415761010080835404028352916020019161176c565b820191906000526020600020905b81548152906001019060200180831161174f57829003601f168201915b5050506003909301549192505060ff1684565b606060378054806020026020016040519081016040528092919081815260200182805480156117d757602002820191906000526020600020905b81546001600160a01b031681526001909101906020018083116117b9575b5050505050905090565b606080603954604051908082528060200260200182016040528015611810578160200160208202803883390190505b5090506000805b60395481101561189157858015611840575060008181526034602052604090206003015460ff16155b806118645750848015611864575060008181526034602052604090206003015460ff165b15611889578083838151811061187657fe5b6020026020010181815250506001820191505b600101611817565b8787036040519080825280602002602001820160405280156118bd578160200160208202803883390190505b5093508790505b86811015611901578281815181106118d857fe5b602002602001015184898303815181106118ee57fe5b60209081029190910101526001016118c4565b505050949350505050565b6040805180820190915260058152640312e302e360dc1b602082015290565b60608060378054905060405190808252806020026020018201604052801561195d578160200160208202803883390190505b5090506000805b603754811015611a20576000858152603560205260408120603780549192918490811061198d57fe5b60009182526020808320909101546001600160a01b0316835282019290925260400190205460ff1615611a1857603781815481106119c757fe5b9060005260206000200160009054906101000a90046001600160a01b03168383815181106119f157fe5b60200260200101906001600160a01b031690816001600160a01b0316815250506001820191505b600101611964565b81604051908082528060200260200182016040528015611a4a578160200160208202803883390190505b509350600090505b81811015611a9a57828181518110611a6657fe5b6020026020010151848281518110611a7a57fe5b6001600160a01b0390921660209283029190910190910152600101611a52565b505050919050565b60395481565b30611ab1612224565b6001600160a01b031614611ac457600080fd5b6037548160328211801590611ad95750818111155b8015611ae457508015155b8015611aef57508115155b611af857600080fd5b60388390556040805184815290517fa3f1ee9126a074d9326c682f561767f710e927faa811f7a99829d49dc421797a9181900360200190a1505050565b611b3d612224565b6001600160a01b03811660009081526036602052604090205460ff16611b6257600080fd5b60008281526034602052604090205482906001600160a01b0316611b8557600080fd5b82611b8e612224565b60008281526035602090815260408083206001600160a01b038516845290915290205460ff1615611bbe57600080fd5b6000858152603560205260408120600191611bd7612224565b6001600160a01b031681526020810191909152604001600020805460ff191691151591909117905584611c08612224565b6001600160a01b03167f4a504a94899432a9846e1aa406dceb1bcfd538bb839071d49d1e5e23f5be30ef60405160405180910390a3611c4685611eef565b5050505050565b6000611c5a848484612260565b905061153481611b35565b30611c6e612224565b6001600160a01b031614611c8157600080fd5b603a8190556040805182815290517fc71bdc6afaf9b1aa90a7078191d4fc1adf3bf680fca3183697df6b0dc226bca29181900360200190a150565b603281565b60385481565b611ccf611406565b6001600160a01b0316336001600160a01b031614611d1e5760405162461bcd60e51b81526004018080602001828103825260248152602001806125c06024913960400191505060405180910390fd5b611c4685858080601f01602080910402602001604051908101604052809392919081815260200183838082843760009201919091525087925086915085905061110a565b30611d6b612224565b6001600160a01b031614611d7e57600080fd5b6001600160a01b038216600090815260366020526040902054829060ff16611da557600080fd5b6001600160a01b038216600090815260366020526040902054829060ff1615611dcd57600080fd5b60005b603754811015611e5557846001600160a01b031660378281548110611df157fe5b6000918252602090912001546001600160a01b03161415611e4d578360378281548110611e1a57fe5b9060005260206000200160006101000a8154816001600160a01b0302191690836001600160a01b03160217905550611e55565b600101611dd0565b506001600160a01b03808516600081815260366020526040808220805460ff1990811690915593871682528082208054909416600117909355915190917f8001553a916ef2f495d26a907cc54d96ed840d7bda71e73194bf5a9df7a76b9091a26040516001600160a01b038416907ff39e6e1eb0edcf53c221607b54b00cd28f3196fed0a24994dc308b8f611b682d90600090a250505050565b611ef7612224565b6001600160a01b03811660009081526036602052604090205460ff16611f1c57600080fd5b81611f25612224565b60008281526035602090815260408083206001600160a01b038516845290915290205460ff16611f5457600080fd5b600084815260346020526040902060030154849060ff1615611f7557600080fd5b600085815260346020526040812090611f8d87611415565b90508080611fc05750600280830154600019610100600183161502011604158015611fc05750611fc08260010154612342565b156121155760038201805460ff1916600117905580611fe8576001820154603c805490910190555b815460018084015460028086018054604080516020601f600019988516156101000298909801909316949094049586018290048202840182019052848352612094956001600160a01b031694929190839083018282801561208a5780601f1061205f5761010080835404028352916020019161208a565b820191906000526020600020905b81548152906001019060200180831161206d57829003601f168201915b5050505050612389565b156120c95760405187907f33e13ecb54c3076d8e8bb8c2881800a4d972b792045ffae98fdf46df365fed7590600090a2612115565b60405187907f526441bb6c1aba3c9a4a6ca1d6545da9c2333c8c48343ef398eb858d72b7923690600090a260038201805460ff1916905580612115576001820154603c80549190910390555b50505050505050565b603c5481565b6033546001600160a01b039081169082166121705760405162461bcd60e51b815260040180806020018281038252602e815260200180612537602e913960400191505060405180910390fd5b806001600160a01b0316826001600160a01b031614156121c15760405162461bcd60e51b815260040180806020018281038252602d815260200180612593602d913960400191505060405180910390fd5b816001600160a01b0316816001600160a01b03167fb9f84b8e65164b14439ae3620df0a4d8786d896996c0282b683f9d8c08f046e860405160405180910390a350603380546001600160a01b0319166001600160a01b0392909216919091179055565b6033546000906001600160a01b03163314612240575033610fed565b6122486123ac565b9050610fed565b303b1590565b50600090565b600091565b6000836001600160a01b03811661227657600080fd5b603954604080516080810182526001600160a01b03888116825260208083018981528385018981526000606086018190528781526034845295909520845181546001600160a01b031916941693909317835551600183015592518051949650919390926122ea926002850192910190612482565b50606091909101516003909101805460ff191691151591909117905560398054600101905560405182907fc0ba8fe4b176c1714197d43b9cc6bcf797a4a7461c5fe8d0ef6e184ae7601e5190600090a2509392505050565b6000603b54620151800142111561235d5742603b556000603c555b603a5482603c540111806123745750603c54828101105b1561238157506000611497565b506001919050565b6000806040516020840160008287838a8c6187965a03f198975050505050505050565b600060606000368080601f0160208091040260200160405190810160405280939291908181526020018383808284376000920191909152505050503601516001600160a01b031692915050565b8154818355818111156112d1576000838152602090206112d19181019083016124f8565b828054828255906000526020600020908101928215612472579160200282015b8281111561247257825182546001600160a01b0319166001600160a01b0390911617825560209092019160019091019061243d565b5061247e929150612512565b5090565b828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f106124c357805160ff19168380011785556124f0565b828001600101855582156124f0579182015b828111156124f05782518255916020019190600101906124d5565b5061247e9291505b610fed91905b8082111561247e57600081556001016124fe565b610fed91905b8082111561247e5780546001600160a01b031916815560010161251856fe47534e526563697069656e743a206e65772052656c617948756220697320746865207a65726f2061646472657373436f6e747261637420696e7374616e63652068617320616c7265616479206265656e20696e697469616c697a656447534e526563697069656e743a206e65772052656c6179487562206973207468652063757272656e74206f6e6547534e526563697069656e743a2063616c6c6572206973206e6f742052656c6179487562a265627a7a72315820f4b03e6fa9d531de2d3f4ff5a84e90c48ff7e823bc6a93d32659a594730c1b9064736f6c634300050d0032

82781:3165:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70975:9;:13;70971:197;;71138:30;;;71158:9;71138:30;;;;71146:10;;71138:30;;;;;;;;;;70971:197;82781:3165;69393:23;;8:9:-1;5:2;;;30:1;27;20:12;5:2;69393:23:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;69393:23:0;;:::i;:::-;;;;-1:-1:-1;;;;;69393:23:0;;;;;;;;;;;;;;20557:116;;8:9:-1;5:2;;;30:1;27;20:12;5:2;20557:116:0;;;:::i;72387:480::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;72387:480:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;72387:480:0;-1:-1:-1;;;;;72387:480:0;;:::i;75069:312::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;75069:312:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;75069:312:0;;:::i;69346:40::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;69346:40:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;69346:40:0;-1:-1:-1;;;;;69346:40:0;;:::i;:::-;;;;;;;;;;;;;;;;;;69275:64;;8:9:-1;5:2;;;30:1;27;20:12;5:2;69275:64:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;69275:64:0;;;;;;-1:-1:-1;;;;;69275:64:0;;:::i;85676:267::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;85676:267:0;;;:::i;:::-;;;;;;;;;;;;;;;;79474:324;;8:9:-1;5:2;;;30:1;27;20:12;5:2;79474:324:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;79474:324:0;;;;;;;;;;;:::i;83424:215::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;83424:215:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;83424:215:0;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;83424:215:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;83424:215:0;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;-1:-1;;;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;83424:215:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;83424:215:0;;-1:-1:-1;;83424:215:0;;;-1:-1:-1;;;83424:215:0;;;;:::i;71427:410::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;71427:410:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;71427:410:0;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;71427:410:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;71427:410:0;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;-1:-1;;;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;71427:410:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;71427:410:0;;-1:-1:-1;;71427:410:0;;;-1:-1:-1;71427:410:0;;-1:-1:-1;;71427:410:0:i;82967:22::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;82967:22:0;;;:::i;82996:19::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;82996:19:0;;;:::i;71968:292::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;71968:292:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;71968:292:0;-1:-1:-1;;;;;71968:292:0;;:::i;21334:87::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;21334:87:0;;;:::i;77580:345::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;77580:345:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;77580:345:0;;:::i;24997:211::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;24997:211:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;24997:211:0;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;24997:211:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;24997:211:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;-1:-1;24997:211:0;;-1:-1:-1;24997:211:0;-1:-1:-1;24997:211:0;:::i;20414:135::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;20414:135:0;;;:::i;81878:415::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;81878:415:0;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;81878:415:0;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;81878:415:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;81878:415:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;81878:415:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;81878:415:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;81878:415:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;81878:415:0;;-1:-1:-1;81878:415:0;-1:-1:-1;81878:415:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;81878:415:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;78950:256;;8:9:-1;5:2;;;30:1;27;20:12;5:2;78950:256:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;78950:256:0;;:::i;69219:49::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;69219:49:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;69219:49:0;;:::i;:::-;;;;-1:-1:-1;;;;;69219:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;69219:49:0;;;;;;;;;-1:-1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;69219:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;79886:124;;8:9:-1;5:2;;;30:1;27;20:12;5:2;79886:124:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:100:-1;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;79886:124:0;;;;;;;;;;;;;;;;;81145:697;;8:9:-1;5:2;;;30:1;27;20:12;5:2;81145:697:0;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;81145:697:0;;;;;;;;;;;;;;;;;;;;;:::i;22592:230::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;22592:230:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:100:-1;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;22592:230:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;80194:594;;8:9:-1;5:2;;;30:1;27;20:12;5:2;80194:594:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;80194:594:0;;:::i;69450:28::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;69450:28:0;;;:::i;73723:219::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;73723:219:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;73723:219:0;;:::i;74575:366::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;74575:366:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;74575:366:0;;:::i;74208:257::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;74208:257:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;74208:257:0;;-1:-1:-1;;;;;74208:257:0;;;;;;;;;;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;74208:257:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;74208:257:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;74208:257:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;74208:257:0;;-1:-1:-1;74208:257:0;;-1:-1:-1;;;;;74208:257:0:i;83776:173::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;83776:173:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;83776:173:0;;:::i;69135:41::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;69135:41:0;;;:::i;69423:20::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;69423:20:0;;;:::i;25857:277::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;25857:277:0;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;25857:277:0;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;25857:277:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;25857:277:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;25857:277:0;;-1:-1:-1;25857:277:0;-1:-1:-1;25857:277:0;;;;;;;;;;;;;;:::i;73074:474::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;73074:474:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;73074:474:0;;;;;;;;;;:::i;84115:854::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;84115:854:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;84115:854:0;;:::i;83022:22::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;83022:22:0;;;:::i;69393:23::-;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;69393:23:0;;-1:-1:-1;69393:23:0;:::o;20557:116::-;20605:60;20622:42;20605:16;:60::i;:::-;20557:116::o;72387:480::-;69719:4;69695:12;:10;:12::i;:::-;-1:-1:-1;;;;;69695:29:0;;69687:38;;;;;;-1:-1:-1;;;;;69913:14:0;;;;;;:7;:14;;;;;;;;;;69905:23;;;;;;-1:-1:-1;;;;;72503:14:0;;72520:5;72503:14;;;:7;:14;;;;;:22;;-1:-1:-1;;72503:22:0;;;72536:174;72553:6;:13;-1:-1:-1;;72553:17:0;72551:19;;72536:174;;;72594:6;:9;;-1:-1:-1;;;;;72594:18:0;;;:6;72601:1;;72594:9;;;;;;;;;;;;;;;;-1:-1:-1;;;;;72594:9:0;:18;72590:120;;;72645:6;72652:13;;-1:-1:-1;;72652:17:0;;;72645:25;;;;;;;;;;;;;;;;72633:6;:9;;-1:-1:-1;;;;;72645:25:0;;;;72640:1;;72633:9;;;;;;;;;;;;;;;:37;;-1:-1:-1;;;;;;72633:37:0;-1:-1:-1;;;;;72633:37:0;;;;;;;;;;72689:5;;72590:120;72572:3;;72536:174;;;-1:-1:-1;72720:6:0;:18;;-1:-1:-1;;72720:18:0;;;;;;:::i;:::-;-1:-1:-1;72764:6:0;:13;72753:8;;:24;72749:75;;;72810:6;:13;72792:32;;:17;:32::i;:::-;72840:19;;-1:-1:-1;;;;;72840:19:0;;;;;;;;69736:1;72387:480;:::o;75069:312::-;75154:12;:10;:12::i;:::-;-1:-1:-1;;;;;69913:14:0;;;;;;:7;:14;;;;;;;;69905:23;;;;;;75187:13;75202:12;:10;:12::i;:::-;70177:28;;;;:13;:28;;;;;;;;-1:-1:-1;;;;;70177:35:0;;;;;;;;;;;;70169:44;;;;;;70443:27;;;;:12;:27;;;;;:36;;;75237:13;;70443:36;;70442:37;70434:46;;;;;;75313:5;75268:28;;;:13;:28;;;;;75313:5;75297:12;:10;:12::i;:::-;-1:-1:-1;;;;;75268:42:0;;;;;;;;;;;;-1:-1:-1;75268:42:0;:50;;-1:-1:-1;;75268:50:0;;;;;;;;;;75359:13;75345:12;:10;:12::i;:::-;75334:39;;-1:-1:-1;;;;;75334:39:0;;;;;;;;;;70224:1;69939;;75069:312;;:::o;69346:40::-;;;;;;;;;;;;;;;:::o;69275:64::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;85676:267::-;85751:4;85783:7;;85793:8;85783:18;85777:3;:24;85773:60;;;-1:-1:-1;85823:10:0;;85816:17;;85773:60;85861:10;;85848;;:23;85844:50;;;-1:-1:-1;85893:1:0;85886:8;;85844:50;-1:-1:-1;85925:10:0;;85912;;:23;85676:267;;:::o;79474:324::-;79580:10;;79608:182;79625:16;;79623:1;:18;79608:182;;;79668:7;:36;;;;-1:-1:-1;79680:15:0;;;;:12;:15;;;;;:24;;;;;79679:25;79668:36;:93;;;;79725:8;:36;;;;-1:-1:-1;79737:15:0;;;;:12;:15;;;;;:24;;;;;79725:36;79661:129;;;79789:1;79780:10;;;;79661:129;79643:3;;79608:182;;;;79474:324;;;;:::o;83424:215::-;1118:12;;;;;;;;:31;;;1134:15;:13;:15::i;:::-;1118:47;;;-1:-1:-1;1154:11:0;;;;1153:12;1118:47;1110:106;;;;-1:-1:-1;;;1110:106:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1225:19;1248:12;;;;;;1247:13;1267:83;;;;1296:12;:19;;-1:-1:-1;;;;1296:19:0;;;;;1324:18;1311:4;1324:18;;;1267:83;83548:48;83577:7;83586:9;83548:28;:48::i;:::-;83607:10;:24;;;1368:57;;;;1412:5;1397:20;;-1:-1:-1;;1397:20:0;;;1368:57;83424:215;;;;:::o;71427:410::-;1118:12;;;;;;;;:31;;;1134:15;:13;:15::i;:::-;1118:47;;;-1:-1:-1;1154:11:0;;;;1153:12;1118:47;1110:106;;;;-1:-1:-1;;;1110:106:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1225:19;1248:12;;;;;;1247:13;1267:83;;;;1296:12;:19;;-1:-1:-1;;;;1296:19:0;;;;;1324:18;1311:4;1324:18;;;1267:83;71530:7;:14;71546:9;69174:2;70691:10;:29;;:69;;;;;70750:10;70737:9;:23;;70691:69;:100;;;;-1:-1:-1;70777:14:0;;;70691:100;:132;;;;-1:-1:-1;70808:15:0;;;70691:132;70683:141;;;;;;71573:25;:23;:25::i;:::-;71614:6;71609:163;71626:7;:14;71624:1;:16;71609:163;;;71671:7;:19;71679:7;71687:1;71679:10;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;71671:19:0;;;;;;;;;;;-1:-1:-1;71671:19:0;;;;71670:20;:48;;;;-1:-1:-1;71694:10:0;;71716:1;;71694:7;;71702:1;;71694:10;;;;;;;;;;;;-1:-1:-1;;;;;71694:24:0;;;71670:48;71662:57;;;;;;71756:4;71734:7;:19;71742:7;71750:1;71742:10;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;71734:19:0;;;;;;;;;;;-1:-1:-1;71734:19:0;:26;;-1:-1:-1;;71734:26:0;;;;;;;;;;-1:-1:-1;71642:3:0;71609:163;;;-1:-1:-1;71782:16:0;;;;:6;;:16;;;;;:::i;:::-;-1:-1:-1;;;71809:8:0;:20;;;1368:57;;;;1412:5;1397:20;;-1:-1:-1;;1397:20:0;;;1368:57;71427:410;;;:::o;82967:22::-;;;;:::o;82996:19::-;;;;:::o;71968:292::-;69719:4;69695:12;:10;:12::i;:::-;-1:-1:-1;;;;;69695:29:0;;69687:38;;;;;;-1:-1:-1;;;;;69815:14:0;;;;;;:7;:14;;;;;;;;;;69814:15;69806:24;;;;;;72088:5;-1:-1:-1;;;;;70562:22:0;;70554:31;;;;;;72121:6;:13;;;;72137:1;72121:17;72140:8;;69174:2;70691:10;:29;;:69;;;;;70750:10;70737:9;:23;;70691:69;:100;;;;-1:-1:-1;70777:14:0;;;70691:100;:132;;;;-1:-1:-1;70808:15:0;;;70691:132;70683:141;;;;;;-1:-1:-1;;;;;72166:14:0;;;;;;:7;:14;;;;;;:21;;-1:-1:-1;;72166:21:0;-1:-1:-1;72166:21:0;;;;;;72198:6;27:10:-1;;23:18;;;45:23;;72198:18:0;;;;;;-1:-1:-1;;;;;;72198:18:0;;;;;72232:20;;;72166:14;72232:20;70596:1;;69841;69736;71968:292;:::o;21334:87::-;21404:9;;-1:-1:-1;;;;;21404:9:0;;21334:87::o;77580:345::-;77669:4;;;77716:202;77733:6;:13;77731:15;;77716:202;;;77772:28;;;;:13;:28;;;;;77801:6;:9;;77772:28;;;77808:1;;77801:9;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;77801:9:0;77772:39;;;;;;;;;;;;;;;77768:72;;;77839:1;77830:10;;;;77768:72;77868:8;;77859:5;:17;77855:51;;;77902:4;77895:11;;;;;;77855:51;77748:3;;77716:202;;;;77580:345;;;;;:::o;24997:211::-;25063:7;25105:12;:10;:12::i;:::-;-1:-1:-1;;;;;25091:26:0;:10;:26;25083:75;;;;-1:-1:-1;;;25083:75:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25176:24;25192:7;;25176:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;25176:15:0;;-1:-1:-1;;;25176:24:0:i;:::-;25169:31;24997:211;-1:-1:-1;;;24997:211:0:o;20414:135::-;1118:12;;;;;;;;:31;;;1134:15;:13;:15::i;:::-;1118:47;;;-1:-1:-1;1154:11:0;;;;1153:12;1118:47;1110:106;;;;-1:-1:-1;;;1110:106:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1225:19;1248:12;;;;;;1247:13;1267:83;;;;1296:12;:19;;-1:-1:-1;;;;1296:19:0;;;;;1324:18;1311:4;1324:18;;;1267:83;20470:9;;-1:-1:-1;;;;;20470:9:0;20466:76;;20510:20;:18;:20::i;:::-;1372:14;1368:57;;;1412:5;1397:20;;-1:-1:-1;;1397:20:0;;;1368:57;20414:135;:::o;81878:415::-;82223:61;;;-1:-1:-1;;;;;82223:61:0;;;;;;;;;;;;82171:12;82223:61;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;-1:-1;82223:61:0;;;;;;-1:-1:-1;;82171:12:0;82203:82;;:19;:82::i;:::-;82196:89;;;;81878:415;;;;;;;;;;;;;;:::o;78950:256::-;79048:10;;79076:122;79093:6;:13;79091:15;;79076:122;;;79130:28;;;;:13;:28;;;;;79159:6;:9;;79130:28;;;79166:1;;79159:9;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;79159:9:0;79130:39;;;;;;;;;;;;;;;79126:72;;;79197:1;79188:10;;;;79126:72;79108:3;;79076:122;;;;78950:256;;;:::o;69219:49::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;69219:49:0;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;69219:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;69219:49:0;;;;;;;-1:-1:-1;;69219:49:0;;;:::o;79886:124::-;79955:16;79996:6;79989:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;79989:13:0;;;-1:-1:-1;79989:13:0;;;;;;;;;;;;;;;;;;;79886:124;:::o;81145:697::-;81269:29;81316:32;81362:16;;81351:28;;;;;;;;;;;;;;;;;;;;;;29:2:-1;21:6;17:15;117:4;105:10;97:6;88:34;136:17;;-1:-1;81351:28:0;-1:-1:-1;81316:63:0;-1:-1:-1;81390:10:0;;81432:256;81444:16;;81442:1;:18;81432:256;;;81487:7;:36;;;;-1:-1:-1;81499:15:0;;;;:12;:15;;;;;:24;;;;;81498:25;81487:36;:93;;;;81544:8;:36;;;;-1:-1:-1;81556:15:0;;;;:12;:15;;;;;:24;;;;;81544:36;81480:208;;;81642:1;81614:18;81633:5;81614:25;;;;;;;;;;;;;:29;;;;;81671:1;81662:10;;;;81480:208;81462:3;;81432:256;;;81732:4;81727:2;:9;81716:21;;;;;;;;;;;;;;;;;;;;;;29:2:-1;21:6;17:15;117:4;105:10;97:6;88:34;136:17;;-1:-1;81716:21:0;;81698:39;;81755:4;81753:6;;81748:86;81763:2;81761:1;:4;81748:86;;;81813:18;81832:1;81813:21;;;;;;;;;;;;;;81785:15;81805:4;81801:1;:8;81785:25;;;;;;;;;;;;;;;;;:49;81767:3;;81748:86;;;81145:697;;;;;;;;;:::o;22592:230::-;22800:14;;;;;;;;;;;;-1:-1:-1;;;22800:14:0;;;;;22592:230::o;80194:594::-;80288:31;80337:34;80388:6;:13;;;;80374:28;;;;;;;;;;;;;;;;;;;;;;29:2:-1;21:6;17:15;117:4;105:10;97:6;88:34;136:17;;-1:-1;80374:28:0;-1:-1:-1;80337:65:0;-1:-1:-1;80413:10:0;;80455:190;80467:6;:13;80465:15;;80455:190;;;80504:28;;;;:13;:28;;;;;80533:6;:9;;80504:28;;;80540:1;;80533:9;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;80533:9:0;80504:39;;;;;;;;;;;;;;;80500:145;;;80591:6;80598:1;80591:9;;;;;;;;;;;;;;;;;;80564:24;;-1:-1:-1;;;;;80591:9:0;;;;80564:17;;80582:5;;80564:24;;;;;;-1:-1:-1;;;;;80564:36:0;;;:24;;;;;;;;;;;:36;-1:-1:-1;80619:10:0;;;;;80500:145;80482:3;;80455:190;;;80686:5;80672:20;;;;;;;;;;;;;;;;;;;;;;29:2:-1;21:6;17:15;117:4;105:10;97:6;88:34;136:17;;-1:-1;80672:20:0;;80655:37;;80710:1;80708:3;;80703:77;80715:5;80713:1;:7;80703:77;;;80760:17;80778:1;80760:20;;;;;;;;;;;;;;80740:14;80755:1;80740:17;;;;;;;;-1:-1:-1;;;;;80740:40:0;;;;:17;;;;;;;;;;;:40;-1:-1:-1;80722:3:0;80703:77;;;80194:594;;;;;;:::o;69450:28::-;;;;:::o;73723:219::-;69719:4;69695:12;:10;:12::i;:::-;-1:-1:-1;;;;;69695:29:0;;69687:38;;;;;;73828:6;:13;73843:9;69174:2;70691:29;;;;;:69;;;70750:10;70737:9;:23;;70691:69;:100;;;;-1:-1:-1;70777:14:0;;;70691:100;:132;;;;-1:-1:-1;70808:15:0;;;70691:132;70683:141;;;;;;73870:8;:20;;;73906:28;;;;;;;;;;;;;;;;;69736:1;;73723:219;:::o;74575:366::-;74660:12;:10;:12::i;:::-;-1:-1:-1;;;;;69913:14:0;;;;;;:7;:14;;;;;;;;69905:23;;;;;;70073:1;70022:27;;;:12;:27;;;;;:39;:27;;-1:-1:-1;;;;;70022:39:0;70014:62;;;;;;74738:13;74753:12;:10;:12::i;:::-;70318:28;;;;:13;:28;;;;;;;;-1:-1:-1;;;;;70318:35:0;;;;;;;;;;;;70317:36;70309:45;;;;;;74783:28;;;;:13;:28;;;;;74828:4;;74812:12;:10;:12::i;:::-;-1:-1:-1;;;;;74783:42:0;;;;;;;;;;;;-1:-1:-1;74783:42:0;:49;;-1:-1:-1;;74783:49:0;;;;;;;;;;74875:13;74861:12;:10;:12::i;:::-;74848:41;;-1:-1:-1;;;;;74848:41:0;;;;;;;;;;74900:33;74919:13;74900:18;:33::i;:::-;70087:1;;69939;74575:366;;:::o;74208:257::-;74321:18;74373:40;74388:11;74401:5;74408:4;74373:14;:40::i;:::-;74357:56;;74424:33;74443:13;74424:18;:33::i;83776:173::-;69719:4;69695:12;:10;:12::i;:::-;-1:-1:-1;;;;;69695:29:0;;69687:38;;;;;;83872:10;:24;;;83912:29;;;;;;;;;;;;;;;;;83776:173;:::o;69135:41::-;69174:2;69135:41;:::o;69423:20::-;;;;:::o;25857:277::-;26003:12;:10;:12::i;:::-;-1:-1:-1;;;;;25989:26:0;:10;:26;25981:75;;;;-1:-1:-1;;;25981:75:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26067:59;26084:7;;26067:59;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;26093:7:0;;-1:-1:-1;26102:12:0;;-1:-1:-1;26116:9:0;;-1:-1:-1;26067:16:0;:59::i;73074:474::-;69719:4;69695:12;:10;:12::i;:::-;-1:-1:-1;;;;;69695:29:0;;69687:38;;;;;;-1:-1:-1;;;;;69913:14:0;;;;;;:7;:14;;;;;;;;;;69905:23;;;;;;-1:-1:-1;;;;;69815:14:0;;;;;;:7;:14;;;;;;;;;;69814:15;69806:24;;;;;;73251:6;73246:153;73263:6;:13;73261:15;;73246:153;;;73300:6;:9;;-1:-1:-1;;;;;73300:18:0;;;:6;73307:1;;73300:9;;;;;;;;;;;;;;;;-1:-1:-1;;;;;73300:9:0;:18;73296:103;;;73351:8;73339:6;73346:1;73339:9;;;;;;;;;;;;;;;;;:20;;-1:-1:-1;;;;;;73339:20:0;-1:-1:-1;;;;;73339:20:0;;;;;;;;;;73378:5;;73296:103;73278:3;;73246:153;;;-1:-1:-1;;;;;;73409:14:0;;;73426:5;73409:14;;;:7;:14;;;;;;:22;;-1:-1:-1;;73409:22:0;;;;;;73442:17;;;;;;;;:24;;;;;-1:-1:-1;73442:24:0;;;;73482:19;;73409:14;;73482:19;;;73517:23;;-1:-1:-1;;;;;73517:23:0;;;;;;;;69939:1;69736;73074:474;;:::o;84115:854::-;84200:12;:10;:12::i;:::-;-1:-1:-1;;;;;69913:14:0;;;;;;:7;:14;;;;;;;;69905:23;;;;;;84233:13;84248:12;:10;:12::i;:::-;70177:28;;;;:13;:28;;;;;;;;-1:-1:-1;;;;;70177:35:0;;;;;;;;;;;;70169:44;;;;;;70443:27;;;;:12;:27;;;;;:36;;;84283:13;;70443:36;;70442:37;70434:46;;;;;;84314:23;84340:27;;;:12;:27;;;;;;84396:26;84353:13;84396:11;:26::i;:::-;84378:44;;84437:10;:61;;;-1:-1:-1;84451:8:0;;;;:15;;;;;;;-1:-1:-1;;84451:15:0;;;:20;:47;;;;;84475:23;84488:3;:9;;;84475:12;:23::i;:::-;84433:529;;;84515:12;;;:19;;-1:-1:-1;;84515:19:0;84530:4;84515:19;;;84554:10;84549:57;;84597:9;;;;84583:10;:23;;;;;;;84549:57;84639:15;;;84656:9;;;;84667:8;;;;:15;;84625:68;;;;84639:15;84667;;;;;;;;-1:-1:-1;;84667:15:0;;;;;;;;84625:68;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;84639:15:0;;84625:68;;84667:8;:15;;84625:68;;84667:8;:15;84625:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:13;:68::i;:::-;84621:330;;;84717:24;;84727:13;;84717:24;;;;;84621:330;;;84785:31;;84802:13;;84785:31;;;;;84835:12;;;:20;;-1:-1:-1;;84835:20:0;;;84879:10;84874:61;;84926:9;;;;84912:10;:23;;;;;;;;84874:61;70491:1;;70224;69939;;84115:854;;:::o;83022:22::-;;;;:::o;21835:403::-;21928:9;;-1:-1:-1;;;;;21928:9:0;;;;21956:25;;21948:84;;;;-1:-1:-1;;;21948:84:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;22051:30:0;;;;;;;;22043:88;;;;-1:-1:-1;;;22043:88:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22149:45;;-1:-1:-1;;;;;22149:45:0;;;;;;;;;;;;;-1:-1:-1;22207:9:0;:23;;-1:-1:-1;;;;;;22207:23:0;-1:-1:-1;;;;;22207:23:0;;;;;;;;;;21835:403::o;23794:216::-;23885:9;;23839:15;;-1:-1:-1;;;;;23885:9:0;23871:10;:23;23867:136;;-1:-1:-1;23918:10:0;23911:17;;23867:136;23968:23;:21;:23::i;:::-;23961:30;;;;1519:476;1959:7;1947:20;1982:7;1519:476;:::o;82301:102::-;-1:-1:-1;82366:7:0;;82301:102::o;27038:155::-;27112:7;;27038:155::o;78268:477::-;78410:18;78379:11;-1:-1:-1;;;;;70562:22:0;;70554:31;;;;;;78462:16;;78519:145;;;;;;;;-1:-1:-1;;;;;78519:145:0;;;;;;;;;;;;;;;;;;-1:-1:-1;78519:145:0;;;;;;78489:27;;;:12;:27;;;;;;:175;;;;-1:-1:-1;;;;;;78489:175:0;;;;;;;;;;-1:-1:-1;78489:175:0;;;;;;;78462:16;;-1:-1:-1;78519:145:0;;78489:27;;:175;;;;;;;;;;:::i;:::-;-1:-1:-1;78489:175:0;;;;;;;;;;;;-1:-1:-1;;78489:175:0;;;;;;;;;;78675:16;:21;;-1:-1:-1;78675:21:0;;;78712:25;;78723:13;;78712:25;;-1:-1:-1;;78712:25:0;78268:477;;;;;;:::o;85212:331::-;85283:4;85315:7;;85325:8;85315:18;85309:3;:24;85305:99;;;85360:3;85350:7;:13;85391:1;85378:10;:14;85305:99;85440:10;;85431:6;85418:10;;:19;:32;:68;;;-1:-1:-1;85476:10:0;;85454:19;;;:32;85418:68;85414:99;;;-1:-1:-1;85508:5:0;85501:12;;85414:99;-1:-1:-1;85531:4:0;85212:331;;;:::o;76296:1128::-;76406:4;76423:11;76484:4;76478:11;76618:2;76612:4;76608:13;77293:1;77273;77164:10;77144:1;77120:5;77090:11;76742:5;76737:3;76733:15;76710:672;76700:682;76296:1128;-1:-1:-1;;;;;;;;76296:1128:0:o;28003:1270::-;28058:22;28876:18;28897:8;;28876:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;;;;28932:8:0;29168:17;29162:24;-1:-1:-1;;;;;29158:73:0;;;-1:-1:-1;;28003:1270:0:o;82781:3165::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;82781:3165:0;-1:-1:-1;;;;;82781:3165:0;;;;;;;;;;;-1:-1:-1;82781:3165:0;;;;;;;-1:-1:-1;82781:3165:0;;;-1:-1:-1;82781:3165:0;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;82781:3165:0;;;-1:-1:-1;82781:3165:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;82781:3165:0;;;-1:-1:-1;82781:3165:0;;

bzzr://f4b03e6fa9d531de2d3f4ff5a84e90c48ff7e823bc6a93d32659a594730c1b90