creation_sourcecode: // SPDX-License-Identifier: MIT
  pragma solidity ^0.8.0;
  
  /**
  
  ██████╗  █████╗ ██████╗  █████╗ ██████╗  ██████╗ ██╗      █████╗ 
  ██╔══██╗██╔══██╗██╔══██╗██╔══██╗██╔═══██╗██║     ██╔══██╗
  ██████╔╝███████║██████╔╝███████║██████╔╝██║   ██║██║     ███████║
  ██╔═══╝ ██╔══██║██╔══██╗██╔══██║██╔══██╗██║   ██║██║     ██╔══██║
  ██║     ██║  ██║██║  ██║██║  ██║██████╔╝╚██████╔╝███████╗██║  ██║
  ╚═╝     ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝  ╚══════╝╚═╝  ╚═╝
  
  */
  
  /**
   * @title Parabola Challenge using Activities protocol v1.0.3 via PanaceaCryptoLab
   *
   * @dev A parabola is the set of all points that are equidistant to a fixed point (called the focus) 
   * and a fixed straight line (called the directrix). The focus lies on the axis of symmetry of the
   * parabola, and the distance between the focus and any point on the parabola is equal to the perpendicular 
   * distance between that point and the directrix. It is simply a quadratic equation and have solution that 
   * can be found using methods like factoring, completing the square, or using the quadratic formula.
   *
   * As we know from algebra, a parabola is described by a quadratic equation of the form y=ax^2+bx+c,
   * where a, b, and c are constants, and x is the variable. This equation represents a symmetrical curve
   * that opens upwards or downwards, depending on the sign of a.
   *
   * As we venture forward, the path remains intriguing until the end;
   * — Are you smart enough to decrypt the message? 
   */
  
  // OpenZeppelin's IERC721 interface
  interface IERC721 {
      function balanceOf(address owner) external view returns (uint256 balance);
      function ownerOf(uint256 tokenId) external view returns (address owner);
      function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
      function safeTransferFrom(address from, address to, uint256 tokenId) external;
      function transferFrom(address from, address to, uint256 tokenId) external;
      function approve(address to, uint256 tokenId) external;
      function setApprovalForAll(address operator, bool _approved) external;
      function getApproved(uint256 tokenId) external view returns (address operator);
      function isApprovedForAll(address owner, address operator) external view returns (bool);
  }
  
  contract Parabola {
      address public immutable Nossumus;
      address public Magellan;
      address public Panacea;
      
      bytes32 private encryptedMessage;
  
      bool public messageEncrypted;
      bool public messageDecrypted;
  
      event MessageEncrypted(string message);
      event noteDecrypted(bool isExactMatch, address sender);
      event MessageDecrypted(bool isExactMatch, address Magellan);
      event AmatVictoriaCuram(string message, bytes32 hash);
  
      modifier onlyNossumus() {
          require(msg.sender == Nossumus, "4caa4d6e85ff34b7812f0b2c7e1e922631b52b2a6b2e36b42d836ae7a12ecbd2");
          _;
      }
  
      constructor(bytes32 hash, address tokenContract) {
          Nossumus = msg.sender;
          Panacea = tokenContract;
          encryptedMessage = hash;
          messageEncrypted = true;
          messageDecrypted = false;
  
          emit MessageEncrypted("The message is encrypted using the robust Keccak-256 hash algorithm before it is stored in the contract to ensure secure communication. This process takes plaintext as input and returns the encrypted message, which is a one-way process, protecting information from unauthorized access during transmission. This means the message will be decrypted if the hash value of an input string corresponds to the encrypted message hash. As we venture forward, the path remains intriguing until the end; - Are you smart enough to decrypt the message?");
      }
  
      /**
      * @dev  A snippet from Panacea.sol
      *
      * Activities protocol v1.0.3 has been successfully installed!
      *
      * Tredecim was informed that Magellan has arrived and is eager to claim his Parabola Award.
      *
      *   address payable[] recipients;
      *
      *   function parabolaAward(address payable recipient) public onlyOwner {
      *       address magellan;
      *       magellan = recipient;
      *       recipient.transfer(100 ether);
      */
  
      // Decrypt the message if the input string is equal to the encrypted message hash
      function decryptMessage(string memory input) external returns (string memory) {
          require(checkOwnership(msg.sender), "ACCESS DENIED!"); // Membership access verification
          bytes32 inputHash = keccak256(abi.encodePacked(input)); // Hash the input string
  
          if (inputHash == encryptedMessage) {
              messageDecrypted = true; // Mark the message as decrypted
              Magellan = msg.sender; // Store the address of Magellan
              emit MessageDecrypted(true, Magellan);
              emit AmatVictoriaCuram("Encrypted Message Hash", encryptedMessage);
              return string(abi.encodePacked("YOU ARE SMART ENOUGH: ", input));
          } else {
              emit noteDecrypted(false, msg.sender);
              return "YOU ARE NOT SMART ENOUGH :)";
          }
      }
  
      function checkOwnership(address _owner) internal view returns (bool) {
          return IERC721(Panacea).balanceOf(_owner) > 0;
      }
  }