Token Yak Token

Overview ERC20

Price
$207.69 @ 15.927123 AVAX (+3.44%)
Fully Diluted Market Cap
Total Supply:
10,000 YAK

Holders:
2,230 addresses

Transfers:
-

Loading
[ Download CSV Export  ] 
Loading
[ Download CSV Export  ] 
Loading

OVERVIEW

Yield Yak is an easy-to-use tool to earn more yield from defi farming on the Avalanche network.

Market

Volume (24H):$5,010.17
Market Capitalization:$0.00
Circulating Supply:0.00 YAK
Market Data Source: Coinmarketcap


Update? Click here to update the token ICO / general information
# Exchange Pair Price  24H Volume % Volume

Contract Source Code Verified (Exact Match)

Contract Name:
YakToken

Compiler Version
v0.7.3+commit.9bfce1f6

Optimization Enabled:
Yes with 9999 runs

Other Settings:
default evmVersion, MIT license
/**
 *Submitted for verification at Etherscan.io on 2021-11-03
*/

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

// File contracts/lib/SafeMath.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;

// From https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/math/Math.sol
// Subject to the MIT license.

/**
 * @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 addition of two unsigned integers, reverting with custom message on overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, errorMessage);

        return c;
    }

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

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on underflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot underflow.
     */
    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 multiplication of two unsigned integers, reverting on overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b, string memory errorMessage) 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, errorMessage);

        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) {
        // Solidity only automatically asserts when dividing by 0
        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 contracts/YakToken.sol

pragma experimental ABIEncoderV2;

/**
 * @title YakToken
 * @dev The governance token for Yield Yak
 * ERC-20 with fixed supply + offchain signing
 */
contract YakToken {
    using SafeMath for uint256;

    /// @notice EIP-20 token name for this token
    string public name = "Yak Token";

    /// @notice EIP-20 token symbol for this token
    string public symbol = "YAK";

    /// @notice EIP-20 token decimals for this token
    uint8 public constant decimals = 18;

    /// @notice Total number of tokens in circulation
    uint256 public totalSupply = 10_000e18; // 10,000

    /// @dev Allowance amounts on behalf of others
    mapping (address => mapping (address => uint256)) internal allowances;

    /// @dev Official record of token balances for each account
    mapping (address => uint256) internal balances;

    /// @notice The EIP-712 typehash for the contract's domain
    bytes32 public constant DOMAIN_TYPEHASH = 0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f;
    
    /// @notice The EIP-712 version hash
    bytes32 public constant VERSION_HASH = 0xc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc6;

    /// @notice The EIP-712 typehash for permit (EIP-2612)
    bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;

    /// @notice A record of states for signing / validating signatures
    mapping (address => uint) public nonces;

    /// @notice The standard EIP-20 transfer event
    event Transfer(address indexed from, address indexed to, uint256 value);

    /// @notice The standard EIP-20 approval event
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @notice Create and send entire token supply to _recipient
     */
    constructor(address _recipient) {
        balances[_recipient] = totalSupply;
        emit Transfer(address(0), _recipient, totalSupply);
    }

    /**
     * @notice Get the number of tokens `spender` is approved to spend on behalf of `account`
     * @param account The address of the account holding the funds
     * @param spender The address of the account spending the funds
     * @return The number of tokens approved
     */
    function allowance(address account, address spender) external view returns (uint) {
        return allowances[account][spender];
    }

    /**
     * @notice Approve `spender` to transfer up to `amount` from `src`
     * @dev This will overwrite the approval amount for `spender`
     * and is subject to issues noted [here](https://eips.ethereum.org/EIPS/eip-20#approve)
     * It is recommended to use increaseAllowance and decreaseAllowance instead
     * @param spender The address of the account which may transfer tokens
     * @param amount The number of tokens that are approved (2^256-1 means infinite)
     * @return Whether or not the approval succeeded
     */
    function approve(address spender, uint256 amount) external returns (bool) {
        _approve(msg.sender, spender, amount);
        return true;
    }

    /**
     * @notice Increase the allowance by a given amount
     * @param spender Spender's address
     * @param addedValue Amount of increase in allowance
     * @return True if successful
     */
    function increaseAllowance(address spender, uint256 addedValue)
        external
        returns (bool)
    {
        _increaseAllowance(msg.sender, spender, addedValue);
        return true;
    }

    /**
     * @notice Decrease the allowance by a given amount
     * @param spender Spender's address
     * @param subtractedValue Amount of decrease in allowance
     * @return True if successful
     */
    function decreaseAllowance(address spender, uint256 subtractedValue)
        external
        returns (bool)
    {
        _decreaseAllowance(msg.sender, spender, subtractedValue);
        return true;
    }

    /**
     * @notice Triggers an approval from owner to spender
     * @param owner The address to approve from
     * @param spender The address to be approved
     * @param value The number of tokens that are approved (2^256-1 means infinite)
     * @param deadline The time at which to expire the signature
     * @param v The recovery byte of the signature
     * @param r Half of the ECDSA signature pair
     * @param s Half of the ECDSA signature pair
     */
    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external {
        require(deadline >= block.timestamp, "Yak::permit: signature expired");

        bytes32 encodeData = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonces[owner]++, deadline));
        _validateSignedData(owner, encodeData, v, r, s);

        _approve(owner, spender, value);
    }

    /**
     * @notice Get the number of tokens held by the `account`
     * @param account The address of the account to get the balance of
     * @return The number of tokens held
     */
    function balanceOf(address account) external view returns (uint) {
        return balances[account];
    }

    /**
     * @notice Transfer `amount` tokens from `msg.sender` to `dst`
     * @param dst The address of the destination account
     * @param amount The number of tokens to transfer
     * @return Whether or not the transfer succeeded
     */
    function transfer(address dst, uint256 amount) external returns (bool) {
        _transferTokens(msg.sender, dst, amount);
        return true;
    }

    /**
     * @notice Transfer `amount` tokens from `src` to `dst`
     * @param src The address of the source account
     * @param dst The address of the destination account
     * @param amount The number of tokens to transfer
     * @return Whether or not the transfer succeeded
     */
    function transferFrom(address src, address dst, uint256 amount) external returns (bool) {
        address spender = msg.sender;
        uint256 spenderAllowance = allowances[src][spender];

        if (spender != src && spenderAllowance != uint256(-1)) {
            uint256 newAllowance = spenderAllowance.sub(
                amount,
                "Yak::transferFrom: transfer amount exceeds allowance"
            );
            allowances[src][spender] = newAllowance;

            emit Approval(src, spender, newAllowance);
        }

        _transferTokens(src, dst, amount);
        return true;
    }

    /**
     * @notice EIP-712 Domain separator
     * @return Separator
     */
    function getDomainSeparator() public view returns (bytes32) {
        return keccak256(
            abi.encode(
                DOMAIN_TYPEHASH,
                keccak256(bytes(name)),
                VERSION_HASH,
                _getChainId(),
                address(this)
            )
        );
    }

    /**
     * @notice Recovers address from signed data and validates the signature
     * @param signer Address that signed the data
     * @param encodeData Data signed by the address
     * @param v The recovery byte of the signature
     * @param r Half of the ECDSA signature pair
     * @param s Half of the ECDSA signature pair
     */
    function _validateSignedData(address signer, bytes32 encodeData, uint8 v, bytes32 r, bytes32 s) internal view {
        bytes32 digest = keccak256(
            abi.encodePacked(
                "\x19\x01",
                getDomainSeparator(),
                encodeData
            )
        );
        address recoveredAddress = ecrecover(digest, v, r, s);
        // Explicitly disallow authorizations for address(0) as ecrecover returns address(0) on malformed messages
        require(recoveredAddress != address(0) && recoveredAddress == signer, "Yak::validateSig: invalid signature");
    }

    /**
     * @notice Approval implementation
     * @param owner The address of the account which owns tokens
     * @param spender The address of the account which may transfer tokens
     * @param amount The number of tokens that are approved (2^256-1 means infinite)
     */
    function _approve(address owner, address spender, uint256 amount) internal {
        require(owner != address(0), "Yak::_approve: approve from the zero address");
        require(spender != address(0), "Yak::_approve: approve to the zero address");
        allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    function _increaseAllowance(
        address owner,
        address spender,
        uint256 addedValue
    ) internal {
        _approve(owner, spender, allowances[owner][spender].add(addedValue));
    }

    function _decreaseAllowance(
        address owner,
        address spender,
        uint256 subtractedValue
    ) internal {
        _approve(
            owner,
            spender,
            allowances[owner][spender].sub(
                subtractedValue,
                "Yak::_decreaseAllowance: decreased allowance below zero"
            )
        );
    }

    /**
     * @notice Transfer implementation
     * @param from The address of the account which owns tokens
     * @param to The address of the account which is receiving tokens
     * @param value The number of tokens that are being transferred
     */
    function _transferTokens(address from, address to, uint256 value) internal {
        require(to != address(0), "Yak::_transferTokens: cannot transfer to the zero address");

        balances[from] = balances[from].sub(
            value,
            "Yak::_transferTokens: transfer exceeds from balance"
        );
        balances[to] = balances[to].add(value);
        emit Transfer(from, to, value);
    }

    /**
     * @notice Current id of the chain where this contract is deployed
     * @return Chain id
     */
    function _getChainId() internal pure returns (uint) {
        uint256 chainId;
        assembly { chainId := chainid() }
        return chainId;
    }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"_recipient","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DOMAIN_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERMIT_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"VERSION_HASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getDomainSeparator","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"dst","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"src","type":"address"},{"internalType":"address","name":"dst","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000dcedf06fd33e1d7b6eb4b309f779a0e9d3172e44

-----Decoded View---------------
Arg [0] : _recipient (address): 0xdcedf06fd33e1d7b6eb4b309f779a0e9d3172e44

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


Deployed ByteCode Sourcemap

6929:10013:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7039:32;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9762:152;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;7322:38::-;;;:::i;:::-;;;;;;;:::i;7693:108::-;;;:::i;12721:627::-;;;;;;:::i;:::-;;:::i;8030:108::-;;;:::i;7223:35::-;;;:::i;:::-;;;;;;;:::i;10131:203::-;;;;;;:::i;:::-;;:::i;11893:108::-;;;;;;:::i;:::-;;:::i;8219:39::-;;;;;;:::i;:::-;;:::i;7132:28::-;;;:::i;7856:105::-;;;:::i;10556:213::-;;;;;;:::i;:::-;;:::i;12262:152::-;;;;;;:::i;:::-;;:::i;11256:434::-;;;;;;:::i;:::-;;:::i;:::-;;9071:136;;;;;;:::i;:::-;;:::i;13441:316::-;;;:::i;7039:32::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;9762:152::-;9830:4;9847:37;9856:10;9868:7;9877:6;9847:8;:37::i;:::-;-1:-1:-1;9902:4:0;9762:152;;;;:::o;7322:38::-;;;;:::o;7693:108::-;7735:66;7693:108;:::o;12721:627::-;12886:15;;;12803:4;12886:15;;;:10;:15;;;;;;;;12838:10;12886:24;;;;;;;;12803:4;;12838:10;;12886:24;12927:14;;;;;:49;;;12973:2;12945:16;:31;;12927:49;12923:350;;;12993:20;13016:133;13055:6;13016:133;;;;;;;;;;;;;;;;;:16;;:133;:20;:133::i;:::-;13164:15;;;;;;;;:10;:15;;;;;;;;:24;;;;;;;;;;;;;;:39;;;13225:36;12993:156;;-1:-1:-1;13164:24:0;;13225:36;;;;12993:156;;13225:36;:::i;:::-;;;;;;;;12923:350;;13285:33;13301:3;13306;13311:6;13285:15;:33::i;:::-;-1:-1:-1;13336:4:0;;12721:627;-1:-1:-1;;;;;12721:627:0:o;8030:108::-;8072:66;8030:108;:::o;7223:35::-;7256:2;7223:35;:::o;10131:203::-;10231:4;10253:51;10272:10;10284:7;10293:10;10253:18;:51::i;11893:108::-;11976:17;;;11952:4;11976:17;;;:8;:17;;;;;;11893:108;;;;:::o;8219:39::-;;;;;;;;;;;;;:::o;7132:28::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7856:105;7895:66;7856:105;:::o;10556:213::-;10661:4;10683:56;10702:10;10714:7;10723:15;10683:18;:56::i;12262:152::-;12327:4;12344:40;12360:10;12372:3;12377:6;12344:15;:40::i;11256:434::-;11408:15;11396:8;:27;;11388:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;11553:13;;;11471:18;11553:13;;;:6;:13;;;;;;;;:15;;;;;;;;11502:77;;;;8072:66;;11530:5;;11537:7;;11546:5;;11553:15;11570:8;;11502:77;;:::i;:::-;;;;;;;;;;;;;11492:88;;;;;;11471:109;;11591:47;11611:5;11618:10;11630:1;11633;11636;11591:19;:47::i;:::-;11651:31;11660:5;11667:7;11676:5;11651:8;:31::i;:::-;11256:434;;;;;;;;:::o;9071:136::-;9171:19;;;;9147:4;9171:19;;;:10;:19;;;;;;;;:28;;;;;;;;;;;;;9071:136::o;13441:316::-;13492:7;7735:66;13572:15;;13622:4;13606:22;;;;;;:::i;:::-;;;;;;;;;7895:66;13678:13;:11;:13::i;:::-;13718:4;13543:195;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;13519:230;;;;;;13512:237;;13441:316;:::o;15019:351::-;15113:19;;;15105:76;;;;;;;;;;;;:::i;:::-;15200:21;;;15192:76;;;;;;;;;;;;:::i;:::-;15279:17;;;;;;;;:10;:17;;;;;;;;:26;;;;;;;;;;;;;;:35;;;15330:32;;;;;15308:6;;15330:32;:::i;:::-;;;;;;;;15019:351;;;:::o;2439:192::-;2525:7;2561:12;2553:6;;;;2545:29;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;2597:5:0;;;2439:192::o;16245:417::-;16339:16;;;16331:86;;;;;;;;;;;;:::i;:::-;16447:117;16480:5;16447:117;;;;;;;;;;;;;;;;;:14;;;;;;;:8;:14;;;;;;;:117;:18;:117::i;:::-;16430:14;;;;;;;;:8;:14;;;;;;:134;;;;16590:12;;;;;;;:23;;16607:5;16590:16;:23::i;:::-;16575:12;;;;;;;;:8;:12;;;;;;;:38;;;;16629:25;;;;;;;;;;16648:5;;16629:25;:::i;15378:210::-;15537:17;;;;;;;;:10;:17;;;;;;;;:26;;;;;;;;;;15512:68;;15521:5;;15528:7;;15537:42;;15568:10;15537:30;:42::i;:::-;15512:8;:68::i;:::-;15378:210;;;:::o;15596:378::-;15735:231;15758:5;15778:7;15800:155;15849:15;15800:155;;;;;;;;;;;;;;;;;:17;;;;;;;;:10;:17;;;;;;;;:26;;;;;;;;;;;:155;:30;:155::i;14117:608::-;14238:14;14343:20;:18;:20::i;:::-;14382:10;14279:128;;;;;;;;;:::i;:::-;;;;;;;;;;;;;14255:163;;;;;;14238:180;;14429:24;14456:26;14466:6;14474:1;14477;14480;14456:26;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;14456:26:0;;;;;;-1:-1:-1;;14617:30:0;;;;;;;:60;;;14671:6;14651:26;;:16;:26;;;14617:60;14609:108;;;;;;;;;;;;:::i;:::-;14117:608;;;;;;;:::o;16785:154::-;16896:9;16785:154;:::o;1120:181::-;1178:7;1210:5;;;1234:6;;;;1226:46;;;;;;;;;;;;:::i;:::-;1292:1;1120:181;-1:-1:-1;;;1120:181:0:o;14:198:1:-;84:20;;144:42;133:54;;123:65;;113:2;;202:1;199;192:12;217:198;;329:2;317:9;308:7;304:23;300:32;297:2;;;350:6;342;335:22;297:2;378:31;399:9;378:31;:::i;420:274::-;;;549:2;537:9;528:7;524:23;520:32;517:2;;;570:6;562;555:22;517:2;598:31;619:9;598:31;:::i;:::-;588:41;;648:40;684:2;673:9;669:18;648:40;:::i;:::-;638:50;;507:187;;;;;:::o;699:342::-;;;;845:2;833:9;824:7;820:23;816:32;813:2;;;866:6;858;851:22;813:2;894:31;915:9;894:31;:::i;:::-;884:41;;944:40;980:2;969:9;965:18;944:40;:::i;:::-;934:50;;1031:2;1020:9;1016:18;1003:32;993:42;;803:238;;;;;:::o;1046:717::-;;;;;;;;1258:3;1246:9;1237:7;1233:23;1229:33;1226:2;;;1280:6;1272;1265:22;1226:2;1308:31;1329:9;1308:31;:::i;:::-;1298:41;;1358:40;1394:2;1383:9;1379:18;1358:40;:::i;:::-;1348:50;;1445:2;1434:9;1430:18;1417:32;1407:42;;1496:2;1485:9;1481:18;1468:32;1458:42;;1550:3;1539:9;1535:19;1522:33;1595:4;1588:5;1584:16;1577:5;1574:27;1564:2;;1620:6;1612;1605:22;1564:2;1216:547;;;;-1:-1:-1;1216:547:1;;;;1648:5;1700:3;1685:19;;1672:33;;-1:-1:-1;1752:3:1;1737:19;;;1724:33;;1216:547;-1:-1:-1;;1216:547:1:o;1768:266::-;;;1897:2;1885:9;1876:7;1872:23;1868:32;1865:2;;;1918:6;1910;1903:22;1865:2;1946:31;1967:9;1946:31;:::i;:::-;1936:41;2024:2;2009:18;;;;1996:32;;-1:-1:-1;;;1855:179:1:o;2039:888::-;;2198:3;2233:6;2227:13;2259:1;2291:2;2280:9;2276:18;2308:1;2303:184;;;;2501:1;2496:406;;;;2269:633;;2303:184;2351:66;2340:9;2336:82;2331:3;2324:95;2471:4;2467:1;2456:9;2452:17;2448:28;2443:3;2439:38;2432:45;;2303:184;;2496:406;2546:1;2535:9;2531:17;2573:6;2568:3;2561:19;2603:4;2650:2;2645:3;2635:18;2675:3;2691:165;2705:6;2702:1;2699:13;2691:165;;;2783:14;;2770:11;;;2763:35;2826:16;;;;2720:10;;2691:165;;;-1:-1:-1;;;2876:16:1;;;-1:-1:-1;2269:633:1;-1:-1:-1;2918:3:1;;2177:750;-1:-1:-1;;;;;2177:750:1:o;2932:444::-;3202:66;3190:79;;3294:1;3285:11;;3278:27;;;;3330:2;3321:12;;3314:28;3367:2;3358:12;;3180:196::o;3381:187::-;3546:14;;3539:22;3521:41;;3509:2;3494:18;;3476:92::o;3573:177::-;3719:25;;;3707:2;3692:18;;3674:76::o;3755:614::-;4042:25;;;4086:42;4164:15;;;4159:2;4144:18;;4137:43;4216:15;;;;4211:2;4196:18;;4189:43;4263:2;4248:18;;4241:34;4306:3;4291:19;;4284:35;;;;4350:3;4335:19;;4328:35;4029:3;4014:19;;3996:373::o;4374:512::-;4633:25;;;4689:2;4674:18;;4667:34;;;;4732:2;4717:18;;4710:34;;;;4775:2;4760:18;;4753:34;4836:42;4824:55;4818:3;4803:19;;4796:84;4620:3;4605:19;;4587:299::o;4891:398::-;5118:25;;;5191:4;5179:17;;;;5174:2;5159:18;;5152:45;5228:2;5213:18;;5206:34;5271:2;5256:18;;5249:34;5105:3;5090:19;;5072:217::o;5294:662::-;;5435:2;5464;5453:9;5446:21;5496:6;5490:13;5539:6;5534:2;5523:9;5519:18;5512:34;5564:4;5577:140;5591:6;5588:1;5585:13;5577:140;;;5686:14;;;5682:23;;5676:30;5652:17;;;5671:2;5648:26;5641:66;5606:10;;5577:140;;;5735:6;5732:1;5729:13;5726:2;;;5805:4;5800:2;5791:6;5780:9;5776:22;5772:31;5765:45;5726:2;-1:-1:-1;5872:2:1;5860:15;5877:66;5856:88;5841:104;;;;5947:2;5837:113;;5415:541;-1:-1:-1;;;5415:541:1:o;5961:351::-;6163:2;6145:21;;;6202:2;6182:18;;;6175:30;6241:29;6236:2;6221:18;;6214:57;6303:2;6288:18;;6135:177::o;6317:408::-;6519:2;6501:21;;;6558:2;6538:18;;;6531:30;6597:34;6592:2;6577:18;;6570:62;6668:14;6663:2;6648:18;;6641:42;6715:3;6700:19;;6491:234::o;6730:399::-;6932:2;6914:21;;;6971:2;6951:18;;;6944:30;7010:34;7005:2;6990:18;;6983:62;7081:5;7076:2;7061:18;;7054:33;7119:3;7104:19;;6904:225::o;7134:354::-;7336:2;7318:21;;;7375:2;7355:18;;;7348:30;7414:32;7409:2;7394:18;;7387:60;7479:2;7464:18;;7308:180::o;7493:406::-;7695:2;7677:21;;;7734:2;7714:18;;;7707:30;7773:34;7768:2;7753:18;;7746:62;7844:12;7839:2;7824:18;;7817:40;7889:3;7874:19;;7667:232::o;7904:421::-;8106:2;8088:21;;;8145:2;8125:18;;;8118:30;8184:34;8179:2;8164:18;;8157:62;8255:27;8250:2;8235:18;;8228:55;8315:3;8300:19;;8078:247::o;8512:184::-;8684:4;8672:17;;;;8654:36;;8642:2;8627:18;;8609:87::o

Swarm Source

ipfs://649beba6913c45cb172354df3e7e548a55f2f580cdc58466d446c3846cd16718
Loading