Contract 0xd105b6B42206dfA6Db00E6a4823bC88eFAC00476

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.1;
pragma experimental ABIEncoderV2;

import "./ICMCCore.sol";
import "./ICMCAsset.sol";
import "./ICMCDeposit.sol";
import "./ICMCWithdraw.sol";
import "./ICMCAdjudicator.sol";

interface IVectorChannel is
    ICMCCore,
    ICMCAsset,
    ICMCDeposit,
    ICMCWithdraw,
    ICMCAdjudicator
{}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.1;
pragma experimental ABIEncoderV2;

import "./LibERC20.sol";
import "./LibUtils.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";


/// @title LibAsset
/// @author Connext <[email protected]>
/// @notice This library contains helpers for dealing with onchain transfers
///         of in-channel assets. It is designed to safely handle all asset
///         transfers out of channel in the event of an onchain dispute. Also
///         safely handles ERC20 transfers that may be non-compliant
library LibAsset {
    address constant ETHER_ASSETID = address(0);

    function isEther(address assetId) internal pure returns (bool) {
        return assetId == ETHER_ASSETID;
    }

    function getOwnBalance(address assetId) internal view returns (uint256) {
        return
            isEther(assetId)
                ? address(this).balance
                : IERC20(assetId).balanceOf(address(this));
    }

    function transferEther(address payable recipient, uint256 amount)
        internal
        returns (bool)
    {
        (bool success, bytes memory returnData) =
            recipient.call{value: amount}("");
        LibUtils.revertIfCallFailed(success, returnData);
        return true;
    }

    function transferERC20(
        address assetId,
        address recipient,
        uint256 amount
    ) internal returns (bool) {
        return LibERC20.transfer(assetId, recipient, amount);
    }

    // This function is a wrapper for transfers of Ether or ERC20 tokens,
    // both standard-compliant ones as well as tokens that exhibit the
    // missing-return-value bug.
    // Although it behaves very much like Solidity's `transfer` function
    // or the ERC20 `transfer` and is, in fact, designed to replace direct
    // usage of those, it is deliberately named `unregisteredTransfer`,
    // because we need to register every transfer out of the channel.
    // Therefore, it should normally not be used directly, with the single
    // exception of the `transferAsset` function in `CMCAsset.sol`,
    // which combines the "naked" unregistered transfer given below
    // with a registration.
    // USING THIS FUNCTION SOMEWHERE ELSE IS PROBABLY WRONG!
    function unregisteredTransfer(
        address assetId,
        address payable recipient,
        uint256 amount
    ) internal returns (bool) {
        return
            isEther(assetId)
                ? transferEther(recipient, amount)
                : transferERC20(assetId, recipient, amount);
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.1;
pragma experimental ABIEncoderV2;

import "./LibUtils.sol";
import "@openzeppelin/contracts/utils/Address.sol";

/// @title LibERC20
/// @author Connext <[email protected]>
/// @notice This library provides several functions to safely handle
///         noncompliant tokens (i.e. does not return a boolean from
///         the transfer function)

library LibERC20 {
    function wrapCall(address assetId, bytes memory callData)
        internal
        returns (bool)
    {
        require(Address.isContract(assetId), "LibERC20: NO_CODE");
        (bool success, bytes memory returnData) = assetId.call(callData);
        LibUtils.revertIfCallFailed(success, returnData);
        return returnData.length == 0 || abi.decode(returnData, (bool));
    }

    function approve(
        address assetId,
        address spender,
        uint256 amount
    ) internal returns (bool) {
        return
            wrapCall(
                assetId,
                abi.encodeWithSignature(
                    "approve(address,uint256)",
                    spender,
                    amount
                )
            );
    }

    function transferFrom(
        address assetId,
        address sender,
        address recipient,
        uint256 amount
    ) internal returns (bool) {
        return
            wrapCall(
                assetId,
                abi.encodeWithSignature(
                    "transferFrom(address,address,uint256)",
                    sender,
                    recipient,
                    amount
                )
            );
    }

    function transfer(
        address assetId,
        address recipient,
        uint256 amount
    ) internal returns (bool) {
        return
            wrapCall(
                assetId,
                abi.encodeWithSignature(
                    "transfer(address,uint256)",
                    recipient,
                    amount
                )
            );
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.1;
pragma experimental ABIEncoderV2;

interface ICMCCore {
    function setup(address _alice, address _bob) external;

    function getAlice() external view returns (address);

    function getBob() external view returns (address);
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.1;
pragma experimental ABIEncoderV2;

interface ICMCAsset {
    function getTotalTransferred(address assetId)
        external
        view
        returns (uint256);

    function getExitableAmount(address assetId, address owner)
        external
        view
        returns (uint256);

    function exit(
        address assetId,
        address owner,
        address payable recipient
    ) external;
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.1;
pragma experimental ABIEncoderV2;

interface ICMCDeposit {
    event AliceDeposited(address assetId, uint256 amount);
    
    function getTotalDepositsAlice(address assetId)
        external
        view
        returns (uint256);

    function getTotalDepositsBob(address assetId)
        external
        view
        returns (uint256);

    function depositAlice(address assetId, uint256 amount) external payable;
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.1;
pragma experimental ABIEncoderV2;

struct WithdrawData {
    address channelAddress;
    address assetId;
    address payable recipient;
    uint256 amount;
    uint256 nonce;
    address callTo;
    bytes callData;
}

interface ICMCWithdraw {
    function getWithdrawalTransactionRecord(WithdrawData calldata wd)
        external
        view
        returns (bool);

    function withdraw(
        WithdrawData calldata wd,
        bytes calldata aliceSignature,
        bytes calldata bobSignature
    ) external;
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.1;
pragma experimental ABIEncoderV2;

import "./Types.sol";

interface ICMCAdjudicator {
    struct CoreChannelState {
        address channelAddress;
        address alice;
        address bob;
        address[] assetIds;
        Balance[] balances;
        uint256[] processedDepositsA;
        uint256[] processedDepositsB;
        uint256[] defundNonces;
        uint256 timeout;
        uint256 nonce;
        bytes32 merkleRoot;
    }

    struct CoreTransferState {
        address channelAddress;
        bytes32 transferId;
        address transferDefinition;
        address initiator;
        address responder;
        address assetId;
        Balance balance;
        uint256 transferTimeout;
        bytes32 initialStateHash;
    }

    struct ChannelDispute {
        bytes32 channelStateHash;
        uint256 nonce;
        bytes32 merkleRoot;
        uint256 consensusExpiry;
        uint256 defundExpiry;
    }

    struct TransferDispute {
        bytes32 transferStateHash;
        uint256 transferDisputeExpiry;
        bool isDefunded;
    }

    event ChannelDisputed(
        address disputer,
        CoreChannelState state,
        ChannelDispute dispute
    );

    event ChannelDefunded(
        address defunder,
        CoreChannelState state,
        ChannelDispute dispute,
        address[] assetIds
    );

    event TransferDisputed(
        address disputer,
        CoreTransferState state,
        TransferDispute dispute
    );

    event TransferDefunded(
        address defunder,
        CoreTransferState state,
        TransferDispute dispute,
        bytes encodedInitialState,
        bytes encodedResolver,
        Balance balance
    );

    function getChannelDispute() external view returns (ChannelDispute memory);

    function getDefundNonce(address assetId) external view returns (uint256);

    function getTransferDispute(bytes32 transferId)
        external
        view
        returns (TransferDispute memory);

    function disputeChannel(
        CoreChannelState calldata ccs,
        bytes calldata aliceSignature,
        bytes calldata bobSignature
    ) external;

    function defundChannel(
        CoreChannelState calldata ccs,
        address[] calldata assetIds,
        uint256[] calldata indices
    ) external;

    function disputeTransfer(
        CoreTransferState calldata cts,
        bytes32[] calldata merkleProofData
    ) external;

    function defundTransfer(
        CoreTransferState calldata cts,
        bytes calldata encodedInitialTransferState,
        bytes calldata encodedTransferResolver,
        bytes calldata responderSignature
    ) external;
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.1;
pragma experimental ABIEncoderV2;

struct Balance {
    uint256[2] amount; // [alice, bob] in channel, [initiator, responder] in transfer
    address payable[2] to; // [alice, bob] in channel, [initiator, responder] in transfer
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.1;
pragma experimental ABIEncoderV2;

/// @title LibUtils
/// @author Connext <[email protected]>
/// @notice Contains a helper to revert if a call was not successfully
///         made
library LibUtils {
    // If success is false, reverts and passes on the revert string.
    function revertIfCallFailed(bool success, bytes memory returnData)
        internal
        pure
    {
        if (!success) {
            assembly {
                revert(add(returnData, 0x20), mload(returnData))
            }
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.0;

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.0;

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.0;

import "../../GSN/Context.sol";
import "./IERC20.sol";
import "../../math/SafeMath.sol";
import "../../utils/Address.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 _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 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 { }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.0;

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.0;

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

        return c;
    }

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

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

        return c;
    }

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

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

        return c;
    }

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

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

        return c;
    }

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

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

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.1;
pragma experimental ABIEncoderV2;

import "./interfaces/ICMCDeposit.sol";
import "./CMCCore.sol";
import "./CMCAsset.sol";
import "./lib/LibAsset.sol";
import "./lib/LibERC20.sol";

/// @title CMCDeposit
/// @author Connext <[email protected]>
/// @notice Contains logic supporting channel multisig deposits. Channel
///         funding is asymmetric, with `alice` having to call a deposit
///         function which tracks the total amount she has deposited so far,
///         and any other funds in the multisig being attributed to `bob`.

contract CMCDeposit is CMCCore, CMCAsset, ICMCDeposit {
    mapping(address => uint256) private depositsAlice;

    receive() external payable onlyViaProxy nonReentrant {}

    function getTotalDepositsAlice(address assetId)
        external
        view
        override
        onlyViaProxy
        nonReentrantView
        returns (uint256)
    {
        return _getTotalDepositsAlice(assetId);
    }

    function _getTotalDepositsAlice(address assetId)
        internal
        view
        returns (uint256)
    {
        return depositsAlice[assetId];
    }

    function getTotalDepositsBob(address assetId)
        external
        view
        override
        onlyViaProxy
        nonReentrantView
        returns (uint256)
    {
        return _getTotalDepositsBob(assetId);
    }

    // Calculated using invariant onchain properties. Note we DONT use safemath here
    function _getTotalDepositsBob(address assetId)
        internal
        view
        returns (uint256)
    {
        return
            LibAsset.getOwnBalance(assetId) +
            totalTransferred[assetId] -
            depositsAlice[assetId];
    }

    function depositAlice(address assetId, uint256 amount)
        external
        payable
        override
        onlyViaProxy
        nonReentrant
    {
        if (LibAsset.isEther(assetId)) {
            require(msg.value == amount, "CMCDeposit: VALUE_MISMATCH");
        } else {
            // If ETH is sent along, it will be attributed to bob
            require(msg.value == 0, "CMCDeposit: ETH_WITH_ERC_TRANSFER");
            require(
                LibERC20.transferFrom(
                    assetId,
                    msg.sender,
                    address(this),
                    amount
                ),
                "CMCDeposit: ERC20_TRANSFER_FAILED"
            );
        }
        // NOTE: explicitly do NOT use safemath here
        depositsAlice[assetId] += amount;
        emit AliceDeposited(assetId, amount);
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.1;
pragma experimental ABIEncoderV2;

import "./interfaces/ICMCCore.sol";
import "./ReentrancyGuard.sol";

/// @title CMCCore
/// @author Connext <[email protected]>
/// @notice Contains logic pertaining to the participants of a channel,
///         including setting and retrieving the participants and the
///         mastercopy.

contract CMCCore is ReentrancyGuard, ICMCCore {
    address private immutable mastercopyAddress;

    address internal alice;
    address internal bob;

    /// @notice Set invalid participants to block the mastercopy from being used directly
    ///         Nonzero address also prevents the mastercopy from being setup
    ///         Only setting alice is sufficient, setting bob too wouldn't change anything
    constructor() {
        mastercopyAddress = address(this);
    }

    // Prevents us from calling methods directly from the mastercopy contract
    modifier onlyViaProxy {
        require(
            address(this) != mastercopyAddress,
            "Mastercopy: ONLY_VIA_PROXY"
        );
        _;
    }

    /// @notice Contract constructor for Proxied copies
    /// @param _alice: Address representing user with function deposit
    /// @param _bob: Address representing user with multisig deposit
    function setup(address _alice, address _bob)
        external
        override
        onlyViaProxy
    {
        require(alice == address(0), "CMCCore: ALREADY_SETUP");
        require(
            _alice != address(0) && _bob != address(0),
            "CMCCore: INVALID_PARTICIPANT"
        );
        require(_alice != _bob, "CMCCore: IDENTICAL_PARTICIPANTS");
        ReentrancyGuard.setup();
        alice = _alice;
        bob = _bob;
    }

    /// @notice A getter function for the bob of the multisig
    /// @return Bob's signer address
    function getAlice()
        external
        view
        override
        onlyViaProxy
        nonReentrantView
        returns (address)
    {
        return alice;
    }

    /// @notice A getter function for the bob of the multisig
    /// @return Alice's signer address
    function getBob()
        external
        view
        override
        onlyViaProxy
        nonReentrantView
        returns (address)
    {
        return bob;
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.1;
pragma experimental ABIEncoderV2;

import "./interfaces/ICMCAsset.sol";
import "./interfaces/Types.sol";
import "./CMCCore.sol";
import "./lib/LibAsset.sol";
import "./lib/LibMath.sol";
import "@openzeppelin/contracts/math/Math.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

/// @title CMCAsset
/// @author Connext <[email protected]>
/// @notice Contains logic to safely transfer channel assets (even if they are
///         noncompliant). During adjudication, balances from defunding the
///         channel or defunding transfers are registered as withdrawable. Once
///         they are registered, the owner (or a watchtower on behalf of the
///         owner), may call `exit` to reclaim funds from the multisig.

contract CMCAsset is CMCCore, ICMCAsset {
    using SafeMath for uint256;
    using LibMath for uint256;

    mapping(address => uint256) internal totalTransferred;
    mapping(address => mapping(address => uint256))
        private exitableAmount;

    function registerTransfer(address assetId, uint256 amount) internal {
        totalTransferred[assetId] += amount;
    }

    function getTotalTransferred(address assetId)
        external
        view
        override
        onlyViaProxy
        nonReentrantView
        returns (uint256)
    {
        return totalTransferred[assetId];
    }

    function makeExitable(
        address assetId,
        address recipient,
        uint256 amount
    ) internal {
        exitableAmount[assetId][
            recipient
        ] = exitableAmount[assetId][recipient].satAdd(amount);
    }

    function makeBalanceExitable(
        address assetId,
        Balance memory balance
    ) internal {
        for (uint256 i = 0; i < 2; i++) {
            uint256 amount = balance.amount[i];
            if (amount > 0) {
                makeExitable(assetId, balance.to[i], amount);
            }
        }
    }

    function getExitableAmount(address assetId, address owner)
        external
        view
        override
        onlyViaProxy
        nonReentrantView
        returns (uint256)
    {
        return exitableAmount[assetId][owner];
    }

    function getAvailableAmount(address assetId, uint256 maxAmount)
        internal
        view
        returns (uint256)
    {
        // Taking the min protects against the case where the multisig
        // holds less than the amount that is trying to be withdrawn
        // while still allowing the total of the funds to be removed
        // without the transaction reverting.
        return Math.min(maxAmount, LibAsset.getOwnBalance(assetId));
    }

    function transferAsset(
        address assetId,
        address payable recipient,
        uint256 amount
    ) internal {
        registerTransfer(assetId, amount);
        require(
            LibAsset.unregisteredTransfer(assetId, recipient, amount),
            "CMCAsset: TRANSFER_FAILED"
        );
    }

    function exit(
        address assetId,
        address owner,
        address payable recipient
    ) external override onlyViaProxy nonReentrant {
        // Either the owner must be the recipient, or in control
        // of setting the recipient of the funds to whomever they
        // choose
        require(
            msg.sender == owner || owner == recipient,
            "CMCAsset: OWNER_MISMATCH"
        );

        uint256 amount =
            getAvailableAmount(
                assetId,
                exitableAmount[assetId][owner]
            );

        // Revert if amount is 0
        require(amount > 0, "CMCAsset: NO_OP");

        // Reduce the amount claimable from the multisig by the owner
        exitableAmount[assetId][
            owner
        ] = exitableAmount[assetId][owner].sub(amount);

        // Perform transfer
        transferAsset(assetId, recipient, amount);
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.1;
pragma experimental ABIEncoderV2;

/// @title CMCWithdraw
/// @author Connext <[email protected]>
/// @notice A "mutex" reentrancy guard, heavily influenced by OpenZeppelin.

contract ReentrancyGuard {
    uint256 private constant OPEN = 1;
    uint256 private constant LOCKED = 2;

    uint256 public lock;

    function setup() internal {
        lock = OPEN;
    }

    modifier nonReentrant() {
        require(lock == OPEN, "ReentrancyGuard: REENTRANT_CALL");
        lock = LOCKED;
        _;
        lock = OPEN;
    }

    modifier nonReentrantView() {
        require(lock == OPEN, "ReentrancyGuard: REENTRANT_CALL");
        _;
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.1;
pragma experimental ABIEncoderV2;

/// @title LibMath
/// @author Connext <[email protected]>
/// @notice This library allows functions that would otherwise overflow and
///         revert if SafeMath was used to instead return the UINT_MAX. In the
///         adjudicator, this is used to ensure you can get the majority of
///         funds out in the event your balance > UINT_MAX and there is an
///         onchain dispute.
library LibMath {
    /// @dev Returns the maximum uint256 for an addition that would overflow
    ///      (saturation arithmetic)
    function satAdd(uint256 x, uint256 y) internal pure returns (uint256) {
        uint256 sum = x + y;
        return sum >= x ? sum : type(uint256).max;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow, so we distribute
        return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.1;
pragma experimental ABIEncoderV2;

import "./interfaces/Commitment.sol";
import "./interfaces/ICMCAdjudicator.sol";
import "./interfaces/ITransferDefinition.sol";
import "./interfaces/Types.sol";
import "./CMCCore.sol";
import "./CMCAsset.sol";
import "./CMCDeposit.sol";
import "./lib/LibChannelCrypto.sol";
import "./lib/LibMath.sol";
import "@openzeppelin/contracts/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";

/// @title CMCAdjudicator
/// @author Connext <[email protected]>
/// @notice Contains logic for disputing a single channel and all active
///         transfers associated with the channel. Contains two major phases:
///         (1) consensus: settle on latest channel state
///         (2) defund: remove assets and dispute active transfers
contract CMCAdjudicator is CMCCore, CMCAsset, CMCDeposit, ICMCAdjudicator {
    using LibChannelCrypto for bytes32;
    using LibMath for uint256;
    using SafeMath for uint256;

    uint256 private constant INITIAL_DEFUND_NONCE = 1;

    ChannelDispute private channelDispute;
    mapping(address => uint256) private defundNonces;
    mapping(bytes32 => TransferDispute) private transferDisputes;

    modifier validateChannel(CoreChannelState calldata ccs) {
        require(
            ccs.channelAddress == address(this) &&
                ccs.alice == alice &&
                ccs.bob == bob,
            "CMCAdjudicator: INVALID_CHANNEL"
        );
        _;
    }

    modifier validateTransfer(CoreTransferState calldata cts) {
        require(
            cts.channelAddress == address(this),
            "CMCAdjudicator: INVALID_TRANSFER"
        );
        _;
    }

    function getChannelDispute()
        external
        view
        override
        onlyViaProxy
        nonReentrantView
        returns (ChannelDispute memory)
    {
        return channelDispute;
    }

    function getDefundNonce(address assetId)
        external
        view
        override
        onlyViaProxy
        nonReentrantView
        returns (uint256)
    {
        return defundNonces[assetId];
    }

    function getTransferDispute(bytes32 transferId)
        external
        view
        override
        onlyViaProxy
        nonReentrantView
        returns (TransferDispute memory)
    {
        return transferDisputes[transferId];
    }

    function disputeChannel(
        CoreChannelState calldata ccs,
        bytes calldata aliceSignature,
        bytes calldata bobSignature
    ) external override onlyViaProxy nonReentrant validateChannel(ccs) {
        // Generate hash
        bytes32 ccsHash = hashChannelState(ccs);

        // Verify Alice's and Bob's signature on the channel state
        verifySignaturesOnChannelStateHash(ccs, ccsHash, aliceSignature, bobSignature);

        // We cannot dispute a channel in its defund phase
        require(!inDefundPhase(), "CMCAdjudicator: INVALID_PHASE");

        // New nonce must be strictly greater than the stored one
        require(
            channelDispute.nonce < ccs.nonce,
            "CMCAdjudicator: INVALID_NONCE"
        );

        if (!inConsensusPhase()) {
            // We are not already in a dispute
            // Set expiries
            // TODO: offchain-ensure that there can't be an overflow
            channelDispute.consensusExpiry = block.timestamp.add(ccs.timeout);
            channelDispute.defundExpiry = block.timestamp.add(
                ccs.timeout.mul(2)
            );
        }

        // Store newer state
        channelDispute.channelStateHash = ccsHash;
        channelDispute.nonce = ccs.nonce;
        channelDispute.merkleRoot = ccs.merkleRoot;

        // Emit event
        emit ChannelDisputed(msg.sender, ccs, channelDispute);
    }

    function defundChannel(
        CoreChannelState calldata ccs,
        address[] calldata assetIds,
        uint256[] calldata indices
    ) external override onlyViaProxy nonReentrant validateChannel(ccs) {
        // These checks are not strictly necessary, but it's a bit cleaner this way
        require(assetIds.length > 0, "CMCAdjudicator: NO_ASSETS_GIVEN");
        require(
            indices.length <= assetIds.length,
            "CMCAdjudicator: WRONG_ARRAY_LENGTHS"
        );

        // Verify that the given channel state matches the stored one
        require(
            hashChannelState(ccs) == channelDispute.channelStateHash,
            "CMCAdjudicator: INVALID_CHANNEL_HASH"
        );

        // We need to be in defund phase for that
        require(inDefundPhase(), "CMCAdjudicator: INVALID_PHASE");

        // TODO SECURITY: Beware of reentrancy
        // TODO: offchain-ensure that all arrays have the same length:
        // assetIds, balances, processedDepositsA, processedDepositsB, defundNonces
        // Make sure there are no duplicates in the assetIds -- duplicates are often a source of double-spends

        // Defund all assets given
        for (uint256 i = 0; i < assetIds.length; i++) {
            address assetId = assetIds[i];

            // Verify or find the index of the assetId in the ccs.assetIds
            uint256 index;
            if (i < indices.length) {
                // The index was supposedly given -- we verify
                index = indices[i];
                require(
                    assetId == ccs.assetIds[index],
                    "CMCAdjudicator: INDEX_MISMATCH"
                );
            } else {
                // we search through the assets in ccs
                for (index = 0; index < ccs.assetIds.length; index++) {
                    if (assetId == ccs.assetIds[index]) {
                        break;
                    }
                }
            }

            // Now, if `index`  is equal to the number of assets in ccs,
            // then the current asset is not in ccs;
            // otherwise, `index` is the index in ccs for the current asset

            // Check the assets haven't already been defunded + update the
            // defundNonce for that asset
            {
                // Open a new block to avoid "stack too deep" error
                uint256 defundNonce =
                    (index == ccs.assetIds.length)
                        ? INITIAL_DEFUND_NONCE
                        : ccs.defundNonces[index];
                require(
                    defundNonces[assetId] < defundNonce,
                    "CMCAdjudicator: CHANNEL_ALREADY_DEFUNDED"
                );
                defundNonces[assetId] = defundNonce;
            }

            // Get total deposits
            uint256 tdAlice = _getTotalDepositsAlice(assetId);
            uint256 tdBob = _getTotalDepositsBob(assetId);

            Balance memory balance;

            if (index == ccs.assetIds.length) {
                // The current asset is not a part of ccs; refund what has been deposited
                balance = Balance({
                    amount: [tdAlice, tdBob],
                    to: [payable(ccs.alice), payable(ccs.bob)]
                });
            } else {
                // Start with the final balances in ccs
                balance = ccs.balances[index];
                // Add unprocessed deposits
                balance.amount[0] = balance.amount[0].satAdd(
                    tdAlice - ccs.processedDepositsA[index]
                );
                balance.amount[1] = balance.amount[1].satAdd(
                    tdBob - ccs.processedDepositsB[index]
                );
            }

            // Add result to exitable amounts
            makeBalanceExitable(assetId, balance);
        }

        emit ChannelDefunded(
            msg.sender,
            ccs,
            channelDispute,
            assetIds
        );
    }

    function disputeTransfer(
        CoreTransferState calldata cts,
        bytes32[] calldata merkleProofData
    ) external override onlyViaProxy nonReentrant validateTransfer(cts) {
        // Verify that the given transfer state is included in the "finalized" channel state
        bytes32 transferStateHash = hashTransferState(cts);
        verifyMerkleProof(
            merkleProofData,
            channelDispute.merkleRoot,
            transferStateHash
        );

        // The channel needs to be in defund phase for that, i.e. channel state is "finalized"
        require(inDefundPhase(), "CMCAdjudicator: INVALID_PHASE");

        // Get stored dispute for this transfer
        TransferDispute storage transferDispute =
            transferDisputes[cts.transferId];

        // Verify that this transfer has not been disputed before
        require(
            transferDispute.transferDisputeExpiry == 0,
            "CMCAdjudicator: TRANSFER_ALREADY_DISPUTED"
        );

        // Store transfer state and set expiry
        transferDispute.transferStateHash = transferStateHash;
        // TODO: offchain-ensure that there can't be an overflow
        transferDispute.transferDisputeExpiry = block.timestamp.add(
            cts.transferTimeout
        );

        emit TransferDisputed(
            msg.sender,
            cts,
            transferDispute
        );
    }

    function defundTransfer(
        CoreTransferState calldata cts,
        bytes calldata encodedInitialTransferState,
        bytes calldata encodedTransferResolver,
        bytes calldata responderSignature
    ) external override onlyViaProxy nonReentrant validateTransfer(cts) {
        // Get stored dispute for this transfer
        TransferDispute storage transferDispute =
            transferDisputes[cts.transferId];

        // Verify that a dispute for this transfer has already been started
        require(
            transferDispute.transferDisputeExpiry != 0,
            "CMCAdjudicator: TRANSFER_NOT_DISPUTED"
        );

        // Verify that the given transfer state matches the stored one
        require(
            hashTransferState(cts) == transferDispute.transferStateHash,
            "CMCAdjudicator: INVALID_TRANSFER_HASH"
        );

        // We can't defund twice
        require(
            !transferDispute.isDefunded,
            "CMCAdjudicator: TRANSFER_ALREADY_DEFUNDED"
        );
        transferDispute.isDefunded = true;

        Balance memory balance;

        if (block.timestamp < transferDispute.transferDisputeExpiry) {
            // Ensure the correct hash is provided
            require(
                keccak256(encodedInitialTransferState) == cts.initialStateHash,
                "CMCAdjudicator: INVALID_TRANSFER_HASH"
            );
            
            // Before dispute expiry, responder or responder-authorized
            // agent (i.e. watchtower) can resolve
            require(
                msg.sender == cts.responder || cts.initialStateHash.checkSignature(responderSignature, cts.responder),
                "CMCAdjudicator: INVALID_RESOLVER"
            );
            
            ITransferDefinition transferDefinition =
                ITransferDefinition(cts.transferDefinition);
            balance = transferDefinition.resolve(
                abi.encode(cts.balance),
                encodedInitialTransferState,
                encodedTransferResolver
            );
            // Verify that returned balances don't exceed initial balances
            require(
                balance.amount[0].add(balance.amount[1]) <=
                    cts.balance.amount[0].add(cts.balance.amount[1]),
                "CMCAdjudicator: INVALID_BALANCES"
            );
        } else {
            // After dispute expiry, if the responder hasn't resolved, we defund the initial balance
            balance = cts.balance;
        }

        // Depending on previous code path, defund either resolved or initial balance
        makeBalanceExitable(cts.assetId, balance);

        // Emit event
        emit TransferDefunded(
            msg.sender,
            cts,
            transferDispute,
            encodedInitialTransferState,
            encodedTransferResolver,
            balance
        );
    }

    function verifySignaturesOnChannelStateHash(
        CoreChannelState calldata ccs,
        bytes32 ccsHash,
        bytes calldata aliceSignature,
        bytes calldata bobSignature
    ) internal pure {
        bytes32 commitment =
            keccak256(abi.encode(CommitmentType.ChannelState, ccsHash));
        require(
            commitment.checkSignature(aliceSignature, ccs.alice),
            "CMCAdjudicator: INVALID_ALICE_SIG"
        );
        require(
            commitment.checkSignature(bobSignature, ccs.bob),
            "CMCAdjudicator: INVALID_BOB_SIG"
        );
    }

    function verifyMerkleProof(
        bytes32[] calldata proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure {
        require(
            MerkleProof.verify(proof, root, leaf),
            "CMCAdjudicator: INVALID_MERKLE_PROOF"
        );
    }

    function inConsensusPhase() internal view returns (bool) {
        return block.timestamp < channelDispute.consensusExpiry;
    }

    function inDefundPhase() internal view returns (bool) {
        return
            channelDispute.consensusExpiry <= block.timestamp &&
            block.timestamp < channelDispute.defundExpiry;
    }

    function hashChannelState(CoreChannelState calldata ccs)
        internal
        pure
        returns (bytes32)
    {
        return keccak256(abi.encode(ccs));
    }

    function hashTransferState(CoreTransferState calldata cts)
        internal
        pure
        returns (bytes32)
    {
        return keccak256(abi.encode(cts));
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.1;
pragma experimental ABIEncoderV2;

enum CommitmentType {ChannelState, WithdrawData}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.1;
pragma experimental ABIEncoderV2;

import "./ITransferRegistry.sol";
import "./Types.sol";

interface ITransferDefinition {
    // Validates the initial state of the transfer.
    // Called by validator.ts during `create` updates.
    function create(bytes calldata encodedBalance, bytes calldata)
        external
        view
        returns (bool);

    // Performs a state transition to resolve a transfer and returns final balances.
    // Called by validator.ts during `resolve` updates.
    function resolve(
        bytes calldata encodedBalance,
        bytes calldata,
        bytes calldata
    ) external view returns (Balance memory);

    // Should also have the following properties:
    // string public constant override Name = "...";
    // string public constant override StateEncoding = "...";
    // string public constant override ResolverEncoding = "...";
    // These properties are included on the transfer specifically
    // to make it easier for implementers to add new transfers by
    // only include a `.sol` file
    function Name() external view returns (string memory);

    function StateEncoding() external view returns (string memory);

    function ResolverEncoding() external view returns (string memory);

    function EncodedCancel() external view returns (bytes memory);

    function getRegistryInformation()
        external
        view
        returns (RegisteredTransfer memory);
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.1;
pragma experimental ABIEncoderV2;

import "@openzeppelin/contracts/cryptography/ECDSA.sol";
		
/// @author Connext <[email protected]>		
/// @notice This library contains helpers for recovering signatures from a		
///         Vector commitments. Channels do not allow for arbitrary signing of		
///         messages to prevent misuse of private keys by injected providers,		
///         and instead only sign messages with a Vector channel prefix.
library LibChannelCrypto {
    function checkSignature(
        bytes32 hash,
        bytes memory signature,
        address allegedSigner
    ) internal pure returns (bool) {
        return recoverChannelMessageSigner(hash, signature) == allegedSigner;
    }

    function recoverChannelMessageSigner(bytes32 hash, bytes memory signature)
        internal
        pure
        returns (address)
    {
        bytes32 digest = toChannelSignedMessage(hash);
        return ECDSA.recover(digest, signature);
    }

    function toChannelSignedMessage(bytes32 hash)
        internal
        pure
        returns (bytes32)
    {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return
            keccak256(abi.encodePacked("\x16Vector Signed Message:\n32", hash));
    }

    function checkUtilitySignature(
        bytes32 hash,
        bytes memory signature,
        address allegedSigner
    ) internal pure returns (bool) {
        return recoverChannelMessageSigner(hash, signature) == allegedSigner;
    }

    function recoverUtilityMessageSigner(bytes32 hash, bytes memory signature)
        internal
        pure
        returns (address)
    {
        bytes32 digest = toUtilitySignedMessage(hash);
        return ECDSA.recover(digest, signature);
    }

    function toUtilitySignedMessage(bytes32 hash)
        internal
        pure
        returns (bytes32)
    {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return
            keccak256(abi.encodePacked("\x17Utility Signed Message:\n32", hash));
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.0;

/**
 * @dev These functions deal with verification of Merkle trees (hash trees),
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        bytes32 computedHash = leaf;

        for (uint256 i = 0; i < proof.length; i++) {
            bytes32 proofElement = proof[i];

            if (computedHash <= proofElement) {
                // Hash(current computed hash + current element of the proof)
                computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
            } else {
                // Hash(current element of the proof + current computed hash)
                computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
            }
        }

        // Check if the computed hash (root) is equal to the provided root
        return computedHash == root;
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.1;
pragma experimental "ABIEncoderV2";

struct RegisteredTransfer {
    string name;
    address definition;
    string stateEncoding;
    string resolverEncoding;
    bytes encodedCancel;
}

interface ITransferRegistry {
    event TransferAdded(RegisteredTransfer transfer);

    event TransferRemoved(RegisteredTransfer transfer);

    // Should add a transfer definition to the registry
    // onlyOwner
    function addTransferDefinition(RegisteredTransfer memory transfer) external;

    // Should remove a transfer definition to the registry
    // onlyOwner
    function removeTransferDefinition(string memory name) external;

    // Should return all transfer defintions in registry
    function getTransferDefinitions()
        external
        view
        returns (RegisteredTransfer[] memory);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.0;

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        // Check the signature length
        if (signature.length != 65) {
            revert("ECDSA: invalid signature length");
        }

        // Divide the signature in r, s and v variables
        bytes32 r;
        bytes32 s;
        uint8 v;

        // ecrecover takes the signature parameters, and the only way to get them
        // currently is to use assembly.
        // solhint-disable-next-line no-inline-assembly
        assembly {
            r := mload(add(signature, 0x20))
            s := mload(add(signature, 0x40))
            v := byte(0, mload(add(signature, 0x60)))
        }

        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (281): 0 < s < secp256k1n ÷ 2 + 1, and for v in (282): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            revert("ECDSA: invalid signature 's' value");
        }

        if (v != 27 && v != 28) {
            revert("ECDSA: invalid signature 'v' value");
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        require(signer != address(0), "ECDSA: invalid signature");

        return signer;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * replicates the behavior of the
     * https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_sign[`eth_sign`]
     * JSON-RPC method.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.1;
pragma experimental ABIEncoderV2;

import "./interfaces/Commitment.sol";
import "./interfaces/ICMCWithdraw.sol";
import "./interfaces/WithdrawHelper.sol";
import "./CMCCore.sol";
import "./CMCAsset.sol";
import "./lib/LibAsset.sol";
import "./lib/LibChannelCrypto.sol";
import "./lib/LibUtils.sol";

/// @title CMCWithdraw
/// @author Connext <[email protected]>
/// @notice Contains logic for all cooperative channel multisig withdrawals.
///         Cooperative withdrawal commitments must be signed by both channel
///         participants. As part of the channel withdrawals, an arbitrary
///         call can be made, which is extracted from the withdraw data.

contract CMCWithdraw is CMCCore, CMCAsset, ICMCWithdraw {
    using LibChannelCrypto for bytes32;

    mapping(bytes32 => bool) private isExecuted;

    modifier validateWithdrawData(WithdrawData calldata wd) {
        require(
            wd.channelAddress == address(this),
            "CMCWithdraw: CHANNEL_MISMATCH"
        );
        _;
    }

    function getWithdrawalTransactionRecord(WithdrawData calldata wd)
        external
        view
        override
        onlyViaProxy
        nonReentrantView
        returns (bool)
    {
        return isExecuted[hashWithdrawData(wd)];
    }

    /// @param wd The withdraw data consisting of
    /// semantic withdraw information, i.e. assetId, recipient, and amount;
    /// information to make an optional call in addition to the actual transfer,
    /// i.e. target address for the call and call payload;
    /// additional information, i.e. channel address and nonce.
    /// @param aliceSignature Signature of owner a
    /// @param bobSignature Signature of owner b
    function withdraw(
        WithdrawData calldata wd,
        bytes calldata aliceSignature,
        bytes calldata bobSignature
    ) external override onlyViaProxy nonReentrant validateWithdrawData(wd) {
        // Generate hash
        bytes32 wdHash = hashWithdrawData(wd);

        // Verify Alice's and Bob's signature on the withdraw data
        verifySignaturesOnWithdrawDataHash(wdHash, aliceSignature, bobSignature);

        // Replay protection
        require(!isExecuted[wdHash], "CMCWithdraw: ALREADY_EXECUTED");
        isExecuted[wdHash] = true;

        // Determine actually transferable amount
        uint256 actualAmount = getAvailableAmount(wd.assetId, wd.amount);

        // Revert if actualAmount is zero && callTo is 0
        require(
            actualAmount > 0 || wd.callTo != address(0),
            "CMCWithdraw: NO_OP"
        );

        // Register and execute the transfer
        transferAsset(wd.assetId, wd.recipient, actualAmount);

        // Do we have to make a call in addition to the actual transfer?
        if (wd.callTo != address(0)) {
            WithdrawHelper(wd.callTo).execute(wd, actualAmount);
        }
    }

    function verifySignaturesOnWithdrawDataHash(
        bytes32 wdHash,
        bytes calldata aliceSignature,
        bytes calldata bobSignature
    ) internal view {
        bytes32 commitment =
            keccak256(abi.encode(CommitmentType.WithdrawData, wdHash));
        require(
            commitment.checkSignature(aliceSignature, alice),
            "CMCWithdraw: INVALID_ALICE_SIG"
        );
        require(
            commitment.checkSignature(bobSignature, bob),
            "CMCWithdraw: INVALID_BOB_SIG"
        );
    }

    function hashWithdrawData(WithdrawData calldata wd)
        internal
        pure
        returns (bytes32)
    {
        return keccak256(abi.encode(wd));
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.1;
pragma experimental ABIEncoderV2;

import "./ICMCWithdraw.sol";

interface WithdrawHelper {
    function execute(WithdrawData calldata wd, uint256 actualAmount) external;
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.1;
pragma experimental ABIEncoderV2;

import "./interfaces/IVectorChannel.sol";
import "./CMCCore.sol";
import "./CMCAsset.sol";
import "./CMCDeposit.sol";
import "./CMCWithdraw.sol";
import "./CMCAdjudicator.sol";

/// @title ChannelMastercopy
/// @author Connext <[email protected]>
/// @notice Contains the logic used by all Vector multisigs. A proxy to this
///         contract is deployed per-channel using the ChannelFactory.sol.
///         Supports channel adjudication logic, deposit logic, and arbitrary
///         calls when a commitment is double-signed.
contract ChannelMastercopy is
    CMCCore,
    CMCAsset,
    CMCDeposit,
    CMCWithdraw,
    CMCAdjudicator,
    IVectorChannel
{

}

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "metadata": {
    "useLiteralContent": true
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"assetId","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"AliceDeposited","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"defunder","type":"address"},{"components":[{"internalType":"address","name":"channelAddress","type":"address"},{"internalType":"address","name":"alice","type":"address"},{"internalType":"address","name":"bob","type":"address"},{"internalType":"address[]","name":"assetIds","type":"address[]"},{"components":[{"internalType":"uint256[2]","name":"amount","type":"uint256[2]"},{"internalType":"address payable[2]","name":"to","type":"address[2]"}],"internalType":"struct Balance[]","name":"balances","type":"tuple[]"},{"internalType":"uint256[]","name":"processedDepositsA","type":"uint256[]"},{"internalType":"uint256[]","name":"processedDepositsB","type":"uint256[]"},{"internalType":"uint256[]","name":"defundNonces","type":"uint256[]"},{"internalType":"uint256","name":"timeout","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"bytes32","name":"merkleRoot","type":"bytes32"}],"indexed":false,"internalType":"struct ICMCAdjudicator.CoreChannelState","name":"state","type":"tuple"},{"components":[{"internalType":"bytes32","name":"channelStateHash","type":"bytes32"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"bytes32","name":"merkleRoot","type":"bytes32"},{"internalType":"uint256","name":"consensusExpiry","type":"uint256"},{"internalType":"uint256","name":"defundExpiry","type":"uint256"}],"indexed":false,"internalType":"struct ICMCAdjudicator.ChannelDispute","name":"dispute","type":"tuple"},{"indexed":false,"internalType":"address[]","name":"assetIds","type":"address[]"}],"name":"ChannelDefunded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"disputer","type":"address"},{"components":[{"internalType":"address","name":"channelAddress","type":"address"},{"internalType":"address","name":"alice","type":"address"},{"internalType":"address","name":"bob","type":"address"},{"internalType":"address[]","name":"assetIds","type":"address[]"},{"components":[{"internalType":"uint256[2]","name":"amount","type":"uint256[2]"},{"internalType":"address payable[2]","name":"to","type":"address[2]"}],"internalType":"struct Balance[]","name":"balances","type":"tuple[]"},{"internalType":"uint256[]","name":"processedDepositsA","type":"uint256[]"},{"internalType":"uint256[]","name":"processedDepositsB","type":"uint256[]"},{"internalType":"uint256[]","name":"defundNonces","type":"uint256[]"},{"internalType":"uint256","name":"timeout","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"bytes32","name":"merkleRoot","type":"bytes32"}],"indexed":false,"internalType":"struct ICMCAdjudicator.CoreChannelState","name":"state","type":"tuple"},{"components":[{"internalType":"bytes32","name":"channelStateHash","type":"bytes32"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"bytes32","name":"merkleRoot","type":"bytes32"},{"internalType":"uint256","name":"consensusExpiry","type":"uint256"},{"internalType":"uint256","name":"defundExpiry","type":"uint256"}],"indexed":false,"internalType":"struct ICMCAdjudicator.ChannelDispute","name":"dispute","type":"tuple"}],"name":"ChannelDisputed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"defunder","type":"address"},{"components":[{"internalType":"address","name":"channelAddress","type":"address"},{"internalType":"bytes32","name":"transferId","type":"bytes32"},{"internalType":"address","name":"transferDefinition","type":"address"},{"internalType":"address","name":"initiator","type":"address"},{"internalType":"address","name":"responder","type":"address"},{"internalType":"address","name":"assetId","type":"address"},{"components":[{"internalType":"uint256[2]","name":"amount","type":"uint256[2]"},{"internalType":"address payable[2]","name":"to","type":"address[2]"}],"internalType":"struct Balance","name":"balance","type":"tuple"},{"internalType":"uint256","name":"transferTimeout","type":"uint256"},{"internalType":"bytes32","name":"initialStateHash","type":"bytes32"}],"indexed":false,"internalType":"struct ICMCAdjudicator.CoreTransferState","name":"state","type":"tuple"},{"components":[{"internalType":"bytes32","name":"transferStateHash","type":"bytes32"},{"internalType":"uint256","name":"transferDisputeExpiry","type":"uint256"},{"internalType":"bool","name":"isDefunded","type":"bool"}],"indexed":false,"internalType":"struct ICMCAdjudicator.TransferDispute","name":"dispute","type":"tuple"},{"indexed":false,"internalType":"bytes","name":"encodedInitialState","type":"bytes"},{"indexed":false,"internalType":"bytes","name":"encodedResolver","type":"bytes"},{"components":[{"internalType":"uint256[2]","name":"amount","type":"uint256[2]"},{"internalType":"address payable[2]","name":"to","type":"address[2]"}],"indexed":false,"internalType":"struct Balance","name":"balance","type":"tuple"}],"name":"TransferDefunded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"disputer","type":"address"},{"components":[{"internalType":"address","name":"channelAddress","type":"address"},{"internalType":"bytes32","name":"transferId","type":"bytes32"},{"internalType":"address","name":"transferDefinition","type":"address"},{"internalType":"address","name":"initiator","type":"address"},{"internalType":"address","name":"responder","type":"address"},{"internalType":"address","name":"assetId","type":"address"},{"components":[{"internalType":"uint256[2]","name":"amount","type":"uint256[2]"},{"internalType":"address payable[2]","name":"to","type":"address[2]"}],"internalType":"struct Balance","name":"balance","type":"tuple"},{"internalType":"uint256","name":"transferTimeout","type":"uint256"},{"internalType":"bytes32","name":"initialStateHash","type":"bytes32"}],"indexed":false,"internalType":"struct ICMCAdjudicator.CoreTransferState","name":"state","type":"tuple"},{"components":[{"internalType":"bytes32","name":"transferStateHash","type":"bytes32"},{"internalType":"uint256","name":"transferDisputeExpiry","type":"uint256"},{"internalType":"bool","name":"isDefunded","type":"bool"}],"indexed":false,"internalType":"struct ICMCAdjudicator.TransferDispute","name":"dispute","type":"tuple"}],"name":"TransferDisputed","type":"event"},{"inputs":[{"components":[{"internalType":"address","name":"channelAddress","type":"address"},{"internalType":"address","name":"alice","type":"address"},{"internalType":"address","name":"bob","type":"address"},{"internalType":"address[]","name":"assetIds","type":"address[]"},{"components":[{"internalType":"uint256[2]","name":"amount","type":"uint256[2]"},{"internalType":"address payable[2]","name":"to","type":"address[2]"}],"internalType":"struct Balance[]","name":"balances","type":"tuple[]"},{"internalType":"uint256[]","name":"processedDepositsA","type":"uint256[]"},{"internalType":"uint256[]","name":"processedDepositsB","type":"uint256[]"},{"internalType":"uint256[]","name":"defundNonces","type":"uint256[]"},{"internalType":"uint256","name":"timeout","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"bytes32","name":"merkleRoot","type":"bytes32"}],"internalType":"struct ICMCAdjudicator.CoreChannelState","name":"ccs","type":"tuple"},{"internalType":"address[]","name":"assetIds","type":"address[]"},{"internalType":"uint256[]","name":"indices","type":"uint256[]"}],"name":"defundChannel","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"channelAddress","type":"address"},{"internalType":"bytes32","name":"transferId","type":"bytes32"},{"internalType":"address","name":"transferDefinition","type":"address"},{"internalType":"address","name":"initiator","type":"address"},{"internalType":"address","name":"responder","type":"address"},{"internalType":"address","name":"assetId","type":"address"},{"components":[{"internalType":"uint256[2]","name":"amount","type":"uint256[2]"},{"internalType":"address payable[2]","name":"to","type":"address[2]"}],"internalType":"struct Balance","name":"balance","type":"tuple"},{"internalType":"uint256","name":"transferTimeout","type":"uint256"},{"internalType":"bytes32","name":"initialStateHash","type":"bytes32"}],"internalType":"struct ICMCAdjudicator.CoreTransferState","name":"cts","type":"tuple"},{"internalType":"bytes","name":"encodedInitialTransferState","type":"bytes"},{"internalType":"bytes","name":"encodedTransferResolver","type":"bytes"},{"internalType":"bytes","name":"responderSignature","type":"bytes"}],"name":"defundTransfer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"assetId","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"depositAlice","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"channelAddress","type":"address"},{"internalType":"address","name":"alice","type":"address"},{"internalType":"address","name":"bob","type":"address"},{"internalType":"address[]","name":"assetIds","type":"address[]"},{"components":[{"internalType":"uint256[2]","name":"amount","type":"uint256[2]"},{"internalType":"address payable[2]","name":"to","type":"address[2]"}],"internalType":"struct Balance[]","name":"balances","type":"tuple[]"},{"internalType":"uint256[]","name":"processedDepositsA","type":"uint256[]"},{"internalType":"uint256[]","name":"processedDepositsB","type":"uint256[]"},{"internalType":"uint256[]","name":"defundNonces","type":"uint256[]"},{"internalType":"uint256","name":"timeout","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"bytes32","name":"merkleRoot","type":"bytes32"}],"internalType":"struct ICMCAdjudicator.CoreChannelState","name":"ccs","type":"tuple"},{"internalType":"bytes","name":"aliceSignature","type":"bytes"},{"internalType":"bytes","name":"bobSignature","type":"bytes"}],"name":"disputeChannel","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"channelAddress","type":"address"},{"internalType":"bytes32","name":"transferId","type":"bytes32"},{"internalType":"address","name":"transferDefinition","type":"address"},{"internalType":"address","name":"initiator","type":"address"},{"internalType":"address","name":"responder","type":"address"},{"internalType":"address","name":"assetId","type":"address"},{"components":[{"internalType":"uint256[2]","name":"amount","type":"uint256[2]"},{"internalType":"address payable[2]","name":"to","type":"address[2]"}],"internalType":"struct Balance","name":"balance","type":"tuple"},{"internalType":"uint256","name":"transferTimeout","type":"uint256"},{"internalType":"bytes32","name":"initialStateHash","type":"bytes32"}],"internalType":"struct ICMCAdjudicator.CoreTransferState","name":"cts","type":"tuple"},{"internalType":"bytes32[]","name":"merkleProofData","type":"bytes32[]"}],"name":"disputeTransfer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"assetId","type":"address"},{"internalType":"address","name":"owner","type":"address"},{"internalType":"address payable","name":"recipient","type":"address"}],"name":"exit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getAlice","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getBob","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getChannelDispute","outputs":[{"components":[{"internalType":"bytes32","name":"channelStateHash","type":"bytes32"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"bytes32","name":"merkleRoot","type":"bytes32"},{"internalType":"uint256","name":"consensusExpiry","type":"uint256"},{"internalType":"uint256","name":"defundExpiry","type":"uint256"}],"internalType":"struct ICMCAdjudicator.ChannelDispute","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"assetId","type":"address"}],"name":"getDefundNonce","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"assetId","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"getExitableAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"assetId","type":"address"}],"name":"getTotalDepositsAlice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"assetId","type":"address"}],"name":"getTotalDepositsBob","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"assetId","type":"address"}],"name":"getTotalTransferred","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"transferId","type":"bytes32"}],"name":"getTransferDispute","outputs":[{"components":[{"internalType":"bytes32","name":"transferStateHash","type":"bytes32"},{"internalType":"uint256","name":"transferDisputeExpiry","type":"uint256"},{"internalType":"bool","name":"isDefunded","type":"bool"}],"internalType":"struct ICMCAdjudicator.TransferDispute","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"channelAddress","type":"address"},{"internalType":"address","name":"assetId","type":"address"},{"internalType":"address payable","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"address","name":"callTo","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct WithdrawData","name":"wd","type":"tuple"}],"name":"getWithdrawalTransactionRecord","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_alice","type":"address"},{"internalType":"address","name":"_bob","type":"address"}],"name":"setup","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"channelAddress","type":"address"},{"internalType":"address","name":"assetId","type":"address"},{"internalType":"address payable","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"address","name":"callTo","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct WithdrawData","name":"wd","type":"tuple"},{"internalType":"bytes","name":"aliceSignature","type":"bytes"},{"internalType":"bytes","name":"bobSignature","type":"bytes"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

635:133:13:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1024:4:10;-1:-1:-1;;;;;1033:17:10;1016:34;;;995:107;;;;-1:-1:-1;;;995:107:10;;;;;;;:::i;:::-;;;;;;;;;307:1:14::1;484:4;;:12;476:56;;;;-1:-1:-1::0;;;476:56:14::1;;;;;;;:::i;:::-;307:1;542:4;576:11:::0;635:133:13;;;;;9214:2884:8;;;;;;;;;;-1:-1:-1;9214:2884:8;;;;;:::i;:::-;;:::i;:::-;;2153:168:10;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1767:1166:12;;;;;;;;;;-1:-1:-1;1767:1166:12;;;;;:::i;:::-;;:::i;1322:447:10:-;;;;;;;;;;-1:-1:-1;1322:447:10;;;;;:::i;:::-;;:::i;2174:238:8:-;;;;;;;;;;-1:-1:-1;2174:238:8;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;3827:3983::-;;;;;;;;;;-1:-1:-1;3827:3983:8;;;;;:::i;:::-;;:::i;3046:910:9:-;;;;;;;;;;-1:-1:-1;3046:910:9;;;;;:::i;:::-;;:::i;7816:1392:8:-;;;;;;;;;;-1:-1:-1;7816:1392:8;;;;;:::i;:::-;;:::i;1752:848:11:-;;;;;;:::i;:::-;;:::i;789:226::-;;;;;;;;;;-1:-1:-1;789:226:11;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;1089:242:12:-;;;;;;;;;;-1:-1:-1;1089:242:12;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;1182:222:11:-;;;;;;;;;;-1:-1:-1;1182:222:11;;;;;:::i;:::-;;:::i;2418:1403:8:-;;;;;;;;;;-1:-1:-1;2418:1403:8;;;;;:::i;:::-;;:::i;1238:218:9:-;;;;;;;;;;-1:-1:-1;1238:218:9;;;;;:::i;:::-;;:::i;1959:209:8:-;;;;;;;;;;-1:-1:-1;1959:209:8;;;;;:::i;:::-;;:::i;2026:236:9:-;;;;;;;;;;-1:-1:-1;2026:236:9;;;;;:::i;:::-;;:::i;1874:172:10:-;;;;;;;;;;;;;:::i;1749:204:8:-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;356:19:14:-;;;;;;;;;;;;;:::i;9214:2884:8:-;1024:4:10;-1:-1:-1;;;;;1033:17:10;1016:34;;;995:107;;;;-1:-1:-1;;;995:107:10;;;;;;;:::i;:::-;307:1:14::1;484:4;;:12;476:56;;;;-1:-1:-1::0;;;476:56:14::1;;;;;;;:::i;:::-;348:1;542:4;:13:::0;9488:3:8;1662:4:::2;1632:18;;::::0;::::2;9488:3:::0;1632:18:::2;:::i;:::-;-1:-1:-1::0;;;;;1632:35:8::2;;1611:114;;;;-1:-1:-1::0;;;1611:114:8::2;;;;;;;:::i;:::-;9622:14:::3;::::0;;::::3;;9551:39;9605:32:::0;;;:16:::3;:32:::0;;;;;;9745:37:::3;::::0;::::3;::::0;9724:126:::3;;;;-1:-1:-1::0;;;9724:126:8::3;;;;;;;:::i;:::-;9979:33:::0;;9953:22:::3;9971:3:::0;9953:17:::3;:22::i;:::-;:59;9932:143;;;;-1:-1:-1::0;;;9932:143:8::3;;;;;;;:::i;:::-;10141:26;::::0;::::3;::::0;::::3;;10140:27;10119:115;;;;-1:-1:-1::0;;;10119:115:8::3;;;;;;;:::i;:::-;10244:26;::::0;::::3;:33:::0;;-1:-1:-1;;10244:33:8::3;10273:4;10244:33;::::0;;10288:22:::3;;:::i;:::-;10343:15;:37;;;10325:15;:55;10321:1400;;;10514:3;:20;;;10482:27;;10472:38;;;;;;;:::i;:::-;;;;;;;;:62;10447:158;;;;-1:-1:-1::0;;;10447:158:8::3;;;;;;;:::i;:::-;10794:13;::::0;;;::::3;::::0;::::3;;:::i;:::-;-1:-1:-1::0;;;;;10780:27:8::3;:10;-1:-1:-1::0;;;;;10780:27:8::3;;:101;;;;10811:70;10847:18;;10811:70;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::3;::::0;;;;-1:-1:-1;10867:13:8::3;::::0;-1:-1:-1;;;10867:13:8;;;::::3;::::0;::::3;;:::i;:::-;10811:20;::::0;::::3;;::::0;:70;:35:::3;:70::i;:::-;10755:192;;;;-1:-1:-1::0;;;10755:192:8::3;;;;;;;:::i;:::-;10974:38;11051:22;::::0;;;::::3;::::0;::::3;;:::i;:::-;10974:100;;11098:18;-1:-1:-1::0;;;;;11098:26:8::3;;11153:3;:11;;11142:23;;;;;;;;:::i;:::-;;;;;;;;;;;;;11183:27;;11228:23;;11098:167;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;11088:177:::0;-1:-1:-1;11443:48:8::3;11469:11;::::0;::::3;11443:21;11469::::0;;;::::3;11443:25;:48::i;:::-;11401:14:::0;;:17:::3;::::0;::::3;::::0;11379;;:40:::3;::::0;:21:::3;:40::i;:::-;:112;;11354:203;;;;-1:-1:-1::0;;;11354:203:8::3;;;;;;;:::i;:::-;10321:1400;;;;11689:21;;::::0;;;;;11699:11:::3;::::0;::::3;11689:21;:::i;:::-;;;10321:1400;11817:41;11837:11;::::0;;;::::3;::::0;::::3;;:::i;:::-;11850:7;11817:19;:41::i;:::-;11896:195;11926:10;11950:3;11967:15;11996:27;;12037:23;;12074:7;11896:195;;;;;;;;;;;;;:::i;:::-;;;;;;;;-1:-1:-1::0;;307:1:14::1;576:4;:11:::0;-1:-1:-1;;;;;;;;9214:2884:8:o;2153:168:10:-;2281:7;1024:4;-1:-1:-1;;;;;1033:17:10;1016:34;;;995:107;;;;-1:-1:-1;;;995:107:10;;;;;;;:::i;:::-;307:1:14::1;646:4;;:12;638:56;;;;-1:-1:-1::0;;;638:56:14::1;;;;;;;:::i;:::-;-1:-1:-1::0;2311:3:10::2;::::0;-1:-1:-1;;;;;2311:3:10::2;2153:168:::0;:::o;1767:1166:12:-;1024:4:10;-1:-1:-1;;;;;1033:17:10;1016:34;;;995:107;;;;-1:-1:-1;;;995:107:10;;;;;;;:::i;:::-;307:1:14::1;484:4;;:12;476:56;;;;-1:-1:-1::0;;;476:56:14::1;;;;;;;:::i;:::-;348:1;542:4;:13:::0;1966:2:12;1005:4:::2;976:17;;::::0;::::2;1966:2:::0;976:17:::2;:::i;:::-;-1:-1:-1::0;;;;;976:34:12::2;;955:110;;;;-1:-1:-1::0;;;955:110:12::2;;;;;;;:::i;:::-;2005:14:::3;2022:20;2039:2;2022:16;:20::i;:::-;2005:37;;2120:72;2155:6;2163:14;;2179:12;;2120:34;:72::i;:::-;2241:18;::::0;;;:10:::3;:18;::::0;;;;;::::3;;2240:19;2232:61;;;;-1:-1:-1::0;;;2232:61:12::3;;;;;;;:::i;:::-;2303:18;::::0;;;:10:::3;:18;::::0;;;;;;;:25;;-1:-1:-1;;2303:25:12::3;2324:4;2303:25;::::0;;2412:41:::3;::::0;2431:10:::3;::::0;;;;;::::3;;:::i;:::-;2443:2;:9;;;2412:18;:41::i;:::-;2389:64;;2557:1;2542:12;:16;:43;;;-1:-1:-1::0;2583:1:12::3;2562:9;::::0;;;::::3;::::0;::::3;;:::i;:::-;-1:-1:-1::0;;;;;2562:23:12::3;;;2542:43;2521:108;;;;-1:-1:-1::0;;;2521:108:12::3;;;;;;;:::i;:::-;2685:53;2699:10;::::0;;;::::3;::::0;::::3;;:::i;:::-;2711:12;::::0;;;::::3;::::0;::::3;;:::i;:::-;2725;2685:13;:53::i;:::-;2847:1;2826:9;::::0;;;::::3;::::0;::::3;;:::i;:::-;-1:-1:-1::0;;;;;2826:23:12::3;;2822:105;;2880:9;::::0;;;::::3;::::0;::::3;;:::i;:::-;-1:-1:-1::0;;;;;2865:33:12::3;;2899:2;2903:12;2865:51;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;::::0;::::3;;;;;;;;;2822:105;-1:-1:-1::0;;307:1:14::1;576:4;:11:::0;-1:-1:-1;;;;;;1767:1166:12:o;1322:447:10:-;1024:4;-1:-1:-1;;;;;1033:17:10;1016:34;;;995:107;;;;-1:-1:-1;;;995:107:10;;;;;;;:::i;:::-;1444:5:::1;::::0;-1:-1:-1;;;;;1444:5:10::1;:19:::0;1436:54:::1;;;;-1:-1:-1::0;;;1436:54:10::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;1521:20:10;::::1;::::0;;::::1;::::0;:42:::1;;-1:-1:-1::0;;;;;;1545:18:10;::::1;::::0;::::1;1521:42;1500:117;;;;-1:-1:-1::0;;;1500:117:10::1;;;;;;;:::i;:::-;1645:4;-1:-1:-1::0;;;;;1635:14:10::1;:6;-1:-1:-1::0;;;;;1635:14:10::1;;;1627:58;;;;-1:-1:-1::0;;;1627:58:10::1;;;;;;;:::i;:::-;1695:23;:21;:23::i;:::-;1728:5;:14:::0;;-1:-1:-1;;;;;1728:14:10;;::::1;-1:-1:-1::0;;;;;;1728:14:10;;::::1;;::::0;;;1752:3:::1;:10:::0;;;;;::::1;::::0;::::1;;::::0;;1322:447::o;2174:238:8:-;2332:22;;:::i;:::-;1024:4:10;-1:-1:-1;;;;;1033:17:10;1016:34;;;995:107;;;;-1:-1:-1;;;995:107:10;;;;;;;:::i;:::-;307:1:14::1;646:4;;:12;638:56;;;;-1:-1:-1::0;;;638:56:14::1;;;;;;;:::i;:::-;-1:-1:-1::0;2377:28:8::2;::::0;;;:16:::2;:28;::::0;;;;;;;;2370:35;;::::2;::::0;::::2;::::0;;;;;;::::2;::::0;::::2;::::0;;;::::2;::::0;;;;::::2;;::::0;::::2;;;;::::0;;;;;;;;2174:238::o;3827:3983::-;1024:4:10;-1:-1:-1;;;;;1033:17:10;1016:34;;;995:107;;;;-1:-1:-1;;;995:107:10;;;;;;;:::i;:::-;307:1:14::1;484:4;;:12;476:56;;;;-1:-1:-1::0;;;476:56:14::1;;;;;;;:::i;:::-;348:1;542:4;:13:::0;4028:3:8;1385:4:::2;1355:18;;::::0;::::2;4028:3:::0;1355:18:::2;:::i;:::-;-1:-1:-1::0;;;;;1355:35:8::2;;:73;;;;-1:-1:-1::0;1423:5:8::2;::::0;-1:-1:-1;;;;;1423:5:8::2;1410:9;::::0;;;::::2;::::0;::::2;;:::i;:::-;-1:-1:-1::0;;;;;1410:18:8::2;;1355:73;:107;;;;-1:-1:-1::0;1459:3:8::2;::::0;-1:-1:-1;;;;;1459:3:8::2;1448:7;::::0;;;::::2;::::0;::::2;;:::i;:::-;-1:-1:-1::0;;;;;1448:14:8::2;;1355:107;1334:185;;;;-1:-1:-1::0;;;1334:185:8::2;;;;;;;:::i;:::-;4135:19:::0;4127:63:::3;;;;-1:-1:-1::0;;;4127:63:8::3;;;;;;;:::i;:::-;4221:33:::0;;::::3;;4200:115;;;;-1:-1:-1::0;;;4200:115:8::3;;;;;;;:::i;:::-;4442:14;:31:::0;4417:21:::3;4434:3:::0;4417:16:::3;:21::i;:::-;:56;4396:139;;;;-1:-1:-1::0;;;4396:139:8::3;;;;;;;:::i;:::-;4604:15;:13;:15::i;:::-;4596:57;;;;-1:-1:-1::0;;;4596:57:8::3;;;;;;;:::i;:::-;5018:9;5013:2659;5033:19:::0;;::::3;5013:2659;;;5073:15;5091:8;;5100:1;5091:11;;;;;;;;;;;;;;;;;;;;:::i;:::-;5073:29:::0;-1:-1:-1;5192:13:8::3;5223:18:::0;;::::3;5219:564;;;5332:7;;5340:1;5332:10;;;;;;;;;;;;;5324:18;;5400:3;:12;;;;;;;;:::i;:::-;5413:5;5400:19;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;5389:30:8::3;:7;-1:-1:-1::0;;;;;5389:30:8::3;;5360:131;;;;-1:-1:-1::0;;;5360:131:8::3;;;;;;;:::i;:::-;5219:564;;;-1:-1:-1::0;5598:1:8::3;5585:184;5609:12;;::::0;::::3;:3:::0;:12:::3;:::i;:::-;:19;;5601:5;:27;5585:184;;;5676:12;;::::0;::::3;:3:::0;:12:::3;:::i;:::-;5689:5;5676:19;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;5665:30:8::3;:7;-1:-1:-1::0;;;;;5665:30:8::3;;5661:90;;;5723:5;;5661:90;5630:7;;5585:184;;;6203:19;6255:12;;::::0;::::3;:3:::0;:12:::3;:::i;:::-;:19;;6246:5;:28;6245:127;;6349:16;;::::0;::::3;:3:::0;:16:::3;:::i;:::-;6366:5;6349:23;;;;;;;;;;;;;6245:127;;;1096:1;6245:127;-1:-1:-1::0;;;;;6419:21:8;::::3;;::::0;;;:12:::3;:21;::::0;;;;;6203:169;;-1:-1:-1;6419:35:8;-1:-1:-1;6390:146:8::3;;;;-1:-1:-1::0;;;6390:146:8::3;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;6554:21:8;::::3;;::::0;;;:12:::3;:21;::::0;;;;:35;;;;6670:31:::3;6567:7:::0;6670:22:::3;:31::i;:::-;6652:49;;6715:13;6731:29;6752:7;6731:20;:29::i;:::-;6715:45;;6775:22;;:::i;:::-;6825:12;;::::0;::::3;:3:::0;:12:::3;:::i;:::-;:19;;6816:5;:28;6812:752;;;6964:137;;;;;;;;;;;;;;;;7003:7;6964:137;;;;7012:5;6964:137;;::::0;::::3;;;;;;;;;;;;7053:3;:9;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;6964:137:8::3;-1:-1:-1::0;;;;;6964:137:8::3;;;;;7073:3;:7;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;6964:137:8::3;::::0;;;;6954:147;-1:-1:-1;6812:752:8::3;;;7206:12;;::::0;::::3;:3:::0;:12:::3;:::i;:::-;7219:5;7206:19;;;;;;;;;;;;7196:29;;;;;;;;;;:::i;:::-;::::0;-1:-1:-1;7307:103:8::3;7363:22;;::::0;::::3;:3:::0;:22:::3;:::i;:::-;7386:5;7363:29;;;;;;;;;;;;;7353:7;:39;7307:7;:14;;;7322:1;7307:17;;;;;;;;;;::::0;;:24:::3;:103::i;:::-;7287:14:::0;;:123;7448:101:::3;7502:22;;::::0;::::3;::::0;::::3;:::i;:::-;7525:5;7502:29;;;;;;;;;;;;;7494:5;:37;7448:7;:14;;;7463:1;7448:17;;;;;;:101;7428:14:::0;;:17:::3;;:121:::0;6812:752:::3;7624:37;7644:7;7653;7624:19;:37::i;:::-;-1:-1:-1::0;;5054:3:8::3;::::0;;::::3;::::0;-1:-1:-1;5013:2659:8::3;::::0;-1:-1:-1;;5013:2659:8::3;;;7687:116;7716:10;7740:3;7757:14;7785:8;;7687:116;;;;;;;;;;:::i;:::-;;;;;;;;-1:-1:-1::0;;307:1:14::1;576:4;:11:::0;-1:-1:-1;;;;3827:3983:8:o;3046:910:9:-;1024:4:10;-1:-1:-1;;;;;1033:17:10;1016:34;;;995:107;;;;-1:-1:-1;;;995:107:10;;;;;;;:::i;:::-;307:1:14::1;484:4;;:12;476:56;;;;-1:-1:-1::0;;;476:56:14::1;;;;;;;:::i;:::-;348:1;542:4;:13:::0;3373:10:9::2;-1:-1:-1::0;;;;;3373:19:9;::::2;;::::0;:41:::2;;;3405:9;-1:-1:-1::0;;;;;3396:18:9::2;:5;-1:-1:-1::0;;;;;3396:18:9::2;;3373:41;3352:112;;;;-1:-1:-1::0;;;3352:112:9::2;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;3565:23:9;;::::2;3475:14;3565:23:::0;;;:14:::2;:23;::::0;;;;;;;:30;;::::2;::::0;;;;;;;;;3504:105:::2;::::0;3540:7;;3504:18:::2;:105::i;:::-;3475:134;;3670:1;3661:6;:10;3653:38;;;;-1:-1:-1::0;;;3653:38:9::2;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;3827:23:9;;::::2;;::::0;;;:14:::2;:23;::::0;;;;;;;:30;;::::2;::::0;;;;;;;:42:::2;::::0;3862:6;3827:34:::2;:42::i;:::-;-1:-1:-1::0;;;;;3772:23:9;;::::2;;::::0;;;:14:::2;:23;::::0;;;;;;;:52;;::::2;::::0;;;;;;:97;3908:41:::2;3787:7:::0;3931:9;3942:6;3908:13:::2;:41::i;:::-;-1:-1:-1::0;;307:1:14::1;576:4;:11:::0;-1:-1:-1;;3046:910:9:o;7816:1392:8:-;1024:4:10;-1:-1:-1;;;;;1033:17:10;1016:34;;;995:107;;;;-1:-1:-1;;;995:107:10;;;;;;;:::i;:::-;307:1:14::1;484:4;;:12;476:56;;;;-1:-1:-1::0;;;476:56:14::1;;;;;;;:::i;:::-;348:1;542:4;:13:::0;7992:3:8;1662:4:::2;1632:18;;::::0;::::2;7992:3:::0;1632:18:::2;:::i;:::-;-1:-1:-1::0;;;;;1632:35:8::2;;1611:114;;;;-1:-1:-1::0;;;1611:114:8::2;;;;;;;:::i;:::-;8100:25:::3;8128:22;8146:3;8128:17;:22::i;:::-;8100:50;;8160:126;8191:15;;8220:14;:25;;;8259:17;8160;:126::i;:::-;8400:15;:13;:15::i;:::-;8392:57;;;;-1:-1:-1::0;;;8392:57:8::3;;;;;;;:::i;:::-;8579:14;::::0;;::::3;;8508:39;8562:32:::0;;;:16:::3;:32:::0;;;;;;8692:37:::3;::::0;::::3;::::0;:42;8671:130:::3;;;;-1:-1:-1::0;;;8671:130:8::3;;;;;;;:::i;:::-;8859:53:::0;;;9027:62:::3;:15;9060:19;::::0;::::3;;9027;:62::i;:::-;8987:37;::::0;::::3;:102:::0;9105:96:::3;::::0;::::3;::::0;::::3;::::0;9135:10:::3;::::0;9159:3;;8987:15;;9105:96:::3;:::i;1752:848:11:-:0;1024:4:10;-1:-1:-1;;;;;1033:17:10;1016:34;;;995:107;;;;-1:-1:-1;;;995:107:10;;;;;;;:::i;:::-;307:1:14::1;484:4;;:12;476:56;;;;-1:-1:-1::0;;;476:56:14::1;;;;;;;:::i;:::-;348:1;542:4;:13:::0;1917:25:11::2;1934:7:::0;1917:16:::2;:25::i;:::-;1913:540;;;1979:6;1966:9;:19;1958:58;;;;-1:-1:-1::0;;;1958:58:11::2;;;;;;;:::i;:::-;1913:540;;;2121:9;:14:::0;2113:60:::2;;;;-1:-1:-1::0;;;2113:60:11::2;;;;;;;:::i;:::-;2212:163;2255:7;2284:10;2324:4;2351:6;2212:21;:163::i;:::-;2187:255;;;;-1:-1:-1::0;;;2187:255:11::2;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;2515:22:11;::::2;;::::0;;;:13:::2;:22;::::0;;;;;;:32;;;::::2;::::0;;2562:31;::::2;::::0;::::2;::::0;2529:7;;2541:6;;2562:31:::2;:::i;:::-;;;;;;;;-1:-1:-1::0;;307:1:14::1;576:4;:11:::0;1752:848:11:o;789:226::-;947:7;1024:4:10;-1:-1:-1;;;;;1033:17:10;1016:34;;;995:107;;;;-1:-1:-1;;;995:107:10;;;;;;;:::i;:::-;307:1:14::1;646:4;;:12;638:56;;;;-1:-1:-1::0;;;638:56:14::1;;;;;;;:::i;:::-;977:31:11::2;1000:7;977:22;:31::i;:::-;970:38:::0;789:226;-1:-1:-1;;789:226:11:o;1089:242:12:-;1265:4;1024::10;-1:-1:-1;;;;;1033:17:10;1016:34;;;995:107;;;;-1:-1:-1;;;995:107:10;;;;;;;:::i;:::-;307:1:14::1;646:4;;:12;638:56;;;;-1:-1:-1::0;;;638:56:14::1;;;;;;;:::i;:::-;1292:10:12::2;:32;1303:20;1320:2;1303:16;:20::i;:::-;1292:32:::0;;::::2;::::0;::::2;::::0;;;;;;-1:-1:-1;1292:32:12;;::::2;;::::0;1089:242;-1:-1:-1;;1089:242:12:o;1182:222:11:-;1338:7;1024:4:10;-1:-1:-1;;;;;1033:17:10;1016:34;;;995:107;;;;-1:-1:-1;;;995:107:10;;;;;;;:::i;:::-;307:1:14::1;646:4;;:12;638:56;;;;-1:-1:-1::0;;;638:56:14::1;;;;;;;:::i;:::-;1368:29:11::2;1389:7;1368:20;:29::i;2418:1403:8:-:0;1024:4:10;-1:-1:-1;;;;;1033:17:10;1016:34;;;995:107;;;;-1:-1:-1;;;995:107:10;;;;;;;:::i;:::-;307:1:14::1;484:4;;:12;476:56;;;;-1:-1:-1::0;;;476:56:14::1;;;;;;;:::i;:::-;348:1;542:4;:13:::0;2623:3:8;1385:4:::2;1355:18;;::::0;::::2;2623:3:::0;1355:18:::2;:::i;:::-;-1:-1:-1::0;;;;;1355:35:8::2;;:73;;;;-1:-1:-1::0;1423:5:8::2;::::0;-1:-1:-1;;;;;1423:5:8::2;1410:9;::::0;;;::::2;::::0;::::2;;:::i;:::-;-1:-1:-1::0;;;;;1410:18:8::2;;1355:73;:107;;;;-1:-1:-1::0;1459:3:8::2;::::0;-1:-1:-1;;;;;1459:3:8::2;1448:7;::::0;;;::::2;::::0;::::2;;:::i;:::-;-1:-1:-1::0;;;;;1448:14:8::2;;1355:107;1334:185;;;;-1:-1:-1::0;;;1334:185:8::2;;;;;;;:::i;:::-;2663:15:::3;2681:21;2698:3;2681:16;:21::i;:::-;2663:39;;2780:78;2815:3;2820:7;2829:14;;2845:12;;2780:34;:78::i;:::-;2937:15;:13;:15::i;:::-;2936:16;2928:58;;;;-1:-1:-1::0;;;2928:58:8::3;;;;;;;:::i;:::-;3084:20:::0;;3107:9:::3;::::0;::::3;;-1:-1:-1::0;3063:108:8::3;;;;-1:-1:-1::0;;;3063:108:8::3;;;;;;;:::i;:::-;3187:18;:16;:18::i;:::-;3182:372;;3398:32;:15;3418:11;::::0;::::3;;3398:19;:32::i;:::-;3365:30:::0;:65;3474:69:::3;3511:18;:11;::::0;::::3;;3527:1;3511:15;:18::i;:::-;3474:15;::::0;:19:::3;:69::i;:::-;3444:27:::0;:99;3182:372:::3;3593:14;:41:::0;;;3667:9:::3;::::0;::::3;;3644:20:::0;:32;3714:14:::3;::::0;::::3;;3686:25:::0;:42;3766:48:::3;::::0;::::3;::::0;::::3;::::0;3782:10:::3;::::0;3667:3;;3766:48:::3;:::i;:::-;;;;;;;;-1:-1:-1::0;;307:1:14::1;576:4;:11:::0;-1:-1:-1;;;;;2418:1403:8:o;1238:218:9:-;1394:7;1024:4:10;-1:-1:-1;;;;;1033:17:10;1016:34;;;995:107;;;;-1:-1:-1;;;995:107:10;;;;;;;:::i;:::-;307:1:14::1;646:4;;:12;638:56;;;;-1:-1:-1::0;;;638:56:14::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;;1424:25:9::2;;::::0;;;:16:::2;:25;::::0;;;;;;1238:218::o;1959:209:8:-;2110:7;1024:4:10;-1:-1:-1;;;;;1033:17:10;1016:34;;;995:107;;;;-1:-1:-1;;;995:107:10;;;;;;;:::i;:::-;307:1:14::1;646:4;;:12;638:56;;;;-1:-1:-1::0;;;638:56:14::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;;2140:21:8::2;;::::0;;;:12:::2;:21;::::0;;;;;;1959:209::o;2026:236:9:-;2195:7;1024:4:10;-1:-1:-1;;;;;1033:17:10;1016:34;;;995:107;;;;-1:-1:-1;;;995:107:10;;;;;;;:::i;:::-;307:1:14::1;646:4;;:12;638:56;;;;-1:-1:-1::0;;;638:56:14::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;;2225:23:9;;::::2;;::::0;;;:14:::2;:23;::::0;;;;;;;:30;;;::::2;::::0;;;;;;;;;2026:236::o;1874:172:10:-;2004:7;1024:4;-1:-1:-1;;;;;1033:17:10;1016:34;;;995:107;;;;-1:-1:-1;;;995:107:10;;;;;;;:::i;:::-;307:1:14::1;646:4;;:12;638:56;;;;-1:-1:-1::0;;;638:56:14::1;;;;;;;:::i;:::-;-1:-1:-1::0;2034:5:10::2;::::0;-1:-1:-1;;;;;2034:5:10::2;1874:172:::0;:::o;1749:204:8:-;1888:21;;:::i;:::-;1024:4:10;-1:-1:-1;;;;;1033:17:10;1016:34;;;995:107;;;;-1:-1:-1;;;995:107:10;;;;;;;:::i;:::-;307:1:14::1;646:4;;:12;638:56;;;;-1:-1:-1::0;;;638:56:14::1;;;;;;;:::i;:::-;-1:-1:-1::0;1925:21:8::2;::::0;;::::2;::::0;::::2;::::0;;1932:14:::2;1925:21:::0;;;;;::::2;::::0;::::2;::::0;;;;;;;;;;;;;;;;;;;;;;1749:204;:::o;356:19:14:-;;;;:::o;13483:169:8:-;13589:7;13640:3;13629:15;;;;;;;;:::i;:::-;;;;;;;;;;;;;13619:26;;;;;;13612:33;;13483:169;;;:::o;548:229:27:-;686:4;757:13;-1:-1:-1;;;;;709:61:27;:44;737:4;743:9;709:27;:44::i;:::-;-1:-1:-1;;;;;709:61:27;;;548:229;-1:-1:-1;;;;548:229:27:o;874:176:4:-;932:7;963:5;;;986:6;;;;978:46;;;;-1:-1:-1;;;978:46:4;;;;;;;:::i;:::-;1042:1;874:176;-1:-1:-1;;;874:176:4:o;1706:314:9:-;1822:9;1817:197;1841:1;1837;:5;1817:197;;;1880:14;;1863;;1895:1;1880:17;;;;;;;;;;;;-1:-1:-1;1915:10:9;;1911:93;;1945:44;1958:7;1967;:10;;;1978:1;1967:13;;;;;;;;;;;1982:6;1945:12;:44::i;:::-;-1:-1:-1;1844:3:9;;1817:197;;;;1706:314;;:::o;3481:161:12:-;3580:7;3631:2;3620:14;;;;;;;;:::i;2939:536::-;3113:18;3167:27;3196:6;3156:47;;;;;;;;;:::i;:::-;;;;;;;;;;;;;3146:58;;;;;;3113:91;;3235:48;3261:14;;3235:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;3277:5:12;;3235:10;;:48;-1:-1:-1;;;;;;3277:5:12;;-1:-1:-1;3235:25:12;:48::i;:::-;3214:125;;;;-1:-1:-1;;;3214:125:12;;;;;;;:::i;:::-;3370:44;3396:12;;3370:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;3410:3:12;;3370:10;;:44;-1:-1:-1;;;;;;3410:3:12;;-1:-1:-1;3370:25:12;:44::i;:::-;3349:119;;;;-1:-1:-1;;;3349:119:12;;;;;;;:::i;:::-;2939:536;;;;;;:::o;2268:455:9:-;2379:7;2664:52;2673:9;2684:31;2707:7;2684:22;:31::i;:::-;2664:8;:52::i;2729:311::-;2861:33;2878:7;2887:6;2861:16;:33::i;:::-;2925:57;2955:7;2964:9;2975:6;2925:29;:57::i;:::-;2904:129;;;;-1:-1:-1;;;2904:129:9;;;;;;;:::i;382:54:14:-;307:1;418:4;:11;382:54::o;13310:167:8:-;13414:7;13465:3;13454:15;;;;;;;;:::i;13104:200::-;13152:4;13221:15;13187:14;:30;;;:49;;:110;;;;-1:-1:-1;13270:27:8;;13252:15;:45;13187:110;13168:129;;13104:200;:::o;1021:155:11:-;-1:-1:-1;;;;;1147:22:11;1117:7;1147:22;;;:13;:22;;;;;;;1021:155::o;1495:251::-;-1:-1:-1;;;;;1717:22:11;;1589:7;1717:22;;;:13;:22;;;;;;;;;1677:16;:25;;;;;;1631:31;1731:7;1631:22;:31::i;:::-;:71;:108;;1495:251;-1:-1:-1;;1495:251:11:o;634:157:29:-;695:7;728:5;;;750:8;;;;:34;;-1:-1:-1;;750:34:29;743:41;634:157;-1:-1:-1;;;;634:157:29:o;1321:134:4:-;1379:7;1405:43;1409:1;1412;1405:43;;;;;;;;;;;;;;;;;:3;:43::i;12701:262:8:-;12857:37;12876:5;;12857:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;12883:4:8;;-1:-1:-1;12889:4:8;;-1:-1:-1;12857:18:8;;-1:-1:-1;12857:37:8:i;:::-;12836:120;;;;-1:-1:-1;;;12836:120:8;;;;;;;:::i;:::-;12701:262;;;;:::o;646:111:26:-;-1:-1:-1;;;;;726:24:26;;;646:111::o;1200:442:28:-;1346:4;1381:254;1407:7;1538:6;1566:9;1597:6;1432:189;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;1432:189:28;;;;;;;;;;;;;;-1:-1:-1;;;;;1432:189:28;-1:-1:-1;;;1432:189:28;;;1381:8;:254::i;:::-;1362:273;1200:442;-1:-1:-1;;;;;1200:442:28:o;12104:591:8:-;12318:18;12372:27;12401:7;12361:48;;;;;;;;;:::i;:::-;;;;;;;;;;;;;12351:59;;;;;;12318:92;;12441:52;12467:14;;12441:52;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;12483:9:8;;-1:-1:-1;;;12483:9:8;;;;;;;:::i;:::-;12441:10;;:52;:25;:52::i;:::-;12420:132;;;;-1:-1:-1;;;12420:132:8;;;;;;;:::i;:::-;12583:48;12609:12;;12583:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;12623:7:8;;-1:-1:-1;;;12623:7:8;;;;;;;:::i;12583:48::-;12562:126;;;;-1:-1:-1;;;12562:126:8;;;;;;;:::i;:::-;12104:591;;;;;;;:::o;12969:129::-;13061:30;;13043:15;:48;12969:129;:::o;2180:459:4:-;2238:7;2479:6;2475:45;;-1:-1:-1;2508:1:4;2501:8;;2475:45;2542:5;;;2546:1;2542;:5;:1;2565:5;;;;;:10;2557:56;;;;-1:-1:-1;;;2557:56:4;;;;;;;:::i;783:246:27:-;905:7;928:14;945:28;968:4;945:22;:28::i;:::-;928:45;;990:32;1004:6;1012:9;990:13;:32::i;1462:238:9:-;-1:-1:-1;;;;;1644:23:9;;;;;;;:14;:23;;;;;;;;:34;;;;;;;;;;:49;;1686:6;1644:41;:49::i;:::-;-1:-1:-1;;;;;1585:23:9;;;;;;;:14;:23;;;;;;;;:56;;;;;;;;;;;;;;:108;;;;-1:-1:-1;1462:238:9:o;763:223:26:-;826:7;864:16;872:7;864;:16::i;:::-;:115;;939:40;;-1:-1:-1;;;939:40:26;;-1:-1:-1;;;;;939:25:26;;;;;:40;;973:4;;939:40;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;864:115;;;-1:-1:-1;899:21:26;;763:223;-1:-1:-1;763:223:26:o;391:104:3:-;449:7;479:1;475;:5;:13;;487:1;475:13;;;-1:-1:-1;483:1:3;;391:104;-1:-1:-1;391:104:3:o;1112:120:9:-;-1:-1:-1;;;;;1190:25:9;;;;;;;:16;:25;;;;;:35;;;;;;;1112:120::o;2263:307:26:-;2401:4;2436:16;2444:7;2436;:16::i;:::-;:127;;2522:41;2536:7;2545:9;2556:6;2522:13;:41::i;:::-;2436:127;;;2471:32;2485:9;2496:6;2471:13;:32::i;1746:187:4:-;1832:7;1867:12;1859:6;;;;1851:29;;;;-1:-1:-1;;;1851:29:4;;;;;;;;:::i;:::-;-1:-1:-1;;;1902:5:4;;;1746:187::o;497:779:2:-;588:4;627;588;642:515;666:5;:12;662:1;:16;642:515;;;699:20;722:5;728:1;722:8;;;;;;;;;;;;;;699:31;;765:12;749;:28;745:402;;917:12;931;900:44;;;;;;;;;:::i;:::-;;;;;;;;;;;;;890:55;;;;;;875:70;;745:402;;;1104:12;1118;1087:44;;;;;;;;;:::i;:::-;;;;;;;;;;;;;1077:55;;;;;;1062:70;;745:402;-1:-1:-1;680:3:2;;642:515;;;-1:-1:-1;1249:20:2;;;;497:779;-1:-1:-1;;;497:779:2:o;439:381:28:-;531:4;559:27;578:7;559:18;:27::i;:::-;551:57;;;;-1:-1:-1;;;551:57:28;;;;;;;:::i;:::-;619:12;633:23;660:7;-1:-1:-1;;;;;660:12:28;673:8;660:22;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;618:64;;;;692:48;720:7;729:10;692:27;:48::i;:::-;757:17;;:22;;:56;;;794:10;783:30;;;;;;;;;;;;:::i;1035:303:27:-;1128:7;1325:4;1274:56;;;;;;;;:::i;1064:2068:1:-;1142:7;1203:9;:16;1223:2;1203:22;1199:94;;1241:41;;-1:-1:-1;;;1241:41:1;;;;;;;:::i;1199:94::-;1643:4;1628:20;;1622:27;1688:4;1673:20;;1667:27;1741:4;1726:20;;1720:27;1359:9;1712:36;2659:66;2646:79;;2642:154;;;2741:44;;-1:-1:-1;;;2741:44:1;;;;;;;:::i;2642:154::-;2810:1;:7;;2815:2;2810:7;;:18;;;;;2821:1;:7;;2826:2;2821:7;;2810:18;2806:93;;;2844:44;;-1:-1:-1;;;2844:44:1;;;;;;;:::i;2806:93::-;2993:14;3010:24;3020:4;3026:1;3029;3032;3010:24;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;3010:24:1;;-1:-1:-1;;3010:24:1;;;-1:-1:-1;;;;;;;3052:20:1;;3044:57;;;;-1:-1:-1;;;3044:57:1;;;;;;;:::i;:::-;3119:6;1064:2068;-1:-1:-1;;;;;;1064:2068:1:o;1291:198:26:-;1414:4;1437:45;1455:7;1464:9;1475:6;1437:17;:45::i;992:293::-;1092:4;1113:12;1127:23;1166:9;-1:-1:-1;;;;;1166:14:26;1188:6;1166:33;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1112:87;;;;1209:48;1237:7;1246:10;1209:27;:48::i;:::-;-1:-1:-1;1274:4:26;;992:293;-1:-1:-1;;;;992:293:26:o;718:610:7:-;778:4;1239:20;;1084:66;1278:23;;;;;;:42;;-1:-1:-1;;1305:15:7;;;1270:51;-1:-1:-1;;718:610:7:o;344:244:30:-;460:7;455:127;;546:10;540:17;533:4;521:10;517:21;510:48;492:80;344:244;;:::o;1648:374:28:-;1766:4;1801:214;1827:7;1946:9;1977:6;1852:149;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;1852:149:28;;;;;;;;;;;;;;-1:-1:-1;;;;;1852:149:28;-1:-1:-1;;;1852:149:28;;;1801:8;:214::i;-1:-1:-1:-;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;5:130::-;72:20;;97:33;72:20;97:33;:::i;470:352::-;;;600:3;593:4;585:6;581:17;577:27;567:2;;-1:-1;;608:12;567:2;-1:-1;638:20;;-1:-1;;;;;667:30;;664:2;;;-1:-1;;700:12;664:2;744:4;736:6;732:17;720:29;;795:3;744:4;;779:6;775:17;736:6;761:32;;758:41;755:2;;;812:1;;802:12;755:2;560:262;;;;;:::o;4552:336::-;;;4666:3;4659:4;4651:6;4647:17;4643:27;4633:2;;-1:-1;;4674:12;4633:2;-1:-1;4704:20;;-1:-1;;;;;4733:30;;4730:2;;;-1:-1;;4766:12;4730:2;4810:4;4802:6;4798:17;4786:29;;4861:3;4810:4;4841:17;4802:6;4827:32;;4824:41;4821:2;;;4878:1;;4868:12;6075:168;;6195:3;6186:6;6181:3;6177:16;6173:26;6170:2;;;-1:-1;;6202:12;6170:2;-1:-1;6222:15;6163:80;-1:-1;6163:80::o;6299:169::-;;6420:3;6411:6;6406:3;6402:16;6398:26;6395:2;;;-1:-1;;6427:12;6503:164;;6619:3;6610:6;6605:3;6601:16;6597:26;6594:2;;;-1:-1;;6626:12;6952:241;;7056:2;7044:9;7035:7;7031:23;7027:32;7024:2;;;-1:-1;;7062:12;7024:2;85:6;72:20;97:33;124:5;97:33;:::i;7464:366::-;;;7585:2;7573:9;7564:7;7560:23;7556:32;7553:2;;;-1:-1;;7591:12;7553:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;7643:63;-1:-1;7743:2;7782:22;;72:20;97:33;72:20;97:33;:::i;:::-;7751:63;;;;7547:283;;;;;:::o;7837:507::-;;;;7983:2;7971:9;7962:7;7958:23;7954:32;7951:2;;;-1:-1;;7989:12;7951:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;8041:63;-1:-1;8141:2;8180:22;;72:20;97:33;72:20;97:33;:::i;:::-;8149:63;-1:-1;8249:2;8296:22;;217:20;242:41;217:20;242:41;:::i;:::-;8257:71;;;;7945:399;;;;;:::o;8351:366::-;;;8472:2;8460:9;8451:7;8447:23;8443:32;8440:2;;;-1:-1;;8478:12;8440:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;8530:63;8630:2;8669:22;;;;6741:20;;-1:-1;;;8434:283::o;8724:257::-;;8836:2;8824:9;8815:7;8811:23;8807:32;8804:2;;;-1:-1;;8842:12;8804:2;4347:6;4341:13;95112:5;92344:13;92337:21;95090:5;95087:32;95077:2;;-1:-1;;95123:12;8988:241;;9092:2;9080:9;9071:7;9067:23;9063:32;9060:2;;;-1:-1;;9098:12;9060:2;-1:-1;4468:20;;9054:175;-1:-1;9054:175::o;9236:292::-;;9365:3;9353:9;9344:7;9340:23;9336:33;9333:2;;;-1:-1;;9372:12;9333:2;5067:20;5082:4;5067:20;:::i;:::-;2714:3;2707:4;2699:6;2695:17;2691:27;2681:2;;-1:-1;;2722:12;2681:2;2775:78;5082:4;2775:78;:::i;:::-;2859:16;2918:17;5082:4;2951:3;2947:27;2976:3;2947:27;2944:36;2941:2;;;-1:-1;;2983:12;2941:2;-1:-1;3003:206;2756:4;3025:1;3022:13;3003:206;;;6741:20;;3096:50;;84823:4;3160:14;;;;3188;;;;3050:1;3043:9;3003:206;;;3007:14;5171:72;5153:16;5146:98;980:3;961:17;2951:3;961:17;957:27;947:2;;-1:-1;;988:12;947:2;1041:86;5082:4;1041:86;:::i;:::-;1133:16;-1:-1;1133:16;;-1:-1;1192:17;-1:-1;9365:3;1221:27;;1218:36;-1:-1;1215:2;;;-1:-1;;1257:12;1215:2;-1:-1;1277:214;2756:4;1299:1;1296:13;1277:214;;;230:6;217:20;242:41;277:5;242:41;:::i;:::-;1370:58;;84823:4;1442:14;;;;1470;;;;;3050:1;1317:9;1277:214;;;-1:-1;;84823:4;5318:16;;5311:106;-1:-1;5322:5;9327:201;-1:-1;;;9327:201::o;9535:314::-;;9675:3;9663:9;9654:7;9650:23;9646:33;9643:2;;;-1:-1;;9682:12;9643:2;5627:20;5642:4;5627:20;:::i;:::-;3368:3;3361:4;3353:6;3349:17;3345:27;3335:2;;-1:-1;;3376:12;3335:2;3429:78;5642:4;3429:78;:::i;:::-;3513:16;3572:17;5642:4;3605:3;3601:27;3630:3;3601:27;3598:36;3595:2;;;-1:-1;;3637:12;3595:2;-1:-1;3657:217;3410:4;3679:1;3676:13;3657:217;;;6889:13;;3750:61;;84823:4;3825:14;;;;3853;;;;3704:1;3697:9;3657:217;;;3661:14;5731:83;5713:16;5706:109;1666:3;1647:17;3605:3;1647:17;1643:27;1633:2;;-1:-1;;1674:12;1633:2;1727:86;5642:4;1727:86;:::i;:::-;1819:16;-1:-1;1819:16;;-1:-1;1878:17;-1:-1;9675:3;1907:27;;1904:36;-1:-1;1901:2;;;-1:-1;;1943:12;1901:2;-1:-1;1963:225;3410:4;1985:1;1982:13;1963:225;;;387:6;381:13;399:41;434:5;399:41;:::i;:::-;2056:69;;84823:4;2139:14;;;;2167;;;;;3704:1;2003:9;1963:225;;9856:961;;;;;;10100:2;10088:9;10079:7;10075:23;10071:32;10068:2;;;-1:-1;;10106:12;10068:2;10164:17;10151:31;-1:-1;;;;;10202:18;10194:6;10191:30;10188:2;;;-1:-1;;10224:12;10188:2;10254:89;10335:7;10326:6;10315:9;10311:22;10254:89;:::i;:::-;10244:99;;10408:2;10397:9;10393:18;10380:32;10366:46;;10202:18;10424:6;10421:30;10418:2;;;-1:-1;;10454:12;10418:2;10492:80;10564:7;10555:6;10544:9;10540:22;10492:80;:::i;:::-;10474:98;;-1:-1;10474:98;-1:-1;10637:2;10622:18;;10609:32;;-1:-1;10650:30;;;10647:2;;;-1:-1;;10683:12;10647:2;;10721:80;10793:7;10784:6;10773:9;10769:22;10721:80;:::i;:::-;10062:755;;;;-1:-1;10062:755;;-1:-1;10703:98;;;10062:755;-1:-1;;;10062:755::o;10824:897::-;;;;;;11036:2;11024:9;11015:7;11011:23;11007:32;11004:2;;;-1:-1;;11042:12;11004:2;11100:17;11087:31;-1:-1;;;;;11138:18;11130:6;11127:30;11124:2;;;-1:-1;;11160:12;11124:2;11190:89;11271:7;11262:6;11251:9;11247:22;11190:89;:::i;:::-;11180:99;;11344:2;11333:9;11329:18;11316:32;11302:46;;11138:18;11360:6;11357:30;11354:2;;;-1:-1;;11390:12;11354:2;11428:64;11484:7;11475:6;11464:9;11460:22;11428:64;:::i;:::-;11410:82;;-1:-1;11410:82;-1:-1;11557:2;11542:18;;11529:32;;-1:-1;11570:30;;;11567:2;;;-1:-1;;11603:12;11567:2;;11641:64;11697:7;11688:6;11677:9;11673:22;11641:64;:::i;11728:598::-;;;;11921:3;11909:9;11900:7;11896:23;11892:33;11889:2;;;-1:-1;;11928:12;11889:2;11990:90;12072:7;12048:22;11990:90;:::i;:::-;11980:100;;12145:3;12134:9;12130:19;12117:33;-1:-1;;;;;12162:6;12159:30;12156:2;;;-1:-1;;12192:12;12156:2;12230:80;12302:7;12293:6;12282:9;12278:22;12230:80;:::i;:::-;11883:443;;12212:98;;-1:-1;12212:98;;-1:-1;;;;11883:443::o;12333:1066::-;;;;;;;;12582:3;12570:9;12561:7;12557:23;12553:33;12550:2;;;-1:-1;;12589:12;12550:2;12651:90;12733:7;12709:22;12651:90;:::i;:::-;12641:100;;12806:3;12795:9;12791:19;12778:33;-1:-1;;;;;12831:18;12823:6;12820:30;12817:2;;;-1:-1;;12853:12;12817:2;12891:64;12947:7;12938:6;12927:9;12923:22;12891:64;:::i;:::-;12873:82;;-1:-1;12873:82;-1:-1;13020:3;13005:19;;12992:33;;-1:-1;13034:30;;;13031:2;;;-1:-1;;13067:12;13031:2;13105:64;13161:7;13152:6;13141:9;13137:22;13105:64;:::i;:::-;13087:82;;-1:-1;13087:82;-1:-1;13234:3;13219:19;;13206:33;;-1:-1;13248:30;;;13245:2;;;-1:-1;;13281:12;13245:2;;13319:64;13375:7;13366:6;13355:9;13351:22;13319:64;:::i;:::-;12544:855;;;;-1:-1;12544:855;;-1:-1;12544:855;;;;13301:82;;-1:-1;;;12544:855::o;13406:391::-;;13542:2;13530:9;13521:7;13517:23;13513:32;13510:2;;;-1:-1;;13548:12;13510:2;13606:17;13593:31;-1:-1;;;;;13636:6;13633:30;13630:2;;;-1:-1;;13666:12;13630:2;13696:85;13773:7;13764:6;13753:9;13749:22;13696:85;:::i;13804:889::-;;;;;;14012:2;14000:9;13991:7;13987:23;13983:32;13980:2;;;-1:-1;;14018:12;13980:2;14076:17;14063:31;-1:-1;;;;;14114:18;14106:6;14103:30;14100:2;;;-1:-1;;14136:12;14100:2;14166:85;14243:7;14234:6;14223:9;14219:22;14166:85;:::i;14700:263::-;;14815:2;14803:9;14794:7;14790:23;14786:32;14783:2;;;-1:-1;;14821:12;14783:2;-1:-1;6889:13;;14777:186;-1:-1;14777:186::o;15983:127::-;-1:-1;;;;;92662:54;16060:45;;16054:56::o;16378:645::-;;87067:6;87062:3;87055:19;87104:4;;87099:3;87095:14;16515:83;;16683:21;-1:-1;16710:291;16735:6;16732:1;16729:13;16710:291;;;85:6;72:20;97:33;124:5;97:33;:::i;:::-;-1:-1;;;;;92662:54;16060:45;;15338:14;;;;88887:12;;;;678:18;16750:9;16710:291;;;-1:-1;17007:10;;16502:521;-1:-1;;;;;16502:521::o;19347:855::-;;87067:6;87062:3;87055:19;87104:4;;87099:3;87095:14;19536:108;;19756:21;-1:-1;19783:397;19808:6;19805:1;19802:13;19783:397;;;20389:4;;93502:3;93497;93484:30;93545:16;;;93538:27;;;40089:16;;;;-1:-1;;18200:321;85812:4;18222:1;18219:13;18200:321;;;230:6;217:20;242:41;277:5;242:41;:::i;:::-;-1:-1;;;;;92662:54;16060:45;;89031:12;;;;678:18;18240:9;;;;;15156:14;;18200:321;;;-1:-1;;;15633:4;15624:14;;;;86807;;;;;19830:1;19823:9;19783:397;;21120:447;87055:19;;;21120:447;-1:-1;;;;;21348:78;;21345:2;;;-1:-1;;21429:12;21345:2;87104:4;21464:6;21460:17;93507:6;93502:3;87104:4;87099:3;87095:14;93484:30;93545:16;;;;87104:4;93545:16;93538:27;;;-1:-1;93545:16;;21242:325;-1:-1;21242:325::o;22199:277::-;;87067:6;87062:3;87055:19;93507:6;93502:3;87104:4;87099:3;87095:14;93484:30;-1:-1;87104:4;93554:6;87099:3;93545:16;;93538:27;87104:4;94519:7;;94523:2;22462:6;94503:14;94499:28;87099:3;22431:39;;22424:46;;22289:187;;;;;:::o;23153:343::-;;23295:5;86158:12;87067:6;87062:3;87055:19;23388:52;23433:6;87104:4;87099:3;87095:14;87104:4;23414:5;23410:16;23388:52;:::i;:::-;94519:7;94503:14;-1:-1;;94499:28;23452:39;;;;87104:4;23452:39;;23243:253;-1:-1;;23243:253::o;39568:692::-;20389:4;93502:3;93497;93484:30;93563:1;20389:4;93545:16;;;93538:27;;;40089:16;;;;18200:321;85812:4;18222:1;18219:13;18200:321;;;89040:2;230:6;217:20;242:41;277:5;242:41;:::i;:::-;-1:-1;;;;;92662:54;16060:45;;89031:12;;;;15156:14;;;;678:18;18240:9;18200:321;;;18204:14;;;39676:584;;:::o;42812:1345::-;43049:23;;21848:37;;43289:4;43278:16;;43272:23;43439:4;43430:14;;21848:37;43517:4;43506:16;;43500:23;43667:4;43658:14;;21848:37;43750:4;43739:16;;43733:23;43900:4;43891:14;;21848:37;43980:4;43969:16;43963:23;44130:4;44121:14;;;21848:37;42939:1218::o;44253:3170::-;;44424:6;88896:2;44535:16;88887:12;44558:63;44606:14;88861:39;88887:12;44535:16;88861:39;:::i;:::-;44558:63;:::i;:::-;44684:50;44717:16;44710:5;44684:50;:::i;:::-;44664:70;;44740:63;88896:2;44792:3;44788:14;44774:12;44740:63;:::i;:::-;;44864:50;44908:4;44901:5;44897:16;44890:5;44864:50;:::i;:::-;44920:63;44908:4;44972:3;44968:14;44954:12;44920:63;:::i;:::-;;45063:77;45134:4;45127:5;45123:16;45116:5;45063:77;:::i;:::-;44424:6;45134:4;45164:3;45160:14;45153:38;45206:119;44424:6;44419:3;44415:16;45306:12;45292;45206:119;:::i;:::-;45198:127;;;;45411:104;45509:4;45502:5;45498:16;45491:5;45411:104;:::i;:::-;45561:3;45555:4;45551:14;45509:4;45539:3;45535:14;45528:38;45581:171;45747:4;45733:12;45719;45581:171;:::i;:::-;45573:179;;;;45848:77;45919:4;45912:5;45908:16;45901:5;45848:77;:::i;:::-;45971:3;45965:4;45961:14;45919:4;45949:3;45945:14;45938:38;45991:119;46105:4;46091:12;46077;45991:119;:::i;:::-;45983:127;;;;46206:77;46277:4;46270:5;46266:16;46259:5;46206:77;:::i;:::-;46329:3;46323:4;46319:14;46277:4;46307:3;46303:14;46296:38;46349:119;46463:4;46449:12;46435;46349:119;:::i;:::-;46341:127;;;;46558:77;46629:4;46622:5;46618:16;46611:5;46558:77;:::i;:::-;46681:3;46675:4;46671:14;46629:4;46659:3;46655:14;46648:38;46701:119;46815:4;46801:12;46787;46701:119;:::i;:::-;46935:6;46924:18;;;6741:20;46997:16;;;21848:37;47121:6;47110:18;;;6741:20;47183:16;;;21848:37;47312:6;47301:18;;;4468:20;47374:16;;;;21848:37;;;;-1:-1;46693:127;;44397:3026;-1:-1;;;44397:3026::o;47521:1977::-;85:6;72:20;97:33;124:5;97:33;:::i;:::-;-1:-1;;;;;92662:54;;;16060:45;;88896:2;88887:12;;;4468:20;48055:14;;;21848:37;48190:4;48179:16;;72:20;;97:33;72:20;97:33;:::i;:::-;92662:54;48190:4;48250:14;;16060:45;48332:50;48376:4;48365:16;;48369:5;48332:50;:::i;:::-;48388:63;48376:4;48440:3;48436:14;48422:12;48388:63;:::i;:::-;;48518:50;48562:4;48555:5;48551:16;48544:5;48518:50;:::i;:::-;48574:63;48562:4;48626:3;48622:14;48608:12;48574:63;:::i;:::-;;48702:50;48746:4;48739:5;48735:16;48728:5;48702:50;:::i;:::-;48758:63;48746:4;48810:3;48806:14;48792:12;48758:63;:::i;:::-;;48969:115;48957:4;49073:3;49069:14;48957:4;48950:5;48946:16;48969:115;:::i;:::-;49201:6;49190:18;;;6741:20;49263:16;;;21848:37;49398:6;49387:18;;;4468:20;49460:16;;21848:37;47659:1839::o;50362:896::-;50606:23;;21848:37;;50862:4;50851:16;;50845:23;51012:4;51003:14;;21848:37;51090:4;51079:16;51073:23;91873:4;91862:16;92344:13;92337:21;51231:4;51222:14;;;21630:34;50495:763::o;51314:1632::-;;85:6;72:20;97:33;124:5;97:33;:::i;:::-;-1:-1;;;;;92662:54;;;16060:45;;88896:2;88887:12;;72:20;;97:33;72:20;97:33;:::i;:::-;92662:54;;;88896:2;51841:14;;16060:45;88887:12;;;72:20;;97:33;72:20;97:33;:::i;:::-;92673:42;92666:5;92662:54;88887:12;52055:3;52051:14;16060:45;52174:4;52167:5;52163:16;6741:20;52174:4;52238:3;52234:14;21848:37;52356:4;52349:5;52345:16;6741:20;52356:4;52420:3;52416:14;21848:37;52539:4;52532:5;52528:16;72:20;63:29;;97:33;124:5;97:33;:::i;:::-;92662:54;52539:4;52599:14;;16060:45;52749:4;52738:16;;91145:17;91210:14;91206:29;;;-1:-1;;91202:48;91178:73;;91168:2;;-1:-1;;91255:12;91168:2;91284:33;;91339:19;;-1:-1;;;;;91398:30;;91395:2;;;-1:-1;;91431:12;91395:2;91488:17;91210:14;91468:38;91458:8;91454:53;91451:2;;;-1:-1;;91510:12;91451:2;51477:4;52749;52779:3;52775:14;52768:38;52821:87;51477:4;51472:3;51468:14;52889:12;88896:2;91377:5;91373:16;52821:87;:::i;53297:392::-;21848:37;;;53550:2;53541:12;;21848:37;53652:12;;;53441:248::o;53696:291::-;;93507:6;93502:3;93497;93484:30;93545:16;;93538:27;;;93545:16;53840:147;-1:-1;53840:147::o;53994:271::-;;23663:5;86158:12;23774:52;23819:6;23814:3;23807:4;23800:5;23796:16;23774:52;:::i;:::-;23838:16;;;;;54128:137;-1:-1;;54128:137::o;54272:520::-;35238:66;35218:87;;35202:2;35324:12;;21848:37;;;;54755:12;;;54489:303::o;54799:379::-;55163:10;54987:191::o;55185:222::-;-1:-1;;;;;92662:54;;;;16060:45;;55312:2;55297:18;;55283:124::o;55414:771::-;-1:-1;;;;;92662:54;;15913:58;;55736:3;55863:2;55848:18;;55841:48;;;55414:771;;55903:128;;55721:19;;56017:6;55903:128;:::i;:::-;55895:136;;56042:133;56171:2;56160:9;56156:18;56147:6;56042:133;:::i;56192:1051::-;-1:-1;;;;;92662:54;;15913:58;;56602:3;56729:2;56714:18;;56707:48;;;56192:1051;;56769:128;56587:19;;;56883:6;56769:128;:::i;:::-;56761:136;;56908:133;57037:2;57026:9;57022:18;57013:6;56908:133;:::i;:::-;57090:9;57084:4;57080:20;57074:3;57063:9;57059:19;57052:49;57115:118;57228:4;57219:6;57211;57115:118;:::i;:::-;57107:126;56573:670;-1:-1;;;;;;;;56573:670::o;57250:740::-;-1:-1;;;;;92662:54;;15913:58;;57580:3;57565:19;;57685:144;57825:2;57810:18;;57801:6;57685:144;:::i;:::-;57840:140;57975:3;57964:9;57960:19;57951:6;57840:140;:::i;57997:1384::-;-1:-1;;;;;92662:54;;15913:58;;57997:1384;58517:3;58762:2;58622:144;58747:18;;;58738:6;58622:144;:::i;:::-;58777:140;58912:3;58901:9;58897:19;58888:6;58777:140;:::i;:::-;58517:3;58950;58939:9;58935:19;58928:49;58991:86;58517:3;58506:9;58502:19;59063:6;59055;58991:86;:::i;:::-;58983:94;;59126:9;59120:4;59116:20;59110:3;59099:9;59095:19;59088:49;59151:86;59232:4;59223:6;59215;59151:86;:::i;:::-;41265:23;;59143:94;;-1:-1;41265:23;-1:-1;20826:1;59366:3;59351:19;;20811:258;85812:4;20833:1;20830:13;20811:258;;;20897:13;;21848:37;;86419:14;;;;20858:1;20851:9;;;;;15806:14;;20811:258;;;20815:14;;58762:2;41473:5;41469:16;41463:23;41443:43;;41602:14;59355:9;41602:14;20826:1;19000:282;85812:4;19022:1;19019:13;19000:282;;;92136:24;19092:6;19086:13;92136:24;:::i;:::-;16060:45;;86419:14;;;;15156;;;;20858:1;19040:9;19000:282;;;19004:14;;;;58488:893;;;;;;;;;;;:::o;59388:444::-;-1:-1;;;;;92662:54;;;16060:45;;92662:54;;;;59735:2;59720:18;;16060:45;59818:2;59803:18;;21848:37;;;;59571:2;59556:18;;59542:290::o;59839:333::-;-1:-1;;;;;92662:54;;;;16060:45;;60158:2;60143:18;;21848:37;59994:2;59979:18;;59965:207::o;60179:210::-;92344:13;;92337:21;21630:34;;60300:2;60285:18;;60271:118::o;60396:548::-;21848:37;;;91873:4;91862:16;;;;60764:2;60749:18;;53250:35;60847:2;60832:18;;21848:37;60930:2;60915:18;;21848:37;60603:3;60588:19;;60574:370::o;60951:736::-;;61208:2;61229:17;61222:47;61283:76;61208:2;61197:9;61193:18;61345:6;61283:76;:::i;:::-;61407:9;61401:4;61397:20;61392:2;61381:9;61377:18;61370:48;61432:86;61513:4;61504:6;61496;61432:86;:::i;:::-;61424:94;;61566:9;61560:4;61556:20;61551:2;61540:9;61536:18;61529:48;61591:86;61672:4;61663:6;61655;61591:86;:::i;61694:367::-;61866:2;61851:18;;94738:1;94728:12;;94718:2;;94744:9;94718:2;23954:67;;;62047:2;62032:18;21848:37;61837:224;:::o;62068:310::-;;62215:2;62236:17;62229:47;62290:78;62215:2;62204:9;62200:18;62354:6;62290:78;:::i;62385:416::-;62585:2;62599:47;;;24612:2;62570:18;;;87055:19;24648:26;87095:14;;;24628:47;24694:12;;;62556:245::o;62808:416::-;63008:2;63022:47;;;24945:2;62993:18;;;87055:19;24981:34;87095:14;;;24961:55;-1:-1;;;25036:12;;;25029:28;25076:12;;;62979:245::o;63231:416::-;63431:2;63445:47;;;25327:2;63416:18;;;87055:19;25363:32;87095:14;;;25343:53;25415:12;;;63402:245::o;63654:416::-;63854:2;63868:47;;;25666:2;63839:18;;;87055:19;25702:31;87095:14;;;25682:52;25753:12;;;63825:245::o;64077:416::-;64277:2;64291:47;;;26004:2;64262:18;;;87055:19;-1:-1;;;87095:14;;;26020:41;26080:12;;;64248:245::o;64500:416::-;64700:2;64714:47;;;26331:2;64685:18;;;87055:19;26367:33;87095:14;;;26347:54;26420:12;;;64671:245::o;64923:416::-;65123:2;65137:47;;;26671:2;65108:18;;;87055:19;26707:31;87095:14;;;26687:52;26758:12;;;65094:245::o;65346:416::-;65546:2;65560:47;;;65531:18;;;87055:19;27045:34;87095:14;;;27025:55;27099:12;;;65517:245::o;65769:416::-;65969:2;65983:47;;;27350:2;65954:18;;;87055:19;27386:33;87095:14;;;27366:54;27439:12;;;65940:245::o;66192:416::-;66392:2;66406:47;;;27690:2;66377:18;;;87055:19;27726:31;87095:14;;;27706:52;27777:12;;;66363:245::o;66615:416::-;66815:2;66829:47;;;28028:2;66800:18;;;87055:19;28064:27;87095:14;;;28044:48;28111:12;;;66786:245::o;67038:416::-;67238:2;67252:47;;;28362:2;67223:18;;;87055:19;28398:33;87095:14;;;28378:54;28451:12;;;67209:245::o;67461:416::-;67661:2;67675:47;;;28702:2;67646:18;;;87055:19;28738:29;87095:14;;;28718:50;28787:12;;;67632:245::o;67884:416::-;68084:2;68098:47;;;29038:2;68069:18;;;87055:19;29074:34;87095:14;;;29054:55;-1:-1;;;29129:12;;;29122:33;29174:12;;;68055:245::o;68307:416::-;68507:2;68521:47;;;29425:2;68492:18;;;87055:19;29461:33;87095:14;;;29441:54;29514:12;;;68478:245::o;68730:416::-;68930:2;68944:47;;;29765:2;68915:18;;;87055:19;29801:33;87095:14;;;29781:54;29854:12;;;68901:245::o;69153:416::-;69353:2;69367:47;;;30105:2;69338:18;;;87055:19;30141:34;87095:14;;;30121:55;-1:-1;;;30196:12;;;30189:26;30234:12;;;69324:245::o;69576:416::-;69776:2;69790:47;;;30485:2;69761:18;;;87055:19;30521:34;87095:14;;;30501:55;-1:-1;;;30576:12;;;30569:32;30620:12;;;69747:245::o;69999:416::-;70199:2;70213:47;;;30871:2;70184:18;;;87055:19;30907:30;87095:14;;;30887:51;30957:12;;;70170:245::o;70422:416::-;70622:2;70636:47;;;31208:2;70607:18;;;87055:19;31244:30;87095:14;;;31224:51;31294:12;;;70593:245::o;70845:416::-;71045:2;71059:47;;;31545:2;71030:18;;;87055:19;31581:34;87095:14;;;31561:55;-1:-1;;;31636:12;;;31629:25;31673:12;;;71016:245::o;71268:416::-;71468:2;71482:47;;;31924:2;71453:18;;;87055:19;31960:31;87095:14;;;31940:52;32011:12;;;71439:245::o;71691:416::-;71891:2;71905:47;;;32262:2;71876:18;;;87055:19;32298:28;87095:14;;;32278:49;32346:12;;;71862:245::o;72114:416::-;72314:2;72328:47;;;32597:2;72299:18;;;87055:19;32633:34;87095:14;;;32613:55;-1:-1;;;32688:12;;;32681:26;32726:12;;;72285:245::o;72537:416::-;72737:2;72751:47;;;32977:2;72722:18;;;87055:19;33013:34;87095:14;;;32993:55;-1:-1;;;33068:12;;;33061:25;33105:12;;;72708:245::o;72960:416::-;73160:2;73174:47;;;33356:2;73145:18;;;87055:19;33392:34;87095:14;;;33372:55;-1:-1;;;33447:12;;;33440:29;33488:12;;;73131:245::o;73383:416::-;73583:2;73597:47;;;33739:2;73568:18;;;87055:19;33775:34;87095:14;;;33755:55;-1:-1;;;33830:12;;;33823:25;33867:12;;;73554:245::o;73806:416::-;74006:2;74020:47;;;34118:2;73991:18;;;87055:19;-1:-1;;;87095:14;;;34134:40;34193:12;;;73977:245::o;74229:416::-;74429:2;74443:47;;;34444:2;74414:18;;;87055:19;34480:33;87095:14;;;34460:54;34533:12;;;74400:245::o;74652:416::-;74852:2;74866:47;;;34784:2;74837:18;;;87055:19;34820:34;87095:14;;;34800:55;-1:-1;;;34875:12;;;34868:28;34915:12;;;74823:245::o;75075:416::-;75275:2;75289:47;;;35575:2;75260:18;;;87055:19;-1:-1;;;87095:14;;;35591:38;35648:12;;;75246:245::o;75498:416::-;75698:2;75712:47;;;35899:2;75683:18;;;87055:19;35935:32;87095:14;;;35915:53;35987:12;;;75669:245::o;75921:416::-;76121:2;76135:47;;;36238:2;76106:18;;;87055:19;36274:34;87095:14;;;36254:55;-1:-1;;;36329:12;;;36322:33;36374:12;;;76092:245::o;76344:416::-;76544:2;76558:47;;;36625:2;76529:18;;;87055:19;36661:26;87095:14;;;36641:47;36707:12;;;76515:245::o;76767:416::-;76967:2;76981:47;;;37263:2;76952:18;;;87055:19;-1:-1;;;87095:14;;;37279:45;37343:12;;;76938:245::o;77190:416::-;77390:2;77404:47;;;37594:2;77375:18;;;87055:19;37630:34;87095:14;;;37610:55;-1:-1;;;37685:12;;;37678:27;37724:12;;;77361:245::o;77613:416::-;77813:2;77827:47;;;37975:2;77798:18;;;87055:19;38011:34;87095:14;;;37991:55;-1:-1;;;38066:12;;;38059:25;38103:12;;;77784:245::o;78036:416::-;78236:2;78250:47;;;78221:18;;;87055:19;38390:34;87095:14;;;38370:55;38444:12;;;78207:245::o;78459:416::-;78659:2;78673:47;;;38695:2;78644:18;;;87055:19;38731:28;87095:14;;;38711:49;38779:12;;;78630:245::o;78882:416::-;79082:2;79096:47;;;79067:18;;;87055:19;39066:34;87095:14;;;39046:55;39120:12;;;79053:245::o;79305:416::-;79505:2;79519:47;;;39371:2;79490:18;;;87055:19;39407:34;87095:14;;;39387:55;-1:-1;;;39462:12;;;39455:29;39503:12;;;79476:245::o;79728:327::-;79907:3;79892:19;;79922:123;79896:9;80018:6;79922:123;:::i;80062:351::-;;80253:3;80242:9;80238:19;80230:27;;41971:16;41965:23;21855:3;21848:37;42137:4;42130:5;42126:16;42120:23;42137:4;42201:3;42197:14;21848:37;42297:4;42290:5;42286:16;42280:23;42297:4;42361:3;42357:14;21848:37;42462:4;42455:5;42451:16;42445:23;42462:4;42526:3;42522:14;21848:37;42624:4;42617:5;42613:16;42607:23;42624:4;42688:3;42684:14;21848:37;80224:189;;;;:::o;80420:410::-;;80617:2;80638:17;80631:47;80692:128;80617:2;80606:9;80602:18;80806:6;80692:128;:::i;80837:367::-;81036:3;81021:19;;81051:143;81025:9;81167:6;81051:143;:::i;81211:354::-;49830:23;;21848:37;;50018:4;50007:16;;;50001:23;50078:14;;;21848:37;50178:4;50167:16;;;50161:23;92344:13;92337:21;50232:14;;;21630:34;;;;81404:2;81389:18;;81375:190::o;81572:394::-;;81761:2;81782:17;81775:47;81836:120;81761:2;81750:9;81746:18;81942:6;81836:120;:::i;81973:505::-;;82190:2;82211:17;82204:47;82265:120;82190:2;82179:9;82175:18;82371:6;82265:120;:::i;:::-;82257:128;;21878:5;82464:2;82453:9;82449:18;21848:37;82161:317;;;;;:::o;82485:222::-;21848:37;;;82612:2;82597:18;;82583:124::o;82714:522::-;;;82865:11;82852:25;91202:48;;82940:8;82924:14;82920:29;82916:48;82896:18;82892:73;82882:2;;-1:-1;;82969:12;82882:2;82996:33;;83050:18;;;-1:-1;;;;;;83077:30;;83074:2;;;-1:-1;;83110:12;83074:2;82955:4;83138:13;;;;-1:-1;83190:17;;82924:14;83170:38;83160:49;;83157:2;;;83222:1;;83212:12;83243:549;;;83421:11;83408:25;91202:48;;83496:8;83480:14;83476:29;83472:48;83452:18;83448:73;83438:2;;-1:-1;;83525:12;83438:2;83552:33;;83606:18;;;-1:-1;;;;;;83633:30;;83630:2;;;-1:-1;;83666:12;83630:2;83511:4;83694:13;;-1:-1;83758:4;83746:17;;83480:14;83726:38;83716:49;;83713:2;;;83778:1;;83768:12;84328:256;84390:2;84384:9;84416:17;;;-1:-1;;;;;84476:34;;84512:22;;;84473:62;84470:2;;;84548:1;;84538:12;84470:2;84390;84557:22;84368:216;;-1:-1;84368:216::o;88787:119::-;;85:6;72:20;97:33;124:5;97:33;:::i;89059:517::-;;;89199:3;89186:17;91202:48;;89267:8;89251:14;89247:29;89243:48;89223:18;89219:73;89209:2;;-1:-1;;89296:12;89209:2;89325:33;;89282:4;89414:16;;;-1:-1;89380:19;;-1:-1;;;;;;89439:30;;89436:2;;;89482:1;;89472:12;89436:2;89282:4;89533:6;89529:17;89251:14;89509:38;89499:8;89495:53;89492:2;;;89561:1;;89551:12;89710:544;;;89877:3;89864:17;91202:48;;89945:8;89929:14;89925:29;89921:48;89901:18;89897:73;89887:2;;-1:-1;;89974:12;89887:2;90003:33;;89960:4;90092:16;;;-1:-1;90058:19;;-1:-1;;;;;;90117:30;;90114:2;;;90160:1;;90150:12;90114:2;90219:4;90211:6;90207:17;89929:14;90187:38;90177:8;90173:53;90170:2;;;90239:1;;90229:12;92600:121;-1:-1;;;;;92662:54;;92645:76::o;93580:268::-;93645:1;93652:101;93666:6;93663:1;93660:13;93652:101;;;93733:11;;;93727:18;93714:11;;;93707:39;93688:2;93681:10;93652:101;;;93768:6;93765:1;93762:13;93759:2;;;-1:-1;;93645:1;93815:16;;93808:27;93629:219::o;94767:117::-;-1:-1;;;;;92662:54;;94826:35;;94816:2;;94875:1;;94865:12;94816:2;94810:74;:::o

ipfs://0c5761a7a244ea0132fa44dddcf0e7db8a07d95db5eae27e73fff5d050f1145c