Contract 0xd105b6B42206dfA6Db00E6a4823bC88eFAC00476

 
Ad
Crypto.com
Txn Hash
Block
From
To
Value
0x0953a4e84f1c1b11a6799e3332a63f87a03b2f21021487fba36471bd36cb2663115515142020-12-29 22:14:3465 days 14 hrs ago0xd4b33434cb36df9286ef5132fcfb8062c96ac56e IN  Contract Creation0 Ether0.18644059252
[ Download CSV Export 
View more zero value Internal Transactions in Advanced View mode
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
ChannelMastercopy

Compiler Version
v0.7.1+commit.f4a555be

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license
File 1 of 31 : IVectorChannel.sol
// 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
{}

File 2 of 31 : LibAsset.sol
// 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);
    }
}

File 3 of 31 : LibERC20.sol
// 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
                )
            );
    }
}

File 4 of 31 : ICMCCore.sol
// 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);
}

File 5 of 31 : ICMCAsset.sol
// 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;
}

File 6 of 31 : ICMCDeposit.sol
// 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;
}

File 7 of 31 : ICMCWithdraw.sol
// 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;
}

File 8 of 31 : ICMCAdjudicator.sol
// 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;
}

File 9 of 31 : Types.sol
// 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
}

File 10 of 31 : LibUtils.sol
// 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))
            }
        }
    }
}

File 11 of 31 : IERC20.sol
// 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);
}

File 12 of 31 : Address.sol
// 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);
            }
        }
    }
}

File 13 of 31 : ERC20.sol
// 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 { }
}

File 14 of 31 : Context.sol
// 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;
    }
}

File 15 of 31 : SafeMath.sol
// 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;
    }
}

File 16 of 31 : CMCDeposit.sol
// 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);
    }
}

File 17 of 31 : CMCCore.sol
// 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;
    }
}

File 18 of 31 : CMCAsset.sol
// 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);
    }
}

File 19 of 31 : ReentrancyGuard.sol
// 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");
        _;
    }
}

File 20 of 31 : LibMath.sol
// 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;
    }
}

File 21 of 31 : Math.sol
// 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);
    }
}

File 22 of 31 : CMCAdjudicator.sol
// 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));
    }
}

File 23 of 31 : Commitment.sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.1;
pragma experimental ABIEncoderV2;

enum CommitmentType {ChannelState, WithdrawData}

File 24 of 31 : ITransferDefinition.sol
// 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);
}

File 25 of 31 : LibChannelCrypto.sol
// 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));
    }
}

File 26 of 31 : MerkleProof.sol
// 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;
    }
}

File 27 of 31 : ITransferRegistry.sol
// 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);
}

File 28 of 31 : ECDSA.sol
// 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));
    }
}

File 29 of 31 : CMCWithdraw.sol
// 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));
    }
}

File 30 of 31 : WithdrawHelper.sol
// 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;
}

File 31 of 31 : ChannelMastercopy.sol
// 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
{

}

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

Contract Security Audit

Contract ABI

[{"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"}]

60a060405234801561001057600080fd5b5030606081901b608052613ffa61008b60003980610128528061041b52806107c752806108425280610a765280610b945280610c3d528061114652806112bb5280611423528061156e52806115ea528061167e52806116f252806118f6528061197f5280611a085280611aa15280611b245250613ffa6000f3fe6080604052600436106101185760003560e01c80636f33389e116100a0578063e7283a8d11610064578063e7283a8d14610384578063e9852569146103a4578063eeb30fea146103c4578063f19eb10e146103d9578063f83d08ba146103fb57610198565b80636f33389e146102ca5780638c048fc2146102f7578063b081e9c814610324578063c60939be14610344578063cefa51221461036457610198565b80633ff0da16116100e75780633ff0da161461022a5780634d3fcbda146102575780635bc9d96d146102775780635fd334d914610297578063635ae901146102b757610198565b8063072f25fd1461019d578063241686a0146101bf5780632c889aa1146101ea5780632d34ba791461020a57610198565b3661019857306001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016141561016f5760405162461bcd60e51b815260040161016690613cab565b60405180910390fd5b6001600054146101915760405162461bcd60e51b815260040161016690613a67565b6001600055005b600080fd5b3480156101a957600080fd5b506101bd6101b8366004612b84565b610410565b005b3480156101cb57600080fd5b506101d46107ba565b6040516101e191906131ad565b60405180910390f35b3480156101f657600080fd5b506101bd610205366004612c61565b610837565b34801561021657600080fd5b506101bd6102253660046127a8565b610a6b565b34801561023657600080fd5b5061024a610245366004612875565b610b81565b6040516101e19190613dc6565b34801561026357600080fd5b506101bd610272366004612a22565b610c32565b34801561028357600080fd5b506101bd6102923660046127e0565b61113b565b3480156102a357600080fd5b506101bd6102b2366004612b31565b6112b0565b6101bd6102c536600461282a565b611418565b3480156102d657600080fd5b506102ea6102e536600461278c565b611561565b6040516101e19190613e1e565b34801561030357600080fd5b50610317610312366004612c2f565b6115dd565b6040516101e1919061337b565b34801561033057600080fd5b506102ea61033f36600461278c565b611671565b34801561035057600080fd5b506101bd61035f366004612ab2565b6116e7565b34801561037057600080fd5b506102ea61037f36600461278c565b6118e9565b34801561039057600080fd5b506102ea61039f36600461278c565b611972565b3480156103b057600080fd5b506102ea6103bf3660046127a8565b6119fb565b3480156103d057600080fd5b506101d4611a94565b3480156103e557600080fd5b506103ee611b11565b6040516101e19190613d6a565b34801561040757600080fd5b506102ea611bb9565b306001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001614156104595760405162461bcd60e51b815260040161016690613cab565b60016000541461047b5760405162461bcd60e51b815260040161016690613a67565b6002600055863061048f602083018361278c565b6001600160a01b0316146104b55760405162461bcd60e51b81526004016101669061358d565b6020808901356000908152600d9091526040902060018101546104ea5760405162461bcd60e51b8152600401610166906139b6565b80546104f58a611bbf565b146105125760405162461bcd60e51b815260040161016690613d17565b600281015460ff16156105375760405162461bcd60e51b8152600401610166906136d5565b60028101805460ff1916600117905561054e61262e565b816001015442101561073657896101600135898960405161057092919061314d565b6040518091039020146105955760405162461bcd60e51b815260040161016690613d17565b6105a560a08b0160808c0161278c565b6001600160a01b0316336001600160a01b03161480610616575061061685858080601f0160208091040260200160405190810160405280939291908181526020018383808284376000920191909152506106099250505060a08d0160808e0161278c565b6101608d01359190611bef565b6106325760405162461bcd60e51b815260040161016690613c76565b600061064460608c0160408d0161278c565b9050806001600160a01b0316638ef98a7e8c60c0016040516020016106699190613d5c565b6040516020818303038152906040528c8c8c8c6040518663ffffffff1660e01b815260040161069c9594939291906133a4565b60806040518083038186803b1580156106b457600080fd5b505afa1580156106c8573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906106ec919061295f565b915061070060c08c013560e08d0135611c17565b82516020810151905161071291611c17565b11156107305760405162461bcd60e51b815260040161016690613ce2565b5061074b565b610748368b90038b0160c08c0161288d565b90505b61076461075e60c08c0160a08d0161278c565b82611c43565b7f93f6b8187e81bd7d01ce234c043cd6ae4feda2e2ae91daae0962c68a656da8c7338b848c8c8c8c886040516107a1989796959493929190613273565b60405180910390a1505060016000555050505050505050565b6000306001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001614156108055760405162461bcd60e51b815260040161016690613cab565b6001600054146108275760405162461bcd60e51b815260040161016690613a67565b506002546001600160a01b031690565b306001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001614156108805760405162461bcd60e51b815260040161016690613cab565b6001600054146108a25760405162461bcd60e51b815260040161016690613a67565b600260005584306108b6602083018361278c565b6001600160a01b0316146108dc5760405162461bcd60e51b8152600401610166906134bc565b60006108e787611c99565b90506108f68187878787611cac565b60008181526006602052604090205460ff16156109255760405162461bcd60e51b8152600401610166906138c5565b6000818152600660209081526040808320805460ff1916600117905561095d91610953918b01908b0161278c565b8960600135611db6565b905060008111806109875750600061097b60c08a0160a08b0161278c565b6001600160a01b031614155b6109a35760405162461bcd60e51b8152600401610166906134f3565b6109cc6109b660408a0160208b0161278c565b6109c660608b0160408c0161278c565b83611dca565b60006109de60c08a0160a08b0161278c565b6001600160a01b031614610a5c576109fc60c0890160a08a0161278c565b6001600160a01b031663f50cd32c89836040518363ffffffff1660e01b8152600401610a29929190613dfc565b600060405180830381600087803b158015610a4357600080fd5b505af1158015610a57573d6000803e3d6000fd5b505050505b50506001600055505050505050565b306001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000161415610ab45760405162461bcd60e51b815260040161016690613cab565b6001546001600160a01b031615610add5760405162461bcd60e51b815260040161016690613bc2565b6001600160a01b03821615801590610afd57506001600160a01b03811615155b610b195760405162461bcd60e51b81526004016101669061384d565b806001600160a01b0316826001600160a01b03161415610b4b5760405162461bcd60e51b8152600401610166906135c2565b610b53611dfb565b600180546001600160a01b039384166001600160a01b03199182161790915560028054929093169116179055565b610b89612653565b306001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000161415610bd25760405162461bcd60e51b815260040161016690613cab565b600160005414610bf45760405162461bcd60e51b815260040161016690613a67565b506000908152600d60209081526040918290208251606081018452815481526001820154928101929092526002015460ff1615159181019190915290565b306001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000161415610c7b5760405162461bcd60e51b815260040161016690613cab565b600160005414610c9d5760405162461bcd60e51b815260040161016690613a67565b60026000558430610cb1602083018361278c565b6001600160a01b0316148015610ce957506001546001600160a01b0316610cde604083016020840161278c565b6001600160a01b0316145b8015610d1757506002546001600160a01b0316610d0c606083016040840161278c565b6001600160a01b0316145b610d335760405162461bcd60e51b815260040161016690613755565b83610d505760405162461bcd60e51b81526004016101669061371e565b83821115610d705760405162461bcd60e51b815260040161016690613bf2565b600754610d7c87611e02565b14610d995760405162461bcd60e51b815260040161016690613441565b610da1611e15565b610dbd5760405162461bcd60e51b815260040161016690613556565b60005b848110156110ed576000868683818110610dd657fe5b9050602002016020810190610deb919061278c565b9050600084831015610e7057858584818110610e0357fe5b905060200201359050888060600190610e1c9190613e27565b82818110610e2657fe5b9050602002016020810190610e3b919061278c565b6001600160a01b0316826001600160a01b031614610e6b5760405162461bcd60e51b815260040161016690613485565b610edc565b5060005b610e8160608a018a613e27565b9050811015610edc57610e9760608a018a613e27565b82818110610ea157fe5b9050602002016020810190610eb6919061278c565b6001600160a01b0316826001600160a01b03161415610ed457610edc565b600101610e74565b6000610eeb60608b018b613e27565b90508214610f1657610f0060e08b018b613e27565b83818110610f0a57fe5b90506020020135610f19565b60015b6001600160a01b0384166000908152600c60205260409020549091508111610f535760405162461bcd60e51b8152600401610166906137ce565b6001600160a01b0383166000908152600c6020526040812091909155610f7883611e32565b90506000610f8584611e4d565b9050610f8f61262e565b610f9c60608d018d613e27565b9050841415611026576040518060400160405280604051806040016040528086815260200185815250815260200160405180604001604052808f6020016020810190610fe8919061278c565b6001600160a01b03166001600160a01b031681526020018f6040016020810190611012919061278c565b6001600160a01b03169052905290506110d2565b61103360808d018d613e6d565b8581811061103d57fe5b905060800201803603810190611053919061288d565b905061109461106560a08e018e613e27565b8681811061106f57fe5b905060200201358403826000015160006002811061108957fe5b602002015190611e82565b8151526110cb6110a760c08e018e613e27565b868181106110b157fe5b905060200201358303826000015160016002811061108957fe5b8151602001525b6110dc8582611c43565b505060019093019250610dc0915050565b507f49cbb28c69ffbdb6b3893f83d64557662a5dd43ffd6045b6a5180ab0a027f2243387600788886040516111269594939291906131f4565b60405180910390a15050600160005550505050565b306001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001614156111845760405162461bcd60e51b815260040161016690613cab565b6001600054146111a65760405162461bcd60e51b815260040161016690613a67565b6002600055336001600160a01b03831614806111d35750806001600160a01b0316826001600160a01b0316145b6111ef5760405162461bcd60e51b815260040161016690613b8b565b6001600160a01b038084166000908152600460209081526040808320938616835292905290812054611222908590611db6565b9050600081116112445760405162461bcd60e51b815260040161016690613ae2565b6001600160a01b038085166000908152600460209081526040808320938716835292905220546112749082611e9b565b6001600160a01b038086166000908152600460209081526040808320938816835292905220556112a5848383611dca565b505060016000555050565b306001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001614156112f95760405162461bcd60e51b815260040161016690613cab565b60016000541461131b5760405162461bcd60e51b815260040161016690613a67565b6002600055823061132f602083018361278c565b6001600160a01b0316146113555760405162461bcd60e51b81526004016101669061358d565b600061136085611bbf565b9050611373848460076002015484611edd565b61137b611e15565b6113975760405162461bcd60e51b815260040161016690613556565b6020808601356000908152600d909152604090206001810154156113cd5760405162461bcd60e51b815260040161016690613b42565b8181556113df42610140880135611c17565b60018201556040517f87b348a76dd4ef431d45553a1d8c5934db960e64201a5776ab64e3eb397f4cfa9061112690339089908590613247565b306001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001614156114615760405162461bcd60e51b815260040161016690613cab565b6001600054146114835760405162461bcd60e51b815260040161016690613a67565b600260005561149182611f3f565b156114ba578034146114b55760405162461bcd60e51b8152600401610166906138fc565b611500565b34156114d85760405162461bcd60e51b815260040161016690613975565b6114e482333084611f4c565b6115005760405162461bcd60e51b815260040161016690613884565b6001600160a01b03821660009081526005602052604090819020805483019055517fb52926ac8ed62d53d4b88d81b71c48639bd63aa53950fcf3e1d7676ca7c26140906115509084908490613362565b60405180910390a150506001600055565b6000306001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001614156115ac5760405162461bcd60e51b815260040161016690613cab565b6001600054146115ce5760405162461bcd60e51b815260040161016690613a67565b6115d782611e32565b92915050565b6000306001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001614156116285760405162461bcd60e51b815260040161016690613cab565b60016000541461164a5760405162461bcd60e51b815260040161016690613a67565b6006600061165784611c99565b815260208101919091526040016000205460ff1692915050565b6000306001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001614156116bc5760405162461bcd60e51b815260040161016690613cab565b6001600054146116de5760405162461bcd60e51b815260040161016690613a67565b6115d782611e4d565b306001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001614156117305760405162461bcd60e51b815260040161016690613cab565b6001600054146117525760405162461bcd60e51b815260040161016690613a67565b60026000558430611766602083018361278c565b6001600160a01b031614801561179e57506001546001600160a01b0316611793604083016020840161278c565b6001600160a01b0316145b80156117cc57506002546001600160a01b03166117c1606083016040840161278c565b6001600160a01b0316145b6117e85760405162461bcd60e51b815260040161016690613755565b60006117f387611e02565b9050611803878288888888611f9f565b61180b611e15565b156118285760405162461bcd60e51b815260040161016690613556565b6008546101208801351161184e5760405162461bcd60e51b8152600401610166906135f9565b6118566120a9565b61188a5761186942610100890135611c17565b600a5561188661187f61010089013560026120b1565b4290611c17565b600b555b60078181556101208801356008556101408801356009556040517fef03cf86f2e77e1a0ae5cb25b50519e55b94788b920ace71f92341df2dab97ed916118d39133918b916131c1565b60405180910390a1505060016000555050505050565b6000306001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001614156119345760405162461bcd60e51b815260040161016690613cab565b6001600054146119565760405162461bcd60e51b815260040161016690613a67565b506001600160a01b031660009081526003602052604090205490565b6000306001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001614156119bd5760405162461bcd60e51b815260040161016690613cab565b6001600054146119df5760405162461bcd60e51b815260040161016690613a67565b506001600160a01b03166000908152600c602052604090205490565b6000306001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000161415611a465760405162461bcd60e51b815260040161016690613cab565b600160005414611a685760405162461bcd60e51b815260040161016690613a67565b506001600160a01b03918216600090815260046020908152604080832093909416825291909152205490565b6000306001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000161415611adf5760405162461bcd60e51b815260040161016690613cab565b600160005414611b015760405162461bcd60e51b815260040161016690613a67565b506001546001600160a01b031690565b611b19612673565b306001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000161415611b625760405162461bcd60e51b815260040161016690613cab565b600160005414611b845760405162461bcd60e51b815260040161016690613a67565b506040805160a0810182526007548152600854602082015260095491810191909152600a546060820152600b54608082015290565b60005481565b600081604051602001611bd29190613db7565b604051602081830303815290604052805190602001209050919050565b6000816001600160a01b0316611c0585856120eb565b6001600160a01b031614949350505050565b600082820183811015611c3c5760405162461bcd60e51b81526004016101669061369e565b9392505050565b60005b6002811015611c945781516000908260028110611c5f57fe5b602002015190508015611c8b57611c8b8484602001518460028110611c8057fe5b602002015183612103565b50600101611c46565b505050565b600081604051602001611bd29190613de9565b6000600186604051602001611cc29291906133df565b604051602081830303815290604052805190602001209050611d2885858080601f01602080910402602001604051908101604052809392919081815260200183838082843760009201919091525050600154859392506001600160a01b03169050611bef565b611d445760405162461bcd60e51b815260040161016690613b0b565b611d9283838080601f01602080910402602001604051908101604052809392919081815260200183838082843760009201919091525050600254859392506001600160a01b03169050611bef565b611dae5760405162461bcd60e51b815260040161016690613816565b505050505050565b6000611c3c82611dc585612164565b6121fb565b611dd48382612211565b611ddf838383612233565b611c945760405162461bcd60e51b815260040161016690613630565b6001600055565b600081604051602001611bd29190613da4565b60004260076003015411158015611e2d5750600b5442105b905090565b6001600160a01b031660009081526005602052604090205490565b6001600160a01b0381166000908152600560209081526040808320546003909252822054611e7a84612164565b010392915050565b600082820183811015611c3c576000195b949350505050565b6000611c3c83836040518060400160405280601e81526020017f536166654d6174683a207375627472616374696f6e206f766572666c6f77000081525061225c565b611f1d8484808060200260200160405190810160405280939291908181526020018383602002808284376000920191909152508692508591506122889050565b611f395760405162461bcd60e51b815260040161016690613a9e565b50505050565b6001600160a01b03161590565b6000611f9685858585604051602401611f679392919061333e565b60408051601f198184030181529190526020810180516001600160e01b03166323b872dd60e01b179052612325565b95945050505050565b60008086604051602001611fb49291906133df565b60405160208183030381529060405280519060200120905061201e85858080601f0160208091040260200160405190810160405280939291908181526020018383808284376000920191909152506120169250505060408a0160208b0161278c565b839190611bef565b61203a5760405162461bcd60e51b815260040161016690613c35565b61208483838080601f0160208091040260200160405190810160405280939291908181526020018383808284376000920191909152506120169250505060608a0160408b0161278c565b6120a05760405162461bcd60e51b815260040161016690613667565b50505050505050565b600a54421090565b6000826120c0575060006115d7565b828202828482816120cd57fe5b0414611c3c5760405162461bcd60e51b8152600401610166906139fb565b6000806120f7846123d6565b9050611e9381846123e9565b6001600160a01b038084166000908152600460209081526040808320938616835292905220546121339082611e82565b6001600160a01b03938416600090815260046020908152604080832095909616825293909352929091209190915550565b600061216f82611f3f565b6121f4576040516370a0823160e01b81526001600160a01b038316906370a082319061219f9030906004016131ad565b60206040518083038186803b1580156121b757600080fd5b505afa1580156121cb573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906121ef9190612c9a565b6115d7565b5047919050565b600081831061220a5781611c3c565b5090919050565b6001600160a01b03909116600090815260036020526040902080549091019055565b600061223e84611f3f565b6122525761224d848484612517565b611e93565b611e938383612524565b600081848411156122805760405162461bcd60e51b815260040161016691906133f7565b505050900390565b600081815b855181101561231a5760008682815181106122a457fe5b602002602001015190508083116122e55782816040516020016122c892919061313f565b604051602081830303815290604052805190602001209250612311565b80836040516020016122f892919061313f565b6040516020818303038152906040528051906020012092505b5060010161228d565b509092149392505050565b60006123308361259c565b61234c5760405162461bcd60e51b815260040161016690613a3c565b60006060846001600160a01b031684604051612368919061315d565b6000604051808303816000865af19150503d80600081146123a5576040519150601f19603f3d011682016040523d82523d6000602084013e6123aa565b606091505b50915091506123b982826125d5565b80511580611f96575080806020019051810190611f969190612855565b600081604051602001611bd29190613179565b6000815160411461240c5760405162461bcd60e51b81526004016101669061351f565b60208201516040830151606084015160001a7f7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a082111561245e5760405162461bcd60e51b81526004016101669061378c565b8060ff16601b1415801561247657508060ff16601c14155b156124935760405162461bcd60e51b815260040161016690613933565b6000600187838686604051600081526020016040526040516124b89493929190613386565b6020604051602081039080840390855afa1580156124da573d6000803e3d6000fd5b5050604051601f1901519150506001600160a01b03811661250d5760405162461bcd60e51b81526004016101669061340a565b9695505050505050565b6000611e938484846125e6565b6000806060846001600160a01b031684604051612540906131aa565b60006040518083038185875af1925050503d806000811461257d576040519150601f19603f3d011682016040523d82523d6000602084013e612582565b606091505b509150915061259182826125d5565b506001949350505050565b6000813f7fc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470818114801590611e93575050151592915050565b816125e257805160208201fd5b5050565b6000611e938484846040516024016125ff929190613362565b60408051601f198184030181529190526020810180516001600160e01b031663a9059cbb60e01b179052612325565b60405180604001604052806126416126a1565b815260200161264e6126a1565b905290565b604080516060810182526000808252602082018190529181019190915290565b6040805160a08101825260008082526020820181905291810182905260608101829052608081019190915290565b60405180604001604052806002906020820280368337509192915050565b80356115d781613fac565b60008083601f8401126126db578182fd5b5081356001600160401b038111156126f1578182fd5b602083019150836020808302850101111561270b57600080fd5b9250929050565b60008083601f840112612723578182fd5b5081356001600160401b03811115612739578182fd5b60208301915083602082850101111561270b57600080fd5b60006101608284031215612763578081fd5b50919050565b60006101808284031215612763578081fd5b600060e08284031215612763578081fd5b60006020828403121561279d578081fd5b8135611c3c81613fac565b600080604083850312156127ba578081fd5b82356127c581613fac565b915060208301356127d581613fac565b809150509250929050565b6000806000606084860312156127f4578081fd5b83356127ff81613fac565b9250602084013561280f81613fac565b9150604084013561281f81613fac565b809150509250925092565b6000806040838503121561283c578182fd5b823561284781613fac565b946020939093013593505050565b600060208284031215612866578081fd5b81518015158114611c3c578182fd5b600060208284031215612886578081fd5b5035919050565b60006080828403121561289e578081fd5b6128a86040613eb3565b83601f8401126128b6578182fd5b6128c06040613eb3565b808460408601878111156128d2578586fd5b855b60028110156128f35782358552602094850194909201916001016128d4565b5082855287605f880112612905578586fd5b61290f6040613eb3565b9350839250905060808601871015612925578485fd5b845b600281101561295057813561293b81613fac565b84526020938401939190910190600101612927565b50506020830152509392505050565b600060808284031215612970578081fd5b61297a6040613eb3565b83601f840112612988578182fd5b6129926040613eb3565b808460408601878111156129a4578586fd5b855b60028110156129c55782518552602094850194909201916001016129a6565b5082855287605f8801126129d7578586fd5b6129e16040613eb3565b93508392509050608086018710156129f7578485fd5b845b6002811015612950578151612a0d81613fac565b845260209384019391909101906001016129f9565b600080600080600060608688031215612a39578283fd5b85356001600160401b0380821115612a4f578485fd5b612a5b89838a01612751565b96506020880135915080821115612a70578485fd5b612a7c89838a016126ca565b90965094506040880135915080821115612a94578283fd5b50612aa1888289016126ca565b969995985093965092949392505050565b600080600080600060608688031215612ac9578283fd5b85356001600160401b0380821115612adf578485fd5b612aeb89838a01612751565b96506020880135915080821115612b00578485fd5b612b0c89838a01612712565b90965094506040880135915080821115612b24578283fd5b50612aa188828901612712565b60008060006101a08486031215612b46578081fd5b612b508585612769565b92506101808401356001600160401b03811115612b6b578182fd5b612b77868287016126ca565b9497909650939450505050565b60008060008060008060006101e0888a031215612b9f578485fd5b612ba98989612769565b96506101808801356001600160401b0380821115612bc5578687fd5b612bd18b838c01612712565b90985096506101a08a0135915080821115612bea578384fd5b612bf68b838c01612712565b90965094506101c08a0135915080821115612c0f578384fd5b50612c1c8a828b01612712565b989b979a50959850939692959293505050565b600060208284031215612c40578081fd5b81356001600160401b03811115612c55578182fd5b611e938482850161277b565b600080600080600060608688031215612c78578283fd5b85356001600160401b0380821115612c8e578485fd5b612aeb89838a0161277b565b600060208284031215612cab578081fd5b5051919050565b6001600160a01b03169052565b60008284526020808501945082825b85811015612cfc578135612ce181613fac565b6001600160a01b031687529582019590820190600101612cce565b509495945050505050565b60008284526020808501945082825b85811015612cfc576040808389378781018581529083019085905b6002821015612d62578235612d4581613fac565b6001600160a01b0316815291850191600191909101908501612d31565b5050506080968701969190910190600101612d16565b81835260006001600160fb1b03831115612d90578081fd5b6020830280836020870137939093016020019283525090919050565b60008284528282602086013780602084860101526020601f19601f85011685010190509392505050565b60008151808452612dee816020860160208601613f80565b601f01601f19169290920160200192915050565b604081833760006040838101828152908301915b6002811015612e475760208335612e2c81613fac565b6001600160a01b031683529283019290910190600101612e16565b5050505050565b8054825260018101546020830152600281015460408301526003810154606083015260040154608090910152565b600061016060208301612e9885612e9383876126bf565b612cb2565b612ea28185613ed9565b9050612eb16020860182612cb2565b50612ebf6040840184613ed9565b612ecc6040860182612cb2565b50612eda6060840184613ee6565b826060870152612eed8387018284612cbf565b92505050612efe6080840184613f2d565b8583036080870152612f11838284612d07565b92505050612f2260a0840184613ee6565b85830360a0870152612f35838284612d78565b92505050612f4660c0840184613ee6565b85830360c0870152612f59838284612d78565b92505050612f6a60e0840184613ee6565b85830360e0870152612f7d838284612d78565b6101008681013590880152610120808701359088015261014095860135959096019490945250929392505050565b8035612fb681613fac565b6001600160a01b03908116835260208281013590840152604082013590612fdc82613fac565b166040830152612fef6060820182613ed9565b612ffc6060840182612cb2565b5061300a6080820182613ed9565b6130176080840182612cb2565b5061302560a0820182613ed9565b61303260a0840182612cb2565b5061304360c0830160c08301612e02565b610140818101359083015261016090810135910152565b80548252600181015460208301526002015460ff161515604090910152565b6000813561308681613fac565b6001600160a01b0390811684526020830135906130a282613fac565b90811660208501526040830135906130b982613fac565b8082166040860152606084013560608601526080840135608086015260a084013591506130e582613fac565b1660a084015260c082013536839003601e19018112613102578182fd5b820180356001600160401b03811115613119578283fd5b803603841315613127578283fd5b60e060c0860152611f9660e086018260208501612dac565b918252602082015260400190565b6000828483379101908152919050565b6000825161316f818460208701613f80565b9190910192915050565b7f16566563746f72205369676e6564204d6573736167653a0a33320000000000008152601a810191909152603a0190565b90565b6001600160a01b0391909116815260200190565b6001600160a01b038416815260e0602082018190526000906131e590830185612e7c565b9050611e936040830184612e4e565b6001600160a01b03861681526101006020820181905260009061321983820188612e7c565b90506132286040840187612e4e565b82810360e084015261323b818587612cbf565b98975050505050505050565b6001600160a01b038416815261020081016132656020830185612fab565b611e936101a083018461305a565b6001600160a01b038916815260006102c060206132928185018c612fab565b6132a06101a085018b61305a565b816102008501526132b4828501898b612dac565b91508382036102208501526132ca828789612dac565b85519093509150600061024085015b60028210156132f85783518152928201926001919091019082016132d9565b5050808501519150610280840160005b600281101561332d5761331b8451613f74565b82529282019290820190600101613308565b505050509998505050505050505050565b6001600160a01b039384168152919092166020820152604081019190915260600190565b6001600160a01b03929092168252602082015260400190565b901515815260200190565b93845260ff9290921660208401526040830152606082015260800190565b6000606082526133b76060830188612dd6565b82810360208401526133ca818789612dac565b9050828103604084015261323b818587612dac565b60408101600284106133ed57fe5b9281526020015290565b600060208252611c3c6020830184612dd6565b60208082526018908201527f45434453413a20696e76616c6964207369676e61747572650000000000000000604082015260600190565b60208082526024908201527f434d4341646a7564696361746f723a20494e56414c49445f4348414e4e454c5f60408201526309082a6960e31b606082015260800190565b6020808252601e908201527f434d4341646a7564696361746f723a20494e4445585f4d49534d415443480000604082015260600190565b6020808252601d908201527f434d4357697468647261773a204348414e4e454c5f4d49534d41544348000000604082015260600190565b6020808252601290820152710434d4357697468647261773a204e4f5f4f560741b604082015260600190565b6020808252601f908201527f45434453413a20696e76616c6964207369676e6174757265206c656e67746800604082015260600190565b6020808252601d908201527f434d4341646a7564696361746f723a20494e56414c49445f5048415345000000604082015260600190565b6020808252818101527f434d4341646a7564696361746f723a20494e56414c49445f5452414e53464552604082015260600190565b6020808252601f908201527f434d43436f72653a204944454e544943414c5f5041525449434950414e545300604082015260600190565b6020808252601d908201527f434d4341646a7564696361746f723a20494e56414c49445f4e4f4e4345000000604082015260600190565b60208082526019908201527f434d4341737365743a205452414e534645525f4641494c454400000000000000604082015260600190565b6020808252601f908201527f434d4341646a7564696361746f723a20494e56414c49445f424f425f53494700604082015260600190565b6020808252601b908201527f536166654d6174683a206164646974696f6e206f766572666c6f770000000000604082015260600190565b60208082526029908201527f434d4341646a7564696361746f723a205452414e534645525f414c524541445960408201526817d11151955391115160ba1b606082015260800190565b6020808252601f908201527f434d4341646a7564696361746f723a204e4f5f4153534554535f474956454e00604082015260600190565b6020808252601f908201527f434d4341646a7564696361746f723a20494e56414c49445f4348414e4e454c00604082015260600190565b60208082526022908201527f45434453413a20696e76616c6964207369676e6174757265202773272076616c604082015261756560f01b606082015260800190565b60208082526028908201527f434d4341646a7564696361746f723a204348414e4e454c5f414c52454144595f604082015267111151955391115160c21b606082015260800190565b6020808252601c908201527f434d4357697468647261773a20494e56414c49445f424f425f53494700000000604082015260600190565b6020808252601c908201527f434d43436f72653a20494e56414c49445f5041525449434950414e5400000000604082015260600190565b60208082526021908201527f434d434465706f7369743a2045524332305f5452414e534645525f4641494c456040820152601160fa1b606082015260800190565b6020808252601d908201527f434d4357697468647261773a20414c52454144595f4558454355544544000000604082015260600190565b6020808252601a908201527f434d434465706f7369743a2056414c55455f4d49534d41544348000000000000604082015260600190565b60208082526022908201527f45434453413a20696e76616c6964207369676e6174757265202776272076616c604082015261756560f01b606082015260800190565b60208082526021908201527f434d434465706f7369743a204554485f574954485f4552435f5452414e5346456040820152602960f91b606082015260800190565b60208082526025908201527f434d4341646a7564696361746f723a205452414e534645525f4e4f545f444953604082015264141555115160da1b606082015260800190565b60208082526021908201527f536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f6040820152607760f81b606082015260800190565b6020808252601190820152704c696245524332303a204e4f5f434f444560781b604082015260600190565b6020808252601f908201527f5265656e7472616e637947756172643a205245454e5452414e545f43414c4c00604082015260600190565b60208082526024908201527f434d4341646a7564696361746f723a20494e56414c49445f4d45524b4c455f506040820152632927a7a360e11b606082015260800190565b6020808252600f908201526e0434d4341737365743a204e4f5f4f5608c1b604082015260600190565b6020808252601e908201527f434d4357697468647261773a20494e56414c49445f414c4943455f5349470000604082015260600190565b60208082526029908201527f434d4341646a7564696361746f723a205452414e534645525f414c524541445960408201526817d11254d41555115160ba1b606082015260800190565b60208082526018908201527f434d4341737365743a204f574e45525f4d49534d415443480000000000000000604082015260600190565b6020808252601690820152750434d43436f72653a20414c52454144595f53455455560541b604082015260600190565b60208082526023908201527f434d4341646a7564696361746f723a2057524f4e475f41525241595f4c454e4760408201526254485360e81b606082015260800190565b60208082526021908201527f434d4341646a7564696361746f723a20494e56414c49445f414c4943455f53496040820152604760f81b606082015260800190565b6020808252818101527f434d4341646a7564696361746f723a20494e56414c49445f5245534f4c564552604082015260600190565b6020808252601a908201527f4d6173746572636f70793a204f4e4c595f5649415f50524f5859000000000000604082015260600190565b6020808252818101527f434d4341646a7564696361746f723a20494e56414c49445f42414c414e434553604082015260600190565b60208082526025908201527f434d4341646a7564696361746f723a20494e56414c49445f5452414e534645526040820152640be9082a6960db1b606082015260800190565b608081016115d78284612e02565b600060a082019050825182526020830151602083015260408301516040830152606083015160608301526080830151608083015292915050565b600060208252611c3c6020830184612e7c565b61018081016115d78284612fab565b815181526020808301519082015260409182015115159181019190915260600190565b600060208252611c3c6020830184613079565b600060408252613e0f6040830185613079565b90508260208301529392505050565b90815260200190565b6000808335601e19843603018112613e3d578283fd5b8301803591506001600160401b03821115613e56578283fd5b602090810192508102360382131561270b57600080fd5b6000808335601e19843603018112613e83578283fd5b8301803591506001600160401b03821115613e9c578283fd5b602001915060808102360382131561270b57600080fd5b6040518181016001600160401b0381118282101715613ed157600080fd5b604052919050565b60008235611c3c81613fac565b6000808335601e19843603018112613efc578283fd5b83016020810192503590506001600160401b03811115613f1b57600080fd5b60208102360383131561270b57600080fd5b6000808335601e19843603018112613f43578283fd5b83016020810192503590506001600160401b03811115613f6257600080fd5b60808102360383131561270b57600080fd5b6001600160a01b031690565b60005b83811015613f9b578181015183820152602001613f83565b83811115611f395750506000910152565b6001600160a01b0381168114613fc157600080fd5b5056fea26469706673582212200c5761a7a244ea0132fa44dddcf0e7db8a07d95db5eae27e73fff5d050f1145c64736f6c63430007010033

Deployed ByteCode Sourcemap

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

Swarm Source

ipfs://0c5761a7a244ea0132fa44dddcf0e7db8a07d95db5eae27e73fff5d050f1145c
Block Transaction Difficulty Gas Used Reward
Block Uncle Number Difficulty Gas Used Reward
Loading
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.