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 Airdrop *
•    - 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-09
*/

// 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/Airdrop.sol

pragma solidity 0.6.12;




contract Airdrop {

    using ECDSA for bytes32;
    using SafeMath for *;

    IERC20 public airdropToken;
    IAdmin public admin;
    uint256 public totalTokensWithdrawn;

    mapping (address => bool) public wasClaimed;

    event TokensAirdropped(address beneficiary, uint256 amount);

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

        admin = IAdmin(_admin);
        airdropToken = IERC20(_airdropToken);
    }

    // Function to withdraw tokens.
    function withdrawTokens(bytes memory signature, uint256 amount) public {
        require(msg.sender == tx.origin, "Require that message sender is tx-origin.");

        address beneficiary = msg.sender;

        require(checkSignature(signature, beneficiary, amount), "Not eligible to claim tokens!");
        require(!wasClaimed[beneficiary], "Already claimed!");
        wasClaimed[msg.sender] = true;

        bool status = airdropToken.transfer(beneficiary, amount);
        require(status, "Token transfer status is false.");

        totalTokensWithdrawn = totalTokensWithdrawn.add(amount);
        emit TokensAirdropped(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));
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_airdropToken","type":"address"},{"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":"TokensAirdropped","type":"event"},{"inputs":[],"name":"admin","outputs":[{"internalType":"contract IAdmin","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"airdropToken","outputs":[{"internalType":"contract IERC20","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"}]

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

14597:1948:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15220:668;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;15220:668:0;;-1:-1:-1;;15220:668:0;;;-1:-1:-1;15220:668:0;;-1:-1:-1;;15220:668:0:i;:::-;;15951:317;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;15951:317:0;;-1:-1:-1;;;;;;;15951:317:0;;;;-1:-1:-1;;;15951:317:0;;;;:::i;:::-;;;;-1:-1:-1;;;;;15951:317:0;;;;;;;;;;;;;;14682:26;;;:::i;16346:194::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;16346:194:0;;-1:-1:-1;;;;;;;16346:194:0;;;;-1:-1:-1;;;16346:194:0;;;;:::i;:::-;;;;;;;;;;;;;;;;;;14785:43;;;;;;;;;;;;;;;;-1:-1:-1;14785:43:0;-1:-1:-1;;;;;14785:43:0;;:::i;14741:35::-;;;:::i;:::-;;;;;;;;;;;;;;;;14715:19;;;:::i;15220:668::-;15310:10;15324:9;15310:23;15302:77;;;;-1:-1:-1;;;15302:77:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15414:10;15445:46;15460:9;15414:10;15484:6;15445:14;:46::i;:::-;15437:88;;;;;-1:-1:-1;;;15437:88:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;15545:23:0;;;;;;:10;:23;;;;;;;;15544:24;15536:53;;;;;-1:-1:-1;;;15536:53:0;;;;;;;;;;;;-1:-1:-1;;;15536:53:0;;;;;;;;;;;;;;;15611:10;15600:22;;;;:10;:22;;;;;;;;:29;;-1:-1:-1;;15600:29:0;15625:4;15600:29;;;15656:12;;:42;;-1:-1:-1;;;15656:42:0;;-1:-1:-1;;;;;15656:42:0;;;;;;;;;;;;;;;:12;;;;;:21;;:42;;;;;;;;;;;15600:22;15656:12;:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;15656:42:0;;-1:-1:-1;15656:42:0;15709:50;;;;;-1:-1:-1;;;15709:50:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;15795:20;;:32;;15820:6;15795:24;:32::i;:::-;15772:20;:55;15843:37;;;-1:-1:-1;;;;;15843:37:0;;;;;;;;;;;;;;;;;;;;;;;15220:668;;;;:::o;15951:317::-;16097:52;;;;;;;-1:-1:-1;;16097:52:0;;;;;;;;;;;;;;;16143:4;16097:52;;;;;;;;;;;;;;;;;;;;;;;16087:63;;;;;-1:-1:-1;;;16183:29:0;16087:63;16183:27;:29::i;:::-;16161:51;-1:-1:-1;16230:30:0;16161:51;16250:9;16230:19;:30::i;:::-;16223:37;15951:317;-1:-1:-1;;;;;;15951:317:0:o;14682:26::-;;;-1:-1:-1;;;;;14682:26:0;;:::o;16346:194::-;16476:5;;16452:4;;-1:-1:-1;;;;;16476:5:0;:13;16490:41;16500:9;16511:11;16524:6;16490:9;:41::i;:::-;16476:56;;;;;;;;;;;;;-1:-1:-1;;;;;16476:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;16476:56:0;;16346:194;-1:-1:-1;;;;16346:194:0:o;14785:43::-;;;;;;;;;;;;;;;:::o;14741:35::-;;;;:::o;14715:19::-;;;-1:-1:-1;;;;;14715:19:0;;:::o;9854:179::-;9912:7;9944:5;;;9968:6;;;;9960:46;;;;;-1:-1:-1;;;9960:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;10024:1;9854:179;-1:-1:-1;;;9854: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://5180bc349782d80ef7e858731eaf3fff274f3213757b0f27e3e3513ec591656d