Contract

/**
 *Submitted for verification at Etherscan.io on 2023-02-02
*/

/**
 *Submitted for verification at Etherscan.io on 2021-11-18
*/

// Sources flattened with hardhat v2.6.8 https://hardhat.org

// File @openzeppelin/contracts/utils/math/[email protected]

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // 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 (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @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) {
        return a + b;
    }

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

    /**
     * @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) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting 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 a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting 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) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * 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) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}


// File @openzeppelin/contracts/utils/[email protected]

pragma solidity ^0.8.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) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

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

        (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");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}


// File contracts/IDeposit.sol

pragma solidity ^0.8.0;

/// @notice  Interface of the official Deposit contract from the ETH
///          Foundation.
interface IDeposit {

    /// @notice Submit a Phase 0 DepositData object.
    ///
    /// @param pubkey - A BLS12-381 public key.
    /// @param withdrawal_credentials - Commitment to a public key for withdrawals.
    /// @param signature - A BLS12-381 signature.
    /// @param deposit_data_root - The SHA-256 hash of the SSZ-encoded DepositData object.
    ///                            Used as a protection against malformed input.
    function deposit(
        bytes calldata pubkey,
        bytes calldata withdrawal_credentials,
        bytes calldata signature,
        bytes32 deposit_data_root
    ) external payable;
}

// Used in unit tests.
contract DepositMock is IDeposit {
    function deposit(bytes calldata pubkey, bytes calldata withdrawal_credentials, bytes calldata signature, bytes32 deposit_data_root) external payable {}
}


// File contracts/BatchDeposit.sol

pragma solidity ^0.8.0;


// Based on Stakefish and Staked.us contracts.
//
// We don't need fees, but we want truffle & unit tests.
contract BatchDeposit {
    using Address for address payable;
    using SafeMath for uint256;

    uint256 public constant kDepositAmount = 32 ether;
    IDeposit private depositContract_;

    event LogDepositLeftover(address to, uint256 amount);
    event LogDepositSent(bytes pubkey, bytes withdrawal);

    // We pass the address of a contract here because this will change
    // from one environment to another. On mainnet and testnet we use
    // the official addresses:
    //
    // - testnet: 0xff50ed3d0ec03aC01D4C79aAd74928BFF48a7b2b (https://goerli.etherscan.io/address/0xff50ed3d0ec03aC01D4C79aAd74928BFF48a7b2b)
    // - mainnet: 0x00000000219ab540356cbb839cbe05303d7705fa (https://etherscan.io/address/0x00000000219ab540356cbb839cbe05303d7705fa)
    //
    // The migration script handles this.
    constructor (address deposit_contract_address) {
	depositContract_ = IDeposit(deposit_contract_address);
    }

    function batchDeposit(
        bytes[] calldata pubkeys,
        bytes[] calldata withdrawal_credentials,
        bytes[] calldata signatures,
        bytes32[] calldata deposit_data_roots
    ) external payable {
        require(
            pubkeys.length == withdrawal_credentials.length &&
            pubkeys.length == signatures.length &&
            pubkeys.length == deposit_data_roots.length,
            "#BatchDeposit batchDeposit(): All parameter array's must have the same length."
        );
        require(
            pubkeys.length > 0,
            "#BatchDeposit batchDeposit(): All parameter array's must have a length greater than zero."
        );
        require(
            msg.value >= kDepositAmount.mul(pubkeys.length),
            "#BatchDeposit batchDeposit(): Ether deposited needs to be at least: 32 * (parameter `pubkeys[]` length)."
        );

        uint256 deposited = 0;

        for (uint256 i = 0; i < pubkeys.length; i++) {
            depositContract_.deposit{value: kDepositAmount}(
                pubkeys[i],
                withdrawal_credentials[i],
                signatures[i],
                deposit_data_roots[i]
            );
	    emit LogDepositSent(pubkeys[i], withdrawal_credentials[i]);
            deposited = deposited.add(kDepositAmount);
        }

        assert(deposited == kDepositAmount.mul(pubkeys.length));

        uint256 ethToReturn = msg.value.sub(deposited);
        if (ethToReturn > 0) {
          emit LogDepositLeftover(msg.sender, ethToReturn);
	  Address.sendValue(payable(msg.sender), ethToReturn);
        }
    }
}

[{"inputs":[{"internalType":"address","name":"deposit_contract_address","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"LogDepositLeftover","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes","name":"pubkey","type":"bytes"},{"indexed":false,"internalType":"bytes","name":"withdrawal","type":"bytes"}],"name":"LogDepositSent","type":"event"},{"inputs":[{"internalType":"bytes[]","name":"pubkeys","type":"bytes[]"},{"internalType":"bytes[]","name":"withdrawal_credentials","type":"bytes[]"},{"internalType":"bytes[]","name":"signatures","type":"bytes[]"},{"internalType":"bytes32[]","name":"deposit_data_roots","type":"bytes32[]"}],"name":"batchDeposit","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"kDepositAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

000000000000000000000000ff50ed3d0ec03ac01d4c79aad74928bff48a7b2b

-----Decoded View---------------
Arg [0] : deposit_contract_address (address): 0xff50ed3d0ec03aC01D4C79aAd74928BFF48a7b2b

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000ff50ed3d0ec03ac01d4c79aad74928bff48a7b2b

16439:2596:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;16543:49;;;;;;;;;;;;16584:8;16543:49;;;;;160:25:1;;;148:2;133:18;16543:49:0;;;;;;;17394:1638;;;;;;:::i;:::-;;:::i;:::-;;;17644:47;;;:99;;;;-1:-1:-1;17708:35:0;;;17644:99;:159;;;;-1:-1:-1;17760:43:0;;;17644:159;17622:287;;;;-1:-1:-1;;;17622:287:0;;2247:2:1;17622:287:0;;;2229:21:1;2286:2;2266:18;;;2259:30;2325:34;2305:18;;;2298:62;2396:34;2376:18;;;2369:62;-1:-1:-1;;;2447:19:1;;;2440:45;2502:19;;17622:287:0;;;;;;;;;17942:18;17920:157;;;;-1:-1:-1;;;17920:157:0;;2734:2:1;17920:157:0;;;2716:21:1;2773:2;2753:18;;;2746:30;2812:34;2792:18;;;2785:62;2883:34;2863:18;;;2856:62;2955:27;2934:19;;;2927:56;3000:19;;17920:157:0;2532:493:1;17920:157:0;18123:34;16584:8;18142:7;18123:18;:34::i;:::-;18110:9;:47;;18088:201;;;;-1:-1:-1;;;18088:201:0;;3232:2:1;18088:201:0;;;3214:21:1;3271:3;3251:18;;;3244:31;3311:34;3291:18;;;3284:62;3382:34;3362:18;;;3355:62;3454:34;3433:19;;;3426:63;-1:-1:-1;;;3505:19:1;;;3498:39;3554:19;;18088:201:0;3030:549:1;18088:201:0;18302:17;18341:9;18336:401;18356:18;;;18336:401;;;18396:16;;-1:-1:-1;;;;;18396:16:0;:24;16584:8;18462:7;;18470:1;18462:10;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;18491:22;;18514:1;18491:25;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;18535:10;;18546:1;18535:13;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;18567:18;;18586:1;18567:21;;;;;;;:::i;:::-;;;;;;;18396:207;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18616:53;18631:7;;18639:1;18631:10;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;18643:22;;18666:1;18643:25;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;18616:53;;;;;;;;;:::i;:::-;;;;;;;;18696:29;:9;16584:8;18696:13;:29::i;:::-;18684:41;-1:-1:-1;18376:3:0;;;;:::i;:::-;;;;18336:401;;;-1:-1:-1;18769:34:0;16584:8;18788:7;18769:18;:34::i;:::-;18756:9;:47;18749:55;;;;:::i;:::-;18817:19;18839:24;:9;18853;18839:13;:24::i;:::-;18817:46;-1:-1:-1;18878:15:0;;18874:151;;18913:43;;;18932:10;6223:51:1;;6305:2;6290:18;;6283:34;;;18913:43:0;;6196:18:1;18913:43:0;;;;;;;18962:51;18988:10;19001:11;18962:17;:51::i;:::-;17611:1421;;17394:1638;;;;;;;;:::o;3702:98::-;3760:7;3787:5;3791:1;3787;:5;:::i;:::-;3780:12;3702:98;-1:-1:-1;;;3702:98:0:o;2964:::-;3022:7;3049:5;3053:1;3049;:5;:::i;3345:98::-;3403:7;3430:5;3434:1;3430;:5;:::i;9221:317::-;9336:6;9311:21;:31;;9303:73;;;;-1:-1:-1;;;9303:73:0;;6966:2:1;9303:73:0;;;6948:21:1;7005:2;6985:18;;;6978:30;7044:31;7024:18;;;7017:59;7093:18;;9303:73:0;6764:353:1;9303:73:0;9390:12;9408:9;-1:-1:-1;;;;;9408:14:0;9430:6;9408:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9389:52;;;9460:7;9452:78;;;;-1:-1:-1;;;9452:78:0;;7534:2:1;9452:78:0;;;7516:21:1;7573:2;7553:18;;;7546:30;7612:34;7592:18;;;7585:62;7683:28;7663:18;;;7656:56;7729:19;;9452:78:0;7332:422:1;9452:78:0;9292:246;9221:317;;:::o;196:374:1:-;266:8;276:6;330:3;323:4;315:6;311:17;307:27;297:55;;348:1;345;338:12;297:55;-1:-1:-1;371:20:1;;414:18;403:30;;400:50;;;446:1;443;436:12;400:50;483:4;475:6;471:17;459:29;;543:3;536:4;526:6;523:1;519:14;511:6;507:27;503:38;500:47;497:67;;;560:1;557;550:12;497:67;196:374;;;;;:::o;575:1465::-;802:6;810;818;826;834;842;850;858;911:3;899:9;890:7;886:23;882:33;879:53;;;928:1;925;918:12;879:53;968:9;955:23;997:18;1038:2;1030:6;1027:14;1024:34;;;1054:1;1051;1044:12;1024:34;1093:77;1162:7;1153:6;1142:9;1138:22;1093:77;:::i;:::-;1189:8;;-1:-1:-1;1067:103:1;-1:-1:-1;1277:2:1;1262:18;;1249:32;;-1:-1:-1;1293:16:1;;;1290:36;;;1322:1;1319;1312:12;1290:36;1361:79;1432:7;1421:8;1410:9;1406:24;1361:79;:::i;:::-;1459:8;;-1:-1:-1;1335:105:1;-1:-1:-1;1547:2:1;1532:18;;1519:32;;-1:-1:-1;1563:16:1;;;1560:36;;;1592:1;1589;1582:12;1560:36;1631:79;1702:7;1691:8;1680:9;1676:24;1631:79;:::i;:::-;1729:8;;-1:-1:-1;1605:105:1;-1:-1:-1;1817:2:1;1802:18;;1789:32;;-1:-1:-1;1833:16:1;;;1830:36;;;1862:1;1859;1852:12;1830:36;;1901:79;1972:7;1961:8;1950:9;1946:24;1901:79;:::i;:::-;575:1465;;;;-1:-1:-1;575:1465:1;;-1:-1:-1;575:1465:1;;;;;;1999:8;-1:-1:-1;;;575:1465:1:o;3584:127::-;3645:10;3640:3;3636:20;3633:1;3626:31;3676:4;3673:1;3666:15;3700:4;3697:1;3690:15;3716:521;3793:4;3799:6;3859:11;3846:25;3953:2;3949:7;3938:8;3922:14;3918:29;3914:43;3894:18;3890:68;3880:96;;3972:1;3969;3962:12;3880:96;3999:33;;4051:20;;;-1:-1:-1;4094:18:1;4083:30;;4080:50;;;4126:1;4123;4116:12;4080:50;4159:4;4147:17;;-1:-1:-1;4190:14:1;4186:27;;;4176:38;;4173:58;;;4227:1;4224;4217:12;4242:266;4330:6;4325:3;4318:19;4382:6;4375:5;4368:4;4363:3;4359:14;4346:43;-1:-1:-1;4434:1:1;4409:16;;;4427:4;4405:27;;;4398:38;;;;4490:2;4469:15;;;-1:-1:-1;;4465:29:1;4456:39;;;4452:50;;4242:266::o;4513:691::-;4810:3;4799:9;4792:22;4773:4;4837:62;4894:3;4883:9;4879:19;4871:6;4863;4837:62;:::i;:::-;4947:9;4939:6;4935:22;4930:2;4919:9;4915:18;4908:50;4981:49;5023:6;5015;5007;4981:49;:::i;:::-;4967:63;;5078:9;5070:6;5066:22;5061:2;5050:9;5046:18;5039:50;5106:49;5148:6;5140;5132;5106:49;:::i;:::-;5098:57;;;5191:6;5186:2;5175:9;5171:18;5164:34;4513:691;;;;;;;;;;:::o;5209:431::-;5422:2;5411:9;5404:21;5385:4;5448:61;5505:2;5494:9;5490:18;5482:6;5474;5448:61;:::i;:::-;5557:9;5549:6;5545:22;5540:2;5529:9;5525:18;5518:50;5585:49;5627:6;5619;5611;5585:49;:::i;:::-;5577:57;5209:431;-1:-1:-1;;;;;;;5209:431:1:o;5645:127::-;5706:10;5701:3;5697:20;5694:1;5687:31;5737:4;5734:1;5727:15;5761:4;5758:1;5751:15;5777:135;5816:3;-1:-1:-1;;5837:17:1;;5834:43;;;5857:18;;:::i;:::-;-1:-1:-1;5904:1:1;5893:13;;5777:135::o;5917:127::-;5978:10;5973:3;5969:20;5966:1;5959:31;6009:4;6006:1;5999:15;6033:4;6030:1;6023:15;6328:168;6368:7;6434:1;6430;6426:6;6422:14;6419:1;6416:21;6411:1;6404:9;6397:17;6393:45;6390:71;;;6441:18;;:::i;:::-;-1:-1:-1;6481:9:1;;6328:168::o;6501:128::-;6541:3;6572:1;6568:6;6565:1;6562:13;6559:39;;;6578:18;;:::i;:::-;-1:-1:-1;6614:9:1;;6501:128::o;6634:125::-;6674:4;6702:1;6699;6696:8;6693:34;;;6707:18;;:::i;:::-;-1:-1:-1;6744:9:1;;6634:125::o

ipfs://0a921112c61ee5b6574a21732056f61ed7772264db37598756baccc90bd619f0