creation_sourcecode: // File: hardhat/console.sol
  
  
  pragma solidity >=0.4.22 <0.9.0;
  
  library console {
      address constant CONSOLE_ADDRESS =
          0x000000000000000000636F6e736F6c652e6c6f67;
  
      function _sendLogPayloadImplementation(bytes memory payload) internal view {
          address consoleAddress = CONSOLE_ADDRESS;
          /// @solidity memory-safe-assembly
          assembly {
              pop(
                  staticcall(
                      gas(),
                      consoleAddress,
                      add(payload, 32),
                      mload(payload),
                      0,
                      0
                  )
              )
          }
      }
  
      function _castToPure(
        function(bytes memory) internal view fnIn
      ) internal pure returns (function(bytes memory) pure fnOut) {
          assembly {
              fnOut := fnIn
          }
      }
  
      function _sendLogPayload(bytes memory payload) internal pure {
          _castToPure(_sendLogPayloadImplementation)(payload);
      }
  
      function log() internal pure {
          _sendLogPayload(abi.encodeWithSignature("log()"));
      }
      function logInt(int256 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(int256)", p0));
      }
  
      function logUint(uint256 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256)", p0));
      }
  
      function logString(string memory p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string)", p0));
      }
  
      function logBool(bool p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
      }
  
      function logAddress(address p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address)", p0));
      }
  
      function logBytes(bytes memory p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bytes)", p0));
      }
  
      function logBytes1(bytes1 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bytes1)", p0));
      }
  
      function logBytes2(bytes2 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bytes2)", p0));
      }
  
      function logBytes3(bytes3 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bytes3)", p0));
      }
  
      function logBytes4(bytes4 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bytes4)", p0));
      }
  
      function logBytes5(bytes5 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bytes5)", p0));
      }
  
      function logBytes6(bytes6 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bytes6)", p0));
      }
  
      function logBytes7(bytes7 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bytes7)", p0));
      }
  
      function logBytes8(bytes8 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bytes8)", p0));
      }
  
      function logBytes9(bytes9 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bytes9)", p0));
      }
  
      function logBytes10(bytes10 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bytes10)", p0));
      }
  
      function logBytes11(bytes11 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bytes11)", p0));
      }
  
      function logBytes12(bytes12 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bytes12)", p0));
      }
  
      function logBytes13(bytes13 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bytes13)", p0));
      }
  
      function logBytes14(bytes14 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bytes14)", p0));
      }
  
      function logBytes15(bytes15 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bytes15)", p0));
      }
  
      function logBytes16(bytes16 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bytes16)", p0));
      }
  
      function logBytes17(bytes17 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bytes17)", p0));
      }
  
      function logBytes18(bytes18 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bytes18)", p0));
      }
  
      function logBytes19(bytes19 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bytes19)", p0));
      }
  
      function logBytes20(bytes20 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bytes20)", p0));
      }
  
      function logBytes21(bytes21 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bytes21)", p0));
      }
  
      function logBytes22(bytes22 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bytes22)", p0));
      }
  
      function logBytes23(bytes23 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bytes23)", p0));
      }
  
      function logBytes24(bytes24 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bytes24)", p0));
      }
  
      function logBytes25(bytes25 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bytes25)", p0));
      }
  
      function logBytes26(bytes26 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bytes26)", p0));
      }
  
      function logBytes27(bytes27 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bytes27)", p0));
      }
  
      function logBytes28(bytes28 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bytes28)", p0));
      }
  
      function logBytes29(bytes29 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bytes29)", p0));
      }
  
      function logBytes30(bytes30 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bytes30)", p0));
      }
  
      function logBytes31(bytes31 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bytes31)", p0));
      }
  
      function logBytes32(bytes32 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0));
      }
  
      function log(uint256 p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256)", p0));
      }
  
      function log(string memory p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string)", p0));
      }
  
      function log(bool p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
      }
  
      function log(address p0) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address)", p0));
      }
  
      function log(uint256 p0, uint256 p1) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256)", p0, p1));
      }
  
      function log(uint256 p0, string memory p1) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,string)", p0, p1));
      }
  
      function log(uint256 p0, bool p1) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,bool)", p0, p1));
      }
  
      function log(uint256 p0, address p1) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,address)", p0, p1));
      }
  
      function log(string memory p0, uint256 p1) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,uint256)", p0, p1));
      }
  
      function log(string memory p0, string memory p1) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1));
      }
  
      function log(string memory p0, bool p1) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,bool)", p0, p1));
      }
  
      function log(string memory p0, address p1) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,address)", p0, p1));
      }
  
      function log(bool p0, uint256 p1) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,uint256)", p0, p1));
      }
  
      function log(bool p0, string memory p1) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,string)", p0, p1));
      }
  
      function log(bool p0, bool p1) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,bool)", p0, p1));
      }
  
      function log(bool p0, address p1) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,address)", p0, p1));
      }
  
      function log(address p0, uint256 p1) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,uint256)", p0, p1));
      }
  
      function log(address p0, string memory p1) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,string)", p0, p1));
      }
  
      function log(address p0, bool p1) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,bool)", p0, p1));
      }
  
      function log(address p0, address p1) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,address)", p0, p1));
      }
  
      function log(uint256 p0, uint256 p1, uint256 p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256)", p0, p1, p2));
      }
  
      function log(uint256 p0, uint256 p1, string memory p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string)", p0, p1, p2));
      }
  
      function log(uint256 p0, uint256 p1, bool p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool)", p0, p1, p2));
      }
  
      function log(uint256 p0, uint256 p1, address p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address)", p0, p1, p2));
      }
  
      function log(uint256 p0, string memory p1, uint256 p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256)", p0, p1, p2));
      }
  
      function log(uint256 p0, string memory p1, string memory p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string)", p0, p1, p2));
      }
  
      function log(uint256 p0, string memory p1, bool p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool)", p0, p1, p2));
      }
  
      function log(uint256 p0, string memory p1, address p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address)", p0, p1, p2));
      }
  
      function log(uint256 p0, bool p1, uint256 p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256)", p0, p1, p2));
      }
  
      function log(uint256 p0, bool p1, string memory p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string)", p0, p1, p2));
      }
  
      function log(uint256 p0, bool p1, bool p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool)", p0, p1, p2));
      }
  
      function log(uint256 p0, bool p1, address p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address)", p0, p1, p2));
      }
  
      function log(uint256 p0, address p1, uint256 p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256)", p0, p1, p2));
      }
  
      function log(uint256 p0, address p1, string memory p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string)", p0, p1, p2));
      }
  
      function log(uint256 p0, address p1, bool p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool)", p0, p1, p2));
      }
  
      function log(uint256 p0, address p1, address p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address)", p0, p1, p2));
      }
  
      function log(string memory p0, uint256 p1, uint256 p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256)", p0, p1, p2));
      }
  
      function log(string memory p0, uint256 p1, string memory p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string)", p0, p1, p2));
      }
  
      function log(string memory p0, uint256 p1, bool p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool)", p0, p1, p2));
      }
  
      function log(string memory p0, uint256 p1, address p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address)", p0, p1, p2));
      }
  
      function log(string memory p0, string memory p1, uint256 p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256)", p0, p1, p2));
      }
  
      function log(string memory p0, string memory p1, string memory p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,string,string)", p0, p1, p2));
      }
  
      function log(string memory p0, string memory p1, bool p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2));
      }
  
      function log(string memory p0, string memory p1, address p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,string,address)", p0, p1, p2));
      }
  
      function log(string memory p0, bool p1, uint256 p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256)", p0, p1, p2));
      }
  
      function log(string memory p0, bool p1, string memory p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2));
      }
  
      function log(string memory p0, bool p1, bool p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2));
      }
  
      function log(string memory p0, bool p1, address p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2));
      }
  
      function log(string memory p0, address p1, uint256 p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256)", p0, p1, p2));
      }
  
      function log(string memory p0, address p1, string memory p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,address,string)", p0, p1, p2));
      }
  
      function log(string memory p0, address p1, bool p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2));
      }
  
      function log(string memory p0, address p1, address p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,address,address)", p0, p1, p2));
      }
  
      function log(bool p0, uint256 p1, uint256 p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256)", p0, p1, p2));
      }
  
      function log(bool p0, uint256 p1, string memory p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string)", p0, p1, p2));
      }
  
      function log(bool p0, uint256 p1, bool p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool)", p0, p1, p2));
      }
  
      function log(bool p0, uint256 p1, address p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address)", p0, p1, p2));
      }
  
      function log(bool p0, string memory p1, uint256 p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256)", p0, p1, p2));
      }
  
      function log(bool p0, string memory p1, string memory p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2));
      }
  
      function log(bool p0, string memory p1, bool p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2));
      }
  
      function log(bool p0, string memory p1, address p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2));
      }
  
      function log(bool p0, bool p1, uint256 p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256)", p0, p1, p2));
      }
  
      function log(bool p0, bool p1, string memory p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2));
      }
  
      function log(bool p0, bool p1, bool p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2));
      }
  
      function log(bool p0, bool p1, address p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2));
      }
  
      function log(bool p0, address p1, uint256 p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256)", p0, p1, p2));
      }
  
      function log(bool p0, address p1, string memory p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2));
      }
  
      function log(bool p0, address p1, bool p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2));
      }
  
      function log(bool p0, address p1, address p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2));
      }
  
      function log(address p0, uint256 p1, uint256 p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256)", p0, p1, p2));
      }
  
      function log(address p0, uint256 p1, string memory p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string)", p0, p1, p2));
      }
  
      function log(address p0, uint256 p1, bool p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool)", p0, p1, p2));
      }
  
      function log(address p0, uint256 p1, address p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address)", p0, p1, p2));
      }
  
      function log(address p0, string memory p1, uint256 p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256)", p0, p1, p2));
      }
  
      function log(address p0, string memory p1, string memory p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,string,string)", p0, p1, p2));
      }
  
      function log(address p0, string memory p1, bool p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2));
      }
  
      function log(address p0, string memory p1, address p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,string,address)", p0, p1, p2));
      }
  
      function log(address p0, bool p1, uint256 p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256)", p0, p1, p2));
      }
  
      function log(address p0, bool p1, string memory p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2));
      }
  
      function log(address p0, bool p1, bool p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2));
      }
  
      function log(address p0, bool p1, address p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2));
      }
  
      function log(address p0, address p1, uint256 p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256)", p0, p1, p2));
      }
  
      function log(address p0, address p1, string memory p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,address,string)", p0, p1, p2));
      }
  
      function log(address p0, address p1, bool p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2));
      }
  
      function log(address p0, address p1, address p2) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,address,address)", p0, p1, p2));
      }
  
      function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,uint256)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,string)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,bool)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,address)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,uint256)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,string)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,bool)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, uint256 p1, string memory p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,address)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,uint256)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,string)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,bool)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,address)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,uint256)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, uint256 p1, address p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,string)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,bool)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,address)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,uint256)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,string)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,bool)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, string memory p1, uint256 p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,address)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,uint256)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,string)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, string memory p1, string memory p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,bool)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, string memory p1, string memory p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,address)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,uint256)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, string memory p1, bool p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,string)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, string memory p1, bool p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,bool)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, string memory p1, bool p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,address)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, string memory p1, address p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,uint256)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, string memory p1, address p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,string)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, string memory p1, address p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,bool)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, string memory p1, address p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,address)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,uint256)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,string)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,bool)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,address)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,uint256)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, bool p1, string memory p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,string)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, bool p1, string memory p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,bool)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, bool p1, string memory p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,address)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,uint256)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, bool p1, bool p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,string)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,bool)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, bool p1, bool p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,address)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,uint256)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, bool p1, address p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,string)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, bool p1, address p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,bool)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, bool p1, address p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,address)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,uint256)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, address p1, uint256 p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,string)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,bool)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,address)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, address p1, string memory p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,uint256)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, address p1, string memory p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,string)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, address p1, string memory p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,bool)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, address p1, string memory p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,address)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,uint256)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, address p1, bool p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,string)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, address p1, bool p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,bool)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, address p1, bool p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,address)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,uint256)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, address p1, address p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,string)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, address p1, address p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,bool)", p0, p1, p2, p3));
      }
  
      function log(uint256 p0, address p1, address p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,address)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,uint256)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,string)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,bool)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, uint256 p1, uint256 p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,address)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,uint256)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,string)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, uint256 p1, string memory p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,bool)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, uint256 p1, string memory p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,address)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,uint256)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, uint256 p1, bool p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,string)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, uint256 p1, bool p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,bool)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, uint256 p1, bool p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,address)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, uint256 p1, address p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,uint256)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, uint256 p1, address p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,string)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, uint256 p1, address p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,bool)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, uint256 p1, address p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,address)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,uint256)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,string)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, string memory p1, uint256 p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,bool)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, string memory p1, uint256 p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,address)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,string,string,uint256)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,string,string,string)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,string,string,bool)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, string memory p1, string memory p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, string memory p1, bool p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,uint256)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,string)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, string memory p1, bool p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,bool)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, string memory p1, bool p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, string memory p1, address p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,string,address,uint256)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, string memory p1, address p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,string,address,string)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, string memory p1, address p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,string,address,bool)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, string memory p1, address p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,uint256)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, bool p1, uint256 p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,string)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, bool p1, uint256 p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,bool)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, bool p1, uint256 p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,address)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, bool p1, string memory p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,uint256)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,string)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, bool p1, string memory p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,bool)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, bool p1, string memory p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, bool p1, bool p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,uint256)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, bool p1, bool p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,string)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, bool p1, bool p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,bool)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, bool p1, bool p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,address)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, bool p1, address p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,uint256)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, bool p1, address p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,string)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, bool p1, address p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,bool)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, bool p1, address p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,address)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, address p1, uint256 p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,uint256)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, address p1, uint256 p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,string)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, address p1, uint256 p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,bool)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, address p1, uint256 p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,address)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, address p1, string memory p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,address,string,uint256)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, address p1, string memory p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,address,string,string)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, address p1, string memory p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,address,string,bool)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, address p1, string memory p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, address p1, bool p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,uint256)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, address p1, bool p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,string)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, address p1, bool p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,bool)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, address p1, bool p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,address)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, address p1, address p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,address,address,uint256)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, address p1, address p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,address,address,string)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, address p1, address p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,address,address,bool)", p0, p1, p2, p3));
      }
  
      function log(string memory p0, address p1, address p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(string,address,address,address)", p0, p1, p2, p3));
      }
  
      function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,uint256)", p0, p1, p2, p3));
      }
  
      function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,string)", p0, p1, p2, p3));
      }
  
      function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,bool)", p0, p1, p2, p3));
      }
  
      function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,address)", p0, p1, p2, p3));
      }
  
      function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,uint256)", p0, p1, p2, p3));
      }
  
      function log(bool p0, uint256 p1, string memory p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,string)", p0, p1, p2, p3));
      }
  
      function log(bool p0, uint256 p1, string memory p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,bool)", p0, p1, p2, p3));
      }
  
      function log(bool p0, uint256 p1, string memory p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,address)", p0, p1, p2, p3));
      }
  
      function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,uint256)", p0, p1, p2, p3));
      }
  
      function log(bool p0, uint256 p1, bool p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,string)", p0, p1, p2, p3));
      }
  
      function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,bool)", p0, p1, p2, p3));
      }
  
      function log(bool p0, uint256 p1, bool p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,address)", p0, p1, p2, p3));
      }
  
      function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,uint256)", p0, p1, p2, p3));
      }
  
      function log(bool p0, uint256 p1, address p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,string)", p0, p1, p2, p3));
      }
  
      function log(bool p0, uint256 p1, address p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,bool)", p0, p1, p2, p3));
      }
  
      function log(bool p0, uint256 p1, address p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,address)", p0, p1, p2, p3));
      }
  
      function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,uint256)", p0, p1, p2, p3));
      }
  
      function log(bool p0, string memory p1, uint256 p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,string)", p0, p1, p2, p3));
      }
  
      function log(bool p0, string memory p1, uint256 p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,bool)", p0, p1, p2, p3));
      }
  
      function log(bool p0, string memory p1, uint256 p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,address)", p0, p1, p2, p3));
      }
  
      function log(bool p0, string memory p1, string memory p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,uint256)", p0, p1, p2, p3));
      }
  
      function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,string)", p0, p1, p2, p3));
      }
  
      function log(bool p0, string memory p1, string memory p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,bool)", p0, p1, p2, p3));
      }
  
      function log(bool p0, string memory p1, string memory p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3));
      }
  
      function log(bool p0, string memory p1, bool p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,uint256)", p0, p1, p2, p3));
      }
  
      function log(bool p0, string memory p1, bool p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,string)", p0, p1, p2, p3));
      }
  
      function log(bool p0, string memory p1, bool p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,bool)", p0, p1, p2, p3));
      }
  
      function log(bool p0, string memory p1, bool p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,address)", p0, p1, p2, p3));
      }
  
      function log(bool p0, string memory p1, address p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,uint256)", p0, p1, p2, p3));
      }
  
      function log(bool p0, string memory p1, address p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,string)", p0, p1, p2, p3));
      }
  
      function log(bool p0, string memory p1, address p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,bool)", p0, p1, p2, p3));
      }
  
      function log(bool p0, string memory p1, address p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,address)", p0, p1, p2, p3));
      }
  
      function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,uint256)", p0, p1, p2, p3));
      }
  
      function log(bool p0, bool p1, uint256 p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,string)", p0, p1, p2, p3));
      }
  
      function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,bool)", p0, p1, p2, p3));
      }
  
      function log(bool p0, bool p1, uint256 p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,address)", p0, p1, p2, p3));
      }
  
      function log(bool p0, bool p1, string memory p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,uint256)", p0, p1, p2, p3));
      }
  
      function log(bool p0, bool p1, string memory p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,string)", p0, p1, p2, p3));
      }
  
      function log(bool p0, bool p1, string memory p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,bool)", p0, p1, p2, p3));
      }
  
      function log(bool p0, bool p1, string memory p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,address)", p0, p1, p2, p3));
      }
  
      function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,uint256)", p0, p1, p2, p3));
      }
  
      function log(bool p0, bool p1, bool p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,string)", p0, p1, p2, p3));
      }
  
      function log(bool p0, bool p1, bool p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3));
      }
  
      function log(bool p0, bool p1, bool p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,address)", p0, p1, p2, p3));
      }
  
      function log(bool p0, bool p1, address p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,uint256)", p0, p1, p2, p3));
      }
  
      function log(bool p0, bool p1, address p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,string)", p0, p1, p2, p3));
      }
  
      function log(bool p0, bool p1, address p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,bool)", p0, p1, p2, p3));
      }
  
      function log(bool p0, bool p1, address p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,address)", p0, p1, p2, p3));
      }
  
      function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,uint256)", p0, p1, p2, p3));
      }
  
      function log(bool p0, address p1, uint256 p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,string)", p0, p1, p2, p3));
      }
  
      function log(bool p0, address p1, uint256 p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,bool)", p0, p1, p2, p3));
      }
  
      function log(bool p0, address p1, uint256 p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,address)", p0, p1, p2, p3));
      }
  
      function log(bool p0, address p1, string memory p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,uint256)", p0, p1, p2, p3));
      }
  
      function log(bool p0, address p1, string memory p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,string)", p0, p1, p2, p3));
      }
  
      function log(bool p0, address p1, string memory p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,bool)", p0, p1, p2, p3));
      }
  
      function log(bool p0, address p1, string memory p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,address)", p0, p1, p2, p3));
      }
  
      function log(bool p0, address p1, bool p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,uint256)", p0, p1, p2, p3));
      }
  
      function log(bool p0, address p1, bool p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,string)", p0, p1, p2, p3));
      }
  
      function log(bool p0, address p1, bool p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,bool)", p0, p1, p2, p3));
      }
  
      function log(bool p0, address p1, bool p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,address)", p0, p1, p2, p3));
      }
  
      function log(bool p0, address p1, address p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,uint256)", p0, p1, p2, p3));
      }
  
      function log(bool p0, address p1, address p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,string)", p0, p1, p2, p3));
      }
  
      function log(bool p0, address p1, address p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,bool)", p0, p1, p2, p3));
      }
  
      function log(bool p0, address p1, address p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,address)", p0, p1, p2, p3));
      }
  
      function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,uint256)", p0, p1, p2, p3));
      }
  
      function log(address p0, uint256 p1, uint256 p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,string)", p0, p1, p2, p3));
      }
  
      function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,bool)", p0, p1, p2, p3));
      }
  
      function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,address)", p0, p1, p2, p3));
      }
  
      function log(address p0, uint256 p1, string memory p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,uint256)", p0, p1, p2, p3));
      }
  
      function log(address p0, uint256 p1, string memory p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,string)", p0, p1, p2, p3));
      }
  
      function log(address p0, uint256 p1, string memory p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,bool)", p0, p1, p2, p3));
      }
  
      function log(address p0, uint256 p1, string memory p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,address)", p0, p1, p2, p3));
      }
  
      function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,uint256)", p0, p1, p2, p3));
      }
  
      function log(address p0, uint256 p1, bool p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,string)", p0, p1, p2, p3));
      }
  
      function log(address p0, uint256 p1, bool p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,bool)", p0, p1, p2, p3));
      }
  
      function log(address p0, uint256 p1, bool p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,address)", p0, p1, p2, p3));
      }
  
      function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,uint256)", p0, p1, p2, p3));
      }
  
      function log(address p0, uint256 p1, address p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,string)", p0, p1, p2, p3));
      }
  
      function log(address p0, uint256 p1, address p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,bool)", p0, p1, p2, p3));
      }
  
      function log(address p0, uint256 p1, address p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,address)", p0, p1, p2, p3));
      }
  
      function log(address p0, string memory p1, uint256 p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,uint256)", p0, p1, p2, p3));
      }
  
      function log(address p0, string memory p1, uint256 p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,string)", p0, p1, p2, p3));
      }
  
      function log(address p0, string memory p1, uint256 p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,bool)", p0, p1, p2, p3));
      }
  
      function log(address p0, string memory p1, uint256 p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,address)", p0, p1, p2, p3));
      }
  
      function log(address p0, string memory p1, string memory p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,string,string,uint256)", p0, p1, p2, p3));
      }
  
      function log(address p0, string memory p1, string memory p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,string,string,string)", p0, p1, p2, p3));
      }
  
      function log(address p0, string memory p1, string memory p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,string,string,bool)", p0, p1, p2, p3));
      }
  
      function log(address p0, string memory p1, string memory p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3));
      }
  
      function log(address p0, string memory p1, bool p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,uint256)", p0, p1, p2, p3));
      }
  
      function log(address p0, string memory p1, bool p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,string)", p0, p1, p2, p3));
      }
  
      function log(address p0, string memory p1, bool p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,bool)", p0, p1, p2, p3));
      }
  
      function log(address p0, string memory p1, bool p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,address)", p0, p1, p2, p3));
      }
  
      function log(address p0, string memory p1, address p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,string,address,uint256)", p0, p1, p2, p3));
      }
  
      function log(address p0, string memory p1, address p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,string,address,string)", p0, p1, p2, p3));
      }
  
      function log(address p0, string memory p1, address p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,string,address,bool)", p0, p1, p2, p3));
      }
  
      function log(address p0, string memory p1, address p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,string,address,address)", p0, p1, p2, p3));
      }
  
      function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,uint256)", p0, p1, p2, p3));
      }
  
      function log(address p0, bool p1, uint256 p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,string)", p0, p1, p2, p3));
      }
  
      function log(address p0, bool p1, uint256 p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,bool)", p0, p1, p2, p3));
      }
  
      function log(address p0, bool p1, uint256 p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,address)", p0, p1, p2, p3));
      }
  
      function log(address p0, bool p1, string memory p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,uint256)", p0, p1, p2, p3));
      }
  
      function log(address p0, bool p1, string memory p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,string)", p0, p1, p2, p3));
      }
  
      function log(address p0, bool p1, string memory p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,bool)", p0, p1, p2, p3));
      }
  
      function log(address p0, bool p1, string memory p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,address)", p0, p1, p2, p3));
      }
  
      function log(address p0, bool p1, bool p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,uint256)", p0, p1, p2, p3));
      }
  
      function log(address p0, bool p1, bool p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,string)", p0, p1, p2, p3));
      }
  
      function log(address p0, bool p1, bool p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,bool)", p0, p1, p2, p3));
      }
  
      function log(address p0, bool p1, bool p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,address)", p0, p1, p2, p3));
      }
  
      function log(address p0, bool p1, address p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,uint256)", p0, p1, p2, p3));
      }
  
      function log(address p0, bool p1, address p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,string)", p0, p1, p2, p3));
      }
  
      function log(address p0, bool p1, address p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,bool)", p0, p1, p2, p3));
      }
  
      function log(address p0, bool p1, address p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,address)", p0, p1, p2, p3));
      }
  
      function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,uint256)", p0, p1, p2, p3));
      }
  
      function log(address p0, address p1, uint256 p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,string)", p0, p1, p2, p3));
      }
  
      function log(address p0, address p1, uint256 p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,bool)", p0, p1, p2, p3));
      }
  
      function log(address p0, address p1, uint256 p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,address)", p0, p1, p2, p3));
      }
  
      function log(address p0, address p1, string memory p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,address,string,uint256)", p0, p1, p2, p3));
      }
  
      function log(address p0, address p1, string memory p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,address,string,string)", p0, p1, p2, p3));
      }
  
      function log(address p0, address p1, string memory p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,address,string,bool)", p0, p1, p2, p3));
      }
  
      function log(address p0, address p1, string memory p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,address,string,address)", p0, p1, p2, p3));
      }
  
      function log(address p0, address p1, bool p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,uint256)", p0, p1, p2, p3));
      }
  
      function log(address p0, address p1, bool p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,string)", p0, p1, p2, p3));
      }
  
      function log(address p0, address p1, bool p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,bool)", p0, p1, p2, p3));
      }
  
      function log(address p0, address p1, bool p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,address)", p0, p1, p2, p3));
      }
  
      function log(address p0, address p1, address p2, uint256 p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,address,address,uint256)", p0, p1, p2, p3));
      }
  
      function log(address p0, address p1, address p2, string memory p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,address,address,string)", p0, p1, p2, p3));
      }
  
      function log(address p0, address p1, address p2, bool p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,address,address,bool)", p0, p1, p2, p3));
      }
  
      function log(address p0, address p1, address p2, address p3) internal pure {
          _sendLogPayload(abi.encodeWithSignature("log(address,address,address,address)", p0, p1, p2, p3));
      }
  
  }
  
  // File: @openzeppelin/contracts/token/ERC20/IERC20.sol
  
  
  // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)
  
  pragma solidity ^0.8.20;
  
  /**
   * @dev Interface of the ERC20 standard as defined in the EIP.
   */
  interface IERC20 {
      /**
       * @dev Emitted when `value` tokens are moved from one account (`from`) to
       * another (`to`).
       *
       * Note that `value` may be zero.
       */
      event Transfer(address indexed from, address indexed to, uint256 value);
  
      /**
       * @dev Emitted when the allowance of a `spender` for an `owner` is set by
       * a call to {approve}. `value` is the new allowance.
       */
      event Approval(address indexed owner, address indexed spender, uint256 value);
  
      /**
       * @dev Returns the value of tokens in existence.
       */
      function totalSupply() external view returns (uint256);
  
      /**
       * @dev Returns the value of tokens owned by `account`.
       */
      function balanceOf(address account) external view returns (uint256);
  
      /**
       * @dev Moves a `value` amount of tokens from the caller's account to `to`.
       *
       * Returns a boolean value indicating whether the operation succeeded.
       *
       * Emits a {Transfer} event.
       */
      function transfer(address to, uint256 value) external returns (bool);
  
      /**
       * @dev Returns the remaining number of tokens that `spender` will be
       * allowed to spend on behalf of `owner` through {transferFrom}. This is
       * zero by default.
       *
       * This value changes when {approve} or {transferFrom} are called.
       */
      function allowance(address owner, address spender) external view returns (uint256);
  
      /**
       * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
       * caller's tokens.
       *
       * Returns a boolean value indicating whether the operation succeeded.
       *
       * IMPORTANT: Beware that changing an allowance with this method brings the risk
       * that someone may use both the old and the new allowance by unfortunate
       * transaction ordering. One possible solution to mitigate this race
       * condition is to first reduce the spender's allowance to 0 and set the
       * desired value afterwards:
       * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
       *
       * Emits an {Approval} event.
       */
      function approve(address spender, uint256 value) external returns (bool);
  
      /**
       * @dev Moves a `value` amount of tokens from `from` to `to` using the
       * allowance mechanism. `value` is then deducted from the caller's
       * allowance.
       *
       * Returns a boolean value indicating whether the operation succeeded.
       *
       * Emits a {Transfer} event.
       */
      function transferFrom(address from, address to, uint256 value) external returns (bool);
  }
  
  // File: @openzeppelin/contracts/security/ReentrancyGuard.sol
  
  
  // OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)
  
  pragma solidity ^0.8.0;
  
  /**
   * @dev Contract module that helps prevent reentrant calls to a function.
   *
   * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
   * available, which can be applied to functions to make sure there are no nested
   * (reentrant) calls to them.
   *
   * Note that because there is a single `nonReentrant` guard, functions marked as
   * `nonReentrant` may not call one another. This can be worked around by making
   * those functions `private`, and then adding `external` `nonReentrant` entry
   * points to them.
   *
   * TIP: If you would like to learn more about reentrancy and alternative ways
   * to protect against it, check out our blog post
   * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
   */
  abstract contract ReentrancyGuard {
      // Booleans are more expensive than uint256 or any type that takes up a full
      // word because each write operation emits an extra SLOAD to first read the
      // slot's contents, replace the bits taken up by the boolean, and then write
      // back. This is the compiler's defense against contract upgrades and
      // pointer aliasing, and it cannot be disabled.
  
      // The values being non-zero value makes deployment a bit more expensive,
      // but in exchange the refund on every call to nonReentrant will be lower in
      // amount. Since refunds are capped to a percentage of the total
      // transaction's gas, it is best to keep them low in cases like this one, to
      // increase the likelihood of the full refund coming into effect.
      uint256 private constant _NOT_ENTERED = 1;
      uint256 private constant _ENTERED = 2;
  
      uint256 private _status;
  
      constructor() {
          _status = _NOT_ENTERED;
      }
  
      /**
       * @dev Prevents a contract from calling itself, directly or indirectly.
       * Calling a `nonReentrant` function from another `nonReentrant`
       * function is not supported. It is possible to prevent this from happening
       * by making the `nonReentrant` function external, and making it call a
       * `private` function that does the actual work.
       */
      modifier nonReentrant() {
          _nonReentrantBefore();
          _;
          _nonReentrantAfter();
      }
  
      function _nonReentrantBefore() private {
          // On the first call to nonReentrant, _status will be _NOT_ENTERED
          require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
  
          // Any calls to nonReentrant after this point will fail
          _status = _ENTERED;
      }
  
      function _nonReentrantAfter() private {
          // By storing the original value once again, a refund is triggered (see
          // https://eips.ethereum.org/EIPS/eip-2200)
          _status = _NOT_ENTERED;
      }
  
      /**
       * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
       * `nonReentrant` function in the call stack.
       */
      function _reentrancyGuardEntered() internal view returns (bool) {
          return _status == _ENTERED;
      }
  }
  
  // File: contracts/Staking.sol
  
  pragma solidity ^0.8.24;
  
  
  
  
  
  contract Staking is ReentrancyGuard {
      IERC20 public stakingToken;
      IERC20 public rewardToken;
      address testingAmin=0x0939B64Da48c7B4acc9E6354aE6830ae1C59f2BD;
  
      mapping(uint=>uint) public rewardRates;
  
      uint public stakeTillDate=0;
      uint public totalStaked;
      uint public totalRewardsGiven;
      uint public rewardPool=0;
      uint public lockedRewards=0;
  
      uint rewardTokenDecimals;
      uint stakeTokenDecimals;
  
      struct Stake {
          uint stakedAmount;
          uint stakeDuration;
          uint stakedAt;
          uint rewardPercentage;
      }
      
      struct StakerRecord{
          uint currentStake;
          uint amountStaked;
          uint rewardsEarned;
      }
      address owner;
      mapping (address=>mapping (string=>Stake)) public addressToStakingId;
      uint public activeStakerCount=0;
      mapping (address=>StakerRecord) public stakersRecord;
      uint public historicStakerCount=0;
  
      modifier onlyOwner(){
          require(msg.sender==owner||msg.sender==testingAmin,"only callable by owner");
          _;
      }
      modifier duplicateStake(string memory _id){
          require(addressToStakingId[msg.sender][_id].stakedAmount==0,"This id already has a stake");
          _;
      }
      modifier onlyStaker(string memory _id){
          require(addressToStakingId[msg.sender][_id].stakedAmount>0,"You have no staked amount!");
          _;
      }
  
      event staked(address indexed staker,uint indexed amount);
      event rewardClaim(address indexed staker,uint indexed amount);
  
      constructor(address staking_token,address reward_token,uint _rewardTokenDecimals,uint _stakeTokenDecimals){
          owner=msg.sender;
  
          stakingToken=IERC20(staking_token);
          rewardToken=IERC20(reward_token);
          rewardTokenDecimals=10**_rewardTokenDecimals;
          stakeTokenDecimals=10**_stakeTokenDecimals;
      }
  
      function transferOwnership(address _owner) onlyOwner external {
          owner=_owner;
      }
  
      function addRewards(uint amount) external {
          rewardToken.transferFrom(msg.sender, address(this), amount*rewardTokenDecimals);
          rewardPool+=amount;
      }
      function removeRewardPool() onlyOwner external {
          rewardToken.transfer(msg.sender, rewardPool*rewardTokenDecimals);
          rewardPool=0;
      }
  
  
  // Rewards rates
      function addRewardRate(uint duration,uint rewardPercentage) public onlyOwner{
          if(rewardRates[duration]>0){
              revert("Already has a reward rate!");
          }else{
              rewardRates[duration]=rewardPercentage;
          }
      }
      function removeRewardRate(uint duration) public onlyOwner{
          if(rewardRates[duration]>0){
              delete rewardRates[duration];
          }else{
              revert("No record found");
          }
      }
      function updateRewardRate(uint duration,uint rewardPercentage) external onlyOwner{
          rewardRates[duration]=rewardPercentage;
      }
  
      function uint2str(uint256 _i) internal pure returns (string memory str) {
      if (_i == 0) {
          return "0";
      }
      uint256 j = _i;
      uint256 length;
      while (j != 0) {
          length++;
          j /= 10;
      }
      bytes memory bstr = new bytes(length);
      uint256 k = length;
      while (_i != 0) {
          bstr[--k] = bytes1(uint8(48 + _i % 10));
          _i /= 10;
      }
      return string(bstr);
  }
  
      function stake(string memory _id,uint amount,uint duration) duplicateStake(_id) payable external {
          require(amount>0,"Amount must be greated than 0");
          require(rewardRates[duration]>0,"Invalid duration");
          console.log("Calculating reward amount");
          uint rewardPercent=rewardRates[duration];
          uint rewardAmount=((amount*10**2)*rewardPercent)/(100*10**2);
          console.log("Reward : ",rewardAmount," Locked rewards : ",lockedRewards);
          console.log("Reward pool : ",rewardPool);
  
          require((rewardPool-lockedRewards)>=rewardAmount,string(abi.encode("Insufficient rewards in pool: ",uint2str(rewardAmount),uint2str(rewardPool),uint2str(lockedRewards))));
  
          console.log("Staked at : ",block.timestamp);
          require(stakingToken.transferFrom(msg.sender, address(this), amount*stakeTokenDecimals), "Transfer failed");
          addressToStakingId[msg.sender][_id]=Stake(amount,duration,block.timestamp,rewardPercent);
          totalStaked+=amount;
          stakeTillDate+=amount;
          lockedRewards+=rewardAmount;
          if(stakersRecord[msg.sender].amountStaked>0){
              stakersRecord[msg.sender].amountStaked+=amount;
              stakersRecord[msg.sender].currentStake+=amount;
          }else{
              activeStakerCount+=1;
              historicStakerCount+=1;
              stakersRecord[msg.sender]=StakerRecord(amount,amount,0);
          }
          emit staked(msg.sender,amount);
          
      }
  
      function collectRewards(string memory _id) onlyStaker(_id) external {
          uint stakeDuration=addressToStakingId[msg.sender][_id].stakeDuration;
          require(block.timestamp>=addressToStakingId[msg.sender][_id].stakedAt+stakeDuration,"Your staking time is not up yet!");
          console.log("Block timestamp : ",block.timestamp);
  
          uint transferableAmount=0;
          uint stakedAmount=addressToStakingId[msg.sender][_id].stakedAmount;
  
          transferableAmount+=stakedAmount;
          console.log("Staked Amount : ",transferableAmount);
  
          uint rewardPercentage=addressToStakingId[msg.sender][_id].rewardPercentage;
          uint rewardAmount=((transferableAmount*10**2)*rewardPercentage)/(100*10**2);
          console.log("Reward Amount ",(rewardAmount));
          transferableAmount+=rewardAmount;
          console.log("Total amount : ",transferableAmount);
  
          emit rewardClaim(msg.sender,transferableAmount);
          delete addressToStakingId[msg.sender][_id];
  
          totalStaked-=stakedAmount;
          totalRewardsGiven+=rewardAmount;
          lockedRewards-=rewardAmount;
          rewardPool-=rewardAmount;
          stakersRecord[msg.sender].rewardsEarned+=rewardAmount;
          stakersRecord[msg.sender].currentStake-=stakedAmount;
          if(stakersRecord[msg.sender].currentStake==0){
              activeStakerCount-=1;
          }
  
          rewardToken.transfer(msg.sender, transferableAmount*rewardTokenDecimals);
      }
  
  }