Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

Outline

• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
• library ECDSA
•    - function recover(bytes32 hash, bytes ...
•    - function recover(bytes32 hash, uint8 ...
•    - function toEthSignedMessageHash(bytes ...
• interface IAdmin
•    - function isAdmin(address user)
• library SafeMath
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b, st ...
•  contract AirdropAVAX *
•    - function safeTransferAVAX(address to, ...
•    - function withdrawTokens(bytes memory ...
•    - function getSigner(bytes memory signa ...
•    - function checkSignature(bytes memory ...

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at snowscan.xyz on 2021-11-08
*/

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

// File @openzeppelin/contracts/token/ERC20/[email protected]


pragma solidity >=0.6.0 <0.8.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 @openzeppelin/contracts/cryptography/[email protected]


pragma solidity >=0.6.0 <0.8.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)))
        }

        return recover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover-bytes32-bytes-} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
        // 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.
        require(uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0, "ECDSA: invalid signature 's' value");
        require(v == 27 || v == 28, "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 contracts/interfaces/IAdmin.sol

pragma solidity 0.6.12;

interface IAdmin {
    function isAdmin(address user) external view returns (bool);
}


// File contracts/math/SafeMath.sol


pragma solidity >=0.6.0 <0.8.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, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        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) {
        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) {
        // 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) {
        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) {
        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) {
        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) {
        require(b <= a, "SafeMath: subtraction overflow");
        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) {
        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, reverting 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) {
        require(b > 0, "SafeMath: division by zero");
        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) {
        require(b > 0, "SafeMath: modulo by zero");
        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) {
        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.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * 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);
        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) {
        require(b > 0, errorMessage);
        return a % b;
    }
}


// File contracts/airdrop/AirdropAVAX.sol

pragma solidity 0.6.12;




contract AirdropAVAX {

    using ECDSA for bytes32;
    using SafeMath for *;

    IAdmin public admin;
    uint256 public totalTokensWithdrawn;

    mapping (address => bool) public wasClaimed;

    event SentAVAX(address beneficiary, uint256 amount);

    // Constructor, initial setup
    constructor(address _admin) public {
        require(_admin != address(0));
        admin = IAdmin(_admin);
    }

    // Safe transfer AVAX to users
    function safeTransferAVAX(address to, uint256 value) internal {
        // Safely transfer AVAX to address
        (bool success, ) = to.call{value: value}(new bytes(0));
        // Require that transfer was successful.
        require(success, "AVAX transfer failed.");
    }

    // Function to withdraw tokens.
    function withdrawTokens(bytes memory signature, uint256 amount) public {
        // Allow only direct - not contract calls.
        require(msg.sender == tx.origin, "Require that message sender is tx-origin.");
        // Get beneficiary address
        address beneficiary = msg.sender;
        // Verify signature
        require(checkSignature(signature, beneficiary, amount), "Not eligible to claim AVAX!");
        // Make sure user didn't claim
        require(!wasClaimed[beneficiary], "Already claimed AVAX!");
        // Mark that user already claimed.
        wasClaimed[msg.sender] = true;
        // Transfer AVAX to user
        safeTransferAVAX(beneficiary, amount);
        // Increase amount of AVAX withdrawn
        totalTokensWithdrawn = totalTokensWithdrawn.add(amount);
        // Trigger event that AVAX is sent.
        emit SentAVAX(beneficiary, amount);
    }

    // Get who signed the message based on the params
    function getSigner(bytes memory signature, address beneficiary, uint256 amount) public view returns (address) {
        bytes32 hash = keccak256(abi.encodePacked(beneficiary, amount, address(this)));
        bytes32 messageHash = hash.toEthSignedMessageHash();
        return messageHash.recover(signature);
    }

    // Check that signature is valid, and is signed by Admin wallets
    function checkSignature(bytes memory signature, address beneficiary, uint256 amount) public view returns (bool) {
        return admin.isAdmin(getSigner(signature, beneficiary, amount));
    }

    receive() external payable {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_admin","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"beneficiary","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"SentAVAX","type":"event"},{"inputs":[],"name":"admin","outputs":[{"internalType":"contract IAdmin","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"signature","type":"bytes"},{"internalType":"address","name":"beneficiary","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"checkSignature","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"signature","type":"bytes"},{"internalType":"address","name":"beneficiary","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"getSigner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalTokensWithdrawn","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"wasClaimed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"signature","type":"bytes"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

14599:2385:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15391:901;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;15391:901:0;;-1:-1:-1;;15391:901:0;;;-1:-1:-1;15391:901:0;;-1:-1:-1;;15391:901:0:i;:::-;;16355:317;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;16355:317:0;;-1:-1:-1;;;;;;;16355:317:0;;;;-1:-1:-1;;;16355:317:0;;;;:::i;:::-;;;;-1:-1:-1;;;;;16355:317:0;;;;;;;;;;;;;;16750:194;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;16750:194:0;;-1:-1:-1;;;;;;;16750:194:0;;;;-1:-1:-1;;;16750:194:0;;;;:::i;:::-;;;;;;;;;;;;;;;;;;14758:43;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;14758:43:0;-1:-1:-1;;;;;14758:43:0;;:::i;14714:35::-;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;14688:19;;;;;;;;;;;;;:::i;15391:901::-;15533:10;15547:9;15533:23;15525:77;;;;-1:-1:-1;;;15525:77:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15671:10;15729:46;15744:9;15671:10;15768:6;15729:14;:46::i;:::-;15721:86;;;;;-1:-1:-1;;;15721:86:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;15867:23:0;;;;;;:10;:23;;;;;;;;15866:24;15858:58;;;;;-1:-1:-1;;;15858:58:0;;;;;;;;;;;;-1:-1:-1;;;15858:58:0;;;;;;;;;;;;;;;15982:10;15971:22;;;;:10;:22;;;;;:29;;-1:-1:-1;;15971:29:0;15996:4;15971:29;;;16045:37;16062:11;16075:6;16045:16;:37::i;:::-;16162:20;;:32;;16187:6;16162:24;:32::i;:::-;16139:20;:55;16255:29;;;-1:-1:-1;;;;;16255:29:0;;;;;;;;;;;;;;;;;;;;;;;15391:901;;;:::o;16355:317::-;16501:52;;;;;;;-1:-1:-1;;16501:52:0;;;;;;;;;;;;;;;16547:4;16501:52;;;;;;;;;;;;;;;;;;;;;;;16491:63;;;;;-1:-1:-1;;;16587:29:0;16491:63;16587:27;:29::i;:::-;16565:51;-1:-1:-1;16634:30:0;16565:51;16654:9;16634:19;:30::i;:::-;16627:37;16355:317;-1:-1:-1;;;;;;16355:317:0:o;16750:194::-;16856:4;16880:5;;-1:-1:-1;;;;;16880:5:0;:13;16894:41;16904:9;16915:11;16928:6;16894:9;:41::i;:::-;16880:56;;;;;;;;;;;;;-1:-1:-1;;;;;16880:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;16880:56:0;;16750:194;-1:-1:-1;;;;16750:194:0:o;14758:43::-;;;;;;;;;;;;;;;:::o;14714:35::-;;;;:::o;14688:19::-;;;-1:-1:-1;;;;;14688:19:0;;:::o;15065:281::-;15223:12;;;15183;15223;;;;;;;;;-1:-1:-1;;;;;15201:7:0;;;15216:5;;15201:35;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;15201:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15182:54;;;15305:7;15297:41;;;;;-1:-1:-1;;;15297:41:0;;;;;;;;;;;;-1:-1:-1;;;15297:41:0;;;;;;;;;;;;;;;15065:281;;;:::o;9852:179::-;9910:7;9942:5;;;9966:6;;;;9958:46;;;;;-1:-1:-1;;;9958:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;10022:1;9852:179;-1:-1:-1;;;9852:179:0:o;6631:269::-;6833:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6823:69;;;;;;6631:269::o;4010:761::-;4088:7;4151:9;:16;4171:2;4151:22;4147:96;;4190:41;;;-1:-1:-1;;;4190:41:0;;;;;;;;;;;;;;;;;;;;;;;;;;;4147:96;4604:4;4589:20;;4583:27;4650:4;4635:20;;4629:27;4704:4;4689:20;;4683:27;4312:9;4675:36;4741:22;4749:4;4675:36;4583:27;4629;5010:7;5935:66;5921:80;;;5913:127;;;;-1:-1:-1;;;5913:127:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6059:1;:7;;6064:2;6059:7;:18;;;;6070:1;:7;;6075:2;6070:7;6059:18;6051:65;;;;-1:-1:-1;;;6051:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6214:14;6231:24;6241:4;6247:1;6250;6253;6231:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;6231:24:0;;-1:-1:-1;;6231:24:0;;;-1:-1:-1;;;;;;;6274:20:0;;6266:57;;;;;-1:-1:-1;;;6266:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;6343:6;4925:1432;-1:-1:-1;;;;;4925:1432:0:o

ipfs://77df5f9f421cad75221f02b28d55e96dc79b4be218ae5e656ec055e957fded34