Token SafeSwap

/**
 *Submitted for verification at Etherscan.io on 2021-10-25
*/

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.9;

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
    
    /**
     * @dev Emitted when you're interested in **actually** burning token in both L2, L1
     *
     * L1 Predicate contract expects this event signature, when you expect it to burn token
     * on L1 too.
     *
     * NOTE L2 burning is done by invoking `withdraw` function defined in child token, which
     * will eventually emit this event
     */
    event Burn(address indexed from, uint256 amount);
}

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

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

        return c;
    }

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

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

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

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

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

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

        return c;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    mapping (address => uint256) private _balances;

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

    uint256 private _totalSupply;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _beforeTokenTransfer(sender, recipient, amount);

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
 * (`UintSet`) are supported.
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastvalue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastvalue;
                // Update the index for the moved value
                set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        return _values(set._inner);
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        assembly {
            result := store
        }

        return result;
    }
}

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }
}

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

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

/**
 * @dev External interface of AccessControl declared to support ERC165 detection.
 */
interface IAccessControl {
    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     *
     * _Available since v3.1._
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {AccessControl-_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) external view returns (bool);

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {AccessControl-_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) external view returns (bytes32);

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) external;
}

// File: @openzeppelin/contracts/access/AccessControl.sol

/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms. This is a lightweight version that doesn't allow enumerating role
 * members except through off-chain means by accessing the contract event logs. Some
 * applications may benefit from on-chain enumerability, for those cases see
 * {AccessControlEnumerable}.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it.
 */
abstract contract AccessControl is Context, IAccessControl, ERC165 {
    struct RoleData {
        mapping(address => bool) members;
        bytes32 adminRole;
    }

    mapping(bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Modifier that checks that an account has a specific role. Reverts
     * with a standardized message including the required role.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     *
     * _Available since v4.1._
     */
    modifier onlyRole(bytes32 role) {
        _checkRole(role, _msgSender());
        _;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
    }

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view override returns (bool) {
        return _roles[role].members[account];
    }

    /**
     * @dev Revert with a standard message if `account` is missing `role`.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     */
    function _checkRole(bytes32 role, address account) internal view {
        if (!hasRole(role, account)) {
            revert(
                string(
                    abi.encodePacked(
                        "AccessControl: account ",
                        Strings.toHexString(uint160(account), 20),
                        " is missing role ",
                        Strings.toHexString(uint256(role), 32)
                    )
                )
            );
        }
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view override returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been revoked `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) public virtual override {
        require(account == _msgSender(), "AccessControl: can only renounce roles for self");

        _revokeRole(role, account);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event. Note that unlike {grantRole}, this function doesn't perform any
     * checks on the calling account.
     *
     * [WARNING]
     * ====
     * This function should only be called from the constructor when setting
     * up the initial roles for the system.
     *
     * Using this function in any other way is effectively circumventing the admin
     * system imposed by {AccessControl}.
     * ====
     *
     * NOTE: This function is deprecated in favor of {_grantRole}.
     */
    function _setupRole(bytes32 role, address account) internal virtual {
        _grantRole(role, account);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        bytes32 previousAdminRole = getRoleAdmin(role);
        _roles[role].adminRole = adminRole;
        emit RoleAdminChanged(role, previousAdminRole, adminRole);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * Internal function without access restriction.
     */
    function _grantRole(bytes32 role, address account) internal virtual {
        if (!hasRole(role, account)) {
            _roles[role].members[account] = true;
            emit RoleGranted(role, account, _msgSender());
        }
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * Internal function without access restriction.
     */
    function _revokeRole(bytes32 role, address account) internal virtual {
        if (hasRole(role, account)) {
            _roles[role].members[account] = false;
            emit RoleRevoked(role, account, _msgSender());
        }
    }
}

// File: contracts/common/AccessControlMixin.sol

contract AccessControlMixin is AccessControl {
    string private _revertMsg;
    function _setupContractId(string memory contractId) internal {
        _revertMsg = string(abi.encodePacked(contractId, ": INSUFFICIENT_PERMISSIONS"));
    }

    modifier only(bytes32 role) {
        require(
            hasRole(role, _msgSender()),
            _revertMsg
        );
        _;
    }
}

// File: contracts/child/ChildToken/IChildToken.sol

interface IChildToken {
    function deposit(address user, bytes calldata depositData) external;
}

// File: contracts/common/Initializable.sol

contract Initializable {
    bool inited = false;

    modifier initializer() {
        require(!inited, "already inited");
        _;
        inited = true;
    }
}

// File: contracts/common/EIP712Base.sol

contract EIP712Base is Initializable {
    struct EIP712Domain {
        string name;
        string version;
        address verifyingContract;
        bytes32 salt;
    }

    string constant public ERC712_VERSION = "1";

    bytes32 internal constant EIP712_DOMAIN_TYPEHASH = keccak256(
        bytes(
            "EIP712Domain(string name,string version,address verifyingContract,bytes32 salt)"
        )
    );
    bytes32 internal domainSeperator;

    // supposed to be called once while initializing.
    // one of the contractsa that inherits this contract follows proxy pattern
    // so it is not possible to do this in a constructor
    function _initializeEIP712(
        string memory name
    )
        internal
        initializer
    {
        _setDomainSeperator(name);
    }

    function _setDomainSeperator(string memory name) internal {
        domainSeperator = keccak256(
            abi.encode(
                EIP712_DOMAIN_TYPEHASH,
                keccak256(bytes(name)),
                keccak256(bytes(ERC712_VERSION)),
                address(this),
                bytes32(getChainId())
            )
        );
    }

    function getDomainSeperator() public view returns (bytes32) {
        return domainSeperator;
    }

    function getChainId() public view returns (uint256) {
        uint256 id;
        assembly {
            id := chainid()
        }
        return id;
    }

    /**
     * Accept message hash and returns hash message in EIP712 compatible form
     * So that it can be used to recover signer from signature signed using EIP712 formatted data
     * https://eips.ethereum.org/EIPS/eip-712
     * "\\x19" makes the encoding deterministic
     * "\\x01" is the version byte to make it compatible to EIP-191
     */
    function toTypedMessageHash(bytes32 messageHash)
        internal
        view
        returns (bytes32)
    {
        return
            keccak256(
                abi.encodePacked("\x19\x01", getDomainSeperator(), messageHash)
            );
    }
}

// File: contracts/common/NativeMetaTransaction.sol

contract NativeMetaTransaction is EIP712Base {
    using SafeMath for uint256;
    bytes32 private constant META_TRANSACTION_TYPEHASH = keccak256(
        bytes(
            "MetaTransaction(uint256 nonce,address from,bytes functionSignature)"
        )
    );
    event MetaTransactionExecuted(
        address userAddress,
        address payable relayerAddress,
        bytes functionSignature
    );
    mapping(address => uint256) nonces;

    /*
     * Meta transaction structure.
     * No point of including value field here as if user is doing value transfer then he has the funds to pay for gas
     * He should call the desired function directly in that case.
     */
    struct MetaTransaction {
        uint256 nonce;
        address from;
        bytes functionSignature;
    }

    function executeMetaTransaction(
        address userAddress,
        bytes memory functionSignature,
        bytes32 sigR,
        bytes32 sigS,
        uint8 sigV
    ) public payable returns (bytes memory) {
        MetaTransaction memory metaTx = MetaTransaction({
            nonce: nonces[userAddress],
            from: userAddress,
            functionSignature: functionSignature
        });

        require(
            verify(userAddress, metaTx, sigR, sigS, sigV),
            "Signer and signature do not match"
        );

        // increase nonce for user (to avoid re-use)
        nonces[userAddress] = nonces[userAddress].add(1);

        emit MetaTransactionExecuted(
            userAddress,
            payable(msg.sender),
            functionSignature
        );

        // Append userAddress and relayer address at the end to extract it from calling context
        (bool success, bytes memory returnData) = address(this).call(
            abi.encodePacked(functionSignature, userAddress)
        );
        require(success, "Function call not successful");

        return returnData;
    }

    function hashMetaTransaction(MetaTransaction memory metaTx)
        internal
        pure
        returns (bytes32)
    {
        return
            keccak256(
                abi.encode(
                    META_TRANSACTION_TYPEHASH,
                    metaTx.nonce,
                    metaTx.from,
                    keccak256(metaTx.functionSignature)
                )
            );
    }

    function getNonce(address user) public view returns (uint256 nonce) {
        nonce = nonces[user];
    }

    function verify(
        address signer,
        MetaTransaction memory metaTx,
        bytes32 sigR,
        bytes32 sigS,
        uint8 sigV
    ) internal view returns (bool) {
        require(signer != address(0), "NativeMetaTransaction: INVALID_SIGNER");
        return
            signer ==
            ecrecover(
                toTypedMessageHash(hashMetaTransaction(metaTx)),
                sigV,
                sigR,
                sigS
            );
    }
}

// File: contracts/common/ContextMixin.sol

abstract contract ContextMixin {
    function msgSender()
        internal
        view
        returns (address payable sender)
    {
        if (msg.sender == address(this)) {
            bytes memory array = msg.data;
            uint256 index = msg.data.length;
            assembly {
                // Load the 32 bytes word from memory with the address on the lower 20 bytes, and mask those.
                sender := and(
                    mload(add(array, index)),
                    0xffffffffffffffffffffffffffffffffffffffff
                )
            }
        } else {
            sender = payable(msg.sender);
        }
        return sender;
    }
}

// File: contracts/child/ChildToken/ChildMintableERC20.sol

contract SSGTx is
    ERC20,
    IChildToken,
    AccessControlMixin,
    NativeMetaTransaction,
    ContextMixin
{
    bytes32 public constant DEPOSITOR_ROLE = keccak256("DEPOSITOR_ROLE");

    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
    
    address public childChainManagerProxy;

    constructor(
        string memory name_,
        string memory symbol_,
        uint8 decimals_,
        address _childChainManagerProxy
    ) ERC20(name_, symbol_) {
        _setupContractId("SSGTx");
        _setupDecimals(decimals_);
        _setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
        _setupRole(DEPOSITOR_ROLE, _childChainManagerProxy);
        _setupRole(MINTER_ROLE, _msgSender());
        _initializeEIP712(name_);
        childChainManagerProxy = _childChainManagerProxy;
    }

    // This is to support Native meta transactions
    // never use msg.sender directly, use _msgSender() instead
    function _msgSender()
        internal
        override
        view
        returns (address payable sender)
    {
        return ContextMixin.msgSender();
    }

    /**
     * @notice called when token is deposited on root chain
     * @dev Should be callable only by ChildChainManager
     * Should handle deposit by minting the required amount for user
     * Make sure minting is done only by this function
     * @param user user address for whom deposit is being done
     * @param depositData abi encoded amount
     */
    function deposit(address user, bytes calldata depositData)
        external
        override
        only(DEPOSITOR_ROLE)
    {
        uint256 amount = abi.decode(depositData, (uint256));
        _mint(user, amount);
    }

    /**
     * @notice called when user wants to withdraw tokens back to root chain
     * @dev Should burn user's tokens. This transaction will be verified when exiting on root chain
     * @param amount amount of tokens to withdraw
     */
    function withdraw(uint256 amount) external {
        _burn(_msgSender(), amount);
    }

    /**
     * @notice Example function to handle minting tokens on matic chain
     * @dev Minting can be done as per requirement,
     * This implementation allows only admin to mint tokens but it can be changed as per requirement
     * @param user user for whom tokens are being minted
     * @param amount amount of token to mint
     */
    function mint(address user, uint256 amount) public only(MINTER_ROLE) {
        _mint(user, amount);
    }

    function burn(address _to, uint256 _amount) public only(MINTER_ROLE) {
        _customBurn(_to, _amount);
    }
    
    function setchildChainManager(address _childChainManagerProxy) public only(DEFAULT_ADMIN_ROLE){
        childChainManagerProxy = _childChainManagerProxy;
        _setupRole(DEPOSITOR_ROLE, _childChainManagerProxy);
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"uint8","name":"decimals_","type":"uint8"},{"internalType":"address","name":"_childChainManagerProxy","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Burn","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"userAddress","type":"address"},{"indexed":false,"internalType":"address payable","name":"relayerAddress","type":"address"},{"indexed":false,"internalType":"bytes","name":"functionSignature","type":"bytes"}],"name":"MetaTransactionExecuted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEPOSITOR_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ERC712_VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINTER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"childChainManagerProxy","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"bytes","name":"depositData","type":"bytes"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"userAddress","type":"address"},{"internalType":"bytes","name":"functionSignature","type":"bytes"},{"internalType":"bytes32","name":"sigR","type":"bytes32"},{"internalType":"bytes32","name":"sigS","type":"bytes32"},{"internalType":"uint8","name":"sigV","type":"uint8"}],"name":"executeMetaTransaction","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"getChainId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getDomainSeperator","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getNonce","outputs":[{"internalType":"uint256","name":"nonce","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_childChainManagerProxy","type":"address"}],"name":"setchildChainManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

60806040526000600860006101000a81548160ff0219169083151502179055503480156200002c57600080fd5b5060405162004715380380620047158339818101604052810190620000529190620008b9565b838381600390805190602001906200006c929190620005c9565b50806004908051906020019062000085929190620005c9565b506012600560006101000a81548160ff021916908360ff1602179055505050620000ea6040518060400160405280600581526020017f5353475478000000000000000000000000000000000000000000000000000000815250620001ee60201b60201c565b620000fb826200022b60201b60201c565b6200011f6000801b620001136200024960201b60201c565b6200026560201b60201c565b620001517f8f4f2da22e8ac8f11e15f9fc141cddbb5deea8800186560abb6e68c5496619a9826200026560201b60201c565b620001927f9f2df0fed2c77648de5860a4cc508cd0818c85b8b8a1ab4ceeef8d981c8956a6620001866200024960201b60201c565b6200026560201b60201c565b620001a3846200027b60201b60201c565b80600b60006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055505050505062000b9d565b8060405160200162000201919062000a06565b6040516020818303038152906040526007908051906020019062000227929190620005c9565b5050565b80600560006101000a81548160ff021916908360ff16021790555050565b600062000260620002fd60201b620014501760201c565b905090565b620002778282620003b060201b60201c565b5050565b600860009054906101000a900460ff1615620002ce576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401620002c59062000a8d565b60405180910390fd5b620002df81620004a260201b60201c565b6001600860006101000a81548160ff02191690831515021790555050565b60003073ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161415620003a957600080368080601f016020809104026020016040519081016040528093929190818152602001838380828437600081840152601f19601f820116905080830192505050505050509050600080369050905073ffffffffffffffffffffffffffffffffffffffff818301511692505050620003ad565b3390505b90565b620003c282826200055160201b60201c565b6200049e5760016006600084815260200190815260200160002060000160008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff021916908315150217905550620004436200024960201b60201c565b73ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16837f2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d60405160405180910390a45b5050565b6040518060800160405280604f8152602001620046c6604f91398051906020012081805190602001206040518060400160405280600181526020017f3100000000000000000000000000000000000000000000000000000000000000815250805190602001203062000519620005bc60201b60201c565b60001b6040516020016200053295949392919062000adb565b6040516020818303038152906040528051906020012060098190555050565b60006006600084815260200190815260200160002060000160008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff16905092915050565b6000804690508091505090565b828054620005d79062000b67565b90600052602060002090601f016020900481019282620005fb576000855562000647565b82601f106200061657805160ff191683800117855562000647565b8280016001018555821562000647579182015b828111156200064657825182559160200191906001019062000629565b5b5090506200065691906200065a565b5090565b5b80821115620006755760008160009055506001016200065b565b5090565b6000604051905090565b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b620006e28262000697565b810181811067ffffffffffffffff82111715620007045762000703620006a8565b5b80604052505050565b60006200071962000679565b9050620007278282620006d7565b919050565b600067ffffffffffffffff8211156200074a5762000749620006a8565b5b620007558262000697565b9050602081019050919050565b60005b838110156200078257808201518184015260208101905062000765565b8381111562000792576000848401525b50505050565b6000620007af620007a9846200072c565b6200070d565b905082815260208101848484011115620007ce57620007cd62000692565b5b620007db84828562000762565b509392505050565b600082601f830112620007fb57620007fa6200068d565b5b81516200080d84826020860162000798565b91505092915050565b600060ff82169050919050565b6200082e8162000816565b81146200083a57600080fd5b50565b6000815190506200084e8162000823565b92915050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000620008818262000854565b9050919050565b620008938162000874565b81146200089f57600080fd5b50565b600081519050620008b38162000888565b92915050565b60008060008060808587031215620008d657620008d562000683565b5b600085015167ffffffffffffffff811115620008f757620008f662000688565b5b6200090587828801620007e3565b945050602085015167ffffffffffffffff81111562000929576200092862000688565b5b6200093787828801620007e3565b93505060406200094a878288016200083d565b92505060606200095d87828801620008a2565b91505092959194509250565b600081519050919050565b600081905092915050565b60006200098c8262000969565b62000998818562000974565b9350620009aa81856020860162000762565b80840191505092915050565b7f3a20494e53554646494349454e545f5045524d495353494f4e53000000000000600082015250565b6000620009ee601a8362000974565b9150620009fb82620009b6565b601a82019050919050565b600062000a1482846200097f565b915062000a2182620009df565b915081905092915050565b600082825260208201905092915050565b7f616c726561647920696e69746564000000000000000000000000000000000000600082015250565b600062000a75600e8362000a2c565b915062000a828262000a3d565b602082019050919050565b6000602082019050818103600083015262000aa88162000a66565b9050919050565b6000819050919050565b62000ac48162000aaf565b82525050565b62000ad58162000874565b82525050565b600060a08201905062000af2600083018862000ab9565b62000b01602083018762000ab9565b62000b10604083018662000ab9565b62000b1f606083018562000aca565b62000b2e608083018462000ab9565b9695505050505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b6000600282049050600182168062000b8057607f821691505b6020821081141562000b975762000b9662000b38565b5b50919050565b613b198062000bad6000396000f3fe6080604052600436106101d85760003560e01c80633950935111610102578063a217fddf11610095578063cf2c52cb11610064578063cf2c52cb14610713578063d53913931461073c578063d547741f14610767578063dd62ed3e14610790576101d8565b8063a217fddf14610643578063a3b0b5a31461066e578063a457c2d714610699578063a9059cbb146106d6576101d8565b806370a08231116100d157806370a082311461057557806391d14854146105b257806395d89b41146105ef5780639dc29fac1461061a576101d8565b806339509351146104bb57806340c10f19146104f857806343ac1e491461052157806362f629e71461054a576101d8565b806323b872dd1161017a5780632f2ff15d116101495780632f2ff15d14610413578063313ce5671461043c5780633408e4701461046757806336568abe14610492576101d8565b806323b872dd14610333578063248a9ca3146103705780632d0335ab146103ad5780632e1a7d4d146103ea576101d8565b80630c53c51c116101b65780630c53c51c146102825780630f7e5970146102b257806318160ddd146102dd57806320379ee514610308576101d8565b806301ffc9a7146101dd57806306fdde031461021a578063095ea7b314610245575b600080fd5b3480156101e957600080fd5b5061020460048036038101906101ff9190612683565b6107cd565b60405161021191906126cb565b60405180910390f35b34801561022657600080fd5b5061022f610847565b60405161023c919061277f565b60405180910390f35b34801561025157600080fd5b5061026c60048036038101906102679190612835565b6108d9565b60405161027991906126cb565b60405180910390f35b61029c60048036038101906102979190612a19565b6108f7565b6040516102a99190612b05565b60405180910390f35b3480156102be57600080fd5b506102c7610b69565b6040516102d4919061277f565b60405180910390f35b3480156102e957600080fd5b506102f2610ba2565b6040516102ff9190612b36565b60405180910390f35b34801561031457600080fd5b5061031d610bac565b60405161032a9190612b60565b60405180910390f35b34801561033f57600080fd5b5061035a60048036038101906103559190612b7b565b610bb6565b60405161036791906126cb565b60405180910390f35b34801561037c57600080fd5b5061039760048036038101906103929190612bce565b610c8f565b6040516103a49190612b60565b60405180910390f35b3480156103b957600080fd5b506103d460048036038101906103cf9190612bfb565b610caf565b6040516103e19190612b36565b60405180910390f35b3480156103f657600080fd5b50610411600480360381019061040c9190612c28565b610cf8565b005b34801561041f57600080fd5b5061043a60048036038101906104359190612c55565b610d0c565b005b34801561044857600080fd5b50610451610d35565b60405161045e9190612ca4565b60405180910390f35b34801561047357600080fd5b5061047c610d4c565b6040516104899190612b36565b60405180910390f35b34801561049e57600080fd5b506104b960048036038101906104b49190612c55565b610d59565b005b3480156104c757600080fd5b506104e260048036038101906104dd9190612835565b610ddc565b6040516104ef91906126cb565b60405180910390f35b34801561050457600080fd5b5061051f600480360381019061051a9190612835565b610e8f565b005b34801561052d57600080fd5b5061054860048036038101906105439190612bfb565b610f14565b005b34801561055657600080fd5b5061055f610fdc565b60405161056c9190612cce565b60405180910390f35b34801561058157600080fd5b5061059c60048036038101906105979190612bfb565b611002565b6040516105a99190612b36565b60405180910390f35b3480156105be57600080fd5b506105d960048036038101906105d49190612c55565b61104a565b6040516105e691906126cb565b60405180910390f35b3480156105fb57600080fd5b506106046110b5565b604051610611919061277f565b60405180910390f35b34801561062657600080fd5b50610641600480360381019061063c9190612835565b611147565b005b34801561064f57600080fd5b506106586111cc565b6040516106659190612b60565b60405180910390f35b34801561067a57600080fd5b506106836111d3565b6040516106909190612b60565b60405180910390f35b3480156106a557600080fd5b506106c060048036038101906106bb9190612835565b6111f7565b6040516106cd91906126cb565b60405180910390f35b3480156106e257600080fd5b506106fd60048036038101906106f89190612835565b6112c4565b60405161070a91906126cb565b60405180910390f35b34801561071f57600080fd5b5061073a60048036038101906107359190612d49565b6112e2565b005b34801561074857600080fd5b5061075161137c565b60405161075e9190612b60565b60405180910390f35b34801561077357600080fd5b5061078e60048036038101906107899190612c55565b6113a0565b005b34801561079c57600080fd5b506107b760048036038101906107b29190612da9565b6113c9565b6040516107c49190612b36565b60405180910390f35b60007f7965db0b000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916827bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19161480610840575061083f82611501565b5b9050919050565b60606003805461085690612e18565b80601f016020809104026020016040519081016040528092919081815260200182805461088290612e18565b80156108cf5780601f106108a4576101008083540402835291602001916108cf565b820191906000526020600020905b8154815290600101906020018083116108b257829003601f168201915b5050505050905090565b60006108ed6108e661156b565b848461157a565b6001905092915050565b606060006040518060600160405280600a60008a73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000205481526020018873ffffffffffffffffffffffffffffffffffffffff16815260200187815250905061097a8782878787611745565b6109b9576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016109b090612ebc565b60405180910390fd5b610a0c6001600a60008a73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000205461184e90919063ffffffff16565b600a60008973ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055507f5845892132946850460bff5a0083f71031bc5bf9aadcd40f1de79423eac9b10b873388604051610a8293929190612efd565b60405180910390a16000803073ffffffffffffffffffffffffffffffffffffffff16888a604051602001610ab7929190612fbf565b604051602081830303815290604052604051610ad39190612fe7565b6000604051808303816000865af19150503d8060008114610b10576040519150601f19603f3d011682016040523d82523d6000602084013e610b15565b606091505b509150915081610b5a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610b519061304a565b60405180910390fd5b80935050505095945050505050565b6040518060400160405280600181526020017f310000000000000000000000000000000000000000000000000000000000000081525081565b6000600254905090565b6000600954905090565b6000610bc38484846118ac565b610c8484610bcf61156b565b610c7f85604051806060016040528060288152602001613a9760289139600160008b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206000610c3561156b565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054611b419092919063ffffffff16565b61157a565b600190509392505050565b600060066000838152602001908152602001600020600101549050919050565b6000600a60008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050919050565b610d09610d0361156b565b82611ba5565b50565b610d1582610c8f565b610d2681610d2161156b565b611d53565b610d308383611df0565b505050565b6000600560009054906101000a900460ff16905090565b6000804690508091505090565b610d6161156b565b73ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614610dce576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610dc5906130dc565b60405180910390fd5b610dd88282611ed1565b5050565b6000610e85610de961156b565b84610e808560016000610dfa61156b565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008973ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000205461184e90919063ffffffff16565b61157a565b6001905092915050565b7f9f2df0fed2c77648de5860a4cc508cd0818c85b8b8a1ab4ceeef8d981c8956a6610ec181610ebc61156b565b61104a565b600790610f04576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610efb9190613191565b60405180910390fd5b50610f0f8383611fb3565b505050565b6000801b610f2981610f2461156b565b61104a565b600790610f6c576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f639190613191565b60405180910390fd5b5081600b60006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550610fd87f8f4f2da22e8ac8f11e15f9fc141cddbb5deea8800186560abb6e68c5496619a983612147565b5050565b600b60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60008060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050919050565b60006006600084815260200190815260200160002060000160008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff16905092915050565b6060600480546110c490612e18565b80601f01602080910402602001604051908101604052809291908181526020018280546110f090612e18565b801561113d5780601f106111125761010080835404028352916020019161113d565b820191906000526020600020905b81548152906001019060200180831161112057829003601f168201915b5050505050905090565b7f9f2df0fed2c77648de5860a4cc508cd0818c85b8b8a1ab4ceeef8d981c8956a66111798161117461156b565b61104a565b6007906111bc576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016111b39190613191565b60405180910390fd5b506111c78383612155565b505050565b6000801b81565b7f8f4f2da22e8ac8f11e15f9fc141cddbb5deea8800186560abb6e68c5496619a981565b60006112ba61120461156b565b846112b585604051806060016040528060258152602001613abf602591396001600061122e61156b565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008a73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054611b419092919063ffffffff16565b61157a565b6001905092915050565b60006112d86112d161156b565b84846118ac565b6001905092915050565b7f8f4f2da22e8ac8f11e15f9fc141cddbb5deea8800186560abb6e68c5496619a96113148161130f61156b565b61104a565b600790611357576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161134e9190613191565b60405180910390fd5b50600083838101906113699190612c28565b90506113758582611fb3565b5050505050565b7f9f2df0fed2c77648de5860a4cc508cd0818c85b8b8a1ab4ceeef8d981c8956a681565b6113a982610c8f565b6113ba816113b561156b565b611d53565b6113c48383611ed1565b505050565b6000600160008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054905092915050565b60003073ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614156114fa57600080368080601f016020809104026020016040519081016040528093929190818152602001838380828437600081840152601f19601f820116905080830192505050505050509050600080369050905073ffffffffffffffffffffffffffffffffffffffff8183015116925050506114fe565b3390505b90565b60007f01ffc9a7000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916827bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916149050919050565b6000611575611450565b905090565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1614156115ea576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016115e190613225565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16141561165a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611651906132b7565b60405180910390fd5b80600160008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055508173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925836040516117389190612b36565b60405180910390a3505050565b60008073ffffffffffffffffffffffffffffffffffffffff168673ffffffffffffffffffffffffffffffffffffffff1614156117b6576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016117ad90613349565b60405180910390fd5b60016117c96117c4876122eb565b612353565b838686604051600081526020016040526040516117e99493929190613369565b6020604051602081039080840390855afa15801561180b573d6000803e3d6000fd5b5050506020604051035173ffffffffffffffffffffffffffffffffffffffff168673ffffffffffffffffffffffffffffffffffffffff1614905095945050505050565b600080828461185d91906133dd565b9050838110156118a2576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016118999061347f565b60405180910390fd5b8091505092915050565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff16141561191c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161191390613511565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16141561198c576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611983906135a3565b60405180910390fd5b61199783838361238c565b611a0281604051806060016040528060268152602001613a71602691396000808773ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054611b419092919063ffffffff16565b6000808573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002081905550611a95816000808573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000205461184e90919063ffffffff16565b6000808473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055508173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef83604051611b349190612b36565b60405180910390a3505050565b6000838311158290611b89576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611b80919061277f565b60405180910390fd5b5060008385611b9891906135c3565b9050809150509392505050565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415611c15576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611c0c90613669565b60405180910390fd5b611c218260008361238c565b611c8c81604051806060016040528060228152602001613a0c602291396000808673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054611b419092919063ffffffff16565b6000808473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002081905550611ce38160025461239190919063ffffffff16565b600281905550600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef83604051611d479190612b36565b60405180910390a35050565b611d5d828261104a565b611dec57611d828173ffffffffffffffffffffffffffffffffffffffff1660146123db565b611d908360001c60206123db565b604051602001611da192919061375d565b6040516020818303038152906040526040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611de3919061277f565b60405180910390fd5b5050565b611dfa828261104a565b611ecd5760016006600084815260200190815260200160002060000160008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff021916908315150217905550611e7261156b565b73ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16837f2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d60405160405180910390a45b5050565b611edb828261104a565b15611faf5760006006600084815260200190815260200160002060000160008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff021916908315150217905550611f5461156b565b73ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16837ff6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b60405160405180910390a45b5050565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415612023576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161201a906137e3565b60405180910390fd5b61202f6000838361238c565b6120448160025461184e90919063ffffffff16565b60028190555061209b816000808573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000205461184e90919063ffffffff16565b6000808473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055508173ffffffffffffffffffffffffffffffffffffffff16600073ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef8360405161213b9190612b36565b60405180910390a35050565b6121518282611df0565b5050565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1614156121c5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016121bc90613669565b60405180910390fd5b6121d18260008361238c565b61223c81604051806060016040528060228152602001613a0c602291396000808673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054611b419092919063ffffffff16565b6000808473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055506122938160025461239190919063ffffffff16565b6002819055508173ffffffffffffffffffffffffffffffffffffffff167fcc16f5dbb4873280815c1ee09dbd06736cffcc184412cf7a71a0fdb75d397ca5826040516122df9190612b36565b60405180910390a25050565b6000604051806080016040528060438152602001613a2e6043913980519060200120826000015183602001518460400151805190602001206040516020016123369493929190613803565b604051602081830303815290604052805190602001209050919050565b600061235d610bac565b8260405160200161236f9291906138b5565b604051602081830303815290604052805190602001209050919050565b505050565b60006123d383836040518060400160405280601e81526020017f536166654d6174683a207375627472616374696f6e206f766572666c6f770000815250611b41565b905092915050565b6060600060028360026123ee91906138ec565b6123f891906133dd565b67ffffffffffffffff8111156124115761241061287f565b5b6040519080825280601f01601f1916602001820160405280156124435781602001600182028036833780820191505090505b5090507f30000000000000000000000000000000000000000000000000000000000000008160008151811061247b5761247a613946565b5b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a9053507f7800000000000000000000000000000000000000000000000000000000000000816001815181106124df576124de613946565b5b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a9053506000600184600261251f91906138ec565b61252991906133dd565b90505b60018111156125c9577f3031323334353637383961626364656600000000000000000000000000000000600f86166010811061256b5761256a613946565b5b1a60f81b82828151811061258257612581613946565b5b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a905350600485901c9450806125c290613975565b905061252c565b506000841461260d576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612604906139eb565b60405180910390fd5b8091505092915050565b6000604051905090565b600080fd5b600080fd5b60007fffffffff0000000000000000000000000000000000000000000000000000000082169050919050565b6126608161262b565b811461266b57600080fd5b50565b60008135905061267d81612657565b92915050565b60006020828403121561269957612698612621565b5b60006126a78482850161266e565b91505092915050565b60008115159050919050565b6126c5816126b0565b82525050565b60006020820190506126e060008301846126bc565b92915050565b600081519050919050565b600082825260208201905092915050565b60005b83811015612720578082015181840152602081019050612705565b8381111561272f576000848401525b50505050565b6000601f19601f8301169050919050565b6000612751826126e6565b61275b81856126f1565b935061276b818560208601612702565b61277481612735565b840191505092915050565b600060208201905081810360008301526127998184612746565b905092915050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b60006127cc826127a1565b9050919050565b6127dc816127c1565b81146127e757600080fd5b50565b6000813590506127f9816127d3565b92915050565b6000819050919050565b612812816127ff565b811461281d57600080fd5b50565b60008135905061282f81612809565b92915050565b6000806040838503121561284c5761284b612621565b5b600061285a858286016127ea565b925050602061286b85828601612820565b9150509250929050565b600080fd5b600080fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b6128b782612735565b810181811067ffffffffffffffff821117156128d6576128d561287f565b5b80604052505050565b60006128e9612617565b90506128f582826128ae565b919050565b600067ffffffffffffffff8211156129155761291461287f565b5b61291e82612735565b9050602081019050919050565b82818337600083830152505050565b600061294d612948846128fa565b6128df565b9050828152602081018484840111156129695761296861287a565b5b61297484828561292b565b509392505050565b600082601f83011261299157612990612875565b5b81356129a184826020860161293a565b91505092915050565b6000819050919050565b6129bd816129aa565b81146129c857600080fd5b50565b6000813590506129da816129b4565b92915050565b600060ff82169050919050565b6129f6816129e0565b8114612a0157600080fd5b50565b600081359050612a13816129ed565b92915050565b600080600080600060a08688031215612a3557612a34612621565b5b6000612a43888289016127ea565b955050602086013567ffffffffffffffff811115612a6457612a63612626565b5b612a708882890161297c565b9450506040612a81888289016129cb565b9350506060612a92888289016129cb565b9250506080612aa388828901612a04565b9150509295509295909350565b600081519050919050565b600082825260208201905092915050565b6000612ad782612ab0565b612ae18185612abb565b9350612af1818560208601612702565b612afa81612735565b840191505092915050565b60006020820190508181036000830152612b1f8184612acc565b905092915050565b612b30816127ff565b82525050565b6000602082019050612b4b6000830184612b27565b92915050565b612b5a816129aa565b82525050565b6000602082019050612b756000830184612b51565b92915050565b600080600060608486031215612b9457612b93612621565b5b6000612ba2868287016127ea565b9350506020612bb3868287016127ea565b9250506040612bc486828701612820565b9150509250925092565b600060208284031215612be457612be3612621565b5b6000612bf2848285016129cb565b91505092915050565b600060208284031215612c1157612c10612621565b5b6000612c1f848285016127ea565b91505092915050565b600060208284031215612c3e57612c3d612621565b5b6000612c4c84828501612820565b91505092915050565b60008060408385031215612c6c57612c6b612621565b5b6000612c7a858286016129cb565b9250506020612c8b858286016127ea565b9150509250929050565b612c9e816129e0565b82525050565b6000602082019050612cb96000830184612c95565b92915050565b612cc8816127c1565b82525050565b6000602082019050612ce36000830184612cbf565b92915050565b600080fd5b600080fd5b60008083601f840112612d0957612d08612875565b5b8235905067ffffffffffffffff811115612d2657612d25612ce9565b5b602083019150836001820283011115612d4257612d41612cee565b5b9250929050565b600080600060408486031215612d6257612d61612621565b5b6000612d70868287016127ea565b935050602084013567ffffffffffffffff811115612d9157612d90612626565b5b612d9d86828701612cf3565b92509250509250925092565b60008060408385031215612dc057612dbf612621565b5b6000612dce858286016127ea565b9250506020612ddf858286016127ea565b9150509250929050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b60006002820490506001821680612e3057607f821691505b60208210811415612e4457612e43612de9565b5b50919050565b7f5369676e657220616e64207369676e617475726520646f206e6f74206d61746360008201527f6800000000000000000000000000000000000000000000000000000000000000602082015250565b6000612ea66021836126f1565b9150612eb182612e4a565b604082019050919050565b60006020820190508181036000830152612ed581612e99565b9050919050565b6000612ee7826127a1565b9050919050565b612ef781612edc565b82525050565b6000606082019050612f126000830186612cbf565b612f1f6020830185612eee565b8181036040830152612f318184612acc565b9050949350505050565b600081905092915050565b6000612f5182612ab0565b612f5b8185612f3b565b9350612f6b818560208601612702565b80840191505092915050565b60008160601b9050919050565b6000612f8f82612f77565b9050919050565b6000612fa182612f84565b9050919050565b612fb9612fb4826127c1565b612f96565b82525050565b6000612fcb8285612f46565b9150612fd78284612fa8565b6014820191508190509392505050565b6000612ff38284612f46565b915081905092915050565b7f46756e6374696f6e2063616c6c206e6f74207375636365737366756c00000000600082015250565b6000613034601c836126f1565b915061303f82612ffe565b602082019050919050565b6000602082019050818103600083015261306381613027565b9050919050565b7f416363657373436f6e74726f6c3a2063616e206f6e6c792072656e6f756e636560008201527f20726f6c657320666f722073656c660000000000000000000000000000000000602082015250565b60006130c6602f836126f1565b91506130d18261306a565b604082019050919050565b600060208201905081810360008301526130f5816130b9565b9050919050565b60008190508160005260206000209050919050565b6000815461311e81612e18565b61312881866126f1565b94506001821660008114613143576001811461315557613188565b60ff1983168652602086019350613188565b61315e856130fc565b60005b8381101561318057815481890152600182019150602081019050613161565b808801955050505b50505092915050565b600060208201905081810360008301526131ab8184613111565b905092915050565b7f45524332303a20617070726f76652066726f6d20746865207a65726f2061646460008201527f7265737300000000000000000000000000000000000000000000000000000000602082015250565b600061320f6024836126f1565b915061321a826131b3565b604082019050919050565b6000602082019050818103600083015261323e81613202565b9050919050565b7f45524332303a20617070726f766520746f20746865207a65726f20616464726560008201527f7373000000000000000000000000000000000000000000000000000000000000602082015250565b60006132a16022836126f1565b91506132ac82613245565b604082019050919050565b600060208201905081810360008301526132d081613294565b9050919050565b7f4e61746976654d6574615472616e73616374696f6e3a20494e56414c49445f5360008201527f49474e4552000000000000000000000000000000000000000000000000000000602082015250565b60006133336025836126f1565b915061333e826132d7565b604082019050919050565b6000602082019050818103600083015261336281613326565b9050919050565b600060808201905061337e6000830187612b51565b61338b6020830186612c95565b6133986040830185612b51565b6133a56060830184612b51565b95945050505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b60006133e8826127ff565b91506133f3836127ff565b9250827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff03821115613428576134276133ae565b5b828201905092915050565b7f536166654d6174683a206164646974696f6e206f766572666c6f770000000000600082015250565b6000613469601b836126f1565b915061347482613433565b602082019050919050565b600060208201905081810360008301526134988161345c565b9050919050565b7f45524332303a207472616e736665722066726f6d20746865207a65726f20616460008201527f6472657373000000000000000000000000000000000000000000000000000000602082015250565b60006134fb6025836126f1565b91506135068261349f565b604082019050919050565b6000602082019050818103600083015261352a816134ee565b9050919050565b7f45524332303a207472616e7366657220746f20746865207a65726f206164647260008201527f6573730000000000000000000000000000000000000000000000000000000000602082015250565b600061358d6023836126f1565b915061359882613531565b604082019050919050565b600060208201905081810360008301526135bc81613580565b9050919050565b60006135ce826127ff565b91506135d9836127ff565b9250828210156135ec576135eb6133ae565b5b828203905092915050565b7f45524332303a206275726e2066726f6d20746865207a65726f2061646472657360008201527f7300000000000000000000000000000000000000000000000000000000000000602082015250565b60006136536021836126f1565b915061365e826135f7565b604082019050919050565b6000602082019050818103600083015261368281613646565b9050919050565b600081905092915050565b7f416363657373436f6e74726f6c3a206163636f756e7420000000000000000000600082015250565b60006136ca601783613689565b91506136d582613694565b601782019050919050565b60006136eb826126e6565b6136f58185613689565b9350613705818560208601612702565b80840191505092915050565b7f206973206d697373696e6720726f6c6520000000000000000000000000000000600082015250565b6000613747601183613689565b915061375282613711565b601182019050919050565b6000613768826136bd565b915061377482856136e0565b915061377f8261373a565b915061378b82846136e0565b91508190509392505050565b7f45524332303a206d696e7420746f20746865207a65726f206164647265737300600082015250565b60006137cd601f836126f1565b91506137d882613797565b602082019050919050565b600060208201905081810360008301526137fc816137c0565b9050919050565b60006080820190506138186000830187612b51565b6138256020830186612b27565b6138326040830185612cbf565b61383f6060830184612b51565b95945050505050565b7f1901000000000000000000000000000000000000000000000000000000000000600082015250565b600061387e600283613689565b915061388982613848565b600282019050919050565b6000819050919050565b6138af6138aa826129aa565b613894565b82525050565b60006138c082613871565b91506138cc828561389e565b6020820191506138dc828461389e565b6020820191508190509392505050565b60006138f7826127ff565b9150613902836127ff565b9250817fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff048311821515161561393b5761393a6133ae565b5b828202905092915050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b6000613980826127ff565b91506000821415613994576139936133ae565b5b600182039050919050565b7f537472696e67733a20686578206c656e67746820696e73756666696369656e74600082015250565b60006139d56020836126f1565b91506139e08261399f565b602082019050919050565b60006020820190508181036000830152613a04816139c8565b905091905056fe45524332303a206275726e20616d6f756e7420657863656564732062616c616e63654d6574615472616e73616374696f6e2875696e74323536206e6f6e63652c616464726573732066726f6d2c62797465732066756e6374696f6e5369676e61747572652945524332303a207472616e7366657220616d6f756e7420657863656564732062616c616e636545524332303a207472616e7366657220616d6f756e74206578636565647320616c6c6f77616e636545524332303a2064656372656173656420616c6c6f77616e63652062656c6f77207a65726fa26469706673582212200b2f4a667b9ba30f3bbe7a45172eec4d9a10d44aeb5232767935a3fc970eea0d64736f6c63430008090033454950373132446f6d61696e28737472696e67206e616d652c737472696e672076657273696f6e2c6164647265737320766572696679696e67436f6e74726163742c627974657333322073616c7429000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000012000000000000000000000000a6fa4fb5f76172d178d61b04b0ecd319c5d1c0aa0000000000000000000000000000000000000000000000000000000000000008536166655377617000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000055353475478000000000000000000000000000000000000000000000000000000

000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000012000000000000000000000000a6fa4fb5f76172d178d61b04b0ecd319c5d1c0aa0000000000000000000000000000000000000000000000000000000000000008536166655377617000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000055353475478000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name_ (string): SafeSwap
Arg [1] : symbol_ (string): SSGTx
Arg [2] : decimals_ (uint8): 18
Arg [3] : _childChainManagerProxy (address): 0xa6fa4fb5f76172d178d61b04b0ecd319c5d1c0aa

-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000012
Arg [3] : 000000000000000000000000a6fa4fb5f76172d178d61b04b0ecd319c5d1c0aa
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000008
Arg [5] : 5361666553776170000000000000000000000000000000000000000000000000
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [7] : 5353475478000000000000000000000000000000000000000000000000000000

60715:2909:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48908:204;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;17941:83;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;20047:169;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57727:1151;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54936:43;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19016:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55946:101;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;20690:321;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50319:123;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59304:107;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;62709:89;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;50704:147;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;18868:83;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56055:161;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51752:218;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;21420;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;63156:107;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;63396:223;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;60994:37;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19179:119;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49204:139;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;18143:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;63271:113;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;48295:49;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;60842:68;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;22141:269;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19511:175;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;62224:230;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;60919:62;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51096:149;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;19749:151;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;48908:204;48993:4;49032:32;49017:47;;;:11;:47;;;;:87;;;;49068:36;49092:11;49068:23;:36::i;:::-;49017:87;49010:94;;48908:204;;;:::o;17941:83::-;17978:13;18011:5;18004:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17941:83;:::o;20047:169::-;20130:4;20147:39;20156:12;:10;:12::i;:::-;20170:7;20179:6;20147:8;:39::i;:::-;20204:4;20197:11;;20047:169;;;;:::o;57727:1151::-;57928:12;57953:29;57985:152;;;;;;;;58023:6;:19;58030:11;58023:19;;;;;;;;;;;;;;;;57985:152;;;;58063:11;57985:152;;;;;;58108:17;57985:152;;;57953:184;;58172:45;58179:11;58192:6;58200:4;58206;58212;58172:6;:45::i;:::-;58150:128;;;;;;;;;;;;:::i;:::-;;;;;;;;;58367:26;58391:1;58367:6;:19;58374:11;58367:19;;;;;;;;;;;;;;;;:23;;:26;;;;:::i;:::-;58345:6;:19;58352:11;58345:19;;;;;;;;;;;;;;;:48;;;;58411:126;58449:11;58483:10;58509:17;58411:126;;;;;;;;:::i;:::-;;;;;;;;58648:12;58662:23;58697:4;58689:18;;58739:17;58758:11;58722:48;;;;;;;;;:::i;:::-;;;;;;;;;;;;;58689:92;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58647:134;;;;58800:7;58792:48;;;;;;;;;;;;:::i;:::-;;;;;;;;;58860:10;58853:17;;;;;57727:1151;;;;;;;:::o;54936:43::-;;;;;;;;;;;;;;;;;;;:::o;19016:100::-;19069:7;19096:12;;19089:19;;19016:100;:::o;55946:101::-;55997:7;56024:15;;56017:22;;55946:101;:::o;20690:321::-;20796:4;20813:36;20823:6;20831:9;20842:6;20813:9;:36::i;:::-;20860:121;20869:6;20877:12;:10;:12::i;:::-;20891:89;20929:6;20891:89;;;;;;;;;;;;;;;;;:11;:19;20903:6;20891:19;;;;;;;;;;;;;;;:33;20911:12;:10;:12::i;:::-;20891:33;;;;;;;;;;;;;;;;:37;;:89;;;;;:::i;:::-;20860:8;:121::i;:::-;20999:4;20992:11;;20690:321;;;;;:::o;50319:123::-;50385:7;50412:6;:12;50419:4;50412:12;;;;;;;;;;;:22;;;50405:29;;50319:123;;;:::o;59304:107::-;59357:13;59391:6;:12;59398:4;59391:12;;;;;;;;;;;;;;;;59383:20;;59304:107;;;:::o;62709:89::-;62763:27;62769:12;:10;:12::i;:::-;62783:6;62763:5;:27::i;:::-;62709:89;:::o;50704:147::-;50787:18;50800:4;50787:12;:18::i;:::-;48786:30;48797:4;48803:12;:10;:12::i;:::-;48786:10;:30::i;:::-;50818:25:::1;50829:4;50835:7;50818:10;:25::i;:::-;50704:147:::0;;;:::o;18868:83::-;18909:5;18934:9;;;;;;;;;;;18927:16;;18868:83;:::o;56055:161::-;56098:7;56118:10;56169:9;56163:15;;56206:2;56199:9;;;56055:161;:::o;51752:218::-;51859:12;:10;:12::i;:::-;51848:23;;:7;:23;;;51840:83;;;;;;;;;;;;:::i;:::-;;;;;;;;;51936:26;51948:4;51954:7;51936:11;:26::i;:::-;51752:218;;:::o;21420:::-;21508:4;21525:83;21534:12;:10;:12::i;:::-;21548:7;21557:50;21596:10;21557:11;:25;21569:12;:10;:12::i;:::-;21557:25;;;;;;;;;;;;;;;:34;21583:7;21557:34;;;;;;;;;;;;;;;;:38;;:50;;;;:::i;:::-;21525:8;:83::i;:::-;21626:4;21619:11;;21420:218;;;;:::o;63156:107::-;60957:24;54233:27;54241:4;54247:12;:10;:12::i;:::-;54233:7;:27::i;:::-;54275:10;54211:85;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;63236:19:::1;63242:4;63248:6;63236:5;:19::i;:::-;63156:107:::0;;;:::o;63396:223::-;48340:4;63471:18;;54233:27;54241:4;54247:12;:10;:12::i;:::-;54233:7;:27::i;:::-;54275:10;54211:85;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;63526:23:::1;63501:22;;:48;;;;;;;;;;;;;;;;;;63560:51;60883:27;63587:23;63560:10;:51::i;:::-;63396:223:::0;;:::o;60994:37::-;;;;;;;;;;;;;:::o;19179:119::-;19245:7;19272:9;:18;19282:7;19272:18;;;;;;;;;;;;;;;;19265:25;;19179:119;;;:::o;49204:139::-;49282:4;49306:6;:12;49313:4;49306:12;;;;;;;;;;;:20;;:29;49327:7;49306:29;;;;;;;;;;;;;;;;;;;;;;;;;49299:36;;49204:139;;;;:::o;18143:87::-;18182:13;18215:7;18208:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18143:87;:::o;63271:113::-;60957:24;54233:27;54241:4;54247:12;:10;:12::i;:::-;54233:7;:27::i;:::-;54275:10;54211:85;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;63351:25:::1;63363:3;63368:7;63351:11;:25::i;:::-;63271:113:::0;;;:::o;48295:49::-;48340:4;48295:49;;;:::o;60842:68::-;60883:27;60842:68;:::o;22141:269::-;22234:4;22251:129;22260:12;:10;:12::i;:::-;22274:7;22283:96;22322:15;22283:96;;;;;;;;;;;;;;;;;:11;:25;22295:12;:10;:12::i;:::-;22283:25;;;;;;;;;;;;;;;:34;22309:7;22283:34;;;;;;;;;;;;;;;;:38;;:96;;;;;:::i;:::-;22251:8;:129::i;:::-;22398:4;22391:11;;22141:269;;;;:::o;19511:175::-;19597:4;19614:42;19624:12;:10;:12::i;:::-;19638:9;19649:6;19614:9;:42::i;:::-;19674:4;19667:11;;19511:175;;;;:::o;62224:230::-;60883:27;54233;54241:4;54247:12;:10;:12::i;:::-;54233:7;:27::i;:::-;54275:10;54211:85;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;62365:14:::1;62393:11;;62382:34;;;;;;;:::i;:::-;62365:51;;62427:19;62433:4;62439:6;62427:5;:19::i;:::-;62354:100;62224:230:::0;;;;:::o;60919:62::-;60957:24;60919:62;:::o;51096:149::-;51180:18;51193:4;51180:12;:18::i;:::-;48786:30;48797:4;48803:12;:10;:12::i;:::-;48786:10;:30::i;:::-;51211:26:::1;51223:4;51229:7;51211:11;:26::i;:::-;51096:149:::0;;;:::o;19749:151::-;19838:7;19865:11;:18;19877:5;19865:18;;;;;;;;;;;;;;;:27;19884:7;19865:27;;;;;;;;;;;;;;;;19858:34;;19749:151;;;;:::o;59996:650::-;60067:22;60133:4;60111:27;;:10;:27;;;60107:508;;;60155:18;60176:8;;60155:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60199:13;60215:8;;:15;;60199:31;;60467:42;60437:5;60430;60426:17;60420:24;60394:134;60384:144;;60254:289;;60107:508;;;60592:10;60575:28;;60107:508;59996:650;:::o;43382:157::-;43467:4;43506:25;43491:40;;;:11;:40;;;;43484:47;;43382:157;;;:::o;61674:169::-;61764:22;61811:24;:22;:24::i;:::-;61804:31;;61674:169;:::o;26030:346::-;26149:1;26132:19;;:5;:19;;;;26124:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;26230:1;26211:21;;:7;:21;;;;26203:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;26314:6;26284:11;:18;26296:5;26284:18;;;;;;;;;;;;;;;:27;26303:7;26284:27;;;;;;;;;;;;;;;:36;;;;26352:7;26336:32;;26345:5;26336:32;;;26361:6;26336:32;;;;;;:::i;:::-;;;;;;;;26030:346;;;:::o;59419:486::-;59597:4;59640:1;59622:20;;:6;:20;;;;59614:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;59738:159;59766:47;59785:27;59805:6;59785:19;:27::i;:::-;59766:18;:47::i;:::-;59832:4;59855;59878;59738:159;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59715:182;;:6;:182;;;59695:202;;59419:486;;;;;;;:::o;5116:181::-;5174:7;5194:9;5210:1;5206;:5;;;;:::i;:::-;5194:17;;5235:1;5230;:6;;5222:46;;;;;;;;;;;;:::i;:::-;;;;;;;;;5288:1;5281:8;;;5116:181;;;;:::o;22900:539::-;23024:1;23006:20;;:6;:20;;;;22998:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;23108:1;23087:23;;:9;:23;;;;23079:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;23163:47;23184:6;23192:9;23203:6;23163:20;:47::i;:::-;23243:71;23265:6;23243:71;;;;;;;;;;;;;;;;;:9;:17;23253:6;23243:17;;;;;;;;;;;;;;;;:21;;:71;;;;;:::i;:::-;23223:9;:17;23233:6;23223:17;;;;;;;;;;;;;;;:91;;;;23348:32;23373:6;23348:9;:20;23358:9;23348:20;;;;;;;;;;;;;;;;:24;;:32;;;;:::i;:::-;23325:9;:20;23335:9;23325:20;;;;;;;;;;;;;;;:55;;;;23413:9;23396:35;;23405:6;23396:35;;;23424:6;23396:35;;;;;;:::i;:::-;;;;;;;;22900:539;;;:::o;6019:192::-;6105:7;6138:1;6133;:6;;6141:12;6125:29;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;6165:9;6181:1;6177;:5;;;;:::i;:::-;6165:17;;6202:1;6195:8;;;6019:192;;;;;:::o;25170:418::-;25273:1;25254:21;;:7;:21;;;;25246:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;25326:49;25347:7;25364:1;25368:6;25326:20;:49::i;:::-;25409:68;25432:6;25409:68;;;;;;;;;;;;;;;;;:9;:18;25419:7;25409:18;;;;;;;;;;;;;;;;:22;;:68;;;;;:::i;:::-;25388:9;:18;25398:7;25388:18;;;;;;;;;;;;;;;:89;;;;25503:24;25520:6;25503:12;;:16;;:24;;;;:::i;:::-;25488:12;:39;;;;25569:1;25543:37;;25552:7;25543:37;;;25573:6;25543:37;;;;;;:::i;:::-;;;;;;;;25170:418;;:::o;49633:497::-;49714:22;49722:4;49728:7;49714;:22::i;:::-;49709:414;;49902:41;49930:7;49902:41;;49940:2;49902:19;:41::i;:::-;50016:38;50044:4;50036:13;;50051:2;50016:19;:38::i;:::-;49807:270;;;;;;;;;:::i;:::-;;;;;;;;;;;;;49753:358;;;;;;;;;;;:::i;:::-;;;;;;;;49709:414;49633:497;;:::o;53253:238::-;53337:22;53345:4;53351:7;53337;:22::i;:::-;53332:152;;53408:4;53376:6;:12;53383:4;53376:12;;;;;;;;;;;:20;;:29;53397:7;53376:29;;;;;;;;;;;;;;;;:36;;;;;;;;;;;;;;;;;;53459:12;:10;:12::i;:::-;53432:40;;53450:7;53432:40;;53444:4;53432:40;;;;;;;;;;53332:152;53253:238;;:::o;53623:239::-;53707:22;53715:4;53721:7;53707;:22::i;:::-;53703:152;;;53778:5;53746:6;:12;53753:4;53746:12;;;;;;;;;;;:20;;:29;53767:7;53746:29;;;;;;;;;;;;;;;;:37;;;;;;;;;;;;;;;;;;53830:12;:10;:12::i;:::-;53803:40;;53821:7;53803:40;;53815:4;53803:40;;;;;;;;;;53703:152;53623:239;;:::o;23720:378::-;23823:1;23804:21;;:7;:21;;;;23796:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;23874:49;23903:1;23907:7;23916:6;23874:20;:49::i;:::-;23951:24;23968:6;23951:12;;:16;;:24;;;;:::i;:::-;23936:12;:39;;;;24007:30;24030:6;24007:9;:18;24017:7;24007:18;;;;;;;;;;;;;;;;:22;;:30;;;;:::i;:::-;23986:9;:18;23996:7;23986:18;;;;;;;;;;;;;;;:51;;;;24074:7;24053:37;;24070:1;24053:37;;;24083:6;24053:37;;;;;;:::i;:::-;;;;;;;;23720:378;;:::o;52629:112::-;52708:25;52719:4;52725:7;52708:10;:25::i;:::-;52629:112;;:::o;24430:408::-;24539:1;24520:21;;:7;:21;;;;24512:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;24592:49;24613:7;24630:1;24634:6;24592:20;:49::i;:::-;24675:68;24698:6;24675:68;;;;;;;;;;;;;;;;;:9;:18;24685:7;24675:18;;;;;;;;;;;;;;;;:22;;:68;;;;;:::i;:::-;24654:9;:18;24664:7;24654:18;;;;;;;;;;;;;;;:89;;;;24769:24;24786:6;24769:12;;:16;;:24;;;;:::i;:::-;24754:12;:39;;;;24814:7;24809:21;;;24823:6;24809:21;;;;;;:::i;:::-;;;;;;;;24430:408;;:::o;58886:410::-;58996:7;57063:100;;;;;;;;;;;;;;;;;57043:127;;;;;;59150:6;:12;;;59185:6;:11;;;59229:6;:24;;;59219:35;;;;;;59069:204;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;59041:247;;;;;;59021:267;;58886:410;;;:::o;56585:258::-;56684:7;56786:20;:18;:20::i;:::-;56808:11;56757:63;;;;;;;;;:::i;:::-;;;;;;;;;;;;;56729:106;;;;;;56709:126;;56585:258;;;:::o;27401:92::-;;;;:::o;5580:136::-;5638:7;5665:43;5669:1;5672;5665:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;5658:50;;5580:136;;;;:::o;41476:451::-;41551:13;41577:19;41622:1;41613:6;41609:1;:10;;;;:::i;:::-;:14;;;;:::i;:::-;41599:25;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41577:47;;41635:15;:6;41642:1;41635:9;;;;;;;;:::i;:::-;;;;;:15;;;;;;;;;;;41661;:6;41668:1;41661:9;;;;;;;;:::i;:::-;;;;;:15;;;;;;;;;;;41692:9;41717:1;41708:6;41704:1;:10;;;;:::i;:::-;:14;;;;:::i;:::-;41692:26;;41687:135;41724:1;41720;:5;41687:135;;;41759:12;41780:3;41772:5;:11;41759:25;;;;;;;:::i;:::-;;;;;41747:6;41754:1;41747:9;;;;;;;;:::i;:::-;;;;;:37;;;;;;;;;;;41809:1;41799:11;;;;;41727:3;;;;:::i;:::-;;;41687:135;;;;41849:1;41840:5;:10;41832:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;41912:6;41898:21;;;41476:451;;;;:::o;7:75:1:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:149;370:7;410:66;403:5;399:78;388:89;;334:149;;;:::o;489:120::-;561:23;578:5;561:23;:::i;:::-;554:5;551:34;541:62;;599:1;596;589:12;541:62;489:120;:::o;615:137::-;660:5;698:6;685:20;676:29;;714:32;740:5;714:32;:::i;:::-;615:137;;;;:::o;758:327::-;816:6;865:2;853:9;844:7;840:23;836:32;833:119;;;871:79;;:::i;:::-;833:119;991:1;1016:52;1060:7;1051:6;1040:9;1036:22;1016:52;:::i;:::-;1006:62;;962:116;758:327;;;;:::o;1091:90::-;1125:7;1168:5;1161:13;1154:21;1143:32;;1091:90;;;:::o;1187:109::-;1268:21;1283:5;1268:21;:::i;:::-;1263:3;1256:34;1187:109;;:::o;1302:210::-;1389:4;1427:2;1416:9;1412:18;1404:26;;1440:65;1502:1;1491:9;1487:17;1478:6;1440:65;:::i;:::-;1302:210;;;;:::o;1518:99::-;1570:6;1604:5;1598:12;1588:22;;1518:99;;;:::o;1623:169::-;1707:11;1741:6;1736:3;1729:19;1781:4;1776:3;1772:14;1757:29;;1623:169;;;;:::o;1798:307::-;1866:1;1876:113;1890:6;1887:1;1884:13;1876:113;;;1975:1;1970:3;1966:11;1960:18;1956:1;1951:3;1947:11;1940:39;1912:2;1909:1;1905:10;1900:15;;1876:113;;;2007:6;2004:1;2001:13;1998:101;;;2087:1;2078:6;2073:3;2069:16;2062:27;1998:101;1847:258;1798:307;;;:::o;2111:102::-;2152:6;2203:2;2199:7;2194:2;2187:5;2183:14;2179:28;2169:38;;2111:102;;;:::o;2219:364::-;2307:3;2335:39;2368:5;2335:39;:::i;:::-;2390:71;2454:6;2449:3;2390:71;:::i;:::-;2383:78;;2470:52;2515:6;2510:3;2503:4;2496:5;2492:16;2470:52;:::i;:::-;2547:29;2569:6;2547:29;:::i;:::-;2542:3;2538:39;2531:46;;2311:272;2219:364;;;;:::o;2589:313::-;2702:4;2740:2;2729:9;2725:18;2717:26;;2789:9;2783:4;2779:20;2775:1;2764:9;2760:17;2753:47;2817:78;2890:4;2881:6;2817:78;:::i;:::-;2809:86;;2589:313;;;;:::o;2908:126::-;2945:7;2985:42;2978:5;2974:54;2963:65;;2908:126;;;:::o;3040:96::-;3077:7;3106:24;3124:5;3106:24;:::i;:::-;3095:35;;3040:96;;;:::o;3142:122::-;3215:24;3233:5;3215:24;:::i;:::-;3208:5;3205:35;3195:63;;3254:1;3251;3244:12;3195:63;3142:122;:::o;3270:139::-;3316:5;3354:6;3341:20;3332:29;;3370:33;3397:5;3370:33;:::i;:::-;3270:139;;;;:::o;3415:77::-;3452:7;3481:5;3470:16;;3415:77;;;:::o;3498:122::-;3571:24;3589:5;3571:24;:::i;:::-;3564:5;3561:35;3551:63;;3610:1;3607;3600:12;3551:63;3498:122;:::o;3626:139::-;3672:5;3710:6;3697:20;3688:29;;3726:33;3753:5;3726:33;:::i;:::-;3626:139;;;;:::o;3771:474::-;3839:6;3847;3896:2;3884:9;3875:7;3871:23;3867:32;3864:119;;;3902:79;;:::i;:::-;3864:119;4022:1;4047:53;4092:7;4083:6;4072:9;4068:22;4047:53;:::i;:::-;4037:63;;3993:117;4149:2;4175:53;4220:7;4211:6;4200:9;4196:22;4175:53;:::i;:::-;4165:63;;4120:118;3771:474;;;;;:::o;4251:117::-;4360:1;4357;4350:12;4374:117;4483:1;4480;4473:12;4497:180;4545:77;4542:1;4535:88;4642:4;4639:1;4632:15;4666:4;4663:1;4656:15;4683:281;4766:27;4788:4;4766:27;:::i;:::-;4758:6;4754:40;4896:6;4884:10;4881:22;4860:18;4848:10;4845:34;4842:62;4839:88;;;4907:18;;:::i;:::-;4839:88;4947:10;4943:2;4936:22;4726:238;4683:281;;:::o;4970:129::-;5004:6;5031:20;;:::i;:::-;5021:30;;5060:33;5088:4;5080:6;5060:33;:::i;:::-;4970:129;;;:::o;5105:307::-;5166:4;5256:18;5248:6;5245:30;5242:56;;;5278:18;;:::i;:::-;5242:56;5316:29;5338:6;5316:29;:::i;:::-;5308:37;;5400:4;5394;5390:15;5382:23;;5105:307;;;:::o;5418:154::-;5502:6;5497:3;5492;5479:30;5564:1;5555:6;5550:3;5546:16;5539:27;5418:154;;;:::o;5578:410::-;5655:5;5680:65;5696:48;5737:6;5696:48;:::i;:::-;5680:65;:::i;:::-;5671:74;;5768:6;5761:5;5754:21;5806:4;5799:5;5795:16;5844:3;5835:6;5830:3;5826:16;5823:25;5820:112;;;5851:79;;:::i;:::-;5820:112;5941:41;5975:6;5970:3;5965;5941:41;:::i;:::-;5661:327;5578:410;;;;;:::o;6007:338::-;6062:5;6111:3;6104:4;6096:6;6092:17;6088:27;6078:122;;6119:79;;:::i;:::-;6078:122;6236:6;6223:20;6261:78;6335:3;6327:6;6320:4;6312:6;6308:17;6261:78;:::i;:::-;6252:87;;6068:277;6007:338;;;;:::o;6351:77::-;6388:7;6417:5;6406:16;;6351:77;;;:::o;6434:122::-;6507:24;6525:5;6507:24;:::i;:::-;6500:5;6497:35;6487:63;;6546:1;6543;6536:12;6487:63;6434:122;:::o;6562:139::-;6608:5;6646:6;6633:20;6624:29;;6662:33;6689:5;6662:33;:::i;:::-;6562:139;;;;:::o;6707:86::-;6742:7;6782:4;6775:5;6771:16;6760:27;;6707:86;;;:::o;6799:118::-;6870:22;6886:5;6870:22;:::i;:::-;6863:5;6860:33;6850:61;;6907:1;6904;6897:12;6850:61;6799:118;:::o;6923:135::-;6967:5;7005:6;6992:20;6983:29;;7021:31;7046:5;7021:31;:::i;:::-;6923:135;;;;:::o;7064:1085::-;7166:6;7174;7182;7190;7198;7247:3;7235:9;7226:7;7222:23;7218:33;7215:120;;;7254:79;;:::i;:::-;7215:120;7374:1;7399:53;7444:7;7435:6;7424:9;7420:22;7399:53;:::i;:::-;7389:63;;7345:117;7529:2;7518:9;7514:18;7501:32;7560:18;7552:6;7549:30;7546:117;;;7582:79;;:::i;:::-;7546:117;7687:62;7741:7;7732:6;7721:9;7717:22;7687:62;:::i;:::-;7677:72;;7472:287;7798:2;7824:53;7869:7;7860:6;7849:9;7845:22;7824:53;:::i;:::-;7814:63;;7769:118;7926:2;7952:53;7997:7;7988:6;7977:9;7973:22;7952:53;:::i;:::-;7942:63;;7897:118;8054:3;8081:51;8124:7;8115:6;8104:9;8100:22;8081:51;:::i;:::-;8071:61;;8025:117;7064:1085;;;;;;;;:::o;8155:98::-;8206:6;8240:5;8234:12;8224:22;;8155:98;;;:::o;8259:168::-;8342:11;8376:6;8371:3;8364:19;8416:4;8411:3;8407:14;8392:29;;8259:168;;;;:::o;8433:360::-;8519:3;8547:38;8579:5;8547:38;:::i;:::-;8601:70;8664:6;8659:3;8601:70;:::i;:::-;8594:77;;8680:52;8725:6;8720:3;8713:4;8706:5;8702:16;8680:52;:::i;:::-;8757:29;8779:6;8757:29;:::i;:::-;8752:3;8748:39;8741:46;;8523:270;8433:360;;;;:::o;8799:309::-;8910:4;8948:2;8937:9;8933:18;8925:26;;8997:9;8991:4;8987:20;8983:1;8972:9;8968:17;8961:47;9025:76;9096:4;9087:6;9025:76;:::i;:::-;9017:84;;8799:309;;;;:::o;9114:118::-;9201:24;9219:5;9201:24;:::i;:::-;9196:3;9189:37;9114:118;;:::o;9238:222::-;9331:4;9369:2;9358:9;9354:18;9346:26;;9382:71;9450:1;9439:9;9435:17;9426:6;9382:71;:::i;:::-;9238:222;;;;:::o;9466:118::-;9553:24;9571:5;9553:24;:::i;:::-;9548:3;9541:37;9466:118;;:::o;9590:222::-;9683:4;9721:2;9710:9;9706:18;9698:26;;9734:71;9802:1;9791:9;9787:17;9778:6;9734:71;:::i;:::-;9590:222;;;;:::o;9818:619::-;9895:6;9903;9911;9960:2;9948:9;9939:7;9935:23;9931:32;9928:119;;;9966:79;;:::i;:::-;9928:119;10086:1;10111:53;10156:7;10147:6;10136:9;10132:22;10111:53;:::i;:::-;10101:63;;10057:117;10213:2;10239:53;10284:7;10275:6;10264:9;10260:22;10239:53;:::i;:::-;10229:63;;10184:118;10341:2;10367:53;10412:7;10403:6;10392:9;10388:22;10367:53;:::i;:::-;10357:63;;10312:118;9818:619;;;;;:::o;10443:329::-;10502:6;10551:2;10539:9;10530:7;10526:23;10522:32;10519:119;;;10557:79;;:::i;:::-;10519:119;10677:1;10702:53;10747:7;10738:6;10727:9;10723:22;10702:53;:::i;:::-;10692:63;;10648:117;10443:329;;;;:::o;10778:::-;10837:6;10886:2;10874:9;10865:7;10861:23;10857:32;10854:119;;;10892:79;;:::i;:::-;10854:119;11012:1;11037:53;11082:7;11073:6;11062:9;11058:22;11037:53;:::i;:::-;11027:63;;10983:117;10778:329;;;;:::o;11113:::-;11172:6;11221:2;11209:9;11200:7;11196:23;11192:32;11189:119;;;11227:79;;:::i;:::-;11189:119;11347:1;11372:53;11417:7;11408:6;11397:9;11393:22;11372:53;:::i;:::-;11362:63;;11318:117;11113:329;;;;:::o;11448:474::-;11516:6;11524;11573:2;11561:9;11552:7;11548:23;11544:32;11541:119;;;11579:79;;:::i;:::-;11541:119;11699:1;11724:53;11769:7;11760:6;11749:9;11745:22;11724:53;:::i;:::-;11714:63;;11670:117;11826:2;11852:53;11897:7;11888:6;11877:9;11873:22;11852:53;:::i;:::-;11842:63;;11797:118;11448:474;;;;;:::o;11928:112::-;12011:22;12027:5;12011:22;:::i;:::-;12006:3;11999:35;11928:112;;:::o;12046:214::-;12135:4;12173:2;12162:9;12158:18;12150:26;;12186:67;12250:1;12239:9;12235:17;12226:6;12186:67;:::i;:::-;12046:214;;;;:::o;12266:118::-;12353:24;12371:5;12353:24;:::i;:::-;12348:3;12341:37;12266:118;;:::o;12390:222::-;12483:4;12521:2;12510:9;12506:18;12498:26;;12534:71;12602:1;12591:9;12587:17;12578:6;12534:71;:::i;:::-;12390:222;;;;:::o;12618:117::-;12727:1;12724;12717:12;12741:117;12850:1;12847;12840:12;12877:552;12934:8;12944:6;12994:3;12987:4;12979:6;12975:17;12971:27;12961:122;;13002:79;;:::i;:::-;12961:122;13115:6;13102:20;13092:30;;13145:18;13137:6;13134:30;13131:117;;;13167:79;;:::i;:::-;13131:117;13281:4;13273:6;13269:17;13257:29;;13335:3;13327:4;13319:6;13315:17;13305:8;13301:32;13298:41;13295:128;;;13342:79;;:::i;:::-;13295:128;12877:552;;;;;:::o;13435:672::-;13514:6;13522;13530;13579:2;13567:9;13558:7;13554:23;13550:32;13547:119;;;13585:79;;:::i;:::-;13547:119;13705:1;13730:53;13775:7;13766:6;13755:9;13751:22;13730:53;:::i;:::-;13720:63;;13676:117;13860:2;13849:9;13845:18;13832:32;13891:18;13883:6;13880:30;13877:117;;;13913:79;;:::i;:::-;13877:117;14026:64;14082:7;14073:6;14062:9;14058:22;14026:64;:::i;:::-;14008:82;;;;13803:297;13435:672;;;;;:::o;14113:474::-;14181:6;14189;14238:2;14226:9;14217:7;14213:23;14209:32;14206:119;;;14244:79;;:::i;:::-;14206:119;14364:1;14389:53;14434:7;14425:6;14414:9;14410:22;14389:53;:::i;:::-;14379:63;;14335:117;14491:2;14517:53;14562:7;14553:6;14542:9;14538:22;14517:53;:::i;:::-;14507:63;;14462:118;14113:474;;;;;:::o;14593:180::-;14641:77;14638:1;14631:88;14738:4;14735:1;14728:15;14762:4;14759:1;14752:15;14779:320;14823:6;14860:1;14854:4;14850:12;14840:22;;14907:1;14901:4;14897:12;14928:18;14918:81;;14984:4;14976:6;14972:17;14962:27;;14918:81;15046:2;15038:6;15035:14;15015:18;15012:38;15009:84;;;15065:18;;:::i;:::-;15009:84;14830:269;14779:320;;;:::o;15105:220::-;15245:34;15241:1;15233:6;15229:14;15222:58;15314:3;15309:2;15301:6;15297:15;15290:28;15105:220;:::o;15331:366::-;15473:3;15494:67;15558:2;15553:3;15494:67;:::i;:::-;15487:74;;15570:93;15659:3;15570:93;:::i;:::-;15688:2;15683:3;15679:12;15672:19;;15331:366;;;:::o;15703:419::-;15869:4;15907:2;15896:9;15892:18;15884:26;;15956:9;15950:4;15946:20;15942:1;15931:9;15927:17;15920:47;15984:131;16110:4;15984:131;:::i;:::-;15976:139;;15703:419;;;:::o;16128:104::-;16173:7;16202:24;16220:5;16202:24;:::i;:::-;16191:35;;16128:104;;;:::o;16238:142::-;16341:32;16367:5;16341:32;:::i;:::-;16336:3;16329:45;16238:142;;:::o;16386:561::-;16569:4;16607:2;16596:9;16592:18;16584:26;;16620:71;16688:1;16677:9;16673:17;16664:6;16620:71;:::i;:::-;16701:88;16785:2;16774:9;16770:18;16761:6;16701:88;:::i;:::-;16836:9;16830:4;16826:20;16821:2;16810:9;16806:18;16799:48;16864:76;16935:4;16926:6;16864:76;:::i;:::-;16856:84;;16386:561;;;;;;:::o;16953:147::-;17054:11;17091:3;17076:18;;16953:147;;;;:::o;17106:373::-;17210:3;17238:38;17270:5;17238:38;:::i;:::-;17292:88;17373:6;17368:3;17292:88;:::i;:::-;17285:95;;17389:52;17434:6;17429:3;17422:4;17415:5;17411:16;17389:52;:::i;:::-;17466:6;17461:3;17457:16;17450:23;;17214:265;17106:373;;;;:::o;17485:94::-;17518:8;17566:5;17562:2;17558:14;17537:35;;17485:94;;;:::o;17585:::-;17624:7;17653:20;17667:5;17653:20;:::i;:::-;17642:31;;17585:94;;;:::o;17685:100::-;17724:7;17753:26;17773:5;17753:26;:::i;:::-;17742:37;;17685:100;;;:::o;17791:157::-;17896:45;17916:24;17934:5;17916:24;:::i;:::-;17896:45;:::i;:::-;17891:3;17884:58;17791:157;;:::o;17954:412::-;18112:3;18134:93;18223:3;18214:6;18134:93;:::i;:::-;18127:100;;18237:75;18308:3;18299:6;18237:75;:::i;:::-;18337:2;18332:3;18328:12;18321:19;;18357:3;18350:10;;17954:412;;;;;:::o;18372:271::-;18502:3;18524:93;18613:3;18604:6;18524:93;:::i;:::-;18517:100;;18634:3;18627:10;;18372:271;;;;:::o;18649:178::-;18789:30;18785:1;18777:6;18773:14;18766:54;18649:178;:::o;18833:366::-;18975:3;18996:67;19060:2;19055:3;18996:67;:::i;:::-;18989:74;;19072:93;19161:3;19072:93;:::i;:::-;19190:2;19185:3;19181:12;19174:19;;18833:366;;;:::o;19205:419::-;19371:4;19409:2;19398:9;19394:18;19386:26;;19458:9;19452:4;19448:20;19444:1;19433:9;19429:17;19422:47;19486:131;19612:4;19486:131;:::i;:::-;19478:139;;19205:419;;;:::o;19630:234::-;19770:34;19766:1;19758:6;19754:14;19747:58;19839:17;19834:2;19826:6;19822:15;19815:42;19630:234;:::o;19870:366::-;20012:3;20033:67;20097:2;20092:3;20033:67;:::i;:::-;20026:74;;20109:93;20198:3;20109:93;:::i;:::-;20227:2;20222:3;20218:12;20211:19;;19870:366;;;:::o;20242:419::-;20408:4;20446:2;20435:9;20431:18;20423:26;;20495:9;20489:4;20485:20;20481:1;20470:9;20466:17;20459:47;20523:131;20649:4;20523:131;:::i;:::-;20515:139;;20242:419;;;:::o;20667:141::-;20716:4;20739:3;20731:11;;20762:3;20759:1;20752:14;20796:4;20793:1;20783:18;20775:26;;20667:141;;;:::o;20838:802::-;20923:3;20960:5;20954:12;20989:36;21015:9;20989:36;:::i;:::-;21041:71;21105:6;21100:3;21041:71;:::i;:::-;21034:78;;21143:1;21132:9;21128:17;21159:1;21154:135;;;;21303:1;21298:336;;;;21121:513;;21154:135;21238:4;21234:9;21223;21219:25;21214:3;21207:38;21274:4;21269:3;21265:14;21258:21;;21154:135;;21298:336;21365:38;21397:5;21365:38;:::i;:::-;21425:1;21439:154;21453:6;21450:1;21447:13;21439:154;;;21527:7;21521:14;21517:1;21512:3;21508:11;21501:35;21577:1;21568:7;21564:15;21553:26;;21475:4;21472:1;21468:12;21463:17;;21439:154;;;21622:1;21617:3;21613:11;21606:18;;21305:329;;21121:513;;20927:713;;20838:802;;;;:::o;21646:307::-;21756:4;21794:2;21783:9;21779:18;21771:26;;21843:9;21837:4;21833:20;21829:1;21818:9;21814:17;21807:47;21871:75;21941:4;21932:6;21871:75;:::i;:::-;21863:83;;21646:307;;;;:::o;21959:223::-;22099:34;22095:1;22087:6;22083:14;22076:58;22168:6;22163:2;22155:6;22151:15;22144:31;21959:223;:::o;22188:366::-;22330:3;22351:67;22415:2;22410:3;22351:67;:::i;:::-;22344:74;;22427:93;22516:3;22427:93;:::i;:::-;22545:2;22540:3;22536:12;22529:19;;22188:366;;;:::o;22560:419::-;22726:4;22764:2;22753:9;22749:18;22741:26;;22813:9;22807:4;22803:20;22799:1;22788:9;22784:17;22777:47;22841:131;22967:4;22841:131;:::i;:::-;22833:139;;22560:419;;;:::o;22985:221::-;23125:34;23121:1;23113:6;23109:14;23102:58;23194:4;23189:2;23181:6;23177:15;23170:29;22985:221;:::o;23212:366::-;23354:3;23375:67;23439:2;23434:3;23375:67;:::i;:::-;23368:74;;23451:93;23540:3;23451:93;:::i;:::-;23569:2;23564:3;23560:12;23553:19;;23212:366;;;:::o;23584:419::-;23750:4;23788:2;23777:9;23773:18;23765:26;;23837:9;23831:4;23827:20;23823:1;23812:9;23808:17;23801:47;23865:131;23991:4;23865:131;:::i;:::-;23857:139;;23584:419;;;:::o;24009:224::-;24149:34;24145:1;24137:6;24133:14;24126:58;24218:7;24213:2;24205:6;24201:15;24194:32;24009:224;:::o;24239:366::-;24381:3;24402:67;24466:2;24461:3;24402:67;:::i;:::-;24395:74;;24478:93;24567:3;24478:93;:::i;:::-;24596:2;24591:3;24587:12;24580:19;;24239:366;;;:::o;24611:419::-;24777:4;24815:2;24804:9;24800:18;24792:26;;24864:9;24858:4;24854:20;24850:1;24839:9;24835:17;24828:47;24892:131;25018:4;24892:131;:::i;:::-;24884:139;;24611:419;;;:::o;25036:545::-;25209:4;25247:3;25236:9;25232:19;25224:27;;25261:71;25329:1;25318:9;25314:17;25305:6;25261:71;:::i;:::-;25342:68;25406:2;25395:9;25391:18;25382:6;25342:68;:::i;:::-;25420:72;25488:2;25477:9;25473:18;25464:6;25420:72;:::i;:::-;25502;25570:2;25559:9;25555:18;25546:6;25502:72;:::i;:::-;25036:545;;;;;;;:::o;25587:180::-;25635:77;25632:1;25625:88;25732:4;25729:1;25722:15;25756:4;25753:1;25746:15;25773:305;25813:3;25832:20;25850:1;25832:20;:::i;:::-;25827:25;;25866:20;25884:1;25866:20;:::i;:::-;25861:25;;26020:1;25952:66;25948:74;25945:1;25942:81;25939:107;;;26026:18;;:::i;:::-;25939:107;26070:1;26067;26063:9;26056:16;;25773:305;;;;:::o;26084:177::-;26224:29;26220:1;26212:6;26208:14;26201:53;26084:177;:::o;26267:366::-;26409:3;26430:67;26494:2;26489:3;26430:67;:::i;:::-;26423:74;;26506:93;26595:3;26506:93;:::i;:::-;26624:2;26619:3;26615:12;26608:19;;26267:366;;;:::o;26639:419::-;26805:4;26843:2;26832:9;26828:18;26820:26;;26892:9;26886:4;26882:20;26878:1;26867:9;26863:17;26856:47;26920:131;27046:4;26920:131;:::i;:::-;26912:139;;26639:419;;;:::o;27064:224::-;27204:34;27200:1;27192:6;27188:14;27181:58;27273:7;27268:2;27260:6;27256:15;27249:32;27064:224;:::o;27294:366::-;27436:3;27457:67;27521:2;27516:3;27457:67;:::i;:::-;27450:74;;27533:93;27622:3;27533:93;:::i;:::-;27651:2;27646:3;27642:12;27635:19;;27294:366;;;:::o;27666:419::-;27832:4;27870:2;27859:9;27855:18;27847:26;;27919:9;27913:4;27909:20;27905:1;27894:9;27890:17;27883:47;27947:131;28073:4;27947:131;:::i;:::-;27939:139;;27666:419;;;:::o;28091:222::-;28231:34;28227:1;28219:6;28215:14;28208:58;28300:5;28295:2;28287:6;28283:15;28276:30;28091:222;:::o;28319:366::-;28461:3;28482:67;28546:2;28541:3;28482:67;:::i;:::-;28475:74;;28558:93;28647:3;28558:93;:::i;:::-;28676:2;28671:3;28667:12;28660:19;;28319:366;;;:::o;28691:419::-;28857:4;28895:2;28884:9;28880:18;28872:26;;28944:9;28938:4;28934:20;28930:1;28919:9;28915:17;28908:47;28972:131;29098:4;28972:131;:::i;:::-;28964:139;;28691:419;;;:::o;29116:191::-;29156:4;29176:20;29194:1;29176:20;:::i;:::-;29171:25;;29210:20;29228:1;29210:20;:::i;:::-;29205:25;;29249:1;29246;29243:8;29240:34;;;29254:18;;:::i;:::-;29240:34;29299:1;29296;29292:9;29284:17;;29116:191;;;;:::o;29313:220::-;29453:34;29449:1;29441:6;29437:14;29430:58;29522:3;29517:2;29509:6;29505:15;29498:28;29313:220;:::o;29539:366::-;29681:3;29702:67;29766:2;29761:3;29702:67;:::i;:::-;29695:74;;29778:93;29867:3;29778:93;:::i;:::-;29896:2;29891:3;29887:12;29880:19;;29539:366;;;:::o;29911:419::-;30077:4;30115:2;30104:9;30100:18;30092:26;;30164:9;30158:4;30154:20;30150:1;30139:9;30135:17;30128:47;30192:131;30318:4;30192:131;:::i;:::-;30184:139;;29911:419;;;:::o;30336:148::-;30438:11;30475:3;30460:18;;30336:148;;;;:::o;30490:173::-;30630:25;30626:1;30618:6;30614:14;30607:49;30490:173;:::o;30669:402::-;30829:3;30850:85;30932:2;30927:3;30850:85;:::i;:::-;30843:92;;30944:93;31033:3;30944:93;:::i;:::-;31062:2;31057:3;31053:12;31046:19;;30669:402;;;:::o;31077:377::-;31183:3;31211:39;31244:5;31211:39;:::i;:::-;31266:89;31348:6;31343:3;31266:89;:::i;:::-;31259:96;;31364:52;31409:6;31404:3;31397:4;31390:5;31386:16;31364:52;:::i;:::-;31441:6;31436:3;31432:16;31425:23;;31187:267;31077:377;;;;:::o;31460:167::-;31600:19;31596:1;31588:6;31584:14;31577:43;31460:167;:::o;31633:402::-;31793:3;31814:85;31896:2;31891:3;31814:85;:::i;:::-;31807:92;;31908:93;31997:3;31908:93;:::i;:::-;32026:2;32021:3;32017:12;32010:19;;31633:402;;;:::o;32041:967::-;32423:3;32445:148;32589:3;32445:148;:::i;:::-;32438:155;;32610:95;32701:3;32692:6;32610:95;:::i;:::-;32603:102;;32722:148;32866:3;32722:148;:::i;:::-;32715:155;;32887:95;32978:3;32969:6;32887:95;:::i;:::-;32880:102;;32999:3;32992:10;;32041:967;;;;;:::o;33014:181::-;33154:33;33150:1;33142:6;33138:14;33131:57;33014:181;:::o;33201:366::-;33343:3;33364:67;33428:2;33423:3;33364:67;:::i;:::-;33357:74;;33440:93;33529:3;33440:93;:::i;:::-;33558:2;33553:3;33549:12;33542:19;;33201:366;;;:::o;33573:419::-;33739:4;33777:2;33766:9;33762:18;33754:26;;33826:9;33820:4;33816:20;33812:1;33801:9;33797:17;33790:47;33854:131;33980:4;33854:131;:::i;:::-;33846:139;;33573:419;;;:::o;33998:553::-;34175:4;34213:3;34202:9;34198:19;34190:27;;34227:71;34295:1;34284:9;34280:17;34271:6;34227:71;:::i;:::-;34308:72;34376:2;34365:9;34361:18;34352:6;34308:72;:::i;:::-;34390;34458:2;34447:9;34443:18;34434:6;34390:72;:::i;:::-;34472;34540:2;34529:9;34525:18;34516:6;34472:72;:::i;:::-;33998:553;;;;;;;:::o;34557:214::-;34697:66;34693:1;34685:6;34681:14;34674:90;34557:214;:::o;34777:400::-;34937:3;34958:84;35040:1;35035:3;34958:84;:::i;:::-;34951:91;;35051:93;35140:3;35051:93;:::i;:::-;35169:1;35164:3;35160:11;35153:18;;34777:400;;;:::o;35183:79::-;35222:7;35251:5;35240:16;;35183:79;;;:::o;35268:157::-;35373:45;35393:24;35411:5;35393:24;:::i;:::-;35373:45;:::i;:::-;35368:3;35361:58;35268:157;;:::o;35431:663::-;35672:3;35694:148;35838:3;35694:148;:::i;:::-;35687:155;;35852:75;35923:3;35914:6;35852:75;:::i;:::-;35952:2;35947:3;35943:12;35936:19;;35965:75;36036:3;36027:6;35965:75;:::i;:::-;36065:2;36060:3;36056:12;36049:19;;36085:3;36078:10;;35431:663;;;;;:::o;36100:348::-;36140:7;36163:20;36181:1;36163:20;:::i;:::-;36158:25;;36197:20;36215:1;36197:20;:::i;:::-;36192:25;;36385:1;36317:66;36313:74;36310:1;36307:81;36302:1;36295:9;36288:17;36284:105;36281:131;;;36392:18;;:::i;:::-;36281:131;36440:1;36437;36433:9;36422:20;;36100:348;;;;:::o;36454:180::-;36502:77;36499:1;36492:88;36599:4;36596:1;36589:15;36623:4;36620:1;36613:15;36640:171;36679:3;36702:24;36720:5;36702:24;:::i;:::-;36693:33;;36748:4;36741:5;36738:15;36735:41;;;36756:18;;:::i;:::-;36735:41;36803:1;36796:5;36792:13;36785:20;;36640:171;;;:::o;36817:182::-;36957:34;36953:1;36945:6;36941:14;36934:58;36817:182;:::o;37005:366::-;37147:3;37168:67;37232:2;37227:3;37168:67;:::i;:::-;37161:74;;37244:93;37333:3;37244:93;:::i;:::-;37362:2;37357:3;37353:12;37346:19;;37005:366;;;:::o;37377:419::-;37543:4;37581:2;37570:9;37566:18;37558:26;;37630:9;37624:4;37620:20;37616:1;37605:9;37601:17;37594:47;37658:131;37784:4;37658:131;:::i;:::-;37650:139;;37377:419;;;:::o

ipfs://0b2f4a667b9ba30f3bbe7a45172eec4d9a10d44aeb5232767935a3fc970eea0d