Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b, st ...
•    - function _msgSender()
•    - function _msgData()
•  contract Ownable is Context
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(address target, ...
•    - function functionCallWithValue(addres ...
•    - function functionCallWithValue(addres ...
•    - function _functionCallWithValue(addre ...
• library MerkleProof
•    - function verify(bytes32[] memory proo ...
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transfer(address recipient, ...
•    - function transferFrom(
• interface IZuniTreasury
•    - function setZuniBadge(address _zuniBa ...
•    - function setCRP(address _crpAddress)
•    - function setZuniToken(IERC20 _zuni)
•    - function giveZuniReward(address to, u ...
•    - function issue(uint256 tokenAmountOut ...
•    - function buyback(uint256 tokenAmountI ...
•    - function capitalization(address token ...
•    - function withdrawToken(
•    - function setSwapFee(uint256 swapFee)
•    - function setCap(uint256 newCap)
•    - function setPublicSwap(bool publicSwa ...
•    - function updateWeight(address token, ...
•    - function updateWeightsGradually(
•    - function pokeWeights()
•    - function commitAddToken(
•    - function applyAddToken()
•    - function removeToken(address token)
•    - function whitelistLiquidityProvider(a ...
•    - function removeWhitelistedLiquidityPr ...
•  contract ZuniReward is Ownable *
•    - function setController(address contro ...
•    - function setTreasury(IZuniTreasury zu ...
•    - function setMerkleRoot(bytes32 merkle ...
•    - function isClaimed(uint256 index)
•    - function _setClaimed(uint256 index)
•    - function claim(

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-12-28
*/

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.12;

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

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

contract Ownable is Context {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

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

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

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

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 in extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        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");

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

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;
    }
}

interface IERC20 {
    // 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
    );

    // 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);

    // Returns the amount of tokens in existence
    function totalSupply() external view returns (uint256);

    // Returns the amount of tokens owned by account
    function balanceOf(address account) external view returns (uint256);

    // 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);

    // Sets amount as the allowance of spender over the caller’s tokens
    // Returns a boolean value indicating whether the operation succeeded
    // Emits an Approval event.
    function approve(address spender, uint256 amount) external returns (bool);

    // 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);

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


interface IZuniTreasury {
    function setZuniBadge(address _zuniBadge) external;

    function setCRP(address _crpAddress) external;

    function setZuniToken(IERC20 _zuni) external;

    function giveZuniReward(address to, uint256 amount) external;

    function issue(uint256 tokenAmountOut) external;

    function buyback(uint256 tokenAmountIn) external;

    function capitalization(address token, uint256 tokenAmountOut) external;

    function withdrawToken(
        address token,
        address to,
        uint256 amount
    ) external;

    // external functions only can be called by owner to config CRP

    function setSwapFee(uint256 swapFee) external;

    function setCap(uint256 newCap) external;

    function setPublicSwap(bool publicSwap) external;

    function updateWeight(address token, uint256 newWeight) external;

    function updateWeightsGradually(
        uint256[] calldata newWeights,
        uint256 startBlock,
        uint256 endBlock
    ) external;

    function pokeWeights() external;

    function commitAddToken(
        address token,
        uint256 balance,
        uint256 denormalizedWeight
    ) external;

    function applyAddToken() external;

    function removeToken(address token) external;

    function whitelistLiquidityProvider(address provider) external;

    function removeWhitelistedLiquidityProvider(address provider) external;
}


contract ZuniReward is Ownable {
    using SafeMath for uint256;
    using Address for address;

    address public controller;
    bytes32 public merkleRoot;

    uint256 private mappingVersion;
    mapping(bytes32 => bool) private claimedMap;

    IZuniTreasury public zuniTreasury;

    event Claimed(uint256 index, address account, uint256 amount);

    modifier onlyController() {
        require(msg.sender == controller);
        _;
    }

    constructor(address controller_, IZuniTreasury zuniTreasury_) public {
        controller = controller_;
        zuniTreasury = zuniTreasury_;
    }

    function setController(address controller_) external onlyOwner {
        controller = controller_;
    }

    function setTreasury(IZuniTreasury zuniTreasury_) external onlyOwner {
        zuniTreasury = zuniTreasury_;
    }

    function setMerkleRoot(bytes32 merkleRoot_) external onlyController {
        merkleRoot = merkleRoot_;
        mappingVersion++;
    }

    function isClaimed(uint256 index) public view returns (bool) {
        bytes32 key = keccak256(abi.encodePacked(mappingVersion, index));
        return claimedMap[key];
    }

    function _setClaimed(uint256 index) private {
        bytes32 key = keccak256(abi.encodePacked(mappingVersion, index));
        claimedMap[key] = true;
    }

    function claim(
        uint256 index,
        address account,
        uint256 amount,
        bytes32[] calldata merkleProof
    ) external {
        require(!isClaimed(index), "MerkleDistributor: Drop already claimed.");

        // Verify the merkle proof.
        bytes32 node = keccak256(abi.encodePacked(index, account, amount));
        require(
            MerkleProof.verify(merkleProof, merkleRoot, node),
            "MerkleDistributor: Invalid proof."
        );

        // Mark it claimed and send the token.
        _setClaimed(index);

        zuniTreasury.giveZuniReward(account, amount);

        emit Claimed(index, account, amount);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"controller_","type":"address"},{"internalType":"contract IZuniTreasury","name":"zuniTreasury_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"index","type":"uint256"},{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Claimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"},{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes32[]","name":"merkleProof","type":"bytes32[]"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"controller","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"isClaimed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"controller_","type":"address"}],"name":"setController","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"merkleRoot_","type":"bytes32"}],"name":"setMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IZuniTreasury","name":"zuniTreasury_","type":"address"}],"name":"setTreasury","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"zuniTreasury","outputs":[{"internalType":"contract IZuniTreasury","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

000000000000000000000000a54c39e8e49f59b1d71da1174a5f8f58dd6186fb000000000000000000000000d69434ffac4114b07723fbc00658955cb0062d2d

-----Decoded View---------------
Arg [0] : controller_ (address): 0xa54c39e8e49F59b1D71dA1174a5F8F58Dd6186fB
Arg [1] : zuniTreasury_ (address): 0xD69434FFAc4114b07723fbc00658955cB0062D2d

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000a54c39e8e49f59b1d71da1174a5f8f58dd6186fb
Arg [1] : 000000000000000000000000d69434ffac4114b07723fbc00658955cb0062d2d

18510:2049:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18770:33;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;19876:680;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;18647:25;;;:::i;:::-;;;;;;;;;;;;;;;;;;;7457:148;;;:::i;:::-;;19377:138;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;6815:79;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;19139:106;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;19523:177;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;19253:116;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;7760:244;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;18615:25;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;18770:33;;;;;;;;;;;;;:::o;19876:680::-;20043:16;20053:5;20043:9;:16::i;:::-;20042:17;20034:70;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20154:12;20196:5;20203:7;20212:6;20179:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20169:51;;;;;;20154:66;;20253:49;20272:11;;20253:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20285:10;;20297:4;20253:18;:49::i;:::-;20231:132;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20424:18;20436:5;20424:11;:18::i;:::-;20455:12;;;;;;;;;;;:27;;;20483:7;20492:6;20455:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20517:31;20525:5;20532:7;20541:6;20517:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19876:680;;;;;;:::o;18647:25::-;;;;:::o;7457:148::-;7037:12;:10;:12::i;:::-;7027:22;;:6;;;;;;;;;;:22;;;7019:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7564:1:::1;7527:40;;7548:6;::::0;::::1;;;;;;;;7527:40;;;;;;;;;;;;7595:1;7578:6:::0;::::1;:19;;;;;;;;;;;;;;;;;;7457:148::o:0;19377:138::-;18941:10;;;;;;;;;;;18927:24;;:10;:24;;;18919:33;;;;;;19469:11:::1;19456:10;:24;;;;19491:14;;:16;;;;;;;;;;;;;19377:138:::0;:::o;6815:79::-;6853:7;6880:6;;;;;;;;;;;6873:13;;6815:79;:::o;19139:106::-;7037:12;:10;:12::i;:::-;7027:22;;:6;;;;;;;;;;:22;;;7019:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19226:11:::1;19213:10;;:24;;;;;;;;;;;;;;;;;;19139:106:::0;:::o;19523:177::-;19578:4;19595:11;19636:14;;19652:5;19619:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19609:50;;;;;;19595:64;;19677:10;:15;19688:3;19677:15;;;;;;;;;;;;;;;;;;;;;19670:22;;;19523:177;;;:::o;19253:116::-;7037:12;:10;:12::i;:::-;7027:22;;:6;;;;;;;;;;:22;;;7019:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19348:13:::1;19333:12;;:28;;;;;;;;;;;;;;;;;;19253:116:::0;:::o;7760:244::-;7037:12;:10;:12::i;:::-;7027:22;;:6;;;;;;;;;;:22;;;7019:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7869:1:::1;7849:22;;:8;:22;;;;7841:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7959:8;7930:38;;7951:6;::::0;::::1;;;;;;;;7930:38;;;;;;;;;;;;7988:8;7979:6;::::0;:17:::1;;;;;;;;;;;;;;;;;;7760:244:::0;:::o;18615:25::-;;;;;;;;;;;;;:::o;14263:796::-;14354:4;14371:20;14394:4;14371:27;;14416:9;14411:525;14435:5;:12;14431:1;:16;14411:525;;;14469:20;14492:5;14498:1;14492:8;;;;;;;;;;;;;;14469:31;;14537:12;14521;:28;14517:408;;14691:12;14705;14674:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14664:55;;;;;;14649:70;;14517:408;;;14881:12;14895;14864:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14854:55;;;;;;14839:70;;14517:408;14411:525;14449:3;;;;;;;14411:525;;;;15047:4;15031:12;:20;15024:27;;;14263:796;;;;;:::o;19708:160::-;19763:11;19804:14;;19820:5;19787:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19777:50;;;;;;19763:64;;19856:4;19838:10;:15;19849:3;19838:15;;;;;;;;;;;;:22;;;;;;;;;;;;;;;;;;19708:160;;:::o;5960:106::-;6013:15;6048:10;6041:17;;5960:106;:::o

ipfs://5bd2539367c3b30b42835092e5506c5004ef82a90cd27b8e35fe7e9318b706e8